mirror of
https://github.com/llvm/llvm-project.git
synced 2025-05-16 19:36:04 +00:00
5569e64ea7
interface (.i) files for each class.
Changed the FindFunction class from:
uint32_t
SBTarget::FindFunctions (const char *name,
uint32_t name_type_mask,
bool append,
lldb::SBSymbolContextList& sc_list)
uint32_t
SBModule::FindFunctions (const char *name,
uint32_t name_type_mask,
bool append,
lldb::SBSymbolContextList& sc_list)
To:
lldb::SBSymbolContextList
SBTarget::FindFunctions (const char *name,
uint32_t name_type_mask = lldb::eFunctionNameTypeAny);
lldb::SBSymbolContextList
SBModule::FindFunctions (const char *name,
uint32_t name_type_mask = lldb::eFunctionNameTypeAny);
This makes the API easier to use from python. Also added the ability to
append a SBSymbolContext or a SBSymbolContextList to a SBSymbolContextList.
Exposed properties for lldb.SBSymbolContextList in python:
lldb.SBSymbolContextList.modules => list() or all lldb.SBModule objects in the list
lldb.SBSymbolContextList.compile_units => list() or all lldb.SBCompileUnits objects in the list
lldb.SBSymbolContextList.functions => list() or all lldb.SBFunction objects in the list
lldb.SBSymbolContextList.blocks => list() or all lldb.SBBlock objects in the list
lldb.SBSymbolContextList.line_entries => list() or all lldb.SBLineEntry objects in the list
lldb.SBSymbolContextList.symbols => list() or all lldb.SBSymbol objects in the list
This allows a call to the SBTarget::FindFunctions(...) and SBModule::FindFunctions(...)
and then the result can be used to extract the desired information:
sc_list = lldb.target.FindFunctions("erase")
for function in sc_list.functions:
print function
for symbol in sc_list.symbols:
print symbol
Exposed properties for the lldb.SBSymbolContext objects in python:
lldb.SBSymbolContext.module => lldb.SBModule
lldb.SBSymbolContext.compile_unit => lldb.SBCompileUnit
lldb.SBSymbolContext.function => lldb.SBFunction
lldb.SBSymbolContext.block => lldb.SBBlock
lldb.SBSymbolContext.line_entry => lldb.SBLineEntry
lldb.SBSymbolContext.symbol => lldb.SBSymbol
Exposed properties for the lldb.SBBlock objects in python:
lldb.SBBlock.parent => lldb.SBBlock for the parent block that contains
lldb.SBBlock.sibling => lldb.SBBlock for the sibling block to the current block
lldb.SBBlock.first_child => lldb.SBBlock for the first child block to the current block
lldb.SBBlock.call_site => for inline functions, return a lldb.declaration object that gives the call site file, line and column
lldb.SBBlock.name => for inline functions this is the name of the inline function that this block represents
lldb.SBBlock.inlined_block => returns the inlined function block that contains this block (might return itself if the current block is an inlined block)
lldb.SBBlock.range[int] => access the address ranges for a block by index, a list() with start and end address is returned
lldb.SBBlock.ranges => an array or all address ranges for this block
lldb.SBBlock.num_ranges => the number of address ranges for this blcok
SBFunction objects can now get the SBType and the SBBlock that represents the
top scope of the function.
SBBlock objects can now get the variable list from the current block. The value
list returned allows varaibles to be viewed prior with no process if code
wants to check the variables in a function. There are two ways to get a variable
list from a SBBlock:
lldb::SBValueList
SBBlock::GetVariables (lldb::SBFrame& frame,
bool arguments,
bool locals,
bool statics,
lldb::DynamicValueType use_dynamic);
lldb::SBValueList
SBBlock::GetVariables (lldb::SBTarget& target,
bool arguments,
bool locals,
bool statics);
When a SBFrame is used, the values returned will be locked down to the frame
and the values will be evaluated in the context of that frame.
When a SBTarget is used, global an static variables can be viewed without a
running process.
llvm-svn: 149853
1543 lines
43 KiB
C++
1543 lines
43 KiB
C++
//===-- SBTarget.cpp --------------------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lldb/API/SBTarget.h"
|
|
|
|
#include "lldb/lldb-public.h"
|
|
|
|
#include "lldb/API/SBDebugger.h"
|
|
#include "lldb/API/SBBreakpoint.h"
|
|
#include "lldb/API/SBFileSpec.h"
|
|
#include "lldb/API/SBListener.h"
|
|
#include "lldb/API/SBModule.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/RegularExpression.h"
|
|
#include "lldb/Core/SearchFilter.h"
|
|
#include "lldb/Core/STLUtils.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/SymbolVendor.h"
|
|
#include "lldb/Symbol/VariableList.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
|
|
|
|
//----------------------------------------------------------------------
|
|
// 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::IsValid () const
|
|
{
|
|
return m_opaque_sp.get() != NULL;
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
{
|
|
log->Printf ("SBTarget(%p)::GetProcess () => SBProcess(%p)",
|
|
target_sp.get(), 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::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);
|
|
}
|
|
|
|
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
|
|
)
|
|
{
|
|
LogSP 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))...",
|
|
target_sp.get(),
|
|
argv,
|
|
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,
|
|
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;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (listener.IsValid())
|
|
process_sp = target_sp->CreateProcess (listener.ref());
|
|
else
|
|
process_sp = target_sp->CreateProcess (target_sp->GetDebugger().GetListener());
|
|
}
|
|
|
|
if (process_sp)
|
|
{
|
|
sb_process.SetSP (process_sp);
|
|
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);
|
|
|
|
error.SetError (process_sp->Launch (launch_info));
|
|
if (error.Success())
|
|
{
|
|
// We we are stopping at the entry point, we can return now!
|
|
if (stop_at_entry)
|
|
return sb_process;
|
|
|
|
// Make sure we are stopped at the entry
|
|
StateType state = process_sp->WaitForProcessToStop (NULL);
|
|
if (state == eStateStopped)
|
|
{
|
|
// resume the process to skip the entry point
|
|
error.SetError (process_sp->Resume());
|
|
if (error.Success())
|
|
{
|
|
// If we are doing synchronous mode, then wait for the
|
|
// process to stop yet again!
|
|
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");
|
|
}
|
|
|
|
log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API);
|
|
if (log)
|
|
{
|
|
log->Printf ("SBTarget(%p)::Launch (...) => SBProceess(%p)",
|
|
target_sp.get(), 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
|
|
)
|
|
{
|
|
SBProcess sb_process;
|
|
ProcessSP process_sp;
|
|
TargetSP target_sp(GetSP());
|
|
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());
|
|
else
|
|
process_sp = target_sp->CreateProcess (target_sp->GetDebugger().GetListener());
|
|
}
|
|
if (process_sp)
|
|
{
|
|
sb_process.SetSP (process_sp);
|
|
|
|
ProcessAttachInfo attach_info;
|
|
attach_info.SetProcessID (pid);
|
|
error.SetError (process_sp->Attach (attach_info));
|
|
// 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");
|
|
}
|
|
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
|
|
)
|
|
{
|
|
SBProcess sb_process;
|
|
ProcessSP process_sp;
|
|
TargetSP target_sp(GetSP());
|
|
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());
|
|
else
|
|
process_sp = target_sp->CreateProcess (target_sp->GetDebugger().GetListener());
|
|
}
|
|
|
|
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 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");
|
|
}
|
|
return sb_process;
|
|
|
|
}
|
|
|
|
lldb::SBProcess
|
|
SBTarget::ConnectRemote
|
|
(
|
|
SBListener &listener,
|
|
const char *url,
|
|
const char *plugin_name,
|
|
SBError& error
|
|
)
|
|
{
|
|
SBProcess sb_process;
|
|
ProcessSP process_sp;
|
|
TargetSP target_sp(GetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
if (listener.IsValid())
|
|
process_sp = target_sp->CreateProcess (listener.ref(), plugin_name);
|
|
else
|
|
process_sp = target_sp->CreateProcess (target_sp->GetDebugger().GetListener(), plugin_name);
|
|
|
|
|
|
if (process_sp)
|
|
{
|
|
sb_process.SetSP (process_sp);
|
|
error.SetError (process_sp->ConnectRemote (url));
|
|
}
|
|
else
|
|
{
|
|
error.SetErrorString ("unable to create lldb_private::Process");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
error.SetErrorString ("SBTarget is invalid");
|
|
}
|
|
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());
|
|
}
|
|
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
{
|
|
log->Printf ("SBTarget(%p)::GetExecutable () => SBFileSpec(%p)",
|
|
target_sp.get(), 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->GetSectionLoadList().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.SetSection(NULL);
|
|
addr.SetOffset(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)
|
|
{
|
|
LogSP 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());
|
|
*sb_bp = target_sp->CreateBreakpoint (NULL, *sb_file_spec, line, true, false);
|
|
}
|
|
|
|
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",
|
|
target_sp.get(),
|
|
path,
|
|
line,
|
|
sb_bp.get(),
|
|
sstr.GetData());
|
|
}
|
|
|
|
return sb_bp;
|
|
}
|
|
|
|
SBBreakpoint
|
|
SBTarget::BreakpointCreateByName (const char *symbol_name, const char *module_name)
|
|
{
|
|
LogSP 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());
|
|
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, false);
|
|
}
|
|
else
|
|
{
|
|
*sb_bp = target_sp->CreateBreakpoint (NULL, NULL, symbol_name, eFunctionNameTypeAuto, false);
|
|
}
|
|
}
|
|
|
|
if (log)
|
|
{
|
|
log->Printf ("SBTarget(%p)::BreakpointCreateByName (symbol=\"%s\", module=\"%s\") => SBBreakpoint(%p)",
|
|
target_sp.get(), symbol_name, module_name, 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)
|
|
{
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
|
|
SBBreakpoint sb_bp;
|
|
TargetSP target_sp(GetSP());
|
|
if (target_sp && symbol_name && symbol_name[0])
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
*sb_bp = target_sp->CreateBreakpoint (module_list.get(),
|
|
comp_unit_list.get(),
|
|
symbol_name,
|
|
name_type_mask,
|
|
false);
|
|
}
|
|
|
|
if (log)
|
|
{
|
|
log->Printf ("SBTarget(%p)::BreakpointCreateByName (symbol=\"%s\", name_type: %d) => SBBreakpoint(%p)",
|
|
target_sp.get(), symbol_name, name_type_mask, sb_bp.get());
|
|
}
|
|
|
|
return sb_bp;
|
|
}
|
|
|
|
|
|
SBBreakpoint
|
|
SBTarget::BreakpointCreateByRegex (const char *symbol_name_regex, const char *module_name)
|
|
{
|
|
LogSP 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);
|
|
|
|
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, false);
|
|
}
|
|
else
|
|
{
|
|
*sb_bp = target_sp->CreateFuncRegexBreakpoint (NULL, NULL, regexp, false);
|
|
}
|
|
}
|
|
|
|
if (log)
|
|
{
|
|
log->Printf ("SBTarget(%p)::BreakpointCreateByRegex (symbol_regex=\"%s\", module_name=\"%s\") => SBBreakpoint(%p)",
|
|
target_sp.get(), symbol_name_regex, module_name, sb_bp.get());
|
|
}
|
|
|
|
return sb_bp;
|
|
}
|
|
|
|
lldb::SBBreakpoint
|
|
SBTarget::BreakpointCreateByRegex (const char *symbol_name_regex,
|
|
const SBFileSpecList &module_list,
|
|
const SBFileSpecList &comp_unit_list)
|
|
{
|
|
LogSP 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);
|
|
|
|
*sb_bp = target_sp->CreateFuncRegexBreakpoint (module_list.get(), comp_unit_list.get(), regexp, false);
|
|
}
|
|
|
|
if (log)
|
|
{
|
|
log->Printf ("SBTarget(%p)::BreakpointCreateByRegex (symbol_regex=\"%s\") => SBBreakpoint(%p)",
|
|
target_sp.get(), symbol_name_regex, sb_bp.get());
|
|
}
|
|
|
|
return sb_bp;
|
|
}
|
|
|
|
SBBreakpoint
|
|
SBTarget::BreakpointCreateByAddress (addr_t address)
|
|
{
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
|
|
SBBreakpoint sb_bp;
|
|
TargetSP target_sp(GetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
*sb_bp = target_sp->CreateBreakpoint (address, false);
|
|
}
|
|
|
|
if (log)
|
|
{
|
|
log->Printf ("SBTarget(%p)::BreakpointCreateByAddress (address=%llu) => SBBreakpoint(%p)", target_sp.get(), (uint64_t) address, sb_bp.get());
|
|
}
|
|
|
|
return sb_bp;
|
|
}
|
|
|
|
lldb::SBBreakpoint
|
|
SBTarget::BreakpointCreateBySourceRegex (const char *source_regex, const lldb::SBFileSpec &source_file, const char *module_name)
|
|
{
|
|
LogSP 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;
|
|
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);
|
|
}
|
|
else
|
|
{
|
|
*sb_bp = target_sp->CreateSourceRegexBreakpoint (NULL, &source_file_spec_list, regexp, false);
|
|
}
|
|
}
|
|
|
|
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)",
|
|
target_sp.get(), source_regex, path, module_name, sb_bp.get());
|
|
}
|
|
|
|
return sb_bp;
|
|
}
|
|
|
|
lldb::SBBreakpoint
|
|
SBTarget::BreakpointCreateBySourceRegex (const char *source_regex,
|
|
const SBFileSpecList &module_list,
|
|
const lldb::SBFileSpecList &source_file_list)
|
|
{
|
|
LogSP 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);
|
|
*sb_bp = target_sp->CreateSourceRegexBreakpoint (module_list.get(), source_file_list.get(), regexp, false);
|
|
}
|
|
|
|
if (log)
|
|
{
|
|
log->Printf ("SBTarget(%p)::BreakpointCreateByRegex (source_regex=\"%s\") => SBBreakpoint(%p)",
|
|
target_sp.get(), source_regex, 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)
|
|
{
|
|
LogSP 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", target_sp.get(), (uint32_t) bp_id, result);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
SBBreakpoint
|
|
SBTarget::FindBreakpointByID (break_id_t bp_id)
|
|
{
|
|
LogSP 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)",
|
|
target_sp.get(), (uint32_t) bp_id, 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)
|
|
{
|
|
LogSP 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->RemoveWatchpointByID (wp_id);
|
|
}
|
|
|
|
if (log)
|
|
{
|
|
log->Printf ("SBTarget(%p)::WatchpointDelete (wp_id=%d) => %i", target_sp.get(), (uint32_t) wp_id, result);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
SBWatchpoint
|
|
SBTarget::FindWatchpointByID (lldb::watch_id_t wp_id)
|
|
{
|
|
LogSP 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());
|
|
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)",
|
|
target_sp.get(), (uint32_t) wp_id, watchpoint_sp.get());
|
|
}
|
|
|
|
return sb_watchpoint;
|
|
}
|
|
|
|
lldb::SBWatchpoint
|
|
SBTarget::WatchAddress (lldb::addr_t addr, size_t size, bool read, bool write)
|
|
{
|
|
LogSP 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;
|
|
watchpoint_sp = target_sp->CreateWatchpoint(addr, size, watch_type);
|
|
sb_watchpoint.SetSP (watchpoint_sp);
|
|
}
|
|
|
|
if (log)
|
|
{
|
|
log->Printf ("SBTarget(%p)::WatchAddress (addr=0x%llx, 0x%u) => SBWatchpoint(%p)",
|
|
target_sp.get(), addr, (uint32_t) size, watchpoint_sp.get());
|
|
}
|
|
|
|
return sb_watchpoint;
|
|
}
|
|
|
|
bool
|
|
SBTarget::EnableAllWatchpoints ()
|
|
{
|
|
TargetSP target_sp(GetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
target_sp->EnableAllWatchpoints ();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
SBTarget::DisableAllWatchpoints ()
|
|
{
|
|
TargetSP target_sp(GetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
target_sp->DisableAllWatchpoints ();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
SBTarget::DeleteAllWatchpoints ()
|
|
{
|
|
TargetSP target_sp(GetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
target_sp->RemoveAllWatchpoints ();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
lldb::SBModule
|
|
SBTarget::AddModule (const char *path,
|
|
const char *triple,
|
|
const char *uuid_cstr)
|
|
{
|
|
lldb::SBModule sb_module;
|
|
TargetSP target_sp(GetSP());
|
|
if (target_sp)
|
|
{
|
|
FileSpec module_file_spec;
|
|
UUID module_uuid;
|
|
ArchSpec module_arch;
|
|
|
|
if (path)
|
|
module_file_spec.SetFile(path, false);
|
|
|
|
if (uuid_cstr)
|
|
module_uuid.SetfromCString(uuid_cstr);
|
|
|
|
if (triple)
|
|
module_arch.SetTriple (triple, target_sp->GetPlatform ().get());
|
|
|
|
sb_module.SetSP(target_sp->GetSharedModule (module_file_spec,
|
|
module_arch,
|
|
uuid_cstr ? &module_uuid : NULL));
|
|
}
|
|
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
|
|
{
|
|
LogSP 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", target_sp.get(), num);
|
|
|
|
return num;
|
|
}
|
|
|
|
void
|
|
SBTarget::Clear ()
|
|
{
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
|
|
if (log)
|
|
log->Printf ("SBTarget(%p)::Clear ()", 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())
|
|
{
|
|
// The module list is thread safe, no need to lock
|
|
sb_module.SetSP (target_sp->GetImages().FindFirstModuleForFileSpec (*sb_file_spec, NULL, NULL));
|
|
}
|
|
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)
|
|
{
|
|
LogSP 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)",
|
|
target_sp.get(), idx, 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
|
|
{
|
|
LogSP 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)",
|
|
target_sp.get(), 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 append = true;
|
|
target_sp->GetImages().FindFunctions (ConstString(name),
|
|
name_type_mask,
|
|
symbols_ok,
|
|
append,
|
|
*sb_sc_list);
|
|
}
|
|
}
|
|
return sb_sc_list;
|
|
}
|
|
|
|
lldb::SBType
|
|
SBTarget::FindFirstType (const char* type)
|
|
{
|
|
TargetSP target_sp(GetSP());
|
|
if (type && target_sp)
|
|
{
|
|
size_t count = target_sp->GetImages().GetSize();
|
|
for (size_t idx = 0; idx < count; idx++)
|
|
{
|
|
SBType found_at_idx = GetModuleAtIndex(idx).FindFirstType(type);
|
|
|
|
if (found_at_idx.IsValid())
|
|
return found_at_idx;
|
|
}
|
|
}
|
|
return SBType();
|
|
}
|
|
|
|
lldb::SBTypeList
|
|
SBTarget::FindTypes (const char* type)
|
|
{
|
|
|
|
SBTypeList retval;
|
|
|
|
TargetSP target_sp(GetSP());
|
|
if (type && target_sp)
|
|
{
|
|
ModuleList& images = target_sp->GetImages();
|
|
ConstString name_const(type);
|
|
SymbolContext sc;
|
|
TypeList type_list;
|
|
|
|
uint32_t num_matches = images.FindTypes(sc,
|
|
name_const,
|
|
true,
|
|
UINT32_MAX,
|
|
type_list);
|
|
|
|
for (size_t idx = 0; idx < num_matches; idx++)
|
|
{
|
|
TypeSP type_sp (type_list.GetTypeAtIndex(idx));
|
|
if (type_sp)
|
|
retval.Append(SBType(type_sp));
|
|
}
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
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();
|
|
ValueObjectList &value_object_list = sb_value_list.ref();
|
|
for (uint32_t i=0; i<match_count; ++i)
|
|
{
|
|
lldb::ValueObjectSP valobj_sp (ValueObjectVariable::Create (exe_scope, variable_list.GetVariableAtIndex(i)));
|
|
if (valobj_sp)
|
|
value_object_list.Append(valobj_sp);
|
|
}
|
|
}
|
|
}
|
|
|
|
return sb_value_list;
|
|
}
|
|
|
|
SBSourceManager
|
|
SBTarget::GetSourceManager()
|
|
{
|
|
SBSourceManager source_manager (*this);
|
|
return source_manager;
|
|
}
|
|
|
|
lldb::SBInstructionList
|
|
SBTarget::GetInstructions (lldb::SBAddress base_addr, 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();
|
|
|
|
sb_instructions.SetDisassembler (Disassembler::DisassembleBytes (target_sp->GetArchitecture(),
|
|
NULL,
|
|
addr,
|
|
buf,
|
|
size));
|
|
}
|
|
|
|
return sb_instructions;
|
|
}
|
|
|
|
lldb::SBInstructionList
|
|
SBTarget::GetInstructions (lldb::addr_t base_addr, const void *buf, size_t size)
|
|
{
|
|
return GetInstructions (ResolveLoadAddress(base_addr), 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
|
|
{
|
|
target_sp->GetSectionLoadList().SetSectionLoadAddress (section.GetSection(), section_base_addr);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sb_error.SetErrorStringWithFormat ("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
|
|
{
|
|
target_sp->GetSectionLoadList().SetSectionUnloaded (section.GetSection());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sb_error.SetErrorStringWithFormat ("invalid target");
|
|
}
|
|
return sb_error;
|
|
}
|
|
|
|
SBError
|
|
SBTarget::SetModuleLoadAddress (lldb::SBModule module, int64_t slide_offset)
|
|
{
|
|
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)
|
|
{
|
|
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)
|
|
target_sp->GetSectionLoadList().SetSectionLoadAddress (section_sp.get(), section_sp->GetFileAddress() + slide_offset);
|
|
}
|
|
}
|
|
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;
|
|
}
|
|
|
|
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)
|
|
{
|
|
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)
|
|
target_sp->GetSectionLoadList().SetSectionUnloaded (section_sp.get());
|
|
}
|
|
}
|
|
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;
|
|
}
|
|
|
|
|