diff options
Diffstat (limited to 'source/API/SBBreakpointLocation.cpp')
| -rw-r--r-- | source/API/SBBreakpointLocation.cpp | 212 |
1 files changed, 172 insertions, 40 deletions
diff --git a/source/API/SBBreakpointLocation.cpp b/source/API/SBBreakpointLocation.cpp index 99ac0277e7000..640545f55ef97 100644 --- a/source/API/SBBreakpointLocation.cpp +++ b/source/API/SBBreakpointLocation.cpp @@ -1,13 +1,13 @@ //===-- SBBreakpointLocation.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/SBBreakpointLocation.h" +#include "SBReproducerPrivate.h" #include "lldb/API/SBAddress.h" #include "lldb/API/SBDebugger.h" #include "lldb/API/SBDefines.h" @@ -22,7 +22,6 @@ #include "lldb/Interpreter/ScriptInterpreter.h" #include "lldb/Target/Target.h" #include "lldb/Target/ThreadSpec.h" -#include "lldb/Utility/Log.h" #include "lldb/Utility/Stream.h" #include "lldb/lldb-defines.h" #include "lldb/lldb-types.h" @@ -30,27 +29,32 @@ using namespace lldb; using namespace lldb_private; -SBBreakpointLocation::SBBreakpointLocation() {} +SBBreakpointLocation::SBBreakpointLocation() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBreakpointLocation); +} SBBreakpointLocation::SBBreakpointLocation( const lldb::BreakpointLocationSP &break_loc_sp) : m_opaque_wp(break_loc_sp) { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - - if (log) { - SBStream sstr; - GetDescription(sstr, lldb::eDescriptionLevelBrief); - LLDB_LOG(log, "location = {0} ({1})", break_loc_sp.get(), sstr.GetData()); - } + LLDB_RECORD_CONSTRUCTOR(SBBreakpointLocation, + (const lldb::BreakpointLocationSP &), break_loc_sp); } SBBreakpointLocation::SBBreakpointLocation(const SBBreakpointLocation &rhs) - : m_opaque_wp(rhs.m_opaque_wp) {} + : m_opaque_wp(rhs.m_opaque_wp) { + LLDB_RECORD_CONSTRUCTOR(SBBreakpointLocation, + (const lldb::SBBreakpointLocation &), rhs); +} const SBBreakpointLocation &SBBreakpointLocation:: operator=(const SBBreakpointLocation &rhs) { + LLDB_RECORD_METHOD( + const lldb::SBBreakpointLocation &, + SBBreakpointLocation, operator=,(const lldb::SBBreakpointLocation &), + rhs); + m_opaque_wp = rhs.m_opaque_wp; - return *this; + return LLDB_RECORD_RESULT(*this); } SBBreakpointLocation::~SBBreakpointLocation() {} @@ -59,17 +63,31 @@ BreakpointLocationSP SBBreakpointLocation::GetSP() const { return m_opaque_wp.lock(); } -bool SBBreakpointLocation::IsValid() const { return bool(GetSP()); } +bool SBBreakpointLocation::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointLocation, IsValid); + return this->operator bool(); +} +SBBreakpointLocation::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointLocation, operator bool); + + return bool(GetSP()); +} SBAddress SBBreakpointLocation::GetAddress() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBBreakpointLocation, GetAddress); + BreakpointLocationSP loc_sp = GetSP(); - if (loc_sp) - return SBAddress(&loc_sp->GetAddress()); - else - return SBAddress(); + if (loc_sp) { + return LLDB_RECORD_RESULT(SBAddress(&loc_sp->GetAddress())); + } + + return LLDB_RECORD_RESULT(SBAddress()); } addr_t SBBreakpointLocation::GetLoadAddress() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBBreakpointLocation, + GetLoadAddress); + addr_t ret_addr = LLDB_INVALID_ADDRESS; BreakpointLocationSP loc_sp = GetSP(); @@ -83,6 +101,8 @@ addr_t SBBreakpointLocation::GetLoadAddress() { } void SBBreakpointLocation::SetEnabled(bool enabled) { + LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetEnabled, (bool), enabled); + BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( @@ -92,6 +112,8 @@ void SBBreakpointLocation::SetEnabled(bool enabled) { } bool SBBreakpointLocation::IsEnabled() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointLocation, IsEnabled); + BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( @@ -102,6 +124,8 @@ bool SBBreakpointLocation::IsEnabled() { } uint32_t SBBreakpointLocation::GetHitCount() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBBreakpointLocation, GetHitCount); + BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( @@ -112,6 +136,8 @@ uint32_t SBBreakpointLocation::GetHitCount() { } uint32_t SBBreakpointLocation::GetIgnoreCount() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBBreakpointLocation, GetIgnoreCount); + BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( @@ -122,6 +148,8 @@ uint32_t SBBreakpointLocation::GetIgnoreCount() { } void SBBreakpointLocation::SetIgnoreCount(uint32_t n) { + LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetIgnoreCount, (uint32_t), n); + BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( @@ -131,6 +159,9 @@ void SBBreakpointLocation::SetIgnoreCount(uint32_t n) { } void SBBreakpointLocation::SetCondition(const char *condition) { + LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetCondition, (const char *), + condition); + BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( @@ -140,16 +171,21 @@ void SBBreakpointLocation::SetCondition(const char *condition) { } const char *SBBreakpointLocation::GetCondition() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBBreakpointLocation, GetCondition); + BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( loc_sp->GetTarget().GetAPIMutex()); return loc_sp->GetConditionText(); } - return NULL; + return nullptr; } void SBBreakpointLocation::SetAutoContinue(bool auto_continue) { + LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetAutoContinue, (bool), + auto_continue); + BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( @@ -159,6 +195,8 @@ void SBBreakpointLocation::SetAutoContinue(bool auto_continue) { } bool SBBreakpointLocation::GetAutoContinue() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointLocation, GetAutoContinue); + BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( @@ -170,10 +208,10 @@ bool SBBreakpointLocation::GetAutoContinue() { void SBBreakpointLocation::SetScriptCallbackFunction( const char *callback_function_name) { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetScriptCallbackFunction, + (const char *), callback_function_name); + BreakpointLocationSP loc_sp = GetSP(); - LLDB_LOG(log, "location = {0}, callback = {1}", loc_sp.get(), - callback_function_name); if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( @@ -182,7 +220,6 @@ void SBBreakpointLocation::SetScriptCallbackFunction( loc_sp->GetBreakpoint() .GetTarget() .GetDebugger() - .GetCommandInterpreter() .GetScriptInterpreter() ->SetBreakpointCommandCallbackFunction(bp_options, callback_function_name); @@ -191,10 +228,10 @@ void SBBreakpointLocation::SetScriptCallbackFunction( SBError SBBreakpointLocation::SetScriptCallbackBody(const char *callback_body_text) { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_METHOD(lldb::SBError, SBBreakpointLocation, SetScriptCallbackBody, + (const char *), callback_body_text); + BreakpointLocationSP loc_sp = GetSP(); - LLDB_LOG(log, "location = {0}: callback body:\n{1}", loc_sp.get(), - callback_body_text); SBError sb_error; if (loc_sp) { @@ -205,17 +242,19 @@ SBBreakpointLocation::SetScriptCallbackBody(const char *callback_body_text) { loc_sp->GetBreakpoint() .GetTarget() .GetDebugger() - .GetCommandInterpreter() .GetScriptInterpreter() ->SetBreakpointCommandCallback(bp_options, callback_body_text); sb_error.SetError(error); } else sb_error.SetErrorString("invalid breakpoint"); - return sb_error; + return LLDB_RECORD_RESULT(sb_error); } void SBBreakpointLocation::SetCommandLineCommands(SBStringList &commands) { + LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetCommandLineCommands, + (lldb::SBStringList &), commands); + BreakpointLocationSP loc_sp = GetSP(); if (!loc_sp) return; @@ -231,6 +270,9 @@ void SBBreakpointLocation::SetCommandLineCommands(SBStringList &commands) { } bool SBBreakpointLocation::GetCommandLineCommands(SBStringList &commands) { + LLDB_RECORD_METHOD(bool, SBBreakpointLocation, GetCommandLineCommands, + (lldb::SBStringList &), commands); + BreakpointLocationSP loc_sp = GetSP(); if (!loc_sp) return false; @@ -243,6 +285,9 @@ bool SBBreakpointLocation::GetCommandLineCommands(SBStringList &commands) { } void SBBreakpointLocation::SetThreadID(tid_t thread_id) { + LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetThreadID, (lldb::tid_t), + thread_id); + BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( @@ -252,6 +297,8 @@ void SBBreakpointLocation::SetThreadID(tid_t thread_id) { } tid_t SBBreakpointLocation::GetThreadID() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBBreakpointLocation, GetThreadID); + tid_t tid = LLDB_INVALID_THREAD_ID; BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { @@ -263,6 +310,9 @@ tid_t SBBreakpointLocation::GetThreadID() { } void SBBreakpointLocation::SetThreadIndex(uint32_t index) { + LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetThreadIndex, (uint32_t), + index); + BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( @@ -272,6 +322,9 @@ void SBBreakpointLocation::SetThreadIndex(uint32_t index) { } uint32_t SBBreakpointLocation::GetThreadIndex() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointLocation, + GetThreadIndex); + uint32_t thread_idx = UINT32_MAX; BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { @@ -283,6 +336,9 @@ uint32_t SBBreakpointLocation::GetThreadIndex() const { } void SBBreakpointLocation::SetThreadName(const char *thread_name) { + LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetThreadName, (const char *), + thread_name); + BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( @@ -292,16 +348,22 @@ void SBBreakpointLocation::SetThreadName(const char *thread_name) { } const char *SBBreakpointLocation::GetThreadName() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointLocation, + GetThreadName); + BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( loc_sp->GetTarget().GetAPIMutex()); return loc_sp->GetThreadName(); } - return NULL; + return nullptr; } void SBBreakpointLocation::SetQueueName(const char *queue_name) { + LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetQueueName, (const char *), + queue_name); + BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( @@ -311,16 +373,21 @@ void SBBreakpointLocation::SetQueueName(const char *queue_name) { } const char *SBBreakpointLocation::GetQueueName() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointLocation, + GetQueueName); + BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( loc_sp->GetTarget().GetAPIMutex()); loc_sp->GetQueueName(); } - return NULL; + return nullptr; } bool SBBreakpointLocation::IsResolved() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointLocation, IsResolved); + BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( @@ -338,6 +405,10 @@ void SBBreakpointLocation::SetLocation( bool SBBreakpointLocation::GetDescription(SBStream &description, DescriptionLevel level) { + LLDB_RECORD_METHOD(bool, SBBreakpointLocation, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel), description, + level); + Stream &strm = description.ref(); BreakpointLocationSP loc_sp = GetSP(); @@ -353,6 +424,8 @@ bool SBBreakpointLocation::GetDescription(SBStream &description, } break_id_t SBBreakpointLocation::GetID() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::break_id_t, SBBreakpointLocation, GetID); + BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { std::lock_guard<std::recursive_mutex> guard( @@ -363,7 +436,9 @@ break_id_t SBBreakpointLocation::GetID() { } SBBreakpoint SBBreakpointLocation::GetBreakpoint() { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBreakpoint, SBBreakpointLocation, + GetBreakpoint); + BreakpointLocationSP loc_sp = GetSP(); SBBreakpoint sb_bp; @@ -373,11 +448,68 @@ SBBreakpoint SBBreakpointLocation::GetBreakpoint() { sb_bp = loc_sp->GetBreakpoint().shared_from_this(); } - if (log) { - SBStream sstr; - sb_bp.GetDescription(sstr); - LLDB_LOG(log, "location = {0}, breakpoint = {1} ({2})", loc_sp.get(), - sb_bp.GetSP().get(), sstr.GetData()); - } - return sb_bp; + return LLDB_RECORD_RESULT(sb_bp); +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBBreakpointLocation>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBBreakpointLocation, ()); + LLDB_REGISTER_CONSTRUCTOR(SBBreakpointLocation, + (const lldb::BreakpointLocationSP &)); + LLDB_REGISTER_CONSTRUCTOR(SBBreakpointLocation, + (const lldb::SBBreakpointLocation &)); + LLDB_REGISTER_METHOD( + const lldb::SBBreakpointLocation &, + SBBreakpointLocation, operator=,(const lldb::SBBreakpointLocation &)); + LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointLocation, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointLocation, operator bool, ()); + LLDB_REGISTER_METHOD(lldb::SBAddress, SBBreakpointLocation, GetAddress, ()); + LLDB_REGISTER_METHOD(lldb::addr_t, SBBreakpointLocation, GetLoadAddress, + ()); + LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetEnabled, (bool)); + LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, IsEnabled, ()); + LLDB_REGISTER_METHOD(uint32_t, SBBreakpointLocation, GetHitCount, ()); + LLDB_REGISTER_METHOD(uint32_t, SBBreakpointLocation, GetIgnoreCount, ()); + LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetIgnoreCount, + (uint32_t)); + LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetCondition, + (const char *)); + LLDB_REGISTER_METHOD(const char *, SBBreakpointLocation, GetCondition, ()); + LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetAutoContinue, (bool)); + LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, GetAutoContinue, ()); + LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetScriptCallbackFunction, + (const char *)); + LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpointLocation, + SetScriptCallbackBody, (const char *)); + LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetCommandLineCommands, + (lldb::SBStringList &)); + LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, GetCommandLineCommands, + (lldb::SBStringList &)); + LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetThreadID, + (lldb::tid_t)); + LLDB_REGISTER_METHOD(lldb::tid_t, SBBreakpointLocation, GetThreadID, ()); + LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetThreadIndex, + (uint32_t)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpointLocation, GetThreadIndex, + ()); + LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetThreadName, + (const char *)); + LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointLocation, + GetThreadName, ()); + LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetQueueName, + (const char *)); + LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointLocation, GetQueueName, + ()); + LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, IsResolved, ()); + LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel)); + LLDB_REGISTER_METHOD(lldb::break_id_t, SBBreakpointLocation, GetID, ()); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBBreakpointLocation, + GetBreakpoint, ()); +} + +} } |