1 files changed, 44 insertions, 46 deletions

diff --git a/lldb/source/Breakpoint/BreakpointSite.cpp b/lldb/source/Breakpoint/BreakpointSite.cpp
index 11ebc59c7e12..3ca93f908e30 100644
--- a/lldb/source/Breakpoint/BreakpointSite.cpp
+++ b/lldb/source/Breakpoint/BreakpointSite.cpp
@@ -12,14 +12,12 @@
 
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
-#include "lldb/Breakpoint/BreakpointSiteList.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-BreakpointSite::BreakpointSite(BreakpointSiteList *list,
-                               const BreakpointLocationSP &owner,
+BreakpointSite::BreakpointSite(const BreakpointLocationSP &constituent,
                                lldb::addr_t addr, bool use_hardware)
     : StoppointSite(GetNextID(), addr, 0, use_hardware),
       m_type(eSoftware), // Process subclasses need to set this correctly using
@@ -28,14 +26,14 @@ BreakpointSite::BreakpointSite(BreakpointSiteList *list,
       m_enabled(false) // Need to create it disabled, so the first enable turns
                        // it on.
 {
-  m_owners.Add(owner);
+  m_constituents.Add(constituent);
 }
 
 BreakpointSite::~BreakpointSite() {
   BreakpointLocationSP bp_loc_sp;
-  const size_t owner_count = m_owners.GetSize();
-  for (size_t i = 0; i < owner_count; i++) {
-    m_owners.GetByIndex(i)->ClearBreakpointSite();
+  const size_t constituent_count = m_constituents.GetSize();
+  for (size_t i = 0; i < constituent_count; i++) {
+    m_constituents.GetByIndex(i)->ClearBreakpointSite();
   }
 }
 
@@ -49,23 +47,23 @@ break_id_t BreakpointSite::GetNextID() {
 
 bool BreakpointSite::ShouldStop(StoppointCallbackContext *context) {
   m_hit_counter.Increment();
-  // ShouldStop can do a lot of work, and might even come come back and hit
-  // this breakpoint site again.  So don't hold the m_owners_mutex the whole
-  // while.  Instead make a local copy of the collection and call ShouldStop on
-  // the copy.
-  BreakpointLocationCollection owners_copy;
+  // ShouldStop can do a lot of work, and might even come back and hit
+  // this breakpoint site again.  So don't hold the m_constituents_mutex the
+  // whole while.  Instead make a local copy of the collection and call
+  // ShouldStop on the copy.
+  BreakpointLocationCollection constituents_copy;
   {
-    std::lock_guard<std::recursive_mutex> guard(m_owners_mutex);
-    owners_copy = m_owners;
+    std::lock_guard<std::recursive_mutex> guard(m_constituents_mutex);
+    constituents_copy = m_constituents;
   }
-  return owners_copy.ShouldStop(context);
+  return constituents_copy.ShouldStop(context);
 }
 
 bool BreakpointSite::IsBreakpointAtThisSite(lldb::break_id_t bp_id) {
-  std::lock_guard<std::recursive_mutex> guard(m_owners_mutex);
-  const size_t owner_count = m_owners.GetSize();
-  for (size_t i = 0; i < owner_count; i++) {
-    if (m_owners.GetByIndex(i)->GetBreakpoint().GetID() == bp_id)
+  std::lock_guard<std::recursive_mutex> guard(m_constituents_mutex);
+  const size_t constituent_count = m_constituents.GetSize();
+  for (size_t i = 0; i < constituent_count; i++) {
+    if (m_constituents.GetByIndex(i)->GetBreakpoint().GetID() == bp_id)
       return true;
   }
   return false;
@@ -76,20 +74,20 @@ void BreakpointSite::Dump(Stream *s) const {
     return;
 
   s->Printf("BreakpointSite %u: addr = 0x%8.8" PRIx64
-            "  type = %s breakpoint  hw_index = %i  hit_count = %-4u",
+            "  type = %s breakpoint  hit_count = %-4u",
             GetID(), (uint64_t)m_addr, IsHardware() ? "hardware" : "software",
-            GetHardwareIndex(), GetHitCount());
+            GetHitCount());
 }
 
 void BreakpointSite::GetDescription(Stream *s, lldb::DescriptionLevel level) {
-  std::lock_guard<std::recursive_mutex> guard(m_owners_mutex);
+  std::lock_guard<std::recursive_mutex> guard(m_constituents_mutex);
   if (level != lldb::eDescriptionLevelBrief)
     s->Printf("breakpoint site: %d at 0x%8.8" PRIx64, GetID(),
               GetLoadAddress());
-  m_owners.GetDescription(s, level);
+  m_constituents.GetDescription(s, level);
 }
 
-bool BreakpointSite::IsInternal() const { return m_owners.IsInternal(); }
+bool BreakpointSite::IsInternal() const { return m_constituents.IsInternal(); }
 
 uint8_t *BreakpointSite::GetTrapOpcodeBytes() { return &m_trap_opcode[0]; }
 
@@ -122,36 +120,36 @@ bool BreakpointSite::IsEnabled() const { return m_enabled; }
 
 void BreakpointSite::SetEnabled(bool enabled) { m_enabled = enabled; }
 
-void BreakpointSite::AddOwner(const BreakpointLocationSP &owner) {
-  std::lock_guard<std::recursive_mutex> guard(m_owners_mutex);
-  m_owners.Add(owner);
+void BreakpointSite::AddConstituent(const BreakpointLocationSP &constituent) {
+  std::lock_guard<std::recursive_mutex> guard(m_constituents_mutex);
+  m_constituents.Add(constituent);
 }
 
-size_t BreakpointSite::RemoveOwner(lldb::break_id_t break_id,
-                                   lldb::break_id_t break_loc_id) {
-  std::lock_guard<std::recursive_mutex> guard(m_owners_mutex);
-  m_owners.Remove(break_id, break_loc_id);
-  return m_owners.GetSize();
+size_t BreakpointSite::RemoveConstituent(lldb::break_id_t break_id,
+                                         lldb::break_id_t break_loc_id) {
+  std::lock_guard<std::recursive_mutex> guard(m_constituents_mutex);
+  m_constituents.Remove(break_id, break_loc_id);
+  return m_constituents.GetSize();
 }
 
-size_t BreakpointSite::GetNumberOfOwners() {
-  std::lock_guard<std::recursive_mutex> guard(m_owners_mutex);
-  return m_owners.GetSize();
+size_t BreakpointSite::GetNumberOfConstituents() {
+  std::lock_guard<std::recursive_mutex> guard(m_constituents_mutex);
+  return m_constituents.GetSize();
 }
 
-BreakpointLocationSP BreakpointSite::GetOwnerAtIndex(size_t index) {
-  std::lock_guard<std::recursive_mutex> guard(m_owners_mutex);
-  return m_owners.GetByIndex(index);
+BreakpointLocationSP BreakpointSite::GetConstituentAtIndex(size_t index) {
+  std::lock_guard<std::recursive_mutex> guard(m_constituents_mutex);
+  return m_constituents.GetByIndex(index);
 }
 
 bool BreakpointSite::ValidForThisThread(Thread &thread) {
-  std::lock_guard<std::recursive_mutex> guard(m_owners_mutex);
-  return m_owners.ValidForThisThread(thread);
+  std::lock_guard<std::recursive_mutex> guard(m_constituents_mutex);
+  return m_constituents.ValidForThisThread(thread);
 }
 
 void BreakpointSite::BumpHitCounts() {
-  std::lock_guard<std::recursive_mutex> guard(m_owners_mutex);
-  for (BreakpointLocationSP loc_sp : m_owners.BreakpointLocations()) {
+  std::lock_guard<std::recursive_mutex> guard(m_constituents_mutex);
+  for (BreakpointLocationSP loc_sp : m_constituents.BreakpointLocations()) {
     loc_sp->BumpHitCount();
   }
 }
@@ -198,10 +196,10 @@ bool BreakpointSite::IntersectsRange(lldb::addr_t addr, size_t size,
   return true;
 }
 
-size_t
-BreakpointSite::CopyOwnersList(BreakpointLocationCollection &out_collection) {
-  std::lock_guard<std::recursive_mutex> guard(m_owners_mutex);
-  for (BreakpointLocationSP loc_sp : m_owners.BreakpointLocations()) {
+size_t BreakpointSite::CopyConstituentsList(
+    BreakpointLocationCollection &out_collection) {
+  std::lock_guard<std::recursive_mutex> guard(m_constituents_mutex);
+  for (BreakpointLocationSP loc_sp : m_constituents.BreakpointLocations()) {
     out_collection.Add(loc_sp);
   }
   return out_collection.GetSize();