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