contrib/llvm/tools/lldb/source/Breakpoint/BreakpointList.cpp

   1 //===-- BreakpointList.cpp --------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/Breakpoint/BreakpointList.h"
  11
  12 #include "lldb/Target/Target.h"
  13
  14 using namespace lldb;
  15 using namespace lldb_private;
  16
  17 static void NotifyChange(const BreakpointSP &bp, BreakpointEventType event) {
  18   Target &target = bp->GetTarget();
  19   if (target.EventTypeHasListeners(Target::eBroadcastBitBreakpointChanged))
  20     target.BroadcastEvent(Target::eBroadcastBitBreakpointChanged,
  21                           new Breakpoint::BreakpointEventData(event, bp));
  22 }
  23
  24 BreakpointList::BreakpointList(bool is_internal)
  25     : m_mutex(), m_breakpoints(), m_next_break_id(0),
  26       m_is_internal(is_internal) {}
  27
  28 BreakpointList::~BreakpointList() {}
  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   m_breakpoints.erase(
 104       std::remove_if(m_breakpoints.begin(), m_breakpoints.end(),
 105                      [&](const BreakpointSP &bp) { return bp->AllowDelete(); }),
 106       m_breakpoints.end());
 107 }
 108
 109 BreakpointList::bp_collection::iterator
 110 BreakpointList::GetBreakpointIDIterator(break_id_t break_id) {
 111   return std::find_if(
 112       m_breakpoints.begin(), m_breakpoints.end(),
 113       [&](const BreakpointSP &bp) { return bp->GetID() == break_id; });
 114 }
 115
 116 BreakpointList::bp_collection::const_iterator
 117 BreakpointList::GetBreakpointIDConstIterator(break_id_t break_id) const {
 118   return std::find_if(
 119       m_breakpoints.begin(), m_breakpoints.end(),
 120       [&](const BreakpointSP &bp) { return bp->GetID() == break_id; });
 121 }
 122
 123 BreakpointSP BreakpointList::FindBreakpointByID(break_id_t break_id) const {
 124   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 125
 126   auto it = GetBreakpointIDConstIterator(break_id);
 127   if (it != m_breakpoints.end())
 128     return *it;
 129   return {};
 130 }
 131
 132 bool BreakpointList::FindBreakpointsByName(const char *name,
 133                                            BreakpointList &matching_bps) {
 134   Status error;
 135   if (!name)
 136     return false;
 137
 138   if (!BreakpointID::StringIsBreakpointName(llvm::StringRef(name), error))
 139     return false;
 140
 141   for (BreakpointSP bkpt_sp : Breakpoints()) {
 142     if (bkpt_sp->MatchesName(name)) {
 143       matching_bps.Add(bkpt_sp, false);
 144     }
 145   }
 146
 147   return true;
 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::GetListMutex(
 190     std::unique_lock<std::recursive_mutex> &lock) {
 191   lock = std::unique_lock<std::recursive_mutex>(m_mutex);
 192 }