lldb/source/Breakpoint/WatchpointList.cpp

   1 //===-- WatchpointList.cpp --------------------------------------*- C++ -*-===//
   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/WatchpointList.h"
  10 #include "lldb/Breakpoint/Watchpoint.h"
  11
  12 using namespace lldb;
  13 using namespace lldb_private;
  14
  15 WatchpointList::WatchpointList()
  16     : m_watchpoints(), m_mutex(), m_next_wp_id(0) {}
  17
  18 WatchpointList::~WatchpointList() {}
  19
  20 // Add a watchpoint to the list.
  21 lldb::watch_id_t WatchpointList::Add(const WatchpointSP &wp_sp, bool notify) {
  22   std::lock_guard<std::recursive_mutex> guard(m_mutex);
  23   wp_sp->SetID(++m_next_wp_id);
  24   m_watchpoints.push_back(wp_sp);
  25   if (notify) {
  26     if (wp_sp->GetTarget().EventTypeHasListeners(
  27             Target::eBroadcastBitWatchpointChanged))
  28       wp_sp->GetTarget().BroadcastEvent(Target::eBroadcastBitWatchpointChanged,
  29                                         new Watchpoint::WatchpointEventData(
  30                                             eWatchpointEventTypeAdded, wp_sp));
  31   }
  32   return wp_sp->GetID();
  33 }
  34
  35 void WatchpointList::Dump(Stream *s) const {
  36   DumpWithLevel(s, lldb::eDescriptionLevelBrief);
  37 }
  38
  39 void WatchpointList::DumpWithLevel(
  40     Stream *s, lldb::DescriptionLevel description_level) const {
  41   std::lock_guard<std::recursive_mutex> guard(m_mutex);
  42   s->Printf("%p: ", static_cast<const void *>(this));
  43   // s->Indent();
  44   s->Printf("WatchpointList with %" PRIu64 " Watchpoints:\n",
  45             (uint64_t)m_watchpoints.size());
  46   s->IndentMore();
  47   wp_collection::const_iterator pos, end = m_watchpoints.end();
  48   for (pos = m_watchpoints.begin(); pos != end; ++pos)
  49     (*pos)->DumpWithLevel(s, description_level);
  50   s->IndentLess();
  51 }
  52
  53 const WatchpointSP WatchpointList::FindByAddress(lldb::addr_t addr) const {
  54   WatchpointSP wp_sp;
  55   std::lock_guard<std::recursive_mutex> guard(m_mutex);
  56   if (!m_watchpoints.empty()) {
  57     wp_collection::const_iterator pos, end = m_watchpoints.end();
  58     for (pos = m_watchpoints.begin(); pos != end; ++pos) {
  59       lldb::addr_t wp_addr = (*pos)->GetLoadAddress();
  60       uint32_t wp_bytesize = (*pos)->GetByteSize();
  61       if ((wp_addr <= addr) && ((wp_addr + wp_bytesize) > addr)) {
  62         wp_sp = *pos;
  63         break;
  64       }
  65     }
  66   }
  67
  68   return wp_sp;
  69 }
  70
  71 const WatchpointSP WatchpointList::FindBySpec(std::string spec) const {
  72   WatchpointSP wp_sp;
  73   std::lock_guard<std::recursive_mutex> guard(m_mutex);
  74   if (!m_watchpoints.empty()) {
  75     wp_collection::const_iterator pos, end = m_watchpoints.end();
  76     for (pos = m_watchpoints.begin(); pos != end; ++pos)
  77       if ((*pos)->GetWatchSpec() == spec) {
  78         wp_sp = *pos;
  79         break;
  80       }
  81   }
  82
  83   return wp_sp;
  84 }
  85
  86 class WatchpointIDMatches {
  87 public:
  88   WatchpointIDMatches(lldb::watch_id_t watch_id) : m_watch_id(watch_id) {}
  89
  90   bool operator()(const WatchpointSP &wp) const {
  91     return m_watch_id == wp->GetID();
  92   }
  93
  94 private:
  95   const lldb::watch_id_t m_watch_id;
  96 };
  97
  98 WatchpointList::wp_collection::iterator
  99 WatchpointList::GetIDIterator(lldb::watch_id_t watch_id) {
 100   return std::find_if(m_watchpoints.begin(),
 101                       m_watchpoints.end(),            // Search full range
 102                       WatchpointIDMatches(watch_id)); // Predicate
 103 }
 104
 105 WatchpointList::wp_collection::const_iterator
 106 WatchpointList::GetIDConstIterator(lldb::watch_id_t watch_id) const {
 107   return std::find_if(m_watchpoints.begin(),
 108                       m_watchpoints.end(),            // Search full range
 109                       WatchpointIDMatches(watch_id)); // Predicate
 110 }
 111
 112 WatchpointSP WatchpointList::FindByID(lldb::watch_id_t watch_id) const {
 113   WatchpointSP wp_sp;
 114   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 115   wp_collection::const_iterator pos = GetIDConstIterator(watch_id);
 116   if (pos != m_watchpoints.end())
 117     wp_sp = *pos;
 118
 119   return wp_sp;
 120 }
 121
 122 lldb::watch_id_t WatchpointList::FindIDByAddress(lldb::addr_t addr) {
 123   WatchpointSP wp_sp = FindByAddress(addr);
 124   if (wp_sp) {
 125     return wp_sp->GetID();
 126   }
 127   return LLDB_INVALID_WATCH_ID;
 128 }
 129
 130 lldb::watch_id_t WatchpointList::FindIDBySpec(std::string spec) {
 131   WatchpointSP wp_sp = FindBySpec(spec);
 132   if (wp_sp) {
 133     return wp_sp->GetID();
 134   }
 135   return LLDB_INVALID_WATCH_ID;
 136 }
 137
 138 WatchpointSP WatchpointList::GetByIndex(uint32_t i) {
 139   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 140   WatchpointSP wp_sp;
 141   if (i < m_watchpoints.size()) {
 142     wp_collection::const_iterator pos = m_watchpoints.begin();
 143     std::advance(pos, i);
 144     wp_sp = *pos;
 145   }
 146   return wp_sp;
 147 }
 148
 149 const WatchpointSP WatchpointList::GetByIndex(uint32_t i) const {
 150   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 151   WatchpointSP wp_sp;
 152   if (i < m_watchpoints.size()) {
 153     wp_collection::const_iterator pos = m_watchpoints.begin();
 154     std::advance(pos, i);
 155     wp_sp = *pos;
 156   }
 157   return wp_sp;
 158 }
 159
 160 std::vector<lldb::watch_id_t> WatchpointList::GetWatchpointIDs() const {
 161   std::vector<lldb::watch_id_t> IDs;
 162   wp_collection::const_iterator pos, end = m_watchpoints.end();
 163   for (pos = m_watchpoints.begin(); pos != end; ++pos)
 164     IDs.push_back((*pos)->GetID());
 165   return IDs;
 166 }
 167
 168 bool WatchpointList::Remove(lldb::watch_id_t watch_id, bool notify) {
 169   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 170   wp_collection::iterator pos = GetIDIterator(watch_id);
 171   if (pos != m_watchpoints.end()) {
 172     WatchpointSP wp_sp = *pos;
 173     if (notify) {
 174       if (wp_sp->GetTarget().EventTypeHasListeners(
 175               Target::eBroadcastBitWatchpointChanged))
 176         wp_sp->GetTarget().BroadcastEvent(
 177             Target::eBroadcastBitWatchpointChanged,
 178             new Watchpoint::WatchpointEventData(eWatchpointEventTypeRemoved,
 179                                                 wp_sp));
 180     }
 181     m_watchpoints.erase(pos);
 182     return true;
 183   }
 184   return false;
 185 }
 186
 187 uint32_t WatchpointList::GetHitCount() const {
 188   uint32_t hit_count = 0;
 189   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 190   wp_collection::const_iterator pos, end = m_watchpoints.end();
 191   for (pos = m_watchpoints.begin(); pos != end; ++pos)
 192     hit_count += (*pos)->GetHitCount();
 193   return hit_count;
 194 }
 195
 196 bool WatchpointList::ShouldStop(StoppointCallbackContext *context,
 197                                 lldb::watch_id_t watch_id) {
 198
 199   WatchpointSP wp_sp = FindByID(watch_id);
 200   if (wp_sp) {
 201     // Let the Watchpoint decide if it should stop here (could not have reached
 202     // it's target hit count yet, or it could have a callback that decided it
 203     // shouldn't stop.
 204     return wp_sp->ShouldStop(context);
 205   }
 206   // We should stop here since this Watchpoint isn't valid anymore or it
 207   // doesn't exist.
 208   return true;
 209 }
 210
 211 void WatchpointList::GetDescription(Stream *s, lldb::DescriptionLevel level) {
 212   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 213   wp_collection::iterator pos, end = m_watchpoints.end();
 214
 215   for (pos = m_watchpoints.begin(); pos != end; ++pos) {
 216     s->Printf(" ");
 217     (*pos)->Dump(s);
 218   }
 219 }
 220
 221 void WatchpointList::SetEnabledAll(bool enabled) {
 222   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 223
 224   wp_collection::iterator pos, end = m_watchpoints.end();
 225   for (pos = m_watchpoints.begin(); pos != end; ++pos)
 226     (*pos)->SetEnabled(enabled);
 227 }
 228
 229 void WatchpointList::RemoveAll(bool notify) {
 230   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 231   if (notify) {
 232
 233     {
 234       wp_collection::iterator pos, end = m_watchpoints.end();
 235       for (pos = m_watchpoints.begin(); pos != end; ++pos) {
 236         if ((*pos)->GetTarget().EventTypeHasListeners(
 237                 Target::eBroadcastBitBreakpointChanged)) {
 238           (*pos)->GetTarget().BroadcastEvent(
 239               Target::eBroadcastBitWatchpointChanged,
 240               new Watchpoint::WatchpointEventData(eWatchpointEventTypeRemoved,
 241                                                   *pos));
 242         }
 243       }
 244     }
 245   }
 246   m_watchpoints.clear();
 247 }
 248
 249 void WatchpointList::GetListMutex(
 250     std::unique_lock<std::recursive_mutex> &lock) {
 251   lock = std::unique_lock<std::recursive_mutex>(m_mutex);
 252 }