SBTarget
SBDebugger::GetSelectedTarget ()
{
Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
SBTarget sb_target;
TargetSP target_sp;
if (m_opaque_sp)
{
// No need to lock, the target list is thread safe
target_sp = m_opaque_sp->GetTargetList().GetSelectedTarget ();
sb_target.SetSP (target_sp);
}
if (log)
{
SBStream sstr;
sb_target.GetDescription (sstr, eDescriptionLevelBrief);
log->Printf ("SBDebugger(%p)::GetSelectedTarget () => SBTarget(%p): %s",
static_cast<void*>(m_opaque_sp.get()),
static_cast<void*>(target_sp.get()), sstr.GetData());
}
return sb_target;
}
bool
SBProcess::RemoteAttachToProcessWithID (lldb::pid_t pid, lldb::SBError& error)
{
ProcessSP process_sp(GetSP());
if (process_sp)
{
Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
if (process_sp->GetState() == eStateConnected)
{
ProcessAttachInfo attach_info;
attach_info.SetProcessID (pid);
error.SetError (process_sp->Attach (attach_info));
}
else
{
error.SetErrorString ("must be in eStateConnected to call RemoteAttachToProcessWithID");
}
}
else
{
error.SetErrorString ("unable to attach pid");
}
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
if (log) {
SBStream sstr;
error.GetDescription (sstr);
log->Printf ("SBProcess(%p)::RemoteAttachToProcessWithID (%" PRIu64 ") => SBError (%p): %s",
static_cast<void*>(process_sp.get()), pid,
static_cast<void*>(error.get()), sstr.GetData());
}
return error.Success();
}
SBError
SBProcess::Continue ()
{
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
SBError sb_error;
ProcessSP process_sp(GetSP());
if (log)
log->Printf ("SBProcess(%p)::Continue ()...",
static_cast<void*>(process_sp.get()));
if (process_sp)
{
Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
if (process_sp->GetTarget().GetDebugger().GetAsyncExecution ())
sb_error.ref() = process_sp->Resume ();
else
sb_error.ref() = process_sp->ResumeSynchronous (NULL);
}
else
sb_error.SetErrorString ("SBProcess is invalid");
if (log)
{
SBStream sstr;
sb_error.GetDescription (sstr);
log->Printf ("SBProcess(%p)::Continue () => SBError (%p): %s",
static_cast<void*>(process_sp.get()),
static_cast<void*>(sb_error.get()), sstr.GetData());
}
return sb_error;
}
SBLineEntry
SBCompileUnit::GetLineEntryAtIndex (uint32_t idx) const
{
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
SBLineEntry sb_line_entry;
if (m_opaque_ptr)
{
LineTable *line_table = m_opaque_ptr->GetLineTable ();
if (line_table)
{
LineEntry line_entry;
if (line_table->GetLineEntryAtIndex(idx, line_entry))
sb_line_entry.SetLineEntry(line_entry);
}
}
if (log)
{
SBStream sstr;
sb_line_entry.GetDescription (sstr);
log->Printf ("SBCompileUnit(%p)::GetLineEntryAtIndex (idx=%u) => SBLineEntry(%p): '%s'",
static_cast<void*>(m_opaque_ptr), idx,
static_cast<void*>(sb_line_entry.get()), sstr.GetData());
}
return sb_line_entry;
}
SBError
SBProcess::Kill ()
{
SBError sb_error;
if (m_opaque_sp)
{
Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
sb_error.SetError (m_opaque_sp->Destroy());
}
else
sb_error.SetErrorString ("SBProcess is invalid");
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
if (log)
{
SBStream sstr;
sb_error.GetDescription (sstr);
log->Printf ("SBProcess(%p)::Kill () => SBError (%p): %s",
m_opaque_sp.get(),
sb_error.get(),
sstr.GetData());
}
return sb_error;
}
SBError
SBProcess::Signal (int signo)
{
SBError sb_error;
ProcessSP process_sp(GetSP());
if (process_sp)
{
Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
sb_error.SetError (process_sp->Signal (signo));
}
else
sb_error.SetErrorString ("SBProcess is invalid");
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
if (log)
{
SBStream sstr;
sb_error.GetDescription (sstr);
log->Printf ("SBProcess(%p)::Signal (signo=%i) => SBError (%p): %s",
process_sp.get(),
signo,
sb_error.get(),
sstr.GetData());
}
return sb_error;
}
void listener_func() {
while (!g_done) {
SBEvent event;
bool got_event = g_listener.WaitForEvent(1, event);
if (got_event) {
if (!event.IsValid())
throw Exception("event is not valid in listener thread");
// send process description
SBProcess process = SBProcess::GetProcessFromEvent(event);
SBStream description;
for (int i = 0; i < process.GetNumThreads(); ++i) {
// send each thread description
description.Clear();
SBThread thread = process.GetThreadAtIndex(i);
thread.GetDescription(description);
g_thread_descriptions.push(description.GetData());
// send each frame function name
uint32_t num_frames = thread.GetNumFrames();
for(int j = 0; j < num_frames; ++j) {
const char* function_name = thread.GetFrameAtIndex(j).GetSymbol().GetName();
if (function_name)
g_frame_functions.push(function_name);
}
}
}
}
}
SBFileSpec
SBCompileUnit::GetSupportFileAtIndex (uint32_t idx) const
{
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
SBFileSpec sb_file_spec;
if (m_opaque_ptr)
{
FileSpecList &support_files = m_opaque_ptr->GetSupportFiles ();
FileSpec file_spec = support_files.GetFileSpecAtIndex(idx);
sb_file_spec.SetFileSpec(file_spec);
}
if (log)
{
SBStream sstr;
sb_file_spec.GetDescription (sstr);
log->Printf ("SBCompileUnit(%p)::GetGetFileSpecAtIndex (idx=%u) => SBFileSpec(%p): '%s'",
static_cast<void*>(m_opaque_ptr), idx,
static_cast<const void*>(sb_file_spec.get()),
sstr.GetData());
}
return sb_file_spec;
}
SBError
SBProcess::Kill ()
{
SBError sb_error;
ProcessSP process_sp(GetSP());
if (process_sp)
{
Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
sb_error.SetError (process_sp->Destroy(true));
}
else
sb_error.SetErrorString ("SBProcess is invalid");
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
if (log)
{
SBStream sstr;
sb_error.GetDescription (sstr);
log->Printf ("SBProcess(%p)::Kill () => SBError (%p): %s",
static_cast<void*>(process_sp.get()),
static_cast<void*>(sb_error.get()), sstr.GetData());
}
return sb_error;
}
void
SBCommandInterpreter::HandleCommandsFromFile (lldb::SBFileSpec &file,
lldb::SBExecutionContext &override_context,
lldb::SBCommandInterpreterRunOptions &options,
lldb::SBCommandReturnObject result)
{
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
if (log)
{
SBStream s;
file.GetDescription (s);
log->Printf ("SBCommandInterpreter(%p)::HandleCommandsFromFile (file=\"%s\", SBCommandReturnObject(%p))",
static_cast<void*>(m_opaque_ptr), s.GetData(),
static_cast<void*>(result.get()));
}
if (!IsValid())
{
result->AppendError ("SBCommandInterpreter is not valid.");
result->SetStatus (eReturnStatusFailed);
return;
}
if (!file.IsValid())
{
SBStream s;
file.GetDescription (s);
result->AppendErrorWithFormat ("File is not valid: %s.", s.GetData());
result->SetStatus (eReturnStatusFailed);
}
FileSpec tmp_spec = file.ref();
ExecutionContext ctx, *ctx_ptr;
if (override_context.get())
{
ctx = override_context.get()->Lock(true);
ctx_ptr = &ctx;
}
else
ctx_ptr = nullptr;
m_opaque_ptr->HandleCommandsFromFile (tmp_spec, ctx_ptr, options.ref(), result.ref());
}
size_t
SBProcess::ReadMemory (addr_t addr, void *dst, size_t dst_len, SBError &sb_error)
{
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
size_t bytes_read = 0;
ProcessSP process_sp(GetSP());
if (log)
{
log->Printf ("SBProcess(%p)::ReadMemory (addr=0x%llx, dst=%p, dst_len=%zu, SBError (%p))...",
process_sp.get(),
addr,
dst,
dst_len,
sb_error.get());
}
if (process_sp)
{
Process::StopLocker stop_locker;
if (stop_locker.TryLock(&process_sp->GetRunLock()))
{
Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
bytes_read = process_sp->ReadMemory (addr, dst, dst_len, sb_error.ref());
}
else
{
if (log)
log->Printf ("SBProcess(%p)::ReadMemory() => error: process is running", process_sp.get());
sb_error.SetErrorString("process is running");
}
}
else
{
sb_error.SetErrorString ("SBProcess is invalid");
}
if (log)
{
SBStream sstr;
sb_error.GetDescription (sstr);
log->Printf ("SBProcess(%p)::ReadMemory (addr=0x%llx, dst=%p, dst_len=%zu, SBError (%p): %s) => %zu",
process_sp.get(),
addr,
dst,
dst_len,
sb_error.get(),
sstr.GetData(),
bytes_read);
}
return bytes_read;
}
bool SBThread::GetInfoItemByPathAsString(const char *path, SBStream &strm) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
bool success = false;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
if (exe_ctx.HasThreadScope()) {
Process::StopLocker stop_locker;
if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
Thread *thread = exe_ctx.GetThreadPtr();
StructuredData::ObjectSP info_root_sp = thread->GetExtendedInfo();
if (info_root_sp) {
StructuredData::ObjectSP node =
info_root_sp->GetObjectForDotSeparatedPath(path);
if (node) {
if (node->GetType() == eStructuredDataTypeString) {
strm.Printf("%s", node->GetAsString()->GetValue().str().c_str());
success = true;
}
if (node->GetType() == eStructuredDataTypeInteger) {
strm.Printf("0x%" PRIx64, node->GetAsInteger()->GetValue());
success = true;
}
if (node->GetType() == eStructuredDataTypeFloat) {
strm.Printf("0x%f", node->GetAsFloat()->GetValue());
success = true;
}
if (node->GetType() == eStructuredDataTypeBoolean) {
if (node->GetAsBoolean()->GetValue() == true)
strm.Printf("true");
else
strm.Printf("false");
success = true;
}
if (node->GetType() == eStructuredDataTypeNull) {
strm.Printf("null");
success = true;
}
}
}
} else {
if (log)
log->Printf("SBThread(%p)::GetInfoItemByPathAsString() => error: "
"process is running",
static_cast<void *>(exe_ctx.GetThreadPtr()));
}
}
if (log)
log->Printf("SBThread(%p)::GetInfoItemByPathAsString (\"%s\") => \"%s\"",
static_cast<void *>(exe_ctx.GetThreadPtr()), path, strm.GetData());
return success;
}
SBWatchpoint::SBWatchpoint(const lldb::WatchpointSP &wp_sp)
: m_opaque_sp(wp_sp) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log) {
SBStream sstr;
GetDescription(sstr, lldb::eDescriptionLevelBrief);
log->Printf("SBWatchpoint::SBWatchpoint (const lldb::WatchpointSP &wp_sp"
"=%p) => this.sp = %p (%s)",
static_cast<void *>(wp_sp.get()),
static_cast<void *>(m_opaque_sp.get()), sstr.GetData());
}
}
size_t
SBProcess::WriteMemory (addr_t addr, const void *src, size_t src_len, SBError &sb_error)
{
size_t bytes_written = 0;
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
ProcessSP process_sp(GetSP());
if (log)
{
log->Printf ("SBProcess(%p)::WriteMemory (addr=0x%llx, src=%p, src_len=%llu, SBError (%p))...",
process_sp.get(),
addr,
src,
(uint64_t)src_len,
sb_error.get());
}
if (process_sp)
{
Process::StopLocker stop_locker;
if (stop_locker.TryLock(&process_sp->GetRunLock()))
{
Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
bytes_written = process_sp->WriteMemory (addr, src, src_len, sb_error.ref());
}
else
{
if (log)
log->Printf ("SBProcess(%p)::WriteMemory() => error: process is running", process_sp.get());
sb_error.SetErrorString("process is running");
}
}
if (log)
{
SBStream sstr;
sb_error.GetDescription (sstr);
log->Printf ("SBProcess(%p)::WriteMemory (addr=0x%llx, src=%p, src_len=%llu, SBError (%p): %s) => %llu",
process_sp.get(),
addr,
src,
(uint64_t)src_len,
sb_error.get(),
sstr.GetData(),
(uint64_t)bytes_written);
}
return bytes_written;
}
SBFrame::SBFrame (const StackFrameSP &lldb_object_sp) :
m_opaque_sp (lldb_object_sp)
{
LogSP log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
if (log)
{
SBStream sstr;
GetDescription (sstr);
log->Printf ("SBFrame::SBFrame (sp=%p) => SBFrame(%p): %s",
lldb_object_sp.get(), m_opaque_sp.get(), sstr.GetData());
}
}
void listener_func() {
while (!g_done) {
SBEvent event;
bool got_event = g_listener.WaitForEvent(1, event);
if (got_event) {
if (!event.IsValid())
throw Exception("event is not valid in listener thread");
SBStream description;
event.GetDescription(description);
string str(description.GetData());
g_event_descriptions.push(str);
}
}
}
SBFileSpec::SBFileSpec (const SBFileSpec &rhs) :
m_opaque_ap()
{
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
if (rhs.m_opaque_ap.get())
m_opaque_ap.reset (new FileSpec (rhs.get()));
if (log)
{
SBStream sstr;
GetDescription (sstr);
log->Printf ("SBFileSpec::SBFileSpec (const SBFileSpec rhs.ap=%p) => SBFileSpec(%p): %s",
rhs.m_opaque_ap.get(), m_opaque_ap.get(), sstr.GetData());
}
}
lldb::ReturnStatus
SBCommandInterpreter::HandleCommand (const char *command_line, SBExecutionContext &override_context, SBCommandReturnObject &result, bool add_to_history)
{
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
if (log)
log->Printf ("SBCommandInterpreter(%p)::HandleCommand (command=\"%s\", SBCommandReturnObject(%p), add_to_history=%i)",
static_cast<void*>(m_opaque_ptr), command_line,
static_cast<void*>(result.get()), add_to_history);
ExecutionContext ctx, *ctx_ptr;
if (override_context.get())
{
ctx = override_context.get()->Lock(true);
ctx_ptr = &ctx;
}
else
ctx_ptr = nullptr;
result.Clear();
if (command_line && IsValid())
{
result.ref().SetInteractive(false);
m_opaque_ptr->HandleCommand (command_line, add_to_history ? eLazyBoolYes : eLazyBoolNo, result.ref(), ctx_ptr);
}
else
{
result->AppendError ("SBCommandInterpreter or the command line is not valid");
result->SetStatus (eReturnStatusFailed);
}
// We need to get the value again, in case the command disabled the log!
log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API);
if (log)
{
SBStream sstr;
result.GetDescription (sstr);
log->Printf ("SBCommandInterpreter(%p)::HandleCommand (command=\"%s\", SBCommandReturnObject(%p): %s, add_to_history=%i) => %i",
static_cast<void*>(m_opaque_ptr), command_line,
static_cast<void*>(result.get()), sstr.GetData(),
add_to_history, result.GetStatus());
}
return result.GetStatus();
}
void
SBDebugger::SetSelectedTarget (SBTarget &sb_target)
{
LogSP log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
if (m_opaque_sp)
{
m_opaque_sp->GetTargetList().SetSelectedTarget (sb_target.get());
}
if (log)
{
SBStream sstr;
sb_target.GetDescription (sstr, eDescriptionLevelBrief);
log->Printf ("SBDebugger(%p)::SetSelectedTarget () => SBTarget(%p): %s", m_opaque_sp.get(),
sb_target.get(), sstr.GetData());
}
}
SBFileSpec SBLineEntry::GetFileSpec() const {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBFileSpec sb_file_spec;
if (m_opaque_ap.get() && m_opaque_ap->file)
sb_file_spec.SetFileSpec(m_opaque_ap->file);
if (log) {
SBStream sstr;
sb_file_spec.GetDescription(sstr);
log->Printf("SBLineEntry(%p)::GetFileSpec () => SBFileSpec(%p): %s",
static_cast<void *>(m_opaque_ap.get()),
static_cast<const void *>(sb_file_spec.get()), sstr.GetData());
}
return sb_file_spec;
}
size_t
SBProcess::ReadMemory (addr_t addr, void *dst, size_t dst_len, SBError &sb_error)
{
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
size_t bytes_read = 0;
if (log)
{
log->Printf ("SBProcess(%p)::ReadMemory (addr=0x%llx, dst=%p, dst_len=%zu, SBError (%p))...",
m_opaque_sp.get(),
addr,
dst,
(uint32_t) dst_len,
sb_error.get());
}
if (m_opaque_sp)
{
Error error;
Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
bytes_read = m_opaque_sp->ReadMemory (addr, dst, dst_len, error);
sb_error.SetError (error);
}
else
{
sb_error.SetErrorString ("SBProcess is invalid");
}
if (log)
{
SBStream sstr;
sb_error.GetDescription (sstr);
log->Printf ("SBProcess(%p)::ReadMemory (addr=0x%llx, dst=%p, dst_len=%zu, SBError (%p): %s) => %d",
m_opaque_sp.get(),
addr,
dst,
(uint32_t) dst_len,
sb_error.get(),
sstr.GetData(),
(uint32_t) bytes_read);
}
return bytes_read;
}
bool SBMemoryRegionInfoList::GetMemoryRegionAtIndex(
uint32_t idx, SBMemoryRegionInfo ®ion_info) {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
bool result = m_opaque_ap->GetMemoryRegionInfoAtIndex(idx, region_info);
if (log) {
SBStream sstr;
region_info.GetDescription(sstr);
log->Printf("SBMemoryRegionInfoList::GetMemoryRegionAtIndex (this.ap=%p, "
"idx=%d) => SBMemoryRegionInfo (this.ap=%p, '%s')",
static_cast<void *>(m_opaque_ap.get()), idx,
static_cast<void *>(region_info.m_opaque_ap.get()),
sstr.GetData());
}
return result;
}
void
SBDebugger::Destroy (SBDebugger &debugger)
{
Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
if (log)
{
SBStream sstr;
debugger.GetDescription (sstr);
log->Printf ("SBDebugger::Destroy () => SBDebugger(%p): %s",
static_cast<void*>(debugger.m_opaque_sp.get()),
sstr.GetData());
}
Debugger::Destroy (debugger.m_opaque_sp);
if (debugger.m_opaque_sp.get() != NULL)
debugger.m_opaque_sp.reset();
}
SBModule
SBSymbolContext::GetModule ()
{
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
SBModule sb_module;
if (m_opaque_ap.get())
sb_module.SetModule(m_opaque_ap->module_sp);
if (log)
{
SBStream sstr;
sb_module.GetDescription (sstr);
log->Printf ("SBSymbolContext(%p)::GetModule () => SBModule(%p): %s",
m_opaque_ap.get(), sb_module.get(), sstr.GetData());
}
return sb_module;
}
SBDebugger
SBDebugger::Create(bool source_init_files, lldb::LogOutputCallback callback, void *baton)
{
Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
SBDebugger debugger;
// Currently we have issues if this function is called simultaneously on two different
// threads. The issues mainly revolve around the fact that the lldb_private::FormatManager
// uses global collections and having two threads parsing the .lldbinit files can cause
// mayhem. So to get around this for now we need to use a mutex to prevent bad things
// from happening.
static Mutex g_mutex(Mutex::eMutexTypeRecursive);
Mutex::Locker locker(g_mutex);
debugger.reset(Debugger::CreateInstance(callback, baton));
if (log)
{
SBStream sstr;
debugger.GetDescription (sstr);
log->Printf ("SBDebugger::Create () => SBDebugger(%p): %s",
static_cast<void*>(debugger.m_opaque_sp.get()),
sstr.GetData());
}
SBCommandInterpreter interp = debugger.GetCommandInterpreter();
if (source_init_files)
{
interp.get()->SkipLLDBInitFiles(false);
interp.get()->SkipAppInitFiles (false);
SBCommandReturnObject result;
interp.SourceInitFileInHomeDirectory(result);
}
else
{
interp.get()->SkipLLDBInitFiles(true);
interp.get()->SkipAppInitFiles (true);
}
return debugger;
}
SBModule SBSymbolContext::GetModule() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBModule sb_module;
ModuleSP module_sp;
if (m_opaque_ap.get()) {
module_sp = m_opaque_ap->module_sp;
sb_module.SetSP(module_sp);
}
if (log) {
SBStream sstr;
sb_module.GetDescription(sstr);
log->Printf("SBSymbolContext(%p)::GetModule () => SBModule(%p): %s",
static_cast<void *>(m_opaque_ap.get()),
static_cast<void *>(module_sp.get()), sstr.GetData());
}
return sb_module;
}
SBThread
SBFrame::GetThread () const
{
LogSP log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
ExecutionContext exe_ctx(m_opaque_sp.get());
ThreadSP thread_sp (exe_ctx.GetThreadSP());
SBThread sb_thread (thread_sp);
if (log)
{
SBStream sstr;
sb_thread.GetDescription (sstr);
log->Printf ("SBFrame(%p)::GetThread () => SBThread(%p): %s",
exe_ctx.GetFramePtr(),
thread_sp.get(),
sstr.GetData());
}
return sb_thread;
}
size_t
SBProcess::WriteMemory (addr_t addr, const void *src, size_t src_len, SBError &sb_error)
{
size_t bytes_written = 0;
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
if (log)
{
log->Printf ("SBProcess(%p)::WriteMemory (addr=0x%llx, src=%p, dst_len=%zu, SBError (%p))...",
m_opaque_sp.get(),
addr,
src,
(uint32_t) src_len,
sb_error.get());
}
if (m_opaque_sp)
{
Error error;
Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
bytes_written = m_opaque_sp->WriteMemory (addr, src, src_len, error);
sb_error.SetError (error);
}
if (log)
{
SBStream sstr;
sb_error.GetDescription (sstr);
log->Printf ("SBProcess(%p)::WriteMemory (addr=0x%llx, src=%p, dst_len=%zu, SBError (%p): %s) => %d",
m_opaque_sp.get(),
addr,
src,
(uint32_t) src_len,
sb_error.get(),
sstr.GetData(),
(uint32_t) bytes_written);
}
return bytes_written;
}
SBTypeSummary SBTypeSummary::CreateWithCallback(FormatCallback cb,
uint32_t options,
const char *description) {
SBTypeSummary retval;
if (cb) {
retval.SetSP(TypeSummaryImplSP(new CXXFunctionSummaryFormat(
options,
[cb](ValueObject &valobj, Stream &stm,
const TypeSummaryOptions &opt) -> bool {
SBStream stream;
SBValue sb_value(valobj.GetSP());
SBTypeSummaryOptions options(&opt);
if (!cb(sb_value, options, stream))
return false;
stm.Write(stream.GetData(), stream.GetSize());
return true;
},
description ? description : "callback summary formatter")));
}
return retval;
}
SBThread
SBFrame::GetThread () const
{
LogSP log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
SBThread sb_thread;
if (m_opaque_sp)
{
Mutex::Locker api_locker (m_opaque_sp->GetThread().GetProcess().GetTarget().GetAPIMutex());
sb_thread.SetThread (m_opaque_sp->GetThread().GetSP());
}
if (log)
{
SBStream sstr;
sb_thread.GetDescription (sstr);
log->Printf ("SBFrame(%p)::GetThread () => SBThread(%p): %s", m_opaque_sp.get(),
sb_thread.get(), sstr.GetData());
}
return sb_thread;
}
