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::RemoveAll(bool notify) {
  75   std::lock_guard<std::recursive_mutex> guard(m_mutex);
  76   ClearAllBreakpointSites();
  77
  78   if (notify) {
  79     bp_collection::iterator pos, end = m_breakpoints.end();
  80     for (pos = m_breakpoints.begin(); pos != end; ++pos) {
  81       if ((*pos)->GetTarget().EventTypeHasListeners(
  82               Target::eBroadcastBitBreakpointChanged)) {
  83         (*pos)->GetTarget().BroadcastEvent(
  84             Target::eBroadcastBitBreakpointChanged,
  85             new Breakpoint::BreakpointEventData(eBreakpointEventTypeRemoved,
  86                                                 *pos));
  87       }
  88     }
  89   }
  90   m_breakpoints.erase(m_breakpoints.begin(), m_breakpoints.end());
  91 }
  92
  93 class BreakpointIDMatches {
  94 public:
  95   BreakpointIDMatches(break_id_t break_id) : m_break_id(break_id) {}
  96
  97   bool operator()(const BreakpointSP &bp) const {
  98     return m_break_id == bp->GetID();
  99   }
 100
 101 private:
 102   const break_id_t m_break_id;
 103 };
 104
 105 BreakpointList::bp_collection::iterator
 106 BreakpointList::GetBreakpointIDIterator(break_id_t break_id) {
 107   return std::find_if(m_breakpoints.begin(),
 108                       m_breakpoints.end(),            // Search full range
 109                       BreakpointIDMatches(break_id)); // Predicate
 110 }
 111
 112 BreakpointList::bp_collection::const_iterator
 113 BreakpointList::GetBreakpointIDConstIterator(break_id_t break_id) const {
 114   return std::find_if(m_breakpoints.begin(),
 115                       m_breakpoints.end(),            // Search full range
 116                       BreakpointIDMatches(break_id)); // Predicate
 117 }
 118
 119 BreakpointSP BreakpointList::FindBreakpointByID(break_id_t break_id) {
 120   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 121   BreakpointSP stop_sp;
 122   bp_collection::iterator pos = GetBreakpointIDIterator(break_id);
 123   if (pos != m_breakpoints.end())
 124     stop_sp = *pos;
 125
 126   return stop_sp;
 127 }
 128
 129 const BreakpointSP
 130 BreakpointList::FindBreakpointByID(break_id_t break_id) const {
 131   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 132   BreakpointSP stop_sp;
 133   bp_collection::const_iterator pos = GetBreakpointIDConstIterator(break_id);
 134   if (pos != m_breakpoints.end())
 135     stop_sp = *pos;
 136
 137   return stop_sp;
 138 }
 139
 140 bool BreakpointList::FindBreakpointsByName(const char *name,
 141                                            BreakpointList &matching_bps) {
 142   Error error;
 143   if (!name)
 144     return false;
 145
 146   if (!BreakpointID::StringIsBreakpointName(llvm::StringRef(name), error))
 147     return false;
 148
 149   for (BreakpointSP bkpt_sp : Breakpoints()) {
 150     if (bkpt_sp->MatchesName(name)) {
 151       matching_bps.Add(bkpt_sp, false);
 152     }
 153   }
 154   return true;
 155 }
 156
 157 void BreakpointList::Dump(Stream *s) const {
 158   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 159   s->Printf("%p: ", static_cast<const void *>(this));
 160   s->Indent();
 161   s->Printf("BreakpointList with %u Breakpoints:\n",
 162             (uint32_t)m_breakpoints.size());
 163   s->IndentMore();
 164   for (const auto &bp_sp : m_breakpoints)
 165     bp_sp->Dump(s);
 166   s->IndentLess();
 167 }
 168
 169 BreakpointSP BreakpointList::GetBreakpointAtIndex(size_t i) {
 170   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 171   BreakpointSP stop_sp;
 172   bp_collection::iterator end = m_breakpoints.end();
 173   bp_collection::iterator pos;
 174   size_t curr_i = 0;
 175   for (pos = m_breakpoints.begin(), curr_i = 0; pos != end; ++pos, ++curr_i) {
 176     if (curr_i == i)
 177       stop_sp = *pos;
 178   }
 179   return stop_sp;
 180 }
 181
 182 const BreakpointSP BreakpointList::GetBreakpointAtIndex(size_t i) const {
 183   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 184   BreakpointSP stop_sp;
 185   bp_collection::const_iterator end = m_breakpoints.end();
 186   bp_collection::const_iterator pos;
 187   size_t curr_i = 0;
 188   for (pos = m_breakpoints.begin(), curr_i = 0; pos != end; ++pos, ++curr_i) {
 189     if (curr_i == i)
 190       stop_sp = *pos;
 191   }
 192   return stop_sp;
 193 }
 194
 195 void BreakpointList::UpdateBreakpoints(ModuleList &module_list, bool added,
 196                                        bool delete_locations) {
 197   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 198   for (const auto &bp_sp : m_breakpoints)
 199     bp_sp->ModulesChanged(module_list, added, delete_locations);
 200 }
 201
 202 void BreakpointList::UpdateBreakpointsWhenModuleIsReplaced(
 203     ModuleSP old_module_sp, ModuleSP new_module_sp) {
 204   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 205   for (const auto &bp_sp : m_breakpoints)
 206     bp_sp->ModuleReplaced(old_module_sp, new_module_sp);
 207 }
 208
 209 void BreakpointList::ClearAllBreakpointSites() {
 210   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 211   for (const auto &bp_sp : m_breakpoints)
 212     bp_sp->ClearAllBreakpointSites();
 213 }
 214
 215 void BreakpointList::GetListMutex(
 216     std::unique_lock<std::recursive_mutex> &lock) {
 217   lock = std::unique_lock<std::recursive_mutex>(m_mutex);
 218 }