Add an API to get an SBBreakpoint's owning SBTarget

[jingham]

Summary

Scripted breakpoint resolvers receive the breakpoint they are being set on, and the callback takes an SBSymbolContext.

Sometimes (for instance if you want to disassemble instructions) you need access to the target that owns the breakpoint. We don't include the owning target in an SBSymbolContext, which mirrors the fact that SBModules aren't owned by a single target, but live in the shared cache and might have many SBTarget owners. So you can't get it from there.

However, an SBBreakpoint is always owned by one target, so it makes sense to be able to get an SBBreakpoint's SBTarget.

[jingham]

Use lldb-instr instead of hand-generating the reproducer wrappers.

lldb/bindings/interface/SBBreakpoint.i

public:
     bool
     IsValid() const;
 
     explicit operator bool() const;
 
     void
     ClearAllBreakpointSites ();
 
+    lldb::SBTarget
+    GetTarget() const;
+  
     lldb::SBBreakpointLocation
     FindLocationByAddress (lldb::addr_t vm_addr);
 
     lldb::break_id_t
     FindLocationIDByAddress (lldb::addr_t vm_addr);
 
     lldb::SBBreakpointLocation
     FindLocationByID (lldb::break_id_t bp_loc_id);

lldb/include/lldb/API/SBBreakpoint.h

 //===-- SBBreakpoint.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_SBBREAKPOINT_H
 #define LLDB_API_SBBREAKPOINT_H
 
 #include "lldb/API/SBDefines.h"
 
 class SBBreakpointListImpl;
 
 namespace lldb {
 
 class LLDB_API SBBreakpoint {
 public:
 
public:
   break_id_t GetID() const;
 
   explicit operator bool() const;
 
   bool IsValid() const;
 
   void ClearAllBreakpointSites();
 
+  lldb::SBTarget GetTarget() const;
+
   lldb::SBBreakpointLocation FindLocationByAddress(lldb::addr_t vm_addr);
 
   lldb::break_id_t FindLocationIDByAddress(lldb::addr_t vm_addr);
 
   lldb::SBBreakpointLocation FindLocationByID(lldb::break_id_t bp_loc_id);
 
   lldb::SBBreakpointLocation GetLocationAtIndex(uint32_t index);
 

lldb/source/API/SBBreakpoint.cpp

 //===-- SBBreakpoint.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/SBBreakpoint.h"
 #include "SBReproducerPrivate.h"
 #include "lldb/API/SBBreakpointLocation.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStringList.h"
 #include "lldb/API/SBStructuredData.h"

 
 bool SBBreakpoint::operator!=(const lldb::SBBreakpoint &rhs) {
   LLDB_RECORD_METHOD(
       bool, SBBreakpoint, operator!=,(const lldb::SBBreakpoint &), rhs);
 
   return m_opaque_wp.lock() != rhs.m_opaque_wp.lock();
 }
 
+SBTarget SBBreakpoint::GetTarget() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBTarget, SBBreakpoint, GetTarget);
+
+  BreakpointSP bkpt_sp = GetSP();
+  if (bkpt_sp)
+    return LLDB_RECORD_RESULT(SBTarget(bkpt_sp->GetTargetSP()));
+
+  return LLDB_RECORD_RESULT(SBTarget());
+}
+
 break_id_t SBBreakpoint::GetID() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::break_id_t, SBBreakpoint, GetID);
 
   break_id_t break_id = LLDB_INVALID_BREAK_ID;
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp)
     break_id = bkpt_sp->GetID();
 
void RegisterMethods<SBBreakpoint>(Registry &R) {
   LLDB_REGISTER_CONSTRUCTOR(SBBreakpoint, (const lldb::SBBreakpoint &));
   LLDB_REGISTER_CONSTRUCTOR(SBBreakpoint, (const lldb::BreakpointSP &));
   LLDB_REGISTER_METHOD(const lldb::SBBreakpoint &,
                        SBBreakpoint, operator=,(const lldb::SBBreakpoint &));
   LLDB_REGISTER_METHOD(bool,
                        SBBreakpoint, operator==,(const lldb::SBBreakpoint &));
   LLDB_REGISTER_METHOD(bool,
                        SBBreakpoint, operator!=,(const lldb::SBBreakpoint &));
+  LLDB_REGISTER_METHOD_CONST(lldb::SBTarget, SBBreakpoint, GetTarget, ());
   LLDB_REGISTER_METHOD_CONST(lldb::break_id_t, SBBreakpoint, GetID, ());
   LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, IsValid, ());
   LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, operator bool, ());
   LLDB_REGISTER_METHOD(void, SBBreakpoint, ClearAllBreakpointSites, ());
   LLDB_REGISTER_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
                        FindLocationByAddress, (lldb::addr_t));
   LLDB_REGISTER_METHOD(lldb::break_id_t, SBBreakpoint,
                        FindLocationIDByAddress, (lldb::addr_t));

lldb/test/API/python_api/breakpoint/TestBreakpointAPI.py

def test_target_delete(self):
         breakpoint = target.BreakpointCreateByName('AFunction', 'a.out')
         self.trace("breakpoint:", breakpoint)
         self.assertTrue(breakpoint and
                         breakpoint.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
         location = breakpoint.GetLocationAtIndex(0)
         self.assertTrue(location.IsValid())
 
+        # Make sure the breakpoint's target is right:
+        self.assertEqual(target, breakpoint.GetTarget(), "Breakpoint reports its target correctly")
+        
         self.assertTrue(self.dbg.DeleteTarget(target))
         self.assertFalse(breakpoint.IsValid())
         self.assertFalse(location.IsValid())