122a4ebde3
This reverts commit a01b26fb51, because it
breaks the "finish" command in some way -- the command does not
terminate after it steps out, but continues running the target. The
exact blast radius is not clear, but it at least affects the usage of
the "finish" command in TestGuiBasicDebug.py. The error is *not*
gui-related, as the same issue can be reproduced by running the same
steps outside of the gui.
There is some kind of a race going on, as the test fails only 20% of the
time on the buildbot.
675 lines
23 KiB
C++
675 lines
23 KiB
C++
//===-- BreakpointOptions.cpp ---------------------------------------------===//
|
|
//
|
|
// 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 = std::make_unique<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 = std::make_unique<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 =
|
|
std::make_unique<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.SetErrorString(
|
|
"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 = std::make_unique<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) {
|
|
Debugger &debugger = target->GetDebugger();
|
|
CommandReturnObject result(debugger.GetUseColor());
|
|
|
|
// 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();
|
|
}
|