LLDB mainline
BreakpointLocationList.cpp
Go to the documentation of this file.
1//===-- BreakpointLocationList.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
10
13#include "lldb/Core/Module.h"
14#include "lldb/Core/Section.h"
16#include "lldb/Target/Target.h"
19#include "lldb/Utility/Log.h"
20
21using namespace lldb;
22using namespace lldb_private;
23
26
28
31 bool resolve_indirect_symbols) {
32 std::lock_guard<std::recursive_mutex> guard(m_mutex);
33 // The location ID is just the size of the location list + 1
34 lldb::break_id_t bp_loc_id = ++m_next_id;
35 BreakpointLocationSP bp_loc_sp(
37 resolve_indirect_symbols));
38 m_locations.push_back(bp_loc_sp);
39 m_address_to_location[addr] = bp_loc_sp;
40 return bp_loc_sp;
41}
42
44 lldb::break_id_t break_id,
45 lldb::BreakpointLocationSP &bp_loc_sp) {
46 BreakpointLocationSP bp = FindByID(break_id);
47 if (bp) {
48 // Let the BreakpointLocation decide if it should stop here (could not have
49 // reached it's target hit count yet, or it could have a callback that
50 // decided it shouldn't stop (shared library loads/unloads).
51 return bp->ShouldStop(context, bp_loc_sp);
52 }
53 // We should stop here since this BreakpointLocation isn't valid anymore or
54 // it doesn't exist.
55 return true;
56}
57
59 BreakpointLocationSP bp_loc_sp = FindByAddress(addr);
60 if (bp_loc_sp) {
61 return bp_loc_sp->GetID();
62 }
64}
65
67 return lhs->GetID() < val;
68}
69
72 std::lock_guard<std::recursive_mutex> guard(m_mutex);
73 collection::const_iterator end = m_locations.end();
74 collection::const_iterator pos =
75 llvm::lower_bound(m_locations, break_id, Compare);
76 if (pos != end && (*pos)->GetID() == break_id)
77 return *(pos);
78 return BreakpointLocationSP();
79}
80
82 Module *module, BreakpointLocationCollection &bp_loc_list) {
83 std::lock_guard<std::recursive_mutex> guard(m_mutex);
84 const size_t orig_size = bp_loc_list.GetSize();
85 collection::iterator pos, end = m_locations.end();
86
87 for (pos = m_locations.begin(); pos != end; ++pos) {
88 BreakpointLocationSP break_loc = (*pos);
89 SectionSP section_sp(break_loc->GetAddress().GetSection());
90 if (section_sp && section_sp->GetModule().get() == module) {
91 bp_loc_list.Add(break_loc);
92 }
93 }
94 return bp_loc_list.GetSize() - orig_size;
95}
96
99 std::lock_guard<std::recursive_mutex> guard(m_mutex);
100 BreakpointLocationSP bp_loc_sp;
101 if (!m_locations.empty()) {
102 Address so_addr;
103
104 if (addr.IsSectionOffset()) {
105 so_addr = addr;
106 } else {
107 // Try and resolve as a load address if possible.
108 m_owner.GetTarget().ResolveLoadAddress(addr.GetOffset(), so_addr);
109 if (!so_addr.IsValid()) {
110 // The address didn't resolve, so just set to passed in addr.
111 so_addr = addr;
112 }
113 }
114
115 addr_map::const_iterator pos = m_address_to_location.find(so_addr);
116 if (pos != m_address_to_location.end())
117 bp_loc_sp = pos->second;
118 }
119
120 return bp_loc_sp;
121}
122
124 s->Printf("%p: ", static_cast<const void *>(this));
125 // s->Indent();
126 std::lock_guard<std::recursive_mutex> guard(m_mutex);
127 s->Printf("BreakpointLocationList with %" PRIu64 " BreakpointLocations:\n",
128 (uint64_t)m_locations.size());
129 s->IndentMore();
130 collection::const_iterator pos, end = m_locations.end();
131 for (pos = m_locations.begin(); pos != end; ++pos)
132 (*pos)->Dump(s);
133 s->IndentLess();
134}
135
137 std::lock_guard<std::recursive_mutex> guard(m_mutex);
138 BreakpointLocationSP bp_loc_sp;
139 if (i < m_locations.size())
140 bp_loc_sp = m_locations[i];
141
142 return bp_loc_sp;
143}
144
146 std::lock_guard<std::recursive_mutex> guard(m_mutex);
147 BreakpointLocationSP bp_loc_sp;
148 if (i < m_locations.size())
149 bp_loc_sp = m_locations[i];
150
151 return bp_loc_sp;
152}
153
155 std::lock_guard<std::recursive_mutex> guard(m_mutex);
156 collection::iterator pos, end = m_locations.end();
158
159 for (pos = m_locations.begin(); pos != end; ++pos) {
160 if (llvm::Error error = (*pos)->ClearBreakpointSite())
161 LLDB_LOG_ERROR(log, std::move(error), "{0}");
162 }
163}
164
166 std::lock_guard<std::recursive_mutex> guard(m_mutex);
167 collection::iterator pos, end = m_locations.end();
169
170 for (pos = m_locations.begin(); pos != end; ++pos) {
171 if ((*pos)->IsEnabled()) {
172 if (llvm::Error error = (*pos)->ResolveBreakpointSite())
173 LLDB_LOG_ERROR(log, std::move(error), "{0}");
174 }
175 }
176}
177
179 uint32_t hit_count = 0;
180 std::lock_guard<std::recursive_mutex> guard(m_mutex);
181 collection::const_iterator pos, end = m_locations.end();
182 for (pos = m_locations.begin(); pos != end; ++pos)
183 hit_count += (*pos)->GetHitCount();
184 return hit_count;
185}
186
188 std::lock_guard<std::recursive_mutex> guard(m_mutex);
189 for (auto &loc : m_locations)
190 loc->ResetHitCount();
191}
192
194 std::lock_guard<std::recursive_mutex> guard(m_mutex);
195 size_t resolve_count = 0;
196 collection::const_iterator pos, end = m_locations.end();
197 for (pos = m_locations.begin(); pos != end; ++pos) {
198 if ((*pos)->IsResolved())
199 ++resolve_count;
200 }
201 return resolve_count;
202}
203
206 std::lock_guard<std::recursive_mutex> guard(m_mutex);
207 collection::iterator pos, end = m_locations.end();
208
209 for (pos = m_locations.begin(); pos != end; ++pos) {
210 s->Printf(" ");
211 (*pos)->GetDescription(s, level);
212 }
213}
214
216 const Address &addr, bool resolve_indirect_symbols, bool *new_location) {
217 std::lock_guard<std::recursive_mutex> guard(m_mutex);
218
219 if (new_location)
220 *new_location = false;
221 BreakpointLocationSP bp_loc_sp(FindByAddress(addr));
222 if (!bp_loc_sp) {
223 bp_loc_sp = Create(addr, resolve_indirect_symbols);
224 if (bp_loc_sp) {
225 if (llvm::Error error = bp_loc_sp->ResolveBreakpointSite())
226 LLDB_LOG_ERROR(GetLog(LLDBLog::Breakpoints), std::move(error), "{0}");
227
228 if (new_location)
229 *new_location = true;
231 m_new_location_recorder->Add(bp_loc_sp);
232 }
233 }
234 }
235 return bp_loc_sp;
236}
237
239 BreakpointLocationSP to_location_sp,
240 BreakpointLocationSP from_location_sp) {
241 if (!from_location_sp || !to_location_sp)
242 return;
243
244 m_address_to_location.erase(to_location_sp->GetAddress());
245 to_location_sp->SwapLocation(from_location_sp);
246 RemoveLocation(from_location_sp);
247 m_address_to_location[to_location_sp->GetAddress()] = to_location_sp;
248 llvm::consumeError(to_location_sp->ResolveBreakpointSite());
249}
250
252 const lldb::BreakpointLocationSP &bp_loc_sp) {
253 if (bp_loc_sp) {
254 std::lock_guard<std::recursive_mutex> guard(m_mutex);
255
256 m_address_to_location.erase(bp_loc_sp->GetAddress());
257
258 size_t num_locations = m_locations.size();
259 for (size_t idx = 0; idx < num_locations; idx++) {
260 if (m_locations[idx].get() == bp_loc_sp.get()) {
262 return true;
263 }
264 }
265 }
266 return false;
267}
268
270 assert (idx < m_locations.size());
271 m_address_to_location.erase(m_locations[idx]->GetAddress());
272 m_locations.erase(m_locations.begin() + idx);
273}
274
276 std::lock_guard<std::recursive_mutex> guard(m_mutex);
277 size_t idx = 0;
278 // Don't cache m_location.size() as it will change since we might remove
279 // locations from our vector...
280 while (idx < m_locations.size()) {
281 BreakpointLocation *bp_loc = m_locations[idx].get();
282 if (bp_loc->GetAddress().SectionWasDeleted()) {
283 // Section was deleted which means this breakpoint comes from a module
284 // that is no longer valid, so we should remove it.
286 continue;
287 }
288 if (arch.IsValid()) {
289 ModuleSP module_sp(bp_loc->GetAddress().GetModule());
290 if (module_sp) {
291 if (!arch.IsCompatibleMatch(module_sp->GetArchitecture())) {
292 // The breakpoint was in a module whose architecture is no longer
293 // compatible with "arch", so we need to remove it
295 continue;
296 }
297 }
298 }
299 // Only increment the index if we didn't remove the locations at index
300 // "idx"
301 ++idx;
302 }
303}
304
306 BreakpointLocationCollection &new_locations) {
307 std::lock_guard<std::recursive_mutex> guard(m_mutex);
308 assert(m_new_location_recorder == nullptr);
309 m_new_location_recorder = &new_locations;
310}
311
313 std::lock_guard<std::recursive_mutex> guard(m_mutex);
314 m_new_location_recorder = nullptr;
315}
316
318 lldb::break_id_t highest_id = 0;
319
320 for (BreakpointLocationSP loc_sp : m_locations) {
321 lldb::break_id_t cur_id = loc_sp->GetID();
322 if (cur_id > highest_id)
323 highest_id = cur_id;
324 }
325 m_next_id = highest_id;
326}
static bool Compare(BreakpointLocationSP lhs, lldb::break_id_t val)
static llvm::raw_ostream & error(Stream &strm)
#define LLDB_LOG_ERROR(log, error,...)
Definition Log.h:392
A section + offset based address class.
Definition Address.h:62
bool SectionWasDeleted() const
Definition Address.cpp:800
lldb::ModuleSP GetModule() const
Get accessor for the module for this address.
Definition Address.cpp:273
lldb::addr_t GetOffset() const
Get the section relative offset value.
Definition Address.h:329
bool IsValid() const
Check if the object state is valid.
Definition Address.h:355
bool IsSectionOffset() const
Check if an address is section offset.
Definition Address.h:342
An architecture specification class.
Definition ArchSpec.h:31
bool IsValid() const
Tests if this ArchSpec is valid.
Definition ArchSpec.h:366
bool IsCompatibleMatch(const ArchSpec &rhs) const
Shorthand for IsMatch(rhs, CompatibleMatch).
Definition ArchSpec.h:520
void Add(const lldb::BreakpointLocationSP &bp_loc_sp)
Add the breakpoint bp_loc_sp to the list.
size_t GetSize() const
Returns the number of elements in this breakpoint location list.
void ResetHitCount()
Resets the hit count of all locations in this list.
void GetDescription(Stream *s, lldb::DescriptionLevel level)
Print a description of the breakpoint locations in this list to the stream s.
void RemoveInvalidLocations(const ArchSpec &arch)
lldb::BreakpointLocationSP GetByIndex(size_t i)
Returns a shared pointer to the breakpoint location with index i.
bool RemoveLocation(const lldb::BreakpointLocationSP &bp_loc_sp)
void Dump(Stream *s) const
Standard "Dump" method. At present it does nothing.
void ClearAllBreakpointSites()
Removes all the locations in this list from their breakpoint site owners list.
uint32_t GetHitCount() const
Returns the number hit count of all locations in this list.
bool ShouldStop(StoppointCallbackContext *context, lldb::break_id_t breakID, lldb::BreakpointLocationSP &bp_loc_sp)
Enquires of the breakpoint location in this list with ID breakID whether we should stop.
const lldb::BreakpointLocationSP FindByAddress(const Address &addr) const
Returns a shared pointer to the breakpoint location at address addr - const version.
void ResolveAllBreakpointSites()
Tells all the breakpoint locations in this list to attempt to resolve any possible breakpoint sites.
size_t FindInModule(Module *module, BreakpointLocationCollection &bp_loc_list)
Returns a breakpoint location list of the breakpoint locations in the module module.
BreakpointLocationList(Breakpoint &owner)
This is the standard constructor.
BreakpointLocationCollection * m_new_location_recorder
lldb::BreakpointLocationSP FindByID(lldb::break_id_t breakID) const
Returns a shared pointer to the breakpoint location with id breakID, const version.
lldb::BreakpointLocationSP Create(const Address &addr, bool resolve_indirect_symbols)
lldb::BreakpointLocationSP AddLocation(const Address &addr, bool resolve_indirect_symbols, bool *new_location=nullptr)
void StartRecordingNewLocations(BreakpointLocationCollection &new_locations)
lldb::break_id_t FindIDByAddress(const Address &addr)
Returns the breakpoint location id to the breakpoint location at address addr.
size_t GetNumResolvedLocations() const
Returns the number of breakpoint locations in this list with resolved breakpoints.
void SwapLocation(lldb::BreakpointLocationSP to_location_sp, lldb::BreakpointLocationSP from_location_sp)
General Outline: A breakpoint location is defined by the breakpoint that produces it,...
Address & GetAddress()
Gets the Address for this breakpoint location.
A class that describes an executable image and its associated object and symbol files.
Definition Module.h:90
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:134
void IndentLess(unsigned amount=2)
Decrement the current indentation level.
Definition Stream.cpp:198
void IndentMore(unsigned amount=2)
Increment the current indentation level.
Definition Stream.cpp:195
#define LLDB_INVALID_BREAK_ID
#define LLDB_INVALID_THREAD_ID
A class that represents a running process on the host machine.
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition Log.h:332
std::shared_ptr< lldb_private::BreakpointLocation > BreakpointLocationSP
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
int32_t break_id_t
Definition lldb-types.h:86
std::shared_ptr< lldb_private::Section > SectionSP
std::shared_ptr< lldb_private::Module > ModuleSP