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