//===-- SBTarget.cpp --------------------------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// #include "lldb/API/SBTarget.h" #include "lldb/lldb-public.h" #include "lldb/API/SBBreakpoint.h" #include "lldb/API/SBDebugger.h" #include "lldb/API/SBEvent.h" #include "lldb/API/SBExpressionOptions.h" #include "lldb/API/SBFileSpec.h" #include "lldb/API/SBListener.h" #include "lldb/API/SBModule.h" #include "lldb/API/SBModuleSpec.h" #include "lldb/API/SBProcess.h" #include "lldb/API/SBSourceManager.h" #include "lldb/API/SBStream.h" #include "lldb/API/SBStringList.h" #include "lldb/API/SBSymbolContextList.h" #include "lldb/Breakpoint/BreakpointID.h" #include "lldb/Breakpoint/BreakpointIDList.h" #include "lldb/Breakpoint/BreakpointList.h" #include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Core/Address.h" #include "lldb/Core/AddressResolver.h" #include "lldb/Core/AddressResolverName.h" #include "lldb/Core/ArchSpec.h" #include "lldb/Core/Debugger.h" #include "lldb/Core/Disassembler.h" #include "lldb/Core/Module.h" #include "lldb/Core/ModuleSpec.h" #include "lldb/Core/STLUtils.h" #include "lldb/Core/SearchFilter.h" #include "lldb/Core/Section.h" #include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectList.h" #include "lldb/Core/ValueObjectVariable.h" #include "lldb/Host/Host.h" #include "lldb/Interpreter/Args.h" #include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/DeclVendor.h" #include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/SymbolFile.h" #include "lldb/Symbol/SymbolVendor.h" #include "lldb/Symbol/VariableList.h" #include "lldb/Target/ABI.h" #include "lldb/Target/Language.h" #include "lldb/Target/LanguageRuntime.h" #include "lldb/Target/ObjCLanguageRuntime.h" #include "lldb/Target/Process.h" #include "lldb/Target/StackFrame.h" #include "lldb/Target/Target.h" #include "lldb/Target/TargetList.h" #include "lldb/Utility/FileSpec.h" #include "lldb/Utility/Log.h" #include "lldb/Utility/RegularExpression.h" #include "../source/Commands/CommandObjectBreakpoint.h" #include "lldb/Interpreter/CommandReturnObject.h" #include "llvm/Support/PrettyStackTrace.h" #include "llvm/Support/Regex.h" using namespace lldb; using namespace lldb_private; #define DEFAULT_DISASM_BYTE_SIZE 32 namespace { Error AttachToProcess(ProcessAttachInfo &attach_info, Target &target) { std::lock_guard guard(target.GetAPIMutex()); auto process_sp = target.GetProcessSP(); if (process_sp) { const auto state = process_sp->GetState(); if (process_sp->IsAlive() && state == eStateConnected) { // If we are already connected, then we have already specified the // listener, so if a valid listener is supplied, we need to error out // to let the client know. if (attach_info.GetListener()) return Error("process is connected and already has a listener, pass " "empty listener"); } } return target.Attach(attach_info, nullptr); } } // namespace //---------------------------------------------------------------------- // SBTarget constructor //---------------------------------------------------------------------- SBTarget::SBTarget() : m_opaque_sp() {} SBTarget::SBTarget(const SBTarget &rhs) : m_opaque_sp(rhs.m_opaque_sp) {} SBTarget::SBTarget(const TargetSP &target_sp) : m_opaque_sp(target_sp) {} const SBTarget &SBTarget::operator=(const SBTarget &rhs) { if (this != &rhs) m_opaque_sp = rhs.m_opaque_sp; return *this; } //---------------------------------------------------------------------- // Destructor //---------------------------------------------------------------------- SBTarget::~SBTarget() {} bool SBTarget::EventIsTargetEvent(const SBEvent &event) { return Target::TargetEventData::GetEventDataFromEvent(event.get()) != NULL; } SBTarget SBTarget::GetTargetFromEvent(const SBEvent &event) { return Target::TargetEventData::GetTargetFromEvent(event.get()); } uint32_t SBTarget::GetNumModulesFromEvent(const SBEvent &event) { const ModuleList module_list = Target::TargetEventData::GetModuleListFromEvent(event.get()); return module_list.GetSize(); } SBModule SBTarget::GetModuleAtIndexFromEvent(const uint32_t idx, const SBEvent &event) { const ModuleList module_list = Target::TargetEventData::GetModuleListFromEvent(event.get()); return SBModule(module_list.GetModuleAtIndex(idx)); } const char *SBTarget::GetBroadcasterClassName() { return Target::GetStaticBroadcasterClass().AsCString(); } bool SBTarget::IsValid() const { return m_opaque_sp.get() != NULL && m_opaque_sp->IsValid(); } SBProcess SBTarget::GetProcess() { SBProcess sb_process; ProcessSP process_sp; TargetSP target_sp(GetSP()); if (target_sp) { process_sp = target_sp->GetProcessSP(); sb_process.SetSP(process_sp); } Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) log->Printf("SBTarget(%p)::GetProcess () => SBProcess(%p)", static_cast(target_sp.get()), static_cast(process_sp.get())); return sb_process; } SBPlatform SBTarget::GetPlatform() { TargetSP target_sp(GetSP()); if (!target_sp) return SBPlatform(); SBPlatform platform; platform.m_opaque_sp = target_sp->GetPlatform(); return platform; } SBDebugger SBTarget::GetDebugger() const { SBDebugger debugger; TargetSP target_sp(GetSP()); if (target_sp) debugger.reset(target_sp->GetDebugger().shared_from_this()); return debugger; } SBProcess SBTarget::LoadCore(const char *core_file) { SBProcess sb_process; TargetSP target_sp(GetSP()); if (target_sp) { FileSpec filespec(core_file, true); ProcessSP process_sp(target_sp->CreateProcess( target_sp->GetDebugger().GetListener(), "", &filespec)); if (process_sp) { process_sp->LoadCore(); sb_process.SetSP(process_sp); } } return sb_process; } SBProcess SBTarget::LaunchSimple(char const **argv, char const **envp, const char *working_directory) { char *stdin_path = NULL; char *stdout_path = NULL; char *stderr_path = NULL; uint32_t launch_flags = 0; bool stop_at_entry = false; SBError error; SBListener listener = GetDebugger().GetListener(); return Launch(listener, argv, envp, stdin_path, stdout_path, stderr_path, working_directory, launch_flags, stop_at_entry, error); } SBError SBTarget::Install() { SBError sb_error; TargetSP target_sp(GetSP()); if (target_sp) { std::lock_guard guard(target_sp->GetAPIMutex()); sb_error.ref() = target_sp->Install(NULL); } return sb_error; } SBProcess SBTarget::Launch(SBListener &listener, char const **argv, char const **envp, const char *stdin_path, const char *stdout_path, const char *stderr_path, const char *working_directory, uint32_t launch_flags, // See LaunchFlags bool stop_at_entry, lldb::SBError &error) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBProcess sb_process; ProcessSP process_sp; TargetSP target_sp(GetSP()); if (log) log->Printf("SBTarget(%p)::Launch (argv=%p, envp=%p, stdin=%s, stdout=%s, " "stderr=%s, working-dir=%s, launch_flags=0x%x, " "stop_at_entry=%i, &error (%p))...", static_cast(target_sp.get()), static_cast(argv), static_cast(envp), stdin_path ? stdin_path : "NULL", stdout_path ? stdout_path : "NULL", stderr_path ? stderr_path : "NULL", working_directory ? working_directory : "NULL", launch_flags, stop_at_entry, static_cast(error.get())); if (target_sp) { std::lock_guard guard(target_sp->GetAPIMutex()); if (stop_at_entry) launch_flags |= eLaunchFlagStopAtEntry; if (getenv("LLDB_LAUNCH_FLAG_DISABLE_ASLR")) launch_flags |= eLaunchFlagDisableASLR; StateType state = eStateInvalid; process_sp = target_sp->GetProcessSP(); if (process_sp) { state = process_sp->GetState(); if (process_sp->IsAlive() && state != eStateConnected) { if (state == eStateAttaching) error.SetErrorString("process attach is in progress"); else error.SetErrorString("a process is already being debugged"); return sb_process; } } if (state == eStateConnected) { // If we are already connected, then we have already specified the // listener, so if a valid listener is supplied, we need to error out // to let the client know. if (listener.IsValid()) { error.SetErrorString("process is connected and already has a listener, " "pass empty listener"); return sb_process; } } if (getenv("LLDB_LAUNCH_FLAG_DISABLE_STDIO")) launch_flags |= eLaunchFlagDisableSTDIO; ProcessLaunchInfo launch_info( FileSpec{stdin_path, false}, FileSpec{stdout_path, false}, FileSpec{stderr_path, false}, FileSpec{working_directory, false}, launch_flags); Module *exe_module = target_sp->GetExecutableModulePointer(); if (exe_module) launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), true); if (argv) launch_info.GetArguments().AppendArguments(argv); if (envp) launch_info.GetEnvironmentEntries().SetArguments(envp); if (listener.IsValid()) launch_info.SetListener(listener.GetSP()); error.SetError(target_sp->Launch(launch_info, NULL)); sb_process.SetSP(target_sp->GetProcessSP()); } else { error.SetErrorString("SBTarget is invalid"); } log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API); if (log) log->Printf("SBTarget(%p)::Launch (...) => SBProcess(%p), SBError(%s)", static_cast(target_sp.get()), static_cast(sb_process.GetSP().get()), error.GetCString()); return sb_process; } SBProcess SBTarget::Launch(SBLaunchInfo &sb_launch_info, SBError &error) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBProcess sb_process; TargetSP target_sp(GetSP()); if (log) log->Printf("SBTarget(%p)::Launch (launch_info, error)...", static_cast(target_sp.get())); if (target_sp) { std::lock_guard guard(target_sp->GetAPIMutex()); StateType state = eStateInvalid; { ProcessSP process_sp = target_sp->GetProcessSP(); if (process_sp) { state = process_sp->GetState(); if (process_sp->IsAlive() && state != eStateConnected) { if (state == eStateAttaching) error.SetErrorString("process attach is in progress"); else error.SetErrorString("a process is already being debugged"); return sb_process; } } } lldb_private::ProcessLaunchInfo &launch_info = sb_launch_info.ref(); if (!launch_info.GetExecutableFile()) { Module *exe_module = target_sp->GetExecutableModulePointer(); if (exe_module) launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), true); } const ArchSpec &arch_spec = target_sp->GetArchitecture(); if (arch_spec.IsValid()) launch_info.GetArchitecture() = arch_spec; error.SetError(target_sp->Launch(launch_info, NULL)); sb_process.SetSP(target_sp->GetProcessSP()); } else { error.SetErrorString("SBTarget is invalid"); } log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API); if (log) log->Printf("SBTarget(%p)::Launch (...) => SBProcess(%p)", static_cast(target_sp.get()), static_cast(sb_process.GetSP().get())); return sb_process; } lldb::SBProcess SBTarget::Attach(SBAttachInfo &sb_attach_info, SBError &error) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBProcess sb_process; TargetSP target_sp(GetSP()); if (log) log->Printf("SBTarget(%p)::Attach (sb_attach_info, error)...", static_cast(target_sp.get())); if (target_sp) { ProcessAttachInfo &attach_info = sb_attach_info.ref(); if (attach_info.ProcessIDIsValid() && !attach_info.UserIDIsValid()) { PlatformSP platform_sp = target_sp->GetPlatform(); // See if we can pre-verify if a process exists or not if (platform_sp && platform_sp->IsConnected()) { lldb::pid_t attach_pid = attach_info.GetProcessID(); ProcessInstanceInfo instance_info; if (platform_sp->GetProcessInfo(attach_pid, instance_info)) { attach_info.SetUserID(instance_info.GetEffectiveUserID()); } else { error.ref().SetErrorStringWithFormat( "no process found with process ID %" PRIu64, attach_pid); if (log) { log->Printf("SBTarget(%p)::Attach (...) => error %s", static_cast(target_sp.get()), error.GetCString()); } return sb_process; } } } error.SetError(AttachToProcess(attach_info, *target_sp)); if (error.Success()) sb_process.SetSP(target_sp->GetProcessSP()); } else { error.SetErrorString("SBTarget is invalid"); } if (log) log->Printf("SBTarget(%p)::Attach (...) => SBProcess(%p)", static_cast(target_sp.get()), static_cast(sb_process.GetSP().get())); return sb_process; } #if defined(__APPLE__) lldb::SBProcess SBTarget::AttachToProcessWithID(SBListener &listener, ::pid_t pid, lldb::SBError &error) { return AttachToProcessWithID(listener, (lldb::pid_t)pid, error); } #endif // #if defined(__APPLE__) lldb::SBProcess SBTarget::AttachToProcessWithID( SBListener &listener, lldb::pid_t pid, // The process ID to attach to SBError &error // An error explaining what went wrong if attach fails ) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBProcess sb_process; TargetSP target_sp(GetSP()); if (log) log->Printf("SBTarget(%p)::%s (listener, pid=%" PRId64 ", error)...", static_cast(target_sp.get()), __FUNCTION__, pid); if (target_sp) { ProcessAttachInfo attach_info; attach_info.SetProcessID(pid); if (listener.IsValid()) attach_info.SetListener(listener.GetSP()); ProcessInstanceInfo instance_info; if (target_sp->GetPlatform()->GetProcessInfo(pid, instance_info)) attach_info.SetUserID(instance_info.GetEffectiveUserID()); error.SetError(AttachToProcess(attach_info, *target_sp)); if (error.Success()) sb_process.SetSP(target_sp->GetProcessSP()); } else error.SetErrorString("SBTarget is invalid"); if (log) log->Printf("SBTarget(%p)::%s (...) => SBProcess(%p)", static_cast(target_sp.get()), __FUNCTION__, static_cast(sb_process.GetSP().get())); return sb_process; } lldb::SBProcess SBTarget::AttachToProcessWithName( SBListener &listener, const char *name, // basename of process to attach to bool wait_for, // if true wait for a new instance of "name" to be launched SBError &error // An error explaining what went wrong if attach fails ) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBProcess sb_process; TargetSP target_sp(GetSP()); if (log) log->Printf("SBTarget(%p)::%s (listener, name=%s, wait_for=%s, error)...", static_cast(target_sp.get()), __FUNCTION__, name, wait_for ? "true" : "false"); if (name && target_sp) { ProcessAttachInfo attach_info; attach_info.GetExecutableFile().SetFile(name, false); attach_info.SetWaitForLaunch(wait_for); if (listener.IsValid()) attach_info.SetListener(listener.GetSP()); error.SetError(AttachToProcess(attach_info, *target_sp)); if (error.Success()) sb_process.SetSP(target_sp->GetProcessSP()); } else error.SetErrorString("SBTarget is invalid"); if (log) log->Printf("SBTarget(%p)::%s (...) => SBProcess(%p)", static_cast(target_sp.get()), __FUNCTION__, static_cast(sb_process.GetSP().get())); return sb_process; } lldb::SBProcess SBTarget::ConnectRemote(SBListener &listener, const char *url, const char *plugin_name, SBError &error) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBProcess sb_process; ProcessSP process_sp; TargetSP target_sp(GetSP()); if (log) log->Printf("SBTarget(%p)::ConnectRemote (listener, url=%s, " "plugin_name=%s, error)...", static_cast(target_sp.get()), url, plugin_name); if (target_sp) { std::lock_guard guard(target_sp->GetAPIMutex()); if (listener.IsValid()) process_sp = target_sp->CreateProcess(listener.m_opaque_sp, plugin_name, NULL); else process_sp = target_sp->CreateProcess( target_sp->GetDebugger().GetListener(), plugin_name, NULL); if (process_sp) { sb_process.SetSP(process_sp); error.SetError(process_sp->ConnectRemote(NULL, url)); } else { error.SetErrorString("unable to create lldb_private::Process"); } } else { error.SetErrorString("SBTarget is invalid"); } if (log) log->Printf("SBTarget(%p)::ConnectRemote (...) => SBProcess(%p)", static_cast(target_sp.get()), static_cast(process_sp.get())); return sb_process; } SBFileSpec SBTarget::GetExecutable() { SBFileSpec exe_file_spec; TargetSP target_sp(GetSP()); if (target_sp) { Module *exe_module = target_sp->GetExecutableModulePointer(); if (exe_module) exe_file_spec.SetFileSpec(exe_module->GetFileSpec()); } Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) { log->Printf("SBTarget(%p)::GetExecutable () => SBFileSpec(%p)", static_cast(target_sp.get()), static_cast(exe_file_spec.get())); } return exe_file_spec; } bool SBTarget::operator==(const SBTarget &rhs) const { return m_opaque_sp.get() == rhs.m_opaque_sp.get(); } bool SBTarget::operator!=(const SBTarget &rhs) const { return m_opaque_sp.get() != rhs.m_opaque_sp.get(); } lldb::TargetSP SBTarget::GetSP() const { return m_opaque_sp; } void SBTarget::SetSP(const lldb::TargetSP &target_sp) { m_opaque_sp = target_sp; } lldb::SBAddress SBTarget::ResolveLoadAddress(lldb::addr_t vm_addr) { lldb::SBAddress sb_addr; Address &addr = sb_addr.ref(); TargetSP target_sp(GetSP()); if (target_sp) { std::lock_guard guard(target_sp->GetAPIMutex()); if (target_sp->ResolveLoadAddress(vm_addr, addr)) return sb_addr; } // We have a load address that isn't in a section, just return an address // with the offset filled in (the address) and the section set to NULL addr.SetRawAddress(vm_addr); return sb_addr; } lldb::SBAddress SBTarget::ResolveFileAddress(lldb::addr_t file_addr) { lldb::SBAddress sb_addr; Address &addr = sb_addr.ref(); TargetSP target_sp(GetSP()); if (target_sp) { std::lock_guard guard(target_sp->GetAPIMutex()); if (target_sp->ResolveFileAddress(file_addr, addr)) return sb_addr; } addr.SetRawAddress(file_addr); return sb_addr; } lldb::SBAddress SBTarget::ResolvePastLoadAddress(uint32_t stop_id, lldb::addr_t vm_addr) { lldb::SBAddress sb_addr; Address &addr = sb_addr.ref(); TargetSP target_sp(GetSP()); if (target_sp) { std::lock_guard guard(target_sp->GetAPIMutex()); if (target_sp->ResolveLoadAddress(vm_addr, addr)) return sb_addr; } // We have a load address that isn't in a section, just return an address // with the offset filled in (the address) and the section set to NULL addr.SetRawAddress(vm_addr); return sb_addr; } SBSymbolContext SBTarget::ResolveSymbolContextForAddress(const SBAddress &addr, uint32_t resolve_scope) { SBSymbolContext sc; if (addr.IsValid()) { TargetSP target_sp(GetSP()); if (target_sp) target_sp->GetImages().ResolveSymbolContextForAddress( addr.ref(), resolve_scope, sc.ref()); } return sc; } size_t SBTarget::ReadMemory(const SBAddress addr, void *buf, size_t size, lldb::SBError &error) { SBError sb_error; size_t bytes_read = 0; TargetSP target_sp(GetSP()); if (target_sp) { std::lock_guard guard(target_sp->GetAPIMutex()); bytes_read = target_sp->ReadMemory(addr.ref(), false, buf, size, sb_error.ref()); } else { sb_error.SetErrorString("invalid target"); } return bytes_read; } SBBreakpoint SBTarget::BreakpointCreateByLocation(const char *file, uint32_t line) { return SBBreakpoint( BreakpointCreateByLocation(SBFileSpec(file, false), line)); } SBBreakpoint SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec, uint32_t line) { return BreakpointCreateByLocation(sb_file_spec, line, 0); } SBBreakpoint SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec, uint32_t line, lldb::addr_t offset) { SBFileSpecList empty_list; return BreakpointCreateByLocation(sb_file_spec, line, offset, empty_list); } SBBreakpoint SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec, uint32_t line, lldb::addr_t offset, SBFileSpecList &sb_module_list) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBBreakpoint sb_bp; TargetSP target_sp(GetSP()); if (target_sp && line != 0) { std::lock_guard guard(target_sp->GetAPIMutex()); const LazyBool check_inlines = eLazyBoolCalculate; const LazyBool skip_prologue = eLazyBoolCalculate; const bool internal = false; const bool hardware = false; const LazyBool move_to_nearest_code = eLazyBoolCalculate; const FileSpecList *module_list = nullptr; if (sb_module_list.GetSize() > 0) { module_list = sb_module_list.get(); } sb_bp = target_sp->CreateBreakpoint( module_list, *sb_file_spec, line, offset, check_inlines, skip_prologue, internal, hardware, move_to_nearest_code); } if (log) { SBStream sstr; sb_bp.GetDescription(sstr); char path[PATH_MAX]; sb_file_spec->GetPath(path, sizeof(path)); log->Printf("SBTarget(%p)::BreakpointCreateByLocation ( %s:%u ) => " "SBBreakpoint(%p): %s", static_cast(target_sp.get()), path, line, static_cast(sb_bp.GetSP().get()), sstr.GetData()); } return sb_bp; } SBBreakpoint SBTarget::BreakpointCreateByName(const char *symbol_name, const char *module_name) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBBreakpoint sb_bp; TargetSP target_sp(GetSP()); if (target_sp.get()) { std::lock_guard guard(target_sp->GetAPIMutex()); const bool internal = false; const bool hardware = false; const LazyBool skip_prologue = eLazyBoolCalculate; const lldb::addr_t offset = 0; if (module_name && module_name[0]) { FileSpecList module_spec_list; module_spec_list.Append(FileSpec(module_name, false)); sb_bp = target_sp->CreateBreakpoint( &module_spec_list, NULL, symbol_name, eFunctionNameTypeAuto, eLanguageTypeUnknown, offset, skip_prologue, internal, hardware); } else { sb_bp = target_sp->CreateBreakpoint( NULL, NULL, symbol_name, eFunctionNameTypeAuto, eLanguageTypeUnknown, offset, skip_prologue, internal, hardware); } } if (log) log->Printf("SBTarget(%p)::BreakpointCreateByName (symbol=\"%s\", " "module=\"%s\") => SBBreakpoint(%p)", static_cast(target_sp.get()), symbol_name, module_name, static_cast(sb_bp.GetSP().get())); return sb_bp; } lldb::SBBreakpoint SBTarget::BreakpointCreateByName(const char *symbol_name, const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { uint32_t name_type_mask = eFunctionNameTypeAuto; return BreakpointCreateByName(symbol_name, name_type_mask, eLanguageTypeUnknown, module_list, comp_unit_list); } lldb::SBBreakpoint SBTarget::BreakpointCreateByName( const char *symbol_name, uint32_t name_type_mask, const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { return BreakpointCreateByName(symbol_name, name_type_mask, eLanguageTypeUnknown, module_list, comp_unit_list); } lldb::SBBreakpoint SBTarget::BreakpointCreateByName( const char *symbol_name, uint32_t name_type_mask, LanguageType symbol_language, const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBBreakpoint sb_bp; TargetSP target_sp(GetSP()); if (target_sp && symbol_name && symbol_name[0]) { const bool internal = false; const bool hardware = false; const LazyBool skip_prologue = eLazyBoolCalculate; std::lock_guard guard(target_sp->GetAPIMutex()); sb_bp = target_sp->CreateBreakpoint( module_list.get(), comp_unit_list.get(), symbol_name, name_type_mask, symbol_language, 0, skip_prologue, internal, hardware); } if (log) log->Printf("SBTarget(%p)::BreakpointCreateByName (symbol=\"%s\", " "name_type: %d) => SBBreakpoint(%p)", static_cast(target_sp.get()), symbol_name, name_type_mask, static_cast(sb_bp.GetSP().get())); return sb_bp; } lldb::SBBreakpoint SBTarget::BreakpointCreateByNames( const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask, const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { return BreakpointCreateByNames(symbol_names, num_names, name_type_mask, eLanguageTypeUnknown, module_list, comp_unit_list); } lldb::SBBreakpoint SBTarget::BreakpointCreateByNames( const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask, LanguageType symbol_language, const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { return BreakpointCreateByNames(symbol_names, num_names, name_type_mask, eLanguageTypeUnknown, 0, module_list, comp_unit_list); } lldb::SBBreakpoint SBTarget::BreakpointCreateByNames( const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask, LanguageType symbol_language, lldb::addr_t offset, const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBBreakpoint sb_bp; TargetSP target_sp(GetSP()); if (target_sp && num_names > 0) { std::lock_guard guard(target_sp->GetAPIMutex()); const bool internal = false; const bool hardware = false; const LazyBool skip_prologue = eLazyBoolCalculate; sb_bp = target_sp->CreateBreakpoint( module_list.get(), comp_unit_list.get(), symbol_names, num_names, name_type_mask, symbol_language, offset, skip_prologue, internal, hardware); } if (log) { log->Printf("SBTarget(%p)::BreakpointCreateByName (symbols={", static_cast(target_sp.get())); for (uint32_t i = 0; i < num_names; i++) { char sep; if (i < num_names - 1) sep = ','; else sep = '}'; if (symbol_names[i] != NULL) log->Printf("\"%s\"%c ", symbol_names[i], sep); else log->Printf("\"\"%c ", sep); } log->Printf("name_type: %d) => SBBreakpoint(%p)", name_type_mask, static_cast(sb_bp.GetSP().get())); } return sb_bp; } SBBreakpoint SBTarget::BreakpointCreateByRegex(const char *symbol_name_regex, const char *module_name) { SBFileSpecList module_spec_list; SBFileSpecList comp_unit_list; if (module_name && module_name[0]) { module_spec_list.Append(FileSpec(module_name, false)); } return BreakpointCreateByRegex(symbol_name_regex, eLanguageTypeUnknown, module_spec_list, comp_unit_list); } lldb::SBBreakpoint SBTarget::BreakpointCreateByRegex(const char *symbol_name_regex, const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { return BreakpointCreateByRegex(symbol_name_regex, eLanguageTypeUnknown, module_list, comp_unit_list); } lldb::SBBreakpoint SBTarget::BreakpointCreateByRegex( const char *symbol_name_regex, LanguageType symbol_language, const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBBreakpoint sb_bp; TargetSP target_sp(GetSP()); if (target_sp && symbol_name_regex && symbol_name_regex[0]) { std::lock_guard guard(target_sp->GetAPIMutex()); RegularExpression regexp((llvm::StringRef(symbol_name_regex))); const bool internal = false; const bool hardware = false; const LazyBool skip_prologue = eLazyBoolCalculate; sb_bp = target_sp->CreateFuncRegexBreakpoint( module_list.get(), comp_unit_list.get(), regexp, symbol_language, skip_prologue, internal, hardware); } if (log) log->Printf("SBTarget(%p)::BreakpointCreateByRegex (symbol_regex=\"%s\") " "=> SBBreakpoint(%p)", static_cast(target_sp.get()), symbol_name_regex, static_cast(sb_bp.GetSP().get())); return sb_bp; } SBBreakpoint SBTarget::BreakpointCreateByAddress(addr_t address) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBBreakpoint sb_bp; TargetSP target_sp(GetSP()); if (target_sp) { std::lock_guard guard(target_sp->GetAPIMutex()); const bool hardware = false; sb_bp = target_sp->CreateBreakpoint(address, false, hardware); } if (log) log->Printf("SBTarget(%p)::BreakpointCreateByAddress (address=%" PRIu64 ") => SBBreakpoint(%p)", static_cast(target_sp.get()), static_cast(address), static_cast(sb_bp.GetSP().get())); return sb_bp; } SBBreakpoint SBTarget::BreakpointCreateBySBAddress(SBAddress &sb_address) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBBreakpoint sb_bp; TargetSP target_sp(GetSP()); if (!sb_address.IsValid()) { if (log) log->Printf("SBTarget(%p)::BreakpointCreateBySBAddress called with " "invalid address", static_cast(target_sp.get())); return sb_bp; } if (target_sp) { std::lock_guard guard(target_sp->GetAPIMutex()); const bool hardware = false; sb_bp = target_sp->CreateBreakpoint(sb_address.ref(), false, hardware); } if (log) { SBStream s; sb_address.GetDescription(s); log->Printf("SBTarget(%p)::BreakpointCreateBySBAddress (address=%s) => " "SBBreakpoint(%p)", static_cast(target_sp.get()), s.GetData(), static_cast(sb_bp.GetSP().get())); } return sb_bp; } lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex(const char *source_regex, const lldb::SBFileSpec &source_file, const char *module_name) { SBFileSpecList module_spec_list; if (module_name && module_name[0]) { module_spec_list.Append(FileSpec(module_name, false)); } SBFileSpecList source_file_list; if (source_file.IsValid()) { source_file_list.Append(source_file); } return BreakpointCreateBySourceRegex(source_regex, module_spec_list, source_file_list); } lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex( const char *source_regex, const SBFileSpecList &module_list, const lldb::SBFileSpecList &source_file_list) { return BreakpointCreateBySourceRegex(source_regex, module_list, source_file_list, SBStringList()); } lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex( const char *source_regex, const SBFileSpecList &module_list, const lldb::SBFileSpecList &source_file_list, const SBStringList &func_names) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBBreakpoint sb_bp; TargetSP target_sp(GetSP()); if (target_sp && source_regex && source_regex[0]) { std::lock_guard guard(target_sp->GetAPIMutex()); const bool hardware = false; const LazyBool move_to_nearest_code = eLazyBoolCalculate; RegularExpression regexp((llvm::StringRef(source_regex))); std::unordered_set func_names_set; for (size_t i = 0; i < func_names.GetSize(); i++) { func_names_set.insert(func_names.GetStringAtIndex(i)); } sb_bp = target_sp->CreateSourceRegexBreakpoint( module_list.get(), source_file_list.get(), func_names_set, regexp, false, hardware, move_to_nearest_code); } if (log) log->Printf("SBTarget(%p)::BreakpointCreateByRegex (source_regex=\"%s\") " "=> SBBreakpoint(%p)", static_cast(target_sp.get()), source_regex, static_cast(sb_bp.GetSP().get())); return sb_bp; } lldb::SBBreakpoint SBTarget::BreakpointCreateForException(lldb::LanguageType language, bool catch_bp, bool throw_bp) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBBreakpoint sb_bp; TargetSP target_sp(GetSP()); if (target_sp) { std::lock_guard guard(target_sp->GetAPIMutex()); const bool hardware = false; sb_bp = target_sp->CreateExceptionBreakpoint(language, catch_bp, throw_bp, hardware); } if (log) log->Printf("SBTarget(%p)::BreakpointCreateByRegex (Language: %s, catch: " "%s throw: %s) => SBBreakpoint(%p)", static_cast(target_sp.get()), Language::GetNameForLanguageType(language), catch_bp ? "on" : "off", throw_bp ? "on" : "off", static_cast(sb_bp.GetSP().get())); return sb_bp; } uint32_t SBTarget::GetNumBreakpoints() const { TargetSP target_sp(GetSP()); if (target_sp) { // The breakpoint list is thread safe, no need to lock return target_sp->GetBreakpointList().GetSize(); } return 0; } SBBreakpoint SBTarget::GetBreakpointAtIndex(uint32_t idx) const { SBBreakpoint sb_breakpoint; TargetSP target_sp(GetSP()); if (target_sp) { // The breakpoint list is thread safe, no need to lock sb_breakpoint = target_sp->GetBreakpointList().GetBreakpointAtIndex(idx); } return sb_breakpoint; } bool SBTarget::BreakpointDelete(break_id_t bp_id) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); bool result = false; TargetSP target_sp(GetSP()); if (target_sp) { std::lock_guard guard(target_sp->GetAPIMutex()); result = target_sp->RemoveBreakpointByID(bp_id); } if (log) log->Printf("SBTarget(%p)::BreakpointDelete (bp_id=%d) => %i", static_cast(target_sp.get()), static_cast(bp_id), result); return result; } SBBreakpoint SBTarget::FindBreakpointByID(break_id_t bp_id) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBBreakpoint sb_breakpoint; TargetSP target_sp(GetSP()); if (target_sp && bp_id != LLDB_INVALID_BREAK_ID) { std::lock_guard guard(target_sp->GetAPIMutex()); sb_breakpoint = target_sp->GetBreakpointByID(bp_id); } if (log) log->Printf( "SBTarget(%p)::FindBreakpointByID (bp_id=%d) => SBBreakpoint(%p)", static_cast(target_sp.get()), static_cast(bp_id), static_cast(sb_breakpoint.GetSP().get())); return sb_breakpoint; } bool SBTarget::FindBreakpointsByName(const char *name, SBBreakpointList &bkpts) { TargetSP target_sp(GetSP()); if (target_sp) { std::lock_guard guard(target_sp->GetAPIMutex()); BreakpointList bkpt_list(false); bool is_valid = target_sp->GetBreakpointList().FindBreakpointsByName(name, bkpt_list); if (!is_valid) return false; for (BreakpointSP bkpt_sp : bkpt_list.Breakpoints()) { bkpts.AppendByID(bkpt_sp->GetID()); } } return true; } bool SBTarget::EnableAllBreakpoints() { TargetSP target_sp(GetSP()); if (target_sp) { std::lock_guard guard(target_sp->GetAPIMutex()); target_sp->EnableAllBreakpoints(); return true; } return false; } bool SBTarget::DisableAllBreakpoints() { TargetSP target_sp(GetSP()); if (target_sp) { std::lock_guard guard(target_sp->GetAPIMutex()); target_sp->DisableAllBreakpoints(); return true; } return false; } bool SBTarget::DeleteAllBreakpoints() { TargetSP target_sp(GetSP()); if (target_sp) { std::lock_guard guard(target_sp->GetAPIMutex()); target_sp->RemoveAllBreakpoints(); return true; } return false; } lldb::SBError SBTarget::BreakpointsCreateFromFile(SBFileSpec &source_file, SBBreakpointList &new_bps) { SBStringList empty_name_list; return BreakpointsCreateFromFile(source_file, empty_name_list, new_bps); } lldb::SBError SBTarget::BreakpointsCreateFromFile(SBFileSpec &source_file, SBStringList &matching_names, SBBreakpointList &new_bps) { SBError sberr; TargetSP target_sp(GetSP()); if (!target_sp) { sberr.SetErrorString( "BreakpointCreateFromFile called with invalid target."); return sberr; } std::lock_guard guard(target_sp->GetAPIMutex()); BreakpointIDList bp_ids; std::vector name_vector; size_t num_names = matching_names.GetSize(); for (size_t i = 0; i < num_names; i++) name_vector.push_back(matching_names.GetStringAtIndex(i)); sberr.ref() = target_sp->CreateBreakpointsFromFile(source_file.ref(), name_vector, bp_ids); if (sberr.Fail()) return sberr; size_t num_bkpts = bp_ids.GetSize(); for (size_t i = 0; i < num_bkpts; i++) { BreakpointID bp_id = bp_ids.GetBreakpointIDAtIndex(i); new_bps.AppendByID(bp_id.GetBreakpointID()); } return sberr; } lldb::SBError SBTarget::BreakpointsWriteToFile(SBFileSpec &dest_file) { SBError sberr; TargetSP target_sp(GetSP()); if (!target_sp) { sberr.SetErrorString("BreakpointWriteToFile called with invalid target."); return sberr; } SBBreakpointList bkpt_list(*this); return BreakpointsWriteToFile(dest_file, bkpt_list); } lldb::SBError SBTarget::BreakpointsWriteToFile(SBFileSpec &dest_file, SBBreakpointList &bkpt_list, bool append) { SBError sberr; TargetSP target_sp(GetSP()); if (!target_sp) { sberr.SetErrorString("BreakpointWriteToFile called with invalid target."); return sberr; } std::lock_guard guard(target_sp->GetAPIMutex()); BreakpointIDList bp_id_list; bkpt_list.CopyToBreakpointIDList(bp_id_list); sberr.ref() = target_sp->SerializeBreakpointsToFile(dest_file.ref(), bp_id_list, append); return sberr; } uint32_t SBTarget::GetNumWatchpoints() const { TargetSP target_sp(GetSP()); if (target_sp) { // The watchpoint list is thread safe, no need to lock return target_sp->GetWatchpointList().GetSize(); } return 0; } SBWatchpoint SBTarget::GetWatchpointAtIndex(uint32_t idx) const { SBWatchpoint sb_watchpoint; TargetSP target_sp(GetSP()); if (target_sp) { // The watchpoint list is thread safe, no need to lock sb_watchpoint.SetSP(target_sp->GetWatchpointList().GetByIndex(idx)); } return sb_watchpoint; } bool SBTarget::DeleteWatchpoint(watch_id_t wp_id) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); bool result = false; TargetSP target_sp(GetSP()); if (target_sp) { std::lock_guard guard(target_sp->GetAPIMutex()); std::unique_lock lock; target_sp->GetWatchpointList().GetListMutex(lock); result = target_sp->RemoveWatchpointByID(wp_id); } if (log) log->Printf("SBTarget(%p)::WatchpointDelete (wp_id=%d) => %i", static_cast(target_sp.get()), static_cast(wp_id), result); return result; } SBWatchpoint SBTarget::FindWatchpointByID(lldb::watch_id_t wp_id) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBWatchpoint sb_watchpoint; lldb::WatchpointSP watchpoint_sp; TargetSP target_sp(GetSP()); if (target_sp && wp_id != LLDB_INVALID_WATCH_ID) { std::lock_guard guard(target_sp->GetAPIMutex()); std::unique_lock lock; target_sp->GetWatchpointList().GetListMutex(lock); watchpoint_sp = target_sp->GetWatchpointList().FindByID(wp_id); sb_watchpoint.SetSP(watchpoint_sp); } if (log) log->Printf( "SBTarget(%p)::FindWatchpointByID (bp_id=%d) => SBWatchpoint(%p)", static_cast(target_sp.get()), static_cast(wp_id), static_cast(watchpoint_sp.get())); return sb_watchpoint; } lldb::SBWatchpoint SBTarget::WatchAddress(lldb::addr_t addr, size_t size, bool read, bool write, SBError &error) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBWatchpoint sb_watchpoint; lldb::WatchpointSP watchpoint_sp; TargetSP target_sp(GetSP()); if (target_sp && (read || write) && addr != LLDB_INVALID_ADDRESS && size > 0) { std::lock_guard guard(target_sp->GetAPIMutex()); uint32_t watch_type = 0; if (read) watch_type |= LLDB_WATCH_TYPE_READ; if (write) watch_type |= LLDB_WATCH_TYPE_WRITE; if (watch_type == 0) { error.SetErrorString( "Can't create a watchpoint that is neither read nor write."); return sb_watchpoint; } // Target::CreateWatchpoint() is thread safe. Error cw_error; // This API doesn't take in a type, so we can't figure out what it is. CompilerType *type = NULL; watchpoint_sp = target_sp->CreateWatchpoint(addr, size, type, watch_type, cw_error); error.SetError(cw_error); sb_watchpoint.SetSP(watchpoint_sp); } if (log) log->Printf("SBTarget(%p)::WatchAddress (addr=0x%" PRIx64 ", 0x%u) => SBWatchpoint(%p)", static_cast(target_sp.get()), addr, static_cast(size), static_cast(watchpoint_sp.get())); return sb_watchpoint; } bool SBTarget::EnableAllWatchpoints() { TargetSP target_sp(GetSP()); if (target_sp) { std::lock_guard guard(target_sp->GetAPIMutex()); std::unique_lock lock; target_sp->GetWatchpointList().GetListMutex(lock); target_sp->EnableAllWatchpoints(); return true; } return false; } bool SBTarget::DisableAllWatchpoints() { TargetSP target_sp(GetSP()); if (target_sp) { std::lock_guard guard(target_sp->GetAPIMutex()); std::unique_lock lock; target_sp->GetWatchpointList().GetListMutex(lock); target_sp->DisableAllWatchpoints(); return true; } return false; } SBValue SBTarget::CreateValueFromAddress(const char *name, SBAddress addr, SBType type) { SBValue sb_value; lldb::ValueObjectSP new_value_sp; if (IsValid() && name && *name && addr.IsValid() && type.IsValid()) { lldb::addr_t load_addr(addr.GetLoadAddress(*this)); ExecutionContext exe_ctx( ExecutionContextRef(ExecutionContext(m_opaque_sp.get(), false))); CompilerType ast_type(type.GetSP()->GetCompilerType(true)); new_value_sp = ValueObject::CreateValueObjectFromAddress(name, load_addr, exe_ctx, ast_type); } sb_value.SetSP(new_value_sp); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) { if (new_value_sp) log->Printf("SBTarget(%p)::CreateValueFromAddress => \"%s\"", static_cast(m_opaque_sp.get()), new_value_sp->GetName().AsCString()); else log->Printf("SBTarget(%p)::CreateValueFromAddress => NULL", static_cast(m_opaque_sp.get())); } return sb_value; } lldb::SBValue SBTarget::CreateValueFromData(const char *name, lldb::SBData data, lldb::SBType type) { SBValue sb_value; lldb::ValueObjectSP new_value_sp; if (IsValid() && name && *name && data.IsValid() && type.IsValid()) { DataExtractorSP extractor(*data); ExecutionContext exe_ctx( ExecutionContextRef(ExecutionContext(m_opaque_sp.get(), false))); CompilerType ast_type(type.GetSP()->GetCompilerType(true)); new_value_sp = ValueObject::CreateValueObjectFromData(name, *extractor, exe_ctx, ast_type); } sb_value.SetSP(new_value_sp); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) { if (new_value_sp) log->Printf("SBTarget(%p)::CreateValueFromData => \"%s\"", static_cast(m_opaque_sp.get()), new_value_sp->GetName().AsCString()); else log->Printf("SBTarget(%p)::CreateValueFromData => NULL", static_cast(m_opaque_sp.get())); } return sb_value; } lldb::SBValue SBTarget::CreateValueFromExpression(const char *name, const char *expr) { SBValue sb_value; lldb::ValueObjectSP new_value_sp; if (IsValid() && name && *name && expr && *expr) { ExecutionContext exe_ctx( ExecutionContextRef(ExecutionContext(m_opaque_sp.get(), false))); new_value_sp = ValueObject::CreateValueObjectFromExpression(name, expr, exe_ctx); } sb_value.SetSP(new_value_sp); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) { if (new_value_sp) log->Printf("SBTarget(%p)::CreateValueFromExpression => \"%s\"", static_cast(m_opaque_sp.get()), new_value_sp->GetName().AsCString()); else log->Printf("SBTarget(%p)::CreateValueFromExpression => NULL", static_cast(m_opaque_sp.get())); } return sb_value; } bool SBTarget::DeleteAllWatchpoints() { TargetSP target_sp(GetSP()); if (target_sp) { std::lock_guard guard(target_sp->GetAPIMutex()); std::unique_lock lock; target_sp->GetWatchpointList().GetListMutex(lock); target_sp->RemoveAllWatchpoints(); return true; } return false; } lldb::SBModule SBTarget::AddModule(const char *path, const char *triple, const char *uuid_cstr) { return AddModule(path, triple, uuid_cstr, NULL); } lldb::SBModule SBTarget::AddModule(const char *path, const char *triple, const char *uuid_cstr, const char *symfile) { lldb::SBModule sb_module; TargetSP target_sp(GetSP()); if (target_sp) { ModuleSpec module_spec; if (path) module_spec.GetFileSpec().SetFile(path, false); if (uuid_cstr) module_spec.GetUUID().SetFromCString(uuid_cstr); if (triple) module_spec.GetArchitecture().SetTriple(triple, target_sp->GetPlatform().get()); else module_spec.GetArchitecture() = target_sp->GetArchitecture(); if (symfile) module_spec.GetSymbolFileSpec().SetFile(symfile, false); sb_module.SetSP(target_sp->GetSharedModule(module_spec)); } return sb_module; } lldb::SBModule SBTarget::AddModule(const SBModuleSpec &module_spec) { lldb::SBModule sb_module; TargetSP target_sp(GetSP()); if (target_sp) sb_module.SetSP(target_sp->GetSharedModule(*module_spec.m_opaque_ap)); return sb_module; } bool SBTarget::AddModule(lldb::SBModule &module) { TargetSP target_sp(GetSP()); if (target_sp) { target_sp->GetImages().AppendIfNeeded(module.GetSP()); return true; } return false; } uint32_t SBTarget::GetNumModules() const { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); uint32_t num = 0; TargetSP target_sp(GetSP()); if (target_sp) { // The module list is thread safe, no need to lock num = target_sp->GetImages().GetSize(); } if (log) log->Printf("SBTarget(%p)::GetNumModules () => %d", static_cast(target_sp.get()), num); return num; } void SBTarget::Clear() { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) log->Printf("SBTarget(%p)::Clear ()", static_cast(m_opaque_sp.get())); m_opaque_sp.reset(); } SBModule SBTarget::FindModule(const SBFileSpec &sb_file_spec) { SBModule sb_module; TargetSP target_sp(GetSP()); if (target_sp && sb_file_spec.IsValid()) { ModuleSpec module_spec(*sb_file_spec); // The module list is thread safe, no need to lock sb_module.SetSP(target_sp->GetImages().FindFirstModule(module_spec)); } return sb_module; } lldb::ByteOrder SBTarget::GetByteOrder() { TargetSP target_sp(GetSP()); if (target_sp) return target_sp->GetArchitecture().GetByteOrder(); return eByteOrderInvalid; } const char *SBTarget::GetTriple() { TargetSP target_sp(GetSP()); if (target_sp) { std::string triple(target_sp->GetArchitecture().GetTriple().str()); // Unique the string so we don't run into ownership issues since // the const strings put the string into the string pool once and // the strings never comes out ConstString const_triple(triple.c_str()); return const_triple.GetCString(); } return NULL; } uint32_t SBTarget::GetDataByteSize() { TargetSP target_sp(GetSP()); if (target_sp) { return target_sp->GetArchitecture().GetDataByteSize(); } return 0; } uint32_t SBTarget::GetCodeByteSize() { TargetSP target_sp(GetSP()); if (target_sp) { return target_sp->GetArchitecture().GetCodeByteSize(); } return 0; } uint32_t SBTarget::GetAddressByteSize() { TargetSP target_sp(GetSP()); if (target_sp) return target_sp->GetArchitecture().GetAddressByteSize(); return sizeof(void *); } SBModule SBTarget::GetModuleAtIndex(uint32_t idx) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBModule sb_module; ModuleSP module_sp; TargetSP target_sp(GetSP()); if (target_sp) { // The module list is thread safe, no need to lock module_sp = target_sp->GetImages().GetModuleAtIndex(idx); sb_module.SetSP(module_sp); } if (log) log->Printf("SBTarget(%p)::GetModuleAtIndex (idx=%d) => SBModule(%p)", static_cast(target_sp.get()), idx, static_cast(module_sp.get())); return sb_module; } bool SBTarget::RemoveModule(lldb::SBModule module) { TargetSP target_sp(GetSP()); if (target_sp) return target_sp->GetImages().Remove(module.GetSP()); return false; } SBBroadcaster SBTarget::GetBroadcaster() const { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); TargetSP target_sp(GetSP()); SBBroadcaster broadcaster(target_sp.get(), false); if (log) log->Printf("SBTarget(%p)::GetBroadcaster () => SBBroadcaster(%p)", static_cast(target_sp.get()), static_cast(broadcaster.get())); return broadcaster; } bool SBTarget::GetDescription(SBStream &description, lldb::DescriptionLevel description_level) { Stream &strm = description.ref(); TargetSP target_sp(GetSP()); if (target_sp) { target_sp->Dump(&strm, description_level); } else strm.PutCString("No value"); return true; } lldb::SBSymbolContextList SBTarget::FindFunctions(const char *name, uint32_t name_type_mask) { lldb::SBSymbolContextList sb_sc_list; if (name && name[0]) { TargetSP target_sp(GetSP()); if (target_sp) { const bool symbols_ok = true; const bool inlines_ok = true; const bool append = true; target_sp->GetImages().FindFunctions(ConstString(name), name_type_mask, symbols_ok, inlines_ok, append, *sb_sc_list); } } return sb_sc_list; } lldb::SBSymbolContextList SBTarget::FindGlobalFunctions(const char *name, uint32_t max_matches, MatchType matchtype) { lldb::SBSymbolContextList sb_sc_list; if (name && name[0]) { llvm::StringRef name_ref(name); TargetSP target_sp(GetSP()); if (target_sp) { std::string regexstr; switch (matchtype) { case eMatchTypeRegex: target_sp->GetImages().FindFunctions(RegularExpression(name_ref), true, true, true, *sb_sc_list); break; case eMatchTypeStartsWith: regexstr = llvm::Regex::escape(name) + ".*"; target_sp->GetImages().FindFunctions(RegularExpression(regexstr), true, true, true, *sb_sc_list); break; default: target_sp->GetImages().FindFunctions(ConstString(name), eFunctionNameTypeAny, true, true, true, *sb_sc_list); break; } } } return sb_sc_list; } lldb::SBType SBTarget::FindFirstType(const char *typename_cstr) { TargetSP target_sp(GetSP()); if (typename_cstr && typename_cstr[0] && target_sp) { ConstString const_typename(typename_cstr); SymbolContext sc; const bool exact_match = false; const ModuleList &module_list = target_sp->GetImages(); size_t count = module_list.GetSize(); for (size_t idx = 0; idx < count; idx++) { ModuleSP module_sp(module_list.GetModuleAtIndex(idx)); if (module_sp) { TypeSP type_sp( module_sp->FindFirstType(sc, const_typename, exact_match)); if (type_sp) return SBType(type_sp); } } // Didn't find the type in the symbols; try the Objective-C runtime // if one is installed ProcessSP process_sp(target_sp->GetProcessSP()); if (process_sp) { ObjCLanguageRuntime *objc_language_runtime = process_sp->GetObjCLanguageRuntime(); if (objc_language_runtime) { DeclVendor *objc_decl_vendor = objc_language_runtime->GetDeclVendor(); if (objc_decl_vendor) { std::vector decls; if (objc_decl_vendor->FindDecls(const_typename, true, 1, decls) > 0) { if (CompilerType type = ClangASTContext::GetTypeForDecl(decls[0])) { return SBType(type); } } } } } // No matches, search for basic typename matches ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext(); if (clang_ast) return SBType(ClangASTContext::GetBasicType(clang_ast->getASTContext(), const_typename)); } return SBType(); } SBType SBTarget::GetBasicType(lldb::BasicType type) { TargetSP target_sp(GetSP()); if (target_sp) { ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext(); if (clang_ast) return SBType( ClangASTContext::GetBasicType(clang_ast->getASTContext(), type)); } return SBType(); } lldb::SBTypeList SBTarget::FindTypes(const char *typename_cstr) { SBTypeList sb_type_list; TargetSP target_sp(GetSP()); if (typename_cstr && typename_cstr[0] && target_sp) { ModuleList &images = target_sp->GetImages(); ConstString const_typename(typename_cstr); bool exact_match = false; SymbolContext sc; TypeList type_list; llvm::DenseSet searched_symbol_files; uint32_t num_matches = images.FindTypes(sc, const_typename, exact_match, UINT32_MAX, searched_symbol_files, type_list); if (num_matches > 0) { for (size_t idx = 0; idx < num_matches; idx++) { TypeSP type_sp(type_list.GetTypeAtIndex(idx)); if (type_sp) sb_type_list.Append(SBType(type_sp)); } } // Try the Objective-C runtime if one is installed ProcessSP process_sp(target_sp->GetProcessSP()); if (process_sp) { ObjCLanguageRuntime *objc_language_runtime = process_sp->GetObjCLanguageRuntime(); if (objc_language_runtime) { DeclVendor *objc_decl_vendor = objc_language_runtime->GetDeclVendor(); if (objc_decl_vendor) { std::vector decls; if (objc_decl_vendor->FindDecls(const_typename, true, 1, decls) > 0) { for (clang::NamedDecl *decl : decls) { if (CompilerType type = ClangASTContext::GetTypeForDecl(decl)) { sb_type_list.Append(SBType(type)); } } } } } } if (sb_type_list.GetSize() == 0) { // No matches, search for basic typename matches ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext(); if (clang_ast) sb_type_list.Append(SBType(ClangASTContext::GetBasicType( clang_ast->getASTContext(), const_typename))); } } return sb_type_list; } SBValueList SBTarget::FindGlobalVariables(const char *name, uint32_t max_matches) { SBValueList sb_value_list; TargetSP target_sp(GetSP()); if (name && target_sp) { VariableList variable_list; const bool append = true; const uint32_t match_count = target_sp->GetImages().FindGlobalVariables( ConstString(name), append, max_matches, variable_list); if (match_count > 0) { ExecutionContextScope *exe_scope = target_sp->GetProcessSP().get(); if (exe_scope == NULL) exe_scope = target_sp.get(); for (uint32_t i = 0; i < match_count; ++i) { lldb::ValueObjectSP valobj_sp(ValueObjectVariable::Create( exe_scope, variable_list.GetVariableAtIndex(i))); if (valobj_sp) sb_value_list.Append(SBValue(valobj_sp)); } } } return sb_value_list; } SBValueList SBTarget::FindGlobalVariables(const char *name, uint32_t max_matches, MatchType matchtype) { SBValueList sb_value_list; TargetSP target_sp(GetSP()); if (name && target_sp) { llvm::StringRef name_ref(name); VariableList variable_list; const bool append = true; std::string regexstr; uint32_t match_count; switch (matchtype) { case eMatchTypeNormal: match_count = target_sp->GetImages().FindGlobalVariables( ConstString(name), append, max_matches, variable_list); break; case eMatchTypeRegex: match_count = target_sp->GetImages().FindGlobalVariables( RegularExpression(name_ref), append, max_matches, variable_list); break; case eMatchTypeStartsWith: regexstr = llvm::Regex::escape(name) + ".*"; match_count = target_sp->GetImages().FindGlobalVariables( RegularExpression(regexstr), append, max_matches, variable_list); break; } if (match_count > 0) { ExecutionContextScope *exe_scope = target_sp->GetProcessSP().get(); if (exe_scope == NULL) exe_scope = target_sp.get(); for (uint32_t i = 0; i < match_count; ++i) { lldb::ValueObjectSP valobj_sp(ValueObjectVariable::Create( exe_scope, variable_list.GetVariableAtIndex(i))); if (valobj_sp) sb_value_list.Append(SBValue(valobj_sp)); } } } return sb_value_list; } lldb::SBValue SBTarget::FindFirstGlobalVariable(const char *name) { SBValueList sb_value_list(FindGlobalVariables(name, 1)); if (sb_value_list.IsValid() && sb_value_list.GetSize() > 0) return sb_value_list.GetValueAtIndex(0); return SBValue(); } SBSourceManager SBTarget::GetSourceManager() { SBSourceManager source_manager(*this); return source_manager; } lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr, uint32_t count) { return ReadInstructions(base_addr, count, NULL); } lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr, uint32_t count, const char *flavor_string) { SBInstructionList sb_instructions; TargetSP target_sp(GetSP()); if (target_sp) { Address *addr_ptr = base_addr.get(); if (addr_ptr) { DataBufferHeap data( target_sp->GetArchitecture().GetMaximumOpcodeByteSize() * count, 0); bool prefer_file_cache = false; lldb_private::Error error; lldb::addr_t load_addr = LLDB_INVALID_ADDRESS; const size_t bytes_read = target_sp->ReadMemory(*addr_ptr, prefer_file_cache, data.GetBytes(), data.GetByteSize(), error, &load_addr); const bool data_from_file = load_addr == LLDB_INVALID_ADDRESS; sb_instructions.SetDisassembler(Disassembler::DisassembleBytes( target_sp->GetArchitecture(), NULL, flavor_string, *addr_ptr, data.GetBytes(), bytes_read, count, data_from_file)); } } return sb_instructions; } lldb::SBInstructionList SBTarget::GetInstructions(lldb::SBAddress base_addr, const void *buf, size_t size) { return GetInstructionsWithFlavor(base_addr, NULL, buf, size); } lldb::SBInstructionList SBTarget::GetInstructionsWithFlavor(lldb::SBAddress base_addr, const char *flavor_string, const void *buf, size_t size) { SBInstructionList sb_instructions; TargetSP target_sp(GetSP()); if (target_sp) { Address addr; if (base_addr.get()) addr = *base_addr.get(); const bool data_from_file = true; sb_instructions.SetDisassembler(Disassembler::DisassembleBytes( target_sp->GetArchitecture(), NULL, flavor_string, addr, buf, size, UINT32_MAX, data_from_file)); } return sb_instructions; } lldb::SBInstructionList SBTarget::GetInstructions(lldb::addr_t base_addr, const void *buf, size_t size) { return GetInstructionsWithFlavor(ResolveLoadAddress(base_addr), NULL, buf, size); } lldb::SBInstructionList SBTarget::GetInstructionsWithFlavor(lldb::addr_t base_addr, const char *flavor_string, const void *buf, size_t size) { return GetInstructionsWithFlavor(ResolveLoadAddress(base_addr), flavor_string, buf, size); } SBError SBTarget::SetSectionLoadAddress(lldb::SBSection section, lldb::addr_t section_base_addr) { SBError sb_error; TargetSP target_sp(GetSP()); if (target_sp) { if (!section.IsValid()) { sb_error.SetErrorStringWithFormat("invalid section"); } else { SectionSP section_sp(section.GetSP()); if (section_sp) { if (section_sp->IsThreadSpecific()) { sb_error.SetErrorString( "thread specific sections are not yet supported"); } else { ProcessSP process_sp(target_sp->GetProcessSP()); if (target_sp->SetSectionLoadAddress(section_sp, section_base_addr)) { ModuleSP module_sp(section_sp->GetModule()); if (module_sp) { ModuleList module_list; module_list.Append(module_sp); target_sp->ModulesDidLoad(module_list); } // Flush info in the process (stack frames, etc) if (process_sp) process_sp->Flush(); } } } } } else { sb_error.SetErrorString("invalid target"); } return sb_error; } SBError SBTarget::ClearSectionLoadAddress(lldb::SBSection section) { SBError sb_error; TargetSP target_sp(GetSP()); if (target_sp) { if (!section.IsValid()) { sb_error.SetErrorStringWithFormat("invalid section"); } else { SectionSP section_sp(section.GetSP()); if (section_sp) { ProcessSP process_sp(target_sp->GetProcessSP()); if (target_sp->SetSectionUnloaded(section_sp)) { ModuleSP module_sp(section_sp->GetModule()); if (module_sp) { ModuleList module_list; module_list.Append(module_sp); target_sp->ModulesDidUnload(module_list, false); } // Flush info in the process (stack frames, etc) if (process_sp) process_sp->Flush(); } } else { sb_error.SetErrorStringWithFormat("invalid section"); } } } else { sb_error.SetErrorStringWithFormat("invalid target"); } return sb_error; } SBError SBTarget::SetModuleLoadAddress(lldb::SBModule module, int64_t slide_offset) { SBError sb_error; TargetSP target_sp(GetSP()); if (target_sp) { ModuleSP module_sp(module.GetSP()); if (module_sp) { bool changed = false; if (module_sp->SetLoadAddress(*target_sp, slide_offset, true, changed)) { // The load was successful, make sure that at least some sections // changed before we notify that our module was loaded. if (changed) { ModuleList module_list; module_list.Append(module_sp); target_sp->ModulesDidLoad(module_list); // Flush info in the process (stack frames, etc) ProcessSP process_sp(target_sp->GetProcessSP()); if (process_sp) process_sp->Flush(); } } } else { sb_error.SetErrorStringWithFormat("invalid module"); } } else { sb_error.SetErrorStringWithFormat("invalid target"); } return sb_error; } SBError SBTarget::ClearModuleLoadAddress(lldb::SBModule module) { SBError sb_error; char path[PATH_MAX]; TargetSP target_sp(GetSP()); if (target_sp) { ModuleSP module_sp(module.GetSP()); if (module_sp) { ObjectFile *objfile = module_sp->GetObjectFile(); if (objfile) { SectionList *section_list = objfile->GetSectionList(); if (section_list) { ProcessSP process_sp(target_sp->GetProcessSP()); bool changed = false; const size_t num_sections = section_list->GetSize(); for (size_t sect_idx = 0; sect_idx < num_sections; ++sect_idx) { SectionSP section_sp(section_list->GetSectionAtIndex(sect_idx)); if (section_sp) changed |= target_sp->SetSectionUnloaded(section_sp); } if (changed) { ModuleList module_list; module_list.Append(module_sp); target_sp->ModulesDidUnload(module_list, false); // Flush info in the process (stack frames, etc) ProcessSP process_sp(target_sp->GetProcessSP()); if (process_sp) process_sp->Flush(); } } else { module_sp->GetFileSpec().GetPath(path, sizeof(path)); sb_error.SetErrorStringWithFormat("no sections in object file '%s'", path); } } else { module_sp->GetFileSpec().GetPath(path, sizeof(path)); sb_error.SetErrorStringWithFormat("no object file for module '%s'", path); } } else { sb_error.SetErrorStringWithFormat("invalid module"); } } else { sb_error.SetErrorStringWithFormat("invalid target"); } return sb_error; } lldb::SBSymbolContextList SBTarget::FindSymbols(const char *name, lldb::SymbolType symbol_type) { SBSymbolContextList sb_sc_list; if (name && name[0]) { TargetSP target_sp(GetSP()); if (target_sp) { bool append = true; target_sp->GetImages().FindSymbolsWithNameAndType( ConstString(name), symbol_type, *sb_sc_list, append); } } return sb_sc_list; } lldb::SBValue SBTarget::EvaluateExpression(const char *expr) { TargetSP target_sp(GetSP()); if (!target_sp) return SBValue(); SBExpressionOptions options; lldb::DynamicValueType fetch_dynamic_value = target_sp->GetPreferDynamicValue(); options.SetFetchDynamicValue(fetch_dynamic_value); options.SetUnwindOnError(true); return EvaluateExpression(expr, options); } lldb::SBValue SBTarget::EvaluateExpression(const char *expr, const SBExpressionOptions &options) { Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); #if !defined(LLDB_DISABLE_PYTHON) Log *expr_log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); #endif SBValue expr_result; ExpressionResults exe_results = eExpressionSetupError; ValueObjectSP expr_value_sp; TargetSP target_sp(GetSP()); StackFrame *frame = NULL; if (target_sp) { if (expr == NULL || expr[0] == '\0') { if (log) log->Printf( "SBTarget::EvaluateExpression called with an empty expression"); return expr_result; } std::lock_guard guard(target_sp->GetAPIMutex()); ExecutionContext exe_ctx(m_opaque_sp.get()); if (log) log->Printf("SBTarget()::EvaluateExpression (expr=\"%s\")...", expr); frame = exe_ctx.GetFramePtr(); Target *target = exe_ctx.GetTargetPtr(); if (target) { #ifdef LLDB_CONFIGURATION_DEBUG StreamString frame_description; if (frame) frame->DumpUsingSettingsFormat(&frame_description); llvm::PrettyStackTraceFormat stack_trace( "SBTarget::EvaluateExpression (expr = \"%s\", fetch_dynamic_value = " "%u) %s", expr, options.GetFetchDynamicValue(), frame_description.GetString().str().c_str()); #endif exe_results = target->EvaluateExpression(expr, frame, expr_value_sp, options.ref()); expr_result.SetSP(expr_value_sp, options.GetFetchDynamicValue()); } else { if (log) log->Printf("SBTarget::EvaluateExpression () => error: could not " "reconstruct frame object for this SBTarget."); } } #ifndef LLDB_DISABLE_PYTHON if (expr_log) expr_log->Printf("** [SBTarget::EvaluateExpression] Expression result is " "%s, summary %s **", expr_result.GetValue(), expr_result.GetSummary()); if (log) log->Printf("SBTarget(%p)::EvaluateExpression (expr=\"%s\") => SBValue(%p) " "(execution result=%d)", static_cast(frame), expr, static_cast(expr_value_sp.get()), exe_results); #endif return expr_result; } lldb::addr_t SBTarget::GetStackRedZoneSize() { TargetSP target_sp(GetSP()); if (target_sp) { ABISP abi_sp; ProcessSP process_sp(target_sp->GetProcessSP()); if (process_sp) abi_sp = process_sp->GetABI(); else abi_sp = ABI::FindPlugin(target_sp->GetArchitecture()); if (abi_sp) return abi_sp->GetRedZoneSize(); } return 0; } lldb::SBLaunchInfo SBTarget::GetLaunchInfo() const { lldb::SBLaunchInfo launch_info(NULL); TargetSP target_sp(GetSP()); if (target_sp) launch_info.ref() = m_opaque_sp->GetProcessLaunchInfo(); return launch_info; } void SBTarget::SetLaunchInfo(const lldb::SBLaunchInfo &launch_info) { TargetSP target_sp(GetSP()); if (target_sp) m_opaque_sp->SetProcessLaunchInfo(launch_info.ref()); }