maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/lldb/source/Breakpoint/BreakpointIDList.cpp

356 lines
13 KiB
C++
Raw Blame History

//===-- BreakpointIDList.cpp ------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/lldb-enumerations.h"
#include "lldb/Breakpoint/BreakpointIDList.h"
#include "lldb/Breakpoint/Breakpoint.h"
#include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Target/Target.h"
#include "lldb/Utility/Args.h"
using namespace lldb;
using namespace lldb_private;
//----------------------------------------------------------------------
// class BreakpointIDList
//----------------------------------------------------------------------
BreakpointIDList::BreakpointIDList()
: m_invalid_id(LLDB_INVALID_BREAK_ID, LLDB_INVALID_BREAK_ID) {}
BreakpointIDList::~BreakpointIDList() = default;
size_t BreakpointIDList::GetSize() const { return m_breakpoint_ids.size(); }
const BreakpointID &
BreakpointIDList::GetBreakpointIDAtIndex(size_t index) const {
return ((index < m_breakpoint_ids.size()) ? m_breakpoint_ids[index]
: m_invalid_id);
}
bool BreakpointIDList::RemoveBreakpointIDAtIndex(size_t index) {
if (index >= m_breakpoint_ids.size())
return false;
m_breakpoint_ids.erase(m_breakpoint_ids.begin() + index);
return true;
}
void BreakpointIDList::Clear() { m_breakpoint_ids.clear(); }
bool BreakpointIDList::AddBreakpointID(BreakpointID bp_id) {
m_breakpoint_ids.push_back(bp_id);
return true; // We don't do any verification in this function, so always
// return true.
}
bool BreakpointIDList::AddBreakpointID(const char *bp_id_str) {
auto bp_id = BreakpointID::ParseCanonicalReference(bp_id_str);
if (!bp_id.hasValue())
return false;
m_breakpoint_ids.push_back(*bp_id);
return true;
}
bool BreakpointIDList::FindBreakpointID(BreakpointID &bp_id,
size_t *position) const {
for (size_t i = 0; i < m_breakpoint_ids.size(); ++i) {
BreakpointID tmp_id = m_breakpoint_ids[i];
if (tmp_id.GetBreakpointID() == bp_id.GetBreakpointID() &&
tmp_id.GetLocationID() == bp_id.GetLocationID()) {
*position = i;
return true;
}
}
return false;
}
bool BreakpointIDList::FindBreakpointID(const char *bp_id_str,
size_t *position) const {
auto bp_id = BreakpointID::ParseCanonicalReference(bp_id_str);
if (!bp_id.hasValue())
return false;
return FindBreakpointID(*bp_id, position);
}
void BreakpointIDList::InsertStringArray(
llvm::ArrayRef<const char *> string_array, CommandReturnObject &result) {
if(string_array.empty())
return;
for (const char *str : string_array) {
auto bp_id = BreakpointID::ParseCanonicalReference(str);
if (bp_id.hasValue())
m_breakpoint_ids.push_back(*bp_id);
}
result.SetStatus(eReturnStatusSuccessFinishNoResult);
}
// This function takes OLD_ARGS, which is usually the result of breaking the
// command string arguments into
// an array of space-separated strings, and searches through the arguments for
// any breakpoint ID range specifiers.
// Any string in the array that is not part of an ID range specifier is copied
// directly into NEW_ARGS. If any
// ID range specifiers are found, the range is interpreted and a list of
// canonical breakpoint IDs corresponding to
// all the current breakpoints and locations in the range are added to
// NEW_ARGS. When this function is done,
// NEW_ARGS should be a copy of OLD_ARGS, with and ID range specifiers replaced
// by the members of the range.
void BreakpointIDList::FindAndReplaceIDRanges(Args &old_args, Target *target,
bool allow_locations,
BreakpointName::Permissions
::PermissionKinds purpose,
CommandReturnObject &result,
Args &new_args) {
llvm::StringRef range_from;
llvm::StringRef range_to;
llvm::StringRef current_arg;
std::set<std::string> names_found;
for (size_t i = 0; i < old_args.size(); ++i) {
bool is_range = false;
current_arg = old_args[i].ref;
if (!allow_locations && current_arg.contains('.')) {
result.AppendErrorWithFormat(
"Breakpoint locations not allowed, saw location: %s.",
current_arg.str().c_str());
new_args.Clear();
return;
}
Status error;
std::tie(range_from, range_to) =
BreakpointIDList::SplitIDRangeExpression(current_arg);
if (!range_from.empty() && !range_to.empty()) {
is_range = true;
} else if (BreakpointID::StringIsBreakpointName(current_arg, error)) {
if (!error.Success()) {
new_args.Clear();
result.AppendError(error.AsCString());
result.SetStatus(eReturnStatusFailed);
return;
} else
names_found.insert(current_arg);
} else if ((i + 2 < old_args.size()) &&
BreakpointID::IsRangeIdentifier(old_args[i + 1].ref) &&
BreakpointID::IsValidIDExpression(current_arg) &&
BreakpointID::IsValidIDExpression(old_args[i + 2].ref)) {
range_from = current_arg;
range_to = old_args[i + 2].ref;
is_range = true;
i = i + 2;
} else {
// See if user has specified id.*
llvm::StringRef tmp_str = old_args[i].ref;
size_t pos = tmp_str.find('.');
if (pos != llvm::StringRef::npos) {
llvm::StringRef bp_id_str = tmp_str.substr(0, pos);
if (BreakpointID::IsValidIDExpression(bp_id_str) &&
tmp_str[pos + 1] == '*' && tmp_str.size() == (pos + 2)) {
BreakpointSP breakpoint_sp;
auto bp_id = BreakpointID::ParseCanonicalReference(bp_id_str);
if (bp_id.hasValue())
breakpoint_sp = target->GetBreakpointByID(bp_id->GetBreakpointID());
if (!breakpoint_sp) {
new_args.Clear();
result.AppendErrorWithFormat("'%d' is not a valid breakpoint ID.\n",
bp_id->GetBreakpointID());
result.SetStatus(eReturnStatusFailed);
return;
}
const size_t num_locations = breakpoint_sp->GetNumLocations();
for (size_t j = 0; j < num_locations; ++j) {
BreakpointLocation *bp_loc =
breakpoint_sp->GetLocationAtIndex(j).get();
StreamString canonical_id_str;
BreakpointID::GetCanonicalReference(
&canonical_id_str, bp_id->GetBreakpointID(), bp_loc->GetID());
new_args.AppendArgument(canonical_id_str.GetString());
}
}
}
}
if (!is_range) {
new_args.AppendArgument(current_arg);
continue;
}
auto start_bp = BreakpointID::ParseCanonicalReference(range_from);
auto end_bp = BreakpointID::ParseCanonicalReference(range_to);
if (!start_bp.hasValue() ||
!target->GetBreakpointByID(start_bp->GetBreakpointID())) {
new_args.Clear();
result.AppendErrorWithFormat("'%s' is not a valid breakpoint ID.\n",
range_from.str().c_str());
result.SetStatus(eReturnStatusFailed);
return;
}
if (!end_bp.hasValue() ||
!target->GetBreakpointByID(end_bp->GetBreakpointID())) {
new_args.Clear();
result.AppendErrorWithFormat("'%s' is not a valid breakpoint ID.\n",
range_to.str().c_str());
result.SetStatus(eReturnStatusFailed);
return;
}
break_id_t start_bp_id = start_bp->GetBreakpointID();
break_id_t start_loc_id = start_bp->GetLocationID();
break_id_t end_bp_id = end_bp->GetBreakpointID();
break_id_t end_loc_id = end_bp->GetLocationID();
if (((start_loc_id == LLDB_INVALID_BREAK_ID) &&
(end_loc_id != LLDB_INVALID_BREAK_ID)) ||
((start_loc_id != LLDB_INVALID_BREAK_ID) &&
(end_loc_id == LLDB_INVALID_BREAK_ID))) {
new_args.Clear();
result.AppendErrorWithFormat("Invalid breakpoint id range: Either "
"both ends of range must specify"
" a breakpoint location, or neither can "
"specify a breakpoint location.\n");
result.SetStatus(eReturnStatusFailed);
return;
}
// We have valid range starting & ending breakpoint IDs. Go through all
// the breakpoints in the target and find all the breakpoints that fit into
// this range, and add them to new_args.
// Next check to see if we have location id's. If so, make sure the
// start_bp_id and end_bp_id are for the same breakpoint; otherwise we have
// an illegal range: breakpoint id ranges that specify bp locations are NOT
// allowed to cross major bp id numbers.
if ((start_loc_id != LLDB_INVALID_BREAK_ID) ||
(end_loc_id != LLDB_INVALID_BREAK_ID)) {
if (start_bp_id != end_bp_id) {
new_args.Clear();
result.AppendErrorWithFormat(
"Invalid range: Ranges that specify particular breakpoint "
"locations"
" must be within the same major breakpoint; you specified two"
" different major breakpoints, %d and %d.\n",
start_bp_id, end_bp_id);
result.SetStatus(eReturnStatusFailed);
return;
}
}
const BreakpointList &breakpoints = target->GetBreakpointList();
const size_t num_breakpoints = breakpoints.GetSize();
for (size_t j = 0; j < num_breakpoints; ++j) {
Breakpoint *breakpoint = breakpoints.GetBreakpointAtIndex(j).get();
break_id_t cur_bp_id = breakpoint->GetID();
if ((cur_bp_id < start_bp_id) || (cur_bp_id > end_bp_id))
continue;
const size_t num_locations = breakpoint->GetNumLocations();
if ((cur_bp_id == start_bp_id) &&
(start_loc_id != LLDB_INVALID_BREAK_ID)) {
for (size_t k = 0; k < num_locations; ++k) {
BreakpointLocation *bp_loc = breakpoint->GetLocationAtIndex(k).get();
if ((bp_loc->GetID() >= start_loc_id) &&
(bp_loc->GetID() <= end_loc_id)) {
StreamString canonical_id_str;
BreakpointID::GetCanonicalReference(&canonical_id_str, cur_bp_id,
bp_loc->GetID());
new_args.AppendArgument(canonical_id_str.GetString());
}
}
} else if ((cur_bp_id == end_bp_id) &&
(end_loc_id != LLDB_INVALID_BREAK_ID)) {
for (size_t k = 0; k < num_locations; ++k) {
BreakpointLocation *bp_loc = breakpoint->GetLocationAtIndex(k).get();
if (bp_loc->GetID() <= end_loc_id) {
StreamString canonical_id_str;
BreakpointID::GetCanonicalReference(&canonical_id_str, cur_bp_id,
bp_loc->GetID());
new_args.AppendArgument(canonical_id_str.GetString());
}
}
} else {
StreamString canonical_id_str;
BreakpointID::GetCanonicalReference(&canonical_id_str, cur_bp_id,
LLDB_INVALID_BREAK_ID);
new_args.AppendArgument(canonical_id_str.GetString());
}
}
}
// Okay, now see if we found any names, and if we did, add them:
if (target && !names_found.empty()) {
Status error;
// Remove any names that aren't visible for this purpose:
auto iter = names_found.begin();
while (iter != names_found.end()) {
BreakpointName *bp_name = target->FindBreakpointName(ConstString(*iter),
true,
error);
if (bp_name && !bp_name->GetPermission(purpose))
iter = names_found.erase(iter);
else
iter++;
}
if (!names_found.empty()) {
for (BreakpointSP bkpt_sp : target->GetBreakpointList().Breakpoints()) {
for (std::string name : names_found) {
if (bkpt_sp->MatchesName(name.c_str())) {
StreamString canonical_id_str;
BreakpointID::GetCanonicalReference(
&canonical_id_str, bkpt_sp->GetID(), LLDB_INVALID_BREAK_ID);
new_args.AppendArgument(canonical_id_str.GetString());
}
}
}
}
}
result.SetStatus(eReturnStatusSuccessFinishNoResult);
}
std::pair<llvm::StringRef, llvm::StringRef>
BreakpointIDList::SplitIDRangeExpression(llvm::StringRef in_string) {
for (auto specifier_str : BreakpointID::GetRangeSpecifiers()) {
size_t idx = in_string.find(specifier_str);
if (idx == llvm::StringRef::npos)
continue;
llvm::StringRef right1 = in_string.drop_front(idx);
llvm::StringRef from = in_string.take_front(idx);
llvm::StringRef to = right1.drop_front(specifier_str.size());
if (BreakpointID::IsValidIDExpression(from) &&
BreakpointID::IsValidIDExpression(to)) {
return std::make_pair(from, to);
}
}
return std::pair<llvm::StringRef, llvm::StringRef>();
}
Reference in New Issue View Git Blame Copy Permalink