+#include "lldb/Breakpoint/Breakpoint.h"

+#include "lldb/Breakpoint/BreakpointIDList.h"

+#include "lldb/Breakpoint/BreakpointLocation.h"

+#include "lldb/Breakpoint/StoppointCallbackContext.h"

+#include "lldb/Core/State.h"

+

+#include "llvm/ADT/STLExtras.h"

+// FIXME: "script-type" needs to have its contents determined dynamically, so

+// somebody can add a new scripting

+// language to lldb and have it pickable here without having to change this

+// enumeration by hand and rebuild lldb proper.

+

+static OptionEnumValueElement g_script_option_enumeration[4] = {

+ {eScriptLanguageNone, "command",

+ "Commands are in the lldb command interpreter language"},

+ {eScriptLanguagePython, "python", "Commands are in the Python language."},

+ {eSortOrderByName, "default-script",

+ "Commands are in the default scripting language."},

+ {0, nullptr, nullptr}};

+

+static OptionDefinition g_breakpoint_add_options[] = {

+ // clang-format off

+ { LLDB_OPT_SET_1, false, "one-liner", 'o', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeOneLiner, "Specify a one-line breakpoint command inline. Be sure to surround it with quotes." },

+ { LLDB_OPT_SET_ALL, false, "stop-on-error", 'e', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean, "Specify whether breakpoint command execution should terminate on error." },

+ { LLDB_OPT_SET_ALL, false, "script-type", 's', OptionParser::eRequiredArgument, nullptr, g_script_option_enumeration, 0, eArgTypeNone, "Specify the language for the commands - if none is specified, the lldb command interpreter will be used." },

+ { LLDB_OPT_SET_2, false, "python-function", 'F', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypePythonFunction, "Give the name of a Python function to run as command for this breakpoint. Be sure to give a module name if appropriate." },

+ { LLDB_OPT_SET_ALL, false, "dummy-breakpoints", 'D', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Sets Dummy breakpoints - i.e. breakpoints set before a file is provided, which prime new targets." },

+ // clang-format on

+};

+

+class CommandObjectBreakpointCommandAdd : public CommandObjectParsed,

+ public IOHandlerDelegateMultiline {

+ CommandObjectBreakpointCommandAdd(CommandInterpreter &interpreter)

+ : CommandObjectParsed(interpreter, "add",

+ "Add LLDB commands to a breakpoint, to be executed "

+ "whenever the breakpoint is hit."

+ " If no breakpoint is specified, adds the "

+ "commands to the last created breakpoint.",

+ nullptr),

+ IOHandlerDelegateMultiline("DONE",

+ IOHandlerDelegate::Completion::LLDBCommand),

+ m_options() {

+ SetHelpLong(

+ R"(

+)"

+ "This command will prompt for commands to be executed when the specified \

+prompt until 'DONE' is entered."

+ R"(

+)"

+ "Syntactic errors may not be detected when initially entered, and many \

+do not appear to be executing, double-check the command syntax."

+ R"(

+)"

+ "Note: You may enter any debugger command exactly as you would at the debugger \

+more than one command per line."

+ R"(

+)"

+ "You may enter either one or more lines of Python, including function \

+generated function, and a call to the function will be attached to the breakpoint."

+ R"(

+)"

+ "When specifying a python function with the --python-function option, you need \

+to supply the function name prepended by the module name:"

+ R"(

+)"

+ "The arguments are the same as the arguments passed to generated functions as \

+via process.GetTarget()."

+ R"(

+)"

+ "Important Note: As Python code gets collected into functions, access to global \

+Python syntax, including indentation, when entering Python breakpoint commands."

+ R"(

+)"

+ "In this case, since there is a reference to a global variable, \

+initialized:"

+ R"(

+)"

+ "Your Python code, however organized, can optionally return a value. \

+LLDB to stop."

+ R"(

+)"

+ "Final Note: A warning that no breakpoint command was generated when there \

+are no syntax errors may indicate that a function was declared but never called.");

+ CommandArgumentEntry arg;

+ CommandArgumentData bp_id_arg;

+ // Define the first (and only) variant of this arg.

+ bp_id_arg.arg_type = eArgTypeBreakpointID;

+ bp_id_arg.arg_repetition = eArgRepeatOptional;

+ // There is only one variant this argument could be; put it into the

+ // argument entry.

+ arg.push_back(bp_id_arg);

+ // Push the data for the first argument into the m_arguments vector.

+ m_arguments.push_back(arg);

+ }

+ ~CommandObjectBreakpointCommandAdd() override = default;

+ Options *GetOptions() override { return &m_options; }

+ void IOHandlerActivated(IOHandler &io_handler) override {

+ StreamFileSP output_sp(io_handler.GetOutputStreamFile());

+ if (output_sp) {

+ output_sp->PutCString(g_reader_instructions);

+ output_sp->Flush();

+ }

+ void IOHandlerInputComplete(IOHandler &io_handler,

+ std::string &line) override {

+ io_handler.SetIsDone(true);

+

+ std::vector<BreakpointOptions *> *bp_options_vec =

+ (std::vector<BreakpointOptions *> *)io_handler.GetUserData();

+ for (BreakpointOptions *bp_options : *bp_options_vec) {

+ if (!bp_options)

+ continue;

+

+ auto cmd_data = llvm::make_unique<BreakpointOptions::CommandData>();

+ cmd_data->user_source.SplitIntoLines(line.c_str(), line.size());

+ bp_options->SetCommandDataCallback(cmd_data);

+ }

+

+ void CollectDataForBreakpointCommandCallback(

+ std::vector<BreakpointOptions *> &bp_options_vec,

+ CommandReturnObject &result) {

+ m_interpreter.GetLLDBCommandsFromIOHandler(

+ "> ", // Prompt

+ *this, // IOHandlerDelegate

+ true, // Run IOHandler in async mode

+ &bp_options_vec); // Baton for the "io_handler" that will be passed back

+ // into our IOHandlerDelegate functions

+ }

+

+ /// Set a one-liner as the callback for the breakpoint.

+ void

+ SetBreakpointCommandCallback(std::vector<BreakpointOptions *> &bp_options_vec,

+ const char *oneliner) {

+ for (auto bp_options : bp_options_vec) {

+ auto cmd_data = llvm::make_unique<BreakpointOptions::CommandData>();

+

+ cmd_data->user_source.AppendString(oneliner);

+ cmd_data->stop_on_error = m_options.m_stop_on_error;

+

+ bp_options->SetCommandDataCallback(cmd_data);

+ }

+

+ class CommandOptions : public Options {

+ public:

+ CommandOptions()

+ : Options(), m_use_commands(false), m_use_script_language(false),

+ m_script_language(eScriptLanguageNone), m_use_one_liner(false),

+ m_one_liner(), m_function_name() {}

+

+ ~CommandOptions() override = default;

+

+ Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,

+ ExecutionContext *execution_context) override {

+ Error error;

+ const int short_option = m_getopt_table[option_idx].val;

+

+ switch (short_option) {

+ case 'o':

+ m_use_one_liner = true;

+ m_one_liner = option_arg;

+ break;

+

+ case 's':

+ m_script_language = (lldb::ScriptLanguage)Args::StringToOptionEnum(

+ option_arg, g_breakpoint_add_options[option_idx].enum_values,

+ eScriptLanguageNone, error);

+

+ if (m_script_language == eScriptLanguagePython ||

+ m_script_language == eScriptLanguageDefault) {

+ m_use_script_language = true;

+ } else {

+ m_use_script_language = false;

+ break;

+

+ case 'e': {

+ bool success = false;

+ m_stop_on_error = Args::StringToBoolean(option_arg, false, &success);

+ if (!success)

+ error.SetErrorStringWithFormat(

+ "invalid value for stop-on-error: \"%s\"",

+ option_arg.str().c_str());

+ } break;

+

+ case 'F':

+ m_use_one_liner = false;

+ m_use_script_language = true;

+ m_function_name.assign(option_arg);

+ break;

+

+ case 'D':

+ m_use_dummy = true;

+ break;

+

+ default:

+ break;

+ }

+ return error;

+ void OptionParsingStarting(ExecutionContext *execution_context) override {

+ m_use_commands = true;

+ m_use_script_language = false;

+ m_script_language = eScriptLanguageNone;

+ m_use_one_liner = false;

+ m_stop_on_error = true;

+ m_one_liner.clear();

+ m_function_name.clear();

+ m_use_dummy = false;

+ }

+ llvm::ArrayRef<OptionDefinition> GetDefinitions() override {

+ return llvm::makeArrayRef(g_breakpoint_add_options);

+ }

+ // Instance variables to hold the values for command options.

+ bool m_use_commands;

+ bool m_use_script_language;

+ lldb::ScriptLanguage m_script_language;

+ // Instance variables to hold the values for one_liner options.

+ bool m_use_one_liner;

+ std::string m_one_liner;

+ bool m_stop_on_error;

+ std::string m_function_name;

+ bool m_use_dummy;

+ };

+ bool DoExecute(Args &command, CommandReturnObject &result) override {

+ Target *target = GetSelectedOrDummyTarget(m_options.m_use_dummy);

+

+ if (target == nullptr) {

+ result.AppendError("There is not a current executable; there are no "

+ "breakpoints to which to add commands");

+ result.SetStatus(eReturnStatusFailed);

+ return false;

+ }

+ const BreakpointList &breakpoints = target->GetBreakpointList();

+ size_t num_breakpoints = breakpoints.GetSize();

+ if (num_breakpoints == 0) {

+ result.AppendError("No breakpoints exist to have commands added");

+ result.SetStatus(eReturnStatusFailed);

+ return false;

+ }

+ if (!m_options.m_use_script_language &&

+ !m_options.m_function_name.empty()) {

+ result.AppendError("need to enable scripting to have a function run as a "

+ "breakpoint command");

+ result.SetStatus(eReturnStatusFailed);

+ return false;

+ }

+ BreakpointIDList valid_bp_ids;

+ CommandObjectMultiwordBreakpoint::VerifyBreakpointOrLocationIDs(

+ command, target, result, &valid_bp_ids);

+

+ m_bp_options_vec.clear();

+

+ if (result.Succeeded()) {

+ const size_t count = valid_bp_ids.GetSize();

+

+ for (size_t i = 0; i < count; ++i) {

+ BreakpointID cur_bp_id = valid_bp_ids.GetBreakpointIDAtIndex(i);

+ if (cur_bp_id.GetBreakpointID() != LLDB_INVALID_BREAK_ID) {

+ Breakpoint *bp =

+ target->GetBreakpointByID(cur_bp_id.GetBreakpointID()).get();

+ BreakpointOptions *bp_options = nullptr;

+ if (cur_bp_id.GetLocationID() == LLDB_INVALID_BREAK_ID) {

+ // This breakpoint does not have an associated location.

+ bp_options = bp->GetOptions();

+ } else {

+ BreakpointLocationSP bp_loc_sp(

+ bp->FindLocationByID(cur_bp_id.GetLocationID()));

+ // This breakpoint does have an associated location.

+ // Get its breakpoint options.

+ if (bp_loc_sp)

+ bp_options = bp_loc_sp->GetLocationOptions();

+ }

+ if (bp_options)

+ m_bp_options_vec.push_back(bp_options);

+ }

+

+ // If we are using script language, get the script interpreter

+ // in order to set or collect command callback. Otherwise, call

+ // the methods associated with this object.

+ if (m_options.m_use_script_language) {

+ ScriptInterpreter *script_interp = m_interpreter.GetScriptInterpreter();

+ // Special handling for one-liner specified inline.

+ if (m_options.m_use_one_liner) {

+ script_interp->SetBreakpointCommandCallback(

+ m_bp_options_vec, m_options.m_one_liner.c_str());

+ } else if (!m_options.m_function_name.empty()) {

+ script_interp->SetBreakpointCommandCallbackFunction(

+ m_bp_options_vec, m_options.m_function_name.c_str());

+ } else {

+ script_interp->CollectDataForBreakpointCommandCallback(

+ m_bp_options_vec, result);

+ }

+ } else {

+ // Special handling for one-liner specified inline.

+ if (m_options.m_use_one_liner)

+ SetBreakpointCommandCallback(m_bp_options_vec,

+ m_options.m_one_liner.c_str());

+ else

+ CollectDataForBreakpointCommandCallback(m_bp_options_vec, result);

+ }

+ return result.Succeeded();

+ }

+private:

+ CommandOptions m_options;

+ std::vector<BreakpointOptions *> m_bp_options_vec; // This stores the

+ // breakpoint options that

+ // we are currently

+ // collecting commands for. In the CollectData... calls we need

+ // to hand this off to the IOHandler, which may run asynchronously.

+ // So we have to have some way to keep it alive, and not leak it.

+ // Making it an ivar of the command object, which never goes away

+ // achieves this. Note that if we were able to run

+ // the same command concurrently in one interpreter we'd have to

+ // make this "per invocation". But there are many more reasons

+ // why it is not in general safe to do that in lldb at present,

+ // so it isn't worthwhile to come up with a more complex mechanism

+ // to address this particular weakness right now.

+ static const char *g_reader_instructions;

+const char *CommandObjectBreakpointCommandAdd::g_reader_instructions =

+ "Enter your debugger command(s). Type 'DONE' to end.\n";

+static OptionDefinition g_breakpoint_delete_options[] = {

+ // clang-format off

+ { LLDB_OPT_SET_1, false, "dummy-breakpoints", 'D', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Delete commands from Dummy breakpoints - i.e. breakpoints set before a file is provided, which prime new targets." },

+ // clang-format on

+};

+

+class CommandObjectBreakpointCommandDelete : public CommandObjectParsed {

+ CommandObjectBreakpointCommandDelete(CommandInterpreter &interpreter)

+ : CommandObjectParsed(interpreter, "delete",

+ m_options() {

+ CommandArgumentEntry arg;

+ CommandArgumentData bp_id_arg;

+ // Define the first (and only) variant of this arg.

+ bp_id_arg.arg_type = eArgTypeBreakpointID;

+ bp_id_arg.arg_repetition = eArgRepeatPlain;

+ // There is only one variant this argument could be; put it into the

+ // argument entry.

+ arg.push_back(bp_id_arg);

+ // Push the data for the first argument into the m_arguments vector.

+ m_arguments.push_back(arg);

+ }

+ ~CommandObjectBreakpointCommandDelete() override = default;

+ Options *GetOptions() override { return &m_options; }

+ class CommandOptions : public Options {

+ public:

+ CommandOptions() : Options(), m_use_dummy(false) {}

+ ~CommandOptions() override = default;

+ Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,

+ ExecutionContext *execution_context) override {

+ Error error;

+ const int short_option = m_getopt_table[option_idx].val;

+ switch (short_option) {

+ case 'D':

+ m_use_dummy = true;

+ break;

+ default:

+ error.SetErrorStringWithFormat("unrecognized option '%c'",

+ short_option);

+ break;

+ }

+ return error;

+ }

+ void OptionParsingStarting(ExecutionContext *execution_context) override {

+ m_use_dummy = false;

+ }

+ llvm::ArrayRef<OptionDefinition> GetDefinitions() override {

+ return llvm::makeArrayRef(g_breakpoint_delete_options);

+ }

+ // Instance variables to hold the values for command options.

+ bool m_use_dummy;

+ };

+ bool DoExecute(Args &command, CommandReturnObject &result) override {

+ Target *target = GetSelectedOrDummyTarget(m_options.m_use_dummy);

+

+ if (target == nullptr) {

+ result.AppendError("There is not a current executable; there are no "

+ "breakpoints from which to delete commands");

+ result.SetStatus(eReturnStatusFailed);

+ return false;

+ }

+ const BreakpointList &breakpoints = target->GetBreakpointList();

+ size_t num_breakpoints = breakpoints.GetSize();

+ if (num_breakpoints == 0) {

+ result.AppendError("No breakpoints exist to have commands deleted");

+ result.SetStatus(eReturnStatusFailed);

+ return false;

+ }

+ if (command.empty()) {

+ result.AppendError(

+ "No breakpoint specified from which to delete the commands");

+ result.SetStatus(eReturnStatusFailed);

+ return false;

+ }

+ BreakpointIDList valid_bp_ids;

+ CommandObjectMultiwordBreakpoint::VerifyBreakpointOrLocationIDs(

+ command, target, result, &valid_bp_ids);

+

+ if (result.Succeeded()) {

+ const size_t count = valid_bp_ids.GetSize();

+ for (size_t i = 0; i < count; ++i) {

+ BreakpointID cur_bp_id = valid_bp_ids.GetBreakpointIDAtIndex(i);

+ if (cur_bp_id.GetBreakpointID() != LLDB_INVALID_BREAK_ID) {

+ Breakpoint *bp =

+ target->GetBreakpointByID(cur_bp_id.GetBreakpointID()).get();

+ if (cur_bp_id.GetLocationID() != LLDB_INVALID_BREAK_ID) {

+ BreakpointLocationSP bp_loc_sp(

+ bp->FindLocationByID(cur_bp_id.GetLocationID()));

+ if (bp_loc_sp)

+ bp_loc_sp->ClearCallback();

+ else {

+ result.AppendErrorWithFormat("Invalid breakpoint ID: %u.%u.\n",

+ cur_bp_id.GetBreakpointID(),

+ cur_bp_id.GetLocationID());

+ result.SetStatus(eReturnStatusFailed);

+ return false;

+ } else {

+ bp->ClearCallback();

+ }

+ }

+ return result.Succeeded();

+ }

+ CommandOptions m_options;

+class CommandObjectBreakpointCommandList : public CommandObjectParsed {

+ CommandObjectBreakpointCommandList(CommandInterpreter &interpreter)

+ : CommandObjectParsed(interpreter, "list", "List the script or set of "

+ "commands to be executed when "

+ "the breakpoint is hit.",

+ nullptr) {

+ CommandArgumentEntry arg;

+ CommandArgumentData bp_id_arg;

+

+ // Define the first (and only) variant of this arg.

+ bp_id_arg.arg_type = eArgTypeBreakpointID;

+ bp_id_arg.arg_repetition = eArgRepeatPlain;

+

+ // There is only one variant this argument could be; put it into the

+ // argument entry.

+ arg.push_back(bp_id_arg);

+ // Push the data for the first argument into the m_arguments vector.

+ m_arguments.push_back(arg);

+ }

+

+ ~CommandObjectBreakpointCommandList() override = default;

+ bool DoExecute(Args &command, CommandReturnObject &result) override {

+ Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();

+

+ if (target == nullptr) {

+ result.AppendError("There is not a current executable; there are no "

+ "breakpoints for which to list commands");

+ result.SetStatus(eReturnStatusFailed);

+ return false;

+ }

+ const BreakpointList &breakpoints = target->GetBreakpointList();

+ size_t num_breakpoints = breakpoints.GetSize();

+ if (num_breakpoints == 0) {

+ result.AppendError("No breakpoints exist for which to list commands");

+ result.SetStatus(eReturnStatusFailed);

+ return false;

+ }

+ if (command.empty()) {

+ result.AppendError(

+ "No breakpoint specified for which to list the commands");

+ result.SetStatus(eReturnStatusFailed);

+ return false;

+ }

+ BreakpointIDList valid_bp_ids;

+ CommandObjectMultiwordBreakpoint::VerifyBreakpointOrLocationIDs(

+ command, target, result, &valid_bp_ids);

+

+ if (result.Succeeded()) {

+ const size_t count = valid_bp_ids.GetSize();

+ for (size_t i = 0; i < count; ++i) {

+ BreakpointID cur_bp_id = valid_bp_ids.GetBreakpointIDAtIndex(i);

+ if (cur_bp_id.GetBreakpointID() != LLDB_INVALID_BREAK_ID) {

+ Breakpoint *bp =

+ target->GetBreakpointByID(cur_bp_id.GetBreakpointID()).get();

+

+ if (bp) {

+ const BreakpointOptions *bp_options = nullptr;

+ if (cur_bp_id.GetLocationID() != LLDB_INVALID_BREAK_ID) {

+ BreakpointLocationSP bp_loc_sp(

+ bp->FindLocationByID(cur_bp_id.GetLocationID()));

+ if (bp_loc_sp)

+ bp_options = bp_loc_sp->GetOptionsNoCreate();

+ else {

+ result.AppendErrorWithFormat("Invalid breakpoint ID: %u.%u.\n",

+ cur_bp_id.GetBreakpointID(),

+ cur_bp_id.GetLocationID());

+ result.SetStatus(eReturnStatusFailed);

+ return false;

+ }

+ } else {

+ bp_options = bp->GetOptions();

+ if (bp_options) {

+ StreamString id_str;

+ BreakpointID::GetCanonicalReference(&id_str,

+ cur_bp_id.GetBreakpointID(),

+ cur_bp_id.GetLocationID());

+ const Baton *baton = bp_options->GetBaton();

+ if (baton) {

+ result.GetOutputStream().Printf("Breakpoint %s:\n",

+ id_str.GetData());

+ result.GetOutputStream().IndentMore();

+ baton->GetDescription(&result.GetOutputStream(),

+ eDescriptionLevelFull);

+ result.GetOutputStream().IndentLess();

+ } else {

+ result.AppendMessageWithFormat(

+ "Breakpoint %s does not have an associated command.\n",

+ id_str.GetData());

+ }

+ }

+ result.SetStatus(eReturnStatusSuccessFinishResult);

+ } else {

+ result.AppendErrorWithFormat("Invalid breakpoint ID: %u.\n",

+ cur_bp_id.GetBreakpointID());

+ result.SetStatus(eReturnStatusFailed);

+ }

+ }

+ }

+

+ return result.Succeeded();

+ }

+CommandObjectBreakpointCommand::CommandObjectBreakpointCommand(

+ CommandInterpreter &interpreter)

+ interpreter, "command", "Commands for adding, removing and listing "

+ "LLDB commands executed when a breakpoint is "

+ "hit.",

+ "command <sub-command> [<sub-command-options>] <breakpoint-id>") {

+ CommandObjectSP add_command_object(

+ new CommandObjectBreakpointCommandAdd(interpreter));

+ CommandObjectSP delete_command_object(

+ new CommandObjectBreakpointCommandDelete(interpreter));

+ CommandObjectSP list_command_object(

+ new CommandObjectBreakpointCommandList(interpreter));

+

+ add_command_object->SetCommandName("breakpoint command add");

+ delete_command_object->SetCommandName("breakpoint command delete");

+ list_command_object->SetCommandName("breakpoint command list");

+

+ LoadSubCommand("add", add_command_object);

+ LoadSubCommand("delete", delete_command_object);

+ LoadSubCommand("list", list_command_object);