vendor/llvm-project/llvmorg-14-init-17616-g024a1fab5c35

1 files changed, 24 insertions, 59 deletions

diff --git a/lldb/source/API/SBQueue.cpp b/lldb/source/API/SBQueue.cpp
index 746df9e79d61..b2c143f6357e 100644
--- a/lldb/source/API/SBQueue.cpp
+++ b/lldb/source/API/SBQueue.cpp
@@ -8,8 +8,8 @@
 
 #include <cinttypes>
 
-#include "SBReproducerPrivate.h"
 #include "lldb/API/SBQueue.h"
+#include "lldb/Utility/Instrumentation.h"
 
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBQueueItem.h"
@@ -27,11 +27,10 @@ namespace lldb_private {
 
 class QueueImpl {
 public:
-  QueueImpl() : m_queue_wp(), m_threads(), m_pending_items() {}
+  QueueImpl() {}
 
   QueueImpl(const lldb::QueueSP &queue_sp)
-      : m_queue_wp(), m_threads(), m_thread_list_fetched(false),
-        m_pending_items(), m_pending_items_fetched(false) {
+      : m_thread_list_fetched(false), m_pending_items_fetched(false) {
     m_queue_wp = queue_sp;
   }
 
@@ -216,17 +215,15 @@ private:
 };
 }
 
-SBQueue::SBQueue() : m_opaque_sp(new QueueImpl()) {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBQueue);
-}
+SBQueue::SBQueue() : m_opaque_sp(new QueueImpl()) { LLDB_INSTRUMENT_VA(this); }
 
 SBQueue::SBQueue(const QueueSP &queue_sp)
     : m_opaque_sp(new QueueImpl(queue_sp)) {
-  LLDB_RECORD_CONSTRUCTOR(SBQueue, (const lldb::QueueSP &), queue_sp);
+  LLDB_INSTRUMENT_VA(this, queue_sp);
 }
 
 SBQueue::SBQueue(const SBQueue &rhs) {
-  LLDB_RECORD_CONSTRUCTOR(SBQueue, (const lldb::SBQueue &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (&rhs == this)
     return;
@@ -235,27 +232,26 @@ SBQueue::SBQueue(const SBQueue &rhs) {
 }
 
 const lldb::SBQueue &SBQueue::operator=(const lldb::SBQueue &rhs) {
-  LLDB_RECORD_METHOD(const lldb::SBQueue &,
-                     SBQueue, operator=,(const lldb::SBQueue &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_sp = rhs.m_opaque_sp;
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 SBQueue::~SBQueue() = default;
 
 bool SBQueue::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBQueue, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBQueue::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBQueue, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->IsValid();
 }
 
 void SBQueue::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBQueue, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   m_opaque_sp->Clear();
 }
@@ -265,94 +261,63 @@ void SBQueue::SetQueue(const QueueSP &queue_sp) {
 }
 
 lldb::queue_id_t SBQueue::GetQueueID() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::queue_id_t, SBQueue, GetQueueID);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetQueueID();
 }
 
 uint32_t SBQueue::GetIndexID() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBQueue, GetIndexID);
+  LLDB_INSTRUMENT_VA(this);
 
   uint32_t index_id = m_opaque_sp->GetIndexID();
   return index_id;
 }
 
 const char *SBQueue::GetName() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBQueue, GetName);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetName();
 }
 
 uint32_t SBQueue::GetNumThreads() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBQueue, GetNumThreads);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetNumThreads();
 }
 
 SBThread SBQueue::GetThreadAtIndex(uint32_t idx) {
-  LLDB_RECORD_METHOD(lldb::SBThread, SBQueue, GetThreadAtIndex, (uint32_t),
-                     idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   SBThread th = m_opaque_sp->GetThreadAtIndex(idx);
-  return LLDB_RECORD_RESULT(th);
+  return th;
 }
 
 uint32_t SBQueue::GetNumPendingItems() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBQueue, GetNumPendingItems);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetNumPendingItems();
 }
 
 SBQueueItem SBQueue::GetPendingItemAtIndex(uint32_t idx) {
-  LLDB_RECORD_METHOD(lldb::SBQueueItem, SBQueue, GetPendingItemAtIndex,
-                     (uint32_t), idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
-  return LLDB_RECORD_RESULT(m_opaque_sp->GetPendingItemAtIndex(idx));
+  return m_opaque_sp->GetPendingItemAtIndex(idx);
 }
 
 uint32_t SBQueue::GetNumRunningItems() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBQueue, GetNumRunningItems);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetNumRunningItems();
 }
 
 SBProcess SBQueue::GetProcess() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBQueue, GetProcess);
+  LLDB_INSTRUMENT_VA(this);
 
-  return LLDB_RECORD_RESULT(m_opaque_sp->GetProcess());
+  return m_opaque_sp->GetProcess();
 }
 
 lldb::QueueKind SBQueue::GetKind() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::QueueKind, SBQueue, GetKind);
+  LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetKind();
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBQueue>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBQueue, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBQueue, (const lldb::QueueSP &));
-  LLDB_REGISTER_CONSTRUCTOR(SBQueue, (const lldb::SBQueue &));
-  LLDB_REGISTER_METHOD(const lldb::SBQueue &,
-                       SBQueue, operator=,(const lldb::SBQueue &));
-  LLDB_REGISTER_METHOD_CONST(bool, SBQueue, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBQueue, operator bool, ());
-  LLDB_REGISTER_METHOD(void, SBQueue, Clear, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::queue_id_t, SBQueue, GetQueueID, ());
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBQueue, GetIndexID, ());
-  LLDB_REGISTER_METHOD_CONST(const char *, SBQueue, GetName, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBQueue, GetNumThreads, ());
-  LLDB_REGISTER_METHOD(lldb::SBThread, SBQueue, GetThreadAtIndex, (uint32_t));
-  LLDB_REGISTER_METHOD(uint32_t, SBQueue, GetNumPendingItems, ());
-  LLDB_REGISTER_METHOD(lldb::SBQueueItem, SBQueue, GetPendingItemAtIndex,
-                       (uint32_t));
-  LLDB_REGISTER_METHOD(uint32_t, SBQueue, GetNumRunningItems, ());
-  LLDB_REGISTER_METHOD(lldb::SBProcess, SBQueue, GetProcess, ());
-  LLDB_REGISTER_METHOD(lldb::QueueKind, SBQueue, GetKind, ());
-}
-
-}
-}