1 //===-- BreakpointLocationList.cpp ----------------------------------------===//
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
7 //===----------------------------------------------------------------------===//
9 #include "lldb/Breakpoint/BreakpointLocationList.h"
11 #include "lldb/Breakpoint/Breakpoint.h"
12 #include "lldb/Breakpoint/BreakpointLocation.h"
13 #include "lldb/Core/Module.h"
14 #include "lldb/Core/Section.h"
15 #include "lldb/Target/SectionLoadList.h"
16 #include "lldb/Target/Target.h"
17 #include "lldb/Utility/ArchSpec.h"
20 using namespace lldb_private;
22 BreakpointLocationList::BreakpointLocationList(Breakpoint &owner)
23 : m_owner(owner), m_locations(), m_address_to_location(), m_mutex(),
24 m_next_id(0), m_new_location_recorder(nullptr) {}
26 BreakpointLocationList::~BreakpointLocationList() = default;
29 BreakpointLocationList::Create(const Address &addr,
30 bool resolve_indirect_symbols) {
31 std::lock_guard<std::recursive_mutex> guard(m_mutex);
32 // The location ID is just the size of the location list + 1
33 lldb::break_id_t bp_loc_id = ++m_next_id;
34 BreakpointLocationSP bp_loc_sp(
35 new BreakpointLocation(bp_loc_id, m_owner, addr, LLDB_INVALID_THREAD_ID,
36 m_owner.IsHardware(), resolve_indirect_symbols));
37 m_locations.push_back(bp_loc_sp);
38 m_address_to_location[addr] = bp_loc_sp;
42 bool BreakpointLocationList::ShouldStop(StoppointCallbackContext *context,
43 lldb::break_id_t break_id) {
44 BreakpointLocationSP bp = FindByID(break_id);
46 // Let the BreakpointLocation decide if it should stop here (could not have
47 // reached it's target hit count yet, or it could have a callback that
48 // decided it shouldn't stop (shared library loads/unloads).
49 return bp->ShouldStop(context);
51 // We should stop here since this BreakpointLocation isn't valid anymore or
56 lldb::break_id_t BreakpointLocationList::FindIDByAddress(const Address &addr) {
57 BreakpointLocationSP bp_loc_sp = FindByAddress(addr);
59 return bp_loc_sp->GetID();
61 return LLDB_INVALID_BREAK_ID;
64 static bool Compare(BreakpointLocationSP lhs, lldb::break_id_t val) {
65 return lhs->GetID() < val;
69 BreakpointLocationList::FindByID(lldb::break_id_t break_id) const {
70 std::lock_guard<std::recursive_mutex> guard(m_mutex);
71 collection::const_iterator end = m_locations.end();
72 collection::const_iterator pos =
73 std::lower_bound(m_locations.begin(), end, break_id, Compare);
74 if (pos != end && (*pos)->GetID() == break_id)
77 return BreakpointLocationSP();
80 size_t BreakpointLocationList::FindInModule(
81 Module *module, BreakpointLocationCollection &bp_loc_list) {
82 std::lock_guard<std::recursive_mutex> guard(m_mutex);
83 const size_t orig_size = bp_loc_list.GetSize();
84 collection::iterator pos, end = m_locations.end();
86 for (pos = m_locations.begin(); pos != end; ++pos) {
87 BreakpointLocationSP break_loc = (*pos);
88 SectionSP section_sp(break_loc->GetAddress().GetSection());
89 if (section_sp && section_sp->GetModule().get() == module) {
90 bp_loc_list.Add(break_loc);
93 return bp_loc_list.GetSize() - orig_size;
96 const BreakpointLocationSP
97 BreakpointLocationList::FindByAddress(const Address &addr) const {
98 std::lock_guard<std::recursive_mutex> guard(m_mutex);
99 BreakpointLocationSP bp_loc_sp;
100 if (!m_locations.empty()) {
103 if (addr.IsSectionOffset()) {
106 // Try and resolve as a load address if possible.
107 m_owner.GetTarget().GetSectionLoadList().ResolveLoadAddress(
108 addr.GetOffset(), so_addr);
109 if (!so_addr.IsValid()) {
110 // The address didn't resolve, so just set to passed in addr.
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;
123 void BreakpointLocationList::Dump(Stream *s) const {
124 s->Printf("%p: ", static_cast<const void *>(this));
126 std::lock_guard<std::recursive_mutex> guard(m_mutex);
127 s->Printf("BreakpointLocationList with %" PRIu64 " BreakpointLocations:\n",
128 (uint64_t)m_locations.size());
130 collection::const_iterator pos, end = m_locations.end();
131 for (pos = m_locations.begin(); pos != end; ++pos)
136 BreakpointLocationSP BreakpointLocationList::GetByIndex(size_t i) {
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];
145 const BreakpointLocationSP BreakpointLocationList::GetByIndex(size_t i) const {
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];
154 void BreakpointLocationList::ClearAllBreakpointSites() {
155 std::lock_guard<std::recursive_mutex> guard(m_mutex);
156 collection::iterator pos, end = m_locations.end();
157 for (pos = m_locations.begin(); pos != end; ++pos)
158 (*pos)->ClearBreakpointSite();
161 void BreakpointLocationList::ResolveAllBreakpointSites() {
162 std::lock_guard<std::recursive_mutex> guard(m_mutex);
163 collection::iterator pos, end = m_locations.end();
165 for (pos = m_locations.begin(); pos != end; ++pos) {
166 if ((*pos)->IsEnabled())
167 (*pos)->ResolveBreakpointSite();
171 uint32_t BreakpointLocationList::GetHitCount() const {
172 uint32_t hit_count = 0;
173 std::lock_guard<std::recursive_mutex> guard(m_mutex);
174 collection::const_iterator pos, end = m_locations.end();
175 for (pos = m_locations.begin(); pos != end; ++pos)
176 hit_count += (*pos)->GetHitCount();
180 size_t BreakpointLocationList::GetNumResolvedLocations() const {
181 std::lock_guard<std::recursive_mutex> guard(m_mutex);
182 size_t resolve_count = 0;
183 collection::const_iterator pos, end = m_locations.end();
184 for (pos = m_locations.begin(); pos != end; ++pos) {
185 if ((*pos)->IsResolved())
188 return resolve_count;
191 void BreakpointLocationList::GetDescription(Stream *s,
192 lldb::DescriptionLevel level) {
193 std::lock_guard<std::recursive_mutex> guard(m_mutex);
194 collection::iterator pos, end = m_locations.end();
196 for (pos = m_locations.begin(); pos != end; ++pos) {
198 (*pos)->GetDescription(s, level);
202 BreakpointLocationSP BreakpointLocationList::AddLocation(
203 const Address &addr, bool resolve_indirect_symbols, bool *new_location) {
204 std::lock_guard<std::recursive_mutex> guard(m_mutex);
207 *new_location = false;
208 BreakpointLocationSP bp_loc_sp(FindByAddress(addr));
210 bp_loc_sp = Create(addr, resolve_indirect_symbols);
212 bp_loc_sp->ResolveBreakpointSite();
215 *new_location = true;
216 if (m_new_location_recorder) {
217 m_new_location_recorder->Add(bp_loc_sp);
224 void BreakpointLocationList::SwapLocation(
225 BreakpointLocationSP to_location_sp,
226 BreakpointLocationSP from_location_sp) {
227 if (!from_location_sp || !to_location_sp)
230 m_address_to_location.erase(to_location_sp->GetAddress());
231 to_location_sp->SwapLocation(from_location_sp);
232 RemoveLocation(from_location_sp);
233 m_address_to_location[to_location_sp->GetAddress()] = to_location_sp;
234 to_location_sp->ResolveBreakpointSite();
237 bool BreakpointLocationList::RemoveLocation(
238 const lldb::BreakpointLocationSP &bp_loc_sp) {
240 std::lock_guard<std::recursive_mutex> guard(m_mutex);
242 m_address_to_location.erase(bp_loc_sp->GetAddress());
244 size_t num_locations = m_locations.size();
245 for (size_t idx = 0; idx < num_locations; idx++) {
246 if (m_locations[idx].get() == bp_loc_sp.get()) {
247 RemoveLocationByIndex(idx);
255 void BreakpointLocationList::RemoveLocationByIndex(size_t idx) {
256 assert (idx < m_locations.size());
257 m_address_to_location.erase(m_locations[idx]->GetAddress());
258 m_locations.erase(m_locations.begin() + idx);
261 void BreakpointLocationList::RemoveInvalidLocations(const ArchSpec &arch) {
262 std::lock_guard<std::recursive_mutex> guard(m_mutex);
264 // Don't cache m_location.size() as it will change since we might remove
265 // locations from our vector...
266 while (idx < m_locations.size()) {
267 BreakpointLocation *bp_loc = m_locations[idx].get();
268 if (bp_loc->GetAddress().SectionWasDeleted()) {
269 // Section was deleted which means this breakpoint comes from a module
270 // that is no longer valid, so we should remove it.
271 RemoveLocationByIndex(idx);
274 if (arch.IsValid()) {
275 ModuleSP module_sp(bp_loc->GetAddress().GetModule());
277 if (!arch.IsCompatibleMatch(module_sp->GetArchitecture())) {
278 // The breakpoint was in a module whose architecture is no longer
279 // compatible with "arch", so we need to remove it
280 RemoveLocationByIndex(idx);
285 // Only increment the index if we didn't remove the locations at index
291 void BreakpointLocationList::StartRecordingNewLocations(
292 BreakpointLocationCollection &new_locations) {
293 std::lock_guard<std::recursive_mutex> guard(m_mutex);
294 assert(m_new_location_recorder == nullptr);
295 m_new_location_recorder = &new_locations;
298 void BreakpointLocationList::StopRecordingNewLocations() {
299 std::lock_guard<std::recursive_mutex> guard(m_mutex);
300 m_new_location_recorder = nullptr;
303 void BreakpointLocationList::Compact() {
304 lldb::break_id_t highest_id = 0;
306 for (BreakpointLocationSP loc_sp : m_locations) {
307 lldb::break_id_t cur_id = loc_sp->GetID();
308 if (cur_id > highest_id)
311 m_next_id = highest_id;