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