Index: lldb/source/API/SBAddress.cpp =================================================================== --- lldb/source/API/SBAddress.cpp +++ lldb/source/API/SBAddress.cpp @@ -52,8 +52,9 @@ SBAddress::~SBAddress() = default; const SBAddress &SBAddress::operator=(const SBAddress &rhs) { - LLDB_RECORD_METHOD(const lldb::SBAddress &, - SBAddress, operator=,(const lldb::SBAddress &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBAddress &, SBAddress, operator=, + (const lldb::SBAddress &), rhs); if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); @@ -67,29 +68,34 @@ } bool SBAddress::operator!=(const SBAddress &rhs) const { - LLDB_RECORD_METHOD_CONST(bool, SBAddress, operator!=,(const SBAddress &), + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD_CONST(bool, SBAddress, operator!=, (const SBAddress &), &rhs); return !(*this == rhs); } bool SBAddress::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBAddress, IsValid); return this->operator bool(); } SBAddress::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBAddress, operator bool); return m_opaque_up != nullptr && m_opaque_up->IsValid(); } void SBAddress::Clear() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBAddress, Clear); m_opaque_up = std::make_unique
(); } void SBAddress::SetAddress(lldb::SBSection section, lldb::addr_t offset) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBAddress, SetAddress, (lldb::SBSection, lldb::addr_t), section, offset); @@ -101,6 +107,7 @@ void SBAddress::SetAddress(const Address &address) { ref() = address; } lldb::addr_t SBAddress::GetFileAddress() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBAddress, GetFileAddress); if (m_opaque_up->IsValid()) @@ -110,6 +117,7 @@ } lldb::addr_t SBAddress::GetLoadAddress(const SBTarget &target) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(lldb::addr_t, SBAddress, GetLoadAddress, (const lldb::SBTarget &), target); @@ -126,6 +134,7 @@ } void SBAddress::SetLoadAddress(lldb::addr_t load_addr, lldb::SBTarget &target) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBAddress, SetLoadAddress, (lldb::addr_t, lldb::SBTarget &), load_addr, target); @@ -144,6 +153,7 @@ } bool SBAddress::OffsetAddress(addr_t offset) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBAddress, OffsetAddress, (lldb::addr_t), offset); if (m_opaque_up->IsValid()) { @@ -157,6 +167,7 @@ } lldb::SBSection SBAddress::GetSection() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSection, SBAddress, GetSection); lldb::SBSection sb_section; @@ -166,6 +177,7 @@ } lldb::addr_t SBAddress::GetOffset() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBAddress, GetOffset); if (m_opaque_up->IsValid()) @@ -193,6 +205,7 @@ Address *SBAddress::get() { return m_opaque_up.get(); } bool SBAddress::GetDescription(SBStream &description) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBAddress, GetDescription, (lldb::SBStream &), description); @@ -209,6 +222,7 @@ } SBModule SBAddress::GetModule() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBModule, SBAddress, GetModule); SBModule sb_module; @@ -218,6 +232,7 @@ } SBSymbolContext SBAddress::GetSymbolContext(uint32_t resolve_scope) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBAddress, GetSymbolContext, (uint32_t), resolve_scope); @@ -229,6 +244,7 @@ } SBCompileUnit SBAddress::GetCompileUnit() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCompileUnit, SBAddress, GetCompileUnit); SBCompileUnit sb_comp_unit; @@ -238,6 +254,7 @@ } SBFunction SBAddress::GetFunction() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFunction, SBAddress, GetFunction); SBFunction sb_function; @@ -247,6 +264,7 @@ } SBBlock SBAddress::GetBlock() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBAddress, GetBlock); SBBlock sb_block; @@ -256,6 +274,7 @@ } SBSymbol SBAddress::GetSymbol() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSymbol, SBAddress, GetSymbol); SBSymbol sb_symbol; @@ -265,6 +284,7 @@ } SBLineEntry SBAddress::GetLineEntry() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBLineEntry, SBAddress, GetLineEntry); SBLineEntry sb_line_entry; Index: lldb/source/API/SBAttachInfo.cpp =================================================================== --- lldb/source/API/SBAttachInfo.cpp +++ lldb/source/API/SBAttachInfo.cpp @@ -59,8 +59,9 @@ 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); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(lldb::SBAttachInfo &, SBAttachInfo, operator=, + (const lldb::SBAttachInfo &), rhs); if (this != &rhs) m_opaque_sp = clone(rhs.m_opaque_sp); @@ -68,36 +69,42 @@ } lldb::pid_t SBAttachInfo::GetProcessID() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBAttachInfo, GetProcessID); return m_opaque_sp->GetProcessID(); } void SBAttachInfo::SetProcessID(lldb::pid_t pid) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBAttachInfo, SetProcessID, (lldb::pid_t), pid); m_opaque_sp->SetProcessID(pid); } uint32_t SBAttachInfo::GetResumeCount() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetResumeCount); return m_opaque_sp->GetResumeCount(); } void SBAttachInfo::SetResumeCount(uint32_t c) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBAttachInfo, SetResumeCount, (uint32_t), c); m_opaque_sp->SetResumeCount(c); } const char *SBAttachInfo::GetProcessPluginName() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBAttachInfo, GetProcessPluginName); return m_opaque_sp->GetProcessPluginName(); } void SBAttachInfo::SetProcessPluginName(const char *plugin_name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBAttachInfo, SetProcessPluginName, (const char *), plugin_name); @@ -105,6 +112,7 @@ } void SBAttachInfo::SetExecutable(const char *path) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBAttachInfo, SetExecutable, (const char *), path); if (path && path[0]) @@ -114,6 +122,7 @@ } void SBAttachInfo::SetExecutable(SBFileSpec exe_file) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBAttachInfo, SetExecutable, (lldb::SBFileSpec), exe_file); @@ -124,18 +133,21 @@ } bool SBAttachInfo::GetWaitForLaunch() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, GetWaitForLaunch); return m_opaque_sp->GetWaitForLaunch(); } void SBAttachInfo::SetWaitForLaunch(bool b) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool), b); m_opaque_sp->SetWaitForLaunch(b); } void SBAttachInfo::SetWaitForLaunch(bool b, bool async) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool, bool), b, async); @@ -144,96 +156,112 @@ } bool SBAttachInfo::GetIgnoreExisting() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, GetIgnoreExisting); return m_opaque_sp->GetIgnoreExisting(); } void SBAttachInfo::SetIgnoreExisting(bool b) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBAttachInfo, SetIgnoreExisting, (bool), b); m_opaque_sp->SetIgnoreExisting(b); } uint32_t SBAttachInfo::GetUserID() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetUserID); return m_opaque_sp->GetUserID(); } uint32_t SBAttachInfo::GetGroupID() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetGroupID); return m_opaque_sp->GetGroupID(); } bool SBAttachInfo::UserIDIsValid() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, UserIDIsValid); return m_opaque_sp->UserIDIsValid(); } bool SBAttachInfo::GroupIDIsValid() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, GroupIDIsValid); return m_opaque_sp->GroupIDIsValid(); } void SBAttachInfo::SetUserID(uint32_t uid) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBAttachInfo, SetUserID, (uint32_t), uid); m_opaque_sp->SetUserID(uid); } void SBAttachInfo::SetGroupID(uint32_t gid) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBAttachInfo, SetGroupID, (uint32_t), gid); m_opaque_sp->SetGroupID(gid); } uint32_t SBAttachInfo::GetEffectiveUserID() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetEffectiveUserID); return m_opaque_sp->GetEffectiveUserID(); } uint32_t SBAttachInfo::GetEffectiveGroupID() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetEffectiveGroupID); return m_opaque_sp->GetEffectiveGroupID(); } bool SBAttachInfo::EffectiveUserIDIsValid() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, EffectiveUserIDIsValid); return m_opaque_sp->EffectiveUserIDIsValid(); } bool SBAttachInfo::EffectiveGroupIDIsValid() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, EffectiveGroupIDIsValid); return m_opaque_sp->EffectiveGroupIDIsValid(); } void SBAttachInfo::SetEffectiveUserID(uint32_t uid) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBAttachInfo, SetEffectiveUserID, (uint32_t), uid); m_opaque_sp->SetEffectiveUserID(uid); } void SBAttachInfo::SetEffectiveGroupID(uint32_t gid) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBAttachInfo, SetEffectiveGroupID, (uint32_t), gid); m_opaque_sp->SetEffectiveGroupID(gid); } lldb::pid_t SBAttachInfo::GetParentProcessID() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBAttachInfo, GetParentProcessID); return m_opaque_sp->GetParentProcessID(); } void SBAttachInfo::SetParentProcessID(lldb::pid_t pid) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBAttachInfo, SetParentProcessID, (lldb::pid_t), pid); @@ -241,18 +269,21 @@ } bool SBAttachInfo::ParentProcessIDIsValid() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, ParentProcessIDIsValid); return m_opaque_sp->ParentProcessIDIsValid(); } SBListener SBAttachInfo::GetListener() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBAttachInfo, GetListener); return SBListener(m_opaque_sp->GetListener()); } void SBAttachInfo::SetListener(SBListener &listener) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBAttachInfo, SetListener, (lldb::SBListener &), listener); Index: lldb/source/API/SBBlock.cpp =================================================================== --- lldb/source/API/SBBlock.cpp +++ lldb/source/API/SBBlock.cpp @@ -35,8 +35,9 @@ } const SBBlock &SBBlock::operator=(const SBBlock &rhs) { - LLDB_RECORD_METHOD(const lldb::SBBlock &, - SBBlock, operator=,(const lldb::SBBlock &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBBlock &, SBBlock, operator=, + (const lldb::SBBlock &), rhs); m_opaque_ptr = rhs.m_opaque_ptr; return *this; @@ -45,16 +46,19 @@ SBBlock::~SBBlock() { m_opaque_ptr = nullptr; } bool SBBlock::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBlock, IsValid); return this->operator bool(); } SBBlock::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBlock, operator bool); return m_opaque_ptr != nullptr; } bool SBBlock::IsInlined() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBlock, IsInlined); if (m_opaque_ptr) @@ -63,6 +67,7 @@ } const char *SBBlock::GetInlinedName() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBlock, GetInlinedName); if (m_opaque_ptr) { @@ -76,6 +81,7 @@ } SBFileSpec SBBlock::GetInlinedCallSiteFile() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBBlock, GetInlinedCallSiteFile); @@ -90,6 +96,7 @@ } uint32_t SBBlock::GetInlinedCallSiteLine() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBlock, GetInlinedCallSiteLine); if (m_opaque_ptr) { @@ -102,6 +109,7 @@ } uint32_t SBBlock::GetInlinedCallSiteColumn() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBlock, GetInlinedCallSiteColumn); if (m_opaque_ptr) { @@ -123,6 +131,7 @@ } SBBlock SBBlock::GetParent() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetParent); SBBlock sb_block; @@ -132,6 +141,7 @@ } lldb::SBBlock SBBlock::GetContainingInlinedBlock() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetContainingInlinedBlock); SBBlock sb_block; @@ -141,6 +151,7 @@ } SBBlock SBBlock::GetSibling() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetSibling); SBBlock sb_block; @@ -150,6 +161,7 @@ } SBBlock SBBlock::GetFirstChild() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetFirstChild); SBBlock sb_block; @@ -163,6 +175,7 @@ void SBBlock::SetPtr(lldb_private::Block *block) { m_opaque_ptr = block; } bool SBBlock::GetDescription(SBStream &description) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBBlock, GetDescription, (lldb::SBStream &), description); @@ -188,6 +201,7 @@ } uint32_t SBBlock::GetNumRanges() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBBlock, GetNumRanges); if (m_opaque_ptr) @@ -196,6 +210,7 @@ } lldb::SBAddress SBBlock::GetRangeStartAddress(uint32_t idx) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBAddress, SBBlock, GetRangeStartAddress, (uint32_t), idx); @@ -210,6 +225,7 @@ } lldb::SBAddress SBBlock::GetRangeEndAddress(uint32_t idx) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBAddress, SBBlock, GetRangeEndAddress, (uint32_t), idx); @@ -225,6 +241,7 @@ } uint32_t SBBlock::GetRangeIndexForBlockAddress(lldb::SBAddress block_addr) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(uint32_t, SBBlock, GetRangeIndexForBlockAddress, (lldb::SBAddress), block_addr); @@ -238,6 +255,7 @@ lldb::SBValueList SBBlock::GetVariables(lldb::SBFrame &frame, bool arguments, bool locals, bool statics, lldb::DynamicValueType use_dynamic) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD( lldb::SBValueList, SBBlock, GetVariables, (lldb::SBFrame &, bool, bool, bool, lldb::DynamicValueType), frame, @@ -294,6 +312,7 @@ lldb::SBValueList SBBlock::GetVariables(lldb::SBTarget &target, bool arguments, bool locals, bool statics) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValueList, SBBlock, GetVariables, (lldb::SBTarget &, bool, bool, bool), target, arguments, locals, statics); Index: lldb/source/API/SBBreakpoint.cpp =================================================================== --- lldb/source/API/SBBreakpoint.cpp +++ lldb/source/API/SBBreakpoint.cpp @@ -60,28 +60,32 @@ SBBreakpoint::~SBBreakpoint() = default; const SBBreakpoint &SBBreakpoint::operator=(const SBBreakpoint &rhs) { - LLDB_RECORD_METHOD(const lldb::SBBreakpoint &, - SBBreakpoint, operator=,(const lldb::SBBreakpoint &), rhs); + LLDB_SCOPED_TIMER(); + 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); + LLDB_SCOPED_TIMER(); + 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); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(bool, SBBreakpoint, operator!=, + (const lldb::SBBreakpoint &), rhs); return m_opaque_wp.lock() != rhs.m_opaque_wp.lock(); } SBTarget SBBreakpoint::GetTarget() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBTarget, SBBreakpoint, GetTarget); BreakpointSP bkpt_sp = GetSP(); @@ -92,6 +96,7 @@ } break_id_t SBBreakpoint::GetID() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::break_id_t, SBBreakpoint, GetID); break_id_t break_id = LLDB_INVALID_BREAK_ID; @@ -103,10 +108,12 @@ } bool SBBreakpoint::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, IsValid); return this->operator bool(); } SBBreakpoint::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, operator bool); BreakpointSP bkpt_sp = GetSP(); @@ -119,6 +126,7 @@ } void SBBreakpoint::ClearAllBreakpointSites() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBBreakpoint, ClearAllBreakpointSites); BreakpointSP bkpt_sp = GetSP(); @@ -130,6 +138,7 @@ } SBBreakpointLocation SBBreakpoint::FindLocationByAddress(addr_t vm_addr) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBBreakpointLocation, SBBreakpoint, FindLocationByAddress, (lldb::addr_t), vm_addr); @@ -152,6 +161,7 @@ } break_id_t SBBreakpoint::FindLocationIDByAddress(addr_t vm_addr) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::break_id_t, SBBreakpoint, FindLocationIDByAddress, (lldb::addr_t), vm_addr); @@ -173,6 +183,7 @@ } SBBreakpointLocation SBBreakpoint::FindLocationByID(break_id_t bp_loc_id) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBBreakpointLocation, SBBreakpoint, FindLocationByID, (lldb::break_id_t), bp_loc_id); @@ -189,6 +200,7 @@ } SBBreakpointLocation SBBreakpoint::GetLocationAtIndex(uint32_t index) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBBreakpointLocation, SBBreakpoint, GetLocationAtIndex, (uint32_t), index); @@ -205,6 +217,7 @@ } void SBBreakpoint::SetEnabled(bool enable) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpoint, SetEnabled, (bool), enable); BreakpointSP bkpt_sp = GetSP(); @@ -217,6 +230,7 @@ } bool SBBreakpoint::IsEnabled() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpoint, IsEnabled); BreakpointSP bkpt_sp = GetSP(); @@ -229,6 +243,7 @@ } void SBBreakpoint::SetOneShot(bool one_shot) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpoint, SetOneShot, (bool), one_shot); BreakpointSP bkpt_sp = GetSP(); @@ -241,6 +256,7 @@ } bool SBBreakpoint::IsOneShot() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, IsOneShot); BreakpointSP bkpt_sp = GetSP(); @@ -253,6 +269,7 @@ } bool SBBreakpoint::IsInternal() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpoint, IsInternal); BreakpointSP bkpt_sp = GetSP(); @@ -265,6 +282,7 @@ } void SBBreakpoint::SetIgnoreCount(uint32_t count) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpoint, SetIgnoreCount, (uint32_t), count); BreakpointSP bkpt_sp = GetSP(); @@ -277,6 +295,7 @@ } void SBBreakpoint::SetCondition(const char *condition) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpoint, SetCondition, (const char *), condition); @@ -289,6 +308,7 @@ } const char *SBBreakpoint::GetCondition() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBBreakpoint, GetCondition); BreakpointSP bkpt_sp = GetSP(); @@ -301,6 +321,7 @@ } void SBBreakpoint::SetAutoContinue(bool auto_continue) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpoint, SetAutoContinue, (bool), auto_continue); @@ -313,6 +334,7 @@ } bool SBBreakpoint::GetAutoContinue() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpoint, GetAutoContinue); BreakpointSP bkpt_sp = GetSP(); @@ -325,6 +347,7 @@ } uint32_t SBBreakpoint::GetHitCount() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpoint, GetHitCount); uint32_t count = 0; @@ -339,6 +362,7 @@ } uint32_t SBBreakpoint::GetIgnoreCount() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpoint, GetIgnoreCount); uint32_t count = 0; @@ -353,6 +377,7 @@ } void SBBreakpoint::SetThreadID(tid_t tid) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpoint, SetThreadID, (lldb::tid_t), tid); BreakpointSP bkpt_sp = GetSP(); @@ -364,6 +389,7 @@ } tid_t SBBreakpoint::GetThreadID() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBBreakpoint, GetThreadID); tid_t tid = LLDB_INVALID_THREAD_ID; @@ -378,6 +404,7 @@ } void SBBreakpoint::SetThreadIndex(uint32_t index) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpoint, SetThreadIndex, (uint32_t), index); BreakpointSP bkpt_sp = GetSP(); @@ -389,6 +416,7 @@ } uint32_t SBBreakpoint::GetThreadIndex() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpoint, GetThreadIndex); uint32_t thread_idx = UINT32_MAX; @@ -406,6 +434,7 @@ } void SBBreakpoint::SetThreadName(const char *thread_name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpoint, SetThreadName, (const char *), thread_name); @@ -419,6 +448,7 @@ } const char *SBBreakpoint::GetThreadName() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpoint, GetThreadName); const char *name = nullptr; @@ -436,6 +466,7 @@ } void SBBreakpoint::SetQueueName(const char *queue_name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpoint, SetQueueName, (const char *), queue_name); @@ -448,6 +479,7 @@ } const char *SBBreakpoint::GetQueueName() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpoint, GetQueueName); const char *name = nullptr; @@ -465,6 +497,7 @@ } size_t SBBreakpoint::GetNumResolvedLocations() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBBreakpoint, GetNumResolvedLocations); @@ -479,6 +512,7 @@ } size_t SBBreakpoint::GetNumLocations() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBBreakpoint, GetNumLocations); BreakpointSP bkpt_sp = GetSP(); @@ -492,6 +526,7 @@ } void SBBreakpoint::SetCommandLineCommands(SBStringList &commands) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpoint, SetCommandLineCommands, (lldb::SBStringList &), commands); @@ -510,6 +545,7 @@ } bool SBBreakpoint::GetCommandLineCommands(SBStringList &commands) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBBreakpoint, GetCommandLineCommands, (lldb::SBStringList &), commands); @@ -525,12 +561,14 @@ } bool SBBreakpoint::GetDescription(SBStream &s) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBBreakpoint, GetDescription, (lldb::SBStream &), s); return GetDescription(s, true); } bool SBBreakpoint::GetDescription(SBStream &s, bool include_locations) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBBreakpoint, GetDescription, (lldb::SBStream &, bool), s, include_locations); @@ -552,6 +590,7 @@ } SBError SBBreakpoint::AddLocation(SBAddress &address) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBBreakpoint, AddLocation, (lldb::SBAddress &), address); @@ -586,6 +625,7 @@ } SBStructuredData SBBreakpoint::SerializeToStructuredData() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStructuredData, SBBreakpoint, SerializeToStructuredData); @@ -601,6 +641,7 @@ } void SBBreakpoint::SetCallback(SBBreakpointHitCallback callback, void *baton) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpoint, SetCallback, (lldb::SBBreakpointHitCallback, void *), callback, baton); @@ -618,8 +659,9 @@ void SBBreakpoint::SetScriptCallbackFunction( const char *callback_function_name) { -LLDB_RECORD_METHOD(void, SBBreakpoint, SetScriptCallbackFunction, - (const char *), callback_function_name); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(void, SBBreakpoint, SetScriptCallbackFunction, + (const char *), callback_function_name); SBStructuredData empty_args; SetScriptCallbackFunction(callback_function_name, empty_args); } @@ -627,8 +669,10 @@ SBError SBBreakpoint::SetScriptCallbackFunction( const char *callback_function_name, SBStructuredData &extra_args) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(SBError, SBBreakpoint, SetScriptCallbackFunction, - (const char *, SBStructuredData &), callback_function_name, extra_args); + (const char *, SBStructuredData &), callback_function_name, + extra_args); SBError sb_error; BreakpointSP bkpt_sp = GetSP(); @@ -652,6 +696,7 @@ } SBError SBBreakpoint::SetScriptCallbackBody(const char *callback_body_text) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBBreakpoint, SetScriptCallbackBody, (const char *), callback_body_text); @@ -675,6 +720,7 @@ } bool SBBreakpoint::AddName(const char *new_name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBBreakpoint, AddName, (const char *), new_name); SBError status = AddNameWithErrorHandling(new_name); @@ -682,6 +728,7 @@ } SBError SBBreakpoint::AddNameWithErrorHandling(const char *new_name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(SBError, SBBreakpoint, AddNameWithErrorHandling, (const char *), new_name); @@ -702,6 +749,7 @@ } void SBBreakpoint::RemoveName(const char *name_to_remove) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpoint, RemoveName, (const char *), name_to_remove); @@ -716,6 +764,7 @@ } bool SBBreakpoint::MatchesName(const char *name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBBreakpoint, MatchesName, (const char *), name); BreakpointSP bkpt_sp = GetSP(); @@ -730,6 +779,7 @@ } void SBBreakpoint::GetNames(SBStringList &names) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpoint, GetNames, (lldb::SBStringList &), names); @@ -807,6 +857,7 @@ } bool SBBreakpoint::IsHardware() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, IsHardware); BreakpointSP bkpt_sp = GetSP(); @@ -909,6 +960,7 @@ SBBreakpointList::~SBBreakpointList() = default; size_t SBBreakpointList::GetSize() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBBreakpointList, GetSize); if (!m_opaque_sp) @@ -918,6 +970,7 @@ } SBBreakpoint SBBreakpointList::GetBreakpointAtIndex(size_t idx) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBBreakpointList, GetBreakpointAtIndex, (size_t), idx); @@ -929,6 +982,7 @@ } SBBreakpoint SBBreakpointList::FindBreakpointByID(lldb::break_id_t id) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBBreakpointList, FindBreakpointByID, (lldb::break_id_t), id); @@ -939,6 +993,7 @@ } void SBBreakpointList::Append(const SBBreakpoint &sb_bkpt) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpointList, Append, (const lldb::SBBreakpoint &), sb_bkpt); @@ -950,6 +1005,7 @@ } void SBBreakpointList::AppendByID(lldb::break_id_t id) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpointList, AppendByID, (lldb::break_id_t), id); @@ -959,6 +1015,7 @@ } bool SBBreakpointList::AppendIfUnique(const SBBreakpoint &sb_bkpt) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBBreakpointList, AppendIfUnique, (const lldb::SBBreakpoint &), sb_bkpt); @@ -970,6 +1027,7 @@ } void SBBreakpointList::Clear() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBBreakpointList, Clear); if (m_opaque_sp) Index: lldb/source/API/SBBreakpointLocation.cpp =================================================================== --- lldb/source/API/SBBreakpointLocation.cpp +++ lldb/source/API/SBBreakpointLocation.cpp @@ -50,10 +50,10 @@ const SBBreakpointLocation &SBBreakpointLocation:: operator=(const SBBreakpointLocation &rhs) { - LLDB_RECORD_METHOD( - const lldb::SBBreakpointLocation &, - SBBreakpointLocation, operator=,(const lldb::SBBreakpointLocation &), - rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBBreakpointLocation &, + SBBreakpointLocation, operator=, + (const lldb::SBBreakpointLocation &), rhs); m_opaque_wp = rhs.m_opaque_wp; return *this; @@ -66,16 +66,19 @@ } bool SBBreakpointLocation::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointLocation, IsValid); return this->operator bool(); } SBBreakpointLocation::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointLocation, operator bool); return bool(GetSP()); } SBAddress SBBreakpointLocation::GetAddress() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBBreakpointLocation, GetAddress); BreakpointLocationSP loc_sp = GetSP(); @@ -87,6 +90,7 @@ } addr_t SBBreakpointLocation::GetLoadAddress() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBBreakpointLocation, GetLoadAddress); @@ -103,6 +107,7 @@ } void SBBreakpointLocation::SetEnabled(bool enabled) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetEnabled, (bool), enabled); BreakpointLocationSP loc_sp = GetSP(); @@ -114,6 +119,7 @@ } bool SBBreakpointLocation::IsEnabled() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointLocation, IsEnabled); BreakpointLocationSP loc_sp = GetSP(); @@ -126,6 +132,7 @@ } uint32_t SBBreakpointLocation::GetHitCount() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBBreakpointLocation, GetHitCount); BreakpointLocationSP loc_sp = GetSP(); @@ -138,6 +145,7 @@ } uint32_t SBBreakpointLocation::GetIgnoreCount() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBBreakpointLocation, GetIgnoreCount); BreakpointLocationSP loc_sp = GetSP(); @@ -150,6 +158,7 @@ } void SBBreakpointLocation::SetIgnoreCount(uint32_t n) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetIgnoreCount, (uint32_t), n); BreakpointLocationSP loc_sp = GetSP(); @@ -161,6 +170,7 @@ } void SBBreakpointLocation::SetCondition(const char *condition) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetCondition, (const char *), condition); @@ -173,6 +183,7 @@ } const char *SBBreakpointLocation::GetCondition() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBBreakpointLocation, GetCondition); BreakpointLocationSP loc_sp = GetSP(); @@ -185,6 +196,7 @@ } void SBBreakpointLocation::SetAutoContinue(bool auto_continue) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetAutoContinue, (bool), auto_continue); @@ -197,6 +209,7 @@ } bool SBBreakpointLocation::GetAutoContinue() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointLocation, GetAutoContinue); BreakpointLocationSP loc_sp = GetSP(); @@ -210,13 +223,15 @@ void SBBreakpointLocation::SetScriptCallbackFunction( const char *callback_function_name) { -LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetScriptCallbackFunction, - (const char *), callback_function_name); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetScriptCallbackFunction, + (const char *), callback_function_name); } SBError SBBreakpointLocation::SetScriptCallbackFunction( const char *callback_function_name, SBStructuredData &extra_args) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(SBError, SBBreakpointLocation, SetScriptCallbackFunction, (const char *, SBStructuredData &), callback_function_name, extra_args); @@ -245,6 +260,7 @@ SBError SBBreakpointLocation::SetScriptCallbackBody(const char *callback_body_text) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBBreakpointLocation, SetScriptCallbackBody, (const char *), callback_body_text); @@ -269,6 +285,7 @@ } void SBBreakpointLocation::SetCommandLineCommands(SBStringList &commands) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetCommandLineCommands, (lldb::SBStringList &), commands); @@ -287,6 +304,7 @@ } bool SBBreakpointLocation::GetCommandLineCommands(SBStringList &commands) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBBreakpointLocation, GetCommandLineCommands, (lldb::SBStringList &), commands); @@ -302,6 +320,7 @@ } void SBBreakpointLocation::SetThreadID(tid_t thread_id) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetThreadID, (lldb::tid_t), thread_id); @@ -314,6 +333,7 @@ } tid_t SBBreakpointLocation::GetThreadID() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBBreakpointLocation, GetThreadID); tid_t tid = LLDB_INVALID_THREAD_ID; @@ -327,6 +347,7 @@ } void SBBreakpointLocation::SetThreadIndex(uint32_t index) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetThreadIndex, (uint32_t), index); @@ -339,6 +360,7 @@ } uint32_t SBBreakpointLocation::GetThreadIndex() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointLocation, GetThreadIndex); @@ -353,6 +375,7 @@ } void SBBreakpointLocation::SetThreadName(const char *thread_name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetThreadName, (const char *), thread_name); @@ -365,6 +388,7 @@ } const char *SBBreakpointLocation::GetThreadName() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointLocation, GetThreadName); @@ -378,6 +402,7 @@ } void SBBreakpointLocation::SetQueueName(const char *queue_name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetQueueName, (const char *), queue_name); @@ -390,6 +415,7 @@ } const char *SBBreakpointLocation::GetQueueName() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointLocation, GetQueueName); @@ -403,6 +429,7 @@ } bool SBBreakpointLocation::IsResolved() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointLocation, IsResolved); BreakpointLocationSP loc_sp = GetSP(); @@ -422,6 +449,7 @@ bool SBBreakpointLocation::GetDescription(SBStream &description, DescriptionLevel level) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBBreakpointLocation, GetDescription, (lldb::SBStream &, lldb::DescriptionLevel), description, level); @@ -441,6 +469,7 @@ } break_id_t SBBreakpointLocation::GetID() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::break_id_t, SBBreakpointLocation, GetID); BreakpointLocationSP loc_sp = GetSP(); @@ -453,6 +482,7 @@ } SBBreakpoint SBBreakpointLocation::GetBreakpoint() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBreakpoint, SBBreakpointLocation, GetBreakpoint); Index: lldb/source/API/SBBreakpointName.cpp =================================================================== --- lldb/source/API/SBBreakpointName.cpp +++ lldb/source/API/SBBreakpointName.cpp @@ -163,9 +163,10 @@ const SBBreakpointName &SBBreakpointName:: operator=(const SBBreakpointName &rhs) { - LLDB_RECORD_METHOD( - const lldb::SBBreakpointName &, - SBBreakpointName, operator=,(const lldb::SBBreakpointName &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBBreakpointName &, + SBBreakpointName, operator=, + (const lldb::SBBreakpointName &), rhs); if (!rhs.m_impl_up) { m_impl_up.reset(); @@ -178,24 +179,28 @@ } bool SBBreakpointName::operator==(const lldb::SBBreakpointName &rhs) { - LLDB_RECORD_METHOD( - bool, SBBreakpointName, operator==,(const lldb::SBBreakpointName &), rhs); + LLDB_SCOPED_TIMER(); + 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); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(bool, SBBreakpointName, operator!=, + (const lldb::SBBreakpointName &), rhs); return *m_impl_up != *rhs.m_impl_up; } bool SBBreakpointName::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, IsValid); return this->operator bool(); } SBBreakpointName::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, operator bool); if (!m_impl_up) @@ -204,6 +209,7 @@ } const char *SBBreakpointName::GetName() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName, GetName); if (!m_impl_up) @@ -212,6 +218,7 @@ } void SBBreakpointName::SetEnabled(bool enable) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpointName, SetEnabled, (bool), enable); BreakpointName *bp_name = GetBreakpointName(); @@ -236,6 +243,7 @@ } bool SBBreakpointName::IsEnabled() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, IsEnabled); BreakpointName *bp_name = GetBreakpointName(); @@ -249,6 +257,7 @@ } void SBBreakpointName::SetOneShot(bool one_shot) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpointName, SetOneShot, (bool), one_shot); BreakpointName *bp_name = GetBreakpointName(); @@ -263,6 +272,7 @@ } bool SBBreakpointName::IsOneShot() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, IsOneShot); const BreakpointName *bp_name = GetBreakpointName(); @@ -276,6 +286,7 @@ } void SBBreakpointName::SetIgnoreCount(uint32_t count) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpointName, SetIgnoreCount, (uint32_t), count); BreakpointName *bp_name = GetBreakpointName(); @@ -290,6 +301,7 @@ } uint32_t SBBreakpointName::GetIgnoreCount() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointName, GetIgnoreCount); BreakpointName *bp_name = GetBreakpointName(); @@ -303,6 +315,7 @@ } void SBBreakpointName::SetCondition(const char *condition) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpointName, SetCondition, (const char *), condition); @@ -318,6 +331,7 @@ } const char *SBBreakpointName::GetCondition() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBBreakpointName, GetCondition); BreakpointName *bp_name = GetBreakpointName(); @@ -331,6 +345,7 @@ } void SBBreakpointName::SetAutoContinue(bool auto_continue) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpointName, SetAutoContinue, (bool), auto_continue); @@ -346,6 +361,7 @@ } bool SBBreakpointName::GetAutoContinue() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAutoContinue); BreakpointName *bp_name = GetBreakpointName(); @@ -359,6 +375,7 @@ } void SBBreakpointName::SetThreadID(tid_t tid) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadID, (lldb::tid_t), tid); BreakpointName *bp_name = GetBreakpointName(); @@ -373,6 +390,7 @@ } tid_t SBBreakpointName::GetThreadID() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBBreakpointName, GetThreadID); BreakpointName *bp_name = GetBreakpointName(); @@ -386,6 +404,7 @@ } void SBBreakpointName::SetThreadIndex(uint32_t index) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadIndex, (uint32_t), index); BreakpointName *bp_name = GetBreakpointName(); @@ -400,6 +419,7 @@ } uint32_t SBBreakpointName::GetThreadIndex() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointName, GetThreadIndex); BreakpointName *bp_name = GetBreakpointName(); @@ -413,6 +433,7 @@ } void SBBreakpointName::SetThreadName(const char *thread_name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadName, (const char *), thread_name); @@ -428,6 +449,7 @@ } const char *SBBreakpointName::GetThreadName() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName, GetThreadName); @@ -442,6 +464,7 @@ } void SBBreakpointName::SetQueueName(const char *queue_name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpointName, SetQueueName, (const char *), queue_name); @@ -457,6 +480,7 @@ } const char *SBBreakpointName::GetQueueName() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName, GetQueueName); @@ -471,6 +495,7 @@ } void SBBreakpointName::SetCommandLineCommands(SBStringList &commands) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpointName, SetCommandLineCommands, (lldb::SBStringList &), commands); @@ -491,6 +516,7 @@ } bool SBBreakpointName::GetCommandLineCommands(SBStringList &commands) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBBreakpointName, GetCommandLineCommands, (lldb::SBStringList &), commands); @@ -507,6 +533,7 @@ } const char *SBBreakpointName::GetHelpString() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName, GetHelpString); @@ -518,6 +545,7 @@ } void SBBreakpointName::SetHelpString(const char *help_string) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpointName, SetHelpString, (const char *), help_string); @@ -532,6 +560,7 @@ } bool SBBreakpointName::GetDescription(SBStream &s) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBBreakpointName, GetDescription, (lldb::SBStream &), s); @@ -550,6 +579,7 @@ void SBBreakpointName::SetCallback(SBBreakpointHitCallback callback, void *baton) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpointName, SetCallback, (lldb::SBBreakpointHitCallback, void *), callback, baton); @@ -569,8 +599,9 @@ void SBBreakpointName::SetScriptCallbackFunction( const char *callback_function_name) { -LLDB_RECORD_METHOD(void, SBBreakpointName, SetScriptCallbackFunction, - (const char *), callback_function_name); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(void, SBBreakpointName, SetScriptCallbackFunction, + (const char *), callback_function_name); SBStructuredData empty_args; SetScriptCallbackFunction(callback_function_name, empty_args); } @@ -578,9 +609,10 @@ SBError SBBreakpointName::SetScriptCallbackFunction( const char *callback_function_name, SBStructuredData &extra_args) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(SBError, SBBreakpointName, SetScriptCallbackFunction, - (const char *, SBStructuredData &), - callback_function_name, extra_args); + (const char *, SBStructuredData &), callback_function_name, + extra_args); SBError sb_error; BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) { @@ -606,6 +638,7 @@ SBError SBBreakpointName::SetScriptCallbackBody(const char *callback_body_text) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBBreakpointName, SetScriptCallbackBody, (const char *), callback_body_text); @@ -631,6 +664,7 @@ } bool SBBreakpointName::GetAllowList() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, GetAllowList); BreakpointName *bp_name = GetBreakpointName(); @@ -640,9 +674,9 @@ } void SBBreakpointName::SetAllowList(bool value) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowList, (bool), value); - BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) return; @@ -650,6 +684,7 @@ } bool SBBreakpointName::GetAllowDelete() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAllowDelete); BreakpointName *bp_name = GetBreakpointName(); @@ -659,9 +694,9 @@ } void SBBreakpointName::SetAllowDelete(bool value) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowDelete, (bool), value); - BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) return; @@ -669,6 +704,7 @@ } bool SBBreakpointName::GetAllowDisable() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAllowDisable); BreakpointName *bp_name = GetBreakpointName(); @@ -678,6 +714,7 @@ } void SBBreakpointName::SetAllowDisable(bool value) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowDisable, (bool), value); BreakpointName *bp_name = GetBreakpointName(); Index: lldb/source/API/SBBroadcaster.cpp =================================================================== --- lldb/source/API/SBBroadcaster.cpp +++ lldb/source/API/SBBroadcaster.cpp @@ -36,9 +36,9 @@ } const SBBroadcaster &SBBroadcaster::operator=(const SBBroadcaster &rhs) { - LLDB_RECORD_METHOD(const lldb::SBBroadcaster &, - SBBroadcaster, operator=,(const lldb::SBBroadcaster &), - rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBBroadcaster &, SBBroadcaster, operator=, + (const lldb::SBBroadcaster &), rhs); if (this != &rhs) { m_opaque_sp = rhs.m_opaque_sp; @@ -50,6 +50,7 @@ SBBroadcaster::~SBBroadcaster() { reset(nullptr, false); } void SBBroadcaster::BroadcastEventByType(uint32_t event_type, bool unique) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBroadcaster, BroadcastEventByType, (uint32_t, bool), event_type, unique); @@ -63,6 +64,7 @@ } void SBBroadcaster::BroadcastEvent(const SBEvent &event, bool unique) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBroadcaster, BroadcastEvent, (const lldb::SBEvent &, bool), event, unique); @@ -78,6 +80,7 @@ void SBBroadcaster::AddInitialEventsToListener(const SBListener &listener, uint32_t requested_events) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBBroadcaster, AddInitialEventsToListener, (const lldb::SBListener &, uint32_t), listener, requested_events); @@ -89,6 +92,7 @@ uint32_t SBBroadcaster::AddListener(const SBListener &listener, uint32_t event_mask) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(uint32_t, SBBroadcaster, AddListener, (const lldb::SBListener &, uint32_t), listener, event_mask); @@ -99,6 +103,7 @@ } const char *SBBroadcaster::GetName() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBroadcaster, GetName); if (m_opaque_ptr) @@ -107,6 +112,7 @@ } bool SBBroadcaster::EventTypeHasListeners(uint32_t event_type) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBBroadcaster, EventTypeHasListeners, (uint32_t), event_type); @@ -117,6 +123,7 @@ bool SBBroadcaster::RemoveListener(const SBListener &listener, uint32_t event_mask) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBBroadcaster, RemoveListener, (const lldb::SBListener &, uint32_t), listener, event_mask); @@ -137,16 +144,19 @@ } bool SBBroadcaster::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBroadcaster, IsValid); return this->operator bool(); } SBBroadcaster::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBroadcaster, operator bool); return m_opaque_ptr != nullptr; } void SBBroadcaster::Clear() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBBroadcaster, Clear); m_opaque_sp.reset(); @@ -154,22 +164,25 @@ } bool SBBroadcaster::operator==(const SBBroadcaster &rhs) const { - LLDB_RECORD_METHOD_CONST( - bool, SBBroadcaster, operator==,(const lldb::SBBroadcaster &), rhs); + LLDB_SCOPED_TIMER(); + 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); + LLDB_SCOPED_TIMER(); + 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); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD_CONST(bool, SBBroadcaster, operator<, + (const lldb::SBBroadcaster &), rhs); return m_opaque_ptr < rhs.m_opaque_ptr; } Index: lldb/source/API/SBCommandInterpreter.cpp =================================================================== --- lldb/source/API/SBCommandInterpreter.cpp +++ lldb/source/API/SBCommandInterpreter.cpp @@ -93,26 +93,29 @@ const SBCommandInterpreter &SBCommandInterpreter:: operator=(const SBCommandInterpreter &rhs) { - LLDB_RECORD_METHOD( - const lldb::SBCommandInterpreter &, - SBCommandInterpreter, operator=,(const lldb::SBCommandInterpreter &), - rhs); + LLDB_SCOPED_TIMER(); + 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 { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, IsValid); return this->operator bool(); } SBCommandInterpreter::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, operator bool); return m_opaque_ptr != nullptr; } bool SBCommandInterpreter::CommandExists(const char *cmd) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBCommandInterpreter, CommandExists, (const char *), cmd); @@ -121,6 +124,7 @@ } bool SBCommandInterpreter::AliasExists(const char *cmd) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBCommandInterpreter, AliasExists, (const char *), cmd); @@ -129,18 +133,21 @@ } bool SBCommandInterpreter::IsActive() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, IsActive); return (IsValid() ? m_opaque_ptr->IsActive() : false); } bool SBCommandInterpreter::WasInterrupted() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, WasInterrupted); return (IsValid() ? m_opaque_ptr->WasInterrupted() : false); } const char *SBCommandInterpreter::GetIOHandlerControlSequence(char ch) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(const char *, SBCommandInterpreter, GetIOHandlerControlSequence, (char), ch); @@ -155,6 +162,7 @@ SBCommandInterpreter::HandleCommand(const char *command_line, SBCommandReturnObject &result, bool add_to_history) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::ReturnStatus, SBCommandInterpreter, HandleCommand, (const char *, lldb::SBCommandReturnObject &, bool), command_line, result, add_to_history); @@ -166,6 +174,7 @@ lldb::ReturnStatus SBCommandInterpreter::HandleCommand( const char *command_line, SBExecutionContext &override_context, SBCommandReturnObject &result, bool add_to_history) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::ReturnStatus, SBCommandInterpreter, HandleCommand, (const char *, lldb::SBExecutionContext &, lldb::SBCommandReturnObject &, bool), @@ -194,6 +203,7 @@ lldb::SBFileSpec &file, lldb::SBExecutionContext &override_context, lldb::SBCommandInterpreterRunOptions &options, lldb::SBCommandReturnObject result) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBCommandInterpreter, HandleCommandsFromFile, (lldb::SBFileSpec &, lldb::SBExecutionContext &, lldb::SBCommandInterpreterRunOptions &, @@ -225,6 +235,7 @@ 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_SCOPED_TIMER(); LLDB_RECORD_METHOD(int, SBCommandInterpreter, HandleCompletion, (const char *, const char *, const char *, int, int, lldb::SBStringList &), @@ -241,6 +252,7 @@ const char *current_line, const char *cursor, const char *last_char, int match_start_point, int max_return_elements, SBStringList &matches, SBStringList &descriptions) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(int, SBCommandInterpreter, HandleCompletionWithDescriptions, (const char *, const char *, const char *, int, int, @@ -311,6 +323,7 @@ const char *current_line, uint32_t cursor_pos, int match_start_point, int max_return_elements, SBStringList &matches, SBStringList &descriptions) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(int, SBCommandInterpreter, HandleCompletionWithDescriptions, (const char *, uint32_t, int, int, lldb::SBStringList &, @@ -330,6 +343,7 @@ int match_start_point, int max_return_elements, lldb::SBStringList &matches) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(int, SBCommandInterpreter, HandleCompletion, (const char *, uint32_t, int, int, lldb::SBStringList &), current_line, cursor_pos, match_start_point, @@ -342,24 +356,28 @@ } bool SBCommandInterpreter::HasCommands() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasCommands); return (IsValid() ? m_opaque_ptr->HasCommands() : false); } bool SBCommandInterpreter::HasAliases() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasAliases); return (IsValid() ? m_opaque_ptr->HasAliases() : false); } bool SBCommandInterpreter::HasAliasOptions() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasAliasOptions); return (IsValid() ? m_opaque_ptr->HasAliasOptions() : false); } SBProcess SBCommandInterpreter::GetProcess() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBCommandInterpreter, GetProcess); SBProcess sb_process; @@ -377,6 +395,7 @@ } SBDebugger SBCommandInterpreter::GetDebugger() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBDebugger, SBCommandInterpreter, GetDebugger); @@ -388,12 +407,14 @@ } bool SBCommandInterpreter::GetPromptOnQuit() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, GetPromptOnQuit); return (IsValid() ? m_opaque_ptr->GetPromptOnQuit() : false); } void SBCommandInterpreter::SetPromptOnQuit(bool b) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBCommandInterpreter, SetPromptOnQuit, (bool), b); if (IsValid()) @@ -401,6 +422,7 @@ } void SBCommandInterpreter::AllowExitCodeOnQuit(bool allow) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBCommandInterpreter, AllowExitCodeOnQuit, (bool), allow); @@ -409,6 +431,7 @@ } bool SBCommandInterpreter::HasCustomQuitExitCode() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasCustomQuitExitCode); bool exited = false; @@ -418,6 +441,7 @@ } int SBCommandInterpreter::GetQuitStatus() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(int, SBCommandInterpreter, GetQuitStatus); bool exited = false; @@ -426,6 +450,7 @@ void SBCommandInterpreter::ResolveCommand(const char *command_line, SBCommandReturnObject &result) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBCommandInterpreter, ResolveCommand, (const char *, lldb::SBCommandReturnObject &), command_line, result); @@ -453,6 +478,7 @@ void SBCommandInterpreter::SourceInitFileInHomeDirectory( SBCommandReturnObject &result) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBCommandInterpreter, SourceInitFileInHomeDirectory, (lldb::SBCommandReturnObject &), result); @@ -470,6 +496,7 @@ void SBCommandInterpreter::SourceInitFileInHomeDirectory( SBCommandReturnObject &result, bool is_repl) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBCommandInterpreter, SourceInitFileInHomeDirectory, (lldb::SBCommandReturnObject &, bool), result, is_repl); @@ -487,6 +514,7 @@ void SBCommandInterpreter::SourceInitFileInCurrentWorkingDirectory( SBCommandReturnObject &result) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBCommandInterpreter, SourceInitFileInCurrentWorkingDirectory, (lldb::SBCommandReturnObject &), result); @@ -504,10 +532,10 @@ } SBBroadcaster SBCommandInterpreter::GetBroadcaster() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBroadcaster, SBCommandInterpreter, GetBroadcaster); - SBBroadcaster broadcaster(m_opaque_ptr, false); return broadcaster; @@ -551,6 +579,7 @@ bool SBCommandInterpreter::SetCommandOverrideCallback( const char *command_name, lldb::CommandOverrideCallback callback, void *baton) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBCommandInterpreter, SetCommandOverrideCallback, (const char *, lldb::CommandOverrideCallback, void *), command_name, callback, baton); @@ -570,6 +599,7 @@ lldb::SBCommand SBCommandInterpreter::AddMultiwordCommand(const char *name, const char *help) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBCommand, SBCommandInterpreter, AddMultiwordCommand, (const char *, const char *), name, help); @@ -584,6 +614,7 @@ lldb::SBCommand SBCommandInterpreter::AddCommand( const char *name, lldb::SBCommandPluginInterface *impl, const char *help) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD( lldb::SBCommand, SBCommandInterpreter, AddCommand, (const char *, lldb::SBCommandPluginInterface *, const char *), name, @@ -597,6 +628,7 @@ SBCommandInterpreter::AddCommand(const char *name, lldb::SBCommandPluginInterface *impl, const char *help, const char *syntax) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand, (const char *, lldb::SBCommandPluginInterface *, const char *, const char *), @@ -607,6 +639,7 @@ lldb::SBCommand SBCommandInterpreter::AddCommand( const char *name, lldb::SBCommandPluginInterface *impl, const char *help, const char *syntax, const char *auto_repeat_command) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand, (const char *, lldb::SBCommandPluginInterface *, const char *, const char *, const char *), @@ -628,22 +661,26 @@ SBCommand::SBCommand(lldb::CommandObjectSP cmd_sp) : m_opaque_sp(cmd_sp) {} bool SBCommand::IsValid() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommand, IsValid); return this->operator bool(); } SBCommand::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommand, operator bool); return m_opaque_sp.get() != nullptr; } const char *SBCommand::GetName() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetName); return (IsValid() ? ConstString(m_opaque_sp->GetCommandName()).AsCString() : nullptr); } const char *SBCommand::GetHelp() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetHelp); return (IsValid() ? ConstString(m_opaque_sp->GetHelp()).AsCString() @@ -651,6 +688,7 @@ } const char *SBCommand::GetHelpLong() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetHelpLong); return (IsValid() ? ConstString(m_opaque_sp->GetHelpLong()).AsCString() @@ -658,6 +696,7 @@ } void SBCommand::SetHelp(const char *help) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBCommand, SetHelp, (const char *), help); if (IsValid()) @@ -665,6 +704,7 @@ } void SBCommand::SetHelpLong(const char *help) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBCommand, SetHelpLong, (const char *), help); if (IsValid()) @@ -673,6 +713,7 @@ lldb::SBCommand SBCommand::AddMultiwordCommand(const char *name, const char *help) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBCommand, SBCommand, AddMultiwordCommand, (const char *, const char *), name, help); @@ -692,6 +733,7 @@ lldb::SBCommand SBCommand::AddCommand(const char *name, lldb::SBCommandPluginInterface *impl, const char *help) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD( lldb::SBCommand, SBCommand, AddCommand, (const char *, lldb::SBCommandPluginInterface *, const char *), name, @@ -703,6 +745,7 @@ lldb::SBCommand SBCommand::AddCommand(const char *name, lldb::SBCommandPluginInterface *impl, const char *help, const char *syntax) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBCommand, SBCommand, AddCommand, (const char *, lldb::SBCommandPluginInterface *, const char *, const char *), @@ -714,6 +757,7 @@ lldb::SBCommandPluginInterface *impl, const char *help, const char *syntax, const char *auto_repeat_command) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBCommand, SBCommand, AddCommand, (const char *, lldb::SBCommandPluginInterface *, const char *, const char *, const char *), @@ -733,12 +777,14 @@ } uint32_t SBCommand::GetFlags() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBCommand, GetFlags); return (IsValid() ? m_opaque_sp->GetFlags().Get() : 0); } void SBCommand::SetFlags(uint32_t flags) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBCommand, SetFlags, (uint32_t), flags); if (IsValid()) Index: lldb/source/API/SBCommandInterpreterRunOptions.cpp =================================================================== --- lldb/source/API/SBCommandInterpreterRunOptions.cpp +++ lldb/source/API/SBCommandInterpreterRunOptions.cpp @@ -36,6 +36,7 @@ SBCommandInterpreterRunOptions &SBCommandInterpreterRunOptions::operator=( const SBCommandInterpreterRunOptions &rhs) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBCommandInterpreterRunOptions &, SBCommandInterpreterRunOptions, operator=, (const lldb::SBCommandInterpreterRunOptions &), rhs); @@ -47,6 +48,7 @@ } bool SBCommandInterpreterRunOptions::GetStopOnContinue() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, GetStopOnContinue); @@ -54,6 +56,7 @@ } void SBCommandInterpreterRunOptions::SetStopOnContinue(bool stop_on_continue) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnContinue, (bool), stop_on_continue); @@ -61,6 +64,7 @@ } bool SBCommandInterpreterRunOptions::GetStopOnError() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, GetStopOnError); @@ -68,6 +72,7 @@ } void SBCommandInterpreterRunOptions::SetStopOnError(bool stop_on_error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnError, (bool), stop_on_error); @@ -75,6 +80,7 @@ } bool SBCommandInterpreterRunOptions::GetStopOnCrash() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, GetStopOnCrash); @@ -82,6 +88,7 @@ } void SBCommandInterpreterRunOptions::SetStopOnCrash(bool stop_on_crash) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnCrash, (bool), stop_on_crash); @@ -89,6 +96,7 @@ } bool SBCommandInterpreterRunOptions::GetEchoCommands() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, GetEchoCommands); @@ -96,6 +104,7 @@ } void SBCommandInterpreterRunOptions::SetEchoCommands(bool echo_commands) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetEchoCommands, (bool), echo_commands); @@ -103,6 +112,7 @@ } bool SBCommandInterpreterRunOptions::GetEchoCommentCommands() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, GetEchoCommentCommands); @@ -110,6 +120,7 @@ } void SBCommandInterpreterRunOptions::SetEchoCommentCommands(bool echo) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetEchoCommentCommands, (bool), echo); @@ -117,6 +128,7 @@ } bool SBCommandInterpreterRunOptions::GetPrintResults() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, GetPrintResults); @@ -124,6 +136,7 @@ } void SBCommandInterpreterRunOptions::SetPrintResults(bool print_results) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetPrintResults, (bool), print_results); @@ -131,6 +144,7 @@ } bool SBCommandInterpreterRunOptions::GetPrintErrors() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, GetPrintErrors); @@ -138,6 +152,7 @@ } void SBCommandInterpreterRunOptions::SetPrintErrors(bool print_errors) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetPrintErrors, (bool), print_errors); @@ -145,6 +160,7 @@ } bool SBCommandInterpreterRunOptions::GetAddToHistory() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, GetAddToHistory); @@ -152,6 +168,7 @@ } void SBCommandInterpreterRunOptions::SetAddToHistory(bool add_to_history) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetAddToHistory, (bool), add_to_history); @@ -159,6 +176,7 @@ } bool SBCommandInterpreterRunOptions::GetAutoHandleEvents() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, GetAutoHandleEvents); @@ -167,6 +185,7 @@ void SBCommandInterpreterRunOptions::SetAutoHandleEvents( bool auto_handle_events) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetAutoHandleEvents, (bool), auto_handle_events); @@ -174,6 +193,7 @@ } bool SBCommandInterpreterRunOptions::GetSpawnThread() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, GetSpawnThread); @@ -181,6 +201,7 @@ } void SBCommandInterpreterRunOptions::SetSpawnThread(bool spawn_thread) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetSpawnThread, (bool), spawn_thread); @@ -222,6 +243,7 @@ SBCommandInterpreterRunResult &SBCommandInterpreterRunResult::operator=( const SBCommandInterpreterRunResult &rhs) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBCommandInterpreterRunResult &, SBCommandInterpreterRunResult, operator=, (const lldb::SBCommandInterpreterRunResult &), rhs); @@ -233,6 +255,7 @@ } int SBCommandInterpreterRunResult::GetNumberOfErrors() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(int, SBCommandInterpreterRunResult, GetNumberOfErrors); @@ -241,6 +264,7 @@ lldb::CommandInterpreterResult SBCommandInterpreterRunResult::GetResult() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::CommandInterpreterResult, SBCommandInterpreterRunResult, GetResult); Index: lldb/source/API/SBCommandReturnObject.cpp =================================================================== --- lldb/source/API/SBCommandReturnObject.cpp +++ lldb/source/API/SBCommandReturnObject.cpp @@ -64,10 +64,10 @@ SBCommandReturnObject &SBCommandReturnObject:: operator=(const SBCommandReturnObject &rhs) { - LLDB_RECORD_METHOD( - lldb::SBCommandReturnObject &, - SBCommandReturnObject, operator=,(const lldb::SBCommandReturnObject &), - rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(lldb::SBCommandReturnObject &, + SBCommandReturnObject, operator=, + (const lldb::SBCommandReturnObject &), rhs); if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); @@ -77,10 +77,12 @@ SBCommandReturnObject::~SBCommandReturnObject() = default; bool SBCommandReturnObject::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandReturnObject, IsValid); return this->operator bool(); } SBCommandReturnObject::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandReturnObject, operator bool); // This method is not useful but it needs to stay to keep SB API stable. @@ -88,6 +90,7 @@ } const char *SBCommandReturnObject::GetOutput() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommandReturnObject, GetOutput); ConstString output(ref().GetOutputData()); @@ -95,6 +98,7 @@ } const char *SBCommandReturnObject::GetError() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommandReturnObject, GetError); ConstString output(ref().GetErrorData()); @@ -102,18 +106,21 @@ } size_t SBCommandReturnObject::GetOutputSize() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(size_t, SBCommandReturnObject, GetOutputSize); return ref().GetOutputData().size(); } size_t SBCommandReturnObject::GetErrorSize() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(size_t, SBCommandReturnObject, GetErrorSize); return ref().GetErrorData().size(); } size_t SBCommandReturnObject::PutOutput(FILE *fh) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutOutput, (FILE *), fh); if (fh) { size_t num_bytes = GetOutputSize(); @@ -124,6 +131,7 @@ } size_t SBCommandReturnObject::PutOutput(FileSP file_sp) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutOutput, (FileSP), file_sp); if (!file_sp) @@ -132,6 +140,7 @@ } size_t SBCommandReturnObject::PutOutput(SBFile file) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutOutput, (SBFile), file); if (!file.m_opaque_sp) return 0; @@ -139,6 +148,7 @@ } size_t SBCommandReturnObject::PutError(FILE *fh) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutError, (FILE *), fh); if (fh) { size_t num_bytes = GetErrorSize(); @@ -149,6 +159,7 @@ } size_t SBCommandReturnObject::PutError(FileSP file_sp) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutError, (FileSP), file_sp); if (!file_sp) @@ -157,6 +168,7 @@ } size_t SBCommandReturnObject::PutError(SBFile file) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutError, (SBFile), file); if (!file.m_opaque_sp) return 0; @@ -164,12 +176,14 @@ } void SBCommandReturnObject::Clear() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBCommandReturnObject, Clear); ref().Clear(); } lldb::ReturnStatus SBCommandReturnObject::GetStatus() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::ReturnStatus, SBCommandReturnObject, GetStatus); @@ -177,6 +191,7 @@ } void SBCommandReturnObject::SetStatus(lldb::ReturnStatus status) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetStatus, (lldb::ReturnStatus), status); @@ -184,18 +199,21 @@ } bool SBCommandReturnObject::Succeeded() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandReturnObject, Succeeded); return ref().Succeeded(); } bool SBCommandReturnObject::HasResult() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandReturnObject, HasResult); return ref().HasResult(); } void SBCommandReturnObject::AppendMessage(const char *message) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBCommandReturnObject, AppendMessage, (const char *), message); @@ -203,6 +221,7 @@ } void SBCommandReturnObject::AppendWarning(const char *message) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBCommandReturnObject, AppendWarning, (const char *), message); @@ -226,6 +245,7 @@ } bool SBCommandReturnObject::GetDescription(SBStream &description) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBCommandReturnObject, GetDescription, (lldb::SBStream &), description); @@ -252,6 +272,7 @@ } void SBCommandReturnObject::SetImmediateOutputFile(FILE *fh) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile, (FILE *), fh); @@ -259,6 +280,7 @@ } void SBCommandReturnObject::SetImmediateErrorFile(FILE *fh) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile, (FILE *), fh); @@ -267,6 +289,7 @@ void SBCommandReturnObject::SetImmediateOutputFile(FILE *fh, bool transfer_ownership) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile, (FILE *, bool), fh, transfer_ownership); FileSP file = std::make_shared(fh, transfer_ownership); @@ -275,6 +298,7 @@ void SBCommandReturnObject::SetImmediateErrorFile(FILE *fh, bool transfer_ownership) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile, (FILE *, bool), fh, transfer_ownership); FileSP file = std::make_shared(fh, transfer_ownership); @@ -282,30 +306,35 @@ } void SBCommandReturnObject::SetImmediateOutputFile(SBFile file) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile, (SBFile), file); ref().SetImmediateOutputFile(file.m_opaque_sp); } void SBCommandReturnObject::SetImmediateErrorFile(SBFile file) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile, (SBFile), file); ref().SetImmediateErrorFile(file.m_opaque_sp); } void SBCommandReturnObject::SetImmediateOutputFile(FileSP file_sp) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile, (FileSP), file_sp); SetImmediateOutputFile(SBFile(file_sp)); } void SBCommandReturnObject::SetImmediateErrorFile(FileSP file_sp) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile, (FileSP), file_sp); SetImmediateErrorFile(SBFile(file_sp)); } void SBCommandReturnObject::PutCString(const char *string, int len) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBCommandReturnObject, PutCString, (const char *, int), string, len); @@ -319,6 +348,7 @@ } const char *SBCommandReturnObject::GetOutput(bool only_if_no_immediate) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(const char *, SBCommandReturnObject, GetOutput, (bool), only_if_no_immediate); @@ -329,6 +359,7 @@ } const char *SBCommandReturnObject::GetError(bool only_if_no_immediate) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(const char *, SBCommandReturnObject, GetError, (bool), only_if_no_immediate); @@ -347,6 +378,7 @@ void SBCommandReturnObject::SetError(lldb::SBError &error, const char *fallback_error_cstr) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetError, (lldb::SBError &, const char *), error, fallback_error_cstr); @@ -358,6 +390,7 @@ } void SBCommandReturnObject::SetError(const char *error_cstr) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetError, (const char *), error_cstr); Index: lldb/source/API/SBCommunication.cpp =================================================================== --- lldb/source/API/SBCommunication.cpp +++ lldb/source/API/SBCommunication.cpp @@ -33,16 +33,19 @@ } bool SBCommunication::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommunication, IsValid); return this->operator bool(); } SBCommunication::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommunication, operator bool); return m_opaque != nullptr; } bool SBCommunication::GetCloseOnEOF() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, GetCloseOnEOF); if (m_opaque) @@ -51,6 +54,7 @@ } void SBCommunication::SetCloseOnEOF(bool b) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBCommunication, SetCloseOnEOF, (bool), b); if (m_opaque) @@ -58,6 +62,7 @@ } ConnectionStatus SBCommunication::Connect(const char *url) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::ConnectionStatus, SBCommunication, Connect, (const char *), url); @@ -70,6 +75,7 @@ } ConnectionStatus SBCommunication::AdoptFileDesriptor(int fd, bool owns_fd) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::ConnectionStatus, SBCommunication, AdoptFileDesriptor, (int, bool), fd, owns_fd); @@ -90,6 +96,7 @@ } ConnectionStatus SBCommunication::Disconnect() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::ConnectionStatus, SBCommunication, Disconnect); @@ -100,6 +107,7 @@ } bool SBCommunication::IsConnected() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommunication, IsConnected); return m_opaque ? m_opaque->IsConnected() : false; @@ -107,6 +115,7 @@ size_t SBCommunication::Read(void *dst, size_t dst_len, uint32_t timeout_usec, ConnectionStatus &status) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(size_t, SBCommunication, Read, (void *, size_t, uint32_t, lldb::ConnectionStatus &), dst, dst_len, timeout_usec, status); @@ -125,6 +134,7 @@ size_t SBCommunication::Write(const void *src, size_t src_len, ConnectionStatus &status) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(size_t, SBCommunication, Write, (const void *, size_t, lldb::ConnectionStatus &), src, src_len, status); @@ -139,18 +149,21 @@ } bool SBCommunication::ReadThreadStart() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadStart); return m_opaque ? m_opaque->StartReadThread() : false; } bool SBCommunication::ReadThreadStop() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadStop); return m_opaque ? m_opaque->StopReadThread() : false; } bool SBCommunication::ReadThreadIsRunning() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadIsRunning); return m_opaque ? m_opaque->ReadThreadIsRunning() : false; @@ -158,6 +171,7 @@ bool SBCommunication::SetReadThreadBytesReceivedCallback( ReadThreadBytesReceived callback, void *callback_baton) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBCommunication, SetReadThreadBytesReceivedCallback, (lldb::SBCommunication::ReadThreadBytesReceived, void *), callback, callback_baton); @@ -171,6 +185,7 @@ } SBBroadcaster SBCommunication::GetBroadcaster() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBroadcaster, SBCommunication, GetBroadcaster); Index: lldb/source/API/SBCompileUnit.cpp =================================================================== --- lldb/source/API/SBCompileUnit.cpp +++ lldb/source/API/SBCompileUnit.cpp @@ -34,9 +34,9 @@ } const SBCompileUnit &SBCompileUnit::operator=(const SBCompileUnit &rhs) { - LLDB_RECORD_METHOD(const lldb::SBCompileUnit &, - SBCompileUnit, operator=,(const lldb::SBCompileUnit &), - rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBCompileUnit &, SBCompileUnit, operator=, + (const lldb::SBCompileUnit &), rhs); m_opaque_ptr = rhs.m_opaque_ptr; return *this; @@ -45,6 +45,7 @@ SBCompileUnit::~SBCompileUnit() { m_opaque_ptr = nullptr; } SBFileSpec SBCompileUnit::GetFileSpec() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBCompileUnit, GetFileSpec); @@ -55,6 +56,7 @@ } uint32_t SBCompileUnit::GetNumLineEntries() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBCompileUnit, GetNumLineEntries); if (m_opaque_ptr) { @@ -67,6 +69,7 @@ } SBLineEntry SBCompileUnit::GetLineEntryAtIndex(uint32_t idx) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(lldb::SBLineEntry, SBCompileUnit, GetLineEntryAtIndex, (uint32_t), idx); @@ -85,6 +88,7 @@ uint32_t SBCompileUnit::FindLineEntryIndex(uint32_t start_idx, uint32_t line, SBFileSpec *inline_file_spec) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex, (uint32_t, uint32_t, lldb::SBFileSpec *), start_idx, line, inline_file_spec); @@ -96,6 +100,7 @@ uint32_t SBCompileUnit::FindLineEntryIndex(uint32_t start_idx, uint32_t line, SBFileSpec *inline_file_spec, bool exact) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex, (uint32_t, uint32_t, lldb::SBFileSpec *, bool), start_idx, line, inline_file_spec, exact); @@ -118,6 +123,7 @@ } uint32_t SBCompileUnit::GetNumSupportFiles() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBCompileUnit, GetNumSupportFiles); if (m_opaque_ptr) @@ -127,6 +133,7 @@ } lldb::SBTypeList SBCompileUnit::GetTypes(uint32_t type_mask) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBTypeList, SBCompileUnit, GetTypes, (uint32_t), type_mask); @@ -151,6 +158,7 @@ } SBFileSpec SBCompileUnit::GetSupportFileAtIndex(uint32_t idx) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(lldb::SBFileSpec, SBCompileUnit, GetSupportFileAtIndex, (uint32_t), idx); @@ -166,6 +174,7 @@ uint32_t SBCompileUnit::FindSupportFileIndex(uint32_t start_idx, const SBFileSpec &sb_file, bool full) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(uint32_t, SBCompileUnit, FindSupportFileIndex, (uint32_t, const lldb::SBFileSpec &, bool), start_idx, sb_file, full); @@ -178,6 +187,7 @@ } lldb::LanguageType SBCompileUnit::GetLanguage() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::LanguageType, SBCompileUnit, GetLanguage); if (m_opaque_ptr) @@ -186,25 +196,29 @@ } bool SBCompileUnit::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCompileUnit, IsValid); return this->operator bool(); } SBCompileUnit::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCompileUnit, operator bool); return m_opaque_ptr != nullptr; } bool SBCompileUnit::operator==(const SBCompileUnit &rhs) const { - LLDB_RECORD_METHOD_CONST( - bool, SBCompileUnit, operator==,(const lldb::SBCompileUnit &), rhs); + LLDB_SCOPED_TIMER(); + 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); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD_CONST(bool, SBCompileUnit, operator!=, + (const lldb::SBCompileUnit &), rhs); return m_opaque_ptr != rhs.m_opaque_ptr; } @@ -224,6 +238,7 @@ } bool SBCompileUnit::GetDescription(SBStream &description) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBCompileUnit, GetDescription, (lldb::SBStream &), description); Index: lldb/source/API/SBData.cpp =================================================================== --- lldb/source/API/SBData.cpp +++ lldb/source/API/SBData.cpp @@ -33,8 +33,9 @@ } const SBData &SBData::operator=(const SBData &rhs) { - LLDB_RECORD_METHOD(const lldb::SBData &, - SBData, operator=,(const lldb::SBData &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBData &, SBData, operator=, + (const lldb::SBData &), rhs); if (this != &rhs) m_opaque_sp = rhs.m_opaque_sp; @@ -58,16 +59,19 @@ const lldb::DataExtractorSP &SBData::operator*() const { return m_opaque_sp; } bool SBData::IsValid() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBData, IsValid); return this->operator bool(); } SBData::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBData, operator bool); return m_opaque_sp.get() != nullptr; } uint8_t SBData::GetAddressByteSize() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint8_t, SBData, GetAddressByteSize); uint8_t value = 0; @@ -77,6 +81,7 @@ } void SBData::SetAddressByteSize(uint8_t addr_byte_size) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBData, SetAddressByteSize, (uint8_t), addr_byte_size); @@ -85,6 +90,7 @@ } void SBData::Clear() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBData, Clear); if (m_opaque_sp.get()) @@ -92,6 +98,7 @@ } size_t SBData::GetByteSize() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(size_t, SBData, GetByteSize); size_t value = 0; @@ -101,6 +108,7 @@ } lldb::ByteOrder SBData::GetByteOrder() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::ByteOrder, SBData, GetByteOrder); lldb::ByteOrder value = eByteOrderInvalid; @@ -110,6 +118,7 @@ } void SBData::SetByteOrder(lldb::ByteOrder endian) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBData, SetByteOrder, (lldb::ByteOrder), endian); if (m_opaque_sp.get()) @@ -117,6 +126,7 @@ } float SBData::GetFloat(lldb::SBError &error, lldb::offset_t offset) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(float, SBData, GetFloat, (lldb::SBError &, lldb::offset_t), error, offset); @@ -133,6 +143,7 @@ } double SBData::GetDouble(lldb::SBError &error, lldb::offset_t offset) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(double, SBData, GetDouble, (lldb::SBError &, lldb::offset_t), error, offset); @@ -149,6 +160,7 @@ } long double SBData::GetLongDouble(lldb::SBError &error, lldb::offset_t offset) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(long double, SBData, GetLongDouble, (lldb::SBError &, lldb::offset_t), error, offset); @@ -165,6 +177,7 @@ } lldb::addr_t SBData::GetAddress(lldb::SBError &error, lldb::offset_t offset) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::addr_t, SBData, GetAddress, (lldb::SBError &, lldb::offset_t), error, offset); @@ -181,6 +194,7 @@ } uint8_t SBData::GetUnsignedInt8(lldb::SBError &error, lldb::offset_t offset) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(uint8_t, SBData, GetUnsignedInt8, (lldb::SBError &, lldb::offset_t), error, offset); @@ -197,6 +211,7 @@ } uint16_t SBData::GetUnsignedInt16(lldb::SBError &error, lldb::offset_t offset) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(uint16_t, SBData, GetUnsignedInt16, (lldb::SBError &, lldb::offset_t), error, offset); @@ -213,6 +228,7 @@ } uint32_t SBData::GetUnsignedInt32(lldb::SBError &error, lldb::offset_t offset) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(uint32_t, SBData, GetUnsignedInt32, (lldb::SBError &, lldb::offset_t), error, offset); @@ -229,6 +245,7 @@ } uint64_t SBData::GetUnsignedInt64(lldb::SBError &error, lldb::offset_t offset) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(uint64_t, SBData, GetUnsignedInt64, (lldb::SBError &, lldb::offset_t), error, offset); @@ -245,6 +262,7 @@ } int8_t SBData::GetSignedInt8(lldb::SBError &error, lldb::offset_t offset) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(int8_t, SBData, GetSignedInt8, (lldb::SBError &, lldb::offset_t), error, offset); @@ -261,6 +279,7 @@ } int16_t SBData::GetSignedInt16(lldb::SBError &error, lldb::offset_t offset) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(int16_t, SBData, GetSignedInt16, (lldb::SBError &, lldb::offset_t), error, offset); @@ -277,6 +296,7 @@ } int32_t SBData::GetSignedInt32(lldb::SBError &error, lldb::offset_t offset) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(int32_t, SBData, GetSignedInt32, (lldb::SBError &, lldb::offset_t), error, offset); @@ -293,6 +313,7 @@ } int64_t SBData::GetSignedInt64(lldb::SBError &error, lldb::offset_t offset) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(int64_t, SBData, GetSignedInt64, (lldb::SBError &, lldb::offset_t), error, offset); @@ -309,6 +330,7 @@ } const char *SBData::GetString(lldb::SBError &error, lldb::offset_t offset) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(const char *, SBData, GetString, (lldb::SBError &, lldb::offset_t), error, offset); @@ -326,6 +348,7 @@ bool SBData::GetDescription(lldb::SBStream &description, lldb::addr_t base_addr) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBData, GetDescription, (lldb::SBStream &, lldb::addr_t), description, base_addr); @@ -342,6 +365,7 @@ size_t SBData::ReadRawData(lldb::SBError &error, lldb::offset_t offset, void *buf, size_t size) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(size_t, SBData, ReadRawData, (lldb::SBError &, lldb::offset_t, void *, size_t), error, offset, buf, size); @@ -360,6 +384,7 @@ void SBData::SetData(lldb::SBError &error, const void *buf, size_t size, lldb::ByteOrder endian, uint8_t addr_size) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD( void, SBData, SetData, (lldb::SBError &, const void *, size_t, lldb::ByteOrder, uint8_t), error, @@ -377,6 +402,7 @@ void SBData::SetDataWithOwnership(lldb::SBError &error, const void *buf, size_t size, lldb::ByteOrder endian, uint8_t addr_size) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD( void, SBData, SetData, (lldb::SBError &, const void *, size_t, lldb::ByteOrder, uint8_t, bool), @@ -394,6 +420,7 @@ } bool SBData::Append(const SBData &rhs) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBData, Append, (const lldb::SBData &), rhs); bool value = false; @@ -534,9 +561,9 @@ } bool SBData::SetDataFromCString(const char *data) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBData, SetDataFromCString, (const char *), data); - if (!data) { return false; } @@ -556,10 +583,10 @@ } bool SBData::SetDataFromUInt64Array(uint64_t *array, size_t array_len) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBData, SetDataFromUInt64Array, (uint64_t *, size_t), array, array_len); - if (!array || array_len == 0) { return false; } @@ -579,10 +606,10 @@ } bool SBData::SetDataFromUInt32Array(uint32_t *array, size_t array_len) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBData, SetDataFromUInt32Array, (uint32_t *, size_t), array, array_len); - if (!array || array_len == 0) { return false; } @@ -601,10 +628,10 @@ } bool SBData::SetDataFromSInt64Array(int64_t *array, size_t array_len) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBData, SetDataFromSInt64Array, (int64_t *, size_t), array, array_len); - if (!array || array_len == 0) { return false; } @@ -623,10 +650,10 @@ } bool SBData::SetDataFromSInt32Array(int32_t *array, size_t array_len) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBData, SetDataFromSInt32Array, (int32_t *, size_t), array, array_len); - if (!array || array_len == 0) { return false; } @@ -645,10 +672,10 @@ } bool SBData::SetDataFromDoubleArray(double *array, size_t array_len) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBData, SetDataFromDoubleArray, (double *, size_t), array, array_len); - if (!array || array_len == 0) { return false; } Index: lldb/source/API/SBDebugger.cpp =================================================================== --- lldb/source/API/SBDebugger.cpp +++ lldb/source/API/SBDebugger.cpp @@ -105,6 +105,7 @@ unsigned long), void *a, lldb::InputReaderGranularity b, char const *c, char const *d, bool e) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD( lldb::SBError, SBInputReader, Initialize, (lldb::SBDebugger &, @@ -117,10 +118,12 @@ } void SBInputReader::SetIsDone(bool b) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBInputReader, SetIsDone, (bool), b); } bool SBInputReader::IsActive() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInputReader, IsActive); return false; @@ -140,8 +143,9 @@ SBDebugger::~SBDebugger() = default; SBDebugger &SBDebugger::operator=(const SBDebugger &rhs) { - LLDB_RECORD_METHOD(lldb::SBDebugger &, - SBDebugger, operator=,(const lldb::SBDebugger &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(lldb::SBDebugger &, SBDebugger, operator=, + (const lldb::SBDebugger &), rhs); if (this != &rhs) { m_opaque_sp = rhs.m_opaque_sp; @@ -179,6 +183,7 @@ } SBBroadcaster SBDebugger::GetBroadcaster() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBroadcaster, SBDebugger, GetBroadcaster); SBBroadcaster broadcaster(&m_opaque_sp->GetBroadcaster(), false); return broadcaster; @@ -208,6 +213,7 @@ } void SBDebugger::Clear() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, Clear); if (m_opaque_sp) @@ -286,16 +292,19 @@ } bool SBDebugger::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, IsValid); return this->operator bool(); } SBDebugger::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, operator bool); return m_opaque_sp.get() != nullptr; } void SBDebugger::SetAsync(bool b) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBDebugger, SetAsync, (bool), b); if (m_opaque_sp) @@ -303,12 +312,14 @@ } bool SBDebugger::GetAsync() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBDebugger, GetAsync); return (m_opaque_sp ? m_opaque_sp->GetAsyncExecution() : false); } void SBDebugger::SkipLLDBInitFiles(bool b) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBDebugger, SkipLLDBInitFiles, (bool), b); if (m_opaque_sp) @@ -316,6 +327,7 @@ } void SBDebugger::SkipAppInitFiles(bool b) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBDebugger, SkipAppInitFiles, (bool), b); if (m_opaque_sp) @@ -323,6 +335,7 @@ } void SBDebugger::SetInputFileHandle(FILE *fh, bool transfer_ownership) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBDebugger, SetInputFileHandle, (FILE *, bool), fh, transfer_ownership); if (m_opaque_sp) @@ -331,6 +344,7 @@ } SBError SBDebugger::SetInputString(const char *data) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(SBError, SBDebugger, SetInputString, (const char *), data); SBError sb_error; if (data == nullptr) { @@ -357,6 +371,7 @@ // of problems; don't want users trying to switch modes in the middle of a // debugging session. SBError SBDebugger::SetInputFile(SBFile file) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(SBError, SBDebugger, SetInputFile, (SBFile), file); SBError error; @@ -369,22 +384,26 @@ } SBError SBDebugger::SetInputFile(FileSP file_sp) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(SBError, SBDebugger, SetInputFile, (FileSP), file_sp); return SetInputFile(SBFile(file_sp)); } SBError SBDebugger::SetOutputFile(FileSP file_sp) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(SBError, SBDebugger, SetOutputFile, (FileSP), file_sp); return SetOutputFile(SBFile(file_sp)); } void SBDebugger::SetOutputFileHandle(FILE *fh, bool transfer_ownership) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBDebugger, SetOutputFileHandle, (FILE *, bool), fh, transfer_ownership); SetOutputFile((FileSP)std::make_shared(fh, transfer_ownership)); } SBError SBDebugger::SetOutputFile(SBFile file) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(SBError, SBDebugger, SetOutputFile, (SBFile file), file); SBError error; if (!m_opaque_sp) { @@ -400,17 +419,20 @@ } void SBDebugger::SetErrorFileHandle(FILE *fh, bool transfer_ownership) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBDebugger, SetErrorFileHandle, (FILE *, bool), fh, transfer_ownership); SetErrorFile((FileSP)std::make_shared(fh, transfer_ownership)); } SBError SBDebugger::SetErrorFile(FileSP file_sp) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(SBError, SBDebugger, SetErrorFile, (FileSP), file_sp); return SetErrorFile(SBFile(file_sp)); } SBError SBDebugger::SetErrorFile(SBFile file) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(SBError, SBDebugger, SetErrorFile, (SBFile file), file); SBError error; if (!m_opaque_sp) { @@ -426,6 +448,7 @@ } FILE *SBDebugger::GetInputFileHandle() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetInputFileHandle); if (m_opaque_sp) { File &file_sp = m_opaque_sp->GetInputFile(); @@ -435,6 +458,7 @@ } SBFile SBDebugger::GetInputFile() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(SBFile, SBDebugger, GetInputFile); if (m_opaque_sp) { return SBFile(m_opaque_sp->GetInputFileSP()); @@ -443,6 +467,7 @@ } FILE *SBDebugger::GetOutputFileHandle() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetOutputFileHandle); if (m_opaque_sp) { StreamFile &stream_file = m_opaque_sp->GetOutputStream(); @@ -452,6 +477,7 @@ } SBFile SBDebugger::GetOutputFile() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(SBFile, SBDebugger, GetOutputFile); if (m_opaque_sp) { SBFile file(m_opaque_sp->GetOutputStream().GetFileSP()); @@ -461,6 +487,7 @@ } FILE *SBDebugger::GetErrorFileHandle() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetErrorFileHandle); if (m_opaque_sp) { @@ -471,6 +498,7 @@ } SBFile SBDebugger::GetErrorFile() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(SBFile, SBDebugger, GetErrorFile); SBFile file; if (m_opaque_sp) { @@ -481,6 +509,7 @@ } void SBDebugger::SaveInputTerminalState() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, SaveInputTerminalState); if (m_opaque_sp) @@ -488,12 +517,14 @@ } void SBDebugger::RestoreInputTerminalState() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, RestoreInputTerminalState); if (m_opaque_sp) m_opaque_sp->RestoreInputTerminalState(); } SBCommandInterpreter SBDebugger::GetCommandInterpreter() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCommandInterpreter, SBDebugger, GetCommandInterpreter); @@ -505,6 +536,7 @@ } void SBDebugger::HandleCommand(const char *command) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBDebugger, HandleCommand, (const char *), command); if (m_opaque_sp) { @@ -538,6 +570,7 @@ } SBListener SBDebugger::GetListener() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBDebugger, GetListener); SBListener sb_listener; @@ -550,6 +583,7 @@ void SBDebugger::HandleProcessEvent(const SBProcess &process, const SBEvent &event, SBFile out, SBFile err) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD( void, SBDebugger, HandleProcessEvent, (const lldb::SBProcess &, const lldb::SBEvent &, SBFile, SBFile), process, @@ -561,6 +595,7 @@ void SBDebugger::HandleProcessEvent(const SBProcess &process, const SBEvent &event, FILE *out, FILE *err) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD( void, SBDebugger, HandleProcessEvent, (const lldb::SBProcess &, const lldb::SBEvent &, FILE *, FILE *), process, @@ -575,6 +610,7 @@ const SBEvent &event, FileSP out_sp, FileSP err_sp) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD( void, SBDebugger, HandleProcessEvent, (const lldb::SBProcess &, const lldb::SBEvent &, FileSP, FileSP), process, @@ -622,6 +658,7 @@ } SBSourceManager SBDebugger::GetSourceManager() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSourceManager, SBDebugger, GetSourceManager); @@ -667,6 +704,7 @@ ScriptLanguage SBDebugger::GetScriptingLanguage(const char *script_language_name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::ScriptLanguage, SBDebugger, GetScriptingLanguage, (const char *), script_language_name); @@ -678,6 +716,7 @@ SBStructuredData SBDebugger::GetScriptInterpreterInfo(lldb::ScriptLanguage language) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(SBStructuredData, SBDebugger, GetScriptInterpreterInfo, (lldb::ScriptLanguage), language); SBStructuredData data; @@ -780,6 +819,7 @@ const char *platform_name, bool add_dependent_modules, lldb::SBError &sb_error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD( lldb::SBTarget, SBDebugger, CreateTarget, (const char *, const char *, const char *, bool, lldb::SBError &), @@ -818,6 +858,7 @@ SBTarget SBDebugger::CreateTargetWithFileAndTargetTriple(const char *filename, const char *target_triple) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, CreateTargetWithFileAndTargetTriple, (const char *, const char *), filename, target_triple); @@ -845,6 +886,7 @@ SBTarget SBDebugger::CreateTargetWithFileAndArch(const char *filename, const char *arch_cstr) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, CreateTargetWithFileAndArch, (const char *, const char *), filename, arch_cstr); @@ -887,6 +929,7 @@ } SBTarget SBDebugger::CreateTarget(const char *filename) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, CreateTarget, (const char *), filename); @@ -912,6 +955,7 @@ } SBTarget SBDebugger::GetDummyTarget() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBDebugger, GetDummyTarget); SBTarget sb_target; @@ -926,6 +970,7 @@ } bool SBDebugger::DeleteTarget(lldb::SBTarget &target) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBDebugger, DeleteTarget, (lldb::SBTarget &), target); @@ -949,6 +994,7 @@ } SBTarget SBDebugger::GetTargetAtIndex(uint32_t idx) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, GetTargetAtIndex, (uint32_t), idx); @@ -961,6 +1007,7 @@ } uint32_t SBDebugger::GetIndexOfTarget(lldb::SBTarget target) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(uint32_t, SBDebugger, GetIndexOfTarget, (lldb::SBTarget), target); @@ -975,6 +1022,7 @@ } SBTarget SBDebugger::FindTargetWithProcessID(lldb::pid_t pid) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithProcessID, (lldb::pid_t), pid); @@ -988,6 +1036,7 @@ SBTarget SBDebugger::FindTargetWithFileAndArch(const char *filename, const char *arch_name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithFileAndArch, (const char *, const char *), filename, arch_name); @@ -1015,6 +1064,7 @@ } uint32_t SBDebugger::GetNumTargets() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumTargets); if (m_opaque_sp) { @@ -1025,6 +1075,7 @@ } SBTarget SBDebugger::GetSelectedTarget() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBDebugger, GetSelectedTarget); Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); @@ -1049,6 +1100,7 @@ } void SBDebugger::SetSelectedTarget(SBTarget &sb_target) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBDebugger, SetSelectedTarget, (lldb::SBTarget &), sb_target); @@ -1068,6 +1120,7 @@ } SBPlatform SBDebugger::GetSelectedPlatform() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBPlatform, SBDebugger, GetSelectedPlatform); Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); @@ -1085,6 +1138,7 @@ } void SBDebugger::SetSelectedPlatform(SBPlatform &sb_platform) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBDebugger, SetSelectedPlatform, (lldb::SBPlatform &), sb_platform); @@ -1102,6 +1156,7 @@ } uint32_t SBDebugger::GetNumPlatforms() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumPlatforms); if (m_opaque_sp) { @@ -1112,6 +1167,7 @@ } SBPlatform SBDebugger::GetPlatformAtIndex(uint32_t idx) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBPlatform, SBDebugger, GetPlatformAtIndex, (uint32_t), idx); @@ -1124,6 +1180,7 @@ } uint32_t SBDebugger::GetNumAvailablePlatforms() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumAvailablePlatforms); uint32_t idx = 0; @@ -1138,6 +1195,7 @@ } SBStructuredData SBDebugger::GetAvailablePlatformInfoAtIndex(uint32_t idx) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBStructuredData, SBDebugger, GetAvailablePlatformInfoAtIndex, (uint32_t), idx); @@ -1169,6 +1227,7 @@ } void SBDebugger::DispatchInput(void *baton, const void *data, size_t data_len) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBDebugger, DispatchInput, (void *, const void *, size_t), baton, data, data_len); @@ -1176,6 +1235,7 @@ } void SBDebugger::DispatchInput(const void *data, size_t data_len) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBDebugger, DispatchInput, (const void *, size_t), data, data_len); @@ -1194,6 +1254,7 @@ } void SBDebugger::DispatchInputInterrupt() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, DispatchInputInterrupt); if (m_opaque_sp) @@ -1201,6 +1262,7 @@ } void SBDebugger::DispatchInputEndOfFile() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, DispatchInputEndOfFile); if (m_opaque_sp) @@ -1208,12 +1270,14 @@ } void SBDebugger::PushInputReader(SBInputReader &reader) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBDebugger, PushInputReader, (lldb::SBInputReader &), reader); } void SBDebugger::RunCommandInterpreter(bool auto_handle_events, bool spawn_thread) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBDebugger, RunCommandInterpreter, (bool, bool), auto_handle_events, spawn_thread); @@ -1232,6 +1296,7 @@ bool &stopped_for_crash) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBDebugger, RunCommandInterpreter, (bool, bool, lldb::SBCommandInterpreterRunOptions &, int &, bool &, bool &), @@ -1254,6 +1319,7 @@ SBCommandInterpreterRunResult SBDebugger::RunCommandInterpreter( const SBCommandInterpreterRunOptions &options) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBCommandInterpreterRunResult, SBDebugger, RunCommandInterpreter, (const lldb::SBCommandInterpreterRunOptions &), options); @@ -1270,6 +1336,7 @@ SBError SBDebugger::RunREPL(lldb::LanguageType language, const char *repl_options) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBDebugger, RunREPL, (lldb::LanguageType, const char *), language, repl_options); @@ -1308,6 +1375,7 @@ } const char *SBDebugger::GetInstanceName() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBDebugger, GetInstanceName); return (m_opaque_sp ? m_opaque_sp->GetInstanceName().AsCString() : nullptr); @@ -1367,12 +1435,14 @@ } uint32_t SBDebugger::GetTerminalWidth() const { + LLDB_SCOPED_TIMER(); 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_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBDebugger, SetTerminalWidth, (uint32_t), term_width); @@ -1381,6 +1451,7 @@ } const char *SBDebugger::GetPrompt() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBDebugger, GetPrompt); Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); @@ -1394,6 +1465,7 @@ } void SBDebugger::SetPrompt(const char *prompt) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBDebugger, SetPrompt, (const char *), prompt); if (m_opaque_sp) @@ -1401,6 +1473,7 @@ } const char *SBDebugger::GetReproducerPath() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBDebugger, GetReproducerPath); return (m_opaque_sp @@ -1409,6 +1482,7 @@ } ScriptLanguage SBDebugger::GetScriptLanguage() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ScriptLanguage, SBDebugger, GetScriptLanguage); @@ -1416,6 +1490,7 @@ } void SBDebugger::SetScriptLanguage(ScriptLanguage script_lang) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBDebugger, SetScriptLanguage, (lldb::ScriptLanguage), script_lang); @@ -1425,6 +1500,7 @@ } LanguageType SBDebugger::GetREPLLanguage() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::LanguageType, SBDebugger, GetREPLLanguage); @@ -1432,6 +1508,7 @@ } void SBDebugger::SetREPLLanguage(LanguageType repl_lang) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBDebugger, SetREPLLanguage, (lldb::LanguageType), repl_lang); @@ -1441,42 +1518,49 @@ } bool SBDebugger::SetUseExternalEditor(bool value) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBDebugger, SetUseExternalEditor, (bool), value); return (m_opaque_sp ? m_opaque_sp->SetUseExternalEditor(value) : false); } bool SBDebugger::GetUseExternalEditor() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBDebugger, GetUseExternalEditor); return (m_opaque_sp ? m_opaque_sp->GetUseExternalEditor() : false); } bool SBDebugger::SetUseColor(bool value) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBDebugger, SetUseColor, (bool), value); return (m_opaque_sp ? m_opaque_sp->SetUseColor(value) : false); } bool SBDebugger::GetUseColor() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetUseColor); return (m_opaque_sp ? m_opaque_sp->GetUseColor() : false); } bool SBDebugger::SetUseSourceCache(bool value) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBDebugger, SetUseSourceCache, (bool), value); return (m_opaque_sp ? m_opaque_sp->SetUseSourceCache(value) : false); } bool SBDebugger::GetUseSourceCache() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetUseSourceCache); return (m_opaque_sp ? m_opaque_sp->GetUseSourceCache() : false); } bool SBDebugger::GetDescription(SBStream &description) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBDebugger, GetDescription, (lldb::SBStream &), description); @@ -1493,12 +1577,14 @@ } user_id_t SBDebugger::GetID() { + LLDB_SCOPED_TIMER(); 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_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBDebugger, SetCurrentPlatform, (const char *), platform_name_cstr); @@ -1530,6 +1616,7 @@ } bool SBDebugger::SetCurrentPlatformSDKRoot(const char *sysroot) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBDebugger, SetCurrentPlatformSDKRoot, (const char *), sysroot); @@ -1550,12 +1637,14 @@ } bool SBDebugger::GetCloseInputOnEOF() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetCloseInputOnEOF); return (m_opaque_sp ? m_opaque_sp->GetCloseInputOnEOF() : false); } void SBDebugger::SetCloseInputOnEOF(bool b) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBDebugger, SetCloseInputOnEOF, (bool), b); if (m_opaque_sp) @@ -1563,6 +1652,7 @@ } SBTypeCategory SBDebugger::GetCategory(const char *category_name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory, (const char *), category_name); @@ -1580,6 +1670,7 @@ } SBTypeCategory SBDebugger::GetCategory(lldb::LanguageType lang_type) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory, (lldb::LanguageType), lang_type); @@ -1592,6 +1683,7 @@ } SBTypeCategory SBDebugger::CreateCategory(const char *category_name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, CreateCategory, (const char *), category_name); @@ -1609,6 +1701,7 @@ } bool SBDebugger::DeleteCategory(const char *category_name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBDebugger, DeleteCategory, (const char *), category_name); @@ -1619,12 +1712,14 @@ } uint32_t SBDebugger::GetNumCategories() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumCategories); return DataVisualization::Categories::GetCount(); } SBTypeCategory SBDebugger::GetCategoryAtIndex(uint32_t index) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategoryAtIndex, (uint32_t), index); @@ -1633,6 +1728,7 @@ } SBTypeCategory SBDebugger::GetDefaultCategory() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeCategory, SBDebugger, GetDefaultCategory); @@ -1640,6 +1736,7 @@ } SBTypeFormat SBDebugger::GetFormatForType(SBTypeNameSpecifier type_name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBDebugger, GetFormatForType, (lldb::SBTypeNameSpecifier), type_name); @@ -1650,6 +1747,7 @@ } SBTypeSummary SBDebugger::GetSummaryForType(SBTypeNameSpecifier type_name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBDebugger, GetSummaryForType, (lldb::SBTypeNameSpecifier), type_name); @@ -1659,6 +1757,7 @@ } SBTypeFilter SBDebugger::GetFilterForType(SBTypeNameSpecifier type_name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBDebugger, GetFilterForType, (lldb::SBTypeNameSpecifier), type_name); @@ -1668,6 +1767,7 @@ } SBTypeSynthetic SBDebugger::GetSyntheticForType(SBTypeNameSpecifier type_name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBDebugger, GetSyntheticForType, (lldb::SBTypeNameSpecifier), type_name); @@ -1687,6 +1787,7 @@ } bool SBDebugger::EnableLog(const char *channel, const char **categories) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBDebugger, EnableLog, (const char *, const char **), channel, categories); @@ -1703,6 +1804,7 @@ void SBDebugger::SetLoggingCallback(lldb::LogOutputCallback log_callback, void *baton) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBDebugger, SetLoggingCallback, (lldb::LogOutputCallback, void *), log_callback, baton); Index: lldb/source/API/SBDeclaration.cpp =================================================================== --- lldb/source/API/SBDeclaration.cpp +++ lldb/source/API/SBDeclaration.cpp @@ -35,9 +35,9 @@ } const SBDeclaration &SBDeclaration::operator=(const SBDeclaration &rhs) { - LLDB_RECORD_METHOD(const lldb::SBDeclaration &, - SBDeclaration, operator=,(const lldb::SBDeclaration &), - rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBDeclaration &, SBDeclaration, operator=, + (const lldb::SBDeclaration &), rhs); if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); @@ -52,20 +52,22 @@ SBDeclaration::~SBDeclaration() = default; bool SBDeclaration::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDeclaration, IsValid); return this->operator bool(); } SBDeclaration::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDeclaration, operator bool); return m_opaque_up.get() && m_opaque_up->IsValid(); } SBFileSpec SBDeclaration::GetFileSpec() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBDeclaration, GetFileSpec); - SBFileSpec sb_file_spec; if (m_opaque_up.get() && m_opaque_up->GetFile()) sb_file_spec.SetFileSpec(m_opaque_up->GetFile()); @@ -74,9 +76,9 @@ } uint32_t SBDeclaration::GetLine() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBDeclaration, GetLine); - uint32_t line = 0; if (m_opaque_up) line = m_opaque_up->GetLine(); @@ -86,6 +88,7 @@ } uint32_t SBDeclaration::GetColumn() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBDeclaration, GetColumn); if (m_opaque_up) @@ -94,6 +97,7 @@ } void SBDeclaration::SetFileSpec(lldb::SBFileSpec filespec) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBDeclaration, SetFileSpec, (lldb::SBFileSpec), filespec); @@ -103,20 +107,23 @@ ref().SetFile(FileSpec()); } void SBDeclaration::SetLine(uint32_t line) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBDeclaration, SetLine, (uint32_t), line); ref().SetLine(line); } void SBDeclaration::SetColumn(uint32_t column) { + LLDB_SCOPED_TIMER(); 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_SCOPED_TIMER(); + 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(); @@ -128,8 +135,9 @@ } bool SBDeclaration::operator!=(const SBDeclaration &rhs) const { - LLDB_RECORD_METHOD_CONST( - bool, SBDeclaration, operator!=,(const lldb::SBDeclaration &), rhs); + LLDB_SCOPED_TIMER(); + 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(); @@ -155,6 +163,7 @@ } bool SBDeclaration::GetDescription(SBStream &description) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBDeclaration, GetDescription, (lldb::SBStream &), description); Index: lldb/source/API/SBEnvironment.cpp =================================================================== --- lldb/source/API/SBEnvironment.cpp +++ lldb/source/API/SBEnvironment.cpp @@ -31,9 +31,9 @@ SBEnvironment::~SBEnvironment() = default; const SBEnvironment &SBEnvironment::operator=(const SBEnvironment &rhs) { - LLDB_RECORD_METHOD(const lldb::SBEnvironment &, - SBEnvironment, operator=,(const lldb::SBEnvironment &), - rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBEnvironment &, SBEnvironment, operator=, + (const lldb::SBEnvironment &), rhs); if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); @@ -41,12 +41,14 @@ } size_t SBEnvironment::GetNumValues() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(size_t, SBEnvironment, GetNumValues); return m_opaque_up->size(); } const char *SBEnvironment::Get(const char *name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(const char *, SBEnvironment, Get, (const char *), name); auto entry = m_opaque_up->find(name); @@ -57,6 +59,7 @@ } const char *SBEnvironment::GetNameAtIndex(size_t index) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(const char *, SBEnvironment, GetNameAtIndex, (size_t), index); @@ -67,6 +70,7 @@ } const char *SBEnvironment::GetValueAtIndex(size_t index) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(const char *, SBEnvironment, GetValueAtIndex, (size_t), index); @@ -77,6 +81,7 @@ } bool SBEnvironment::Set(const char *name, const char *value, bool overwrite) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBEnvironment, Set, (const char *, const char *, bool), name, value, overwrite); @@ -89,12 +94,14 @@ } bool SBEnvironment::Unset(const char *name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBEnvironment, Unset, (const char *), name); return m_opaque_up->erase(name); } SBStringList SBEnvironment::GetEntries() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStringList, SBEnvironment, GetEntries); SBStringList entries; @@ -105,6 +112,7 @@ } void SBEnvironment::PutEntry(const char *name_and_value) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBEnvironment, PutEntry, (const char *), name_and_value); @@ -113,6 +121,7 @@ } void SBEnvironment::SetEntries(const SBStringList &entries, bool append) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBEnvironment, SetEntries, (const lldb::SBStringList &, bool), entries, append); @@ -124,6 +133,7 @@ } void SBEnvironment::Clear() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBEnvironment, Clear); m_opaque_up->clear(); Index: lldb/source/API/SBError.cpp =================================================================== --- lldb/source/API/SBError.cpp +++ lldb/source/API/SBError.cpp @@ -28,8 +28,9 @@ SBError::~SBError() = default; const SBError &SBError::operator=(const SBError &rhs) { - LLDB_RECORD_METHOD(const lldb::SBError &, - SBError, operator=,(const lldb::SBError &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBError &, SBError, operator=, + (const lldb::SBError &), rhs); if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); @@ -37,6 +38,7 @@ } const char *SBError::GetCString() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBError, GetCString); if (m_opaque_up) @@ -45,6 +47,7 @@ } void SBError::Clear() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBError, Clear); if (m_opaque_up) @@ -52,6 +55,7 @@ } bool SBError::Fail() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, Fail); bool ret_value = false; @@ -63,6 +67,7 @@ } bool SBError::Success() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, Success); bool ret_value = true; @@ -73,9 +78,9 @@ } uint32_t SBError::GetError() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBError, GetError); - uint32_t err = 0; if (m_opaque_up) err = m_opaque_up->GetError(); @@ -85,6 +90,7 @@ } ErrorType SBError::GetType() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ErrorType, SBError, GetType); ErrorType err_type = eErrorTypeInvalid; @@ -95,6 +101,7 @@ } void SBError::SetError(uint32_t err, ErrorType type) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBError, SetError, (uint32_t, lldb::ErrorType), err, type); @@ -108,6 +115,7 @@ } void SBError::SetErrorToErrno() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBError, SetErrorToErrno); CreateIfNeeded(); @@ -115,6 +123,7 @@ } void SBError::SetErrorToGenericError() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBError, SetErrorToGenericError); CreateIfNeeded(); @@ -122,6 +131,7 @@ } void SBError::SetErrorString(const char *err_str) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBError, SetErrorString, (const char *), err_str); CreateIfNeeded(); @@ -138,10 +148,12 @@ } bool SBError::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, IsValid); return this->operator bool(); } SBError::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, operator bool); return m_opaque_up != nullptr; @@ -167,6 +179,7 @@ } bool SBError::GetDescription(SBStream &description) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBError, GetDescription, (lldb::SBStream &), description); Index: lldb/source/API/SBEvent.cpp =================================================================== --- lldb/source/API/SBEvent.cpp +++ lldb/source/API/SBEvent.cpp @@ -46,8 +46,9 @@ } const SBEvent &SBEvent::operator=(const SBEvent &rhs) { - LLDB_RECORD_METHOD(const lldb::SBEvent &, - SBEvent, operator=,(const lldb::SBEvent &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBEvent &, SBEvent, operator=, + (const lldb::SBEvent &), rhs); if (this != &rhs) { m_event_sp = rhs.m_event_sp; @@ -59,6 +60,7 @@ SBEvent::~SBEvent() = default; const char *SBEvent::GetDataFlavor() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBEvent, GetDataFlavor); Event *lldb_event = get(); @@ -71,9 +73,9 @@ } uint32_t SBEvent::GetType() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBEvent, GetType); - const Event *lldb_event = get(); uint32_t event_type = 0; if (lldb_event) @@ -84,6 +86,7 @@ } SBBroadcaster SBEvent::GetBroadcaster() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBEvent, GetBroadcaster); @@ -95,6 +98,7 @@ } const char *SBEvent::GetBroadcasterClass() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBEvent, GetBroadcasterClass); const Event *lldb_event = get(); @@ -105,6 +109,7 @@ } bool SBEvent::BroadcasterMatchesPtr(const SBBroadcaster *broadcaster) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBEvent, BroadcasterMatchesPtr, (const lldb::SBBroadcaster *), broadcaster); @@ -114,6 +119,7 @@ } bool SBEvent::BroadcasterMatchesRef(const SBBroadcaster &broadcaster) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBEvent, BroadcasterMatchesRef, (const lldb::SBBroadcaster &), broadcaster); @@ -127,6 +133,7 @@ } void SBEvent::Clear() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBEvent, Clear); Event *lldb_event = get(); @@ -158,10 +165,12 @@ } bool SBEvent::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBEvent, IsValid); return this->operator bool(); } SBEvent::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBEvent, operator bool); // Do NOT use m_opaque_ptr directly!!! Must use the SBEvent::get() accessor. @@ -178,6 +187,7 @@ } bool SBEvent::GetDescription(SBStream &description) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBEvent, GetDescription, (lldb::SBStream &), description); @@ -192,6 +202,7 @@ } bool SBEvent::GetDescription(SBStream &description) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(bool, SBEvent, GetDescription, (lldb::SBStream &), description); Index: lldb/source/API/SBExecutionContext.cpp =================================================================== --- lldb/source/API/SBExecutionContext.cpp +++ lldb/source/API/SBExecutionContext.cpp @@ -69,9 +69,10 @@ const SBExecutionContext &SBExecutionContext:: operator=(const lldb::SBExecutionContext &rhs) { - LLDB_RECORD_METHOD( - const lldb::SBExecutionContext &, - SBExecutionContext, operator=,(const lldb::SBExecutionContext &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBExecutionContext &, + SBExecutionContext, operator=, + (const lldb::SBExecutionContext &), rhs); m_exe_ctx_sp = rhs.m_exe_ctx_sp; return *this; @@ -82,6 +83,7 @@ } SBTarget SBExecutionContext::GetTarget() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBTarget, SBExecutionContext, GetTarget); @@ -95,6 +97,7 @@ } SBProcess SBExecutionContext::GetProcess() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBProcess, SBExecutionContext, GetProcess); @@ -108,6 +111,7 @@ } SBThread SBExecutionContext::GetThread() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBExecutionContext, GetThread); @@ -121,6 +125,7 @@ } SBFrame SBExecutionContext::GetFrame() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFrame, SBExecutionContext, GetFrame); SBFrame sb_frame; Index: lldb/source/API/SBExpressionOptions.cpp =================================================================== --- lldb/source/API/SBExpressionOptions.cpp +++ lldb/source/API/SBExpressionOptions.cpp @@ -29,9 +29,10 @@ const SBExpressionOptions &SBExpressionOptions:: operator=(const SBExpressionOptions &rhs) { - LLDB_RECORD_METHOD( - const lldb::SBExpressionOptions &, - SBExpressionOptions, operator=,(const lldb::SBExpressionOptions &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBExpressionOptions &, + SBExpressionOptions, operator=, + (const lldb::SBExpressionOptions &), rhs); if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); @@ -41,6 +42,7 @@ SBExpressionOptions::~SBExpressionOptions() = default; bool SBExpressionOptions::GetCoerceResultToId() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, GetCoerceResultToId); @@ -48,6 +50,7 @@ } void SBExpressionOptions::SetCoerceResultToId(bool coerce) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBExpressionOptions, SetCoerceResultToId, (bool), coerce); @@ -55,12 +58,14 @@ } bool SBExpressionOptions::GetUnwindOnError() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, GetUnwindOnError); return m_opaque_up->DoesUnwindOnError(); } void SBExpressionOptions::SetUnwindOnError(bool unwind) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBExpressionOptions, SetUnwindOnError, (bool), unwind); @@ -68,6 +73,7 @@ } bool SBExpressionOptions::GetIgnoreBreakpoints() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, GetIgnoreBreakpoints); @@ -75,6 +81,7 @@ } void SBExpressionOptions::SetIgnoreBreakpoints(bool ignore) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBExpressionOptions, SetIgnoreBreakpoints, (bool), ignore); @@ -82,6 +89,7 @@ } lldb::DynamicValueType SBExpressionOptions::GetFetchDynamicValue() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::DynamicValueType, SBExpressionOptions, GetFetchDynamicValue); @@ -89,6 +97,7 @@ } void SBExpressionOptions::SetFetchDynamicValue(lldb::DynamicValueType dynamic) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBExpressionOptions, SetFetchDynamicValue, (lldb::DynamicValueType), dynamic); @@ -96,6 +105,7 @@ } uint32_t SBExpressionOptions::GetTimeoutInMicroSeconds() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBExpressionOptions, GetTimeoutInMicroSeconds); @@ -103,6 +113,7 @@ } void SBExpressionOptions::SetTimeoutInMicroSeconds(uint32_t timeout) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTimeoutInMicroSeconds, (uint32_t), timeout); @@ -111,6 +122,7 @@ } uint32_t SBExpressionOptions::GetOneThreadTimeoutInMicroSeconds() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBExpressionOptions, GetOneThreadTimeoutInMicroSeconds); @@ -120,6 +132,7 @@ } void SBExpressionOptions::SetOneThreadTimeoutInMicroSeconds(uint32_t timeout) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBExpressionOptions, SetOneThreadTimeoutInMicroSeconds, (uint32_t), timeout); @@ -129,12 +142,14 @@ } bool SBExpressionOptions::GetTryAllThreads() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, GetTryAllThreads); return m_opaque_up->GetTryAllThreads(); } void SBExpressionOptions::SetTryAllThreads(bool run_others) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTryAllThreads, (bool), run_others); @@ -142,12 +157,14 @@ } bool SBExpressionOptions::GetStopOthers() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, GetStopOthers); return m_opaque_up->GetStopOthers(); } void SBExpressionOptions::SetStopOthers(bool run_others) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBExpressionOptions, SetStopOthers, (bool), run_others); @@ -155,6 +172,7 @@ } bool SBExpressionOptions::GetTrapExceptions() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, GetTrapExceptions); @@ -162,6 +180,7 @@ } void SBExpressionOptions::SetTrapExceptions(bool trap_exceptions) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTrapExceptions, (bool), trap_exceptions); @@ -169,6 +188,7 @@ } void SBExpressionOptions::SetLanguage(lldb::LanguageType language) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBExpressionOptions, SetLanguage, (lldb::LanguageType), language); @@ -177,6 +197,7 @@ void SBExpressionOptions::SetCancelCallback( lldb::ExpressionCancelCallback callback, void *baton) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBExpressionOptions, SetCancelCallback, (lldb::ExpressionCancelCallback, void *), callback, baton); @@ -184,12 +205,14 @@ } bool SBExpressionOptions::GetGenerateDebugInfo() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetGenerateDebugInfo); return m_opaque_up->GetGenerateDebugInfo(); } void SBExpressionOptions::SetGenerateDebugInfo(bool b) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBExpressionOptions, SetGenerateDebugInfo, (bool), b); @@ -197,6 +220,7 @@ } bool SBExpressionOptions::GetSuppressPersistentResult() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetSuppressPersistentResult); @@ -204,6 +228,7 @@ } void SBExpressionOptions::SetSuppressPersistentResult(bool b) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBExpressionOptions, SetSuppressPersistentResult, (bool), b); @@ -211,6 +236,7 @@ } const char *SBExpressionOptions::GetPrefix() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBExpressionOptions, GetPrefix); @@ -218,6 +244,7 @@ } void SBExpressionOptions::SetPrefix(const char *prefix) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBExpressionOptions, SetPrefix, (const char *), prefix); @@ -225,18 +252,21 @@ } bool SBExpressionOptions::GetAutoApplyFixIts() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetAutoApplyFixIts); return m_opaque_up->GetAutoApplyFixIts(); } void SBExpressionOptions::SetAutoApplyFixIts(bool b) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBExpressionOptions, SetAutoApplyFixIts, (bool), b); return m_opaque_up->SetAutoApplyFixIts(b); } uint64_t SBExpressionOptions::GetRetriesWithFixIts() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBExpressionOptions, GetRetriesWithFixIts); @@ -244,6 +274,7 @@ } void SBExpressionOptions::SetRetriesWithFixIts(uint64_t retries) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBExpressionOptions, SetRetriesWithFixIts, (uint64_t), retries); @@ -251,12 +282,14 @@ } bool SBExpressionOptions::GetTopLevel() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetTopLevel); return m_opaque_up->GetExecutionPolicy() == eExecutionPolicyTopLevel; } void SBExpressionOptions::SetTopLevel(bool b) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTopLevel, (bool), b); m_opaque_up->SetExecutionPolicy(b ? eExecutionPolicyTopLevel @@ -264,12 +297,14 @@ } bool SBExpressionOptions::GetAllowJIT() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetAllowJIT); return m_opaque_up->GetExecutionPolicy() != eExecutionPolicyNever; } void SBExpressionOptions::SetAllowJIT(bool allow) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBExpressionOptions, SetAllowJIT, (bool), allow); m_opaque_up->SetExecutionPolicy(allow ? m_opaque_up->default_execution_policy Index: lldb/source/API/SBFile.cpp =================================================================== --- lldb/source/API/SBFile.cpp +++ lldb/source/API/SBFile.cpp @@ -27,8 +27,9 @@ } SBFile &SBFile ::operator=(const SBFile &rhs) { - LLDB_RECORD_METHOD(lldb::SBFile &, - SBFile, operator=,(const lldb::SBFile &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(lldb::SBFile &, SBFile, operator=, (const lldb::SBFile &), + rhs); if (this != &rhs) m_opaque_sp = rhs.m_opaque_sp; @@ -57,6 +58,7 @@ } SBError SBFile::Read(uint8_t *buf, size_t num_bytes, size_t *bytes_read) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBFile, Read, (uint8_t *, size_t, size_t *), buf, num_bytes, bytes_read); @@ -74,6 +76,7 @@ SBError SBFile::Write(const uint8_t *buf, size_t num_bytes, size_t *bytes_written) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBFile, Write, (const uint8_t *, size_t, size_t *), buf, num_bytes, bytes_written); @@ -91,6 +94,7 @@ } SBError SBFile::Flush() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBFile, Flush); SBError error; @@ -104,11 +108,13 @@ } bool SBFile::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFile, IsValid); return m_opaque_sp && m_opaque_sp->IsValid(); } SBError SBFile::Close() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBFile, Close); SBError error; if (m_opaque_sp) { @@ -119,16 +125,19 @@ } SBFile::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFile, operator bool); return IsValid(); } bool SBFile::operator!() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFile, operator!); return !IsValid(); } FileSP SBFile::GetFile() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(FileSP, SBFile, GetFile); return m_opaque_sp; } Index: lldb/source/API/SBFileSpec.cpp =================================================================== --- lldb/source/API/SBFileSpec.cpp +++ lldb/source/API/SBFileSpec.cpp @@ -54,8 +54,9 @@ SBFileSpec::~SBFileSpec() = default; const SBFileSpec &SBFileSpec::operator=(const SBFileSpec &rhs) { - LLDB_RECORD_METHOD(const lldb::SBFileSpec &, - SBFileSpec, operator=,(const lldb::SBFileSpec &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBFileSpec &, SBFileSpec, operator=, + (const lldb::SBFileSpec &), rhs); if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); @@ -63,36 +64,42 @@ } bool SBFileSpec::operator==(const SBFileSpec &rhs) const { - LLDB_RECORD_METHOD_CONST(bool, SBFileSpec, operator==,(const SBFileSpec &rhs), - rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD_CONST(bool, SBFileSpec, operator==, + (const SBFileSpec &rhs), rhs); return ref() == rhs.ref(); } bool SBFileSpec::operator!=(const SBFileSpec &rhs) const { - LLDB_RECORD_METHOD_CONST(bool, SBFileSpec, operator!=,(const SBFileSpec &rhs), - rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD_CONST(bool, SBFileSpec, operator!=, + (const SBFileSpec &rhs), rhs); return !(*this == rhs); } bool SBFileSpec::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFileSpec, IsValid); return this->operator bool(); } SBFileSpec::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFileSpec, operator bool); return m_opaque_up->operator bool(); } bool SBFileSpec::Exists() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFileSpec, Exists); return FileSystem::Instance().Exists(*m_opaque_up); } bool SBFileSpec::ResolveExecutableLocation() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBFileSpec, ResolveExecutableLocation); return FileSystem::Instance().ResolveExecutableLocation(*m_opaque_up); @@ -111,12 +118,14 @@ } const char *SBFileSpec::GetFilename() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFileSpec, GetFilename); return m_opaque_up->GetFilename().AsCString(); } const char *SBFileSpec::GetDirectory() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFileSpec, GetDirectory); FileSpec directory{*m_opaque_up}; @@ -125,6 +134,7 @@ } void SBFileSpec::SetFilename(const char *filename) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBFileSpec, SetFilename, (const char *), filename); if (filename && filename[0]) @@ -134,6 +144,7 @@ } void SBFileSpec::SetDirectory(const char *directory) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBFileSpec, SetDirectory, (const char *), directory); if (directory && directory[0]) @@ -143,6 +154,7 @@ } uint32_t SBFileSpec::GetPath(char *dst_path, size_t dst_len) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(uint32_t, SBFileSpec, GetPath, (char *, size_t), dst_path, "", dst_len); @@ -172,6 +184,7 @@ } bool SBFileSpec::GetDescription(SBStream &description) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(bool, SBFileSpec, GetDescription, (lldb::SBStream &), description); @@ -183,6 +196,7 @@ } void SBFileSpec::AppendPathComponent(const char *fn) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBFileSpec, AppendPathComponent, (const char *), fn); m_opaque_up->AppendPathComponent(fn); Index: lldb/source/API/SBFileSpecList.cpp =================================================================== --- lldb/source/API/SBFileSpecList.cpp +++ lldb/source/API/SBFileSpecList.cpp @@ -34,9 +34,9 @@ SBFileSpecList::~SBFileSpecList() = default; const SBFileSpecList &SBFileSpecList::operator=(const SBFileSpecList &rhs) { - LLDB_RECORD_METHOD(const lldb::SBFileSpecList &, - SBFileSpecList, operator=,(const lldb::SBFileSpecList &), - rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBFileSpecList &, SBFileSpecList, operator=, + (const lldb::SBFileSpecList &), rhs); if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); @@ -44,12 +44,14 @@ } uint32_t SBFileSpecList::GetSize() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBFileSpecList, GetSize); return m_opaque_up->GetSize(); } void SBFileSpecList::Append(const SBFileSpec &sb_file) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBFileSpecList, Append, (const lldb::SBFileSpec &), sb_file); @@ -57,6 +59,7 @@ } bool SBFileSpecList::AppendIfUnique(const SBFileSpec &sb_file) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBFileSpecList, AppendIfUnique, (const lldb::SBFileSpec &), sb_file); @@ -64,6 +67,7 @@ } void SBFileSpecList::Clear() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBFileSpecList, Clear); m_opaque_up->Clear(); @@ -71,6 +75,7 @@ uint32_t SBFileSpecList::FindFileIndex(uint32_t idx, const SBFileSpec &sb_file, bool full) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(uint32_t, SBFileSpecList, FindFileIndex, (uint32_t, const lldb::SBFileSpec &, bool), idx, sb_file, full); @@ -79,6 +84,7 @@ } const SBFileSpec SBFileSpecList::GetFileSpecAtIndex(uint32_t idx) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(const lldb::SBFileSpec, SBFileSpecList, GetFileSpecAtIndex, (uint32_t), idx); @@ -104,6 +110,7 @@ } bool SBFileSpecList::GetDescription(SBStream &description) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(bool, SBFileSpecList, GetDescription, (lldb::SBStream &), description); Index: lldb/source/API/SBFrame.cpp =================================================================== --- lldb/source/API/SBFrame.cpp +++ lldb/source/API/SBFrame.cpp @@ -73,8 +73,9 @@ SBFrame::~SBFrame() = default; const SBFrame &SBFrame::operator=(const SBFrame &rhs) { - LLDB_RECORD_METHOD(const lldb::SBFrame &, - SBFrame, operator=,(const lldb::SBFrame &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBFrame &, SBFrame, operator=, + (const lldb::SBFrame &), rhs); if (this != &rhs) m_opaque_sp = clone(rhs.m_opaque_sp); @@ -90,10 +91,12 @@ } bool SBFrame::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsValid); return this->operator bool(); } SBFrame::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, operator bool); std::unique_lock lock; @@ -112,6 +115,7 @@ } SBSymbolContext SBFrame::GetSymbolContext(uint32_t resolve_scope) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(lldb::SBSymbolContext, SBFrame, GetSymbolContext, (uint32_t), resolve_scope); @@ -133,6 +137,7 @@ } SBModule SBFrame::GetModule() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBModule, SBFrame, GetModule); SBModule sb_module; @@ -158,6 +163,7 @@ } SBCompileUnit SBFrame::GetCompileUnit() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBCompileUnit, SBFrame, GetCompileUnit); @@ -183,6 +189,7 @@ } SBFunction SBFrame::GetFunction() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFunction, SBFrame, GetFunction); SBFunction sb_function; @@ -207,6 +214,7 @@ } SBSymbol SBFrame::GetSymbol() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBSymbol, SBFrame, GetSymbol); SBSymbol sb_symbol; @@ -230,6 +238,7 @@ } SBBlock SBFrame::GetBlock() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBlock, SBFrame, GetBlock); SBBlock sb_block; @@ -251,6 +260,7 @@ } SBBlock SBFrame::GetFrameBlock() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBlock, SBFrame, GetFrameBlock); SBBlock sb_block; @@ -272,6 +282,7 @@ } SBLineEntry SBFrame::GetLineEntry() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBLineEntry, SBFrame, GetLineEntry); SBLineEntry sb_line_entry; @@ -295,6 +306,7 @@ } uint32_t SBFrame::GetFrameID() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBFrame, GetFrameID); uint32_t frame_idx = UINT32_MAX; @@ -310,6 +322,7 @@ } lldb::addr_t SBFrame::GetCFA() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetCFA); std::unique_lock lock; @@ -322,6 +335,7 @@ } addr_t SBFrame::GetPC() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetPC); addr_t addr = LLDB_INVALID_ADDRESS; @@ -346,6 +360,7 @@ } bool SBFrame::SetPC(addr_t new_pc) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBFrame, SetPC, (lldb::addr_t), new_pc); bool ret_val = false; @@ -369,6 +384,7 @@ } addr_t SBFrame::GetSP() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetSP); addr_t addr = LLDB_INVALID_ADDRESS; @@ -392,6 +408,7 @@ } addr_t SBFrame::GetFP() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetFP); addr_t addr = LLDB_INVALID_ADDRESS; @@ -415,6 +432,7 @@ } SBAddress SBFrame::GetPCAddress() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBFrame, GetPCAddress); SBAddress sb_addr; @@ -436,12 +454,14 @@ } void SBFrame::Clear() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBFrame, Clear); m_opaque_sp->Clear(); } lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath, (const char *), var_path); @@ -461,6 +481,7 @@ lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path, DynamicValueType use_dynamic) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath, (const char *, lldb::DynamicValueType), var_path, use_dynamic); @@ -496,6 +517,7 @@ } SBValue SBFrame::FindVariable(const char *name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindVariable, (const char *), name); @@ -515,6 +537,7 @@ SBValue SBFrame::FindVariable(const char *name, lldb::DynamicValueType use_dynamic) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindVariable, (const char *, lldb::DynamicValueType), name, use_dynamic); @@ -549,6 +572,7 @@ } SBValue SBFrame::FindValue(const char *name, ValueType value_type) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindValue, (const char *, lldb::ValueType), name, value_type); @@ -568,6 +592,7 @@ SBValue SBFrame::FindValue(const char *name, ValueType value_type, lldb::DynamicValueType use_dynamic) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindValue, (const char *, lldb::ValueType, lldb::DynamicValueType), name, value_type, use_dynamic); @@ -682,6 +707,7 @@ } bool SBFrame::IsEqual(const SBFrame &that) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(bool, SBFrame, IsEqual, (const lldb::SBFrame &), that); @@ -691,20 +717,23 @@ } bool SBFrame::operator==(const SBFrame &rhs) const { - LLDB_RECORD_METHOD_CONST(bool, SBFrame, operator==,(const lldb::SBFrame &), + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD_CONST(bool, SBFrame, operator==, (const lldb::SBFrame &), rhs); return IsEqual(rhs); } bool SBFrame::operator!=(const SBFrame &rhs) const { - LLDB_RECORD_METHOD_CONST(bool, SBFrame, operator!=,(const lldb::SBFrame &), + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD_CONST(bool, SBFrame, operator!=, (const lldb::SBFrame &), rhs); return !IsEqual(rhs); } SBThread SBFrame::GetThread() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBFrame, GetThread); std::unique_lock lock; @@ -717,6 +746,7 @@ } const char *SBFrame::Disassemble() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFrame, Disassemble); const char *disassembly = nullptr; @@ -741,6 +771,7 @@ SBValueList SBFrame::GetVariables(bool arguments, bool locals, bool statics, bool in_scope_only) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables, (bool, bool, bool, bool), arguments, locals, statics, in_scope_only); @@ -773,6 +804,7 @@ lldb::SBValueList SBFrame::GetVariables(bool arguments, bool locals, bool statics, bool in_scope_only, lldb::DynamicValueType use_dynamic) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables, (bool, bool, bool, bool, lldb::DynamicValueType), arguments, locals, statics, in_scope_only, use_dynamic); @@ -794,6 +826,7 @@ } SBValueList SBFrame::GetVariables(const lldb::SBVariablesOptions &options) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables, (const lldb::SBVariablesOptions &), options); @@ -895,6 +928,7 @@ } SBValueList SBFrame::GetRegisters() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValueList, SBFrame, GetRegisters); SBValueList value_list; @@ -925,6 +959,7 @@ } SBValue SBFrame::FindRegister(const char *name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindRegister, (const char *), name); @@ -957,6 +992,7 @@ } bool SBFrame::GetDescription(SBStream &description) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBFrame, GetDescription, (lldb::SBStream &), description); @@ -984,6 +1020,7 @@ } SBValue SBFrame::EvaluateExpression(const char *expr) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression, (const char *), expr); @@ -1012,6 +1049,7 @@ SBValue SBFrame::EvaluateExpression(const char *expr, lldb::DynamicValueType fetch_dynamic_value) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression, (const char *, lldb::DynamicValueType), expr, fetch_dynamic_value); @@ -1035,6 +1073,7 @@ SBValue SBFrame::EvaluateExpression(const char *expr, lldb::DynamicValueType fetch_dynamic_value, bool unwind_on_error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression, (const char *, lldb::DynamicValueType, bool), expr, fetch_dynamic_value, unwind_on_error); @@ -1057,6 +1096,7 @@ lldb::SBValue SBFrame::EvaluateExpression(const char *expr, const SBExpressionOptions &options) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression, (const char *, const lldb::SBExpressionOptions &), expr, options); @@ -1110,12 +1150,14 @@ } bool SBFrame::IsInlined() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBFrame, IsInlined); return static_cast(this)->IsInlined(); } bool SBFrame::IsInlined() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsInlined); std::unique_lock lock; @@ -1140,12 +1182,14 @@ } bool SBFrame::IsArtificial() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBFrame, IsArtificial); return static_cast(this)->IsArtificial(); } bool SBFrame::IsArtificial() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsArtificial); std::unique_lock lock; @@ -1159,12 +1203,14 @@ } const char *SBFrame::GetFunctionName() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBFrame, GetFunctionName); return static_cast(this)->GetFunctionName(); } lldb::LanguageType SBFrame::GuessLanguage() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::LanguageType, SBFrame, GuessLanguage); std::unique_lock lock; @@ -1186,6 +1232,7 @@ } const char *SBFrame::GetFunctionName() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFrame, GetFunctionName); const char *name = nullptr; @@ -1228,6 +1275,7 @@ } const char *SBFrame::GetDisplayFunctionName() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBFrame, GetDisplayFunctionName); const char *name = nullptr; Index: lldb/source/API/SBFunction.cpp =================================================================== --- lldb/source/API/SBFunction.cpp +++ lldb/source/API/SBFunction.cpp @@ -33,8 +33,9 @@ } const SBFunction &SBFunction::operator=(const SBFunction &rhs) { - LLDB_RECORD_METHOD(const lldb::SBFunction &, - SBFunction, operator=,(const lldb::SBFunction &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBFunction &, SBFunction, operator=, + (const lldb::SBFunction &), rhs); m_opaque_ptr = rhs.m_opaque_ptr; return *this; @@ -43,16 +44,19 @@ SBFunction::~SBFunction() { m_opaque_ptr = nullptr; } bool SBFunction::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFunction, IsValid); return this->operator bool(); } SBFunction::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFunction, operator bool); return m_opaque_ptr != nullptr; } const char *SBFunction::GetName() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFunction, GetName); const char *cstr = nullptr; @@ -63,6 +67,7 @@ } const char *SBFunction::GetDisplayName() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFunction, GetDisplayName); const char *cstr = nullptr; @@ -73,6 +78,7 @@ } const char *SBFunction::GetMangledName() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFunction, GetMangledName); const char *cstr = nullptr; @@ -82,20 +88,23 @@ } bool SBFunction::operator==(const SBFunction &rhs) const { - LLDB_RECORD_METHOD_CONST( - bool, SBFunction, operator==,(const lldb::SBFunction &), rhs); + LLDB_SCOPED_TIMER(); + 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); + LLDB_SCOPED_TIMER(); + 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_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBFunction, GetDescription, (lldb::SBStream &), s); if (m_opaque_ptr) { @@ -111,6 +120,7 @@ } SBInstructionList SBFunction::GetInstructions(SBTarget target) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions, (lldb::SBTarget), target); @@ -119,6 +129,7 @@ SBInstructionList SBFunction::GetInstructions(SBTarget target, const char *flavor) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions, (lldb::SBTarget, const char *), target, flavor); @@ -146,6 +157,7 @@ } SBAddress SBFunction::GetStartAddress() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBFunction, GetStartAddress); SBAddress addr; @@ -155,6 +167,7 @@ } SBAddress SBFunction::GetEndAddress() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBFunction, GetEndAddress); SBAddress addr; @@ -169,6 +182,7 @@ } const char *SBFunction::GetArgumentName(uint32_t arg_idx) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(const char *, SBFunction, GetArgumentName, (uint32_t), arg_idx); @@ -188,6 +202,7 @@ } uint32_t SBFunction::GetPrologueByteSize() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBFunction, GetPrologueByteSize); if (m_opaque_ptr) @@ -196,6 +211,7 @@ } SBType SBFunction::GetType() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBFunction, GetType); SBType sb_type; @@ -208,6 +224,7 @@ } SBBlock SBFunction::GetBlock() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBFunction, GetBlock); SBBlock sb_block; @@ -217,6 +234,7 @@ } lldb::LanguageType SBFunction::GetLanguage() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::LanguageType, SBFunction, GetLanguage); if (m_opaque_ptr) { @@ -227,6 +245,7 @@ } bool SBFunction::GetIsOptimized() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBFunction, GetIsOptimized); if (m_opaque_ptr) { Index: lldb/source/API/SBInstruction.cpp =================================================================== --- lldb/source/API/SBInstruction.cpp +++ lldb/source/API/SBInstruction.cpp @@ -80,9 +80,9 @@ } const SBInstruction &SBInstruction::operator=(const SBInstruction &rhs) { - LLDB_RECORD_METHOD(const lldb::SBInstruction &, - SBInstruction, operator=,(const lldb::SBInstruction &), - rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBInstruction &, SBInstruction, operator=, + (const lldb::SBInstruction &), rhs); if (this != &rhs) m_opaque_sp = rhs.m_opaque_sp; @@ -92,16 +92,19 @@ SBInstruction::~SBInstruction() = default; bool SBInstruction::IsValid() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, IsValid); return this->operator bool(); } SBInstruction::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInstruction, operator bool); return m_opaque_sp && m_opaque_sp->IsValid(); } SBAddress SBInstruction::GetAddress() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBInstruction, GetAddress); SBAddress sb_addr; @@ -112,6 +115,7 @@ } const char *SBInstruction::GetMnemonic(SBTarget target) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(const char *, SBInstruction, GetMnemonic, (lldb::SBTarget), target); @@ -132,6 +136,7 @@ } const char *SBInstruction::GetOperands(SBTarget target) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(const char *, SBInstruction, GetOperands, (lldb::SBTarget), target); @@ -152,6 +157,7 @@ } const char *SBInstruction::GetComment(SBTarget target) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(const char *, SBInstruction, GetComment, (lldb::SBTarget), target); @@ -172,6 +178,7 @@ } size_t SBInstruction::GetByteSize() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(size_t, SBInstruction, GetByteSize); lldb::InstructionSP inst_sp(GetOpaque()); @@ -181,6 +188,7 @@ } SBData SBInstruction::GetData(SBTarget target) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBData, SBInstruction, GetData, (lldb::SBTarget), target); @@ -196,6 +204,7 @@ } bool SBInstruction::DoesBranch() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, DoesBranch); lldb::InstructionSP inst_sp(GetOpaque()); @@ -205,6 +214,7 @@ } bool SBInstruction::HasDelaySlot() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, HasDelaySlot); lldb::InstructionSP inst_sp(GetOpaque()); @@ -214,6 +224,7 @@ } bool SBInstruction::CanSetBreakpoint() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, CanSetBreakpoint); lldb::InstructionSP inst_sp(GetOpaque()); @@ -235,6 +246,7 @@ } bool SBInstruction::GetDescription(lldb::SBStream &s) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBInstruction, GetDescription, (lldb::SBStream &), s); @@ -257,17 +269,20 @@ } void SBInstruction::Print(FILE *outp) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBInstruction, Print, (FILE *), outp); FileSP out = std::make_shared(outp, /*take_ownership=*/false); Print(out); } void SBInstruction::Print(SBFile out) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBInstruction, Print, (SBFile), out); Print(out.m_opaque_sp); } void SBInstruction::Print(FileSP out_sp) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBInstruction, Print, (FileSP), out_sp); if (!out_sp || !out_sp->IsValid()) @@ -291,6 +306,7 @@ bool SBInstruction::EmulateWithFrame(lldb::SBFrame &frame, uint32_t evaluate_options) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBInstruction, EmulateWithFrame, (lldb::SBFrame &, uint32_t), frame, evaluate_options); @@ -316,6 +332,7 @@ } bool SBInstruction::DumpEmulation(const char *triple) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBInstruction, DumpEmulation, (const char *), triple); @@ -328,6 +345,7 @@ bool SBInstruction::TestEmulation(lldb::SBStream &output_stream, const char *test_file) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBInstruction, TestEmulation, (lldb::SBStream &, const char *), output_stream, test_file); Index: lldb/source/API/SBInstructionList.cpp =================================================================== --- lldb/source/API/SBInstructionList.cpp +++ lldb/source/API/SBInstructionList.cpp @@ -33,9 +33,10 @@ const SBInstructionList &SBInstructionList:: operator=(const SBInstructionList &rhs) { - LLDB_RECORD_METHOD( - const lldb::SBInstructionList &, - SBInstructionList, operator=,(const lldb::SBInstructionList &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBInstructionList &, + SBInstructionList, operator=, + (const lldb::SBInstructionList &), rhs); if (this != &rhs) m_opaque_sp = rhs.m_opaque_sp; @@ -45,16 +46,19 @@ SBInstructionList::~SBInstructionList() = default; bool SBInstructionList::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInstructionList, IsValid); return this->operator bool(); } SBInstructionList::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInstructionList, operator bool); return m_opaque_sp.get() != nullptr; } size_t SBInstructionList::GetSize() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(size_t, SBInstructionList, GetSize); if (m_opaque_sp) @@ -63,6 +67,7 @@ } SBInstruction SBInstructionList::GetInstructionAtIndex(uint32_t idx) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBInstruction, SBInstructionList, GetInstructionAtIndex, (uint32_t), idx); @@ -77,6 +82,7 @@ size_t SBInstructionList::GetInstructionsCount(const SBAddress &start, const SBAddress &end, bool canSetBreakpoint) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(size_t, SBInstructionList, GetInstructionsCount, (const lldb::SBAddress &, const lldb::SBAddress &, bool), start, end, canSetBreakpoint); @@ -104,12 +110,14 @@ } void SBInstructionList::Clear() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBInstructionList, Clear); m_opaque_sp.reset(); } void SBInstructionList::AppendInstruction(SBInstruction insn) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBInstructionList, AppendInstruction, (lldb::SBInstruction), insn); } @@ -119,6 +127,7 @@ } void SBInstructionList::Print(FILE *out) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBInstructionList, Print, (FILE *), out); if (out == nullptr) return; @@ -127,6 +136,7 @@ } void SBInstructionList::Print(SBFile out) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBInstructionList, Print, (SBFile), out); if (!out.IsValid()) return; @@ -135,6 +145,7 @@ } void SBInstructionList::Print(FileSP out_sp) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBInstructionList, Print, (FileSP), out_sp); if (!out_sp || !out_sp->IsValid()) return; @@ -143,6 +154,7 @@ } bool SBInstructionList::GetDescription(lldb::SBStream &stream) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBInstructionList, GetDescription, (lldb::SBStream &), stream); return GetDescription(stream.ref()); @@ -186,6 +198,7 @@ } bool SBInstructionList::DumpEmulationForAllInstructions(const char *triple) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBInstructionList, DumpEmulationForAllInstructions, (const char *), triple); Index: lldb/source/API/SBLaunchInfo.cpp =================================================================== --- lldb/source/API/SBLaunchInfo.cpp +++ lldb/source/API/SBLaunchInfo.cpp @@ -54,8 +54,9 @@ } SBLaunchInfo &SBLaunchInfo::operator=(const SBLaunchInfo &rhs) { - LLDB_RECORD_METHOD(SBLaunchInfo &, - SBLaunchInfo, operator=,(const lldb::SBLaunchInfo &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(SBLaunchInfo &, SBLaunchInfo, operator=, + (const lldb::SBLaunchInfo &), rhs); m_opaque_sp = rhs.m_opaque_sp; return *this; @@ -72,48 +73,56 @@ } lldb::pid_t SBLaunchInfo::GetProcessID() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBLaunchInfo, GetProcessID); return m_opaque_sp->GetProcessID(); } uint32_t SBLaunchInfo::GetUserID() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetUserID); return m_opaque_sp->GetUserID(); } uint32_t SBLaunchInfo::GetGroupID() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetGroupID); return m_opaque_sp->GetGroupID(); } bool SBLaunchInfo::UserIDIsValid() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBLaunchInfo, UserIDIsValid); return m_opaque_sp->UserIDIsValid(); } bool SBLaunchInfo::GroupIDIsValid() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBLaunchInfo, GroupIDIsValid); return m_opaque_sp->GroupIDIsValid(); } void SBLaunchInfo::SetUserID(uint32_t uid) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBLaunchInfo, SetUserID, (uint32_t), uid); m_opaque_sp->SetUserID(uid); } void SBLaunchInfo::SetGroupID(uint32_t gid) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBLaunchInfo, SetGroupID, (uint32_t), gid); m_opaque_sp->SetGroupID(gid); } SBFileSpec SBLaunchInfo::GetExecutableFile() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBLaunchInfo, GetExecutableFile); return SBFileSpec(m_opaque_sp->GetExecutableFile()); @@ -121,6 +130,7 @@ void SBLaunchInfo::SetExecutableFile(SBFileSpec exe_file, bool add_as_first_arg) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBLaunchInfo, SetExecutableFile, (lldb::SBFileSpec, bool), exe_file, add_as_first_arg); @@ -128,12 +138,14 @@ } SBListener SBLaunchInfo::GetListener() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBLaunchInfo, GetListener); return SBListener(m_opaque_sp->GetListener()); } void SBLaunchInfo::SetListener(SBListener &listener) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBLaunchInfo, SetListener, (lldb::SBListener &), listener); @@ -141,12 +153,14 @@ } uint32_t SBLaunchInfo::GetNumArguments() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetNumArguments); return m_opaque_sp->GetArguments().GetArgumentCount(); } const char *SBLaunchInfo::GetArgumentAtIndex(uint32_t idx) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(const char *, SBLaunchInfo, GetArgumentAtIndex, (uint32_t), idx); @@ -154,6 +168,7 @@ } void SBLaunchInfo::SetArguments(const char **argv, bool append) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBLaunchInfo, SetArguments, (const char **, bool), argv, append); @@ -169,12 +184,14 @@ } uint32_t SBLaunchInfo::GetNumEnvironmentEntries() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetNumEnvironmentEntries); return m_opaque_sp->GetEnvironment().size(); } const char *SBLaunchInfo::GetEnvironmentEntryAtIndex(uint32_t idx) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(const char *, SBLaunchInfo, GetEnvironmentEntryAtIndex, (uint32_t), idx); @@ -184,12 +201,14 @@ } void SBLaunchInfo::SetEnvironmentEntries(const char **envp, bool append) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBLaunchInfo, SetEnvironmentEntries, (const char **, bool), envp, append); SetEnvironment(SBEnvironment(Environment(envp)), append); } void SBLaunchInfo::SetEnvironment(const SBEnvironment &env, bool append) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBLaunchInfo, SetEnvironment, (const lldb::SBEnvironment &, bool), env, append); Environment &refEnv = env.ref(); @@ -202,17 +221,20 @@ } SBEnvironment SBLaunchInfo::GetEnvironment() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBEnvironment, SBLaunchInfo, GetEnvironment); return SBEnvironment(Environment(m_opaque_sp->GetEnvironment())); } void SBLaunchInfo::Clear() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBLaunchInfo, Clear); m_opaque_sp->Clear(); } const char *SBLaunchInfo::GetWorkingDirectory() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBLaunchInfo, GetWorkingDirectory); @@ -220,6 +242,7 @@ } void SBLaunchInfo::SetWorkingDirectory(const char *working_dir) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBLaunchInfo, SetWorkingDirectory, (const char *), working_dir); @@ -227,24 +250,28 @@ } uint32_t SBLaunchInfo::GetLaunchFlags() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetLaunchFlags); return m_opaque_sp->GetFlags().Get(); } void SBLaunchInfo::SetLaunchFlags(uint32_t flags) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBLaunchInfo, SetLaunchFlags, (uint32_t), flags); m_opaque_sp->GetFlags().Reset(flags); } const char *SBLaunchInfo::GetProcessPluginName() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBLaunchInfo, GetProcessPluginName); return m_opaque_sp->GetProcessPluginName(); } void SBLaunchInfo::SetProcessPluginName(const char *plugin_name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBLaunchInfo, SetProcessPluginName, (const char *), plugin_name); @@ -252,6 +279,7 @@ } const char *SBLaunchInfo::GetShell() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBLaunchInfo, GetShell); // Constify this string so that it is saved in the string pool. Otherwise it @@ -261,18 +289,21 @@ } void SBLaunchInfo::SetShell(const char *path) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBLaunchInfo, SetShell, (const char *), path); m_opaque_sp->SetShell(FileSpec(path)); } bool SBLaunchInfo::GetShellExpandArguments() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBLaunchInfo, GetShellExpandArguments); return m_opaque_sp->GetShellExpandArguments(); } void SBLaunchInfo::SetShellExpandArguments(bool expand) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBLaunchInfo, SetShellExpandArguments, (bool), expand); @@ -280,24 +311,28 @@ } uint32_t SBLaunchInfo::GetResumeCount() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetResumeCount); return m_opaque_sp->GetResumeCount(); } void SBLaunchInfo::SetResumeCount(uint32_t c) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBLaunchInfo, SetResumeCount, (uint32_t), c); m_opaque_sp->SetResumeCount(c); } bool SBLaunchInfo::AddCloseFileAction(int fd) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddCloseFileAction, (int), fd); return m_opaque_sp->AppendCloseFileAction(fd); } bool SBLaunchInfo::AddDuplicateFileAction(int fd, int dup_fd) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddDuplicateFileAction, (int, int), fd, dup_fd); @@ -306,6 +341,7 @@ bool SBLaunchInfo::AddOpenFileAction(int fd, const char *path, bool read, bool write) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddOpenFileAction, (int, const char *, bool, bool), fd, path, read, write); @@ -313,6 +349,7 @@ } bool SBLaunchInfo::AddSuppressFileAction(int fd, bool read, bool write) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddSuppressFileAction, (int, bool, bool), fd, read, write); @@ -320,6 +357,7 @@ } void SBLaunchInfo::SetLaunchEventData(const char *data) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBLaunchInfo, SetLaunchEventData, (const char *), data); @@ -327,6 +365,7 @@ } const char *SBLaunchInfo::GetLaunchEventData() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBLaunchInfo, GetLaunchEventData); @@ -334,18 +373,21 @@ } void SBLaunchInfo::SetDetachOnError(bool enable) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBLaunchInfo, SetDetachOnError, (bool), enable); m_opaque_sp->SetDetachOnError(enable); } bool SBLaunchInfo::GetDetachOnError() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBLaunchInfo, GetDetachOnError); return m_opaque_sp->GetDetachOnError(); } const char *SBLaunchInfo::GetScriptedProcessClassName() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBLaunchInfo, GetScriptedProcessClassName); @@ -356,6 +398,7 @@ } void SBLaunchInfo::SetScriptedProcessClassName(const char *class_name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBLaunchInfo, SetScriptedProcessClassName, (const char *), class_name); @@ -363,6 +406,7 @@ } lldb::SBStructuredData SBLaunchInfo::GetScriptedProcessDictionary() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBStructuredData, SBLaunchInfo, GetScriptedProcessDictionary); @@ -376,6 +420,7 @@ } void SBLaunchInfo::SetScriptedProcessDictionary(lldb::SBStructuredData dict) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBLaunchInfo, SetScriptedProcessDictionary, (lldb::SBStructuredData), dict); if (!dict.IsValid() || !dict.m_impl_up) Index: lldb/source/API/SBLineEntry.cpp =================================================================== --- lldb/source/API/SBLineEntry.cpp +++ lldb/source/API/SBLineEntry.cpp @@ -33,8 +33,9 @@ } const SBLineEntry &SBLineEntry::operator=(const SBLineEntry &rhs) { - LLDB_RECORD_METHOD(const lldb::SBLineEntry &, - SBLineEntry, operator=,(const lldb::SBLineEntry &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBLineEntry &, SBLineEntry, operator=, + (const lldb::SBLineEntry &), rhs); if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); @@ -48,6 +49,7 @@ SBLineEntry::~SBLineEntry() = default; SBAddress SBLineEntry::GetStartAddress() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBLineEntry, GetStartAddress); @@ -59,6 +61,7 @@ } SBAddress SBLineEntry::GetEndAddress() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBLineEntry, GetEndAddress); SBAddress sb_address; @@ -70,16 +73,19 @@ } bool SBLineEntry::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBLineEntry, IsValid); return this->operator bool(); } SBLineEntry::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBLineEntry, operator bool); return m_opaque_up.get() && m_opaque_up->IsValid(); } SBFileSpec SBLineEntry::GetFileSpec() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBLineEntry, GetFileSpec); SBFileSpec sb_file_spec; @@ -90,6 +96,7 @@ } uint32_t SBLineEntry::GetLine() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBLineEntry, GetLine); uint32_t line = 0; @@ -100,6 +107,7 @@ } uint32_t SBLineEntry::GetColumn() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBLineEntry, GetColumn); if (m_opaque_up) @@ -108,6 +116,7 @@ } void SBLineEntry::SetFileSpec(lldb::SBFileSpec filespec) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBLineEntry, SetFileSpec, (lldb::SBFileSpec), filespec); @@ -117,20 +126,23 @@ ref().file.Clear(); } void SBLineEntry::SetLine(uint32_t line) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBLineEntry, SetLine, (uint32_t), line); ref().line = line; } void SBLineEntry::SetColumn(uint32_t column) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBLineEntry, SetColumn, (uint32_t), column); ref().line = column; } bool SBLineEntry::operator==(const SBLineEntry &rhs) const { - LLDB_RECORD_METHOD_CONST( - bool, SBLineEntry, operator==,(const lldb::SBLineEntry &), rhs); + LLDB_SCOPED_TIMER(); + 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(); @@ -142,8 +154,9 @@ } bool SBLineEntry::operator!=(const SBLineEntry &rhs) const { - LLDB_RECORD_METHOD_CONST( - bool, SBLineEntry, operator!=,(const lldb::SBLineEntry &), rhs); + LLDB_SCOPED_TIMER(); + 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(); @@ -167,6 +180,7 @@ const lldb_private::LineEntry &SBLineEntry::ref() const { return *m_opaque_up; } bool SBLineEntry::GetDescription(SBStream &description) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBLineEntry, GetDescription, (lldb::SBStream &), description); Index: lldb/source/API/SBListener.cpp =================================================================== --- lldb/source/API/SBListener.cpp +++ lldb/source/API/SBListener.cpp @@ -33,8 +33,9 @@ } const lldb::SBListener &SBListener::operator=(const lldb::SBListener &rhs) { - LLDB_RECORD_METHOD(const lldb::SBListener &, - SBListener, operator=,(const lldb::SBListener &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBListener &, SBListener, operator=, + (const lldb::SBListener &), rhs); if (this != &rhs) { m_opaque_sp = rhs.m_opaque_sp; @@ -49,16 +50,19 @@ SBListener::~SBListener() = default; bool SBListener::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBListener, IsValid); return this->operator bool(); } SBListener::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBListener, operator bool); return m_opaque_sp != nullptr; } void SBListener::AddEvent(const SBEvent &event) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBListener, AddEvent, (const lldb::SBEvent &), event); @@ -68,6 +72,7 @@ } void SBListener::Clear() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBListener, Clear); if (m_opaque_sp) @@ -77,6 +82,7 @@ uint32_t SBListener::StartListeningForEventClass(SBDebugger &debugger, const char *broadcaster_class, uint32_t event_mask) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(uint32_t, SBListener, StartListeningForEventClass, (lldb::SBDebugger &, const char *, uint32_t), debugger, broadcaster_class, event_mask); @@ -95,6 +101,7 @@ bool SBListener::StopListeningForEventClass(SBDebugger &debugger, const char *broadcaster_class, uint32_t event_mask) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBListener, StopListeningForEventClass, (lldb::SBDebugger &, const char *, uint32_t), debugger, broadcaster_class, event_mask); @@ -112,6 +119,7 @@ uint32_t SBListener::StartListeningForEvents(const SBBroadcaster &broadcaster, uint32_t event_mask) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(uint32_t, SBListener, StartListeningForEvents, (const lldb::SBBroadcaster &, uint32_t), broadcaster, event_mask); @@ -127,6 +135,7 @@ bool SBListener::StopListeningForEvents(const SBBroadcaster &broadcaster, uint32_t event_mask) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBListener, StopListeningForEvents, (const lldb::SBBroadcaster &, uint32_t), broadcaster, event_mask); @@ -138,6 +147,7 @@ } bool SBListener::WaitForEvent(uint32_t timeout_secs, SBEvent &event) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBListener, WaitForEvent, (uint32_t, lldb::SBEvent &), timeout_secs, event); @@ -165,6 +175,7 @@ bool SBListener::WaitForEventForBroadcaster(uint32_t num_seconds, const SBBroadcaster &broadcaster, SBEvent &event) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBListener, WaitForEventForBroadcaster, (uint32_t, const lldb::SBBroadcaster &, lldb::SBEvent &), num_seconds, broadcaster, event); @@ -187,6 +198,7 @@ bool SBListener::WaitForEventForBroadcasterWithType( uint32_t num_seconds, const SBBroadcaster &broadcaster, uint32_t event_type_mask, SBEvent &event) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD( bool, SBListener, WaitForEventForBroadcasterWithType, (uint32_t, const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &), @@ -208,6 +220,7 @@ } bool SBListener::PeekAtNextEvent(SBEvent &event) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBListener, PeekAtNextEvent, (lldb::SBEvent &), event); @@ -221,6 +234,7 @@ bool SBListener::PeekAtNextEventForBroadcaster(const SBBroadcaster &broadcaster, SBEvent &event) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBListener, PeekAtNextEventForBroadcaster, (const lldb::SBBroadcaster &, lldb::SBEvent &), broadcaster, event); @@ -236,6 +250,7 @@ bool SBListener::PeekAtNextEventForBroadcasterWithType( const SBBroadcaster &broadcaster, uint32_t event_type_mask, SBEvent &event) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBListener, PeekAtNextEventForBroadcasterWithType, (const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &), broadcaster, event_type_mask, event); @@ -250,6 +265,7 @@ } bool SBListener::GetNextEvent(SBEvent &event) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBListener, GetNextEvent, (lldb::SBEvent &), event); if (m_opaque_sp) { @@ -265,6 +281,7 @@ bool SBListener::GetNextEventForBroadcaster(const SBBroadcaster &broadcaster, SBEvent &event) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBListener, GetNextEventForBroadcaster, (const lldb::SBBroadcaster &, lldb::SBEvent &), broadcaster, event); @@ -284,6 +301,7 @@ bool SBListener::GetNextEventForBroadcasterWithType( const SBBroadcaster &broadcaster, uint32_t event_type_mask, SBEvent &event) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBListener, GetNextEventForBroadcasterWithType, (const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &), broadcaster, event_type_mask, event); @@ -302,6 +320,7 @@ } bool SBListener::HandleBroadcastEvent(const SBEvent &event) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBListener, HandleBroadcastEvent, (const lldb::SBEvent &), event); Index: lldb/source/API/SBMemoryRegionInfo.cpp =================================================================== --- lldb/source/API/SBMemoryRegionInfo.cpp +++ lldb/source/API/SBMemoryRegionInfo.cpp @@ -54,9 +54,10 @@ const SBMemoryRegionInfo &SBMemoryRegionInfo:: operator=(const SBMemoryRegionInfo &rhs) { - LLDB_RECORD_METHOD( - const lldb::SBMemoryRegionInfo &, - SBMemoryRegionInfo, operator=,(const lldb::SBMemoryRegionInfo &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBMemoryRegionInfo &, + SBMemoryRegionInfo, operator=, + (const lldb::SBMemoryRegionInfo &), rhs); if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); @@ -66,23 +67,24 @@ SBMemoryRegionInfo::~SBMemoryRegionInfo() = default; void SBMemoryRegionInfo::Clear() { + LLDB_SCOPED_TIMER(); 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); + LLDB_SCOPED_TIMER(); + 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); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD_CONST(bool, SBMemoryRegionInfo, operator!=, + (const lldb::SBMemoryRegionInfo &), rhs); return ref() != rhs.ref(); } @@ -92,54 +94,63 @@ const MemoryRegionInfo &SBMemoryRegionInfo::ref() const { return *m_opaque_up; } lldb::addr_t SBMemoryRegionInfo::GetRegionBase() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBMemoryRegionInfo, GetRegionBase); return m_opaque_up->GetRange().GetRangeBase(); } lldb::addr_t SBMemoryRegionInfo::GetRegionEnd() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBMemoryRegionInfo, GetRegionEnd); return m_opaque_up->GetRange().GetRangeEnd(); } bool SBMemoryRegionInfo::IsReadable() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsReadable); return m_opaque_up->GetReadable() == MemoryRegionInfo::eYes; } bool SBMemoryRegionInfo::IsWritable() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsWritable); return m_opaque_up->GetWritable() == MemoryRegionInfo::eYes; } bool SBMemoryRegionInfo::IsExecutable() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsExecutable); return m_opaque_up->GetExecutable() == MemoryRegionInfo::eYes; } bool SBMemoryRegionInfo::IsMapped() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsMapped); return m_opaque_up->GetMapped() == MemoryRegionInfo::eYes; } const char *SBMemoryRegionInfo::GetName() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBMemoryRegionInfo, GetName); return m_opaque_up->GetName().AsCString(); } bool SBMemoryRegionInfo::HasDirtyMemoryPageList() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, HasDirtyMemoryPageList); return m_opaque_up->GetDirtyPageList().hasValue(); } uint32_t SBMemoryRegionInfo::GetNumDirtyPages() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBMemoryRegionInfo, GetNumDirtyPages); uint32_t num_dirty_pages = 0; @@ -152,6 +163,7 @@ } addr_t SBMemoryRegionInfo::GetDirtyPageAddressAtIndex(uint32_t idx) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::addr_t, SBMemoryRegionInfo, GetDirtyPageAddressAtIndex, (uint32_t), idx); @@ -165,12 +177,14 @@ } int SBMemoryRegionInfo::GetPageSize() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(int, SBMemoryRegionInfo, GetPageSize); return m_opaque_up->GetPageSize(); } bool SBMemoryRegionInfo::GetDescription(SBStream &description) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBMemoryRegionInfo, GetDescription, (lldb::SBStream &), description); Index: lldb/source/API/SBMemoryRegionInfoList.cpp =================================================================== --- lldb/source/API/SBMemoryRegionInfoList.cpp +++ lldb/source/API/SBMemoryRegionInfoList.cpp @@ -97,10 +97,10 @@ const SBMemoryRegionInfoList &SBMemoryRegionInfoList:: operator=(const SBMemoryRegionInfoList &rhs) { - LLDB_RECORD_METHOD( - const lldb::SBMemoryRegionInfoList &, - SBMemoryRegionInfoList, operator=,(const lldb::SBMemoryRegionInfoList &), - rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBMemoryRegionInfoList &, + SBMemoryRegionInfoList, operator=, + (const lldb::SBMemoryRegionInfoList &), rhs); if (this != &rhs) { *m_opaque_up = *rhs.m_opaque_up; @@ -109,6 +109,7 @@ } uint32_t SBMemoryRegionInfoList::GetSize() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBMemoryRegionInfoList, GetSize); return m_opaque_up->GetSize(); @@ -116,6 +117,7 @@ bool SBMemoryRegionInfoList::GetMemoryRegionContainingAddress( lldb::addr_t addr, SBMemoryRegionInfo ®ion_info) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD( bool, SBMemoryRegionInfoList, GetMemoryRegionContainingAddress, (lldb::addr_t, lldb::SBMemoryRegionInfo &), addr, region_info); @@ -125,6 +127,7 @@ bool SBMemoryRegionInfoList::GetMemoryRegionAtIndex( uint32_t idx, SBMemoryRegionInfo ®ion_info) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBMemoryRegionInfoList, GetMemoryRegionAtIndex, (uint32_t, lldb::SBMemoryRegionInfo &), idx, region_info); @@ -132,12 +135,14 @@ } void SBMemoryRegionInfoList::Clear() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBMemoryRegionInfoList, Clear); m_opaque_up->Clear(); } void SBMemoryRegionInfoList::Append(SBMemoryRegionInfo &sb_region) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBMemoryRegionInfoList, Append, (lldb::SBMemoryRegionInfo &), sb_region); @@ -145,6 +150,7 @@ } void SBMemoryRegionInfoList::Append(SBMemoryRegionInfoList &sb_region_list) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBMemoryRegionInfoList, Append, (lldb::SBMemoryRegionInfoList &), sb_region_list); Index: lldb/source/API/SBModule.cpp =================================================================== --- lldb/source/API/SBModule.cpp +++ lldb/source/API/SBModule.cpp @@ -64,6 +64,7 @@ } const SBModule &SBModule::operator=(const SBModule &rhs) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(const lldb::SBModule &, SBModule, operator=, (const lldb::SBModule &), rhs); @@ -75,22 +76,26 @@ SBModule::~SBModule() = default; bool SBModule::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModule, IsValid); return this->operator bool(); } SBModule::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModule, operator bool); return m_opaque_sp.get() != nullptr; } void SBModule::Clear() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBModule, Clear); m_opaque_sp.reset(); } SBFileSpec SBModule::GetFileSpec() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule, GetFileSpec); SBFileSpec file_spec; @@ -102,6 +107,7 @@ } lldb::SBFileSpec SBModule::GetPlatformFileSpec() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule, GetPlatformFileSpec); @@ -114,6 +120,7 @@ } bool SBModule::SetPlatformFileSpec(const lldb::SBFileSpec &platform_file) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBModule, SetPlatformFileSpec, (const lldb::SBFileSpec &), platform_file); @@ -129,6 +136,7 @@ } lldb::SBFileSpec SBModule::GetRemoteInstallFileSpec() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModule, GetRemoteInstallFileSpec); @@ -140,6 +148,7 @@ } bool SBModule::SetRemoteInstallFileSpec(lldb::SBFileSpec &file) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBModule, SetRemoteInstallFileSpec, (lldb::SBFileSpec &), file); @@ -152,6 +161,7 @@ } const uint8_t *SBModule::GetUUIDBytes() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(const uint8_t *, SBModule, GetUUIDBytes); const uint8_t *uuid_bytes = nullptr; @@ -163,6 +173,7 @@ } const char *SBModule::GetUUIDString() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBModule, GetUUIDString); const char *uuid_cstr = nullptr; @@ -183,6 +194,7 @@ } bool SBModule::operator==(const SBModule &rhs) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(bool, SBModule, operator==, (const lldb::SBModule &), rhs); @@ -192,6 +204,7 @@ } bool SBModule::operator!=(const SBModule &rhs) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(bool, SBModule, operator!=, (const lldb::SBModule &), rhs); @@ -205,6 +218,7 @@ void SBModule::SetSP(const ModuleSP &module_sp) { m_opaque_sp = module_sp; } SBAddress SBModule::ResolveFileAddress(lldb::addr_t vm_addr) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBAddress, SBModule, ResolveFileAddress, (lldb::addr_t), vm_addr); @@ -221,6 +235,7 @@ SBSymbolContext SBModule::ResolveSymbolContextForAddress(const SBAddress &addr, uint32_t resolve_scope) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBModule, ResolveSymbolContextForAddress, (const lldb::SBAddress &, uint32_t), addr, resolve_scope); @@ -234,6 +249,7 @@ } bool SBModule::GetDescription(SBStream &description) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBModule, GetDescription, (lldb::SBStream &), description); @@ -249,6 +265,7 @@ } uint32_t SBModule::GetNumCompileUnits() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBModule, GetNumCompileUnits); ModuleSP module_sp(GetSP()); @@ -259,6 +276,7 @@ } SBCompileUnit SBModule::GetCompileUnitAtIndex(uint32_t index) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBCompileUnit, SBModule, GetCompileUnitAtIndex, (uint32_t), index); @@ -272,6 +290,7 @@ } SBSymbolContextList SBModule::FindCompileUnits(const SBFileSpec &sb_file_spec) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBModule, FindCompileUnits, (const lldb::SBFileSpec &), sb_file_spec); @@ -290,6 +309,7 @@ } size_t SBModule::GetNumSymbols() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModule, GetNumSymbols); ModuleSP module_sp(GetSP()); @@ -299,6 +319,7 @@ } SBSymbol SBModule::GetSymbolAtIndex(size_t idx) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBSymbol, SBModule, GetSymbolAtIndex, (size_t), idx); SBSymbol sb_symbol; @@ -311,6 +332,7 @@ lldb::SBSymbol SBModule::FindSymbol(const char *name, lldb::SymbolType symbol_type) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBSymbol, SBModule, FindSymbol, (const char *, lldb::SymbolType), name, symbol_type); @@ -328,6 +350,7 @@ lldb::SBSymbolContextList SBModule::FindSymbols(const char *name, lldb::SymbolType symbol_type) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBModule, FindSymbols, (const char *, lldb::SymbolType), name, symbol_type); @@ -356,6 +379,7 @@ } size_t SBModule::GetNumSections() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModule, GetNumSections); ModuleSP module_sp(GetSP()); @@ -370,6 +394,7 @@ } SBSection SBModule::GetSectionAtIndex(size_t idx) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBSection, SBModule, GetSectionAtIndex, (size_t), idx); @@ -388,6 +413,7 @@ lldb::SBSymbolContextList SBModule::FindFunctions(const char *name, uint32_t name_type_mask) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBModule, FindFunctions, (const char *, uint32_t), name, name_type_mask); @@ -407,6 +433,7 @@ SBValueList SBModule::FindGlobalVariables(SBTarget &target, const char *name, uint32_t max_matches) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValueList, SBModule, FindGlobalVariables, (lldb::SBTarget &, const char *, uint32_t), target, name, max_matches); @@ -431,6 +458,7 @@ lldb::SBValue SBModule::FindFirstGlobalVariable(lldb::SBTarget &target, const char *name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValue, SBModule, FindFirstGlobalVariable, (lldb::SBTarget &, const char *), target, name); @@ -441,6 +469,7 @@ } lldb::SBType SBModule::FindFirstType(const char *name_cstr) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBType, SBModule, FindFirstType, (const char *), name_cstr); @@ -467,6 +496,7 @@ } lldb::SBType SBModule::GetBasicType(lldb::BasicType type) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBType, SBModule, GetBasicType, (lldb::BasicType), type); @@ -484,6 +514,7 @@ } lldb::SBTypeList SBModule::FindTypes(const char *type) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBTypeList, SBModule, FindTypes, (const char *), type); @@ -521,6 +552,7 @@ } lldb::SBType SBModule::GetTypeByID(lldb::user_id_t uid) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBType, SBModule, GetTypeByID, (lldb::user_id_t), uid); @@ -536,6 +568,7 @@ } lldb::SBTypeList SBModule::GetTypes(uint32_t type_mask) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBTypeList, SBModule, GetTypes, (uint32_t), type_mask); @@ -556,6 +589,7 @@ } SBSection SBModule::FindSection(const char *sect_name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBSection, SBModule, FindSection, (const char *), sect_name); @@ -578,6 +612,7 @@ } lldb::ByteOrder SBModule::GetByteOrder() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::ByteOrder, SBModule, GetByteOrder); ModuleSP module_sp(GetSP()); @@ -587,6 +622,7 @@ } const char *SBModule::GetTriple() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBModule, GetTriple); ModuleSP module_sp(GetSP()); @@ -602,6 +638,7 @@ } uint32_t SBModule::GetAddressByteSize() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBModule, GetAddressByteSize); ModuleSP module_sp(GetSP()); @@ -611,6 +648,7 @@ } uint32_t SBModule::GetVersion(uint32_t *versions, uint32_t num_versions) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(uint32_t, SBModule, GetVersion, (uint32_t *, uint32_t), versions, num_versions); @@ -640,6 +678,7 @@ } lldb::SBFileSpec SBModule::GetSymbolFileSpec() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule, GetSymbolFileSpec); @@ -653,6 +692,7 @@ } lldb::SBAddress SBModule::GetObjectFileHeaderAddress() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBModule, GetObjectFileHeaderAddress); @@ -667,6 +707,7 @@ } lldb::SBAddress SBModule::GetObjectFileEntryPointAddress() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBModule, GetObjectFileEntryPointAddress); Index: lldb/source/API/SBModuleSpec.cpp =================================================================== --- lldb/source/API/SBModuleSpec.cpp +++ lldb/source/API/SBModuleSpec.cpp @@ -30,8 +30,9 @@ } const SBModuleSpec &SBModuleSpec::operator=(const SBModuleSpec &rhs) { - LLDB_RECORD_METHOD(const lldb::SBModuleSpec &, - SBModuleSpec, operator=,(const lldb::SBModuleSpec &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBModuleSpec &, SBModuleSpec, operator=, + (const lldb::SBModuleSpec &), rhs); if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); @@ -41,22 +42,26 @@ SBModuleSpec::~SBModuleSpec() = default; bool SBModuleSpec::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModuleSpec, IsValid); return this->operator bool(); } SBModuleSpec::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModuleSpec, operator bool); return m_opaque_up->operator bool(); } void SBModuleSpec::Clear() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBModuleSpec, Clear); m_opaque_up->Clear(); } SBFileSpec SBModuleSpec::GetFileSpec() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModuleSpec, GetFileSpec); SBFileSpec sb_spec(m_opaque_up->GetFileSpec()); @@ -64,6 +69,7 @@ } void SBModuleSpec::SetFileSpec(const lldb::SBFileSpec &sb_spec) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBModuleSpec, SetFileSpec, (const lldb::SBFileSpec &), sb_spec); @@ -71,6 +77,7 @@ } lldb::SBFileSpec SBModuleSpec::GetPlatformFileSpec() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModuleSpec, GetPlatformFileSpec); @@ -78,6 +85,7 @@ } void SBModuleSpec::SetPlatformFileSpec(const lldb::SBFileSpec &sb_spec) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBModuleSpec, SetPlatformFileSpec, (const lldb::SBFileSpec &), sb_spec); @@ -85,12 +93,14 @@ } lldb::SBFileSpec SBModuleSpec::GetSymbolFileSpec() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModuleSpec, GetSymbolFileSpec); return SBFileSpec(m_opaque_up->GetSymbolFileSpec()); } void SBModuleSpec::SetSymbolFileSpec(const lldb::SBFileSpec &sb_spec) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBModuleSpec, SetSymbolFileSpec, (const lldb::SBFileSpec &), sb_spec); @@ -98,18 +108,21 @@ } const char *SBModuleSpec::GetObjectName() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBModuleSpec, GetObjectName); return m_opaque_up->GetObjectName().GetCString(); } void SBModuleSpec::SetObjectName(const char *name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBModuleSpec, SetObjectName, (const char *), name); m_opaque_up->GetObjectName().SetCString(name); } const char *SBModuleSpec::GetTriple() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBModuleSpec, GetTriple); std::string triple(m_opaque_up->GetArchitecture().GetTriple().str()); @@ -121,6 +134,7 @@ } void SBModuleSpec::SetTriple(const char *triple) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBModuleSpec, SetTriple, (const char *), triple); m_opaque_up->GetArchitecture().SetTriple(triple); @@ -131,6 +145,7 @@ } size_t SBModuleSpec::GetUUIDLength() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModuleSpec, GetUUIDLength); return m_opaque_up->GetUUID().GetBytes().size(); @@ -142,6 +157,7 @@ } bool SBModuleSpec::GetDescription(lldb::SBStream &description) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBModuleSpec, GetDescription, (lldb::SBStream &), description); @@ -160,9 +176,9 @@ } SBModuleSpecList &SBModuleSpecList::operator=(const SBModuleSpecList &rhs) { - LLDB_RECORD_METHOD( - lldb::SBModuleSpecList &, - SBModuleSpecList, operator=,(const lldb::SBModuleSpecList &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(lldb::SBModuleSpecList &, SBModuleSpecList, operator=, + (const lldb::SBModuleSpecList &), rhs); if (this != &rhs) *m_opaque_up = *rhs.m_opaque_up; @@ -184,6 +200,7 @@ } void SBModuleSpecList::Append(const SBModuleSpec &spec) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBModuleSpecList, Append, (const lldb::SBModuleSpec &), spec); @@ -191,6 +208,7 @@ } void SBModuleSpecList::Append(const SBModuleSpecList &spec_list) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBModuleSpecList, Append, (const lldb::SBModuleSpecList &), spec_list); @@ -198,12 +216,14 @@ } size_t SBModuleSpecList::GetSize() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModuleSpecList, GetSize); return m_opaque_up->GetSize(); } SBModuleSpec SBModuleSpecList::GetSpecAtIndex(size_t i) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBModuleSpec, SBModuleSpecList, GetSpecAtIndex, (size_t), i); @@ -214,6 +234,7 @@ SBModuleSpec SBModuleSpecList::FindFirstMatchingSpec(const SBModuleSpec &match_spec) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBModuleSpec, SBModuleSpecList, FindFirstMatchingSpec, (const lldb::SBModuleSpec &), match_spec); @@ -226,6 +247,7 @@ SBModuleSpecList SBModuleSpecList::FindMatchingSpecs(const SBModuleSpec &match_spec) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBModuleSpecList, SBModuleSpecList, FindMatchingSpecs, (const lldb::SBModuleSpec &), match_spec); @@ -237,6 +259,7 @@ } bool SBModuleSpecList::GetDescription(lldb::SBStream &description) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBModuleSpecList, GetDescription, (lldb::SBStream &), description); Index: lldb/source/API/SBPlatform.cpp =================================================================== --- lldb/source/API/SBPlatform.cpp +++ lldb/source/API/SBPlatform.cpp @@ -91,17 +91,17 @@ SBPlatformConnectOptions & SBPlatformConnectOptions::operator=(const SBPlatformConnectOptions &rhs) { - LLDB_RECORD_METHOD( - SBPlatformConnectOptions &, - SBPlatformConnectOptions, operator=,( - const lldb::SBPlatformConnectOptions &), - rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(SBPlatformConnectOptions &, + SBPlatformConnectOptions, operator=, + (const lldb::SBPlatformConnectOptions &), rhs); *m_opaque_ptr = *rhs.m_opaque_ptr; return *this; } const char *SBPlatformConnectOptions::GetURL() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformConnectOptions, GetURL); if (m_opaque_ptr->m_url.empty()) @@ -110,6 +110,7 @@ } void SBPlatformConnectOptions::SetURL(const char *url) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBPlatformConnectOptions, SetURL, (const char *), url); @@ -120,6 +121,7 @@ } bool SBPlatformConnectOptions::GetRsyncEnabled() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBPlatformConnectOptions, GetRsyncEnabled); return m_opaque_ptr->m_rsync_enabled; @@ -128,6 +130,7 @@ void SBPlatformConnectOptions::EnableRsync( const char *options, const char *remote_path_prefix, bool omit_hostname_from_remote_path) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBPlatformConnectOptions, EnableRsync, (const char *, const char *, bool), options, remote_path_prefix, omit_hostname_from_remote_path); @@ -147,12 +150,14 @@ } void SBPlatformConnectOptions::DisableRsync() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatformConnectOptions, DisableRsync); m_opaque_ptr->m_rsync_enabled = false; } const char *SBPlatformConnectOptions::GetLocalCacheDirectory() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformConnectOptions, GetLocalCacheDirectory); @@ -160,6 +165,7 @@ } void SBPlatformConnectOptions::SetLocalCacheDirectory(const char *path) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBPlatformConnectOptions, SetLocalCacheDirectory, (const char *), path); @@ -195,10 +201,10 @@ SBPlatformShellCommand & SBPlatformShellCommand::operator=(const SBPlatformShellCommand &rhs) { - LLDB_RECORD_METHOD( - SBPlatformShellCommand &, - SBPlatformShellCommand, operator=,(const lldb::SBPlatformShellCommand &), - rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(SBPlatformShellCommand &, + SBPlatformShellCommand, operator=, + (const lldb::SBPlatformShellCommand &), rhs); *m_opaque_ptr = *rhs.m_opaque_ptr; return *this; @@ -207,6 +213,7 @@ SBPlatformShellCommand::~SBPlatformShellCommand() { delete m_opaque_ptr; } void SBPlatformShellCommand::Clear() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatformShellCommand, Clear); m_opaque_ptr->m_output = std::string(); @@ -215,6 +222,7 @@ } const char *SBPlatformShellCommand::GetShell() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand, GetShell); if (m_opaque_ptr->m_shell.empty()) @@ -223,6 +231,7 @@ } void SBPlatformShellCommand::SetShell(const char *shell_interpreter) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetShell, (const char *), shell_interpreter); @@ -233,6 +242,7 @@ } const char *SBPlatformShellCommand::GetCommand() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand, GetCommand); if (m_opaque_ptr->m_command.empty()) @@ -241,6 +251,7 @@ } void SBPlatformShellCommand::SetCommand(const char *shell_command) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetCommand, (const char *), shell_command); @@ -251,6 +262,7 @@ } const char *SBPlatformShellCommand::GetWorkingDirectory() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand, GetWorkingDirectory); @@ -260,6 +272,7 @@ } void SBPlatformShellCommand::SetWorkingDirectory(const char *path) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetWorkingDirectory, (const char *), path); @@ -270,6 +283,7 @@ } uint32_t SBPlatformShellCommand::GetTimeoutSeconds() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatformShellCommand, GetTimeoutSeconds); @@ -279,6 +293,7 @@ } void SBPlatformShellCommand::SetTimeoutSeconds(uint32_t sec) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetTimeoutSeconds, (uint32_t), sec); @@ -289,18 +304,21 @@ } int SBPlatformShellCommand::GetSignal() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(int, SBPlatformShellCommand, GetSignal); return m_opaque_ptr->m_signo; } int SBPlatformShellCommand::GetStatus() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(int, SBPlatformShellCommand, GetStatus); return m_opaque_ptr->m_status; } const char *SBPlatformShellCommand::GetOutput() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand, GetOutput); if (m_opaque_ptr->m_output.empty()) @@ -326,8 +344,9 @@ } SBPlatform &SBPlatform::operator=(const SBPlatform &rhs) { - LLDB_RECORD_METHOD(SBPlatform &, - SBPlatform, operator=,(const lldb::SBPlatform &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(SBPlatform &, SBPlatform, operator=, + (const lldb::SBPlatform &), rhs); m_opaque_sp = rhs.m_opaque_sp; return *this; @@ -345,22 +364,26 @@ } bool SBPlatform::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBPlatform, IsValid); return this->operator bool(); } SBPlatform::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBPlatform, operator bool); return m_opaque_sp.get() != nullptr; } void SBPlatform::Clear() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatform, Clear); m_opaque_sp.reset(); } const char *SBPlatform::GetName() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetName); PlatformSP platform_sp(GetSP()); @@ -376,6 +399,7 @@ } const char *SBPlatform::GetWorkingDirectory() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetWorkingDirectory); PlatformSP platform_sp(GetSP()); @@ -385,6 +409,7 @@ } bool SBPlatform::SetWorkingDirectory(const char *path) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBPlatform, SetWorkingDirectory, (const char *), path); @@ -400,6 +425,7 @@ } SBError SBPlatform::ConnectRemote(SBPlatformConnectOptions &connect_options) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, ConnectRemote, (lldb::SBPlatformConnectOptions &), connect_options); @@ -416,6 +442,7 @@ } void SBPlatform::DisconnectRemote() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatform, DisconnectRemote); PlatformSP platform_sp(GetSP()); @@ -424,6 +451,7 @@ } bool SBPlatform::IsConnected() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBPlatform, IsConnected); PlatformSP platform_sp(GetSP()); @@ -433,6 +461,7 @@ } const char *SBPlatform::GetTriple() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetTriple); PlatformSP platform_sp(GetSP()); @@ -448,6 +477,7 @@ } const char *SBPlatform::GetOSBuild() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetOSBuild); PlatformSP platform_sp(GetSP()); @@ -463,6 +493,7 @@ } const char *SBPlatform::GetOSDescription() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetOSDescription); PlatformSP platform_sp(GetSP()); @@ -478,6 +509,7 @@ } const char *SBPlatform::GetHostname() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetHostname); PlatformSP platform_sp(GetSP()); @@ -487,6 +519,7 @@ } uint32_t SBPlatform::GetOSMajorVersion() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatform, GetOSMajorVersion); llvm::VersionTuple version; @@ -496,6 +529,7 @@ } uint32_t SBPlatform::GetOSMinorVersion() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatform, GetOSMinorVersion); llvm::VersionTuple version; @@ -505,6 +539,7 @@ } uint32_t SBPlatform::GetOSUpdateVersion() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatform, GetOSUpdateVersion); llvm::VersionTuple version; @@ -514,6 +549,7 @@ } SBError SBPlatform::Get(SBFileSpec &src, SBFileSpec &dst) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Get, (lldb::SBFileSpec &, lldb::SBFileSpec &), src, dst); @@ -528,6 +564,7 @@ } SBError SBPlatform::Put(SBFileSpec &src, SBFileSpec &dst) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Put, (lldb::SBFileSpec &, lldb::SBFileSpec &), src, dst); return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) { @@ -551,6 +588,7 @@ } SBError SBPlatform::Install(SBFileSpec &src, SBFileSpec &dst) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Install, (lldb::SBFileSpec &, lldb::SBFileSpec &), src, dst); return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) { @@ -565,6 +603,7 @@ } SBError SBPlatform::Run(SBPlatformShellCommand &shell_command) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Run, (lldb::SBPlatformShellCommand &), shell_command); return ExecuteConnected( @@ -589,6 +628,7 @@ } SBError SBPlatform::Launch(SBLaunchInfo &launch_info) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Launch, (lldb::SBLaunchInfo &), launch_info); return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) { @@ -600,6 +640,7 @@ } SBError SBPlatform::Kill(const lldb::pid_t pid) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Kill, (const lldb::pid_t), pid); return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) { return platform_sp->KillProcess(pid); @@ -622,6 +663,7 @@ } SBError SBPlatform::MakeDirectory(const char *path, uint32_t file_permissions) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, MakeDirectory, (const char *, uint32_t), path, file_permissions); @@ -637,6 +679,7 @@ } uint32_t SBPlatform::GetFilePermissions(const char *path) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(uint32_t, SBPlatform, GetFilePermissions, (const char *), path); @@ -651,6 +694,7 @@ SBError SBPlatform::SetFilePermissions(const char *path, uint32_t file_permissions) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, SetFilePermissions, (const char *, uint32_t), path, file_permissions); @@ -666,6 +710,7 @@ } SBUnixSignals SBPlatform::GetUnixSignals() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBUnixSignals, SBPlatform, GetUnixSignals); @@ -676,6 +721,7 @@ } SBEnvironment SBPlatform::GetEnvironment() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBEnvironment, SBPlatform, GetEnvironment); PlatformSP platform_sp(GetSP()); Index: lldb/source/API/SBProcess.cpp =================================================================== --- lldb/source/API/SBProcess.cpp +++ lldb/source/API/SBProcess.cpp @@ -63,8 +63,9 @@ } const SBProcess &SBProcess::operator=(const SBProcess &rhs) { - LLDB_RECORD_METHOD(const lldb::SBProcess &, - SBProcess, operator=,(const lldb::SBProcess &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBProcess &, SBProcess, operator=, + (const lldb::SBProcess &), rhs); if (this != &rhs) m_opaque_wp = rhs.m_opaque_wp; @@ -82,6 +83,7 @@ } const char *SBProcess::GetPluginName() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetPluginName); ProcessSP process_sp(GetSP()); @@ -92,6 +94,7 @@ } const char *SBProcess::GetShortPluginName() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetShortPluginName); ProcessSP process_sp(GetSP()); @@ -106,16 +109,19 @@ void SBProcess::SetSP(const ProcessSP &process_sp) { m_opaque_wp = process_sp; } void SBProcess::Clear() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBProcess, Clear); m_opaque_wp.reset(); } bool SBProcess::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcess, IsValid); return this->operator bool(); } SBProcess::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcess, operator bool); ProcessSP process_sp(m_opaque_wp.lock()); @@ -128,6 +134,7 @@ const char *working_directory, uint32_t launch_flags, bool stop_at_entry, lldb::SBError &error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBProcess, RemoteLaunch, (const char **, const char **, const char *, const char *, const char *, const char *, uint32_t, bool, @@ -165,6 +172,7 @@ bool SBProcess::RemoteAttachToProcessWithID(lldb::pid_t pid, lldb::SBError &error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBProcess, RemoteAttachToProcessWithID, (lldb::pid_t, lldb::SBError &), pid, error); @@ -188,6 +196,7 @@ } uint32_t SBProcess::GetNumThreads() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumThreads); uint32_t num_threads = 0; @@ -205,6 +214,7 @@ } SBThread SBProcess::GetSelectedThread() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBProcess, GetSelectedThread); @@ -223,6 +233,7 @@ SBThread SBProcess::CreateOSPluginThread(lldb::tid_t tid, lldb::addr_t context) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, CreateOSPluginThread, (lldb::tid_t, lldb::addr_t), tid, context); @@ -240,6 +251,7 @@ } SBTarget SBProcess::GetTarget() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBTarget, SBProcess, GetTarget); SBTarget sb_target; @@ -254,6 +266,7 @@ } size_t SBProcess::PutSTDIN(const char *src, size_t src_len) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(size_t, SBProcess, PutSTDIN, (const char *, size_t), src, src_len); @@ -268,6 +281,7 @@ } size_t SBProcess::GetSTDOUT(char *dst, size_t dst_len) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(size_t, SBProcess, GetSTDOUT, (char *, size_t), dst, "", dst_len); @@ -282,6 +296,7 @@ } size_t SBProcess::GetSTDERR(char *dst, size_t dst_len) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(size_t, SBProcess, GetSTDERR, (char *, size_t), dst, "", dst_len); @@ -296,6 +311,7 @@ } size_t SBProcess::GetAsyncProfileData(char *dst, size_t dst_len) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(size_t, SBProcess, GetAsyncProfileData, (char *, size_t), dst, "", dst_len); @@ -310,6 +326,7 @@ } void SBProcess::ReportEventState(const SBEvent &event, SBFile out) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(void, SBProcess, ReportEventState, (const SBEvent &, SBFile), event, out); @@ -317,6 +334,7 @@ } void SBProcess::ReportEventState(const SBEvent &event, FILE *out) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(void, SBProcess, ReportEventState, (const lldb::SBEvent &, FILE *), event, out); FileSP outfile = std::make_shared(out, false); @@ -325,6 +343,7 @@ void SBProcess::ReportEventState(const SBEvent &event, FileSP out) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(void, SBProcess, ReportEventState, (const SBEvent &, FileSP), event, out); @@ -342,6 +361,7 @@ void SBProcess::AppendEventStateReport(const SBEvent &event, SBCommandReturnObject &result) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBProcess, AppendEventStateReport, (const lldb::SBEvent &, lldb::SBCommandReturnObject &), event, result); @@ -358,6 +378,7 @@ } bool SBProcess::SetSelectedThread(const SBThread &thread) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThread, (const lldb::SBThread &), thread); @@ -372,10 +393,10 @@ } bool SBProcess::SetSelectedThreadByID(lldb::tid_t tid) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByID, (lldb::tid_t), tid); - bool ret_val = false; ProcessSP process_sp(GetSP()); if (process_sp) { @@ -388,6 +409,7 @@ } bool SBProcess::SetSelectedThreadByIndexID(uint32_t index_id) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByIndexID, (uint32_t), index_id); @@ -404,6 +426,7 @@ } SBThread SBProcess::GetThreadAtIndex(size_t index) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadAtIndex, (size_t), index); @@ -423,6 +446,7 @@ } uint32_t SBProcess::GetNumQueues() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumQueues); uint32_t num_queues = 0; @@ -440,6 +464,7 @@ } SBQueue SBProcess::GetQueueAtIndex(size_t index) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBQueue, SBProcess, GetQueueAtIndex, (size_t), index); @@ -460,6 +485,7 @@ } uint32_t SBProcess::GetStopID(bool include_expression_stops) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(uint32_t, SBProcess, GetStopID, (bool), include_expression_stops); @@ -476,6 +502,7 @@ } SBEvent SBProcess::GetStopEventForStopID(uint32_t stop_id) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBEvent, SBProcess, GetStopEventForStopID, (uint32_t), stop_id); @@ -493,6 +520,7 @@ } StateType SBProcess::GetState() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::StateType, SBProcess, GetState); StateType ret_val = eStateInvalid; @@ -507,6 +535,7 @@ } int SBProcess::GetExitStatus() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(int, SBProcess, GetExitStatus); int exit_status = 0; @@ -521,6 +550,7 @@ } const char *SBProcess::GetExitDescription() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetExitDescription); const char *exit_desc = nullptr; @@ -534,6 +564,7 @@ } lldb::pid_t SBProcess::GetProcessID() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBProcess, GetProcessID); lldb::pid_t ret_val = LLDB_INVALID_PROCESS_ID; @@ -545,6 +576,7 @@ } uint32_t SBProcess::GetUniqueID() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetUniqueID); uint32_t ret_val = 0; @@ -555,6 +587,7 @@ } ByteOrder SBProcess::GetByteOrder() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ByteOrder, SBProcess, GetByteOrder); ByteOrder byteOrder = eByteOrderInvalid; @@ -567,6 +600,7 @@ } uint32_t SBProcess::GetAddressByteSize() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBProcess, GetAddressByteSize); uint32_t size = 0; @@ -579,6 +613,7 @@ } SBError SBProcess::Continue() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Continue); SBError sb_error; @@ -599,6 +634,7 @@ } SBError SBProcess::Destroy() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Destroy); SBError sb_error; @@ -614,6 +650,7 @@ } SBError SBProcess::Stop() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Stop); SBError sb_error; @@ -629,6 +666,7 @@ } SBError SBProcess::Kill() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Kill); SBError sb_error; @@ -644,6 +682,7 @@ } SBError SBProcess::Detach() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Detach); // FIXME: This should come from a process default. @@ -652,6 +691,7 @@ } SBError SBProcess::Detach(bool keep_stopped) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBProcess, Detach, (bool), keep_stopped); SBError sb_error; @@ -667,6 +707,7 @@ } SBError SBProcess::Signal(int signo) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBProcess, Signal, (int), signo); SBError sb_error; @@ -682,6 +723,7 @@ } SBUnixSignals SBProcess::GetUnixSignals() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBUnixSignals, SBProcess, GetUnixSignals); if (auto process_sp = GetSP()) @@ -691,6 +733,7 @@ } void SBProcess::SendAsyncInterrupt() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBProcess, SendAsyncInterrupt); ProcessSP process_sp(GetSP()); @@ -700,6 +743,7 @@ } SBThread SBProcess::GetThreadByID(tid_t tid) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadByID, (lldb::tid_t), tid); @@ -719,6 +763,7 @@ } SBThread SBProcess::GetThreadByIndexID(uint32_t index_id) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadByIndexID, (uint32_t), index_id); @@ -822,10 +867,10 @@ } SBBroadcaster SBProcess::GetBroadcaster() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBProcess, GetBroadcaster); - ProcessSP process_sp(GetSP()); SBBroadcaster broadcaster(process_sp.get(), false); @@ -842,6 +887,7 @@ size_t SBProcess::ReadMemory(addr_t addr, void *dst, size_t dst_len, SBError &sb_error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(size_t, SBProcess, ReadMemory, (lldb::addr_t, void *, size_t, lldb::SBError &), addr, dst, dst_len, sb_error); @@ -869,6 +915,7 @@ size_t SBProcess::ReadCStringFromMemory(addr_t addr, void *buf, size_t size, lldb::SBError &sb_error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(size_t, SBProcess, ReadCStringFromMemory, (lldb::addr_t, void *, size_t, lldb::SBError &), addr, buf, size, sb_error); @@ -893,6 +940,7 @@ uint64_t SBProcess::ReadUnsignedFromMemory(addr_t addr, uint32_t byte_size, lldb::SBError &sb_error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(uint64_t, SBProcess, ReadUnsignedFromMemory, (lldb::addr_t, uint32_t, lldb::SBError &), addr, byte_size, sb_error); @@ -917,6 +965,7 @@ lldb::addr_t SBProcess::ReadPointerFromMemory(addr_t addr, lldb::SBError &sb_error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::addr_t, SBProcess, ReadPointerFromMemory, (lldb::addr_t, lldb::SBError &), addr, sb_error); @@ -939,6 +988,7 @@ size_t SBProcess::WriteMemory(addr_t addr, const void *src, size_t src_len, SBError &sb_error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(size_t, SBProcess, WriteMemory, (lldb::addr_t, const void *, size_t, lldb::SBError &), addr, src, src_len, sb_error); @@ -963,6 +1013,7 @@ } bool SBProcess::GetDescription(SBStream &description) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBProcess, GetDescription, (lldb::SBStream &), description); @@ -988,6 +1039,7 @@ } SBStructuredData SBProcess::GetExtendedCrashInformation() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStructuredData, SBProcess, GetExtendedCrashInformation); SBStructuredData data; @@ -1013,6 +1065,7 @@ uint32_t SBProcess::GetNumSupportedHardwareWatchpoints(lldb::SBError &sb_error) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(uint32_t, SBProcess, GetNumSupportedHardwareWatchpoints, (lldb::SBError &), sb_error); @@ -1031,6 +1084,7 @@ uint32_t SBProcess::LoadImage(lldb::SBFileSpec &sb_remote_image_spec, lldb::SBError &sb_error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(uint32_t, SBProcess, LoadImage, (lldb::SBFileSpec &, lldb::SBError &), sb_remote_image_spec, sb_error); @@ -1041,6 +1095,7 @@ uint32_t SBProcess::LoadImage(const lldb::SBFileSpec &sb_local_image_spec, const lldb::SBFileSpec &sb_remote_image_spec, lldb::SBError &sb_error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD( uint32_t, SBProcess, LoadImage, (const lldb::SBFileSpec &, const lldb::SBFileSpec &, lldb::SBError &), @@ -1068,6 +1123,7 @@ SBStringList &paths, lldb::SBFileSpec &loaded_path, lldb::SBError &error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(uint32_t, SBProcess, LoadImageUsingPaths, (const lldb::SBFileSpec &, lldb::SBStringList &, lldb::SBFileSpec &, lldb::SBError &), @@ -1103,6 +1159,7 @@ } lldb::SBError SBProcess::UnloadImage(uint32_t image_token) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBProcess, UnloadImage, (uint32_t), image_token); @@ -1125,6 +1182,7 @@ } lldb::SBError SBProcess::SendEventData(const char *event_data) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBProcess, SendEventData, (const char *), event_data); @@ -1145,6 +1203,7 @@ } uint32_t SBProcess::GetNumExtendedBacktraceTypes() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumExtendedBacktraceTypes); ProcessSP process_sp(GetSP()); @@ -1156,6 +1215,7 @@ } const char *SBProcess::GetExtendedBacktraceTypeAtIndex(uint32_t idx) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(const char *, SBProcess, GetExtendedBacktraceTypeAtIndex, (uint32_t), idx); @@ -1172,6 +1232,7 @@ } SBThreadCollection SBProcess::GetHistoryThreads(addr_t addr) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBThreadCollection, SBProcess, GetHistoryThreads, (lldb::addr_t), addr); @@ -1185,6 +1246,7 @@ bool SBProcess::IsInstrumentationRuntimePresent( InstrumentationRuntimeType type) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBProcess, IsInstrumentationRuntimePresent, (lldb::InstrumentationRuntimeType), type); @@ -1205,6 +1267,7 @@ } lldb::SBError SBProcess::SaveCore(const char *file_name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBProcess, SaveCore, (const char *), file_name); @@ -1232,6 +1295,7 @@ lldb::SBError SBProcess::GetMemoryRegionInfo(lldb::addr_t load_addr, SBMemoryRegionInfo &sb_region_info) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBProcess, GetMemoryRegionInfo, (lldb::addr_t, lldb::SBMemoryRegionInfo &), load_addr, sb_region_info); @@ -1256,6 +1320,7 @@ } lldb::SBMemoryRegionInfoList SBProcess::GetMemoryRegions() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBMemoryRegionInfoList, SBProcess, GetMemoryRegions); @@ -1274,6 +1339,7 @@ } lldb::SBProcessInfo SBProcess::GetProcessInfo() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcessInfo, SBProcess, GetProcessInfo); lldb::SBProcessInfo sb_proc_info; @@ -1287,6 +1353,7 @@ lldb::addr_t SBProcess::AllocateMemory(size_t size, uint32_t permissions, lldb::SBError &sb_error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::addr_t, SBProcess, AllocateMemory, (size_t, uint32_t, lldb::SBError &), size, permissions, sb_error); @@ -1309,6 +1376,7 @@ } lldb::SBError SBProcess::DeallocateMemory(lldb::addr_t ptr) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBProcess, DeallocateMemory, (lldb::addr_t), ptr); Index: lldb/source/API/SBProcessInfo.cpp =================================================================== --- lldb/source/API/SBProcessInfo.cpp +++ lldb/source/API/SBProcessInfo.cpp @@ -28,9 +28,9 @@ SBProcessInfo::~SBProcessInfo() = default; SBProcessInfo &SBProcessInfo::operator=(const SBProcessInfo &rhs) { - LLDB_RECORD_METHOD(lldb::SBProcessInfo &, - SBProcessInfo, operator=,(const lldb::SBProcessInfo &), - rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(lldb::SBProcessInfo &, SBProcessInfo, operator=, + (const lldb::SBProcessInfo &), rhs); if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); @@ -49,16 +49,19 @@ } bool SBProcessInfo::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcessInfo, IsValid); return this->operator bool(); } SBProcessInfo::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcessInfo, operator bool); return m_opaque_up != nullptr; } const char *SBProcessInfo::GetName() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcessInfo, GetName); const char *name = nullptr; @@ -69,6 +72,7 @@ } SBFileSpec SBProcessInfo::GetExecutableFile() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBProcessInfo, GetExecutableFile); @@ -80,6 +84,7 @@ } lldb::pid_t SBProcessInfo::GetProcessID() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBProcessInfo, GetProcessID); lldb::pid_t proc_id = LLDB_INVALID_PROCESS_ID; @@ -90,6 +95,7 @@ } uint32_t SBProcessInfo::GetUserID() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetUserID); uint32_t user_id = UINT32_MAX; @@ -100,6 +106,7 @@ } uint32_t SBProcessInfo::GetGroupID() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetGroupID); uint32_t group_id = UINT32_MAX; @@ -110,6 +117,7 @@ } bool SBProcessInfo::UserIDIsValid() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, UserIDIsValid); bool is_valid = false; @@ -120,6 +128,7 @@ } bool SBProcessInfo::GroupIDIsValid() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, GroupIDIsValid); bool is_valid = false; @@ -130,6 +139,7 @@ } uint32_t SBProcessInfo::GetEffectiveUserID() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetEffectiveUserID); uint32_t user_id = UINT32_MAX; @@ -140,6 +150,7 @@ } uint32_t SBProcessInfo::GetEffectiveGroupID() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetEffectiveGroupID); uint32_t group_id = UINT32_MAX; @@ -150,6 +161,7 @@ } bool SBProcessInfo::EffectiveUserIDIsValid() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, EffectiveUserIDIsValid); bool is_valid = false; @@ -160,6 +172,7 @@ } bool SBProcessInfo::EffectiveGroupIDIsValid() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, EffectiveGroupIDIsValid); bool is_valid = false; @@ -170,6 +183,7 @@ } lldb::pid_t SBProcessInfo::GetParentProcessID() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBProcessInfo, GetParentProcessID); lldb::pid_t proc_id = LLDB_INVALID_PROCESS_ID; @@ -180,6 +194,7 @@ } const char *SBProcessInfo::GetTriple() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcessInfo, GetTriple); const char *triple = nullptr; Index: lldb/source/API/SBQueue.cpp =================================================================== --- lldb/source/API/SBQueue.cpp +++ lldb/source/API/SBQueue.cpp @@ -234,8 +234,9 @@ } const lldb::SBQueue &SBQueue::operator=(const lldb::SBQueue &rhs) { - LLDB_RECORD_METHOD(const lldb::SBQueue &, - SBQueue, operator=,(const lldb::SBQueue &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBQueue &, SBQueue, operator=, + (const lldb::SBQueue &), rhs); m_opaque_sp = rhs.m_opaque_sp; return *this; @@ -244,16 +245,19 @@ SBQueue::~SBQueue() = default; bool SBQueue::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBQueue, IsValid); return this->operator bool(); } SBQueue::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBQueue, operator bool); return m_opaque_sp->IsValid(); } void SBQueue::Clear() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBQueue, Clear); m_opaque_sp->Clear(); @@ -264,12 +268,14 @@ } lldb::queue_id_t SBQueue::GetQueueID() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::queue_id_t, SBQueue, GetQueueID); return m_opaque_sp->GetQueueID(); } uint32_t SBQueue::GetIndexID() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBQueue, GetIndexID); uint32_t index_id = m_opaque_sp->GetIndexID(); @@ -277,18 +283,21 @@ } const char *SBQueue::GetName() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBQueue, GetName); return m_opaque_sp->GetName(); } uint32_t SBQueue::GetNumThreads() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBQueue, GetNumThreads); return m_opaque_sp->GetNumThreads(); } SBThread SBQueue::GetThreadAtIndex(uint32_t idx) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBThread, SBQueue, GetThreadAtIndex, (uint32_t), idx); @@ -297,12 +306,14 @@ } uint32_t SBQueue::GetNumPendingItems() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBQueue, GetNumPendingItems); return m_opaque_sp->GetNumPendingItems(); } SBQueueItem SBQueue::GetPendingItemAtIndex(uint32_t idx) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBQueueItem, SBQueue, GetPendingItemAtIndex, (uint32_t), idx); @@ -310,18 +321,21 @@ } uint32_t SBQueue::GetNumRunningItems() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBQueue, GetNumRunningItems); return m_opaque_sp->GetNumRunningItems(); } SBProcess SBQueue::GetProcess() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBQueue, GetProcess); return m_opaque_sp->GetProcess(); } lldb::QueueKind SBQueue::GetKind() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::QueueKind, SBQueue, GetKind); return m_opaque_sp->GetKind(); Index: lldb/source/API/SBQueueItem.cpp =================================================================== --- lldb/source/API/SBQueueItem.cpp +++ lldb/source/API/SBQueueItem.cpp @@ -33,22 +33,26 @@ SBQueueItem::~SBQueueItem() { m_queue_item_sp.reset(); } bool SBQueueItem::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBQueueItem, IsValid); return this->operator bool(); } SBQueueItem::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBQueueItem, operator bool); return m_queue_item_sp.get() != nullptr; } void SBQueueItem::Clear() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBQueueItem, Clear); m_queue_item_sp.reset(); } void SBQueueItem::SetQueueItem(const QueueItemSP &queue_item_sp) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBQueueItem, SetQueueItem, (const lldb::QueueItemSP &), queue_item_sp); @@ -56,6 +60,7 @@ } lldb::QueueItemKind SBQueueItem::GetKind() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::QueueItemKind, SBQueueItem, GetKind); QueueItemKind result = eQueueItemKindUnknown; @@ -66,6 +71,7 @@ } void SBQueueItem::SetKind(lldb::QueueItemKind kind) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBQueueItem, SetKind, (lldb::QueueItemKind), kind); if (m_queue_item_sp) { @@ -74,6 +80,7 @@ } SBAddress SBQueueItem::GetAddress() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBQueueItem, GetAddress); SBAddress result; @@ -84,6 +91,7 @@ } void SBQueueItem::SetAddress(SBAddress addr) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBQueueItem, SetAddress, (lldb::SBAddress), addr); if (m_queue_item_sp) { @@ -92,6 +100,7 @@ } SBThread SBQueueItem::GetExtendedBacktraceThread(const char *type) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBThread, SBQueueItem, GetExtendedBacktraceThread, (const char *), type); Index: lldb/source/API/SBSection.cpp =================================================================== --- lldb/source/API/SBSection.cpp +++ lldb/source/API/SBSection.cpp @@ -34,8 +34,9 @@ } const SBSection &SBSection::operator=(const SBSection &rhs) { - LLDB_RECORD_METHOD(const lldb::SBSection &, - SBSection, operator=,(const lldb::SBSection &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBSection &, SBSection, operator=, + (const lldb::SBSection &), rhs); m_opaque_wp = rhs.m_opaque_wp; return *this; @@ -44,10 +45,12 @@ SBSection::~SBSection() = default; bool SBSection::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSection, IsValid); return this->operator bool(); } SBSection::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSection, operator bool); SectionSP section_sp(GetSP()); @@ -55,6 +58,7 @@ } const char *SBSection::GetName() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBSection, GetName); SectionSP section_sp(GetSP()); @@ -64,6 +68,7 @@ } lldb::SBSection SBSection::GetParent() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSection, SBSection, GetParent); lldb::SBSection sb_section; @@ -77,6 +82,7 @@ } lldb::SBSection SBSection::FindSubSection(const char *sect_name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBSection, SBSection, FindSubSection, (const char *), sect_name); @@ -93,6 +99,7 @@ } size_t SBSection::GetNumSubSections() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(size_t, SBSection, GetNumSubSections); SectionSP section_sp(GetSP()); @@ -102,6 +109,7 @@ } lldb::SBSection SBSection::GetSubSectionAtIndex(size_t idx) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBSection, SBSection, GetSubSectionAtIndex, (size_t), idx); @@ -119,6 +127,7 @@ } lldb::addr_t SBSection::GetFileAddress() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBSection, GetFileAddress); lldb::addr_t file_addr = LLDB_INVALID_ADDRESS; @@ -129,6 +138,7 @@ } lldb::addr_t SBSection::GetLoadAddress(lldb::SBTarget &sb_target) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::addr_t, SBSection, GetLoadAddress, (lldb::SBTarget &), sb_target); @@ -142,6 +152,7 @@ } lldb::addr_t SBSection::GetByteSize() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBSection, GetByteSize); SectionSP section_sp(GetSP()); @@ -151,6 +162,7 @@ } uint64_t SBSection::GetFileOffset() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBSection, GetFileOffset); SectionSP section_sp(GetSP()); @@ -166,6 +178,7 @@ } uint64_t SBSection::GetFileByteSize() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBSection, GetFileByteSize); SectionSP section_sp(GetSP()); @@ -175,12 +188,14 @@ } SBData SBSection::GetSectionData() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBData, SBSection, GetSectionData); return GetSectionData(0, UINT64_MAX); } SBData SBSection::GetSectionData(uint64_t offset, uint64_t size) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBData, SBSection, GetSectionData, (uint64_t, uint64_t), offset, size); @@ -221,6 +236,7 @@ } SectionType SBSection::GetSectionType() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SectionType, SBSection, GetSectionType); SectionSP section_sp(GetSP()); @@ -230,6 +246,7 @@ } uint32_t SBSection::GetPermissions() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBSection, GetPermissions); SectionSP section_sp(GetSP()); @@ -239,6 +256,7 @@ } uint32_t SBSection::GetTargetByteSize() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBSection, GetTargetByteSize); SectionSP section_sp(GetSP()); @@ -248,7 +266,8 @@ } bool SBSection::operator==(const SBSection &rhs) { - LLDB_RECORD_METHOD(bool, SBSection, operator==,(const lldb::SBSection &), + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(bool, SBSection, operator==, (const lldb::SBSection &), rhs); SectionSP lhs_section_sp(GetSP()); @@ -259,7 +278,8 @@ } bool SBSection::operator!=(const SBSection &rhs) { - LLDB_RECORD_METHOD(bool, SBSection, operator!=,(const lldb::SBSection &), + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(bool, SBSection, operator!=, (const lldb::SBSection &), rhs); SectionSP lhs_section_sp(GetSP()); @@ -268,6 +288,7 @@ } bool SBSection::GetDescription(SBStream &description) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBSection, GetDescription, (lldb::SBStream &), description); Index: lldb/source/API/SBSourceManager.cpp =================================================================== --- lldb/source/API/SBSourceManager.cpp +++ lldb/source/API/SBSourceManager.cpp @@ -95,9 +95,9 @@ const lldb::SBSourceManager &SBSourceManager:: operator=(const lldb::SBSourceManager &rhs) { - LLDB_RECORD_METHOD(const lldb::SBSourceManager &, - SBSourceManager, operator=,(const lldb::SBSourceManager &), - rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBSourceManager &, SBSourceManager, operator=, + (const lldb::SBSourceManager &), rhs); m_opaque_up = std::make_unique(*(rhs.m_opaque_up.get())); return *this; @@ -108,6 +108,7 @@ 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_SCOPED_TIMER(); LLDB_RECORD_METHOD(size_t, SBSourceManager, DisplaySourceLinesWithLineNumbers, (const lldb::SBFileSpec &, uint32_t, uint32_t, uint32_t, const char *, lldb::SBStream &), @@ -124,6 +125,7 @@ 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_SCOPED_TIMER(); LLDB_RECORD_METHOD( size_t, SBSourceManager, DisplaySourceLinesWithLineNumbersAndColumn, (const lldb::SBFileSpec &, uint32_t, uint32_t, uint32_t, uint32_t, Index: lldb/source/API/SBStream.cpp =================================================================== --- lldb/source/API/SBStream.cpp +++ lldb/source/API/SBStream.cpp @@ -29,10 +29,12 @@ SBStream::~SBStream() = default; bool SBStream::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStream, IsValid); return this->operator bool(); } SBStream::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStream, operator bool); return (m_opaque_up != nullptr); @@ -41,6 +43,7 @@ // 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_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBStream, GetData); if (m_is_file || m_opaque_up == nullptr) @@ -52,6 +55,7 @@ // 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_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(size_t, SBStream, GetSize); if (m_is_file || m_opaque_up == nullptr) @@ -61,6 +65,7 @@ } void SBStream::Print(const char *str) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBStream, Print, (const char *), str); Printf("%s", str); @@ -76,6 +81,7 @@ } void SBStream::RedirectToFile(const char *path, bool append) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBStream, RedirectToFile, (const char *, bool), path, append); @@ -114,6 +120,7 @@ } void SBStream::RedirectToFileHandle(FILE *fh, bool transfer_fh_ownership) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBStream, RedirectToFileHandle, (FILE *, bool), fh, transfer_fh_ownership); FileSP file = std::make_unique(fh, transfer_fh_ownership); @@ -121,11 +128,13 @@ } void SBStream::RedirectToFile(SBFile file) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBStream, RedirectToFile, (SBFile), file) RedirectToFile(file.GetFile()); } void SBStream::RedirectToFile(FileSP file_sp) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBStream, RedirectToFile, (FileSP), file_sp); if (!file_sp || !file_sp->IsValid()) @@ -150,6 +159,7 @@ } void SBStream::RedirectToFileDescriptor(int fd, bool transfer_fh_ownership) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBStream, RedirectToFileDescriptor, (int, bool), fd, transfer_fh_ownership); @@ -182,6 +192,7 @@ } void SBStream::Clear() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBStream, Clear); if (m_opaque_up) { Index: lldb/source/API/SBStringList.cpp =================================================================== --- lldb/source/API/SBStringList.cpp +++ lldb/source/API/SBStringList.cpp @@ -28,8 +28,9 @@ } const SBStringList &SBStringList::operator=(const SBStringList &rhs) { - LLDB_RECORD_METHOD(const lldb::SBStringList &, - SBStringList, operator=,(const lldb::SBStringList &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBStringList &, SBStringList, operator=, + (const lldb::SBStringList &), rhs); if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); @@ -47,16 +48,19 @@ } bool SBStringList::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStringList, IsValid); return this->operator bool(); } SBStringList::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStringList, operator bool); return (m_opaque_up != nullptr); } void SBStringList::AppendString(const char *str) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBStringList, AppendString, (const char *), str); if (str != nullptr) { @@ -68,6 +72,7 @@ } void SBStringList::AppendList(const char **strv, int strc) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBStringList, AppendList, (const char **, int), strv, strc); @@ -80,6 +85,7 @@ } void SBStringList::AppendList(const SBStringList &strings) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBStringList, AppendList, (const lldb::SBStringList &), strings); @@ -97,6 +103,7 @@ } uint32_t SBStringList::GetSize() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBStringList, GetSize); if (IsValid()) { @@ -106,6 +113,7 @@ } const char *SBStringList::GetStringAtIndex(size_t idx) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(const char *, SBStringList, GetStringAtIndex, (size_t), idx); @@ -116,6 +124,7 @@ } const char *SBStringList::GetStringAtIndex(size_t idx) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(const char *, SBStringList, GetStringAtIndex, (size_t), idx); @@ -126,6 +135,7 @@ } void SBStringList::Clear() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBStringList, Clear); if (IsValid()) { Index: lldb/source/API/SBStructuredData.cpp =================================================================== --- lldb/source/API/SBStructuredData.cpp +++ lldb/source/API/SBStructuredData.cpp @@ -49,15 +49,16 @@ SBStructuredData &SBStructuredData:: operator=(const lldb::SBStructuredData &rhs) { - LLDB_RECORD_METHOD( - lldb::SBStructuredData &, - SBStructuredData, operator=,(const lldb::SBStructuredData &), rhs); + LLDB_SCOPED_TIMER(); + 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_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBStructuredData, SetFromJSON, (lldb::SBStream &), stream); @@ -73,6 +74,7 @@ } lldb::SBError SBStructuredData::SetFromJSON(const char *json) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBStructuredData, SetFromJSON, (const char *), json); lldb::SBStream s; @@ -81,23 +83,27 @@ } bool SBStructuredData::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStructuredData, IsValid); return this->operator bool(); } SBStructuredData::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStructuredData, operator bool); return m_impl_up->IsValid(); } void SBStructuredData::Clear() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBStructuredData, Clear); m_impl_up->Clear(); } SBError SBStructuredData::GetAsJSON(lldb::SBStream &stream) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(lldb::SBError, SBStructuredData, GetAsJSON, (lldb::SBStream &), stream); @@ -107,6 +113,7 @@ } lldb::SBError SBStructuredData::GetDescription(lldb::SBStream &stream) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(lldb::SBError, SBStructuredData, GetDescription, (lldb::SBStream &), stream); @@ -117,6 +124,7 @@ } StructuredDataType SBStructuredData::GetType() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::StructuredDataType, SBStructuredData, GetType); @@ -124,12 +132,14 @@ } size_t SBStructuredData::GetSize() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBStructuredData, GetSize); return m_impl_up->GetSize(); } bool SBStructuredData::GetKeys(lldb::SBStringList &keys) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(bool, SBStructuredData, GetKeys, (lldb::SBStringList &), keys); @@ -157,6 +167,7 @@ } lldb::SBStructuredData SBStructuredData::GetValueForKey(const char *key) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(lldb::SBStructuredData, SBStructuredData, GetValueForKey, (const char *), key); @@ -166,6 +177,7 @@ } lldb::SBStructuredData SBStructuredData::GetItemAtIndex(size_t idx) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(lldb::SBStructuredData, SBStructuredData, GetItemAtIndex, (size_t), idx); @@ -175,6 +187,7 @@ } uint64_t SBStructuredData::GetIntegerValue(uint64_t fail_value) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(uint64_t, SBStructuredData, GetIntegerValue, (uint64_t), fail_value); @@ -182,6 +195,7 @@ } double SBStructuredData::GetFloatValue(double fail_value) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(double, SBStructuredData, GetFloatValue, (double), fail_value); @@ -189,6 +203,7 @@ } bool SBStructuredData::GetBooleanValue(bool fail_value) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(bool, SBStructuredData, GetBooleanValue, (bool), fail_value); @@ -196,6 +211,7 @@ } size_t SBStructuredData::GetStringValue(char *dst, size_t dst_len) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(size_t, SBStructuredData, GetStringValue, (char *, size_t), dst, "", dst_len); Index: lldb/source/API/SBSymbol.cpp =================================================================== --- lldb/source/API/SBSymbol.cpp +++ lldb/source/API/SBSymbol.cpp @@ -28,8 +28,9 @@ } const SBSymbol &SBSymbol::operator=(const SBSymbol &rhs) { - LLDB_RECORD_METHOD(const lldb::SBSymbol &, - SBSymbol, operator=,(const lldb::SBSymbol &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBSymbol &, SBSymbol, operator=, + (const lldb::SBSymbol &), rhs); m_opaque_ptr = rhs.m_opaque_ptr; return *this; @@ -42,16 +43,19 @@ } bool SBSymbol::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbol, IsValid); return this->operator bool(); } SBSymbol::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbol, operator bool); return m_opaque_ptr != nullptr; } const char *SBSymbol::GetName() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetName); const char *name = nullptr; @@ -62,6 +66,7 @@ } const char *SBSymbol::GetDisplayName() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetDisplayName); const char *name = nullptr; @@ -72,6 +77,7 @@ } const char *SBSymbol::GetMangledName() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetMangledName); const char *name = nullptr; @@ -81,20 +87,23 @@ } bool SBSymbol::operator==(const SBSymbol &rhs) const { - LLDB_RECORD_METHOD_CONST(bool, SBSymbol, operator==,(const lldb::SBSymbol &), + LLDB_SCOPED_TIMER(); + 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 &), + LLDB_SCOPED_TIMER(); + 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_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBSymbol, GetDescription, (lldb::SBStream &), description); @@ -109,6 +118,7 @@ } SBInstructionList SBSymbol::GetInstructions(SBTarget target) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions, (lldb::SBTarget), target); @@ -117,6 +127,7 @@ SBInstructionList SBSymbol::GetInstructions(SBTarget target, const char *flavor_string) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions, (lldb::SBTarget, const char *), target, flavor_string); @@ -145,6 +156,7 @@ void SBSymbol::reset(lldb_private::Symbol *symbol) { m_opaque_ptr = symbol; } SBAddress SBSymbol::GetStartAddress() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBSymbol, GetStartAddress); SBAddress addr; @@ -155,6 +167,7 @@ } SBAddress SBSymbol::GetEndAddress() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBSymbol, GetEndAddress); SBAddress addr; @@ -169,6 +182,7 @@ } uint32_t SBSymbol::GetPrologueByteSize() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBSymbol, GetPrologueByteSize); if (m_opaque_ptr) @@ -177,6 +191,7 @@ } SymbolType SBSymbol::GetType() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SymbolType, SBSymbol, GetType); if (m_opaque_ptr) @@ -185,6 +200,7 @@ } bool SBSymbol::IsExternal() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBSymbol, IsExternal); if (m_opaque_ptr) @@ -193,6 +209,7 @@ } bool SBSymbol::IsSynthetic() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBSymbol, IsSynthetic); if (m_opaque_ptr) Index: lldb/source/API/SBSymbolContext.cpp =================================================================== --- lldb/source/API/SBSymbolContext.cpp +++ lldb/source/API/SBSymbolContext.cpp @@ -38,9 +38,9 @@ SBSymbolContext::~SBSymbolContext() = default; const SBSymbolContext &SBSymbolContext::operator=(const SBSymbolContext &rhs) { - LLDB_RECORD_METHOD(const lldb::SBSymbolContext &, - SBSymbolContext, operator=,(const lldb::SBSymbolContext &), - rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBSymbolContext &, SBSymbolContext, operator=, + (const lldb::SBSymbolContext &), rhs); if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); @@ -48,16 +48,19 @@ } bool SBSymbolContext::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContext, IsValid); return this->operator bool(); } SBSymbolContext::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContext, operator bool); return m_opaque_up != nullptr; } SBModule SBSymbolContext::GetModule() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBModule, SBSymbolContext, GetModule); SBModule sb_module; @@ -71,6 +74,7 @@ } SBCompileUnit SBSymbolContext::GetCompileUnit() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCompileUnit, SBSymbolContext, GetCompileUnit); @@ -78,6 +82,7 @@ } SBFunction SBSymbolContext::GetFunction() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFunction, SBSymbolContext, GetFunction); Function *function = nullptr; @@ -91,12 +96,14 @@ } SBBlock SBSymbolContext::GetBlock() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBSymbolContext, GetBlock); return SBBlock(m_opaque_up ? m_opaque_up->block : nullptr); } SBLineEntry SBSymbolContext::GetLineEntry() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBLineEntry, SBSymbolContext, GetLineEntry); SBLineEntry sb_line_entry; @@ -107,6 +114,7 @@ } SBSymbol SBSymbolContext::GetSymbol() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSymbol, SBSymbolContext, GetSymbol); Symbol *symbol = nullptr; @@ -120,6 +128,7 @@ } void SBSymbolContext::SetModule(lldb::SBModule module) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBSymbolContext, SetModule, (lldb::SBModule), module); @@ -127,6 +136,7 @@ } void SBSymbolContext::SetCompileUnit(lldb::SBCompileUnit compile_unit) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBSymbolContext, SetCompileUnit, (lldb::SBCompileUnit), compile_unit); @@ -134,6 +144,7 @@ } void SBSymbolContext::SetFunction(lldb::SBFunction function) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBSymbolContext, SetFunction, (lldb::SBFunction), function); @@ -141,12 +152,14 @@ } void SBSymbolContext::SetBlock(lldb::SBBlock block) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBSymbolContext, SetBlock, (lldb::SBBlock), block); ref().block = block.GetPtr(); } void SBSymbolContext::SetLineEntry(lldb::SBLineEntry line_entry) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBSymbolContext, SetLineEntry, (lldb::SBLineEntry), line_entry); @@ -157,6 +170,7 @@ } void SBSymbolContext::SetSymbol(lldb::SBSymbol symbol) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBSymbolContext, SetSymbol, (lldb::SBSymbol), symbol); @@ -189,6 +203,7 @@ } bool SBSymbolContext::GetDescription(SBStream &description) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBSymbolContext, GetDescription, (lldb::SBStream &), description); @@ -205,6 +220,7 @@ SBSymbolContext SBSymbolContext::GetParentOfInlinedScope(const SBAddress &curr_frame_pc, SBAddress &parent_frame_addr) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(lldb::SBSymbolContext, SBSymbolContext, GetParentOfInlinedScope, (const lldb::SBAddress &, lldb::SBAddress &), Index: lldb/source/API/SBSymbolContextList.cpp =================================================================== --- lldb/source/API/SBSymbolContextList.cpp +++ lldb/source/API/SBSymbolContextList.cpp @@ -31,9 +31,10 @@ const SBSymbolContextList &SBSymbolContextList:: operator=(const SBSymbolContextList &rhs) { - LLDB_RECORD_METHOD( - const lldb::SBSymbolContextList &, - SBSymbolContextList, operator=,(const lldb::SBSymbolContextList &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBSymbolContextList &, + SBSymbolContextList, operator=, + (const lldb::SBSymbolContextList &), rhs); if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); @@ -41,6 +42,7 @@ } uint32_t SBSymbolContextList::GetSize() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBSymbolContextList, GetSize); if (m_opaque_up) @@ -49,6 +51,7 @@ } SBSymbolContext SBSymbolContextList::GetContextAtIndex(uint32_t idx) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBSymbolContextList, GetContextAtIndex, (uint32_t), idx); @@ -62,6 +65,7 @@ } void SBSymbolContextList::Clear() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBSymbolContextList, Clear); if (m_opaque_up) @@ -69,6 +73,7 @@ } void SBSymbolContextList::Append(SBSymbolContext &sc) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBSymbolContextList, Append, (lldb::SBSymbolContext &), sc); @@ -77,6 +82,7 @@ } void SBSymbolContextList::Append(SBSymbolContextList &sc_list) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBSymbolContextList, Append, (lldb::SBSymbolContextList &), sc_list); @@ -85,10 +91,12 @@ } bool SBSymbolContextList::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContextList, IsValid); return this->operator bool(); } SBSymbolContextList::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContextList, operator bool); return m_opaque_up != nullptr; @@ -104,6 +112,7 @@ } bool SBSymbolContextList::GetDescription(lldb::SBStream &description) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBSymbolContextList, GetDescription, (lldb::SBStream &), description); Index: lldb/source/API/SBTarget.cpp =================================================================== --- lldb/source/API/SBTarget.cpp +++ lldb/source/API/SBTarget.cpp @@ -104,8 +104,9 @@ } const SBTarget &SBTarget::operator=(const SBTarget &rhs) { - LLDB_RECORD_METHOD(const lldb::SBTarget &, - SBTarget, operator=,(const lldb::SBTarget &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBTarget &, SBTarget, operator=, + (const lldb::SBTarget &), rhs); if (this != &rhs) m_opaque_sp = rhs.m_opaque_sp; @@ -157,16 +158,19 @@ } bool SBTarget::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTarget, IsValid); return this->operator bool(); } SBTarget::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTarget, operator bool); return m_opaque_sp.get() != nullptr && m_opaque_sp->IsValid(); } SBProcess SBTarget::GetProcess() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBTarget, GetProcess); SBProcess sb_process; @@ -181,6 +185,7 @@ } SBPlatform SBTarget::GetPlatform() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBPlatform, SBTarget, GetPlatform); TargetSP target_sp(GetSP()); @@ -194,6 +199,7 @@ } SBDebugger SBTarget::GetDebugger() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBDebugger, SBTarget, GetDebugger); SBDebugger debugger; @@ -204,6 +210,7 @@ } SBStructuredData SBTarget::GetStatistics() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStructuredData, SBTarget, GetStatistics); SBStructuredData data; @@ -219,6 +226,7 @@ } void SBTarget::SetCollectingStats(bool v) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBTarget, SetCollectingStats, (bool), v); TargetSP target_sp(GetSP()); @@ -228,6 +236,7 @@ } bool SBTarget::GetCollectingStats() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, GetCollectingStats); TargetSP target_sp(GetSP()); @@ -237,6 +246,7 @@ } SBProcess SBTarget::LoadCore(const char *core_file) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, LoadCore, (const char *), core_file); @@ -245,6 +255,7 @@ } SBProcess SBTarget::LoadCore(const char *core_file, lldb::SBError &error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, LoadCore, (const char *, lldb::SBError &), core_file, error); @@ -270,6 +281,7 @@ SBProcess SBTarget::LaunchSimple(char const **argv, char const **envp, const char *working_directory) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, LaunchSimple, (const char **, const char **, const char *), argv, envp, working_directory); @@ -295,6 +307,7 @@ } SBError SBTarget::Install() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBTarget, Install); SBError sb_error; @@ -312,6 +325,7 @@ const char *working_directory, uint32_t launch_flags, // See LaunchFlags bool stop_at_entry, lldb::SBError &error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, Launch, (lldb::SBListener &, const char **, const char **, const char *, const char *, const char *, const char *, @@ -395,11 +409,11 @@ } SBProcess SBTarget::Launch(SBLaunchInfo &sb_launch_info, SBError &error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, Launch, (lldb::SBLaunchInfo &, lldb::SBError &), sb_launch_info, error); - SBProcess sb_process; TargetSP target_sp(GetSP()); @@ -444,6 +458,7 @@ } lldb::SBProcess SBTarget::Attach(SBAttachInfo &sb_attach_info, SBError &error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, Attach, (lldb::SBAttachInfo &, lldb::SBError &), sb_attach_info, error); @@ -483,6 +498,7 @@ lldb::pid_t pid, // The process ID to attach to SBError &error // An error explaining what went wrong if attach fails ) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, AttachToProcessWithID, (lldb::SBListener &, lldb::pid_t, lldb::SBError &), listener, pid, error); @@ -515,6 +531,7 @@ 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_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, AttachToProcessWithName, (lldb::SBListener &, const char *, bool, lldb::SBError &), listener, name, wait_for, error); @@ -541,6 +558,7 @@ lldb::SBProcess SBTarget::ConnectRemote(SBListener &listener, const char *url, const char *plugin_name, SBError &error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD( lldb::SBProcess, SBTarget, ConnectRemote, (lldb::SBListener &, const char *, const char *, lldb::SBError &), @@ -574,6 +592,7 @@ } SBFileSpec SBTarget::GetExecutable() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBTarget, GetExecutable); SBFileSpec exe_file_spec; @@ -588,14 +607,16 @@ } bool SBTarget::operator==(const SBTarget &rhs) const { - LLDB_RECORD_METHOD_CONST(bool, SBTarget, operator==,(const lldb::SBTarget &), + LLDB_SCOPED_TIMER(); + 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 &), + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD_CONST(bool, SBTarget, operator!=, (const lldb::SBTarget &), rhs); return m_opaque_sp.get() != rhs.m_opaque_sp.get(); @@ -608,6 +629,7 @@ } lldb::SBAddress SBTarget::ResolveLoadAddress(lldb::addr_t vm_addr) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolveLoadAddress, (lldb::addr_t), vm_addr); @@ -627,6 +649,7 @@ } lldb::SBAddress SBTarget::ResolveFileAddress(lldb::addr_t file_addr) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolveFileAddress, (lldb::addr_t), file_addr); @@ -645,6 +668,7 @@ lldb::SBAddress SBTarget::ResolvePastLoadAddress(uint32_t stop_id, lldb::addr_t vm_addr) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolvePastLoadAddress, (uint32_t, lldb::addr_t), stop_id, vm_addr); @@ -666,6 +690,7 @@ SBSymbolContext SBTarget::ResolveSymbolContextForAddress(const SBAddress &addr, uint32_t resolve_scope) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBTarget, ResolveSymbolContextForAddress, (const lldb::SBAddress &, uint32_t), addr, resolve_scope); @@ -683,6 +708,7 @@ size_t SBTarget::ReadMemory(const SBAddress addr, void *buf, size_t size, lldb::SBError &error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(size_t, SBTarget, ReadMemory, (const lldb::SBAddress, void *, size_t, lldb::SBError &), addr, buf, size, error); @@ -703,6 +729,7 @@ SBBreakpoint SBTarget::BreakpointCreateByLocation(const char *file, uint32_t line) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation, (const char *, uint32_t), file, line); @@ -713,6 +740,7 @@ SBBreakpoint SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec, uint32_t line) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation, (const lldb::SBFileSpec &, uint32_t), sb_file_spec, line); @@ -722,6 +750,7 @@ SBBreakpoint SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec, uint32_t line, lldb::addr_t offset) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation, (const lldb::SBFileSpec &, uint32_t, lldb::addr_t), sb_file_spec, line, offset); @@ -734,6 +763,7 @@ SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec, uint32_t line, lldb::addr_t offset, SBFileSpecList &sb_module_list) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation, (const lldb::SBFileSpec &, uint32_t, lldb::addr_t, lldb::SBFileSpecList &), @@ -746,6 +776,7 @@ SBBreakpoint SBTarget::BreakpointCreateByLocation( const SBFileSpec &sb_file_spec, uint32_t line, uint32_t column, lldb::addr_t offset, SBFileSpecList &sb_module_list) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation, (const lldb::SBFileSpec &, uint32_t, uint32_t, lldb::addr_t, lldb::SBFileSpecList &), @@ -777,6 +808,7 @@ const SBFileSpec &sb_file_spec, uint32_t line, uint32_t column, lldb::addr_t offset, SBFileSpecList &sb_module_list, bool move_to_nearest_code) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation, (const lldb::SBFileSpec &, uint32_t, uint32_t, lldb::addr_t, lldb::SBFileSpecList &, bool), @@ -807,6 +839,7 @@ SBBreakpoint SBTarget::BreakpointCreateByName(const char *symbol_name, const char *module_name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName, (const char *, const char *), symbol_name, module_name); @@ -839,6 +872,7 @@ SBTarget::BreakpointCreateByName(const char *symbol_name, const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName, (const char *, const lldb::SBFileSpecList &, const lldb::SBFileSpecList &), @@ -853,6 +887,7 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateByName( const char *symbol_name, uint32_t name_type_mask, const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName, (const char *, uint32_t, const lldb::SBFileSpecList &, const lldb::SBFileSpecList &), @@ -867,6 +902,7 @@ const char *symbol_name, uint32_t name_type_mask, LanguageType symbol_language, const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName, (const char *, uint32_t, lldb::LanguageType, const lldb::SBFileSpecList &, @@ -893,6 +929,7 @@ 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) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD( lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames, (const char **, uint32_t, uint32_t, const lldb::SBFileSpecList &, @@ -908,6 +945,7 @@ 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) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames, (const char **, uint32_t, uint32_t, lldb::LanguageType, const lldb::SBFileSpecList &, @@ -924,6 +962,7 @@ 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_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames, (const char **, uint32_t, uint32_t, lldb::LanguageType, lldb::addr_t, const lldb::SBFileSpecList &, @@ -949,6 +988,7 @@ SBBreakpoint SBTarget::BreakpointCreateByRegex(const char *symbol_name_regex, const char *module_name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex, (const char *, const char *), symbol_name_regex, module_name); @@ -966,6 +1006,7 @@ SBTarget::BreakpointCreateByRegex(const char *symbol_name_regex, const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex, (const char *, const lldb::SBFileSpecList &, const lldb::SBFileSpecList &), @@ -978,13 +1019,13 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateByRegex( const char *symbol_name_regex, LanguageType symbol_language, const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { + LLDB_SCOPED_TIMER(); 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); - SBBreakpoint sb_bp; TargetSP target_sp(GetSP()); if (target_sp && symbol_name_regex && symbol_name_regex[0]) { @@ -1003,6 +1044,7 @@ } SBBreakpoint SBTarget::BreakpointCreateByAddress(addr_t address) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByAddress, (lldb::addr_t), address); @@ -1018,6 +1060,7 @@ } SBBreakpoint SBTarget::BreakpointCreateBySBAddress(SBAddress &sb_address) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateBySBAddress, (lldb::SBAddress &), sb_address); @@ -1040,6 +1083,7 @@ SBTarget::BreakpointCreateBySourceRegex(const char *source_regex, const lldb::SBFileSpec &source_file, const char *module_name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateBySourceRegex, (const char *, const lldb::SBFileSpec &, const char *), @@ -1063,6 +1107,7 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex( const char *source_regex, const SBFileSpecList &module_list, const lldb::SBFileSpecList &source_file_list) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateBySourceRegex, (const char *, const lldb::SBFileSpecList &, @@ -1077,6 +1122,7 @@ const char *source_regex, const SBFileSpecList &module_list, const lldb::SBFileSpecList &source_file_list, const SBStringList &func_names) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateBySourceRegex, (const char *, const lldb::SBFileSpecList &, @@ -1106,6 +1152,7 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateForException(lldb::LanguageType language, bool catch_bp, bool throw_bp) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateForException, (lldb::LanguageType, bool, bool), language, catch_bp, throw_bp); @@ -1126,6 +1173,7 @@ const char *class_name, SBStructuredData &extra_args, const SBFileSpecList &module_list, const SBFileSpecList &file_list, bool request_hardware) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD( lldb::SBBreakpoint, SBTarget, BreakpointCreateFromScript, (const char *, lldb::SBStructuredData &, const lldb::SBFileSpecList &, @@ -1153,6 +1201,7 @@ } uint32_t SBTarget::GetNumBreakpoints() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumBreakpoints); TargetSP target_sp(GetSP()); @@ -1164,6 +1213,7 @@ } SBBreakpoint SBTarget::GetBreakpointAtIndex(uint32_t idx) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(lldb::SBBreakpoint, SBTarget, GetBreakpointAtIndex, (uint32_t), idx); @@ -1177,6 +1227,7 @@ } bool SBTarget::BreakpointDelete(break_id_t bp_id) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBTarget, BreakpointDelete, (lldb::break_id_t), bp_id); @@ -1191,6 +1242,7 @@ } SBBreakpoint SBTarget::FindBreakpointByID(break_id_t bp_id) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, FindBreakpointByID, (lldb::break_id_t), bp_id); @@ -1206,6 +1258,7 @@ bool SBTarget::FindBreakpointsByName(const char *name, SBBreakpointList &bkpts) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBTarget, FindBreakpointsByName, (const char *, lldb::SBBreakpointList &), name, bkpts); @@ -1228,6 +1281,7 @@ } void SBTarget::GetBreakpointNames(SBStringList &names) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBTarget, GetBreakpointNames, (lldb::SBStringList &), names); @@ -1245,6 +1299,7 @@ } void SBTarget::DeleteBreakpointName(const char *name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBTarget, DeleteBreakpointName, (const char *), name); @@ -1256,6 +1311,7 @@ } bool SBTarget::EnableAllBreakpoints() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, EnableAllBreakpoints); TargetSP target_sp(GetSP()); @@ -1268,6 +1324,7 @@ } bool SBTarget::DisableAllBreakpoints() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DisableAllBreakpoints); TargetSP target_sp(GetSP()); @@ -1280,6 +1337,7 @@ } bool SBTarget::DeleteAllBreakpoints() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DeleteAllBreakpoints); TargetSP target_sp(GetSP()); @@ -1293,6 +1351,7 @@ lldb::SBError SBTarget::BreakpointsCreateFromFile(SBFileSpec &source_file, SBBreakpointList &new_bps) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBTarget, BreakpointsCreateFromFile, (lldb::SBFileSpec &, lldb::SBBreakpointList &), source_file, new_bps); @@ -1304,6 +1363,7 @@ lldb::SBError SBTarget::BreakpointsCreateFromFile(SBFileSpec &source_file, SBStringList &matching_names, SBBreakpointList &new_bps) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD( lldb::SBError, SBTarget, BreakpointsCreateFromFile, (lldb::SBFileSpec &, lldb::SBStringList &, lldb::SBBreakpointList &), @@ -1339,6 +1399,7 @@ } lldb::SBError SBTarget::BreakpointsWriteToFile(SBFileSpec &dest_file) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile, (lldb::SBFileSpec &), dest_file); @@ -1355,6 +1416,7 @@ lldb::SBError SBTarget::BreakpointsWriteToFile(SBFileSpec &dest_file, SBBreakpointList &bkpt_list, bool append) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile, (lldb::SBFileSpec &, lldb::SBBreakpointList &, bool), dest_file, bkpt_list, append); @@ -1375,6 +1437,7 @@ } uint32_t SBTarget::GetNumWatchpoints() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumWatchpoints); TargetSP target_sp(GetSP()); @@ -1386,6 +1449,7 @@ } SBWatchpoint SBTarget::GetWatchpointAtIndex(uint32_t idx) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(lldb::SBWatchpoint, SBTarget, GetWatchpointAtIndex, (uint32_t), idx); @@ -1399,10 +1463,10 @@ } bool SBTarget::DeleteWatchpoint(watch_id_t wp_id) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBTarget, DeleteWatchpoint, (lldb::watch_id_t), wp_id); - bool result = false; TargetSP target_sp(GetSP()); if (target_sp) { @@ -1416,10 +1480,10 @@ } SBWatchpoint SBTarget::FindWatchpointByID(lldb::watch_id_t wp_id) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBTarget, FindWatchpointByID, (lldb::watch_id_t), wp_id); - SBWatchpoint sb_watchpoint; lldb::WatchpointSP watchpoint_sp; TargetSP target_sp(GetSP()); @@ -1437,6 +1501,7 @@ lldb::SBWatchpoint SBTarget::WatchAddress(lldb::addr_t addr, size_t size, bool read, bool write, SBError &error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBTarget, WatchAddress, (lldb::addr_t, size_t, bool, bool, lldb::SBError &), addr, size, read, write, error); @@ -1472,6 +1537,7 @@ } bool SBTarget::EnableAllWatchpoints() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, EnableAllWatchpoints); TargetSP target_sp(GetSP()); @@ -1486,6 +1552,7 @@ } bool SBTarget::DisableAllWatchpoints() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DisableAllWatchpoints); TargetSP target_sp(GetSP()); @@ -1501,6 +1568,7 @@ SBValue SBTarget::CreateValueFromAddress(const char *name, SBAddress addr, SBType type) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, CreateValueFromAddress, (const char *, lldb::SBAddress, lldb::SBType), name, addr, type); @@ -1521,6 +1589,7 @@ lldb::SBValue SBTarget::CreateValueFromData(const char *name, lldb::SBData data, lldb::SBType type) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, CreateValueFromData, (const char *, lldb::SBData, lldb::SBType), name, data, type); @@ -1541,6 +1610,7 @@ lldb::SBValue SBTarget::CreateValueFromExpression(const char *name, const char *expr) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, CreateValueFromExpression, (const char *, const char *), name, expr); @@ -1557,6 +1627,7 @@ } bool SBTarget::DeleteAllWatchpoints() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DeleteAllWatchpoints); TargetSP target_sp(GetSP()); @@ -1572,6 +1643,7 @@ void SBTarget::AppendImageSearchPath(const char *from, const char *to, lldb::SBError &error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBTarget, AppendImageSearchPath, (const char *, const char *, lldb::SBError &), from, to, error); @@ -1591,6 +1663,7 @@ lldb::SBModule SBTarget::AddModule(const char *path, const char *triple, const char *uuid_cstr) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule, (const char *, const char *, const char *), path, triple, uuid_cstr); @@ -1600,6 +1673,7 @@ lldb::SBModule SBTarget::AddModule(const char *path, const char *triple, const char *uuid_cstr, const char *symfile) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule, (const char *, const char *, const char *, const char *), path, triple, uuid_cstr, symfile); @@ -1629,6 +1703,7 @@ } lldb::SBModule SBTarget::AddModule(const SBModuleSpec &module_spec) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule, (const lldb::SBModuleSpec &), module_spec); @@ -1641,6 +1716,7 @@ } bool SBTarget::AddModule(lldb::SBModule &module) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBTarget, AddModule, (lldb::SBModule &), module); TargetSP target_sp(GetSP()); @@ -1652,6 +1728,7 @@ } uint32_t SBTarget::GetNumModules() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumModules); uint32_t num = 0; @@ -1665,12 +1742,14 @@ } void SBTarget::Clear() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBTarget, Clear); m_opaque_sp.reset(); } SBModule SBTarget::FindModule(const SBFileSpec &sb_file_spec) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, FindModule, (const lldb::SBFileSpec &), sb_file_spec); @@ -1685,6 +1764,7 @@ } SBSymbolContextList SBTarget::FindCompileUnits(const SBFileSpec &sb_file_spec) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindCompileUnits, (const lldb::SBFileSpec &), sb_file_spec); @@ -1696,6 +1776,7 @@ } lldb::ByteOrder SBTarget::GetByteOrder() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::ByteOrder, SBTarget, GetByteOrder); TargetSP target_sp(GetSP()); @@ -1705,6 +1786,7 @@ } const char *SBTarget::GetTriple() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTarget, GetTriple); TargetSP target_sp(GetSP()); @@ -1720,6 +1802,7 @@ } uint32_t SBTarget::GetDataByteSize() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTarget, GetDataByteSize); TargetSP target_sp(GetSP()); @@ -1730,6 +1813,7 @@ } uint32_t SBTarget::GetCodeByteSize() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTarget, GetCodeByteSize); TargetSP target_sp(GetSP()); @@ -1740,7 +1824,9 @@ } uint32_t SBTarget::GetMaximumNumberOfChildrenToDisplay() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetMaximumNumberOfChildrenToDisplay); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, + GetMaximumNumberOfChildrenToDisplay); TargetSP target_sp(GetSP()); if(target_sp){ @@ -1750,6 +1836,7 @@ } uint32_t SBTarget::GetAddressByteSize() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTarget, GetAddressByteSize); TargetSP target_sp(GetSP()); @@ -1759,6 +1846,7 @@ } SBModule SBTarget::GetModuleAtIndex(uint32_t idx) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, GetModuleAtIndex, (uint32_t), idx); @@ -1775,6 +1863,7 @@ } bool SBTarget::RemoveModule(lldb::SBModule module) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBTarget, RemoveModule, (lldb::SBModule), module); TargetSP target_sp(GetSP()); @@ -1784,10 +1873,10 @@ } SBBroadcaster SBTarget::GetBroadcaster() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBTarget, GetBroadcaster); - TargetSP target_sp(GetSP()); SBBroadcaster broadcaster(target_sp.get(), false); @@ -1796,6 +1885,7 @@ bool SBTarget::GetDescription(SBStream &description, lldb::DescriptionLevel description_level) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBTarget, GetDescription, (lldb::SBStream &, lldb::DescriptionLevel), description, description_level); @@ -1813,6 +1903,7 @@ lldb::SBSymbolContextList SBTarget::FindFunctions(const char *name, uint32_t name_type_mask) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindFunctions, (const char *, uint32_t), name, name_type_mask); @@ -1837,6 +1928,7 @@ lldb::SBSymbolContextList SBTarget::FindGlobalFunctions(const char *name, uint32_t max_matches, MatchType matchtype) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindGlobalFunctions, (const char *, uint32_t, lldb::MatchType), name, max_matches, matchtype); @@ -1873,6 +1965,7 @@ } lldb::SBType SBTarget::FindFirstType(const char *typename_cstr) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBType, SBTarget, FindFirstType, (const char *), typename_cstr); @@ -1915,6 +2008,7 @@ } SBType SBTarget::GetBasicType(lldb::BasicType type) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBType, SBTarget, GetBasicType, (lldb::BasicType), type); @@ -1928,6 +2022,7 @@ } lldb::SBTypeList SBTarget::FindTypes(const char *typename_cstr) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBTypeList, SBTarget, FindTypes, (const char *), typename_cstr); @@ -1973,6 +2068,7 @@ SBValueList SBTarget::FindGlobalVariables(const char *name, uint32_t max_matches) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables, (const char *, uint32_t), name, max_matches); @@ -2002,6 +2098,7 @@ SBValueList SBTarget::FindGlobalVariables(const char *name, uint32_t max_matches, MatchType matchtype) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables, (const char *, uint32_t, lldb::MatchType), name, max_matches, matchtype); @@ -2046,6 +2143,7 @@ } lldb::SBValue SBTarget::FindFirstGlobalVariable(const char *name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, FindFirstGlobalVariable, (const char *), name); @@ -2056,6 +2154,7 @@ } SBSourceManager SBTarget::GetSourceManager() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSourceManager, SBTarget, GetSourceManager); SBSourceManager source_manager(*this); @@ -2064,6 +2163,7 @@ lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr, uint32_t count) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions, (lldb::SBAddress, uint32_t), base_addr, count); @@ -2073,6 +2173,7 @@ lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr, uint32_t count, const char *flavor_string) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions, (lldb::SBAddress, uint32_t, const char *), base_addr, count, flavor_string); @@ -2105,6 +2206,7 @@ lldb::SBInstructionList SBTarget::GetInstructions(lldb::SBAddress base_addr, const void *buf, size_t size) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, GetInstructions, (lldb::SBAddress, const void *, size_t), base_addr, buf, size); @@ -2116,6 +2218,7 @@ SBTarget::GetInstructionsWithFlavor(lldb::SBAddress base_addr, const char *flavor_string, const void *buf, size_t size) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, GetInstructionsWithFlavor, (lldb::SBAddress, const char *, const void *, size_t), @@ -2143,6 +2246,7 @@ lldb::SBInstructionList SBTarget::GetInstructions(lldb::addr_t base_addr, const void *buf, size_t size) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, GetInstructions, (lldb::addr_t, const void *, size_t), base_addr, buf, size); @@ -2155,6 +2259,7 @@ SBTarget::GetInstructionsWithFlavor(lldb::addr_t base_addr, const char *flavor_string, const void *buf, size_t size) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, GetInstructionsWithFlavor, (lldb::addr_t, const char *, const void *, size_t), @@ -2166,6 +2271,7 @@ SBError SBTarget::SetSectionLoadAddress(lldb::SBSection section, lldb::addr_t section_base_addr) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBTarget, SetSectionLoadAddress, (lldb::SBSection, lldb::addr_t), section, section_base_addr); @@ -2204,6 +2310,7 @@ } SBError SBTarget::ClearSectionLoadAddress(lldb::SBSection section) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBTarget, ClearSectionLoadAddress, (lldb::SBSection), section); @@ -2240,6 +2347,7 @@ SBError SBTarget::SetModuleLoadAddress(lldb::SBModule module, int64_t slide_offset) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBTarget, SetModuleLoadAddress, (lldb::SBModule, int64_t), module, slide_offset); @@ -2274,6 +2382,7 @@ } SBError SBTarget::ClearModuleLoadAddress(lldb::SBModule module) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBTarget, ClearModuleLoadAddress, (lldb::SBModule), module); @@ -2327,6 +2436,7 @@ lldb::SBSymbolContextList SBTarget::FindSymbols(const char *name, lldb::SymbolType symbol_type) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindSymbols, (const char *, lldb::SymbolType), name, symbol_type); @@ -2341,6 +2451,7 @@ } lldb::SBValue SBTarget::EvaluateExpression(const char *expr) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, EvaluateExpression, (const char *), expr); @@ -2358,6 +2469,7 @@ lldb::SBValue SBTarget::EvaluateExpression(const char *expr, const SBExpressionOptions &options) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, EvaluateExpression, (const char *, const lldb::SBExpressionOptions &), expr, options); @@ -2393,6 +2505,7 @@ } lldb::addr_t SBTarget::GetStackRedZoneSize() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBTarget, GetStackRedZoneSize); TargetSP target_sp(GetSP()); @@ -2410,6 +2523,7 @@ } bool SBTarget::IsLoaded(const SBModule &module) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(bool, SBTarget, IsLoaded, (const lldb::SBModule &), module); @@ -2425,6 +2539,7 @@ } lldb::SBLaunchInfo SBTarget::GetLaunchInfo() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBLaunchInfo, SBTarget, GetLaunchInfo); lldb::SBLaunchInfo launch_info(nullptr); @@ -2435,6 +2550,7 @@ } void SBTarget::SetLaunchInfo(const lldb::SBLaunchInfo &launch_info) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBTarget, SetLaunchInfo, (const lldb::SBLaunchInfo &), launch_info); @@ -2444,6 +2560,7 @@ } SBEnvironment SBTarget::GetEnvironment() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBEnvironment, SBTarget, GetEnvironment); TargetSP target_sp(GetSP()); @@ -2455,6 +2572,7 @@ } lldb::SBTrace SBTarget::GetTrace() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTrace, SBTarget, GetTrace); TargetSP target_sp(GetSP()); @@ -2465,6 +2583,7 @@ } lldb::SBTrace SBTarget::CreateTrace(lldb::SBError &error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBTrace, SBTarget, CreateTrace, (lldb::SBError &), error); TargetSP target_sp(GetSP()); Index: lldb/source/API/SBThread.cpp =================================================================== --- lldb/source/API/SBThread.cpp +++ lldb/source/API/SBThread.cpp @@ -76,8 +76,9 @@ // Assignment operator const lldb::SBThread &SBThread::operator=(const SBThread &rhs) { - LLDB_RECORD_METHOD(const lldb::SBThread &, - SBThread, operator=,(const lldb::SBThread &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBThread &, SBThread, operator=, + (const lldb::SBThread &), rhs); if (this != &rhs) m_opaque_sp = clone(rhs.m_opaque_sp); @@ -88,6 +89,7 @@ SBThread::~SBThread() = default; lldb::SBQueue SBThread::GetQueue() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBQueue, SBThread, GetQueue); SBQueue sb_queue; @@ -109,10 +111,12 @@ } bool SBThread::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThread, IsValid); return this->operator bool(); } SBThread::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThread, operator bool); std::unique_lock lock; @@ -130,12 +134,14 @@ } void SBThread::Clear() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBThread, Clear); m_opaque_sp->Clear(); } StopReason SBThread::GetStopReason() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::StopReason, SBThread, GetStopReason); StopReason reason = eStopReasonInvalid; @@ -153,6 +159,7 @@ } size_t SBThread::GetStopReasonDataCount() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(size_t, SBThread, GetStopReasonDataCount); std::unique_lock lock; @@ -210,6 +217,7 @@ } uint64_t SBThread::GetStopReasonDataAtIndex(uint32_t idx) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(uint64_t, SBThread, GetStopReasonDataAtIndex, (uint32_t), idx); @@ -280,6 +288,7 @@ } bool SBThread::GetStopReasonExtendedInfoAsJSON(lldb::SBStream &stream) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBThread, GetStopReasonExtendedInfoAsJSON, (lldb::SBStream &), stream); @@ -303,6 +312,7 @@ SBThreadCollection SBThread::GetStopReasonExtendedBacktraces(InstrumentationRuntimeType type) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBThreadCollection, SBThread, GetStopReasonExtendedBacktraces, (lldb::InstrumentationRuntimeType), type); @@ -328,6 +338,7 @@ } size_t SBThread::GetStopDescription(char *dst, size_t dst_len) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(size_t, SBThread, GetStopDescription, (char *, size_t), dst, "", dst_len); @@ -357,6 +368,7 @@ } SBValue SBThread::GetStopReturnValue() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBThread, GetStopReturnValue); ValueObjectSP return_valobj_sp; @@ -381,6 +393,7 @@ } lldb::tid_t SBThread::GetThreadID() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::tid_t, SBThread, GetThreadID); ThreadSP thread_sp(m_opaque_sp->GetThreadSP()); @@ -390,6 +403,7 @@ } uint32_t SBThread::GetIndexID() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBThread, GetIndexID); ThreadSP thread_sp(m_opaque_sp->GetThreadSP()); @@ -399,6 +413,7 @@ } const char *SBThread::GetName() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBThread, GetName); const char *name = nullptr; @@ -416,6 +431,7 @@ } const char *SBThread::GetQueueName() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBThread, GetQueueName); const char *name = nullptr; @@ -433,6 +449,7 @@ } lldb::queue_id_t SBThread::GetQueueID() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::queue_id_t, SBThread, GetQueueID); queue_id_t id = LLDB_INVALID_QUEUE_ID; @@ -450,6 +467,7 @@ } bool SBThread::GetInfoItemByPathAsString(const char *path, SBStream &strm) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBThread, GetInfoItemByPathAsString, (const char *, lldb::SBStream &), path, strm); @@ -532,6 +550,7 @@ } void SBThread::StepOver(lldb::RunMode stop_other_threads) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBThread, StepOver, (lldb::RunMode), stop_other_threads); @@ -540,6 +559,7 @@ } void SBThread::StepOver(lldb::RunMode stop_other_threads, SBError &error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBThread, StepOver, (lldb::RunMode, lldb::SBError &), stop_other_threads, error); @@ -573,6 +593,7 @@ } void SBThread::StepInto(lldb::RunMode stop_other_threads) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBThread, StepInto, (lldb::RunMode), stop_other_threads); @@ -581,6 +602,7 @@ void SBThread::StepInto(const char *target_name, lldb::RunMode stop_other_threads) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBThread, StepInto, (const char *, lldb::RunMode), target_name, stop_other_threads); @@ -590,11 +612,11 @@ void SBThread::StepInto(const char *target_name, uint32_t end_line, SBError &error, lldb::RunMode stop_other_threads) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBThread, StepInto, (const char *, uint32_t, lldb::SBError &, lldb::RunMode), target_name, end_line, error, stop_other_threads); - std::unique_lock lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -640,6 +662,7 @@ } void SBThread::StepOut() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBThread, StepOut); SBError error; // Ignored @@ -647,6 +670,7 @@ } void SBThread::StepOut(SBError &error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBThread, StepOut, (lldb::SBError &), error); std::unique_lock lock; @@ -675,6 +699,7 @@ } void SBThread::StepOutOfFrame(SBFrame &sb_frame) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBThread, StepOutOfFrame, (lldb::SBFrame &), sb_frame); @@ -683,10 +708,10 @@ } void SBThread::StepOutOfFrame(SBFrame &sb_frame, SBError &error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBThread, StepOutOfFrame, (lldb::SBFrame &, lldb::SBError &), sb_frame, error); - std::unique_lock lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -722,6 +747,7 @@ } void SBThread::StepInstruction(bool step_over) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBThread, StepInstruction, (bool), step_over); SBError error; // Ignored @@ -729,6 +755,7 @@ } void SBThread::StepInstruction(bool step_over, SBError &error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBThread, StepInstruction, (bool, lldb::SBError &), step_over, error); @@ -752,6 +779,7 @@ } void SBThread::RunToAddress(lldb::addr_t addr) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBThread, RunToAddress, (lldb::addr_t), addr); SBError error; // Ignored @@ -759,6 +787,7 @@ } void SBThread::RunToAddress(lldb::addr_t addr, SBError &error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBThread, RunToAddress, (lldb::addr_t, lldb::SBError &), addr, error); @@ -789,6 +818,7 @@ SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame, lldb::SBFileSpec &sb_file_spec, uint32_t line) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBThread, StepOverUntil, (lldb::SBFrame &, lldb::SBFileSpec &, uint32_t), sb_frame, sb_file_spec, line); @@ -908,6 +938,7 @@ } SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan, (const char *), script_class_name); @@ -916,6 +947,7 @@ SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name, bool resume_immediately) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan, (const char *, bool), script_class_name, resume_immediately); @@ -928,6 +960,7 @@ SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name, SBStructuredData &args_data, bool resume_immediately) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan, (const char *, lldb::SBStructuredData &, bool), script_class_name, args_data, resume_immediately); @@ -966,6 +999,7 @@ } SBError SBThread::JumpToLine(lldb::SBFileSpec &file_spec, uint32_t line) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBThread, JumpToLine, (lldb::SBFileSpec &, uint32_t), file_spec, line); @@ -987,6 +1021,7 @@ } SBError SBThread::ReturnFromFrame(SBFrame &frame, SBValue &return_value) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBError, SBThread, ReturnFromFrame, (lldb::SBFrame &, lldb::SBValue &), frame, return_value); @@ -1005,6 +1040,7 @@ } SBError SBThread::UnwindInnermostExpression() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBThread, UnwindInnermostExpression); @@ -1024,6 +1060,7 @@ } bool SBThread::Suspend() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, Suspend); SBError error; // Ignored @@ -1031,6 +1068,7 @@ } bool SBThread::Suspend(SBError &error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBThread, Suspend, (lldb::SBError &), error); std::unique_lock lock; @@ -1051,6 +1089,7 @@ } bool SBThread::Resume() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, Resume); SBError error; // Ignored @@ -1058,6 +1097,7 @@ } bool SBThread::Resume(SBError &error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBThread, Resume, (lldb::SBError &), error); std::unique_lock lock; @@ -1079,6 +1119,7 @@ } bool SBThread::IsSuspended() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, IsSuspended); std::unique_lock lock; @@ -1090,6 +1131,7 @@ } bool SBThread::IsStopped() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, IsStopped); std::unique_lock lock; @@ -1101,6 +1143,7 @@ } SBProcess SBThread::GetProcess() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBThread, GetProcess); SBProcess sb_process; @@ -1117,6 +1160,7 @@ } uint32_t SBThread::GetNumFrames() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBThread, GetNumFrames); uint32_t num_frames = 0; @@ -1134,6 +1178,7 @@ } SBFrame SBThread::GetFrameAtIndex(uint32_t idx) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBFrame, SBThread, GetFrameAtIndex, (uint32_t), idx); SBFrame sb_frame; @@ -1153,6 +1198,7 @@ } lldb::SBFrame SBThread::GetSelectedFrame() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFrame, SBThread, GetSelectedFrame); SBFrame sb_frame; @@ -1172,6 +1218,7 @@ } lldb::SBFrame SBThread::SetSelectedFrame(uint32_t idx) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBFrame, SBThread, SetSelectedFrame, (uint32_t), idx); @@ -1217,7 +1264,8 @@ } bool SBThread::operator==(const SBThread &rhs) const { - LLDB_RECORD_METHOD_CONST(bool, SBThread, operator==,(const lldb::SBThread &), + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD_CONST(bool, SBThread, operator==, (const lldb::SBThread &), rhs); return m_opaque_sp->GetThreadSP().get() == @@ -1225,7 +1273,8 @@ } bool SBThread::operator!=(const SBThread &rhs) const { - LLDB_RECORD_METHOD_CONST(bool, SBThread, operator!=,(const lldb::SBThread &), + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD_CONST(bool, SBThread, operator!=, (const lldb::SBThread &), rhs); return m_opaque_sp->GetThreadSP().get() != @@ -1233,6 +1282,7 @@ } bool SBThread::GetStatus(SBStream &status) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(bool, SBThread, GetStatus, (lldb::SBStream &), status); @@ -1250,6 +1300,7 @@ } bool SBThread::GetDescription(SBStream &description) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(bool, SBThread, GetDescription, (lldb::SBStream &), description); @@ -1257,6 +1308,7 @@ } bool SBThread::GetDescription(SBStream &description, bool stop_format) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(bool, SBThread, GetDescription, (lldb::SBStream &, bool), description, stop_format); @@ -1278,6 +1330,7 @@ } SBThread SBThread::GetExtendedBacktraceThread(const char *type) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBThread, SBThread, GetExtendedBacktraceThread, (const char *), type); @@ -1313,6 +1366,7 @@ } uint32_t SBThread::GetExtendedBacktraceOriginatingIndexID() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBThread, GetExtendedBacktraceOriginatingIndexID); @@ -1323,6 +1377,7 @@ } SBValue SBThread::GetCurrentException() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBThread, GetCurrentException); ThreadSP thread_sp(m_opaque_sp->GetThreadSP()); @@ -1333,6 +1388,7 @@ } SBThread SBThread::GetCurrentExceptionBacktrace() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBThread, SBThread, GetCurrentExceptionBacktrace); @@ -1344,6 +1400,7 @@ } bool SBThread::SafeToCallFunctions() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, SafeToCallFunctions); ThreadSP thread_sp(m_opaque_sp->GetThreadSP()); Index: lldb/source/API/SBThreadCollection.cpp =================================================================== --- lldb/source/API/SBThreadCollection.cpp +++ lldb/source/API/SBThreadCollection.cpp @@ -26,9 +26,10 @@ const SBThreadCollection &SBThreadCollection:: operator=(const SBThreadCollection &rhs) { - LLDB_RECORD_METHOD( - const lldb::SBThreadCollection &, - SBThreadCollection, operator=,(const lldb::SBThreadCollection &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBThreadCollection &, + SBThreadCollection, operator=, + (const lldb::SBThreadCollection &), rhs); if (this != &rhs) m_opaque_sp = rhs.m_opaque_sp; @@ -61,16 +62,19 @@ } bool SBThreadCollection::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadCollection, IsValid); return this->operator bool(); } SBThreadCollection::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadCollection, operator bool); return m_opaque_sp.get() != nullptr; } size_t SBThreadCollection::GetSize() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(size_t, SBThreadCollection, GetSize); if (m_opaque_sp) @@ -79,6 +83,7 @@ } SBThread SBThreadCollection::GetThreadAtIndex(size_t idx) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBThread, SBThreadCollection, GetThreadAtIndex, (size_t), idx); Index: lldb/source/API/SBThreadPlan.cpp =================================================================== --- lldb/source/API/SBThreadPlan.cpp +++ lldb/source/API/SBThreadPlan.cpp @@ -88,8 +88,9 @@ // Assignment operator const lldb::SBThreadPlan &SBThreadPlan::operator=(const SBThreadPlan &rhs) { - LLDB_RECORD_METHOD(const lldb::SBThreadPlan &, - SBThreadPlan, operator=,(const lldb::SBThreadPlan &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBThreadPlan &, SBThreadPlan, operator=, + (const lldb::SBThreadPlan &), rhs); if (this != &rhs) m_opaque_wp = rhs.m_opaque_wp; @@ -99,34 +100,40 @@ SBThreadPlan::~SBThreadPlan() = default; bool SBThreadPlan::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadPlan, IsValid); return this->operator bool(); } SBThreadPlan::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadPlan, operator bool); return static_cast(GetSP()); } void SBThreadPlan::Clear() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBThreadPlan, Clear); m_opaque_wp.reset(); } lldb::StopReason SBThreadPlan::GetStopReason() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::StopReason, SBThreadPlan, GetStopReason); return eStopReasonNone; } size_t SBThreadPlan::GetStopReasonDataCount() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(size_t, SBThreadPlan, GetStopReasonDataCount); return 0; } uint64_t SBThreadPlan::GetStopReasonDataAtIndex(uint32_t idx) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(uint64_t, SBThreadPlan, GetStopReasonDataAtIndex, (uint32_t), idx); @@ -134,6 +141,7 @@ } SBThread SBThreadPlan::GetThread() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBThreadPlan, GetThread); ThreadPlanSP thread_plan_sp(GetSP()); @@ -144,6 +152,7 @@ } bool SBThreadPlan::GetDescription(lldb::SBStream &description) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(bool, SBThreadPlan, GetDescription, (lldb::SBStream &), description); @@ -161,6 +170,7 @@ } void SBThreadPlan::SetPlanComplete(bool success) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBThreadPlan, SetPlanComplete, (bool), success); ThreadPlanSP thread_plan_sp(GetSP()); @@ -169,6 +179,7 @@ } bool SBThreadPlan::IsPlanComplete() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, IsPlanComplete); ThreadPlanSP thread_plan_sp(GetSP()); @@ -178,6 +189,7 @@ } bool SBThreadPlan::IsPlanStale() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, IsPlanStale); ThreadPlanSP thread_plan_sp(GetSP()); @@ -187,6 +199,7 @@ } bool SBThreadPlan::IsValid() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, IsValid); ThreadPlanSP thread_plan_sp(GetSP()); @@ -196,6 +209,7 @@ } bool SBThreadPlan::GetStopOthers() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, GetStopOthers); ThreadPlanSP thread_plan_sp(GetSP()); @@ -205,6 +219,7 @@ } void SBThreadPlan::SetStopOthers(bool stop_others) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBThreadPlan, SetStopOthers, (bool), stop_others); ThreadPlanSP thread_plan_sp(GetSP()); @@ -221,6 +236,7 @@ SBThreadPlan SBThreadPlan::QueueThreadPlanForStepOverRange(SBAddress &sb_start_address, lldb::addr_t size) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan, QueueThreadPlanForStepOverRange, (lldb::SBAddress &, lldb::addr_t), sb_start_address, size); @@ -231,6 +247,7 @@ SBThreadPlan SBThreadPlan::QueueThreadPlanForStepOverRange( SBAddress &sb_start_address, lldb::addr_t size, SBError &error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan, QueueThreadPlanForStepOverRange, (lldb::SBAddress &, lldb::addr_t, lldb::SBError &), @@ -265,6 +282,7 @@ SBThreadPlan SBThreadPlan::QueueThreadPlanForStepInRange(SBAddress &sb_start_address, lldb::addr_t size) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan, QueueThreadPlanForStepInRange, (lldb::SBAddress &, lldb::addr_t), sb_start_address, size); @@ -276,6 +294,7 @@ SBThreadPlan SBThreadPlan::QueueThreadPlanForStepInRange(SBAddress &sb_start_address, lldb::addr_t size, SBError &error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan, QueueThreadPlanForStepInRange, (lldb::SBAddress &, lldb::addr_t, lldb::SBError &), @@ -310,6 +329,7 @@ SBThreadPlan SBThreadPlan::QueueThreadPlanForStepOut(uint32_t frame_idx_to_step_to, bool first_insn) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan, QueueThreadPlanForStepOut, (uint32_t, bool), frame_idx_to_step_to, first_insn); @@ -321,6 +341,7 @@ SBThreadPlan SBThreadPlan::QueueThreadPlanForStepOut(uint32_t frame_idx_to_step_to, bool first_insn, SBError &error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan, QueueThreadPlanForStepOut, (uint32_t, bool, lldb::SBError &), frame_idx_to_step_to, @@ -350,6 +371,7 @@ SBThreadPlan SBThreadPlan::QueueThreadPlanForRunToAddress(SBAddress sb_address) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan, QueueThreadPlanForRunToAddress, (lldb::SBAddress), sb_address); @@ -360,6 +382,7 @@ SBThreadPlan SBThreadPlan::QueueThreadPlanForRunToAddress(SBAddress sb_address, SBError &error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan, QueueThreadPlanForRunToAddress, (lldb::SBAddress, lldb::SBError &), sb_address, error); @@ -387,6 +410,7 @@ SBThreadPlan SBThreadPlan::QueueThreadPlanForStepScripted(const char *script_class_name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan, QueueThreadPlanForStepScripted, (const char *), script_class_name); @@ -398,6 +422,7 @@ SBThreadPlan SBThreadPlan::QueueThreadPlanForStepScripted(const char *script_class_name, SBError &error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan, QueueThreadPlanForStepScripted, (const char *, lldb::SBError &), script_class_name, error); @@ -424,9 +449,10 @@ SBThreadPlan::QueueThreadPlanForStepScripted(const char *script_class_name, lldb::SBStructuredData &args_data, SBError &error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan, QueueThreadPlanForStepScripted, - (const char *, lldb::SBStructuredData &, lldb::SBError &), + (const char *, lldb::SBStructuredData &, lldb::SBError &), script_class_name, args_data, error); ThreadPlanSP thread_plan_sp(GetSP()); Index: lldb/source/API/SBTrace.cpp =================================================================== --- lldb/source/API/SBTrace.cpp +++ lldb/source/API/SBTrace.cpp @@ -27,11 +27,13 @@ } const char *SBTrace::GetStartConfigurationHelp() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTrace, GetStartConfigurationHelp); return m_opaque_sp ? m_opaque_sp->GetStartConfigurationHelp() : nullptr; } SBError SBTrace::Start(const SBStructuredData &configuration) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(SBError, SBTrace, Start, (const SBStructuredData &), configuration); SBError error; @@ -45,6 +47,7 @@ SBError SBTrace::Start(const SBThread &thread, const SBStructuredData &configuration) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(SBError, SBTrace, Start, (const SBThread &, const SBStructuredData &), thread, configuration); @@ -63,6 +66,7 @@ } SBError SBTrace::Stop() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(SBError, SBTrace, Stop); SBError error; if (!m_opaque_sp) @@ -73,6 +77,7 @@ } SBError SBTrace::Stop(const SBThread &thread) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(SBError, SBTrace, Stop, (const SBThread &), thread); SBError error; if (!m_opaque_sp) @@ -83,11 +88,13 @@ } bool SBTrace::IsValid() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBTrace, IsValid); return this->operator bool(); } SBTrace::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTrace, operator bool); return (bool)m_opaque_sp; } Index: lldb/source/API/SBType.cpp =================================================================== --- lldb/source/API/SBType.cpp +++ lldb/source/API/SBType.cpp @@ -51,7 +51,8 @@ //{} // bool SBType::operator==(SBType &rhs) { - LLDB_RECORD_METHOD(bool, SBType, operator==,(lldb::SBType &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(bool, SBType, operator==, (lldb::SBType &), rhs); if (!IsValid()) return !rhs.IsValid(); @@ -63,7 +64,8 @@ } bool SBType::operator!=(SBType &rhs) { - LLDB_RECORD_METHOD(bool, SBType, operator!=,(lldb::SBType &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(bool, SBType, operator!=, (lldb::SBType &), rhs); if (!IsValid()) return rhs.IsValid(); @@ -81,7 +83,8 @@ } SBType &SBType::operator=(const SBType &rhs) { - LLDB_RECORD_METHOD(lldb::SBType &, SBType, operator=,(const lldb::SBType &), + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(lldb::SBType &, SBType, operator=, (const lldb::SBType &), rhs); if (this != &rhs) { @@ -107,10 +110,12 @@ } bool SBType::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBType, IsValid); return this->operator bool(); } SBType::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBType, operator bool); if (m_opaque_sp.get() == nullptr) @@ -120,6 +125,7 @@ } uint64_t SBType::GetByteSize() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBType, GetByteSize); if (IsValid()) @@ -130,6 +136,7 @@ } bool SBType::IsPointerType() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsPointerType); if (!IsValid()) @@ -138,6 +145,7 @@ } bool SBType::IsArrayType() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsArrayType); if (!IsValid()) @@ -147,6 +155,7 @@ } bool SBType::IsVectorType() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsVectorType); if (!IsValid()) @@ -155,6 +164,7 @@ } bool SBType::IsReferenceType() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsReferenceType); if (!IsValid()) @@ -163,6 +173,7 @@ } SBType SBType::GetPointerType() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetPointerType); if (!IsValid()) @@ -172,6 +183,7 @@ } SBType SBType::GetPointeeType() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetPointeeType); if (!IsValid()) @@ -180,6 +192,7 @@ } SBType SBType::GetReferenceType() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetReferenceType); if (!IsValid()) @@ -188,6 +201,7 @@ } SBType SBType::GetTypedefedType() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetTypedefedType); if (!IsValid()) @@ -196,6 +210,7 @@ } SBType SBType::GetDereferencedType() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetDereferencedType); if (!IsValid()) @@ -204,6 +219,7 @@ } SBType SBType::GetArrayElementType() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetArrayElementType); if (!IsValid()) @@ -213,6 +229,7 @@ } SBType SBType::GetArrayType(uint64_t size) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBType, SBType, GetArrayType, (uint64_t), size); if (!IsValid()) @@ -222,6 +239,7 @@ } SBType SBType::GetVectorElementType() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetVectorElementType); SBType type_sb; @@ -235,6 +253,7 @@ } bool SBType::IsFunctionType() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsFunctionType); if (!IsValid()) @@ -243,6 +262,7 @@ } bool SBType::IsPolymorphicClass() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsPolymorphicClass); if (!IsValid()) @@ -251,6 +271,7 @@ } bool SBType::IsTypedefType() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsTypedefType); if (!IsValid()) @@ -259,6 +280,7 @@ } bool SBType::IsAnonymousType() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsAnonymousType); if (!IsValid()) @@ -267,6 +289,7 @@ } bool SBType::IsScopedEnumerationType() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsScopedEnumerationType); if (!IsValid()) @@ -275,6 +298,7 @@ } lldb::SBType SBType::GetFunctionReturnType() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetFunctionReturnType); if (IsValid()) { @@ -287,6 +311,7 @@ } lldb::SBTypeList SBType::GetFunctionArgumentTypes() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeList, SBType, GetFunctionArgumentTypes); @@ -302,6 +327,7 @@ } uint32_t SBType::GetNumberOfMemberFunctions() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfMemberFunctions); if (IsValid()) { @@ -311,6 +337,7 @@ } lldb::SBTypeMemberFunction SBType::GetMemberFunctionAtIndex(uint32_t idx) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBTypeMemberFunction, SBType, GetMemberFunctionAtIndex, (uint32_t), idx); @@ -322,6 +349,7 @@ } lldb::SBType SBType::GetUnqualifiedType() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetUnqualifiedType); if (!IsValid()) @@ -330,6 +358,7 @@ } lldb::SBType SBType::GetCanonicalType() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetCanonicalType); if (IsValid()) @@ -338,6 +367,7 @@ } SBType SBType::GetEnumerationIntegerType() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetEnumerationIntegerType); if (IsValid()) { @@ -348,6 +378,7 @@ } lldb::BasicType SBType::GetBasicType() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::BasicType, SBType, GetBasicType); if (IsValid()) @@ -356,6 +387,7 @@ } SBType SBType::GetBasicType(lldb::BasicType basic_type) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBType, SBType, GetBasicType, (lldb::BasicType), basic_type); @@ -366,6 +398,7 @@ } uint32_t SBType::GetNumberOfDirectBaseClasses() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfDirectBaseClasses); if (IsValid()) @@ -374,6 +407,7 @@ } uint32_t SBType::GetNumberOfVirtualBaseClasses() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfVirtualBaseClasses); if (IsValid()) @@ -382,6 +416,7 @@ } uint32_t SBType::GetNumberOfFields() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfFields); if (IsValid()) @@ -391,6 +426,7 @@ bool SBType::GetDescription(SBStream &description, lldb::DescriptionLevel description_level) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBType, GetDescription, (lldb::SBStream &, lldb::DescriptionLevel), description, description_level); @@ -406,6 +442,7 @@ } SBTypeMember SBType::GetDirectBaseClassAtIndex(uint32_t idx) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBTypeMember, SBType, GetDirectBaseClassAtIndex, (uint32_t), idx); @@ -423,6 +460,7 @@ } SBTypeMember SBType::GetVirtualBaseClassAtIndex(uint32_t idx) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBTypeMember, SBType, GetVirtualBaseClassAtIndex, (uint32_t), idx); @@ -440,6 +478,7 @@ } SBTypeEnumMemberList SBType::GetEnumMembers() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeEnumMemberList, SBType, GetEnumMembers); @@ -463,6 +502,7 @@ } SBTypeMember SBType::GetFieldAtIndex(uint32_t idx) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBTypeMember, SBType, GetFieldAtIndex, (uint32_t), idx); @@ -490,6 +530,7 @@ } bool SBType::IsTypeComplete() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsTypeComplete); if (!IsValid()) @@ -498,6 +539,7 @@ } uint32_t SBType::GetTypeFlags() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetTypeFlags); if (!IsValid()) @@ -506,6 +548,7 @@ } lldb::SBModule SBType::GetModule() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBModule, SBType, GetModule); lldb::SBModule sb_module; @@ -517,6 +560,7 @@ } const char *SBType::GetName() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBType, GetName); if (!IsValid()) @@ -525,6 +569,7 @@ } const char *SBType::GetDisplayTypeName() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBType, GetDisplayTypeName); if (!IsValid()) @@ -533,6 +578,7 @@ } lldb::TypeClass SBType::GetTypeClass() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::TypeClass, SBType, GetTypeClass); if (IsValid()) @@ -541,6 +587,7 @@ } uint32_t SBType::GetNumberOfTemplateArguments() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfTemplateArguments); if (IsValid()) @@ -549,6 +596,7 @@ } lldb::SBType SBType::GetTemplateArgumentType(uint32_t idx) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBType, SBType, GetTemplateArgumentType, (uint32_t), idx); @@ -574,6 +622,7 @@ } lldb::TemplateArgumentKind SBType::GetTemplateArgumentKind(uint32_t idx) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::TemplateArgumentKind, SBType, GetTemplateArgumentKind, (uint32_t), idx); @@ -596,18 +645,21 @@ } bool SBTypeList::IsValid() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeList, IsValid); return this->operator bool(); } SBTypeList::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeList, operator bool); return (m_opaque_up != nullptr); } SBTypeList &SBTypeList::operator=(const SBTypeList &rhs) { - LLDB_RECORD_METHOD(lldb::SBTypeList &, - SBTypeList, operator=,(const lldb::SBTypeList &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(lldb::SBTypeList &, SBTypeList, operator=, + (const lldb::SBTypeList &), rhs); if (this != &rhs) { m_opaque_up = std::make_unique(); @@ -619,6 +671,7 @@ } void SBTypeList::Append(SBType type) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBTypeList, Append, (lldb::SBType), type); if (type.IsValid()) @@ -626,6 +679,7 @@ } SBType SBTypeList::GetTypeAtIndex(uint32_t index) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBType, SBTypeList, GetTypeAtIndex, (uint32_t), index); @@ -635,6 +689,7 @@ } uint32_t SBTypeList::GetSize() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeList, GetSize); return m_opaque_up->GetSize(); @@ -656,8 +711,9 @@ } lldb::SBTypeMember &SBTypeMember::operator=(const lldb::SBTypeMember &rhs) { - LLDB_RECORD_METHOD(lldb::SBTypeMember &, - SBTypeMember, operator=,(const lldb::SBTypeMember &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(lldb::SBTypeMember &, SBTypeMember, operator=, + (const lldb::SBTypeMember &), rhs); if (this != &rhs) { if (rhs.IsValid()) @@ -667,16 +723,19 @@ } bool SBTypeMember::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMember, IsValid); return this->operator bool(); } SBTypeMember::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMember, operator bool); return m_opaque_up.get(); } const char *SBTypeMember::GetName() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMember, GetName); if (m_opaque_up) @@ -685,6 +744,7 @@ } SBType SBTypeMember::GetType() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeMember, GetType); SBType sb_type; @@ -695,6 +755,7 @@ } uint64_t SBTypeMember::GetOffsetInBytes() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBTypeMember, GetOffsetInBytes); if (m_opaque_up) @@ -703,6 +764,7 @@ } uint64_t SBTypeMember::GetOffsetInBits() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBTypeMember, GetOffsetInBits); if (m_opaque_up) @@ -711,6 +773,7 @@ } bool SBTypeMember::IsBitfield() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeMember, IsBitfield); if (m_opaque_up) @@ -719,6 +782,7 @@ } uint32_t SBTypeMember::GetBitfieldSizeInBits() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeMember, GetBitfieldSizeInBits); if (m_opaque_up) @@ -728,6 +792,7 @@ bool SBTypeMember::GetDescription(lldb::SBStream &description, lldb::DescriptionLevel description_level) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBTypeMember, GetDescription, (lldb::SBStream &, lldb::DescriptionLevel), description, description_level); @@ -785,10 +850,10 @@ lldb::SBTypeMemberFunction &SBTypeMemberFunction:: operator=(const lldb::SBTypeMemberFunction &rhs) { - LLDB_RECORD_METHOD( - lldb::SBTypeMemberFunction &, - SBTypeMemberFunction, operator=,(const lldb::SBTypeMemberFunction &), - rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(lldb::SBTypeMemberFunction &, + SBTypeMemberFunction, operator=, + (const lldb::SBTypeMemberFunction &), rhs); if (this != &rhs) m_opaque_sp = rhs.m_opaque_sp; @@ -796,16 +861,19 @@ } bool SBTypeMemberFunction::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMemberFunction, IsValid); return this->operator bool(); } SBTypeMemberFunction::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMemberFunction, operator bool); return m_opaque_sp.get(); } const char *SBTypeMemberFunction::GetName() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMemberFunction, GetName); if (m_opaque_sp) @@ -814,6 +882,7 @@ } const char *SBTypeMemberFunction::GetDemangledName() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMemberFunction, GetDemangledName); @@ -828,6 +897,7 @@ } const char *SBTypeMemberFunction::GetMangledName() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMemberFunction, GetMangledName); @@ -837,6 +907,7 @@ } SBType SBTypeMemberFunction::GetType() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeMemberFunction, GetType); SBType sb_type; @@ -847,6 +918,7 @@ } lldb::SBType SBTypeMemberFunction::GetReturnType() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeMemberFunction, GetReturnType); SBType sb_type; @@ -857,6 +929,7 @@ } uint32_t SBTypeMemberFunction::GetNumberOfArguments() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeMemberFunction, GetNumberOfArguments); @@ -866,6 +939,7 @@ } lldb::SBType SBTypeMemberFunction::GetArgumentTypeAtIndex(uint32_t i) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBType, SBTypeMemberFunction, GetArgumentTypeAtIndex, (uint32_t), i); @@ -878,6 +952,7 @@ } lldb::MemberFunctionKind SBTypeMemberFunction::GetKind() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::MemberFunctionKind, SBTypeMemberFunction, GetKind); @@ -888,6 +963,7 @@ bool SBTypeMemberFunction::GetDescription( lldb::SBStream &description, lldb::DescriptionLevel description_level) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBTypeMemberFunction, GetDescription, (lldb::SBStream &, lldb::DescriptionLevel), description, description_level); Index: lldb/source/API/SBTypeCategory.cpp =================================================================== --- lldb/source/API/SBTypeCategory.cpp +++ lldb/source/API/SBTypeCategory.cpp @@ -42,16 +42,19 @@ SBTypeCategory::~SBTypeCategory() = default; bool SBTypeCategory::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeCategory, IsValid); return this->operator bool(); } SBTypeCategory::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeCategory, operator bool); return (m_opaque_sp.get() != nullptr); } bool SBTypeCategory::GetEnabled() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeCategory, GetEnabled); if (!IsValid()) @@ -60,6 +63,7 @@ } void SBTypeCategory::SetEnabled(bool enabled) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBTypeCategory, SetEnabled, (bool), enabled); if (!IsValid()) @@ -71,6 +75,7 @@ } const char *SBTypeCategory::GetName() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeCategory, GetName); if (!IsValid()) @@ -79,6 +84,7 @@ } lldb::LanguageType SBTypeCategory::GetLanguageAtIndex(uint32_t idx) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::LanguageType, SBTypeCategory, GetLanguageAtIndex, (uint32_t), idx); @@ -88,6 +94,7 @@ } uint32_t SBTypeCategory::GetNumLanguages() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumLanguages); if (IsValid()) @@ -96,6 +103,7 @@ } void SBTypeCategory::AddLanguage(lldb::LanguageType language) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBTypeCategory, AddLanguage, (lldb::LanguageType), language); @@ -104,6 +112,7 @@ } uint32_t SBTypeCategory::GetNumFormats() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumFormats); if (!IsValid()) @@ -114,6 +123,7 @@ } uint32_t SBTypeCategory::GetNumSummaries() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumSummaries); if (!IsValid()) @@ -123,6 +133,7 @@ } uint32_t SBTypeCategory::GetNumFilters() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumFilters); if (!IsValid()) @@ -132,6 +143,7 @@ } uint32_t SBTypeCategory::GetNumSynthetics() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumSynthetics); if (!IsValid()) @@ -142,6 +154,7 @@ lldb::SBTypeNameSpecifier SBTypeCategory::GetTypeNameSpecifierForFilterAtIndex(uint32_t index) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory, GetTypeNameSpecifierForFilterAtIndex, (uint32_t), index); @@ -153,6 +166,7 @@ lldb::SBTypeNameSpecifier SBTypeCategory::GetTypeNameSpecifierForFormatAtIndex(uint32_t index) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory, GetTypeNameSpecifierForFormatAtIndex, (uint32_t), index); @@ -164,6 +178,7 @@ lldb::SBTypeNameSpecifier SBTypeCategory::GetTypeNameSpecifierForSummaryAtIndex(uint32_t index) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory, GetTypeNameSpecifierForSummaryAtIndex, (uint32_t), index); @@ -175,6 +190,7 @@ lldb::SBTypeNameSpecifier SBTypeCategory::GetTypeNameSpecifierForSyntheticAtIndex(uint32_t index) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory, GetTypeNameSpecifierForSyntheticAtIndex, (uint32_t), index); @@ -186,6 +202,7 @@ } SBTypeFilter SBTypeCategory::GetFilterForType(SBTypeNameSpecifier spec) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterForType, (lldb::SBTypeNameSpecifier), spec); @@ -213,6 +230,7 @@ return lldb::SBTypeFilter(filter_sp); } SBTypeFormat SBTypeCategory::GetFormatForType(SBTypeNameSpecifier spec) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatForType, (lldb::SBTypeNameSpecifier), spec); @@ -238,6 +256,7 @@ } SBTypeSummary SBTypeCategory::GetSummaryForType(SBTypeNameSpecifier spec) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryForType, (lldb::SBTypeNameSpecifier), spec); @@ -263,6 +282,7 @@ } SBTypeSynthetic SBTypeCategory::GetSyntheticForType(SBTypeNameSpecifier spec) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBTypeCategory, GetSyntheticForType, (lldb::SBTypeNameSpecifier), spec); @@ -291,6 +311,7 @@ } SBTypeFilter SBTypeCategory::GetFilterAtIndex(uint32_t index) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterAtIndex, (uint32_t), index); @@ -309,6 +330,7 @@ } SBTypeFormat SBTypeCategory::GetFormatAtIndex(uint32_t index) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatAtIndex, (uint32_t), index); @@ -318,6 +340,7 @@ } SBTypeSummary SBTypeCategory::GetSummaryAtIndex(uint32_t index) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryAtIndex, (uint32_t), index); @@ -327,6 +350,7 @@ } SBTypeSynthetic SBTypeCategory::GetSyntheticAtIndex(uint32_t index) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBTypeCategory, GetSyntheticAtIndex, (uint32_t), index); @@ -346,6 +370,7 @@ bool SBTypeCategory::AddTypeFormat(SBTypeNameSpecifier type_name, SBTypeFormat format) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeFormat, (lldb::SBTypeNameSpecifier, lldb::SBTypeFormat), type_name, format); @@ -370,6 +395,7 @@ } bool SBTypeCategory::DeleteTypeFormat(SBTypeNameSpecifier type_name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeFormat, (lldb::SBTypeNameSpecifier), type_name); @@ -389,6 +415,7 @@ bool SBTypeCategory::AddTypeSummary(SBTypeNameSpecifier type_name, SBTypeSummary summary) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeSummary, (lldb::SBTypeNameSpecifier, lldb::SBTypeSummary), type_name, summary); @@ -447,6 +474,7 @@ } bool SBTypeCategory::DeleteTypeSummary(SBTypeNameSpecifier type_name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeSummary, (lldb::SBTypeNameSpecifier), type_name); @@ -466,6 +494,7 @@ bool SBTypeCategory::AddTypeFilter(SBTypeNameSpecifier type_name, SBTypeFilter filter) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeFilter, (lldb::SBTypeNameSpecifier, lldb::SBTypeFilter), type_name, filter); @@ -490,6 +519,7 @@ } bool SBTypeCategory::DeleteTypeFilter(SBTypeNameSpecifier type_name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeFilter, (lldb::SBTypeNameSpecifier), type_name); @@ -509,6 +539,7 @@ bool SBTypeCategory::AddTypeSynthetic(SBTypeNameSpecifier type_name, SBTypeSynthetic synth) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeSynthetic, (lldb::SBTypeNameSpecifier, lldb::SBTypeSynthetic), type_name, synth); @@ -567,6 +598,7 @@ } bool SBTypeCategory::DeleteTypeSynthetic(SBTypeNameSpecifier type_name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeSynthetic, (lldb::SBTypeNameSpecifier), type_name); @@ -586,6 +618,7 @@ bool SBTypeCategory::GetDescription(lldb::SBStream &description, lldb::DescriptionLevel description_level) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBTypeCategory, GetDescription, (lldb::SBStream &, lldb::DescriptionLevel), description, description_level); @@ -598,9 +631,9 @@ lldb::SBTypeCategory &SBTypeCategory:: operator=(const lldb::SBTypeCategory &rhs) { - LLDB_RECORD_METHOD(lldb::SBTypeCategory &, - SBTypeCategory, operator=,(const lldb::SBTypeCategory &), - rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(lldb::SBTypeCategory &, SBTypeCategory, operator=, + (const lldb::SBTypeCategory &), rhs); if (this != &rhs) { m_opaque_sp = rhs.m_opaque_sp; @@ -609,7 +642,8 @@ } bool SBTypeCategory::operator==(lldb::SBTypeCategory &rhs) { - LLDB_RECORD_METHOD(bool, SBTypeCategory, operator==,(lldb::SBTypeCategory &), + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(bool, SBTypeCategory, operator==, (lldb::SBTypeCategory &), rhs); if (!IsValid()) @@ -619,7 +653,8 @@ } bool SBTypeCategory::operator!=(lldb::SBTypeCategory &rhs) { - LLDB_RECORD_METHOD(bool, SBTypeCategory, operator!=,(lldb::SBTypeCategory &), + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(bool, SBTypeCategory, operator!=, (lldb::SBTypeCategory &), rhs); if (!IsValid()) Index: lldb/source/API/SBTypeEnumMember.cpp =================================================================== --- lldb/source/API/SBTypeEnumMember.cpp +++ lldb/source/API/SBTypeEnumMember.cpp @@ -39,9 +39,9 @@ } SBTypeEnumMember &SBTypeEnumMember::operator=(const SBTypeEnumMember &rhs) { - LLDB_RECORD_METHOD( - SBTypeEnumMember &, - SBTypeEnumMember, operator=,(const lldb::SBTypeEnumMember &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(SBTypeEnumMember &, SBTypeEnumMember, operator=, + (const lldb::SBTypeEnumMember &), rhs); if (this != &rhs) m_opaque_sp = clone(rhs.m_opaque_sp); @@ -49,16 +49,19 @@ } bool SBTypeEnumMember::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMember, IsValid); return this->operator bool(); } SBTypeEnumMember::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMember, operator bool); return m_opaque_sp.get(); } const char *SBTypeEnumMember::GetName() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeEnumMember, GetName); if (m_opaque_sp.get()) @@ -67,6 +70,7 @@ } int64_t SBTypeEnumMember::GetValueAsSigned() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(int64_t, SBTypeEnumMember, GetValueAsSigned); if (m_opaque_sp.get()) @@ -75,6 +79,7 @@ } uint64_t SBTypeEnumMember::GetValueAsUnsigned() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBTypeEnumMember, GetValueAsUnsigned); if (m_opaque_sp.get()) @@ -83,6 +88,7 @@ } SBType SBTypeEnumMember::GetType() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeEnumMember, GetType); SBType sb_type; @@ -123,10 +129,12 @@ } bool SBTypeEnumMemberList::IsValid() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeEnumMemberList, IsValid); return this->operator bool(); } SBTypeEnumMemberList::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMemberList, operator bool); return (m_opaque_up != nullptr); @@ -134,10 +142,10 @@ SBTypeEnumMemberList &SBTypeEnumMemberList:: operator=(const SBTypeEnumMemberList &rhs) { - LLDB_RECORD_METHOD( - lldb::SBTypeEnumMemberList &, - SBTypeEnumMemberList, operator=,(const lldb::SBTypeEnumMemberList &), - rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(lldb::SBTypeEnumMemberList &, + SBTypeEnumMemberList, operator=, + (const lldb::SBTypeEnumMemberList &), rhs); if (this != &rhs) { m_opaque_up = std::make_unique(); @@ -151,6 +159,7 @@ } void SBTypeEnumMemberList::Append(SBTypeEnumMember enum_member) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBTypeEnumMemberList, Append, (lldb::SBTypeEnumMember), enum_member); @@ -160,6 +169,7 @@ SBTypeEnumMember SBTypeEnumMemberList::GetTypeEnumMemberAtIndex(uint32_t index) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBTypeEnumMember, SBTypeEnumMemberList, GetTypeEnumMemberAtIndex, (uint32_t), index); @@ -169,6 +179,7 @@ } uint32_t SBTypeEnumMemberList::GetSize() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeEnumMemberList, GetSize); return m_opaque_up->GetSize(); @@ -178,6 +189,7 @@ bool SBTypeEnumMember::GetDescription( lldb::SBStream &description, lldb::DescriptionLevel description_level) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBTypeEnumMember, GetDescription, (lldb::SBStream &, lldb::DescriptionLevel), description, description_level); Index: lldb/source/API/SBTypeFilter.cpp =================================================================== --- lldb/source/API/SBTypeFilter.cpp +++ lldb/source/API/SBTypeFilter.cpp @@ -31,16 +31,19 @@ SBTypeFilter::~SBTypeFilter() = default; bool SBTypeFilter::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFilter, IsValid); return this->operator bool(); } SBTypeFilter::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFilter, operator bool); return m_opaque_sp.get() != nullptr; } uint32_t SBTypeFilter::GetOptions() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeFilter, GetOptions); if (IsValid()) @@ -49,6 +52,7 @@ } void SBTypeFilter::SetOptions(uint32_t value) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBTypeFilter, SetOptions, (uint32_t), value); if (CopyOnWrite_Impl()) @@ -57,6 +61,7 @@ bool SBTypeFilter::GetDescription(lldb::SBStream &description, lldb::DescriptionLevel description_level) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBTypeFilter, GetDescription, (lldb::SBStream &, lldb::DescriptionLevel), description, description_level); @@ -70,6 +75,7 @@ } void SBTypeFilter::Clear() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBTypeFilter, Clear); if (CopyOnWrite_Impl()) @@ -77,6 +83,7 @@ } uint32_t SBTypeFilter::GetNumberOfExpressionPaths() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeFilter, GetNumberOfExpressionPaths); @@ -86,6 +93,7 @@ } const char *SBTypeFilter::GetExpressionPathAtIndex(uint32_t i) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(const char *, SBTypeFilter, GetExpressionPathAtIndex, (uint32_t), i); @@ -99,6 +107,7 @@ } bool SBTypeFilter::ReplaceExpressionPathAtIndex(uint32_t i, const char *item) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBTypeFilter, ReplaceExpressionPathAtIndex, (uint32_t, const char *), i, item); @@ -109,6 +118,7 @@ } void SBTypeFilter::AppendExpressionPath(const char *item) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBTypeFilter, AppendExpressionPath, (const char *), item); @@ -117,8 +127,9 @@ } lldb::SBTypeFilter &SBTypeFilter::operator=(const lldb::SBTypeFilter &rhs) { - LLDB_RECORD_METHOD(lldb::SBTypeFilter &, - SBTypeFilter, operator=,(const lldb::SBTypeFilter &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(lldb::SBTypeFilter &, SBTypeFilter, operator=, + (const lldb::SBTypeFilter &), rhs); if (this != &rhs) { m_opaque_sp = rhs.m_opaque_sp; @@ -127,7 +138,8 @@ } bool SBTypeFilter::operator==(lldb::SBTypeFilter &rhs) { - LLDB_RECORD_METHOD(bool, SBTypeFilter, operator==,(lldb::SBTypeFilter &), + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(bool, SBTypeFilter, operator==, (lldb::SBTypeFilter &), rhs); if (!IsValid()) @@ -137,6 +149,7 @@ } bool SBTypeFilter::IsEqualTo(lldb::SBTypeFilter &rhs) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBTypeFilter, IsEqualTo, (lldb::SBTypeFilter &), rhs); @@ -155,7 +168,8 @@ } bool SBTypeFilter::operator!=(lldb::SBTypeFilter &rhs) { - LLDB_RECORD_METHOD(bool, SBTypeFilter, operator!=,(lldb::SBTypeFilter &), + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(bool, SBTypeFilter, operator!=, (lldb::SBTypeFilter &), rhs); if (!IsValid()) Index: lldb/source/API/SBTypeFormat.cpp =================================================================== --- lldb/source/API/SBTypeFormat.cpp +++ lldb/source/API/SBTypeFormat.cpp @@ -40,16 +40,19 @@ SBTypeFormat::~SBTypeFormat() = default; bool SBTypeFormat::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFormat, IsValid); return this->operator bool(); } SBTypeFormat::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFormat, operator bool); return m_opaque_sp.get() != nullptr; } lldb::Format SBTypeFormat::GetFormat() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::Format, SBTypeFormat, GetFormat); if (IsValid() && m_opaque_sp->GetType() == TypeFormatImpl::Type::eTypeFormat) @@ -58,6 +61,7 @@ } const char *SBTypeFormat::GetTypeName() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeFormat, GetTypeName); if (IsValid() && m_opaque_sp->GetType() == TypeFormatImpl::Type::eTypeEnum) @@ -68,6 +72,7 @@ } uint32_t SBTypeFormat::GetOptions() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeFormat, GetOptions); if (IsValid()) @@ -76,6 +81,7 @@ } void SBTypeFormat::SetFormat(lldb::Format fmt) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBTypeFormat, SetFormat, (lldb::Format), fmt); if (CopyOnWrite_Impl(Type::eTypeFormat)) @@ -83,6 +89,7 @@ } void SBTypeFormat::SetTypeName(const char *type) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBTypeFormat, SetTypeName, (const char *), type); if (CopyOnWrite_Impl(Type::eTypeEnum)) @@ -91,6 +98,7 @@ } void SBTypeFormat::SetOptions(uint32_t value) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBTypeFormat, SetOptions, (uint32_t), value); if (CopyOnWrite_Impl(Type::eTypeKeepSame)) @@ -99,6 +107,7 @@ bool SBTypeFormat::GetDescription(lldb::SBStream &description, lldb::DescriptionLevel description_level) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBTypeFormat, GetDescription, (lldb::SBStream &, lldb::DescriptionLevel), description, description_level); @@ -112,8 +121,9 @@ } lldb::SBTypeFormat &SBTypeFormat::operator=(const lldb::SBTypeFormat &rhs) { - LLDB_RECORD_METHOD(lldb::SBTypeFormat &, - SBTypeFormat, operator=,(const lldb::SBTypeFormat &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(lldb::SBTypeFormat &, SBTypeFormat, operator=, + (const lldb::SBTypeFormat &), rhs); if (this != &rhs) { m_opaque_sp = rhs.m_opaque_sp; @@ -122,7 +132,8 @@ } bool SBTypeFormat::operator==(lldb::SBTypeFormat &rhs) { - LLDB_RECORD_METHOD(bool, SBTypeFormat, operator==,(lldb::SBTypeFormat &), + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(bool, SBTypeFormat, operator==, (lldb::SBTypeFormat &), rhs); if (!IsValid()) @@ -131,6 +142,7 @@ } bool SBTypeFormat::IsEqualTo(lldb::SBTypeFormat &rhs) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBTypeFormat, IsEqualTo, (lldb::SBTypeFormat &), rhs); @@ -144,7 +156,8 @@ } bool SBTypeFormat::operator!=(lldb::SBTypeFormat &rhs) { - LLDB_RECORD_METHOD(bool, SBTypeFormat, operator!=,(lldb::SBTypeFormat &), + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(bool, SBTypeFormat, operator!=, (lldb::SBTypeFormat &), rhs); if (!IsValid()) Index: lldb/source/API/SBTypeNameSpecifier.cpp =================================================================== --- lldb/source/API/SBTypeNameSpecifier.cpp +++ lldb/source/API/SBTypeNameSpecifier.cpp @@ -47,16 +47,19 @@ SBTypeNameSpecifier::~SBTypeNameSpecifier() = default; bool SBTypeNameSpecifier::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeNameSpecifier, IsValid); return this->operator bool(); } SBTypeNameSpecifier::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeNameSpecifier, operator bool); return m_opaque_sp.get() != nullptr; } const char *SBTypeNameSpecifier::GetName() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeNameSpecifier, GetName); if (!IsValid()) @@ -66,6 +69,7 @@ } SBType SBTypeNameSpecifier::GetType() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeNameSpecifier, GetType); if (!IsValid()) @@ -77,6 +81,7 @@ } bool SBTypeNameSpecifier::IsRegex() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeNameSpecifier, IsRegex); if (!IsValid()) @@ -87,6 +92,7 @@ bool SBTypeNameSpecifier::GetDescription( lldb::SBStream &description, lldb::DescriptionLevel description_level) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBTypeNameSpecifier, GetDescription, (lldb::SBStream &, lldb::DescriptionLevel), description, description_level); @@ -100,9 +106,10 @@ lldb::SBTypeNameSpecifier &SBTypeNameSpecifier:: operator=(const lldb::SBTypeNameSpecifier &rhs) { - LLDB_RECORD_METHOD( - lldb::SBTypeNameSpecifier &, - SBTypeNameSpecifier, operator=,(const lldb::SBTypeNameSpecifier &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier &, + SBTypeNameSpecifier, operator=, + (const lldb::SBTypeNameSpecifier &), rhs); if (this != &rhs) { m_opaque_sp = rhs.m_opaque_sp; @@ -111,8 +118,9 @@ } bool SBTypeNameSpecifier::operator==(lldb::SBTypeNameSpecifier &rhs) { - LLDB_RECORD_METHOD( - bool, SBTypeNameSpecifier, operator==,(lldb::SBTypeNameSpecifier &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(bool, SBTypeNameSpecifier, operator==, + (lldb::SBTypeNameSpecifier &), rhs); if (!IsValid()) return !rhs.IsValid(); @@ -120,6 +128,7 @@ } bool SBTypeNameSpecifier::IsEqualTo(lldb::SBTypeNameSpecifier &rhs) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBTypeNameSpecifier, IsEqualTo, (lldb::SBTypeNameSpecifier &), rhs); @@ -135,8 +144,9 @@ } bool SBTypeNameSpecifier::operator!=(lldb::SBTypeNameSpecifier &rhs) { - LLDB_RECORD_METHOD( - bool, SBTypeNameSpecifier, operator!=,(lldb::SBTypeNameSpecifier &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(bool, SBTypeNameSpecifier, operator!=, + (lldb::SBTypeNameSpecifier &), rhs); if (!IsValid()) return !rhs.IsValid(); Index: lldb/source/API/SBTypeSummary.cpp =================================================================== --- lldb/source/API/SBTypeSummary.cpp +++ lldb/source/API/SBTypeSummary.cpp @@ -35,16 +35,19 @@ SBTypeSummaryOptions::~SBTypeSummaryOptions() = default; bool SBTypeSummaryOptions::IsValid() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummaryOptions, IsValid); return this->operator bool(); } SBTypeSummaryOptions::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSummaryOptions, operator bool); return m_opaque_up.get(); } lldb::LanguageType SBTypeSummaryOptions::GetLanguage() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::LanguageType, SBTypeSummaryOptions, GetLanguage); @@ -54,6 +57,7 @@ } lldb::TypeSummaryCapping SBTypeSummaryOptions::GetCapping() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::TypeSummaryCapping, SBTypeSummaryOptions, GetCapping); @@ -63,6 +67,7 @@ } void SBTypeSummaryOptions::SetLanguage(lldb::LanguageType l) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBTypeSummaryOptions, SetLanguage, (lldb::LanguageType), l); @@ -71,6 +76,7 @@ } void SBTypeSummaryOptions::SetCapping(lldb::TypeSummaryCapping c) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBTypeSummaryOptions, SetCapping, (lldb::TypeSummaryCapping), c); @@ -186,16 +192,19 @@ SBTypeSummary::~SBTypeSummary() = default; bool SBTypeSummary::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSummary, IsValid); return this->operator bool(); } SBTypeSummary::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSummary, operator bool); return m_opaque_sp.get() != nullptr; } bool SBTypeSummary::IsFunctionCode() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummary, IsFunctionCode); if (!IsValid()) @@ -209,6 +218,7 @@ } bool SBTypeSummary::IsFunctionName() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummary, IsFunctionName); if (!IsValid()) @@ -222,6 +232,7 @@ } bool SBTypeSummary::IsSummaryString() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummary, IsSummaryString); if (!IsValid()) @@ -231,6 +242,7 @@ } const char *SBTypeSummary::GetData() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeSummary, GetData); if (!IsValid()) @@ -249,6 +261,7 @@ } uint32_t SBTypeSummary::GetOptions() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeSummary, GetOptions); if (!IsValid()) @@ -257,6 +270,7 @@ } void SBTypeSummary::SetOptions(uint32_t value) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBTypeSummary, SetOptions, (uint32_t), value); if (!CopyOnWrite_Impl()) @@ -265,6 +279,7 @@ } void SBTypeSummary::SetSummaryString(const char *data) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBTypeSummary, SetSummaryString, (const char *), data); @@ -278,6 +293,7 @@ } void SBTypeSummary::SetFunctionName(const char *data) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBTypeSummary, SetFunctionName, (const char *), data); @@ -291,6 +307,7 @@ } void SBTypeSummary::SetFunctionCode(const char *data) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBTypeSummary, SetFunctionCode, (const char *), data); @@ -305,6 +322,7 @@ bool SBTypeSummary::GetDescription(lldb::SBStream &description, lldb::DescriptionLevel description_level) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBTypeSummary, GetDescription, (lldb::SBStream &, lldb::DescriptionLevel), description, description_level); @@ -318,6 +336,7 @@ } bool SBTypeSummary::DoesPrintValue(lldb::SBValue value) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBTypeSummary, DoesPrintValue, (lldb::SBValue), value); @@ -328,9 +347,9 @@ } lldb::SBTypeSummary &SBTypeSummary::operator=(const lldb::SBTypeSummary &rhs) { - LLDB_RECORD_METHOD(lldb::SBTypeSummary &, - SBTypeSummary, operator=,(const lldb::SBTypeSummary &), - rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(lldb::SBTypeSummary &, SBTypeSummary, operator=, + (const lldb::SBTypeSummary &), rhs); if (this != &rhs) { m_opaque_sp = rhs.m_opaque_sp; @@ -339,7 +358,8 @@ } bool SBTypeSummary::operator==(lldb::SBTypeSummary &rhs) { - LLDB_RECORD_METHOD(bool, SBTypeSummary, operator==,(lldb::SBTypeSummary &), + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(bool, SBTypeSummary, operator==, (lldb::SBTypeSummary &), rhs); if (!IsValid()) @@ -348,6 +368,7 @@ } bool SBTypeSummary::IsEqualTo(lldb::SBTypeSummary &rhs) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBTypeSummary, IsEqualTo, (lldb::SBTypeSummary &), rhs); @@ -389,7 +410,8 @@ } bool SBTypeSummary::operator!=(lldb::SBTypeSummary &rhs) { - LLDB_RECORD_METHOD(bool, SBTypeSummary, operator!=,(lldb::SBTypeSummary &), + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(bool, SBTypeSummary, operator!=, (lldb::SBTypeSummary &), rhs); if (!IsValid()) Index: lldb/source/API/SBTypeSynthetic.cpp =================================================================== --- lldb/source/API/SBTypeSynthetic.cpp +++ lldb/source/API/SBTypeSynthetic.cpp @@ -53,16 +53,19 @@ SBTypeSynthetic::~SBTypeSynthetic() = default; bool SBTypeSynthetic::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSynthetic, IsValid); return this->operator bool(); } SBTypeSynthetic::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSynthetic, operator bool); return m_opaque_sp.get() != nullptr; } bool SBTypeSynthetic::IsClassCode() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSynthetic, IsClassCode); if (!IsValid()) @@ -72,6 +75,7 @@ } bool SBTypeSynthetic::IsClassName() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSynthetic, IsClassName); if (!IsValid()) @@ -80,6 +84,7 @@ } const char *SBTypeSynthetic::GetData() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeSynthetic, GetData); if (!IsValid()) @@ -91,6 +96,7 @@ } void SBTypeSynthetic::SetClassName(const char *data) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBTypeSynthetic, SetClassName, (const char *), data); if (IsValid() && data && *data) @@ -98,6 +104,7 @@ } void SBTypeSynthetic::SetClassCode(const char *data) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBTypeSynthetic, SetClassCode, (const char *), data); if (IsValid() && data && *data) @@ -105,6 +112,7 @@ } uint32_t SBTypeSynthetic::GetOptions() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeSynthetic, GetOptions); if (!IsValid()) @@ -113,6 +121,7 @@ } void SBTypeSynthetic::SetOptions(uint32_t value) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBTypeSynthetic, SetOptions, (uint32_t), value); if (!CopyOnWrite_Impl()) @@ -122,6 +131,7 @@ bool SBTypeSynthetic::GetDescription(lldb::SBStream &description, lldb::DescriptionLevel description_level) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBTypeSynthetic, GetDescription, (lldb::SBStream &, lldb::DescriptionLevel), description, description_level); @@ -135,9 +145,9 @@ lldb::SBTypeSynthetic &SBTypeSynthetic:: operator=(const lldb::SBTypeSynthetic &rhs) { - LLDB_RECORD_METHOD(lldb::SBTypeSynthetic &, - SBTypeSynthetic, operator=,(const lldb::SBTypeSynthetic &), - rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(lldb::SBTypeSynthetic &, SBTypeSynthetic, operator=, + (const lldb::SBTypeSynthetic &), rhs); if (this != &rhs) { m_opaque_sp = rhs.m_opaque_sp; @@ -146,8 +156,9 @@ } bool SBTypeSynthetic::operator==(lldb::SBTypeSynthetic &rhs) { - LLDB_RECORD_METHOD( - bool, SBTypeSynthetic, operator==,(lldb::SBTypeSynthetic &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(bool, SBTypeSynthetic, operator==, + (lldb::SBTypeSynthetic &), rhs); if (!IsValid()) return !rhs.IsValid(); @@ -155,6 +166,7 @@ } bool SBTypeSynthetic::IsEqualTo(lldb::SBTypeSynthetic &rhs) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBTypeSynthetic, IsEqualTo, (lldb::SBTypeSynthetic &), rhs); @@ -174,8 +186,9 @@ } bool SBTypeSynthetic::operator!=(lldb::SBTypeSynthetic &rhs) { - LLDB_RECORD_METHOD( - bool, SBTypeSynthetic, operator!=,(lldb::SBTypeSynthetic &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(bool, SBTypeSynthetic, operator!=, + (lldb::SBTypeSynthetic &), rhs); if (!IsValid()) return !rhs.IsValid(); Index: lldb/source/API/SBUnixSignals.cpp =================================================================== --- lldb/source/API/SBUnixSignals.cpp +++ lldb/source/API/SBUnixSignals.cpp @@ -33,9 +33,9 @@ : 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); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBUnixSignals &, SBUnixSignals, operator=, + (const lldb::SBUnixSignals &), rhs); if (this != &rhs) m_opaque_wp = rhs.m_opaque_wp; @@ -51,22 +51,26 @@ } void SBUnixSignals::Clear() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBUnixSignals, Clear); m_opaque_wp.reset(); } bool SBUnixSignals::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBUnixSignals, IsValid); return this->operator bool(); } SBUnixSignals::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBUnixSignals, operator bool); return static_cast(GetSP()); } const char *SBUnixSignals::GetSignalAsCString(int32_t signo) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(const char *, SBUnixSignals, GetSignalAsCString, (int32_t), signo); @@ -77,6 +81,7 @@ } int32_t SBUnixSignals::GetSignalNumberFromName(const char *name) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(int32_t, SBUnixSignals, GetSignalNumberFromName, (const char *), name); @@ -87,6 +92,7 @@ } bool SBUnixSignals::GetShouldSuppress(int32_t signo) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(bool, SBUnixSignals, GetShouldSuppress, (int32_t), signo); @@ -97,6 +103,7 @@ } bool SBUnixSignals::SetShouldSuppress(int32_t signo, bool value) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldSuppress, (int32_t, bool), signo, value); @@ -109,6 +116,7 @@ } bool SBUnixSignals::GetShouldStop(int32_t signo) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(bool, SBUnixSignals, GetShouldStop, (int32_t), signo); @@ -119,6 +127,7 @@ } bool SBUnixSignals::SetShouldStop(int32_t signo, bool value) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldStop, (int32_t, bool), signo, value); @@ -131,6 +140,7 @@ } bool SBUnixSignals::GetShouldNotify(int32_t signo) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(bool, SBUnixSignals, GetShouldNotify, (int32_t), signo); @@ -141,6 +151,7 @@ } bool SBUnixSignals::SetShouldNotify(int32_t signo, bool value) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldNotify, (int32_t, bool), signo, value); @@ -153,6 +164,7 @@ } int32_t SBUnixSignals::GetNumSignals() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(int32_t, SBUnixSignals, GetNumSignals); if (auto signals_sp = GetSP()) @@ -162,6 +174,7 @@ } int32_t SBUnixSignals::GetSignalAtIndex(int32_t index) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(int32_t, SBUnixSignals, GetSignalAtIndex, (int32_t), index); Index: lldb/source/API/SBValue.cpp =================================================================== --- lldb/source/API/SBValue.cpp +++ lldb/source/API/SBValue.cpp @@ -230,8 +230,9 @@ } SBValue &SBValue::operator=(const SBValue &rhs) { - LLDB_RECORD_METHOD(lldb::SBValue &, - SBValue, operator=,(const lldb::SBValue &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(lldb::SBValue &, SBValue, operator=, + (const lldb::SBValue &), rhs); if (this != &rhs) { SetSP(rhs.m_opaque_sp); @@ -242,10 +243,12 @@ SBValue::~SBValue() = default; bool SBValue::IsValid() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsValid); return this->operator bool(); } SBValue::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBValue, operator bool); // If this function ever changes to anything that does more than just check @@ -256,12 +259,14 @@ } void SBValue::Clear() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBValue, Clear); m_opaque_sp.reset(); } SBError SBValue::GetError() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBValue, GetError); SBError sb_error; @@ -278,6 +283,7 @@ } user_id_t SBValue::GetID() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::user_id_t, SBValue, GetID); ValueLocker locker; @@ -288,6 +294,7 @@ } const char *SBValue::GetName() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetName); const char *name = nullptr; @@ -300,6 +307,7 @@ } const char *SBValue::GetTypeName() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetTypeName); const char *name = nullptr; @@ -313,6 +321,7 @@ } const char *SBValue::GetDisplayTypeName() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetDisplayTypeName); const char *name = nullptr; @@ -326,6 +335,7 @@ } size_t SBValue::GetByteSize() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(size_t, SBValue, GetByteSize); size_t result = 0; @@ -340,6 +350,7 @@ } bool SBValue::IsInScope() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsInScope); bool result = false; @@ -354,6 +365,7 @@ } const char *SBValue::GetValue() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetValue); const char *cstr = nullptr; @@ -367,6 +379,7 @@ } ValueType SBValue::GetValueType() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::ValueType, SBValue, GetValueType); ValueType result = eValueTypeInvalid; @@ -379,6 +392,7 @@ } const char *SBValue::GetObjectDescription() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetObjectDescription); const char *cstr = nullptr; @@ -392,6 +406,7 @@ } SBType SBValue::GetType() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBValue, GetType); SBType sb_type; @@ -407,6 +422,7 @@ } bool SBValue::GetValueDidChange() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, GetValueDidChange); bool result = false; @@ -421,6 +437,7 @@ } const char *SBValue::GetSummary() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetSummary); const char *cstr = nullptr; @@ -435,6 +452,7 @@ const char *SBValue::GetSummary(lldb::SBStream &stream, lldb::SBTypeSummaryOptions &options) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(const char *, SBValue, GetSummary, (lldb::SBStream &, lldb::SBTypeSummaryOptions &), stream, options); @@ -451,6 +469,7 @@ } const char *SBValue::GetLocation() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetLocation); const char *cstr = nullptr; @@ -464,6 +483,7 @@ // Deprecated - use the one that takes an lldb::SBError bool SBValue::SetValueFromCString(const char *value_str) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBValue, SetValueFromCString, (const char *), value_str); @@ -472,6 +492,7 @@ } bool SBValue::SetValueFromCString(const char *value_str, lldb::SBError &error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBValue, SetValueFromCString, (const char *, lldb::SBError &), value_str, error); @@ -488,6 +509,7 @@ } lldb::SBTypeFormat SBValue::GetTypeFormat() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeFormat, SBValue, GetTypeFormat); lldb::SBTypeFormat format; @@ -504,6 +526,7 @@ } lldb::SBTypeSummary SBValue::GetTypeSummary() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeSummary, SBValue, GetTypeSummary); lldb::SBTypeSummary summary; @@ -520,6 +543,7 @@ } lldb::SBTypeFilter SBValue::GetTypeFilter() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeFilter, SBValue, GetTypeFilter); lldb::SBTypeFilter filter; @@ -540,6 +564,7 @@ } lldb::SBTypeSynthetic SBValue::GetTypeSynthetic() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeSynthetic, SBValue, GetTypeSynthetic); lldb::SBTypeSynthetic synthetic; @@ -561,6 +586,7 @@ lldb::SBValue SBValue::CreateChildAtOffset(const char *name, uint32_t offset, SBType type) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateChildAtOffset, (const char *, uint32_t, lldb::SBType), name, offset, type); @@ -581,6 +607,7 @@ } lldb::SBValue SBValue::Cast(SBType type) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValue, SBValue, Cast, (lldb::SBType), type); lldb::SBValue sb_value; @@ -595,6 +622,7 @@ lldb::SBValue SBValue::CreateValueFromExpression(const char *name, const char *expression) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateValueFromExpression, (const char *, const char *), name, expression); @@ -606,6 +634,7 @@ lldb::SBValue SBValue::CreateValueFromExpression(const char *name, const char *expression, SBExpressionOptions &options) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateValueFromExpression, (const char *, const char *, lldb::SBExpressionOptions &), name, expression, options); @@ -628,6 +657,7 @@ lldb::SBValue SBValue::CreateValueFromAddress(const char *name, lldb::addr_t address, SBType sb_type) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateValueFromAddress, (const char *, lldb::addr_t, lldb::SBType), name, address, sb_type); @@ -649,6 +679,7 @@ lldb::SBValue SBValue::CreateValueFromData(const char *name, SBData data, SBType sb_type) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateValueFromData, (const char *, lldb::SBData, lldb::SBType), name, data, sb_type); @@ -669,6 +700,7 @@ } SBValue SBValue::GetChildAtIndex(uint32_t idx) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildAtIndex, (uint32_t), idx); const bool can_create_synthetic = false; @@ -686,6 +718,7 @@ SBValue SBValue::GetChildAtIndex(uint32_t idx, lldb::DynamicValueType use_dynamic, bool can_create_synthetic) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildAtIndex, (uint32_t, lldb::DynamicValueType, bool), idx, use_dynamic, can_create_synthetic); @@ -709,6 +742,7 @@ } uint32_t SBValue::GetIndexOfChildWithName(const char *name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(uint32_t, SBValue, GetIndexOfChildWithName, (const char *), name); @@ -722,6 +756,7 @@ } SBValue SBValue::GetChildMemberWithName(const char *name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName, (const char *), name); @@ -738,6 +773,7 @@ SBValue SBValue::GetChildMemberWithName(const char *name, lldb::DynamicValueType use_dynamic_value) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName, (const char *, lldb::DynamicValueType), name, use_dynamic_value); @@ -758,6 +794,7 @@ } lldb::SBValue SBValue::GetDynamicValue(lldb::DynamicValueType use_dynamic) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetDynamicValue, (lldb::DynamicValueType), use_dynamic); @@ -771,6 +808,7 @@ } lldb::SBValue SBValue::GetStaticValue() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, GetStaticValue); SBValue value_sb; @@ -784,6 +822,7 @@ } lldb::SBValue SBValue::GetNonSyntheticValue() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, GetNonSyntheticValue); SBValue value_sb; @@ -796,6 +835,7 @@ } lldb::DynamicValueType SBValue::GetPreferDynamicValue() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::DynamicValueType, SBValue, GetPreferDynamicValue); @@ -805,6 +845,7 @@ } void SBValue::SetPreferDynamicValue(lldb::DynamicValueType use_dynamic) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBValue, SetPreferDynamicValue, (lldb::DynamicValueType), use_dynamic); @@ -813,6 +854,7 @@ } bool SBValue::GetPreferSyntheticValue() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, GetPreferSyntheticValue); if (!IsValid()) @@ -821,6 +863,7 @@ } void SBValue::SetPreferSyntheticValue(bool use_synthetic) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBValue, SetPreferSyntheticValue, (bool), use_synthetic); @@ -829,6 +872,7 @@ } bool SBValue::IsDynamic() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsDynamic); ValueLocker locker; @@ -839,6 +883,7 @@ } bool SBValue::IsSynthetic() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsSynthetic); ValueLocker locker; @@ -849,6 +894,7 @@ } bool SBValue::IsSyntheticChildrenGenerated() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsSyntheticChildrenGenerated); ValueLocker locker; @@ -859,6 +905,7 @@ } void SBValue::SetSyntheticChildrenGenerated(bool is) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBValue, SetSyntheticChildrenGenerated, (bool), is); ValueLocker locker; @@ -868,6 +915,7 @@ } lldb::SBValue SBValue::GetValueForExpressionPath(const char *expr_path) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetValueForExpressionPath, (const char *), expr_path); @@ -886,6 +934,7 @@ } int64_t SBValue::GetValueAsSigned(SBError &error, int64_t fail_value) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(int64_t, SBValue, GetValueAsSigned, (lldb::SBError &, int64_t), error, fail_value); @@ -907,6 +956,7 @@ } uint64_t SBValue::GetValueAsUnsigned(SBError &error, uint64_t fail_value) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(uint64_t, SBValue, GetValueAsUnsigned, (lldb::SBError &, uint64_t), error, fail_value); @@ -928,6 +978,7 @@ } int64_t SBValue::GetValueAsSigned(int64_t fail_value) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(int64_t, SBValue, GetValueAsSigned, (int64_t), fail_value); ValueLocker locker; @@ -939,6 +990,7 @@ } uint64_t SBValue::GetValueAsUnsigned(uint64_t fail_value) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(uint64_t, SBValue, GetValueAsUnsigned, (uint64_t), fail_value); @@ -951,6 +1003,7 @@ } bool SBValue::MightHaveChildren() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, MightHaveChildren); bool has_children = false; @@ -963,6 +1016,7 @@ } bool SBValue::IsRuntimeSupportValue() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsRuntimeSupportValue); bool is_support = false; @@ -975,12 +1029,14 @@ } uint32_t SBValue::GetNumChildren() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBValue, GetNumChildren); return GetNumChildren(UINT32_MAX); } uint32_t SBValue::GetNumChildren(uint32_t max) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(uint32_t, SBValue, GetNumChildren, (uint32_t), max); uint32_t num_children = 0; @@ -994,6 +1050,7 @@ } SBValue SBValue::Dereference() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, Dereference); SBValue sb_value; @@ -1009,12 +1066,14 @@ // Deprecated - please use GetType().IsPointerType() instead. bool SBValue::TypeIsPointerType() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, TypeIsPointerType); return GetType().IsPointerType(); } void *SBValue::GetOpaqueType() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void *, SBValue, GetOpaqueType); ValueLocker locker; @@ -1025,6 +1084,7 @@ } lldb::SBTarget SBValue::GetTarget() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBValue, GetTarget); SBTarget sb_target; @@ -1038,6 +1098,7 @@ } lldb::SBProcess SBValue::GetProcess() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBValue, GetProcess); SBProcess sb_process; @@ -1051,6 +1112,7 @@ } lldb::SBThread SBValue::GetThread() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBThread, SBValue, GetThread); SBThread sb_thread; @@ -1064,6 +1126,7 @@ } lldb::SBFrame SBValue::GetFrame() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFrame, SBValue, GetFrame); SBFrame sb_frame; @@ -1085,6 +1148,7 @@ } lldb::ValueObjectSP SBValue::GetSP() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ValueObjectSP, SBValue, GetSP); ValueLocker locker; @@ -1146,6 +1210,7 @@ } bool SBValue::GetExpressionPath(SBStream &description) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBValue, GetExpressionPath, (lldb::SBStream &), description); @@ -1160,6 +1225,7 @@ bool SBValue::GetExpressionPath(SBStream &description, bool qualify_cxx_base_classes) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBValue, GetExpressionPath, (lldb::SBStream &, bool), description, qualify_cxx_base_classes); @@ -1173,6 +1239,7 @@ } lldb::SBValue SBValue::EvaluateExpression(const char *expr) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValue, EvaluateExpression, (const char *), expr); @@ -1196,6 +1263,7 @@ lldb::SBValue SBValue::EvaluateExpression(const char *expr, const SBExpressionOptions &options) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValue, EvaluateExpression, (const char *, const lldb::SBExpressionOptions &), expr, options); @@ -1206,12 +1274,12 @@ lldb::SBValue SBValue::EvaluateExpression(const char *expr, const SBExpressionOptions &options, const char *name) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST( lldb::SBValue, SBValue, EvaluateExpression, (const char *, const lldb::SBExpressionOptions &, const char *), expr, options, name); - if (!expr || expr[0] == '\0') { return SBValue(); } @@ -1249,6 +1317,7 @@ } bool SBValue::GetDescription(SBStream &description) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBValue, GetDescription, (lldb::SBStream &), description); @@ -1265,6 +1334,7 @@ } lldb::Format SBValue::GetFormat() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::Format, SBValue, GetFormat); ValueLocker locker; @@ -1275,6 +1345,7 @@ } void SBValue::SetFormat(lldb::Format format) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBValue, SetFormat, (lldb::Format), format); ValueLocker locker; @@ -1284,6 +1355,7 @@ } lldb::SBValue SBValue::AddressOf() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, AddressOf); SBValue sb_value; @@ -1299,6 +1371,7 @@ } lldb::addr_t SBValue::GetLoadAddress() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBValue, GetLoadAddress); lldb::addr_t value = LLDB_INVALID_ADDRESS; @@ -1329,6 +1402,7 @@ } lldb::SBAddress SBValue::GetAddress() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBValue, GetAddress); Address addr; @@ -1358,6 +1432,7 @@ } lldb::SBData SBValue::GetPointeeData(uint32_t item_idx, uint32_t item_count) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBData, SBValue, GetPointeeData, (uint32_t, uint32_t), item_idx, item_count); @@ -1378,6 +1453,7 @@ } lldb::SBData SBValue::GetData() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBData, SBValue, GetData); lldb::SBData sb_data; @@ -1395,6 +1471,7 @@ } bool SBValue::SetData(lldb::SBData &data, SBError &error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBValue, SetData, (lldb::SBData &, lldb::SBError &), data, error); @@ -1430,6 +1507,7 @@ } lldb::SBValue SBValue::Clone(const char *new_name) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValue, SBValue, Clone, (const char *), new_name); ValueLocker locker; @@ -1442,6 +1520,7 @@ } lldb::SBDeclaration SBValue::GetDeclaration() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBDeclaration, SBValue, GetDeclaration); ValueLocker locker; @@ -1457,6 +1536,7 @@ lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read, bool write, SBError &error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBValue, Watch, (bool, bool, bool, lldb::SBError &), resolve_location, read, write, error); @@ -1522,6 +1602,7 @@ // Backward compatibility fix in the interim. lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read, bool write) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBValue, Watch, (bool, bool, bool), resolve_location, read, write); @@ -1531,6 +1612,7 @@ lldb::SBWatchpoint SBValue::WatchPointee(bool resolve_location, bool read, bool write, SBError &error) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBValue, WatchPointee, (bool, bool, bool, lldb::SBError &), resolve_location, read, write, error); @@ -1542,6 +1624,7 @@ } lldb::SBValue SBValue::Persist() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, Persist); ValueLocker locker; Index: lldb/source/API/SBValueList.cpp =================================================================== --- lldb/source/API/SBValueList.cpp +++ lldb/source/API/SBValueList.cpp @@ -84,24 +84,28 @@ SBValueList::~SBValueList() = default; bool SBValueList::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBValueList, IsValid); return this->operator bool(); } SBValueList::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBValueList, operator bool); return (m_opaque_up != nullptr); } void SBValueList::Clear() { + LLDB_SCOPED_TIMER(); 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); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBValueList &, SBValueList, operator=, + (const lldb::SBValueList &), rhs); if (this != &rhs) { if (rhs.IsValid()) @@ -123,6 +127,7 @@ const ValueListImpl &SBValueList::operator*() const { return *m_opaque_up; } void SBValueList::Append(const SBValue &val_obj) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBValueList, Append, (const lldb::SBValue &), val_obj); @@ -138,6 +143,7 @@ } void SBValueList::Append(const lldb::SBValueList &value_list) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBValueList, Append, (const lldb::SBValueList &), value_list); @@ -148,10 +154,10 @@ } SBValue SBValueList::GetValueAtIndex(uint32_t idx) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValueList, GetValueAtIndex, (uint32_t), idx); - SBValue sb_value; if (m_opaque_up) sb_value = m_opaque_up->GetValueAtIndex(idx); @@ -160,6 +166,7 @@ } uint32_t SBValueList::GetSize() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBValueList, GetSize); uint32_t size = 0; @@ -175,6 +182,7 @@ } SBValue SBValueList::FindValueObjectByUID(lldb::user_id_t uid) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(lldb::SBValue, SBValueList, FindValueObjectByUID, (lldb::user_id_t), uid); @@ -185,6 +193,7 @@ } SBValue SBValueList::GetFirstValueByName(const char *name) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValueList, GetFirstValueByName, (const char *), name); Index: lldb/source/API/SBVariablesOptions.cpp =================================================================== --- lldb/source/API/SBVariablesOptions.cpp +++ lldb/source/API/SBVariablesOptions.cpp @@ -91,10 +91,9 @@ SBVariablesOptions &SBVariablesOptions:: operator=(const SBVariablesOptions &options) { - LLDB_RECORD_METHOD( - lldb::SBVariablesOptions &, - SBVariablesOptions, operator=,(const lldb::SBVariablesOptions &), - options); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(lldb::SBVariablesOptions &, SBVariablesOptions, operator=, + (const lldb::SBVariablesOptions &), options); m_opaque_up = std::make_unique(options.ref()); return *this; @@ -103,16 +102,19 @@ SBVariablesOptions::~SBVariablesOptions() = default; bool SBVariablesOptions::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, IsValid); return this->operator bool(); } SBVariablesOptions::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, operator bool); return m_opaque_up != nullptr; } bool SBVariablesOptions::GetIncludeArguments() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, GetIncludeArguments); @@ -120,6 +122,7 @@ } void SBVariablesOptions::SetIncludeArguments(bool arguments) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeArguments, (bool), arguments); @@ -128,6 +131,7 @@ bool SBVariablesOptions::GetIncludeRecognizedArguments( const lldb::SBTarget &target) const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST(bool, SBVariablesOptions, GetIncludeRecognizedArguments, (const lldb::SBTarget &), target); @@ -136,6 +140,7 @@ } void SBVariablesOptions::SetIncludeRecognizedArguments(bool arguments) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeRecognizedArguments, (bool), arguments); @@ -143,12 +148,14 @@ } bool SBVariablesOptions::GetIncludeLocals() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, GetIncludeLocals); return m_opaque_up->GetIncludeLocals(); } void SBVariablesOptions::SetIncludeLocals(bool locals) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeLocals, (bool), locals); @@ -156,12 +163,14 @@ } bool SBVariablesOptions::GetIncludeStatics() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, GetIncludeStatics); return m_opaque_up->GetIncludeStatics(); } void SBVariablesOptions::SetIncludeStatics(bool statics) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeStatics, (bool), statics); @@ -169,12 +178,14 @@ } bool SBVariablesOptions::GetInScopeOnly() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, GetInScopeOnly); return m_opaque_up->GetInScopeOnly(); } void SBVariablesOptions::SetInScopeOnly(bool in_scope_only) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBVariablesOptions, SetInScopeOnly, (bool), in_scope_only); @@ -182,6 +193,7 @@ } bool SBVariablesOptions::GetIncludeRuntimeSupportValues() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, GetIncludeRuntimeSupportValues); @@ -190,6 +202,7 @@ void SBVariablesOptions::SetIncludeRuntimeSupportValues( bool runtime_support_values) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeRuntimeSupportValues, (bool), runtime_support_values); @@ -197,6 +210,7 @@ } lldb::DynamicValueType SBVariablesOptions::GetUseDynamic() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::DynamicValueType, SBVariablesOptions, GetUseDynamic); @@ -204,6 +218,7 @@ } void SBVariablesOptions::SetUseDynamic(lldb::DynamicValueType dynamic) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBVariablesOptions, SetUseDynamic, (lldb::DynamicValueType), dynamic); Index: lldb/source/API/SBWatchpoint.cpp =================================================================== --- lldb/source/API/SBWatchpoint.cpp +++ lldb/source/API/SBWatchpoint.cpp @@ -39,8 +39,9 @@ } const SBWatchpoint &SBWatchpoint::operator=(const SBWatchpoint &rhs) { - LLDB_RECORD_METHOD(const lldb::SBWatchpoint &, - SBWatchpoint, operator=,(const lldb::SBWatchpoint &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD(const lldb::SBWatchpoint &, SBWatchpoint, operator=, + (const lldb::SBWatchpoint &), rhs); m_opaque_wp = rhs.m_opaque_wp; return *this; @@ -49,9 +50,9 @@ SBWatchpoint::~SBWatchpoint() = default; watch_id_t SBWatchpoint::GetID() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::watch_id_t, SBWatchpoint, GetID); - watch_id_t watch_id = LLDB_INVALID_WATCH_ID; lldb::WatchpointSP watchpoint_sp(GetSP()); if (watchpoint_sp) @@ -61,30 +62,35 @@ } bool SBWatchpoint::IsValid() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBWatchpoint, IsValid); return this->operator bool(); } SBWatchpoint::operator bool() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBWatchpoint, operator bool); return bool(m_opaque_wp.lock()); } bool SBWatchpoint::operator==(const SBWatchpoint &rhs) const { - LLDB_RECORD_METHOD_CONST( - bool, SBWatchpoint, operator==,(const SBWatchpoint &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD_CONST(bool, SBWatchpoint, operator==, + (const SBWatchpoint &), rhs); return GetSP() == rhs.GetSP(); } bool SBWatchpoint::operator!=(const SBWatchpoint &rhs) const { - LLDB_RECORD_METHOD_CONST( - bool, SBWatchpoint, operator!=,(const SBWatchpoint &), rhs); + LLDB_SCOPED_TIMER(); + LLDB_RECORD_METHOD_CONST(bool, SBWatchpoint, operator!=, + (const SBWatchpoint &), rhs); return !(*this == rhs); } SBError SBWatchpoint::GetError() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBWatchpoint, GetError); SBError sb_error; @@ -96,6 +102,7 @@ } int32_t SBWatchpoint::GetHardwareIndex() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(int32_t, SBWatchpoint, GetHardwareIndex); int32_t hw_index = -1; @@ -111,6 +118,7 @@ } addr_t SBWatchpoint::GetWatchAddress() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBWatchpoint, GetWatchAddress); addr_t ret_addr = LLDB_INVALID_ADDRESS; @@ -126,6 +134,7 @@ } size_t SBWatchpoint::GetWatchSize() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(size_t, SBWatchpoint, GetWatchSize); size_t watch_size = 0; @@ -141,6 +150,7 @@ } void SBWatchpoint::SetEnabled(bool enabled) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBWatchpoint, SetEnabled, (bool), enabled); lldb::WatchpointSP watchpoint_sp(GetSP()); @@ -161,6 +171,7 @@ } bool SBWatchpoint::IsEnabled() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(bool, SBWatchpoint, IsEnabled); lldb::WatchpointSP watchpoint_sp(GetSP()); @@ -173,6 +184,7 @@ } uint32_t SBWatchpoint::GetHitCount() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBWatchpoint, GetHitCount); uint32_t count = 0; @@ -187,6 +199,7 @@ } uint32_t SBWatchpoint::GetIgnoreCount() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBWatchpoint, GetIgnoreCount); lldb::WatchpointSP watchpoint_sp(GetSP()); @@ -199,6 +212,7 @@ } void SBWatchpoint::SetIgnoreCount(uint32_t n) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBWatchpoint, SetIgnoreCount, (uint32_t), n); lldb::WatchpointSP watchpoint_sp(GetSP()); @@ -210,6 +224,7 @@ } const char *SBWatchpoint::GetCondition() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(const char *, SBWatchpoint, GetCondition); lldb::WatchpointSP watchpoint_sp(GetSP()); @@ -222,6 +237,7 @@ } void SBWatchpoint::SetCondition(const char *condition) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBWatchpoint, SetCondition, (const char *), condition); @@ -235,6 +251,7 @@ bool SBWatchpoint::GetDescription(SBStream &description, DescriptionLevel level) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(bool, SBWatchpoint, GetDescription, (lldb::SBStream &, lldb::DescriptionLevel), description, level); @@ -254,18 +271,21 @@ } void SBWatchpoint::Clear() { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_NO_ARGS(void, SBWatchpoint, Clear); m_opaque_wp.reset(); } lldb::WatchpointSP SBWatchpoint::GetSP() const { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::WatchpointSP, SBWatchpoint, GetSP); return m_opaque_wp.lock(); } void SBWatchpoint::SetSP(const lldb::WatchpointSP &sp) { + LLDB_SCOPED_TIMER(); LLDB_RECORD_METHOD(void, SBWatchpoint, SetSP, (const lldb::WatchpointSP &), sp);