343 lines
11 KiB
C++
343 lines
11 KiB
C++
//===-- BreakpointBase.cpp --------------------------------------*- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "BreakpointBase.h"
|
|
#include "VSCode.h"
|
|
#include "llvm/ADT/StringExtras.h"
|
|
|
|
using namespace lldb_vscode;
|
|
|
|
BreakpointBase::BreakpointBase(const llvm::json::Object &obj)
|
|
: condition(std::string(GetString(obj, "condition"))),
|
|
hitCondition(std::string(GetString(obj, "hitCondition"))),
|
|
logMessage(std::string(GetString(obj, "logMessage"))) {}
|
|
|
|
void BreakpointBase::SetCondition() { bp.SetCondition(condition.c_str()); }
|
|
|
|
void BreakpointBase::SetHitCondition() {
|
|
uint64_t hitCount = 0;
|
|
if (llvm::to_integer(hitCondition, hitCount))
|
|
bp.SetIgnoreCount(hitCount - 1);
|
|
}
|
|
|
|
lldb::SBError BreakpointBase::AppendLogMessagePart(llvm::StringRef part,
|
|
bool is_expr) {
|
|
if (is_expr) {
|
|
logMessageParts.emplace_back(part, is_expr);
|
|
} else {
|
|
std::string formatted;
|
|
lldb::SBError error = FormatLogText(part, formatted);
|
|
if (error.Fail())
|
|
return error;
|
|
logMessageParts.emplace_back(formatted, is_expr);
|
|
}
|
|
return lldb::SBError();
|
|
}
|
|
|
|
// TODO: consolidate this code with the implementation in
|
|
// FormatEntity::ParseInternal().
|
|
lldb::SBError BreakpointBase::FormatLogText(llvm::StringRef text,
|
|
std::string &formatted) {
|
|
lldb::SBError error;
|
|
while (!text.empty()) {
|
|
size_t backslash_pos = text.find_first_of('\\');
|
|
if (backslash_pos == std::string::npos) {
|
|
formatted += text.str();
|
|
return error;
|
|
}
|
|
|
|
formatted += text.substr(0, backslash_pos).str();
|
|
// Skip the characters before and including '\'.
|
|
text = text.drop_front(backslash_pos + 1);
|
|
|
|
if (text.empty()) {
|
|
error.SetErrorString(
|
|
"'\\' character was not followed by another character");
|
|
return error;
|
|
}
|
|
|
|
const char desens_char = text[0];
|
|
text = text.drop_front(); // Skip the desensitized char character
|
|
switch (desens_char) {
|
|
case 'a':
|
|
formatted.push_back('\a');
|
|
break;
|
|
case 'b':
|
|
formatted.push_back('\b');
|
|
break;
|
|
case 'f':
|
|
formatted.push_back('\f');
|
|
break;
|
|
case 'n':
|
|
formatted.push_back('\n');
|
|
break;
|
|
case 'r':
|
|
formatted.push_back('\r');
|
|
break;
|
|
case 't':
|
|
formatted.push_back('\t');
|
|
break;
|
|
case 'v':
|
|
formatted.push_back('\v');
|
|
break;
|
|
case '\'':
|
|
formatted.push_back('\'');
|
|
break;
|
|
case '\\':
|
|
formatted.push_back('\\');
|
|
break;
|
|
case '0':
|
|
// 1 to 3 octal chars
|
|
{
|
|
if (text.empty()) {
|
|
error.SetErrorString("missing octal number following '\\0'");
|
|
return error;
|
|
}
|
|
|
|
// Make a string that can hold onto the initial zero char, up to 3
|
|
// octal digits, and a terminating NULL.
|
|
char oct_str[5] = {0, 0, 0, 0, 0};
|
|
|
|
size_t i;
|
|
for (i = 0;
|
|
i < text.size() && i < 4 && (text[i] >= '0' && text[i] <= '7');
|
|
++i) {
|
|
oct_str[i] = text[i];
|
|
}
|
|
|
|
text = text.drop_front(i);
|
|
unsigned long octal_value = ::strtoul(oct_str, nullptr, 8);
|
|
if (octal_value <= UINT8_MAX) {
|
|
formatted.push_back((char)octal_value);
|
|
} else {
|
|
error.SetErrorString("octal number is larger than a single byte");
|
|
return error;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 'x': {
|
|
if (text.empty()) {
|
|
error.SetErrorString("missing hex number following '\\x'");
|
|
return error;
|
|
}
|
|
// hex number in the text
|
|
if (isxdigit(text[0])) {
|
|
// Make a string that can hold onto two hex chars plus a
|
|
// NULL terminator
|
|
char hex_str[3] = {0, 0, 0};
|
|
hex_str[0] = text[0];
|
|
|
|
text = text.drop_front();
|
|
|
|
if (!text.empty() && isxdigit(text[0])) {
|
|
hex_str[1] = text[0];
|
|
text = text.drop_front();
|
|
}
|
|
|
|
unsigned long hex_value = strtoul(hex_str, nullptr, 16);
|
|
if (hex_value <= UINT8_MAX) {
|
|
formatted.push_back((char)hex_value);
|
|
} else {
|
|
error.SetErrorString("hex number is larger than a single byte");
|
|
return error;
|
|
}
|
|
} else {
|
|
formatted.push_back(desens_char);
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
// Just desensitize any other character by just printing what came
|
|
// after the '\'
|
|
formatted.push_back(desens_char);
|
|
break;
|
|
}
|
|
}
|
|
return error;
|
|
}
|
|
|
|
// logMessage will be divided into array of LogMessagePart as two kinds:
|
|
// 1. raw print text message, and
|
|
// 2. interpolated expression for evaluation which is inside matching curly
|
|
// braces.
|
|
//
|
|
// The function tries to parse logMessage into a list of LogMessageParts
|
|
// for easy later access in BreakpointHitCallback.
|
|
void BreakpointBase::SetLogMessage() {
|
|
logMessageParts.clear();
|
|
|
|
// Contains unmatched open curly braces indices.
|
|
std::vector<int> unmatched_curly_braces;
|
|
|
|
// Contains all matched curly braces in logMessage.
|
|
// Loop invariant: matched_curly_braces_ranges are sorted by start index in
|
|
// ascending order without any overlap between them.
|
|
std::vector<std::pair<int, int>> matched_curly_braces_ranges;
|
|
|
|
lldb::SBError error;
|
|
// Part1 - parse matched_curly_braces_ranges.
|
|
// locating all curly braced expression ranges in logMessage.
|
|
// The algorithm takes care of nested and imbalanced curly braces.
|
|
for (size_t i = 0; i < logMessage.size(); ++i) {
|
|
if (logMessage[i] == '{') {
|
|
unmatched_curly_braces.push_back(i);
|
|
} else if (logMessage[i] == '}') {
|
|
if (unmatched_curly_braces.empty())
|
|
// Nothing to match.
|
|
continue;
|
|
|
|
int last_unmatched_index = unmatched_curly_braces.back();
|
|
unmatched_curly_braces.pop_back();
|
|
|
|
// Erase any matched ranges included in the new match.
|
|
while (!matched_curly_braces_ranges.empty()) {
|
|
assert(matched_curly_braces_ranges.back().first !=
|
|
last_unmatched_index &&
|
|
"How can a curley brace be matched twice?");
|
|
if (matched_curly_braces_ranges.back().first < last_unmatched_index)
|
|
break;
|
|
|
|
// This is a nested range let's earse it.
|
|
assert((size_t)matched_curly_braces_ranges.back().second < i);
|
|
matched_curly_braces_ranges.pop_back();
|
|
}
|
|
|
|
// Assert invariant.
|
|
assert(matched_curly_braces_ranges.empty() ||
|
|
matched_curly_braces_ranges.back().first < last_unmatched_index);
|
|
matched_curly_braces_ranges.emplace_back(last_unmatched_index, i);
|
|
}
|
|
}
|
|
|
|
// Part2 - parse raw text and expresions parts.
|
|
// All expression ranges have been parsed in matched_curly_braces_ranges.
|
|
// The code below uses matched_curly_braces_ranges to divide logMessage
|
|
// into raw text parts and expression parts.
|
|
int last_raw_text_start = 0;
|
|
for (const std::pair<int, int> &curly_braces_range :
|
|
matched_curly_braces_ranges) {
|
|
// Raw text before open curly brace.
|
|
assert(curly_braces_range.first >= last_raw_text_start);
|
|
size_t raw_text_len = curly_braces_range.first - last_raw_text_start;
|
|
if (raw_text_len > 0) {
|
|
error = AppendLogMessagePart(
|
|
llvm::StringRef(logMessage.c_str() + last_raw_text_start,
|
|
raw_text_len),
|
|
/*is_expr=*/false);
|
|
if (error.Fail()) {
|
|
NotifyLogMessageError(error.GetCString());
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Expression between curly braces.
|
|
assert(curly_braces_range.second > curly_braces_range.first);
|
|
size_t expr_len = curly_braces_range.second - curly_braces_range.first - 1;
|
|
error = AppendLogMessagePart(
|
|
llvm::StringRef(logMessage.c_str() + curly_braces_range.first + 1,
|
|
expr_len),
|
|
/*is_expr=*/true);
|
|
if (error.Fail()) {
|
|
NotifyLogMessageError(error.GetCString());
|
|
return;
|
|
}
|
|
|
|
last_raw_text_start = curly_braces_range.second + 1;
|
|
}
|
|
// Trailing raw text after close curly brace.
|
|
assert(last_raw_text_start >= 0);
|
|
if (logMessage.size() > (size_t)last_raw_text_start) {
|
|
error = AppendLogMessagePart(
|
|
llvm::StringRef(logMessage.c_str() + last_raw_text_start,
|
|
logMessage.size() - last_raw_text_start),
|
|
/*is_expr=*/false);
|
|
if (error.Fail()) {
|
|
NotifyLogMessageError(error.GetCString());
|
|
return;
|
|
}
|
|
}
|
|
|
|
bp.SetCallback(BreakpointBase::BreakpointHitCallback, this);
|
|
}
|
|
|
|
void BreakpointBase::NotifyLogMessageError(llvm::StringRef error) {
|
|
std::string message = "Log message has error: ";
|
|
message += error;
|
|
g_vsc.SendOutput(OutputType::Console, message);
|
|
}
|
|
|
|
/*static*/
|
|
bool BreakpointBase::BreakpointHitCallback(
|
|
void *baton, lldb::SBProcess &process, lldb::SBThread &thread,
|
|
lldb::SBBreakpointLocation &location) {
|
|
if (!baton)
|
|
return true;
|
|
|
|
BreakpointBase *bp = (BreakpointBase *)baton;
|
|
lldb::SBFrame frame = thread.GetSelectedFrame();
|
|
|
|
std::string output;
|
|
for (const BreakpointBase::LogMessagePart &messagePart :
|
|
bp->logMessageParts) {
|
|
if (messagePart.is_expr) {
|
|
// Try local frame variables first before fall back to expression
|
|
// evaluation
|
|
const std::string &expr_str = messagePart.text;
|
|
const char *expr = expr_str.c_str();
|
|
lldb::SBValue value =
|
|
frame.GetValueForVariablePath(expr, lldb::eDynamicDontRunTarget);
|
|
if (value.GetError().Fail())
|
|
value = frame.EvaluateExpression(expr);
|
|
const char *expr_val = value.GetValue();
|
|
if (expr_val)
|
|
output += expr_val;
|
|
} else {
|
|
output += messagePart.text;
|
|
}
|
|
}
|
|
if (!output.empty() && output.back() != '\n')
|
|
output.push_back('\n'); // Ensure log message has line break.
|
|
g_vsc.SendOutput(OutputType::Console, output.c_str());
|
|
|
|
// Do not stop.
|
|
return false;
|
|
}
|
|
|
|
void BreakpointBase::UpdateBreakpoint(const BreakpointBase &request_bp) {
|
|
if (condition != request_bp.condition) {
|
|
condition = request_bp.condition;
|
|
SetCondition();
|
|
}
|
|
if (hitCondition != request_bp.hitCondition) {
|
|
hitCondition = request_bp.hitCondition;
|
|
SetHitCondition();
|
|
}
|
|
if (logMessage != request_bp.logMessage) {
|
|
logMessage = request_bp.logMessage;
|
|
SetLogMessage();
|
|
}
|
|
}
|
|
|
|
const char *BreakpointBase::GetBreakpointLabel() {
|
|
// Breakpoints in LLDB can have names added to them which are kind of like
|
|
// labels or categories. All breakpoints that are set through the IDE UI get
|
|
// sent through the various VS code DAP set*Breakpoint packets, and these
|
|
// breakpoints will be labeled with this name so if breakpoint update events
|
|
// come in for breakpoints that the IDE doesn't know about, like if a
|
|
// breakpoint is set manually using the debugger console, we won't report any
|
|
// updates on them and confused the IDE. This function gets called by all of
|
|
// the breakpoint classes after they set breakpoints to mark a breakpoint as
|
|
// a UI breakpoint. We can later check a lldb::SBBreakpoint object that comes
|
|
// in via LLDB breakpoint changed events and check the breakpoint by calling
|
|
// "bool lldb::SBBreakpoint::MatchesName(const char *)" to check if a
|
|
// breakpoint in one of the UI breakpoints that we should report changes for.
|
|
return "vscode";
|
|
}
|