forked from OSchip/llvm-project
2694 lines
78 KiB
C++
2694 lines
78 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/lldb-python.h"
|
|
|
|
#include "lldb/API/SBTarget.h"
|
|
|
|
#include "lldb/lldb-public.h"
|
|
|
|
#include "lldb/API/SBDebugger.h"
|
|
#include "lldb/API/SBBreakpoint.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/SBSourceManager.h"
|
|
#include "lldb/API/SBProcess.h"
|
|
#include "lldb/API/SBStream.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/RegularExpression.h"
|
|
#include "lldb/Core/SearchFilter.h"
|
|
#include "lldb/Core/Section.h"
|
|
#include "lldb/Core/STLUtils.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/ObjectFile.h"
|
|
#include "lldb/Symbol/SymbolVendor.h"
|
|
#include "lldb/Symbol/VariableList.h"
|
|
#include "lldb/Target/LanguageRuntime.h"
|
|
#include "lldb/Target/Process.h"
|
|
|
|
#include "lldb/Target/Target.h"
|
|
#include "lldb/Target/TargetList.h"
|
|
|
|
#include "lldb/Interpreter/CommandReturnObject.h"
|
|
#include "../source/Commands/CommandObjectBreakpoint.h"
|
|
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
#define DEFAULT_DISASM_BYTE_SIZE 32
|
|
|
|
SBLaunchInfo::SBLaunchInfo (const char **argv) :
|
|
m_opaque_sp(new ProcessLaunchInfo())
|
|
{
|
|
m_opaque_sp->GetFlags().Reset (eLaunchFlagDebug | eLaunchFlagDisableASLR);
|
|
if (argv && argv[0])
|
|
m_opaque_sp->GetArguments().SetArguments(argv);
|
|
}
|
|
|
|
SBLaunchInfo::~SBLaunchInfo()
|
|
{
|
|
}
|
|
|
|
lldb_private::ProcessLaunchInfo &
|
|
SBLaunchInfo::ref ()
|
|
{
|
|
return *m_opaque_sp;
|
|
}
|
|
|
|
|
|
uint32_t
|
|
SBLaunchInfo::GetUserID()
|
|
{
|
|
return m_opaque_sp->GetUserID();
|
|
}
|
|
|
|
uint32_t
|
|
SBLaunchInfo::GetGroupID()
|
|
{
|
|
return m_opaque_sp->GetGroupID();
|
|
}
|
|
|
|
bool
|
|
SBLaunchInfo::UserIDIsValid ()
|
|
{
|
|
return m_opaque_sp->UserIDIsValid();
|
|
}
|
|
|
|
bool
|
|
SBLaunchInfo::GroupIDIsValid ()
|
|
{
|
|
return m_opaque_sp->GroupIDIsValid();
|
|
}
|
|
|
|
void
|
|
SBLaunchInfo::SetUserID (uint32_t uid)
|
|
{
|
|
m_opaque_sp->SetUserID (uid);
|
|
}
|
|
|
|
void
|
|
SBLaunchInfo::SetGroupID (uint32_t gid)
|
|
{
|
|
m_opaque_sp->SetGroupID (gid);
|
|
}
|
|
|
|
uint32_t
|
|
SBLaunchInfo::GetNumArguments ()
|
|
{
|
|
return m_opaque_sp->GetArguments().GetArgumentCount();
|
|
}
|
|
|
|
const char *
|
|
SBLaunchInfo::GetArgumentAtIndex (uint32_t idx)
|
|
{
|
|
return m_opaque_sp->GetArguments().GetArgumentAtIndex(idx);
|
|
}
|
|
|
|
void
|
|
SBLaunchInfo::SetArguments (const char **argv, bool append)
|
|
{
|
|
if (append)
|
|
{
|
|
if (argv)
|
|
m_opaque_sp->GetArguments().AppendArguments(argv);
|
|
}
|
|
else
|
|
{
|
|
if (argv)
|
|
m_opaque_sp->GetArguments().SetArguments(argv);
|
|
else
|
|
m_opaque_sp->GetArguments().Clear();
|
|
}
|
|
}
|
|
|
|
uint32_t
|
|
SBLaunchInfo::GetNumEnvironmentEntries ()
|
|
{
|
|
return m_opaque_sp->GetEnvironmentEntries().GetArgumentCount();
|
|
}
|
|
|
|
const char *
|
|
SBLaunchInfo::GetEnvironmentEntryAtIndex (uint32_t idx)
|
|
{
|
|
return m_opaque_sp->GetEnvironmentEntries().GetArgumentAtIndex(idx);
|
|
}
|
|
|
|
void
|
|
SBLaunchInfo::SetEnvironmentEntries (const char **envp, bool append)
|
|
{
|
|
if (append)
|
|
{
|
|
if (envp)
|
|
m_opaque_sp->GetEnvironmentEntries().AppendArguments(envp);
|
|
}
|
|
else
|
|
{
|
|
if (envp)
|
|
m_opaque_sp->GetEnvironmentEntries().SetArguments(envp);
|
|
else
|
|
m_opaque_sp->GetEnvironmentEntries().Clear();
|
|
}
|
|
}
|
|
|
|
void
|
|
SBLaunchInfo::Clear ()
|
|
{
|
|
m_opaque_sp->Clear();
|
|
}
|
|
|
|
const char *
|
|
SBLaunchInfo::GetWorkingDirectory () const
|
|
{
|
|
return m_opaque_sp->GetWorkingDirectory();
|
|
}
|
|
|
|
void
|
|
SBLaunchInfo::SetWorkingDirectory (const char *working_dir)
|
|
{
|
|
m_opaque_sp->SetWorkingDirectory(working_dir);
|
|
}
|
|
|
|
uint32_t
|
|
SBLaunchInfo::GetLaunchFlags ()
|
|
{
|
|
return m_opaque_sp->GetFlags().Get();
|
|
}
|
|
|
|
void
|
|
SBLaunchInfo::SetLaunchFlags (uint32_t flags)
|
|
{
|
|
m_opaque_sp->GetFlags().Reset(flags);
|
|
}
|
|
|
|
const char *
|
|
SBLaunchInfo::GetProcessPluginName ()
|
|
{
|
|
return m_opaque_sp->GetProcessPluginName();
|
|
}
|
|
|
|
void
|
|
SBLaunchInfo::SetProcessPluginName (const char *plugin_name)
|
|
{
|
|
return m_opaque_sp->SetProcessPluginName (plugin_name);
|
|
}
|
|
|
|
const char *
|
|
SBLaunchInfo::GetShell ()
|
|
{
|
|
return m_opaque_sp->GetShell();
|
|
}
|
|
|
|
void
|
|
SBLaunchInfo::SetShell (const char * path)
|
|
{
|
|
m_opaque_sp->SetShell (path);
|
|
}
|
|
|
|
uint32_t
|
|
SBLaunchInfo::GetResumeCount ()
|
|
{
|
|
return m_opaque_sp->GetResumeCount();
|
|
}
|
|
|
|
void
|
|
SBLaunchInfo::SetResumeCount (uint32_t c)
|
|
{
|
|
m_opaque_sp->SetResumeCount (c);
|
|
}
|
|
|
|
bool
|
|
SBLaunchInfo::AddCloseFileAction (int fd)
|
|
{
|
|
return m_opaque_sp->AppendCloseFileAction(fd);
|
|
}
|
|
|
|
bool
|
|
SBLaunchInfo::AddDuplicateFileAction (int fd, int dup_fd)
|
|
{
|
|
return m_opaque_sp->AppendDuplicateFileAction(fd, dup_fd);
|
|
}
|
|
|
|
bool
|
|
SBLaunchInfo::AddOpenFileAction (int fd, const char *path, bool read, bool write)
|
|
{
|
|
return m_opaque_sp->AppendOpenFileAction(fd, path, read, write);
|
|
}
|
|
|
|
bool
|
|
SBLaunchInfo::AddSuppressFileAction (int fd, bool read, bool write)
|
|
{
|
|
return m_opaque_sp->AppendSuppressFileAction(fd, read, write);
|
|
}
|
|
|
|
void
|
|
SBLaunchInfo::SetLaunchEventData (const char *data)
|
|
{
|
|
m_opaque_sp->SetLaunchEventData (data);
|
|
}
|
|
|
|
const char *
|
|
SBLaunchInfo::GetLaunchEventData () const
|
|
{
|
|
return m_opaque_sp->GetLaunchEventData ();
|
|
}
|
|
|
|
SBAttachInfo::SBAttachInfo () :
|
|
m_opaque_sp (new ProcessAttachInfo())
|
|
{
|
|
}
|
|
|
|
SBAttachInfo::SBAttachInfo (lldb::pid_t pid) :
|
|
m_opaque_sp (new ProcessAttachInfo())
|
|
{
|
|
m_opaque_sp->SetProcessID (pid);
|
|
}
|
|
|
|
SBAttachInfo::SBAttachInfo (const char *path, bool wait_for) :
|
|
m_opaque_sp (new ProcessAttachInfo())
|
|
{
|
|
if (path && path[0])
|
|
m_opaque_sp->GetExecutableFile().SetFile(path, false);
|
|
m_opaque_sp->SetWaitForLaunch (wait_for);
|
|
}
|
|
|
|
SBAttachInfo::SBAttachInfo (const SBAttachInfo &rhs) :
|
|
m_opaque_sp (new ProcessAttachInfo())
|
|
{
|
|
*m_opaque_sp = *rhs.m_opaque_sp;
|
|
}
|
|
|
|
SBAttachInfo::~SBAttachInfo()
|
|
{
|
|
}
|
|
|
|
lldb_private::ProcessAttachInfo &
|
|
SBAttachInfo::ref ()
|
|
{
|
|
return *m_opaque_sp;
|
|
}
|
|
|
|
SBAttachInfo &
|
|
SBAttachInfo::operator = (const SBAttachInfo &rhs)
|
|
{
|
|
if (this != &rhs)
|
|
*m_opaque_sp = *rhs.m_opaque_sp;
|
|
return *this;
|
|
}
|
|
|
|
lldb::pid_t
|
|
SBAttachInfo::GetProcessID ()
|
|
{
|
|
return m_opaque_sp->GetProcessID();
|
|
}
|
|
|
|
void
|
|
SBAttachInfo::SetProcessID (lldb::pid_t pid)
|
|
{
|
|
m_opaque_sp->SetProcessID (pid);
|
|
}
|
|
|
|
|
|
uint32_t
|
|
SBAttachInfo::GetResumeCount ()
|
|
{
|
|
return m_opaque_sp->GetResumeCount();
|
|
}
|
|
|
|
void
|
|
SBAttachInfo::SetResumeCount (uint32_t c)
|
|
{
|
|
m_opaque_sp->SetResumeCount (c);
|
|
}
|
|
|
|
const char *
|
|
SBAttachInfo::GetProcessPluginName ()
|
|
{
|
|
return m_opaque_sp->GetProcessPluginName();
|
|
}
|
|
|
|
void
|
|
SBAttachInfo::SetProcessPluginName (const char *plugin_name)
|
|
{
|
|
return m_opaque_sp->SetProcessPluginName (plugin_name);
|
|
}
|
|
|
|
void
|
|
SBAttachInfo::SetExecutable (const char *path)
|
|
{
|
|
if (path && path[0])
|
|
m_opaque_sp->GetExecutableFile().SetFile(path, false);
|
|
else
|
|
m_opaque_sp->GetExecutableFile().Clear();
|
|
}
|
|
|
|
void
|
|
SBAttachInfo::SetExecutable (SBFileSpec exe_file)
|
|
{
|
|
if (exe_file.IsValid())
|
|
m_opaque_sp->GetExecutableFile() = exe_file.ref();
|
|
else
|
|
m_opaque_sp->GetExecutableFile().Clear();
|
|
}
|
|
|
|
bool
|
|
SBAttachInfo::GetWaitForLaunch ()
|
|
{
|
|
return m_opaque_sp->GetWaitForLaunch();
|
|
}
|
|
|
|
void
|
|
SBAttachInfo::SetWaitForLaunch (bool b)
|
|
{
|
|
m_opaque_sp->SetWaitForLaunch (b);
|
|
}
|
|
|
|
bool
|
|
SBAttachInfo::GetIgnoreExisting ()
|
|
{
|
|
return m_opaque_sp->GetIgnoreExisting();
|
|
}
|
|
|
|
void
|
|
SBAttachInfo::SetIgnoreExisting (bool b)
|
|
{
|
|
m_opaque_sp->SetIgnoreExisting (b);
|
|
}
|
|
|
|
uint32_t
|
|
SBAttachInfo::GetUserID()
|
|
{
|
|
return m_opaque_sp->GetUserID();
|
|
}
|
|
|
|
uint32_t
|
|
SBAttachInfo::GetGroupID()
|
|
{
|
|
return m_opaque_sp->GetGroupID();
|
|
}
|
|
|
|
bool
|
|
SBAttachInfo::UserIDIsValid ()
|
|
{
|
|
return m_opaque_sp->UserIDIsValid();
|
|
}
|
|
|
|
bool
|
|
SBAttachInfo::GroupIDIsValid ()
|
|
{
|
|
return m_opaque_sp->GroupIDIsValid();
|
|
}
|
|
|
|
void
|
|
SBAttachInfo::SetUserID (uint32_t uid)
|
|
{
|
|
m_opaque_sp->SetUserID (uid);
|
|
}
|
|
|
|
void
|
|
SBAttachInfo::SetGroupID (uint32_t gid)
|
|
{
|
|
m_opaque_sp->SetGroupID (gid);
|
|
}
|
|
|
|
uint32_t
|
|
SBAttachInfo::GetEffectiveUserID()
|
|
{
|
|
return m_opaque_sp->GetEffectiveUserID();
|
|
}
|
|
|
|
uint32_t
|
|
SBAttachInfo::GetEffectiveGroupID()
|
|
{
|
|
return m_opaque_sp->GetEffectiveGroupID();
|
|
}
|
|
|
|
bool
|
|
SBAttachInfo::EffectiveUserIDIsValid ()
|
|
{
|
|
return m_opaque_sp->EffectiveUserIDIsValid();
|
|
}
|
|
|
|
bool
|
|
SBAttachInfo::EffectiveGroupIDIsValid ()
|
|
{
|
|
return m_opaque_sp->EffectiveGroupIDIsValid ();
|
|
}
|
|
|
|
void
|
|
SBAttachInfo::SetEffectiveUserID (uint32_t uid)
|
|
{
|
|
m_opaque_sp->SetEffectiveUserID(uid);
|
|
}
|
|
|
|
void
|
|
SBAttachInfo::SetEffectiveGroupID (uint32_t gid)
|
|
{
|
|
m_opaque_sp->SetEffectiveGroupID(gid);
|
|
}
|
|
|
|
lldb::pid_t
|
|
SBAttachInfo::GetParentProcessID ()
|
|
{
|
|
return m_opaque_sp->GetParentProcessID();
|
|
}
|
|
|
|
void
|
|
SBAttachInfo::SetParentProcessID (lldb::pid_t pid)
|
|
{
|
|
m_opaque_sp->SetParentProcessID (pid);
|
|
}
|
|
|
|
bool
|
|
SBAttachInfo::ParentProcessIDIsValid()
|
|
{
|
|
return m_opaque_sp->ParentProcessIDIsValid();
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
// 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()
|
|
{
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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(),
|
|
NULL,
|
|
&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)
|
|
{
|
|
Mutex::Locker api_locker (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)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
|
|
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 (stdin_path, stdout_path, stderr_path, working_directory, 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())
|
|
error.SetError (target_sp->Launch(listener.ref(), launch_info));
|
|
else
|
|
error.SetError (target_sp->Launch(target_sp->GetDebugger().GetListener(), launch_info));
|
|
|
|
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;
|
|
}
|
|
|
|
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)
|
|
{
|
|
Mutex::Locker api_locker (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();
|
|
|
|
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 (target_sp->GetDebugger().GetListener(), launch_info));
|
|
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;
|
|
ProcessSP process_sp;
|
|
TargetSP target_sp(GetSP());
|
|
|
|
if (log)
|
|
log->Printf ("SBTarget(%p)::Attach (sb_attach_info, error)...",
|
|
static_cast<void*>(target_sp.get()));
|
|
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
|
|
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");
|
|
if (log)
|
|
log->Printf ("SBTarget(%p)::Attach (...) => error %s",
|
|
static_cast<void*>(target_sp.get()),
|
|
error.GetCString());
|
|
return sb_process;
|
|
}
|
|
}
|
|
|
|
if (state != eStateConnected)
|
|
process_sp = target_sp->CreateProcess (target_sp->GetDebugger().GetListener(), NULL, NULL);
|
|
|
|
if (process_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 (process_sp->Attach (attach_info));
|
|
if (error.Success())
|
|
{
|
|
sb_process.SetSP (process_sp);
|
|
// If we are doing synchronous mode, then wait for the
|
|
// process to stop!
|
|
if (target_sp->GetDebugger().GetAsyncExecution () == false)
|
|
process_sp->WaitForProcessToStop (NULL);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
error.SetErrorString ("unable to create lldb_private::Process");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
error.SetErrorString ("SBTarget is invalid");
|
|
}
|
|
|
|
if (log)
|
|
log->Printf ("SBTarget(%p)::Attach (...) => SBProcess(%p)",
|
|
static_cast<void*>(target_sp.get()),
|
|
static_cast<void*>(process_sp.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;
|
|
ProcessSP process_sp;
|
|
TargetSP target_sp(GetSP());
|
|
|
|
if (log)
|
|
log->Printf ("SBTarget(%p)::AttachToProcessWithID (listener, pid=%" PRId64 ", error)...",
|
|
static_cast<void*>(target_sp.get()), pid);
|
|
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
|
|
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;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (listener.IsValid())
|
|
process_sp = target_sp->CreateProcess (listener.ref(), NULL, NULL);
|
|
else
|
|
process_sp = target_sp->CreateProcess (target_sp->GetDebugger().GetListener(), NULL, NULL);
|
|
}
|
|
if (process_sp)
|
|
{
|
|
sb_process.SetSP (process_sp);
|
|
|
|
ProcessAttachInfo attach_info;
|
|
attach_info.SetProcessID (pid);
|
|
|
|
PlatformSP platform_sp = target_sp->GetPlatform();
|
|
ProcessInstanceInfo instance_info;
|
|
if (platform_sp->GetProcessInfo(pid, instance_info))
|
|
{
|
|
attach_info.SetUserID(instance_info.GetEffectiveUserID());
|
|
}
|
|
error.SetError (process_sp->Attach (attach_info));
|
|
if (error.Success())
|
|
{
|
|
// If we are doing synchronous mode, then wait for the
|
|
// process to stop!
|
|
if (target_sp->GetDebugger().GetAsyncExecution () == false)
|
|
process_sp->WaitForProcessToStop (NULL);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
error.SetErrorString ("unable to create lldb_private::Process");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
error.SetErrorString ("SBTarget is invalid");
|
|
}
|
|
|
|
if (log)
|
|
log->Printf ("SBTarget(%p)::AttachToProcessWithID (...) => SBProcess(%p)",
|
|
static_cast<void*>(target_sp.get()),
|
|
static_cast<void*>(process_sp.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;
|
|
ProcessSP process_sp;
|
|
TargetSP target_sp(GetSP());
|
|
|
|
if (log)
|
|
log->Printf ("SBTarget(%p)::AttachToProcessWithName (listener, name=%s, wait_for=%s, error)...",
|
|
static_cast<void*>(target_sp.get()), name,
|
|
wait_for ? "true" : "false");
|
|
|
|
if (name && target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
|
|
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;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (listener.IsValid())
|
|
process_sp = target_sp->CreateProcess (listener.ref(), NULL, NULL);
|
|
else
|
|
process_sp = target_sp->CreateProcess (target_sp->GetDebugger().GetListener(), NULL, NULL);
|
|
}
|
|
|
|
if (process_sp)
|
|
{
|
|
sb_process.SetSP (process_sp);
|
|
ProcessAttachInfo attach_info;
|
|
attach_info.GetExecutableFile().SetFile(name, false);
|
|
attach_info.SetWaitForLaunch(wait_for);
|
|
error.SetError (process_sp->Attach (attach_info));
|
|
if (error.Success())
|
|
{
|
|
// If we are doing synchronous mode, then wait for the
|
|
// process to stop!
|
|
if (target_sp->GetDebugger().GetAsyncExecution () == false)
|
|
process_sp->WaitForProcessToStop (NULL);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
error.SetErrorString ("unable to create lldb_private::Process");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
error.SetErrorString ("SBTarget is invalid");
|
|
}
|
|
|
|
if (log)
|
|
log->Printf ("SBTarget(%p)::AttachToPorcessWithName (...) => SBProcess(%p)",
|
|
static_cast<void*>(target_sp.get()),
|
|
static_cast<void*>(process_sp.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)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
if (listener.IsValid())
|
|
process_sp = target_sp->CreateProcess (listener.ref(), 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)
|
|
{
|
|
Mutex::Locker api_locker (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::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)
|
|
{
|
|
Mutex::Locker api_locker (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;
|
|
}
|
|
|
|
|
|
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)
|
|
{
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
|
|
SBBreakpoint sb_bp;
|
|
TargetSP target_sp(GetSP());
|
|
if (target_sp && line != 0)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
|
|
const LazyBool check_inlines = eLazyBoolCalculate;
|
|
const LazyBool skip_prologue = eLazyBoolCalculate;
|
|
const bool internal = false;
|
|
const bool hardware = false;
|
|
*sb_bp = target_sp->CreateBreakpoint (NULL, *sb_file_spec, line, check_inlines, skip_prologue, internal, hardware);
|
|
}
|
|
|
|
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())
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
|
|
const bool internal = false;
|
|
const bool hardware = false;
|
|
const LazyBool skip_prologue = eLazyBoolCalculate;
|
|
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, skip_prologue, internal, hardware);
|
|
}
|
|
else
|
|
{
|
|
*sb_bp = target_sp->CreateBreakpoint (NULL, NULL, symbol_name, eFunctionNameTypeAuto, 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, 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)
|
|
{
|
|
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;
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
*sb_bp = target_sp->CreateBreakpoint (module_list.get(),
|
|
comp_unit_list.get(),
|
|
symbol_name,
|
|
name_type_mask,
|
|
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)
|
|
{
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
|
|
SBBreakpoint sb_bp;
|
|
TargetSP target_sp(GetSP());
|
|
if (target_sp && num_names > 0)
|
|
{
|
|
Mutex::Locker api_locker (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,
|
|
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)
|
|
{
|
|
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])
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
RegularExpression regexp(symbol_name_regex);
|
|
const bool internal = false;
|
|
const bool hardware = false;
|
|
const LazyBool skip_prologue = eLazyBoolCalculate;
|
|
|
|
if (module_name && module_name[0])
|
|
{
|
|
FileSpecList module_spec_list;
|
|
module_spec_list.Append (FileSpec (module_name, false));
|
|
|
|
*sb_bp = target_sp->CreateFuncRegexBreakpoint (&module_spec_list, NULL, regexp, skip_prologue, internal, hardware);
|
|
}
|
|
else
|
|
{
|
|
*sb_bp = target_sp->CreateFuncRegexBreakpoint (NULL, NULL, regexp, skip_prologue, internal, hardware);
|
|
}
|
|
}
|
|
|
|
if (log)
|
|
log->Printf ("SBTarget(%p)::BreakpointCreateByRegex (symbol_regex=\"%s\", module_name=\"%s\") => SBBreakpoint(%p)",
|
|
static_cast<void*>(target_sp.get()), symbol_name_regex,
|
|
module_name, static_cast<void*>(sb_bp.get()));
|
|
|
|
return sb_bp;
|
|
}
|
|
|
|
lldb::SBBreakpoint
|
|
SBTarget::BreakpointCreateByRegex (const char *symbol_name_regex,
|
|
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])
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
RegularExpression regexp(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, 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)
|
|
{
|
|
Mutex::Locker api_locker (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;
|
|
}
|
|
|
|
lldb::SBBreakpoint
|
|
SBTarget::BreakpointCreateBySourceRegex (const char *source_regex,
|
|
const lldb::SBFileSpec &source_file,
|
|
const char *module_name)
|
|
{
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
|
|
SBBreakpoint sb_bp;
|
|
TargetSP target_sp(GetSP());
|
|
if (target_sp && source_regex && source_regex[0])
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
RegularExpression regexp(source_regex);
|
|
FileSpecList source_file_spec_list;
|
|
const bool hardware = false;
|
|
source_file_spec_list.Append (source_file.ref());
|
|
|
|
if (module_name && module_name[0])
|
|
{
|
|
FileSpecList module_spec_list;
|
|
module_spec_list.Append (FileSpec (module_name, false));
|
|
|
|
*sb_bp = target_sp->CreateSourceRegexBreakpoint (&module_spec_list, &source_file_spec_list, regexp, false, hardware);
|
|
}
|
|
else
|
|
{
|
|
*sb_bp = target_sp->CreateSourceRegexBreakpoint (NULL, &source_file_spec_list, regexp, false, hardware);
|
|
}
|
|
}
|
|
|
|
if (log)
|
|
{
|
|
char path[PATH_MAX];
|
|
source_file->GetPath (path, sizeof(path));
|
|
log->Printf ("SBTarget(%p)::BreakpointCreateByRegex (source_regex=\"%s\", file=\"%s\", module_name=\"%s\") => SBBreakpoint(%p)",
|
|
static_cast<void*>(target_sp.get()), source_regex, path,
|
|
module_name, static_cast<void*>(sb_bp.get()));
|
|
}
|
|
|
|
return sb_bp;
|
|
}
|
|
|
|
lldb::SBBreakpoint
|
|
SBTarget::BreakpointCreateBySourceRegex (const char *source_regex,
|
|
const SBFileSpecList &module_list,
|
|
const lldb::SBFileSpecList &source_file_list)
|
|
{
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
|
|
SBBreakpoint sb_bp;
|
|
TargetSP target_sp(GetSP());
|
|
if (target_sp && source_regex && source_regex[0])
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
const bool hardware = false;
|
|
RegularExpression regexp(source_regex);
|
|
*sb_bp = target_sp->CreateSourceRegexBreakpoint (module_list.get(), source_file_list.get(), regexp, false, hardware);
|
|
}
|
|
|
|
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)
|
|
{
|
|
Mutex::Locker api_locker (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()),
|
|
LanguageRuntime::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)
|
|
{
|
|
Mutex::Locker api_locker (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)
|
|
{
|
|
Mutex::Locker api_locker (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::EnableAllBreakpoints ()
|
|
{
|
|
TargetSP target_sp(GetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
target_sp->EnableAllBreakpoints ();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
SBTarget::DisableAllBreakpoints ()
|
|
{
|
|
TargetSP target_sp(GetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
target_sp->DisableAllBreakpoints ();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
SBTarget::DeleteAllBreakpoints ()
|
|
{
|
|
TargetSP target_sp(GetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
target_sp->RemoveAllBreakpoints ();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
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)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
Mutex::Locker locker;
|
|
target_sp->GetWatchpointList().GetListMutex(locker);
|
|
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)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
Mutex::Locker locker;
|
|
target_sp->GetWatchpointList().GetListMutex(locker);
|
|
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)
|
|
{
|
|
Mutex::Locker api_locker (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.
|
|
ClangASTType *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)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
Mutex::Locker locker;
|
|
target_sp->GetWatchpointList().GetListMutex(locker);
|
|
target_sp->EnableAllWatchpoints ();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
SBTarget::DisableAllWatchpoints ()
|
|
{
|
|
TargetSP target_sp(GetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
Mutex::Locker locker;
|
|
target_sp->GetWatchpointList().GetListMutex(locker);
|
|
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 address(addr.GetLoadAddress(*this));
|
|
lldb::TypeImplSP type_impl_sp (type.GetSP());
|
|
ClangASTType pointer_ast_type(type_impl_sp->GetClangASTType(true).GetPointerType ());
|
|
if (pointer_ast_type)
|
|
{
|
|
lldb::DataBufferSP buffer(new lldb_private::DataBufferHeap(&address,sizeof(lldb::addr_t)));
|
|
|
|
ExecutionContext exe_ctx (ExecutionContextRef(ExecutionContext(m_opaque_sp.get(),false)));
|
|
ValueObjectSP ptr_result_valobj_sp(ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(),
|
|
pointer_ast_type,
|
|
ConstString(name),
|
|
buffer,
|
|
exe_ctx.GetByteOrder(),
|
|
exe_ctx.GetAddressByteSize()));
|
|
|
|
if (ptr_result_valobj_sp)
|
|
{
|
|
ptr_result_valobj_sp->GetValue().SetValueType(Value::eValueTypeLoadAddress);
|
|
Error err;
|
|
new_value_sp = ptr_result_valobj_sp->Dereference(err);
|
|
if (new_value_sp)
|
|
new_value_sp->SetName(ConstString(name));
|
|
}
|
|
}
|
|
}
|
|
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;
|
|
}
|
|
|
|
bool
|
|
SBTarget::DeleteAllWatchpoints ()
|
|
{
|
|
TargetSP target_sp(GetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
Mutex::Locker locker;
|
|
target_sp->GetWatchpointList().GetListMutex(locker);
|
|
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::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::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)
|
|
{
|
|
TypeVendor *objc_type_vendor = objc_language_runtime->GetTypeVendor();
|
|
|
|
if (objc_type_vendor)
|
|
{
|
|
std::vector <ClangASTType> types;
|
|
|
|
if (objc_type_vendor->FindTypes(const_typename, true, 1, types) > 0)
|
|
return SBType(types[0]);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 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;
|
|
|
|
uint32_t num_matches = images.FindTypes (sc,
|
|
const_typename,
|
|
exact_match,
|
|
UINT32_MAX,
|
|
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)
|
|
{
|
|
TypeVendor *objc_type_vendor = objc_language_runtime->GetTypeVendor();
|
|
|
|
if (objc_type_vendor)
|
|
{
|
|
std::vector <ClangASTType> types;
|
|
|
|
if (objc_type_vendor->FindTypes(const_typename, true, UINT32_MAX, types))
|
|
{
|
|
for (ClangASTType &type : types)
|
|
{
|
|
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;
|
|
}
|
|
|
|
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());
|
|
uint32_t stop_id = 0;
|
|
if (process_sp)
|
|
stop_id = process_sp->GetStopID();
|
|
|
|
if (target_sp->SetSectionLoadAddress (section_sp, section_base_addr))
|
|
{
|
|
// 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
|
|
{
|
|
ProcessSP process_sp (target_sp->GetProcessSP());
|
|
uint32_t stop_id = 0;
|
|
if (process_sp)
|
|
stop_id = process_sp->GetStopID();
|
|
|
|
if (target_sp->SetSectionUnloaded (section.GetSP()))
|
|
{
|
|
// Flush info in the process (stack frames, etc)
|
|
if (process_sp)
|
|
process_sp->Flush();
|
|
}
|
|
}
|
|
}
|
|
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());
|
|
uint32_t stop_id = 0;
|
|
if (process_sp)
|
|
stop_id = process_sp->GetStopID();
|
|
|
|
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) > 0;
|
|
}
|
|
if (changed)
|
|
{
|
|
// 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, const SBExpressionOptions &options)
|
|
{
|
|
Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
Log * expr_log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
|
|
SBValue expr_result;
|
|
ExecutionResults exe_results = eExecutionSetupError;
|
|
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;
|
|
}
|
|
|
|
Mutex::Locker api_locker (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);
|
|
Host::SetCrashDescriptionWithFormat ("SBTarget::EvaluateExpression (expr = \"%s\", fetch_dynamic_value = %u) %s",
|
|
expr, options.GetFetchDynamicValue(), frame_description.GetString().c_str());
|
|
#endif
|
|
exe_results = target->EvaluateExpression (expr,
|
|
frame,
|
|
expr_value_sp,
|
|
options.ref());
|
|
|
|
expr_result.SetSP(expr_value_sp, options.GetFetchDynamicValue());
|
|
#ifdef LLDB_CONFIGURATION_DEBUG
|
|
Host::SetCrashDescription (NULL);
|
|
#endif
|
|
}
|
|
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;
|
|
}
|
|
|