1 //===-- BreakpointIDList.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 // C Includes
11 // C++ Includes
12 // Other libraries and framework includes
13 // Project includes
14 #include "lldb/lldb-enumerations.h"
15 #include "lldb/Breakpoint/BreakpointIDList.h"
16 
17 #include "lldb/Breakpoint/Breakpoint.h"
18 #include "lldb/Breakpoint/BreakpointLocation.h"
19 #include "lldb/Interpreter/Args.h"
20 #include "lldb/Interpreter/CommandReturnObject.h"
21 #include "lldb/Target/Target.h"
22 
23 using namespace lldb;
24 using namespace lldb_private;
25 
26 //----------------------------------------------------------------------
27 // class BreakpointIDList
28 //----------------------------------------------------------------------
29 
30 BreakpointIDList::BreakpointIDList()
31     : m_invalid_id(LLDB_INVALID_BREAK_ID, LLDB_INVALID_BREAK_ID) {}
32 
33 BreakpointIDList::~BreakpointIDList() = default;
34 
35 size_t BreakpointIDList::GetSize() const { return m_breakpoint_ids.size(); }
36 
37 const BreakpointID &
38 BreakpointIDList::GetBreakpointIDAtIndex(size_t index) const {
39   return ((index < m_breakpoint_ids.size()) ? m_breakpoint_ids[index]
40                                             : m_invalid_id);
41 }
42 
43 bool BreakpointIDList::RemoveBreakpointIDAtIndex(size_t index) {
44   if (index >= m_breakpoint_ids.size())
45     return false;
46 
47   m_breakpoint_ids.erase(m_breakpoint_ids.begin() + index);
48   return true;
49 }
50 
51 void BreakpointIDList::Clear() { m_breakpoint_ids.clear(); }
52 
53 bool BreakpointIDList::AddBreakpointID(BreakpointID bp_id) {
54   m_breakpoint_ids.push_back(bp_id);
55 
56   return true; // We don't do any verification in this function, so always
57                // return true.
58 }
59 
60 bool BreakpointIDList::AddBreakpointID(const char *bp_id_str) {
61   auto bp_id = BreakpointID::ParseCanonicalReference(bp_id_str);
62   if (!bp_id.hasValue())
63     return false;
64 
65   m_breakpoint_ids.push_back(*bp_id);
66   return true;
67 }
68 
69 bool BreakpointIDList::FindBreakpointID(BreakpointID &bp_id,
70                                         size_t *position) const {
71   for (size_t i = 0; i < m_breakpoint_ids.size(); ++i) {
72     BreakpointID tmp_id = m_breakpoint_ids[i];
73     if (tmp_id.GetBreakpointID() == bp_id.GetBreakpointID() &&
74         tmp_id.GetLocationID() == bp_id.GetLocationID()) {
75       *position = i;
76       return true;
77     }
78   }
79 
80   return false;
81 }
82 
83 bool BreakpointIDList::FindBreakpointID(const char *bp_id_str,
84                                         size_t *position) const {
85   auto bp_id = BreakpointID::ParseCanonicalReference(bp_id_str);
86   if (!bp_id.hasValue())
87     return false;
88 
89   return FindBreakpointID(*bp_id, position);
90 }
91 
92 void BreakpointIDList::InsertStringArray(const char **string_array,
93                                          size_t array_size,
94                                          CommandReturnObject &result) {
95   if (string_array == nullptr)
96     return;
97 
98   for (uint32_t i = 0; i < array_size; ++i) {
99     auto bp_id = BreakpointID::ParseCanonicalReference(string_array[i]);
100     if (bp_id.hasValue())
101       m_breakpoint_ids.push_back(*bp_id);
102   }
103   result.SetStatus(eReturnStatusSuccessFinishNoResult);
104 }
105 
106 //  This function takes OLD_ARGS, which is usually the result of breaking the
107 //  command string arguments into
108 //  an array of space-separated strings, and searches through the arguments for
109 //  any breakpoint ID range specifiers.
110 //  Any string in the array that is not part of an ID range specifier is copied
111 //  directly into NEW_ARGS.  If any
112 //  ID range specifiers are found, the range is interpreted and a list of
113 //  canonical breakpoint IDs corresponding to
114 //  all the current breakpoints and locations in the range are added to
115 //  NEW_ARGS.  When this function is done,
116 //  NEW_ARGS should be a copy of OLD_ARGS, with and ID range specifiers replaced
117 //  by the members of the range.
118 
119 void BreakpointIDList::FindAndReplaceIDRanges(Args &old_args, Target *target,
120                                               bool allow_locations,
121                                               BreakpointName::Permissions
122                                                   ::PermissionKinds purpose,
123                                               CommandReturnObject &result,
124                                               Args &new_args) {
125   llvm::StringRef range_from;
126   llvm::StringRef range_to;
127   llvm::StringRef current_arg;
128   std::set<std::string> names_found;
129 
130   for (size_t i = 0; i < old_args.size(); ++i) {
131     bool is_range = false;
132 
133     current_arg = old_args[i].ref;
134     if (!allow_locations && current_arg.contains('.')) {
135       result.AppendErrorWithFormat(
136           "Breakpoint locations not allowed, saw location: %s.",
137           current_arg.str().c_str());
138       new_args.Clear();
139       return;
140     }
141 
142     Status error;
143 
144     std::tie(range_from, range_to) =
145         BreakpointIDList::SplitIDRangeExpression(current_arg);
146     if (!range_from.empty() && !range_to.empty()) {
147       is_range = true;
148     } else if (BreakpointID::StringIsBreakpointName(current_arg, error)) {
149       if (!error.Success()) {
150         new_args.Clear();
151         result.AppendError(error.AsCString());
152         result.SetStatus(eReturnStatusFailed);
153         return;
154       } else
155         names_found.insert(current_arg);
156     } else if ((i + 2 < old_args.size()) &&
157                BreakpointID::IsRangeIdentifier(old_args[i + 1].ref) &&
158                BreakpointID::IsValidIDExpression(current_arg) &&
159                BreakpointID::IsValidIDExpression(old_args[i + 2].ref)) {
160       range_from = current_arg;
161       range_to = old_args[i + 2].ref;
162       is_range = true;
163       i = i + 2;
164     } else {
165       // See if user has specified id.*
166       llvm::StringRef tmp_str = old_args[i].ref;
167       size_t pos = tmp_str.find('.');
168       if (pos != llvm::StringRef::npos) {
169         llvm::StringRef bp_id_str = tmp_str.substr(0, pos);
170         if (BreakpointID::IsValidIDExpression(bp_id_str) &&
171             tmp_str[pos + 1] == '*' && tmp_str.size() == (pos + 2)) {
172 
173           BreakpointSP breakpoint_sp;
174           auto bp_id = BreakpointID::ParseCanonicalReference(bp_id_str);
175           if (bp_id.hasValue())
176             breakpoint_sp = target->GetBreakpointByID(bp_id->GetBreakpointID());
177           if (!breakpoint_sp) {
178             new_args.Clear();
179             result.AppendErrorWithFormat("'%d' is not a valid breakpoint ID.\n",
180                                          bp_id->GetBreakpointID());
181             result.SetStatus(eReturnStatusFailed);
182             return;
183           }
184           const size_t num_locations = breakpoint_sp->GetNumLocations();
185           for (size_t j = 0; j < num_locations; ++j) {
186             BreakpointLocation *bp_loc =
187                 breakpoint_sp->GetLocationAtIndex(j).get();
188             StreamString canonical_id_str;
189             BreakpointID::GetCanonicalReference(
190                 &canonical_id_str, bp_id->GetBreakpointID(), bp_loc->GetID());
191             new_args.AppendArgument(canonical_id_str.GetString());
192           }
193         }
194       }
195     }
196 
197     if (!is_range) {
198       new_args.AppendArgument(current_arg);
199       continue;
200     }
201 
202     auto start_bp = BreakpointID::ParseCanonicalReference(range_from);
203     auto end_bp = BreakpointID::ParseCanonicalReference(range_to);
204 
205     if (!start_bp.hasValue() ||
206         !target->GetBreakpointByID(start_bp->GetBreakpointID())) {
207       new_args.Clear();
208       result.AppendErrorWithFormat("'%s' is not a valid breakpoint ID.\n",
209                                    range_from.str().c_str());
210       result.SetStatus(eReturnStatusFailed);
211       return;
212     }
213 
214     if (!end_bp.hasValue() ||
215         !target->GetBreakpointByID(end_bp->GetBreakpointID())) {
216       new_args.Clear();
217       result.AppendErrorWithFormat("'%s' is not a valid breakpoint ID.\n",
218                                    range_to.str().c_str());
219       result.SetStatus(eReturnStatusFailed);
220       return;
221     }
222     break_id_t start_bp_id = start_bp->GetBreakpointID();
223     break_id_t start_loc_id = start_bp->GetLocationID();
224     break_id_t end_bp_id = end_bp->GetBreakpointID();
225     break_id_t end_loc_id = end_bp->GetLocationID();
226     if (((start_loc_id == LLDB_INVALID_BREAK_ID) &&
227             (end_loc_id != LLDB_INVALID_BREAK_ID)) ||
228         ((start_loc_id != LLDB_INVALID_BREAK_ID) &&
229          (end_loc_id == LLDB_INVALID_BREAK_ID))) {
230       new_args.Clear();
231       result.AppendErrorWithFormat("Invalid breakpoint id range:  Either "
232                                    "both ends of range must specify"
233                                    " a breakpoint location, or neither can "
234                                    "specify a breakpoint location.\n");
235       result.SetStatus(eReturnStatusFailed);
236       return;
237     }
238 
239     // We have valid range starting & ending breakpoint IDs.  Go through all
240     // the breakpoints in the target and find all the breakpoints that fit
241     // into this range, and add them to new_args.
242 
243     // Next check to see if we have location id's.  If so, make sure the
244     // start_bp_id and end_bp_id are for the same breakpoint; otherwise we
245     // have an illegal range: breakpoint id ranges that specify bp locations
246     // are NOT allowed to cross major bp id numbers.
247 
248     if ((start_loc_id != LLDB_INVALID_BREAK_ID) ||
249         (end_loc_id != LLDB_INVALID_BREAK_ID)) {
250       if (start_bp_id != end_bp_id) {
251         new_args.Clear();
252         result.AppendErrorWithFormat(
253             "Invalid range: Ranges that specify particular breakpoint "
254             "locations"
255             " must be within the same major breakpoint; you specified two"
256             " different major breakpoints, %d and %d.\n",
257             start_bp_id, end_bp_id);
258         result.SetStatus(eReturnStatusFailed);
259         return;
260       }
261     }
262 
263     const BreakpointList &breakpoints = target->GetBreakpointList();
264     const size_t num_breakpoints = breakpoints.GetSize();
265     for (size_t j = 0; j < num_breakpoints; ++j) {
266       Breakpoint *breakpoint = breakpoints.GetBreakpointAtIndex(j).get();
267       break_id_t cur_bp_id = breakpoint->GetID();
268 
269       if ((cur_bp_id < start_bp_id) || (cur_bp_id > end_bp_id))
270         continue;
271 
272       const size_t num_locations = breakpoint->GetNumLocations();
273 
274       if ((cur_bp_id == start_bp_id) &&
275           (start_loc_id != LLDB_INVALID_BREAK_ID)) {
276         for (size_t k = 0; k < num_locations; ++k) {
277           BreakpointLocation *bp_loc = breakpoint->GetLocationAtIndex(k).get();
278           if ((bp_loc->GetID() >= start_loc_id) &&
279               (bp_loc->GetID() <= end_loc_id)) {
280             StreamString canonical_id_str;
281             BreakpointID::GetCanonicalReference(&canonical_id_str, cur_bp_id,
282                                                 bp_loc->GetID());
283             new_args.AppendArgument(canonical_id_str.GetString());
284           }
285         }
286       } else if ((cur_bp_id == end_bp_id) &&
287                  (end_loc_id != LLDB_INVALID_BREAK_ID)) {
288         for (size_t k = 0; k < num_locations; ++k) {
289           BreakpointLocation *bp_loc = breakpoint->GetLocationAtIndex(k).get();
290           if (bp_loc->GetID() <= end_loc_id) {
291             StreamString canonical_id_str;
292             BreakpointID::GetCanonicalReference(&canonical_id_str, cur_bp_id,
293                                                 bp_loc->GetID());
294             new_args.AppendArgument(canonical_id_str.GetString());
295           }
296         }
297       } else {
298         StreamString canonical_id_str;
299         BreakpointID::GetCanonicalReference(&canonical_id_str, cur_bp_id,
300                                             LLDB_INVALID_BREAK_ID);
301         new_args.AppendArgument(canonical_id_str.GetString());
302       }
303     }
304   }
305 
306   // Okay, now see if we found any names, and if we did, add them:
307   if (target && !names_found.empty()) {
308     Status error;
309     // Remove any names that aren't visible for this purpose:
310     auto iter = names_found.begin();
311     while (iter != names_found.end()) {
312       BreakpointName *bp_name = target->FindBreakpointName(ConstString(*iter),
313                                                            true,
314                                                            error);
315       if (bp_name && !bp_name->GetPermission(purpose))
316         iter = names_found.erase(iter);
317       else
318         iter++;
319     }
320 
321     if (!names_found.empty()) {
322       for (BreakpointSP bkpt_sp : target->GetBreakpointList().Breakpoints()) {
323         for (std::string name : names_found) {
324           if (bkpt_sp->MatchesName(name.c_str())) {
325             StreamString canonical_id_str;
326             BreakpointID::GetCanonicalReference(
327                 &canonical_id_str, bkpt_sp->GetID(), LLDB_INVALID_BREAK_ID);
328             new_args.AppendArgument(canonical_id_str.GetString());
329           }
330         }
331       }
332     }
333   }
334 
335   result.SetStatus(eReturnStatusSuccessFinishNoResult);
336 }
337 
338 std::pair<llvm::StringRef, llvm::StringRef>
339 BreakpointIDList::SplitIDRangeExpression(llvm::StringRef in_string) {
340   for (auto specifier_str : BreakpointID::GetRangeSpecifiers()) {
341     size_t idx = in_string.find(specifier_str);
342     if (idx == llvm::StringRef::npos)
343       continue;
344     llvm::StringRef right1 = in_string.drop_front(idx);
345 
346     llvm::StringRef from = in_string.take_front(idx);
347     llvm::StringRef to = right1.drop_front(specifier_str.size());
348 
349     if (BreakpointID::IsValidIDExpression(from) &&
350         BreakpointID::IsValidIDExpression(to)) {
351       return std::make_pair(from, to);
352     }
353   }
354 
355   return std::pair<llvm::StringRef, llvm::StringRef>();
356 }
357