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.
Add(const WatchpointSP & wp_sp,bool notify)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 auto data_sp = std::make_shared<Watchpoint::WatchpointEventData>(
28 eWatchpointEventTypeAdded, wp_sp);
29 wp_sp->GetTarget().BroadcastEvent(Target::eBroadcastBitWatchpointChanged,
30 data_sp);
31 }
32 }
33 return wp_sp->GetID();
34 }
35
Dump(Stream * s) const36 void WatchpointList::Dump(Stream *s) const {
37 DumpWithLevel(s, lldb::eDescriptionLevelBrief);
38 }
39
DumpWithLevel(Stream * s,lldb::DescriptionLevel description_level) const40 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
FindByAddress(lldb::addr_t addr) const54 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
FindBySpec(std::string spec) const72 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:
WatchpointIDMatches(lldb::watch_id_t watch_id)89 WatchpointIDMatches(lldb::watch_id_t watch_id) : m_watch_id(watch_id) {}
90
operator ()(const WatchpointSP & wp) const91 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
GetIDIterator(lldb::watch_id_t watch_id)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
GetIDConstIterator(lldb::watch_id_t watch_id) const107 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
FindByID(lldb::watch_id_t watch_id) const113 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
FindIDByAddress(lldb::addr_t addr)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
FindIDBySpec(std::string spec)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
GetByIndex(uint32_t i)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
GetByIndex(uint32_t i) const150 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
GetWatchpointIDs() const161 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
Remove(lldb::watch_id_t watch_id,bool notify)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 auto data_sp = std::make_shared<Watchpoint::WatchpointEventData>(
178 eWatchpointEventTypeRemoved, wp_sp);
179 wp_sp->GetTarget().BroadcastEvent(
180 Target::eBroadcastBitWatchpointChanged, data_sp);
181 }
182 }
183 m_watchpoints.erase(pos);
184 return true;
185 }
186 return false;
187 }
188
GetHitCount() const189 uint32_t WatchpointList::GetHitCount() const {
190 uint32_t hit_count = 0;
191 std::lock_guard<std::recursive_mutex> guard(m_mutex);
192 wp_collection::const_iterator pos, end = m_watchpoints.end();
193 for (pos = m_watchpoints.begin(); pos != end; ++pos)
194 hit_count += (*pos)->GetHitCount();
195 return hit_count;
196 }
197
ShouldStop(StoppointCallbackContext * context,lldb::watch_id_t watch_id)198 bool WatchpointList::ShouldStop(StoppointCallbackContext *context,
199 lldb::watch_id_t watch_id) {
200
201 WatchpointSP wp_sp = FindByID(watch_id);
202 if (wp_sp) {
203 // Let the Watchpoint decide if it should stop here (could not have reached
204 // it's target hit count yet, or it could have a callback that decided it
205 // shouldn't stop.
206 return wp_sp->ShouldStop(context);
207 }
208 // We should stop here since this Watchpoint isn't valid anymore or it
209 // doesn't exist.
210 return true;
211 }
212
GetDescription(Stream * s,lldb::DescriptionLevel level)213 void WatchpointList::GetDescription(Stream *s, lldb::DescriptionLevel level) {
214 std::lock_guard<std::recursive_mutex> guard(m_mutex);
215 wp_collection::iterator pos, end = m_watchpoints.end();
216
217 for (pos = m_watchpoints.begin(); pos != end; ++pos) {
218 s->Printf(" ");
219 (*pos)->Dump(s);
220 }
221 }
222
SetEnabledAll(bool enabled)223 void WatchpointList::SetEnabledAll(bool enabled) {
224 std::lock_guard<std::recursive_mutex> guard(m_mutex);
225
226 wp_collection::iterator pos, end = m_watchpoints.end();
227 for (pos = m_watchpoints.begin(); pos != end; ++pos)
228 (*pos)->SetEnabled(enabled);
229 }
230
RemoveAll(bool notify)231 void WatchpointList::RemoveAll(bool notify) {
232 std::lock_guard<std::recursive_mutex> guard(m_mutex);
233 if (notify) {
234
235 {
236 wp_collection::iterator pos, end = m_watchpoints.end();
237 for (pos = m_watchpoints.begin(); pos != end; ++pos) {
238 if ((*pos)->GetTarget().EventTypeHasListeners(
239 Target::eBroadcastBitBreakpointChanged)) {
240 auto data_sp = std::make_shared<Watchpoint::WatchpointEventData>(
241 eWatchpointEventTypeRemoved, *pos);
242 (*pos)->GetTarget().BroadcastEvent(
243 Target::eBroadcastBitWatchpointChanged, data_sp);
244 }
245 }
246 }
247 }
248 m_watchpoints.clear();
249 }
250
GetListMutex(std::unique_lock<std::recursive_mutex> & lock)251 void WatchpointList::GetListMutex(
252 std::unique_lock<std::recursive_mutex> &lock) {
253 lock = std::unique_lock<std::recursive_mutex>(m_mutex);
254 }
255