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 // 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 (Mutex::eMutexTypeRecursive),
  23     m_breakpoints(),
  24     m_next_break_id (0),
  25     m_is_internal (is_internal)
  26 {
  27 }
  28
  29 BreakpointList::~BreakpointList()
  30 {
  31 }
  32
  33
  34 break_id_t
  35 BreakpointList::Add (BreakpointSP &bp_sp, bool notify)
  36 {
  37     Mutex::Locker locker(m_mutex);
  38     // Internal breakpoint IDs are negative, normal ones are positive
  39     bp_sp->SetID (m_is_internal ? --m_next_break_id : ++m_next_break_id);
  40
  41     m_breakpoints.push_back(bp_sp);
  42     if (notify)
  43     {
  44         if (bp_sp->GetTarget().EventTypeHasListeners(Target::eBroadcastBitBreakpointChanged))
  45             bp_sp->GetTarget().BroadcastEvent (Target::eBroadcastBitBreakpointChanged,
  46                                                new Breakpoint::BreakpointEventData (eBreakpointEventTypeAdded, bp_sp));
  47     }
  48     return bp_sp->GetID();
  49 }
  50
  51 bool
  52 BreakpointList::Remove (break_id_t break_id, bool notify)
  53 {
  54     Mutex::Locker locker(m_mutex);
  55     bp_collection::iterator pos = GetBreakpointIDIterator(break_id);    // Predicate
  56     if (pos != m_breakpoints.end())
  57     {
  58         BreakpointSP bp_sp (*pos);
  59         m_breakpoints.erase(pos);
  60         if (notify)
  61         {
  62             if (bp_sp->GetTarget().EventTypeHasListeners(Target::eBroadcastBitBreakpointChanged))
  63                 bp_sp->GetTarget().BroadcastEvent (Target::eBroadcastBitBreakpointChanged,
  64                                                    new Breakpoint::BreakpointEventData (eBreakpointEventTypeRemoved, bp_sp));
  65         }
  66         return true;
  67     }
  68     return false;
  69 }
  70
  71 void
  72 BreakpointList::SetEnabledAll (bool enabled)
  73 {
  74     Mutex::Locker locker(m_mutex);
  75     bp_collection::iterator pos, end = m_breakpoints.end();
  76     for (pos = m_breakpoints.begin(); pos != end; ++pos)
  77         (*pos)->SetEnabled (enabled);
  78 }
  79
  80
  81 void
  82 BreakpointList::RemoveAll (bool notify)
  83 {
  84     Mutex::Locker locker(m_mutex);
  85     ClearAllBreakpointSites ();
  86
  87     if (notify)
  88     {
  89         bp_collection::iterator pos, end = m_breakpoints.end();
  90         for (pos = m_breakpoints.begin(); pos != end; ++pos)
  91         {
  92             if ((*pos)->GetTarget().EventTypeHasListeners(Target::eBroadcastBitBreakpointChanged))
  93             {
  94                 (*pos)->GetTarget().BroadcastEvent (Target::eBroadcastBitBreakpointChanged,
  95                                                     new Breakpoint::BreakpointEventData (eBreakpointEventTypeRemoved,
  96                                                                                          *pos));
  97             }
  98         }
  99     }
 100     m_breakpoints.erase (m_breakpoints.begin(), m_breakpoints.end());
 101 }
 102
 103 class BreakpointIDMatches
 104 {
 105 public:
 106     BreakpointIDMatches (break_id_t break_id) :
 107         m_break_id(break_id)
 108     {
 109     }
 110
 111     bool operator() (const BreakpointSP &bp) const
 112     {
 113         return m_break_id == bp->GetID();
 114     }
 115
 116 private:
 117    const break_id_t m_break_id;
 118 };
 119
 120 BreakpointList::bp_collection::iterator
 121 BreakpointList::GetBreakpointIDIterator (break_id_t break_id)
 122 {
 123     return std::find_if(m_breakpoints.begin(), m_breakpoints.end(), // Search full range
 124                         BreakpointIDMatches(break_id));             // Predicate
 125 }
 126
 127 BreakpointList::bp_collection::const_iterator
 128 BreakpointList::GetBreakpointIDConstIterator (break_id_t break_id) const
 129 {
 130     return std::find_if(m_breakpoints.begin(), m_breakpoints.end(), // Search full range
 131                         BreakpointIDMatches(break_id));             // Predicate
 132 }
 133
 134 BreakpointSP
 135 BreakpointList::FindBreakpointByID (break_id_t break_id)
 136 {
 137     Mutex::Locker locker(m_mutex);
 138     BreakpointSP stop_sp;
 139     bp_collection::iterator pos = GetBreakpointIDIterator(break_id);
 140     if (pos != m_breakpoints.end())
 141         stop_sp = *pos;
 142
 143     return stop_sp;
 144 }
 145
 146 const BreakpointSP
 147 BreakpointList::FindBreakpointByID (break_id_t break_id) const
 148 {
 149     Mutex::Locker locker(m_mutex);
 150     BreakpointSP stop_sp;
 151     bp_collection::const_iterator pos = GetBreakpointIDConstIterator(break_id);
 152     if (pos != m_breakpoints.end())
 153         stop_sp = *pos;
 154
 155     return stop_sp;
 156 }
 157
 158 void
 159 BreakpointList::Dump (Stream *s) const
 160 {
 161     Mutex::Locker locker(m_mutex);
 162     s->Printf("%p: ", this);
 163     s->Indent();
 164     s->Printf("BreakpointList with %u Breakpoints:\n", (uint32_t)m_breakpoints.size());
 165     s->IndentMore();
 166     bp_collection::const_iterator pos;
 167     bp_collection::const_iterator end = m_breakpoints.end();
 168     for (pos = m_breakpoints.begin(); pos != end; ++pos)
 169         (*pos)->Dump(s);
 170     s->IndentLess();
 171 }
 172
 173
 174 BreakpointSP
 175 BreakpointList::GetBreakpointAtIndex (size_t i)
 176 {
 177     Mutex::Locker locker(m_mutex);
 178     BreakpointSP stop_sp;
 179     bp_collection::iterator end = m_breakpoints.end();
 180     bp_collection::iterator pos;
 181     size_t curr_i = 0;
 182     for (pos = m_breakpoints.begin(), curr_i = 0; pos != end; ++pos, ++curr_i)
 183     {
 184         if (curr_i == i)
 185             stop_sp = *pos;
 186     }
 187     return stop_sp;
 188 }
 189
 190 const BreakpointSP
 191 BreakpointList::GetBreakpointAtIndex (size_t i) const
 192 {
 193     Mutex::Locker locker(m_mutex);
 194     BreakpointSP stop_sp;
 195     bp_collection::const_iterator end = m_breakpoints.end();
 196     bp_collection::const_iterator pos;
 197     size_t curr_i = 0;
 198     for (pos = m_breakpoints.begin(), curr_i = 0; pos != end; ++pos, ++curr_i)
 199     {
 200         if (curr_i == i)
 201             stop_sp = *pos;
 202     }
 203     return stop_sp;
 204 }
 205
 206 void
 207 BreakpointList::UpdateBreakpoints (ModuleList& module_list, bool added)
 208 {
 209     Mutex::Locker locker(m_mutex);
 210     bp_collection::iterator end = m_breakpoints.end();
 211     bp_collection::iterator pos;
 212     for (pos = m_breakpoints.begin(); pos != end; ++pos)
 213         (*pos)->ModulesChanged (module_list, added);
 214
 215 }
 216
 217 void
 218 BreakpointList::UpdateBreakpointsWhenModuleIsReplaced (ModuleSP old_module_sp, ModuleSP new_module_sp)
 219 {
 220     Mutex::Locker locker(m_mutex);
 221     bp_collection::iterator end = m_breakpoints.end();
 222     bp_collection::iterator pos;
 223     for (pos = m_breakpoints.begin(); pos != end; ++pos)
 224         (*pos)->ModuleReplaced (old_module_sp, new_module_sp);
 225
 226 }
 227
 228 void
 229 BreakpointList::ClearAllBreakpointSites ()
 230 {
 231     Mutex::Locker locker(m_mutex);
 232     bp_collection::iterator end = m_breakpoints.end();
 233     bp_collection::iterator pos;
 234     for (pos = m_breakpoints.begin(); pos != end; ++pos)
 235         (*pos)->ClearAllBreakpointSites ();
 236
 237 }
 238
 239 void
 240 BreakpointList::GetListMutex (Mutex::Locker &locker)
 241 {
 242     return locker.Lock (m_mutex);
 243 }