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;
68 switch (short_option) {
90 error.SetErrorStringWithFormat(
91 "invalid boolean value '%s' passed for -G option",
92 option_arg.str().c_str());
95 uint32_t ignore_count;
96 if (option_arg.getAsInteger(0, ignore_count))
97 error.SetErrorStringWithFormat(
"invalid ignore count '%s'",
98 option_arg.str().c_str());
108 error.SetErrorStringWithFormat(
109 "invalid boolean value '%s' passed for -o option",
110 option_arg.str().c_str());
114 if (option_arg ==
"current") {
115 if (!execution_context) {
116 error.SetErrorStringWithFormat(
"No context to determine current "
120 if (!ctx_thread_sp || !ctx_thread_sp->IsValid()) {
121 error.SetErrorStringWithFormat(
"No currently selected thread");
123 thread_id = ctx_thread_sp->GetID();
126 }
else if (option_arg.getAsInteger(0, thread_id)) {
127 error.SetErrorStringWithFormat(
"invalid thread id string '%s'",
128 option_arg.str().c_str());
141 if (option_arg.getAsInteger(0, thread_index)) {
142 error.SetErrorStringWithFormat(
"invalid thread index string '%s'",
143 option_arg.str().c_str());
149 llvm_unreachable(
"Unimplemented option");
162 auto cmd_data = std::make_unique<BreakpointOptions::CommandData>();
165 cmd_data->user_source.AppendString(str);
167 cmd_data->stop_on_error =
true;
179#define LLDB_OPTIONS_breakpoint_dummy
180#include "CommandOptions.inc"
189 return llvm::ArrayRef(g_breakpoint_dummy_options);
195 const int short_option =
196 g_breakpoint_dummy_options[option_idx].short_option;
198 switch (short_option) {
203 llvm_unreachable(
"Unimplemented option");
216#define LLDB_OPTIONS_breakpoint_set
217#include "CommandOptions.inc"
236 interpreter,
"breakpoint set",
237 "Sets a breakpoint or set of breakpoints in the executable.",
238 "breakpoint set <cmd-options>"),
264 const int short_option =
265 g_breakpoint_set_options[option_idx].short_option;
267 switch (short_option) {
283 if (option_arg.getAsInteger(0,
m_column))
284 error.SetErrorStringWithFormat(
"invalid column number: %s",
285 option_arg.str().c_str());
308 error.SetErrorStringWithFormat(
309 "Set exception breakpoints separately for c++ and objective-c");
312 error.SetErrorStringWithFormat(
313 "Unknown language type: '%s' for exception breakpoint",
314 option_arg.str().c_str());
317 error.SetErrorStringWithFormat(
318 "Unsupported language type: '%s' for exception breakpoint",
319 option_arg.str().c_str());
336 error.SetErrorStringWithFormat(
337 "Invalid boolean value for on-catch option: '%s'",
338 option_arg.str().c_str());
355 error.SetErrorStringWithFormat(
356 "Invalid boolean value for skip prologue option: '%s'",
357 option_arg.str().c_str());
362 error.SetErrorStringWithFormat(
"invalid line number: %s.",
363 option_arg.str().c_str());
369 error.SetErrorStringWithFormat(
370 "Unknown language type: '%s' for breakpoint",
371 option_arg.str().c_str());
384 error.SetErrorStringWithFormat(
385 "Invalid boolean value for move-to-nearest-code option: '%s'",
386 option_arg.str().c_str());
404 error.SetErrorStringWithFormat(
"Invalid breakpoint name: %s",
405 option_arg.str().c_str());
412 option_arg, 0, &
error);
443 error.SetErrorStringWithFormat(
444 "Invalid boolean value for on-throw option: '%s'",
445 option_arg.str().c_str());
457 error.SetErrorStringWithFormat(
458 "Invalid value for file:line specifier: %s",
468 llvm_unreachable(
"Unimplemented option");
500 return llvm::ArrayRef(g_breakpoint_set_options);
564 const bool internal =
false;
572 switch (break_type) {
577 if (num_files == 0) {
579 result.
AppendError(
"No file supplied and no default file available.");
582 }
else if (num_files > 1) {
583 result.
AppendError(
"Only one file at a time is allowed for file and "
584 "line breakpoints.");
605 if (num_modules_specified == 1) {
610 }
else if (num_modules_specified == 0) {
614 result.
AppendError(
"Only one shared library can be specified for "
615 "address breakpoints.");
624 if (name_type_mask == 0)
625 name_type_mask = eFunctionNameTypeAuto;
638 if (llvm::Error err = regexp.
GetError()) {
640 "Function name regular expression could not be compiled: %s",
641 llvm::toString(std::move(err)).c_str());
648 "Function name regex does not accept glob patterns.");
666 "No files provided and could not find default file.");
674 if (llvm::Error err = regexp.
GetError()) {
676 "Source text regular expression could not be compiled: \"%s\"",
677 llvm::toString(std::move(err)).c_str());
691 if (precond_error.
Fail()) {
693 "Error setting extra exception arguments: %s",
708 "Error setting extra exception arguments: %s",
error.AsCString());
725 if (name_error.
Fail()) {
737 const bool show_locations =
false;
741 output_stream.
Printf(
"Breakpoint set in dummy target, will get copied "
742 "into future targets.\n");
748 output_stream.
Printf(
"WARNING: Unable to resolve breakpoint to any "
749 "actual locations.\n");
754 result.
AppendError(
"Breakpoint creation failed: No breakpoint created.");
763 uint32_t default_line;
768 if (cur_frame ==
nullptr) {
770 "No selected frame to use to find the default file.");
773 result.
AppendError(
"Cannot use the selected frame to find the default "
774 "file, it has no debug info.");
782 result.
AppendError(
"Can't find the file for the selected frame to "
783 "use as the default file.");
805 "Modify the options on a breakpoint or set of "
806 "breakpoints in the executable. "
807 "If no breakpoint is specified, acts on the last "
808 "created breakpoint. "
809 "With the exception of -e, -d and -i, passing an "
810 "empty argument clears the modification.",
841 std::unique_lock<std::recursive_mutex> lock;
847 command, &target, result, &valid_bp_ids,
848 BreakpointName::Permissions::PermissionKinds::disablePerm);
851 const size_t count = valid_bp_ids.
GetSize();
852 for (
size_t i = 0; i < count; ++i) {
888 "Enable the specified disabled breakpoint(s). If "
889 "no breakpoints are specified, enable all of them.",
912 std::unique_lock<std::recursive_mutex> lock;
917 size_t num_breakpoints = breakpoints.
GetSize();
919 if (num_breakpoints == 0) {
920 result.
AppendError(
"No breakpoints exist to be enabled.");
924 if (command.
empty()) {
929 (uint64_t)num_breakpoints);
935 command, &target, result, &valid_bp_ids,
936 BreakpointName::Permissions::PermissionKinds::disablePerm);
939 int enable_count = 0;
941 const size_t count = valid_bp_ids.
GetSize();
942 for (
size_t i = 0; i < count; ++i) {
962 enable_count + loc_count);
978 interpreter,
"breakpoint disable",
979 "Disable the specified breakpoint(s) without deleting "
980 "them. If none are specified, disable all "
984 "Disable the specified breakpoint(s) without deleting them. \
985If none are specified, disable all breakpoints."
989 "Note: disabling a breakpoint will cause none of its locations to be hit \
990regardless of whether individual locations are enabled or disabled. After the sequence:"
993 (lldb) break disable 1
994 (lldb) break enable 1.1
996execution will NOT stop at location 1.1. To achieve that, type:
998 (lldb) break disable 1.*
999 (lldb) break enable 1.1
1002 "The first command disables all locations for breakpoint 1, \
1003the second re-enables the first location.");
1025 std::unique_lock<std::recursive_mutex> lock;
1029 size_t num_breakpoints = breakpoints.
GetSize();
1031 if (num_breakpoints == 0) {
1032 result.
AppendError(
"No breakpoints exist to be disabled.");
1036 if (command.
empty()) {
1041 (uint64_t)num_breakpoints);
1048 command, &target, result, &valid_bp_ids,
1049 BreakpointName::Permissions::PermissionKinds::disablePerm);
1052 int disable_count = 0;
1054 const size_t count = valid_bp_ids.
GetSize();
1055 for (
size_t i = 0; i < count; ++i) {
1075 disable_count + loc_count);
1086#pragma mark List::CommandOptions
1087#define LLDB_OPTIONS_breakpoint_list
1088#include "CommandOptions.inc"
1096 interpreter,
"breakpoint list",
1097 "List some or all breakpoints at configurable levels of detail.",
1108 arg.push_back(bp_id_arg);
1129 switch (short_option) {
1146 llvm_unreachable(
"Unimplemented option");
1159 return llvm::ArrayRef(g_breakpoint_list_options);
1176 std::unique_lock<std::recursive_mutex> lock;
1179 size_t num_breakpoints = breakpoints.
GetSize();
1181 if (num_breakpoints == 0) {
1189 if (command.
empty()) {
1192 for (
size_t i = 0; i < num_breakpoints; ++i) {
1203 command, &target, result, &valid_bp_ids,
1204 BreakpointName::Permissions::PermissionKinds::listPerm);
1207 for (
size_t i = 0; i < valid_bp_ids.
GetSize(); ++i) {
1228#pragma mark Clear::CommandOptions
1230#define LLDB_OPTIONS_breakpoint_clear
1231#include "CommandOptions.inc"
1241 "Delete or disable breakpoints matching the "
1242 "specified source file and line.",
1243 "breakpoint clear <cmd-options>") {}
1260 switch (short_option) {
1270 llvm_unreachable(
"Unimplemented option");
1282 return llvm::ArrayRef(g_breakpoint_clear_options);
1304 std::unique_lock<std::recursive_mutex> lock;
1308 size_t num_breakpoints = breakpoints.
GetSize();
1311 if (num_breakpoints == 0) {
1312 result.
AppendError(
"Breakpoint clear: No breakpoint cleared.");
1319 std::vector<break_id_t> BreakIDs;
1320 for (
size_t i = 0; i < num_breakpoints; ++i)
1323 int num_cleared = 0;
1325 switch (break_type) {
1331 for (
size_t i = 0; i < num_breakpoints; ++i) {
1337 if (loc_coll.
GetSize() == 0) {
1351 if (num_cleared > 0) {
1353 output_stream.
Printf(
"%d breakpoints cleared:\n", num_cleared);
1355 output_stream.
EOL();
1358 result.
AppendError(
"Breakpoint clear: No breakpoint cleared.");
1369#define LLDB_OPTIONS_breakpoint_delete
1370#include "CommandOptions.inc"
1378 "Delete the specified breakpoint(s). If no "
1379 "breakpoints are specified, delete them all.",
1411 switch (short_option) {
1425 llvm_unreachable(
"Unimplemented option");
1438 return llvm::ArrayRef(g_breakpoint_delete_options);
1452 std::unique_lock<std::recursive_mutex> lock;
1457 size_t num_breakpoints = breakpoints.
GetSize();
1459 if (num_breakpoints == 0) {
1460 result.
AppendError(
"No breakpoints exist to be deleted.");
1468 "About to delete all breakpoints, do you want to do that?",
1474 "All breakpoints removed. (%" PRIu64
" breakpoint%s)\n",
1475 (uint64_t)num_breakpoints, num_breakpoints > 1 ?
"s" :
"");
1489 if (!command.
empty()) {
1491 command, &target, result, &excluded_bp_ids,
1492 BreakpointName::Permissions::PermissionKinds::deletePerm);
1497 for (
auto breakpoint_sp : breakpoints.
Breakpoints()) {
1498 if (!breakpoint_sp->IsEnabled() && breakpoint_sp->AllowDelete()) {
1505 if (valid_bp_ids.
GetSize() == 0) {
1511 command, &target, result, &valid_bp_ids,
1512 BreakpointName::Permissions::PermissionKinds::deletePerm);
1517 int delete_count = 0;
1518 int disable_count = 0;
1519 const size_t count = valid_bp_ids.
GetSize();
1520 for (
size_t i = 0; i < count; ++i) {
1542 "%d breakpoints deleted; %d breakpoint locations disabled.\n",
1543 delete_count, disable_count);
1553#define LLDB_OPTIONS_breakpoint_name
1554#include "CommandOptions.inc"
1564 return llvm::ArrayRef(g_breakpoint_name_options);
1570 const int short_option = g_breakpoint_name_options[option_idx].short_option;
1572 switch (short_option) {
1580 error.SetErrorStringWithFormat(
1581 "unrecognized value \"%s\" for breakpoint",
1582 option_arg.str().c_str());
1586 error.SetErrorStringWithFormat(
1587 "unrecognized value \"%s\" for use-dummy",
1588 option_arg.str().c_str());
1595 llvm_unreachable(
"Unimplemented option");
1614#define LLDB_OPTIONS_breakpoint_access
1615#include "CommandOptions.inc"
1624 return llvm::ArrayRef(g_breakpoint_access_options);
1629 const int short_option =
1630 g_breakpoint_access_options[option_idx].short_option;
1632 switch (short_option) {
1634 bool value, success;
1639 error.SetErrorStringWithFormat(
1640 "invalid boolean value '%s' passed for -L option",
1641 option_arg.str().c_str());
1644 bool value, success;
1649 error.SetErrorStringWithFormat(
1650 "invalid boolean value '%s' passed for -L option",
1651 option_arg.str().c_str());
1654 bool value, success;
1659 error.SetErrorStringWithFormat(
1660 "invalid boolean value '%s' passed for -L option",
1661 option_arg.str().c_str());
1664 llvm_unreachable(
"Unimplemented option");
1682 interpreter,
"configure",
1683 "Configure the options for the breakpoint"
1685 "If you provide a breakpoint id, the options will be copied from "
1686 "the breakpoint, otherwise only the options specified will be set "
1688 "breakpoint name configure <command-options> "
1689 "<breakpoint-name-list>") {
1696 arg1.push_back(id_arg);
1722 std::unique_lock<std::recursive_mutex> lock;
1726 for (
auto &entry : command.
entries()) {
1730 entry.c_str(),
error.AsCString());
1749 for (
auto &entry : command.
entries()) {
1782 interpreter,
"add",
"Add a name to the breakpoints provided.",
1783 "breakpoint name add <command-options> <breakpoint-id-list>") {
1790 arg1.push_back(id_arg);
1818 std::unique_lock<std::recursive_mutex> lock;
1823 size_t num_breakpoints = breakpoints.
GetSize();
1824 if (num_breakpoints == 0) {
1825 result.
AppendError(
"No breakpoints, cannot add names.");
1832 command, &target, result, &valid_bp_ids,
1833 BreakpointName::Permissions::PermissionKinds::listPerm);
1836 if (valid_bp_ids.
GetSize() == 0) {
1837 result.
AppendError(
"No breakpoints specified, cannot add names.");
1840 size_t num_valid_ids = valid_bp_ids.
GetSize();
1844 for (
size_t index = 0; index < num_valid_ids; index++) {
1864 interpreter,
"delete",
1865 "Delete a name from the breakpoints provided.",
1866 "breakpoint name delete <command-options> <breakpoint-id-list>") {
1873 arg1.push_back(id_arg);
1901 std::unique_lock<std::recursive_mutex> lock;
1906 size_t num_breakpoints = breakpoints.
GetSize();
1907 if (num_breakpoints == 0) {
1908 result.
AppendError(
"No breakpoints, cannot delete names.");
1915 command, &target, result, &valid_bp_ids,
1916 BreakpointName::Permissions::PermissionKinds::deletePerm);
1919 if (valid_bp_ids.
GetSize() == 0) {
1920 result.
AppendError(
"No breakpoints specified, cannot delete names.");
1924 size_t num_valid_ids = valid_bp_ids.
GetSize();
1925 for (
size_t index = 0; index < num_valid_ids; index++) {
1945 "List either the names for a breakpoint or info "
1946 "about a given name. With no arguments, lists all "
1948 "breakpoint name list <command-options>") {
1962 std::vector<std::string> name_list;
1963 if (command.
empty()) {
1967 name_list.push_back(arg.c_str());
1971 if (name_list.empty()) {
1974 for (
const std::string &name_str : name_list) {
1975 const char *name = name_str.c_str();
1987 std::unique_lock<std::recursive_mutex> lock;
1991 bool any_set =
false;
1993 if (bp_sp->MatchesName(name)) {
2021 interpreter,
"name",
"Commands to manage breakpoint names") {
2026Breakpoint names provide a general tagging mechanism for breakpoints. Each
2027breakpoint name can be added to any number of breakpoints, and each breakpoint
2028can have any number of breakpoint names attached to it. For instance:
2030 (lldb) break name add -N MyName 1-10
2032adds the name MyName to breakpoints 1-10, and:
2034 (lldb) break set -n myFunc -N Name1 -N Name2
2036adds two names to the breakpoint set at myFunc.
2038They have a number of interrelated uses:
20401) They provide a stable way to refer to a breakpoint (e.g. in another
2041breakpoint's action). Using the breakpoint ID for this purpose is fragile, since
2042it depends on the order of breakpoint creation. Giving a name to the breakpoint
2043you want to act on, and then referring to it by name, is more robust:
2045 (lldb) break set -n myFunc -N BKPT1
2046 (lldb) break set -n myOtherFunc -C "break disable BKPT1"
20482) This is actually just a specific use of a more general feature of breakpoint
2049names. The <breakpt-id-list> argument type used to specify one or more
2050breakpoints in most of the commands that deal with breakpoints also accepts
2051breakpoint names. That allows you to refer to one breakpoint in a stable
2052manner, but also makes them a convenient grouping mechanism, allowing you to
2053easily act on a group of breakpoints by using their name, for instance disabling
2054them all in one action:
2056 (lldb) break set -n myFunc -N Group1
2057 (lldb) break set -n myOtherFunc -N Group1
2058 (lldb) break disable Group1
20603) But breakpoint names are also entities in their own right, and can be
2061configured with all the modifiable attributes of a breakpoint. Then when you
2062add a breakpoint name to a breakpoint, the breakpoint will be configured to
2063match the state of the breakpoint name. The link between the name and the
2064breakpoints sharing it remains live, so if you change the configuration on the
2065name, it will also change the configurations on the breakpoints:
2067 (lldb) break name configure -i 10 IgnoreSome
2068 (lldb) break set -n myFunc -N IgnoreSome
2069 (lldb) break list IgnoreSome
2070 2: name = 'myFunc', locations = 0 (pending) Options: ignore: 10 enabled
2073 (lldb) break name configure -i 5 IgnoreSome
2074 (lldb) break list IgnoreSome
2075 2: name = 'myFunc', locations = 0 (pending) Options: ignore: 5 enabled
2079Options that are not configured on a breakpoint name don't affect the value of
2080those options on the breakpoints they are added to. So for instance, if Name1
2081has the -i option configured and Name2 the -c option, adding both names to a
2082breakpoint will set the -i option from Name1 and the -c option from Name2, and
2083the other options will be unaltered.
2085If you add multiple names to a breakpoint which have configured values for
2086the same option, the last name added's value wins.
2088The "liveness" of these settings is one way, from name to breakpoint.
2089If you use "break modify" to change an option that is also configured on a name
2090which that breakpoint has, the "break modify" command will override the setting
2091for that breakpoint, but won't change the value configured in the name or on the
2092other breakpoints sharing that name.
20944) Breakpoint names are also a convenient way to copy option sets from one
2095breakpoint to another. Using the -B option to "breakpoint name configure" makes
2096a name configured with all the options of the original breakpoint. Then
2097adding that name to another breakpoint copies over all the values from the
2098original breakpoint to the new one.
21005) You can also use breakpoint names to hide breakpoints from the breakpoint
2101operations that act on all breakpoints: "break delete", "break disable" and
2102"break list". You do that by specifying a "false" value for the
2103--allow-{list,delete,disable} options to "breakpoint name configure" and then
2104adding that name to a breakpoint.
2106This won't keep the breakpoint from being deleted or disabled if you refer to it
2107specifically by ID. The point of the feature is to make sure users don't
2108inadvertently delete or disable useful breakpoints (e.g. ones an IDE is using
2109for its own purposes) as part of a "delete all" or "disable all" operation. The
2110list hiding is because it's confusing for people to see breakpoints they
2133#pragma mark Read::CommandOptions
2134#define LLDB_OPTIONS_breakpoint_read
2135#include "CommandOptions.inc"
2143 "Read and set the breakpoints previously saved to "
2144 "a file with \"breakpoint write\". ",
2162 switch (short_option) {
2170 error.SetErrorStringWithFormat(
"Invalid breakpoint name: %s",
2173 m_names.push_back(std::string(option_arg));
2177 llvm_unreachable(
"Unimplemented option");
2189 return llvm::ArrayRef(g_breakpoint_read_options);
2195 int opt_arg_pos = opt_element_vector[opt_element_index].opt_arg_pos;
2196 int opt_defs_index = opt_element_vector[opt_element_index].opt_defs_index;
2205 std::optional<FileSpec> file_spec;
2206 const llvm::StringRef dash_f(
"-f");
2207 for (
int arg_idx = 0; arg_idx < opt_arg_pos; arg_idx++) {
2221 if (!
error.Success())
2228 const size_t num_bkpts = bkpt_array->
GetSize();
2229 for (
size_t i = 0; i < num_bkpts; i++) {
2232 if (!bkpt_object_sp)
2254 size_t num_names = names_array->
GetSize();
2256 for (
size_t i = 0; i < num_names; i++) {
2257 llvm::StringRef name;
2273 std::unique_lock<std::recursive_mutex> lock;
2282 if (!
error.Success()) {
2289 size_t num_breakpoints = new_bps.
GetSize();
2290 if (num_breakpoints == 0) {
2295 for (
size_t i = 0; i < num_breakpoints; ++i) {
2313#pragma mark Write::CommandOptions
2314#define LLDB_OPTIONS_breakpoint_write
2315#include "CommandOptions.inc"
2322 "Write the breakpoints listed to a file that can "
2323 "be read in with \"breakpoint read\". "
2324 "If given no arguments, writes all breakpoints.",
2356 switch (short_option) {
2364 llvm_unreachable(
"Unimplemented option");
2376 return llvm::ArrayRef(g_breakpoint_write_options);
2389 std::unique_lock<std::recursive_mutex> lock;
2393 if (!command.
empty()) {
2395 command, &target, result, &valid_bp_ids,
2396 BreakpointName::Permissions::PermissionKinds::listPerm);
2407 if (!
error.Success()) {
2419#pragma mark MultiwordBreakpoint
2424 interpreter,
"breakpoint",
2425 "Commands for operating on breakpoints (see 'help b' for shorthand.)",
2426 "breakpoint <subcommand> [<command-options>]") {
2450 list_command_object->SetCommandName(
"breakpoint list");
2451 enable_command_object->SetCommandName(
"breakpoint enable");
2452 disable_command_object->SetCommandName(
"breakpoint disable");
2453 clear_command_object->SetCommandName(
"breakpoint clear");
2454 delete_command_object->SetCommandName(
"breakpoint delete");
2455 set_command_object->SetCommandName(
"breakpoint set");
2456 command_command_object->SetCommandName(
"breakpoint command");
2457 modify_command_object->SetCommandName(
"breakpoint modify");
2458 name_command_object->SetCommandName(
"breakpoint name");
2459 write_command_object->SetCommandName(
"breakpoint write");
2460 read_command_object->SetCommandName(
"breakpoint read");
2478 Args &args,
Target *target,
bool allow_locations,
2480 BreakpointName::Permissions ::PermissionKinds purpose) {
2501 "No breakpoint specified and no last created breakpoint.");
2513 purpose, result, temp_args);
2528 const size_t count = valid_ids->
GetSize();
2529 for (
size_t i = 0; i < count; ++i) {
2533 if (breakpoint !=
nullptr) {
2535 if (
static_cast<size_t>(cur_bp_id.
GetLocationID()) > num_locations) {
2541 "'%s' is not a currently valid breakpoint/location id.\n",
2547 "'%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
Options * GetOptions() override
CommandObjectBreakpointClear(CommandInterpreter &interpreter)
~CommandObjectBreakpointClear() override=default
bool DoExecute(Args &command, CommandReturnObject &result) override
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 input array contains a parsed version of the line.
Options * GetOptions() override
bool DoExecute(Args &command, CommandReturnObject &result) override
bool DoExecute(Args &command, CommandReturnObject &result) override
~CommandObjectBreakpointDisable() override=default
CommandObjectBreakpointDisable(CommandInterpreter &interpreter)
void HandleArgumentCompletion(CompletionRequest &request, OptionElementVector &opt_element_vector) override
The input array contains a parsed version of the line.
~CommandObjectBreakpointEnable() override=default
void HandleArgumentCompletion(CompletionRequest &request, OptionElementVector &opt_element_vector) override
The input array contains a parsed version of the line.
bool DoExecute(Args &command, CommandReturnObject &result) override
CommandObjectBreakpointEnable(CommandInterpreter &interpreter)
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
bool DoExecute(Args &command, CommandReturnObject &result) override
~CommandObjectBreakpointList() override=default
Options * GetOptions() override
CommandObjectBreakpointList(CommandInterpreter &interpreter)
BreakpointDummyOptionGroup m_dummy_opts
void HandleArgumentCompletion(CompletionRequest &request, OptionElementVector &opt_element_vector) override
The input array contains a parsed version of the line.
CommandObjectBreakpointModify(CommandInterpreter &interpreter)
BreakpointOptionGroup m_bp_opts
~CommandObjectBreakpointModify() override=default
OptionGroupOptions m_options
bool DoExecute(Args &command, CommandReturnObject &result) override
Options * GetOptions() override
OptionGroupOptions m_option_group
bool DoExecute(Args &command, CommandReturnObject &result) override
CommandObjectBreakpointNameAdd(CommandInterpreter &interpreter)
Options * GetOptions() override
~CommandObjectBreakpointNameAdd() override=default
BreakpointNameOptionGroup m_name_options
void HandleArgumentCompletion(CompletionRequest &request, OptionElementVector &opt_element_vector) override
The input array contains a parsed version of the line.
BreakpointNameOptionGroup m_name_options
void HandleArgumentCompletion(CompletionRequest &request, OptionElementVector &opt_element_vector) override
The input array contains a parsed version of the line.
CommandObjectBreakpointNameDelete(CommandInterpreter &interpreter)
Options * GetOptions() override
~CommandObjectBreakpointNameDelete() override=default
OptionGroupOptions m_option_group
bool DoExecute(Args &command, CommandReturnObject &result) override
CommandObjectBreakpointNameList(CommandInterpreter &interpreter)
Options * GetOptions() override
OptionGroupOptions m_option_group
~CommandObjectBreakpointNameList() override=default
bool DoExecute(Args &command, CommandReturnObject &result) override
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
bool 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
bool DoExecute(Args &command, CommandReturnObject &result) override
~CommandObjectBreakpointSet() override=default
BreakpointOptionGroup m_bp_opts
bool GetDefaultFile(Target &target, FileSpec &file, CommandReturnObject &result)
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.
Options * GetOptions() override
void HandleArgumentCompletion(CompletionRequest &request, OptionElementVector &opt_element_vector) override
The input array contains a parsed version of the line.
CommandObjectBreakpointWrite(CommandInterpreter &interpreter)
~CommandObjectBreakpointWrite() override=default
bool DoExecute(Args &command, CommandReturnObject &result) override
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.
const BreakpointID & GetBreakpointIDAtIndex(size_t index) const
static void FindAndReplaceIDRanges(Args &old_args, Target *target, bool allow_locations, BreakpointName::Permissions ::PermissionKinds purpose, CommandReturnObject &result, Args &new_args)
bool AddBreakpointID(BreakpointID bp_id)
bool FindBreakpointID(BreakpointID &bp_id, size_t *position) const
void InsertStringArray(llvm::ArrayRef< const char * > string_array, CommandReturnObject &result)
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)
static void AddIDsArgumentData(CommandArgumentEntry &arg, lldb::CommandArgumentType ID, lldb::CommandArgumentType IDRange)
Target & GetDummyTarget()
ExecutionContext m_exe_ctx
std::vector< CommandArgumentEntry > m_arguments
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)
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.
const FileSpec * GetFileSpecPointerAtIndex(size_t idx) const
Get file specification pointer 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
bool GetItemAtIndexAsString(size_t idx, llvm::StringRef &result) 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()
lldb::BreakpointSP CreateAddressInModuleBreakpoint(lldb::addr_t file_addr, bool internal, const FileSpec *file_spec, bool request_hardware)
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 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 AddNameToBreakpoint(BreakpointID &id, const char *name, Status &error)
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
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
@ eArgTypeBreakpointIDRange
Used to build individual command argument lists.
ArgumentRepetitionType arg_repetition
lldb::CommandArgumentType arg_type
FileSpec file
The source file, possibly mapped by the target.source-map setting.
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)