contrib/llvm/tools/lldb/source/Breakpoint/BreakpointIDList.cpp

   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 }