63#include "clang/Frontend/CompilerInstance.h"
64#include "clang/Frontend/CompilerInvocation.h"
65#include "clang/Frontend/FrontendActions.h"
66#include "clang/Serialization/ObjectFilePCHContainerReader.h"
67#include "llvm/ADT/ScopeExit.h"
68#include "llvm/ADT/StringRef.h"
69#include "llvm/Support/FileSystem.h"
70#include "llvm/Support/FormatAdapters.h"
77 const char *prefix_cstr,
78 bool show_stopped_process_status,
Stream &strm) {
83 bool exe_valid =
false;
88 ::strcpy(exe_path,
"<none>");
90 std::string formatted_label =
"";
91 const std::string &label = target->
GetLabel();
93 formatted_label =
" (" + label +
")";
96 strm.
Printf(
"%starget #%u%s: %s", prefix_cstr ? prefix_cstr :
"", target_idx,
97 formatted_label.data(), exe_path);
99 uint32_t properties = 0;
107 strm.
Format(
"{0}platform={1}", properties++ > 0 ?
", " :
" ( ",
108 platform_sp->GetName());
111 bool show_process_status =
false;
114 StateType state = process_sp->GetState();
115 if (show_stopped_process_status)
119 strm.
Printf(
"%spid=%" PRIu64, properties++ > 0 ?
", " :
" ( ", pid);
120 strm.
Printf(
"%sstate=%s", properties++ > 0 ?
", " :
" ( ", state_cstr);
126 if (show_process_status) {
127 const bool only_threads_with_stop_reason =
true;
128 const uint32_t start_frame = 0;
129 const uint32_t num_frames = 1;
130 const uint32_t num_frames_with_source = 1;
131 const bool stop_format =
false;
132 process_sp->GetStatus(strm);
133 process_sp->GetThreadStatus(strm, only_threads_with_stop_reason,
134 start_frame, num_frames, num_frames_with_source,
140 bool show_stopped_process_status,
Stream &strm) {
145 for (uint32_t i = 0; i < num_targets; ++i) {
148 bool is_selected = target_sp.get() == selected_target_sp.get();
150 show_stopped_process_status, strm);
157#define LLDB_OPTIONS_target_dependents
158#include "CommandOptions.inc"
167 return llvm::ArrayRef(g_target_dependents_options);
175 if (option_value.empty()) {
180 const char short_option =
181 g_target_dependents_options[option_idx].short_option;
182 if (short_option ==
'd') {
185 option_value, g_target_dependents_options[option_idx].enum_values, 0,
191 "unrecognized short option '%c'", short_option);
211#pragma mark CommandObjectTargetCreate
217 interpreter,
"target create",
218 "Create a target using the argument as the main executable.",
222 "Fullpath to a core file to use for this target."),
224 "Optional name for this target.", nullptr),
227 "Fullpath to a stand alone debug "
228 "symbols file for when debug symbols "
229 "are not in the executable."),
232 "Fullpath to the file on the remote host if debugging remotely.") {
263 llvm::toString(file.takeError()));
268 if (argc == 1 || core_file || remote_file) {
277 llvm::toString(file.takeError()));
285 bool must_set_platform_path =
false;
290 llvm::StringRef arch_cstr =
m_arch_option.GetArchitectureName();
292 debugger, file_path, arch_cstr,
301 const llvm::StringRef label =
302 m_label.GetOptionValue().GetCurrentValueAsRef();
303 if (!label.empty()) {
304 if (
auto E = target_sp->SetLabel(label))
309 auto on_error = llvm::make_scope_exit(
311 target_list.DeleteTarget(target_sp);
318 PlatformSP platform_sp = target_sp->GetPlatform();
322 file_spec.
SetFile(file_path, FileSpec::Style::native);
327 if (platform_sp && platform_sp->IsHost() &&
337 if (!platform_sp->GetFileExists(remote_file)) {
338 Status err = platform_sp->PutFile(file_spec, remote_file);
352 Status err = platform_sp->GetFile(remote_file, file_spec);
366 if (platform_sp->IsHost()) {
367 result.
AppendError(
"Supply a local file, not a remote file, "
368 "when debugging on the host.");
371 if (platform_sp->IsConnected() && !platform_sp->GetFileExists(remote_file)) {
372 result.
AppendError(
"remote --> local transfer without local "
373 "path is not implemented yet");
380 target_sp->SetProcessLaunchInfo(launch_info);
384 result.
AppendError(
"no platform found for target");
389 if (symfile || remote_file) {
390 ModuleSP module_sp(target_sp->GetExecutableModule());
393 module_sp->SetSymbolFileFileSpec(symfile);
395 std::string remote_path = remote_file.
GetPath();
396 target_sp->SetArg0(remote_path.c_str());
397 module_sp->SetPlatformFileSpec(remote_file);
402 if (must_set_platform_path) {
405 target_sp->GetOrCreateModule(main_module_spec,
true );
407 module_sp->SetPlatformFileSpec(remote_file);
413 target_sp->AppendExecutableSearchPaths(core_file_dir);
415 ProcessSP process_sp(target_sp->CreateProcess(
416 GetDebugger().GetListener(), llvm::StringRef(), &core_file,
false));
423 target_sp->GetStatistics().GetLoadCoreTime());
424 error = process_sp->LoadCore();
432 "Core file '{0}' ({1}) was loaded.\n", core_file.
GetPath(),
433 target_sp->GetArchitecture().GetArchitectureName());
443 "Current executable set to '%s' (%s).\n",
445 target_sp->GetArchitecture().GetArchitectureName());
451 "argument, or use the --core option.\n",
467#pragma mark CommandObjectTargetList
473 interpreter,
"target list",
474 "List all current targets in the current debug session.", nullptr) {
483 bool show_stopped_process_status =
false;
485 show_stopped_process_status, strm) == 0) {
492#pragma mark CommandObjectTargetSelect
498 interpreter,
"target select",
499 "Select a target as the current target by target index.", nullptr) {
512 if (llvm::to_integer(target_identifier, target_idx)) {
513 if (target_idx < num_targets) {
516 bool show_stopped_process_status =
false;
520 if (num_targets > 0) {
522 "index %u is out of range, valid target indexes are 0 - %u\n",
523 target_idx, num_targets - 1);
526 "index %u is out of range since there are no active targets\n",
531 for (
size_t i = 0; i < num_targets; i++) {
533 const std::string &label = target_sp->GetLabel();
534 if (!label.empty() && label == target_identifier) {
544 bool show_stopped_process_status =
false;
554 "'target select' takes a single argument: a target index\n");
559#pragma mark CommandObjectTargetDelete
565 "Delete one or more targets by target index.",
571 "Perform extra cleanup to minimize memory consumption after "
572 "deleting the target. "
573 "By default, LLDB will keep in memory any modules previously "
574 "loaded by the target as well "
575 "as all of its debug info. Specifying --clean will unload all of "
576 "these shared modules and "
577 "cause them to be reparsed again the next time the target is run",
592 std::vector<TargetSP> delete_target_list;
599 }
else if (argc > 0) {
602 if (num_targets == 0) {
607 for (
auto &entry : args.
entries()) {
609 if (entry.ref().getAsInteger(0, target_idx)) {
614 if (target_idx < num_targets) {
617 delete_target_list.push_back(target_sp);
623 "target indexes are 0 - %u\n",
624 target_idx, num_targets - 1);
627 "target index %u is out of range, the only valid index is 0\n",
638 delete_target_list.push_back(target_sp);
641 const size_t num_targets_to_delete = delete_target_list.size();
642 for (
size_t idx = 0; idx < num_targets_to_delete; ++idx) {
643 target_sp = delete_target_list[idx];
645 target_sp->Destroy();
650 const bool mandatory =
true;
654 (uint32_t)num_targets_to_delete);
667 interpreter,
"target show-launch-environment",
668 "Shows the environment being passed to the process when launched, "
669 "taking info account 3 settings: target.env-vars, "
670 "target.inherit-env and target.unset-env-vars.",
671 nullptr, eCommandRequiresTarget) {}
680 std::vector<Environment::value_type *> env_vector;
681 env_vector.reserve(env.size());
683 env_vector.push_back(&KV);
684 std::sort(env_vector.begin(), env_vector.end(),
685 [](Environment::value_type *a, Environment::value_type *b) {
686 return a->first() < b->first();
690 for (
auto &KV : env_vector)
691 strm.
Format(
"{0}={1}\n", KV->first(), KV->second);
697#pragma mark CommandObjectTargetVariable
706 "Read global variables for the current target, "
707 "before or while running a process.",
708 nullptr, eCommandRequiresTarget),
713 "A basename or fullpath to a file that contains "
714 "global variables. This option can be "
715 "specified multiple times."),
719 "A basename or fullpath to a shared library to use in the search "
721 "variables. This option can be specified multiple times.") {
740 const char *root_name) {
743 if (!valobj_sp->GetTargetSP()->GetDisplayRuntimeSupportValues() &&
744 valobj_sp->IsRuntimeSupportValue())
747 switch (var_sp->GetScope()) {
778 bool show_fullpaths =
false;
779 bool show_module =
true;
780 if (var_sp->DumpDeclaration(&s, show_fullpaths, show_module))
790 if (llvm::Error
error = valobj_sp->Dump(s, options))
796 size_t old_size = variable_list.
GetSize();
801 return variable_list.
GetSize() - old_size;
812 if (variable_list.
Empty())
816 s.
Format(
"Global variables for {0} in {1}:\n",
819 s.
Printf(
"Global variables for %s\n",
820 sc.
module_sp->GetFileSpec().GetPath().c_str());
849 bool use_var_name =
false;
854 "error: invalid regular expression: '%s'\n", arg.c_str());
860 matches = variable_list.
GetSize();
863 arg.c_str(),
m_exe_ctx.GetBestExecutionContextScope(),
865 matches = variable_list.
GetSize();
873 for (uint32_t global_idx = 0; global_idx < matches; ++global_idx) {
880 m_exe_ctx.GetBestExecutionContextScope(), var_sp);
884 use_var_name ? var_sp->GetName().GetCString()
896 const size_t num_compile_units = compile_units.
GetSize();
897 const size_t num_shlibs = shlibs.
GetSize();
898 if (num_compile_units == 0 && num_shlibs == 0) {
899 bool success =
false;
906 const bool can_create =
true;
909 if (comp_unit_varlist_sp) {
910 size_t count = comp_unit_varlist_sp->GetSize();
923 "no global variables in current compile unit: {0}\n",
927 "no debug information for frame %u\n",
930 result.
AppendError(
"'target variable' takes one or more global "
931 "variable names as arguments\n");
936 if (num_shlibs > 0) {
937 for (
size_t shlib_idx = 0; shlib_idx < num_shlibs; ++shlib_idx) {
944 if (num_compile_units > 0) {
945 for (
size_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx)
946 module_sp->FindCompileUnits(
956 "target doesn't contain the specified shared library: %s\n",
957 module_file.
GetPath().c_str());
963 for (
size_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx)
970 const bool can_create =
true;
972 sc.comp_unit->GetVariableList(can_create));
973 if (comp_unit_varlist_sp)
976 }
else if (sc.module_sp) {
979 llvm::StringRef(
"."));
981 sc.module_sp->FindGlobalVariables(all_globals_regex,
UINT32_MAX,
1001#pragma mark CommandObjectTargetModulesSearchPathsAdd
1007 "Add new image search paths substitution pairs to "
1008 "the current target.",
1009 nullptr, eCommandRequiresTarget) {
1028 arg.push_back(old_prefix_arg);
1029 arg.push_back(new_prefix_arg);
1041 result.
AppendError(
"add requires an even number of arguments\n");
1043 for (
size_t i = 0; i < argc; i += 2) {
1047 if (from[0] && to[0]) {
1051 "target modules search path adding ImageSearchPath "
1052 "pair: '%s' -> '%s'",
1055 bool last_pair = ((argc - i) == 2);
1057 from, to, last_pair);
1061 result.
AppendError(
"<path-prefix> can't be empty\n");
1063 result.
AppendError(
"<new-path-prefix> can't be empty\n");
1070#pragma mark CommandObjectTargetModulesSearchPathsClear
1076 "Clear all current image search path substitution "
1077 "pairs from the current target.",
1078 "target modules search-paths clear",
1079 eCommandRequiresTarget) {}
1092#pragma mark CommandObjectTargetModulesSearchPathsInsert
1098 "Insert a new image search path substitution pair "
1099 "into the current target at the specified index.",
1100 nullptr, eCommandRequiresTarget) {
1112 arg1.push_back(index_arg);
1128 arg2.push_back(old_prefix_arg);
1129 arg2.push_back(new_prefix_arg);
1146 const size_t num = list.
GetSize();
1148 for (
size_t i = 0; i < num; ++i) {
1152 strm << old_path <<
" -> " << new_path;
1162 if (argc >= 3 && argc & 1) {
1163 uint32_t insert_idx;
1167 "<index> parameter is not an integer: '%s'.\n",
1176 for (uint32_t i = 0; i < argc; i += 2, ++insert_idx) {
1180 if (from[0] && to[0]) {
1181 bool last_pair = ((argc - i) == 2);
1187 result.
AppendError(
"<path-prefix> can't be empty\n");
1189 result.
AppendError(
"<new-path-prefix> can't be empty\n");
1194 result.
AppendError(
"insert requires at least three arguments\n");
1199#pragma mark CommandObjectTargetModulesSearchPathsList
1205 "List all current image search path substitution "
1206 "pairs in the current target.",
1207 "target modules search-paths list",
1208 eCommandRequiresTarget) {}
1220#pragma mark CommandObjectTargetModulesSearchPathsQuery
1226 interpreter,
"target modules search-paths query",
1227 "Transform a path using the first applicable image search path.",
1228 nullptr, eCommandRequiresTarget) {
1238 result.
AppendError(
"query requires one argument\n");
1255 bool full_triple, uint32_t width) {
1260 module->GetArchitecture().DumpTriple(arch_strm.AsRawOstream());
1263 std::string arch_str = std::string(arch_strm.
GetString());
1266 strm.
Printf(
"%-*s", width, arch_str.c_str());
1274 module->GetUUID().Dump(strm);
1283 uint32_t num_matches = 0;
1286 num_matches =
module->ResolveSymbolContextsForFileSpec(
1287 file_spec, 0, false, eSymbolContextCompUnit, sc_list);
1289 bool first_module =
true;
1294 strm <<
"Line table for " << sc.comp_unit->GetPrimaryFile() <<
" in `"
1295 <<
module->GetFileSpec().GetFilename() << "\n";
1296 LineTable *line_table = sc.comp_unit->GetLineTable();
1302 strm <<
"No line table";
1304 first_module =
false;
1312 if (file_spec_ptr) {
1314 std::string fullpath = file_spec_ptr->
GetPath();
1315 strm.
Printf(
"%-*s", width, fullpath.c_str());
1324 strm.
Printf(
"%-*s", width,
"");
1329 if (file_spec_ptr) {
1338 strm.
Printf(
"%-*s", width,
"");
1343 if (file_spec_ptr) {
1352 strm.
Printf(
"%-*s", width,
"");
1356 std::lock_guard<std::recursive_mutex> guard(module_list.
GetMutex());
1357 const size_t num_modules = module_list.
GetSize();
1358 if (num_modules == 0)
1361 size_t num_dumped = 0;
1362 strm.
Format(
"Dumping headers for {0} module(s).\n", num_modules);
1366 if (num_dumped++ > 0) {
1370 ObjectFile *objfile = module_sp->GetObjectFile();
1372 objfile->
Dump(&strm);
1374 strm.
Format(
"No object file for module: {0:F}\n",
1375 module_sp->GetFileSpec());
1390 sort_order, name_preference);
1396 SectionList *section_list =
module->GetSectionList();
1398 strm.
Printf(
"Sections for '%s' (%s):\n",
1411 symbol_file->Dump(strm);
1419 Module *module,
bool errors_only,
1420 bool load_all_debug_info) {
1424 if (symbol_file->GetSeparateDebugInfo(d, errors_only,
1425 load_all_debug_info)) {
1427 std::make_shared<StructuredData::Dictionary>(std::move(d)));
1440 "------------------ --- -----------------------------------------");
1449 strm.
Printf(
"0x%16.16" PRIx64
" ", dwo_id);
1451 strm.
Printf(
"0x???????????????? ");
1453 llvm::StringRef
error;
1455 strm <<
"E " <<
error;
1457 llvm::StringRef resolved_dwo_path;
1459 resolved_dwo_path)) {
1460 strm <<
" " << resolved_dwo_path;
1461 if (resolved_dwo_path.ends_with(
".dwp")) {
1462 llvm::StringRef dwo_name;
1464 strm <<
"(" << dwo_name <<
")";
1477 strm.
PutCString(
"------------------ --- ---------------------");
1484 uint32_t oso_mod_time;
1486 strm.
Printf(
"0x%16.16" PRIx32
" ", oso_mod_time);
1488 llvm::StringRef
error;
1490 strm <<
"E " <<
error;
1492 llvm::StringRef oso_path;
1494 strm <<
" " << oso_path;
1503 bool verbose,
bool all_ranges,
Stream &strm,
1504 std::optional<Stream::HighlightSettings> settings = std::nullopt) {
1506 strm.
Indent(
" Address: ");
1511 strm.
Indent(
" Summary: ");
1527 Module *module, uint32_t resolve_mask,
1529 bool verbose,
bool all_ranges) {
1538 else if (so_addr.
GetModule().get() != module)
1547 DumpAddress(exe_scope, so_addr, verbose, all_ranges, strm);
1556 const char *name,
bool name_is_regex,
1557 bool verbose,
bool all_ranges) {
1561 Symtab *symtab =
module->GetSymtab();
1567 std::vector<uint32_t> match_indexes;
1569 uint32_t num_matches = 0;
1570 if (name_is_regex) {
1579 if (num_matches > 0) {
1581 strm.
Printf(
"%u symbols match %s'%s' in ", num_matches,
1582 name_is_regex ?
"the regular expression " :
"", name);
1589 for (uint32_t i = 0; i < num_matches; ++i) {
1596 use_color && name_is_regex
1597 ? std::optional<Stream::HighlightSettings>{settings}
1605 use_color && name_is_regex
1606 ? std::optional<Stream::HighlightSettings>{settings}
1627 std::optional<Stream::HighlightSettings> settings = std::nullopt) {
1629 bool first_module =
true;
1635 if (sc.line_entry.IsValid())
1636 addr = sc.line_entry.range.GetBaseAddress();
1637 else if (sc.block && sc.block->GetContainingInlinedBlock())
1638 sc.block->GetContainingInlinedBlock()->GetStartAddress(addr);
1640 addr = sc.GetFunctionOrSymbolAddress();
1642 DumpAddress(exe_scope, addr, verbose, all_ranges, strm, settings);
1643 first_module =
false;
1650 const char *name,
bool name_is_regex,
1652 bool verbose,
bool all_ranges) {
1653 if (module && name && name[0]) {
1655 size_t num_matches = 0;
1656 if (name_is_regex) {
1658 module->FindFunctions(function_name_regex, options, sc_list);
1661 module->FindFunctions(function_name, CompilerDeclContext(),
1662 eFunctionNameTypeAuto, options, sc_list);
1664 num_matches = sc_list.
GetSize();
1667 strm.
Printf(
"%" PRIu64
" match%s found in ", (uint64_t)num_matches,
1668 num_matches > 1 ?
"es" :
"");
1673 strm, sc_list, verbose, all_ranges);
1682 Module *module,
const char *name_cstr,
1683 bool name_is_regex) {
1684 if (module && name_cstr && name_cstr[0]) {
1687 module->FindTypes(query, results);
1692 sc.
module_sp =
module->shared_from_this();
1696 if (type_list.
Empty())
1699 const uint64_t num_matches = type_list.
GetSize();
1702 strm.
Printf(
"%" PRIu64
" match%s found in ", num_matches,
1703 num_matches > 1 ?
"es" :
"");
1711 type_sp->GetFullCompilerType();
1714 TypeSP typedef_type_sp(type_sp);
1715 TypeSP typedefed_type_sp(typedef_type_sp->GetTypedefType());
1716 while (typedefed_type_sp) {
1718 strm.
Printf(
" typedef '%s': ",
1719 typedef_type_sp->GetName().GetCString());
1720 typedefed_type_sp->GetFullCompilerType();
1723 typedef_type_sp = typedefed_type_sp;
1724 typedefed_type_sp = typedef_type_sp->GetTypedefType();
1735 const char *name_cstr,
bool name_is_regex) {
1738 module.FindTypes(query, results);
1741 sc.
module_sp =
module.shared_from_this();
1743 if (type_list.
Empty())
1755 type_sp->GetFullCompilerType();
1758 TypeSP typedef_type_sp(type_sp);
1759 TypeSP typedefed_type_sp(typedef_type_sp->GetTypedefType());
1760 while (typedefed_type_sp) {
1762 strm.
Printf(
" typedef '%s': ",
1763 typedef_type_sp->GetName().GetCString());
1764 typedefed_type_sp->GetFullCompilerType();
1767 typedef_type_sp = typedefed_type_sp;
1768 typedefed_type_sp = typedef_type_sp->GetTypedefType();
1778 uint32_t line,
bool check_inlines,
1779 bool verbose,
bool all_ranges) {
1780 if (module && file_spec) {
1782 const uint32_t num_matches =
module->ResolveSymbolContextsForFileSpec(
1783 file_spec, line, check_inlines, eSymbolContextEverything, sc_list);
1784 if (num_matches > 0) {
1786 strm.
Printf(
"%u match%s found in ", num_matches,
1787 num_matches > 1 ?
"es" :
"");
1790 strm.
Printf(
":%u", line);
1796 strm, sc_list, verbose, all_ranges);
1805 bool check_global_list) {
1806 FileSpec module_file_spec(module_name);
1809 const size_t initial_size = module_list.
GetSize();
1811 if (check_global_list) {
1813 std::lock_guard<std::recursive_mutex> guard(
1817 for (
size_t image_idx = 0; image_idx < num_modules; ++image_idx) {
1822 module_sp =
module->shared_from_this();
1830 const size_t num_matches = module_list.
GetSize();
1834 if (num_matches == 0) {
1843 return module_list.
GetSize() - initial_size;
1846#pragma mark CommandObjectTargetModulesModuleAutoComplete
1873#pragma mark CommandObjectTargetModulesSourceFileAutoComplete
1883 const char *syntax, uint32_t flags)
1898#pragma mark CommandObjectTargetModulesDumpObjfile
1905 interpreter,
"target modules dump objfile",
1906 "Dump the object file headers from one or more target modules.",
1907 nullptr, eCommandRequiresTarget) {}
1919 size_t num_dumped = 0;
1924 if (num_dumped == 0) {
1925 result.
AppendError(
"the target has no associated executable images");
1930 const char *arg_cstr;
1931 for (
int arg_idx = 0;
1934 size_t num_matched =
1936 if (num_matched == 0) {
1938 "Unable to find an image that matches '%s'.\n", arg_cstr);
1946 if (num_dumped > 0) {
1949 result.
AppendError(
"no matching executable images found");
1954#define LLDB_OPTIONS_target_modules_dump_symtab
1955#include "CommandOptions.inc"
1962 interpreter,
"target modules dump symtab",
1963 "Dump the symbol table from one or more target modules.", nullptr,
1964 eCommandRequiresTarget) {}
1981 switch (short_option) {
1994 llvm_unreachable(
"Unimplemented option");
2005 return llvm::ArrayRef(g_target_modules_dump_symtab_options);
2015 uint32_t num_dumped = 0;
2027 std::lock_guard<std::recursive_mutex> guard(module_list.
GetMutex());
2028 const size_t num_modules = module_list.
GetSize();
2029 if (num_modules > 0) {
2031 "Dumping symbol table for {0} modules.\n", num_modules);
2033 if (num_dumped > 0) {
2038 "Interrupted in dump all symtabs with {0} "
2039 "of {1} dumped.", num_dumped, num_modules))
2044 module_sp.get(),
m_options.m_sort_order,
2048 result.
AppendError(
"the target has no associated executable images");
2053 const char *arg_cstr;
2054 for (
int arg_idx = 0;
2058 const size_t num_matches =
2060 if (num_matches > 0) {
2063 if (num_dumped > 0) {
2068 "Interrupted in dump symtab list with {0} of {1} dumped.",
2069 num_dumped, num_matches))
2074 module_sp.get(),
m_options.m_sort_order,
2080 "Unable to find an image that matches '%s'.\n", arg_cstr);
2087 result.
AppendError(
"no matching executable images found");
2094#pragma mark CommandObjectTargetModulesDumpSections
2103 interpreter,
"target modules dump sections",
2104 "Dump the sections from one or more target modules.",
2106 nullptr, eCommandRequiresTarget) {}
2113 uint32_t num_dumped = 0;
2122 if (num_modules == 0) {
2123 result.
AppendError(
"the target has no associated executable images");
2129 for (
size_t image_idx = 0; image_idx < num_modules; ++image_idx) {
2131 "Interrupted in dump all sections with {0} of {1} dumped",
2132 image_idx, num_modules))
2142 const char *arg_cstr;
2143 for (
int arg_idx = 0;
2147 const size_t num_matches =
2149 if (num_matches > 0) {
2150 for (
size_t i = 0; i < num_matches; ++i) {
2152 "Interrupted in dump section list with {0} of {1} dumped.",
2165 std::lock_guard<std::recursive_mutex> guard(
2169 "Unable to find an image that matches '%s'.\n", arg_cstr);
2177 result.
AppendError(
"no matching executable images found");
2186 interpreter,
"target modules dump pcm-info",
2187 "Dump information about the given clang module (pcm).") {
2206 result.
AppendError(
"file must have a .pcm extension");
2215 const char *clang_args[] = {
"clang", pcm_path};
2216 clang::CompilerInstance compiler(clang::createInvocation(clang_args));
2217 compiler.setVirtualFileSystem(
2219 compiler.createDiagnostics();
2223 std::shared_ptr<llvm::raw_ostream> Out(
2225 clang::DumpModuleInfoAction dump_module_info(Out);
2227 compiler.getPCHContainerOperations()->registerReader(
2228 std::make_unique<clang::ObjectFilePCHContainerReader>());
2230 if (compiler.ExecuteAction(dump_module_info))
2235#pragma mark CommandObjectTargetModulesDumpClangAST
2244 interpreter,
"target modules dump ast",
2245 "Dump the clang ast for a given module's symbol file.",
2246 "target modules dump ast [--filter <name>] [<file1> ...]",
2247 eCommandRequiresTarget),
2249 "Dump only the decls whose names contain the specified filter "
2268 const size_t num_modules = module_list.
GetSize();
2269 if (num_modules == 0) {
2270 result.
AppendError(
"the target has no associated executable images");
2274 llvm::StringRef filter =
m_filter.GetOptionValue().GetCurrentValueAsRef();
2283 if (
SymbolFile *sf = module_sp->GetSymbolFile())
2294 const size_t num_matches =
2296 if (num_matches == 0) {
2298 std::lock_guard<std::recursive_mutex> guard(
2302 "Unable to find an image that matches '%s'.\n", arg.c_str());
2306 for (
size_t i = 0; i < num_matches; ++i) {
2308 "Interrupted in dump clang ast list with {0} of {1} dumped.",
2322#pragma mark CommandObjectTargetModulesDumpSymfile
2331 interpreter,
"target modules dump symfile",
2332 "Dump the debug symbol file for one or more target modules.",
2334 nullptr, eCommandRequiresTarget) {}
2341 uint32_t num_dumped = 0;
2350 std::lock_guard<std::recursive_mutex> guard(target_modules.
GetMutex());
2351 const size_t num_modules = target_modules.
GetSize();
2352 if (num_modules == 0) {
2353 result.
AppendError(
"the target has no associated executable images");
2357 "Dumping debug symbols for {0} modules.\n", num_modules);
2360 "debug symbols with {0} of {1} modules dumped",
2361 num_dumped, num_modules))
2369 const char *arg_cstr;
2370 for (
int arg_idx = 0;
2374 const size_t num_matches =
2376 if (num_matches > 0) {
2377 for (
size_t i = 0; i < num_matches; ++i) {
2379 "of {1} requested modules",
2390 "Unable to find an image that matches '%s'.\n", arg_cstr);
2397 result.
AppendError(
"no matching executable images found");
2402#pragma mark CommandObjectTargetModulesDumpLineTable
2403#define LLDB_OPTIONS_target_modules_dump
2404#include "CommandOptions.inc"
2413 interpreter,
"target modules dump line-table",
2414 "Dump the line table for one or more compilation units.", nullptr,
2415 eCommandRequiresTarget) {}
2424 uint32_t total_num_dumped = 0;
2431 result.
AppendError(
"file option must be specified");
2435 const char *arg_cstr;
2436 for (
int arg_idx = 0;
2442 std::lock_guard<std::recursive_mutex> guard(target_modules.
GetMutex());
2443 size_t num_modules = target_modules.
GetSize();
2444 if (num_modules > 0) {
2445 uint32_t num_dumped = 0;
2448 "Interrupted in dump all line tables with "
2449 "{0} of {1} dumped", num_dumped,
2460 if (num_dumped == 0)
2462 "No source filenames matched '%s'.\n", arg_cstr);
2464 total_num_dumped += num_dumped;
2469 if (total_num_dumped > 0)
2472 result.
AppendError(
"no source filenames matched any command arguments");
2482 assert(option_idx == 0 &&
"We only have one option.");
2493 return llvm::ArrayRef(g_target_modules_dump_options);
2502#pragma mark CommandObjectTargetModulesDumpSeparateDebugInfoFiles
2503#define LLDB_OPTIONS_target_modules_dump_separate_debug_info
2504#include "CommandOptions.inc"
2514 interpreter,
"target modules dump separate-debug-info",
2515 "List the separate debug info symbol files for one or more target "
2517 nullptr, eCommandRequiresTarget) {}
2534 switch (short_option) {
2540 m_json.SetCurrentValue(
true);
2541 m_json.SetOptionWasSet();
2548 llvm_unreachable(
"Unimplemented option");
2560 return llvm::ArrayRef(g_target_modules_dump_separate_debug_info_options);
2571 uint32_t num_dumped = 0;
2581 std::lock_guard<std::recursive_mutex> guard(target_modules.
GetMutex());
2582 const size_t num_modules = target_modules.
GetSize();
2583 if (num_modules == 0) {
2584 result.
AppendError(
"the target has no associated executable images");
2590 "Interrupted in dumping all "
2591 "separate debug info with {0} of {1} modules dumped",
2592 num_dumped, num_modules))
2603 const char *arg_cstr;
2604 for (
int arg_idx = 0;
2608 const size_t num_matches =
2610 if (num_matches > 0) {
2611 for (
size_t i = 0; i < num_matches; ++i) {
2613 "Interrupted dumping {0} "
2614 "of {1} requested modules",
2625 "Unable to find an image that matches '%s'.\n", arg_cstr);
2629 if (num_dumped > 0) {
2634 separate_debug_info_lists_by_module.
Dump(strm,
2638 separate_debug_info_lists_by_module.
ForEach(
2648 if (!separate_debug_info_list) {
2652 llvm::StringRef type;
2653 llvm::StringRef symfile;
2660 "separate-debug-info-files", files))) {
2664 strm <<
"Symbol file: " << symfile;
2666 strm <<
"Type: \"" << type <<
"\"";
2668 if (type ==
"dwo") {
2670 }
else if (type ==
"oso") {
2674 "Found unsupported debug info type '%s'.\n",
2675 type.str().c_str());
2682 result.
AppendError(
"no matching executable images found");
2689#pragma mark CommandObjectTargetModulesDump
2698 interpreter,
"target modules dump",
2699 "Commands for dumping information about one or more target "
2701 "target modules dump "
2702 "[objfile|symtab|sections|ast|symfile|line-table|pcm-info|separate-"
2704 "[<file1> <file2> ...]") {
2740 "Add a new module to the current target's modules.",
2741 "target modules add [<module>]",
2742 eCommandRequiresTarget),
2745 "Fullpath to a stand alone debug "
2746 "symbols file for when debug symbols "
2747 "are not in the executable.") {
2791 "Unable to create the executable or symbol file with "
2792 "UUID %s with path %s and symbol file %s",
2797 "Unable to create the executable or symbol file with "
2798 "UUID %s with path %s",
2804 "or symbol file with UUID %s",
2813 "Unable to locate the executable or symbol file with UUID %s",
2820 "one or more executable image paths must be specified");
2824 for (
auto &entry : args.
entries()) {
2825 if (entry.ref().empty())
2843 const char *error_cstr =
error.AsCString();
2855 std::string resolved_path = file_spec.
GetPath();
2856 if (resolved_path != entry.ref()) {
2858 "invalid module path '%s' with resolved path '%s'\n",
2859 entry.ref().str().c_str(), resolved_path.c_str());
2882 interpreter,
"target modules load",
2883 "Set the load addresses for one or more sections in a target "
2885 "target modules load [--file <module> --uuid <uuid>] <sect-name> "
2886 "<address> [<sect-name> <address> ....]",
2887 eCommandRequiresTarget),
2889 "Fullpath or basename for module to load.",
""),
2891 "Write file contents to the memory.", false, true),
2893 "Set PC to the entry point."
2894 " Only applicable with '--load' option.",
2897 "Set the load address for all sections to be the "
2898 "virtual address in the file plus the offset.",
2916 const bool load =
m_load_option.GetOptionValue().GetCurrentValue();
2917 const bool set_pc =
m_pc_option.GetOptionValue().GetCurrentValue();
2921 bool search_using_module_spec =
false;
2928 if (module_list.
GetSize() == 1) {
2929 search_using_module_spec =
true;
2937 search_using_module_spec =
true;
2938 const char *arg_cstr =
m_file_option.GetOptionValue().GetCurrentValue();
2939 const bool use_global_module_list =
true;
2942 &target, arg_cstr, module_list, use_global_module_list);
2943 if (num_matches == 1) {
2946 }
else if (num_matches > 1) {
2947 search_using_module_spec =
false;
2949 "more than 1 module matched by name '%s'\n", arg_cstr);
2951 search_using_module_spec =
false;
2958 search_using_module_spec =
true;
2963 if (search_using_module_spec) {
2966 const size_t num_matches = matching_modules.
GetSize();
2969 if (num_matches == 1) {
2972 ObjectFile *objfile =
module->GetObjectFile();
2974 SectionList *section_list =
module->GetSectionList();
2976 bool changed =
false;
2981 const bool slide_is_offset =
true;
2982 module->SetLoadAddress(target, slide, slide_is_offset,
2985 result.
AppendError(
"one or more section name + load "
2986 "address pair must be specified");
2991 result.
AppendError(
"The \"--slide <offset>\" option can't "
2992 "be used in conjunction with setting "
2993 "section load addresses.\n");
2997 for (
size_t i = 0; i < argc; i += 2) {
3000 if (sect_name && load_addr_cstr) {
3003 if (llvm::to_integer(load_addr_cstr, load_addr)) {
3007 if (section_sp->IsThreadSpecific()) {
3009 "thread specific sections are not yet "
3010 "supported (section '%s')\n",
3018 "section '%s' loaded at 0x%" PRIx64
"\n",
3019 sect_name, load_addr);
3023 "matches the section "
3030 "invalid load address string '%s'\n", load_addr_cstr);
3035 result.
AppendError(
"section names must be followed by "
3036 "a load address.\n");
3038 result.
AppendError(
"one or more section name + load "
3039 "address pair must be specified.\n");
3058 if (set_pc && !file_entry.
IsValid()) {
3059 result.
AppendError(
"No entry address in object file");
3062 std::vector<ObjectFile::LoadableData> loadables(
3064 if (loadables.size() == 0) {
3068 Status error = process->WriteObjectFile(std::move(loadables));
3074 ThreadList &thread_list = process->GetThreadList();
3078 if (!reg_context->SetPC(file_entry_addr)) {
3086 module->GetFileSpec().GetPath(path, sizeof(path));
3091 module->GetFileSpec().GetPath(path, sizeof(path));
3097 if (module_spec_file) {
3098 module_spec_file->
GetPath(path,
sizeof(path));
3104 std::string uuid_str;
3113 if (num_matches > 1) {
3115 "multiple modules match%s%s%s%s:\n", path[0] ?
" file=" :
"",
3116 path, !uuid_str.empty() ?
" uuid=" :
"", uuid_str.c_str());
3117 for (
size_t i = 0; i < num_matches; ++i) {
3125 "no modules were found that match%s%s%s%s.\n",
3126 path[0] ?
" file=" :
"", path, !uuid_str.empty() ?
" uuid=" :
"",
3131 result.
AppendError(
"either the \"--file <module>\" or the \"--uuid "
3132 "<uuid>\" option must be specified.\n");
3144#pragma mark CommandObjectTargetModulesList
3146#define LLDB_OPTIONS_target_modules_list
3147#include "CommandOptions.inc"
3162 if (short_option ==
'g') {
3164 }
else if (short_option ==
'a') {
3168 unsigned long width = 0;
3169 option_arg.getAsInteger(0, width);
3182 return llvm::ArrayRef(g_target_modules_list_options);
3194 interpreter,
"target modules list",
3195 "List current executable and dependent shared library images.") {
3206 const bool use_global_module_list =
m_options.m_use_global_module_list;
3226 "Couldn't find module matching address: 0x%" PRIx64
".",
3231 "Couldn't find module containing address: 0x%" PRIx64
".",
3237 size_t num_modules = 0;
3243 std::unique_lock<std::recursive_mutex> guard(
3249 if (use_global_module_list) {
3259 &target, arg.c_str(), module_list, use_global_module_list);
3260 if (num_matches == 0) {
3269 module_list_ptr = &module_list;
3272 std::unique_lock<std::recursive_mutex> lock;
3273 if (module_list_ptr !=
nullptr) {
3275 std::unique_lock<std::recursive_mutex>(module_list_ptr->
GetMutex());
3277 num_modules = module_list_ptr->
GetSize();
3280 if (num_modules > 0) {
3281 for (uint32_t image_idx = 0; image_idx < num_modules; ++image_idx) {
3284 if (module_list_ptr) {
3286 module = module_sp.get();
3288 module = Module::GetAllocatedModuleAtIndex(image_idx);
3289 module_sp =
module->shared_from_this();
3292 const size_t indent = strm.
Printf(
"[%3u] ", image_idx);
3298 if (use_global_module_list)
3300 "the global module list has no matching modules");
3302 result.
AppendError(
"the target has no matching modules");
3304 if (use_global_module_list)
3305 result.
AppendError(
"the global module list is empty");
3308 "the target has no associated executable images");
3315 if (module ==
nullptr) {
3320 bool dump_object_name =
false;
3322 m_options.m_format_array.push_back(std::make_pair(
'u', 0));
3323 m_options.m_format_array.push_back(std::make_pair(
'h', 0));
3324 m_options.m_format_array.push_back(std::make_pair(
'f', 0));
3325 m_options.m_format_array.push_back(std::make_pair(
'S', 0));
3327 const size_t num_entries =
m_options.m_format_array.size();
3328 bool print_space =
false;
3329 for (
size_t i = 0; i < num_entries; ++i) {
3333 const char format_char =
m_options.m_format_array[i].first;
3334 uint32_t width =
m_options.m_format_array[i].second;
3335 switch (format_char) {
3346 dump_object_name =
true;
3355 dump_object_name =
true;
3362 uint32_t addr_nibble_width =
3365 ObjectFile *objfile =
module->GetObjectFile();
3372 base_addr.
Dump(&strm, &target,
3376 if (format_char ==
'o') {
3378 strm.
Printf(
"0x%*.*" PRIx64, addr_nibble_width,
3383 strm.
Printf(
"0x%*.*" PRIx64, addr_nibble_width,
3384 addr_nibble_width, load_addr);
3395 strm.
Printf(
"%*s", addr_nibble_width + 2,
"");
3400 size_t ref_count = 0;
3401 char in_shared_cache =
'Y';
3403 ModuleSP module_sp(module->shared_from_this());
3405 in_shared_cache =
'N';
3408 ref_count = module_sp.use_count() - 1;
3411 strm.
Printf(
"{%c %*" PRIu64
"}", in_shared_cache, width, (uint64_t)ref_count);
3413 strm.
Printf(
"{%c %" PRIu64
"}", in_shared_cache, (uint64_t)ref_count);
3420 symbol_file->GetObjectFile()->GetFileSpec();
3421 if (format_char ==
'S') {
3423 if (!symfile_spec || symfile_spec == module->
GetFileSpec()) {
3424 print_space =
false;
3428 strm.
Printf(
"\n%*s", indent,
"");
3431 dump_object_name =
true;
3434 strm.
Printf(
"%.*s", width,
"<NONE>");
3439 llvm::AlignStyle::Left, width));
3443 strm.
Printf(
"%p",
static_cast<void *
>(module));
3454 if (dump_object_name) {
3455 const char *object_name =
module->GetObjectName().GetCString();
3457 strm.
Printf(
"(%s)", object_name);
3465#pragma mark CommandObjectTargetModulesShowUnwind
3468#define LLDB_OPTIONS_target_modules_show_unwind
3469#include "CommandOptions.inc"
3494 switch (short_option) {
3496 m_str = std::string(option_arg);
3502 "invalid address string '%s'", option_arg.str().c_str());
3507 m_str = std::string(option_arg);
3512 bool value, success;
3518 "invalid boolean value '%s' passed for -c option", option_arg);
3523 llvm_unreachable(
"Unimplemented option");
3537 return llvm::ArrayRef(g_target_modules_show_unwind_options);
3551 interpreter,
"target modules show-unwind",
3552 "Show synthesized unwind instructions for a function.", nullptr,
3553 eCommandRequiresTarget | eCommandRequiresProcess |
3554 eCommandProcessMustBeLaunched | eCommandProcessMustBePaused) {}
3566 abi = process->
GetABI().get();
3568 if (process ==
nullptr) {
3570 "You must have a process running to use this command.");
3576 result.
AppendError(
"the process must be paused to use this command");
3582 result.
AppendError(
"the process must be paused to use this command");
3594 function_options, sc_list);
3600 module_sp->ResolveSymbolContextForAddress(addr,
3601 eSymbolContextEverything, sc);
3608 "address-expression or function name option must be specified.");
3619 if (sc.symbol ==
nullptr && sc.function ==
nullptr)
3621 if (!sc.module_sp || sc.module_sp->GetObjectFile() ==
nullptr)
3623 Address addr = sc.GetFunctionOrSymbolAddress();
3633 UnwindTable &uw_table = sc.module_sp->GetUnwindTable();
3639 if (!func_unwinders_sp)
3643 "UNWIND PLANS for %s`%s (start addr 0x%" PRIx64
")\n",
3644 sc.module_sp->GetPlatformFileSpec().GetFilename().AsCString(),
3650 for (
size_t i = 0; i < count; i++) {
3652 if (strcmp(funcname.
GetCString(), trap_func_name) == 0)
3655 "treated as a trap handler function via user setting.\n");
3659 const std::vector<ConstString> trap_handler_names(
3660 platform_sp->GetTrapHandlerSymbolNames());
3661 for (
ConstString trap_name : trap_handler_names) {
3662 if (trap_name == funcname) {
3665 "name is listed by the platform as a trap handler.\n");
3672 if (std::shared_ptr<const UnwindPlan> plan_sp =
3673 func_unwinders_sp->GetUnwindPlanAtNonCallSite(*target, *thread)) {
3675 "Asynchronous (not restricted to call-sites) UnwindPlan is '%s'\n",
3676 plan_sp->GetSourceName().AsCString());
3678 if (std::shared_ptr<const UnwindPlan> plan_sp =
3679 func_unwinders_sp->GetUnwindPlanAtCallSite(*target, *thread)) {
3681 "Synchronous (restricted to call-sites) UnwindPlan is '%s'\n",
3682 plan_sp->GetSourceName().AsCString());
3684 if (std::shared_ptr<const UnwindPlan> plan_sp =
3685 func_unwinders_sp->GetUnwindPlanFastUnwind(*target, *thread)) {
3687 plan_sp->GetSourceName().AsCString());
3692 if (std::shared_ptr<const UnwindPlan> plan_sp =
3693 func_unwinders_sp->GetAssemblyUnwindPlan(*target, *thread)) {
3695 "Assembly language inspection UnwindPlan:\n");
3701 if (std::shared_ptr<const UnwindPlan> plan_sp =
3702 func_unwinders_sp->GetObjectFileUnwindPlan(*target)) {
3709 if (std::shared_ptr<const UnwindPlan> plan_sp =
3710 func_unwinders_sp->GetObjectFileAugmentedUnwindPlan(*target,
3718 if (std::shared_ptr<const UnwindPlan> plan_sp =
3719 func_unwinders_sp->GetEHFrameUnwindPlan(*target)) {
3726 if (std::shared_ptr<const UnwindPlan> plan_sp =
3727 func_unwinders_sp->GetEHFrameAugmentedUnwindPlan(*target,
3735 if (std::shared_ptr<const UnwindPlan> plan_sp =
3736 func_unwinders_sp->GetDebugFrameUnwindPlan(*target)) {
3743 if (std::shared_ptr<const UnwindPlan> plan_sp =
3744 func_unwinders_sp->GetDebugFrameAugmentedUnwindPlan(*target,
3752 if (std::shared_ptr<const UnwindPlan> plan_sp =
3753 func_unwinders_sp->GetArmUnwindUnwindPlan(*target)) {
3760 if (std::shared_ptr<const UnwindPlan> plan_sp =
3761 func_unwinders_sp->GetSymbolFileUnwindPlan(*thread)) {
3768 if (std::shared_ptr<const UnwindPlan> plan_sp =
3769 func_unwinders_sp->GetCompactUnwindUnwindPlan(*target)) {
3776 if (std::shared_ptr<const UnwindPlan> plan_sp =
3777 func_unwinders_sp->GetUnwindPlanFastUnwind(*target, *thread)) {
3786 if (
UnwindPlanSP plan_sp = abi_sp->CreateDefaultUnwindPlan()) {
3793 if (
UnwindPlanSP plan_sp = abi_sp->CreateFunctionEntryUnwindPlan()) {
3795 "Arch default at entry point UnwindPlan:\n");
3810#define LLDB_OPTIONS_target_modules_lookup
3811#include "CommandOptions.inc"
3838 switch (short_option) {
3846 if (option_arg.getAsInteger(0,
m_offset))
3848 "invalid offset string '%s'", option_arg.str().c_str());
3852 m_str = std::string(option_arg);
3857 m_file.SetFile(option_arg, FileSpec::Style::native);
3868 "invalid line number string '%s'", option_arg.str().c_str());
3875 m_str = std::string(option_arg);
3880 m_str = std::string(option_arg);
3885 m_str = std::string(option_arg);
3905 llvm_unreachable(
"Unimplemented option");
3930 "conjunction with --verbose.");
3936 return llvm::ArrayRef(g_target_modules_lookup_options);
3957 "Look up information within executable and "
3958 "dependent shared library images.",
3959 nullptr, eCommandRequiresTarget) {
3968 bool &syntax_error) {
3986 const SymbolContext &sym_ctx(frame->GetSymbolContext(eSymbolContextModule));
4016 eSymbolContextEverything |
4018 ?
static_cast<int>(eSymbolContextVariable)
4063 m_options.m_use_regex, function_options,
4088 syntax_error =
true;
4099 bool syntax_error =
false;
4101 uint32_t num_successful_lookups = 0;
4113 num_successful_lookups++;
4123 std::lock_guard<std::recursive_mutex> guard(target_modules.
GetMutex());
4124 if (target_modules.
GetSize() == 0) {
4125 result.
AppendError(
"the target has no associated executable images");
4133 num_successful_lookups++;
4138 const char *arg_cstr;
4143 const size_t num_matches =
4145 if (num_matches > 0) {
4146 for (
size_t j = 0; j < num_matches; ++j) {
4151 num_successful_lookups++;
4157 "Unable to find an image that matches '%s'.\n", arg_cstr);
4161 if (num_successful_lookups > 0)
4170#pragma mark CommandObjectMultiwordImageSearchPaths
4179 interpreter,
"target modules search-paths",
4180 "Commands for managing module search paths for a target.",
4181 "target modules search-paths <subcommand> [<subcommand-options>]") {
4203#pragma mark CommandObjectTargetModules
4212 "Commands for accessing information for one or "
4213 "more target modules.",
4214 "target modules <sub-command> ...") {
4248 interpreter,
"target symbols add",
4249 "Add a debug symbol file to one of the target's current modules by "
4250 "specifying a path to a debug symbols file or by using the options "
4251 "to specify a module.",
4252 "target symbols add <cmd-options> [<symfile>]",
4253 eCommandRequiresTarget),
4257 "Locate the debug symbols for the shared library specified by "
4261 "Locate the debug symbols for the currently selected frame.", false,
4264 "Locate the debug symbols for every frame in "
4265 "the current call stack.",
4288 if (!symbol_fspec) {
4290 "one or more executable image paths must be specified");
4295 symbol_fspec.
GetPath(symfile_path,
sizeof(symfile_path));
4309 0, 0, symfile_module_specs)) {
4315 symfile_module_spec)) {
4319 symfile_uuid_module_spec.
GetUUID() = symfile_module_spec.
GetUUID();
4325 if (matching_modules.
IsEmpty()) {
4328 const size_t num_symfile_module_specs = symfile_module_specs.
GetSize();
4330 i < num_symfile_module_specs && matching_modules.
IsEmpty(); ++i) {
4332 i, symfile_module_spec)) {
4336 symfile_uuid_module_spec.
GetUUID() =
4337 symfile_module_spec.
GetUUID();
4348 if (matching_modules.
IsEmpty())
4351 while (matching_modules.
IsEmpty()) {
4355 if (!filename_no_extension)
4367 if (matching_modules.
GetSize() > 1) {
4369 "use the --uuid option to resolve the "
4375 if (matching_modules.
GetSize() == 1) {
4381 module_sp->SetSymbolFileFileSpec(symbol_fspec);
4387 if (object_file && object_file->
GetFileSpec() == symbol_fspec) {
4389 const FileSpec &module_fs = module_sp->GetFileSpec();
4391 "symbol file '%s' has been added to '%s'\n", symfile_path,
4397 module_list.
Append(module_sp);
4404 module_sp->LoadScriptingResourceInTarget(target,
error,
4408 "unable to load scripting data for module %s - error "
4410 module_sp->GetFileSpec()
4411 .GetFileNameStrippingExtension()
4414 else if (feedback_stream.
GetSize())
4423 module_sp->SetSymbolFileFileSpec(
FileSpec());
4428 ss_symfile_uuid <<
" (";
4430 ss_symfile_uuid <<
')';
4433 "symbol file '%s'%s does not match any existing module%s\n",
4434 symfile_path, ss_symfile_uuid.
GetData(),
4435 !llvm::sys::fs::is_regular_file(symbol_fspec.
GetPath())
4436 ?
"\n please specify the full path to the symbol file"
4463 error_strm.
PutCString(
"unable to find debug symbols for UUID ");
4482 module_spec.
GetFileSpec() = module_sp->GetFileSpec();
4484 module_spec.
GetUUID() = module_sp->GetUUID();
4493 "unable to find debug symbols for the executable file ");
4508 "a process must exist in order to use the --frame option");
4527 if (!frame_module_sp) {
4533 module_spec.
GetUUID() = frame_module_sp->GetUUID();
4535 module_spec.
GetFileSpec() = frame_module_sp->GetPlatformFileSpec();
4538 result.
AppendError(
"unable to find debug symbols for the current frame");
4551 "a process must exist in order to use the --stack option");
4568 bool symbols_found =
false;
4569 uint32_t frame_count = thread->GetStackFrameCount();
4570 for (uint32_t i = 0; i < frame_count; ++i) {
4574 frame_sp->GetSymbolContext(eSymbolContextModule).module_sp);
4575 if (!frame_module_sp)
4579 module_spec.
GetUUID() = frame_module_sp->GetUUID();
4580 module_spec.
GetFileSpec() = frame_module_sp->GetPlatformFileSpec();
4583 bool current_frame_flush =
false;
4585 symbols_found =
true;
4586 flush |= current_frame_flush;
4589 if (!symbols_found) {
4591 "unable to find debug symbols in the current call stack");
4603 const bool uuid_option_set =
4605 const bool file_option_set =
m_file_option.GetOptionValue().OptionWasSet();
4606 const bool frame_option_set =
4608 const bool stack_option_set =
4613 if (uuid_option_set)
4615 else if (file_option_set)
4617 else if (frame_option_set)
4619 else if (stack_option_set)
4622 result.
AppendError(
"one or more symbol file paths must be specified, "
4623 "or options must be specified");
4625 if (uuid_option_set) {
4626 result.
AppendError(
"specify either one or more paths to symbol files "
4627 "or use the --uuid option without arguments");
4628 }
else if (frame_option_set) {
4629 result.
AppendError(
"specify either one or more paths to symbol files "
4630 "or use the --frame option without arguments");
4631 }
else if (file_option_set && argc > 1) {
4632 result.
AppendError(
"specify at most one symbol file path when "
4633 "--shlib option is set");
4637 for (
auto &entry : args.
entries()) {
4638 if (!entry.ref().empty()) {
4640 symbol_file_spec.
SetFile(entry.ref(), FileSpec::Style::native);
4642 if (file_option_set) {
4649 ->ResolveSymbolFile(*target, module_spec, symfile_spec)
4654 bool symfile_exists =
4657 if (symfile_exists) {
4661 std::string resolved_symfile_path =
4663 if (resolved_symfile_path != entry.ref()) {
4665 "invalid module path '%s' with resolved path '%s'\n",
4666 entry.c_str(), resolved_symfile_path.c_str());
4692#pragma mark CommandObjectTargetSymbols
4701 interpreter,
"target symbols",
4702 "Commands for adding and managing debug symbol files.",
4703 "target symbols <sub-command> ...") {
4717#pragma mark CommandObjectTargetStopHookAdd
4720#define LLDB_OPTIONS_target_stop_hook_add
4721#include "CommandOptions.inc"
4733 return llvm::ArrayRef(g_target_stop_hook_add_options);
4739 const int short_option =
4740 g_target_stop_hook_add_options[option_idx].short_option;
4742 switch (short_option) {
4749 if (option_arg.getAsInteger(0,
m_line_end)) {
4751 "invalid end line number: \"%s\"", option_arg.str().c_str());
4758 bool value, success;
4764 "invalid boolean value '%s' passed for -G option",
4765 option_arg.str().c_str());
4770 "invalid start line number: \"%s\"", option_arg.str().c_str());
4799 "invalid thread id string '%s'", option_arg.str().c_str());
4816 "invalid thread index string '%s'", option_arg.str().c_str());
4826 bool value, success;
4832 "invalid boolean value '%s' passed for -F option",
4833 option_arg.str().c_str());
4837 llvm_unreachable(
"Unimplemented option");
4872 eFunctionNameTypeAuto;
4890 "Add a hook to be executed when the target stops."
4891 "The hook can either be a list of commands or an "
4892 "appropriately defined Python class. You can also "
4893 "add filters so the hook only runs a certain stop "
4895 "target stop-hook add"),
4901Command Based stop-hooks:
4902-------------------------
4903 Stop hooks can run a list of lldb commands by providing one or more
4904 --one-liner options. The commands will get run in the order they are added.
4905 Or you can provide no commands, in which case you will enter a command editor
4906 where you can enter the commands to be run.
4908Python Based Stop Hooks:
4909------------------------
4910 Stop hooks can be implemented with a suitably defined Python class, whose name
4911 is passed in the --python-class option.
4913 When the stop hook is added, the class is initialized by calling:
4915 def __init__(self, target, extra_args, internal_dict):
4917 target: The target that the stop hook is being added to.
4918 extra_args: An SBStructuredData Dictionary filled with the -key -value
4919 option pairs passed to the command.
4920 dict: An implementation detail provided by lldb.
4922 Then when the stop-hook triggers, lldb will run the 'handle_stop' method.
4923 The method has the signature:
4925 def handle_stop(self, exe_ctx, stream):
4927 exe_ctx: An SBExecutionContext for the thread that has stopped.
4928 stream: An SBStream, anything written to this stream will be printed in the
4929 the stop message when the process stops.
4931 Return Value: The method returns "should_stop". If should_stop is false
4932 from all the stop hook executions on threads that stopped
4933 with a reason, then the process will continue. Note that this
4934 will happen only after all the stop hooks are run.
4938 Stop hooks can be set to always run, or to only run when the stopped thread
4939 matches the filter options passed on the command line. The available filter
4940 options include a shared library or a thread or queue specification,
4941 a line range in a source file, a function name or a class name.
4961 "Enter your stop hook command(s). Type 'DONE' to end.\n");
4967 std::string &line)
override {
4973 locked_stream.
Printf(
"error: stop hook #%" PRIu64
4974 " aborted, no commands.\n",
4980 Target::StopHookCommandLine *hook_ptr =
4981 static_cast<Target::StopHookCommandLine *
>(
m_stop_hook_sp.get());
4986 LockedStreamFile locked_stream = output_sp->Lock();
4987 locked_stream.
Printf(
"Stop hook #%" PRIu64
" added.\n",
4996 void DoExecute(Args &command, CommandReturnObject &result)
override {
5002 Target::StopHook::StopHookKind::CommandBased
5003 : Target::StopHook::StopHookKind::ScriptBased);
5006 std::unique_ptr<SymbolContextSpecifier> specifier_up;
5008 specifier_up = std::make_unique<SymbolContextSpecifier>(
5012 specifier_up->AddSpecification(
5018 specifier_up->AddSpecification(
5024 specifier_up->AddSpecification(
m_options.m_file_name.c_str(),
5029 specifier_up->AddLineSpecification(
5035 specifier_up->AddLineSpecification(
5039 if (!
m_options.m_function_name.empty()) {
5040 specifier_up->AddSpecification(
5047 new_hook_sp->SetSpecifier(specifier_up.release());
5050 new_hook_sp->SetRunAtInitialStop(
m_options.m_at_initial_stop);
5055 ThreadSpec *thread_spec =
new ThreadSpec();
5070 new_hook_sp->SetThreadSpecifier(thread_spec);
5080 new_hook_sp->GetID());
5083 Target::StopHookScripted *hook_ptr =
5084 static_cast<Target::StopHookScripted *
>(new_hook_sp.get());
5088 if (
error.Success())
5090 new_hook_sp->GetID());
5114#pragma mark CommandObjectTargetStopHookDelete
5122 "Delete a stop-hook.",
5123 "target stop-hook delete [<idx>]") {
5142 if (num_args == 0) {
5143 if (!
m_interpreter.Confirm(
"Delete all stop hooks?",
true)) {
5150 for (
size_t i = 0; i < num_args; i++) {
5168#pragma mark CommandObjectTargetStopHookEnableDisable
5175 bool enable,
const char *name,
5176 const char *help,
const char *syntax)
5198 if (num_args == 0) {
5201 for (
size_t i = 0; i < num_args; i++) {
5223#pragma mark CommandObjectTargetStopHookList
5231 "List all stop-hooks.",
"target stop-hook list") {}
5240 if (num_hooks == 0) {
5243 for (
size_t i = 0; i < num_hooks; i++) {
5255#pragma mark CommandObjectMultiwordTargetStopHooks
5263 interpreter,
"target stop-hook",
5264 "Commands for operating on debugger target stop-hooks.",
5265 "target stop-hook <subcommand> [<subcommand-options>]") {
5273 interpreter,
false,
"target stop-hook disable [<id>]",
5274 "Disable a stop-hook.",
"target stop-hook disable")));
5277 interpreter,
true,
"target stop-hook enable [<id>]",
5278 "Enable a stop-hook.",
"target stop-hook enable")));
5286#pragma mark CommandObjectTargetDumpTypesystem
5293 interpreter,
"target dump typesystem",
5294 "Dump the state of the target's internal type system. Intended to "
5295 "be used for debugging LLDB itself.",
5296 nullptr, eCommandRequiresTarget) {}
5312#pragma mark CommandObjectTargetDumpSectionLoadList
5319 interpreter,
"target dump section-load-list",
5320 "Dump the state of the target's internal section load list. "
5321 "Intended to be used for debugging LLDB itself.",
5322 nullptr, eCommandRequiresTarget) {}
5334#pragma mark CommandObjectTargetDump
5342 interpreter,
"target dump",
5343 "Commands for dumping information about the target.",
5344 "target dump [typesystem|section-load-list]") {
5356#pragma mark CommandObjectMultiwordTarget
5363 "Commands for operating on debugger targets.",
5364 "target <subcommand> [<subcommand-options>]") {
static bool GetSeparateDebugInfoList(StructuredData::Array &list, Module *module, bool errors_only, bool load_all_debug_info)
static uint32_t DumpTargetList(TargetList &target_list, bool show_stopped_process_status, Stream &strm)
static void DumpModuleUUID(Stream &strm, Module *module)
static void DumpModuleSections(CommandInterpreter &interpreter, Stream &strm, Module *module)
static void DumpModuleArchitecture(Stream &strm, Module *module, bool full_triple, uint32_t width)
static bool LookupAddressInModule(CommandInterpreter &interpreter, Stream &strm, Module *module, uint32_t resolve_mask, lldb::addr_t raw_addr, lldb::addr_t offset, bool verbose, bool all_ranges)
static void DumpTargetInfo(uint32_t target_idx, Target *target, const char *prefix_cstr, bool show_stopped_process_status, Stream &strm)
static void DumpDirectory(Stream &strm, const FileSpec *file_spec_ptr, uint32_t width)
static uint32_t LookupSymbolInModule(CommandInterpreter &interpreter, Stream &strm, Module *module, const char *name, bool name_is_regex, bool verbose, bool all_ranges)
static size_t LookupTypeInModule(Target *target, CommandInterpreter &interpreter, Stream &strm, Module *module, const char *name_cstr, bool name_is_regex)
static bool DumpModuleSymbolFile(Stream &strm, Module *module)
static void DumpFullpath(Stream &strm, const FileSpec *file_spec_ptr, uint32_t width)
static void DumpDwoFilesTable(Stream &strm, StructuredData::Array &dwo_listings)
static size_t LookupFunctionInModule(CommandInterpreter &interpreter, Stream &strm, Module *module, const char *name, bool name_is_regex, const ModuleFunctionSearchOptions &options, bool verbose, bool all_ranges)
static size_t LookupTypeHere(Target *target, CommandInterpreter &interpreter, Stream &strm, Module &module, const char *name_cstr, bool name_is_regex)
static uint32_t DumpCompileUnitLineTable(CommandInterpreter &interpreter, Stream &strm, Module *module, const FileSpec &file_spec, lldb::DescriptionLevel desc_level)
static void DumpBasename(Stream &strm, const FileSpec *file_spec_ptr, uint32_t width)
static size_t DumpModuleObjfileHeaders(Stream &strm, ModuleList &module_list)
static uint32_t LookupFileAndLineInModule(CommandInterpreter &interpreter, Stream &strm, Module *module, const FileSpec &file_spec, uint32_t line, bool check_inlines, bool verbose, bool all_ranges)
static void DumpSymbolContextList(ExecutionContextScope *exe_scope, Stream &strm, const SymbolContextList &sc_list, bool verbose, bool all_ranges, std::optional< Stream::HighlightSettings > settings=std::nullopt)
static void DumpOsoFilesTable(Stream &strm, StructuredData::Array &oso_listings)
static size_t FindModulesByName(Target *target, const char *module_name, ModuleList &module_list, bool check_global_list)
static void DumpModuleSymtab(CommandInterpreter &interpreter, Stream &strm, Module *module, SortOrder sort_order, Mangled::NamePreference name_preference)
static llvm::raw_ostream & error(Stream &strm)
#define INTERRUPT_REQUESTED(debugger,...)
This handy define will keep you from having to generate a report for the interruption by hand.
#define LLDB_LOGF(log,...)
#define LLDB_SCOPED_TIMERF(...)
~CommandObjectMultiwordTargetStopHooks() override=default
CommandObjectMultiwordTargetStopHooks(CommandInterpreter &interpreter)
OptionGroupString m_label
OptionGroupPlatform m_platform_options
~CommandObjectTargetCreate() override=default
Options * GetOptions() override
OptionGroupFile m_symbol_file
OptionGroupFile m_remote_file
OptionGroupOptions m_option_group
OptionGroupArchitecture m_arch_option
CommandObjectTargetCreate(CommandInterpreter &interpreter)
OptionGroupDependents m_add_dependents
OptionGroupFile m_core_file
void DoExecute(Args &command, CommandReturnObject &result) override
OptionGroupBoolean m_cleanup_option
OptionGroupOptions m_option_group
void DoExecute(Args &args, CommandReturnObject &result) override
CommandObjectTargetDelete(CommandInterpreter &interpreter)
OptionGroupBoolean m_all_option
~CommandObjectTargetDelete() override=default
Options * GetOptions() override
Dumps the SectionLoadList of the selected Target.
void DoExecute(Args &command, CommandReturnObject &result) override
~CommandObjectTargetDumpSectionLoadList() override=default
CommandObjectTargetDumpSectionLoadList(CommandInterpreter &interpreter)
Dumps the TypeSystem of the selected Target.
CommandObjectTargetDumpTypesystem(CommandInterpreter &interpreter)
~CommandObjectTargetDumpTypesystem() override=default
void DoExecute(Args &command, CommandReturnObject &result) override
Multi-word command for 'target dump'.
CommandObjectTargetDump(CommandInterpreter &interpreter)
~CommandObjectTargetDump() override=default
CommandObjectTargetList(CommandInterpreter &interpreter)
void DoExecute(Args &args, CommandReturnObject &result) override
~CommandObjectTargetList() override=default
OptionGroupOptions m_option_group
OptionGroupFile m_symbol_file
CommandObjectTargetModulesAdd(CommandInterpreter &interpreter)
void DoExecute(Args &args, CommandReturnObject &result) override
OptionGroupUUID m_uuid_option_group
~CommandObjectTargetModulesAdd() override=default
Options * GetOptions() override
CommandObjectTargetModulesDumpClangAST(CommandInterpreter &interpreter)
Options * GetOptions() override
void DoExecute(Args &command, CommandReturnObject &result) override
OptionGroupString m_filter
~CommandObjectTargetModulesDumpClangAST() override=default
OptionGroupOptions m_option_group
~CommandObjectTargetModulesDumpClangPCMInfo() override=default
CommandObjectTargetModulesDumpClangPCMInfo(CommandInterpreter &interpreter)
void DoExecute(Args &command, CommandReturnObject &result) 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.
void OptionParsingStarting(ExecutionContext *execution_context) override
~CommandObjectTargetModulesDumpLineTable() override=default
Options * GetOptions() override
void DoExecute(Args &command, CommandReturnObject &result) override
CommandObjectTargetModulesDumpLineTable(CommandInterpreter &interpreter)
void DoExecute(Args &command, CommandReturnObject &result) override
~CommandObjectTargetModulesDumpObjfile() override=default
CommandObjectTargetModulesDumpObjfile(CommandInterpreter &interpreter)
CommandObjectTargetModulesDumpSections(CommandInterpreter &interpreter)
~CommandObjectTargetModulesDumpSections() override=default
void DoExecute(Args &command, CommandReturnObject &result) override
void OptionParsingStarting(ExecutionContext *execution_context) override
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
~CommandOptions() override=default
OptionValueBoolean m_errors_only
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
Set the value of an option.
OptionValueBoolean m_json
OptionValueBoolean m_load_all_debug_info
~CommandObjectTargetModulesDumpSeparateDebugInfoFiles() override=default
CommandObjectTargetModulesDumpSeparateDebugInfoFiles(CommandInterpreter &interpreter)
void DoExecute(Args &command, CommandReturnObject &result) override
Options * GetOptions() override
CommandObjectTargetModulesDumpSymfile(CommandInterpreter &interpreter)
~CommandObjectTargetModulesDumpSymfile() override=default
void DoExecute(Args &command, CommandReturnObject &result) 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.
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
OptionValueBoolean m_prefer_mangled
Options * GetOptions() override
void DoExecute(Args &command, CommandReturnObject &result) override
CommandObjectTargetModulesDumpSymtab(CommandInterpreter &interpreter)
~CommandObjectTargetModulesDumpSymtab() override=default
~CommandObjectTargetModulesDump() override=default
CommandObjectTargetModulesDump(CommandInterpreter &interpreter)
CommandObjectTargetModulesImageSearchPaths(CommandInterpreter &interpreter)
~CommandObjectTargetModulesImageSearchPaths() override=default
bool m_use_global_module_list
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
void OptionParsingStarting(ExecutionContext *execution_context) override
FormatWidthCollection m_format_array
std::vector< std::pair< char, uint32_t > > FormatWidthCollection
~CommandOptions() override=default
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
Set the value of an option.
lldb::addr_t m_module_addr
CommandObjectTargetModulesList(CommandInterpreter &interpreter)
~CommandObjectTargetModulesList() override=default
void DoExecute(Args &command, CommandReturnObject &result) override
void PrintModule(Target &target, Module *module, int indent, Stream &strm)
Options * GetOptions() override
OptionGroupBoolean m_pc_option
OptionGroupUInt64 m_slide_option
OptionGroupBoolean m_load_option
void DoExecute(Args &args, CommandReturnObject &result) override
Options * GetOptions() override
OptionGroupUUID m_uuid_option_group
~CommandObjectTargetModulesLoad() override=default
OptionGroupOptions m_option_group
CommandObjectTargetModulesLoad(CommandInterpreter &interpreter)
OptionGroupString m_file_option
~CommandOptions() override=default
void OptionParsingStarting(ExecutionContext *execution_context) override
Status OptionParsingFinished(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
bool LookupInModule(CommandInterpreter &interpreter, Module *module, CommandReturnObject &result, bool &syntax_error)
Options * GetOptions() override
~CommandObjectTargetModulesLookup() override=default
@ eLookupTypeFunctionOrSymbol
void DoExecute(Args &command, CommandReturnObject &result) override
bool LookupHere(CommandInterpreter &interpreter, CommandReturnObject &result, bool &syntax_error)
CommandObjectTargetModulesLookup(CommandInterpreter &interpreter)
CommandObjectTargetModulesModuleAutoComplete(CommandInterpreter &interpreter, const char *name, const char *help, const char *syntax, uint32_t flags=0)
~CommandObjectTargetModulesModuleAutoComplete() override=default
void HandleArgumentCompletion(CompletionRequest &request, OptionElementVector &opt_element_vector) override
The default version handles argument definitions that have only one argument type,...
~CommandObjectTargetModulesSearchPathsAdd() override=default
void DoExecute(Args &command, CommandReturnObject &result) override
CommandObjectTargetModulesSearchPathsAdd(CommandInterpreter &interpreter)
void DoExecute(Args &command, CommandReturnObject &result) override
~CommandObjectTargetModulesSearchPathsClear() override=default
CommandObjectTargetModulesSearchPathsClear(CommandInterpreter &interpreter)
void HandleArgumentCompletion(CompletionRequest &request, OptionElementVector &opt_element_vector) override
The default version handles argument definitions that have only one argument type,...
~CommandObjectTargetModulesSearchPathsInsert() override=default
CommandObjectTargetModulesSearchPathsInsert(CommandInterpreter &interpreter)
void DoExecute(Args &command, CommandReturnObject &result) override
~CommandObjectTargetModulesSearchPathsList() override=default
CommandObjectTargetModulesSearchPathsList(CommandInterpreter &interpreter)
void DoExecute(Args &command, CommandReturnObject &result) override
~CommandObjectTargetModulesSearchPathsQuery() override=default
void DoExecute(Args &command, CommandReturnObject &result) override
CommandObjectTargetModulesSearchPathsQuery(CommandInterpreter &interpreter)
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
~CommandOptions() override=default
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
@ eLookupTypeFunctionOrSymbol
CommandObjectTargetModulesShowUnwind(CommandInterpreter &interpreter)
void DoExecute(Args &command, CommandReturnObject &result) override
Options * GetOptions() override
~CommandObjectTargetModulesShowUnwind() override=default
CommandObjectTargetModulesSourceFileAutoComplete(CommandInterpreter &interpreter, const char *name, const char *help, const char *syntax, uint32_t flags)
void HandleArgumentCompletion(CompletionRequest &request, OptionElementVector &opt_element_vector) override
The default version handles argument definitions that have only one argument type,...
~CommandObjectTargetModulesSourceFileAutoComplete() override=default
~CommandObjectTargetModules() override=default
const CommandObjectTargetModules & operator=(const CommandObjectTargetModules &)=delete
CommandObjectTargetModules(const CommandObjectTargetModules &)=delete
CommandObjectTargetModules(CommandInterpreter &interpreter)
~CommandObjectTargetSelect() override=default
void DoExecute(Args &args, CommandReturnObject &result) override
CommandObjectTargetSelect(CommandInterpreter &interpreter)
CommandObjectTargetShowLaunchEnvironment(CommandInterpreter &interpreter)
void DoExecute(Args &args, CommandReturnObject &result) override
~CommandObjectTargetShowLaunchEnvironment() override=default
uint32_t m_func_name_type_mask
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
std::string m_function_name
std::vector< std::string > m_one_liner
~CommandOptions() override=default
std::string m_thread_name
void OptionParsingStarting(ExecutionContext *execution_context) override
std::string m_module_name
OptionGroupOptions m_all_options
Target::StopHookSP m_stop_hook_sp
void IOHandlerActivated(IOHandler &io_handler, bool interactive) override
CommandObjectTargetStopHookAdd(CommandInterpreter &interpreter)
void IOHandlerInputComplete(IOHandler &io_handler, std::string &line) override
Called when a line or lines have been retrieved.
~CommandObjectTargetStopHookAdd() override=default
Options * GetOptions() override
OptionGroupPythonClassWithDict m_python_class_options
void DoExecute(Args &command, CommandReturnObject &result) override
void DoExecute(Args &command, CommandReturnObject &result) override
void HandleArgumentCompletion(CompletionRequest &request, OptionElementVector &opt_element_vector) override
The default version handles argument definitions that have only one argument type,...
CommandObjectTargetStopHookDelete(CommandInterpreter &interpreter)
~CommandObjectTargetStopHookDelete() override=default
~CommandObjectTargetStopHookEnableDisable() override=default
void HandleArgumentCompletion(CompletionRequest &request, OptionElementVector &opt_element_vector) override
The default version handles argument definitions that have only one argument type,...
void DoExecute(Args &command, CommandReturnObject &result) override
CommandObjectTargetStopHookEnableDisable(CommandInterpreter &interpreter, bool enable, const char *name, const char *help, const char *syntax)
void DoExecute(Args &command, CommandReturnObject &result) override
~CommandObjectTargetStopHookList() override=default
CommandObjectTargetStopHookList(CommandInterpreter &interpreter)
bool AddSymbolsForUUID(CommandReturnObject &result, bool &flush)
bool DownloadObjectAndSymbolFile(ModuleSpec &module_spec, CommandReturnObject &result, bool &flush)
bool AddSymbolsForStack(CommandReturnObject &result, bool &flush)
OptionGroupBoolean m_current_stack_option
OptionGroupBoolean m_current_frame_option
CommandObjectTargetSymbolsAdd(CommandInterpreter &interpreter)
bool AddSymbolsForFrame(CommandReturnObject &result, bool &flush)
OptionGroupOptions m_option_group
~CommandObjectTargetSymbolsAdd() override=default
Options * GetOptions() override
void DoExecute(Args &args, CommandReturnObject &result) override
OptionGroupFile m_file_option
OptionGroupUUID m_uuid_option_group
bool AddModuleSymbols(Target *target, ModuleSpec &module_spec, bool &flush, CommandReturnObject &result)
bool AddSymbolsForFile(CommandReturnObject &result, bool &flush)
const CommandObjectTargetSymbols & operator=(const CommandObjectTargetSymbols &)=delete
CommandObjectTargetSymbols(CommandInterpreter &interpreter)
~CommandObjectTargetSymbols() override=default
CommandObjectTargetSymbols(const CommandObjectTargetSymbols &)=delete
OptionGroupFormat m_option_format
void DumpGlobalVariableList(const ExecutionContext &exe_ctx, const SymbolContext &sc, const VariableList &variable_list, CommandReturnObject &result)
void DumpValueObject(Stream &s, VariableSP &var_sp, ValueObjectSP &valobj_sp, const char *root_name)
static size_t GetVariableCallback(void *baton, const char *name, VariableList &variable_list)
static const uint32_t SHORT_OPTION_SHLB
CommandObjectTargetVariable(CommandInterpreter &interpreter)
OptionGroupFileList m_option_shared_libraries
void DoExecute(Args &args, CommandReturnObject &result) override
Options * GetOptions() override
OptionGroupFileList m_option_compile_units
static const uint32_t SHORT_OPTION_FILE
OptionGroupVariable m_option_variable
OptionGroupValueObjectDisplay m_varobj_options
OptionGroupOptions m_option_group
~CommandObjectTargetVariable() override=default
~OptionGroupDependents() override=default
OptionGroupDependents()=default
LoadDependentFiles m_load_dependent_files
OptionGroupDependents(const OptionGroupDependents &)=delete
const OptionGroupDependents & operator=(const OptionGroupDependents &)=delete
void OptionParsingStarting(ExecutionContext *execution_context) override
Status SetOptionValue(uint32_t, const char *, ExecutionContext *)=delete
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value, ExecutionContext *execution_context) override
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
virtual lldb::addr_t FixCodeAddress(lldb::addr_t pc)
Some targets might use bits in a code address to indicate a mode switch.
A section + offset based address class.
lldb::addr_t GetLoadAddress(Target *target) const
Get the load address.
bool SetLoadAddress(lldb::addr_t load_addr, Target *target, bool allow_section_end=false)
Set the address to represent load_addr.
@ DumpStyleFileAddress
Display as the file address (if any).
@ DumpStyleSectionNameOffset
Display as the section name + offset.
@ DumpStyleDetailedSymbolContext
Detailed symbol context information for an address for all symbol context members.
@ DumpStyleInvalid
Invalid dump style.
@ DumpStyleModuleWithFileAddress
Display as the file address with the module name prepended (if any).
@ DumpStyleResolvedDescription
Display the details about what an address resolves to.
bool Dump(Stream *s, ExecutionContextScope *exe_scope, DumpStyle style, DumpStyle fallback_style=DumpStyleInvalid, uint32_t addr_byte_size=UINT32_MAX, bool all_ranges=false, std::optional< Stream::HighlightSettings > settings=std::nullopt) const
Dump a description of this object to a Stream.
lldb::ModuleSP GetModule() const
Get accessor for the module for this address.
lldb::addr_t GetFileAddress() const
Get the file address.
bool IsValid() const
Check if the object state is valid.
An architecture specification class.
uint32_t GetAddressByteSize() const
Returns the size in bytes of an address of the current architecture.
bool IsValid() const
Tests if this ArchSpec is valid.
void DumpTriple(llvm::raw_ostream &s) const
const char * GetArchitectureName() const
Returns a static string representing the current architecture.
A command line argument class.
void Shift()
Shifts the first argument C string value of the array off the argument array.
size_t GetArgumentCount() const
Gets the number of arguments left in this command object.
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.
static bool InvokeCommonCompletionCallbacks(CommandInterpreter &interpreter, uint32_t completion_mask, lldb_private::CompletionRequest &request, SearchFilter *searcher)
ExecutionContext GetExecutionContext() const
CommandObjectMultiwordTarget(CommandInterpreter &interpreter)
~CommandObjectMultiwordTarget() override
bool LoadSubCommand(llvm::StringRef cmd_name, const lldb::CommandObjectSP &command_obj) override
CommandObjectMultiword(CommandInterpreter &interpreter, const char *name, const char *help=nullptr, const char *syntax=nullptr, uint32_t flags=0)
friend class CommandInterpreter
CommandObjectParsed(CommandInterpreter &interpreter, const char *name, const char *help=nullptr, const char *syntax=nullptr, uint32_t flags=0)
std::vector< CommandArgumentData > CommandArgumentEntry
virtual void SetHelpLong(llvm::StringRef str)
void AddSimpleArgumentList(lldb::CommandArgumentType arg_type, ArgumentRepetitionType repetition_type=eArgRepeatPlain)
ExecutionContext m_exe_ctx
std::vector< CommandArgumentEntry > m_arguments
CommandInterpreter & GetCommandInterpreter()
CommandInterpreter & m_interpreter
virtual void HandleArgumentCompletion(CompletionRequest &request, OptionElementVector &opt_element_vector)
The default version handles argument definitions that have only one argument type,...
void void AppendError(llvm::StringRef in_string)
const ValueObjectList & GetValueObjectList() const
void AppendWarningWithFormat(const char *format,...) __attribute__((format(printf
Stream & GetErrorStream()
void SetStatus(lldb::ReturnStatus status)
void SetError(Status error)
void AppendErrorWithFormat(const char *format,...) __attribute__((format(printf
void AppendMessageWithFormat(const char *format,...) __attribute__((format(printf
void void AppendMessageWithFormatv(const char *format, Args &&...args)
void void AppendWarning(llvm::StringRef in_string)
void AppendErrorWithFormatv(const char *format, Args &&...args)
Stream & GetOutputStream()
A class that describes a compilation unit.
lldb::VariableListSP GetVariableList(bool can_create)
Get the variable list for a compile unit.
const FileSpec & GetPrimaryFile() const
Return the primary source spec associated with this compile unit.
"lldb/Utility/ArgCompletionRequest.h"
void TryCompleteCurrentArg(llvm::StringRef completion, llvm::StringRef description="")
Adds a possible completion string if the completion would complete the current argument.
size_t GetCursorIndex() const
A uniqued constant string class.
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
void Dump(Stream *s, const char *value_if_empty=nullptr) const
Dump the object description to a stream.
bool IsEmpty() const
Test for empty string.
llvm::StringRef GetStringRef() const
Get the string value as a llvm::StringRef.
const char * GetCString() const
Get the string value as a C string.
A class to manage flag bits.
TargetList & GetTargetList()
Get accessor for the target list.
llvm::StringRef GetRegexMatchAnsiSuffix() const
llvm::StringRef GetRegexMatchAnsiPrefix() const
DumpValueObjectOptions & SetRootValueObjectName(const char *name=nullptr)
DumpValueObjectOptions & SetFormat(lldb::Format format=lldb::eFormatDefault)
A class that measures elapsed time in an exception safe way.
"lldb/Target/ExecutionContextScope.h" Inherit from this if your object can reconstruct its execution ...
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
ExecutionContextScope * GetBestExecutionContextScope() const
Target * GetTargetPtr() const
Returns a pointer to the target object.
const FileSpec & GetFileSpecAtIndex(size_t idx) const
Get file at index.
size_t GetSize() const
Get the number of files in the file list.
void SetFile(llvm::StringRef path, Style style)
Change the file specified with a new path.
void SetDirectory(ConstString directory)
Directory string set accessor.
const ConstString & GetFilename() const
Filename string const get accessor.
const ConstString & GetDirectory() const
Directory string const get accessor.
ConstString GetFileNameStrippingExtension() const
Return the filename without the extension part.
size_t GetPath(char *path, size_t max_path_length, bool denormalize=true) const
Extract the full path to the file.
void Dump(llvm::raw_ostream &s) const
Dump this object to a Stream.
llvm::StringRef GetFileNameExtension() const
Extract the extension of the file.
void SetFilename(ConstString filename)
Filename string set accessor.
void Resolve(llvm::SmallVectorImpl< char > &path)
Resolve path to make it canonical.
bool ResolveExecutableLocation(FileSpec &file_spec)
Call into the Host to see if it can help find the file.
bool Exists(const FileSpec &file_spec) const
Returns whether the given file exists.
int Open(const char *path, int flags, int mode=0600)
Wraps open in a platform-independent way.
static FileSystem & Instance()
IOHandlerDelegateMultiline(llvm::StringRef end_line, Completion completion=Completion::None)
A delegate class for use with IOHandler subclasses.
lldb::LockableStreamFileSP GetErrorStreamFileSP()
lldb::LockableStreamFileSP GetOutputStreamFileSP()
void GetDescription(Stream *s, Target *target, lldb::DescriptionLevel level)
A collection class for Module objects.
void FindFunctions(ConstString name, lldb::FunctionNameType name_type_mask, const ModuleFunctionSearchOptions &options, SymbolContextList &sc_list) const
ModuleIterableNoLocking ModulesNoLocking() const
static bool ModuleIsInCache(const Module *module_ptr)
void FindGlobalVariables(ConstString name, size_t max_matches, VariableList &variable_list) const
Find global and static variables by name.
std::recursive_mutex & GetMutex() const
lldb::ModuleSP FindFirstModule(const ModuleSpec &module_spec) const
Finds the first module whose file specification matches module_spec.
lldb::ModuleSP GetModuleAtIndexUnlocked(size_t idx) const
Get the module shared pointer for the module at index idx without acquiring the ModuleList mutex.
void FindCompileUnits(const FileSpec &path, SymbolContextList &sc_list) const
Find compile units by partial or full path.
bool AppendIfNeeded(const lldb::ModuleSP &new_module, bool notify=true)
Append a module to the module list, if it is not already there.
Module * GetModulePointerAtIndex(size_t idx) const
Get the module pointer for the module at index idx.
void FindModules(const ModuleSpec &module_spec, ModuleList &matching_module_list) const
Finds modules whose file specification matches module_spec.
lldb::ModuleSP GetModuleAtIndex(size_t idx) const
Get the module shared pointer for the module at index idx.
void Append(const lldb::ModuleSP &module_sp, bool notify=true)
Append a module to the module list.
static size_t RemoveOrphanSharedModules(bool mandatory)
static void FindSharedModules(const ModuleSpec &module_spec, ModuleList &matching_module_list)
ModuleIterable Modules() const
size_t GetSize() const
Gets the size of the module list.
bool GetModuleSpecAtIndex(size_t i, ModuleSpec &module_spec) const
bool FindMatchingModuleSpec(const ModuleSpec &module_spec, ModuleSpec &match_module_spec) const
FileSpec & GetPlatformFileSpec()
ArchSpec & GetArchitecture()
FileSpec * GetFileSpecPtr()
FileSpec & GetSymbolFileSpec()
A class that describes an executable image and its associated object and symbol files.
const lldb_private::UUID & GetUUID()
Get a reference to the UUID value contained in this object.
virtual SymbolFile * GetSymbolFile(bool can_create=true, Stream *feedback_strm=nullptr)
Get the module's symbol file.
static Module * GetAllocatedModuleAtIndex(size_t idx)
static std::recursive_mutex & GetAllocationModuleCollectionMutex()
bool ResolveFileAddress(lldb::addr_t vm_addr, Address &so_addr)
Symtab * GetSymtab(bool can_create=true)
Get the module's symbol table.
bool MatchesModuleSpec(const ModuleSpec &module_ref)
static size_t GetNumberAllocatedModules()
const ArchSpec & GetArchitecture() const
Get const accessor for the module architecture.
std::string GetSpecificationDescription() const
Get the module path and object name.
const FileSpec & GetFileSpec() const
Get const accessor for the module file specification.
const llvm::sys::TimePoint & GetModificationTime() const
A plug-in interface definition class for object file parsers.
virtual void Dump(Stream *s)=0
Dump a description of this object to a Stream.
virtual std::vector< LoadableData > GetLoadableData(Target &target)
Loads this objfile to memory.
virtual lldb_private::Address GetEntryPointAddress()
Returns the address of the Entry Point in this object file - if the object file doesn't have an entry...
virtual FileSpec & GetFileSpec()
Get accessor to the object file specification.
virtual lldb_private::Address GetBaseAddress()
Returns base address of this object file.
static size_t GetModuleSpecifications(const FileSpec &file, lldb::offset_t file_offset, lldb::offset_t file_size, ModuleSpecList &specs, lldb::DataBufferSP data_sp=lldb::DataBufferSP())
A command line option parsing protocol class.
std::vector< Option > m_getopt_table
void Insert(llvm::StringRef path, llvm::StringRef replacement, uint32_t insert_idx, bool notify)
void Append(llvm::StringRef path, llvm::StringRef replacement, bool notify)
bool RemapPath(ConstString path, ConstString &new_path) const
bool GetPathsAtIndex(uint32_t idx, ConstString &path, ConstString &new_path) const
void Dump(Stream *s, int pair_index=-1)
static bool DownloadObjectAndSymbolFile(ModuleSpec &module_spec, Status &error, bool force_lookup=true, bool copy_executable=true)
void SetExecutableFile(const FileSpec &exe_file, bool add_exe_file_as_first_arg)
A plug-in interface definition class for debugging a process.
ThreadList & GetThreadList()
void Flush()
Flush all data in the process.
lldb::StateType GetState()
Get accessor for the current process state.
const lldb::ABISP & GetABI()
bool IsValid() const
Test if this object contains a valid regular expression.
lldb::SectionSP FindSectionByName(ConstString section_dstr) const
void Dump(llvm::raw_ostream &s, unsigned indent, Target *target, bool show_header, uint32_t depth) const
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.
uint32_t GetFrameIndex() const
Query this frame to find what frame it is in this Thread's StackFrameList.
static Status FromErrorStringWithFormat(const char *format,...) __attribute__((format(printf
static Status FromErrorString(const char *str)
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.
static Status static Status FromErrorStringWithFormatv(const char *format, Args &&...args)
const char * GetData() const
llvm::StringRef GetString() const
A stream class that can stream formatted output to a file.
void Format(const char *format, Args &&... args)
llvm::raw_ostream & AsRawOstream()
Returns a raw_ostream that forwards the data to this Stream object.
size_t Indent(llvm::StringRef s="")
Indent the current line in the stream.
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
void SetAddressByteSize(uint32_t addr_size)
Set the address size in bytes.
void SetIndentLevel(unsigned level)
Set the current indentation level.
void PutCStringColorHighlighted(llvm::StringRef text, std::optional< HighlightSettings > settings=std::nullopt)
Output a C string to the stream with color highlighting.
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.
unsigned GetIndentLevel() const
Get the current indentation level.
void AddItem(const ObjectSP &item)
bool ForEach(std::function< bool(Object *object)> const &foreach_callback) const
bool GetValueForKeyAsInteger(llvm::StringRef key, IntType &result) const
bool GetValueForKeyAsString(llvm::StringRef key, llvm::StringRef &result) const
bool GetValueForKeyAsArray(llvm::StringRef key, Array *&result) const
Dictionary * GetAsDictionary()
void Dump(lldb_private::Stream &s, bool pretty_print=true) const
Defines a list of symbol context objects.
uint32_t GetSize() const
Get accessor for a symbol context list size.
void Append(const SymbolContext &sc)
Append a new symbol context to the list.
@ eClassOrNamespaceSpecified
Defines a symbol context baton that can be handed other debug core functions.
Function * function
The Function for a given query.
void SortTypeList(TypeMap &type_map, TypeList &type_list) const
Sorts the types in TypeMap according to SymbolContext to TypeList.
lldb::ModuleSP module_sp
The Module for a given query.
CompileUnit * comp_unit
The CompileUnit for a given query.
Symbol * symbol
The Symbol for a given query.
Provides public interface for all SymbolFiles.
virtual ObjectFile * GetObjectFile()=0
bool ValueIsAddress() const
bool GetByteSizeIsValid() const
Address & GetAddressRef()
lldb::addr_t GetByteSize() const
ConstString GetDisplayName() const
uint64_t GetRawValue() const
Get the raw value of the symbol from the symbol table.
Symbol * SymbolAtIndex(size_t idx)
uint32_t AppendSymbolIndexesWithName(ConstString symbol_name, std::vector< uint32_t > &matches)
uint32_t AppendSymbolIndexesMatchingRegExAndType(const RegularExpression ®ex, lldb::SymbolType symbol_type, std::vector< uint32_t > &indexes, Mangled::NamePreference name_preference=Mangled::ePreferDemangled)
lldb::TargetSP GetTargetAtIndex(uint32_t index) const
void SetSelectedTarget(uint32_t index)
bool DeleteTarget(lldb::TargetSP &target_sp)
Delete a Target object from the list.
Status CreateTarget(Debugger &debugger, llvm::StringRef user_exe_path, llvm::StringRef triple_str, LoadDependentFiles get_dependent_modules, const OptionGroupPlatform *platform_options, lldb::TargetSP &target_sp)
Create a new Target.
lldb::TargetSP GetSelectedTarget()
size_t GetNumTargets() const
bool GetUserSpecifiedTrapHandlerNames(Args &args) const
Environment GetEnvironment() const
void SetActionFromString(const std::string &strings)
void SetActionFromStrings(const std::vector< std::string > &strings)
Status SetScriptCallback(std::string class_name, StructuredData::ObjectSP extra_args_sp)
void ModulesDidLoad(ModuleList &module_list)
Module * GetExecutableModulePointer()
StopHookSP CreateStopHook(StopHook::StopHookKind kind)
Add an empty stop hook to the Target's stop hook list, and returns a shared pointer to it in new_hook...
PathMappingList & GetImageSearchPathList()
std::shared_ptr< StopHook > StopHookSP
void SymbolsDidLoad(ModuleList &module_list)
size_t GetNumStopHooks() const
void DumpSectionLoadList(Stream &s)
const lldb::ProcessSP & GetProcessSP() const
lldb::ModuleSP GetOrCreateModule(const ModuleSpec &module_spec, bool notify, Status *error_ptr=nullptr)
Find a binary on the system and return its Module, or return an existing Module that is already in th...
void UndoCreateStopHook(lldb::user_id_t uid)
If you tried to create a stop hook, and that failed, call this to remove the stop hook,...
bool ResolveLoadAddress(lldb::addr_t load_addr, Address &so_addr, uint32_t stop_id=SectionLoadHistory::eStopIDNow, bool allow_section_end=false)
bool SetStopHookActiveStateByID(lldb::user_id_t uid, bool active_state)
void SetAllStopHooksActiveState(bool active_state)
void RemoveAllStopHooks()
StopHookSP GetStopHookAtIndex(size_t index)
lldb::PlatformSP GetPlatform()
const ModuleList & GetImages() const
Get accessor for the images for this process.
const ArchSpec & GetArchitecture() const
const std::string & GetLabel() const
lldb::ProcessSP CalculateProcess() override
bool SetSectionLoadAddress(const lldb::SectionSP §ion, lldb::addr_t load_addr, bool warn_multiple=false)
bool RemoveStopHookByID(lldb::user_id_t uid)
lldb::ThreadSP GetSelectedThread()
uint32_t GetSize(bool can_update=true)
lldb::ThreadSP GetThreadAtIndex(uint32_t idx, bool can_update=true)
void SetIndex(uint32_t index)
void SetName(llvm::StringRef name)
void SetTID(lldb::tid_t tid)
void SetQueueName(llvm::StringRef queue_name)
lldb::TypeSP GetTypeAtIndex(uint32_t idx)
A class that contains all state required for type lookups.
This class tracks the state and results of a TypeQuery.
void Dump(Stream &s) const
std::string GetAsString(llvm::StringRef separator="-") const
lldb::FuncUnwindersSP GetFuncUnwindersContainingAddress(const Address &addr, const SymbolContext &sc)
lldb::FuncUnwindersSP GetUncachedFuncUnwindersContainingAddress(const Address &addr, const SymbolContext &sc)
A collection of ValueObject values that.
void Append(const lldb::ValueObjectSP &val_obj_sp)
lldb::ValueObjectSP GetValueObjectAtIndex(size_t idx)
static lldb::ValueObjectSP Create(ExecutionContextScope *exe_scope, const lldb::VariableSP &var_sp)
lldb::VariableSP GetVariableAtIndex(size_t idx) const
static Status GetValuesForVariableExpressionPath(llvm::StringRef variable_expr_path, ExecutionContextScope *scope, GetVariableCallback callback, void *baton, VariableList &variable_list, ValueObjectList &valobj_list)
#define LLDB_OPT_SET_FROM_TO(A, B)
#define LLDB_INVALID_LINE_NUMBER
#define LLDB_INVALID_THREAD_ID
#define LLDB_INVALID_INDEX32
#define LLDB_INVALID_ADDRESS
#define LLDB_INVALID_PROCESS_ID
A class that represents a running process on the host machine.
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
std::vector< OptionArgElement > OptionElementVector
bool StateIsStoppedState(lldb::StateType state, bool must_exist)
Check if a state represents a state where the process or thread is stopped.
void DumpAddress(llvm::raw_ostream &s, uint64_t addr, uint32_t addr_size, const char *prefix=nullptr, const char *suffix=nullptr)
Output an address value to this stream.
const char * StateAsCString(lldb::StateType state)
Converts a StateType to a C string.
const char * toString(AppleArm64ExceptionClass EC)
std::shared_ptr< lldb_private::TypeSystem > TypeSystemSP
std::shared_ptr< lldb_private::ABI > ABISP
std::shared_ptr< lldb_private::StackFrame > StackFrameSP
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
std::shared_ptr< lldb_private::Thread > ThreadSP
std::shared_ptr< lldb_private::CommandObject > CommandObjectSP
std::shared_ptr< lldb_private::ValueObject > ValueObjectSP
Format
Display format definitions.
std::shared_ptr< lldb_private::Platform > PlatformSP
StateType
Process and Thread States.
std::shared_ptr< lldb_private::FuncUnwinders > FuncUnwindersSP
std::shared_ptr< lldb_private::Type > TypeSP
std::shared_ptr< lldb_private::Process > ProcessSP
@ eReturnStatusSuccessFinishResult
@ eReturnStatusSuccessFinishNoResult
std::shared_ptr< lldb_private::VariableList > VariableListSP
std::shared_ptr< lldb_private::UnwindPlan > UnwindPlanSP
std::shared_ptr< lldb_private::Variable > VariableSP
std::shared_ptr< lldb_private::LockableStreamFile > LockableStreamFileSP
std::shared_ptr< lldb_private::Section > SectionSP
std::shared_ptr< lldb_private::Target > TargetSP
std::shared_ptr< lldb_private::RegisterContext > RegisterContextSP
std::shared_ptr< lldb_private::Module > ModuleSP
@ eValueTypeVariableGlobal
globals variable
@ eValueTypeVariableLocal
function local variables
@ eValueTypeVariableArgument
function argument variables
@ eValueTypeVariableStatic
static variable
@ eValueTypeVariableThreadLocal
thread local storage variable
Used to build individual command argument lists.
ArgumentRepetitionType arg_repetition
lldb::CommandArgumentType arg_type
Options used by Module::FindFunctions.
bool include_inlines
Include inlined functions.
bool include_symbols
Include the symbol table.
static int64_t ToOptionEnum(llvm::StringRef s, const OptionEnumValues &enum_values, int32_t fail_value, Status &error)
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)
Struct to store information for color highlighting in the stream.