diff options
Diffstat (limited to 'source/API/SBProcess.cpp')
| -rw-r--r-- | source/API/SBProcess.cpp | 820 |
1 files changed, 406 insertions, 414 deletions
diff --git a/source/API/SBProcess.cpp b/source/API/SBProcess.cpp index cb1124607ec01..4226ff77ecdc3 100644 --- a/source/API/SBProcess.cpp +++ b/source/API/SBProcess.cpp @@ -1,13 +1,13 @@ //===-- SBProcess.cpp -------------------------------------------*- C++ -*-===// // -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #include "lldb/API/SBProcess.h" +#include "SBReproducerPrivate.h" #include <inttypes.h> @@ -25,7 +25,7 @@ #include "lldb/Target/Target.h" #include "lldb/Target/Thread.h" #include "lldb/Utility/Args.h" -#include "lldb/Utility/Log.h" +#include "lldb/Utility/ProcessInfo.h" #include "lldb/Utility/State.h" #include "lldb/Utility/Stream.h" @@ -49,33 +49,43 @@ using namespace lldb; using namespace lldb_private; -SBProcess::SBProcess() : m_opaque_wp() {} +SBProcess::SBProcess() : m_opaque_wp() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBProcess); +} -//---------------------------------------------------------------------- // SBProcess constructor -//---------------------------------------------------------------------- -SBProcess::SBProcess(const SBProcess &rhs) : m_opaque_wp(rhs.m_opaque_wp) {} +SBProcess::SBProcess(const SBProcess &rhs) : m_opaque_wp(rhs.m_opaque_wp) { + LLDB_RECORD_CONSTRUCTOR(SBProcess, (const lldb::SBProcess &), rhs); +} SBProcess::SBProcess(const lldb::ProcessSP &process_sp) - : m_opaque_wp(process_sp) {} + : m_opaque_wp(process_sp) { + LLDB_RECORD_CONSTRUCTOR(SBProcess, (const lldb::ProcessSP &), process_sp); +} const SBProcess &SBProcess::operator=(const SBProcess &rhs) { + LLDB_RECORD_METHOD(const lldb::SBProcess &, + SBProcess, operator=,(const lldb::SBProcess &), rhs); + if (this != &rhs) m_opaque_wp = rhs.m_opaque_wp; - return *this; + return LLDB_RECORD_RESULT(*this); } -//---------------------------------------------------------------------- // Destructor -//---------------------------------------------------------------------- SBProcess::~SBProcess() {} const char *SBProcess::GetBroadcasterClassName() { + LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBProcess, + GetBroadcasterClassName); + return Process::GetStaticBroadcasterClass().AsCString(); } const char *SBProcess::GetPluginName() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetPluginName); + ProcessSP process_sp(GetSP()); if (process_sp) { return process_sp->GetPluginName().GetCString(); @@ -84,6 +94,8 @@ const char *SBProcess::GetPluginName() { } const char *SBProcess::GetShortPluginName() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetShortPluginName); + ProcessSP process_sp(GetSP()); if (process_sp) { return process_sp->GetPluginName().GetCString(); @@ -95,9 +107,19 @@ lldb::ProcessSP SBProcess::GetSP() const { return m_opaque_wp.lock(); } void SBProcess::SetSP(const ProcessSP &process_sp) { m_opaque_wp = process_sp; } -void SBProcess::Clear() { m_opaque_wp.reset(); } +void SBProcess::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBProcess, Clear); + + m_opaque_wp.reset(); +} bool SBProcess::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcess, IsValid); + return this->operator bool(); +} +SBProcess::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcess, operator bool); + ProcessSP process_sp(m_opaque_wp.lock()); return ((bool)process_sp && process_sp->IsValid()); } @@ -108,18 +130,12 @@ bool SBProcess::RemoteLaunch(char const **argv, char const **envp, const char *working_directory, uint32_t launch_flags, bool stop_at_entry, lldb::SBError &error) { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf("SBProcess(%p)::RemoteLaunch (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 *>(m_opaque_wp.lock().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())); + LLDB_RECORD_METHOD(bool, SBProcess, RemoteLaunch, + (const char **, const char **, const char *, const char *, + const char *, const char *, uint32_t, bool, + lldb::SBError &), + argv, envp, stdin_path, stdout_path, stderr_path, + working_directory, launch_flags, stop_at_entry, error); ProcessSP process_sp(GetSP()); if (process_sp) { @@ -146,19 +162,14 @@ bool SBProcess::RemoteLaunch(char const **argv, char const **envp, error.SetErrorString("unable to attach pid"); } - if (log) { - SBStream sstr; - error.GetDescription(sstr); - log->Printf("SBProcess(%p)::RemoteLaunch (...) => SBError (%p): %s", - static_cast<void *>(process_sp.get()), - static_cast<void *>(error.get()), sstr.GetData()); - } - return error.Success(); } bool SBProcess::RemoteAttachToProcessWithID(lldb::pid_t pid, lldb::SBError &error) { + LLDB_RECORD_METHOD(bool, SBProcess, RemoteAttachToProcessWithID, + (lldb::pid_t, lldb::SBError &), pid, error); + ProcessSP process_sp(GetSP()); if (process_sp) { std::lock_guard<std::recursive_mutex> guard( @@ -175,21 +186,11 @@ bool SBProcess::RemoteAttachToProcessWithID(lldb::pid_t pid, 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(); } uint32_t SBProcess::GetNumThreads() { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumThreads); uint32_t num_threads = 0; ProcessSP process_sp(GetSP()); @@ -202,15 +203,12 @@ uint32_t SBProcess::GetNumThreads() { num_threads = process_sp->GetThreadList().GetSize(can_update); } - if (log) - log->Printf("SBProcess(%p)::GetNumThreads () => %d", - static_cast<void *>(process_sp.get()), num_threads); - return num_threads; } SBThread SBProcess::GetSelectedThread() const { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBProcess, + GetSelectedThread); SBThread sb_thread; ThreadSP thread_sp; @@ -222,17 +220,13 @@ SBThread SBProcess::GetSelectedThread() const { sb_thread.SetThread(thread_sp); } - if (log) - log->Printf("SBProcess(%p)::GetSelectedThread () => SBThread(%p)", - static_cast<void *>(process_sp.get()), - static_cast<void *>(thread_sp.get())); - - return sb_thread; + return LLDB_RECORD_RESULT(sb_thread); } SBThread SBProcess::CreateOSPluginThread(lldb::tid_t tid, lldb::addr_t context) { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, CreateOSPluginThread, + (lldb::tid_t, lldb::addr_t), tid, context); SBThread sb_thread; ThreadSP thread_sp; @@ -244,17 +238,11 @@ SBThread SBProcess::CreateOSPluginThread(lldb::tid_t tid, sb_thread.SetThread(thread_sp); } - if (log) - log->Printf("SBProcess(%p)::CreateOSPluginThread (tid=0x%" PRIx64 - ", context=0x%" PRIx64 ") => SBThread(%p)", - static_cast<void *>(process_sp.get()), tid, context, - static_cast<void *>(thread_sp.get())); - - return sb_thread; + return LLDB_RECORD_RESULT(sb_thread); } SBTarget SBProcess::GetTarget() const { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBTarget, SBProcess, GetTarget); SBTarget sb_target; TargetSP target_sp; @@ -264,16 +252,12 @@ SBTarget SBProcess::GetTarget() const { sb_target.SetSP(target_sp); } - if (log) - log->Printf("SBProcess(%p)::GetTarget () => SBTarget(%p)", - static_cast<void *>(process_sp.get()), - static_cast<void *>(target_sp.get())); - - return sb_target; + return LLDB_RECORD_RESULT(sb_target); } size_t SBProcess::PutSTDIN(const char *src, size_t src_len) { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_METHOD(size_t, SBProcess, PutSTDIN, (const char *, size_t), src, + src_len); size_t ret_val = 0; ProcessSP process_sp(GetSP()); @@ -282,16 +266,13 @@ size_t SBProcess::PutSTDIN(const char *src, size_t src_len) { ret_val = process_sp->PutSTDIN(src, src_len, error); } - if (log) - log->Printf("SBProcess(%p)::PutSTDIN (src=\"%s\", src_len=%" PRIu64 - ") => %" PRIu64, - static_cast<void *>(process_sp.get()), src, - static_cast<uint64_t>(src_len), static_cast<uint64_t>(ret_val)); - return ret_val; } size_t SBProcess::GetSTDOUT(char *dst, size_t dst_len) const { + LLDB_RECORD_METHOD_CONST(size_t, SBProcess, GetSTDOUT, (char *, size_t), dst, + dst_len); + size_t bytes_read = 0; ProcessSP process_sp(GetSP()); if (process_sp) { @@ -299,18 +280,13 @@ size_t SBProcess::GetSTDOUT(char *dst, size_t dst_len) const { bytes_read = process_sp->GetSTDOUT(dst, dst_len, error); } - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf( - "SBProcess(%p)::GetSTDOUT (dst=\"%.*s\", dst_len=%" PRIu64 - ") => %" PRIu64, - static_cast<void *>(process_sp.get()), static_cast<int>(bytes_read), - dst, static_cast<uint64_t>(dst_len), static_cast<uint64_t>(bytes_read)); - return bytes_read; } size_t SBProcess::GetSTDERR(char *dst, size_t dst_len) const { + LLDB_RECORD_METHOD_CONST(size_t, SBProcess, GetSTDERR, (char *, size_t), dst, + dst_len); + size_t bytes_read = 0; ProcessSP process_sp(GetSP()); if (process_sp) { @@ -318,18 +294,13 @@ size_t SBProcess::GetSTDERR(char *dst, size_t dst_len) const { bytes_read = process_sp->GetSTDERR(dst, dst_len, error); } - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf( - "SBProcess(%p)::GetSTDERR (dst=\"%.*s\", dst_len=%" PRIu64 - ") => %" PRIu64, - static_cast<void *>(process_sp.get()), static_cast<int>(bytes_read), - dst, static_cast<uint64_t>(dst_len), static_cast<uint64_t>(bytes_read)); - return bytes_read; } size_t SBProcess::GetAsyncProfileData(char *dst, size_t dst_len) const { + LLDB_RECORD_METHOD_CONST(size_t, SBProcess, GetAsyncProfileData, + (char *, size_t), dst, dst_len); + size_t bytes_read = 0; ProcessSP process_sp(GetSP()); if (process_sp) { @@ -337,20 +308,14 @@ size_t SBProcess::GetAsyncProfileData(char *dst, size_t dst_len) const { bytes_read = process_sp->GetAsyncProfileData(dst, dst_len, error); } - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf( - "SBProcess(%p)::GetAsyncProfileData (dst=\"%.*s\", dst_len=%" PRIu64 - ") => %" PRIu64, - static_cast<void *>(process_sp.get()), static_cast<int>(bytes_read), - dst, static_cast<uint64_t>(dst_len), static_cast<uint64_t>(bytes_read)); - return bytes_read; } lldb::SBTrace SBProcess::StartTrace(SBTraceOptions &options, lldb::SBError &error) { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_METHOD(lldb::SBTrace, SBProcess, StartTrace, + (lldb::SBTraceOptions &, lldb::SBError &), options, error); + ProcessSP process_sp(GetSP()); error.Clear(); SBTrace trace_instance; @@ -362,13 +327,15 @@ lldb::SBTrace SBProcess::StartTrace(SBTraceOptions &options, } else { uid = process_sp->StartTrace(*(options.m_traceoptions_sp), error.ref()); trace_instance.SetTraceUID(uid); - LLDB_LOG(log, "SBProcess::returned uid - {0}", uid); } - return trace_instance; + return LLDB_RECORD_RESULT(trace_instance); } void SBProcess::ReportEventState(const SBEvent &event, FILE *out) const { - if (out == NULL) + LLDB_RECORD_METHOD_CONST(void, SBProcess, ReportEventState, + (const lldb::SBEvent &, FILE *), event, out); + + if (out == nullptr) return; ProcessSP process_sp(GetSP()); @@ -386,6 +353,10 @@ void SBProcess::ReportEventState(const SBEvent &event, FILE *out) const { void SBProcess::AppendEventStateReport(const SBEvent &event, SBCommandReturnObject &result) { + LLDB_RECORD_METHOD(void, SBProcess, AppendEventStateReport, + (const lldb::SBEvent &, lldb::SBCommandReturnObject &), + event, result); + ProcessSP process_sp(GetSP()); if (process_sp) { const StateType event_state = SBProcess::GetStateFromEvent(event); @@ -398,6 +369,9 @@ void SBProcess::AppendEventStateReport(const SBEvent &event, } bool SBProcess::SetSelectedThread(const SBThread &thread) { + LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThread, + (const lldb::SBThread &), thread); + ProcessSP process_sp(GetSP()); if (process_sp) { std::lock_guard<std::recursive_mutex> guard( @@ -409,7 +383,9 @@ bool SBProcess::SetSelectedThread(const SBThread &thread) { } bool SBProcess::SetSelectedThreadByID(lldb::tid_t tid) { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByID, (lldb::tid_t), + tid); + bool ret_val = false; ProcessSP process_sp(GetSP()); @@ -419,17 +395,12 @@ bool SBProcess::SetSelectedThreadByID(lldb::tid_t tid) { ret_val = process_sp->GetThreadList().SetSelectedThreadByID(tid); } - if (log) - log->Printf("SBProcess(%p)::SetSelectedThreadByID (tid=0x%4.4" PRIx64 - ") => %s", - static_cast<void *>(process_sp.get()), tid, - (ret_val ? "true" : "false")); - return ret_val; } bool SBProcess::SetSelectedThreadByIndexID(uint32_t index_id) { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByIndexID, (uint32_t), + index_id); bool ret_val = false; ProcessSP process_sp(GetSP()); @@ -439,16 +410,13 @@ bool SBProcess::SetSelectedThreadByIndexID(uint32_t index_id) { ret_val = process_sp->GetThreadList().SetSelectedThreadByIndexID(index_id); } - if (log) - log->Printf("SBProcess(%p)::SetSelectedThreadByID (tid=0x%x) => %s", - static_cast<void *>(process_sp.get()), index_id, - (ret_val ? "true" : "false")); return ret_val; } SBThread SBProcess::GetThreadAtIndex(size_t index) { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadAtIndex, (size_t), + index); SBThread sb_thread; ThreadSP thread_sp; @@ -462,17 +430,11 @@ SBThread SBProcess::GetThreadAtIndex(size_t index) { sb_thread.SetThread(thread_sp); } - if (log) - log->Printf("SBProcess(%p)::GetThreadAtIndex (index=%d) => SBThread(%p)", - static_cast<void *>(process_sp.get()), - static_cast<uint32_t>(index), - static_cast<void *>(thread_sp.get())); - - return sb_thread; + return LLDB_RECORD_RESULT(sb_thread); } uint32_t SBProcess::GetNumQueues() { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumQueues); uint32_t num_queues = 0; ProcessSP process_sp(GetSP()); @@ -485,15 +447,12 @@ uint32_t SBProcess::GetNumQueues() { } } - if (log) - log->Printf("SBProcess(%p)::GetNumQueues () => %d", - static_cast<void *>(process_sp.get()), num_queues); - return num_queues; } SBQueue SBProcess::GetQueueAtIndex(size_t index) { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_METHOD(lldb::SBQueue, SBProcess, GetQueueAtIndex, (size_t), + index); SBQueue sb_queue; QueueSP queue_sp; @@ -508,16 +467,13 @@ SBQueue SBProcess::GetQueueAtIndex(size_t index) { } } - if (log) - log->Printf("SBProcess(%p)::GetQueueAtIndex (index=%d) => SBQueue(%p)", - static_cast<void *>(process_sp.get()), - static_cast<uint32_t>(index), - static_cast<void *>(queue_sp.get())); - - return sb_queue; + return LLDB_RECORD_RESULT(sb_queue); } uint32_t SBProcess::GetStopID(bool include_expression_stops) { + LLDB_RECORD_METHOD(uint32_t, SBProcess, GetStopID, (bool), + include_expression_stops); + ProcessSP process_sp(GetSP()); if (process_sp) { std::lock_guard<std::recursive_mutex> guard( @@ -531,7 +487,8 @@ uint32_t SBProcess::GetStopID(bool include_expression_stops) { } SBEvent SBProcess::GetStopEventForStopID(uint32_t stop_id) { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_METHOD(lldb::SBEvent, SBProcess, GetStopEventForStopID, + (uint32_t), stop_id); SBEvent sb_event; EventSP event_sp; @@ -543,16 +500,11 @@ SBEvent SBProcess::GetStopEventForStopID(uint32_t stop_id) { sb_event.reset(event_sp); } - if (log) - log->Printf("SBProcess(%p)::GetStopEventForStopID (stop_id=%" PRIu32 - ") => SBEvent(%p)", - static_cast<void *>(process_sp.get()), stop_id, - static_cast<void *>(event_sp.get())); - - return sb_event; + return LLDB_RECORD_RESULT(sb_event); } StateType SBProcess::GetState() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::StateType, SBProcess, GetState); StateType ret_val = eStateInvalid; ProcessSP process_sp(GetSP()); @@ -562,16 +514,12 @@ StateType SBProcess::GetState() { ret_val = process_sp->GetState(); } - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf("SBProcess(%p)::GetState () => %s", - static_cast<void *>(process_sp.get()), - lldb_private::StateAsCString(ret_val)); - return ret_val; } int SBProcess::GetExitStatus() { + LLDB_RECORD_METHOD_NO_ARGS(int, SBProcess, GetExitStatus); + int exit_status = 0; ProcessSP process_sp(GetSP()); if (process_sp) { @@ -579,94 +527,74 @@ int SBProcess::GetExitStatus() { process_sp->GetTarget().GetAPIMutex()); exit_status = process_sp->GetExitStatus(); } - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf("SBProcess(%p)::GetExitStatus () => %i (0x%8.8x)", - static_cast<void *>(process_sp.get()), exit_status, - exit_status); return exit_status; } const char *SBProcess::GetExitDescription() { - const char *exit_desc = NULL; + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetExitDescription); + + const char *exit_desc = nullptr; ProcessSP process_sp(GetSP()); if (process_sp) { std::lock_guard<std::recursive_mutex> guard( process_sp->GetTarget().GetAPIMutex()); exit_desc = process_sp->GetExitDescription(); } - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf("SBProcess(%p)::GetExitDescription () => %s", - static_cast<void *>(process_sp.get()), exit_desc); return exit_desc; } lldb::pid_t SBProcess::GetProcessID() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBProcess, GetProcessID); + lldb::pid_t ret_val = LLDB_INVALID_PROCESS_ID; ProcessSP process_sp(GetSP()); if (process_sp) ret_val = process_sp->GetID(); - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf("SBProcess(%p)::GetProcessID () => %" PRIu64, - static_cast<void *>(process_sp.get()), ret_val); - return ret_val; } uint32_t SBProcess::GetUniqueID() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetUniqueID); + uint32_t ret_val = 0; ProcessSP process_sp(GetSP()); if (process_sp) ret_val = process_sp->GetUniqueID(); - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf("SBProcess(%p)::GetUniqueID () => %" PRIu32, - static_cast<void *>(process_sp.get()), ret_val); return ret_val; } ByteOrder SBProcess::GetByteOrder() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ByteOrder, SBProcess, GetByteOrder); + ByteOrder byteOrder = eByteOrderInvalid; ProcessSP process_sp(GetSP()); if (process_sp) byteOrder = process_sp->GetTarget().GetArchitecture().GetByteOrder(); - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf("SBProcess(%p)::GetByteOrder () => %d", - static_cast<void *>(process_sp.get()), byteOrder); return byteOrder; } uint32_t SBProcess::GetAddressByteSize() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBProcess, GetAddressByteSize); + uint32_t size = 0; ProcessSP process_sp(GetSP()); if (process_sp) size = process_sp->GetTarget().GetArchitecture().GetAddressByteSize(); - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf("SBProcess(%p)::GetAddressByteSize () => %d", - static_cast<void *>(process_sp.get()), size); return size; } SBError SBProcess::Continue() { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Continue); SBError sb_error; ProcessSP process_sp(GetSP()); - if (log) - log->Printf("SBProcess(%p)::Continue ()...", - static_cast<void *>(process_sp.get())); - if (process_sp) { std::lock_guard<std::recursive_mutex> guard( process_sp->GetTarget().GetAPIMutex()); @@ -674,22 +602,16 @@ SBError SBProcess::Continue() { if (process_sp->GetTarget().GetDebugger().GetAsyncExecution()) sb_error.ref() = process_sp->Resume(); else - sb_error.ref() = process_sp->ResumeSynchronous(NULL); + sb_error.ref() = process_sp->ResumeSynchronous(nullptr); } 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; + return LLDB_RECORD_RESULT(sb_error); } SBError SBProcess::Destroy() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Destroy); + SBError sb_error; ProcessSP process_sp(GetSP()); if (process_sp) { @@ -699,19 +621,12 @@ SBError SBProcess::Destroy() { } 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)::Destroy () => SBError (%p): %s", - static_cast<void *>(process_sp.get()), - static_cast<void *>(sb_error.get()), sstr.GetData()); - } - - return sb_error; + return LLDB_RECORD_RESULT(sb_error); } SBError SBProcess::Stop() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Stop); + SBError sb_error; ProcessSP process_sp(GetSP()); if (process_sp) { @@ -721,19 +636,12 @@ SBError SBProcess::Stop() { } 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)::Stop () => SBError (%p): %s", - static_cast<void *>(process_sp.get()), - static_cast<void *>(sb_error.get()), sstr.GetData()); - } - - return sb_error; + return LLDB_RECORD_RESULT(sb_error); } SBError SBProcess::Kill() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Kill); + SBError sb_error; ProcessSP process_sp(GetSP()); if (process_sp) { @@ -743,25 +651,20 @@ SBError SBProcess::Kill() { } 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; + return LLDB_RECORD_RESULT(sb_error); } SBError SBProcess::Detach() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Detach); + // FIXME: This should come from a process default. bool keep_stopped = false; - return Detach(keep_stopped); + return LLDB_RECORD_RESULT(Detach(keep_stopped)); } SBError SBProcess::Detach(bool keep_stopped) { + LLDB_RECORD_METHOD(lldb::SBError, SBProcess, Detach, (bool), keep_stopped); + SBError sb_error; ProcessSP process_sp(GetSP()); if (process_sp) { @@ -771,10 +674,12 @@ SBError SBProcess::Detach(bool keep_stopped) { } else sb_error.SetErrorString("SBProcess is invalid"); - return sb_error; + return LLDB_RECORD_RESULT(sb_error); } SBError SBProcess::Signal(int signo) { + LLDB_RECORD_METHOD(lldb::SBError, SBProcess, Signal, (int), signo); + SBError sb_error; ProcessSP process_sp(GetSP()); if (process_sp) { @@ -783,25 +688,22 @@ SBError SBProcess::Signal(int signo) { sb_error.SetError(process_sp->Signal(signo)); } 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)::Signal (signo=%i) => SBError (%p): %s", - static_cast<void *>(process_sp.get()), signo, - static_cast<void *>(sb_error.get()), sstr.GetData()); - } - return sb_error; + + return LLDB_RECORD_RESULT(sb_error); } SBUnixSignals SBProcess::GetUnixSignals() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBUnixSignals, SBProcess, GetUnixSignals); + if (auto process_sp = GetSP()) - return SBUnixSignals{process_sp}; + return LLDB_RECORD_RESULT(SBUnixSignals{process_sp}); - return {}; + return LLDB_RECORD_RESULT(SBUnixSignals{}); } void SBProcess::SendAsyncInterrupt() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBProcess, SendAsyncInterrupt); + ProcessSP process_sp(GetSP()); if (process_sp) { process_sp->SendAsyncInterrupt(); @@ -809,6 +711,9 @@ void SBProcess::SendAsyncInterrupt() { } SBThread SBProcess::GetThreadByID(tid_t tid) { + LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadByID, (lldb::tid_t), + tid); + SBThread sb_thread; ThreadSP thread_sp; ProcessSP process_sp(GetSP()); @@ -821,17 +726,13 @@ SBThread SBProcess::GetThreadByID(tid_t tid) { sb_thread.SetThread(thread_sp); } - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf("SBProcess(%p)::GetThreadByID (tid=0x%4.4" PRIx64 - ") => SBThread (%p)", - static_cast<void *>(process_sp.get()), tid, - static_cast<void *>(thread_sp.get())); - - return sb_thread; + return LLDB_RECORD_RESULT(sb_thread); } SBThread SBProcess::GetThreadByIndexID(uint32_t index_id) { + LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadByIndexID, (uint32_t), + index_id); + SBThread sb_thread; ThreadSP thread_sp; ProcessSP process_sp(GetSP()); @@ -845,51 +746,48 @@ SBThread SBProcess::GetThreadByIndexID(uint32_t index_id) { sb_thread.SetThread(thread_sp); } - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf("SBProcess(%p)::GetThreadByID (tid=0x%x) => SBThread (%p)", - static_cast<void *>(process_sp.get()), index_id, - static_cast<void *>(thread_sp.get())); - - return sb_thread; + return LLDB_RECORD_RESULT(sb_thread); } StateType SBProcess::GetStateFromEvent(const SBEvent &event) { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_STATIC_METHOD(lldb::StateType, SBProcess, GetStateFromEvent, + (const lldb::SBEvent &), event); StateType ret_val = Process::ProcessEventData::GetStateFromEvent(event.get()); - if (log) - log->Printf("SBProcess::GetStateFromEvent (event.sp=%p) => %s", - static_cast<void *>(event.get()), - lldb_private::StateAsCString(ret_val)); - return ret_val; } bool SBProcess::GetRestartedFromEvent(const SBEvent &event) { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_STATIC_METHOD(bool, SBProcess, GetRestartedFromEvent, + (const lldb::SBEvent &), event); bool ret_val = Process::ProcessEventData::GetRestartedFromEvent(event.get()); - if (log) - log->Printf("SBProcess::%s (event.sp=%p) => %d", __FUNCTION__, - static_cast<void *>(event.get()), ret_val); - return ret_val; } size_t SBProcess::GetNumRestartedReasonsFromEvent(const lldb::SBEvent &event) { + LLDB_RECORD_STATIC_METHOD(size_t, SBProcess, GetNumRestartedReasonsFromEvent, + (const lldb::SBEvent &), event); + return Process::ProcessEventData::GetNumRestartedReasons(event.get()); } const char * SBProcess::GetRestartedReasonAtIndexFromEvent(const lldb::SBEvent &event, size_t idx) { + LLDB_RECORD_STATIC_METHOD(const char *, SBProcess, + GetRestartedReasonAtIndexFromEvent, + (const lldb::SBEvent &, size_t), event, idx); + return Process::ProcessEventData::GetRestartedReasonAtIndex(event.get(), idx); } SBProcess SBProcess::GetProcessFromEvent(const SBEvent &event) { + LLDB_RECORD_STATIC_METHOD(lldb::SBProcess, SBProcess, GetProcessFromEvent, + (const lldb::SBEvent &), event); + ProcessSP process_sp = Process::ProcessEventData::GetProcessFromEvent(event.get()); if (!process_sp) { @@ -897,24 +795,37 @@ SBProcess SBProcess::GetProcessFromEvent(const SBEvent &event) { process_sp = EventDataStructuredData::GetProcessFromEvent(event.get()); } - return SBProcess(process_sp); + return LLDB_RECORD_RESULT(SBProcess(process_sp)); } bool SBProcess::GetInterruptedFromEvent(const SBEvent &event) { + LLDB_RECORD_STATIC_METHOD(bool, SBProcess, GetInterruptedFromEvent, + (const lldb::SBEvent &), event); + return Process::ProcessEventData::GetInterruptedFromEvent(event.get()); } lldb::SBStructuredData SBProcess::GetStructuredDataFromEvent(const lldb::SBEvent &event) { - return SBStructuredData(event.GetSP()); + LLDB_RECORD_STATIC_METHOD(lldb::SBStructuredData, SBProcess, + GetStructuredDataFromEvent, (const lldb::SBEvent &), + event); + + return LLDB_RECORD_RESULT(SBStructuredData(event.GetSP())); } bool SBProcess::EventIsProcessEvent(const SBEvent &event) { + LLDB_RECORD_STATIC_METHOD(bool, SBProcess, EventIsProcessEvent, + (const lldb::SBEvent &), event); + return (event.GetBroadcasterClass() == SBProcess::GetBroadcasterClass()) && !EventIsStructuredDataEvent(event); } bool SBProcess::EventIsStructuredDataEvent(const lldb::SBEvent &event) { + LLDB_RECORD_STATIC_METHOD(bool, SBProcess, EventIsStructuredDataEvent, + (const lldb::SBEvent &), event); + EventSP event_sp = event.GetSP(); EventData *event_data = event_sp ? event_sp->GetData() : nullptr; return event_data && (event_data->GetFlavor() == @@ -922,38 +833,35 @@ bool SBProcess::EventIsStructuredDataEvent(const lldb::SBEvent &event) { } SBBroadcaster SBProcess::GetBroadcaster() const { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBProcess, + GetBroadcaster); + ProcessSP process_sp(GetSP()); SBBroadcaster broadcaster(process_sp.get(), false); - if (log) - log->Printf("SBProcess(%p)::GetBroadcaster () => SBBroadcaster (%p)", - static_cast<void *>(process_sp.get()), - static_cast<void *>(broadcaster.get())); - return broadcaster; + return LLDB_RECORD_RESULT(broadcaster); } const char *SBProcess::GetBroadcasterClass() { + LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBProcess, + GetBroadcasterClass); + return Process::GetStaticBroadcasterClass().AsCString(); } size_t SBProcess::ReadMemory(addr_t addr, void *dst, size_t dst_len, SBError &sb_error) { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_DUMMY(size_t, SBProcess, ReadMemory, + (lldb::addr_t, void *, size_t, lldb::SBError &), addr, dst, + dst_len, sb_error); size_t bytes_read = 0; ProcessSP process_sp(GetSP()); - if (log) - log->Printf("SBProcess(%p)::ReadMemory (addr=0x%" PRIx64 - ", dst=%p, dst_len=%" PRIu64 ", SBError (%p))...", - static_cast<void *>(process_sp.get()), addr, - static_cast<void *>(dst), static_cast<uint64_t>(dst_len), - static_cast<void *>(sb_error.get())); if (process_sp) { Process::StopLocker stop_locker; @@ -962,31 +870,21 @@ size_t SBProcess::ReadMemory(addr_t addr, void *dst, size_t dst_len, 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", - static_cast<void *>(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%" PRIx64 - ", dst=%p, dst_len=%" PRIu64 ", SBError (%p): %s) => %" PRIu64, - static_cast<void *>(process_sp.get()), addr, - static_cast<void *>(dst), static_cast<uint64_t>(dst_len), - static_cast<void *>(sb_error.get()), sstr.GetData(), - static_cast<uint64_t>(bytes_read)); - } - return bytes_read; } size_t SBProcess::ReadCStringFromMemory(addr_t addr, void *buf, size_t size, lldb::SBError &sb_error) { + LLDB_RECORD_DUMMY(size_t, SBProcess, ReadCStringFromMemory, + (lldb::addr_t, void *, size_t, lldb::SBError &), addr, buf, + size, sb_error); + size_t bytes_read = 0; ProcessSP process_sp(GetSP()); if (process_sp) { @@ -997,11 +895,6 @@ size_t SBProcess::ReadCStringFromMemory(addr_t addr, void *buf, size_t size, bytes_read = process_sp->ReadCStringFromMemory(addr, (char *)buf, size, sb_error.ref()); } else { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf("SBProcess(%p)::ReadCStringFromMemory() => error: process " - "is running", - static_cast<void *>(process_sp.get())); sb_error.SetErrorString("process is running"); } } else { @@ -1012,6 +905,10 @@ size_t SBProcess::ReadCStringFromMemory(addr_t addr, void *buf, size_t size, uint64_t SBProcess::ReadUnsignedFromMemory(addr_t addr, uint32_t byte_size, lldb::SBError &sb_error) { + LLDB_RECORD_METHOD(uint64_t, SBProcess, ReadUnsignedFromMemory, + (lldb::addr_t, uint32_t, lldb::SBError &), addr, byte_size, + sb_error); + uint64_t value = 0; ProcessSP process_sp(GetSP()); if (process_sp) { @@ -1022,11 +919,6 @@ uint64_t SBProcess::ReadUnsignedFromMemory(addr_t addr, uint32_t byte_size, value = process_sp->ReadUnsignedIntegerFromMemory(addr, byte_size, 0, sb_error.ref()); } else { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf("SBProcess(%p)::ReadUnsignedFromMemory() => error: process " - "is running", - static_cast<void *>(process_sp.get())); sb_error.SetErrorString("process is running"); } } else { @@ -1037,6 +929,9 @@ uint64_t SBProcess::ReadUnsignedFromMemory(addr_t addr, uint32_t byte_size, lldb::addr_t SBProcess::ReadPointerFromMemory(addr_t addr, lldb::SBError &sb_error) { + LLDB_RECORD_METHOD(lldb::addr_t, SBProcess, ReadPointerFromMemory, + (lldb::addr_t, lldb::SBError &), addr, sb_error); + lldb::addr_t ptr = LLDB_INVALID_ADDRESS; ProcessSP process_sp(GetSP()); if (process_sp) { @@ -1046,11 +941,6 @@ lldb::addr_t SBProcess::ReadPointerFromMemory(addr_t addr, process_sp->GetTarget().GetAPIMutex()); ptr = process_sp->ReadPointerFromMemory(addr, sb_error.ref()); } else { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf("SBProcess(%p)::ReadPointerFromMemory() => error: process " - "is running", - static_cast<void *>(process_sp.get())); sb_error.SetErrorString("process is running"); } } else { @@ -1061,19 +951,14 @@ lldb::addr_t SBProcess::ReadPointerFromMemory(addr_t addr, size_t SBProcess::WriteMemory(addr_t addr, const void *src, size_t src_len, SBError &sb_error) { - size_t bytes_written = 0; + LLDB_RECORD_DUMMY(size_t, SBProcess, WriteMemory, + (lldb::addr_t, const void *, size_t, lldb::SBError &), addr, + src, src_len, sb_error); - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + size_t bytes_written = 0; ProcessSP process_sp(GetSP()); - if (log) - log->Printf("SBProcess(%p)::WriteMemory (addr=0x%" PRIx64 - ", src=%p, src_len=%" PRIu64 ", SBError (%p))...", - static_cast<void *>(process_sp.get()), addr, - static_cast<const void *>(src), static_cast<uint64_t>(src_len), - static_cast<void *>(sb_error.get())); - if (process_sp) { Process::StopLocker stop_locker; if (stop_locker.TryLock(&process_sp->GetRunLock())) { @@ -1082,28 +967,17 @@ size_t SBProcess::WriteMemory(addr_t addr, const void *src, size_t src_len, bytes_written = process_sp->WriteMemory(addr, src, src_len, sb_error.ref()); } else { - if (log) - log->Printf("SBProcess(%p)::WriteMemory() => error: process is running", - static_cast<void *>(process_sp.get())); sb_error.SetErrorString("process is running"); } } - if (log) { - SBStream sstr; - sb_error.GetDescription(sstr); - log->Printf("SBProcess(%p)::WriteMemory (addr=0x%" PRIx64 - ", src=%p, src_len=%" PRIu64 ", SBError (%p): %s) => %" PRIu64, - static_cast<void *>(process_sp.get()), addr, - static_cast<const void *>(src), static_cast<uint64_t>(src_len), - static_cast<void *>(sb_error.get()), sstr.GetData(), - static_cast<uint64_t>(bytes_written)); - } - return bytes_written; } bool SBProcess::GetDescription(SBStream &description) { + LLDB_RECORD_METHOD(bool, SBProcess, GetDescription, (lldb::SBStream &), + description); + Stream &strm = description.ref(); ProcessSP process_sp(GetSP()); @@ -1111,7 +985,7 @@ bool SBProcess::GetDescription(SBStream &description) { char path[PATH_MAX]; GetTarget().GetExecutable().GetPath(path, sizeof(path)); Module *exe_module = process_sp->GetTarget().GetExecutableModulePointer(); - const char *exe_name = NULL; + const char *exe_name = nullptr; if (exe_module) exe_name = exe_module->GetFileSpec().GetFilename().AsCString(); @@ -1127,7 +1001,9 @@ bool SBProcess::GetDescription(SBStream &description) { uint32_t SBProcess::GetNumSupportedHardwareWatchpoints(lldb::SBError &sb_error) const { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_METHOD_CONST(uint32_t, SBProcess, + GetNumSupportedHardwareWatchpoints, + (lldb::SBError &), sb_error); uint32_t num = 0; ProcessSP process_sp(GetSP()); @@ -1135,9 +1011,6 @@ SBProcess::GetNumSupportedHardwareWatchpoints(lldb::SBError &sb_error) const { std::lock_guard<std::recursive_mutex> guard( process_sp->GetTarget().GetAPIMutex()); sb_error.SetError(process_sp->GetWatchpointSupportInfo(num)); - if (log) - log->Printf("SBProcess(%p)::GetNumSupportedHardwareWatchpoints () => %u", - static_cast<void *>(process_sp.get()), num); } else { sb_error.SetErrorString("SBProcess is invalid"); } @@ -1146,39 +1019,34 @@ SBProcess::GetNumSupportedHardwareWatchpoints(lldb::SBError &sb_error) const { uint32_t SBProcess::LoadImage(lldb::SBFileSpec &sb_remote_image_spec, lldb::SBError &sb_error) { + LLDB_RECORD_METHOD(uint32_t, SBProcess, LoadImage, + (lldb::SBFileSpec &, lldb::SBError &), + sb_remote_image_spec, sb_error); + return LoadImage(SBFileSpec(), sb_remote_image_spec, sb_error); } uint32_t SBProcess::LoadImage(const lldb::SBFileSpec &sb_local_image_spec, const lldb::SBFileSpec &sb_remote_image_spec, lldb::SBError &sb_error) { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_METHOD( + uint32_t, SBProcess, LoadImage, + (const lldb::SBFileSpec &, const lldb::SBFileSpec &, lldb::SBError &), + sb_local_image_spec, sb_remote_image_spec, sb_error); + ProcessSP process_sp(GetSP()); if (process_sp) { Process::StopLocker stop_locker; if (stop_locker.TryLock(&process_sp->GetRunLock())) { - if (log) - log->Printf("SBProcess(%p)::LoadImage() => calling Platform::LoadImage" - "for: %s", - static_cast<void *>(process_sp.get()), - sb_local_image_spec.GetFilename()); - std::lock_guard<std::recursive_mutex> guard( process_sp->GetTarget().GetAPIMutex()); PlatformSP platform_sp = process_sp->GetTarget().GetPlatform(); return platform_sp->LoadImage(process_sp.get(), *sb_local_image_spec, *sb_remote_image_spec, sb_error.ref()); } else { - if (log) - log->Printf("SBProcess(%p)::LoadImage() => error: process is running", - static_cast<void *>(process_sp.get())); sb_error.SetErrorString("process is running"); } - } else { - if (log) - log->Printf("SBProcess(%p)::LoadImage() => error: called with invalid" - " process", - static_cast<void *>(process_sp.get())); + } else { sb_error.SetErrorString("process is invalid"); } return LLDB_INVALID_IMAGE_TOKEN; @@ -1186,19 +1054,17 @@ uint32_t SBProcess::LoadImage(const lldb::SBFileSpec &sb_local_image_spec, uint32_t SBProcess::LoadImageUsingPaths(const lldb::SBFileSpec &image_spec, SBStringList &paths, - lldb::SBFileSpec &loaded_path, + lldb::SBFileSpec &loaded_path, lldb::SBError &error) { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_METHOD(uint32_t, SBProcess, LoadImageUsingPaths, + (const lldb::SBFileSpec &, lldb::SBStringList &, + lldb::SBFileSpec &, lldb::SBError &), + image_spec, paths, loaded_path, error); + ProcessSP process_sp(GetSP()); if (process_sp) { Process::StopLocker stop_locker; if (stop_locker.TryLock(&process_sp->GetRunLock())) { - if (log) - log->Printf("SBProcess(%p)::LoadImageUsingPaths() => " - "calling Platform::LoadImageUsingPaths for: %s", - static_cast<void *>(process_sp.get()), - image_spec.GetFilename()); - std::lock_guard<std::recursive_mutex> guard( process_sp->GetTarget().GetAPIMutex()); PlatformSP platform_sp = process_sp->GetTarget().GetPlatform(); @@ -1208,34 +1074,26 @@ uint32_t SBProcess::LoadImageUsingPaths(const lldb::SBFileSpec &image_spec, for (size_t i = 0; i < num_paths; i++) paths_vec.push_back(paths.GetStringAtIndex(i)); FileSpec loaded_spec; - - uint32_t token = platform_sp->LoadImageUsingPaths(process_sp.get(), - *image_spec, - paths_vec, - error.ref(), - &loaded_spec); - if (token != LLDB_INVALID_IMAGE_TOKEN) - loaded_path = loaded_spec; - return token; + + uint32_t token = platform_sp->LoadImageUsingPaths( + process_sp.get(), *image_spec, paths_vec, error.ref(), &loaded_spec); + if (token != LLDB_INVALID_IMAGE_TOKEN) + loaded_path = loaded_spec; + return token; } else { - if (log) - log->Printf("SBProcess(%p)::LoadImageUsingPaths() => error: " - "process is running", - static_cast<void *>(process_sp.get())); error.SetErrorString("process is running"); } - } else { - if (log) - log->Printf("SBProcess(%p)::LoadImageUsingPaths() => error: " - "called with invalid process", - static_cast<void *>(process_sp.get())); + } else { error.SetErrorString("process is invalid"); } - + return LLDB_INVALID_IMAGE_TOKEN; } lldb::SBError SBProcess::UnloadImage(uint32_t image_token) { + LLDB_RECORD_METHOD(lldb::SBError, SBProcess, UnloadImage, (uint32_t), + image_token); + lldb::SBError sb_error; ProcessSP process_sp(GetSP()); if (process_sp) { @@ -1247,18 +1105,17 @@ lldb::SBError SBProcess::UnloadImage(uint32_t image_token) { sb_error.SetError( platform_sp->UnloadImage(process_sp.get(), image_token)); } else { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf("SBProcess(%p)::UnloadImage() => error: process is running", - static_cast<void *>(process_sp.get())); sb_error.SetErrorString("process is running"); } } else sb_error.SetErrorString("invalid process"); - return sb_error; + return LLDB_RECORD_RESULT(sb_error); } lldb::SBError SBProcess::SendEventData(const char *event_data) { + LLDB_RECORD_METHOD(lldb::SBError, SBProcess, SendEventData, (const char *), + event_data); + lldb::SBError sb_error; ProcessSP process_sp(GetSP()); if (process_sp) { @@ -1268,19 +1125,16 @@ lldb::SBError SBProcess::SendEventData(const char *event_data) { process_sp->GetTarget().GetAPIMutex()); sb_error.SetError(process_sp->SendEventData(event_data)); } else { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf( - "SBProcess(%p)::SendEventData() => error: process is running", - static_cast<void *>(process_sp.get())); sb_error.SetErrorString("process is running"); } } else sb_error.SetErrorString("invalid process"); - return sb_error; + return LLDB_RECORD_RESULT(sb_error); } uint32_t SBProcess::GetNumExtendedBacktraceTypes() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumExtendedBacktraceTypes); + ProcessSP process_sp(GetSP()); if (process_sp && process_sp->GetSystemRuntime()) { SystemRuntime *runtime = process_sp->GetSystemRuntime(); @@ -1290,6 +1144,9 @@ uint32_t SBProcess::GetNumExtendedBacktraceTypes() { } const char *SBProcess::GetExtendedBacktraceTypeAtIndex(uint32_t idx) { + LLDB_RECORD_METHOD(const char *, SBProcess, GetExtendedBacktraceTypeAtIndex, + (uint32_t), idx); + ProcessSP process_sp(GetSP()); if (process_sp && process_sp->GetSystemRuntime()) { SystemRuntime *runtime = process_sp->GetSystemRuntime(); @@ -1297,28 +1154,28 @@ const char *SBProcess::GetExtendedBacktraceTypeAtIndex(uint32_t idx) { runtime->GetExtendedBacktraceTypes(); if (idx < names.size()) { return names[idx].AsCString(); - } else { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf("SBProcess(%p)::GetExtendedBacktraceTypeAtIndex() => " - "error: requested extended backtrace name out of bounds", - static_cast<void *>(process_sp.get())); } } - return NULL; + return nullptr; } SBThreadCollection SBProcess::GetHistoryThreads(addr_t addr) { + LLDB_RECORD_METHOD(lldb::SBThreadCollection, SBProcess, GetHistoryThreads, + (lldb::addr_t), addr); + ProcessSP process_sp(GetSP()); SBThreadCollection threads; if (process_sp) { threads = SBThreadCollection(process_sp->GetHistoryThreads(addr)); } - return threads; + return LLDB_RECORD_RESULT(threads); } bool SBProcess::IsInstrumentationRuntimePresent( InstrumentationRuntimeType type) { + LLDB_RECORD_METHOD(bool, SBProcess, IsInstrumentationRuntimePresent, + (lldb::InstrumentationRuntimeType), type); + ProcessSP process_sp(GetSP()); if (!process_sp) return false; @@ -1333,11 +1190,14 @@ bool SBProcess::IsInstrumentationRuntimePresent( } lldb::SBError SBProcess::SaveCore(const char *file_name) { + LLDB_RECORD_METHOD(lldb::SBError, SBProcess, SaveCore, (const char *), + file_name); + lldb::SBError error; ProcessSP process_sp(GetSP()); if (!process_sp) { error.SetErrorString("SBProcess is invalid"); - return error; + return LLDB_RECORD_RESULT(error); } std::lock_guard<std::recursive_mutex> guard( @@ -1345,17 +1205,21 @@ lldb::SBError SBProcess::SaveCore(const char *file_name) { if (process_sp->GetState() != eStateStopped) { error.SetErrorString("the process is not stopped"); - return error; + return LLDB_RECORD_RESULT(error); } FileSpec core_file(file_name); error.ref() = PluginManager::SaveCore(process_sp, core_file); - return error; + return LLDB_RECORD_RESULT(error); } lldb::SBError SBProcess::GetMemoryRegionInfo(lldb::addr_t load_addr, SBMemoryRegionInfo &sb_region_info) { + LLDB_RECORD_METHOD(lldb::SBError, SBProcess, GetMemoryRegionInfo, + (lldb::addr_t, lldb::SBMemoryRegionInfo &), load_addr, + sb_region_info); + lldb::SBError sb_error; ProcessSP process_sp(GetSP()); if (process_sp) { @@ -1367,20 +1231,18 @@ SBProcess::GetMemoryRegionInfo(lldb::addr_t load_addr, sb_error.ref() = process_sp->GetMemoryRegionInfo(load_addr, sb_region_info.ref()); } else { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf( - "SBProcess(%p)::GetMemoryRegionInfo() => error: process is running", - static_cast<void *>(process_sp.get())); sb_error.SetErrorString("process is running"); } } else { sb_error.SetErrorString("SBProcess is invalid"); } - return sb_error; + return LLDB_RECORD_RESULT(sb_error); } lldb::SBMemoryRegionInfoList SBProcess::GetMemoryRegions() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBMemoryRegionInfoList, SBProcess, + GetMemoryRegions); + lldb::SBMemoryRegionInfoList sb_region_list; ProcessSP process_sp(GetSP()); @@ -1390,23 +1252,153 @@ lldb::SBMemoryRegionInfoList SBProcess::GetMemoryRegions() { process_sp->GetTarget().GetAPIMutex()); process_sp->GetMemoryRegions(sb_region_list.ref()); - } else { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf( - "SBProcess(%p)::GetMemoryRegionInfo() => error: process is running", - static_cast<void *>(process_sp.get())); } - return sb_region_list; + return LLDB_RECORD_RESULT(sb_region_list); } lldb::SBProcessInfo SBProcess::GetProcessInfo() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcessInfo, SBProcess, GetProcessInfo); + lldb::SBProcessInfo sb_proc_info; ProcessSP process_sp(GetSP()); ProcessInstanceInfo proc_info; if (process_sp && process_sp->GetProcessInfo(proc_info)) { sb_proc_info.SetProcessInfo(proc_info); } - return sb_proc_info; + return LLDB_RECORD_RESULT(sb_proc_info); +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBProcess>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBProcess, ()); + LLDB_REGISTER_CONSTRUCTOR(SBProcess, (const lldb::SBProcess &)); + LLDB_REGISTER_CONSTRUCTOR(SBProcess, (const lldb::ProcessSP &)); + LLDB_REGISTER_METHOD(const lldb::SBProcess &, + SBProcess, operator=,(const lldb::SBProcess &)); + LLDB_REGISTER_STATIC_METHOD(const char *, SBProcess, + GetBroadcasterClassName, ()); + LLDB_REGISTER_METHOD(const char *, SBProcess, GetPluginName, ()); + LLDB_REGISTER_METHOD(const char *, SBProcess, GetShortPluginName, ()); + LLDB_REGISTER_METHOD(void, SBProcess, Clear, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBProcess, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBProcess, operator bool, ()); + LLDB_REGISTER_METHOD(bool, SBProcess, RemoteLaunch, + (const char **, const char **, const char *, + const char *, const char *, const char *, uint32_t, + bool, lldb::SBError &)); + LLDB_REGISTER_METHOD(bool, SBProcess, RemoteAttachToProcessWithID, + (lldb::pid_t, lldb::SBError &)); + LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetNumThreads, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBProcess, GetSelectedThread, + ()); + LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, CreateOSPluginThread, + (lldb::tid_t, lldb::addr_t)); + LLDB_REGISTER_METHOD_CONST(lldb::SBTarget, SBProcess, GetTarget, ()); + LLDB_REGISTER_METHOD(size_t, SBProcess, PutSTDIN, (const char *, size_t)); + LLDB_REGISTER_METHOD_CONST(size_t, SBProcess, GetSTDOUT, (char *, size_t)); + LLDB_REGISTER_METHOD_CONST(size_t, SBProcess, GetSTDERR, (char *, size_t)); + LLDB_REGISTER_METHOD_CONST(size_t, SBProcess, GetAsyncProfileData, + (char *, size_t)); + LLDB_REGISTER_METHOD(lldb::SBTrace, SBProcess, StartTrace, + (lldb::SBTraceOptions &, lldb::SBError &)); + LLDB_REGISTER_METHOD_CONST(void, SBProcess, ReportEventState, + (const lldb::SBEvent &, FILE *)); + LLDB_REGISTER_METHOD( + void, SBProcess, AppendEventStateReport, + (const lldb::SBEvent &, lldb::SBCommandReturnObject &)); + LLDB_REGISTER_METHOD(bool, SBProcess, SetSelectedThread, + (const lldb::SBThread &)); + LLDB_REGISTER_METHOD(bool, SBProcess, SetSelectedThreadByID, (lldb::tid_t)); + LLDB_REGISTER_METHOD(bool, SBProcess, SetSelectedThreadByIndexID, + (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, GetThreadAtIndex, (size_t)); + LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetNumQueues, ()); + LLDB_REGISTER_METHOD(lldb::SBQueue, SBProcess, GetQueueAtIndex, (size_t)); + LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetStopID, (bool)); + LLDB_REGISTER_METHOD(lldb::SBEvent, SBProcess, GetStopEventForStopID, + (uint32_t)); + LLDB_REGISTER_METHOD(lldb::StateType, SBProcess, GetState, ()); + LLDB_REGISTER_METHOD(int, SBProcess, GetExitStatus, ()); + LLDB_REGISTER_METHOD(const char *, SBProcess, GetExitDescription, ()); + LLDB_REGISTER_METHOD(lldb::pid_t, SBProcess, GetProcessID, ()); + LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetUniqueID, ()); + LLDB_REGISTER_METHOD_CONST(lldb::ByteOrder, SBProcess, GetByteOrder, ()); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBProcess, GetAddressByteSize, ()); + LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Continue, ()); + LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Destroy, ()); + LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Stop, ()); + LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Kill, ()); + LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Detach, ()); + LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Detach, (bool)); + LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Signal, (int)); + LLDB_REGISTER_METHOD(lldb::SBUnixSignals, SBProcess, GetUnixSignals, ()); + LLDB_REGISTER_METHOD(void, SBProcess, SendAsyncInterrupt, ()); + LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, GetThreadByID, + (lldb::tid_t)); + LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, GetThreadByIndexID, + (uint32_t)); + LLDB_REGISTER_STATIC_METHOD(lldb::StateType, SBProcess, GetStateFromEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, GetRestartedFromEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_STATIC_METHOD(size_t, SBProcess, + GetNumRestartedReasonsFromEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_STATIC_METHOD(const char *, SBProcess, + GetRestartedReasonAtIndexFromEvent, + (const lldb::SBEvent &, size_t)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBProcess, SBProcess, GetProcessFromEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, GetInterruptedFromEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBStructuredData, SBProcess, + GetStructuredDataFromEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, EventIsProcessEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, EventIsStructuredDataEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_METHOD_CONST(lldb::SBBroadcaster, SBProcess, GetBroadcaster, + ()); + LLDB_REGISTER_STATIC_METHOD(const char *, SBProcess, GetBroadcasterClass, + ()); + LLDB_REGISTER_METHOD(uint64_t, SBProcess, ReadUnsignedFromMemory, + (lldb::addr_t, uint32_t, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::addr_t, SBProcess, ReadPointerFromMemory, + (lldb::addr_t, lldb::SBError &)); + LLDB_REGISTER_METHOD(bool, SBProcess, GetDescription, (lldb::SBStream &)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBProcess, + GetNumSupportedHardwareWatchpoints, + (lldb::SBError &)); + LLDB_REGISTER_METHOD(uint32_t, SBProcess, LoadImage, + (lldb::SBFileSpec &, lldb::SBError &)); + LLDB_REGISTER_METHOD( + uint32_t, SBProcess, LoadImage, + (const lldb::SBFileSpec &, const lldb::SBFileSpec &, lldb::SBError &)); + LLDB_REGISTER_METHOD(uint32_t, SBProcess, LoadImageUsingPaths, + (const lldb::SBFileSpec &, lldb::SBStringList &, + lldb::SBFileSpec &, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, UnloadImage, (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, SendEventData, + (const char *)); + LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetNumExtendedBacktraceTypes, ()); + LLDB_REGISTER_METHOD(const char *, SBProcess, + GetExtendedBacktraceTypeAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBThreadCollection, SBProcess, GetHistoryThreads, + (lldb::addr_t)); + LLDB_REGISTER_METHOD(bool, SBProcess, IsInstrumentationRuntimePresent, + (lldb::InstrumentationRuntimeType)); + LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, SaveCore, (const char *)); + LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, GetMemoryRegionInfo, + (lldb::addr_t, lldb::SBMemoryRegionInfo &)); + LLDB_REGISTER_METHOD(lldb::SBMemoryRegionInfoList, SBProcess, + GetMemoryRegions, ()); + LLDB_REGISTER_METHOD(lldb::SBProcessInfo, SBProcess, GetProcessInfo, ()); +} + +} } |