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 // C Includes
  13 // C++ Includes
  14 // Other libraries and framework includes
  15 // Project includes
  16 #include "lldb/Target/Target.h"
  17
  18 using namespace lldb;
  19 using namespace lldb_private;
  20
  21 BreakpointList::BreakpointList(bool is_internal)
  22     : m_mutex(), m_breakpoints(), m_next_break_id(0),
  23       m_is_internal(is_internal) {}
  24
  25 BreakpointList::~BreakpointList() {}
  26
  27 break_id_t BreakpointList::Add(BreakpointSP &bp_sp, bool notify) {
  28   std::lock_guard<std::recursive_mutex> guard(m_mutex);
  29   // Internal breakpoint IDs are negative, normal ones are positive
  30   bp_sp->SetID(m_is_internal ? --m_next_break_id : ++m_next_break_id);
  31
  32   m_breakpoints.push_back(bp_sp);
  33   if (notify) {
  34     if (bp_sp->GetTarget().EventTypeHasListeners(
  35             Target::eBroadcastBitBreakpointChanged))
  36       bp_sp->GetTarget().BroadcastEvent(Target::eBroadcastBitBreakpointChanged,
  37                                         new Breakpoint::BreakpointEventData(
  38                                             eBreakpointEventTypeAdded, bp_sp));
  39   }
  40   return bp_sp->GetID();
  41 }
  42
  43 bool BreakpointList::Remove(break_id_t break_id, bool notify) {
  44   std::lock_guard<std::recursive_mutex> guard(m_mutex);
  45   bp_collection::iterator pos = GetBreakpointIDIterator(break_id); // Predicate
  46   if (pos != m_breakpoints.end()) {
  47     BreakpointSP bp_sp(*pos);
  48     m_breakpoints.erase(pos);
  49     if (notify) {
  50       if (bp_sp->GetTarget().EventTypeHasListeners(
  51               Target::eBroadcastBitBreakpointChanged))
  52         bp_sp->GetTarget().BroadcastEvent(
  53             Target::eBroadcastBitBreakpointChanged,
  54             new Breakpoint::BreakpointEventData(eBreakpointEventTypeRemoved,
  55                                                 bp_sp));
  56     }
  57     return true;
  58   }
  59   return false;
  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     bp_collection::iterator pos, end = m_breakpoints.end();
  87     for (pos = m_breakpoints.begin(); pos != end; ++pos) {
  88       if ((*pos)->GetTarget().EventTypeHasListeners(
  89               Target::eBroadcastBitBreakpointChanged)) {
  90         (*pos)->GetTarget().BroadcastEvent(
  91             Target::eBroadcastBitBreakpointChanged,
  92             new Breakpoint::BreakpointEventData(eBreakpointEventTypeRemoved,
  93                                                 *pos));
  94       }
  95     }
  96   }
  97   m_breakpoints.erase(m_breakpoints.begin(), m_breakpoints.end());
  98 }
  99
 100 void BreakpointList::RemoveAllowed(bool notify) {
 101   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 102
 103   bp_collection::iterator pos, end = m_breakpoints.end();
 104   if (notify) {
 105     for (pos = m_breakpoints.begin(); pos != end; ++pos) {
 106       if(!(*pos)->AllowDelete())
 107         continue;
 108       if ((*pos)->GetTarget().EventTypeHasListeners(
 109               Target::eBroadcastBitBreakpointChanged)) {
 110         (*pos)->GetTarget().BroadcastEvent(
 111             Target::eBroadcastBitBreakpointChanged,
 112             new Breakpoint::BreakpointEventData(eBreakpointEventTypeRemoved,
 113                                                 *pos));
 114       }
 115     }
 116   }
 117   pos = m_breakpoints.begin();
 118   while ( pos != end) {
 119     auto bp = *pos;
 120     if (bp->AllowDelete()) {
 121       bp->ClearAllBreakpointSites();
 122       pos = m_breakpoints.erase(pos);
 123     } else
 124       pos++;
 125   }
 126 }
 127
 128 class BreakpointIDMatches {
 129 public:
 130   BreakpointIDMatches(break_id_t break_id) : m_break_id(break_id) {}
 131
 132   bool operator()(const BreakpointSP &bp) const {
 133     return m_break_id == bp->GetID();
 134   }
 135
 136 private:
 137   const break_id_t m_break_id;
 138 };
 139
 140 BreakpointList::bp_collection::iterator
 141 BreakpointList::GetBreakpointIDIterator(break_id_t break_id) {
 142   return std::find_if(m_breakpoints.begin(),
 143                       m_breakpoints.end(),            // Search full range
 144                       BreakpointIDMatches(break_id)); // Predicate
 145 }
 146
 147 BreakpointList::bp_collection::const_iterator
 148 BreakpointList::GetBreakpointIDConstIterator(break_id_t break_id) const {
 149   return std::find_if(m_breakpoints.begin(),
 150                       m_breakpoints.end(),            // Search full range
 151                       BreakpointIDMatches(break_id)); // Predicate
 152 }
 153
 154 BreakpointSP BreakpointList::FindBreakpointByID(break_id_t break_id) {
 155   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 156   BreakpointSP stop_sp;
 157   bp_collection::iterator pos = GetBreakpointIDIterator(break_id);
 158   if (pos != m_breakpoints.end())
 159     stop_sp = *pos;
 160
 161   return stop_sp;
 162 }
 163
 164 const BreakpointSP
 165 BreakpointList::FindBreakpointByID(break_id_t break_id) const {
 166   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 167   BreakpointSP stop_sp;
 168   bp_collection::const_iterator pos = GetBreakpointIDConstIterator(break_id);
 169   if (pos != m_breakpoints.end())
 170     stop_sp = *pos;
 171
 172   return stop_sp;
 173 }
 174
 175 bool BreakpointList::FindBreakpointsByName(const char *name,
 176                                            BreakpointList &matching_bps) {
 177   Status error;
 178   if (!name)
 179     return false;
 180
 181   if (!BreakpointID::StringIsBreakpointName(llvm::StringRef(name), error))
 182     return false;
 183
 184   for (BreakpointSP bkpt_sp : Breakpoints()) {
 185     if (bkpt_sp->MatchesName(name)) {
 186       matching_bps.Add(bkpt_sp, false);
 187     }
 188   }
 189   return true;
 190 }
 191
 192 void BreakpointList::Dump(Stream *s) const {
 193   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 194   s->Printf("%p: ", static_cast<const void *>(this));
 195   s->Indent();
 196   s->Printf("BreakpointList with %u Breakpoints:\n",
 197             (uint32_t)m_breakpoints.size());
 198   s->IndentMore();
 199   for (const auto &bp_sp : m_breakpoints)
 200     bp_sp->Dump(s);
 201   s->IndentLess();
 202 }
 203
 204 BreakpointSP BreakpointList::GetBreakpointAtIndex(size_t i) {
 205   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 206   BreakpointSP stop_sp;
 207   bp_collection::iterator end = m_breakpoints.end();
 208   bp_collection::iterator pos;
 209   size_t curr_i = 0;
 210   for (pos = m_breakpoints.begin(), curr_i = 0; pos != end; ++pos, ++curr_i) {
 211     if (curr_i == i)
 212       stop_sp = *pos;
 213   }
 214   return stop_sp;
 215 }
 216
 217 const BreakpointSP BreakpointList::GetBreakpointAtIndex(size_t i) const {
 218   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 219   BreakpointSP stop_sp;
 220   bp_collection::const_iterator end = m_breakpoints.end();
 221   bp_collection::const_iterator pos;
 222   size_t curr_i = 0;
 223   for (pos = m_breakpoints.begin(), curr_i = 0; pos != end; ++pos, ++curr_i) {
 224     if (curr_i == i)
 225       stop_sp = *pos;
 226   }
 227   return stop_sp;
 228 }
 229
 230 void BreakpointList::UpdateBreakpoints(ModuleList &module_list, bool added,
 231                                        bool delete_locations) {
 232   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 233   for (const auto &bp_sp : m_breakpoints)
 234     bp_sp->ModulesChanged(module_list, added, delete_locations);
 235 }
 236
 237 void BreakpointList::UpdateBreakpointsWhenModuleIsReplaced(
 238     ModuleSP old_module_sp, ModuleSP new_module_sp) {
 239   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 240   for (const auto &bp_sp : m_breakpoints)
 241     bp_sp->ModuleReplaced(old_module_sp, new_module_sp);
 242 }
 243
 244 void BreakpointList::ClearAllBreakpointSites() {
 245   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 246   for (const auto &bp_sp : m_breakpoints)
 247     bp_sp->ClearAllBreakpointSites();
 248 }
 249
 250 void BreakpointList::GetListMutex(
 251     std::unique_lock<std::recursive_mutex> &lock) {
 252   lock = std::unique_lock<std::recursive_mutex>(m_mutex);
 253 }