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 
9 #include "lldb/Breakpoint/BreakpointLocationList.h"
10 
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"
18 
19 using namespace lldb;
20 using namespace lldb_private;
21 
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) {}
25 
26 BreakpointLocationList::~BreakpointLocationList() = default;
27 
28 BreakpointLocationSP
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;
39   return bp_loc_sp;
40 }
41 
42 bool BreakpointLocationList::ShouldStop(StoppointCallbackContext *context,
43                                         lldb::break_id_t break_id) {
44   BreakpointLocationSP bp = FindByID(break_id);
45   if (bp) {
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);
50   }
51   // We should stop here since this BreakpointLocation isn't valid anymore or
52   // it doesn't exist.
53   return true;
54 }
55 
56 lldb::break_id_t BreakpointLocationList::FindIDByAddress(const Address &addr) {
57   BreakpointLocationSP bp_loc_sp = FindByAddress(addr);
58   if (bp_loc_sp) {
59     return bp_loc_sp->GetID();
60   }
61   return LLDB_INVALID_BREAK_ID;
62 }
63 
64 static bool Compare(BreakpointLocationSP lhs, lldb::break_id_t val) {
65   return lhs->GetID() < val;
66 }
67 
68 BreakpointLocationSP
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)
75     return *(pos);
76   else
77     return BreakpointLocationSP();
78 }
79 
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();
85 
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);
91     }
92   }
93   return bp_loc_list.GetSize() - orig_size;
94 }
95 
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()) {
101     Address so_addr;
102 
103     if (addr.IsSectionOffset()) {
104       so_addr = addr;
105     } else {
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.
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 
123 void BreakpointLocationList::Dump(Stream *s) const {
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 
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];
141 
142   return bp_loc_sp;
143 }
144 
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];
150 
151   return bp_loc_sp;
152 }
153 
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();
159 }
160 
161 void BreakpointLocationList::ResolveAllBreakpointSites() {
162   std::lock_guard<std::recursive_mutex> guard(m_mutex);
163   collection::iterator pos, end = m_locations.end();
164 
165   for (pos = m_locations.begin(); pos != end; ++pos) {
166     if ((*pos)->IsEnabled())
167       (*pos)->ResolveBreakpointSite();
168   }
169 }
170 
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();
177   return hit_count;
178 }
179 
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())
186       ++resolve_count;
187   }
188   return resolve_count;
189 }
190 
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();
195 
196   for (pos = m_locations.begin(); pos != end; ++pos) {
197     s->Printf(" ");
198     (*pos)->GetDescription(s, level);
199   }
200 }
201 
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);
205 
206   if (new_location)
207     *new_location = false;
208   BreakpointLocationSP bp_loc_sp(FindByAddress(addr));
209   if (!bp_loc_sp) {
210     bp_loc_sp = Create(addr, resolve_indirect_symbols);
211     if (bp_loc_sp) {
212       bp_loc_sp->ResolveBreakpointSite();
213 
214       if (new_location)
215         *new_location = true;
216       if (m_new_location_recorder) {
217         m_new_location_recorder->Add(bp_loc_sp);
218       }
219     }
220   }
221   return bp_loc_sp;
222 }
223 
224 void BreakpointLocationList::SwapLocation(
225     BreakpointLocationSP to_location_sp,
226     BreakpointLocationSP from_location_sp) {
227   if (!from_location_sp || !to_location_sp)
228     return;
229 
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();
235 }
236 
237 bool BreakpointLocationList::RemoveLocation(
238     const lldb::BreakpointLocationSP &bp_loc_sp) {
239   if (bp_loc_sp) {
240     std::lock_guard<std::recursive_mutex> guard(m_mutex);
241 
242     m_address_to_location.erase(bp_loc_sp->GetAddress());
243 
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);
248         return true;
249       }
250     }
251   }
252   return false;
253 }
254 
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);
259 }
260 
261 void BreakpointLocationList::RemoveInvalidLocations(const ArchSpec &arch) {
262   std::lock_guard<std::recursive_mutex> guard(m_mutex);
263   size_t idx = 0;
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);
272       continue;
273     }
274     if (arch.IsValid()) {
275       ModuleSP module_sp(bp_loc->GetAddress().GetModule());
276       if (module_sp) {
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);
281           continue;
282         }
283       }
284     }
285     // Only increment the index if we didn't remove the locations at index
286     // "idx"
287     ++idx;
288   }
289 }
290 
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;
296 }
297 
298 void BreakpointLocationList::StopRecordingNewLocations() {
299   std::lock_guard<std::recursive_mutex> guard(m_mutex);
300   m_new_location_recorder = nullptr;
301 }
302 
303 void BreakpointLocationList::Compact() {
304   lldb::break_id_t highest_id = 0;
305 
306   for (BreakpointLocationSP loc_sp : m_locations) {
307     lldb::break_id_t cur_id = loc_sp->GetID();
308     if (cur_id > highest_id)
309       highest_id = cur_id;
310   }
311   m_next_id = highest_id;
312 }
313