LLDB mainline
BreakpointLocationCollection.cpp
Go to the documentation of this file.
1//===-- BreakpointLocationCollection.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
13#include "lldb/Target/Thread.h"
15
16using namespace lldb;
17using namespace lldb_private;
18
19// BreakpointLocationCollection constructor
21
22// Destructor
24
26 std::lock_guard<std::mutex> guard(m_collection_mutex);
27 BreakpointLocationSP old_bp_loc =
28 FindByIDPair(bp_loc->GetBreakpoint().GetID(), bp_loc->GetID());
29 if (!old_bp_loc.get())
30 m_break_loc_collection.push_back(bp_loc);
31}
32
34 lldb::break_id_t bp_loc_id) {
35 std::lock_guard<std::mutex> guard(m_collection_mutex);
36 collection::iterator pos = GetIDPairIterator(bp_id, bp_loc_id); // Predicate
37 if (pos != m_break_loc_collection.end()) {
38 m_break_loc_collection.erase(pos);
39 return true;
40 }
41 return false;
42}
43
45public:
47 lldb::break_id_t break_loc_id)
48 : m_break_id(break_id), m_break_loc_id(break_loc_id) {}
49
50 bool operator()(const BreakpointLocationSP &bp_loc) const {
51 return m_break_id == bp_loc->GetBreakpoint().GetID() &&
52 m_break_loc_id == bp_loc->GetID();
53 }
54
55private:
58};
59
60BreakpointLocationCollection::collection::iterator
62 lldb::break_id_t break_loc_id) {
63 return llvm::find_if(
64 m_break_loc_collection, // Search full range
65 BreakpointIDPairMatches(break_id, break_loc_id)); // Predicate
66}
67
68BreakpointLocationCollection::collection::const_iterator
70 lldb::break_id_t break_id, lldb::break_id_t break_loc_id) const {
71 return llvm::find_if(
72 m_break_loc_collection, // Search full range
73 BreakpointIDPairMatches(break_id, break_loc_id)); // Predicate
74}
75
78 lldb::break_id_t break_loc_id) {
80 collection::iterator pos = GetIDPairIterator(break_id, break_loc_id);
81 if (pos != m_break_loc_collection.end())
82 stop_sp = *pos;
83
84 return stop_sp;
85}
86
88 lldb::break_id_t break_id, lldb::break_id_t break_loc_id) const {
90 collection::const_iterator pos =
91 GetIDPairConstIterator(break_id, break_loc_id);
92 if (pos != m_break_loc_collection.end())
93 stop_sp = *pos;
94
95 return stop_sp;
96}
97
99 std::lock_guard<std::mutex> guard(m_collection_mutex);
100 BreakpointLocationSP stop_sp;
101 if (i < m_break_loc_collection.size())
102 stop_sp = m_break_loc_collection[i];
103
104 return stop_sp;
105}
106
109 std::lock_guard<std::mutex> guard(m_collection_mutex);
110 BreakpointLocationSP stop_sp;
111 if (i < m_break_loc_collection.size())
112 stop_sp = m_break_loc_collection[i];
113
114 return stop_sp;
115}
116
118 StoppointCallbackContext *context) {
119 bool shouldStop = false;
120 size_t i = 0;
121 size_t prev_size = GetSize();
122 while (i < prev_size) {
123 // ShouldStop can remove the breakpoint from the list, or even delete
124 // it, so we should
125 BreakpointLocationSP cur_loc_sp = GetByIndex(i);
126 BreakpointSP keep_bkpt_alive_sp = cur_loc_sp->GetBreakpoint().shared_from_this();
127 if (cur_loc_sp->ShouldStop(context))
128 shouldStop = true;
129
130 if (prev_size == GetSize())
131 i++;
132 prev_size = GetSize();
133 }
134 return shouldStop;
135}
136
138 std::lock_guard<std::mutex> guard(m_collection_mutex);
139 collection::iterator pos, begin = m_break_loc_collection.begin(),
140 end = m_break_loc_collection.end();
141
142 for (pos = begin; pos != end; ++pos) {
143 if ((*pos)->ValidForThisThread(thread))
144 return true;
145 }
146 return false;
147}
148
150 std::lock_guard<std::mutex> guard(m_collection_mutex);
151 collection::const_iterator pos, begin = m_break_loc_collection.begin(),
152 end = m_break_loc_collection.end();
153
154 bool is_internal = true;
155
156 for (pos = begin; pos != end; ++pos) {
157 if (!(*pos)->GetBreakpoint().IsInternal()) {
158 is_internal = false;
159 break;
160 }
161 }
162 return is_internal;
163}
164
166 Stream *s, lldb::DescriptionLevel level) {
167 std::lock_guard<std::mutex> guard(m_collection_mutex);
168 collection::iterator pos, begin = m_break_loc_collection.begin(),
169 end = m_break_loc_collection.end();
170
171 for (pos = begin; pos != end; ++pos) {
172 if (pos != begin)
173 s->PutChar(' ');
174 (*pos)->GetDescription(s, level);
175 }
176}
177
179 const BreakpointLocationCollection &rhs) {
180 if (this != &rhs) {
182 std::lock_guard<std::mutex> lhs_guard(m_collection_mutex, std::adopt_lock);
183 std::lock_guard<std::mutex> rhs_guard(rhs.m_collection_mutex, std::adopt_lock);
185 }
186 return *this;
187}
BreakpointIDPairMatches(lldb::break_id_t break_id, lldb::break_id_t break_loc_id)
bool operator()(const BreakpointLocationSP &bp_loc) const
lldb::BreakpointLocationSP FindByIDPair(lldb::break_id_t break_id, lldb::break_id_t break_loc_id)
Returns a shared pointer to the breakpoint location with id breakID.
void GetDescription(Stream *s, lldb::DescriptionLevel level)
Print a description of the breakpoint locations in this list to the stream s.
bool IsInternal() const
Tell whether ALL the breakpoints in the location collection are internal.
bool ValidForThisThread(Thread &thread)
Check whether this collection of breakpoint locations have any thread specifiers, and if yes,...
collection::const_iterator GetIDPairConstIterator(lldb::break_id_t break_id, lldb::break_id_t break_loc_id) const
BreakpointLocationCollection & operator=(const BreakpointLocationCollection &rhs)
collection::iterator GetIDPairIterator(lldb::break_id_t break_id, lldb::break_id_t break_loc_id)
bool ShouldStop(StoppointCallbackContext *context)
Enquires of all the breakpoint locations in this list whether we should stop at a hit at breakID.
lldb::BreakpointLocationSP GetByIndex(size_t i)
Returns a shared pointer to the breakpoint location with index i.
void Add(const lldb::BreakpointLocationSP &bp_loc_sp)
Add the breakpoint bp_loc_sp to the list.
bool Remove(lldb::break_id_t break_id, lldb::break_id_t break_loc_id)
Removes the breakpoint location given by breakID from this list.
size_t GetSize() const
Returns the number of elements in this breakpoint location list.
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 PutChar(char ch)
Definition Stream.cpp:131
A class that represents a running process on the host machine.
std::shared_ptr< lldb_private::BreakpointLocation > BreakpointLocationSP
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
std::shared_ptr< lldb_private::Breakpoint > BreakpointSP
int32_t break_id_t
Definition lldb-types.h:86