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_next_id(0), m_new_location_recorder(nullptr) {}
24 
25 BreakpointLocationList::~BreakpointLocationList() = default;
26 
27 BreakpointLocationSP
28 BreakpointLocationList::Create(const Address &addr,
29                                bool resolve_indirect_symbols) {
30   std::lock_guard<std::recursive_mutex> guard(m_mutex);
31   // The location ID is just the size of the location list + 1
32   lldb::break_id_t bp_loc_id = ++m_next_id;
33   BreakpointLocationSP bp_loc_sp(
34       new BreakpointLocation(bp_loc_id, m_owner, addr, LLDB_INVALID_THREAD_ID,
35                              m_owner.IsHardware(), resolve_indirect_symbols));
36   m_locations.push_back(bp_loc_sp);
37   m_address_to_location[addr] = bp_loc_sp;
38   return bp_loc_sp;
39 }
40 
41 bool BreakpointLocationList::ShouldStop(StoppointCallbackContext *context,
42                                         lldb::break_id_t break_id) {
43   BreakpointLocationSP bp = FindByID(break_id);
44   if (bp) {
45     // Let the BreakpointLocation decide if it should stop here (could not have
46     // reached it's target hit count yet, or it could have a callback that
47     // decided it shouldn't stop (shared library loads/unloads).
48     return bp->ShouldStop(context);
49   }
50   // We should stop here since this BreakpointLocation isn't valid anymore or
51   // it doesn't exist.
52   return true;
53 }
54 
55 lldb::break_id_t BreakpointLocationList::FindIDByAddress(const Address &addr) {
56   BreakpointLocationSP bp_loc_sp = FindByAddress(addr);
57   if (bp_loc_sp) {
58     return bp_loc_sp->GetID();
59   }
60   return LLDB_INVALID_BREAK_ID;
61 }
62 
63 static bool Compare(BreakpointLocationSP lhs, lldb::break_id_t val) {
64   return lhs->GetID() < val;
65 }
66 
67 BreakpointLocationSP
68 BreakpointLocationList::FindByID(lldb::break_id_t break_id) const {
69   std::lock_guard<std::recursive_mutex> guard(m_mutex);
70   collection::const_iterator end = m_locations.end();
71   collection::const_iterator pos =
72       llvm::lower_bound(m_locations, break_id, Compare);
73   if (pos != end && (*pos)->GetID() == break_id)
74     return *(pos);
75   else
76     return BreakpointLocationSP();
77 }
78 
79 size_t BreakpointLocationList::FindInModule(
80     Module *module, BreakpointLocationCollection &bp_loc_list) {
81   std::lock_guard<std::recursive_mutex> guard(m_mutex);
82   const size_t orig_size = bp_loc_list.GetSize();
83   collection::iterator pos, end = m_locations.end();
84 
85   for (pos = m_locations.begin(); pos != end; ++pos) {
86     BreakpointLocationSP break_loc = (*pos);
87     SectionSP section_sp(break_loc->GetAddress().GetSection());
88     if (section_sp && section_sp->GetModule().get() == module) {
89       bp_loc_list.Add(break_loc);
90     }
91   }
92   return bp_loc_list.GetSize() - orig_size;
93 }
94 
95 const BreakpointLocationSP
96 BreakpointLocationList::FindByAddress(const Address &addr) const {
97   std::lock_guard<std::recursive_mutex> guard(m_mutex);
98   BreakpointLocationSP bp_loc_sp;
99   if (!m_locations.empty()) {
100     Address so_addr;
101 
102     if (addr.IsSectionOffset()) {
103       so_addr = addr;
104     } else {
105       // Try and resolve as a load address if possible.
106       m_owner.GetTarget().GetSectionLoadList().ResolveLoadAddress(
107           addr.GetOffset(), so_addr);
108       if (!so_addr.IsValid()) {
109         // The address didn't resolve, so just set to passed in addr.
110         so_addr = addr;
111       }
112     }
113 
114     addr_map::const_iterator pos = m_address_to_location.find(so_addr);
115     if (pos != m_address_to_location.end())
116       bp_loc_sp = pos->second;
117   }
118 
119   return bp_loc_sp;
120 }
121 
122 void BreakpointLocationList::Dump(Stream *s) const {
123   s->Printf("%p: ", static_cast<const void *>(this));
124   // s->Indent();
125   std::lock_guard<std::recursive_mutex> guard(m_mutex);
126   s->Printf("BreakpointLocationList with %" PRIu64 " BreakpointLocations:\n",
127             (uint64_t)m_locations.size());
128   s->IndentMore();
129   collection::const_iterator pos, end = m_locations.end();
130   for (pos = m_locations.begin(); pos != end; ++pos)
131     (*pos)->Dump(s);
132   s->IndentLess();
133 }
134 
135 BreakpointLocationSP BreakpointLocationList::GetByIndex(size_t i) {
136   std::lock_guard<std::recursive_mutex> guard(m_mutex);
137   BreakpointLocationSP bp_loc_sp;
138   if (i < m_locations.size())
139     bp_loc_sp = m_locations[i];
140 
141   return bp_loc_sp;
142 }
143 
144 const BreakpointLocationSP BreakpointLocationList::GetByIndex(size_t i) const {
145   std::lock_guard<std::recursive_mutex> guard(m_mutex);
146   BreakpointLocationSP bp_loc_sp;
147   if (i < m_locations.size())
148     bp_loc_sp = m_locations[i];
149 
150   return bp_loc_sp;
151 }
152 
153 void BreakpointLocationList::ClearAllBreakpointSites() {
154   std::lock_guard<std::recursive_mutex> guard(m_mutex);
155   collection::iterator pos, end = m_locations.end();
156   for (pos = m_locations.begin(); pos != end; ++pos)
157     (*pos)->ClearBreakpointSite();
158 }
159 
160 void BreakpointLocationList::ResolveAllBreakpointSites() {
161   std::lock_guard<std::recursive_mutex> guard(m_mutex);
162   collection::iterator pos, end = m_locations.end();
163 
164   for (pos = m_locations.begin(); pos != end; ++pos) {
165     if ((*pos)->IsEnabled())
166       (*pos)->ResolveBreakpointSite();
167   }
168 }
169 
170 uint32_t BreakpointLocationList::GetHitCount() const {
171   uint32_t hit_count = 0;
172   std::lock_guard<std::recursive_mutex> guard(m_mutex);
173   collection::const_iterator pos, end = m_locations.end();
174   for (pos = m_locations.begin(); pos != end; ++pos)
175     hit_count += (*pos)->GetHitCount();
176   return hit_count;
177 }
178 
179 void BreakpointLocationList::ResetHitCount() {
180   std::lock_guard<std::recursive_mutex> guard(m_mutex);
181   for (auto &loc : m_locations)
182     loc->ResetHitCount();
183 }
184 
185 size_t BreakpointLocationList::GetNumResolvedLocations() const {
186   std::lock_guard<std::recursive_mutex> guard(m_mutex);
187   size_t resolve_count = 0;
188   collection::const_iterator pos, end = m_locations.end();
189   for (pos = m_locations.begin(); pos != end; ++pos) {
190     if ((*pos)->IsResolved())
191       ++resolve_count;
192   }
193   return resolve_count;
194 }
195 
196 void BreakpointLocationList::GetDescription(Stream *s,
197                                             lldb::DescriptionLevel level) {
198   std::lock_guard<std::recursive_mutex> guard(m_mutex);
199   collection::iterator pos, end = m_locations.end();
200 
201   for (pos = m_locations.begin(); pos != end; ++pos) {
202     s->Printf(" ");
203     (*pos)->GetDescription(s, level);
204   }
205 }
206 
207 BreakpointLocationSP BreakpointLocationList::AddLocation(
208     const Address &addr, bool resolve_indirect_symbols, bool *new_location) {
209   std::lock_guard<std::recursive_mutex> guard(m_mutex);
210 
211   if (new_location)
212     *new_location = false;
213   BreakpointLocationSP bp_loc_sp(FindByAddress(addr));
214   if (!bp_loc_sp) {
215     bp_loc_sp = Create(addr, resolve_indirect_symbols);
216     if (bp_loc_sp) {
217       bp_loc_sp->ResolveBreakpointSite();
218 
219       if (new_location)
220         *new_location = true;
221       if (m_new_location_recorder) {
222         m_new_location_recorder->Add(bp_loc_sp);
223       }
224     }
225   }
226   return bp_loc_sp;
227 }
228 
229 void BreakpointLocationList::SwapLocation(
230     BreakpointLocationSP to_location_sp,
231     BreakpointLocationSP from_location_sp) {
232   if (!from_location_sp || !to_location_sp)
233     return;
234 
235   m_address_to_location.erase(to_location_sp->GetAddress());
236   to_location_sp->SwapLocation(from_location_sp);
237   RemoveLocation(from_location_sp);
238   m_address_to_location[to_location_sp->GetAddress()] = to_location_sp;
239   to_location_sp->ResolveBreakpointSite();
240 }
241 
242 bool BreakpointLocationList::RemoveLocation(
243     const lldb::BreakpointLocationSP &bp_loc_sp) {
244   if (bp_loc_sp) {
245     std::lock_guard<std::recursive_mutex> guard(m_mutex);
246 
247     m_address_to_location.erase(bp_loc_sp->GetAddress());
248 
249     size_t num_locations = m_locations.size();
250     for (size_t idx = 0; idx < num_locations; idx++) {
251       if (m_locations[idx].get() == bp_loc_sp.get()) {
252         RemoveLocationByIndex(idx);
253         return true;
254       }
255     }
256   }
257   return false;
258 }
259 
260 void BreakpointLocationList::RemoveLocationByIndex(size_t idx) {
261   assert (idx < m_locations.size());
262   m_address_to_location.erase(m_locations[idx]->GetAddress());
263   m_locations.erase(m_locations.begin() + idx);
264 }
265 
266 void BreakpointLocationList::RemoveInvalidLocations(const ArchSpec &arch) {
267   std::lock_guard<std::recursive_mutex> guard(m_mutex);
268   size_t idx = 0;
269   // Don't cache m_location.size() as it will change since we might remove
270   // locations from our vector...
271   while (idx < m_locations.size()) {
272     BreakpointLocation *bp_loc = m_locations[idx].get();
273     if (bp_loc->GetAddress().SectionWasDeleted()) {
274       // Section was deleted which means this breakpoint comes from a module
275       // that is no longer valid, so we should remove it.
276       RemoveLocationByIndex(idx);
277       continue;
278     }
279     if (arch.IsValid()) {
280       ModuleSP module_sp(bp_loc->GetAddress().GetModule());
281       if (module_sp) {
282         if (!arch.IsCompatibleMatch(module_sp->GetArchitecture())) {
283           // The breakpoint was in a module whose architecture is no longer
284           // compatible with "arch", so we need to remove it
285           RemoveLocationByIndex(idx);
286           continue;
287         }
288       }
289     }
290     // Only increment the index if we didn't remove the locations at index
291     // "idx"
292     ++idx;
293   }
294 }
295 
296 void BreakpointLocationList::StartRecordingNewLocations(
297     BreakpointLocationCollection &new_locations) {
298   std::lock_guard<std::recursive_mutex> guard(m_mutex);
299   assert(m_new_location_recorder == nullptr);
300   m_new_location_recorder = &new_locations;
301 }
302 
303 void BreakpointLocationList::StopRecordingNewLocations() {
304   std::lock_guard<std::recursive_mutex> guard(m_mutex);
305   m_new_location_recorder = nullptr;
306 }
307 
308 void BreakpointLocationList::Compact() {
309   lldb::break_id_t highest_id = 0;
310 
311   for (BreakpointLocationSP loc_sp : m_locations) {
312     lldb::break_id_t cur_id = loc_sp->GetID();
313     if (cur_id > highest_id)
314       highest_id = cur_id;
315   }
316   m_next_id = highest_id;
317 }
318