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