LLDB mainline
CommandObjectBreakpoint.cpp
Go to the documentation of this file.
1//===-- CommandObjectBreakpoint.cpp ---------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
27#include "lldb/Target/Target.h"
31
32#include <memory>
33#include <optional>
34#include <vector>
35
36using namespace lldb;
37using namespace lldb_private;
38
41 s->IndentMore();
42 bp->GetDescription(s, level, true);
43 s->IndentLess();
44 s->EOL();
45}
46
47// Modifiable Breakpoint Options
48#pragma mark Modify::CommandOptions
49#define LLDB_OPTIONS_breakpoint_modify
50#include "CommandOptions.inc"
51
53public:
55
56 ~BreakpointOptionGroup() override = default;
57
58 llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
59 return llvm::ArrayRef(g_breakpoint_modify_options);
60 }
61
62 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
63 ExecutionContext *execution_context) override {
65 const int short_option =
66 g_breakpoint_modify_options[option_idx].short_option;
67
68 switch (short_option) {
69 case 'c':
70 // Normally an empty breakpoint condition marks is as unset. But we need
71 // to say it was passed in.
72 m_bp_opts.SetCondition(option_arg.str().c_str());
74 break;
75 case 'C':
76 m_commands.push_back(std::string(option_arg));
77 break;
78 case 'd':
79 m_bp_opts.SetEnabled(false);
80 break;
81 case 'e':
83 break;
84 case 'G': {
85 bool value, success;
86 value = OptionArgParser::ToBoolean(option_arg, false, &success);
87 if (success) {
89 } else
90 error.SetErrorStringWithFormat(
91 "invalid boolean value '%s' passed for -G option",
92 option_arg.str().c_str());
93 } break;
94 case 'i': {
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());
99 else
100 m_bp_opts.SetIgnoreCount(ignore_count);
101 } break;
102 case 'o': {
103 bool value, success;
104 value = OptionArgParser::ToBoolean(option_arg, false, &success);
105 if (success) {
106 m_bp_opts.SetOneShot(value);
107 } else
108 error.SetErrorStringWithFormat(
109 "invalid boolean value '%s' passed for -o option",
110 option_arg.str().c_str());
111 } break;
112 case 't': {
114 if (option_arg == "current") {
115 if (!execution_context) {
116 error.SetErrorStringWithFormat("No context to determine current "
117 "thread");
118 } else {
119 ThreadSP ctx_thread_sp = execution_context->GetThreadSP();
120 if (!ctx_thread_sp || !ctx_thread_sp->IsValid()) {
121 error.SetErrorStringWithFormat("No currently selected thread");
122 } else {
123 thread_id = ctx_thread_sp->GetID();
124 }
125 }
126 } else if (option_arg.getAsInteger(0, thread_id)) {
127 error.SetErrorStringWithFormat("invalid thread id string '%s'",
128 option_arg.str().c_str());
129 }
130 if (thread_id != LLDB_INVALID_THREAD_ID)
131 m_bp_opts.SetThreadID(thread_id);
132 } break;
133 case 'T':
134 m_bp_opts.GetThreadSpec()->SetName(option_arg.str().c_str());
135 break;
136 case 'q':
137 m_bp_opts.GetThreadSpec()->SetQueueName(option_arg.str().c_str());
138 break;
139 case 'x': {
140 uint32_t thread_index = UINT32_MAX;
141 if (option_arg.getAsInteger(0, thread_index)) {
142 error.SetErrorStringWithFormat("invalid thread index string '%s'",
143 option_arg.str().c_str());
144 } else {
145 m_bp_opts.GetThreadSpec()->SetIndex(thread_index);
146 }
147 } break;
148 default:
149 llvm_unreachable("Unimplemented option");
150 }
151
152 return error;
153 }
154
155 void OptionParsingStarting(ExecutionContext *execution_context) override {
157 m_commands.clear();
158 }
159
160 Status OptionParsingFinished(ExecutionContext *execution_context) override {
161 if (!m_commands.empty()) {
162 auto cmd_data = std::make_unique<BreakpointOptions::CommandData>();
163
164 for (std::string &str : m_commands)
165 cmd_data->user_source.AppendString(str);
166
167 cmd_data->stop_on_error = true;
169 }
170 return Status();
171 }
172
174
175 std::vector<std::string> m_commands;
177};
178
179#define LLDB_OPTIONS_breakpoint_dummy
180#include "CommandOptions.inc"
181
183public:
185
186 ~BreakpointDummyOptionGroup() override = default;
187
188 llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
189 return llvm::ArrayRef(g_breakpoint_dummy_options);
190 }
191
192 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
193 ExecutionContext *execution_context) override {
195 const int short_option =
196 g_breakpoint_dummy_options[option_idx].short_option;
197
198 switch (short_option) {
199 case 'D':
200 m_use_dummy = true;
201 break;
202 default:
203 llvm_unreachable("Unimplemented option");
204 }
205
206 return error;
207 }
208
209 void OptionParsingStarting(ExecutionContext *execution_context) override {
210 m_use_dummy = false;
211 }
212
214};
215
216#define LLDB_OPTIONS_breakpoint_set
217#include "CommandOptions.inc"
218
219// CommandObjectBreakpointSet
220
222public:
232 };
233
236 interpreter, "breakpoint set",
237 "Sets a breakpoint or set of breakpoints in the executable.",
238 "breakpoint set <cmd-options>"),
239 m_python_class_options("scripted breakpoint", true, 'P') {
240 // We're picking up all the normal options, commands and disable.
249 }
250
251 ~CommandObjectBreakpointSet() override = default;
252
253 Options *GetOptions() override { return &m_all_options; }
254
256 public:
257 CommandOptions() = default;
258
259 ~CommandOptions() override = default;
260
261 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
262 ExecutionContext *execution_context) override {
264 const int short_option =
265 g_breakpoint_set_options[option_idx].short_option;
266
267 switch (short_option) {
268 case 'a': {
269 m_load_addr = OptionArgParser::ToAddress(execution_context, option_arg,
271 } break;
272
273 case 'A':
274 m_all_files = true;
275 break;
276
277 case 'b':
278 m_func_names.push_back(std::string(option_arg));
279 m_func_name_type_mask |= eFunctionNameTypeBase;
280 break;
281
282 case 'u':
283 if (option_arg.getAsInteger(0, m_column))
284 error.SetErrorStringWithFormat("invalid column number: %s",
285 option_arg.str().c_str());
286 break;
287
288 case 'E': {
290
291 switch (language) {
292 case eLanguageTypeC89:
293 case eLanguageTypeC:
294 case eLanguageTypeC99:
295 case eLanguageTypeC11:
297 break;
303 break;
306 break;
308 error.SetErrorStringWithFormat(
309 "Set exception breakpoints separately for c++ and objective-c");
310 break;
312 error.SetErrorStringWithFormat(
313 "Unknown language type: '%s' for exception breakpoint",
314 option_arg.str().c_str());
315 break;
316 default:
317 error.SetErrorStringWithFormat(
318 "Unsupported language type: '%s' for exception breakpoint",
319 option_arg.str().c_str());
320 }
321 } break;
322
323 case 'f':
325 break;
326
327 case 'F':
328 m_func_names.push_back(std::string(option_arg));
329 m_func_name_type_mask |= eFunctionNameTypeFull;
330 break;
331
332 case 'h': {
333 bool success;
334 m_catch_bp = OptionArgParser::ToBoolean(option_arg, true, &success);
335 if (!success)
336 error.SetErrorStringWithFormat(
337 "Invalid boolean value for on-catch option: '%s'",
338 option_arg.str().c_str());
339 } break;
340
341 case 'H':
342 m_hardware = true;
343 break;
344
345 case 'K': {
346 bool success;
347 bool value;
348 value = OptionArgParser::ToBoolean(option_arg, true, &success);
349 if (value)
351 else
353
354 if (!success)
355 error.SetErrorStringWithFormat(
356 "Invalid boolean value for skip prologue option: '%s'",
357 option_arg.str().c_str());
358 } break;
359
360 case 'l':
361 if (option_arg.getAsInteger(0, m_line_num))
362 error.SetErrorStringWithFormat("invalid line number: %s.",
363 option_arg.str().c_str());
364 break;
365
366 case 'L':
369 error.SetErrorStringWithFormat(
370 "Unknown language type: '%s' for breakpoint",
371 option_arg.str().c_str());
372 break;
373
374 case 'm': {
375 bool success;
376 bool value;
377 value = OptionArgParser::ToBoolean(option_arg, true, &success);
378 if (value)
380 else
382
383 if (!success)
384 error.SetErrorStringWithFormat(
385 "Invalid boolean value for move-to-nearest-code option: '%s'",
386 option_arg.str().c_str());
387 break;
388 }
389
390 case 'M':
391 m_func_names.push_back(std::string(option_arg));
392 m_func_name_type_mask |= eFunctionNameTypeMethod;
393 break;
394
395 case 'n':
396 m_func_names.push_back(std::string(option_arg));
397 m_func_name_type_mask |= eFunctionNameTypeAuto;
398 break;
399
400 case 'N': {
402 m_breakpoint_names.push_back(std::string(option_arg));
403 else
404 error.SetErrorStringWithFormat("Invalid breakpoint name: %s",
405 option_arg.str().c_str());
406 break;
407 }
408
409 case 'R': {
410 lldb::addr_t tmp_offset_addr;
411 tmp_offset_addr = OptionArgParser::ToAddress(execution_context,
412 option_arg, 0, &error);
413 if (error.Success())
414 m_offset_addr = tmp_offset_addr;
415 } break;
416
417 case 'O':
420 break;
421
422 case 'p':
423 m_source_text_regexp.assign(std::string(option_arg));
424 break;
425
426 case 'r':
427 m_func_regexp.assign(std::string(option_arg));
428 break;
429
430 case 's':
431 m_modules.AppendIfUnique(FileSpec(option_arg));
432 break;
433
434 case 'S':
435 m_func_names.push_back(std::string(option_arg));
436 m_func_name_type_mask |= eFunctionNameTypeSelector;
437 break;
438
439 case 'w': {
440 bool success;
441 m_throw_bp = OptionArgParser::ToBoolean(option_arg, true, &success);
442 if (!success)
443 error.SetErrorStringWithFormat(
444 "Invalid boolean value for on-throw option: '%s'",
445 option_arg.str().c_str());
446 } break;
447
448 case 'X':
449 m_source_regex_func_names.insert(std::string(option_arg));
450 break;
451
452 case 'y':
453 {
455 Status fcl_err = value.SetValueFromString(option_arg);
456 if (!fcl_err.Success()) {
457 error.SetErrorStringWithFormat(
458 "Invalid value for file:line specifier: %s",
459 fcl_err.AsCString());
460 } else {
462 m_line_num = value.GetLineNumber();
463 m_column = value.GetColumnNumber();
464 }
465 } break;
466
467 default:
468 llvm_unreachable("Unimplemented option");
469 }
470
471 return error;
472 }
473
474 void OptionParsingStarting(ExecutionContext *execution_context) override {
476 m_line_num = 0;
477 m_column = 0;
478 m_func_names.clear();
479 m_func_name_type_mask = eFunctionNameTypeNone;
480 m_func_regexp.clear();
481 m_source_text_regexp.clear();
484 m_offset_addr = 0;
485 m_catch_bp = false;
486 m_throw_bp = true;
487 m_hardware = false;
491 m_breakpoint_names.clear();
492 m_all_files = false;
496 m_current_key.clear();
497 }
498
499 llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
500 return llvm::ArrayRef(g_breakpoint_set_options);
501 }
502
503 // Instance variables to hold the values for command options.
504
505 std::string m_condition;
509 std::vector<std::string> m_func_names;
510 std::vector<std::string> m_breakpoint_names;
511 lldb::FunctionNameType m_func_name_type_mask = eFunctionNameTypeNone;
512 std::string m_func_regexp;
517 bool m_catch_bp = false;
518 bool m_throw_bp = true;
519 bool m_hardware = false; // Request to use hardware breakpoints
523 bool m_all_files = false;
526 std::unordered_set<std::string> m_source_regex_func_names;
527 std::string m_current_key;
528 };
529
530protected:
531 bool DoExecute(Args &command, CommandReturnObject &result) override {
533
534 // The following are the various types of breakpoints that could be set:
535 // 1). -f -l -p [-s -g] (setting breakpoint by source location)
536 // 2). -a [-s -g] (setting breakpoint by address)
537 // 3). -n [-s -g] (setting breakpoint by function name)
538 // 4). -r [-s -g] (setting breakpoint by function name regular
539 // expression)
540 // 5). -p -f (setting a breakpoint by comparing a reg-exp
541 // to source text)
542 // 6). -E [-w -h] (setting a breakpoint for exceptions for a
543 // given language.)
544
546
547 if (!m_python_class_options.GetName().empty())
548 break_type = eSetTypeScripted;
549 else if (m_options.m_line_num != 0)
550 break_type = eSetTypeFileAndLine;
552 break_type = eSetTypeAddress;
553 else if (!m_options.m_func_names.empty())
554 break_type = eSetTypeFunctionName;
555 else if (!m_options.m_func_regexp.empty())
556 break_type = eSetTypeFunctionRegexp;
557 else if (!m_options.m_source_text_regexp.empty())
558 break_type = eSetTypeSourceRegexp;
560 break_type = eSetTypeException;
561
562 BreakpointSP bp_sp = nullptr;
563 FileSpec module_spec;
564 const bool internal = false;
565
566 // If the user didn't specify skip-prologue, having an offset should turn
567 // that off.
568 if (m_options.m_offset_addr != 0 &&
571
572 switch (break_type) {
573 case eSetTypeFileAndLine: // Breakpoint by source position
574 {
575 FileSpec file;
576 const size_t num_files = m_options.m_filenames.GetSize();
577 if (num_files == 0) {
578 if (!GetDefaultFile(target, file, result)) {
579 result.AppendError("No file supplied and no default file available.");
580 return false;
581 }
582 } else if (num_files > 1) {
583 result.AppendError("Only one file at a time is allowed for file and "
584 "line breakpoints.");
585 return false;
586 } else
588
589 // Only check for inline functions if
590 LazyBool check_inlines = eLazyBoolCalculate;
591
592 bp_sp = target.CreateBreakpoint(
597 } break;
598
599 case eSetTypeAddress: // Breakpoint by address
600 {
601 // If a shared library has been specified, make an lldb_private::Address
602 // with the library, and use that. That way the address breakpoint
603 // will track the load location of the library.
604 size_t num_modules_specified = m_options.m_modules.GetSize();
605 if (num_modules_specified == 1) {
606 const FileSpec *file_spec =
608 bp_sp = target.CreateAddressInModuleBreakpoint(
609 m_options.m_load_addr, internal, file_spec, m_options.m_hardware);
610 } else if (num_modules_specified == 0) {
611 bp_sp = target.CreateBreakpoint(m_options.m_load_addr, internal,
613 } else {
614 result.AppendError("Only one shared library can be specified for "
615 "address breakpoints.");
616 return false;
617 }
618 break;
619 }
620 case eSetTypeFunctionName: // Breakpoint by function name
621 {
622 FunctionNameType name_type_mask = m_options.m_func_name_type_mask;
623
624 if (name_type_mask == 0)
625 name_type_mask = eFunctionNameTypeAuto;
626
627 bp_sp = target.CreateBreakpoint(
632 } break;
633
634 case eSetTypeFunctionRegexp: // Breakpoint by regular expression function
635 // name
636 {
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());
642 // Check if the incorrect regex looks like a globbing expression and
643 // warn the user about it.
644 if (!m_options.m_func_regexp.empty()) {
645 if (m_options.m_func_regexp[0] == '*' ||
646 m_options.m_func_regexp[0] == '?')
647 result.AppendWarning(
648 "Function name regex does not accept glob patterns.");
649 }
650 return false;
651 }
652
653 bp_sp = target.CreateFuncRegexBreakpoint(
654 &(m_options.m_modules), &(m_options.m_filenames), std::move(regexp),
657 } break;
658 case eSetTypeSourceRegexp: // Breakpoint by regexp on source text.
659 {
660 const size_t num_files = m_options.m_filenames.GetSize();
661
662 if (num_files == 0 && !m_options.m_all_files) {
663 FileSpec file;
664 if (!GetDefaultFile(target, file, result)) {
665 result.AppendError(
666 "No files provided and could not find default file.");
667 return false;
668 } else {
670 }
671 }
672
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());
678 return false;
679 }
680 bp_sp = target.CreateSourceRegexBreakpoint(
682 m_options.m_source_regex_func_names, std::move(regexp), internal,
684 } break;
685 case eSetTypeException: {
686 Status precond_error;
687 bp_sp = target.CreateExceptionBreakpoint(
690 &precond_error);
691 if (precond_error.Fail()) {
693 "Error setting extra exception arguments: %s",
694 precond_error.AsCString());
695 target.RemoveBreakpointByID(bp_sp->GetID());
696 return false;
697 }
698 } break;
699 case eSetTypeScripted: {
700
702 bp_sp = target.CreateScriptedBreakpoint(
706 if (error.Fail()) {
708 "Error setting extra exception arguments: %s", error.AsCString());
709 target.RemoveBreakpointByID(bp_sp->GetID());
710 return false;
711 }
712 } break;
713 default:
714 break;
715 }
716
717 // Now set the various options that were passed in:
718 if (bp_sp) {
719 bp_sp->GetOptions().CopyOverSetOptions(m_bp_opts.GetBreakpointOptions());
720
721 if (!m_options.m_breakpoint_names.empty()) {
722 Status name_error;
723 for (auto name : m_options.m_breakpoint_names) {
724 target.AddNameToBreakpoint(bp_sp, name.c_str(), name_error);
725 if (name_error.Fail()) {
726 result.AppendErrorWithFormat("Invalid breakpoint name: %s",
727 name.c_str());
728 target.RemoveBreakpointByID(bp_sp->GetID());
729 return false;
730 }
731 }
732 }
733 }
734
735 if (bp_sp) {
736 Stream &output_stream = result.GetOutputStream();
737 const bool show_locations = false;
738 bp_sp->GetDescription(&output_stream, lldb::eDescriptionLevelInitial,
739 show_locations);
740 if (&target == &GetDummyTarget())
741 output_stream.Printf("Breakpoint set in dummy target, will get copied "
742 "into future targets.\n");
743 else {
744 // Don't print out this warning for exception breakpoints. They can
745 // get set before the target is set, but we won't know how to actually
746 // set the breakpoint till we run.
747 if (bp_sp->GetNumLocations() == 0 && break_type != eSetTypeException) {
748 output_stream.Printf("WARNING: Unable to resolve breakpoint to any "
749 "actual locations.\n");
750 }
751 }
753 } else if (!bp_sp) {
754 result.AppendError("Breakpoint creation failed: No breakpoint created.");
755 }
756
757 return result.Succeeded();
758 }
759
760private:
761 bool GetDefaultFile(Target &target, FileSpec &file,
762 CommandReturnObject &result) {
763 uint32_t default_line;
764 // First use the Source Manager's default file. Then use the current stack
765 // frame's file.
766 if (!target.GetSourceManager().GetDefaultFileAndLine(file, default_line)) {
767 StackFrame *cur_frame = m_exe_ctx.GetFramePtr();
768 if (cur_frame == nullptr) {
769 result.AppendError(
770 "No selected frame to use to find the default file.");
771 return false;
772 } else if (!cur_frame->HasDebugInformation()) {
773 result.AppendError("Cannot use the selected frame to find the default "
774 "file, it has no debug info.");
775 return false;
776 } else {
777 const SymbolContext &sc =
778 cur_frame->GetSymbolContext(eSymbolContextLineEntry);
779 if (sc.line_entry.file) {
780 file = sc.line_entry.file;
781 } else {
782 result.AppendError("Can't find the file for the selected frame to "
783 "use as the default file.");
784 return false;
785 }
786 }
787 }
788 return true;
789 }
790
796};
797
798// CommandObjectBreakpointModify
799#pragma mark Modify
800
802public:
804 : CommandObjectParsed(interpreter, "breakpoint modify",
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.",
811 nullptr) {
815 // Add the entry for the first argument for this command to the object's
816 // arguments vector.
817 m_arguments.push_back(arg);
818
824 }
825
826 ~CommandObjectBreakpointModify() override = default;
827
828 void
830 OptionElementVector &opt_element_vector) override {
833 request, nullptr);
834 }
835
836 Options *GetOptions() override { return &m_options; }
837
838protected:
839 bool DoExecute(Args &command, CommandReturnObject &result) override {
841
842 std::unique_lock<std::recursive_mutex> lock;
843 target.GetBreakpointList().GetListMutex(lock);
844
845 BreakpointIDList valid_bp_ids;
846
848 command, &target, result, &valid_bp_ids,
849 BreakpointName::Permissions::PermissionKinds::disablePerm);
850
851 if (result.Succeeded()) {
852 const size_t count = valid_bp_ids.GetSize();
853 for (size_t i = 0; i < count; ++i) {
854 BreakpointID cur_bp_id = valid_bp_ids.GetBreakpointIDAtIndex(i);
855
856 if (cur_bp_id.GetBreakpointID() != LLDB_INVALID_BREAK_ID) {
857 Breakpoint *bp =
858 target.GetBreakpointByID(cur_bp_id.GetBreakpointID()).get();
859 if (cur_bp_id.GetLocationID() != LLDB_INVALID_BREAK_ID) {
860 BreakpointLocation *location =
861 bp->FindLocationByID(cur_bp_id.GetLocationID()).get();
862 if (location)
865 } else {
868 }
869 }
870 }
871 }
872
873 return result.Succeeded();
874 }
875
876private:
880};
881
882// CommandObjectBreakpointEnable
883#pragma mark Enable
884
886public:
888 : CommandObjectParsed(interpreter, "enable",
889 "Enable the specified disabled breakpoint(s). If "
890 "no breakpoints are specified, enable all of them.",
891 nullptr) {
895 // Add the entry for the first argument for this command to the object's
896 // arguments vector.
897 m_arguments.push_back(arg);
898 }
899
900 ~CommandObjectBreakpointEnable() override = default;
901
902 void
904 OptionElementVector &opt_element_vector) override {
907 request, nullptr);
908 }
909
910protected:
911 bool DoExecute(Args &command, CommandReturnObject &result) override {
913
914 std::unique_lock<std::recursive_mutex> lock;
915 target.GetBreakpointList().GetListMutex(lock);
916
917 const BreakpointList &breakpoints = target.GetBreakpointList();
918
919 size_t num_breakpoints = breakpoints.GetSize();
920
921 if (num_breakpoints == 0) {
922 result.AppendError("No breakpoints exist to be enabled.");
923 return false;
924 }
925
926 if (command.empty()) {
927 // No breakpoint selected; enable all currently set breakpoints.
929 result.AppendMessageWithFormat("All breakpoints enabled. (%" PRIu64
930 " breakpoints)\n",
931 (uint64_t)num_breakpoints);
933 } else {
934 // Particular breakpoint selected; enable that breakpoint.
935 BreakpointIDList valid_bp_ids;
937 command, &target, result, &valid_bp_ids,
938 BreakpointName::Permissions::PermissionKinds::disablePerm);
939
940 if (result.Succeeded()) {
941 int enable_count = 0;
942 int loc_count = 0;
943 const size_t count = valid_bp_ids.GetSize();
944 for (size_t i = 0; i < count; ++i) {
945 BreakpointID cur_bp_id = valid_bp_ids.GetBreakpointIDAtIndex(i);
946
947 if (cur_bp_id.GetBreakpointID() != LLDB_INVALID_BREAK_ID) {
948 Breakpoint *breakpoint =
949 target.GetBreakpointByID(cur_bp_id.GetBreakpointID()).get();
950 if (cur_bp_id.GetLocationID() != LLDB_INVALID_BREAK_ID) {
951 BreakpointLocation *location =
952 breakpoint->FindLocationByID(cur_bp_id.GetLocationID()).get();
953 if (location) {
954 location->SetEnabled(true);
955 ++loc_count;
956 }
957 } else {
958 breakpoint->SetEnabled(true);
959 ++enable_count;
960 }
961 }
962 }
963 result.AppendMessageWithFormat("%d breakpoints enabled.\n",
964 enable_count + loc_count);
966 }
967 }
968
969 return result.Succeeded();
970 }
971};
972
973// CommandObjectBreakpointDisable
974#pragma mark Disable
975
977public:
980 interpreter, "breakpoint disable",
981 "Disable the specified breakpoint(s) without deleting "
982 "them. If none are specified, disable all "
983 "breakpoints.",
984 nullptr) {
986 "Disable the specified breakpoint(s) without deleting them. \
987If none are specified, disable all breakpoints."
988 R"(
989
990)"
991 "Note: disabling a breakpoint will cause none of its locations to be hit \
992regardless of whether individual locations are enabled or disabled. After the sequence:"
993 R"(
994
995 (lldb) break disable 1
996 (lldb) break enable 1.1
997
998execution will NOT stop at location 1.1. To achieve that, type:
999
1000 (lldb) break disable 1.*
1001 (lldb) break enable 1.1
1002
1004 "The first command disables all locations for breakpoint 1, \
1005the second re-enables the first location.");
1010 // Add the entry for the first argument for this command to the object's
1011 // arguments vector.
1012 m_arguments.push_back(arg);
1013 }
1015 ~CommandObjectBreakpointDisable() override = default;
1016
1017 void
1019 OptionElementVector &opt_element_vector) override {
1022 request, nullptr);
1023 }
1024
1025protected:
1026 bool DoExecute(Args &command, CommandReturnObject &result) override {
1027 Target &target = GetSelectedOrDummyTarget();
1028 std::unique_lock<std::recursive_mutex> lock;
1029 target.GetBreakpointList().GetListMutex(lock);
1030
1031 const BreakpointList &breakpoints = target.GetBreakpointList();
1032 size_t num_breakpoints = breakpoints.GetSize();
1033
1034 if (num_breakpoints == 0) {
1035 result.AppendError("No breakpoints exist to be disabled.");
1036 return false;
1037 }
1038
1039 if (command.empty()) {
1040 // No breakpoint selected; disable all currently set breakpoints.
1042 result.AppendMessageWithFormat("All breakpoints disabled. (%" PRIu64
1043 " breakpoints)\n",
1044 (uint64_t)num_breakpoints);
1046 } else {
1047 // Particular breakpoint selected; disable that breakpoint.
1048 BreakpointIDList valid_bp_ids;
1049
1051 command, &target, result, &valid_bp_ids,
1052 BreakpointName::Permissions::PermissionKinds::disablePerm);
1053
1054 if (result.Succeeded()) {
1055 int disable_count = 0;
1056 int loc_count = 0;
1057 const size_t count = valid_bp_ids.GetSize();
1058 for (size_t i = 0; i < count; ++i) {
1059 BreakpointID cur_bp_id = valid_bp_ids.GetBreakpointIDAtIndex(i);
1060
1061 if (cur_bp_id.GetBreakpointID() != LLDB_INVALID_BREAK_ID) {
1062 Breakpoint *breakpoint =
1063 target.GetBreakpointByID(cur_bp_id.GetBreakpointID()).get();
1064 if (cur_bp_id.GetLocationID() != LLDB_INVALID_BREAK_ID) {
1065 BreakpointLocation *location =
1066 breakpoint->FindLocationByID(cur_bp_id.GetLocationID()).get();
1067 if (location) {
1068 location->SetEnabled(false);
1069 ++loc_count;
1070 }
1071 } else {
1072 breakpoint->SetEnabled(false);
1073 ++disable_count;
1074 }
1075 }
1076 }
1077 result.AppendMessageWithFormat("%d breakpoints disabled.\n",
1078 disable_count + loc_count);
1080 }
1081 }
1082
1083 return result.Succeeded();
1084 }
1085};
1086
1087// CommandObjectBreakpointList
1088
1089#pragma mark List::CommandOptions
1090#define LLDB_OPTIONS_breakpoint_list
1091#include "CommandOptions.inc"
1092
1093#pragma mark List
1094
1096public:
1099 interpreter, "breakpoint list",
1100 "List some or all breakpoints at configurable levels of detail.",
1101 nullptr) {
1103 CommandArgumentData bp_id_arg;
1104
1105 // Define the first (and only) variant of this arg.
1106 bp_id_arg.arg_type = eArgTypeBreakpointID;
1108
1109 // There is only one variant this argument could be; put it into the
1110 // argument entry.
1111 arg.push_back(bp_id_arg);
1112
1113 // Push the data for the first argument into the m_arguments vector.
1114 m_arguments.push_back(arg);
1115 }
1116
1117 ~CommandObjectBreakpointList() override = default;
1118
1119 Options *GetOptions() override { return &m_options; }
1120
1121 class CommandOptions : public Options {
1122 public:
1123 CommandOptions() = default;
1124
1125 ~CommandOptions() override = default;
1126
1127 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
1128 ExecutionContext *execution_context) override {
1129 Status error;
1130 const int short_option = m_getopt_table[option_idx].val;
1131
1132 switch (short_option) {
1133 case 'b':
1135 break;
1136 case 'D':
1137 m_use_dummy = true;
1138 break;
1139 case 'f':
1141 break;
1142 case 'v':
1144 break;
1145 case 'i':
1146 m_internal = true;
1147 break;
1148 default:
1149 llvm_unreachable("Unimplemented option");
1150 }
1151
1152 return error;
1153 }
1154
1155 void OptionParsingStarting(ExecutionContext *execution_context) override {
1157 m_internal = false;
1158 m_use_dummy = false;
1159 }
1160
1161 llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
1162 return llvm::ArrayRef(g_breakpoint_list_options);
1163 }
1164
1165 // Instance variables to hold the values for command options.
1166
1168
1170 bool m_use_dummy = false;
1171 };
1172
1173protected:
1174 bool DoExecute(Args &command, CommandReturnObject &result) override {
1176
1177 const BreakpointList &breakpoints =
1179 std::unique_lock<std::recursive_mutex> lock;
1181
1182 size_t num_breakpoints = breakpoints.GetSize();
1183
1184 if (num_breakpoints == 0) {
1185 result.AppendMessage("No breakpoints currently set.");
1187 return true;
1188 }
1189
1190 Stream &output_stream = result.GetOutputStream();
1191
1192 if (command.empty()) {
1193 // No breakpoint selected; show info about all currently set breakpoints.
1194 result.AppendMessage("Current breakpoints:");
1195 for (size_t i = 0; i < num_breakpoints; ++i) {
1196 Breakpoint *breakpoint = breakpoints.GetBreakpointAtIndex(i).get();
1197 if (breakpoint->AllowList())
1198 AddBreakpointDescription(&output_stream, breakpoint,
1200 }
1202 } else {
1203 // Particular breakpoints selected; show info about that breakpoint.
1204 BreakpointIDList valid_bp_ids;
1206 command, &target, result, &valid_bp_ids,
1207 BreakpointName::Permissions::PermissionKinds::listPerm);
1208
1209 if (result.Succeeded()) {
1210 for (size_t i = 0; i < valid_bp_ids.GetSize(); ++i) {
1211 BreakpointID cur_bp_id = valid_bp_ids.GetBreakpointIDAtIndex(i);
1212 Breakpoint *breakpoint =
1213 target.GetBreakpointByID(cur_bp_id.GetBreakpointID()).get();
1214 AddBreakpointDescription(&output_stream, breakpoint,
1216 }
1218 } else {
1219 result.AppendError("Invalid breakpoint ID.");
1220 }
1221 }
1222
1223 return result.Succeeded();
1224 }
1225
1226private:
1228};
1229
1230// CommandObjectBreakpointClear
1231#pragma mark Clear::CommandOptions
1232
1233#define LLDB_OPTIONS_breakpoint_clear
1234#include "CommandOptions.inc"
1235
1236#pragma mark Clear
1237
1239public:
1241
1243 : CommandObjectParsed(interpreter, "breakpoint clear",
1244 "Delete or disable breakpoints matching the "
1245 "specified source file and line.",
1246 "breakpoint clear <cmd-options>") {}
1247
1248 ~CommandObjectBreakpointClear() override = default;
1249
1250 Options *GetOptions() override { return &m_options; }
1251
1252 class CommandOptions : public Options {
1253 public:
1254 CommandOptions() = default;
1255
1256 ~CommandOptions() override = default;
1257
1258 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
1259 ExecutionContext *execution_context) override {
1260 Status error;
1261 const int short_option = m_getopt_table[option_idx].val;
1262
1263 switch (short_option) {
1264 case 'f':
1265 m_filename.assign(std::string(option_arg));
1266 break;
1267
1268 case 'l':
1269 option_arg.getAsInteger(0, m_line_num);
1270 break;
1271
1272 default:
1273 llvm_unreachable("Unimplemented option");
1274 }
1275
1276 return error;
1277 }
1278
1279 void OptionParsingStarting(ExecutionContext *execution_context) override {
1280 m_filename.clear();
1281 m_line_num = 0;
1282 }
1283
1284 llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
1285 return llvm::ArrayRef(g_breakpoint_clear_options);
1286 }
1287
1288 // Instance variables to hold the values for command options.
1289
1290 std::string m_filename;
1292 };
1293
1294protected:
1295 bool DoExecute(Args &command, CommandReturnObject &result) override {
1296 Target &target = GetSelectedOrDummyTarget();
1297
1298 // The following are the various types of breakpoints that could be
1299 // cleared:
1300 // 1). -f -l (clearing breakpoint by source location)
1301
1303
1304 if (m_options.m_line_num != 0)
1305 break_type = eClearTypeFileAndLine;
1306
1307 std::unique_lock<std::recursive_mutex> lock;
1308 target.GetBreakpointList().GetListMutex(lock);
1309
1310 BreakpointList &breakpoints = target.GetBreakpointList();
1311 size_t num_breakpoints = breakpoints.GetSize();
1312
1313 // Early return if there's no breakpoint at all.
1314 if (num_breakpoints == 0) {
1315 result.AppendError("Breakpoint clear: No breakpoint cleared.");
1316 return result.Succeeded();
1317 }
1318
1319 // Find matching breakpoints and delete them.
1320
1321 // First create a copy of all the IDs.
1322 std::vector<break_id_t> BreakIDs;
1323 for (size_t i = 0; i < num_breakpoints; ++i)
1324 BreakIDs.push_back(breakpoints.GetBreakpointAtIndex(i)->GetID());
1325
1326 int num_cleared = 0;
1327 StreamString ss;
1328 switch (break_type) {
1329 case eClearTypeFileAndLine: // Breakpoint by source position
1330 {
1331 const ConstString filename(m_options.m_filename.c_str());
1333
1334 for (size_t i = 0; i < num_breakpoints; ++i) {
1335 Breakpoint *bp = breakpoints.FindBreakpointByID(BreakIDs[i]).get();
1336
1337 if (bp->GetMatchingFileLine(filename, m_options.m_line_num, loc_coll)) {
1338 // If the collection size is 0, it's a full match and we can just
1339 // remove the breakpoint.
1340 if (loc_coll.GetSize() == 0) {
1342 ss.EOL();
1343 target.RemoveBreakpointByID(bp->GetID());
1344 ++num_cleared;
1345 }
1346 }
1347 }
1348 } break;
1349
1350 default:
1351 break;
1352 }
1353
1354 if (num_cleared > 0) {
1355 Stream &output_stream = result.GetOutputStream();
1356 output_stream.Printf("%d breakpoints cleared:\n", num_cleared);
1357 output_stream << ss.GetString();
1358 output_stream.EOL();
1360 } else {
1361 result.AppendError("Breakpoint clear: No breakpoint cleared.");
1362 }
1363
1364 return result.Succeeded();
1365 }
1366
1367private:
1369};
1370
1371// CommandObjectBreakpointDelete
1372#define LLDB_OPTIONS_breakpoint_delete
1373#include "CommandOptions.inc"
1374
1375#pragma mark Delete
1376
1378public:
1380 : CommandObjectParsed(interpreter, "breakpoint delete",
1381 "Delete the specified breakpoint(s). If no "
1382 "breakpoints are specified, delete them all.",
1383 nullptr) {
1387 // Add the entry for the first argument for this command to the object's
1388 // arguments vector.
1389 m_arguments.push_back(arg);
1390 }
1391
1393
1394 void
1396 OptionElementVector &opt_element_vector) override {
1399 request, nullptr);
1400 }
1401
1402 Options *GetOptions() override { return &m_options; }
1403
1404 class CommandOptions : public Options {
1405 public:
1406 CommandOptions() = default;
1407
1408 ~CommandOptions() override = default;
1409
1410 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
1411 ExecutionContext *execution_context) override {
1412 Status error;
1413 const int short_option = m_getopt_table[option_idx].val;
1414
1415 switch (short_option) {
1416 case 'f':
1417 m_force = true;
1418 break;
1419
1420 case 'D':
1421 m_use_dummy = true;
1422 break;
1423
1424 case 'd':
1425 m_delete_disabled = true;
1426 break;
1427
1428 default:
1429 llvm_unreachable("Unimplemented option");
1430 }
1431
1432 return error;
1433 }
1434
1435 void OptionParsingStarting(ExecutionContext *execution_context) override {
1436 m_use_dummy = false;
1437 m_force = false;
1438 m_delete_disabled = false;
1439 }
1440
1441 llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
1442 return llvm::ArrayRef(g_breakpoint_delete_options);
1443 }
1444
1445 // Instance variables to hold the values for command options.
1446 bool m_use_dummy = false;
1447 bool m_force = false;
1448 bool m_delete_disabled = false;
1449 };
1450
1451protected:
1452 bool DoExecute(Args &command, CommandReturnObject &result) override {
1454 result.Clear();
1455
1456 std::unique_lock<std::recursive_mutex> lock;
1457 target.GetBreakpointList().GetListMutex(lock);
1458
1459 BreakpointList &breakpoints = target.GetBreakpointList();
1460
1461 size_t num_breakpoints = breakpoints.GetSize();
1462
1463 if (num_breakpoints == 0) {
1464 result.AppendError("No breakpoints exist to be deleted.");
1465 return false;
1466 }
1467
1468 // Handle the delete all breakpoints case:
1469 if (command.empty() && !m_options.m_delete_disabled) {
1470 if (!m_options.m_force &&
1472 "About to delete all breakpoints, do you want to do that?",
1473 true)) {
1474 result.AppendMessage("Operation cancelled...");
1475 } else {
1476 target.RemoveAllowedBreakpoints();
1478 "All breakpoints removed. (%" PRIu64 " breakpoint%s)\n",
1479 (uint64_t)num_breakpoints, num_breakpoints > 1 ? "s" : "");
1480 }
1482 return result.Succeeded();
1483 }
1484
1485 // Either we have some kind of breakpoint specification(s),
1486 // or we are handling "break disable --deleted". Gather the list
1487 // of breakpoints to delete here, the we'll delete them below.
1488 BreakpointIDList valid_bp_ids;
1489
1491 BreakpointIDList excluded_bp_ids;
1492
1493 if (!command.empty()) {
1495 command, &target, result, &excluded_bp_ids,
1496 BreakpointName::Permissions::PermissionKinds::deletePerm);
1497 if (!result.Succeeded())
1498 return false;
1499 }
1500
1501 for (auto breakpoint_sp : breakpoints.Breakpoints()) {
1502 if (!breakpoint_sp->IsEnabled() && breakpoint_sp->AllowDelete()) {
1503 BreakpointID bp_id(breakpoint_sp->GetID());
1504 size_t pos = 0;
1505 if (!excluded_bp_ids.FindBreakpointID(bp_id, &pos))
1506 valid_bp_ids.AddBreakpointID(breakpoint_sp->GetID());
1507 }
1508 }
1509 if (valid_bp_ids.GetSize() == 0) {
1510 result.AppendError("No disabled breakpoints.");
1511 return false;
1512 }
1513 } else {
1515 command, &target, result, &valid_bp_ids,
1516 BreakpointName::Permissions::PermissionKinds::deletePerm);
1517 if (!result.Succeeded())
1518 return false;
1519 }
1520
1521 int delete_count = 0;
1522 int disable_count = 0;
1523 const size_t count = valid_bp_ids.GetSize();
1524 for (size_t i = 0; i < count; ++i) {
1525 BreakpointID cur_bp_id = valid_bp_ids.GetBreakpointIDAtIndex(i);
1526
1527 if (cur_bp_id.GetBreakpointID() != LLDB_INVALID_BREAK_ID) {
1528 if (cur_bp_id.GetLocationID() != LLDB_INVALID_BREAK_ID) {
1529 Breakpoint *breakpoint =
1530 target.GetBreakpointByID(cur_bp_id.GetBreakpointID()).get();
1531 BreakpointLocation *location =
1532 breakpoint->FindLocationByID(cur_bp_id.GetLocationID()).get();
1533 // It makes no sense to try to delete individual locations, so we
1534 // disable them instead.
1535 if (location) {
1536 location->SetEnabled(false);
1537 ++disable_count;
1538 }
1539 } else {
1540 target.RemoveBreakpointByID(cur_bp_id.GetBreakpointID());
1541 ++delete_count;
1542 }
1543 }
1544 }
1546 "%d breakpoints deleted; %d breakpoint locations disabled.\n",
1547 delete_count, disable_count);
1549 return result.Succeeded();
1550 }
1551
1552private:
1554};
1555
1556// CommandObjectBreakpointName
1557#define LLDB_OPTIONS_breakpoint_name
1558#include "CommandOptions.inc"
1559
1561public:
1564
1565 ~BreakpointNameOptionGroup() override = default;
1566
1567 llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
1568 return llvm::ArrayRef(g_breakpoint_name_options);
1569 }
1570
1571 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
1572 ExecutionContext *execution_context) override {
1573 Status error;
1574 const int short_option = g_breakpoint_name_options[option_idx].short_option;
1575
1576 switch (short_option) {
1577 case 'N':
1579 error.Success())
1580 m_name.SetValueFromString(option_arg);
1581 break;
1582 case 'B':
1583 if (m_breakpoint.SetValueFromString(option_arg).Fail())
1584 error.SetErrorStringWithFormat(
1585 "unrecognized value \"%s\" for breakpoint",
1586 option_arg.str().c_str());
1587 break;
1588 case 'D':
1589 if (m_use_dummy.SetValueFromString(option_arg).Fail())
1590 error.SetErrorStringWithFormat(
1591 "unrecognized value \"%s\" for use-dummy",
1592 option_arg.str().c_str());
1593 break;
1594 case 'H':
1596 break;
1597
1598 default:
1599 llvm_unreachable("Unimplemented option");
1600 }
1601 return error;
1602 }
1603
1604 void OptionParsingStarting(ExecutionContext *execution_context) override {
1605 m_name.Clear();
1610 }
1611
1616};
1617
1618#define LLDB_OPTIONS_breakpoint_access
1619#include "CommandOptions.inc"
1620
1622public:
1624
1625 ~BreakpointAccessOptionGroup() override = default;
1626
1627 llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
1628 return llvm::ArrayRef(g_breakpoint_access_options);
1629 }
1630 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
1631 ExecutionContext *execution_context) override {
1632 Status error;
1633 const int short_option =
1634 g_breakpoint_access_options[option_idx].short_option;
1635
1636 switch (short_option) {
1637 case 'L': {
1638 bool value, success;
1639 value = OptionArgParser::ToBoolean(option_arg, false, &success);
1640 if (success) {
1642 } else
1643 error.SetErrorStringWithFormat(
1644 "invalid boolean value '%s' passed for -L option",
1645 option_arg.str().c_str());
1646 } break;
1647 case 'A': {
1648 bool value, success;
1649 value = OptionArgParser::ToBoolean(option_arg, false, &success);
1650 if (success) {
1652 } else
1653 error.SetErrorStringWithFormat(
1654 "invalid boolean value '%s' passed for -L option",
1655 option_arg.str().c_str());
1656 } break;
1657 case 'D': {
1658 bool value, success;
1659 value = OptionArgParser::ToBoolean(option_arg, false, &success);
1660 if (success) {
1662 } else
1663 error.SetErrorStringWithFormat(
1664 "invalid boolean value '%s' passed for -L option",
1665 option_arg.str().c_str());
1666 } break;
1667 default:
1668 llvm_unreachable("Unimplemented option");
1669 }
1670
1671 return error;
1672 }
1673
1674 void OptionParsingStarting(ExecutionContext *execution_context) override {}
1675
1677 return m_permissions;
1678 }
1680};
1681
1683public:
1686 interpreter, "configure",
1687 "Configure the options for the breakpoint"
1688 " name provided. "
1689 "If you provide a breakpoint id, the options will be copied from "
1690 "the breakpoint, otherwise only the options specified will be set "
1691 "on the name.",
1692 "breakpoint name configure <command-options> "
1693 "<breakpoint-name-list>") {
1694 // Create the first variant for the first (and only) argument for this
1695 // command.
1697 CommandArgumentData id_arg;
1700 arg1.push_back(id_arg);
1701 m_arguments.push_back(arg1);
1702
1709 }
1710
1712
1713 Options *GetOptions() override { return &m_option_group; }
1714
1715protected:
1716 bool DoExecute(Args &command, CommandReturnObject &result) override {
1717
1718 const size_t argc = command.GetArgumentCount();
1719 if (argc == 0) {
1720 result.AppendError("No names provided.");
1721 return false;
1722 }
1723
1724 Target &target = GetSelectedOrDummyTarget(false);
1725
1726 std::unique_lock<std::recursive_mutex> lock;
1727 target.GetBreakpointList().GetListMutex(lock);
1728
1729 // Make a pass through first to see that all the names are legal.
1730 for (auto &entry : command.entries()) {
1731 Status error;
1732 if (!BreakpointID::StringIsBreakpointName(entry.ref(), error)) {
1733 result.AppendErrorWithFormat("Invalid breakpoint name: %s - %s",
1734 entry.c_str(), error.AsCString());
1735 return false;
1736 }
1737 }
1738 // Now configure them, we already pre-checked the names so we don't need to
1739 // check the error:
1740 BreakpointSP bp_sp;
1742 lldb::break_id_t bp_id =
1743 m_bp_id.m_breakpoint.GetValueAs<uint64_t>().value_or(0);
1744 bp_sp = target.GetBreakpointByID(bp_id);
1745 if (!bp_sp) {
1746 result.AppendErrorWithFormatv("Could not find specified breakpoint {0}",
1747 bp_id);
1748 return false;
1749 }
1750 }
1751
1752 Status error;
1753 for (auto &entry : command.entries()) {
1754 ConstString name(entry.c_str());
1755 BreakpointName *bp_name = target.FindBreakpointName(name, true, error);
1756 if (!bp_name)
1757 continue;
1759 bp_name->SetHelp(m_bp_id.m_help_string.GetValueAs<llvm::StringRef>()
1760 .value_or("")
1761 .str()
1762 .c_str());
1763
1764 if (bp_sp)
1765 target.ConfigureBreakpointName(*bp_name, bp_sp->GetOptions(),
1767 else
1768 target.ConfigureBreakpointName(*bp_name,
1771 }
1772 return true;
1773 }
1774
1775private:
1776 BreakpointNameOptionGroup m_bp_id; // Only using the id part of this.
1780};
1781
1783public:
1786 interpreter, "add", "Add a name to the breakpoints provided.",
1787 "breakpoint name add <command-options> <breakpoint-id-list>") {
1788 // Create the first variant for the first (and only) argument for this
1789 // command.
1791 CommandArgumentData id_arg;
1794 arg1.push_back(id_arg);
1795 m_arguments.push_back(arg1);
1796
1799 }
1800
1802
1803 void
1805 OptionElementVector &opt_element_vector) override {
1808 request, nullptr);
1809 }
1810
1811 Options *GetOptions() override { return &m_option_group; }
1812
1813protected:
1814 bool DoExecute(Args &command, CommandReturnObject &result) override {
1816 result.AppendError("No name option provided.");
1817 return false;
1818 }
1819
1820 Target &target =
1822
1823 std::unique_lock<std::recursive_mutex> lock;
1824 target.GetBreakpointList().GetListMutex(lock);
1825
1826 const BreakpointList &breakpoints = target.GetBreakpointList();
1827
1828 size_t num_breakpoints = breakpoints.GetSize();
1829 if (num_breakpoints == 0) {
1830 result.AppendError("No breakpoints, cannot add names.");
1831 return false;
1832 }
1833
1834 // Particular breakpoint selected; disable that breakpoint.
1835 BreakpointIDList valid_bp_ids;
1837 command, &target, result, &valid_bp_ids,
1838 BreakpointName::Permissions::PermissionKinds::listPerm);
1839
1840 if (result.Succeeded()) {
1841 if (valid_bp_ids.GetSize() == 0) {
1842 result.AppendError("No breakpoints specified, cannot add names.");
1843 return false;
1844 }
1845 size_t num_valid_ids = valid_bp_ids.GetSize();
1846 const char *bp_name = m_name_options.m_name.GetCurrentValue();
1847 Status error; // This error reports illegal names, but we've already
1848 // checked that, so we don't need to check it again here.
1849 for (size_t index = 0; index < num_valid_ids; index++) {
1850 lldb::break_id_t bp_id =
1851 valid_bp_ids.GetBreakpointIDAtIndex(index).GetBreakpointID();
1852 BreakpointSP bp_sp = breakpoints.FindBreakpointByID(bp_id);
1853 target.AddNameToBreakpoint(bp_sp, bp_name, error);
1854 }
1855 }
1856
1857 return true;
1858 }
1859
1860private:
1863};
1864
1866public:
1869 interpreter, "delete",
1870 "Delete a name from the breakpoints provided.",
1871 "breakpoint name delete <command-options> <breakpoint-id-list>") {
1872 // Create the first variant for the first (and only) argument for this
1873 // command.
1875 CommandArgumentData id_arg;
1878 arg1.push_back(id_arg);
1879 m_arguments.push_back(arg1);
1880
1883 }
1884
1886
1887 void
1889 OptionElementVector &opt_element_vector) override {
1892 request, nullptr);
1893 }
1894
1895 Options *GetOptions() override { return &m_option_group; }
1896
1897protected:
1898 bool DoExecute(Args &command, CommandReturnObject &result) override {
1900 result.AppendError("No name option provided.");
1901 return false;
1902 }
1903
1904 Target &target =
1906
1907 std::unique_lock<std::recursive_mutex> lock;
1908 target.GetBreakpointList().GetListMutex(lock);
1909
1910 const BreakpointList &breakpoints = target.GetBreakpointList();
1911
1912 size_t num_breakpoints = breakpoints.GetSize();
1913 if (num_breakpoints == 0) {
1914 result.AppendError("No breakpoints, cannot delete names.");
1915 return false;
1916 }
1917
1918 // Particular breakpoint selected; disable that breakpoint.
1919 BreakpointIDList valid_bp_ids;
1921 command, &target, result, &valid_bp_ids,
1922 BreakpointName::Permissions::PermissionKinds::deletePerm);
1923
1924 if (result.Succeeded()) {
1925 if (valid_bp_ids.GetSize() == 0) {
1926 result.AppendError("No breakpoints specified, cannot delete names.");
1927 return false;
1928 }
1930 size_t num_valid_ids = valid_bp_ids.GetSize();
1931 for (size_t index = 0; index < num_valid_ids; index++) {
1932 lldb::break_id_t bp_id =
1933 valid_bp_ids.GetBreakpointIDAtIndex(index).GetBreakpointID();
1934 BreakpointSP bp_sp = breakpoints.FindBreakpointByID(bp_id);
1935 target.RemoveNameFromBreakpoint(bp_sp, bp_name);
1936 }
1937 }
1938
1939 return true;
1940 }
1941
1942private:
1945};
1946
1948public:
1950 : CommandObjectParsed(interpreter, "list",
1951 "List either the names for a breakpoint or info "
1952 "about a given name. With no arguments, lists all "
1953 "names",
1954 "breakpoint name list <command-options>") {
1957 }
1958
1960
1961 Options *GetOptions() override { return &m_option_group; }
1962
1963protected:
1964 bool DoExecute(Args &command, CommandReturnObject &result) override {
1965 Target &target =
1967
1968 std::vector<std::string> name_list;
1969 if (command.empty()) {
1970 target.GetBreakpointNames(name_list);
1971 } else {
1972 for (const Args::ArgEntry &arg : command) {
1973 name_list.push_back(arg.c_str());
1974 }
1975 }
1976
1977 if (name_list.empty()) {
1978 result.AppendMessage("No breakpoint names found.");
1979 } else {
1980 for (const std::string &name_str : name_list) {
1981 const char *name = name_str.c_str();
1982 // First print out the options for the name:
1983 Status error;
1984 BreakpointName *bp_name =
1985 target.FindBreakpointName(ConstString(name), false, error);
1986 if (bp_name) {
1987 StreamString s;
1988 result.AppendMessageWithFormat("Name: %s\n", name);
1989 if (bp_name->GetDescription(&s, eDescriptionLevelFull)) {
1990 result.AppendMessage(s.GetString());
1991 }
1992
1993 std::unique_lock<std::recursive_mutex> lock;
1994 target.GetBreakpointList().GetListMutex(lock);
1995
1996 BreakpointList &breakpoints = target.GetBreakpointList();
1997 bool any_set = false;
1998 for (BreakpointSP bp_sp : breakpoints.Breakpoints()) {
1999 if (bp_sp->MatchesName(name)) {
2000 StreamString s;
2001 any_set = true;
2002 bp_sp->GetDescription(&s, eDescriptionLevelBrief);
2003 s.EOL();
2004 result.AppendMessage(s.GetString());
2005 }
2006 }
2007 if (!any_set)
2008 result.AppendMessage("No breakpoints using this name.");
2009 } else {
2010 result.AppendMessageWithFormat("Name: %s not found.\n", name);
2011 }
2012 }
2013 }
2014 return true;
2015 }
2016
2017private:
2020};
2021
2022// CommandObjectBreakpointName
2024public:
2027 interpreter, "name", "Commands to manage breakpoint names") {
2028
2029
2031 R"(
2032Breakpoint names provide a general tagging mechanism for breakpoints. Each
2033breakpoint name can be added to any number of breakpoints, and each breakpoint
2034can have any number of breakpoint names attached to it. For instance:
2035
2036 (lldb) break name add -N MyName 1-10
2037
2038adds the name MyName to breakpoints 1-10, and:
2039
2040 (lldb) break set -n myFunc -N Name1 -N Name2
2041
2042adds two names to the breakpoint set at myFunc.
2043
2044They have a number of interrelated uses:
2045
20461) They provide a stable way to refer to a breakpoint (e.g. in another
2047breakpoint's action). Using the breakpoint ID for this purpose is fragile, since
2048it depends on the order of breakpoint creation. Giving a name to the breakpoint
2049you want to act on, and then referring to it by name, is more robust:
2050
2051 (lldb) break set -n myFunc -N BKPT1
2052 (lldb) break set -n myOtherFunc -C "break disable BKPT1"
2053
20542) This is actually just a specific use of a more general feature of breakpoint
2055names. The <breakpt-id-list> argument type used to specify one or more
2056breakpoints in most of the commands that deal with breakpoints also accepts
2057breakpoint names. That allows you to refer to one breakpoint in a stable
2058manner, but also makes them a convenient grouping mechanism, allowing you to
2059easily act on a group of breakpoints by using their name, for instance disabling
2060them all in one action:
2061
2062 (lldb) break set -n myFunc -N Group1
2063 (lldb) break set -n myOtherFunc -N Group1
2064 (lldb) break disable Group1
2065
20663) But breakpoint names are also entities in their own right, and can be
2067configured with all the modifiable attributes of a breakpoint. Then when you
2068add a breakpoint name to a breakpoint, the breakpoint will be configured to
2069match the state of the breakpoint name. The link between the name and the
2070breakpoints sharing it remains live, so if you change the configuration on the
2071name, it will also change the configurations on the breakpoints:
2072
2073 (lldb) break name configure -i 10 IgnoreSome
2074 (lldb) break set -n myFunc -N IgnoreSome
2075 (lldb) break list IgnoreSome
2076 2: name = 'myFunc', locations = 0 (pending) Options: ignore: 10 enabled
2077 Names:
2078 IgnoreSome
2079 (lldb) break name configure -i 5 IgnoreSome
2080 (lldb) break list IgnoreSome
2081 2: name = 'myFunc', locations = 0 (pending) Options: ignore: 5 enabled
2082 Names:
2083 IgnoreSome
2084
2085Options that are not configured on a breakpoint name don't affect the value of
2086those options on the breakpoints they are added to. So for instance, if Name1
2087has the -i option configured and Name2 the -c option, adding both names to a
2088breakpoint will set the -i option from Name1 and the -c option from Name2, and
2089the other options will be unaltered.
2090
2091If you add multiple names to a breakpoint which have configured values for
2092the same option, the last name added's value wins.
2093
2094The "liveness" of these settings is one way, from name to breakpoint.
2095If you use "break modify" to change an option that is also configured on a name
2096which that breakpoint has, the "break modify" command will override the setting
2097for that breakpoint, but won't change the value configured in the name or on the
2098other breakpoints sharing that name.
2099
21004) Breakpoint names are also a convenient way to copy option sets from one
2101breakpoint to another. Using the -B option to "breakpoint name configure" makes
2102a name configured with all the options of the original breakpoint. Then
2103adding that name to another breakpoint copies over all the values from the
2104original breakpoint to the new one.
2105
21065) You can also use breakpoint names to hide breakpoints from the breakpoint
2107operations that act on all breakpoints: "break delete", "break disable" and
2108"break list". You do that by specifying a "false" value for the
2109--allow-{list,delete,disable} options to "breakpoint name configure" and then
2110adding that name to a breakpoint.
2111
2112This won't keep the breakpoint from being deleted or disabled if you refer to it
2113specifically by ID. The point of the feature is to make sure users don't
2114inadvertently delete or disable useful breakpoints (e.g. ones an IDE is using
2115for its own purposes) as part of a "delete all" or "disable all" operation. The
2116list hiding is because it's confusing for people to see breakpoints they
2117didn't set.
2118
2119)");
2120 CommandObjectSP add_command_object(
2121 new CommandObjectBreakpointNameAdd(interpreter));
2122 CommandObjectSP delete_command_object(
2123 new CommandObjectBreakpointNameDelete(interpreter));
2124 CommandObjectSP list_command_object(
2125 new CommandObjectBreakpointNameList(interpreter));
2126 CommandObjectSP configure_command_object(
2127 new CommandObjectBreakpointNameConfigure(interpreter));
2128
2129 LoadSubCommand("add", add_command_object);
2130 LoadSubCommand("delete", delete_command_object);
2131 LoadSubCommand("list", list_command_object);
2132 LoadSubCommand("configure", configure_command_object);
2133 }
2134
2135 ~CommandObjectBreakpointName() override = default;
2136};
2137
2138// CommandObjectBreakpointRead
2139#pragma mark Read::CommandOptions
2140#define LLDB_OPTIONS_breakpoint_read
2141#include "CommandOptions.inc"
2142
2143#pragma mark Read
2144
2146public:
2148 : CommandObjectParsed(interpreter, "breakpoint read",
2149 "Read and set the breakpoints previously saved to "
2150 "a file with \"breakpoint write\". ",
2151 nullptr) {}
2152
2153 ~CommandObjectBreakpointRead() override = default;
2154
2155 Options *GetOptions() override { return &m_options; }
2156
2157 class CommandOptions : public Options {
2158 public:
2159 CommandOptions() = default;
2160
2161 ~CommandOptions() override = default;
2162
2163 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
2164 ExecutionContext *execution_context) override {
2165 Status error;
2166 const int short_option = m_getopt_table[option_idx].val;
2167
2168 switch (short_option) {
2169 case 'f':
2170 m_filename.assign(std::string(option_arg));
2171 break;
2172 case 'N': {
2173 Status name_error;
2174 if (!BreakpointID::StringIsBreakpointName(llvm::StringRef(option_arg),
2175 name_error)) {
2176 error.SetErrorStringWithFormat("Invalid breakpoint name: %s",
2177 name_error.AsCString());
2178 }
2179 m_names.push_back(std::string(option_arg));
2180 break;
2181 }
2182 default:
2183 llvm_unreachable("Unimplemented option");
2184 }
2185
2186 return error;
2187 }
2188
2189 void OptionParsingStarting(ExecutionContext *execution_context) override {
2190 m_filename.clear();
2191 m_names.clear();
2192 }
2193
2194 llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
2195 return llvm::ArrayRef(g_breakpoint_read_options);
2196 }
2197
2199 CompletionRequest &request, OptionElementVector &opt_element_vector,
2200 int opt_element_index, CommandInterpreter &interpreter) override {
2201 int opt_arg_pos = opt_element_vector[opt_element_index].opt_arg_pos;
2202 int opt_defs_index = opt_element_vector[opt_element_index].opt_defs_index;
2203
2204 switch (GetDefinitions()[opt_defs_index].short_option) {
2205 case 'f':
2207 interpreter, CommandCompletions::eDiskFileCompletion, request,
2208 nullptr);
2209 break;
2210
2211 case 'N':
2212 std::optional<FileSpec> file_spec;
2213 const llvm::StringRef dash_f("-f");
2214 for (int arg_idx = 0; arg_idx < opt_arg_pos; arg_idx++) {
2215 if (dash_f == request.GetParsedLine().GetArgumentAtIndex(arg_idx)) {
2216 file_spec.emplace(
2217 request.GetParsedLine().GetArgumentAtIndex(arg_idx + 1));
2218 break;
2219 }
2220 }
2221 if (!file_spec)
2222 return;
2223
2224 FileSystem::Instance().Resolve(*file_spec);
2225 Status error;
2226 StructuredData::ObjectSP input_data_sp =
2228 if (!error.Success())
2229 return;
2230
2231 StructuredData::Array *bkpt_array = input_data_sp->GetAsArray();
2232 if (!bkpt_array)
2233 return;
2234
2235 const size_t num_bkpts = bkpt_array->GetSize();
2236 for (size_t i = 0; i < num_bkpts; i++) {
2237 StructuredData::ObjectSP bkpt_object_sp =
2238 bkpt_array->GetItemAtIndex(i);
2239 if (!bkpt_object_sp)
2240 return;
2241
2242 StructuredData::Dictionary *bkpt_dict =
2243 bkpt_object_sp->GetAsDictionary();
2244 if (!bkpt_dict)
2245 return;
2246
2247 StructuredData::ObjectSP bkpt_data_sp =
2249 if (!bkpt_data_sp)
2250 return;
2251
2252 bkpt_dict = bkpt_data_sp->GetAsDictionary();
2253 if (!bkpt_dict)
2254 return;
2255
2256 StructuredData::Array *names_array;
2257
2258 if (!bkpt_dict->GetValueForKeyAsArray("Names", names_array))
2259 return;
2260
2261 size_t num_names = names_array->GetSize();
2262
2263 for (size_t i = 0; i < num_names; i++) {
2264 llvm::StringRef name;
2265 if (names_array->GetItemAtIndexAsString(i, name))
2266 request.TryCompleteCurrentArg(name);
2267 }
2268 }
2269 }
2270 }
2271
2272 std::string m_filename;
2273 std::vector<std::string> m_names;
2274 };
2275
2276protected:
2277 bool DoExecute(Args &command, CommandReturnObject &result) override {
2278 Target &target = GetSelectedOrDummyTarget();
2279
2280 std::unique_lock<std::recursive_mutex> lock;
2281 target.GetBreakpointList().GetListMutex(lock);
2282
2283 FileSpec input_spec(m_options.m_filename);
2284 FileSystem::Instance().Resolve(input_spec);
2285 BreakpointIDList new_bps;
2286 Status error = target.CreateBreakpointsFromFile(input_spec,
2287 m_options.m_names, new_bps);
2288
2289 if (!error.Success()) {
2290 result.AppendError(error.AsCString());
2291 return false;
2292 }
2293
2294 Stream &output_stream = result.GetOutputStream();
2295
2296 size_t num_breakpoints = new_bps.GetSize();
2297 if (num_breakpoints == 0) {
2298 result.AppendMessage("No breakpoints added.");
2299 } else {
2300 // No breakpoint selected; show info about all currently set breakpoints.
2301 result.AppendMessage("New breakpoints:");
2302 for (size_t i = 0; i < num_breakpoints; ++i) {
2303 BreakpointID bp_id = new_bps.GetBreakpointIDAtIndex(i);
2304 Breakpoint *bp = target.GetBreakpointList()
2306 .get();
2307 if (bp)
2309 false);
2310 }
2311 }
2312 return result.Succeeded();
2313 }
2314
2315private:
2317};
2318
2319// CommandObjectBreakpointWrite
2320#pragma mark Write::CommandOptions
2321#define LLDB_OPTIONS_breakpoint_write
2322#include "CommandOptions.inc"
2323
2324#pragma mark Write
2326public:
2328 : CommandObjectParsed(interpreter, "breakpoint write",
2329 "Write the breakpoints listed to a file that can "
2330 "be read in with \"breakpoint read\". "
2331 "If given no arguments, writes all breakpoints.",
2332 nullptr) {
2336 // Add the entry for the first argument for this command to the object's
2337 // arguments vector.
2338 m_arguments.push_back(arg);
2339 }
2340
2341 ~CommandObjectBreakpointWrite() override = default;
2342
2343 void
2345 OptionElementVector &opt_element_vector) override {
2348 request, nullptr);
2349 }
2350
2351 Options *GetOptions() override { return &m_options; }
2352
2353 class CommandOptions : public Options {
2354 public:
2355 CommandOptions() = default;
2356
2357 ~CommandOptions() override = default;
2358
2359 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
2360 ExecutionContext *execution_context) override {
2361 Status error;
2362 const int short_option = m_getopt_table[option_idx].val;
2363
2364 switch (short_option) {
2365 case 'f':
2366 m_filename.assign(std::string(option_arg));
2367 break;
2368 case 'a':
2369 m_append = true;
2370 break;
2371 default:
2372 llvm_unreachable("Unimplemented option");
2373 }
2374
2375 return error;
2376 }
2377
2378 void OptionParsingStarting(ExecutionContext *execution_context) override {
2379 m_filename.clear();
2380 m_append = false;
2381 }
2382
2383 llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
2384 return llvm::ArrayRef(g_breakpoint_write_options);
2385 }
2386
2387 // Instance variables to hold the values for command options.
2388
2389 std::string m_filename;
2390 bool m_append = false;
2391 };
2392
2393protected:
2394 bool DoExecute(Args &command, CommandReturnObject &result) override {
2395 Target &target = GetSelectedOrDummyTarget();
2396
2397 std::unique_lock<std::recursive_mutex> lock;
2398 target.GetBreakpointList().GetListMutex(lock);
2399
2400 BreakpointIDList valid_bp_ids;
2401 if (!command.empty()) {
2403 command, &target, result, &valid_bp_ids,
2404 BreakpointName::Permissions::PermissionKinds::listPerm);
2405
2406 if (!result.Succeeded()) {
2408 return false;
2409 }
2410 }
2411 FileSpec file_spec(m_options.m_filename);
2412 FileSystem::Instance().Resolve(file_spec);
2413 Status error = target.SerializeBreakpointsToFile(file_spec, valid_bp_ids,
2415 if (!error.Success()) {
2416 result.AppendErrorWithFormat("error serializing breakpoints: %s.",
2417 error.AsCString());
2418 }
2419 return result.Succeeded();
2420 }
2421
2422private:
2424};
2425
2426// CommandObjectMultiwordBreakpoint
2427#pragma mark MultiwordBreakpoint
2428
2430 CommandInterpreter &interpreter)
2432 interpreter, "breakpoint",
2433 "Commands for operating on breakpoints (see 'help b' for shorthand.)",
2434 "breakpoint <subcommand> [<command-options>]") {
2435 CommandObjectSP list_command_object(
2436 new CommandObjectBreakpointList(interpreter));
2437 CommandObjectSP enable_command_object(
2438 new CommandObjectBreakpointEnable(interpreter));
2439 CommandObjectSP disable_command_object(
2440 new CommandObjectBreakpointDisable(interpreter));
2441 CommandObjectSP clear_command_object(
2442 new CommandObjectBreakpointClear(interpreter));
2443 CommandObjectSP delete_command_object(
2444 new CommandObjectBreakpointDelete(interpreter));
2445 CommandObjectSP set_command_object(
2446 new CommandObjectBreakpointSet(interpreter));
2447 CommandObjectSP command_command_object(
2448 new CommandObjectBreakpointCommand(interpreter));
2449 CommandObjectSP modify_command_object(
2450 new CommandObjectBreakpointModify(interpreter));
2451 CommandObjectSP name_command_object(
2452 new CommandObjectBreakpointName(interpreter));
2453 CommandObjectSP write_command_object(
2454 new CommandObjectBreakpointWrite(interpreter));
2455 CommandObjectSP read_command_object(
2456 new CommandObjectBreakpointRead(interpreter));
2457
2458 list_command_object->SetCommandName("breakpoint list");
2459 enable_command_object->SetCommandName("breakpoint enable");
2460 disable_command_object->SetCommandName("breakpoint disable");
2461 clear_command_object->SetCommandName("breakpoint clear");
2462 delete_command_object->SetCommandName("breakpoint delete");
2463 set_command_object->SetCommandName("breakpoint set");
2464 command_command_object->SetCommandName("breakpoint command");
2465 modify_command_object->SetCommandName("breakpoint modify");
2466 name_command_object->SetCommandName("breakpoint name");
2467 write_command_object->SetCommandName("breakpoint write");
2468 read_command_object->SetCommandName("breakpoint read");
2469
2470 LoadSubCommand("list", list_command_object);
2471 LoadSubCommand("enable", enable_command_object);
2472 LoadSubCommand("disable", disable_command_object);
2473 LoadSubCommand("clear", clear_command_object);
2474 LoadSubCommand("delete", delete_command_object);
2475 LoadSubCommand("set", set_command_object);
2476 LoadSubCommand("command", command_command_object);
2477 LoadSubCommand("modify", modify_command_object);
2478 LoadSubCommand("name", name_command_object);
2479 LoadSubCommand("write", write_command_object);
2480 LoadSubCommand("read", read_command_object);
2481}
2482
2484
2486 Args &args, Target *target, bool allow_locations,
2487 CommandReturnObject &result, BreakpointIDList *valid_ids,
2488 BreakpointName::Permissions ::PermissionKinds purpose) {
2489 // args can be strings representing 1). integers (for breakpoint ids)
2490 // 2). the full breakpoint & location
2491 // canonical representation
2492 // 3). the word "to" or a hyphen,
2493 // representing a range (in which case there
2494 // had *better* be an entry both before &
2495 // after of one of the first two types.
2496 // 4). A breakpoint name
2497 // If args is empty, we will use the last created breakpoint (if there is
2498 // one.)
2499
2500 Args temp_args;
2501
2502 if (args.empty()) {
2503 if (target->GetLastCreatedBreakpoint()) {
2504 valid_ids->AddBreakpointID(BreakpointID(
2505 target->GetLastCreatedBreakpoint()->GetID(), LLDB_INVALID_BREAK_ID));
2507 } else {
2508 result.AppendError(
2509 "No breakpoint specified and no last created breakpoint.");
2510 }
2511 return;
2512 }
2513
2514 // Create a new Args variable to use; copy any non-breakpoint-id-ranges stuff
2515 // directly from the old ARGS to the new TEMP_ARGS. Do not copy breakpoint
2516 // id range strings over; instead generate a list of strings for all the
2517 // breakpoint ids in the range, and shove all of those breakpoint id strings
2518 // into TEMP_ARGS.
2519
2520 BreakpointIDList::FindAndReplaceIDRanges(args, target, allow_locations,
2521 purpose, result, temp_args);
2522
2523 // NOW, convert the list of breakpoint id strings in TEMP_ARGS into an actual
2524 // BreakpointIDList:
2525
2526 valid_ids->InsertStringArray(temp_args.GetArgumentArrayRef(), result);
2527
2528 // At this point, all of the breakpoint ids that the user passed in have
2529 // been converted to breakpoint IDs and put into valid_ids.
2530
2531 if (result.Succeeded()) {
2532 // Now that we've converted everything from args into a list of breakpoint
2533 // ids, go through our tentative list of breakpoint id's and verify that
2534 // they correspond to valid/currently set breakpoints.
2535
2536 const size_t count = valid_ids->GetSize();
2537 for (size_t i = 0; i < count; ++i) {
2538 BreakpointID cur_bp_id = valid_ids->GetBreakpointIDAtIndex(i);
2539 Breakpoint *breakpoint =
2540 target->GetBreakpointByID(cur_bp_id.GetBreakpointID()).get();
2541 if (breakpoint != nullptr) {
2542 const size_t num_locations = breakpoint->GetNumLocations();
2543 if (static_cast<size_t>(cur_bp_id.GetLocationID()) > num_locations) {
2544 StreamString id_str;
2546 &id_str, cur_bp_id.GetBreakpointID(), cur_bp_id.GetLocationID());
2547 i = valid_ids->GetSize() + 1;
2548 result.AppendErrorWithFormat(
2549 "'%s' is not a currently valid breakpoint/location id.\n",
2550 id_str.GetData());
2551 }
2552 } else {
2553 i = valid_ids->GetSize() + 1;
2554 result.AppendErrorWithFormat(
2555 "'%d' is not a currently valid breakpoint ID.\n",
2556 cur_bp_id.GetBreakpointID());
2557 }
2558 }
2559 }
2560}
static void AddBreakpointDescription(Stream *s, Breakpoint *bp, lldb::DescriptionLevel level)
static llvm::raw_ostream & error(Stream &strm)
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
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
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
~BreakpointNameOptionGroup() 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.
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
void OptionParsingStarting(ExecutionContext *execution_context) 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.
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.
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
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.
bool DoExecute(Args &command, CommandReturnObject &result) override
~CommandObjectBreakpointList() override=default
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)
~CommandObjectBreakpointModify() override=default
bool DoExecute(Args &command, CommandReturnObject &result) override
bool DoExecute(Args &command, CommandReturnObject &result) override
CommandObjectBreakpointNameAdd(CommandInterpreter &interpreter)
~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.
~CommandObjectBreakpointNameConfigure() override=default
bool DoExecute(Args &command, CommandReturnObject &result) override
CommandObjectBreakpointNameConfigure(CommandInterpreter &interpreter)
void HandleArgumentCompletion(CompletionRequest &request, OptionElementVector &opt_element_vector) override
The input array contains a parsed version of the line.
CommandObjectBreakpointNameDelete(CommandInterpreter &interpreter)
~CommandObjectBreakpointNameDelete() override=default
bool DoExecute(Args &command, CommandReturnObject &result) override
CommandObjectBreakpointNameList(CommandInterpreter &interpreter)
~CommandObjectBreakpointNameList() override=default
bool DoExecute(Args &command, CommandReturnObject &result) override
~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.
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)
~CommandObjectBreakpointRead() 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
std::unordered_set< std::string > m_source_regex_func_names
bool DoExecute(Args &command, CommandReturnObject &result) override
~CommandObjectBreakpointSet() override=default
bool GetDefaultFile(Target &target, FileSpec &file, CommandReturnObject &result)
OptionGroupPythonClassWithDict m_python_class_options
CommandObjectBreakpointSet(CommandInterpreter &interpreter)
BreakpointDummyOptionGroup m_dummy_options
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
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.
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.
Definition: Args.h:33
llvm::ArrayRef< const char * > GetArgumentArrayRef() const
Gets the argument as an ArrayRef.
Definition: Args.h:169
size_t GetArgumentCount() const
Gets the number of arguments left in this command object.
Definition: Args.h:116
void AppendArgument(llvm::StringRef arg_str, char quote_char='\0')
Appends a new argument to the end of the list argument list.
Definition: Args.cpp:322
llvm::ArrayRef< ArgEntry > entries() const
Definition: Args.h:128
const char * GetArgumentAtIndex(size_t idx) const
Gets the NULL terminated C string argument pointer for the argument at index idx.
Definition: Args.cpp:263
bool empty() const
Definition: Args.h:118
void Clear()
Clear the arguments.
Definition: Args.cpp:378
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
Definition: BreakpointID.h:29
lldb::break_id_t GetLocationID() const
Definition: BreakpointID.h:31
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 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()
~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...
Definition: Breakpoint.h:81
void GetDescription(Stream *s, lldb::DescriptionLevel level, bool show_locations=false)
Put a description of this breakpoint into the stream s.
Definition: Breakpoint.cpp:849
BreakpointOptions & GetOptions()
Returns the BreakpointOptions structure set at the breakpoint level.
Definition: Breakpoint.cpp:438
bool AllowList() const
Definition: Breakpoint.h:574
static const char * GetSerializationKey()
Definition: Breakpoint.h:160
bool GetMatchingFileLine(ConstString filename, uint32_t line_number, BreakpointLocationCollection &loc_coll)
Find breakpoint locations which match the (filename, line_number) description.
Definition: Breakpoint.cpp:956
lldb::BreakpointLocationSP FindLocationByID(lldb::break_id_t bp_loc_id)
Find a breakpoint location for a given breakpoint location ID.
Definition: Breakpoint.cpp:270
size_t GetNumLocations() const
Return the number of breakpoint locations.
Definition: Breakpoint.cpp:842
void SetEnabled(bool enable) override
If enable is true, enable the breakpoint, if false disable it.
Definition: Breakpoint.cpp:290
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)
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)
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)
"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.
Definition: ConstString.h:40
"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.
A file collection class.
Definition: FileSpecList.h:24
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.
A file utility class.
Definition: FileSpec.h:56
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.
Definition: Flags.h:73
static lldb::LanguageType GetLanguageTypeFromString(const char *string)=delete
void Append(OptionGroup *group)
Append options from a OptionGroup class.
Definition: Options.cpp:755
const StructuredData::DictionarySP GetStructuredData()
Status SetValueFromString(llvm::StringRef value, VarSetOperationType op=eVarSetOperationAssign) override
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
std::optional< T > GetValueAs() const
Definition: OptionValue.h:269
A command line option parsing protocol class.
Definition: Options.h:58
std::vector< Option > m_getopt_table
Definition: Options.h:198
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.
Definition: StackFrame.h:41
const SymbolContext & GetSymbolContext(lldb::SymbolContextItem resolve_scope)
Provide a SymbolContext for this StackFrame's current pc value.
Definition: StackFrame.cpp:300
bool HasDebugInformation()
Determine whether this StackFrame has debug information available or not.
An error handling class.
Definition: Status.h:44
bool Fail() const
Test for error condition.
Definition: Status.cpp:181
const char * AsCString(const char *default_error_str="unknown error") const
Get the error string associated with the current error.
Definition: Status.cpp:130
bool Success() const
Test for success condition.
Definition: Status.cpp:287
lldb::break_id_t GetID() const
Definition: Stoppoint.cpp:22
const char * GetData() const
Definition: StreamString.h:43
llvm::StringRef GetString() const
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:107
size_t EOL()
Output and End of Line character to the stream.
Definition: Stream.cpp:128
void IndentLess(unsigned amount=2)
Decrement the current indentation level.
Definition: Stream.cpp:171
void IndentMore(unsigned amount=2)
Increment the current indentation level.
Definition: Stream.cpp:168
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
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.
Definition: SymbolContext.h:33
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)
Definition: Target.cpp:622
lldb::BreakpointSP CreateFuncRegexBreakpoint(const FileSpecList *containingModules, const FileSpecList *containingSourceFiles, RegularExpression func_regexp, lldb::LanguageType requested_language, LazyBool skip_prologue, bool internal, bool request_hardware)
Definition: Target.cpp:588
lldb::BreakpointSP GetBreakpointByID(lldb::break_id_t break_id)
Definition: Target.cpp:326
BreakpointList & GetBreakpointList(bool internal=false)
Definition: Target.cpp:312
SourceManager & GetSourceManager()
Definition: Target.cpp:2721
lldb::BreakpointSP CreateAddressInModuleBreakpoint(lldb::addr_t file_addr, bool internal, const FileSpec *file_spec, bool request_hardware)
Definition: Target.cpp:442
void DisableAllowedBreakpoints()
Definition: Target.cpp:931
bool RemoveBreakpointByID(lldb::break_id_t break_id)
Definition: Target.cpp:955
BreakpointName * FindBreakpointName(ConstString name, bool can_create, Status &error)
Definition: Target.cpp:721
void ConfigureBreakpointName(BreakpointName &bp_name, const BreakpointOptions &options, const BreakpointName::Permissions &permissions)
Definition: Target.cpp:760
Status SerializeBreakpointsToFile(const FileSpec &file, const BreakpointIDList &bp_ids, bool append)
Definition: Target.cpp:1016
lldb::BreakpointSP CreateExceptionBreakpoint(enum lldb::LanguageType language, bool catch_bp, bool throw_bp, bool internal, Args *additional_args=nullptr, Status *additional_args_error=nullptr)
Definition: Target.cpp:605
void EnableAllowedBreakpoints()
Definition: Target.cpp:948
void RemoveAllowedBreakpoints()
Definition: Target.cpp:900
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)
Definition: Target.cpp:354
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)
Definition: Target.cpp:337
void GetBreakpointNames(std::vector< std::string > &names)
Definition: Target.cpp:782
Status CreateBreakpointsFromFile(const FileSpec &file, BreakpointIDList &new_bps)
Definition: Target.cpp:1108
void RemoveNameFromBreakpoint(lldb::BreakpointSP &bp_sp, ConstString name)
Definition: Target.cpp:755
lldb::BreakpointSP GetLastCreatedBreakpoint()
Definition: Target.h:638
void AddNameToBreakpoint(BreakpointID &id, const char *name, Status &error)
Definition: Target.cpp:690
void SetIndex(uint32_t index)
Definition: ThreadSpec.h:45
void SetName(llvm::StringRef name)
Definition: ThreadSpec.h:49
void SetQueueName(llvm::StringRef queue_name)
Definition: ThreadSpec.h:51
#define LLDB_OPT_SET_1
Definition: lldb-defines.h:102
#define LLDB_OPT_SET_2
Definition: lldb-defines.h:103
#define LLDB_INVALID_BREAK_ID
Definition: lldb-defines.h:37
#define LLDB_INVALID_THREAD_ID
Definition: lldb-defines.h:82
#define LLDB_OPT_SET_ALL
Definition: lldb-defines.h:101
#define LLDB_OPT_SET_3
Definition: lldb-defines.h:104
#define LLDB_OPT_SET_11
Definition: lldb-defines.h:112
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:74
#define UINT32_MAX
Definition: lldb-defines.h:19
#define LLDB_OPT_SET_4
Definition: lldb-defines.h:105
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
std::vector< OptionArgElement > OptionElementVector
Definition: Options.h:43
Definition: SBAddress.h:15
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
@ eDescriptionLevelBrief
@ eDescriptionLevelInitial
@ eDescriptionLevelFull
@ eDescriptionLevelVerbose
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.
int32_t break_id_t
Definition: lldb-types.h:84
@ eReturnStatusFailed
@ eReturnStatusSuccessFinishResult
@ eReturnStatusSuccessFinishNoResult
@ eArgTypeBreakpointIDRange
@ eArgTypeBreakpointID
@ eArgTypeBreakpointName
uint64_t addr_t
Definition: lldb-types.h:79
uint64_t tid_t
Definition: lldb-types.h:82
Used to build individual command argument lists.
Definition: CommandObject.h:93
FileSpec file
The source file, possibly mapped by the target.source-map setting.
Definition: LineEntry.h:140
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)