lldb/source/Breakpoint/BreakpointList.cpp

   1 //===-- BreakpointList.cpp ------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "lldb/Breakpoint/BreakpointList.h"
  10
  11 #include "lldb/Target/Target.h"
  12
  13 #include "llvm/Support/Errc.h"
  14
  15 using namespace lldb;
  16 using namespace lldb_private;
  17
  18 static void NotifyChange(const BreakpointSP &bp, BreakpointEventType event) {
  19   Target &target = bp->GetTarget();
  20   if (target.EventTypeHasListeners(Target::eBroadcastBitBreakpointChanged))
  21     target.BroadcastEvent(Target::eBroadcastBitBreakpointChanged,
  22                           new Breakpoint::BreakpointEventData(event, bp));
  23 }
  24
  25 BreakpointList::BreakpointList(bool is_internal)
  26     : m_next_break_id(0), m_is_internal(is_internal) {}
  27
  28 BreakpointList::~BreakpointList() = default;
  29
  30 break_id_t BreakpointList::Add(BreakpointSP &bp_sp, bool notify) {
  31   std::lock_guard<std::recursive_mutex> guard(m_mutex);
  32
  33   // Internal breakpoint IDs are negative, normal ones are positive
  34   bp_sp->SetID(m_is_internal ? --m_next_break_id : ++m_next_break_id);
  35
  36   m_breakpoints.push_back(bp_sp);
  37
  38   if (notify)
  39     NotifyChange(bp_sp, eBreakpointEventTypeAdded);
  40
  41   return bp_sp->GetID();
  42 }
  43
  44 bool BreakpointList::Remove(break_id_t break_id, bool notify) {
  45   std::lock_guard<std::recursive_mutex> guard(m_mutex);
  46
  47   auto it = std::find_if(
  48       m_breakpoints.begin(), m_breakpoints.end(),
  49       [&](const BreakpointSP &bp) { return bp->GetID() == break_id; });
  50
  51   if (it == m_breakpoints.end())
  52     return false;
  53
  54   if (notify)
  55     NotifyChange(*it, eBreakpointEventTypeRemoved);
  56
  57   m_breakpoints.erase(it);
  58
  59   return true;
  60 }
  61
  62 void BreakpointList::RemoveInvalidLocations(const ArchSpec &arch) {
  63   std::lock_guard<std::recursive_mutex> guard(m_mutex);
  64   for (const auto &bp_sp : m_breakpoints)
  65     bp_sp->RemoveInvalidLocations(arch);
  66 }
  67
  68 void BreakpointList::SetEnabledAll(bool enabled) {
  69   std::lock_guard<std::recursive_mutex> guard(m_mutex);
  70   for (const auto &bp_sp : m_breakpoints)
  71     bp_sp->SetEnabled(enabled);
  72 }
  73
  74 void BreakpointList::SetEnabledAllowed(bool enabled) {
  75   std::lock_guard<std::recursive_mutex> guard(m_mutex);
  76   for (const auto &bp_sp : m_breakpoints)
  77     if (bp_sp->AllowDisable())
  78       bp_sp->SetEnabled(enabled);
  79 }
  80
  81 void BreakpointList::RemoveAll(bool notify) {
  82   std::lock_guard<std::recursive_mutex> guard(m_mutex);
  83   ClearAllBreakpointSites();
  84
  85   if (notify) {
  86     for (const auto &bp_sp : m_breakpoints)
  87       NotifyChange(bp_sp, eBreakpointEventTypeRemoved);
  88   }
  89
  90   m_breakpoints.clear();
  91 }
  92
  93 void BreakpointList::RemoveAllowed(bool notify) {
  94   std::lock_guard<std::recursive_mutex> guard(m_mutex);
  95
  96   for (const auto &bp_sp : m_breakpoints) {
  97     if (bp_sp->AllowDelete())
  98       bp_sp->ClearAllBreakpointSites();
  99     if (notify)
 100       NotifyChange(bp_sp, eBreakpointEventTypeRemoved);
 101   }
 102
 103   llvm::erase_if(m_breakpoints,
 104                  [&](const BreakpointSP &bp) { return bp->AllowDelete(); });
 105 }
 106
 107 BreakpointList::bp_collection::iterator
 108 BreakpointList::GetBreakpointIDIterator(break_id_t break_id) {
 109   return std::find_if(
 110       m_breakpoints.begin(), m_breakpoints.end(),
 111       [&](const BreakpointSP &bp) { return bp->GetID() == break_id; });
 112 }
 113
 114 BreakpointList::bp_collection::const_iterator
 115 BreakpointList::GetBreakpointIDConstIterator(break_id_t break_id) const {
 116   return std::find_if(
 117       m_breakpoints.begin(), m_breakpoints.end(),
 118       [&](const BreakpointSP &bp) { return bp->GetID() == break_id; });
 119 }
 120
 121 BreakpointSP BreakpointList::FindBreakpointByID(break_id_t break_id) const {
 122   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 123
 124   auto it = GetBreakpointIDConstIterator(break_id);
 125   if (it != m_breakpoints.end())
 126     return *it;
 127   return {};
 128 }
 129
 130 llvm::Expected<std::vector<lldb::BreakpointSP>>
 131 BreakpointList::FindBreakpointsByName(const char *name) {
 132   if (!name)
 133     return llvm::createStringError(llvm::errc::invalid_argument,
 134                                    "FindBreakpointsByName requires a name");
 135
 136   Status error;
 137   if (!BreakpointID::StringIsBreakpointName(llvm::StringRef(name), error))
 138     return error.ToError();
 139
 140   std::vector<lldb::BreakpointSP> matching_bps;
 141   for (BreakpointSP bkpt_sp : Breakpoints()) {
 142     if (bkpt_sp->MatchesName(name)) {
 143       matching_bps.push_back(bkpt_sp);
 144     }
 145   }
 146
 147   return matching_bps;
 148 }
 149
 150 void BreakpointList::Dump(Stream *s) const {
 151   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 152   s->Printf("%p: ", static_cast<const void *>(this));
 153   s->Indent();
 154   s->Printf("BreakpointList with %u Breakpoints:\n",
 155             (uint32_t)m_breakpoints.size());
 156   s->IndentMore();
 157   for (const auto &bp_sp : m_breakpoints)
 158     bp_sp->Dump(s);
 159   s->IndentLess();
 160 }
 161
 162 BreakpointSP BreakpointList::GetBreakpointAtIndex(size_t i) const {
 163   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 164   if (i < m_breakpoints.size())
 165     return m_breakpoints[i];
 166   return {};
 167 }
 168
 169 void BreakpointList::UpdateBreakpoints(ModuleList &module_list, bool added,
 170                                        bool delete_locations) {
 171   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 172   for (const auto &bp_sp : m_breakpoints)
 173     bp_sp->ModulesChanged(module_list, added, delete_locations);
 174 }
 175
 176 void BreakpointList::UpdateBreakpointsWhenModuleIsReplaced(
 177     ModuleSP old_module_sp, ModuleSP new_module_sp) {
 178   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 179   for (const auto &bp_sp : m_breakpoints)
 180     bp_sp->ModuleReplaced(old_module_sp, new_module_sp);
 181 }
 182
 183 void BreakpointList::ClearAllBreakpointSites() {
 184   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 185   for (const auto &bp_sp : m_breakpoints)
 186     bp_sp->ClearAllBreakpointSites();
 187 }
 188
 189 void BreakpointList::ResetHitCounts() {
 190   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 191   for (const auto &bp_sp : m_breakpoints)
 192     bp_sp->ResetHitCount();
 193 }
 194
 195 void BreakpointList::GetListMutex(
 196     std::unique_lock<std::recursive_mutex> &lock) {
 197   lock = std::unique_lock<std::recursive_mutex>(m_mutex);
 198 }