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 // 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 }