LLDB mainline
CommandObjectTarget.cpp
Go to the documentation of this file.
1//===-- CommandObjectTarget.cpp -------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
10
11#include "lldb/Core/Address.h"
12#include "lldb/Core/Debugger.h"
13#include "lldb/Core/IOHandler.h"
14#include "lldb/Core/Module.h"
17#include "lldb/Core/Section.h"
43#include "lldb/Target/ABI.h"
44#include "lldb/Target/Process.h"
48#include "lldb/Target/Thread.h"
50#include "lldb/Utility/Args.h"
54#include "lldb/Utility/State.h"
55#include "lldb/Utility/Stream.h"
57#include "lldb/Utility/Timer.h"
61
62#include "clang/Frontend/CompilerInstance.h"
63#include "clang/Frontend/CompilerInvocation.h"
64#include "clang/Frontend/FrontendActions.h"
65#include "clang/Serialization/ObjectFilePCHContainerReader.h"
66#include "llvm/ADT/ScopeExit.h"
67#include "llvm/ADT/StringRef.h"
68#include "llvm/Support/FileSystem.h"
69#include "llvm/Support/FormatAdapters.h"
70
71
72using namespace lldb;
73using namespace lldb_private;
74
75static void DumpTargetInfo(uint32_t target_idx, Target *target,
76 const char *prefix_cstr,
77 bool show_stopped_process_status, Stream &strm) {
78 const ArchSpec &target_arch = target->GetArchitecture();
79
80 Module *exe_module = target->GetExecutableModulePointer();
81 char exe_path[PATH_MAX];
82 bool exe_valid = false;
83 if (exe_module)
84 exe_valid = exe_module->GetFileSpec().GetPath(exe_path, sizeof(exe_path));
85
86 if (!exe_valid)
87 ::strcpy(exe_path, "<none>");
88
89 std::string formatted_label = "";
90 const std::string &label = target->GetLabel();
91 if (!label.empty()) {
92 formatted_label = " (" + label + ")";
93 }
94
95 strm.Printf("%starget #%u%s: %s", prefix_cstr ? prefix_cstr : "", target_idx,
96 formatted_label.data(), exe_path);
97
98 uint32_t properties = 0;
99 if (target_arch.IsValid()) {
100 strm.Printf(" ( arch=");
101 target_arch.DumpTriple(strm.AsRawOstream());
102 properties++;
103 }
104 PlatformSP platform_sp(target->GetPlatform());
105 if (platform_sp)
106 strm.Format("{0}platform={1}", properties++ > 0 ? ", " : " ( ",
107 platform_sp->GetName());
108
109 ProcessSP process_sp(target->GetProcessSP());
110 bool show_process_status = false;
111 if (process_sp) {
112 lldb::pid_t pid = process_sp->GetID();
113 StateType state = process_sp->GetState();
114 if (show_stopped_process_status)
115 show_process_status = StateIsStoppedState(state, true);
116 const char *state_cstr = StateAsCString(state);
117 if (pid != LLDB_INVALID_PROCESS_ID)
118 strm.Printf("%spid=%" PRIu64, properties++ > 0 ? ", " : " ( ", pid);
119 strm.Printf("%sstate=%s", properties++ > 0 ? ", " : " ( ", state_cstr);
120 }
121 if (properties > 0)
122 strm.PutCString(" )\n");
123 else
124 strm.EOL();
125 if (show_process_status) {
126 const bool only_threads_with_stop_reason = true;
127 const uint32_t start_frame = 0;
128 const uint32_t num_frames = 1;
129 const uint32_t num_frames_with_source = 1;
130 const bool stop_format = false;
131 process_sp->GetStatus(strm);
132 process_sp->GetThreadStatus(strm, only_threads_with_stop_reason,
133 start_frame, num_frames, num_frames_with_source,
134 stop_format);
135 }
136}
137
138static uint32_t DumpTargetList(TargetList &target_list,
139 bool show_stopped_process_status, Stream &strm) {
140 const uint32_t num_targets = target_list.GetNumTargets();
141 if (num_targets) {
142 TargetSP selected_target_sp(target_list.GetSelectedTarget());
143 strm.PutCString("Current targets:\n");
144 for (uint32_t i = 0; i < num_targets; ++i) {
145 TargetSP target_sp(target_list.GetTargetAtIndex(i));
146 if (target_sp) {
147 bool is_selected = target_sp.get() == selected_target_sp.get();
148 DumpTargetInfo(i, target_sp.get(), is_selected ? "* " : " ",
149 show_stopped_process_status, strm);
150 }
151 }
152 }
153 return num_targets;
154}
155
156#define LLDB_OPTIONS_target_dependents
157#include "CommandOptions.inc"
158
160public:
162
163 ~OptionGroupDependents() override = default;
164
165 llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
166 return llvm::ArrayRef(g_target_dependents_options);
167 }
168
169 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
170 ExecutionContext *execution_context) override {
172
173 // For compatibility no value means don't load dependents.
174 if (option_value.empty()) {
176 return error;
177 }
178
179 const char short_option =
180 g_target_dependents_options[option_idx].short_option;
181 if (short_option == 'd') {
182 LoadDependentFiles tmp_load_dependents;
184 option_value, g_target_dependents_options[option_idx].enum_values, 0,
185 error);
186 if (error.Success())
187 m_load_dependent_files = tmp_load_dependents;
188 } else {
190 "unrecognized short option '%c'", short_option);
191 }
192
193 return error;
194 }
195
196 Status SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
197
198 void OptionParsingStarting(ExecutionContext *execution_context) override {
200 }
201
203
204private:
208};
209
210#pragma mark CommandObjectTargetCreate
211
213public:
216 interpreter, "target create",
217 "Create a target using the argument as the main executable.",
218 nullptr),
219 m_platform_options(true), // Include the --platform option.
220 m_core_file(LLDB_OPT_SET_1, false, "core", 'c', 0, eArgTypeFilename,
221 "Fullpath to a core file to use for this target."),
222 m_label(LLDB_OPT_SET_1, false, "label", 'l', 0, eArgTypeName,
223 "Optional name for this target.", nullptr),
224 m_symbol_file(LLDB_OPT_SET_1, false, "symfile", 's', 0,
226 "Fullpath to a stand alone debug "
227 "symbols file for when debug symbols "
228 "are not in the executable."),
230 LLDB_OPT_SET_1, false, "remote-file", 'r', 0, eArgTypeFilename,
231 "Fullpath to the file on the remote host if debugging remotely.") {
232
234
243 }
244
245 ~CommandObjectTargetCreate() override = default;
246
247 Options *GetOptions() override { return &m_option_group; }
248
249protected:
250 void DoExecute(Args &command, CommandReturnObject &result) override {
251 const size_t argc = command.GetArgumentCount();
254
255 if (core_file) {
256 auto file = FileSystem::Instance().Open(
258
259 if (!file) {
260 result.AppendErrorWithFormatv("Cannot open '{0}': {1}.",
261 core_file.GetPath(),
262 llvm::toString(file.takeError()));
263 return;
264 }
265 }
266
267 if (argc == 1 || core_file || remote_file) {
269 if (symfile) {
270 auto file = FileSystem::Instance().Open(
272
273 if (!file) {
274 result.AppendErrorWithFormatv("Cannot open '{0}': {1}.",
275 symfile.GetPath(),
276 llvm::toString(file.takeError()));
277 return;
278 }
279 }
280
281 const char *file_path = command.GetArgumentAtIndex(0);
282 LLDB_SCOPED_TIMERF("(lldb) target create '%s'", file_path);
283
284 bool must_set_platform_path = false;
285
286 Debugger &debugger = GetDebugger();
287
288 TargetSP target_sp;
289 llvm::StringRef arch_cstr = m_arch_option.GetArchitectureName();
291 debugger, file_path, arch_cstr,
293 target_sp));
294
295 if (!target_sp) {
296 result.AppendError(error.AsCString());
297 return;
298 }
299
300 const llvm::StringRef label =
302 if (!label.empty()) {
303 if (auto E = target_sp->SetLabel(label))
304 result.SetError(std::move(E));
305 return;
306 }
307
308 auto on_error = llvm::make_scope_exit(
309 [&target_list = debugger.GetTargetList(), &target_sp]() {
310 target_list.DeleteTarget(target_sp);
311 });
312
313 // Only get the platform after we create the target because we might
314 // have switched platforms depending on what the arguments were to
315 // CreateTarget() we can't rely on the selected platform.
316
317 PlatformSP platform_sp = target_sp->GetPlatform();
318
319 FileSpec file_spec;
320 if (file_path) {
321 file_spec.SetFile(file_path, FileSpec::Style::native);
322 FileSystem::Instance().Resolve(file_spec);
323
324 // Try to resolve the exe based on PATH and/or platform-specific
325 // suffixes, but only if using the host platform.
326 if (platform_sp && platform_sp->IsHost() &&
327 !FileSystem::Instance().Exists(file_spec))
329 }
330
331 if (remote_file) {
332 if (platform_sp) {
333 // I have a remote file.. two possible cases
334 if (file_spec && FileSystem::Instance().Exists(file_spec)) {
335 // if the remote file does not exist, push it there
336 if (!platform_sp->GetFileExists(remote_file)) {
337 Status err = platform_sp->PutFile(file_spec, remote_file);
338 if (err.Fail()) {
339 result.AppendError(err.AsCString());
340 return;
341 }
342 }
343 } else {
344 // there is no local file and we need one
345 // in order to make the remote ---> local transfer we need a
346 // platform
347 // TODO: if the user has passed in a --platform argument, use it
348 // to fetch the right platform
349 if (file_path) {
350 // copy the remote file to the local file
351 Status err = platform_sp->GetFile(remote_file, file_spec);
352 if (err.Fail()) {
353 result.AppendError(err.AsCString());
354 return;
355 }
356 } else {
357 // If the remote file exists, we can debug reading that out of
358 // memory. If the platform is already connected to an lldb-server
359 // then we can at least check the file exists remotely. Otherwise
360 // we'll just have to trust that it will be there when we do
361 // process connect.
362 // I don't do this for the host platform because it seems odd to
363 // support supplying a remote file but no local file for a local
364 // debug session.
365 if (platform_sp->IsHost()) {
366 result.AppendError("Supply a local file, not a remote file, "
367 "when debugging on the host.");
368 return;
369 }
370 if (platform_sp->IsConnected() && !platform_sp->GetFileExists(remote_file)) {
371 result.AppendError("remote --> local transfer without local "
372 "path is not implemented yet");
373 return;
374 }
375 // Since there's only a remote file, we need to set the executable
376 // file spec to the remote one.
377 ProcessLaunchInfo launch_info = target_sp->GetProcessLaunchInfo();
378 launch_info.SetExecutableFile(FileSpec(remote_file), true);
379 target_sp->SetProcessLaunchInfo(launch_info);
380 }
381 }
382 } else {
383 result.AppendError("no platform found for target");
384 return;
385 }
386 }
387
388 if (symfile || remote_file) {
389 ModuleSP module_sp(target_sp->GetExecutableModule());
390 if (module_sp) {
391 if (symfile)
392 module_sp->SetSymbolFileFileSpec(symfile);
393 if (remote_file) {
394 std::string remote_path = remote_file.GetPath();
395 target_sp->SetArg0(remote_path.c_str());
396 module_sp->SetPlatformFileSpec(remote_file);
397 }
398 }
399 }
400
401 if (must_set_platform_path) {
402 ModuleSpec main_module_spec(file_spec);
403 ModuleSP module_sp =
404 target_sp->GetOrCreateModule(main_module_spec, true /* notify */);
405 if (module_sp)
406 module_sp->SetPlatformFileSpec(remote_file);
407 }
408
409 if (core_file) {
410 FileSpec core_file_dir;
411 core_file_dir.SetDirectory(core_file.GetDirectory());
412 target_sp->AppendExecutableSearchPaths(core_file_dir);
413
414 ProcessSP process_sp(target_sp->CreateProcess(
415 GetDebugger().GetListener(), llvm::StringRef(), &core_file, false));
416
417 if (process_sp) {
418 // Seems weird that we Launch a core file, but that is what we
419 // do!
420 error = process_sp->LoadCore();
421
422 if (error.Fail()) {
423 result.AppendError(error.AsCString("unknown core file format"));
424 return;
425 } else {
427 "Core file '{0}' ({1}) was loaded.\n", core_file.GetPath(),
428 target_sp->GetArchitecture().GetArchitectureName());
430 on_error.release();
431 }
432 } else {
433 result.AppendErrorWithFormatv("Unknown core file format '{0}'\n",
434 core_file.GetPath());
435 }
436 } else {
438 "Current executable set to '%s' (%s).\n",
439 file_spec.GetPath().c_str(),
440 target_sp->GetArchitecture().GetArchitectureName());
442 on_error.release();
443 }
444 } else {
445 result.AppendErrorWithFormat("'%s' takes exactly one executable path "
446 "argument, or use the --core option.\n",
447 m_cmd_name.c_str());
448 }
449 }
450
451private:
460};
461
462#pragma mark CommandObjectTargetList
463
465public:
468 interpreter, "target list",
469 "List all current targets in the current debug session.", nullptr) {
470 }
471
472 ~CommandObjectTargetList() override = default;
473
474protected:
475 void DoExecute(Args &args, CommandReturnObject &result) override {
476 Stream &strm = result.GetOutputStream();
477
478 bool show_stopped_process_status = false;
479 if (DumpTargetList(GetDebugger().GetTargetList(),
480 show_stopped_process_status, strm) == 0) {
481 strm.PutCString("No targets.\n");
482 }
484 }
485};
486
487#pragma mark CommandObjectTargetSelect
488
490public:
493 interpreter, "target select",
494 "Select a target as the current target by target index.", nullptr) {
496 }
497
498 ~CommandObjectTargetSelect() override = default;
499
500protected:
501 void DoExecute(Args &args, CommandReturnObject &result) override {
502 if (args.GetArgumentCount() == 1) {
503 const char *target_identifier = args.GetArgumentAtIndex(0);
504 uint32_t target_idx = LLDB_INVALID_INDEX32;
505 TargetList &target_list = GetDebugger().GetTargetList();
506 const uint32_t num_targets = target_list.GetNumTargets();
507 if (llvm::to_integer(target_identifier, target_idx)) {
508 if (target_idx < num_targets) {
509 target_list.SetSelectedTarget(target_idx);
510 Stream &strm = result.GetOutputStream();
511 bool show_stopped_process_status = false;
512 DumpTargetList(target_list, show_stopped_process_status, strm);
514 } else {
515 if (num_targets > 0) {
517 "index %u is out of range, valid target indexes are 0 - %u\n",
518 target_idx, num_targets - 1);
519 } else {
521 "index %u is out of range since there are no active targets\n",
522 target_idx);
523 }
524 }
525 } else {
526 for (size_t i = 0; i < num_targets; i++) {
527 if (TargetSP target_sp = target_list.GetTargetAtIndex(i)) {
528 const std::string &label = target_sp->GetLabel();
529 if (!label.empty() && label == target_identifier) {
530 target_idx = i;
531 break;
532 }
533 }
534 }
535
536 if (target_idx != LLDB_INVALID_INDEX32) {
537 target_list.SetSelectedTarget(target_idx);
538 Stream &strm = result.GetOutputStream();
539 bool show_stopped_process_status = false;
540 DumpTargetList(target_list, show_stopped_process_status, strm);
542 } else {
543 result.AppendErrorWithFormat("invalid index string value '%s'\n",
544 target_identifier);
545 }
546 }
547 } else {
548 result.AppendError(
549 "'target select' takes a single argument: a target index\n");
550 }
551 }
552};
553
554#pragma mark CommandObjectTargetDelete
555
557public:
559 : CommandObjectParsed(interpreter, "target delete",
560 "Delete one or more targets by target index.",
561 nullptr),
562 m_all_option(LLDB_OPT_SET_1, false, "all", 'a', "Delete all targets.",
563 false, true),
565 LLDB_OPT_SET_1, false, "clean", 'c',
566 "Perform extra cleanup to minimize memory consumption after "
567 "deleting the target. "
568 "By default, LLDB will keep in memory any modules previously "
569 "loaded by the target as well "
570 "as all of its debug info. Specifying --clean will unload all of "
571 "these shared modules and "
572 "cause them to be reparsed again the next time the target is run",
573 false, true) {
578 }
579
580 ~CommandObjectTargetDelete() override = default;
581
582 Options *GetOptions() override { return &m_option_group; }
583
584protected:
585 void DoExecute(Args &args, CommandReturnObject &result) override {
586 const size_t argc = args.GetArgumentCount();
587 std::vector<TargetSP> delete_target_list;
588 TargetList &target_list = GetDebugger().GetTargetList();
589 TargetSP target_sp;
590
592 for (size_t i = 0; i < target_list.GetNumTargets(); ++i)
593 delete_target_list.push_back(target_list.GetTargetAtIndex(i));
594 } else if (argc > 0) {
595 const uint32_t num_targets = target_list.GetNumTargets();
596 // Bail out if don't have any targets.
597 if (num_targets == 0) {
598 result.AppendError("no targets to delete");
599 return;
600 }
601
602 for (auto &entry : args.entries()) {
603 uint32_t target_idx;
604 if (entry.ref().getAsInteger(0, target_idx)) {
605 result.AppendErrorWithFormat("invalid target index '%s'\n",
606 entry.c_str());
607 return;
608 }
609 if (target_idx < num_targets) {
610 target_sp = target_list.GetTargetAtIndex(target_idx);
611 if (target_sp) {
612 delete_target_list.push_back(target_sp);
613 continue;
614 }
615 }
616 if (num_targets > 1)
617 result.AppendErrorWithFormat("target index %u is out of range, valid "
618 "target indexes are 0 - %u\n",
619 target_idx, num_targets - 1);
620 else
622 "target index %u is out of range, the only valid index is 0\n",
623 target_idx);
624
625 return;
626 }
627 } else {
628 target_sp = target_list.GetSelectedTarget();
629 if (!target_sp) {
630 result.AppendErrorWithFormat("no target is currently selected\n");
631 return;
632 }
633 delete_target_list.push_back(target_sp);
634 }
635
636 const size_t num_targets_to_delete = delete_target_list.size();
637 for (size_t idx = 0; idx < num_targets_to_delete; ++idx) {
638 target_sp = delete_target_list[idx];
639 target_list.DeleteTarget(target_sp);
640 target_sp->Destroy();
641 }
642 // If "--clean" was specified, prune any orphaned shared modules from the
643 // global shared module list
645 const bool mandatory = true;
647 }
648 result.GetOutputStream().Printf("%u targets deleted.\n",
649 (uint32_t)num_targets_to_delete);
651
652 return;
653 }
654
658};
659
661public:
664 interpreter, "target show-launch-environment",
665 "Shows the environment being passed to the process when launched, "
666 "taking info account 3 settings: target.env-vars, "
667 "target.inherit-env and target.unset-env-vars.",
668 nullptr, eCommandRequiresTarget) {}
669
671
672protected:
673 void DoExecute(Args &args, CommandReturnObject &result) override {
674 Target *target = m_exe_ctx.GetTargetPtr();
675 Environment env = target->GetEnvironment();
676
677 std::vector<Environment::value_type *> env_vector;
678 env_vector.reserve(env.size());
679 for (auto &KV : env)
680 env_vector.push_back(&KV);
681 std::sort(env_vector.begin(), env_vector.end(),
682 [](Environment::value_type *a, Environment::value_type *b) {
683 return a->first() < b->first();
684 });
685
686 auto &strm = result.GetOutputStream();
687 for (auto &KV : env_vector)
688 strm.Format("{0}={1}\n", KV->first(), KV->second);
689
691 }
692};
693
694#pragma mark CommandObjectTargetVariable
695
697 static const uint32_t SHORT_OPTION_FILE = 0x66696c65; // 'file'
698 static const uint32_t SHORT_OPTION_SHLB = 0x73686c62; // 'shlb'
699
700public:
702 : CommandObjectParsed(interpreter, "target variable",
703 "Read global variables for the current target, "
704 "before or while running a process.",
705 nullptr, eCommandRequiresTarget),
706 m_option_variable(false), // Don't include frame options
710 "A basename or fullpath to a file that contains "
711 "global variables. This option can be "
712 "specified multiple times."),
714 LLDB_OPT_SET_1, false, "shlib", SHORT_OPTION_SHLB, 0,
716 "A basename or fullpath to a shared library to use in the search "
717 "for global "
718 "variables. This option can be specified multiple times.") {
720
732 }
733
734 ~CommandObjectTargetVariable() override = default;
735
736 void DumpValueObject(Stream &s, VariableSP &var_sp, ValueObjectSP &valobj_sp,
737 const char *root_name) {
739
740 if (!valobj_sp->GetTargetSP()->GetDisplayRuntimeSupportValues() &&
741 valobj_sp->IsRuntimeSupportValue())
742 return;
743
744 switch (var_sp->GetScope()) {
747 s.PutCString("GLOBAL: ");
748 break;
749
752 s.PutCString("STATIC: ");
753 break;
754
757 s.PutCString(" ARG: ");
758 break;
759
762 s.PutCString(" LOCAL: ");
763 break;
764
767 s.PutCString("THREAD: ");
768 break;
769
770 default:
771 break;
772 }
773
775 bool show_fullpaths = false;
776 bool show_module = true;
777 if (var_sp->DumpDeclaration(&s, show_fullpaths, show_module))
778 s.PutCString(": ");
779 }
780
781 const Format format = m_option_format.GetFormat();
782 if (format != eFormatDefault)
783 options.SetFormat(format);
784
785 options.SetRootValueObjectName(root_name);
786
787 if (llvm::Error error = valobj_sp->Dump(s, options))
788 s << "error: " << toString(std::move(error));
789 }
790
791 static size_t GetVariableCallback(void *baton, const char *name,
792 VariableList &variable_list) {
793 size_t old_size = variable_list.GetSize();
794 Target *target = static_cast<Target *>(baton);
795 if (target)
797 variable_list);
798 return variable_list.GetSize() - old_size;
799 }
800
801 Options *GetOptions() override { return &m_option_group; }
802
803protected:
805 const SymbolContext &sc,
806 const VariableList &variable_list, Stream &s) {
807 if (variable_list.Empty())
808 return;
809 if (sc.module_sp) {
810 if (sc.comp_unit) {
811 s.Format("Global variables for {0} in {1}:\n",
812 sc.comp_unit->GetPrimaryFile(), sc.module_sp->GetFileSpec());
813 } else {
814 s.Printf("Global variables for %s\n",
815 sc.module_sp->GetFileSpec().GetPath().c_str());
816 }
817 } else if (sc.comp_unit) {
818 s.Format("Global variables for {0}\n", sc.comp_unit->GetPrimaryFile());
819 }
820
821 for (VariableSP var_sp : variable_list) {
822 if (!var_sp)
823 continue;
825 exe_ctx.GetBestExecutionContextScope(), var_sp));
826
827 if (valobj_sp)
828 DumpValueObject(s, var_sp, valobj_sp, var_sp->GetName().GetCString());
829 }
830 }
831
832 void DoExecute(Args &args, CommandReturnObject &result) override {
833 Target *target = m_exe_ctx.GetTargetPtr();
834 const size_t argc = args.GetArgumentCount();
835 Stream &s = result.GetOutputStream();
836
837 if (argc > 0) {
838 for (const Args::ArgEntry &arg : args) {
839 VariableList variable_list;
840 ValueObjectList valobj_list;
841
842 size_t matches = 0;
843 bool use_var_name = false;
845 RegularExpression regex(arg.ref());
846 if (!regex.IsValid()) {
847 result.GetErrorStream().Printf(
848 "error: invalid regular expression: '%s'\n", arg.c_str());
849 return;
850 }
851 use_var_name = true;
853 variable_list);
854 matches = variable_list.GetSize();
855 } else {
858 GetVariableCallback, target, variable_list, valobj_list));
859 matches = variable_list.GetSize();
860 }
861
862 if (matches == 0) {
863 result.AppendErrorWithFormat("can't find global variable '%s'",
864 arg.c_str());
865 return;
866 } else {
867 for (uint32_t global_idx = 0; global_idx < matches; ++global_idx) {
868 VariableSP var_sp(variable_list.GetVariableAtIndex(global_idx));
869 if (var_sp) {
870 ValueObjectSP valobj_sp(
871 valobj_list.GetValueObjectAtIndex(global_idx));
872 if (!valobj_sp)
873 valobj_sp = ValueObjectVariable::Create(
875
876 if (valobj_sp)
877 DumpValueObject(s, var_sp, valobj_sp,
878 use_var_name ? var_sp->GetName().GetCString()
879 : arg.c_str());
880 }
881 }
882 }
883 }
884 } else {
885 const FileSpecList &compile_units =
887 const FileSpecList &shlibs =
889 SymbolContextList sc_list;
890 const size_t num_compile_units = compile_units.GetSize();
891 const size_t num_shlibs = shlibs.GetSize();
892 if (num_compile_units == 0 && num_shlibs == 0) {
893 bool success = false;
895 CompileUnit *comp_unit = nullptr;
896 if (frame) {
897 SymbolContext sc = frame->GetSymbolContext(eSymbolContextCompUnit);
898 comp_unit = sc.comp_unit;
899 if (sc.comp_unit) {
900 const bool can_create = true;
901 VariableListSP comp_unit_varlist_sp(
902 sc.comp_unit->GetVariableList(can_create));
903 if (comp_unit_varlist_sp) {
904 size_t count = comp_unit_varlist_sp->GetSize();
905 if (count > 0) {
906 DumpGlobalVariableList(m_exe_ctx, sc, *comp_unit_varlist_sp, s);
907 success = true;
908 }
909 }
910 }
911 }
912 if (!success) {
913 if (frame) {
914 if (comp_unit)
916 "no global variables in current compile unit: {0}\n",
917 comp_unit->GetPrimaryFile());
918 else
920 "no debug information for frame %u\n",
921 frame->GetFrameIndex());
922 } else
923 result.AppendError("'target variable' takes one or more global "
924 "variable names as arguments\n");
925 }
926 } else {
927 SymbolContextList sc_list;
928 // We have one or more compile unit or shlib
929 if (num_shlibs > 0) {
930 for (size_t shlib_idx = 0; shlib_idx < num_shlibs; ++shlib_idx) {
931 const FileSpec module_file(shlibs.GetFileSpecAtIndex(shlib_idx));
932 ModuleSpec module_spec(module_file);
933
934 ModuleSP module_sp(
935 target->GetImages().FindFirstModule(module_spec));
936 if (module_sp) {
937 if (num_compile_units > 0) {
938 for (size_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx)
939 module_sp->FindCompileUnits(
940 compile_units.GetFileSpecAtIndex(cu_idx), sc_list);
941 } else {
942 SymbolContext sc;
943 sc.module_sp = module_sp;
944 sc_list.Append(sc);
945 }
946 } else {
947 // Didn't find matching shlib/module in target...
949 "target doesn't contain the specified shared library: %s\n",
950 module_file.GetPath().c_str());
951 }
952 }
953 } else {
954 // No shared libraries, we just want to find globals for the compile
955 // units files that were specified
956 for (size_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx)
957 target->GetImages().FindCompileUnits(
958 compile_units.GetFileSpecAtIndex(cu_idx), sc_list);
959 }
960
961 for (const SymbolContext &sc : sc_list) {
962 if (sc.comp_unit) {
963 const bool can_create = true;
964 VariableListSP comp_unit_varlist_sp(
965 sc.comp_unit->GetVariableList(can_create));
966 if (comp_unit_varlist_sp)
967 DumpGlobalVariableList(m_exe_ctx, sc, *comp_unit_varlist_sp, s);
968 } else if (sc.module_sp) {
969 // Get all global variables for this module
970 lldb_private::RegularExpression all_globals_regex(
971 llvm::StringRef(".")); // Any global with at least one character
972 VariableList variable_list;
973 sc.module_sp->FindGlobalVariables(all_globals_regex, UINT32_MAX,
974 variable_list);
975 DumpGlobalVariableList(m_exe_ctx, sc, variable_list, s);
976 }
977 }
978 }
979 }
980
982 m_cmd_name);
983 }
984
991};
992
993#pragma mark CommandObjectTargetModulesSearchPathsAdd
994
996public:
998 : CommandObjectParsed(interpreter, "target modules search-paths add",
999 "Add new image search paths substitution pairs to "
1000 "the current target.",
1001 nullptr, eCommandRequiresTarget) {
1003 CommandArgumentData old_prefix_arg;
1004 CommandArgumentData new_prefix_arg;
1005
1006 // Define the first variant of this arg pair.
1007 old_prefix_arg.arg_type = eArgTypeOldPathPrefix;
1008 old_prefix_arg.arg_repetition = eArgRepeatPairPlus;
1009
1010 // Define the first variant of this arg pair.
1011 new_prefix_arg.arg_type = eArgTypeNewPathPrefix;
1012 new_prefix_arg.arg_repetition = eArgRepeatPairPlus;
1013
1014 // There are two required arguments that must always occur together, i.e.
1015 // an argument "pair". Because they must always occur together, they are
1016 // treated as two variants of one argument rather than two independent
1017 // arguments. Push them both into the first argument position for
1018 // m_arguments...
1019
1020 arg.push_back(old_prefix_arg);
1021 arg.push_back(new_prefix_arg);
1022
1023 m_arguments.push_back(arg);
1024 }
1025
1027
1028protected:
1029 void DoExecute(Args &command, CommandReturnObject &result) override {
1030 Target &target = GetTarget();
1031 const size_t argc = command.GetArgumentCount();
1032 if (argc & 1) {
1033 result.AppendError("add requires an even number of arguments\n");
1034 } else {
1035 for (size_t i = 0; i < argc; i += 2) {
1036 const char *from = command.GetArgumentAtIndex(i);
1037 const char *to = command.GetArgumentAtIndex(i + 1);
1038
1039 if (from[0] && to[0]) {
1040 Log *log = GetLog(LLDBLog::Host);
1041 if (log) {
1042 LLDB_LOGF(log,
1043 "target modules search path adding ImageSearchPath "
1044 "pair: '%s' -> '%s'",
1045 from, to);
1046 }
1047 bool last_pair = ((argc - i) == 2);
1049 from, to, last_pair); // Notify if this is the last pair
1051 } else {
1052 if (from[0])
1053 result.AppendError("<path-prefix> can't be empty\n");
1054 else
1055 result.AppendError("<new-path-prefix> can't be empty\n");
1056 }
1057 }
1058 }
1059 }
1060};
1061
1062#pragma mark CommandObjectTargetModulesSearchPathsClear
1063
1065public:
1067 : CommandObjectParsed(interpreter, "target modules search-paths clear",
1068 "Clear all current image search path substitution "
1069 "pairs from the current target.",
1070 "target modules search-paths clear",
1071 eCommandRequiresTarget) {}
1072
1074
1075protected:
1076 void DoExecute(Args &command, CommandReturnObject &result) override {
1077 Target &target = GetTarget();
1078 bool notify = true;
1079 target.GetImageSearchPathList().Clear(notify);
1081 }
1082};
1083
1084#pragma mark CommandObjectTargetModulesSearchPathsInsert
1085
1087public:
1089 : CommandObjectParsed(interpreter, "target modules search-paths insert",
1090 "Insert a new image search path substitution pair "
1091 "into the current target at the specified index.",
1092 nullptr, eCommandRequiresTarget) {
1095 CommandArgumentData index_arg;
1096 CommandArgumentData old_prefix_arg;
1097 CommandArgumentData new_prefix_arg;
1098
1099 // Define the first and only variant of this arg.
1100 index_arg.arg_type = eArgTypeIndex;
1101 index_arg.arg_repetition = eArgRepeatPlain;
1102
1103 // Put the one and only variant into the first arg for m_arguments:
1104 arg1.push_back(index_arg);
1105
1106 // Define the first variant of this arg pair.
1107 old_prefix_arg.arg_type = eArgTypeOldPathPrefix;
1108 old_prefix_arg.arg_repetition = eArgRepeatPairPlus;
1109
1110 // Define the first variant of this arg pair.
1111 new_prefix_arg.arg_type = eArgTypeNewPathPrefix;
1112 new_prefix_arg.arg_repetition = eArgRepeatPairPlus;
1113
1114 // There are two required arguments that must always occur together, i.e.
1115 // an argument "pair". Because they must always occur together, they are
1116 // treated as two variants of one argument rather than two independent
1117 // arguments. Push them both into the same argument position for
1118 // m_arguments...
1119
1120 arg2.push_back(old_prefix_arg);
1121 arg2.push_back(new_prefix_arg);
1122
1123 // Add arguments to m_arguments.
1124 m_arguments.push_back(arg1);
1125 m_arguments.push_back(arg2);
1126 }
1127
1129
1130 void
1132 OptionElementVector &opt_element_vector) override {
1133 if (!m_exe_ctx.HasTargetScope() || request.GetCursorIndex() != 0)
1134 return;
1135
1136 Target *target = m_exe_ctx.GetTargetPtr();
1137 const PathMappingList &list = target->GetImageSearchPathList();
1138 const size_t num = list.GetSize();
1139 ConstString old_path, new_path;
1140 for (size_t i = 0; i < num; ++i) {
1141 if (!list.GetPathsAtIndex(i, old_path, new_path))
1142 break;
1143 StreamString strm;
1144 strm << old_path << " -> " << new_path;
1145 request.TryCompleteCurrentArg(std::to_string(i), strm.GetString());
1146 }
1147 }
1148
1149protected:
1150 void DoExecute(Args &command, CommandReturnObject &result) override {
1151 Target &target = GetTarget();
1152 size_t argc = command.GetArgumentCount();
1153 // check for at least 3 arguments and an odd number of parameters
1154 if (argc >= 3 && argc & 1) {
1155 uint32_t insert_idx;
1156
1157 if (!llvm::to_integer(command.GetArgumentAtIndex(0), insert_idx)) {
1158 result.AppendErrorWithFormat(
1159 "<index> parameter is not an integer: '%s'.\n",
1160 command.GetArgumentAtIndex(0));
1161 return;
1162 }
1163
1164 // shift off the index
1165 command.Shift();
1166 argc = command.GetArgumentCount();
1167
1168 for (uint32_t i = 0; i < argc; i += 2, ++insert_idx) {
1169 const char *from = command.GetArgumentAtIndex(i);
1170 const char *to = command.GetArgumentAtIndex(i + 1);
1171
1172 if (from[0] && to[0]) {
1173 bool last_pair = ((argc - i) == 2);
1174 target.GetImageSearchPathList().Insert(from, to, insert_idx,
1175 last_pair);
1177 } else {
1178 if (from[0])
1179 result.AppendError("<path-prefix> can't be empty\n");
1180 else
1181 result.AppendError("<new-path-prefix> can't be empty\n");
1182 return;
1183 }
1184 }
1185 } else {
1186 result.AppendError("insert requires at least three arguments\n");
1187 }
1188 }
1189};
1190
1191#pragma mark CommandObjectTargetModulesSearchPathsList
1192
1194public:
1196 : CommandObjectParsed(interpreter, "target modules search-paths list",
1197 "List all current image search path substitution "
1198 "pairs in the current target.",
1199 "target modules search-paths list",
1200 eCommandRequiresTarget) {}
1201
1203
1204protected:
1205 void DoExecute(Args &command, CommandReturnObject &result) override {
1206 Target &target = GetTarget();
1207 target.GetImageSearchPathList().Dump(&result.GetOutputStream());
1209 }
1210};
1211
1212#pragma mark CommandObjectTargetModulesSearchPathsQuery
1213
1215public:
1218 interpreter, "target modules search-paths query",
1219 "Transform a path using the first applicable image search path.",
1220 nullptr, eCommandRequiresTarget) {
1222 }
1223
1225
1226protected:
1227 void DoExecute(Args &command, CommandReturnObject &result) override {
1228 Target &target = GetTarget();
1229 if (command.GetArgumentCount() != 1) {
1230 result.AppendError("query requires one argument\n");
1231 return;
1232 }
1233
1234 ConstString orig(command.GetArgumentAtIndex(0));
1235 ConstString transformed;
1236 if (target.GetImageSearchPathList().RemapPath(orig, transformed))
1237 result.GetOutputStream().Printf("%s\n", transformed.GetCString());
1238 else
1239 result.GetOutputStream().Printf("%s\n", orig.GetCString());
1240
1242 }
1243};
1244
1245// Static Helper functions
1246static void DumpModuleArchitecture(Stream &strm, Module *module,
1247 bool full_triple, uint32_t width) {
1248 if (module) {
1249 StreamString arch_strm;
1250
1251 if (full_triple)
1252 module->GetArchitecture().DumpTriple(arch_strm.AsRawOstream());
1253 else
1254 arch_strm.PutCString(module->GetArchitecture().GetArchitectureName());
1255 std::string arch_str = std::string(arch_strm.GetString());
1256
1257 if (width)
1258 strm.Printf("%-*s", width, arch_str.c_str());
1259 else
1260 strm.PutCString(arch_str);
1261 }
1262}
1263
1264static void DumpModuleUUID(Stream &strm, Module *module) {
1265 if (module && module->GetUUID().IsValid())
1266 module->GetUUID().Dump(strm);
1267 else
1268 strm.PutCString(" ");
1269}
1270
1272 Stream &strm, Module *module,
1273 const FileSpec &file_spec,
1274 lldb::DescriptionLevel desc_level) {
1275 uint32_t num_matches = 0;
1276 if (module) {
1277 SymbolContextList sc_list;
1278 num_matches = module->ResolveSymbolContextsForFileSpec(
1279 file_spec, 0, false, eSymbolContextCompUnit, sc_list);
1280
1281 bool first_module = true;
1282 for (const SymbolContext &sc : sc_list) {
1283 if (!first_module)
1284 strm << "\n\n";
1285
1286 strm << "Line table for " << sc.comp_unit->GetPrimaryFile() << " in `"
1287 << module->GetFileSpec().GetFilename() << "\n";
1288 LineTable *line_table = sc.comp_unit->GetLineTable();
1289 if (line_table)
1290 line_table->GetDescription(
1291 &strm, interpreter.GetExecutionContext().GetTargetPtr(),
1292 desc_level);
1293 else
1294 strm << "No line table";
1295
1296 first_module = false;
1297 }
1298 }
1299 return num_matches;
1300}
1301
1302static void DumpFullpath(Stream &strm, const FileSpec *file_spec_ptr,
1303 uint32_t width) {
1304 if (file_spec_ptr) {
1305 if (width > 0) {
1306 std::string fullpath = file_spec_ptr->GetPath();
1307 strm.Printf("%-*s", width, fullpath.c_str());
1308 return;
1309 } else {
1310 file_spec_ptr->Dump(strm.AsRawOstream());
1311 return;
1312 }
1313 }
1314 // Keep the width spacing correct if things go wrong...
1315 if (width > 0)
1316 strm.Printf("%-*s", width, "");
1317}
1318
1319static void DumpDirectory(Stream &strm, const FileSpec *file_spec_ptr,
1320 uint32_t width) {
1321 if (file_spec_ptr) {
1322 if (width > 0)
1323 strm.Printf("%-*s", width, file_spec_ptr->GetDirectory().AsCString(""));
1324 else
1325 file_spec_ptr->GetDirectory().Dump(&strm);
1326 return;
1327 }
1328 // Keep the width spacing correct if things go wrong...
1329 if (width > 0)
1330 strm.Printf("%-*s", width, "");
1331}
1332
1333static void DumpBasename(Stream &strm, const FileSpec *file_spec_ptr,
1334 uint32_t width) {
1335 if (file_spec_ptr) {
1336 if (width > 0)
1337 strm.Printf("%-*s", width, file_spec_ptr->GetFilename().AsCString(""));
1338 else
1339 file_spec_ptr->GetFilename().Dump(&strm);
1340 return;
1341 }
1342 // Keep the width spacing correct if things go wrong...
1343 if (width > 0)
1344 strm.Printf("%-*s", width, "");
1345}
1346
1347static size_t DumpModuleObjfileHeaders(Stream &strm, ModuleList &module_list) {
1348 std::lock_guard<std::recursive_mutex> guard(module_list.GetMutex());
1349 const size_t num_modules = module_list.GetSize();
1350 if (num_modules == 0)
1351 return 0;
1352
1353 size_t num_dumped = 0;
1354 strm.Format("Dumping headers for {0} module(s).\n", num_modules);
1355 strm.IndentMore();
1356 for (ModuleSP module_sp : module_list.ModulesNoLocking()) {
1357 if (module_sp) {
1358 if (num_dumped++ > 0) {
1359 strm.EOL();
1360 strm.EOL();
1361 }
1362 ObjectFile *objfile = module_sp->GetObjectFile();
1363 if (objfile)
1364 objfile->Dump(&strm);
1365 else {
1366 strm.Format("No object file for module: {0:F}\n",
1367 module_sp->GetFileSpec());
1368 }
1369 }
1370 }
1371 strm.IndentLess();
1372 return num_dumped;
1373}
1374
1375static void DumpModuleSymtab(CommandInterpreter &interpreter, Stream &strm,
1376 Module *module, SortOrder sort_order,
1377 Mangled::NamePreference name_preference) {
1378 if (!module)
1379 return;
1380 if (Symtab *symtab = module->GetSymtab())
1381 symtab->Dump(&strm, interpreter.GetExecutionContext().GetTargetPtr(),
1382 sort_order, name_preference);
1383}
1384
1385static void DumpModuleSections(CommandInterpreter &interpreter, Stream &strm,
1386 Module *module) {
1387 if (module) {
1388 SectionList *section_list = module->GetSectionList();
1389 if (section_list) {
1390 strm.Printf("Sections for '%s' (%s):\n",
1391 module->GetSpecificationDescription().c_str(),
1393 section_list->Dump(strm.AsRawOstream(), strm.GetIndentLevel() + 2,
1394 interpreter.GetExecutionContext().GetTargetPtr(), true,
1395 UINT32_MAX);
1396 }
1397 }
1398}
1399
1400static bool DumpModuleSymbolFile(Stream &strm, Module *module) {
1401 if (module) {
1402 if (SymbolFile *symbol_file = module->GetSymbolFile(true)) {
1403 symbol_file->Dump(strm);
1404 return true;
1405 }
1406 }
1407 return false;
1408}
1409
1411 Module *module, bool errors_only) {
1412 if (module) {
1413 if (SymbolFile *symbol_file = module->GetSymbolFile(/*can_create=*/true)) {
1415 if (symbol_file->GetSeparateDebugInfo(d, errors_only)) {
1416 list.AddItem(
1417 std::make_shared<StructuredData::Dictionary>(std::move(d)));
1418 return true;
1419 }
1420 }
1421 }
1422 return false;
1423}
1424
1425static void DumpDwoFilesTable(Stream &strm,
1426 StructuredData::Array &dwo_listings) {
1427 strm.PutCString("Dwo ID Err Dwo Path");
1428 strm.EOL();
1429 strm.PutCString(
1430 "------------------ --- -----------------------------------------");
1431 strm.EOL();
1432 dwo_listings.ForEach([&strm](StructuredData::Object *dwo) {
1434 if (!dict)
1435 return false;
1436
1437 uint64_t dwo_id;
1438 if (dict->GetValueForKeyAsInteger("dwo_id", dwo_id))
1439 strm.Printf("0x%16.16" PRIx64 " ", dwo_id);
1440 else
1441 strm.Printf("0x???????????????? ");
1442
1443 llvm::StringRef error;
1444 if (dict->GetValueForKeyAsString("error", error))
1445 strm << "E " << error;
1446 else {
1447 llvm::StringRef resolved_dwo_path;
1448 if (dict->GetValueForKeyAsString("resolved_dwo_path",
1449 resolved_dwo_path)) {
1450 strm << " " << resolved_dwo_path;
1451 if (resolved_dwo_path.ends_with(".dwp")) {
1452 llvm::StringRef dwo_name;
1453 if (dict->GetValueForKeyAsString("dwo_name", dwo_name))
1454 strm << "(" << dwo_name << ")";
1455 }
1456 }
1457 }
1458 strm.EOL();
1459 return true;
1460 });
1461}
1462
1463static void DumpOsoFilesTable(Stream &strm,
1464 StructuredData::Array &oso_listings) {
1465 strm.PutCString("Mod Time Err Oso Path");
1466 strm.EOL();
1467 strm.PutCString("------------------ --- ---------------------");
1468 strm.EOL();
1469 oso_listings.ForEach([&strm](StructuredData::Object *oso) {
1471 if (!dict)
1472 return false;
1473
1474 uint32_t oso_mod_time;
1475 if (dict->GetValueForKeyAsInteger("oso_mod_time", oso_mod_time))
1476 strm.Printf("0x%16.16" PRIx32 " ", oso_mod_time);
1477
1478 llvm::StringRef error;
1479 if (dict->GetValueForKeyAsString("error", error))
1480 strm << "E " << error;
1481 else {
1482 llvm::StringRef oso_path;
1483 if (dict->GetValueForKeyAsString("oso_path", oso_path))
1484 strm << " " << oso_path;
1485 }
1486 strm.EOL();
1487 return true;
1488 });
1489}
1490
1491static void
1492DumpAddress(ExecutionContextScope *exe_scope, const Address &so_addr,
1493 bool verbose, bool all_ranges, Stream &strm,
1494 std::optional<Stream::HighlightSettings> settings = std::nullopt) {
1495 strm.IndentMore();
1496 strm.Indent(" Address: ");
1497 so_addr.Dump(&strm, exe_scope, Address::DumpStyleModuleWithFileAddress);
1498 strm.PutCString(" (");
1499 so_addr.Dump(&strm, exe_scope, Address::DumpStyleSectionNameOffset);
1500 strm.PutCString(")\n");
1501 strm.Indent(" Summary: ");
1502 const uint32_t save_indent = strm.GetIndentLevel();
1503 strm.SetIndentLevel(save_indent + 13);
1504 so_addr.Dump(&strm, exe_scope, Address::DumpStyleResolvedDescription,
1505 Address::DumpStyleInvalid, UINT32_MAX, false, settings);
1506 strm.SetIndentLevel(save_indent);
1507 // Print out detailed address information when verbose is enabled
1508 if (verbose) {
1509 strm.EOL();
1510 so_addr.Dump(&strm, exe_scope, Address::DumpStyleDetailedSymbolContext,
1511 Address::DumpStyleInvalid, UINT32_MAX, all_ranges, settings);
1512 }
1513 strm.IndentLess();
1514}
1515
1516static bool LookupAddressInModule(CommandInterpreter &interpreter, Stream &strm,
1517 Module *module, uint32_t resolve_mask,
1518 lldb::addr_t raw_addr, lldb::addr_t offset,
1519 bool verbose, bool all_ranges) {
1520 if (module) {
1521 lldb::addr_t addr = raw_addr - offset;
1522 Address so_addr;
1523 SymbolContext sc;
1524 Target *target = interpreter.GetExecutionContext().GetTargetPtr();
1525 if (target && !target->GetSectionLoadList().IsEmpty()) {
1526 if (!target->GetSectionLoadList().ResolveLoadAddress(addr, so_addr))
1527 return false;
1528 else if (so_addr.GetModule().get() != module)
1529 return false;
1530 } else {
1531 if (!module->ResolveFileAddress(addr, so_addr))
1532 return false;
1533 }
1534
1535 ExecutionContextScope *exe_scope =
1537 DumpAddress(exe_scope, so_addr, verbose, all_ranges, strm);
1538 return true;
1539 }
1540
1541 return false;
1542}
1543
1544static uint32_t LookupSymbolInModule(CommandInterpreter &interpreter,
1545 Stream &strm, Module *module,
1546 const char *name, bool name_is_regex,
1547 bool verbose, bool all_ranges) {
1548 if (!module)
1549 return 0;
1550
1551 Symtab *symtab = module->GetSymtab();
1552 if (!symtab)
1553 return 0;
1554
1555 SymbolContext sc;
1556 const bool use_color = interpreter.GetDebugger().GetUseColor();
1557 std::vector<uint32_t> match_indexes;
1558 ConstString symbol_name(name);
1559 uint32_t num_matches = 0;
1560 if (name_is_regex) {
1561 RegularExpression name_regexp(symbol_name.GetStringRef());
1562 num_matches = symtab->AppendSymbolIndexesMatchingRegExAndType(
1563 name_regexp, eSymbolTypeAny, match_indexes);
1564 } else {
1565 num_matches =
1566 symtab->AppendSymbolIndexesWithName(symbol_name, match_indexes);
1567 }
1568
1569 if (num_matches > 0) {
1570 strm.Indent();
1571 strm.Printf("%u symbols match %s'%s' in ", num_matches,
1572 name_is_regex ? "the regular expression " : "", name);
1573 DumpFullpath(strm, &module->GetFileSpec(), 0);
1574 strm.PutCString(":\n");
1575 strm.IndentMore();
1577 name, interpreter.GetDebugger().GetRegexMatchAnsiPrefix(),
1578 interpreter.GetDebugger().GetRegexMatchAnsiSuffix());
1579 for (uint32_t i = 0; i < num_matches; ++i) {
1580 Symbol *symbol = symtab->SymbolAtIndex(match_indexes[i]);
1581 if (symbol) {
1582 if (symbol->ValueIsAddress()) {
1585 symbol->GetAddressRef(), verbose, all_ranges, strm,
1586 use_color && name_is_regex
1587 ? std::optional<Stream::HighlightSettings>{settings}
1588 : std::nullopt);
1589 strm.EOL();
1590 } else {
1591 strm.IndentMore();
1592 strm.Indent(" Name: ");
1594 symbol->GetDisplayName().GetStringRef(),
1595 use_color && name_is_regex
1596 ? std::optional<Stream::HighlightSettings>{settings}
1597 : std::nullopt);
1598 strm.EOL();
1599 strm.Indent(" Value: ");
1600 strm.Printf("0x%16.16" PRIx64 "\n", symbol->GetRawValue());
1601 if (symbol->GetByteSizeIsValid()) {
1602 strm.Indent(" Size: ");
1603 strm.Printf("0x%16.16" PRIx64 "\n", symbol->GetByteSize());
1604 }
1605 strm.IndentLess();
1606 }
1607 }
1608 }
1609 strm.IndentLess();
1610 }
1611 return num_matches;
1612}
1613
1615 ExecutionContextScope *exe_scope, Stream &strm,
1616 const SymbolContextList &sc_list, bool verbose, bool all_ranges,
1617 std::optional<Stream::HighlightSettings> settings = std::nullopt) {
1618 strm.IndentMore();
1619 bool first_module = true;
1620 for (const SymbolContext &sc : sc_list) {
1621 if (!first_module)
1622 strm.EOL();
1623
1624 AddressRange range;
1625
1626 sc.GetAddressRange(eSymbolContextEverything, 0, true, range);
1627
1628 DumpAddress(exe_scope, range.GetBaseAddress(), verbose, all_ranges, strm,
1629 settings);
1630 first_module = false;
1631 }
1632 strm.IndentLess();
1633}
1634
1636 Stream &strm, Module *module,
1637 const char *name, bool name_is_regex,
1638 const ModuleFunctionSearchOptions &options,
1639 bool verbose, bool all_ranges) {
1640 if (module && name && name[0]) {
1641 SymbolContextList sc_list;
1642 size_t num_matches = 0;
1643 if (name_is_regex) {
1644 RegularExpression function_name_regex((llvm::StringRef(name)));
1645 module->FindFunctions(function_name_regex, options, sc_list);
1646 } else {
1647 ConstString function_name(name);
1648 module->FindFunctions(function_name, CompilerDeclContext(),
1649 eFunctionNameTypeAuto, options, sc_list);
1650 }
1651 num_matches = sc_list.GetSize();
1652 if (num_matches) {
1653 strm.Indent();
1654 strm.Printf("%" PRIu64 " match%s found in ", (uint64_t)num_matches,
1655 num_matches > 1 ? "es" : "");
1656 DumpFullpath(strm, &module->GetFileSpec(), 0);
1657 strm.PutCString(":\n");
1660 strm, sc_list, verbose, all_ranges);
1661 }
1662 return num_matches;
1663 }
1664 return 0;
1665}
1666
1667static size_t LookupTypeInModule(Target *target,
1668 CommandInterpreter &interpreter, Stream &strm,
1669 Module *module, const char *name_cstr,
1670 bool name_is_regex) {
1671 if (module && name_cstr && name_cstr[0]) {
1672 TypeQuery query(name_cstr);
1673 TypeResults results;
1674 module->FindTypes(query, results);
1675
1676 TypeList type_list;
1677 SymbolContext sc;
1678 if (module)
1679 sc.module_sp = module->shared_from_this();
1680 // Sort the type results and put the results that matched in \a module
1681 // first if \a module was specified.
1682 sc.SortTypeList(results.GetTypeMap(), type_list);
1683 if (type_list.Empty())
1684 return 0;
1685
1686 const uint64_t num_matches = type_list.GetSize();
1687
1688 strm.Indent();
1689 strm.Printf("%" PRIu64 " match%s found in ", num_matches,
1690 num_matches > 1 ? "es" : "");
1691 DumpFullpath(strm, &module->GetFileSpec(), 0);
1692 strm.PutCString(":\n");
1693 for (TypeSP type_sp : type_list.Types()) {
1694 if (!type_sp)
1695 continue;
1696 // Resolve the clang type so that any forward references to types
1697 // that haven't yet been parsed will get parsed.
1698 type_sp->GetFullCompilerType();
1699 type_sp->GetDescription(&strm, eDescriptionLevelFull, true, target);
1700 // Print all typedef chains
1701 TypeSP typedef_type_sp(type_sp);
1702 TypeSP typedefed_type_sp(typedef_type_sp->GetTypedefType());
1703 while (typedefed_type_sp) {
1704 strm.EOL();
1705 strm.Printf(" typedef '%s': ",
1706 typedef_type_sp->GetName().GetCString());
1707 typedefed_type_sp->GetFullCompilerType();
1708 typedefed_type_sp->GetDescription(&strm, eDescriptionLevelFull, true,
1709 target);
1710 typedef_type_sp = typedefed_type_sp;
1711 typedefed_type_sp = typedef_type_sp->GetTypedefType();
1712 }
1713 strm.EOL();
1714 }
1715 return type_list.GetSize();
1716 }
1717 return 0;
1718}
1719
1720static size_t LookupTypeHere(Target *target, CommandInterpreter &interpreter,
1721 Stream &strm, Module &module,
1722 const char *name_cstr, bool name_is_regex) {
1723 TypeQuery query(name_cstr);
1724 TypeResults results;
1725 module.FindTypes(query, results);
1726 TypeList type_list;
1727 SymbolContext sc;
1728 sc.module_sp = module.shared_from_this();
1729 sc.SortTypeList(results.GetTypeMap(), type_list);
1730 if (type_list.Empty())
1731 return 0;
1732
1733 strm.Indent();
1734 strm.PutCString("Best match found in ");
1735 DumpFullpath(strm, &module.GetFileSpec(), 0);
1736 strm.PutCString(":\n");
1737
1738 TypeSP type_sp(type_list.GetTypeAtIndex(0));
1739 if (type_sp) {
1740 // Resolve the clang type so that any forward references to types that
1741 // haven't yet been parsed will get parsed.
1742 type_sp->GetFullCompilerType();
1743 type_sp->GetDescription(&strm, eDescriptionLevelFull, true, target);
1744 // Print all typedef chains.
1745 TypeSP typedef_type_sp(type_sp);
1746 TypeSP typedefed_type_sp(typedef_type_sp->GetTypedefType());
1747 while (typedefed_type_sp) {
1748 strm.EOL();
1749 strm.Printf(" typedef '%s': ",
1750 typedef_type_sp->GetName().GetCString());
1751 typedefed_type_sp->GetFullCompilerType();
1752 typedefed_type_sp->GetDescription(&strm, eDescriptionLevelFull, true,
1753 target);
1754 typedef_type_sp = typedefed_type_sp;
1755 typedefed_type_sp = typedef_type_sp->GetTypedefType();
1756 }
1757 }
1758 strm.EOL();
1759 return type_list.GetSize();
1760}
1761
1763 Stream &strm, Module *module,
1764 const FileSpec &file_spec,
1765 uint32_t line, bool check_inlines,
1766 bool verbose, bool all_ranges) {
1767 if (module && file_spec) {
1768 SymbolContextList sc_list;
1769 const uint32_t num_matches = module->ResolveSymbolContextsForFileSpec(
1770 file_spec, line, check_inlines, eSymbolContextEverything, sc_list);
1771 if (num_matches > 0) {
1772 strm.Indent();
1773 strm.Printf("%u match%s found in ", num_matches,
1774 num_matches > 1 ? "es" : "");
1775 strm << file_spec;
1776 if (line > 0)
1777 strm.Printf(":%u", line);
1778 strm << " in ";
1779 DumpFullpath(strm, &module->GetFileSpec(), 0);
1780 strm.PutCString(":\n");
1783 strm, sc_list, verbose, all_ranges);
1784 return num_matches;
1785 }
1786 }
1787 return 0;
1788}
1789
1790static size_t FindModulesByName(Target *target, const char *module_name,
1791 ModuleList &module_list,
1792 bool check_global_list) {
1793 FileSpec module_file_spec(module_name);
1794 ModuleSpec module_spec(module_file_spec);
1795
1796 const size_t initial_size = module_list.GetSize();
1797
1798 if (check_global_list) {
1799 // Check the global list
1800 std::lock_guard<std::recursive_mutex> guard(
1802 const size_t num_modules = Module::GetNumberAllocatedModules();
1803 ModuleSP module_sp;
1804 for (size_t image_idx = 0; image_idx < num_modules; ++image_idx) {
1805 Module *module = Module::GetAllocatedModuleAtIndex(image_idx);
1806
1807 if (module) {
1808 if (module->MatchesModuleSpec(module_spec)) {
1809 module_sp = module->shared_from_this();
1810 module_list.AppendIfNeeded(module_sp);
1811 }
1812 }
1813 }
1814 } else {
1815 if (target) {
1816 target->GetImages().FindModules(module_spec, module_list);
1817 const size_t num_matches = module_list.GetSize();
1818
1819 // Not found in our module list for our target, check the main shared
1820 // module list in case it is a extra file used somewhere else
1821 if (num_matches == 0) {
1822 module_spec.GetArchitecture() = target->GetArchitecture();
1823 ModuleList::FindSharedModules(module_spec, module_list);
1824 }
1825 } else {
1826 ModuleList::FindSharedModules(module_spec, module_list);
1827 }
1828 }
1829
1830 return module_list.GetSize() - initial_size;
1831}
1832
1833#pragma mark CommandObjectTargetModulesModuleAutoComplete
1834
1835// A base command object class that can auto complete with module file
1836// paths
1837
1839 : public CommandObjectParsed {
1840public:
1842 const char *name,
1843 const char *help,
1844 const char *syntax,
1845 uint32_t flags = 0)
1846 : CommandObjectParsed(interpreter, name, help, syntax, flags) {
1848 }
1849
1851
1852 void
1854 OptionElementVector &opt_element_vector) override {
1856 GetCommandInterpreter(), lldb::eModuleCompletion, request, nullptr);
1857 }
1858};
1859
1860#pragma mark CommandObjectTargetModulesSourceFileAutoComplete
1861
1862// A base command object class that can auto complete with module source
1863// file paths
1864
1866 : public CommandObjectParsed {
1867public:
1869 CommandInterpreter &interpreter, const char *name, const char *help,
1870 const char *syntax, uint32_t flags)
1871 : CommandObjectParsed(interpreter, name, help, syntax, flags) {
1873 }
1874
1876
1877 void
1879 OptionElementVector &opt_element_vector) override {
1882 }
1883};
1884
1885#pragma mark CommandObjectTargetModulesDumpObjfile
1886
1889public:
1892 interpreter, "target modules dump objfile",
1893 "Dump the object file headers from one or more target modules.",
1894 nullptr, eCommandRequiresTarget) {}
1895
1897
1898protected:
1899 void DoExecute(Args &command, CommandReturnObject &result) override {
1900 Target &target = GetTarget();
1901
1902 uint32_t addr_byte_size = target.GetArchitecture().GetAddressByteSize();
1903 result.GetOutputStream().SetAddressByteSize(addr_byte_size);
1904 result.GetErrorStream().SetAddressByteSize(addr_byte_size);
1905
1906 size_t num_dumped = 0;
1907 if (command.GetArgumentCount() == 0) {
1908 // Dump all headers for all modules images
1909 num_dumped = DumpModuleObjfileHeaders(result.GetOutputStream(),
1910 target.GetImages());
1911 if (num_dumped == 0) {
1912 result.AppendError("the target has no associated executable images");
1913 }
1914 } else {
1915 // Find the modules that match the basename or full path.
1916 ModuleList module_list;
1917 const char *arg_cstr;
1918 for (int arg_idx = 0;
1919 (arg_cstr = command.GetArgumentAtIndex(arg_idx)) != nullptr;
1920 ++arg_idx) {
1921 size_t num_matched =
1922 FindModulesByName(&target, arg_cstr, module_list, true);
1923 if (num_matched == 0) {
1925 "Unable to find an image that matches '%s'.\n", arg_cstr);
1926 }
1927 }
1928 // Dump all the modules we found.
1929 num_dumped =
1930 DumpModuleObjfileHeaders(result.GetOutputStream(), module_list);
1931 }
1932
1933 if (num_dumped > 0) {
1935 } else {
1936 result.AppendError("no matching executable images found");
1937 }
1938 }
1939};
1940
1941#define LLDB_OPTIONS_target_modules_dump_symtab
1942#include "CommandOptions.inc"
1943
1946public:
1949 interpreter, "target modules dump symtab",
1950 "Dump the symbol table from one or more target modules.", nullptr,
1951 eCommandRequiresTarget) {}
1952
1954
1955 Options *GetOptions() override { return &m_options; }
1956
1957 class CommandOptions : public Options {
1958 public:
1959 CommandOptions() = default;
1960
1961 ~CommandOptions() override = default;
1962
1963 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
1964 ExecutionContext *execution_context) override {
1965 Status error;
1966 const int short_option = m_getopt_table[option_idx].val;
1967
1968 switch (short_option) {
1969 case 'm':
1972 break;
1973
1974 case 's':
1976 option_arg, GetDefinitions()[option_idx].enum_values,
1978 break;
1979
1980 default:
1981 llvm_unreachable("Unimplemented option");
1982 }
1983 return error;
1984 }
1985
1986 void OptionParsingStarting(ExecutionContext *execution_context) override {
1989 }
1990
1991 llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
1992 return llvm::ArrayRef(g_target_modules_dump_symtab_options);
1993 }
1994
1997 };
1998
1999protected:
2000 void DoExecute(Args &command, CommandReturnObject &result) override {
2001 Target &target = GetTarget();
2002 uint32_t num_dumped = 0;
2003 Mangled::NamePreference name_preference =
2006
2007 uint32_t addr_byte_size = target.GetArchitecture().GetAddressByteSize();
2008 result.GetOutputStream().SetAddressByteSize(addr_byte_size);
2009 result.GetErrorStream().SetAddressByteSize(addr_byte_size);
2010
2011 if (command.GetArgumentCount() == 0) {
2012 // Dump all sections for all modules images
2013 const ModuleList &module_list = target.GetImages();
2014 std::lock_guard<std::recursive_mutex> guard(module_list.GetMutex());
2015 const size_t num_modules = module_list.GetSize();
2016 if (num_modules > 0) {
2017 result.GetOutputStream().Format(
2018 "Dumping symbol table for {0} modules.\n", num_modules);
2019 for (ModuleSP module_sp : module_list.ModulesNoLocking()) {
2020 if (num_dumped > 0) {
2021 result.GetOutputStream().EOL();
2022 result.GetOutputStream().EOL();
2023 }
2025 "Interrupted in dump all symtabs with {0} "
2026 "of {1} dumped.", num_dumped, num_modules))
2027 break;
2028
2029 num_dumped++;
2031 module_sp.get(), m_options.m_sort_order,
2032 name_preference);
2033 }
2034 } else {
2035 result.AppendError("the target has no associated executable images");
2036 return;
2037 }
2038 } else {
2039 // Dump specified images (by basename or fullpath)
2040 const char *arg_cstr;
2041 for (int arg_idx = 0;
2042 (arg_cstr = command.GetArgumentAtIndex(arg_idx)) != nullptr;
2043 ++arg_idx) {
2044 ModuleList module_list;
2045 const size_t num_matches =
2046 FindModulesByName(&target, arg_cstr, module_list, true);
2047 if (num_matches > 0) {
2048 for (ModuleSP module_sp : module_list.Modules()) {
2049 if (module_sp) {
2050 if (num_dumped > 0) {
2051 result.GetOutputStream().EOL();
2052 result.GetOutputStream().EOL();
2053 }
2055 "Interrupted in dump symtab list with {0} of {1} dumped.",
2056 num_dumped, num_matches))
2057 break;
2058
2059 num_dumped++;
2061 module_sp.get(), m_options.m_sort_order,
2062 name_preference);
2063 }
2064 }
2065 } else
2067 "Unable to find an image that matches '%s'.\n", arg_cstr);
2068 }
2069 }
2070
2071 if (num_dumped > 0)
2073 else {
2074 result.AppendError("no matching executable images found");
2075 }
2076 }
2077
2079};
2080
2081#pragma mark CommandObjectTargetModulesDumpSections
2082
2083// Image section dumping command
2084
2087public:
2090 interpreter, "target modules dump sections",
2091 "Dump the sections from one or more target modules.",
2092 //"target modules dump sections [<file1> ...]")
2093 nullptr, eCommandRequiresTarget) {}
2094
2096
2097protected:
2098 void DoExecute(Args &command, CommandReturnObject &result) override {
2099 Target &target = GetTarget();
2100 uint32_t num_dumped = 0;
2101
2102 uint32_t addr_byte_size = target.GetArchitecture().GetAddressByteSize();
2103 result.GetOutputStream().SetAddressByteSize(addr_byte_size);
2104 result.GetErrorStream().SetAddressByteSize(addr_byte_size);
2105
2106 if (command.GetArgumentCount() == 0) {
2107 // Dump all sections for all modules images
2108 const size_t num_modules = target.GetImages().GetSize();
2109 if (num_modules == 0) {
2110 result.AppendError("the target has no associated executable images");
2111 return;
2112 }
2113
2114 result.GetOutputStream().Format("Dumping sections for {0} modules.\n",
2115 num_modules);
2116 for (size_t image_idx = 0; image_idx < num_modules; ++image_idx) {
2118 "Interrupted in dump all sections with {0} of {1} dumped",
2119 image_idx, num_modules))
2120 break;
2121
2122 num_dumped++;
2125 target.GetImages().GetModulePointerAtIndex(image_idx));
2126 }
2127 } else {
2128 // Dump specified images (by basename or fullpath)
2129 const char *arg_cstr;
2130 for (int arg_idx = 0;
2131 (arg_cstr = command.GetArgumentAtIndex(arg_idx)) != nullptr;
2132 ++arg_idx) {
2133 ModuleList module_list;
2134 const size_t num_matches =
2135 FindModulesByName(&target, arg_cstr, module_list, true);
2136 if (num_matches > 0) {
2137 for (size_t i = 0; i < num_matches; ++i) {
2139 "Interrupted in dump section list with {0} of {1} dumped.",
2140 i, num_matches))
2141 break;
2142
2143 Module *module = module_list.GetModulePointerAtIndex(i);
2144 if (module) {
2145 num_dumped++;
2147 module);
2148 }
2149 }
2150 } else {
2151 // Check the global list
2152 std::lock_guard<std::recursive_mutex> guard(
2154
2156 "Unable to find an image that matches '%s'.\n", arg_cstr);
2157 }
2158 }
2159 }
2160
2161 if (num_dumped > 0)
2163 else {
2164 result.AppendError("no matching executable images found");
2165 }
2166 }
2167};
2168
2170public:
2173 interpreter, "target modules dump pcm-info",
2174 "Dump information about the given clang module (pcm).") {
2175 // Take a single file argument.
2177 }
2178
2180
2181protected:
2182 void DoExecute(Args &command, CommandReturnObject &result) override {
2183 if (command.GetArgumentCount() != 1) {
2184 result.AppendErrorWithFormat("'%s' takes exactly one pcm path argument.",
2185 m_cmd_name.c_str());
2186 return;
2187 }
2188
2189 const char *pcm_path = command.GetArgumentAtIndex(0);
2190 const FileSpec pcm_file{pcm_path};
2191
2192 if (pcm_file.GetFileNameExtension() != ".pcm") {
2193 result.AppendError("file must have a .pcm extension");
2194 return;
2195 }
2196
2197 if (!FileSystem::Instance().Exists(pcm_file)) {
2198 result.AppendError("pcm file does not exist");
2199 return;
2200 }
2201
2202 clang::CompilerInstance compiler;
2203 compiler.createDiagnostics(*FileSystem::Instance().GetVirtualFileSystem());
2204
2205 const char *clang_args[] = {"clang", pcm_path};
2206 compiler.setInvocation(clang::createInvocation(clang_args));
2207
2208 // Pass empty deleter to not attempt to free memory that was allocated
2209 // outside of the current scope, possibly statically.
2210 std::shared_ptr<llvm::raw_ostream> Out(
2211 &result.GetOutputStream().AsRawOstream(), [](llvm::raw_ostream *) {});
2212 clang::DumpModuleInfoAction dump_module_info(Out);
2213 // DumpModuleInfoAction requires ObjectFilePCHContainerReader.
2214 compiler.getPCHContainerOperations()->registerReader(
2215 std::make_unique<clang::ObjectFilePCHContainerReader>());
2216
2217 if (compiler.ExecuteAction(dump_module_info))
2219 }
2220};
2221
2222#pragma mark CommandObjectTargetModulesDumpClangAST
2223
2224// Clang AST dumping command
2225
2228public:
2231 interpreter, "target modules dump ast",
2232 "Dump the clang ast for a given module's symbol file.",
2233 //"target modules dump ast [<file1> ...]")
2234 nullptr, eCommandRequiresTarget) {}
2235
2237
2238protected:
2239 void DoExecute(Args &command, CommandReturnObject &result) override {
2240 Target &target = GetTarget();
2241
2242 const ModuleList &module_list = target.GetImages();
2243 const size_t num_modules = module_list.GetSize();
2244 if (num_modules == 0) {
2245 result.AppendError("the target has no associated executable images");
2246 return;
2247 }
2248
2249 if (command.GetArgumentCount() == 0) {
2250 // Dump all ASTs for all modules images
2251 result.GetOutputStream().Format("Dumping clang ast for {0} modules.\n",
2252 num_modules);
2253 for (ModuleSP module_sp : module_list.ModulesNoLocking()) {
2254 if (INTERRUPT_REQUESTED(GetDebugger(), "Interrupted dumping clang ast"))
2255 break;
2256 if (SymbolFile *sf = module_sp->GetSymbolFile())
2257 sf->DumpClangAST(result.GetOutputStream());
2258 }
2260 return;
2261 }
2262
2263 // Dump specified ASTs (by basename or fullpath)
2264 for (const Args::ArgEntry &arg : command.entries()) {
2265 ModuleList module_list;
2266 const size_t num_matches =
2267 FindModulesByName(&target, arg.c_str(), module_list, true);
2268 if (num_matches == 0) {
2269 // Check the global list
2270 std::lock_guard<std::recursive_mutex> guard(
2272
2274 "Unable to find an image that matches '%s'.\n", arg.c_str());
2275 continue;
2276 }
2277
2278 for (size_t i = 0; i < num_matches; ++i) {
2280 "Interrupted in dump clang ast list with {0} of {1} dumped.",
2281 i, num_matches))
2282 break;
2283
2284 Module *m = module_list.GetModulePointerAtIndex(i);
2285 if (SymbolFile *sf = m->GetSymbolFile())
2286 sf->DumpClangAST(result.GetOutputStream());
2287 }
2288 }
2290 }
2291};
2292
2293#pragma mark CommandObjectTargetModulesDumpSymfile
2294
2295// Image debug symbol dumping command
2296
2299public:
2302 interpreter, "target modules dump symfile",
2303 "Dump the debug symbol file for one or more target modules.",
2304 //"target modules dump symfile [<file1> ...]")
2305 nullptr, eCommandRequiresTarget) {}
2306
2308
2309protected:
2310 void DoExecute(Args &command, CommandReturnObject &result) override {
2311 Target &target = GetTarget();
2312 uint32_t num_dumped = 0;
2313
2314 uint32_t addr_byte_size = target.GetArchitecture().GetAddressByteSize();
2315 result.GetOutputStream().SetAddressByteSize(addr_byte_size);
2316 result.GetErrorStream().SetAddressByteSize(addr_byte_size);
2317
2318 if (command.GetArgumentCount() == 0) {
2319 // Dump all sections for all modules images
2320 const ModuleList &target_modules = target.GetImages();
2321 std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());
2322 const size_t num_modules = target_modules.GetSize();
2323 if (num_modules == 0) {
2324 result.AppendError("the target has no associated executable images");
2325 return;
2326 }
2327 result.GetOutputStream().Format(
2328 "Dumping debug symbols for {0} modules.\n", num_modules);
2329 for (ModuleSP module_sp : target_modules.ModulesNoLocking()) {
2330 if (INTERRUPT_REQUESTED(GetDebugger(), "Interrupted in dumping all "
2331 "debug symbols with {0} of {1} modules dumped",
2332 num_dumped, num_modules))
2333 break;
2334
2335 if (DumpModuleSymbolFile(result.GetOutputStream(), module_sp.get()))
2336 num_dumped++;
2337 }
2338 } else {
2339 // Dump specified images (by basename or fullpath)
2340 const char *arg_cstr;
2341 for (int arg_idx = 0;
2342 (arg_cstr = command.GetArgumentAtIndex(arg_idx)) != nullptr;
2343 ++arg_idx) {
2344 ModuleList module_list;
2345 const size_t num_matches =
2346 FindModulesByName(&target, arg_cstr, module_list, true);
2347 if (num_matches > 0) {
2348 for (size_t i = 0; i < num_matches; ++i) {
2349 if (INTERRUPT_REQUESTED(GetDebugger(), "Interrupted dumping {0} "
2350 "of {1} requested modules",
2351 i, num_matches))
2352 break;
2353 Module *module = module_list.GetModulePointerAtIndex(i);
2354 if (module) {
2355 if (DumpModuleSymbolFile(result.GetOutputStream(), module))
2356 num_dumped++;
2357 }
2358 }
2359 } else
2361 "Unable to find an image that matches '%s'.\n", arg_cstr);
2362 }
2363 }
2364
2365 if (num_dumped > 0)
2367 else {
2368 result.AppendError("no matching executable images found");
2369 }
2370 }
2371};
2372
2373#pragma mark CommandObjectTargetModulesDumpLineTable
2374#define LLDB_OPTIONS_target_modules_dump
2375#include "CommandOptions.inc"
2376
2377// Image debug line table dumping command
2378
2381public:
2384 interpreter, "target modules dump line-table",
2385 "Dump the line table for one or more compilation units.", nullptr,
2386 eCommandRequiresTarget) {}
2387
2389
2390 Options *GetOptions() override { return &m_options; }
2391
2392protected:
2393 void DoExecute(Args &command, CommandReturnObject &result) override {
2394 Target *target = m_exe_ctx.GetTargetPtr();
2395 uint32_t total_num_dumped = 0;
2396
2397 uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
2398 result.GetOutputStream().SetAddressByteSize(addr_byte_size);
2399 result.GetErrorStream().SetAddressByteSize(addr_byte_size);
2400
2401 if (command.GetArgumentCount() == 0) {
2402 result.AppendError("file option must be specified.");
2403 return;
2404 } else {
2405 // Dump specified images (by basename or fullpath)
2406 const char *arg_cstr;
2407 for (int arg_idx = 0;
2408 (arg_cstr = command.GetArgumentAtIndex(arg_idx)) != nullptr;
2409 ++arg_idx) {
2410 FileSpec file_spec(arg_cstr);
2411
2412 const ModuleList &target_modules = target->GetImages();
2413 std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());
2414 size_t num_modules = target_modules.GetSize();
2415 if (num_modules > 0) {
2416 uint32_t num_dumped = 0;
2417 for (ModuleSP module_sp : target_modules.ModulesNoLocking()) {
2419 "Interrupted in dump all line tables with "
2420 "{0} of {1} dumped", num_dumped,
2421 num_modules))
2422 break;
2423
2425 m_interpreter, result.GetOutputStream(), module_sp.get(),
2426 file_spec,
2429 num_dumped++;
2430 }
2431 if (num_dumped == 0)
2433 "No source filenames matched '%s'.\n", arg_cstr);
2434 else
2435 total_num_dumped += num_dumped;
2436 }
2437 }
2438 }
2439
2440 if (total_num_dumped > 0)
2442 else {
2443 result.AppendError("no source filenames matched any command arguments");
2444 }
2445 }
2446
2447 class CommandOptions : public Options {
2448 public:
2450
2451 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
2452 ExecutionContext *execution_context) override {
2453 assert(option_idx == 0 && "We only have one option.");
2454 m_verbose = true;
2455
2456 return Status();
2457 }
2458
2459 void OptionParsingStarting(ExecutionContext *execution_context) override {
2460 m_verbose = false;
2461 }
2462
2463 llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
2464 return llvm::ArrayRef(g_target_modules_dump_options);
2465 }
2466
2468 };
2469
2471};
2472
2473#pragma mark CommandObjectTargetModulesDumpSeparateDebugInfoFiles
2474#define LLDB_OPTIONS_target_modules_dump_separate_debug_info
2475#include "CommandOptions.inc"
2476
2477// Image debug separate debug info dumping command
2478
2481public:
2483 CommandInterpreter &interpreter)
2485 interpreter, "target modules dump separate-debug-info",
2486 "List the separate debug info symbol files for one or more target "
2487 "modules.",
2488 nullptr, eCommandRequiresTarget) {}
2489
2491
2492 Options *GetOptions() override { return &m_options; }
2493
2494 class CommandOptions : public Options {
2495 public:
2496 CommandOptions() = default;
2497
2498 ~CommandOptions() override = default;
2499
2500 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
2501 ExecutionContext *execution_context) override {
2502 Status error;
2503 const int short_option = m_getopt_table[option_idx].val;
2504
2505 switch (short_option) {
2506 case 'j':
2507 m_json.SetCurrentValue(true);
2509 break;
2510 case 'e':
2513 break;
2514 default:
2515 llvm_unreachable("Unimplemented option");
2516 }
2517 return error;
2518 }
2519
2520 void OptionParsingStarting(ExecutionContext *execution_context) override {
2521 m_json.Clear();
2523 }
2524
2525 llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
2526 return llvm::ArrayRef(g_target_modules_dump_separate_debug_info_options);
2527 }
2528
2531 };
2532
2533protected:
2534 void DoExecute(Args &command, CommandReturnObject &result) override {
2535 Target &target = GetTarget();
2536 uint32_t num_dumped = 0;
2537
2538 uint32_t addr_byte_size = target.GetArchitecture().GetAddressByteSize();
2539 result.GetOutputStream().SetAddressByteSize(addr_byte_size);
2540 result.GetErrorStream().SetAddressByteSize(addr_byte_size);
2541
2542 StructuredData::Array separate_debug_info_lists_by_module;
2543 if (command.GetArgumentCount() == 0) {
2544 // Dump all sections for all modules images
2545 const ModuleList &target_modules = target.GetImages();
2546 std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());
2547 const size_t num_modules = target_modules.GetSize();
2548 if (num_modules == 0) {
2549 result.AppendError("the target has no associated executable images");
2550 return;
2551 }
2552 for (ModuleSP module_sp : target_modules.ModulesNoLocking()) {
2554 GetDebugger(),
2555 "Interrupted in dumping all "
2556 "separate debug info with {0} of {1} modules dumped",
2557 num_dumped, num_modules))
2558 break;
2559
2560 if (GetSeparateDebugInfoList(separate_debug_info_lists_by_module,
2561 module_sp.get(),
2562 bool(m_options.m_errors_only)))
2563 num_dumped++;
2564 }
2565 } else {
2566 // Dump specified images (by basename or fullpath)
2567 const char *arg_cstr;
2568 for (int arg_idx = 0;
2569 (arg_cstr = command.GetArgumentAtIndex(arg_idx)) != nullptr;
2570 ++arg_idx) {
2571 ModuleList module_list;
2572 const size_t num_matches =
2573 FindModulesByName(&target, arg_cstr, module_list, true);
2574 if (num_matches > 0) {
2575 for (size_t i = 0; i < num_matches; ++i) {
2577 "Interrupted dumping {0} "
2578 "of {1} requested modules",
2579 i, num_matches))
2580 break;
2581 Module *module = module_list.GetModulePointerAtIndex(i);
2582 if (GetSeparateDebugInfoList(separate_debug_info_lists_by_module,
2583 module, bool(m_options.m_errors_only)))
2584 num_dumped++;
2585 }
2586 } else
2588 "Unable to find an image that matches '%s'.\n", arg_cstr);
2589 }
2590 }
2591
2592 if (num_dumped > 0) {
2593 Stream &strm = result.GetOutputStream();
2594 // Display the debug info files in some format.
2595 if (m_options.m_json) {
2596 // JSON format
2597 separate_debug_info_lists_by_module.Dump(strm,
2598 /*pretty_print=*/true);
2599 } else {
2600 // Human-readable table format
2601 separate_debug_info_lists_by_module.ForEach(
2602 [&result, &strm](StructuredData::Object *obj) {
2603 if (!obj) {
2604 return false;
2605 }
2606
2607 // Each item in `separate_debug_info_lists_by_module` should be a
2608 // valid structured data dictionary.
2609 StructuredData::Dictionary *separate_debug_info_list =
2610 obj->GetAsDictionary();
2611 if (!separate_debug_info_list) {
2612 return false;
2613 }
2614
2615 llvm::StringRef type;
2616 llvm::StringRef symfile;
2617 StructuredData::Array *files;
2618 if (!(separate_debug_info_list->GetValueForKeyAsString("type",
2619 type) &&
2620 separate_debug_info_list->GetValueForKeyAsString("symfile",
2621 symfile) &&
2622 separate_debug_info_list->GetValueForKeyAsArray(
2623 "separate-debug-info-files", files))) {
2624 assert(false);
2625 }
2626
2627 strm << "Symbol file: " << symfile;
2628 strm.EOL();
2629 strm << "Type: \"" << type << "\"";
2630 strm.EOL();
2631 if (type == "dwo") {
2632 DumpDwoFilesTable(strm, *files);
2633 } else if (type == "oso") {
2634 DumpOsoFilesTable(strm, *files);
2635 } else {
2637 "Found unsupported debug info type '%s'.\n",
2638 type.str().c_str());
2639 }
2640 return true;
2641 });
2642 }
2644 } else {
2645 result.AppendError("no matching executable images found");
2646 }
2647 }
2648
2650};
2651
2652#pragma mark CommandObjectTargetModulesDump
2653
2654// Dump multi-word command for target modules
2655
2657public:
2658 // Constructors and Destructors
2661 interpreter, "target modules dump",
2662 "Commands for dumping information about one or more target "
2663 "modules.",
2664 "target modules dump "
2665 "[objfile|symtab|sections|ast|symfile|line-table|pcm-info|separate-"
2666 "debug-info] "
2667 "[<file1> <file2> ...]") {
2668 LoadSubCommand("objfile",
2670 new CommandObjectTargetModulesDumpObjfile(interpreter)));
2672 "symtab",
2674 LoadSubCommand("sections",
2676 interpreter)));
2677 LoadSubCommand("symfile",
2679 new CommandObjectTargetModulesDumpSymfile(interpreter)));
2681 "ast", CommandObjectSP(
2682 new CommandObjectTargetModulesDumpClangAST(interpreter)));
2683 LoadSubCommand("line-table",
2685 interpreter)));
2687 "pcm-info",
2690 LoadSubCommand("separate-debug-info",
2693 interpreter)));
2694 }
2695
2697};
2698
2700public:
2702 : CommandObjectParsed(interpreter, "target modules add",
2703 "Add a new module to the current target's modules.",
2704 "target modules add [<module>]",
2705 eCommandRequiresTarget),
2706 m_symbol_file(LLDB_OPT_SET_1, false, "symfile", 's', 0,
2708 "Fullpath to a stand alone debug "
2709 "symbols file for when debug symbols "
2710 "are not in the executable.") {
2716 }
2717
2719
2720 Options *GetOptions() override { return &m_option_group; }
2721
2722protected:
2726
2727 void DoExecute(Args &args, CommandReturnObject &result) override {
2728 Target &target = GetTarget();
2729 bool flush = false;
2730
2731 const size_t argc = args.GetArgumentCount();
2732 if (argc == 0) {
2734 // We are given a UUID only, go locate the file
2735 ModuleSpec module_spec;
2736 module_spec.GetUUID() =
2739 module_spec.GetSymbolFileSpec() =
2741 Status error;
2743 ModuleSP module_sp(
2744 target.GetOrCreateModule(module_spec, true /* notify */));
2745 if (module_sp) {
2747 return;
2748 } else {
2749 StreamString strm;
2750 module_spec.GetUUID().Dump(strm);
2751 if (module_spec.GetFileSpec()) {
2752 if (module_spec.GetSymbolFileSpec()) {
2753 result.AppendErrorWithFormat(
2754 "Unable to create the executable or symbol file with "
2755 "UUID %s with path %s and symbol file %s",
2756 strm.GetData(), module_spec.GetFileSpec().GetPath().c_str(),
2757 module_spec.GetSymbolFileSpec().GetPath().c_str());
2758 } else {
2759 result.AppendErrorWithFormat(
2760 "Unable to create the executable or symbol file with "
2761 "UUID %s with path %s",
2762 strm.GetData(),
2763 module_spec.GetFileSpec().GetPath().c_str());
2764 }
2765 } else {
2766 result.AppendErrorWithFormat("Unable to create the executable "
2767 "or symbol file with UUID %s",
2768 strm.GetData());
2769 }
2770 return;
2771 }
2772 } else {
2773 StreamString strm;
2774 module_spec.GetUUID().Dump(strm);
2775 result.AppendErrorWithFormat(
2776 "Unable to locate the executable or symbol file with UUID %s",
2777 strm.GetData());
2778 result.SetError(std::move(error));
2779 return;
2780 }
2781 } else {
2782 result.AppendError(
2783 "one or more executable image paths must be specified");
2784 return;
2785 }
2786 } else {
2787 for (auto &entry : args.entries()) {
2788 if (entry.ref().empty())
2789 continue;
2790
2791 FileSpec file_spec(entry.ref());
2792 if (FileSystem::Instance().Exists(file_spec)) {
2793 ModuleSpec module_spec(file_spec);
2795 module_spec.GetUUID() =
2798 module_spec.GetSymbolFileSpec() =
2800 if (!module_spec.GetArchitecture().IsValid())
2801 module_spec.GetArchitecture() = target.GetArchitecture();
2802 Status error;
2803 ModuleSP module_sp(
2804 target.GetOrCreateModule(module_spec, true /* notify */, &error));
2805 if (!module_sp) {
2806 const char *error_cstr = error.AsCString();
2807 if (error_cstr)
2808 result.AppendError(error_cstr);
2809 else
2810 result.AppendErrorWithFormat("unsupported module: %s",
2811 entry.c_str());
2812 return;
2813 } else {
2814 flush = true;
2815 }
2817 } else {
2818 std::string resolved_path = file_spec.GetPath();
2819 if (resolved_path != entry.ref()) {
2820 result.AppendErrorWithFormat(
2821 "invalid module path '%s' with resolved path '%s'\n",
2822 entry.ref().str().c_str(), resolved_path.c_str());
2823 break;
2824 }
2825 result.AppendErrorWithFormat("invalid module path '%s'\n",
2826 entry.c_str());
2827 break;
2828 }
2829 }
2830 }
2831
2832 if (flush) {
2833 ProcessSP process = target.GetProcessSP();
2834 if (process)
2835 process->Flush();
2836 }
2837 }
2838};
2839
2842public:
2845 interpreter, "target modules load",
2846 "Set the load addresses for one or more sections in a target "
2847 "module.",
2848 "target modules load [--file <module> --uuid <uuid>] <sect-name> "
2849 "<address> [<sect-name> <address> ....]",
2850 eCommandRequiresTarget),
2851 m_file_option(LLDB_OPT_SET_1, false, "file", 'f', 0, eArgTypeName,
2852 "Fullpath or basename for module to load.", ""),
2853 m_load_option(LLDB_OPT_SET_1, false, "load", 'l',
2854 "Write file contents to the memory.", false, true),
2855 m_pc_option(LLDB_OPT_SET_1, false, "set-pc-to-entry", 'p',
2856 "Set PC to the entry point."
2857 " Only applicable with '--load' option.",
2858 false, true),
2859 m_slide_option(LLDB_OPT_SET_1, false, "slide", 's', 0, eArgTypeOffset,
2860 "Set the load address for all sections to be the "
2861 "virtual address in the file plus the offset.",
2862 0) {
2870 }
2871
2873
2874 Options *GetOptions() override { return &m_option_group; }
2875
2876protected:
2877 void DoExecute(Args &args, CommandReturnObject &result) override {
2878 Target &target = GetTarget();
2879 const bool load = m_load_option.GetOptionValue().GetCurrentValue();
2880 const bool set_pc = m_pc_option.GetOptionValue().GetCurrentValue();
2881
2882 const size_t argc = args.GetArgumentCount();
2883 ModuleSpec module_spec;
2884 bool search_using_module_spec = false;
2885
2886 // Allow "load" option to work without --file or --uuid option.
2887 if (load) {
2890 ModuleList &module_list = target.GetImages();
2891 if (module_list.GetSize() == 1) {
2892 search_using_module_spec = true;
2893 module_spec.GetFileSpec() =
2894 module_list.GetModuleAtIndex(0)->GetFileSpec();
2895 }
2896 }
2897 }
2898
2900 search_using_module_spec = true;
2901 const char *arg_cstr = m_file_option.GetOptionValue().GetCurrentValue();
2902 const bool use_global_module_list = true;
2903 ModuleList module_list;
2904 const size_t num_matches = FindModulesByName(
2905 &target, arg_cstr, module_list, use_global_module_list);
2906 if (num_matches == 1) {
2907 module_spec.GetFileSpec() =
2908 module_list.GetModuleAtIndex(0)->GetFileSpec();
2909 } else if (num_matches > 1) {
2910 search_using_module_spec = false;
2911 result.AppendErrorWithFormat(
2912 "more than 1 module matched by name '%s'\n", arg_cstr);
2913 } else {
2914 search_using_module_spec = false;
2915 result.AppendErrorWithFormat("no object file for module '%s'\n",
2916 arg_cstr);
2917 }
2918 }
2919
2921 search_using_module_spec = true;
2922 module_spec.GetUUID() =
2924 }
2925
2926 if (search_using_module_spec) {
2927 ModuleList matching_modules;
2928 target.GetImages().FindModules(module_spec, matching_modules);
2929 const size_t num_matches = matching_modules.GetSize();
2930
2931 char path[PATH_MAX];
2932 if (num_matches == 1) {
2933 Module *module = matching_modules.GetModulePointerAtIndex(0);
2934 if (module) {
2935 ObjectFile *objfile = module->GetObjectFile();
2936 if (objfile) {
2937 SectionList *section_list = module->GetSectionList();
2938 if (section_list) {
2939 bool changed = false;
2940 if (argc == 0) {
2942 const addr_t slide =
2944 const bool slide_is_offset = true;
2945 module->SetLoadAddress(target, slide, slide_is_offset,
2946 changed);
2947 } else {
2948 result.AppendError("one or more section name + load "
2949 "address pair must be specified");
2950 return;
2951 }
2952 } else {
2954 result.AppendError("The \"--slide <offset>\" option can't "
2955 "be used in conjunction with setting "
2956 "section load addresses.\n");
2957 return;
2958 }
2959
2960 for (size_t i = 0; i < argc; i += 2) {
2961 const char *sect_name = args.GetArgumentAtIndex(i);
2962 const char *load_addr_cstr = args.GetArgumentAtIndex(i + 1);
2963 if (sect_name && load_addr_cstr) {
2964 ConstString const_sect_name(sect_name);
2965 addr_t load_addr;
2966 if (llvm::to_integer(load_addr_cstr, load_addr)) {
2967 SectionSP section_sp(
2968 section_list->FindSectionByName(const_sect_name));
2969 if (section_sp) {
2970 if (section_sp->IsThreadSpecific()) {
2971 result.AppendErrorWithFormat(
2972 "thread specific sections are not yet "
2973 "supported (section '%s')\n",
2974 sect_name);
2975 break;
2976 } else {
2978 section_sp, load_addr))
2979 changed = true;
2981 "section '%s' loaded at 0x%" PRIx64 "\n",
2982 sect_name, load_addr);
2983 }
2984 } else {
2985 result.AppendErrorWithFormat("no section found that "
2986 "matches the section "
2987 "name '%s'\n",
2988 sect_name);
2989 break;
2990 }
2991 } else {
2992 result.AppendErrorWithFormat(
2993 "invalid load address string '%s'\n", load_addr_cstr);
2994 break;
2995 }
2996 } else {
2997 if (sect_name)
2998 result.AppendError("section names must be followed by "
2999 "a load address.\n");
3000 else
3001 result.AppendError("one or more section name + load "
3002 "address pair must be specified.\n");
3003 break;
3004 }
3005 }
3006 }
3007
3008 if (changed) {
3009 target.ModulesDidLoad(matching_modules);
3010 Process *process = m_exe_ctx.GetProcessPtr();
3011 if (process)
3012 process->Flush();
3013 }
3014 if (load) {
3015 ProcessSP process = target.CalculateProcess();
3016 Address file_entry = objfile->GetEntryPointAddress();
3017 if (!process) {
3018 result.AppendError("No process");
3019 return;
3020 }
3021 if (set_pc && !file_entry.IsValid()) {
3022 result.AppendError("No entry address in object file");
3023 return;
3024 }
3025 std::vector<ObjectFile::LoadableData> loadables(
3026 objfile->GetLoadableData(target));
3027 if (loadables.size() == 0) {
3028 result.AppendError("No loadable sections");
3029 return;
3030 }
3031 Status error = process->WriteObjectFile(std::move(loadables));
3032 if (error.Fail()) {
3033 result.AppendError(error.AsCString());
3034 return;
3035 }
3036 if (set_pc) {
3037 ThreadList &thread_list = process->GetThreadList();
3038 RegisterContextSP reg_context(
3039 thread_list.GetSelectedThread()->GetRegisterContext());
3040 addr_t file_entry_addr = file_entry.GetLoadAddress(&target);
3041 if (!reg_context->SetPC(file_entry_addr)) {
3042 result.AppendErrorWithFormat("failed to set PC value to "
3043 "0x%" PRIx64 "\n",
3044 file_entry_addr);
3045 }
3046 }
3047 }
3048 } else {
3049 module->GetFileSpec().GetPath(path, sizeof(path));
3050 result.AppendErrorWithFormat("no sections in object file '%s'\n",
3051 path);
3052 }
3053 } else {
3054 module->GetFileSpec().GetPath(path, sizeof(path));
3055 result.AppendErrorWithFormat("no object file for module '%s'\n",
3056 path);
3057 }
3058 } else {
3059 FileSpec *module_spec_file = module_spec.GetFileSpecPtr();
3060 if (module_spec_file) {
3061 module_spec_file->GetPath(path, sizeof(path));
3062 result.AppendErrorWithFormat("invalid module '%s'.\n", path);
3063 } else
3064 result.AppendError("no module spec");
3065 }
3066 } else {
3067 std::string uuid_str;
3068
3069 if (module_spec.GetFileSpec())
3070 module_spec.GetFileSpec().GetPath(path, sizeof(path));
3071 else
3072 path[0] = '\0';
3073
3074 if (module_spec.GetUUIDPtr())
3075 uuid_str = module_spec.GetUUID().GetAsString();
3076 if (num_matches > 1) {
3077 result.AppendErrorWithFormat(
3078 "multiple modules match%s%s%s%s:\n", path[0] ? " file=" : "",
3079 path, !uuid_str.empty() ? " uuid=" : "", uuid_str.c_str());
3080 for (size_t i = 0; i < num_matches; ++i) {
3081 if (matching_modules.GetModulePointerAtIndex(i)
3082 ->GetFileSpec()
3083 .GetPath(path, sizeof(path)))
3084 result.AppendMessageWithFormat("%s\n", path);
3085 }
3086 } else {
3087 result.AppendErrorWithFormat(
3088 "no modules were found that match%s%s%s%s.\n",
3089 path[0] ? " file=" : "", path, !uuid_str.empty() ? " uuid=" : "",
3090 uuid_str.c_str());
3091 }
3092 }
3093 } else {
3094 result.AppendError("either the \"--file <module>\" or the \"--uuid "
3095 "<uuid>\" option must be specified.\n");
3096 }
3097 }
3098
3105};
3106
3107#pragma mark CommandObjectTargetModulesList
3108// List images with associated information
3109#define LLDB_OPTIONS_target_modules_list
3110#include "CommandOptions.inc"
3111
3113public:
3114 class CommandOptions : public Options {
3115 public:
3116 CommandOptions() = default;
3117
3118 ~CommandOptions() override = default;
3119
3120 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
3121 ExecutionContext *execution_context) override {
3122 Status error;
3123
3124 const int short_option = m_getopt_table[option_idx].val;
3125 if (short_option == 'g') {
3127 } else if (short_option == 'a') {
3129 execution_context, option_arg, LLDB_INVALID_ADDRESS, &error);
3130 } else {
3131 unsigned long width = 0;
3132 option_arg.getAsInteger(0, width);
3133 m_format_array.push_back(std::make_pair(short_option, width));
3134 }
3135 return error;
3136 }
3137
3138 void OptionParsingStarting(ExecutionContext *execution_context) override {
3139 m_format_array.clear();
3142 }
3143
3144 llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
3145 return llvm::ArrayRef(g_target_modules_list_options);
3146 }
3147
3148 // Instance variables to hold the values for command options.
3149 typedef std::vector<std::pair<char, uint32_t>> FormatWidthCollection;
3153 };
3154
3157 interpreter, "target modules list",
3158 "List current executable and dependent shared library images.") {
3160 }
3161
3163
3164 Options *GetOptions() override { return &m_options; }
3165
3166protected:
3167 void DoExecute(Args &command, CommandReturnObject &result) override {
3168 Target &target = GetTarget();
3169 const bool use_global_module_list = m_options.m_use_global_module_list;
3170 // Define a local module list here to ensure it lives longer than any
3171 // "locker" object which might lock its contents below (through the
3172 // "module_list_ptr" variable).
3173 ModuleList module_list;
3174 uint32_t addr_byte_size = target.GetArchitecture().GetAddressByteSize();
3175 result.GetOutputStream().SetAddressByteSize(addr_byte_size);
3176 result.GetErrorStream().SetAddressByteSize(addr_byte_size);
3177 // Dump all sections for all modules images
3178 Stream &strm = result.GetOutputStream();
3179
3181 Address module_address;
3182 if (module_address.SetLoadAddress(m_options.m_module_addr, &target)) {
3183 ModuleSP module_sp(module_address.GetModule());
3184 if (module_sp) {
3185 PrintModule(target, module_sp.get(), 0, strm);
3187 } else {
3188 result.AppendErrorWithFormat(
3189 "Couldn't find module matching address: 0x%" PRIx64 ".",
3191 }
3192 } else {
3193 result.AppendErrorWithFormat(
3194 "Couldn't find module containing address: 0x%" PRIx64 ".",
3196 }
3197 return;
3198 }
3199
3200 size_t num_modules = 0;
3201
3202 // This locker will be locked on the mutex in module_list_ptr if it is
3203 // non-nullptr. Otherwise it will lock the
3204 // AllocationModuleCollectionMutex when accessing the global module list
3205 // directly.
3206 std::unique_lock<std::recursive_mutex> guard(
3208
3209 const ModuleList *module_list_ptr = nullptr;
3210 const size_t argc = command.GetArgumentCount();
3211 if (argc == 0) {
3212 if (use_global_module_list) {
3213 guard.lock();
3214 num_modules = Module::GetNumberAllocatedModules();
3215 } else {
3216 module_list_ptr = &target.GetImages();
3217 }
3218 } else {
3219 for (const Args::ArgEntry &arg : command) {
3220 // Dump specified images (by basename or fullpath)
3221 const size_t num_matches = FindModulesByName(
3222 &target, arg.c_str(), module_list, use_global_module_list);
3223 if (num_matches == 0) {
3224 if (argc == 1) {
3225 result.AppendErrorWithFormat("no modules found that match '%s'",
3226 arg.c_str());
3227 return;
3228 }
3229 }
3230 }
3231
3232 module_list_ptr = &module_list;
3233 }
3234
3235 std::unique_lock<std::recursive_mutex> lock;
3236 if (module_list_ptr != nullptr) {
3237 lock =
3238 std::unique_lock<std::recursive_mutex>(module_list_ptr->GetMutex());
3239
3240 num_modules = module_list_ptr->GetSize();
3241 }
3242
3243 if (num_modules > 0) {
3244 for (uint32_t image_idx = 0; image_idx < num_modules; ++image_idx) {
3245 ModuleSP module_sp;
3246 Module *module;
3247 if (module_list_ptr) {
3248 module_sp = module_list_ptr->GetModuleAtIndexUnlocked(image_idx);
3249 module = module_sp.get();
3250 } else {
3251 module = Module::GetAllocatedModuleAtIndex(image_idx);
3252 module_sp = module->shared_from_this();
3253 }
3254
3255 const size_t indent = strm.Printf("[%3u] ", image_idx);
3256 PrintModule(target, module, indent, strm);
3257 }
3259 } else {
3260 if (argc) {
3261 if (use_global_module_list)
3262 result.AppendError(
3263 "the global module list has no matching modules");
3264 else
3265 result.AppendError("the target has no matching modules");
3266 } else {
3267 if (use_global_module_list)
3268 result.AppendError("the global module list is empty");
3269 else
3270 result.AppendError(
3271 "the target has no associated executable images");
3272 }
3273 return;
3274 }
3275 }
3276
3277 void PrintModule(Target &target, Module *module, int indent, Stream &strm) {
3278 if (module == nullptr) {
3279 strm.PutCString("Null module");
3280 return;
3281 }
3282
3283 bool dump_object_name = false;
3284 if (m_options.m_format_array.empty()) {
3285 m_options.m_format_array.push_back(std::make_pair('u', 0));
3286 m_options.m_format_array.push_back(std::make_pair('h', 0));
3287 m_options.m_format_array.push_back(std::make_pair('f', 0));
3288 m_options.m_format_array.push_back(std::make_pair('S', 0));
3289 }
3290 const size_t num_entries = m_options.m_format_array.size();
3291 bool print_space = false;
3292 for (size_t i = 0; i < num_entries; ++i) {
3293 if (print_space)
3294 strm.PutChar(' ');
3295 print_space = true;
3296 const char format_char = m_options.m_format_array[i].first;
3297 uint32_t width = m_options.m_format_array[i].second;
3298 switch (format_char) {
3299 case 'A':
3300 DumpModuleArchitecture(strm, module, false, width);
3301 break;
3302
3303 case 't':
3304 DumpModuleArchitecture(strm, module, true, width);
3305 break;
3306
3307 case 'f':
3308 DumpFullpath(strm, &module->GetFileSpec(), width);
3309 dump_object_name = true;
3310 break;
3311
3312 case 'd':
3313 DumpDirectory(strm, &module->GetFileSpec(), width);
3314 break;
3315
3316 case 'b':
3317 DumpBasename(strm, &module->GetFileSpec(), width);
3318 dump_object_name = true;
3319 break;
3320
3321 case 'h':
3322 case 'o':
3323 // Image header address
3324 {
3325 uint32_t addr_nibble_width =
3326 target.GetArchitecture().GetAddressByteSize() * 2;
3327
3328 ObjectFile *objfile = module->GetObjectFile();
3329 if (objfile) {
3330 Address base_addr(objfile->GetBaseAddress());
3331 if (base_addr.IsValid()) {
3332 if (!target.GetSectionLoadList().IsEmpty()) {
3333 lldb::addr_t load_addr = base_addr.GetLoadAddress(&target);
3334 if (load_addr == LLDB_INVALID_ADDRESS) {
3335 base_addr.Dump(&strm, &target,
3338 } else {
3339 if (format_char == 'o') {
3340 // Show the offset of slide for the image
3341 strm.Printf("0x%*.*" PRIx64, addr_nibble_width,
3342 addr_nibble_width,
3343 load_addr - base_addr.GetFileAddress());
3344 } else {
3345 // Show the load address of the image
3346 strm.Printf("0x%*.*" PRIx64, addr_nibble_width,
3347 addr_nibble_width, load_addr);
3348 }
3349 }
3350 break;
3351 }
3352 // The address was valid, but the image isn't loaded, output the
3353 // address in an appropriate format
3354 base_addr.Dump(&strm, &target, Address::DumpStyleFileAddress);
3355 break;
3356 }
3357 }
3358 strm.Printf("%*s", addr_nibble_width + 2, "");
3359 }
3360 break;
3361
3362 case 'r': {
3363 size_t ref_count = 0;
3364 char in_shared_cache = 'Y';
3365
3366 ModuleSP module_sp(module->shared_from_this());
3367 if (!ModuleList::ModuleIsInCache(module))
3368 in_shared_cache = 'N';
3369 if (module_sp) {
3370 // Take one away to make sure we don't count our local "module_sp"
3371 ref_count = module_sp.use_count() - 1;
3372 }
3373 if (width)
3374 strm.Printf("{%c %*" PRIu64 "}", in_shared_cache, width, (uint64_t)ref_count);
3375 else
3376 strm.Printf("{%c %" PRIu64 "}", in_shared_cache, (uint64_t)ref_count);
3377 } break;
3378
3379 case 's':
3380 case 'S': {
3381 if (const SymbolFile *symbol_file = module->GetSymbolFile()) {
3382 const FileSpec symfile_spec =
3383 symbol_file->GetObjectFile()->GetFileSpec();
3384 if (format_char == 'S') {
3385 // Dump symbol file only if different from module file
3386 if (!symfile_spec || symfile_spec == module->GetFileSpec()) {
3387 print_space = false;
3388 break;
3389 }
3390 // Add a newline and indent past the index
3391 strm.Printf("\n%*s", indent, "");
3392 }
3393 DumpFullpath(strm, &symfile_spec, width);
3394 dump_object_name = true;
3395 break;
3396 }
3397 strm.Printf("%.*s", width, "<NONE>");
3398 } break;
3399
3400 case 'm':
3401 strm.Format("{0:%c}", llvm::fmt_align(module->GetModificationTime(),
3402 llvm::AlignStyle::Left, width));
3403 break;
3404
3405 case 'p':
3406 strm.Printf("%p", static_cast<void *>(module));
3407 break;
3408
3409 case 'u':
3410 DumpModuleUUID(strm, module);
3411 break;
3412
3413 default:
3414 break;
3415 }
3416 }
3417 if (dump_object_name) {
3418 const char *object_name = module->GetObjectName().GetCString();
3419 if (object_name)
3420 strm.Printf("(%s)", object_name);
3421 }
3422 strm.EOL();
3423 }
3424
3426};
3427
3428#pragma mark CommandObjectTargetModulesShowUnwind
3429
3430// Lookup unwind information in images
3431#define LLDB_OPTIONS_target_modules_show_unwind
3432#include "CommandOptions.inc"
3433
3435public:
3436 enum {
3444
3445 class CommandOptions : public Options {
3446 public:
3447 CommandOptions() = default;
3448
3449 ~CommandOptions() override = default;
3450
3451 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
3452 ExecutionContext *execution_context) override {
3453 Status error;
3454
3455 const int short_option = m_getopt_table[option_idx].val;
3456
3457 switch (short_option) {
3458 case 'a': {
3459 m_str = std::string(option_arg);
3461 m_addr = OptionArgParser::ToAddress(execution_context, option_arg,
3465 "invalid address string '%s'", option_arg.str().c_str());
3466 break;
3467 }
3468
3469 case 'n':
3470 m_str = std::string(option_arg);
3472 break;
3473
3474 default:
3475 llvm_unreachable("Unimplemented option");
3476 }
3477
3478 return error;
3479 }
3480
3481 void OptionParsingStarting(ExecutionContext *execution_context) override {
3483 m_str.clear();
3485 }
3486
3487 llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
3488 return llvm::ArrayRef(g_target_modules_show_unwind_options);
3489 }
3490
3491 // Instance variables to hold the values for command options.
3492
3493 int m_type = eLookupTypeInvalid; // Should be a eLookupTypeXXX enum after
3494 // parsing options
3495 std::string m_str; // Holds name lookup
3496 lldb::addr_t m_addr = LLDB_INVALID_ADDRESS; // Holds the address to lookup
3497 };
3498
3501 interpreter, "target modules show-unwind",
3502 "Show synthesized unwind instructions for a function.", nullptr,
3503 eCommandRequiresTarget | eCommandRequiresProcess |
3504 eCommandProcessMustBeLaunched | eCommandProcessMustBePaused) {}
3505
3507
3508 Options *GetOptions() override { return &m_options; }
3509
3510protected:
3511 void DoExecute(Args &command, CommandReturnObject &result) override {
3512 Target *target = m_exe_ctx.GetTargetPtr();
3513 Process *process = m_exe_ctx.GetProcessPtr();
3514 ABI *abi = nullptr;
3515 if (process)
3516 abi = process->GetABI().get();
3517
3518 if (process == nullptr) {
3519 result.AppendError(
3520 "You must have a process running to use this command.");
3521 return;
3522 }
3523
3524 ThreadList threads(process->GetThreadList());
3525 if (threads.GetSize() == 0) {
3526 result.AppendError("The process must be paused to use this command.");
3527 return;
3528 }
3529
3530 ThreadSP thread(threads.GetThreadAtIndex(0));
3531 if (!thread) {
3532 result.AppendError("The process must be paused to use this command.");
3533 return;
3534 }
3535
3536 SymbolContextList sc_list;
3537
3539 ConstString function_name(m_options.m_str.c_str());
3540 ModuleFunctionSearchOptions function_options;
3541 function_options.include_symbols = true;
3542 function_options.include_inlines = false;
3543 target->GetImages().FindFunctions(function_name, eFunctionNameTypeAuto,
3544 function_options, sc_list);
3545 } else if (m_options.m_type == eLookupTypeAddress && target) {
3546 Address addr;
3548 addr)) {
3549 SymbolContext sc;
3550 ModuleSP module_sp(addr.GetModule());
3551 module_sp->ResolveSymbolContextForAddress(addr,
3552 eSymbolContextEverything, sc);
3553 if (sc.function || sc.symbol) {
3554 sc_list.Append(sc);
3555 }
3556 }
3557 } else {
3558 result.AppendError(
3559 "address-expression or function name option must be specified.");
3560 return;
3561 }
3562
3563 if (sc_list.GetSize() == 0) {
3564 result.AppendErrorWithFormat("no unwind data found that matches '%s'.",
3565 m_options.m_str.c_str());
3566 return;
3567 }
3568
3569 for (const SymbolContext &sc : sc_list) {
3570 if (sc.symbol == nullptr && sc.function == nullptr)
3571 continue;
3572 if (!sc.module_sp || sc.module_sp->GetObjectFile() == nullptr)
3573 continue;
3574 AddressRange range;
3575 if (!sc.GetAddressRange(eSymbolContextFunction | eSymbolContextSymbol, 0,
3576 false, range))
3577 continue;
3578 if (!range.GetBaseAddress().IsValid())
3579 continue;
3580 ConstString funcname(sc.GetFunctionName());
3581 if (funcname.IsEmpty())
3582 continue;
3583 addr_t start_addr = range.GetBaseAddress().GetLoadAddress(target);
3584 if (abi)
3585 start_addr = abi->FixCodeAddress(start_addr);
3586
3587 FuncUnwindersSP func_unwinders_sp(
3588 sc.module_sp->GetUnwindTable()
3589 .GetUncachedFuncUnwindersContainingAddress(start_addr, sc));
3590 if (!func_unwinders_sp)
3591 continue;
3592
3593 result.GetOutputStream().Printf(
3594 "UNWIND PLANS for %s`%s (start addr 0x%" PRIx64 ")\n",
3595 sc.module_sp->GetPlatformFileSpec().GetFilename().AsCString(),
3596 funcname.AsCString(), start_addr);
3597
3598 Args args;
3600 size_t count = args.GetArgumentCount();
3601 for (size_t i = 0; i < count; i++) {
3602 const char *trap_func_name = args.GetArgumentAtIndex(i);
3603 if (strcmp(funcname.GetCString(), trap_func_name) == 0)
3604 result.GetOutputStream().Printf(
3605 "This function is "
3606 "treated as a trap handler function via user setting.\n");
3607 }
3608 PlatformSP platform_sp(target->GetPlatform());
3609 if (platform_sp) {
3610 const std::vector<ConstString> trap_handler_names(
3611 platform_sp->GetTrapHandlerSymbolNames());
3612 for (ConstString trap_name : trap_handler_names) {
3613 if (trap_name == funcname) {
3614 result.GetOutputStream().Printf(
3615 "This function's "
3616 "name is listed by the platform as a trap handler.\n");
3617 }
3618 }
3619 }
3620
3621 result.GetOutputStream().Printf("\n");
3622
3623 UnwindPlanSP non_callsite_unwind_plan =
3624 func_unwinders_sp->GetUnwindPlanAtNonCallSite(*target, *thread);
3625 if (non_callsite_unwind_plan) {
3626 result.GetOutputStream().Printf(
3627 "Asynchronous (not restricted to call-sites) UnwindPlan is '%s'\n",
3628 non_callsite_unwind_plan->GetSourceName().AsCString());
3629 }
3630 UnwindPlanSP callsite_unwind_plan =
3631 func_unwinders_sp->GetUnwindPlanAtCallSite(*target, *thread);
3632 if (callsite_unwind_plan) {
3633 result.GetOutputStream().Printf(
3634 "Synchronous (restricted to call-sites) UnwindPlan is '%s'\n",
3635 callsite_unwind_plan->GetSourceName().AsCString());
3636 }
3637 UnwindPlanSP fast_unwind_plan =
3638 func_unwinders_sp->GetUnwindPlanFastUnwind(*target, *thread);
3639 if (fast_unwind_plan) {
3640 result.GetOutputStream().Printf(
3641 "Fast UnwindPlan is '%s'\n",
3642 fast_unwind_plan->GetSourceName().AsCString());
3643 }
3644
3645 result.GetOutputStream().Printf("\n");
3646
3647 UnwindPlanSP assembly_sp =
3648 func_unwinders_sp->GetAssemblyUnwindPlan(*target, *thread);
3649 if (assembly_sp) {
3650 result.GetOutputStream().Printf(
3651 "Assembly language inspection UnwindPlan:\n");
3652 assembly_sp->Dump(result.GetOutputStream(), thread.get(),
3654 result.GetOutputStream().Printf("\n");
3655 }
3656
3657 UnwindPlanSP of_unwind_sp =
3658 func_unwinders_sp->GetObjectFileUnwindPlan(*target);
3659 if (of_unwind_sp) {
3660 result.GetOutputStream().Printf("object file UnwindPlan:\n");
3661 of_unwind_sp->Dump(result.GetOutputStream(), thread.get(),
3663 result.GetOutputStream().Printf("\n");
3664 }
3665
3666 UnwindPlanSP of_unwind_augmented_sp =
3667 func_unwinders_sp->GetObjectFileAugmentedUnwindPlan(*target, *thread);
3668 if (of_unwind_augmented_sp) {
3669 result.GetOutputStream().Printf("object file augmented UnwindPlan:\n");
3670 of_unwind_augmented_sp->Dump(result.GetOutputStream(), thread.get(),
3672 result.GetOutputStream().Printf("\n");
3673 }
3674
3676 func_unwinders_sp->GetEHFrameUnwindPlan(*target);
3677 if (ehframe_sp) {
3678 result.GetOutputStream().Printf("eh_frame UnwindPlan:\n");
3679 ehframe_sp->Dump(result.GetOutputStream(), thread.get(),
3681 result.GetOutputStream().Printf("\n");
3682 }
3683
3684 UnwindPlanSP ehframe_augmented_sp =
3685 func_unwinders_sp->GetEHFrameAugmentedUnwindPlan(*target, *thread);
3686 if (ehframe_augmented_sp) {
3687 result.GetOutputStream().Printf("eh_frame augmented UnwindPlan:\n");
3688 ehframe_augmented_sp->Dump(result.GetOutputStream(), thread.get(),
3690 result.GetOutputStream().Printf("\n");
3691 }
3692
3693 if (UnwindPlanSP plan_sp =
3694 func_unwinders_sp->GetDebugFrameUnwindPlan(*target)) {
3695 result.GetOutputStream().Printf("debug_frame UnwindPlan:\n");
3696 plan_sp->Dump(result.GetOutputStream(), thread.get(),
3698 result.GetOutputStream().Printf("\n");
3699 }
3700
3701 if (UnwindPlanSP plan_sp =
3702 func_unwinders_sp->GetDebugFrameAugmentedUnwindPlan(*target,
3703 *thread)) {
3704 result.GetOutputStream().Printf("debug_frame augmented UnwindPlan:\n");
3705 plan_sp->Dump(result.GetOutputStream(), thread.get(),
3707 result.GetOutputStream().Printf("\n");
3708 }
3709
3710 UnwindPlanSP arm_unwind_sp =
3711 func_unwinders_sp->GetArmUnwindUnwindPlan(*target);
3712 if (arm_unwind_sp) {
3713 result.GetOutputStream().Printf("ARM.exidx unwind UnwindPlan:\n");
3714 arm_unwind_sp->Dump(result.GetOutputStream(), thread.get(),
3716 result.GetOutputStream().Printf("\n");
3717 }
3718
3719 if (UnwindPlanSP symfile_plan_sp =
3720 func_unwinders_sp->GetSymbolFileUnwindPlan(*thread)) {
3721 result.GetOutputStream().Printf("Symbol file UnwindPlan:\n");
3722 symfile_plan_sp->Dump(result.GetOutputStream(), thread.get(),
3724 result.GetOutputStream().Printf("\n");
3725 }
3726
3727 UnwindPlanSP compact_unwind_sp =
3728 func_unwinders_sp->GetCompactUnwindUnwindPlan(*target);
3729 if (compact_unwind_sp) {
3730 result.GetOutputStream().Printf("Compact unwind UnwindPlan:\n");
3731 compact_unwind_sp->Dump(result.GetOutputStream(), thread.get(),
3733 result.GetOutputStream().Printf("\n");
3734 }
3735
3736 if (fast_unwind_plan) {
3737 result.GetOutputStream().Printf("Fast UnwindPlan:\n");
3738 fast_unwind_plan->Dump(result.GetOutputStream(), thread.get(),
3740 result.GetOutputStream().Printf("\n");
3741 }
3742
3743 ABISP abi_sp = process->GetABI();
3744 if (abi_sp) {
3746 if (abi_sp->CreateDefaultUnwindPlan(arch_default)) {
3747 result.GetOutputStream().Printf("Arch default UnwindPlan:\n");
3748 arch_default.Dump(result.GetOutputStream(), thread.get(),
3750 result.GetOutputStream().Printf("\n");
3751 }
3752
3754 if (abi_sp->CreateFunctionEntryUnwindPlan(arch_entry)) {
3755 result.GetOutputStream().Printf(
3756 "Arch default at entry point UnwindPlan:\n");
3757 arch_entry.Dump(result.GetOutputStream(), thread.get(),
3759 result.GetOutputStream().Printf("\n");
3760 }
3761 }
3762
3763 result.GetOutputStream().Printf("\n");
3764 }
3765 }
3766
3768};
3769
3770// Lookup information in images
3771#define LLDB_OPTIONS_target_modules_lookup
3772#include "CommandOptions.inc"
3773
3775public:
3776 enum {
3780 eLookupTypeFileLine, // Line is optional
3786
3787 class CommandOptions : public Options {
3788 public:
3790
3791 ~CommandOptions() override = default;
3792
3793 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
3794 ExecutionContext *execution_context) override {
3795 Status error;
3796
3797 const int short_option = m_getopt_table[option_idx].val;
3798
3799 switch (short_option) {
3800 case 'a': {
3802 m_addr = OptionArgParser::ToAddress(execution_context, option_arg,
3804 } break;
3805
3806 case 'o':
3807 if (option_arg.getAsInteger(0, m_offset))
3809 "invalid offset string '%s'", option_arg.str().c_str());
3810 break;
3811
3812 case 's':
3813 m_str = std::string(option_arg);
3815 break;
3816
3817 case 'f':
3818 m_file.SetFile(option_arg, FileSpec::Style::native);
3820 break;
3821
3822 case 'i':
3823 m_include_inlines = false;
3824 break;
3825
3826 case 'l':
3827 if (option_arg.getAsInteger(0, m_line_number))
3829 "invalid line number string '%s'", option_arg.str().c_str());
3830 else if (m_line_number == 0)
3831 error = Status::FromErrorString("zero is an invalid line number");
3833 break;
3834
3835 case 'F':
3836 m_str = std::string(option_arg);
3838 break;
3839
3840 case 'n':
3841 m_str = std::string(option_arg);
3843 break;
3844
3845 case 't':
3846 m_str = std::string(option_arg);
3848 break;
3849
3850 case 'v':
3851 m_verbose = true;
3852 break;
3853
3854 case 'A':
3855 m_print_all = true;
3856 break;
3857
3858 case 'r':
3859 m_use_regex = true;
3860 break;
3861
3862 case '\x01':
3863 m_all_ranges = true;
3864 break;
3865 default:
3866 llvm_unreachable("Unimplemented option");
3867 }
3868
3869 return error;
3870 }
3871
3872 void OptionParsingStarting(ExecutionContext *execution_context) override {
3874 m_str.clear();
3875 m_file.Clear();
3877 m_offset = 0;
3878 m_line_number = 0;
3879 m_use_regex = false;
3880 m_include_inlines = true;
3881 m_all_ranges = false;
3882 m_verbose = false;
3883 m_print_all = false;
3884 }
3885
3886 Status OptionParsingFinished(ExecutionContext *execution_context) override {
3887 Status status;
3888 if (m_all_ranges && !m_verbose) {
3889 status =
3890 Status::FromErrorString("--show-variable-ranges must be used in "
3891 "conjunction with --verbose.");
3892 }
3893 return status;
3894 }
3895
3896 llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
3897 return llvm::ArrayRef(g_target_modules_lookup_options);
3898 }
3899
3900 int m_type; // Should be a eLookupTypeXXX enum after parsing options
3901 std::string m_str; // Holds name lookup
3902 FileSpec m_file; // Files for file lookups
3903 lldb::addr_t m_addr; // Holds the address to lookup
3905 m_offset; // Subtract this offset from m_addr before doing lookups.
3906 uint32_t m_line_number; // Line number for file+line lookups
3907 bool m_use_regex; // Name lookups in m_str are regular expressions.
3908 bool m_include_inlines; // Check for inline entries when looking up by
3909 // file/line.
3910 bool m_all_ranges; // Print all ranges or single range.
3911 bool m_verbose; // Enable verbose lookup info
3912 bool m_print_all; // Print all matches, even in cases where there's a best
3913 // match.
3914 };
3915
3917 : CommandObjectParsed(interpreter, "target modules lookup",
3918 "Look up information within executable and "
3919 "dependent shared library images.",
3920 nullptr, eCommandRequiresTarget) {
3922 }
3923
3925
3926 Options *GetOptions() override { return &m_options; }
3927
3929 bool &syntax_error) {
3930 switch (m_options.m_type) {
3931 case eLookupTypeAddress:
3935 case eLookupTypeSymbol:
3936 default:
3937 return false;
3938 case eLookupTypeType:
3939 break;
3940 }
3941
3943
3944 if (!frame)
3945 return false;
3946
3947 const SymbolContext &sym_ctx(frame->GetSymbolContext(eSymbolContextModule));
3948
3949 if (!sym_ctx.module_sp)
3950 return false;
3951
3952 switch (m_options.m_type) {
3953 default:
3954 return false;
3955 case eLookupTypeType:
3956 if (!m_options.m_str.empty()) {
3958 result.GetOutputStream(), *sym_ctx.module_sp,
3961 return true;
3962 }
3963 }
3964 break;
3965 }
3966
3967 return false;
3968 }
3969
3970 bool LookupInModule(CommandInterpreter &interpreter, Module *module,
3971 CommandReturnObject &result, bool &syntax_error) {
3972 switch (m_options.m_type) {
3973 case eLookupTypeAddress:
3976 m_interpreter, result.GetOutputStream(), module,
3977 eSymbolContextEverything |
3979 ? static_cast<int>(eSymbolContextVariable)
3980 : 0),
3984 return true;
3985 }
3986 }
3987 break;
3988
3989 case eLookupTypeSymbol:
3990 if (!m_options.m_str.empty()) {
3992 module, m_options.m_str.c_str(),
3996 return true;
3997 }
3998 }
3999 break;
4000
4002 if (m_options.m_file) {
4004 m_interpreter, result.GetOutputStream(), module,
4009 return true;
4010 }
4011 }
4012 break;
4013
4016 if (!m_options.m_str.empty()) {
4017 ModuleFunctionSearchOptions function_options;
4018 function_options.include_symbols =
4020 function_options.include_inlines = m_options.m_include_inlines;
4021
4023 module, m_options.m_str.c_str(),
4024 m_options.m_use_regex, function_options,
4028 return true;
4029 }
4030 }
4031 break;
4032
4033 case eLookupTypeType:
4034 if (!m_options.m_str.empty()) {
4036 &GetTarget(), m_interpreter, result.GetOutputStream(), module,
4039 return true;
4040 }
4041 }
4042 break;
4043
4044 default:
4046 result.GetErrorStream(), *this,
4047 GetCommandInterpreter().GetDebugger().GetTerminalWidth());
4048 syntax_error = true;
4049 break;
4050 }
4051
4053 return false;
4054 }
4055
4056protected:
4057 void DoExecute(Args &command, CommandReturnObject &result) override {
4058 Target &target = GetTarget();
4059 bool syntax_error = false;
4060 uint32_t i;
4061 uint32_t num_successful_lookups = 0;
4062 uint32_t addr_byte_size = target.GetArchitecture().GetAddressByteSize();
4063 result.GetOutputStream().SetAddressByteSize(addr_byte_size);
4064 result.GetErrorStream().SetAddressByteSize(addr_byte_size);
4065 // Dump all sections for all modules images
4066
4067 if (command.GetArgumentCount() == 0) {
4068 ModuleSP current_module;
4069
4070 // Where it is possible to look in the current symbol context first,
4071 // try that. If this search was successful and --all was not passed,
4072 // don't print anything else.
4073 if (LookupHere(m_interpreter, result, syntax_error)) {
4074 result.GetOutputStream().EOL();
4075 num_successful_lookups++;
4076 if (!m_options.m_print_all) {
4078 return;
4079 }
4080 }
4081
4082 // Dump all sections for all other modules
4083
4084 const ModuleList &target_modules = target.GetImages();
4085 std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());
4086 if (target_modules.GetSize() == 0) {
4087 result.AppendError("the target has no associated executable images");
4088 return;
4089 }
4090
4091 for (ModuleSP module_sp : target_modules.ModulesNoLocking()) {
4092 if (module_sp != current_module &&
4093 LookupInModule(m_interpreter, module_sp.get(), result,
4094 syntax_error)) {
4095 result.GetOutputStream().EOL();
4096 num_successful_lookups++;
4097 }
4098 }
4099 } else {
4100 // Dump specified images (by basename or fullpath)
4101 const char *arg_cstr;
4102 for (i = 0; (arg_cstr = command.GetArgumentAtIndex(i)) != nullptr &&
4103 !syntax_error;
4104 ++i) {
4105 ModuleList module_list;
4106 const size_t num_matches =
4107 FindModulesByName(&target, arg_cstr, module_list, false);
4108 if (num_matches > 0) {
4109 for (size_t j = 0; j < num_matches; ++j) {
4110 Module *module = module_list.GetModulePointerAtIndex(j);
4111 if (module) {
4112 if (LookupInModule(m_interpreter, module, result, syntax_error)) {
4113 result.GetOutputStream().EOL();
4114 num_successful_lookups++;
4115 }
4116 }
4117 }
4118 } else
4120 "Unable to find an image that matches '%s'.\n", arg_cstr);
4121 }
4122 }
4123
4124 if (num_successful_lookups > 0)
4126 else
4128 }
4129
4131};
4132
4133#pragma mark CommandObjectMultiwordImageSearchPaths
4134
4135// CommandObjectMultiwordImageSearchPaths
4136
4138 : public CommandObjectMultiword {
4139public:
4142 interpreter, "target modules search-paths",
4143 "Commands for managing module search paths for a target.",
4144 "target modules search-paths <subcommand> [<subcommand-options>]") {
4146 "add", CommandObjectSP(
4150 interpreter)));
4152 "insert",
4157 interpreter)));
4160 interpreter)));
4161 }
4162
4164};
4165
4166#pragma mark CommandObjectTargetModules
4167
4168// CommandObjectTargetModules
4169
4171public:
4172 // Constructors and Destructors
4174 : CommandObjectMultiword(interpreter, "target modules",
4175 "Commands for accessing information for one or "
4176 "more target modules.",
4177 "target modules <sub-command> ...") {
4179 "add", CommandObjectSP(new CommandObjectTargetModulesAdd(interpreter)));
4181 interpreter)));
4183 interpreter)));
4185 interpreter)));
4187 "lookup",
4190 "search-paths",
4194 "show-unwind",
4196 }
4197
4198 ~CommandObjectTargetModules() override = default;
4199
4200private:
4201 // For CommandObjectTargetModules only
4205};
4206
4208public:
4211 interpreter, "target symbols add",
4212 "Add a debug symbol file to one of the target's current modules by "
4213 "specifying a path to a debug symbols file or by using the options "
4214 "to specify a module.",
4215 "target symbols add <cmd-options> [<symfile>]",
4216 eCommandRequiresTarget),
4218 LLDB_OPT_SET_1, false, "shlib", 's', lldb::eModuleCompletion,
4220 "Locate the debug symbols for the shared library specified by "
4221 "name."),
4223 LLDB_OPT_SET_2, false, "frame", 'F',
4224 "Locate the debug symbols for the currently selected frame.", false,
4225 true),
4226 m_current_stack_option(LLDB_OPT_SET_2, false, "stack", 'S',
4227 "Locate the debug symbols for every frame in "
4228 "the current call stack.",
4229 false, true)
4230
4231 {
4241 }
4242
4244
4245 Options *GetOptions() override { return &m_option_group; }
4246
4247protected:
4248 bool AddModuleSymbols(Target *target, ModuleSpec &module_spec, bool &flush,
4249 CommandReturnObject &result) {
4250 const FileSpec &symbol_fspec = module_spec.GetSymbolFileSpec();
4251 if (!symbol_fspec) {
4252 result.AppendError(
4253 "one or more executable image paths must be specified");
4254 return false;
4255 }
4256
4257 char symfile_path[PATH_MAX];
4258 symbol_fspec.GetPath(symfile_path, sizeof(symfile_path));
4259
4260 if (!module_spec.GetUUID().IsValid()) {
4261 if (!module_spec.GetFileSpec() && !module_spec.GetPlatformFileSpec())
4262 module_spec.GetFileSpec().SetFilename(symbol_fspec.GetFilename());
4263 }
4264
4265 // Now module_spec represents a symbol file for a module that might exist
4266 // in the current target. Let's find possible matches.
4267 ModuleList matching_modules;
4268
4269 // First extract all module specs from the symbol file
4270 lldb_private::ModuleSpecList symfile_module_specs;
4272 0, 0, symfile_module_specs)) {
4273 // Now extract the module spec that matches the target architecture
4274 ModuleSpec target_arch_module_spec;
4275 ModuleSpec symfile_module_spec;
4276 target_arch_module_spec.GetArchitecture() = target->GetArchitecture();
4277 if (symfile_module_specs.FindMatchingModuleSpec(target_arch_module_spec,
4278 symfile_module_spec)) {
4279 if (symfile_module_spec.GetUUID().IsValid()) {
4280 // It has a UUID, look for this UUID in the target modules
4281 ModuleSpec symfile_uuid_module_spec;
4282 symfile_uuid_module_spec.GetUUID() = symfile_module_spec.GetUUID();
4283 target->GetImages().FindModules(symfile_uuid_module_spec,
4284 matching_modules);
4285 }
4286 }
4287
4288 if (matching_modules.IsEmpty()) {
4289 // No matches yet. Iterate through the module specs to find a UUID
4290 // value that we can match up to an image in our target.
4291 const size_t num_symfile_module_specs = symfile_module_specs.GetSize();
4292 for (size_t i = 0;
4293 i < num_symfile_module_specs && matching_modules.IsEmpty(); ++i) {
4294 if (symfile_module_specs.GetModuleSpecAtIndex(
4295 i, symfile_module_spec)) {
4296 if (symfile_module_spec.GetUUID().IsValid()) {
4297 // It has a UUID. Look for this UUID in the target modules.
4298 ModuleSpec symfile_uuid_module_spec;
4299 symfile_uuid_module_spec.GetUUID() =
4300 symfile_module_spec.GetUUID();
4301 target->GetImages().FindModules(symfile_uuid_module_spec,
4302 matching_modules);
4303 }
4304 }
4305 }
4306 }
4307 }
4308
4309 // Just try to match up the file by basename if we have no matches at
4310 // this point. For example, module foo might have symbols in foo.debug.
4311 if (matching_modules.IsEmpty())
4312 target->GetImages().FindModules(module_spec, matching_modules);
4313
4314 while (matching_modules.IsEmpty()) {
4315 ConstString filename_no_extension(
4317 // Empty string returned, let's bail
4318 if (!filename_no_extension)
4319 break;
4320
4321 // Check if there was no extension to strip and the basename is the same
4322 if (filename_no_extension == module_spec.GetFileSpec().GetFilename())
4323 break;
4324
4325 // Replace basename with one fewer extension
4326 module_spec.GetFileSpec().SetFilename(filename_no_extension);
4327 target->GetImages().FindModules(module_spec, matching_modules);
4328 }
4329
4330 if (matching_modules.GetSize() > 1) {
4331 result.AppendErrorWithFormat("multiple modules match symbol file '%s', "
4332 "use the --uuid option to resolve the "
4333 "ambiguity.\n",
4334 symfile_path);
4335 return false;
4336 }
4337
4338 if (matching_modules.GetSize() == 1) {
4339 ModuleSP module_sp(matching_modules.GetModuleAtIndex(0));
4340
4341 // The module has not yet created its symbol vendor, we can just give
4342 // the existing target module the symfile path to use for when it
4343 // decides to create it!
4344 module_sp->SetSymbolFileFileSpec(symbol_fspec);
4345
4346 SymbolFile *symbol_file =
4347 module_sp->GetSymbolFile(true, &result.GetErrorStream());
4348 if (symbol_file) {
4349 ObjectFile *object_file = symbol_file->GetObjectFile();
4350 if (object_file && object_file->GetFileSpec() == symbol_fspec) {
4351 // Provide feedback that the symfile has been successfully added.
4352 const FileSpec &module_fs = module_sp->GetFileSpec();
4354 "symbol file '%s' has been added to '%s'\n", symfile_path,
4355 module_fs.GetPath().c_str());
4356
4357 // Let clients know something changed in the module if it is
4358 // currently loaded
4359 ModuleList module_list;
4360 module_list.Append(module_sp);
4361 target->SymbolsDidLoad(module_list);
4362
4363 // Make sure we load any scripting resources that may be embedded
4364 // in the debug info files in case the platform supports that.
4365 Status error;
4366 StreamString feedback_stream;
4367 module_sp->LoadScriptingResourceInTarget(target, error,
4368 feedback_stream);
4369 if (error.Fail() && error.AsCString())
4371 "unable to load scripting data for module %s - error "
4372 "reported was %s",
4373 module_sp->GetFileSpec()
4374 .GetFileNameStrippingExtension()
4375 .GetCString(),
4376 error.AsCString());
4377 else if (feedback_stream.GetSize())
4378 result.AppendWarning(feedback_stream.GetData());
4379
4380 flush = true;
4382 return true;
4383 }
4384 }
4385 // Clear the symbol file spec if anything went wrong
4386 module_sp->SetSymbolFileFileSpec(FileSpec());
4387 }
4388
4389 StreamString ss_symfile_uuid;
4390 if (module_spec.GetUUID().IsValid()) {
4391 ss_symfile_uuid << " (";
4392 module_spec.GetUUID().Dump(ss_symfile_uuid);
4393 ss_symfile_uuid << ')';
4394 }
4395 result.AppendErrorWithFormat(
4396 "symbol file '%s'%s does not match any existing module%s\n",
4397 symfile_path, ss_symfile_uuid.GetData(),
4398 !llvm::sys::fs::is_regular_file(symbol_fspec.GetPath())
4399 ? "\n please specify the full path to the symbol file"
4400 : "");
4401 return false;
4402 }
4403
4405 CommandReturnObject &result, bool &flush) {
4406 Status error;
4408 if (module_spec.GetSymbolFileSpec())
4409 return AddModuleSymbols(m_exe_ctx.GetTargetPtr(), module_spec, flush,
4410 result);
4411 } else {
4412 result.SetError(std::move(error));
4413 }
4414 return false;
4415 }
4416
4417 bool AddSymbolsForUUID(CommandReturnObject &result, bool &flush) {
4419
4420 ModuleSpec module_spec;
4421 module_spec.GetUUID() =
4423
4424 if (!DownloadObjectAndSymbolFile(module_spec, result, flush)) {
4425 StreamString error_strm;
4426 error_strm.PutCString("unable to find debug symbols for UUID ");
4427 module_spec.GetUUID().Dump(error_strm);
4428 result.AppendError(error_strm.GetString());
4429 return false;
4430 }
4431
4432 return true;
4433 }
4434
4435 bool AddSymbolsForFile(CommandReturnObject &result, bool &flush) {
4437
4438 ModuleSpec module_spec;
4439 module_spec.GetFileSpec() =
4441
4442 Target *target = m_exe_ctx.GetTargetPtr();
4443 ModuleSP module_sp(target->GetImages().FindFirstModule(module_spec));
4444 if (module_sp) {
4445 module_spec.GetFileSpec() = module_sp->GetFileSpec();
4446 module_spec.GetPlatformFileSpec() = module_sp->GetPlatformFileSpec();
4447 module_spec.GetUUID() = module_sp->GetUUID();
4448 module_spec.GetArchitecture() = module_sp->GetArchitecture();
4449 } else {
4450 module_spec.GetArchitecture() = target->GetArchitecture();
4451 }
4452
4453 if (!DownloadObjectAndSymbolFile(module_spec, result, flush)) {
4454 StreamString error_strm;
4455 error_strm.PutCString(
4456 "unable to find debug symbols for the executable file ");
4457 error_strm << module_spec.GetFileSpec();
4458 result.AppendError(error_strm.GetString());
4459 return false;
4460 }
4461
4462 return true;
4463 }
4464
4465 bool AddSymbolsForFrame(CommandReturnObject &result, bool &flush) {
4467
4468 Process *process = m_exe_ctx.GetProcessPtr();
4469 if (!process) {
4470 result.AppendError(
4471 "a process must exist in order to use the --frame option");
4472 return false;
4473 }
4474
4475 const StateType process_state = process->GetState();
4476 if (!StateIsStoppedState(process_state, true)) {
4477 result.AppendErrorWithFormat("process is not stopped: %s",
4478 StateAsCString(process_state));
4479 return false;
4480 }
4481
4482 StackFrame *frame = m_exe_ctx.GetFramePtr();
4483 if (!frame) {
4484 result.AppendError("invalid current frame");
4485 return false;
4486 }
4487
4488 ModuleSP frame_module_sp(
4489 frame->GetSymbolContext(eSymbolContextModule).module_sp);
4490 if (!frame_module_sp) {
4491 result.AppendError("frame has no module");
4492 return false;
4493 }
4494
4495 ModuleSpec module_spec;
4496 module_spec.GetUUID() = frame_module_sp->GetUUID();
4497 module_spec.GetArchitecture() = frame_module_sp->GetArchitecture();
4498 module_spec.GetFileSpec() = frame_module_sp->GetPlatformFileSpec();
4499
4500 if (!DownloadObjectAndSymbolFile(module_spec, result, flush)) {
4501 result.AppendError("unable to find debug symbols for the current frame");
4502 return false;
4503 }
4504
4505 return true;
4506 }
4507
4508 bool AddSymbolsForStack(CommandReturnObject &result, bool &flush) {
4510
4511 Process *process = m_exe_ctx.GetProcessPtr();
4512 if (!process) {
4513 result.AppendError(
4514 "a process must exist in order to use the --stack option");
4515 return false;
4516 }
4517
4518 const StateType process_state = process->GetState();
4519 if (!StateIsStoppedState(process_state, true)) {
4520 result.AppendErrorWithFormat("process is not stopped: %s",
4521 StateAsCString(process_state));
4522 return false;
4523 }
4524
4525 Thread *thread = m_exe_ctx.GetThreadPtr();
4526 if (!thread) {
4527 result.AppendError("invalid current thread");
4528 return false;
4529 }
4530
4531 bool symbols_found = false;
4532 uint32_t frame_count = thread->GetStackFrameCount();
4533 for (uint32_t i = 0; i < frame_count; ++i) {
4534 lldb::StackFrameSP frame_sp = thread->GetStackFrameAtIndex(i);
4535
4536 ModuleSP frame_module_sp(
4537 frame_sp->GetSymbolContext(eSymbolContextModule).module_sp);
4538 if (!frame_module_sp)
4539 continue;
4540
4541 ModuleSpec module_spec;
4542 module_spec.GetUUID() = frame_module_sp->GetUUID();
4543 module_spec.GetFileSpec() = frame_module_sp->GetPlatformFileSpec();
4544 module_spec.GetArchitecture() = frame_module_sp->GetArchitecture();
4545
4546 bool current_frame_flush = false;
4547 if (DownloadObjectAndSymbolFile(module_spec, result, current_frame_flush))
4548 symbols_found = true;
4549 flush |= current_frame_flush;
4550 }
4551
4552 if (!symbols_found) {
4553 result.AppendError(
4554 "unable to find debug symbols in the current call stack");
4555 return false;
4556 }
4557
4558 return true;
4559 }
4560
4561 void DoExecute(Args &args, CommandReturnObject &result) override {
4562 Target *target = m_exe_ctx.GetTargetPtr();
4564 bool flush = false;
4565 ModuleSpec module_spec;
4566 const bool uuid_option_set =
4568 const bool file_option_set = m_file_option.GetOptionValue().OptionWasSet();
4569 const bool frame_option_set =
4571 const bool stack_option_set =
4573 const size_t argc = args.GetArgumentCount();
4574
4575 if (argc == 0) {
4576 if (uuid_option_set)
4577 AddSymbolsForUUID(result, flush);
4578 else if (file_option_set)
4579 AddSymbolsForFile(result, flush);
4580 else if (frame_option_set)
4581 AddSymbolsForFrame(result, flush);
4582 else if (stack_option_set)
4583 AddSymbolsForStack(result, flush);
4584 else
4585 result.AppendError("one or more symbol file paths must be specified, "
4586 "or options must be specified");
4587 } else {
4588 if (uuid_option_set) {
4589 result.AppendError("specify either one or more paths to symbol files "
4590 "or use the --uuid option without arguments");
4591 } else if (frame_option_set) {
4592 result.AppendError("specify either one or more paths to symbol files "
4593 "or use the --frame option without arguments");
4594 } else if (file_option_set && argc > 1) {
4595 result.AppendError("specify at most one symbol file path when "
4596 "--shlib option is set");
4597 } else {
4598 PlatformSP platform_sp(target->GetPlatform());
4599
4600 for (auto &entry : args.entries()) {
4601 if (!entry.ref().empty()) {
4602 auto &symbol_file_spec = module_spec.GetSymbolFileSpec();
4603 symbol_file_spec.SetFile(entry.ref(), FileSpec::Style::native);
4604 FileSystem::Instance().Resolve(symbol_file_spec);
4605 if (file_option_set) {
4606 module_spec.GetFileSpec() =
4608 }
4609 if (platform_sp) {
4610 FileSpec symfile_spec;
4611 if (platform_sp
4612 ->ResolveSymbolFile(*target, module_spec, symfile_spec)
4613 .Success())
4614 module_spec.GetSymbolFileSpec() = symfile_spec;
4615 }
4616
4617 bool symfile_exists =
4619
4620 if (symfile_exists) {
4621 if (!AddModuleSymbols(target, module_spec, flush, result))
4622 break;
4623 } else {
4624 std::string resolved_symfile_path =
4625 module_spec.GetSymbolFileSpec().GetPath();
4626 if (resolved_symfile_path != entry.ref()) {
4627 result.AppendErrorWithFormat(
4628 "invalid module path '%s' with resolved path '%s'\n",
4629 entry.c_str(), resolved_symfile_path.c_str());
4630 break;
4631 }
4632 result.AppendErrorWithFormat("invalid module path '%s'\n",
4633 entry.c_str());
4634 break;
4635 }
4636 }
4637 }
4638 }
4639 }
4640
4641 if (flush) {
4642 Process *process = m_exe_ctx.GetProcessPtr();
4643 if (process)
4644 process->Flush();
4645 }
4646 }
4647
4653};
4654
4655#pragma mark CommandObjectTargetSymbols
4656
4657// CommandObjectTargetSymbols
4658
4660public:
4661 // Constructors and Destructors
4664 interpreter, "target symbols",
4665 "Commands for adding and managing debug symbol files.",
4666 "target symbols <sub-command> ...") {
4668 "add", CommandObjectSP(new CommandObjectTargetSymbolsAdd(interpreter)));
4669 }
4670
4671 ~CommandObjectTargetSymbols() override = default;
4672
4673private:
4674 // For CommandObjectTargetModules only
4678};
4679
4680#pragma mark CommandObjectTargetStopHookAdd
4681
4682// CommandObjectTargetStopHookAdd
4683#define LLDB_OPTIONS_target_stop_hook_add
4684#include "CommandOptions.inc"
4685
4688public:
4690 public:
4692
4693 ~CommandOptions() override = default;
4694
4695 llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
4696 return llvm::ArrayRef(g_target_stop_hook_add_options);
4697 }
4698
4699 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
4700 ExecutionContext *execution_context) override {
4701 Status error;
4702 const int short_option =
4703 g_target_stop_hook_add_options[option_idx].short_option;
4704
4705 switch (short_option) {
4706 case 'c':
4707 m_class_name = std::string(option_arg);
4708 m_sym_ctx_specified = true;
4709 break;
4710
4711 case 'e':
4712 if (option_arg.getAsInteger(0, m_line_end)) {
4714 "invalid end line number: \"%s\"", option_arg.str().c_str());
4715 break;
4716 }
4717 m_sym_ctx_specified = true;
4718 break;
4719
4720 case 'G': {
4721 bool value, success;
4722 value = OptionArgParser::ToBoolean(option_arg, false, &success);
4723 if (success) {
4724 m_auto_continue = value;
4725 } else
4727 "invalid boolean value '%s' passed for -G option",
4728 option_arg.str().c_str());
4729 } break;
4730 case 'l':
4731 if (option_arg.getAsInteger(0, m_line_start)) {
4733 "invalid start line number: \"%s\"", option_arg.str().c_str());
4734 break;
4735 }
4736 m_sym_ctx_specified = true;
4737 break;
4738
4739 case 'i':
4740 m_no_inlines = true;
4741 break;
4742
4743 case 'n':
4744 m_function_name = std::string(option_arg);
4745 m_func_name_type_mask |= eFunctionNameTypeAuto;
4746 m_sym_ctx_specified = true;
4747 break;
4748
4749 case 'f':
4750 m_file_name = std::string(option_arg);
4751 m_sym_ctx_specified = true;
4752 break;
4753
4754 case 's':
4755 m_module_name = std::string(option_arg);
4756 m_sym_ctx_specified = true;
4757 break;
4758
4759 case 't':
4760 if (option_arg.getAsInteger(0, m_thread_id))
4762 "invalid thread id string '%s'", option_arg.str().c_str());
4763 m_thread_specified = true;
4764 break;
4765
4766 case 'T':
4767 m_thread_name = std::string(option_arg);
4768 m_thread_specified = true;
4769 break;
4770
4771 case 'q':
4772 m_queue_name = std::string(option_arg);
4773 m_thread_specified = true;
4774 break;
4775
4776 case 'x':
4777 if (option_arg.getAsInteger(0, m_thread_index))
4779 "invalid thread index string '%s'", option_arg.str().c_str());
4780 m_thread_specified = true;
4781 break;
4782
4783 case 'o':
4784 m_use_one_liner = true;
4785 m_one_liner.push_back(std::string(option_arg));
4786 break;
4787
4788 default:
4789 llvm_unreachable("Unimplemented option");
4790 }
4791 return error;
4792 }
4793
4794 void OptionParsingStarting(ExecutionContext *execution_context) override {
4795 m_class_name.clear();
4796 m_function_name.clear();
4797 m_line_start = 0;
4799 m_file_name.clear();
4800 m_module_name.clear();
4801 m_func_name_type_mask = eFunctionNameTypeAuto;
4804 m_thread_name.clear();
4805 m_queue_name.clear();
4806
4807 m_no_inlines = false;
4808 m_sym_ctx_specified = false;
4809 m_thread_specified = false;
4810
4811 m_use_one_liner = false;
4812 m_one_liner.clear();
4813 m_auto_continue = false;
4814 }
4815
4816 std::string m_class_name;
4817 std::string m_function_name;
4818 uint32_t m_line_start = 0;
4820 std::string m_file_name;
4821 std::string m_module_name;
4823 eFunctionNameTypeAuto; // A pick from lldb::FunctionNameType.
4826 std::string m_thread_name;
4827 std::string m_queue_name;
4829 bool m_no_inlines = false;
4831 // Instance variables to hold the values for one_liner options.
4832 bool m_use_one_liner = false;
4833 std::vector<std::string> m_one_liner;
4834
4835 bool m_auto_continue = false;
4836 };
4837
4839 : CommandObjectParsed(interpreter, "target stop-hook add",
4840 "Add a hook to be executed when the target stops."
4841 "The hook can either be a list of commands or an "
4842 "appropriately defined Python class. You can also "
4843 "add filters so the hook only runs a certain stop "
4844 "points.",
4845 "target stop-hook add"),
4848 m_python_class_options("scripted stop-hook", true, 'P') {
4850 R"(
4851Command Based stop-hooks:
4852-------------------------
4853 Stop hooks can run a list of lldb commands by providing one or more
4854 --one-line-command options. The commands will get run in the order they are
4855 added. Or you can provide no commands, in which case you will enter a
4856 command editor where you can enter the commands to be run.
4857
4858Python Based Stop Hooks:
4859------------------------
4860 Stop hooks can be implemented with a suitably defined Python class, whose name
4861 is passed in the --python-class option.
4862
4863 When the stop hook is added, the class is initialized by calling:
4864
4865 def __init__(self, target, extra_args, internal_dict):
4866
4867 target: The target that the stop hook is being added to.
4868 extra_args: An SBStructuredData Dictionary filled with the -key -value
4869 option pairs passed to the command.
4870 dict: An implementation detail provided by lldb.
4871
4872 Then when the stop-hook triggers, lldb will run the 'handle_stop' method.
4873 The method has the signature:
4874
4875 def handle_stop(self, exe_ctx, stream):
4876
4877 exe_ctx: An SBExecutionContext for the thread that has stopped.
4878 stream: An SBStream, anything written to this stream will be printed in the
4879 the stop message when the process stops.
4880
4881 Return Value: The method returns "should_stop". If should_stop is false
4882 from all the stop hook executions on threads that stopped
4883 with a reason, then the process will continue. Note that this
4884 will happen only after all the stop hooks are run.
4885
4886Filter Options:
4887---------------
4888 Stop hooks can be set to always run, or to only run when the stopped thread
4889 matches the filter options passed on the command line. The available filter
4890 options include a shared library or a thread or queue specification,
4891 a line range in a source file, a function name or a class name.
4892 )");
4895 LLDB_OPT_SET_FROM_TO(4, 6));
4898 }
4899
4900 ~CommandObjectTargetStopHookAdd() override = default;
4901
4902 Options *GetOptions() override { return &m_all_options; }
4903
4904protected:
4905 void IOHandlerActivated(IOHandler &io_handler, bool interactive) override {
4906 StreamFileSP output_sp(io_handler.GetOutputStreamFileSP());
4907 if (output_sp && interactive) {
4908 output_sp->PutCString(
4909 "Enter your stop hook command(s). Type 'DONE' to end.\n");
4910 output_sp->Flush();
4911 }
4912 }
4913
4914 void IOHandlerInputComplete(IOHandler &io_handler,
4915 std::string &line) override {
4916 if (m_stop_hook_sp) {
4917 if (line.empty()) {
4918 StreamFileSP error_sp(io_handler.GetErrorStreamFileSP());
4919 if (error_sp) {
4920 error_sp->Printf("error: stop hook #%" PRIu64
4921 " aborted, no commands.\n",
4922 m_stop_hook_sp->GetID());
4923 error_sp->Flush();
4924 }
4926 } else {
4927 // The IOHandler editor is only for command lines stop hooks:
4928 Target::StopHookCommandLine *hook_ptr =
4929 static_cast<Target::StopHookCommandLine *>(m_stop_hook_sp.get());
4930
4931 hook_ptr->SetActionFromString(line);
4932 StreamFileSP output_sp(io_handler.GetOutputStreamFileSP());
4933 if (output_sp) {
4934 output_sp->Printf("Stop hook #%" PRIu64 " added.\n",
4935 m_stop_hook_sp->GetID());
4936 output_sp->Flush();
4937 }
4938 }
4939 m_stop_hook_sp.reset();
4940 }
4941 io_handler.SetIsDone(true);
4942 }
4943
4944 void DoExecute(Args &command, CommandReturnObject &result) override {
4945 m_stop_hook_sp.reset();
4946
4947 Target &target = GetTarget();
4948 Target::StopHookSP new_hook_sp =
4950 Target::StopHook::StopHookKind::CommandBased
4951 : Target::StopHook::StopHookKind::ScriptBased);
4952
4953 // First step, make the specifier.
4954 std::unique_ptr<SymbolContextSpecifier> specifier_up;
4956 specifier_up = std::make_unique<SymbolContextSpecifier>(
4957 GetDebugger().GetSelectedTarget());
4958
4959 if (!m_options.m_module_name.empty()) {
4960 specifier_up->AddSpecification(
4961 m_options.m_module_name.c_str(),
4963 }
4964
4965 if (!m_options.m_class_name.empty()) {
4966 specifier_up->AddSpecification(
4967 m_options.m_class_name.c_str(),
4969 }
4970
4971 if (!m_options.m_file_name.empty()) {
4972 specifier_up->AddSpecification(m_options.m_file_name.c_str(),
4974 }
4975
4976 if (m_options.m_line_start != 0) {
4977 specifier_up->AddLineSpecification(
4980 }
4981
4982 if (m_options.m_line_end != UINT_MAX) {
4983 specifier_up->AddLineSpecification(
4985 }
4986
4987 if (!m_options.m_function_name.empty()) {
4988 specifier_up->AddSpecification(
4989 m_options.m_function_name.c_str(),
4991 }
4992 }
4993
4994 if (specifier_up)
4995 new_hook_sp->SetSpecifier(specifier_up.release());
4996
4997 // Next see if any of the thread options have been entered:
4998
5000 ThreadSpec *thread_spec = new ThreadSpec();
5001
5003 thread_spec->SetTID(m_options.m_thread_id);
5004 }
5005
5007 thread_spec->SetIndex(m_options.m_thread_index);
5008
5009 if (!m_options.m_thread_name.empty())
5010 thread_spec->SetName(m_options.m_thread_name.c_str());
5013 thread_spec->SetQueueName(m_options.m_queue_name.c_str());
5015 new_hook_sp->SetThreadSpecifier(thread_spec);
5016 }
5017
5018 new_hook_sp->SetAutoContinue(m_options.m_auto_continue);
5020 // This is a command line stop hook:
5021 Target::StopHookCommandLine *hook_ptr =
5022 static_cast<Target::StopHookCommandLine *>(new_hook_sp.get());
5024 result.AppendMessageWithFormat("Stop hook #%" PRIu64 " added.\n",
5025 new_hook_sp->GetID());
5026 } else if (!m_python_class_options.GetName().empty()) {
5027 // This is a scripted stop hook:
5028 Target::StopHookScripted *hook_ptr =
5029 static_cast<Target::StopHookScripted *>(new_hook_sp.get());
5030 Status error = hook_ptr->SetScriptCallback(
5033 if (error.Success())
5034 result.AppendMessageWithFormat("Stop hook #%" PRIu64 " added.\n",
5035 new_hook_sp->GetID());
5036 else {
5037 // FIXME: Set the stop hook ID counter back.
5038 result.AppendErrorWithFormat("Couldn't add stop hook: %s",
5039 error.AsCString());
5040 target.UndoCreateStopHook(new_hook_sp->GetID());
5041 return;
5042 }
5043 } else {
5044 m_stop_hook_sp = new_hook_sp;
5046 *this); // IOHandlerDelegate
5047 }
5049 }
5050
5051private:
5052 CommandOptions m_options;
5055
5057};
5058
5059#pragma mark CommandObjectTargetStopHookDelete
5060
5061// CommandObjectTargetStopHookDelete
5062
5064public:
5066 : CommandObjectParsed(interpreter, "target stop-hook delete",
5067 "Delete a stop-hook.",
5068 "target stop-hook delete [<idx>]") {
5070 }
5071
5073
5074 void
5076 OptionElementVector &opt_element_vector) override {
5077 if (request.GetCursorIndex())
5078 return;
5079 CommandObject::HandleArgumentCompletion(request, opt_element_vector);
5080 }
5081
5082protected:
5083 void DoExecute(Args &command, CommandReturnObject &result) override {
5084 Target &target = GetTarget();
5085 // FIXME: see if we can use the breakpoint id style parser?
5086 size_t num_args = command.GetArgumentCount();
5087 if (num_args == 0) {
5088 if (!m_interpreter.Confirm("Delete all stop hooks?", true)) {
5090 return;
5091 } else {
5092 target.RemoveAllStopHooks();
5093 }
5094 } else {
5095 for (size_t i = 0; i < num_args; i++) {
5096 lldb::user_id_t user_id;
5097 if (!llvm::to_integer(command.GetArgumentAtIndex(i), user_id)) {
5098 result.AppendErrorWithFormat("invalid stop hook id: \"%s\".\n",
5099 command.GetArgumentAtIndex(i));
5100 return;
5101 }
5102 if (!target.RemoveStopHookByID(user_id)) {
5103 result.AppendErrorWithFormat("unknown stop hook id: \"%s\".\n",
5104 command.GetArgumentAtIndex(i));
5105 return;
5106 }
5107 }
5108 }
5110 }
5111};
5112
5113#pragma mark CommandObjectTargetStopHookEnableDisable
5114
5115// CommandObjectTargetStopHookEnableDisable
5116
5118public:
5120 bool enable, const char *name,
5121 const char *help, const char *syntax)
5122 : CommandObjectParsed(interpreter, name, help, syntax), m_enable(enable) {
5124 }
5125
5127
5128 void
5130 OptionElementVector &opt_element_vector) override {
5131 if (request.GetCursorIndex())
5132 return;
5133 CommandObject::HandleArgumentCompletion(request, opt_element_vector);
5134 }
5135
5136protected:
5137 void DoExecute(Args &command, CommandReturnObject &result) override {
5138 Target &target = GetTarget();
5139 // FIXME: see if we can use the breakpoint id style parser?
5140 size_t num_args = command.GetArgumentCount();
5141 bool success;
5142
5143 if (num_args == 0) {
5145 } else {
5146 for (size_t i = 0; i < num_args; i++) {
5147 lldb::user_id_t user_id;
5148 if (!llvm::to_integer(command.GetArgumentAtIndex(i), user_id)) {
5149 result.AppendErrorWithFormat("invalid stop hook id: \"%s\".\n",
5150 command.GetArgumentAtIndex(i));
5151 return;
5152 }
5153 success = target.SetStopHookActiveStateByID(user_id, m_enable);
5154 if (!success) {
5155 result.AppendErrorWithFormat("unknown stop hook id: \"%s\".\n",
5156 command.GetArgumentAtIndex(i));
5157 return;
5158 }
5159 }
5160 }
5162 }
5163
5164private:
5166};
5167
5168#pragma mark CommandObjectTargetStopHookList
5169
5170// CommandObjectTargetStopHookList
5171
5173public:
5175 : CommandObjectParsed(interpreter, "target stop-hook list",
5176 "List all stop-hooks.", "target stop-hook list") {}
5177
5179
5180protected:
5181 void DoExecute(Args &command, CommandReturnObject &result) override {
5182 Target &target = GetTarget();
5183
5184 size_t num_hooks = target.GetNumStopHooks();
5185 if (num_hooks == 0) {
5186 result.GetOutputStream().PutCString("No stop hooks.\n");
5187 } else {
5188 for (size_t i = 0; i < num_hooks; i++) {
5189 Target::StopHookSP this_hook = target.GetStopHookAtIndex(i);
5190 if (i > 0)
5191 result.GetOutputStream().PutCString("\n");
5192 this_hook->GetDescription(result.GetOutputStream(),
5194 }
5195 }
5197 }
5198};
5199
5200#pragma mark CommandObjectMultiwordTargetStopHooks
5201
5202// CommandObjectMultiwordTargetStopHooks
5203
5205public:
5208 interpreter, "target stop-hook",
5209 "Commands for operating on debugger target stop-hooks.",
5210 "target stop-hook <subcommand> [<subcommand-options>]") {
5212 new CommandObjectTargetStopHookAdd(interpreter)));
5214 "delete",
5216 LoadSubCommand("disable",
5218 interpreter, false, "target stop-hook disable [<id>]",
5219 "Disable a stop-hook.", "target stop-hook disable")));
5220 LoadSubCommand("enable",
5222 interpreter, true, "target stop-hook enable [<id>]",
5223 "Enable a stop-hook.", "target stop-hook enable")));
5225 interpreter)));
5226 }
5227
5229};
5230
5231#pragma mark CommandObjectTargetDumpTypesystem
5232
5233/// Dumps the TypeSystem of the selected Target.
5235public:
5238 interpreter, "target dump typesystem",
5239 "Dump the state of the target's internal type system. Intended to "
5240 "be used for debugging LLDB itself.",
5241 nullptr, eCommandRequiresTarget) {}
5242
5244
5245protected:
5246 void DoExecute(Args &command, CommandReturnObject &result) override {
5247 // Go over every scratch TypeSystem and dump to the command output.
5248 for (lldb::TypeSystemSP ts : GetTarget().GetScratchTypeSystems())
5249 if (ts)
5250 ts->Dump(result.GetOutputStream().AsRawOstream());
5251
5253 }
5254};
5255
5256#pragma mark CommandObjectTargetDumpSectionLoadList
5257
5258/// Dumps the SectionLoadList of the selected Target.
5260public:
5263 interpreter, "target dump section-load-list",
5264 "Dump the state of the target's internal section load list. "
5265 "Intended to be used for debugging LLDB itself.",
5266 nullptr, eCommandRequiresTarget) {}
5267
5269
5270protected:
5271 void DoExecute(Args &command, CommandReturnObject &result) override {
5272 Target &target = GetTarget();
5273 target.GetSectionLoadList().Dump(result.GetOutputStream(), &target);
5275 }
5276};
5277
5278#pragma mark CommandObjectTargetDump
5279
5280/// Multi-word command for 'target dump'.
5282public:
5283 // Constructors and Destructors
5286 interpreter, "target dump",
5287 "Commands for dumping information about the target.",
5288 "target dump [typesystem|section-load-list]") {
5290 "typesystem",
5292 LoadSubCommand("section-load-list",
5294 interpreter)));
5295 }
5296
5297 ~CommandObjectTargetDump() override = default;
5298};
5299
5300#pragma mark CommandObjectMultiwordTarget
5301
5302// CommandObjectMultiwordTarget
5303
5305 CommandInterpreter &interpreter)
5306 : CommandObjectMultiword(interpreter, "target",
5307 "Commands for operating on debugger targets.",
5308 "target <subcommand> [<subcommand-options>]") {
5309 LoadSubCommand("create",
5310 CommandObjectSP(new CommandObjectTargetCreate(interpreter)));
5311 LoadSubCommand("delete",
5312 CommandObjectSP(new CommandObjectTargetDelete(interpreter)));
5313 LoadSubCommand("dump",
5314 CommandObjectSP(new CommandObjectTargetDump(interpreter)));
5315 LoadSubCommand("list",
5316 CommandObjectSP(new CommandObjectTargetList(interpreter)));
5317 LoadSubCommand("select",
5318 CommandObjectSP(new CommandObjectTargetSelect(interpreter)));
5319 LoadSubCommand("show-launch-environment",
5321 interpreter)));
5323 "stop-hook",
5325 LoadSubCommand("modules",
5327 LoadSubCommand("symbols",
5329 LoadSubCommand("variable",
5331}
5332
@ ehframe_sp
static bool GetSeparateDebugInfoList(StructuredData::Array &list, Module *module, bool errors_only)
static void DumpAddress(ExecutionContextScope *exe_scope, const Address &so_addr, bool verbose, bool all_ranges, Stream &strm, std::optional< Stream::HighlightSettings > settings=std::nullopt)
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.
Definition: Debugger.h:454
#define LLDB_LOGF(log,...)
Definition: Log.h:376
#define LLDB_SCOPED_TIMERF(...)
Definition: Timer.h:86
~CommandObjectMultiwordTargetStopHooks() override=default
CommandObjectMultiwordTargetStopHooks(CommandInterpreter &interpreter)
OptionGroupPlatform m_platform_options
~CommandObjectTargetCreate() override=default
Options * GetOptions() override
OptionGroupArchitecture m_arch_option
CommandObjectTargetCreate(CommandInterpreter &interpreter)
OptionGroupDependents m_add_dependents
void DoExecute(Args &command, CommandReturnObject &result) override
OptionGroupBoolean m_cleanup_option
void DoExecute(Args &args, CommandReturnObject &result) override
CommandObjectTargetDelete(CommandInterpreter &interpreter)
~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
CommandObjectTargetModulesAdd(CommandInterpreter &interpreter)
void DoExecute(Args &args, CommandReturnObject &result) override
~CommandObjectTargetModulesAdd() override=default
CommandObjectTargetModulesDumpClangAST(CommandInterpreter &interpreter)
void DoExecute(Args &command, CommandReturnObject &result) override
~CommandObjectTargetModulesDumpClangAST() override=default
~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
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
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
Set the value of an option.
~CommandObjectTargetModulesDumpSeparateDebugInfoFiles() override=default
CommandObjectTargetModulesDumpSeparateDebugInfoFiles(CommandInterpreter &interpreter)
void DoExecute(Args &command, CommandReturnObject &result) override
CommandObjectTargetModulesDumpSymfile(CommandInterpreter &interpreter)
~CommandObjectTargetModulesDumpSymfile() override=default
void DoExecute(Args &command, CommandReturnObject &result) override
void OptionParsingStarting(ExecutionContext *execution_context) override
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
Set the value of an option.
llvm::ArrayRef< OptionDefinition > GetDefinitions() 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
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
void OptionParsingStarting(ExecutionContext *execution_context) override
std::vector< std::pair< char, uint32_t > > FormatWidthCollection
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
Set the value of an option.
CommandObjectTargetModulesList(CommandInterpreter &interpreter)
~CommandObjectTargetModulesList() override=default
void DoExecute(Args &command, CommandReturnObject &result) override
void PrintModule(Target &target, Module *module, int indent, Stream &strm)
void DoExecute(Args &args, CommandReturnObject &result) override
~CommandObjectTargetModulesLoad() override=default
CommandObjectTargetModulesLoad(CommandInterpreter &interpreter)
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)
~CommandObjectTargetModulesLookup() override=default
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
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
CommandObjectTargetModulesShowUnwind(CommandInterpreter &interpreter)
void DoExecute(Args &command, CommandReturnObject &result) 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
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
void OptionParsingStarting(ExecutionContext *execution_context) override
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
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)
CommandObjectTargetSymbolsAdd(CommandInterpreter &interpreter)
bool AddSymbolsForFrame(CommandReturnObject &result, bool &flush)
~CommandObjectTargetSymbolsAdd() override=default
void DoExecute(Args &args, CommandReturnObject &result) override
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
void DumpValueObject(Stream &s, VariableSP &var_sp, ValueObjectSP &valobj_sp, const char *root_name)
void DumpGlobalVariableList(const ExecutionContext &exe_ctx, const SymbolContext &sc, const VariableList &variable_list, Stream &s)
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
OptionGroupFileList m_option_compile_units
static const uint32_t SHORT_OPTION_FILE
OptionGroupVariable m_option_variable
OptionGroupValueObjectDisplay m_varobj_options
~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.
Definition: ABI.cpp:150
A section + offset based address range class.
Definition: AddressRange.h:25
Address & GetBaseAddress()
Get accessor for the base address of the range.
Definition: AddressRange.h:211
A section + offset based address class.
Definition: Address.h:62
lldb::addr_t GetLoadAddress(Target *target) const
Get the load address.
Definition: Address.cpp:313
bool SetLoadAddress(lldb::addr_t load_addr, Target *target, bool allow_section_end=false)
Set the address to represent load_addr.
Definition: Address.cpp:1047
@ DumpStyleFileAddress
Display as the file address (if any).
Definition: Address.h:87
@ DumpStyleSectionNameOffset
Display as the section name + offset.
Definition: Address.h:74
@ DumpStyleDetailedSymbolContext
Detailed symbol context information for an address for all symbol context members.
Definition: Address.h:112
@ DumpStyleInvalid
Invalid dump style.
Definition: Address.h:68
@ DumpStyleModuleWithFileAddress
Display as the file address with the module name prepended (if any).
Definition: Address.h:93
@ DumpStyleResolvedDescription
Display the details about what an address resolves to.
Definition: Address.h:104
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.
Definition: Address.cpp:408
lldb::ModuleSP GetModule() const
Get accessor for the module for this address.
Definition: Address.cpp:285
lldb::addr_t GetFileAddress() const
Get the file address.
Definition: Address.cpp:293
bool IsValid() const
Check if the object state is valid.
Definition: Address.h:355
An architecture specification class.
Definition: ArchSpec.h:31
uint32_t GetAddressByteSize() const
Returns the size in bytes of an address of the current architecture.
Definition: ArchSpec.cpp:709
bool IsValid() const
Tests if this ArchSpec is valid.
Definition: ArchSpec.h:359
void DumpTriple(llvm::raw_ostream &s) const
Definition: ArchSpec.cpp:1472
const char * GetArchitectureName() const
Returns a static string representing the current architecture.
Definition: ArchSpec.cpp:570
A command line argument class.
Definition: Args.h:33
void Shift()
Shifts the first argument C string value of the array off the argument array.
Definition: Args.cpp:295
size_t GetArgumentCount() const
Gets the number of arguments left in this command object.
Definition: Args.h:120
llvm::ArrayRef< ArgEntry > entries() const
Definition: Args.h:132
const char * GetArgumentAtIndex(size_t idx) const
Gets the NULL terminated C string argument pointer for the argument at index idx.
Definition: Args.cpp:273
static bool InvokeCommonCompletionCallbacks(CommandInterpreter &interpreter, uint32_t completion_mask, lldb_private::CompletionRequest &request, SearchFilter *searcher)
bool Confirm(llvm::StringRef message, bool default_answer)
ExecutionContext GetExecutionContext() const
void GetLLDBCommandsFromIOHandler(const char *prompt, IOHandlerDelegate &delegate, void *baton=nullptr)
void PrintWarningsIfNecessary(Stream &s, const std::string &cmd_name)
CommandObjectMultiwordTarget(CommandInterpreter &interpreter)
bool LoadSubCommand(llvm::StringRef cmd_name, const lldb::CommandObjectSP &command_obj) override
std::vector< CommandArgumentData > CommandArgumentEntry
virtual void SetHelpLong(llvm::StringRef str)
void AddSimpleArgumentList(lldb::CommandArgumentType arg_type, ArgumentRepetitionType repetition_type=eArgRepeatPlain)
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 AppendErrorWithFormatv(const char *format, Args &&... args)
void void AppendError(llvm::StringRef in_string)
void AppendWarningWithFormat(const char *format,...) __attribute__((format(printf
void SetStatus(lldb::ReturnStatus status)
void void AppendMessageWithFormatv(const char *format, Args &&... args)
void AppendErrorWithFormat(const char *format,...) __attribute__((format(printf
void AppendMessageWithFormat(const char *format,...) __attribute__((format(printf
void void AppendWarning(llvm::StringRef in_string)
A class that describes a compilation unit.
Definition: CompileUnit.h:43
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.
Definition: CompileUnit.h:232
Represents a generic declaration context in a program.
"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.
A uniqued constant string class.
Definition: ConstString.h:40
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
Definition: ConstString.h:188
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.
Definition: ConstString.h:304
llvm::StringRef GetStringRef() const
Get the string value as a llvm::StringRef.
Definition: ConstString.h:197
const char * GetCString() const
Get the string value as a C string.
Definition: ConstString.h:216
A class to manage flag bits.
Definition: Debugger.h:80
TargetList & GetTargetList()
Get accessor for the target list.
Definition: Debugger.h:198
bool GetUseColor() const
Definition: Debugger.cpp:421
llvm::StringRef GetRegexMatchAnsiSuffix() const
Definition: Debugger.cpp:481
llvm::StringRef GetRegexMatchAnsiPrefix() const
Definition: Debugger.cpp:475
DumpValueObjectOptions & SetRootValueObjectName(const char *name=nullptr)
DumpValueObjectOptions & SetFormat(lldb::Format format=lldb::eFormatDefault)
"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
StackFrame * GetFramePtr() const
Returns a pointer to the frame object.
const lldb::StackFrameSP & GetFrameSP() const
Get accessor to get the frame shared pointer.
Target * GetTargetPtr() const
Returns a pointer to the target object.
bool HasTargetScope() const
Returns true the ExecutionContext object contains a valid target.
Process * GetProcessPtr() const
Returns a pointer to the process object.
Thread * GetThreadPtr() const
Returns a pointer to the thread object.
A file collection class.
Definition: FileSpecList.h:91
const FileSpec & GetFileSpecAtIndex(size_t idx) const
Get file at index.
size_t GetSize() const
Get the number of files in the file list.
A file utility class.
Definition: FileSpec.h:56
void SetFile(llvm::StringRef path, Style style)
Change the file specified with a new path.
Definition: FileSpec.cpp:174
void SetDirectory(ConstString directory)
Directory string set accessor.
Definition: FileSpec.cpp:335
const ConstString & GetFilename() const
Filename string const get accessor.
Definition: FileSpec.h:240
const ConstString & GetDirectory() const
Directory string const get accessor.
Definition: FileSpec.h:223
ConstString GetFileNameStrippingExtension() const
Return the filename without the extension part.
Definition: FileSpec.cpp:407
size_t GetPath(char *path, size_t max_path_length, bool denormalize=true) const
Extract the full path to the file.
Definition: FileSpec.cpp:367
void Clear()
Clears the object state.
Definition: FileSpec.cpp:259
void Dump(llvm::raw_ostream &s) const
Dump this object to a Stream.
Definition: FileSpec.cpp:325
void SetFilename(ConstString filename)
Filename string set accessor.
Definition: FileSpec.cpp:345
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()
@ eOpenOptionReadOnly
Definition: File.h:51
A delegate class for use with IOHandler subclasses.
Definition: IOHandler.h:189
lldb::StreamFileSP GetErrorStreamFileSP()
Definition: IOHandler.cpp:107
lldb::StreamFileSP GetOutputStreamFileSP()
Definition: IOHandler.cpp:105
void SetIsDone(bool b)
Definition: IOHandler.h:85
A line table class.
Definition: LineTable.h:40
void GetDescription(Stream *s, Target *target, lldb::DescriptionLevel level)
Definition: LineTable.cpp:370
A collection class for Module objects.
Definition: ModuleList.h:103
void FindFunctions(ConstString name, lldb::FunctionNameType name_type_mask, const ModuleFunctionSearchOptions &options, SymbolContextList &sc_list) const
ModuleIterableNoLocking ModulesNoLocking() const
Definition: ModuleList.h:533
static bool ModuleIsInCache(const Module *module_ptr)
Definition: ModuleList.cpp:767
void FindGlobalVariables(ConstString name, size_t max_matches, VariableList &variable_list) const
Find global and static variables by name.
Definition: ModuleList.cpp:510
std::recursive_mutex & GetMutex() const
Definition: ModuleList.h:230
lldb::ModuleSP FindFirstModule(const ModuleSpec &module_spec) const
Definition: ModuleList.cpp:626
lldb::ModuleSP GetModuleAtIndexUnlocked(size_t idx) const
Get the module shared pointer for the module at index idx without acquiring the ModuleList mutex.
Definition: ModuleList.cpp:434
void FindCompileUnits(const FileSpec &path, SymbolContextList &sc_list) const
Find compile units by partial or full path.
Definition: ModuleList.cpp:503
bool AppendIfNeeded(const lldb::ModuleSP &new_module, bool notify=true)
Append a module to the module list, if it is not already there.
Definition: ModuleList.cpp:280
Module * GetModulePointerAtIndex(size_t idx) const
Get the module pointer for the module at index idx.
Definition: ModuleList.cpp:422
void FindModules(const ModuleSpec &module_spec, ModuleList &matching_module_list) const
Finds the first module whose file specification matches file_spec.
Definition: ModuleList.cpp:543
lldb::ModuleSP GetModuleAtIndex(size_t idx) const
Get the module shared pointer for the module at index idx.
Definition: ModuleList.cpp:429
void Append(const lldb::ModuleSP &module_sp, bool notify=true)
Append a module to the module list.
Definition: ModuleList.cpp:247
static size_t RemoveOrphanSharedModules(bool mandatory)
Definition: ModuleList.cpp:784
static void FindSharedModules(const ModuleSpec &module_spec, ModuleList &matching_module_list)
Definition: ModuleList.cpp:775
ModuleIterable Modules() const
Definition: ModuleList.h:527
size_t GetSize() const
Gets the size of the module list.
Definition: ModuleList.cpp:638
bool GetModuleSpecAtIndex(size_t i, ModuleSpec &module_spec) const
Definition: ModuleSpec.h:323
bool FindMatchingModuleSpec(const ModuleSpec &module_spec, ModuleSpec &match_module_spec) const
Definition: ModuleSpec.h:333
FileSpec & GetPlatformFileSpec()
Definition: ModuleSpec.h:65
FileSpec & GetFileSpec()
Definition: ModuleSpec.h:53
ArchSpec & GetArchitecture()
Definition: ModuleSpec.h:89
FileSpec * GetFileSpecPtr()
Definition: ModuleSpec.h:47
FileSpec & GetSymbolFileSpec()
Definition: ModuleSpec.h:77
A class that describes an executable image and its associated object and symbol files.
Definition: Module.h:89
const lldb_private::UUID & GetUUID()
Get a reference to the UUID value contained in this object.
Definition: Module.cpp:347
virtual ObjectFile * GetObjectFile()
Get the object file representation for the current architecture.
Definition: Module.cpp:1199
virtual SymbolFile * GetSymbolFile(bool can_create=true, Stream *feedback_strm=nullptr)
Get the module's symbol file.
Definition: Module.cpp:999
ConstString GetObjectName() const
Definition: Module.cpp:1197
static Module * GetAllocatedModuleAtIndex(size_t idx)
Definition: Module.cpp:124
static std::recursive_mutex & GetAllocationModuleCollectionMutex()
Definition: Module.cpp:106
bool SetLoadAddress(Target &target, lldb::addr_t value, bool value_is_offset, bool &changed)
Set the load address for all sections in a module to be the file address plus slide.
Definition: Module.cpp:1511
bool ResolveFileAddress(lldb::addr_t vm_addr, Address &so_addr)
Definition: Module.cpp:444
void FindFunctions(const LookupInfo &lookup_info, const CompilerDeclContext &parent_decl_ctx, const ModuleFunctionSearchOptions &options, SymbolContextList &sc_list)
Find functions by lookup info.
Definition: Module.cpp:831
bool MatchesModuleSpec(const ModuleSpec &module_ref)
Definition: Module.cpp:1523
Symtab * GetSymtab()
Definition: Module.cpp:1026
static size_t GetNumberAllocatedModules()
Definition: Module.cpp:118
const ArchSpec & GetArchitecture() const
Get const accessor for the module architecture.
Definition: Module.cpp:1041
virtual SectionList * GetSectionList()
Get the unified section list for the module.
Definition: Module.cpp:1241
uint32_t ResolveSymbolContextsForFileSpec(const FileSpec &file_spec, uint32_t line, bool check_inlines, lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list)
Resolve items in the symbol context for a given file and line.
Definition: Module.cpp:591
std::string GetSpecificationDescription() const
Get the module path and object name.
Definition: Module.cpp:1043
const FileSpec & GetFileSpec() const
Get const accessor for the module file specification.
Definition: Module.h:453
const llvm::sys::TimePoint & GetModificationTime() const
Definition: Module.h:489
void FindTypes(const TypeQuery &query, TypeResults &results)
Find types using a type-matching object that contains all search parameters.
Definition: Module.cpp:976
A plug-in interface definition class for object file parsers.
Definition: ObjectFile.h:44
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.
Definition: ObjectFile.cpp:639
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...
Definition: ObjectFile.h:470
virtual FileSpec & GetFileSpec()
Get accessor to the object file specification.
Definition: ObjectFile.h:275
virtual lldb_private::Address GetBaseAddress()
Returns base address of this object file.
Definition: ObjectFile.h:480
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())
Definition: ObjectFile.cpp:196
OptionValueBoolean & GetOptionValue()
OptionValueFileSpecList & GetOptionValue()
OptionValueFileSpec & GetOptionValue()
static const uint32_t OPTION_GROUP_GDB_FMT
static const uint32_t OPTION_GROUP_FORMAT
void Append(OptionGroup *group)
Append options from a OptionGroup class.
Definition: Options.cpp:788
const StructuredData::DictionarySP GetStructuredData()
OptionValueString & GetOptionValue()
OptionValueUInt64 & GetOptionValue()
const OptionValueUUID & GetOptionValue() const
DumpValueObjectOptions GetAsDumpOptions(LanguageRuntimeDescriptionDisplayVerbosity lang_descr_verbosity=eLanguageRuntimeDescriptionDisplayVerbosityFull, lldb::Format format=lldb::eFormatDefault, lldb::TypeSummaryImplSP summary_sp=lldb::TypeSummaryImplSP())
llvm::StringRef GetCurrentValueAsRef() const
const char * GetCurrentValue() const
A command line option parsing protocol class.
Definition: Options.h:58
void GenerateOptionUsage(Stream &strm, CommandObject &cmd, uint32_t screen_width)
Definition: Options.cpp:427
std::vector< Option > m_getopt_table
Definition: Options.h:198
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)
Definition: ProcessInfo.cpp:65
A plug-in interface definition class for debugging a process.
Definition: Process.h:343
ThreadList & GetThreadList()
Definition: Process.h:2182
void Flush()
Flush all data in the process.
Definition: Process.cpp:5864
lldb::StateType GetState()
Get accessor for the current process state.
Definition: Process.cpp:1308
const lldb::ABISP & GetABI()
Definition: Process.cpp:1504
bool IsValid() const
Test if this object contains a valid regular expression.
lldb::SectionSP FindSectionByName(ConstString section_dstr) const
Definition: Section.cpp:558
void Dump(llvm::raw_ostream &s, unsigned indent, Target *target, bool show_header, uint32_t depth) const
Definition: Section.cpp:644
void Dump(Stream &s, Target *target)
bool ResolveLoadAddress(lldb::addr_t load_addr, Address &so_addr, bool allow_section_end=false) const
bool SetSectionLoadAddress(const lldb::SectionSP &section_sp, lldb::addr_t load_addr, bool warn_multiple=false)
This base class provides an interface to stack frames.
Definition: StackFrame.h:44
const SymbolContext & GetSymbolContext(lldb::SymbolContextItem resolve_scope)
Provide a SymbolContext for this StackFrame's current pc value.
Definition: StackFrame.cpp:301
uint32_t GetFrameIndex() const
Query this frame to find what frame it is in this Thread's StackFrameList.
Definition: StackFrame.cpp:176
An error handling class.
Definition: Status.h:118
static Status FromErrorStringWithFormat(const char *format,...) __attribute__((format(printf
Definition: Status.cpp:106
static Status FromErrorString(const char *str)
Definition: Status.h:141
bool Fail() const
Test for error condition.
Definition: Status.cpp:294
const char * AsCString(const char *default_error_str="unknown error") const
Get the error string associated with the current error.
Definition: Status.cpp:195
const char * GetData() const
Definition: StreamString.h:45
llvm::StringRef GetString() const
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
void Format(const char *format, Args &&... args)
Definition: Stream.h:353
llvm::raw_ostream & AsRawOstream()
Returns a raw_ostream that forwards the data to this Stream object.
Definition: Stream.h:401
size_t Indent(llvm::StringRef s="")
Indent the current line in the stream.
Definition: Stream.cpp:157
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:134
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
Definition: Stream.cpp:65
void SetAddressByteSize(uint32_t addr_size)
Set the address size in bytes.
Definition: Stream.cpp:209
size_t PutChar(char ch)
Definition: Stream.cpp:131
void SetIndentLevel(unsigned level)
Set the current indentation level.
Definition: Stream.cpp:190
void PutCStringColorHighlighted(llvm::StringRef text, std::optional< HighlightSettings > settings=std::nullopt)
Output a C string to the stream with color highlighting.
Definition: Stream.cpp:75
size_t EOL()
Output and End of Line character to the stream.
Definition: Stream.cpp:155
void IndentLess(unsigned amount=2)
Decrement the current indentation level.
Definition: Stream.cpp:198
void IndentMore(unsigned amount=2)
Increment the current indentation level.
Definition: Stream.cpp:195
unsigned GetIndentLevel() const
Get the current indentation level.
Definition: Stream.cpp:187
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
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.
Defines a symbol context baton that can be handed other debug core functions.
Definition: SymbolContext.h:34
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.
Definition: SymbolFile.h:50
virtual ObjectFile * GetObjectFile()=0
bool ValueIsAddress() const
Definition: Symbol.cpp:165
bool GetByteSizeIsValid() const
Definition: Symbol.h:208
Address & GetAddressRef()
Definition: Symbol.h:72
lldb::addr_t GetByteSize() const
Definition: Symbol.cpp:468
ConstString GetDisplayName() const
Definition: Symbol.cpp:169
uint64_t GetRawValue() const
Get the raw value of the symbol from the symbol table.
Definition: Symbol.h:109
Symbol * SymbolAtIndex(size_t idx)
Definition: Symtab.cpp:228
uint32_t AppendSymbolIndexesWithName(ConstString symbol_name, std::vector< uint32_t > &matches)
Definition: Symtab.cpp:680
uint32_t AppendSymbolIndexesMatchingRegExAndType(const RegularExpression &regex, lldb::SymbolType symbol_type, std::vector< uint32_t > &indexes, Mangled::NamePreference name_preference=Mangled::ePreferDemangled)
Definition: Symtab.cpp:757
lldb::TargetSP GetTargetAtIndex(uint32_t index) const
Definition: TargetList.cpp:500
void SetSelectedTarget(uint32_t index)
Definition: TargetList.cpp:530
bool DeleteTarget(lldb::TargetSP &target_sp)
Delete a Target object from the list.
Definition: TargetList.cpp:372
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.
Definition: TargetList.cpp:45
lldb::TargetSP GetSelectedTarget()
Definition: TargetList.cpp:545
size_t GetNumTargets() const
Definition: TargetList.cpp:495
bool GetUserSpecifiedTrapHandlerNames(Args &args) const
Definition: Target.cpp:4935
Environment GetEnvironment() const
Definition: Target.cpp:4589
void SetActionFromString(const std::string &strings)
Definition: Target.cpp:3910
void SetActionFromStrings(const std::vector< std::string > &strings)
Definition: Target.cpp:3914
Status SetScriptCallback(std::string class_name, StructuredData::ObjectSP extra_args_sp)
Definition: Target.cpp:3955
void ModulesDidLoad(ModuleList &module_list)
Definition: Target.cpp:1814
Module * GetExecutableModulePointer()
Definition: Target.cpp:1518
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...
Definition: Target.cpp:2957
PathMappingList & GetImageSearchPathList()
Definition: Target.cpp:2540
std::shared_ptr< StopHook > StopHookSP
Definition: Target.h:1415
void SymbolsDidLoad(ModuleList &module_list)
Definition: Target.cpp:1834
SectionLoadList & GetSectionLoadList()
Definition: Target.h:1154
size_t GetNumStopHooks() const
Definition: Target.h:1449
const lldb::ProcessSP & GetProcessSP() const
Definition: Target.cpp:297
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...
Definition: Target.cpp:2286
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,...
Definition: Target.cpp:2972
bool SetStopHookActiveStateByID(lldb::user_id_t uid, bool active_state)
Definition: Target.cpp:2996
void SetAllStopHooksActiveState(bool active_state)
Definition: Target.cpp:3007
void RemoveAllStopHooks()
Definition: Target.cpp:2984
StopHookSP GetStopHookAtIndex(size_t index)
Definition: Target.h:1451
lldb::PlatformSP GetPlatform()
Definition: Target.h:1463
const ModuleList & GetImages() const
Get accessor for the images for this process.
Definition: Target.h:997
const ArchSpec & GetArchitecture() const
Definition: Target.h:1039
const std::string & GetLabel() const
Definition: Target.h:586
lldb::ProcessSP CalculateProcess() override
Definition: Target.cpp:2529
bool RemoveStopHookByID(lldb::user_id_t uid)
Definition: Target.cpp:2979
lldb::ThreadSP GetSelectedThread()
Definition: ThreadList.cpp:683
uint32_t GetSize(bool can_update=true)
Definition: ThreadList.cpp:82
lldb::ThreadSP GetThreadAtIndex(uint32_t idx, bool can_update=true)
Definition: ThreadList.cpp:90
void SetIndex(uint32_t index)
Definition: ThreadSpec.h:45
void SetName(llvm::StringRef name)
Definition: ThreadSpec.h:49
void SetTID(lldb::tid_t tid)
Definition: ThreadSpec.h:47
void SetQueueName(llvm::StringRef queue_name)
Definition: ThreadSpec.h:51
virtual lldb::StackFrameSP GetStackFrameAtIndex(uint32_t idx)
Definition: Thread.h:408
virtual uint32_t GetStackFrameCount()
GetStackFrameCount can be expensive.
Definition: Thread.h:404
uint32_t GetSize() const
Definition: TypeList.cpp:60
bool Empty() const
Definition: TypeList.h:37
TypeIterable Types()
Definition: TypeList.h:45
lldb::TypeSP GetTypeAtIndex(uint32_t idx)
Definition: TypeList.cpp:66
A class that contains all state required for type lookups.
Definition: Type.h:104
This class tracks the state and results of a TypeQuery.
Definition: Type.h:344
TypeMap & GetTypeMap()
Definition: Type.h:386
void Dump(Stream &s) const
Definition: UUID.cpp:63
std::string GetAsString(llvm::StringRef separator="-") const
Definition: UUID.cpp:49
bool IsValid() const
Definition: UUID.h:69
void Dump(Stream &s, Thread *thread, lldb::addr_t base_addr) const
Definition: UnwindPlan.cpp:523
A collection of ValueObject values that.
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)
Definition: Variable.cpp:325
#define LLDB_OPT_SET_1
Definition: lldb-defines.h:111
#define LLDB_OPT_SET_FROM_TO(A, B)
Definition: lldb-defines.h:123
#define LLDB_OPT_SET_2
Definition: lldb-defines.h:112
#define LLDB_INVALID_LINE_NUMBER
Definition: lldb-defines.h:94
#define LLDB_INVALID_THREAD_ID
Definition: lldb-defines.h:90
#define LLDB_INVALID_INDEX32
Definition: lldb-defines.h:83
#define LLDB_OPT_SET_ALL
Definition: lldb-defines.h:110
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:82
#define UINT32_MAX
Definition: lldb-defines.h:19
#define LLDB_INVALID_PROCESS_ID
Definition: lldb-defines.h:89
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.
Definition: Log.h:332
std::vector< OptionArgElement > OptionElementVector
Definition: Options.h:43
bool StateIsStoppedState(lldb::StateType state, bool must_exist)
Check if a state represents a state where the process or thread is stopped.
Definition: State.cpp:89
const char * StateAsCString(lldb::StateType state)
Converts a StateType to a C string.
Definition: State.cpp:14
const char * toString(AppleArm64ExceptionClass EC)
Definition: SBAddress.h:15
@ eSourceFileCompletion
std::shared_ptr< lldb_private::TypeSystem > TypeSystemSP
Definition: lldb-forward.h:469
std::shared_ptr< lldb_private::ABI > ABISP
Definition: lldb-forward.h:317
std::shared_ptr< lldb_private::StackFrame > StackFrameSP
Definition: lldb-forward.h:424
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
@ eDescriptionLevelBrief
@ eDescriptionLevelFull
std::shared_ptr< lldb_private::Thread > ThreadSP
Definition: lldb-forward.h:450
std::shared_ptr< lldb_private::CommandObject > CommandObjectSP
Definition: lldb-forward.h:333
std::shared_ptr< lldb_private::ValueObject > ValueObjectSP
Definition: lldb-forward.h:484
Format
Display format definitions.
std::shared_ptr< lldb_private::Platform > PlatformSP
Definition: lldb-forward.h:388
StateType
Process and Thread States.
std::shared_ptr< lldb_private::FuncUnwinders > FuncUnwindersSP
Definition: lldb-forward.h:356
std::shared_ptr< lldb_private::Type > TypeSP
Definition: lldb-forward.h:461
std::shared_ptr< lldb_private::Process > ProcessSP
Definition: lldb-forward.h:389
@ eReturnStatusFailed
@ eReturnStatusSuccessFinishResult
@ eReturnStatusSuccessFinishNoResult
uint64_t pid_t
Definition: lldb-types.h:83
@ eArgTypeOldPathPrefix
@ eArgTypeTargetID
@ eArgTypeShlibName
@ eArgTypeNewPathPrefix
@ eArgTypeFilename
@ eArgTypeSourceFile
@ eArgTypeDirectoryName
@ eArgTypeStopHookID
std::shared_ptr< lldb_private::VariableList > VariableListSP
Definition: lldb-forward.h:487
std::shared_ptr< lldb_private::UnwindPlan > UnwindPlanSP
Definition: lldb-forward.h:483
std::shared_ptr< lldb_private::StreamFile > StreamFileSP
Definition: lldb-forward.h:433
std::shared_ptr< lldb_private::Variable > VariableSP
Definition: lldb-forward.h:486
uint64_t user_id_t
Definition: lldb-types.h:82
std::shared_ptr< lldb_private::Section > SectionSP
Definition: lldb-forward.h:418
uint64_t addr_t
Definition: lldb-types.h:80
std::shared_ptr< lldb_private::Target > TargetSP
Definition: lldb-forward.h:448
std::shared_ptr< lldb_private::RegisterContext > RegisterContextSP
Definition: lldb-forward.h:394
uint64_t tid_t
Definition: lldb-types.h:84
std::shared_ptr< lldb_private::Module > ModuleSP
Definition: lldb-forward.h:373
@ eValueTypeVariableGlobal
globals variable
@ eValueTypeVariableLocal
function local variables
@ eValueTypeVariableArgument
function argument variables
@ eValueTypeVariableStatic
static variable
@ eValueTypeVariableThreadLocal
thread local storage variable
@ eRegisterKindGeneric
insn ptr reg, stack ptr reg, etc not specific to any particular target
Used to build individual command argument lists.
Definition: CommandObject.h:95
Options used by Module::FindFunctions.
Definition: Module.h:66
bool include_inlines
Include inlined functions.
Definition: Module.h:70
bool include_symbols
Include the symbol table.
Definition: Module.h:68
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.
Definition: Stream.h:37
#define PATH_MAX