Magic-Mirror/llvm-capstone
1
0
Fork 0
mirror of https://github.com/capstone-engine/llvm-capstone.git synced 2025-01-08 00:52:54 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity
a2fc1e0cc8
llvm-capstone/lldb/source/API/SBTarget.cpp
Zachary Turner bf9a77305f Move classes from Core -> Utility. 
This moves the following classes from Core -> Utility.

ConstString
Error
RegularExpression
Stream
StreamString

The goal here is to get lldbUtility into a state where it has
no dependendencies except on itself and LLVM, so it can be the
starting point at which to start untangling LLDB's dependencies.
These are all low level and very widely used classes, and
previously lldbUtility had dependencies up to lldbCore in order
to use these classes.  So moving then down to lldbUtility makes
sense from both the short term and long term perspective in
solving this problem.

Differential Revision: https://reviews.llvm.org/D29427

llvm-svn: 293941
2017-02-02 21:39:50 +00:00

2193 lines
72 KiB
C++
Raw Blame History

//===-- 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/Log.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/FileSpec.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/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<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 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<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;
}
#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<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.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.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.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.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.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.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.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.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.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.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.
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<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::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<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(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());
}
Reference in New Issue View Git Blame Copy Permalink