1 //===-- BreakpointLocationCollection.cpp ------------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "lldb/Breakpoint/BreakpointLocationCollection.h"
11 #include "lldb/Breakpoint/Breakpoint.h"
12 #include "lldb/Breakpoint/BreakpointLocation.h"
13 #include "lldb/Core/ModuleList.h"
14 #include "lldb/Target/Thread.h"
15 #include "lldb/Target/ThreadSpec.h"
16 
17 using namespace lldb;
18 using namespace lldb_private;
19 
20 //----------------------------------------------------------------------
21 // BreakpointLocationCollection constructor
22 //----------------------------------------------------------------------
23 BreakpointLocationCollection::BreakpointLocationCollection()
24     : m_break_loc_collection(), m_collection_mutex() {}
25 
26 //----------------------------------------------------------------------
27 // Destructor
28 //----------------------------------------------------------------------
29 BreakpointLocationCollection::~BreakpointLocationCollection() {}
30 
31 void BreakpointLocationCollection::Add(const BreakpointLocationSP &bp_loc) {
32   std::lock_guard<std::mutex> guard(m_collection_mutex);
33   BreakpointLocationSP old_bp_loc =
34       FindByIDPair(bp_loc->GetBreakpoint().GetID(), bp_loc->GetID());
35   if (!old_bp_loc.get())
36     m_break_loc_collection.push_back(bp_loc);
37 }
38 
39 bool BreakpointLocationCollection::Remove(lldb::break_id_t bp_id,
40                                           lldb::break_id_t bp_loc_id) {
41   std::lock_guard<std::mutex> guard(m_collection_mutex);
42   collection::iterator pos = GetIDPairIterator(bp_id, bp_loc_id); // Predicate
43   if (pos != m_break_loc_collection.end()) {
44     m_break_loc_collection.erase(pos);
45     return true;
46   }
47   return false;
48 }
49 
50 class BreakpointIDPairMatches {
51 public:
52   BreakpointIDPairMatches(lldb::break_id_t break_id,
53                           lldb::break_id_t break_loc_id)
54       : m_break_id(break_id), m_break_loc_id(break_loc_id) {}
55 
56   bool operator()(const BreakpointLocationSP &bp_loc) const {
57     return m_break_id == bp_loc->GetBreakpoint().GetID() &&
58            m_break_loc_id == bp_loc->GetID();
59   }
60 
61 private:
62   const lldb::break_id_t m_break_id;
63   const lldb::break_id_t m_break_loc_id;
64 };
65 
66 BreakpointLocationCollection::collection::iterator
67 BreakpointLocationCollection::GetIDPairIterator(lldb::break_id_t break_id,
68                                                 lldb::break_id_t break_loc_id) {
69   return std::find_if(
70       m_break_loc_collection.begin(),
71       m_break_loc_collection.end(),                     // Search full range
72       BreakpointIDPairMatches(break_id, break_loc_id)); // Predicate
73 }
74 
75 BreakpointLocationCollection::collection::const_iterator
76 BreakpointLocationCollection::GetIDPairConstIterator(
77     lldb::break_id_t break_id, lldb::break_id_t break_loc_id) const {
78   return std::find_if(
79       m_break_loc_collection.begin(),
80       m_break_loc_collection.end(),                     // Search full range
81       BreakpointIDPairMatches(break_id, break_loc_id)); // Predicate
82 }
83 
84 BreakpointLocationSP
85 BreakpointLocationCollection::FindByIDPair(lldb::break_id_t break_id,
86                                            lldb::break_id_t break_loc_id) {
87   BreakpointLocationSP stop_sp;
88   collection::iterator pos = GetIDPairIterator(break_id, break_loc_id);
89   if (pos != m_break_loc_collection.end())
90     stop_sp = *pos;
91 
92   return stop_sp;
93 }
94 
95 const BreakpointLocationSP BreakpointLocationCollection::FindByIDPair(
96     lldb::break_id_t break_id, lldb::break_id_t break_loc_id) const {
97   BreakpointLocationSP stop_sp;
98   collection::const_iterator pos =
99       GetIDPairConstIterator(break_id, break_loc_id);
100   if (pos != m_break_loc_collection.end())
101     stop_sp = *pos;
102 
103   return stop_sp;
104 }
105 
106 BreakpointLocationSP BreakpointLocationCollection::GetByIndex(size_t i) {
107   std::lock_guard<std::mutex> guard(m_collection_mutex);
108   BreakpointLocationSP stop_sp;
109   if (i < m_break_loc_collection.size())
110     stop_sp = m_break_loc_collection[i];
111 
112   return stop_sp;
113 }
114 
115 const BreakpointLocationSP
116 BreakpointLocationCollection::GetByIndex(size_t i) const {
117   std::lock_guard<std::mutex> guard(m_collection_mutex);
118   BreakpointLocationSP stop_sp;
119   if (i < m_break_loc_collection.size())
120     stop_sp = m_break_loc_collection[i];
121 
122   return stop_sp;
123 }
124 
125 bool BreakpointLocationCollection::ShouldStop(
126     StoppointCallbackContext *context) {
127   bool shouldStop = false;
128   size_t i = 0;
129   size_t prev_size = GetSize();
130   while (i < prev_size) {
131     // ShouldStop can remove the breakpoint from the list
132     if (GetByIndex(i)->ShouldStop(context))
133       shouldStop = true;
134 
135     if (prev_size == GetSize())
136       i++;
137     prev_size = GetSize();
138   }
139   return shouldStop;
140 }
141 
142 bool BreakpointLocationCollection::ValidForThisThread(Thread *thread) {
143   std::lock_guard<std::mutex> guard(m_collection_mutex);
144   collection::iterator pos, begin = m_break_loc_collection.begin(),
145                             end = m_break_loc_collection.end();
146 
147   for (pos = begin; pos != end; ++pos) {
148     if ((*pos)->ValidForThisThread(thread))
149       return true;
150   }
151   return false;
152 }
153 
154 bool BreakpointLocationCollection::IsInternal() const {
155   std::lock_guard<std::mutex> guard(m_collection_mutex);
156   collection::const_iterator pos, begin = m_break_loc_collection.begin(),
157                                   end = m_break_loc_collection.end();
158 
159   bool is_internal = true;
160 
161   for (pos = begin; pos != end; ++pos) {
162     if (!(*pos)->GetBreakpoint().IsInternal()) {
163       is_internal = false;
164       break;
165     }
166   }
167   return is_internal;
168 }
169 
170 void BreakpointLocationCollection::GetDescription(
171     Stream *s, lldb::DescriptionLevel level) {
172   std::lock_guard<std::mutex> guard(m_collection_mutex);
173   collection::iterator pos, begin = m_break_loc_collection.begin(),
174                             end = m_break_loc_collection.end();
175 
176   for (pos = begin; pos != end; ++pos) {
177     if (pos != begin)
178       s->PutChar(' ');
179     (*pos)->GetDescription(s, level);
180   }
181 }
182