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; }