| //===-- CommandObjectTarget.cpp ---------------------------------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "CommandObjectTarget.h" |
| |
| // Project includes |
| #include "lldb/Core/Debugger.h" |
| #include "lldb/Core/IOHandler.h" |
| #include "lldb/Core/Module.h" |
| #include "lldb/Core/ModuleSpec.h" |
| #include "lldb/Core/Section.h" |
| #include "lldb/Core/State.h" |
| #include "lldb/Core/ValueObjectVariable.h" |
| #include "lldb/DataFormatters/ValueObjectPrinter.h" |
| #include "lldb/Host/OptionParser.h" |
| #include "lldb/Host/StringConvert.h" |
| #include "lldb/Host/Symbols.h" |
| #include "lldb/Interpreter/CommandInterpreter.h" |
| #include "lldb/Interpreter/CommandReturnObject.h" |
| #include "lldb/Interpreter/OptionArgParser.h" |
| #include "lldb/Interpreter/OptionGroupArchitecture.h" |
| #include "lldb/Interpreter/OptionGroupBoolean.h" |
| #include "lldb/Interpreter/OptionGroupFile.h" |
| #include "lldb/Interpreter/OptionGroupFormat.h" |
| #include "lldb/Interpreter/OptionGroupPlatform.h" |
| #include "lldb/Interpreter/OptionGroupString.h" |
| #include "lldb/Interpreter/OptionGroupUInt64.h" |
| #include "lldb/Interpreter/OptionGroupUUID.h" |
| #include "lldb/Interpreter/OptionGroupValueObjectDisplay.h" |
| #include "lldb/Interpreter/OptionGroupVariable.h" |
| #include "lldb/Interpreter/Options.h" |
| #include "lldb/Symbol/CompileUnit.h" |
| #include "lldb/Symbol/FuncUnwinders.h" |
| #include "lldb/Symbol/LineTable.h" |
| #include "lldb/Symbol/ObjectFile.h" |
| #include "lldb/Symbol/SymbolFile.h" |
| #include "lldb/Symbol/SymbolVendor.h" |
| #include "lldb/Symbol/UnwindPlan.h" |
| #include "lldb/Symbol/VariableList.h" |
| #include "lldb/Target/ABI.h" |
| #include "lldb/Target/Process.h" |
| #include "lldb/Target/RegisterContext.h" |
| #include "lldb/Target/SectionLoadList.h" |
| #include "lldb/Target/StackFrame.h" |
| #include "lldb/Target/Thread.h" |
| #include "lldb/Target/ThreadSpec.h" |
| #include "lldb/Utility/Args.h" |
| #include "lldb/Utility/Timer.h" |
| |
| #include "llvm/Support/FileSystem.h" |
| #include "llvm/Support/FormatAdapters.h" |
| |
| // C Includes |
| // C++ Includes |
| #include <cerrno> |
| |
| using namespace lldb; |
| using namespace lldb_private; |
| |
| static void DumpTargetInfo(uint32_t target_idx, Target *target, |
| const char *prefix_cstr, |
| bool show_stopped_process_status, Stream &strm) { |
| const ArchSpec &target_arch = target->GetArchitecture(); |
| |
| Module *exe_module = target->GetExecutableModulePointer(); |
| char exe_path[PATH_MAX]; |
| bool exe_valid = false; |
| if (exe_module) |
| exe_valid = exe_module->GetFileSpec().GetPath(exe_path, sizeof(exe_path)); |
| |
| if (!exe_valid) |
| ::strcpy(exe_path, "<none>"); |
| |
| strm.Printf("%starget #%u: %s", prefix_cstr ? prefix_cstr : "", target_idx, |
| exe_path); |
| |
| uint32_t properties = 0; |
| if (target_arch.IsValid()) { |
| strm.Printf("%sarch=", properties++ > 0 ? ", " : " ( "); |
| target_arch.DumpTriple(strm); |
| properties++; |
| } |
| PlatformSP platform_sp(target->GetPlatform()); |
| if (platform_sp) |
| strm.Printf("%splatform=%s", properties++ > 0 ? ", " : " ( ", |
| platform_sp->GetName().GetCString()); |
| |
| ProcessSP process_sp(target->GetProcessSP()); |
| bool show_process_status = false; |
| if (process_sp) { |
| lldb::pid_t pid = process_sp->GetID(); |
| StateType state = process_sp->GetState(); |
| if (show_stopped_process_status) |
| show_process_status = StateIsStoppedState(state, true); |
| const char *state_cstr = StateAsCString(state); |
| if (pid != LLDB_INVALID_PROCESS_ID) |
| strm.Printf("%spid=%" PRIu64, properties++ > 0 ? ", " : " ( ", pid); |
| strm.Printf("%sstate=%s", properties++ > 0 ? ", " : " ( ", state_cstr); |
| } |
| if (properties > 0) |
| strm.PutCString(" )\n"); |
| else |
| strm.EOL(); |
| if (show_process_status) { |
| const bool only_threads_with_stop_reason = true; |
| const uint32_t start_frame = 0; |
| const uint32_t num_frames = 1; |
| const uint32_t num_frames_with_source = 1; |
| const bool stop_format = false; |
| process_sp->GetStatus(strm); |
| process_sp->GetThreadStatus(strm, only_threads_with_stop_reason, |
| start_frame, num_frames, |
| num_frames_with_source, stop_format); |
| } |
| } |
| |
| static uint32_t DumpTargetList(TargetList &target_list, |
| bool show_stopped_process_status, Stream &strm) { |
| const uint32_t num_targets = target_list.GetNumTargets(); |
| if (num_targets) { |
| TargetSP selected_target_sp(target_list.GetSelectedTarget()); |
| strm.PutCString("Current targets:\n"); |
| for (uint32_t i = 0; i < num_targets; ++i) { |
| TargetSP target_sp(target_list.GetTargetAtIndex(i)); |
| if (target_sp) { |
| bool is_selected = target_sp.get() == selected_target_sp.get(); |
| DumpTargetInfo(i, target_sp.get(), is_selected ? "* " : " ", |
| show_stopped_process_status, strm); |
| } |
| } |
| } |
| return num_targets; |
| } |
| |
| #pragma mark CommandObjectTargetCreate |
| |
| //------------------------------------------------------------------------- |
| // "target create" |
| //------------------------------------------------------------------------- |
| |
| class CommandObjectTargetCreate : public CommandObjectParsed { |
| public: |
| CommandObjectTargetCreate(CommandInterpreter &interpreter) |
| : CommandObjectParsed( |
| interpreter, "target create", |
| "Create a target using the argument as the main executable.", |
| nullptr), |
| m_option_group(), m_arch_option(), |
| m_core_file(LLDB_OPT_SET_1, false, "core", 'c', 0, eArgTypeFilename, |
| "Fullpath to a core file to use for this target."), |
| m_platform_path(LLDB_OPT_SET_1, false, "platform-path", 'P', 0, |
| eArgTypePath, |
| "Path to the remote file to use for this target."), |
| m_symbol_file(LLDB_OPT_SET_1, false, "symfile", 's', 0, |
| eArgTypeFilename, "Fullpath to a stand alone debug " |
| "symbols file for when debug symbols " |
| "are not in the executable."), |
| m_remote_file( |
| LLDB_OPT_SET_1, false, "remote-file", 'r', 0, eArgTypeFilename, |
| "Fullpath to the file on the remote host if debugging remotely."), |
| m_add_dependents(LLDB_OPT_SET_1, false, "no-dependents", 'd', |
| "Don't load dependent files when creating the target, " |
| "just add the specified executable.", |
| true, true) { |
| CommandArgumentEntry arg; |
| CommandArgumentData file_arg; |
| |
| // Define the first (and only) variant of this arg. |
| file_arg.arg_type = eArgTypeFilename; |
| file_arg.arg_repetition = eArgRepeatPlain; |
| |
| // There is only one variant this argument could be; put it into the |
| // argument entry. |
| arg.push_back(file_arg); |
| |
| // Push the data for the first argument into the m_arguments vector. |
| m_arguments.push_back(arg); |
| |
| m_option_group.Append(&m_arch_option, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); |
| m_option_group.Append(&m_core_file, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); |
| m_option_group.Append(&m_platform_path, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); |
| m_option_group.Append(&m_symbol_file, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); |
| m_option_group.Append(&m_remote_file, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); |
| m_option_group.Append(&m_add_dependents, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); |
| m_option_group.Finalize(); |
| } |
| |
| ~CommandObjectTargetCreate() override = default; |
| |
| Options *GetOptions() override { return &m_option_group; } |
| |
| int HandleArgumentCompletion( |
| CompletionRequest &request, |
| OptionElementVector &opt_element_vector) override { |
| CommandCompletions::InvokeCommonCompletionCallbacks( |
| GetCommandInterpreter(), CommandCompletions::eDiskFileCompletion, |
| request, nullptr); |
| return request.GetNumberOfMatches(); |
| } |
| |
| protected: |
| bool DoExecute(Args &command, CommandReturnObject &result) override { |
| const size_t argc = command.GetArgumentCount(); |
| FileSpec core_file(m_core_file.GetOptionValue().GetCurrentValue()); |
| FileSpec remote_file(m_remote_file.GetOptionValue().GetCurrentValue()); |
| |
| if (core_file) { |
| if (!core_file.Exists()) { |
| result.AppendErrorWithFormat("core file '%s' doesn't exist", |
| core_file.GetPath().c_str()); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| if (!core_file.Readable()) { |
| result.AppendErrorWithFormat("core file '%s' is not readable", |
| core_file.GetPath().c_str()); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| } |
| |
| if (argc == 1 || core_file || remote_file) { |
| FileSpec symfile(m_symbol_file.GetOptionValue().GetCurrentValue()); |
| if (symfile) { |
| if (symfile.Exists()) { |
| if (!symfile.Readable()) { |
| result.AppendErrorWithFormat("symbol file '%s' is not readable", |
| symfile.GetPath().c_str()); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| } else { |
| char symfile_path[PATH_MAX]; |
| symfile.GetPath(symfile_path, sizeof(symfile_path)); |
| result.AppendErrorWithFormat("invalid symbol file path '%s'", |
| symfile_path); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| } |
| |
| const char *file_path = command.GetArgumentAtIndex(0); |
| static Timer::Category func_cat(LLVM_PRETTY_FUNCTION); |
| Timer scoped_timer(func_cat, "(lldb) target create '%s'", file_path); |
| FileSpec file_spec; |
| |
| if (file_path) |
| file_spec.SetFile(file_path, true, FileSpec::Style::native); |
| |
| bool must_set_platform_path = false; |
| |
| Debugger &debugger = m_interpreter.GetDebugger(); |
| |
| TargetSP target_sp; |
| llvm::StringRef arch_cstr = m_arch_option.GetArchitectureName(); |
| const bool get_dependent_files = |
| m_add_dependents.GetOptionValue().GetCurrentValue(); |
| Status error(debugger.GetTargetList().CreateTarget( |
| debugger, file_path, arch_cstr, get_dependent_files, nullptr, |
| target_sp)); |
| |
| if (target_sp) { |
| // Only get the platform after we create the target because we might |
| // have switched platforms depending on what the arguments were to |
| // CreateTarget() we can't rely on the selected platform. |
| |
| PlatformSP platform_sp = target_sp->GetPlatform(); |
| |
| if (remote_file) { |
| if (platform_sp) { |
| // I have a remote file.. two possible cases |
| if (file_spec && file_spec.Exists()) { |
| // if the remote file does not exist, push it there |
| if (!platform_sp->GetFileExists(remote_file)) { |
| Status err = platform_sp->PutFile(file_spec, remote_file); |
| if (err.Fail()) { |
| result.AppendError(err.AsCString()); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| } |
| } else { |
| // there is no local file and we need one |
| // in order to make the remote ---> local transfer we need a |
| // platform |
| // TODO: if the user has passed in a --platform argument, use it |
| // to fetch the right platform |
| if (!platform_sp) { |
| result.AppendError( |
| "unable to perform remote debugging without a platform"); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| if (file_path) { |
| // copy the remote file to the local file |
| Status err = platform_sp->GetFile(remote_file, file_spec); |
| if (err.Fail()) { |
| result.AppendError(err.AsCString()); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| } else { |
| // make up a local file |
| result.AppendError("remote --> local transfer without local " |
| "path is not implemented yet"); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| } |
| } else { |
| result.AppendError("no platform found for target"); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| } |
| |
| if (symfile || remote_file) { |
| ModuleSP module_sp(target_sp->GetExecutableModule()); |
| if (module_sp) { |
| if (symfile) |
| module_sp->SetSymbolFileFileSpec(symfile); |
| if (remote_file) { |
| std::string remote_path = remote_file.GetPath(); |
| target_sp->SetArg0(remote_path.c_str()); |
| module_sp->SetPlatformFileSpec(remote_file); |
| } |
| } |
| } |
| |
| debugger.GetTargetList().SetSelectedTarget(target_sp.get()); |
| if (must_set_platform_path) { |
| ModuleSpec main_module_spec(file_spec); |
| ModuleSP module_sp = target_sp->GetSharedModule(main_module_spec); |
| if (module_sp) |
| module_sp->SetPlatformFileSpec(remote_file); |
| } |
| if (core_file) { |
| char core_path[PATH_MAX]; |
| core_file.GetPath(core_path, sizeof(core_path)); |
| if (core_file.Exists()) { |
| if (!core_file.Readable()) { |
| result.AppendMessageWithFormat( |
| "Core file '%s' is not readable.\n", core_path); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| FileSpec core_file_dir; |
| core_file_dir.GetDirectory() = core_file.GetDirectory(); |
| target_sp->GetExecutableSearchPaths().Append(core_file_dir); |
| |
| ProcessSP process_sp(target_sp->CreateProcess( |
| m_interpreter.GetDebugger().GetListener(), llvm::StringRef(), |
| &core_file)); |
| |
| if (process_sp) { |
| // Seems weird that we Launch a core file, but that is what we |
| // do! |
| error = process_sp->LoadCore(); |
| |
| if (error.Fail()) { |
| result.AppendError( |
| error.AsCString("can't find plug-in for core file")); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } else { |
| result.AppendMessageWithFormat( |
| "Core file '%s' (%s) was loaded.\n", core_path, |
| target_sp->GetArchitecture().GetArchitectureName()); |
| result.SetStatus(eReturnStatusSuccessFinishNoResult); |
| } |
| } else { |
| result.AppendErrorWithFormat( |
| "Unable to find process plug-in for core file '%s'\n", |
| core_path); |
| result.SetStatus(eReturnStatusFailed); |
| } |
| } else { |
| result.AppendErrorWithFormat("Core file '%s' does not exist\n", |
| core_path); |
| result.SetStatus(eReturnStatusFailed); |
| } |
| } else { |
| result.AppendMessageWithFormat( |
| "Current executable set to '%s' (%s).\n", file_path, |
| target_sp->GetArchitecture().GetArchitectureName()); |
| result.SetStatus(eReturnStatusSuccessFinishNoResult); |
| } |
| } else { |
| result.AppendError(error.AsCString()); |
| result.SetStatus(eReturnStatusFailed); |
| } |
| } else { |
| result.AppendErrorWithFormat("'%s' takes exactly one executable path " |
| "argument, or use the --core option.\n", |
| m_cmd_name.c_str()); |
| result.SetStatus(eReturnStatusFailed); |
| } |
| return result.Succeeded(); |
| } |
| |
| private: |
| OptionGroupOptions m_option_group; |
| OptionGroupArchitecture m_arch_option; |
| OptionGroupFile m_core_file; |
| OptionGroupFile m_platform_path; |
| OptionGroupFile m_symbol_file; |
| OptionGroupFile m_remote_file; |
| OptionGroupBoolean m_add_dependents; |
| }; |
| |
| #pragma mark CommandObjectTargetList |
| |
| //---------------------------------------------------------------------- |
| // "target list" |
| //---------------------------------------------------------------------- |
| |
| class CommandObjectTargetList : public CommandObjectParsed { |
| public: |
| CommandObjectTargetList(CommandInterpreter &interpreter) |
| : CommandObjectParsed( |
| interpreter, "target list", |
| "List all current targets in the current debug session.", nullptr) { |
| } |
| |
| ~CommandObjectTargetList() override = default; |
| |
| protected: |
| bool DoExecute(Args &args, CommandReturnObject &result) override { |
| if (args.GetArgumentCount() == 0) { |
| Stream &strm = result.GetOutputStream(); |
| |
| bool show_stopped_process_status = false; |
| if (DumpTargetList(m_interpreter.GetDebugger().GetTargetList(), |
| show_stopped_process_status, strm) == 0) { |
| strm.PutCString("No targets.\n"); |
| } |
| result.SetStatus(eReturnStatusSuccessFinishResult); |
| } else { |
| result.AppendError("the 'target list' command takes no arguments\n"); |
| result.SetStatus(eReturnStatusFailed); |
| } |
| return result.Succeeded(); |
| } |
| }; |
| |
| #pragma mark CommandObjectTargetSelect |
| |
| //---------------------------------------------------------------------- |
| // "target select" |
| //---------------------------------------------------------------------- |
| |
| class CommandObjectTargetSelect : public CommandObjectParsed { |
| public: |
| CommandObjectTargetSelect(CommandInterpreter &interpreter) |
| : CommandObjectParsed( |
| interpreter, "target select", |
| "Select a target as the current target by target index.", nullptr) { |
| } |
| |
| ~CommandObjectTargetSelect() override = default; |
| |
| protected: |
| bool DoExecute(Args &args, CommandReturnObject &result) override { |
| if (args.GetArgumentCount() == 1) { |
| bool success = false; |
| const char *target_idx_arg = args.GetArgumentAtIndex(0); |
| uint32_t target_idx = |
| StringConvert::ToUInt32(target_idx_arg, UINT32_MAX, 0, &success); |
| if (success) { |
| TargetList &target_list = m_interpreter.GetDebugger().GetTargetList(); |
| const uint32_t num_targets = target_list.GetNumTargets(); |
| if (target_idx < num_targets) { |
| TargetSP target_sp(target_list.GetTargetAtIndex(target_idx)); |
| if (target_sp) { |
| Stream &strm = result.GetOutputStream(); |
| target_list.SetSelectedTarget(target_sp.get()); |
| bool show_stopped_process_status = false; |
| DumpTargetList(target_list, show_stopped_process_status, strm); |
| result.SetStatus(eReturnStatusSuccessFinishResult); |
| } else { |
| result.AppendErrorWithFormat("target #%u is NULL in target list\n", |
| target_idx); |
| result.SetStatus(eReturnStatusFailed); |
| } |
| } else { |
| if (num_targets > 0) { |
| result.AppendErrorWithFormat( |
| "index %u is out of range, valid target indexes are 0 - %u\n", |
| target_idx, num_targets - 1); |
| } else { |
| result.AppendErrorWithFormat( |
| "index %u is out of range since there are no active targets\n", |
| target_idx); |
| } |
| result.SetStatus(eReturnStatusFailed); |
| } |
| } else { |
| result.AppendErrorWithFormat("invalid index string value '%s'\n", |
| target_idx_arg); |
| result.SetStatus(eReturnStatusFailed); |
| } |
| } else { |
| result.AppendError( |
| "'target select' takes a single argument: a target index\n"); |
| result.SetStatus(eReturnStatusFailed); |
| } |
| return result.Succeeded(); |
| } |
| }; |
| |
| #pragma mark CommandObjectTargetSelect |
| |
| //---------------------------------------------------------------------- |
| // "target delete" |
| //---------------------------------------------------------------------- |
| |
| class CommandObjectTargetDelete : public CommandObjectParsed { |
| public: |
| CommandObjectTargetDelete(CommandInterpreter &interpreter) |
| : CommandObjectParsed(interpreter, "target delete", |
| "Delete one or more targets by target index.", |
| nullptr), |
| m_option_group(), m_all_option(LLDB_OPT_SET_1, false, "all", 'a', |
| "Delete all targets.", false, true), |
| m_cleanup_option( |
| LLDB_OPT_SET_1, false, "clean", 'c', |
| "Perform extra cleanup to minimize memory consumption after " |
| "deleting the target. " |
| "By default, LLDB will keep in memory any modules previously " |
| "loaded by the target as well " |
| "as all of its debug info. Specifying --clean will unload all of " |
| "these shared modules and " |
| "cause them to be reparsed again the next time the target is run", |
| false, true) { |
| m_option_group.Append(&m_all_option, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); |
| m_option_group.Append(&m_cleanup_option, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); |
| m_option_group.Finalize(); |
| } |
| |
| ~CommandObjectTargetDelete() override = default; |
| |
| Options *GetOptions() override { return &m_option_group; } |
| |
| protected: |
| bool DoExecute(Args &args, CommandReturnObject &result) override { |
| const size_t argc = args.GetArgumentCount(); |
| std::vector<TargetSP> delete_target_list; |
| TargetList &target_list = m_interpreter.GetDebugger().GetTargetList(); |
| TargetSP target_sp; |
| |
| if (m_all_option.GetOptionValue()) { |
| for (int i = 0; i < target_list.GetNumTargets(); ++i) |
| delete_target_list.push_back(target_list.GetTargetAtIndex(i)); |
| } else if (argc > 0) { |
| const uint32_t num_targets = target_list.GetNumTargets(); |
| // Bail out if don't have any targets. |
| if (num_targets == 0) { |
| result.AppendError("no targets to delete"); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| |
| for (auto &entry : args.entries()) { |
| uint32_t target_idx; |
| if (entry.ref.getAsInteger(0, target_idx)) { |
| result.AppendErrorWithFormat("invalid target index '%s'\n", |
| entry.c_str()); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| if (target_idx < num_targets) { |
| target_sp = target_list.GetTargetAtIndex(target_idx); |
| if (target_sp) { |
| delete_target_list.push_back(target_sp); |
| continue; |
| } |
| } |
| if (num_targets > 1) |
| result.AppendErrorWithFormat("target index %u is out of range, valid " |
| "target indexes are 0 - %u\n", |
| target_idx, num_targets - 1); |
| else |
| result.AppendErrorWithFormat( |
| "target index %u is out of range, the only valid index is 0\n", |
| target_idx); |
| |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| } else { |
| target_sp = target_list.GetSelectedTarget(); |
| if (!target_sp) { |
| result.AppendErrorWithFormat("no target is currently selected\n"); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| delete_target_list.push_back(target_sp); |
| } |
| |
| const size_t num_targets_to_delete = delete_target_list.size(); |
| for (size_t idx = 0; idx < num_targets_to_delete; ++idx) { |
| target_sp = delete_target_list[idx]; |
| target_list.DeleteTarget(target_sp); |
| target_sp->Destroy(); |
| } |
| // If "--clean" was specified, prune any orphaned shared modules from the |
| // global shared module list |
| if (m_cleanup_option.GetOptionValue()) { |
| const bool mandatory = true; |
| ModuleList::RemoveOrphanSharedModules(mandatory); |
| } |
| result.GetOutputStream().Printf("%u targets deleted.\n", |
| (uint32_t)num_targets_to_delete); |
| result.SetStatus(eReturnStatusSuccessFinishResult); |
| |
| return true; |
| } |
| |
| OptionGroupOptions m_option_group; |
| OptionGroupBoolean m_all_option; |
| OptionGroupBoolean m_cleanup_option; |
| }; |
| |
| #pragma mark CommandObjectTargetVariable |
| |
| //---------------------------------------------------------------------- |
| // "target variable" |
| //---------------------------------------------------------------------- |
| |
| class CommandObjectTargetVariable : public CommandObjectParsed { |
| static const uint32_t SHORT_OPTION_FILE = 0x66696c65; // 'file' |
| static const uint32_t SHORT_OPTION_SHLB = 0x73686c62; // 'shlb' |
| |
| public: |
| CommandObjectTargetVariable(CommandInterpreter &interpreter) |
| : CommandObjectParsed(interpreter, "target variable", |
| "Read global variables for the current target, " |
| "before or while running a process.", |
| nullptr, eCommandRequiresTarget), |
| m_option_group(), |
| m_option_variable(false), // Don't include frame options |
| m_option_format(eFormatDefault), |
| m_option_compile_units(LLDB_OPT_SET_1, false, "file", SHORT_OPTION_FILE, |
| 0, eArgTypeFilename, |
| "A basename or fullpath to a file that contains " |
| "global variables. This option can be " |
| "specified multiple times."), |
| m_option_shared_libraries( |
| LLDB_OPT_SET_1, false, "shlib", SHORT_OPTION_SHLB, 0, |
| eArgTypeFilename, |
| "A basename or fullpath to a shared library to use in the search " |
| "for global " |
| "variables. This option can be specified multiple times."), |
| m_varobj_options() { |
| CommandArgumentEntry arg; |
| CommandArgumentData var_name_arg; |
| |
| // Define the first (and only) variant of this arg. |
| var_name_arg.arg_type = eArgTypeVarName; |
| var_name_arg.arg_repetition = eArgRepeatPlus; |
| |
| // There is only one variant this argument could be; put it into the |
| // argument entry. |
| arg.push_back(var_name_arg); |
| |
| // Push the data for the first argument into the m_arguments vector. |
| m_arguments.push_back(arg); |
| |
| m_option_group.Append(&m_varobj_options, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); |
| m_option_group.Append(&m_option_variable, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); |
| m_option_group.Append(&m_option_format, |
| OptionGroupFormat::OPTION_GROUP_FORMAT | |
| OptionGroupFormat::OPTION_GROUP_GDB_FMT, |
| LLDB_OPT_SET_1); |
| m_option_group.Append(&m_option_compile_units, LLDB_OPT_SET_ALL, |
| LLDB_OPT_SET_1); |
| m_option_group.Append(&m_option_shared_libraries, LLDB_OPT_SET_ALL, |
| LLDB_OPT_SET_1); |
| m_option_group.Finalize(); |
| } |
| |
| ~CommandObjectTargetVariable() override = default; |
| |
| void DumpValueObject(Stream &s, VariableSP &var_sp, ValueObjectSP &valobj_sp, |
| const char *root_name) { |
| DumpValueObjectOptions options(m_varobj_options.GetAsDumpOptions()); |
| |
| if (!valobj_sp->GetTargetSP()->GetDisplayRuntimeSupportValues() && |
| valobj_sp->IsRuntimeSupportValue()) |
| return; |
| |
| switch (var_sp->GetScope()) { |
| case eValueTypeVariableGlobal: |
| if (m_option_variable.show_scope) |
| s.PutCString("GLOBAL: "); |
| break; |
| |
| case eValueTypeVariableStatic: |
| if (m_option_variable.show_scope) |
| s.PutCString("STATIC: "); |
| break; |
| |
| case eValueTypeVariableArgument: |
| if (m_option_variable.show_scope) |
| s.PutCString(" ARG: "); |
| break; |
| |
| case eValueTypeVariableLocal: |
| if (m_option_variable.show_scope) |
| s.PutCString(" LOCAL: "); |
| break; |
| |
| case eValueTypeVariableThreadLocal: |
| if (m_option_variable.show_scope) |
| s.PutCString("THREAD: "); |
| break; |
| |
| default: |
| break; |
| } |
| |
| if (m_option_variable.show_decl) { |
| bool show_fullpaths = false; |
| bool show_module = true; |
| if (var_sp->DumpDeclaration(&s, show_fullpaths, show_module)) |
| s.PutCString(": "); |
| } |
| |
| const Format format = m_option_format.GetFormat(); |
| if (format != eFormatDefault) |
| options.SetFormat(format); |
| |
| options.SetRootValueObjectName(root_name); |
| |
| valobj_sp->Dump(s, options); |
| } |
| |
| static size_t GetVariableCallback(void *baton, const char *name, |
| VariableList &variable_list) { |
| Target *target = static_cast<Target *>(baton); |
| if (target) { |
| return target->GetImages().FindGlobalVariables(ConstString(name), |
| UINT32_MAX, variable_list); |
| } |
| return 0; |
| } |
| |
| Options *GetOptions() override { return &m_option_group; } |
| |
| protected: |
| void DumpGlobalVariableList(const ExecutionContext &exe_ctx, |
| const SymbolContext &sc, |
| const VariableList &variable_list, Stream &s) { |
| size_t count = variable_list.GetSize(); |
| if (count > 0) { |
| if (sc.module_sp) { |
| if (sc.comp_unit) { |
| s.Printf("Global variables for %s in %s:\n", |
| sc.comp_unit->GetPath().c_str(), |
| sc.module_sp->GetFileSpec().GetPath().c_str()); |
| } else { |
| s.Printf("Global variables for %s\n", |
| sc.module_sp->GetFileSpec().GetPath().c_str()); |
| } |
| } else if (sc.comp_unit) { |
| s.Printf("Global variables for %s\n", sc.comp_unit->GetPath().c_str()); |
| } |
| |
| for (uint32_t i = 0; i < count; ++i) { |
| VariableSP var_sp(variable_list.GetVariableAtIndex(i)); |
| if (var_sp) { |
| ValueObjectSP valobj_sp(ValueObjectVariable::Create( |
| exe_ctx.GetBestExecutionContextScope(), var_sp)); |
| |
| if (valobj_sp) |
| DumpValueObject(s, var_sp, valobj_sp, |
| var_sp->GetName().GetCString()); |
| } |
| } |
| } |
| } |
| |
| bool DoExecute(Args &args, CommandReturnObject &result) override { |
| Target *target = m_exe_ctx.GetTargetPtr(); |
| const size_t argc = args.GetArgumentCount(); |
| Stream &s = result.GetOutputStream(); |
| |
| if (argc > 0) { |
| |
| // TODO: Convert to entry-based iteration. Requires converting |
| // DumpValueObject. |
| for (size_t idx = 0; idx < argc; ++idx) { |
| VariableList variable_list; |
| ValueObjectList valobj_list; |
| |
| const char *arg = args.GetArgumentAtIndex(idx); |
| size_t matches = 0; |
| bool use_var_name = false; |
| if (m_option_variable.use_regex) { |
| RegularExpression regex(llvm::StringRef::withNullAsEmpty(arg)); |
| if (!regex.IsValid()) { |
| result.GetErrorStream().Printf( |
| "error: invalid regular expression: '%s'\n", arg); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| use_var_name = true; |
| matches = target->GetImages().FindGlobalVariables(regex, UINT32_MAX, |
| variable_list); |
| } else { |
| Status error(Variable::GetValuesForVariableExpressionPath( |
| arg, m_exe_ctx.GetBestExecutionContextScope(), |
| GetVariableCallback, target, variable_list, valobj_list)); |
| matches = variable_list.GetSize(); |
| } |
| |
| if (matches == 0) { |
| result.GetErrorStream().Printf( |
| "error: can't find global variable '%s'\n", arg); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } else { |
| for (uint32_t global_idx = 0; global_idx < matches; ++global_idx) { |
| VariableSP var_sp(variable_list.GetVariableAtIndex(global_idx)); |
| if (var_sp) { |
| ValueObjectSP valobj_sp( |
| valobj_list.GetValueObjectAtIndex(global_idx)); |
| if (!valobj_sp) |
| valobj_sp = ValueObjectVariable::Create( |
| m_exe_ctx.GetBestExecutionContextScope(), var_sp); |
| |
| if (valobj_sp) |
| DumpValueObject(s, var_sp, valobj_sp, |
| use_var_name ? var_sp->GetName().GetCString() |
| : arg); |
| } |
| } |
| } |
| } |
| } else { |
| const FileSpecList &compile_units = |
| m_option_compile_units.GetOptionValue().GetCurrentValue(); |
| const FileSpecList &shlibs = |
| m_option_shared_libraries.GetOptionValue().GetCurrentValue(); |
| SymbolContextList sc_list; |
| const size_t num_compile_units = compile_units.GetSize(); |
| const size_t num_shlibs = shlibs.GetSize(); |
| if (num_compile_units == 0 && num_shlibs == 0) { |
| bool success = false; |
| StackFrame *frame = m_exe_ctx.GetFramePtr(); |
| CompileUnit *comp_unit = nullptr; |
| if (frame) { |
| SymbolContext sc = frame->GetSymbolContext(eSymbolContextCompUnit); |
| if (sc.comp_unit) { |
| const bool can_create = true; |
| VariableListSP comp_unit_varlist_sp( |
| sc.comp_unit->GetVariableList(can_create)); |
| if (comp_unit_varlist_sp) { |
| size_t count = comp_unit_varlist_sp->GetSize(); |
| if (count > 0) { |
| DumpGlobalVariableList(m_exe_ctx, sc, *comp_unit_varlist_sp, s); |
| success = true; |
| } |
| } |
| } |
| } |
| if (!success) { |
| if (frame) { |
| if (comp_unit) |
| result.AppendErrorWithFormat( |
| "no global variables in current compile unit: %s\n", |
| comp_unit->GetPath().c_str()); |
| else |
| result.AppendErrorWithFormat( |
| "no debug information for frame %u\n", |
| frame->GetFrameIndex()); |
| } else |
| result.AppendError("'target variable' takes one or more global " |
| "variable names as arguments\n"); |
| result.SetStatus(eReturnStatusFailed); |
| } |
| } else { |
| SymbolContextList sc_list; |
| const bool append = true; |
| // We have one or more compile unit or shlib |
| if (num_shlibs > 0) { |
| for (size_t shlib_idx = 0; shlib_idx < num_shlibs; ++shlib_idx) { |
| const FileSpec module_file(shlibs.GetFileSpecAtIndex(shlib_idx)); |
| ModuleSpec module_spec(module_file); |
| |
| ModuleSP module_sp( |
| target->GetImages().FindFirstModule(module_spec)); |
| if (module_sp) { |
| if (num_compile_units > 0) { |
| for (size_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) |
| module_sp->FindCompileUnits( |
| compile_units.GetFileSpecAtIndex(cu_idx), append, |
| sc_list); |
| } else { |
| SymbolContext sc; |
| sc.module_sp = module_sp; |
| sc_list.Append(sc); |
| } |
| } else { |
| // Didn't find matching shlib/module in target... |
| result.AppendErrorWithFormat( |
| "target doesn't contain the specified shared library: %s\n", |
| module_file.GetPath().c_str()); |
| } |
| } |
| } else { |
| // No shared libraries, we just want to find globals for the compile |
| // units files that were specified |
| for (size_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) |
| target->GetImages().FindCompileUnits( |
| compile_units.GetFileSpecAtIndex(cu_idx), append, sc_list); |
| } |
| |
| const uint32_t num_scs = sc_list.GetSize(); |
| if (num_scs > 0) { |
| SymbolContext sc; |
| for (uint32_t sc_idx = 0; sc_idx < num_scs; ++sc_idx) { |
| if (sc_list.GetContextAtIndex(sc_idx, sc)) { |
| if (sc.comp_unit) { |
| const bool can_create = true; |
| VariableListSP comp_unit_varlist_sp( |
| sc.comp_unit->GetVariableList(can_create)); |
| if (comp_unit_varlist_sp) |
| DumpGlobalVariableList(m_exe_ctx, sc, *comp_unit_varlist_sp, |
| s); |
| } else if (sc.module_sp) { |
| // Get all global variables for this module |
| lldb_private::RegularExpression all_globals_regex( |
| llvm::StringRef( |
| ".")); // Any global with at least one character |
| VariableList variable_list; |
| sc.module_sp->FindGlobalVariables(all_globals_regex, UINT32_MAX, |
| variable_list); |
| DumpGlobalVariableList(m_exe_ctx, sc, variable_list, s); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| if (m_interpreter.TruncationWarningNecessary()) { |
| result.GetOutputStream().Printf(m_interpreter.TruncationWarningText(), |
| m_cmd_name.c_str()); |
| m_interpreter.TruncationWarningGiven(); |
| } |
| |
| return result.Succeeded(); |
| } |
| |
| OptionGroupOptions m_option_group; |
| OptionGroupVariable m_option_variable; |
| OptionGroupFormat m_option_format; |
| OptionGroupFileList m_option_compile_units; |
| OptionGroupFileList m_option_shared_libraries; |
| OptionGroupValueObjectDisplay m_varobj_options; |
| }; |
| |
| #pragma mark CommandObjectTargetModulesSearchPathsAdd |
| |
| class CommandObjectTargetModulesSearchPathsAdd : public CommandObjectParsed { |
| public: |
| CommandObjectTargetModulesSearchPathsAdd(CommandInterpreter &interpreter) |
| : CommandObjectParsed(interpreter, "target modules search-paths add", |
| "Add new image search paths substitution pairs to " |
| "the current target.", |
| nullptr) { |
| CommandArgumentEntry arg; |
| CommandArgumentData old_prefix_arg; |
| CommandArgumentData new_prefix_arg; |
| |
| // Define the first variant of this arg pair. |
| old_prefix_arg.arg_type = eArgTypeOldPathPrefix; |
| old_prefix_arg.arg_repetition = eArgRepeatPairPlus; |
| |
| // Define the first variant of this arg pair. |
| new_prefix_arg.arg_type = eArgTypeNewPathPrefix; |
| new_prefix_arg.arg_repetition = eArgRepeatPairPlus; |
| |
| // There are two required arguments that must always occur together, i.e. |
| // an argument "pair". Because they must always occur together, they are |
| // treated as two variants of one argument rather than two independent |
| // arguments. Push them both into the first argument position for |
| // m_arguments... |
| |
| arg.push_back(old_prefix_arg); |
| arg.push_back(new_prefix_arg); |
| |
| m_arguments.push_back(arg); |
| } |
| |
| ~CommandObjectTargetModulesSearchPathsAdd() override = default; |
| |
| protected: |
| bool DoExecute(Args &command, CommandReturnObject &result) override { |
| Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get(); |
| if (target) { |
| const size_t argc = command.GetArgumentCount(); |
| if (argc & 1) { |
| result.AppendError("add requires an even number of arguments\n"); |
| result.SetStatus(eReturnStatusFailed); |
| } else { |
| for (size_t i = 0; i < argc; i += 2) { |
| const char *from = command.GetArgumentAtIndex(i); |
| const char *to = command.GetArgumentAtIndex(i + 1); |
| |
| if (from[0] && to[0]) { |
| Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST); |
| if (log) { |
| log->Printf("target modules search path adding ImageSearchPath " |
| "pair: '%s' -> '%s'", |
| from, to); |
| } |
| bool last_pair = ((argc - i) == 2); |
| target->GetImageSearchPathList().Append( |
| ConstString(from), ConstString(to), |
| last_pair); // Notify if this is the last pair |
| result.SetStatus(eReturnStatusSuccessFinishNoResult); |
| } else { |
| if (from[0]) |
| result.AppendError("<path-prefix> can't be empty\n"); |
| else |
| result.AppendError("<new-path-prefix> can't be empty\n"); |
| result.SetStatus(eReturnStatusFailed); |
| } |
| } |
| } |
| } else { |
| result.AppendError("invalid target\n"); |
| result.SetStatus(eReturnStatusFailed); |
| } |
| return result.Succeeded(); |
| } |
| }; |
| |
| #pragma mark CommandObjectTargetModulesSearchPathsClear |
| |
| class CommandObjectTargetModulesSearchPathsClear : public CommandObjectParsed { |
| public: |
| CommandObjectTargetModulesSearchPathsClear(CommandInterpreter &interpreter) |
| : CommandObjectParsed(interpreter, "target modules search-paths clear", |
| "Clear all current image search path substitution " |
| "pairs from the current target.", |
| "target modules search-paths clear") {} |
| |
| ~CommandObjectTargetModulesSearchPathsClear() override = default; |
| |
| protected: |
| bool DoExecute(Args &command, CommandReturnObject &result) override { |
| Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get(); |
| if (target) { |
| bool notify = true; |
| target->GetImageSearchPathList().Clear(notify); |
| result.SetStatus(eReturnStatusSuccessFinishNoResult); |
| } else { |
| result.AppendError("invalid target\n"); |
| result.SetStatus(eReturnStatusFailed); |
| } |
| return result.Succeeded(); |
| } |
| }; |
| |
| #pragma mark CommandObjectTargetModulesSearchPathsInsert |
| |
| class CommandObjectTargetModulesSearchPathsInsert : public CommandObjectParsed { |
| public: |
| CommandObjectTargetModulesSearchPathsInsert(CommandInterpreter &interpreter) |
| : CommandObjectParsed(interpreter, "target modules search-paths insert", |
| "Insert a new image search path substitution pair " |
| "into the current target at the specified index.", |
| nullptr) { |
| CommandArgumentEntry arg1; |
| CommandArgumentEntry arg2; |
| CommandArgumentData index_arg; |
| CommandArgumentData old_prefix_arg; |
| CommandArgumentData new_prefix_arg; |
| |
| // Define the first and only variant of this arg. |
| index_arg.arg_type = eArgTypeIndex; |
| index_arg.arg_repetition = eArgRepeatPlain; |
| |
| // Put the one and only variant into the first arg for m_arguments: |
| arg1.push_back(index_arg); |
| |
| // Define the first variant of this arg pair. |
| old_prefix_arg.arg_type = eArgTypeOldPathPrefix; |
| old_prefix_arg.arg_repetition = eArgRepeatPairPlus; |
| |
| // Define the first variant of this arg pair. |
| new_prefix_arg.arg_type = eArgTypeNewPathPrefix; |
| new_prefix_arg.arg_repetition = eArgRepeatPairPlus; |
| |
| // There are two required arguments that must always occur together, i.e. |
| // an argument "pair". Because they must always occur together, they are |
| // treated as two variants of one argument rather than two independent |
| // arguments. Push them both into the same argument position for |
| // m_arguments... |
| |
| arg2.push_back(old_prefix_arg); |
| arg2.push_back(new_prefix_arg); |
| |
| // Add arguments to m_arguments. |
| m_arguments.push_back(arg1); |
| m_arguments.push_back(arg2); |
| } |
| |
| ~CommandObjectTargetModulesSearchPathsInsert() override = default; |
| |
| protected: |
| bool DoExecute(Args &command, CommandReturnObject &result) override { |
| Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get(); |
| if (target) { |
| size_t argc = command.GetArgumentCount(); |
| // check for at least 3 arguments and an odd number of parameters |
| if (argc >= 3 && argc & 1) { |
| bool success = false; |
| |
| uint32_t insert_idx = StringConvert::ToUInt32( |
| command.GetArgumentAtIndex(0), UINT32_MAX, 0, &success); |
| |
| if (!success) { |
| result.AppendErrorWithFormat( |
| "<index> parameter is not an integer: '%s'.\n", |
| command.GetArgumentAtIndex(0)); |
| result.SetStatus(eReturnStatusFailed); |
| return result.Succeeded(); |
| } |
| |
| // shift off the index |
| command.Shift(); |
| argc = command.GetArgumentCount(); |
| |
| for (uint32_t i = 0; i < argc; i += 2, ++insert_idx) { |
| const char *from = command.GetArgumentAtIndex(i); |
| const char *to = command.GetArgumentAtIndex(i + 1); |
| |
| if (from[0] && to[0]) { |
| bool last_pair = ((argc - i) == 2); |
| target->GetImageSearchPathList().Insert( |
| ConstString(from), ConstString(to), insert_idx, last_pair); |
| result.SetStatus(eReturnStatusSuccessFinishNoResult); |
| } else { |
| if (from[0]) |
| result.AppendError("<path-prefix> can't be empty\n"); |
| else |
| result.AppendError("<new-path-prefix> can't be empty\n"); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| } |
| } else { |
| result.AppendError("insert requires at least three arguments\n"); |
| result.SetStatus(eReturnStatusFailed); |
| return result.Succeeded(); |
| } |
| |
| } else { |
| result.AppendError("invalid target\n"); |
| result.SetStatus(eReturnStatusFailed); |
| } |
| return result.Succeeded(); |
| } |
| }; |
| |
| #pragma mark CommandObjectTargetModulesSearchPathsList |
| |
| class CommandObjectTargetModulesSearchPathsList : public CommandObjectParsed { |
| public: |
| CommandObjectTargetModulesSearchPathsList(CommandInterpreter &interpreter) |
| : CommandObjectParsed(interpreter, "target modules search-paths list", |
| "List all current image search path substitution " |
| "pairs in the current target.", |
| "target modules search-paths list") {} |
| |
| ~CommandObjectTargetModulesSearchPathsList() override = default; |
| |
| protected: |
| bool DoExecute(Args &command, CommandReturnObject &result) override { |
| Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get(); |
| if (target) { |
| if (command.GetArgumentCount() != 0) { |
| result.AppendError("list takes no arguments\n"); |
| result.SetStatus(eReturnStatusFailed); |
| return result.Succeeded(); |
| } |
| |
| target->GetImageSearchPathList().Dump(&result.GetOutputStream()); |
| result.SetStatus(eReturnStatusSuccessFinishResult); |
| } else { |
| result.AppendError("invalid target\n"); |
| result.SetStatus(eReturnStatusFailed); |
| } |
| return result.Succeeded(); |
| } |
| }; |
| |
| #pragma mark CommandObjectTargetModulesSearchPathsQuery |
| |
| class CommandObjectTargetModulesSearchPathsQuery : public CommandObjectParsed { |
| public: |
| CommandObjectTargetModulesSearchPathsQuery(CommandInterpreter &interpreter) |
| : CommandObjectParsed( |
| interpreter, "target modules search-paths query", |
| "Transform a path using the first applicable image search path.", |
| nullptr) { |
| CommandArgumentEntry arg; |
| CommandArgumentData path_arg; |
| |
| // Define the first (and only) variant of this arg. |
| path_arg.arg_type = eArgTypeDirectoryName; |
| path_arg.arg_repetition = eArgRepeatPlain; |
| |
| // There is only one variant this argument could be; put it into the |
| // argument entry. |
| arg.push_back(path_arg); |
| |
| // Push the data for the first argument into the m_arguments vector. |
| m_arguments.push_back(arg); |
| } |
| |
| ~CommandObjectTargetModulesSearchPathsQuery() override = default; |
| |
| protected: |
| bool DoExecute(Args &command, CommandReturnObject &result) override { |
| Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get(); |
| if (target) { |
| if (command.GetArgumentCount() != 1) { |
| result.AppendError("query requires one argument\n"); |
| result.SetStatus(eReturnStatusFailed); |
| return result.Succeeded(); |
| } |
| |
| ConstString orig(command.GetArgumentAtIndex(0)); |
| ConstString transformed; |
| if (target->GetImageSearchPathList().RemapPath(orig, transformed)) |
| result.GetOutputStream().Printf("%s\n", transformed.GetCString()); |
| else |
| result.GetOutputStream().Printf("%s\n", orig.GetCString()); |
| |
| result.SetStatus(eReturnStatusSuccessFinishResult); |
| } else { |
| result.AppendError("invalid target\n"); |
| result.SetStatus(eReturnStatusFailed); |
| } |
| return result.Succeeded(); |
| } |
| }; |
| |
| //---------------------------------------------------------------------- |
| // Static Helper functions |
| //---------------------------------------------------------------------- |
| static void DumpModuleArchitecture(Stream &strm, Module *module, |
| bool full_triple, uint32_t width) { |
| if (module) { |
| StreamString arch_strm; |
| |
| if (full_triple) |
| module->GetArchitecture().DumpTriple(arch_strm); |
| else |
| arch_strm.PutCString(module->GetArchitecture().GetArchitectureName()); |
| std::string arch_str = arch_strm.GetString(); |
| |
| if (width) |
| strm.Printf("%-*s", width, arch_str.c_str()); |
| else |
| strm.PutCString(arch_str); |
| } |
| } |
| |
| static void DumpModuleUUID(Stream &strm, Module *module) { |
| if (module && module->GetUUID().IsValid()) |
| module->GetUUID().Dump(&strm); |
| else |
| strm.PutCString(" "); |
| } |
| |
| static uint32_t DumpCompileUnitLineTable(CommandInterpreter &interpreter, |
| Stream &strm, Module *module, |
| const FileSpec &file_spec, |
| bool load_addresses) { |
| uint32_t num_matches = 0; |
| if (module) { |
| SymbolContextList sc_list; |
| num_matches = module->ResolveSymbolContextsForFileSpec( |
| file_spec, 0, false, eSymbolContextCompUnit, sc_list); |
| |
| for (uint32_t i = 0; i < num_matches; ++i) { |
| SymbolContext sc; |
| if (sc_list.GetContextAtIndex(i, sc)) { |
| if (i > 0) |
| strm << "\n\n"; |
| |
| strm << "Line table for " << *static_cast<FileSpec *>(sc.comp_unit) |
| << " in `" << module->GetFileSpec().GetFilename() << "\n"; |
| LineTable *line_table = sc.comp_unit->GetLineTable(); |
| if (line_table) |
| line_table->GetDescription( |
| &strm, interpreter.GetExecutionContext().GetTargetPtr(), |
| lldb::eDescriptionLevelBrief); |
| else |
| strm << "No line table"; |
| } |
| } |
| } |
| return num_matches; |
| } |
| |
| static void DumpFullpath(Stream &strm, const FileSpec *file_spec_ptr, |
| uint32_t width) { |
| if (file_spec_ptr) { |
| if (width > 0) { |
| std::string fullpath = file_spec_ptr->GetPath(); |
| strm.Printf("%-*s", width, fullpath.c_str()); |
| return; |
| } else { |
| file_spec_ptr->Dump(&strm); |
| return; |
| } |
| } |
| // Keep the width spacing correct if things go wrong... |
| if (width > 0) |
| strm.Printf("%-*s", width, ""); |
| } |
| |
| static void DumpDirectory(Stream &strm, const FileSpec *file_spec_ptr, |
| uint32_t width) { |
| if (file_spec_ptr) { |
| if (width > 0) |
| strm.Printf("%-*s", width, file_spec_ptr->GetDirectory().AsCString("")); |
| else |
| file_spec_ptr->GetDirectory().Dump(&strm); |
| return; |
| } |
| // Keep the width spacing correct if things go wrong... |
| if (width > 0) |
| strm.Printf("%-*s", width, ""); |
| } |
| |
| static void DumpBasename(Stream &strm, const FileSpec *file_spec_ptr, |
| uint32_t width) { |
| if (file_spec_ptr) { |
| if (width > 0) |
| strm.Printf("%-*s", width, file_spec_ptr->GetFilename().AsCString("")); |
| else |
| file_spec_ptr->GetFilename().Dump(&strm); |
| return; |
| } |
| // Keep the width spacing correct if things go wrong... |
| if (width > 0) |
| strm.Printf("%-*s", width, ""); |
| } |
| |
| static size_t DumpModuleObjfileHeaders(Stream &strm, ModuleList &module_list) { |
| size_t num_dumped = 0; |
| std::lock_guard<std::recursive_mutex> guard(module_list.GetMutex()); |
| const size_t num_modules = module_list.GetSize(); |
| if (num_modules > 0) { |
| strm.Printf("Dumping headers for %" PRIu64 " module(s).\n", |
| static_cast<uint64_t>(num_modules)); |
| strm.IndentMore(); |
| for (size_t image_idx = 0; image_idx < num_modules; ++image_idx) { |
| Module *module = module_list.GetModulePointerAtIndexUnlocked(image_idx); |
| if (module) { |
| if (num_dumped++ > 0) { |
| strm.EOL(); |
| strm.EOL(); |
| } |
| ObjectFile *objfile = module->GetObjectFile(); |
| if (objfile) |
| objfile->Dump(&strm); |
| else { |
| strm.Format("No object file for module: {0:F}\n", |
| module->GetFileSpec()); |
| } |
| } |
| } |
| strm.IndentLess(); |
| } |
| return num_dumped; |
| } |
| |
| static void DumpModuleSymtab(CommandInterpreter &interpreter, Stream &strm, |
| Module *module, SortOrder sort_order) { |
| if (module) { |
| SymbolVendor *sym_vendor = module->GetSymbolVendor(); |
| if (sym_vendor) { |
| Symtab *symtab = sym_vendor->GetSymtab(); |
| if (symtab) |
| symtab->Dump(&strm, interpreter.GetExecutionContext().GetTargetPtr(), |
| sort_order); |
| } |
| } |
| } |
| |
| static void DumpModuleSections(CommandInterpreter &interpreter, Stream &strm, |
| Module *module) { |
| if (module) { |
| SectionList *section_list = module->GetSectionList(); |
| if (section_list) { |
| strm.Printf("Sections for '%s' (%s):\n", |
| module->GetSpecificationDescription().c_str(), |
| module->GetArchitecture().GetArchitectureName()); |
| strm.IndentMore(); |
| section_list->Dump(&strm, |
| interpreter.GetExecutionContext().GetTargetPtr(), true, |
| UINT32_MAX); |
| strm.IndentLess(); |
| } |
| } |
| } |
| |
| static bool DumpModuleSymbolVendor(Stream &strm, Module *module) { |
| if (module) { |
| SymbolVendor *symbol_vendor = module->GetSymbolVendor(true); |
| if (symbol_vendor) { |
| symbol_vendor->Dump(&strm); |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| static void DumpAddress(ExecutionContextScope *exe_scope, |
| const Address &so_addr, bool verbose, Stream &strm) { |
| strm.IndentMore(); |
| strm.Indent(" Address: "); |
| so_addr.Dump(&strm, exe_scope, Address::DumpStyleModuleWithFileAddress); |
| strm.PutCString(" ("); |
| so_addr.Dump(&strm, exe_scope, Address::DumpStyleSectionNameOffset); |
| strm.PutCString(")\n"); |
| strm.Indent(" Summary: "); |
| const uint32_t save_indent = strm.GetIndentLevel(); |
| strm.SetIndentLevel(save_indent + 13); |
| so_addr.Dump(&strm, exe_scope, Address::DumpStyleResolvedDescription); |
| strm.SetIndentLevel(save_indent); |
| // Print out detailed address information when verbose is enabled |
| if (verbose) { |
| strm.EOL(); |
| so_addr.Dump(&strm, exe_scope, Address::DumpStyleDetailedSymbolContext); |
| } |
| strm.IndentLess(); |
| } |
| |
| static bool LookupAddressInModule(CommandInterpreter &interpreter, Stream &strm, |
| Module *module, uint32_t resolve_mask, |
| lldb::addr_t raw_addr, lldb::addr_t offset, |
| bool verbose) { |
| if (module) { |
| lldb::addr_t addr = raw_addr - offset; |
| Address so_addr; |
| SymbolContext sc; |
| Target *target = interpreter.GetExecutionContext().GetTargetPtr(); |
| if (target && !target->GetSectionLoadList().IsEmpty()) { |
| if (!target->GetSectionLoadList().ResolveLoadAddress(addr, so_addr)) |
| return false; |
| else if (so_addr.GetModule().get() != module) |
| return false; |
| } else { |
| if (!module->ResolveFileAddress(addr, so_addr)) |
| return false; |
| } |
| |
| ExecutionContextScope *exe_scope = |
| interpreter.GetExecutionContext().GetBestExecutionContextScope(); |
| DumpAddress(exe_scope, so_addr, verbose, strm); |
| // strm.IndentMore(); |
| // strm.Indent (" Address: "); |
| // so_addr.Dump (&strm, exe_scope, |
| // Address::DumpStyleModuleWithFileAddress); |
| // strm.PutCString (" ("); |
| // so_addr.Dump (&strm, exe_scope, |
| // Address::DumpStyleSectionNameOffset); |
| // strm.PutCString (")\n"); |
| // strm.Indent (" Summary: "); |
| // const uint32_t save_indent = strm.GetIndentLevel (); |
| // strm.SetIndentLevel (save_indent + 13); |
| // so_addr.Dump (&strm, exe_scope, |
| // Address::DumpStyleResolvedDescription); |
| // strm.SetIndentLevel (save_indent); |
| // // Print out detailed address information when verbose is enabled |
| // if (verbose) |
| // { |
| // strm.EOL(); |
| // so_addr.Dump (&strm, exe_scope, |
| // Address::DumpStyleDetailedSymbolContext); |
| // } |
| // strm.IndentLess(); |
| return true; |
| } |
| |
| return false; |
| } |
| |
| static uint32_t LookupSymbolInModule(CommandInterpreter &interpreter, |
| Stream &strm, Module *module, |
| const char *name, bool name_is_regex, |
| bool verbose) { |
| if (module) { |
| SymbolContext sc; |
| |
| SymbolVendor *sym_vendor = module->GetSymbolVendor(); |
| if (sym_vendor) { |
| Symtab *symtab = sym_vendor->GetSymtab(); |
| if (symtab) { |
| std::vector<uint32_t> match_indexes; |
| ConstString symbol_name(name); |
| uint32_t num_matches = 0; |
| if (name_is_regex) { |
| RegularExpression name_regexp(symbol_name.GetStringRef()); |
| num_matches = symtab->AppendSymbolIndexesMatchingRegExAndType( |
| name_regexp, eSymbolTypeAny, match_indexes); |
| } else { |
| num_matches = |
| symtab->AppendSymbolIndexesWithName(symbol_name, match_indexes); |
| } |
| |
| if (num_matches > 0) { |
| strm.Indent(); |
| strm.Printf("%u symbols match %s'%s' in ", num_matches, |
| name_is_regex ? "the regular expression " : "", name); |
| DumpFullpath(strm, &module->GetFileSpec(), 0); |
| strm.PutCString(":\n"); |
| strm.IndentMore(); |
| for (uint32_t i = 0; i < num_matches; ++i) { |
| Symbol *symbol = symtab->SymbolAtIndex(match_indexes[i]); |
| if (symbol && symbol->ValueIsAddress()) { |
| DumpAddress(interpreter.GetExecutionContext() |
| .GetBestExecutionContextScope(), |
| symbol->GetAddressRef(), verbose, strm); |
| } |
| } |
| strm.IndentLess(); |
| return num_matches; |
| } |
| } |
| } |
| } |
| return 0; |
| } |
| |
| static void DumpSymbolContextList(ExecutionContextScope *exe_scope, |
| Stream &strm, SymbolContextList &sc_list, |
| bool verbose) { |
| strm.IndentMore(); |
| |
| const uint32_t num_matches = sc_list.GetSize(); |
| |
| for (uint32_t i = 0; i < num_matches; ++i) { |
| SymbolContext sc; |
| if (sc_list.GetContextAtIndex(i, sc)) { |
| AddressRange range; |
| |
| sc.GetAddressRange(eSymbolContextEverything, 0, true, range); |
| |
| DumpAddress(exe_scope, range.GetBaseAddress(), verbose, strm); |
| } |
| } |
| strm.IndentLess(); |
| } |
| |
| static size_t LookupFunctionInModule(CommandInterpreter &interpreter, |
| Stream &strm, Module *module, |
| const char *name, bool name_is_regex, |
| bool include_inlines, bool include_symbols, |
| bool verbose) { |
| if (module && name && name[0]) { |
| SymbolContextList sc_list; |
| const bool append = true; |
| size_t num_matches = 0; |
| if (name_is_regex) { |
| RegularExpression function_name_regex((llvm::StringRef(name))); |
| num_matches = module->FindFunctions(function_name_regex, include_symbols, |
| include_inlines, append, sc_list); |
| } else { |
| ConstString function_name(name); |
| num_matches = module->FindFunctions( |
| function_name, nullptr, eFunctionNameTypeAuto, include_symbols, |
| include_inlines, append, sc_list); |
| } |
| |
| if (num_matches) { |
| strm.Indent(); |
| strm.Printf("%" PRIu64 " match%s found in ", (uint64_t)num_matches, |
| num_matches > 1 ? "es" : ""); |
| DumpFullpath(strm, &module->GetFileSpec(), 0); |
| strm.PutCString(":\n"); |
| DumpSymbolContextList( |
| interpreter.GetExecutionContext().GetBestExecutionContextScope(), |
| strm, sc_list, verbose); |
| } |
| return num_matches; |
| } |
| return 0; |
| } |
| |
| static size_t LookupTypeInModule(CommandInterpreter &interpreter, Stream &strm, |
| Module *module, const char *name_cstr, |
| bool name_is_regex) { |
| if (module && name_cstr && name_cstr[0]) { |
| TypeList type_list; |
| const uint32_t max_num_matches = UINT32_MAX; |
| size_t num_matches = 0; |
| bool name_is_fully_qualified = false; |
| SymbolContext sc; |
| |
| ConstString name(name_cstr); |
| llvm::DenseSet<lldb_private::SymbolFile *> searched_symbol_files; |
| num_matches = |
| module->FindTypes(sc, name, name_is_fully_qualified, max_num_matches, |
| searched_symbol_files, type_list); |
| |
| if (num_matches) { |
| strm.Indent(); |
| strm.Printf("%" PRIu64 " match%s found in ", (uint64_t)num_matches, |
| num_matches > 1 ? "es" : ""); |
| DumpFullpath(strm, &module->GetFileSpec(), 0); |
| strm.PutCString(":\n"); |
| for (TypeSP type_sp : type_list.Types()) { |
| if (type_sp) { |
| // Resolve the clang type so that any forward references to types |
| // that haven't yet been parsed will get parsed. |
| type_sp->GetFullCompilerType(); |
| type_sp->GetDescription(&strm, eDescriptionLevelFull, true); |
| // Print all typedef chains |
| TypeSP typedef_type_sp(type_sp); |
| TypeSP typedefed_type_sp(typedef_type_sp->GetTypedefType()); |
| while (typedefed_type_sp) { |
| strm.EOL(); |
| strm.Printf(" typedef '%s': ", |
| typedef_type_sp->GetName().GetCString()); |
| typedefed_type_sp->GetFullCompilerType(); |
| typedefed_type_sp->GetDescription(&strm, eDescriptionLevelFull, |
| true); |
| typedef_type_sp = typedefed_type_sp; |
| typedefed_type_sp = typedef_type_sp->GetTypedefType(); |
| } |
| } |
| strm.EOL(); |
| } |
| } |
| return num_matches; |
| } |
| return 0; |
| } |
| |
| static size_t LookupTypeHere(CommandInterpreter &interpreter, Stream &strm, |
| const SymbolContext &sym_ctx, |
| const char *name_cstr, bool name_is_regex) { |
| if (!sym_ctx.module_sp) |
| return 0; |
| |
| TypeList type_list; |
| const uint32_t max_num_matches = UINT32_MAX; |
| size_t num_matches = 1; |
| bool name_is_fully_qualified = false; |
| |
| ConstString name(name_cstr); |
| llvm::DenseSet<SymbolFile *> searched_symbol_files; |
| num_matches = sym_ctx.module_sp->FindTypes( |
| sym_ctx, name, name_is_fully_qualified, max_num_matches, |
| searched_symbol_files, type_list); |
| |
| if (num_matches) { |
| strm.Indent(); |
| strm.PutCString("Best match found in "); |
| DumpFullpath(strm, &sym_ctx.module_sp->GetFileSpec(), 0); |
| strm.PutCString(":\n"); |
| |
| TypeSP type_sp(type_list.GetTypeAtIndex(0)); |
| if (type_sp) { |
| // Resolve the clang type so that any forward references to types that |
| // haven't yet been parsed will get parsed. |
| type_sp->GetFullCompilerType(); |
| type_sp->GetDescription(&strm, eDescriptionLevelFull, true); |
| // Print all typedef chains |
| TypeSP typedef_type_sp(type_sp); |
| TypeSP typedefed_type_sp(typedef_type_sp->GetTypedefType()); |
| while (typedefed_type_sp) { |
| strm.EOL(); |
| strm.Printf(" typedef '%s': ", |
| typedef_type_sp->GetName().GetCString()); |
| typedefed_type_sp->GetFullCompilerType(); |
| typedefed_type_sp->GetDescription(&strm, eDescriptionLevelFull, true); |
| typedef_type_sp = typedefed_type_sp; |
| typedefed_type_sp = typedef_type_sp->GetTypedefType(); |
| } |
| } |
| strm.EOL(); |
| } |
| return num_matches; |
| } |
| |
| static uint32_t LookupFileAndLineInModule(CommandInterpreter &interpreter, |
| Stream &strm, Module *module, |
| const FileSpec &file_spec, |
| uint32_t line, bool check_inlines, |
| bool verbose) { |
| if (module && file_spec) { |
| SymbolContextList sc_list; |
| const uint32_t num_matches = module->ResolveSymbolContextsForFileSpec( |
| file_spec, line, check_inlines, eSymbolContextEverything, sc_list); |
| if (num_matches > 0) { |
| strm.Indent(); |
| strm.Printf("%u match%s found in ", num_matches, |
| num_matches > 1 ? "es" : ""); |
| strm << file_spec; |
| if (line > 0) |
| strm.Printf(":%u", line); |
| strm << " in "; |
| DumpFullpath(strm, &module->GetFileSpec(), 0); |
| strm.PutCString(":\n"); |
| DumpSymbolContextList( |
| interpreter.GetExecutionContext().GetBestExecutionContextScope(), |
| strm, sc_list, verbose); |
| return num_matches; |
| } |
| } |
| return 0; |
| } |
| |
| static size_t FindModulesByName(Target *target, const char *module_name, |
| ModuleList &module_list, |
| bool check_global_list) { |
| FileSpec module_file_spec(module_name, false); |
| ModuleSpec module_spec(module_file_spec); |
| |
| const size_t initial_size = module_list.GetSize(); |
| |
| if (check_global_list) { |
| // Check the global list |
| std::lock_guard<std::recursive_mutex> guard( |
| Module::GetAllocationModuleCollectionMutex()); |
| const size_t num_modules = Module::GetNumberAllocatedModules(); |
| ModuleSP module_sp; |
| for (size_t image_idx = 0; image_idx < num_modules; ++image_idx) { |
| Module *module = Module::GetAllocatedModuleAtIndex(image_idx); |
| |
| if (module) { |
| if (module->MatchesModuleSpec(module_spec)) { |
| module_sp = module->shared_from_this(); |
| module_list.AppendIfNeeded(module_sp); |
| } |
| } |
| } |
| } else { |
| if (target) { |
| const size_t num_matches = |
| target->GetImages().FindModules(module_spec, module_list); |
| |
| // Not found in our module list for our target, check the main shared |
| // module list in case it is a extra file used somewhere else |
| if (num_matches == 0) { |
| module_spec.GetArchitecture() = target->GetArchitecture(); |
| ModuleList::FindSharedModules(module_spec, module_list); |
| } |
| } else { |
| ModuleList::FindSharedModules(module_spec, module_list); |
| } |
| } |
| |
| return module_list.GetSize() - initial_size; |
| } |
| |
| #pragma mark CommandObjectTargetModulesModuleAutoComplete |
| |
| //---------------------------------------------------------------------- |
| // A base command object class that can auto complete with module file |
| // paths |
| //---------------------------------------------------------------------- |
| |
| class CommandObjectTargetModulesModuleAutoComplete |
| : public CommandObjectParsed { |
| public: |
| CommandObjectTargetModulesModuleAutoComplete(CommandInterpreter &interpreter, |
| const char *name, |
| const char *help, |
| const char *syntax) |
| : CommandObjectParsed(interpreter, name, help, syntax) { |
| CommandArgumentEntry arg; |
| CommandArgumentData file_arg; |
| |
| // Define the first (and only) variant of this arg. |
| file_arg.arg_type = eArgTypeFilename; |
| file_arg.arg_repetition = eArgRepeatStar; |
| |
| // There is only one variant this argument could be; put it into the |
| // argument entry. |
| arg.push_back(file_arg); |
| |
| // Push the data for the first argument into the m_arguments vector. |
| m_arguments.push_back(arg); |
| } |
| |
| ~CommandObjectTargetModulesModuleAutoComplete() override = default; |
| |
| int HandleArgumentCompletion( |
| CompletionRequest &request, |
| OptionElementVector &opt_element_vector) override { |
| CommandCompletions::InvokeCommonCompletionCallbacks( |
| GetCommandInterpreter(), CommandCompletions::eModuleCompletion, request, |
| nullptr); |
| return request.GetNumberOfMatches(); |
| } |
| }; |
| |
| #pragma mark CommandObjectTargetModulesSourceFileAutoComplete |
| |
| //---------------------------------------------------------------------- |
| // A base command object class that can auto complete with module source |
| // file paths |
| //---------------------------------------------------------------------- |
| |
| class CommandObjectTargetModulesSourceFileAutoComplete |
| : public CommandObjectParsed { |
| public: |
| CommandObjectTargetModulesSourceFileAutoComplete( |
| CommandInterpreter &interpreter, const char *name, const char *help, |
| const char *syntax, uint32_t flags) |
| : CommandObjectParsed(interpreter, name, help, syntax, flags) { |
| CommandArgumentEntry arg; |
| CommandArgumentData source_file_arg; |
| |
| // Define the first (and only) variant of this arg. |
| source_file_arg.arg_type = eArgTypeSourceFile; |
| source_file_arg.arg_repetition = eArgRepeatPlus; |
| |
| // There is only one variant this argument could be; put it into the |
| // argument entry. |
| arg.push_back(source_file_arg); |
| |
| // Push the data for the first argument into the m_arguments vector. |
| m_arguments.push_back(arg); |
| } |
| |
| ~CommandObjectTargetModulesSourceFileAutoComplete() override = default; |
| |
| int HandleArgumentCompletion( |
| CompletionRequest &request, |
| OptionElementVector &opt_element_vector) override { |
| CommandCompletions::InvokeCommonCompletionCallbacks( |
| GetCommandInterpreter(), CommandCompletions::eSourceFileCompletion, |
| request, nullptr); |
| return request.GetNumberOfMatches(); |
| } |
| }; |
| |
| #pragma mark CommandObjectTargetModulesDumpObjfile |
| |
| class CommandObjectTargetModulesDumpObjfile |
| : public CommandObjectTargetModulesModuleAutoComplete { |
| public: |
| CommandObjectTargetModulesDumpObjfile(CommandInterpreter &interpreter) |
| : CommandObjectTargetModulesModuleAutoComplete( |
| interpreter, "target modules dump objfile", |
| "Dump the object file headers from one or more target modules.", |
| nullptr) {} |
| |
| ~CommandObjectTargetModulesDumpObjfile() override = default; |
| |
| protected: |
| bool DoExecute(Args &command, CommandReturnObject &result) override { |
| Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get(); |
| if (target == nullptr) { |
| result.AppendError("invalid target, create a debug target using the " |
| "'target create' command"); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| |
| uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize(); |
| result.GetOutputStream().SetAddressByteSize(addr_byte_size); |
| result.GetErrorStream().SetAddressByteSize(addr_byte_size); |
| |
| size_t num_dumped = 0; |
| if (command.GetArgumentCount() == 0) { |
| // Dump all headers for all modules images |
| num_dumped = DumpModuleObjfileHeaders(result.GetOutputStream(), |
| target->GetImages()); |
| if (num_dumped == 0) { |
| result.AppendError("the target has no associated executable images"); |
| result.SetStatus(eReturnStatusFailed); |
| } |
| } else { |
| // Find the modules that match the basename or full path. |
| ModuleList module_list; |
| const char *arg_cstr; |
| for (int arg_idx = 0; |
| (arg_cstr = command.GetArgumentAtIndex(arg_idx)) != nullptr; |
| ++arg_idx) { |
| size_t num_matched = |
| FindModulesByName(target, arg_cstr, module_list, true); |
| if (num_matched == 0) { |
| result.AppendWarningWithFormat( |
| "Unable to find an image that matches '%s'.\n", arg_cstr); |
| } |
| } |
| // Dump all the modules we found. |
| num_dumped = |
| DumpModuleObjfileHeaders(result.GetOutputStream(), module_list); |
| } |
| |
| if (num_dumped > 0) { |
| result.SetStatus(eReturnStatusSuccessFinishResult); |
| } else { |
| result.AppendError("no matching executable images found"); |
| result.SetStatus(eReturnStatusFailed); |
| } |
| return result.Succeeded(); |
| } |
| }; |
| |
| #pragma mark CommandObjectTargetModulesDumpSymtab |
| |
| static OptionEnumValueElement g_sort_option_enumeration[4] = { |
| {eSortOrderNone, "none", |
| "No sorting, use the original symbol table order."}, |
| {eSortOrderByAddress, "address", "Sort output by symbol address."}, |
| {eSortOrderByName, "name", "Sort output by symbol name."}, |
| {0, nullptr, nullptr}}; |
| |
| static OptionDefinition g_target_modules_dump_symtab_options[] = { |
| // clang-format off |
| { LLDB_OPT_SET_1, false, "sort", 's', OptionParser::eRequiredArgument, nullptr, g_sort_option_enumeration, 0, eArgTypeSortOrder, "Supply a sort order when dumping the symbol table." } |
| // clang-format on |
| }; |
| |
| class CommandObjectTargetModulesDumpSymtab |
| : public CommandObjectTargetModulesModuleAutoComplete { |
| public: |
| CommandObjectTargetModulesDumpSymtab(CommandInterpreter &interpreter) |
| : CommandObjectTargetModulesModuleAutoComplete( |
| interpreter, "target modules dump symtab", |
| "Dump the symbol table from one or more target modules.", nullptr), |
| m_options() {} |
| |
| ~CommandObjectTargetModulesDumpSymtab() override = default; |
| |
| Options *GetOptions() override { return &m_options; } |
| |
| class CommandOptions : public Options { |
| public: |
| CommandOptions() : Options(), m_sort_order(eSortOrderNone) {} |
| |
| ~CommandOptions() override = default; |
| |
| Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, |
| ExecutionContext *execution_context) override { |
| Status error; |
| const int short_option = m_getopt_table[option_idx].val; |
| |
| switch (short_option) { |
| case 's': |
| m_sort_order = (SortOrder)OptionArgParser::ToOptionEnum( |
| option_arg, GetDefinitions()[option_idx].enum_values, |
| eSortOrderNone, error); |
| break; |
| |
| default: |
| error.SetErrorStringWithFormat("invalid short option character '%c'", |
| short_option); |
| break; |
| } |
| return error; |
| } |
| |
| void OptionParsingStarting(ExecutionContext *execution_context) override { |
| m_sort_order = eSortOrderNone; |
| } |
| |
| llvm::ArrayRef<OptionDefinition> GetDefinitions() override { |
| return llvm::makeArrayRef(g_target_modules_dump_symtab_options); |
| } |
| |
| SortOrder m_sort_order; |
| }; |
| |
| protected: |
| bool DoExecute(Args &command, CommandReturnObject &result) override { |
| Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get(); |
| if (target == nullptr) { |
| result.AppendError("invalid target, create a debug target using the " |
| "'target create' command"); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } else { |
| uint32_t num_dumped = 0; |
| |
| uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize(); |
| result.GetOutputStream().SetAddressByteSize(addr_byte_size); |
| result.GetErrorStream().SetAddressByteSize(addr_byte_size); |
| |
| if (command.GetArgumentCount() == 0) { |
| // Dump all sections for all modules images |
| std::lock_guard<std::recursive_mutex> guard( |
| target->GetImages().GetMutex()); |
| const size_t num_modules = target->GetImages().GetSize(); |
| if (num_modules > 0) { |
| result.GetOutputStream().Printf("Dumping symbol table for %" PRIu64 |
| " modules.\n", |
| (uint64_t)num_modules); |
| for (size_t image_idx = 0; image_idx < num_modules; ++image_idx) { |
| if (num_dumped > 0) { |
| result.GetOutputStream().EOL(); |
| result.GetOutputStream().EOL(); |
| } |
| if (m_interpreter.WasInterrupted()) |
| break; |
| num_dumped++; |
| DumpModuleSymtab( |
| m_interpreter, result.GetOutputStream(), |
| target->GetImages().GetModulePointerAtIndexUnlocked(image_idx), |
| m_options.m_sort_order); |
| } |
| } else { |
| result.AppendError("the target has no associated executable images"); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| } else { |
| // Dump specified images (by basename or fullpath) |
| const char *arg_cstr; |
| for (int arg_idx = 0; |
| (arg_cstr = command.GetArgumentAtIndex(arg_idx)) != nullptr; |
| ++arg_idx) { |
| ModuleList module_list; |
| const size_t num_matches = |
| FindModulesByName(target, arg_cstr, module_list, true); |
| if (num_matches > 0) { |
| for (size_t i = 0; i < num_matches; ++i) { |
| Module *module = module_list.GetModulePointerAtIndex(i); |
| if (module) { |
| if (num_dumped > 0) { |
| result.GetOutputStream().EOL(); |
| result.GetOutputStream().EOL(); |
| } |
| if (m_interpreter.WasInterrupted()) |
| break; |
| num_dumped++; |
| DumpModuleSymtab(m_interpreter, result.GetOutputStream(), |
| module, m_options.m_sort_order); |
| } |
| } |
| } else |
| result.AppendWarningWithFormat( |
| "Unable to find an image that matches '%s'.\n", arg_cstr); |
| } |
| } |
| |
| if (num_dumped > 0) |
| result.SetStatus(eReturnStatusSuccessFinishResult); |
| else { |
| result.AppendError("no matching executable images found"); |
| result.SetStatus(eReturnStatusFailed); |
| } |
| } |
| return result.Succeeded(); |
| } |
| |
| CommandOptions m_options; |
| }; |
| |
| #pragma mark CommandObjectTargetModulesDumpSections |
| |
| //---------------------------------------------------------------------- |
| // Image section dumping command |
| //---------------------------------------------------------------------- |
| |
| class CommandObjectTargetModulesDumpSections |
| : public CommandObjectTargetModulesModuleAutoComplete { |
| public: |
| CommandObjectTargetModulesDumpSections(CommandInterpreter &interpreter) |
| : CommandObjectTargetModulesModuleAutoComplete( |
| interpreter, "target modules dump sections", |
| "Dump the sections from one or more target modules.", |
| //"target modules dump sections [<file1> ...]") |
| nullptr) {} |
| |
| ~CommandObjectTargetModulesDumpSections() override = default; |
| |
| protected: |
| bool DoExecute(Args &command, CommandReturnObject &result) override { |
| Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get(); |
| if (target == nullptr) { |
| result.AppendError("invalid target, create a debug target using the " |
| "'target create' command"); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } else { |
| uint32_t num_dumped = 0; |
| |
| uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize(); |
| result.GetOutputStream().SetAddressByteSize(addr_byte_size); |
| result.GetErrorStream().SetAddressByteSize(addr_byte_size); |
| |
| if (command.GetArgumentCount() == 0) { |
| // Dump all sections for all modules images |
| const size_t num_modules = target->GetImages().GetSize(); |
| if (num_modules > 0) { |
| result.GetOutputStream().Printf("Dumping sections for %" PRIu64 |
| " modules.\n", |
| (uint64_t)num_modules); |
| for (size_t image_idx = 0; image_idx < num_modules; ++image_idx) { |
| if (m_interpreter.WasInterrupted()) |
| break; |
| num_dumped++; |
| DumpModuleSections( |
| m_interpreter, result.GetOutputStream(), |
| target->GetImages().GetModulePointerAtIndex(image_idx)); |
| } |
| } else { |
| result.AppendError("the target has no associated executable images"); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| } else { |
| // Dump specified images (by basename or fullpath) |
| const char *arg_cstr; |
| for (int arg_idx = 0; |
| (arg_cstr = command.GetArgumentAtIndex(arg_idx)) != nullptr; |
| ++arg_idx) { |
| ModuleList module_list; |
| const size_t num_matches = |
| FindModulesByName(target, arg_cstr, module_list, true); |
| if (num_matches > 0) { |
| for (size_t i = 0; i < num_matches; ++i) { |
| if (m_interpreter.WasInterrupted()) |
| break; |
| Module *module = module_list.GetModulePointerAtIndex(i); |
| if (module) { |
| num_dumped++; |
| DumpModuleSections(m_interpreter, result.GetOutputStream(), |
| module); |
| } |
| } |
| } else { |
| // Check the global list |
| std::lock_guard<std::recursive_mutex> guard( |
| Module::GetAllocationModuleCollectionMutex()); |
| |
| result.AppendWarningWithFormat( |
| "Unable to find an image that matches '%s'.\n", arg_cstr); |
| } |
| } |
| } |
| |
| if (num_dumped > 0) |
| result.SetStatus(eReturnStatusSuccessFinishResult); |
| else { |
| result.AppendError("no matching executable images found"); |
| result.SetStatus(eReturnStatusFailed); |
| } |
| } |
| return result.Succeeded(); |
| } |
| }; |
| |
| #pragma mark CommandObjectTargetModulesDumpSymfile |
| |
| //---------------------------------------------------------------------- |
| // Image debug symbol dumping command |
| //---------------------------------------------------------------------- |
| |
| class CommandObjectTargetModulesDumpSymfile |
| : public CommandObjectTargetModulesModuleAutoComplete { |
| public: |
| CommandObjectTargetModulesDumpSymfile(CommandInterpreter &interpreter) |
| : CommandObjectTargetModulesModuleAutoComplete( |
| interpreter, "target modules dump symfile", |
| "Dump the debug symbol file for one or more target modules.", |
| //"target modules dump symfile [<file1> ...]") |
| nullptr) {} |
| |
| ~CommandObjectTargetModulesDumpSymfile() override = default; |
| |
| protected: |
| bool DoExecute(Args &command, CommandReturnObject &result) override { |
| Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get(); |
| if (target == nullptr) { |
| result.AppendError("invalid target, create a debug target using the " |
| "'target create' command"); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } else { |
| uint32_t num_dumped = 0; |
| |
| uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize(); |
| result.GetOutputStream().SetAddressByteSize(addr_byte_size); |
| result.GetErrorStream().SetAddressByteSize(addr_byte_size); |
| |
| if (command.GetArgumentCount() == 0) { |
| // Dump all sections for all modules images |
| const ModuleList &target_modules = target->GetImages(); |
| std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex()); |
| const size_t num_modules = target_modules.GetSize(); |
| if (num_modules > 0) { |
| result.GetOutputStream().Printf("Dumping debug symbols for %" PRIu64 |
| " modules.\n", |
| (uint64_t)num_modules); |
| for (uint32_t image_idx = 0; image_idx < num_modules; ++image_idx) { |
| if (m_interpreter.WasInterrupted()) |
| break; |
| if (DumpModuleSymbolVendor( |
| result.GetOutputStream(), |
| target_modules.GetModulePointerAtIndexUnlocked(image_idx))) |
| num_dumped++; |
| } |
| } else { |
| result.AppendError("the target has no associated executable images"); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| } else { |
| // Dump specified images (by basename or fullpath) |
| const char *arg_cstr; |
| for (int arg_idx = 0; |
| (arg_cstr = command.GetArgumentAtIndex(arg_idx)) != nullptr; |
| ++arg_idx) { |
| ModuleList module_list; |
| const size_t num_matches = |
| FindModulesByName(target, arg_cstr, module_list, true); |
| if (num_matches > 0) { |
| for (size_t i = 0; i < num_matches; ++i) { |
| if (m_interpreter.WasInterrupted()) |
| break; |
| Module *module = module_list.GetModulePointerAtIndex(i); |
| if (module) { |
| if (DumpModuleSymbolVendor(result.GetOutputStream(), module)) |
| num_dumped++; |
| } |
| } |
| } else |
| result.AppendWarningWithFormat( |
| "Unable to find an image that matches '%s'.\n", arg_cstr); |
| } |
| } |
| |
| if (num_dumped > 0) |
| result.SetStatus(eReturnStatusSuccessFinishResult); |
| else { |
| result.AppendError("no matching executable images found"); |
| result.SetStatus(eReturnStatusFailed); |
| } |
| } |
| return result.Succeeded(); |
| } |
| }; |
| |
| #pragma mark CommandObjectTargetModulesDumpLineTable |
| |
| //---------------------------------------------------------------------- |
| // Image debug line table dumping command |
| //---------------------------------------------------------------------- |
| |
| class CommandObjectTargetModulesDumpLineTable |
| : public CommandObjectTargetModulesSourceFileAutoComplete { |
| public: |
| CommandObjectTargetModulesDumpLineTable(CommandInterpreter &interpreter) |
| : CommandObjectTargetModulesSourceFileAutoComplete( |
| interpreter, "target modules dump line-table", |
| "Dump the line table for one or more compilation units.", nullptr, |
| eCommandRequiresTarget) {} |
| |
| ~CommandObjectTargetModulesDumpLineTable() override = default; |
| |
| protected: |
| bool DoExecute(Args &command, CommandReturnObject &result) override { |
| Target *target = m_exe_ctx.GetTargetPtr(); |
| uint32_t total_num_dumped = 0; |
| |
| uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize(); |
| result.GetOutputStream().SetAddressByteSize(addr_byte_size); |
| result.GetErrorStream().SetAddressByteSize(addr_byte_size); |
| |
| if (command.GetArgumentCount() == 0) { |
| result.AppendError("file option must be specified."); |
| result.SetStatus(eReturnStatusFailed); |
| return result.Succeeded(); |
| } else { |
| // Dump specified images (by basename or fullpath) |
| const char *arg_cstr; |
| for (int arg_idx = 0; |
| (arg_cstr = command.GetArgumentAtIndex(arg_idx)) != nullptr; |
| ++arg_idx) { |
| FileSpec file_spec(arg_cstr, false); |
| |
| const ModuleList &target_modules = target->GetImages(); |
| std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex()); |
| const size_t num_modules = target_modules.GetSize(); |
| if (num_modules > 0) { |
| uint32_t num_dumped = 0; |
| for (uint32_t i = 0; i < num_modules; ++i) { |
| if (m_interpreter.WasInterrupted()) |
| break; |
| if (DumpCompileUnitLineTable( |
| m_interpreter, result.GetOutputStream(), |
| target_modules.GetModulePointerAtIndexUnlocked(i), |
| file_spec, m_exe_ctx.GetProcessPtr() && |
| m_exe_ctx.GetProcessRef().IsAlive())) |
| num_dumped++; |
| } |
| if (num_dumped == 0) |
| result.AppendWarningWithFormat( |
| "No source filenames matched '%s'.\n", arg_cstr); |
| else |
| total_num_dumped += num_dumped; |
| } |
| } |
| } |
| |
| if (total_num_dumped > 0) |
| result.SetStatus(eReturnStatusSuccessFinishResult); |
| else { |
| result.AppendError("no source filenames matched any command arguments"); |
| result.SetStatus(eReturnStatusFailed); |
| } |
| return result.Succeeded(); |
| } |
| }; |
| |
| #pragma mark CommandObjectTargetModulesDump |
| |
| //---------------------------------------------------------------------- |
| // Dump multi-word command for target modules |
| //---------------------------------------------------------------------- |
| |
| class CommandObjectTargetModulesDump : public CommandObjectMultiword { |
| public: |
| //------------------------------------------------------------------ |
| // Constructors and Destructors |
| //------------------------------------------------------------------ |
| CommandObjectTargetModulesDump(CommandInterpreter &interpreter) |
| : CommandObjectMultiword(interpreter, "target modules dump", |
| "Commands for dumping information about one or " |
| "more target modules.", |
| "target modules dump " |
| "[headers|symtab|sections|symfile|line-table] " |
| "[<file1> <file2> ...]") { |
| LoadSubCommand("objfile", |
| CommandObjectSP( |
| new CommandObjectTargetModulesDumpObjfile(interpreter))); |
| LoadSubCommand( |
| "symtab", |
| CommandObjectSP(new CommandObjectTargetModulesDumpSymtab(interpreter))); |
| LoadSubCommand("sections", |
| CommandObjectSP(new CommandObjectTargetModulesDumpSections( |
| interpreter))); |
| LoadSubCommand("symfile", |
| CommandObjectSP( |
| new CommandObjectTargetModulesDumpSymfile(interpreter))); |
| LoadSubCommand("line-table", |
| CommandObjectSP(new CommandObjectTargetModulesDumpLineTable( |
| interpreter))); |
| } |
| |
| ~CommandObjectTargetModulesDump() override = default; |
| }; |
| |
| class CommandObjectTargetModulesAdd : public CommandObjectParsed { |
| public: |
| CommandObjectTargetModulesAdd(CommandInterpreter &interpreter) |
| : CommandObjectParsed(interpreter, "target modules add", |
| "Add a new module to the current target's modules.", |
| "target modules add [<module>]"), |
| m_option_group(), |
| m_symbol_file(LLDB_OPT_SET_1, false, "symfile", 's', 0, |
| eArgTypeFilename, "Fullpath to a stand alone debug " |
| "symbols file for when debug symbols " |
| "are not in the executable.") { |
| m_option_group.Append(&m_uuid_option_group, LLDB_OPT_SET_ALL, |
| LLDB_OPT_SET_1); |
| m_option_group.Append(&m_symbol_file, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); |
| m_option_group.Finalize(); |
| } |
| |
| ~CommandObjectTargetModulesAdd() override = default; |
| |
| Options *GetOptions() override { return &m_option_group; } |
| |
| int HandleArgumentCompletion( |
| CompletionRequest &request, |
| OptionElementVector &opt_element_vector) override { |
| CommandCompletions::InvokeCommonCompletionCallbacks( |
| GetCommandInterpreter(), CommandCompletions::eDiskFileCompletion, |
| request, nullptr); |
| return request.GetNumberOfMatches(); |
| } |
| |
| protected: |
| OptionGroupOptions m_option_group; |
| OptionGroupUUID m_uuid_option_group; |
| OptionGroupFile m_symbol_file; |
| |
| bool DoExecute(Args &args, CommandReturnObject &result) override { |
| Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get(); |
| if (target == nullptr) { |
| result.AppendError("invalid target, create a debug target using the " |
| "'target create' command"); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } else { |
| bool flush = false; |
| |
| const size_t argc = args.GetArgumentCount(); |
| if (argc == 0) { |
| if (m_uuid_option_group.GetOptionValue().OptionWasSet()) { |
| // We are given a UUID only, go locate the file |
| ModuleSpec module_spec; |
| module_spec.GetUUID() = |
| m_uuid_option_group.GetOptionValue().GetCurrentValue(); |
| if (m_symbol_file.GetOptionValue().OptionWasSet()) |
| module_spec.GetSymbolFileSpec() = |
| m_symbol_file.GetOptionValue().GetCurrentValue(); |
| if (Symbols::DownloadObjectAndSymbolFile(module_spec)) { |
| ModuleSP module_sp(target->GetSharedModule(module_spec)); |
| if (module_sp) { |
| result.SetStatus(eReturnStatusSuccessFinishResult); |
| return true; |
| } else { |
| StreamString strm; |
| module_spec.GetUUID().Dump(&strm); |
| if (module_spec.GetFileSpec()) { |
| if (module_spec.GetSymbolFileSpec()) { |
| result.AppendErrorWithFormat( |
| "Unable to create the executable or symbol file with " |
| "UUID %s with path %s and symbol file %s", |
| strm.GetData(), |
| module_spec.GetFileSpec().GetPath().c_str(), |
| module_spec.GetSymbolFileSpec().GetPath().c_str()); |
| } else { |
| result.AppendErrorWithFormat( |
| "Unable to create the executable or symbol file with " |
| "UUID %s with path %s", |
| strm.GetData(), |
| module_spec.GetFileSpec().GetPath().c_str()); |
| } |
| } else { |
| result.AppendErrorWithFormat("Unable to create the executable " |
| "or symbol file with UUID %s", |
| strm.GetData()); |
| } |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| } else { |
| StreamString strm; |
| module_spec.GetUUID().Dump(&strm); |
| result.AppendErrorWithFormat( |
| "Unable to locate the executable or symbol file with UUID %s", |
| strm.GetData()); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| } else { |
| result.AppendError( |
| "one or more executable image paths must be specified"); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| } else { |
| for (auto &entry : args.entries()) { |
| if (entry.ref.empty()) |
| continue; |
| |
| FileSpec file_spec(entry.ref, true); |
| if (file_spec.Exists()) { |
| ModuleSpec module_spec(file_spec); |
| if (m_uuid_option_group.GetOptionValue().OptionWasSet()) |
| module_spec.GetUUID() = |
| m_uuid_option_group.GetOptionValue().GetCurrentValue(); |
| if (m_symbol_file.GetOptionValue().OptionWasSet()) |
| module_spec.GetSymbolFileSpec() = |
| m_symbol_file.GetOptionValue().GetCurrentValue(); |
| if (!module_spec.GetArchitecture().IsValid()) |
| module_spec.GetArchitecture() = target->GetArchitecture(); |
| Status error; |
| ModuleSP module_sp(target->GetSharedModule(module_spec, &error)); |
| if (!module_sp) { |
| const char *error_cstr = error.AsCString(); |
| if (error_cstr) |
| result.AppendError(error_cstr); |
| else |
| result.AppendErrorWithFormat("unsupported module: %s", |
| entry.c_str()); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } else { |
| flush = true; |
| } |
| result.SetStatus(eReturnStatusSuccessFinishResult); |
| } else { |
| std::string resolved_path = file_spec.GetPath(); |
| result.SetStatus(eReturnStatusFailed); |
| if (resolved_path != entry.ref) { |
| result.AppendErrorWithFormat( |
| "invalid module path '%s' with resolved path '%s'\n", |
| entry.ref.str().c_str(), resolved_path.c_str()); |
| break; |
| } |
| result.AppendErrorWithFormat("invalid module path '%s'\n", |
| entry.c_str()); |
| break; |
| } |
| } |
| } |
| |
| if (flush) { |
| ProcessSP process = target->GetProcessSP(); |
| if (process) |
| process->Flush(); |
| } |
| } |
| |
| return result.Succeeded(); |
| } |
| }; |
| |
| class CommandObjectTargetModulesLoad |
| : public CommandObjectTargetModulesModuleAutoComplete { |
| public: |
| CommandObjectTargetModulesLoad(CommandInterpreter &interpreter) |
| : CommandObjectTargetModulesModuleAutoComplete( |
| interpreter, "target modules load", "Set the load addresses for " |
| "one or more sections in a " |
| "target module.", |
| "target modules load [--file <module> --uuid <uuid>] <sect-name> " |
| "<address> [<sect-name> <address> ....]"), |
| m_option_group(), |
| m_file_option(LLDB_OPT_SET_1, false, "file", 'f', 0, eArgTypeName, |
| "Fullpath or basename for module to load.", ""), |
| m_load_option(LLDB_OPT_SET_1, false, "load", 'l', |
| "Write file contents to the memory.", false, true), |
| m_pc_option(LLDB_OPT_SET_1, false, "set-pc-to-entry", 'p', |
| "Set PC to the entry point." |
| " Only applicable with '--load' option.", |
| false, true), |
| m_slide_option(LLDB_OPT_SET_1, false, "slide", 's', 0, eArgTypeOffset, |
| "Set the load address for all sections to be the " |
| "virtual address in the file plus the offset.", |
| 0) { |
| m_option_group.Append(&m_uuid_option_group, LLDB_OPT_SET_ALL, |
| LLDB_OPT_SET_1); |
| m_option_group.Append(&m_file_option, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); |
| m_option_group.Append(&m_load_option, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); |
| m_option_group.Append(&m_pc_option, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); |
| m_option_group.Append(&m_slide_option, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); |
| m_option_group.Finalize(); |
| } |
| |
| ~CommandObjectTargetModulesLoad() override = default; |
| |
| Options *GetOptions() override { return &m_option_group; } |
| |
| protected: |
| bool DoExecute(Args &args, CommandReturnObject &result) override { |
| Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get(); |
| const bool load = m_load_option.GetOptionValue().GetCurrentValue(); |
| const bool set_pc = m_pc_option.GetOptionValue().GetCurrentValue(); |
| if (target == nullptr) { |
| result.AppendError("invalid target, create a debug target using the " |
| "'target create' command"); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } else { |
| const size_t argc = args.GetArgumentCount(); |
| ModuleSpec module_spec; |
| bool search_using_module_spec = false; |
| |
| // Allow "load" option to work without --file or --uuid option. |
| if (load) { |
| if (!m_file_option.GetOptionValue().OptionWasSet() && |
| !m_uuid_option_group.GetOptionValue().OptionWasSet()) { |
| ModuleList &module_list = target->GetImages(); |
| if (module_list.GetSize() == 1) { |
| search_using_module_spec = true; |
| module_spec.GetFileSpec() = |
| module_list.GetModuleAtIndex(0)->GetFileSpec(); |
| } |
| } |
| } |
| |
| if (m_file_option.GetOptionValue().OptionWasSet()) { |
| search_using_module_spec = true; |
| const char *arg_cstr = m_file_option.GetOptionValue().GetCurrentValue(); |
| const bool use_global_module_list = true; |
| ModuleList module_list; |
| const size_t num_matches = FindModulesByName( |
| target, arg_cstr, module_list, use_global_module_list); |
| if (num_matches == 1) { |
| module_spec.GetFileSpec() = |
| module_list.GetModuleAtIndex(0)->GetFileSpec(); |
| } else if (num_matches > 1) { |
| search_using_module_spec = false; |
| result.AppendErrorWithFormat( |
| "more than 1 module matched by name '%s'\n", arg_cstr); |
| result.SetStatus(eReturnStatusFailed); |
| } else { |
| search_using_module_spec = false; |
| result.AppendErrorWithFormat("no object file for module '%s'\n", |
| arg_cstr); |
| result.SetStatus(eReturnStatusFailed); |
| } |
| } |
| |
| if (m_uuid_option_group.GetOptionValue().OptionWasSet()) { |
| search_using_module_spec = true; |
| module_spec.GetUUID() = |
| m_uuid_option_group.GetOptionValue().GetCurrentValue(); |
| } |
| |
| if (search_using_module_spec) { |
| ModuleList matching_modules; |
| const size_t num_matches = |
| target->GetImages().FindModules(module_spec, matching_modules); |
| |
| char path[PATH_MAX]; |
| if (num_matches == 1) { |
| Module *module = matching_modules.GetModulePointerAtIndex(0); |
| if (module) { |
| ObjectFile *objfile = module->GetObjectFile(); |
| if (objfile) { |
| SectionList *section_list = module->GetSectionList(); |
| if (section_list) { |
| bool changed = false; |
| if (argc == 0) { |
| if (m_slide_option.GetOptionValue().OptionWasSet()) { |
| const addr_t slide = |
| m_slide_option.GetOptionValue().GetCurrentValue(); |
| const bool slide_is_offset = true; |
| module->SetLoadAddress(*target, slide, slide_is_offset, |
| changed); |
| } else { |
| result.AppendError("one or more section name + load " |
| "address pair must be specified"); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| } else { |
| if (m_slide_option.GetOptionValue().OptionWasSet()) { |
| result.AppendError("The \"--slide <offset>\" option can't " |
| "be used in conjunction with setting " |
| "section load addresses.\n"); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| |
| for (size_t i = 0; i < argc; i += 2) { |
| const char *sect_name = args.GetArgumentAtIndex(i); |
| const char *load_addr_cstr = args.GetArgumentAtIndex(i + 1); |
| if (sect_name && load_addr_cstr) { |
| ConstString const_sect_name(sect_name); |
| bool success = false; |
| addr_t load_addr = StringConvert::ToUInt64( |
| load_addr_cstr, LLDB_INVALID_ADDRESS, 0, &success); |
| if (success) { |
| SectionSP section_sp( |
| section_list->FindSectionByName(const_sect_name)); |
| if (section_sp) { |
| if (section_sp->IsThreadSpecific()) { |
| result.AppendErrorWithFormat( |
| "thread specific sections are not yet " |
| "supported (section '%s')\n", |
| sect_name); |
| result.SetStatus(eReturnStatusFailed); |
| break; |
| } else { |
| if (target->GetSectionLoadList() |
| .SetSectionLoadAddress(section_sp, |
| load_addr)) |
| changed = true; |
| result.AppendMessageWithFormat( |
| "section '%s' loaded at 0x%" PRIx64 "\n", |
| sect_name, load_addr); |
| } |
| } else { |
| result.AppendErrorWithFormat("no section found that " |
| "matches the section " |
| "name '%s'\n", |
| sect_name); |
| result.SetStatus(eReturnStatusFailed); |
| break; |
| } |
| } else { |
| result.AppendErrorWithFormat( |
| "invalid load address string '%s'\n", |
| load_addr_cstr); |
| result.SetStatus(eReturnStatusFailed); |
| break; |
| } |
| } else { |
| if (sect_name) |
| result.AppendError("section names must be followed by " |
| "a load address.\n"); |
| else |
| result.AppendError("one or more section name + load " |
| "address pair must be specified.\n"); |
| result.SetStatus(eReturnStatusFailed); |
| break; |
| } |
| } |
| } |
| |
| if (changed) { |
| target->ModulesDidLoad(matching_modules); |
| Process *process = m_exe_ctx.GetProcessPtr(); |
| if (process) |
| process->Flush(); |
| } |
| if (load) { |
| ProcessSP process = target->CalculateProcess(); |
| Address file_entry = objfile->GetEntryPointAddress(); |
| if (!process) { |
| result.AppendError("No process"); |
| return false; |
| } |
| if (set_pc && !file_entry.IsValid()) { |
| result.AppendError("No entry address in object file"); |
| return false; |
| } |
| std::vector<ObjectFile::LoadableData> loadables( |
| objfile->GetLoadableData(*target)); |
| if (loadables.size() == 0) { |
| result.AppendError("No loadable sections"); |
| return false; |
| } |
| Status error = process->WriteObjectFile(std::move(loadables)); |
| if (error.Fail()) { |
| result.AppendError(error.AsCString()); |
| return false; |
| } |
| if (set_pc) { |
| ThreadList &thread_list = process->GetThreadList(); |
| ThreadSP curr_thread(thread_list.GetSelectedThread()); |
| RegisterContextSP reg_context( |
| curr_thread->GetRegisterContext()); |
| reg_context->SetPC(file_entry.GetLoadAddress(target)); |
| } |
| } |
| } else { |
| module->GetFileSpec().GetPath(path, sizeof(path)); |
| result.AppendErrorWithFormat( |
| "no sections in object file '%s'\n", path); |
| result.SetStatus(eReturnStatusFailed); |
| } |
| } else { |
| module->GetFileSpec().GetPath(path, sizeof(path)); |
| result.AppendErrorWithFormat("no object file for module '%s'\n", |
| path); |
| result.SetStatus(eReturnStatusFailed); |
| } |
| } else { |
| FileSpec *module_spec_file = module_spec.GetFileSpecPtr(); |
| if (module_spec_file) { |
| module_spec_file->GetPath(path, sizeof(path)); |
| result.AppendErrorWithFormat("invalid module '%s'.\n", path); |
| } else |
| result.AppendError("no module spec"); |
| result.SetStatus(eReturnStatusFailed); |
| } |
| } else { |
| std::string uuid_str; |
| |
| if (module_spec.GetFileSpec()) |
| module_spec.GetFileSpec().GetPath(path, sizeof(path)); |
| else |
| path[0] = '\0'; |
| |
| if (module_spec.GetUUIDPtr()) |
| uuid_str = module_spec.GetUUID().GetAsString(); |
| if (num_matches > 1) { |
| result.AppendErrorWithFormat( |
| "multiple modules match%s%s%s%s:\n", path[0] ? " file=" : "", |
| path, !uuid_str.empty() ? " uuid=" : "", uuid_str.c_str()); |
| for (size_t i = 0; i < num_matches; ++i) { |
| if (matching_modules.GetModulePointerAtIndex(i) |
| ->GetFileSpec() |
| .GetPath(path, sizeof(path))) |
| result.AppendMessageWithFormat("%s\n", path); |
| } |
| } else { |
| result.AppendErrorWithFormat( |
| "no modules were found that match%s%s%s%s.\n", |
| path[0] ? " file=" : "", path, |
| !uuid_str.empty() ? " uuid=" : "", uuid_str.c_str()); |
| } |
| result.SetStatus(eReturnStatusFailed); |
| } |
| } else { |
| result.AppendError("either the \"--file <module>\" or the \"--uuid " |
| "<uuid>\" option must be specified.\n"); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| } |
| return result.Succeeded(); |
| } |
| |
| OptionGroupOptions m_option_group; |
| OptionGroupUUID m_uuid_option_group; |
| OptionGroupString m_file_option; |
| OptionGroupBoolean m_load_option; |
| OptionGroupBoolean m_pc_option; |
| OptionGroupUInt64 m_slide_option; |
| }; |
| |
| //---------------------------------------------------------------------- |
| // List images with associated information |
| //---------------------------------------------------------------------- |
| |
| static OptionDefinition g_target_modules_list_options[] = { |
| // clang-format off |
| { LLDB_OPT_SET_1, false, "address", 'a', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeAddressOrExpression, "Display the image at this address." }, |
| { LLDB_OPT_SET_1, false, "arch", 'A', OptionParser::eOptionalArgument, nullptr, nullptr, 0, eArgTypeWidth, "Display the architecture when listing images." }, |
| { LLDB_OPT_SET_1, false, "triple", 't', OptionParser::eOptionalArgument, nullptr, nullptr, 0, eArgTypeWidth, "Display the triple when listing images." }, |
| { LLDB_OPT_SET_1, false, "header", 'h', OptionParser::eNoArgument, |