1//===-- BreakpointLocationList.cpp ------------------------------*- C++ -*-===//
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
19using namespace lldb;
20using namespace lldb_private;
21
22BreakpointLocationList::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
26BreakpointLocationList::~BreakpointLocationList() = default;
27
28BreakpointLocationSP
29BreakpointLocationList::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
42bool 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
56lldb::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
64static bool Compare(BreakpointLocationSP lhs, lldb::break_id_t val) {
65  return lhs->GetID() < val;
66}
67
68BreakpointLocationSP
69BreakpointLocationList::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
80size_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
96const BreakpointLocationSP
97BreakpointLocationList::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
123void 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
136BreakpointLocationSP 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
145const 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
154void 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
161void 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
171uint32_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
180size_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
191void 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
202BreakpointLocationSP 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
224void 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
237bool 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
255void 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
261void 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
291void 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
298void BreakpointLocationList::StopRecordingNewLocations() {
299  std::lock_guard<std::recursive_mutex> guard(m_mutex);
300  m_new_location_recorder = nullptr;
301}
302
303void 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