48#pragma mark Modify::CommandOptions
49#define LLDB_OPTIONS_breakpoint_modify
50#include "CommandOptions.inc"
59 return llvm::ArrayRef(g_breakpoint_modify_options);
65 const int short_option =
66 g_breakpoint_modify_options[option_idx].short_option;
67 const char *long_option =
68 g_breakpoint_modify_options[option_idx].long_option;
70 switch (short_option) {
96 uint32_t ignore_count;
97 if (option_arg.getAsInteger(0, ignore_count))
114 if (option_arg ==
"current") {
115 if (!execution_context) {
117 option_arg, short_option, long_option,
118 "No context to determine current thread");
121 if (!ctx_thread_sp || !ctx_thread_sp->IsValid()) {
124 "No currently selected thread");
126 thread_id = ctx_thread_sp->GetID();
129 }
else if (option_arg.getAsInteger(0, thread_id)) {
144 if (option_arg.getAsInteger(0, thread_index)) {
152 llvm_unreachable(
"Unimplemented option");
165 auto cmd_data = std::make_unique<BreakpointOptions::CommandData>();
168 cmd_data->user_source.AppendString(str);
170 cmd_data->stop_on_error =
true;
182#define LLDB_OPTIONS_breakpoint_dummy
183#include "CommandOptions.inc"
192 return llvm::ArrayRef(g_breakpoint_dummy_options);
198 const int short_option =
199 g_breakpoint_dummy_options[option_idx].short_option;
201 switch (short_option) {
206 llvm_unreachable(
"Unimplemented option");
219#define LLDB_OPTIONS_breakpoint_set
220#include "CommandOptions.inc"
239 interpreter,
"breakpoint set",
240 "Sets a breakpoint or set of breakpoints in the executable.",
241 "breakpoint set <cmd-options>"),
267 const int short_option =
268 g_breakpoint_set_options[option_idx].short_option;
269 const char *long_option =
270 g_breakpoint_set_options[option_idx].long_option;
272 switch (short_option) {
288 if (option_arg.getAsInteger(0,
m_column))
297 llvm::StringRef error_context;
316 "Set exception breakpoints separately for c++ and objective-c";
319 error_context =
"Unknown language type for exception breakpoint";
322 error_context =
"Unsupported language type for exception breakpoint";
324 if (!error_context.empty())
326 long_option, error_context);
412 option_arg, short_option, long_option,
"Invalid breakpoint name");
419 option_arg, 0, &
error);
474 llvm_unreachable(
"Unimplemented option");
506 return llvm::ArrayRef(g_breakpoint_set_options);
570 const bool internal =
false;
578 switch (break_type) {
583 if (num_files == 0) {
585 result.
AppendError(
"No file supplied and no default file available.");
588 }
else if (num_files > 1) {
589 result.
AppendError(
"Only one file at a time is allowed for file and "
590 "line breakpoints.");
611 if (num_modules_specified == 1) {
616 }
else if (num_modules_specified == 0) {
620 result.
AppendError(
"Only one shared library can be specified for "
621 "address breakpoints.");
630 if (name_type_mask == 0)
631 name_type_mask = eFunctionNameTypeAuto;
644 if (llvm::Error err = regexp.
GetError()) {
646 "Function name regular expression could not be compiled: %s",
647 llvm::toString(std::move(err)).c_str());
654 "Function name regex does not accept glob patterns.");
672 "No files provided and could not find default file.");
680 if (llvm::Error err = regexp.
GetError()) {
682 "Source text regular expression could not be compiled: \"%s\"",
683 llvm::toString(std::move(err)).c_str());
697 if (precond_error.
Fail()) {
699 "Error setting extra exception arguments: %s",
714 "Error setting extra exception arguments: %s",
error.AsCString());
731 if (name_error.
Fail()) {
743 const bool show_locations =
false;
747 output_stream.
Printf(
"Breakpoint set in dummy target, will get copied "
748 "into future targets.\n");
754 output_stream.
Printf(
"WARNING: Unable to resolve breakpoint to any "
755 "actual locations.\n");
760 result.
AppendError(
"Breakpoint creation failed: No breakpoint created.");
767 uint32_t default_line;
772 if (cur_frame ==
nullptr) {
774 "No selected frame to use to find the default file.");
777 result.
AppendError(
"Cannot use the selected frame to find the default "
778 "file, it has no debug info.");
786 result.
AppendError(
"Can't find the file for the selected frame to "
787 "use as the default file.");
809 "Modify the options on a breakpoint or set of "
810 "breakpoints in the executable. "
811 "If no breakpoint is specified, acts on the last "
812 "created breakpoint. "
813 "With the exception of -e, -d and -i, passing an "
814 "empty argument clears the modification.",
840 std::unique_lock<std::recursive_mutex> lock;
846 command, &target, result, &valid_bp_ids,
847 BreakpointName::Permissions::PermissionKinds::disablePerm);
850 const size_t count = valid_bp_ids.
GetSize();
851 for (
size_t i = 0; i < count; ++i) {
885 "Enable the specified disabled breakpoint(s). If "
886 "no breakpoints are specified, enable all of them.",
904 std::unique_lock<std::recursive_mutex> lock;
909 size_t num_breakpoints = breakpoints.
GetSize();
911 if (num_breakpoints == 0) {
912 result.
AppendError(
"No breakpoints exist to be enabled.");
916 if (command.
empty()) {
921 (uint64_t)num_breakpoints);
927 command, &target, result, &valid_bp_ids,
928 BreakpointName::Permissions::PermissionKinds::disablePerm);
931 int enable_count = 0;
933 const size_t count = valid_bp_ids.
GetSize();
934 for (
size_t i = 0; i < count; ++i) {
954 enable_count + loc_count);
968 interpreter,
"breakpoint disable",
969 "Disable the specified breakpoint(s) without deleting "
970 "them. If none are specified, disable all "
974 "Disable the specified breakpoint(s) without deleting them. \
975If none are specified, disable all breakpoints."
979 "Note: disabling a breakpoint will cause none of its locations to be hit \
980regardless of whether individual locations are enabled or disabled. After the sequence:"
983 (lldb) break disable 1
984 (lldb) break enable 1.1
986execution will NOT stop at location 1.1. To achieve that, type:
988 (lldb) break disable 1.*
989 (lldb) break enable 1.1
992 "The first command disables all locations for breakpoint 1, \
993the second re-enables the first location.");
1010 std::unique_lock<std::recursive_mutex> lock;
1014 size_t num_breakpoints = breakpoints.
GetSize();
1016 if (num_breakpoints == 0) {
1017 result.
AppendError(
"No breakpoints exist to be disabled.");
1021 if (command.
empty()) {
1026 (uint64_t)num_breakpoints);
1033 command, &target, result, &valid_bp_ids,
1034 BreakpointName::Permissions::PermissionKinds::disablePerm);
1037 int disable_count = 0;
1039 const size_t count = valid_bp_ids.
GetSize();
1040 for (
size_t i = 0; i < count; ++i) {
1060 disable_count + loc_count);
1069#pragma mark List::CommandOptions
1070#define LLDB_OPTIONS_breakpoint_list
1071#include "CommandOptions.inc"
1079 interpreter,
"breakpoint list",
1080 "List some or all breakpoints at configurable levels of detail.",
1104 switch (short_option) {
1121 llvm_unreachable(
"Unimplemented option");
1134 return llvm::ArrayRef(g_breakpoint_list_options);
1151 std::unique_lock<std::recursive_mutex> lock;
1154 size_t num_breakpoints = breakpoints.
GetSize();
1156 if (num_breakpoints == 0) {
1164 if (command.
empty()) {
1167 for (
size_t i = 0; i < num_breakpoints; ++i) {
1178 command, &target, result, &valid_bp_ids,
1179 BreakpointName::Permissions::PermissionKinds::listPerm);
1182 for (
size_t i = 0; i < valid_bp_ids.
GetSize(); ++i) {
1201#pragma mark Clear::CommandOptions
1203#define LLDB_OPTIONS_breakpoint_clear
1204#include "CommandOptions.inc"
1214 "Delete or disable breakpoints matching the "
1215 "specified source file and line.",
1216 "breakpoint clear <cmd-options>") {}
1233 switch (short_option) {
1243 llvm_unreachable(
"Unimplemented option");
1255 return llvm::ArrayRef(g_breakpoint_clear_options);
1277 std::unique_lock<std::recursive_mutex> lock;
1281 size_t num_breakpoints = breakpoints.
GetSize();
1284 if (num_breakpoints == 0) {
1285 result.
AppendError(
"Breakpoint clear: No breakpoint cleared.");
1292 std::vector<break_id_t> BreakIDs;
1293 for (
size_t i = 0; i < num_breakpoints; ++i)
1296 int num_cleared = 0;
1298 switch (break_type) {
1304 for (
size_t i = 0; i < num_breakpoints; ++i) {
1310 if (loc_coll.
GetSize() == 0) {
1324 if (num_cleared > 0) {
1326 output_stream.
Printf(
"%d breakpoints cleared:\n", num_cleared);
1328 output_stream.
EOL();
1331 result.
AppendError(
"Breakpoint clear: No breakpoint cleared.");
1340#define LLDB_OPTIONS_breakpoint_delete
1341#include "CommandOptions.inc"
1349 "Delete the specified breakpoint(s). If no "
1350 "breakpoints are specified, delete them all.",
1377 switch (short_option) {
1391 llvm_unreachable(
"Unimplemented option");
1404 return llvm::ArrayRef(g_breakpoint_delete_options);
1418 std::unique_lock<std::recursive_mutex> lock;
1423 size_t num_breakpoints = breakpoints.
GetSize();
1425 if (num_breakpoints == 0) {
1426 result.
AppendError(
"No breakpoints exist to be deleted.");
1434 "About to delete all breakpoints, do you want to do that?",
1440 "All breakpoints removed. (%" PRIu64
" breakpoint%s)\n",
1441 (uint64_t)num_breakpoints, num_breakpoints > 1 ?
"s" :
"");
1455 if (!command.
empty()) {
1457 command, &target, result, &excluded_bp_ids,
1458 BreakpointName::Permissions::PermissionKinds::deletePerm);
1463 for (
auto breakpoint_sp : breakpoints.
Breakpoints()) {
1464 if (!breakpoint_sp->IsEnabled() && breakpoint_sp->AllowDelete()) {
1466 if (!excluded_bp_ids.
Contains(bp_id))
1470 if (valid_bp_ids.
GetSize() == 0) {
1476 command, &target, result, &valid_bp_ids,
1477 BreakpointName::Permissions::PermissionKinds::deletePerm);
1482 int delete_count = 0;
1483 int disable_count = 0;
1484 const size_t count = valid_bp_ids.
GetSize();
1485 for (
size_t i = 0; i < count; ++i) {
1507 "%d breakpoints deleted; %d breakpoint locations disabled.\n",
1508 delete_count, disable_count);
1517#define LLDB_OPTIONS_breakpoint_name
1518#include "CommandOptions.inc"
1528 return llvm::ArrayRef(g_breakpoint_name_options);
1534 const int short_option = g_breakpoint_name_options[option_idx].short_option;
1535 const char *long_option = g_breakpoint_name_options[option_idx].long_option;
1537 switch (short_option) {
1558 llvm_unreachable(
"Unimplemented option");
1577#define LLDB_OPTIONS_breakpoint_access
1578#include "CommandOptions.inc"
1587 return llvm::ArrayRef(g_breakpoint_access_options);
1592 const int short_option =
1593 g_breakpoint_access_options[option_idx].short_option;
1594 const char *long_option =
1595 g_breakpoint_access_options[option_idx].long_option;
1597 switch (short_option) {
1599 bool value, success;
1608 bool value, success;
1617 bool value, success;
1626 llvm_unreachable(
"Unimplemented option");
1644 interpreter,
"configure",
1645 "Configure the options for the breakpoint"
1647 "If you provide a breakpoint id, the options will be copied from "
1648 "the breakpoint, otherwise only the options specified will be set "
1650 "breakpoint name configure <command-options> "
1651 "<breakpoint-name-list>") {
1677 std::unique_lock<std::recursive_mutex> lock;
1681 for (
auto &entry : command.
entries()) {
1685 entry.c_str(),
error.AsCString());
1704 for (
auto &entry : command.
entries()) {
1736 interpreter,
"add",
"Add a name to the breakpoints provided.",
1737 "breakpoint name add <command-options> <breakpoint-id-list>") {
1765 std::unique_lock<std::recursive_mutex> lock;
1770 size_t num_breakpoints = breakpoints.
GetSize();
1771 if (num_breakpoints == 0) {
1772 result.
AppendError(
"No breakpoints, cannot add names.");
1779 command, &target, result, &valid_bp_ids,
1780 BreakpointName::Permissions::PermissionKinds::listPerm);
1783 if (valid_bp_ids.
GetSize() == 0) {
1784 result.
AppendError(
"No breakpoints specified, cannot add names.");
1787 size_t num_valid_ids = valid_bp_ids.
GetSize();
1791 for (
size_t index = 0; index < num_valid_ids; index++) {
1809 interpreter,
"delete",
1810 "Delete a name from the breakpoints provided.",
1811 "breakpoint name delete <command-options> <breakpoint-id-list>") {
1839 std::unique_lock<std::recursive_mutex> lock;
1844 size_t num_breakpoints = breakpoints.
GetSize();
1845 if (num_breakpoints == 0) {
1846 result.
AppendError(
"No breakpoints, cannot delete names.");
1853 command, &target, result, &valid_bp_ids,
1854 BreakpointName::Permissions::PermissionKinds::deletePerm);
1857 if (valid_bp_ids.
GetSize() == 0) {
1858 result.
AppendError(
"No breakpoints specified, cannot delete names.");
1862 size_t num_valid_ids = valid_bp_ids.
GetSize();
1863 for (
size_t index = 0; index < num_valid_ids; index++) {
1881 "List either the names for a breakpoint or info "
1882 "about a given name. With no arguments, lists all "
1884 "breakpoint name list <command-options>") {
1898 std::vector<std::string> name_list;
1899 if (command.
empty()) {
1903 name_list.push_back(arg.c_str());
1907 if (name_list.empty()) {
1910 for (
const std::string &name_str : name_list) {
1911 const char *name = name_str.c_str();
1923 std::unique_lock<std::recursive_mutex> lock;
1927 bool any_set =
false;
1929 if (bp_sp->MatchesName(name)) {
1956 interpreter,
"name",
"Commands to manage breakpoint names") {
1961Breakpoint names provide a general tagging mechanism for breakpoints. Each
1962breakpoint name can be added to any number of breakpoints, and each breakpoint
1963can have any number of breakpoint names attached to it. For instance:
1965 (lldb) break name add -N MyName 1-10
1967adds the name MyName to breakpoints 1-10, and:
1969 (lldb) break set -n myFunc -N Name1 -N Name2
1971adds two names to the breakpoint set at myFunc.
1973They have a number of interrelated uses:
19751) They provide a stable way to refer to a breakpoint (e.g. in another
1976breakpoint's action). Using the breakpoint ID for this purpose is fragile, since
1977it depends on the order of breakpoint creation. Giving a name to the breakpoint
1978you want to act on, and then referring to it by name, is more robust:
1980 (lldb) break set -n myFunc -N BKPT1
1981 (lldb) break set -n myOtherFunc -C "break disable BKPT1"
19832) This is actually just a specific use of a more general feature of breakpoint
1984names. The <breakpt-id-list> argument type used to specify one or more
1985breakpoints in most of the commands that deal with breakpoints also accepts
1986breakpoint names. That allows you to refer to one breakpoint in a stable
1987manner, but also makes them a convenient grouping mechanism, allowing you to
1988easily act on a group of breakpoints by using their name, for instance disabling
1989them all in one action:
1991 (lldb) break set -n myFunc -N Group1
1992 (lldb) break set -n myOtherFunc -N Group1
1993 (lldb) break disable Group1
19953) But breakpoint names are also entities in their own right, and can be
1996configured with all the modifiable attributes of a breakpoint. Then when you
1997add a breakpoint name to a breakpoint, the breakpoint will be configured to
1998match the state of the breakpoint name. The link between the name and the
1999breakpoints sharing it remains live, so if you change the configuration on the
2000name, it will also change the configurations on the breakpoints:
2002 (lldb) break name configure -i 10 IgnoreSome
2003 (lldb) break set -n myFunc -N IgnoreSome
2004 (lldb) break list IgnoreSome
2005 2: name = 'myFunc', locations = 0 (pending) Options: ignore: 10 enabled
2008 (lldb) break name configure -i 5 IgnoreSome
2009 (lldb) break list IgnoreSome
2010 2: name = 'myFunc', locations = 0 (pending) Options: ignore: 5 enabled
2014Options that are not configured on a breakpoint name don't affect the value of
2015those options on the breakpoints they are added to. So for instance, if Name1
2016has the -i option configured and Name2 the -c option, adding both names to a
2017breakpoint will set the -i option from Name1 and the -c option from Name2, and
2018the other options will be unaltered.
2020If you add multiple names to a breakpoint which have configured values for
2021the same option, the last name added's value wins.
2023The "liveness" of these settings is one way, from name to breakpoint.
2024If you use "break modify" to change an option that is also configured on a name
2025which that breakpoint has, the "break modify" command will override the setting
2026for that breakpoint, but won't change the value configured in the name or on the
2027other breakpoints sharing that name.
20294) Breakpoint names are also a convenient way to copy option sets from one
2030breakpoint to another. Using the -B option to "breakpoint name configure" makes
2031a name configured with all the options of the original breakpoint. Then
2032adding that name to another breakpoint copies over all the values from the
2033original breakpoint to the new one.
20355) You can also use breakpoint names to hide breakpoints from the breakpoint
2036operations that act on all breakpoints: "break delete", "break disable" and
2037"break list". You do that by specifying a "false" value for the
2038--allow-{list,delete,disable} options to "breakpoint name configure" and then
2039adding that name to a breakpoint.
2041This won't keep the breakpoint from being deleted or disabled if you refer to it
2042specifically by ID. The point of the feature is to make sure users don't
2043inadvertently delete or disable useful breakpoints (e.g. ones an IDE is using
2044for its own purposes) as part of a "delete all" or "disable all" operation. The
2045list hiding is because it's confusing for people to see breakpoints they
2068#pragma mark Read::CommandOptions
2069#define LLDB_OPTIONS_breakpoint_read
2070#include "CommandOptions.inc"
2078 "Read and set the breakpoints previously saved to "
2079 "a file with \"breakpoint write\". ",
2096 const char *long_option =
2099 switch (short_option) {
2110 m_names.push_back(std::string(option_arg));
2114 llvm_unreachable(
"Unimplemented option");
2126 return llvm::ArrayRef(g_breakpoint_read_options);
2132 int opt_arg_pos = opt_element_vector[opt_element_index].opt_arg_pos;
2133 int opt_defs_index = opt_element_vector[opt_element_index].opt_defs_index;
2142 std::optional<FileSpec> file_spec;
2143 const llvm::StringRef dash_f(
"-f");
2144 for (
int arg_idx = 0; arg_idx < opt_arg_pos; arg_idx++) {
2158 if (!
error.Success())
2165 const size_t num_bkpts = bkpt_array->
GetSize();
2166 for (
size_t i = 0; i < num_bkpts; i++) {
2169 if (!bkpt_object_sp)
2191 size_t num_names = names_array->
GetSize();
2193 for (
size_t i = 0; i < num_names; i++) {
2194 if (std::optional<llvm::StringRef> maybe_name =
2210 std::unique_lock<std::recursive_mutex> lock;
2219 if (!
error.Success()) {
2226 size_t num_breakpoints = new_bps.
GetSize();
2227 if (num_breakpoints == 0) {
2232 for (
size_t i = 0; i < num_breakpoints; ++i) {
2249#pragma mark Write::CommandOptions
2250#define LLDB_OPTIONS_breakpoint_write
2251#include "CommandOptions.inc"
2258 "Write the breakpoints listed to a file that can "
2259 "be read in with \"breakpoint read\". "
2260 "If given no arguments, writes all breakpoints.",
2287 switch (short_option) {
2295 llvm_unreachable(
"Unimplemented option");
2307 return llvm::ArrayRef(g_breakpoint_write_options);
2320 std::unique_lock<std::recursive_mutex> lock;
2324 if (!command.
empty()) {
2326 command, &target, result, &valid_bp_ids,
2327 BreakpointName::Permissions::PermissionKinds::listPerm);
2338 if (!
error.Success()) {
2349#pragma mark MultiwordBreakpoint
2354 interpreter,
"breakpoint",
2355 "Commands for operating on breakpoints (see 'help b' for shorthand.)",
2356 "breakpoint <subcommand> [<command-options>]") {
2380 list_command_object->SetCommandName(
"breakpoint list");
2381 enable_command_object->SetCommandName(
"breakpoint enable");
2382 disable_command_object->SetCommandName(
"breakpoint disable");
2383 clear_command_object->SetCommandName(
"breakpoint clear");
2384 delete_command_object->SetCommandName(
"breakpoint delete");
2385 set_command_object->SetCommandName(
"breakpoint set");
2386 command_command_object->SetCommandName(
"breakpoint command");
2387 modify_command_object->SetCommandName(
"breakpoint modify");
2388 name_command_object->SetCommandName(
"breakpoint name");
2389 write_command_object->SetCommandName(
"breakpoint write");
2390 read_command_object->SetCommandName(
"breakpoint read");
2408 Args &args,
Target *target,
bool allow_locations,
2410 BreakpointName::Permissions ::PermissionKinds purpose) {
2431 "No breakpoint specified and no last created breakpoint.");
2443 args, target, allow_locations, purpose, temp_args)) {
2463 const size_t count = valid_ids->
GetSize();
2464 for (
size_t i = 0; i < count; ++i) {
2468 if (breakpoint !=
nullptr) {
2470 if (
static_cast<size_t>(cur_bp_id.
GetLocationID()) > num_locations) {
2476 "'%s' is not a currently valid breakpoint/location id.\n",
2482 "'%d' is not a currently valid breakpoint ID.\n",
static void AddBreakpointDescription(Stream *s, Breakpoint *bp, lldb::DescriptionLevel level)
static llvm::raw_ostream & error(Stream &strm)
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
BreakpointAccessOptionGroup()=default
const BreakpointName::Permissions & GetPermissions() const
~BreakpointAccessOptionGroup() override=default
BreakpointName::Permissions m_permissions
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
void OptionParsingStarting(ExecutionContext *execution_context) override
BreakpointDummyOptionGroup()=default
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
void OptionParsingStarting(ExecutionContext *execution_context) override
~BreakpointDummyOptionGroup() override=default
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
OptionValueBoolean m_use_dummy
BreakpointNameOptionGroup()
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
OptionValueString m_help_string
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
~BreakpointNameOptionGroup() override=default
void OptionParsingStarting(ExecutionContext *execution_context) override
OptionValueUInt64 m_breakpoint
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
Set the value of an option.
~CommandOptions() override=default
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
void OptionParsingStarting(ExecutionContext *execution_context) override
void DoExecute(Args &command, CommandReturnObject &result) override
Options * GetOptions() override
CommandObjectBreakpointClear(CommandInterpreter &interpreter)
~CommandObjectBreakpointClear() override=default
void OptionParsingStarting(ExecutionContext *execution_context) override
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
Set the value of an option.
~CommandOptions() override=default
CommandObjectBreakpointDelete(CommandInterpreter &interpreter)
~CommandObjectBreakpointDelete() override=default
void HandleArgumentCompletion(CompletionRequest &request, OptionElementVector &opt_element_vector) override
The default version handles argument definitions that have only one argument type,...
Options * GetOptions() override
void DoExecute(Args &command, CommandReturnObject &result) override
~CommandObjectBreakpointDisable() override=default
CommandObjectBreakpointDisable(CommandInterpreter &interpreter)
void DoExecute(Args &command, CommandReturnObject &result) override
void HandleArgumentCompletion(CompletionRequest &request, OptionElementVector &opt_element_vector) override
The default version handles argument definitions that have only one argument type,...
~CommandObjectBreakpointEnable() override=default
void HandleArgumentCompletion(CompletionRequest &request, OptionElementVector &opt_element_vector) override
The default version handles argument definitions that have only one argument type,...
CommandObjectBreakpointEnable(CommandInterpreter &interpreter)
void DoExecute(Args &command, CommandReturnObject &result) override
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
~CommandOptions() override=default
void OptionParsingStarting(ExecutionContext *execution_context) override
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
Set the value of an option.
lldb::DescriptionLevel m_level
~CommandObjectBreakpointList() override=default
Options * GetOptions() override
void DoExecute(Args &command, CommandReturnObject &result) override
CommandObjectBreakpointList(CommandInterpreter &interpreter)
void DoExecute(Args &command, CommandReturnObject &result) override
BreakpointDummyOptionGroup m_dummy_opts
void HandleArgumentCompletion(CompletionRequest &request, OptionElementVector &opt_element_vector) override
The default version handles argument definitions that have only one argument type,...
CommandObjectBreakpointModify(CommandInterpreter &interpreter)
BreakpointOptionGroup m_bp_opts
~CommandObjectBreakpointModify() override=default
OptionGroupOptions m_options
Options * GetOptions() override
void DoExecute(Args &command, CommandReturnObject &result) override
OptionGroupOptions m_option_group
CommandObjectBreakpointNameAdd(CommandInterpreter &interpreter)
Options * GetOptions() override
~CommandObjectBreakpointNameAdd() override=default
BreakpointNameOptionGroup m_name_options
void HandleArgumentCompletion(CompletionRequest &request, OptionElementVector &opt_element_vector) override
The default version handles argument definitions that have only one argument type,...
BreakpointNameOptionGroup m_name_options
void HandleArgumentCompletion(CompletionRequest &request, OptionElementVector &opt_element_vector) override
The default version handles argument definitions that have only one argument type,...
CommandObjectBreakpointNameDelete(CommandInterpreter &interpreter)
Options * GetOptions() override
void DoExecute(Args &command, CommandReturnObject &result) override
~CommandObjectBreakpointNameDelete() override=default
OptionGroupOptions m_option_group
CommandObjectBreakpointNameList(CommandInterpreter &interpreter)
void DoExecute(Args &command, CommandReturnObject &result) override
Options * GetOptions() override
OptionGroupOptions m_option_group
~CommandObjectBreakpointNameList() override=default
BreakpointNameOptionGroup m_name_options
~CommandObjectBreakpointName() override=default
CommandObjectBreakpointName(CommandInterpreter &interpreter)
void HandleOptionArgumentCompletion(CompletionRequest &request, OptionElementVector &opt_element_vector, int opt_element_index, CommandInterpreter &interpreter) override
Handles the generic bits of figuring out whether we are in an option, and if so completing it.
std::vector< std::string > m_names
~CommandOptions() override=default
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
Set the value of an option.
void OptionParsingStarting(ExecutionContext *execution_context) override
void DoExecute(Args &command, CommandReturnObject &result) override
CommandObjectBreakpointRead(CommandInterpreter &interpreter)
Options * GetOptions() override
~CommandObjectBreakpointRead() override=default
lldb::LanguageType m_language
void OptionParsingStarting(ExecutionContext *execution_context) override
std::string m_func_regexp
std::string m_source_text_regexp
std::vector< std::string > m_breakpoint_names
~CommandOptions() override=default
Args m_exception_extra_args
std::string m_current_key
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
lldb::LanguageType m_exception_language
lldb::addr_t m_offset_addr
LazyBool m_move_to_nearest_code
lldb::FunctionNameType m_func_name_type_mask
std::vector< std::string > m_func_names
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
std::unordered_set< std::string > m_source_regex_func_names
OptionGroupOptions m_all_options
~CommandObjectBreakpointSet() override=default
BreakpointOptionGroup m_bp_opts
bool GetDefaultFile(Target &target, FileSpec &file, CommandReturnObject &result)
void DoExecute(Args &command, CommandReturnObject &result) override
Options * GetOptions() override
OptionGroupPythonClassWithDict m_python_class_options
CommandObjectBreakpointSet(CommandInterpreter &interpreter)
BreakpointDummyOptionGroup m_dummy_options
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
void OptionParsingStarting(ExecutionContext *execution_context) override
~CommandOptions() override=default
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
Set the value of an option.
void DoExecute(Args &command, CommandReturnObject &result) override
Options * GetOptions() override
void HandleArgumentCompletion(CompletionRequest &request, OptionElementVector &opt_element_vector) override
The default version handles argument definitions that have only one argument type,...
CommandObjectBreakpointWrite(CommandInterpreter &interpreter)
~CommandObjectBreakpointWrite() override=default
A command line argument class.
llvm::ArrayRef< const char * > GetArgumentArrayRef() const
Gets the argument as an ArrayRef.
size_t GetArgumentCount() const
Gets the number of arguments left in this command object.
void AppendArgument(llvm::StringRef arg_str, char quote_char='\0')
Appends a new argument to the end of the list argument list.
llvm::ArrayRef< ArgEntry > entries() const
const char * GetArgumentAtIndex(size_t idx) const
Gets the NULL terminated C string argument pointer for the argument at index idx.
void Clear()
Clear the arguments.
bool Contains(BreakpointID bp_id) const
bool AddBreakpointID(BreakpointID bp_id)
BreakpointID GetBreakpointIDAtIndex(size_t index) const
static llvm::Error FindAndReplaceIDRanges(Args &old_args, Target *target, bool allow_locations, BreakpointName::Permissions ::PermissionKinds purpose, Args &new_args)
static std::optional< BreakpointID > ParseCanonicalReference(llvm::StringRef input)
Takes an input string containing the description of a breakpoint or breakpoint and location and retur...
lldb::break_id_t GetBreakpointID() const
lldb::break_id_t GetLocationID() const
static void GetCanonicalReference(Stream *s, lldb::break_id_t break_id, lldb::break_id_t break_loc_id)
Takes a breakpoint ID and the breakpoint location id and returns a string containing the canonical de...
static bool StringIsBreakpointName(llvm::StringRef str, Status &error)
Takes an input string and checks to see whether it is a breakpoint name.
General Outline: Allows adding and removing breakpoints and find by ID and index.
BreakpointIterable Breakpoints()
lldb::BreakpointSP FindBreakpointByID(lldb::break_id_t breakID) const
Returns a shared pointer to the breakpoint with id breakID.
void GetListMutex(std::unique_lock< std::recursive_mutex > &lock)
Sets the passed in Locker to hold the Breakpoint List mutex.
size_t GetSize() const
Returns the number of elements in this breakpoint list.
lldb::BreakpointSP GetBreakpointAtIndex(size_t i) const
Returns a shared pointer to the breakpoint with index i.
size_t GetSize() const
Returns the number of elements in this breakpoint location list.
General Outline: A breakpoint location is defined by the breakpoint that produces it,...
BreakpointOptions & GetLocationOptions()
Use this to set location specific breakpoint options.
void SetEnabled(bool enabled)
If enabled is true, enable the breakpoint, if false disable it.
bool SetAllowDisable(bool value)
bool SetAllowList(bool value)
bool SetAllowDelete(bool value)
bool GetDescription(Stream *s, lldb::DescriptionLevel level)
void SetHelp(const char *description)
BreakpointOptions & GetOptions()
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
Status OptionParsingFinished(ExecutionContext *execution_context) override
const BreakpointOptions & GetBreakpointOptions()
BreakpointOptions m_bp_opts
std::vector< std::string > m_commands
~BreakpointOptionGroup() override=default
void OptionParsingStarting(ExecutionContext *execution_context) override
"lldb/Breakpoint/BreakpointOptions.h" Class that manages the options on a breakpoint or breakpoint lo...
Flags m_set_flags
Which options are set at this level.
void SetIgnoreCount(uint32_t n)
Set the breakpoint to ignore the next count breakpoint hits.
void SetEnabled(bool enabled)
If enable is true, enable the breakpoint, if false disable it.
void SetCondition(const char *condition)
Set the breakpoint option's condition.
ThreadSpec * GetThreadSpec()
Returns a pointer to the ThreadSpec for this option, creating it.
void SetOneShot(bool one_shot)
If enable is true, enable the breakpoint, if false disable it.
void SetAutoContinue(bool auto_continue)
Set the auto-continue state.
void SetThreadID(lldb::tid_t thread_id)
void CopyOverSetOptions(const BreakpointOptions &rhs)
Copy over only the options set in the incoming BreakpointOptions.
void SetCommandDataCallback(std::unique_ptr< CommandData > &cmd_data)
Set a callback based on BreakpointOptions::CommandData.
General Outline: A breakpoint has four main parts, a filter, a resolver, the list of breakpoint locat...
void GetDescription(Stream *s, lldb::DescriptionLevel level, bool show_locations=false)
Put a description of this breakpoint into the stream s.
BreakpointOptions & GetOptions()
Returns the BreakpointOptions structure set at the breakpoint level.
static const char * GetSerializationKey()
bool GetMatchingFileLine(ConstString filename, uint32_t line_number, BreakpointLocationCollection &loc_coll)
Find breakpoint locations which match the (filename, line_number) description.
lldb::BreakpointLocationSP FindLocationByID(lldb::break_id_t bp_loc_id)
Find a breakpoint location for a given breakpoint location ID.
size_t GetNumLocations() const
Return the number of breakpoint locations.
void SetEnabled(bool enable) override
If enable is true, enable the breakpoint, if false disable it.
static bool InvokeCommonCompletionCallbacks(CommandInterpreter &interpreter, uint32_t completion_mask, lldb_private::CompletionRequest &request, SearchFilter *searcher)
bool Confirm(llvm::StringRef message, bool default_answer)
static void VerifyBreakpointOrLocationIDs(Args &args, Target *target, CommandReturnObject &result, BreakpointIDList *valid_ids, BreakpointName::Permissions ::PermissionKinds purpose)
static void VerifyIDs(Args &args, Target *target, bool allow_locations, CommandReturnObject &result, BreakpointIDList *valid_ids, BreakpointName::Permissions::PermissionKinds purpose)
CommandObjectMultiwordBreakpoint(CommandInterpreter &interpreter)
~CommandObjectMultiwordBreakpoint() override
static void VerifyBreakpointIDs(Args &args, Target *target, CommandReturnObject &result, BreakpointIDList *valid_ids, BreakpointName::Permissions::PermissionKinds purpose)
bool LoadSubCommand(llvm::StringRef cmd_name, const lldb::CommandObjectSP &command_obj) override
std::vector< CommandArgumentData > CommandArgumentEntry
virtual void SetHelpLong(llvm::StringRef str)
void AddSimpleArgumentList(lldb::CommandArgumentType arg_type, ArgumentRepetitionType repetition_type=eArgRepeatPlain)
Target & GetDummyTarget()
ExecutionContext m_exe_ctx
void AddIDsArgumentData(IDType type)
CommandInterpreter & GetCommandInterpreter()
CommandInterpreter & m_interpreter
Target & GetSelectedOrDummyTarget(bool prefer_dummy=false)
void AppendErrorWithFormatv(const char *format, Args &&... args)
void AppendMessage(llvm::StringRef in_string)
void void AppendError(llvm::StringRef in_string)
void SetStatus(lldb::ReturnStatus status)
void AppendErrorWithFormat(const char *format,...) __attribute__((format(printf
void AppendMessageWithFormat(const char *format,...) __attribute__((format(printf
void void AppendWarning(llvm::StringRef in_string)
void SetError(const Status &error, const char *fallback_error_cstr=nullptr)
Stream & GetOutputStream()
"lldb/Utility/ArgCompletionRequest.h"
const Args & GetParsedLine() const
void TryCompleteCurrentArg(llvm::StringRef completion, llvm::StringRef description="")
Adds a possible completion string if the completion would complete the current argument.
A uniqued constant string class.
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
StackFrame * GetFramePtr() const
Returns a pointer to the frame object.
const lldb::ThreadSP & GetThreadSP() const
Get accessor to get the thread shared pointer.
const FileSpec & GetFileSpecAtIndex(size_t idx) const
Get file at index.
void Clear()
Clears the file list.
void Append(const FileSpec &file)
Append a FileSpec object to the list.
size_t GetSize() const
Get the number of files in the file list.
bool AppendIfUnique(const FileSpec &file)
Append a FileSpec object if unique.
void Resolve(llvm::SmallVectorImpl< char > &path)
Resolve path to make it canonical.
static FileSystem & Instance()
ValueType Set(ValueType mask)
Set one or more flags by logical OR'ing mask with the current flags.
static lldb::LanguageType GetLanguageTypeFromString(const char *string)=delete
void Append(OptionGroup *group)
Append options from a OptionGroup class.
const std::string & GetName()
const StructuredData::DictionarySP GetStructuredData()
void SetDefaultValue(bool value)
Status SetValueFromString(llvm::StringRef value, VarSetOperationType op=eVarSetOperationAssign) override
bool GetCurrentValue() const
uint32_t GetColumnNumber()
Status SetValueFromString(llvm::StringRef value, VarSetOperationType op=eVarSetOperationAssign) override
Status SetValueFromString(llvm::StringRef value, VarSetOperationType op=eVarSetOperationAssign) override
const char * GetCurrentValue() const
Status SetValueFromString(llvm::StringRef value, VarSetOperationType op=eVarSetOperationAssign) override
bool OptionWasSet() const
std::optional< T > GetValueAs() const
A command line option parsing protocol class.
std::vector< Option > m_getopt_table
llvm::Error GetError() const
Return an error if the regular expression failed to compile.
bool GetDefaultFileAndLine(FileSpec &file_spec, uint32_t &line)
This base class provides an interface to stack frames.
const SymbolContext & GetSymbolContext(lldb::SymbolContextItem resolve_scope)
Provide a SymbolContext for this StackFrame's current pc value.
bool HasDebugInformation()
Determine whether this StackFrame has debug information available or not.
bool Fail() const
Test for error condition.
const char * AsCString(const char *default_error_str="unknown error") const
Get the error string associated with the current error.
bool Success() const
Test for success condition.
lldb::break_id_t GetID() const
const char * GetData() const
llvm::StringRef GetString() const
A stream class that can stream formatted output to a file.
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
size_t EOL()
Output and End of Line character to the stream.
void IndentLess(unsigned amount=2)
Decrement the current indentation level.
void IndentMore(unsigned amount=2)
Increment the current indentation level.
ObjectSP GetItemAtIndex(size_t idx) const
std::optional< llvm::StringRef > GetItemAtIndexAsString(size_t idx) const
ObjectSP GetValueForKey(llvm::StringRef key) const
bool GetValueForKeyAsArray(llvm::StringRef key, Array *&result) const
Dictionary * GetAsDictionary()
std::shared_ptr< Object > ObjectSP
static ObjectSP ParseJSONFromFile(const FileSpec &file, Status &error)
Defines a symbol context baton that can be handed other debug core functions.
LineEntry line_entry
The LineEntry for a given query.
lldb::BreakpointSP CreateScriptedBreakpoint(const llvm::StringRef class_name, const FileSpecList *containingModules, const FileSpecList *containingSourceFiles, bool internal, bool request_hardware, StructuredData::ObjectSP extra_args_sp, Status *creation_error=nullptr)
lldb::BreakpointSP CreateFuncRegexBreakpoint(const FileSpecList *containingModules, const FileSpecList *containingSourceFiles, RegularExpression func_regexp, lldb::LanguageType requested_language, LazyBool skip_prologue, bool internal, bool request_hardware)
lldb::BreakpointSP GetBreakpointByID(lldb::break_id_t break_id)
BreakpointList & GetBreakpointList(bool internal=false)
SourceManager & GetSourceManager()
void AddNameToBreakpoint(BreakpointID &id, llvm::StringRef name, Status &error)
void DisableAllowedBreakpoints()
bool RemoveBreakpointByID(lldb::break_id_t break_id)
BreakpointName * FindBreakpointName(ConstString name, bool can_create, Status &error)
void ConfigureBreakpointName(BreakpointName &bp_name, const BreakpointOptions &options, const BreakpointName::Permissions &permissions)
Status SerializeBreakpointsToFile(const FileSpec &file, const BreakpointIDList &bp_ids, bool append)
lldb::BreakpointSP CreateExceptionBreakpoint(enum lldb::LanguageType language, bool catch_bp, bool throw_bp, bool internal, Args *additional_args=nullptr, Status *additional_args_error=nullptr)
void EnableAllowedBreakpoints()
void RemoveAllowedBreakpoints()
lldb::BreakpointSP CreateAddressInModuleBreakpoint(lldb::addr_t file_addr, bool internal, const FileSpec &file_spec, bool request_hardware)
lldb::BreakpointSP CreateBreakpoint(const FileSpecList *containingModules, const FileSpec &file, uint32_t line_no, uint32_t column, lldb::addr_t offset, LazyBool check_inlines, LazyBool skip_prologue, bool internal, bool request_hardware, LazyBool move_to_nearest_code)
lldb::BreakpointSP CreateSourceRegexBreakpoint(const FileSpecList *containingModules, const FileSpecList *source_file_list, const std::unordered_set< std::string > &function_names, RegularExpression source_regex, bool internal, bool request_hardware, LazyBool move_to_nearest_code)
void GetBreakpointNames(std::vector< std::string > &names)
Status CreateBreakpointsFromFile(const FileSpec &file, BreakpointIDList &new_bps)
void RemoveNameFromBreakpoint(lldb::BreakpointSP &bp_sp, ConstString name)
lldb::BreakpointSP GetLastCreatedBreakpoint()
void SetIndex(uint32_t index)
void SetName(llvm::StringRef name)
void SetQueueName(llvm::StringRef queue_name)
#define LLDB_INVALID_BREAK_ID
#define LLDB_INVALID_THREAD_ID
#define LLDB_INVALID_ADDRESS
A class that represents a running process on the host machine.
std::vector< OptionArgElement > OptionElementVector
static constexpr llvm::StringLiteral g_bool_parsing_error_message
static constexpr llvm::StringLiteral g_int_parsing_error_message
llvm::Error CreateOptionParsingError(llvm::StringRef option_arg, const char short_option, llvm::StringRef long_option={}, llvm::StringRef additional_context={})
Creates an error that represents the failure to parse an command line option argument.
static constexpr llvm::StringLiteral g_language_parsing_error_message
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
@ eDescriptionLevelInitial
@ eDescriptionLevelVerbose
std::shared_ptr< lldb_private::Thread > ThreadSP
std::shared_ptr< lldb_private::CommandObject > CommandObjectSP
LanguageType
Programming language type.
@ eLanguageTypeC_plus_plus_14
ISO C++:2014.
@ eLanguageTypeC11
ISO C:2011.
@ eLanguageTypeC99
ISO C:1999.
@ eLanguageTypeC_plus_plus_03
ISO C++:2003.
@ eLanguageTypeUnknown
Unknown or invalid language value.
@ eLanguageTypeObjC_plus_plus
Objective-C++.
@ eLanguageTypeC_plus_plus_11
ISO C++:2011.
@ eLanguageTypeC89
ISO C:1989.
@ eLanguageTypeC
Non-standardized C, such as K&R.
@ eLanguageTypeObjC
Objective-C.
@ eLanguageTypeC_plus_plus
ISO C++:1998.
std::shared_ptr< lldb_private::Breakpoint > BreakpointSP
@ eReturnStatusSuccessFinishResult
@ eReturnStatusSuccessFinishNoResult
Used to build individual command argument lists.
const FileSpec & GetFile() const
Helper to access the file.
static lldb::addr_t ToAddress(const ExecutionContext *exe_ctx, llvm::StringRef s, lldb::addr_t fail_value, Status *error_ptr)
Try to parse an address.
static bool ToBoolean(llvm::StringRef s, bool fail_value, bool *success_ptr)