Clear expression when breakpoint location becomes unresolved

[labath]

Summary

The compiled expression is not needed once the location goes away. Also,
it holds a reference to the module, which prevents cleanup of the module
if somebody holds a reference to the breakpoint object.

This fixes the StepOverBreakpoint test on windows, but I am unsure how
to make a more generic test for this.

[labath]

Note that the breakpoint location's site gets cleared when you disable the breakpoint or its location, as well as when you delete it. So if you have a workflow that does: "hit a breakpoint, disable it, hit another, reenable the first, hit the second" you'll end up re-evaluating the condition expression unnecessarily. This isn't a terribly common workflow, and compiling the expression is not hugely expensive. But in this instance, it was probably better to break the link at the SBBreakpoint level, and not here.

Sorry, I thought I understood Greg wanted me to do this. I can certainly do the SBBreakpoint thing instead.

[labath]

No worries. I'll come back soon with the weak_ptr thingy.

[jingham]

Sorry, I sent a reply but did it by replying to the e-mail version of the patch, and the mail server choked on it for reasons that aren't clear to me...

Greg was most likely thinking that BreakpointLocation had a "Clear" method like the Target and Process, which we can call when WE know we're done with something, but we can't tell when it will actually get destroyed. BreakpointLocation hasn't needed such a thing. In fact, if you wanted to fix this by adding a Clear method and removing the expression there, that would be fine too. In the process & target case we have to know that we've cleared them, but since you're only throwing away a cache, you wouldn't need to do any extra work for BreakpointLocations.

However, solving the reference loop with a weak pointer in SBBreakpoint is fine as well. The targets keep the breakpoints alive as long as the target exists, and about the only sensible thing you can do with a breakpoint after it's target is gone, is print it's ID in an error "Hey, I tried to do something with breakpoint 1 but it didn't work because it's target was gone". Now you will either have to keep that info redundantly on the side or say <UNKNOWN> rather than "1".

That doesn't seems worth keeping the breakpoint alive.

[labath]

Switch SBBreakpoint to weak_ptr. This diff is pretty big but it amounts to
s/m_opaque_sp/m_opaque_wp and inserting a lock at the beginning of every
function. Since I had to touch them anyway, I took the opportunity to upgrade
the logging statements.

If this is ok, I'll follow this up with the same change for SBBreakpointLocation
and SBWatchpoint.

[jingham]

This looks fine.

It reads a little odd to me that the BreakpointSP recipient of GetSP is generally called opaque_sp after the patch. Historically it makes sense because it was the result of the substitution m_opaque_sp -> opaque_sp. But if you didn't know that it might seem odd, since there's nothing opaque about it. Something like "bkpt_sp" would read more naturally. OTOH is does make the patch larger, so I don't feel very strongly about it.

[labath]

I like bkpt_sp. I will rename it before submission. It does not make the diff any larger as I have had to rename all occurrences of it anyway.

lldb/trunk/include/lldb/API/SBBreakpoint.h

 
 private:
   friend class SBBreakpointList;
   friend class SBBreakpointLocation;
   friend class SBTarget;
 
   SBBreakpoint(const lldb::BreakpointSP &bp_sp);
 
-  lldb_private::Breakpoint *operator->() const;
-
-  lldb_private::Breakpoint *get() const;
-
-  lldb::BreakpointSP &operator*();
-
-  const lldb::BreakpointSP &operator*() const;
-
   static bool PrivateBreakpointHitCallback(
       void *baton, lldb_private::StoppointCallbackContext *context,
       lldb::user_id_t break_id, lldb::user_id_t break_loc_id);
 
-  lldb::BreakpointSP m_opaque_sp;
+  lldb::BreakpointSP GetSP() const;
+
+  lldb::BreakpointWP m_opaque_wp;
 };
 
 class LLDB_API SBBreakpointList {
 public:
   SBBreakpointList(SBTarget &target);
 
   ~SBBreakpointList();
 

lldb/trunk/packages/Python/lldbsuite/test/functionalities/breakpoint/step_over_breakpoint/TestStepOverBreakpoint.py

def setUp(self):
 
         # Start debugging
         self.process = self.target.LaunchSimple(
             None, None, self.get_process_working_directory())
         self.assertIsNotNone(self.process, PROCESS_IS_VALID)
         self.thread = lldbutil.get_one_thread_stopped_at_breakpoint(self.process, self.breakpoint1)
         self.assertIsNotNone(self.thread, "Didn't stop at breakpoint 1.")
 
-    @skipIf(bugnumber="llvm.org/pr31972", hostoslist=["windows"])
     def test_step_instruction(self): 
         # Count instructions between breakpoint_1 and breakpoint_4
         contextList = self.target.FindFunctions('main', lldb.eFunctionNameTypeAuto)
         self.assertEquals(contextList.GetSize(), 1)
         symbolContext = contextList.GetContextAtIndex(0)
         function = symbolContext.GetFunction()
         self.assertTrue(function)
         instructions = function.GetInstructions(self.target)

lldb/trunk/packages/Python/lldbsuite/test/python_api/breakpoint/TestBreakpointAPI.py

 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class BreakpointAPITestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     @add_test_categories(['pyapi'])
     def test_breakpoint_is_valid(self):
         """Make sure that if an SBBreakpoint gets deleted its IsValid returns false."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target by the debugger.
def test_breakpoint_is_valid(self):
         # Make sure we can't find it:
         del_bkpt = target.FindBreakpointByID(breakpoint.GetID())
         self.assertTrue(not del_bkpt, "We did delete the breakpoint.")
 
         # Finally make sure the original breakpoint is no longer valid.
         self.assertTrue(
             not breakpoint,
             "Breakpoint we deleted is no longer valid.")
+
+    @add_test_categories(['pyapi'])
+    def test_target_delete(self):
+        """Make sure that if an SBTarget gets deleted the associated
+        Breakpoint's IsValid returns false."""
+
+        self.build()
+        exe = os.path.join(os.getcwd(), "a.out")
+
+        # Create a target by the debugger.
+        target = self.dbg.CreateTarget(exe)
+        self.assertTrue(target, VALID_TARGET)
+
+        # Now create a breakpoint on main.c by name 'AFunction'.
+        breakpoint = target.BreakpointCreateByName('AFunction', 'a.out')
+        #print("breakpoint:", breakpoint)
+        self.assertTrue(breakpoint and
+                        breakpoint.GetNumLocations() == 1,
+                        VALID_BREAKPOINT)
+
+        self.assertTrue(self.dbg.DeleteTarget(target))
+        self.assertFalse(breakpoint.IsValid())

lldb/trunk/source/API/SBBreakpoint.cpp

public:
   SBBreakpointCallbackBaton(SBBreakpoint::BreakpointHitCallback callback,
                             void *baton)
       : TypedBaton(llvm::make_unique<CallbackData>()) {
     getItem()->callback = callback;
     getItem()->callback_baton = baton;
   }
 };
 
-SBBreakpoint::SBBreakpoint() : m_opaque_sp() {}
+SBBreakpoint::SBBreakpoint() {}
 
 SBBreakpoint::SBBreakpoint(const SBBreakpoint &rhs)
-    : m_opaque_sp(rhs.m_opaque_sp) {}
+    : m_opaque_wp(rhs.m_opaque_wp) {}
 
 SBBreakpoint::SBBreakpoint(const lldb::BreakpointSP &bp_sp)
-    : m_opaque_sp(bp_sp) {}
+    : m_opaque_wp(bp_sp) {}
 
 SBBreakpoint::~SBBreakpoint() = default;
 
 const SBBreakpoint &SBBreakpoint::operator=(const SBBreakpoint &rhs) {
-  if (this != &rhs)
-    m_opaque_sp = rhs.m_opaque_sp;
+  m_opaque_wp = rhs.m_opaque_wp;
   return *this;
 }
 
 bool SBBreakpoint::operator==(const lldb::SBBreakpoint &rhs) {
-  if (m_opaque_sp && rhs.m_opaque_sp)
-    return m_opaque_sp.get() == rhs.m_opaque_sp.get();
-  return false;
+  return m_opaque_wp.lock() == rhs.m_opaque_wp.lock();
 }
 
 bool SBBreakpoint::operator!=(const lldb::SBBreakpoint &rhs) {
-  if (m_opaque_sp && rhs.m_opaque_sp)
-    return m_opaque_sp.get() != rhs.m_opaque_sp.get();
-  return (m_opaque_sp && !rhs.m_opaque_sp) || (rhs.m_opaque_sp && !m_opaque_sp);
+  return m_opaque_wp.lock() != rhs.m_opaque_wp.lock();
 }
 
 break_id_t SBBreakpoint::GetID() const {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   break_id_t break_id = LLDB_INVALID_BREAK_ID;
-  if (m_opaque_sp)
-    break_id = m_opaque_sp->GetID();
-
-  if (log) {
-    if (break_id == LLDB_INVALID_BREAK_ID)
-      log->Printf("SBBreakpoint(%p)::GetID () => LLDB_INVALID_BREAK_ID",
-                  static_cast<void *>(m_opaque_sp.get()));
-    else
-      log->Printf("SBBreakpoint(%p)::GetID () => %u",
-                  static_cast<void *>(m_opaque_sp.get()), break_id);
-  }
+  BreakpointSP bkpt_sp = GetSP();
+  if (bkpt_sp)
+    break_id = bkpt_sp->GetID();
 
+  LLDB_LOG(log, "breakpoint = {0}, id = {1}", bkpt_sp.get(), break_id);
   return break_id;
 }
 
 bool SBBreakpoint::IsValid() const {
-  if (!m_opaque_sp)
+  BreakpointSP bkpt_sp = GetSP();
+  if (!bkpt_sp)
     return false;
-  else if (m_opaque_sp->GetTarget().GetBreakpointByID(m_opaque_sp->GetID()))
+  else if (bkpt_sp->GetTarget().GetBreakpointByID(bkpt_sp->GetID()))
     return true;
   else
     return false;
 }
 
 void SBBreakpoint::ClearAllBreakpointSites() {
-  if (m_opaque_sp) {
+  BreakpointSP bkpt_sp = GetSP();
+  if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
-        m_opaque_sp->GetTarget().GetAPIMutex());
-    m_opaque_sp->ClearAllBreakpointSites();
+        bkpt_sp->GetTarget().GetAPIMutex());
+    bkpt_sp->ClearAllBreakpointSites();
   }
 }
 
 SBBreakpointLocation SBBreakpoint::FindLocationByAddress(addr_t vm_addr) {
   SBBreakpointLocation sb_bp_location;
 
-  if (m_opaque_sp) {
+  BreakpointSP bkpt_sp = GetSP();
+  if (bkpt_sp) {
     if (vm_addr != LLDB_INVALID_ADDRESS) {
       std::lock_guard<std::recursive_mutex> guard(
-          m_opaque_sp->GetTarget().GetAPIMutex());
+          bkpt_sp->GetTarget().GetAPIMutex());
       Address address;
-      Target &target = m_opaque_sp->GetTarget();
+      Target &target = bkpt_sp->GetTarget();
       if (!target.GetSectionLoadList().ResolveLoadAddress(vm_addr, address)) {
         address.SetRawAddress(vm_addr);
       }
-      sb_bp_location.SetLocation(m_opaque_sp->FindLocationByAddress(address));
+      sb_bp_location.SetLocation(bkpt_sp->FindLocationByAddress(address));
     }
   }
   return sb_bp_location;
 }
 
 break_id_t SBBreakpoint::FindLocationIDByAddress(addr_t vm_addr) {
   break_id_t break_id = LLDB_INVALID_BREAK_ID;
+  BreakpointSP bkpt_sp = GetSP();
 
-  if (m_opaque_sp && vm_addr != LLDB_INVALID_ADDRESS) {
+  if (bkpt_sp && vm_addr != LLDB_INVALID_ADDRESS) {
     std::lock_guard<std::recursive_mutex> guard(
-        m_opaque_sp->GetTarget().GetAPIMutex());
+        bkpt_sp->GetTarget().GetAPIMutex());
     Address address;
-    Target &target = m_opaque_sp->GetTarget();
+    Target &target = bkpt_sp->GetTarget();
     if (!target.GetSectionLoadList().ResolveLoadAddress(vm_addr, address)) {
       address.SetRawAddress(vm_addr);
     }
-    break_id = m_opaque_sp->FindLocationIDByAddress(address);
+    break_id = bkpt_sp->FindLocationIDByAddress(address);
   }
 
   return break_id;
 }
 
 SBBreakpointLocation SBBreakpoint::FindLocationByID(break_id_t bp_loc_id) {
   SBBreakpointLocation sb_bp_location;
+  BreakpointSP bkpt_sp = GetSP();
 
-  if (m_opaque_sp) {
+  if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
-        m_opaque_sp->GetTarget().GetAPIMutex());
-    sb_bp_location.SetLocation(m_opaque_sp->FindLocationByID(bp_loc_id));
+        bkpt_sp->GetTarget().GetAPIMutex());
+    sb_bp_location.SetLocation(bkpt_sp->FindLocationByID(bp_loc_id));
   }
 
   return sb_bp_location;
 }
 
 SBBreakpointLocation SBBreakpoint::GetLocationAtIndex(uint32_t index) {
   SBBreakpointLocation sb_bp_location;
+  BreakpointSP bkpt_sp = GetSP();
 
-  if (m_opaque_sp) {
+  if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
-        m_opaque_sp->GetTarget().GetAPIMutex());
-    sb_bp_location.SetLocation(m_opaque_sp->GetLocationAtIndex(index));
+        bkpt_sp->GetTarget().GetAPIMutex());
+    sb_bp_location.SetLocation(bkpt_sp->GetLocationAtIndex(index));
   }
 
   return sb_bp_location;
 }
 
 void SBBreakpoint::SetEnabled(bool enable) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  BreakpointSP bkpt_sp = GetSP();
 
-  if (log)
-    log->Printf("SBBreakpoint(%p)::SetEnabled (enabled=%i)",
-                static_cast<void *>(m_opaque_sp.get()), enable);
+  LLDB_LOG(log, "breakpoint = {0}, enable = {1}", bkpt_sp.get(), enable);
 
-  if (m_opaque_sp) {
+  if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
-        m_opaque_sp->GetTarget().GetAPIMutex());
-    m_opaque_sp->SetEnabled(enable);
+        bkpt_sp->GetTarget().GetAPIMutex());
+    bkpt_sp->SetEnabled(enable);
   }
 }
 
 bool SBBreakpoint::IsEnabled() {
-  if (m_opaque_sp) {
+  BreakpointSP bkpt_sp = GetSP();
+  if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
-        m_opaque_sp->GetTarget().GetAPIMutex());
-    return m_opaque_sp->IsEnabled();
+        bkpt_sp->GetTarget().GetAPIMutex());
+    return bkpt_sp->IsEnabled();
   } else
     return false;
 }
 
 void SBBreakpoint::SetOneShot(bool one_shot) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  BreakpointSP bkpt_sp = GetSP();
 
-  if (log)
-    log->Printf("SBBreakpoint(%p)::SetOneShot (one_shot=%i)",
-                static_cast<void *>(m_opaque_sp.get()), one_shot);
+  LLDB_LOG(log, "breakpoint = {0}, one_shot = {1}", bkpt_sp.get(), one_shot);
 
-  if (m_opaque_sp) {
+  if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
-        m_opaque_sp->GetTarget().GetAPIMutex());
-    m_opaque_sp->SetOneShot(one_shot);
+        bkpt_sp->GetTarget().GetAPIMutex());
+    bkpt_sp->SetOneShot(one_shot);
   }
 }
 
 bool SBBreakpoint::IsOneShot() const {
-  if (m_opaque_sp) {
+  BreakpointSP bkpt_sp = GetSP();
+  if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
-        m_opaque_sp->GetTarget().GetAPIMutex());
-    return m_opaque_sp->IsOneShot();
+        bkpt_sp->GetTarget().GetAPIMutex());
+    return bkpt_sp->IsOneShot();
   } else
     return false;
 }
 
 bool SBBreakpoint::IsInternal() {
-  if (m_opaque_sp) {
+  BreakpointSP bkpt_sp = GetSP();
+  if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
-        m_opaque_sp->GetTarget().GetAPIMutex());
-    return m_opaque_sp->IsInternal();
+        bkpt_sp->GetTarget().GetAPIMutex());
+    return bkpt_sp->IsInternal();
   } else
     return false;
 }
 
 void SBBreakpoint::SetIgnoreCount(uint32_t count) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  BreakpointSP bkpt_sp = GetSP();
 
-  if (log)
-    log->Printf("SBBreakpoint(%p)::SetIgnoreCount (count=%u)",
-                static_cast<void *>(m_opaque_sp.get()), count);
+  LLDB_LOG(log, "breakpoint = {0}, count = {1}", bkpt_sp.get(), count);
 
-  if (m_opaque_sp) {
+  if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
-        m_opaque_sp->GetTarget().GetAPIMutex());
-    m_opaque_sp->SetIgnoreCount(count);
+        bkpt_sp->GetTarget().GetAPIMutex());
+    bkpt_sp->SetIgnoreCount(count);
   }
 }
 
 void SBBreakpoint::SetCondition(const char *condition) {
-  if (m_opaque_sp) {
+  BreakpointSP bkpt_sp = GetSP();
+  if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
-        m_opaque_sp->GetTarget().GetAPIMutex());
-    m_opaque_sp->SetCondition(condition);
+        bkpt_sp->GetTarget().GetAPIMutex());
+    bkpt_sp->SetCondition(condition);
   }
 }
 
 const char *SBBreakpoint::GetCondition() {
-  if (m_opaque_sp) {
+  BreakpointSP bkpt_sp = GetSP();
+  if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
-        m_opaque_sp->GetTarget().GetAPIMutex());
-    return m_opaque_sp->GetConditionText();
+        bkpt_sp->GetTarget().GetAPIMutex());
+    return bkpt_sp->GetConditionText();
   }
   return nullptr;
 }
 
 uint32_t SBBreakpoint::GetHitCount() const {
   uint32_t count = 0;
-  if (m_opaque_sp) {
+  BreakpointSP bkpt_sp = GetSP();
+  if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
-        m_opaque_sp->GetTarget().GetAPIMutex());
-    count = m_opaque_sp->GetHitCount();
+        bkpt_sp->GetTarget().GetAPIMutex());
+    count = bkpt_sp->GetHitCount();
   }
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBBreakpoint(%p)::GetHitCount () => %u",
-                static_cast<void *>(m_opaque_sp.get()), count);
+  LLDB_LOG(log, "breakpoint = {0}, count = {1}", bkpt_sp.get(), count);
 
   return count;
 }
 
 uint32_t SBBreakpoint::GetIgnoreCount() const {
   uint32_t count = 0;
-  if (m_opaque_sp) {
+  BreakpointSP bkpt_sp = GetSP();
+  if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
-        m_opaque_sp->GetTarget().GetAPIMutex());
-    count = m_opaque_sp->GetIgnoreCount();
+        bkpt_sp->GetTarget().GetAPIMutex());
+    count = bkpt_sp->GetIgnoreCount();
   }
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBBreakpoint(%p)::GetIgnoreCount () => %u",
-                static_cast<void *>(m_opaque_sp.get()), count);
+  LLDB_LOG(log, "breakpoint = {0}, count = {1}", bkpt_sp.get(), count);
 
   return count;
 }
 
 void SBBreakpoint::SetThreadID(tid_t tid) {
-  if (m_opaque_sp) {
+  BreakpointSP bkpt_sp = GetSP();
+  if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
-        m_opaque_sp->GetTarget().GetAPIMutex());
-    m_opaque_sp->SetThreadID(tid);
+        bkpt_sp->GetTarget().GetAPIMutex());
+    bkpt_sp->SetThreadID(tid);
   }
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBBreakpoint(%p)::SetThreadID (tid=0x%4.4" PRIx64 ")",
-                static_cast<void *>(m_opaque_sp.get()), tid);
+  LLDB_LOG(log, "breakpoint = {0}, tid = {1:x}", bkpt_sp.get(), tid);
 }
 
 tid_t SBBreakpoint::GetThreadID() {
   tid_t tid = LLDB_INVALID_THREAD_ID;
-  if (m_opaque_sp) {
+  BreakpointSP bkpt_sp = GetSP();
+  if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
-        m_opaque_sp->GetTarget().GetAPIMutex());
-    tid = m_opaque_sp->GetThreadID();
+        bkpt_sp->GetTarget().GetAPIMutex());
+    tid = bkpt_sp->GetThreadID();
   }
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBBreakpoint(%p)::GetThreadID () => 0x%4.4" PRIx64,
-                static_cast<void *>(m_opaque_sp.get()), tid);
+  LLDB_LOG(log, "breakpoint = {0}, tid = {1:x}", bkpt_sp.get(), tid);
   return tid;
 }
 
 void SBBreakpoint::SetThreadIndex(uint32_t index) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBBreakpoint(%p)::SetThreadIndex (%u)",
-                static_cast<void *>(m_opaque_sp.get()), index);
-  if (m_opaque_sp) {
+  BreakpointSP bkpt_sp = GetSP();
+  LLDB_LOG(log, "breakpoint = {0}, index = {1}", bkpt_sp.get(), index);
+  if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
-        m_opaque_sp->GetTarget().GetAPIMutex());
-    m_opaque_sp->GetOptions()->GetThreadSpec()->SetIndex(index);
+        bkpt_sp->GetTarget().GetAPIMutex());
+    bkpt_sp->GetOptions()->GetThreadSpec()->SetIndex(index);
   }
 }
 
 uint32_t SBBreakpoint::GetThreadIndex() const {
   uint32_t thread_idx = UINT32_MAX;
-  if (m_opaque_sp) {
+  BreakpointSP bkpt_sp = GetSP();
+  if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
-        m_opaque_sp->GetTarget().GetAPIMutex());
+        bkpt_sp->GetTarget().GetAPIMutex());
     const ThreadSpec *thread_spec =
-        m_opaque_sp->GetOptions()->GetThreadSpecNoCreate();
+        bkpt_sp->GetOptions()->GetThreadSpecNoCreate();
     if (thread_spec != nullptr)
       thread_idx = thread_spec->GetIndex();
   }
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBBreakpoint(%p)::GetThreadIndex () => %u",
-                static_cast<void *>(m_opaque_sp.get()), thread_idx);
+  LLDB_LOG(log, "breakpoint = {0}, index = {1}", bkpt_sp.get(), thread_idx);
 
   return thread_idx;
 }
 
 void SBBreakpoint::SetThreadName(const char *thread_name) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBBreakpoint(%p)::SetThreadName (%s)",
-                static_cast<void *>(m_opaque_sp.get()), thread_name);
+  BreakpointSP bkpt_sp = GetSP();
+  LLDB_LOG(log, "breakpoint = {0}, name = {1}", bkpt_sp.get(), thread_name);
 
-  if (m_opaque_sp) {
+  if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
-        m_opaque_sp->GetTarget().GetAPIMutex());
-    m_opaque_sp->GetOptions()->GetThreadSpec()->SetName(thread_name);
+        bkpt_sp->GetTarget().GetAPIMutex());
+    bkpt_sp->GetOptions()->GetThreadSpec()->SetName(thread_name);
   }
 }
 
 const char *SBBreakpoint::GetThreadName() const {
   const char *name = nullptr;
-  if (m_opaque_sp) {
+  BreakpointSP bkpt_sp = GetSP();
+  if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
-        m_opaque_sp->GetTarget().GetAPIMutex());
+        bkpt_sp->GetTarget().GetAPIMutex());
     const ThreadSpec *thread_spec =
-        m_opaque_sp->GetOptions()->GetThreadSpecNoCreate();
+        bkpt_sp->GetOptions()->GetThreadSpecNoCreate();
     if (thread_spec != nullptr)
       name = thread_spec->GetName();
   }
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBBreakpoint(%p)::GetThreadName () => %s",
-                static_cast<void *>(m_opaque_sp.get()), name);
+  LLDB_LOG(log, "breakpoint = {0}, name = {1}", bkpt_sp.get(), name);
 
   return name;
 }
 
 void SBBreakpoint::SetQueueName(const char *queue_name) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBBreakpoint(%p)::SetQueueName (%s)",
-                static_cast<void *>(m_opaque_sp.get()), queue_name);
-  if (m_opaque_sp) {
+  BreakpointSP bkpt_sp = GetSP();
+  LLDB_LOG(log, "breakpoint = {0}, queue_name = {1}", bkpt_sp.get(),
+           queue_name);
+  if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
-        m_opaque_sp->GetTarget().GetAPIMutex());
-    m_opaque_sp->GetOptions()->GetThreadSpec()->SetQueueName(queue_name);
+        bkpt_sp->GetTarget().GetAPIMutex());
+    bkpt_sp->GetOptions()->GetThreadSpec()->SetQueueName(queue_name);
   }
 }
 
 const char *SBBreakpoint::GetQueueName() const {
   const char *name = nullptr;
-  if (m_opaque_sp) {
+  BreakpointSP bkpt_sp = GetSP();
+  if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
-        m_opaque_sp->GetTarget().GetAPIMutex());
+        bkpt_sp->GetTarget().GetAPIMutex());
     const ThreadSpec *thread_spec =
-        m_opaque_sp->GetOptions()->GetThreadSpecNoCreate();
+        bkpt_sp->GetOptions()->GetThreadSpecNoCreate();
     if (thread_spec)
       name = thread_spec->GetQueueName();
   }
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBBreakpoint(%p)::GetQueueName () => %s",
-                static_cast<void *>(m_opaque_sp.get()), name);
+  LLDB_LOG(log, "breakpoint = {0}, name = {1}", bkpt_sp.get(), name);
 
   return name;
 }
 
 size_t SBBreakpoint::GetNumResolvedLocations() const {
   size_t num_resolved = 0;
-  if (m_opaque_sp) {
+  BreakpointSP bkpt_sp = GetSP();
+  if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
-        m_opaque_sp->GetTarget().GetAPIMutex());
-    num_resolved = m_opaque_sp->GetNumResolvedLocations();
+        bkpt_sp->GetTarget().GetAPIMutex());
+    num_resolved = bkpt_sp->GetNumResolvedLocations();
   }
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBBreakpoint(%p)::GetNumResolvedLocations () => %" PRIu64,
-                static_cast<void *>(m_opaque_sp.get()),
-                static_cast<uint64_t>(num_resolved));
+  LLDB_LOG(log, "breakpoint = {0}, num_resolved = {1}", bkpt_sp.get(),
+           num_resolved);
   return num_resolved;
 }
 
 size_t SBBreakpoint::GetNumLocations() const {
+  BreakpointSP bkpt_sp = GetSP();
   size_t num_locs = 0;
-  if (m_opaque_sp) {
+  if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
-        m_opaque_sp->GetTarget().GetAPIMutex());
-    num_locs = m_opaque_sp->GetNumLocations();
+        bkpt_sp->GetTarget().GetAPIMutex());
+    num_locs = bkpt_sp->GetNumLocations();
   }
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBBreakpoint(%p)::GetNumLocations () => %" PRIu64,
-                static_cast<void *>(m_opaque_sp.get()),
-                static_cast<uint64_t>(num_locs));
+  LLDB_LOG(log, "breakpoint = {0}, num_locs = {1}", bkpt_sp.get(), num_locs);
   return num_locs;
 }
 
 void SBBreakpoint::SetCommandLineCommands(SBStringList &commands) {
-  if (!m_opaque_sp)
+  BreakpointSP bkpt_sp = GetSP();
+  if (!bkpt_sp)
     return;
   if (commands.GetSize() == 0)
     return;
 
   std::lock_guard<std::recursive_mutex> guard(
-      m_opaque_sp->GetTarget().GetAPIMutex());
+      bkpt_sp->GetTarget().GetAPIMutex());
   std::unique_ptr<BreakpointOptions::CommandData> cmd_data_up(
       new BreakpointOptions::CommandData(*commands, eScriptLanguageNone));
 
-  m_opaque_sp->GetOptions()->SetCommandDataCallback(cmd_data_up);
+  bkpt_sp->GetOptions()->SetCommandDataCallback(cmd_data_up);
 }
 
 bool SBBreakpoint::GetCommandLineCommands(SBStringList &commands) {
-  if (!m_opaque_sp)
+  BreakpointSP bkpt_sp = GetSP();
+  if (!bkpt_sp)
     return false;
   StringList command_list;
   bool has_commands =
-      m_opaque_sp->GetOptions()->GetCommandLineCallbacks(command_list);
+      bkpt_sp->GetOptions()->GetCommandLineCallbacks(command_list);
   if (has_commands)
     commands.AppendList(command_list);
   return has_commands;
 }
 
 bool SBBreakpoint::GetDescription(SBStream &s) {
   return GetDescription(s, true);
 }
 
 bool SBBreakpoint::GetDescription(SBStream &s, bool include_locations) {
-  if (m_opaque_sp) {
+  BreakpointSP bkpt_sp = GetSP();
+  if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
-        m_opaque_sp->GetTarget().GetAPIMutex());
-    s.Printf("SBBreakpoint: id = %i, ", m_opaque_sp->GetID());
-    m_opaque_sp->GetResolverDescription(s.get());
-    m_opaque_sp->GetFilterDescription(s.get());
+        bkpt_sp->GetTarget().GetAPIMutex());
+    s.Printf("SBBreakpoint: id = %i, ", bkpt_sp->GetID());
+    bkpt_sp->GetResolverDescription(s.get());
+    bkpt_sp->GetFilterDescription(s.get());
     if (include_locations) {
-      const size_t num_locations = m_opaque_sp->GetNumLocations();
+      const size_t num_locations = bkpt_sp->GetNumLocations();
       s.Printf(", locations = %" PRIu64, (uint64_t)num_locations);
     }
     return true;
   }
   s.Printf("No value");
   return false;
 }
 
if (bp && data->callback) {
       }
     }
   }
   return true; // Return true if we should stop at this breakpoint
 }
 
 void SBBreakpoint::SetCallback(BreakpointHitCallback callback, void *baton) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  BreakpointSP bkpt_sp = GetSP();
+  LLDB_LOG(log, "breakpoint = {0}, callback = {1}, baton = {2}", bkpt_sp.get(),
+           callback, baton);
 
-  if (log) {
-    void *pointer = &callback;
-    log->Printf("SBBreakpoint(%p)::SetCallback (callback=%p, baton=%p)",
-                static_cast<void *>(m_opaque_sp.get()),
-                *static_cast<void **>(&pointer), static_cast<void *>(baton));
-  }
-
-  if (m_opaque_sp) {
+  if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
-        m_opaque_sp->GetTarget().GetAPIMutex());
+        bkpt_sp->GetTarget().GetAPIMutex());
     BatonSP baton_sp(new SBBreakpointCallbackBaton(callback, baton));
-    m_opaque_sp->SetCallback(SBBreakpoint::PrivateBreakpointHitCallback,
-                             baton_sp, false);
+    bkpt_sp->SetCallback(SBBreakpoint::PrivateBreakpointHitCallback, baton_sp,
+                         false);
   }
 }
 
 void SBBreakpoint::SetScriptCallbackFunction(
     const char *callback_function_name) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  BreakpointSP bkpt_sp = GetSP();
+  LLDB_LOG(log, "breakpoint = {0}, callback = {1}", bkpt_sp.get(),
+           callback_function_name);
 
-  if (log)
-    log->Printf("SBBreakpoint(%p)::SetScriptCallbackFunction (callback=%s)",
-                static_cast<void *>(m_opaque_sp.get()), callback_function_name);
-
-  if (m_opaque_sp) {
-    std::lock_guard<std::recursive_mutex> guard(
-        m_opaque_sp->GetTarget().GetAPIMutex());
-    BreakpointOptions *bp_options = m_opaque_sp->GetOptions();
-    m_opaque_sp->GetTarget()
+  if (bkpt_sp) {
+    std::lock_guard<std::recursive_mutex> guard(
+        bkpt_sp->GetTarget().GetAPIMutex());
+    BreakpointOptions *bp_options = bkpt_sp->GetOptions();
+    bkpt_sp->GetTarget()
         .GetDebugger()
         .GetCommandInterpreter()
         .GetScriptInterpreter()
         ->SetBreakpointCommandCallbackFunction(bp_options,
                                                callback_function_name);
   }
 }
 
 SBError SBBreakpoint::SetScriptCallbackBody(const char *callback_body_text) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
-  if (log)
-    log->Printf("SBBreakpoint(%p)::SetScriptCallbackBody: callback body:\n%s)",
-                static_cast<void *>(m_opaque_sp.get()), callback_body_text);
+  BreakpointSP bkpt_sp = GetSP();
+  LLDB_LOG(log, "breakpoint = {0}, callback body:\n{1}", bkpt_sp.get(),
+           callback_body_text);
 
   SBError sb_error;
-  if (m_opaque_sp) {
+  if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
-        m_opaque_sp->GetTarget().GetAPIMutex());
-    BreakpointOptions *bp_options = m_opaque_sp->GetOptions();
+        bkpt_sp->GetTarget().GetAPIMutex());
+    BreakpointOptions *bp_options = bkpt_sp->GetOptions();
     Error error =
-        m_opaque_sp->GetTarget()
+        bkpt_sp->GetTarget()
             .GetDebugger()
             .GetCommandInterpreter()
             .GetScriptInterpreter()
             ->SetBreakpointCommandCallback(bp_options, callback_body_text);
     sb_error.SetError(error);
   } else
     sb_error.SetErrorString("invalid breakpoint");
 
   return sb_error;
 }
 
 bool SBBreakpoint::AddName(const char *new_name) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  BreakpointSP bkpt_sp = GetSP();
+  LLDB_LOG(log, "breakpoint = {0}, name = {1}", bkpt_sp.get(), new_name);
 
-  if (log)
-    log->Printf("SBBreakpoint(%p)::AddName (name=%s)",
-                static_cast<void *>(m_opaque_sp.get()), new_name);
-
-  if (m_opaque_sp) {
+  if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
-        m_opaque_sp->GetTarget().GetAPIMutex());
+        bkpt_sp->GetTarget().GetAPIMutex());
     Error error; // Think I'm just going to swallow the error here, it's
                  // probably more annoying to have to provide it.
-    return m_opaque_sp->AddName(new_name, error);
+    return bkpt_sp->AddName(new_name, error);
   }
 
   return false;
 }
 
 void SBBreakpoint::RemoveName(const char *name_to_remove) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  BreakpointSP bkpt_sp = GetSP();
+  LLDB_LOG(log, "breakpoint = {0}, name = {1}", bkpt_sp.get(), name_to_remove);
 
-  if (log)
-    log->Printf("SBBreakpoint(%p)::RemoveName (name=%s)",
-                static_cast<void *>(m_opaque_sp.get()), name_to_remove);
-
-  if (m_opaque_sp) {
+  if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
-        m_opaque_sp->GetTarget().GetAPIMutex());
-    m_opaque_sp->RemoveName(name_to_remove);
+        bkpt_sp->GetTarget().GetAPIMutex());
+    bkpt_sp->RemoveName(name_to_remove);
   }
 }
 
 bool SBBreakpoint::MatchesName(const char *name) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  BreakpointSP bkpt_sp = GetSP();
+  LLDB_LOG(log, "breakpoint = {0}, name = {1}", bkpt_sp.get(), name);
 
-  if (log)
-    log->Printf("SBBreakpoint(%p)::MatchesName (name=%s)",
-                static_cast<void *>(m_opaque_sp.get()), name);
-
-  if (m_opaque_sp) {
+  if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
-        m_opaque_sp->GetTarget().GetAPIMutex());
-    return m_opaque_sp->MatchesName(name);
+        bkpt_sp->GetTarget().GetAPIMutex());
+    return bkpt_sp->MatchesName(name);
   }
 
   return false;
 }
 
 void SBBreakpoint::GetNames(SBStringList &names) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  BreakpointSP bkpt_sp = GetSP();
+  LLDB_LOG(log, "breakpoint = {0}", bkpt_sp.get());
 
-  if (log)
-    log->Printf("SBBreakpoint(%p)::GetNames ()",
-                static_cast<void *>(m_opaque_sp.get()));
-
-  if (m_opaque_sp) {
+  if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
-        m_opaque_sp->GetTarget().GetAPIMutex());
+        bkpt_sp->GetTarget().GetAPIMutex());
     std::vector<std::string> names_vec;
-    m_opaque_sp->GetNames(names_vec);
+    bkpt_sp->GetNames(names_vec);
     for (std::string name : names_vec) {
       names.AppendString(name.c_str());
     }
   }
 }
 
-lldb_private::Breakpoint *SBBreakpoint::operator->() const {
-  return m_opaque_sp.get();
-}
-
-lldb_private::Breakpoint *SBBreakpoint::get() const {
-  return m_opaque_sp.get();
-}
-
-lldb::BreakpointSP &SBBreakpoint::operator*() { return m_opaque_sp; }
-
-const lldb::BreakpointSP &SBBreakpoint::operator*() const {
-  return m_opaque_sp;
-}
-
 bool SBBreakpoint::EventIsBreakpointEvent(const lldb::SBEvent &event) {
   return Breakpoint::BreakpointEventData::GetEventDataFromEvent(event.get()) !=
          nullptr;
 }
 
 BreakpointEventType
 SBBreakpoint::GetBreakpointEventTypeFromEvent(const SBEvent &event) {
   if (event.IsValid())
     return Breakpoint::BreakpointEventData::GetBreakpointEventTypeFromEvent(
         event.GetSP());
   return eBreakpointEventTypeInvalidType;
 }
 
 SBBreakpoint SBBreakpoint::GetBreakpointFromEvent(const lldb::SBEvent &event) {
-  SBBreakpoint sb_breakpoint;
   if (event.IsValid())
-    sb_breakpoint.m_opaque_sp =
-        Breakpoint::BreakpointEventData::GetBreakpointFromEvent(event.GetSP());
-  return sb_breakpoint;
+    return SBBreakpoint(
+        Breakpoint::BreakpointEventData::GetBreakpointFromEvent(event.GetSP()));
+  return SBBreakpoint();
 }
 
 SBBreakpointLocation
 SBBreakpoint::GetBreakpointLocationAtIndexFromEvent(const lldb::SBEvent &event,
                                                     uint32_t loc_idx) {
   SBBreakpointLocation sb_breakpoint_loc;
   if (event.IsValid())
     sb_breakpoint_loc.SetLocation(
         Breakpoint::BreakpointEventData::GetBreakpointLocationAtIndexFromEvent(
             event.GetSP(), loc_idx));
   return sb_breakpoint_loc;
 }
 
 uint32_t
 SBBreakpoint::GetNumBreakpointLocationsFromEvent(const lldb::SBEvent &event) {
   uint32_t num_locations = 0;
   if (event.IsValid())
     num_locations =
         (Breakpoint::BreakpointEventData::GetNumBreakpointLocationsFromEvent(
             event.GetSP()));
   return num_locations;
 }
 
+BreakpointSP SBBreakpoint::GetSP() const { return m_opaque_wp.lock(); }
+
 // This is simple collection of breakpoint id's and their target.
 class SBBreakpointListImpl {
 public:
   SBBreakpointListImpl(lldb::TargetSP target_sp) : m_target_wp() {
     if (target_sp && target_sp->IsValid())
       m_target_wp = target_sp;
   }
 
BreakpointSP FindBreakpointByID(lldb::break_id_t desired_id) {
 
     for (lldb::break_id_t &break_id : m_break_ids) {
       if (break_id == desired_id)
         return target_sp->GetBreakpointList().FindBreakpointByID(break_id);
     }
     return BreakpointSP();
   }
 
-  bool Append(Breakpoint &bkpt) {
+  bool Append(BreakpointSP bkpt) {
     TargetSP target_sp = m_target_wp.lock();
-    if (!target_sp)
+    if (!target_sp || !bkpt)
       return false;
-    if (bkpt.GetTargetSP() != target_sp)
+    if (bkpt->GetTargetSP() != target_sp)
       return false;
-    m_break_ids.push_back(bkpt.GetID());
+    m_break_ids.push_back(bkpt->GetID());
     return true;
   }
 
-  bool AppendIfUnique(Breakpoint &bkpt) {
+  bool AppendIfUnique(BreakpointSP bkpt) {
     TargetSP target_sp = m_target_wp.lock();
-    if (!target_sp)
+    if (!target_sp || !bkpt)
       return false;
-    if (bkpt.GetTargetSP() != target_sp)
+    if (bkpt->GetTargetSP() != target_sp)
       return false;
-    lldb::break_id_t bp_id = bkpt.GetID();
+    lldb::break_id_t bp_id = bkpt->GetID();
     if (find(m_break_ids.begin(), m_break_ids.end(), bp_id) ==
         m_break_ids.end())
       return false;
 
-    m_break_ids.push_back(bkpt.GetID());
+    m_break_ids.push_back(bkpt->GetID());
     return true;
   }
 
   bool AppendByID(lldb::break_id_t id) {
     TargetSP target_sp = m_target_wp.lock();
     if (!target_sp)
       return false;
     if (id == LLDB_INVALID_BREAK_ID)
SBBreakpoint SBBreakpointList::FindBreakpointByID(lldb::break_id_t id) {
   return SBBreakpoint(bkpt_sp);
 }
 
 void SBBreakpointList::Append(const SBBreakpoint &sb_bkpt) {
   if (!sb_bkpt.IsValid())
     return;
   if (!m_opaque_sp)
     return;
-  m_opaque_sp->Append(*sb_bkpt.get());
+  m_opaque_sp->Append(sb_bkpt.m_opaque_wp.lock());
 }
 
 void SBBreakpointList::AppendByID(lldb::break_id_t id) {
   if (!m_opaque_sp)
     return;
   m_opaque_sp->AppendByID(id);
 }
 
 bool SBBreakpointList::AppendIfUnique(const SBBreakpoint &sb_bkpt) {
   if (!sb_bkpt.IsValid())
     return false;
   if (!m_opaque_sp)
     return false;
-  return m_opaque_sp->AppendIfUnique(*sb_bkpt.get());
+  return m_opaque_sp->AppendIfUnique(sb_bkpt.GetSP());
 }
 
 void SBBreakpointList::Clear() {
   if (m_opaque_sp)
     m_opaque_sp->Clear();
 }
 
 void SBBreakpointList::CopyToBreakpointIDList(
     lldb_private::BreakpointIDList &bp_id_list) {
   if (m_opaque_sp)
     m_opaque_sp->CopyToBreakpointIDList(bp_id_list);
 }

lldb/trunk/source/API/SBBreakpointLocation.cpp

SBBreakpoint SBBreakpointLocation::GetBreakpoint() {
 
   // if (log)
   //    log->Printf ("SBBreakpointLocation::GetBreakpoint ()");
 
   SBBreakpoint sb_bp;
   if (m_opaque_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         m_opaque_sp->GetTarget().GetAPIMutex());
-    *sb_bp = m_opaque_sp->GetBreakpoint().shared_from_this();
+    sb_bp = m_opaque_sp->GetBreakpoint().shared_from_this();
   }
 
   if (log) {
     SBStream sstr;
     sb_bp.GetDescription(sstr);
     log->Printf(
         "SBBreakpointLocation(%p)::GetBreakpoint () => SBBreakpoint(%p) %s",
         static_cast<void *>(m_opaque_sp.get()),
-        static_cast<void *>(sb_bp.get()), sstr.GetData());
+        static_cast<void *>(sb_bp.GetSP().get()), sstr.GetData());
   }
   return sb_bp;
 }

lldb/trunk/source/API/SBTarget.cpp

if (target_sp && line != 0) {
     const LazyBool skip_prologue = eLazyBoolCalculate;
     const bool internal = false;
     const bool hardware = false;
     const LazyBool move_to_nearest_code = eLazyBoolCalculate;
     const FileSpecList *module_list = nullptr;
     if (sb_module_list.GetSize() > 0) {
       module_list = sb_module_list.get();
     }
-    *sb_bp = target_sp->CreateBreakpoint(
+    sb_bp = target_sp->CreateBreakpoint(
         module_list, *sb_file_spec, line, offset, check_inlines, skip_prologue,
         internal, hardware, move_to_nearest_code);
   }
 
   if (log) {
     SBStream sstr;
     sb_bp.GetDescription(sstr);
     char path[PATH_MAX];
     sb_file_spec->GetPath(path, sizeof(path));
     log->Printf("SBTarget(%p)::BreakpointCreateByLocation ( %s:%u ) => "
                 "SBBreakpoint(%p): %s",
                 static_cast<void *>(target_sp.get()), path, line,
-                static_cast<void *>(sb_bp.get()), sstr.GetData());
+                static_cast<void *>(sb_bp.GetSP().get()), sstr.GetData());
   }
 
   return sb_bp;
 }
 
 SBBreakpoint SBTarget::BreakpointCreateByName(const char *symbol_name,
                                               const char *module_name) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
   if (target_sp.get()) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 
     const bool internal = false;
     const bool hardware = false;
     const LazyBool skip_prologue = eLazyBoolCalculate;
     const lldb::addr_t offset = 0;
     if (module_name && module_name[0]) {
       FileSpecList module_spec_list;
       module_spec_list.Append(FileSpec(module_name, false));
-      *sb_bp = target_sp->CreateBreakpoint(
+      sb_bp = target_sp->CreateBreakpoint(
           &module_spec_list, NULL, symbol_name, eFunctionNameTypeAuto,
           eLanguageTypeUnknown, offset, skip_prologue, internal, hardware);
     } else {
-      *sb_bp = target_sp->CreateBreakpoint(
+      sb_bp = target_sp->CreateBreakpoint(
           NULL, NULL, symbol_name, eFunctionNameTypeAuto, eLanguageTypeUnknown,
           offset, skip_prologue, internal, hardware);
     }
   }
 
   if (log)
     log->Printf("SBTarget(%p)::BreakpointCreateByName (symbol=\"%s\", "
                 "module=\"%s\") => SBBreakpoint(%p)",
                 static_cast<void *>(target_sp.get()), symbol_name, module_name,
-                static_cast<void *>(sb_bp.get()));
+                static_cast<void *>(sb_bp.GetSP().get()));
 
   return sb_bp;
 }
 
 lldb::SBBreakpoint
 SBTarget::BreakpointCreateByName(const char *symbol_name,
                                  const SBFileSpecList &module_list,
                                  const SBFileSpecList &comp_unit_list) {
lldb::SBBreakpoint SBTarget::BreakpointCreateByName(
 
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
   if (target_sp && symbol_name && symbol_name[0]) {
     const bool internal = false;
     const bool hardware = false;
     const LazyBool skip_prologue = eLazyBoolCalculate;
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
-    *sb_bp = target_sp->CreateBreakpoint(
+    sb_bp = target_sp->CreateBreakpoint(
         module_list.get(), comp_unit_list.get(), symbol_name, name_type_mask,
         symbol_language, 0, skip_prologue, internal, hardware);
   }
 
   if (log)
     log->Printf("SBTarget(%p)::BreakpointCreateByName (symbol=\"%s\", "
                 "name_type: %d) => SBBreakpoint(%p)",
                 static_cast<void *>(target_sp.get()), symbol_name,
-                name_type_mask, static_cast<void *>(sb_bp.get()));
+                name_type_mask, static_cast<void *>(sb_bp.GetSP().get()));
 
   return sb_bp;
 }
 
 lldb::SBBreakpoint SBTarget::BreakpointCreateByNames(
     const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask,
     const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) {
   return BreakpointCreateByNames(symbol_names, num_names, name_type_mask,
lldb::SBBreakpoint SBTarget::BreakpointCreateByNames(
 
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
   if (target_sp && num_names > 0) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     const bool internal = false;
     const bool hardware = false;
     const LazyBool skip_prologue = eLazyBoolCalculate;
-    *sb_bp = target_sp->CreateBreakpoint(
+    sb_bp = target_sp->CreateBreakpoint(
         module_list.get(), comp_unit_list.get(), symbol_names, num_names,
         name_type_mask, symbol_language, offset, skip_prologue, internal,
         hardware);
   }
 
   if (log) {
     log->Printf("SBTarget(%p)::BreakpointCreateByName (symbols={",
                 static_cast<void *>(target_sp.get()));
     for (uint32_t i = 0; i < num_names; i++) {
       char sep;
       if (i < num_names - 1)
         sep = ',';
       else
         sep = '}';
       if (symbol_names[i] != NULL)
         log->Printf("\"%s\"%c ", symbol_names[i], sep);
       else
         log->Printf("\"<NULL>\"%c ", sep);
     }
     log->Printf("name_type: %d) => SBBreakpoint(%p)", name_type_mask,
-                static_cast<void *>(sb_bp.get()));
+                static_cast<void *>(sb_bp.GetSP().get()));
   }
 
   return sb_bp;
 }
 
 SBBreakpoint SBTarget::BreakpointCreateByRegex(const char *symbol_name_regex,
                                                const char *module_name) {
   SBFileSpecList module_spec_list;
lldb::SBBreakpoint SBTarget::BreakpointCreateByRegex(
   TargetSP target_sp(GetSP());
   if (target_sp && symbol_name_regex && symbol_name_regex[0]) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     RegularExpression regexp((llvm::StringRef(symbol_name_regex)));
     const bool internal = false;
     const bool hardware = false;
     const LazyBool skip_prologue = eLazyBoolCalculate;
 
-    *sb_bp = target_sp->CreateFuncRegexBreakpoint(
+    sb_bp = target_sp->CreateFuncRegexBreakpoint(
         module_list.get(), comp_unit_list.get(), regexp, symbol_language,
         skip_prologue, internal, hardware);
   }
 
   if (log)
     log->Printf("SBTarget(%p)::BreakpointCreateByRegex (symbol_regex=\"%s\") "
                 "=> SBBreakpoint(%p)",
                 static_cast<void *>(target_sp.get()), symbol_name_regex,
-                static_cast<void *>(sb_bp.get()));
+                static_cast<void *>(sb_bp.GetSP().get()));
 
   return sb_bp;
 }
 
 SBBreakpoint SBTarget::BreakpointCreateByAddress(addr_t address) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
   if (target_sp) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     const bool hardware = false;
-    *sb_bp = target_sp->CreateBreakpoint(address, false, hardware);
+    sb_bp = target_sp->CreateBreakpoint(address, false, hardware);
   }
 
   if (log)
     log->Printf("SBTarget(%p)::BreakpointCreateByAddress (address=%" PRIu64
                 ") => SBBreakpoint(%p)",
                 static_cast<void *>(target_sp.get()),
                 static_cast<uint64_t>(address),
-                static_cast<void *>(sb_bp.get()));
+                static_cast<void *>(sb_bp.GetSP().get()));
 
   return sb_bp;
 }
 
 SBBreakpoint SBTarget::BreakpointCreateBySBAddress(SBAddress &sb_address) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
   if (!sb_address.IsValid()) {
     if (log)
       log->Printf("SBTarget(%p)::BreakpointCreateBySBAddress called with "
                   "invalid address",
                   static_cast<void *>(target_sp.get()));
     return sb_bp;
   }
 
   if (target_sp) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     const bool hardware = false;
-    *sb_bp = target_sp->CreateBreakpoint(sb_address.ref(), false, hardware);
+    sb_bp = target_sp->CreateBreakpoint(sb_address.ref(), false, hardware);
   }
 
   if (log) {
     SBStream s;
     sb_address.GetDescription(s);
     log->Printf("SBTarget(%p)::BreakpointCreateBySBAddress (address=%s) => "
                 "SBBreakpoint(%p)",
                 static_cast<void *>(target_sp.get()), s.GetData(),
-                static_cast<void *>(sb_bp.get()));
+                static_cast<void *>(sb_bp.GetSP().get()));
   }
 
   return sb_bp;
 }
 
 lldb::SBBreakpoint
 SBTarget::BreakpointCreateBySourceRegex(const char *source_regex,
                                         const lldb::SBFileSpec &source_file,
if (target_sp && source_regex && source_regex[0]) {
     const bool hardware = false;
     const LazyBool move_to_nearest_code = eLazyBoolCalculate;
     RegularExpression regexp((llvm::StringRef(source_regex)));
     std::unordered_set<std::string> func_names_set;
     for (size_t i = 0; i < func_names.GetSize(); i++) {
       func_names_set.insert(func_names.GetStringAtIndex(i));
     }
 
-    *sb_bp = target_sp->CreateSourceRegexBreakpoint(
+    sb_bp = target_sp->CreateSourceRegexBreakpoint(
         module_list.get(), source_file_list.get(), func_names_set, regexp,
         false, hardware, move_to_nearest_code);
   }
 
   if (log)
     log->Printf("SBTarget(%p)::BreakpointCreateByRegex (source_regex=\"%s\") "
                 "=> SBBreakpoint(%p)",
                 static_cast<void *>(target_sp.get()), source_regex,
-                static_cast<void *>(sb_bp.get()));
+                static_cast<void *>(sb_bp.GetSP().get()));
 
   return sb_bp;
 }
 
 lldb::SBBreakpoint
 SBTarget::BreakpointCreateForException(lldb::LanguageType language,
                                        bool catch_bp, bool throw_bp) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
   if (target_sp) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     const bool hardware = false;
-    *sb_bp = target_sp->CreateExceptionBreakpoint(language, catch_bp, throw_bp,
+    sb_bp = target_sp->CreateExceptionBreakpoint(language, catch_bp, throw_bp,
                                                   hardware);
   }
 
   if (log)
     log->Printf("SBTarget(%p)::BreakpointCreateByRegex (Language: %s, catch: "
                 "%s throw: %s) => SBBreakpoint(%p)",
                 static_cast<void *>(target_sp.get()),
                 Language::GetNameForLanguageType(language),
                 catch_bp ? "on" : "off", throw_bp ? "on" : "off",
-                static_cast<void *>(sb_bp.get()));
+                static_cast<void *>(sb_bp.GetSP().get()));
 
   return sb_bp;
 }
 
 uint32_t SBTarget::GetNumBreakpoints() const {
   TargetSP target_sp(GetSP());
   if (target_sp) {
     // The breakpoint list is thread safe, no need to lock
     return target_sp->GetBreakpointList().GetSize();
   }
   return 0;
 }
 
 SBBreakpoint SBTarget::GetBreakpointAtIndex(uint32_t idx) const {
   SBBreakpoint sb_breakpoint;
   TargetSP target_sp(GetSP());
   if (target_sp) {
     // The breakpoint list is thread safe, no need to lock
-    *sb_breakpoint = target_sp->GetBreakpointList().GetBreakpointAtIndex(idx);
+    sb_breakpoint = target_sp->GetBreakpointList().GetBreakpointAtIndex(idx);
   }
   return sb_breakpoint;
 }
 
 bool SBTarget::BreakpointDelete(break_id_t bp_id) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   bool result = false;

 
 SBBreakpoint SBTarget::FindBreakpointByID(break_id_t bp_id) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBBreakpoint sb_breakpoint;
   TargetSP target_sp(GetSP());
   if (target_sp && bp_id != LLDB_INVALID_BREAK_ID) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
-    *sb_breakpoint = target_sp->GetBreakpointByID(bp_id);
+    sb_breakpoint = target_sp->GetBreakpointByID(bp_id);
   }
 
   if (log)
     log->Printf(
         "SBTarget(%p)::FindBreakpointByID (bp_id=%d) => SBBreakpoint(%p)",
         static_cast<void *>(target_sp.get()), static_cast<uint32_t>(bp_id),
-        static_cast<void *>(sb_breakpoint.get()));
+        static_cast<void *>(sb_breakpoint.GetSP().get()));
 
   return sb_breakpoint;
 }
 
 bool SBTarget::FindBreakpointsByName(const char *name,
                                      SBBreakpointList &bkpts) {
   TargetSP target_sp(GetSP());
   if (target_sp) {