diff options
| author | Jonas Devlieghere <jonas@devlieghere.com> | 2019-03-06 00:06:00 +0000 |
|---|---|---|
| committer | Jonas Devlieghere <jonas@devlieghere.com> | 2019-03-06 00:06:00 +0000 |
| commit | baf5664f5056b13329db8410f19d9fe7aca77686 (patch) | |
| tree | a4b267266e551c167bdb7fd7c508fd148d0d9b7a /lldb/source/API | |
| parent | bd4bf82a48c2b5b632766593916f8d7ea98c9e0a (diff) | |
| download | bcm5719-llvm-baf5664f5056b13329db8410f19d9fe7aca77686.tar.gz bcm5719-llvm-baf5664f5056b13329db8410f19d9fe7aca77686.zip | |
[Reproducers] Add SBReproducer macros
This patch adds the SBReproducer macros needed to capture and reply the
corresponding calls. This patch was generated by running the lldb-instr
tool on the API source files.
Differential revision: https://reviews.llvm.org/D57475
llvm-svn: 355459
Diffstat (limited to 'lldb/source/API')
66 files changed, 8842 insertions, 983 deletions
diff --git a/lldb/source/API/SBAddress.cpp b/lldb/source/API/SBAddress.cpp index e7dcbd30c0d..cad1eb8aada 100644 --- a/lldb/source/API/SBAddress.cpp +++ b/lldb/source/API/SBAddress.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBAddress.h" +#include "SBReproducerPrivate.h" #include "Utils.h" #include "lldb/API/SBProcess.h" #include "lldb/API/SBSection.h" @@ -21,7 +22,9 @@ using namespace lldb; using namespace lldb_private; -SBAddress::SBAddress() : m_opaque_up(new Address()) {} +SBAddress::SBAddress() : m_opaque_up(new Address()) { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBAddress); +} SBAddress::SBAddress(const Address *lldb_object_ptr) : m_opaque_up(new Address()) { @@ -30,21 +33,32 @@ SBAddress::SBAddress(const Address *lldb_object_ptr) } SBAddress::SBAddress(const SBAddress &rhs) : m_opaque_up(new Address()) { + LLDB_RECORD_CONSTRUCTOR(SBAddress, (const lldb::SBAddress &), rhs); + m_opaque_up = clone(rhs.m_opaque_up); } SBAddress::SBAddress(lldb::SBSection section, lldb::addr_t offset) - : m_opaque_up(new Address(section.GetSP(), offset)) {} + : m_opaque_up(new Address(section.GetSP(), offset)) { + LLDB_RECORD_CONSTRUCTOR(SBAddress, (lldb::SBSection, lldb::addr_t), section, + offset); +} // Create an address by resolving a load address using the supplied target SBAddress::SBAddress(lldb::addr_t load_addr, lldb::SBTarget &target) : m_opaque_up(new Address()) { + LLDB_RECORD_CONSTRUCTOR(SBAddress, (lldb::addr_t, lldb::SBTarget &), + load_addr, target); + SetLoadAddress(load_addr, target); } SBAddress::~SBAddress() {} const SBAddress &SBAddress::operator=(const SBAddress &rhs) { + LLDB_RECORD_METHOD(const lldb::SBAddress &, + SBAddress, operator=,(const lldb::SBAddress &), rhs); + if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); return *this; @@ -57,12 +71,21 @@ bool lldb::operator==(const SBAddress &lhs, const SBAddress &rhs) { } bool SBAddress::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBAddress, IsValid); + return m_opaque_up != NULL && m_opaque_up->IsValid(); } -void SBAddress::Clear() { m_opaque_up.reset(new Address()); } +void SBAddress::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBAddress, Clear); + + m_opaque_up.reset(new Address()); +} void SBAddress::SetAddress(lldb::SBSection section, lldb::addr_t offset) { + LLDB_RECORD_METHOD(void, SBAddress, SetAddress, + (lldb::SBSection, lldb::addr_t), section, offset); + Address &addr = ref(); addr.SetSection(section.GetSP()); addr.SetOffset(offset); @@ -76,6 +99,8 @@ void SBAddress::SetAddress(const Address *lldb_object_ptr) { } lldb::addr_t SBAddress::GetFileAddress() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBAddress, GetFileAddress); + if (m_opaque_up->IsValid()) return m_opaque_up->GetFileAddress(); else @@ -83,6 +108,9 @@ lldb::addr_t SBAddress::GetFileAddress() const { } lldb::addr_t SBAddress::GetLoadAddress(const SBTarget &target) const { + LLDB_RECORD_METHOD_CONST(lldb::addr_t, SBAddress, GetLoadAddress, + (const lldb::SBTarget &), target); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); lldb::addr_t addr = LLDB_INVALID_ADDRESS; @@ -108,6 +136,9 @@ lldb::addr_t SBAddress::GetLoadAddress(const SBTarget &target) const { } void SBAddress::SetLoadAddress(lldb::addr_t load_addr, lldb::SBTarget &target) { + LLDB_RECORD_METHOD(void, SBAddress, SetLoadAddress, + (lldb::addr_t, lldb::SBTarget &), load_addr, target); + // Create the address object if we don't already have one ref(); if (target.IsValid()) @@ -123,6 +154,8 @@ void SBAddress::SetLoadAddress(lldb::addr_t load_addr, lldb::SBTarget &target) { } bool SBAddress::OffsetAddress(addr_t offset) { + LLDB_RECORD_METHOD(bool, SBAddress, OffsetAddress, (lldb::addr_t), offset); + if (m_opaque_up->IsValid()) { addr_t addr_offset = m_opaque_up->GetOffset(); if (addr_offset != LLDB_INVALID_ADDRESS) { @@ -134,13 +167,17 @@ bool SBAddress::OffsetAddress(addr_t offset) { } lldb::SBSection SBAddress::GetSection() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSection, SBAddress, GetSection); + lldb::SBSection sb_section; if (m_opaque_up->IsValid()) sb_section.SetSP(m_opaque_up->GetSection()); - return sb_section; + return LLDB_RECORD_RESULT(sb_section); } lldb::addr_t SBAddress::GetOffset() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBAddress, GetOffset); + if (m_opaque_up->IsValid()) return m_opaque_up->GetOffset(); return 0; @@ -166,6 +203,9 @@ const Address &SBAddress::ref() const { Address *SBAddress::get() { return m_opaque_up.get(); } bool SBAddress::GetDescription(SBStream &description) { + LLDB_RECORD_METHOD(bool, SBAddress, GetDescription, (lldb::SBStream &), + description); + // Call "ref()" on the stream to make sure it creates a backing stream in // case there isn't one already... Stream &strm = description.ref(); @@ -185,54 +225,69 @@ bool SBAddress::GetDescription(SBStream &description) { } SBModule SBAddress::GetModule() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBModule, SBAddress, GetModule); + SBModule sb_module; if (m_opaque_up->IsValid()) sb_module.SetSP(m_opaque_up->GetModule()); - return sb_module; + return LLDB_RECORD_RESULT(sb_module); } SBSymbolContext SBAddress::GetSymbolContext(uint32_t resolve_scope) { + LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBAddress, GetSymbolContext, + (uint32_t), resolve_scope); + SBSymbolContext sb_sc; SymbolContextItem scope = static_cast<SymbolContextItem>(resolve_scope); if (m_opaque_up->IsValid()) m_opaque_up->CalculateSymbolContext(&sb_sc.ref(), scope); - return sb_sc; + return LLDB_RECORD_RESULT(sb_sc); } SBCompileUnit SBAddress::GetCompileUnit() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCompileUnit, SBAddress, GetCompileUnit); + SBCompileUnit sb_comp_unit; if (m_opaque_up->IsValid()) sb_comp_unit.reset(m_opaque_up->CalculateSymbolContextCompileUnit()); - return sb_comp_unit; + return LLDB_RECORD_RESULT(sb_comp_unit); } SBFunction SBAddress::GetFunction() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFunction, SBAddress, GetFunction); + SBFunction sb_function; if (m_opaque_up->IsValid()) sb_function.reset(m_opaque_up->CalculateSymbolContextFunction()); - return sb_function; + return LLDB_RECORD_RESULT(sb_function); } SBBlock SBAddress::GetBlock() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBAddress, GetBlock); + SBBlock sb_block; if (m_opaque_up->IsValid()) sb_block.SetPtr(m_opaque_up->CalculateSymbolContextBlock()); - return sb_block; + return LLDB_RECORD_RESULT(sb_block); } SBSymbol SBAddress::GetSymbol() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSymbol, SBAddress, GetSymbol); + SBSymbol sb_symbol; if (m_opaque_up->IsValid()) sb_symbol.reset(m_opaque_up->CalculateSymbolContextSymbol()); - return sb_symbol; + return LLDB_RECORD_RESULT(sb_symbol); } SBLineEntry SBAddress::GetLineEntry() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBLineEntry, SBAddress, GetLineEntry); + SBLineEntry sb_line_entry; if (m_opaque_up->IsValid()) { LineEntry line_entry; if (m_opaque_up->CalculateSymbolContextLineEntry(line_entry)) sb_line_entry.SetLineEntry(line_entry); } - return sb_line_entry; + return LLDB_RECORD_RESULT(sb_line_entry); } diff --git a/lldb/source/API/SBAttachInfo.cpp b/lldb/source/API/SBAttachInfo.cpp index c51964bed70..56cc6bb3be4 100644 --- a/lldb/source/API/SBAttachInfo.cpp +++ b/lldb/source/API/SBAttachInfo.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBAttachInfo.h" +#include "SBReproducerPrivate.h" #include "Utils.h" #include "lldb/API/SBFileSpec.h" #include "lldb/API/SBListener.h" @@ -15,15 +16,21 @@ using namespace lldb; using namespace lldb_private; -SBAttachInfo::SBAttachInfo() : m_opaque_sp(new ProcessAttachInfo()) {} +SBAttachInfo::SBAttachInfo() : m_opaque_sp(new ProcessAttachInfo()) { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBAttachInfo); +} SBAttachInfo::SBAttachInfo(lldb::pid_t pid) : m_opaque_sp(new ProcessAttachInfo()) { + LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (lldb::pid_t), pid); + m_opaque_sp->SetProcessID(pid); } SBAttachInfo::SBAttachInfo(const char *path, bool wait_for) : m_opaque_sp(new ProcessAttachInfo()) { + LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (const char *, bool), path, wait_for); + if (path && path[0]) m_opaque_sp->GetExecutableFile().SetFile(path, FileSpec::Style::native); m_opaque_sp->SetWaitForLaunch(wait_for); @@ -31,6 +38,9 @@ SBAttachInfo::SBAttachInfo(const char *path, bool wait_for) SBAttachInfo::SBAttachInfo(const char *path, bool wait_for, bool async) : m_opaque_sp(new ProcessAttachInfo()) { + LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (const char *, bool, bool), path, + wait_for, async); + if (path && path[0]) m_opaque_sp->GetExecutableFile().SetFile(path, FileSpec::Style::native); m_opaque_sp->SetWaitForLaunch(wait_for); @@ -39,6 +49,8 @@ SBAttachInfo::SBAttachInfo(const char *path, bool wait_for, bool async) SBAttachInfo::SBAttachInfo(const SBAttachInfo &rhs) : m_opaque_sp(new ProcessAttachInfo()) { + LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (const lldb::SBAttachInfo &), rhs); + m_opaque_sp = clone(rhs.m_opaque_sp); } @@ -47,34 +59,54 @@ SBAttachInfo::~SBAttachInfo() {} lldb_private::ProcessAttachInfo &SBAttachInfo::ref() { return *m_opaque_sp; } SBAttachInfo &SBAttachInfo::operator=(const SBAttachInfo &rhs) { + LLDB_RECORD_METHOD(lldb::SBAttachInfo &, + SBAttachInfo, operator=,(const lldb::SBAttachInfo &), rhs); + if (this != &rhs) m_opaque_sp = clone(rhs.m_opaque_sp); return *this; } -lldb::pid_t SBAttachInfo::GetProcessID() { return m_opaque_sp->GetProcessID(); } +lldb::pid_t SBAttachInfo::GetProcessID() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBAttachInfo, GetProcessID); + + return m_opaque_sp->GetProcessID(); +} void SBAttachInfo::SetProcessID(lldb::pid_t pid) { + LLDB_RECORD_METHOD(void, SBAttachInfo, SetProcessID, (lldb::pid_t), pid); + m_opaque_sp->SetProcessID(pid); } uint32_t SBAttachInfo::GetResumeCount() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetResumeCount); + return m_opaque_sp->GetResumeCount(); } void SBAttachInfo::SetResumeCount(uint32_t c) { + LLDB_RECORD_METHOD(void, SBAttachInfo, SetResumeCount, (uint32_t), c); + m_opaque_sp->SetResumeCount(c); } const char *SBAttachInfo::GetProcessPluginName() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBAttachInfo, GetProcessPluginName); + return m_opaque_sp->GetProcessPluginName(); } void SBAttachInfo::SetProcessPluginName(const char *plugin_name) { + LLDB_RECORD_METHOD(void, SBAttachInfo, SetProcessPluginName, (const char *), + plugin_name); + return m_opaque_sp->SetProcessPluginName(plugin_name); } void SBAttachInfo::SetExecutable(const char *path) { + LLDB_RECORD_METHOD(void, SBAttachInfo, SetExecutable, (const char *), path); + if (path && path[0]) m_opaque_sp->GetExecutableFile().SetFile(path, FileSpec::Style::native); else @@ -82,6 +114,9 @@ void SBAttachInfo::SetExecutable(const char *path) { } void SBAttachInfo::SetExecutable(SBFileSpec exe_file) { + LLDB_RECORD_METHOD(void, SBAttachInfo, SetExecutable, (lldb::SBFileSpec), + exe_file); + if (exe_file.IsValid()) m_opaque_sp->GetExecutableFile() = exe_file.ref(); else @@ -89,78 +124,137 @@ void SBAttachInfo::SetExecutable(SBFileSpec exe_file) { } bool SBAttachInfo::GetWaitForLaunch() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, GetWaitForLaunch); + return m_opaque_sp->GetWaitForLaunch(); } void SBAttachInfo::SetWaitForLaunch(bool b) { + LLDB_RECORD_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool), b); + m_opaque_sp->SetWaitForLaunch(b); } void SBAttachInfo::SetWaitForLaunch(bool b, bool async) { + LLDB_RECORD_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool, bool), b, + async); + m_opaque_sp->SetWaitForLaunch(b); m_opaque_sp->SetAsync(async); } bool SBAttachInfo::GetIgnoreExisting() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, GetIgnoreExisting); + return m_opaque_sp->GetIgnoreExisting(); } void SBAttachInfo::SetIgnoreExisting(bool b) { + LLDB_RECORD_METHOD(void, SBAttachInfo, SetIgnoreExisting, (bool), b); + m_opaque_sp->SetIgnoreExisting(b); } -uint32_t SBAttachInfo::GetUserID() { return m_opaque_sp->GetUserID(); } +uint32_t SBAttachInfo::GetUserID() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetUserID); -uint32_t SBAttachInfo::GetGroupID() { return m_opaque_sp->GetGroupID(); } + return m_opaque_sp->GetUserID(); +} -bool SBAttachInfo::UserIDIsValid() { return m_opaque_sp->UserIDIsValid(); } +uint32_t SBAttachInfo::GetGroupID() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetGroupID); -bool SBAttachInfo::GroupIDIsValid() { return m_opaque_sp->GroupIDIsValid(); } + return m_opaque_sp->GetGroupID(); +} -void SBAttachInfo::SetUserID(uint32_t uid) { m_opaque_sp->SetUserID(uid); } +bool SBAttachInfo::UserIDIsValid() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, UserIDIsValid); -void SBAttachInfo::SetGroupID(uint32_t gid) { m_opaque_sp->SetGroupID(gid); } + return m_opaque_sp->UserIDIsValid(); +} + +bool SBAttachInfo::GroupIDIsValid() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, GroupIDIsValid); + + return m_opaque_sp->GroupIDIsValid(); +} + +void SBAttachInfo::SetUserID(uint32_t uid) { + LLDB_RECORD_METHOD(void, SBAttachInfo, SetUserID, (uint32_t), uid); + + m_opaque_sp->SetUserID(uid); +} + +void SBAttachInfo::SetGroupID(uint32_t gid) { + LLDB_RECORD_METHOD(void, SBAttachInfo, SetGroupID, (uint32_t), gid); + + m_opaque_sp->SetGroupID(gid); +} uint32_t SBAttachInfo::GetEffectiveUserID() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetEffectiveUserID); + return m_opaque_sp->GetEffectiveUserID(); } uint32_t SBAttachInfo::GetEffectiveGroupID() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetEffectiveGroupID); + return m_opaque_sp->GetEffectiveGroupID(); } bool SBAttachInfo::EffectiveUserIDIsValid() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, EffectiveUserIDIsValid); + return m_opaque_sp->EffectiveUserIDIsValid(); } bool SBAttachInfo::EffectiveGroupIDIsValid() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, EffectiveGroupIDIsValid); + return m_opaque_sp->EffectiveGroupIDIsValid(); } void SBAttachInfo::SetEffectiveUserID(uint32_t uid) { + LLDB_RECORD_METHOD(void, SBAttachInfo, SetEffectiveUserID, (uint32_t), uid); + m_opaque_sp->SetEffectiveUserID(uid); } void SBAttachInfo::SetEffectiveGroupID(uint32_t gid) { + LLDB_RECORD_METHOD(void, SBAttachInfo, SetEffectiveGroupID, (uint32_t), gid); + m_opaque_sp->SetEffectiveGroupID(gid); } lldb::pid_t SBAttachInfo::GetParentProcessID() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBAttachInfo, GetParentProcessID); + return m_opaque_sp->GetParentProcessID(); } void SBAttachInfo::SetParentProcessID(lldb::pid_t pid) { + LLDB_RECORD_METHOD(void, SBAttachInfo, SetParentProcessID, (lldb::pid_t), + pid); + m_opaque_sp->SetParentProcessID(pid); } bool SBAttachInfo::ParentProcessIDIsValid() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, ParentProcessIDIsValid); + return m_opaque_sp->ParentProcessIDIsValid(); } SBListener SBAttachInfo::GetListener() { - return SBListener(m_opaque_sp->GetListener()); + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBAttachInfo, GetListener); + + return LLDB_RECORD_RESULT(SBListener(m_opaque_sp->GetListener())); } void SBAttachInfo::SetListener(SBListener &listener) { + LLDB_RECORD_METHOD(void, SBAttachInfo, SetListener, (lldb::SBListener &), + listener); + m_opaque_sp->SetListener(listener.GetSP()); } diff --git a/lldb/source/API/SBBlock.cpp b/lldb/source/API/SBBlock.cpp index 4f131cd2429..ce5a4e4ceb0 100644 --- a/lldb/source/API/SBBlock.cpp +++ b/lldb/source/API/SBBlock.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBBlock.h" +#include "SBReproducerPrivate.h" #include "lldb/API/SBAddress.h" #include "lldb/API/SBFileSpec.h" #include "lldb/API/SBFrame.h" @@ -25,29 +26,44 @@ using namespace lldb; using namespace lldb_private; -SBBlock::SBBlock() : m_opaque_ptr(NULL) {} +SBBlock::SBBlock() : m_opaque_ptr(NULL) { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBlock); +} SBBlock::SBBlock(lldb_private::Block *lldb_object_ptr) : m_opaque_ptr(lldb_object_ptr) {} -SBBlock::SBBlock(const SBBlock &rhs) : m_opaque_ptr(rhs.m_opaque_ptr) {} +SBBlock::SBBlock(const SBBlock &rhs) : m_opaque_ptr(rhs.m_opaque_ptr) { + LLDB_RECORD_CONSTRUCTOR(SBBlock, (const lldb::SBBlock &), rhs); +} const SBBlock &SBBlock::operator=(const SBBlock &rhs) { + LLDB_RECORD_METHOD(const lldb::SBBlock &, + SBBlock, operator=,(const lldb::SBBlock &), rhs); + m_opaque_ptr = rhs.m_opaque_ptr; return *this; } SBBlock::~SBBlock() { m_opaque_ptr = NULL; } -bool SBBlock::IsValid() const { return m_opaque_ptr != NULL; } +bool SBBlock::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBlock, IsValid); + + return m_opaque_ptr != NULL; +} bool SBBlock::IsInlined() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBlock, IsInlined); + if (m_opaque_ptr) return m_opaque_ptr->GetInlinedFunctionInfo() != NULL; return false; } const char *SBBlock::GetInlinedName() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBlock, GetInlinedName); + if (m_opaque_ptr) { const InlineFunctionInfo *inlined_info = m_opaque_ptr->GetInlinedFunctionInfo(); @@ -65,6 +81,9 @@ const char *SBBlock::GetInlinedName() const { } SBFileSpec SBBlock::GetInlinedCallSiteFile() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBBlock, + GetInlinedCallSiteFile); + SBFileSpec sb_file; if (m_opaque_ptr) { const InlineFunctionInfo *inlined_info = @@ -72,10 +91,12 @@ SBFileSpec SBBlock::GetInlinedCallSiteFile() const { if (inlined_info) sb_file.SetFileSpec(inlined_info->GetCallSite().GetFile()); } - return sb_file; + return LLDB_RECORD_RESULT(sb_file); } uint32_t SBBlock::GetInlinedCallSiteLine() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBlock, GetInlinedCallSiteLine); + if (m_opaque_ptr) { const InlineFunctionInfo *inlined_info = m_opaque_ptr->GetInlinedFunctionInfo(); @@ -86,6 +107,8 @@ uint32_t SBBlock::GetInlinedCallSiteLine() const { } uint32_t SBBlock::GetInlinedCallSiteColumn() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBlock, GetInlinedCallSiteColumn); + if (m_opaque_ptr) { const InlineFunctionInfo *inlined_info = m_opaque_ptr->GetInlinedFunctionInfo(); @@ -105,31 +128,39 @@ void SBBlock::AppendVariables(bool can_create, bool get_parent_variables, } SBBlock SBBlock::GetParent() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetParent); + SBBlock sb_block; if (m_opaque_ptr) sb_block.m_opaque_ptr = m_opaque_ptr->GetParent(); - return sb_block; + return LLDB_RECORD_RESULT(sb_block); } lldb::SBBlock SBBlock::GetContainingInlinedBlock() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetContainingInlinedBlock); + SBBlock sb_block; if (m_opaque_ptr) sb_block.m_opaque_ptr = m_opaque_ptr->GetContainingInlinedBlock(); - return sb_block; + return LLDB_RECORD_RESULT(sb_block); } SBBlock SBBlock::GetSibling() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetSibling); + SBBlock sb_block; if (m_opaque_ptr) sb_block.m_opaque_ptr = m_opaque_ptr->GetSibling(); - return sb_block; + return LLDB_RECORD_RESULT(sb_block); } SBBlock SBBlock::GetFirstChild() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetFirstChild); + SBBlock sb_block; if (m_opaque_ptr) sb_block.m_opaque_ptr = m_opaque_ptr->GetFirstChild(); - return sb_block; + return LLDB_RECORD_RESULT(sb_block); } lldb_private::Block *SBBlock::GetPtr() { return m_opaque_ptr; } @@ -137,6 +168,9 @@ lldb_private::Block *SBBlock::GetPtr() { return m_opaque_ptr; } void SBBlock::SetPtr(lldb_private::Block *block) { m_opaque_ptr = block; } bool SBBlock::GetDescription(SBStream &description) { + LLDB_RECORD_METHOD(bool, SBBlock, GetDescription, (lldb::SBStream &), + description); + Stream &strm = description.ref(); if (m_opaque_ptr) { @@ -159,12 +193,17 @@ bool SBBlock::GetDescription(SBStream &description) { } uint32_t SBBlock::GetNumRanges() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBBlock, GetNumRanges); + if (m_opaque_ptr) return m_opaque_ptr->GetNumRanges(); return 0; } lldb::SBAddress SBBlock::GetRangeStartAddress(uint32_t idx) { + LLDB_RECORD_METHOD(lldb::SBAddress, SBBlock, GetRangeStartAddress, (uint32_t), + idx); + lldb::SBAddress sb_addr; if (m_opaque_ptr) { AddressRange range; @@ -172,10 +211,13 @@ lldb::SBAddress SBBlock::GetRangeStartAddress(uint32_t idx) { sb_addr.ref() = range.GetBaseAddress(); } } - return sb_addr; + return LLDB_RECORD_RESULT(sb_addr); } lldb::SBAddress SBBlock::GetRangeEndAddress(uint32_t idx) { + LLDB_RECORD_METHOD(lldb::SBAddress, SBBlock, GetRangeEndAddress, (uint32_t), + idx); + lldb::SBAddress sb_addr; if (m_opaque_ptr) { AddressRange range; @@ -184,10 +226,13 @@ lldb::SBAddress SBBlock::GetRangeEndAddress(uint32_t idx) { sb_addr.ref().Slide(range.GetByteSize()); } } - return sb_addr; + return LLDB_RECORD_RESULT(sb_addr); } uint32_t SBBlock::GetRangeIndexForBlockAddress(lldb::SBAddress block_addr) { + LLDB_RECORD_METHOD(uint32_t, SBBlock, GetRangeIndexForBlockAddress, + (lldb::SBAddress), block_addr); + if (m_opaque_ptr && block_addr.IsValid()) { return m_opaque_ptr->GetRangeIndexContainingAddress(block_addr.ref()); } @@ -198,6 +243,11 @@ uint32_t SBBlock::GetRangeIndexForBlockAddress(lldb::SBAddress block_addr) { lldb::SBValueList SBBlock::GetVariables(lldb::SBFrame &frame, bool arguments, bool locals, bool statics, lldb::DynamicValueType use_dynamic) { + LLDB_RECORD_METHOD( + lldb::SBValueList, SBBlock, GetVariables, + (lldb::SBFrame &, bool, bool, bool, lldb::DynamicValueType), frame, + arguments, locals, statics, use_dynamic); + Block *block = GetPtr(); SBValueList value_list; if (block) { @@ -244,11 +294,15 @@ lldb::SBValueList SBBlock::GetVariables(lldb::SBFrame &frame, bool arguments, } } } - return value_list; + return LLDB_RECORD_RESULT(value_list); } lldb::SBValueList SBBlock::GetVariables(lldb::SBTarget &target, bool arguments, bool locals, bool statics) { + LLDB_RECORD_METHOD(lldb::SBValueList, SBBlock, GetVariables, + (lldb::SBTarget &, bool, bool, bool), target, arguments, + locals, statics); + Block *block = GetPtr(); SBValueList value_list; @@ -292,5 +346,5 @@ lldb::SBValueList SBBlock::GetVariables(lldb::SBTarget &target, bool arguments, } } } - return value_list; + return LLDB_RECORD_RESULT(value_list); } diff --git a/lldb/source/API/SBBreakpoint.cpp b/lldb/source/API/SBBreakpoint.cpp index 9b040f36349..7ea68e28461 100644 --- a/lldb/source/API/SBBreakpoint.cpp +++ b/lldb/source/API/SBBreakpoint.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBBreakpoint.h" +#include "SBReproducerPrivate.h" #include "lldb/API/SBBreakpointLocation.h" #include "lldb/API/SBDebugger.h" #include "lldb/API/SBEvent.h" @@ -43,30 +44,45 @@ using namespace lldb; using namespace lldb_private; -SBBreakpoint::SBBreakpoint() {} +SBBreakpoint::SBBreakpoint() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBreakpoint); } SBBreakpoint::SBBreakpoint(const SBBreakpoint &rhs) - : m_opaque_wp(rhs.m_opaque_wp) {} + : m_opaque_wp(rhs.m_opaque_wp) { + LLDB_RECORD_CONSTRUCTOR(SBBreakpoint, (const lldb::SBBreakpoint &), rhs); +} SBBreakpoint::SBBreakpoint(const lldb::BreakpointSP &bp_sp) - : m_opaque_wp(bp_sp) {} + : m_opaque_wp(bp_sp) { + LLDB_RECORD_CONSTRUCTOR(SBBreakpoint, (const lldb::BreakpointSP &), bp_sp); +} SBBreakpoint::~SBBreakpoint() = default; const SBBreakpoint &SBBreakpoint::operator=(const SBBreakpoint &rhs) { + LLDB_RECORD_METHOD(const lldb::SBBreakpoint &, + SBBreakpoint, operator=,(const lldb::SBBreakpoint &), rhs); + m_opaque_wp = rhs.m_opaque_wp; return *this; } bool SBBreakpoint::operator==(const lldb::SBBreakpoint &rhs) { + LLDB_RECORD_METHOD( + bool, SBBreakpoint, operator==,(const lldb::SBBreakpoint &), rhs); + return m_opaque_wp.lock() == rhs.m_opaque_wp.lock(); } bool SBBreakpoint::operator!=(const lldb::SBBreakpoint &rhs) { + LLDB_RECORD_METHOD( + bool, SBBreakpoint, operator!=,(const lldb::SBBreakpoint &), rhs); + return m_opaque_wp.lock() != rhs.m_opaque_wp.lock(); } break_id_t SBBreakpoint::GetID() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::break_id_t, SBBreakpoint, GetID); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); break_id_t break_id = LLDB_INVALID_BREAK_ID; @@ -79,6 +95,8 @@ break_id_t SBBreakpoint::GetID() const { } bool SBBreakpoint::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, IsValid); + BreakpointSP bkpt_sp = GetSP(); if (!bkpt_sp) return false; @@ -89,6 +107,8 @@ bool SBBreakpoint::IsValid() const { } void SBBreakpoint::ClearAllBreakpointSites() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBBreakpoint, ClearAllBreakpointSites); + BreakpointSP bkpt_sp = GetSP(); if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( @@ -98,6 +118,9 @@ void SBBreakpoint::ClearAllBreakpointSites() { } SBBreakpointLocation SBBreakpoint::FindLocationByAddress(addr_t vm_addr) { + LLDB_RECORD_METHOD(lldb::SBBreakpointLocation, SBBreakpoint, + FindLocationByAddress, (lldb::addr_t), vm_addr); + SBBreakpointLocation sb_bp_location; BreakpointSP bkpt_sp = GetSP(); @@ -113,10 +136,13 @@ SBBreakpointLocation SBBreakpoint::FindLocationByAddress(addr_t vm_addr) { sb_bp_location.SetLocation(bkpt_sp->FindLocationByAddress(address)); } } - return sb_bp_location; + return LLDB_RECORD_RESULT(sb_bp_location); } break_id_t SBBreakpoint::FindLocationIDByAddress(addr_t vm_addr) { + LLDB_RECORD_METHOD(lldb::break_id_t, SBBreakpoint, FindLocationIDByAddress, + (lldb::addr_t), vm_addr); + break_id_t break_id = LLDB_INVALID_BREAK_ID; BreakpointSP bkpt_sp = GetSP(); @@ -135,6 +161,9 @@ break_id_t SBBreakpoint::FindLocationIDByAddress(addr_t vm_addr) { } SBBreakpointLocation SBBreakpoint::FindLocationByID(break_id_t bp_loc_id) { + LLDB_RECORD_METHOD(lldb::SBBreakpointLocation, SBBreakpoint, FindLocationByID, + (lldb::break_id_t), bp_loc_id); + SBBreakpointLocation sb_bp_location; BreakpointSP bkpt_sp = GetSP(); @@ -144,10 +173,13 @@ SBBreakpointLocation SBBreakpoint::FindLocationByID(break_id_t bp_loc_id) { sb_bp_location.SetLocation(bkpt_sp->FindLocationByID(bp_loc_id)); } - return sb_bp_location; + return LLDB_RECORD_RESULT(sb_bp_location); } SBBreakpointLocation SBBreakpoint::GetLocationAtIndex(uint32_t index) { + LLDB_RECORD_METHOD(lldb::SBBreakpointLocation, SBBreakpoint, + GetLocationAtIndex, (uint32_t), index); + SBBreakpointLocation sb_bp_location; BreakpointSP bkpt_sp = GetSP(); @@ -157,10 +189,12 @@ SBBreakpointLocation SBBreakpoint::GetLocationAtIndex(uint32_t index) { sb_bp_location.SetLocation(bkpt_sp->GetLocationAtIndex(index)); } - return sb_bp_location; + return LLDB_RECORD_RESULT(sb_bp_location); } void SBBreakpoint::SetEnabled(bool enable) { + LLDB_RECORD_METHOD(void, SBBreakpoint, SetEnabled, (bool), enable); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointSP bkpt_sp = GetSP(); @@ -174,6 +208,8 @@ void SBBreakpoint::SetEnabled(bool enable) { } bool SBBreakpoint::IsEnabled() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpoint, IsEnabled); + BreakpointSP bkpt_sp = GetSP(); if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( @@ -184,6 +220,8 @@ bool SBBreakpoint::IsEnabled() { } void SBBreakpoint::SetOneShot(bool one_shot) { + LLDB_RECORD_METHOD(void, SBBreakpoint, SetOneShot, (bool), one_shot); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointSP bkpt_sp = GetSP(); @@ -197,6 +235,8 @@ void SBBreakpoint::SetOneShot(bool one_shot) { } bool SBBreakpoint::IsOneShot() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, IsOneShot); + BreakpointSP bkpt_sp = GetSP(); if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( @@ -207,6 +247,8 @@ bool SBBreakpoint::IsOneShot() const { } bool SBBreakpoint::IsInternal() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpoint, IsInternal); + BreakpointSP bkpt_sp = GetSP(); if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( @@ -217,6 +259,8 @@ bool SBBreakpoint::IsInternal() { } void SBBreakpoint::SetIgnoreCount(uint32_t count) { + LLDB_RECORD_METHOD(void, SBBreakpoint, SetIgnoreCount, (uint32_t), count); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointSP bkpt_sp = GetSP(); @@ -230,6 +274,9 @@ void SBBreakpoint::SetIgnoreCount(uint32_t count) { } void SBBreakpoint::SetCondition(const char *condition) { + LLDB_RECORD_METHOD(void, SBBreakpoint, SetCondition, (const char *), + condition); + BreakpointSP bkpt_sp = GetSP(); if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( @@ -239,6 +286,8 @@ void SBBreakpoint::SetCondition(const char *condition) { } const char *SBBreakpoint::GetCondition() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBBreakpoint, GetCondition); + BreakpointSP bkpt_sp = GetSP(); if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( @@ -249,6 +298,9 @@ const char *SBBreakpoint::GetCondition() { } void SBBreakpoint::SetAutoContinue(bool auto_continue) { + LLDB_RECORD_METHOD(void, SBBreakpoint, SetAutoContinue, (bool), + auto_continue); + BreakpointSP bkpt_sp = GetSP(); if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( @@ -258,6 +310,8 @@ void SBBreakpoint::SetAutoContinue(bool auto_continue) { } bool SBBreakpoint::GetAutoContinue() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpoint, GetAutoContinue); + BreakpointSP bkpt_sp = GetSP(); if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( @@ -268,6 +322,8 @@ bool SBBreakpoint::GetAutoContinue() { } uint32_t SBBreakpoint::GetHitCount() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpoint, GetHitCount); + uint32_t count = 0; BreakpointSP bkpt_sp = GetSP(); if (bkpt_sp) { @@ -283,6 +339,8 @@ uint32_t SBBreakpoint::GetHitCount() const { } uint32_t SBBreakpoint::GetIgnoreCount() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpoint, GetIgnoreCount); + uint32_t count = 0; BreakpointSP bkpt_sp = GetSP(); if (bkpt_sp) { @@ -298,6 +356,8 @@ uint32_t SBBreakpoint::GetIgnoreCount() const { } void SBBreakpoint::SetThreadID(tid_t tid) { + LLDB_RECORD_METHOD(void, SBBreakpoint, SetThreadID, (lldb::tid_t), tid); + BreakpointSP bkpt_sp = GetSP(); if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( @@ -309,6 +369,8 @@ void SBBreakpoint::SetThreadID(tid_t tid) { } tid_t SBBreakpoint::GetThreadID() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBBreakpoint, GetThreadID); + tid_t tid = LLDB_INVALID_THREAD_ID; BreakpointSP bkpt_sp = GetSP(); if (bkpt_sp) { @@ -323,6 +385,8 @@ tid_t SBBreakpoint::GetThreadID() { } void SBBreakpoint::SetThreadIndex(uint32_t index) { + LLDB_RECORD_METHOD(void, SBBreakpoint, SetThreadIndex, (uint32_t), index); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointSP bkpt_sp = GetSP(); LLDB_LOG(log, "breakpoint = {0}, index = {1}", bkpt_sp.get(), index); @@ -334,6 +398,8 @@ void SBBreakpoint::SetThreadIndex(uint32_t index) { } uint32_t SBBreakpoint::GetThreadIndex() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpoint, GetThreadIndex); + uint32_t thread_idx = UINT32_MAX; BreakpointSP bkpt_sp = GetSP(); if (bkpt_sp) { @@ -351,6 +417,9 @@ uint32_t SBBreakpoint::GetThreadIndex() const { } void SBBreakpoint::SetThreadName(const char *thread_name) { + LLDB_RECORD_METHOD(void, SBBreakpoint, SetThreadName, (const char *), + thread_name); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointSP bkpt_sp = GetSP(); LLDB_LOG(log, "breakpoint = {0}, name = {1}", bkpt_sp.get(), thread_name); @@ -363,6 +432,8 @@ void SBBreakpoint::SetThreadName(const char *thread_name) { } const char *SBBreakpoint::GetThreadName() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpoint, GetThreadName); + const char *name = nullptr; BreakpointSP bkpt_sp = GetSP(); if (bkpt_sp) { @@ -380,6 +451,9 @@ const char *SBBreakpoint::GetThreadName() const { } void SBBreakpoint::SetQueueName(const char *queue_name) { + LLDB_RECORD_METHOD(void, SBBreakpoint, SetQueueName, (const char *), + queue_name); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointSP bkpt_sp = GetSP(); LLDB_LOG(log, "breakpoint = {0}, queue_name = {1}", bkpt_sp.get(), @@ -392,6 +466,8 @@ void SBBreakpoint::SetQueueName(const char *queue_name) { } const char *SBBreakpoint::GetQueueName() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpoint, GetQueueName); + const char *name = nullptr; BreakpointSP bkpt_sp = GetSP(); if (bkpt_sp) { @@ -409,6 +485,9 @@ const char *SBBreakpoint::GetQueueName() const { } size_t SBBreakpoint::GetNumResolvedLocations() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBBreakpoint, + GetNumResolvedLocations); + size_t num_resolved = 0; BreakpointSP bkpt_sp = GetSP(); if (bkpt_sp) { @@ -423,6 +502,8 @@ size_t SBBreakpoint::GetNumResolvedLocations() const { } size_t SBBreakpoint::GetNumLocations() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBBreakpoint, GetNumLocations); + BreakpointSP bkpt_sp = GetSP(); size_t num_locs = 0; if (bkpt_sp) { @@ -436,6 +517,9 @@ size_t SBBreakpoint::GetNumLocations() const { } void SBBreakpoint::SetCommandLineCommands(SBStringList &commands) { + LLDB_RECORD_METHOD(void, SBBreakpoint, SetCommandLineCommands, + (lldb::SBStringList &), commands); + BreakpointSP bkpt_sp = GetSP(); if (!bkpt_sp) return; @@ -451,6 +535,9 @@ void SBBreakpoint::SetCommandLineCommands(SBStringList &commands) { } bool SBBreakpoint::GetCommandLineCommands(SBStringList &commands) { + LLDB_RECORD_METHOD(bool, SBBreakpoint, GetCommandLineCommands, + (lldb::SBStringList &), commands); + BreakpointSP bkpt_sp = GetSP(); if (!bkpt_sp) return false; @@ -463,10 +550,15 @@ bool SBBreakpoint::GetCommandLineCommands(SBStringList &commands) { } bool SBBreakpoint::GetDescription(SBStream &s) { + LLDB_RECORD_METHOD(bool, SBBreakpoint, GetDescription, (lldb::SBStream &), s); + return GetDescription(s, true); } bool SBBreakpoint::GetDescription(SBStream &s, bool include_locations) { + LLDB_RECORD_METHOD(bool, SBBreakpoint, GetDescription, + (lldb::SBStream &, bool), s, include_locations); + BreakpointSP bkpt_sp = GetSP(); if (bkpt_sp) { std::lock_guard<std::recursive_mutex> guard( @@ -484,39 +576,39 @@ bool SBBreakpoint::GetDescription(SBStream &s, bool include_locations) { return false; } -SBError -SBBreakpoint::AddLocation(SBAddress &address) { - BreakpointSP bkpt_sp = GetSP(); - SBError error; - - if (!address.IsValid()) { - error.SetErrorString("Can't add an invalid address."); - return error; - } - - if (!bkpt_sp) { - error.SetErrorString("No breakpoint to add a location to."); - return error; - } - - if (!llvm::isa<BreakpointResolverScripted>(bkpt_sp->GetResolver().get())) { - error.SetErrorString("Only a scripted resolver can add locations."); - return error; - } - - if (bkpt_sp->GetSearchFilter()->AddressPasses(address.ref())) - bkpt_sp->AddLocation(address.ref()); - else - { - StreamString s; - address.get()->Dump(&s, &bkpt_sp->GetTarget(), - Address::DumpStyleModuleWithFileAddress); - error.SetErrorStringWithFormat("Address: %s didn't pass the filter.", - s.GetData()); - } - return error; -} +SBError SBBreakpoint::AddLocation(SBAddress &address) { + LLDB_RECORD_METHOD(lldb::SBError, SBBreakpoint, AddLocation, + (lldb::SBAddress &), address); + BreakpointSP bkpt_sp = GetSP(); + SBError error; + + if (!address.IsValid()) { + error.SetErrorString("Can't add an invalid address."); + return LLDB_RECORD_RESULT(error); + } + + if (!bkpt_sp) { + error.SetErrorString("No breakpoint to add a location to."); + return LLDB_RECORD_RESULT(error); + } + + if (!llvm::isa<BreakpointResolverScripted>(bkpt_sp->GetResolver().get())) { + error.SetErrorString("Only a scripted resolver can add locations."); + return LLDB_RECORD_RESULT(error); + } + + if (bkpt_sp->GetSearchFilter()->AddressPasses(address.ref())) + bkpt_sp->AddLocation(address.ref()); + else { + StreamString s; + address.get()->Dump(&s, &bkpt_sp->GetTarget(), + Address::DumpStyleModuleWithFileAddress); + error.SetErrorStringWithFormat("Address: %s didn't pass the filter.", + s.GetData()); + } + return LLDB_RECORD_RESULT(error); +} void SBBreakpoint ::SetCallback(SBBreakpointHitCallback callback, @@ -538,6 +630,9 @@ void SBBreakpoint void SBBreakpoint::SetScriptCallbackFunction( const char *callback_function_name) { + LLDB_RECORD_METHOD(void, SBBreakpoint, SetScriptCallbackFunction, + (const char *), callback_function_name); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointSP bkpt_sp = GetSP(); LLDB_LOG(log, "breakpoint = {0}, callback = {1}", bkpt_sp.get(), @@ -557,6 +652,9 @@ void SBBreakpoint::SetScriptCallbackFunction( } SBError SBBreakpoint::SetScriptCallbackBody(const char *callback_body_text) { + LLDB_RECORD_METHOD(lldb::SBError, SBBreakpoint, SetScriptCallbackBody, + (const char *), callback_body_text); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointSP bkpt_sp = GetSP(); LLDB_LOG(log, "breakpoint = {0}, callback body:\n{1}", bkpt_sp.get(), @@ -577,10 +675,12 @@ SBError SBBreakpoint::SetScriptCallbackBody(const char *callback_body_text) { } else sb_error.SetErrorString("invalid breakpoint"); - return sb_error; + return LLDB_RECORD_RESULT(sb_error); } bool SBBreakpoint::AddName(const char *new_name) { + LLDB_RECORD_METHOD(bool, SBBreakpoint, AddName, (const char *), new_name); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointSP bkpt_sp = GetSP(); LLDB_LOG(log, "breakpoint = {0}, name = {1}", bkpt_sp.get(), new_name); @@ -604,6 +704,9 @@ bool SBBreakpoint::AddName(const char *new_name) { } void SBBreakpoint::RemoveName(const char *name_to_remove) { + LLDB_RECORD_METHOD(void, SBBreakpoint, RemoveName, (const char *), + name_to_remove); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointSP bkpt_sp = GetSP(); LLDB_LOG(log, "breakpoint = {0}, name = {1}", bkpt_sp.get(), name_to_remove); @@ -617,6 +720,8 @@ void SBBreakpoint::RemoveName(const char *name_to_remove) { } bool SBBreakpoint::MatchesName(const char *name) { + LLDB_RECORD_METHOD(bool, SBBreakpoint, MatchesName, (const char *), name); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointSP bkpt_sp = GetSP(); LLDB_LOG(log, "breakpoint = {0}, name = {1}", bkpt_sp.get(), name); @@ -631,6 +736,9 @@ bool SBBreakpoint::MatchesName(const char *name) { } void SBBreakpoint::GetNames(SBStringList &names) { + LLDB_RECORD_METHOD(void, SBBreakpoint, GetNames, (lldb::SBStringList &), + names); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointSP bkpt_sp = GetSP(); LLDB_LOG(log, "breakpoint = {0}", bkpt_sp.get()); @@ -647,12 +755,19 @@ void SBBreakpoint::GetNames(SBStringList &names) { } bool SBBreakpoint::EventIsBreakpointEvent(const lldb::SBEvent &event) { + LLDB_RECORD_STATIC_METHOD(bool, SBBreakpoint, EventIsBreakpointEvent, + (const lldb::SBEvent &), event); + return Breakpoint::BreakpointEventData::GetEventDataFromEvent(event.get()) != nullptr; } BreakpointEventType SBBreakpoint::GetBreakpointEventTypeFromEvent(const SBEvent &event) { + LLDB_RECORD_STATIC_METHOD(lldb::BreakpointEventType, SBBreakpoint, + GetBreakpointEventTypeFromEvent, + (const lldb::SBEvent &), event); + if (event.IsValid()) return Breakpoint::BreakpointEventData::GetBreakpointEventTypeFromEvent( event.GetSP()); @@ -660,25 +775,38 @@ SBBreakpoint::GetBreakpointEventTypeFromEvent(const SBEvent &event) { } SBBreakpoint SBBreakpoint::GetBreakpointFromEvent(const lldb::SBEvent &event) { + LLDB_RECORD_STATIC_METHOD(lldb::SBBreakpoint, SBBreakpoint, + GetBreakpointFromEvent, (const lldb::SBEvent &), + event); + if (event.IsValid()) - return SBBreakpoint( - Breakpoint::BreakpointEventData::GetBreakpointFromEvent(event.GetSP())); - return SBBreakpoint(); + return LLDB_RECORD_RESULT( + SBBreakpoint(Breakpoint::BreakpointEventData::GetBreakpointFromEvent( + event.GetSP()))); + return LLDB_RECORD_RESULT(SBBreakpoint()); } SBBreakpointLocation SBBreakpoint::GetBreakpointLocationAtIndexFromEvent(const lldb::SBEvent &event, uint32_t loc_idx) { + LLDB_RECORD_STATIC_METHOD(lldb::SBBreakpointLocation, SBBreakpoint, + GetBreakpointLocationAtIndexFromEvent, + (const lldb::SBEvent &, uint32_t), event, loc_idx); + SBBreakpointLocation sb_breakpoint_loc; if (event.IsValid()) sb_breakpoint_loc.SetLocation( Breakpoint::BreakpointEventData::GetBreakpointLocationAtIndexFromEvent( event.GetSP(), loc_idx)); - return sb_breakpoint_loc; + return LLDB_RECORD_RESULT(sb_breakpoint_loc); } uint32_t SBBreakpoint::GetNumBreakpointLocationsFromEvent(const lldb::SBEvent &event) { + LLDB_RECORD_STATIC_METHOD(uint32_t, SBBreakpoint, + GetNumBreakpointLocationsFromEvent, + (const lldb::SBEvent &), event); + uint32_t num_locations = 0; if (event.IsValid()) num_locations = @@ -688,6 +816,8 @@ SBBreakpoint::GetNumBreakpointLocationsFromEvent(const lldb::SBEvent &event) { } bool SBBreakpoint::IsHardware() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, IsHardware); + BreakpointSP bkpt_sp = GetSP(); if (bkpt_sp) return bkpt_sp->IsHardware(); @@ -781,11 +911,15 @@ private: }; SBBreakpointList::SBBreakpointList(SBTarget &target) - : m_opaque_sp(new SBBreakpointListImpl(target.GetSP())) {} + : m_opaque_sp(new SBBreakpointListImpl(target.GetSP())) { + LLDB_RECORD_CONSTRUCTOR(SBBreakpointList, (lldb::SBTarget &), target); +} SBBreakpointList::~SBBreakpointList() {} size_t SBBreakpointList::GetSize() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBBreakpointList, GetSize); + if (!m_opaque_sp) return 0; else @@ -793,21 +927,30 @@ size_t SBBreakpointList::GetSize() const { } SBBreakpoint SBBreakpointList::GetBreakpointAtIndex(size_t idx) { + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBBreakpointList, GetBreakpointAtIndex, + (size_t), idx); + if (!m_opaque_sp) - return SBBreakpoint(); + return LLDB_RECORD_RESULT(SBBreakpoint()); BreakpointSP bkpt_sp = m_opaque_sp->GetBreakpointAtIndex(idx); - return SBBreakpoint(bkpt_sp); + return LLDB_RECORD_RESULT(SBBreakpoint(bkpt_sp)); } SBBreakpoint SBBreakpointList::FindBreakpointByID(lldb::break_id_t id) { + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBBreakpointList, FindBreakpointByID, + (lldb::break_id_t), id); + if (!m_opaque_sp) - return SBBreakpoint(); + return LLDB_RECORD_RESULT(SBBreakpoint()); BreakpointSP bkpt_sp = m_opaque_sp->FindBreakpointByID(id); - return SBBreakpoint(bkpt_sp); + return LLDB_RECORD_RESULT(SBBreakpoint(bkpt_sp)); } void SBBreakpointList::Append(const SBBreakpoint &sb_bkpt) { + LLDB_RECORD_METHOD(void, SBBreakpointList, Append, + (const lldb::SBBreakpoint &), sb_bkpt); + if (!sb_bkpt.IsValid()) return; if (!m_opaque_sp) @@ -816,12 +959,18 @@ void SBBreakpointList::Append(const SBBreakpoint &sb_bkpt) { } void SBBreakpointList::AppendByID(lldb::break_id_t id) { + LLDB_RECORD_METHOD(void, SBBreakpointList, AppendByID, (lldb::break_id_t), + id); + if (!m_opaque_sp) return; m_opaque_sp->AppendByID(id); } bool SBBreakpointList::AppendIfUnique(const SBBreakpoint &sb_bkpt) { + LLDB_RECORD_METHOD(bool, SBBreakpointList, AppendIfUnique, + (const lldb::SBBreakpoint &), sb_bkpt); + if (!sb_bkpt.IsValid()) return false; if (!m_opaque_sp) @@ -830,6 +979,8 @@ bool SBBreakpointList::AppendIfUnique(const SBBreakpoint &sb_bkpt) { } void SBBreakpointList::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBBreakpointList, Clear); + if (m_opaque_sp) m_opaque_sp->Clear(); } diff --git a/lldb/source/API/SBBreakpointLocation.cpp b/lldb/source/API/SBBreakpointLocation.cpp index a11f0d22a98..66b2d02de39 100644 --- a/lldb/source/API/SBBreakpointLocation.cpp +++ b/lldb/source/API/SBBreakpointLocation.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBBreakpointLocation.h" +#include "SBReproducerPrivate.h" #include "lldb/API/SBAddress.h" #include "lldb/API/SBDebugger.h" #include "lldb/API/SBDefines.h" @@ -29,11 +30,16 @@ 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) { + LLDB_RECORD_CONSTRUCTOR(SBBreakpointLocation, + (const lldb::BreakpointLocationSP &), break_loc_sp); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) { @@ -44,10 +50,18 @@ SBBreakpointLocation::SBBreakpointLocation( } 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; } @@ -58,17 +72,27 @@ 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 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(); @@ -82,6 +106,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( @@ -91,6 +117,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( @@ -101,6 +129,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( @@ -111,6 +141,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( @@ -121,6 +153,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( @@ -130,6 +164,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( @@ -139,6 +176,8 @@ 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( @@ -149,6 +188,9 @@ const char *SBBreakpointLocation::GetCondition() { } 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( @@ -158,6 +200,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( @@ -169,6 +213,9 @@ bool SBBreakpointLocation::GetAutoContinue() { void SBBreakpointLocation::SetScriptCallbackFunction( const char *callback_function_name) { + LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetScriptCallbackFunction, + (const char *), callback_function_name); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointLocationSP loc_sp = GetSP(); LLDB_LOG(log, "location = {0}, callback = {1}", loc_sp.get(), @@ -190,6 +237,9 @@ void SBBreakpointLocation::SetScriptCallbackFunction( SBError SBBreakpointLocation::SetScriptCallbackBody(const char *callback_body_text) { + LLDB_RECORD_METHOD(lldb::SBError, SBBreakpointLocation, SetScriptCallbackBody, + (const char *), callback_body_text); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointLocationSP loc_sp = GetSP(); LLDB_LOG(log, "location = {0}: callback body:\n{1}", loc_sp.get(), @@ -211,10 +261,13 @@ SBBreakpointLocation::SetScriptCallbackBody(const char *callback_body_text) { } 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; @@ -230,6 +283,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; @@ -242,6 +298,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( @@ -251,6 +310,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) { @@ -262,6 +323,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( @@ -271,6 +335,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) { @@ -282,6 +349,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( @@ -291,6 +361,9 @@ 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( @@ -301,6 +374,9 @@ const char *SBBreakpointLocation::GetThreadName() const { } 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( @@ -310,6 +386,9 @@ 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( @@ -320,6 +399,8 @@ const char *SBBreakpointLocation::GetQueueName() const { } 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( @@ -337,6 +418,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(); @@ -352,6 +437,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( @@ -362,6 +449,9 @@ break_id_t SBBreakpointLocation::GetID() { } SBBreakpoint SBBreakpointLocation::GetBreakpoint() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBreakpoint, SBBreakpointLocation, + GetBreakpoint); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointLocationSP loc_sp = GetSP(); @@ -378,5 +468,5 @@ SBBreakpoint SBBreakpointLocation::GetBreakpoint() { 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); } diff --git a/lldb/source/API/SBBreakpointName.cpp b/lldb/source/API/SBBreakpointName.cpp index f02732e2a87..99d5e29f0da 100644 --- a/lldb/source/API/SBBreakpointName.cpp +++ b/lldb/source/API/SBBreakpointName.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBBreakpointName.h" +#include "SBReproducerPrivate.h" #include "lldb/API/SBDebugger.h" #include "lldb/API/SBError.h" #include "lldb/API/SBStream.h" @@ -105,10 +106,14 @@ lldb_private::BreakpointName *SBBreakpointNameImpl::GetBreakpointName() const { } // namespace lldb -SBBreakpointName::SBBreakpointName() {} +SBBreakpointName::SBBreakpointName() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBreakpointName); +} + +SBBreakpointName::SBBreakpointName(SBTarget &sb_target, const char *name) { + LLDB_RECORD_CONSTRUCTOR(SBBreakpointName, (lldb::SBTarget &, const char *), + sb_target, name); -SBBreakpointName::SBBreakpointName(SBTarget &sb_target, const char *name) -{ m_impl_up.reset(new SBBreakpointNameImpl(sb_target, name)); // Call FindBreakpointName here to make sure the name is valid, reset if not: BreakpointName *bp_name = GetBreakpointName(); @@ -116,8 +121,10 @@ SBBreakpointName::SBBreakpointName(SBTarget &sb_target, const char *name) m_impl_up.reset(); } -SBBreakpointName::SBBreakpointName(SBBreakpoint &sb_bkpt, const char *name) -{ +SBBreakpointName::SBBreakpointName(SBBreakpoint &sb_bkpt, const char *name) { + LLDB_RECORD_CONSTRUCTOR(SBBreakpointName, + (lldb::SBBreakpoint &, const char *), sb_bkpt, name); + if (!sb_bkpt.IsValid()) { m_impl_up.reset(); return; @@ -139,8 +146,10 @@ SBBreakpointName::SBBreakpointName(SBBreakpoint &sb_bkpt, const char *name) BreakpointName::Permissions()); } -SBBreakpointName::SBBreakpointName(const SBBreakpointName &rhs) -{ +SBBreakpointName::SBBreakpointName(const SBBreakpointName &rhs) { + LLDB_RECORD_CONSTRUCTOR(SBBreakpointName, (const lldb::SBBreakpointName &), + rhs); + if (!rhs.m_impl_up) return; else @@ -150,8 +159,12 @@ SBBreakpointName::SBBreakpointName(const SBBreakpointName &rhs) SBBreakpointName::~SBBreakpointName() = default; -const SBBreakpointName &SBBreakpointName::operator=(const SBBreakpointName &rhs) -{ +const SBBreakpointName &SBBreakpointName:: +operator=(const SBBreakpointName &rhs) { + LLDB_RECORD_METHOD( + const lldb::SBBreakpointName &, + SBBreakpointName, operator=,(const lldb::SBBreakpointName &), rhs); + if (!rhs.m_impl_up) { m_impl_up.reset(); return *this; @@ -163,26 +176,38 @@ const SBBreakpointName &SBBreakpointName::operator=(const SBBreakpointName &rhs) } bool SBBreakpointName::operator==(const lldb::SBBreakpointName &rhs) { + LLDB_RECORD_METHOD( + bool, SBBreakpointName, operator==,(const lldb::SBBreakpointName &), rhs); + return *m_impl_up == *rhs.m_impl_up; } bool SBBreakpointName::operator!=(const lldb::SBBreakpointName &rhs) { + LLDB_RECORD_METHOD( + bool, SBBreakpointName, operator!=,(const lldb::SBBreakpointName &), rhs); + return *m_impl_up != *rhs.m_impl_up; } bool SBBreakpointName::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, IsValid); + if (!m_impl_up) return false; return m_impl_up->IsValid(); } const char *SBBreakpointName::GetName() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName, GetName); + if (!m_impl_up) return "<Invalid Breakpoint Name Object>"; return m_impl_up->GetName(); } void SBBreakpointName::SetEnabled(bool enable) { + LLDB_RECORD_METHOD(void, SBBreakpointName, SetEnabled, (bool), enable); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointName *bp_name = GetBreakpointName(); @@ -208,6 +233,8 @@ void SBBreakpointName::UpdateName(BreakpointName &bp_name) { } bool SBBreakpointName::IsEnabled() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, IsEnabled); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointName *bp_name = GetBreakpointName(); @@ -222,6 +249,8 @@ bool SBBreakpointName::IsEnabled() { } void SBBreakpointName::SetOneShot(bool one_shot) { + LLDB_RECORD_METHOD(void, SBBreakpointName, SetOneShot, (bool), one_shot); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointName *bp_name = GetBreakpointName(); @@ -237,6 +266,8 @@ void SBBreakpointName::SetOneShot(bool one_shot) { } bool SBBreakpointName::IsOneShot() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, IsOneShot); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); const BreakpointName *bp_name = GetBreakpointName(); @@ -251,6 +282,8 @@ bool SBBreakpointName::IsOneShot() const { } void SBBreakpointName::SetIgnoreCount(uint32_t count) { + LLDB_RECORD_METHOD(void, SBBreakpointName, SetIgnoreCount, (uint32_t), count); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointName *bp_name = GetBreakpointName(); @@ -266,6 +299,8 @@ void SBBreakpointName::SetIgnoreCount(uint32_t count) { } uint32_t SBBreakpointName::GetIgnoreCount() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointName, GetIgnoreCount); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointName *bp_name = GetBreakpointName(); @@ -280,6 +315,9 @@ uint32_t SBBreakpointName::GetIgnoreCount() const { } void SBBreakpointName::SetCondition(const char *condition) { + LLDB_RECORD_METHOD(void, SBBreakpointName, SetCondition, (const char *), + condition); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointName *bp_name = GetBreakpointName(); @@ -297,6 +335,8 @@ void SBBreakpointName::SetCondition(const char *condition) { } const char *SBBreakpointName::GetCondition() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBBreakpointName, GetCondition); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointName *bp_name = GetBreakpointName(); @@ -311,6 +351,9 @@ const char *SBBreakpointName::GetCondition() { } void SBBreakpointName::SetAutoContinue(bool auto_continue) { + LLDB_RECORD_METHOD(void, SBBreakpointName, SetAutoContinue, (bool), + auto_continue); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointName *bp_name = GetBreakpointName(); @@ -327,6 +370,8 @@ void SBBreakpointName::SetAutoContinue(bool auto_continue) { } bool SBBreakpointName::GetAutoContinue() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAutoContinue); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointName *bp_name = GetBreakpointName(); @@ -341,6 +386,8 @@ bool SBBreakpointName::GetAutoContinue() { } void SBBreakpointName::SetThreadID(tid_t tid) { + LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadID, (lldb::tid_t), tid); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointName *bp_name = GetBreakpointName(); @@ -357,6 +404,8 @@ void SBBreakpointName::SetThreadID(tid_t tid) { } tid_t SBBreakpointName::GetThreadID() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBBreakpointName, GetThreadID); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointName *bp_name = GetBreakpointName(); @@ -371,6 +420,8 @@ tid_t SBBreakpointName::GetThreadID() { } void SBBreakpointName::SetThreadIndex(uint32_t index) { + LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadIndex, (uint32_t), index); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointName *bp_name = GetBreakpointName(); @@ -387,6 +438,8 @@ void SBBreakpointName::SetThreadIndex(uint32_t index) { } uint32_t SBBreakpointName::GetThreadIndex() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointName, GetThreadIndex); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointName *bp_name = GetBreakpointName(); @@ -401,6 +454,9 @@ uint32_t SBBreakpointName::GetThreadIndex() const { } void SBBreakpointName::SetThreadName(const char *thread_name) { + LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadName, (const char *), + thread_name); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointName *bp_name = GetBreakpointName(); @@ -417,6 +473,9 @@ void SBBreakpointName::SetThreadName(const char *thread_name) { } const char *SBBreakpointName::GetThreadName() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName, + GetThreadName); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointName *bp_name = GetBreakpointName(); @@ -431,6 +490,9 @@ const char *SBBreakpointName::GetThreadName() const { } void SBBreakpointName::SetQueueName(const char *queue_name) { + LLDB_RECORD_METHOD(void, SBBreakpointName, SetQueueName, (const char *), + queue_name); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointName *bp_name = GetBreakpointName(); @@ -447,6 +509,9 @@ void SBBreakpointName::SetQueueName(const char *queue_name) { } const char *SBBreakpointName::GetQueueName() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName, + GetQueueName); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointName *bp_name = GetBreakpointName(); @@ -461,6 +526,9 @@ const char *SBBreakpointName::GetQueueName() const { } void SBBreakpointName::SetCommandLineCommands(SBStringList &commands) { + LLDB_RECORD_METHOD(void, SBBreakpointName, SetCommandLineCommands, + (lldb::SBStringList &), commands); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) @@ -480,6 +548,9 @@ void SBBreakpointName::SetCommandLineCommands(SBStringList &commands) { } bool SBBreakpointName::GetCommandLineCommands(SBStringList &commands) { + LLDB_RECORD_METHOD(bool, SBBreakpointName, GetCommandLineCommands, + (lldb::SBStringList &), commands); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointName *bp_name = GetBreakpointName(); @@ -496,6 +567,9 @@ bool SBBreakpointName::GetCommandLineCommands(SBStringList &commands) { } const char *SBBreakpointName::GetHelpString() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName, + GetHelpString); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointName *bp_name = GetBreakpointName(); @@ -507,6 +581,9 @@ const char *SBBreakpointName::GetHelpString() const { } void SBBreakpointName::SetHelpString(const char *help_string) { + LLDB_RECORD_METHOD(void, SBBreakpointName, SetHelpString, (const char *), + help_string); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) @@ -520,6 +597,9 @@ void SBBreakpointName::SetHelpString(const char *help_string) { } bool SBBreakpointName::GetDescription(SBStream &s) { + LLDB_RECORD_METHOD(bool, SBBreakpointName, GetDescription, (lldb::SBStream &), + s); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointName *bp_name = GetBreakpointName(); @@ -556,6 +636,9 @@ void SBBreakpointName::SetCallback(SBBreakpointHitCallback callback, void SBBreakpointName::SetScriptCallbackFunction( const char *callback_function_name) { + LLDB_RECORD_METHOD(void, SBBreakpointName, SetScriptCallbackFunction, + (const char *), callback_function_name); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointName *bp_name = GetBreakpointName(); @@ -578,14 +661,17 @@ void SBBreakpointName::SetScriptCallbackFunction( UpdateName(*bp_name); } -SBError SBBreakpointName::SetScriptCallbackBody(const char *callback_body_text) -{ +SBError +SBBreakpointName::SetScriptCallbackBody(const char *callback_body_text) { + LLDB_RECORD_METHOD(lldb::SBError, SBBreakpointName, SetScriptCallbackBody, + (const char *), callback_body_text); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBError sb_error; BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) - return sb_error; - + return LLDB_RECORD_RESULT(sb_error); + LLDB_LOG(log, "Name: {0} callback: {1}\n", bp_name->GetName(), callback_body_text); @@ -603,19 +689,21 @@ SBError SBBreakpointName::SetScriptCallbackBody(const char *callback_body_text) if (!sb_error.Fail()) UpdateName(*bp_name); - return sb_error; + return LLDB_RECORD_RESULT(sb_error); } -bool SBBreakpointName::GetAllowList() const -{ +bool SBBreakpointName::GetAllowList() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, GetAllowList); + BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) return false; return bp_name->GetPermissions().GetAllowList(); } -void SBBreakpointName::SetAllowList(bool value) -{ +void SBBreakpointName::SetAllowList(bool value) { + LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowList, (bool), value); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointName *bp_name = GetBreakpointName(); @@ -626,17 +714,19 @@ void SBBreakpointName::SetAllowList(bool value) bp_name->GetName().AsCString()); bp_name->GetPermissions().SetAllowList(value); } - -bool SBBreakpointName::GetAllowDelete() -{ + +bool SBBreakpointName::GetAllowDelete() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAllowDelete); + BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) return false; return bp_name->GetPermissions().GetAllowDelete(); } -void SBBreakpointName::SetAllowDelete(bool value) -{ +void SBBreakpointName::SetAllowDelete(bool value) { + LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowDelete, (bool), value); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointName *bp_name = GetBreakpointName(); @@ -647,17 +737,19 @@ void SBBreakpointName::SetAllowDelete(bool value) bp_name->GetName().AsCString()); bp_name->GetPermissions().SetAllowDelete(value); } - -bool SBBreakpointName::GetAllowDisable() -{ + +bool SBBreakpointName::GetAllowDisable() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAllowDisable); + BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) return false; return bp_name->GetPermissions().GetAllowDisable(); } -void SBBreakpointName::SetAllowDisable(bool value) -{ +void SBBreakpointName::SetAllowDisable(bool value) { + LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowDisable, (bool), value); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); BreakpointName *bp_name = GetBreakpointName(); diff --git a/lldb/source/API/SBBroadcaster.cpp b/lldb/source/API/SBBroadcaster.cpp index 2252e402671..17911dc72ee 100644 --- a/lldb/source/API/SBBroadcaster.cpp +++ b/lldb/source/API/SBBroadcaster.cpp @@ -6,6 +6,7 @@ // //===----------------------------------------------------------------------===// +#include "SBReproducerPrivate.h" #include "lldb/Utility/Broadcaster.h" #include "lldb/Utility/Log.h" @@ -16,10 +17,14 @@ using namespace lldb; using namespace lldb_private; -SBBroadcaster::SBBroadcaster() : m_opaque_sp(), m_opaque_ptr(NULL) {} +SBBroadcaster::SBBroadcaster() : m_opaque_sp(), m_opaque_ptr(NULL) { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBroadcaster); +} SBBroadcaster::SBBroadcaster(const char *name) : m_opaque_sp(new Broadcaster(NULL, name)), m_opaque_ptr(NULL) { + LLDB_RECORD_CONSTRUCTOR(SBBroadcaster, (const char *), name); + m_opaque_ptr = m_opaque_sp.get(); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); LLDB_LOGV(log, "(name=\"{0}\") => SBBroadcaster({1})", name, m_opaque_ptr); @@ -33,9 +38,15 @@ SBBroadcaster::SBBroadcaster(lldb_private::Broadcaster *broadcaster, bool owns) } SBBroadcaster::SBBroadcaster(const SBBroadcaster &rhs) - : m_opaque_sp(rhs.m_opaque_sp), m_opaque_ptr(rhs.m_opaque_ptr) {} + : m_opaque_sp(rhs.m_opaque_sp), m_opaque_ptr(rhs.m_opaque_ptr) { + LLDB_RECORD_CONSTRUCTOR(SBBroadcaster, (const lldb::SBBroadcaster &), rhs); +} const SBBroadcaster &SBBroadcaster::operator=(const SBBroadcaster &rhs) { + LLDB_RECORD_METHOD(const lldb::SBBroadcaster &, + SBBroadcaster, operator=,(const lldb::SBBroadcaster &), + rhs); + if (this != &rhs) { m_opaque_sp = rhs.m_opaque_sp; m_opaque_ptr = rhs.m_opaque_ptr; @@ -46,6 +57,9 @@ const SBBroadcaster &SBBroadcaster::operator=(const SBBroadcaster &rhs) { SBBroadcaster::~SBBroadcaster() { reset(NULL, false); } void SBBroadcaster::BroadcastEventByType(uint32_t event_type, bool unique) { + LLDB_RECORD_METHOD(void, SBBroadcaster, BroadcastEventByType, + (uint32_t, bool), event_type, unique); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) @@ -63,6 +77,9 @@ void SBBroadcaster::BroadcastEventByType(uint32_t event_type, bool unique) { } void SBBroadcaster::BroadcastEvent(const SBEvent &event, bool unique) { + LLDB_RECORD_METHOD(void, SBBroadcaster, BroadcastEvent, + (const lldb::SBEvent &, bool), event, unique); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) @@ -83,6 +100,10 @@ void SBBroadcaster::BroadcastEvent(const SBEvent &event, bool unique) { void SBBroadcaster::AddInitialEventsToListener(const SBListener &listener, uint32_t requested_events) { + LLDB_RECORD_METHOD(void, SBBroadcaster, AddInitialEventsToListener, + (const lldb::SBListener &, uint32_t), listener, + requested_events); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) log->Printf("SBBroadcaster(%p)::AddInitialEventsToListener " @@ -96,18 +117,27 @@ void SBBroadcaster::AddInitialEventsToListener(const SBListener &listener, uint32_t SBBroadcaster::AddListener(const SBListener &listener, uint32_t event_mask) { + LLDB_RECORD_METHOD(uint32_t, SBBroadcaster, AddListener, + (const lldb::SBListener &, uint32_t), listener, + event_mask); + if (m_opaque_ptr) return m_opaque_ptr->AddListener(listener.m_opaque_sp, event_mask); return 0; } const char *SBBroadcaster::GetName() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBroadcaster, GetName); + if (m_opaque_ptr) return m_opaque_ptr->GetBroadcasterName().GetCString(); return NULL; } bool SBBroadcaster::EventTypeHasListeners(uint32_t event_type) { + LLDB_RECORD_METHOD(bool, SBBroadcaster, EventTypeHasListeners, (uint32_t), + event_type); + if (m_opaque_ptr) return m_opaque_ptr->EventTypeHasListeners(event_type); return false; @@ -115,6 +145,10 @@ bool SBBroadcaster::EventTypeHasListeners(uint32_t event_type) { bool SBBroadcaster::RemoveListener(const SBListener &listener, uint32_t event_mask) { + LLDB_RECORD_METHOD(bool, SBBroadcaster, RemoveListener, + (const lldb::SBListener &, uint32_t), listener, + event_mask); + if (m_opaque_ptr) return m_opaque_ptr->RemoveListener(listener.m_opaque_sp, event_mask); return false; @@ -130,21 +164,36 @@ void SBBroadcaster::reset(Broadcaster *broadcaster, bool owns) { m_opaque_ptr = broadcaster; } -bool SBBroadcaster::IsValid() const { return m_opaque_ptr != NULL; } +bool SBBroadcaster::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBroadcaster, IsValid); + + return m_opaque_ptr != NULL; +} void SBBroadcaster::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBBroadcaster, Clear); + m_opaque_sp.reset(); m_opaque_ptr = NULL; } bool SBBroadcaster::operator==(const SBBroadcaster &rhs) const { + LLDB_RECORD_METHOD_CONST( + bool, SBBroadcaster, operator==,(const lldb::SBBroadcaster &), rhs); + return m_opaque_ptr == rhs.m_opaque_ptr; } bool SBBroadcaster::operator!=(const SBBroadcaster &rhs) const { + LLDB_RECORD_METHOD_CONST( + bool, SBBroadcaster, operator!=,(const lldb::SBBroadcaster &), rhs); + return m_opaque_ptr != rhs.m_opaque_ptr; } bool SBBroadcaster::operator<(const SBBroadcaster &rhs) const { + LLDB_RECORD_METHOD_CONST( + bool, SBBroadcaster, operator<,(const lldb::SBBroadcaster &), rhs); + return m_opaque_ptr < rhs.m_opaque_ptr; } diff --git a/lldb/source/API/SBCommandInterpreter.cpp b/lldb/source/API/SBCommandInterpreter.cpp index 16740868ff7..d50c80e6dfa 100644 --- a/lldb/source/API/SBCommandInterpreter.cpp +++ b/lldb/source/API/SBCommandInterpreter.cpp @@ -8,6 +8,7 @@ #include "lldb/lldb-types.h" +#include "SBReproducerPrivate.h" #include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandObjectMultiword.h" #include "lldb/Interpreter/CommandReturnObject.h" @@ -31,64 +32,108 @@ using namespace lldb; using namespace lldb_private; SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommandInterpreterRunOptions); + m_opaque_up.reset(new CommandInterpreterRunOptions()); } SBCommandInterpreterRunOptions::~SBCommandInterpreterRunOptions() = default; bool SBCommandInterpreterRunOptions::GetStopOnContinue() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, + GetStopOnContinue); + return m_opaque_up->GetStopOnContinue(); } void SBCommandInterpreterRunOptions::SetStopOnContinue(bool stop_on_continue) { + LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnContinue, + (bool), stop_on_continue); + m_opaque_up->SetStopOnContinue(stop_on_continue); } bool SBCommandInterpreterRunOptions::GetStopOnError() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, + GetStopOnError); + return m_opaque_up->GetStopOnError(); } void SBCommandInterpreterRunOptions::SetStopOnError(bool stop_on_error) { + LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnError, + (bool), stop_on_error); + m_opaque_up->SetStopOnError(stop_on_error); } bool SBCommandInterpreterRunOptions::GetStopOnCrash() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, + GetStopOnCrash); + return m_opaque_up->GetStopOnCrash(); } void SBCommandInterpreterRunOptions::SetStopOnCrash(bool stop_on_crash) { + LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnCrash, + (bool), stop_on_crash); + m_opaque_up->SetStopOnCrash(stop_on_crash); } bool SBCommandInterpreterRunOptions::GetEchoCommands() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, + GetEchoCommands); + return m_opaque_up->GetEchoCommands(); } void SBCommandInterpreterRunOptions::SetEchoCommands(bool echo_commands) { + LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetEchoCommands, + (bool), echo_commands); + m_opaque_up->SetEchoCommands(echo_commands); } bool SBCommandInterpreterRunOptions::GetEchoCommentCommands() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, + GetEchoCommentCommands); + return m_opaque_up->GetEchoCommentCommands(); } void SBCommandInterpreterRunOptions::SetEchoCommentCommands(bool echo) { + LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, + SetEchoCommentCommands, (bool), echo); + m_opaque_up->SetEchoCommentCommands(echo); } bool SBCommandInterpreterRunOptions::GetPrintResults() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, + GetPrintResults); + return m_opaque_up->GetPrintResults(); } void SBCommandInterpreterRunOptions::SetPrintResults(bool print_results) { + LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetPrintResults, + (bool), print_results); + m_opaque_up->SetPrintResults(print_results); } bool SBCommandInterpreterRunOptions::GetAddToHistory() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, + GetAddToHistory); + return m_opaque_up->GetAddToHistory(); } void SBCommandInterpreterRunOptions::SetAddToHistory(bool add_to_history) { + LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetAddToHistory, + (bool), add_to_history); + m_opaque_up->SetAddToHistory(add_to_history); } @@ -130,6 +175,9 @@ protected: SBCommandInterpreter::SBCommandInterpreter(CommandInterpreter *interpreter) : m_opaque_ptr(interpreter) { + LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreter, + (lldb_private::CommandInterpreter *), interpreter); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) @@ -140,37 +188,62 @@ SBCommandInterpreter::SBCommandInterpreter(CommandInterpreter *interpreter) } SBCommandInterpreter::SBCommandInterpreter(const SBCommandInterpreter &rhs) - : m_opaque_ptr(rhs.m_opaque_ptr) {} + : m_opaque_ptr(rhs.m_opaque_ptr) { + LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreter, + (const lldb::SBCommandInterpreter &), rhs); +} SBCommandInterpreter::~SBCommandInterpreter() = default; const SBCommandInterpreter &SBCommandInterpreter:: operator=(const SBCommandInterpreter &rhs) { + LLDB_RECORD_METHOD( + const lldb::SBCommandInterpreter &, + SBCommandInterpreter, operator=,(const lldb::SBCommandInterpreter &), + rhs); + m_opaque_ptr = rhs.m_opaque_ptr; return *this; } -bool SBCommandInterpreter::IsValid() const { return m_opaque_ptr != nullptr; } +bool SBCommandInterpreter::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, IsValid); + + return m_opaque_ptr != nullptr; +} bool SBCommandInterpreter::CommandExists(const char *cmd) { + LLDB_RECORD_METHOD(bool, SBCommandInterpreter, CommandExists, (const char *), + cmd); + return (((cmd != nullptr) && IsValid()) ? m_opaque_ptr->CommandExists(cmd) : false); } bool SBCommandInterpreter::AliasExists(const char *cmd) { + LLDB_RECORD_METHOD(bool, SBCommandInterpreter, AliasExists, (const char *), + cmd); + return (((cmd != nullptr) && IsValid()) ? m_opaque_ptr->AliasExists(cmd) : false); } bool SBCommandInterpreter::IsActive() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, IsActive); + return (IsValid() ? m_opaque_ptr->IsActive() : false); } bool SBCommandInterpreter::WasInterrupted() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, WasInterrupted); + return (IsValid() ? m_opaque_ptr->WasInterrupted() : false); } const char *SBCommandInterpreter::GetIOHandlerControlSequence(char ch) { + LLDB_RECORD_METHOD(const char *, SBCommandInterpreter, + GetIOHandlerControlSequence, (char), ch); + return (IsValid() ? m_opaque_ptr->GetDebugger() .GetTopIOHandlerControlSequence(ch) @@ -182,6 +255,10 @@ lldb::ReturnStatus SBCommandInterpreter::HandleCommand(const char *command_line, SBCommandReturnObject &result, bool add_to_history) { + LLDB_RECORD_METHOD(lldb::ReturnStatus, SBCommandInterpreter, HandleCommand, + (const char *, lldb::SBCommandReturnObject &, bool), + command_line, result, add_to_history); + SBExecutionContext sb_exe_ctx; return HandleCommand(command_line, sb_exe_ctx, result, add_to_history); } @@ -189,6 +266,11 @@ SBCommandInterpreter::HandleCommand(const char *command_line, lldb::ReturnStatus SBCommandInterpreter::HandleCommand( const char *command_line, SBExecutionContext &override_context, SBCommandReturnObject &result, bool add_to_history) { + LLDB_RECORD_METHOD(lldb::ReturnStatus, SBCommandInterpreter, HandleCommand, + (const char *, lldb::SBExecutionContext &, + lldb::SBCommandReturnObject &, bool), + command_line, override_context, result, add_to_history); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) @@ -235,6 +317,12 @@ void SBCommandInterpreter::HandleCommandsFromFile( lldb::SBFileSpec &file, lldb::SBExecutionContext &override_context, lldb::SBCommandInterpreterRunOptions &options, lldb::SBCommandReturnObject result) { + LLDB_RECORD_METHOD(void, SBCommandInterpreter, HandleCommandsFromFile, + (lldb::SBFileSpec &, lldb::SBExecutionContext &, + lldb::SBCommandInterpreterRunOptions &, + lldb::SBCommandReturnObject), + file, override_context, options, result); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) { @@ -274,6 +362,12 @@ void SBCommandInterpreter::HandleCommandsFromFile( int SBCommandInterpreter::HandleCompletion( const char *current_line, const char *cursor, const char *last_char, int match_start_point, int max_return_elements, SBStringList &matches) { + LLDB_RECORD_METHOD(int, SBCommandInterpreter, HandleCompletion, + (const char *, const char *, const char *, int, int, + lldb::SBStringList &), + current_line, cursor, last_char, match_start_point, + max_return_elements, matches); + SBStringList dummy_descriptions; return HandleCompletionWithDescriptions( current_line, cursor, last_char, match_start_point, max_return_elements, @@ -284,6 +378,13 @@ int SBCommandInterpreter::HandleCompletionWithDescriptions( const char *current_line, const char *cursor, const char *last_char, int match_start_point, int max_return_elements, SBStringList &matches, SBStringList &descriptions) { + LLDB_RECORD_METHOD(int, SBCommandInterpreter, + HandleCompletionWithDescriptions, + (const char *, const char *, const char *, int, int, + lldb::SBStringList &, lldb::SBStringList &), + current_line, cursor, last_char, match_start_point, + max_return_elements, matches, descriptions); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); int num_completions = 0; @@ -333,6 +434,13 @@ int SBCommandInterpreter::HandleCompletionWithDescriptions( const char *current_line, uint32_t cursor_pos, int match_start_point, int max_return_elements, SBStringList &matches, SBStringList &descriptions) { + LLDB_RECORD_METHOD(int, SBCommandInterpreter, + HandleCompletionWithDescriptions, + (const char *, uint32_t, int, int, lldb::SBStringList &, + lldb::SBStringList &), + current_line, cursor_pos, match_start_point, + max_return_elements, matches, descriptions); + const char *cursor = current_line + cursor_pos; const char *last_char = current_line + strlen(current_line); return HandleCompletionWithDescriptions( @@ -345,6 +453,11 @@ int SBCommandInterpreter::HandleCompletion(const char *current_line, int match_start_point, int max_return_elements, lldb::SBStringList &matches) { + LLDB_RECORD_METHOD(int, SBCommandInterpreter, HandleCompletion, + (const char *, uint32_t, int, int, lldb::SBStringList &), + current_line, cursor_pos, match_start_point, + max_return_elements, matches); + const char *cursor = current_line + cursor_pos; const char *last_char = current_line + strlen(current_line); return HandleCompletion(current_line, cursor, last_char, match_start_point, @@ -352,18 +465,26 @@ int SBCommandInterpreter::HandleCompletion(const char *current_line, } bool SBCommandInterpreter::HasCommands() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasCommands); + return (IsValid() ? m_opaque_ptr->HasCommands() : false); } bool SBCommandInterpreter::HasAliases() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasAliases); + return (IsValid() ? m_opaque_ptr->HasAliases() : false); } bool SBCommandInterpreter::HasAliasOptions() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasAliasOptions); + return (IsValid() ? m_opaque_ptr->HasAliasOptions() : false); } SBProcess SBCommandInterpreter::GetProcess() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBCommandInterpreter, GetProcess); + SBProcess sb_process; ProcessSP process_sp; if (IsValid()) { @@ -381,10 +502,13 @@ SBProcess SBCommandInterpreter::GetProcess() { static_cast<void *>(m_opaque_ptr), static_cast<void *>(process_sp.get())); - return sb_process; + return LLDB_RECORD_RESULT(sb_process); } SBDebugger SBCommandInterpreter::GetDebugger() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBDebugger, SBCommandInterpreter, + GetDebugger); + SBDebugger sb_debugger; if (IsValid()) sb_debugger.reset(m_opaque_ptr->GetDebugger().shared_from_this()); @@ -395,24 +519,33 @@ SBDebugger SBCommandInterpreter::GetDebugger() { static_cast<void *>(m_opaque_ptr), static_cast<void *>(sb_debugger.get())); - return sb_debugger; + return LLDB_RECORD_RESULT(sb_debugger); } bool SBCommandInterpreter::GetPromptOnQuit() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, GetPromptOnQuit); + return (IsValid() ? m_opaque_ptr->GetPromptOnQuit() : false); } void SBCommandInterpreter::SetPromptOnQuit(bool b) { + LLDB_RECORD_METHOD(void, SBCommandInterpreter, SetPromptOnQuit, (bool), b); + if (IsValid()) m_opaque_ptr->SetPromptOnQuit(b); } void SBCommandInterpreter::AllowExitCodeOnQuit(bool allow) { + LLDB_RECORD_METHOD(void, SBCommandInterpreter, AllowExitCodeOnQuit, (bool), + allow); + if (m_opaque_ptr) m_opaque_ptr->AllowExitCodeOnQuit(allow); } bool SBCommandInterpreter::HasCustomQuitExitCode() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasCustomQuitExitCode); + bool exited = false; if (m_opaque_ptr) m_opaque_ptr->GetQuitExitCode(exited); @@ -420,12 +553,18 @@ bool SBCommandInterpreter::HasCustomQuitExitCode() { } int SBCommandInterpreter::GetQuitStatus() { + LLDB_RECORD_METHOD_NO_ARGS(int, SBCommandInterpreter, GetQuitStatus); + bool exited = false; return (m_opaque_ptr ? m_opaque_ptr->GetQuitExitCode(exited) : 0); } void SBCommandInterpreter::ResolveCommand(const char *command_line, SBCommandReturnObject &result) { + LLDB_RECORD_METHOD(void, SBCommandInterpreter, ResolveCommand, + (const char *, lldb::SBCommandReturnObject &), + command_line, result); + result.Clear(); if (command_line && IsValid()) { m_opaque_ptr->ResolveCommand(command_line, result.ref()); @@ -450,6 +589,9 @@ void SBCommandInterpreter::reset( void SBCommandInterpreter::SourceInitFileInHomeDirectory( SBCommandReturnObject &result) { + LLDB_RECORD_METHOD(void, SBCommandInterpreter, SourceInitFileInHomeDirectory, + (lldb::SBCommandReturnObject &), result); + result.Clear(); if (IsValid()) { TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget()); @@ -472,6 +614,10 @@ void SBCommandInterpreter::SourceInitFileInHomeDirectory( void SBCommandInterpreter::SourceInitFileInCurrentWorkingDirectory( SBCommandReturnObject &result) { + LLDB_RECORD_METHOD(void, SBCommandInterpreter, + SourceInitFileInCurrentWorkingDirectory, + (lldb::SBCommandReturnObject &), result); + result.Clear(); if (IsValid()) { TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget()); @@ -493,6 +639,9 @@ void SBCommandInterpreter::SourceInitFileInCurrentWorkingDirectory( } SBBroadcaster SBCommandInterpreter::GetBroadcaster() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBroadcaster, SBCommandInterpreter, + GetBroadcaster); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBBroadcaster broadcaster(m_opaque_ptr, false); @@ -503,25 +652,40 @@ SBBroadcaster SBCommandInterpreter::GetBroadcaster() { static_cast<void *>(m_opaque_ptr), static_cast<void *>(broadcaster.get())); - return broadcaster; + return LLDB_RECORD_RESULT(broadcaster); } const char *SBCommandInterpreter::GetBroadcasterClass() { + LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBCommandInterpreter, + GetBroadcasterClass); + return CommandInterpreter::GetStaticBroadcasterClass().AsCString(); } const char *SBCommandInterpreter::GetArgumentTypeAsCString( const lldb::CommandArgumentType arg_type) { + LLDB_RECORD_STATIC_METHOD(const char *, SBCommandInterpreter, + GetArgumentTypeAsCString, + (const lldb::CommandArgumentType), arg_type); + return CommandObject::GetArgumentTypeAsCString(arg_type); } const char *SBCommandInterpreter::GetArgumentDescriptionAsCString( const lldb::CommandArgumentType arg_type) { + LLDB_RECORD_STATIC_METHOD(const char *, SBCommandInterpreter, + GetArgumentDescriptionAsCString, + (const lldb::CommandArgumentType), arg_type); + return CommandObject::GetArgumentDescriptionAsCString(arg_type); } bool SBCommandInterpreter::EventIsCommandInterpreterEvent( const lldb::SBEvent &event) { + LLDB_RECORD_STATIC_METHOD(bool, SBCommandInterpreter, + EventIsCommandInterpreterEvent, + (const lldb::SBEvent &), event); + return event.GetBroadcasterClass() == SBCommandInterpreter::GetBroadcasterClass(); } @@ -544,122 +708,166 @@ bool SBCommandInterpreter::SetCommandOverrideCallback( lldb::SBCommand SBCommandInterpreter::AddMultiwordCommand(const char *name, const char *help) { + LLDB_RECORD_METHOD(lldb::SBCommand, SBCommandInterpreter, AddMultiwordCommand, + (const char *, const char *), name, help); + CommandObjectMultiword *new_command = new CommandObjectMultiword(*m_opaque_ptr, name, help); new_command->SetRemovable(true); lldb::CommandObjectSP new_command_sp(new_command); if (new_command_sp && m_opaque_ptr->AddUserCommand(name, new_command_sp, true)) - return lldb::SBCommand(new_command_sp); - return lldb::SBCommand(); + return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp)); + return LLDB_RECORD_RESULT(lldb::SBCommand()); } lldb::SBCommand SBCommandInterpreter::AddCommand( const char *name, lldb::SBCommandPluginInterface *impl, const char *help) { + LLDB_RECORD_METHOD( + lldb::SBCommand, SBCommandInterpreter, AddCommand, + (const char *, lldb::SBCommandPluginInterface *, const char *), name, + impl, help); + lldb::CommandObjectSP new_command_sp; new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>( *m_opaque_ptr, name, impl, help); if (new_command_sp && m_opaque_ptr->AddUserCommand(name, new_command_sp, true)) - return lldb::SBCommand(new_command_sp); - return lldb::SBCommand(); + return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp)); + return LLDB_RECORD_RESULT(lldb::SBCommand()); } lldb::SBCommand SBCommandInterpreter::AddCommand(const char *name, lldb::SBCommandPluginInterface *impl, const char *help, const char *syntax) { + LLDB_RECORD_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand, + (const char *, lldb::SBCommandPluginInterface *, + const char *, const char *), + name, impl, help, syntax); + lldb::CommandObjectSP new_command_sp; new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>( *m_opaque_ptr, name, impl, help, syntax); if (new_command_sp && m_opaque_ptr->AddUserCommand(name, new_command_sp, true)) - return lldb::SBCommand(new_command_sp); - return lldb::SBCommand(); + return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp)); + return LLDB_RECORD_RESULT(lldb::SBCommand()); } -SBCommand::SBCommand() = default; +SBCommand::SBCommand() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommand); } SBCommand::SBCommand(lldb::CommandObjectSP cmd_sp) : m_opaque_sp(cmd_sp) {} -bool SBCommand::IsValid() { return m_opaque_sp.get() != nullptr; } +bool SBCommand::IsValid() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommand, IsValid); + + return m_opaque_sp.get() != nullptr; +} const char *SBCommand::GetName() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetName); + return (IsValid() ? ConstString(m_opaque_sp->GetCommandName()).AsCString() : nullptr); } const char *SBCommand::GetHelp() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetHelp); + return (IsValid() ? ConstString(m_opaque_sp->GetHelp()).AsCString() : nullptr); } const char *SBCommand::GetHelpLong() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetHelpLong); + return (IsValid() ? ConstString(m_opaque_sp->GetHelpLong()).AsCString() : nullptr); } void SBCommand::SetHelp(const char *help) { + LLDB_RECORD_METHOD(void, SBCommand, SetHelp, (const char *), help); + if (IsValid()) m_opaque_sp->SetHelp(help); } void SBCommand::SetHelpLong(const char *help) { + LLDB_RECORD_METHOD(void, SBCommand, SetHelpLong, (const char *), help); + if (IsValid()) m_opaque_sp->SetHelpLong(help); } lldb::SBCommand SBCommand::AddMultiwordCommand(const char *name, const char *help) { + LLDB_RECORD_METHOD(lldb::SBCommand, SBCommand, AddMultiwordCommand, + (const char *, const char *), name, help); + if (!IsValid()) - return lldb::SBCommand(); + return LLDB_RECORD_RESULT(lldb::SBCommand()); if (!m_opaque_sp->IsMultiwordObject()) - return lldb::SBCommand(); + return LLDB_RECORD_RESULT(lldb::SBCommand()); CommandObjectMultiword *new_command = new CommandObjectMultiword( m_opaque_sp->GetCommandInterpreter(), name, help); new_command->SetRemovable(true); lldb::CommandObjectSP new_command_sp(new_command); if (new_command_sp && m_opaque_sp->LoadSubCommand(name, new_command_sp)) - return lldb::SBCommand(new_command_sp); - return lldb::SBCommand(); + return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp)); + return LLDB_RECORD_RESULT(lldb::SBCommand()); } lldb::SBCommand SBCommand::AddCommand(const char *name, lldb::SBCommandPluginInterface *impl, const char *help) { + LLDB_RECORD_METHOD( + lldb::SBCommand, SBCommand, AddCommand, + (const char *, lldb::SBCommandPluginInterface *, const char *), name, + impl, help); + if (!IsValid()) - return lldb::SBCommand(); + return LLDB_RECORD_RESULT(lldb::SBCommand()); if (!m_opaque_sp->IsMultiwordObject()) - return lldb::SBCommand(); + return LLDB_RECORD_RESULT(lldb::SBCommand()); lldb::CommandObjectSP new_command_sp; new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>( m_opaque_sp->GetCommandInterpreter(), name, impl, help); if (new_command_sp && m_opaque_sp->LoadSubCommand(name, new_command_sp)) - return lldb::SBCommand(new_command_sp); - return lldb::SBCommand(); + return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp)); + return LLDB_RECORD_RESULT(lldb::SBCommand()); } lldb::SBCommand SBCommand::AddCommand(const char *name, lldb::SBCommandPluginInterface *impl, const char *help, const char *syntax) { + LLDB_RECORD_METHOD(lldb::SBCommand, SBCommand, AddCommand, + (const char *, lldb::SBCommandPluginInterface *, + const char *, const char *), + name, impl, help, syntax); + if (!IsValid()) - return lldb::SBCommand(); + return LLDB_RECORD_RESULT(lldb::SBCommand()); if (!m_opaque_sp->IsMultiwordObject()) - return lldb::SBCommand(); + return LLDB_RECORD_RESULT(lldb::SBCommand()); lldb::CommandObjectSP new_command_sp; new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>( m_opaque_sp->GetCommandInterpreter(), name, impl, help, syntax); if (new_command_sp && m_opaque_sp->LoadSubCommand(name, new_command_sp)) - return lldb::SBCommand(new_command_sp); - return lldb::SBCommand(); + return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp)); + return LLDB_RECORD_RESULT(lldb::SBCommand()); } uint32_t SBCommand::GetFlags() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBCommand, GetFlags); + return (IsValid() ? m_opaque_sp->GetFlags().Get() : 0); } void SBCommand::SetFlags(uint32_t flags) { + LLDB_RECORD_METHOD(void, SBCommand, SetFlags, (uint32_t), flags); + if (IsValid()) m_opaque_sp->GetFlags().Set(flags); } diff --git a/lldb/source/API/SBCommandReturnObject.cpp b/lldb/source/API/SBCommandReturnObject.cpp index ef37e3d59b2..62a8c106bba 100644 --- a/lldb/source/API/SBCommandReturnObject.cpp +++ b/lldb/source/API/SBCommandReturnObject.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBCommandReturnObject.h" +#include "SBReproducerPrivate.h" #include "Utils.h" #include "lldb/API/SBError.h" #include "lldb/API/SBStream.h" @@ -19,32 +20,54 @@ using namespace lldb; using namespace lldb_private; SBCommandReturnObject::SBCommandReturnObject() - : m_opaque_up(new CommandReturnObject()) {} + : m_opaque_up(new CommandReturnObject()) { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommandReturnObject); +} SBCommandReturnObject::SBCommandReturnObject(const SBCommandReturnObject &rhs) : m_opaque_up() { + LLDB_RECORD_CONSTRUCTOR(SBCommandReturnObject, + (const lldb::SBCommandReturnObject &), rhs); + m_opaque_up = clone(rhs.m_opaque_up); } SBCommandReturnObject::SBCommandReturnObject(CommandReturnObject *ptr) - : m_opaque_up(ptr) {} + : m_opaque_up(ptr) { + LLDB_RECORD_CONSTRUCTOR(SBCommandReturnObject, + (lldb_private::CommandReturnObject *), ptr); +} SBCommandReturnObject::~SBCommandReturnObject() = default; CommandReturnObject *SBCommandReturnObject::Release() { + LLDB_RECORD_METHOD_NO_ARGS(lldb_private::CommandReturnObject *, + SBCommandReturnObject, Release); + return m_opaque_up.release(); } const SBCommandReturnObject &SBCommandReturnObject:: operator=(const SBCommandReturnObject &rhs) { + LLDB_RECORD_METHOD( + const lldb::SBCommandReturnObject &, + SBCommandReturnObject, operator=,(const lldb::SBCommandReturnObject &), + rhs); + if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); return *this; } -bool SBCommandReturnObject::IsValid() const { return m_opaque_up != nullptr; } +bool SBCommandReturnObject::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandReturnObject, IsValid); + + return m_opaque_up != nullptr; +} const char *SBCommandReturnObject::GetOutput() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommandReturnObject, GetOutput); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (m_opaque_up) { @@ -66,6 +89,8 @@ const char *SBCommandReturnObject::GetOutput() { } const char *SBCommandReturnObject::GetError() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommandReturnObject, GetError); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (m_opaque_up) { @@ -86,14 +111,20 @@ const char *SBCommandReturnObject::GetError() { } size_t SBCommandReturnObject::GetOutputSize() { + LLDB_RECORD_METHOD_NO_ARGS(size_t, SBCommandReturnObject, GetOutputSize); + return (m_opaque_up ? m_opaque_up->GetOutputData().size() : 0); } size_t SBCommandReturnObject::GetErrorSize() { + LLDB_RECORD_METHOD_NO_ARGS(size_t, SBCommandReturnObject, GetErrorSize); + return (m_opaque_up ? m_opaque_up->GetErrorData().size() : 0); } size_t SBCommandReturnObject::PutOutput(FILE *fh) { + LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutOutput, (FILE *), fh); + if (fh) { size_t num_bytes = GetOutputSize(); if (num_bytes) @@ -103,6 +134,8 @@ size_t SBCommandReturnObject::PutOutput(FILE *fh) { } size_t SBCommandReturnObject::PutError(FILE *fh) { + LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutError, (FILE *), fh); + if (fh) { size_t num_bytes = GetErrorSize(); if (num_bytes) @@ -112,33 +145,51 @@ size_t SBCommandReturnObject::PutError(FILE *fh) { } void SBCommandReturnObject::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBCommandReturnObject, Clear); + if (m_opaque_up) m_opaque_up->Clear(); } lldb::ReturnStatus SBCommandReturnObject::GetStatus() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::ReturnStatus, SBCommandReturnObject, + GetStatus); + return (m_opaque_up ? m_opaque_up->GetStatus() : lldb::eReturnStatusInvalid); } void SBCommandReturnObject::SetStatus(lldb::ReturnStatus status) { + LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetStatus, + (lldb::ReturnStatus), status); + if (m_opaque_up) m_opaque_up->SetStatus(status); } bool SBCommandReturnObject::Succeeded() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandReturnObject, Succeeded); + return (m_opaque_up ? m_opaque_up->Succeeded() : false); } bool SBCommandReturnObject::HasResult() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandReturnObject, HasResult); + return (m_opaque_up ? m_opaque_up->HasResult() : false); } void SBCommandReturnObject::AppendMessage(const char *message) { + LLDB_RECORD_METHOD(void, SBCommandReturnObject, AppendMessage, (const char *), + message); + if (m_opaque_up) m_opaque_up->AppendMessage(message); } void SBCommandReturnObject::AppendWarning(const char *message) { + LLDB_RECORD_METHOD(void, SBCommandReturnObject, AppendWarning, (const char *), + message); + if (m_opaque_up) m_opaque_up->AppendWarning(message); } @@ -167,6 +218,9 @@ void SBCommandReturnObject::SetLLDBObjectPtr(CommandReturnObject *ptr) { } bool SBCommandReturnObject::GetDescription(SBStream &description) { + LLDB_RECORD_METHOD(bool, SBCommandReturnObject, GetDescription, + (lldb::SBStream &), description); + Stream &strm = description.ref(); if (m_opaque_up) { @@ -193,26 +247,41 @@ bool SBCommandReturnObject::GetDescription(SBStream &description) { } void SBCommandReturnObject::SetImmediateOutputFile(FILE *fh) { + LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile, + (FILE *), fh); + SetImmediateOutputFile(fh, false); } void SBCommandReturnObject::SetImmediateErrorFile(FILE *fh) { + LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile, + (FILE *), fh); + SetImmediateErrorFile(fh, false); } void SBCommandReturnObject::SetImmediateOutputFile(FILE *fh, bool transfer_ownership) { + LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile, + (FILE *, bool), fh, transfer_ownership); + if (m_opaque_up) m_opaque_up->SetImmediateOutputFile(fh, transfer_ownership); } void SBCommandReturnObject::SetImmediateErrorFile(FILE *fh, bool transfer_ownership) { + LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile, + (FILE *, bool), fh, transfer_ownership); + if (m_opaque_up) m_opaque_up->SetImmediateErrorFile(fh, transfer_ownership); } void SBCommandReturnObject::PutCString(const char *string, int len) { + LLDB_RECORD_METHOD(void, SBCommandReturnObject, PutCString, + (const char *, int), string, len); + if (m_opaque_up) { if (len == 0 || string == nullptr || *string == 0) { return; @@ -225,6 +294,9 @@ void SBCommandReturnObject::PutCString(const char *string, int len) { } const char *SBCommandReturnObject::GetOutput(bool only_if_no_immediate) { + LLDB_RECORD_METHOD(const char *, SBCommandReturnObject, GetOutput, (bool), + only_if_no_immediate); + if (!m_opaque_up) return nullptr; if (!only_if_no_immediate || @@ -234,6 +306,9 @@ const char *SBCommandReturnObject::GetOutput(bool only_if_no_immediate) { } const char *SBCommandReturnObject::GetError(bool only_if_no_immediate) { + LLDB_RECORD_METHOD(const char *, SBCommandReturnObject, GetError, (bool), + only_if_no_immediate); + if (!m_opaque_up) return nullptr; if (!only_if_no_immediate || @@ -255,6 +330,10 @@ size_t SBCommandReturnObject::Printf(const char *format, ...) { void SBCommandReturnObject::SetError(lldb::SBError &error, const char *fallback_error_cstr) { + LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetError, + (lldb::SBError &, const char *), error, + fallback_error_cstr); + if (m_opaque_up) { if (error.IsValid()) m_opaque_up->SetError(error.ref(), fallback_error_cstr); @@ -264,6 +343,9 @@ void SBCommandReturnObject::SetError(lldb::SBError &error, } void SBCommandReturnObject::SetError(const char *error_cstr) { + LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetError, (const char *), + error_cstr); + if (m_opaque_up && error_cstr) m_opaque_up->SetError(error_cstr); } diff --git a/lldb/source/API/SBCommunication.cpp b/lldb/source/API/SBCommunication.cpp index 2fc217432c0..41fb0062d09 100644 --- a/lldb/source/API/SBCommunication.cpp +++ b/lldb/source/API/SBCommunication.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBCommunication.h" +#include "SBReproducerPrivate.h" #include "lldb/API/SBBroadcaster.h" #include "lldb/Core/Communication.h" #include "lldb/Host/ConnectionFileDescriptor.h" @@ -16,10 +17,14 @@ using namespace lldb; using namespace lldb_private; -SBCommunication::SBCommunication() : m_opaque(NULL), m_opaque_owned(false) {} +SBCommunication::SBCommunication() : m_opaque(NULL), m_opaque_owned(false) { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommunication); +} SBCommunication::SBCommunication(const char *broadcaster_name) : m_opaque(new Communication(broadcaster_name)), m_opaque_owned(true) { + LLDB_RECORD_CONSTRUCTOR(SBCommunication, (const char *), broadcaster_name); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) @@ -35,20 +40,31 @@ SBCommunication::~SBCommunication() { m_opaque_owned = false; } -bool SBCommunication::IsValid() const { return m_opaque != NULL; } +bool SBCommunication::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommunication, IsValid); + + return m_opaque != NULL; +} bool SBCommunication::GetCloseOnEOF() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, GetCloseOnEOF); + if (m_opaque) return m_opaque->GetCloseOnEOF(); return false; } void SBCommunication::SetCloseOnEOF(bool b) { + LLDB_RECORD_METHOD(void, SBCommunication, SetCloseOnEOF, (bool), b); + if (m_opaque) m_opaque->SetCloseOnEOF(b); } ConnectionStatus SBCommunication::Connect(const char *url) { + LLDB_RECORD_METHOD(lldb::ConnectionStatus, SBCommunication, Connect, + (const char *), url); + if (m_opaque) { if (!m_opaque->HasConnection()) m_opaque->SetConnection(Host::CreateDefaultConnection(url).release()); @@ -58,6 +74,9 @@ ConnectionStatus SBCommunication::Connect(const char *url) { } ConnectionStatus SBCommunication::AdoptFileDesriptor(int fd, bool owns_fd) { + LLDB_RECORD_METHOD(lldb::ConnectionStatus, SBCommunication, + AdoptFileDesriptor, (int, bool), fd, owns_fd); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); ConnectionStatus status = eConnectionStatusNoConnection; @@ -83,6 +102,9 @@ ConnectionStatus SBCommunication::AdoptFileDesriptor(int fd, bool owns_fd) { } ConnectionStatus SBCommunication::Disconnect() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::ConnectionStatus, SBCommunication, + Disconnect); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); ConnectionStatus status = eConnectionStatusNoConnection; @@ -98,6 +120,8 @@ ConnectionStatus SBCommunication::Disconnect() { } bool SBCommunication::IsConnected() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommunication, IsConnected); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); bool result = false; if (m_opaque) @@ -158,6 +182,8 @@ size_t SBCommunication::Write(const void *src, size_t src_len, } bool SBCommunication::ReadThreadStart() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadStart); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); bool success = false; @@ -172,6 +198,8 @@ bool SBCommunication::ReadThreadStart() { } bool SBCommunication::ReadThreadStop() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadStop); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) log->Printf("SBCommunication(%p)::ReadThreadStop ()...", @@ -189,6 +217,8 @@ bool SBCommunication::ReadThreadStop() { } bool SBCommunication::ReadThreadIsRunning() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadIsRunning); + bool result = false; if (m_opaque) result = m_opaque->ReadThreadIsRunning(); @@ -220,6 +250,9 @@ bool SBCommunication::SetReadThreadBytesReceivedCallback( } SBBroadcaster SBCommunication::GetBroadcaster() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBroadcaster, SBCommunication, + GetBroadcaster); + SBBroadcaster broadcaster(m_opaque, false); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); @@ -229,10 +262,13 @@ SBBroadcaster SBCommunication::GetBroadcaster() { static_cast<void *>(m_opaque), static_cast<void *>(broadcaster.get())); - return broadcaster; + return LLDB_RECORD_RESULT(broadcaster); } const char *SBCommunication::GetBroadcasterClass() { + LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBCommunication, + GetBroadcasterClass); + return Communication::GetStaticBroadcasterClass().AsCString(); } diff --git a/lldb/source/API/SBCompileUnit.cpp b/lldb/source/API/SBCompileUnit.cpp index ef7d4c1d39f..d3e828c2ecc 100644 --- a/lldb/source/API/SBCompileUnit.cpp +++ b/lldb/source/API/SBCompileUnit.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBCompileUnit.h" +#include "SBReproducerPrivate.h" #include "lldb/API/SBLineEntry.h" #include "lldb/API/SBStream.h" #include "lldb/Core/Module.h" @@ -20,15 +21,23 @@ using namespace lldb; using namespace lldb_private; -SBCompileUnit::SBCompileUnit() : m_opaque_ptr(NULL) {} +SBCompileUnit::SBCompileUnit() : m_opaque_ptr(NULL) { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCompileUnit); +} SBCompileUnit::SBCompileUnit(lldb_private::CompileUnit *lldb_object_ptr) : m_opaque_ptr(lldb_object_ptr) {} SBCompileUnit::SBCompileUnit(const SBCompileUnit &rhs) - : m_opaque_ptr(rhs.m_opaque_ptr) {} + : m_opaque_ptr(rhs.m_opaque_ptr) { + LLDB_RECORD_CONSTRUCTOR(SBCompileUnit, (const lldb::SBCompileUnit &), rhs); +} const SBCompileUnit &SBCompileUnit::operator=(const SBCompileUnit &rhs) { + LLDB_RECORD_METHOD(const lldb::SBCompileUnit &, + SBCompileUnit, operator=,(const lldb::SBCompileUnit &), + rhs); + m_opaque_ptr = rhs.m_opaque_ptr; return *this; } @@ -36,13 +45,18 @@ const SBCompileUnit &SBCompileUnit::operator=(const SBCompileUnit &rhs) { SBCompileUnit::~SBCompileUnit() { m_opaque_ptr = NULL; } SBFileSpec SBCompileUnit::GetFileSpec() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBCompileUnit, + GetFileSpec); + SBFileSpec file_spec; if (m_opaque_ptr) file_spec.SetFileSpec(*m_opaque_ptr); - return file_spec; + return LLDB_RECORD_RESULT(file_spec); } uint32_t SBCompileUnit::GetNumLineEntries() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBCompileUnit, GetNumLineEntries); + if (m_opaque_ptr) { LineTable *line_table = m_opaque_ptr->GetLineTable(); if (line_table) @@ -52,6 +66,9 @@ uint32_t SBCompileUnit::GetNumLineEntries() const { } SBLineEntry SBCompileUnit::GetLineEntryAtIndex(uint32_t idx) const { + LLDB_RECORD_METHOD_CONST(lldb::SBLineEntry, SBCompileUnit, + GetLineEntryAtIndex, (uint32_t), idx); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBLineEntry sb_line_entry; @@ -73,11 +90,15 @@ SBLineEntry SBCompileUnit::GetLineEntryAtIndex(uint32_t idx) const { static_cast<void *>(sb_line_entry.get()), sstr.GetData()); } - return sb_line_entry; + return LLDB_RECORD_RESULT(sb_line_entry); } uint32_t SBCompileUnit::FindLineEntryIndex(uint32_t start_idx, uint32_t line, SBFileSpec *inline_file_spec) const { + LLDB_RECORD_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex, + (uint32_t, uint32_t, lldb::SBFileSpec *), start_idx, + line, inline_file_spec); + const bool exact = true; return FindLineEntryIndex(start_idx, line, inline_file_spec, exact); } @@ -85,6 +106,10 @@ uint32_t SBCompileUnit::FindLineEntryIndex(uint32_t start_idx, uint32_t line, uint32_t SBCompileUnit::FindLineEntryIndex(uint32_t start_idx, uint32_t line, SBFileSpec *inline_file_spec, bool exact) const { + LLDB_RECORD_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex, + (uint32_t, uint32_t, lldb::SBFileSpec *, bool), + start_idx, line, inline_file_spec, exact); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); uint32_t index = UINT32_MAX; @@ -124,6 +149,8 @@ uint32_t SBCompileUnit::FindLineEntryIndex(uint32_t start_idx, uint32_t line, } uint32_t SBCompileUnit::GetNumSupportFiles() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBCompileUnit, GetNumSupportFiles); + if (m_opaque_ptr) { FileSpecList &support_files = m_opaque_ptr->GetSupportFiles(); return support_files.GetSize(); @@ -132,27 +159,33 @@ uint32_t SBCompileUnit::GetNumSupportFiles() const { } lldb::SBTypeList SBCompileUnit::GetTypes(uint32_t type_mask) { + LLDB_RECORD_METHOD(lldb::SBTypeList, SBCompileUnit, GetTypes, (uint32_t), + type_mask); + SBTypeList sb_type_list; if (!m_opaque_ptr) - return sb_type_list; + return LLDB_RECORD_RESULT(sb_type_list); ModuleSP module_sp(m_opaque_ptr->GetModule()); if (!module_sp) - return sb_type_list; + return LLDB_RECORD_RESULT(sb_type_list); SymbolVendor *vendor = module_sp->GetSymbolVendor(); if (!vendor) - return sb_type_list; + return LLDB_RECORD_RESULT(sb_type_list); TypeClass type_class = static_cast<TypeClass>(type_mask); TypeList type_list; vendor->GetTypes(m_opaque_ptr, type_class, type_list); sb_type_list.m_opaque_up->Append(type_list); - return sb_type_list; + return LLDB_RECORD_RESULT(sb_type_list); } SBFileSpec SBCompileUnit::GetSupportFileAtIndex(uint32_t idx) const { + LLDB_RECORD_METHOD_CONST(lldb::SBFileSpec, SBCompileUnit, + GetSupportFileAtIndex, (uint32_t), idx); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBFileSpec sb_file_spec; @@ -171,12 +204,16 @@ SBFileSpec SBCompileUnit::GetSupportFileAtIndex(uint32_t idx) const { static_cast<const void *>(sb_file_spec.get()), sstr.GetData()); } - return sb_file_spec; + return LLDB_RECORD_RESULT(sb_file_spec); } uint32_t SBCompileUnit::FindSupportFileIndex(uint32_t start_idx, const SBFileSpec &sb_file, bool full) { + LLDB_RECORD_METHOD(uint32_t, SBCompileUnit, FindSupportFileIndex, + (uint32_t, const lldb::SBFileSpec &, bool), start_idx, + sb_file, full); + if (m_opaque_ptr) { FileSpecList &support_files = m_opaque_ptr->GetSupportFiles(); return support_files.FindFileIndex(start_idx, sb_file.ref(), full); @@ -185,18 +222,30 @@ uint32_t SBCompileUnit::FindSupportFileIndex(uint32_t start_idx, } lldb::LanguageType SBCompileUnit::GetLanguage() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::LanguageType, SBCompileUnit, GetLanguage); + if (m_opaque_ptr) return m_opaque_ptr->GetLanguage(); return lldb::eLanguageTypeUnknown; } -bool SBCompileUnit::IsValid() const { return m_opaque_ptr != NULL; } +bool SBCompileUnit::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCompileUnit, IsValid); + + return m_opaque_ptr != NULL; +} bool SBCompileUnit::operator==(const SBCompileUnit &rhs) const { + LLDB_RECORD_METHOD_CONST( + bool, SBCompileUnit, operator==,(const lldb::SBCompileUnit &), rhs); + return m_opaque_ptr == rhs.m_opaque_ptr; } bool SBCompileUnit::operator!=(const SBCompileUnit &rhs) const { + LLDB_RECORD_METHOD_CONST( + bool, SBCompileUnit, operator!=,(const lldb::SBCompileUnit &), rhs); + return m_opaque_ptr != rhs.m_opaque_ptr; } @@ -215,6 +264,9 @@ void SBCompileUnit::reset(lldb_private::CompileUnit *lldb_object_ptr) { } bool SBCompileUnit::GetDescription(SBStream &description) { + LLDB_RECORD_METHOD(bool, SBCompileUnit, GetDescription, (lldb::SBStream &), + description); + Stream &strm = description.ref(); if (m_opaque_ptr) { diff --git a/lldb/source/API/SBData.cpp b/lldb/source/API/SBData.cpp index 54a97614a07..6dbbd65e44a 100644 --- a/lldb/source/API/SBData.cpp +++ b/lldb/source/API/SBData.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBData.h" +#include "SBReproducerPrivate.h" #include "lldb/API/SBError.h" #include "lldb/API/SBStream.h" @@ -22,13 +23,20 @@ using namespace lldb; using namespace lldb_private; -SBData::SBData() : m_opaque_sp(new DataExtractor()) {} +SBData::SBData() : m_opaque_sp(new DataExtractor()) { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBData); +} SBData::SBData(const lldb::DataExtractorSP &data_sp) : m_opaque_sp(data_sp) {} -SBData::SBData(const SBData &rhs) : m_opaque_sp(rhs.m_opaque_sp) {} +SBData::SBData(const SBData &rhs) : m_opaque_sp(rhs.m_opaque_sp) { + LLDB_RECORD_CONSTRUCTOR(SBData, (const lldb::SBData &), rhs); +} const SBData &SBData::operator=(const SBData &rhs) { + LLDB_RECORD_METHOD(const lldb::SBData &, + SBData, operator=,(const lldb::SBData &), rhs); + if (this != &rhs) m_opaque_sp = rhs.m_opaque_sp; return *this; @@ -50,9 +58,15 @@ lldb::DataExtractorSP &SBData::operator*() { return m_opaque_sp; } const lldb::DataExtractorSP &SBData::operator*() const { return m_opaque_sp; } -bool SBData::IsValid() { return m_opaque_sp.get() != NULL; } +bool SBData::IsValid() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBData, IsValid); + + return m_opaque_sp.get() != NULL; +} uint8_t SBData::GetAddressByteSize() { + LLDB_RECORD_METHOD_NO_ARGS(uint8_t, SBData, GetAddressByteSize); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); uint8_t value = 0; if (m_opaque_sp.get()) @@ -65,6 +79,9 @@ uint8_t SBData::GetAddressByteSize() { } void SBData::SetAddressByteSize(uint8_t addr_byte_size) { + LLDB_RECORD_METHOD(void, SBData, SetAddressByteSize, (uint8_t), + addr_byte_size); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (m_opaque_sp.get()) m_opaque_sp->SetAddressByteSize(addr_byte_size); @@ -73,11 +90,15 @@ void SBData::SetAddressByteSize(uint8_t addr_byte_size) { } void SBData::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBData, Clear); + if (m_opaque_sp.get()) m_opaque_sp->Clear(); } size_t SBData::GetByteSize() { + LLDB_RECORD_METHOD_NO_ARGS(size_t, SBData, GetByteSize); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); size_t value = 0; if (m_opaque_sp.get()) @@ -90,6 +111,8 @@ size_t SBData::GetByteSize() { } lldb::ByteOrder SBData::GetByteOrder() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::ByteOrder, SBData, GetByteOrder); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); lldb::ByteOrder value = eByteOrderInvalid; if (m_opaque_sp.get()) @@ -102,6 +125,8 @@ lldb::ByteOrder SBData::GetByteOrder() { } void SBData::SetByteOrder(lldb::ByteOrder endian) { + LLDB_RECORD_METHOD(void, SBData, SetByteOrder, (lldb::ByteOrder), endian); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (m_opaque_sp.get()) m_opaque_sp->SetByteOrder(endian); @@ -110,6 +135,9 @@ void SBData::SetByteOrder(lldb::ByteOrder endian) { } float SBData::GetFloat(lldb::SBError &error, lldb::offset_t offset) { + LLDB_RECORD_METHOD(float, SBData, GetFloat, (lldb::SBError &, lldb::offset_t), + error, offset); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); float value = 0; if (!m_opaque_sp.get()) { @@ -127,6 +155,9 @@ float SBData::GetFloat(lldb::SBError &error, lldb::offset_t offset) { } double SBData::GetDouble(lldb::SBError &error, lldb::offset_t offset) { + LLDB_RECORD_METHOD(double, SBData, GetDouble, + (lldb::SBError &, lldb::offset_t), error, offset); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); double value = 0; if (!m_opaque_sp.get()) { @@ -145,6 +176,9 @@ double SBData::GetDouble(lldb::SBError &error, lldb::offset_t offset) { } long double SBData::GetLongDouble(lldb::SBError &error, lldb::offset_t offset) { + LLDB_RECORD_METHOD(long double, SBData, GetLongDouble, + (lldb::SBError &, lldb::offset_t), error, offset); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); long double value = 0; if (!m_opaque_sp.get()) { @@ -163,6 +197,9 @@ long double SBData::GetLongDouble(lldb::SBError &error, lldb::offset_t offset) { } lldb::addr_t SBData::GetAddress(lldb::SBError &error, lldb::offset_t offset) { + LLDB_RECORD_METHOD(lldb::addr_t, SBData, GetAddress, + (lldb::SBError &, lldb::offset_t), error, offset); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); lldb::addr_t value = 0; if (!m_opaque_sp.get()) { @@ -182,6 +219,9 @@ lldb::addr_t SBData::GetAddress(lldb::SBError &error, lldb::offset_t offset) { } uint8_t SBData::GetUnsignedInt8(lldb::SBError &error, lldb::offset_t offset) { + LLDB_RECORD_METHOD(uint8_t, SBData, GetUnsignedInt8, + (lldb::SBError &, lldb::offset_t), error, offset); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); uint8_t value = 0; if (!m_opaque_sp.get()) { @@ -200,6 +240,9 @@ uint8_t SBData::GetUnsignedInt8(lldb::SBError &error, lldb::offset_t offset) { } uint16_t SBData::GetUnsignedInt16(lldb::SBError &error, lldb::offset_t offset) { + LLDB_RECORD_METHOD(uint16_t, SBData, GetUnsignedInt16, + (lldb::SBError &, lldb::offset_t), error, offset); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); uint16_t value = 0; if (!m_opaque_sp.get()) { @@ -218,6 +261,9 @@ uint16_t SBData::GetUnsignedInt16(lldb::SBError &error, lldb::offset_t offset) { } uint32_t SBData::GetUnsignedInt32(lldb::SBError &error, lldb::offset_t offset) { + LLDB_RECORD_METHOD(uint32_t, SBData, GetUnsignedInt32, + (lldb::SBError &, lldb::offset_t), error, offset); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); uint32_t value = 0; if (!m_opaque_sp.get()) { @@ -236,6 +282,9 @@ uint32_t SBData::GetUnsignedInt32(lldb::SBError &error, lldb::offset_t offset) { } uint64_t SBData::GetUnsignedInt64(lldb::SBError &error, lldb::offset_t offset) { + LLDB_RECORD_METHOD(uint64_t, SBData, GetUnsignedInt64, + (lldb::SBError &, lldb::offset_t), error, offset); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); uint64_t value = 0; if (!m_opaque_sp.get()) { @@ -254,6 +303,9 @@ uint64_t SBData::GetUnsignedInt64(lldb::SBError &error, lldb::offset_t offset) { } int8_t SBData::GetSignedInt8(lldb::SBError &error, lldb::offset_t offset) { + LLDB_RECORD_METHOD(int8_t, SBData, GetSignedInt8, + (lldb::SBError &, lldb::offset_t), error, offset); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); int8_t value = 0; if (!m_opaque_sp.get()) { @@ -272,6 +324,9 @@ int8_t SBData::GetSignedInt8(lldb::SBError &error, lldb::offset_t offset) { } int16_t SBData::GetSignedInt16(lldb::SBError &error, lldb::offset_t offset) { + LLDB_RECORD_METHOD(int16_t, SBData, GetSignedInt16, + (lldb::SBError &, lldb::offset_t), error, offset); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); int16_t value = 0; if (!m_opaque_sp.get()) { @@ -290,6 +345,9 @@ int16_t SBData::GetSignedInt16(lldb::SBError &error, lldb::offset_t offset) { } int32_t SBData::GetSignedInt32(lldb::SBError &error, lldb::offset_t offset) { + LLDB_RECORD_METHOD(int32_t, SBData, GetSignedInt32, + (lldb::SBError &, lldb::offset_t), error, offset); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); int32_t value = 0; if (!m_opaque_sp.get()) { @@ -308,6 +366,9 @@ int32_t SBData::GetSignedInt32(lldb::SBError &error, lldb::offset_t offset) { } int64_t SBData::GetSignedInt64(lldb::SBError &error, lldb::offset_t offset) { + LLDB_RECORD_METHOD(int64_t, SBData, GetSignedInt64, + (lldb::SBError &, lldb::offset_t), error, offset); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); int64_t value = 0; if (!m_opaque_sp.get()) { @@ -326,6 +387,9 @@ int64_t SBData::GetSignedInt64(lldb::SBError &error, lldb::offset_t offset) { } const char *SBData::GetString(lldb::SBError &error, lldb::offset_t offset) { + LLDB_RECORD_METHOD(const char *, SBData, GetString, + (lldb::SBError &, lldb::offset_t), error, offset); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); const char *value = 0; if (!m_opaque_sp.get()) { @@ -345,6 +409,9 @@ const char *SBData::GetString(lldb::SBError &error, lldb::offset_t offset) { bool SBData::GetDescription(lldb::SBStream &description, lldb::addr_t base_addr) { + LLDB_RECORD_METHOD(bool, SBData, GetDescription, + (lldb::SBStream &, lldb::addr_t), description, base_addr); + Stream &strm = description.ref(); if (m_opaque_sp) { @@ -399,6 +466,8 @@ void SBData::SetData(lldb::SBError &error, const void *buf, size_t size, } bool SBData::Append(const SBData &rhs) { + LLDB_RECORD_METHOD(bool, SBData, Append, (const lldb::SBData &), rhs); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); bool value = false; if (m_opaque_sp.get() && rhs.m_opaque_sp.get()) @@ -412,8 +481,12 @@ bool SBData::Append(const SBData &rhs) { lldb::SBData SBData::CreateDataFromCString(lldb::ByteOrder endian, uint32_t addr_byte_size, const char *data) { + LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromCString, + (lldb::ByteOrder, uint32_t, const char *), endian, + addr_byte_size, data); + if (!data || !data[0]) - return SBData(); + return LLDB_RECORD_RESULT(SBData()); uint32_t data_len = strlen(data); @@ -423,15 +496,19 @@ lldb::SBData SBData::CreateDataFromCString(lldb::ByteOrder endian, SBData ret(data_sp); - return ret; + return LLDB_RECORD_RESULT(ret); } lldb::SBData SBData::CreateDataFromUInt64Array(lldb::ByteOrder endian, uint32_t addr_byte_size, uint64_t *array, size_t array_len) { + LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromUInt64Array, + (lldb::ByteOrder, uint32_t, uint64_t *, size_t), + endian, addr_byte_size, array, array_len); + if (!array || array_len == 0) - return SBData(); + return LLDB_RECORD_RESULT(SBData()); size_t data_len = array_len * sizeof(uint64_t); @@ -441,15 +518,19 @@ lldb::SBData SBData::CreateDataFromUInt64Array(lldb::ByteOrder endian, SBData ret(data_sp); - return ret; + return LLDB_RECORD_RESULT(ret); } lldb::SBData SBData::CreateDataFromUInt32Array(lldb::ByteOrder endian, uint32_t addr_byte_size, uint32_t *array, size_t array_len) { + LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromUInt32Array, + (lldb::ByteOrder, uint32_t, uint32_t *, size_t), + endian, addr_byte_size, array, array_len); + if (!array || array_len == 0) - return SBData(); + return LLDB_RECORD_RESULT(SBData()); size_t data_len = array_len * sizeof(uint32_t); @@ -459,15 +540,19 @@ lldb::SBData SBData::CreateDataFromUInt32Array(lldb::ByteOrder endian, SBData ret(data_sp); - return ret; + return LLDB_RECORD_RESULT(ret); } lldb::SBData SBData::CreateDataFromSInt64Array(lldb::ByteOrder endian, uint32_t addr_byte_size, int64_t *array, size_t array_len) { + LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromSInt64Array, + (lldb::ByteOrder, uint32_t, int64_t *, size_t), + endian, addr_byte_size, array, array_len); + if (!array || array_len == 0) - return SBData(); + return LLDB_RECORD_RESULT(SBData()); size_t data_len = array_len * sizeof(int64_t); @@ -477,15 +562,19 @@ lldb::SBData SBData::CreateDataFromSInt64Array(lldb::ByteOrder endian, SBData ret(data_sp); - return ret; + return LLDB_RECORD_RESULT(ret); } lldb::SBData SBData::CreateDataFromSInt32Array(lldb::ByteOrder endian, uint32_t addr_byte_size, int32_t *array, size_t array_len) { + LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromSInt32Array, + (lldb::ByteOrder, uint32_t, int32_t *, size_t), + endian, addr_byte_size, array, array_len); + if (!array || array_len == 0) - return SBData(); + return LLDB_RECORD_RESULT(SBData()); size_t data_len = array_len * sizeof(int32_t); @@ -495,15 +584,19 @@ lldb::SBData SBData::CreateDataFromSInt32Array(lldb::ByteOrder endian, SBData ret(data_sp); - return ret; + return LLDB_RECORD_RESULT(ret); } lldb::SBData SBData::CreateDataFromDoubleArray(lldb::ByteOrder endian, uint32_t addr_byte_size, double *array, size_t array_len) { + LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromDoubleArray, + (lldb::ByteOrder, uint32_t, double *, size_t), + endian, addr_byte_size, array, array_len); + if (!array || array_len == 0) - return SBData(); + return LLDB_RECORD_RESULT(SBData()); size_t data_len = array_len * sizeof(double); @@ -513,10 +606,12 @@ lldb::SBData SBData::CreateDataFromDoubleArray(lldb::ByteOrder endian, SBData ret(data_sp); - return ret; + return LLDB_RECORD_RESULT(ret); } bool SBData::SetDataFromCString(const char *data) { + LLDB_RECORD_METHOD(bool, SBData, SetDataFromCString, (const char *), data); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (!data) { @@ -544,6 +639,9 @@ bool SBData::SetDataFromCString(const char *data) { } bool SBData::SetDataFromUInt64Array(uint64_t *array, size_t array_len) { + LLDB_RECORD_METHOD(bool, SBData, SetDataFromUInt64Array, (uint64_t *, size_t), + array, array_len); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (!array || array_len == 0) { @@ -576,6 +674,9 @@ bool SBData::SetDataFromUInt64Array(uint64_t *array, size_t array_len) { } bool SBData::SetDataFromUInt32Array(uint32_t *array, size_t array_len) { + LLDB_RECORD_METHOD(bool, SBData, SetDataFromUInt32Array, (uint32_t *, size_t), + array, array_len); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (!array || array_len == 0) { @@ -608,6 +709,9 @@ bool SBData::SetDataFromUInt32Array(uint32_t *array, size_t array_len) { } bool SBData::SetDataFromSInt64Array(int64_t *array, size_t array_len) { + LLDB_RECORD_METHOD(bool, SBData, SetDataFromSInt64Array, (int64_t *, size_t), + array, array_len); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (!array || array_len == 0) { @@ -640,6 +744,9 @@ bool SBData::SetDataFromSInt64Array(int64_t *array, size_t array_len) { } bool SBData::SetDataFromSInt32Array(int32_t *array, size_t array_len) { + LLDB_RECORD_METHOD(bool, SBData, SetDataFromSInt32Array, (int32_t *, size_t), + array, array_len); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (!array || array_len == 0) { @@ -672,6 +779,9 @@ bool SBData::SetDataFromSInt32Array(int32_t *array, size_t array_len) { } bool SBData::SetDataFromDoubleArray(double *array, size_t array_len) { + LLDB_RECORD_METHOD(bool, SBData, SetDataFromDoubleArray, (double *, size_t), + array, array_len); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (!array || array_len == 0) { diff --git a/lldb/source/API/SBDebugger.cpp b/lldb/source/API/SBDebugger.cpp index 535dcf67582..d4ca3cea8e9 100644 --- a/lldb/source/API/SBDebugger.cpp +++ b/lldb/source/API/SBDebugger.cpp @@ -6,7 +6,7 @@ // //===----------------------------------------------------------------------===// - +#include "SBReproducerPrivate.h" #include "SystemInitializerFull.h" #include "lldb/API/SBDebugger.h" @@ -142,20 +142,33 @@ SBError SBInputReader::Initialize( return SBError(); } -void SBInputReader::SetIsDone(bool) {} +void SBInputReader::SetIsDone(bool b) { + LLDB_RECORD_METHOD(void, SBInputReader, SetIsDone, (bool), b); +} + +bool SBInputReader::IsActive() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInputReader, IsActive); -bool SBInputReader::IsActive() const { return false; } + return false; +} -SBDebugger::SBDebugger() = default; +SBDebugger::SBDebugger() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBDebugger); } SBDebugger::SBDebugger(const lldb::DebuggerSP &debugger_sp) - : m_opaque_sp(debugger_sp) {} + : m_opaque_sp(debugger_sp) { + LLDB_RECORD_CONSTRUCTOR(SBDebugger, (const lldb::DebuggerSP &), debugger_sp); +} -SBDebugger::SBDebugger(const SBDebugger &rhs) : m_opaque_sp(rhs.m_opaque_sp) {} +SBDebugger::SBDebugger(const SBDebugger &rhs) : m_opaque_sp(rhs.m_opaque_sp) { + LLDB_RECORD_CONSTRUCTOR(SBDebugger, (const lldb::SBDebugger &), rhs); +} SBDebugger::~SBDebugger() = default; SBDebugger &SBDebugger::operator=(const SBDebugger &rhs) { + LLDB_RECORD_METHOD(lldb::SBDebugger &, + SBDebugger, operator=,(const lldb::SBDebugger &), rhs); + if (this != &rhs) { m_opaque_sp = rhs.m_opaque_sp; } @@ -163,10 +176,14 @@ SBDebugger &SBDebugger::operator=(const SBDebugger &rhs) { } void SBDebugger::Initialize() { + LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, Initialize); SBError ignored = SBDebugger::InitializeWithErrorHandling(); } lldb::SBError SBDebugger::InitializeWithErrorHandling() { + LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBError, SBDebugger, + InitializeWithErrorHandling); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) @@ -177,12 +194,18 @@ lldb::SBError SBDebugger::InitializeWithErrorHandling() { llvm::make_unique<SystemInitializerFull>(), LoadPlugin)) { error.SetError(Status(std::move(e))); } - return error; + return LLDB_RECORD_RESULT(error); } -void SBDebugger::Terminate() { g_debugger_lifetime->Terminate(); } +void SBDebugger::Terminate() { + LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, Terminate); + + g_debugger_lifetime->Terminate(); +} void SBDebugger::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, Clear); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) @@ -196,11 +219,17 @@ void SBDebugger::Clear() { } SBDebugger SBDebugger::Create() { - return SBDebugger::Create(false, nullptr, nullptr); + LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBDebugger, SBDebugger, Create); + + return LLDB_RECORD_RESULT(SBDebugger::Create(false, nullptr, nullptr)); } SBDebugger SBDebugger::Create(bool source_init_files) { - return SBDebugger::Create(source_init_files, nullptr, nullptr); + LLDB_RECORD_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, (bool), + source_init_files); + + return LLDB_RECORD_RESULT( + SBDebugger::Create(source_init_files, nullptr, nullptr)); } SBDebugger SBDebugger::Create(bool source_init_files, @@ -243,6 +272,9 @@ SBDebugger SBDebugger::Create(bool source_init_files, } void SBDebugger::Destroy(SBDebugger &debugger) { + LLDB_RECORD_STATIC_METHOD(void, SBDebugger, Destroy, (lldb::SBDebugger &), + debugger); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) { @@ -260,6 +292,8 @@ void SBDebugger::Destroy(SBDebugger &debugger) { } void SBDebugger::MemoryPressureDetected() { + LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, MemoryPressureDetected); + // Since this function can be call asynchronously, we allow it to be non- // mandatory. We have seen deadlocks with this function when called so we // need to safeguard against this until we can determine what is causing the @@ -275,23 +309,35 @@ void SBDebugger::MemoryPressureDetected() { ModuleList::RemoveOrphanSharedModules(mandatory); } -bool SBDebugger::IsValid() const { return m_opaque_sp.get() != nullptr; } +bool SBDebugger::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, IsValid); + + return m_opaque_sp.get() != nullptr; +} void SBDebugger::SetAsync(bool b) { + LLDB_RECORD_METHOD(void, SBDebugger, SetAsync, (bool), b); + if (m_opaque_sp) m_opaque_sp->SetAsyncExecution(b); } bool SBDebugger::GetAsync() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBDebugger, GetAsync); + return (m_opaque_sp ? m_opaque_sp->GetAsyncExecution() : false); } void SBDebugger::SkipLLDBInitFiles(bool b) { + LLDB_RECORD_METHOD(void, SBDebugger, SkipLLDBInitFiles, (bool), b); + if (m_opaque_sp) m_opaque_sp->GetCommandInterpreter().SkipLLDBInitFiles(b); } void SBDebugger::SkipAppInitFiles(bool b) { + LLDB_RECORD_METHOD(void, SBDebugger, SkipAppInitFiles, (bool), b); + if (m_opaque_sp) m_opaque_sp->GetCommandInterpreter().SkipAppInitFiles(b); } @@ -300,6 +346,9 @@ void SBDebugger::SkipAppInitFiles(bool b) { // of problems; don't want users trying to switch modes in the middle of a // debugging session. void SBDebugger::SetInputFileHandle(FILE *fh, bool transfer_ownership) { + LLDB_RECORD_METHOD(void, SBDebugger, SetInputFileHandle, (FILE *, bool), fh, + transfer_ownership); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) @@ -323,6 +372,9 @@ void SBDebugger::SetInputFileHandle(FILE *fh, bool transfer_ownership) { } void SBDebugger::SetOutputFileHandle(FILE *fh, bool transfer_ownership) { + LLDB_RECORD_METHOD(void, SBDebugger, SetOutputFileHandle, (FILE *, bool), fh, + transfer_ownership); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) @@ -336,6 +388,9 @@ void SBDebugger::SetOutputFileHandle(FILE *fh, bool transfer_ownership) { } void SBDebugger::SetErrorFileHandle(FILE *fh, bool transfer_ownership) { + LLDB_RECORD_METHOD(void, SBDebugger, SetErrorFileHandle, (FILE *, bool), fh, + transfer_ownership); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) @@ -349,6 +404,8 @@ void SBDebugger::SetErrorFileHandle(FILE *fh, bool transfer_ownership) { } FILE *SBDebugger::GetInputFileHandle() { + LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetInputFileHandle); + if (m_opaque_sp) { StreamFileSP stream_file_sp(m_opaque_sp->GetInputFile()); if (stream_file_sp) @@ -358,6 +415,8 @@ FILE *SBDebugger::GetInputFileHandle() { } FILE *SBDebugger::GetOutputFileHandle() { + LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetOutputFileHandle); + if (m_opaque_sp) { StreamFileSP stream_file_sp(m_opaque_sp->GetOutputFile()); if (stream_file_sp) @@ -367,6 +426,8 @@ FILE *SBDebugger::GetOutputFileHandle() { } FILE *SBDebugger::GetErrorFileHandle() { + LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetErrorFileHandle); + if (m_opaque_sp) { StreamFileSP stream_file_sp(m_opaque_sp->GetErrorFile()); if (stream_file_sp) @@ -376,15 +437,22 @@ FILE *SBDebugger::GetErrorFileHandle() { } void SBDebugger::SaveInputTerminalState() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, SaveInputTerminalState); + if (m_opaque_sp) m_opaque_sp->SaveInputTerminalState(); } void SBDebugger::RestoreInputTerminalState() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, RestoreInputTerminalState); + if (m_opaque_sp) m_opaque_sp->RestoreInputTerminalState(); } SBCommandInterpreter SBDebugger::GetCommandInterpreter() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCommandInterpreter, SBDebugger, + GetCommandInterpreter); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBCommandInterpreter sb_interpreter; @@ -397,10 +465,12 @@ SBCommandInterpreter SBDebugger::GetCommandInterpreter() { static_cast<void *>(m_opaque_sp.get()), static_cast<void *>(sb_interpreter.get())); - return sb_interpreter; + return LLDB_RECORD_RESULT(sb_interpreter); } void SBDebugger::HandleCommand(const char *command) { + LLDB_RECORD_METHOD(void, SBDebugger, HandleCommand, (const char *), command); + if (m_opaque_sp) { TargetSP target_sp(m_opaque_sp->GetSelectedTarget()); std::unique_lock<std::recursive_mutex> lock; @@ -435,6 +505,8 @@ void SBDebugger::HandleCommand(const char *command) { } SBListener SBDebugger::GetListener() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBDebugger, GetListener); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBListener sb_listener; @@ -446,12 +518,17 @@ SBListener SBDebugger::GetListener() { static_cast<void *>(m_opaque_sp.get()), static_cast<void *>(sb_listener.get())); - return sb_listener; + return LLDB_RECORD_RESULT(sb_listener); } void SBDebugger::HandleProcessEvent(const SBProcess &process, const SBEvent &event, FILE *out, FILE *err) { + LLDB_RECORD_METHOD( + void, SBDebugger, HandleProcessEvent, + (const lldb::SBProcess &, const lldb::SBEvent &, FILE *, FILE *), process, + event, out, err); + if (!process.IsValid()) return; @@ -494,11 +571,17 @@ void SBDebugger::HandleProcessEvent(const SBProcess &process, } SBSourceManager SBDebugger::GetSourceManager() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSourceManager, SBDebugger, + GetSourceManager); + SBSourceManager sb_source_manager(*this); - return sb_source_manager; + return LLDB_RECORD_RESULT(sb_source_manager); } bool SBDebugger::GetDefaultArchitecture(char *arch_name, size_t arch_name_len) { + LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, GetDefaultArchitecture, + (char *, size_t), "", arch_name_len); + if (arch_name && arch_name_len) { ArchSpec default_arch = Target::GetDefaultArchitecture(); @@ -518,6 +601,9 @@ bool SBDebugger::GetDefaultArchitecture(char *arch_name, size_t arch_name_len) { } bool SBDebugger::SetDefaultArchitecture(const char *arch_name) { + LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, SetDefaultArchitecture, + (const char *), arch_name); + if (arch_name) { ArchSpec arch(arch_name); if (arch.IsValid()) { @@ -530,16 +616,24 @@ bool SBDebugger::SetDefaultArchitecture(const char *arch_name) { ScriptLanguage SBDebugger::GetScriptingLanguage(const char *script_language_name) { + LLDB_RECORD_METHOD(lldb::ScriptLanguage, SBDebugger, GetScriptingLanguage, + (const char *), script_language_name); + if (!script_language_name) return eScriptLanguageDefault; return OptionArgParser::ToScriptLanguage( llvm::StringRef(script_language_name), eScriptLanguageDefault, nullptr); } const char *SBDebugger::GetVersionString() { + LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBDebugger, GetVersionString); + return lldb_private::GetVersion(); } const char *SBDebugger::StateAsCString(StateType state) { + LLDB_RECORD_STATIC_METHOD(const char *, SBDebugger, StateAsCString, + (lldb::StateType), state); + return lldb_private::StateAsCString(state); } @@ -564,6 +658,9 @@ static void AddLLVMTargets(StructuredData::Dictionary &dict) { } SBStructuredData SBDebugger::GetBuildConfiguration() { + LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBStructuredData, SBDebugger, + GetBuildConfiguration); + auto config_up = llvm::make_unique<StructuredData::Dictionary>(); AddBoolConfigEntry( *config_up, "xml", XMLDocument::XMLEnabled(), @@ -572,10 +669,13 @@ SBStructuredData SBDebugger::GetBuildConfiguration() { SBStructuredData data; data.m_impl_up->SetObjectSP(std::move(config_up)); - return data; + return LLDB_RECORD_RESULT(data); } bool SBDebugger::StateIsRunningState(StateType state) { + LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, StateIsRunningState, + (lldb::StateType), state); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); const bool result = lldb_private::StateIsRunningState(state); @@ -587,6 +687,9 @@ bool SBDebugger::StateIsRunningState(StateType state) { } bool SBDebugger::StateIsStoppedState(StateType state) { + LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, StateIsStoppedState, + (lldb::StateType), state); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); const bool result = lldb_private::StateIsStoppedState(state, false); @@ -602,6 +705,11 @@ lldb::SBTarget SBDebugger::CreateTarget(const char *filename, const char *platform_name, bool add_dependent_modules, lldb::SBError &sb_error) { + LLDB_RECORD_METHOD( + lldb::SBTarget, SBDebugger, CreateTarget, + (const char *, const char *, const char *, bool, lldb::SBError &), + filename, target_triple, platform_name, add_dependent_modules, sb_error); + SBTarget sb_target; TargetSP target_sp; if (m_opaque_sp) { @@ -629,12 +737,16 @@ lldb::SBTarget SBDebugger::CreateTarget(const char *filename, platform_name, add_dependent_modules, sb_error.GetCString(), static_cast<void *>(target_sp.get())); - return sb_target; + return LLDB_RECORD_RESULT(sb_target); } SBTarget SBDebugger::CreateTargetWithFileAndTargetTriple(const char *filename, const char *target_triple) { + LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, + CreateTargetWithFileAndTargetTriple, + (const char *, const char *), filename, target_triple); + SBTarget sb_target; TargetSP target_sp; if (m_opaque_sp) { @@ -653,11 +765,14 @@ SBDebugger::CreateTargetWithFileAndTargetTriple(const char *filename, static_cast<void *>(m_opaque_sp.get()), filename, target_triple, static_cast<void *>(target_sp.get())); - return sb_target; + return LLDB_RECORD_RESULT(sb_target); } SBTarget SBDebugger::CreateTargetWithFileAndArch(const char *filename, const char *arch_cstr) { + LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, CreateTargetWithFileAndArch, + (const char *, const char *), filename, arch_cstr); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBTarget sb_target; @@ -683,10 +798,13 @@ SBTarget SBDebugger::CreateTargetWithFileAndArch(const char *filename, static_cast<void *>(m_opaque_sp.get()), filename, arch_cstr, static_cast<void *>(target_sp.get())); - return sb_target; + return LLDB_RECORD_RESULT(sb_target); } SBTarget SBDebugger::CreateTarget(const char *filename) { + LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, CreateTarget, (const char *), + filename); + SBTarget sb_target; TargetSP target_sp; if (m_opaque_sp) { @@ -708,10 +826,12 @@ SBTarget SBDebugger::CreateTarget(const char *filename) { "SBDebugger(%p)::CreateTarget (filename=\"%s\") => SBTarget(%p)", static_cast<void *>(m_opaque_sp.get()), filename, static_cast<void *>(target_sp.get())); - return sb_target; + return LLDB_RECORD_RESULT(sb_target); } SBTarget SBDebugger::GetDummyTarget() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBDebugger, GetDummyTarget); + SBTarget sb_target; if (m_opaque_sp) { sb_target.SetSP(m_opaque_sp->GetDummyTarget()->shared_from_this()); @@ -722,10 +842,13 @@ SBTarget SBDebugger::GetDummyTarget() { "SBDebugger(%p)::GetDummyTarget() => SBTarget(%p)", static_cast<void *>(m_opaque_sp.get()), static_cast<void *>(sb_target.GetSP().get())); - return sb_target; + return LLDB_RECORD_RESULT(sb_target); } bool SBDebugger::DeleteTarget(lldb::SBTarget &target) { + LLDB_RECORD_METHOD(bool, SBDebugger, DeleteTarget, (lldb::SBTarget &), + target); + bool result = false; if (m_opaque_sp) { TargetSP target_sp(target.GetSP()); @@ -749,15 +872,20 @@ bool SBDebugger::DeleteTarget(lldb::SBTarget &target) { } SBTarget SBDebugger::GetTargetAtIndex(uint32_t idx) { + LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, GetTargetAtIndex, (uint32_t), + idx); + SBTarget sb_target; if (m_opaque_sp) { // No need to lock, the target list is thread safe sb_target.SetSP(m_opaque_sp->GetTargetList().GetTargetAtIndex(idx)); } - return sb_target; + return LLDB_RECORD_RESULT(sb_target); } uint32_t SBDebugger::GetIndexOfTarget(lldb::SBTarget target) { + LLDB_RECORD_METHOD(uint32_t, SBDebugger, GetIndexOfTarget, (lldb::SBTarget), + target); lldb::TargetSP target_sp = target.GetSP(); if (!target_sp) @@ -770,16 +898,22 @@ uint32_t SBDebugger::GetIndexOfTarget(lldb::SBTarget target) { } SBTarget SBDebugger::FindTargetWithProcessID(lldb::pid_t pid) { + LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithProcessID, + (lldb::pid_t), pid); + SBTarget sb_target; if (m_opaque_sp) { // No need to lock, the target list is thread safe sb_target.SetSP(m_opaque_sp->GetTargetList().FindTargetWithProcessID(pid)); } - return sb_target; + return LLDB_RECORD_RESULT(sb_target); } SBTarget SBDebugger::FindTargetWithFileAndArch(const char *filename, const char *arch_name) { + LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithFileAndArch, + (const char *, const char *), filename, arch_name); + SBTarget sb_target; if (m_opaque_sp && filename && filename[0]) { // No need to lock, the target list is thread safe @@ -790,7 +924,7 @@ SBTarget SBDebugger::FindTargetWithFileAndArch(const char *filename, FileSpec(filename), arch_name ? &arch : nullptr)); sb_target.SetSP(target_sp); } - return sb_target; + return LLDB_RECORD_RESULT(sb_target); } SBTarget SBDebugger::FindTargetWithLLDBProcess(const ProcessSP &process_sp) { @@ -804,6 +938,8 @@ SBTarget SBDebugger::FindTargetWithLLDBProcess(const ProcessSP &process_sp) { } uint32_t SBDebugger::GetNumTargets() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumTargets); + if (m_opaque_sp) { // No need to lock, the target list is thread safe return m_opaque_sp->GetTargetList().GetNumTargets(); @@ -812,6 +948,8 @@ uint32_t SBDebugger::GetNumTargets() { } SBTarget SBDebugger::GetSelectedTarget() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBDebugger, GetSelectedTarget); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBTarget sb_target; @@ -830,10 +968,13 @@ SBTarget SBDebugger::GetSelectedTarget() { static_cast<void *>(target_sp.get()), sstr.GetData()); } - return sb_target; + return LLDB_RECORD_RESULT(sb_target); } void SBDebugger::SetSelectedTarget(SBTarget &sb_target) { + LLDB_RECORD_METHOD(void, SBDebugger, SetSelectedTarget, (lldb::SBTarget &), + sb_target); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); TargetSP target_sp(sb_target.GetSP()); @@ -850,6 +991,8 @@ void SBDebugger::SetSelectedTarget(SBTarget &sb_target) { } SBPlatform SBDebugger::GetSelectedPlatform() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBPlatform, SBDebugger, GetSelectedPlatform); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBPlatform sb_platform; @@ -862,10 +1005,13 @@ SBPlatform SBDebugger::GetSelectedPlatform() { static_cast<void *>(m_opaque_sp.get()), static_cast<void *>(sb_platform.GetSP().get()), sb_platform.GetName()); - return sb_platform; + return LLDB_RECORD_RESULT(sb_platform); } void SBDebugger::SetSelectedPlatform(SBPlatform &sb_platform) { + LLDB_RECORD_METHOD(void, SBDebugger, SetSelectedPlatform, + (lldb::SBPlatform &), sb_platform); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); DebuggerSP debugger_sp(m_opaque_sp); @@ -881,6 +1027,8 @@ void SBDebugger::SetSelectedPlatform(SBPlatform &sb_platform) { } uint32_t SBDebugger::GetNumPlatforms() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumPlatforms); + if (m_opaque_sp) { // No need to lock, the platform list is thread safe return m_opaque_sp->GetPlatformList().GetSize(); @@ -889,15 +1037,20 @@ uint32_t SBDebugger::GetNumPlatforms() { } SBPlatform SBDebugger::GetPlatformAtIndex(uint32_t idx) { + LLDB_RECORD_METHOD(lldb::SBPlatform, SBDebugger, GetPlatformAtIndex, + (uint32_t), idx); + SBPlatform sb_platform; if (m_opaque_sp) { // No need to lock, the platform list is thread safe sb_platform.SetSP(m_opaque_sp->GetPlatformList().GetAtIndex(idx)); } - return sb_platform; + return LLDB_RECORD_RESULT(sb_platform); } uint32_t SBDebugger::GetNumAvailablePlatforms() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumAvailablePlatforms); + uint32_t idx = 0; while (true) { if (!PluginManager::GetPlatformPluginNameAtIndex(idx)) { @@ -910,6 +1063,9 @@ uint32_t SBDebugger::GetNumAvailablePlatforms() { } SBStructuredData SBDebugger::GetAvailablePlatformInfoAtIndex(uint32_t idx) { + LLDB_RECORD_METHOD(lldb::SBStructuredData, SBDebugger, + GetAvailablePlatformInfoAtIndex, (uint32_t), idx); + SBStructuredData data; auto platform_dict = llvm::make_unique<StructuredData::Dictionary>(); llvm::StringRef name_str("name"), desc_str("description"); @@ -924,21 +1080,21 @@ SBStructuredData SBDebugger::GetAvailablePlatformInfoAtIndex(uint32_t idx) { const char *plugin_name = PluginManager::GetPlatformPluginNameAtIndex(idx - 1); if (!plugin_name) { - return data; + return LLDB_RECORD_RESULT(data); } platform_dict->AddStringItem(name_str, llvm::StringRef(plugin_name)); const char *plugin_desc = PluginManager::GetPlatformPluginDescriptionAtIndex(idx - 1); if (!plugin_desc) { - return data; + return LLDB_RECORD_RESULT(data); } platform_dict->AddStringItem(desc_str, llvm::StringRef(plugin_desc)); } data.m_impl_up->SetObjectSP( StructuredData::ObjectSP(platform_dict.release())); - return data; + return LLDB_RECORD_RESULT(data); } void SBDebugger::DispatchInput(void *baton, const void *data, size_t data_len) { @@ -961,19 +1117,29 @@ void SBDebugger::DispatchInput(const void *data, size_t data_len) { } void SBDebugger::DispatchInputInterrupt() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, DispatchInputInterrupt); + if (m_opaque_sp) m_opaque_sp->DispatchInputInterrupt(); } void SBDebugger::DispatchInputEndOfFile() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, DispatchInputEndOfFile); + if (m_opaque_sp) m_opaque_sp->DispatchInputEndOfFile(); } -void SBDebugger::PushInputReader(SBInputReader &reader) {} +void SBDebugger::PushInputReader(SBInputReader &reader) { + LLDB_RECORD_METHOD(void, SBDebugger, PushInputReader, (lldb::SBInputReader &), + reader); +} void SBDebugger::RunCommandInterpreter(bool auto_handle_events, bool spawn_thread) { + LLDB_RECORD_METHOD(void, SBDebugger, RunCommandInterpreter, (bool, bool), + auto_handle_events, spawn_thread); + if (m_opaque_sp) { CommandInterpreterRunOptions options; @@ -989,6 +1155,12 @@ void SBDebugger::RunCommandInterpreter(bool auto_handle_events, bool &stopped_for_crash) { + LLDB_RECORD_METHOD(void, SBDebugger, RunCommandInterpreter, + (bool, bool, lldb::SBCommandInterpreterRunOptions &, int &, + bool &, bool &), + auto_handle_events, spawn_thread, options, num_errors, + quit_requested, stopped_for_crash); + if (m_opaque_sp) { CommandInterpreter &interp = m_opaque_sp->GetCommandInterpreter(); interp.RunCommandInterpreter(auto_handle_events, spawn_thread, @@ -1001,12 +1173,16 @@ void SBDebugger::RunCommandInterpreter(bool auto_handle_events, SBError SBDebugger::RunREPL(lldb::LanguageType language, const char *repl_options) { + LLDB_RECORD_METHOD(lldb::SBError, SBDebugger, RunREPL, + (lldb::LanguageType, const char *), language, + repl_options); + SBError error; if (m_opaque_sp) error.ref() = m_opaque_sp->RunREPL(language, repl_options); else error.SetErrorString("invalid debugger"); - return error; + return LLDB_RECORD_RESULT(error); } void SBDebugger::reset(const DebuggerSP &debugger_sp) { @@ -1023,20 +1199,29 @@ Debugger &SBDebugger::ref() const { const lldb::DebuggerSP &SBDebugger::get_sp() const { return m_opaque_sp; } SBDebugger SBDebugger::FindDebuggerWithID(int id) { + LLDB_RECORD_STATIC_METHOD(lldb::SBDebugger, SBDebugger, FindDebuggerWithID, + (int), id); + // No need to lock, the debugger list is thread safe SBDebugger sb_debugger; DebuggerSP debugger_sp = Debugger::FindDebuggerWithID(id); if (debugger_sp) sb_debugger.reset(debugger_sp); - return sb_debugger; + return LLDB_RECORD_RESULT(sb_debugger); } const char *SBDebugger::GetInstanceName() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBDebugger, GetInstanceName); + return (m_opaque_sp ? m_opaque_sp->GetInstanceName().AsCString() : nullptr); } SBError SBDebugger::SetInternalVariable(const char *var_name, const char *value, const char *debugger_instance_name) { + LLDB_RECORD_STATIC_METHOD(lldb::SBError, SBDebugger, SetInternalVariable, + (const char *, const char *, const char *), + var_name, value, debugger_instance_name); + SBError sb_error; DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName( ConstString(debugger_instance_name))); @@ -1052,12 +1237,16 @@ SBError SBDebugger::SetInternalVariable(const char *var_name, const char *value, } if (error.Fail()) sb_error.SetError(error); - return sb_error; + return LLDB_RECORD_RESULT(sb_error); } SBStringList SBDebugger::GetInternalVariableValue(const char *var_name, const char *debugger_instance_name) { + LLDB_RECORD_STATIC_METHOD( + lldb::SBStringList, SBDebugger, GetInternalVariableValue, + (const char *, const char *), var_name, debugger_instance_name); + SBStringList ret_value; DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName( ConstString(debugger_instance_name))); @@ -1074,23 +1263,30 @@ SBDebugger::GetInternalVariableValue(const char *var_name, if (!value_str.empty()) { StringList string_list; string_list.SplitIntoLines(value_str); - return SBStringList(&string_list); + return LLDB_RECORD_RESULT(SBStringList(&string_list)); } } } - return SBStringList(); + return LLDB_RECORD_RESULT(SBStringList()); } uint32_t SBDebugger::GetTerminalWidth() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBDebugger, GetTerminalWidth); + return (m_opaque_sp ? m_opaque_sp->GetTerminalWidth() : 0); } void SBDebugger::SetTerminalWidth(uint32_t term_width) { + LLDB_RECORD_METHOD(void, SBDebugger, SetTerminalWidth, (uint32_t), + term_width); + if (m_opaque_sp) m_opaque_sp->SetTerminalWidth(term_width); } const char *SBDebugger::GetPrompt() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBDebugger, GetPrompt); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) @@ -1103,43 +1299,64 @@ const char *SBDebugger::GetPrompt() const { } void SBDebugger::SetPrompt(const char *prompt) { + LLDB_RECORD_METHOD(void, SBDebugger, SetPrompt, (const char *), prompt); + if (m_opaque_sp) m_opaque_sp->SetPrompt(llvm::StringRef::withNullAsEmpty(prompt)); } const char *SBDebugger::GetReproducerPath() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBDebugger, GetReproducerPath); + return (m_opaque_sp ? ConstString(m_opaque_sp->GetReproducerPath()).GetCString() : nullptr); } ScriptLanguage SBDebugger::GetScriptLanguage() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ScriptLanguage, SBDebugger, + GetScriptLanguage); + return (m_opaque_sp ? m_opaque_sp->GetScriptLanguage() : eScriptLanguageNone); } void SBDebugger::SetScriptLanguage(ScriptLanguage script_lang) { + LLDB_RECORD_METHOD(void, SBDebugger, SetScriptLanguage, + (lldb::ScriptLanguage), script_lang); + if (m_opaque_sp) { m_opaque_sp->SetScriptLanguage(script_lang); } } bool SBDebugger::SetUseExternalEditor(bool value) { + LLDB_RECORD_METHOD(bool, SBDebugger, SetUseExternalEditor, (bool), value); + return (m_opaque_sp ? m_opaque_sp->SetUseExternalEditor(value) : false); } bool SBDebugger::GetUseExternalEditor() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBDebugger, GetUseExternalEditor); + return (m_opaque_sp ? m_opaque_sp->GetUseExternalEditor() : false); } bool SBDebugger::SetUseColor(bool value) { + LLDB_RECORD_METHOD(bool, SBDebugger, SetUseColor, (bool), value); + return (m_opaque_sp ? m_opaque_sp->SetUseColor(value) : false); } bool SBDebugger::GetUseColor() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetUseColor); + return (m_opaque_sp ? m_opaque_sp->GetUseColor() : false); } bool SBDebugger::GetDescription(SBStream &description) { + LLDB_RECORD_METHOD(bool, SBDebugger, GetDescription, (lldb::SBStream &), + description); + Stream &strm = description.ref(); if (m_opaque_sp) { @@ -1153,10 +1370,15 @@ bool SBDebugger::GetDescription(SBStream &description) { } user_id_t SBDebugger::GetID() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::user_id_t, SBDebugger, GetID); + return (m_opaque_sp ? m_opaque_sp->GetID() : LLDB_INVALID_UID); } SBError SBDebugger::SetCurrentPlatform(const char *platform_name_cstr) { + LLDB_RECORD_METHOD(lldb::SBError, SBDebugger, SetCurrentPlatform, + (const char *), platform_name_cstr); + SBError sb_error; if (m_opaque_sp) { if (platform_name_cstr && platform_name_cstr[0]) { @@ -1181,10 +1403,13 @@ SBError SBDebugger::SetCurrentPlatform(const char *platform_name_cstr) { } else { sb_error.ref().SetErrorString("invalid debugger"); } - return sb_error; + return LLDB_RECORD_RESULT(sb_error); } bool SBDebugger::SetCurrentPlatformSDKRoot(const char *sysroot) { + LLDB_RECORD_METHOD(bool, SBDebugger, SetCurrentPlatformSDKRoot, + (const char *), sysroot); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (m_opaque_sp) { PlatformSP platform_sp( @@ -1201,49 +1426,68 @@ bool SBDebugger::SetCurrentPlatformSDKRoot(const char *sysroot) { } bool SBDebugger::GetCloseInputOnEOF() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetCloseInputOnEOF); + return (m_opaque_sp ? m_opaque_sp->GetCloseInputOnEOF() : false); } void SBDebugger::SetCloseInputOnEOF(bool b) { + LLDB_RECORD_METHOD(void, SBDebugger, SetCloseInputOnEOF, (bool), b); + if (m_opaque_sp) m_opaque_sp->SetCloseInputOnEOF(b); } SBTypeCategory SBDebugger::GetCategory(const char *category_name) { + LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory, + (const char *), category_name); + if (!category_name || *category_name == 0) - return SBTypeCategory(); + return LLDB_RECORD_RESULT(SBTypeCategory()); TypeCategoryImplSP category_sp; if (DataVisualization::Categories::GetCategory(ConstString(category_name), - category_sp, false)) - return SBTypeCategory(category_sp); - else - return SBTypeCategory(); + category_sp, false)) { + return LLDB_RECORD_RESULT(SBTypeCategory(category_sp)); + } else { + return LLDB_RECORD_RESULT(SBTypeCategory()); + } } SBTypeCategory SBDebugger::GetCategory(lldb::LanguageType lang_type) { + LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory, + (lldb::LanguageType), lang_type); + TypeCategoryImplSP category_sp; - if (DataVisualization::Categories::GetCategory(lang_type, category_sp)) - return SBTypeCategory(category_sp); - else - return SBTypeCategory(); + if (DataVisualization::Categories::GetCategory(lang_type, category_sp)) { + return LLDB_RECORD_RESULT(SBTypeCategory(category_sp)); + } else { + return LLDB_RECORD_RESULT(SBTypeCategory()); + } } SBTypeCategory SBDebugger::CreateCategory(const char *category_name) { + LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, CreateCategory, + (const char *), category_name); + if (!category_name || *category_name == 0) - return SBTypeCategory(); + return LLDB_RECORD_RESULT(SBTypeCategory()); TypeCategoryImplSP category_sp; if (DataVisualization::Categories::GetCategory(ConstString(category_name), - category_sp, true)) - return SBTypeCategory(category_sp); - else - return SBTypeCategory(); + category_sp, true)) { + return LLDB_RECORD_RESULT(SBTypeCategory(category_sp)); + } else { + return LLDB_RECORD_RESULT(SBTypeCategory()); + } } bool SBDebugger::DeleteCategory(const char *category_name) { + LLDB_RECORD_METHOD(bool, SBDebugger, DeleteCategory, (const char *), + category_name); + if (!category_name || *category_name == 0) return false; @@ -1251,45 +1495,67 @@ bool SBDebugger::DeleteCategory(const char *category_name) { } uint32_t SBDebugger::GetNumCategories() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumCategories); + return DataVisualization::Categories::GetCount(); } SBTypeCategory SBDebugger::GetCategoryAtIndex(uint32_t index) { - return SBTypeCategory( - DataVisualization::Categories::GetCategoryAtIndex(index)); + LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategoryAtIndex, + (uint32_t), index); + + return LLDB_RECORD_RESULT( + SBTypeCategory(DataVisualization::Categories::GetCategoryAtIndex(index))); } SBTypeCategory SBDebugger::GetDefaultCategory() { - return GetCategory("default"); + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeCategory, SBDebugger, + GetDefaultCategory); + + return LLDB_RECORD_RESULT(GetCategory("default")); } SBTypeFormat SBDebugger::GetFormatForType(SBTypeNameSpecifier type_name) { + LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBDebugger, GetFormatForType, + (lldb::SBTypeNameSpecifier), type_name); + SBTypeCategory default_category_sb = GetDefaultCategory(); if (default_category_sb.GetEnabled()) - return default_category_sb.GetFormatForType(type_name); - return SBTypeFormat(); + return LLDB_RECORD_RESULT(default_category_sb.GetFormatForType(type_name)); + return LLDB_RECORD_RESULT(SBTypeFormat()); } #ifndef LLDB_DISABLE_PYTHON SBTypeSummary SBDebugger::GetSummaryForType(SBTypeNameSpecifier type_name) { + LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBDebugger, GetSummaryForType, + (lldb::SBTypeNameSpecifier), type_name); + if (!type_name.IsValid()) - return SBTypeSummary(); - return SBTypeSummary(DataVisualization::GetSummaryForType(type_name.GetSP())); + return LLDB_RECORD_RESULT(SBTypeSummary()); + return LLDB_RECORD_RESULT( + SBTypeSummary(DataVisualization::GetSummaryForType(type_name.GetSP()))); } #endif // LLDB_DISABLE_PYTHON SBTypeFilter SBDebugger::GetFilterForType(SBTypeNameSpecifier type_name) { + LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBDebugger, GetFilterForType, + (lldb::SBTypeNameSpecifier), type_name); + if (!type_name.IsValid()) - return SBTypeFilter(); - return SBTypeFilter(DataVisualization::GetFilterForType(type_name.GetSP())); + return LLDB_RECORD_RESULT(SBTypeFilter()); + return LLDB_RECORD_RESULT( + SBTypeFilter(DataVisualization::GetFilterForType(type_name.GetSP()))); } #ifndef LLDB_DISABLE_PYTHON SBTypeSynthetic SBDebugger::GetSyntheticForType(SBTypeNameSpecifier type_name) { + LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBDebugger, GetSyntheticForType, + (lldb::SBTypeNameSpecifier), type_name); + if (!type_name.IsValid()) - return SBTypeSynthetic(); - return SBTypeSynthetic( - DataVisualization::GetSyntheticForType(type_name.GetSP())); + return LLDB_RECORD_RESULT(SBTypeSynthetic()); + return LLDB_RECORD_RESULT(SBTypeSynthetic( + DataVisualization::GetSyntheticForType(type_name.GetSP()))); } #endif // LLDB_DISABLE_PYTHON @@ -1303,6 +1569,9 @@ static llvm::ArrayRef<const char *> GetCategoryArray(const char **categories) { } bool SBDebugger::EnableLog(const char *channel, const char **categories) { + LLDB_RECORD_METHOD(bool, SBDebugger, EnableLog, (const char *, const char **), + channel, categories); + if (m_opaque_sp) { uint32_t log_options = LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME; diff --git a/lldb/source/API/SBDeclaration.cpp b/lldb/source/API/SBDeclaration.cpp index bec3791b506..971f46e3456 100644 --- a/lldb/source/API/SBDeclaration.cpp +++ b/lldb/source/API/SBDeclaration.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBDeclaration.h" +#include "SBReproducerPrivate.h" #include "Utils.h" #include "lldb/API/SBStream.h" #include "lldb/Host/PosixApi.h" @@ -19,9 +20,13 @@ using namespace lldb; using namespace lldb_private; -SBDeclaration::SBDeclaration() : m_opaque_up() {} +SBDeclaration::SBDeclaration() : m_opaque_up() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBDeclaration); +} SBDeclaration::SBDeclaration(const SBDeclaration &rhs) : m_opaque_up() { + LLDB_RECORD_CONSTRUCTOR(SBDeclaration, (const lldb::SBDeclaration &), rhs); + m_opaque_up = clone(rhs.m_opaque_up); } @@ -32,6 +37,10 @@ SBDeclaration::SBDeclaration(const lldb_private::Declaration *lldb_object_ptr) } const SBDeclaration &SBDeclaration::operator=(const SBDeclaration &rhs) { + LLDB_RECORD_METHOD(const lldb::SBDeclaration &, + SBDeclaration, operator=,(const lldb::SBDeclaration &), + rhs); + if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); return *this; @@ -45,10 +54,15 @@ void SBDeclaration::SetDeclaration( SBDeclaration::~SBDeclaration() {} bool SBDeclaration::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDeclaration, IsValid); + return m_opaque_up.get() && m_opaque_up->IsValid(); } SBFileSpec SBDeclaration::GetFileSpec() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBDeclaration, + GetFileSpec); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBFileSpec sb_file_spec; @@ -63,10 +77,12 @@ SBFileSpec SBDeclaration::GetFileSpec() const { static_cast<const void *>(sb_file_spec.get()), sstr.GetData()); } - return sb_file_spec; + return LLDB_RECORD_RESULT(sb_file_spec); } uint32_t SBDeclaration::GetLine() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBDeclaration, GetLine); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); uint32_t line = 0; @@ -81,22 +97,38 @@ uint32_t SBDeclaration::GetLine() const { } uint32_t SBDeclaration::GetColumn() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBDeclaration, GetColumn); + if (m_opaque_up) return m_opaque_up->GetColumn(); return 0; } void SBDeclaration::SetFileSpec(lldb::SBFileSpec filespec) { + LLDB_RECORD_METHOD(void, SBDeclaration, SetFileSpec, (lldb::SBFileSpec), + filespec); + if (filespec.IsValid()) ref().SetFile(filespec.ref()); else ref().SetFile(FileSpec()); } -void SBDeclaration::SetLine(uint32_t line) { ref().SetLine(line); } +void SBDeclaration::SetLine(uint32_t line) { + LLDB_RECORD_METHOD(void, SBDeclaration, SetLine, (uint32_t), line); -void SBDeclaration::SetColumn(uint32_t column) { ref().SetColumn(column); } + ref().SetLine(line); +} + +void SBDeclaration::SetColumn(uint32_t column) { + LLDB_RECORD_METHOD(void, SBDeclaration, SetColumn, (uint32_t), column); + + ref().SetColumn(column); +} bool SBDeclaration::operator==(const SBDeclaration &rhs) const { + LLDB_RECORD_METHOD_CONST( + bool, SBDeclaration, operator==,(const lldb::SBDeclaration &), rhs); + lldb_private::Declaration *lhs_ptr = m_opaque_up.get(); lldb_private::Declaration *rhs_ptr = rhs.m_opaque_up.get(); @@ -107,6 +139,9 @@ bool SBDeclaration::operator==(const SBDeclaration &rhs) const { } bool SBDeclaration::operator!=(const SBDeclaration &rhs) const { + LLDB_RECORD_METHOD_CONST( + bool, SBDeclaration, operator!=,(const lldb::SBDeclaration &), rhs); + lldb_private::Declaration *lhs_ptr = m_opaque_up.get(); lldb_private::Declaration *rhs_ptr = rhs.m_opaque_up.get(); @@ -131,6 +166,9 @@ const lldb_private::Declaration &SBDeclaration::ref() const { } bool SBDeclaration::GetDescription(SBStream &description) { + LLDB_RECORD_METHOD(bool, SBDeclaration, GetDescription, (lldb::SBStream &), + description); + Stream &strm = description.ref(); if (m_opaque_up) { diff --git a/lldb/source/API/SBError.cpp b/lldb/source/API/SBError.cpp index 1b026f0c4b9..d60fa361b4f 100644 --- a/lldb/source/API/SBError.cpp +++ b/lldb/source/API/SBError.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBError.h" +#include "SBReproducerPrivate.h" #include "Utils.h" #include "lldb/API/SBStream.h" #include "lldb/Utility/Log.h" @@ -17,32 +18,43 @@ using namespace lldb; using namespace lldb_private; -SBError::SBError() : m_opaque_up() {} +SBError::SBError() : m_opaque_up() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBError); } SBError::SBError(const SBError &rhs) : m_opaque_up() { + LLDB_RECORD_CONSTRUCTOR(SBError, (const lldb::SBError &), rhs); + m_opaque_up = clone(rhs.m_opaque_up); } SBError::~SBError() {} const SBError &SBError::operator=(const SBError &rhs) { + LLDB_RECORD_METHOD(const lldb::SBError &, + SBError, operator=,(const lldb::SBError &), rhs); + if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); return *this; } const char *SBError::GetCString() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBError, GetCString); + if (m_opaque_up) return m_opaque_up->AsCString(); return NULL; } void SBError::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBError, Clear); + if (m_opaque_up) m_opaque_up->Clear(); } bool SBError::Fail() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, Fail); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); bool ret_value = false; @@ -57,6 +69,8 @@ bool SBError::Fail() const { } bool SBError::Success() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, Success); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); bool ret_value = true; if (m_opaque_up) @@ -70,6 +84,8 @@ bool SBError::Success() const { } uint32_t SBError::GetError() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBError, GetError); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); uint32_t err = 0; @@ -84,6 +100,8 @@ uint32_t SBError::GetError() const { } ErrorType SBError::GetType() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ErrorType, SBError, GetType); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); ErrorType err_type = eErrorTypeInvalid; if (m_opaque_up) @@ -97,6 +115,9 @@ ErrorType SBError::GetType() const { } void SBError::SetError(uint32_t err, ErrorType type) { + LLDB_RECORD_METHOD(void, SBError, SetError, (uint32_t, lldb::ErrorType), err, + type); + CreateIfNeeded(); m_opaque_up->SetError(err, type); } @@ -107,16 +128,22 @@ void SBError::SetError(const Status &lldb_error) { } void SBError::SetErrorToErrno() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBError, SetErrorToErrno); + CreateIfNeeded(); m_opaque_up->SetErrorToErrno(); } void SBError::SetErrorToGenericError() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBError, SetErrorToGenericError); + CreateIfNeeded(); m_opaque_up->SetErrorToErrno(); } void SBError::SetErrorString(const char *err_str) { + LLDB_RECORD_METHOD(void, SBError, SetErrorString, (const char *), err_str); + CreateIfNeeded(); m_opaque_up->SetErrorString(err_str); } @@ -130,7 +157,11 @@ int SBError::SetErrorStringWithFormat(const char *format, ...) { return num_chars; } -bool SBError::IsValid() const { return m_opaque_up != NULL; } +bool SBError::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, IsValid); + + return m_opaque_up != NULL; +} void SBError::CreateIfNeeded() { if (m_opaque_up == NULL) @@ -152,6 +183,9 @@ const lldb_private::Status &SBError::operator*() const { } bool SBError::GetDescription(SBStream &description) { + LLDB_RECORD_METHOD(bool, SBError, GetDescription, (lldb::SBStream &), + description); + if (m_opaque_up) { if (m_opaque_up->Success()) description.Printf("success"); diff --git a/lldb/source/API/SBEvent.cpp b/lldb/source/API/SBEvent.cpp index 2ea6c91523f..1d991c3eb65 100644 --- a/lldb/source/API/SBEvent.cpp +++ b/lldb/source/API/SBEvent.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBEvent.h" +#include "SBReproducerPrivate.h" #include "lldb/API/SBBroadcaster.h" #include "lldb/API/SBStream.h" @@ -21,21 +22,35 @@ using namespace lldb; using namespace lldb_private; -SBEvent::SBEvent() : m_event_sp(), m_opaque_ptr(NULL) {} +SBEvent::SBEvent() : m_event_sp(), m_opaque_ptr(NULL) { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBEvent); +} SBEvent::SBEvent(uint32_t event_type, const char *cstr, uint32_t cstr_len) : m_event_sp(new Event(event_type, new EventDataBytes(cstr, cstr_len))), - m_opaque_ptr(m_event_sp.get()) {} + m_opaque_ptr(m_event_sp.get()) { + LLDB_RECORD_CONSTRUCTOR(SBEvent, (uint32_t, const char *, uint32_t), + event_type, cstr, cstr_len); +} SBEvent::SBEvent(EventSP &event_sp) - : m_event_sp(event_sp), m_opaque_ptr(event_sp.get()) {} + : m_event_sp(event_sp), m_opaque_ptr(event_sp.get()) { + LLDB_RECORD_CONSTRUCTOR(SBEvent, (lldb::EventSP &), event_sp); +} -SBEvent::SBEvent(Event *event_ptr) : m_event_sp(), m_opaque_ptr(event_ptr) {} +SBEvent::SBEvent(Event *event_ptr) : m_event_sp(), m_opaque_ptr(event_ptr) { + LLDB_RECORD_CONSTRUCTOR(SBEvent, (lldb_private::Event *), event_ptr); +} SBEvent::SBEvent(const SBEvent &rhs) - : m_event_sp(rhs.m_event_sp), m_opaque_ptr(rhs.m_opaque_ptr) {} + : m_event_sp(rhs.m_event_sp), m_opaque_ptr(rhs.m_opaque_ptr) { + LLDB_RECORD_CONSTRUCTOR(SBEvent, (const lldb::SBEvent &), rhs); +} const SBEvent &SBEvent::operator=(const SBEvent &rhs) { + LLDB_RECORD_METHOD(const lldb::SBEvent &, + SBEvent, operator=,(const lldb::SBEvent &), rhs); + if (this != &rhs) { m_event_sp = rhs.m_event_sp; m_opaque_ptr = rhs.m_opaque_ptr; @@ -46,6 +61,8 @@ const SBEvent &SBEvent::operator=(const SBEvent &rhs) { SBEvent::~SBEvent() {} const char *SBEvent::GetDataFlavor() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBEvent, GetDataFlavor); + Event *lldb_event = get(); if (lldb_event) { EventData *event_data = lldb_event->GetData(); @@ -56,6 +73,8 @@ const char *SBEvent::GetDataFlavor() { } uint32_t SBEvent::GetType() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBEvent, GetType); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); const Event *lldb_event = get(); @@ -78,14 +97,19 @@ uint32_t SBEvent::GetType() const { } SBBroadcaster SBEvent::GetBroadcaster() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBEvent, + GetBroadcaster); + SBBroadcaster broadcaster; const Event *lldb_event = get(); if (lldb_event) broadcaster.reset(lldb_event->GetBroadcaster(), false); - return broadcaster; + return LLDB_RECORD_RESULT(broadcaster); } const char *SBEvent::GetBroadcasterClass() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBEvent, GetBroadcasterClass); + const Event *lldb_event = get(); if (lldb_event) return lldb_event->GetBroadcaster()->GetBroadcasterClass().AsCString(); @@ -94,12 +118,17 @@ const char *SBEvent::GetBroadcasterClass() const { } bool SBEvent::BroadcasterMatchesPtr(const SBBroadcaster *broadcaster) { + LLDB_RECORD_METHOD(bool, SBEvent, BroadcasterMatchesPtr, + (const lldb::SBBroadcaster *), broadcaster); + if (broadcaster) return BroadcasterMatchesRef(*broadcaster); return false; } bool SBEvent::BroadcasterMatchesRef(const SBBroadcaster &broadcaster) { + LLDB_RECORD_METHOD(bool, SBEvent, BroadcasterMatchesRef, + (const lldb::SBBroadcaster &), broadcaster); Event *lldb_event = get(); bool success = false; @@ -116,6 +145,8 @@ bool SBEvent::BroadcasterMatchesRef(const SBBroadcaster &broadcaster) { } void SBEvent::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBEvent, Clear); + Event *lldb_event = get(); if (lldb_event) lldb_event->Clear(); @@ -145,12 +176,17 @@ void SBEvent::reset(Event *event_ptr) { } bool SBEvent::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBEvent, IsValid); + // Do NOT use m_opaque_ptr directly!!! Must use the SBEvent::get() accessor. // See comments in SBEvent::get().... return SBEvent::get() != NULL; } const char *SBEvent::GetCStringFromEvent(const SBEvent &event) { + LLDB_RECORD_STATIC_METHOD(const char *, SBEvent, GetCStringFromEvent, + (const lldb::SBEvent &), event); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) @@ -164,6 +200,9 @@ const char *SBEvent::GetCStringFromEvent(const SBEvent &event) { } bool SBEvent::GetDescription(SBStream &description) { + LLDB_RECORD_METHOD(bool, SBEvent, GetDescription, (lldb::SBStream &), + description); + Stream &strm = description.ref(); if (get()) { @@ -175,6 +214,9 @@ bool SBEvent::GetDescription(SBStream &description) { } bool SBEvent::GetDescription(SBStream &description) const { + LLDB_RECORD_METHOD_CONST(bool, SBEvent, GetDescription, (lldb::SBStream &), + description); + Stream &strm = description.ref(); if (get()) { diff --git a/lldb/source/API/SBExecutionContext.cpp b/lldb/source/API/SBExecutionContext.cpp index e2e04081a25..e1c6ed4dd68 100644 --- a/lldb/source/API/SBExecutionContext.cpp +++ b/lldb/source/API/SBExecutionContext.cpp @@ -8,6 +8,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBExecutionContext.h" +#include "SBReproducerPrivate.h" #include "lldb/API/SBFrame.h" #include "lldb/API/SBProcess.h" @@ -19,32 +20,49 @@ using namespace lldb; using namespace lldb_private; -SBExecutionContext::SBExecutionContext() : m_exe_ctx_sp() {} +SBExecutionContext::SBExecutionContext() : m_exe_ctx_sp() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBExecutionContext); +} SBExecutionContext::SBExecutionContext(const lldb::SBExecutionContext &rhs) - : m_exe_ctx_sp(rhs.m_exe_ctx_sp) {} + : m_exe_ctx_sp(rhs.m_exe_ctx_sp) { + LLDB_RECORD_CONSTRUCTOR(SBExecutionContext, + (const lldb::SBExecutionContext &), rhs); +} SBExecutionContext::SBExecutionContext( lldb::ExecutionContextRefSP exe_ctx_ref_sp) - : m_exe_ctx_sp(exe_ctx_ref_sp) {} + : m_exe_ctx_sp(exe_ctx_ref_sp) { + LLDB_RECORD_CONSTRUCTOR(SBExecutionContext, (lldb::ExecutionContextRefSP), + exe_ctx_ref_sp); +} SBExecutionContext::SBExecutionContext(const lldb::SBTarget &target) : m_exe_ctx_sp(new ExecutionContextRef()) { + LLDB_RECORD_CONSTRUCTOR(SBExecutionContext, (const lldb::SBTarget &), target); + m_exe_ctx_sp->SetTargetSP(target.GetSP()); } SBExecutionContext::SBExecutionContext(const lldb::SBProcess &process) : m_exe_ctx_sp(new ExecutionContextRef()) { + LLDB_RECORD_CONSTRUCTOR(SBExecutionContext, (const lldb::SBProcess &), + process); + m_exe_ctx_sp->SetProcessSP(process.GetSP()); } SBExecutionContext::SBExecutionContext(lldb::SBThread thread) : m_exe_ctx_sp(new ExecutionContextRef()) { + LLDB_RECORD_CONSTRUCTOR(SBExecutionContext, (lldb::SBThread), thread); + m_exe_ctx_sp->SetThreadPtr(thread.get()); } SBExecutionContext::SBExecutionContext(const lldb::SBFrame &frame) : m_exe_ctx_sp(new ExecutionContextRef()) { + LLDB_RECORD_CONSTRUCTOR(SBExecutionContext, (const lldb::SBFrame &), frame); + m_exe_ctx_sp->SetFrameSP(frame.GetFrameSP()); } @@ -52,6 +70,10 @@ SBExecutionContext::~SBExecutionContext() {} const SBExecutionContext &SBExecutionContext:: operator=(const lldb::SBExecutionContext &rhs) { + LLDB_RECORD_METHOD( + const lldb::SBExecutionContext &, + SBExecutionContext, operator=,(const lldb::SBExecutionContext &), rhs); + m_exe_ctx_sp = rhs.m_exe_ctx_sp; return *this; } @@ -61,41 +83,52 @@ ExecutionContextRef *SBExecutionContext::get() const { } SBTarget SBExecutionContext::GetTarget() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBTarget, SBExecutionContext, + GetTarget); + SBTarget sb_target; if (m_exe_ctx_sp) { TargetSP target_sp(m_exe_ctx_sp->GetTargetSP()); if (target_sp) sb_target.SetSP(target_sp); } - return sb_target; + return LLDB_RECORD_RESULT(sb_target); } SBProcess SBExecutionContext::GetProcess() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBProcess, SBExecutionContext, + GetProcess); + SBProcess sb_process; if (m_exe_ctx_sp) { ProcessSP process_sp(m_exe_ctx_sp->GetProcessSP()); if (process_sp) sb_process.SetSP(process_sp); } - return sb_process; + return LLDB_RECORD_RESULT(sb_process); } SBThread SBExecutionContext::GetThread() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBExecutionContext, + GetThread); + SBThread sb_thread; if (m_exe_ctx_sp) { ThreadSP thread_sp(m_exe_ctx_sp->GetThreadSP()); if (thread_sp) sb_thread.SetThread(thread_sp); } - return sb_thread; + return LLDB_RECORD_RESULT(sb_thread); } SBFrame SBExecutionContext::GetFrame() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFrame, SBExecutionContext, GetFrame); + SBFrame sb_frame; if (m_exe_ctx_sp) { StackFrameSP frame_sp(m_exe_ctx_sp->GetFrameSP()); if (frame_sp) sb_frame.SetFrameSP(frame_sp); } - return sb_frame; + return LLDB_RECORD_RESULT(sb_frame); } diff --git a/lldb/source/API/SBExpressionOptions.cpp b/lldb/source/API/SBExpressionOptions.cpp index b12ddc42604..cb2e43bba49 100644 --- a/lldb/source/API/SBExpressionOptions.cpp +++ b/lldb/source/API/SBExpressionOptions.cpp @@ -8,6 +8,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBExpressionOptions.h" +#include "SBReproducerPrivate.h" #include "Utils.h" #include "lldb/API/SBStream.h" #include "lldb/Target/Target.h" @@ -16,15 +17,24 @@ using namespace lldb; using namespace lldb_private; SBExpressionOptions::SBExpressionOptions() - : m_opaque_up(new EvaluateExpressionOptions()) {} + : m_opaque_up(new EvaluateExpressionOptions()) { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBExpressionOptions); +} SBExpressionOptions::SBExpressionOptions(const SBExpressionOptions &rhs) : m_opaque_up() { + LLDB_RECORD_CONSTRUCTOR(SBExpressionOptions, + (const lldb::SBExpressionOptions &), rhs); + m_opaque_up = clone(rhs.m_opaque_up); } const SBExpressionOptions &SBExpressionOptions:: operator=(const SBExpressionOptions &rhs) { + LLDB_RECORD_METHOD( + const lldb::SBExpressionOptions &, + SBExpressionOptions, operator=,(const lldb::SBExpressionOptions &), rhs); + if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); return *this; @@ -33,83 +43,137 @@ operator=(const SBExpressionOptions &rhs) { SBExpressionOptions::~SBExpressionOptions() {} bool SBExpressionOptions::GetCoerceResultToId() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, + GetCoerceResultToId); + return m_opaque_up->DoesCoerceToId(); } void SBExpressionOptions::SetCoerceResultToId(bool coerce) { + LLDB_RECORD_METHOD(void, SBExpressionOptions, SetCoerceResultToId, (bool), + coerce); + m_opaque_up->SetCoerceToId(coerce); } bool SBExpressionOptions::GetUnwindOnError() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, GetUnwindOnError); + return m_opaque_up->DoesUnwindOnError(); } void SBExpressionOptions::SetUnwindOnError(bool unwind) { + LLDB_RECORD_METHOD(void, SBExpressionOptions, SetUnwindOnError, (bool), + unwind); + m_opaque_up->SetUnwindOnError(unwind); } bool SBExpressionOptions::GetIgnoreBreakpoints() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, + GetIgnoreBreakpoints); + return m_opaque_up->DoesIgnoreBreakpoints(); } void SBExpressionOptions::SetIgnoreBreakpoints(bool ignore) { + LLDB_RECORD_METHOD(void, SBExpressionOptions, SetIgnoreBreakpoints, (bool), + ignore); + m_opaque_up->SetIgnoreBreakpoints(ignore); } lldb::DynamicValueType SBExpressionOptions::GetFetchDynamicValue() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::DynamicValueType, SBExpressionOptions, + GetFetchDynamicValue); + return m_opaque_up->GetUseDynamic(); } void SBExpressionOptions::SetFetchDynamicValue(lldb::DynamicValueType dynamic) { + LLDB_RECORD_METHOD(void, SBExpressionOptions, SetFetchDynamicValue, + (lldb::DynamicValueType), dynamic); + m_opaque_up->SetUseDynamic(dynamic); } uint32_t SBExpressionOptions::GetTimeoutInMicroSeconds() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBExpressionOptions, + GetTimeoutInMicroSeconds); + return m_opaque_up->GetTimeout() ? m_opaque_up->GetTimeout()->count() : 0; } void SBExpressionOptions::SetTimeoutInMicroSeconds(uint32_t timeout) { + LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTimeoutInMicroSeconds, + (uint32_t), timeout); + m_opaque_up->SetTimeout(timeout == 0 ? Timeout<std::micro>(llvm::None) : std::chrono::microseconds(timeout)); } uint32_t SBExpressionOptions::GetOneThreadTimeoutInMicroSeconds() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBExpressionOptions, + GetOneThreadTimeoutInMicroSeconds); + return m_opaque_up->GetOneThreadTimeout() ? m_opaque_up->GetOneThreadTimeout()->count() : 0; } void SBExpressionOptions::SetOneThreadTimeoutInMicroSeconds(uint32_t timeout) { + LLDB_RECORD_METHOD(void, SBExpressionOptions, + SetOneThreadTimeoutInMicroSeconds, (uint32_t), timeout); + m_opaque_up->SetOneThreadTimeout(timeout == 0 ? Timeout<std::micro>(llvm::None) : std::chrono::microseconds(timeout)); } bool SBExpressionOptions::GetTryAllThreads() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, GetTryAllThreads); + return m_opaque_up->GetTryAllThreads(); } void SBExpressionOptions::SetTryAllThreads(bool run_others) { + LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTryAllThreads, (bool), + run_others); + m_opaque_up->SetTryAllThreads(run_others); } bool SBExpressionOptions::GetStopOthers() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, GetStopOthers); + return m_opaque_up->GetStopOthers(); } void SBExpressionOptions::SetStopOthers(bool run_others) { + LLDB_RECORD_METHOD(void, SBExpressionOptions, SetStopOthers, (bool), + run_others); + m_opaque_up->SetStopOthers(run_others); } bool SBExpressionOptions::GetTrapExceptions() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, + GetTrapExceptions); + return m_opaque_up->GetTrapExceptions(); } void SBExpressionOptions::SetTrapExceptions(bool trap_exceptions) { + LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTrapExceptions, (bool), + trap_exceptions); + m_opaque_up->SetTrapExceptions(trap_exceptions); } void SBExpressionOptions::SetLanguage(lldb::LanguageType language) { + LLDB_RECORD_METHOD(void, SBExpressionOptions, SetLanguage, + (lldb::LanguageType), language); + m_opaque_up->SetLanguage(language); } @@ -119,51 +183,80 @@ void SBExpressionOptions::SetCancelCallback( } bool SBExpressionOptions::GetGenerateDebugInfo() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetGenerateDebugInfo); + return m_opaque_up->GetGenerateDebugInfo(); } void SBExpressionOptions::SetGenerateDebugInfo(bool b) { + LLDB_RECORD_METHOD(void, SBExpressionOptions, SetGenerateDebugInfo, (bool), + b); + return m_opaque_up->SetGenerateDebugInfo(b); } bool SBExpressionOptions::GetSuppressPersistentResult() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, + GetSuppressPersistentResult); + return m_opaque_up->GetResultIsInternal(); } void SBExpressionOptions::SetSuppressPersistentResult(bool b) { + LLDB_RECORD_METHOD(void, SBExpressionOptions, SetSuppressPersistentResult, + (bool), b); + return m_opaque_up->SetResultIsInternal(b); } const char *SBExpressionOptions::GetPrefix() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBExpressionOptions, + GetPrefix); + return m_opaque_up->GetPrefix(); } void SBExpressionOptions::SetPrefix(const char *prefix) { + LLDB_RECORD_METHOD(void, SBExpressionOptions, SetPrefix, (const char *), + prefix); + return m_opaque_up->SetPrefix(prefix); } bool SBExpressionOptions::GetAutoApplyFixIts() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetAutoApplyFixIts); + return m_opaque_up->GetAutoApplyFixIts(); } void SBExpressionOptions::SetAutoApplyFixIts(bool b) { + LLDB_RECORD_METHOD(void, SBExpressionOptions, SetAutoApplyFixIts, (bool), b); + return m_opaque_up->SetAutoApplyFixIts(b); } bool SBExpressionOptions::GetTopLevel() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetTopLevel); + return m_opaque_up->GetExecutionPolicy() == eExecutionPolicyTopLevel; } void SBExpressionOptions::SetTopLevel(bool b) { + LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTopLevel, (bool), b); + m_opaque_up->SetExecutionPolicy(b ? eExecutionPolicyTopLevel : m_opaque_up->default_execution_policy); } bool SBExpressionOptions::GetAllowJIT() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetAllowJIT); + return m_opaque_up->GetExecutionPolicy() != eExecutionPolicyNever; } void SBExpressionOptions::SetAllowJIT(bool allow) { + LLDB_RECORD_METHOD(void, SBExpressionOptions, SetAllowJIT, (bool), allow); + m_opaque_up->SetExecutionPolicy(allow ? m_opaque_up->default_execution_policy : eExecutionPolicyNever); } diff --git a/lldb/source/API/SBFileSpec.cpp b/lldb/source/API/SBFileSpec.cpp index 92b48aa01c1..1c2c993d31c 100644 --- a/lldb/source/API/SBFileSpec.cpp +++ b/lldb/source/API/SBFileSpec.cpp @@ -6,11 +6,9 @@ // //===----------------------------------------------------------------------===// -#include <inttypes.h> -#include <limits.h> - -#include "Utils.h" #include "lldb/API/SBFileSpec.h" +#include "SBReproducerPrivate.h" +#include "Utils.h" #include "lldb/API/SBStream.h" #include "lldb/Host/FileSystem.h" #include "lldb/Host/PosixApi.h" @@ -20,12 +18,19 @@ #include "llvm/ADT/SmallString.h" +#include <inttypes.h> +#include <limits.h> + using namespace lldb; using namespace lldb_private; -SBFileSpec::SBFileSpec() : m_opaque_up(new lldb_private::FileSpec()) {} +SBFileSpec::SBFileSpec() : m_opaque_up(new lldb_private::FileSpec()) { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFileSpec); +} SBFileSpec::SBFileSpec(const SBFileSpec &rhs) : m_opaque_up() { + LLDB_RECORD_CONSTRUCTOR(SBFileSpec, (const lldb::SBFileSpec &), rhs); + m_opaque_up = clone(rhs.m_opaque_up); } @@ -34,11 +39,15 @@ SBFileSpec::SBFileSpec(const lldb_private::FileSpec &fspec) // Deprecated!!! SBFileSpec::SBFileSpec(const char *path) : m_opaque_up(new FileSpec(path)) { + LLDB_RECORD_CONSTRUCTOR(SBFileSpec, (const char *), path); + FileSystem::Instance().Resolve(*m_opaque_up); } SBFileSpec::SBFileSpec(const char *path, bool resolve) : m_opaque_up(new FileSpec(path)) { + LLDB_RECORD_CONSTRUCTOR(SBFileSpec, (const char *, bool), path, resolve); + if (resolve) FileSystem::Instance().Resolve(*m_opaque_up); } @@ -46,14 +55,23 @@ SBFileSpec::SBFileSpec(const char *path, bool resolve) SBFileSpec::~SBFileSpec() {} const SBFileSpec &SBFileSpec::operator=(const SBFileSpec &rhs) { + LLDB_RECORD_METHOD(const lldb::SBFileSpec &, + SBFileSpec, operator=,(const lldb::SBFileSpec &), rhs); + if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); return *this; } -bool SBFileSpec::IsValid() const { return m_opaque_up->operator bool(); } +bool SBFileSpec::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFileSpec, IsValid); + + return m_opaque_up->operator bool(); +} bool SBFileSpec::Exists() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFileSpec, Exists); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); bool result = FileSystem::Instance().Exists(*m_opaque_up); @@ -67,11 +85,17 @@ bool SBFileSpec::Exists() const { } bool SBFileSpec::ResolveExecutableLocation() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBFileSpec, ResolveExecutableLocation); + return FileSystem::Instance().ResolveExecutableLocation(*m_opaque_up); } int SBFileSpec::ResolvePath(const char *src_path, char *dst_path, size_t dst_len) { + LLDB_RECORD_STATIC_METHOD(int, SBFileSpec, ResolvePath, + (const char *, char *, size_t), src_path, dst_path, + dst_len); + llvm::SmallString<64> result(src_path); FileSystem::Instance().Resolve(result); ::snprintf(dst_path, dst_len, "%s", result.c_str()); @@ -79,6 +103,8 @@ int SBFileSpec::ResolvePath(const char *src_path, char *dst_path, } const char *SBFileSpec::GetFilename() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFileSpec, GetFilename); + const char *s = m_opaque_up->GetFilename().AsCString(); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); @@ -95,6 +121,8 @@ const char *SBFileSpec::GetFilename() const { } const char *SBFileSpec::GetDirectory() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFileSpec, GetDirectory); + FileSpec directory{*m_opaque_up}; directory.GetFilename().Clear(); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); @@ -111,6 +139,8 @@ const char *SBFileSpec::GetDirectory() const { } void SBFileSpec::SetFilename(const char *filename) { + LLDB_RECORD_METHOD(void, SBFileSpec, SetFilename, (const char *), filename); + if (filename && filename[0]) m_opaque_up->GetFilename().SetCString(filename); else @@ -118,6 +148,8 @@ void SBFileSpec::SetFilename(const char *filename) { } void SBFileSpec::SetDirectory(const char *directory) { + LLDB_RECORD_METHOD(void, SBFileSpec, SetDirectory, (const char *), directory); + if (directory && directory[0]) m_opaque_up->GetDirectory().SetCString(directory); else @@ -125,6 +157,9 @@ void SBFileSpec::SetDirectory(const char *directory) { } uint32_t SBFileSpec::GetPath(char *dst_path, size_t dst_len) const { + LLDB_RECORD_METHOD_CONST(uint32_t, SBFileSpec, GetPath, (char *, size_t), + dst_path, dst_len); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); uint32_t result = m_opaque_up->GetPath(dst_path, dst_len); @@ -159,6 +194,9 @@ void SBFileSpec::SetFileSpec(const lldb_private::FileSpec &fs) { } bool SBFileSpec::GetDescription(SBStream &description) const { + LLDB_RECORD_METHOD_CONST(bool, SBFileSpec, GetDescription, (lldb::SBStream &), + description); + Stream &strm = description.ref(); char path[PATH_MAX]; if (m_opaque_up->GetPath(path, sizeof(path))) @@ -167,5 +205,7 @@ bool SBFileSpec::GetDescription(SBStream &description) const { } void SBFileSpec::AppendPathComponent(const char *fn) { + LLDB_RECORD_METHOD(void, SBFileSpec, AppendPathComponent, (const char *), fn); + m_opaque_up->AppendPathComponent(fn); } diff --git a/lldb/source/API/SBFileSpecList.cpp b/lldb/source/API/SBFileSpecList.cpp index d0b521c4b2f..a73a6df6187 100644 --- a/lldb/source/API/SBFileSpecList.cpp +++ b/lldb/source/API/SBFileSpecList.cpp @@ -6,11 +6,10 @@ // //===----------------------------------------------------------------------===// -#include <limits.h> - +#include "lldb/API/SBFileSpecList.h" +#include "SBReproducerPrivate.h" #include "Utils.h" #include "lldb/API/SBFileSpec.h" -#include "lldb/API/SBFileSpecList.h" #include "lldb/API/SBStream.h" #include "lldb/Core/FileSpecList.h" #include "lldb/Host/PosixApi.h" @@ -18,12 +17,18 @@ #include "lldb/Utility/Log.h" #include "lldb/Utility/Stream.h" +#include <limits.h> + using namespace lldb; using namespace lldb_private; -SBFileSpecList::SBFileSpecList() : m_opaque_up(new FileSpecList()) {} +SBFileSpecList::SBFileSpecList() : m_opaque_up(new FileSpecList()) { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFileSpecList); +} SBFileSpecList::SBFileSpecList(const SBFileSpecList &rhs) : m_opaque_up() { + LLDB_RECORD_CONSTRUCTOR(SBFileSpecList, (const lldb::SBFileSpecList &), rhs); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); m_opaque_up = clone(rhs.m_opaque_up); @@ -39,32 +44,57 @@ SBFileSpecList::SBFileSpecList(const SBFileSpecList &rhs) : m_opaque_up() { SBFileSpecList::~SBFileSpecList() {} const SBFileSpecList &SBFileSpecList::operator=(const SBFileSpecList &rhs) { + LLDB_RECORD_METHOD(const lldb::SBFileSpecList &, + SBFileSpecList, operator=,(const lldb::SBFileSpecList &), + rhs); + if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); return *this; } -uint32_t SBFileSpecList::GetSize() const { return m_opaque_up->GetSize(); } +uint32_t SBFileSpecList::GetSize() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBFileSpecList, GetSize); + + return m_opaque_up->GetSize(); +} void SBFileSpecList::Append(const SBFileSpec &sb_file) { + LLDB_RECORD_METHOD(void, SBFileSpecList, Append, (const lldb::SBFileSpec &), + sb_file); + m_opaque_up->Append(sb_file.ref()); } bool SBFileSpecList::AppendIfUnique(const SBFileSpec &sb_file) { + LLDB_RECORD_METHOD(bool, SBFileSpecList, AppendIfUnique, + (const lldb::SBFileSpec &), sb_file); + return m_opaque_up->AppendIfUnique(sb_file.ref()); } -void SBFileSpecList::Clear() { m_opaque_up->Clear(); } +void SBFileSpecList::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBFileSpecList, Clear); + + m_opaque_up->Clear(); +} uint32_t SBFileSpecList::FindFileIndex(uint32_t idx, const SBFileSpec &sb_file, bool full) { + LLDB_RECORD_METHOD(uint32_t, SBFileSpecList, FindFileIndex, + (uint32_t, const lldb::SBFileSpec &, bool), idx, sb_file, + full); + return m_opaque_up->FindFileIndex(idx, sb_file.ref(), full); } const SBFileSpec SBFileSpecList::GetFileSpecAtIndex(uint32_t idx) const { + LLDB_RECORD_METHOD_CONST(const lldb::SBFileSpec, SBFileSpecList, + GetFileSpecAtIndex, (uint32_t), idx); + SBFileSpec new_spec; new_spec.SetFileSpec(m_opaque_up->GetFileSpecAtIndex(idx)); - return new_spec; + return LLDB_RECORD_RESULT(new_spec); } const lldb_private::FileSpecList *SBFileSpecList::operator->() const { @@ -84,6 +114,9 @@ const lldb_private::FileSpecList &SBFileSpecList::ref() const { } bool SBFileSpecList::GetDescription(SBStream &description) const { + LLDB_RECORD_METHOD_CONST(bool, SBFileSpecList, GetDescription, + (lldb::SBStream &), description); + Stream &strm = description.ref(); if (m_opaque_up) { diff --git a/lldb/source/API/SBFrame.cpp b/lldb/source/API/SBFrame.cpp index 55401c03dff..5ab2af37cf1 100644 --- a/lldb/source/API/SBFrame.cpp +++ b/lldb/source/API/SBFrame.cpp @@ -15,6 +15,7 @@ #include "lldb/lldb-types.h" #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h" +#include "SBReproducerPrivate.h" #include "Utils.h" #include "lldb/Core/Address.h" #include "lldb/Core/StreamFile.h" @@ -54,10 +55,15 @@ using namespace lldb; using namespace lldb_private; -SBFrame::SBFrame() : m_opaque_sp(new ExecutionContextRef()) {} +SBFrame::SBFrame() : m_opaque_sp(new ExecutionContextRef()) { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFrame); +} SBFrame::SBFrame(const StackFrameSP &lldb_object_sp) : m_opaque_sp(new ExecutionContextRef(lldb_object_sp)) { + LLDB_RECORD_CONSTRUCTOR(SBFrame, (const lldb::StackFrameSP &), + lldb_object_sp); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) { @@ -70,12 +76,17 @@ SBFrame::SBFrame(const StackFrameSP &lldb_object_sp) } SBFrame::SBFrame(const SBFrame &rhs) : m_opaque_sp() { + LLDB_RECORD_CONSTRUCTOR(SBFrame, (const lldb::SBFrame &), rhs); + m_opaque_sp = clone(rhs.m_opaque_sp); } SBFrame::~SBFrame() = default; const SBFrame &SBFrame::operator=(const SBFrame &rhs) { + LLDB_RECORD_METHOD(const lldb::SBFrame &, + SBFrame, operator=,(const lldb::SBFrame &), rhs); + if (this != &rhs) m_opaque_sp = clone(rhs.m_opaque_sp); return *this; @@ -90,6 +101,8 @@ void SBFrame::SetFrameSP(const StackFrameSP &lldb_object_sp) { } bool SBFrame::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsValid); + std::unique_lock<std::recursive_mutex> lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -106,6 +119,9 @@ bool SBFrame::IsValid() const { } SBSymbolContext SBFrame::GetSymbolContext(uint32_t resolve_scope) const { + LLDB_RECORD_METHOD_CONST(lldb::SBSymbolContext, SBFrame, GetSymbolContext, + (uint32_t), resolve_scope); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBSymbolContext sb_sym_ctx; std::unique_lock<std::recursive_mutex> lock; @@ -138,10 +154,12 @@ SBSymbolContext SBFrame::GetSymbolContext(uint32_t resolve_scope) const { static_cast<void *>(frame), resolve_scope, static_cast<void *>(sb_sym_ctx.get())); - return sb_sym_ctx; + return LLDB_RECORD_RESULT(sb_sym_ctx); } SBModule SBFrame::GetModule() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBModule, SBFrame, GetModule); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBModule sb_module; ModuleSP module_sp; @@ -174,10 +192,13 @@ SBModule SBFrame::GetModule() const { static_cast<void *>(frame), static_cast<void *>(module_sp.get())); - return sb_module; + return LLDB_RECORD_RESULT(sb_module); } SBCompileUnit SBFrame::GetCompileUnit() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBCompileUnit, SBFrame, + GetCompileUnit); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBCompileUnit sb_comp_unit; std::unique_lock<std::recursive_mutex> lock; @@ -208,10 +229,12 @@ SBCompileUnit SBFrame::GetCompileUnit() const { static_cast<void *>(frame), static_cast<void *>(sb_comp_unit.get())); - return sb_comp_unit; + return LLDB_RECORD_RESULT(sb_comp_unit); } SBFunction SBFrame::GetFunction() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFunction, SBFrame, GetFunction); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBFunction sb_function; std::unique_lock<std::recursive_mutex> lock; @@ -242,10 +265,12 @@ SBFunction SBFrame::GetFunction() const { static_cast<void *>(frame), static_cast<void *>(sb_function.get())); - return sb_function; + return LLDB_RECORD_RESULT(sb_function); } SBSymbol SBFrame::GetSymbol() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBSymbol, SBFrame, GetSymbol); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBSymbol sb_symbol; std::unique_lock<std::recursive_mutex> lock; @@ -274,10 +299,12 @@ SBSymbol SBFrame::GetSymbol() const { log->Printf("SBFrame(%p)::GetSymbol () => SBSymbol(%p)", static_cast<void *>(frame), static_cast<void *>(sb_symbol.get())); - return sb_symbol; + return LLDB_RECORD_RESULT(sb_symbol); } SBBlock SBFrame::GetBlock() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBlock, SBFrame, GetBlock); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBBlock sb_block; std::unique_lock<std::recursive_mutex> lock; @@ -307,10 +334,12 @@ SBBlock SBFrame::GetBlock() const { log->Printf("SBFrame(%p)::GetBlock () => SBBlock(%p)", static_cast<void *>(frame), static_cast<void *>(sb_block.GetPtr())); - return sb_block; + return LLDB_RECORD_RESULT(sb_block); } SBBlock SBFrame::GetFrameBlock() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBlock, SBFrame, GetFrameBlock); + SBBlock sb_block; std::unique_lock<std::recursive_mutex> lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -339,10 +368,12 @@ SBBlock SBFrame::GetFrameBlock() const { log->Printf("SBFrame(%p)::GetFrameBlock () => SBBlock(%p)", static_cast<void *>(frame), static_cast<void *>(sb_block.GetPtr())); - return sb_block; + return LLDB_RECORD_RESULT(sb_block); } SBLineEntry SBFrame::GetLineEntry() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBLineEntry, SBFrame, GetLineEntry); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBLineEntry sb_line_entry; std::unique_lock<std::recursive_mutex> lock; @@ -372,10 +403,12 @@ SBLineEntry SBFrame::GetLineEntry() const { log->Printf("SBFrame(%p)::GetLineEntry () => SBLineEntry(%p)", static_cast<void *>(frame), static_cast<void *>(sb_line_entry.get())); - return sb_line_entry; + return LLDB_RECORD_RESULT(sb_line_entry); } uint32_t SBFrame::GetFrameID() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBFrame, GetFrameID); + uint32_t frame_idx = UINT32_MAX; std::unique_lock<std::recursive_mutex> lock; @@ -393,6 +426,8 @@ uint32_t SBFrame::GetFrameID() const { } lldb::addr_t SBFrame::GetCFA() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetCFA); + std::unique_lock<std::recursive_mutex> lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -403,6 +438,8 @@ lldb::addr_t SBFrame::GetCFA() const { } addr_t SBFrame::GetPC() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetPC); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); addr_t addr = LLDB_INVALID_ADDRESS; std::unique_lock<std::recursive_mutex> lock; @@ -437,6 +474,8 @@ addr_t SBFrame::GetPC() const { } bool SBFrame::SetPC(addr_t new_pc) { + LLDB_RECORD_METHOD(bool, SBFrame, SetPC, (lldb::addr_t), new_pc); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); bool ret_val = false; std::unique_lock<std::recursive_mutex> lock; @@ -470,6 +509,8 @@ bool SBFrame::SetPC(addr_t new_pc) { } addr_t SBFrame::GetSP() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetSP); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); addr_t addr = LLDB_INVALID_ADDRESS; std::unique_lock<std::recursive_mutex> lock; @@ -502,6 +543,8 @@ addr_t SBFrame::GetSP() const { } addr_t SBFrame::GetFP() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetFP); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); addr_t addr = LLDB_INVALID_ADDRESS; std::unique_lock<std::recursive_mutex> lock; @@ -534,6 +577,8 @@ addr_t SBFrame::GetFP() const { } SBAddress SBFrame::GetPCAddress() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBFrame, GetPCAddress); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBAddress sb_addr; std::unique_lock<std::recursive_mutex> lock; @@ -561,12 +606,19 @@ SBAddress SBFrame::GetPCAddress() const { if (log) log->Printf("SBFrame(%p)::GetPCAddress () => SBAddress(%p)", static_cast<void *>(frame), static_cast<void *>(sb_addr.get())); - return sb_addr; + return LLDB_RECORD_RESULT(sb_addr); } -void SBFrame::Clear() { m_opaque_sp->Clear(); } +void SBFrame::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBFrame, Clear); + + m_opaque_sp->Clear(); +} lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path) { + LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath, + (const char *), var_path); + SBValue sb_value; std::unique_lock<std::recursive_mutex> lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -578,18 +630,22 @@ lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path) { frame->CalculateTarget()->GetPreferDynamicValue(); sb_value = GetValueForVariablePath(var_path, use_dynamic); } - return sb_value; + return LLDB_RECORD_RESULT(sb_value); } lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path, DynamicValueType use_dynamic) { + LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath, + (const char *, lldb::DynamicValueType), var_path, + use_dynamic); + SBValue sb_value; Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (var_path == nullptr || var_path[0] == '\0') { if (log) log->Printf( "SBFrame::GetValueForVariablePath called with empty variable path."); - return sb_value; + return LLDB_RECORD_RESULT(sb_value); } std::unique_lock<std::recursive_mutex> lock; @@ -622,10 +678,13 @@ lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path, "SBFrame::GetValueForVariablePath () => error: process is running"); } } - return sb_value; + return LLDB_RECORD_RESULT(sb_value); } SBValue SBFrame::FindVariable(const char *name) { + LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindVariable, (const char *), + name); + SBValue value; std::unique_lock<std::recursive_mutex> lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -637,11 +696,14 @@ SBValue SBFrame::FindVariable(const char *name) { frame->CalculateTarget()->GetPreferDynamicValue(); value = FindVariable(name, use_dynamic); } - return value; + return LLDB_RECORD_RESULT(value); } SBValue SBFrame::FindVariable(const char *name, lldb::DynamicValueType use_dynamic) { + LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindVariable, + (const char *, lldb::DynamicValueType), name, use_dynamic); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); VariableSP var_sp; SBValue sb_value; @@ -649,7 +711,7 @@ SBValue SBFrame::FindVariable(const char *name, if (name == nullptr || name[0] == '\0') { if (log) log->Printf("SBFrame::FindVariable called with empty name"); - return sb_value; + return LLDB_RECORD_RESULT(sb_value); } ValueObjectSP value_sp; @@ -684,10 +746,13 @@ SBValue SBFrame::FindVariable(const char *name, static_cast<void *>(frame), name, static_cast<void *>(value_sp.get())); - return sb_value; + return LLDB_RECORD_RESULT(sb_value); } SBValue SBFrame::FindValue(const char *name, ValueType value_type) { + LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindValue, + (const char *, lldb::ValueType), name, value_type); + SBValue value; std::unique_lock<std::recursive_mutex> lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -699,18 +764,22 @@ SBValue SBFrame::FindValue(const char *name, ValueType value_type) { frame->CalculateTarget()->GetPreferDynamicValue(); value = FindValue(name, value_type, use_dynamic); } - return value; + return LLDB_RECORD_RESULT(value); } SBValue SBFrame::FindValue(const char *name, ValueType value_type, lldb::DynamicValueType use_dynamic) { + LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindValue, + (const char *, lldb::ValueType, lldb::DynamicValueType), + name, value_type, use_dynamic); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBValue sb_value; if (name == nullptr || name[0] == '\0') { if (log) log->Printf("SBFrame::FindValue called with empty name."); - return sb_value; + return LLDB_RECORD_RESULT(sb_value); } ValueObjectSP value_sp; @@ -834,20 +903,35 @@ SBValue SBFrame::FindValue(const char *name, ValueType value_type, static_cast<void *>(frame), name, value_type, static_cast<void *>(value_sp.get())); - return sb_value; + return LLDB_RECORD_RESULT(sb_value); } bool SBFrame::IsEqual(const SBFrame &that) const { + LLDB_RECORD_METHOD_CONST(bool, SBFrame, IsEqual, (const lldb::SBFrame &), + that); + lldb::StackFrameSP this_sp = GetFrameSP(); lldb::StackFrameSP that_sp = that.GetFrameSP(); return (this_sp && that_sp && this_sp->GetStackID() == that_sp->GetStackID()); } -bool SBFrame::operator==(const SBFrame &rhs) const { return IsEqual(rhs); } +bool SBFrame::operator==(const SBFrame &rhs) const { + LLDB_RECORD_METHOD_CONST(bool, SBFrame, operator==,(const lldb::SBFrame &), + rhs); + + return IsEqual(rhs); +} -bool SBFrame::operator!=(const SBFrame &rhs) const { return !IsEqual(rhs); } +bool SBFrame::operator!=(const SBFrame &rhs) const { + LLDB_RECORD_METHOD_CONST(bool, SBFrame, operator!=,(const lldb::SBFrame &), + rhs); + + return !IsEqual(rhs); +} SBThread SBFrame::GetThread() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBFrame, GetThread); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); std::unique_lock<std::recursive_mutex> lock; @@ -864,10 +948,12 @@ SBThread SBFrame::GetThread() const { static_cast<void *>(thread_sp.get()), sstr.GetData()); } - return sb_thread; + return LLDB_RECORD_RESULT(sb_thread); } const char *SBFrame::Disassemble() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFrame, Disassemble); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); const char *disassembly = nullptr; std::unique_lock<std::recursive_mutex> lock; @@ -902,6 +988,10 @@ const char *SBFrame::Disassemble() const { SBValueList SBFrame::GetVariables(bool arguments, bool locals, bool statics, bool in_scope_only) { + LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables, + (bool, bool, bool, bool), arguments, locals, statics, + in_scope_only); + SBValueList value_list; std::unique_lock<std::recursive_mutex> lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -924,12 +1014,16 @@ SBValueList SBFrame::GetVariables(bool arguments, bool locals, bool statics, value_list = GetVariables(options); } - return value_list; + return LLDB_RECORD_RESULT(value_list); } lldb::SBValueList SBFrame::GetVariables(bool arguments, bool locals, bool statics, bool in_scope_only, lldb::DynamicValueType use_dynamic) { + LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables, + (bool, bool, bool, bool, lldb::DynamicValueType), + arguments, locals, statics, in_scope_only, use_dynamic); + std::unique_lock<std::recursive_mutex> lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -943,10 +1037,13 @@ lldb::SBValueList SBFrame::GetVariables(bool arguments, bool locals, options.SetInScopeOnly(in_scope_only); options.SetIncludeRuntimeSupportValues(include_runtime_support_values); options.SetUseDynamic(use_dynamic); - return GetVariables(options); + return LLDB_RECORD_RESULT(GetVariables(options)); } SBValueList SBFrame::GetVariables(const lldb::SBVariablesOptions &options) { + LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables, + (const lldb::SBVariablesOptions &), options); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBValueList value_list; @@ -1063,10 +1160,12 @@ SBValueList SBFrame::GetVariables(const lldb::SBVariablesOptions &options) { static_cast<void *>(frame), static_cast<void *>(value_list.opaque_ptr())); - return value_list; + return LLDB_RECORD_RESULT(value_list); } SBValueList SBFrame::GetRegisters() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValueList, SBFrame, GetRegisters); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBValueList value_list; @@ -1105,10 +1204,13 @@ SBValueList SBFrame::GetRegisters() { static_cast<void *>(frame), static_cast<void *>(value_list.opaque_ptr())); - return value_list; + return LLDB_RECORD_RESULT(value_list); } SBValue SBFrame::FindRegister(const char *name) { + LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindRegister, (const char *), + name); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBValue result; @@ -1156,10 +1258,13 @@ SBValue SBFrame::FindRegister(const char *name) { static_cast<void *>(frame), static_cast<void *>(value_sp.get())); - return result; + return LLDB_RECORD_RESULT(result); } bool SBFrame::GetDescription(SBStream &description) { + LLDB_RECORD_METHOD(bool, SBFrame, GetDescription, (lldb::SBStream &), + description); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); Stream &strm = description.ref(); @@ -1192,6 +1297,9 @@ bool SBFrame::GetDescription(SBStream &description) { } SBValue SBFrame::EvaluateExpression(const char *expr) { + LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression, (const char *), + expr); + SBValue result; std::unique_lock<std::recursive_mutex> lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -1209,14 +1317,18 @@ SBValue SBFrame::EvaluateExpression(const char *expr) { options.SetLanguage(target->GetLanguage()); else options.SetLanguage(frame->GetLanguage()); - return EvaluateExpression(expr, options); + return LLDB_RECORD_RESULT(EvaluateExpression(expr, options)); } - return result; + return LLDB_RECORD_RESULT(result); } SBValue SBFrame::EvaluateExpression(const char *expr, lldb::DynamicValueType fetch_dynamic_value) { + LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression, + (const char *, lldb::DynamicValueType), expr, + fetch_dynamic_value); + SBExpressionOptions options; options.SetFetchDynamicValue(fetch_dynamic_value); options.SetUnwindOnError(true); @@ -1230,12 +1342,16 @@ SBFrame::EvaluateExpression(const char *expr, options.SetLanguage(target->GetLanguage()); else if (frame) options.SetLanguage(frame->GetLanguage()); - return EvaluateExpression(expr, options); + return LLDB_RECORD_RESULT(EvaluateExpression(expr, options)); } SBValue SBFrame::EvaluateExpression(const char *expr, lldb::DynamicValueType fetch_dynamic_value, bool unwind_on_error) { + LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression, + (const char *, lldb::DynamicValueType, bool), expr, + fetch_dynamic_value, unwind_on_error); + SBExpressionOptions options; std::unique_lock<std::recursive_mutex> lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -1249,11 +1365,15 @@ SBValue SBFrame::EvaluateExpression(const char *expr, options.SetLanguage(target->GetLanguage()); else if (frame) options.SetLanguage(frame->GetLanguage()); - return EvaluateExpression(expr, options); + return LLDB_RECORD_RESULT(EvaluateExpression(expr, options)); } lldb::SBValue SBFrame::EvaluateExpression(const char *expr, const SBExpressionOptions &options) { + LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression, + (const char *, const lldb::SBExpressionOptions &), expr, + options); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); #ifndef LLDB_DISABLE_PYTHON @@ -1267,7 +1387,7 @@ lldb::SBValue SBFrame::EvaluateExpression(const char *expr, if (log) log->Printf( "SBFrame::EvaluateExpression called with an empty expression"); - return expr_result; + return LLDB_RECORD_RESULT(expr_result); } ValueObjectSP expr_value_sp; @@ -1326,14 +1446,18 @@ lldb::SBValue SBFrame::EvaluateExpression(const char *expr, static_cast<void *>(expr_value_sp.get()), exe_results); #endif - return expr_result; + return LLDB_RECORD_RESULT(expr_result); } bool SBFrame::IsInlined() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBFrame, IsInlined); + return static_cast<const SBFrame *>(this)->IsInlined(); } bool SBFrame::IsInlined() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsInlined); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); std::unique_lock<std::recursive_mutex> lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -1364,10 +1488,14 @@ bool SBFrame::IsInlined() const { } bool SBFrame::IsArtificial() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBFrame, IsArtificial); + return static_cast<const SBFrame *>(this)->IsArtificial(); } bool SBFrame::IsArtificial() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsArtificial); + std::unique_lock<std::recursive_mutex> lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -1379,13 +1507,17 @@ bool SBFrame::IsArtificial() const { } const char *SBFrame::GetFunctionName() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBFrame, GetFunctionName); + return static_cast<const SBFrame *>(this)->GetFunctionName(); } lldb::LanguageType SBFrame::GuessLanguage() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::LanguageType, SBFrame, GuessLanguage); + std::unique_lock<std::recursive_mutex> lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); - + StackFrame *frame = nullptr; Target *target = exe_ctx.GetTargetPtr(); Process *process = exe_ctx.GetProcessPtr(); @@ -1402,6 +1534,8 @@ lldb::LanguageType SBFrame::GuessLanguage() const { } const char *SBFrame::GetFunctionName() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFrame, GetFunctionName); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); const char *name = nullptr; std::unique_lock<std::recursive_mutex> lock; @@ -1451,6 +1585,8 @@ const char *SBFrame::GetFunctionName() const { } const char *SBFrame::GetDisplayFunctionName() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBFrame, GetDisplayFunctionName); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); const char *name = nullptr; diff --git a/lldb/source/API/SBFunction.cpp b/lldb/source/API/SBFunction.cpp index 04df42faad1..8ef2430f6d9 100644 --- a/lldb/source/API/SBFunction.cpp +++ b/lldb/source/API/SBFunction.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBFunction.h" +#include "SBReproducerPrivate.h" #include "lldb/API/SBProcess.h" #include "lldb/API/SBStream.h" #include "lldb/Core/Disassembler.h" @@ -22,24 +23,37 @@ using namespace lldb; using namespace lldb_private; -SBFunction::SBFunction() : m_opaque_ptr(NULL) {} +SBFunction::SBFunction() : m_opaque_ptr(NULL) { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFunction); +} SBFunction::SBFunction(lldb_private::Function *lldb_object_ptr) : m_opaque_ptr(lldb_object_ptr) {} SBFunction::SBFunction(const lldb::SBFunction &rhs) - : m_opaque_ptr(rhs.m_opaque_ptr) {} + : m_opaque_ptr(rhs.m_opaque_ptr) { + LLDB_RECORD_CONSTRUCTOR(SBFunction, (const lldb::SBFunction &), rhs); +} const SBFunction &SBFunction::operator=(const SBFunction &rhs) { + LLDB_RECORD_METHOD(const lldb::SBFunction &, + SBFunction, operator=,(const lldb::SBFunction &), rhs); + m_opaque_ptr = rhs.m_opaque_ptr; return *this; } SBFunction::~SBFunction() { m_opaque_ptr = NULL; } -bool SBFunction::IsValid() const { return m_opaque_ptr != NULL; } +bool SBFunction::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFunction, IsValid); + + return m_opaque_ptr != NULL; +} const char *SBFunction::GetName() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFunction, GetName); + const char *cstr = NULL; if (m_opaque_ptr) cstr = m_opaque_ptr->GetName().AsCString(); @@ -57,6 +71,8 @@ const char *SBFunction::GetName() const { } const char *SBFunction::GetDisplayName() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFunction, GetDisplayName); + const char *cstr = NULL; if (m_opaque_ptr) cstr = m_opaque_ptr->GetMangled() @@ -76,6 +92,8 @@ const char *SBFunction::GetDisplayName() const { } const char *SBFunction::GetMangledName() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFunction, GetMangledName); + const char *cstr = NULL; if (m_opaque_ptr) cstr = m_opaque_ptr->GetMangled().GetMangledName().AsCString(); @@ -92,14 +110,22 @@ const char *SBFunction::GetMangledName() const { } bool SBFunction::operator==(const SBFunction &rhs) const { + LLDB_RECORD_METHOD_CONST( + bool, SBFunction, operator==,(const lldb::SBFunction &), rhs); + return m_opaque_ptr == rhs.m_opaque_ptr; } bool SBFunction::operator!=(const SBFunction &rhs) const { + LLDB_RECORD_METHOD_CONST( + bool, SBFunction, operator!=,(const lldb::SBFunction &), rhs); + return m_opaque_ptr != rhs.m_opaque_ptr; } bool SBFunction::GetDescription(SBStream &s) { + LLDB_RECORD_METHOD(bool, SBFunction, GetDescription, (lldb::SBStream &), s); + if (m_opaque_ptr) { s.Printf("SBFunction: id = 0x%8.8" PRIx64 ", name = %s", m_opaque_ptr->GetID(), m_opaque_ptr->GetName().AsCString()); @@ -113,11 +139,17 @@ bool SBFunction::GetDescription(SBStream &s) { } SBInstructionList SBFunction::GetInstructions(SBTarget target) { - return GetInstructions(target, NULL); + LLDB_RECORD_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions, + (lldb::SBTarget), target); + + return LLDB_RECORD_RESULT(GetInstructions(target, NULL)); } SBInstructionList SBFunction::GetInstructions(SBTarget target, const char *flavor) { + LLDB_RECORD_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions, + (lldb::SBTarget, const char *), target, flavor); + SBInstructionList sb_instructions; if (m_opaque_ptr) { ExecutionContext exe_ctx; @@ -137,7 +169,7 @@ SBInstructionList SBFunction::GetInstructions(SBTarget target, m_opaque_ptr->GetAddressRange(), prefer_file_cache)); } } - return sb_instructions; + return LLDB_RECORD_RESULT(sb_instructions); } lldb_private::Function *SBFunction::get() { return m_opaque_ptr; } @@ -147,13 +179,17 @@ void SBFunction::reset(lldb_private::Function *lldb_object_ptr) { } SBAddress SBFunction::GetStartAddress() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBFunction, GetStartAddress); + SBAddress addr; if (m_opaque_ptr) addr.SetAddress(&m_opaque_ptr->GetAddressRange().GetBaseAddress()); - return addr; + return LLDB_RECORD_RESULT(addr); } SBAddress SBFunction::GetEndAddress() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBFunction, GetEndAddress); + SBAddress addr; if (m_opaque_ptr) { addr_t byte_size = m_opaque_ptr->GetAddressRange().GetByteSize(); @@ -162,10 +198,13 @@ SBAddress SBFunction::GetEndAddress() { addr->Slide(byte_size); } } - return addr; + return LLDB_RECORD_RESULT(addr); } const char *SBFunction::GetArgumentName(uint32_t arg_idx) { + LLDB_RECORD_METHOD(const char *, SBFunction, GetArgumentName, (uint32_t), + arg_idx); + if (m_opaque_ptr) { Block &block = m_opaque_ptr->GetBlock(true); VariableListSP variable_list_sp = block.GetBlockVariableList(true); @@ -182,29 +221,37 @@ const char *SBFunction::GetArgumentName(uint32_t arg_idx) { } uint32_t SBFunction::GetPrologueByteSize() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBFunction, GetPrologueByteSize); + if (m_opaque_ptr) return m_opaque_ptr->GetPrologueByteSize(); return 0; } SBType SBFunction::GetType() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBFunction, GetType); + SBType sb_type; if (m_opaque_ptr) { Type *function_type = m_opaque_ptr->GetType(); if (function_type) sb_type.ref().SetType(function_type->shared_from_this()); } - return sb_type; + return LLDB_RECORD_RESULT(sb_type); } SBBlock SBFunction::GetBlock() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBFunction, GetBlock); + SBBlock sb_block; if (m_opaque_ptr) sb_block.SetPtr(&m_opaque_ptr->GetBlock(true)); - return sb_block; + return LLDB_RECORD_RESULT(sb_block); } lldb::LanguageType SBFunction::GetLanguage() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::LanguageType, SBFunction, GetLanguage); + if (m_opaque_ptr) { if (m_opaque_ptr->GetCompileUnit()) return m_opaque_ptr->GetCompileUnit()->GetLanguage(); @@ -213,6 +260,8 @@ lldb::LanguageType SBFunction::GetLanguage() { } bool SBFunction::GetIsOptimized() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBFunction, GetIsOptimized); + if (m_opaque_ptr) { if (m_opaque_ptr->GetCompileUnit()) return m_opaque_ptr->GetCompileUnit()->GetIsOptimized(); diff --git a/lldb/source/API/SBHostOS.cpp b/lldb/source/API/SBHostOS.cpp index 75ce5776360..08440b341de 100644 --- a/lldb/source/API/SBHostOS.cpp +++ b/lldb/source/API/SBHostOS.cpp @@ -10,6 +10,7 @@ #include "Plugins/ScriptInterpreter/Python/lldb-python.h" #endif +#include "SBReproducerPrivate.h" #include "lldb/API/SBError.h" #include "lldb/API/SBHostOS.h" #include "lldb/Host/FileSystem.h" @@ -33,16 +34,25 @@ using namespace lldb; using namespace lldb_private; SBFileSpec SBHostOS::GetProgramFileSpec() { + LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBFileSpec, SBHostOS, + GetProgramFileSpec); + SBFileSpec sb_filespec; sb_filespec.SetFileSpec(HostInfo::GetProgramFileSpec()); - return sb_filespec; + return LLDB_RECORD_RESULT(sb_filespec); } SBFileSpec SBHostOS::GetLLDBPythonPath() { - return GetLLDBPath(ePathTypePythonDir); + LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBFileSpec, SBHostOS, + GetLLDBPythonPath); + + return LLDB_RECORD_RESULT(GetLLDBPath(ePathTypePythonDir)); } SBFileSpec SBHostOS::GetLLDBPath(lldb::PathType path_type) { + LLDB_RECORD_STATIC_METHOD(lldb::SBFileSpec, SBHostOS, GetLLDBPath, + (lldb::PathType), path_type); + FileSpec fspec; switch (path_type) { case ePathTypeLLDBShlibDir: @@ -78,10 +88,13 @@ SBFileSpec SBHostOS::GetLLDBPath(lldb::PathType path_type) { SBFileSpec sb_fspec; sb_fspec.SetFileSpec(fspec); - return sb_fspec; + return LLDB_RECORD_RESULT(sb_fspec); } SBFileSpec SBHostOS::GetUserHomeDirectory() { + LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBFileSpec, SBHostOS, + GetUserHomeDirectory); + SBFileSpec sb_fspec; llvm::SmallString<64> home_dir_path; @@ -90,7 +103,7 @@ SBFileSpec SBHostOS::GetUserHomeDirectory() { FileSystem::Instance().Resolve(homedir); sb_fspec.SetFileSpec(homedir); - return sb_fspec; + return LLDB_RECORD_RESULT(sb_fspec); } lldb::thread_t SBHostOS::ThreadCreate(const char *name, @@ -113,9 +126,16 @@ lldb::thread_t SBHostOS::ThreadCreate(const char *name, return thread.Release(); } -void SBHostOS::ThreadCreated(const char *name) {} +void SBHostOS::ThreadCreated(const char *name) { + LLDB_RECORD_STATIC_METHOD(void, SBHostOS, ThreadCreated, (const char *), + name); +} bool SBHostOS::ThreadCancel(lldb::thread_t thread, SBError *error_ptr) { + LLDB_RECORD_STATIC_METHOD(bool, SBHostOS, ThreadCancel, + (lldb::thread_t, lldb::SBError *), thread, + error_ptr); + Status error; HostThread host_thread(thread); error = host_thread.Cancel(); @@ -126,6 +146,10 @@ bool SBHostOS::ThreadCancel(lldb::thread_t thread, SBError *error_ptr) { } bool SBHostOS::ThreadDetach(lldb::thread_t thread, SBError *error_ptr) { + LLDB_RECORD_STATIC_METHOD(bool, SBHostOS, ThreadDetach, + (lldb::thread_t, lldb::SBError *), thread, + error_ptr); + Status error; #if defined(_WIN32) if (error_ptr) @@ -142,6 +166,11 @@ bool SBHostOS::ThreadDetach(lldb::thread_t thread, SBError *error_ptr) { bool SBHostOS::ThreadJoin(lldb::thread_t thread, lldb::thread_result_t *result, SBError *error_ptr) { + LLDB_RECORD_STATIC_METHOD( + bool, SBHostOS, ThreadJoin, + (lldb::thread_t, lldb::thread_result_t *, lldb::SBError *), thread, + result, error_ptr); + Status error; HostThread host_thread(thread); error = host_thread.Join(result); diff --git a/lldb/source/API/SBInstruction.cpp b/lldb/source/API/SBInstruction.cpp index abc390b24b8..53b2d196788 100644 --- a/lldb/source/API/SBInstruction.cpp +++ b/lldb/source/API/SBInstruction.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBInstruction.h" +#include "SBReproducerPrivate.h" #include "lldb/API/SBAddress.h" #include "lldb/API/SBFrame.h" @@ -66,16 +67,24 @@ protected: using namespace lldb; using namespace lldb_private; -SBInstruction::SBInstruction() : m_opaque_sp() {} +SBInstruction::SBInstruction() : m_opaque_sp() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBInstruction); +} SBInstruction::SBInstruction(const lldb::DisassemblerSP &disasm_sp, const lldb::InstructionSP &inst_sp) : m_opaque_sp(new InstructionImpl(disasm_sp, inst_sp)) {} SBInstruction::SBInstruction(const SBInstruction &rhs) - : m_opaque_sp(rhs.m_opaque_sp) {} + : m_opaque_sp(rhs.m_opaque_sp) { + LLDB_RECORD_CONSTRUCTOR(SBInstruction, (const lldb::SBInstruction &), rhs); +} const SBInstruction &SBInstruction::operator=(const SBInstruction &rhs) { + LLDB_RECORD_METHOD(const lldb::SBInstruction &, + SBInstruction, operator=,(const lldb::SBInstruction &), + rhs); + if (this != &rhs) m_opaque_sp = rhs.m_opaque_sp; return *this; @@ -83,17 +92,26 @@ const SBInstruction &SBInstruction::operator=(const SBInstruction &rhs) { SBInstruction::~SBInstruction() {} -bool SBInstruction::IsValid() { return m_opaque_sp && m_opaque_sp->IsValid(); } +bool SBInstruction::IsValid() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, IsValid); + + return m_opaque_sp && m_opaque_sp->IsValid(); +} SBAddress SBInstruction::GetAddress() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBInstruction, GetAddress); + SBAddress sb_addr; lldb::InstructionSP inst_sp(GetOpaque()); if (inst_sp && inst_sp->GetAddress().IsValid()) sb_addr.SetAddress(&inst_sp->GetAddress()); - return sb_addr; + return LLDB_RECORD_RESULT(sb_addr); } const char *SBInstruction::GetMnemonic(SBTarget target) { + LLDB_RECORD_METHOD(const char *, SBInstruction, GetMnemonic, (lldb::SBTarget), + target); + lldb::InstructionSP inst_sp(GetOpaque()); if (inst_sp) { ExecutionContext exe_ctx; @@ -111,6 +129,9 @@ const char *SBInstruction::GetMnemonic(SBTarget target) { } const char *SBInstruction::GetOperands(SBTarget target) { + LLDB_RECORD_METHOD(const char *, SBInstruction, GetOperands, (lldb::SBTarget), + target); + lldb::InstructionSP inst_sp(GetOpaque()); if (inst_sp) { ExecutionContext exe_ctx; @@ -128,6 +149,9 @@ const char *SBInstruction::GetOperands(SBTarget target) { } const char *SBInstruction::GetComment(SBTarget target) { + LLDB_RECORD_METHOD(const char *, SBInstruction, GetComment, (lldb::SBTarget), + target); + lldb::InstructionSP inst_sp(GetOpaque()); if (inst_sp) { ExecutionContext exe_ctx; @@ -145,6 +169,8 @@ const char *SBInstruction::GetComment(SBTarget target) { } size_t SBInstruction::GetByteSize() { + LLDB_RECORD_METHOD_NO_ARGS(size_t, SBInstruction, GetByteSize); + lldb::InstructionSP inst_sp(GetOpaque()); if (inst_sp) return inst_sp->GetOpcode().GetByteSize(); @@ -152,6 +178,9 @@ size_t SBInstruction::GetByteSize() { } SBData SBInstruction::GetData(SBTarget target) { + LLDB_RECORD_METHOD(lldb::SBData, SBInstruction, GetData, (lldb::SBTarget), + target); + lldb::SBData sb_data; lldb::InstructionSP inst_sp(GetOpaque()); if (inst_sp) { @@ -160,10 +189,12 @@ SBData SBInstruction::GetData(SBTarget target) { sb_data.SetOpaque(data_extractor_sp); } } - return sb_data; + return LLDB_RECORD_RESULT(sb_data); } bool SBInstruction::DoesBranch() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, DoesBranch); + lldb::InstructionSP inst_sp(GetOpaque()); if (inst_sp) return inst_sp->DoesBranch(); @@ -171,13 +202,17 @@ bool SBInstruction::DoesBranch() { } bool SBInstruction::HasDelaySlot() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, HasDelaySlot); + lldb::InstructionSP inst_sp(GetOpaque()); if (inst_sp) return inst_sp->HasDelaySlot(); return false; } -bool SBInstruction::CanSetBreakpoint () { +bool SBInstruction::CanSetBreakpoint() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, CanSetBreakpoint); + lldb::InstructionSP inst_sp(GetOpaque()); if (inst_sp) return inst_sp->CanSetBreakpoint(); @@ -197,6 +232,9 @@ void SBInstruction::SetOpaque(const lldb::DisassemblerSP &disasm_sp, } bool SBInstruction::GetDescription(lldb::SBStream &s) { + LLDB_RECORD_METHOD(bool, SBInstruction, GetDescription, (lldb::SBStream &), + s); + lldb::InstructionSP inst_sp(GetOpaque()); if (inst_sp) { SymbolContext sc; @@ -216,6 +254,8 @@ bool SBInstruction::GetDescription(lldb::SBStream &s) { } void SBInstruction::Print(FILE *out) { + LLDB_RECORD_METHOD(void, SBInstruction, Print, (FILE *), out); + if (out == NULL) return; @@ -236,6 +276,9 @@ void SBInstruction::Print(FILE *out) { bool SBInstruction::EmulateWithFrame(lldb::SBFrame &frame, uint32_t evaluate_options) { + LLDB_RECORD_METHOD(bool, SBInstruction, EmulateWithFrame, + (lldb::SBFrame &, uint32_t), frame, evaluate_options); + lldb::InstructionSP inst_sp(GetOpaque()); if (inst_sp) { lldb::StackFrameSP frame_sp(frame.GetFrameSP()); @@ -258,6 +301,9 @@ bool SBInstruction::EmulateWithFrame(lldb::SBFrame &frame, } bool SBInstruction::DumpEmulation(const char *triple) { + LLDB_RECORD_METHOD(bool, SBInstruction, DumpEmulation, (const char *), + triple); + lldb::InstructionSP inst_sp(GetOpaque()); if (inst_sp && triple) { return inst_sp->DumpEmulation(HostInfo::GetAugmentedArchSpec(triple)); @@ -267,6 +313,10 @@ bool SBInstruction::DumpEmulation(const char *triple) { bool SBInstruction::TestEmulation(lldb::SBStream &output_stream, const char *test_file) { + LLDB_RECORD_METHOD(bool, SBInstruction, TestEmulation, + (lldb::SBStream &, const char *), output_stream, + test_file); + if (!m_opaque_sp) SetOpaque(lldb::DisassemblerSP(), lldb::InstructionSP(new PseudoInstruction())); diff --git a/lldb/source/API/SBInstructionList.cpp b/lldb/source/API/SBInstructionList.cpp index 5f66625b5e0..bc6f74c597a 100644 --- a/lldb/source/API/SBInstructionList.cpp +++ b/lldb/source/API/SBInstructionList.cpp @@ -7,8 +7,9 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBInstructionList.h" -#include "lldb/API/SBInstruction.h" +#include "SBReproducerPrivate.h" #include "lldb/API/SBAddress.h" +#include "lldb/API/SBInstruction.h" #include "lldb/API/SBStream.h" #include "lldb/Core/Disassembler.h" #include "lldb/Core/Module.h" @@ -18,13 +19,22 @@ using namespace lldb; using namespace lldb_private; -SBInstructionList::SBInstructionList() : m_opaque_sp() {} +SBInstructionList::SBInstructionList() : m_opaque_sp() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBInstructionList); +} SBInstructionList::SBInstructionList(const SBInstructionList &rhs) - : m_opaque_sp(rhs.m_opaque_sp) {} + : m_opaque_sp(rhs.m_opaque_sp) { + LLDB_RECORD_CONSTRUCTOR(SBInstructionList, (const lldb::SBInstructionList &), + rhs); +} const SBInstructionList &SBInstructionList:: operator=(const SBInstructionList &rhs) { + LLDB_RECORD_METHOD( + const lldb::SBInstructionList &, + SBInstructionList, operator=,(const lldb::SBInstructionList &), rhs); + if (this != &rhs) m_opaque_sp = rhs.m_opaque_sp; return *this; @@ -32,26 +42,39 @@ operator=(const SBInstructionList &rhs) { SBInstructionList::~SBInstructionList() {} -bool SBInstructionList::IsValid() const { return m_opaque_sp.get() != NULL; } +bool SBInstructionList::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInstructionList, IsValid); + + return m_opaque_sp.get() != NULL; +} size_t SBInstructionList::GetSize() { + LLDB_RECORD_METHOD_NO_ARGS(size_t, SBInstructionList, GetSize); + if (m_opaque_sp) return m_opaque_sp->GetInstructionList().GetSize(); return 0; } SBInstruction SBInstructionList::GetInstructionAtIndex(uint32_t idx) { + LLDB_RECORD_METHOD(lldb::SBInstruction, SBInstructionList, + GetInstructionAtIndex, (uint32_t), idx); + SBInstruction inst; if (m_opaque_sp && idx < m_opaque_sp->GetInstructionList().GetSize()) inst.SetOpaque( m_opaque_sp, m_opaque_sp->GetInstructionList().GetInstructionAtIndex(idx)); - return inst; + return LLDB_RECORD_RESULT(inst); } size_t SBInstructionList::GetInstructionsCount(const SBAddress &start, - const SBAddress &end, - bool canSetBreakpoint) { + const SBAddress &end, + bool canSetBreakpoint) { + LLDB_RECORD_METHOD(size_t, SBInstructionList, GetInstructionsCount, + (const lldb::SBAddress &, const lldb::SBAddress &, bool), + start, end, canSetBreakpoint); + size_t num_instructions = GetSize(); size_t i = 0; SBAddress addr; @@ -74,20 +97,32 @@ size_t SBInstructionList::GetInstructionsCount(const SBAddress &start, return upper_index - lower_index - instructions_to_skip; } -void SBInstructionList::Clear() { m_opaque_sp.reset(); } +void SBInstructionList::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBInstructionList, Clear); + + m_opaque_sp.reset(); +} -void SBInstructionList::AppendInstruction(SBInstruction insn) {} +void SBInstructionList::AppendInstruction(SBInstruction insn) { + LLDB_RECORD_METHOD(void, SBInstructionList, AppendInstruction, + (lldb::SBInstruction), insn); +} void SBInstructionList::SetDisassembler(const lldb::DisassemblerSP &opaque_sp) { m_opaque_sp = opaque_sp; } void SBInstructionList::Print(FILE *out) { + LLDB_RECORD_METHOD(void, SBInstructionList, Print, (FILE *), out); + if (out == NULL) return; } bool SBInstructionList::GetDescription(lldb::SBStream &description) { + LLDB_RECORD_METHOD(bool, SBInstructionList, GetDescription, + (lldb::SBStream &), description); + if (m_opaque_sp) { size_t num_instructions = GetSize(); if (num_instructions) { @@ -125,6 +160,9 @@ bool SBInstructionList::GetDescription(lldb::SBStream &description) { } bool SBInstructionList::DumpEmulationForAllInstructions(const char *triple) { + LLDB_RECORD_METHOD(bool, SBInstructionList, DumpEmulationForAllInstructions, + (const char *), triple); + if (m_opaque_sp) { size_t len = GetSize(); for (size_t i = 0; i < len; ++i) { diff --git a/lldb/source/API/SBLanguageRuntime.cpp b/lldb/source/API/SBLanguageRuntime.cpp index 64149ee85d4..eb64ac144b4 100644 --- a/lldb/source/API/SBLanguageRuntime.cpp +++ b/lldb/source/API/SBLanguageRuntime.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBLanguageRuntime.h" +#include "SBReproducerPrivate.h" #include "lldb/Target/Language.h" using namespace lldb; @@ -14,11 +15,18 @@ using namespace lldb_private; lldb::LanguageType SBLanguageRuntime::GetLanguageTypeFromString(const char *string) { + LLDB_RECORD_STATIC_METHOD(lldb::LanguageType, SBLanguageRuntime, + GetLanguageTypeFromString, (const char *), string); + return Language::GetLanguageTypeFromString( llvm::StringRef::withNullAsEmpty(string)); } const char * SBLanguageRuntime::GetNameForLanguageType(lldb::LanguageType language) { + LLDB_RECORD_STATIC_METHOD(const char *, SBLanguageRuntime, + GetNameForLanguageType, (lldb::LanguageType), + language); + return Language::GetNameForLanguageType(language); } diff --git a/lldb/source/API/SBLaunchInfo.cpp b/lldb/source/API/SBLaunchInfo.cpp index 3d27887081d..4457d1a01f8 100644 --- a/lldb/source/API/SBLaunchInfo.cpp +++ b/lldb/source/API/SBLaunchInfo.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBLaunchInfo.h" +#include "SBReproducerPrivate.h" #include "lldb/API/SBFileSpec.h" #include "lldb/API/SBListener.h" @@ -35,6 +36,8 @@ private: SBLaunchInfo::SBLaunchInfo(const char **argv) : m_opaque_sp(new SBLaunchInfoImpl()) { + LLDB_RECORD_CONSTRUCTOR(SBLaunchInfo, (const char **), argv); + m_opaque_sp->GetFlags().Reset(eLaunchFlagDebug | eLaunchFlagDisableASLR); if (argv && argv[0]) m_opaque_sp->GetArguments().SetArguments(argv); @@ -50,46 +53,92 @@ void SBLaunchInfo::set_ref(const ProcessLaunchInfo &info) { *m_opaque_sp = info; } -lldb::pid_t SBLaunchInfo::GetProcessID() { return m_opaque_sp->GetProcessID(); } +lldb::pid_t SBLaunchInfo::GetProcessID() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBLaunchInfo, GetProcessID); + + return m_opaque_sp->GetProcessID(); +} + +uint32_t SBLaunchInfo::GetUserID() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetUserID); + + return m_opaque_sp->GetUserID(); +} + +uint32_t SBLaunchInfo::GetGroupID() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetGroupID); + + return m_opaque_sp->GetGroupID(); +} + +bool SBLaunchInfo::UserIDIsValid() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBLaunchInfo, UserIDIsValid); + + return m_opaque_sp->UserIDIsValid(); +} -uint32_t SBLaunchInfo::GetUserID() { return m_opaque_sp->GetUserID(); } +bool SBLaunchInfo::GroupIDIsValid() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBLaunchInfo, GroupIDIsValid); -uint32_t SBLaunchInfo::GetGroupID() { return m_opaque_sp->GetGroupID(); } + return m_opaque_sp->GroupIDIsValid(); +} -bool SBLaunchInfo::UserIDIsValid() { return m_opaque_sp->UserIDIsValid(); } +void SBLaunchInfo::SetUserID(uint32_t uid) { + LLDB_RECORD_METHOD(void, SBLaunchInfo, SetUserID, (uint32_t), uid); -bool SBLaunchInfo::GroupIDIsValid() { return m_opaque_sp->GroupIDIsValid(); } + m_opaque_sp->SetUserID(uid); +} -void SBLaunchInfo::SetUserID(uint32_t uid) { m_opaque_sp->SetUserID(uid); } +void SBLaunchInfo::SetGroupID(uint32_t gid) { + LLDB_RECORD_METHOD(void, SBLaunchInfo, SetGroupID, (uint32_t), gid); -void SBLaunchInfo::SetGroupID(uint32_t gid) { m_opaque_sp->SetGroupID(gid); } + m_opaque_sp->SetGroupID(gid); +} SBFileSpec SBLaunchInfo::GetExecutableFile() { - return SBFileSpec(m_opaque_sp->GetExecutableFile()); + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBLaunchInfo, GetExecutableFile); + + return LLDB_RECORD_RESULT(SBFileSpec(m_opaque_sp->GetExecutableFile())); } void SBLaunchInfo::SetExecutableFile(SBFileSpec exe_file, bool add_as_first_arg) { + LLDB_RECORD_METHOD(void, SBLaunchInfo, SetExecutableFile, + (lldb::SBFileSpec, bool), exe_file, add_as_first_arg); + m_opaque_sp->SetExecutableFile(exe_file.ref(), add_as_first_arg); } SBListener SBLaunchInfo::GetListener() { - return SBListener(m_opaque_sp->GetListener()); + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBLaunchInfo, GetListener); + + return LLDB_RECORD_RESULT(SBListener(m_opaque_sp->GetListener())); } void SBLaunchInfo::SetListener(SBListener &listener) { + LLDB_RECORD_METHOD(void, SBLaunchInfo, SetListener, (lldb::SBListener &), + listener); + m_opaque_sp->SetListener(listener.GetSP()); } uint32_t SBLaunchInfo::GetNumArguments() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetNumArguments); + return m_opaque_sp->GetArguments().GetArgumentCount(); } const char *SBLaunchInfo::GetArgumentAtIndex(uint32_t idx) { + LLDB_RECORD_METHOD(const char *, SBLaunchInfo, GetArgumentAtIndex, (uint32_t), + idx); + return m_opaque_sp->GetArguments().GetArgumentAtIndex(idx); } void SBLaunchInfo::SetArguments(const char **argv, bool append) { + LLDB_RECORD_METHOD(void, SBLaunchInfo, SetArguments, (const char **, bool), + argv, append); + if (append) { if (argv) m_opaque_sp->GetArguments().AppendArguments(argv); @@ -102,16 +151,24 @@ void SBLaunchInfo::SetArguments(const char **argv, bool append) { } uint32_t SBLaunchInfo::GetNumEnvironmentEntries() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetNumEnvironmentEntries); + return m_opaque_sp->GetEnvironment().size(); } const char *SBLaunchInfo::GetEnvironmentEntryAtIndex(uint32_t idx) { + LLDB_RECORD_METHOD(const char *, SBLaunchInfo, GetEnvironmentEntryAtIndex, + (uint32_t), idx); + if (idx > GetNumEnvironmentEntries()) return nullptr; return m_opaque_sp->GetEnvp()[idx]; } void SBLaunchInfo::SetEnvironmentEntries(const char **envp, bool append) { + LLDB_RECORD_METHOD(void, SBLaunchInfo, SetEnvironmentEntries, + (const char **, bool), envp, append); + Environment env(envp); if (append) m_opaque_sp->GetEnvironment().insert(env.begin(), env.end()); @@ -120,33 +177,54 @@ void SBLaunchInfo::SetEnvironmentEntries(const char **envp, bool append) { m_opaque_sp->RegenerateEnvp(); } -void SBLaunchInfo::Clear() { m_opaque_sp->Clear(); } +void SBLaunchInfo::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBLaunchInfo, Clear); + + m_opaque_sp->Clear(); +} const char *SBLaunchInfo::GetWorkingDirectory() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBLaunchInfo, + GetWorkingDirectory); + return m_opaque_sp->GetWorkingDirectory().GetCString(); } void SBLaunchInfo::SetWorkingDirectory(const char *working_dir) { + LLDB_RECORD_METHOD(void, SBLaunchInfo, SetWorkingDirectory, (const char *), + working_dir); + m_opaque_sp->SetWorkingDirectory(FileSpec(working_dir)); } uint32_t SBLaunchInfo::GetLaunchFlags() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetLaunchFlags); + return m_opaque_sp->GetFlags().Get(); } void SBLaunchInfo::SetLaunchFlags(uint32_t flags) { + LLDB_RECORD_METHOD(void, SBLaunchInfo, SetLaunchFlags, (uint32_t), flags); + m_opaque_sp->GetFlags().Reset(flags); } const char *SBLaunchInfo::GetProcessPluginName() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBLaunchInfo, GetProcessPluginName); + return m_opaque_sp->GetProcessPluginName(); } void SBLaunchInfo::SetProcessPluginName(const char *plugin_name) { + LLDB_RECORD_METHOD(void, SBLaunchInfo, SetProcessPluginName, (const char *), + plugin_name); + return m_opaque_sp->SetProcessPluginName(plugin_name); } const char *SBLaunchInfo::GetShell() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBLaunchInfo, GetShell); + // Constify this string so that it is saved in the string pool. Otherwise it // would be freed when this function goes out of scope. ConstString shell(m_opaque_sp->GetShell().GetPath().c_str()); @@ -154,54 +232,86 @@ const char *SBLaunchInfo::GetShell() { } void SBLaunchInfo::SetShell(const char *path) { + LLDB_RECORD_METHOD(void, SBLaunchInfo, SetShell, (const char *), path); + m_opaque_sp->SetShell(FileSpec(path)); } bool SBLaunchInfo::GetShellExpandArguments() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBLaunchInfo, GetShellExpandArguments); + return m_opaque_sp->GetShellExpandArguments(); } void SBLaunchInfo::SetShellExpandArguments(bool expand) { + LLDB_RECORD_METHOD(void, SBLaunchInfo, SetShellExpandArguments, (bool), + expand); + m_opaque_sp->SetShellExpandArguments(expand); } uint32_t SBLaunchInfo::GetResumeCount() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetResumeCount); + return m_opaque_sp->GetResumeCount(); } void SBLaunchInfo::SetResumeCount(uint32_t c) { + LLDB_RECORD_METHOD(void, SBLaunchInfo, SetResumeCount, (uint32_t), c); + m_opaque_sp->SetResumeCount(c); } bool SBLaunchInfo::AddCloseFileAction(int fd) { + LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddCloseFileAction, (int), fd); + return m_opaque_sp->AppendCloseFileAction(fd); } bool SBLaunchInfo::AddDuplicateFileAction(int fd, int dup_fd) { + LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddDuplicateFileAction, (int, int), fd, + dup_fd); + return m_opaque_sp->AppendDuplicateFileAction(fd, dup_fd); } bool SBLaunchInfo::AddOpenFileAction(int fd, const char *path, bool read, bool write) { + LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddOpenFileAction, + (int, const char *, bool, bool), fd, path, read, write); + return m_opaque_sp->AppendOpenFileAction(fd, FileSpec(path), read, write); } bool SBLaunchInfo::AddSuppressFileAction(int fd, bool read, bool write) { + LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddSuppressFileAction, + (int, bool, bool), fd, read, write); + return m_opaque_sp->AppendSuppressFileAction(fd, read, write); } void SBLaunchInfo::SetLaunchEventData(const char *data) { + LLDB_RECORD_METHOD(void, SBLaunchInfo, SetLaunchEventData, (const char *), + data); + m_opaque_sp->SetLaunchEventData(data); } const char *SBLaunchInfo::GetLaunchEventData() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBLaunchInfo, + GetLaunchEventData); + return m_opaque_sp->GetLaunchEventData(); } void SBLaunchInfo::SetDetachOnError(bool enable) { + LLDB_RECORD_METHOD(void, SBLaunchInfo, SetDetachOnError, (bool), enable); + m_opaque_sp->SetDetachOnError(enable); } bool SBLaunchInfo::GetDetachOnError() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBLaunchInfo, GetDetachOnError); + return m_opaque_sp->GetDetachOnError(); } diff --git a/lldb/source/API/SBLineEntry.cpp b/lldb/source/API/SBLineEntry.cpp index 2d3f23f454e..6b124128433 100644 --- a/lldb/source/API/SBLineEntry.cpp +++ b/lldb/source/API/SBLineEntry.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBLineEntry.h" +#include "SBReproducerPrivate.h" #include "Utils.h" #include "lldb/API/SBStream.h" #include "lldb/Host/PosixApi.h" @@ -19,9 +20,13 @@ using namespace lldb; using namespace lldb_private; -SBLineEntry::SBLineEntry() : m_opaque_up() {} +SBLineEntry::SBLineEntry() : m_opaque_up() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBLineEntry); +} SBLineEntry::SBLineEntry(const SBLineEntry &rhs) : m_opaque_up() { + LLDB_RECORD_CONSTRUCTOR(SBLineEntry, (const lldb::SBLineEntry &), rhs); + m_opaque_up = clone(rhs.m_opaque_up); } @@ -32,6 +37,9 @@ SBLineEntry::SBLineEntry(const lldb_private::LineEntry *lldb_object_ptr) } const SBLineEntry &SBLineEntry::operator=(const SBLineEntry &rhs) { + LLDB_RECORD_METHOD(const lldb::SBLineEntry &, + SBLineEntry, operator=,(const lldb::SBLineEntry &), rhs); + if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); return *this; @@ -44,6 +52,9 @@ void SBLineEntry::SetLineEntry(const lldb_private::LineEntry &lldb_object_ref) { SBLineEntry::~SBLineEntry() {} SBAddress SBLineEntry::GetStartAddress() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBLineEntry, + GetStartAddress); + SBAddress sb_address; if (m_opaque_up) sb_address.SetAddress(&m_opaque_up->range.GetBaseAddress()); @@ -60,10 +71,12 @@ SBAddress SBLineEntry::GetStartAddress() const { static_cast<void *>(sb_address.get()), sstr.GetData()); } - return sb_address; + return LLDB_RECORD_RESULT(sb_address); } SBAddress SBLineEntry::GetEndAddress() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBLineEntry, GetEndAddress); + SBAddress sb_address; if (m_opaque_up) { sb_address.SetAddress(&m_opaque_up->range.GetBaseAddress()); @@ -80,14 +93,18 @@ SBAddress SBLineEntry::GetEndAddress() const { static_cast<void *>(m_opaque_up.get()), static_cast<void *>(sb_address.get()), sstr.GetData()); } - return sb_address; + return LLDB_RECORD_RESULT(sb_address); } bool SBLineEntry::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBLineEntry, IsValid); + return m_opaque_up.get() && m_opaque_up->IsValid(); } SBFileSpec SBLineEntry::GetFileSpec() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBLineEntry, GetFileSpec); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBFileSpec sb_file_spec; @@ -102,10 +119,12 @@ SBFileSpec SBLineEntry::GetFileSpec() const { static_cast<const void *>(sb_file_spec.get()), sstr.GetData()); } - return sb_file_spec; + return LLDB_RECORD_RESULT(sb_file_spec); } uint32_t SBLineEntry::GetLine() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBLineEntry, GetLine); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); uint32_t line = 0; @@ -120,22 +139,38 @@ uint32_t SBLineEntry::GetLine() const { } uint32_t SBLineEntry::GetColumn() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBLineEntry, GetColumn); + if (m_opaque_up) return m_opaque_up->column; return 0; } void SBLineEntry::SetFileSpec(lldb::SBFileSpec filespec) { + LLDB_RECORD_METHOD(void, SBLineEntry, SetFileSpec, (lldb::SBFileSpec), + filespec); + if (filespec.IsValid()) ref().file = filespec.ref(); else ref().file.Clear(); } -void SBLineEntry::SetLine(uint32_t line) { ref().line = line; } +void SBLineEntry::SetLine(uint32_t line) { + LLDB_RECORD_METHOD(void, SBLineEntry, SetLine, (uint32_t), line); + + ref().line = line; +} + +void SBLineEntry::SetColumn(uint32_t column) { + LLDB_RECORD_METHOD(void, SBLineEntry, SetColumn, (uint32_t), column); -void SBLineEntry::SetColumn(uint32_t column) { ref().line = column; } + ref().line = column; +} bool SBLineEntry::operator==(const SBLineEntry &rhs) const { + LLDB_RECORD_METHOD_CONST( + bool, SBLineEntry, operator==,(const lldb::SBLineEntry &), rhs); + lldb_private::LineEntry *lhs_ptr = m_opaque_up.get(); lldb_private::LineEntry *rhs_ptr = rhs.m_opaque_up.get(); @@ -146,6 +181,9 @@ bool SBLineEntry::operator==(const SBLineEntry &rhs) const { } bool SBLineEntry::operator!=(const SBLineEntry &rhs) const { + LLDB_RECORD_METHOD_CONST( + bool, SBLineEntry, operator!=,(const lldb::SBLineEntry &), rhs); + lldb_private::LineEntry *lhs_ptr = m_opaque_up.get(); lldb_private::LineEntry *rhs_ptr = rhs.m_opaque_up.get(); @@ -168,6 +206,9 @@ lldb_private::LineEntry &SBLineEntry::ref() { const lldb_private::LineEntry &SBLineEntry::ref() const { return *m_opaque_up; } bool SBLineEntry::GetDescription(SBStream &description) { + LLDB_RECORD_METHOD(bool, SBLineEntry, GetDescription, (lldb::SBStream &), + description); + Stream &strm = description.ref(); if (m_opaque_up) { diff --git a/lldb/source/API/SBListener.cpp b/lldb/source/API/SBListener.cpp index cde879dbead..1f74d57a359 100644 --- a/lldb/source/API/SBListener.cpp +++ b/lldb/source/API/SBListener.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBListener.h" +#include "SBReproducerPrivate.h" #include "lldb/API/SBBroadcaster.h" #include "lldb/API/SBDebugger.h" #include "lldb/API/SBEvent.h" @@ -20,10 +21,14 @@ using namespace lldb; using namespace lldb_private; -SBListener::SBListener() : m_opaque_sp(), m_unused_ptr(NULL) {} +SBListener::SBListener() : m_opaque_sp(), m_unused_ptr(NULL) { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBListener); +} SBListener::SBListener(const char *name) : m_opaque_sp(Listener::MakeListener(name)), m_unused_ptr(nullptr) { + LLDB_RECORD_CONSTRUCTOR(SBListener, (const char *), name); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) @@ -32,9 +37,14 @@ SBListener::SBListener(const char *name) } SBListener::SBListener(const SBListener &rhs) - : m_opaque_sp(rhs.m_opaque_sp), m_unused_ptr(nullptr) {} + : m_opaque_sp(rhs.m_opaque_sp), m_unused_ptr(nullptr) { + LLDB_RECORD_CONSTRUCTOR(SBListener, (const lldb::SBListener &), rhs); +} const lldb::SBListener &SBListener::operator=(const lldb::SBListener &rhs) { + LLDB_RECORD_METHOD(const lldb::SBListener &, + SBListener, operator=,(const lldb::SBListener &), rhs); + if (this != &rhs) { m_opaque_sp = rhs.m_opaque_sp; m_unused_ptr = nullptr; @@ -47,15 +57,24 @@ SBListener::SBListener(const lldb::ListenerSP &listener_sp) SBListener::~SBListener() {} -bool SBListener::IsValid() const { return m_opaque_sp != nullptr; } +bool SBListener::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBListener, IsValid); + + return m_opaque_sp != nullptr; +} void SBListener::AddEvent(const SBEvent &event) { + LLDB_RECORD_METHOD(void, SBListener, AddEvent, (const lldb::SBEvent &), + event); + EventSP &event_sp = event.GetSP(); if (event_sp) m_opaque_sp->AddEvent(event_sp); } void SBListener::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBListener, Clear); + if (m_opaque_sp) m_opaque_sp->Clear(); } @@ -63,6 +82,10 @@ void SBListener::Clear() { uint32_t SBListener::StartListeningForEventClass(SBDebugger &debugger, const char *broadcaster_class, uint32_t event_mask) { + LLDB_RECORD_METHOD(uint32_t, SBListener, StartListeningForEventClass, + (lldb::SBDebugger &, const char *, uint32_t), debugger, + broadcaster_class, event_mask); + if (m_opaque_sp) { Debugger *lldb_debugger = debugger.get(); if (!lldb_debugger) @@ -77,6 +100,10 @@ uint32_t SBListener::StartListeningForEventClass(SBDebugger &debugger, bool SBListener::StopListeningForEventClass(SBDebugger &debugger, const char *broadcaster_class, uint32_t event_mask) { + LLDB_RECORD_METHOD(bool, SBListener, StopListeningForEventClass, + (lldb::SBDebugger &, const char *, uint32_t), debugger, + broadcaster_class, event_mask); + if (m_opaque_sp) { Debugger *lldb_debugger = debugger.get(); if (!lldb_debugger) @@ -90,6 +117,10 @@ bool SBListener::StopListeningForEventClass(SBDebugger &debugger, uint32_t SBListener::StartListeningForEvents(const SBBroadcaster &broadcaster, uint32_t event_mask) { + LLDB_RECORD_METHOD(uint32_t, SBListener, StartListeningForEvents, + (const lldb::SBBroadcaster &, uint32_t), broadcaster, + event_mask); + uint32_t acquired_event_mask = 0; if (m_opaque_sp && broadcaster.IsValid()) { acquired_event_mask = @@ -131,6 +162,10 @@ uint32_t SBListener::StartListeningForEvents(const SBBroadcaster &broadcaster, bool SBListener::StopListeningForEvents(const SBBroadcaster &broadcaster, uint32_t event_mask) { + LLDB_RECORD_METHOD(bool, SBListener, StopListeningForEvents, + (const lldb::SBBroadcaster &, uint32_t), broadcaster, + event_mask); + if (m_opaque_sp && broadcaster.IsValid()) { return m_opaque_sp->StopListeningForEvents(broadcaster.get(), event_mask); } @@ -138,6 +173,9 @@ bool SBListener::StopListeningForEvents(const SBBroadcaster &broadcaster, } bool SBListener::WaitForEvent(uint32_t timeout_secs, SBEvent &event) { + LLDB_RECORD_METHOD(bool, SBListener, WaitForEvent, + (uint32_t, lldb::SBEvent &), timeout_secs, event); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) { if (timeout_secs == UINT32_MAX) { @@ -189,6 +227,10 @@ bool SBListener::WaitForEvent(uint32_t timeout_secs, SBEvent &event) { bool SBListener::WaitForEventForBroadcaster(uint32_t num_seconds, const SBBroadcaster &broadcaster, SBEvent &event) { + LLDB_RECORD_METHOD(bool, SBListener, WaitForEventForBroadcaster, + (uint32_t, const lldb::SBBroadcaster &, lldb::SBEvent &), + num_seconds, broadcaster, event); + if (m_opaque_sp && broadcaster.IsValid()) { Timeout<std::micro> timeout(llvm::None); if (num_seconds != UINT32_MAX) @@ -207,6 +249,11 @@ bool SBListener::WaitForEventForBroadcaster(uint32_t num_seconds, bool SBListener::WaitForEventForBroadcasterWithType( uint32_t num_seconds, const SBBroadcaster &broadcaster, uint32_t event_type_mask, SBEvent &event) { + LLDB_RECORD_METHOD( + bool, SBListener, WaitForEventForBroadcasterWithType, + (uint32_t, const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &), + num_seconds, broadcaster, event_type_mask, event); + if (m_opaque_sp && broadcaster.IsValid()) { Timeout<std::micro> timeout(llvm::None); if (num_seconds != UINT32_MAX) @@ -223,6 +270,9 @@ bool SBListener::WaitForEventForBroadcasterWithType( } bool SBListener::PeekAtNextEvent(SBEvent &event) { + LLDB_RECORD_METHOD(bool, SBListener, PeekAtNextEvent, (lldb::SBEvent &), + event); + if (m_opaque_sp) { event.reset(m_opaque_sp->PeekAtNextEvent()); return event.IsValid(); @@ -233,6 +283,10 @@ bool SBListener::PeekAtNextEvent(SBEvent &event) { bool SBListener::PeekAtNextEventForBroadcaster(const SBBroadcaster &broadcaster, SBEvent &event) { + LLDB_RECORD_METHOD(bool, SBListener, PeekAtNextEventForBroadcaster, + (const lldb::SBBroadcaster &, lldb::SBEvent &), + broadcaster, event); + if (m_opaque_sp && broadcaster.IsValid()) { event.reset(m_opaque_sp->PeekAtNextEventForBroadcaster(broadcaster.get())); return event.IsValid(); @@ -244,6 +298,10 @@ bool SBListener::PeekAtNextEventForBroadcaster(const SBBroadcaster &broadcaster, bool SBListener::PeekAtNextEventForBroadcasterWithType( const SBBroadcaster &broadcaster, uint32_t event_type_mask, SBEvent &event) { + LLDB_RECORD_METHOD(bool, SBListener, PeekAtNextEventForBroadcasterWithType, + (const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &), + broadcaster, event_type_mask, event); + if (m_opaque_sp && broadcaster.IsValid()) { event.reset(m_opaque_sp->PeekAtNextEventForBroadcasterWithType( broadcaster.get(), event_type_mask)); @@ -254,6 +312,8 @@ bool SBListener::PeekAtNextEventForBroadcasterWithType( } bool SBListener::GetNextEvent(SBEvent &event) { + LLDB_RECORD_METHOD(bool, SBListener, GetNextEvent, (lldb::SBEvent &), event); + if (m_opaque_sp) { EventSP event_sp; if (m_opaque_sp->GetEvent(event_sp, std::chrono::seconds(0))) { @@ -267,6 +327,10 @@ bool SBListener::GetNextEvent(SBEvent &event) { bool SBListener::GetNextEventForBroadcaster(const SBBroadcaster &broadcaster, SBEvent &event) { + LLDB_RECORD_METHOD(bool, SBListener, GetNextEventForBroadcaster, + (const lldb::SBBroadcaster &, lldb::SBEvent &), + broadcaster, event); + if (m_opaque_sp && broadcaster.IsValid()) { EventSP event_sp; if (m_opaque_sp->GetEventForBroadcaster(broadcaster.get(), event_sp, @@ -282,6 +346,10 @@ bool SBListener::GetNextEventForBroadcaster(const SBBroadcaster &broadcaster, bool SBListener::GetNextEventForBroadcasterWithType( const SBBroadcaster &broadcaster, uint32_t event_type_mask, SBEvent &event) { + LLDB_RECORD_METHOD(bool, SBListener, GetNextEventForBroadcasterWithType, + (const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &), + broadcaster, event_type_mask, event); + if (m_opaque_sp && broadcaster.IsValid()) { EventSP event_sp; if (m_opaque_sp->GetEventForBroadcasterWithType(broadcaster.get(), @@ -296,6 +364,9 @@ bool SBListener::GetNextEventForBroadcasterWithType( } bool SBListener::HandleBroadcastEvent(const SBEvent &event) { + LLDB_RECORD_METHOD(bool, SBListener, HandleBroadcastEvent, + (const lldb::SBEvent &), event); + if (m_opaque_sp) return m_opaque_sp->HandleBroadcastEvent(event.GetSP()); return false; diff --git a/lldb/source/API/SBMemoryRegionInfo.cpp b/lldb/source/API/SBMemoryRegionInfo.cpp index bbb2173badf..e3ebc97a985 100644 --- a/lldb/source/API/SBMemoryRegionInfo.cpp +++ b/lldb/source/API/SBMemoryRegionInfo.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBMemoryRegionInfo.h" +#include "SBReproducerPrivate.h" #include "Utils.h" #include "lldb/API/SBDefines.h" #include "lldb/API/SBError.h" @@ -17,8 +18,9 @@ using namespace lldb; using namespace lldb_private; -SBMemoryRegionInfo::SBMemoryRegionInfo() - : m_opaque_up(new MemoryRegionInfo()) {} +SBMemoryRegionInfo::SBMemoryRegionInfo() : m_opaque_up(new MemoryRegionInfo()) { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBMemoryRegionInfo); +} SBMemoryRegionInfo::SBMemoryRegionInfo(const MemoryRegionInfo *lldb_object_ptr) : m_opaque_up(new MemoryRegionInfo()) { @@ -28,11 +30,17 @@ SBMemoryRegionInfo::SBMemoryRegionInfo(const MemoryRegionInfo *lldb_object_ptr) SBMemoryRegionInfo::SBMemoryRegionInfo(const SBMemoryRegionInfo &rhs) : m_opaque_up() { + LLDB_RECORD_CONSTRUCTOR(SBMemoryRegionInfo, + (const lldb::SBMemoryRegionInfo &), rhs); m_opaque_up = clone(rhs.m_opaque_up); } const SBMemoryRegionInfo &SBMemoryRegionInfo:: operator=(const SBMemoryRegionInfo &rhs) { + LLDB_RECORD_METHOD( + const lldb::SBMemoryRegionInfo &, + SBMemoryRegionInfo, operator=,(const lldb::SBMemoryRegionInfo &), rhs); + if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); return *this; @@ -40,13 +48,25 @@ operator=(const SBMemoryRegionInfo &rhs) { SBMemoryRegionInfo::~SBMemoryRegionInfo() {} -void SBMemoryRegionInfo::Clear() { m_opaque_up->Clear(); } +void SBMemoryRegionInfo::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBMemoryRegionInfo, Clear); + + m_opaque_up->Clear(); +} bool SBMemoryRegionInfo::operator==(const SBMemoryRegionInfo &rhs) const { + LLDB_RECORD_METHOD_CONST( + bool, SBMemoryRegionInfo, operator==,(const lldb::SBMemoryRegionInfo &), + rhs); + return ref() == rhs.ref(); } bool SBMemoryRegionInfo::operator!=(const SBMemoryRegionInfo &rhs) const { + LLDB_RECORD_METHOD_CONST( + bool, SBMemoryRegionInfo, operator!=,(const lldb::SBMemoryRegionInfo &), + rhs); + return ref() != rhs.ref(); } @@ -55,34 +75,51 @@ MemoryRegionInfo &SBMemoryRegionInfo::ref() { return *m_opaque_up; } const MemoryRegionInfo &SBMemoryRegionInfo::ref() const { return *m_opaque_up; } lldb::addr_t SBMemoryRegionInfo::GetRegionBase() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBMemoryRegionInfo, GetRegionBase); + return m_opaque_up->GetRange().GetRangeBase(); } lldb::addr_t SBMemoryRegionInfo::GetRegionEnd() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBMemoryRegionInfo, GetRegionEnd); + return m_opaque_up->GetRange().GetRangeEnd(); } bool SBMemoryRegionInfo::IsReadable() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsReadable); + return m_opaque_up->GetReadable() == MemoryRegionInfo::eYes; } bool SBMemoryRegionInfo::IsWritable() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsWritable); + return m_opaque_up->GetWritable() == MemoryRegionInfo::eYes; } bool SBMemoryRegionInfo::IsExecutable() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsExecutable); + return m_opaque_up->GetExecutable() == MemoryRegionInfo::eYes; } bool SBMemoryRegionInfo::IsMapped() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsMapped); + return m_opaque_up->GetMapped() == MemoryRegionInfo::eYes; } const char *SBMemoryRegionInfo::GetName() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBMemoryRegionInfo, GetName); + return m_opaque_up->GetName().AsCString(); } bool SBMemoryRegionInfo::GetDescription(SBStream &description) { + LLDB_RECORD_METHOD(bool, SBMemoryRegionInfo, GetDescription, + (lldb::SBStream &), description); + Stream &strm = description.ref(); const addr_t load_addr = m_opaque_up->GetRange().base; diff --git a/lldb/source/API/SBMemoryRegionInfoList.cpp b/lldb/source/API/SBMemoryRegionInfoList.cpp index a0104b98ed7..eebedc87568 100644 --- a/lldb/source/API/SBMemoryRegionInfoList.cpp +++ b/lldb/source/API/SBMemoryRegionInfoList.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBMemoryRegionInfoList.h" +#include "SBReproducerPrivate.h" #include "lldb/API/SBMemoryRegionInfo.h" #include "lldb/API/SBStream.h" #include "lldb/Target/MemoryRegionInfo.h" @@ -71,16 +72,26 @@ const MemoryRegionInfos &SBMemoryRegionInfoList::ref() const { } SBMemoryRegionInfoList::SBMemoryRegionInfoList() - : m_opaque_up(new MemoryRegionInfoListImpl()) {} + : m_opaque_up(new MemoryRegionInfoListImpl()) { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBMemoryRegionInfoList); +} SBMemoryRegionInfoList::SBMemoryRegionInfoList( const SBMemoryRegionInfoList &rhs) - : m_opaque_up(new MemoryRegionInfoListImpl(*rhs.m_opaque_up)) {} + : m_opaque_up(new MemoryRegionInfoListImpl(*rhs.m_opaque_up)) { + LLDB_RECORD_CONSTRUCTOR(SBMemoryRegionInfoList, + (const lldb::SBMemoryRegionInfoList &), rhs); +} SBMemoryRegionInfoList::~SBMemoryRegionInfoList() {} const SBMemoryRegionInfoList &SBMemoryRegionInfoList:: operator=(const SBMemoryRegionInfoList &rhs) { + LLDB_RECORD_METHOD( + const lldb::SBMemoryRegionInfoList &, + SBMemoryRegionInfoList, operator=,(const lldb::SBMemoryRegionInfoList &), + rhs); + if (this != &rhs) { *m_opaque_up = *rhs.m_opaque_up; } @@ -88,11 +99,16 @@ operator=(const SBMemoryRegionInfoList &rhs) { } uint32_t SBMemoryRegionInfoList::GetSize() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBMemoryRegionInfoList, GetSize); + return m_opaque_up->GetSize(); } bool SBMemoryRegionInfoList::GetMemoryRegionAtIndex( uint32_t idx, SBMemoryRegionInfo ®ion_info) { + LLDB_RECORD_METHOD(bool, SBMemoryRegionInfoList, GetMemoryRegionAtIndex, + (uint32_t, lldb::SBMemoryRegionInfo &), idx, region_info); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); bool result = m_opaque_up->GetMemoryRegionInfoAtIndex(idx, region_info.ref()); @@ -110,13 +126,23 @@ bool SBMemoryRegionInfoList::GetMemoryRegionAtIndex( return result; } -void SBMemoryRegionInfoList::Clear() { m_opaque_up->Clear(); } +void SBMemoryRegionInfoList::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBMemoryRegionInfoList, Clear); + + m_opaque_up->Clear(); +} void SBMemoryRegionInfoList::Append(SBMemoryRegionInfo &sb_region) { + LLDB_RECORD_METHOD(void, SBMemoryRegionInfoList, Append, + (lldb::SBMemoryRegionInfo &), sb_region); + m_opaque_up->Append(sb_region.ref()); } void SBMemoryRegionInfoList::Append(SBMemoryRegionInfoList &sb_region_list) { + LLDB_RECORD_METHOD(void, SBMemoryRegionInfoList, Append, + (lldb::SBMemoryRegionInfoList &), sb_region_list); + m_opaque_up->Append(*sb_region_list); } diff --git a/lldb/source/API/SBModule.cpp b/lldb/source/API/SBModule.cpp index a7886b034bd..ed80449b7cb 100644 --- a/lldb/source/API/SBModule.cpp +++ b/lldb/source/API/SBModule.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBModule.h" +#include "SBReproducerPrivate.h" #include "lldb/API/SBAddress.h" #include "lldb/API/SBFileSpec.h" #include "lldb/API/SBModuleSpec.h" @@ -30,11 +31,15 @@ using namespace lldb; using namespace lldb_private; -SBModule::SBModule() : m_opaque_sp() {} +SBModule::SBModule() : m_opaque_sp() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBModule); +} SBModule::SBModule(const lldb::ModuleSP &module_sp) : m_opaque_sp(module_sp) {} SBModule::SBModule(const SBModuleSpec &module_spec) : m_opaque_sp() { + LLDB_RECORD_CONSTRUCTOR(SBModule, (const lldb::SBModuleSpec &), module_spec); + ModuleSP module_sp; Status error = ModuleList::GetSharedModule(*module_spec.m_opaque_up, module_sp, NULL, NULL, NULL); @@ -42,10 +47,15 @@ SBModule::SBModule(const SBModuleSpec &module_spec) : m_opaque_sp() { SetSP(module_sp); } -SBModule::SBModule(const SBModule &rhs) : m_opaque_sp(rhs.m_opaque_sp) {} +SBModule::SBModule(const SBModule &rhs) : m_opaque_sp(rhs.m_opaque_sp) { + LLDB_RECORD_CONSTRUCTOR(SBModule, (const lldb::SBModule &), rhs); +} SBModule::SBModule(lldb::SBProcess &process, lldb::addr_t header_addr) : m_opaque_sp() { + LLDB_RECORD_CONSTRUCTOR(SBModule, (lldb::SBProcess &, lldb::addr_t), process, + header_addr); + ProcessSP process_sp(process.GetSP()); if (process_sp) { m_opaque_sp = process_sp->ReadModuleFromMemory(FileSpec(), header_addr); @@ -59,6 +69,9 @@ SBModule::SBModule(lldb::SBProcess &process, lldb::addr_t header_addr) } const SBModule &SBModule::operator=(const SBModule &rhs) { + LLDB_RECORD_METHOD(const lldb::SBModule &, + SBModule, operator=,(const lldb::SBModule &), rhs); + if (this != &rhs) m_opaque_sp = rhs.m_opaque_sp; return *this; @@ -66,11 +79,21 @@ const SBModule &SBModule::operator=(const SBModule &rhs) { SBModule::~SBModule() {} -bool SBModule::IsValid() const { return m_opaque_sp.get() != NULL; } +bool SBModule::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModule, IsValid); + + return m_opaque_sp.get() != NULL; +} + +void SBModule::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBModule, Clear); -void SBModule::Clear() { m_opaque_sp.reset(); } + m_opaque_sp.reset(); +} SBFileSpec SBModule::GetFileSpec() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule, GetFileSpec); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBFileSpec file_spec; @@ -83,10 +106,13 @@ SBFileSpec SBModule::GetFileSpec() const { static_cast<void *>(module_sp.get()), static_cast<const void *>(file_spec.get())); - return file_spec; + return LLDB_RECORD_RESULT(file_spec); } lldb::SBFileSpec SBModule::GetPlatformFileSpec() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule, + GetPlatformFileSpec); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBFileSpec file_spec; @@ -99,10 +125,13 @@ lldb::SBFileSpec SBModule::GetPlatformFileSpec() const { static_cast<void *>(module_sp.get()), static_cast<const void *>(file_spec.get())); - return file_spec; + return LLDB_RECORD_RESULT(file_spec); } bool SBModule::SetPlatformFileSpec(const lldb::SBFileSpec &platform_file) { + LLDB_RECORD_METHOD(bool, SBModule, SetPlatformFileSpec, + (const lldb::SBFileSpec &), platform_file); + bool result = false; Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); @@ -121,14 +150,20 @@ bool SBModule::SetPlatformFileSpec(const lldb::SBFileSpec &platform_file) { } lldb::SBFileSpec SBModule::GetRemoteInstallFileSpec() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModule, + GetRemoteInstallFileSpec); + SBFileSpec sb_file_spec; ModuleSP module_sp(GetSP()); if (module_sp) sb_file_spec.SetFileSpec(module_sp->GetRemoteInstallFileSpec()); - return sb_file_spec; + return LLDB_RECORD_RESULT(sb_file_spec); } bool SBModule::SetRemoteInstallFileSpec(lldb::SBFileSpec &file) { + LLDB_RECORD_METHOD(bool, SBModule, SetRemoteInstallFileSpec, + (lldb::SBFileSpec &), file); + ModuleSP module_sp(GetSP()); if (module_sp) { module_sp->SetRemoteInstallFileSpec(file.ref()); @@ -138,6 +173,8 @@ bool SBModule::SetRemoteInstallFileSpec(lldb::SBFileSpec &file) { } const uint8_t *SBModule::GetUUIDBytes() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const uint8_t *, SBModule, GetUUIDBytes); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); const uint8_t *uuid_bytes = NULL; @@ -159,6 +196,8 @@ const uint8_t *SBModule::GetUUIDBytes() const { } const char *SBModule::GetUUIDString() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBModule, GetUUIDString); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); const char *uuid_cstr = NULL; @@ -185,12 +224,18 @@ const char *SBModule::GetUUIDString() const { } bool SBModule::operator==(const SBModule &rhs) const { + LLDB_RECORD_METHOD_CONST(bool, SBModule, operator==,(const lldb::SBModule &), + rhs); + if (m_opaque_sp) return m_opaque_sp.get() == rhs.m_opaque_sp.get(); return false; } bool SBModule::operator!=(const SBModule &rhs) const { + LLDB_RECORD_METHOD_CONST(bool, SBModule, operator!=,(const lldb::SBModule &), + rhs); + if (m_opaque_sp) return m_opaque_sp.get() != rhs.m_opaque_sp.get(); return false; @@ -201,6 +246,9 @@ ModuleSP SBModule::GetSP() const { return m_opaque_sp; } void SBModule::SetSP(const ModuleSP &module_sp) { m_opaque_sp = module_sp; } SBAddress SBModule::ResolveFileAddress(lldb::addr_t vm_addr) { + LLDB_RECORD_METHOD(lldb::SBAddress, SBModule, ResolveFileAddress, + (lldb::addr_t), vm_addr); + lldb::SBAddress sb_addr; ModuleSP module_sp(GetSP()); if (module_sp) { @@ -208,21 +256,28 @@ SBAddress SBModule::ResolveFileAddress(lldb::addr_t vm_addr) { if (module_sp->ResolveFileAddress(vm_addr, addr)) sb_addr.ref() = addr; } - return sb_addr; + return LLDB_RECORD_RESULT(sb_addr); } SBSymbolContext SBModule::ResolveSymbolContextForAddress(const SBAddress &addr, uint32_t resolve_scope) { + LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBModule, + ResolveSymbolContextForAddress, + (const lldb::SBAddress &, uint32_t), addr, resolve_scope); + SBSymbolContext sb_sc; ModuleSP module_sp(GetSP()); SymbolContextItem scope = static_cast<SymbolContextItem>(resolve_scope); if (module_sp && addr.IsValid()) module_sp->ResolveSymbolContextForAddress(addr.ref(), scope, *sb_sc); - return sb_sc; + return LLDB_RECORD_RESULT(sb_sc); } bool SBModule::GetDescription(SBStream &description) { + LLDB_RECORD_METHOD(bool, SBModule, GetDescription, (lldb::SBStream &), + description); + Stream &strm = description.ref(); ModuleSP module_sp(GetSP()); @@ -235,6 +290,8 @@ bool SBModule::GetDescription(SBStream &description) { } uint32_t SBModule::GetNumCompileUnits() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBModule, GetNumCompileUnits); + ModuleSP module_sp(GetSP()); if (module_sp) { return module_sp->GetNumCompileUnits(); @@ -243,24 +300,29 @@ uint32_t SBModule::GetNumCompileUnits() { } SBCompileUnit SBModule::GetCompileUnitAtIndex(uint32_t index) { + LLDB_RECORD_METHOD(lldb::SBCompileUnit, SBModule, GetCompileUnitAtIndex, + (uint32_t), index); + SBCompileUnit sb_cu; ModuleSP module_sp(GetSP()); if (module_sp) { CompUnitSP cu_sp = module_sp->GetCompileUnitAtIndex(index); sb_cu.reset(cu_sp.get()); } - return sb_cu; + return LLDB_RECORD_RESULT(sb_cu); } -SBSymbolContextList -SBModule::FindCompileUnits(const SBFileSpec &sb_file_spec) { +SBSymbolContextList SBModule::FindCompileUnits(const SBFileSpec &sb_file_spec) { + LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBModule, FindCompileUnits, + (const lldb::SBFileSpec &), sb_file_spec); + SBSymbolContextList sb_sc_list; const ModuleSP module_sp(GetSP()); if (sb_file_spec.IsValid() && module_sp) { const bool append = true; module_sp->FindCompileUnits(*sb_file_spec, append, *sb_sc_list); } - return sb_sc_list; + return LLDB_RECORD_RESULT(sb_sc_list); } static Symtab *GetUnifiedSymbolTable(const lldb::ModuleSP &module_sp) { @@ -273,6 +335,8 @@ static Symtab *GetUnifiedSymbolTable(const lldb::ModuleSP &module_sp) { } size_t SBModule::GetNumSymbols() { + LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModule, GetNumSymbols); + ModuleSP module_sp(GetSP()); if (module_sp) { Symtab *symtab = GetUnifiedSymbolTable(module_sp); @@ -283,16 +347,21 @@ size_t SBModule::GetNumSymbols() { } SBSymbol SBModule::GetSymbolAtIndex(size_t idx) { + LLDB_RECORD_METHOD(lldb::SBSymbol, SBModule, GetSymbolAtIndex, (size_t), idx); + SBSymbol sb_symbol; ModuleSP module_sp(GetSP()); Symtab *symtab = GetUnifiedSymbolTable(module_sp); if (symtab) sb_symbol.SetSymbol(symtab->SymbolAtIndex(idx)); - return sb_symbol; + return LLDB_RECORD_RESULT(sb_symbol); } lldb::SBSymbol SBModule::FindSymbol(const char *name, lldb::SymbolType symbol_type) { + LLDB_RECORD_METHOD(lldb::SBSymbol, SBModule, FindSymbol, + (const char *, lldb::SymbolType), name, symbol_type); + SBSymbol sb_symbol; if (name && name[0]) { ModuleSP module_sp(GetSP()); @@ -302,11 +371,14 @@ lldb::SBSymbol SBModule::FindSymbol(const char *name, ConstString(name), symbol_type, Symtab::eDebugAny, Symtab::eVisibilityAny)); } - return sb_symbol; + return LLDB_RECORD_RESULT(sb_symbol); } lldb::SBSymbolContextList SBModule::FindSymbols(const char *name, lldb::SymbolType symbol_type) { + LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBModule, FindSymbols, + (const char *, lldb::SymbolType), name, symbol_type); + SBSymbolContextList sb_sc_list; if (name && name[0]) { ModuleSP module_sp(GetSP()); @@ -327,10 +399,12 @@ lldb::SBSymbolContextList SBModule::FindSymbols(const char *name, } } } - return sb_sc_list; + return LLDB_RECORD_RESULT(sb_sc_list); } size_t SBModule::GetNumSections() { + LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModule, GetNumSections); + ModuleSP module_sp(GetSP()); if (module_sp) { // Give the symbol vendor a chance to add to the unified section list. @@ -343,6 +417,9 @@ size_t SBModule::GetNumSections() { } SBSection SBModule::GetSectionAtIndex(size_t idx) { + LLDB_RECORD_METHOD(lldb::SBSection, SBModule, GetSectionAtIndex, (size_t), + idx); + SBSection sb_section; ModuleSP module_sp(GetSP()); if (module_sp) { @@ -353,11 +430,14 @@ SBSection SBModule::GetSectionAtIndex(size_t idx) { if (section_list) sb_section.SetSP(section_list->GetSectionAtIndex(idx)); } - return sb_section; + return LLDB_RECORD_RESULT(sb_section); } lldb::SBSymbolContextList SBModule::FindFunctions(const char *name, uint32_t name_type_mask) { + LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBModule, FindFunctions, + (const char *, uint32_t), name, name_type_mask); + lldb::SBSymbolContextList sb_sc_list; ModuleSP module_sp(GetSP()); if (name && module_sp) { @@ -368,11 +448,15 @@ lldb::SBSymbolContextList SBModule::FindFunctions(const char *name, module_sp->FindFunctions(ConstString(name), NULL, type, symbols_ok, inlines_ok, append, *sb_sc_list); } - return sb_sc_list; + return LLDB_RECORD_RESULT(sb_sc_list); } SBValueList SBModule::FindGlobalVariables(SBTarget &target, const char *name, uint32_t max_matches) { + LLDB_RECORD_METHOD(lldb::SBValueList, SBModule, FindGlobalVariables, + (lldb::SBTarget &, const char *, uint32_t), target, name, + max_matches); + SBValueList sb_value_list; ModuleSP module_sp(GetSP()); if (name && module_sp) { @@ -392,18 +476,24 @@ SBValueList SBModule::FindGlobalVariables(SBTarget &target, const char *name, } } - return sb_value_list; + return LLDB_RECORD_RESULT(sb_value_list); } lldb::SBValue SBModule::FindFirstGlobalVariable(lldb::SBTarget &target, const char *name) { + LLDB_RECORD_METHOD(lldb::SBValue, SBModule, FindFirstGlobalVariable, + (lldb::SBTarget &, const char *), target, name); + SBValueList sb_value_list(FindGlobalVariables(target, name, 1)); if (sb_value_list.IsValid() && sb_value_list.GetSize() > 0) - return sb_value_list.GetValueAtIndex(0); - return SBValue(); + return LLDB_RECORD_RESULT(sb_value_list.GetValueAtIndex(0)); + return LLDB_RECORD_RESULT(SBValue()); } lldb::SBType SBModule::FindFirstType(const char *name_cstr) { + LLDB_RECORD_METHOD(lldb::SBType, SBModule, FindFirstType, (const char *), + name_cstr); + SBType sb_type; ModuleSP module_sp(GetSP()); if (name_cstr && module_sp) { @@ -420,21 +510,27 @@ lldb::SBType SBModule::FindFirstType(const char *name_cstr) { sb_type = SBType(type_system->GetBuiltinTypeByName(name)); } } - return sb_type; + return LLDB_RECORD_RESULT(sb_type); } lldb::SBType SBModule::GetBasicType(lldb::BasicType type) { + LLDB_RECORD_METHOD(lldb::SBType, SBModule, GetBasicType, (lldb::BasicType), + type); + ModuleSP module_sp(GetSP()); if (module_sp) { TypeSystem *type_system = module_sp->GetTypeSystemForLanguage(eLanguageTypeC); if (type_system) - return SBType(type_system->GetBasicTypeFromAST(type)); + return LLDB_RECORD_RESULT(SBType(type_system->GetBasicTypeFromAST(type))); } - return SBType(); + return LLDB_RECORD_RESULT(SBType()); } lldb::SBTypeList SBModule::FindTypes(const char *type) { + LLDB_RECORD_METHOD(lldb::SBTypeList, SBModule, FindTypes, (const char *), + type); + SBTypeList retval; ModuleSP module_sp(GetSP()); @@ -463,40 +559,49 @@ lldb::SBTypeList SBModule::FindTypes(const char *type) { } } - return retval; + return LLDB_RECORD_RESULT(retval); } lldb::SBType SBModule::GetTypeByID(lldb::user_id_t uid) { + LLDB_RECORD_METHOD(lldb::SBType, SBModule, GetTypeByID, (lldb::user_id_t), + uid); + ModuleSP module_sp(GetSP()); if (module_sp) { SymbolVendor *vendor = module_sp->GetSymbolVendor(); if (vendor) { Type *type_ptr = vendor->ResolveTypeUID(uid); if (type_ptr) - return SBType(type_ptr->shared_from_this()); + return LLDB_RECORD_RESULT(SBType(type_ptr->shared_from_this())); } } - return SBType(); + return LLDB_RECORD_RESULT(SBType()); } lldb::SBTypeList SBModule::GetTypes(uint32_t type_mask) { + LLDB_RECORD_METHOD(lldb::SBTypeList, SBModule, GetTypes, (uint32_t), + type_mask); + SBTypeList sb_type_list; ModuleSP module_sp(GetSP()); if (!module_sp) - return sb_type_list; + return LLDB_RECORD_RESULT(sb_type_list); SymbolVendor *vendor = module_sp->GetSymbolVendor(); if (!vendor) - return sb_type_list; + return LLDB_RECORD_RESULT(sb_type_list); TypeClass type_class = static_cast<TypeClass>(type_mask); TypeList type_list; vendor->GetTypes(NULL, type_class, type_list); sb_type_list.m_opaque_up->Append(type_list); - return sb_type_list; + return LLDB_RECORD_RESULT(sb_type_list); } SBSection SBModule::FindSection(const char *sect_name) { + LLDB_RECORD_METHOD(lldb::SBSection, SBModule, FindSection, (const char *), + sect_name); + SBSection sb_section; ModuleSP module_sp(GetSP()); @@ -512,10 +617,12 @@ SBSection SBModule::FindSection(const char *sect_name) { } } } - return sb_section; + return LLDB_RECORD_RESULT(sb_section); } lldb::ByteOrder SBModule::GetByteOrder() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::ByteOrder, SBModule, GetByteOrder); + ModuleSP module_sp(GetSP()); if (module_sp) return module_sp->GetArchitecture().GetByteOrder(); @@ -523,6 +630,8 @@ lldb::ByteOrder SBModule::GetByteOrder() { } const char *SBModule::GetTriple() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBModule, GetTriple); + ModuleSP module_sp(GetSP()); if (module_sp) { std::string triple(module_sp->GetArchitecture().GetTriple().str()); @@ -536,6 +645,8 @@ const char *SBModule::GetTriple() { } uint32_t SBModule::GetAddressByteSize() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBModule, GetAddressByteSize); + ModuleSP module_sp(GetSP()); if (module_sp) return module_sp->GetArchitecture().GetAddressByteSize(); @@ -543,6 +654,9 @@ uint32_t SBModule::GetAddressByteSize() { } uint32_t SBModule::GetVersion(uint32_t *versions, uint32_t num_versions) { + LLDB_RECORD_METHOD(uint32_t, SBModule, GetVersion, (uint32_t *, uint32_t), + versions, num_versions); + llvm::VersionTuple version; if (ModuleSP module_sp = GetSP()) version = module_sp->GetVersion(); @@ -569,6 +683,9 @@ uint32_t SBModule::GetVersion(uint32_t *versions, uint32_t num_versions) { } lldb::SBFileSpec SBModule::GetSymbolFileSpec() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule, + GetSymbolFileSpec); + lldb::SBFileSpec sb_file_spec; ModuleSP module_sp(GetSP()); if (module_sp) { @@ -576,10 +693,13 @@ lldb::SBFileSpec SBModule::GetSymbolFileSpec() const { if (symbol_vendor_ptr) sb_file_spec.SetFileSpec(symbol_vendor_ptr->GetMainFileSpec()); } - return sb_file_spec; + return LLDB_RECORD_RESULT(sb_file_spec); } lldb::SBAddress SBModule::GetObjectFileHeaderAddress() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBModule, + GetObjectFileHeaderAddress); + lldb::SBAddress sb_addr; ModuleSP module_sp(GetSP()); if (module_sp) { @@ -587,10 +707,13 @@ lldb::SBAddress SBModule::GetObjectFileHeaderAddress() const { if (objfile_ptr) sb_addr.ref() = objfile_ptr->GetBaseAddress(); } - return sb_addr; + return LLDB_RECORD_RESULT(sb_addr); } lldb::SBAddress SBModule::GetObjectFileEntryPointAddress() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBModule, + GetObjectFileEntryPointAddress); + lldb::SBAddress sb_addr; ModuleSP module_sp(GetSP()); if (module_sp) { @@ -598,5 +721,5 @@ lldb::SBAddress SBModule::GetObjectFileEntryPointAddress() const { if (objfile_ptr) sb_addr.ref() = objfile_ptr->GetEntryPointAddress(); } - return sb_addr; + return LLDB_RECORD_RESULT(sb_addr); } diff --git a/lldb/source/API/SBModuleSpec.cpp b/lldb/source/API/SBModuleSpec.cpp index fa34cff05c3..918b17f7cb2 100644 --- a/lldb/source/API/SBModuleSpec.cpp +++ b/lldb/source/API/SBModuleSpec.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBModuleSpec.h" +#include "SBReproducerPrivate.h" #include "Utils.h" #include "lldb/API/SBStream.h" #include "lldb/Core/Module.h" @@ -18,13 +19,20 @@ using namespace lldb; using namespace lldb_private; -SBModuleSpec::SBModuleSpec() : m_opaque_up(new lldb_private::ModuleSpec()) {} +SBModuleSpec::SBModuleSpec() : m_opaque_up(new lldb_private::ModuleSpec()) { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBModuleSpec); +} SBModuleSpec::SBModuleSpec(const SBModuleSpec &rhs) : m_opaque_up() { + LLDB_RECORD_CONSTRUCTOR(SBModuleSpec, (const lldb::SBModuleSpec &), rhs); + m_opaque_up = clone(rhs.m_opaque_up); } const SBModuleSpec &SBModuleSpec::operator=(const SBModuleSpec &rhs) { + LLDB_RECORD_METHOD(const lldb::SBModuleSpec &, + SBModuleSpec, operator=,(const lldb::SBModuleSpec &), rhs); + if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); return *this; @@ -32,44 +40,74 @@ const SBModuleSpec &SBModuleSpec::operator=(const SBModuleSpec &rhs) { SBModuleSpec::~SBModuleSpec() {} -bool SBModuleSpec::IsValid() const { return m_opaque_up->operator bool(); } +bool SBModuleSpec::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModuleSpec, IsValid); + + return m_opaque_up->operator bool(); +} + +void SBModuleSpec::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBModuleSpec, Clear); -void SBModuleSpec::Clear() { m_opaque_up->Clear(); } + m_opaque_up->Clear(); +} SBFileSpec SBModuleSpec::GetFileSpec() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModuleSpec, GetFileSpec); + SBFileSpec sb_spec(m_opaque_up->GetFileSpec()); - return sb_spec; + return LLDB_RECORD_RESULT(sb_spec); } void SBModuleSpec::SetFileSpec(const lldb::SBFileSpec &sb_spec) { + LLDB_RECORD_METHOD(void, SBModuleSpec, SetFileSpec, + (const lldb::SBFileSpec &), sb_spec); + m_opaque_up->GetFileSpec() = *sb_spec; } lldb::SBFileSpec SBModuleSpec::GetPlatformFileSpec() { - return SBFileSpec(m_opaque_up->GetPlatformFileSpec()); + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModuleSpec, + GetPlatformFileSpec); + + return LLDB_RECORD_RESULT(SBFileSpec(m_opaque_up->GetPlatformFileSpec())); } void SBModuleSpec::SetPlatformFileSpec(const lldb::SBFileSpec &sb_spec) { + LLDB_RECORD_METHOD(void, SBModuleSpec, SetPlatformFileSpec, + (const lldb::SBFileSpec &), sb_spec); + m_opaque_up->GetPlatformFileSpec() = *sb_spec; } lldb::SBFileSpec SBModuleSpec::GetSymbolFileSpec() { - return SBFileSpec(m_opaque_up->GetSymbolFileSpec()); + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModuleSpec, GetSymbolFileSpec); + + return LLDB_RECORD_RESULT(SBFileSpec(m_opaque_up->GetSymbolFileSpec())); } void SBModuleSpec::SetSymbolFileSpec(const lldb::SBFileSpec &sb_spec) { + LLDB_RECORD_METHOD(void, SBModuleSpec, SetSymbolFileSpec, + (const lldb::SBFileSpec &), sb_spec); + m_opaque_up->GetSymbolFileSpec() = *sb_spec; } const char *SBModuleSpec::GetObjectName() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBModuleSpec, GetObjectName); + return m_opaque_up->GetObjectName().GetCString(); } void SBModuleSpec::SetObjectName(const char *name) { + LLDB_RECORD_METHOD(void, SBModuleSpec, SetObjectName, (const char *), name); + m_opaque_up->GetObjectName().SetCString(name); } const char *SBModuleSpec::GetTriple() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBModuleSpec, GetTriple); + std::string triple(m_opaque_up->GetArchitecture().GetTriple().str()); // Unique the string so we don't run into ownership issues since the const // strings put the string into the string pool once and the strings never @@ -79,6 +117,8 @@ const char *SBModuleSpec::GetTriple() { } void SBModuleSpec::SetTriple(const char *triple) { + LLDB_RECORD_METHOD(void, SBModuleSpec, SetTriple, (const char *), triple); + m_opaque_up->GetArchitecture().SetTriple(triple); } @@ -87,6 +127,8 @@ const uint8_t *SBModuleSpec::GetUUIDBytes() { } size_t SBModuleSpec::GetUUIDLength() { + LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModuleSpec, GetUUIDLength); + return m_opaque_up->GetUUID().GetBytes().size(); } @@ -96,16 +138,28 @@ bool SBModuleSpec::SetUUIDBytes(const uint8_t *uuid, size_t uuid_len) { } bool SBModuleSpec::GetDescription(lldb::SBStream &description) { + LLDB_RECORD_METHOD(bool, SBModuleSpec, GetDescription, (lldb::SBStream &), + description); + m_opaque_up->Dump(description.ref()); return true; } -SBModuleSpecList::SBModuleSpecList() : m_opaque_up(new ModuleSpecList()) {} +SBModuleSpecList::SBModuleSpecList() : m_opaque_up(new ModuleSpecList()) { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBModuleSpecList); +} SBModuleSpecList::SBModuleSpecList(const SBModuleSpecList &rhs) - : m_opaque_up(new ModuleSpecList(*rhs.m_opaque_up)) {} + : m_opaque_up(new ModuleSpecList(*rhs.m_opaque_up)) { + LLDB_RECORD_CONSTRUCTOR(SBModuleSpecList, (const lldb::SBModuleSpecList &), + rhs); +} SBModuleSpecList &SBModuleSpecList::operator=(const SBModuleSpecList &rhs) { + LLDB_RECORD_METHOD( + lldb::SBModuleSpecList &, + SBModuleSpecList, operator=,(const lldb::SBModuleSpecList &), rhs); + if (this != &rhs) *m_opaque_up = *rhs.m_opaque_up; return *this; @@ -114,47 +168,74 @@ SBModuleSpecList &SBModuleSpecList::operator=(const SBModuleSpecList &rhs) { SBModuleSpecList::~SBModuleSpecList() {} SBModuleSpecList SBModuleSpecList::GetModuleSpecifications(const char *path) { + LLDB_RECORD_STATIC_METHOD(lldb::SBModuleSpecList, SBModuleSpecList, + GetModuleSpecifications, (const char *), path); + SBModuleSpecList specs; FileSpec file_spec(path); FileSystem::Instance().Resolve(file_spec); Host::ResolveExecutableInBundle(file_spec); ObjectFile::GetModuleSpecifications(file_spec, 0, 0, *specs.m_opaque_up); - return specs; + return LLDB_RECORD_RESULT(specs); } void SBModuleSpecList::Append(const SBModuleSpec &spec) { + LLDB_RECORD_METHOD(void, SBModuleSpecList, Append, + (const lldb::SBModuleSpec &), spec); + m_opaque_up->Append(*spec.m_opaque_up); } void SBModuleSpecList::Append(const SBModuleSpecList &spec_list) { + LLDB_RECORD_METHOD(void, SBModuleSpecList, Append, + (const lldb::SBModuleSpecList &), spec_list); + m_opaque_up->Append(*spec_list.m_opaque_up); } -size_t SBModuleSpecList::GetSize() { return m_opaque_up->GetSize(); } +size_t SBModuleSpecList::GetSize() { + LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModuleSpecList, GetSize); + + return m_opaque_up->GetSize(); +} SBModuleSpec SBModuleSpecList::GetSpecAtIndex(size_t i) { + LLDB_RECORD_METHOD(lldb::SBModuleSpec, SBModuleSpecList, GetSpecAtIndex, + (size_t), i); + SBModuleSpec sb_module_spec; m_opaque_up->GetModuleSpecAtIndex(i, *sb_module_spec.m_opaque_up); - return sb_module_spec; + return LLDB_RECORD_RESULT(sb_module_spec); } SBModuleSpec SBModuleSpecList::FindFirstMatchingSpec(const SBModuleSpec &match_spec) { + LLDB_RECORD_METHOD(lldb::SBModuleSpec, SBModuleSpecList, + FindFirstMatchingSpec, (const lldb::SBModuleSpec &), + match_spec); + SBModuleSpec sb_module_spec; m_opaque_up->FindMatchingModuleSpec(*match_spec.m_opaque_up, *sb_module_spec.m_opaque_up); - return sb_module_spec; + return LLDB_RECORD_RESULT(sb_module_spec); } SBModuleSpecList SBModuleSpecList::FindMatchingSpecs(const SBModuleSpec &match_spec) { + LLDB_RECORD_METHOD(lldb::SBModuleSpecList, SBModuleSpecList, + FindMatchingSpecs, (const lldb::SBModuleSpec &), + match_spec); + SBModuleSpecList specs; m_opaque_up->FindMatchingModuleSpecs(*match_spec.m_opaque_up, *specs.m_opaque_up); - return specs; + return LLDB_RECORD_RESULT(specs); } bool SBModuleSpecList::GetDescription(lldb::SBStream &description) { + LLDB_RECORD_METHOD(bool, SBModuleSpecList, GetDescription, (lldb::SBStream &), + description); + m_opaque_up->Dump(description.ref()); return true; } diff --git a/lldb/source/API/SBPlatform.cpp b/lldb/source/API/SBPlatform.cpp index 46a2bff8af0..8031e8d00c6 100644 --- a/lldb/source/API/SBPlatform.cpp +++ b/lldb/source/API/SBPlatform.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBPlatform.h" +#include "SBReproducerPrivate.h" #include "lldb/API/SBError.h" #include "lldb/API/SBFileSpec.h" #include "lldb/API/SBLaunchInfo.h" @@ -70,27 +71,43 @@ struct PlatformShellCommand { // SBPlatformConnectOptions //---------------------------------------------------------------------- SBPlatformConnectOptions::SBPlatformConnectOptions(const char *url) - : m_opaque_ptr(new PlatformConnectOptions(url)) {} + : m_opaque_ptr(new PlatformConnectOptions(url)) { + LLDB_RECORD_CONSTRUCTOR(SBPlatformConnectOptions, (const char *), url); +} SBPlatformConnectOptions::SBPlatformConnectOptions( const SBPlatformConnectOptions &rhs) : m_opaque_ptr(new PlatformConnectOptions()) { + LLDB_RECORD_CONSTRUCTOR(SBPlatformConnectOptions, + (const lldb::SBPlatformConnectOptions &), rhs); + *m_opaque_ptr = *rhs.m_opaque_ptr; } SBPlatformConnectOptions::~SBPlatformConnectOptions() { delete m_opaque_ptr; } void SBPlatformConnectOptions::operator=(const SBPlatformConnectOptions &rhs) { + LLDB_RECORD_METHOD( + void, + SBPlatformConnectOptions, operator=,( + const lldb::SBPlatformConnectOptions &), + rhs); + *m_opaque_ptr = *rhs.m_opaque_ptr; } const char *SBPlatformConnectOptions::GetURL() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformConnectOptions, GetURL); + if (m_opaque_ptr->m_url.empty()) return NULL; return m_opaque_ptr->m_url.c_str(); } void SBPlatformConnectOptions::SetURL(const char *url) { + LLDB_RECORD_METHOD(void, SBPlatformConnectOptions, SetURL, (const char *), + url); + if (url && url[0]) m_opaque_ptr->m_url = url; else @@ -98,12 +115,18 @@ void SBPlatformConnectOptions::SetURL(const char *url) { } bool SBPlatformConnectOptions::GetRsyncEnabled() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBPlatformConnectOptions, GetRsyncEnabled); + return m_opaque_ptr->m_rsync_enabled; } void SBPlatformConnectOptions::EnableRsync( const char *options, const char *remote_path_prefix, bool omit_hostname_from_remote_path) { + LLDB_RECORD_METHOD(void, SBPlatformConnectOptions, EnableRsync, + (const char *, const char *, bool), options, + remote_path_prefix, omit_hostname_from_remote_path); + m_opaque_ptr->m_rsync_enabled = true; m_opaque_ptr->m_rsync_omit_hostname_from_remote_path = omit_hostname_from_remote_path; @@ -119,14 +142,22 @@ void SBPlatformConnectOptions::EnableRsync( } void SBPlatformConnectOptions::DisableRsync() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatformConnectOptions, DisableRsync); + m_opaque_ptr->m_rsync_enabled = false; } const char *SBPlatformConnectOptions::GetLocalCacheDirectory() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformConnectOptions, + GetLocalCacheDirectory); + return m_opaque_ptr->m_local_cache_directory.GetCString(); } void SBPlatformConnectOptions::SetLocalCacheDirectory(const char *path) { + LLDB_RECORD_METHOD(void, SBPlatformConnectOptions, SetLocalCacheDirectory, + (const char *), path); + if (path && path[0]) m_opaque_ptr->m_local_cache_directory.SetCString(path); else @@ -137,29 +168,42 @@ void SBPlatformConnectOptions::SetLocalCacheDirectory(const char *path) { // SBPlatformShellCommand //---------------------------------------------------------------------- SBPlatformShellCommand::SBPlatformShellCommand(const char *shell_command) - : m_opaque_ptr(new PlatformShellCommand(shell_command)) {} + : m_opaque_ptr(new PlatformShellCommand(shell_command)) { + LLDB_RECORD_CONSTRUCTOR(SBPlatformShellCommand, (const char *), + shell_command); +} SBPlatformShellCommand::SBPlatformShellCommand( const SBPlatformShellCommand &rhs) : m_opaque_ptr(new PlatformShellCommand()) { + LLDB_RECORD_CONSTRUCTOR(SBPlatformShellCommand, + (const lldb::SBPlatformShellCommand &), rhs); + *m_opaque_ptr = *rhs.m_opaque_ptr; } SBPlatformShellCommand::~SBPlatformShellCommand() { delete m_opaque_ptr; } void SBPlatformShellCommand::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatformShellCommand, Clear); + m_opaque_ptr->m_output = std::string(); m_opaque_ptr->m_status = 0; m_opaque_ptr->m_signo = 0; } const char *SBPlatformShellCommand::GetCommand() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand, GetCommand); + if (m_opaque_ptr->m_command.empty()) return NULL; return m_opaque_ptr->m_command.c_str(); } void SBPlatformShellCommand::SetCommand(const char *shell_command) { + LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetCommand, (const char *), + shell_command); + if (shell_command && shell_command[0]) m_opaque_ptr->m_command = shell_command; else @@ -167,12 +211,18 @@ void SBPlatformShellCommand::SetCommand(const char *shell_command) { } const char *SBPlatformShellCommand::GetWorkingDirectory() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand, + GetWorkingDirectory); + if (m_opaque_ptr->m_working_dir.empty()) return NULL; return m_opaque_ptr->m_working_dir.c_str(); } void SBPlatformShellCommand::SetWorkingDirectory(const char *path) { + LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetWorkingDirectory, + (const char *), path); + if (path && path[0]) m_opaque_ptr->m_working_dir = path; else @@ -180,23 +230,39 @@ void SBPlatformShellCommand::SetWorkingDirectory(const char *path) { } uint32_t SBPlatformShellCommand::GetTimeoutSeconds() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatformShellCommand, + GetTimeoutSeconds); + if (m_opaque_ptr->m_timeout) return m_opaque_ptr->m_timeout->count(); return UINT32_MAX; } void SBPlatformShellCommand::SetTimeoutSeconds(uint32_t sec) { + LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetTimeoutSeconds, + (uint32_t), sec); + if (sec == UINT32_MAX) m_opaque_ptr->m_timeout = llvm::None; else m_opaque_ptr->m_timeout = std::chrono::seconds(sec); } -int SBPlatformShellCommand::GetSignal() { return m_opaque_ptr->m_signo; } +int SBPlatformShellCommand::GetSignal() { + LLDB_RECORD_METHOD_NO_ARGS(int, SBPlatformShellCommand, GetSignal); + + return m_opaque_ptr->m_signo; +} + +int SBPlatformShellCommand::GetStatus() { + LLDB_RECORD_METHOD_NO_ARGS(int, SBPlatformShellCommand, GetStatus); -int SBPlatformShellCommand::GetStatus() { return m_opaque_ptr->m_status; } + return m_opaque_ptr->m_status; +} const char *SBPlatformShellCommand::GetOutput() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand, GetOutput); + if (m_opaque_ptr->m_output.empty()) return NULL; return m_opaque_ptr->m_output.c_str(); @@ -205,9 +271,13 @@ const char *SBPlatformShellCommand::GetOutput() { //---------------------------------------------------------------------- // SBPlatform //---------------------------------------------------------------------- -SBPlatform::SBPlatform() : m_opaque_sp() {} +SBPlatform::SBPlatform() : m_opaque_sp() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBPlatform); +} SBPlatform::SBPlatform(const char *platform_name) : m_opaque_sp() { + LLDB_RECORD_CONSTRUCTOR(SBPlatform, (const char *), platform_name); + Status error; if (platform_name && platform_name[0]) m_opaque_sp = Platform::Create(ConstString(platform_name), error); @@ -215,11 +285,21 @@ SBPlatform::SBPlatform(const char *platform_name) : m_opaque_sp() { SBPlatform::~SBPlatform() {} -bool SBPlatform::IsValid() const { return m_opaque_sp.get() != NULL; } +bool SBPlatform::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBPlatform, IsValid); + + return m_opaque_sp.get() != NULL; +} + +void SBPlatform::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatform, Clear); -void SBPlatform::Clear() { m_opaque_sp.reset(); } + m_opaque_sp.reset(); +} const char *SBPlatform::GetName() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetName); + PlatformSP platform_sp(GetSP()); if (platform_sp) return platform_sp->GetName().GetCString(); @@ -233,6 +313,8 @@ void SBPlatform::SetSP(const lldb::PlatformSP &platform_sp) { } const char *SBPlatform::GetWorkingDirectory() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetWorkingDirectory); + PlatformSP platform_sp(GetSP()); if (platform_sp) return platform_sp->GetWorkingDirectory().GetCString(); @@ -240,6 +322,9 @@ const char *SBPlatform::GetWorkingDirectory() { } bool SBPlatform::SetWorkingDirectory(const char *path) { + LLDB_RECORD_METHOD(bool, SBPlatform, SetWorkingDirectory, (const char *), + path); + PlatformSP platform_sp(GetSP()); if (platform_sp) { if (path) @@ -252,6 +337,9 @@ bool SBPlatform::SetWorkingDirectory(const char *path) { } SBError SBPlatform::ConnectRemote(SBPlatformConnectOptions &connect_options) { + LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, ConnectRemote, + (lldb::SBPlatformConnectOptions &), connect_options); + SBError sb_error; PlatformSP platform_sp(GetSP()); if (platform_sp && connect_options.GetURL()) { @@ -262,16 +350,20 @@ SBError SBPlatform::ConnectRemote(SBPlatformConnectOptions &connect_options) { } else { sb_error.SetErrorString("invalid platform"); } - return sb_error; + return LLDB_RECORD_RESULT(sb_error); } void SBPlatform::DisconnectRemote() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatform, DisconnectRemote); + PlatformSP platform_sp(GetSP()); if (platform_sp) platform_sp->DisconnectRemote(); } bool SBPlatform::IsConnected() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBPlatform, IsConnected); + PlatformSP platform_sp(GetSP()); if (platform_sp) return platform_sp->IsConnected(); @@ -279,6 +371,8 @@ bool SBPlatform::IsConnected() { } const char *SBPlatform::GetTriple() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetTriple); + PlatformSP platform_sp(GetSP()); if (platform_sp) { ArchSpec arch(platform_sp->GetSystemArchitecture()); @@ -292,6 +386,8 @@ const char *SBPlatform::GetTriple() { } const char *SBPlatform::GetOSBuild() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetOSBuild); + PlatformSP platform_sp(GetSP()); if (platform_sp) { std::string s; @@ -307,6 +403,8 @@ const char *SBPlatform::GetOSBuild() { } const char *SBPlatform::GetOSDescription() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetOSDescription); + PlatformSP platform_sp(GetSP()); if (platform_sp) { std::string s; @@ -322,6 +420,8 @@ const char *SBPlatform::GetOSDescription() { } const char *SBPlatform::GetHostname() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetHostname); + PlatformSP platform_sp(GetSP()); if (platform_sp) return platform_sp->GetHostname(); @@ -329,6 +429,8 @@ const char *SBPlatform::GetHostname() { } uint32_t SBPlatform::GetOSMajorVersion() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatform, GetOSMajorVersion); + llvm::VersionTuple version; if (PlatformSP platform_sp = GetSP()) version = platform_sp->GetOSVersion(); @@ -336,6 +438,8 @@ uint32_t SBPlatform::GetOSMajorVersion() { } uint32_t SBPlatform::GetOSMinorVersion() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatform, GetOSMinorVersion); + llvm::VersionTuple version; if (PlatformSP platform_sp = GetSP()) version = platform_sp->GetOSVersion(); @@ -343,6 +447,8 @@ uint32_t SBPlatform::GetOSMinorVersion() { } uint32_t SBPlatform::GetOSUpdateVersion() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatform, GetOSUpdateVersion); + llvm::VersionTuple version; if (PlatformSP platform_sp = GetSP()) version = platform_sp->GetOSVersion(); @@ -350,6 +456,9 @@ uint32_t SBPlatform::GetOSUpdateVersion() { } SBError SBPlatform::Get(SBFileSpec &src, SBFileSpec &dst) { + LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Get, + (lldb::SBFileSpec &, lldb::SBFileSpec &), src, dst); + SBError sb_error; PlatformSP platform_sp(GetSP()); if (platform_sp) { @@ -357,44 +466,54 @@ SBError SBPlatform::Get(SBFileSpec &src, SBFileSpec &dst) { } else { sb_error.SetErrorString("invalid platform"); } - return sb_error; + return LLDB_RECORD_RESULT(sb_error); } SBError SBPlatform::Put(SBFileSpec &src, SBFileSpec &dst) { - return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) { - if (src.Exists()) { - uint32_t permissions = FileSystem::Instance().GetPermissions(src.ref()); - if (permissions == 0) { - if (FileSystem::Instance().IsDirectory(src.ref())) - permissions = eFilePermissionsDirectoryDefault; - else - permissions = eFilePermissionsFileDefault; - } - - return platform_sp->PutFile(src.ref(), dst.ref(), permissions); - } - - Status error; - error.SetErrorStringWithFormat("'src' argument doesn't exist: '%s'", - src.ref().GetPath().c_str()); - return error; - }); + LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Put, + (lldb::SBFileSpec &, lldb::SBFileSpec &), src, dst); + return LLDB_RECORD_RESULT( + ExecuteConnected([&](const lldb::PlatformSP &platform_sp) { + if (src.Exists()) { + uint32_t permissions = + FileSystem::Instance().GetPermissions(src.ref()); + if (permissions == 0) { + if (FileSystem::Instance().IsDirectory(src.ref())) + permissions = eFilePermissionsDirectoryDefault; + else + permissions = eFilePermissionsFileDefault; + } + + return platform_sp->PutFile(src.ref(), dst.ref(), permissions); + } + + Status error; + error.SetErrorStringWithFormat("'src' argument doesn't exist: '%s'", + src.ref().GetPath().c_str()); + return error; + })); } SBError SBPlatform::Install(SBFileSpec &src, SBFileSpec &dst) { - return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) { - if (src.Exists()) - return platform_sp->Install(src.ref(), dst.ref()); + LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Install, + (lldb::SBFileSpec &, lldb::SBFileSpec &), src, dst); + return LLDB_RECORD_RESULT( + ExecuteConnected([&](const lldb::PlatformSP &platform_sp) { + if (src.Exists()) + return platform_sp->Install(src.ref(), dst.ref()); - Status error; - error.SetErrorStringWithFormat("'src' argument doesn't exist: '%s'", - src.ref().GetPath().c_str()); - return error; - }); + Status error; + error.SetErrorStringWithFormat("'src' argument doesn't exist: '%s'", + src.ref().GetPath().c_str()); + return error; + })); } SBError SBPlatform::Run(SBPlatformShellCommand &shell_command) { - return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) { + LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Run, + (lldb::SBPlatformShellCommand &), shell_command); + return LLDB_RECORD_RESULT(ExecuteConnected([&](const lldb::PlatformSP + &platform_sp) { const char *command = shell_command.GetCommand(); if (!command) return Status("invalid shell command (empty)"); @@ -410,22 +529,27 @@ SBError SBPlatform::Run(SBPlatformShellCommand &shell_command) { &shell_command.m_opaque_ptr->m_signo, &shell_command.m_opaque_ptr->m_output, shell_command.m_opaque_ptr->m_timeout); - }); + })); } SBError SBPlatform::Launch(SBLaunchInfo &launch_info) { - return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) { - ProcessLaunchInfo info = launch_info.ref(); - Status error = platform_sp->LaunchProcess(info); - launch_info.set_ref(info); - return error; - }); + LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Launch, (lldb::SBLaunchInfo &), + launch_info); + return LLDB_RECORD_RESULT( + ExecuteConnected([&](const lldb::PlatformSP &platform_sp) { + ProcessLaunchInfo info = launch_info.ref(); + Status error = platform_sp->LaunchProcess(info); + launch_info.set_ref(info); + return error; + })); } SBError SBPlatform::Kill(const lldb::pid_t pid) { - return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) { - return platform_sp->KillProcess(pid); - }); + LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Kill, (const lldb::pid_t), pid); + return LLDB_RECORD_RESULT( + ExecuteConnected([&](const lldb::PlatformSP &platform_sp) { + return platform_sp->KillProcess(pid); + })); } SBError SBPlatform::ExecuteConnected( @@ -444,6 +568,9 @@ SBError SBPlatform::ExecuteConnected( } SBError SBPlatform::MakeDirectory(const char *path, uint32_t file_permissions) { + LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, MakeDirectory, + (const char *, uint32_t), path, file_permissions); + SBError sb_error; PlatformSP platform_sp(GetSP()); if (platform_sp) { @@ -452,10 +579,13 @@ SBError SBPlatform::MakeDirectory(const char *path, uint32_t file_permissions) { } else { sb_error.SetErrorString("invalid platform"); } - return sb_error; + return LLDB_RECORD_RESULT(sb_error); } uint32_t SBPlatform::GetFilePermissions(const char *path) { + LLDB_RECORD_METHOD(uint32_t, SBPlatform, GetFilePermissions, (const char *), + path); + PlatformSP platform_sp(GetSP()); if (platform_sp) { uint32_t file_permissions = 0; @@ -467,6 +597,9 @@ uint32_t SBPlatform::GetFilePermissions(const char *path) { SBError SBPlatform::SetFilePermissions(const char *path, uint32_t file_permissions) { + LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, SetFilePermissions, + (const char *, uint32_t), path, file_permissions); + SBError sb_error; PlatformSP platform_sp(GetSP()); if (platform_sp) { @@ -475,12 +608,15 @@ SBError SBPlatform::SetFilePermissions(const char *path, } else { sb_error.SetErrorString("invalid platform"); } - return sb_error; + return LLDB_RECORD_RESULT(sb_error); } SBUnixSignals SBPlatform::GetUnixSignals() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBUnixSignals, SBPlatform, + GetUnixSignals); + if (auto platform_sp = GetSP()) - return SBUnixSignals{platform_sp}; + return LLDB_RECORD_RESULT(SBUnixSignals{platform_sp}); - return {}; + return LLDB_RECORD_RESULT(SBUnixSignals()); } diff --git a/lldb/source/API/SBProcess.cpp b/lldb/source/API/SBProcess.cpp index 4ec235aecc8..f1e288d32a3 100644 --- a/lldb/source/API/SBProcess.cpp +++ b/lldb/source/API/SBProcess.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBProcess.h" +#include "SBReproducerPrivate.h" #include <inttypes.h> @@ -49,18 +50,27 @@ 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; @@ -72,10 +82,15 @@ const SBProcess &SBProcess::operator=(const SBProcess &rhs) { 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 +99,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 +112,15 @@ 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); + ProcessSP process_sp(m_opaque_wp.lock()); return ((bool)process_sp && process_sp->IsValid()); } @@ -108,6 +131,13 @@ bool SBProcess::RemoteLaunch(char const **argv, char const **envp, const char *working_directory, uint32_t launch_flags, bool stop_at_entry, lldb::SBError &error) { + 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); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) log->Printf("SBProcess(%p)::RemoteLaunch (argv=%p, envp=%p, stdin=%s, " @@ -159,6 +189,9 @@ bool SBProcess::RemoteLaunch(char const **argv, char const **envp, 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( @@ -189,6 +222,8 @@ bool SBProcess::RemoteAttachToProcessWithID(lldb::pid_t pid, } uint32_t SBProcess::GetNumThreads() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumThreads); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); uint32_t num_threads = 0; @@ -210,6 +245,9 @@ uint32_t SBProcess::GetNumThreads() { } SBThread SBProcess::GetSelectedThread() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBProcess, + GetSelectedThread); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBThread sb_thread; @@ -227,11 +265,14 @@ SBThread SBProcess::GetSelectedThread() const { 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) { + LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, CreateOSPluginThread, + (lldb::tid_t, lldb::addr_t), tid, context); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBThread sb_thread; @@ -250,10 +291,12 @@ SBThread SBProcess::CreateOSPluginThread(lldb::tid_t tid, 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 { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBTarget, SBProcess, GetTarget); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBTarget sb_target; @@ -269,10 +312,13 @@ SBTarget SBProcess::GetTarget() const { 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) { + LLDB_RECORD_METHOD(size_t, SBProcess, PutSTDIN, (const char *, size_t), src, + src_len); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); size_t ret_val = 0; @@ -292,6 +338,9 @@ size_t SBProcess::PutSTDIN(const char *src, size_t src_len) { } 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) { @@ -311,6 +360,9 @@ size_t SBProcess::GetSTDOUT(char *dst, size_t dst_len) const { } 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) { @@ -330,6 +382,9 @@ size_t SBProcess::GetSTDERR(char *dst, size_t dst_len) const { } 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) { @@ -350,6 +405,9 @@ size_t SBProcess::GetAsyncProfileData(char *dst, size_t dst_len) const { lldb::SBTrace SBProcess::StartTrace(SBTraceOptions &options, lldb::SBError &error) { + LLDB_RECORD_METHOD(lldb::SBTrace, SBProcess, StartTrace, + (lldb::SBTraceOptions &, lldb::SBError &), options, error); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); ProcessSP process_sp(GetSP()); error.Clear(); @@ -364,10 +422,13 @@ lldb::SBTrace SBProcess::StartTrace(SBTraceOptions &options, 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 { + LLDB_RECORD_METHOD_CONST(void, SBProcess, ReportEventState, + (const lldb::SBEvent &, FILE *), event, out); + if (out == NULL) return; @@ -386,6 +447,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 +463,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,6 +477,9 @@ bool SBProcess::SetSelectedThread(const SBThread &thread) { } bool SBProcess::SetSelectedThreadByID(lldb::tid_t tid) { + LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByID, (lldb::tid_t), + tid); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); bool ret_val = false; @@ -429,6 +500,9 @@ bool SBProcess::SetSelectedThreadByID(lldb::tid_t tid) { } bool SBProcess::SetSelectedThreadByIndexID(uint32_t index_id) { + LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByIndexID, (uint32_t), + index_id); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); bool ret_val = false; @@ -448,6 +522,9 @@ bool SBProcess::SetSelectedThreadByIndexID(uint32_t index_id) { } SBThread SBProcess::GetThreadAtIndex(size_t index) { + LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadAtIndex, (size_t), + index); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBThread sb_thread; @@ -468,10 +545,12 @@ SBThread SBProcess::GetThreadAtIndex(size_t index) { static_cast<uint32_t>(index), static_cast<void *>(thread_sp.get())); - return sb_thread; + return LLDB_RECORD_RESULT(sb_thread); } uint32_t SBProcess::GetNumQueues() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumQueues); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); uint32_t num_queues = 0; @@ -493,6 +572,9 @@ uint32_t SBProcess::GetNumQueues() { } SBQueue SBProcess::GetQueueAtIndex(size_t index) { + LLDB_RECORD_METHOD(lldb::SBQueue, SBProcess, GetQueueAtIndex, (size_t), + index); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBQueue sb_queue; @@ -514,10 +596,13 @@ SBQueue SBProcess::GetQueueAtIndex(size_t index) { 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,6 +616,9 @@ uint32_t SBProcess::GetStopID(bool include_expression_stops) { } SBEvent SBProcess::GetStopEventForStopID(uint32_t stop_id) { + LLDB_RECORD_METHOD(lldb::SBEvent, SBProcess, GetStopEventForStopID, + (uint32_t), stop_id); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBEvent sb_event; @@ -549,10 +637,11 @@ SBEvent SBProcess::GetStopEventForStopID(uint32_t stop_id) { 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()); @@ -572,6 +661,8 @@ StateType SBProcess::GetState() { } int SBProcess::GetExitStatus() { + LLDB_RECORD_METHOD_NO_ARGS(int, SBProcess, GetExitStatus); + int exit_status = 0; ProcessSP process_sp(GetSP()); if (process_sp) { @@ -589,6 +680,8 @@ int SBProcess::GetExitStatus() { } const char *SBProcess::GetExitDescription() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetExitDescription); + const char *exit_desc = NULL; ProcessSP process_sp(GetSP()); if (process_sp) { @@ -604,6 +697,8 @@ const char *SBProcess::GetExitDescription() { } 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) @@ -618,6 +713,8 @@ lldb::pid_t SBProcess::GetProcessID() { } 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) @@ -630,6 +727,8 @@ uint32_t SBProcess::GetUniqueID() { } ByteOrder SBProcess::GetByteOrder() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ByteOrder, SBProcess, GetByteOrder); + ByteOrder byteOrder = eByteOrderInvalid; ProcessSP process_sp(GetSP()); if (process_sp) @@ -644,6 +743,8 @@ ByteOrder SBProcess::GetByteOrder() const { } 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) @@ -658,6 +759,8 @@ uint32_t SBProcess::GetAddressByteSize() const { } SBError SBProcess::Continue() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Continue); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBError sb_error; @@ -686,10 +789,12 @@ SBError SBProcess::Continue() { 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) { @@ -708,10 +813,12 @@ SBError SBProcess::Destroy() { 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) { @@ -730,10 +837,12 @@ SBError SBProcess::Stop() { 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) { @@ -752,16 +861,20 @@ SBError SBProcess::Kill() { 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 +884,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) { @@ -791,17 +906,21 @@ SBError SBProcess::Signal(int signo) { 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 +928,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()); @@ -828,10 +950,13 @@ SBThread SBProcess::GetThreadByID(tid_t tid) { 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()); @@ -851,10 +976,13 @@ SBThread SBProcess::GetThreadByIndexID(uint32_t index_id) { 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) { + LLDB_RECORD_STATIC_METHOD(lldb::StateType, SBProcess, GetStateFromEvent, + (const lldb::SBEvent &), event); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); StateType ret_val = Process::ProcessEventData::GetStateFromEvent(event.get()); @@ -868,6 +996,9 @@ StateType SBProcess::GetStateFromEvent(const SBEvent &event) { } bool SBProcess::GetRestartedFromEvent(const SBEvent &event) { + LLDB_RECORD_STATIC_METHOD(bool, SBProcess, GetRestartedFromEvent, + (const lldb::SBEvent &), event); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); bool ret_val = Process::ProcessEventData::GetRestartedFromEvent(event.get()); @@ -880,16 +1011,26 @@ bool SBProcess::GetRestartedFromEvent(const SBEvent &event) { } 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 +1038,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,6 +1076,9 @@ bool SBProcess::EventIsStructuredDataEvent(const lldb::SBEvent &event) { } SBBroadcaster SBProcess::GetBroadcaster() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBProcess, + GetBroadcaster); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); ProcessSP process_sp(GetSP()); @@ -933,10 +1090,13 @@ SBBroadcaster SBProcess::GetBroadcaster() const { 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(); } @@ -1012,6 +1172,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) { @@ -1037,6 +1201,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) { @@ -1104,6 +1271,9 @@ size_t SBProcess::WriteMemory(addr_t addr, const void *src, size_t src_len, } bool SBProcess::GetDescription(SBStream &description) { + LLDB_RECORD_METHOD(bool, SBProcess, GetDescription, (lldb::SBStream &), + description); + Stream &strm = description.ref(); ProcessSP process_sp(GetSP()); @@ -1127,6 +1297,10 @@ bool SBProcess::GetDescription(SBStream &description) { uint32_t SBProcess::GetNumSupportedHardwareWatchpoints(lldb::SBError &sb_error) const { + LLDB_RECORD_METHOD_CONST(uint32_t, SBProcess, + GetNumSupportedHardwareWatchpoints, + (lldb::SBError &), sb_error); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); uint32_t num = 0; @@ -1146,12 +1320,21 @@ 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) { + 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); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); ProcessSP process_sp(GetSP()); if (process_sp) { @@ -1186,8 +1369,13 @@ 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) { + LLDB_RECORD_METHOD(uint32_t, SBProcess, LoadImageUsingPaths, + (const lldb::SBFileSpec &, lldb::SBStringList &, + lldb::SBFileSpec &, lldb::SBError &), + image_spec, paths, loaded_path, error); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); ProcessSP process_sp(GetSP()); if (process_sp) { @@ -1236,6 +1424,9 @@ uint32_t SBProcess::LoadImageUsingPaths(const lldb::SBFileSpec &image_spec, } 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) { @@ -1255,10 +1446,13 @@ lldb::SBError SBProcess::UnloadImage(uint32_t image_token) { } } 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) { @@ -1277,10 +1471,12 @@ lldb::SBError SBProcess::SendEventData(const char *event_data) { } } 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 +1486,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(); @@ -1309,16 +1508,22 @@ const char *SBProcess::GetExtendedBacktraceTypeAtIndex(uint32_t idx) { } 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 +1538,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 +1553,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) { @@ -1377,10 +1589,13 @@ SBProcess::GetMemoryRegionInfo(lldb::addr_t load_addr, } 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()); @@ -1398,15 +1613,17 @@ lldb::SBMemoryRegionInfoList SBProcess::GetMemoryRegions() { 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); } diff --git a/lldb/source/API/SBProcessInfo.cpp b/lldb/source/API/SBProcessInfo.cpp index 6a3897bc72b..fbf9caedbea 100644 --- a/lldb/source/API/SBProcessInfo.cpp +++ b/lldb/source/API/SBProcessInfo.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBProcessInfo.h" +#include "SBReproducerPrivate.h" #include "Utils.h" #include "lldb/API/SBFileSpec.h" #include "lldb/Utility/ProcessInfo.h" @@ -14,15 +15,23 @@ using namespace lldb; using namespace lldb_private; -SBProcessInfo::SBProcessInfo() : m_opaque_up() {} +SBProcessInfo::SBProcessInfo() : m_opaque_up() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBProcessInfo); +} SBProcessInfo::SBProcessInfo(const SBProcessInfo &rhs) : m_opaque_up() { + LLDB_RECORD_CONSTRUCTOR(SBProcessInfo, (const lldb::SBProcessInfo &), rhs); + m_opaque_up = clone(rhs.m_opaque_up); } SBProcessInfo::~SBProcessInfo() {} SBProcessInfo &SBProcessInfo::operator=(const SBProcessInfo &rhs) { + LLDB_RECORD_METHOD(lldb::SBProcessInfo &, + SBProcessInfo, operator=,(const lldb::SBProcessInfo &), + rhs); + if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); return *this; @@ -39,9 +48,15 @@ void SBProcessInfo::SetProcessInfo(const ProcessInstanceInfo &proc_info_ref) { ref() = proc_info_ref; } -bool SBProcessInfo::IsValid() const { return m_opaque_up != nullptr; } +bool SBProcessInfo::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcessInfo, IsValid); + + return m_opaque_up != nullptr; +} const char *SBProcessInfo::GetName() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcessInfo, GetName); + const char *name = nullptr; if (m_opaque_up) { name = m_opaque_up->GetName(); @@ -50,14 +65,19 @@ const char *SBProcessInfo::GetName() { } SBFileSpec SBProcessInfo::GetExecutableFile() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBProcessInfo, + GetExecutableFile); + SBFileSpec file_spec; if (m_opaque_up) { file_spec.SetFileSpec(m_opaque_up->GetExecutableFile()); } - return file_spec; + return LLDB_RECORD_RESULT(file_spec); } lldb::pid_t SBProcessInfo::GetProcessID() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBProcessInfo, GetProcessID); + lldb::pid_t proc_id = LLDB_INVALID_PROCESS_ID; if (m_opaque_up) { proc_id = m_opaque_up->GetProcessID(); @@ -66,6 +86,8 @@ lldb::pid_t SBProcessInfo::GetProcessID() { } uint32_t SBProcessInfo::GetUserID() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetUserID); + uint32_t user_id = UINT32_MAX; if (m_opaque_up) { user_id = m_opaque_up->GetUserID(); @@ -74,6 +96,8 @@ uint32_t SBProcessInfo::GetUserID() { } uint32_t SBProcessInfo::GetGroupID() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetGroupID); + uint32_t group_id = UINT32_MAX; if (m_opaque_up) { group_id = m_opaque_up->GetGroupID(); @@ -82,6 +106,8 @@ uint32_t SBProcessInfo::GetGroupID() { } bool SBProcessInfo::UserIDIsValid() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, UserIDIsValid); + bool is_valid = false; if (m_opaque_up) { is_valid = m_opaque_up->UserIDIsValid(); @@ -90,6 +116,8 @@ bool SBProcessInfo::UserIDIsValid() { } bool SBProcessInfo::GroupIDIsValid() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, GroupIDIsValid); + bool is_valid = false; if (m_opaque_up) { is_valid = m_opaque_up->GroupIDIsValid(); @@ -98,6 +126,8 @@ bool SBProcessInfo::GroupIDIsValid() { } uint32_t SBProcessInfo::GetEffectiveUserID() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetEffectiveUserID); + uint32_t user_id = UINT32_MAX; if (m_opaque_up) { user_id = m_opaque_up->GetEffectiveUserID(); @@ -106,6 +136,8 @@ uint32_t SBProcessInfo::GetEffectiveUserID() { } uint32_t SBProcessInfo::GetEffectiveGroupID() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetEffectiveGroupID); + uint32_t group_id = UINT32_MAX; if (m_opaque_up) { group_id = m_opaque_up->GetEffectiveGroupID(); @@ -114,6 +146,8 @@ uint32_t SBProcessInfo::GetEffectiveGroupID() { } bool SBProcessInfo::EffectiveUserIDIsValid() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, EffectiveUserIDIsValid); + bool is_valid = false; if (m_opaque_up) { is_valid = m_opaque_up->EffectiveUserIDIsValid(); @@ -122,6 +156,8 @@ bool SBProcessInfo::EffectiveUserIDIsValid() { } bool SBProcessInfo::EffectiveGroupIDIsValid() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, EffectiveGroupIDIsValid); + bool is_valid = false; if (m_opaque_up) { is_valid = m_opaque_up->EffectiveGroupIDIsValid(); @@ -130,6 +166,8 @@ bool SBProcessInfo::EffectiveGroupIDIsValid() { } lldb::pid_t SBProcessInfo::GetParentProcessID() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBProcessInfo, GetParentProcessID); + lldb::pid_t proc_id = LLDB_INVALID_PROCESS_ID; if (m_opaque_up) { proc_id = m_opaque_up->GetParentProcessID(); diff --git a/lldb/source/API/SBQueue.cpp b/lldb/source/API/SBQueue.cpp index f73a20208f5..940084c12b6 100644 --- a/lldb/source/API/SBQueue.cpp +++ b/lldb/source/API/SBQueue.cpp @@ -8,6 +8,7 @@ #include <inttypes.h> +#include "SBReproducerPrivate.h" #include "lldb/API/SBQueue.h" #include "lldb/API/SBProcess.h" @@ -231,12 +232,18 @@ private: }; } -SBQueue::SBQueue() : m_opaque_sp(new QueueImpl()) {} +SBQueue::SBQueue() : m_opaque_sp(new QueueImpl()) { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBQueue); +} SBQueue::SBQueue(const QueueSP &queue_sp) - : m_opaque_sp(new QueueImpl(queue_sp)) {} + : m_opaque_sp(new QueueImpl(queue_sp)) { + LLDB_RECORD_CONSTRUCTOR(SBQueue, (const lldb::QueueSP &), queue_sp); +} SBQueue::SBQueue(const SBQueue &rhs) { + LLDB_RECORD_CONSTRUCTOR(SBQueue, (const lldb::SBQueue &), rhs); + if (&rhs == this) return; @@ -244,6 +251,9 @@ SBQueue::SBQueue(const SBQueue &rhs) { } const lldb::SBQueue &SBQueue::operator=(const lldb::SBQueue &rhs) { + LLDB_RECORD_METHOD(const lldb::SBQueue &, + SBQueue, operator=,(const lldb::SBQueue &), rhs); + m_opaque_sp = rhs.m_opaque_sp; return *this; } @@ -251,6 +261,8 @@ const lldb::SBQueue &SBQueue::operator=(const lldb::SBQueue &rhs) { SBQueue::~SBQueue() {} bool SBQueue::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBQueue, IsValid); + bool is_valid = m_opaque_sp->IsValid(); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) @@ -260,6 +272,8 @@ bool SBQueue::IsValid() const { } void SBQueue::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBQueue, Clear); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) log->Printf("SBQueue(0x%" PRIx64 ")::Clear()", m_opaque_sp->GetQueueID()); @@ -271,6 +285,8 @@ void SBQueue::SetQueue(const QueueSP &queue_sp) { } lldb::queue_id_t SBQueue::GetQueueID() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::queue_id_t, SBQueue, GetQueueID); + lldb::queue_id_t qid = m_opaque_sp->GetQueueID(); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) @@ -280,6 +296,8 @@ lldb::queue_id_t SBQueue::GetQueueID() const { } uint32_t SBQueue::GetIndexID() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBQueue, GetIndexID); + uint32_t index_id = m_opaque_sp->GetIndexID(); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) @@ -289,6 +307,8 @@ uint32_t SBQueue::GetIndexID() const { } const char *SBQueue::GetName() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBQueue, GetName); + const char *name = m_opaque_sp->GetName(); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) @@ -298,6 +318,8 @@ const char *SBQueue::GetName() const { } uint32_t SBQueue::GetNumThreads() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBQueue, GetNumThreads); + uint32_t numthreads = m_opaque_sp->GetNumThreads(); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) @@ -307,15 +329,20 @@ uint32_t SBQueue::GetNumThreads() { } SBThread SBQueue::GetThreadAtIndex(uint32_t idx) { + LLDB_RECORD_METHOD(lldb::SBThread, SBQueue, GetThreadAtIndex, (uint32_t), + idx); + SBThread th = m_opaque_sp->GetThreadAtIndex(idx); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) log->Printf("SBQueue(0x%" PRIx64 ")::GetThreadAtIndex(%d)", m_opaque_sp->GetQueueID(), idx); - return th; + return LLDB_RECORD_RESULT(th); } uint32_t SBQueue::GetNumPendingItems() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBQueue, GetNumPendingItems); + uint32_t pending_items = m_opaque_sp->GetNumPendingItems(); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) @@ -325,14 +352,19 @@ uint32_t SBQueue::GetNumPendingItems() { } SBQueueItem SBQueue::GetPendingItemAtIndex(uint32_t idx) { + LLDB_RECORD_METHOD(lldb::SBQueueItem, SBQueue, GetPendingItemAtIndex, + (uint32_t), idx); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) log->Printf("SBQueue(0x%" PRIx64 ")::GetPendingItemAtIndex(%d)", m_opaque_sp->GetQueueID(), idx); - return m_opaque_sp->GetPendingItemAtIndex(idx); + return LLDB_RECORD_RESULT(m_opaque_sp->GetPendingItemAtIndex(idx)); } uint32_t SBQueue::GetNumRunningItems() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBQueue, GetNumRunningItems); + uint32_t running_items = m_opaque_sp->GetNumRunningItems(); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) @@ -341,6 +373,14 @@ uint32_t SBQueue::GetNumRunningItems() { return running_items; } -SBProcess SBQueue::GetProcess() { return m_opaque_sp->GetProcess(); } +SBProcess SBQueue::GetProcess() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBQueue, GetProcess); -lldb::QueueKind SBQueue::GetKind() { return m_opaque_sp->GetKind(); } + return LLDB_RECORD_RESULT(m_opaque_sp->GetProcess()); +} + +lldb::QueueKind SBQueue::GetKind() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::QueueKind, SBQueue, GetKind); + + return m_opaque_sp->GetKind(); +} diff --git a/lldb/source/API/SBQueueItem.cpp b/lldb/source/API/SBQueueItem.cpp index 398c74b55e4..5a41867c8d4 100644 --- a/lldb/source/API/SBQueueItem.cpp +++ b/lldb/source/API/SBQueueItem.cpp @@ -8,6 +8,7 @@ #include "lldb/lldb-forward.h" +#include "SBReproducerPrivate.h" #include "lldb/API/SBAddress.h" #include "lldb/API/SBQueueItem.h" #include "lldb/API/SBThread.h" @@ -23,10 +24,15 @@ using namespace lldb_private; //---------------------------------------------------------------------- // Constructors //---------------------------------------------------------------------- -SBQueueItem::SBQueueItem() : m_queue_item_sp() {} +SBQueueItem::SBQueueItem() : m_queue_item_sp() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBQueueItem); +} SBQueueItem::SBQueueItem(const QueueItemSP &queue_item_sp) - : m_queue_item_sp(queue_item_sp) {} + : m_queue_item_sp(queue_item_sp) { + LLDB_RECORD_CONSTRUCTOR(SBQueueItem, (const lldb::QueueItemSP &), + queue_item_sp); +} //---------------------------------------------------------------------- // Destructor @@ -34,6 +40,8 @@ SBQueueItem::SBQueueItem(const QueueItemSP &queue_item_sp) SBQueueItem::~SBQueueItem() { m_queue_item_sp.reset(); } bool SBQueueItem::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBQueueItem, IsValid); + bool is_valid = m_queue_item_sp.get() != NULL; Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) @@ -44,6 +52,8 @@ bool SBQueueItem::IsValid() const { } void SBQueueItem::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBQueueItem, Clear); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) log->Printf("SBQueueItem(%p)::Clear()", @@ -52,10 +62,15 @@ void SBQueueItem::Clear() { } void SBQueueItem::SetQueueItem(const QueueItemSP &queue_item_sp) { + LLDB_RECORD_METHOD(void, SBQueueItem, SetQueueItem, + (const lldb::QueueItemSP &), queue_item_sp); + m_queue_item_sp = queue_item_sp; } lldb::QueueItemKind SBQueueItem::GetKind() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::QueueItemKind, SBQueueItem, GetKind); + QueueItemKind result = eQueueItemKindUnknown; Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (m_queue_item_sp) { @@ -69,12 +84,16 @@ lldb::QueueItemKind SBQueueItem::GetKind() const { } void SBQueueItem::SetKind(lldb::QueueItemKind kind) { + LLDB_RECORD_METHOD(void, SBQueueItem, SetKind, (lldb::QueueItemKind), kind); + if (m_queue_item_sp) { m_queue_item_sp->SetKind(kind); } } SBAddress SBQueueItem::GetAddress() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBQueueItem, GetAddress); + SBAddress result; Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (m_queue_item_sp) { @@ -90,16 +109,21 @@ SBAddress SBQueueItem::GetAddress() const { static_cast<void *>(m_queue_item_sp.get()), static_cast<void *>(result.get()), sstr.GetData()); } - return result; + return LLDB_RECORD_RESULT(result); } void SBQueueItem::SetAddress(SBAddress addr) { + LLDB_RECORD_METHOD(void, SBQueueItem, SetAddress, (lldb::SBAddress), addr); + if (m_queue_item_sp) { m_queue_item_sp->SetAddress(addr.ref()); } } SBThread SBQueueItem::GetExtendedBacktraceThread(const char *type) { + LLDB_RECORD_METHOD(lldb::SBThread, SBQueueItem, GetExtendedBacktraceThread, + (const char *), type); + SBThread result; Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (m_queue_item_sp) { @@ -128,5 +152,5 @@ SBThread SBQueueItem::GetExtendedBacktraceThread(const char *type) { } } } - return result; + return LLDB_RECORD_RESULT(result); } diff --git a/lldb/source/API/SBReproducer.cpp b/lldb/source/API/SBReproducer.cpp index 17e13c55a94..0e4b7206b9b 100644 --- a/lldb/source/API/SBReproducer.cpp +++ b/lldb/source/API/SBReproducer.cpp @@ -8,6 +8,7 @@ #include "SBReproducerPrivate.h" +#include "SBReproducerPrivate.h" #include "lldb/API/LLDB.h" #include "lldb/API/SBAddress.h" #include "lldb/API/SBAttachInfo.h" @@ -28,7 +29,2856 @@ using namespace lldb; using namespace lldb_private; using namespace lldb_private::repro; -SBRegistry::SBRegistry() {} +static void SetFileHandleRedirect(SBDebugger *, FILE *, bool) { + // Do nothing. +} + +static bool GetDefaultArchitectureRedirect(char *arch_name, + size_t arch_name_len) { + // The function is writing to its argument. Without the redirect it would + // write into the replay buffer. + char buffer[arch_name_len]; + return SBDebugger::GetDefaultArchitecture(buffer, arch_name_len); +} + +SBRegistry::SBRegistry() { + + // Custom implementation. + Register(&invoke<void (SBDebugger::*)( + FILE *, bool)>::method<&SBDebugger::SetInputFileHandle>::doit, + &SetFileHandleRedirect); + Register(&invoke<void (SBDebugger::*)( + FILE *, bool)>::method<&SBDebugger::SetErrorFileHandle>::doit, + &SetFileHandleRedirect); + Register(&invoke<void (SBDebugger::*)( + FILE *, bool)>::method<&SBDebugger::SetOutputFileHandle>::doit, + &SetFileHandleRedirect); + Register<bool(char *, size_t)>(static_cast<bool (*)(char *, size_t)>( + &SBDebugger::GetDefaultArchitecture), + &GetDefaultArchitectureRedirect); + + { + LLDB_REGISTER_CONSTRUCTOR(SBAddress, ()); + LLDB_REGISTER_CONSTRUCTOR(SBAddress, (const lldb::SBAddress &)); + LLDB_REGISTER_CONSTRUCTOR(SBAddress, (lldb::SBSection, lldb::addr_t)); + LLDB_REGISTER_CONSTRUCTOR(SBAddress, (lldb::addr_t, lldb::SBTarget &)); + LLDB_REGISTER_METHOD(const lldb::SBAddress &, + SBAddress, operator=,(const lldb::SBAddress &)); + LLDB_REGISTER_METHOD_CONST(bool, SBAddress, IsValid, ()); + LLDB_REGISTER_METHOD(void, SBAddress, Clear, ()); + LLDB_REGISTER_METHOD(void, SBAddress, SetAddress, + (lldb::SBSection, lldb::addr_t)); + LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBAddress, GetFileAddress, ()); + LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBAddress, GetLoadAddress, + (const lldb::SBTarget &)); + LLDB_REGISTER_METHOD(void, SBAddress, SetLoadAddress, + (lldb::addr_t, lldb::SBTarget &)); + LLDB_REGISTER_METHOD(bool, SBAddress, OffsetAddress, (lldb::addr_t)); + LLDB_REGISTER_METHOD(lldb::SBSection, SBAddress, GetSection, ()); + LLDB_REGISTER_METHOD(lldb::addr_t, SBAddress, GetOffset, ()); + LLDB_REGISTER_METHOD(bool, SBAddress, GetDescription, (lldb::SBStream &)); + LLDB_REGISTER_METHOD(lldb::SBModule, SBAddress, GetModule, ()); + LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBAddress, GetSymbolContext, + (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBCompileUnit, SBAddress, GetCompileUnit, ()); + LLDB_REGISTER_METHOD(lldb::SBFunction, SBAddress, GetFunction, ()); + LLDB_REGISTER_METHOD(lldb::SBBlock, SBAddress, GetBlock, ()); + LLDB_REGISTER_METHOD(lldb::SBSymbol, SBAddress, GetSymbol, ()); + LLDB_REGISTER_METHOD(lldb::SBLineEntry, SBAddress, GetLineEntry, ()); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, ()); + LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (lldb::pid_t)); + LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (const char *, bool)); + LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (const char *, bool, bool)); + LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (const lldb::SBAttachInfo &)); + LLDB_REGISTER_METHOD(lldb::SBAttachInfo &, + SBAttachInfo, operator=,(const lldb::SBAttachInfo &)); + LLDB_REGISTER_METHOD(lldb::pid_t, SBAttachInfo, GetProcessID, ()); + LLDB_REGISTER_METHOD(void, SBAttachInfo, SetProcessID, (lldb::pid_t)); + LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetResumeCount, ()); + LLDB_REGISTER_METHOD(void, SBAttachInfo, SetResumeCount, (uint32_t)); + LLDB_REGISTER_METHOD(const char *, SBAttachInfo, GetProcessPluginName, ()); + LLDB_REGISTER_METHOD(void, SBAttachInfo, SetProcessPluginName, + (const char *)); + LLDB_REGISTER_METHOD(void, SBAttachInfo, SetExecutable, (const char *)); + LLDB_REGISTER_METHOD(void, SBAttachInfo, SetExecutable, (lldb::SBFileSpec)); + LLDB_REGISTER_METHOD(bool, SBAttachInfo, GetWaitForLaunch, ()); + LLDB_REGISTER_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool)); + LLDB_REGISTER_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool, bool)); + LLDB_REGISTER_METHOD(bool, SBAttachInfo, GetIgnoreExisting, ()); + LLDB_REGISTER_METHOD(void, SBAttachInfo, SetIgnoreExisting, (bool)); + LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetUserID, ()); + LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetGroupID, ()); + LLDB_REGISTER_METHOD(bool, SBAttachInfo, UserIDIsValid, ()); + LLDB_REGISTER_METHOD(bool, SBAttachInfo, GroupIDIsValid, ()); + LLDB_REGISTER_METHOD(void, SBAttachInfo, SetUserID, (uint32_t)); + LLDB_REGISTER_METHOD(void, SBAttachInfo, SetGroupID, (uint32_t)); + LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetEffectiveUserID, ()); + LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetEffectiveGroupID, ()); + LLDB_REGISTER_METHOD(bool, SBAttachInfo, EffectiveUserIDIsValid, ()); + LLDB_REGISTER_METHOD(bool, SBAttachInfo, EffectiveGroupIDIsValid, ()); + LLDB_REGISTER_METHOD(void, SBAttachInfo, SetEffectiveUserID, (uint32_t)); + LLDB_REGISTER_METHOD(void, SBAttachInfo, SetEffectiveGroupID, (uint32_t)); + LLDB_REGISTER_METHOD(lldb::pid_t, SBAttachInfo, GetParentProcessID, ()); + LLDB_REGISTER_METHOD(void, SBAttachInfo, SetParentProcessID, (lldb::pid_t)); + LLDB_REGISTER_METHOD(bool, SBAttachInfo, ParentProcessIDIsValid, ()); + LLDB_REGISTER_METHOD(lldb::SBListener, SBAttachInfo, GetListener, ()); + LLDB_REGISTER_METHOD(void, SBAttachInfo, SetListener, (lldb::SBListener &)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBBlock, ()); + LLDB_REGISTER_CONSTRUCTOR(SBBlock, (const lldb::SBBlock &)); + LLDB_REGISTER_METHOD(const lldb::SBBlock &, + SBBlock, operator=,(const lldb::SBBlock &)); + LLDB_REGISTER_METHOD_CONST(bool, SBBlock, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBBlock, IsInlined, ()); + LLDB_REGISTER_METHOD_CONST(const char *, SBBlock, GetInlinedName, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBBlock, + GetInlinedCallSiteFile, ()); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBBlock, GetInlinedCallSiteLine, ()); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBBlock, GetInlinedCallSiteColumn, ()); + LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetParent, ()); + LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetContainingInlinedBlock, ()); + LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetSibling, ()); + LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetFirstChild, ()); + LLDB_REGISTER_METHOD(bool, SBBlock, GetDescription, (lldb::SBStream &)); + LLDB_REGISTER_METHOD(uint32_t, SBBlock, GetNumRanges, ()); + LLDB_REGISTER_METHOD(lldb::SBAddress, SBBlock, GetRangeStartAddress, + (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBAddress, SBBlock, GetRangeEndAddress, + (uint32_t)); + LLDB_REGISTER_METHOD(uint32_t, SBBlock, GetRangeIndexForBlockAddress, + (lldb::SBAddress)); + LLDB_REGISTER_METHOD( + lldb::SBValueList, SBBlock, GetVariables, + (lldb::SBFrame &, bool, bool, bool, lldb::DynamicValueType)); + LLDB_REGISTER_METHOD(lldb::SBValueList, SBBlock, GetVariables, + (lldb::SBTarget &, bool, bool, bool)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBBreakpoint, ()); + LLDB_REGISTER_CONSTRUCTOR(SBBreakpoint, (const lldb::SBBreakpoint &)); + LLDB_REGISTER_CONSTRUCTOR(SBBreakpoint, (const lldb::BreakpointSP &)); + LLDB_REGISTER_METHOD(const lldb::SBBreakpoint &, + SBBreakpoint, operator=,(const lldb::SBBreakpoint &)); + LLDB_REGISTER_METHOD(bool, + SBBreakpoint, operator==,(const lldb::SBBreakpoint &)); + LLDB_REGISTER_METHOD(bool, + SBBreakpoint, operator!=,(const lldb::SBBreakpoint &)); + LLDB_REGISTER_METHOD_CONST(lldb::break_id_t, SBBreakpoint, GetID, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, IsValid, ()); + LLDB_REGISTER_METHOD(void, SBBreakpoint, ClearAllBreakpointSites, ()); + LLDB_REGISTER_METHOD(lldb::SBBreakpointLocation, SBBreakpoint, + FindLocationByAddress, (lldb::addr_t)); + LLDB_REGISTER_METHOD(lldb::break_id_t, SBBreakpoint, + FindLocationIDByAddress, (lldb::addr_t)); + LLDB_REGISTER_METHOD(lldb::SBBreakpointLocation, SBBreakpoint, + FindLocationByID, (lldb::break_id_t)); + LLDB_REGISTER_METHOD(lldb::SBBreakpointLocation, SBBreakpoint, + GetLocationAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(void, SBBreakpoint, SetEnabled, (bool)); + LLDB_REGISTER_METHOD(bool, SBBreakpoint, IsEnabled, ()); + LLDB_REGISTER_METHOD(void, SBBreakpoint, SetOneShot, (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, IsOneShot, ()); + LLDB_REGISTER_METHOD(bool, SBBreakpoint, IsInternal, ()); + LLDB_REGISTER_METHOD(void, SBBreakpoint, SetIgnoreCount, (uint32_t)); + LLDB_REGISTER_METHOD(void, SBBreakpoint, SetCondition, (const char *)); + LLDB_REGISTER_METHOD(const char *, SBBreakpoint, GetCondition, ()); + LLDB_REGISTER_METHOD(void, SBBreakpoint, SetAutoContinue, (bool)); + LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetAutoContinue, ()); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpoint, GetHitCount, ()); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpoint, GetIgnoreCount, ()); + LLDB_REGISTER_METHOD(void, SBBreakpoint, SetThreadID, (lldb::tid_t)); + LLDB_REGISTER_METHOD(lldb::tid_t, SBBreakpoint, GetThreadID, ()); + LLDB_REGISTER_METHOD(void, SBBreakpoint, SetThreadIndex, (uint32_t)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpoint, GetThreadIndex, ()); + LLDB_REGISTER_METHOD(void, SBBreakpoint, SetThreadName, (const char *)); + LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpoint, GetThreadName, ()); + LLDB_REGISTER_METHOD(void, SBBreakpoint, SetQueueName, (const char *)); + LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpoint, GetQueueName, ()); + LLDB_REGISTER_METHOD_CONST(size_t, SBBreakpoint, GetNumResolvedLocations, + ()); + LLDB_REGISTER_METHOD_CONST(size_t, SBBreakpoint, GetNumLocations, ()); + LLDB_REGISTER_METHOD(void, SBBreakpoint, SetCommandLineCommands, + (lldb::SBStringList &)); + LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetCommandLineCommands, + (lldb::SBStringList &)); + LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetDescription, + (lldb::SBStream &)); + LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetDescription, + (lldb::SBStream &, bool)); + LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpoint, AddLocation, + (lldb::SBAddress &)); + LLDB_REGISTER_METHOD(void, SBBreakpoint, SetScriptCallbackFunction, + (const char *)); + LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpoint, SetScriptCallbackBody, + (const char *)); + LLDB_REGISTER_METHOD(bool, SBBreakpoint, AddName, (const char *)); + LLDB_REGISTER_METHOD(void, SBBreakpoint, RemoveName, (const char *)); + LLDB_REGISTER_METHOD(bool, SBBreakpoint, MatchesName, (const char *)); + LLDB_REGISTER_METHOD(void, SBBreakpoint, GetNames, (lldb::SBStringList &)); + LLDB_REGISTER_STATIC_METHOD(bool, SBBreakpoint, EventIsBreakpointEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_STATIC_METHOD(lldb::BreakpointEventType, SBBreakpoint, + GetBreakpointEventTypeFromEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBBreakpoint, SBBreakpoint, + GetBreakpointFromEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBBreakpointLocation, SBBreakpoint, + GetBreakpointLocationAtIndexFromEvent, + (const lldb::SBEvent &, uint32_t)); + LLDB_REGISTER_STATIC_METHOD(uint32_t, SBBreakpoint, + GetNumBreakpointLocationsFromEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, IsHardware, ()); + LLDB_REGISTER_CONSTRUCTOR(SBBreakpointList, (lldb::SBTarget &)); + LLDB_REGISTER_METHOD_CONST(size_t, SBBreakpointList, GetSize, ()); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBBreakpointList, + GetBreakpointAtIndex, (size_t)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBBreakpointList, + FindBreakpointByID, (lldb::break_id_t)); + LLDB_REGISTER_METHOD(void, SBBreakpointList, Append, + (const lldb::SBBreakpoint &)); + LLDB_REGISTER_METHOD(void, SBBreakpointList, AppendByID, + (lldb::break_id_t)); + LLDB_REGISTER_METHOD(bool, SBBreakpointList, AppendIfUnique, + (const lldb::SBBreakpoint &)); + LLDB_REGISTER_METHOD(void, SBBreakpointList, Clear, ()); + } + { + 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(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, ()); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName, ()); + LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName, + (lldb::SBTarget &, const char *)); + LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName, + (lldb::SBBreakpoint &, const char *)); + LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName, + (const lldb::SBBreakpointName &)); + LLDB_REGISTER_METHOD( + const lldb::SBBreakpointName &, + SBBreakpointName, operator=,(const lldb::SBBreakpointName &)); + LLDB_REGISTER_METHOD( + bool, SBBreakpointName, operator==,(const lldb::SBBreakpointName &)); + LLDB_REGISTER_METHOD( + bool, SBBreakpointName, operator!=,(const lldb::SBBreakpointName &)); + LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetName, ()); + LLDB_REGISTER_METHOD(void, SBBreakpointName, SetEnabled, (bool)); + LLDB_REGISTER_METHOD(bool, SBBreakpointName, IsEnabled, ()); + LLDB_REGISTER_METHOD(void, SBBreakpointName, SetOneShot, (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, IsOneShot, ()); + LLDB_REGISTER_METHOD(void, SBBreakpointName, SetIgnoreCount, (uint32_t)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpointName, GetIgnoreCount, ()); + LLDB_REGISTER_METHOD(void, SBBreakpointName, SetCondition, (const char *)); + LLDB_REGISTER_METHOD(const char *, SBBreakpointName, GetCondition, ()); + LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAutoContinue, (bool)); + LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetAutoContinue, ()); + LLDB_REGISTER_METHOD(void, SBBreakpointName, SetThreadID, (lldb::tid_t)); + LLDB_REGISTER_METHOD(lldb::tid_t, SBBreakpointName, GetThreadID, ()); + LLDB_REGISTER_METHOD(void, SBBreakpointName, SetThreadIndex, (uint32_t)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpointName, GetThreadIndex, ()); + LLDB_REGISTER_METHOD(void, SBBreakpointName, SetThreadName, (const char *)); + LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetThreadName, + ()); + LLDB_REGISTER_METHOD(void, SBBreakpointName, SetQueueName, (const char *)); + LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetQueueName, + ()); + LLDB_REGISTER_METHOD(void, SBBreakpointName, SetCommandLineCommands, + (lldb::SBStringList &)); + LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetCommandLineCommands, + (lldb::SBStringList &)); + LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetHelpString, + ()); + LLDB_REGISTER_METHOD(void, SBBreakpointName, SetHelpString, (const char *)); + LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetDescription, + (lldb::SBStream &)); + LLDB_REGISTER_METHOD(void, SBBreakpointName, SetScriptCallbackFunction, + (const char *)); + LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpointName, SetScriptCallbackBody, + (const char *)); + LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, GetAllowList, ()); + LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAllowList, (bool)); + LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetAllowDelete, ()); + LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAllowDelete, (bool)); + LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetAllowDisable, ()); + LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAllowDisable, (bool)); + } + {} { + LLDB_REGISTER_CONSTRUCTOR(SBBroadcaster, ()); + LLDB_REGISTER_CONSTRUCTOR(SBBroadcaster, (const char *)); + LLDB_REGISTER_CONSTRUCTOR(SBBroadcaster, (const lldb::SBBroadcaster &)); + LLDB_REGISTER_METHOD( + const lldb::SBBroadcaster &, + SBBroadcaster, operator=,(const lldb::SBBroadcaster &)); + LLDB_REGISTER_METHOD(void, SBBroadcaster, BroadcastEventByType, + (uint32_t, bool)); + LLDB_REGISTER_METHOD(void, SBBroadcaster, BroadcastEvent, + (const lldb::SBEvent &, bool)); + LLDB_REGISTER_METHOD(void, SBBroadcaster, AddInitialEventsToListener, + (const lldb::SBListener &, uint32_t)); + LLDB_REGISTER_METHOD(uint32_t, SBBroadcaster, AddListener, + (const lldb::SBListener &, uint32_t)); + LLDB_REGISTER_METHOD_CONST(const char *, SBBroadcaster, GetName, ()); + LLDB_REGISTER_METHOD(bool, SBBroadcaster, EventTypeHasListeners, + (uint32_t)); + LLDB_REGISTER_METHOD(bool, SBBroadcaster, RemoveListener, + (const lldb::SBListener &, uint32_t)); + LLDB_REGISTER_METHOD_CONST(bool, SBBroadcaster, IsValid, ()); + LLDB_REGISTER_METHOD(void, SBBroadcaster, Clear, ()); + LLDB_REGISTER_METHOD_CONST( + bool, SBBroadcaster, operator==,(const lldb::SBBroadcaster &)); + LLDB_REGISTER_METHOD_CONST( + bool, SBBroadcaster, operator!=,(const lldb::SBBroadcaster &)); + LLDB_REGISTER_METHOD_CONST( + bool, SBBroadcaster, operator<,(const lldb::SBBroadcaster &)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreterRunOptions, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions, + GetStopOnContinue, ()); + LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, + SetStopOnContinue, (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions, + GetStopOnError, ()); + LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnError, + (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions, + GetStopOnCrash, ()); + LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnCrash, + (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions, + GetEchoCommands, ()); + LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetEchoCommands, + (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions, + GetEchoCommentCommands, ()); + LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, + SetEchoCommentCommands, (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions, + GetPrintResults, ()); + LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetPrintResults, + (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions, + GetAddToHistory, ()); + LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetAddToHistory, + (bool)); + LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreter, + (lldb_private::CommandInterpreter *)); + LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreter, + (const lldb::SBCommandInterpreter &)); + LLDB_REGISTER_METHOD( + const lldb::SBCommandInterpreter &, + SBCommandInterpreter, operator=,(const lldb::SBCommandInterpreter &)); + LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, IsValid, ()); + LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, CommandExists, + (const char *)); + LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, AliasExists, + (const char *)); + LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, IsActive, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, WasInterrupted, ()); + LLDB_REGISTER_METHOD(const char *, SBCommandInterpreter, + GetIOHandlerControlSequence, (char)); + LLDB_REGISTER_METHOD(lldb::ReturnStatus, SBCommandInterpreter, + HandleCommand, + (const char *, lldb::SBCommandReturnObject &, bool)); + LLDB_REGISTER_METHOD(lldb::ReturnStatus, SBCommandInterpreter, + HandleCommand, + (const char *, lldb::SBExecutionContext &, + lldb::SBCommandReturnObject &, bool)); + LLDB_REGISTER_METHOD(void, SBCommandInterpreter, HandleCommandsFromFile, + (lldb::SBFileSpec &, lldb::SBExecutionContext &, + lldb::SBCommandInterpreterRunOptions &, + lldb::SBCommandReturnObject)); + LLDB_REGISTER_METHOD(int, SBCommandInterpreter, HandleCompletion, + (const char *, const char *, const char *, int, int, + lldb::SBStringList &)); + LLDB_REGISTER_METHOD(int, SBCommandInterpreter, + HandleCompletionWithDescriptions, + (const char *, const char *, const char *, int, int, + lldb::SBStringList &, lldb::SBStringList &)); + LLDB_REGISTER_METHOD(int, SBCommandInterpreter, + HandleCompletionWithDescriptions, + (const char *, uint32_t, int, int, + lldb::SBStringList &, lldb::SBStringList &)); + LLDB_REGISTER_METHOD( + int, SBCommandInterpreter, HandleCompletion, + (const char *, uint32_t, int, int, lldb::SBStringList &)); + LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasCommands, ()); + LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasAliases, ()); + LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasAliasOptions, ()); + LLDB_REGISTER_METHOD(lldb::SBProcess, SBCommandInterpreter, GetProcess, ()); + LLDB_REGISTER_METHOD(lldb::SBDebugger, SBCommandInterpreter, GetDebugger, + ()); + LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, GetPromptOnQuit, ()); + LLDB_REGISTER_METHOD(void, SBCommandInterpreter, SetPromptOnQuit, (bool)); + LLDB_REGISTER_METHOD(void, SBCommandInterpreter, AllowExitCodeOnQuit, + (bool)); + LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasCustomQuitExitCode, ()); + LLDB_REGISTER_METHOD(int, SBCommandInterpreter, GetQuitStatus, ()); + LLDB_REGISTER_METHOD(void, SBCommandInterpreter, ResolveCommand, + (const char *, lldb::SBCommandReturnObject &)); + LLDB_REGISTER_METHOD(void, SBCommandInterpreter, + SourceInitFileInHomeDirectory, + (lldb::SBCommandReturnObject &)); + LLDB_REGISTER_METHOD(void, SBCommandInterpreter, + SourceInitFileInCurrentWorkingDirectory, + (lldb::SBCommandReturnObject &)); + LLDB_REGISTER_METHOD(lldb::SBBroadcaster, SBCommandInterpreter, + GetBroadcaster, ()); + LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter, + GetBroadcasterClass, ()); + LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter, + GetArgumentTypeAsCString, + (const lldb::CommandArgumentType)); + LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter, + GetArgumentDescriptionAsCString, + (const lldb::CommandArgumentType)); + LLDB_REGISTER_STATIC_METHOD(bool, SBCommandInterpreter, + EventIsCommandInterpreterEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommandInterpreter, + AddMultiwordCommand, (const char *, const char *)); + LLDB_REGISTER_METHOD( + lldb::SBCommand, SBCommandInterpreter, AddCommand, + (const char *, lldb::SBCommandPluginInterface *, const char *)); + LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand, + (const char *, lldb::SBCommandPluginInterface *, + const char *, const char *)); + LLDB_REGISTER_CONSTRUCTOR(SBCommand, ()); + LLDB_REGISTER_METHOD(bool, SBCommand, IsValid, ()); + LLDB_REGISTER_METHOD(const char *, SBCommand, GetName, ()); + LLDB_REGISTER_METHOD(const char *, SBCommand, GetHelp, ()); + LLDB_REGISTER_METHOD(const char *, SBCommand, GetHelpLong, ()); + LLDB_REGISTER_METHOD(void, SBCommand, SetHelp, (const char *)); + LLDB_REGISTER_METHOD(void, SBCommand, SetHelpLong, (const char *)); + LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddMultiwordCommand, + (const char *, const char *)); + LLDB_REGISTER_METHOD( + lldb::SBCommand, SBCommand, AddCommand, + (const char *, lldb::SBCommandPluginInterface *, const char *)); + LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddCommand, + (const char *, lldb::SBCommandPluginInterface *, + const char *, const char *)); + LLDB_REGISTER_METHOD(uint32_t, SBCommand, GetFlags, ()); + LLDB_REGISTER_METHOD(void, SBCommand, SetFlags, (uint32_t)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBCommandReturnObject, ()); + LLDB_REGISTER_CONSTRUCTOR(SBCommandReturnObject, + (const lldb::SBCommandReturnObject &)); + LLDB_REGISTER_CONSTRUCTOR(SBCommandReturnObject, + (lldb_private::CommandReturnObject *)); + LLDB_REGISTER_METHOD(lldb_private::CommandReturnObject *, + SBCommandReturnObject, Release, ()); + LLDB_REGISTER_METHOD( + const lldb::SBCommandReturnObject &, + SBCommandReturnObject, operator=,(const lldb::SBCommandReturnObject &)); + LLDB_REGISTER_METHOD_CONST(bool, SBCommandReturnObject, IsValid, ()); + LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetOutput, ()); + LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetError, ()); + LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, GetOutputSize, ()); + LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, GetErrorSize, ()); + LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutOutput, (FILE *)); + LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutError, (FILE *)); + LLDB_REGISTER_METHOD(void, SBCommandReturnObject, Clear, ()); + LLDB_REGISTER_METHOD(lldb::ReturnStatus, SBCommandReturnObject, GetStatus, + ()); + LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetStatus, + (lldb::ReturnStatus)); + LLDB_REGISTER_METHOD(bool, SBCommandReturnObject, Succeeded, ()); + LLDB_REGISTER_METHOD(bool, SBCommandReturnObject, HasResult, ()); + LLDB_REGISTER_METHOD(void, SBCommandReturnObject, AppendMessage, + (const char *)); + LLDB_REGISTER_METHOD(void, SBCommandReturnObject, AppendWarning, + (const char *)); + LLDB_REGISTER_METHOD(bool, SBCommandReturnObject, GetDescription, + (lldb::SBStream &)); + LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile, + (FILE *)); + LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile, + (FILE *)); + LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile, + (FILE *, bool)); + LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile, + (FILE *, bool)); + LLDB_REGISTER_METHOD(void, SBCommandReturnObject, PutCString, + (const char *, int)); + LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetOutput, + (bool)); + LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetError, (bool)); + LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetError, + (lldb::SBError &, const char *)); + LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetError, (const char *)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBCommunication, ()); + LLDB_REGISTER_CONSTRUCTOR(SBCommunication, (const char *)); + LLDB_REGISTER_METHOD_CONST(bool, SBCommunication, IsValid, ()); + LLDB_REGISTER_METHOD(bool, SBCommunication, GetCloseOnEOF, ()); + LLDB_REGISTER_METHOD(void, SBCommunication, SetCloseOnEOF, (bool)); + LLDB_REGISTER_METHOD(lldb::ConnectionStatus, SBCommunication, Connect, + (const char *)); + LLDB_REGISTER_METHOD(lldb::ConnectionStatus, SBCommunication, + AdoptFileDesriptor, (int, bool)); + LLDB_REGISTER_METHOD(lldb::ConnectionStatus, SBCommunication, Disconnect, + ()); + LLDB_REGISTER_METHOD_CONST(bool, SBCommunication, IsConnected, ()); + LLDB_REGISTER_METHOD(bool, SBCommunication, ReadThreadStart, ()); + LLDB_REGISTER_METHOD(bool, SBCommunication, ReadThreadStop, ()); + LLDB_REGISTER_METHOD(bool, SBCommunication, ReadThreadIsRunning, ()); + LLDB_REGISTER_METHOD(lldb::SBBroadcaster, SBCommunication, GetBroadcaster, + ()); + LLDB_REGISTER_STATIC_METHOD(const char *, SBCommunication, + GetBroadcasterClass, ()); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBCompileUnit, ()); + LLDB_REGISTER_CONSTRUCTOR(SBCompileUnit, (const lldb::SBCompileUnit &)); + LLDB_REGISTER_METHOD( + const lldb::SBCompileUnit &, + SBCompileUnit, operator=,(const lldb::SBCompileUnit &)); + LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBCompileUnit, GetFileSpec, + ()); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, GetNumLineEntries, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBLineEntry, SBCompileUnit, + GetLineEntryAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex, + (uint32_t, uint32_t, lldb::SBFileSpec *)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex, + (uint32_t, uint32_t, lldb::SBFileSpec *, bool)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, GetNumSupportFiles, ()); + LLDB_REGISTER_METHOD(lldb::SBTypeList, SBCompileUnit, GetTypes, (uint32_t)); + LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBCompileUnit, + GetSupportFileAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(uint32_t, SBCompileUnit, FindSupportFileIndex, + (uint32_t, const lldb::SBFileSpec &, bool)); + LLDB_REGISTER_METHOD(lldb::LanguageType, SBCompileUnit, GetLanguage, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBCompileUnit, IsValid, ()); + LLDB_REGISTER_METHOD_CONST( + bool, SBCompileUnit, operator==,(const lldb::SBCompileUnit &)); + LLDB_REGISTER_METHOD_CONST( + bool, SBCompileUnit, operator!=,(const lldb::SBCompileUnit &)); + LLDB_REGISTER_METHOD(bool, SBCompileUnit, GetDescription, + (lldb::SBStream &)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBData, ()); + LLDB_REGISTER_CONSTRUCTOR(SBData, (const lldb::SBData &)); + LLDB_REGISTER_METHOD(const lldb::SBData &, + SBData, operator=,(const lldb::SBData &)); + LLDB_REGISTER_METHOD(bool, SBData, IsValid, ()); + LLDB_REGISTER_METHOD(uint8_t, SBData, GetAddressByteSize, ()); + LLDB_REGISTER_METHOD(void, SBData, SetAddressByteSize, (uint8_t)); + LLDB_REGISTER_METHOD(void, SBData, Clear, ()); + LLDB_REGISTER_METHOD(size_t, SBData, GetByteSize, ()); + LLDB_REGISTER_METHOD(lldb::ByteOrder, SBData, GetByteOrder, ()); + LLDB_REGISTER_METHOD(void, SBData, SetByteOrder, (lldb::ByteOrder)); + LLDB_REGISTER_METHOD(float, SBData, GetFloat, + (lldb::SBError &, lldb::offset_t)); + LLDB_REGISTER_METHOD(double, SBData, GetDouble, + (lldb::SBError &, lldb::offset_t)); + LLDB_REGISTER_METHOD(long double, SBData, GetLongDouble, + (lldb::SBError &, lldb::offset_t)); + LLDB_REGISTER_METHOD(lldb::addr_t, SBData, GetAddress, + (lldb::SBError &, lldb::offset_t)); + LLDB_REGISTER_METHOD(uint8_t, SBData, GetUnsignedInt8, + (lldb::SBError &, lldb::offset_t)); + LLDB_REGISTER_METHOD(uint16_t, SBData, GetUnsignedInt16, + (lldb::SBError &, lldb::offset_t)); + LLDB_REGISTER_METHOD(uint32_t, SBData, GetUnsignedInt32, + (lldb::SBError &, lldb::offset_t)); + LLDB_REGISTER_METHOD(uint64_t, SBData, GetUnsignedInt64, + (lldb::SBError &, lldb::offset_t)); + LLDB_REGISTER_METHOD(int8_t, SBData, GetSignedInt8, + (lldb::SBError &, lldb::offset_t)); + LLDB_REGISTER_METHOD(int16_t, SBData, GetSignedInt16, + (lldb::SBError &, lldb::offset_t)); + LLDB_REGISTER_METHOD(int32_t, SBData, GetSignedInt32, + (lldb::SBError &, lldb::offset_t)); + LLDB_REGISTER_METHOD(int64_t, SBData, GetSignedInt64, + (lldb::SBError &, lldb::offset_t)); + LLDB_REGISTER_METHOD(const char *, SBData, GetString, + (lldb::SBError &, lldb::offset_t)); + LLDB_REGISTER_METHOD(bool, SBData, GetDescription, + (lldb::SBStream &, lldb::addr_t)); + LLDB_REGISTER_METHOD(bool, SBData, Append, (const lldb::SBData &)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromCString, + (lldb::ByteOrder, uint32_t, const char *)); + LLDB_REGISTER_STATIC_METHOD( + lldb::SBData, SBData, CreateDataFromUInt64Array, + (lldb::ByteOrder, uint32_t, uint64_t *, size_t)); + LLDB_REGISTER_STATIC_METHOD( + lldb::SBData, SBData, CreateDataFromUInt32Array, + (lldb::ByteOrder, uint32_t, uint32_t *, size_t)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromSInt64Array, + (lldb::ByteOrder, uint32_t, int64_t *, size_t)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromSInt32Array, + (lldb::ByteOrder, uint32_t, int32_t *, size_t)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromDoubleArray, + (lldb::ByteOrder, uint32_t, double *, size_t)); + LLDB_REGISTER_METHOD(bool, SBData, SetDataFromCString, (const char *)); + LLDB_REGISTER_METHOD(bool, SBData, SetDataFromUInt64Array, + (uint64_t *, size_t)); + LLDB_REGISTER_METHOD(bool, SBData, SetDataFromUInt32Array, + (uint32_t *, size_t)); + LLDB_REGISTER_METHOD(bool, SBData, SetDataFromSInt64Array, + (int64_t *, size_t)); + LLDB_REGISTER_METHOD(bool, SBData, SetDataFromSInt32Array, + (int32_t *, size_t)); + LLDB_REGISTER_METHOD(bool, SBData, SetDataFromDoubleArray, + (double *, size_t)); + } + { + LLDB_REGISTER_METHOD(void, SBInputReader, SetIsDone, (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBInputReader, IsActive, ()); + LLDB_REGISTER_CONSTRUCTOR(SBDebugger, ()); + LLDB_REGISTER_CONSTRUCTOR(SBDebugger, (const lldb::DebuggerSP &)); + LLDB_REGISTER_CONSTRUCTOR(SBDebugger, (const lldb::SBDebugger &)); + LLDB_REGISTER_METHOD(lldb::SBDebugger &, + SBDebugger, operator=,(const lldb::SBDebugger &)); + LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Initialize, ()); + LLDB_REGISTER_STATIC_METHOD(lldb::SBError, SBDebugger, + InitializeWithErrorHandling, ()); + LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Terminate, ()); + LLDB_REGISTER_METHOD(void, SBDebugger, Clear, ()); + LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, ()); + LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, (bool)); + LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Destroy, + (lldb::SBDebugger &)); + LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, MemoryPressureDetected, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, IsValid, ()); + LLDB_REGISTER_METHOD(void, SBDebugger, SetAsync, (bool)); + LLDB_REGISTER_METHOD(bool, SBDebugger, GetAsync, ()); + LLDB_REGISTER_METHOD(void, SBDebugger, SkipLLDBInitFiles, (bool)); + LLDB_REGISTER_METHOD(void, SBDebugger, SkipAppInitFiles, (bool)); + LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetInputFileHandle, ()); + LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetOutputFileHandle, ()); + LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetErrorFileHandle, ()); + LLDB_REGISTER_METHOD(void, SBDebugger, SaveInputTerminalState, ()); + LLDB_REGISTER_METHOD(void, SBDebugger, RestoreInputTerminalState, ()); + LLDB_REGISTER_METHOD(lldb::SBCommandInterpreter, SBDebugger, + GetCommandInterpreter, ()); + LLDB_REGISTER_METHOD(void, SBDebugger, HandleCommand, (const char *)); + LLDB_REGISTER_METHOD(lldb::SBListener, SBDebugger, GetListener, ()); + LLDB_REGISTER_METHOD( + void, SBDebugger, HandleProcessEvent, + (const lldb::SBProcess &, const lldb::SBEvent &, FILE *, FILE *)); + LLDB_REGISTER_METHOD(lldb::SBSourceManager, SBDebugger, GetSourceManager, + ()); + LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, SetDefaultArchitecture, + (const char *)); + LLDB_REGISTER_METHOD(lldb::ScriptLanguage, SBDebugger, GetScriptingLanguage, + (const char *)); + LLDB_REGISTER_STATIC_METHOD(const char *, SBDebugger, GetVersionString, ()); + LLDB_REGISTER_STATIC_METHOD(const char *, SBDebugger, StateAsCString, + (lldb::StateType)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBStructuredData, SBDebugger, + GetBuildConfiguration, ()); + LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, StateIsRunningState, + (lldb::StateType)); + LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, StateIsStoppedState, + (lldb::StateType)); + LLDB_REGISTER_METHOD( + lldb::SBTarget, SBDebugger, CreateTarget, + (const char *, const char *, const char *, bool, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, + CreateTargetWithFileAndTargetTriple, + (const char *, const char *)); + LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, + CreateTargetWithFileAndArch, + (const char *, const char *)); + LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, CreateTarget, + (const char *)); + LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetDummyTarget, ()); + LLDB_REGISTER_METHOD(bool, SBDebugger, DeleteTarget, (lldb::SBTarget &)); + LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetTargetAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetIndexOfTarget, + (lldb::SBTarget)); + LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithProcessID, + (lldb::pid_t)); + LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithFileAndArch, + (const char *, const char *)); + LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumTargets, ()); + LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetSelectedTarget, ()); + LLDB_REGISTER_METHOD(void, SBDebugger, SetSelectedTarget, + (lldb::SBTarget &)); + LLDB_REGISTER_METHOD(lldb::SBPlatform, SBDebugger, GetSelectedPlatform, ()); + LLDB_REGISTER_METHOD(void, SBDebugger, SetSelectedPlatform, + (lldb::SBPlatform &)); + LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumPlatforms, ()); + LLDB_REGISTER_METHOD(lldb::SBPlatform, SBDebugger, GetPlatformAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumAvailablePlatforms, ()); + LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBDebugger, + GetAvailablePlatformInfoAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(void, SBDebugger, DispatchInputInterrupt, ()); + LLDB_REGISTER_METHOD(void, SBDebugger, DispatchInputEndOfFile, ()); + LLDB_REGISTER_METHOD(void, SBDebugger, PushInputReader, + (lldb::SBInputReader &)); + LLDB_REGISTER_METHOD(void, SBDebugger, RunCommandInterpreter, (bool, bool)); + LLDB_REGISTER_METHOD(void, SBDebugger, RunCommandInterpreter, + (bool, bool, lldb::SBCommandInterpreterRunOptions &, + int &, bool &, bool &)); + LLDB_REGISTER_METHOD(lldb::SBError, SBDebugger, RunREPL, + (lldb::LanguageType, const char *)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, + FindDebuggerWithID, (int)); + LLDB_REGISTER_METHOD(const char *, SBDebugger, GetInstanceName, ()); + LLDB_REGISTER_STATIC_METHOD(lldb::SBError, SBDebugger, SetInternalVariable, + (const char *, const char *, const char *)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBStringList, SBDebugger, + GetInternalVariableValue, + (const char *, const char *)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBDebugger, GetTerminalWidth, ()); + LLDB_REGISTER_METHOD(void, SBDebugger, SetTerminalWidth, (uint32_t)); + LLDB_REGISTER_METHOD_CONST(const char *, SBDebugger, GetPrompt, ()); + LLDB_REGISTER_METHOD(void, SBDebugger, SetPrompt, (const char *)); + LLDB_REGISTER_METHOD_CONST(const char *, SBDebugger, GetReproducerPath, ()); + LLDB_REGISTER_METHOD_CONST(lldb::ScriptLanguage, SBDebugger, + GetScriptLanguage, ()); + LLDB_REGISTER_METHOD(void, SBDebugger, SetScriptLanguage, + (lldb::ScriptLanguage)); + LLDB_REGISTER_METHOD(bool, SBDebugger, SetUseExternalEditor, (bool)); + LLDB_REGISTER_METHOD(bool, SBDebugger, GetUseExternalEditor, ()); + LLDB_REGISTER_METHOD(bool, SBDebugger, SetUseColor, (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, GetUseColor, ()); + LLDB_REGISTER_METHOD(bool, SBDebugger, GetDescription, (lldb::SBStream &)); + LLDB_REGISTER_METHOD(lldb::user_id_t, SBDebugger, GetID, ()); + LLDB_REGISTER_METHOD(lldb::SBError, SBDebugger, SetCurrentPlatform, + (const char *)); + LLDB_REGISTER_METHOD(bool, SBDebugger, SetCurrentPlatformSDKRoot, + (const char *)); + LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, GetCloseInputOnEOF, ()); + LLDB_REGISTER_METHOD(void, SBDebugger, SetCloseInputOnEOF, (bool)); + LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory, + (const char *)); + LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory, + (lldb::LanguageType)); + LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, CreateCategory, + (const char *)); + LLDB_REGISTER_METHOD(bool, SBDebugger, DeleteCategory, (const char *)); + LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumCategories, ()); + LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategoryAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetDefaultCategory, + ()); + LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBDebugger, GetFormatForType, + (lldb::SBTypeNameSpecifier)); + LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBDebugger, GetSummaryForType, + (lldb::SBTypeNameSpecifier)); + LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBDebugger, GetFilterForType, + (lldb::SBTypeNameSpecifier)); + LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBDebugger, GetSyntheticForType, + (lldb::SBTypeNameSpecifier)); + LLDB_REGISTER_METHOD(bool, SBDebugger, EnableLog, + (const char *, const char **)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBDeclaration, ()); + LLDB_REGISTER_CONSTRUCTOR(SBDeclaration, (const lldb::SBDeclaration &)); + LLDB_REGISTER_METHOD( + const lldb::SBDeclaration &, + SBDeclaration, operator=,(const lldb::SBDeclaration &)); + LLDB_REGISTER_METHOD_CONST(bool, SBDeclaration, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBDeclaration, GetFileSpec, + ()); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBDeclaration, GetLine, ()); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBDeclaration, GetColumn, ()); + LLDB_REGISTER_METHOD(void, SBDeclaration, SetFileSpec, (lldb::SBFileSpec)); + LLDB_REGISTER_METHOD(void, SBDeclaration, SetLine, (uint32_t)); + LLDB_REGISTER_METHOD(void, SBDeclaration, SetColumn, (uint32_t)); + LLDB_REGISTER_METHOD_CONST( + bool, SBDeclaration, operator==,(const lldb::SBDeclaration &)); + LLDB_REGISTER_METHOD_CONST( + bool, SBDeclaration, operator!=,(const lldb::SBDeclaration &)); + LLDB_REGISTER_METHOD(bool, SBDeclaration, GetDescription, + (lldb::SBStream &)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBError, ()); + LLDB_REGISTER_CONSTRUCTOR(SBError, (const lldb::SBError &)); + LLDB_REGISTER_METHOD(const lldb::SBError &, + SBError, operator=,(const lldb::SBError &)); + LLDB_REGISTER_METHOD_CONST(const char *, SBError, GetCString, ()); + LLDB_REGISTER_METHOD(void, SBError, Clear, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBError, Fail, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBError, Success, ()); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBError, GetError, ()); + LLDB_REGISTER_METHOD_CONST(lldb::ErrorType, SBError, GetType, ()); + LLDB_REGISTER_METHOD(void, SBError, SetError, (uint32_t, lldb::ErrorType)); + LLDB_REGISTER_METHOD(void, SBError, SetErrorToErrno, ()); + LLDB_REGISTER_METHOD(void, SBError, SetErrorToGenericError, ()); + LLDB_REGISTER_METHOD(void, SBError, SetErrorString, (const char *)); + LLDB_REGISTER_METHOD_CONST(bool, SBError, IsValid, ()); + LLDB_REGISTER_METHOD(bool, SBError, GetDescription, (lldb::SBStream &)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBEvent, ()); + LLDB_REGISTER_CONSTRUCTOR(SBEvent, (uint32_t, const char *, uint32_t)); + LLDB_REGISTER_CONSTRUCTOR(SBEvent, (lldb::EventSP &)); + LLDB_REGISTER_CONSTRUCTOR(SBEvent, (lldb_private::Event *)); + LLDB_REGISTER_CONSTRUCTOR(SBEvent, (const lldb::SBEvent &)); + LLDB_REGISTER_METHOD(const lldb::SBEvent &, + SBEvent, operator=,(const lldb::SBEvent &)); + LLDB_REGISTER_METHOD(const char *, SBEvent, GetDataFlavor, ()); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBEvent, GetType, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBBroadcaster, SBEvent, GetBroadcaster, + ()); + LLDB_REGISTER_METHOD_CONST(const char *, SBEvent, GetBroadcasterClass, ()); + LLDB_REGISTER_METHOD(bool, SBEvent, BroadcasterMatchesPtr, + (const lldb::SBBroadcaster *)); + LLDB_REGISTER_METHOD(bool, SBEvent, BroadcasterMatchesRef, + (const lldb::SBBroadcaster &)); + LLDB_REGISTER_METHOD(void, SBEvent, Clear, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBEvent, IsValid, ()); + LLDB_REGISTER_STATIC_METHOD(const char *, SBEvent, GetCStringFromEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_METHOD(bool, SBEvent, GetDescription, (lldb::SBStream &)); + LLDB_REGISTER_METHOD_CONST(bool, SBEvent, GetDescription, + (lldb::SBStream &)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, ()); + LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, + (const lldb::SBExecutionContext &)); + LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, + (lldb::ExecutionContextRefSP)); + LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, (const lldb::SBTarget &)); + LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, (const lldb::SBProcess &)); + LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, (lldb::SBThread)); + LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, (const lldb::SBFrame &)); + LLDB_REGISTER_METHOD( + const lldb::SBExecutionContext &, + SBExecutionContext, operator=,(const lldb::SBExecutionContext &)); + LLDB_REGISTER_METHOD_CONST(lldb::SBTarget, SBExecutionContext, GetTarget, + ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBProcess, SBExecutionContext, GetProcess, + ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBExecutionContext, GetThread, + ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBFrame, SBExecutionContext, GetFrame, ()); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBExpressionOptions, ()); + LLDB_REGISTER_CONSTRUCTOR(SBExpressionOptions, + (const lldb::SBExpressionOptions &)); + LLDB_REGISTER_METHOD( + const lldb::SBExpressionOptions &, + SBExpressionOptions, operator=,(const lldb::SBExpressionOptions &)); + LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetCoerceResultToId, + ()); + LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetCoerceResultToId, + (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetUnwindOnError, ()); + LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetUnwindOnError, (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetIgnoreBreakpoints, + ()); + LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetIgnoreBreakpoints, + (bool)); + LLDB_REGISTER_METHOD_CONST(lldb::DynamicValueType, SBExpressionOptions, + GetFetchDynamicValue, ()); + LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetFetchDynamicValue, + (lldb::DynamicValueType)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBExpressionOptions, + GetTimeoutInMicroSeconds, ()); + LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetTimeoutInMicroSeconds, + (uint32_t)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBExpressionOptions, + GetOneThreadTimeoutInMicroSeconds, ()); + LLDB_REGISTER_METHOD(void, SBExpressionOptions, + SetOneThreadTimeoutInMicroSeconds, (uint32_t)); + LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetTryAllThreads, ()); + LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetTryAllThreads, (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetStopOthers, ()); + LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetStopOthers, (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetTrapExceptions, + ()); + LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetTrapExceptions, (bool)); + LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetLanguage, + (lldb::LanguageType)); + LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetGenerateDebugInfo, ()); + LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetGenerateDebugInfo, + (bool)); + LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetSuppressPersistentResult, + ()); + LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetSuppressPersistentResult, + (bool)); + LLDB_REGISTER_METHOD_CONST(const char *, SBExpressionOptions, GetPrefix, + ()); + LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetPrefix, (const char *)); + LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetAutoApplyFixIts, ()); + LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetAutoApplyFixIts, (bool)); + LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetTopLevel, ()); + LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetTopLevel, (bool)); + LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetAllowJIT, ()); + LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetAllowJIT, (bool)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBFileSpec, ()); + LLDB_REGISTER_CONSTRUCTOR(SBFileSpec, (const lldb::SBFileSpec &)); + LLDB_REGISTER_CONSTRUCTOR(SBFileSpec, (const char *)); + LLDB_REGISTER_CONSTRUCTOR(SBFileSpec, (const char *, bool)); + LLDB_REGISTER_METHOD(const lldb::SBFileSpec &, + SBFileSpec, operator=,(const lldb::SBFileSpec &)); + LLDB_REGISTER_METHOD_CONST(bool, SBFileSpec, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBFileSpec, Exists, ()); + LLDB_REGISTER_METHOD(bool, SBFileSpec, ResolveExecutableLocation, ()); + LLDB_REGISTER_STATIC_METHOD(int, SBFileSpec, ResolvePath, + (const char *, char *, size_t)); + LLDB_REGISTER_METHOD_CONST(const char *, SBFileSpec, GetFilename, ()); + LLDB_REGISTER_METHOD_CONST(const char *, SBFileSpec, GetDirectory, ()); + LLDB_REGISTER_METHOD(void, SBFileSpec, SetFilename, (const char *)); + LLDB_REGISTER_METHOD(void, SBFileSpec, SetDirectory, (const char *)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBFileSpec, GetPath, (char *, size_t)); + LLDB_REGISTER_METHOD_CONST(bool, SBFileSpec, GetDescription, + (lldb::SBStream &)); + LLDB_REGISTER_METHOD(void, SBFileSpec, AppendPathComponent, (const char *)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBFileSpecList, ()); + LLDB_REGISTER_CONSTRUCTOR(SBFileSpecList, (const lldb::SBFileSpecList &)); + LLDB_REGISTER_METHOD( + const lldb::SBFileSpecList &, + SBFileSpecList, operator=,(const lldb::SBFileSpecList &)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBFileSpecList, GetSize, ()); + LLDB_REGISTER_METHOD(void, SBFileSpecList, Append, + (const lldb::SBFileSpec &)); + LLDB_REGISTER_METHOD(bool, SBFileSpecList, AppendIfUnique, + (const lldb::SBFileSpec &)); + LLDB_REGISTER_METHOD(void, SBFileSpecList, Clear, ()); + LLDB_REGISTER_METHOD(uint32_t, SBFileSpecList, FindFileIndex, + (uint32_t, const lldb::SBFileSpec &, bool)); + LLDB_REGISTER_METHOD_CONST(const lldb::SBFileSpec, SBFileSpecList, + GetFileSpecAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD_CONST(bool, SBFileSpecList, GetDescription, + (lldb::SBStream &)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBFrame, ()); + LLDB_REGISTER_CONSTRUCTOR(SBFrame, (const lldb::StackFrameSP &)); + LLDB_REGISTER_CONSTRUCTOR(SBFrame, (const lldb::SBFrame &)); + LLDB_REGISTER_METHOD(const lldb::SBFrame &, + SBFrame, operator=,(const lldb::SBFrame &)); + LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBSymbolContext, SBFrame, GetSymbolContext, + (uint32_t)); + LLDB_REGISTER_METHOD_CONST(lldb::SBModule, SBFrame, GetModule, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBCompileUnit, SBFrame, GetCompileUnit, + ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBFunction, SBFrame, GetFunction, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBSymbol, SBFrame, GetSymbol, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBBlock, SBFrame, GetBlock, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBBlock, SBFrame, GetFrameBlock, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBLineEntry, SBFrame, GetLineEntry, ()); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBFrame, GetFrameID, ()); + LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetCFA, ()); + LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetPC, ()); + LLDB_REGISTER_METHOD(bool, SBFrame, SetPC, (lldb::addr_t)); + LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetSP, ()); + LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetFP, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBFrame, GetPCAddress, ()); + LLDB_REGISTER_METHOD(void, SBFrame, Clear, ()); + LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath, + (const char *)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath, + (const char *, lldb::DynamicValueType)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindVariable, (const char *)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindVariable, + (const char *, lldb::DynamicValueType)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindValue, + (const char *, lldb::ValueType)); + LLDB_REGISTER_METHOD( + lldb::SBValue, SBFrame, FindValue, + (const char *, lldb::ValueType, lldb::DynamicValueType)); + LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsEqual, (const lldb::SBFrame &)); + LLDB_REGISTER_METHOD_CONST(bool, + SBFrame, operator==,(const lldb::SBFrame &)); + LLDB_REGISTER_METHOD_CONST(bool, + SBFrame, operator!=,(const lldb::SBFrame &)); + LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBFrame, GetThread, ()); + LLDB_REGISTER_METHOD_CONST(const char *, SBFrame, Disassemble, ()); + LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetVariables, + (bool, bool, bool, bool)); + LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetVariables, + (bool, bool, bool, bool, lldb::DynamicValueType)); + LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetVariables, + (const lldb::SBVariablesOptions &)); + LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetRegisters, ()); + LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindRegister, (const char *)); + LLDB_REGISTER_METHOD(bool, SBFrame, GetDescription, (lldb::SBStream &)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression, + (const char *)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression, + (const char *, lldb::DynamicValueType)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression, + (const char *, lldb::DynamicValueType, bool)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression, + (const char *, const lldb::SBExpressionOptions &)); + LLDB_REGISTER_METHOD(bool, SBFrame, IsInlined, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsInlined, ()); + LLDB_REGISTER_METHOD(bool, SBFrame, IsArtificial, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsArtificial, ()); + LLDB_REGISTER_METHOD(const char *, SBFrame, GetFunctionName, ()); + LLDB_REGISTER_METHOD_CONST(lldb::LanguageType, SBFrame, GuessLanguage, ()); + LLDB_REGISTER_METHOD_CONST(const char *, SBFrame, GetFunctionName, ()); + LLDB_REGISTER_METHOD(const char *, SBFrame, GetDisplayFunctionName, ()); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBFunction, ()); + LLDB_REGISTER_CONSTRUCTOR(SBFunction, (const lldb::SBFunction &)); + LLDB_REGISTER_METHOD(const lldb::SBFunction &, + SBFunction, operator=,(const lldb::SBFunction &)); + LLDB_REGISTER_METHOD_CONST(bool, SBFunction, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(const char *, SBFunction, GetName, ()); + LLDB_REGISTER_METHOD_CONST(const char *, SBFunction, GetDisplayName, ()); + LLDB_REGISTER_METHOD_CONST(const char *, SBFunction, GetMangledName, ()); + LLDB_REGISTER_METHOD_CONST( + bool, SBFunction, operator==,(const lldb::SBFunction &)); + LLDB_REGISTER_METHOD_CONST( + bool, SBFunction, operator!=,(const lldb::SBFunction &)); + LLDB_REGISTER_METHOD(bool, SBFunction, GetDescription, (lldb::SBStream &)); + LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions, + (lldb::SBTarget)); + LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions, + (lldb::SBTarget, const char *)); + LLDB_REGISTER_METHOD(lldb::SBAddress, SBFunction, GetStartAddress, ()); + LLDB_REGISTER_METHOD(lldb::SBAddress, SBFunction, GetEndAddress, ()); + LLDB_REGISTER_METHOD(const char *, SBFunction, GetArgumentName, (uint32_t)); + LLDB_REGISTER_METHOD(uint32_t, SBFunction, GetPrologueByteSize, ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBFunction, GetType, ()); + LLDB_REGISTER_METHOD(lldb::SBBlock, SBFunction, GetBlock, ()); + LLDB_REGISTER_METHOD(lldb::LanguageType, SBFunction, GetLanguage, ()); + LLDB_REGISTER_METHOD(bool, SBFunction, GetIsOptimized, ()); + } + { + LLDB_REGISTER_STATIC_METHOD(lldb::SBFileSpec, SBHostOS, GetProgramFileSpec, + ()); + LLDB_REGISTER_STATIC_METHOD(lldb::SBFileSpec, SBHostOS, GetLLDBPythonPath, + ()); + LLDB_REGISTER_STATIC_METHOD(lldb::SBFileSpec, SBHostOS, GetLLDBPath, + (lldb::PathType)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBFileSpec, SBHostOS, + GetUserHomeDirectory, ()); + LLDB_REGISTER_STATIC_METHOD(void, SBHostOS, ThreadCreated, (const char *)); + LLDB_REGISTER_STATIC_METHOD(bool, SBHostOS, ThreadCancel, + (lldb::thread_t, lldb::SBError *)); + LLDB_REGISTER_STATIC_METHOD(bool, SBHostOS, ThreadDetach, + (lldb::thread_t, lldb::SBError *)); + LLDB_REGISTER_STATIC_METHOD( + bool, SBHostOS, ThreadJoin, + (lldb::thread_t, lldb::thread_result_t *, lldb::SBError *)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBInstruction, ()); + LLDB_REGISTER_CONSTRUCTOR(SBInstruction, (const lldb::SBInstruction &)); + LLDB_REGISTER_METHOD( + const lldb::SBInstruction &, + SBInstruction, operator=,(const lldb::SBInstruction &)); + LLDB_REGISTER_METHOD(bool, SBInstruction, IsValid, ()); + LLDB_REGISTER_METHOD(lldb::SBAddress, SBInstruction, GetAddress, ()); + LLDB_REGISTER_METHOD(const char *, SBInstruction, GetMnemonic, + (lldb::SBTarget)); + LLDB_REGISTER_METHOD(const char *, SBInstruction, GetOperands, + (lldb::SBTarget)); + LLDB_REGISTER_METHOD(const char *, SBInstruction, GetComment, + (lldb::SBTarget)); + LLDB_REGISTER_METHOD(size_t, SBInstruction, GetByteSize, ()); + LLDB_REGISTER_METHOD(lldb::SBData, SBInstruction, GetData, + (lldb::SBTarget)); + LLDB_REGISTER_METHOD(bool, SBInstruction, DoesBranch, ()); + LLDB_REGISTER_METHOD(bool, SBInstruction, HasDelaySlot, ()); + LLDB_REGISTER_METHOD(bool, SBInstruction, CanSetBreakpoint, ()); + LLDB_REGISTER_METHOD(bool, SBInstruction, GetDescription, + (lldb::SBStream &)); + LLDB_REGISTER_METHOD(void, SBInstruction, Print, (FILE *)); + LLDB_REGISTER_METHOD(bool, SBInstruction, EmulateWithFrame, + (lldb::SBFrame &, uint32_t)); + LLDB_REGISTER_METHOD(bool, SBInstruction, DumpEmulation, (const char *)); + LLDB_REGISTER_METHOD(bool, SBInstruction, TestEmulation, + (lldb::SBStream &, const char *)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBInstructionList, ()); + LLDB_REGISTER_CONSTRUCTOR(SBInstructionList, + (const lldb::SBInstructionList &)); + LLDB_REGISTER_METHOD( + const lldb::SBInstructionList &, + SBInstructionList, operator=,(const lldb::SBInstructionList &)); + LLDB_REGISTER_METHOD_CONST(bool, SBInstructionList, IsValid, ()); + LLDB_REGISTER_METHOD(size_t, SBInstructionList, GetSize, ()); + LLDB_REGISTER_METHOD(lldb::SBInstruction, SBInstructionList, + GetInstructionAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD( + size_t, SBInstructionList, GetInstructionsCount, + (const lldb::SBAddress &, const lldb::SBAddress &, bool)); + LLDB_REGISTER_METHOD(void, SBInstructionList, Clear, ()); + LLDB_REGISTER_METHOD(void, SBInstructionList, AppendInstruction, + (lldb::SBInstruction)); + LLDB_REGISTER_METHOD(void, SBInstructionList, Print, (FILE *)); + LLDB_REGISTER_METHOD(bool, SBInstructionList, GetDescription, + (lldb::SBStream &)); + LLDB_REGISTER_METHOD(bool, SBInstructionList, + DumpEmulationForAllInstructions, (const char *)); + } + { + LLDB_REGISTER_STATIC_METHOD(lldb::LanguageType, SBLanguageRuntime, + GetLanguageTypeFromString, (const char *)); + LLDB_REGISTER_STATIC_METHOD(const char *, SBLanguageRuntime, + GetNameForLanguageType, (lldb::LanguageType)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBLaunchInfo, (const char **)); + LLDB_REGISTER_METHOD(lldb::pid_t, SBLaunchInfo, GetProcessID, ()); + LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetUserID, ()); + LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetGroupID, ()); + LLDB_REGISTER_METHOD(bool, SBLaunchInfo, UserIDIsValid, ()); + LLDB_REGISTER_METHOD(bool, SBLaunchInfo, GroupIDIsValid, ()); + LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetUserID, (uint32_t)); + LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetGroupID, (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBLaunchInfo, GetExecutableFile, ()); + LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetExecutableFile, + (lldb::SBFileSpec, bool)); + LLDB_REGISTER_METHOD(lldb::SBListener, SBLaunchInfo, GetListener, ()); + LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetListener, (lldb::SBListener &)); + LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetNumArguments, ()); + LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetArgumentAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetArguments, + (const char **, bool)); + LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetNumEnvironmentEntries, ()); + LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetEnvironmentEntryAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetEnvironmentEntries, + (const char **, bool)); + LLDB_REGISTER_METHOD(void, SBLaunchInfo, Clear, ()); + LLDB_REGISTER_METHOD_CONST(const char *, SBLaunchInfo, GetWorkingDirectory, + ()); + LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetWorkingDirectory, + (const char *)); + LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetLaunchFlags, ()); + LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetLaunchFlags, (uint32_t)); + LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetProcessPluginName, ()); + LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetProcessPluginName, + (const char *)); + LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetShell, ()); + LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetShell, (const char *)); + LLDB_REGISTER_METHOD(bool, SBLaunchInfo, GetShellExpandArguments, ()); + LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetShellExpandArguments, (bool)); + LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetResumeCount, ()); + LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetResumeCount, (uint32_t)); + LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddCloseFileAction, (int)); + LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddDuplicateFileAction, + (int, int)); + LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddOpenFileAction, + (int, const char *, bool, bool)); + LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddSuppressFileAction, + (int, bool, bool)); + LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetLaunchEventData, + (const char *)); + LLDB_REGISTER_METHOD_CONST(const char *, SBLaunchInfo, GetLaunchEventData, + ()); + LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetDetachOnError, (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBLaunchInfo, GetDetachOnError, ()); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBLineEntry, ()); + LLDB_REGISTER_CONSTRUCTOR(SBLineEntry, (const lldb::SBLineEntry &)); + LLDB_REGISTER_METHOD(const lldb::SBLineEntry &, + SBLineEntry, operator=,(const lldb::SBLineEntry &)); + LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBLineEntry, GetStartAddress, + ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBLineEntry, GetEndAddress, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBLineEntry, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBLineEntry, GetFileSpec, ()); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBLineEntry, GetLine, ()); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBLineEntry, GetColumn, ()); + LLDB_REGISTER_METHOD(void, SBLineEntry, SetFileSpec, (lldb::SBFileSpec)); + LLDB_REGISTER_METHOD(void, SBLineEntry, SetLine, (uint32_t)); + LLDB_REGISTER_METHOD(void, SBLineEntry, SetColumn, (uint32_t)); + LLDB_REGISTER_METHOD_CONST( + bool, SBLineEntry, operator==,(const lldb::SBLineEntry &)); + LLDB_REGISTER_METHOD_CONST( + bool, SBLineEntry, operator!=,(const lldb::SBLineEntry &)); + LLDB_REGISTER_METHOD(bool, SBLineEntry, GetDescription, (lldb::SBStream &)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBListener, ()); + LLDB_REGISTER_CONSTRUCTOR(SBListener, (const char *)); + LLDB_REGISTER_CONSTRUCTOR(SBListener, (const lldb::SBListener &)); + LLDB_REGISTER_METHOD(const lldb::SBListener &, + SBListener, operator=,(const lldb::SBListener &)); + LLDB_REGISTER_METHOD_CONST(bool, SBListener, IsValid, ()); + LLDB_REGISTER_METHOD(void, SBListener, AddEvent, (const lldb::SBEvent &)); + LLDB_REGISTER_METHOD(void, SBListener, Clear, ()); + LLDB_REGISTER_METHOD(uint32_t, SBListener, StartListeningForEventClass, + (lldb::SBDebugger &, const char *, uint32_t)); + LLDB_REGISTER_METHOD(bool, SBListener, StopListeningForEventClass, + (lldb::SBDebugger &, const char *, uint32_t)); + LLDB_REGISTER_METHOD(uint32_t, SBListener, StartListeningForEvents, + (const lldb::SBBroadcaster &, uint32_t)); + LLDB_REGISTER_METHOD(bool, SBListener, StopListeningForEvents, + (const lldb::SBBroadcaster &, uint32_t)); + LLDB_REGISTER_METHOD(bool, SBListener, WaitForEvent, + (uint32_t, lldb::SBEvent &)); + LLDB_REGISTER_METHOD( + bool, SBListener, WaitForEventForBroadcaster, + (uint32_t, const lldb::SBBroadcaster &, lldb::SBEvent &)); + LLDB_REGISTER_METHOD( + bool, SBListener, WaitForEventForBroadcasterWithType, + (uint32_t, const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &)); + LLDB_REGISTER_METHOD(bool, SBListener, PeekAtNextEvent, (lldb::SBEvent &)); + LLDB_REGISTER_METHOD(bool, SBListener, PeekAtNextEventForBroadcaster, + (const lldb::SBBroadcaster &, lldb::SBEvent &)); + LLDB_REGISTER_METHOD( + bool, SBListener, PeekAtNextEventForBroadcasterWithType, + (const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &)); + LLDB_REGISTER_METHOD(bool, SBListener, GetNextEvent, (lldb::SBEvent &)); + LLDB_REGISTER_METHOD(bool, SBListener, GetNextEventForBroadcaster, + (const lldb::SBBroadcaster &, lldb::SBEvent &)); + LLDB_REGISTER_METHOD( + bool, SBListener, GetNextEventForBroadcasterWithType, + (const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &)); + LLDB_REGISTER_METHOD(bool, SBListener, HandleBroadcastEvent, + (const lldb::SBEvent &)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfo, ()); + LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfo, + (const lldb::SBMemoryRegionInfo &)); + LLDB_REGISTER_METHOD( + const lldb::SBMemoryRegionInfo &, + SBMemoryRegionInfo, operator=,(const lldb::SBMemoryRegionInfo &)); + LLDB_REGISTER_METHOD(void, SBMemoryRegionInfo, Clear, ()); + LLDB_REGISTER_METHOD_CONST( + bool, + SBMemoryRegionInfo, operator==,(const lldb::SBMemoryRegionInfo &)); + LLDB_REGISTER_METHOD_CONST( + bool, + SBMemoryRegionInfo, operator!=,(const lldb::SBMemoryRegionInfo &)); + LLDB_REGISTER_METHOD(lldb::addr_t, SBMemoryRegionInfo, GetRegionBase, ()); + LLDB_REGISTER_METHOD(lldb::addr_t, SBMemoryRegionInfo, GetRegionEnd, ()); + LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsReadable, ()); + LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsWritable, ()); + LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsExecutable, ()); + LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsMapped, ()); + LLDB_REGISTER_METHOD(const char *, SBMemoryRegionInfo, GetName, ()); + LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, GetDescription, + (lldb::SBStream &)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfoList, ()); + LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfoList, + (const lldb::SBMemoryRegionInfoList &)); + LLDB_REGISTER_METHOD( + const lldb::SBMemoryRegionInfoList &, + SBMemoryRegionInfoList, operator=,( + const lldb::SBMemoryRegionInfoList &)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBMemoryRegionInfoList, GetSize, ()); + LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfoList, GetMemoryRegionAtIndex, + (uint32_t, lldb::SBMemoryRegionInfo &)); + LLDB_REGISTER_METHOD(void, SBMemoryRegionInfoList, Clear, ()); + LLDB_REGISTER_METHOD(void, SBMemoryRegionInfoList, Append, + (lldb::SBMemoryRegionInfo &)); + LLDB_REGISTER_METHOD(void, SBMemoryRegionInfoList, Append, + (lldb::SBMemoryRegionInfoList &)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBModule, ()); + LLDB_REGISTER_CONSTRUCTOR(SBModule, (const lldb::SBModuleSpec &)); + LLDB_REGISTER_CONSTRUCTOR(SBModule, (const lldb::SBModule &)); + LLDB_REGISTER_CONSTRUCTOR(SBModule, (lldb::SBProcess &, lldb::addr_t)); + LLDB_REGISTER_METHOD(const lldb::SBModule &, + SBModule, operator=,(const lldb::SBModule &)); + LLDB_REGISTER_METHOD_CONST(bool, SBModule, IsValid, ()); + LLDB_REGISTER_METHOD(void, SBModule, Clear, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBModule, GetFileSpec, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBModule, GetPlatformFileSpec, + ()); + LLDB_REGISTER_METHOD(bool, SBModule, SetPlatformFileSpec, + (const lldb::SBFileSpec &)); + LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModule, GetRemoteInstallFileSpec, + ()); + LLDB_REGISTER_METHOD(bool, SBModule, SetRemoteInstallFileSpec, + (lldb::SBFileSpec &)); + LLDB_REGISTER_METHOD_CONST(const char *, SBModule, GetUUIDString, ()); + LLDB_REGISTER_METHOD_CONST(bool, + SBModule, operator==,(const lldb::SBModule &)); + LLDB_REGISTER_METHOD_CONST(bool, + SBModule, operator!=,(const lldb::SBModule &)); + LLDB_REGISTER_METHOD(lldb::SBAddress, SBModule, ResolveFileAddress, + (lldb::addr_t)); + LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBModule, + ResolveSymbolContextForAddress, + (const lldb::SBAddress &, uint32_t)); + LLDB_REGISTER_METHOD(bool, SBModule, GetDescription, (lldb::SBStream &)); + LLDB_REGISTER_METHOD(uint32_t, SBModule, GetNumCompileUnits, ()); + LLDB_REGISTER_METHOD(lldb::SBCompileUnit, SBModule, GetCompileUnitAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBModule, FindCompileUnits, + (const lldb::SBFileSpec &)); + LLDB_REGISTER_METHOD(size_t, SBModule, GetNumSymbols, ()); + LLDB_REGISTER_METHOD(lldb::SBSymbol, SBModule, GetSymbolAtIndex, (size_t)); + LLDB_REGISTER_METHOD(lldb::SBSymbol, SBModule, FindSymbol, + (const char *, lldb::SymbolType)); + LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBModule, FindSymbols, + (const char *, lldb::SymbolType)); + LLDB_REGISTER_METHOD(size_t, SBModule, GetNumSections, ()); + LLDB_REGISTER_METHOD(lldb::SBSection, SBModule, GetSectionAtIndex, + (size_t)); + LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBModule, FindFunctions, + (const char *, uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBValueList, SBModule, FindGlobalVariables, + (lldb::SBTarget &, const char *, uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBModule, FindFirstGlobalVariable, + (lldb::SBTarget &, const char *)); + LLDB_REGISTER_METHOD(lldb::SBType, SBModule, FindFirstType, (const char *)); + LLDB_REGISTER_METHOD(lldb::SBType, SBModule, GetBasicType, + (lldb::BasicType)); + LLDB_REGISTER_METHOD(lldb::SBTypeList, SBModule, FindTypes, (const char *)); + LLDB_REGISTER_METHOD(lldb::SBType, SBModule, GetTypeByID, + (lldb::user_id_t)); + LLDB_REGISTER_METHOD(lldb::SBTypeList, SBModule, GetTypes, (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBSection, SBModule, FindSection, + (const char *)); + LLDB_REGISTER_METHOD(lldb::ByteOrder, SBModule, GetByteOrder, ()); + LLDB_REGISTER_METHOD(const char *, SBModule, GetTriple, ()); + LLDB_REGISTER_METHOD(uint32_t, SBModule, GetAddressByteSize, ()); + LLDB_REGISTER_METHOD(uint32_t, SBModule, GetVersion, + (uint32_t *, uint32_t)); + LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBModule, GetSymbolFileSpec, + ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBModule, + GetObjectFileHeaderAddress, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBModule, + GetObjectFileEntryPointAddress, ()); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBModuleSpec, ()); + LLDB_REGISTER_CONSTRUCTOR(SBModuleSpec, (const lldb::SBModuleSpec &)); + LLDB_REGISTER_METHOD(const lldb::SBModuleSpec &, + SBModuleSpec, operator=,(const lldb::SBModuleSpec &)); + LLDB_REGISTER_METHOD_CONST(bool, SBModuleSpec, IsValid, ()); + LLDB_REGISTER_METHOD(void, SBModuleSpec, Clear, ()); + LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModuleSpec, GetFileSpec, ()); + LLDB_REGISTER_METHOD(void, SBModuleSpec, SetFileSpec, + (const lldb::SBFileSpec &)); + LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModuleSpec, GetPlatformFileSpec, + ()); + LLDB_REGISTER_METHOD(void, SBModuleSpec, SetPlatformFileSpec, + (const lldb::SBFileSpec &)); + LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModuleSpec, GetSymbolFileSpec, ()); + LLDB_REGISTER_METHOD(void, SBModuleSpec, SetSymbolFileSpec, + (const lldb::SBFileSpec &)); + LLDB_REGISTER_METHOD(const char *, SBModuleSpec, GetObjectName, ()); + LLDB_REGISTER_METHOD(void, SBModuleSpec, SetObjectName, (const char *)); + LLDB_REGISTER_METHOD(const char *, SBModuleSpec, GetTriple, ()); + LLDB_REGISTER_METHOD(void, SBModuleSpec, SetTriple, (const char *)); + LLDB_REGISTER_METHOD(size_t, SBModuleSpec, GetUUIDLength, ()); + LLDB_REGISTER_METHOD(bool, SBModuleSpec, GetDescription, + (lldb::SBStream &)); + LLDB_REGISTER_CONSTRUCTOR(SBModuleSpecList, ()); + LLDB_REGISTER_CONSTRUCTOR(SBModuleSpecList, + (const lldb::SBModuleSpecList &)); + LLDB_REGISTER_METHOD( + lldb::SBModuleSpecList &, + SBModuleSpecList, operator=,(const lldb::SBModuleSpecList &)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBModuleSpecList, SBModuleSpecList, + GetModuleSpecifications, (const char *)); + LLDB_REGISTER_METHOD(void, SBModuleSpecList, Append, + (const lldb::SBModuleSpec &)); + LLDB_REGISTER_METHOD(void, SBModuleSpecList, Append, + (const lldb::SBModuleSpecList &)); + LLDB_REGISTER_METHOD(size_t, SBModuleSpecList, GetSize, ()); + LLDB_REGISTER_METHOD(lldb::SBModuleSpec, SBModuleSpecList, GetSpecAtIndex, + (size_t)); + LLDB_REGISTER_METHOD(lldb::SBModuleSpec, SBModuleSpecList, + FindFirstMatchingSpec, (const lldb::SBModuleSpec &)); + LLDB_REGISTER_METHOD(lldb::SBModuleSpecList, SBModuleSpecList, + FindMatchingSpecs, (const lldb::SBModuleSpec &)); + LLDB_REGISTER_METHOD(bool, SBModuleSpecList, GetDescription, + (lldb::SBStream &)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBPlatformConnectOptions, (const char *)); + LLDB_REGISTER_CONSTRUCTOR(SBPlatformConnectOptions, + (const lldb::SBPlatformConnectOptions &)); + LLDB_REGISTER_METHOD( + void, + SBPlatformConnectOptions, operator=,( + const lldb::SBPlatformConnectOptions &)); + LLDB_REGISTER_METHOD(const char *, SBPlatformConnectOptions, GetURL, ()); + LLDB_REGISTER_METHOD(void, SBPlatformConnectOptions, SetURL, + (const char *)); + LLDB_REGISTER_METHOD(bool, SBPlatformConnectOptions, GetRsyncEnabled, ()); + LLDB_REGISTER_METHOD(void, SBPlatformConnectOptions, EnableRsync, + (const char *, const char *, bool)); + LLDB_REGISTER_METHOD(void, SBPlatformConnectOptions, DisableRsync, ()); + LLDB_REGISTER_METHOD(const char *, SBPlatformConnectOptions, + GetLocalCacheDirectory, ()); + LLDB_REGISTER_METHOD(void, SBPlatformConnectOptions, SetLocalCacheDirectory, + (const char *)); + LLDB_REGISTER_CONSTRUCTOR(SBPlatformShellCommand, (const char *)); + LLDB_REGISTER_CONSTRUCTOR(SBPlatformShellCommand, + (const lldb::SBPlatformShellCommand &)); + LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, Clear, ()); + LLDB_REGISTER_METHOD(const char *, SBPlatformShellCommand, GetCommand, ()); + LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, SetCommand, + (const char *)); + LLDB_REGISTER_METHOD(const char *, SBPlatformShellCommand, + GetWorkingDirectory, ()); + LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, SetWorkingDirectory, + (const char *)); + LLDB_REGISTER_METHOD(uint32_t, SBPlatformShellCommand, GetTimeoutSeconds, + ()); + LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, SetTimeoutSeconds, + (uint32_t)); + LLDB_REGISTER_METHOD(int, SBPlatformShellCommand, GetSignal, ()); + LLDB_REGISTER_METHOD(int, SBPlatformShellCommand, GetStatus, ()); + LLDB_REGISTER_METHOD(const char *, SBPlatformShellCommand, GetOutput, ()); + LLDB_REGISTER_CONSTRUCTOR(SBPlatform, ()); + LLDB_REGISTER_CONSTRUCTOR(SBPlatform, (const char *)); + LLDB_REGISTER_METHOD_CONST(bool, SBPlatform, IsValid, ()); + LLDB_REGISTER_METHOD(void, SBPlatform, Clear, ()); + LLDB_REGISTER_METHOD(const char *, SBPlatform, GetName, ()); + LLDB_REGISTER_METHOD(const char *, SBPlatform, GetWorkingDirectory, ()); + LLDB_REGISTER_METHOD(bool, SBPlatform, SetWorkingDirectory, (const char *)); + LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, ConnectRemote, + (lldb::SBPlatformConnectOptions &)); + LLDB_REGISTER_METHOD(void, SBPlatform, DisconnectRemote, ()); + LLDB_REGISTER_METHOD(bool, SBPlatform, IsConnected, ()); + LLDB_REGISTER_METHOD(const char *, SBPlatform, GetTriple, ()); + LLDB_REGISTER_METHOD(const char *, SBPlatform, GetOSBuild, ()); + LLDB_REGISTER_METHOD(const char *, SBPlatform, GetOSDescription, ()); + LLDB_REGISTER_METHOD(const char *, SBPlatform, GetHostname, ()); + LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetOSMajorVersion, ()); + LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetOSMinorVersion, ()); + LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetOSUpdateVersion, ()); + LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Get, + (lldb::SBFileSpec &, lldb::SBFileSpec &)); + LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Put, + (lldb::SBFileSpec &, lldb::SBFileSpec &)); + LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Install, + (lldb::SBFileSpec &, lldb::SBFileSpec &)); + LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Run, + (lldb::SBPlatformShellCommand &)); + LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Launch, + (lldb::SBLaunchInfo &)); + LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Kill, (const lldb::pid_t)); + LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, MakeDirectory, + (const char *, uint32_t)); + LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetFilePermissions, + (const char *)); + LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, SetFilePermissions, + (const char *, uint32_t)); + LLDB_REGISTER_METHOD_CONST(lldb::SBUnixSignals, SBPlatform, GetUnixSignals, + ()); + } + { + 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(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, ()); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBProcessInfo, ()); + LLDB_REGISTER_CONSTRUCTOR(SBProcessInfo, (const lldb::SBProcessInfo &)); + LLDB_REGISTER_METHOD( + lldb::SBProcessInfo &, + SBProcessInfo, operator=,(const lldb::SBProcessInfo &)); + LLDB_REGISTER_METHOD_CONST(bool, SBProcessInfo, IsValid, ()); + LLDB_REGISTER_METHOD(const char *, SBProcessInfo, GetName, ()); + LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBProcessInfo, GetExecutableFile, + ()); + LLDB_REGISTER_METHOD(lldb::pid_t, SBProcessInfo, GetProcessID, ()); + LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetUserID, ()); + LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetGroupID, ()); + LLDB_REGISTER_METHOD(bool, SBProcessInfo, UserIDIsValid, ()); + LLDB_REGISTER_METHOD(bool, SBProcessInfo, GroupIDIsValid, ()); + LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetEffectiveUserID, ()); + LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetEffectiveGroupID, ()); + LLDB_REGISTER_METHOD(bool, SBProcessInfo, EffectiveUserIDIsValid, ()); + LLDB_REGISTER_METHOD(bool, SBProcessInfo, EffectiveGroupIDIsValid, ()); + LLDB_REGISTER_METHOD(lldb::pid_t, SBProcessInfo, GetParentProcessID, ()); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBQueue, ()); + LLDB_REGISTER_CONSTRUCTOR(SBQueue, (const lldb::QueueSP &)); + LLDB_REGISTER_CONSTRUCTOR(SBQueue, (const lldb::SBQueue &)); + LLDB_REGISTER_METHOD(const lldb::SBQueue &, + SBQueue, operator=,(const lldb::SBQueue &)); + LLDB_REGISTER_METHOD_CONST(bool, SBQueue, IsValid, ()); + LLDB_REGISTER_METHOD(void, SBQueue, Clear, ()); + LLDB_REGISTER_METHOD_CONST(lldb::queue_id_t, SBQueue, GetQueueID, ()); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBQueue, GetIndexID, ()); + LLDB_REGISTER_METHOD_CONST(const char *, SBQueue, GetName, ()); + LLDB_REGISTER_METHOD(uint32_t, SBQueue, GetNumThreads, ()); + LLDB_REGISTER_METHOD(lldb::SBThread, SBQueue, GetThreadAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(uint32_t, SBQueue, GetNumPendingItems, ()); + LLDB_REGISTER_METHOD(lldb::SBQueueItem, SBQueue, GetPendingItemAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD(uint32_t, SBQueue, GetNumRunningItems, ()); + LLDB_REGISTER_METHOD(lldb::SBProcess, SBQueue, GetProcess, ()); + LLDB_REGISTER_METHOD(lldb::QueueKind, SBQueue, GetKind, ()); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBQueueItem, ()); + LLDB_REGISTER_CONSTRUCTOR(SBQueueItem, (const lldb::QueueItemSP &)); + LLDB_REGISTER_METHOD_CONST(bool, SBQueueItem, IsValid, ()); + LLDB_REGISTER_METHOD(void, SBQueueItem, Clear, ()); + LLDB_REGISTER_METHOD(void, SBQueueItem, SetQueueItem, + (const lldb::QueueItemSP &)); + LLDB_REGISTER_METHOD_CONST(lldb::QueueItemKind, SBQueueItem, GetKind, ()); + LLDB_REGISTER_METHOD(void, SBQueueItem, SetKind, (lldb::QueueItemKind)); + LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBQueueItem, GetAddress, ()); + LLDB_REGISTER_METHOD(void, SBQueueItem, SetAddress, (lldb::SBAddress)); + LLDB_REGISTER_METHOD(lldb::SBThread, SBQueueItem, + GetExtendedBacktraceThread, (const char *)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBSection, ()); + LLDB_REGISTER_CONSTRUCTOR(SBSection, (const lldb::SBSection &)); + LLDB_REGISTER_METHOD(const lldb::SBSection &, + SBSection, operator=,(const lldb::SBSection &)); + LLDB_REGISTER_METHOD_CONST(bool, SBSection, IsValid, ()); + LLDB_REGISTER_METHOD(const char *, SBSection, GetName, ()); + LLDB_REGISTER_METHOD(lldb::SBSection, SBSection, GetParent, ()); + LLDB_REGISTER_METHOD(lldb::SBSection, SBSection, FindSubSection, + (const char *)); + LLDB_REGISTER_METHOD(size_t, SBSection, GetNumSubSections, ()); + LLDB_REGISTER_METHOD(lldb::SBSection, SBSection, GetSubSectionAtIndex, + (size_t)); + LLDB_REGISTER_METHOD(lldb::addr_t, SBSection, GetFileAddress, ()); + LLDB_REGISTER_METHOD(lldb::addr_t, SBSection, GetLoadAddress, + (lldb::SBTarget &)); + LLDB_REGISTER_METHOD(lldb::addr_t, SBSection, GetByteSize, ()); + LLDB_REGISTER_METHOD(uint64_t, SBSection, GetFileOffset, ()); + LLDB_REGISTER_METHOD(uint64_t, SBSection, GetFileByteSize, ()); + LLDB_REGISTER_METHOD(lldb::SBData, SBSection, GetSectionData, ()); + LLDB_REGISTER_METHOD(lldb::SBData, SBSection, GetSectionData, + (uint64_t, uint64_t)); + LLDB_REGISTER_METHOD(lldb::SectionType, SBSection, GetSectionType, ()); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBSection, GetPermissions, ()); + LLDB_REGISTER_METHOD(uint32_t, SBSection, GetTargetByteSize, ()); + LLDB_REGISTER_METHOD(bool, SBSection, operator==,(const lldb::SBSection &)); + LLDB_REGISTER_METHOD(bool, SBSection, operator!=,(const lldb::SBSection &)); + LLDB_REGISTER_METHOD(bool, SBSection, GetDescription, (lldb::SBStream &)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBSourceManager, (const lldb::SBDebugger &)); + LLDB_REGISTER_CONSTRUCTOR(SBSourceManager, (const lldb::SBTarget &)); + LLDB_REGISTER_CONSTRUCTOR(SBSourceManager, (const lldb::SBSourceManager &)); + LLDB_REGISTER_METHOD( + const lldb::SBSourceManager &, + SBSourceManager, operator=,(const lldb::SBSourceManager &)); + LLDB_REGISTER_METHOD(size_t, SBSourceManager, + DisplaySourceLinesWithLineNumbers, + (const lldb::SBFileSpec &, uint32_t, uint32_t, + uint32_t, const char *, lldb::SBStream &)); + LLDB_REGISTER_METHOD(size_t, SBSourceManager, + DisplaySourceLinesWithLineNumbersAndColumn, + (const lldb::SBFileSpec &, uint32_t, uint32_t, + uint32_t, uint32_t, const char *, lldb::SBStream &)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBStream, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBStream, IsValid, ()); + LLDB_REGISTER_METHOD(const char *, SBStream, GetData, ()); + LLDB_REGISTER_METHOD(size_t, SBStream, GetSize, ()); + LLDB_REGISTER_METHOD(void, SBStream, RedirectToFile, (const char *, bool)); + LLDB_REGISTER_METHOD(void, SBStream, RedirectToFileHandle, (FILE *, bool)); + LLDB_REGISTER_METHOD(void, SBStream, RedirectToFileDescriptor, (int, bool)); + LLDB_REGISTER_METHOD(void, SBStream, Clear, ()); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBStringList, ()); + LLDB_REGISTER_CONSTRUCTOR(SBStringList, (const lldb::SBStringList &)); + LLDB_REGISTER_METHOD(const lldb::SBStringList &, + SBStringList, operator=,(const lldb::SBStringList &)); + LLDB_REGISTER_METHOD_CONST(bool, SBStringList, IsValid, ()); + LLDB_REGISTER_METHOD(void, SBStringList, AppendString, (const char *)); + LLDB_REGISTER_METHOD(void, SBStringList, AppendList, (const char **, int)); + LLDB_REGISTER_METHOD(void, SBStringList, AppendList, + (const lldb::SBStringList &)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBStringList, GetSize, ()); + LLDB_REGISTER_METHOD(const char *, SBStringList, GetStringAtIndex, + (size_t)); + LLDB_REGISTER_METHOD_CONST(const char *, SBStringList, GetStringAtIndex, + (size_t)); + LLDB_REGISTER_METHOD(void, SBStringList, Clear, ()); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBStructuredData, ()); + LLDB_REGISTER_CONSTRUCTOR(SBStructuredData, + (const lldb::SBStructuredData &)); + LLDB_REGISTER_CONSTRUCTOR(SBStructuredData, (const lldb::EventSP &)); + LLDB_REGISTER_CONSTRUCTOR(SBStructuredData, + (lldb_private::StructuredDataImpl *)); + LLDB_REGISTER_METHOD( + lldb::SBStructuredData &, + SBStructuredData, operator=,(const lldb::SBStructuredData &)); + LLDB_REGISTER_METHOD(lldb::SBError, SBStructuredData, SetFromJSON, + (lldb::SBStream &)); + LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, IsValid, ()); + LLDB_REGISTER_METHOD(void, SBStructuredData, Clear, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBError, SBStructuredData, GetAsJSON, + (lldb::SBStream &)); + LLDB_REGISTER_METHOD_CONST(lldb::SBError, SBStructuredData, GetDescription, + (lldb::SBStream &)); + LLDB_REGISTER_METHOD_CONST(lldb::StructuredDataType, SBStructuredData, + GetType, ()); + LLDB_REGISTER_METHOD_CONST(size_t, SBStructuredData, GetSize, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, GetKeys, + (lldb::SBStringList &)); + LLDB_REGISTER_METHOD_CONST(lldb::SBStructuredData, SBStructuredData, + GetValueForKey, (const char *)); + LLDB_REGISTER_METHOD_CONST(lldb::SBStructuredData, SBStructuredData, + GetItemAtIndex, (size_t)); + LLDB_REGISTER_METHOD_CONST(uint64_t, SBStructuredData, GetIntegerValue, + (uint64_t)); + LLDB_REGISTER_METHOD_CONST(double, SBStructuredData, GetFloatValue, + (double)); + LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, GetBooleanValue, (bool)); + LLDB_REGISTER_METHOD_CONST(size_t, SBStructuredData, GetStringValue, + (char *, size_t)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBSymbol, ()); + LLDB_REGISTER_CONSTRUCTOR(SBSymbol, (const lldb::SBSymbol &)); + LLDB_REGISTER_METHOD(const lldb::SBSymbol &, + SBSymbol, operator=,(const lldb::SBSymbol &)); + LLDB_REGISTER_METHOD_CONST(bool, SBSymbol, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(const char *, SBSymbol, GetName, ()); + LLDB_REGISTER_METHOD_CONST(const char *, SBSymbol, GetDisplayName, ()); + LLDB_REGISTER_METHOD_CONST(const char *, SBSymbol, GetMangledName, ()); + LLDB_REGISTER_METHOD_CONST(bool, + SBSymbol, operator==,(const lldb::SBSymbol &)); + LLDB_REGISTER_METHOD_CONST(bool, + SBSymbol, operator!=,(const lldb::SBSymbol &)); + LLDB_REGISTER_METHOD(bool, SBSymbol, GetDescription, (lldb::SBStream &)); + LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions, + (lldb::SBTarget)); + LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions, + (lldb::SBTarget, const char *)); + LLDB_REGISTER_METHOD(lldb::SBAddress, SBSymbol, GetStartAddress, ()); + LLDB_REGISTER_METHOD(lldb::SBAddress, SBSymbol, GetEndAddress, ()); + LLDB_REGISTER_METHOD(uint32_t, SBSymbol, GetPrologueByteSize, ()); + LLDB_REGISTER_METHOD(lldb::SymbolType, SBSymbol, GetType, ()); + LLDB_REGISTER_METHOD(bool, SBSymbol, IsExternal, ()); + LLDB_REGISTER_METHOD(bool, SBSymbol, IsSynthetic, ()); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext, ()); + LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext, + (const lldb_private::SymbolContext *)); + LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext, (const lldb::SBSymbolContext &)); + LLDB_REGISTER_METHOD( + const lldb::SBSymbolContext &, + SBSymbolContext, operator=,(const lldb::SBSymbolContext &)); + LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContext, IsValid, ()); + LLDB_REGISTER_METHOD(lldb::SBModule, SBSymbolContext, GetModule, ()); + LLDB_REGISTER_METHOD(lldb::SBCompileUnit, SBSymbolContext, GetCompileUnit, + ()); + LLDB_REGISTER_METHOD(lldb::SBFunction, SBSymbolContext, GetFunction, ()); + LLDB_REGISTER_METHOD(lldb::SBBlock, SBSymbolContext, GetBlock, ()); + LLDB_REGISTER_METHOD(lldb::SBLineEntry, SBSymbolContext, GetLineEntry, ()); + LLDB_REGISTER_METHOD(lldb::SBSymbol, SBSymbolContext, GetSymbol, ()); + LLDB_REGISTER_METHOD(void, SBSymbolContext, SetModule, (lldb::SBModule)); + LLDB_REGISTER_METHOD(void, SBSymbolContext, SetCompileUnit, + (lldb::SBCompileUnit)); + LLDB_REGISTER_METHOD(void, SBSymbolContext, SetFunction, + (lldb::SBFunction)); + LLDB_REGISTER_METHOD(void, SBSymbolContext, SetBlock, (lldb::SBBlock)); + LLDB_REGISTER_METHOD(void, SBSymbolContext, SetLineEntry, + (lldb::SBLineEntry)); + LLDB_REGISTER_METHOD(void, SBSymbolContext, SetSymbol, (lldb::SBSymbol)); + LLDB_REGISTER_METHOD(bool, SBSymbolContext, GetDescription, + (lldb::SBStream &)); + LLDB_REGISTER_METHOD_CONST(lldb::SBSymbolContext, SBSymbolContext, + GetParentOfInlinedScope, + (const lldb::SBAddress &, lldb::SBAddress &)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBSymbolContextList, ()); + LLDB_REGISTER_CONSTRUCTOR(SBSymbolContextList, + (const lldb::SBSymbolContextList &)); + LLDB_REGISTER_METHOD( + const lldb::SBSymbolContextList &, + SBSymbolContextList, operator=,(const lldb::SBSymbolContextList &)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBSymbolContextList, GetSize, ()); + LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBSymbolContextList, + GetContextAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(void, SBSymbolContextList, Clear, ()); + LLDB_REGISTER_METHOD(void, SBSymbolContextList, Append, + (lldb::SBSymbolContext &)); + LLDB_REGISTER_METHOD(void, SBSymbolContextList, Append, + (lldb::SBSymbolContextList &)); + LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContextList, IsValid, ()); + LLDB_REGISTER_METHOD(bool, SBSymbolContextList, GetDescription, + (lldb::SBStream &)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBTarget, ()); + LLDB_REGISTER_CONSTRUCTOR(SBTarget, (const lldb::SBTarget &)); + LLDB_REGISTER_CONSTRUCTOR(SBTarget, (const lldb::TargetSP &)); + LLDB_REGISTER_METHOD(const lldb::SBTarget &, + SBTarget, operator=,(const lldb::SBTarget &)); + LLDB_REGISTER_STATIC_METHOD(bool, SBTarget, EventIsTargetEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBTarget, SBTarget, GetTargetFromEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_STATIC_METHOD(uint32_t, SBTarget, GetNumModulesFromEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBModule, SBTarget, + GetModuleAtIndexFromEvent, + (const uint32_t, const lldb::SBEvent &)); + LLDB_REGISTER_STATIC_METHOD(const char *, SBTarget, GetBroadcasterClassName, + ()); + LLDB_REGISTER_METHOD_CONST(bool, SBTarget, IsValid, ()); + LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, GetProcess, ()); + LLDB_REGISTER_METHOD(lldb::SBPlatform, SBTarget, GetPlatform, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBDebugger, SBTarget, GetDebugger, ()); + LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBTarget, GetStatistics, ()); + LLDB_REGISTER_METHOD(void, SBTarget, SetCollectingStats, (bool)); + LLDB_REGISTER_METHOD(bool, SBTarget, GetCollectingStats, ()); + LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LoadCore, (const char *)); + LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LoadCore, + (const char *, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LaunchSimple, + (const char **, const char **, const char *)); + LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, Install, ()); + LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, Launch, + (lldb::SBListener &, const char **, const char **, + const char *, const char *, const char *, + const char *, uint32_t, bool, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, Launch, + (lldb::SBLaunchInfo &, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, Attach, + (lldb::SBAttachInfo &, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, AttachToProcessWithID, + (lldb::SBListener &, lldb::pid_t, lldb::SBError &)); + LLDB_REGISTER_METHOD( + lldb::SBProcess, SBTarget, AttachToProcessWithName, + (lldb::SBListener &, const char *, bool, lldb::SBError &)); + LLDB_REGISTER_METHOD( + lldb::SBProcess, SBTarget, ConnectRemote, + (lldb::SBListener &, const char *, const char *, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBTarget, GetExecutable, ()); + LLDB_REGISTER_METHOD_CONST(bool, + SBTarget, operator==,(const lldb::SBTarget &)); + LLDB_REGISTER_METHOD_CONST(bool, + SBTarget, operator!=,(const lldb::SBTarget &)); + LLDB_REGISTER_METHOD(lldb::SBAddress, SBTarget, ResolveLoadAddress, + (lldb::addr_t)); + LLDB_REGISTER_METHOD(lldb::SBAddress, SBTarget, ResolveFileAddress, + (lldb::addr_t)); + LLDB_REGISTER_METHOD(lldb::SBAddress, SBTarget, ResolvePastLoadAddress, + (uint32_t, lldb::addr_t)); + LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBTarget, + ResolveSymbolContextForAddress, + (const lldb::SBAddress &, uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, + BreakpointCreateByLocation, (const char *, uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, + BreakpointCreateByLocation, + (const lldb::SBFileSpec &, uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, + BreakpointCreateByLocation, + (const lldb::SBFileSpec &, uint32_t, lldb::addr_t)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, + BreakpointCreateByLocation, + (const lldb::SBFileSpec &, uint32_t, lldb::addr_t, + lldb::SBFileSpecList &)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, + BreakpointCreateByLocation, + (const lldb::SBFileSpec &, uint32_t, uint32_t, + lldb::addr_t, lldb::SBFileSpecList &)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName, + (const char *, const char *)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName, + (const char *, const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName, + (const char *, uint32_t, const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName, + (const char *, uint32_t, lldb::LanguageType, + const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames, + (const char **, uint32_t, uint32_t, + const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames, + (const char **, uint32_t, uint32_t, lldb::LanguageType, + const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames, + (const char **, uint32_t, uint32_t, lldb::LanguageType, + lldb::addr_t, const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex, + (const char *, const char *)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex, + (const char *, const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex, + (const char *, lldb::LanguageType, + const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, + BreakpointCreateByAddress, (lldb::addr_t)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, + BreakpointCreateBySBAddress, (lldb::SBAddress &)); + LLDB_REGISTER_METHOD( + lldb::SBBreakpoint, SBTarget, BreakpointCreateBySourceRegex, + (const char *, const lldb::SBFileSpec &, const char *)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, + BreakpointCreateBySourceRegex, + (const char *, const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &)); + LLDB_REGISTER_METHOD( + lldb::SBBreakpoint, SBTarget, BreakpointCreateBySourceRegex, + (const char *, const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &, const lldb::SBStringList &)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, + BreakpointCreateForException, + (lldb::LanguageType, bool, bool)); + LLDB_REGISTER_METHOD( + lldb::SBBreakpoint, SBTarget, BreakpointCreateFromScript, + (const char *, lldb::SBStructuredData &, const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &, bool)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetNumBreakpoints, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBBreakpoint, SBTarget, + GetBreakpointAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(bool, SBTarget, BreakpointDelete, (lldb::break_id_t)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, FindBreakpointByID, + (lldb::break_id_t)); + LLDB_REGISTER_METHOD(bool, SBTarget, FindBreakpointsByName, + (const char *, lldb::SBBreakpointList &)); + LLDB_REGISTER_METHOD(void, SBTarget, GetBreakpointNames, + (lldb::SBStringList &)); + LLDB_REGISTER_METHOD(void, SBTarget, DeleteBreakpointName, (const char *)); + LLDB_REGISTER_METHOD(bool, SBTarget, EnableAllBreakpoints, ()); + LLDB_REGISTER_METHOD(bool, SBTarget, DisableAllBreakpoints, ()); + LLDB_REGISTER_METHOD(bool, SBTarget, DeleteAllBreakpoints, ()); + LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, BreakpointsCreateFromFile, + (lldb::SBFileSpec &, lldb::SBBreakpointList &)); + LLDB_REGISTER_METHOD( + lldb::SBError, SBTarget, BreakpointsCreateFromFile, + (lldb::SBFileSpec &, lldb::SBStringList &, lldb::SBBreakpointList &)); + LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile, + (lldb::SBFileSpec &)); + LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile, + (lldb::SBFileSpec &, lldb::SBBreakpointList &, bool)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetNumWatchpoints, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBWatchpoint, SBTarget, + GetWatchpointAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(bool, SBTarget, DeleteWatchpoint, (lldb::watch_id_t)); + LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBTarget, FindWatchpointByID, + (lldb::watch_id_t)); + LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBTarget, WatchAddress, + (lldb::addr_t, size_t, bool, bool, lldb::SBError &)); + LLDB_REGISTER_METHOD(bool, SBTarget, EnableAllWatchpoints, ()); + LLDB_REGISTER_METHOD(bool, SBTarget, DisableAllWatchpoints, ()); + LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, CreateValueFromAddress, + (const char *, lldb::SBAddress, lldb::SBType)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, CreateValueFromData, + (const char *, lldb::SBData, lldb::SBType)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, CreateValueFromExpression, + (const char *, const char *)); + LLDB_REGISTER_METHOD(bool, SBTarget, DeleteAllWatchpoints, ()); + LLDB_REGISTER_METHOD(void, SBTarget, AppendImageSearchPath, + (const char *, const char *, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, AddModule, + (const char *, const char *, const char *)); + LLDB_REGISTER_METHOD( + lldb::SBModule, SBTarget, AddModule, + (const char *, const char *, const char *, const char *)); + LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, AddModule, + (const lldb::SBModuleSpec &)); + LLDB_REGISTER_METHOD(bool, SBTarget, AddModule, (lldb::SBModule &)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetNumModules, ()); + LLDB_REGISTER_METHOD(void, SBTarget, Clear, ()); + LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, FindModule, + (const lldb::SBFileSpec &)); + LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, FindCompileUnits, + (const lldb::SBFileSpec &)); + LLDB_REGISTER_METHOD(lldb::ByteOrder, SBTarget, GetByteOrder, ()); + LLDB_REGISTER_METHOD(const char *, SBTarget, GetTriple, ()); + LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetDataByteSize, ()); + LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetCodeByteSize, ()); + LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetAddressByteSize, ()); + LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, GetModuleAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD(bool, SBTarget, RemoveModule, (lldb::SBModule)); + LLDB_REGISTER_METHOD_CONST(lldb::SBBroadcaster, SBTarget, GetBroadcaster, + ()); + LLDB_REGISTER_METHOD(bool, SBTarget, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel)); + LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, FindFunctions, + (const char *, uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, + FindGlobalFunctions, + (const char *, uint32_t, lldb::MatchType)); + LLDB_REGISTER_METHOD(lldb::SBType, SBTarget, FindFirstType, (const char *)); + LLDB_REGISTER_METHOD(lldb::SBType, SBTarget, GetBasicType, + (lldb::BasicType)); + LLDB_REGISTER_METHOD(lldb::SBTypeList, SBTarget, FindTypes, (const char *)); + LLDB_REGISTER_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables, + (const char *, uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables, + (const char *, uint32_t, lldb::MatchType)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, FindFirstGlobalVariable, + (const char *)); + LLDB_REGISTER_METHOD(lldb::SBSourceManager, SBTarget, GetSourceManager, ()); + LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions, + (lldb::SBAddress, uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions, + (lldb::SBAddress, uint32_t, const char *)); + LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, SetSectionLoadAddress, + (lldb::SBSection, lldb::addr_t)); + LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, ClearSectionLoadAddress, + (lldb::SBSection)); + LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, SetModuleLoadAddress, + (lldb::SBModule, int64_t)); + LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, ClearModuleLoadAddress, + (lldb::SBModule)); + LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, FindSymbols, + (const char *, lldb::SymbolType)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, EvaluateExpression, + (const char *)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, EvaluateExpression, + (const char *, const lldb::SBExpressionOptions &)); + LLDB_REGISTER_METHOD(lldb::addr_t, SBTarget, GetStackRedZoneSize, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBLaunchInfo, SBTarget, GetLaunchInfo, ()); + LLDB_REGISTER_METHOD(void, SBTarget, SetLaunchInfo, + (const lldb::SBLaunchInfo &)); + } + { + LLDB_REGISTER_STATIC_METHOD(const char *, SBThread, GetBroadcasterClassName, + ()); + LLDB_REGISTER_CONSTRUCTOR(SBThread, ()); + LLDB_REGISTER_CONSTRUCTOR(SBThread, (const lldb::ThreadSP &)); + LLDB_REGISTER_CONSTRUCTOR(SBThread, (const lldb::SBThread &)); + LLDB_REGISTER_METHOD(const lldb::SBThread &, + SBThread, operator=,(const lldb::SBThread &)); + LLDB_REGISTER_METHOD_CONST(lldb::SBQueue, SBThread, GetQueue, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBThread, IsValid, ()); + LLDB_REGISTER_METHOD(void, SBThread, Clear, ()); + LLDB_REGISTER_METHOD(lldb::StopReason, SBThread, GetStopReason, ()); + LLDB_REGISTER_METHOD(size_t, SBThread, GetStopReasonDataCount, ()); + LLDB_REGISTER_METHOD(uint64_t, SBThread, GetStopReasonDataAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD(bool, SBThread, GetStopReasonExtendedInfoAsJSON, + (lldb::SBStream &)); + LLDB_REGISTER_METHOD(lldb::SBThreadCollection, SBThread, + GetStopReasonExtendedBacktraces, + (lldb::InstrumentationRuntimeType)); + LLDB_REGISTER_METHOD(size_t, SBThread, GetStopDescription, + (char *, size_t)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBThread, GetStopReturnValue, ()); + LLDB_REGISTER_METHOD_CONST(lldb::tid_t, SBThread, GetThreadID, ()); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBThread, GetIndexID, ()); + LLDB_REGISTER_METHOD_CONST(const char *, SBThread, GetName, ()); + LLDB_REGISTER_METHOD_CONST(const char *, SBThread, GetQueueName, ()); + LLDB_REGISTER_METHOD_CONST(lldb::queue_id_t, SBThread, GetQueueID, ()); + LLDB_REGISTER_METHOD(bool, SBThread, GetInfoItemByPathAsString, + (const char *, lldb::SBStream &)); + LLDB_REGISTER_METHOD(void, SBThread, StepOver, (lldb::RunMode)); + LLDB_REGISTER_METHOD(void, SBThread, StepOver, + (lldb::RunMode, lldb::SBError &)); + LLDB_REGISTER_METHOD(void, SBThread, StepInto, (lldb::RunMode)); + LLDB_REGISTER_METHOD(void, SBThread, StepInto, + (const char *, lldb::RunMode)); + LLDB_REGISTER_METHOD( + void, SBThread, StepInto, + (const char *, uint32_t, lldb::SBError &, lldb::RunMode)); + LLDB_REGISTER_METHOD(void, SBThread, StepOut, ()); + LLDB_REGISTER_METHOD(void, SBThread, StepOut, (lldb::SBError &)); + LLDB_REGISTER_METHOD(void, SBThread, StepOutOfFrame, (lldb::SBFrame &)); + LLDB_REGISTER_METHOD(void, SBThread, StepOutOfFrame, + (lldb::SBFrame &, lldb::SBError &)); + LLDB_REGISTER_METHOD(void, SBThread, StepInstruction, (bool)); + LLDB_REGISTER_METHOD(void, SBThread, StepInstruction, + (bool, lldb::SBError &)); + LLDB_REGISTER_METHOD(void, SBThread, RunToAddress, (lldb::addr_t)); + LLDB_REGISTER_METHOD(void, SBThread, RunToAddress, + (lldb::addr_t, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBError, SBThread, StepOverUntil, + (lldb::SBFrame &, lldb::SBFileSpec &, uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan, + (const char *)); + LLDB_REGISTER_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan, + (const char *, bool)); + LLDB_REGISTER_METHOD(lldb::SBError, SBThread, JumpToLine, + (lldb::SBFileSpec &, uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBError, SBThread, ReturnFromFrame, + (lldb::SBFrame &, lldb::SBValue &)); + LLDB_REGISTER_METHOD(lldb::SBError, SBThread, UnwindInnermostExpression, + ()); + LLDB_REGISTER_METHOD(bool, SBThread, Suspend, ()); + LLDB_REGISTER_METHOD(bool, SBThread, Suspend, (lldb::SBError &)); + LLDB_REGISTER_METHOD(bool, SBThread, Resume, ()); + LLDB_REGISTER_METHOD(bool, SBThread, Resume, (lldb::SBError &)); + LLDB_REGISTER_METHOD(bool, SBThread, IsSuspended, ()); + LLDB_REGISTER_METHOD(bool, SBThread, IsStopped, ()); + LLDB_REGISTER_METHOD(lldb::SBProcess, SBThread, GetProcess, ()); + LLDB_REGISTER_METHOD(uint32_t, SBThread, GetNumFrames, ()); + LLDB_REGISTER_METHOD(lldb::SBFrame, SBThread, GetFrameAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBFrame, SBThread, GetSelectedFrame, ()); + LLDB_REGISTER_METHOD(lldb::SBFrame, SBThread, SetSelectedFrame, (uint32_t)); + LLDB_REGISTER_STATIC_METHOD(bool, SBThread, EventIsThreadEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBFrame, SBThread, GetStackFrameFromEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBThread, SBThread, GetThreadFromEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_METHOD_CONST(bool, + SBThread, operator==,(const lldb::SBThread &)); + LLDB_REGISTER_METHOD_CONST(bool, + SBThread, operator!=,(const lldb::SBThread &)); + LLDB_REGISTER_METHOD_CONST(bool, SBThread, GetStatus, (lldb::SBStream &)); + LLDB_REGISTER_METHOD_CONST(bool, SBThread, GetDescription, + (lldb::SBStream &)); + LLDB_REGISTER_METHOD_CONST(bool, SBThread, GetDescription, + (lldb::SBStream &, bool)); + LLDB_REGISTER_METHOD(lldb::SBThread, SBThread, GetExtendedBacktraceThread, + (const char *)); + LLDB_REGISTER_METHOD(uint32_t, SBThread, + GetExtendedBacktraceOriginatingIndexID, ()); + LLDB_REGISTER_METHOD(lldb::SBValue, SBThread, GetCurrentException, ()); + LLDB_REGISTER_METHOD(lldb::SBThread, SBThread, GetCurrentExceptionBacktrace, + ()); + LLDB_REGISTER_METHOD(bool, SBThread, SafeToCallFunctions, ()); + LLDB_REGISTER_METHOD(lldb_private::Thread *, SBThread, operator->,()); + LLDB_REGISTER_METHOD(lldb_private::Thread *, SBThread, get, ()); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBThreadCollection, ()); + LLDB_REGISTER_CONSTRUCTOR(SBThreadCollection, + (const lldb::SBThreadCollection &)); + LLDB_REGISTER_METHOD( + const lldb::SBThreadCollection &, + SBThreadCollection, operator=,(const lldb::SBThreadCollection &)); + LLDB_REGISTER_METHOD_CONST(bool, SBThreadCollection, IsValid, ()); + LLDB_REGISTER_METHOD(size_t, SBThreadCollection, GetSize, ()); + LLDB_REGISTER_METHOD(lldb::SBThread, SBThreadCollection, GetThreadAtIndex, + (size_t)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, ()); + LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (const lldb::ThreadPlanSP &)); + LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (const lldb::SBThreadPlan &)); + LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (lldb::SBThread &, const char *)); + LLDB_REGISTER_METHOD(const lldb::SBThreadPlan &, + SBThreadPlan, operator=,(const lldb::SBThreadPlan &)); + LLDB_REGISTER_METHOD(lldb_private::ThreadPlan *, SBThreadPlan, get, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBThreadPlan, IsValid, ()); + LLDB_REGISTER_METHOD(void, SBThreadPlan, Clear, ()); + LLDB_REGISTER_METHOD(lldb::StopReason, SBThreadPlan, GetStopReason, ()); + LLDB_REGISTER_METHOD(size_t, SBThreadPlan, GetStopReasonDataCount, ()); + LLDB_REGISTER_METHOD(uint64_t, SBThreadPlan, GetStopReasonDataAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBThreadPlan, GetThread, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBThreadPlan, GetDescription, + (lldb::SBStream &)); + LLDB_REGISTER_METHOD(void, SBThreadPlan, SetPlanComplete, (bool)); + LLDB_REGISTER_METHOD(bool, SBThreadPlan, IsPlanComplete, ()); + LLDB_REGISTER_METHOD(bool, SBThreadPlan, IsPlanStale, ()); + LLDB_REGISTER_METHOD(bool, SBThreadPlan, IsValid, ()); + LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForStepOverRange, + (lldb::SBAddress &, lldb::addr_t)); + LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForStepOverRange, + (lldb::SBAddress &, lldb::addr_t, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForStepInRange, + (lldb::SBAddress &, lldb::addr_t)); + LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForStepInRange, + (lldb::SBAddress &, lldb::addr_t, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForStepOut, (uint32_t, bool)); + LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForStepOut, + (uint32_t, bool, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForRunToAddress, (lldb::SBAddress)); + LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForRunToAddress, + (lldb::SBAddress, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForStepScripted, (const char *)); + LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForStepScripted, + (const char *, lldb::SBError &)); + } + { + LLDB_REGISTER_METHOD(void, SBTrace, StopTrace, + (lldb::SBError &, lldb::tid_t)); + LLDB_REGISTER_METHOD(void, SBTrace, GetTraceConfig, + (lldb::SBTraceOptions &, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::user_id_t, SBTrace, GetTraceUID, ()); + LLDB_REGISTER_CONSTRUCTOR(SBTrace, ()); + LLDB_REGISTER_METHOD(bool, SBTrace, IsValid, ()); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBTraceOptions, ()); + LLDB_REGISTER_METHOD_CONST(lldb::TraceType, SBTraceOptions, getType, ()); + LLDB_REGISTER_METHOD_CONST(uint64_t, SBTraceOptions, getTraceBufferSize, + ()); + LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBTraceOptions, getTraceParams, + (lldb::SBError &)); + LLDB_REGISTER_METHOD_CONST(uint64_t, SBTraceOptions, getMetaDataBufferSize, + ()); + LLDB_REGISTER_METHOD(void, SBTraceOptions, setTraceParams, + (lldb::SBStructuredData &)); + LLDB_REGISTER_METHOD(void, SBTraceOptions, setType, (lldb::TraceType)); + LLDB_REGISTER_METHOD(void, SBTraceOptions, setTraceBufferSize, (uint64_t)); + LLDB_REGISTER_METHOD(void, SBTraceOptions, setMetaDataBufferSize, + (uint64_t)); + LLDB_REGISTER_METHOD(bool, SBTraceOptions, IsValid, ()); + LLDB_REGISTER_METHOD(void, SBTraceOptions, setThreadID, (lldb::tid_t)); + LLDB_REGISTER_METHOD(lldb::tid_t, SBTraceOptions, getThreadID, ()); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBType, ()); + LLDB_REGISTER_CONSTRUCTOR(SBType, (const lldb::SBType &)); + LLDB_REGISTER_METHOD(bool, SBType, operator==,(lldb::SBType &)); + LLDB_REGISTER_METHOD(bool, SBType, operator!=,(lldb::SBType &)); + LLDB_REGISTER_METHOD(lldb::SBType &, + SBType, operator=,(const lldb::SBType &)); + LLDB_REGISTER_METHOD_CONST(bool, SBType, IsValid, ()); + LLDB_REGISTER_METHOD(uint64_t, SBType, GetByteSize, ()); + LLDB_REGISTER_METHOD(bool, SBType, IsPointerType, ()); + LLDB_REGISTER_METHOD(bool, SBType, IsArrayType, ()); + LLDB_REGISTER_METHOD(bool, SBType, IsVectorType, ()); + LLDB_REGISTER_METHOD(bool, SBType, IsReferenceType, ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetPointerType, ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetPointeeType, ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetReferenceType, ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetTypedefedType, ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetDereferencedType, ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetArrayElementType, ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetArrayType, (uint64_t)); + LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetVectorElementType, ()); + LLDB_REGISTER_METHOD(bool, SBType, IsFunctionType, ()); + LLDB_REGISTER_METHOD(bool, SBType, IsPolymorphicClass, ()); + LLDB_REGISTER_METHOD(bool, SBType, IsTypedefType, ()); + LLDB_REGISTER_METHOD(bool, SBType, IsAnonymousType, ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetFunctionReturnType, ()); + LLDB_REGISTER_METHOD(lldb::SBTypeList, SBType, GetFunctionArgumentTypes, + ()); + LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfMemberFunctions, ()); + LLDB_REGISTER_METHOD(lldb::SBTypeMemberFunction, SBType, + GetMemberFunctionAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetUnqualifiedType, ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetCanonicalType, ()); + LLDB_REGISTER_METHOD(lldb::BasicType, SBType, GetBasicType, ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetBasicType, (lldb::BasicType)); + LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfDirectBaseClasses, ()); + LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfVirtualBaseClasses, ()); + LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfFields, ()); + LLDB_REGISTER_METHOD(bool, SBType, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel)); + LLDB_REGISTER_METHOD(lldb::SBTypeMember, SBType, GetDirectBaseClassAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBTypeMember, SBType, GetVirtualBaseClassAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBTypeEnumMemberList, SBType, GetEnumMembers, + ()); + LLDB_REGISTER_METHOD(lldb::SBTypeMember, SBType, GetFieldAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD(bool, SBType, IsTypeComplete, ()); + LLDB_REGISTER_METHOD(uint32_t, SBType, GetTypeFlags, ()); + LLDB_REGISTER_METHOD(const char *, SBType, GetName, ()); + LLDB_REGISTER_METHOD(const char *, SBType, GetDisplayTypeName, ()); + LLDB_REGISTER_METHOD(lldb::TypeClass, SBType, GetTypeClass, ()); + LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfTemplateArguments, ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetTemplateArgumentType, + (uint32_t)); + LLDB_REGISTER_METHOD(lldb::TemplateArgumentKind, SBType, + GetTemplateArgumentKind, (uint32_t)); + LLDB_REGISTER_CONSTRUCTOR(SBTypeList, ()); + LLDB_REGISTER_CONSTRUCTOR(SBTypeList, (const lldb::SBTypeList &)); + LLDB_REGISTER_METHOD(bool, SBTypeList, IsValid, ()); + LLDB_REGISTER_METHOD(lldb::SBTypeList &, + SBTypeList, operator=,(const lldb::SBTypeList &)); + LLDB_REGISTER_METHOD(void, SBTypeList, Append, (lldb::SBType)); + LLDB_REGISTER_METHOD(lldb::SBType, SBTypeList, GetTypeAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(uint32_t, SBTypeList, GetSize, ()); + LLDB_REGISTER_CONSTRUCTOR(SBTypeMember, ()); + LLDB_REGISTER_CONSTRUCTOR(SBTypeMember, (const lldb::SBTypeMember &)); + LLDB_REGISTER_METHOD(lldb::SBTypeMember &, + SBTypeMember, operator=,(const lldb::SBTypeMember &)); + LLDB_REGISTER_METHOD_CONST(bool, SBTypeMember, IsValid, ()); + LLDB_REGISTER_METHOD(const char *, SBTypeMember, GetName, ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMember, GetType, ()); + LLDB_REGISTER_METHOD(uint64_t, SBTypeMember, GetOffsetInBytes, ()); + LLDB_REGISTER_METHOD(uint64_t, SBTypeMember, GetOffsetInBits, ()); + LLDB_REGISTER_METHOD(bool, SBTypeMember, IsBitfield, ()); + LLDB_REGISTER_METHOD(uint32_t, SBTypeMember, GetBitfieldSizeInBits, ()); + LLDB_REGISTER_METHOD(bool, SBTypeMember, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel)); + LLDB_REGISTER_CONSTRUCTOR(SBTypeMemberFunction, ()); + LLDB_REGISTER_CONSTRUCTOR(SBTypeMemberFunction, + (const lldb::SBTypeMemberFunction &)); + LLDB_REGISTER_METHOD( + lldb::SBTypeMemberFunction &, + SBTypeMemberFunction, operator=,(const lldb::SBTypeMemberFunction &)); + LLDB_REGISTER_METHOD_CONST(bool, SBTypeMemberFunction, IsValid, ()); + LLDB_REGISTER_METHOD(const char *, SBTypeMemberFunction, GetName, ()); + LLDB_REGISTER_METHOD(const char *, SBTypeMemberFunction, GetDemangledName, + ()); + LLDB_REGISTER_METHOD(const char *, SBTypeMemberFunction, GetMangledName, + ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMemberFunction, GetType, ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMemberFunction, GetReturnType, ()); + LLDB_REGISTER_METHOD(uint32_t, SBTypeMemberFunction, GetNumberOfArguments, + ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMemberFunction, + GetArgumentTypeAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(lldb::MemberFunctionKind, SBTypeMemberFunction, + GetKind, ()); + LLDB_REGISTER_METHOD(bool, SBTypeMemberFunction, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBTypeCategory, ()); + LLDB_REGISTER_CONSTRUCTOR(SBTypeCategory, (const lldb::SBTypeCategory &)); + LLDB_REGISTER_METHOD_CONST(bool, SBTypeCategory, IsValid, ()); + LLDB_REGISTER_METHOD(bool, SBTypeCategory, GetEnabled, ()); + LLDB_REGISTER_METHOD(void, SBTypeCategory, SetEnabled, (bool)); + LLDB_REGISTER_METHOD(const char *, SBTypeCategory, GetName, ()); + LLDB_REGISTER_METHOD(lldb::LanguageType, SBTypeCategory, GetLanguageAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumLanguages, ()); + LLDB_REGISTER_METHOD(void, SBTypeCategory, AddLanguage, + (lldb::LanguageType)); + LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumFormats, ()); + LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumSummaries, ()); + LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumFilters, ()); + LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumSynthetics, ()); + LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory, + GetTypeNameSpecifierForFilterAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory, + GetTypeNameSpecifierForFormatAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory, + GetTypeNameSpecifierForSummaryAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory, + GetTypeNameSpecifierForSyntheticAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterForType, + (lldb::SBTypeNameSpecifier)); + LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatForType, + (lldb::SBTypeNameSpecifier)); + LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryForType, + (lldb::SBTypeNameSpecifier)); + LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBTypeCategory, + GetSyntheticForType, (lldb::SBTypeNameSpecifier)); + LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBTypeCategory, + GetSyntheticAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeFormat, + (lldb::SBTypeNameSpecifier, lldb::SBTypeFormat)); + LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeFormat, + (lldb::SBTypeNameSpecifier)); + LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeSummary, + (lldb::SBTypeNameSpecifier, lldb::SBTypeSummary)); + LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeSummary, + (lldb::SBTypeNameSpecifier)); + LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeFilter, + (lldb::SBTypeNameSpecifier, lldb::SBTypeFilter)); + LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeFilter, + (lldb::SBTypeNameSpecifier)); + LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeSynthetic, + (lldb::SBTypeNameSpecifier, lldb::SBTypeSynthetic)); + LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeSynthetic, + (lldb::SBTypeNameSpecifier)); + LLDB_REGISTER_METHOD(bool, SBTypeCategory, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel)); + LLDB_REGISTER_METHOD( + lldb::SBTypeCategory &, + SBTypeCategory, operator=,(const lldb::SBTypeCategory &)); + LLDB_REGISTER_METHOD(bool, + SBTypeCategory, operator==,(lldb::SBTypeCategory &)); + LLDB_REGISTER_METHOD(bool, + SBTypeCategory, operator!=,(lldb::SBTypeCategory &)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMember, ()); + LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMember, + (const lldb::SBTypeEnumMember &)); + LLDB_REGISTER_METHOD( + lldb::SBTypeEnumMember &, + SBTypeEnumMember, operator=,(const lldb::SBTypeEnumMember &)); + LLDB_REGISTER_METHOD_CONST(bool, SBTypeEnumMember, IsValid, ()); + LLDB_REGISTER_METHOD(const char *, SBTypeEnumMember, GetName, ()); + LLDB_REGISTER_METHOD(int64_t, SBTypeEnumMember, GetValueAsSigned, ()); + LLDB_REGISTER_METHOD(uint64_t, SBTypeEnumMember, GetValueAsUnsigned, ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBTypeEnumMember, GetType, ()); + LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMemberList, ()); + LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMemberList, + (const lldb::SBTypeEnumMemberList &)); + LLDB_REGISTER_METHOD(bool, SBTypeEnumMemberList, IsValid, ()); + LLDB_REGISTER_METHOD( + lldb::SBTypeEnumMemberList &, + SBTypeEnumMemberList, operator=,(const lldb::SBTypeEnumMemberList &)); + LLDB_REGISTER_METHOD(void, SBTypeEnumMemberList, Append, + (lldb::SBTypeEnumMember)); + LLDB_REGISTER_METHOD(lldb::SBTypeEnumMember, SBTypeEnumMemberList, + GetTypeEnumMemberAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(uint32_t, SBTypeEnumMemberList, GetSize, ()); + LLDB_REGISTER_METHOD(bool, SBTypeEnumMember, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBTypeFilter, ()); + LLDB_REGISTER_CONSTRUCTOR(SBTypeFilter, (uint32_t)); + LLDB_REGISTER_CONSTRUCTOR(SBTypeFilter, (const lldb::SBTypeFilter &)); + LLDB_REGISTER_METHOD_CONST(bool, SBTypeFilter, IsValid, ()); + LLDB_REGISTER_METHOD(uint32_t, SBTypeFilter, GetOptions, ()); + LLDB_REGISTER_METHOD(void, SBTypeFilter, SetOptions, (uint32_t)); + LLDB_REGISTER_METHOD(bool, SBTypeFilter, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel)); + LLDB_REGISTER_METHOD(void, SBTypeFilter, Clear, ()); + LLDB_REGISTER_METHOD(uint32_t, SBTypeFilter, GetNumberOfExpressionPaths, + ()); + LLDB_REGISTER_METHOD(const char *, SBTypeFilter, GetExpressionPathAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD(bool, SBTypeFilter, ReplaceExpressionPathAtIndex, + (uint32_t, const char *)); + LLDB_REGISTER_METHOD(void, SBTypeFilter, AppendExpressionPath, + (const char *)); + LLDB_REGISTER_METHOD(lldb::SBTypeFilter &, + SBTypeFilter, operator=,(const lldb::SBTypeFilter &)); + LLDB_REGISTER_METHOD(bool, SBTypeFilter, operator==,(lldb::SBTypeFilter &)); + LLDB_REGISTER_METHOD(bool, SBTypeFilter, IsEqualTo, (lldb::SBTypeFilter &)); + LLDB_REGISTER_METHOD(bool, SBTypeFilter, operator!=,(lldb::SBTypeFilter &)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBTypeFormat, ()); + LLDB_REGISTER_CONSTRUCTOR(SBTypeFormat, (lldb::Format, uint32_t)); + LLDB_REGISTER_CONSTRUCTOR(SBTypeFormat, (const char *, uint32_t)); + LLDB_REGISTER_CONSTRUCTOR(SBTypeFormat, (const lldb::SBTypeFormat &)); + LLDB_REGISTER_METHOD_CONST(bool, SBTypeFormat, IsValid, ()); + LLDB_REGISTER_METHOD(lldb::Format, SBTypeFormat, GetFormat, ()); + LLDB_REGISTER_METHOD(const char *, SBTypeFormat, GetTypeName, ()); + LLDB_REGISTER_METHOD(uint32_t, SBTypeFormat, GetOptions, ()); + LLDB_REGISTER_METHOD(void, SBTypeFormat, SetFormat, (lldb::Format)); + LLDB_REGISTER_METHOD(void, SBTypeFormat, SetTypeName, (const char *)); + LLDB_REGISTER_METHOD(void, SBTypeFormat, SetOptions, (uint32_t)); + LLDB_REGISTER_METHOD(bool, SBTypeFormat, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel)); + LLDB_REGISTER_METHOD(lldb::SBTypeFormat &, + SBTypeFormat, operator=,(const lldb::SBTypeFormat &)); + LLDB_REGISTER_METHOD(bool, SBTypeFormat, operator==,(lldb::SBTypeFormat &)); + LLDB_REGISTER_METHOD(bool, SBTypeFormat, IsEqualTo, (lldb::SBTypeFormat &)); + LLDB_REGISTER_METHOD(bool, SBTypeFormat, operator!=,(lldb::SBTypeFormat &)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier, ()); + LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier, (const char *, bool)); + LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier, (lldb::SBType)); + LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier, + (const lldb::SBTypeNameSpecifier &)); + LLDB_REGISTER_METHOD_CONST(bool, SBTypeNameSpecifier, IsValid, ()); + LLDB_REGISTER_METHOD(const char *, SBTypeNameSpecifier, GetName, ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBTypeNameSpecifier, GetType, ()); + LLDB_REGISTER_METHOD(bool, SBTypeNameSpecifier, IsRegex, ()); + LLDB_REGISTER_METHOD(bool, SBTypeNameSpecifier, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel)); + LLDB_REGISTER_METHOD( + lldb::SBTypeNameSpecifier &, + SBTypeNameSpecifier, operator=,(const lldb::SBTypeNameSpecifier &)); + LLDB_REGISTER_METHOD( + bool, SBTypeNameSpecifier, operator==,(lldb::SBTypeNameSpecifier &)); + LLDB_REGISTER_METHOD(bool, SBTypeNameSpecifier, IsEqualTo, + (lldb::SBTypeNameSpecifier &)); + LLDB_REGISTER_METHOD( + bool, SBTypeNameSpecifier, operator!=,(lldb::SBTypeNameSpecifier &)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBTypeSummaryOptions, ()); + LLDB_REGISTER_CONSTRUCTOR(SBTypeSummaryOptions, + (const lldb::SBTypeSummaryOptions &)); + LLDB_REGISTER_METHOD(bool, SBTypeSummaryOptions, IsValid, ()); + LLDB_REGISTER_METHOD(lldb::LanguageType, SBTypeSummaryOptions, GetLanguage, + ()); + LLDB_REGISTER_METHOD(lldb::TypeSummaryCapping, SBTypeSummaryOptions, + GetCapping, ()); + LLDB_REGISTER_METHOD(void, SBTypeSummaryOptions, SetLanguage, + (lldb::LanguageType)); + LLDB_REGISTER_METHOD(void, SBTypeSummaryOptions, SetCapping, + (lldb::TypeSummaryCapping)); + LLDB_REGISTER_CONSTRUCTOR(SBTypeSummaryOptions, + (const lldb_private::TypeSummaryOptions *)); + LLDB_REGISTER_CONSTRUCTOR(SBTypeSummary, ()); + LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary, + CreateWithSummaryString, + (const char *, uint32_t)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary, + CreateWithFunctionName, + (const char *, uint32_t)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary, + CreateWithScriptCode, (const char *, uint32_t)); + LLDB_REGISTER_CONSTRUCTOR(SBTypeSummary, (const lldb::SBTypeSummary &)); + LLDB_REGISTER_METHOD_CONST(bool, SBTypeSummary, IsValid, ()); + LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsFunctionCode, ()); + LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsFunctionName, ()); + LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsSummaryString, ()); + LLDB_REGISTER_METHOD(const char *, SBTypeSummary, GetData, ()); + LLDB_REGISTER_METHOD(uint32_t, SBTypeSummary, GetOptions, ()); + LLDB_REGISTER_METHOD(void, SBTypeSummary, SetOptions, (uint32_t)); + LLDB_REGISTER_METHOD(void, SBTypeSummary, SetSummaryString, (const char *)); + LLDB_REGISTER_METHOD(void, SBTypeSummary, SetFunctionName, (const char *)); + LLDB_REGISTER_METHOD(void, SBTypeSummary, SetFunctionCode, (const char *)); + LLDB_REGISTER_METHOD(bool, SBTypeSummary, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel)); + LLDB_REGISTER_METHOD(bool, SBTypeSummary, DoesPrintValue, (lldb::SBValue)); + LLDB_REGISTER_METHOD( + lldb::SBTypeSummary &, + SBTypeSummary, operator=,(const lldb::SBTypeSummary &)); + LLDB_REGISTER_METHOD(bool, + SBTypeSummary, operator==,(lldb::SBTypeSummary &)); + LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsEqualTo, + (lldb::SBTypeSummary &)); + LLDB_REGISTER_METHOD(bool, + SBTypeSummary, operator!=,(lldb::SBTypeSummary &)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBTypeSynthetic, ()); + LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSynthetic, SBTypeSynthetic, + CreateWithClassName, (const char *, uint32_t)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSynthetic, SBTypeSynthetic, + CreateWithScriptCode, (const char *, uint32_t)); + LLDB_REGISTER_CONSTRUCTOR(SBTypeSynthetic, (const lldb::SBTypeSynthetic &)); + LLDB_REGISTER_METHOD_CONST(bool, SBTypeSynthetic, IsValid, ()); + LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, IsClassCode, ()); + LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, IsClassName, ()); + LLDB_REGISTER_METHOD(const char *, SBTypeSynthetic, GetData, ()); + LLDB_REGISTER_METHOD(void, SBTypeSynthetic, SetClassName, (const char *)); + LLDB_REGISTER_METHOD(void, SBTypeSynthetic, SetClassCode, (const char *)); + LLDB_REGISTER_METHOD(uint32_t, SBTypeSynthetic, GetOptions, ()); + LLDB_REGISTER_METHOD(void, SBTypeSynthetic, SetOptions, (uint32_t)); + LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel)); + LLDB_REGISTER_METHOD( + lldb::SBTypeSynthetic &, + SBTypeSynthetic, operator=,(const lldb::SBTypeSynthetic &)); + LLDB_REGISTER_METHOD(bool, + SBTypeSynthetic, operator==,(lldb::SBTypeSynthetic &)); + LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, IsEqualTo, + (lldb::SBTypeSynthetic &)); + LLDB_REGISTER_METHOD(bool, + SBTypeSynthetic, operator!=,(lldb::SBTypeSynthetic &)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBUnixSignals, ()); + LLDB_REGISTER_CONSTRUCTOR(SBUnixSignals, (const lldb::SBUnixSignals &)); + LLDB_REGISTER_METHOD( + const lldb::SBUnixSignals &, + SBUnixSignals, operator=,(const lldb::SBUnixSignals &)); + LLDB_REGISTER_METHOD(void, SBUnixSignals, Clear, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(const char *, SBUnixSignals, GetSignalAsCString, + (int32_t)); + LLDB_REGISTER_METHOD_CONST(int32_t, SBUnixSignals, GetSignalNumberFromName, + (const char *)); + LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, GetShouldSuppress, + (int32_t)); + LLDB_REGISTER_METHOD(bool, SBUnixSignals, SetShouldSuppress, + (int32_t, bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, GetShouldStop, (int32_t)); + LLDB_REGISTER_METHOD(bool, SBUnixSignals, SetShouldStop, (int32_t, bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, GetShouldNotify, (int32_t)); + LLDB_REGISTER_METHOD(bool, SBUnixSignals, SetShouldNotify, (int32_t, bool)); + LLDB_REGISTER_METHOD_CONST(int32_t, SBUnixSignals, GetNumSignals, ()); + LLDB_REGISTER_METHOD_CONST(int32_t, SBUnixSignals, GetSignalAtIndex, + (int32_t)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBValue, ()); + LLDB_REGISTER_CONSTRUCTOR(SBValue, (const lldb::ValueObjectSP &)); + LLDB_REGISTER_CONSTRUCTOR(SBValue, (const lldb::SBValue &)); + LLDB_REGISTER_METHOD(lldb::SBValue &, + SBValue, operator=,(const lldb::SBValue &)); + LLDB_REGISTER_METHOD(bool, SBValue, IsValid, ()); + LLDB_REGISTER_METHOD(void, SBValue, Clear, ()); + LLDB_REGISTER_METHOD(lldb::SBError, SBValue, GetError, ()); + LLDB_REGISTER_METHOD(lldb::user_id_t, SBValue, GetID, ()); + LLDB_REGISTER_METHOD(const char *, SBValue, GetName, ()); + LLDB_REGISTER_METHOD(const char *, SBValue, GetTypeName, ()); + LLDB_REGISTER_METHOD(const char *, SBValue, GetDisplayTypeName, ()); + LLDB_REGISTER_METHOD(size_t, SBValue, GetByteSize, ()); + LLDB_REGISTER_METHOD(bool, SBValue, IsInScope, ()); + LLDB_REGISTER_METHOD(const char *, SBValue, GetValue, ()); + LLDB_REGISTER_METHOD(lldb::ValueType, SBValue, GetValueType, ()); + LLDB_REGISTER_METHOD(const char *, SBValue, GetObjectDescription, ()); + LLDB_REGISTER_METHOD(const char *, SBValue, GetTypeValidatorResult, ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBValue, GetType, ()); + LLDB_REGISTER_METHOD(bool, SBValue, GetValueDidChange, ()); + LLDB_REGISTER_METHOD(const char *, SBValue, GetSummary, ()); + LLDB_REGISTER_METHOD(const char *, SBValue, GetSummary, + (lldb::SBStream &, lldb::SBTypeSummaryOptions &)); + LLDB_REGISTER_METHOD(const char *, SBValue, GetLocation, ()); + LLDB_REGISTER_METHOD(bool, SBValue, SetValueFromCString, (const char *)); + LLDB_REGISTER_METHOD(bool, SBValue, SetValueFromCString, + (const char *, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBValue, GetTypeFormat, ()); + LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBValue, GetTypeSummary, ()); + LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBValue, GetTypeFilter, ()); + LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBValue, GetTypeSynthetic, ()); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, CreateChildAtOffset, + (const char *, uint32_t, lldb::SBType)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, Cast, (lldb::SBType)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, CreateValueFromExpression, + (const char *, const char *)); + LLDB_REGISTER_METHOD( + lldb::SBValue, SBValue, CreateValueFromExpression, + (const char *, const char *, lldb::SBExpressionOptions &)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, CreateValueFromAddress, + (const char *, lldb::addr_t, lldb::SBType)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, CreateValueFromData, + (const char *, lldb::SBData, lldb::SBType)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetChildAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetChildAtIndex, + (uint32_t, lldb::DynamicValueType, bool)); + LLDB_REGISTER_METHOD(uint32_t, SBValue, GetIndexOfChildWithName, + (const char *)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName, + (const char *)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName, + (const char *, lldb::DynamicValueType)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetDynamicValue, + (lldb::DynamicValueType)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetStaticValue, ()); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetNonSyntheticValue, ()); + LLDB_REGISTER_METHOD(lldb::DynamicValueType, SBValue, GetPreferDynamicValue, + ()); + LLDB_REGISTER_METHOD(void, SBValue, SetPreferDynamicValue, + (lldb::DynamicValueType)); + LLDB_REGISTER_METHOD(bool, SBValue, GetPreferSyntheticValue, ()); + LLDB_REGISTER_METHOD(void, SBValue, SetPreferSyntheticValue, (bool)); + LLDB_REGISTER_METHOD(bool, SBValue, IsDynamic, ()); + LLDB_REGISTER_METHOD(bool, SBValue, IsSynthetic, ()); + LLDB_REGISTER_METHOD(bool, SBValue, IsSyntheticChildrenGenerated, ()); + LLDB_REGISTER_METHOD(void, SBValue, SetSyntheticChildrenGenerated, (bool)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetValueForExpressionPath, + (const char *)); + LLDB_REGISTER_METHOD(int64_t, SBValue, GetValueAsSigned, + (lldb::SBError &, int64_t)); + LLDB_REGISTER_METHOD(uint64_t, SBValue, GetValueAsUnsigned, + (lldb::SBError &, uint64_t)); + LLDB_REGISTER_METHOD(int64_t, SBValue, GetValueAsSigned, (int64_t)); + LLDB_REGISTER_METHOD(uint64_t, SBValue, GetValueAsUnsigned, (uint64_t)); + LLDB_REGISTER_METHOD(bool, SBValue, MightHaveChildren, ()); + LLDB_REGISTER_METHOD(bool, SBValue, IsRuntimeSupportValue, ()); + LLDB_REGISTER_METHOD(uint32_t, SBValue, GetNumChildren, ()); + LLDB_REGISTER_METHOD(uint32_t, SBValue, GetNumChildren, (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, Dereference, ()); + LLDB_REGISTER_METHOD(bool, SBValue, TypeIsPointerType, ()); + LLDB_REGISTER_METHOD(void *, SBValue, GetOpaqueType, ()); + LLDB_REGISTER_METHOD(lldb::SBTarget, SBValue, GetTarget, ()); + LLDB_REGISTER_METHOD(lldb::SBProcess, SBValue, GetProcess, ()); + LLDB_REGISTER_METHOD(lldb::SBThread, SBValue, GetThread, ()); + LLDB_REGISTER_METHOD(lldb::SBFrame, SBValue, GetFrame, ()); + LLDB_REGISTER_METHOD_CONST(lldb::ValueObjectSP, SBValue, GetSP, ()); + LLDB_REGISTER_METHOD(bool, SBValue, GetExpressionPath, (lldb::SBStream &)); + LLDB_REGISTER_METHOD(bool, SBValue, GetExpressionPath, + (lldb::SBStream &, bool)); + LLDB_REGISTER_METHOD_CONST(lldb::SBValue, SBValue, EvaluateExpression, + (const char *)); + LLDB_REGISTER_METHOD_CONST( + lldb::SBValue, SBValue, EvaluateExpression, + (const char *, const lldb::SBExpressionOptions &)); + LLDB_REGISTER_METHOD_CONST( + lldb::SBValue, SBValue, EvaluateExpression, + (const char *, const lldb::SBExpressionOptions &, const char *)); + LLDB_REGISTER_METHOD(bool, SBValue, GetDescription, (lldb::SBStream &)); + LLDB_REGISTER_METHOD(lldb::Format, SBValue, GetFormat, ()); + LLDB_REGISTER_METHOD(void, SBValue, SetFormat, (lldb::Format)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, AddressOf, ()); + LLDB_REGISTER_METHOD(lldb::addr_t, SBValue, GetLoadAddress, ()); + LLDB_REGISTER_METHOD(lldb::SBAddress, SBValue, GetAddress, ()); + LLDB_REGISTER_METHOD(lldb::SBData, SBValue, GetPointeeData, + (uint32_t, uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBData, SBValue, GetData, ()); + LLDB_REGISTER_METHOD(bool, SBValue, SetData, + (lldb::SBData &, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBDeclaration, SBValue, GetDeclaration, ()); + LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBValue, Watch, + (bool, bool, bool, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBValue, Watch, + (bool, bool, bool)); + LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBValue, WatchPointee, + (bool, bool, bool, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, Persist, ()); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBValueList, ()); + LLDB_REGISTER_CONSTRUCTOR(SBValueList, (const lldb::SBValueList &)); + LLDB_REGISTER_METHOD_CONST(bool, SBValueList, IsValid, ()); + LLDB_REGISTER_METHOD(void, SBValueList, Clear, ()); + LLDB_REGISTER_METHOD(const lldb::SBValueList &, + SBValueList, operator=,(const lldb::SBValueList &)); + LLDB_REGISTER_METHOD(void, SBValueList, Append, (const lldb::SBValue &)); + LLDB_REGISTER_METHOD(void, SBValueList, Append, + (const lldb::SBValueList &)); + LLDB_REGISTER_METHOD_CONST(lldb::SBValue, SBValueList, GetValueAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBValueList, GetSize, ()); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValueList, FindValueObjectByUID, + (lldb::user_id_t)); + LLDB_REGISTER_METHOD_CONST(lldb::SBValue, SBValueList, GetFirstValueByName, + (const char *)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBVariablesOptions, ()); + LLDB_REGISTER_CONSTRUCTOR(SBVariablesOptions, + (const lldb::SBVariablesOptions &)); + LLDB_REGISTER_METHOD( + lldb::SBVariablesOptions &, + SBVariablesOptions, operator=,(const lldb::SBVariablesOptions &)); + LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetIncludeArguments, + ()); + LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetIncludeArguments, (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, + GetIncludeRecognizedArguments, + (const lldb::SBTarget &)); + LLDB_REGISTER_METHOD(void, SBVariablesOptions, + SetIncludeRecognizedArguments, (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetIncludeLocals, ()); + LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetIncludeLocals, (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetIncludeStatics, ()); + LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetIncludeStatics, (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetInScopeOnly, ()); + LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetInScopeOnly, (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, + GetIncludeRuntimeSupportValues, ()); + LLDB_REGISTER_METHOD(void, SBVariablesOptions, + SetIncludeRuntimeSupportValues, (bool)); + LLDB_REGISTER_METHOD_CONST(lldb::DynamicValueType, SBVariablesOptions, + GetUseDynamic, ()); + LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetUseDynamic, + (lldb::DynamicValueType)); + } + { + LLDB_REGISTER_CONSTRUCTOR(SBWatchpoint, ()); + LLDB_REGISTER_CONSTRUCTOR(SBWatchpoint, (const lldb::WatchpointSP &)); + LLDB_REGISTER_CONSTRUCTOR(SBWatchpoint, (const lldb::SBWatchpoint &)); + LLDB_REGISTER_METHOD(const lldb::SBWatchpoint &, + SBWatchpoint, operator=,(const lldb::SBWatchpoint &)); + LLDB_REGISTER_METHOD(lldb::watch_id_t, SBWatchpoint, GetID, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBWatchpoint, IsValid, ()); + LLDB_REGISTER_METHOD(lldb::SBError, SBWatchpoint, GetError, ()); + LLDB_REGISTER_METHOD(int32_t, SBWatchpoint, GetHardwareIndex, ()); + LLDB_REGISTER_METHOD(lldb::addr_t, SBWatchpoint, GetWatchAddress, ()); + LLDB_REGISTER_METHOD(size_t, SBWatchpoint, GetWatchSize, ()); + LLDB_REGISTER_METHOD(void, SBWatchpoint, SetEnabled, (bool)); + LLDB_REGISTER_METHOD(bool, SBWatchpoint, IsEnabled, ()); + LLDB_REGISTER_METHOD(uint32_t, SBWatchpoint, GetHitCount, ()); + LLDB_REGISTER_METHOD(uint32_t, SBWatchpoint, GetIgnoreCount, ()); + LLDB_REGISTER_METHOD(void, SBWatchpoint, SetIgnoreCount, (uint32_t)); + LLDB_REGISTER_METHOD(const char *, SBWatchpoint, GetCondition, ()); + LLDB_REGISTER_METHOD(void, SBWatchpoint, SetCondition, (const char *)); + LLDB_REGISTER_METHOD(bool, SBWatchpoint, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel)); + LLDB_REGISTER_METHOD(void, SBWatchpoint, Clear, ()); + LLDB_REGISTER_METHOD_CONST(lldb::WatchpointSP, SBWatchpoint, GetSP, ()); + LLDB_REGISTER_METHOD(void, SBWatchpoint, SetSP, + (const lldb::WatchpointSP &)); + LLDB_REGISTER_STATIC_METHOD(bool, SBWatchpoint, EventIsWatchpointEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_STATIC_METHOD(lldb::WatchpointEventType, SBWatchpoint, + GetWatchpointEventTypeFromEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBWatchpoint, SBWatchpoint, + GetWatchpointFromEvent, + (const lldb::SBEvent &)); + } +} const char *SBReproducer::Capture(const char *path) { static std::string error; diff --git a/lldb/source/API/SBSection.cpp b/lldb/source/API/SBSection.cpp index b76714bb175..7ad7df963a7 100644 --- a/lldb/source/API/SBSection.cpp +++ b/lldb/source/API/SBSection.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBSection.h" +#include "SBReproducerPrivate.h" #include "lldb/API/SBStream.h" #include "lldb/API/SBTarget.h" #include "lldb/Core/Module.h" @@ -20,9 +21,13 @@ using namespace lldb; using namespace lldb_private; -SBSection::SBSection() : m_opaque_wp() {} +SBSection::SBSection() : m_opaque_wp() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSection); +} -SBSection::SBSection(const SBSection &rhs) : m_opaque_wp(rhs.m_opaque_wp) {} +SBSection::SBSection(const SBSection &rhs) : m_opaque_wp(rhs.m_opaque_wp) { + LLDB_RECORD_CONSTRUCTOR(SBSection, (const lldb::SBSection &), rhs); +} SBSection::SBSection(const lldb::SectionSP §ion_sp) : m_opaque_wp() // Don't init with section_sp otherwise this will throw if @@ -33,6 +38,9 @@ SBSection::SBSection(const lldb::SectionSP §ion_sp) } const SBSection &SBSection::operator=(const SBSection &rhs) { + LLDB_RECORD_METHOD(const lldb::SBSection &, + SBSection, operator=,(const lldb::SBSection &), rhs); + m_opaque_wp = rhs.m_opaque_wp; return *this; } @@ -40,11 +48,15 @@ const SBSection &SBSection::operator=(const SBSection &rhs) { SBSection::~SBSection() {} bool SBSection::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSection, IsValid); + SectionSP section_sp(GetSP()); return section_sp && section_sp->GetModule().get() != NULL; } const char *SBSection::GetName() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBSection, GetName); + SectionSP section_sp(GetSP()); if (section_sp) return section_sp->GetName().GetCString(); @@ -52,6 +64,8 @@ const char *SBSection::GetName() { } lldb::SBSection SBSection::GetParent() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSection, SBSection, GetParent); + lldb::SBSection sb_section; SectionSP section_sp(GetSP()); if (section_sp) { @@ -59,10 +73,13 @@ lldb::SBSection SBSection::GetParent() { if (parent_section_sp) sb_section.SetSP(parent_section_sp); } - return sb_section; + return LLDB_RECORD_RESULT(sb_section); } lldb::SBSection SBSection::FindSubSection(const char *sect_name) { + LLDB_RECORD_METHOD(lldb::SBSection, SBSection, FindSubSection, (const char *), + sect_name); + lldb::SBSection sb_section; if (sect_name) { SectionSP section_sp(GetSP()); @@ -72,10 +89,12 @@ lldb::SBSection SBSection::FindSubSection(const char *sect_name) { section_sp->GetChildren().FindSectionByName(const_sect_name)); } } - return sb_section; + return LLDB_RECORD_RESULT(sb_section); } size_t SBSection::GetNumSubSections() { + LLDB_RECORD_METHOD_NO_ARGS(size_t, SBSection, GetNumSubSections); + SectionSP section_sp(GetSP()); if (section_sp) return section_sp->GetChildren().GetSize(); @@ -83,11 +102,14 @@ size_t SBSection::GetNumSubSections() { } lldb::SBSection SBSection::GetSubSectionAtIndex(size_t idx) { + LLDB_RECORD_METHOD(lldb::SBSection, SBSection, GetSubSectionAtIndex, (size_t), + idx); + lldb::SBSection sb_section; SectionSP section_sp(GetSP()); if (section_sp) sb_section.SetSP(section_sp->GetChildren().GetSectionAtIndex(idx)); - return sb_section; + return LLDB_RECORD_RESULT(sb_section); } lldb::SectionSP SBSection::GetSP() const { return m_opaque_wp.lock(); } @@ -97,6 +119,8 @@ void SBSection::SetSP(const lldb::SectionSP §ion_sp) { } lldb::addr_t SBSection::GetFileAddress() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBSection, GetFileAddress); + lldb::addr_t file_addr = LLDB_INVALID_ADDRESS; SectionSP section_sp(GetSP()); if (section_sp) @@ -105,6 +129,9 @@ lldb::addr_t SBSection::GetFileAddress() { } lldb::addr_t SBSection::GetLoadAddress(lldb::SBTarget &sb_target) { + LLDB_RECORD_METHOD(lldb::addr_t, SBSection, GetLoadAddress, + (lldb::SBTarget &), sb_target); + TargetSP target_sp(sb_target.GetSP()); if (target_sp) { SectionSP section_sp(GetSP()); @@ -115,6 +142,8 @@ lldb::addr_t SBSection::GetLoadAddress(lldb::SBTarget &sb_target) { } lldb::addr_t SBSection::GetByteSize() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBSection, GetByteSize); + SectionSP section_sp(GetSP()); if (section_sp) return section_sp->GetByteSize(); @@ -122,6 +151,8 @@ lldb::addr_t SBSection::GetByteSize() { } uint64_t SBSection::GetFileOffset() { + LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBSection, GetFileOffset); + SectionSP section_sp(GetSP()); if (section_sp) { ModuleSP module_sp(section_sp->GetModule()); @@ -135,15 +166,24 @@ uint64_t SBSection::GetFileOffset() { } uint64_t SBSection::GetFileByteSize() { + LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBSection, GetFileByteSize); + SectionSP section_sp(GetSP()); if (section_sp) return section_sp->GetFileSize(); return 0; } -SBData SBSection::GetSectionData() { return GetSectionData(0, UINT64_MAX); } +SBData SBSection::GetSectionData() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBData, SBSection, GetSectionData); + + return LLDB_RECORD_RESULT(GetSectionData(0, UINT64_MAX)); +} SBData SBSection::GetSectionData(uint64_t offset, uint64_t size) { + LLDB_RECORD_METHOD(lldb::SBData, SBSection, GetSectionData, + (uint64_t, uint64_t), offset, size); + SBData sb_data; SectionSP section_sp(GetSP()); if (section_sp) { @@ -177,26 +217,30 @@ SBData SBSection::GetSectionData(uint64_t offset, uint64_t size) { } } } - return sb_data; + return LLDB_RECORD_RESULT(sb_data); } SectionType SBSection::GetSectionType() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SectionType, SBSection, GetSectionType); + SectionSP section_sp(GetSP()); if (section_sp.get()) return section_sp->GetType(); return eSectionTypeInvalid; } -uint32_t -SBSection::GetPermissions() const -{ - SectionSP section_sp(GetSP()); - if (section_sp) - return section_sp->GetPermissions(); - return 0; +uint32_t SBSection::GetPermissions() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBSection, GetPermissions); + + SectionSP section_sp(GetSP()); + if (section_sp) + return section_sp->GetPermissions(); + return 0; } uint32_t SBSection::GetTargetByteSize() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBSection, GetTargetByteSize); + SectionSP section_sp(GetSP()); if (section_sp.get()) return section_sp->GetTargetByteSize(); @@ -204,6 +248,9 @@ uint32_t SBSection::GetTargetByteSize() { } bool SBSection::operator==(const SBSection &rhs) { + LLDB_RECORD_METHOD(bool, SBSection, operator==,(const lldb::SBSection &), + rhs); + SectionSP lhs_section_sp(GetSP()); SectionSP rhs_section_sp(rhs.GetSP()); if (lhs_section_sp && rhs_section_sp) @@ -212,12 +259,18 @@ bool SBSection::operator==(const SBSection &rhs) { } bool SBSection::operator!=(const SBSection &rhs) { + LLDB_RECORD_METHOD(bool, SBSection, operator!=,(const lldb::SBSection &), + rhs); + SectionSP lhs_section_sp(GetSP()); SectionSP rhs_section_sp(rhs.GetSP()); return lhs_section_sp != rhs_section_sp; } bool SBSection::GetDescription(SBStream &description) { + LLDB_RECORD_METHOD(bool, SBSection, GetDescription, (lldb::SBStream &), + description); + Stream &strm = description.ref(); SectionSP section_sp(GetSP()); diff --git a/lldb/source/API/SBSourceManager.cpp b/lldb/source/API/SBSourceManager.cpp index 85eba4f8887..78817d1fe97 100644 --- a/lldb/source/API/SBSourceManager.cpp +++ b/lldb/source/API/SBSourceManager.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBSourceManager.h" +#include "SBReproducerPrivate.h" #include "lldb/API/SBDebugger.h" #include "lldb/API/SBStream.h" #include "lldb/API/SBTarget.h" @@ -71,14 +72,22 @@ using namespace lldb; using namespace lldb_private; SBSourceManager::SBSourceManager(const SBDebugger &debugger) { + LLDB_RECORD_CONSTRUCTOR(SBSourceManager, (const lldb::SBDebugger &), + debugger); + m_opaque_up.reset(new SourceManagerImpl(debugger.get_sp())); } SBSourceManager::SBSourceManager(const SBTarget &target) { + LLDB_RECORD_CONSTRUCTOR(SBSourceManager, (const lldb::SBTarget &), target); + m_opaque_up.reset(new SourceManagerImpl(target.GetSP())); } SBSourceManager::SBSourceManager(const SBSourceManager &rhs) { + LLDB_RECORD_CONSTRUCTOR(SBSourceManager, (const lldb::SBSourceManager &), + rhs); + if (&rhs == this) return; @@ -87,6 +96,10 @@ SBSourceManager::SBSourceManager(const SBSourceManager &rhs) { const lldb::SBSourceManager &SBSourceManager:: operator=(const lldb::SBSourceManager &rhs) { + LLDB_RECORD_METHOD(const lldb::SBSourceManager &, + SBSourceManager, operator=,(const lldb::SBSourceManager &), + rhs); + m_opaque_up.reset(new SourceManagerImpl(*(rhs.m_opaque_up.get()))); return *this; } @@ -96,6 +109,12 @@ SBSourceManager::~SBSourceManager() {} size_t SBSourceManager::DisplaySourceLinesWithLineNumbers( const SBFileSpec &file, uint32_t line, uint32_t context_before, uint32_t context_after, const char *current_line_cstr, SBStream &s) { + LLDB_RECORD_METHOD(size_t, SBSourceManager, DisplaySourceLinesWithLineNumbers, + (const lldb::SBFileSpec &, uint32_t, uint32_t, uint32_t, + const char *, lldb::SBStream &), + file, line, context_before, context_after, + current_line_cstr, s); + const uint32_t column = 0; return DisplaySourceLinesWithLineNumbersAndColumn( file.ref(), line, column, context_before, context_after, @@ -106,6 +125,12 @@ size_t SBSourceManager::DisplaySourceLinesWithLineNumbersAndColumn( const SBFileSpec &file, uint32_t line, uint32_t column, uint32_t context_before, uint32_t context_after, const char *current_line_cstr, SBStream &s) { + LLDB_RECORD_METHOD( + size_t, SBSourceManager, DisplaySourceLinesWithLineNumbersAndColumn, + (const lldb::SBFileSpec &, uint32_t, uint32_t, uint32_t, uint32_t, + const char *, lldb::SBStream &), + file, line, column, context_before, context_after, current_line_cstr, s); + if (m_opaque_up == NULL) return 0; diff --git a/lldb/source/API/SBStream.cpp b/lldb/source/API/SBStream.cpp index 11479d521bb..c1fc455a687 100644 --- a/lldb/source/API/SBStream.cpp +++ b/lldb/source/API/SBStream.cpp @@ -8,6 +8,7 @@ #include "lldb/API/SBStream.h" +#include "SBReproducerPrivate.h" #include "lldb/Core/StreamFile.h" #include "lldb/Host/FileSystem.h" #include "lldb/Utility/Status.h" @@ -17,18 +18,26 @@ using namespace lldb; using namespace lldb_private; -SBStream::SBStream() : m_opaque_up(new StreamString()), m_is_file(false) {} +SBStream::SBStream() : m_opaque_up(new StreamString()), m_is_file(false) { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBStream); +} SBStream::SBStream(SBStream &&rhs) : m_opaque_up(std::move(rhs.m_opaque_up)), m_is_file(rhs.m_is_file) {} SBStream::~SBStream() {} -bool SBStream::IsValid() const { return (m_opaque_up != NULL); } +bool SBStream::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStream, IsValid); + + return (m_opaque_up != NULL); +} // If this stream is not redirected to a file, it will maintain a local cache // for the stream data which can be accessed using this accessor. const char *SBStream::GetData() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBStream, GetData); + if (m_is_file || m_opaque_up == NULL) return NULL; @@ -38,6 +47,8 @@ const char *SBStream::GetData() { // If this stream is not redirected to a file, it will maintain a local cache // for the stream output whose length can be accessed using this accessor. size_t SBStream::GetSize() { + LLDB_RECORD_METHOD_NO_ARGS(size_t, SBStream, GetSize); + if (m_is_file || m_opaque_up == NULL) return 0; @@ -54,6 +65,9 @@ void SBStream::Printf(const char *format, ...) { } void SBStream::RedirectToFile(const char *path, bool append) { + LLDB_RECORD_METHOD(void, SBStream, RedirectToFile, (const char *, bool), path, + append); + if (path == nullptr) return; @@ -87,6 +101,9 @@ void SBStream::RedirectToFile(const char *path, bool append) { } void SBStream::RedirectToFileHandle(FILE *fh, bool transfer_fh_ownership) { + LLDB_RECORD_METHOD(void, SBStream, RedirectToFileHandle, (FILE *, bool), fh, + transfer_fh_ownership); + if (fh == nullptr) return; @@ -111,6 +128,9 @@ void SBStream::RedirectToFileHandle(FILE *fh, bool transfer_fh_ownership) { } void SBStream::RedirectToFileDescriptor(int fd, bool transfer_fh_ownership) { + LLDB_RECORD_METHOD(void, SBStream, RedirectToFileDescriptor, (int, bool), fd, + transfer_fh_ownership); + std::string local_data; if (m_opaque_up) { // See if we have any locally backed data. If so, copy it so we can then @@ -142,6 +162,8 @@ lldb_private::Stream &SBStream::ref() { } void SBStream::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBStream, Clear); + if (m_opaque_up) { // See if we have any locally backed data. If so, copy it so we can then // redirect it to the file so we don't lose the data diff --git a/lldb/source/API/SBStringList.cpp b/lldb/source/API/SBStringList.cpp index 12d35c9ecd2..a248468b0cf 100644 --- a/lldb/source/API/SBStringList.cpp +++ b/lldb/source/API/SBStringList.cpp @@ -7,13 +7,16 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBStringList.h" +#include "SBReproducerPrivate.h" #include "Utils.h" #include "lldb/Utility/StringList.h" using namespace lldb; using namespace lldb_private; -SBStringList::SBStringList() : m_opaque_up() {} +SBStringList::SBStringList() : m_opaque_up() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBStringList); +} SBStringList::SBStringList(const lldb_private::StringList *lldb_strings_ptr) : m_opaque_up() { @@ -22,10 +25,15 @@ SBStringList::SBStringList(const lldb_private::StringList *lldb_strings_ptr) } SBStringList::SBStringList(const SBStringList &rhs) : m_opaque_up() { + LLDB_RECORD_CONSTRUCTOR(SBStringList, (const lldb::SBStringList &), rhs); + m_opaque_up = clone(rhs.m_opaque_up); } const SBStringList &SBStringList::operator=(const SBStringList &rhs) { + LLDB_RECORD_METHOD(const lldb::SBStringList &, + SBStringList, operator=,(const lldb::SBStringList &), rhs); + if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); return *this; @@ -41,9 +49,15 @@ const lldb_private::StringList &SBStringList::operator*() const { return *m_opaque_up; } -bool SBStringList::IsValid() const { return (m_opaque_up != NULL); } +bool SBStringList::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStringList, IsValid); + + return (m_opaque_up != NULL); +} void SBStringList::AppendString(const char *str) { + LLDB_RECORD_METHOD(void, SBStringList, AppendString, (const char *), str); + if (str != NULL) { if (IsValid()) m_opaque_up->AppendString(str); @@ -53,6 +67,9 @@ void SBStringList::AppendString(const char *str) { } void SBStringList::AppendList(const char **strv, int strc) { + LLDB_RECORD_METHOD(void, SBStringList, AppendList, (const char **, int), strv, + strc); + if ((strv != NULL) && (strc > 0)) { if (IsValid()) m_opaque_up->AppendList(strv, strc); @@ -62,6 +79,9 @@ void SBStringList::AppendList(const char **strv, int strc) { } void SBStringList::AppendList(const SBStringList &strings) { + LLDB_RECORD_METHOD(void, SBStringList, AppendList, + (const lldb::SBStringList &), strings); + if (strings.IsValid()) { if (!IsValid()) m_opaque_up.reset(new lldb_private::StringList()); @@ -76,6 +96,8 @@ void SBStringList::AppendList(const StringList &strings) { } uint32_t SBStringList::GetSize() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBStringList, GetSize); + if (IsValid()) { return m_opaque_up->GetSize(); } @@ -83,6 +105,9 @@ uint32_t SBStringList::GetSize() const { } const char *SBStringList::GetStringAtIndex(size_t idx) { + LLDB_RECORD_METHOD(const char *, SBStringList, GetStringAtIndex, (size_t), + idx); + if (IsValid()) { return m_opaque_up->GetStringAtIndex(idx); } @@ -90,6 +115,9 @@ const char *SBStringList::GetStringAtIndex(size_t idx) { } const char *SBStringList::GetStringAtIndex(size_t idx) const { + LLDB_RECORD_METHOD_CONST(const char *, SBStringList, GetStringAtIndex, + (size_t), idx); + if (IsValid()) { return m_opaque_up->GetStringAtIndex(idx); } @@ -97,6 +125,8 @@ const char *SBStringList::GetStringAtIndex(size_t idx) const { } void SBStringList::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBStringList, Clear); + if (IsValid()) { m_opaque_up->Clear(); } diff --git a/lldb/source/API/SBStructuredData.cpp b/lldb/source/API/SBStructuredData.cpp index 35fe77f47bf..9c06015b230 100644 --- a/lldb/source/API/SBStructuredData.cpp +++ b/lldb/source/API/SBStructuredData.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBStructuredData.h" +#include "SBReproducerPrivate.h" #include "lldb/API/SBStream.h" #include "lldb/API/SBStringList.h" @@ -23,26 +24,43 @@ using namespace lldb_private; #pragma mark-- #pragma mark SBStructuredData -SBStructuredData::SBStructuredData() : m_impl_up(new StructuredDataImpl()) {} +SBStructuredData::SBStructuredData() : m_impl_up(new StructuredDataImpl()) { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBStructuredData); +} SBStructuredData::SBStructuredData(const lldb::SBStructuredData &rhs) - : m_impl_up(new StructuredDataImpl(*rhs.m_impl_up.get())) {} + : m_impl_up(new StructuredDataImpl(*rhs.m_impl_up.get())) { + LLDB_RECORD_CONSTRUCTOR(SBStructuredData, (const lldb::SBStructuredData &), + rhs); +} SBStructuredData::SBStructuredData(const lldb::EventSP &event_sp) - : m_impl_up(new StructuredDataImpl(event_sp)) {} + : m_impl_up(new StructuredDataImpl(event_sp)) { + LLDB_RECORD_CONSTRUCTOR(SBStructuredData, (const lldb::EventSP &), event_sp); +} SBStructuredData::SBStructuredData(lldb_private::StructuredDataImpl *impl) - : m_impl_up(impl) {} + : m_impl_up(impl) { + LLDB_RECORD_CONSTRUCTOR(SBStructuredData, + (lldb_private::StructuredDataImpl *), impl); +} SBStructuredData::~SBStructuredData() {} SBStructuredData &SBStructuredData:: operator=(const lldb::SBStructuredData &rhs) { + LLDB_RECORD_METHOD( + lldb::SBStructuredData &, + SBStructuredData, operator=,(const lldb::SBStructuredData &), rhs); + *m_impl_up = *rhs.m_impl_up; return *this; } lldb::SBError SBStructuredData::SetFromJSON(lldb::SBStream &stream) { + LLDB_RECORD_METHOD(lldb::SBError, SBStructuredData, SetFromJSON, + (lldb::SBStream &), stream); + lldb::SBError error; std::string json_str(stream.GetData()); @@ -51,35 +69,57 @@ lldb::SBError SBStructuredData::SetFromJSON(lldb::SBStream &stream) { if (!json_obj || json_obj->GetType() != eStructuredDataTypeDictionary) error.SetErrorString("Invalid Syntax"); - return error; + return LLDB_RECORD_RESULT(error); } -bool SBStructuredData::IsValid() const { return m_impl_up->IsValid(); } +bool SBStructuredData::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStructuredData, IsValid); -void SBStructuredData::Clear() { m_impl_up->Clear(); } + return m_impl_up->IsValid(); +} + +void SBStructuredData::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBStructuredData, Clear); + + m_impl_up->Clear(); +} SBError SBStructuredData::GetAsJSON(lldb::SBStream &stream) const { + LLDB_RECORD_METHOD_CONST(lldb::SBError, SBStructuredData, GetAsJSON, + (lldb::SBStream &), stream); + SBError error; error.SetError(m_impl_up->GetAsJSON(stream.ref())); - return error; + return LLDB_RECORD_RESULT(error); } lldb::SBError SBStructuredData::GetDescription(lldb::SBStream &stream) const { + LLDB_RECORD_METHOD_CONST(lldb::SBError, SBStructuredData, GetDescription, + (lldb::SBStream &), stream); + Status error = m_impl_up->GetDescription(stream.ref()); SBError sb_error; sb_error.SetError(error); - return sb_error; + return LLDB_RECORD_RESULT(sb_error); } StructuredDataType SBStructuredData::GetType() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::StructuredDataType, SBStructuredData, + GetType); + return (m_impl_up ? m_impl_up->GetType() : eStructuredDataTypeInvalid); } size_t SBStructuredData::GetSize() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBStructuredData, GetSize); + return (m_impl_up ? m_impl_up->GetSize() : 0); } bool SBStructuredData::GetKeys(lldb::SBStringList &keys) const { + LLDB_RECORD_METHOD_CONST(bool, SBStructuredData, GetKeys, + (lldb::SBStringList &), keys); + if (!m_impl_up) return false; @@ -107,35 +147,53 @@ bool SBStructuredData::GetKeys(lldb::SBStringList &keys) const { } lldb::SBStructuredData SBStructuredData::GetValueForKey(const char *key) const { + LLDB_RECORD_METHOD_CONST(lldb::SBStructuredData, SBStructuredData, + GetValueForKey, (const char *), key); + if (!m_impl_up) - return SBStructuredData(); + return LLDB_RECORD_RESULT(SBStructuredData()); SBStructuredData result; result.m_impl_up->SetObjectSP(m_impl_up->GetValueForKey(key)); - return result; + return LLDB_RECORD_RESULT(result); } lldb::SBStructuredData SBStructuredData::GetItemAtIndex(size_t idx) const { + LLDB_RECORD_METHOD_CONST(lldb::SBStructuredData, SBStructuredData, + GetItemAtIndex, (size_t), idx); + if (!m_impl_up) - return SBStructuredData(); + return LLDB_RECORD_RESULT(SBStructuredData()); SBStructuredData result; result.m_impl_up->SetObjectSP(m_impl_up->GetItemAtIndex(idx)); - return result; + return LLDB_RECORD_RESULT(result); } uint64_t SBStructuredData::GetIntegerValue(uint64_t fail_value) const { + LLDB_RECORD_METHOD_CONST(uint64_t, SBStructuredData, GetIntegerValue, + (uint64_t), fail_value); + return (m_impl_up ? m_impl_up->GetIntegerValue(fail_value) : fail_value); } double SBStructuredData::GetFloatValue(double fail_value) const { + LLDB_RECORD_METHOD_CONST(double, SBStructuredData, GetFloatValue, (double), + fail_value); + return (m_impl_up ? m_impl_up->GetFloatValue(fail_value) : fail_value); } bool SBStructuredData::GetBooleanValue(bool fail_value) const { + LLDB_RECORD_METHOD_CONST(bool, SBStructuredData, GetBooleanValue, (bool), + fail_value); + return (m_impl_up ? m_impl_up->GetBooleanValue(fail_value) : fail_value); } size_t SBStructuredData::GetStringValue(char *dst, size_t dst_len) const { + LLDB_RECORD_METHOD_CONST(size_t, SBStructuredData, GetStringValue, + (char *, size_t), dst, dst_len); + return (m_impl_up ? m_impl_up->GetStringValue(dst, dst_len) : 0); } diff --git a/lldb/source/API/SBSymbol.cpp b/lldb/source/API/SBSymbol.cpp index 981c9864f44..719f9e8c543 100644 --- a/lldb/source/API/SBSymbol.cpp +++ b/lldb/source/API/SBSymbol.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBSymbol.h" +#include "SBReproducerPrivate.h" #include "lldb/API/SBStream.h" #include "lldb/Core/Disassembler.h" #include "lldb/Core/Module.h" @@ -18,15 +19,21 @@ using namespace lldb; using namespace lldb_private; -SBSymbol::SBSymbol() : m_opaque_ptr(NULL) {} +SBSymbol::SBSymbol() : m_opaque_ptr(NULL) { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSymbol); +} SBSymbol::SBSymbol(lldb_private::Symbol *lldb_object_ptr) : m_opaque_ptr(lldb_object_ptr) {} -SBSymbol::SBSymbol(const lldb::SBSymbol &rhs) - : m_opaque_ptr(rhs.m_opaque_ptr) {} +SBSymbol::SBSymbol(const lldb::SBSymbol &rhs) : m_opaque_ptr(rhs.m_opaque_ptr) { + LLDB_RECORD_CONSTRUCTOR(SBSymbol, (const lldb::SBSymbol &), rhs); +} const SBSymbol &SBSymbol::operator=(const SBSymbol &rhs) { + LLDB_RECORD_METHOD(const lldb::SBSymbol &, + SBSymbol, operator=,(const lldb::SBSymbol &), rhs); + m_opaque_ptr = rhs.m_opaque_ptr; return *this; } @@ -37,9 +44,15 @@ void SBSymbol::SetSymbol(lldb_private::Symbol *lldb_object_ptr) { m_opaque_ptr = lldb_object_ptr; } -bool SBSymbol::IsValid() const { return m_opaque_ptr != NULL; } +bool SBSymbol::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbol, IsValid); + + return m_opaque_ptr != NULL; +} const char *SBSymbol::GetName() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetName); + const char *name = NULL; if (m_opaque_ptr) name = m_opaque_ptr->GetName().AsCString(); @@ -52,6 +65,8 @@ const char *SBSymbol::GetName() const { } const char *SBSymbol::GetDisplayName() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetDisplayName); + const char *name = NULL; if (m_opaque_ptr) name = m_opaque_ptr->GetMangled() @@ -66,6 +81,8 @@ const char *SBSymbol::GetDisplayName() const { } const char *SBSymbol::GetMangledName() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetMangledName); + const char *name = NULL; if (m_opaque_ptr) name = m_opaque_ptr->GetMangled().GetMangledName().AsCString(); @@ -78,14 +95,23 @@ const char *SBSymbol::GetMangledName() const { } bool SBSymbol::operator==(const SBSymbol &rhs) const { + LLDB_RECORD_METHOD_CONST(bool, SBSymbol, operator==,(const lldb::SBSymbol &), + rhs); + return m_opaque_ptr == rhs.m_opaque_ptr; } bool SBSymbol::operator!=(const SBSymbol &rhs) const { + LLDB_RECORD_METHOD_CONST(bool, SBSymbol, operator!=,(const lldb::SBSymbol &), + rhs); + return m_opaque_ptr != rhs.m_opaque_ptr; } bool SBSymbol::GetDescription(SBStream &description) { + LLDB_RECORD_METHOD(bool, SBSymbol, GetDescription, (lldb::SBStream &), + description); + Stream &strm = description.ref(); if (m_opaque_ptr) { @@ -97,11 +123,17 @@ bool SBSymbol::GetDescription(SBStream &description) { } SBInstructionList SBSymbol::GetInstructions(SBTarget target) { - return GetInstructions(target, NULL); + LLDB_RECORD_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions, + (lldb::SBTarget), target); + + return LLDB_RECORD_RESULT(GetInstructions(target, NULL)); } SBInstructionList SBSymbol::GetInstructions(SBTarget target, const char *flavor_string) { + LLDB_RECORD_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions, + (lldb::SBTarget, const char *), target, flavor_string); + SBInstructionList sb_instructions; if (m_opaque_ptr) { ExecutionContext exe_ctx; @@ -124,7 +156,7 @@ SBInstructionList SBSymbol::GetInstructions(SBTarget target, } } } - return sb_instructions; + return LLDB_RECORD_RESULT(sb_instructions); } lldb_private::Symbol *SBSymbol::get() { return m_opaque_ptr; } @@ -132,14 +164,18 @@ lldb_private::Symbol *SBSymbol::get() { return m_opaque_ptr; } void SBSymbol::reset(lldb_private::Symbol *symbol) { m_opaque_ptr = symbol; } SBAddress SBSymbol::GetStartAddress() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBSymbol, GetStartAddress); + SBAddress addr; if (m_opaque_ptr && m_opaque_ptr->ValueIsAddress()) { addr.SetAddress(&m_opaque_ptr->GetAddressRef()); } - return addr; + return LLDB_RECORD_RESULT(addr); } SBAddress SBSymbol::GetEndAddress() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBSymbol, GetEndAddress); + SBAddress addr; if (m_opaque_ptr && m_opaque_ptr->ValueIsAddress()) { lldb::addr_t range_size = m_opaque_ptr->GetByteSize(); @@ -148,28 +184,36 @@ SBAddress SBSymbol::GetEndAddress() { addr->Slide(m_opaque_ptr->GetByteSize()); } } - return addr; + return LLDB_RECORD_RESULT(addr); } uint32_t SBSymbol::GetPrologueByteSize() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBSymbol, GetPrologueByteSize); + if (m_opaque_ptr) return m_opaque_ptr->GetPrologueByteSize(); return 0; } SymbolType SBSymbol::GetType() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SymbolType, SBSymbol, GetType); + if (m_opaque_ptr) return m_opaque_ptr->GetType(); return eSymbolTypeInvalid; } bool SBSymbol::IsExternal() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBSymbol, IsExternal); + if (m_opaque_ptr) return m_opaque_ptr->IsExternal(); return false; } bool SBSymbol::IsSynthetic() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBSymbol, IsSynthetic); + if (m_opaque_ptr) return m_opaque_ptr->IsSynthetic(); return false; diff --git a/lldb/source/API/SBSymbolContext.cpp b/lldb/source/API/SBSymbolContext.cpp index ae426709f18..c3fd84a8479 100644 --- a/lldb/source/API/SBSymbolContext.cpp +++ b/lldb/source/API/SBSymbolContext.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBSymbolContext.h" +#include "SBReproducerPrivate.h" #include "Utils.h" #include "lldb/API/SBStream.h" #include "lldb/Core/Module.h" @@ -18,20 +19,32 @@ using namespace lldb; using namespace lldb_private; -SBSymbolContext::SBSymbolContext() : m_opaque_up() {} +SBSymbolContext::SBSymbolContext() : m_opaque_up() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSymbolContext); +} SBSymbolContext::SBSymbolContext(const SymbolContext *sc_ptr) : m_opaque_up() { + LLDB_RECORD_CONSTRUCTOR(SBSymbolContext, + (const lldb_private::SymbolContext *), sc_ptr); + if (sc_ptr) m_opaque_up = llvm::make_unique<SymbolContext>(*sc_ptr); } SBSymbolContext::SBSymbolContext(const SBSymbolContext &rhs) : m_opaque_up() { + LLDB_RECORD_CONSTRUCTOR(SBSymbolContext, (const lldb::SBSymbolContext &), + rhs); + m_opaque_up = clone(rhs.m_opaque_up); } SBSymbolContext::~SBSymbolContext() {} const SBSymbolContext &SBSymbolContext::operator=(const SBSymbolContext &rhs) { + LLDB_RECORD_METHOD(const lldb::SBSymbolContext &, + SBSymbolContext, operator=,(const lldb::SBSymbolContext &), + rhs); + if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); return *this; @@ -44,9 +57,15 @@ void SBSymbolContext::SetSymbolContext(const SymbolContext *sc_ptr) { m_opaque_up->Clear(true); } -bool SBSymbolContext::IsValid() const { return m_opaque_up != NULL; } +bool SBSymbolContext::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContext, IsValid); + + return m_opaque_up != NULL; +} SBModule SBSymbolContext::GetModule() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBModule, SBSymbolContext, GetModule); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBModule sb_module; @@ -64,14 +83,20 @@ SBModule SBSymbolContext::GetModule() { static_cast<void *>(module_sp.get()), sstr.GetData()); } - return sb_module; + return LLDB_RECORD_RESULT(sb_module); } SBCompileUnit SBSymbolContext::GetCompileUnit() { - return SBCompileUnit(m_opaque_up ? m_opaque_up->comp_unit : NULL); + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCompileUnit, SBSymbolContext, + GetCompileUnit); + + return LLDB_RECORD_RESULT( + SBCompileUnit(m_opaque_up ? m_opaque_up->comp_unit : NULL)); } SBFunction SBSymbolContext::GetFunction() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFunction, SBSymbolContext, GetFunction); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); Function *function = NULL; @@ -86,14 +111,18 @@ SBFunction SBSymbolContext::GetFunction() { static_cast<void *>(m_opaque_up.get()), static_cast<void *>(function)); - return sb_function; + return LLDB_RECORD_RESULT(sb_function); } SBBlock SBSymbolContext::GetBlock() { - return SBBlock(m_opaque_up ? m_opaque_up->block : NULL); + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBSymbolContext, GetBlock); + + return LLDB_RECORD_RESULT(SBBlock(m_opaque_up ? m_opaque_up->block : NULL)); } SBLineEntry SBSymbolContext::GetLineEntry() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBLineEntry, SBSymbolContext, GetLineEntry); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBLineEntry sb_line_entry; @@ -106,10 +135,12 @@ SBLineEntry SBSymbolContext::GetLineEntry() { static_cast<void *>(sb_line_entry.get())); } - return sb_line_entry; + return LLDB_RECORD_RESULT(sb_line_entry); } SBSymbol SBSymbolContext::GetSymbol() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSymbol, SBSymbolContext, GetSymbol); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); Symbol *symbol = NULL; @@ -124,26 +155,40 @@ SBSymbol SBSymbolContext::GetSymbol() { static_cast<void *>(m_opaque_up.get()), static_cast<void *>(symbol)); - return sb_symbol; + return LLDB_RECORD_RESULT(sb_symbol); } void SBSymbolContext::SetModule(lldb::SBModule module) { + LLDB_RECORD_METHOD(void, SBSymbolContext, SetModule, (lldb::SBModule), + module); + ref().module_sp = module.GetSP(); } void SBSymbolContext::SetCompileUnit(lldb::SBCompileUnit compile_unit) { + LLDB_RECORD_METHOD(void, SBSymbolContext, SetCompileUnit, + (lldb::SBCompileUnit), compile_unit); + ref().comp_unit = compile_unit.get(); } void SBSymbolContext::SetFunction(lldb::SBFunction function) { + LLDB_RECORD_METHOD(void, SBSymbolContext, SetFunction, (lldb::SBFunction), + function); + ref().function = function.get(); } void SBSymbolContext::SetBlock(lldb::SBBlock block) { + LLDB_RECORD_METHOD(void, SBSymbolContext, SetBlock, (lldb::SBBlock), block); + ref().block = block.GetPtr(); } void SBSymbolContext::SetLineEntry(lldb::SBLineEntry line_entry) { + LLDB_RECORD_METHOD(void, SBSymbolContext, SetLineEntry, (lldb::SBLineEntry), + line_entry); + if (line_entry.IsValid()) ref().line_entry = line_entry.ref(); else @@ -151,6 +196,9 @@ void SBSymbolContext::SetLineEntry(lldb::SBLineEntry line_entry) { } void SBSymbolContext::SetSymbol(lldb::SBSymbol symbol) { + LLDB_RECORD_METHOD(void, SBSymbolContext, SetSymbol, (lldb::SBSymbol), + symbol); + ref().symbol = symbol.get(); } @@ -180,6 +228,9 @@ lldb_private::SymbolContext *SBSymbolContext::get() const { } bool SBSymbolContext::GetDescription(SBStream &description) { + LLDB_RECORD_METHOD(bool, SBSymbolContext, GetDescription, (lldb::SBStream &), + description); + Stream &strm = description.ref(); if (m_opaque_up) { @@ -193,11 +244,16 @@ bool SBSymbolContext::GetDescription(SBStream &description) { SBSymbolContext SBSymbolContext::GetParentOfInlinedScope(const SBAddress &curr_frame_pc, SBAddress &parent_frame_addr) const { + LLDB_RECORD_METHOD_CONST(lldb::SBSymbolContext, SBSymbolContext, + GetParentOfInlinedScope, + (const lldb::SBAddress &, lldb::SBAddress &), + curr_frame_pc, parent_frame_addr); + SBSymbolContext sb_sc; if (m_opaque_up.get() && curr_frame_pc.IsValid()) { if (m_opaque_up->GetParentOfInlinedScope(curr_frame_pc.ref(), sb_sc.ref(), parent_frame_addr.ref())) - return sb_sc; + return LLDB_RECORD_RESULT(sb_sc); } - return SBSymbolContext(); + return LLDB_RECORD_RESULT(SBSymbolContext()); } diff --git a/lldb/source/API/SBSymbolContextList.cpp b/lldb/source/API/SBSymbolContextList.cpp index 7a5b93b4cda..55943a7e1ce 100644 --- a/lldb/source/API/SBSymbolContextList.cpp +++ b/lldb/source/API/SBSymbolContextList.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBSymbolContextList.h" +#include "SBReproducerPrivate.h" #include "Utils.h" #include "lldb/API/SBStream.h" #include "lldb/Symbol/SymbolContext.h" @@ -15,10 +16,14 @@ using namespace lldb; using namespace lldb_private; SBSymbolContextList::SBSymbolContextList() - : m_opaque_up(new SymbolContextList()) {} + : m_opaque_up(new SymbolContextList()) { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSymbolContextList); +} SBSymbolContextList::SBSymbolContextList(const SBSymbolContextList &rhs) : m_opaque_up() { + LLDB_RECORD_CONSTRUCTOR(SBSymbolContextList, + (const lldb::SBSymbolContextList &), rhs); m_opaque_up = clone(rhs.m_opaque_up); } @@ -27,18 +32,27 @@ SBSymbolContextList::~SBSymbolContextList() {} const SBSymbolContextList &SBSymbolContextList:: operator=(const SBSymbolContextList &rhs) { + LLDB_RECORD_METHOD( + const lldb::SBSymbolContextList &, + SBSymbolContextList, operator=,(const lldb::SBSymbolContextList &), rhs); + if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); return *this; } uint32_t SBSymbolContextList::GetSize() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBSymbolContextList, GetSize); + if (m_opaque_up) return m_opaque_up->GetSize(); return 0; } SBSymbolContext SBSymbolContextList::GetContextAtIndex(uint32_t idx) { + LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBSymbolContextList, + GetContextAtIndex, (uint32_t), idx); + SBSymbolContext sb_sc; if (m_opaque_up) { SymbolContext sc; @@ -46,25 +60,37 @@ SBSymbolContext SBSymbolContextList::GetContextAtIndex(uint32_t idx) { sb_sc.SetSymbolContext(&sc); } } - return sb_sc; + return LLDB_RECORD_RESULT(sb_sc); } void SBSymbolContextList::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBSymbolContextList, Clear); + if (m_opaque_up) m_opaque_up->Clear(); } void SBSymbolContextList::Append(SBSymbolContext &sc) { + LLDB_RECORD_METHOD(void, SBSymbolContextList, Append, + (lldb::SBSymbolContext &), sc); + if (sc.IsValid() && m_opaque_up.get()) m_opaque_up->Append(*sc); } void SBSymbolContextList::Append(SBSymbolContextList &sc_list) { + LLDB_RECORD_METHOD(void, SBSymbolContextList, Append, + (lldb::SBSymbolContextList &), sc_list); + if (sc_list.IsValid() && m_opaque_up.get()) m_opaque_up->Append(*sc_list); } -bool SBSymbolContextList::IsValid() const { return m_opaque_up != NULL; } +bool SBSymbolContextList::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContextList, IsValid); + + return m_opaque_up != NULL; +} lldb_private::SymbolContextList *SBSymbolContextList::operator->() const { return m_opaque_up.get(); @@ -76,6 +102,9 @@ lldb_private::SymbolContextList &SBSymbolContextList::operator*() const { } bool SBSymbolContextList::GetDescription(lldb::SBStream &description) { + LLDB_RECORD_METHOD(bool, SBSymbolContextList, GetDescription, + (lldb::SBStream &), description); + Stream &strm = description.ref(); if (m_opaque_up) m_opaque_up->GetDescription(&strm, lldb::eDescriptionLevelFull, NULL); diff --git a/lldb/source/API/SBTarget.cpp b/lldb/source/API/SBTarget.cpp index 3b53d2dcd5d..7719764631f 100644 --- a/lldb/source/API/SBTarget.cpp +++ b/lldb/source/API/SBTarget.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBTarget.h" +#include "SBReproducerPrivate.h" #include "lldb/lldb-public.h" @@ -100,13 +101,22 @@ Status AttachToProcess(ProcessAttachInfo &attach_info, Target &target) { //---------------------------------------------------------------------- // SBTarget constructor //---------------------------------------------------------------------- -SBTarget::SBTarget() : m_opaque_sp() {} +SBTarget::SBTarget() : m_opaque_sp() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTarget); +} -SBTarget::SBTarget(const SBTarget &rhs) : m_opaque_sp(rhs.m_opaque_sp) {} +SBTarget::SBTarget(const SBTarget &rhs) : m_opaque_sp(rhs.m_opaque_sp) { + LLDB_RECORD_CONSTRUCTOR(SBTarget, (const lldb::SBTarget &), rhs); +} -SBTarget::SBTarget(const TargetSP &target_sp) : m_opaque_sp(target_sp) {} +SBTarget::SBTarget(const TargetSP &target_sp) : m_opaque_sp(target_sp) { + LLDB_RECORD_CONSTRUCTOR(SBTarget, (const lldb::TargetSP &), target_sp); +} const SBTarget &SBTarget::operator=(const SBTarget &rhs) { + LLDB_RECORD_METHOD(const lldb::SBTarget &, + SBTarget, operator=,(const lldb::SBTarget &), rhs); + if (this != &rhs) m_opaque_sp = rhs.m_opaque_sp; return *this; @@ -118,14 +128,24 @@ const SBTarget &SBTarget::operator=(const SBTarget &rhs) { SBTarget::~SBTarget() {} bool SBTarget::EventIsTargetEvent(const SBEvent &event) { + LLDB_RECORD_STATIC_METHOD(bool, SBTarget, EventIsTargetEvent, + (const lldb::SBEvent &), event); + return Target::TargetEventData::GetEventDataFromEvent(event.get()) != NULL; } SBTarget SBTarget::GetTargetFromEvent(const SBEvent &event) { - return Target::TargetEventData::GetTargetFromEvent(event.get()); + LLDB_RECORD_STATIC_METHOD(lldb::SBTarget, SBTarget, GetTargetFromEvent, + (const lldb::SBEvent &), event); + + return LLDB_RECORD_RESULT( + Target::TargetEventData::GetTargetFromEvent(event.get())); } uint32_t SBTarget::GetNumModulesFromEvent(const SBEvent &event) { + LLDB_RECORD_STATIC_METHOD(uint32_t, SBTarget, GetNumModulesFromEvent, + (const lldb::SBEvent &), event); + const ModuleList module_list = Target::TargetEventData::GetModuleListFromEvent(event.get()); return module_list.GetSize(); @@ -133,20 +153,31 @@ uint32_t SBTarget::GetNumModulesFromEvent(const SBEvent &event) { SBModule SBTarget::GetModuleAtIndexFromEvent(const uint32_t idx, const SBEvent &event) { + LLDB_RECORD_STATIC_METHOD(lldb::SBModule, SBTarget, GetModuleAtIndexFromEvent, + (const uint32_t, const lldb::SBEvent &), idx, + event); + const ModuleList module_list = Target::TargetEventData::GetModuleListFromEvent(event.get()); - return SBModule(module_list.GetModuleAtIndex(idx)); + return LLDB_RECORD_RESULT(SBModule(module_list.GetModuleAtIndex(idx))); } const char *SBTarget::GetBroadcasterClassName() { + LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBTarget, + GetBroadcasterClassName); + return Target::GetStaticBroadcasterClass().AsCString(); } bool SBTarget::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTarget, IsValid); + return m_opaque_sp.get() != NULL && m_opaque_sp->IsValid(); } SBProcess SBTarget::GetProcess() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBTarget, GetProcess); + SBProcess sb_process; ProcessSP process_sp; TargetSP target_sp(GetSP()); @@ -161,33 +192,39 @@ SBProcess SBTarget::GetProcess() { static_cast<void *>(target_sp.get()), static_cast<void *>(process_sp.get())); - return sb_process; + return LLDB_RECORD_RESULT(sb_process); } SBPlatform SBTarget::GetPlatform() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBPlatform, SBTarget, GetPlatform); + TargetSP target_sp(GetSP()); if (!target_sp) - return SBPlatform(); + return LLDB_RECORD_RESULT(SBPlatform()); SBPlatform platform; platform.m_opaque_sp = target_sp->GetPlatform(); - return platform; + return LLDB_RECORD_RESULT(platform); } SBDebugger SBTarget::GetDebugger() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBDebugger, SBTarget, GetDebugger); + SBDebugger debugger; TargetSP target_sp(GetSP()); if (target_sp) debugger.reset(target_sp->GetDebugger().shared_from_this()); - return debugger; + return LLDB_RECORD_RESULT(debugger); } SBStructuredData SBTarget::GetStatistics() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStructuredData, SBTarget, GetStatistics); + SBStructuredData data; TargetSP target_sp(GetSP()); if (!target_sp) - return data; + return LLDB_RECORD_RESULT(data); auto stats_up = llvm::make_unique<StructuredData::Dictionary>(); int i = 0; @@ -199,10 +236,12 @@ SBStructuredData SBTarget::GetStatistics() { } data.m_impl_up->SetObjectSP(std::move(stats_up)); - return data; + return LLDB_RECORD_RESULT(data); } void SBTarget::SetCollectingStats(bool v) { + LLDB_RECORD_METHOD(void, SBTarget, SetCollectingStats, (bool), v); + TargetSP target_sp(GetSP()); if (!target_sp) return; @@ -210,19 +249,26 @@ void SBTarget::SetCollectingStats(bool v) { } bool SBTarget::GetCollectingStats() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, GetCollectingStats); + TargetSP target_sp(GetSP()); if (!target_sp) return false; return target_sp->GetCollectingStats(); } - SBProcess SBTarget::LoadCore(const char *core_file) { + LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, LoadCore, (const char *), + core_file); + lldb::SBError error; // Ignored - return LoadCore(core_file, error); + return LLDB_RECORD_RESULT(LoadCore(core_file, error)); } SBProcess SBTarget::LoadCore(const char *core_file, lldb::SBError &error) { + LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, LoadCore, + (const char *, lldb::SBError &), core_file, error); + SBProcess sb_process; TargetSP target_sp(GetSP()); if (target_sp) { @@ -240,11 +286,15 @@ SBProcess SBTarget::LoadCore(const char *core_file, lldb::SBError &error) { } else { error.SetErrorString("SBTarget is invalid"); } - return sb_process; + return LLDB_RECORD_RESULT(sb_process); } SBProcess SBTarget::LaunchSimple(char const **argv, char const **envp, const char *working_directory) { + LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, LaunchSimple, + (const char **, const char **, const char *), argv, envp, + working_directory); + char *stdin_path = NULL; char *stdout_path = NULL; char *stderr_path = NULL; @@ -252,18 +302,21 @@ SBProcess SBTarget::LaunchSimple(char const **argv, char const **envp, bool stop_at_entry = false; SBError error; SBListener listener = GetDebugger().GetListener(); - return Launch(listener, argv, envp, stdin_path, stdout_path, stderr_path, - working_directory, launch_flags, stop_at_entry, error); + return LLDB_RECORD_RESULT(Launch(listener, argv, envp, stdin_path, + stdout_path, stderr_path, working_directory, + launch_flags, stop_at_entry, error)); } SBError SBTarget::Install() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBTarget, Install); + SBError sb_error; TargetSP target_sp(GetSP()); if (target_sp) { std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); sb_error.ref() = target_sp->Install(NULL); } - return sb_error; + return LLDB_RECORD_RESULT(sb_error); } SBProcess SBTarget::Launch(SBListener &listener, char const **argv, @@ -272,6 +325,13 @@ SBProcess SBTarget::Launch(SBListener &listener, char const **argv, const char *working_directory, uint32_t launch_flags, // See LaunchFlags bool stop_at_entry, lldb::SBError &error) { + LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, Launch, + (lldb::SBListener &, const char **, const char **, + const char *, const char *, const char *, const char *, + uint32_t, bool, lldb::SBError &), + listener, argv, envp, stdin_path, stdout_path, stderr_path, + working_directory, launch_flags, stop_at_entry, error); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBProcess sb_process; @@ -308,7 +368,7 @@ SBProcess SBTarget::Launch(SBListener &listener, char const **argv, error.SetErrorString("process attach is in progress"); else error.SetErrorString("a process is already being debugged"); - return sb_process; + return LLDB_RECORD_RESULT(sb_process); } } @@ -319,7 +379,7 @@ SBProcess SBTarget::Launch(SBListener &listener, char const **argv, if (listener.IsValid()) { error.SetErrorString("process is connected and already has a listener, " "pass empty listener"); - return sb_process; + return LLDB_RECORD_RESULT(sb_process); } } @@ -355,10 +415,14 @@ SBProcess SBTarget::Launch(SBListener &listener, char const **argv, static_cast<void *>(sb_process.GetSP().get()), error.GetCString()); - return sb_process; + return LLDB_RECORD_RESULT(sb_process); } SBProcess SBTarget::Launch(SBLaunchInfo &sb_launch_info, SBError &error) { + LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, Launch, + (lldb::SBLaunchInfo &, lldb::SBError &), sb_launch_info, + error); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBProcess sb_process; @@ -381,7 +445,7 @@ SBProcess SBTarget::Launch(SBLaunchInfo &sb_launch_info, SBError &error) { error.SetErrorString("process attach is in progress"); else error.SetErrorString("a process is already being debugged"); - return sb_process; + return LLDB_RECORD_RESULT(sb_process); } } } @@ -411,10 +475,14 @@ SBProcess SBTarget::Launch(SBLaunchInfo &sb_launch_info, SBError &error) { static_cast<void *>(target_sp.get()), static_cast<void *>(sb_process.GetSP().get())); - return sb_process; + return LLDB_RECORD_RESULT(sb_process); } lldb::SBProcess SBTarget::Attach(SBAttachInfo &sb_attach_info, SBError &error) { + LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, Attach, + (lldb::SBAttachInfo &, lldb::SBError &), sb_attach_info, + error); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBProcess sb_process; @@ -442,7 +510,7 @@ lldb::SBProcess SBTarget::Attach(SBAttachInfo &sb_attach_info, SBError &error) { static_cast<void *>(target_sp.get()), error.GetCString()); } - return sb_process; + return LLDB_RECORD_RESULT(sb_process); } } } @@ -458,14 +526,18 @@ lldb::SBProcess SBTarget::Attach(SBAttachInfo &sb_attach_info, SBError &error) { static_cast<void *>(target_sp.get()), static_cast<void *>(sb_process.GetSP().get())); - return sb_process; + return LLDB_RECORD_RESULT(sb_process); } lldb::SBProcess SBTarget::AttachToProcessWithID( SBListener &listener, lldb::pid_t pid, // The process ID to attach to SBError &error // An error explaining what went wrong if attach fails - ) { +) { + LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, AttachToProcessWithID, + (lldb::SBListener &, lldb::pid_t, lldb::SBError &), + listener, pid, error); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBProcess sb_process; @@ -495,7 +567,7 @@ lldb::SBProcess SBTarget::AttachToProcessWithID( log->Printf("SBTarget(%p)::%s (...) => SBProcess(%p)", static_cast<void *>(target_sp.get()), __FUNCTION__, static_cast<void *>(sb_process.GetSP().get())); - return sb_process; + return LLDB_RECORD_RESULT(sb_process); } lldb::SBProcess SBTarget::AttachToProcessWithName( @@ -503,7 +575,11 @@ lldb::SBProcess SBTarget::AttachToProcessWithName( const char *name, // basename of process to attach to bool wait_for, // if true wait for a new instance of "name" to be launched SBError &error // An error explaining what went wrong if attach fails - ) { +) { + LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, AttachToProcessWithName, + (lldb::SBListener &, const char *, bool, lldb::SBError &), + listener, name, wait_for, error); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBProcess sb_process; @@ -531,12 +607,17 @@ lldb::SBProcess SBTarget::AttachToProcessWithName( log->Printf("SBTarget(%p)::%s (...) => SBProcess(%p)", static_cast<void *>(target_sp.get()), __FUNCTION__, static_cast<void *>(sb_process.GetSP().get())); - return sb_process; + return LLDB_RECORD_RESULT(sb_process); } lldb::SBProcess SBTarget::ConnectRemote(SBListener &listener, const char *url, const char *plugin_name, SBError &error) { + LLDB_RECORD_METHOD( + lldb::SBProcess, SBTarget, ConnectRemote, + (lldb::SBListener &, const char *, const char *, lldb::SBError &), + listener, url, plugin_name, error); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBProcess sb_process; @@ -571,10 +652,11 @@ lldb::SBProcess SBTarget::ConnectRemote(SBListener &listener, const char *url, log->Printf("SBTarget(%p)::ConnectRemote (...) => SBProcess(%p)", static_cast<void *>(target_sp.get()), static_cast<void *>(process_sp.get())); - return sb_process; + return LLDB_RECORD_RESULT(sb_process); } SBFileSpec SBTarget::GetExecutable() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBTarget, GetExecutable); SBFileSpec exe_file_spec; TargetSP target_sp(GetSP()); @@ -591,14 +673,20 @@ SBFileSpec SBTarget::GetExecutable() { static_cast<const void *>(exe_file_spec.get())); } - return exe_file_spec; + return LLDB_RECORD_RESULT(exe_file_spec); } bool SBTarget::operator==(const SBTarget &rhs) const { + LLDB_RECORD_METHOD_CONST(bool, SBTarget, operator==,(const lldb::SBTarget &), + rhs); + return m_opaque_sp.get() == rhs.m_opaque_sp.get(); } bool SBTarget::operator!=(const SBTarget &rhs) const { + LLDB_RECORD_METHOD_CONST(bool, SBTarget, operator!=,(const lldb::SBTarget &), + rhs); + return m_opaque_sp.get() != rhs.m_opaque_sp.get(); } @@ -609,55 +697,68 @@ void SBTarget::SetSP(const lldb::TargetSP &target_sp) { } lldb::SBAddress SBTarget::ResolveLoadAddress(lldb::addr_t vm_addr) { + LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolveLoadAddress, + (lldb::addr_t), vm_addr); + lldb::SBAddress sb_addr; Address &addr = sb_addr.ref(); TargetSP target_sp(GetSP()); if (target_sp) { std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); if (target_sp->ResolveLoadAddress(vm_addr, addr)) - return sb_addr; + return LLDB_RECORD_RESULT(sb_addr); } // We have a load address that isn't in a section, just return an address // with the offset filled in (the address) and the section set to NULL addr.SetRawAddress(vm_addr); - return sb_addr; + return LLDB_RECORD_RESULT(sb_addr); } lldb::SBAddress SBTarget::ResolveFileAddress(lldb::addr_t file_addr) { + LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolveFileAddress, + (lldb::addr_t), file_addr); + lldb::SBAddress sb_addr; Address &addr = sb_addr.ref(); TargetSP target_sp(GetSP()); if (target_sp) { std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); if (target_sp->ResolveFileAddress(file_addr, addr)) - return sb_addr; + return LLDB_RECORD_RESULT(sb_addr); } addr.SetRawAddress(file_addr); - return sb_addr; + return LLDB_RECORD_RESULT(sb_addr); } lldb::SBAddress SBTarget::ResolvePastLoadAddress(uint32_t stop_id, lldb::addr_t vm_addr) { + LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolvePastLoadAddress, + (uint32_t, lldb::addr_t), stop_id, vm_addr); + lldb::SBAddress sb_addr; Address &addr = sb_addr.ref(); TargetSP target_sp(GetSP()); if (target_sp) { std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); if (target_sp->ResolveLoadAddress(vm_addr, addr)) - return sb_addr; + return LLDB_RECORD_RESULT(sb_addr); } // We have a load address that isn't in a section, just return an address // with the offset filled in (the address) and the section set to NULL addr.SetRawAddress(vm_addr); - return sb_addr; + return LLDB_RECORD_RESULT(sb_addr); } SBSymbolContext SBTarget::ResolveSymbolContextForAddress(const SBAddress &addr, uint32_t resolve_scope) { + LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBTarget, + ResolveSymbolContextForAddress, + (const lldb::SBAddress &, uint32_t), addr, resolve_scope); + SBSymbolContext sc; SymbolContextItem scope = static_cast<SymbolContextItem>(resolve_scope); if (addr.IsValid()) { @@ -666,7 +767,7 @@ SBTarget::ResolveSymbolContextForAddress(const SBAddress &addr, target_sp->GetImages().ResolveSymbolContextForAddress(addr.ref(), scope, sc.ref()); } - return sc; + return LLDB_RECORD_RESULT(sc); } size_t SBTarget::ReadMemory(const SBAddress addr, void *buf, size_t size, @@ -687,34 +788,55 @@ size_t SBTarget::ReadMemory(const SBAddress addr, void *buf, size_t size, SBBreakpoint SBTarget::BreakpointCreateByLocation(const char *file, uint32_t line) { - return SBBreakpoint( - BreakpointCreateByLocation(SBFileSpec(file, false), line)); + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation, + (const char *, uint32_t), file, line); + + return LLDB_RECORD_RESULT( + SBBreakpoint(BreakpointCreateByLocation(SBFileSpec(file, false), line))); } SBBreakpoint SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec, uint32_t line) { - return BreakpointCreateByLocation(sb_file_spec, line, 0); + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation, + (const lldb::SBFileSpec &, uint32_t), sb_file_spec, line); + + return LLDB_RECORD_RESULT(BreakpointCreateByLocation(sb_file_spec, line, 0)); } SBBreakpoint SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec, uint32_t line, lldb::addr_t offset) { + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation, + (const lldb::SBFileSpec &, uint32_t, lldb::addr_t), + sb_file_spec, line, offset); + SBFileSpecList empty_list; - return BreakpointCreateByLocation(sb_file_spec, line, offset, empty_list); + return LLDB_RECORD_RESULT( + BreakpointCreateByLocation(sb_file_spec, line, offset, empty_list)); } SBBreakpoint SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec, uint32_t line, lldb::addr_t offset, SBFileSpecList &sb_module_list) { - return BreakpointCreateByLocation(sb_file_spec, line, 0, offset, - sb_module_list); + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation, + (const lldb::SBFileSpec &, uint32_t, lldb::addr_t, + lldb::SBFileSpecList &), + sb_file_spec, line, offset, sb_module_list); + + return LLDB_RECORD_RESULT(BreakpointCreateByLocation(sb_file_spec, line, 0, + offset, sb_module_list)); } SBBreakpoint SBTarget::BreakpointCreateByLocation( const SBFileSpec &sb_file_spec, uint32_t line, uint32_t column, lldb::addr_t offset, SBFileSpecList &sb_module_list) { + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation, + (const lldb::SBFileSpec &, uint32_t, uint32_t, + lldb::addr_t, lldb::SBFileSpecList &), + sb_file_spec, line, column, offset, sb_module_list); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBBreakpoint sb_bp; @@ -747,11 +869,14 @@ SBBreakpoint SBTarget::BreakpointCreateByLocation( static_cast<void *>(sb_bp.GetSP().get()), sstr.GetData()); } - return sb_bp; + return LLDB_RECORD_RESULT(sb_bp); } SBBreakpoint SBTarget::BreakpointCreateByName(const char *symbol_name, const char *module_name) { + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName, + (const char *, const char *), symbol_name, module_name); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBBreakpoint sb_bp; @@ -782,31 +907,48 @@ SBBreakpoint SBTarget::BreakpointCreateByName(const char *symbol_name, static_cast<void *>(target_sp.get()), symbol_name, module_name, static_cast<void *>(sb_bp.GetSP().get())); - return sb_bp; + return LLDB_RECORD_RESULT(sb_bp); } lldb::SBBreakpoint SBTarget::BreakpointCreateByName(const char *symbol_name, const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName, + (const char *, const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &), + symbol_name, module_list, comp_unit_list); + lldb::FunctionNameType name_type_mask = eFunctionNameTypeAuto; - return BreakpointCreateByName(symbol_name, name_type_mask, - eLanguageTypeUnknown, module_list, - comp_unit_list); + return LLDB_RECORD_RESULT( + BreakpointCreateByName(symbol_name, name_type_mask, eLanguageTypeUnknown, + module_list, comp_unit_list)); } lldb::SBBreakpoint SBTarget::BreakpointCreateByName( const char *symbol_name, uint32_t name_type_mask, const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { - return BreakpointCreateByName(symbol_name, name_type_mask, - eLanguageTypeUnknown, module_list, - comp_unit_list); + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName, + (const char *, uint32_t, const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &), + symbol_name, name_type_mask, module_list, comp_unit_list); + + return LLDB_RECORD_RESULT( + BreakpointCreateByName(symbol_name, name_type_mask, eLanguageTypeUnknown, + module_list, comp_unit_list)); } lldb::SBBreakpoint SBTarget::BreakpointCreateByName( const char *symbol_name, uint32_t name_type_mask, LanguageType symbol_language, const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName, + (const char *, uint32_t, lldb::LanguageType, + const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &), + symbol_name, name_type_mask, symbol_language, module_list, + comp_unit_list); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBBreakpoint sb_bp; @@ -828,30 +970,50 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateByName( static_cast<void *>(target_sp.get()), symbol_name, name_type_mask, static_cast<void *>(sb_bp.GetSP().get())); - return sb_bp; + return LLDB_RECORD_RESULT(sb_bp); } lldb::SBBreakpoint SBTarget::BreakpointCreateByNames( const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask, const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { - return BreakpointCreateByNames(symbol_names, num_names, name_type_mask, - eLanguageTypeUnknown, module_list, - comp_unit_list); + LLDB_RECORD_METHOD( + lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames, + (const char **, uint32_t, uint32_t, const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &), + symbol_names, num_names, name_type_mask, module_list, comp_unit_list); + + return LLDB_RECORD_RESULT(BreakpointCreateByNames( + symbol_names, num_names, name_type_mask, eLanguageTypeUnknown, + module_list, comp_unit_list)); } lldb::SBBreakpoint SBTarget::BreakpointCreateByNames( const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask, LanguageType symbol_language, const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { - return BreakpointCreateByNames(symbol_names, num_names, name_type_mask, - eLanguageTypeUnknown, 0, module_list, - comp_unit_list); + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames, + (const char **, uint32_t, uint32_t, lldb::LanguageType, + const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &), + symbol_names, num_names, name_type_mask, symbol_language, + module_list, comp_unit_list); + + return LLDB_RECORD_RESULT(BreakpointCreateByNames( + symbol_names, num_names, name_type_mask, eLanguageTypeUnknown, 0, + module_list, comp_unit_list)); } lldb::SBBreakpoint SBTarget::BreakpointCreateByNames( const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask, LanguageType symbol_language, lldb::addr_t offset, const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames, + (const char **, uint32_t, uint32_t, lldb::LanguageType, + lldb::addr_t, const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &), + symbol_names, num_names, name_type_mask, symbol_language, + offset, module_list, comp_unit_list); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBBreakpoint sb_bp; @@ -885,31 +1047,47 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateByNames( static_cast<void *>(sb_bp.GetSP().get())); } - return sb_bp; + return LLDB_RECORD_RESULT(sb_bp); } SBBreakpoint SBTarget::BreakpointCreateByRegex(const char *symbol_name_regex, const char *module_name) { + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex, + (const char *, const char *), symbol_name_regex, + module_name); + SBFileSpecList module_spec_list; SBFileSpecList comp_unit_list; if (module_name && module_name[0]) { module_spec_list.Append(FileSpec(module_name)); } - return BreakpointCreateByRegex(symbol_name_regex, eLanguageTypeUnknown, - module_spec_list, comp_unit_list); + return LLDB_RECORD_RESULT( + BreakpointCreateByRegex(symbol_name_regex, eLanguageTypeUnknown, + module_spec_list, comp_unit_list)); } lldb::SBBreakpoint SBTarget::BreakpointCreateByRegex(const char *symbol_name_regex, const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { - return BreakpointCreateByRegex(symbol_name_regex, eLanguageTypeUnknown, - module_list, comp_unit_list); + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex, + (const char *, const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &), + symbol_name_regex, module_list, comp_unit_list); + + return LLDB_RECORD_RESULT(BreakpointCreateByRegex( + symbol_name_regex, eLanguageTypeUnknown, module_list, comp_unit_list)); } lldb::SBBreakpoint SBTarget::BreakpointCreateByRegex( const char *symbol_name_regex, LanguageType symbol_language, const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { + LLDB_RECORD_METHOD( + lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex, + (const char *, lldb::LanguageType, const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &), + symbol_name_regex, symbol_language, module_list, comp_unit_list); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBBreakpoint sb_bp; @@ -932,10 +1110,13 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateByRegex( static_cast<void *>(target_sp.get()), symbol_name_regex, static_cast<void *>(sb_bp.GetSP().get())); - return sb_bp; + return LLDB_RECORD_RESULT(sb_bp); } SBBreakpoint SBTarget::BreakpointCreateByAddress(addr_t address) { + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByAddress, + (lldb::addr_t), address); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBBreakpoint sb_bp; @@ -953,10 +1134,13 @@ SBBreakpoint SBTarget::BreakpointCreateByAddress(addr_t address) { static_cast<uint64_t>(address), static_cast<void *>(sb_bp.GetSP().get())); - return sb_bp; + return LLDB_RECORD_RESULT(sb_bp); } SBBreakpoint SBTarget::BreakpointCreateBySBAddress(SBAddress &sb_address) { + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateBySBAddress, + (lldb::SBAddress &), sb_address); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBBreakpoint sb_bp; @@ -966,7 +1150,7 @@ SBBreakpoint SBTarget::BreakpointCreateBySBAddress(SBAddress &sb_address) { log->Printf("SBTarget(%p)::BreakpointCreateBySBAddress called with " "invalid address", static_cast<void *>(target_sp.get())); - return sb_bp; + return LLDB_RECORD_RESULT(sb_bp); } if (target_sp) { @@ -984,13 +1168,18 @@ SBBreakpoint SBTarget::BreakpointCreateBySBAddress(SBAddress &sb_address) { static_cast<void *>(sb_bp.GetSP().get())); } - return sb_bp; + return LLDB_RECORD_RESULT(sb_bp); } lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex(const char *source_regex, const lldb::SBFileSpec &source_file, const char *module_name) { + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, + BreakpointCreateBySourceRegex, + (const char *, const lldb::SBFileSpec &, const char *), + source_regex, source_file, module_name); + SBFileSpecList module_spec_list; if (module_name && module_name[0]) { @@ -1002,21 +1191,33 @@ SBTarget::BreakpointCreateBySourceRegex(const char *source_regex, source_file_list.Append(source_file); } - return BreakpointCreateBySourceRegex(source_regex, module_spec_list, - source_file_list); + return LLDB_RECORD_RESULT(BreakpointCreateBySourceRegex( + source_regex, module_spec_list, source_file_list)); } lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex( const char *source_regex, const SBFileSpecList &module_list, const lldb::SBFileSpecList &source_file_list) { - return BreakpointCreateBySourceRegex(source_regex, module_list, - source_file_list, SBStringList()); + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, + BreakpointCreateBySourceRegex, + (const char *, const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &), + source_regex, module_list, source_file_list); + + return LLDB_RECORD_RESULT(BreakpointCreateBySourceRegex( + source_regex, module_list, source_file_list, SBStringList())); } lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex( const char *source_regex, const SBFileSpecList &module_list, const lldb::SBFileSpecList &source_file_list, const SBStringList &func_names) { + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, + BreakpointCreateBySourceRegex, + (const char *, const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &, const lldb::SBStringList &), + source_regex, module_list, source_file_list, func_names); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBBreakpoint sb_bp; @@ -1042,12 +1243,16 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex( static_cast<void *>(target_sp.get()), source_regex, static_cast<void *>(sb_bp.GetSP().get())); - return sb_bp; + return LLDB_RECORD_RESULT(sb_bp); } lldb::SBBreakpoint SBTarget::BreakpointCreateForException(lldb::LanguageType language, bool catch_bp, bool throw_bp) { + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateForException, + (lldb::LanguageType, bool, bool), language, catch_bp, + throw_bp); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBBreakpoint sb_bp; @@ -1067,16 +1272,19 @@ SBTarget::BreakpointCreateForException(lldb::LanguageType language, catch_bp ? "on" : "off", throw_bp ? "on" : "off", static_cast<void *>(sb_bp.GetSP().get())); - return sb_bp; + return LLDB_RECORD_RESULT(sb_bp); } -lldb::SBBreakpoint -SBTarget::BreakpointCreateFromScript(const char *class_name, - SBStructuredData &extra_args, - const SBFileSpecList &module_list, - const SBFileSpecList &file_list, - bool request_hardware) -{ +lldb::SBBreakpoint SBTarget::BreakpointCreateFromScript( + const char *class_name, SBStructuredData &extra_args, + const SBFileSpecList &module_list, const SBFileSpecList &file_list, + bool request_hardware) { + LLDB_RECORD_METHOD( + lldb::SBBreakpoint, SBTarget, BreakpointCreateFromScript, + (const char *, lldb::SBStructuredData &, const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &, bool), + class_name, extra_args, module_list, file_list, request_hardware); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBBreakpoint sb_bp; @@ -1102,11 +1310,12 @@ SBTarget::BreakpointCreateFromScript(const char *class_name, class_name, static_cast<void *>(sb_bp.GetSP().get())); - return sb_bp; + return LLDB_RECORD_RESULT(sb_bp); } - uint32_t SBTarget::GetNumBreakpoints() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumBreakpoints); + TargetSP target_sp(GetSP()); if (target_sp) { // The breakpoint list is thread safe, no need to lock @@ -1116,16 +1325,22 @@ uint32_t SBTarget::GetNumBreakpoints() const { } SBBreakpoint SBTarget::GetBreakpointAtIndex(uint32_t idx) const { + LLDB_RECORD_METHOD_CONST(lldb::SBBreakpoint, SBTarget, GetBreakpointAtIndex, + (uint32_t), idx); + SBBreakpoint sb_breakpoint; TargetSP target_sp(GetSP()); if (target_sp) { // The breakpoint list is thread safe, no need to lock sb_breakpoint = target_sp->GetBreakpointList().GetBreakpointAtIndex(idx); } - return sb_breakpoint; + return LLDB_RECORD_RESULT(sb_breakpoint); } bool SBTarget::BreakpointDelete(break_id_t bp_id) { + LLDB_RECORD_METHOD(bool, SBTarget, BreakpointDelete, (lldb::break_id_t), + bp_id); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); bool result = false; @@ -1144,6 +1359,9 @@ bool SBTarget::BreakpointDelete(break_id_t bp_id) { } SBBreakpoint SBTarget::FindBreakpointByID(break_id_t bp_id) { + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, FindBreakpointByID, + (lldb::break_id_t), bp_id); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBBreakpoint sb_breakpoint; @@ -1159,11 +1377,14 @@ SBBreakpoint SBTarget::FindBreakpointByID(break_id_t bp_id) { static_cast<void *>(target_sp.get()), static_cast<uint32_t>(bp_id), static_cast<void *>(sb_breakpoint.GetSP().get())); - return sb_breakpoint; + return LLDB_RECORD_RESULT(sb_breakpoint); } bool SBTarget::FindBreakpointsByName(const char *name, SBBreakpointList &bkpts) { + LLDB_RECORD_METHOD(bool, SBTarget, FindBreakpointsByName, + (const char *, lldb::SBBreakpointList &), name, bkpts); + TargetSP target_sp(GetSP()); if (target_sp) { std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); @@ -1179,8 +1400,10 @@ bool SBTarget::FindBreakpointsByName(const char *name, return true; } -void SBTarget::GetBreakpointNames(SBStringList &names) -{ +void SBTarget::GetBreakpointNames(SBStringList &names) { + LLDB_RECORD_METHOD(void, SBTarget, GetBreakpointNames, (lldb::SBStringList &), + names); + names.Clear(); TargetSP target_sp(GetSP()); @@ -1194,8 +1417,10 @@ void SBTarget::GetBreakpointNames(SBStringList &names) } } -void SBTarget::DeleteBreakpointName(const char *name) -{ +void SBTarget::DeleteBreakpointName(const char *name) { + LLDB_RECORD_METHOD(void, SBTarget, DeleteBreakpointName, (const char *), + name); + TargetSP target_sp(GetSP()); if (target_sp) { std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); @@ -1204,6 +1429,8 @@ void SBTarget::DeleteBreakpointName(const char *name) } bool SBTarget::EnableAllBreakpoints() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, EnableAllBreakpoints); + TargetSP target_sp(GetSP()); if (target_sp) { std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); @@ -1214,6 +1441,8 @@ bool SBTarget::EnableAllBreakpoints() { } bool SBTarget::DisableAllBreakpoints() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DisableAllBreakpoints); + TargetSP target_sp(GetSP()); if (target_sp) { std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); @@ -1224,6 +1453,8 @@ bool SBTarget::DisableAllBreakpoints() { } bool SBTarget::DeleteAllBreakpoints() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DeleteAllBreakpoints); + TargetSP target_sp(GetSP()); if (target_sp) { std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); @@ -1235,19 +1466,29 @@ bool SBTarget::DeleteAllBreakpoints() { lldb::SBError SBTarget::BreakpointsCreateFromFile(SBFileSpec &source_file, SBBreakpointList &new_bps) { + LLDB_RECORD_METHOD(lldb::SBError, SBTarget, BreakpointsCreateFromFile, + (lldb::SBFileSpec &, lldb::SBBreakpointList &), + source_file, new_bps); + SBStringList empty_name_list; - return BreakpointsCreateFromFile(source_file, empty_name_list, new_bps); + return LLDB_RECORD_RESULT( + BreakpointsCreateFromFile(source_file, empty_name_list, new_bps)); } lldb::SBError SBTarget::BreakpointsCreateFromFile(SBFileSpec &source_file, SBStringList &matching_names, SBBreakpointList &new_bps) { + LLDB_RECORD_METHOD( + lldb::SBError, SBTarget, BreakpointsCreateFromFile, + (lldb::SBFileSpec &, lldb::SBStringList &, lldb::SBBreakpointList &), + source_file, matching_names, new_bps); + SBError sberr; TargetSP target_sp(GetSP()); if (!target_sp) { sberr.SetErrorString( "BreakpointCreateFromFile called with invalid target."); - return sberr; + return LLDB_RECORD_RESULT(sberr); } std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); @@ -1261,35 +1502,42 @@ lldb::SBError SBTarget::BreakpointsCreateFromFile(SBFileSpec &source_file, sberr.ref() = target_sp->CreateBreakpointsFromFile(source_file.ref(), name_vector, bp_ids); if (sberr.Fail()) - return sberr; + return LLDB_RECORD_RESULT(sberr); size_t num_bkpts = bp_ids.GetSize(); for (size_t i = 0; i < num_bkpts; i++) { BreakpointID bp_id = bp_ids.GetBreakpointIDAtIndex(i); new_bps.AppendByID(bp_id.GetBreakpointID()); } - return sberr; + return LLDB_RECORD_RESULT(sberr); } lldb::SBError SBTarget::BreakpointsWriteToFile(SBFileSpec &dest_file) { + LLDB_RECORD_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile, + (lldb::SBFileSpec &), dest_file); + SBError sberr; TargetSP target_sp(GetSP()); if (!target_sp) { sberr.SetErrorString("BreakpointWriteToFile called with invalid target."); - return sberr; + return LLDB_RECORD_RESULT(sberr); } SBBreakpointList bkpt_list(*this); - return BreakpointsWriteToFile(dest_file, bkpt_list); + return LLDB_RECORD_RESULT(BreakpointsWriteToFile(dest_file, bkpt_list)); } lldb::SBError SBTarget::BreakpointsWriteToFile(SBFileSpec &dest_file, SBBreakpointList &bkpt_list, bool append) { + LLDB_RECORD_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile, + (lldb::SBFileSpec &, lldb::SBBreakpointList &, bool), + dest_file, bkpt_list, append); + SBError sberr; TargetSP target_sp(GetSP()); if (!target_sp) { sberr.SetErrorString("BreakpointWriteToFile called with invalid target."); - return sberr; + return LLDB_RECORD_RESULT(sberr); } std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); @@ -1297,10 +1545,12 @@ lldb::SBError SBTarget::BreakpointsWriteToFile(SBFileSpec &dest_file, bkpt_list.CopyToBreakpointIDList(bp_id_list); sberr.ref() = target_sp->SerializeBreakpointsToFile(dest_file.ref(), bp_id_list, append); - return sberr; + return LLDB_RECORD_RESULT(sberr); } uint32_t SBTarget::GetNumWatchpoints() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumWatchpoints); + TargetSP target_sp(GetSP()); if (target_sp) { // The watchpoint list is thread safe, no need to lock @@ -1310,16 +1560,22 @@ uint32_t SBTarget::GetNumWatchpoints() const { } SBWatchpoint SBTarget::GetWatchpointAtIndex(uint32_t idx) const { + LLDB_RECORD_METHOD_CONST(lldb::SBWatchpoint, SBTarget, GetWatchpointAtIndex, + (uint32_t), idx); + SBWatchpoint sb_watchpoint; TargetSP target_sp(GetSP()); if (target_sp) { // The watchpoint list is thread safe, no need to lock sb_watchpoint.SetSP(target_sp->GetWatchpointList().GetByIndex(idx)); } - return sb_watchpoint; + return LLDB_RECORD_RESULT(sb_watchpoint); } bool SBTarget::DeleteWatchpoint(watch_id_t wp_id) { + LLDB_RECORD_METHOD(bool, SBTarget, DeleteWatchpoint, (lldb::watch_id_t), + wp_id); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); bool result = false; @@ -1340,6 +1596,9 @@ bool SBTarget::DeleteWatchpoint(watch_id_t wp_id) { } SBWatchpoint SBTarget::FindWatchpointByID(lldb::watch_id_t wp_id) { + LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBTarget, FindWatchpointByID, + (lldb::watch_id_t), wp_id); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBWatchpoint sb_watchpoint; @@ -1359,12 +1618,16 @@ SBWatchpoint SBTarget::FindWatchpointByID(lldb::watch_id_t wp_id) { static_cast<void *>(target_sp.get()), static_cast<uint32_t>(wp_id), static_cast<void *>(watchpoint_sp.get())); - return sb_watchpoint; + return LLDB_RECORD_RESULT(sb_watchpoint); } lldb::SBWatchpoint SBTarget::WatchAddress(lldb::addr_t addr, size_t size, bool read, bool write, SBError &error) { + LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBTarget, WatchAddress, + (lldb::addr_t, size_t, bool, bool, lldb::SBError &), addr, + size, read, write, error); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBWatchpoint sb_watchpoint; @@ -1381,7 +1644,7 @@ lldb::SBWatchpoint SBTarget::WatchAddress(lldb::addr_t addr, size_t size, if (watch_type == 0) { error.SetErrorString( "Can't create a watchpoint that is neither read nor write."); - return sb_watchpoint; + return LLDB_RECORD_RESULT(sb_watchpoint); } // Target::CreateWatchpoint() is thread safe. @@ -1401,10 +1664,12 @@ lldb::SBWatchpoint SBTarget::WatchAddress(lldb::addr_t addr, size_t size, static_cast<uint32_t>(size), static_cast<void *>(watchpoint_sp.get())); - return sb_watchpoint; + return LLDB_RECORD_RESULT(sb_watchpoint); } bool SBTarget::EnableAllWatchpoints() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, EnableAllWatchpoints); + TargetSP target_sp(GetSP()); if (target_sp) { std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); @@ -1417,6 +1682,8 @@ bool SBTarget::EnableAllWatchpoints() { } bool SBTarget::DisableAllWatchpoints() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DisableAllWatchpoints); + TargetSP target_sp(GetSP()); if (target_sp) { std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); @@ -1430,6 +1697,10 @@ bool SBTarget::DisableAllWatchpoints() { SBValue SBTarget::CreateValueFromAddress(const char *name, SBAddress addr, SBType type) { + LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, CreateValueFromAddress, + (const char *, lldb::SBAddress, lldb::SBType), name, addr, + type); + SBValue sb_value; lldb::ValueObjectSP new_value_sp; if (IsValid() && name && *name && addr.IsValid() && type.IsValid()) { @@ -1451,11 +1722,15 @@ SBValue SBTarget::CreateValueFromAddress(const char *name, SBAddress addr, log->Printf("SBTarget(%p)::CreateValueFromAddress => NULL", static_cast<void *>(m_opaque_sp.get())); } - return sb_value; + return LLDB_RECORD_RESULT(sb_value); } lldb::SBValue SBTarget::CreateValueFromData(const char *name, lldb::SBData data, lldb::SBType type) { + LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, CreateValueFromData, + (const char *, lldb::SBData, lldb::SBType), name, data, + type); + SBValue sb_value; lldb::ValueObjectSP new_value_sp; if (IsValid() && name && *name && data.IsValid() && type.IsValid()) { @@ -1477,11 +1752,14 @@ lldb::SBValue SBTarget::CreateValueFromData(const char *name, lldb::SBData data, log->Printf("SBTarget(%p)::CreateValueFromData => NULL", static_cast<void *>(m_opaque_sp.get())); } - return sb_value; + return LLDB_RECORD_RESULT(sb_value); } lldb::SBValue SBTarget::CreateValueFromExpression(const char *name, const char *expr) { + LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, CreateValueFromExpression, + (const char *, const char *), name, expr); + SBValue sb_value; lldb::ValueObjectSP new_value_sp; if (IsValid() && name && *name && expr && *expr) { @@ -1501,10 +1779,12 @@ lldb::SBValue SBTarget::CreateValueFromExpression(const char *name, log->Printf("SBTarget(%p)::CreateValueFromExpression => NULL", static_cast<void *>(m_opaque_sp.get())); } - return sb_value; + return LLDB_RECORD_RESULT(sb_value); } bool SBTarget::DeleteAllWatchpoints() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DeleteAllWatchpoints); + TargetSP target_sp(GetSP()); if (target_sp) { std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); @@ -1518,6 +1798,10 @@ bool SBTarget::DeleteAllWatchpoints() { void SBTarget::AppendImageSearchPath(const char *from, const char *to, lldb::SBError &error) { + LLDB_RECORD_METHOD(void, SBTarget, AppendImageSearchPath, + (const char *, const char *, lldb::SBError &), from, to, + error); + TargetSP target_sp(GetSP()); if (!target_sp) return error.SetErrorString("invalid target"); @@ -1538,11 +1822,19 @@ void SBTarget::AppendImageSearchPath(const char *from, const char *to, lldb::SBModule SBTarget::AddModule(const char *path, const char *triple, const char *uuid_cstr) { - return AddModule(path, triple, uuid_cstr, NULL); + LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule, + (const char *, const char *, const char *), path, triple, + uuid_cstr); + + return LLDB_RECORD_RESULT(AddModule(path, triple, uuid_cstr, NULL)); } lldb::SBModule SBTarget::AddModule(const char *path, const char *triple, const char *uuid_cstr, const char *symfile) { + LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule, + (const char *, const char *, const char *, const char *), + path, triple, uuid_cstr, symfile); + lldb::SBModule sb_module; TargetSP target_sp(GetSP()); if (target_sp) { @@ -1564,18 +1856,23 @@ lldb::SBModule SBTarget::AddModule(const char *path, const char *triple, sb_module.SetSP(target_sp->GetSharedModule(module_spec)); } - return sb_module; + return LLDB_RECORD_RESULT(sb_module); } lldb::SBModule SBTarget::AddModule(const SBModuleSpec &module_spec) { + LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule, + (const lldb::SBModuleSpec &), module_spec); + lldb::SBModule sb_module; TargetSP target_sp(GetSP()); if (target_sp) sb_module.SetSP(target_sp->GetSharedModule(*module_spec.m_opaque_up)); - return sb_module; + return LLDB_RECORD_RESULT(sb_module); } bool SBTarget::AddModule(lldb::SBModule &module) { + LLDB_RECORD_METHOD(bool, SBTarget, AddModule, (lldb::SBModule &), module); + TargetSP target_sp(GetSP()); if (target_sp) { target_sp->GetImages().AppendIfNeeded(module.GetSP()); @@ -1585,6 +1882,8 @@ bool SBTarget::AddModule(lldb::SBModule &module) { } uint32_t SBTarget::GetNumModules() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumModules); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); uint32_t num = 0; @@ -1602,6 +1901,8 @@ uint32_t SBTarget::GetNumModules() const { } void SBTarget::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBTarget, Clear); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) @@ -1612,6 +1913,9 @@ void SBTarget::Clear() { } SBModule SBTarget::FindModule(const SBFileSpec &sb_file_spec) { + LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, FindModule, + (const lldb::SBFileSpec &), sb_file_spec); + SBModule sb_module; TargetSP target_sp(GetSP()); if (target_sp && sb_file_spec.IsValid()) { @@ -1619,11 +1923,13 @@ SBModule SBTarget::FindModule(const SBFileSpec &sb_file_spec) { // The module list is thread safe, no need to lock sb_module.SetSP(target_sp->GetImages().FindFirstModule(module_spec)); } - return sb_module; + return LLDB_RECORD_RESULT(sb_module); } -SBSymbolContextList -SBTarget::FindCompileUnits(const SBFileSpec &sb_file_spec) { +SBSymbolContextList SBTarget::FindCompileUnits(const SBFileSpec &sb_file_spec) { + LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindCompileUnits, + (const lldb::SBFileSpec &), sb_file_spec); + SBSymbolContextList sb_sc_list; const TargetSP target_sp(GetSP()); if (target_sp && sb_file_spec.IsValid()) { @@ -1631,10 +1937,12 @@ SBTarget::FindCompileUnits(const SBFileSpec &sb_file_spec) { target_sp->GetImages().FindCompileUnits(*sb_file_spec, append, *sb_sc_list); } - return sb_sc_list; + return LLDB_RECORD_RESULT(sb_sc_list); } lldb::ByteOrder SBTarget::GetByteOrder() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::ByteOrder, SBTarget, GetByteOrder); + TargetSP target_sp(GetSP()); if (target_sp) return target_sp->GetArchitecture().GetByteOrder(); @@ -1642,6 +1950,8 @@ lldb::ByteOrder SBTarget::GetByteOrder() { } const char *SBTarget::GetTriple() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTarget, GetTriple); + TargetSP target_sp(GetSP()); if (target_sp) { std::string triple(target_sp->GetArchitecture().GetTriple().str()); @@ -1655,6 +1965,8 @@ const char *SBTarget::GetTriple() { } uint32_t SBTarget::GetDataByteSize() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTarget, GetDataByteSize); + TargetSP target_sp(GetSP()); if (target_sp) { return target_sp->GetArchitecture().GetDataByteSize(); @@ -1663,6 +1975,8 @@ uint32_t SBTarget::GetDataByteSize() { } uint32_t SBTarget::GetCodeByteSize() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTarget, GetCodeByteSize); + TargetSP target_sp(GetSP()); if (target_sp) { return target_sp->GetArchitecture().GetCodeByteSize(); @@ -1671,6 +1985,8 @@ uint32_t SBTarget::GetCodeByteSize() { } uint32_t SBTarget::GetAddressByteSize() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTarget, GetAddressByteSize); + TargetSP target_sp(GetSP()); if (target_sp) return target_sp->GetArchitecture().GetAddressByteSize(); @@ -1678,6 +1994,9 @@ uint32_t SBTarget::GetAddressByteSize() { } SBModule SBTarget::GetModuleAtIndex(uint32_t idx) { + LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, GetModuleAtIndex, (uint32_t), + idx); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBModule sb_module; @@ -1694,10 +2013,12 @@ SBModule SBTarget::GetModuleAtIndex(uint32_t idx) { static_cast<void *>(target_sp.get()), idx, static_cast<void *>(module_sp.get())); - return sb_module; + return LLDB_RECORD_RESULT(sb_module); } bool SBTarget::RemoveModule(lldb::SBModule module) { + LLDB_RECORD_METHOD(bool, SBTarget, RemoveModule, (lldb::SBModule), module); + TargetSP target_sp(GetSP()); if (target_sp) return target_sp->GetImages().Remove(module.GetSP()); @@ -1705,6 +2026,9 @@ bool SBTarget::RemoveModule(lldb::SBModule module) { } SBBroadcaster SBTarget::GetBroadcaster() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBTarget, + GetBroadcaster); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); TargetSP target_sp(GetSP()); @@ -1715,11 +2039,15 @@ SBBroadcaster SBTarget::GetBroadcaster() const { static_cast<void *>(target_sp.get()), static_cast<void *>(broadcaster.get())); - return broadcaster; + return LLDB_RECORD_RESULT(broadcaster); } bool SBTarget::GetDescription(SBStream &description, lldb::DescriptionLevel description_level) { + LLDB_RECORD_METHOD(bool, SBTarget, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel), description, + description_level); + Stream &strm = description.ref(); TargetSP target_sp(GetSP()); @@ -1733,13 +2061,16 @@ bool SBTarget::GetDescription(SBStream &description, lldb::SBSymbolContextList SBTarget::FindFunctions(const char *name, uint32_t name_type_mask) { + LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindFunctions, + (const char *, uint32_t), name, name_type_mask); + lldb::SBSymbolContextList sb_sc_list; if (!name | !name[0]) - return sb_sc_list; + return LLDB_RECORD_RESULT(sb_sc_list); TargetSP target_sp(GetSP()); if (!target_sp) - return sb_sc_list; + return LLDB_RECORD_RESULT(sb_sc_list); const bool symbols_ok = true; const bool inlines_ok = true; @@ -1747,12 +2078,16 @@ lldb::SBSymbolContextList SBTarget::FindFunctions(const char *name, FunctionNameType mask = static_cast<FunctionNameType>(name_type_mask); target_sp->GetImages().FindFunctions(ConstString(name), mask, symbols_ok, inlines_ok, append, *sb_sc_list); - return sb_sc_list; + return LLDB_RECORD_RESULT(sb_sc_list); } lldb::SBSymbolContextList SBTarget::FindGlobalFunctions(const char *name, uint32_t max_matches, MatchType matchtype) { + LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindGlobalFunctions, + (const char *, uint32_t, lldb::MatchType), name, + max_matches, matchtype); + lldb::SBSymbolContextList sb_sc_list; if (name && name[0]) { llvm::StringRef name_ref(name); @@ -1777,10 +2112,13 @@ lldb::SBSymbolContextList SBTarget::FindGlobalFunctions(const char *name, } } } - return sb_sc_list; + return LLDB_RECORD_RESULT(sb_sc_list); } lldb::SBType SBTarget::FindFirstType(const char *typename_cstr) { + LLDB_RECORD_METHOD(lldb::SBType, SBTarget, FindFirstType, (const char *), + typename_cstr); + TargetSP target_sp(GetSP()); if (typename_cstr && typename_cstr[0] && target_sp) { ConstString const_typename(typename_cstr); @@ -1795,7 +2133,7 @@ lldb::SBType SBTarget::FindFirstType(const char *typename_cstr) { TypeSP type_sp( module_sp->FindFirstType(sc, const_typename, exact_match)); if (type_sp) - return SBType(type_sp); + return LLDB_RECORD_RESULT(SBType(type_sp)); } } @@ -1816,7 +2154,7 @@ lldb::SBType SBTarget::FindFirstType(const char *typename_cstr) { if (objc_decl_vendor->FindDecls(const_typename, true, 1, decls) > 0) { if (CompilerType type = ClangASTContext::GetTypeForDecl(decls[0])) { - return SBType(type); + return LLDB_RECORD_RESULT(SBType(type)); } } } @@ -1826,24 +2164,30 @@ lldb::SBType SBTarget::FindFirstType(const char *typename_cstr) { // No matches, search for basic typename matches ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext(); if (clang_ast) - return SBType(ClangASTContext::GetBasicType(clang_ast->getASTContext(), - const_typename)); + return LLDB_RECORD_RESULT(SBType(ClangASTContext::GetBasicType( + clang_ast->getASTContext(), const_typename))); } - return SBType(); + return LLDB_RECORD_RESULT(SBType()); } SBType SBTarget::GetBasicType(lldb::BasicType type) { + LLDB_RECORD_METHOD(lldb::SBType, SBTarget, GetBasicType, (lldb::BasicType), + type); + TargetSP target_sp(GetSP()); if (target_sp) { ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext(); if (clang_ast) - return SBType( - ClangASTContext::GetBasicType(clang_ast->getASTContext(), type)); + return LLDB_RECORD_RESULT(SBType( + ClangASTContext::GetBasicType(clang_ast->getASTContext(), type))); } - return SBType(); + return LLDB_RECORD_RESULT(SBType()); } lldb::SBTypeList SBTarget::FindTypes(const char *typename_cstr) { + LLDB_RECORD_METHOD(lldb::SBTypeList, SBTarget, FindTypes, (const char *), + typename_cstr); + SBTypeList sb_type_list; TargetSP target_sp(GetSP()); if (typename_cstr && typename_cstr[0] && target_sp) { @@ -1897,11 +2241,14 @@ lldb::SBTypeList SBTarget::FindTypes(const char *typename_cstr) { clang_ast->getASTContext(), const_typename))); } } - return sb_type_list; + return LLDB_RECORD_RESULT(sb_type_list); } SBValueList SBTarget::FindGlobalVariables(const char *name, uint32_t max_matches) { + LLDB_RECORD_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables, + (const char *, uint32_t), name, max_matches); + SBValueList sb_value_list; TargetSP target_sp(GetSP()); @@ -1923,12 +2270,16 @@ SBValueList SBTarget::FindGlobalVariables(const char *name, } } - return sb_value_list; + return LLDB_RECORD_RESULT(sb_value_list); } SBValueList SBTarget::FindGlobalVariables(const char *name, uint32_t max_matches, MatchType matchtype) { + LLDB_RECORD_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables, + (const char *, uint32_t, lldb::MatchType), name, + max_matches, matchtype); + SBValueList sb_value_list; TargetSP target_sp(GetSP()); @@ -1967,29 +2318,41 @@ SBValueList SBTarget::FindGlobalVariables(const char *name, } } - return sb_value_list; + return LLDB_RECORD_RESULT(sb_value_list); } lldb::SBValue SBTarget::FindFirstGlobalVariable(const char *name) { + LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, FindFirstGlobalVariable, + (const char *), name); + SBValueList sb_value_list(FindGlobalVariables(name, 1)); if (sb_value_list.IsValid() && sb_value_list.GetSize() > 0) - return sb_value_list.GetValueAtIndex(0); - return SBValue(); + return LLDB_RECORD_RESULT(sb_value_list.GetValueAtIndex(0)); + return LLDB_RECORD_RESULT(SBValue()); } SBSourceManager SBTarget::GetSourceManager() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSourceManager, SBTarget, GetSourceManager); + SBSourceManager source_manager(*this); - return source_manager; + return LLDB_RECORD_RESULT(source_manager); } lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr, uint32_t count) { - return ReadInstructions(base_addr, count, NULL); + LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions, + (lldb::SBAddress, uint32_t), base_addr, count); + + return LLDB_RECORD_RESULT(ReadInstructions(base_addr, count, NULL)); } lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr, uint32_t count, const char *flavor_string) { + LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions, + (lldb::SBAddress, uint32_t, const char *), base_addr, + count, flavor_string); + SBInstructionList sb_instructions; TargetSP target_sp(GetSP()); @@ -2012,7 +2375,7 @@ lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr, } } - return sb_instructions; + return LLDB_RECORD_RESULT(sb_instructions); } lldb::SBInstructionList SBTarget::GetInstructions(lldb::SBAddress base_addr, @@ -2061,6 +2424,10 @@ SBTarget::GetInstructionsWithFlavor(lldb::addr_t base_addr, SBError SBTarget::SetSectionLoadAddress(lldb::SBSection section, lldb::addr_t section_base_addr) { + LLDB_RECORD_METHOD(lldb::SBError, SBTarget, SetSectionLoadAddress, + (lldb::SBSection, lldb::addr_t), section, + section_base_addr); + SBError sb_error; TargetSP target_sp(GetSP()); if (target_sp) { @@ -2091,10 +2458,13 @@ SBError SBTarget::SetSectionLoadAddress(lldb::SBSection section, } else { sb_error.SetErrorString("invalid target"); } - return sb_error; + return LLDB_RECORD_RESULT(sb_error); } SBError SBTarget::ClearSectionLoadAddress(lldb::SBSection section) { + LLDB_RECORD_METHOD(lldb::SBError, SBTarget, ClearSectionLoadAddress, + (lldb::SBSection), section); + SBError sb_error; TargetSP target_sp(GetSP()); @@ -2123,11 +2493,14 @@ SBError SBTarget::ClearSectionLoadAddress(lldb::SBSection section) { } else { sb_error.SetErrorStringWithFormat("invalid target"); } - return sb_error; + return LLDB_RECORD_RESULT(sb_error); } SBError SBTarget::SetModuleLoadAddress(lldb::SBModule module, int64_t slide_offset) { + LLDB_RECORD_METHOD(lldb::SBError, SBTarget, SetModuleLoadAddress, + (lldb::SBModule, int64_t), module, slide_offset); + SBError sb_error; TargetSP target_sp(GetSP()); @@ -2155,10 +2528,13 @@ SBError SBTarget::SetModuleLoadAddress(lldb::SBModule module, } else { sb_error.SetErrorStringWithFormat("invalid target"); } - return sb_error; + return LLDB_RECORD_RESULT(sb_error); } SBError SBTarget::ClearModuleLoadAddress(lldb::SBModule module) { + LLDB_RECORD_METHOD(lldb::SBError, SBTarget, ClearModuleLoadAddress, + (lldb::SBModule), module); + SBError sb_error; char path[PATH_MAX]; @@ -2204,11 +2580,14 @@ SBError SBTarget::ClearModuleLoadAddress(lldb::SBModule module) { } else { sb_error.SetErrorStringWithFormat("invalid target"); } - return sb_error; + return LLDB_RECORD_RESULT(sb_error); } lldb::SBSymbolContextList SBTarget::FindSymbols(const char *name, lldb::SymbolType symbol_type) { + LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindSymbols, + (const char *, lldb::SymbolType), name, symbol_type); + SBSymbolContextList sb_sc_list; if (name && name[0]) { TargetSP target_sp(GetSP()); @@ -2218,24 +2597,31 @@ lldb::SBSymbolContextList SBTarget::FindSymbols(const char *name, ConstString(name), symbol_type, *sb_sc_list, append); } } - return sb_sc_list; + return LLDB_RECORD_RESULT(sb_sc_list); } lldb::SBValue SBTarget::EvaluateExpression(const char *expr) { + LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, EvaluateExpression, + (const char *), expr); + TargetSP target_sp(GetSP()); if (!target_sp) - return SBValue(); + return LLDB_RECORD_RESULT(SBValue()); SBExpressionOptions options; lldb::DynamicValueType fetch_dynamic_value = target_sp->GetPreferDynamicValue(); options.SetFetchDynamicValue(fetch_dynamic_value); options.SetUnwindOnError(true); - return EvaluateExpression(expr, options); + return LLDB_RECORD_RESULT(EvaluateExpression(expr, options)); } lldb::SBValue SBTarget::EvaluateExpression(const char *expr, const SBExpressionOptions &options) { + LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, EvaluateExpression, + (const char *, const lldb::SBExpressionOptions &), expr, + options); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); #if !defined(LLDB_DISABLE_PYTHON) Log *expr_log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); @@ -2250,7 +2636,7 @@ lldb::SBValue SBTarget::EvaluateExpression(const char *expr, if (log) log->Printf( "SBTarget::EvaluateExpression called with an empty expression"); - return expr_result; + return LLDB_RECORD_RESULT(expr_result); } std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); @@ -2296,10 +2682,12 @@ lldb::SBValue SBTarget::EvaluateExpression(const char *expr, static_cast<void *>(expr_value_sp.get()), exe_results); #endif - return expr_result; + return LLDB_RECORD_RESULT(expr_result); } lldb::addr_t SBTarget::GetStackRedZoneSize() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBTarget, GetStackRedZoneSize); + TargetSP target_sp(GetSP()); if (target_sp) { ABISP abi_sp; @@ -2315,14 +2703,19 @@ lldb::addr_t SBTarget::GetStackRedZoneSize() { } lldb::SBLaunchInfo SBTarget::GetLaunchInfo() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBLaunchInfo, SBTarget, GetLaunchInfo); + lldb::SBLaunchInfo launch_info(NULL); TargetSP target_sp(GetSP()); if (target_sp) launch_info.set_ref(m_opaque_sp->GetProcessLaunchInfo()); - return launch_info; + return LLDB_RECORD_RESULT(launch_info); } void SBTarget::SetLaunchInfo(const lldb::SBLaunchInfo &launch_info) { + LLDB_RECORD_METHOD(void, SBTarget, SetLaunchInfo, + (const lldb::SBLaunchInfo &), launch_info); + TargetSP target_sp(GetSP()); if (target_sp) m_opaque_sp->SetProcessLaunchInfo(launch_info.ref()); diff --git a/lldb/source/API/SBThread.cpp b/lldb/source/API/SBThread.cpp index bc9652625ec..ab08bb3563f 100644 --- a/lldb/source/API/SBThread.cpp +++ b/lldb/source/API/SBThread.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBThread.h" +#include "SBReproducerPrivate.h" #include "Utils.h" #include "lldb/API/SBAddress.h" #include "lldb/API/SBDebugger.h" @@ -49,18 +50,27 @@ using namespace lldb; using namespace lldb_private; const char *SBThread::GetBroadcasterClassName() { + LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBThread, + GetBroadcasterClassName); + return Thread::GetStaticBroadcasterClass().AsCString(); } //---------------------------------------------------------------------- // Constructors //---------------------------------------------------------------------- -SBThread::SBThread() : m_opaque_sp(new ExecutionContextRef()) {} +SBThread::SBThread() : m_opaque_sp(new ExecutionContextRef()) { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBThread); +} SBThread::SBThread(const ThreadSP &lldb_object_sp) - : m_opaque_sp(new ExecutionContextRef(lldb_object_sp)) {} + : m_opaque_sp(new ExecutionContextRef(lldb_object_sp)) { + LLDB_RECORD_CONSTRUCTOR(SBThread, (const lldb::ThreadSP &), lldb_object_sp); +} SBThread::SBThread(const SBThread &rhs) : m_opaque_sp() { + LLDB_RECORD_CONSTRUCTOR(SBThread, (const lldb::SBThread &), rhs); + m_opaque_sp = clone(rhs.m_opaque_sp); } @@ -69,6 +79,9 @@ SBThread::SBThread(const SBThread &rhs) : m_opaque_sp() { //---------------------------------------------------------------------- const lldb::SBThread &SBThread::operator=(const SBThread &rhs) { + LLDB_RECORD_METHOD(const lldb::SBThread &, + SBThread, operator=,(const lldb::SBThread &), rhs); + if (this != &rhs) m_opaque_sp = clone(rhs.m_opaque_sp); return *this; @@ -80,6 +93,8 @@ const lldb::SBThread &SBThread::operator=(const SBThread &rhs) { SBThread::~SBThread() {} lldb::SBQueue SBThread::GetQueue() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBQueue, SBThread, GetQueue); + SBQueue sb_queue; QueueSP queue_sp; std::unique_lock<std::recursive_mutex> lock; @@ -105,10 +120,12 @@ lldb::SBQueue SBThread::GetQueue() const { static_cast<void *>(exe_ctx.GetThreadPtr()), static_cast<void *>(queue_sp.get())); - return sb_queue; + return LLDB_RECORD_RESULT(sb_queue); } bool SBThread::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThread, IsValid); + std::unique_lock<std::recursive_mutex> lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -123,9 +140,15 @@ bool SBThread::IsValid() const { return false; } -void SBThread::Clear() { m_opaque_sp->Clear(); } +void SBThread::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBThread, Clear); + + m_opaque_sp->Clear(); +} StopReason SBThread::GetStopReason() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::StopReason, SBThread, GetStopReason); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); StopReason reason = eStopReasonInvalid; @@ -153,6 +176,8 @@ StopReason SBThread::GetStopReason() { } size_t SBThread::GetStopReasonDataCount() { + LLDB_RECORD_METHOD_NO_ARGS(size_t, SBThread, GetStopReasonDataCount); + std::unique_lock<std::recursive_mutex> lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -206,6 +231,9 @@ size_t SBThread::GetStopReasonDataCount() { } uint64_t SBThread::GetStopReasonDataAtIndex(uint32_t idx) { + LLDB_RECORD_METHOD(uint64_t, SBThread, GetStopReasonDataAtIndex, (uint32_t), + idx); + std::unique_lock<std::recursive_mutex> lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -271,6 +299,9 @@ uint64_t SBThread::GetStopReasonDataAtIndex(uint32_t idx) { } bool SBThread::GetStopReasonExtendedInfoAsJSON(lldb::SBStream &stream) { + LLDB_RECORD_METHOD(bool, SBThread, GetStopReasonExtendedInfoAsJSON, + (lldb::SBStream &), stream); + Stream &strm = stream.ref(); std::unique_lock<std::recursive_mutex> lock; @@ -291,6 +322,10 @@ bool SBThread::GetStopReasonExtendedInfoAsJSON(lldb::SBStream &stream) { SBThreadCollection SBThread::GetStopReasonExtendedBacktraces(InstrumentationRuntimeType type) { + LLDB_RECORD_METHOD(lldb::SBThreadCollection, SBThread, + GetStopReasonExtendedBacktraces, + (lldb::InstrumentationRuntimeType), type); + ThreadCollectionSP threads; threads = std::make_shared<ThreadCollection>(); @@ -298,20 +333,23 @@ SBThread::GetStopReasonExtendedBacktraces(InstrumentationRuntimeType type) { ExecutionContext exe_ctx(m_opaque_sp.get(), lock); if (!exe_ctx.HasThreadScope()) - return threads; + return LLDB_RECORD_RESULT(threads); ProcessSP process_sp = exe_ctx.GetProcessSP(); StopInfoSP stop_info = exe_ctx.GetThreadPtr()->GetStopInfo(); StructuredData::ObjectSP info = stop_info->GetExtendedInfo(); if (!info) - return threads; + return LLDB_RECORD_RESULT(threads); - return process_sp->GetInstrumentationRuntime(type) - ->GetBacktracesFromExtendedStopInfo(info); + return LLDB_RECORD_RESULT(process_sp->GetInstrumentationRuntime(type) + ->GetBacktracesFromExtendedStopInfo(info)); } size_t SBThread::GetStopDescription(char *dst, size_t dst_len) { + LLDB_RECORD_METHOD(size_t, SBThread, GetStopDescription, (char *, size_t), + dst, dst_len); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); std::unique_lock<std::recursive_mutex> lock; @@ -423,6 +461,8 @@ size_t SBThread::GetStopDescription(char *dst, size_t dst_len) { } SBValue SBThread::GetStopReturnValue() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBThread, GetStopReturnValue); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); ValueObjectSP return_valobj_sp; std::unique_lock<std::recursive_mutex> lock; @@ -449,7 +489,7 @@ SBValue SBThread::GetStopReturnValue() { return_valobj_sp.get() ? return_valobj_sp->GetValueAsCString() : "<no return value>"); - return SBValue(return_valobj_sp); + return LLDB_RECORD_RESULT(SBValue(return_valobj_sp)); } void SBThread::SetThread(const ThreadSP &lldb_object_sp) { @@ -457,6 +497,8 @@ void SBThread::SetThread(const ThreadSP &lldb_object_sp) { } lldb::tid_t SBThread::GetThreadID() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::tid_t, SBThread, GetThreadID); + ThreadSP thread_sp(m_opaque_sp->GetThreadSP()); if (thread_sp) return thread_sp->GetID(); @@ -464,6 +506,8 @@ lldb::tid_t SBThread::GetThreadID() const { } uint32_t SBThread::GetIndexID() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBThread, GetIndexID); + ThreadSP thread_sp(m_opaque_sp->GetThreadSP()); if (thread_sp) return thread_sp->GetIndexID(); @@ -471,6 +515,8 @@ uint32_t SBThread::GetIndexID() const { } const char *SBThread::GetName() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBThread, GetName); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); const char *name = NULL; std::unique_lock<std::recursive_mutex> lock; @@ -496,6 +542,8 @@ const char *SBThread::GetName() const { } const char *SBThread::GetQueueName() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBThread, GetQueueName); + const char *name = NULL; std::unique_lock<std::recursive_mutex> lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -521,6 +569,8 @@ const char *SBThread::GetQueueName() const { } lldb::queue_id_t SBThread::GetQueueID() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::queue_id_t, SBThread, GetQueueID); + queue_id_t id = LLDB_INVALID_QUEUE_ID; std::unique_lock<std::recursive_mutex> lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -545,6 +595,9 @@ lldb::queue_id_t SBThread::GetQueueID() const { } bool SBThread::GetInfoItemByPathAsString(const char *path, SBStream &strm) { + LLDB_RECORD_METHOD(bool, SBThread, GetInfoItemByPathAsString, + (const char *, lldb::SBStream &), path, strm); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); bool success = false; std::unique_lock<std::recursive_mutex> lock; @@ -634,11 +687,17 @@ SBError SBThread::ResumeNewPlan(ExecutionContext &exe_ctx, } void SBThread::StepOver(lldb::RunMode stop_other_threads) { + LLDB_RECORD_METHOD(void, SBThread, StepOver, (lldb::RunMode), + stop_other_threads); + SBError error; // Ignored StepOver(stop_other_threads, error); } void SBThread::StepOver(lldb::RunMode stop_other_threads, SBError &error) { + LLDB_RECORD_METHOD(void, SBThread, StepOver, (lldb::RunMode, lldb::SBError &), + stop_other_threads, error); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); std::unique_lock<std::recursive_mutex> lock; @@ -676,17 +735,27 @@ void SBThread::StepOver(lldb::RunMode stop_other_threads, SBError &error) { } void SBThread::StepInto(lldb::RunMode stop_other_threads) { + LLDB_RECORD_METHOD(void, SBThread, StepInto, (lldb::RunMode), + stop_other_threads); + StepInto(NULL, stop_other_threads); } void SBThread::StepInto(const char *target_name, lldb::RunMode stop_other_threads) { + LLDB_RECORD_METHOD(void, SBThread, StepInto, (const char *, lldb::RunMode), + target_name, stop_other_threads); + SBError error; // Ignored StepInto(target_name, LLDB_INVALID_LINE_NUMBER, error, stop_other_threads); } void SBThread::StepInto(const char *target_name, uint32_t end_line, SBError &error, lldb::RunMode stop_other_threads) { + LLDB_RECORD_METHOD(void, SBThread, StepInto, + (const char *, uint32_t, lldb::SBError &, lldb::RunMode), + target_name, end_line, error, stop_other_threads); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); std::unique_lock<std::recursive_mutex> lock; @@ -741,11 +810,15 @@ void SBThread::StepInto(const char *target_name, uint32_t end_line, } void SBThread::StepOut() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBThread, StepOut); + SBError error; // Ignored StepOut(error); } void SBThread::StepOut(SBError &error) { + LLDB_RECORD_METHOD(void, SBThread, StepOut, (lldb::SBError &), error); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); std::unique_lock<std::recursive_mutex> lock; @@ -778,11 +851,17 @@ void SBThread::StepOut(SBError &error) { } void SBThread::StepOutOfFrame(SBFrame &sb_frame) { + LLDB_RECORD_METHOD(void, SBThread, StepOutOfFrame, (lldb::SBFrame &), + sb_frame); + SBError error; // Ignored StepOutOfFrame(sb_frame, error); } void SBThread::StepOutOfFrame(SBFrame &sb_frame, SBError &error) { + LLDB_RECORD_METHOD(void, SBThread, StepOutOfFrame, + (lldb::SBFrame &, lldb::SBError &), sb_frame, error); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); std::unique_lock<std::recursive_mutex> lock; @@ -835,11 +914,16 @@ void SBThread::StepOutOfFrame(SBFrame &sb_frame, SBError &error) { } void SBThread::StepInstruction(bool step_over) { + LLDB_RECORD_METHOD(void, SBThread, StepInstruction, (bool), step_over); + SBError error; // Ignored StepInstruction(step_over, error); } void SBThread::StepInstruction(bool step_over, SBError &error) { + LLDB_RECORD_METHOD(void, SBThread, StepInstruction, (bool, lldb::SBError &), + step_over, error); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); std::unique_lock<std::recursive_mutex> lock; @@ -866,11 +950,16 @@ void SBThread::StepInstruction(bool step_over, SBError &error) { } void SBThread::RunToAddress(lldb::addr_t addr) { + LLDB_RECORD_METHOD(void, SBThread, RunToAddress, (lldb::addr_t), addr); + SBError error; // Ignored RunToAddress(addr, error); } void SBThread::RunToAddress(lldb::addr_t addr, SBError &error) { + LLDB_RECORD_METHOD(void, SBThread, RunToAddress, + (lldb::addr_t, lldb::SBError &), addr, error); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); std::unique_lock<std::recursive_mutex> lock; @@ -904,6 +993,10 @@ void SBThread::RunToAddress(lldb::addr_t addr, SBError &error) { SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame, lldb::SBFileSpec &sb_file_spec, uint32_t line) { + LLDB_RECORD_METHOD(lldb::SBError, SBThread, StepOverUntil, + (lldb::SBFrame &, lldb::SBFileSpec &, uint32_t), sb_frame, + sb_file_spec, line); + SBError sb_error; Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); char path[PATH_MAX]; @@ -930,7 +1023,7 @@ SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame, if (line == 0) { sb_error.SetErrorString("invalid line argument"); - return sb_error; + return LLDB_RECORD_RESULT(sb_error); } if (!frame_sp) { @@ -942,7 +1035,7 @@ SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame, SymbolContext frame_sc; if (!frame_sp) { sb_error.SetErrorString("no valid frames in thread to step"); - return sb_error; + return LLDB_RECORD_RESULT(sb_error); } // If we have a frame, get its line @@ -953,7 +1046,7 @@ SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame, if (frame_sc.comp_unit == NULL) { sb_error.SetErrorStringWithFormat( "frame %u doesn't have debug information", frame_sp->GetFrameIndex()); - return sb_error; + return LLDB_RECORD_RESULT(sb_error); } FileSpec step_file_spec; @@ -965,7 +1058,7 @@ SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame, step_file_spec = frame_sc.line_entry.file; else { sb_error.SetErrorString("invalid file argument or no file for frame"); - return sb_error; + return LLDB_RECORD_RESULT(sb_error); } } @@ -1025,15 +1118,23 @@ SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame, } else { sb_error.SetErrorString("this SBThread object is invalid"); } - return sb_error; + return LLDB_RECORD_RESULT(sb_error); } SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name) { - return StepUsingScriptedThreadPlan(script_class_name, true); + LLDB_RECORD_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan, + (const char *), script_class_name); + + return LLDB_RECORD_RESULT( + StepUsingScriptedThreadPlan(script_class_name, true)); } SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name, bool resume_immediately) { + LLDB_RECORD_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan, + (const char *, bool), script_class_name, + resume_immediately); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBError error; @@ -1047,7 +1148,7 @@ SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name, if (!exe_ctx.HasThreadScope()) { error.SetErrorString("this SBThread object is invalid"); - return error; + return LLDB_RECORD_RESULT(error); } Thread *thread = exe_ctx.GetThreadPtr(); @@ -1057,21 +1158,24 @@ SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name, if (new_plan_status.Fail()) { error.SetErrorString(new_plan_status.AsCString()); - return error; + return LLDB_RECORD_RESULT(error); } if (!resume_immediately) - return error; + return LLDB_RECORD_RESULT(error); if (new_plan_status.Success()) error = ResumeNewPlan(exe_ctx, new_plan_sp.get()); else error.SetErrorString(new_plan_status.AsCString()); - return error; + return LLDB_RECORD_RESULT(error); } SBError SBThread::JumpToLine(lldb::SBFileSpec &file_spec, uint32_t line) { + LLDB_RECORD_METHOD(lldb::SBError, SBThread, JumpToLine, + (lldb::SBFileSpec &, uint32_t), file_spec, line); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBError sb_error; @@ -1085,17 +1189,20 @@ SBError SBThread::JumpToLine(lldb::SBFileSpec &file_spec, uint32_t line) { if (!exe_ctx.HasThreadScope()) { sb_error.SetErrorString("this SBThread object is invalid"); - return sb_error; + return LLDB_RECORD_RESULT(sb_error); } Thread *thread = exe_ctx.GetThreadPtr(); Status err = thread->JumpToLine(file_spec.get(), line, true); sb_error.SetError(err); - return sb_error; + return LLDB_RECORD_RESULT(sb_error); } SBError SBThread::ReturnFromFrame(SBFrame &frame, SBValue &return_value) { + LLDB_RECORD_METHOD(lldb::SBError, SBThread, ReturnFromFrame, + (lldb::SBFrame &, lldb::SBValue &), frame, return_value); + SBError sb_error; Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); @@ -1114,10 +1221,13 @@ SBError SBThread::ReturnFromFrame(SBFrame &frame, SBValue &return_value) { thread->ReturnFromFrame(frame.GetFrameSP(), return_value.GetSP())); } - return sb_error; + return LLDB_RECORD_RESULT(sb_error); } SBError SBThread::UnwindInnermostExpression() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBThread, + UnwindInnermostExpression); + SBError sb_error; Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); @@ -1136,15 +1246,19 @@ SBError SBThread::UnwindInnermostExpression() { thread->SetSelectedFrameByIndex(0, false); } - return sb_error; + return LLDB_RECORD_RESULT(sb_error); } bool SBThread::Suspend() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, Suspend); + SBError error; // Ignored return Suspend(error); } bool SBThread::Suspend(SBError &error) { + LLDB_RECORD_METHOD(bool, SBThread, Suspend, (lldb::SBError &), error); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); std::unique_lock<std::recursive_mutex> lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -1170,11 +1284,15 @@ bool SBThread::Suspend(SBError &error) { } bool SBThread::Resume() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, Resume); + SBError error; // Ignored return Resume(error); } bool SBThread::Resume(SBError &error) { + LLDB_RECORD_METHOD(bool, SBThread, Resume, (lldb::SBError &), error); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); std::unique_lock<std::recursive_mutex> lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -1201,6 +1319,8 @@ bool SBThread::Resume(SBError &error) { } bool SBThread::IsSuspended() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, IsSuspended); + std::unique_lock<std::recursive_mutex> lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -1210,6 +1330,8 @@ bool SBThread::IsSuspended() { } bool SBThread::IsStopped() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, IsStopped); + std::unique_lock<std::recursive_mutex> lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -1219,6 +1341,8 @@ bool SBThread::IsStopped() { } SBProcess SBThread::GetProcess() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBThread, GetProcess); + SBProcess sb_process; std::unique_lock<std::recursive_mutex> lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -1239,10 +1363,12 @@ SBProcess SBThread::GetProcess() { frame_desc_strm.GetData()); } - return sb_process; + return LLDB_RECORD_RESULT(sb_process); } uint32_t SBThread::GetNumFrames() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBThread, GetNumFrames); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); uint32_t num_frames = 0; @@ -1268,6 +1394,8 @@ uint32_t SBThread::GetNumFrames() { } SBFrame SBThread::GetFrameAtIndex(uint32_t idx) { + LLDB_RECORD_METHOD(lldb::SBFrame, SBThread, GetFrameAtIndex, (uint32_t), idx); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBFrame sb_frame; @@ -1296,10 +1424,12 @@ SBFrame SBThread::GetFrameAtIndex(uint32_t idx) { static_cast<void *>(frame_sp.get()), frame_desc_strm.GetData()); } - return sb_frame; + return LLDB_RECORD_RESULT(sb_frame); } lldb::SBFrame SBThread::GetSelectedFrame() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFrame, SBThread, GetSelectedFrame); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBFrame sb_frame; @@ -1328,10 +1458,13 @@ lldb::SBFrame SBThread::GetSelectedFrame() { static_cast<void *>(frame_sp.get()), frame_desc_strm.GetData()); } - return sb_frame; + return LLDB_RECORD_RESULT(sb_frame); } lldb::SBFrame SBThread::SetSelectedFrame(uint32_t idx) { + LLDB_RECORD_METHOD(lldb::SBFrame, SBThread, SetSelectedFrame, (uint32_t), + idx); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBFrame sb_frame; @@ -1363,32 +1496,52 @@ lldb::SBFrame SBThread::SetSelectedFrame(uint32_t idx) { static_cast<void *>(exe_ctx.GetThreadPtr()), idx, static_cast<void *>(frame_sp.get()), frame_desc_strm.GetData()); } - return sb_frame; + return LLDB_RECORD_RESULT(sb_frame); } bool SBThread::EventIsThreadEvent(const SBEvent &event) { + LLDB_RECORD_STATIC_METHOD(bool, SBThread, EventIsThreadEvent, + (const lldb::SBEvent &), event); + return Thread::ThreadEventData::GetEventDataFromEvent(event.get()) != NULL; } SBFrame SBThread::GetStackFrameFromEvent(const SBEvent &event) { - return Thread::ThreadEventData::GetStackFrameFromEvent(event.get()); + LLDB_RECORD_STATIC_METHOD(lldb::SBFrame, SBThread, GetStackFrameFromEvent, + (const lldb::SBEvent &), event); + + return LLDB_RECORD_RESULT( + Thread::ThreadEventData::GetStackFrameFromEvent(event.get())); } SBThread SBThread::GetThreadFromEvent(const SBEvent &event) { - return Thread::ThreadEventData::GetThreadFromEvent(event.get()); + LLDB_RECORD_STATIC_METHOD(lldb::SBThread, SBThread, GetThreadFromEvent, + (const lldb::SBEvent &), event); + + return LLDB_RECORD_RESULT( + Thread::ThreadEventData::GetThreadFromEvent(event.get())); } bool SBThread::operator==(const SBThread &rhs) const { + LLDB_RECORD_METHOD_CONST(bool, SBThread, operator==,(const lldb::SBThread &), + rhs); + return m_opaque_sp->GetThreadSP().get() == rhs.m_opaque_sp->GetThreadSP().get(); } bool SBThread::operator!=(const SBThread &rhs) const { + LLDB_RECORD_METHOD_CONST(bool, SBThread, operator!=,(const lldb::SBThread &), + rhs); + return m_opaque_sp->GetThreadSP().get() != rhs.m_opaque_sp->GetThreadSP().get(); } bool SBThread::GetStatus(SBStream &status) const { + LLDB_RECORD_METHOD_CONST(bool, SBThread, GetStatus, (lldb::SBStream &), + status); + Stream &strm = status.ref(); std::unique_lock<std::recursive_mutex> lock; @@ -1403,10 +1556,16 @@ bool SBThread::GetStatus(SBStream &status) const { } bool SBThread::GetDescription(SBStream &description) const { - return GetDescription(description, false); + LLDB_RECORD_METHOD_CONST(bool, SBThread, GetDescription, (lldb::SBStream &), + description); + + return GetDescription(description, false); } bool SBThread::GetDescription(SBStream &description, bool stop_format) const { + LLDB_RECORD_METHOD_CONST(bool, SBThread, GetDescription, + (lldb::SBStream &, bool), description, stop_format); + Stream &strm = description.ref(); std::unique_lock<std::recursive_mutex> lock; @@ -1425,6 +1584,9 @@ bool SBThread::GetDescription(SBStream &description, bool stop_format) const { } SBThread SBThread::GetExtendedBacktraceThread(const char *type) { + LLDB_RECORD_METHOD(lldb::SBThread, SBThread, GetExtendedBacktraceThread, + (const char *), type); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); std::unique_lock<std::recursive_mutex> lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -1475,10 +1637,13 @@ SBThread SBThread::GetExtendedBacktraceThread(const char *type) { log->Printf("SBThread(%p)::GetExtendedBacktraceThread() is not returning a " "Valid thread", static_cast<void *>(exe_ctx.GetThreadPtr())); - return sb_origin_thread; + return LLDB_RECORD_RESULT(sb_origin_thread); } uint32_t SBThread::GetExtendedBacktraceOriginatingIndexID() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBThread, + GetExtendedBacktraceOriginatingIndexID); + ThreadSP thread_sp(m_opaque_sp->GetThreadSP()); if (thread_sp) return thread_sp->GetExtendedBacktraceOriginatingIndexID(); @@ -1486,20 +1651,30 @@ uint32_t SBThread::GetExtendedBacktraceOriginatingIndexID() { } SBValue SBThread::GetCurrentException() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBThread, GetCurrentException); + ThreadSP thread_sp(m_opaque_sp->GetThreadSP()); - if (!thread_sp) return SBValue(); + if (!thread_sp) + return LLDB_RECORD_RESULT(SBValue()); - return SBValue(thread_sp->GetCurrentException()); + return LLDB_RECORD_RESULT(SBValue(thread_sp->GetCurrentException())); } SBThread SBThread::GetCurrentExceptionBacktrace() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBThread, SBThread, + GetCurrentExceptionBacktrace); + ThreadSP thread_sp(m_opaque_sp->GetThreadSP()); - if (!thread_sp) return SBThread(); + if (!thread_sp) + return LLDB_RECORD_RESULT(SBThread()); - return SBThread(thread_sp->GetCurrentExceptionBacktrace()); + return LLDB_RECORD_RESULT( + SBThread(thread_sp->GetCurrentExceptionBacktrace())); } bool SBThread::SafeToCallFunctions() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, SafeToCallFunctions); + ThreadSP thread_sp(m_opaque_sp->GetThreadSP()); if (thread_sp) return thread_sp->SafeToCallFunctions(); @@ -1507,6 +1682,8 @@ bool SBThread::SafeToCallFunctions() { } lldb_private::Thread *SBThread::operator->() { + LLDB_RECORD_METHOD_NO_ARGS(lldb_private::Thread *, SBThread, operator->); + ThreadSP thread_sp(m_opaque_sp->GetThreadSP()); if (thread_sp) return thread_sp.get(); @@ -1515,6 +1692,8 @@ lldb_private::Thread *SBThread::operator->() { } lldb_private::Thread *SBThread::get() { + LLDB_RECORD_METHOD_NO_ARGS(lldb_private::Thread *, SBThread, get); + ThreadSP thread_sp(m_opaque_sp->GetThreadSP()); if (thread_sp) return thread_sp.get(); diff --git a/lldb/source/API/SBThreadCollection.cpp b/lldb/source/API/SBThreadCollection.cpp index 360e5a0e953..b9c1e755468 100644 --- a/lldb/source/API/SBThreadCollection.cpp +++ b/lldb/source/API/SBThreadCollection.cpp @@ -7,19 +7,29 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBThreadCollection.h" +#include "SBReproducerPrivate.h" #include "lldb/API/SBThread.h" #include "lldb/Target/ThreadList.h" using namespace lldb; using namespace lldb_private; -SBThreadCollection::SBThreadCollection() : m_opaque_sp() {} +SBThreadCollection::SBThreadCollection() : m_opaque_sp() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBThreadCollection); +} SBThreadCollection::SBThreadCollection(const SBThreadCollection &rhs) - : m_opaque_sp(rhs.m_opaque_sp) {} + : m_opaque_sp(rhs.m_opaque_sp) { + LLDB_RECORD_CONSTRUCTOR(SBThreadCollection, + (const lldb::SBThreadCollection &), rhs); +} const SBThreadCollection &SBThreadCollection:: operator=(const SBThreadCollection &rhs) { + LLDB_RECORD_METHOD( + const lldb::SBThreadCollection &, + SBThreadCollection, operator=,(const lldb::SBThreadCollection &), rhs); + if (this != &rhs) m_opaque_sp = rhs.m_opaque_sp; return *this; @@ -50,17 +60,26 @@ const lldb::ThreadCollectionSP &SBThreadCollection::operator*() const { return m_opaque_sp; } -bool SBThreadCollection::IsValid() const { return m_opaque_sp.get() != NULL; } +bool SBThreadCollection::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadCollection, IsValid); + + return m_opaque_sp.get() != NULL; +} size_t SBThreadCollection::GetSize() { + LLDB_RECORD_METHOD_NO_ARGS(size_t, SBThreadCollection, GetSize); + if (m_opaque_sp) return m_opaque_sp->GetSize(); return 0; } SBThread SBThreadCollection::GetThreadAtIndex(size_t idx) { + LLDB_RECORD_METHOD(lldb::SBThread, SBThreadCollection, GetThreadAtIndex, + (size_t), idx); + SBThread thread; if (m_opaque_sp && idx < m_opaque_sp->GetSize()) thread = m_opaque_sp->GetThreadAtIndex(idx); - return thread; + return LLDB_RECORD_RESULT(thread); } diff --git a/lldb/source/API/SBThreadPlan.cpp b/lldb/source/API/SBThreadPlan.cpp index cca06df828e..f8646fcd6e1 100644 --- a/lldb/source/API/SBThreadPlan.cpp +++ b/lldb/source/API/SBThreadPlan.cpp @@ -6,6 +6,7 @@ // //===----------------------------------------------------------------------===// +#include "SBReproducerPrivate.h" #include "lldb/API/SBThread.h" #include "lldb/API/SBFileSpec.h" @@ -49,15 +50,23 @@ using namespace lldb_private; //---------------------------------------------------------------------- // Constructors //---------------------------------------------------------------------- -SBThreadPlan::SBThreadPlan() {} +SBThreadPlan::SBThreadPlan() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBThreadPlan); } SBThreadPlan::SBThreadPlan(const ThreadPlanSP &lldb_object_sp) - : m_opaque_sp(lldb_object_sp) {} + : m_opaque_sp(lldb_object_sp) { + LLDB_RECORD_CONSTRUCTOR(SBThreadPlan, (const lldb::ThreadPlanSP &), + lldb_object_sp); +} SBThreadPlan::SBThreadPlan(const SBThreadPlan &rhs) - : m_opaque_sp(rhs.m_opaque_sp) {} + : m_opaque_sp(rhs.m_opaque_sp) { + LLDB_RECORD_CONSTRUCTOR(SBThreadPlan, (const lldb::SBThreadPlan &), rhs); +} SBThreadPlan::SBThreadPlan(lldb::SBThread &sb_thread, const char *class_name) { + LLDB_RECORD_CONSTRUCTOR(SBThreadPlan, (lldb::SBThread &, const char *), + sb_thread, class_name); + Thread *thread = sb_thread.get(); if (thread) m_opaque_sp = std::make_shared<ThreadPlanPython>(*thread, class_name); @@ -68,6 +77,9 @@ SBThreadPlan::SBThreadPlan(lldb::SBThread &sb_thread, const char *class_name) { //---------------------------------------------------------------------- const lldb::SBThreadPlan &SBThreadPlan::operator=(const SBThreadPlan &rhs) { + LLDB_RECORD_METHOD(const lldb::SBThreadPlan &, + SBThreadPlan, operator=,(const lldb::SBThreadPlan &), rhs); + if (this != &rhs) m_opaque_sp = rhs.m_opaque_sp; return *this; @@ -77,26 +89,57 @@ const lldb::SBThreadPlan &SBThreadPlan::operator=(const SBThreadPlan &rhs) { //---------------------------------------------------------------------- SBThreadPlan::~SBThreadPlan() {} -lldb_private::ThreadPlan *SBThreadPlan::get() { return m_opaque_sp.get(); } +lldb_private::ThreadPlan *SBThreadPlan::get() { + LLDB_RECORD_METHOD_NO_ARGS(lldb_private::ThreadPlan *, SBThreadPlan, get); + + return m_opaque_sp.get(); +} + +bool SBThreadPlan::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadPlan, IsValid); + + return m_opaque_sp.get() != NULL; +} + +void SBThreadPlan::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBThreadPlan, Clear); + + m_opaque_sp.reset(); +} -bool SBThreadPlan::IsValid() const { return m_opaque_sp.get() != NULL; } +lldb::StopReason SBThreadPlan::GetStopReason() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::StopReason, SBThreadPlan, GetStopReason); -void SBThreadPlan::Clear() { m_opaque_sp.reset(); } + return eStopReasonNone; +} + +size_t SBThreadPlan::GetStopReasonDataCount() { + LLDB_RECORD_METHOD_NO_ARGS(size_t, SBThreadPlan, GetStopReasonDataCount); -lldb::StopReason SBThreadPlan::GetStopReason() { return eStopReasonNone; } + return 0; +} -size_t SBThreadPlan::GetStopReasonDataCount() { return 0; } +uint64_t SBThreadPlan::GetStopReasonDataAtIndex(uint32_t idx) { + LLDB_RECORD_METHOD(uint64_t, SBThreadPlan, GetStopReasonDataAtIndex, + (uint32_t), idx); -uint64_t SBThreadPlan::GetStopReasonDataAtIndex(uint32_t idx) { return 0; } + return 0; +} SBThread SBThreadPlan::GetThread() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBThreadPlan, GetThread); + if (m_opaque_sp) { - return SBThread(m_opaque_sp->GetThread().shared_from_this()); + return LLDB_RECORD_RESULT( + SBThread(m_opaque_sp->GetThread().shared_from_this())); } else - return SBThread(); + return LLDB_RECORD_RESULT(SBThread()); } bool SBThreadPlan::GetDescription(lldb::SBStream &description) const { + LLDB_RECORD_METHOD_CONST(bool, SBThreadPlan, GetDescription, + (lldb::SBStream &), description); + if (m_opaque_sp) { m_opaque_sp->GetDescription(description.get(), eDescriptionLevelFull); } else { @@ -110,11 +153,15 @@ void SBThreadPlan::SetThreadPlan(const ThreadPlanSP &lldb_object_sp) { } void SBThreadPlan::SetPlanComplete(bool success) { + LLDB_RECORD_METHOD(void, SBThreadPlan, SetPlanComplete, (bool), success); + if (m_opaque_sp) m_opaque_sp->SetPlanComplete(success); } bool SBThreadPlan::IsPlanComplete() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, IsPlanComplete); + if (m_opaque_sp) return m_opaque_sp->IsPlanComplete(); else @@ -122,6 +169,8 @@ bool SBThreadPlan::IsPlanComplete() { } bool SBThreadPlan::IsPlanStale() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, IsPlanStale); + if (m_opaque_sp) return m_opaque_sp->IsPlanStale(); else @@ -129,6 +178,8 @@ bool SBThreadPlan::IsPlanStale() { } bool SBThreadPlan::IsValid() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, IsValid); + if (m_opaque_sp) return m_opaque_sp->ValidatePlan(nullptr); else @@ -144,16 +195,26 @@ bool SBThreadPlan::IsValid() { SBThreadPlan SBThreadPlan::QueueThreadPlanForStepOverRange(SBAddress &sb_start_address, lldb::addr_t size) { + LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForStepOverRange, + (lldb::SBAddress &, lldb::addr_t), sb_start_address, size); + SBError error; - return QueueThreadPlanForStepOverRange(sb_start_address, size, error); + return LLDB_RECORD_RESULT( + QueueThreadPlanForStepOverRange(sb_start_address, size, error)); } SBThreadPlan SBThreadPlan::QueueThreadPlanForStepOverRange( SBAddress &sb_start_address, lldb::addr_t size, SBError &error) { + LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForStepOverRange, + (lldb::SBAddress &, lldb::addr_t, lldb::SBError &), + sb_start_address, size, error); + if (m_opaque_sp) { Address *start_address = sb_start_address.get(); if (!start_address) { - return SBThreadPlan(); + return LLDB_RECORD_RESULT(SBThreadPlan()); } AddressRange range(*start_address, size); @@ -168,26 +229,36 @@ SBThreadPlan SBThreadPlan::QueueThreadPlanForStepOverRange( if (plan_status.Fail()) error.SetErrorString(plan_status.AsCString()); - return plan; + return LLDB_RECORD_RESULT(plan); } else { - return SBThreadPlan(); + return LLDB_RECORD_RESULT(SBThreadPlan()); } } SBThreadPlan SBThreadPlan::QueueThreadPlanForStepInRange(SBAddress &sb_start_address, lldb::addr_t size) { + LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForStepInRange, + (lldb::SBAddress &, lldb::addr_t), sb_start_address, size); + SBError error; - return QueueThreadPlanForStepInRange(sb_start_address, size, error); + return LLDB_RECORD_RESULT( + QueueThreadPlanForStepInRange(sb_start_address, size, error)); } SBThreadPlan SBThreadPlan::QueueThreadPlanForStepInRange(SBAddress &sb_start_address, lldb::addr_t size, SBError &error) { + LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForStepInRange, + (lldb::SBAddress &, lldb::addr_t, lldb::SBError &), + sb_start_address, size, error); + if (m_opaque_sp) { Address *start_address = sb_start_address.get(); if (!start_address) { - return SBThreadPlan(); + return LLDB_RECORD_RESULT(SBThreadPlan()); } AddressRange range(*start_address, size); @@ -202,22 +273,32 @@ SBThreadPlan::QueueThreadPlanForStepInRange(SBAddress &sb_start_address, if (plan_status.Fail()) error.SetErrorString(plan_status.AsCString()); - return plan; + return LLDB_RECORD_RESULT(plan); } else { - return SBThreadPlan(); + return LLDB_RECORD_RESULT(SBThreadPlan()); } } SBThreadPlan SBThreadPlan::QueueThreadPlanForStepOut(uint32_t frame_idx_to_step_to, bool first_insn) { + LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForStepOut, (uint32_t, bool), + frame_idx_to_step_to, first_insn); + SBError error; - return QueueThreadPlanForStepOut(frame_idx_to_step_to, first_insn, error); + return LLDB_RECORD_RESULT( + QueueThreadPlanForStepOut(frame_idx_to_step_to, first_insn, error)); } SBThreadPlan SBThreadPlan::QueueThreadPlanForStepOut(uint32_t frame_idx_to_step_to, bool first_insn, SBError &error) { + LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForStepOut, + (uint32_t, bool, lldb::SBError &), frame_idx_to_step_to, + first_insn, error); + if (m_opaque_sp) { SymbolContext sc; sc = m_opaque_sp->GetThread().GetStackFrameAtIndex(0)->GetSymbolContext( @@ -232,24 +313,32 @@ SBThreadPlan::QueueThreadPlanForStepOut(uint32_t frame_idx_to_step_to, if (plan_status.Fail()) error.SetErrorString(plan_status.AsCString()); - return plan; + return LLDB_RECORD_RESULT(plan); } else { - return SBThreadPlan(); + return LLDB_RECORD_RESULT(SBThreadPlan()); } } SBThreadPlan SBThreadPlan::QueueThreadPlanForRunToAddress(SBAddress sb_address) { + LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForRunToAddress, (lldb::SBAddress), + sb_address); + SBError error; - return QueueThreadPlanForRunToAddress(sb_address, error); + return LLDB_RECORD_RESULT(QueueThreadPlanForRunToAddress(sb_address, error)); } SBThreadPlan SBThreadPlan::QueueThreadPlanForRunToAddress(SBAddress sb_address, SBError &error) { + LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForRunToAddress, + (lldb::SBAddress, lldb::SBError &), sb_address, error); + if (m_opaque_sp) { Address *address = sb_address.get(); if (!address) - return SBThreadPlan(); + return LLDB_RECORD_RESULT(SBThreadPlan()); Status plan_status; SBThreadPlan plan = @@ -259,21 +348,30 @@ SBThreadPlan SBThreadPlan::QueueThreadPlanForRunToAddress(SBAddress sb_address, if (plan_status.Fail()) error.SetErrorString(plan_status.AsCString()); - return plan; + return LLDB_RECORD_RESULT(plan); } else { - return SBThreadPlan(); + return LLDB_RECORD_RESULT(SBThreadPlan()); } } SBThreadPlan SBThreadPlan::QueueThreadPlanForStepScripted(const char *script_class_name) { + LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForStepScripted, (const char *), + script_class_name); + SBError error; - return QueueThreadPlanForStepScripted(script_class_name, error); + return LLDB_RECORD_RESULT( + QueueThreadPlanForStepScripted(script_class_name, error)); } SBThreadPlan SBThreadPlan::QueueThreadPlanForStepScripted(const char *script_class_name, SBError &error) { + LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForStepScripted, + (const char *, lldb::SBError &), script_class_name, error); + if (m_opaque_sp) { Status plan_status; SBThreadPlan plan = @@ -283,8 +381,8 @@ SBThreadPlan::QueueThreadPlanForStepScripted(const char *script_class_name, if (plan_status.Fail()) error.SetErrorString(plan_status.AsCString()); - return plan; + return LLDB_RECORD_RESULT(plan); } else { - return SBThreadPlan(); + return LLDB_RECORD_RESULT(SBThreadPlan()); } } diff --git a/lldb/source/API/SBTrace.cpp b/lldb/source/API/SBTrace.cpp index daccdec63f0..71842fe775e 100644 --- a/lldb/source/API/SBTrace.cpp +++ b/lldb/source/API/SBTrace.cpp @@ -6,6 +6,7 @@ // //===----------------------------------------------------------------------===// +#include "SBReproducerPrivate.h" #include "lldb/Target/Process.h" #include "lldb/Utility/Log.h" @@ -60,6 +61,9 @@ size_t SBTrace::GetMetaData(SBError &error, void *buf, size_t size, } void SBTrace::StopTrace(SBError &error, lldb::tid_t thread_id) { + LLDB_RECORD_METHOD(void, SBTrace, StopTrace, (lldb::SBError &, lldb::tid_t), + error, thread_id); + ProcessSP process_sp(GetSP()); error.Clear(); @@ -71,6 +75,9 @@ void SBTrace::StopTrace(SBError &error, lldb::tid_t thread_id) { } void SBTrace::GetTraceConfig(SBTraceOptions &options, SBError &error) { + LLDB_RECORD_METHOD(void, SBTrace, GetTraceConfig, + (lldb::SBTraceOptions &, lldb::SBError &), options, error); + ProcessSP process_sp(GetSP()); error.Clear(); @@ -83,6 +90,8 @@ void SBTrace::GetTraceConfig(SBTraceOptions &options, SBError &error) { } lldb::user_id_t SBTrace::GetTraceUID() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::user_id_t, SBTrace, GetTraceUID); + if (m_trace_impl_sp) return m_trace_impl_sp->uid; return LLDB_INVALID_UID; @@ -94,6 +103,8 @@ void SBTrace::SetTraceUID(lldb::user_id_t uid) { } SBTrace::SBTrace() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTrace); + m_trace_impl_sp = std::make_shared<TraceImpl>(); if (m_trace_impl_sp) m_trace_impl_sp->uid = LLDB_INVALID_UID; @@ -102,6 +113,8 @@ SBTrace::SBTrace() { void SBTrace::SetSP(const ProcessSP &process_sp) { m_opaque_wp = process_sp; } bool SBTrace::IsValid() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBTrace, IsValid); + if (!m_trace_impl_sp) return false; if (!GetSP()) diff --git a/lldb/source/API/SBTraceOptions.cpp b/lldb/source/API/SBTraceOptions.cpp index e48f1dcfc32..a9c799a7428 100644 --- a/lldb/source/API/SBTraceOptions.cpp +++ b/lldb/source/API/SBTraceOptions.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBTraceOptions.h" +#include "SBReproducerPrivate.h" #include "lldb/API/SBError.h" #include "lldb/API/SBStructuredData.h" #include "lldb/Core/StructuredDataImpl.h" @@ -19,22 +20,32 @@ using namespace lldb; using namespace lldb_private; SBTraceOptions::SBTraceOptions() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTraceOptions); + m_traceoptions_sp = std::make_shared<TraceOptions>(); } lldb::TraceType SBTraceOptions::getType() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::TraceType, SBTraceOptions, getType); + if (m_traceoptions_sp) return m_traceoptions_sp->getType(); return lldb::TraceType::eTraceTypeNone; } uint64_t SBTraceOptions::getTraceBufferSize() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint64_t, SBTraceOptions, + getTraceBufferSize); + if (m_traceoptions_sp) return m_traceoptions_sp->getTraceBufferSize(); return 0; } lldb::SBStructuredData SBTraceOptions::getTraceParams(lldb::SBError &error) { + LLDB_RECORD_METHOD(lldb::SBStructuredData, SBTraceOptions, getTraceParams, + (lldb::SBError &), error); + error.Clear(); const lldb_private::StructuredData::DictionarySP dict_obj = m_traceoptions_sp->getTraceParams(); @@ -43,16 +54,22 @@ lldb::SBStructuredData SBTraceOptions::getTraceParams(lldb::SBError &error) { structData.m_impl_up->SetObjectSP(dict_obj->shared_from_this()); else error.SetErrorString("Empty trace params"); - return structData; + return LLDB_RECORD_RESULT(structData); } uint64_t SBTraceOptions::getMetaDataBufferSize() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint64_t, SBTraceOptions, + getMetaDataBufferSize); + if (m_traceoptions_sp) return m_traceoptions_sp->getTraceBufferSize(); return 0; } void SBTraceOptions::setTraceParams(lldb::SBStructuredData ¶ms) { + LLDB_RECORD_METHOD(void, SBTraceOptions, setTraceParams, + (lldb::SBStructuredData &), params); + if (m_traceoptions_sp && params.m_impl_up) { StructuredData::ObjectSP obj_sp = params.m_impl_up->GetObjectSP(); if (obj_sp && obj_sp->GetAsDictionary() != nullptr) @@ -63,32 +80,47 @@ void SBTraceOptions::setTraceParams(lldb::SBStructuredData ¶ms) { } void SBTraceOptions::setType(lldb::TraceType type) { + LLDB_RECORD_METHOD(void, SBTraceOptions, setType, (lldb::TraceType), type); + if (m_traceoptions_sp) m_traceoptions_sp->setType(type); } void SBTraceOptions::setTraceBufferSize(uint64_t size) { + LLDB_RECORD_METHOD(void, SBTraceOptions, setTraceBufferSize, (uint64_t), + size); + if (m_traceoptions_sp) m_traceoptions_sp->setTraceBufferSize(size); } void SBTraceOptions::setMetaDataBufferSize(uint64_t size) { + LLDB_RECORD_METHOD(void, SBTraceOptions, setMetaDataBufferSize, (uint64_t), + size); + if (m_traceoptions_sp) m_traceoptions_sp->setMetaDataBufferSize(size); } bool SBTraceOptions::IsValid() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBTraceOptions, IsValid); + if (m_traceoptions_sp) return true; return false; } void SBTraceOptions::setThreadID(lldb::tid_t thread_id) { + LLDB_RECORD_METHOD(void, SBTraceOptions, setThreadID, (lldb::tid_t), + thread_id); + if (m_traceoptions_sp) m_traceoptions_sp->setThreadID(thread_id); } lldb::tid_t SBTraceOptions::getThreadID() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBTraceOptions, getThreadID); + if (m_traceoptions_sp) return m_traceoptions_sp->getThreadID(); return LLDB_INVALID_THREAD_ID; diff --git a/lldb/source/API/SBType.cpp b/lldb/source/API/SBType.cpp index 25a56dea745..703b4faf8d8 100644 --- a/lldb/source/API/SBType.cpp +++ b/lldb/source/API/SBType.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBType.h" +#include "SBReproducerPrivate.h" #include "lldb/API/SBDefines.h" #include "lldb/API/SBStream.h" #include "lldb/API/SBTypeEnumMember.h" @@ -25,7 +26,7 @@ using namespace lldb; using namespace lldb_private; -SBType::SBType() : m_opaque_sp() {} +SBType::SBType() : m_opaque_sp() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBType); } SBType::SBType(const CompilerType &type) : m_opaque_sp(new TypeImpl( @@ -38,6 +39,8 @@ SBType::SBType(const lldb::TypeImplSP &type_impl_sp) : m_opaque_sp(type_impl_sp) {} SBType::SBType(const SBType &rhs) : m_opaque_sp() { + LLDB_RECORD_CONSTRUCTOR(SBType, (const lldb::SBType &), rhs); + if (this != &rhs) { m_opaque_sp = rhs.m_opaque_sp; } @@ -48,6 +51,8 @@ SBType::SBType(const SBType &rhs) : m_opaque_sp() { //{} // bool SBType::operator==(SBType &rhs) { + LLDB_RECORD_METHOD(bool, SBType, operator==,(lldb::SBType &), rhs); + if (!IsValid()) return !rhs.IsValid(); @@ -58,6 +63,8 @@ bool SBType::operator==(SBType &rhs) { } bool SBType::operator!=(SBType &rhs) { + LLDB_RECORD_METHOD(bool, SBType, operator!=,(lldb::SBType &), rhs); + if (!IsValid()) return rhs.IsValid(); @@ -74,6 +81,9 @@ void SBType::SetSP(const lldb::TypeImplSP &type_impl_sp) { } SBType &SBType::operator=(const SBType &rhs) { + LLDB_RECORD_METHOD(lldb::SBType &, SBType, operator=,(const lldb::SBType &), + rhs); + if (this != &rhs) { m_opaque_sp = rhs.m_opaque_sp; } @@ -97,6 +107,8 @@ const TypeImpl &SBType::ref() const { } bool SBType::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBType, IsValid); + if (m_opaque_sp.get() == NULL) return false; @@ -104,6 +116,8 @@ bool SBType::IsValid() const { } uint64_t SBType::GetByteSize() { + LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBType, GetByteSize); + if (IsValid()) if (llvm::Optional<uint64_t> size = m_opaque_sp->GetCompilerType(false).GetByteSize(nullptr)) @@ -112,12 +126,16 @@ uint64_t SBType::GetByteSize() { } bool SBType::IsPointerType() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsPointerType); + if (!IsValid()) return false; return m_opaque_sp->GetCompilerType(true).IsPointerType(); } bool SBType::IsArrayType() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsArrayType); + if (!IsValid()) return false; return m_opaque_sp->GetCompilerType(true).IsArrayType(nullptr, nullptr, @@ -125,63 +143,88 @@ bool SBType::IsArrayType() { } bool SBType::IsVectorType() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsVectorType); + if (!IsValid()) return false; return m_opaque_sp->GetCompilerType(true).IsVectorType(nullptr, nullptr); } bool SBType::IsReferenceType() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsReferenceType); + if (!IsValid()) return false; return m_opaque_sp->GetCompilerType(true).IsReferenceType(); } SBType SBType::GetPointerType() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetPointerType); + if (!IsValid()) - return SBType(); + return LLDB_RECORD_RESULT(SBType()); - return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetPointerType()))); + return LLDB_RECORD_RESULT( + SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetPointerType())))); } SBType SBType::GetPointeeType() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetPointeeType); + if (!IsValid()) - return SBType(); - return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetPointeeType()))); + return LLDB_RECORD_RESULT(SBType()); + return LLDB_RECORD_RESULT( + SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetPointeeType())))); } SBType SBType::GetReferenceType() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetReferenceType); + if (!IsValid()) - return SBType(); - return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetReferenceType()))); + return LLDB_RECORD_RESULT(SBType()); + return LLDB_RECORD_RESULT( + SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetReferenceType())))); } SBType SBType::GetTypedefedType() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetTypedefedType); + if (!IsValid()) - return SBType(); - return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetTypedefedType()))); + return LLDB_RECORD_RESULT(SBType()); + return LLDB_RECORD_RESULT( + SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetTypedefedType())))); } SBType SBType::GetDereferencedType() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetDereferencedType); + if (!IsValid()) - return SBType(); - return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetDereferencedType()))); + return LLDB_RECORD_RESULT(SBType()); + return LLDB_RECORD_RESULT( + SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetDereferencedType())))); } SBType SBType::GetArrayElementType() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetArrayElementType); + if (!IsValid()) - return SBType(); - return SBType(TypeImplSP( - new TypeImpl(m_opaque_sp->GetCompilerType(true).GetArrayElementType()))); + return LLDB_RECORD_RESULT(SBType()); + return LLDB_RECORD_RESULT(SBType(TypeImplSP( + new TypeImpl(m_opaque_sp->GetCompilerType(true).GetArrayElementType())))); } SBType SBType::GetArrayType(uint64_t size) { + LLDB_RECORD_METHOD(lldb::SBType, SBType, GetArrayType, (uint64_t), size); + if (!IsValid()) - return SBType(); - return SBType(TypeImplSP( - new TypeImpl(m_opaque_sp->GetCompilerType(true).GetArrayType(size)))); + return LLDB_RECORD_RESULT(SBType()); + return LLDB_RECORD_RESULT(SBType(TypeImplSP( + new TypeImpl(m_opaque_sp->GetCompilerType(true).GetArrayType(size))))); } SBType SBType::GetVectorElementType() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetVectorElementType); + SBType type_sb; if (IsValid()) { CompilerType vector_element_type; @@ -189,44 +232,57 @@ SBType SBType::GetVectorElementType() { nullptr)) type_sb.SetSP(TypeImplSP(new TypeImpl(vector_element_type))); } - return type_sb; + return LLDB_RECORD_RESULT(type_sb); } bool SBType::IsFunctionType() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsFunctionType); + if (!IsValid()) return false; return m_opaque_sp->GetCompilerType(true).IsFunctionType(); } bool SBType::IsPolymorphicClass() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsPolymorphicClass); + if (!IsValid()) return false; return m_opaque_sp->GetCompilerType(true).IsPolymorphicClass(); } bool SBType::IsTypedefType() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsTypedefType); + if (!IsValid()) return false; return m_opaque_sp->GetCompilerType(true).IsTypedefType(); } bool SBType::IsAnonymousType() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsAnonymousType); + if (!IsValid()) return false; return m_opaque_sp->GetCompilerType(true).IsAnonymousType(); } lldb::SBType SBType::GetFunctionReturnType() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetFunctionReturnType); + if (IsValid()) { CompilerType return_type( m_opaque_sp->GetCompilerType(true).GetFunctionReturnType()); if (return_type.IsValid()) - return SBType(return_type); + return LLDB_RECORD_RESULT(SBType(return_type)); } - return lldb::SBType(); + return LLDB_RECORD_RESULT(lldb::SBType()); } lldb::SBTypeList SBType::GetFunctionArgumentTypes() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeList, SBType, + GetFunctionArgumentTypes); + SBTypeList sb_type_list; if (IsValid()) { CompilerType func_type(m_opaque_sp->GetCompilerType(true)); @@ -235,10 +291,12 @@ lldb::SBTypeList SBType::GetFunctionArgumentTypes() { sb_type_list.Append(SBType(func_type.GetFunctionArgumentAtIndex(i))); } } - return sb_type_list; + return LLDB_RECORD_RESULT(sb_type_list); } uint32_t SBType::GetNumberOfMemberFunctions() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfMemberFunctions); + if (IsValid()) { return m_opaque_sp->GetCompilerType(true).GetNumMemberFunctions(); } @@ -246,51 +304,71 @@ uint32_t SBType::GetNumberOfMemberFunctions() { } lldb::SBTypeMemberFunction SBType::GetMemberFunctionAtIndex(uint32_t idx) { + LLDB_RECORD_METHOD(lldb::SBTypeMemberFunction, SBType, + GetMemberFunctionAtIndex, (uint32_t), idx); + SBTypeMemberFunction sb_func_type; if (IsValid()) sb_func_type.reset(new TypeMemberFunctionImpl( m_opaque_sp->GetCompilerType(true).GetMemberFunctionAtIndex(idx))); - return sb_func_type; + return LLDB_RECORD_RESULT(sb_func_type); } lldb::SBType SBType::GetUnqualifiedType() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetUnqualifiedType); + if (!IsValid()) - return SBType(); - return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetUnqualifiedType()))); + return LLDB_RECORD_RESULT(SBType()); + return LLDB_RECORD_RESULT( + SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetUnqualifiedType())))); } lldb::SBType SBType::GetCanonicalType() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetCanonicalType); + if (IsValid()) - return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetCanonicalType()))); - return SBType(); + return LLDB_RECORD_RESULT( + SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetCanonicalType())))); + return LLDB_RECORD_RESULT(SBType()); } lldb::BasicType SBType::GetBasicType() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::BasicType, SBType, GetBasicType); + if (IsValid()) return m_opaque_sp->GetCompilerType(false).GetBasicTypeEnumeration(); return eBasicTypeInvalid; } SBType SBType::GetBasicType(lldb::BasicType basic_type) { + LLDB_RECORD_METHOD(lldb::SBType, SBType, GetBasicType, (lldb::BasicType), + basic_type); + if (IsValid() && m_opaque_sp->IsValid()) - return SBType( - m_opaque_sp->GetTypeSystem(false)->GetBasicTypeFromAST(basic_type)); - return SBType(); + return LLDB_RECORD_RESULT(SBType( + m_opaque_sp->GetTypeSystem(false)->GetBasicTypeFromAST(basic_type))); + return LLDB_RECORD_RESULT(SBType()); } uint32_t SBType::GetNumberOfDirectBaseClasses() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfDirectBaseClasses); + if (IsValid()) return m_opaque_sp->GetCompilerType(true).GetNumDirectBaseClasses(); return 0; } uint32_t SBType::GetNumberOfVirtualBaseClasses() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfVirtualBaseClasses); + if (IsValid()) return m_opaque_sp->GetCompilerType(true).GetNumVirtualBaseClasses(); return 0; } uint32_t SBType::GetNumberOfFields() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfFields); + if (IsValid()) return m_opaque_sp->GetCompilerType(true).GetNumFields(); return 0; @@ -298,6 +376,10 @@ uint32_t SBType::GetNumberOfFields() { bool SBType::GetDescription(SBStream &description, lldb::DescriptionLevel description_level) { + LLDB_RECORD_METHOD(bool, SBType, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel), description, + description_level); + Stream &strm = description.ref(); if (m_opaque_sp) { @@ -309,6 +391,9 @@ bool SBType::GetDescription(SBStream &description, } SBTypeMember SBType::GetDirectBaseClassAtIndex(uint32_t idx) { + LLDB_RECORD_METHOD(lldb::SBTypeMember, SBType, GetDirectBaseClassAtIndex, + (uint32_t), idx); + SBTypeMember sb_type_member; if (IsValid()) { uint32_t bit_offset = 0; @@ -319,10 +404,13 @@ SBTypeMember SBType::GetDirectBaseClassAtIndex(uint32_t idx) { sb_type_member.reset(new TypeMemberImpl( TypeImplSP(new TypeImpl(base_class_type)), bit_offset)); } - return sb_type_member; + return LLDB_RECORD_RESULT(sb_type_member); } SBTypeMember SBType::GetVirtualBaseClassAtIndex(uint32_t idx) { + LLDB_RECORD_METHOD(lldb::SBTypeMember, SBType, GetVirtualBaseClassAtIndex, + (uint32_t), idx); + SBTypeMember sb_type_member; if (IsValid()) { uint32_t bit_offset = 0; @@ -333,10 +421,13 @@ SBTypeMember SBType::GetVirtualBaseClassAtIndex(uint32_t idx) { sb_type_member.reset(new TypeMemberImpl( TypeImplSP(new TypeImpl(base_class_type)), bit_offset)); } - return sb_type_member; + return LLDB_RECORD_RESULT(sb_type_member); } SBTypeEnumMemberList SBType::GetEnumMembers() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeEnumMemberList, SBType, + GetEnumMembers); + SBTypeEnumMemberList sb_enum_member_list; if (IsValid()) { CompilerType this_type(m_opaque_sp->GetCompilerType(true)); @@ -353,10 +444,13 @@ SBTypeEnumMemberList SBType::GetEnumMembers() { }); } } - return sb_enum_member_list; + return LLDB_RECORD_RESULT(sb_enum_member_list); } SBTypeMember SBType::GetFieldAtIndex(uint32_t idx) { + LLDB_RECORD_METHOD(lldb::SBTypeMember, SBType, GetFieldAtIndex, (uint32_t), + idx); + SBTypeMember sb_type_member; if (IsValid()) { CompilerType this_type(m_opaque_sp->GetCompilerType(false)); @@ -377,48 +471,63 @@ SBTypeMember SBType::GetFieldAtIndex(uint32_t idx) { } } } - return sb_type_member; + return LLDB_RECORD_RESULT(sb_type_member); } bool SBType::IsTypeComplete() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsTypeComplete); + if (!IsValid()) return false; return m_opaque_sp->GetCompilerType(false).IsCompleteType(); } uint32_t SBType::GetTypeFlags() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetTypeFlags); + if (!IsValid()) return 0; return m_opaque_sp->GetCompilerType(true).GetTypeInfo(); } const char *SBType::GetName() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBType, GetName); + if (!IsValid()) return ""; return m_opaque_sp->GetName().GetCString(); } const char *SBType::GetDisplayTypeName() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBType, GetDisplayTypeName); + if (!IsValid()) return ""; return m_opaque_sp->GetDisplayTypeName().GetCString(); } lldb::TypeClass SBType::GetTypeClass() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::TypeClass, SBType, GetTypeClass); + if (IsValid()) return m_opaque_sp->GetCompilerType(true).GetTypeClass(); return lldb::eTypeClassInvalid; } uint32_t SBType::GetNumberOfTemplateArguments() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfTemplateArguments); + if (IsValid()) return m_opaque_sp->GetCompilerType(false).GetNumTemplateArguments(); return 0; } lldb::SBType SBType::GetTemplateArgumentType(uint32_t idx) { + LLDB_RECORD_METHOD(lldb::SBType, SBType, GetTemplateArgumentType, (uint32_t), + idx); + if (!IsValid()) - return SBType(); + return LLDB_RECORD_RESULT(SBType()); CompilerType type; switch(GetTemplateArgumentKind(idx)) { @@ -434,28 +543,42 @@ lldb::SBType SBType::GetTemplateArgumentType(uint32_t idx) { break; } if (type.IsValid()) - return SBType(type); - return SBType(); + return LLDB_RECORD_RESULT(SBType(type)); + return LLDB_RECORD_RESULT(SBType()); } lldb::TemplateArgumentKind SBType::GetTemplateArgumentKind(uint32_t idx) { + LLDB_RECORD_METHOD(lldb::TemplateArgumentKind, SBType, + GetTemplateArgumentKind, (uint32_t), idx); + if (IsValid()) return m_opaque_sp->GetCompilerType(false).GetTemplateArgumentKind(idx); return eTemplateArgumentKindNull; } -SBTypeList::SBTypeList() : m_opaque_up(new TypeListImpl()) {} +SBTypeList::SBTypeList() : m_opaque_up(new TypeListImpl()) { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeList); +} SBTypeList::SBTypeList(const SBTypeList &rhs) : m_opaque_up(new TypeListImpl()) { + LLDB_RECORD_CONSTRUCTOR(SBTypeList, (const lldb::SBTypeList &), rhs); + for (uint32_t i = 0, rhs_size = const_cast<SBTypeList &>(rhs).GetSize(); i < rhs_size; i++) Append(const_cast<SBTypeList &>(rhs).GetTypeAtIndex(i)); } -bool SBTypeList::IsValid() { return (m_opaque_up != NULL); } +bool SBTypeList::IsValid() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeList, IsValid); + + return (m_opaque_up != NULL); +} SBTypeList &SBTypeList::operator=(const SBTypeList &rhs) { + LLDB_RECORD_METHOD(lldb::SBTypeList &, + SBTypeList, operator=,(const lldb::SBTypeList &), rhs); + if (this != &rhs) { m_opaque_up.reset(new TypeListImpl()); for (uint32_t i = 0, rhs_size = const_cast<SBTypeList &>(rhs).GetSize(); @@ -466,25 +589,38 @@ SBTypeList &SBTypeList::operator=(const SBTypeList &rhs) { } void SBTypeList::Append(SBType type) { + LLDB_RECORD_METHOD(void, SBTypeList, Append, (lldb::SBType), type); + if (type.IsValid()) m_opaque_up->Append(type.m_opaque_sp); } SBType SBTypeList::GetTypeAtIndex(uint32_t index) { + LLDB_RECORD_METHOD(lldb::SBType, SBTypeList, GetTypeAtIndex, (uint32_t), + index); + if (m_opaque_up) - return SBType(m_opaque_up->GetTypeAtIndex(index)); - return SBType(); + return LLDB_RECORD_RESULT(SBType(m_opaque_up->GetTypeAtIndex(index))); + return LLDB_RECORD_RESULT(SBType()); } -uint32_t SBTypeList::GetSize() { return m_opaque_up->GetSize(); } +uint32_t SBTypeList::GetSize() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeList, GetSize); + + return m_opaque_up->GetSize(); +} SBTypeList::~SBTypeList() {} -SBTypeMember::SBTypeMember() : m_opaque_up() {} +SBTypeMember::SBTypeMember() : m_opaque_up() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeMember); +} SBTypeMember::~SBTypeMember() {} SBTypeMember::SBTypeMember(const SBTypeMember &rhs) : m_opaque_up() { + LLDB_RECORD_CONSTRUCTOR(SBTypeMember, (const lldb::SBTypeMember &), rhs); + if (this != &rhs) { if (rhs.IsValid()) m_opaque_up.reset(new TypeMemberImpl(rhs.ref())); @@ -492,6 +628,9 @@ SBTypeMember::SBTypeMember(const SBTypeMember &rhs) : m_opaque_up() { } lldb::SBTypeMember &SBTypeMember::operator=(const lldb::SBTypeMember &rhs) { + LLDB_RECORD_METHOD(lldb::SBTypeMember &, + SBTypeMember, operator=,(const lldb::SBTypeMember &), rhs); + if (this != &rhs) { if (rhs.IsValid()) m_opaque_up.reset(new TypeMemberImpl(rhs.ref())); @@ -499,41 +638,57 @@ lldb::SBTypeMember &SBTypeMember::operator=(const lldb::SBTypeMember &rhs) { return *this; } -bool SBTypeMember::IsValid() const { return m_opaque_up.get(); } +bool SBTypeMember::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMember, IsValid); + + return m_opaque_up.get(); +} const char *SBTypeMember::GetName() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMember, GetName); + if (m_opaque_up) return m_opaque_up->GetName().GetCString(); return NULL; } SBType SBTypeMember::GetType() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeMember, GetType); + SBType sb_type; if (m_opaque_up) { sb_type.SetSP(m_opaque_up->GetTypeImpl()); } - return sb_type; + return LLDB_RECORD_RESULT(sb_type); } uint64_t SBTypeMember::GetOffsetInBytes() { + LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBTypeMember, GetOffsetInBytes); + if (m_opaque_up) return m_opaque_up->GetBitOffset() / 8u; return 0; } uint64_t SBTypeMember::GetOffsetInBits() { + LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBTypeMember, GetOffsetInBits); + if (m_opaque_up) return m_opaque_up->GetBitOffset(); return 0; } bool SBTypeMember::IsBitfield() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeMember, IsBitfield); + if (m_opaque_up) return m_opaque_up->GetIsBitfield(); return false; } uint32_t SBTypeMember::GetBitfieldSizeInBits() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeMember, GetBitfieldSizeInBits); + if (m_opaque_up) return m_opaque_up->GetBitfieldBitSize(); return 0; @@ -541,6 +696,10 @@ uint32_t SBTypeMember::GetBitfieldSizeInBits() { bool SBTypeMember::GetDescription(lldb::SBStream &description, lldb::DescriptionLevel description_level) { + LLDB_RECORD_METHOD(bool, SBTypeMember, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel), description, + description_level); + Stream &strm = description.ref(); if (m_opaque_up) { @@ -580,29 +739,48 @@ TypeMemberImpl &SBTypeMember::ref() { const TypeMemberImpl &SBTypeMember::ref() const { return *m_opaque_up; } -SBTypeMemberFunction::SBTypeMemberFunction() : m_opaque_sp() {} +SBTypeMemberFunction::SBTypeMemberFunction() : m_opaque_sp() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeMemberFunction); +} SBTypeMemberFunction::~SBTypeMemberFunction() {} SBTypeMemberFunction::SBTypeMemberFunction(const SBTypeMemberFunction &rhs) - : m_opaque_sp(rhs.m_opaque_sp) {} + : m_opaque_sp(rhs.m_opaque_sp) { + LLDB_RECORD_CONSTRUCTOR(SBTypeMemberFunction, + (const lldb::SBTypeMemberFunction &), rhs); +} lldb::SBTypeMemberFunction &SBTypeMemberFunction:: operator=(const lldb::SBTypeMemberFunction &rhs) { + LLDB_RECORD_METHOD( + lldb::SBTypeMemberFunction &, + SBTypeMemberFunction, operator=,(const lldb::SBTypeMemberFunction &), + rhs); + if (this != &rhs) m_opaque_sp = rhs.m_opaque_sp; return *this; } -bool SBTypeMemberFunction::IsValid() const { return m_opaque_sp.get(); } +bool SBTypeMemberFunction::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMemberFunction, IsValid); + + return m_opaque_sp.get(); +} const char *SBTypeMemberFunction::GetName() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMemberFunction, GetName); + if (m_opaque_sp) return m_opaque_sp->GetName().GetCString(); return NULL; } const char *SBTypeMemberFunction::GetDemangledName() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMemberFunction, + GetDemangledName); + if (m_opaque_sp) { ConstString mangled_str = m_opaque_sp->GetMangledName(); if (mangled_str) { @@ -614,43 +792,59 @@ const char *SBTypeMemberFunction::GetDemangledName() { } const char *SBTypeMemberFunction::GetMangledName() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMemberFunction, + GetMangledName); + if (m_opaque_sp) return m_opaque_sp->GetMangledName().GetCString(); return NULL; } SBType SBTypeMemberFunction::GetType() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeMemberFunction, GetType); + SBType sb_type; if (m_opaque_sp) { sb_type.SetSP(lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetType()))); } - return sb_type; + return LLDB_RECORD_RESULT(sb_type); } lldb::SBType SBTypeMemberFunction::GetReturnType() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeMemberFunction, GetReturnType); + SBType sb_type; if (m_opaque_sp) { sb_type.SetSP(lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetReturnType()))); } - return sb_type; + return LLDB_RECORD_RESULT(sb_type); } uint32_t SBTypeMemberFunction::GetNumberOfArguments() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeMemberFunction, + GetNumberOfArguments); + if (m_opaque_sp) return m_opaque_sp->GetNumArguments(); return 0; } lldb::SBType SBTypeMemberFunction::GetArgumentTypeAtIndex(uint32_t i) { + LLDB_RECORD_METHOD(lldb::SBType, SBTypeMemberFunction, GetArgumentTypeAtIndex, + (uint32_t), i); + SBType sb_type; if (m_opaque_sp) { sb_type.SetSP( lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetArgumentAtIndex(i)))); } - return sb_type; + return LLDB_RECORD_RESULT(sb_type); } lldb::MemberFunctionKind SBTypeMemberFunction::GetKind() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::MemberFunctionKind, SBTypeMemberFunction, + GetKind); + if (m_opaque_sp) return m_opaque_sp->GetKind(); return lldb::eMemberFunctionKindUnknown; @@ -658,6 +852,10 @@ lldb::MemberFunctionKind SBTypeMemberFunction::GetKind() { bool SBTypeMemberFunction::GetDescription( lldb::SBStream &description, lldb::DescriptionLevel description_level) { + LLDB_RECORD_METHOD(bool, SBTypeMemberFunction, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel), description, + description_level); + Stream &strm = description.ref(); if (m_opaque_sp) diff --git a/lldb/source/API/SBTypeCategory.cpp b/lldb/source/API/SBTypeCategory.cpp index 1d8234a030f..22eff9fcb9c 100644 --- a/lldb/source/API/SBTypeCategory.cpp +++ b/lldb/source/API/SBTypeCategory.cpp @@ -8,6 +8,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBTypeCategory.h" +#include "SBReproducerPrivate.h" #include "lldb/API/SBStream.h" #include "lldb/API/SBTypeFilter.h" @@ -26,26 +27,38 @@ using namespace lldb_private; typedef std::pair<lldb::TypeCategoryImplSP, user_id_t> ImplType; -SBTypeCategory::SBTypeCategory() : m_opaque_sp() {} +SBTypeCategory::SBTypeCategory() : m_opaque_sp() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeCategory); +} SBTypeCategory::SBTypeCategory(const char *name) : m_opaque_sp() { DataVisualization::Categories::GetCategory(ConstString(name), m_opaque_sp); } SBTypeCategory::SBTypeCategory(const lldb::SBTypeCategory &rhs) - : m_opaque_sp(rhs.m_opaque_sp) {} + : m_opaque_sp(rhs.m_opaque_sp) { + LLDB_RECORD_CONSTRUCTOR(SBTypeCategory, (const lldb::SBTypeCategory &), rhs); +} SBTypeCategory::~SBTypeCategory() {} -bool SBTypeCategory::IsValid() const { return (m_opaque_sp.get() != NULL); } +bool SBTypeCategory::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeCategory, IsValid); + + return (m_opaque_sp.get() != NULL); +} bool SBTypeCategory::GetEnabled() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeCategory, GetEnabled); + if (!IsValid()) return false; return m_opaque_sp->IsEnabled(); } void SBTypeCategory::SetEnabled(bool enabled) { + LLDB_RECORD_METHOD(void, SBTypeCategory, SetEnabled, (bool), enabled); + if (!IsValid()) return; if (enabled) @@ -55,29 +68,41 @@ void SBTypeCategory::SetEnabled(bool enabled) { } const char *SBTypeCategory::GetName() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeCategory, GetName); + if (!IsValid()) return NULL; return m_opaque_sp->GetName(); } lldb::LanguageType SBTypeCategory::GetLanguageAtIndex(uint32_t idx) { + LLDB_RECORD_METHOD(lldb::LanguageType, SBTypeCategory, GetLanguageAtIndex, + (uint32_t), idx); + if (IsValid()) return m_opaque_sp->GetLanguageAtIndex(idx); return lldb::eLanguageTypeUnknown; } uint32_t SBTypeCategory::GetNumLanguages() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumLanguages); + if (IsValid()) return m_opaque_sp->GetNumLanguages(); return 0; } void SBTypeCategory::AddLanguage(lldb::LanguageType language) { + LLDB_RECORD_METHOD(void, SBTypeCategory, AddLanguage, (lldb::LanguageType), + language); + if (IsValid()) m_opaque_sp->AddLanguage(language); } uint32_t SBTypeCategory::GetNumFormats() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumFormats); + if (!IsValid()) return 0; @@ -86,6 +111,8 @@ uint32_t SBTypeCategory::GetNumFormats() { } uint32_t SBTypeCategory::GetNumSummaries() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumSummaries); + if (!IsValid()) return 0; return m_opaque_sp->GetTypeSummariesContainer()->GetCount() + @@ -93,6 +120,8 @@ uint32_t SBTypeCategory::GetNumSummaries() { } uint32_t SBTypeCategory::GetNumFilters() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumFilters); + if (!IsValid()) return 0; return m_opaque_sp->GetTypeFiltersContainer()->GetCount() + @@ -101,6 +130,8 @@ uint32_t SBTypeCategory::GetNumFilters() { #ifndef LLDB_DISABLE_PYTHON uint32_t SBTypeCategory::GetNumSynthetics() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumSynthetics); + if (!IsValid()) return 0; return m_opaque_sp->GetTypeSyntheticsContainer()->GetCount() + @@ -110,44 +141,60 @@ uint32_t SBTypeCategory::GetNumSynthetics() { lldb::SBTypeNameSpecifier SBTypeCategory::GetTypeNameSpecifierForFilterAtIndex(uint32_t index) { + LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory, + GetTypeNameSpecifierForFilterAtIndex, (uint32_t), index); + if (!IsValid()) - return SBTypeNameSpecifier(); - return SBTypeNameSpecifier( - m_opaque_sp->GetTypeNameSpecifierForFilterAtIndex(index)); + return LLDB_RECORD_RESULT(SBTypeNameSpecifier()); + return LLDB_RECORD_RESULT(SBTypeNameSpecifier( + m_opaque_sp->GetTypeNameSpecifierForFilterAtIndex(index))); } lldb::SBTypeNameSpecifier SBTypeCategory::GetTypeNameSpecifierForFormatAtIndex(uint32_t index) { + LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory, + GetTypeNameSpecifierForFormatAtIndex, (uint32_t), index); + if (!IsValid()) - return SBTypeNameSpecifier(); - return SBTypeNameSpecifier( - m_opaque_sp->GetTypeNameSpecifierForFormatAtIndex(index)); + return LLDB_RECORD_RESULT(SBTypeNameSpecifier()); + return LLDB_RECORD_RESULT(SBTypeNameSpecifier( + m_opaque_sp->GetTypeNameSpecifierForFormatAtIndex(index))); } lldb::SBTypeNameSpecifier SBTypeCategory::GetTypeNameSpecifierForSummaryAtIndex(uint32_t index) { + LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory, + GetTypeNameSpecifierForSummaryAtIndex, (uint32_t), index); + if (!IsValid()) - return SBTypeNameSpecifier(); - return SBTypeNameSpecifier( - m_opaque_sp->GetTypeNameSpecifierForSummaryAtIndex(index)); + return LLDB_RECORD_RESULT(SBTypeNameSpecifier()); + return LLDB_RECORD_RESULT(SBTypeNameSpecifier( + m_opaque_sp->GetTypeNameSpecifierForSummaryAtIndex(index))); } #ifndef LLDB_DISABLE_PYTHON lldb::SBTypeNameSpecifier SBTypeCategory::GetTypeNameSpecifierForSyntheticAtIndex(uint32_t index) { + LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory, + GetTypeNameSpecifierForSyntheticAtIndex, (uint32_t), + index); + if (!IsValid()) - return SBTypeNameSpecifier(); - return SBTypeNameSpecifier( - m_opaque_sp->GetTypeNameSpecifierForSyntheticAtIndex(index)); + return LLDB_RECORD_RESULT(SBTypeNameSpecifier()); + return LLDB_RECORD_RESULT(SBTypeNameSpecifier( + m_opaque_sp->GetTypeNameSpecifierForSyntheticAtIndex(index))); } #endif SBTypeFilter SBTypeCategory::GetFilterForType(SBTypeNameSpecifier spec) { + LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterForType, + (lldb::SBTypeNameSpecifier), spec); + if (!IsValid()) - return SBTypeFilter(); + return LLDB_RECORD_RESULT(SBTypeFilter()); if (!spec.IsValid()) - return SBTypeFilter(); + return LLDB_RECORD_RESULT(SBTypeFilter()); lldb::TypeFilterImplSP children_sp; @@ -159,19 +206,22 @@ SBTypeFilter SBTypeCategory::GetFilterForType(SBTypeNameSpecifier spec) { ConstString(spec.GetName()), children_sp); if (!children_sp) - return lldb::SBTypeFilter(); + return LLDB_RECORD_RESULT(lldb::SBTypeFilter()); TypeFilterImplSP filter_sp = std::static_pointer_cast<TypeFilterImpl>(children_sp); - return lldb::SBTypeFilter(filter_sp); + return LLDB_RECORD_RESULT(lldb::SBTypeFilter(filter_sp)); } SBTypeFormat SBTypeCategory::GetFormatForType(SBTypeNameSpecifier spec) { + LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatForType, + (lldb::SBTypeNameSpecifier), spec); + if (!IsValid()) - return SBTypeFormat(); + return LLDB_RECORD_RESULT(SBTypeFormat()); if (!spec.IsValid()) - return SBTypeFormat(); + return LLDB_RECORD_RESULT(SBTypeFormat()); lldb::TypeFormatImplSP format_sp; @@ -183,18 +233,21 @@ SBTypeFormat SBTypeCategory::GetFormatForType(SBTypeNameSpecifier spec) { ConstString(spec.GetName()), format_sp); if (!format_sp) - return lldb::SBTypeFormat(); + return LLDB_RECORD_RESULT(lldb::SBTypeFormat()); - return lldb::SBTypeFormat(format_sp); + return LLDB_RECORD_RESULT(lldb::SBTypeFormat(format_sp)); } #ifndef LLDB_DISABLE_PYTHON SBTypeSummary SBTypeCategory::GetSummaryForType(SBTypeNameSpecifier spec) { + LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryForType, + (lldb::SBTypeNameSpecifier), spec); + if (!IsValid()) - return SBTypeSummary(); + return LLDB_RECORD_RESULT(SBTypeSummary()); if (!spec.IsValid()) - return SBTypeSummary(); + return LLDB_RECORD_RESULT(SBTypeSummary()); lldb::TypeSummaryImplSP summary_sp; @@ -206,19 +259,22 @@ SBTypeSummary SBTypeCategory::GetSummaryForType(SBTypeNameSpecifier spec) { ConstString(spec.GetName()), summary_sp); if (!summary_sp) - return lldb::SBTypeSummary(); + return LLDB_RECORD_RESULT(lldb::SBTypeSummary()); - return lldb::SBTypeSummary(summary_sp); + return LLDB_RECORD_RESULT(lldb::SBTypeSummary(summary_sp)); } #endif // LLDB_DISABLE_PYTHON #ifndef LLDB_DISABLE_PYTHON SBTypeSynthetic SBTypeCategory::GetSyntheticForType(SBTypeNameSpecifier spec) { + LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBTypeCategory, GetSyntheticForType, + (lldb::SBTypeNameSpecifier), spec); + if (!IsValid()) - return SBTypeSynthetic(); + return LLDB_RECORD_RESULT(SBTypeSynthetic()); if (!spec.IsValid()) - return SBTypeSynthetic(); + return LLDB_RECORD_RESULT(SBTypeSynthetic()); lldb::SyntheticChildrenSP children_sp; @@ -230,65 +286,83 @@ SBTypeSynthetic SBTypeCategory::GetSyntheticForType(SBTypeNameSpecifier spec) { ConstString(spec.GetName()), children_sp); if (!children_sp) - return lldb::SBTypeSynthetic(); + return LLDB_RECORD_RESULT(lldb::SBTypeSynthetic()); ScriptedSyntheticChildrenSP synth_sp = std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp); - return lldb::SBTypeSynthetic(synth_sp); + return LLDB_RECORD_RESULT(lldb::SBTypeSynthetic(synth_sp)); } #endif #ifndef LLDB_DISABLE_PYTHON SBTypeFilter SBTypeCategory::GetFilterAtIndex(uint32_t index) { + LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterAtIndex, + (uint32_t), index); + if (!IsValid()) - return SBTypeFilter(); + return LLDB_RECORD_RESULT(SBTypeFilter()); lldb::SyntheticChildrenSP children_sp = m_opaque_sp->GetSyntheticAtIndex((index)); if (!children_sp.get()) - return lldb::SBTypeFilter(); + return LLDB_RECORD_RESULT(lldb::SBTypeFilter()); TypeFilterImplSP filter_sp = std::static_pointer_cast<TypeFilterImpl>(children_sp); - return lldb::SBTypeFilter(filter_sp); + return LLDB_RECORD_RESULT(lldb::SBTypeFilter(filter_sp)); } #endif SBTypeFormat SBTypeCategory::GetFormatAtIndex(uint32_t index) { + LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatAtIndex, + (uint32_t), index); + if (!IsValid()) - return SBTypeFormat(); - return SBTypeFormat(m_opaque_sp->GetFormatAtIndex((index))); + return LLDB_RECORD_RESULT(SBTypeFormat()); + return LLDB_RECORD_RESULT( + SBTypeFormat(m_opaque_sp->GetFormatAtIndex((index)))); } #ifndef LLDB_DISABLE_PYTHON SBTypeSummary SBTypeCategory::GetSummaryAtIndex(uint32_t index) { + LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryAtIndex, + (uint32_t), index); + if (!IsValid()) - return SBTypeSummary(); - return SBTypeSummary(m_opaque_sp->GetSummaryAtIndex((index))); + return LLDB_RECORD_RESULT(SBTypeSummary()); + return LLDB_RECORD_RESULT( + SBTypeSummary(m_opaque_sp->GetSummaryAtIndex((index)))); } #endif #ifndef LLDB_DISABLE_PYTHON SBTypeSynthetic SBTypeCategory::GetSyntheticAtIndex(uint32_t index) { + LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBTypeCategory, GetSyntheticAtIndex, + (uint32_t), index); + if (!IsValid()) - return SBTypeSynthetic(); + return LLDB_RECORD_RESULT(SBTypeSynthetic()); lldb::SyntheticChildrenSP children_sp = m_opaque_sp->GetSyntheticAtIndex((index)); if (!children_sp.get()) - return lldb::SBTypeSynthetic(); + return LLDB_RECORD_RESULT(lldb::SBTypeSynthetic()); ScriptedSyntheticChildrenSP synth_sp = std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp); - return lldb::SBTypeSynthetic(synth_sp); + return LLDB_RECORD_RESULT(lldb::SBTypeSynthetic(synth_sp)); } #endif bool SBTypeCategory::AddTypeFormat(SBTypeNameSpecifier type_name, SBTypeFormat format) { + LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeFormat, + (lldb::SBTypeNameSpecifier, lldb::SBTypeFormat), type_name, + format); + if (!IsValid()) return false; @@ -311,6 +385,9 @@ bool SBTypeCategory::AddTypeFormat(SBTypeNameSpecifier type_name, } bool SBTypeCategory::DeleteTypeFormat(SBTypeNameSpecifier type_name) { + LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeFormat, + (lldb::SBTypeNameSpecifier), type_name); + if (!IsValid()) return false; @@ -328,6 +405,10 @@ bool SBTypeCategory::DeleteTypeFormat(SBTypeNameSpecifier type_name) { #ifndef LLDB_DISABLE_PYTHON bool SBTypeCategory::AddTypeSummary(SBTypeNameSpecifier type_name, SBTypeSummary summary) { + LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeSummary, + (lldb::SBTypeNameSpecifier, lldb::SBTypeSummary), + type_name, summary); + if (!IsValid()) return false; @@ -385,6 +466,9 @@ bool SBTypeCategory::AddTypeSummary(SBTypeNameSpecifier type_name, #endif bool SBTypeCategory::DeleteTypeSummary(SBTypeNameSpecifier type_name) { + LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeSummary, + (lldb::SBTypeNameSpecifier), type_name); + if (!IsValid()) return false; @@ -401,6 +485,10 @@ bool SBTypeCategory::DeleteTypeSummary(SBTypeNameSpecifier type_name) { bool SBTypeCategory::AddTypeFilter(SBTypeNameSpecifier type_name, SBTypeFilter filter) { + LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeFilter, + (lldb::SBTypeNameSpecifier, lldb::SBTypeFilter), type_name, + filter); + if (!IsValid()) return false; @@ -423,6 +511,9 @@ bool SBTypeCategory::AddTypeFilter(SBTypeNameSpecifier type_name, } bool SBTypeCategory::DeleteTypeFilter(SBTypeNameSpecifier type_name) { + LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeFilter, + (lldb::SBTypeNameSpecifier), type_name); + if (!IsValid()) return false; @@ -440,6 +531,10 @@ bool SBTypeCategory::DeleteTypeFilter(SBTypeNameSpecifier type_name) { #ifndef LLDB_DISABLE_PYTHON bool SBTypeCategory::AddTypeSynthetic(SBTypeNameSpecifier type_name, SBTypeSynthetic synth) { + LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeSynthetic, + (lldb::SBTypeNameSpecifier, lldb::SBTypeSynthetic), + type_name, synth); + if (!IsValid()) return false; @@ -496,6 +591,9 @@ bool SBTypeCategory::AddTypeSynthetic(SBTypeNameSpecifier type_name, } bool SBTypeCategory::DeleteTypeSynthetic(SBTypeNameSpecifier type_name) { + LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeSynthetic, + (lldb::SBTypeNameSpecifier), type_name); + if (!IsValid()) return false; @@ -513,6 +611,10 @@ bool SBTypeCategory::DeleteTypeSynthetic(SBTypeNameSpecifier type_name) { bool SBTypeCategory::GetDescription(lldb::SBStream &description, lldb::DescriptionLevel description_level) { + LLDB_RECORD_METHOD(bool, SBTypeCategory, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel), description, + description_level); + if (!IsValid()) return false; description.Printf("Category name: %s\n", GetName()); @@ -521,6 +623,10 @@ bool SBTypeCategory::GetDescription(lldb::SBStream &description, lldb::SBTypeCategory &SBTypeCategory:: operator=(const lldb::SBTypeCategory &rhs) { + LLDB_RECORD_METHOD(lldb::SBTypeCategory &, + SBTypeCategory, operator=,(const lldb::SBTypeCategory &), + rhs); + if (this != &rhs) { m_opaque_sp = rhs.m_opaque_sp; } @@ -528,6 +634,9 @@ operator=(const lldb::SBTypeCategory &rhs) { } bool SBTypeCategory::operator==(lldb::SBTypeCategory &rhs) { + LLDB_RECORD_METHOD(bool, SBTypeCategory, operator==,(lldb::SBTypeCategory &), + rhs); + if (!IsValid()) return !rhs.IsValid(); @@ -535,6 +644,9 @@ bool SBTypeCategory::operator==(lldb::SBTypeCategory &rhs) { } bool SBTypeCategory::operator!=(lldb::SBTypeCategory &rhs) { + LLDB_RECORD_METHOD(bool, SBTypeCategory, operator!=,(lldb::SBTypeCategory &), + rhs); + if (!IsValid()) return rhs.IsValid(); diff --git a/lldb/source/API/SBTypeEnumMember.cpp b/lldb/source/API/SBTypeEnumMember.cpp index 62701ef1e4a..0a39f9166d9 100644 --- a/lldb/source/API/SBTypeEnumMember.cpp +++ b/lldb/source/API/SBTypeEnumMember.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBTypeEnumMember.h" +#include "SBReproducerPrivate.h" #include "Utils.h" #include "lldb/API/SBDefines.h" #include "lldb/API/SBStream.h" @@ -20,7 +21,9 @@ using namespace lldb; using namespace lldb_private; -SBTypeEnumMember::SBTypeEnumMember() : m_opaque_sp() {} +SBTypeEnumMember::SBTypeEnumMember() : m_opaque_sp() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeEnumMember); +} SBTypeEnumMember::~SBTypeEnumMember() {} @@ -30,41 +33,59 @@ SBTypeEnumMember::SBTypeEnumMember( SBTypeEnumMember::SBTypeEnumMember(const SBTypeEnumMember &rhs) : m_opaque_sp() { + LLDB_RECORD_CONSTRUCTOR(SBTypeEnumMember, (const lldb::SBTypeEnumMember &), + rhs); + m_opaque_sp = clone(rhs.m_opaque_sp); } SBTypeEnumMember &SBTypeEnumMember::operator=(const SBTypeEnumMember &rhs) { + LLDB_RECORD_CONSTRUCTOR(SBTypeEnumMember, (const lldb::SBTypeEnumMember &), + rhs); + if (this != &rhs) m_opaque_sp = clone(rhs.m_opaque_sp); return *this; } -bool SBTypeEnumMember::IsValid() const { return m_opaque_sp.get(); } +bool SBTypeEnumMember::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMember, IsValid); + + return m_opaque_sp.get(); +} const char *SBTypeEnumMember::GetName() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeEnumMember, GetName); + if (m_opaque_sp.get()) return m_opaque_sp->GetName().GetCString(); return NULL; } int64_t SBTypeEnumMember::GetValueAsSigned() { + LLDB_RECORD_METHOD_NO_ARGS(int64_t, SBTypeEnumMember, GetValueAsSigned); + if (m_opaque_sp.get()) return m_opaque_sp->GetValueAsSigned(); return 0; } uint64_t SBTypeEnumMember::GetValueAsUnsigned() { + LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBTypeEnumMember, GetValueAsUnsigned); + if (m_opaque_sp.get()) return m_opaque_sp->GetValueAsUnsigned(); return 0; } SBType SBTypeEnumMember::GetType() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeEnumMember, GetType); + SBType sb_type; if (m_opaque_sp.get()) { sb_type.SetSP(m_opaque_sp->GetIntegerType()); } - return sb_type; + return LLDB_RECORD_RESULT(sb_type); } void SBTypeEnumMember::reset(TypeEnumMemberImpl *type_member_impl) { @@ -82,20 +103,34 @@ const TypeEnumMemberImpl &SBTypeEnumMember::ref() const { } SBTypeEnumMemberList::SBTypeEnumMemberList() - : m_opaque_up(new TypeEnumMemberListImpl()) {} + : m_opaque_up(new TypeEnumMemberListImpl()) { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeEnumMemberList); +} SBTypeEnumMemberList::SBTypeEnumMemberList(const SBTypeEnumMemberList &rhs) : m_opaque_up(new TypeEnumMemberListImpl()) { + LLDB_RECORD_CONSTRUCTOR(SBTypeEnumMemberList, + (const lldb::SBTypeEnumMemberList &), rhs); + for (uint32_t i = 0, rhs_size = const_cast<SBTypeEnumMemberList &>(rhs).GetSize(); i < rhs_size; i++) Append(const_cast<SBTypeEnumMemberList &>(rhs).GetTypeEnumMemberAtIndex(i)); } -bool SBTypeEnumMemberList::IsValid() { return (m_opaque_up != NULL); } +bool SBTypeEnumMemberList::IsValid() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeEnumMemberList, IsValid); + + return (m_opaque_up != NULL); +} SBTypeEnumMemberList &SBTypeEnumMemberList:: operator=(const SBTypeEnumMemberList &rhs) { + LLDB_RECORD_METHOD( + lldb::SBTypeEnumMemberList &, + SBTypeEnumMemberList, operator=,(const lldb::SBTypeEnumMemberList &), + rhs); + if (this != &rhs) { m_opaque_up.reset(new TypeEnumMemberListImpl()); for (uint32_t i = 0, @@ -108,23 +143,38 @@ operator=(const SBTypeEnumMemberList &rhs) { } void SBTypeEnumMemberList::Append(SBTypeEnumMember enum_member) { + LLDB_RECORD_METHOD(void, SBTypeEnumMemberList, Append, + (lldb::SBTypeEnumMember), enum_member); + if (enum_member.IsValid()) m_opaque_up->Append(enum_member.m_opaque_sp); } SBTypeEnumMember SBTypeEnumMemberList::GetTypeEnumMemberAtIndex(uint32_t index) { + LLDB_RECORD_METHOD(lldb::SBTypeEnumMember, SBTypeEnumMemberList, + GetTypeEnumMemberAtIndex, (uint32_t), index); + if (m_opaque_up) - return SBTypeEnumMember(m_opaque_up->GetTypeEnumMemberAtIndex(index)); - return SBTypeEnumMember(); + return LLDB_RECORD_RESULT( + SBTypeEnumMember(m_opaque_up->GetTypeEnumMemberAtIndex(index))); + return LLDB_RECORD_RESULT(SBTypeEnumMember()); } -uint32_t SBTypeEnumMemberList::GetSize() { return m_opaque_up->GetSize(); } +uint32_t SBTypeEnumMemberList::GetSize() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeEnumMemberList, GetSize); + + return m_opaque_up->GetSize(); +} SBTypeEnumMemberList::~SBTypeEnumMemberList() {} bool SBTypeEnumMember::GetDescription( lldb::SBStream &description, lldb::DescriptionLevel description_level) { + LLDB_RECORD_METHOD(bool, SBTypeEnumMember, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel), description, + description_level); + Stream &strm = description.ref(); if (m_opaque_sp.get()) { diff --git a/lldb/source/API/SBTypeFilter.cpp b/lldb/source/API/SBTypeFilter.cpp index 505affd0d6e..53ae9fd7b95 100644 --- a/lldb/source/API/SBTypeFilter.cpp +++ b/lldb/source/API/SBTypeFilter.cpp @@ -8,6 +8,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBTypeFilter.h" +#include "SBReproducerPrivate.h" #include "lldb/API/SBStream.h" @@ -16,31 +17,49 @@ using namespace lldb; using namespace lldb_private; -SBTypeFilter::SBTypeFilter() : m_opaque_sp() {} +SBTypeFilter::SBTypeFilter() : m_opaque_sp() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeFilter); +} SBTypeFilter::SBTypeFilter(uint32_t options) - : m_opaque_sp(TypeFilterImplSP(new TypeFilterImpl(options))) {} + : m_opaque_sp(TypeFilterImplSP(new TypeFilterImpl(options))) { + LLDB_RECORD_CONSTRUCTOR(SBTypeFilter, (uint32_t), options); +} SBTypeFilter::SBTypeFilter(const lldb::SBTypeFilter &rhs) - : m_opaque_sp(rhs.m_opaque_sp) {} + : m_opaque_sp(rhs.m_opaque_sp) { + LLDB_RECORD_CONSTRUCTOR(SBTypeFilter, (const lldb::SBTypeFilter &), rhs); +} SBTypeFilter::~SBTypeFilter() {} -bool SBTypeFilter::IsValid() const { return m_opaque_sp.get() != NULL; } +bool SBTypeFilter::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFilter, IsValid); + + return m_opaque_sp.get() != NULL; +} uint32_t SBTypeFilter::GetOptions() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeFilter, GetOptions); + if (IsValid()) return m_opaque_sp->GetOptions(); return 0; } void SBTypeFilter::SetOptions(uint32_t value) { + LLDB_RECORD_METHOD(void, SBTypeFilter, SetOptions, (uint32_t), value); + if (CopyOnWrite_Impl()) m_opaque_sp->SetOptions(value); } bool SBTypeFilter::GetDescription(lldb::SBStream &description, lldb::DescriptionLevel description_level) { + LLDB_RECORD_METHOD(bool, SBTypeFilter, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel), description, + description_level); + if (!IsValid()) return false; else { @@ -50,17 +69,25 @@ bool SBTypeFilter::GetDescription(lldb::SBStream &description, } void SBTypeFilter::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBTypeFilter, Clear); + if (CopyOnWrite_Impl()) m_opaque_sp->Clear(); } uint32_t SBTypeFilter::GetNumberOfExpressionPaths() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeFilter, + GetNumberOfExpressionPaths); + if (IsValid()) return m_opaque_sp->GetCount(); return 0; } const char *SBTypeFilter::GetExpressionPathAtIndex(uint32_t i) { + LLDB_RECORD_METHOD(const char *, SBTypeFilter, GetExpressionPathAtIndex, + (uint32_t), i); + if (IsValid()) { const char *item = m_opaque_sp->GetExpressionPathAtIndex(i); if (item && *item == '.') @@ -71,6 +98,9 @@ const char *SBTypeFilter::GetExpressionPathAtIndex(uint32_t i) { } bool SBTypeFilter::ReplaceExpressionPathAtIndex(uint32_t i, const char *item) { + LLDB_RECORD_METHOD(bool, SBTypeFilter, ReplaceExpressionPathAtIndex, + (uint32_t, const char *), i, item); + if (CopyOnWrite_Impl()) return m_opaque_sp->SetExpressionPathAtIndex(i, item); else @@ -78,11 +108,17 @@ bool SBTypeFilter::ReplaceExpressionPathAtIndex(uint32_t i, const char *item) { } void SBTypeFilter::AppendExpressionPath(const char *item) { + LLDB_RECORD_METHOD(void, SBTypeFilter, AppendExpressionPath, (const char *), + item); + if (CopyOnWrite_Impl()) m_opaque_sp->AddExpressionPath(item); } lldb::SBTypeFilter &SBTypeFilter::operator=(const lldb::SBTypeFilter &rhs) { + LLDB_RECORD_METHOD(lldb::SBTypeFilter &, + SBTypeFilter, operator=,(const lldb::SBTypeFilter &), rhs); + if (this != &rhs) { m_opaque_sp = rhs.m_opaque_sp; } @@ -90,6 +126,9 @@ lldb::SBTypeFilter &SBTypeFilter::operator=(const lldb::SBTypeFilter &rhs) { } bool SBTypeFilter::operator==(lldb::SBTypeFilter &rhs) { + LLDB_RECORD_METHOD(bool, SBTypeFilter, operator==,(lldb::SBTypeFilter &), + rhs); + if (!IsValid()) return !rhs.IsValid(); @@ -97,6 +136,9 @@ bool SBTypeFilter::operator==(lldb::SBTypeFilter &rhs) { } bool SBTypeFilter::IsEqualTo(lldb::SBTypeFilter &rhs) { + LLDB_RECORD_METHOD(bool, SBTypeFilter, IsEqualTo, (lldb::SBTypeFilter &), + rhs); + if (!IsValid()) return !rhs.IsValid(); @@ -112,6 +154,9 @@ bool SBTypeFilter::IsEqualTo(lldb::SBTypeFilter &rhs) { } bool SBTypeFilter::operator!=(lldb::SBTypeFilter &rhs) { + LLDB_RECORD_METHOD(bool, SBTypeFilter, operator!=,(lldb::SBTypeFilter &), + rhs); + if (!IsValid()) return !rhs.IsValid(); diff --git a/lldb/source/API/SBTypeFormat.cpp b/lldb/source/API/SBTypeFormat.cpp index cce29ea1ccf..667bca822fb 100644 --- a/lldb/source/API/SBTypeFormat.cpp +++ b/lldb/source/API/SBTypeFormat.cpp @@ -8,6 +8,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBTypeFormat.h" +#include "SBReproducerPrivate.h" #include "lldb/API/SBStream.h" @@ -16,30 +17,48 @@ using namespace lldb; using namespace lldb_private; -SBTypeFormat::SBTypeFormat() : m_opaque_sp() {} +SBTypeFormat::SBTypeFormat() : m_opaque_sp() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeFormat); +} SBTypeFormat::SBTypeFormat(lldb::Format format, uint32_t options) : m_opaque_sp( - TypeFormatImplSP(new TypeFormatImpl_Format(format, options))) {} + TypeFormatImplSP(new TypeFormatImpl_Format(format, options))) { + LLDB_RECORD_CONSTRUCTOR(SBTypeFormat, (lldb::Format, uint32_t), format, + options); +} SBTypeFormat::SBTypeFormat(const char *type, uint32_t options) : m_opaque_sp(TypeFormatImplSP(new TypeFormatImpl_EnumType( - ConstString(type ? type : ""), options))) {} + ConstString(type ? type : ""), options))) { + LLDB_RECORD_CONSTRUCTOR(SBTypeFormat, (const char *, uint32_t), type, + options); +} SBTypeFormat::SBTypeFormat(const lldb::SBTypeFormat &rhs) - : m_opaque_sp(rhs.m_opaque_sp) {} + : m_opaque_sp(rhs.m_opaque_sp) { + LLDB_RECORD_CONSTRUCTOR(SBTypeFormat, (const lldb::SBTypeFormat &), rhs); +} SBTypeFormat::~SBTypeFormat() {} -bool SBTypeFormat::IsValid() const { return m_opaque_sp.get() != NULL; } +bool SBTypeFormat::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFormat, IsValid); + + return m_opaque_sp.get() != NULL; +} lldb::Format SBTypeFormat::GetFormat() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::Format, SBTypeFormat, GetFormat); + if (IsValid() && m_opaque_sp->GetType() == TypeFormatImpl::Type::eTypeFormat) return ((TypeFormatImpl_Format *)m_opaque_sp.get())->GetFormat(); return lldb::eFormatInvalid; } const char *SBTypeFormat::GetTypeName() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeFormat, GetTypeName); + if (IsValid() && m_opaque_sp->GetType() == TypeFormatImpl::Type::eTypeEnum) return ((TypeFormatImpl_EnumType *)m_opaque_sp.get()) ->GetTypeName() @@ -48,29 +67,41 @@ const char *SBTypeFormat::GetTypeName() { } uint32_t SBTypeFormat::GetOptions() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeFormat, GetOptions); + if (IsValid()) return m_opaque_sp->GetOptions(); return 0; } void SBTypeFormat::SetFormat(lldb::Format fmt) { + LLDB_RECORD_METHOD(void, SBTypeFormat, SetFormat, (lldb::Format), fmt); + if (CopyOnWrite_Impl(Type::eTypeFormat)) ((TypeFormatImpl_Format *)m_opaque_sp.get())->SetFormat(fmt); } void SBTypeFormat::SetTypeName(const char *type) { + LLDB_RECORD_METHOD(void, SBTypeFormat, SetTypeName, (const char *), type); + if (CopyOnWrite_Impl(Type::eTypeEnum)) ((TypeFormatImpl_EnumType *)m_opaque_sp.get()) ->SetTypeName(ConstString(type ? type : "")); } void SBTypeFormat::SetOptions(uint32_t value) { + LLDB_RECORD_METHOD(void, SBTypeFormat, SetOptions, (uint32_t), value); + if (CopyOnWrite_Impl(Type::eTypeKeepSame)) m_opaque_sp->SetOptions(value); } bool SBTypeFormat::GetDescription(lldb::SBStream &description, lldb::DescriptionLevel description_level) { + LLDB_RECORD_METHOD(bool, SBTypeFormat, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel), description, + description_level); + if (!IsValid()) return false; else { @@ -80,6 +111,9 @@ bool SBTypeFormat::GetDescription(lldb::SBStream &description, } lldb::SBTypeFormat &SBTypeFormat::operator=(const lldb::SBTypeFormat &rhs) { + LLDB_RECORD_METHOD(lldb::SBTypeFormat &, + SBTypeFormat, operator=,(const lldb::SBTypeFormat &), rhs); + if (this != &rhs) { m_opaque_sp = rhs.m_opaque_sp; } @@ -87,12 +121,18 @@ lldb::SBTypeFormat &SBTypeFormat::operator=(const lldb::SBTypeFormat &rhs) { } bool SBTypeFormat::operator==(lldb::SBTypeFormat &rhs) { + LLDB_RECORD_METHOD(bool, SBTypeFormat, operator==,(lldb::SBTypeFormat &), + rhs); + if (!IsValid()) return !rhs.IsValid(); return m_opaque_sp == rhs.m_opaque_sp; } bool SBTypeFormat::IsEqualTo(lldb::SBTypeFormat &rhs) { + LLDB_RECORD_METHOD(bool, SBTypeFormat, IsEqualTo, (lldb::SBTypeFormat &), + rhs); + if (!IsValid()) return !rhs.IsValid(); @@ -103,6 +143,9 @@ bool SBTypeFormat::IsEqualTo(lldb::SBTypeFormat &rhs) { } bool SBTypeFormat::operator!=(lldb::SBTypeFormat &rhs) { + LLDB_RECORD_METHOD(bool, SBTypeFormat, operator!=,(lldb::SBTypeFormat &), + rhs); + if (!IsValid()) return !rhs.IsValid(); return m_opaque_sp != rhs.m_opaque_sp; diff --git a/lldb/source/API/SBTypeNameSpecifier.cpp b/lldb/source/API/SBTypeNameSpecifier.cpp index 48e1e1e221f..6f6d59e08de 100644 --- a/lldb/source/API/SBTypeNameSpecifier.cpp +++ b/lldb/source/API/SBTypeNameSpecifier.cpp @@ -8,6 +8,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBTypeNameSpecifier.h" +#include "SBReproducerPrivate.h" #include "lldb/API/SBStream.h" #include "lldb/API/SBType.h" @@ -17,28 +18,44 @@ using namespace lldb; using namespace lldb_private; -SBTypeNameSpecifier::SBTypeNameSpecifier() : m_opaque_sp() {} +SBTypeNameSpecifier::SBTypeNameSpecifier() : m_opaque_sp() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeNameSpecifier); +} SBTypeNameSpecifier::SBTypeNameSpecifier(const char *name, bool is_regex) : m_opaque_sp(new TypeNameSpecifierImpl(name, is_regex)) { + LLDB_RECORD_CONSTRUCTOR(SBTypeNameSpecifier, (const char *, bool), name, + is_regex); + if (name == NULL || (*name) == 0) m_opaque_sp.reset(); } SBTypeNameSpecifier::SBTypeNameSpecifier(SBType type) : m_opaque_sp() { + LLDB_RECORD_CONSTRUCTOR(SBTypeNameSpecifier, (lldb::SBType), type); + if (type.IsValid()) m_opaque_sp = TypeNameSpecifierImplSP( new TypeNameSpecifierImpl(type.m_opaque_sp->GetCompilerType(true))); } SBTypeNameSpecifier::SBTypeNameSpecifier(const lldb::SBTypeNameSpecifier &rhs) - : m_opaque_sp(rhs.m_opaque_sp) {} + : m_opaque_sp(rhs.m_opaque_sp) { + LLDB_RECORD_CONSTRUCTOR(SBTypeNameSpecifier, + (const lldb::SBTypeNameSpecifier &), rhs); +} SBTypeNameSpecifier::~SBTypeNameSpecifier() {} -bool SBTypeNameSpecifier::IsValid() const { return m_opaque_sp.get() != NULL; } +bool SBTypeNameSpecifier::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeNameSpecifier, IsValid); + + return m_opaque_sp.get() != NULL; +} const char *SBTypeNameSpecifier::GetName() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeNameSpecifier, GetName); + if (!IsValid()) return NULL; @@ -46,15 +63,19 @@ const char *SBTypeNameSpecifier::GetName() { } SBType SBTypeNameSpecifier::GetType() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeNameSpecifier, GetType); + if (!IsValid()) - return SBType(); + return LLDB_RECORD_RESULT(SBType()); lldb_private::CompilerType c_type = m_opaque_sp->GetCompilerType(); if (c_type.IsValid()) - return SBType(c_type); - return SBType(); + return LLDB_RECORD_RESULT(SBType(c_type)); + return LLDB_RECORD_RESULT(SBType()); } bool SBTypeNameSpecifier::IsRegex() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeNameSpecifier, IsRegex); + if (!IsValid()) return false; @@ -63,6 +84,10 @@ bool SBTypeNameSpecifier::IsRegex() { bool SBTypeNameSpecifier::GetDescription( lldb::SBStream &description, lldb::DescriptionLevel description_level) { + LLDB_RECORD_METHOD(bool, SBTypeNameSpecifier, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel), description, + description_level); + if (!IsValid()) return false; description.Printf("SBTypeNameSpecifier(%s,%s)", GetName(), @@ -72,6 +97,10 @@ bool SBTypeNameSpecifier::GetDescription( lldb::SBTypeNameSpecifier &SBTypeNameSpecifier:: operator=(const lldb::SBTypeNameSpecifier &rhs) { + LLDB_RECORD_METHOD( + lldb::SBTypeNameSpecifier &, + SBTypeNameSpecifier, operator=,(const lldb::SBTypeNameSpecifier &), rhs); + if (this != &rhs) { m_opaque_sp = rhs.m_opaque_sp; } @@ -79,12 +108,18 @@ operator=(const lldb::SBTypeNameSpecifier &rhs) { } bool SBTypeNameSpecifier::operator==(lldb::SBTypeNameSpecifier &rhs) { + LLDB_RECORD_METHOD( + bool, SBTypeNameSpecifier, operator==,(lldb::SBTypeNameSpecifier &), rhs); + if (!IsValid()) return !rhs.IsValid(); return m_opaque_sp == rhs.m_opaque_sp; } bool SBTypeNameSpecifier::IsEqualTo(lldb::SBTypeNameSpecifier &rhs) { + LLDB_RECORD_METHOD(bool, SBTypeNameSpecifier, IsEqualTo, + (lldb::SBTypeNameSpecifier &), rhs); + if (!IsValid()) return !rhs.IsValid(); @@ -97,6 +132,9 @@ bool SBTypeNameSpecifier::IsEqualTo(lldb::SBTypeNameSpecifier &rhs) { } bool SBTypeNameSpecifier::operator!=(lldb::SBTypeNameSpecifier &rhs) { + LLDB_RECORD_METHOD( + bool, SBTypeNameSpecifier, operator!=,(lldb::SBTypeNameSpecifier &), rhs); + if (!IsValid()) return !rhs.IsValid(); return m_opaque_sp != rhs.m_opaque_sp; diff --git a/lldb/source/API/SBTypeSummary.cpp b/lldb/source/API/SBTypeSummary.cpp index 349bfd06b9b..02002a19106 100644 --- a/lldb/source/API/SBTypeSummary.cpp +++ b/lldb/source/API/SBTypeSummary.cpp @@ -8,6 +8,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBTypeSummary.h" +#include "SBReproducerPrivate.h" #include "Utils.h" #include "lldb/API/SBStream.h" #include "lldb/API/SBValue.h" @@ -18,36 +19,58 @@ using namespace lldb; using namespace lldb_private; -SBTypeSummaryOptions::SBTypeSummaryOptions() - : m_opaque_up(new TypeSummaryOptions()) {} +SBTypeSummaryOptions::SBTypeSummaryOptions() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeSummaryOptions); + + m_opaque_up.reset(new TypeSummaryOptions()); +} SBTypeSummaryOptions::SBTypeSummaryOptions( const lldb::SBTypeSummaryOptions &rhs) { + LLDB_RECORD_CONSTRUCTOR(SBTypeSummaryOptions, + (const lldb::SBTypeSummaryOptions &), rhs); + m_opaque_up = clone(rhs.m_opaque_up); } SBTypeSummaryOptions::~SBTypeSummaryOptions() {} -bool SBTypeSummaryOptions::IsValid() { return m_opaque_up.get(); } +bool SBTypeSummaryOptions::IsValid() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummaryOptions, IsValid); + + return m_opaque_up.get(); +} lldb::LanguageType SBTypeSummaryOptions::GetLanguage() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::LanguageType, SBTypeSummaryOptions, + GetLanguage); + if (IsValid()) return m_opaque_up->GetLanguage(); return lldb::eLanguageTypeUnknown; } lldb::TypeSummaryCapping SBTypeSummaryOptions::GetCapping() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::TypeSummaryCapping, SBTypeSummaryOptions, + GetCapping); + if (IsValid()) return m_opaque_up->GetCapping(); return eTypeSummaryCapped; } void SBTypeSummaryOptions::SetLanguage(lldb::LanguageType l) { + LLDB_RECORD_METHOD(void, SBTypeSummaryOptions, SetLanguage, + (lldb::LanguageType), l); + if (IsValid()) m_opaque_up->SetLanguage(l); } void SBTypeSummaryOptions::SetCapping(lldb::TypeSummaryCapping c) { + LLDB_RECORD_METHOD(void, SBTypeSummaryOptions, SetCapping, + (lldb::TypeSummaryCapping), c); + if (IsValid()) m_opaque_up->SetCapping(c); } @@ -75,6 +98,10 @@ const lldb_private::TypeSummaryOptions &SBTypeSummaryOptions::ref() const { SBTypeSummaryOptions::SBTypeSummaryOptions( const lldb_private::TypeSummaryOptions *lldb_object_ptr) { + LLDB_RECORD_CONSTRUCTOR(SBTypeSummaryOptions, + (const lldb_private::TypeSummaryOptions *), + lldb_object_ptr); + SetOptions(lldb_object_ptr); } @@ -86,33 +113,47 @@ void SBTypeSummaryOptions::SetOptions( m_opaque_up.reset(new TypeSummaryOptions()); } -SBTypeSummary::SBTypeSummary() : m_opaque_sp() {} +SBTypeSummary::SBTypeSummary() : m_opaque_sp() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeSummary); +} SBTypeSummary SBTypeSummary::CreateWithSummaryString(const char *data, uint32_t options) { + LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary, + CreateWithSummaryString, (const char *, uint32_t), + data, options); + if (!data || data[0] == 0) - return SBTypeSummary(); + return LLDB_RECORD_RESULT(SBTypeSummary()); - return SBTypeSummary( - TypeSummaryImplSP(new StringSummaryFormat(options, data))); + return LLDB_RECORD_RESULT( + SBTypeSummary(TypeSummaryImplSP(new StringSummaryFormat(options, data)))); } SBTypeSummary SBTypeSummary::CreateWithFunctionName(const char *data, uint32_t options) { + LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary, + CreateWithFunctionName, (const char *, uint32_t), + data, options); + if (!data || data[0] == 0) - return SBTypeSummary(); + return LLDB_RECORD_RESULT(SBTypeSummary()); - return SBTypeSummary( - TypeSummaryImplSP(new ScriptSummaryFormat(options, data))); + return LLDB_RECORD_RESULT( + SBTypeSummary(TypeSummaryImplSP(new ScriptSummaryFormat(options, data)))); } SBTypeSummary SBTypeSummary::CreateWithScriptCode(const char *data, uint32_t options) { + LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary, + CreateWithScriptCode, (const char *, uint32_t), + data, options); + if (!data || data[0] == 0) - return SBTypeSummary(); + return LLDB_RECORD_RESULT(SBTypeSummary()); - return SBTypeSummary( - TypeSummaryImplSP(new ScriptSummaryFormat(options, "", data))); + return LLDB_RECORD_RESULT(SBTypeSummary( + TypeSummaryImplSP(new ScriptSummaryFormat(options, "", data)))); } SBTypeSummary SBTypeSummary::CreateWithCallback(FormatCallback cb, @@ -139,13 +180,21 @@ SBTypeSummary SBTypeSummary::CreateWithCallback(FormatCallback cb, } SBTypeSummary::SBTypeSummary(const lldb::SBTypeSummary &rhs) - : m_opaque_sp(rhs.m_opaque_sp) {} + : m_opaque_sp(rhs.m_opaque_sp) { + LLDB_RECORD_CONSTRUCTOR(SBTypeSummary, (const lldb::SBTypeSummary &), rhs); +} SBTypeSummary::~SBTypeSummary() {} -bool SBTypeSummary::IsValid() const { return m_opaque_sp.get() != NULL; } +bool SBTypeSummary::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSummary, IsValid); + + return m_opaque_sp.get() != NULL; +} bool SBTypeSummary::IsFunctionCode() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummary, IsFunctionCode); + if (!IsValid()) return false; if (ScriptSummaryFormat *script_summary_ptr = @@ -157,6 +206,8 @@ bool SBTypeSummary::IsFunctionCode() { } bool SBTypeSummary::IsFunctionName() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummary, IsFunctionName); + if (!IsValid()) return false; if (ScriptSummaryFormat *script_summary_ptr = @@ -168,6 +219,8 @@ bool SBTypeSummary::IsFunctionName() { } bool SBTypeSummary::IsSummaryString() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummary, IsSummaryString); + if (!IsValid()) return false; @@ -175,6 +228,8 @@ bool SBTypeSummary::IsSummaryString() { } const char *SBTypeSummary::GetData() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeSummary, GetData); + if (!IsValid()) return NULL; if (ScriptSummaryFormat *script_summary_ptr = @@ -191,18 +246,25 @@ const char *SBTypeSummary::GetData() { } uint32_t SBTypeSummary::GetOptions() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeSummary, GetOptions); + if (!IsValid()) return lldb::eTypeOptionNone; return m_opaque_sp->GetOptions(); } void SBTypeSummary::SetOptions(uint32_t value) { + LLDB_RECORD_METHOD(void, SBTypeSummary, SetOptions, (uint32_t), value); + if (!CopyOnWrite_Impl()) return; m_opaque_sp->SetOptions(value); } void SBTypeSummary::SetSummaryString(const char *data) { + LLDB_RECORD_METHOD(void, SBTypeSummary, SetSummaryString, (const char *), + data); + if (!IsValid()) return; if (!llvm::isa<StringSummaryFormat>(m_opaque_sp.get())) @@ -213,6 +275,9 @@ void SBTypeSummary::SetSummaryString(const char *data) { } void SBTypeSummary::SetFunctionName(const char *data) { + LLDB_RECORD_METHOD(void, SBTypeSummary, SetFunctionName, (const char *), + data); + if (!IsValid()) return; if (!llvm::isa<ScriptSummaryFormat>(m_opaque_sp.get())) @@ -223,6 +288,9 @@ void SBTypeSummary::SetFunctionName(const char *data) { } void SBTypeSummary::SetFunctionCode(const char *data) { + LLDB_RECORD_METHOD(void, SBTypeSummary, SetFunctionCode, (const char *), + data); + if (!IsValid()) return; if (!llvm::isa<ScriptSummaryFormat>(m_opaque_sp.get())) @@ -234,6 +302,10 @@ void SBTypeSummary::SetFunctionCode(const char *data) { bool SBTypeSummary::GetDescription(lldb::SBStream &description, lldb::DescriptionLevel description_level) { + LLDB_RECORD_METHOD(bool, SBTypeSummary, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel), description, + description_level); + if (!CopyOnWrite_Impl()) return false; else { @@ -243,6 +315,9 @@ bool SBTypeSummary::GetDescription(lldb::SBStream &description, } bool SBTypeSummary::DoesPrintValue(lldb::SBValue value) { + LLDB_RECORD_METHOD(bool, SBTypeSummary, DoesPrintValue, (lldb::SBValue), + value); + if (!IsValid()) return false; lldb::ValueObjectSP value_sp = value.GetSP(); @@ -250,6 +325,10 @@ bool SBTypeSummary::DoesPrintValue(lldb::SBValue value) { } lldb::SBTypeSummary &SBTypeSummary::operator=(const lldb::SBTypeSummary &rhs) { + LLDB_RECORD_METHOD(lldb::SBTypeSummary &, + SBTypeSummary, operator=,(const lldb::SBTypeSummary &), + rhs); + if (this != &rhs) { m_opaque_sp = rhs.m_opaque_sp; } @@ -257,12 +336,18 @@ lldb::SBTypeSummary &SBTypeSummary::operator=(const lldb::SBTypeSummary &rhs) { } bool SBTypeSummary::operator==(lldb::SBTypeSummary &rhs) { + LLDB_RECORD_METHOD(bool, SBTypeSummary, operator==,(lldb::SBTypeSummary &), + rhs); + if (!IsValid()) return !rhs.IsValid(); return m_opaque_sp == rhs.m_opaque_sp; } bool SBTypeSummary::IsEqualTo(lldb::SBTypeSummary &rhs) { + LLDB_RECORD_METHOD(bool, SBTypeSummary, IsEqualTo, (lldb::SBTypeSummary &), + rhs); + if (IsValid()) { // valid and invalid are different if (!rhs.IsValid()) @@ -301,6 +386,9 @@ bool SBTypeSummary::IsEqualTo(lldb::SBTypeSummary &rhs) { } bool SBTypeSummary::operator!=(lldb::SBTypeSummary &rhs) { + LLDB_RECORD_METHOD(bool, SBTypeSummary, operator!=,(lldb::SBTypeSummary &), + rhs); + if (!IsValid()) return !rhs.IsValid(); return m_opaque_sp != rhs.m_opaque_sp; diff --git a/lldb/source/API/SBTypeSynthetic.cpp b/lldb/source/API/SBTypeSynthetic.cpp index e9a68c60338..1c6625e8dd7 100644 --- a/lldb/source/API/SBTypeSynthetic.cpp +++ b/lldb/source/API/SBTypeSynthetic.cpp @@ -8,6 +8,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBTypeSynthetic.h" +#include "SBReproducerPrivate.h" #include "lldb/API/SBStream.h" @@ -18,32 +19,51 @@ using namespace lldb_private; #ifndef LLDB_DISABLE_PYTHON -SBTypeSynthetic::SBTypeSynthetic() : m_opaque_sp() {} +SBTypeSynthetic::SBTypeSynthetic() : m_opaque_sp() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeSynthetic); +} SBTypeSynthetic SBTypeSynthetic::CreateWithClassName(const char *data, uint32_t options) { + LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSynthetic, SBTypeSynthetic, + CreateWithClassName, (const char *, uint32_t), data, + options); + if (!data || data[0] == 0) - return SBTypeSynthetic(); - return SBTypeSynthetic(ScriptedSyntheticChildrenSP( - new ScriptedSyntheticChildren(options, data, ""))); + return LLDB_RECORD_RESULT(SBTypeSynthetic()); + return LLDB_RECORD_RESULT(SBTypeSynthetic(ScriptedSyntheticChildrenSP( + new ScriptedSyntheticChildren(options, data, "")))); } SBTypeSynthetic SBTypeSynthetic::CreateWithScriptCode(const char *data, uint32_t options) { + LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSynthetic, SBTypeSynthetic, + CreateWithScriptCode, (const char *, uint32_t), + data, options); + if (!data || data[0] == 0) - return SBTypeSynthetic(); - return SBTypeSynthetic(ScriptedSyntheticChildrenSP( - new ScriptedSyntheticChildren(options, "", data))); + return LLDB_RECORD_RESULT(SBTypeSynthetic()); + return LLDB_RECORD_RESULT(SBTypeSynthetic(ScriptedSyntheticChildrenSP( + new ScriptedSyntheticChildren(options, "", data)))); } SBTypeSynthetic::SBTypeSynthetic(const lldb::SBTypeSynthetic &rhs) - : m_opaque_sp(rhs.m_opaque_sp) {} + : m_opaque_sp(rhs.m_opaque_sp) { + LLDB_RECORD_CONSTRUCTOR(SBTypeSynthetic, (const lldb::SBTypeSynthetic &), + rhs); +} SBTypeSynthetic::~SBTypeSynthetic() {} -bool SBTypeSynthetic::IsValid() const { return m_opaque_sp.get() != NULL; } +bool SBTypeSynthetic::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSynthetic, IsValid); + + return m_opaque_sp.get() != NULL; +} bool SBTypeSynthetic::IsClassCode() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSynthetic, IsClassCode); + if (!IsValid()) return false; const char *code = m_opaque_sp->GetPythonCode(); @@ -51,12 +71,16 @@ bool SBTypeSynthetic::IsClassCode() { } bool SBTypeSynthetic::IsClassName() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSynthetic, IsClassName); + if (!IsValid()) return false; return !IsClassCode(); } const char *SBTypeSynthetic::GetData() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeSynthetic, GetData); + if (!IsValid()) return NULL; if (IsClassCode()) @@ -66,22 +90,30 @@ const char *SBTypeSynthetic::GetData() { } void SBTypeSynthetic::SetClassName(const char *data) { + LLDB_RECORD_METHOD(void, SBTypeSynthetic, SetClassName, (const char *), data); + if (IsValid() && data && *data) m_opaque_sp->SetPythonClassName(data); } void SBTypeSynthetic::SetClassCode(const char *data) { + LLDB_RECORD_METHOD(void, SBTypeSynthetic, SetClassCode, (const char *), data); + if (IsValid() && data && *data) m_opaque_sp->SetPythonCode(data); } uint32_t SBTypeSynthetic::GetOptions() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeSynthetic, GetOptions); + if (!IsValid()) return lldb::eTypeOptionNone; return m_opaque_sp->GetOptions(); } void SBTypeSynthetic::SetOptions(uint32_t value) { + LLDB_RECORD_METHOD(void, SBTypeSynthetic, SetOptions, (uint32_t), value); + if (!CopyOnWrite_Impl()) return; m_opaque_sp->SetOptions(value); @@ -89,6 +121,10 @@ void SBTypeSynthetic::SetOptions(uint32_t value) { bool SBTypeSynthetic::GetDescription(lldb::SBStream &description, lldb::DescriptionLevel description_level) { + LLDB_RECORD_METHOD(bool, SBTypeSynthetic, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel), description, + description_level); + if (m_opaque_sp) { description.Printf("%s\n", m_opaque_sp->GetDescription().c_str()); return true; @@ -98,6 +134,10 @@ bool SBTypeSynthetic::GetDescription(lldb::SBStream &description, lldb::SBTypeSynthetic &SBTypeSynthetic:: operator=(const lldb::SBTypeSynthetic &rhs) { + LLDB_RECORD_METHOD(lldb::SBTypeSynthetic &, + SBTypeSynthetic, operator=,(const lldb::SBTypeSynthetic &), + rhs); + if (this != &rhs) { m_opaque_sp = rhs.m_opaque_sp; } @@ -105,12 +145,18 @@ operator=(const lldb::SBTypeSynthetic &rhs) { } bool SBTypeSynthetic::operator==(lldb::SBTypeSynthetic &rhs) { + LLDB_RECORD_METHOD( + bool, SBTypeSynthetic, operator==,(lldb::SBTypeSynthetic &), rhs); + if (!IsValid()) return !rhs.IsValid(); return m_opaque_sp == rhs.m_opaque_sp; } bool SBTypeSynthetic::IsEqualTo(lldb::SBTypeSynthetic &rhs) { + LLDB_RECORD_METHOD(bool, SBTypeSynthetic, IsEqualTo, + (lldb::SBTypeSynthetic &), rhs); + if (!IsValid()) return !rhs.IsValid(); @@ -127,6 +173,9 @@ bool SBTypeSynthetic::IsEqualTo(lldb::SBTypeSynthetic &rhs) { } bool SBTypeSynthetic::operator!=(lldb::SBTypeSynthetic &rhs) { + LLDB_RECORD_METHOD( + bool, SBTypeSynthetic, operator!=,(lldb::SBTypeSynthetic &), rhs); + if (!IsValid()) return !rhs.IsValid(); return m_opaque_sp != rhs.m_opaque_sp; diff --git a/lldb/source/API/SBUnixSignals.cpp b/lldb/source/API/SBUnixSignals.cpp index 88fefcfab7d..318c0fc59e6 100644 --- a/lldb/source/API/SBUnixSignals.cpp +++ b/lldb/source/API/SBUnixSignals.cpp @@ -7,6 +7,7 @@ // //===----------------------------------------------------------------------===// +#include "SBReproducerPrivate.h" #include "lldb/Target/Platform.h" #include "lldb/Target/Process.h" #include "lldb/Target/UnixSignals.h" @@ -18,10 +19,14 @@ using namespace lldb; using namespace lldb_private; -SBUnixSignals::SBUnixSignals() {} +SBUnixSignals::SBUnixSignals() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBUnixSignals); +} SBUnixSignals::SBUnixSignals(const SBUnixSignals &rhs) - : m_opaque_wp(rhs.m_opaque_wp) {} + : m_opaque_wp(rhs.m_opaque_wp) { + LLDB_RECORD_CONSTRUCTOR(SBUnixSignals, (const lldb::SBUnixSignals &), rhs); +} SBUnixSignals::SBUnixSignals(ProcessSP &process_sp) : m_opaque_wp(process_sp ? process_sp->GetUnixSignals() : nullptr) {} @@ -30,6 +35,10 @@ SBUnixSignals::SBUnixSignals(PlatformSP &platform_sp) : m_opaque_wp(platform_sp ? platform_sp->GetUnixSignals() : nullptr) {} const SBUnixSignals &SBUnixSignals::operator=(const SBUnixSignals &rhs) { + LLDB_RECORD_METHOD(const lldb::SBUnixSignals &, + SBUnixSignals, operator=,(const lldb::SBUnixSignals &), + rhs); + if (this != &rhs) m_opaque_wp = rhs.m_opaque_wp; return *this; @@ -43,11 +52,22 @@ void SBUnixSignals::SetSP(const UnixSignalsSP &signals_sp) { m_opaque_wp = signals_sp; } -void SBUnixSignals::Clear() { m_opaque_wp.reset(); } +void SBUnixSignals::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBUnixSignals, Clear); + + m_opaque_wp.reset(); +} -bool SBUnixSignals::IsValid() const { return static_cast<bool>(GetSP()); } +bool SBUnixSignals::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBUnixSignals, IsValid); + + return static_cast<bool>(GetSP()); +} const char *SBUnixSignals::GetSignalAsCString(int32_t signo) const { + LLDB_RECORD_METHOD_CONST(const char *, SBUnixSignals, GetSignalAsCString, + (int32_t), signo); + if (auto signals_sp = GetSP()) return signals_sp->GetSignalAsCString(signo); @@ -55,6 +75,9 @@ const char *SBUnixSignals::GetSignalAsCString(int32_t signo) const { } int32_t SBUnixSignals::GetSignalNumberFromName(const char *name) const { + LLDB_RECORD_METHOD_CONST(int32_t, SBUnixSignals, GetSignalNumberFromName, + (const char *), name); + if (auto signals_sp = GetSP()) return signals_sp->GetSignalNumberFromName(name); @@ -62,6 +85,9 @@ int32_t SBUnixSignals::GetSignalNumberFromName(const char *name) const { } bool SBUnixSignals::GetShouldSuppress(int32_t signo) const { + LLDB_RECORD_METHOD_CONST(bool, SBUnixSignals, GetShouldSuppress, (int32_t), + signo); + if (auto signals_sp = GetSP()) return signals_sp->GetShouldSuppress(signo); @@ -69,6 +95,9 @@ bool SBUnixSignals::GetShouldSuppress(int32_t signo) const { } bool SBUnixSignals::SetShouldSuppress(int32_t signo, bool value) { + LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldSuppress, (int32_t, bool), + signo, value); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); auto signals_sp = GetSP(); @@ -84,6 +113,9 @@ bool SBUnixSignals::SetShouldSuppress(int32_t signo, bool value) { } bool SBUnixSignals::GetShouldStop(int32_t signo) const { + LLDB_RECORD_METHOD_CONST(bool, SBUnixSignals, GetShouldStop, (int32_t), + signo); + if (auto signals_sp = GetSP()) return signals_sp->GetShouldStop(signo); @@ -91,6 +123,9 @@ bool SBUnixSignals::GetShouldStop(int32_t signo) const { } bool SBUnixSignals::SetShouldStop(int32_t signo, bool value) { + LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldStop, (int32_t, bool), signo, + value); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); auto signals_sp = GetSP(); @@ -106,6 +141,9 @@ bool SBUnixSignals::SetShouldStop(int32_t signo, bool value) { } bool SBUnixSignals::GetShouldNotify(int32_t signo) const { + LLDB_RECORD_METHOD_CONST(bool, SBUnixSignals, GetShouldNotify, (int32_t), + signo); + if (auto signals_sp = GetSP()) return signals_sp->GetShouldNotify(signo); @@ -113,6 +151,9 @@ bool SBUnixSignals::GetShouldNotify(int32_t signo) const { } bool SBUnixSignals::SetShouldNotify(int32_t signo, bool value) { + LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldNotify, (int32_t, bool), + signo, value); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); auto signals_sp = GetSP(); @@ -128,6 +169,8 @@ bool SBUnixSignals::SetShouldNotify(int32_t signo, bool value) { } int32_t SBUnixSignals::GetNumSignals() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(int32_t, SBUnixSignals, GetNumSignals); + if (auto signals_sp = GetSP()) return signals_sp->GetNumSignals(); @@ -135,6 +178,9 @@ int32_t SBUnixSignals::GetNumSignals() const { } int32_t SBUnixSignals::GetSignalAtIndex(int32_t index) const { + LLDB_RECORD_METHOD_CONST(int32_t, SBUnixSignals, GetSignalAtIndex, (int32_t), + index); + if (auto signals_sp = GetSP()) return signals_sp->GetSignalAtIndex(index); diff --git a/lldb/source/API/SBValue.cpp b/lldb/source/API/SBValue.cpp index 439c55e603c..87bdd1de0d0 100644 --- a/lldb/source/API/SBValue.cpp +++ b/lldb/source/API/SBValue.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBValue.h" +#include "SBReproducerPrivate.h" #include "lldb/API/SBDeclaration.h" #include "lldb/API/SBStream.h" @@ -219,13 +220,24 @@ private: Status m_lock_error; }; -SBValue::SBValue() : m_opaque_sp() {} +SBValue::SBValue() : m_opaque_sp() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBValue); } -SBValue::SBValue(const lldb::ValueObjectSP &value_sp) { SetSP(value_sp); } +SBValue::SBValue(const lldb::ValueObjectSP &value_sp) { + LLDB_RECORD_CONSTRUCTOR(SBValue, (const lldb::ValueObjectSP &), value_sp); -SBValue::SBValue(const SBValue &rhs) { SetSP(rhs.m_opaque_sp); } + SetSP(value_sp); +} + +SBValue::SBValue(const SBValue &rhs) { + LLDB_RECORD_CONSTRUCTOR(SBValue, (const lldb::SBValue &), rhs); + + SetSP(rhs.m_opaque_sp); +} SBValue &SBValue::operator=(const SBValue &rhs) { + LLDB_RECORD_METHOD(lldb::SBValue &, + SBValue, operator=,(const lldb::SBValue &), rhs); + if (this != &rhs) { SetSP(rhs.m_opaque_sp); } @@ -235,6 +247,8 @@ SBValue &SBValue::operator=(const SBValue &rhs) { SBValue::~SBValue() {} bool SBValue::IsValid() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsValid); + // If this function ever changes to anything that does more than just check // if the opaque shared pointer is non NULL, then we need to update all "if // (m_opaque_sp)" code in this file. @@ -242,9 +256,15 @@ bool SBValue::IsValid() { m_opaque_sp->GetRootSP().get() != NULL; } -void SBValue::Clear() { m_opaque_sp.reset(); } +void SBValue::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBValue, Clear); + + m_opaque_sp.reset(); +} SBError SBValue::GetError() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBValue, GetError); + SBError sb_error; ValueLocker locker; @@ -255,10 +275,12 @@ SBError SBValue::GetError() { sb_error.SetErrorStringWithFormat("error: %s", locker.GetError().AsCString()); - return sb_error; + return LLDB_RECORD_RESULT(sb_error); } user_id_t SBValue::GetID() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::user_id_t, SBValue, GetID); + ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); if (value_sp) @@ -267,6 +289,8 @@ user_id_t SBValue::GetID() { } const char *SBValue::GetName() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetName); + const char *name = NULL; ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -287,6 +311,8 @@ const char *SBValue::GetName() { } const char *SBValue::GetTypeName() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetTypeName); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); const char *name = NULL; ValueLocker locker; @@ -308,6 +334,8 @@ const char *SBValue::GetTypeName() { } const char *SBValue::GetDisplayTypeName() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetDisplayTypeName); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); const char *name = NULL; ValueLocker locker; @@ -329,6 +357,8 @@ const char *SBValue::GetDisplayTypeName() { } size_t SBValue::GetByteSize() { + LLDB_RECORD_METHOD_NO_ARGS(size_t, SBValue, GetByteSize); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); size_t result = 0; @@ -347,6 +377,8 @@ size_t SBValue::GetByteSize() { } bool SBValue::IsInScope() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsInScope); + bool result = false; ValueLocker locker; @@ -364,6 +396,8 @@ bool SBValue::IsInScope() { } const char *SBValue::GetValue() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetValue); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); const char *cstr = NULL; @@ -385,6 +419,8 @@ const char *SBValue::GetValue() { } ValueType SBValue::GetValueType() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::ValueType, SBValue, GetValueType); + ValueType result = eValueTypeInvalid; ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -437,6 +473,8 @@ ValueType SBValue::GetValueType() { } const char *SBValue::GetObjectDescription() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetObjectDescription); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); const char *cstr = NULL; ValueLocker locker; @@ -456,6 +494,8 @@ const char *SBValue::GetObjectDescription() { } const char *SBValue::GetTypeValidatorResult() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetTypeValidatorResult); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); const char *cstr = NULL; ValueLocker locker; @@ -481,6 +521,8 @@ const char *SBValue::GetTypeValidatorResult() { } SBType SBValue::GetType() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBValue, GetType); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBType sb_type; ValueLocker locker; @@ -499,10 +541,12 @@ SBType SBValue::GetType() { log->Printf("SBValue(%p)::GetType => NULL", static_cast<void *>(value_sp.get())); } - return sb_type; + return LLDB_RECORD_RESULT(sb_type); } bool SBValue::GetValueDidChange() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, GetValueDidChange); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); bool result = false; ValueLocker locker; @@ -519,6 +563,8 @@ bool SBValue::GetValueDidChange() { } const char *SBValue::GetSummary() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetSummary); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); const char *cstr = NULL; ValueLocker locker; @@ -539,6 +585,10 @@ const char *SBValue::GetSummary() { const char *SBValue::GetSummary(lldb::SBStream &stream, lldb::SBTypeSummaryOptions &options) { + LLDB_RECORD_METHOD(const char *, SBValue, GetSummary, + (lldb::SBStream &, lldb::SBTypeSummaryOptions &), stream, + options); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -560,6 +610,8 @@ const char *SBValue::GetSummary(lldb::SBStream &stream, } const char *SBValue::GetLocation() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetLocation); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); const char *cstr = NULL; ValueLocker locker; @@ -580,11 +632,17 @@ const char *SBValue::GetLocation() { // Deprecated - use the one that takes an lldb::SBError bool SBValue::SetValueFromCString(const char *value_str) { + LLDB_RECORD_METHOD(bool, SBValue, SetValueFromCString, (const char *), + value_str); + lldb::SBError dummy; return SetValueFromCString(value_str, dummy); } bool SBValue::SetValueFromCString(const char *value_str, lldb::SBError &error) { + LLDB_RECORD_METHOD(bool, SBValue, SetValueFromCString, + (const char *, lldb::SBError &), value_str, error); + bool success = false; ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -603,6 +661,8 @@ bool SBValue::SetValueFromCString(const char *value_str, lldb::SBError &error) { } lldb::SBTypeFormat SBValue::GetTypeFormat() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeFormat, SBValue, GetTypeFormat); + lldb::SBTypeFormat format; ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -613,10 +673,12 @@ lldb::SBTypeFormat SBValue::GetTypeFormat() { format.SetSP(format_sp); } } - return format; + return LLDB_RECORD_RESULT(format); } lldb::SBTypeSummary SBValue::GetTypeSummary() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeSummary, SBValue, GetTypeSummary); + lldb::SBTypeSummary summary; ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -627,10 +689,12 @@ lldb::SBTypeSummary SBValue::GetTypeSummary() { summary.SetSP(summary_sp); } } - return summary; + return LLDB_RECORD_RESULT(summary); } lldb::SBTypeFilter SBValue::GetTypeFilter() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeFilter, SBValue, GetTypeFilter); + lldb::SBTypeFilter filter; ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -645,11 +709,13 @@ lldb::SBTypeFilter SBValue::GetTypeFilter() { } } } - return filter; + return LLDB_RECORD_RESULT(filter); } #ifndef LLDB_DISABLE_PYTHON lldb::SBTypeSynthetic SBValue::GetTypeSynthetic() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeSynthetic, SBValue, GetTypeSynthetic); + lldb::SBTypeSynthetic synthetic; ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -664,12 +730,16 @@ lldb::SBTypeSynthetic SBValue::GetTypeSynthetic() { } } } - return synthetic; + return LLDB_RECORD_RESULT(synthetic); } #endif lldb::SBValue SBValue::CreateChildAtOffset(const char *name, uint32_t offset, SBType type) { + LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateChildAtOffset, + (const char *, uint32_t, lldb::SBType), name, offset, + type); + lldb::SBValue sb_value; ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -692,10 +762,12 @@ lldb::SBValue SBValue::CreateChildAtOffset(const char *name, uint32_t offset, log->Printf("SBValue(%p)::CreateChildAtOffset => NULL", static_cast<void *>(value_sp.get())); } - return sb_value; + return LLDB_RECORD_RESULT(sb_value); } lldb::SBValue SBValue::Cast(SBType type) { + LLDB_RECORD_METHOD(lldb::SBValue, SBValue, Cast, (lldb::SBType), type); + lldb::SBValue sb_value; ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -703,19 +775,27 @@ lldb::SBValue SBValue::Cast(SBType type) { if (value_sp && type_sp) sb_value.SetSP(value_sp->Cast(type_sp->GetCompilerType(false)), GetPreferDynamicValue(), GetPreferSyntheticValue()); - return sb_value; + return LLDB_RECORD_RESULT(sb_value); } lldb::SBValue SBValue::CreateValueFromExpression(const char *name, const char *expression) { + LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateValueFromExpression, + (const char *, const char *), name, expression); + SBExpressionOptions options; options.ref().SetKeepInMemory(true); - return CreateValueFromExpression(name, expression, options); + return LLDB_RECORD_RESULT( + CreateValueFromExpression(name, expression, options)); } lldb::SBValue SBValue::CreateValueFromExpression(const char *name, const char *expression, SBExpressionOptions &options) { + LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateValueFromExpression, + (const char *, const char *, lldb::SBExpressionOptions &), + name, expression, options); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); lldb::SBValue sb_value; ValueLocker locker; @@ -740,12 +820,16 @@ lldb::SBValue SBValue::CreateValueFromExpression(const char *name, "expression=\"%s\") => NULL", static_cast<void *>(value_sp.get()), name, expression); } - return sb_value; + return LLDB_RECORD_RESULT(sb_value); } lldb::SBValue SBValue::CreateValueFromAddress(const char *name, lldb::addr_t address, SBType sb_type) { + LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateValueFromAddress, + (const char *, lldb::addr_t, lldb::SBType), name, address, + sb_type); + lldb::SBValue sb_value; ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -768,11 +852,15 @@ lldb::SBValue SBValue::CreateValueFromAddress(const char *name, log->Printf("SBValue(%p)::CreateValueFromAddress => NULL", static_cast<void *>(value_sp.get())); } - return sb_value; + return LLDB_RECORD_RESULT(sb_value); } lldb::SBValue SBValue::CreateValueFromData(const char *name, SBData data, SBType sb_type) { + LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateValueFromData, + (const char *, lldb::SBData, lldb::SBType), name, data, + sb_type); + lldb::SBValue sb_value; lldb::ValueObjectSP new_value_sp; ValueLocker locker; @@ -795,10 +883,12 @@ lldb::SBValue SBValue::CreateValueFromData(const char *name, SBData data, log->Printf("SBValue(%p)::CreateValueFromData => NULL", static_cast<void *>(value_sp.get())); } - return sb_value; + return LLDB_RECORD_RESULT(sb_value); } SBValue SBValue::GetChildAtIndex(uint32_t idx) { + LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildAtIndex, (uint32_t), idx); + const bool can_create_synthetic = false; lldb::DynamicValueType use_dynamic = eNoDynamicValues; TargetSP target_sp; @@ -808,12 +898,17 @@ SBValue SBValue::GetChildAtIndex(uint32_t idx) { if (target_sp) use_dynamic = target_sp->GetPreferDynamicValue(); - return GetChildAtIndex(idx, use_dynamic, can_create_synthetic); + return LLDB_RECORD_RESULT( + GetChildAtIndex(idx, use_dynamic, can_create_synthetic)); } SBValue SBValue::GetChildAtIndex(uint32_t idx, lldb::DynamicValueType use_dynamic, bool can_create_synthetic) { + LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildAtIndex, + (uint32_t, lldb::DynamicValueType, bool), idx, use_dynamic, + can_create_synthetic); + lldb::ValueObjectSP child_sp; Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); @@ -834,10 +929,13 @@ SBValue SBValue::GetChildAtIndex(uint32_t idx, static_cast<void *>(value_sp.get()), idx, static_cast<void *>(value_sp.get())); - return sb_value; + return LLDB_RECORD_RESULT(sb_value); } uint32_t SBValue::GetIndexOfChildWithName(const char *name) { + LLDB_RECORD_METHOD(uint32_t, SBValue, GetIndexOfChildWithName, (const char *), + name); + uint32_t idx = UINT32_MAX; ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -858,6 +956,9 @@ uint32_t SBValue::GetIndexOfChildWithName(const char *name) { } SBValue SBValue::GetChildMemberWithName(const char *name) { + LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName, + (const char *), name); + lldb::DynamicValueType use_dynamic_value = eNoDynamicValues; TargetSP target_sp; if (m_opaque_sp) @@ -865,12 +966,16 @@ SBValue SBValue::GetChildMemberWithName(const char *name) { if (target_sp) use_dynamic_value = target_sp->GetPreferDynamicValue(); - return GetChildMemberWithName(name, use_dynamic_value); + return LLDB_RECORD_RESULT(GetChildMemberWithName(name, use_dynamic_value)); } SBValue SBValue::GetChildMemberWithName(const char *name, lldb::DynamicValueType use_dynamic_value) { + LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName, + (const char *, lldb::DynamicValueType), name, + use_dynamic_value); + lldb::ValueObjectSP child_sp; const ConstString str_name(name); @@ -891,20 +996,25 @@ SBValue::GetChildMemberWithName(const char *name, static_cast<void *>(value_sp.get()), name, static_cast<void *>(value_sp.get())); - return sb_value; + return LLDB_RECORD_RESULT(sb_value); } lldb::SBValue SBValue::GetDynamicValue(lldb::DynamicValueType use_dynamic) { + LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetDynamicValue, + (lldb::DynamicValueType), use_dynamic); + SBValue value_sb; if (IsValid()) { ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(), use_dynamic, m_opaque_sp->GetUseSynthetic())); value_sb.SetSP(proxy_sp); } - return value_sb; + return LLDB_RECORD_RESULT(value_sb); } lldb::SBValue SBValue::GetStaticValue() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, GetStaticValue); + SBValue value_sb; if (IsValid()) { ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(), @@ -912,42 +1022,57 @@ lldb::SBValue SBValue::GetStaticValue() { m_opaque_sp->GetUseSynthetic())); value_sb.SetSP(proxy_sp); } - return value_sb; + return LLDB_RECORD_RESULT(value_sb); } lldb::SBValue SBValue::GetNonSyntheticValue() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, GetNonSyntheticValue); + SBValue value_sb; if (IsValid()) { ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(), m_opaque_sp->GetUseDynamic(), false)); value_sb.SetSP(proxy_sp); } - return value_sb; + return LLDB_RECORD_RESULT(value_sb); } lldb::DynamicValueType SBValue::GetPreferDynamicValue() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::DynamicValueType, SBValue, + GetPreferDynamicValue); + if (!IsValid()) return eNoDynamicValues; return m_opaque_sp->GetUseDynamic(); } void SBValue::SetPreferDynamicValue(lldb::DynamicValueType use_dynamic) { + LLDB_RECORD_METHOD(void, SBValue, SetPreferDynamicValue, + (lldb::DynamicValueType), use_dynamic); + if (IsValid()) return m_opaque_sp->SetUseDynamic(use_dynamic); } bool SBValue::GetPreferSyntheticValue() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, GetPreferSyntheticValue); + if (!IsValid()) return false; return m_opaque_sp->GetUseSynthetic(); } void SBValue::SetPreferSyntheticValue(bool use_synthetic) { + LLDB_RECORD_METHOD(void, SBValue, SetPreferSyntheticValue, (bool), + use_synthetic); + if (IsValid()) return m_opaque_sp->SetUseSynthetic(use_synthetic); } bool SBValue::IsDynamic() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsDynamic); + ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); if (value_sp) @@ -956,6 +1081,8 @@ bool SBValue::IsDynamic() { } bool SBValue::IsSynthetic() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsSynthetic); + ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); if (value_sp) @@ -964,6 +1091,8 @@ bool SBValue::IsSynthetic() { } bool SBValue::IsSyntheticChildrenGenerated() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsSyntheticChildrenGenerated); + ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); if (value_sp) @@ -972,6 +1101,8 @@ bool SBValue::IsSyntheticChildrenGenerated() { } void SBValue::SetSyntheticChildrenGenerated(bool is) { + LLDB_RECORD_METHOD(void, SBValue, SetSyntheticChildrenGenerated, (bool), is); + ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); if (value_sp) @@ -979,6 +1110,9 @@ void SBValue::SetSyntheticChildrenGenerated(bool is) { } lldb::SBValue SBValue::GetValueForExpressionPath(const char *expr_path) { + LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetValueForExpressionPath, + (const char *), expr_path); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); lldb::ValueObjectSP child_sp; ValueLocker locker; @@ -997,10 +1131,13 @@ lldb::SBValue SBValue::GetValueForExpressionPath(const char *expr_path) { static_cast<void *>(value_sp.get()), expr_path, static_cast<void *>(value_sp.get())); - return sb_value; + return LLDB_RECORD_RESULT(sb_value); } int64_t SBValue::GetValueAsSigned(SBError &error, int64_t fail_value) { + LLDB_RECORD_METHOD(int64_t, SBValue, GetValueAsSigned, + (lldb::SBError &, int64_t), error, fail_value); + error.Clear(); ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -1019,6 +1156,9 @@ int64_t SBValue::GetValueAsSigned(SBError &error, int64_t fail_value) { } uint64_t SBValue::GetValueAsUnsigned(SBError &error, uint64_t fail_value) { + LLDB_RECORD_METHOD(uint64_t, SBValue, GetValueAsUnsigned, + (lldb::SBError &, uint64_t), error, fail_value); + error.Clear(); ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -1037,6 +1177,8 @@ uint64_t SBValue::GetValueAsUnsigned(SBError &error, uint64_t fail_value) { } int64_t SBValue::GetValueAsSigned(int64_t fail_value) { + LLDB_RECORD_METHOD(int64_t, SBValue, GetValueAsSigned, (int64_t), fail_value); + ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); if (value_sp) { @@ -1046,6 +1188,9 @@ int64_t SBValue::GetValueAsSigned(int64_t fail_value) { } uint64_t SBValue::GetValueAsUnsigned(uint64_t fail_value) { + LLDB_RECORD_METHOD(uint64_t, SBValue, GetValueAsUnsigned, (uint64_t), + fail_value); + ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); if (value_sp) { @@ -1055,6 +1200,8 @@ uint64_t SBValue::GetValueAsUnsigned(uint64_t fail_value) { } bool SBValue::MightHaveChildren() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, MightHaveChildren); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); bool has_children = false; ValueLocker locker; @@ -1069,6 +1216,8 @@ bool SBValue::MightHaveChildren() { } bool SBValue::IsRuntimeSupportValue() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsRuntimeSupportValue); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); bool is_support = false; ValueLocker locker; @@ -1082,9 +1231,15 @@ bool SBValue::IsRuntimeSupportValue() { return is_support; } -uint32_t SBValue::GetNumChildren() { return GetNumChildren(UINT32_MAX); } +uint32_t SBValue::GetNumChildren() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBValue, GetNumChildren); + + return GetNumChildren(UINT32_MAX); +} uint32_t SBValue::GetNumChildren(uint32_t max) { + LLDB_RECORD_METHOD(uint32_t, SBValue, GetNumChildren, (uint32_t), max); + uint32_t num_children = 0; Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); @@ -1101,6 +1256,8 @@ uint32_t SBValue::GetNumChildren(uint32_t max) { } SBValue SBValue::Dereference() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, Dereference); + SBValue sb_value; ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -1114,13 +1271,19 @@ SBValue SBValue::Dereference() { static_cast<void *>(value_sp.get()), static_cast<void *>(value_sp.get())); - return sb_value; + return LLDB_RECORD_RESULT(sb_value); } // Deprecated - please use GetType().IsPointerType() instead. -bool SBValue::TypeIsPointerType() { return GetType().IsPointerType(); } +bool SBValue::TypeIsPointerType() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, TypeIsPointerType); + + return GetType().IsPointerType(); +} void *SBValue::GetOpaqueType() { + LLDB_RECORD_METHOD_NO_ARGS(void *, SBValue, GetOpaqueType); + ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); if (value_sp) @@ -1129,6 +1292,8 @@ void *SBValue::GetOpaqueType() { } lldb::SBTarget SBValue::GetTarget() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBValue, GetTarget); + SBTarget sb_target; TargetSP target_sp; if (m_opaque_sp) { @@ -1145,10 +1310,12 @@ lldb::SBTarget SBValue::GetTarget() { static_cast<void *>(m_opaque_sp.get()), static_cast<void *>(target_sp.get())); } - return sb_target; + return LLDB_RECORD_RESULT(sb_target); } lldb::SBProcess SBValue::GetProcess() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBValue, GetProcess); + SBProcess sb_process; ProcessSP process_sp; if (m_opaque_sp) { @@ -1165,10 +1332,12 @@ lldb::SBProcess SBValue::GetProcess() { static_cast<void *>(m_opaque_sp.get()), static_cast<void *>(process_sp.get())); } - return sb_process; + return LLDB_RECORD_RESULT(sb_process); } lldb::SBThread SBValue::GetThread() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBThread, SBValue, GetThread); + SBThread sb_thread; ThreadSP thread_sp; if (m_opaque_sp) { @@ -1185,10 +1354,12 @@ lldb::SBThread SBValue::GetThread() { static_cast<void *>(m_opaque_sp.get()), static_cast<void *>(thread_sp.get())); } - return sb_thread; + return LLDB_RECORD_RESULT(sb_thread); } lldb::SBFrame SBValue::GetFrame() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFrame, SBValue, GetFrame); + SBFrame sb_frame; StackFrameSP frame_sp; if (m_opaque_sp) { @@ -1205,7 +1376,7 @@ lldb::SBFrame SBValue::GetFrame() { static_cast<void *>(m_opaque_sp.get()), static_cast<void *>(frame_sp.get())); } - return sb_frame; + return LLDB_RECORD_RESULT(sb_frame); } lldb::ValueObjectSP SBValue::GetSP(ValueLocker &locker) const { @@ -1217,8 +1388,10 @@ lldb::ValueObjectSP SBValue::GetSP(ValueLocker &locker) const { } lldb::ValueObjectSP SBValue::GetSP() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ValueObjectSP, SBValue, GetSP); + ValueLocker locker; - return GetSP(locker); + return LLDB_RECORD_RESULT(GetSP(locker)); } void SBValue::SetSP(ValueImplSP impl_sp) { m_opaque_sp = impl_sp; } @@ -1276,6 +1449,9 @@ void SBValue::SetSP(const lldb::ValueObjectSP &sp, } bool SBValue::GetExpressionPath(SBStream &description) { + LLDB_RECORD_METHOD(bool, SBValue, GetExpressionPath, (lldb::SBStream &), + description); + ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); if (value_sp) { @@ -1287,6 +1463,9 @@ bool SBValue::GetExpressionPath(SBStream &description) { bool SBValue::GetExpressionPath(SBStream &description, bool qualify_cxx_base_classes) { + LLDB_RECORD_METHOD(bool, SBValue, GetExpressionPath, (lldb::SBStream &, bool), + description, qualify_cxx_base_classes); + ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); if (value_sp) { @@ -1296,39 +1475,51 @@ bool SBValue::GetExpressionPath(SBStream &description, return false; } -lldb::SBValue SBValue::EvaluateExpression(const char* expr) const { +lldb::SBValue SBValue::EvaluateExpression(const char *expr) const { + LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValue, EvaluateExpression, + (const char *), expr); + ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); if (!value_sp) - return SBValue(); + return LLDB_RECORD_RESULT(SBValue()); lldb::TargetSP target_sp = value_sp->GetTargetSP(); if (!target_sp) - return SBValue(); + return LLDB_RECORD_RESULT(SBValue()); lldb::SBExpressionOptions options; options.SetFetchDynamicValue(target_sp->GetPreferDynamicValue()); options.SetUnwindOnError(true); options.SetIgnoreBreakpoints(true); - return EvaluateExpression(expr, options, nullptr); + return LLDB_RECORD_RESULT(EvaluateExpression(expr, options, nullptr)); } lldb::SBValue SBValue::EvaluateExpression(const char *expr, const SBExpressionOptions &options) const { - return EvaluateExpression(expr, options, nullptr); + LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValue, EvaluateExpression, + (const char *, const lldb::SBExpressionOptions &), + expr, options); + + return LLDB_RECORD_RESULT(EvaluateExpression(expr, options, nullptr)); } lldb::SBValue SBValue::EvaluateExpression(const char *expr, const SBExpressionOptions &options, const char *name) const { + LLDB_RECORD_METHOD_CONST( + lldb::SBValue, SBValue, EvaluateExpression, + (const char *, const lldb::SBExpressionOptions &, const char *), expr, + options, name); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (!expr || expr[0] == '\0') { LLDB_LOG(log, "SBValue::EvaluateExpression called with an empty expression"); - return SBValue(); + return LLDB_RECORD_RESULT(SBValue()); } LLDB_LOG(log, "SBValue()::EvaluateExpression (expr=\"{0}\")...", expr); @@ -1338,7 +1529,7 @@ lldb::SBValue SBValue::EvaluateExpression(const char *expr, if (!value_sp) { LLDB_LOG(log, "SBValue::EvaluateExpression () => error: could not " "reconstruct value object for this SBValue"); - return SBValue(); + return LLDB_RECORD_RESULT(SBValue()); } lldb::TargetSP target_sp = value_sp->GetTargetSP(); @@ -1346,7 +1537,7 @@ lldb::SBValue SBValue::EvaluateExpression(const char *expr, LLDB_LOG( log, "SBValue::EvaluateExpression () => error: could not retrieve target"); - return SBValue(); + return LLDB_RECORD_RESULT(SBValue()); } std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); @@ -1356,7 +1547,7 @@ lldb::SBValue SBValue::EvaluateExpression(const char *expr, if (!frame) { LLDB_LOG(log, "SBValue::EvaluateExpression () => error: could not retrieve " "current stack frame"); - return SBValue(); + return LLDB_RECORD_RESULT(SBValue()); } ValueObjectSP res_val_sp; @@ -1374,10 +1565,13 @@ lldb::SBValue SBValue::EvaluateExpression(const char *expr, SBValue result; result.SetSP(res_val_sp, options.GetFetchDynamicValue()); - return result; + return LLDB_RECORD_RESULT(result); } bool SBValue::GetDescription(SBStream &description) { + LLDB_RECORD_METHOD(bool, SBValue, GetDescription, (lldb::SBStream &), + description); + Stream &strm = description.ref(); ValueLocker locker; @@ -1391,6 +1585,8 @@ bool SBValue::GetDescription(SBStream &description) { } lldb::Format SBValue::GetFormat() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::Format, SBValue, GetFormat); + ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); if (value_sp) @@ -1399,6 +1595,8 @@ lldb::Format SBValue::GetFormat() { } void SBValue::SetFormat(lldb::Format format) { + LLDB_RECORD_METHOD(void, SBValue, SetFormat, (lldb::Format), format); + ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); if (value_sp) @@ -1406,6 +1604,8 @@ void SBValue::SetFormat(lldb::Format format) { } lldb::SBValue SBValue::AddressOf() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, AddressOf); + SBValue sb_value; ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -1420,10 +1620,12 @@ lldb::SBValue SBValue::AddressOf() { static_cast<void *>(value_sp.get()), static_cast<void *>(value_sp.get())); - return sb_value; + return LLDB_RECORD_RESULT(sb_value); } lldb::addr_t SBValue::GetLoadAddress() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBValue, GetLoadAddress); + lldb::addr_t value = LLDB_INVALID_ADDRESS; ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -1456,6 +1658,8 @@ lldb::addr_t SBValue::GetLoadAddress() { } lldb::SBAddress SBValue::GetAddress() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBValue, GetAddress); + Address addr; ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -1485,10 +1689,13 @@ lldb::SBAddress SBValue::GetAddress() { (addr.GetSection() ? addr.GetSection()->GetName().GetCString() : "NULL"), addr.GetOffset()); - return SBAddress(new Address(addr)); + return LLDB_RECORD_RESULT(SBAddress(new Address(addr))); } lldb::SBData SBValue::GetPointeeData(uint32_t item_idx, uint32_t item_count) { + LLDB_RECORD_METHOD(lldb::SBData, SBValue, GetPointeeData, + (uint32_t, uint32_t), item_idx, item_count); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); lldb::SBData sb_data; ValueLocker locker; @@ -1507,10 +1714,12 @@ lldb::SBData SBValue::GetPointeeData(uint32_t item_idx, uint32_t item_count) { static_cast<void *>(value_sp.get()), item_idx, item_count, static_cast<void *>(sb_data.get())); - return sb_data; + return LLDB_RECORD_RESULT(sb_data); } lldb::SBData SBValue::GetData() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBData, SBValue, GetData); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); lldb::SBData sb_data; ValueLocker locker; @@ -1527,10 +1736,13 @@ lldb::SBData SBValue::GetData() { static_cast<void *>(value_sp.get()), static_cast<void *>(sb_data.get())); - return sb_data; + return LLDB_RECORD_RESULT(sb_data); } bool SBValue::SetData(lldb::SBData &data, SBError &error) { + LLDB_RECORD_METHOD(bool, SBValue, SetData, (lldb::SBData &, lldb::SBError &), + data, error); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -1572,6 +1784,8 @@ bool SBValue::SetData(lldb::SBData &data, SBError &error) { } lldb::SBDeclaration SBValue::GetDeclaration() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBDeclaration, SBValue, GetDeclaration); + ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); SBDeclaration decl_sb; @@ -1580,11 +1794,15 @@ lldb::SBDeclaration SBValue::GetDeclaration() { if (value_sp->GetDeclaration(decl)) decl_sb.SetDeclaration(decl); } - return decl_sb; + return LLDB_RECORD_RESULT(decl_sb); } lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read, bool write, SBError &error) { + LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBValue, Watch, + (bool, bool, bool, lldb::SBError &), resolve_location, + read, write, error); + SBWatchpoint sb_watchpoint; // If the SBValue is not valid, there's no point in even trying to watch it. @@ -1594,18 +1812,18 @@ lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read, bool write, if (value_sp && target_sp) { // Read and Write cannot both be false. if (!read && !write) - return sb_watchpoint; + return LLDB_RECORD_RESULT(sb_watchpoint); // If the value is not in scope, don't try and watch and invalid value if (!IsInScope()) - return sb_watchpoint; + return LLDB_RECORD_RESULT(sb_watchpoint); addr_t addr = GetLoadAddress(); if (addr == LLDB_INVALID_ADDRESS) - return sb_watchpoint; + return LLDB_RECORD_RESULT(sb_watchpoint); size_t byte_size = GetByteSize(); if (byte_size == 0) - return sb_watchpoint; + return LLDB_RECORD_RESULT(sb_watchpoint); uint32_t watch_type = 0; if (read) @@ -1648,7 +1866,7 @@ lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read, bool write, error.SetErrorString("could not set watchpoint, a target is required"); } - return sb_watchpoint; + return LLDB_RECORD_RESULT(sb_watchpoint); } // FIXME: Remove this method impl (as well as the decl in .h) once it is no @@ -1656,24 +1874,33 @@ lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read, bool write, // Backward compatibility fix in the interim. lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read, bool write) { + LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBValue, Watch, (bool, bool, bool), + resolve_location, read, write); + SBError error; - return Watch(resolve_location, read, write, error); + return LLDB_RECORD_RESULT(Watch(resolve_location, read, write, error)); } lldb::SBWatchpoint SBValue::WatchPointee(bool resolve_location, bool read, bool write, SBError &error) { + LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBValue, WatchPointee, + (bool, bool, bool, lldb::SBError &), resolve_location, + read, write, error); + SBWatchpoint sb_watchpoint; if (IsInScope() && GetType().IsPointerType()) sb_watchpoint = Dereference().Watch(resolve_location, read, write, error); - return sb_watchpoint; + return LLDB_RECORD_RESULT(sb_watchpoint); } lldb::SBValue SBValue::Persist() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, Persist); + ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); SBValue persisted_sb; if (value_sp) { persisted_sb.SetSP(value_sp->Persist()); } - return persisted_sb; + return LLDB_RECORD_RESULT(persisted_sb); } diff --git a/lldb/source/API/SBValueList.cpp b/lldb/source/API/SBValueList.cpp index 69af083b1bb..e3adb445cce 100644 --- a/lldb/source/API/SBValueList.cpp +++ b/lldb/source/API/SBValueList.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBValueList.h" +#include "SBReproducerPrivate.h" #include "lldb/API/SBStream.h" #include "lldb/API/SBValue.h" #include "lldb/Core/ValueObjectList.h" @@ -67,9 +68,13 @@ private: std::vector<lldb::SBValue> m_values; }; -SBValueList::SBValueList() : m_opaque_up() {} +SBValueList::SBValueList() : m_opaque_up() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBValueList); +} SBValueList::SBValueList(const SBValueList &rhs) : m_opaque_up() { + LLDB_RECORD_CONSTRUCTOR(SBValueList, (const lldb::SBValueList &), rhs); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (rhs.IsValid()) @@ -98,11 +103,22 @@ SBValueList::SBValueList(const ValueListImpl *lldb_object_ptr) : m_opaque_up() { SBValueList::~SBValueList() {} -bool SBValueList::IsValid() const { return (m_opaque_up != NULL); } +bool SBValueList::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBValueList, IsValid); + + return (m_opaque_up != NULL); +} -void SBValueList::Clear() { m_opaque_up.reset(); } +void SBValueList::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBValueList, Clear); + + m_opaque_up.reset(); +} const SBValueList &SBValueList::operator=(const SBValueList &rhs) { + LLDB_RECORD_METHOD(const lldb::SBValueList &, + SBValueList, operator=,(const lldb::SBValueList &), rhs); + if (this != &rhs) { if (rhs.IsValid()) m_opaque_up.reset(new ValueListImpl(*rhs)); @@ -123,6 +139,9 @@ const ValueListImpl *SBValueList::operator->() const { const ValueListImpl &SBValueList::operator*() const { return *m_opaque_up; } void SBValueList::Append(const SBValue &val_obj) { + LLDB_RECORD_METHOD(void, SBValueList, Append, (const lldb::SBValue &), + val_obj); + CreateIfNeeded(); m_opaque_up->Append(val_obj); } @@ -135,6 +154,9 @@ void SBValueList::Append(lldb::ValueObjectSP &val_obj_sp) { } void SBValueList::Append(const lldb::SBValueList &value_list) { + LLDB_RECORD_METHOD(void, SBValueList, Append, (const lldb::SBValueList &), + value_list); + if (value_list.IsValid()) { CreateIfNeeded(); m_opaque_up->Append(*value_list); @@ -142,6 +164,9 @@ void SBValueList::Append(const lldb::SBValueList &value_list) { } SBValue SBValueList::GetValueAtIndex(uint32_t idx) const { + LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValueList, GetValueAtIndex, + (uint32_t), idx); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); // if (log) @@ -161,10 +186,12 @@ SBValue SBValueList::GetValueAtIndex(uint32_t idx) const { static_cast<void *>(sb_value.GetSP().get()), sstr.GetData()); } - return sb_value; + return LLDB_RECORD_RESULT(sb_value); } uint32_t SBValueList::GetSize() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBValueList, GetSize); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); // if (log) @@ -187,17 +214,23 @@ void SBValueList::CreateIfNeeded() { } SBValue SBValueList::FindValueObjectByUID(lldb::user_id_t uid) { + LLDB_RECORD_METHOD(lldb::SBValue, SBValueList, FindValueObjectByUID, + (lldb::user_id_t), uid); + SBValue sb_value; if (m_opaque_up) sb_value = m_opaque_up->FindValueByUID(uid); - return sb_value; + return LLDB_RECORD_RESULT(sb_value); } SBValue SBValueList::GetFirstValueByName(const char *name) const { + LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValueList, GetFirstValueByName, + (const char *), name); + SBValue sb_value; if (m_opaque_up) sb_value = m_opaque_up->GetFirstValueByName(name); - return sb_value; + return LLDB_RECORD_RESULT(sb_value); } void *SBValueList::opaque_ptr() { return m_opaque_up.get(); } diff --git a/lldb/source/API/SBVariablesOptions.cpp b/lldb/source/API/SBVariablesOptions.cpp index 69c684d9962..e278cb01ce7 100644 --- a/lldb/source/API/SBVariablesOptions.cpp +++ b/lldb/source/API/SBVariablesOptions.cpp @@ -8,6 +8,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBVariablesOptions.h" +#include "SBReproducerPrivate.h" #include "lldb/API/SBTarget.h" #include "lldb/Target/Target.h" @@ -80,76 +81,130 @@ private: }; SBVariablesOptions::SBVariablesOptions() - : m_opaque_up(new VariablesOptionsImpl()) {} + : m_opaque_up(new VariablesOptionsImpl()) { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBVariablesOptions); +} SBVariablesOptions::SBVariablesOptions(const SBVariablesOptions &options) - : m_opaque_up(new VariablesOptionsImpl(options.ref())) {} + : m_opaque_up(new VariablesOptionsImpl(options.ref())) { + LLDB_RECORD_CONSTRUCTOR(SBVariablesOptions, + (const lldb::SBVariablesOptions &), options); +} SBVariablesOptions &SBVariablesOptions:: operator=(const SBVariablesOptions &options) { + LLDB_RECORD_METHOD( + lldb::SBVariablesOptions &, + SBVariablesOptions, operator=,(const lldb::SBVariablesOptions &), + options); + m_opaque_up.reset(new VariablesOptionsImpl(options.ref())); return *this; } SBVariablesOptions::~SBVariablesOptions() = default; -bool SBVariablesOptions::IsValid() const { return m_opaque_up != nullptr; } +bool SBVariablesOptions::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, IsValid); + + return m_opaque_up != nullptr; +} bool SBVariablesOptions::GetIncludeArguments() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, + GetIncludeArguments); + return m_opaque_up->GetIncludeArguments(); } void SBVariablesOptions::SetIncludeArguments(bool arguments) { + LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeArguments, (bool), + arguments); + m_opaque_up->SetIncludeArguments(arguments); } bool SBVariablesOptions::GetIncludeRecognizedArguments( const lldb::SBTarget &target) const { + LLDB_RECORD_METHOD_CONST(bool, SBVariablesOptions, + GetIncludeRecognizedArguments, + (const lldb::SBTarget &), target); + return m_opaque_up->GetIncludeRecognizedArguments(target.GetSP()); } void SBVariablesOptions::SetIncludeRecognizedArguments(bool arguments) { + LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeRecognizedArguments, + (bool), arguments); + m_opaque_up->SetIncludeRecognizedArguments(arguments); } bool SBVariablesOptions::GetIncludeLocals() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, GetIncludeLocals); + return m_opaque_up->GetIncludeLocals(); } void SBVariablesOptions::SetIncludeLocals(bool locals) { + LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeLocals, (bool), + locals); + m_opaque_up->SetIncludeLocals(locals); } bool SBVariablesOptions::GetIncludeStatics() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, GetIncludeStatics); + return m_opaque_up->GetIncludeStatics(); } void SBVariablesOptions::SetIncludeStatics(bool statics) { + LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeStatics, (bool), + statics); + m_opaque_up->SetIncludeStatics(statics); } bool SBVariablesOptions::GetInScopeOnly() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, GetInScopeOnly); + return m_opaque_up->GetInScopeOnly(); } void SBVariablesOptions::SetInScopeOnly(bool in_scope_only) { + LLDB_RECORD_METHOD(void, SBVariablesOptions, SetInScopeOnly, (bool), + in_scope_only); + m_opaque_up->SetInScopeOnly(in_scope_only); } bool SBVariablesOptions::GetIncludeRuntimeSupportValues() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, + GetIncludeRuntimeSupportValues); + return m_opaque_up->GetIncludeRuntimeSupportValues(); } void SBVariablesOptions::SetIncludeRuntimeSupportValues( bool runtime_support_values) { + LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeRuntimeSupportValues, + (bool), runtime_support_values); + m_opaque_up->SetIncludeRuntimeSupportValues(runtime_support_values); } lldb::DynamicValueType SBVariablesOptions::GetUseDynamic() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::DynamicValueType, SBVariablesOptions, + GetUseDynamic); + return m_opaque_up->GetUseDynamic(); } void SBVariablesOptions::SetUseDynamic(lldb::DynamicValueType dynamic) { + LLDB_RECORD_METHOD(void, SBVariablesOptions, SetUseDynamic, + (lldb::DynamicValueType), dynamic); + m_opaque_up->SetUseDynamic(dynamic); } diff --git a/lldb/source/API/SBWatchpoint.cpp b/lldb/source/API/SBWatchpoint.cpp index 563123734ed..7ef8a7a11b0 100644 --- a/lldb/source/API/SBWatchpoint.cpp +++ b/lldb/source/API/SBWatchpoint.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBWatchpoint.h" +#include "SBReproducerPrivate.h" #include "lldb/API/SBAddress.h" #include "lldb/API/SBDebugger.h" #include "lldb/API/SBDefines.h" @@ -26,10 +27,12 @@ using namespace lldb; using namespace lldb_private; -SBWatchpoint::SBWatchpoint() {} +SBWatchpoint::SBWatchpoint() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBWatchpoint); } SBWatchpoint::SBWatchpoint(const lldb::WatchpointSP &wp_sp) : m_opaque_wp(wp_sp) { + LLDB_RECORD_CONSTRUCTOR(SBWatchpoint, (const lldb::WatchpointSP &), wp_sp); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) { @@ -40,9 +43,14 @@ SBWatchpoint::SBWatchpoint(const lldb::WatchpointSP &wp_sp) } SBWatchpoint::SBWatchpoint(const SBWatchpoint &rhs) - : m_opaque_wp(rhs.m_opaque_wp) {} + : m_opaque_wp(rhs.m_opaque_wp) { + LLDB_RECORD_CONSTRUCTOR(SBWatchpoint, (const lldb::SBWatchpoint &), rhs); +} const SBWatchpoint &SBWatchpoint::operator=(const SBWatchpoint &rhs) { + LLDB_RECORD_METHOD(const lldb::SBWatchpoint &, + SBWatchpoint, operator=,(const lldb::SBWatchpoint &), rhs); + m_opaque_wp = rhs.m_opaque_wp; return *this; } @@ -50,6 +58,8 @@ const SBWatchpoint &SBWatchpoint::operator=(const SBWatchpoint &rhs) { SBWatchpoint::~SBWatchpoint() {} watch_id_t SBWatchpoint::GetID() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::watch_id_t, SBWatchpoint, GetID); + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); watch_id_t watch_id = LLDB_INVALID_WATCH_ID; @@ -69,18 +79,26 @@ watch_id_t SBWatchpoint::GetID() { return watch_id; } -bool SBWatchpoint::IsValid() const { return bool(m_opaque_wp.lock()); } +bool SBWatchpoint::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBWatchpoint, IsValid); + + return bool(m_opaque_wp.lock()); +} SBError SBWatchpoint::GetError() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBWatchpoint, GetError); + SBError sb_error; lldb::WatchpointSP watchpoint_sp(GetSP()); if (watchpoint_sp) { sb_error.SetError(watchpoint_sp->GetError()); } - return sb_error; + return LLDB_RECORD_RESULT(sb_error); } int32_t SBWatchpoint::GetHardwareIndex() { + LLDB_RECORD_METHOD_NO_ARGS(int32_t, SBWatchpoint, GetHardwareIndex); + int32_t hw_index = -1; lldb::WatchpointSP watchpoint_sp(GetSP()); @@ -94,6 +112,8 @@ int32_t SBWatchpoint::GetHardwareIndex() { } addr_t SBWatchpoint::GetWatchAddress() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBWatchpoint, GetWatchAddress); + addr_t ret_addr = LLDB_INVALID_ADDRESS; lldb::WatchpointSP watchpoint_sp(GetSP()); @@ -107,6 +127,8 @@ addr_t SBWatchpoint::GetWatchAddress() { } size_t SBWatchpoint::GetWatchSize() { + LLDB_RECORD_METHOD_NO_ARGS(size_t, SBWatchpoint, GetWatchSize); + size_t watch_size = 0; lldb::WatchpointSP watchpoint_sp(GetSP()); @@ -120,6 +142,8 @@ size_t SBWatchpoint::GetWatchSize() { } void SBWatchpoint::SetEnabled(bool enabled) { + LLDB_RECORD_METHOD(void, SBWatchpoint, SetEnabled, (bool), enabled); + lldb::WatchpointSP watchpoint_sp(GetSP()); if (watchpoint_sp) { Target &target = watchpoint_sp->GetTarget(); @@ -138,6 +162,8 @@ void SBWatchpoint::SetEnabled(bool enabled) { } bool SBWatchpoint::IsEnabled() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBWatchpoint, IsEnabled); + lldb::WatchpointSP watchpoint_sp(GetSP()); if (watchpoint_sp) { std::lock_guard<std::recursive_mutex> guard( @@ -148,6 +174,8 @@ bool SBWatchpoint::IsEnabled() { } uint32_t SBWatchpoint::GetHitCount() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBWatchpoint, GetHitCount); + uint32_t count = 0; lldb::WatchpointSP watchpoint_sp(GetSP()); if (watchpoint_sp) { @@ -165,6 +193,8 @@ uint32_t SBWatchpoint::GetHitCount() { } uint32_t SBWatchpoint::GetIgnoreCount() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBWatchpoint, GetIgnoreCount); + lldb::WatchpointSP watchpoint_sp(GetSP()); if (watchpoint_sp) { std::lock_guard<std::recursive_mutex> guard( @@ -175,6 +205,8 @@ uint32_t SBWatchpoint::GetIgnoreCount() { } void SBWatchpoint::SetIgnoreCount(uint32_t n) { + LLDB_RECORD_METHOD(void, SBWatchpoint, SetIgnoreCount, (uint32_t), n); + lldb::WatchpointSP watchpoint_sp(GetSP()); if (watchpoint_sp) { std::lock_guard<std::recursive_mutex> guard( @@ -184,6 +216,8 @@ void SBWatchpoint::SetIgnoreCount(uint32_t n) { } const char *SBWatchpoint::GetCondition() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBWatchpoint, GetCondition); + lldb::WatchpointSP watchpoint_sp(GetSP()); if (watchpoint_sp) { std::lock_guard<std::recursive_mutex> guard( @@ -194,6 +228,9 @@ const char *SBWatchpoint::GetCondition() { } void SBWatchpoint::SetCondition(const char *condition) { + LLDB_RECORD_METHOD(void, SBWatchpoint, SetCondition, (const char *), + condition); + lldb::WatchpointSP watchpoint_sp(GetSP()); if (watchpoint_sp) { std::lock_guard<std::recursive_mutex> guard( @@ -204,6 +241,10 @@ void SBWatchpoint::SetCondition(const char *condition) { bool SBWatchpoint::GetDescription(SBStream &description, DescriptionLevel level) { + LLDB_RECORD_METHOD(bool, SBWatchpoint, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel), description, + level); + Stream &strm = description.ref(); lldb::WatchpointSP watchpoint_sp(GetSP()); @@ -218,19 +259,39 @@ bool SBWatchpoint::GetDescription(SBStream &description, return true; } -void SBWatchpoint::Clear() { m_opaque_wp.reset(); } +void SBWatchpoint::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBWatchpoint, Clear); -lldb::WatchpointSP SBWatchpoint::GetSP() const { return m_opaque_wp.lock(); } + m_opaque_wp.reset(); +} + +lldb::WatchpointSP SBWatchpoint::GetSP() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::WatchpointSP, SBWatchpoint, GetSP); -void SBWatchpoint::SetSP(const lldb::WatchpointSP &sp) { m_opaque_wp = sp; } + return LLDB_RECORD_RESULT(m_opaque_wp.lock()); +} + +void SBWatchpoint::SetSP(const lldb::WatchpointSP &sp) { + LLDB_RECORD_METHOD(void, SBWatchpoint, SetSP, (const lldb::WatchpointSP &), + sp); + + m_opaque_wp = sp; +} bool SBWatchpoint::EventIsWatchpointEvent(const lldb::SBEvent &event) { + LLDB_RECORD_STATIC_METHOD(bool, SBWatchpoint, EventIsWatchpointEvent, + (const lldb::SBEvent &), event); + return Watchpoint::WatchpointEventData::GetEventDataFromEvent(event.get()) != NULL; } WatchpointEventType SBWatchpoint::GetWatchpointEventTypeFromEvent(const SBEvent &event) { + LLDB_RECORD_STATIC_METHOD(lldb::WatchpointEventType, SBWatchpoint, + GetWatchpointEventTypeFromEvent, + (const lldb::SBEvent &), event); + if (event.IsValid()) return Watchpoint::WatchpointEventData::GetWatchpointEventTypeFromEvent( event.GetSP()); @@ -238,9 +299,13 @@ SBWatchpoint::GetWatchpointEventTypeFromEvent(const SBEvent &event) { } SBWatchpoint SBWatchpoint::GetWatchpointFromEvent(const lldb::SBEvent &event) { + LLDB_RECORD_STATIC_METHOD(lldb::SBWatchpoint, SBWatchpoint, + GetWatchpointFromEvent, (const lldb::SBEvent &), + event); + SBWatchpoint sb_watchpoint; if (event.IsValid()) sb_watchpoint = Watchpoint::WatchpointEventData::GetWatchpointFromEvent(event.GetSP()); - return sb_watchpoint; + return LLDB_RECORD_RESULT(sb_watchpoint); } |
