LLDB mainline
WatchpointList.cpp
Go to the documentation of this file.
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
11
12using namespace lldb;
13using namespace lldb_private;
14
16
18
19// Add a watchpoint to the list.
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(
27 wp_sp->GetTarget().BroadcastEvent(Target::eBroadcastBitWatchpointChanged,
29 eWatchpointEventTypeAdded, wp_sp));
30 }
31 return wp_sp->GetID();
32}
33
36}
37
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
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
70const 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
86public:
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
93private:
95};
96
97WatchpointList::wp_collection::iterator
99 return std::find_if(m_watchpoints.begin(),
100 m_watchpoints.end(), // Search full range
101 WatchpointIDMatches(watch_id)); // Predicate
102}
103
104WatchpointList::wp_collection::const_iterator
106 return std::find_if(m_watchpoints.begin(),
107 m_watchpoints.end(), // Search full range
108 WatchpointIDMatches(watch_id)); // Predicate
109}
110
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
122 WatchpointSP wp_sp = FindByAddress(addr);
123 if (wp_sp) {
124 return wp_sp->GetID();
125 }
127}
128
130 WatchpointSP wp_sp = FindBySpec(spec);
131 if (wp_sp) {
132 return wp_sp->GetID();
133 }
135}
136
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
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
159std::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
167bool 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(
175 wp_sp->GetTarget().BroadcastEvent(
177 new Watchpoint::WatchpointEventData(eWatchpointEventTypeRemoved,
178 wp_sp));
179 }
180 m_watchpoints.erase(pos);
181 return true;
182 }
183 return false;
184}
185
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
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
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
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
228void 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(
237 (*pos)->GetTarget().BroadcastEvent(
239 new Watchpoint::WatchpointEventData(eWatchpointEventTypeRemoved,
240 *pos));
241 }
242 }
243 }
244 }
245 m_watchpoints.clear();
246}
247
249 std::unique_lock<std::recursive_mutex> &lock) {
250 lock = std::unique_lock<std::recursive_mutex>(m_mutex);
251}
WatchpointIDMatches(lldb::watch_id_t watch_id)
bool operator()(const WatchpointSP &wp) const
const lldb::watch_id_t m_watch_id
General Outline: When we hit a breakpoint we need to package up whatever information is needed to eva...
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:107
void IndentLess(unsigned amount=2)
Decrement the current indentation level.
Definition: Stream.cpp:171
void IndentMore(unsigned amount=2)
Increment the current indentation level.
Definition: Stream.cpp:168
@ eBroadcastBitWatchpointChanged
Definition: Target.h:493
@ eBroadcastBitBreakpointChanged
Definition: Target.h:490
lldb::WatchpointSP GetByIndex(uint32_t i)
Returns a shared pointer to the watchpoint with index i.
void GetDescription(Stream *s, lldb::DescriptionLevel level)
Print a description of the watchpoints in this list to the stream s.
lldb::watch_id_t Add(const lldb::WatchpointSP &wp_sp, bool notify)
Add a Watchpoint to the list.
void SetEnabledAll(bool enabled)
lldb::watch_id_t FindIDBySpec(std::string spec)
Returns the watchpoint id to the watchpoint with watchpoint spec spec.
id_vector GetWatchpointIDs() const
lldb::WatchpointSP FindByID(lldb::watch_id_t watchID) const
Returns a shared pointer to the watchpoint with id watchID, const version.
const lldb::WatchpointSP FindBySpec(std::string spec) const
Returns a shared pointer to the watchpoint with watchpoint spec spec.
WatchpointList()
Default constructor makes an empty list.
std::recursive_mutex m_mutex
bool ShouldStop(StoppointCallbackContext *context, lldb::watch_id_t watchID)
Enquires of the watchpoint in this list with ID watchID whether we should stop.
lldb::watch_id_t FindIDByAddress(lldb::addr_t addr)
Returns the watchpoint id to the watchpoint at address addr.
wp_collection::iterator GetIDIterator(lldb::watch_id_t watchID)
void GetListMutex(std::unique_lock< std::recursive_mutex > &lock)
Sets the passed in Locker to hold the Watchpoint List mutex.
uint32_t GetHitCount() const
Returns the number hit count of all watchpoints in this list.
void Dump(Stream *s) const
Standard "Dump" method.
bool Remove(lldb::watch_id_t watchID, bool notify)
Removes the watchpoint given by watchID from this list.
~WatchpointList()
Destructor, currently does nothing.
wp_collection::const_iterator GetIDConstIterator(lldb::watch_id_t watchID) const
const lldb::WatchpointSP FindByAddress(lldb::addr_t addr) const
Returns a shared pointer to the watchpoint at address addr - const version.
void DumpWithLevel(Stream *s, lldb::DescriptionLevel description_level) const
Dump with lldb::DescriptionLevel.
#define LLDB_INVALID_WATCH_ID
Definition: lldb-defines.h:43
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
Definition: SBAddress.h:15
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
@ eDescriptionLevelBrief
std::shared_ptr< lldb_private::Watchpoint > WatchpointSP
Definition: lldb-forward.h:472
int32_t watch_id_t
Definition: lldb-types.h:85
uint64_t addr_t
Definition: lldb-types.h:79