[lldb] Instrument SB API with signposts

[JDevlieghere]

Summary

Instrument the SB API with signposts on Darwin. This gives us a time profile on whose behalf LLDB spends time (particularly when run via the SBAPI from an IDE).

[jingham]

I was about to say this shouldn't matter, since most people don't run with timers enabled and the timers should be no-ops when timing is off. But LLDB_SCOPED_TIMER seems to do a bunch of work even when the timers are disabled. The work includes "look up the Category in the map of categories, making a new one if not found", get the current time of day and stash that away, and do whatever the Signpost chooses to do on entry & exit. So this would be adding non-trivial work for everybody for every SB API call.

Is this really necessary? Seems like you could have LLDB_SCOPED_TIMER do nothing if the Timer::g_display_depth == 0. That would mean that you wouldn't get timings for the remaining bit of any timers that would have been active when you enabled the timers, but that doesn't seem particularly wrong to me...

I'm a little confused about what you want to achieve as well. You said you want to see "on whose behalf LLDB spends time". This change will tell you that during the course of the debug session, SBWatchpoint::SetSP consumed N seconds, and SBWatchpoint::GetSP M seconds. It will also dump some text to the console when an SB API is called, but I'm not sure how you would get access to that info and attribute it back to the caller.

But the timers don't record stacks, so you won't know anything about the callers, you will just know that that SB API consumed N seconds. I'm not sure how that tells you "on whose behalf lldb spends time". Of course, the Signpost call could do anything you want, so you could have a variant that captures stacks, but then these calls are going to get even more expensive...

[labath]

In D117632#3253445, @jingham wrote:

I was about to say this shouldn't matter, since most people don't run with timers enabled and the timers should be no-ops when timing is off. But LLDB_SCOPED_TIMER seems to do a bunch of work even when the timers are disabled. The work includes "look up the Category in the map of categories, making a new one if not found", get the current time of day and stash that away, and do whatever the Signpost chooses to do on entry & exit. So this would be adding non-trivial work for everybody for every SB API call.

Is this really necessary? Seems like you could have LLDB_SCOPED_TIMER do nothing if the Timer::g_display_depth == 0. That would mean that you wouldn't get timings for the remaining bit of any timers that would have been active when you enabled the timers, but that doesn't seem particularly wrong to me...

The way that timers currently work is that they are always active and measuring and can always be retrieved via log timers dump. g_display_depth (and log timers enable) only control whether their information gets dumped to stdout.

Apart from that, I don't have any particular opinion on this. I can't say I have found the lldb timers particularly useful. I think we could make then sufficiently cheap so that they could be added to every SB method (and hidden in the LLDB_RECORD_METHOD macro, since we already have it), but if I wanted to do some performance analysis, I'd probably use a profiler.

[JDevlieghere]

Do you actually care about the timers or is this really about getting these methods instrumented with signposts on our platform? If it's the latter, I think it would make more sense to put that call in the LLDB_RECORD_* macros (which I'm planning to rename imminently). If this is about instrumenting the API, we can use the old reproducer logic to differentiate between calls made across the API boundary. Maybe it would make sense to only instrument external calls.

If it's just the signposts I'm not worried about performance, there's no way that's slower than the old reproducer instrumentation :-)

[aprantl]

In D117632#3255158, @JDevlieghere wrote:

Do you actually care about the timers or is this really about getting these methods instrumented with signposts on our platform? If it's the latter, I think it would make more sense to put that call in the LLDB_RECORD_* macros (which I'm planning to rename imminently). If this is about instrumenting the API, we can use the old reproducer logic to differentiate between calls made across the API boundary. Maybe it would make sense to only instrument external calls.

If it's just the signposts I'm not worried about performance, there's no way that's slower than the old reproducer instrumentation :-)

That's right, I'm only interested in signposts. I'll put this patch aside for now, it would make sense to integrate this functionality into the properly renamed macros!

[aprantl]

I'm a little confused about what you want to achieve as well.

With signposts you get a flamegraph of all nested signposted functions, which is really intuitive to look at.

[JDevlieghere]

I can do this after the rename.

[aprantl]

Assuming UpdateBoundary is only called in the destructor this looks nice!

lldb/source/Utility/Instrumentation.cpp

21 ↗

(On Diff #401369)

///

[JDevlieghere]

Yup, at this point I might as well inline it.

lldb/source/API/SBAddress.cpp

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

 }
 
 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<Address>();
 }
 
 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);
 

 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())

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

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

 }
 
 bool SBAddress::OffsetAddress(addr_t offset) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBAddress, OffsetAddress, (lldb::addr_t), offset);
 
   if (m_opaque_up->IsValid()) {

 }
 
 lldb::SBSection SBAddress::GetSection() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSection, SBAddress, GetSection);
 
   lldb::SBSection sb_section;

 }
 
 lldb::addr_t SBAddress::GetOffset() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBAddress, GetOffset);
 
   if (m_opaque_up->IsValid())

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

 }
 
 SBModule SBAddress::GetModule() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBModule, SBAddress, GetModule);
 
   SBModule sb_module;

 }
 
 SBSymbolContext SBAddress::GetSymbolContext(uint32_t resolve_scope) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBAddress, GetSymbolContext,
                      (uint32_t), resolve_scope);
 

 }
 
 SBCompileUnit SBAddress::GetCompileUnit() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCompileUnit, SBAddress, GetCompileUnit);
 
   SBCompileUnit sb_comp_unit;

 }
 
 SBFunction SBAddress::GetFunction() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFunction, SBAddress, GetFunction);
 
   SBFunction sb_function;

 }
 
 SBBlock SBAddress::GetBlock() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBAddress, GetBlock);
 
   SBBlock sb_block;

 }
 
 SBSymbol SBAddress::GetSymbol() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSymbol, SBAddress, GetSymbol);
 
   SBSymbol sb_symbol;

 }
 
 SBLineEntry SBAddress::GetLineEntry() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBLineEntry, SBAddress, GetLineEntry);
 
   SBLineEntry sb_line_entry;

lldb/source/API/SBAttachInfo.cpp

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

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

 }
 
 void SBAttachInfo::SetExecutable(const char *path) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBAttachInfo, SetExecutable, (const char *), path);
 
   if (path && path[0])

 }
 
 void SBAttachInfo::SetExecutable(SBFileSpec exe_file) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBAttachInfo, SetExecutable, (lldb::SBFileSpec),
                      exe_file);
 

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

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

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

lldb/source/API/SBBlock.cpp

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

 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)

 }
 
 const char *SBBlock::GetInlinedName() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBlock, GetInlinedName);
 
   if (m_opaque_ptr) {

 }
 
 SBFileSpec SBBlock::GetInlinedCallSiteFile() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBBlock,
                                    GetInlinedCallSiteFile);
 

 }
 
 uint32_t SBBlock::GetInlinedCallSiteLine() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBlock, GetInlinedCallSiteLine);
 
   if (m_opaque_ptr) {

 }
 
 uint32_t SBBlock::GetInlinedCallSiteColumn() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBlock, GetInlinedCallSiteColumn);
 
   if (m_opaque_ptr) {

 }
 
 SBBlock SBBlock::GetParent() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetParent);
 
   SBBlock sb_block;

 }
 
 lldb::SBBlock SBBlock::GetContainingInlinedBlock() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetContainingInlinedBlock);
 
   SBBlock sb_block;

 }
 
 SBBlock SBBlock::GetSibling() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetSibling);
 
   SBBlock sb_block;

 }
 
 SBBlock SBBlock::GetFirstChild() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetFirstChild);
 
   SBBlock sb_block;

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

 }
 
 uint32_t SBBlock::GetNumRanges() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBBlock, GetNumRanges);
 
   if (m_opaque_ptr)

 }
 
 lldb::SBAddress SBBlock::GetRangeStartAddress(uint32_t idx) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBAddress, SBBlock, GetRangeStartAddress, (uint32_t),
                      idx);
 

 }
 
 lldb::SBAddress SBBlock::GetRangeEndAddress(uint32_t idx) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBAddress, SBBlock, GetRangeEndAddress, (uint32_t),
                      idx);
 

 }
 
 uint32_t SBBlock::GetRangeIndexForBlockAddress(lldb::SBAddress block_addr) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(uint32_t, SBBlock, GetRangeIndexForBlockAddress,
                      (lldb::SBAddress), block_addr);
 

 lldb::SBValueList SBBlock::GetVariables(lldb::SBFrame &frame, bool arguments,
                                         bool locals, bool statics,
                                         lldb::DynamicValueType use_dynamic) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(
       lldb::SBValueList, SBBlock, GetVariables,
       (lldb::SBFrame &, bool, bool, bool, lldb::DynamicValueType), frame,

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

lldb/source/API/SBBreakpoint.cpp

 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();

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

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

 }
 
 void SBBreakpoint::ClearAllBreakpointSites() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(void, SBBreakpoint, ClearAllBreakpointSites);
 
   BreakpointSP bkpt_sp = GetSP();

 }
 
 SBBreakpointLocation SBBreakpoint::FindLocationByAddress(addr_t vm_addr) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
                      FindLocationByAddress, (lldb::addr_t), vm_addr);
 

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

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

 }
 
 SBBreakpointLocation SBBreakpoint::GetLocationAtIndex(uint32_t index) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
                      GetLocationAtIndex, (uint32_t), index);
 

 }
 
 void SBBreakpoint::SetEnabled(bool enable) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpoint, SetEnabled, (bool), enable);
 
   BreakpointSP bkpt_sp = GetSP();

 }
 
 bool SBBreakpoint::IsEnabled() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpoint, IsEnabled);
 
   BreakpointSP bkpt_sp = GetSP();

 }
 
 void SBBreakpoint::SetOneShot(bool one_shot) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpoint, SetOneShot, (bool), one_shot);
 
   BreakpointSP bkpt_sp = GetSP();

 }
 
 bool SBBreakpoint::IsOneShot() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, IsOneShot);
 
   BreakpointSP bkpt_sp = GetSP();

 }
 
 bool SBBreakpoint::IsInternal() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpoint, IsInternal);
 
   BreakpointSP bkpt_sp = GetSP();

 }
 
 void SBBreakpoint::SetIgnoreCount(uint32_t count) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpoint, SetIgnoreCount, (uint32_t), count);
 
   BreakpointSP bkpt_sp = GetSP();

 }
 
 void SBBreakpoint::SetCondition(const char *condition) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpoint, SetCondition, (const char *),
                      condition);
 

 }
 
 const char *SBBreakpoint::GetCondition() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBBreakpoint, GetCondition);
 
   BreakpointSP bkpt_sp = GetSP();

 }
 
 void SBBreakpoint::SetAutoContinue(bool auto_continue) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpoint, SetAutoContinue, (bool),
                      auto_continue);
 

 }
 
 bool SBBreakpoint::GetAutoContinue() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpoint, GetAutoContinue);
 
   BreakpointSP bkpt_sp = GetSP();

 }
 
 uint32_t SBBreakpoint::GetHitCount() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpoint, GetHitCount);
 
   uint32_t count = 0;

 }
 
 uint32_t SBBreakpoint::GetIgnoreCount() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpoint, GetIgnoreCount);
 
   uint32_t count = 0;

 }
 
 void SBBreakpoint::SetThreadID(tid_t tid) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpoint, SetThreadID, (lldb::tid_t), tid);
 
   BreakpointSP bkpt_sp = GetSP();

 }
 
 tid_t SBBreakpoint::GetThreadID() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBBreakpoint, GetThreadID);
 
   tid_t tid = LLDB_INVALID_THREAD_ID;

 }
 
 void SBBreakpoint::SetThreadIndex(uint32_t index) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpoint, SetThreadIndex, (uint32_t), index);
 
   BreakpointSP bkpt_sp = GetSP();

 }
 
 uint32_t SBBreakpoint::GetThreadIndex() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpoint, GetThreadIndex);
 
   uint32_t thread_idx = UINT32_MAX;

 }
 
 void SBBreakpoint::SetThreadName(const char *thread_name) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpoint, SetThreadName, (const char *),
                      thread_name);
 

 }
 
 const char *SBBreakpoint::GetThreadName() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpoint, GetThreadName);
 
   const char *name = nullptr;

 }
 
 void SBBreakpoint::SetQueueName(const char *queue_name) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpoint, SetQueueName, (const char *),
                      queue_name);
 

 }
 
 const char *SBBreakpoint::GetQueueName() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpoint, GetQueueName);
 
   const char *name = nullptr;

 }
 
 size_t SBBreakpoint::GetNumResolvedLocations() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBBreakpoint,
                                    GetNumResolvedLocations);
 

 }
 
 size_t SBBreakpoint::GetNumLocations() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBBreakpoint, GetNumLocations);
 
   BreakpointSP bkpt_sp = GetSP();

 }
 
 void SBBreakpoint::SetCommandLineCommands(SBStringList &commands) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpoint, SetCommandLineCommands,
                      (lldb::SBStringList &), commands);
 

 }
 
 bool SBBreakpoint::GetCommandLineCommands(SBStringList &commands) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBBreakpoint, GetCommandLineCommands,
                      (lldb::SBStringList &), commands);
 

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

 }
 
 SBError SBBreakpoint::AddLocation(SBAddress &address) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBError, SBBreakpoint, AddLocation,
                      (lldb::SBAddress &), address);
 

 }
 
 SBStructuredData SBBreakpoint::SerializeToStructuredData() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStructuredData, SBBreakpoint,
                              SerializeToStructuredData);
 

 }
 
 void SBBreakpoint::SetCallback(SBBreakpointHitCallback callback, void *baton) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpoint, SetCallback,
                      (lldb::SBBreakpointHitCallback, void *), callback, baton);
 

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

 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();
 

 }
 
 SBError SBBreakpoint::SetScriptCallbackBody(const char *callback_body_text) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBError, SBBreakpoint, SetScriptCallbackBody,
                      (const char *), callback_body_text);
 

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

 }
 
 SBError SBBreakpoint::AddNameWithErrorHandling(const char *new_name) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(SBError, SBBreakpoint, AddNameWithErrorHandling,
                      (const char *), new_name);
 

 }
 
 void SBBreakpoint::RemoveName(const char *name_to_remove) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpoint, RemoveName, (const char *),
                      name_to_remove);
 

 }
 
 bool SBBreakpoint::MatchesName(const char *name) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBBreakpoint, MatchesName, (const char *), name);
 
   BreakpointSP bkpt_sp = GetSP();

 }
 
 void SBBreakpoint::GetNames(SBStringList &names) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpoint, GetNames, (lldb::SBStringList &),
                      names);
 

 }
 
 bool SBBreakpoint::IsHardware() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, IsHardware);
 
   BreakpointSP bkpt_sp = GetSP();

 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)

 }
 
 SBBreakpoint SBBreakpointList::GetBreakpointAtIndex(size_t idx) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBBreakpointList, GetBreakpointAtIndex,
                      (size_t), idx);
 

 }
 
 SBBreakpoint SBBreakpointList::FindBreakpointByID(lldb::break_id_t id) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBBreakpointList, FindBreakpointByID,
                      (lldb::break_id_t), id);
 

 }
 
 void SBBreakpointList::Append(const SBBreakpoint &sb_bkpt) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpointList, Append,
                      (const lldb::SBBreakpoint &), sb_bkpt);
 

 }
 
 void SBBreakpointList::AppendByID(lldb::break_id_t id) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpointList, AppendByID, (lldb::break_id_t),
                      id);
 

 }
 
 bool SBBreakpointList::AppendIfUnique(const SBBreakpoint &sb_bkpt) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBBreakpointList, AppendIfUnique,
                      (const lldb::SBBreakpoint &), sb_bkpt);
 

 }
 
 void SBBreakpointList::Clear() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(void, SBBreakpointList, Clear);
 
   if (m_opaque_sp)

lldb/source/API/SBBreakpointLocation.cpp

 
 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;

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

 }
 
 addr_t SBBreakpointLocation::GetLoadAddress() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBBreakpointLocation,
                              GetLoadAddress);
 

 }
 
 void SBBreakpointLocation::SetEnabled(bool enabled) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetEnabled, (bool), enabled);
 
   BreakpointLocationSP loc_sp = GetSP();

 }
 
 bool SBBreakpointLocation::IsEnabled() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointLocation, IsEnabled);
 
   BreakpointLocationSP loc_sp = GetSP();

 }
 
 uint32_t SBBreakpointLocation::GetHitCount() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBBreakpointLocation, GetHitCount);
 
   BreakpointLocationSP loc_sp = GetSP();

 }
 
 uint32_t SBBreakpointLocation::GetIgnoreCount() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBBreakpointLocation, GetIgnoreCount);
 
   BreakpointLocationSP loc_sp = GetSP();

 }
 
 void SBBreakpointLocation::SetIgnoreCount(uint32_t n) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetIgnoreCount, (uint32_t), n);
 
   BreakpointLocationSP loc_sp = GetSP();

 }
 
 void SBBreakpointLocation::SetCondition(const char *condition) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetCondition, (const char *),
                      condition);
 

 }
 
 const char *SBBreakpointLocation::GetCondition() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBBreakpointLocation, GetCondition);
 
   BreakpointLocationSP loc_sp = GetSP();

 }
 
 void SBBreakpointLocation::SetAutoContinue(bool auto_continue) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetAutoContinue, (bool),
                      auto_continue);
 

 }
 
 bool SBBreakpointLocation::GetAutoContinue() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointLocation, GetAutoContinue);
 
   BreakpointLocationSP loc_sp = GetSP();

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

 
 SBError
 SBBreakpointLocation::SetScriptCallbackBody(const char *callback_body_text) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBError, SBBreakpointLocation, SetScriptCallbackBody,
                      (const char *), callback_body_text);
 

 }
 
 void SBBreakpointLocation::SetCommandLineCommands(SBStringList &commands) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetCommandLineCommands,
                      (lldb::SBStringList &), commands);
 

 }
 
 bool SBBreakpointLocation::GetCommandLineCommands(SBStringList &commands) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBBreakpointLocation, GetCommandLineCommands,
                      (lldb::SBStringList &), commands);
 

 }
 
 void SBBreakpointLocation::SetThreadID(tid_t thread_id) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetThreadID, (lldb::tid_t),
                      thread_id);
 

 }
 
 tid_t SBBreakpointLocation::GetThreadID() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBBreakpointLocation, GetThreadID);
 
   tid_t tid = LLDB_INVALID_THREAD_ID;

 }
 
 void SBBreakpointLocation::SetThreadIndex(uint32_t index) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetThreadIndex, (uint32_t),
                      index);
 

 }
 
 uint32_t SBBreakpointLocation::GetThreadIndex() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointLocation,
                                    GetThreadIndex);
 

 }
 
 void SBBreakpointLocation::SetThreadName(const char *thread_name) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetThreadName, (const char *),
                      thread_name);
 

 }
 
 const char *SBBreakpointLocation::GetThreadName() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointLocation,
                                    GetThreadName);
 

 }
 
 void SBBreakpointLocation::SetQueueName(const char *queue_name) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetQueueName, (const char *),
                      queue_name);
 

 }
 
 const char *SBBreakpointLocation::GetQueueName() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointLocation,
                                    GetQueueName);
 

 }
 
 bool SBBreakpointLocation::IsResolved() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointLocation, IsResolved);
 
   BreakpointLocationSP loc_sp = GetSP();

 
 bool SBBreakpointLocation::GetDescription(SBStream &description,
                                           DescriptionLevel level) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBBreakpointLocation, GetDescription,
                      (lldb::SBStream &, lldb::DescriptionLevel), description,
                      level);

 }
 
 break_id_t SBBreakpointLocation::GetID() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::break_id_t, SBBreakpointLocation, GetID);
 
   BreakpointLocationSP loc_sp = GetSP();

 }
 
 SBBreakpoint SBBreakpointLocation::GetBreakpoint() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBreakpoint, SBBreakpointLocation,
                              GetBreakpoint);
 

lldb/source/API/SBBreakpointName.cpp

 
 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();

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

 }
 
 const char *SBBreakpointName::GetName() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName, GetName);
 
   if (!m_impl_up)

 }
 
 void SBBreakpointName::SetEnabled(bool enable) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpointName, SetEnabled, (bool), enable);
 
   BreakpointName *bp_name = GetBreakpointName();

 }
 
 bool SBBreakpointName::IsEnabled() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, IsEnabled);
 
   BreakpointName *bp_name = GetBreakpointName();

 }
 
 void SBBreakpointName::SetOneShot(bool one_shot) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpointName, SetOneShot, (bool), one_shot);
 
   BreakpointName *bp_name = GetBreakpointName();

 }
 
 bool SBBreakpointName::IsOneShot() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, IsOneShot);
 
   const BreakpointName *bp_name = GetBreakpointName();

 }
 
 void SBBreakpointName::SetIgnoreCount(uint32_t count) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpointName, SetIgnoreCount, (uint32_t), count);
 
   BreakpointName *bp_name = GetBreakpointName();

 }
 
 uint32_t SBBreakpointName::GetIgnoreCount() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointName, GetIgnoreCount);
 
   BreakpointName *bp_name = GetBreakpointName();

 }
 
 void SBBreakpointName::SetCondition(const char *condition) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpointName, SetCondition, (const char *),
                      condition);
 

 }
 
 const char *SBBreakpointName::GetCondition() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBBreakpointName, GetCondition);
 
   BreakpointName *bp_name = GetBreakpointName();

 }
 
 void SBBreakpointName::SetAutoContinue(bool auto_continue) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpointName, SetAutoContinue, (bool),
                      auto_continue);
 

 }
 
 bool SBBreakpointName::GetAutoContinue() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAutoContinue);
 
   BreakpointName *bp_name = GetBreakpointName();

 }
 
 void SBBreakpointName::SetThreadID(tid_t tid) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadID, (lldb::tid_t), tid);
 
   BreakpointName *bp_name = GetBreakpointName();

 }
 
 tid_t SBBreakpointName::GetThreadID() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBBreakpointName, GetThreadID);
 
   BreakpointName *bp_name = GetBreakpointName();

 }
 
 void SBBreakpointName::SetThreadIndex(uint32_t index) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadIndex, (uint32_t), index);
 
   BreakpointName *bp_name = GetBreakpointName();

 }
 
 uint32_t SBBreakpointName::GetThreadIndex() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointName, GetThreadIndex);
 
   BreakpointName *bp_name = GetBreakpointName();

 }
 
 void SBBreakpointName::SetThreadName(const char *thread_name) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadName, (const char *),
                      thread_name);
 

 }
 
 const char *SBBreakpointName::GetThreadName() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName,
                                    GetThreadName);
 

 }
 
 void SBBreakpointName::SetQueueName(const char *queue_name) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpointName, SetQueueName, (const char *),
                      queue_name);
 

 }
 
 const char *SBBreakpointName::GetQueueName() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName,
                                    GetQueueName);
 

 }
 
 void SBBreakpointName::SetCommandLineCommands(SBStringList &commands) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpointName, SetCommandLineCommands,
                      (lldb::SBStringList &), commands);
 

 }
 
 bool SBBreakpointName::GetCommandLineCommands(SBStringList &commands) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBBreakpointName, GetCommandLineCommands,
                      (lldb::SBStringList &), commands);
 

 }
 
 const char *SBBreakpointName::GetHelpString() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName,
                                    GetHelpString);
 

 }
 
 void SBBreakpointName::SetHelpString(const char *help_string) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpointName, SetHelpString, (const char *),
                      help_string);
 

 }
 
 bool SBBreakpointName::GetDescription(SBStream &s) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBBreakpointName, GetDescription, (lldb::SBStream &),
                      s);
 

 
 void SBBreakpointName::SetCallback(SBBreakpointHitCallback callback,
                                    void *baton) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpointName, SetCallback,
                      (lldb::SBBreakpointHitCallback, void *), callback, baton);
 

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

 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) {

 
 SBError
 SBBreakpointName::SetScriptCallbackBody(const char *callback_body_text) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBError, SBBreakpointName, SetScriptCallbackBody,
                      (const char *), callback_body_text);
 

 }
 
 bool SBBreakpointName::GetAllowList() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, GetAllowList);
 
   BreakpointName *bp_name = GetBreakpointName();

 }
 
 void SBBreakpointName::SetAllowList(bool value) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowList, (bool), value);
 
-
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return;

 }
 
 bool SBBreakpointName::GetAllowDelete() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAllowDelete);
 
   BreakpointName *bp_name = GetBreakpointName();

 }
 
 void SBBreakpointName::SetAllowDelete(bool value) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowDelete, (bool), value);
 
-
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return;

 }
 
 bool SBBreakpointName::GetAllowDisable() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAllowDisable);
 
   BreakpointName *bp_name = GetBreakpointName();

 }
 
 void SBBreakpointName::SetAllowDisable(bool value) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowDisable, (bool), value);
 
   BreakpointName *bp_name = GetBreakpointName();

lldb/source/API/SBBroadcaster.cpp

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

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

 }
 
 void SBBroadcaster::BroadcastEvent(const SBEvent &event, bool unique) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBBroadcaster, BroadcastEvent,
                      (const lldb::SBEvent &, bool), event, unique);
 

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

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

 }
 
 const char *SBBroadcaster::GetName() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBroadcaster, GetName);
 
   if (m_opaque_ptr)

 }
 
 bool SBBroadcaster::EventTypeHasListeners(uint32_t event_type) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBBroadcaster, EventTypeHasListeners, (uint32_t),
                      event_type);
 

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

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

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

lldb/source/API/SBCommandInterpreter.cpp

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

 }
 
 bool SBCommandInterpreter::AliasExists(const char *cmd) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBCommandInterpreter, AliasExists, (const char *),
                      cmd);
 

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

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

 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),

     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 &,

 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 &),

     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,

     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 &,

                                            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,

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

 }
 
 SBDebugger SBCommandInterpreter::GetDebugger() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBDebugger, SBCommandInterpreter,
                              GetDebugger);
 

 }
 
 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())

 }
 
 void SBCommandInterpreter::AllowExitCodeOnQuit(bool allow) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBCommandInterpreter, AllowExitCodeOnQuit, (bool),
                      allow);
 

 }
 
 bool SBCommandInterpreter::HasCustomQuitExitCode() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasCustomQuitExitCode);
 
   bool exited = false;

 }
 
 int SBCommandInterpreter::GetQuitStatus() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(int, SBCommandInterpreter, GetQuitStatus);
 
   bool exited = false;

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

 
 void SBCommandInterpreter::SourceInitFileInHomeDirectory(
     SBCommandReturnObject &result) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBCommandInterpreter, SourceInitFileInHomeDirectory,
                      (lldb::SBCommandReturnObject &), result);
 

 
 void SBCommandInterpreter::SourceInitFileInHomeDirectory(
     SBCommandReturnObject &result, bool is_repl) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBCommandInterpreter, SourceInitFileInHomeDirectory,
                      (lldb::SBCommandReturnObject &, bool), result, is_repl);
 

 
 void SBCommandInterpreter::SourceInitFileInCurrentWorkingDirectory(
     SBCommandReturnObject &result) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBCommandInterpreter,
                      SourceInitFileInCurrentWorkingDirectory,
                      (lldb::SBCommandReturnObject &), result);

 }
 
 SBBroadcaster SBCommandInterpreter::GetBroadcaster() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBroadcaster, SBCommandInterpreter,
                              GetBroadcaster);
 
-
   SBBroadcaster broadcaster(m_opaque_ptr, false);
 
   return broadcaster;

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

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

 
 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,

 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 *),

 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 *),

 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()

 }
 
 const char *SBCommand::GetHelpLong() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetHelpLong);
 
   return (IsValid() ? ConstString(m_opaque_sp->GetHelpLong()).AsCString()

 }
 
 void SBCommand::SetHelp(const char *help) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBCommand, SetHelp, (const char *), help);
 
   if (IsValid())

 }
 
 void SBCommand::SetHelpLong(const char *help) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBCommand, SetHelpLong, (const char *), help);
 
   if (IsValid())

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

 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,

 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 *),

                                       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 *),

 }
 
 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())

lldb/source/API/SBCommandInterpreterRunOptions.cpp

 
 SBCommandInterpreterRunOptions &SBCommandInterpreterRunOptions::operator=(
     const SBCommandInterpreterRunOptions &rhs) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBCommandInterpreterRunOptions &,
                      SBCommandInterpreterRunOptions, operator=,
                      (const lldb::SBCommandInterpreterRunOptions &), rhs);

 }
 
 bool SBCommandInterpreterRunOptions::GetStopOnContinue() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
                                    GetStopOnContinue);
 

 }
 
 void SBCommandInterpreterRunOptions::SetStopOnContinue(bool stop_on_continue) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnContinue,
                      (bool), stop_on_continue);
 

 }
 
 bool SBCommandInterpreterRunOptions::GetStopOnError() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
                                    GetStopOnError);
 

 }
 
 void SBCommandInterpreterRunOptions::SetStopOnError(bool stop_on_error) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnError,
                      (bool), stop_on_error);
 

 }
 
 bool SBCommandInterpreterRunOptions::GetStopOnCrash() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
                                    GetStopOnCrash);
 

 }
 
 void SBCommandInterpreterRunOptions::SetStopOnCrash(bool stop_on_crash) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnCrash,
                      (bool), stop_on_crash);
 

 }
 
 bool SBCommandInterpreterRunOptions::GetEchoCommands() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
                                    GetEchoCommands);
 

 }
 
 void SBCommandInterpreterRunOptions::SetEchoCommands(bool echo_commands) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetEchoCommands,
                      (bool), echo_commands);
 

 }
 
 bool SBCommandInterpreterRunOptions::GetEchoCommentCommands() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
                                    GetEchoCommentCommands);
 

 }
 
 void SBCommandInterpreterRunOptions::SetEchoCommentCommands(bool echo) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions,
                      SetEchoCommentCommands, (bool), echo);
 

 }
 
 bool SBCommandInterpreterRunOptions::GetPrintResults() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
                                    GetPrintResults);
 

 }
 
 void SBCommandInterpreterRunOptions::SetPrintResults(bool print_results) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetPrintResults,
                      (bool), print_results);
 

 }
 
 bool SBCommandInterpreterRunOptions::GetPrintErrors() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
                                    GetPrintErrors);
 

 }
 
 void SBCommandInterpreterRunOptions::SetPrintErrors(bool print_errors) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetPrintErrors,
                      (bool), print_errors);
 

 }
 
 bool SBCommandInterpreterRunOptions::GetAddToHistory() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
                                    GetAddToHistory);
 

 }
 
 void SBCommandInterpreterRunOptions::SetAddToHistory(bool add_to_history) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetAddToHistory,
                      (bool), add_to_history);
 

 }
 
 bool SBCommandInterpreterRunOptions::GetAutoHandleEvents() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
                                    GetAutoHandleEvents);
 

 
 void SBCommandInterpreterRunOptions::SetAutoHandleEvents(
     bool auto_handle_events) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetAutoHandleEvents,
                      (bool), auto_handle_events);
 

 }
 
 bool SBCommandInterpreterRunOptions::GetSpawnThread() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
                                    GetSpawnThread);
 

 }
 
 void SBCommandInterpreterRunOptions::SetSpawnThread(bool spawn_thread) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetSpawnThread,
                      (bool), spawn_thread);
 

 
 SBCommandInterpreterRunResult &SBCommandInterpreterRunResult::operator=(
     const SBCommandInterpreterRunResult &rhs) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBCommandInterpreterRunResult &,
                      SBCommandInterpreterRunResult, operator=,
                      (const lldb::SBCommandInterpreterRunResult &), rhs);

 }
 
 int SBCommandInterpreterRunResult::GetNumberOfErrors() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(int, SBCommandInterpreterRunResult,
                                    GetNumberOfErrors);
 

 
 lldb::CommandInterpreterResult
 SBCommandInterpreterRunResult::GetResult() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::CommandInterpreterResult,
                                    SBCommandInterpreterRunResult, GetResult);
 

lldb/source/API/SBCommandReturnObject.cpp

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

 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.

 }
 
 const char *SBCommandReturnObject::GetOutput() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommandReturnObject, GetOutput);
 
   ConstString output(ref().GetOutputData());

 }
 
 const char *SBCommandReturnObject::GetError() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommandReturnObject, GetError);
 
   ConstString output(ref().GetErrorData());

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

 }
 
 size_t SBCommandReturnObject::PutOutput(FileSP file_sp) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutOutput, (FileSP),
                      file_sp);
   if (!file_sp)

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

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

 }
 
 size_t SBCommandReturnObject::PutError(FileSP file_sp) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutError, (FileSP),
                      file_sp);
   if (!file_sp)

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

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

 }
 
 void SBCommandReturnObject::SetStatus(lldb::ReturnStatus status) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetStatus,
                      (lldb::ReturnStatus), status);
 

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

 }
 
 void SBCommandReturnObject::AppendWarning(const char *message) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBCommandReturnObject, AppendWarning, (const char *),
                      message);
 

 }
 
 bool SBCommandReturnObject::GetDescription(SBStream &description) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBCommandReturnObject, GetDescription,
                      (lldb::SBStream &), description);
 

 }
 
 void SBCommandReturnObject::SetImmediateOutputFile(FILE *fh) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
                      (FILE *), fh);
 

 }
 
 void SBCommandReturnObject::SetImmediateErrorFile(FILE *fh) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
                      (FILE *), fh);
 

 
 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<NativeFile>(fh, transfer_ownership);

 
 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<NativeFile>(fh, transfer_ownership);

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

 }
 
 const char *SBCommandReturnObject::GetOutput(bool only_if_no_immediate) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(const char *, SBCommandReturnObject, GetOutput, (bool),
                      only_if_no_immediate);
 

 }
 
 const char *SBCommandReturnObject::GetError(bool only_if_no_immediate) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(const char *, SBCommandReturnObject, GetError, (bool),
                      only_if_no_immediate);
 

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

 }
 
 void SBCommandReturnObject::SetError(const char *error_cstr) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetError, (const char *),
                      error_cstr);
 

lldb/source/API/SBCommunication.cpp

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

 }
 
 void SBCommunication::SetCloseOnEOF(bool b) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBCommunication, SetCloseOnEOF, (bool), b);
 
   if (m_opaque)

 }
 
 ConnectionStatus SBCommunication::Connect(const char *url) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::ConnectionStatus, SBCommunication, Connect,
                      (const char *), url);
 

 }
 
 ConnectionStatus SBCommunication::AdoptFileDesriptor(int fd, bool owns_fd) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::ConnectionStatus, SBCommunication,
                      AdoptFileDesriptor, (int, bool), fd, owns_fd);
 

 }
 
 ConnectionStatus SBCommunication::Disconnect() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::ConnectionStatus, SBCommunication,
                              Disconnect);
 

 }
 
 bool SBCommunication::IsConnected() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommunication, IsConnected);
 
   return m_opaque ? m_opaque->IsConnected() : false;

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

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

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

 
 bool SBCommunication::SetReadThreadBytesReceivedCallback(
     ReadThreadBytesReceived callback, void *callback_baton) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBCommunication, SetReadThreadBytesReceivedCallback,
                      (lldb::SBCommunication::ReadThreadBytesReceived, void *),
                      callback, callback_baton);

 }
 
 SBBroadcaster SBCommunication::GetBroadcaster() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBroadcaster, SBCommunication,
                              GetBroadcaster);
 

lldb/source/API/SBCompileUnit.cpp

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

 SBCompileUnit::~SBCompileUnit() { m_opaque_ptr = nullptr; }
 
 SBFileSpec SBCompileUnit::GetFileSpec() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBCompileUnit,
                                    GetFileSpec);
 

 }
 
 uint32_t SBCompileUnit::GetNumLineEntries() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBCompileUnit, GetNumLineEntries);
 
   if (m_opaque_ptr) {

 }
 
 SBLineEntry SBCompileUnit::GetLineEntryAtIndex(uint32_t idx) const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST(lldb::SBLineEntry, SBCompileUnit,
                            GetLineEntryAtIndex, (uint32_t), idx);
 

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

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

 }
 
 uint32_t SBCompileUnit::GetNumSupportFiles() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBCompileUnit, GetNumSupportFiles);
 
   if (m_opaque_ptr)

 }
 
 lldb::SBTypeList SBCompileUnit::GetTypes(uint32_t type_mask) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBTypeList, SBCompileUnit, GetTypes, (uint32_t),
                      type_mask);
 

 }
 
 SBFileSpec SBCompileUnit::GetSupportFileAtIndex(uint32_t idx) const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST(lldb::SBFileSpec, SBCompileUnit,
                            GetSupportFileAtIndex, (uint32_t), idx);
 

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

 }
 
 lldb::LanguageType SBCompileUnit::GetLanguage() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::LanguageType, SBCompileUnit, GetLanguage);
 
   if (m_opaque_ptr)

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

 }
 
 bool SBCompileUnit::GetDescription(SBStream &description) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBCompileUnit, GetDescription, (lldb::SBStream &),
                      description);
 

lldb/source/API/SBData.cpp

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

 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;

 }
 
 void SBData::SetAddressByteSize(uint8_t addr_byte_size) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBData, SetAddressByteSize, (uint8_t),
                      addr_byte_size);
 

 }
 
 void SBData::Clear() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(void, SBData, Clear);
 
   if (m_opaque_sp.get())

 }
 
 size_t SBData::GetByteSize() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(size_t, SBData, GetByteSize);
 
   size_t value = 0;

 }
 
 lldb::ByteOrder SBData::GetByteOrder() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::ByteOrder, SBData, GetByteOrder);
 
   lldb::ByteOrder value = eByteOrderInvalid;

 }
 
 void SBData::SetByteOrder(lldb::ByteOrder endian) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBData, SetByteOrder, (lldb::ByteOrder), endian);
 
   if (m_opaque_sp.get())

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 
 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,

 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),

 }
 
 bool SBData::Append(const SBData &rhs) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBData, Append, (const lldb::SBData &), rhs);
 
   bool value = false;

 }
 
 bool SBData::SetDataFromCString(const char *data) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBData, SetDataFromCString, (const char *), data);
 
-
   if (!data) {
     return false;
   }

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

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

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

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

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

lldb/source/API/SBDebugger.cpp

                               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 &,

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

 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;

 }
 
 SBBroadcaster SBDebugger::GetBroadcaster() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBroadcaster, SBDebugger, GetBroadcaster);
   SBBroadcaster broadcaster(&m_opaque_sp->GetBroadcaster(), false);
   return broadcaster;

 }
 
 void SBDebugger::Clear() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, Clear);
 
   if (m_opaque_sp)

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

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

 }
 
 void SBDebugger::SkipAppInitFiles(bool b) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBDebugger, SkipAppInitFiles, (bool), b);
 
   if (m_opaque_sp)

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

 }
 
 SBError SBDebugger::SetInputString(const char *data) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(SBError, SBDebugger, SetInputString, (const char *), data);
   SBError sb_error;
   if (data == nullptr) {

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

 }
 
 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<NativeFile>(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) {

 }
 
 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<NativeFile>(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) {

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

 }
 
 SBFile SBDebugger::GetInputFile() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(SBFile, SBDebugger, GetInputFile);
   if (m_opaque_sp) {
     return SBFile(m_opaque_sp->GetInputFileSP());

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

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

 }
 
 FILE *SBDebugger::GetErrorFileHandle() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetErrorFileHandle);
 
   if (m_opaque_sp) {

 }
 
 SBFile SBDebugger::GetErrorFile() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(SBFile, SBDebugger, GetErrorFile);
   SBFile file;
   if (m_opaque_sp) {

 }
 
 void SBDebugger::SaveInputTerminalState() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, SaveInputTerminalState);
 
   if (m_opaque_sp)

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

 }
 
 void SBDebugger::HandleCommand(const char *command) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBDebugger, HandleCommand, (const char *), command);
 
   if (m_opaque_sp) {

 }
 
 SBListener SBDebugger::GetListener() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBDebugger, GetListener);
 
   SBListener sb_listener;

 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,

 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,

                                     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,

 }
 
 SBSourceManager SBDebugger::GetSourceManager() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSourceManager, SBDebugger,
                              GetSourceManager);
 

 
 ScriptLanguage
 SBDebugger::GetScriptingLanguage(const char *script_language_name) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::ScriptLanguage, SBDebugger, GetScriptingLanguage,
                      (const char *), script_language_name);
 

 
 SBStructuredData
 SBDebugger::GetScriptInterpreterInfo(lldb::ScriptLanguage language) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(SBStructuredData, SBDebugger, GetScriptInterpreterInfo,
                      (lldb::ScriptLanguage), language);
   SBStructuredData data;

                                         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 &),

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

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

 }
 
 SBTarget SBDebugger::CreateTarget(const char *filename) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, CreateTarget, (const char *),
                      filename);
 

 }
 
 SBTarget SBDebugger::GetDummyTarget() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBDebugger, GetDummyTarget);
 
   SBTarget sb_target;

 }
 
 bool SBDebugger::DeleteTarget(lldb::SBTarget &target) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBDebugger, DeleteTarget, (lldb::SBTarget &),
                      target);
 

 }
 
 SBTarget SBDebugger::GetTargetAtIndex(uint32_t idx) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, GetTargetAtIndex, (uint32_t),
                      idx);
 

 }
 
 uint32_t SBDebugger::GetIndexOfTarget(lldb::SBTarget target) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(uint32_t, SBDebugger, GetIndexOfTarget, (lldb::SBTarget),
                      target);
 

 }
 
 SBTarget SBDebugger::FindTargetWithProcessID(lldb::pid_t pid) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithProcessID,
                      (lldb::pid_t), pid);
 

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

 }
 
 uint32_t SBDebugger::GetNumTargets() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumTargets);
 
   if (m_opaque_sp) {

 }
 
 SBTarget SBDebugger::GetSelectedTarget() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBDebugger, GetSelectedTarget);
 
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));

 }
 
 void SBDebugger::SetSelectedTarget(SBTarget &sb_target) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBDebugger, SetSelectedTarget, (lldb::SBTarget &),
                      sb_target);
 

 }
 
 SBPlatform SBDebugger::GetSelectedPlatform() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBPlatform, SBDebugger, GetSelectedPlatform);
 
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));

 }
 
 void SBDebugger::SetSelectedPlatform(SBPlatform &sb_platform) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBDebugger, SetSelectedPlatform,
                      (lldb::SBPlatform &), sb_platform);
 

 }
 
 uint32_t SBDebugger::GetNumPlatforms() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumPlatforms);
 
   if (m_opaque_sp) {

 }
 
 SBPlatform SBDebugger::GetPlatformAtIndex(uint32_t idx) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBPlatform, SBDebugger, GetPlatformAtIndex,
                      (uint32_t), idx);
 

 }
 
 uint32_t SBDebugger::GetNumAvailablePlatforms() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumAvailablePlatforms);
 
   uint32_t idx = 0;

 }
 
 SBStructuredData SBDebugger::GetAvailablePlatformInfoAtIndex(uint32_t idx) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBStructuredData, SBDebugger,
                      GetAvailablePlatformInfoAtIndex, (uint32_t), idx);
 

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

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

 }
 
 void SBDebugger::DispatchInputInterrupt() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, DispatchInputInterrupt);
 
   if (m_opaque_sp)

 }
 
 void SBDebugger::DispatchInputEndOfFile() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, DispatchInputEndOfFile);
 
   if (m_opaque_sp)

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

                                        bool &stopped_for_crash)
 
 {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBDebugger, RunCommandInterpreter,
                      (bool, bool, lldb::SBCommandInterpreterRunOptions &, int &,
                       bool &, bool &),

 
 SBCommandInterpreterRunResult SBDebugger::RunCommandInterpreter(
     const SBCommandInterpreterRunOptions &options) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBCommandInterpreterRunResult, SBDebugger,
                      RunCommandInterpreter,
                      (const lldb::SBCommandInterpreterRunOptions &), options);

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

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

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

 }
 
 const char *SBDebugger::GetPrompt() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBDebugger, GetPrompt);
 
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));

 }
 
 void SBDebugger::SetPrompt(const char *prompt) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBDebugger, SetPrompt, (const char *), prompt);
 
   if (m_opaque_sp)

 }
 
 const char *SBDebugger::GetReproducerPath() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBDebugger, GetReproducerPath);
 
   return (m_opaque_sp

 }
 
 ScriptLanguage SBDebugger::GetScriptLanguage() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ScriptLanguage, SBDebugger,
                                    GetScriptLanguage);
 

 }
 
 void SBDebugger::SetScriptLanguage(ScriptLanguage script_lang) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBDebugger, SetScriptLanguage,
                      (lldb::ScriptLanguage), script_lang);
 

 }
 
 LanguageType SBDebugger::GetREPLLanguage() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::LanguageType, SBDebugger,
                                    GetREPLLanguage);
 

 }
 
 void SBDebugger::SetREPLLanguage(LanguageType repl_lang) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBDebugger, SetREPLLanguage, (lldb::LanguageType),
                      repl_lang);
 

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

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

 }
 
 bool SBDebugger::SetCurrentPlatformSDKRoot(const char *sysroot) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBDebugger, SetCurrentPlatformSDKRoot,
                      (const char *), sysroot);
 

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

 }
 
 SBTypeCategory SBDebugger::GetCategory(const char *category_name) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory,
                      (const char *), category_name);
 

 }
 
 SBTypeCategory SBDebugger::GetCategory(lldb::LanguageType lang_type) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory,
                      (lldb::LanguageType), lang_type);
 

 }
 
 SBTypeCategory SBDebugger::CreateCategory(const char *category_name) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, CreateCategory,
                      (const char *), category_name);
 

 }
 
 bool SBDebugger::DeleteCategory(const char *category_name) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBDebugger, DeleteCategory, (const char *),
                      category_name);
 

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

 }
 
 SBTypeCategory SBDebugger::GetDefaultCategory() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeCategory, SBDebugger,
                              GetDefaultCategory);
 

 }
 
 SBTypeFormat SBDebugger::GetFormatForType(SBTypeNameSpecifier type_name) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBDebugger, GetFormatForType,
                      (lldb::SBTypeNameSpecifier), type_name);
 

 }
 
 SBTypeSummary SBDebugger::GetSummaryForType(SBTypeNameSpecifier type_name) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBDebugger, GetSummaryForType,
                      (lldb::SBTypeNameSpecifier), type_name);
 

 }
 
 SBTypeFilter SBDebugger::GetFilterForType(SBTypeNameSpecifier type_name) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBDebugger, GetFilterForType,
                      (lldb::SBTypeNameSpecifier), type_name);
 

 }
 
 SBTypeSynthetic SBDebugger::GetSyntheticForType(SBTypeNameSpecifier type_name) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBDebugger, GetSyntheticForType,
                      (lldb::SBTypeNameSpecifier), type_name);
 

 }
 
 bool SBDebugger::EnableLog(const char *channel, const char **categories) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBDebugger, EnableLog, (const char *, const char **),
                      channel, categories);
 

 
 void SBDebugger::SetLoggingCallback(lldb::LogOutputCallback log_callback,
                                     void *baton) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBDebugger, SetLoggingCallback,
                      (lldb::LogOutputCallback, void *), log_callback, baton);
 

lldb/source/API/SBDeclaration.cpp

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

 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());

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

 }
 
 uint32_t SBDeclaration::GetColumn() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBDeclaration, GetColumn);
 
   if (m_opaque_up)

 }
 
 void SBDeclaration::SetFileSpec(lldb::SBFileSpec filespec) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBDeclaration, SetFileSpec, (lldb::SBFileSpec),
                      filespec);
 

     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();

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

 }
 
 bool SBDeclaration::GetDescription(SBStream &description) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBDeclaration, GetDescription, (lldb::SBStream &),
                      description);
 

lldb/source/API/SBEnvironment.cpp

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

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

 }
 
 const char *SBEnvironment::GetNameAtIndex(size_t index) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(const char *, SBEnvironment, GetNameAtIndex, (size_t),
                      index);
 

 }
 
 const char *SBEnvironment::GetValueAtIndex(size_t index) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(const char *, SBEnvironment, GetValueAtIndex, (size_t),
                      index);
 

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

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

 }
 
 void SBEnvironment::PutEntry(const char *name_and_value) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBEnvironment, PutEntry, (const char *),
                      name_and_value);
 

 }
 
 void SBEnvironment::SetEntries(const SBStringList &entries, bool append) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBEnvironment, SetEntries,
                      (const lldb::SBStringList &, bool), entries, append);
 

 }
 
 void SBEnvironment::Clear() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(void, SBEnvironment, Clear);
 
   m_opaque_up->clear();

lldb/source/API/SBError.cpp

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

 }
 
 const char *SBError::GetCString() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBError, GetCString);
 
   if (m_opaque_up)

 }
 
 void SBError::Clear() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(void, SBError, Clear);
 
   if (m_opaque_up)

 }
 
 bool SBError::Fail() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, Fail);
 
   bool ret_value = false;

 }
 
 bool SBError::Success() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, Success);
 
   bool ret_value = true;

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

 }
 
 ErrorType SBError::GetType() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ErrorType, SBError, GetType);
 
   ErrorType err_type = eErrorTypeInvalid;

 }
 
 void SBError::SetError(uint32_t err, ErrorType type) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBError, SetError, (uint32_t, lldb::ErrorType), err,
                      type);
 

 }
 
 void SBError::SetErrorToErrno() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(void, SBError, SetErrorToErrno);
 
   CreateIfNeeded();

 }
 
 void SBError::SetErrorToGenericError() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(void, SBError, SetErrorToGenericError);
 
   CreateIfNeeded();

 }
 
 void SBError::SetErrorString(const char *err_str) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBError, SetErrorString, (const char *), err_str);
 
   CreateIfNeeded();

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

 }
 
 bool SBError::GetDescription(SBStream &description) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBError, GetDescription, (lldb::SBStream &),
                      description);
 

lldb/source/API/SBEvent.cpp

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

 SBEvent::~SBEvent() = default;
 
 const char *SBEvent::GetDataFlavor() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBEvent, GetDataFlavor);
 
   Event *lldb_event = get();

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

 }
 
 SBBroadcaster SBEvent::GetBroadcaster() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBEvent,
                                    GetBroadcaster);
 

 }
 
 const char *SBEvent::GetBroadcasterClass() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBEvent, GetBroadcasterClass);
 
   const Event *lldb_event = get();

 }
 
 bool SBEvent::BroadcasterMatchesPtr(const SBBroadcaster *broadcaster) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBEvent, BroadcasterMatchesPtr,
                      (const lldb::SBBroadcaster *), broadcaster);
 

 }
 
 bool SBEvent::BroadcasterMatchesRef(const SBBroadcaster &broadcaster) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBEvent, BroadcasterMatchesRef,
                      (const lldb::SBBroadcaster &), broadcaster);
 

 }
 
 void SBEvent::Clear() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(void, SBEvent, Clear);
 
   Event *lldb_event = get();

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

 }
 
 bool SBEvent::GetDescription(SBStream &description) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBEvent, GetDescription, (lldb::SBStream &),
                      description);
 

 }
 
 bool SBEvent::GetDescription(SBStream &description) const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST(bool, SBEvent, GetDescription, (lldb::SBStream &),
                            description);
 

lldb/source/API/SBExecutionContext.cpp

 
 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;

 }
 
 SBTarget SBExecutionContext::GetTarget() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBTarget, SBExecutionContext,
                                    GetTarget);
 

 }
 
 SBProcess SBExecutionContext::GetProcess() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBProcess, SBExecutionContext,
                                    GetProcess);
 

 }
 
 SBThread SBExecutionContext::GetThread() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBExecutionContext,
                                    GetThread);
 

 }
 
 SBFrame SBExecutionContext::GetFrame() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFrame, SBExecutionContext, GetFrame);
 
   SBFrame sb_frame;

lldb/source/API/SBExpressionOptions.cpp

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

 SBExpressionOptions::~SBExpressionOptions() = default;
 
 bool SBExpressionOptions::GetCoerceResultToId() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions,
                                    GetCoerceResultToId);
 

 }
 
 void SBExpressionOptions::SetCoerceResultToId(bool coerce) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBExpressionOptions, SetCoerceResultToId, (bool),
                      coerce);
 

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

 }
 
 bool SBExpressionOptions::GetIgnoreBreakpoints() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions,
                                    GetIgnoreBreakpoints);
 

 }
 
 void SBExpressionOptions::SetIgnoreBreakpoints(bool ignore) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBExpressionOptions, SetIgnoreBreakpoints, (bool),
                      ignore);
 

 }
 
 lldb::DynamicValueType SBExpressionOptions::GetFetchDynamicValue() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::DynamicValueType, SBExpressionOptions,
                                    GetFetchDynamicValue);
 

 }
 
 void SBExpressionOptions::SetFetchDynamicValue(lldb::DynamicValueType dynamic) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBExpressionOptions, SetFetchDynamicValue,
                      (lldb::DynamicValueType), dynamic);
 

 }
 
 uint32_t SBExpressionOptions::GetTimeoutInMicroSeconds() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBExpressionOptions,
                                    GetTimeoutInMicroSeconds);
 

 }
 
 void SBExpressionOptions::SetTimeoutInMicroSeconds(uint32_t timeout) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTimeoutInMicroSeconds,
                      (uint32_t), timeout);
 

 }
 
 uint32_t SBExpressionOptions::GetOneThreadTimeoutInMicroSeconds() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBExpressionOptions,
                                    GetOneThreadTimeoutInMicroSeconds);
 

 }
 
 void SBExpressionOptions::SetOneThreadTimeoutInMicroSeconds(uint32_t timeout) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBExpressionOptions,
                      SetOneThreadTimeoutInMicroSeconds, (uint32_t), timeout);
 

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

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

 }
 
 bool SBExpressionOptions::GetTrapExceptions() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions,
                                    GetTrapExceptions);
 

 }
 
 void SBExpressionOptions::SetTrapExceptions(bool trap_exceptions) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTrapExceptions, (bool),
                      trap_exceptions);
 

 }
 
 void SBExpressionOptions::SetLanguage(lldb::LanguageType language) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBExpressionOptions, SetLanguage,
                      (lldb::LanguageType), language);
 

 
 void SBExpressionOptions::SetCancelCallback(
     lldb::ExpressionCancelCallback callback, void *baton) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBExpressionOptions, SetCancelCallback,
                      (lldb::ExpressionCancelCallback, void *), callback, baton);
 

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

 }
 
 bool SBExpressionOptions::GetSuppressPersistentResult() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions,
                              GetSuppressPersistentResult);
 

 }
 
 void SBExpressionOptions::SetSuppressPersistentResult(bool b) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBExpressionOptions, SetSuppressPersistentResult,
                      (bool), b);
 

 }
 
 const char *SBExpressionOptions::GetPrefix() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBExpressionOptions,
                                    GetPrefix);
 

 }
 
 void SBExpressionOptions::SetPrefix(const char *prefix) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBExpressionOptions, SetPrefix, (const char *),
                      prefix);
 

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

 }
 
 void SBExpressionOptions::SetRetriesWithFixIts(uint64_t retries) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBExpressionOptions, SetRetriesWithFixIts,
                      (uint64_t), retries);
 

 }
 
 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

 }
 
 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

lldb/source/API/SBFile.cpp

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

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

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

 }
 
 SBError SBFile::Flush() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBFile, Flush);
 
   SBError error;

 }
 
 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) {

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

lldb/source/API/SBFileSpec.cpp

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

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

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

 }
 
 void SBFileSpec::SetFilename(const char *filename) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBFileSpec, SetFilename, (const char *), filename);
 
   if (filename && filename[0])

 }
 
 void SBFileSpec::SetDirectory(const char *directory) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBFileSpec, SetDirectory, (const char *), directory);
 
   if (directory && directory[0])

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

 }
 
 bool SBFileSpec::GetDescription(SBStream &description) const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST(bool, SBFileSpec, GetDescription, (lldb::SBStream &),
                            description);
 

 }
 
 void SBFileSpec::AppendPathComponent(const char *fn) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBFileSpec, AppendPathComponent, (const char *), fn);
 
   m_opaque_up->AppendPathComponent(fn);

lldb/source/API/SBFileSpecList.cpp

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

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

 }
 
 bool SBFileSpecList::AppendIfUnique(const SBFileSpec &sb_file) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBFileSpecList, AppendIfUnique,
                      (const lldb::SBFileSpec &), sb_file);
 

 }
 
 void SBFileSpecList::Clear() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(void, SBFileSpecList, Clear);
 
   m_opaque_up->Clear();

 
 uint32_t SBFileSpecList::FindFileIndex(uint32_t idx, const SBFileSpec &sb_file,
                                        bool full) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(uint32_t, SBFileSpecList, FindFileIndex,
                      (uint32_t, const lldb::SBFileSpec &, bool), idx, sb_file,
                      full);

 }
 
 const SBFileSpec SBFileSpecList::GetFileSpecAtIndex(uint32_t idx) const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST(const lldb::SBFileSpec, SBFileSpecList,
                            GetFileSpecAtIndex, (uint32_t), idx);
 

 }
 
 bool SBFileSpecList::GetDescription(SBStream &description) const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST(bool, SBFileSpecList, GetDescription,
                            (lldb::SBStream &), description);
 

lldb/source/API/SBFrame.cpp

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

 }
 
 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<std::recursive_mutex> lock;

 }
 
 SBSymbolContext SBFrame::GetSymbolContext(uint32_t resolve_scope) const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST(lldb::SBSymbolContext, SBFrame, GetSymbolContext,
                            (uint32_t), resolve_scope);
 

 }
 
 SBModule SBFrame::GetModule() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBModule, SBFrame, GetModule);
 
   SBModule sb_module;

 }
 
 SBCompileUnit SBFrame::GetCompileUnit() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBCompileUnit, SBFrame,
                                    GetCompileUnit);
 

 }
 
 SBFunction SBFrame::GetFunction() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFunction, SBFrame, GetFunction);
 
   SBFunction sb_function;

 }
 
 SBSymbol SBFrame::GetSymbol() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBSymbol, SBFrame, GetSymbol);
 
   SBSymbol sb_symbol;

 }
 
 SBBlock SBFrame::GetBlock() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBlock, SBFrame, GetBlock);
 
   SBBlock sb_block;

 }
 
 SBBlock SBFrame::GetFrameBlock() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBlock, SBFrame, GetFrameBlock);
 
   SBBlock sb_block;

 }
 
 SBLineEntry SBFrame::GetLineEntry() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBLineEntry, SBFrame, GetLineEntry);
 
   SBLineEntry sb_line_entry;

 }
 
 uint32_t SBFrame::GetFrameID() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBFrame, GetFrameID);
 
   uint32_t frame_idx = UINT32_MAX;

 }
 
 lldb::addr_t SBFrame::GetCFA() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetCFA);
 
   std::unique_lock<std::recursive_mutex> lock;

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

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

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

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

 }
 
 SBAddress SBFrame::GetPCAddress() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBFrame, GetPCAddress);
 
   SBAddress sb_addr;

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

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

 }
 
 SBValue SBFrame::FindVariable(const char *name) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindVariable, (const char *),
                      name);
 

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

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

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

 }
 
 bool SBFrame::IsEqual(const SBFrame &that) const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST(bool, SBFrame, IsEqual, (const lldb::SBFrame &),
                            that);
 

 }
 
 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<std::recursive_mutex> lock;

 }
 
 const char *SBFrame::Disassemble() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFrame, Disassemble);
 
   const char *disassembly = nullptr;

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

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

 }
 
 SBValueList SBFrame::GetVariables(const lldb::SBVariablesOptions &options) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables,
                      (const lldb::SBVariablesOptions &), options);
 

 }
 
 SBValueList SBFrame::GetRegisters() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValueList, SBFrame, GetRegisters);
 
   SBValueList value_list;

 }
 
 SBValue SBFrame::FindRegister(const char *name) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindRegister, (const char *),
                      name);
 

 }
 
 bool SBFrame::GetDescription(SBStream &description) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBFrame, GetDescription, (lldb::SBStream &),
                      description);
 

 }
 
 SBValue SBFrame::EvaluateExpression(const char *expr) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression, (const char *),
                      expr);
 

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

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

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

 }
 
 bool SBFrame::IsInlined() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBFrame, IsInlined);
 
   return static_cast<const SBFrame *>(this)->IsInlined();
 }
 
 bool SBFrame::IsInlined() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsInlined);
 
   std::unique_lock<std::recursive_mutex> lock;

 }
 
 bool SBFrame::IsArtificial() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBFrame, IsArtificial);
 
   return static_cast<const SBFrame *>(this)->IsArtificial();
 }
 
 bool SBFrame::IsArtificial() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsArtificial);
 
   std::unique_lock<std::recursive_mutex> lock;

 }
 
 const char *SBFrame::GetFunctionName() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBFrame, GetFunctionName);
 
   return static_cast<const SBFrame *>(this)->GetFunctionName();
 }
 
 lldb::LanguageType SBFrame::GuessLanguage() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::LanguageType, SBFrame, GuessLanguage);
 
   std::unique_lock<std::recursive_mutex> lock;

 }
 
 const char *SBFrame::GetFunctionName() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFrame, GetFunctionName);
 
   const char *name = nullptr;

 }
 
 const char *SBFrame::GetDisplayFunctionName() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBFrame, GetDisplayFunctionName);
 
   const char *name = nullptr;

lldb/source/API/SBFunction.cpp

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

 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;

 }
 
 const char *SBFunction::GetDisplayName() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFunction, GetDisplayName);
 
   const char *cstr = nullptr;

 }
 
 const char *SBFunction::GetMangledName() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFunction, GetMangledName);
 
   const char *cstr = nullptr;

 }
 
 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) {

 }
 
 SBInstructionList SBFunction::GetInstructions(SBTarget target) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions,
                      (lldb::SBTarget), target);
 

 
 SBInstructionList SBFunction::GetInstructions(SBTarget target,
                                               const char *flavor) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions,
                      (lldb::SBTarget, const char *), target, flavor);
 

 }
 
 SBAddress SBFunction::GetStartAddress() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBFunction, GetStartAddress);
 
   SBAddress addr;

 }
 
 SBAddress SBFunction::GetEndAddress() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBFunction, GetEndAddress);
 
   SBAddress addr;

 }
 
 const char *SBFunction::GetArgumentName(uint32_t arg_idx) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(const char *, SBFunction, GetArgumentName, (uint32_t),
                      arg_idx);
 

 }
 
 uint32_t SBFunction::GetPrologueByteSize() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBFunction, GetPrologueByteSize);
 
   if (m_opaque_ptr)

 }
 
 SBType SBFunction::GetType() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBFunction, GetType);
 
   SBType sb_type;

 }
 
 SBBlock SBFunction::GetBlock() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBFunction, GetBlock);
 
   SBBlock sb_block;

 }
 
 lldb::LanguageType SBFunction::GetLanguage() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::LanguageType, SBFunction, GetLanguage);
 
   if (m_opaque_ptr) {

 }
 
 bool SBFunction::GetIsOptimized() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBFunction, GetIsOptimized);
 
   if (m_opaque_ptr) {

lldb/source/API/SBInstruction.cpp

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

 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;

 }
 
 const char *SBInstruction::GetMnemonic(SBTarget target) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(const char *, SBInstruction, GetMnemonic, (lldb::SBTarget),
                      target);
 

 }
 
 const char *SBInstruction::GetOperands(SBTarget target) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(const char *, SBInstruction, GetOperands, (lldb::SBTarget),
                      target);
 

 }
 
 const char *SBInstruction::GetComment(SBTarget target) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(const char *, SBInstruction, GetComment, (lldb::SBTarget),
                      target);
 

 }
 
 size_t SBInstruction::GetByteSize() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(size_t, SBInstruction, GetByteSize);
 
   lldb::InstructionSP inst_sp(GetOpaque());

 }
 
 SBData SBInstruction::GetData(SBTarget target) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBData, SBInstruction, GetData, (lldb::SBTarget),
                      target);
 

 }
 
 bool SBInstruction::DoesBranch() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, DoesBranch);
 
   lldb::InstructionSP inst_sp(GetOpaque());

 }
 
 bool SBInstruction::HasDelaySlot() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, HasDelaySlot);
 
   lldb::InstructionSP inst_sp(GetOpaque());

 }
 
 bool SBInstruction::CanSetBreakpoint() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, CanSetBreakpoint);
 
   lldb::InstructionSP inst_sp(GetOpaque());

 }
 
 bool SBInstruction::GetDescription(lldb::SBStream &s) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBInstruction, GetDescription, (lldb::SBStream &),
                      s);
 

 }
 
 void SBInstruction::Print(FILE *outp) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBInstruction, Print, (FILE *), outp);
   FileSP out = std::make_shared<NativeFile>(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())

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

 }
 
 bool SBInstruction::DumpEmulation(const char *triple) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBInstruction, DumpEmulation, (const char *),
                      triple);
 

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

lldb/source/API/SBInstructionList.cpp

 
 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;

 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)

 }
 
 SBInstruction SBInstructionList::GetInstructionAtIndex(uint32_t idx) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBInstruction, SBInstructionList,
                      GetInstructionAtIndex, (uint32_t), idx);
 

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

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

 }
 
 void SBInstructionList::Print(FILE *out) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBInstructionList, Print, (FILE *), out);
   if (out == nullptr)
     return;

 }
 
 void SBInstructionList::Print(SBFile out) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBInstructionList, Print, (SBFile), out);
   if (!out.IsValid())
     return;

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

 }
 
 bool SBInstructionList::GetDescription(lldb::SBStream &stream) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBInstructionList, GetDescription,
                      (lldb::SBStream &), stream);
   return GetDescription(stream.ref());

 }
 
 bool SBInstructionList::DumpEmulationForAllInstructions(const char *triple) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBInstructionList, DumpEmulationForAllInstructions,
                      (const char *), triple);
 

lldb/source/API/SBLaunchInfo.cpp

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

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

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

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

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

 }
 
 void SBLaunchInfo::SetArguments(const char **argv, bool append) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBLaunchInfo, SetArguments, (const char **, bool),
                      argv, append);
 

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

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

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

 }
 
 void SBLaunchInfo::SetWorkingDirectory(const char *working_dir) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBLaunchInfo, SetWorkingDirectory, (const char *),
                      working_dir);
 

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

 }
 
 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

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

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

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

 }
 
 bool SBLaunchInfo::AddSuppressFileAction(int fd, bool read, bool write) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddSuppressFileAction,
                      (int, bool, bool), fd, read, write);
 

 }
 
 void SBLaunchInfo::SetLaunchEventData(const char *data) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBLaunchInfo, SetLaunchEventData, (const char *),
                      data);
 

 }
 
 const char *SBLaunchInfo::GetLaunchEventData() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBLaunchInfo,
                                    GetLaunchEventData);
 

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

 }
 
 void SBLaunchInfo::SetScriptedProcessClassName(const char *class_name) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBLaunchInfo, SetScriptedProcessClassName,
                      (const char *), class_name);
 

 }
 
 lldb::SBStructuredData SBLaunchInfo::GetScriptedProcessDictionary() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBStructuredData, SBLaunchInfo,
                                    GetScriptedProcessDictionary);
 

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

lldb/source/API/SBLineEntry.cpp

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

 SBLineEntry::~SBLineEntry() = default;
 
 SBAddress SBLineEntry::GetStartAddress() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBLineEntry,
                                    GetStartAddress);
 

 }
 
 SBAddress SBLineEntry::GetEndAddress() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBLineEntry, GetEndAddress);
 
   SBAddress sb_address;

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

 }
 
 uint32_t SBLineEntry::GetLine() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBLineEntry, GetLine);
 
   uint32_t line = 0;

 }
 
 uint32_t SBLineEntry::GetColumn() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBLineEntry, GetColumn);
 
   if (m_opaque_up)

 }
 
 void SBLineEntry::SetFileSpec(lldb::SBFileSpec filespec) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBLineEntry, SetFileSpec, (lldb::SBFileSpec),
                      filespec);
 

     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();

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

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

lldb/source/API/SBListener.cpp

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

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

 }
 
 void SBListener::Clear() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(void, SBListener, Clear);
 
   if (m_opaque_sp)

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

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

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

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

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

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

 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 &),

 }
 
 bool SBListener::PeekAtNextEvent(SBEvent &event) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBListener, PeekAtNextEvent, (lldb::SBEvent &),
                      event);
 

 
 bool SBListener::PeekAtNextEventForBroadcaster(const SBBroadcaster &broadcaster,
                                                SBEvent &event) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBListener, PeekAtNextEventForBroadcaster,
                      (const lldb::SBBroadcaster &, lldb::SBEvent &),
                      broadcaster, event);

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

 }
 
 bool SBListener::GetNextEvent(SBEvent &event) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBListener, GetNextEvent, (lldb::SBEvent &), event);
 
   if (m_opaque_sp) {

 
 bool SBListener::GetNextEventForBroadcaster(const SBBroadcaster &broadcaster,
                                             SBEvent &event) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBListener, GetNextEventForBroadcaster,
                      (const lldb::SBBroadcaster &, lldb::SBEvent &),
                      broadcaster, event);

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

 }
 
 bool SBListener::HandleBroadcastEvent(const SBEvent &event) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBListener, HandleBroadcastEvent,
                      (const lldb::SBEvent &), event);
 

lldb/source/API/SBMemoryRegionInfo.cpp

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

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

 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;

 }
 
 addr_t SBMemoryRegionInfo::GetDirtyPageAddressAtIndex(uint32_t idx) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::addr_t, SBMemoryRegionInfo,
                      GetDirtyPageAddressAtIndex, (uint32_t), idx);
 

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

lldb/source/API/SBMemoryRegionInfoList.cpp

 
 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;

 }
 
 uint32_t SBMemoryRegionInfoList::GetSize() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBMemoryRegionInfoList, GetSize);
 
   return m_opaque_up->GetSize();

 
 bool SBMemoryRegionInfoList::GetMemoryRegionContainingAddress(
     lldb::addr_t addr, SBMemoryRegionInfo &region_info) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(
       bool, SBMemoryRegionInfoList, GetMemoryRegionContainingAddress,
       (lldb::addr_t, lldb::SBMemoryRegionInfo &), addr, region_info);

 
 bool SBMemoryRegionInfoList::GetMemoryRegionAtIndex(
     uint32_t idx, SBMemoryRegionInfo &region_info) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBMemoryRegionInfoList, GetMemoryRegionAtIndex,
                      (uint32_t, lldb::SBMemoryRegionInfo &), idx, region_info);
 

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

 }
 
 void SBMemoryRegionInfoList::Append(SBMemoryRegionInfoList &sb_region_list) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBMemoryRegionInfoList, Append,
                      (lldb::SBMemoryRegionInfoList &), sb_region_list);
 

lldb/source/API/SBModule.cpp

 }
 
 const SBModule &SBModule::operator=(const SBModule &rhs) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(const lldb::SBModule &, SBModule, operator=,
                      (const lldb::SBModule &), rhs);
 

 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;

 }
 
 lldb::SBFileSpec SBModule::GetPlatformFileSpec() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule,
                                    GetPlatformFileSpec);
 

 }
 
 bool SBModule::SetPlatformFileSpec(const lldb::SBFileSpec &platform_file) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBModule, SetPlatformFileSpec,
                      (const lldb::SBFileSpec &), platform_file);
 

 }
 
 lldb::SBFileSpec SBModule::GetRemoteInstallFileSpec() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModule,
                              GetRemoteInstallFileSpec);
 

 }
 
 bool SBModule::SetRemoteInstallFileSpec(lldb::SBFileSpec &file) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBModule, SetRemoteInstallFileSpec,
                      (lldb::SBFileSpec &), file);
 

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

 }
 
 const char *SBModule::GetUUIDString() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBModule, GetUUIDString);
 
   const char *uuid_cstr = nullptr;

 }
 
 bool SBModule::operator==(const SBModule &rhs) const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST(bool, SBModule, operator==, (const lldb::SBModule &),
                            rhs);
 

 }
 
 bool SBModule::operator!=(const SBModule &rhs) const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST(bool, SBModule, operator!=, (const lldb::SBModule &),
                            rhs);
 

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

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

 }
 
 bool SBModule::GetDescription(SBStream &description) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBModule, GetDescription, (lldb::SBStream &),
                      description);
 

 }
 
 uint32_t SBModule::GetNumCompileUnits() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBModule, GetNumCompileUnits);
 
   ModuleSP module_sp(GetSP());

 }
 
 SBCompileUnit SBModule::GetCompileUnitAtIndex(uint32_t index) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBCompileUnit, SBModule, GetCompileUnitAtIndex,
                      (uint32_t), index);
 

 }
 
 SBSymbolContextList SBModule::FindCompileUnits(const SBFileSpec &sb_file_spec) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBModule, FindCompileUnits,
                      (const lldb::SBFileSpec &), sb_file_spec);
 

 }
 
 size_t SBModule::GetNumSymbols() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModule, GetNumSymbols);
 
   ModuleSP module_sp(GetSP());

 }
 
 SBSymbol SBModule::GetSymbolAtIndex(size_t idx) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBSymbol, SBModule, GetSymbolAtIndex, (size_t), idx);
 
   SBSymbol sb_symbol;

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

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

 }
 
 size_t SBModule::GetNumSections() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModule, GetNumSections);
 
   ModuleSP module_sp(GetSP());

 }
 
 SBSection SBModule::GetSectionAtIndex(size_t idx) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBSection, SBModule, GetSectionAtIndex, (size_t),
                      idx);
 

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

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

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

 }
 
 lldb::SBType SBModule::FindFirstType(const char *name_cstr) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBType, SBModule, FindFirstType, (const char *),
                      name_cstr);
 

 }
 
 lldb::SBType SBModule::GetBasicType(lldb::BasicType type) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBType, SBModule, GetBasicType, (lldb::BasicType),
                      type);
 

 }
 
 lldb::SBTypeList SBModule::FindTypes(const char *type) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBTypeList, SBModule, FindTypes, (const char *),
                      type);
 

 }
 
 lldb::SBType SBModule::GetTypeByID(lldb::user_id_t uid) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBType, SBModule, GetTypeByID, (lldb::user_id_t),
                      uid);
 

 }
 
 lldb::SBTypeList SBModule::GetTypes(uint32_t type_mask) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBTypeList, SBModule, GetTypes, (uint32_t),
                      type_mask);
 

 }
 
 SBSection SBModule::FindSection(const char *sect_name) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBSection, SBModule, FindSection, (const char *),
                      sect_name);
 

 }
 
 lldb::ByteOrder SBModule::GetByteOrder() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::ByteOrder, SBModule, GetByteOrder);
 
   ModuleSP module_sp(GetSP());

 }
 
 const char *SBModule::GetTriple() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBModule, GetTriple);
 
   ModuleSP module_sp(GetSP());

 }
 
 uint32_t SBModule::GetAddressByteSize() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBModule, GetAddressByteSize);
 
   ModuleSP module_sp(GetSP());

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

 }
 
 lldb::SBFileSpec SBModule::GetSymbolFileSpec() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule,
                                    GetSymbolFileSpec);
 

 }
 
 lldb::SBAddress SBModule::GetObjectFileHeaderAddress() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBModule,
                                    GetObjectFileHeaderAddress);
 

 }
 
 lldb::SBAddress SBModule::GetObjectFileEntryPointAddress() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBModule,
                                    GetObjectFileEntryPointAddress);
 

lldb/source/API/SBModuleSpec.cpp

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

 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());

 }
 
 void SBModuleSpec::SetFileSpec(const lldb::SBFileSpec &sb_spec) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBModuleSpec, SetFileSpec,
                      (const lldb::SBFileSpec &), sb_spec);
 

 }
 
 lldb::SBFileSpec SBModuleSpec::GetPlatformFileSpec() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModuleSpec,
                              GetPlatformFileSpec);
 

 }
 
 void SBModuleSpec::SetPlatformFileSpec(const lldb::SBFileSpec &sb_spec) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBModuleSpec, SetPlatformFileSpec,
                      (const lldb::SBFileSpec &), sb_spec);
 

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

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

 }
 
 void SBModuleSpec::SetTriple(const char *triple) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBModuleSpec, SetTriple, (const char *), triple);
 
   m_opaque_up->GetArchitecture().SetTriple(triple);

 }
 
 size_t SBModuleSpec::GetUUIDLength() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModuleSpec, GetUUIDLength);
 
   return m_opaque_up->GetUUID().GetBytes().size();

 }
 
 bool SBModuleSpec::GetDescription(lldb::SBStream &description) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBModuleSpec, GetDescription, (lldb::SBStream &),
                      description);
 

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

 }
 
 void SBModuleSpecList::Append(const SBModuleSpec &spec) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBModuleSpecList, Append,
                      (const lldb::SBModuleSpec &), spec);
 

 }
 
 void SBModuleSpecList::Append(const SBModuleSpecList &spec_list) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBModuleSpecList, Append,
                      (const lldb::SBModuleSpecList &), spec_list);
 

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

 
 SBModuleSpec
 SBModuleSpecList::FindFirstMatchingSpec(const SBModuleSpec &match_spec) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBModuleSpec, SBModuleSpecList,
                      FindFirstMatchingSpec, (const lldb::SBModuleSpec &),
                      match_spec);

 
 SBModuleSpecList
 SBModuleSpecList::FindMatchingSpecs(const SBModuleSpec &match_spec) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBModuleSpecList, SBModuleSpecList,
                      FindMatchingSpecs, (const lldb::SBModuleSpec &),
                      match_spec);

 }
 
 bool SBModuleSpecList::GetDescription(lldb::SBStream &description) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBModuleSpecList, GetDescription, (lldb::SBStream &),
                      description);
 

lldb/source/API/SBPlatform.cpp

 
 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())

 }
 
 void SBPlatformConnectOptions::SetURL(const char *url) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBPlatformConnectOptions, SetURL, (const char *),
                      url);
 

 }
 
 bool SBPlatformConnectOptions::GetRsyncEnabled() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBPlatformConnectOptions, GetRsyncEnabled);
 
   return m_opaque_ptr->m_rsync_enabled;

 void SBPlatformConnectOptions::EnableRsync(
     const char *options, const char *remote_path_prefix,
     bool omit_hostname_from_remote_path) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBPlatformConnectOptions, EnableRsync,
                      (const char *, const char *, bool), options,
                      remote_path_prefix, omit_hostname_from_remote_path);

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

 }
 
 void SBPlatformConnectOptions::SetLocalCacheDirectory(const char *path) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBPlatformConnectOptions, SetLocalCacheDirectory,
                      (const char *), path);
 

 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;

 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();

 }
 
 const char *SBPlatformShellCommand::GetShell() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand, GetShell);
 
   if (m_opaque_ptr->m_shell.empty())

 }
 
 void SBPlatformShellCommand::SetShell(const char *shell_interpreter) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetShell, (const char *),
                      shell_interpreter);
 

 }
 
 const char *SBPlatformShellCommand::GetCommand() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand, GetCommand);
 
   if (m_opaque_ptr->m_command.empty())

 }
 
 void SBPlatformShellCommand::SetCommand(const char *shell_command) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetCommand, (const char *),
                      shell_command);
 

 }
 
 const char *SBPlatformShellCommand::GetWorkingDirectory() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand,
                              GetWorkingDirectory);
 

 }
 
 void SBPlatformShellCommand::SetWorkingDirectory(const char *path) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetWorkingDirectory,
                      (const char *), path);
 

 }
 
 uint32_t SBPlatformShellCommand::GetTimeoutSeconds() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatformShellCommand,
                              GetTimeoutSeconds);
 

 }
 
 void SBPlatformShellCommand::SetTimeoutSeconds(uint32_t sec) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetTimeoutSeconds,
                      (uint32_t), sec);
 

 }
 
 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())

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

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

 }
 
 const char *SBPlatform::GetWorkingDirectory() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetWorkingDirectory);
 
   PlatformSP platform_sp(GetSP());

 }
 
 bool SBPlatform::SetWorkingDirectory(const char *path) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBPlatform, SetWorkingDirectory, (const char *),
                      path);
 

 }
 
 SBError SBPlatform::ConnectRemote(SBPlatformConnectOptions &connect_options) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, ConnectRemote,
                      (lldb::SBPlatformConnectOptions &), connect_options);
 

 }
 
 void SBPlatform::DisconnectRemote() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatform, DisconnectRemote);
 
   PlatformSP platform_sp(GetSP());

 }
 
 bool SBPlatform::IsConnected() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBPlatform, IsConnected);
 
   PlatformSP platform_sp(GetSP());

 }
 
 const char *SBPlatform::GetTriple() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetTriple);
 
   PlatformSP platform_sp(GetSP());

 }
 
 const char *SBPlatform::GetOSBuild() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetOSBuild);
 
   PlatformSP platform_sp(GetSP());

 }
 
 const char *SBPlatform::GetOSDescription() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetOSDescription);
 
   PlatformSP platform_sp(GetSP());

 }
 
 const char *SBPlatform::GetHostname() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetHostname);
 
   PlatformSP platform_sp(GetSP());

 }
 
 uint32_t SBPlatform::GetOSMajorVersion() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatform, GetOSMajorVersion);
 
   llvm::VersionTuple version;

 }
 
 uint32_t SBPlatform::GetOSMinorVersion() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatform, GetOSMinorVersion);
 
   llvm::VersionTuple version;

 }
 
 uint32_t SBPlatform::GetOSUpdateVersion() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatform, GetOSUpdateVersion);
 
   llvm::VersionTuple version;

 }
 
 SBError SBPlatform::Get(SBFileSpec &src, SBFileSpec &dst) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Get,
                      (lldb::SBFileSpec &, lldb::SBFileSpec &), src, dst);
 

 }
 
 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) {

 }
 
 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) {

 }
 
 SBError SBPlatform::Run(SBPlatformShellCommand &shell_command) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Run,
                      (lldb::SBPlatformShellCommand &), shell_command);
   return ExecuteConnected(

 }
 
 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) {

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

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

 }
 
 uint32_t SBPlatform::GetFilePermissions(const char *path) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(uint32_t, SBPlatform, GetFilePermissions, (const char *),
                      path);
 

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

 }
 
 SBUnixSignals SBPlatform::GetUnixSignals() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBUnixSignals, SBPlatform,
                                    GetUnixSignals);
 

 }
 
 SBEnvironment SBPlatform::GetEnvironment() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBEnvironment, SBPlatform, GetEnvironment);
   PlatformSP platform_sp(GetSP());
 

lldb/source/API/SBProcess.cpp

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

 }
 
 const char *SBProcess::GetPluginName() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetPluginName);
 
   ProcessSP process_sp(GetSP());

 }
 
 const char *SBProcess::GetShortPluginName() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetShortPluginName);
 
   ProcessSP process_sp(GetSP());

 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());

                              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,

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

 }
 
 uint32_t SBProcess::GetNumThreads() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumThreads);
 
   uint32_t num_threads = 0;

 }
 
 SBThread SBProcess::GetSelectedThread() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBProcess,
                                    GetSelectedThread);
 

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

 }
 
 SBTarget SBProcess::GetTarget() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBTarget, SBProcess, GetTarget);
 
   SBTarget sb_target;

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

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

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

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

 }
 
 void SBProcess::ReportEventState(const SBEvent &event, SBFile out) const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST(void, SBProcess, ReportEventState,
                            (const SBEvent &, SBFile), event, out);
 

 }
 
 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<NativeFile>(out, false);

 
 void SBProcess::ReportEventState(const SBEvent &event, FileSP out) const {
 
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST(void, SBProcess, ReportEventState,
                            (const SBEvent &, FileSP), event, out);
 

 
 void SBProcess::AppendEventStateReport(const SBEvent &event,
                                        SBCommandReturnObject &result) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBProcess, AppendEventStateReport,
                      (const lldb::SBEvent &, lldb::SBCommandReturnObject &),
                      event, result);

 }
 
 bool SBProcess::SetSelectedThread(const SBThread &thread) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThread,
                      (const lldb::SBThread &), thread);
 

 }
 
 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) {

 }
 
 bool SBProcess::SetSelectedThreadByIndexID(uint32_t index_id) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByIndexID, (uint32_t),
                      index_id);
 

 }
 
 SBThread SBProcess::GetThreadAtIndex(size_t index) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadAtIndex, (size_t),
                      index);
 

 }
 
 uint32_t SBProcess::GetNumQueues() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumQueues);
 
   uint32_t num_queues = 0;

 }
 
 SBQueue SBProcess::GetQueueAtIndex(size_t index) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBQueue, SBProcess, GetQueueAtIndex, (size_t),
                      index);
 

 }
 
 uint32_t SBProcess::GetStopID(bool include_expression_stops) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(uint32_t, SBProcess, GetStopID, (bool),
                      include_expression_stops);
 

 }
 
 SBEvent SBProcess::GetStopEventForStopID(uint32_t stop_id) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBEvent, SBProcess, GetStopEventForStopID,
                      (uint32_t), stop_id);
 

 }
 
 StateType SBProcess::GetState() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::StateType, SBProcess, GetState);
 
   StateType ret_val = eStateInvalid;

 }
 
 int SBProcess::GetExitStatus() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(int, SBProcess, GetExitStatus);
 
   int exit_status = 0;

 }
 
 const char *SBProcess::GetExitDescription() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetExitDescription);
 
   const char *exit_desc = nullptr;

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

 }
 
 uint32_t SBProcess::GetUniqueID() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetUniqueID);
 
   uint32_t ret_val = 0;

 }
 
 ByteOrder SBProcess::GetByteOrder() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ByteOrder, SBProcess, GetByteOrder);
 
   ByteOrder byteOrder = eByteOrderInvalid;

 }
 
 uint32_t SBProcess::GetAddressByteSize() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBProcess, GetAddressByteSize);
 
   uint32_t size = 0;

 }
 
 SBError SBProcess::Continue() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Continue);
 
   SBError sb_error;

 }
 
 SBError SBProcess::Destroy() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Destroy);
 
   SBError sb_error;

 }
 
 SBError SBProcess::Stop() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Stop);
 
   SBError sb_error;

 }
 
 SBError SBProcess::Kill() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Kill);
 
   SBError sb_error;

 }
 
 SBError SBProcess::Detach() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Detach);
 
   // FIXME: This should come from a process default.

 }
 
 SBError SBProcess::Detach(bool keep_stopped) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBError, SBProcess, Detach, (bool), keep_stopped);
 
   SBError sb_error;

 }
 
 SBError SBProcess::Signal(int signo) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBError, SBProcess, Signal, (int), signo);
 
   SBError sb_error;

 }
 
 SBUnixSignals SBProcess::GetUnixSignals() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBUnixSignals, SBProcess, GetUnixSignals);
 
   if (auto process_sp = GetSP())

 }
 
 void SBProcess::SendAsyncInterrupt() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(void, SBProcess, SendAsyncInterrupt);
 
   ProcessSP process_sp(GetSP());

 }
 
 SBThread SBProcess::GetThreadByID(tid_t tid) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadByID, (lldb::tid_t),
                      tid);
 

 }
 
 SBThread SBProcess::GetThreadByIndexID(uint32_t index_id) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadByIndexID, (uint32_t),
                      index_id);
 

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

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

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

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

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

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

 }
 
 bool SBProcess::GetDescription(SBStream &description) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBProcess, GetDescription, (lldb::SBStream &),
                      description);
 

 }
 
 SBStructuredData SBProcess::GetExtendedCrashInformation() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStructuredData, SBProcess,
                              GetExtendedCrashInformation);
   SBStructuredData data;

 
 uint32_t
 SBProcess::GetNumSupportedHardwareWatchpoints(lldb::SBError &sb_error) const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST(uint32_t, SBProcess,
                            GetNumSupportedHardwareWatchpoints,
                            (lldb::SBError &), sb_error);

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

 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 &),

                                         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 &),

 }
 
 lldb::SBError SBProcess::UnloadImage(uint32_t image_token) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBError, SBProcess, UnloadImage, (uint32_t),
                      image_token);
 

 }
 
 lldb::SBError SBProcess::SendEventData(const char *event_data) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBError, SBProcess, SendEventData, (const char *),
                      event_data);
 

 }
 
 uint32_t SBProcess::GetNumExtendedBacktraceTypes() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumExtendedBacktraceTypes);
 
   ProcessSP process_sp(GetSP());

 }
 
 const char *SBProcess::GetExtendedBacktraceTypeAtIndex(uint32_t idx) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(const char *, SBProcess, GetExtendedBacktraceTypeAtIndex,
                      (uint32_t), idx);
 

 }
 
 SBThreadCollection SBProcess::GetHistoryThreads(addr_t addr) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBThreadCollection, SBProcess, GetHistoryThreads,
                      (lldb::addr_t), addr);
 

 
 bool SBProcess::IsInstrumentationRuntimePresent(
     InstrumentationRuntimeType type) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBProcess, IsInstrumentationRuntimePresent,
                      (lldb::InstrumentationRuntimeType), type);
 

 }
 
 lldb::SBError SBProcess::SaveCore(const char *file_name) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBError, SBProcess, SaveCore, (const char *),
                      file_name);
 

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

 }
 
 lldb::SBMemoryRegionInfoList SBProcess::GetMemoryRegions() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBMemoryRegionInfoList, SBProcess,
                              GetMemoryRegions);
 

 }
 
 lldb::SBProcessInfo SBProcess::GetProcessInfo() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcessInfo, SBProcess, GetProcessInfo);
 
   lldb::SBProcessInfo sb_proc_info;

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

 }
 
 lldb::SBError SBProcess::DeallocateMemory(lldb::addr_t ptr) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBError, SBProcess, DeallocateMemory, (lldb::addr_t),
                      ptr);
 

lldb/source/API/SBProcessInfo.cpp

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

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

 }
 
 SBFileSpec SBProcessInfo::GetExecutableFile() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBProcessInfo,
                              GetExecutableFile);
 

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

 }
 
 uint32_t SBProcessInfo::GetUserID() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetUserID);
 
   uint32_t user_id = UINT32_MAX;

 }
 
 uint32_t SBProcessInfo::GetGroupID() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetGroupID);
 
   uint32_t group_id = UINT32_MAX;

 }
 
 bool SBProcessInfo::UserIDIsValid() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, UserIDIsValid);
 
   bool is_valid = false;

 }
 
 bool SBProcessInfo::GroupIDIsValid() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, GroupIDIsValid);
 
   bool is_valid = false;

 }
 
 uint32_t SBProcessInfo::GetEffectiveUserID() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetEffectiveUserID);
 
   uint32_t user_id = UINT32_MAX;

 }
 
 uint32_t SBProcessInfo::GetEffectiveGroupID() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetEffectiveGroupID);
 
   uint32_t group_id = UINT32_MAX;

 }
 
 bool SBProcessInfo::EffectiveUserIDIsValid() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, EffectiveUserIDIsValid);
 
   bool is_valid = false;

 }
 
 bool SBProcessInfo::EffectiveGroupIDIsValid() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, EffectiveGroupIDIsValid);
 
   bool is_valid = false;

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

 }
 
 const char *SBProcessInfo::GetTriple() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcessInfo, GetTriple);
 
   const char *triple = nullptr;

lldb/source/API/SBQueue.cpp

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

 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();

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

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

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

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

lldb/source/API/SBQueueItem.cpp

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

 }
 
 lldb::QueueItemKind SBQueueItem::GetKind() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::QueueItemKind, SBQueueItem, GetKind);
 
   QueueItemKind result = eQueueItemKindUnknown;

 }
 
 void SBQueueItem::SetKind(lldb::QueueItemKind kind) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBQueueItem, SetKind, (lldb::QueueItemKind), kind);
 
   if (m_queue_item_sp) {

 }
 
 SBAddress SBQueueItem::GetAddress() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBQueueItem, GetAddress);
 
   SBAddress result;

 }
 
 void SBQueueItem::SetAddress(SBAddress addr) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBQueueItem, SetAddress, (lldb::SBAddress), addr);
 
   if (m_queue_item_sp) {

 }
 
 SBThread SBQueueItem::GetExtendedBacktraceThread(const char *type) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBThread, SBQueueItem, GetExtendedBacktraceThread,
                      (const char *), type);
 

lldb/source/API/SBSection.cpp

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

 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());

 }
 
 const char *SBSection::GetName() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBSection, GetName);
 
   SectionSP section_sp(GetSP());

 }
 
 lldb::SBSection SBSection::GetParent() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSection, SBSection, GetParent);
 
   lldb::SBSection sb_section;

 }
 
 lldb::SBSection SBSection::FindSubSection(const char *sect_name) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBSection, SBSection, FindSubSection, (const char *),
                      sect_name);
 

 }
 
 size_t SBSection::GetNumSubSections() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(size_t, SBSection, GetNumSubSections);
 
   SectionSP section_sp(GetSP());

 }
 
 lldb::SBSection SBSection::GetSubSectionAtIndex(size_t idx) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBSection, SBSection, GetSubSectionAtIndex, (size_t),
                      idx);
 

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

 }
 
 lldb::addr_t SBSection::GetLoadAddress(lldb::SBTarget &sb_target) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::addr_t, SBSection, GetLoadAddress,
                      (lldb::SBTarget &), sb_target);
 

 }
 
 lldb::addr_t SBSection::GetByteSize() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBSection, GetByteSize);
 
   SectionSP section_sp(GetSP());

 }
 
 uint64_t SBSection::GetFileOffset() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBSection, GetFileOffset);
 
   SectionSP section_sp(GetSP());

 }
 
 uint64_t SBSection::GetFileByteSize() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBSection, GetFileByteSize);
 
   SectionSP section_sp(GetSP());

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

 }
 
 SectionType SBSection::GetSectionType() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SectionType, SBSection, GetSectionType);
 
   SectionSP section_sp(GetSP());

 }
 
 uint32_t SBSection::GetPermissions() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBSection, GetPermissions);
 
   SectionSP section_sp(GetSP());

 }
 
 uint32_t SBSection::GetTargetByteSize() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBSection, GetTargetByteSize);
 
   SectionSP section_sp(GetSP());

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

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

 }
 
 bool SBSection::GetDescription(SBStream &description) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBSection, GetDescription, (lldb::SBStream &),
                      description);
 

lldb/source/API/SBSourceManager.cpp

 
 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<SourceManagerImpl>(*(rhs.m_opaque_up.get()));
   return *this;

 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 &),

     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,

lldb/source/API/SBStream.cpp

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

 // 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)

 // 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)

 }
 
 void SBStream::Print(const char *str) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBStream, Print, (const char *), str);
 
   Printf("%s", str);

 }
 
 void SBStream::RedirectToFile(const char *path, bool append) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBStream, RedirectToFile, (const char *, bool), path,
                      append);
 

 }
 
 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<NativeFile>(fh, transfer_fh_ownership);

 }
 
 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())

 }
 
 void SBStream::RedirectToFileDescriptor(int fd, bool transfer_fh_ownership) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBStream, RedirectToFileDescriptor, (int, bool), fd,
                      transfer_fh_ownership);
 

 }
 
 void SBStream::Clear() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(void, SBStream, Clear);
 
   if (m_opaque_up) {

lldb/source/API/SBStringList.cpp

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

 }
 
 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) {

 }
 
 void SBStringList::AppendList(const char **strv, int strc) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBStringList, AppendList, (const char **, int), strv,
                      strc);
 

 }
 
 void SBStringList::AppendList(const SBStringList &strings) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBStringList, AppendList,
                      (const lldb::SBStringList &), strings);
 

 }
 
 uint32_t SBStringList::GetSize() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBStringList, GetSize);
 
   if (IsValid()) {

 }
 
 const char *SBStringList::GetStringAtIndex(size_t idx) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(const char *, SBStringList, GetStringAtIndex, (size_t),
                      idx);
 

 }
 
 const char *SBStringList::GetStringAtIndex(size_t idx) const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST(const char *, SBStringList, GetStringAtIndex,
                            (size_t), idx);
 

 }
 
 void SBStringList::Clear() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(void, SBStringList, Clear);
 
   if (IsValid()) {

lldb/source/API/SBStructuredData.cpp

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

 }
 
 lldb::SBError SBStructuredData::SetFromJSON(const char *json) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBError, SBStructuredData, SetFromJSON,
                      (const char *), json);
   lldb::SBStream s;

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

 }
 
 lldb::SBError SBStructuredData::GetDescription(lldb::SBStream &stream) const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST(lldb::SBError, SBStructuredData, GetDescription,
                            (lldb::SBStream &), stream);
 

 }
 
 StructuredDataType SBStructuredData::GetType() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::StructuredDataType, SBStructuredData,
                                    GetType);
 

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

 }
 
 lldb::SBStructuredData SBStructuredData::GetValueForKey(const char *key) const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST(lldb::SBStructuredData, SBStructuredData,
                            GetValueForKey, (const char *), key);
 

 }
 
 lldb::SBStructuredData SBStructuredData::GetItemAtIndex(size_t idx) const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST(lldb::SBStructuredData, SBStructuredData,
                            GetItemAtIndex, (size_t), idx);
 

 }
 
 uint64_t SBStructuredData::GetIntegerValue(uint64_t fail_value) const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST(uint64_t, SBStructuredData, GetIntegerValue,
                            (uint64_t), fail_value);
 

 }
 
 double SBStructuredData::GetFloatValue(double fail_value) const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST(double, SBStructuredData, GetFloatValue, (double),
                            fail_value);
 

 }
 
 bool SBStructuredData::GetBooleanValue(bool fail_value) const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST(bool, SBStructuredData, GetBooleanValue, (bool),
                            fail_value);
 

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

lldb/source/API/SBSymbol.cpp

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

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

 }
 
 const char *SBSymbol::GetDisplayName() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetDisplayName);
 
   const char *name = nullptr;

 }
 
 const char *SBSymbol::GetMangledName() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetMangledName);
 
   const char *name = nullptr;

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

 }
 
 SBInstructionList SBSymbol::GetInstructions(SBTarget target) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions,
                      (lldb::SBTarget), target);
 

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

 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;

 }
 
 SBAddress SBSymbol::GetEndAddress() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBSymbol, GetEndAddress);
 
   SBAddress addr;

 }
 
 uint32_t SBSymbol::GetPrologueByteSize() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBSymbol, GetPrologueByteSize);
 
   if (m_opaque_ptr)

 }
 
 SymbolType SBSymbol::GetType() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SymbolType, SBSymbol, GetType);
 
   if (m_opaque_ptr)

 }
 
 bool SBSymbol::IsExternal() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBSymbol, IsExternal);
 
   if (m_opaque_ptr)

 }
 
 bool SBSymbol::IsSynthetic() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBSymbol, IsSynthetic);
 
   if (m_opaque_ptr)

lldb/source/API/SBSymbolContext.cpp

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

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

 }
 
 SBCompileUnit SBSymbolContext::GetCompileUnit() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCompileUnit, SBSymbolContext,
                              GetCompileUnit);
 

 }
 
 SBFunction SBSymbolContext::GetFunction() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFunction, SBSymbolContext, GetFunction);
 
   Function *function = nullptr;

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

 }
 
 SBSymbol SBSymbolContext::GetSymbol() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSymbol, SBSymbolContext, GetSymbol);
 
   Symbol *symbol = nullptr;

 }
 
 void SBSymbolContext::SetModule(lldb::SBModule module) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBSymbolContext, SetModule, (lldb::SBModule),
                      module);
 

 }
 
 void SBSymbolContext::SetCompileUnit(lldb::SBCompileUnit compile_unit) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBSymbolContext, SetCompileUnit,
                      (lldb::SBCompileUnit), compile_unit);
 

 }
 
 void SBSymbolContext::SetFunction(lldb::SBFunction function) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBSymbolContext, SetFunction, (lldb::SBFunction),
                      function);
 

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

 }
 
 void SBSymbolContext::SetSymbol(lldb::SBSymbol symbol) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBSymbolContext, SetSymbol, (lldb::SBSymbol),
                      symbol);
 

 }
 
 bool SBSymbolContext::GetDescription(SBStream &description) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBSymbolContext, GetDescription, (lldb::SBStream &),
                      description);
 

 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 &),

lldb/source/API/SBSymbolContextList.cpp

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

 }
 
 uint32_t SBSymbolContextList::GetSize() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBSymbolContextList, GetSize);
 
   if (m_opaque_up)

 }
 
 SBSymbolContext SBSymbolContextList::GetContextAtIndex(uint32_t idx) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBSymbolContextList,
                      GetContextAtIndex, (uint32_t), idx);
 

 }
 
 void SBSymbolContextList::Clear() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(void, SBSymbolContextList, Clear);
 
   if (m_opaque_up)

 }
 
 void SBSymbolContextList::Append(SBSymbolContext &sc) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBSymbolContextList, Append,
                      (lldb::SBSymbolContext &), sc);
 

 }
 
 void SBSymbolContextList::Append(SBSymbolContextList &sc_list) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBSymbolContextList, Append,
                      (lldb::SBSymbolContextList &), sc_list);
 

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

 }
 
 bool SBSymbolContextList::GetDescription(lldb::SBStream &description) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBSymbolContextList, GetDescription,
                      (lldb::SBStream &), description);
 

lldb/source/API/SBTarget.cpp

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

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

 }
 
 SBPlatform SBTarget::GetPlatform() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBPlatform, SBTarget, GetPlatform);
 
   TargetSP target_sp(GetSP());

 }
 
 SBDebugger SBTarget::GetDebugger() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBDebugger, SBTarget, GetDebugger);
 
   SBDebugger debugger;

 }
 
 SBStructuredData SBTarget::GetStatistics() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStructuredData, SBTarget, GetStatistics);
 
   SBStructuredData data;

 }
 
 void SBTarget::SetCollectingStats(bool v) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBTarget, SetCollectingStats, (bool), v);
 
   TargetSP target_sp(GetSP());

 }
 
 bool SBTarget::GetCollectingStats() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, GetCollectingStats);
 
   TargetSP target_sp(GetSP());

 }
 
 SBProcess SBTarget::LoadCore(const char *core_file) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, LoadCore, (const char *),
                      core_file);
 

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

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

 }
 
 SBError SBTarget::Install() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBTarget, Install);
 
   SBError sb_error;

                            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 *,

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

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

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

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

 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 &),

 }
 
 SBFileSpec SBTarget::GetExecutable() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBTarget, GetExecutable);
 
   SBFileSpec exe_file_spec;

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

 }
 
 lldb::SBAddress SBTarget::ResolveLoadAddress(lldb::addr_t vm_addr) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolveLoadAddress,
                      (lldb::addr_t), vm_addr);
 

 }
 
 lldb::SBAddress SBTarget::ResolveFileAddress(lldb::addr_t file_addr) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolveFileAddress,
                      (lldb::addr_t), file_addr);
 

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

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

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

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

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

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

 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 &),

 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 &),

     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),

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

 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 &),

 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 &),

     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 &,

 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 &,

     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 &,

     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 &,

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

 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 &),

 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]) {

 }
 
 SBBreakpoint SBTarget::BreakpointCreateByAddress(addr_t address) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByAddress,
                      (lldb::addr_t), address);
 

 }
 
 SBBreakpoint SBTarget::BreakpointCreateBySBAddress(SBAddress &sb_address) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateBySBAddress,
                      (lldb::SBAddress &), sb_address);
 

 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 *),

 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 &,

     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 &,

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

     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 &,

 }
 
 uint32_t SBTarget::GetNumBreakpoints() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumBreakpoints);
 
   TargetSP target_sp(GetSP());

 }
 
 SBBreakpoint SBTarget::GetBreakpointAtIndex(uint32_t idx) const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST(lldb::SBBreakpoint, SBTarget, GetBreakpointAtIndex,
                            (uint32_t), idx);
 

 }
 
 bool SBTarget::BreakpointDelete(break_id_t bp_id) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBTarget, BreakpointDelete, (lldb::break_id_t),
                      bp_id);
 

 }
 
 SBBreakpoint SBTarget::FindBreakpointByID(break_id_t bp_id) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, FindBreakpointByID,
                      (lldb::break_id_t), bp_id);
 

 
 bool SBTarget::FindBreakpointsByName(const char *name,
                                      SBBreakpointList &bkpts) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBTarget, FindBreakpointsByName,
                      (const char *, lldb::SBBreakpointList &), name, bkpts);
 

 }
 
 void SBTarget::GetBreakpointNames(SBStringList &names) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBTarget, GetBreakpointNames, (lldb::SBStringList &),
                      names);
 

 }
 
 void SBTarget::DeleteBreakpointName(const char *name) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBTarget, DeleteBreakpointName, (const char *),
                      name);
 

 }
 
 bool SBTarget::EnableAllBreakpoints() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, EnableAllBreakpoints);
 
   TargetSP target_sp(GetSP());

 }
 
 bool SBTarget::DisableAllBreakpoints() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DisableAllBreakpoints);
 
   TargetSP target_sp(GetSP());

 }
 
 bool SBTarget::DeleteAllBreakpoints() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DeleteAllBreakpoints);
 
   TargetSP target_sp(GetSP());

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

 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 &),

 }
 
 lldb::SBError SBTarget::BreakpointsWriteToFile(SBFileSpec &dest_file) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile,
                      (lldb::SBFileSpec &), dest_file);
 

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

 }
 
 uint32_t SBTarget::GetNumWatchpoints() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumWatchpoints);
 
   TargetSP target_sp(GetSP());

 }
 
 SBWatchpoint SBTarget::GetWatchpointAtIndex(uint32_t idx) const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST(lldb::SBWatchpoint, SBTarget, GetWatchpointAtIndex,
                            (uint32_t), idx);
 

 }
 
 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) {

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

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

 }
 
 bool SBTarget::EnableAllWatchpoints() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, EnableAllWatchpoints);
 
   TargetSP target_sp(GetSP());

 }
 
 bool SBTarget::DisableAllWatchpoints() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DisableAllWatchpoints);
 
   TargetSP target_sp(GetSP());

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

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

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

 }
 
 bool SBTarget::DeleteAllWatchpoints() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DeleteAllWatchpoints);
 
   TargetSP target_sp(GetSP());

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

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

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

 }
 
 lldb::SBModule SBTarget::AddModule(const SBModuleSpec &module_spec) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule,
                      (const lldb::SBModuleSpec &), module_spec);
 

 }
 
 bool SBTarget::AddModule(lldb::SBModule &module) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBTarget, AddModule, (lldb::SBModule &), module);
 
   TargetSP target_sp(GetSP());

 }
 
 uint32_t SBTarget::GetNumModules() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumModules);
 
   uint32_t num = 0;

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

 }
 
 SBSymbolContextList SBTarget::FindCompileUnits(const SBFileSpec &sb_file_spec) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindCompileUnits,
                      (const lldb::SBFileSpec &), sb_file_spec);
 

 }
 
 lldb::ByteOrder SBTarget::GetByteOrder() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::ByteOrder, SBTarget, GetByteOrder);
 
   TargetSP target_sp(GetSP());

 }
 
 const char *SBTarget::GetTriple() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTarget, GetTriple);
 
   TargetSP target_sp(GetSP());

 }
 
 uint32_t SBTarget::GetDataByteSize() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTarget, GetDataByteSize);
 
   TargetSP target_sp(GetSP());

 }
 
 uint32_t SBTarget::GetCodeByteSize() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTarget, GetCodeByteSize);
 
   TargetSP target_sp(GetSP());

 }
 
 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){

 }
 
 uint32_t SBTarget::GetAddressByteSize() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTarget, GetAddressByteSize);
 
   TargetSP target_sp(GetSP());

 }
 
 SBModule SBTarget::GetModuleAtIndex(uint32_t idx) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, GetModuleAtIndex, (uint32_t),
                      idx);
 

 }
 
 bool SBTarget::RemoveModule(lldb::SBModule module) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBTarget, RemoveModule, (lldb::SBModule), module);
 
   TargetSP target_sp(GetSP());

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

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

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

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

 }
 
 lldb::SBType SBTarget::FindFirstType(const char *typename_cstr) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBType, SBTarget, FindFirstType, (const char *),
                      typename_cstr);
 

 }
 
 SBType SBTarget::GetBasicType(lldb::BasicType type) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBType, SBTarget, GetBasicType, (lldb::BasicType),
                      type);
 

 }
 
 lldb::SBTypeList SBTarget::FindTypes(const char *typename_cstr) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBTypeList, SBTarget, FindTypes, (const char *),
                      typename_cstr);
 

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

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

 }
 
 lldb::SBValue SBTarget::FindFirstGlobalVariable(const char *name) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, FindFirstGlobalVariable,
                      (const char *), name);
 

 }
 
 SBSourceManager SBTarget::GetSourceManager() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSourceManager, SBTarget, GetSourceManager);
 
   SBSourceManager source_manager(*this);

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

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

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

 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),

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

 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),

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

 }
 
 SBError SBTarget::ClearSectionLoadAddress(lldb::SBSection section) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBError, SBTarget, ClearSectionLoadAddress,
                      (lldb::SBSection), section);
 

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

 }
 
 SBError SBTarget::ClearModuleLoadAddress(lldb::SBModule module) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBError, SBTarget, ClearModuleLoadAddress,
                      (lldb::SBModule), module);
 

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

 }
 
 lldb::SBValue SBTarget::EvaluateExpression(const char *expr) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, EvaluateExpression,
                      (const char *), expr);
 

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

 }
 
 lldb::addr_t SBTarget::GetStackRedZoneSize() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBTarget, GetStackRedZoneSize);
 
   TargetSP target_sp(GetSP());

 }
 
 bool SBTarget::IsLoaded(const SBModule &module) const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST(bool, SBTarget, IsLoaded, (const lldb::SBModule &),
                            module);
 

 }
 
 lldb::SBLaunchInfo SBTarget::GetLaunchInfo() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBLaunchInfo, SBTarget, GetLaunchInfo);
 
   lldb::SBLaunchInfo launch_info(nullptr);

 }
 
 void SBTarget::SetLaunchInfo(const lldb::SBLaunchInfo &launch_info) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBTarget, SetLaunchInfo,
                      (const lldb::SBLaunchInfo &), launch_info);
 

 }
 
 SBEnvironment SBTarget::GetEnvironment() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBEnvironment, SBTarget, GetEnvironment);
   TargetSP target_sp(GetSP());
 

 }
 
 lldb::SBTrace SBTarget::GetTrace() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTrace, SBTarget, GetTrace);
   TargetSP target_sp(GetSP());
 

 }
 
 lldb::SBTrace SBTarget::CreateTrace(lldb::SBError &error) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBTrace, SBTarget, CreateTrace, (lldb::SBError &),
                      error);
   TargetSP target_sp(GetSP());

lldb/source/API/SBThread.cpp

 // 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);

 SBThread::~SBThread() = default;
 
 lldb::SBQueue SBThread::GetQueue() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBQueue, SBThread, GetQueue);
 
   SBQueue sb_queue;

 }
 
 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<std::recursive_mutex> lock;

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

 }
 
 size_t SBThread::GetStopReasonDataCount() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(size_t, SBThread, GetStopReasonDataCount);
 
   std::unique_lock<std::recursive_mutex> lock;

 }
 
 uint64_t SBThread::GetStopReasonDataAtIndex(uint32_t idx) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(uint64_t, SBThread, GetStopReasonDataAtIndex, (uint32_t),
                      idx);
 

 }
 
 bool SBThread::GetStopReasonExtendedInfoAsJSON(lldb::SBStream &stream) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBThread, GetStopReasonExtendedInfoAsJSON,
                      (lldb::SBStream &), stream);
 

 
 SBThreadCollection
 SBThread::GetStopReasonExtendedBacktraces(InstrumentationRuntimeType type) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBThreadCollection, SBThread,
                      GetStopReasonExtendedBacktraces,
                      (lldb::InstrumentationRuntimeType), type);

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

 }
 
 SBValue SBThread::GetStopReturnValue() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBThread, GetStopReturnValue);
 
   ValueObjectSP return_valobj_sp;

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

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

 }
 
 const char *SBThread::GetName() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBThread, GetName);
 
   const char *name = nullptr;

 }
 
 const char *SBThread::GetQueueName() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBThread, GetQueueName);
 
   const char *name = nullptr;

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

 }
 
 bool SBThread::GetInfoItemByPathAsString(const char *path, SBStream &strm) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBThread, GetInfoItemByPathAsString,
                      (const char *, lldb::SBStream &), path, strm);
 

 }
 
 void SBThread::StepOver(lldb::RunMode stop_other_threads) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBThread, StepOver, (lldb::RunMode),
                      stop_other_threads);
 

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

 }
 
 void SBThread::StepInto(lldb::RunMode stop_other_threads) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBThread, StepInto, (lldb::RunMode),
                      stop_other_threads);
 

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

 
 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<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 

 }
 
 void SBThread::StepOut() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(void, SBThread, StepOut);
 
   SBError error; // Ignored

 }
 
 void SBThread::StepOut(SBError &error) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBThread, StepOut, (lldb::SBError &), error);
 
   std::unique_lock<std::recursive_mutex> lock;

 }
 
 void SBThread::StepOutOfFrame(SBFrame &sb_frame) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBThread, StepOutOfFrame, (lldb::SBFrame &),
                      sb_frame);
 

 }
 
 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<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 

 }
 
 void SBThread::StepInstruction(bool step_over) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBThread, StepInstruction, (bool), step_over);
 
   SBError error; // Ignored

 }
 
 void SBThread::StepInstruction(bool step_over, SBError &error) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBThread, StepInstruction, (bool, lldb::SBError &),
                      step_over, error);
 

 }
 
 void SBThread::RunToAddress(lldb::addr_t addr) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBThread, RunToAddress, (lldb::addr_t), addr);
 
   SBError error; // Ignored

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

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

 }
 
 SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
                      (const char *), script_class_name);
 

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

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

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

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

 }
 
 SBError SBThread::UnwindInnermostExpression() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBThread,
                              UnwindInnermostExpression);
 

 }
 
 bool SBThread::Suspend() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, Suspend);
 
   SBError error; // Ignored

 }
 
 bool SBThread::Suspend(SBError &error) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBThread, Suspend, (lldb::SBError &), error);
 
   std::unique_lock<std::recursive_mutex> lock;

 }
 
 bool SBThread::Resume() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, Resume);
 
   SBError error; // Ignored

 }
 
 bool SBThread::Resume(SBError &error) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBThread, Resume, (lldb::SBError &), error);
 
   std::unique_lock<std::recursive_mutex> lock;

 }
 
 bool SBThread::IsSuspended() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, IsSuspended);
 
   std::unique_lock<std::recursive_mutex> lock;

 }
 
 bool SBThread::IsStopped() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, IsStopped);
 
   std::unique_lock<std::recursive_mutex> lock;

 }
 
 SBProcess SBThread::GetProcess() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBThread, GetProcess);
 
   SBProcess sb_process;

 }
 
 uint32_t SBThread::GetNumFrames() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBThread, GetNumFrames);
 
   uint32_t num_frames = 0;

 }
 
 SBFrame SBThread::GetFrameAtIndex(uint32_t idx) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBFrame, SBThread, GetFrameAtIndex, (uint32_t), idx);
 
   SBFrame sb_frame;

 }
 
 lldb::SBFrame SBThread::GetSelectedFrame() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFrame, SBThread, GetSelectedFrame);
 
   SBFrame sb_frame;

 }
 
 lldb::SBFrame SBThread::SetSelectedFrame(uint32_t idx) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBFrame, SBThread, SetSelectedFrame, (uint32_t),
                      idx);
 

 }
 
 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() ==

 }
 
 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() !=

 }
 
 bool SBThread::GetStatus(SBStream &status) const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST(bool, SBThread, GetStatus, (lldb::SBStream &),
                            status);
 

 }
 
 bool SBThread::GetDescription(SBStream &description) const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST(bool, SBThread, GetDescription, (lldb::SBStream &),
                            description);
 

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

 }
 
 SBThread SBThread::GetExtendedBacktraceThread(const char *type) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBThread, SBThread, GetExtendedBacktraceThread,
                      (const char *), type);
 

 }
 
 uint32_t SBThread::GetExtendedBacktraceOriginatingIndexID() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBThread,
                              GetExtendedBacktraceOriginatingIndexID);
 

 }
 
 SBValue SBThread::GetCurrentException() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBThread, GetCurrentException);
 
   ThreadSP thread_sp(m_opaque_sp->GetThreadSP());

 }
 
 SBThread SBThread::GetCurrentExceptionBacktrace() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBThread, SBThread,
                              GetCurrentExceptionBacktrace);
 

 }
 
 bool SBThread::SafeToCallFunctions() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, SafeToCallFunctions);
 
   ThreadSP thread_sp(m_opaque_sp->GetThreadSP());

lldb/source/API/SBThreadCollection.cpp

 
 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;

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

 }
 
 SBThread SBThreadCollection::GetThreadAtIndex(size_t idx) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBThread, SBThreadCollection, GetThreadAtIndex,
                      (size_t), idx);
 

lldb/source/API/SBThreadPlan.cpp

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

 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<bool>(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);
 

 }
 
 SBThread SBThreadPlan::GetThread() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBThreadPlan, GetThread);
 
   ThreadPlanSP thread_plan_sp(GetSP());

 }
 
 bool SBThreadPlan::GetDescription(lldb::SBStream &description) const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST(bool, SBThreadPlan, GetDescription,
                            (lldb::SBStream &), description);
 

 }
 
 void SBThreadPlan::SetPlanComplete(bool success) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBThreadPlan, SetPlanComplete, (bool), success);
 
   ThreadPlanSP thread_plan_sp(GetSP());

 }
 
 bool SBThreadPlan::IsPlanComplete() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, IsPlanComplete);
 
   ThreadPlanSP thread_plan_sp(GetSP());

 }
 
 bool SBThreadPlan::IsPlanStale() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, IsPlanStale);
 
   ThreadPlanSP thread_plan_sp(GetSP());

 }
 
 bool SBThreadPlan::IsValid() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, IsValid);
 
   ThreadPlanSP thread_plan_sp(GetSP());

 }
 
 bool SBThreadPlan::GetStopOthers() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, GetStopOthers);
 
   ThreadPlanSP thread_plan_sp(GetSP());

 }
 
 void SBThreadPlan::SetStopOthers(bool stop_others) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBThreadPlan, SetStopOthers, (bool), stop_others);
 
   ThreadPlanSP thread_plan_sp(GetSP());

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

 
 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 &),

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

 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 &),

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

 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,

 
 SBThreadPlan
 SBThreadPlan::QueueThreadPlanForRunToAddress(SBAddress sb_address) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
                      QueueThreadPlanForRunToAddress, (lldb::SBAddress),
                      sb_address);

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

 
 SBThreadPlan
 SBThreadPlan::QueueThreadPlanForStepScripted(const char *script_class_name) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
                      QueueThreadPlanForStepScripted, (const char *),
                      script_class_name);

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

 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());

lldb/source/API/SBTrace.cpp

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

 
 SBError SBTrace::Start(const SBThread &thread,
                        const SBStructuredData &configuration) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(SBError, SBTrace, Start,
                      (const SBThread &, const SBStructuredData &), thread,
                      configuration);

 }
 
 SBError SBTrace::Stop() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(SBError, SBTrace, Stop);
   SBError error;
   if (!m_opaque_sp)

 }
 
 SBError SBTrace::Stop(const SBThread &thread) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(SBError, SBTrace, Stop, (const SBThread &), thread);
   SBError error;
   if (!m_opaque_sp)

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

lldb/source/API/SBType.cpp

 //{}
 //
 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();

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

 }
 
 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) {

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

 }
 
 uint64_t SBType::GetByteSize() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBType, GetByteSize);
 
   if (IsValid())

 }
 
 bool SBType::IsPointerType() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsPointerType);
 
   if (!IsValid())

 }
 
 bool SBType::IsArrayType() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsArrayType);
 
   if (!IsValid())

 }
 
 bool SBType::IsVectorType() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsVectorType);
 
   if (!IsValid())

 }
 
 bool SBType::IsReferenceType() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsReferenceType);
 
   if (!IsValid())

 }
 
 SBType SBType::GetPointerType() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetPointerType);
 
   if (!IsValid())

 }
 
 SBType SBType::GetPointeeType() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetPointeeType);
 
   if (!IsValid())

 }
 
 SBType SBType::GetReferenceType() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetReferenceType);
 
   if (!IsValid())

 }
 
 SBType SBType::GetTypedefedType() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetTypedefedType);
 
   if (!IsValid())

 }
 
 SBType SBType::GetDereferencedType() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetDereferencedType);
 
   if (!IsValid())

 }
 
 SBType SBType::GetArrayElementType() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetArrayElementType);
 
   if (!IsValid())

 }
 
 SBType SBType::GetArrayType(uint64_t size) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBType, SBType, GetArrayType, (uint64_t), size);
 
   if (!IsValid())

 }
 
 SBType SBType::GetVectorElementType() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetVectorElementType);
 
   SBType type_sb;

 }
 
 bool SBType::IsFunctionType() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsFunctionType);
 
   if (!IsValid())

 }
 
 bool SBType::IsPolymorphicClass() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsPolymorphicClass);
 
   if (!IsValid())

 }
 
 bool SBType::IsTypedefType() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsTypedefType);
 
   if (!IsValid())

 }
 
 bool SBType::IsAnonymousType() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsAnonymousType);
 
   if (!IsValid())

 }
 
 bool SBType::IsScopedEnumerationType() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsScopedEnumerationType);
 
   if (!IsValid())

 }
 
 lldb::SBType SBType::GetFunctionReturnType() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetFunctionReturnType);
 
   if (IsValid()) {

 }
 
 lldb::SBTypeList SBType::GetFunctionArgumentTypes() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeList, SBType,
                              GetFunctionArgumentTypes);
 

 }
 
 uint32_t SBType::GetNumberOfMemberFunctions() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfMemberFunctions);
 
   if (IsValid()) {

 }
 
 lldb::SBTypeMemberFunction SBType::GetMemberFunctionAtIndex(uint32_t idx) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBTypeMemberFunction, SBType,
                      GetMemberFunctionAtIndex, (uint32_t), idx);
 

 }
 
 lldb::SBType SBType::GetUnqualifiedType() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetUnqualifiedType);
 
   if (!IsValid())

 }
 
 lldb::SBType SBType::GetCanonicalType() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetCanonicalType);
 
   if (IsValid())

 }
 
 SBType SBType::GetEnumerationIntegerType() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetEnumerationIntegerType);
 
   if (IsValid()) {

 }
 
 lldb::BasicType SBType::GetBasicType() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::BasicType, SBType, GetBasicType);
 
   if (IsValid())

 }
 
 SBType SBType::GetBasicType(lldb::BasicType basic_type) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBType, SBType, GetBasicType, (lldb::BasicType),
                      basic_type);
 

 }
 
 uint32_t SBType::GetNumberOfDirectBaseClasses() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfDirectBaseClasses);
 
   if (IsValid())

 }
 
 uint32_t SBType::GetNumberOfVirtualBaseClasses() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfVirtualBaseClasses);
 
   if (IsValid())

 }
 
 uint32_t SBType::GetNumberOfFields() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfFields);
 
   if (IsValid())

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

 }
 
 SBTypeMember SBType::GetDirectBaseClassAtIndex(uint32_t idx) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBTypeMember, SBType, GetDirectBaseClassAtIndex,
                      (uint32_t), idx);
 

 }
 
 SBTypeMember SBType::GetVirtualBaseClassAtIndex(uint32_t idx) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBTypeMember, SBType, GetVirtualBaseClassAtIndex,
                      (uint32_t), idx);
 

 }
 
 SBTypeEnumMemberList SBType::GetEnumMembers() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeEnumMemberList, SBType,
                              GetEnumMembers);
 

 }
 
 SBTypeMember SBType::GetFieldAtIndex(uint32_t idx) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBTypeMember, SBType, GetFieldAtIndex, (uint32_t),
                      idx);
 

 }
 
 bool SBType::IsTypeComplete() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsTypeComplete);
 
   if (!IsValid())

 }
 
 uint32_t SBType::GetTypeFlags() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetTypeFlags);
 
   if (!IsValid())

 }
 
 lldb::SBModule SBType::GetModule() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBModule, SBType, GetModule);
 
   lldb::SBModule sb_module;

 }
 
 const char *SBType::GetName() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBType, GetName);
 
   if (!IsValid())

 }
 
 const char *SBType::GetDisplayTypeName() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBType, GetDisplayTypeName);
 
   if (!IsValid())

 }
 
 lldb::TypeClass SBType::GetTypeClass() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::TypeClass, SBType, GetTypeClass);
 
   if (IsValid())

 }
 
 uint32_t SBType::GetNumberOfTemplateArguments() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfTemplateArguments);
 
   if (IsValid())

 }
 
 lldb::SBType SBType::GetTemplateArgumentType(uint32_t idx) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBType, SBType, GetTemplateArgumentType, (uint32_t),
                      idx);
 

 }
 
 lldb::TemplateArgumentKind SBType::GetTemplateArgumentKind(uint32_t idx) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::TemplateArgumentKind, SBType,
                      GetTemplateArgumentKind, (uint32_t), idx);
 

 }
 
 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<TypeListImpl>();

 }
 
 void SBTypeList::Append(SBType type) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBTypeList, Append, (lldb::SBType), type);
 
   if (type.IsValid())

 }
 
 SBType SBTypeList::GetTypeAtIndex(uint32_t index) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBType, SBTypeList, GetTypeAtIndex, (uint32_t),
                      index);
 

 }
 
 uint32_t SBTypeList::GetSize() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeList, GetSize);
 
   return m_opaque_up->GetSize();

 }
 
 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())

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

 }
 
 SBType SBTypeMember::GetType() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeMember, GetType);
 
   SBType sb_type;

 }
 
 uint64_t SBTypeMember::GetOffsetInBytes() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBTypeMember, GetOffsetInBytes);
 
   if (m_opaque_up)

 }
 
 uint64_t SBTypeMember::GetOffsetInBits() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBTypeMember, GetOffsetInBits);
 
   if (m_opaque_up)

 }
 
 bool SBTypeMember::IsBitfield() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeMember, IsBitfield);
 
   if (m_opaque_up)

 }
 
 uint32_t SBTypeMember::GetBitfieldSizeInBits() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeMember, GetBitfieldSizeInBits);
 
   if (m_opaque_up)

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

 
 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;

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

 }
 
 const char *SBTypeMemberFunction::GetDemangledName() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMemberFunction,
                              GetDemangledName);
 

 }
 
 const char *SBTypeMemberFunction::GetMangledName() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMemberFunction,
                              GetMangledName);
 

 }
 
 SBType SBTypeMemberFunction::GetType() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeMemberFunction, GetType);
 
   SBType sb_type;

 }
 
 lldb::SBType SBTypeMemberFunction::GetReturnType() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeMemberFunction, GetReturnType);
 
   SBType sb_type;

 }
 
 uint32_t SBTypeMemberFunction::GetNumberOfArguments() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeMemberFunction,
                              GetNumberOfArguments);
 

 }
 
 lldb::SBType SBTypeMemberFunction::GetArgumentTypeAtIndex(uint32_t i) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBType, SBTypeMemberFunction, GetArgumentTypeAtIndex,
                      (uint32_t), i);
 

 }
 
 lldb::MemberFunctionKind SBTypeMemberFunction::GetKind() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::MemberFunctionKind, SBTypeMemberFunction,
                              GetKind);
 

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

lldb/source/API/SBTypeCategory.cpp

 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())

 }
 
 void SBTypeCategory::SetEnabled(bool enabled) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBTypeCategory, SetEnabled, (bool), enabled);
 
   if (!IsValid())

 }
 
 const char *SBTypeCategory::GetName() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeCategory, GetName);
 
   if (!IsValid())

 }
 
 lldb::LanguageType SBTypeCategory::GetLanguageAtIndex(uint32_t idx) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::LanguageType, SBTypeCategory, GetLanguageAtIndex,
                      (uint32_t), idx);
 

 }
 
 uint32_t SBTypeCategory::GetNumLanguages() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumLanguages);
 
   if (IsValid())

 }
 
 void SBTypeCategory::AddLanguage(lldb::LanguageType language) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBTypeCategory, AddLanguage, (lldb::LanguageType),
                      language);
 

 }
 
 uint32_t SBTypeCategory::GetNumFormats() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumFormats);
 
   if (!IsValid())

 }
 
 uint32_t SBTypeCategory::GetNumSummaries() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumSummaries);
 
   if (!IsValid())

 }
 
 uint32_t SBTypeCategory::GetNumFilters() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumFilters);
 
   if (!IsValid())

 }
 
 uint32_t SBTypeCategory::GetNumSynthetics() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumSynthetics);
 
   if (!IsValid())

 
 lldb::SBTypeNameSpecifier
 SBTypeCategory::GetTypeNameSpecifierForFilterAtIndex(uint32_t index) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
                      GetTypeNameSpecifierForFilterAtIndex, (uint32_t), index);
 

 
 lldb::SBTypeNameSpecifier
 SBTypeCategory::GetTypeNameSpecifierForFormatAtIndex(uint32_t index) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
                      GetTypeNameSpecifierForFormatAtIndex, (uint32_t), index);
 

 
 lldb::SBTypeNameSpecifier
 SBTypeCategory::GetTypeNameSpecifierForSummaryAtIndex(uint32_t index) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
                      GetTypeNameSpecifierForSummaryAtIndex, (uint32_t), index);
 

 
 lldb::SBTypeNameSpecifier
 SBTypeCategory::GetTypeNameSpecifierForSyntheticAtIndex(uint32_t index) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
                      GetTypeNameSpecifierForSyntheticAtIndex, (uint32_t),
                      index);

 }
 
 SBTypeFilter SBTypeCategory::GetFilterForType(SBTypeNameSpecifier spec) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterForType,
                      (lldb::SBTypeNameSpecifier), spec);
 

   return lldb::SBTypeFilter(filter_sp);
 }
 SBTypeFormat SBTypeCategory::GetFormatForType(SBTypeNameSpecifier spec) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatForType,
                      (lldb::SBTypeNameSpecifier), spec);
 

 }
 
 SBTypeSummary SBTypeCategory::GetSummaryForType(SBTypeNameSpecifier spec) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryForType,
                      (lldb::SBTypeNameSpecifier), spec);
 

 }
 
 SBTypeSynthetic SBTypeCategory::GetSyntheticForType(SBTypeNameSpecifier spec) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBTypeCategory, GetSyntheticForType,
                      (lldb::SBTypeNameSpecifier), spec);
 

 }
 
 SBTypeFilter SBTypeCategory::GetFilterAtIndex(uint32_t index) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterAtIndex,
                      (uint32_t), index);
 

 }
 
 SBTypeFormat SBTypeCategory::GetFormatAtIndex(uint32_t index) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatAtIndex,
                      (uint32_t), index);
 

 }
 
 SBTypeSummary SBTypeCategory::GetSummaryAtIndex(uint32_t index) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryAtIndex,
                      (uint32_t), index);
 

 }
 
 SBTypeSynthetic SBTypeCategory::GetSyntheticAtIndex(uint32_t index) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBTypeCategory, GetSyntheticAtIndex,
                      (uint32_t), index);
 

 
 bool SBTypeCategory::AddTypeFormat(SBTypeNameSpecifier type_name,
                                    SBTypeFormat format) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeFormat,
                      (lldb::SBTypeNameSpecifier, lldb::SBTypeFormat), type_name,
                      format);

 }
 
 bool SBTypeCategory::DeleteTypeFormat(SBTypeNameSpecifier type_name) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeFormat,
                      (lldb::SBTypeNameSpecifier), type_name);
 

 
 bool SBTypeCategory::AddTypeSummary(SBTypeNameSpecifier type_name,
                                     SBTypeSummary summary) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeSummary,
                      (lldb::SBTypeNameSpecifier, lldb::SBTypeSummary),
                      type_name, summary);

 }
 
 bool SBTypeCategory::DeleteTypeSummary(SBTypeNameSpecifier type_name) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeSummary,
                      (lldb::SBTypeNameSpecifier), type_name);
 

 
 bool SBTypeCategory::AddTypeFilter(SBTypeNameSpecifier type_name,
                                    SBTypeFilter filter) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeFilter,
                      (lldb::SBTypeNameSpecifier, lldb::SBTypeFilter), type_name,
                      filter);

 }
 
 bool SBTypeCategory::DeleteTypeFilter(SBTypeNameSpecifier type_name) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeFilter,
                      (lldb::SBTypeNameSpecifier), type_name);
 

 
 bool SBTypeCategory::AddTypeSynthetic(SBTypeNameSpecifier type_name,
                                       SBTypeSynthetic synth) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeSynthetic,
                      (lldb::SBTypeNameSpecifier, lldb::SBTypeSynthetic),
                      type_name, synth);

 }
 
 bool SBTypeCategory::DeleteTypeSynthetic(SBTypeNameSpecifier type_name) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeSynthetic,
                      (lldb::SBTypeNameSpecifier), type_name);
 

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

 
 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;

 }
 
 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())

 }
 
 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())

lldb/source/API/SBTypeEnumMember.cpp

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

 }
 
 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())

 }
 
 int64_t SBTypeEnumMember::GetValueAsSigned() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(int64_t, SBTypeEnumMember, GetValueAsSigned);
 
   if (m_opaque_sp.get())

 }
 
 uint64_t SBTypeEnumMember::GetValueAsUnsigned() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBTypeEnumMember, GetValueAsUnsigned);
 
   if (m_opaque_sp.get())

 }
 
 SBType SBTypeEnumMember::GetType() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeEnumMember, GetType);
 
   SBType sb_type;

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

 
 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<TypeEnumMemberListImpl>();

 }
 
 void SBTypeEnumMemberList::Append(SBTypeEnumMember enum_member) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBTypeEnumMemberList, Append,
                      (lldb::SBTypeEnumMember), enum_member);
 

 
 SBTypeEnumMember
 SBTypeEnumMemberList::GetTypeEnumMemberAtIndex(uint32_t index) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBTypeEnumMember, SBTypeEnumMemberList,
                      GetTypeEnumMemberAtIndex, (uint32_t), index);
 

 }
 
 uint32_t SBTypeEnumMemberList::GetSize() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeEnumMemberList, GetSize);
 
   return m_opaque_up->GetSize();

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

lldb/source/API/SBTypeFilter.cpp

 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())

 }
 
 void SBTypeFilter::SetOptions(uint32_t value) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBTypeFilter, SetOptions, (uint32_t), value);
 
   if (CopyOnWrite_Impl())

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

 }
 
 void SBTypeFilter::Clear() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(void, SBTypeFilter, Clear);
 
   if (CopyOnWrite_Impl())

 }
 
 uint32_t SBTypeFilter::GetNumberOfExpressionPaths() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeFilter,
                              GetNumberOfExpressionPaths);
 

 }
 
 const char *SBTypeFilter::GetExpressionPathAtIndex(uint32_t i) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(const char *, SBTypeFilter, GetExpressionPathAtIndex,
                      (uint32_t), i);
 

 }
 
 bool SBTypeFilter::ReplaceExpressionPathAtIndex(uint32_t i, const char *item) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBTypeFilter, ReplaceExpressionPathAtIndex,
                      (uint32_t, const char *), i, item);
 

 }
 
 void SBTypeFilter::AppendExpressionPath(const char *item) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBTypeFilter, AppendExpressionPath, (const char *),
                      item);
 

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

 }
 
 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())

 }
 
 bool SBTypeFilter::IsEqualTo(lldb::SBTypeFilter &rhs) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBTypeFilter, IsEqualTo, (lldb::SBTypeFilter &),
                      rhs);
 

 }
 
 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())

lldb/source/API/SBTypeFormat.cpp

 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)

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

 }
 
 uint32_t SBTypeFormat::GetOptions() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeFormat, GetOptions);
 
   if (IsValid())

 }
 
 void SBTypeFormat::SetFormat(lldb::Format fmt) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBTypeFormat, SetFormat, (lldb::Format), fmt);
 
   if (CopyOnWrite_Impl(Type::eTypeFormat))

 }
 
 void SBTypeFormat::SetTypeName(const char *type) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBTypeFormat, SetTypeName, (const char *), type);
 
   if (CopyOnWrite_Impl(Type::eTypeEnum))

 }
 
 void SBTypeFormat::SetOptions(uint32_t value) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBTypeFormat, SetOptions, (uint32_t), value);
 
   if (CopyOnWrite_Impl(Type::eTypeKeepSame))

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

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

 }
 
 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())

 }
 
 bool SBTypeFormat::IsEqualTo(lldb::SBTypeFormat &rhs) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBTypeFormat, IsEqualTo, (lldb::SBTypeFormat &),
                      rhs);
 

 }
 
 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())

lldb/source/API/SBTypeNameSpecifier.cpp

 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())

 }
 
 SBType SBTypeNameSpecifier::GetType() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeNameSpecifier, GetType);
 
   if (!IsValid())

 }
 
 bool SBTypeNameSpecifier::IsRegex() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeNameSpecifier, IsRegex);
 
   if (!IsValid())

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

 
 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;

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

 }
 
 bool SBTypeNameSpecifier::IsEqualTo(lldb::SBTypeNameSpecifier &rhs) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBTypeNameSpecifier, IsEqualTo,
                      (lldb::SBTypeNameSpecifier &), rhs);
 

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

lldb/source/API/SBTypeSummary.cpp

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

 }
 
 lldb::TypeSummaryCapping SBTypeSummaryOptions::GetCapping() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::TypeSummaryCapping, SBTypeSummaryOptions,
                              GetCapping);
 

 }
 
 void SBTypeSummaryOptions::SetLanguage(lldb::LanguageType l) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBTypeSummaryOptions, SetLanguage,
                      (lldb::LanguageType), l);
 

 }
 
 void SBTypeSummaryOptions::SetCapping(lldb::TypeSummaryCapping c) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBTypeSummaryOptions, SetCapping,
                      (lldb::TypeSummaryCapping), c);
 

 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())

 }
 
 bool SBTypeSummary::IsFunctionName() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummary, IsFunctionName);
 
   if (!IsValid())

 }
 
 bool SBTypeSummary::IsSummaryString() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummary, IsSummaryString);
 
   if (!IsValid())

 }
 
 const char *SBTypeSummary::GetData() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeSummary, GetData);
 
   if (!IsValid())

 }
 
 uint32_t SBTypeSummary::GetOptions() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeSummary, GetOptions);
 
   if (!IsValid())

 }
 
 void SBTypeSummary::SetOptions(uint32_t value) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBTypeSummary, SetOptions, (uint32_t), value);
 
   if (!CopyOnWrite_Impl())

 }
 
 void SBTypeSummary::SetSummaryString(const char *data) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBTypeSummary, SetSummaryString, (const char *),
                      data);
 

 }
 
 void SBTypeSummary::SetFunctionName(const char *data) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBTypeSummary, SetFunctionName, (const char *),
                      data);
 

 }
 
 void SBTypeSummary::SetFunctionCode(const char *data) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBTypeSummary, SetFunctionCode, (const char *),
                      data);
 

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

 }
 
 bool SBTypeSummary::DoesPrintValue(lldb::SBValue value) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBTypeSummary, DoesPrintValue, (lldb::SBValue),
                      value);
 

 }
 
 lldb::SBTypeSummary &SBTypeSummary::operator=(const lldb::SBTypeSummary &rhs) {
-  LLDB_RECORD_METHOD(lldb::SBTypeSummary &,
-                     SBTypeSummary, operator=,(const lldb::SBTypeSummary &),
-                     rhs);
+  LLDB_SCOPED_TIMER();
+  LLDB_RECORD_METHOD(lldb::SBTypeSummary &, SBTypeSummary, operator=,
+                     (const lldb::SBTypeSummary &), rhs);
 
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;

 }
 
 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())

 }
 
 bool SBTypeSummary::IsEqualTo(lldb::SBTypeSummary &rhs) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBTypeSummary, IsEqualTo, (lldb::SBTypeSummary &),
                      rhs);
 

 }
 
 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())

lldb/source/API/SBTypeSynthetic.cpp

 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())

 }
 
 bool SBTypeSynthetic::IsClassName() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSynthetic, IsClassName);
 
   if (!IsValid())

 }
 
 const char *SBTypeSynthetic::GetData() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeSynthetic, GetData);
 
   if (!IsValid())

 }
 
 void SBTypeSynthetic::SetClassName(const char *data) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBTypeSynthetic, SetClassName, (const char *), data);
 
   if (IsValid() && data && *data)

 }
 
 void SBTypeSynthetic::SetClassCode(const char *data) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBTypeSynthetic, SetClassCode, (const char *), data);
 
   if (IsValid() && data && *data)

 }
 
 uint32_t SBTypeSynthetic::GetOptions() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeSynthetic, GetOptions);
 
   if (!IsValid())

 }
 
 void SBTypeSynthetic::SetOptions(uint32_t value) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBTypeSynthetic, SetOptions, (uint32_t), value);
 
   if (!CopyOnWrite_Impl())

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

 
 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;

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

 }
 
 bool SBTypeSynthetic::IsEqualTo(lldb::SBTypeSynthetic &rhs) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBTypeSynthetic, IsEqualTo,
                      (lldb::SBTypeSynthetic &), rhs);
 

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

lldb/source/API/SBUnixSignals.cpp

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

 }
 
 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<bool>(GetSP());
 }
 
 const char *SBUnixSignals::GetSignalAsCString(int32_t signo) const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST(const char *, SBUnixSignals, GetSignalAsCString,
                            (int32_t), signo);
 

 }
 
 int32_t SBUnixSignals::GetSignalNumberFromName(const char *name) const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST(int32_t, SBUnixSignals, GetSignalNumberFromName,
                            (const char *), name);
 

 }
 
 bool SBUnixSignals::GetShouldSuppress(int32_t signo) const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST(bool, SBUnixSignals, GetShouldSuppress, (int32_t),
                            signo);
 

 }
 
 bool SBUnixSignals::SetShouldSuppress(int32_t signo, bool value) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldSuppress, (int32_t, bool),
                      signo, value);
 

 }
 
 bool SBUnixSignals::GetShouldStop(int32_t signo) const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST(bool, SBUnixSignals, GetShouldStop, (int32_t),
                            signo);
 

 }
 
 bool SBUnixSignals::SetShouldStop(int32_t signo, bool value) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldStop, (int32_t, bool), signo,
                      value);
 

 }
 
 bool SBUnixSignals::GetShouldNotify(int32_t signo) const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST(bool, SBUnixSignals, GetShouldNotify, (int32_t),
                            signo);
 

 }
 
 bool SBUnixSignals::SetShouldNotify(int32_t signo, bool value) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldNotify, (int32_t, bool),
                      signo, value);
 

 }
 
 int32_t SBUnixSignals::GetNumSignals() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(int32_t, SBUnixSignals, GetNumSignals);
 
   if (auto signals_sp = GetSP())

 }
 
 int32_t SBUnixSignals::GetSignalAtIndex(int32_t index) const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST(int32_t, SBUnixSignals, GetSignalAtIndex, (int32_t),
                            index);
 

lldb/source/API/SBValue.cpp

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

 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

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

 }
 
 user_id_t SBValue::GetID() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::user_id_t, SBValue, GetID);
 
   ValueLocker locker;

 }
 
 const char *SBValue::GetName() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetName);
 
   const char *name = nullptr;

 }
 
 const char *SBValue::GetTypeName() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetTypeName);
 
   const char *name = nullptr;

 }
 
 const char *SBValue::GetDisplayTypeName() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetDisplayTypeName);
 
   const char *name = nullptr;

 }
 
 size_t SBValue::GetByteSize() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(size_t, SBValue, GetByteSize);
 
   size_t result = 0;

 }
 
 bool SBValue::IsInScope() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsInScope);
 
   bool result = false;

 }
 
 const char *SBValue::GetValue() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetValue);
 
   const char *cstr = nullptr;

 }
 
 ValueType SBValue::GetValueType() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::ValueType, SBValue, GetValueType);
 
   ValueType result = eValueTypeInvalid;

 }
 
 const char *SBValue::GetObjectDescription() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetObjectDescription);
 
   const char *cstr = nullptr;

 }
 
 SBType SBValue::GetType() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBValue, GetType);
 
   SBType sb_type;

 }
 
 bool SBValue::GetValueDidChange() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, GetValueDidChange);
 
   bool result = false;

 }
 
 const char *SBValue::GetSummary() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetSummary);
 
   const char *cstr = nullptr;

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

 }
 
 const char *SBValue::GetLocation() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetLocation);
 
   const char *cstr = nullptr;

 
 // 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);
 

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

 }
 
 lldb::SBTypeFormat SBValue::GetTypeFormat() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeFormat, SBValue, GetTypeFormat);
 
   lldb::SBTypeFormat format;

 }
 
 lldb::SBTypeSummary SBValue::GetTypeSummary() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeSummary, SBValue, GetTypeSummary);
 
   lldb::SBTypeSummary summary;

 }
 
 lldb::SBTypeFilter SBValue::GetTypeFilter() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeFilter, SBValue, GetTypeFilter);
 
   lldb::SBTypeFilter filter;

 }
 
 lldb::SBTypeSynthetic SBValue::GetTypeSynthetic() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeSynthetic, SBValue, GetTypeSynthetic);
 
   lldb::SBTypeSynthetic synthetic;

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

 }
 
 lldb::SBValue SBValue::Cast(SBType type) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBValue, SBValue, Cast, (lldb::SBType), type);
 
   lldb::SBValue sb_value;

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

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

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

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

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

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

 }
 
 uint32_t SBValue::GetIndexOfChildWithName(const char *name) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(uint32_t, SBValue, GetIndexOfChildWithName, (const char *),
                      name);
 

 }
 
 SBValue SBValue::GetChildMemberWithName(const char *name) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName,
                      (const char *), name);
 

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

 }
 
 lldb::SBValue SBValue::GetDynamicValue(lldb::DynamicValueType use_dynamic) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetDynamicValue,
                      (lldb::DynamicValueType), use_dynamic);
 

 }
 
 lldb::SBValue SBValue::GetStaticValue() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, GetStaticValue);
 
   SBValue value_sb;

 }
 
 lldb::SBValue SBValue::GetNonSyntheticValue() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, GetNonSyntheticValue);
 
   SBValue value_sb;

 }
 
 lldb::DynamicValueType SBValue::GetPreferDynamicValue() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::DynamicValueType, SBValue,
                              GetPreferDynamicValue);
 

 }
 
 void SBValue::SetPreferDynamicValue(lldb::DynamicValueType use_dynamic) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBValue, SetPreferDynamicValue,
                      (lldb::DynamicValueType), use_dynamic);
 

 }
 
 bool SBValue::GetPreferSyntheticValue() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, GetPreferSyntheticValue);
 
   if (!IsValid())

 }
 
 void SBValue::SetPreferSyntheticValue(bool use_synthetic) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBValue, SetPreferSyntheticValue, (bool),
                      use_synthetic);
 

 }
 
 bool SBValue::IsDynamic() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsDynamic);
 
   ValueLocker locker;

 }
 
 bool SBValue::IsSynthetic() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsSynthetic);
 
   ValueLocker locker;

 }
 
 bool SBValue::IsSyntheticChildrenGenerated() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsSyntheticChildrenGenerated);
 
   ValueLocker locker;

 }
 
 void SBValue::SetSyntheticChildrenGenerated(bool is) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBValue, SetSyntheticChildrenGenerated, (bool), is);
 
   ValueLocker locker;

 }
 
 lldb::SBValue SBValue::GetValueForExpressionPath(const char *expr_path) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetValueForExpressionPath,
                      (const char *), expr_path);
 

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

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

 }
 
 int64_t SBValue::GetValueAsSigned(int64_t fail_value) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(int64_t, SBValue, GetValueAsSigned, (int64_t), fail_value);
 
   ValueLocker locker;

 }
 
 uint64_t SBValue::GetValueAsUnsigned(uint64_t fail_value) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(uint64_t, SBValue, GetValueAsUnsigned, (uint64_t),
                      fail_value);
 

 }
 
 bool SBValue::MightHaveChildren() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, MightHaveChildren);
 
   bool has_children = false;

 }
 
 bool SBValue::IsRuntimeSupportValue() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsRuntimeSupportValue);
 
   bool is_support = false;

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

 }
 
 SBValue SBValue::Dereference() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, Dereference);
 
   SBValue sb_value;

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

 }
 
 lldb::SBTarget SBValue::GetTarget() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBValue, GetTarget);
 
   SBTarget sb_target;

 }
 
 lldb::SBProcess SBValue::GetProcess() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBValue, GetProcess);
 
   SBProcess sb_process;

 }
 
 lldb::SBThread SBValue::GetThread() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBThread, SBValue, GetThread);
 
   SBThread sb_thread;

 }
 
 lldb::SBFrame SBValue::GetFrame() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFrame, SBValue, GetFrame);
 
   SBFrame sb_frame;

 }
 
 lldb::ValueObjectSP SBValue::GetSP() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ValueObjectSP, SBValue, GetSP);
 
   ValueLocker locker;

 }
 
 bool SBValue::GetExpressionPath(SBStream &description) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBValue, GetExpressionPath, (lldb::SBStream &),
                      description);
 

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

 }
 
 lldb::SBValue SBValue::EvaluateExpression(const char *expr) const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValue, EvaluateExpression,
                            (const char *), expr);
 

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

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

 }
 
 bool SBValue::GetDescription(SBStream &description) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBValue, GetDescription, (lldb::SBStream &),
                      description);
 

 }
 
 lldb::Format SBValue::GetFormat() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::Format, SBValue, GetFormat);
 
   ValueLocker locker;

 }
 
 void SBValue::SetFormat(lldb::Format format) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBValue, SetFormat, (lldb::Format), format);
 
   ValueLocker locker;

 }
 
 lldb::SBValue SBValue::AddressOf() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, AddressOf);
 
   SBValue sb_value;

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

 }
 
 lldb::SBAddress SBValue::GetAddress() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBValue, GetAddress);
 
   Address addr;

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

 }
 
 lldb::SBData SBValue::GetData() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBData, SBValue, GetData);
 
   lldb::SBData sb_data;

 }
 
 bool SBValue::SetData(lldb::SBData &data, SBError &error) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBValue, SetData, (lldb::SBData &, lldb::SBError &),
                      data, error);
 

 }
 
 lldb::SBValue SBValue::Clone(const char *new_name) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBValue, SBValue, Clone, (const char *), new_name);
 
   ValueLocker locker;

 }
 
 lldb::SBDeclaration SBValue::GetDeclaration() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBDeclaration, SBValue, GetDeclaration);
 
   ValueLocker locker;

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

 // 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);
 

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

 }
 
 lldb::SBValue SBValue::Persist() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, Persist);
 
   ValueLocker locker;

lldb/source/API/SBValueList.cpp

 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())

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

 }
 
 void SBValueList::Append(const lldb::SBValueList &value_list) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBValueList, Append, (const lldb::SBValueList &),
                      value_list);
 

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

 }
 
 uint32_t SBValueList::GetSize() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBValueList, GetSize);
 
   uint32_t size = 0;

 }
 
 SBValue SBValueList::FindValueObjectByUID(lldb::user_id_t uid) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(lldb::SBValue, SBValueList, FindValueObjectByUID,
                      (lldb::user_id_t), uid);
 

 }
 
 SBValue SBValueList::GetFirstValueByName(const char *name) const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValueList, GetFirstValueByName,
                            (const char *), name);
 

lldb/source/API/SBVariablesOptions.cpp

 
 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<VariablesOptionsImpl>(options.ref());
   return *this;

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

 }
 
 void SBVariablesOptions::SetIncludeArguments(bool arguments) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeArguments, (bool),
                      arguments);
 

 
 bool SBVariablesOptions::GetIncludeRecognizedArguments(
     const lldb::SBTarget &target) const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST(bool, SBVariablesOptions,
                            GetIncludeRecognizedArguments,
                            (const lldb::SBTarget &), target);

 }
 
 void SBVariablesOptions::SetIncludeRecognizedArguments(bool arguments) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeRecognizedArguments,
                      (bool), arguments);
 

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

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

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

 }
 
 bool SBVariablesOptions::GetIncludeRuntimeSupportValues() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions,
                                    GetIncludeRuntimeSupportValues);
 

 
 void SBVariablesOptions::SetIncludeRuntimeSupportValues(
     bool runtime_support_values) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeRuntimeSupportValues,
                      (bool), runtime_support_values);
 

 }
 
 lldb::DynamicValueType SBVariablesOptions::GetUseDynamic() const {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::DynamicValueType, SBVariablesOptions,
                                    GetUseDynamic);
 

 }
 
 void SBVariablesOptions::SetUseDynamic(lldb::DynamicValueType dynamic) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBVariablesOptions, SetUseDynamic,
                      (lldb::DynamicValueType), dynamic);
 

lldb/source/API/SBWatchpoint.cpp

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

 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)

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

 }
 
 int32_t SBWatchpoint::GetHardwareIndex() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(int32_t, SBWatchpoint, GetHardwareIndex);
 
   int32_t hw_index = -1;

 }
 
 addr_t SBWatchpoint::GetWatchAddress() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBWatchpoint, GetWatchAddress);
 
   addr_t ret_addr = LLDB_INVALID_ADDRESS;

 }
 
 size_t SBWatchpoint::GetWatchSize() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(size_t, SBWatchpoint, GetWatchSize);
 
   size_t watch_size = 0;

 }
 
 void SBWatchpoint::SetEnabled(bool enabled) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBWatchpoint, SetEnabled, (bool), enabled);
 
   lldb::WatchpointSP watchpoint_sp(GetSP());

 }
 
 bool SBWatchpoint::IsEnabled() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBWatchpoint, IsEnabled);
 
   lldb::WatchpointSP watchpoint_sp(GetSP());

 }
 
 uint32_t SBWatchpoint::GetHitCount() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBWatchpoint, GetHitCount);
 
   uint32_t count = 0;

 }
 
 uint32_t SBWatchpoint::GetIgnoreCount() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBWatchpoint, GetIgnoreCount);
 
   lldb::WatchpointSP watchpoint_sp(GetSP());

 }
 
 void SBWatchpoint::SetIgnoreCount(uint32_t n) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBWatchpoint, SetIgnoreCount, (uint32_t), n);
 
   lldb::WatchpointSP watchpoint_sp(GetSP());

 }
 
 const char *SBWatchpoint::GetCondition() {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBWatchpoint, GetCondition);
 
   lldb::WatchpointSP watchpoint_sp(GetSP());

 }
 
 void SBWatchpoint::SetCondition(const char *condition) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(void, SBWatchpoint, SetCondition, (const char *),
                      condition);
 

 
 bool SBWatchpoint::GetDescription(SBStream &description,
                                   DescriptionLevel level) {
+  LLDB_SCOPED_TIMER();
   LLDB_RECORD_METHOD(bool, SBWatchpoint, GetDescription,
                      (lldb::SBStream &, lldb::DescriptionLevel), description,
                      level);

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