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/BreakpointOptions.cpp

674 lines
23 KiB
C++
Raw Blame History

//===-- BreakpointOptions.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 "lldb/Breakpoint/BreakpointOptions.h"
#include "lldb/Breakpoint/StoppointCallbackContext.h"
#include "lldb/Core/Value.h"
#include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/ThreadSpec.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StringList.h"
#include "llvm/ADT/STLExtras.h"
using namespace lldb;
using namespace lldb_private;
const char
*BreakpointOptions::CommandData::g_option_names[static_cast<uint32_t>(
BreakpointOptions::CommandData::OptionNames::LastOptionName)]{
"UserSource", "ScriptSource", "StopOnError"};
StructuredData::ObjectSP
BreakpointOptions::CommandData::SerializeToStructuredData() {
size_t num_strings = user_source.GetSize();
if (num_strings == 0 && script_source.empty()) {
// We shouldn't serialize commands if there aren't any, return an empty sp
// to indicate this.
return StructuredData::ObjectSP();
}
StructuredData::DictionarySP options_dict_sp(
new StructuredData::Dictionary());
options_dict_sp->AddBooleanItem(GetKey(OptionNames::StopOnError),
stop_on_error);
StructuredData::ArraySP user_source_sp(new StructuredData::Array());
for (size_t i = 0; i < num_strings; i++) {
StructuredData::StringSP item_sp(
new StructuredData::String(user_source[i]));
user_source_sp->AddItem(item_sp);
options_dict_sp->AddItem(GetKey(OptionNames::UserSource), user_source_sp);
}
options_dict_sp->AddStringItem(
GetKey(OptionNames::Interpreter),
ScriptInterpreter::LanguageToString(interpreter));
return options_dict_sp;
}
std::unique_ptr<BreakpointOptions::CommandData>
BreakpointOptions::CommandData::CreateFromStructuredData(
const StructuredData::Dictionary &options_dict, Status &error) {
std::unique_ptr<CommandData> data_up(new CommandData());
bool found_something = false;
bool success = options_dict.GetValueForKeyAsBoolean(
GetKey(OptionNames::StopOnError), data_up->stop_on_error);
if (success)
found_something = true;
llvm::StringRef interpreter_str;
ScriptLanguage interp_language;
success = options_dict.GetValueForKeyAsString(
GetKey(OptionNames::Interpreter), interpreter_str);
if (!success) {
error.SetErrorString("Missing command language value.");
return data_up;
}
found_something = true;
interp_language = ScriptInterpreter::StringToLanguage(interpreter_str);
if (interp_language == eScriptLanguageUnknown) {
error.SetErrorStringWithFormatv("Unknown breakpoint command language: {0}.",
interpreter_str);
return data_up;
}
data_up->interpreter = interp_language;
StructuredData::Array *user_source;
success = options_dict.GetValueForKeyAsArray(GetKey(OptionNames::UserSource),
user_source);
if (success) {
found_something = true;
size_t num_elems = user_source->GetSize();
for (size_t i = 0; i < num_elems; i++) {
llvm::StringRef elem_string;
success = user_source->GetItemAtIndexAsString(i, elem_string);
if (success)
data_up->user_source.AppendString(elem_string);
}
}
if (found_something)
return data_up;
else
return std::unique_ptr<BreakpointOptions::CommandData>();
}
const char *BreakpointOptions::g_option_names[(
size_t)BreakpointOptions::OptionNames::LastOptionName]{
"ConditionText", "IgnoreCount",
"EnabledState", "OneShotState", "AutoContinue"};
bool BreakpointOptions::NullCallback(void *baton,
StoppointCallbackContext *context,
lldb::user_id_t break_id,
lldb::user_id_t break_loc_id) {
return true;
}
// BreakpointOptions constructor
BreakpointOptions::BreakpointOptions(bool all_flags_set)
: m_callback(BreakpointOptions::NullCallback), m_callback_baton_sp(),
m_baton_is_command_baton(false), m_callback_is_synchronous(false),
m_enabled(true), m_one_shot(false), m_ignore_count(0), m_thread_spec_up(),
m_condition_text(), m_condition_text_hash(0), m_auto_continue(false),
m_set_flags(0) {
if (all_flags_set)
m_set_flags.Set(~((Flags::ValueType)0));
}
BreakpointOptions::BreakpointOptions(const char *condition, bool enabled,
int32_t ignore, bool one_shot,
bool auto_continue)
: m_callback(nullptr), m_baton_is_command_baton(false),
m_callback_is_synchronous(false), m_enabled(enabled),
m_one_shot(one_shot), m_ignore_count(ignore),
m_condition_text_hash(0), m_auto_continue(auto_continue)
{
m_set_flags.Set(eEnabled | eIgnoreCount | eOneShot
| eAutoContinue);
if (condition && *condition != '\0') {
SetCondition(condition);
}
}
// BreakpointOptions copy constructor
BreakpointOptions::BreakpointOptions(const BreakpointOptions &rhs)
: m_callback(rhs.m_callback), m_callback_baton_sp(rhs.m_callback_baton_sp),
m_baton_is_command_baton(rhs.m_baton_is_command_baton),
m_callback_is_synchronous(rhs.m_callback_is_synchronous),
m_enabled(rhs.m_enabled), m_one_shot(rhs.m_one_shot),
m_ignore_count(rhs.m_ignore_count), m_thread_spec_up(),
m_auto_continue(rhs.m_auto_continue), m_set_flags(rhs.m_set_flags) {
if (rhs.m_thread_spec_up != nullptr)
m_thread_spec_up.reset(new ThreadSpec(*rhs.m_thread_spec_up));
m_condition_text = rhs.m_condition_text;
m_condition_text_hash = rhs.m_condition_text_hash;
}
// BreakpointOptions assignment operator
const BreakpointOptions &BreakpointOptions::
operator=(const BreakpointOptions &rhs) {
m_callback = rhs.m_callback;
m_callback_baton_sp = rhs.m_callback_baton_sp;
m_baton_is_command_baton = rhs.m_baton_is_command_baton;
m_callback_is_synchronous = rhs.m_callback_is_synchronous;
m_enabled = rhs.m_enabled;
m_one_shot = rhs.m_one_shot;
m_ignore_count = rhs.m_ignore_count;
if (rhs.m_thread_spec_up != nullptr)
m_thread_spec_up.reset(new ThreadSpec(*rhs.m_thread_spec_up));
m_condition_text = rhs.m_condition_text;
m_condition_text_hash = rhs.m_condition_text_hash;
m_auto_continue = rhs.m_auto_continue;
m_set_flags = rhs.m_set_flags;
return *this;
}
void BreakpointOptions::CopyOverSetOptions(const BreakpointOptions &incoming)
{
if (incoming.m_set_flags.Test(eEnabled))
{
m_enabled = incoming.m_enabled;
m_set_flags.Set(eEnabled);
}
if (incoming.m_set_flags.Test(eOneShot))
{
m_one_shot = incoming.m_one_shot;
m_set_flags.Set(eOneShot);
}
if (incoming.m_set_flags.Test(eCallback))
{
m_callback = incoming.m_callback;
m_callback_baton_sp = incoming.m_callback_baton_sp;
m_callback_is_synchronous = incoming.m_callback_is_synchronous;
m_baton_is_command_baton = incoming.m_baton_is_command_baton;
m_set_flags.Set(eCallback);
}
if (incoming.m_set_flags.Test(eIgnoreCount))
{
m_ignore_count = incoming.m_ignore_count;
m_set_flags.Set(eIgnoreCount);
}
if (incoming.m_set_flags.Test(eCondition))
{
// If we're copying over an empty condition, mark it as unset.
if (incoming.m_condition_text.empty()) {
m_condition_text.clear();
m_condition_text_hash = 0;
m_set_flags.Clear(eCondition);
} else {
m_condition_text = incoming.m_condition_text;
m_condition_text_hash = incoming.m_condition_text_hash;
m_set_flags.Set(eCondition);
}
}
if (incoming.m_set_flags.Test(eAutoContinue))
{
m_auto_continue = incoming.m_auto_continue;
m_set_flags.Set(eAutoContinue);
}
if (incoming.m_set_flags.Test(eThreadSpec) && incoming.m_thread_spec_up) {
if (!m_thread_spec_up)
m_thread_spec_up.reset(new ThreadSpec(*incoming.m_thread_spec_up));
else
*m_thread_spec_up = *incoming.m_thread_spec_up;
m_set_flags.Set(eThreadSpec);
}
}
// Destructor
BreakpointOptions::~BreakpointOptions() = default;
std::unique_ptr<BreakpointOptions> BreakpointOptions::CreateFromStructuredData(
Target &target, const StructuredData::Dictionary &options_dict,
Status &error) {
bool enabled = true;
bool one_shot = false;
bool auto_continue = false;
int32_t ignore_count = 0;
llvm::StringRef condition_ref("");
Flags set_options;
const char *key = GetKey(OptionNames::EnabledState);
bool success;
if (key && options_dict.HasKey(key)) {
success = options_dict.GetValueForKeyAsBoolean(key, enabled);
if (!success) {
error.SetErrorStringWithFormat("%s key is not a boolean.", key);
return nullptr;
}
set_options.Set(eEnabled);
}
key = GetKey(OptionNames::OneShotState);
if (key && options_dict.HasKey(key)) {
success = options_dict.GetValueForKeyAsBoolean(key, one_shot);
if (!success) {
error.SetErrorStringWithFormat("%s key is not a boolean.", key);
return nullptr;
}
set_options.Set(eOneShot);
}
key = GetKey(OptionNames::AutoContinue);
if (key && options_dict.HasKey(key)) {
success = options_dict.GetValueForKeyAsBoolean(key, auto_continue);
if (!success) {
error.SetErrorStringWithFormat("%s key is not a boolean.", key);
return nullptr;
}
set_options.Set(eAutoContinue);
}
key = GetKey(OptionNames::IgnoreCount);
if (key && options_dict.HasKey(key)) {
success = options_dict.GetValueForKeyAsInteger(key, ignore_count);
if (!success) {
error.SetErrorStringWithFormat("%s key is not an integer.", key);
return nullptr;
}
set_options.Set(eIgnoreCount);
}
key = GetKey(OptionNames::ConditionText);
if (key && options_dict.HasKey(key)) {
success = options_dict.GetValueForKeyAsString(key, condition_ref);
if (!success) {
error.SetErrorStringWithFormat("%s key is not an string.", key);
return nullptr;
}
set_options.Set(eCondition);
}
std::unique_ptr<CommandData> cmd_data_up;
StructuredData::Dictionary *cmds_dict;
success = options_dict.GetValueForKeyAsDictionary(
CommandData::GetSerializationKey(), cmds_dict);
if (success && cmds_dict) {
Status cmds_error;
cmd_data_up = CommandData::CreateFromStructuredData(*cmds_dict, cmds_error);
if (cmds_error.Fail()) {
error.SetErrorStringWithFormat(
"Failed to deserialize breakpoint command options: %s.",
cmds_error.AsCString());
return nullptr;
}
}
auto bp_options = std::make_unique<BreakpointOptions>(
condition_ref.str().c_str(), enabled,
ignore_count, one_shot, auto_continue);
if (cmd_data_up) {
if (cmd_data_up->interpreter == eScriptLanguageNone)
bp_options->SetCommandDataCallback(cmd_data_up);
else {
ScriptInterpreter *interp = target.GetDebugger().GetScriptInterpreter();
if (!interp) {
error.SetErrorStringWithFormat(
"Can't set script commands - no script interpreter");
return nullptr;
}
if (interp->GetLanguage() != cmd_data_up->interpreter) {
error.SetErrorStringWithFormat(
"Current script language doesn't match breakpoint's language: %s",
ScriptInterpreter::LanguageToString(cmd_data_up->interpreter)
.c_str());
return nullptr;
}
Status script_error;
script_error =
interp->SetBreakpointCommandCallback(bp_options.get(), cmd_data_up);
if (script_error.Fail()) {
error.SetErrorStringWithFormat("Error generating script callback: %s.",
error.AsCString());
return nullptr;
}
}
}
StructuredData::Dictionary *thread_spec_dict;
success = options_dict.GetValueForKeyAsDictionary(
ThreadSpec::GetSerializationKey(), thread_spec_dict);
if (success) {
Status thread_spec_error;
std::unique_ptr<ThreadSpec> thread_spec_up =
ThreadSpec::CreateFromStructuredData(*thread_spec_dict,
thread_spec_error);
if (thread_spec_error.Fail()) {
error.SetErrorStringWithFormat(
"Failed to deserialize breakpoint thread spec options: %s.",
thread_spec_error.AsCString());
return nullptr;
}
bp_options->SetThreadSpec(thread_spec_up);
}
return bp_options;
}
StructuredData::ObjectSP BreakpointOptions::SerializeToStructuredData() {
StructuredData::DictionarySP options_dict_sp(
new StructuredData::Dictionary());
if (m_set_flags.Test(eEnabled))
options_dict_sp->AddBooleanItem(GetKey(OptionNames::EnabledState),
m_enabled);
if (m_set_flags.Test(eOneShot))
options_dict_sp->AddBooleanItem(GetKey(OptionNames::OneShotState),
m_one_shot);
if (m_set_flags.Test(eAutoContinue))
options_dict_sp->AddBooleanItem(GetKey(OptionNames::AutoContinue),
m_auto_continue);
if (m_set_flags.Test(eIgnoreCount))
options_dict_sp->AddIntegerItem(GetKey(OptionNames::IgnoreCount),
m_ignore_count);
if (m_set_flags.Test(eCondition))
options_dict_sp->AddStringItem(GetKey(OptionNames::ConditionText),
m_condition_text);
if (m_set_flags.Test(eCallback) && m_baton_is_command_baton) {
auto cmd_baton =
std::static_pointer_cast<CommandBaton>(m_callback_baton_sp);
StructuredData::ObjectSP commands_sp =
cmd_baton->getItem()->SerializeToStructuredData();
if (commands_sp) {
options_dict_sp->AddItem(
BreakpointOptions::CommandData::GetSerializationKey(), commands_sp);
}
}
if (m_set_flags.Test(eThreadSpec) && m_thread_spec_up) {
StructuredData::ObjectSP thread_spec_sp =
m_thread_spec_up->SerializeToStructuredData();
options_dict_sp->AddItem(ThreadSpec::GetSerializationKey(), thread_spec_sp);
}
return options_dict_sp;
}
// Callbacks
void BreakpointOptions::SetCallback(BreakpointHitCallback callback,
const lldb::BatonSP &callback_baton_sp,
bool callback_is_synchronous) {
// FIXME: This seems unsafe. If BatonSP actually *is* a CommandBaton, but
// in a shared_ptr<Baton> instead of a shared_ptr<CommandBaton>, then we will
// set m_baton_is_command_baton to false, which is incorrect. One possible
// solution is to make the base Baton class provide a method such as:
// virtual StringRef getBatonId() const { return ""; }
// and have CommandBaton override this to return something unique, and then
// check for it here. Another option might be to make Baton using the llvm
// casting infrastructure, so that we could write something like:
// if (llvm::isa<CommandBaton>(callback_baton_sp))
// at relevant callsites instead of storing a boolean.
m_callback_is_synchronous = callback_is_synchronous;
m_callback = callback;
m_callback_baton_sp = callback_baton_sp;
m_baton_is_command_baton = false;
m_set_flags.Set(eCallback);
}
void BreakpointOptions::SetCallback(
BreakpointHitCallback callback,
const BreakpointOptions::CommandBatonSP &callback_baton_sp,
bool callback_is_synchronous) {
m_callback_is_synchronous = callback_is_synchronous;
m_callback = callback;
m_callback_baton_sp = callback_baton_sp;
m_baton_is_command_baton = true;
m_set_flags.Set(eCallback);
}
void BreakpointOptions::ClearCallback() {
m_callback = BreakpointOptions::NullCallback;
m_callback_is_synchronous = false;
m_callback_baton_sp.reset();
m_baton_is_command_baton = false;
m_set_flags.Clear(eCallback);
}
Baton *BreakpointOptions::GetBaton() { return m_callback_baton_sp.get(); }
const Baton *BreakpointOptions::GetBaton() const {
return m_callback_baton_sp.get();
}
bool BreakpointOptions::InvokeCallback(StoppointCallbackContext *context,
lldb::user_id_t break_id,
lldb::user_id_t break_loc_id) {
if (m_callback) {
if (context->is_synchronous == IsCallbackSynchronous()) {
return m_callback(m_callback_baton_sp ? m_callback_baton_sp->data()
: nullptr,
context, break_id, break_loc_id);
} else if (IsCallbackSynchronous()) {
// If a synchronous callback is called at async time, it should not say
// to stop.
return false;
}
}
return true;
}
bool BreakpointOptions::HasCallback() const {
return m_callback != BreakpointOptions::NullCallback;
}
bool BreakpointOptions::GetCommandLineCallbacks(StringList &command_list) {
if (!HasCallback())
return false;
if (!m_baton_is_command_baton)
return false;
auto cmd_baton = std::static_pointer_cast<CommandBaton>(m_callback_baton_sp);
CommandData *data = cmd_baton->getItem();
if (!data)
return false;
command_list = data->user_source;
return true;
}
void BreakpointOptions::SetCondition(const char *condition) {
if (!condition || condition[0] == '\0') {
condition = "";
m_set_flags.Clear(eCondition);
}
else
m_set_flags.Set(eCondition);
m_condition_text.assign(condition);
std::hash<std::string> hasher;
m_condition_text_hash = hasher(m_condition_text);
}
const char *BreakpointOptions::GetConditionText(size_t *hash) const {
if (!m_condition_text.empty()) {
if (hash)
*hash = m_condition_text_hash;
return m_condition_text.c_str();
} else {
return nullptr;
}
}
const ThreadSpec *BreakpointOptions::GetThreadSpecNoCreate() const {
return m_thread_spec_up.get();
}
ThreadSpec *BreakpointOptions::GetThreadSpec() {
if (m_thread_spec_up == nullptr) {
m_set_flags.Set(eThreadSpec);
m_thread_spec_up.reset(new ThreadSpec());
}
return m_thread_spec_up.get();
}
void BreakpointOptions::SetThreadID(lldb::tid_t thread_id) {
GetThreadSpec()->SetTID(thread_id);
m_set_flags.Set(eThreadSpec);
}
void BreakpointOptions::SetThreadSpec(
std::unique_ptr<ThreadSpec> &thread_spec_up) {
m_thread_spec_up = std::move(thread_spec_up);
m_set_flags.Set(eThreadSpec);
}
void BreakpointOptions::GetDescription(Stream *s,
lldb::DescriptionLevel level) const {
// Figure out if there are any options not at their default value, and only
// print anything if there are:
if (m_ignore_count != 0 || !m_enabled || m_one_shot || m_auto_continue ||
(GetThreadSpecNoCreate() != nullptr &&
GetThreadSpecNoCreate()->HasSpecification())) {
if (level == lldb::eDescriptionLevelVerbose) {
s->EOL();
s->IndentMore();
s->Indent();
s->PutCString("Breakpoint Options:\n");
s->IndentMore();
s->Indent();
} else
s->PutCString(" Options: ");
if (m_ignore_count > 0)
s->Printf("ignore: %d ", m_ignore_count);
s->Printf("%sabled ", m_enabled ? "en" : "dis");
if (m_one_shot)
s->Printf("one-shot ");
if (m_auto_continue)
s->Printf("auto-continue ");
if (m_thread_spec_up)
m_thread_spec_up->GetDescription(s, level);
if (level == lldb::eDescriptionLevelFull) {
s->IndentLess();
s->IndentMore();
}
}
if (m_callback_baton_sp.get()) {
if (level != eDescriptionLevelBrief) {
s->EOL();
m_callback_baton_sp->GetDescription(s->AsRawOstream(), level,
s->GetIndentLevel());
}
}
if (!m_condition_text.empty()) {
if (level != eDescriptionLevelBrief) {
s->EOL();
s->Printf("Condition: %s\n", m_condition_text.c_str());
}
}
}
void BreakpointOptions::CommandBaton::GetDescription(
llvm::raw_ostream &s, lldb::DescriptionLevel level,
unsigned indentation) const {
const CommandData *data = getItem();
if (level == eDescriptionLevelBrief) {
s << ", commands = "
<< ((data && data->user_source.GetSize() > 0) ? "yes" : "no");
return;
}
indentation += 2;
s.indent(indentation);
s << "Breakpoint commands";
if (data->interpreter != eScriptLanguageNone)
s << llvm::formatv(" ({0}):\n",
ScriptInterpreter::LanguageToString(data->interpreter));
else
s << ":\n";
indentation += 2;
if (data && data->user_source.GetSize() > 0) {
for (llvm::StringRef str : data->user_source) {
s.indent(indentation);
s << str << "\n";
}
} else
s << "No commands.\n";
}
void BreakpointOptions::SetCommandDataCallback(
std::unique_ptr<CommandData> &cmd_data) {
cmd_data->interpreter = eScriptLanguageNone;
auto baton_sp = std::make_shared<CommandBaton>(std::move(cmd_data));
SetCallback(BreakpointOptions::BreakpointOptionsCallbackFunction, baton_sp);
m_set_flags.Set(eCallback);
}
bool BreakpointOptions::BreakpointOptionsCallbackFunction(
void *baton, StoppointCallbackContext *context, lldb::user_id_t break_id,
lldb::user_id_t break_loc_id) {
bool ret_value = true;
if (baton == nullptr)
return true;
CommandData *data = (CommandData *)baton;
StringList &commands = data->user_source;
if (commands.GetSize() > 0) {
ExecutionContext exe_ctx(context->exe_ctx_ref);
Target *target = exe_ctx.GetTargetPtr();
if (target) {
CommandReturnObject result;
Debugger &debugger = target->GetDebugger();
// Rig up the results secondary output stream to the debugger's, so the
// output will come out synchronously if the debugger is set up that way.
StreamSP output_stream(debugger.GetAsyncOutputStream());
StreamSP error_stream(debugger.GetAsyncErrorStream());
result.SetImmediateOutputStream(output_stream);
result.SetImmediateErrorStream(error_stream);
CommandInterpreterRunOptions options;
options.SetStopOnContinue(true);
options.SetStopOnError(data->stop_on_error);
options.SetEchoCommands(true);
options.SetPrintResults(true);
options.SetPrintErrors(true);
options.SetAddToHistory(false);
debugger.GetCommandInterpreter().HandleCommands(commands, &exe_ctx,
options, result);
result.GetImmediateOutputStream()->Flush();
result.GetImmediateErrorStream()->Flush();
}
}
return ret_value;
}
void BreakpointOptions::Clear()
{
m_set_flags.Clear();
m_thread_spec_up.release();
m_one_shot = false;
m_ignore_count = 0;
m_auto_continue = false;
m_callback = nullptr;
m_callback_baton_sp.reset();
m_baton_is_command_baton = false;
m_callback_is_synchronous = false;
m_enabled = false;
m_condition_text.clear();
}
Reference in New Issue View Git Blame Copy Permalink