2183 lines
72 KiB
C++
2183 lines
72 KiB
C++
//===-- 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 {
|
|
|
|
Status AttachToProcess(ProcessAttachInfo &attach_info, Target &target) {
|
|
std::lock_guard<std::recursive_mutex> 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 Status("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<void *>(target_sp.get()),
|
|
static_cast<void *>(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<std::recursive_mutex> 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<void *>(target_sp.get()), static_cast<void *>(argv),
|
|
static_cast<void *>(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<void *>(error.get()));
|
|
|
|
if (target_sp) {
|
|
std::lock_guard<std::recursive_mutex> 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<void *>(target_sp.get()),
|
|
static_cast<void *>(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<void *>(target_sp.get()));
|
|
|
|
if (target_sp) {
|
|
std::lock_guard<std::recursive_mutex> 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<void *>(target_sp.get()),
|
|
static_cast<void *>(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<void *>(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<void *>(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<void *>(target_sp.get()),
|
|
static_cast<void *>(sb_process.GetSP().get()));
|
|
|
|
return sb_process;
|
|
}
|
|
|
|
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<void *>(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<void *>(target_sp.get()), __FUNCTION__,
|
|
static_cast<void *>(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<void *>(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<void *>(target_sp.get()), __FUNCTION__,
|
|
static_cast<void *>(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<void *>(target_sp.get()), url, plugin_name);
|
|
|
|
if (target_sp) {
|
|
std::lock_guard<std::recursive_mutex> 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<void *>(target_sp.get()),
|
|
static_cast<void *>(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<void *>(target_sp.get()),
|
|
static_cast<const void *>(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<std::recursive_mutex> 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<std::recursive_mutex> 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<std::recursive_mutex> 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<std::recursive_mutex> 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<std::recursive_mutex> 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<void *>(target_sp.get()), path, line,
|
|
static_cast<void *>(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<std::recursive_mutex> 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<void *>(target_sp.get()), symbol_name, module_name,
|
|
static_cast<void *>(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<std::recursive_mutex> 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<void *>(target_sp.get()), symbol_name,
|
|
name_type_mask, static_cast<void *>(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<std::recursive_mutex> 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<void *>(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("\"<NULL>\"%c ", sep);
|
|
}
|
|
log->Printf("name_type: %d) => SBBreakpoint(%p)", name_type_mask,
|
|
static_cast<void *>(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<std::recursive_mutex> 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<void *>(target_sp.get()), symbol_name_regex,
|
|
static_cast<void *>(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<std::recursive_mutex> 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<void *>(target_sp.get()),
|
|
static_cast<uint64_t>(address),
|
|
static_cast<void *>(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<void *>(target_sp.get()));
|
|
return sb_bp;
|
|
}
|
|
|
|
if (target_sp) {
|
|
std::lock_guard<std::recursive_mutex> 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<void *>(target_sp.get()), s.GetData(),
|
|
static_cast<void *>(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<std::recursive_mutex> guard(target_sp->GetAPIMutex());
|
|
const bool hardware = false;
|
|
const LazyBool move_to_nearest_code = eLazyBoolCalculate;
|
|
RegularExpression regexp((llvm::StringRef(source_regex)));
|
|
std::unordered_set<std::string> 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<void *>(target_sp.get()), source_regex,
|
|
static_cast<void *>(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<std::recursive_mutex> 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<void *>(target_sp.get()),
|
|
Language::GetNameForLanguageType(language),
|
|
catch_bp ? "on" : "off", throw_bp ? "on" : "off",
|
|
static_cast<void *>(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<std::recursive_mutex> guard(target_sp->GetAPIMutex());
|
|
result = target_sp->RemoveBreakpointByID(bp_id);
|
|
}
|
|
|
|
if (log)
|
|
log->Printf("SBTarget(%p)::BreakpointDelete (bp_id=%d) => %i",
|
|
static_cast<void *>(target_sp.get()),
|
|
static_cast<uint32_t>(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<std::recursive_mutex> 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<void *>(target_sp.get()), static_cast<uint32_t>(bp_id),
|
|
static_cast<void *>(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<std::recursive_mutex> 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<std::recursive_mutex> guard(target_sp->GetAPIMutex());
|
|
target_sp->EnableAllBreakpoints();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool SBTarget::DisableAllBreakpoints() {
|
|
TargetSP target_sp(GetSP());
|
|
if (target_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
|
|
target_sp->DisableAllBreakpoints();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool SBTarget::DeleteAllBreakpoints() {
|
|
TargetSP target_sp(GetSP());
|
|
if (target_sp) {
|
|
std::lock_guard<std::recursive_mutex> 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<std::recursive_mutex> guard(target_sp->GetAPIMutex());
|
|
|
|
BreakpointIDList bp_ids;
|
|
|
|
std::vector<std::string> 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<std::recursive_mutex> 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<std::recursive_mutex> guard(target_sp->GetAPIMutex());
|
|
std::unique_lock<std::recursive_mutex> 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<void *>(target_sp.get()),
|
|
static_cast<uint32_t>(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<std::recursive_mutex> guard(target_sp->GetAPIMutex());
|
|
std::unique_lock<std::recursive_mutex> 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<void *>(target_sp.get()), static_cast<uint32_t>(wp_id),
|
|
static_cast<void *>(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<std::recursive_mutex> 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.
|
|
Status 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<void *>(target_sp.get()), addr,
|
|
static_cast<uint32_t>(size),
|
|
static_cast<void *>(watchpoint_sp.get()));
|
|
|
|
return sb_watchpoint;
|
|
}
|
|
|
|
bool SBTarget::EnableAllWatchpoints() {
|
|
TargetSP target_sp(GetSP());
|
|
if (target_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
|
|
std::unique_lock<std::recursive_mutex> 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<std::recursive_mutex> guard(target_sp->GetAPIMutex());
|
|
std::unique_lock<std::recursive_mutex> 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<void *>(m_opaque_sp.get()),
|
|
new_value_sp->GetName().AsCString());
|
|
else
|
|
log->Printf("SBTarget(%p)::CreateValueFromAddress => NULL",
|
|
static_cast<void *>(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<void *>(m_opaque_sp.get()),
|
|
new_value_sp->GetName().AsCString());
|
|
else
|
|
log->Printf("SBTarget(%p)::CreateValueFromData => NULL",
|
|
static_cast<void *>(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<void *>(m_opaque_sp.get()),
|
|
new_value_sp->GetName().AsCString());
|
|
else
|
|
log->Printf("SBTarget(%p)::CreateValueFromExpression => NULL",
|
|
static_cast<void *>(m_opaque_sp.get()));
|
|
}
|
|
return sb_value;
|
|
}
|
|
|
|
bool SBTarget::DeleteAllWatchpoints() {
|
|
TargetSP target_sp(GetSP());
|
|
if (target_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
|
|
std::unique_lock<std::recursive_mutex> 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<void *>(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<void *>(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<void *>(target_sp.get()), idx,
|
|
static_cast<void *>(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<void *>(target_sp.get()),
|
|
static_cast<void *>(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<clang::NamedDecl *> 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<SymbolFile *> 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<clang::NamedDecl *> 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::Status 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<std::recursive_mutex> 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<void *>(frame), expr,
|
|
static_cast<void *>(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(ProcessSP(), 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());
|
|
}
|