[Lldb-commits] [lldb] 1755f5b - [lldb] Decouple instrumentation from the reproducers
Jonas Devlieghere via lldb-commits
lldb-commits at lists.llvm.org
Thu Jan 20 18:06:24 PST 2022
Author: Jonas Devlieghere
Date: 2022-01-20T18:06:14-08:00
New Revision: 1755f5b1d7b7871672abdf0fde5ccd091b8dbc04
URL: https://github.com/llvm/llvm-project/commit/1755f5b1d7b7871672abdf0fde5ccd091b8dbc04
DIFF: https://github.com/llvm/llvm-project/commit/1755f5b1d7b7871672abdf0fde5ccd091b8dbc04.diff
LOG: [lldb] Decouple instrumentation from the reproducers
Remove the last remaining references to the reproducers from the
instrumentation. This patch renames the relevant files and macros.
Differential revision: https://reviews.llvm.org/D117712
Added:
lldb/include/lldb/Utility/Instrumentation.h
lldb/source/Utility/Instrumentation.cpp
Modified:
lldb/source/API/SBAddress.cpp
lldb/source/API/SBAttachInfo.cpp
lldb/source/API/SBBlock.cpp
lldb/source/API/SBBreakpoint.cpp
lldb/source/API/SBBreakpointLocation.cpp
lldb/source/API/SBBreakpointName.cpp
lldb/source/API/SBBreakpointOptionCommon.cpp
lldb/source/API/SBBroadcaster.cpp
lldb/source/API/SBCommandInterpreter.cpp
lldb/source/API/SBCommandInterpreterRunOptions.cpp
lldb/source/API/SBCommandReturnObject.cpp
lldb/source/API/SBCommunication.cpp
lldb/source/API/SBCompileUnit.cpp
lldb/source/API/SBData.cpp
lldb/source/API/SBDebugger.cpp
lldb/source/API/SBDeclaration.cpp
lldb/source/API/SBEnvironment.cpp
lldb/source/API/SBError.cpp
lldb/source/API/SBEvent.cpp
lldb/source/API/SBExecutionContext.cpp
lldb/source/API/SBExpressionOptions.cpp
lldb/source/API/SBFile.cpp
lldb/source/API/SBFileSpec.cpp
lldb/source/API/SBFileSpecList.cpp
lldb/source/API/SBFrame.cpp
lldb/source/API/SBFunction.cpp
lldb/source/API/SBHostOS.cpp
lldb/source/API/SBInstruction.cpp
lldb/source/API/SBInstructionList.cpp
lldb/source/API/SBLanguageRuntime.cpp
lldb/source/API/SBLaunchInfo.cpp
lldb/source/API/SBLineEntry.cpp
lldb/source/API/SBListener.cpp
lldb/source/API/SBMemoryRegionInfo.cpp
lldb/source/API/SBMemoryRegionInfoList.cpp
lldb/source/API/SBModule.cpp
lldb/source/API/SBModuleSpec.cpp
lldb/source/API/SBPlatform.cpp
lldb/source/API/SBProcess.cpp
lldb/source/API/SBProcessInfo.cpp
lldb/source/API/SBQueue.cpp
lldb/source/API/SBQueueItem.cpp
lldb/source/API/SBReproducer.cpp
lldb/source/API/SBSection.cpp
lldb/source/API/SBSourceManager.cpp
lldb/source/API/SBStream.cpp
lldb/source/API/SBStringList.cpp
lldb/source/API/SBStructuredData.cpp
lldb/source/API/SBSymbol.cpp
lldb/source/API/SBSymbolContext.cpp
lldb/source/API/SBSymbolContextList.cpp
lldb/source/API/SBTarget.cpp
lldb/source/API/SBThread.cpp
lldb/source/API/SBThreadCollection.cpp
lldb/source/API/SBThreadPlan.cpp
lldb/source/API/SBTrace.cpp
lldb/source/API/SBType.cpp
lldb/source/API/SBTypeCategory.cpp
lldb/source/API/SBTypeEnumMember.cpp
lldb/source/API/SBTypeFilter.cpp
lldb/source/API/SBTypeFormat.cpp
lldb/source/API/SBTypeNameSpecifier.cpp
lldb/source/API/SBTypeSummary.cpp
lldb/source/API/SBTypeSynthetic.cpp
lldb/source/API/SBUnixSignals.cpp
lldb/source/API/SBValue.cpp
lldb/source/API/SBValueList.cpp
lldb/source/API/SBVariablesOptions.cpp
lldb/source/API/SBWatchpoint.cpp
lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp
lldb/source/Utility/CMakeLists.txt
Removed:
lldb/include/lldb/Utility/ReproducerInstrumentation.h
lldb/source/Utility/ReproducerInstrumentation.cpp
################################################################################
diff --git a/lldb/include/lldb/Utility/Instrumentation.h b/lldb/include/lldb/Utility/Instrumentation.h
new file mode 100644
index 000000000000..6962270bb89d
--- /dev/null
+++ b/lldb/include/lldb/Utility/Instrumentation.h
@@ -0,0 +1,103 @@
+//===-- Instrumentation.h ---------------------------------------*- C++ -*-===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_UTILITY_INSTRUMENTATION_H
+#define LLDB_UTILITY_INSTRUMENTATION_H
+
+#include "lldb/Utility/FileSpec.h"
+#include "lldb/Utility/Log.h"
+#include "lldb/Utility/Logging.h"
+
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/ErrorHandling.h"
+
+#include <map>
+#include <thread>
+#include <type_traits>
+
+namespace lldb_private {
+namespace instrumentation {
+
+template <typename T,
+ typename std::enable_if<std::is_fundamental<T>::value, int>::type = 0>
+inline void stringify_append(llvm::raw_string_ostream &ss, const T &t) {
+ ss << t;
+}
+
+template <typename T, typename std::enable_if<!std::is_fundamental<T>::value,
+ int>::type = 0>
+inline void stringify_append(llvm::raw_string_ostream &ss, const T &t) {
+ ss << &t;
+}
+
+template <typename T>
+inline void stringify_append(llvm::raw_string_ostream &ss, T *t) {
+ ss << reinterpret_cast<void *>(t);
+}
+
+template <typename T>
+inline void stringify_append(llvm::raw_string_ostream &ss, const T *t) {
+ ss << reinterpret_cast<const void *>(t);
+}
+
+template <>
+inline void stringify_append<char>(llvm::raw_string_ostream &ss,
+ const char *t) {
+ ss << '\"' << t << '\"';
+}
+
+template <>
+inline void stringify_append<std::nullptr_t>(llvm::raw_string_ostream &ss,
+ const std::nullptr_t &t) {
+ ss << "\"nullptr\"";
+}
+
+template <typename Head>
+inline void stringify_helper(llvm::raw_string_ostream &ss, const Head &head) {
+ stringify_append(ss, head);
+}
+
+template <typename Head, typename... Tail>
+inline void stringify_helper(llvm::raw_string_ostream &ss, const Head &head,
+ const Tail &...tail) {
+ stringify_append(ss, head);
+ ss << ", ";
+ stringify_helper(ss, tail...);
+}
+
+template <typename... Ts> inline std::string stringify_args(const Ts &...ts) {
+ std::string buffer;
+ llvm::raw_string_ostream ss(buffer);
+ stringify_helper(ss, ts...);
+ return ss.str();
+}
+
+/// RAII object for instrumenting LLDB API functions.
+class Instrumenter {
+public:
+ Instrumenter(llvm::StringRef pretty_func, std::string &&pretty_args = {});
+ ~Instrumenter();
+
+private:
+ void UpdateBoundary();
+
+ /// Whether this function call was the one crossing the API boundary.
+ bool m_local_boundary = false;
+};
+} // namespace instrumentation
+} // namespace lldb_private
+
+#define LLDB_INSTRUMENT() \
+ lldb_private::instrumentation::Instrumenter _instr(LLVM_PRETTY_FUNCTION);
+
+#define LLDB_INSTRUMENT_VA(...) \
+ lldb_private::instrumentation::Instrumenter _instr( \
+ LLVM_PRETTY_FUNCTION, \
+ lldb_private::instrumentation::stringify_args(__VA_ARGS__));
+
+#endif // LLDB_UTILITY_INSTRUMENTATION_H
diff --git a/lldb/include/lldb/Utility/ReproducerInstrumentation.h b/lldb/include/lldb/Utility/ReproducerInstrumentation.h
deleted file mode 100644
index 3bce7b8f3a6f..000000000000
--- a/lldb/include/lldb/Utility/ReproducerInstrumentation.h
+++ /dev/null
@@ -1,151 +0,0 @@
-//===-- ReproducerInstrumentation.h -----------------------------*- C++ -*-===//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLDB_UTILITY_REPRODUCERINSTRUMENTATION_H
-#define LLDB_UTILITY_REPRODUCERINSTRUMENTATION_H
-
-#include "lldb/Utility/FileSpec.h"
-#include "lldb/Utility/Log.h"
-#include "lldb/Utility/Logging.h"
-
-#include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/Support/ErrorHandling.h"
-
-#include <map>
-#include <thread>
-#include <type_traits>
-
-template <typename T,
- typename std::enable_if<std::is_fundamental<T>::value, int>::type = 0>
-inline void stringify_append(llvm::raw_string_ostream &ss, const T &t) {
- ss << t;
-}
-
-template <typename T, typename std::enable_if<!std::is_fundamental<T>::value,
- int>::type = 0>
-inline void stringify_append(llvm::raw_string_ostream &ss, const T &t) {
- ss << &t;
-}
-
-template <typename T>
-inline void stringify_append(llvm::raw_string_ostream &ss, T *t) {
- ss << reinterpret_cast<void *>(t);
-}
-
-template <typename T>
-inline void stringify_append(llvm::raw_string_ostream &ss, const T *t) {
- ss << reinterpret_cast<const void *>(t);
-}
-
-template <>
-inline void stringify_append<char>(llvm::raw_string_ostream &ss,
- const char *t) {
- ss << '\"' << t << '\"';
-}
-
-template <>
-inline void stringify_append<std::nullptr_t>(llvm::raw_string_ostream &ss,
- const std::nullptr_t &t) {
- ss << "\"nullptr\"";
-}
-
-template <typename Head>
-inline void stringify_helper(llvm::raw_string_ostream &ss, const Head &head) {
- stringify_append(ss, head);
-}
-
-template <typename Head, typename... Tail>
-inline void stringify_helper(llvm::raw_string_ostream &ss, const Head &head,
- const Tail &... tail) {
- stringify_append(ss, head);
- ss << ", ";
- stringify_helper(ss, tail...);
-}
-
-template <typename... Ts> inline std::string stringify_args(const Ts &... ts) {
- std::string buffer;
- llvm::raw_string_ostream ss(buffer);
- stringify_helper(ss, ts...);
- return ss.str();
-}
-
-#define LLDB_CONSTRUCT_(T, Class, ...) \
- lldb_private::repro::Recorder _recorder(LLVM_PRETTY_FUNCTION);
-
-#define LLDB_RECORD_CONSTRUCTOR(Class, Signature, ...) \
- LLDB_CONSTRUCT_(Class Signature, this, __VA_ARGS__)
-
-#define LLDB_RECORD_CONSTRUCTOR_NO_ARGS(Class) \
- LLDB_CONSTRUCT_(Class(), this, lldb_private::repro::EmptyArg())
-
-#define LLDB_RECORD_(T1, T2, ...) \
- lldb_private::repro::Recorder _recorder(LLVM_PRETTY_FUNCTION, \
- stringify_args(__VA_ARGS__));
-
-#define LLDB_RECORD_METHOD(Result, Class, Method, Signature, ...) \
- LLDB_RECORD_(Result(Class::*) Signature, (&Class::Method), this, __VA_ARGS__)
-
-#define LLDB_RECORD_METHOD_CONST(Result, Class, Method, Signature, ...) \
- LLDB_RECORD_(Result(Class::*) Signature const, (&Class::Method), this, \
- __VA_ARGS__)
-
-#define LLDB_RECORD_METHOD_NO_ARGS(Result, Class, Method) \
- LLDB_RECORD_(Result (Class::*)(), (&Class::Method), this)
-
-#define LLDB_RECORD_METHOD_CONST_NO_ARGS(Result, Class, Method) \
- LLDB_RECORD_(Result (Class::*)() const, (&Class::Method), this)
-
-#define LLDB_RECORD_STATIC_METHOD(Result, Class, Method, Signature, ...) \
- LLDB_RECORD_(Result(*) Signature, (&Class::Method), __VA_ARGS__)
-
-#define LLDB_RECORD_STATIC_METHOD_NO_ARGS(Result, Class, Method) \
- LLDB_RECORD_(Result (*)(), (&Class::Method), lldb_private::repro::EmptyArg())
-
-/// The LLDB_RECORD_DUMMY macro is special because it doesn't actually record
-/// anything. It's used to track API boundaries when we cannot record for
-/// technical reasons.
-#define LLDB_RECORD_DUMMY(Result, Class, Method, Signature, ...) \
- lldb_private::repro::Recorder _recorder;
-
-#define LLDB_RECORD_DUMMY_NO_ARGS(Result, Class, Method) \
- lldb_private::repro::Recorder _recorder;
-
-namespace lldb_private {
-namespace repro {
-
-struct EmptyArg {};
-
-/// RAII object that records function invocations and their return value.
-///
-/// API calls are only captured when the API boundary is crossed. Once we're in
-/// the API layer, and another API function is called, it doesn't need to be
-/// recorded.
-///
-/// When a call is recored, its result is always recorded as well, even if the
-/// function returns a void. For functions that return by value, RecordResult
-/// should be used. Otherwise a sentinel value (0) will be serialized.
-///
-/// Because of the functional overlap between logging and recording API calls,
-/// this class is also used for logging.
-class Recorder {
-public:
- Recorder();
- Recorder(llvm::StringRef pretty_func, std::string &&pretty_args = {});
- ~Recorder();
-
-private:
- void UpdateBoundary();
-
- /// Whether this function call was the one crossing the API boundary.
- bool m_local_boundary = false;
-};
-
-} // namespace repro
-} // namespace lldb_private
-
-#endif // LLDB_UTILITY_REPRODUCERINSTRUMENTATION_H
diff --git a/lldb/source/API/SBAddress.cpp b/lldb/source/API/SBAddress.cpp
index af1b876d803d..e519f0bcc83c 100644
--- a/lldb/source/API/SBAddress.cpp
+++ b/lldb/source/API/SBAddress.cpp
@@ -7,7 +7,6 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBAddress.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/API/SBProcess.h"
#include "lldb/API/SBSection.h"
@@ -16,35 +15,34 @@
#include "lldb/Core/Module.h"
#include "lldb/Symbol/LineEntry.h"
#include "lldb/Target/Target.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb;
using namespace lldb_private;
SBAddress::SBAddress() : m_opaque_up(new Address()) {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBAddress);
+ LLDB_INSTRUMENT_VA(this);
}
SBAddress::SBAddress(const Address &address)
: m_opaque_up(std::make_unique<Address>(address)) {}
SBAddress::SBAddress(const SBAddress &rhs) : m_opaque_up(new Address()) {
- LLDB_RECORD_CONSTRUCTOR(SBAddress, (const lldb::SBAddress &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_up = clone(rhs.m_opaque_up);
}
SBAddress::SBAddress(lldb::SBSection section, lldb::addr_t offset)
: m_opaque_up(new Address(section.GetSP(), offset)) {
- LLDB_RECORD_CONSTRUCTOR(SBAddress, (lldb::SBSection, lldb::addr_t), section,
- offset);
+ LLDB_INSTRUMENT_VA(this, section, offset);
}
// Create an address by resolving a load address using the supplied target
SBAddress::SBAddress(lldb::addr_t load_addr, lldb::SBTarget &target)
: m_opaque_up(new Address()) {
- LLDB_RECORD_CONSTRUCTOR(SBAddress, (lldb::addr_t, lldb::SBTarget &),
- load_addr, target);
+ LLDB_INSTRUMENT_VA(this, load_addr, target);
SetLoadAddress(load_addr, target);
}
@@ -52,8 +50,7 @@ SBAddress::SBAddress(lldb::addr_t load_addr, lldb::SBTarget &target)
SBAddress::~SBAddress() = default;
const SBAddress &SBAddress::operator=(const SBAddress &rhs) {
- LLDB_RECORD_METHOD(const lldb::SBAddress &,
- SBAddress, operator=,(const lldb::SBAddress &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
@@ -67,31 +64,29 @@ bool lldb::operator==(const SBAddress &lhs, const SBAddress &rhs) {
}
bool SBAddress::operator!=(const SBAddress &rhs) const {
- LLDB_RECORD_METHOD_CONST(bool, SBAddress, operator!=,(const SBAddress &),
- &rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
return !(*this == rhs);
}
bool SBAddress::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBAddress, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBAddress::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBAddress, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up != nullptr && m_opaque_up->IsValid();
}
void SBAddress::Clear() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBAddress, Clear);
+ LLDB_INSTRUMENT_VA(this);
m_opaque_up = std::make_unique<Address>();
}
void SBAddress::SetAddress(lldb::SBSection section, lldb::addr_t offset) {
- LLDB_RECORD_METHOD(void, SBAddress, SetAddress,
- (lldb::SBSection, lldb::addr_t), section, offset);
+ LLDB_INSTRUMENT_VA(this, section, offset);
Address &addr = ref();
addr.SetSection(section.GetSP());
@@ -101,7 +96,7 @@ void SBAddress::SetAddress(lldb::SBSection section, lldb::addr_t offset) {
void SBAddress::SetAddress(const Address &address) { ref() = address; }
lldb::addr_t SBAddress::GetFileAddress() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBAddress, GetFileAddress);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_up->IsValid())
return m_opaque_up->GetFileAddress();
@@ -110,8 +105,7 @@ lldb::addr_t SBAddress::GetFileAddress() const {
}
lldb::addr_t SBAddress::GetLoadAddress(const SBTarget &target) const {
- LLDB_RECORD_METHOD_CONST(lldb::addr_t, SBAddress, GetLoadAddress,
- (const lldb::SBTarget &), target);
+ LLDB_INSTRUMENT_VA(this, target);
lldb::addr_t addr = LLDB_INVALID_ADDRESS;
TargetSP target_sp(target.GetSP());
@@ -126,8 +120,7 @@ lldb::addr_t SBAddress::GetLoadAddress(const SBTarget &target) const {
}
void SBAddress::SetLoadAddress(lldb::addr_t load_addr, lldb::SBTarget &target) {
- LLDB_RECORD_METHOD(void, SBAddress, SetLoadAddress,
- (lldb::addr_t, lldb::SBTarget &), load_addr, target);
+ LLDB_INSTRUMENT_VA(this, load_addr, target);
// Create the address object if we don't already have one
ref();
@@ -144,7 +137,7 @@ void SBAddress::SetLoadAddress(lldb::addr_t load_addr, lldb::SBTarget &target) {
}
bool SBAddress::OffsetAddress(addr_t offset) {
- LLDB_RECORD_METHOD(bool, SBAddress, OffsetAddress, (lldb::addr_t), offset);
+ LLDB_INSTRUMENT_VA(this, offset);
if (m_opaque_up->IsValid()) {
addr_t addr_offset = m_opaque_up->GetOffset();
@@ -157,7 +150,7 @@ bool SBAddress::OffsetAddress(addr_t offset) {
}
lldb::SBSection SBAddress::GetSection() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSection, SBAddress, GetSection);
+ LLDB_INSTRUMENT_VA(this);
lldb::SBSection sb_section;
if (m_opaque_up->IsValid())
@@ -166,7 +159,7 @@ lldb::SBSection SBAddress::GetSection() {
}
lldb::addr_t SBAddress::GetOffset() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBAddress, GetOffset);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_up->IsValid())
return m_opaque_up->GetOffset();
@@ -193,8 +186,7 @@ const Address &SBAddress::ref() const {
Address *SBAddress::get() { return m_opaque_up.get(); }
bool SBAddress::GetDescription(SBStream &description) {
- LLDB_RECORD_METHOD(bool, SBAddress, GetDescription, (lldb::SBStream &),
- description);
+ LLDB_INSTRUMENT_VA(this, description);
// Call "ref()" on the stream to make sure it creates a backing stream in
// case there isn't one already...
@@ -209,7 +201,7 @@ bool SBAddress::GetDescription(SBStream &description) {
}
SBModule SBAddress::GetModule() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBModule, SBAddress, GetModule);
+ LLDB_INSTRUMENT_VA(this);
SBModule sb_module;
if (m_opaque_up->IsValid())
@@ -218,8 +210,7 @@ SBModule SBAddress::GetModule() {
}
SBSymbolContext SBAddress::GetSymbolContext(uint32_t resolve_scope) {
- LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBAddress, GetSymbolContext,
- (uint32_t), resolve_scope);
+ LLDB_INSTRUMENT_VA(this, resolve_scope);
SBSymbolContext sb_sc;
SymbolContextItem scope = static_cast<SymbolContextItem>(resolve_scope);
@@ -229,7 +220,7 @@ SBSymbolContext SBAddress::GetSymbolContext(uint32_t resolve_scope) {
}
SBCompileUnit SBAddress::GetCompileUnit() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCompileUnit, SBAddress, GetCompileUnit);
+ LLDB_INSTRUMENT_VA(this);
SBCompileUnit sb_comp_unit;
if (m_opaque_up->IsValid())
@@ -238,7 +229,7 @@ SBCompileUnit SBAddress::GetCompileUnit() {
}
SBFunction SBAddress::GetFunction() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFunction, SBAddress, GetFunction);
+ LLDB_INSTRUMENT_VA(this);
SBFunction sb_function;
if (m_opaque_up->IsValid())
@@ -247,7 +238,7 @@ SBFunction SBAddress::GetFunction() {
}
SBBlock SBAddress::GetBlock() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBAddress, GetBlock);
+ LLDB_INSTRUMENT_VA(this);
SBBlock sb_block;
if (m_opaque_up->IsValid())
@@ -256,7 +247,7 @@ SBBlock SBAddress::GetBlock() {
}
SBSymbol SBAddress::GetSymbol() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSymbol, SBAddress, GetSymbol);
+ LLDB_INSTRUMENT_VA(this);
SBSymbol sb_symbol;
if (m_opaque_up->IsValid())
@@ -265,7 +256,7 @@ SBSymbol SBAddress::GetSymbol() {
}
SBLineEntry SBAddress::GetLineEntry() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBLineEntry, SBAddress, GetLineEntry);
+ LLDB_INSTRUMENT_VA(this);
SBLineEntry sb_line_entry;
if (m_opaque_up->IsValid()) {
diff --git a/lldb/source/API/SBAttachInfo.cpp b/lldb/source/API/SBAttachInfo.cpp
index 8118088a38ec..edb4f7104d41 100644
--- a/lldb/source/API/SBAttachInfo.cpp
+++ b/lldb/source/API/SBAttachInfo.cpp
@@ -7,29 +7,29 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBAttachInfo.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/API/SBFileSpec.h"
#include "lldb/API/SBListener.h"
#include "lldb/Target/Process.h"
+#include "lldb/Utility/Instrumentation.h"
using namespace lldb;
using namespace lldb_private;
SBAttachInfo::SBAttachInfo() : m_opaque_sp(new ProcessAttachInfo()) {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBAttachInfo);
+ LLDB_INSTRUMENT_VA(this);
}
SBAttachInfo::SBAttachInfo(lldb::pid_t pid)
: m_opaque_sp(new ProcessAttachInfo()) {
- LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (lldb::pid_t), pid);
+ LLDB_INSTRUMENT_VA(this, pid);
m_opaque_sp->SetProcessID(pid);
}
SBAttachInfo::SBAttachInfo(const char *path, bool wait_for)
: m_opaque_sp(new ProcessAttachInfo()) {
- LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (const char *, bool), path, wait_for);
+ LLDB_INSTRUMENT_VA(this, path, wait_for);
if (path && path[0])
m_opaque_sp->GetExecutableFile().SetFile(path, FileSpec::Style::native);
@@ -38,8 +38,7 @@ SBAttachInfo::SBAttachInfo(const char *path, bool wait_for)
SBAttachInfo::SBAttachInfo(const char *path, bool wait_for, bool async)
: m_opaque_sp(new ProcessAttachInfo()) {
- LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (const char *, bool, bool), path,
- wait_for, async);
+ LLDB_INSTRUMENT_VA(this, path, wait_for, async);
if (path && path[0])
m_opaque_sp->GetExecutableFile().SetFile(path, FileSpec::Style::native);
@@ -49,7 +48,7 @@ SBAttachInfo::SBAttachInfo(const char *path, bool wait_for, bool async)
SBAttachInfo::SBAttachInfo(const SBAttachInfo &rhs)
: m_opaque_sp(new ProcessAttachInfo()) {
- LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (const lldb::SBAttachInfo &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_sp = clone(rhs.m_opaque_sp);
}
@@ -59,8 +58,7 @@ SBAttachInfo::~SBAttachInfo() = default;
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_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_sp = clone(rhs.m_opaque_sp);
@@ -68,44 +66,43 @@ SBAttachInfo &SBAttachInfo::operator=(const SBAttachInfo &rhs) {
}
lldb::pid_t SBAttachInfo::GetProcessID() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBAttachInfo, GetProcessID);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetProcessID();
}
void SBAttachInfo::SetProcessID(lldb::pid_t pid) {
- LLDB_RECORD_METHOD(void, SBAttachInfo, SetProcessID, (lldb::pid_t), pid);
+ LLDB_INSTRUMENT_VA(this, pid);
m_opaque_sp->SetProcessID(pid);
}
uint32_t SBAttachInfo::GetResumeCount() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetResumeCount);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetResumeCount();
}
void SBAttachInfo::SetResumeCount(uint32_t c) {
- LLDB_RECORD_METHOD(void, SBAttachInfo, SetResumeCount, (uint32_t), c);
+ LLDB_INSTRUMENT_VA(this, c);
m_opaque_sp->SetResumeCount(c);
}
const char *SBAttachInfo::GetProcessPluginName() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBAttachInfo, GetProcessPluginName);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetProcessPluginName();
}
void SBAttachInfo::SetProcessPluginName(const char *plugin_name) {
- LLDB_RECORD_METHOD(void, SBAttachInfo, SetProcessPluginName, (const char *),
- plugin_name);
+ LLDB_INSTRUMENT_VA(this, plugin_name);
return m_opaque_sp->SetProcessPluginName(plugin_name);
}
void SBAttachInfo::SetExecutable(const char *path) {
- LLDB_RECORD_METHOD(void, SBAttachInfo, SetExecutable, (const char *), path);
+ LLDB_INSTRUMENT_VA(this, path);
if (path && path[0])
m_opaque_sp->GetExecutableFile().SetFile(path, FileSpec::Style::native);
@@ -114,8 +111,7 @@ void SBAttachInfo::SetExecutable(const char *path) {
}
void SBAttachInfo::SetExecutable(SBFileSpec exe_file) {
- LLDB_RECORD_METHOD(void, SBAttachInfo, SetExecutable, (lldb::SBFileSpec),
- exe_file);
+ LLDB_INSTRUMENT_VA(this, exe_file);
if (exe_file.IsValid())
m_opaque_sp->GetExecutableFile() = exe_file.ref();
@@ -124,137 +120,134 @@ void SBAttachInfo::SetExecutable(SBFileSpec exe_file) {
}
bool SBAttachInfo::GetWaitForLaunch() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, GetWaitForLaunch);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetWaitForLaunch();
}
void SBAttachInfo::SetWaitForLaunch(bool b) {
- LLDB_RECORD_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool), b);
+ LLDB_INSTRUMENT_VA(this, b);
m_opaque_sp->SetWaitForLaunch(b);
}
void SBAttachInfo::SetWaitForLaunch(bool b, bool async) {
- LLDB_RECORD_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool, bool), b,
- async);
+ LLDB_INSTRUMENT_VA(this, b, async);
m_opaque_sp->SetWaitForLaunch(b);
m_opaque_sp->SetAsync(async);
}
bool SBAttachInfo::GetIgnoreExisting() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, GetIgnoreExisting);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetIgnoreExisting();
}
void SBAttachInfo::SetIgnoreExisting(bool b) {
- LLDB_RECORD_METHOD(void, SBAttachInfo, SetIgnoreExisting, (bool), b);
+ LLDB_INSTRUMENT_VA(this, b);
m_opaque_sp->SetIgnoreExisting(b);
}
uint32_t SBAttachInfo::GetUserID() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetUserID);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetUserID();
}
uint32_t SBAttachInfo::GetGroupID() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetGroupID);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetGroupID();
}
bool SBAttachInfo::UserIDIsValid() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, UserIDIsValid);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->UserIDIsValid();
}
bool SBAttachInfo::GroupIDIsValid() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, GroupIDIsValid);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GroupIDIsValid();
}
void SBAttachInfo::SetUserID(uint32_t uid) {
- LLDB_RECORD_METHOD(void, SBAttachInfo, SetUserID, (uint32_t), uid);
+ LLDB_INSTRUMENT_VA(this, uid);
m_opaque_sp->SetUserID(uid);
}
void SBAttachInfo::SetGroupID(uint32_t gid) {
- LLDB_RECORD_METHOD(void, SBAttachInfo, SetGroupID, (uint32_t), gid);
+ LLDB_INSTRUMENT_VA(this, gid);
m_opaque_sp->SetGroupID(gid);
}
uint32_t SBAttachInfo::GetEffectiveUserID() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetEffectiveUserID);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetEffectiveUserID();
}
uint32_t SBAttachInfo::GetEffectiveGroupID() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetEffectiveGroupID);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetEffectiveGroupID();
}
bool SBAttachInfo::EffectiveUserIDIsValid() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, EffectiveUserIDIsValid);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->EffectiveUserIDIsValid();
}
bool SBAttachInfo::EffectiveGroupIDIsValid() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, EffectiveGroupIDIsValid);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->EffectiveGroupIDIsValid();
}
void SBAttachInfo::SetEffectiveUserID(uint32_t uid) {
- LLDB_RECORD_METHOD(void, SBAttachInfo, SetEffectiveUserID, (uint32_t), uid);
+ LLDB_INSTRUMENT_VA(this, uid);
m_opaque_sp->SetEffectiveUserID(uid);
}
void SBAttachInfo::SetEffectiveGroupID(uint32_t gid) {
- LLDB_RECORD_METHOD(void, SBAttachInfo, SetEffectiveGroupID, (uint32_t), gid);
+ LLDB_INSTRUMENT_VA(this, gid);
m_opaque_sp->SetEffectiveGroupID(gid);
}
lldb::pid_t SBAttachInfo::GetParentProcessID() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBAttachInfo, GetParentProcessID);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetParentProcessID();
}
void SBAttachInfo::SetParentProcessID(lldb::pid_t pid) {
- LLDB_RECORD_METHOD(void, SBAttachInfo, SetParentProcessID, (lldb::pid_t),
- pid);
+ LLDB_INSTRUMENT_VA(this, pid);
m_opaque_sp->SetParentProcessID(pid);
}
bool SBAttachInfo::ParentProcessIDIsValid() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, ParentProcessIDIsValid);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->ParentProcessIDIsValid();
}
SBListener SBAttachInfo::GetListener() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBAttachInfo, GetListener);
+ LLDB_INSTRUMENT_VA(this);
return SBListener(m_opaque_sp->GetListener());
}
void SBAttachInfo::SetListener(SBListener &listener) {
- LLDB_RECORD_METHOD(void, SBAttachInfo, SetListener, (lldb::SBListener &),
- listener);
+ LLDB_INSTRUMENT_VA(this, listener);
m_opaque_sp->SetListener(listener.GetSP());
}
diff --git a/lldb/source/API/SBBlock.cpp b/lldb/source/API/SBBlock.cpp
index 720d630491f8..7d7565340836 100644
--- a/lldb/source/API/SBBlock.cpp
+++ b/lldb/source/API/SBBlock.cpp
@@ -7,7 +7,6 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBBlock.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBFileSpec.h"
#include "lldb/API/SBFrame.h"
@@ -21,22 +20,22 @@
#include "lldb/Symbol/VariableList.h"
#include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h"
+#include "lldb/Utility/Instrumentation.h"
using namespace lldb;
using namespace lldb_private;
-SBBlock::SBBlock() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBlock); }
+SBBlock::SBBlock() { LLDB_INSTRUMENT_VA(this); }
SBBlock::SBBlock(lldb_private::Block *lldb_object_ptr)
: m_opaque_ptr(lldb_object_ptr) {}
SBBlock::SBBlock(const SBBlock &rhs) : m_opaque_ptr(rhs.m_opaque_ptr) {
- LLDB_RECORD_CONSTRUCTOR(SBBlock, (const lldb::SBBlock &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
}
const SBBlock &SBBlock::operator=(const SBBlock &rhs) {
- LLDB_RECORD_METHOD(const lldb::SBBlock &,
- SBBlock, operator=,(const lldb::SBBlock &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_ptr = rhs.m_opaque_ptr;
return *this;
@@ -45,17 +44,17 @@ const SBBlock &SBBlock::operator=(const SBBlock &rhs) {
SBBlock::~SBBlock() { m_opaque_ptr = nullptr; }
bool SBBlock::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBlock, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBBlock::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBlock, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_ptr != nullptr;
}
bool SBBlock::IsInlined() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBlock, IsInlined);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr)
return m_opaque_ptr->GetInlinedFunctionInfo() != nullptr;
@@ -63,7 +62,7 @@ bool SBBlock::IsInlined() const {
}
const char *SBBlock::GetInlinedName() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBlock, GetInlinedName);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr) {
const InlineFunctionInfo *inlined_info =
@@ -76,8 +75,7 @@ const char *SBBlock::GetInlinedName() const {
}
SBFileSpec SBBlock::GetInlinedCallSiteFile() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBBlock,
- GetInlinedCallSiteFile);
+ LLDB_INSTRUMENT_VA(this);
SBFileSpec sb_file;
if (m_opaque_ptr) {
@@ -90,7 +88,7 @@ SBFileSpec SBBlock::GetInlinedCallSiteFile() const {
}
uint32_t SBBlock::GetInlinedCallSiteLine() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBlock, GetInlinedCallSiteLine);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr) {
const InlineFunctionInfo *inlined_info =
@@ -102,7 +100,7 @@ uint32_t SBBlock::GetInlinedCallSiteLine() const {
}
uint32_t SBBlock::GetInlinedCallSiteColumn() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBlock, GetInlinedCallSiteColumn);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr) {
const InlineFunctionInfo *inlined_info =
@@ -123,7 +121,7 @@ void SBBlock::AppendVariables(bool can_create, bool get_parent_variables,
}
SBBlock SBBlock::GetParent() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetParent);
+ LLDB_INSTRUMENT_VA(this);
SBBlock sb_block;
if (m_opaque_ptr)
@@ -132,7 +130,7 @@ SBBlock SBBlock::GetParent() {
}
lldb::SBBlock SBBlock::GetContainingInlinedBlock() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetContainingInlinedBlock);
+ LLDB_INSTRUMENT_VA(this);
SBBlock sb_block;
if (m_opaque_ptr)
@@ -141,7 +139,7 @@ lldb::SBBlock SBBlock::GetContainingInlinedBlock() {
}
SBBlock SBBlock::GetSibling() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetSibling);
+ LLDB_INSTRUMENT_VA(this);
SBBlock sb_block;
if (m_opaque_ptr)
@@ -150,7 +148,7 @@ SBBlock SBBlock::GetSibling() {
}
SBBlock SBBlock::GetFirstChild() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetFirstChild);
+ LLDB_INSTRUMENT_VA(this);
SBBlock sb_block;
if (m_opaque_ptr)
@@ -163,8 +161,7 @@ lldb_private::Block *SBBlock::GetPtr() { return m_opaque_ptr; }
void SBBlock::SetPtr(lldb_private::Block *block) { m_opaque_ptr = block; }
bool SBBlock::GetDescription(SBStream &description) {
- LLDB_RECORD_METHOD(bool, SBBlock, GetDescription, (lldb::SBStream &),
- description);
+ LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();
@@ -188,7 +185,7 @@ bool SBBlock::GetDescription(SBStream &description) {
}
uint32_t SBBlock::GetNumRanges() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBBlock, GetNumRanges);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr)
return m_opaque_ptr->GetNumRanges();
@@ -196,8 +193,7 @@ uint32_t SBBlock::GetNumRanges() {
}
lldb::SBAddress SBBlock::GetRangeStartAddress(uint32_t idx) {
- LLDB_RECORD_METHOD(lldb::SBAddress, SBBlock, GetRangeStartAddress, (uint32_t),
- idx);
+ LLDB_INSTRUMENT_VA(this, idx);
lldb::SBAddress sb_addr;
if (m_opaque_ptr) {
@@ -210,8 +206,7 @@ lldb::SBAddress SBBlock::GetRangeStartAddress(uint32_t idx) {
}
lldb::SBAddress SBBlock::GetRangeEndAddress(uint32_t idx) {
- LLDB_RECORD_METHOD(lldb::SBAddress, SBBlock, GetRangeEndAddress, (uint32_t),
- idx);
+ LLDB_INSTRUMENT_VA(this, idx);
lldb::SBAddress sb_addr;
if (m_opaque_ptr) {
@@ -225,8 +220,7 @@ lldb::SBAddress SBBlock::GetRangeEndAddress(uint32_t idx) {
}
uint32_t SBBlock::GetRangeIndexForBlockAddress(lldb::SBAddress block_addr) {
- LLDB_RECORD_METHOD(uint32_t, SBBlock, GetRangeIndexForBlockAddress,
- (lldb::SBAddress), block_addr);
+ LLDB_INSTRUMENT_VA(this, block_addr);
if (m_opaque_ptr && block_addr.IsValid()) {
return m_opaque_ptr->GetRangeIndexContainingAddress(block_addr.ref());
@@ -238,10 +232,7 @@ uint32_t SBBlock::GetRangeIndexForBlockAddress(lldb::SBAddress block_addr) {
lldb::SBValueList SBBlock::GetVariables(lldb::SBFrame &frame, bool arguments,
bool locals, bool statics,
lldb::DynamicValueType use_dynamic) {
- LLDB_RECORD_METHOD(
- lldb::SBValueList, SBBlock, GetVariables,
- (lldb::SBFrame &, bool, bool, bool, lldb::DynamicValueType), frame,
- arguments, locals, statics, use_dynamic);
+ LLDB_INSTRUMENT_VA(this, frame, arguments, locals, statics, use_dynamic);
Block *block = GetPtr();
SBValueList value_list;
@@ -294,9 +285,7 @@ lldb::SBValueList SBBlock::GetVariables(lldb::SBFrame &frame, bool arguments,
lldb::SBValueList SBBlock::GetVariables(lldb::SBTarget &target, bool arguments,
bool locals, bool statics) {
- LLDB_RECORD_METHOD(lldb::SBValueList, SBBlock, GetVariables,
- (lldb::SBTarget &, bool, bool, bool), target, arguments,
- locals, statics);
+ LLDB_INSTRUMENT_VA(this, target, arguments, locals, statics);
Block *block = GetPtr();
diff --git a/lldb/source/API/SBBreakpoint.cpp b/lldb/source/API/SBBreakpoint.cpp
index 709895e8bbc9..5fe8f7fe0583 100644
--- a/lldb/source/API/SBBreakpoint.cpp
+++ b/lldb/source/API/SBBreakpoint.cpp
@@ -7,7 +7,6 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBBreakpoint.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBBreakpointLocation.h"
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBEvent.h"
@@ -16,6 +15,7 @@
#include "lldb/API/SBStringList.h"
#include "lldb/API/SBStructuredData.h"
#include "lldb/API/SBThread.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/Breakpoint/Breakpoint.h"
#include "lldb/Breakpoint/BreakpointIDList.h"
@@ -45,44 +45,41 @@
using namespace lldb;
using namespace lldb_private;
-SBBreakpoint::SBBreakpoint() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBreakpoint); }
+SBBreakpoint::SBBreakpoint() { LLDB_INSTRUMENT_VA(this); }
SBBreakpoint::SBBreakpoint(const SBBreakpoint &rhs)
: m_opaque_wp(rhs.m_opaque_wp) {
- LLDB_RECORD_CONSTRUCTOR(SBBreakpoint, (const lldb::SBBreakpoint &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
}
SBBreakpoint::SBBreakpoint(const lldb::BreakpointSP &bp_sp)
: m_opaque_wp(bp_sp) {
- LLDB_RECORD_CONSTRUCTOR(SBBreakpoint, (const lldb::BreakpointSP &), bp_sp);
+ LLDB_INSTRUMENT_VA(this, bp_sp);
}
SBBreakpoint::~SBBreakpoint() = default;
const SBBreakpoint &SBBreakpoint::operator=(const SBBreakpoint &rhs) {
- LLDB_RECORD_METHOD(const lldb::SBBreakpoint &,
- SBBreakpoint, operator=,(const lldb::SBBreakpoint &), rhs);
+ LLDB_INSTRUMENT_VA(this, 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_INSTRUMENT_VA(this, 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_INSTRUMENT_VA(this, rhs);
return m_opaque_wp.lock() != rhs.m_opaque_wp.lock();
}
SBTarget SBBreakpoint::GetTarget() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBTarget, SBBreakpoint, GetTarget);
+ LLDB_INSTRUMENT_VA(this);
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp)
@@ -92,7 +89,7 @@ SBTarget SBBreakpoint::GetTarget() const {
}
break_id_t SBBreakpoint::GetID() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::break_id_t, SBBreakpoint, GetID);
+ LLDB_INSTRUMENT_VA(this);
break_id_t break_id = LLDB_INVALID_BREAK_ID;
BreakpointSP bkpt_sp = GetSP();
@@ -103,11 +100,11 @@ break_id_t SBBreakpoint::GetID() const {
}
bool SBBreakpoint::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBBreakpoint::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, operator bool);
+ LLDB_INSTRUMENT_VA(this);
BreakpointSP bkpt_sp = GetSP();
if (!bkpt_sp)
@@ -119,7 +116,7 @@ SBBreakpoint::operator bool() const {
}
void SBBreakpoint::ClearAllBreakpointSites() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBBreakpoint, ClearAllBreakpointSites);
+ LLDB_INSTRUMENT_VA(this);
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
@@ -130,8 +127,7 @@ void SBBreakpoint::ClearAllBreakpointSites() {
}
SBBreakpointLocation SBBreakpoint::FindLocationByAddress(addr_t vm_addr) {
- LLDB_RECORD_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
- FindLocationByAddress, (lldb::addr_t), vm_addr);
+ LLDB_INSTRUMENT_VA(this, vm_addr);
SBBreakpointLocation sb_bp_location;
@@ -152,8 +148,7 @@ SBBreakpointLocation SBBreakpoint::FindLocationByAddress(addr_t vm_addr) {
}
break_id_t SBBreakpoint::FindLocationIDByAddress(addr_t vm_addr) {
- LLDB_RECORD_METHOD(lldb::break_id_t, SBBreakpoint, FindLocationIDByAddress,
- (lldb::addr_t), vm_addr);
+ LLDB_INSTRUMENT_VA(this, vm_addr);
break_id_t break_id = LLDB_INVALID_BREAK_ID;
BreakpointSP bkpt_sp = GetSP();
@@ -173,8 +168,7 @@ break_id_t SBBreakpoint::FindLocationIDByAddress(addr_t vm_addr) {
}
SBBreakpointLocation SBBreakpoint::FindLocationByID(break_id_t bp_loc_id) {
- LLDB_RECORD_METHOD(lldb::SBBreakpointLocation, SBBreakpoint, FindLocationByID,
- (lldb::break_id_t), bp_loc_id);
+ LLDB_INSTRUMENT_VA(this, bp_loc_id);
SBBreakpointLocation sb_bp_location;
BreakpointSP bkpt_sp = GetSP();
@@ -189,8 +183,7 @@ SBBreakpointLocation SBBreakpoint::FindLocationByID(break_id_t bp_loc_id) {
}
SBBreakpointLocation SBBreakpoint::GetLocationAtIndex(uint32_t index) {
- LLDB_RECORD_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
- GetLocationAtIndex, (uint32_t), index);
+ LLDB_INSTRUMENT_VA(this, index);
SBBreakpointLocation sb_bp_location;
BreakpointSP bkpt_sp = GetSP();
@@ -205,7 +198,7 @@ SBBreakpointLocation SBBreakpoint::GetLocationAtIndex(uint32_t index) {
}
void SBBreakpoint::SetEnabled(bool enable) {
- LLDB_RECORD_METHOD(void, SBBreakpoint, SetEnabled, (bool), enable);
+ LLDB_INSTRUMENT_VA(this, enable);
BreakpointSP bkpt_sp = GetSP();
@@ -217,7 +210,7 @@ void SBBreakpoint::SetEnabled(bool enable) {
}
bool SBBreakpoint::IsEnabled() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpoint, IsEnabled);
+ LLDB_INSTRUMENT_VA(this);
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
@@ -229,7 +222,7 @@ bool SBBreakpoint::IsEnabled() {
}
void SBBreakpoint::SetOneShot(bool one_shot) {
- LLDB_RECORD_METHOD(void, SBBreakpoint, SetOneShot, (bool), one_shot);
+ LLDB_INSTRUMENT_VA(this, one_shot);
BreakpointSP bkpt_sp = GetSP();
@@ -241,7 +234,7 @@ void SBBreakpoint::SetOneShot(bool one_shot) {
}
bool SBBreakpoint::IsOneShot() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, IsOneShot);
+ LLDB_INSTRUMENT_VA(this);
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
@@ -253,7 +246,7 @@ bool SBBreakpoint::IsOneShot() const {
}
bool SBBreakpoint::IsInternal() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpoint, IsInternal);
+ LLDB_INSTRUMENT_VA(this);
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
@@ -265,7 +258,7 @@ bool SBBreakpoint::IsInternal() {
}
void SBBreakpoint::SetIgnoreCount(uint32_t count) {
- LLDB_RECORD_METHOD(void, SBBreakpoint, SetIgnoreCount, (uint32_t), count);
+ LLDB_INSTRUMENT_VA(this, count);
BreakpointSP bkpt_sp = GetSP();
@@ -277,8 +270,7 @@ void SBBreakpoint::SetIgnoreCount(uint32_t count) {
}
void SBBreakpoint::SetCondition(const char *condition) {
- LLDB_RECORD_METHOD(void, SBBreakpoint, SetCondition, (const char *),
- condition);
+ LLDB_INSTRUMENT_VA(this, condition);
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
@@ -289,7 +281,7 @@ void SBBreakpoint::SetCondition(const char *condition) {
}
const char *SBBreakpoint::GetCondition() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBBreakpoint, GetCondition);
+ LLDB_INSTRUMENT_VA(this);
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
@@ -301,8 +293,7 @@ const char *SBBreakpoint::GetCondition() {
}
void SBBreakpoint::SetAutoContinue(bool auto_continue) {
- LLDB_RECORD_METHOD(void, SBBreakpoint, SetAutoContinue, (bool),
- auto_continue);
+ LLDB_INSTRUMENT_VA(this, auto_continue);
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
@@ -313,7 +304,7 @@ void SBBreakpoint::SetAutoContinue(bool auto_continue) {
}
bool SBBreakpoint::GetAutoContinue() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpoint, GetAutoContinue);
+ LLDB_INSTRUMENT_VA(this);
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
@@ -325,7 +316,7 @@ bool SBBreakpoint::GetAutoContinue() {
}
uint32_t SBBreakpoint::GetHitCount() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpoint, GetHitCount);
+ LLDB_INSTRUMENT_VA(this);
uint32_t count = 0;
BreakpointSP bkpt_sp = GetSP();
@@ -339,7 +330,7 @@ uint32_t SBBreakpoint::GetHitCount() const {
}
uint32_t SBBreakpoint::GetIgnoreCount() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpoint, GetIgnoreCount);
+ LLDB_INSTRUMENT_VA(this);
uint32_t count = 0;
BreakpointSP bkpt_sp = GetSP();
@@ -353,7 +344,7 @@ uint32_t SBBreakpoint::GetIgnoreCount() const {
}
void SBBreakpoint::SetThreadID(tid_t tid) {
- LLDB_RECORD_METHOD(void, SBBreakpoint, SetThreadID, (lldb::tid_t), tid);
+ LLDB_INSTRUMENT_VA(this, tid);
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
@@ -364,7 +355,7 @@ void SBBreakpoint::SetThreadID(tid_t tid) {
}
tid_t SBBreakpoint::GetThreadID() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBBreakpoint, GetThreadID);
+ LLDB_INSTRUMENT_VA(this);
tid_t tid = LLDB_INVALID_THREAD_ID;
BreakpointSP bkpt_sp = GetSP();
@@ -378,7 +369,7 @@ tid_t SBBreakpoint::GetThreadID() {
}
void SBBreakpoint::SetThreadIndex(uint32_t index) {
- LLDB_RECORD_METHOD(void, SBBreakpoint, SetThreadIndex, (uint32_t), index);
+ LLDB_INSTRUMENT_VA(this, index);
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
@@ -389,7 +380,7 @@ void SBBreakpoint::SetThreadIndex(uint32_t index) {
}
uint32_t SBBreakpoint::GetThreadIndex() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpoint, GetThreadIndex);
+ LLDB_INSTRUMENT_VA(this);
uint32_t thread_idx = UINT32_MAX;
BreakpointSP bkpt_sp = GetSP();
@@ -406,8 +397,7 @@ uint32_t SBBreakpoint::GetThreadIndex() const {
}
void SBBreakpoint::SetThreadName(const char *thread_name) {
- LLDB_RECORD_METHOD(void, SBBreakpoint, SetThreadName, (const char *),
- thread_name);
+ LLDB_INSTRUMENT_VA(this, thread_name);
BreakpointSP bkpt_sp = GetSP();
@@ -419,7 +409,7 @@ void SBBreakpoint::SetThreadName(const char *thread_name) {
}
const char *SBBreakpoint::GetThreadName() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpoint, GetThreadName);
+ LLDB_INSTRUMENT_VA(this);
const char *name = nullptr;
BreakpointSP bkpt_sp = GetSP();
@@ -436,8 +426,7 @@ const char *SBBreakpoint::GetThreadName() const {
}
void SBBreakpoint::SetQueueName(const char *queue_name) {
- LLDB_RECORD_METHOD(void, SBBreakpoint, SetQueueName, (const char *),
- queue_name);
+ LLDB_INSTRUMENT_VA(this, queue_name);
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
@@ -448,7 +437,7 @@ void SBBreakpoint::SetQueueName(const char *queue_name) {
}
const char *SBBreakpoint::GetQueueName() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpoint, GetQueueName);
+ LLDB_INSTRUMENT_VA(this);
const char *name = nullptr;
BreakpointSP bkpt_sp = GetSP();
@@ -465,8 +454,7 @@ const char *SBBreakpoint::GetQueueName() const {
}
size_t SBBreakpoint::GetNumResolvedLocations() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBBreakpoint,
- GetNumResolvedLocations);
+ LLDB_INSTRUMENT_VA(this);
size_t num_resolved = 0;
BreakpointSP bkpt_sp = GetSP();
@@ -479,7 +467,7 @@ size_t SBBreakpoint::GetNumResolvedLocations() const {
}
size_t SBBreakpoint::GetNumLocations() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBBreakpoint, GetNumLocations);
+ LLDB_INSTRUMENT_VA(this);
BreakpointSP bkpt_sp = GetSP();
size_t num_locs = 0;
@@ -492,8 +480,7 @@ size_t SBBreakpoint::GetNumLocations() const {
}
void SBBreakpoint::SetCommandLineCommands(SBStringList &commands) {
- LLDB_RECORD_METHOD(void, SBBreakpoint, SetCommandLineCommands,
- (lldb::SBStringList &), commands);
+ LLDB_INSTRUMENT_VA(this, commands);
BreakpointSP bkpt_sp = GetSP();
if (!bkpt_sp)
@@ -510,8 +497,7 @@ void SBBreakpoint::SetCommandLineCommands(SBStringList &commands) {
}
bool SBBreakpoint::GetCommandLineCommands(SBStringList &commands) {
- LLDB_RECORD_METHOD(bool, SBBreakpoint, GetCommandLineCommands,
- (lldb::SBStringList &), commands);
+ LLDB_INSTRUMENT_VA(this, commands);
BreakpointSP bkpt_sp = GetSP();
if (!bkpt_sp)
@@ -525,14 +511,13 @@ bool SBBreakpoint::GetCommandLineCommands(SBStringList &commands) {
}
bool SBBreakpoint::GetDescription(SBStream &s) {
- LLDB_RECORD_METHOD(bool, SBBreakpoint, GetDescription, (lldb::SBStream &), s);
+ LLDB_INSTRUMENT_VA(this, s);
return GetDescription(s, true);
}
bool SBBreakpoint::GetDescription(SBStream &s, bool include_locations) {
- LLDB_RECORD_METHOD(bool, SBBreakpoint, GetDescription,
- (lldb::SBStream &, bool), s, include_locations);
+ LLDB_INSTRUMENT_VA(this, s, include_locations);
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
@@ -552,8 +537,7 @@ bool SBBreakpoint::GetDescription(SBStream &s, bool include_locations) {
}
SBError SBBreakpoint::AddLocation(SBAddress &address) {
- LLDB_RECORD_METHOD(lldb::SBError, SBBreakpoint, AddLocation,
- (lldb::SBAddress &), address);
+ LLDB_INSTRUMENT_VA(this, address);
BreakpointSP bkpt_sp = GetSP();
SBError error;
@@ -586,8 +570,7 @@ SBError SBBreakpoint::AddLocation(SBAddress &address) {
}
SBStructuredData SBBreakpoint::SerializeToStructuredData() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStructuredData, SBBreakpoint,
- SerializeToStructuredData);
+ LLDB_INSTRUMENT_VA(this);
SBStructuredData data;
BreakpointSP bkpt_sp = GetSP();
@@ -601,8 +584,7 @@ SBStructuredData SBBreakpoint::SerializeToStructuredData() {
}
void SBBreakpoint::SetCallback(SBBreakpointHitCallback callback, void *baton) {
- LLDB_RECORD_METHOD(void, SBBreakpoint, SetCallback,
- (lldb::SBBreakpointHitCallback, void *), callback, baton);
+ LLDB_INSTRUMENT_VA(this, callback, baton);
BreakpointSP bkpt_sp = GetSP();
@@ -618,8 +600,7 @@ void SBBreakpoint::SetCallback(SBBreakpointHitCallback callback, void *baton) {
void SBBreakpoint::SetScriptCallbackFunction(
const char *callback_function_name) {
-LLDB_RECORD_METHOD(void, SBBreakpoint, SetScriptCallbackFunction,
- (const char *), callback_function_name);
+ LLDB_INSTRUMENT_VA(this, callback_function_name);
SBStructuredData empty_args;
SetScriptCallbackFunction(callback_function_name, empty_args);
}
@@ -627,8 +608,7 @@ LLDB_RECORD_METHOD(void, SBBreakpoint, SetScriptCallbackFunction,
SBError SBBreakpoint::SetScriptCallbackFunction(
const char *callback_function_name,
SBStructuredData &extra_args) {
- LLDB_RECORD_METHOD(SBError, SBBreakpoint, SetScriptCallbackFunction,
- (const char *, SBStructuredData &), callback_function_name, extra_args);
+ LLDB_INSTRUMENT_VA(this, callback_function_name, extra_args);
SBError sb_error;
BreakpointSP bkpt_sp = GetSP();
@@ -652,8 +632,7 @@ SBError SBBreakpoint::SetScriptCallbackFunction(
}
SBError SBBreakpoint::SetScriptCallbackBody(const char *callback_body_text) {
- LLDB_RECORD_METHOD(lldb::SBError, SBBreakpoint, SetScriptCallbackBody,
- (const char *), callback_body_text);
+ LLDB_INSTRUMENT_VA(this, callback_body_text);
BreakpointSP bkpt_sp = GetSP();
@@ -675,15 +654,14 @@ SBError SBBreakpoint::SetScriptCallbackBody(const char *callback_body_text) {
}
bool SBBreakpoint::AddName(const char *new_name) {
- LLDB_RECORD_METHOD(bool, SBBreakpoint, AddName, (const char *), new_name);
+ LLDB_INSTRUMENT_VA(this, new_name);
SBError status = AddNameWithErrorHandling(new_name);
return status.Success();
}
SBError SBBreakpoint::AddNameWithErrorHandling(const char *new_name) {
- LLDB_RECORD_METHOD(SBError, SBBreakpoint, AddNameWithErrorHandling,
- (const char *), new_name);
+ LLDB_INSTRUMENT_VA(this, new_name);
BreakpointSP bkpt_sp = GetSP();
@@ -702,8 +680,7 @@ SBError SBBreakpoint::AddNameWithErrorHandling(const char *new_name) {
}
void SBBreakpoint::RemoveName(const char *name_to_remove) {
- LLDB_RECORD_METHOD(void, SBBreakpoint, RemoveName, (const char *),
- name_to_remove);
+ LLDB_INSTRUMENT_VA(this, name_to_remove);
BreakpointSP bkpt_sp = GetSP();
@@ -716,7 +693,7 @@ void SBBreakpoint::RemoveName(const char *name_to_remove) {
}
bool SBBreakpoint::MatchesName(const char *name) {
- LLDB_RECORD_METHOD(bool, SBBreakpoint, MatchesName, (const char *), name);
+ LLDB_INSTRUMENT_VA(this, name);
BreakpointSP bkpt_sp = GetSP();
@@ -730,8 +707,7 @@ bool SBBreakpoint::MatchesName(const char *name) {
}
void SBBreakpoint::GetNames(SBStringList &names) {
- LLDB_RECORD_METHOD(void, SBBreakpoint, GetNames, (lldb::SBStringList &),
- names);
+ LLDB_INSTRUMENT_VA(this, names);
BreakpointSP bkpt_sp = GetSP();
@@ -747,8 +723,7 @@ void SBBreakpoint::GetNames(SBStringList &names) {
}
bool SBBreakpoint::EventIsBreakpointEvent(const lldb::SBEvent &event) {
- LLDB_RECORD_STATIC_METHOD(bool, SBBreakpoint, EventIsBreakpointEvent,
- (const lldb::SBEvent &), event);
+ LLDB_INSTRUMENT_VA(event);
return Breakpoint::BreakpointEventData::GetEventDataFromEvent(event.get()) !=
nullptr;
@@ -756,9 +731,7 @@ bool SBBreakpoint::EventIsBreakpointEvent(const lldb::SBEvent &event) {
BreakpointEventType
SBBreakpoint::GetBreakpointEventTypeFromEvent(const SBEvent &event) {
- LLDB_RECORD_STATIC_METHOD(lldb::BreakpointEventType, SBBreakpoint,
- GetBreakpointEventTypeFromEvent,
- (const lldb::SBEvent &), event);
+ LLDB_INSTRUMENT_VA(event);
if (event.IsValid())
return Breakpoint::BreakpointEventData::GetBreakpointEventTypeFromEvent(
@@ -767,9 +740,7 @@ SBBreakpoint::GetBreakpointEventTypeFromEvent(const SBEvent &event) {
}
SBBreakpoint SBBreakpoint::GetBreakpointFromEvent(const lldb::SBEvent &event) {
- LLDB_RECORD_STATIC_METHOD(lldb::SBBreakpoint, SBBreakpoint,
- GetBreakpointFromEvent, (const lldb::SBEvent &),
- event);
+ LLDB_INSTRUMENT_VA(event);
if (event.IsValid())
return SBBreakpoint(
@@ -780,9 +751,7 @@ SBBreakpoint SBBreakpoint::GetBreakpointFromEvent(const lldb::SBEvent &event) {
SBBreakpointLocation
SBBreakpoint::GetBreakpointLocationAtIndexFromEvent(const lldb::SBEvent &event,
uint32_t loc_idx) {
- LLDB_RECORD_STATIC_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
- GetBreakpointLocationAtIndexFromEvent,
- (const lldb::SBEvent &, uint32_t), event, loc_idx);
+ LLDB_INSTRUMENT_VA(event, loc_idx);
SBBreakpointLocation sb_breakpoint_loc;
if (event.IsValid())
@@ -794,9 +763,7 @@ SBBreakpoint::GetBreakpointLocationAtIndexFromEvent(const lldb::SBEvent &event,
uint32_t
SBBreakpoint::GetNumBreakpointLocationsFromEvent(const lldb::SBEvent &event) {
- LLDB_RECORD_STATIC_METHOD(uint32_t, SBBreakpoint,
- GetNumBreakpointLocationsFromEvent,
- (const lldb::SBEvent &), event);
+ LLDB_INSTRUMENT_VA(event);
uint32_t num_locations = 0;
if (event.IsValid())
@@ -807,7 +774,7 @@ SBBreakpoint::GetNumBreakpointLocationsFromEvent(const lldb::SBEvent &event) {
}
bool SBBreakpoint::IsHardware() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, IsHardware);
+ LLDB_INSTRUMENT_VA(this);
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp)
@@ -903,13 +870,13 @@ class SBBreakpointListImpl {
SBBreakpointList::SBBreakpointList(SBTarget &target)
: m_opaque_sp(new SBBreakpointListImpl(target.GetSP())) {
- LLDB_RECORD_CONSTRUCTOR(SBBreakpointList, (lldb::SBTarget &), target);
+ LLDB_INSTRUMENT_VA(this, target);
}
SBBreakpointList::~SBBreakpointList() = default;
size_t SBBreakpointList::GetSize() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBBreakpointList, GetSize);
+ LLDB_INSTRUMENT_VA(this);
if (!m_opaque_sp)
return 0;
@@ -918,8 +885,7 @@ size_t SBBreakpointList::GetSize() const {
}
SBBreakpoint SBBreakpointList::GetBreakpointAtIndex(size_t idx) {
- LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBBreakpointList, GetBreakpointAtIndex,
- (size_t), idx);
+ LLDB_INSTRUMENT_VA(this, idx);
if (!m_opaque_sp)
return SBBreakpoint();
@@ -929,8 +895,7 @@ SBBreakpoint SBBreakpointList::GetBreakpointAtIndex(size_t idx) {
}
SBBreakpoint SBBreakpointList::FindBreakpointByID(lldb::break_id_t id) {
- LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBBreakpointList, FindBreakpointByID,
- (lldb::break_id_t), id);
+ LLDB_INSTRUMENT_VA(this, id);
if (!m_opaque_sp)
return SBBreakpoint();
@@ -939,8 +904,7 @@ SBBreakpoint SBBreakpointList::FindBreakpointByID(lldb::break_id_t id) {
}
void SBBreakpointList::Append(const SBBreakpoint &sb_bkpt) {
- LLDB_RECORD_METHOD(void, SBBreakpointList, Append,
- (const lldb::SBBreakpoint &), sb_bkpt);
+ LLDB_INSTRUMENT_VA(this, sb_bkpt);
if (!sb_bkpt.IsValid())
return;
@@ -950,8 +914,7 @@ void SBBreakpointList::Append(const SBBreakpoint &sb_bkpt) {
}
void SBBreakpointList::AppendByID(lldb::break_id_t id) {
- LLDB_RECORD_METHOD(void, SBBreakpointList, AppendByID, (lldb::break_id_t),
- id);
+ LLDB_INSTRUMENT_VA(this, id);
if (!m_opaque_sp)
return;
@@ -959,8 +922,7 @@ void SBBreakpointList::AppendByID(lldb::break_id_t id) {
}
bool SBBreakpointList::AppendIfUnique(const SBBreakpoint &sb_bkpt) {
- LLDB_RECORD_METHOD(bool, SBBreakpointList, AppendIfUnique,
- (const lldb::SBBreakpoint &), sb_bkpt);
+ LLDB_INSTRUMENT_VA(this, sb_bkpt);
if (!sb_bkpt.IsValid())
return false;
@@ -970,7 +932,7 @@ bool SBBreakpointList::AppendIfUnique(const SBBreakpoint &sb_bkpt) {
}
void SBBreakpointList::Clear() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBBreakpointList, Clear);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp)
m_opaque_sp->Clear();
diff --git a/lldb/source/API/SBBreakpointLocation.cpp b/lldb/source/API/SBBreakpointLocation.cpp
index c2e0001bd6c5..914317437723 100644
--- a/lldb/source/API/SBBreakpointLocation.cpp
+++ b/lldb/source/API/SBBreakpointLocation.cpp
@@ -7,13 +7,13 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBBreakpointLocation.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBDefines.h"
#include "lldb/API/SBStream.h"
-#include "lldb/API/SBStructuredData.h"
#include "lldb/API/SBStringList.h"
+#include "lldb/API/SBStructuredData.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/Breakpoint/Breakpoint.h"
#include "lldb/Breakpoint/BreakpointLocation.h"
@@ -31,29 +31,22 @@
using namespace lldb;
using namespace lldb_private;
-SBBreakpointLocation::SBBreakpointLocation() {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBreakpointLocation);
-}
+SBBreakpointLocation::SBBreakpointLocation() { LLDB_INSTRUMENT_VA(this); }
SBBreakpointLocation::SBBreakpointLocation(
const lldb::BreakpointLocationSP &break_loc_sp)
: m_opaque_wp(break_loc_sp) {
- LLDB_RECORD_CONSTRUCTOR(SBBreakpointLocation,
- (const lldb::BreakpointLocationSP &), break_loc_sp);
+ LLDB_INSTRUMENT_VA(this, break_loc_sp);
}
SBBreakpointLocation::SBBreakpointLocation(const SBBreakpointLocation &rhs)
: m_opaque_wp(rhs.m_opaque_wp) {
- LLDB_RECORD_CONSTRUCTOR(SBBreakpointLocation,
- (const lldb::SBBreakpointLocation &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
}
const SBBreakpointLocation &SBBreakpointLocation::
operator=(const SBBreakpointLocation &rhs) {
- LLDB_RECORD_METHOD(
- const lldb::SBBreakpointLocation &,
- SBBreakpointLocation, operator=,(const lldb::SBBreakpointLocation &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_wp = rhs.m_opaque_wp;
return *this;
@@ -66,17 +59,17 @@ BreakpointLocationSP SBBreakpointLocation::GetSP() const {
}
bool SBBreakpointLocation::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointLocation, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBBreakpointLocation::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointLocation, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return bool(GetSP());
}
SBAddress SBBreakpointLocation::GetAddress() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBBreakpointLocation, GetAddress);
+ LLDB_INSTRUMENT_VA(this);
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
@@ -87,8 +80,7 @@ SBAddress SBBreakpointLocation::GetAddress() {
}
addr_t SBBreakpointLocation::GetLoadAddress() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBBreakpointLocation,
- GetLoadAddress);
+ LLDB_INSTRUMENT_VA(this);
addr_t ret_addr = LLDB_INVALID_ADDRESS;
BreakpointLocationSP loc_sp = GetSP();
@@ -103,7 +95,7 @@ addr_t SBBreakpointLocation::GetLoadAddress() {
}
void SBBreakpointLocation::SetEnabled(bool enabled) {
- LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetEnabled, (bool), enabled);
+ LLDB_INSTRUMENT_VA(this, enabled);
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
@@ -114,7 +106,7 @@ void SBBreakpointLocation::SetEnabled(bool enabled) {
}
bool SBBreakpointLocation::IsEnabled() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointLocation, IsEnabled);
+ LLDB_INSTRUMENT_VA(this);
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
@@ -126,7 +118,7 @@ bool SBBreakpointLocation::IsEnabled() {
}
uint32_t SBBreakpointLocation::GetHitCount() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBBreakpointLocation, GetHitCount);
+ LLDB_INSTRUMENT_VA(this);
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
@@ -138,7 +130,7 @@ uint32_t SBBreakpointLocation::GetHitCount() {
}
uint32_t SBBreakpointLocation::GetIgnoreCount() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBBreakpointLocation, GetIgnoreCount);
+ LLDB_INSTRUMENT_VA(this);
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
@@ -150,7 +142,7 @@ uint32_t SBBreakpointLocation::GetIgnoreCount() {
}
void SBBreakpointLocation::SetIgnoreCount(uint32_t n) {
- LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetIgnoreCount, (uint32_t), n);
+ LLDB_INSTRUMENT_VA(this, n);
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
@@ -161,8 +153,7 @@ void SBBreakpointLocation::SetIgnoreCount(uint32_t n) {
}
void SBBreakpointLocation::SetCondition(const char *condition) {
- LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetCondition, (const char *),
- condition);
+ LLDB_INSTRUMENT_VA(this, condition);
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
@@ -173,7 +164,7 @@ void SBBreakpointLocation::SetCondition(const char *condition) {
}
const char *SBBreakpointLocation::GetCondition() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBBreakpointLocation, GetCondition);
+ LLDB_INSTRUMENT_VA(this);
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
@@ -185,8 +176,7 @@ const char *SBBreakpointLocation::GetCondition() {
}
void SBBreakpointLocation::SetAutoContinue(bool auto_continue) {
- LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetAutoContinue, (bool),
- auto_continue);
+ LLDB_INSTRUMENT_VA(this, auto_continue);
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
@@ -197,7 +187,7 @@ void SBBreakpointLocation::SetAutoContinue(bool auto_continue) {
}
bool SBBreakpointLocation::GetAutoContinue() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointLocation, GetAutoContinue);
+ LLDB_INSTRUMENT_VA(this);
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
@@ -210,16 +200,13 @@ bool SBBreakpointLocation::GetAutoContinue() {
void SBBreakpointLocation::SetScriptCallbackFunction(
const char *callback_function_name) {
-LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetScriptCallbackFunction,
- (const char *), callback_function_name);
+ LLDB_INSTRUMENT_VA(this, callback_function_name);
}
SBError SBBreakpointLocation::SetScriptCallbackFunction(
const char *callback_function_name,
SBStructuredData &extra_args) {
- LLDB_RECORD_METHOD(SBError, SBBreakpointLocation, SetScriptCallbackFunction,
- (const char *, SBStructuredData &), callback_function_name,
- extra_args);
+ LLDB_INSTRUMENT_VA(this, callback_function_name, extra_args);
SBError sb_error;
BreakpointLocationSP loc_sp = GetSP();
@@ -245,8 +232,7 @@ SBError SBBreakpointLocation::SetScriptCallbackFunction(
SBError
SBBreakpointLocation::SetScriptCallbackBody(const char *callback_body_text) {
- LLDB_RECORD_METHOD(lldb::SBError, SBBreakpointLocation, SetScriptCallbackBody,
- (const char *), callback_body_text);
+ LLDB_INSTRUMENT_VA(this, callback_body_text);
BreakpointLocationSP loc_sp = GetSP();
@@ -269,8 +255,7 @@ SBBreakpointLocation::SetScriptCallbackBody(const char *callback_body_text) {
}
void SBBreakpointLocation::SetCommandLineCommands(SBStringList &commands) {
- LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetCommandLineCommands,
- (lldb::SBStringList &), commands);
+ LLDB_INSTRUMENT_VA(this, commands);
BreakpointLocationSP loc_sp = GetSP();
if (!loc_sp)
@@ -287,8 +272,7 @@ void SBBreakpointLocation::SetCommandLineCommands(SBStringList &commands) {
}
bool SBBreakpointLocation::GetCommandLineCommands(SBStringList &commands) {
- LLDB_RECORD_METHOD(bool, SBBreakpointLocation, GetCommandLineCommands,
- (lldb::SBStringList &), commands);
+ LLDB_INSTRUMENT_VA(this, commands);
BreakpointLocationSP loc_sp = GetSP();
if (!loc_sp)
@@ -302,8 +286,7 @@ bool SBBreakpointLocation::GetCommandLineCommands(SBStringList &commands) {
}
void SBBreakpointLocation::SetThreadID(tid_t thread_id) {
- LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetThreadID, (lldb::tid_t),
- thread_id);
+ LLDB_INSTRUMENT_VA(this, thread_id);
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
@@ -314,7 +297,7 @@ void SBBreakpointLocation::SetThreadID(tid_t thread_id) {
}
tid_t SBBreakpointLocation::GetThreadID() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBBreakpointLocation, GetThreadID);
+ LLDB_INSTRUMENT_VA(this);
tid_t tid = LLDB_INVALID_THREAD_ID;
BreakpointLocationSP loc_sp = GetSP();
@@ -327,8 +310,7 @@ tid_t SBBreakpointLocation::GetThreadID() {
}
void SBBreakpointLocation::SetThreadIndex(uint32_t index) {
- LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetThreadIndex, (uint32_t),
- index);
+ LLDB_INSTRUMENT_VA(this, index);
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
@@ -339,8 +321,7 @@ void SBBreakpointLocation::SetThreadIndex(uint32_t index) {
}
uint32_t SBBreakpointLocation::GetThreadIndex() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointLocation,
- GetThreadIndex);
+ LLDB_INSTRUMENT_VA(this);
uint32_t thread_idx = UINT32_MAX;
BreakpointLocationSP loc_sp = GetSP();
@@ -353,8 +334,7 @@ uint32_t SBBreakpointLocation::GetThreadIndex() const {
}
void SBBreakpointLocation::SetThreadName(const char *thread_name) {
- LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetThreadName, (const char *),
- thread_name);
+ LLDB_INSTRUMENT_VA(this, thread_name);
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
@@ -365,8 +345,7 @@ void SBBreakpointLocation::SetThreadName(const char *thread_name) {
}
const char *SBBreakpointLocation::GetThreadName() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointLocation,
- GetThreadName);
+ LLDB_INSTRUMENT_VA(this);
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
@@ -378,8 +357,7 @@ const char *SBBreakpointLocation::GetThreadName() const {
}
void SBBreakpointLocation::SetQueueName(const char *queue_name) {
- LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetQueueName, (const char *),
- queue_name);
+ LLDB_INSTRUMENT_VA(this, queue_name);
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
@@ -390,8 +368,7 @@ void SBBreakpointLocation::SetQueueName(const char *queue_name) {
}
const char *SBBreakpointLocation::GetQueueName() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointLocation,
- GetQueueName);
+ LLDB_INSTRUMENT_VA(this);
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
@@ -403,7 +380,7 @@ const char *SBBreakpointLocation::GetQueueName() const {
}
bool SBBreakpointLocation::IsResolved() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointLocation, IsResolved);
+ LLDB_INSTRUMENT_VA(this);
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
@@ -422,9 +399,7 @@ void SBBreakpointLocation::SetLocation(
bool SBBreakpointLocation::GetDescription(SBStream &description,
DescriptionLevel level) {
- LLDB_RECORD_METHOD(bool, SBBreakpointLocation, GetDescription,
- (lldb::SBStream &, lldb::DescriptionLevel), description,
- level);
+ LLDB_INSTRUMENT_VA(this, description, level);
Stream &strm = description.ref();
BreakpointLocationSP loc_sp = GetSP();
@@ -441,7 +416,7 @@ bool SBBreakpointLocation::GetDescription(SBStream &description,
}
break_id_t SBBreakpointLocation::GetID() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::break_id_t, SBBreakpointLocation, GetID);
+ LLDB_INSTRUMENT_VA(this);
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
@@ -453,8 +428,7 @@ break_id_t SBBreakpointLocation::GetID() {
}
SBBreakpoint SBBreakpointLocation::GetBreakpoint() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBreakpoint, SBBreakpointLocation,
- GetBreakpoint);
+ LLDB_INSTRUMENT_VA(this);
BreakpointLocationSP loc_sp = GetSP();
diff --git a/lldb/source/API/SBBreakpointName.cpp b/lldb/source/API/SBBreakpointName.cpp
index 2937cb9e03d8..796229d04ce4 100644
--- a/lldb/source/API/SBBreakpointName.cpp
+++ b/lldb/source/API/SBBreakpointName.cpp
@@ -7,13 +7,13 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBBreakpointName.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBError.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBStringList.h"
#include "lldb/API/SBStructuredData.h"
#include "lldb/API/SBTarget.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/Breakpoint/BreakpointName.h"
#include "lldb/Breakpoint/StoppointCallbackContext.h"
@@ -107,13 +107,10 @@ lldb_private::BreakpointName *SBBreakpointNameImpl::GetBreakpointName() const {
} // namespace lldb
-SBBreakpointName::SBBreakpointName() {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBreakpointName);
-}
+SBBreakpointName::SBBreakpointName() { LLDB_INSTRUMENT_VA(this); }
SBBreakpointName::SBBreakpointName(SBTarget &sb_target, const char *name) {
- LLDB_RECORD_CONSTRUCTOR(SBBreakpointName, (lldb::SBTarget &, const char *),
- sb_target, name);
+ LLDB_INSTRUMENT_VA(this, sb_target, name);
m_impl_up = std::make_unique<SBBreakpointNameImpl>(sb_target, name);
// Call FindBreakpointName here to make sure the name is valid, reset if not:
@@ -123,8 +120,7 @@ SBBreakpointName::SBBreakpointName(SBTarget &sb_target, const char *name) {
}
SBBreakpointName::SBBreakpointName(SBBreakpoint &sb_bkpt, const char *name) {
- LLDB_RECORD_CONSTRUCTOR(SBBreakpointName,
- (lldb::SBBreakpoint &, const char *), sb_bkpt, name);
+ LLDB_INSTRUMENT_VA(this, sb_bkpt, name);
if (!sb_bkpt.IsValid()) {
m_impl_up.reset();
@@ -149,8 +145,7 @@ SBBreakpointName::SBBreakpointName(SBBreakpoint &sb_bkpt, const char *name) {
}
SBBreakpointName::SBBreakpointName(const SBBreakpointName &rhs) {
- LLDB_RECORD_CONSTRUCTOR(SBBreakpointName, (const lldb::SBBreakpointName &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (!rhs.m_impl_up)
return;
@@ -163,9 +158,7 @@ SBBreakpointName::~SBBreakpointName() = default;
const SBBreakpointName &SBBreakpointName::
operator=(const SBBreakpointName &rhs) {
- LLDB_RECORD_METHOD(
- const lldb::SBBreakpointName &,
- SBBreakpointName, operator=,(const lldb::SBBreakpointName &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (!rhs.m_impl_up) {
m_impl_up.reset();
@@ -178,25 +171,23 @@ operator=(const SBBreakpointName &rhs) {
}
bool SBBreakpointName::operator==(const lldb::SBBreakpointName &rhs) {
- LLDB_RECORD_METHOD(
- bool, SBBreakpointName, operator==,(const lldb::SBBreakpointName &), rhs);
+ LLDB_INSTRUMENT_VA(this, 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_INSTRUMENT_VA(this, rhs);
return *m_impl_up != *rhs.m_impl_up;
}
bool SBBreakpointName::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBBreakpointName::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, operator bool);
+ LLDB_INSTRUMENT_VA(this);
if (!m_impl_up)
return false;
@@ -204,7 +195,7 @@ SBBreakpointName::operator bool() const {
}
const char *SBBreakpointName::GetName() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName, GetName);
+ LLDB_INSTRUMENT_VA(this);
if (!m_impl_up)
return "<Invalid Breakpoint Name Object>";
@@ -212,7 +203,7 @@ const char *SBBreakpointName::GetName() const {
}
void SBBreakpointName::SetEnabled(bool enable) {
- LLDB_RECORD_METHOD(void, SBBreakpointName, SetEnabled, (bool), enable);
+ LLDB_INSTRUMENT_VA(this, enable);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@@ -236,7 +227,7 @@ void SBBreakpointName::UpdateName(BreakpointName &bp_name) {
}
bool SBBreakpointName::IsEnabled() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, IsEnabled);
+ LLDB_INSTRUMENT_VA(this);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@@ -249,7 +240,7 @@ bool SBBreakpointName::IsEnabled() {
}
void SBBreakpointName::SetOneShot(bool one_shot) {
- LLDB_RECORD_METHOD(void, SBBreakpointName, SetOneShot, (bool), one_shot);
+ LLDB_INSTRUMENT_VA(this, one_shot);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@@ -263,7 +254,7 @@ void SBBreakpointName::SetOneShot(bool one_shot) {
}
bool SBBreakpointName::IsOneShot() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, IsOneShot);
+ LLDB_INSTRUMENT_VA(this);
const BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@@ -276,7 +267,7 @@ bool SBBreakpointName::IsOneShot() const {
}
void SBBreakpointName::SetIgnoreCount(uint32_t count) {
- LLDB_RECORD_METHOD(void, SBBreakpointName, SetIgnoreCount, (uint32_t), count);
+ LLDB_INSTRUMENT_VA(this, count);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@@ -290,7 +281,7 @@ void SBBreakpointName::SetIgnoreCount(uint32_t count) {
}
uint32_t SBBreakpointName::GetIgnoreCount() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointName, GetIgnoreCount);
+ LLDB_INSTRUMENT_VA(this);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@@ -303,8 +294,7 @@ uint32_t SBBreakpointName::GetIgnoreCount() const {
}
void SBBreakpointName::SetCondition(const char *condition) {
- LLDB_RECORD_METHOD(void, SBBreakpointName, SetCondition, (const char *),
- condition);
+ LLDB_INSTRUMENT_VA(this, condition);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@@ -318,7 +308,7 @@ void SBBreakpointName::SetCondition(const char *condition) {
}
const char *SBBreakpointName::GetCondition() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBBreakpointName, GetCondition);
+ LLDB_INSTRUMENT_VA(this);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@@ -331,8 +321,7 @@ const char *SBBreakpointName::GetCondition() {
}
void SBBreakpointName::SetAutoContinue(bool auto_continue) {
- LLDB_RECORD_METHOD(void, SBBreakpointName, SetAutoContinue, (bool),
- auto_continue);
+ LLDB_INSTRUMENT_VA(this, auto_continue);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@@ -346,7 +335,7 @@ void SBBreakpointName::SetAutoContinue(bool auto_continue) {
}
bool SBBreakpointName::GetAutoContinue() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAutoContinue);
+ LLDB_INSTRUMENT_VA(this);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@@ -359,7 +348,7 @@ bool SBBreakpointName::GetAutoContinue() {
}
void SBBreakpointName::SetThreadID(tid_t tid) {
- LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadID, (lldb::tid_t), tid);
+ LLDB_INSTRUMENT_VA(this, tid);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@@ -373,7 +362,7 @@ void SBBreakpointName::SetThreadID(tid_t tid) {
}
tid_t SBBreakpointName::GetThreadID() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBBreakpointName, GetThreadID);
+ LLDB_INSTRUMENT_VA(this);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@@ -386,7 +375,7 @@ tid_t SBBreakpointName::GetThreadID() {
}
void SBBreakpointName::SetThreadIndex(uint32_t index) {
- LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadIndex, (uint32_t), index);
+ LLDB_INSTRUMENT_VA(this, index);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@@ -400,7 +389,7 @@ void SBBreakpointName::SetThreadIndex(uint32_t index) {
}
uint32_t SBBreakpointName::GetThreadIndex() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointName, GetThreadIndex);
+ LLDB_INSTRUMENT_VA(this);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@@ -413,8 +402,7 @@ uint32_t SBBreakpointName::GetThreadIndex() const {
}
void SBBreakpointName::SetThreadName(const char *thread_name) {
- LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadName, (const char *),
- thread_name);
+ LLDB_INSTRUMENT_VA(this, thread_name);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@@ -428,8 +416,7 @@ void SBBreakpointName::SetThreadName(const char *thread_name) {
}
const char *SBBreakpointName::GetThreadName() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName,
- GetThreadName);
+ LLDB_INSTRUMENT_VA(this);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@@ -442,8 +429,7 @@ const char *SBBreakpointName::GetThreadName() const {
}
void SBBreakpointName::SetQueueName(const char *queue_name) {
- LLDB_RECORD_METHOD(void, SBBreakpointName, SetQueueName, (const char *),
- queue_name);
+ LLDB_INSTRUMENT_VA(this, queue_name);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@@ -457,8 +443,7 @@ void SBBreakpointName::SetQueueName(const char *queue_name) {
}
const char *SBBreakpointName::GetQueueName() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName,
- GetQueueName);
+ LLDB_INSTRUMENT_VA(this);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@@ -471,8 +456,7 @@ const char *SBBreakpointName::GetQueueName() const {
}
void SBBreakpointName::SetCommandLineCommands(SBStringList &commands) {
- LLDB_RECORD_METHOD(void, SBBreakpointName, SetCommandLineCommands,
- (lldb::SBStringList &), commands);
+ LLDB_INSTRUMENT_VA(this, commands);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@@ -491,8 +475,7 @@ void SBBreakpointName::SetCommandLineCommands(SBStringList &commands) {
}
bool SBBreakpointName::GetCommandLineCommands(SBStringList &commands) {
- LLDB_RECORD_METHOD(bool, SBBreakpointName, GetCommandLineCommands,
- (lldb::SBStringList &), commands);
+ LLDB_INSTRUMENT_VA(this, commands);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@@ -507,8 +490,7 @@ bool SBBreakpointName::GetCommandLineCommands(SBStringList &commands) {
}
const char *SBBreakpointName::GetHelpString() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName,
- GetHelpString);
+ LLDB_INSTRUMENT_VA(this);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@@ -518,8 +500,7 @@ const char *SBBreakpointName::GetHelpString() const {
}
void SBBreakpointName::SetHelpString(const char *help_string) {
- LLDB_RECORD_METHOD(void, SBBreakpointName, SetHelpString, (const char *),
- help_string);
+ LLDB_INSTRUMENT_VA(this, help_string);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@@ -532,8 +513,7 @@ void SBBreakpointName::SetHelpString(const char *help_string) {
}
bool SBBreakpointName::GetDescription(SBStream &s) {
- LLDB_RECORD_METHOD(bool, SBBreakpointName, GetDescription, (lldb::SBStream &),
- s);
+ LLDB_INSTRUMENT_VA(this, s);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@@ -550,8 +530,7 @@ bool SBBreakpointName::GetDescription(SBStream &s) {
void SBBreakpointName::SetCallback(SBBreakpointHitCallback callback,
void *baton) {
- LLDB_RECORD_METHOD(void, SBBreakpointName, SetCallback,
- (lldb::SBBreakpointHitCallback, void *), callback, baton);
+ LLDB_INSTRUMENT_VA(this, callback, baton);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@@ -569,8 +548,7 @@ void SBBreakpointName::SetCallback(SBBreakpointHitCallback callback,
void SBBreakpointName::SetScriptCallbackFunction(
const char *callback_function_name) {
-LLDB_RECORD_METHOD(void, SBBreakpointName, SetScriptCallbackFunction,
- (const char *), callback_function_name);
+ LLDB_INSTRUMENT_VA(this, callback_function_name);
SBStructuredData empty_args;
SetScriptCallbackFunction(callback_function_name, empty_args);
}
@@ -578,9 +556,7 @@ LLDB_RECORD_METHOD(void, SBBreakpointName, SetScriptCallbackFunction,
SBError SBBreakpointName::SetScriptCallbackFunction(
const char *callback_function_name,
SBStructuredData &extra_args) {
- LLDB_RECORD_METHOD(SBError, SBBreakpointName, SetScriptCallbackFunction,
- (const char *, SBStructuredData &),
- callback_function_name, extra_args);
+ LLDB_INSTRUMENT_VA(this, callback_function_name, extra_args);
SBError sb_error;
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name) {
@@ -606,8 +582,7 @@ SBError SBBreakpointName::SetScriptCallbackFunction(
SBError
SBBreakpointName::SetScriptCallbackBody(const char *callback_body_text) {
- LLDB_RECORD_METHOD(lldb::SBError, SBBreakpointName, SetScriptCallbackBody,
- (const char *), callback_body_text);
+ LLDB_INSTRUMENT_VA(this, callback_body_text);
SBError sb_error;
BreakpointName *bp_name = GetBreakpointName();
@@ -631,7 +606,7 @@ SBBreakpointName::SetScriptCallbackBody(const char *callback_body_text) {
}
bool SBBreakpointName::GetAllowList() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, GetAllowList);
+ LLDB_INSTRUMENT_VA(this);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@@ -640,8 +615,7 @@ bool SBBreakpointName::GetAllowList() const {
}
void SBBreakpointName::SetAllowList(bool value) {
- LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowList, (bool), value);
-
+ LLDB_INSTRUMENT_VA(this, value);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@@ -650,7 +624,7 @@ void SBBreakpointName::SetAllowList(bool value) {
}
bool SBBreakpointName::GetAllowDelete() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAllowDelete);
+ LLDB_INSTRUMENT_VA(this);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@@ -659,8 +633,7 @@ bool SBBreakpointName::GetAllowDelete() {
}
void SBBreakpointName::SetAllowDelete(bool value) {
- LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowDelete, (bool), value);
-
+ LLDB_INSTRUMENT_VA(this, value);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@@ -669,7 +642,7 @@ void SBBreakpointName::SetAllowDelete(bool value) {
}
bool SBBreakpointName::GetAllowDisable() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAllowDisable);
+ LLDB_INSTRUMENT_VA(this);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@@ -678,7 +651,7 @@ bool SBBreakpointName::GetAllowDisable() {
}
void SBBreakpointName::SetAllowDisable(bool value) {
- LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowDisable, (bool), value);
+ LLDB_INSTRUMENT_VA(this, value);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
diff --git a/lldb/source/API/SBBreakpointOptionCommon.cpp b/lldb/source/API/SBBreakpointOptionCommon.cpp
index 2ee47ff7795c..685ed172c820 100644
--- a/lldb/source/API/SBBreakpointOptionCommon.cpp
+++ b/lldb/source/API/SBBreakpointOptionCommon.cpp
@@ -26,6 +26,7 @@
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadSpec.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/Log.h"
#include "lldb/Utility/Stream.h"
@@ -38,19 +39,18 @@
using namespace lldb;
using namespace lldb_private;
-SBBreakpointCallbackBaton::SBBreakpointCallbackBaton(SBBreakpointHitCallback
- callback,
- void *baton)
- : TypedBaton(std::make_unique<CallbackData>()) {
- getItem()->callback = callback;
- getItem()->callback_baton = baton;
- }
+SBBreakpointCallbackBaton::SBBreakpointCallbackBaton(
+ SBBreakpointHitCallback callback, void *baton)
+ : TypedBaton(std::make_unique<CallbackData>()) {
+ LLDB_INSTRUMENT_VA(this, callback, baton);
+ getItem()->callback = callback;
+ getItem()->callback_baton = baton;
+}
- bool SBBreakpointCallbackBaton::PrivateBreakpointHitCallback(void *baton,
- StoppointCallbackContext *ctx,
- lldb::user_id_t break_id,
- lldb::user_id_t break_loc_id)
-{
+bool SBBreakpointCallbackBaton::PrivateBreakpointHitCallback(
+ void *baton, StoppointCallbackContext *ctx, lldb::user_id_t break_id,
+ lldb::user_id_t break_loc_id) {
+ LLDB_INSTRUMENT_VA(baton, ctx, break_id, break_loc_id);
ExecutionContext exe_ctx(ctx->exe_ctx_ref);
BreakpointSP bp_sp(
exe_ctx.GetTargetRef().GetBreakpointList().FindBreakpointByID(break_id));
diff --git a/lldb/source/API/SBBroadcaster.cpp b/lldb/source/API/SBBroadcaster.cpp
index 4fa11cab5d9f..f145bc6e99d8 100644
--- a/lldb/source/API/SBBroadcaster.cpp
+++ b/lldb/source/API/SBBroadcaster.cpp
@@ -6,8 +6,8 @@
//
//===----------------------------------------------------------------------===//
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/Utility/Broadcaster.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/API/SBBroadcaster.h"
#include "lldb/API/SBEvent.h"
@@ -16,13 +16,11 @@
using namespace lldb;
using namespace lldb_private;
-SBBroadcaster::SBBroadcaster() {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBroadcaster);
-}
+SBBroadcaster::SBBroadcaster() { LLDB_INSTRUMENT_VA(this); }
SBBroadcaster::SBBroadcaster(const char *name)
: m_opaque_sp(new Broadcaster(nullptr, name)), m_opaque_ptr(nullptr) {
- LLDB_RECORD_CONSTRUCTOR(SBBroadcaster, (const char *), name);
+ LLDB_INSTRUMENT_VA(this, name);
m_opaque_ptr = m_opaque_sp.get();
}
@@ -32,13 +30,11 @@ SBBroadcaster::SBBroadcaster(lldb_private::Broadcaster *broadcaster, bool owns)
SBBroadcaster::SBBroadcaster(const SBBroadcaster &rhs)
: m_opaque_sp(rhs.m_opaque_sp), m_opaque_ptr(rhs.m_opaque_ptr) {
- LLDB_RECORD_CONSTRUCTOR(SBBroadcaster, (const lldb::SBBroadcaster &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
}
const SBBroadcaster &SBBroadcaster::operator=(const SBBroadcaster &rhs) {
- LLDB_RECORD_METHOD(const lldb::SBBroadcaster &,
- SBBroadcaster, operator=,(const lldb::SBBroadcaster &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
@@ -50,8 +46,7 @@ const SBBroadcaster &SBBroadcaster::operator=(const SBBroadcaster &rhs) {
SBBroadcaster::~SBBroadcaster() { reset(nullptr, false); }
void SBBroadcaster::BroadcastEventByType(uint32_t event_type, bool unique) {
- LLDB_RECORD_METHOD(void, SBBroadcaster, BroadcastEventByType,
- (uint32_t, bool), event_type, unique);
+ LLDB_INSTRUMENT_VA(this, event_type, unique);
if (m_opaque_ptr == nullptr)
return;
@@ -63,8 +58,7 @@ void SBBroadcaster::BroadcastEventByType(uint32_t event_type, bool unique) {
}
void SBBroadcaster::BroadcastEvent(const SBEvent &event, bool unique) {
- LLDB_RECORD_METHOD(void, SBBroadcaster, BroadcastEvent,
- (const lldb::SBEvent &, bool), event, unique);
+ LLDB_INSTRUMENT_VA(this, event, unique);
if (m_opaque_ptr == nullptr)
return;
@@ -78,9 +72,7 @@ void SBBroadcaster::BroadcastEvent(const SBEvent &event, bool unique) {
void SBBroadcaster::AddInitialEventsToListener(const SBListener &listener,
uint32_t requested_events) {
- LLDB_RECORD_METHOD(void, SBBroadcaster, AddInitialEventsToListener,
- (const lldb::SBListener &, uint32_t), listener,
- requested_events);
+ LLDB_INSTRUMENT_VA(this, listener, requested_events);
if (m_opaque_ptr)
m_opaque_ptr->AddInitialEventsToListener(listener.m_opaque_sp,
@@ -89,9 +81,7 @@ void SBBroadcaster::AddInitialEventsToListener(const SBListener &listener,
uint32_t SBBroadcaster::AddListener(const SBListener &listener,
uint32_t event_mask) {
- LLDB_RECORD_METHOD(uint32_t, SBBroadcaster, AddListener,
- (const lldb::SBListener &, uint32_t), listener,
- event_mask);
+ LLDB_INSTRUMENT_VA(this, listener, event_mask);
if (m_opaque_ptr)
return m_opaque_ptr->AddListener(listener.m_opaque_sp, event_mask);
@@ -99,7 +89,7 @@ uint32_t SBBroadcaster::AddListener(const SBListener &listener,
}
const char *SBBroadcaster::GetName() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBroadcaster, GetName);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr)
return m_opaque_ptr->GetBroadcasterName().GetCString();
@@ -107,8 +97,7 @@ const char *SBBroadcaster::GetName() const {
}
bool SBBroadcaster::EventTypeHasListeners(uint32_t event_type) {
- LLDB_RECORD_METHOD(bool, SBBroadcaster, EventTypeHasListeners, (uint32_t),
- event_type);
+ LLDB_INSTRUMENT_VA(this, event_type);
if (m_opaque_ptr)
return m_opaque_ptr->EventTypeHasListeners(event_type);
@@ -117,9 +106,7 @@ bool SBBroadcaster::EventTypeHasListeners(uint32_t event_type) {
bool SBBroadcaster::RemoveListener(const SBListener &listener,
uint32_t event_mask) {
- LLDB_RECORD_METHOD(bool, SBBroadcaster, RemoveListener,
- (const lldb::SBListener &, uint32_t), listener,
- event_mask);
+ LLDB_INSTRUMENT_VA(this, listener, event_mask);
if (m_opaque_ptr)
return m_opaque_ptr->RemoveListener(listener.m_opaque_sp, event_mask);
@@ -137,39 +124,36 @@ void SBBroadcaster::reset(Broadcaster *broadcaster, bool owns) {
}
bool SBBroadcaster::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBroadcaster, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBBroadcaster::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBroadcaster, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_ptr != nullptr;
}
void SBBroadcaster::Clear() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBBroadcaster, Clear);
+ LLDB_INSTRUMENT_VA(this);
m_opaque_sp.reset();
m_opaque_ptr = nullptr;
}
bool SBBroadcaster::operator==(const SBBroadcaster &rhs) const {
- LLDB_RECORD_METHOD_CONST(
- bool, SBBroadcaster, operator==,(const lldb::SBBroadcaster &), rhs);
+ LLDB_INSTRUMENT_VA(this, 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_INSTRUMENT_VA(this, 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_INSTRUMENT_VA(this, rhs);
return m_opaque_ptr < rhs.m_opaque_ptr;
}
diff --git a/lldb/source/API/SBCommandInterpreter.cpp b/lldb/source/API/SBCommandInterpreter.cpp
index d543246edcb4..073c1a1b042c 100644
--- a/lldb/source/API/SBCommandInterpreter.cpp
+++ b/lldb/source/API/SBCommandInterpreter.cpp
@@ -8,11 +8,11 @@
#include "lldb/lldb-types.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/CommandObjectMultiword.h"
#include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Target/Target.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/Listener.h"
#include "lldb/API/SBBroadcaster.h"
@@ -78,71 +78,62 @@ class CommandPluginInterfaceImplementation : public CommandObjectParsed {
SBCommandInterpreter::SBCommandInterpreter(CommandInterpreter *interpreter)
: m_opaque_ptr(interpreter) {
- LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreter,
- (lldb_private::CommandInterpreter *), interpreter);
-
+ LLDB_INSTRUMENT_VA(this, interpreter);
}
SBCommandInterpreter::SBCommandInterpreter(const SBCommandInterpreter &rhs)
: m_opaque_ptr(rhs.m_opaque_ptr) {
- LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreter,
- (const lldb::SBCommandInterpreter &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
}
SBCommandInterpreter::~SBCommandInterpreter() = default;
const SBCommandInterpreter &SBCommandInterpreter::
operator=(const SBCommandInterpreter &rhs) {
- LLDB_RECORD_METHOD(
- const lldb::SBCommandInterpreter &,
- SBCommandInterpreter, operator=,(const lldb::SBCommandInterpreter &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_ptr = rhs.m_opaque_ptr;
return *this;
}
bool SBCommandInterpreter::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBCommandInterpreter::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_ptr != nullptr;
}
bool SBCommandInterpreter::CommandExists(const char *cmd) {
- LLDB_RECORD_METHOD(bool, SBCommandInterpreter, CommandExists, (const char *),
- cmd);
+ LLDB_INSTRUMENT_VA(this, cmd);
return (((cmd != nullptr) && IsValid()) ? m_opaque_ptr->CommandExists(cmd)
: false);
}
bool SBCommandInterpreter::AliasExists(const char *cmd) {
- LLDB_RECORD_METHOD(bool, SBCommandInterpreter, AliasExists, (const char *),
- cmd);
+ LLDB_INSTRUMENT_VA(this, cmd);
return (((cmd != nullptr) && IsValid()) ? m_opaque_ptr->AliasExists(cmd)
: false);
}
bool SBCommandInterpreter::IsActive() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, IsActive);
+ LLDB_INSTRUMENT_VA(this);
return (IsValid() ? m_opaque_ptr->IsActive() : false);
}
bool SBCommandInterpreter::WasInterrupted() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, WasInterrupted);
+ LLDB_INSTRUMENT_VA(this);
return (IsValid() ? m_opaque_ptr->WasInterrupted() : false);
}
const char *SBCommandInterpreter::GetIOHandlerControlSequence(char ch) {
- LLDB_RECORD_METHOD(const char *, SBCommandInterpreter,
- GetIOHandlerControlSequence, (char), ch);
+ LLDB_INSTRUMENT_VA(this, ch);
return (IsValid()
? m_opaque_ptr->GetDebugger()
@@ -155,9 +146,7 @@ lldb::ReturnStatus
SBCommandInterpreter::HandleCommand(const char *command_line,
SBCommandReturnObject &result,
bool add_to_history) {
- LLDB_RECORD_METHOD(lldb::ReturnStatus, SBCommandInterpreter, HandleCommand,
- (const char *, lldb::SBCommandReturnObject &, bool),
- command_line, result, add_to_history);
+ LLDB_INSTRUMENT_VA(this, command_line, result, add_to_history);
SBExecutionContext sb_exe_ctx;
return HandleCommand(command_line, sb_exe_ctx, result, add_to_history);
@@ -166,10 +155,8 @@ SBCommandInterpreter::HandleCommand(const char *command_line,
lldb::ReturnStatus SBCommandInterpreter::HandleCommand(
const char *command_line, SBExecutionContext &override_context,
SBCommandReturnObject &result, bool add_to_history) {
- LLDB_RECORD_METHOD(lldb::ReturnStatus, SBCommandInterpreter, HandleCommand,
- (const char *, lldb::SBExecutionContext &,
- lldb::SBCommandReturnObject &, bool),
- command_line, override_context, result, add_to_history);
+ LLDB_INSTRUMENT_VA(this, command_line, override_context, result,
+ add_to_history);
result.Clear();
if (command_line && IsValid()) {
@@ -194,11 +181,7 @@ void SBCommandInterpreter::HandleCommandsFromFile(
lldb::SBFileSpec &file, lldb::SBExecutionContext &override_context,
lldb::SBCommandInterpreterRunOptions &options,
lldb::SBCommandReturnObject result) {
- LLDB_RECORD_METHOD(void, SBCommandInterpreter, HandleCommandsFromFile,
- (lldb::SBFileSpec &, lldb::SBExecutionContext &,
- lldb::SBCommandInterpreterRunOptions &,
- lldb::SBCommandReturnObject),
- file, override_context, options, result);
+ LLDB_INSTRUMENT_VA(this, file, override_context, options, result);
if (!IsValid()) {
result->AppendError("SBCommandInterpreter is not valid.");
@@ -225,10 +208,7 @@ void SBCommandInterpreter::HandleCommandsFromFile(
int SBCommandInterpreter::HandleCompletion(
const char *current_line, const char *cursor, const char *last_char,
int match_start_point, int max_return_elements, SBStringList &matches) {
- LLDB_RECORD_METHOD(int, SBCommandInterpreter, HandleCompletion,
- (const char *, const char *, const char *, int, int,
- lldb::SBStringList &),
- current_line, cursor, last_char, match_start_point,
+ LLDB_INSTRUMENT_VA(this, current_line, cursor, last_char, match_start_point,
max_return_elements, matches);
SBStringList dummy_descriptions;
@@ -241,11 +221,7 @@ int SBCommandInterpreter::HandleCompletionWithDescriptions(
const char *current_line, const char *cursor, const char *last_char,
int match_start_point, int max_return_elements, SBStringList &matches,
SBStringList &descriptions) {
- LLDB_RECORD_METHOD(int, SBCommandInterpreter,
- HandleCompletionWithDescriptions,
- (const char *, const char *, const char *, int, int,
- lldb::SBStringList &, lldb::SBStringList &),
- current_line, cursor, last_char, match_start_point,
+ LLDB_INSTRUMENT_VA(this, current_line, cursor, last_char, match_start_point,
max_return_elements, matches, descriptions);
// Sanity check the arguments that are passed in: cursor & last_char have to
@@ -311,11 +287,7 @@ int SBCommandInterpreter::HandleCompletionWithDescriptions(
const char *current_line, uint32_t cursor_pos, int match_start_point,
int max_return_elements, SBStringList &matches,
SBStringList &descriptions) {
- LLDB_RECORD_METHOD(int, SBCommandInterpreter,
- HandleCompletionWithDescriptions,
- (const char *, uint32_t, int, int, lldb::SBStringList &,
- lldb::SBStringList &),
- current_line, cursor_pos, match_start_point,
+ LLDB_INSTRUMENT_VA(this, current_line, cursor_pos, match_start_point,
max_return_elements, matches, descriptions);
const char *cursor = current_line + cursor_pos;
@@ -330,9 +302,7 @@ int SBCommandInterpreter::HandleCompletion(const char *current_line,
int match_start_point,
int max_return_elements,
lldb::SBStringList &matches) {
- LLDB_RECORD_METHOD(int, SBCommandInterpreter, HandleCompletion,
- (const char *, uint32_t, int, int, lldb::SBStringList &),
- current_line, cursor_pos, match_start_point,
+ LLDB_INSTRUMENT_VA(this, current_line, cursor_pos, match_start_point,
max_return_elements, matches);
const char *cursor = current_line + cursor_pos;
@@ -342,25 +312,25 @@ int SBCommandInterpreter::HandleCompletion(const char *current_line,
}
bool SBCommandInterpreter::HasCommands() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasCommands);
+ LLDB_INSTRUMENT_VA(this);
return (IsValid() ? m_opaque_ptr->HasCommands() : false);
}
bool SBCommandInterpreter::HasAliases() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasAliases);
+ LLDB_INSTRUMENT_VA(this);
return (IsValid() ? m_opaque_ptr->HasAliases() : false);
}
bool SBCommandInterpreter::HasAliasOptions() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasAliasOptions);
+ LLDB_INSTRUMENT_VA(this);
return (IsValid() ? m_opaque_ptr->HasAliasOptions() : false);
}
SBProcess SBCommandInterpreter::GetProcess() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBCommandInterpreter, GetProcess);
+ LLDB_INSTRUMENT_VA(this);
SBProcess sb_process;
ProcessSP process_sp;
@@ -377,8 +347,7 @@ SBProcess SBCommandInterpreter::GetProcess() {
}
SBDebugger SBCommandInterpreter::GetDebugger() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBDebugger, SBCommandInterpreter,
- GetDebugger);
+ LLDB_INSTRUMENT_VA(this);
SBDebugger sb_debugger;
if (IsValid())
@@ -388,28 +357,27 @@ SBDebugger SBCommandInterpreter::GetDebugger() {
}
bool SBCommandInterpreter::GetPromptOnQuit() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, GetPromptOnQuit);
+ LLDB_INSTRUMENT_VA(this);
return (IsValid() ? m_opaque_ptr->GetPromptOnQuit() : false);
}
void SBCommandInterpreter::SetPromptOnQuit(bool b) {
- LLDB_RECORD_METHOD(void, SBCommandInterpreter, SetPromptOnQuit, (bool), b);
+ LLDB_INSTRUMENT_VA(this, b);
if (IsValid())
m_opaque_ptr->SetPromptOnQuit(b);
}
void SBCommandInterpreter::AllowExitCodeOnQuit(bool allow) {
- LLDB_RECORD_METHOD(void, SBCommandInterpreter, AllowExitCodeOnQuit, (bool),
- allow);
+ LLDB_INSTRUMENT_VA(this, allow);
if (m_opaque_ptr)
m_opaque_ptr->AllowExitCodeOnQuit(allow);
}
bool SBCommandInterpreter::HasCustomQuitExitCode() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasCustomQuitExitCode);
+ LLDB_INSTRUMENT_VA(this);
bool exited = false;
if (m_opaque_ptr)
@@ -418,7 +386,7 @@ bool SBCommandInterpreter::HasCustomQuitExitCode() {
}
int SBCommandInterpreter::GetQuitStatus() {
- LLDB_RECORD_METHOD_NO_ARGS(int, SBCommandInterpreter, GetQuitStatus);
+ LLDB_INSTRUMENT_VA(this);
bool exited = false;
return (m_opaque_ptr ? m_opaque_ptr->GetQuitExitCode(exited) : 0);
@@ -426,9 +394,7 @@ int SBCommandInterpreter::GetQuitStatus() {
void SBCommandInterpreter::ResolveCommand(const char *command_line,
SBCommandReturnObject &result) {
- LLDB_RECORD_METHOD(void, SBCommandInterpreter, ResolveCommand,
- (const char *, lldb::SBCommandReturnObject &),
- command_line, result);
+ LLDB_INSTRUMENT_VA(this, command_line, result);
result.Clear();
if (command_line && IsValid()) {
@@ -453,8 +419,7 @@ void SBCommandInterpreter::reset(
void SBCommandInterpreter::SourceInitFileInHomeDirectory(
SBCommandReturnObject &result) {
- LLDB_RECORD_METHOD(void, SBCommandInterpreter, SourceInitFileInHomeDirectory,
- (lldb::SBCommandReturnObject &), result);
+ LLDB_INSTRUMENT_VA(this, result);
result.Clear();
if (IsValid()) {
@@ -470,8 +435,7 @@ void SBCommandInterpreter::SourceInitFileInHomeDirectory(
void SBCommandInterpreter::SourceInitFileInHomeDirectory(
SBCommandReturnObject &result, bool is_repl) {
- LLDB_RECORD_METHOD(void, SBCommandInterpreter, SourceInitFileInHomeDirectory,
- (lldb::SBCommandReturnObject &, bool), result, is_repl);
+ LLDB_INSTRUMENT_VA(this, result, is_repl);
result.Clear();
if (IsValid()) {
@@ -487,9 +451,7 @@ void SBCommandInterpreter::SourceInitFileInHomeDirectory(
void SBCommandInterpreter::SourceInitFileInCurrentWorkingDirectory(
SBCommandReturnObject &result) {
- LLDB_RECORD_METHOD(void, SBCommandInterpreter,
- SourceInitFileInCurrentWorkingDirectory,
- (lldb::SBCommandReturnObject &), result);
+ LLDB_INSTRUMENT_VA(this, result);
result.Clear();
if (IsValid()) {
@@ -504,9 +466,7 @@ void SBCommandInterpreter::SourceInitFileInCurrentWorkingDirectory(
}
SBBroadcaster SBCommandInterpreter::GetBroadcaster() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBroadcaster, SBCommandInterpreter,
- GetBroadcaster);
-
+ LLDB_INSTRUMENT_VA(this);
SBBroadcaster broadcaster(m_opaque_ptr, false);
@@ -514,35 +474,28 @@ SBBroadcaster SBCommandInterpreter::GetBroadcaster() {
}
const char *SBCommandInterpreter::GetBroadcasterClass() {
- LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBCommandInterpreter,
- GetBroadcasterClass);
+ LLDB_INSTRUMENT();
return CommandInterpreter::GetStaticBroadcasterClass().AsCString();
}
const char *SBCommandInterpreter::GetArgumentTypeAsCString(
const lldb::CommandArgumentType arg_type) {
- LLDB_RECORD_STATIC_METHOD(const char *, SBCommandInterpreter,
- GetArgumentTypeAsCString,
- (const lldb::CommandArgumentType), arg_type);
+ LLDB_INSTRUMENT_VA(arg_type);
return CommandObject::GetArgumentTypeAsCString(arg_type);
}
const char *SBCommandInterpreter::GetArgumentDescriptionAsCString(
const lldb::CommandArgumentType arg_type) {
- LLDB_RECORD_STATIC_METHOD(const char *, SBCommandInterpreter,
- GetArgumentDescriptionAsCString,
- (const lldb::CommandArgumentType), arg_type);
+ LLDB_INSTRUMENT_VA(arg_type);
return CommandObject::GetArgumentDescriptionAsCString(arg_type);
}
bool SBCommandInterpreter::EventIsCommandInterpreterEvent(
const lldb::SBEvent &event) {
- LLDB_RECORD_STATIC_METHOD(bool, SBCommandInterpreter,
- EventIsCommandInterpreterEvent,
- (const lldb::SBEvent &), event);
+ LLDB_INSTRUMENT_VA(event);
return event.GetBroadcasterClass() ==
SBCommandInterpreter::GetBroadcasterClass();
@@ -551,9 +504,7 @@ bool SBCommandInterpreter::EventIsCommandInterpreterEvent(
bool SBCommandInterpreter::SetCommandOverrideCallback(
const char *command_name, lldb::CommandOverrideCallback callback,
void *baton) {
- LLDB_RECORD_METHOD(bool, SBCommandInterpreter, SetCommandOverrideCallback,
- (const char *, lldb::CommandOverrideCallback, void *),
- command_name, callback, baton);
+ LLDB_INSTRUMENT_VA(this, command_name, callback, baton);
if (command_name && command_name[0] && IsValid()) {
llvm::StringRef command_name_str = command_name;
@@ -570,8 +521,7 @@ bool SBCommandInterpreter::SetCommandOverrideCallback(
lldb::SBCommand SBCommandInterpreter::AddMultiwordCommand(const char *name,
const char *help) {
- LLDB_RECORD_METHOD(lldb::SBCommand, SBCommandInterpreter, AddMultiwordCommand,
- (const char *, const char *), name, help);
+ LLDB_INSTRUMENT_VA(this, name, help);
lldb::CommandObjectSP new_command_sp(
new CommandObjectMultiword(*m_opaque_ptr, name, help));
@@ -584,10 +534,7 @@ lldb::SBCommand SBCommandInterpreter::AddMultiwordCommand(const char *name,
lldb::SBCommand SBCommandInterpreter::AddCommand(
const char *name, lldb::SBCommandPluginInterface *impl, const char *help) {
- LLDB_RECORD_METHOD(
- lldb::SBCommand, SBCommandInterpreter, AddCommand,
- (const char *, lldb::SBCommandPluginInterface *, const char *), name,
- impl, help);
+ LLDB_INSTRUMENT_VA(this, name, impl, help);
return AddCommand(name, impl, help, /*syntax=*/nullptr,
/*auto_repeat_command=*/"");
@@ -597,20 +544,14 @@ lldb::SBCommand
SBCommandInterpreter::AddCommand(const char *name,
lldb::SBCommandPluginInterface *impl,
const char *help, const char *syntax) {
- LLDB_RECORD_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand,
- (const char *, lldb::SBCommandPluginInterface *,
- const char *, const char *),
- name, impl, help, syntax);
+ LLDB_INSTRUMENT_VA(this, name, impl, help, syntax);
return AddCommand(name, impl, help, syntax, /*auto_repeat_command=*/"");
}
lldb::SBCommand SBCommandInterpreter::AddCommand(
const char *name, lldb::SBCommandPluginInterface *impl, const char *help,
const char *syntax, const char *auto_repeat_command) {
- LLDB_RECORD_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand,
- (const char *, lldb::SBCommandPluginInterface *,
- const char *, const char *, const char *),
- name, impl, help, syntax, auto_repeat_command);
+ LLDB_INSTRUMENT_VA(this, name, impl, help, syntax, auto_repeat_command);
lldb::CommandObjectSP new_command_sp;
new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>(
@@ -623,49 +564,49 @@ lldb::SBCommand SBCommandInterpreter::AddCommand(
return lldb::SBCommand();
}
-SBCommand::SBCommand() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommand); }
+SBCommand::SBCommand() { LLDB_INSTRUMENT_VA(this); }
SBCommand::SBCommand(lldb::CommandObjectSP cmd_sp) : m_opaque_sp(cmd_sp) {}
bool SBCommand::IsValid() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommand, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBCommand::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommand, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp.get() != nullptr;
}
const char *SBCommand::GetName() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetName);
+ LLDB_INSTRUMENT_VA(this);
return (IsValid() ? ConstString(m_opaque_sp->GetCommandName()).AsCString() : nullptr);
}
const char *SBCommand::GetHelp() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetHelp);
+ LLDB_INSTRUMENT_VA(this);
return (IsValid() ? ConstString(m_opaque_sp->GetHelp()).AsCString()
: nullptr);
}
const char *SBCommand::GetHelpLong() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetHelpLong);
+ LLDB_INSTRUMENT_VA(this);
return (IsValid() ? ConstString(m_opaque_sp->GetHelpLong()).AsCString()
: nullptr);
}
void SBCommand::SetHelp(const char *help) {
- LLDB_RECORD_METHOD(void, SBCommand, SetHelp, (const char *), help);
+ LLDB_INSTRUMENT_VA(this, help);
if (IsValid())
m_opaque_sp->SetHelp(help);
}
void SBCommand::SetHelpLong(const char *help) {
- LLDB_RECORD_METHOD(void, SBCommand, SetHelpLong, (const char *), help);
+ LLDB_INSTRUMENT_VA(this, help);
if (IsValid())
m_opaque_sp->SetHelpLong(help);
@@ -673,8 +614,7 @@ void SBCommand::SetHelpLong(const char *help) {
lldb::SBCommand SBCommand::AddMultiwordCommand(const char *name,
const char *help) {
- LLDB_RECORD_METHOD(lldb::SBCommand, SBCommand, AddMultiwordCommand,
- (const char *, const char *), name, help);
+ LLDB_INSTRUMENT_VA(this, name, help);
if (!IsValid())
return lldb::SBCommand();
@@ -692,10 +632,7 @@ lldb::SBCommand SBCommand::AddMultiwordCommand(const char *name,
lldb::SBCommand SBCommand::AddCommand(const char *name,
lldb::SBCommandPluginInterface *impl,
const char *help) {
- LLDB_RECORD_METHOD(
- lldb::SBCommand, SBCommand, AddCommand,
- (const char *, lldb::SBCommandPluginInterface *, const char *), name,
- impl, help);
+ LLDB_INSTRUMENT_VA(this, name, impl, help);
return AddCommand(name, impl, help, /*syntax=*/nullptr,
/*auto_repeat_command=*/"");
}
@@ -703,10 +640,7 @@ lldb::SBCommand SBCommand::AddCommand(const char *name,
lldb::SBCommand SBCommand::AddCommand(const char *name,
lldb::SBCommandPluginInterface *impl,
const char *help, const char *syntax) {
- LLDB_RECORD_METHOD(lldb::SBCommand, SBCommand, AddCommand,
- (const char *, lldb::SBCommandPluginInterface *,
- const char *, const char *),
- name, impl, help, syntax);
+ LLDB_INSTRUMENT_VA(this, name, impl, help, syntax);
return AddCommand(name, impl, help, syntax, /*auto_repeat_command=*/"");
}
@@ -714,10 +648,7 @@ lldb::SBCommand SBCommand::AddCommand(const char *name,
lldb::SBCommandPluginInterface *impl,
const char *help, const char *syntax,
const char *auto_repeat_command) {
- LLDB_RECORD_METHOD(lldb::SBCommand, SBCommand, AddCommand,
- (const char *, lldb::SBCommandPluginInterface *,
- const char *, const char *, const char *),
- name, impl, help, syntax, auto_repeat_command);
+ LLDB_INSTRUMENT_VA(this, name, impl, help, syntax, auto_repeat_command);
if (!IsValid())
return lldb::SBCommand();
@@ -733,13 +664,13 @@ lldb::SBCommand SBCommand::AddCommand(const char *name,
}
uint32_t SBCommand::GetFlags() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBCommand, GetFlags);
+ LLDB_INSTRUMENT_VA(this);
return (IsValid() ? m_opaque_sp->GetFlags().Get() : 0);
}
void SBCommand::SetFlags(uint32_t flags) {
- LLDB_RECORD_METHOD(void, SBCommand, SetFlags, (uint32_t), flags);
+ LLDB_INSTRUMENT_VA(this, flags);
if (IsValid())
m_opaque_sp->GetFlags().Set(flags);
diff --git a/lldb/source/API/SBCommandInterpreterRunOptions.cpp b/lldb/source/API/SBCommandInterpreterRunOptions.cpp
index eb1a4885f207..6c6b2aa15a79 100644
--- a/lldb/source/API/SBCommandInterpreterRunOptions.cpp
+++ b/lldb/source/API/SBCommandInterpreterRunOptions.cpp
@@ -8,7 +8,7 @@
#include "lldb/lldb-types.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/API/SBCommandInterpreterRunOptions.h"
#include "lldb/Interpreter/CommandInterpreter.h"
@@ -19,15 +19,14 @@ using namespace lldb;
using namespace lldb_private;
SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions() {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommandInterpreterRunOptions);
+ LLDB_INSTRUMENT_VA(this);
m_opaque_up = std::make_unique<CommandInterpreterRunOptions>();
}
SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions(
const SBCommandInterpreterRunOptions &rhs) {
- LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreterRunOptions,
- (const lldb::SBCommandInterpreterRunOptions &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_up = std::make_unique<CommandInterpreterRunOptions>(rhs.ref());
}
@@ -36,9 +35,7 @@ SBCommandInterpreterRunOptions::~SBCommandInterpreterRunOptions() = default;
SBCommandInterpreterRunOptions &SBCommandInterpreterRunOptions::operator=(
const SBCommandInterpreterRunOptions &rhs) {
- LLDB_RECORD_METHOD(lldb::SBCommandInterpreterRunOptions &,
- SBCommandInterpreterRunOptions, operator=,
- (const lldb::SBCommandInterpreterRunOptions &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this == &rhs)
return *this;
@@ -47,142 +44,122 @@ SBCommandInterpreterRunOptions &SBCommandInterpreterRunOptions::operator=(
}
bool SBCommandInterpreterRunOptions::GetStopOnContinue() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
- GetStopOnContinue);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetStopOnContinue();
}
void SBCommandInterpreterRunOptions::SetStopOnContinue(bool stop_on_continue) {
- LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnContinue,
- (bool), stop_on_continue);
+ LLDB_INSTRUMENT_VA(this, stop_on_continue);
m_opaque_up->SetStopOnContinue(stop_on_continue);
}
bool SBCommandInterpreterRunOptions::GetStopOnError() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
- GetStopOnError);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetStopOnError();
}
void SBCommandInterpreterRunOptions::SetStopOnError(bool stop_on_error) {
- LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnError,
- (bool), stop_on_error);
+ LLDB_INSTRUMENT_VA(this, stop_on_error);
m_opaque_up->SetStopOnError(stop_on_error);
}
bool SBCommandInterpreterRunOptions::GetStopOnCrash() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
- GetStopOnCrash);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetStopOnCrash();
}
void SBCommandInterpreterRunOptions::SetStopOnCrash(bool stop_on_crash) {
- LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnCrash,
- (bool), stop_on_crash);
+ LLDB_INSTRUMENT_VA(this, stop_on_crash);
m_opaque_up->SetStopOnCrash(stop_on_crash);
}
bool SBCommandInterpreterRunOptions::GetEchoCommands() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
- GetEchoCommands);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetEchoCommands();
}
void SBCommandInterpreterRunOptions::SetEchoCommands(bool echo_commands) {
- LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetEchoCommands,
- (bool), echo_commands);
+ LLDB_INSTRUMENT_VA(this, echo_commands);
m_opaque_up->SetEchoCommands(echo_commands);
}
bool SBCommandInterpreterRunOptions::GetEchoCommentCommands() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
- GetEchoCommentCommands);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetEchoCommentCommands();
}
void SBCommandInterpreterRunOptions::SetEchoCommentCommands(bool echo) {
- LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions,
- SetEchoCommentCommands, (bool), echo);
+ LLDB_INSTRUMENT_VA(this, echo);
m_opaque_up->SetEchoCommentCommands(echo);
}
bool SBCommandInterpreterRunOptions::GetPrintResults() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
- GetPrintResults);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetPrintResults();
}
void SBCommandInterpreterRunOptions::SetPrintResults(bool print_results) {
- LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetPrintResults,
- (bool), print_results);
+ LLDB_INSTRUMENT_VA(this, print_results);
m_opaque_up->SetPrintResults(print_results);
}
bool SBCommandInterpreterRunOptions::GetPrintErrors() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
- GetPrintErrors);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetPrintErrors();
}
void SBCommandInterpreterRunOptions::SetPrintErrors(bool print_errors) {
- LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetPrintErrors,
- (bool), print_errors);
+ LLDB_INSTRUMENT_VA(this, print_errors);
m_opaque_up->SetPrintErrors(print_errors);
}
bool SBCommandInterpreterRunOptions::GetAddToHistory() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
- GetAddToHistory);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetAddToHistory();
}
void SBCommandInterpreterRunOptions::SetAddToHistory(bool add_to_history) {
- LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetAddToHistory,
- (bool), add_to_history);
+ LLDB_INSTRUMENT_VA(this, add_to_history);
m_opaque_up->SetAddToHistory(add_to_history);
}
bool SBCommandInterpreterRunOptions::GetAutoHandleEvents() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
- GetAutoHandleEvents);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetAutoHandleEvents();
}
void SBCommandInterpreterRunOptions::SetAutoHandleEvents(
bool auto_handle_events) {
- LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetAutoHandleEvents,
- (bool), auto_handle_events);
+ LLDB_INSTRUMENT_VA(this, auto_handle_events);
m_opaque_up->SetAutoHandleEvents(auto_handle_events);
}
bool SBCommandInterpreterRunOptions::GetSpawnThread() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
- GetSpawnThread);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetSpawnThread();
}
void SBCommandInterpreterRunOptions::SetSpawnThread(bool spawn_thread) {
- LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetSpawnThread,
- (bool), spawn_thread);
+ LLDB_INSTRUMENT_VA(this, spawn_thread);
m_opaque_up->SetSpawnThread(spawn_thread);
}
@@ -201,14 +178,13 @@ SBCommandInterpreterRunResult::SBCommandInterpreterRunResult()
: m_opaque_up(new CommandInterpreterRunResult())
{
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommandInterpreterRunResult);
+ LLDB_INSTRUMENT_VA(this);
}
SBCommandInterpreterRunResult::SBCommandInterpreterRunResult(
const SBCommandInterpreterRunResult &rhs)
: m_opaque_up(new CommandInterpreterRunResult()) {
- LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreterRunResult,
- (const lldb::SBCommandInterpreterRunResult &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
*m_opaque_up = *rhs.m_opaque_up;
}
@@ -222,9 +198,7 @@ SBCommandInterpreterRunResult::~SBCommandInterpreterRunResult() = default;
SBCommandInterpreterRunResult &SBCommandInterpreterRunResult::operator=(
const SBCommandInterpreterRunResult &rhs) {
- LLDB_RECORD_METHOD(lldb::SBCommandInterpreterRunResult &,
- SBCommandInterpreterRunResult, operator=,
- (const lldb::SBCommandInterpreterRunResult &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this == &rhs)
return *this;
@@ -233,16 +207,14 @@ SBCommandInterpreterRunResult &SBCommandInterpreterRunResult::operator=(
}
int SBCommandInterpreterRunResult::GetNumberOfErrors() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(int, SBCommandInterpreterRunResult,
- GetNumberOfErrors);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetNumErrors();
}
lldb::CommandInterpreterResult
SBCommandInterpreterRunResult::GetResult() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::CommandInterpreterResult,
- SBCommandInterpreterRunResult, GetResult);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetResult();
}
diff --git a/lldb/source/API/SBCommandReturnObject.cpp b/lldb/source/API/SBCommandReturnObject.cpp
index 505145d75ce8..7d2c102b3d8c 100644
--- a/lldb/source/API/SBCommandReturnObject.cpp
+++ b/lldb/source/API/SBCommandReturnObject.cpp
@@ -7,13 +7,13 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBCommandReturnObject.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/API/SBError.h"
#include "lldb/API/SBFile.h"
#include "lldb/API/SBStream.h"
#include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/Status.h"
using namespace lldb;
@@ -46,28 +46,23 @@ class lldb_private::SBCommandReturnObjectImpl {
SBCommandReturnObject::SBCommandReturnObject()
: m_opaque_up(new SBCommandReturnObjectImpl()) {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommandReturnObject);
+ LLDB_INSTRUMENT_VA(this);
}
SBCommandReturnObject::SBCommandReturnObject(CommandReturnObject &ref)
: m_opaque_up(new SBCommandReturnObjectImpl(ref)) {
- LLDB_RECORD_CONSTRUCTOR(SBCommandReturnObject,
- (lldb_private::CommandReturnObject &), ref);
+ LLDB_INSTRUMENT_VA(this, ref);
}
SBCommandReturnObject::SBCommandReturnObject(const SBCommandReturnObject &rhs) {
- LLDB_RECORD_CONSTRUCTOR(SBCommandReturnObject,
- (const lldb::SBCommandReturnObject &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_up = clone(rhs.m_opaque_up);
}
SBCommandReturnObject &SBCommandReturnObject::
operator=(const SBCommandReturnObject &rhs) {
- LLDB_RECORD_METHOD(
- lldb::SBCommandReturnObject &,
- SBCommandReturnObject, operator=,(const lldb::SBCommandReturnObject &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
@@ -77,44 +72,44 @@ operator=(const SBCommandReturnObject &rhs) {
SBCommandReturnObject::~SBCommandReturnObject() = default;
bool SBCommandReturnObject::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandReturnObject, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBCommandReturnObject::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandReturnObject, operator bool);
+ LLDB_INSTRUMENT_VA(this);
// This method is not useful but it needs to stay to keep SB API stable.
return true;
}
const char *SBCommandReturnObject::GetOutput() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommandReturnObject, GetOutput);
+ LLDB_INSTRUMENT_VA(this);
ConstString output(ref().GetOutputData());
return output.AsCString(/*value_if_empty*/ "");
}
const char *SBCommandReturnObject::GetError() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommandReturnObject, GetError);
+ LLDB_INSTRUMENT_VA(this);
ConstString output(ref().GetErrorData());
return output.AsCString(/*value_if_empty*/ "");
}
size_t SBCommandReturnObject::GetOutputSize() {
- LLDB_RECORD_METHOD_NO_ARGS(size_t, SBCommandReturnObject, GetOutputSize);
+ LLDB_INSTRUMENT_VA(this);
return ref().GetOutputData().size();
}
size_t SBCommandReturnObject::GetErrorSize() {
- LLDB_RECORD_METHOD_NO_ARGS(size_t, SBCommandReturnObject, GetErrorSize);
+ LLDB_INSTRUMENT_VA(this);
return ref().GetErrorData().size();
}
size_t SBCommandReturnObject::PutOutput(FILE *fh) {
- LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutOutput, (FILE *), fh);
+ LLDB_INSTRUMENT_VA(this, fh);
if (fh) {
size_t num_bytes = GetOutputSize();
if (num_bytes)
@@ -124,22 +119,21 @@ size_t SBCommandReturnObject::PutOutput(FILE *fh) {
}
size_t SBCommandReturnObject::PutOutput(FileSP file_sp) {
- LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutOutput, (FileSP),
- file_sp);
+ LLDB_INSTRUMENT_VA(this, file_sp);
if (!file_sp)
return 0;
return file_sp->Printf("%s", GetOutput());
}
size_t SBCommandReturnObject::PutOutput(SBFile file) {
- LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutOutput, (SBFile), file);
+ LLDB_INSTRUMENT_VA(this, file);
if (!file.m_opaque_sp)
return 0;
return file.m_opaque_sp->Printf("%s", GetOutput());
}
size_t SBCommandReturnObject::PutError(FILE *fh) {
- LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutError, (FILE *), fh);
+ LLDB_INSTRUMENT_VA(this, fh);
if (fh) {
size_t num_bytes = GetErrorSize();
if (num_bytes)
@@ -149,62 +143,57 @@ size_t SBCommandReturnObject::PutError(FILE *fh) {
}
size_t SBCommandReturnObject::PutError(FileSP file_sp) {
- LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutError, (FileSP),
- file_sp);
+ LLDB_INSTRUMENT_VA(this, file_sp);
if (!file_sp)
return 0;
return file_sp->Printf("%s", GetError());
}
size_t SBCommandReturnObject::PutError(SBFile file) {
- LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutError, (SBFile), file);
+ LLDB_INSTRUMENT_VA(this, file);
if (!file.m_opaque_sp)
return 0;
return file.m_opaque_sp->Printf("%s", GetError());
}
void SBCommandReturnObject::Clear() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBCommandReturnObject, Clear);
+ LLDB_INSTRUMENT_VA(this);
ref().Clear();
}
lldb::ReturnStatus SBCommandReturnObject::GetStatus() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::ReturnStatus, SBCommandReturnObject,
- GetStatus);
+ LLDB_INSTRUMENT_VA(this);
return ref().GetStatus();
}
void SBCommandReturnObject::SetStatus(lldb::ReturnStatus status) {
- LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetStatus,
- (lldb::ReturnStatus), status);
+ LLDB_INSTRUMENT_VA(this, status);
ref().SetStatus(status);
}
bool SBCommandReturnObject::Succeeded() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandReturnObject, Succeeded);
+ LLDB_INSTRUMENT_VA(this);
return ref().Succeeded();
}
bool SBCommandReturnObject::HasResult() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandReturnObject, HasResult);
+ LLDB_INSTRUMENT_VA(this);
return ref().HasResult();
}
void SBCommandReturnObject::AppendMessage(const char *message) {
- LLDB_RECORD_METHOD(void, SBCommandReturnObject, AppendMessage, (const char *),
- message);
+ LLDB_INSTRUMENT_VA(this, message);
ref().AppendMessage(message);
}
void SBCommandReturnObject::AppendWarning(const char *message) {
- LLDB_RECORD_METHOD(void, SBCommandReturnObject, AppendWarning, (const char *),
- message);
+ LLDB_INSTRUMENT_VA(this, message);
ref().AppendWarning(message);
}
@@ -226,8 +215,7 @@ CommandReturnObject &SBCommandReturnObject::ref() const {
}
bool SBCommandReturnObject::GetDescription(SBStream &description) {
- LLDB_RECORD_METHOD(bool, SBCommandReturnObject, GetDescription,
- (lldb::SBStream &), description);
+ LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();
@@ -252,62 +240,53 @@ bool SBCommandReturnObject::GetDescription(SBStream &description) {
}
void SBCommandReturnObject::SetImmediateOutputFile(FILE *fh) {
- LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
- (FILE *), fh);
+ LLDB_INSTRUMENT_VA(this, fh);
SetImmediateOutputFile(fh, false);
}
void SBCommandReturnObject::SetImmediateErrorFile(FILE *fh) {
- LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
- (FILE *), fh);
+ LLDB_INSTRUMENT_VA(this, fh);
SetImmediateErrorFile(fh, false);
}
void SBCommandReturnObject::SetImmediateOutputFile(FILE *fh,
bool transfer_ownership) {
- LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
- (FILE *, bool), fh, transfer_ownership);
+ LLDB_INSTRUMENT_VA(this, fh, transfer_ownership);
FileSP file = std::make_shared<NativeFile>(fh, transfer_ownership);
ref().SetImmediateOutputFile(file);
}
void SBCommandReturnObject::SetImmediateErrorFile(FILE *fh,
bool transfer_ownership) {
- LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
- (FILE *, bool), fh, transfer_ownership);
+ LLDB_INSTRUMENT_VA(this, fh, transfer_ownership);
FileSP file = std::make_shared<NativeFile>(fh, transfer_ownership);
ref().SetImmediateErrorFile(file);
}
void SBCommandReturnObject::SetImmediateOutputFile(SBFile file) {
- LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
- (SBFile), file);
+ LLDB_INSTRUMENT_VA(this, file);
ref().SetImmediateOutputFile(file.m_opaque_sp);
}
void SBCommandReturnObject::SetImmediateErrorFile(SBFile file) {
- LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
- (SBFile), file);
+ LLDB_INSTRUMENT_VA(this, file);
ref().SetImmediateErrorFile(file.m_opaque_sp);
}
void SBCommandReturnObject::SetImmediateOutputFile(FileSP file_sp) {
- LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
- (FileSP), file_sp);
+ LLDB_INSTRUMENT_VA(this, file_sp);
SetImmediateOutputFile(SBFile(file_sp));
}
void SBCommandReturnObject::SetImmediateErrorFile(FileSP file_sp) {
- LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
- (FileSP), file_sp);
+ LLDB_INSTRUMENT_VA(this, file_sp);
SetImmediateErrorFile(SBFile(file_sp));
}
void SBCommandReturnObject::PutCString(const char *string, int len) {
- LLDB_RECORD_METHOD(void, SBCommandReturnObject, PutCString,
- (const char *, int), string, len);
+ LLDB_INSTRUMENT_VA(this, string, len);
if (len == 0 || string == nullptr || *string == 0) {
return;
@@ -319,8 +298,7 @@ void SBCommandReturnObject::PutCString(const char *string, int len) {
}
const char *SBCommandReturnObject::GetOutput(bool only_if_no_immediate) {
- LLDB_RECORD_METHOD(const char *, SBCommandReturnObject, GetOutput, (bool),
- only_if_no_immediate);
+ LLDB_INSTRUMENT_VA(this, only_if_no_immediate);
if (!only_if_no_immediate ||
ref().GetImmediateOutputStream().get() == nullptr)
@@ -329,8 +307,7 @@ const char *SBCommandReturnObject::GetOutput(bool only_if_no_immediate) {
}
const char *SBCommandReturnObject::GetError(bool only_if_no_immediate) {
- LLDB_RECORD_METHOD(const char *, SBCommandReturnObject, GetError, (bool),
- only_if_no_immediate);
+ LLDB_INSTRUMENT_VA(this, only_if_no_immediate);
if (!only_if_no_immediate || ref().GetImmediateErrorStream().get() == nullptr)
return GetError();
@@ -347,9 +324,7 @@ size_t SBCommandReturnObject::Printf(const char *format, ...) {
void SBCommandReturnObject::SetError(lldb::SBError &error,
const char *fallback_error_cstr) {
- LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetError,
- (lldb::SBError &, const char *), error,
- fallback_error_cstr);
+ LLDB_INSTRUMENT_VA(this, error, fallback_error_cstr);
if (error.IsValid())
ref().SetError(error.ref(), fallback_error_cstr);
@@ -358,8 +333,7 @@ void SBCommandReturnObject::SetError(lldb::SBError &error,
}
void SBCommandReturnObject::SetError(const char *error_cstr) {
- LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetError, (const char *),
- error_cstr);
+ LLDB_INSTRUMENT_VA(this, error_cstr);
if (error_cstr)
ref().AppendError(error_cstr);
diff --git a/lldb/source/API/SBCommunication.cpp b/lldb/source/API/SBCommunication.cpp
index 79a95c9dad62..0a1dad1e2e8f 100644
--- a/lldb/source/API/SBCommunication.cpp
+++ b/lldb/source/API/SBCommunication.cpp
@@ -7,22 +7,20 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBCommunication.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBBroadcaster.h"
#include "lldb/Core/Communication.h"
#include "lldb/Host/ConnectionFileDescriptor.h"
#include "lldb/Host/Host.h"
+#include "lldb/Utility/Instrumentation.h"
using namespace lldb;
using namespace lldb_private;
-SBCommunication::SBCommunication() {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommunication);
-}
+SBCommunication::SBCommunication() { LLDB_INSTRUMENT_VA(this); }
SBCommunication::SBCommunication(const char *broadcaster_name)
: m_opaque(new Communication(broadcaster_name)), m_opaque_owned(true) {
- LLDB_RECORD_CONSTRUCTOR(SBCommunication, (const char *), broadcaster_name);
+ LLDB_INSTRUMENT_VA(this, broadcaster_name);
}
SBCommunication::~SBCommunication() {
@@ -33,17 +31,17 @@ SBCommunication::~SBCommunication() {
}
bool SBCommunication::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommunication, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBCommunication::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommunication, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque != nullptr;
}
bool SBCommunication::GetCloseOnEOF() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, GetCloseOnEOF);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque)
return m_opaque->GetCloseOnEOF();
@@ -51,15 +49,14 @@ bool SBCommunication::GetCloseOnEOF() {
}
void SBCommunication::SetCloseOnEOF(bool b) {
- LLDB_RECORD_METHOD(void, SBCommunication, SetCloseOnEOF, (bool), b);
+ LLDB_INSTRUMENT_VA(this, b);
if (m_opaque)
m_opaque->SetCloseOnEOF(b);
}
ConnectionStatus SBCommunication::Connect(const char *url) {
- LLDB_RECORD_METHOD(lldb::ConnectionStatus, SBCommunication, Connect,
- (const char *), url);
+ LLDB_INSTRUMENT_VA(this, url);
if (m_opaque) {
if (!m_opaque->HasConnection())
@@ -70,8 +67,7 @@ ConnectionStatus SBCommunication::Connect(const char *url) {
}
ConnectionStatus SBCommunication::AdoptFileDesriptor(int fd, bool owns_fd) {
- LLDB_RECORD_METHOD(lldb::ConnectionStatus, SBCommunication,
- AdoptFileDesriptor, (int, bool), fd, owns_fd);
+ LLDB_INSTRUMENT_VA(this, fd, owns_fd);
ConnectionStatus status = eConnectionStatusNoConnection;
if (m_opaque) {
@@ -90,8 +86,7 @@ ConnectionStatus SBCommunication::AdoptFileDesriptor(int fd, bool owns_fd) {
}
ConnectionStatus SBCommunication::Disconnect() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::ConnectionStatus, SBCommunication,
- Disconnect);
+ LLDB_INSTRUMENT_VA(this);
ConnectionStatus status = eConnectionStatusNoConnection;
if (m_opaque)
@@ -100,16 +95,14 @@ ConnectionStatus SBCommunication::Disconnect() {
}
bool SBCommunication::IsConnected() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommunication, IsConnected);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque ? m_opaque->IsConnected() : false;
}
size_t SBCommunication::Read(void *dst, size_t dst_len, uint32_t timeout_usec,
ConnectionStatus &status) {
- LLDB_RECORD_METHOD(size_t, SBCommunication, Read,
- (void *, size_t, uint32_t, lldb::ConnectionStatus &), dst,
- dst_len, timeout_usec, status);
+ LLDB_INSTRUMENT_VA(this, dst, dst_len, timeout_usec, status);
size_t bytes_read = 0;
Timeout<std::micro> timeout = timeout_usec == UINT32_MAX
@@ -125,9 +118,7 @@ size_t SBCommunication::Read(void *dst, size_t dst_len, uint32_t timeout_usec,
size_t SBCommunication::Write(const void *src, size_t src_len,
ConnectionStatus &status) {
- LLDB_RECORD_METHOD(size_t, SBCommunication, Write,
- (const void *, size_t, lldb::ConnectionStatus &), src,
- src_len, status);
+ LLDB_INSTRUMENT_VA(this, src, src_len, status);
size_t bytes_written = 0;
if (m_opaque)
@@ -139,28 +130,26 @@ size_t SBCommunication::Write(const void *src, size_t src_len,
}
bool SBCommunication::ReadThreadStart() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadStart);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque ? m_opaque->StartReadThread() : false;
}
bool SBCommunication::ReadThreadStop() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadStop);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque ? m_opaque->StopReadThread() : false;
}
bool SBCommunication::ReadThreadIsRunning() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadIsRunning);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque ? m_opaque->ReadThreadIsRunning() : false;
}
bool SBCommunication::SetReadThreadBytesReceivedCallback(
ReadThreadBytesReceived callback, void *callback_baton) {
- LLDB_RECORD_METHOD(bool, SBCommunication, SetReadThreadBytesReceivedCallback,
- (lldb::SBCommunication::ReadThreadBytesReceived, void *),
- callback, callback_baton);
+ LLDB_INSTRUMENT_VA(this, callback, callback_baton);
bool result = false;
if (m_opaque) {
@@ -171,16 +160,14 @@ bool SBCommunication::SetReadThreadBytesReceivedCallback(
}
SBBroadcaster SBCommunication::GetBroadcaster() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBroadcaster, SBCommunication,
- GetBroadcaster);
+ LLDB_INSTRUMENT_VA(this);
SBBroadcaster broadcaster(m_opaque, false);
return broadcaster;
}
const char *SBCommunication::GetBroadcasterClass() {
- LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBCommunication,
- GetBroadcasterClass);
+ LLDB_INSTRUMENT();
return Communication::GetStaticBroadcasterClass().AsCString();
}
diff --git a/lldb/source/API/SBCompileUnit.cpp b/lldb/source/API/SBCompileUnit.cpp
index f3f3246ef2b5..46a319c6b7a3 100644
--- a/lldb/source/API/SBCompileUnit.cpp
+++ b/lldb/source/API/SBCompileUnit.cpp
@@ -7,7 +7,6 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBCompileUnit.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBLineEntry.h"
#include "lldb/API/SBStream.h"
#include "lldb/Core/Module.h"
@@ -17,26 +16,23 @@
#include "lldb/Symbol/SymbolFile.h"
#include "lldb/Symbol/Type.h"
#include "lldb/Symbol/TypeList.h"
+#include "lldb/Utility/Instrumentation.h"
using namespace lldb;
using namespace lldb_private;
-SBCompileUnit::SBCompileUnit() {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCompileUnit);
-}
+SBCompileUnit::SBCompileUnit() { LLDB_INSTRUMENT_VA(this); }
SBCompileUnit::SBCompileUnit(lldb_private::CompileUnit *lldb_object_ptr)
: m_opaque_ptr(lldb_object_ptr) {}
SBCompileUnit::SBCompileUnit(const SBCompileUnit &rhs)
: m_opaque_ptr(rhs.m_opaque_ptr) {
- LLDB_RECORD_CONSTRUCTOR(SBCompileUnit, (const lldb::SBCompileUnit &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
}
const SBCompileUnit &SBCompileUnit::operator=(const SBCompileUnit &rhs) {
- LLDB_RECORD_METHOD(const lldb::SBCompileUnit &,
- SBCompileUnit, operator=,(const lldb::SBCompileUnit &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_ptr = rhs.m_opaque_ptr;
return *this;
@@ -45,8 +41,7 @@ const SBCompileUnit &SBCompileUnit::operator=(const SBCompileUnit &rhs) {
SBCompileUnit::~SBCompileUnit() { m_opaque_ptr = nullptr; }
SBFileSpec SBCompileUnit::GetFileSpec() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBCompileUnit,
- GetFileSpec);
+ LLDB_INSTRUMENT_VA(this);
SBFileSpec file_spec;
if (m_opaque_ptr)
@@ -55,7 +50,7 @@ SBFileSpec SBCompileUnit::GetFileSpec() const {
}
uint32_t SBCompileUnit::GetNumLineEntries() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBCompileUnit, GetNumLineEntries);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr) {
LineTable *line_table = m_opaque_ptr->GetLineTable();
@@ -67,8 +62,7 @@ uint32_t SBCompileUnit::GetNumLineEntries() const {
}
SBLineEntry SBCompileUnit::GetLineEntryAtIndex(uint32_t idx) const {
- LLDB_RECORD_METHOD_CONST(lldb::SBLineEntry, SBCompileUnit,
- GetLineEntryAtIndex, (uint32_t), idx);
+ LLDB_INSTRUMENT_VA(this, idx);
SBLineEntry sb_line_entry;
if (m_opaque_ptr) {
@@ -85,9 +79,7 @@ SBLineEntry SBCompileUnit::GetLineEntryAtIndex(uint32_t idx) const {
uint32_t SBCompileUnit::FindLineEntryIndex(uint32_t start_idx, uint32_t line,
SBFileSpec *inline_file_spec) const {
- LLDB_RECORD_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex,
- (uint32_t, uint32_t, lldb::SBFileSpec *), start_idx,
- line, inline_file_spec);
+ LLDB_INSTRUMENT_VA(this, start_idx, line, inline_file_spec);
const bool exact = true;
return FindLineEntryIndex(start_idx, line, inline_file_spec, exact);
@@ -96,9 +88,7 @@ uint32_t SBCompileUnit::FindLineEntryIndex(uint32_t start_idx, uint32_t line,
uint32_t SBCompileUnit::FindLineEntryIndex(uint32_t start_idx, uint32_t line,
SBFileSpec *inline_file_spec,
bool exact) const {
- LLDB_RECORD_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex,
- (uint32_t, uint32_t, lldb::SBFileSpec *, bool),
- start_idx, line, inline_file_spec, exact);
+ LLDB_INSTRUMENT_VA(this, start_idx, line, inline_file_spec, exact);
uint32_t index = UINT32_MAX;
if (m_opaque_ptr) {
@@ -118,7 +108,7 @@ uint32_t SBCompileUnit::FindLineEntryIndex(uint32_t start_idx, uint32_t line,
}
uint32_t SBCompileUnit::GetNumSupportFiles() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBCompileUnit, GetNumSupportFiles);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr)
return m_opaque_ptr->GetSupportFiles().GetSize();
@@ -127,8 +117,7 @@ uint32_t SBCompileUnit::GetNumSupportFiles() const {
}
lldb::SBTypeList SBCompileUnit::GetTypes(uint32_t type_mask) {
- LLDB_RECORD_METHOD(lldb::SBTypeList, SBCompileUnit, GetTypes, (uint32_t),
- type_mask);
+ LLDB_INSTRUMENT_VA(this, type_mask);
SBTypeList sb_type_list;
@@ -151,8 +140,7 @@ lldb::SBTypeList SBCompileUnit::GetTypes(uint32_t type_mask) {
}
SBFileSpec SBCompileUnit::GetSupportFileAtIndex(uint32_t idx) const {
- LLDB_RECORD_METHOD_CONST(lldb::SBFileSpec, SBCompileUnit,
- GetSupportFileAtIndex, (uint32_t), idx);
+ LLDB_INSTRUMENT_VA(this, idx);
SBFileSpec sb_file_spec;
if (m_opaque_ptr) {
@@ -166,9 +154,7 @@ SBFileSpec SBCompileUnit::GetSupportFileAtIndex(uint32_t idx) const {
uint32_t SBCompileUnit::FindSupportFileIndex(uint32_t start_idx,
const SBFileSpec &sb_file,
bool full) {
- LLDB_RECORD_METHOD(uint32_t, SBCompileUnit, FindSupportFileIndex,
- (uint32_t, const lldb::SBFileSpec &, bool), start_idx,
- sb_file, full);
+ LLDB_INSTRUMENT_VA(this, start_idx, sb_file, full);
if (m_opaque_ptr) {
const FileSpecList &support_files = m_opaque_ptr->GetSupportFiles();
@@ -178,7 +164,7 @@ uint32_t SBCompileUnit::FindSupportFileIndex(uint32_t start_idx,
}
lldb::LanguageType SBCompileUnit::GetLanguage() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::LanguageType, SBCompileUnit, GetLanguage);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr)
return m_opaque_ptr->GetLanguage();
@@ -186,25 +172,23 @@ lldb::LanguageType SBCompileUnit::GetLanguage() {
}
bool SBCompileUnit::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCompileUnit, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBCompileUnit::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCompileUnit, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_ptr != nullptr;
}
bool SBCompileUnit::operator==(const SBCompileUnit &rhs) const {
- LLDB_RECORD_METHOD_CONST(
- bool, SBCompileUnit, operator==,(const lldb::SBCompileUnit &), rhs);
+ LLDB_INSTRUMENT_VA(this, 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_INSTRUMENT_VA(this, rhs);
return m_opaque_ptr != rhs.m_opaque_ptr;
}
@@ -224,8 +208,7 @@ void SBCompileUnit::reset(lldb_private::CompileUnit *lldb_object_ptr) {
}
bool SBCompileUnit::GetDescription(SBStream &description) {
- LLDB_RECORD_METHOD(bool, SBCompileUnit, GetDescription, (lldb::SBStream &),
- description);
+ LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();
diff --git a/lldb/source/API/SBData.cpp b/lldb/source/API/SBData.cpp
index e58f032a4f9c..5232bdde1ded 100644
--- a/lldb/source/API/SBData.cpp
+++ b/lldb/source/API/SBData.cpp
@@ -7,9 +7,9 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBData.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBError.h"
#include "lldb/API/SBStream.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/Core/DumpDataExtractor.h"
#include "lldb/Utility/DataBufferHeap.h"
@@ -23,18 +23,17 @@ using namespace lldb;
using namespace lldb_private;
SBData::SBData() : m_opaque_sp(new DataExtractor()) {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBData);
+ LLDB_INSTRUMENT_VA(this);
}
SBData::SBData(const lldb::DataExtractorSP &data_sp) : m_opaque_sp(data_sp) {}
SBData::SBData(const SBData &rhs) : m_opaque_sp(rhs.m_opaque_sp) {
- LLDB_RECORD_CONSTRUCTOR(SBData, (const lldb::SBData &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
}
const SBData &SBData::operator=(const SBData &rhs) {
- LLDB_RECORD_METHOD(const lldb::SBData &,
- SBData, operator=,(const lldb::SBData &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_sp = rhs.m_opaque_sp;
@@ -58,17 +57,17 @@ lldb::DataExtractorSP &SBData::operator*() { return m_opaque_sp; }
const lldb::DataExtractorSP &SBData::operator*() const { return m_opaque_sp; }
bool SBData::IsValid() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBData, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBData::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBData, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp.get() != nullptr;
}
uint8_t SBData::GetAddressByteSize() {
- LLDB_RECORD_METHOD_NO_ARGS(uint8_t, SBData, GetAddressByteSize);
+ LLDB_INSTRUMENT_VA(this);
uint8_t value = 0;
if (m_opaque_sp.get())
@@ -77,22 +76,21 @@ uint8_t SBData::GetAddressByteSize() {
}
void SBData::SetAddressByteSize(uint8_t addr_byte_size) {
- LLDB_RECORD_METHOD(void, SBData, SetAddressByteSize, (uint8_t),
- addr_byte_size);
+ LLDB_INSTRUMENT_VA(this, addr_byte_size);
if (m_opaque_sp.get())
m_opaque_sp->SetAddressByteSize(addr_byte_size);
}
void SBData::Clear() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBData, Clear);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp.get())
m_opaque_sp->Clear();
}
size_t SBData::GetByteSize() {
- LLDB_RECORD_METHOD_NO_ARGS(size_t, SBData, GetByteSize);
+ LLDB_INSTRUMENT_VA(this);
size_t value = 0;
if (m_opaque_sp.get())
@@ -101,7 +99,7 @@ size_t SBData::GetByteSize() {
}
lldb::ByteOrder SBData::GetByteOrder() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::ByteOrder, SBData, GetByteOrder);
+ LLDB_INSTRUMENT_VA(this);
lldb::ByteOrder value = eByteOrderInvalid;
if (m_opaque_sp.get())
@@ -110,15 +108,14 @@ lldb::ByteOrder SBData::GetByteOrder() {
}
void SBData::SetByteOrder(lldb::ByteOrder endian) {
- LLDB_RECORD_METHOD(void, SBData, SetByteOrder, (lldb::ByteOrder), endian);
+ LLDB_INSTRUMENT_VA(this, endian);
if (m_opaque_sp.get())
m_opaque_sp->SetByteOrder(endian);
}
float SBData::GetFloat(lldb::SBError &error, lldb::offset_t offset) {
- LLDB_RECORD_METHOD(float, SBData, GetFloat, (lldb::SBError &, lldb::offset_t),
- error, offset);
+ LLDB_INSTRUMENT_VA(this, error, offset);
float value = 0;
if (!m_opaque_sp.get()) {
@@ -133,8 +130,7 @@ float SBData::GetFloat(lldb::SBError &error, lldb::offset_t offset) {
}
double SBData::GetDouble(lldb::SBError &error, lldb::offset_t offset) {
- LLDB_RECORD_METHOD(double, SBData, GetDouble,
- (lldb::SBError &, lldb::offset_t), error, offset);
+ LLDB_INSTRUMENT_VA(this, error, offset);
double value = 0;
if (!m_opaque_sp.get()) {
@@ -149,8 +145,7 @@ double SBData::GetDouble(lldb::SBError &error, lldb::offset_t offset) {
}
long double SBData::GetLongDouble(lldb::SBError &error, lldb::offset_t offset) {
- LLDB_RECORD_METHOD(long double, SBData, GetLongDouble,
- (lldb::SBError &, lldb::offset_t), error, offset);
+ LLDB_INSTRUMENT_VA(this, error, offset);
long double value = 0;
if (!m_opaque_sp.get()) {
@@ -165,8 +160,7 @@ long double SBData::GetLongDouble(lldb::SBError &error, lldb::offset_t offset) {
}
lldb::addr_t SBData::GetAddress(lldb::SBError &error, lldb::offset_t offset) {
- LLDB_RECORD_METHOD(lldb::addr_t, SBData, GetAddress,
- (lldb::SBError &, lldb::offset_t), error, offset);
+ LLDB_INSTRUMENT_VA(this, error, offset);
lldb::addr_t value = 0;
if (!m_opaque_sp.get()) {
@@ -181,8 +175,7 @@ lldb::addr_t SBData::GetAddress(lldb::SBError &error, lldb::offset_t offset) {
}
uint8_t SBData::GetUnsignedInt8(lldb::SBError &error, lldb::offset_t offset) {
- LLDB_RECORD_METHOD(uint8_t, SBData, GetUnsignedInt8,
- (lldb::SBError &, lldb::offset_t), error, offset);
+ LLDB_INSTRUMENT_VA(this, error, offset);
uint8_t value = 0;
if (!m_opaque_sp.get()) {
@@ -197,8 +190,7 @@ uint8_t SBData::GetUnsignedInt8(lldb::SBError &error, lldb::offset_t offset) {
}
uint16_t SBData::GetUnsignedInt16(lldb::SBError &error, lldb::offset_t offset) {
- LLDB_RECORD_METHOD(uint16_t, SBData, GetUnsignedInt16,
- (lldb::SBError &, lldb::offset_t), error, offset);
+ LLDB_INSTRUMENT_VA(this, error, offset);
uint16_t value = 0;
if (!m_opaque_sp.get()) {
@@ -213,8 +205,7 @@ uint16_t SBData::GetUnsignedInt16(lldb::SBError &error, lldb::offset_t offset) {
}
uint32_t SBData::GetUnsignedInt32(lldb::SBError &error, lldb::offset_t offset) {
- LLDB_RECORD_METHOD(uint32_t, SBData, GetUnsignedInt32,
- (lldb::SBError &, lldb::offset_t), error, offset);
+ LLDB_INSTRUMENT_VA(this, error, offset);
uint32_t value = 0;
if (!m_opaque_sp.get()) {
@@ -229,8 +220,7 @@ uint32_t SBData::GetUnsignedInt32(lldb::SBError &error, lldb::offset_t offset) {
}
uint64_t SBData::GetUnsignedInt64(lldb::SBError &error, lldb::offset_t offset) {
- LLDB_RECORD_METHOD(uint64_t, SBData, GetUnsignedInt64,
- (lldb::SBError &, lldb::offset_t), error, offset);
+ LLDB_INSTRUMENT_VA(this, error, offset);
uint64_t value = 0;
if (!m_opaque_sp.get()) {
@@ -245,8 +235,7 @@ uint64_t SBData::GetUnsignedInt64(lldb::SBError &error, lldb::offset_t offset) {
}
int8_t SBData::GetSignedInt8(lldb::SBError &error, lldb::offset_t offset) {
- LLDB_RECORD_METHOD(int8_t, SBData, GetSignedInt8,
- (lldb::SBError &, lldb::offset_t), error, offset);
+ LLDB_INSTRUMENT_VA(this, error, offset);
int8_t value = 0;
if (!m_opaque_sp.get()) {
@@ -261,8 +250,7 @@ int8_t SBData::GetSignedInt8(lldb::SBError &error, lldb::offset_t offset) {
}
int16_t SBData::GetSignedInt16(lldb::SBError &error, lldb::offset_t offset) {
- LLDB_RECORD_METHOD(int16_t, SBData, GetSignedInt16,
- (lldb::SBError &, lldb::offset_t), error, offset);
+ LLDB_INSTRUMENT_VA(this, error, offset);
int16_t value = 0;
if (!m_opaque_sp.get()) {
@@ -277,8 +265,7 @@ int16_t SBData::GetSignedInt16(lldb::SBError &error, lldb::offset_t offset) {
}
int32_t SBData::GetSignedInt32(lldb::SBError &error, lldb::offset_t offset) {
- LLDB_RECORD_METHOD(int32_t, SBData, GetSignedInt32,
- (lldb::SBError &, lldb::offset_t), error, offset);
+ LLDB_INSTRUMENT_VA(this, error, offset);
int32_t value = 0;
if (!m_opaque_sp.get()) {
@@ -293,8 +280,7 @@ int32_t SBData::GetSignedInt32(lldb::SBError &error, lldb::offset_t offset) {
}
int64_t SBData::GetSignedInt64(lldb::SBError &error, lldb::offset_t offset) {
- LLDB_RECORD_METHOD(int64_t, SBData, GetSignedInt64,
- (lldb::SBError &, lldb::offset_t), error, offset);
+ LLDB_INSTRUMENT_VA(this, error, offset);
int64_t value = 0;
if (!m_opaque_sp.get()) {
@@ -309,8 +295,7 @@ int64_t SBData::GetSignedInt64(lldb::SBError &error, lldb::offset_t offset) {
}
const char *SBData::GetString(lldb::SBError &error, lldb::offset_t offset) {
- LLDB_RECORD_METHOD(const char *, SBData, GetString,
- (lldb::SBError &, lldb::offset_t), error, offset);
+ LLDB_INSTRUMENT_VA(this, error, offset);
const char *value = nullptr;
if (!m_opaque_sp.get()) {
@@ -326,8 +311,7 @@ const char *SBData::GetString(lldb::SBError &error, lldb::offset_t offset) {
bool SBData::GetDescription(lldb::SBStream &description,
lldb::addr_t base_addr) {
- LLDB_RECORD_METHOD(bool, SBData, GetDescription,
- (lldb::SBStream &, lldb::addr_t), description, base_addr);
+ LLDB_INSTRUMENT_VA(this, description, base_addr);
Stream &strm = description.ref();
@@ -342,9 +326,7 @@ bool SBData::GetDescription(lldb::SBStream &description,
size_t SBData::ReadRawData(lldb::SBError &error, lldb::offset_t offset,
void *buf, size_t size) {
- LLDB_RECORD_METHOD(size_t, SBData, ReadRawData,
- (lldb::SBError &, lldb::offset_t, void *, size_t), error,
- offset, buf, size);
+ LLDB_INSTRUMENT_VA(this, error, offset, buf, size);
void *ok = nullptr;
if (!m_opaque_sp.get()) {
@@ -360,10 +342,7 @@ size_t SBData::ReadRawData(lldb::SBError &error, lldb::offset_t offset,
void SBData::SetData(lldb::SBError &error, const void *buf, size_t size,
lldb::ByteOrder endian, uint8_t addr_size) {
- LLDB_RECORD_METHOD(
- void, SBData, SetData,
- (lldb::SBError &, const void *, size_t, lldb::ByteOrder, uint8_t), error,
- buf, size, endian, addr_size);
+ LLDB_INSTRUMENT_VA(this, error, buf, size, endian, addr_size);
if (!m_opaque_sp.get())
m_opaque_sp = std::make_shared<DataExtractor>(buf, size, endian, addr_size);
@@ -377,10 +356,7 @@ void SBData::SetData(lldb::SBError &error, const void *buf, size_t size,
void SBData::SetDataWithOwnership(lldb::SBError &error, const void *buf,
size_t size, lldb::ByteOrder endian,
uint8_t addr_size) {
- LLDB_RECORD_METHOD(
- void, SBData, SetData,
- (lldb::SBError &, const void *, size_t, lldb::ByteOrder, uint8_t, bool),
- error, buf, size, endian, addr_size);
+ LLDB_INSTRUMENT_VA(this, error, buf, size, endian, addr_size);
lldb::DataBufferSP buffer_sp = std::make_shared<DataBufferHeap>(buf, size);
@@ -394,7 +370,7 @@ void SBData::SetDataWithOwnership(lldb::SBError &error, const void *buf,
}
bool SBData::Append(const SBData &rhs) {
- LLDB_RECORD_METHOD(bool, SBData, Append, (const lldb::SBData &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
bool value = false;
if (m_opaque_sp.get() && rhs.m_opaque_sp.get())
@@ -405,9 +381,7 @@ bool SBData::Append(const SBData &rhs) {
lldb::SBData SBData::CreateDataFromCString(lldb::ByteOrder endian,
uint32_t addr_byte_size,
const char *data) {
- LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromCString,
- (lldb::ByteOrder, uint32_t, const char *), endian,
- addr_byte_size, data);
+ LLDB_INSTRUMENT_VA(endian, addr_byte_size, data);
if (!data || !data[0])
return SBData();
@@ -427,9 +401,7 @@ lldb::SBData SBData::CreateDataFromUInt64Array(lldb::ByteOrder endian,
uint32_t addr_byte_size,
uint64_t *array,
size_t array_len) {
- LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromUInt64Array,
- (lldb::ByteOrder, uint32_t, uint64_t *, size_t),
- endian, addr_byte_size, array, array_len);
+ LLDB_INSTRUMENT_VA(endian, addr_byte_size, array, array_len);
if (!array || array_len == 0)
return SBData();
@@ -449,9 +421,7 @@ lldb::SBData SBData::CreateDataFromUInt32Array(lldb::ByteOrder endian,
uint32_t addr_byte_size,
uint32_t *array,
size_t array_len) {
- LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromUInt32Array,
- (lldb::ByteOrder, uint32_t, uint32_t *, size_t),
- endian, addr_byte_size, array, array_len);
+ LLDB_INSTRUMENT_VA(endian, addr_byte_size, array, array_len);
if (!array || array_len == 0)
return SBData();
@@ -471,9 +441,7 @@ lldb::SBData SBData::CreateDataFromSInt64Array(lldb::ByteOrder endian,
uint32_t addr_byte_size,
int64_t *array,
size_t array_len) {
- LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromSInt64Array,
- (lldb::ByteOrder, uint32_t, int64_t *, size_t),
- endian, addr_byte_size, array, array_len);
+ LLDB_INSTRUMENT_VA(endian, addr_byte_size, array, array_len);
if (!array || array_len == 0)
return SBData();
@@ -493,9 +461,7 @@ lldb::SBData SBData::CreateDataFromSInt32Array(lldb::ByteOrder endian,
uint32_t addr_byte_size,
int32_t *array,
size_t array_len) {
- LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromSInt32Array,
- (lldb::ByteOrder, uint32_t, int32_t *, size_t),
- endian, addr_byte_size, array, array_len);
+ LLDB_INSTRUMENT_VA(endian, addr_byte_size, array, array_len);
if (!array || array_len == 0)
return SBData();
@@ -515,9 +481,7 @@ lldb::SBData SBData::CreateDataFromDoubleArray(lldb::ByteOrder endian,
uint32_t addr_byte_size,
double *array,
size_t array_len) {
- LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromDoubleArray,
- (lldb::ByteOrder, uint32_t, double *, size_t),
- endian, addr_byte_size, array, array_len);
+ LLDB_INSTRUMENT_VA(endian, addr_byte_size, array, array_len);
if (!array || array_len == 0)
return SBData();
@@ -534,8 +498,7 @@ lldb::SBData SBData::CreateDataFromDoubleArray(lldb::ByteOrder endian,
}
bool SBData::SetDataFromCString(const char *data) {
- LLDB_RECORD_METHOD(bool, SBData, SetDataFromCString, (const char *), data);
-
+ LLDB_INSTRUMENT_VA(this, data);
if (!data) {
return false;
@@ -556,9 +519,7 @@ bool SBData::SetDataFromCString(const char *data) {
}
bool SBData::SetDataFromUInt64Array(uint64_t *array, size_t array_len) {
- LLDB_RECORD_METHOD(bool, SBData, SetDataFromUInt64Array, (uint64_t *, size_t),
- array, array_len);
-
+ LLDB_INSTRUMENT_VA(this, array, array_len);
if (!array || array_len == 0) {
return false;
@@ -579,9 +540,7 @@ bool SBData::SetDataFromUInt64Array(uint64_t *array, size_t array_len) {
}
bool SBData::SetDataFromUInt32Array(uint32_t *array, size_t array_len) {
- LLDB_RECORD_METHOD(bool, SBData, SetDataFromUInt32Array, (uint32_t *, size_t),
- array, array_len);
-
+ LLDB_INSTRUMENT_VA(this, array, array_len);
if (!array || array_len == 0) {
return false;
@@ -601,9 +560,7 @@ bool SBData::SetDataFromUInt32Array(uint32_t *array, size_t array_len) {
}
bool SBData::SetDataFromSInt64Array(int64_t *array, size_t array_len) {
- LLDB_RECORD_METHOD(bool, SBData, SetDataFromSInt64Array, (int64_t *, size_t),
- array, array_len);
-
+ LLDB_INSTRUMENT_VA(this, array, array_len);
if (!array || array_len == 0) {
return false;
@@ -623,9 +580,7 @@ bool SBData::SetDataFromSInt64Array(int64_t *array, size_t array_len) {
}
bool SBData::SetDataFromSInt32Array(int32_t *array, size_t array_len) {
- LLDB_RECORD_METHOD(bool, SBData, SetDataFromSInt32Array, (int32_t *, size_t),
- array, array_len);
-
+ LLDB_INSTRUMENT_VA(this, array, array_len);
if (!array || array_len == 0) {
return false;
@@ -645,9 +600,7 @@ bool SBData::SetDataFromSInt32Array(int32_t *array, size_t array_len) {
}
bool SBData::SetDataFromDoubleArray(double *array, size_t array_len) {
- LLDB_RECORD_METHOD(bool, SBData, SetDataFromDoubleArray, (double *, size_t),
- array, array_len);
-
+ LLDB_INSTRUMENT_VA(this, array, array_len);
if (!array || array_len == 0) {
return false;
diff --git a/lldb/source/API/SBDebugger.cpp b/lldb/source/API/SBDebugger.cpp
index e8d723810fb4..8b09d6a8e435 100644
--- a/lldb/source/API/SBDebugger.cpp
+++ b/lldb/source/API/SBDebugger.cpp
@@ -6,8 +6,8 @@
//
//===----------------------------------------------------------------------===//
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "SystemInitializerFull.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/API/SBDebugger.h"
@@ -105,43 +105,34 @@ SBError SBInputReader::Initialize(
unsigned long),
void *a, lldb::InputReaderGranularity b, char const *c, char const *d,
bool e) {
- LLDB_RECORD_METHOD(
- lldb::SBError, SBInputReader, Initialize,
- (lldb::SBDebugger &,
- unsigned long (*)(void *, lldb::SBInputReader *, lldb::InputReaderAction,
- const char *, unsigned long),
- void *, lldb::InputReaderGranularity, const char *, const char *, bool),
- sb_debugger, callback, a, b, c, d, e);
+ LLDB_INSTRUMENT_VA(this, sb_debugger, callback, a, b, c, d, e);
return SBError();
}
-void SBInputReader::SetIsDone(bool b) {
- LLDB_RECORD_METHOD(void, SBInputReader, SetIsDone, (bool), b);
-}
+void SBInputReader::SetIsDone(bool b) { LLDB_INSTRUMENT_VA(this, b); }
bool SBInputReader::IsActive() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInputReader, IsActive);
+ LLDB_INSTRUMENT_VA(this);
return false;
}
-SBDebugger::SBDebugger() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBDebugger); }
+SBDebugger::SBDebugger() { LLDB_INSTRUMENT_VA(this); }
SBDebugger::SBDebugger(const lldb::DebuggerSP &debugger_sp)
: m_opaque_sp(debugger_sp) {
- LLDB_RECORD_CONSTRUCTOR(SBDebugger, (const lldb::DebuggerSP &), debugger_sp);
+ LLDB_INSTRUMENT_VA(this, debugger_sp);
}
SBDebugger::SBDebugger(const SBDebugger &rhs) : m_opaque_sp(rhs.m_opaque_sp) {
- LLDB_RECORD_CONSTRUCTOR(SBDebugger, (const lldb::SBDebugger &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
}
SBDebugger::~SBDebugger() = default;
SBDebugger &SBDebugger::operator=(const SBDebugger &rhs) {
- LLDB_RECORD_METHOD(lldb::SBDebugger &,
- SBDebugger, operator=,(const lldb::SBDebugger &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
@@ -150,8 +141,7 @@ SBDebugger &SBDebugger::operator=(const SBDebugger &rhs) {
}
const char *SBDebugger::GetBroadcasterClass() {
- LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBDebugger,
- GetBroadcasterClass);
+ LLDB_INSTRUMENT();
return Debugger::GetStaticBroadcasterClass().AsCString();
}
@@ -161,6 +151,8 @@ const char *SBDebugger::GetProgressFromEvent(const lldb::SBEvent &event,
uint64_t &completed,
uint64_t &total,
bool &is_debugger_specific) {
+ LLDB_INSTRUMENT_VA(event, progress_id, completed, total,
+ is_debugger_specific);
const Debugger::ProgressEventData *progress_data =
Debugger::ProgressEventData::GetEventDataFromEvent(event.get());
if (progress_data == nullptr)
@@ -169,29 +161,22 @@ const char *SBDebugger::GetProgressFromEvent(const lldb::SBEvent &event,
completed = progress_data->GetCompleted();
total = progress_data->GetTotal();
is_debugger_specific = progress_data->IsDebuggerSpecific();
- // We must record the static method _after_ the out parameters have been
- // filled in.
- LLDB_RECORD_STATIC_METHOD(
- const char *, SBDebugger, GetProgressFromEvent,
- (const lldb::SBEvent &, uint64_t &, uint64_t &, uint64_t &, bool &),
- event, progress_id, completed, total, is_debugger_specific);
return progress_data->GetMessage().c_str();
}
SBBroadcaster SBDebugger::GetBroadcaster() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBroadcaster, SBDebugger, GetBroadcaster);
+ LLDB_INSTRUMENT_VA(this);
SBBroadcaster broadcaster(&m_opaque_sp->GetBroadcaster(), false);
return broadcaster;
}
void SBDebugger::Initialize() {
- LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, Initialize);
+ LLDB_INSTRUMENT();
SBError ignored = SBDebugger::InitializeWithErrorHandling();
}
lldb::SBError SBDebugger::InitializeWithErrorHandling() {
- LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBError, SBDebugger,
- InitializeWithErrorHandling);
+ LLDB_INSTRUMENT();
SBError error;
if (auto e = g_debugger_lifetime->Initialize(
@@ -202,13 +187,13 @@ lldb::SBError SBDebugger::InitializeWithErrorHandling() {
}
void SBDebugger::Terminate() {
- LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, Terminate);
+ LLDB_INSTRUMENT();
g_debugger_lifetime->Terminate();
}
void SBDebugger::Clear() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, Clear);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp)
m_opaque_sp->ClearIOHandlers();
@@ -217,14 +202,13 @@ void SBDebugger::Clear() {
}
SBDebugger SBDebugger::Create() {
- LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBDebugger, SBDebugger, Create);
+ LLDB_INSTRUMENT();
return SBDebugger::Create(false, nullptr, nullptr);
}
SBDebugger SBDebugger::Create(bool source_init_files) {
- LLDB_RECORD_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, (bool),
- source_init_files);
+ LLDB_INSTRUMENT_VA(source_init_files);
return SBDebugger::Create(source_init_files, nullptr, nullptr);
}
@@ -233,9 +217,7 @@ SBDebugger SBDebugger::Create(bool source_init_files,
lldb::LogOutputCallback callback, void *baton)
{
- LLDB_RECORD_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create,
- (bool, lldb::LogOutputCallback, void *),
- source_init_files, callback, baton);
+ LLDB_INSTRUMENT_VA(source_init_files, callback, baton);
SBDebugger debugger;
@@ -263,8 +245,7 @@ SBDebugger SBDebugger::Create(bool source_init_files,
}
void SBDebugger::Destroy(SBDebugger &debugger) {
- LLDB_RECORD_STATIC_METHOD(void, SBDebugger, Destroy, (lldb::SBDebugger &),
- debugger);
+ LLDB_INSTRUMENT_VA(debugger);
Debugger::Destroy(debugger.m_opaque_sp);
@@ -273,7 +254,7 @@ void SBDebugger::Destroy(SBDebugger &debugger) {
}
void SBDebugger::MemoryPressureDetected() {
- LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, MemoryPressureDetected);
+ LLDB_INSTRUMENT();
// Since this function can be call asynchronously, we allow it to be non-
// mandatory. We have seen deadlocks with this function when called so we
@@ -286,52 +267,51 @@ void SBDebugger::MemoryPressureDetected() {
}
bool SBDebugger::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBDebugger::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp.get() != nullptr;
}
void SBDebugger::SetAsync(bool b) {
- LLDB_RECORD_METHOD(void, SBDebugger, SetAsync, (bool), b);
+ LLDB_INSTRUMENT_VA(this, b);
if (m_opaque_sp)
m_opaque_sp->SetAsyncExecution(b);
}
bool SBDebugger::GetAsync() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBDebugger, GetAsync);
+ LLDB_INSTRUMENT_VA(this);
return (m_opaque_sp ? m_opaque_sp->GetAsyncExecution() : false);
}
void SBDebugger::SkipLLDBInitFiles(bool b) {
- LLDB_RECORD_METHOD(void, SBDebugger, SkipLLDBInitFiles, (bool), b);
+ LLDB_INSTRUMENT_VA(this, b);
if (m_opaque_sp)
m_opaque_sp->GetCommandInterpreter().SkipLLDBInitFiles(b);
}
void SBDebugger::SkipAppInitFiles(bool b) {
- LLDB_RECORD_METHOD(void, SBDebugger, SkipAppInitFiles, (bool), b);
+ LLDB_INSTRUMENT_VA(this, b);
if (m_opaque_sp)
m_opaque_sp->GetCommandInterpreter().SkipAppInitFiles(b);
}
void SBDebugger::SetInputFileHandle(FILE *fh, bool transfer_ownership) {
- LLDB_RECORD_METHOD(void, SBDebugger, SetInputFileHandle, (FILE *, bool), fh,
- transfer_ownership);
+ LLDB_INSTRUMENT_VA(this, fh, transfer_ownership);
if (m_opaque_sp)
m_opaque_sp->SetInputFile(
(FileSP)std::make_shared<NativeFile>(fh, transfer_ownership));
}
SBError SBDebugger::SetInputString(const char *data) {
- LLDB_RECORD_METHOD(SBError, SBDebugger, SetInputString, (const char *), data);
+ LLDB_INSTRUMENT_VA(this, data);
SBError sb_error;
if (data == nullptr) {
sb_error.SetErrorString("String data is null");
@@ -357,7 +337,7 @@ SBError SBDebugger::SetInputString(const char *data) {
// of problems; don't want users trying to switch modes in the middle of a
// debugging session.
SBError SBDebugger::SetInputFile(SBFile file) {
- LLDB_RECORD_METHOD(SBError, SBDebugger, SetInputFile, (SBFile), file);
+ LLDB_INSTRUMENT_VA(this, file);
SBError error;
if (!m_opaque_sp) {
@@ -369,23 +349,22 @@ SBError SBDebugger::SetInputFile(SBFile file) {
}
SBError SBDebugger::SetInputFile(FileSP file_sp) {
- LLDB_RECORD_METHOD(SBError, SBDebugger, SetInputFile, (FileSP), file_sp);
+ LLDB_INSTRUMENT_VA(this, file_sp);
return SetInputFile(SBFile(file_sp));
}
SBError SBDebugger::SetOutputFile(FileSP file_sp) {
- LLDB_RECORD_METHOD(SBError, SBDebugger, SetOutputFile, (FileSP), file_sp);
+ LLDB_INSTRUMENT_VA(this, file_sp);
return SetOutputFile(SBFile(file_sp));
}
void SBDebugger::SetOutputFileHandle(FILE *fh, bool transfer_ownership) {
- LLDB_RECORD_METHOD(void, SBDebugger, SetOutputFileHandle, (FILE *, bool), fh,
- transfer_ownership);
+ LLDB_INSTRUMENT_VA(this, fh, transfer_ownership);
SetOutputFile((FileSP)std::make_shared<NativeFile>(fh, transfer_ownership));
}
SBError SBDebugger::SetOutputFile(SBFile file) {
- LLDB_RECORD_METHOD(SBError, SBDebugger, SetOutputFile, (SBFile file), file);
+ LLDB_INSTRUMENT_VA(this, file);
SBError error;
if (!m_opaque_sp) {
error.ref().SetErrorString("invalid debugger");
@@ -400,18 +379,17 @@ SBError SBDebugger::SetOutputFile(SBFile file) {
}
void SBDebugger::SetErrorFileHandle(FILE *fh, bool transfer_ownership) {
- LLDB_RECORD_METHOD(void, SBDebugger, SetErrorFileHandle, (FILE *, bool), fh,
- transfer_ownership);
+ LLDB_INSTRUMENT_VA(this, fh, transfer_ownership);
SetErrorFile((FileSP)std::make_shared<NativeFile>(fh, transfer_ownership));
}
SBError SBDebugger::SetErrorFile(FileSP file_sp) {
- LLDB_RECORD_METHOD(SBError, SBDebugger, SetErrorFile, (FileSP), file_sp);
+ LLDB_INSTRUMENT_VA(this, file_sp);
return SetErrorFile(SBFile(file_sp));
}
SBError SBDebugger::SetErrorFile(SBFile file) {
- LLDB_RECORD_METHOD(SBError, SBDebugger, SetErrorFile, (SBFile file), file);
+ LLDB_INSTRUMENT_VA(this, file);
SBError error;
if (!m_opaque_sp) {
error.ref().SetErrorString("invalid debugger");
@@ -426,7 +404,7 @@ SBError SBDebugger::SetErrorFile(SBFile file) {
}
FILE *SBDebugger::GetInputFileHandle() {
- LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetInputFileHandle);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp) {
File &file_sp = m_opaque_sp->GetInputFile();
return file_sp.GetStream();
@@ -435,7 +413,7 @@ FILE *SBDebugger::GetInputFileHandle() {
}
SBFile SBDebugger::GetInputFile() {
- LLDB_RECORD_METHOD_NO_ARGS(SBFile, SBDebugger, GetInputFile);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp) {
return SBFile(m_opaque_sp->GetInputFileSP());
}
@@ -443,7 +421,7 @@ SBFile SBDebugger::GetInputFile() {
}
FILE *SBDebugger::GetOutputFileHandle() {
- LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetOutputFileHandle);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp) {
StreamFile &stream_file = m_opaque_sp->GetOutputStream();
return stream_file.GetFile().GetStream();
@@ -452,7 +430,7 @@ FILE *SBDebugger::GetOutputFileHandle() {
}
SBFile SBDebugger::GetOutputFile() {
- LLDB_RECORD_METHOD_NO_ARGS(SBFile, SBDebugger, GetOutputFile);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp) {
SBFile file(m_opaque_sp->GetOutputStream().GetFileSP());
return file;
@@ -461,7 +439,7 @@ SBFile SBDebugger::GetOutputFile() {
}
FILE *SBDebugger::GetErrorFileHandle() {
- LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetErrorFileHandle);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp) {
StreamFile &stream_file = m_opaque_sp->GetErrorStream();
@@ -471,7 +449,7 @@ FILE *SBDebugger::GetErrorFileHandle() {
}
SBFile SBDebugger::GetErrorFile() {
- LLDB_RECORD_METHOD_NO_ARGS(SBFile, SBDebugger, GetErrorFile);
+ LLDB_INSTRUMENT_VA(this);
SBFile file;
if (m_opaque_sp) {
SBFile file(m_opaque_sp->GetErrorStream().GetFileSP());
@@ -481,21 +459,20 @@ SBFile SBDebugger::GetErrorFile() {
}
void SBDebugger::SaveInputTerminalState() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, SaveInputTerminalState);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp)
m_opaque_sp->SaveInputTerminalState();
}
void SBDebugger::RestoreInputTerminalState() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, RestoreInputTerminalState);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp)
m_opaque_sp->RestoreInputTerminalState();
}
SBCommandInterpreter SBDebugger::GetCommandInterpreter() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCommandInterpreter, SBDebugger,
- GetCommandInterpreter);
+ LLDB_INSTRUMENT_VA(this);
SBCommandInterpreter sb_interpreter;
if (m_opaque_sp)
@@ -505,7 +482,7 @@ SBCommandInterpreter SBDebugger::GetCommandInterpreter() {
}
void SBDebugger::HandleCommand(const char *command) {
- LLDB_RECORD_METHOD(void, SBDebugger, HandleCommand, (const char *), command);
+ LLDB_INSTRUMENT_VA(this, command);
if (m_opaque_sp) {
TargetSP target_sp(m_opaque_sp->GetSelectedTarget());
@@ -538,7 +515,7 @@ void SBDebugger::HandleCommand(const char *command) {
}
SBListener SBDebugger::GetListener() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBDebugger, GetListener);
+ LLDB_INSTRUMENT_VA(this);
SBListener sb_listener;
if (m_opaque_sp)
@@ -550,10 +527,7 @@ SBListener SBDebugger::GetListener() {
void SBDebugger::HandleProcessEvent(const SBProcess &process,
const SBEvent &event, SBFile out,
SBFile err) {
- LLDB_RECORD_METHOD(
- void, SBDebugger, HandleProcessEvent,
- (const lldb::SBProcess &, const lldb::SBEvent &, SBFile, SBFile), process,
- event, out, err);
+ LLDB_INSTRUMENT_VA(this, process, event, out, err);
return HandleProcessEvent(process, event, out.m_opaque_sp, err.m_opaque_sp);
}
@@ -561,10 +535,7 @@ void SBDebugger::HandleProcessEvent(const SBProcess &process,
void SBDebugger::HandleProcessEvent(const SBProcess &process,
const SBEvent &event, FILE *out,
FILE *err) {
- LLDB_RECORD_METHOD(
- void, SBDebugger, HandleProcessEvent,
- (const lldb::SBProcess &, const lldb::SBEvent &, FILE *, FILE *), process,
- event, out, err);
+ LLDB_INSTRUMENT_VA(this, process, event, out, err);
FileSP outfile = std::make_shared<NativeFile>(out, false);
FileSP errfile = std::make_shared<NativeFile>(err, false);
@@ -575,10 +546,7 @@ void SBDebugger::HandleProcessEvent(const SBProcess &process,
const SBEvent &event, FileSP out_sp,
FileSP err_sp) {
- LLDB_RECORD_METHOD(
- void, SBDebugger, HandleProcessEvent,
- (const lldb::SBProcess &, const lldb::SBEvent &, FileSP, FileSP), process,
- event, out_sp, err_sp);
+ LLDB_INSTRUMENT_VA(this, process, event, out_sp, err_sp);
if (!process.IsValid())
return;
@@ -622,16 +590,14 @@ void SBDebugger::HandleProcessEvent(const SBProcess &process,
}
SBSourceManager SBDebugger::GetSourceManager() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSourceManager, SBDebugger,
- GetSourceManager);
+ LLDB_INSTRUMENT_VA(this);
SBSourceManager sb_source_manager(*this);
return sb_source_manager;
}
bool SBDebugger::GetDefaultArchitecture(char *arch_name, size_t arch_name_len) {
- LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, GetDefaultArchitecture,
- (char *, size_t), arch_name, "", arch_name_len);
+ LLDB_INSTRUMENT_VA(arch_name, arch_name_len);
if (arch_name && arch_name_len) {
ArchSpec default_arch = Target::GetDefaultArchitecture();
@@ -652,8 +618,7 @@ bool SBDebugger::GetDefaultArchitecture(char *arch_name, size_t arch_name_len) {
}
bool SBDebugger::SetDefaultArchitecture(const char *arch_name) {
- LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, SetDefaultArchitecture,
- (const char *), arch_name);
+ LLDB_INSTRUMENT_VA(arch_name);
if (arch_name) {
ArchSpec arch(arch_name);
@@ -667,8 +632,7 @@ bool SBDebugger::SetDefaultArchitecture(const char *arch_name) {
ScriptLanguage
SBDebugger::GetScriptingLanguage(const char *script_language_name) {
- LLDB_RECORD_METHOD(lldb::ScriptLanguage, SBDebugger, GetScriptingLanguage,
- (const char *), script_language_name);
+ LLDB_INSTRUMENT_VA(this, script_language_name);
if (!script_language_name)
return eScriptLanguageDefault;
@@ -678,8 +642,7 @@ SBDebugger::GetScriptingLanguage(const char *script_language_name) {
SBStructuredData
SBDebugger::GetScriptInterpreterInfo(lldb::ScriptLanguage language) {
- LLDB_RECORD_METHOD(SBStructuredData, SBDebugger, GetScriptInterpreterInfo,
- (lldb::ScriptLanguage), language);
+ LLDB_INSTRUMENT_VA(this, language);
SBStructuredData data;
if (m_opaque_sp) {
lldb_private::ScriptInterpreter *interp =
@@ -692,14 +655,13 @@ SBDebugger::GetScriptInterpreterInfo(lldb::ScriptLanguage language) {
}
const char *SBDebugger::GetVersionString() {
- LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBDebugger, GetVersionString);
+ LLDB_INSTRUMENT();
return lldb_private::GetVersion();
}
const char *SBDebugger::StateAsCString(StateType state) {
- LLDB_RECORD_STATIC_METHOD(const char *, SBDebugger, StateAsCString,
- (lldb::StateType), state);
+ LLDB_INSTRUMENT_VA(state);
return lldb_private::StateAsCString(state);
}
@@ -725,8 +687,7 @@ static void AddLLVMTargets(StructuredData::Dictionary &dict) {
}
SBStructuredData SBDebugger::GetBuildConfiguration() {
- LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBStructuredData, SBDebugger,
- GetBuildConfiguration);
+ LLDB_INSTRUMENT();
auto config_up = std::make_unique<StructuredData::Dictionary>();
AddBoolConfigEntry(
@@ -758,8 +719,7 @@ SBStructuredData SBDebugger::GetBuildConfiguration() {
}
bool SBDebugger::StateIsRunningState(StateType state) {
- LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, StateIsRunningState,
- (lldb::StateType), state);
+ LLDB_INSTRUMENT_VA(state);
const bool result = lldb_private::StateIsRunningState(state);
@@ -767,8 +727,7 @@ bool SBDebugger::StateIsRunningState(StateType state) {
}
bool SBDebugger::StateIsStoppedState(StateType state) {
- LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, StateIsStoppedState,
- (lldb::StateType), state);
+ LLDB_INSTRUMENT_VA(state);
const bool result = lldb_private::StateIsStoppedState(state, false);
@@ -780,10 +739,8 @@ lldb::SBTarget SBDebugger::CreateTarget(const char *filename,
const char *platform_name,
bool add_dependent_modules,
lldb::SBError &sb_error) {
- LLDB_RECORD_METHOD(
- lldb::SBTarget, SBDebugger, CreateTarget,
- (const char *, const char *, const char *, bool, lldb::SBError &),
- filename, target_triple, platform_name, add_dependent_modules, sb_error);
+ LLDB_INSTRUMENT_VA(this, filename, target_triple, platform_name,
+ add_dependent_modules, sb_error);
SBTarget sb_target;
TargetSP target_sp;
@@ -818,9 +775,7 @@ lldb::SBTarget SBDebugger::CreateTarget(const char *filename,
SBTarget
SBDebugger::CreateTargetWithFileAndTargetTriple(const char *filename,
const char *target_triple) {
- LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger,
- CreateTargetWithFileAndTargetTriple,
- (const char *, const char *), filename, target_triple);
+ LLDB_INSTRUMENT_VA(this, filename, target_triple);
SBTarget sb_target;
TargetSP target_sp;
@@ -845,8 +800,7 @@ SBDebugger::CreateTargetWithFileAndTargetTriple(const char *filename,
SBTarget SBDebugger::CreateTargetWithFileAndArch(const char *filename,
const char *arch_cstr) {
- LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, CreateTargetWithFileAndArch,
- (const char *, const char *), filename, arch_cstr);
+ LLDB_INSTRUMENT_VA(this, filename, arch_cstr);
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
@@ -858,16 +812,18 @@ SBTarget SBDebugger::CreateTargetWithFileAndArch(const char *filename,
// The version of CreateTarget that takes an ArchSpec won't accept an
// empty ArchSpec, so when the arch hasn't been specified, we need to
// call the target triple version.
- error = m_opaque_sp->GetTargetList().CreateTarget(*m_opaque_sp, filename,
- arch_cstr, eLoadDependentsYes, nullptr, target_sp);
+ error = m_opaque_sp->GetTargetList().CreateTarget(
+ *m_opaque_sp, filename, arch_cstr, eLoadDependentsYes, nullptr,
+ target_sp);
} else {
- PlatformSP platform_sp = m_opaque_sp->GetPlatformList()
- .GetSelectedPlatform();
- ArchSpec arch = Platform::GetAugmentedArchSpec(platform_sp.get(),
- arch_cstr);
+ PlatformSP platform_sp =
+ m_opaque_sp->GetPlatformList().GetSelectedPlatform();
+ ArchSpec arch =
+ Platform::GetAugmentedArchSpec(platform_sp.get(), arch_cstr);
if (arch.IsValid())
- error = m_opaque_sp->GetTargetList().CreateTarget(*m_opaque_sp, filename,
- arch, eLoadDependentsYes, platform_sp, target_sp);
+ error = m_opaque_sp->GetTargetList().CreateTarget(
+ *m_opaque_sp, filename, arch, eLoadDependentsYes, platform_sp,
+ target_sp);
else
error.SetErrorStringWithFormat("invalid arch_cstr: %s", arch_cstr);
}
@@ -887,8 +843,7 @@ SBTarget SBDebugger::CreateTargetWithFileAndArch(const char *filename,
}
SBTarget SBDebugger::CreateTarget(const char *filename) {
- LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, CreateTarget, (const char *),
- filename);
+ LLDB_INSTRUMENT_VA(this, filename);
SBTarget sb_target;
TargetSP target_sp;
@@ -912,7 +867,7 @@ SBTarget SBDebugger::CreateTarget(const char *filename) {
}
SBTarget SBDebugger::GetDummyTarget() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBDebugger, GetDummyTarget);
+ LLDB_INSTRUMENT_VA(this);
SBTarget sb_target;
if (m_opaque_sp) {
@@ -926,8 +881,7 @@ SBTarget SBDebugger::GetDummyTarget() {
}
bool SBDebugger::DeleteTarget(lldb::SBTarget &target) {
- LLDB_RECORD_METHOD(bool, SBDebugger, DeleteTarget, (lldb::SBTarget &),
- target);
+ LLDB_INSTRUMENT_VA(this, target);
bool result = false;
if (m_opaque_sp) {
@@ -949,8 +903,7 @@ bool SBDebugger::DeleteTarget(lldb::SBTarget &target) {
}
SBTarget SBDebugger::GetTargetAtIndex(uint32_t idx) {
- LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, GetTargetAtIndex, (uint32_t),
- idx);
+ LLDB_INSTRUMENT_VA(this, idx);
SBTarget sb_target;
if (m_opaque_sp) {
@@ -961,8 +914,7 @@ SBTarget SBDebugger::GetTargetAtIndex(uint32_t idx) {
}
uint32_t SBDebugger::GetIndexOfTarget(lldb::SBTarget target) {
- LLDB_RECORD_METHOD(uint32_t, SBDebugger, GetIndexOfTarget, (lldb::SBTarget),
- target);
+ LLDB_INSTRUMENT_VA(this, target);
lldb::TargetSP target_sp = target.GetSP();
if (!target_sp)
@@ -975,8 +927,7 @@ uint32_t SBDebugger::GetIndexOfTarget(lldb::SBTarget target) {
}
SBTarget SBDebugger::FindTargetWithProcessID(lldb::pid_t pid) {
- LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithProcessID,
- (lldb::pid_t), pid);
+ LLDB_INSTRUMENT_VA(this, pid);
SBTarget sb_target;
if (m_opaque_sp) {
@@ -988,8 +939,7 @@ SBTarget SBDebugger::FindTargetWithProcessID(lldb::pid_t pid) {
SBTarget SBDebugger::FindTargetWithFileAndArch(const char *filename,
const char *arch_name) {
- LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithFileAndArch,
- (const char *, const char *), filename, arch_name);
+ LLDB_INSTRUMENT_VA(this, filename, arch_name);
SBTarget sb_target;
if (m_opaque_sp && filename && filename[0]) {
@@ -1015,7 +965,7 @@ SBTarget SBDebugger::FindTargetWithLLDBProcess(const ProcessSP &process_sp) {
}
uint32_t SBDebugger::GetNumTargets() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumTargets);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp) {
// No need to lock, the target list is thread safe
@@ -1025,7 +975,7 @@ uint32_t SBDebugger::GetNumTargets() {
}
SBTarget SBDebugger::GetSelectedTarget() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBDebugger, GetSelectedTarget);
+ LLDB_INSTRUMENT_VA(this);
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
@@ -1049,8 +999,7 @@ SBTarget SBDebugger::GetSelectedTarget() {
}
void SBDebugger::SetSelectedTarget(SBTarget &sb_target) {
- LLDB_RECORD_METHOD(void, SBDebugger, SetSelectedTarget, (lldb::SBTarget &),
- sb_target);
+ LLDB_INSTRUMENT_VA(this, sb_target);
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
@@ -1068,7 +1017,7 @@ void SBDebugger::SetSelectedTarget(SBTarget &sb_target) {
}
SBPlatform SBDebugger::GetSelectedPlatform() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBPlatform, SBDebugger, GetSelectedPlatform);
+ LLDB_INSTRUMENT_VA(this);
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
@@ -1085,8 +1034,7 @@ SBPlatform SBDebugger::GetSelectedPlatform() {
}
void SBDebugger::SetSelectedPlatform(SBPlatform &sb_platform) {
- LLDB_RECORD_METHOD(void, SBDebugger, SetSelectedPlatform,
- (lldb::SBPlatform &), sb_platform);
+ LLDB_INSTRUMENT_VA(this, sb_platform);
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
@@ -1102,7 +1050,7 @@ void SBDebugger::SetSelectedPlatform(SBPlatform &sb_platform) {
}
uint32_t SBDebugger::GetNumPlatforms() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumPlatforms);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp) {
// No need to lock, the platform list is thread safe
@@ -1112,8 +1060,7 @@ uint32_t SBDebugger::GetNumPlatforms() {
}
SBPlatform SBDebugger::GetPlatformAtIndex(uint32_t idx) {
- LLDB_RECORD_METHOD(lldb::SBPlatform, SBDebugger, GetPlatformAtIndex,
- (uint32_t), idx);
+ LLDB_INSTRUMENT_VA(this, idx);
SBPlatform sb_platform;
if (m_opaque_sp) {
@@ -1124,7 +1071,7 @@ SBPlatform SBDebugger::GetPlatformAtIndex(uint32_t idx) {
}
uint32_t SBDebugger::GetNumAvailablePlatforms() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumAvailablePlatforms);
+ LLDB_INSTRUMENT_VA(this);
uint32_t idx = 0;
while (true) {
@@ -1138,8 +1085,7 @@ uint32_t SBDebugger::GetNumAvailablePlatforms() {
}
SBStructuredData SBDebugger::GetAvailablePlatformInfoAtIndex(uint32_t idx) {
- LLDB_RECORD_METHOD(lldb::SBStructuredData, SBDebugger,
- GetAvailablePlatformInfoAtIndex, (uint32_t), idx);
+ LLDB_INSTRUMENT_VA(this, idx);
SBStructuredData data;
auto platform_dict = std::make_unique<StructuredData::Dictionary>();
@@ -1169,15 +1115,13 @@ SBStructuredData SBDebugger::GetAvailablePlatformInfoAtIndex(uint32_t idx) {
}
void SBDebugger::DispatchInput(void *baton, const void *data, size_t data_len) {
- LLDB_RECORD_METHOD(void, SBDebugger, DispatchInput,
- (void *, const void *, size_t), baton, data, data_len);
+ LLDB_INSTRUMENT_VA(this, baton, data, data_len);
DispatchInput(data, data_len);
}
void SBDebugger::DispatchInput(const void *data, size_t data_len) {
- LLDB_RECORD_METHOD(void, SBDebugger, DispatchInput, (const void *, size_t),
- data, data_len);
+ LLDB_INSTRUMENT_VA(this, data, data_len);
// Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
//
@@ -1194,28 +1138,26 @@ void SBDebugger::DispatchInput(const void *data, size_t data_len) {
}
void SBDebugger::DispatchInputInterrupt() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, DispatchInputInterrupt);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp)
m_opaque_sp->DispatchInputInterrupt();
}
void SBDebugger::DispatchInputEndOfFile() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, DispatchInputEndOfFile);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp)
m_opaque_sp->DispatchInputEndOfFile();
}
void SBDebugger::PushInputReader(SBInputReader &reader) {
- LLDB_RECORD_METHOD(void, SBDebugger, PushInputReader, (lldb::SBInputReader &),
- reader);
+ LLDB_INSTRUMENT_VA(this, reader);
}
void SBDebugger::RunCommandInterpreter(bool auto_handle_events,
bool spawn_thread) {
- LLDB_RECORD_METHOD(void, SBDebugger, RunCommandInterpreter, (bool, bool),
- auto_handle_events, spawn_thread);
+ LLDB_INSTRUMENT_VA(this, auto_handle_events, spawn_thread);
if (m_opaque_sp) {
CommandInterpreterRunOptions options;
@@ -1232,11 +1174,8 @@ void SBDebugger::RunCommandInterpreter(bool auto_handle_events,
bool &stopped_for_crash)
{
- LLDB_RECORD_METHOD(void, SBDebugger, RunCommandInterpreter,
- (bool, bool, lldb::SBCommandInterpreterRunOptions &, int &,
- bool &, bool &),
- auto_handle_events, spawn_thread, options, num_errors,
- quit_requested, stopped_for_crash);
+ LLDB_INSTRUMENT_VA(this, auto_handle_events, spawn_thread, options,
+ num_errors, quit_requested, stopped_for_crash);
if (m_opaque_sp) {
options.SetAutoHandleEvents(auto_handle_events);
@@ -1254,9 +1193,7 @@ void SBDebugger::RunCommandInterpreter(bool auto_handle_events,
SBCommandInterpreterRunResult SBDebugger::RunCommandInterpreter(
const SBCommandInterpreterRunOptions &options) {
- LLDB_RECORD_METHOD(lldb::SBCommandInterpreterRunResult, SBDebugger,
- RunCommandInterpreter,
- (const lldb::SBCommandInterpreterRunOptions &), options);
+ LLDB_INSTRUMENT_VA(this, options);
if (!m_opaque_sp)
return SBCommandInterpreterRunResult();
@@ -1270,9 +1207,7 @@ SBCommandInterpreterRunResult SBDebugger::RunCommandInterpreter(
SBError SBDebugger::RunREPL(lldb::LanguageType language,
const char *repl_options) {
- LLDB_RECORD_METHOD(lldb::SBError, SBDebugger, RunREPL,
- (lldb::LanguageType, const char *), language,
- repl_options);
+ LLDB_INSTRUMENT_VA(this, language, repl_options);
SBError error;
if (m_opaque_sp)
@@ -1296,8 +1231,7 @@ Debugger &SBDebugger::ref() const {
const lldb::DebuggerSP &SBDebugger::get_sp() const { return m_opaque_sp; }
SBDebugger SBDebugger::FindDebuggerWithID(int id) {
- LLDB_RECORD_STATIC_METHOD(lldb::SBDebugger, SBDebugger, FindDebuggerWithID,
- (int), id);
+ LLDB_INSTRUMENT_VA(id);
// No need to lock, the debugger list is thread safe
SBDebugger sb_debugger;
@@ -1308,16 +1242,14 @@ SBDebugger SBDebugger::FindDebuggerWithID(int id) {
}
const char *SBDebugger::GetInstanceName() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBDebugger, GetInstanceName);
+ LLDB_INSTRUMENT_VA(this);
return (m_opaque_sp ? m_opaque_sp->GetInstanceName().AsCString() : nullptr);
}
SBError SBDebugger::SetInternalVariable(const char *var_name, const char *value,
const char *debugger_instance_name) {
- LLDB_RECORD_STATIC_METHOD(lldb::SBError, SBDebugger, SetInternalVariable,
- (const char *, const char *, const char *),
- var_name, value, debugger_instance_name);
+ LLDB_INSTRUMENT_VA(var_name, value, debugger_instance_name);
SBError sb_error;
DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName(
@@ -1340,9 +1272,7 @@ SBError SBDebugger::SetInternalVariable(const char *var_name, const char *value,
SBStringList
SBDebugger::GetInternalVariableValue(const char *var_name,
const char *debugger_instance_name) {
- LLDB_RECORD_STATIC_METHOD(
- lldb::SBStringList, SBDebugger, GetInternalVariableValue,
- (const char *, const char *), var_name, debugger_instance_name);
+ LLDB_INSTRUMENT_VA(var_name, debugger_instance_name);
DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName(
ConstString(debugger_instance_name)));
@@ -1367,21 +1297,20 @@ SBDebugger::GetInternalVariableValue(const char *var_name,
}
uint32_t SBDebugger::GetTerminalWidth() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBDebugger, GetTerminalWidth);
+ LLDB_INSTRUMENT_VA(this);
return (m_opaque_sp ? m_opaque_sp->GetTerminalWidth() : 0);
}
void SBDebugger::SetTerminalWidth(uint32_t term_width) {
- LLDB_RECORD_METHOD(void, SBDebugger, SetTerminalWidth, (uint32_t),
- term_width);
+ LLDB_INSTRUMENT_VA(this, term_width);
if (m_opaque_sp)
m_opaque_sp->SetTerminalWidth(term_width);
}
const char *SBDebugger::GetPrompt() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBDebugger, GetPrompt);
+ LLDB_INSTRUMENT_VA(this);
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
@@ -1394,14 +1323,14 @@ const char *SBDebugger::GetPrompt() const {
}
void SBDebugger::SetPrompt(const char *prompt) {
- LLDB_RECORD_METHOD(void, SBDebugger, SetPrompt, (const char *), prompt);
+ LLDB_INSTRUMENT_VA(this, prompt);
if (m_opaque_sp)
m_opaque_sp->SetPrompt(llvm::StringRef(prompt));
}
const char *SBDebugger::GetReproducerPath() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBDebugger, GetReproducerPath);
+ LLDB_INSTRUMENT_VA(this);
return (m_opaque_sp
? ConstString(m_opaque_sp->GetReproducerPath()).GetCString()
@@ -1409,15 +1338,13 @@ const char *SBDebugger::GetReproducerPath() const {
}
ScriptLanguage SBDebugger::GetScriptLanguage() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ScriptLanguage, SBDebugger,
- GetScriptLanguage);
+ LLDB_INSTRUMENT_VA(this);
return (m_opaque_sp ? m_opaque_sp->GetScriptLanguage() : eScriptLanguageNone);
}
void SBDebugger::SetScriptLanguage(ScriptLanguage script_lang) {
- LLDB_RECORD_METHOD(void, SBDebugger, SetScriptLanguage,
- (lldb::ScriptLanguage), script_lang);
+ LLDB_INSTRUMENT_VA(this, script_lang);
if (m_opaque_sp) {
m_opaque_sp->SetScriptLanguage(script_lang);
@@ -1425,15 +1352,13 @@ void SBDebugger::SetScriptLanguage(ScriptLanguage script_lang) {
}
LanguageType SBDebugger::GetREPLLanguage() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::LanguageType, SBDebugger,
- GetREPLLanguage);
+ LLDB_INSTRUMENT_VA(this);
return (m_opaque_sp ? m_opaque_sp->GetREPLLanguage() : eLanguageTypeUnknown);
}
void SBDebugger::SetREPLLanguage(LanguageType repl_lang) {
- LLDB_RECORD_METHOD(void, SBDebugger, SetREPLLanguage, (lldb::LanguageType),
- repl_lang);
+ LLDB_INSTRUMENT_VA(this, repl_lang);
if (m_opaque_sp) {
m_opaque_sp->SetREPLLanguage(repl_lang);
@@ -1441,44 +1366,43 @@ void SBDebugger::SetREPLLanguage(LanguageType repl_lang) {
}
bool SBDebugger::SetUseExternalEditor(bool value) {
- LLDB_RECORD_METHOD(bool, SBDebugger, SetUseExternalEditor, (bool), value);
+ LLDB_INSTRUMENT_VA(this, value);
return (m_opaque_sp ? m_opaque_sp->SetUseExternalEditor(value) : false);
}
bool SBDebugger::GetUseExternalEditor() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBDebugger, GetUseExternalEditor);
+ LLDB_INSTRUMENT_VA(this);
return (m_opaque_sp ? m_opaque_sp->GetUseExternalEditor() : false);
}
bool SBDebugger::SetUseColor(bool value) {
- LLDB_RECORD_METHOD(bool, SBDebugger, SetUseColor, (bool), value);
+ LLDB_INSTRUMENT_VA(this, value);
return (m_opaque_sp ? m_opaque_sp->SetUseColor(value) : false);
}
bool SBDebugger::GetUseColor() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetUseColor);
+ LLDB_INSTRUMENT_VA(this);
return (m_opaque_sp ? m_opaque_sp->GetUseColor() : false);
}
bool SBDebugger::SetUseSourceCache(bool value) {
- LLDB_RECORD_METHOD(bool, SBDebugger, SetUseSourceCache, (bool), value);
+ LLDB_INSTRUMENT_VA(this, value);
return (m_opaque_sp ? m_opaque_sp->SetUseSourceCache(value) : false);
}
bool SBDebugger::GetUseSourceCache() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetUseSourceCache);
+ LLDB_INSTRUMENT_VA(this);
return (m_opaque_sp ? m_opaque_sp->GetUseSourceCache() : false);
}
bool SBDebugger::GetDescription(SBStream &description) {
- LLDB_RECORD_METHOD(bool, SBDebugger, GetDescription, (lldb::SBStream &),
- description);
+ LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();
@@ -1493,14 +1417,13 @@ bool SBDebugger::GetDescription(SBStream &description) {
}
user_id_t SBDebugger::GetID() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::user_id_t, SBDebugger, GetID);
+ LLDB_INSTRUMENT_VA(this);
return (m_opaque_sp ? m_opaque_sp->GetID() : LLDB_INVALID_UID);
}
SBError SBDebugger::SetCurrentPlatform(const char *platform_name_cstr) {
- LLDB_RECORD_METHOD(lldb::SBError, SBDebugger, SetCurrentPlatform,
- (const char *), platform_name_cstr);
+ LLDB_INSTRUMENT_VA(this, platform_name_cstr);
SBError sb_error;
if (m_opaque_sp) {
@@ -1530,8 +1453,7 @@ SBError SBDebugger::SetCurrentPlatform(const char *platform_name_cstr) {
}
bool SBDebugger::SetCurrentPlatformSDKRoot(const char *sysroot) {
- LLDB_RECORD_METHOD(bool, SBDebugger, SetCurrentPlatformSDKRoot,
- (const char *), sysroot);
+ LLDB_INSTRUMENT_VA(this, sysroot);
if (SBPlatform platform = GetSelectedPlatform()) {
platform.SetSDKRoot(sysroot);
@@ -1541,21 +1463,20 @@ bool SBDebugger::SetCurrentPlatformSDKRoot(const char *sysroot) {
}
bool SBDebugger::GetCloseInputOnEOF() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetCloseInputOnEOF);
+ LLDB_INSTRUMENT_VA(this);
return (m_opaque_sp ? m_opaque_sp->GetCloseInputOnEOF() : false);
}
void SBDebugger::SetCloseInputOnEOF(bool b) {
- LLDB_RECORD_METHOD(void, SBDebugger, SetCloseInputOnEOF, (bool), b);
+ LLDB_INSTRUMENT_VA(this, b);
if (m_opaque_sp)
m_opaque_sp->SetCloseInputOnEOF(b);
}
SBTypeCategory SBDebugger::GetCategory(const char *category_name) {
- LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory,
- (const char *), category_name);
+ LLDB_INSTRUMENT_VA(this, category_name);
if (!category_name || *category_name == 0)
return SBTypeCategory();
@@ -1571,8 +1492,7 @@ SBTypeCategory SBDebugger::GetCategory(const char *category_name) {
}
SBTypeCategory SBDebugger::GetCategory(lldb::LanguageType lang_type) {
- LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory,
- (lldb::LanguageType), lang_type);
+ LLDB_INSTRUMENT_VA(this, lang_type);
TypeCategoryImplSP category_sp;
if (DataVisualization::Categories::GetCategory(lang_type, category_sp)) {
@@ -1583,8 +1503,7 @@ SBTypeCategory SBDebugger::GetCategory(lldb::LanguageType lang_type) {
}
SBTypeCategory SBDebugger::CreateCategory(const char *category_name) {
- LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, CreateCategory,
- (const char *), category_name);
+ LLDB_INSTRUMENT_VA(this, category_name);
if (!category_name || *category_name == 0)
return SBTypeCategory();
@@ -1600,8 +1519,7 @@ SBTypeCategory SBDebugger::CreateCategory(const char *category_name) {
}
bool SBDebugger::DeleteCategory(const char *category_name) {
- LLDB_RECORD_METHOD(bool, SBDebugger, DeleteCategory, (const char *),
- category_name);
+ LLDB_INSTRUMENT_VA(this, category_name);
if (!category_name || *category_name == 0)
return false;
@@ -1610,29 +1528,26 @@ bool SBDebugger::DeleteCategory(const char *category_name) {
}
uint32_t SBDebugger::GetNumCategories() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumCategories);
+ LLDB_INSTRUMENT_VA(this);
return DataVisualization::Categories::GetCount();
}
SBTypeCategory SBDebugger::GetCategoryAtIndex(uint32_t index) {
- LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategoryAtIndex,
- (uint32_t), index);
+ LLDB_INSTRUMENT_VA(this, index);
return SBTypeCategory(
DataVisualization::Categories::GetCategoryAtIndex(index));
}
SBTypeCategory SBDebugger::GetDefaultCategory() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeCategory, SBDebugger,
- GetDefaultCategory);
+ LLDB_INSTRUMENT_VA(this);
return GetCategory("default");
}
SBTypeFormat SBDebugger::GetFormatForType(SBTypeNameSpecifier type_name) {
- LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBDebugger, GetFormatForType,
- (lldb::SBTypeNameSpecifier), type_name);
+ LLDB_INSTRUMENT_VA(this, type_name);
SBTypeCategory default_category_sb = GetDefaultCategory();
if (default_category_sb.GetEnabled())
@@ -1641,8 +1556,7 @@ SBTypeFormat SBDebugger::GetFormatForType(SBTypeNameSpecifier type_name) {
}
SBTypeSummary SBDebugger::GetSummaryForType(SBTypeNameSpecifier type_name) {
- LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBDebugger, GetSummaryForType,
- (lldb::SBTypeNameSpecifier), type_name);
+ LLDB_INSTRUMENT_VA(this, type_name);
if (!type_name.IsValid())
return SBTypeSummary();
@@ -1650,8 +1564,7 @@ SBTypeSummary SBDebugger::GetSummaryForType(SBTypeNameSpecifier type_name) {
}
SBTypeFilter SBDebugger::GetFilterForType(SBTypeNameSpecifier type_name) {
- LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBDebugger, GetFilterForType,
- (lldb::SBTypeNameSpecifier), type_name);
+ LLDB_INSTRUMENT_VA(this, type_name);
if (!type_name.IsValid())
return SBTypeFilter();
@@ -1659,8 +1572,7 @@ SBTypeFilter SBDebugger::GetFilterForType(SBTypeNameSpecifier type_name) {
}
SBTypeSynthetic SBDebugger::GetSyntheticForType(SBTypeNameSpecifier type_name) {
- LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBDebugger, GetSyntheticForType,
- (lldb::SBTypeNameSpecifier), type_name);
+ LLDB_INSTRUMENT_VA(this, type_name);
if (!type_name.IsValid())
return SBTypeSynthetic();
@@ -1678,8 +1590,7 @@ static llvm::ArrayRef<const char *> GetCategoryArray(const char **categories) {
}
bool SBDebugger::EnableLog(const char *channel, const char **categories) {
- LLDB_RECORD_METHOD(bool, SBDebugger, EnableLog, (const char *, const char **),
- channel, categories);
+ LLDB_INSTRUMENT_VA(this, channel, categories);
if (m_opaque_sp) {
uint32_t log_options =
@@ -1694,8 +1605,7 @@ bool SBDebugger::EnableLog(const char *channel, const char **categories) {
void SBDebugger::SetLoggingCallback(lldb::LogOutputCallback log_callback,
void *baton) {
- LLDB_RECORD_METHOD(void, SBDebugger, SetLoggingCallback,
- (lldb::LogOutputCallback, void *), log_callback, baton);
+ LLDB_INSTRUMENT_VA(this, log_callback, baton);
if (m_opaque_sp) {
return m_opaque_sp->SetLoggingCallback(log_callback, baton);
diff --git a/lldb/source/API/SBDeclaration.cpp b/lldb/source/API/SBDeclaration.cpp
index f0273b081bb8..5b7def09b5cc 100644
--- a/lldb/source/API/SBDeclaration.cpp
+++ b/lldb/source/API/SBDeclaration.cpp
@@ -7,11 +7,11 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBDeclaration.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/API/SBStream.h"
#include "lldb/Core/Declaration.h"
#include "lldb/Host/PosixApi.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/Stream.h"
#include <climits>
@@ -19,12 +19,10 @@
using namespace lldb;
using namespace lldb_private;
-SBDeclaration::SBDeclaration() {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBDeclaration);
-}
+SBDeclaration::SBDeclaration() { LLDB_INSTRUMENT_VA(this); }
SBDeclaration::SBDeclaration(const SBDeclaration &rhs) {
- LLDB_RECORD_CONSTRUCTOR(SBDeclaration, (const lldb::SBDeclaration &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_up = clone(rhs.m_opaque_up);
}
@@ -35,9 +33,7 @@ SBDeclaration::SBDeclaration(const lldb_private::Declaration *lldb_object_ptr) {
}
const SBDeclaration &SBDeclaration::operator=(const SBDeclaration &rhs) {
- LLDB_RECORD_METHOD(const lldb::SBDeclaration &,
- SBDeclaration, operator=,(const lldb::SBDeclaration &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
@@ -52,19 +48,17 @@ void SBDeclaration::SetDeclaration(
SBDeclaration::~SBDeclaration() = default;
bool SBDeclaration::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDeclaration, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBDeclaration::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDeclaration, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up.get() && m_opaque_up->IsValid();
}
SBFileSpec SBDeclaration::GetFileSpec() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBDeclaration,
- GetFileSpec);
-
+ LLDB_INSTRUMENT_VA(this);
SBFileSpec sb_file_spec;
if (m_opaque_up.get() && m_opaque_up->GetFile())
@@ -74,8 +68,7 @@ SBFileSpec SBDeclaration::GetFileSpec() const {
}
uint32_t SBDeclaration::GetLine() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBDeclaration, GetLine);
-
+ LLDB_INSTRUMENT_VA(this);
uint32_t line = 0;
if (m_opaque_up)
@@ -86,7 +79,7 @@ uint32_t SBDeclaration::GetLine() const {
}
uint32_t SBDeclaration::GetColumn() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBDeclaration, GetColumn);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_up)
return m_opaque_up->GetColumn();
@@ -94,8 +87,7 @@ uint32_t SBDeclaration::GetColumn() const {
}
void SBDeclaration::SetFileSpec(lldb::SBFileSpec filespec) {
- LLDB_RECORD_METHOD(void, SBDeclaration, SetFileSpec, (lldb::SBFileSpec),
- filespec);
+ LLDB_INSTRUMENT_VA(this, filespec);
if (filespec.IsValid())
ref().SetFile(filespec.ref());
@@ -103,20 +95,19 @@ void SBDeclaration::SetFileSpec(lldb::SBFileSpec filespec) {
ref().SetFile(FileSpec());
}
void SBDeclaration::SetLine(uint32_t line) {
- LLDB_RECORD_METHOD(void, SBDeclaration, SetLine, (uint32_t), line);
+ LLDB_INSTRUMENT_VA(this, line);
ref().SetLine(line);
}
void SBDeclaration::SetColumn(uint32_t column) {
- LLDB_RECORD_METHOD(void, SBDeclaration, SetColumn, (uint32_t), column);
+ LLDB_INSTRUMENT_VA(this, column);
ref().SetColumn(column);
}
bool SBDeclaration::operator==(const SBDeclaration &rhs) const {
- LLDB_RECORD_METHOD_CONST(
- bool, SBDeclaration, operator==,(const lldb::SBDeclaration &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
lldb_private::Declaration *lhs_ptr = m_opaque_up.get();
lldb_private::Declaration *rhs_ptr = rhs.m_opaque_up.get();
@@ -128,8 +119,7 @@ bool SBDeclaration::operator==(const SBDeclaration &rhs) const {
}
bool SBDeclaration::operator!=(const SBDeclaration &rhs) const {
- LLDB_RECORD_METHOD_CONST(
- bool, SBDeclaration, operator!=,(const lldb::SBDeclaration &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
lldb_private::Declaration *lhs_ptr = m_opaque_up.get();
lldb_private::Declaration *rhs_ptr = rhs.m_opaque_up.get();
@@ -155,8 +145,7 @@ const lldb_private::Declaration &SBDeclaration::ref() const {
}
bool SBDeclaration::GetDescription(SBStream &description) {
- LLDB_RECORD_METHOD(bool, SBDeclaration, GetDescription, (lldb::SBStream &),
- description);
+ LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();
diff --git a/lldb/source/API/SBEnvironment.cpp b/lldb/source/API/SBEnvironment.cpp
index d1df3ad12345..5fafabe02e01 100644
--- a/lldb/source/API/SBEnvironment.cpp
+++ b/lldb/source/API/SBEnvironment.cpp
@@ -7,22 +7,22 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBEnvironment.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/API/SBStringList.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Environment.h"
+#include "lldb/Utility/Instrumentation.h"
using namespace lldb;
using namespace lldb_private;
SBEnvironment::SBEnvironment() : m_opaque_up(new Environment()) {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBEnvironment);
+ LLDB_INSTRUMENT_VA(this);
}
SBEnvironment::SBEnvironment(const SBEnvironment &rhs)
: m_opaque_up(clone(rhs.m_opaque_up)) {
- LLDB_RECORD_CONSTRUCTOR(SBEnvironment, (const lldb::SBEnvironment &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
}
SBEnvironment::SBEnvironment(Environment rhs)
@@ -31,9 +31,7 @@ SBEnvironment::SBEnvironment(Environment rhs)
SBEnvironment::~SBEnvironment() = default;
const SBEnvironment &SBEnvironment::operator=(const SBEnvironment &rhs) {
- LLDB_RECORD_METHOD(const lldb::SBEnvironment &,
- SBEnvironment, operator=,(const lldb::SBEnvironment &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
@@ -41,13 +39,13 @@ const SBEnvironment &SBEnvironment::operator=(const SBEnvironment &rhs) {
}
size_t SBEnvironment::GetNumValues() {
- LLDB_RECORD_METHOD_NO_ARGS(size_t, SBEnvironment, GetNumValues);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->size();
}
const char *SBEnvironment::Get(const char *name) {
- LLDB_RECORD_METHOD(const char *, SBEnvironment, Get, (const char *), name);
+ LLDB_INSTRUMENT_VA(this, name);
auto entry = m_opaque_up->find(name);
if (entry == m_opaque_up->end()) {
@@ -57,8 +55,7 @@ const char *SBEnvironment::Get(const char *name) {
}
const char *SBEnvironment::GetNameAtIndex(size_t index) {
- LLDB_RECORD_METHOD(const char *, SBEnvironment, GetNameAtIndex, (size_t),
- index);
+ LLDB_INSTRUMENT_VA(this, index);
if (index >= GetNumValues())
return nullptr;
@@ -67,8 +64,7 @@ const char *SBEnvironment::GetNameAtIndex(size_t index) {
}
const char *SBEnvironment::GetValueAtIndex(size_t index) {
- LLDB_RECORD_METHOD(const char *, SBEnvironment, GetValueAtIndex, (size_t),
- index);
+ LLDB_INSTRUMENT_VA(this, index);
if (index >= GetNumValues())
return nullptr;
@@ -77,9 +73,7 @@ const char *SBEnvironment::GetValueAtIndex(size_t index) {
}
bool SBEnvironment::Set(const char *name, const char *value, bool overwrite) {
- LLDB_RECORD_METHOD(bool, SBEnvironment, Set,
- (const char *, const char *, bool), name, value,
- overwrite);
+ LLDB_INSTRUMENT_VA(this, name, value, overwrite);
if (overwrite) {
m_opaque_up->insert_or_assign(name, std::string(value));
@@ -89,13 +83,13 @@ bool SBEnvironment::Set(const char *name, const char *value, bool overwrite) {
}
bool SBEnvironment::Unset(const char *name) {
- LLDB_RECORD_METHOD(bool, SBEnvironment, Unset, (const char *), name);
+ LLDB_INSTRUMENT_VA(this, name);
return m_opaque_up->erase(name);
}
SBStringList SBEnvironment::GetEntries() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStringList, SBEnvironment, GetEntries);
+ LLDB_INSTRUMENT_VA(this);
SBStringList entries;
for (const auto &KV : *m_opaque_up) {
@@ -105,16 +99,14 @@ SBStringList SBEnvironment::GetEntries() {
}
void SBEnvironment::PutEntry(const char *name_and_value) {
- LLDB_RECORD_METHOD(void, SBEnvironment, PutEntry, (const char *),
- name_and_value);
+ LLDB_INSTRUMENT_VA(this, name_and_value);
auto split = llvm::StringRef(name_and_value).split('=');
m_opaque_up->insert_or_assign(split.first.str(), split.second.str());
}
void SBEnvironment::SetEntries(const SBStringList &entries, bool append) {
- LLDB_RECORD_METHOD(void, SBEnvironment, SetEntries,
- (const lldb::SBStringList &, bool), entries, append);
+ LLDB_INSTRUMENT_VA(this, entries, append);
if (!append)
m_opaque_up->clear();
@@ -124,7 +116,7 @@ void SBEnvironment::SetEntries(const SBStringList &entries, bool append) {
}
void SBEnvironment::Clear() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBEnvironment, Clear);
+ LLDB_INSTRUMENT_VA(this);
m_opaque_up->clear();
}
diff --git a/lldb/source/API/SBError.cpp b/lldb/source/API/SBError.cpp
index 793ebb7df5eb..ef4f7266f083 100644
--- a/lldb/source/API/SBError.cpp
+++ b/lldb/source/API/SBError.cpp
@@ -7,9 +7,9 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBError.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/API/SBStream.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/Status.h"
#include <cstdarg>
@@ -17,10 +17,10 @@
using namespace lldb;
using namespace lldb_private;
-SBError::SBError() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBError); }
+SBError::SBError() { LLDB_INSTRUMENT_VA(this); }
SBError::SBError(const SBError &rhs) {
- LLDB_RECORD_CONSTRUCTOR(SBError, (const lldb::SBError &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_up = clone(rhs.m_opaque_up);
}
@@ -28,8 +28,7 @@ SBError::SBError(const SBError &rhs) {
SBError::~SBError() = default;
const SBError &SBError::operator=(const SBError &rhs) {
- LLDB_RECORD_METHOD(const lldb::SBError &,
- SBError, operator=,(const lldb::SBError &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
@@ -37,7 +36,7 @@ const SBError &SBError::operator=(const SBError &rhs) {
}
const char *SBError::GetCString() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBError, GetCString);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_up)
return m_opaque_up->AsCString();
@@ -45,14 +44,14 @@ const char *SBError::GetCString() const {
}
void SBError::Clear() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBError, Clear);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_up)
m_opaque_up->Clear();
}
bool SBError::Fail() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, Fail);
+ LLDB_INSTRUMENT_VA(this);
bool ret_value = false;
if (m_opaque_up)
@@ -63,7 +62,7 @@ bool SBError::Fail() const {
}
bool SBError::Success() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, Success);
+ LLDB_INSTRUMENT_VA(this);
bool ret_value = true;
if (m_opaque_up)
@@ -73,8 +72,7 @@ bool SBError::Success() const {
}
uint32_t SBError::GetError() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBError, GetError);
-
+ LLDB_INSTRUMENT_VA(this);
uint32_t err = 0;
if (m_opaque_up)
@@ -85,7 +83,7 @@ uint32_t SBError::GetError() const {
}
ErrorType SBError::GetType() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ErrorType, SBError, GetType);
+ LLDB_INSTRUMENT_VA(this);
ErrorType err_type = eErrorTypeInvalid;
if (m_opaque_up)
@@ -95,8 +93,7 @@ ErrorType SBError::GetType() const {
}
void SBError::SetError(uint32_t err, ErrorType type) {
- LLDB_RECORD_METHOD(void, SBError, SetError, (uint32_t, lldb::ErrorType), err,
- type);
+ LLDB_INSTRUMENT_VA(this, err, type);
CreateIfNeeded();
m_opaque_up->SetError(err, type);
@@ -108,21 +105,21 @@ void SBError::SetError(const Status &lldb_error) {
}
void SBError::SetErrorToErrno() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBError, SetErrorToErrno);
+ LLDB_INSTRUMENT_VA(this);
CreateIfNeeded();
m_opaque_up->SetErrorToErrno();
}
void SBError::SetErrorToGenericError() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBError, SetErrorToGenericError);
+ LLDB_INSTRUMENT_VA(this);
CreateIfNeeded();
m_opaque_up->SetErrorToGenericError();
}
void SBError::SetErrorString(const char *err_str) {
- LLDB_RECORD_METHOD(void, SBError, SetErrorString, (const char *), err_str);
+ LLDB_INSTRUMENT_VA(this, err_str);
CreateIfNeeded();
m_opaque_up->SetErrorString(err_str);
@@ -138,11 +135,11 @@ int SBError::SetErrorStringWithFormat(const char *format, ...) {
}
bool SBError::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBError::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up != nullptr;
}
@@ -167,8 +164,7 @@ const lldb_private::Status &SBError::operator*() const {
}
bool SBError::GetDescription(SBStream &description) {
- LLDB_RECORD_METHOD(bool, SBError, GetDescription, (lldb::SBStream &),
- description);
+ LLDB_INSTRUMENT_VA(this, description);
if (m_opaque_up) {
if (m_opaque_up->Success())
diff --git a/lldb/source/API/SBEvent.cpp b/lldb/source/API/SBEvent.cpp
index 710ef2cf8118..536680bd1c5e 100644
--- a/lldb/source/API/SBEvent.cpp
+++ b/lldb/source/API/SBEvent.cpp
@@ -7,9 +7,9 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBEvent.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBBroadcaster.h"
#include "lldb/API/SBStream.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/Breakpoint/Breakpoint.h"
#include "lldb/Core/StreamFile.h"
@@ -22,32 +22,30 @@
using namespace lldb;
using namespace lldb_private;
-SBEvent::SBEvent() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBEvent); }
+SBEvent::SBEvent() { LLDB_INSTRUMENT_VA(this); }
SBEvent::SBEvent(uint32_t event_type, const char *cstr, uint32_t cstr_len)
: m_event_sp(new Event(event_type, new EventDataBytes(cstr, cstr_len))),
m_opaque_ptr(m_event_sp.get()) {
- LLDB_RECORD_CONSTRUCTOR(SBEvent, (uint32_t, const char *, uint32_t),
- event_type, cstr, cstr_len);
+ LLDB_INSTRUMENT_VA(this, event_type, cstr, cstr_len);
}
SBEvent::SBEvent(EventSP &event_sp)
: m_event_sp(event_sp), m_opaque_ptr(event_sp.get()) {
- LLDB_RECORD_CONSTRUCTOR(SBEvent, (lldb::EventSP &), event_sp);
+ LLDB_INSTRUMENT_VA(this, event_sp);
}
SBEvent::SBEvent(Event *event_ptr) : m_opaque_ptr(event_ptr) {
- LLDB_RECORD_CONSTRUCTOR(SBEvent, (lldb_private::Event *), event_ptr);
+ LLDB_INSTRUMENT_VA(this, event_ptr);
}
SBEvent::SBEvent(const SBEvent &rhs)
: m_event_sp(rhs.m_event_sp), m_opaque_ptr(rhs.m_opaque_ptr) {
- LLDB_RECORD_CONSTRUCTOR(SBEvent, (const lldb::SBEvent &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
}
const SBEvent &SBEvent::operator=(const SBEvent &rhs) {
- LLDB_RECORD_METHOD(const lldb::SBEvent &,
- SBEvent, operator=,(const lldb::SBEvent &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
m_event_sp = rhs.m_event_sp;
@@ -59,7 +57,7 @@ const SBEvent &SBEvent::operator=(const SBEvent &rhs) {
SBEvent::~SBEvent() = default;
const char *SBEvent::GetDataFlavor() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBEvent, GetDataFlavor);
+ LLDB_INSTRUMENT_VA(this);
Event *lldb_event = get();
if (lldb_event) {
@@ -71,8 +69,7 @@ const char *SBEvent::GetDataFlavor() {
}
uint32_t SBEvent::GetType() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBEvent, GetType);
-
+ LLDB_INSTRUMENT_VA(this);
const Event *lldb_event = get();
uint32_t event_type = 0;
@@ -84,8 +81,7 @@ uint32_t SBEvent::GetType() const {
}
SBBroadcaster SBEvent::GetBroadcaster() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBEvent,
- GetBroadcaster);
+ LLDB_INSTRUMENT_VA(this);
SBBroadcaster broadcaster;
const Event *lldb_event = get();
@@ -95,7 +91,7 @@ SBBroadcaster SBEvent::GetBroadcaster() const {
}
const char *SBEvent::GetBroadcasterClass() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBEvent, GetBroadcasterClass);
+ LLDB_INSTRUMENT_VA(this);
const Event *lldb_event = get();
if (lldb_event)
@@ -105,8 +101,7 @@ const char *SBEvent::GetBroadcasterClass() const {
}
bool SBEvent::BroadcasterMatchesPtr(const SBBroadcaster *broadcaster) {
- LLDB_RECORD_METHOD(bool, SBEvent, BroadcasterMatchesPtr,
- (const lldb::SBBroadcaster *), broadcaster);
+ LLDB_INSTRUMENT_VA(this, broadcaster);
if (broadcaster)
return BroadcasterMatchesRef(*broadcaster);
@@ -114,8 +109,7 @@ bool SBEvent::BroadcasterMatchesPtr(const SBBroadcaster *broadcaster) {
}
bool SBEvent::BroadcasterMatchesRef(const SBBroadcaster &broadcaster) {
- LLDB_RECORD_METHOD(bool, SBEvent, BroadcasterMatchesRef,
- (const lldb::SBBroadcaster &), broadcaster);
+ LLDB_INSTRUMENT_VA(this, broadcaster);
Event *lldb_event = get();
bool success = false;
@@ -127,7 +121,7 @@ bool SBEvent::BroadcasterMatchesRef(const SBBroadcaster &broadcaster) {
}
void SBEvent::Clear() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBEvent, Clear);
+ LLDB_INSTRUMENT_VA(this);
Event *lldb_event = get();
if (lldb_event)
@@ -158,11 +152,11 @@ void SBEvent::reset(Event *event_ptr) {
}
bool SBEvent::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBEvent, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBEvent::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBEvent, operator bool);
+ LLDB_INSTRUMENT_VA(this);
// Do NOT use m_opaque_ptr directly!!! Must use the SBEvent::get() accessor.
// See comments in SBEvent::get()....
@@ -170,16 +164,14 @@ SBEvent::operator bool() const {
}
const char *SBEvent::GetCStringFromEvent(const SBEvent &event) {
- LLDB_RECORD_STATIC_METHOD(const char *, SBEvent, GetCStringFromEvent,
- (const lldb::SBEvent &), event);
+ LLDB_INSTRUMENT_VA(event);
return static_cast<const char *>(
EventDataBytes::GetBytesFromEvent(event.get()));
}
bool SBEvent::GetDescription(SBStream &description) {
- LLDB_RECORD_METHOD(bool, SBEvent, GetDescription, (lldb::SBStream &),
- description);
+ LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();
@@ -192,8 +184,7 @@ bool SBEvent::GetDescription(SBStream &description) {
}
bool SBEvent::GetDescription(SBStream &description) const {
- LLDB_RECORD_METHOD_CONST(bool, SBEvent, GetDescription, (lldb::SBStream &),
- description);
+ LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();
diff --git a/lldb/source/API/SBExecutionContext.cpp b/lldb/source/API/SBExecutionContext.cpp
index 1f53e84ac6e6..a0b68e6efe38 100644
--- a/lldb/source/API/SBExecutionContext.cpp
+++ b/lldb/source/API/SBExecutionContext.cpp
@@ -7,7 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBExecutionContext.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/API/SBFrame.h"
#include "lldb/API/SBProcess.h"
@@ -19,48 +19,43 @@
using namespace lldb;
using namespace lldb_private;
-SBExecutionContext::SBExecutionContext() {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBExecutionContext);
-}
+SBExecutionContext::SBExecutionContext() { LLDB_INSTRUMENT_VA(this); }
SBExecutionContext::SBExecutionContext(const lldb::SBExecutionContext &rhs)
: m_exe_ctx_sp(rhs.m_exe_ctx_sp) {
- LLDB_RECORD_CONSTRUCTOR(SBExecutionContext,
- (const lldb::SBExecutionContext &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
}
SBExecutionContext::SBExecutionContext(
lldb::ExecutionContextRefSP exe_ctx_ref_sp)
: m_exe_ctx_sp(exe_ctx_ref_sp) {
- LLDB_RECORD_CONSTRUCTOR(SBExecutionContext, (lldb::ExecutionContextRefSP),
- exe_ctx_ref_sp);
+ LLDB_INSTRUMENT_VA(this, exe_ctx_ref_sp);
}
SBExecutionContext::SBExecutionContext(const lldb::SBTarget &target)
: m_exe_ctx_sp(new ExecutionContextRef()) {
- LLDB_RECORD_CONSTRUCTOR(SBExecutionContext, (const lldb::SBTarget &), target);
+ LLDB_INSTRUMENT_VA(this, target);
m_exe_ctx_sp->SetTargetSP(target.GetSP());
}
SBExecutionContext::SBExecutionContext(const lldb::SBProcess &process)
: m_exe_ctx_sp(new ExecutionContextRef()) {
- LLDB_RECORD_CONSTRUCTOR(SBExecutionContext, (const lldb::SBProcess &),
- process);
+ LLDB_INSTRUMENT_VA(this, process);
m_exe_ctx_sp->SetProcessSP(process.GetSP());
}
SBExecutionContext::SBExecutionContext(lldb::SBThread thread)
: m_exe_ctx_sp(new ExecutionContextRef()) {
- LLDB_RECORD_CONSTRUCTOR(SBExecutionContext, (lldb::SBThread), thread);
+ LLDB_INSTRUMENT_VA(this, thread);
m_exe_ctx_sp->SetThreadPtr(thread.get());
}
SBExecutionContext::SBExecutionContext(const lldb::SBFrame &frame)
: m_exe_ctx_sp(new ExecutionContextRef()) {
- LLDB_RECORD_CONSTRUCTOR(SBExecutionContext, (const lldb::SBFrame &), frame);
+ LLDB_INSTRUMENT_VA(this, frame);
m_exe_ctx_sp->SetFrameSP(frame.GetFrameSP());
}
@@ -69,9 +64,7 @@ SBExecutionContext::~SBExecutionContext() = default;
const SBExecutionContext &SBExecutionContext::
operator=(const lldb::SBExecutionContext &rhs) {
- LLDB_RECORD_METHOD(
- const lldb::SBExecutionContext &,
- SBExecutionContext, operator=,(const lldb::SBExecutionContext &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
m_exe_ctx_sp = rhs.m_exe_ctx_sp;
return *this;
@@ -82,8 +75,7 @@ ExecutionContextRef *SBExecutionContext::get() const {
}
SBTarget SBExecutionContext::GetTarget() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBTarget, SBExecutionContext,
- GetTarget);
+ LLDB_INSTRUMENT_VA(this);
SBTarget sb_target;
if (m_exe_ctx_sp) {
@@ -95,8 +87,7 @@ SBTarget SBExecutionContext::GetTarget() const {
}
SBProcess SBExecutionContext::GetProcess() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBProcess, SBExecutionContext,
- GetProcess);
+ LLDB_INSTRUMENT_VA(this);
SBProcess sb_process;
if (m_exe_ctx_sp) {
@@ -108,8 +99,7 @@ SBProcess SBExecutionContext::GetProcess() const {
}
SBThread SBExecutionContext::GetThread() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBExecutionContext,
- GetThread);
+ LLDB_INSTRUMENT_VA(this);
SBThread sb_thread;
if (m_exe_ctx_sp) {
@@ -121,7 +111,7 @@ SBThread SBExecutionContext::GetThread() const {
}
SBFrame SBExecutionContext::GetFrame() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFrame, SBExecutionContext, GetFrame);
+ LLDB_INSTRUMENT_VA(this);
SBFrame sb_frame;
if (m_exe_ctx_sp) {
diff --git a/lldb/source/API/SBExpressionOptions.cpp b/lldb/source/API/SBExpressionOptions.cpp
index 6dfff7ee4603..191e38fe5cfc 100644
--- a/lldb/source/API/SBExpressionOptions.cpp
+++ b/lldb/source/API/SBExpressionOptions.cpp
@@ -7,31 +7,28 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBExpressionOptions.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/API/SBStream.h"
#include "lldb/Target/Target.h"
+#include "lldb/Utility/Instrumentation.h"
using namespace lldb;
using namespace lldb_private;
SBExpressionOptions::SBExpressionOptions()
: m_opaque_up(new EvaluateExpressionOptions()) {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBExpressionOptions);
+ LLDB_INSTRUMENT_VA(this);
}
SBExpressionOptions::SBExpressionOptions(const SBExpressionOptions &rhs) {
- LLDB_RECORD_CONSTRUCTOR(SBExpressionOptions,
- (const lldb::SBExpressionOptions &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_up = clone(rhs.m_opaque_up);
}
const SBExpressionOptions &SBExpressionOptions::
operator=(const SBExpressionOptions &rhs) {
- LLDB_RECORD_METHOD(
- const lldb::SBExpressionOptions &,
- SBExpressionOptions, operator=,(const lldb::SBExpressionOptions &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
@@ -41,78 +38,68 @@ operator=(const SBExpressionOptions &rhs) {
SBExpressionOptions::~SBExpressionOptions() = default;
bool SBExpressionOptions::GetCoerceResultToId() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions,
- GetCoerceResultToId);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->DoesCoerceToId();
}
void SBExpressionOptions::SetCoerceResultToId(bool coerce) {
- LLDB_RECORD_METHOD(void, SBExpressionOptions, SetCoerceResultToId, (bool),
- coerce);
+ LLDB_INSTRUMENT_VA(this, coerce);
m_opaque_up->SetCoerceToId(coerce);
}
bool SBExpressionOptions::GetUnwindOnError() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, GetUnwindOnError);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->DoesUnwindOnError();
}
void SBExpressionOptions::SetUnwindOnError(bool unwind) {
- LLDB_RECORD_METHOD(void, SBExpressionOptions, SetUnwindOnError, (bool),
- unwind);
+ LLDB_INSTRUMENT_VA(this, unwind);
m_opaque_up->SetUnwindOnError(unwind);
}
bool SBExpressionOptions::GetIgnoreBreakpoints() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions,
- GetIgnoreBreakpoints);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->DoesIgnoreBreakpoints();
}
void SBExpressionOptions::SetIgnoreBreakpoints(bool ignore) {
- LLDB_RECORD_METHOD(void, SBExpressionOptions, SetIgnoreBreakpoints, (bool),
- ignore);
+ LLDB_INSTRUMENT_VA(this, ignore);
m_opaque_up->SetIgnoreBreakpoints(ignore);
}
lldb::DynamicValueType SBExpressionOptions::GetFetchDynamicValue() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::DynamicValueType, SBExpressionOptions,
- GetFetchDynamicValue);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetUseDynamic();
}
void SBExpressionOptions::SetFetchDynamicValue(lldb::DynamicValueType dynamic) {
- LLDB_RECORD_METHOD(void, SBExpressionOptions, SetFetchDynamicValue,
- (lldb::DynamicValueType), dynamic);
+ LLDB_INSTRUMENT_VA(this, dynamic);
m_opaque_up->SetUseDynamic(dynamic);
}
uint32_t SBExpressionOptions::GetTimeoutInMicroSeconds() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBExpressionOptions,
- GetTimeoutInMicroSeconds);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetTimeout() ? m_opaque_up->GetTimeout()->count() : 0;
}
void SBExpressionOptions::SetTimeoutInMicroSeconds(uint32_t timeout) {
- LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTimeoutInMicroSeconds,
- (uint32_t), timeout);
+ LLDB_INSTRUMENT_VA(this, timeout);
m_opaque_up->SetTimeout(timeout == 0 ? Timeout<std::micro>(llvm::None)
: std::chrono::microseconds(timeout));
}
uint32_t SBExpressionOptions::GetOneThreadTimeoutInMicroSeconds() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBExpressionOptions,
- GetOneThreadTimeoutInMicroSeconds);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetOneThreadTimeout()
? m_opaque_up->GetOneThreadTimeout()->count()
@@ -120,8 +107,7 @@ uint32_t SBExpressionOptions::GetOneThreadTimeoutInMicroSeconds() const {
}
void SBExpressionOptions::SetOneThreadTimeoutInMicroSeconds(uint32_t timeout) {
- LLDB_RECORD_METHOD(void, SBExpressionOptions,
- SetOneThreadTimeoutInMicroSeconds, (uint32_t), timeout);
+ LLDB_INSTRUMENT_VA(this, timeout);
m_opaque_up->SetOneThreadTimeout(timeout == 0
? Timeout<std::micro>(llvm::None)
@@ -129,148 +115,135 @@ void SBExpressionOptions::SetOneThreadTimeoutInMicroSeconds(uint32_t timeout) {
}
bool SBExpressionOptions::GetTryAllThreads() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, GetTryAllThreads);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetTryAllThreads();
}
void SBExpressionOptions::SetTryAllThreads(bool run_others) {
- LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTryAllThreads, (bool),
- run_others);
+ LLDB_INSTRUMENT_VA(this, run_others);
m_opaque_up->SetTryAllThreads(run_others);
}
bool SBExpressionOptions::GetStopOthers() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, GetStopOthers);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetStopOthers();
}
void SBExpressionOptions::SetStopOthers(bool run_others) {
- LLDB_RECORD_METHOD(void, SBExpressionOptions, SetStopOthers, (bool),
- run_others);
+ LLDB_INSTRUMENT_VA(this, run_others);
m_opaque_up->SetStopOthers(run_others);
}
bool SBExpressionOptions::GetTrapExceptions() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions,
- GetTrapExceptions);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetTrapExceptions();
}
void SBExpressionOptions::SetTrapExceptions(bool trap_exceptions) {
- LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTrapExceptions, (bool),
- trap_exceptions);
+ LLDB_INSTRUMENT_VA(this, trap_exceptions);
m_opaque_up->SetTrapExceptions(trap_exceptions);
}
void SBExpressionOptions::SetLanguage(lldb::LanguageType language) {
- LLDB_RECORD_METHOD(void, SBExpressionOptions, SetLanguage,
- (lldb::LanguageType), language);
+ LLDB_INSTRUMENT_VA(this, language);
m_opaque_up->SetLanguage(language);
}
void SBExpressionOptions::SetCancelCallback(
lldb::ExpressionCancelCallback callback, void *baton) {
- LLDB_RECORD_METHOD(void, SBExpressionOptions, SetCancelCallback,
- (lldb::ExpressionCancelCallback, void *), callback, baton);
+ LLDB_INSTRUMENT_VA(this, callback, baton);
m_opaque_up->SetCancelCallback(callback, baton);
}
bool SBExpressionOptions::GetGenerateDebugInfo() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetGenerateDebugInfo);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetGenerateDebugInfo();
}
void SBExpressionOptions::SetGenerateDebugInfo(bool b) {
- LLDB_RECORD_METHOD(void, SBExpressionOptions, SetGenerateDebugInfo, (bool),
- b);
+ LLDB_INSTRUMENT_VA(this, b);
return m_opaque_up->SetGenerateDebugInfo(b);
}
bool SBExpressionOptions::GetSuppressPersistentResult() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions,
- GetSuppressPersistentResult);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetResultIsInternal();
}
void SBExpressionOptions::SetSuppressPersistentResult(bool b) {
- LLDB_RECORD_METHOD(void, SBExpressionOptions, SetSuppressPersistentResult,
- (bool), b);
+ LLDB_INSTRUMENT_VA(this, b);
return m_opaque_up->SetResultIsInternal(b);
}
const char *SBExpressionOptions::GetPrefix() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBExpressionOptions,
- GetPrefix);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetPrefix();
}
void SBExpressionOptions::SetPrefix(const char *prefix) {
- LLDB_RECORD_METHOD(void, SBExpressionOptions, SetPrefix, (const char *),
- prefix);
+ LLDB_INSTRUMENT_VA(this, prefix);
return m_opaque_up->SetPrefix(prefix);
}
bool SBExpressionOptions::GetAutoApplyFixIts() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetAutoApplyFixIts);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetAutoApplyFixIts();
}
void SBExpressionOptions::SetAutoApplyFixIts(bool b) {
- LLDB_RECORD_METHOD(void, SBExpressionOptions, SetAutoApplyFixIts, (bool), b);
+ LLDB_INSTRUMENT_VA(this, b);
return m_opaque_up->SetAutoApplyFixIts(b);
}
uint64_t SBExpressionOptions::GetRetriesWithFixIts() {
- LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBExpressionOptions,
- GetRetriesWithFixIts);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetRetriesWithFixIts();
}
void SBExpressionOptions::SetRetriesWithFixIts(uint64_t retries) {
- LLDB_RECORD_METHOD(void, SBExpressionOptions, SetRetriesWithFixIts,
- (uint64_t), retries);
+ LLDB_INSTRUMENT_VA(this, retries);
return m_opaque_up->SetRetriesWithFixIts(retries);
}
bool SBExpressionOptions::GetTopLevel() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetTopLevel);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetExecutionPolicy() == eExecutionPolicyTopLevel;
}
void SBExpressionOptions::SetTopLevel(bool b) {
- LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTopLevel, (bool), b);
+ LLDB_INSTRUMENT_VA(this, b);
m_opaque_up->SetExecutionPolicy(b ? eExecutionPolicyTopLevel
: m_opaque_up->default_execution_policy);
}
bool SBExpressionOptions::GetAllowJIT() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetAllowJIT);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetExecutionPolicy() != eExecutionPolicyNever;
}
void SBExpressionOptions::SetAllowJIT(bool allow) {
- LLDB_RECORD_METHOD(void, SBExpressionOptions, SetAllowJIT, (bool), allow);
+ LLDB_INSTRUMENT_VA(this, allow);
m_opaque_up->SetExecutionPolicy(allow ? m_opaque_up->default_execution_policy
: eExecutionPolicyNever);
diff --git a/lldb/source/API/SBFile.cpp b/lldb/source/API/SBFile.cpp
index 4fae46ea10cb..0db859c3b746 100644
--- a/lldb/source/API/SBFile.cpp
+++ b/lldb/source/API/SBFile.cpp
@@ -7,9 +7,9 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBFile.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBError.h"
#include "lldb/Host/File.h"
+#include "lldb/Utility/Instrumentation.h"
using namespace lldb;
using namespace lldb_private;
@@ -19,33 +19,31 @@ SBFile::~SBFile() = default;
SBFile::SBFile(FileSP file_sp) : m_opaque_sp(file_sp) {
// We have no way to capture the incoming FileSP as the class isn't
// instrumented, so pretend that it's always null.
- LLDB_RECORD_CONSTRUCTOR(SBFile, (lldb::FileSP), nullptr);
+ LLDB_INSTRUMENT_VA(this, file_sp);
}
SBFile::SBFile(const SBFile &rhs) : m_opaque_sp(rhs.m_opaque_sp) {
- LLDB_RECORD_CONSTRUCTOR(SBFile, (const lldb::SBFile&), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
}
SBFile &SBFile ::operator=(const SBFile &rhs) {
- LLDB_RECORD_METHOD(lldb::SBFile &,
- SBFile, operator=,(const lldb::SBFile &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_sp = rhs.m_opaque_sp;
return *this;
}
-SBFile::SBFile() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFile); }
+SBFile::SBFile() { LLDB_INSTRUMENT_VA(this); }
SBFile::SBFile(FILE *file, bool transfer_ownership) {
- LLDB_RECORD_CONSTRUCTOR(SBFile, (FILE *, bool), file, transfer_ownership);
+ LLDB_INSTRUMENT_VA(this, file, transfer_ownership);
m_opaque_sp = std::make_shared<NativeFile>(file, transfer_ownership);
}
SBFile::SBFile(int fd, const char *mode, bool transfer_owndership) {
- LLDB_RECORD_CONSTRUCTOR(SBFile, (int, const char *, bool), fd, mode,
- transfer_owndership);
+ LLDB_INSTRUMENT_VA(this, fd, mode, transfer_owndership);
auto options = File::GetOptionsFromMode(mode);
if (!options) {
@@ -57,8 +55,7 @@ SBFile::SBFile(int fd, const char *mode, bool transfer_owndership) {
}
SBError SBFile::Read(uint8_t *buf, size_t num_bytes, size_t *bytes_read) {
- LLDB_RECORD_METHOD(lldb::SBError, SBFile, Read, (uint8_t *, size_t, size_t *),
- buf, num_bytes, bytes_read);
+ LLDB_INSTRUMENT_VA(this, buf, num_bytes, bytes_read);
SBError error;
if (!m_opaque_sp) {
@@ -74,9 +71,7 @@ SBError SBFile::Read(uint8_t *buf, size_t num_bytes, size_t *bytes_read) {
SBError SBFile::Write(const uint8_t *buf, size_t num_bytes,
size_t *bytes_written) {
- LLDB_RECORD_METHOD(lldb::SBError, SBFile, Write,
- (const uint8_t *, size_t, size_t *), buf, num_bytes,
- bytes_written);
+ LLDB_INSTRUMENT_VA(this, buf, num_bytes, bytes_written);
SBError error;
if (!m_opaque_sp) {
@@ -91,7 +86,7 @@ SBError SBFile::Write(const uint8_t *buf, size_t num_bytes,
}
SBError SBFile::Flush() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBFile, Flush);
+ LLDB_INSTRUMENT_VA(this);
SBError error;
if (!m_opaque_sp) {
@@ -104,12 +99,12 @@ SBError SBFile::Flush() {
}
bool SBFile::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFile, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp && m_opaque_sp->IsValid();
}
SBError SBFile::Close() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBFile, Close);
+ LLDB_INSTRUMENT_VA(this);
SBError error;
if (m_opaque_sp) {
Status status = m_opaque_sp->Close();
@@ -119,16 +114,16 @@ SBError SBFile::Close() {
}
SBFile::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFile, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return IsValid();
}
bool SBFile::operator!() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFile, operator!);
+ LLDB_INSTRUMENT_VA(this);
return !IsValid();
}
FileSP SBFile::GetFile() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(FileSP, SBFile, GetFile);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp;
}
diff --git a/lldb/source/API/SBFileSpec.cpp b/lldb/source/API/SBFileSpec.cpp
index b1b676af2d5c..2bec9a7a1e77 100644
--- a/lldb/source/API/SBFileSpec.cpp
+++ b/lldb/source/API/SBFileSpec.cpp
@@ -7,12 +7,12 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBFileSpec.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/API/SBStream.h"
#include "lldb/Host/FileSystem.h"
#include "lldb/Host/PosixApi.h"
#include "lldb/Utility/FileSpec.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/Stream.h"
#include "llvm/ADT/SmallString.h"
@@ -24,11 +24,11 @@ using namespace lldb;
using namespace lldb_private;
SBFileSpec::SBFileSpec() : m_opaque_up(new lldb_private::FileSpec()) {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFileSpec);
+ LLDB_INSTRUMENT_VA(this);
}
SBFileSpec::SBFileSpec(const SBFileSpec &rhs) {
- LLDB_RECORD_CONSTRUCTOR(SBFileSpec, (const lldb::SBFileSpec &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_up = clone(rhs.m_opaque_up);
}
@@ -38,14 +38,14 @@ SBFileSpec::SBFileSpec(const lldb_private::FileSpec &fspec)
// Deprecated!!!
SBFileSpec::SBFileSpec(const char *path) : m_opaque_up(new FileSpec(path)) {
- LLDB_RECORD_CONSTRUCTOR(SBFileSpec, (const char *), path);
+ LLDB_INSTRUMENT_VA(this, path);
FileSystem::Instance().Resolve(*m_opaque_up);
}
SBFileSpec::SBFileSpec(const char *path, bool resolve)
: m_opaque_up(new FileSpec(path)) {
- LLDB_RECORD_CONSTRUCTOR(SBFileSpec, (const char *, bool), path, resolve);
+ LLDB_INSTRUMENT_VA(this, path, resolve);
if (resolve)
FileSystem::Instance().Resolve(*m_opaque_up);
@@ -54,8 +54,7 @@ SBFileSpec::SBFileSpec(const char *path, bool resolve)
SBFileSpec::~SBFileSpec() = default;
const SBFileSpec &SBFileSpec::operator=(const SBFileSpec &rhs) {
- LLDB_RECORD_METHOD(const lldb::SBFileSpec &,
- SBFileSpec, operator=,(const lldb::SBFileSpec &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
@@ -63,46 +62,42 @@ const SBFileSpec &SBFileSpec::operator=(const SBFileSpec &rhs) {
}
bool SBFileSpec::operator==(const SBFileSpec &rhs) const {
- LLDB_RECORD_METHOD_CONST(bool, SBFileSpec, operator==,(const SBFileSpec &rhs),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
return ref() == rhs.ref();
}
bool SBFileSpec::operator!=(const SBFileSpec &rhs) const {
- LLDB_RECORD_METHOD_CONST(bool, SBFileSpec, operator!=,(const SBFileSpec &rhs),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
return !(*this == rhs);
}
bool SBFileSpec::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFileSpec, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBFileSpec::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFileSpec, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->operator bool();
}
bool SBFileSpec::Exists() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFileSpec, Exists);
+ LLDB_INSTRUMENT_VA(this);
return FileSystem::Instance().Exists(*m_opaque_up);
}
bool SBFileSpec::ResolveExecutableLocation() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBFileSpec, ResolveExecutableLocation);
+ LLDB_INSTRUMENT_VA(this);
return FileSystem::Instance().ResolveExecutableLocation(*m_opaque_up);
}
int SBFileSpec::ResolvePath(const char *src_path, char *dst_path,
size_t dst_len) {
- LLDB_RECORD_STATIC_METHOD(int, SBFileSpec, ResolvePath,
- (const char *, char *, size_t), src_path, dst_path,
- dst_len);
+ LLDB_INSTRUMENT_VA(src_path, dst_path, dst_len);
llvm::SmallString<64> result(src_path);
FileSystem::Instance().Resolve(result);
@@ -111,13 +106,13 @@ int SBFileSpec::ResolvePath(const char *src_path, char *dst_path,
}
const char *SBFileSpec::GetFilename() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFileSpec, GetFilename);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetFilename().AsCString();
}
const char *SBFileSpec::GetDirectory() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFileSpec, GetDirectory);
+ LLDB_INSTRUMENT_VA(this);
FileSpec directory{*m_opaque_up};
directory.GetFilename().Clear();
@@ -125,7 +120,7 @@ const char *SBFileSpec::GetDirectory() const {
}
void SBFileSpec::SetFilename(const char *filename) {
- LLDB_RECORD_METHOD(void, SBFileSpec, SetFilename, (const char *), filename);
+ LLDB_INSTRUMENT_VA(this, filename);
if (filename && filename[0])
m_opaque_up->GetFilename().SetCString(filename);
@@ -134,7 +129,7 @@ void SBFileSpec::SetFilename(const char *filename) {
}
void SBFileSpec::SetDirectory(const char *directory) {
- LLDB_RECORD_METHOD(void, SBFileSpec, SetDirectory, (const char *), directory);
+ LLDB_INSTRUMENT_VA(this, directory);
if (directory && directory[0])
m_opaque_up->GetDirectory().SetCString(directory);
@@ -143,8 +138,7 @@ void SBFileSpec::SetDirectory(const char *directory) {
}
uint32_t SBFileSpec::GetPath(char *dst_path, size_t dst_len) const {
- LLDB_RECORD_METHOD_CONST(uint32_t, SBFileSpec, GetPath, (char *, size_t),
- dst_path, "", dst_len);
+ LLDB_INSTRUMENT_VA(this, dst_path, dst_len);
uint32_t result = m_opaque_up->GetPath(dst_path, dst_len);
@@ -172,8 +166,7 @@ void SBFileSpec::SetFileSpec(const lldb_private::FileSpec &fs) {
}
bool SBFileSpec::GetDescription(SBStream &description) const {
- LLDB_RECORD_METHOD_CONST(bool, SBFileSpec, GetDescription, (lldb::SBStream &),
- description);
+ LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();
char path[PATH_MAX];
@@ -183,7 +176,7 @@ bool SBFileSpec::GetDescription(SBStream &description) const {
}
void SBFileSpec::AppendPathComponent(const char *fn) {
- LLDB_RECORD_METHOD(void, SBFileSpec, AppendPathComponent, (const char *), fn);
+ LLDB_INSTRUMENT_VA(this, fn);
m_opaque_up->AppendPathComponent(fn);
}
diff --git a/lldb/source/API/SBFileSpecList.cpp b/lldb/source/API/SBFileSpecList.cpp
index 6e85957cb088..cf81c4234087 100644
--- a/lldb/source/API/SBFileSpecList.cpp
+++ b/lldb/source/API/SBFileSpecList.cpp
@@ -7,13 +7,13 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBFileSpecList.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/API/SBFileSpec.h"
#include "lldb/API/SBStream.h"
#include "lldb/Core/FileSpecList.h"
#include "lldb/Host/PosixApi.h"
#include "lldb/Utility/FileSpec.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/Stream.h"
#include <climits>
@@ -22,11 +22,11 @@ using namespace lldb;
using namespace lldb_private;
SBFileSpecList::SBFileSpecList() : m_opaque_up(new FileSpecList()) {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFileSpecList);
+ LLDB_INSTRUMENT_VA(this);
}
SBFileSpecList::SBFileSpecList(const SBFileSpecList &rhs) {
- LLDB_RECORD_CONSTRUCTOR(SBFileSpecList, (const lldb::SBFileSpecList &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_up = clone(rhs.m_opaque_up);
}
@@ -34,9 +34,7 @@ SBFileSpecList::SBFileSpecList(const SBFileSpecList &rhs) {
SBFileSpecList::~SBFileSpecList() = default;
const SBFileSpecList &SBFileSpecList::operator=(const SBFileSpecList &rhs) {
- LLDB_RECORD_METHOD(const lldb::SBFileSpecList &,
- SBFileSpecList, operator=,(const lldb::SBFileSpecList &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
@@ -44,43 +42,38 @@ const SBFileSpecList &SBFileSpecList::operator=(const SBFileSpecList &rhs) {
}
uint32_t SBFileSpecList::GetSize() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBFileSpecList, GetSize);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetSize();
}
void SBFileSpecList::Append(const SBFileSpec &sb_file) {
- LLDB_RECORD_METHOD(void, SBFileSpecList, Append, (const lldb::SBFileSpec &),
- sb_file);
+ LLDB_INSTRUMENT_VA(this, sb_file);
m_opaque_up->Append(sb_file.ref());
}
bool SBFileSpecList::AppendIfUnique(const SBFileSpec &sb_file) {
- LLDB_RECORD_METHOD(bool, SBFileSpecList, AppendIfUnique,
- (const lldb::SBFileSpec &), sb_file);
+ LLDB_INSTRUMENT_VA(this, sb_file);
return m_opaque_up->AppendIfUnique(sb_file.ref());
}
void SBFileSpecList::Clear() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBFileSpecList, Clear);
+ LLDB_INSTRUMENT_VA(this);
m_opaque_up->Clear();
}
uint32_t SBFileSpecList::FindFileIndex(uint32_t idx, const SBFileSpec &sb_file,
bool full) {
- LLDB_RECORD_METHOD(uint32_t, SBFileSpecList, FindFileIndex,
- (uint32_t, const lldb::SBFileSpec &, bool), idx, sb_file,
- full);
+ LLDB_INSTRUMENT_VA(this, idx, sb_file, full);
return m_opaque_up->FindFileIndex(idx, sb_file.ref(), full);
}
const SBFileSpec SBFileSpecList::GetFileSpecAtIndex(uint32_t idx) const {
- LLDB_RECORD_METHOD_CONST(const lldb::SBFileSpec, SBFileSpecList,
- GetFileSpecAtIndex, (uint32_t), idx);
+ LLDB_INSTRUMENT_VA(this, idx);
SBFileSpec new_spec;
new_spec.SetFileSpec(m_opaque_up->GetFileSpecAtIndex(idx));
@@ -104,8 +97,7 @@ const lldb_private::FileSpecList &SBFileSpecList::ref() const {
}
bool SBFileSpecList::GetDescription(SBStream &description) const {
- LLDB_RECORD_METHOD_CONST(bool, SBFileSpecList, GetDescription,
- (lldb::SBStream &), description);
+ LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();
diff --git a/lldb/source/API/SBFrame.cpp b/lldb/source/API/SBFrame.cpp
index ab3886e24d6f..ffbbed00f8e2 100644
--- a/lldb/source/API/SBFrame.cpp
+++ b/lldb/source/API/SBFrame.cpp
@@ -14,7 +14,6 @@
#include "lldb/lldb-types.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/Core/Address.h"
#include "lldb/Core/StreamFile.h"
@@ -38,6 +37,7 @@
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/Stream.h"
#include "lldb/API/SBAddress.h"
@@ -55,17 +55,16 @@ using namespace lldb;
using namespace lldb_private;
SBFrame::SBFrame() : m_opaque_sp(new ExecutionContextRef()) {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFrame);
+ LLDB_INSTRUMENT_VA(this);
}
SBFrame::SBFrame(const StackFrameSP &lldb_object_sp)
: m_opaque_sp(new ExecutionContextRef(lldb_object_sp)) {
- LLDB_RECORD_CONSTRUCTOR(SBFrame, (const lldb::StackFrameSP &),
- lldb_object_sp);
+ LLDB_INSTRUMENT_VA(this, lldb_object_sp);
}
SBFrame::SBFrame(const SBFrame &rhs) {
- LLDB_RECORD_CONSTRUCTOR(SBFrame, (const lldb::SBFrame &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_sp = clone(rhs.m_opaque_sp);
}
@@ -73,8 +72,7 @@ SBFrame::SBFrame(const SBFrame &rhs) {
SBFrame::~SBFrame() = default;
const SBFrame &SBFrame::operator=(const SBFrame &rhs) {
- LLDB_RECORD_METHOD(const lldb::SBFrame &,
- SBFrame, operator=,(const lldb::SBFrame &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_sp = clone(rhs.m_opaque_sp);
@@ -90,11 +88,11 @@ void SBFrame::SetFrameSP(const StackFrameSP &lldb_object_sp) {
}
bool SBFrame::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBFrame::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, operator bool);
+ LLDB_INSTRUMENT_VA(this);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -112,8 +110,7 @@ SBFrame::operator bool() const {
}
SBSymbolContext SBFrame::GetSymbolContext(uint32_t resolve_scope) const {
- LLDB_RECORD_METHOD_CONST(lldb::SBSymbolContext, SBFrame, GetSymbolContext,
- (uint32_t), resolve_scope);
+ LLDB_INSTRUMENT_VA(this, resolve_scope);
SBSymbolContext sb_sym_ctx;
std::unique_lock<std::recursive_mutex> lock;
@@ -133,7 +130,7 @@ SBSymbolContext SBFrame::GetSymbolContext(uint32_t resolve_scope) const {
}
SBModule SBFrame::GetModule() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBModule, SBFrame, GetModule);
+ LLDB_INSTRUMENT_VA(this);
SBModule sb_module;
ModuleSP module_sp;
@@ -158,8 +155,7 @@ SBModule SBFrame::GetModule() const {
}
SBCompileUnit SBFrame::GetCompileUnit() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBCompileUnit, SBFrame,
- GetCompileUnit);
+ LLDB_INSTRUMENT_VA(this);
SBCompileUnit sb_comp_unit;
std::unique_lock<std::recursive_mutex> lock;
@@ -183,7 +179,7 @@ SBCompileUnit SBFrame::GetCompileUnit() const {
}
SBFunction SBFrame::GetFunction() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFunction, SBFrame, GetFunction);
+ LLDB_INSTRUMENT_VA(this);
SBFunction sb_function;
std::unique_lock<std::recursive_mutex> lock;
@@ -207,7 +203,7 @@ SBFunction SBFrame::GetFunction() const {
}
SBSymbol SBFrame::GetSymbol() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBSymbol, SBFrame, GetSymbol);
+ LLDB_INSTRUMENT_VA(this);
SBSymbol sb_symbol;
std::unique_lock<std::recursive_mutex> lock;
@@ -230,7 +226,7 @@ SBSymbol SBFrame::GetSymbol() const {
}
SBBlock SBFrame::GetBlock() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBlock, SBFrame, GetBlock);
+ LLDB_INSTRUMENT_VA(this);
SBBlock sb_block;
std::unique_lock<std::recursive_mutex> lock;
@@ -251,7 +247,7 @@ SBBlock SBFrame::GetBlock() const {
}
SBBlock SBFrame::GetFrameBlock() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBlock, SBFrame, GetFrameBlock);
+ LLDB_INSTRUMENT_VA(this);
SBBlock sb_block;
std::unique_lock<std::recursive_mutex> lock;
@@ -272,7 +268,7 @@ SBBlock SBFrame::GetFrameBlock() const {
}
SBLineEntry SBFrame::GetLineEntry() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBLineEntry, SBFrame, GetLineEntry);
+ LLDB_INSTRUMENT_VA(this);
SBLineEntry sb_line_entry;
std::unique_lock<std::recursive_mutex> lock;
@@ -295,7 +291,7 @@ SBLineEntry SBFrame::GetLineEntry() const {
}
uint32_t SBFrame::GetFrameID() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBFrame, GetFrameID);
+ LLDB_INSTRUMENT_VA(this);
uint32_t frame_idx = UINT32_MAX;
@@ -310,7 +306,7 @@ uint32_t SBFrame::GetFrameID() const {
}
lldb::addr_t SBFrame::GetCFA() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetCFA);
+ LLDB_INSTRUMENT_VA(this);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -322,7 +318,7 @@ lldb::addr_t SBFrame::GetCFA() const {
}
addr_t SBFrame::GetPC() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetPC);
+ LLDB_INSTRUMENT_VA(this);
addr_t addr = LLDB_INVALID_ADDRESS;
std::unique_lock<std::recursive_mutex> lock;
@@ -346,7 +342,7 @@ addr_t SBFrame::GetPC() const {
}
bool SBFrame::SetPC(addr_t new_pc) {
- LLDB_RECORD_METHOD(bool, SBFrame, SetPC, (lldb::addr_t), new_pc);
+ LLDB_INSTRUMENT_VA(this, new_pc);
bool ret_val = false;
std::unique_lock<std::recursive_mutex> lock;
@@ -369,7 +365,7 @@ bool SBFrame::SetPC(addr_t new_pc) {
}
addr_t SBFrame::GetSP() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetSP);
+ LLDB_INSTRUMENT_VA(this);
addr_t addr = LLDB_INVALID_ADDRESS;
std::unique_lock<std::recursive_mutex> lock;
@@ -392,7 +388,7 @@ addr_t SBFrame::GetSP() const {
}
addr_t SBFrame::GetFP() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetFP);
+ LLDB_INSTRUMENT_VA(this);
addr_t addr = LLDB_INVALID_ADDRESS;
std::unique_lock<std::recursive_mutex> lock;
@@ -415,7 +411,7 @@ addr_t SBFrame::GetFP() const {
}
SBAddress SBFrame::GetPCAddress() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBFrame, GetPCAddress);
+ LLDB_INSTRUMENT_VA(this);
SBAddress sb_addr;
std::unique_lock<std::recursive_mutex> lock;
@@ -436,14 +432,13 @@ SBAddress SBFrame::GetPCAddress() const {
}
void SBFrame::Clear() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBFrame, Clear);
+ LLDB_INSTRUMENT_VA(this);
m_opaque_sp->Clear();
}
lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path) {
- LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,
- (const char *), var_path);
+ LLDB_INSTRUMENT_VA(this, var_path);
SBValue sb_value;
std::unique_lock<std::recursive_mutex> lock;
@@ -461,9 +456,7 @@ lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path) {
lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path,
DynamicValueType use_dynamic) {
- LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,
- (const char *, lldb::DynamicValueType), var_path,
- use_dynamic);
+ LLDB_INSTRUMENT_VA(this, var_path, use_dynamic);
SBValue sb_value;
if (var_path == nullptr || var_path[0] == '\0') {
@@ -496,8 +489,7 @@ lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path,
}
SBValue SBFrame::FindVariable(const char *name) {
- LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindVariable, (const char *),
- name);
+ LLDB_INSTRUMENT_VA(this, name);
SBValue value;
std::unique_lock<std::recursive_mutex> lock;
@@ -515,8 +507,7 @@ SBValue SBFrame::FindVariable(const char *name) {
SBValue SBFrame::FindVariable(const char *name,
lldb::DynamicValueType use_dynamic) {
- LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindVariable,
- (const char *, lldb::DynamicValueType), name, use_dynamic);
+ LLDB_INSTRUMENT_VA(this, name, use_dynamic);
VariableSP var_sp;
SBValue sb_value;
@@ -549,8 +540,7 @@ SBValue SBFrame::FindVariable(const char *name,
}
SBValue SBFrame::FindValue(const char *name, ValueType value_type) {
- LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindValue,
- (const char *, lldb::ValueType), name, value_type);
+ LLDB_INSTRUMENT_VA(this, name, value_type);
SBValue value;
std::unique_lock<std::recursive_mutex> lock;
@@ -568,9 +558,7 @@ SBValue SBFrame::FindValue(const char *name, ValueType value_type) {
SBValue SBFrame::FindValue(const char *name, ValueType value_type,
lldb::DynamicValueType use_dynamic) {
- LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindValue,
- (const char *, lldb::ValueType, lldb::DynamicValueType),
- name, value_type, use_dynamic);
+ LLDB_INSTRUMENT_VA(this, name, value_type, use_dynamic);
SBValue sb_value;
@@ -682,8 +670,7 @@ SBValue SBFrame::FindValue(const char *name, ValueType value_type,
}
bool SBFrame::IsEqual(const SBFrame &that) const {
- LLDB_RECORD_METHOD_CONST(bool, SBFrame, IsEqual, (const lldb::SBFrame &),
- that);
+ LLDB_INSTRUMENT_VA(this, that);
lldb::StackFrameSP this_sp = GetFrameSP();
lldb::StackFrameSP that_sp = that.GetFrameSP();
@@ -691,21 +678,19 @@ bool SBFrame::IsEqual(const SBFrame &that) const {
}
bool SBFrame::operator==(const SBFrame &rhs) const {
- LLDB_RECORD_METHOD_CONST(bool, SBFrame, operator==,(const lldb::SBFrame &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
return IsEqual(rhs);
}
bool SBFrame::operator!=(const SBFrame &rhs) const {
- LLDB_RECORD_METHOD_CONST(bool, SBFrame, operator!=,(const lldb::SBFrame &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
return !IsEqual(rhs);
}
SBThread SBFrame::GetThread() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBFrame, GetThread);
+ LLDB_INSTRUMENT_VA(this);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -717,7 +702,7 @@ SBThread SBFrame::GetThread() const {
}
const char *SBFrame::Disassemble() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFrame, Disassemble);
+ LLDB_INSTRUMENT_VA(this);
const char *disassembly = nullptr;
std::unique_lock<std::recursive_mutex> lock;
@@ -741,9 +726,7 @@ const char *SBFrame::Disassemble() const {
SBValueList SBFrame::GetVariables(bool arguments, bool locals, bool statics,
bool in_scope_only) {
- LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables,
- (bool, bool, bool, bool), arguments, locals, statics,
- in_scope_only);
+ LLDB_INSTRUMENT_VA(this, arguments, locals, statics, in_scope_only);
SBValueList value_list;
std::unique_lock<std::recursive_mutex> lock;
@@ -773,9 +756,8 @@ SBValueList SBFrame::GetVariables(bool arguments, bool locals, bool statics,
lldb::SBValueList SBFrame::GetVariables(bool arguments, bool locals,
bool statics, bool in_scope_only,
lldb::DynamicValueType use_dynamic) {
- LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables,
- (bool, bool, bool, bool, lldb::DynamicValueType),
- arguments, locals, statics, in_scope_only, use_dynamic);
+ LLDB_INSTRUMENT_VA(this, arguments, locals, statics, in_scope_only,
+ use_dynamic);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -794,8 +776,7 @@ lldb::SBValueList SBFrame::GetVariables(bool arguments, bool locals,
}
SBValueList SBFrame::GetVariables(const lldb::SBVariablesOptions &options) {
- LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables,
- (const lldb::SBVariablesOptions &), options);
+ LLDB_INSTRUMENT_VA(this, options);
SBValueList value_list;
std::unique_lock<std::recursive_mutex> lock;
@@ -895,7 +876,7 @@ SBValueList SBFrame::GetVariables(const lldb::SBVariablesOptions &options) {
}
SBValueList SBFrame::GetRegisters() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValueList, SBFrame, GetRegisters);
+ LLDB_INSTRUMENT_VA(this);
SBValueList value_list;
std::unique_lock<std::recursive_mutex> lock;
@@ -925,8 +906,7 @@ SBValueList SBFrame::GetRegisters() {
}
SBValue SBFrame::FindRegister(const char *name) {
- LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindRegister, (const char *),
- name);
+ LLDB_INSTRUMENT_VA(this, name);
SBValue result;
ValueObjectSP value_sp;
@@ -957,8 +937,7 @@ SBValue SBFrame::FindRegister(const char *name) {
}
bool SBFrame::GetDescription(SBStream &description) {
- LLDB_RECORD_METHOD(bool, SBFrame, GetDescription, (lldb::SBStream &),
- description);
+ LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();
@@ -984,8 +963,7 @@ bool SBFrame::GetDescription(SBStream &description) {
}
SBValue SBFrame::EvaluateExpression(const char *expr) {
- LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression, (const char *),
- expr);
+ LLDB_INSTRUMENT_VA(this, expr);
SBValue result;
std::unique_lock<std::recursive_mutex> lock;
@@ -1012,9 +990,7 @@ SBValue SBFrame::EvaluateExpression(const char *expr) {
SBValue
SBFrame::EvaluateExpression(const char *expr,
lldb::DynamicValueType fetch_dynamic_value) {
- LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
- (const char *, lldb::DynamicValueType), expr,
- fetch_dynamic_value);
+ LLDB_INSTRUMENT_VA(this, expr, fetch_dynamic_value);
SBExpressionOptions options;
options.SetFetchDynamicValue(fetch_dynamic_value);
@@ -1035,9 +1011,7 @@ SBFrame::EvaluateExpression(const char *expr,
SBValue SBFrame::EvaluateExpression(const char *expr,
lldb::DynamicValueType fetch_dynamic_value,
bool unwind_on_error) {
- LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
- (const char *, lldb::DynamicValueType, bool), expr,
- fetch_dynamic_value, unwind_on_error);
+ LLDB_INSTRUMENT_VA(this, expr, fetch_dynamic_value, unwind_on_error);
SBExpressionOptions options;
std::unique_lock<std::recursive_mutex> lock;
@@ -1057,9 +1031,7 @@ SBValue SBFrame::EvaluateExpression(const char *expr,
lldb::SBValue SBFrame::EvaluateExpression(const char *expr,
const SBExpressionOptions &options) {
- LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
- (const char *, const lldb::SBExpressionOptions &), expr,
- options);
+ LLDB_INSTRUMENT_VA(this, expr, options);
Log *expr_log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
@@ -1110,13 +1082,13 @@ lldb::SBValue SBFrame::EvaluateExpression(const char *expr,
}
bool SBFrame::IsInlined() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBFrame, IsInlined);
+ LLDB_INSTRUMENT_VA(this);
return static_cast<const SBFrame *>(this)->IsInlined();
}
bool SBFrame::IsInlined() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsInlined);
+ LLDB_INSTRUMENT_VA(this);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -1140,13 +1112,13 @@ bool SBFrame::IsInlined() const {
}
bool SBFrame::IsArtificial() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBFrame, IsArtificial);
+ LLDB_INSTRUMENT_VA(this);
return static_cast<const SBFrame *>(this)->IsArtificial();
}
bool SBFrame::IsArtificial() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsArtificial);
+ LLDB_INSTRUMENT_VA(this);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -1159,13 +1131,13 @@ bool SBFrame::IsArtificial() const {
}
const char *SBFrame::GetFunctionName() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBFrame, GetFunctionName);
+ LLDB_INSTRUMENT_VA(this);
return static_cast<const SBFrame *>(this)->GetFunctionName();
}
lldb::LanguageType SBFrame::GuessLanguage() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::LanguageType, SBFrame, GuessLanguage);
+ LLDB_INSTRUMENT_VA(this);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -1186,7 +1158,7 @@ lldb::LanguageType SBFrame::GuessLanguage() const {
}
const char *SBFrame::GetFunctionName() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFrame, GetFunctionName);
+ LLDB_INSTRUMENT_VA(this);
const char *name = nullptr;
std::unique_lock<std::recursive_mutex> lock;
@@ -1228,7 +1200,7 @@ const char *SBFrame::GetFunctionName() const {
}
const char *SBFrame::GetDisplayFunctionName() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBFrame, GetDisplayFunctionName);
+ LLDB_INSTRUMENT_VA(this);
const char *name = nullptr;
diff --git a/lldb/source/API/SBFunction.cpp b/lldb/source/API/SBFunction.cpp
index 2b1bc05e3356..562cae4e8906 100644
--- a/lldb/source/API/SBFunction.cpp
+++ b/lldb/source/API/SBFunction.cpp
@@ -7,7 +7,6 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBFunction.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBProcess.h"
#include "lldb/API/SBStream.h"
#include "lldb/Core/Disassembler.h"
@@ -18,23 +17,23 @@
#include "lldb/Symbol/VariableList.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Target.h"
+#include "lldb/Utility/Instrumentation.h"
using namespace lldb;
using namespace lldb_private;
-SBFunction::SBFunction() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFunction); }
+SBFunction::SBFunction() { LLDB_INSTRUMENT_VA(this); }
SBFunction::SBFunction(lldb_private::Function *lldb_object_ptr)
: m_opaque_ptr(lldb_object_ptr) {}
SBFunction::SBFunction(const lldb::SBFunction &rhs)
: m_opaque_ptr(rhs.m_opaque_ptr) {
- LLDB_RECORD_CONSTRUCTOR(SBFunction, (const lldb::SBFunction &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
}
const SBFunction &SBFunction::operator=(const SBFunction &rhs) {
- LLDB_RECORD_METHOD(const lldb::SBFunction &,
- SBFunction, operator=,(const lldb::SBFunction &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_ptr = rhs.m_opaque_ptr;
return *this;
@@ -43,17 +42,17 @@ const SBFunction &SBFunction::operator=(const SBFunction &rhs) {
SBFunction::~SBFunction() { m_opaque_ptr = nullptr; }
bool SBFunction::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFunction, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBFunction::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFunction, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_ptr != nullptr;
}
const char *SBFunction::GetName() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFunction, GetName);
+ LLDB_INSTRUMENT_VA(this);
const char *cstr = nullptr;
if (m_opaque_ptr)
@@ -63,7 +62,7 @@ const char *SBFunction::GetName() const {
}
const char *SBFunction::GetDisplayName() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFunction, GetDisplayName);
+ LLDB_INSTRUMENT_VA(this);
const char *cstr = nullptr;
if (m_opaque_ptr)
@@ -73,7 +72,7 @@ const char *SBFunction::GetDisplayName() const {
}
const char *SBFunction::GetMangledName() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFunction, GetMangledName);
+ LLDB_INSTRUMENT_VA(this);
const char *cstr = nullptr;
if (m_opaque_ptr)
@@ -82,21 +81,19 @@ const char *SBFunction::GetMangledName() const {
}
bool SBFunction::operator==(const SBFunction &rhs) const {
- LLDB_RECORD_METHOD_CONST(
- bool, SBFunction, operator==,(const lldb::SBFunction &), rhs);
+ LLDB_INSTRUMENT_VA(this, 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_INSTRUMENT_VA(this, rhs);
return m_opaque_ptr != rhs.m_opaque_ptr;
}
bool SBFunction::GetDescription(SBStream &s) {
- LLDB_RECORD_METHOD(bool, SBFunction, GetDescription, (lldb::SBStream &), s);
+ LLDB_INSTRUMENT_VA(this, s);
if (m_opaque_ptr) {
s.Printf("SBFunction: id = 0x%8.8" PRIx64 ", name = %s",
@@ -111,16 +108,14 @@ bool SBFunction::GetDescription(SBStream &s) {
}
SBInstructionList SBFunction::GetInstructions(SBTarget target) {
- LLDB_RECORD_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions,
- (lldb::SBTarget), target);
+ LLDB_INSTRUMENT_VA(this, target);
return GetInstructions(target, nullptr);
}
SBInstructionList SBFunction::GetInstructions(SBTarget target,
const char *flavor) {
- LLDB_RECORD_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions,
- (lldb::SBTarget, const char *), target, flavor);
+ LLDB_INSTRUMENT_VA(this, target, flavor);
SBInstructionList sb_instructions;
if (m_opaque_ptr) {
@@ -146,7 +141,7 @@ void SBFunction::reset(lldb_private::Function *lldb_object_ptr) {
}
SBAddress SBFunction::GetStartAddress() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBFunction, GetStartAddress);
+ LLDB_INSTRUMENT_VA(this);
SBAddress addr;
if (m_opaque_ptr)
@@ -155,7 +150,7 @@ SBAddress SBFunction::GetStartAddress() {
}
SBAddress SBFunction::GetEndAddress() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBFunction, GetEndAddress);
+ LLDB_INSTRUMENT_VA(this);
SBAddress addr;
if (m_opaque_ptr) {
@@ -169,8 +164,7 @@ SBAddress SBFunction::GetEndAddress() {
}
const char *SBFunction::GetArgumentName(uint32_t arg_idx) {
- LLDB_RECORD_METHOD(const char *, SBFunction, GetArgumentName, (uint32_t),
- arg_idx);
+ LLDB_INSTRUMENT_VA(this, arg_idx);
if (m_opaque_ptr) {
Block &block = m_opaque_ptr->GetBlock(true);
@@ -188,7 +182,7 @@ const char *SBFunction::GetArgumentName(uint32_t arg_idx) {
}
uint32_t SBFunction::GetPrologueByteSize() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBFunction, GetPrologueByteSize);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr)
return m_opaque_ptr->GetPrologueByteSize();
@@ -196,7 +190,7 @@ uint32_t SBFunction::GetPrologueByteSize() {
}
SBType SBFunction::GetType() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBFunction, GetType);
+ LLDB_INSTRUMENT_VA(this);
SBType sb_type;
if (m_opaque_ptr) {
@@ -208,7 +202,7 @@ SBType SBFunction::GetType() {
}
SBBlock SBFunction::GetBlock() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBFunction, GetBlock);
+ LLDB_INSTRUMENT_VA(this);
SBBlock sb_block;
if (m_opaque_ptr)
@@ -217,7 +211,7 @@ SBBlock SBFunction::GetBlock() {
}
lldb::LanguageType SBFunction::GetLanguage() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::LanguageType, SBFunction, GetLanguage);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr) {
if (m_opaque_ptr->GetCompileUnit())
@@ -227,7 +221,7 @@ lldb::LanguageType SBFunction::GetLanguage() {
}
bool SBFunction::GetIsOptimized() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBFunction, GetIsOptimized);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr) {
if (m_opaque_ptr->GetCompileUnit())
diff --git a/lldb/source/API/SBHostOS.cpp b/lldb/source/API/SBHostOS.cpp
index 5bcb83d95ae7..06cf654031a1 100644
--- a/lldb/source/API/SBHostOS.cpp
+++ b/lldb/source/API/SBHostOS.cpp
@@ -7,7 +7,6 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBHostOS.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBError.h"
#include "lldb/Host/Config.h"
#include "lldb/Host/FileSystem.h"
@@ -17,6 +16,7 @@
#include "lldb/Host/HostThread.h"
#include "lldb/Host/ThreadLauncher.h"
#include "lldb/Utility/FileSpec.h"
+#include "lldb/Utility/Instrumentation.h"
#include "Plugins/ExpressionParser/Clang/ClangHost.h"
#if LLDB_ENABLE_PYTHON
@@ -30,8 +30,7 @@ using namespace lldb;
using namespace lldb_private;
SBFileSpec SBHostOS::GetProgramFileSpec() {
- LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBFileSpec, SBHostOS,
- GetProgramFileSpec);
+ LLDB_INSTRUMENT();
SBFileSpec sb_filespec;
sb_filespec.SetFileSpec(HostInfo::GetProgramFileSpec());
@@ -39,15 +38,13 @@ SBFileSpec SBHostOS::GetProgramFileSpec() {
}
SBFileSpec SBHostOS::GetLLDBPythonPath() {
- LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBFileSpec, SBHostOS,
- GetLLDBPythonPath);
+ LLDB_INSTRUMENT();
return GetLLDBPath(ePathTypePythonDir);
}
SBFileSpec SBHostOS::GetLLDBPath(lldb::PathType path_type) {
- LLDB_RECORD_STATIC_METHOD(lldb::SBFileSpec, SBHostOS, GetLLDBPath,
- (lldb::PathType), path_type);
+ LLDB_INSTRUMENT_VA(path_type);
FileSpec fspec;
switch (path_type) {
@@ -88,8 +85,7 @@ SBFileSpec SBHostOS::GetLLDBPath(lldb::PathType path_type) {
}
SBFileSpec SBHostOS::GetUserHomeDirectory() {
- LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBFileSpec, SBHostOS,
- GetUserHomeDirectory);
+ LLDB_INSTRUMENT();
FileSpec homedir;
FileSystem::Instance().GetHomeDirectory(homedir);
@@ -104,9 +100,7 @@ SBFileSpec SBHostOS::GetUserHomeDirectory() {
lldb::thread_t SBHostOS::ThreadCreate(const char *name,
lldb::thread_func_t thread_function,
void *thread_arg, SBError *error_ptr) {
- LLDB_RECORD_STATIC_METHOD(lldb::thread_t, SBHostOS, ThreadCreate,
- (lldb::thread_func_t, void *, SBError *), name,
- thread_function, thread_arg, error_ptr);
+ LLDB_INSTRUMENT_VA(name, thread_function, thread_arg, error_ptr);
llvm::Expected<HostThread> thread =
ThreadLauncher::LaunchThread(name, thread_function, thread_arg);
if (!thread) {
@@ -120,15 +114,10 @@ lldb::thread_t SBHostOS::ThreadCreate(const char *name,
return thread->Release();
}
-void SBHostOS::ThreadCreated(const char *name) {
- LLDB_RECORD_STATIC_METHOD(void, SBHostOS, ThreadCreated, (const char *),
- name);
-}
+void SBHostOS::ThreadCreated(const char *name) { LLDB_INSTRUMENT_VA(name); }
bool SBHostOS::ThreadCancel(lldb::thread_t thread, SBError *error_ptr) {
- LLDB_RECORD_STATIC_METHOD(bool, SBHostOS, ThreadCancel,
- (lldb::thread_t, lldb::SBError *), thread,
- error_ptr);
+ LLDB_INSTRUMENT_VA(thread, error_ptr);
Status error;
HostThread host_thread(thread);
@@ -140,9 +129,7 @@ bool SBHostOS::ThreadCancel(lldb::thread_t thread, SBError *error_ptr) {
}
bool SBHostOS::ThreadDetach(lldb::thread_t thread, SBError *error_ptr) {
- LLDB_RECORD_STATIC_METHOD(bool, SBHostOS, ThreadDetach,
- (lldb::thread_t, lldb::SBError *), thread,
- error_ptr);
+ LLDB_INSTRUMENT_VA(thread, error_ptr);
Status error;
#if defined(_WIN32)
@@ -160,10 +147,7 @@ bool SBHostOS::ThreadDetach(lldb::thread_t thread, SBError *error_ptr) {
bool SBHostOS::ThreadJoin(lldb::thread_t thread, lldb::thread_result_t *result,
SBError *error_ptr) {
- LLDB_RECORD_STATIC_METHOD(
- bool, SBHostOS, ThreadJoin,
- (lldb::thread_t, lldb::thread_result_t *, lldb::SBError *), thread,
- result, error_ptr);
+ LLDB_INSTRUMENT_VA(thread, result, error_ptr);
Status error;
HostThread host_thread(thread);
diff --git a/lldb/source/API/SBInstruction.cpp b/lldb/source/API/SBInstruction.cpp
index f9a75686d906..6cb9e5dbc1af 100644
--- a/lldb/source/API/SBInstruction.cpp
+++ b/lldb/source/API/SBInstruction.cpp
@@ -7,7 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBInstruction.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBFrame.h"
@@ -66,9 +66,7 @@ class InstructionImpl {
using namespace lldb;
using namespace lldb_private;
-SBInstruction::SBInstruction() {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBInstruction);
-}
+SBInstruction::SBInstruction() { LLDB_INSTRUMENT_VA(this); }
SBInstruction::SBInstruction(const lldb::DisassemblerSP &disasm_sp,
const lldb::InstructionSP &inst_sp)
@@ -76,13 +74,11 @@ SBInstruction::SBInstruction(const lldb::DisassemblerSP &disasm_sp,
SBInstruction::SBInstruction(const SBInstruction &rhs)
: m_opaque_sp(rhs.m_opaque_sp) {
- LLDB_RECORD_CONSTRUCTOR(SBInstruction, (const lldb::SBInstruction &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
}
const SBInstruction &SBInstruction::operator=(const SBInstruction &rhs) {
- LLDB_RECORD_METHOD(const lldb::SBInstruction &,
- SBInstruction, operator=,(const lldb::SBInstruction &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_sp = rhs.m_opaque_sp;
@@ -92,17 +88,17 @@ const SBInstruction &SBInstruction::operator=(const SBInstruction &rhs) {
SBInstruction::~SBInstruction() = default;
bool SBInstruction::IsValid() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBInstruction::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInstruction, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp && m_opaque_sp->IsValid();
}
SBAddress SBInstruction::GetAddress() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBInstruction, GetAddress);
+ LLDB_INSTRUMENT_VA(this);
SBAddress sb_addr;
lldb::InstructionSP inst_sp(GetOpaque());
@@ -112,8 +108,7 @@ SBAddress SBInstruction::GetAddress() {
}
const char *SBInstruction::GetMnemonic(SBTarget target) {
- LLDB_RECORD_METHOD(const char *, SBInstruction, GetMnemonic, (lldb::SBTarget),
- target);
+ LLDB_INSTRUMENT_VA(this, target);
lldb::InstructionSP inst_sp(GetOpaque());
if (inst_sp) {
@@ -132,8 +127,7 @@ const char *SBInstruction::GetMnemonic(SBTarget target) {
}
const char *SBInstruction::GetOperands(SBTarget target) {
- LLDB_RECORD_METHOD(const char *, SBInstruction, GetOperands, (lldb::SBTarget),
- target);
+ LLDB_INSTRUMENT_VA(this, target);
lldb::InstructionSP inst_sp(GetOpaque());
if (inst_sp) {
@@ -152,8 +146,7 @@ const char *SBInstruction::GetOperands(SBTarget target) {
}
const char *SBInstruction::GetComment(SBTarget target) {
- LLDB_RECORD_METHOD(const char *, SBInstruction, GetComment, (lldb::SBTarget),
- target);
+ LLDB_INSTRUMENT_VA(this, target);
lldb::InstructionSP inst_sp(GetOpaque());
if (inst_sp) {
@@ -172,7 +165,7 @@ const char *SBInstruction::GetComment(SBTarget target) {
}
size_t SBInstruction::GetByteSize() {
- LLDB_RECORD_METHOD_NO_ARGS(size_t, SBInstruction, GetByteSize);
+ LLDB_INSTRUMENT_VA(this);
lldb::InstructionSP inst_sp(GetOpaque());
if (inst_sp)
@@ -181,8 +174,7 @@ size_t SBInstruction::GetByteSize() {
}
SBData SBInstruction::GetData(SBTarget target) {
- LLDB_RECORD_METHOD(lldb::SBData, SBInstruction, GetData, (lldb::SBTarget),
- target);
+ LLDB_INSTRUMENT_VA(this, target);
lldb::SBData sb_data;
lldb::InstructionSP inst_sp(GetOpaque());
@@ -196,7 +188,7 @@ SBData SBInstruction::GetData(SBTarget target) {
}
bool SBInstruction::DoesBranch() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, DoesBranch);
+ LLDB_INSTRUMENT_VA(this);
lldb::InstructionSP inst_sp(GetOpaque());
if (inst_sp)
@@ -205,7 +197,7 @@ bool SBInstruction::DoesBranch() {
}
bool SBInstruction::HasDelaySlot() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, HasDelaySlot);
+ LLDB_INSTRUMENT_VA(this);
lldb::InstructionSP inst_sp(GetOpaque());
if (inst_sp)
@@ -214,7 +206,7 @@ bool SBInstruction::HasDelaySlot() {
}
bool SBInstruction::CanSetBreakpoint() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, CanSetBreakpoint);
+ LLDB_INSTRUMENT_VA(this);
lldb::InstructionSP inst_sp(GetOpaque());
if (inst_sp)
@@ -235,8 +227,7 @@ void SBInstruction::SetOpaque(const lldb::DisassemblerSP &disasm_sp,
}
bool SBInstruction::GetDescription(lldb::SBStream &s) {
- LLDB_RECORD_METHOD(bool, SBInstruction, GetDescription, (lldb::SBStream &),
- s);
+ LLDB_INSTRUMENT_VA(this, s);
lldb::InstructionSP inst_sp(GetOpaque());
if (inst_sp) {
@@ -257,18 +248,18 @@ bool SBInstruction::GetDescription(lldb::SBStream &s) {
}
void SBInstruction::Print(FILE *outp) {
- LLDB_RECORD_METHOD(void, SBInstruction, Print, (FILE *), outp);
+ LLDB_INSTRUMENT_VA(this, outp);
FileSP out = std::make_shared<NativeFile>(outp, /*take_ownership=*/false);
Print(out);
}
void SBInstruction::Print(SBFile out) {
- LLDB_RECORD_METHOD(void, SBInstruction, Print, (SBFile), out);
+ LLDB_INSTRUMENT_VA(this, out);
Print(out.m_opaque_sp);
}
void SBInstruction::Print(FileSP out_sp) {
- LLDB_RECORD_METHOD(void, SBInstruction, Print, (FileSP), out_sp);
+ LLDB_INSTRUMENT_VA(this, out_sp);
if (!out_sp || !out_sp->IsValid())
return;
@@ -291,8 +282,7 @@ void SBInstruction::Print(FileSP out_sp) {
bool SBInstruction::EmulateWithFrame(lldb::SBFrame &frame,
uint32_t evaluate_options) {
- LLDB_RECORD_METHOD(bool, SBInstruction, EmulateWithFrame,
- (lldb::SBFrame &, uint32_t), frame, evaluate_options);
+ LLDB_INSTRUMENT_VA(this, frame, evaluate_options);
lldb::InstructionSP inst_sp(GetOpaque());
if (inst_sp) {
@@ -316,8 +306,7 @@ bool SBInstruction::EmulateWithFrame(lldb::SBFrame &frame,
}
bool SBInstruction::DumpEmulation(const char *triple) {
- LLDB_RECORD_METHOD(bool, SBInstruction, DumpEmulation, (const char *),
- triple);
+ LLDB_INSTRUMENT_VA(this, triple);
lldb::InstructionSP inst_sp(GetOpaque());
if (inst_sp && triple) {
@@ -328,9 +317,7 @@ bool SBInstruction::DumpEmulation(const char *triple) {
bool SBInstruction::TestEmulation(lldb::SBStream &output_stream,
const char *test_file) {
- LLDB_RECORD_METHOD(bool, SBInstruction, TestEmulation,
- (lldb::SBStream &, const char *), output_stream,
- test_file);
+ LLDB_INSTRUMENT_VA(this, output_stream, test_file);
if (!m_opaque_sp)
SetOpaque(lldb::DisassemblerSP(),
diff --git a/lldb/source/API/SBInstructionList.cpp b/lldb/source/API/SBInstructionList.cpp
index 241c497b7fc3..e289e8e9343d 100644
--- a/lldb/source/API/SBInstructionList.cpp
+++ b/lldb/source/API/SBInstructionList.cpp
@@ -7,35 +7,30 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBInstructionList.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBAddress.h"
+#include "lldb/API/SBFile.h"
#include "lldb/API/SBInstruction.h"
#include "lldb/API/SBStream.h"
-#include "lldb/API/SBFile.h"
#include "lldb/Core/Disassembler.h"
#include "lldb/Core/Module.h"
#include "lldb/Core/StreamFile.h"
#include "lldb/Symbol/SymbolContext.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/Stream.h"
using namespace lldb;
using namespace lldb_private;
-SBInstructionList::SBInstructionList() {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBInstructionList);
-}
+SBInstructionList::SBInstructionList() { LLDB_INSTRUMENT_VA(this); }
SBInstructionList::SBInstructionList(const SBInstructionList &rhs)
: m_opaque_sp(rhs.m_opaque_sp) {
- LLDB_RECORD_CONSTRUCTOR(SBInstructionList, (const lldb::SBInstructionList &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
}
const SBInstructionList &SBInstructionList::
operator=(const SBInstructionList &rhs) {
- LLDB_RECORD_METHOD(
- const lldb::SBInstructionList &,
- SBInstructionList, operator=,(const lldb::SBInstructionList &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_sp = rhs.m_opaque_sp;
@@ -45,17 +40,17 @@ operator=(const SBInstructionList &rhs) {
SBInstructionList::~SBInstructionList() = default;
bool SBInstructionList::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInstructionList, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBInstructionList::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInstructionList, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp.get() != nullptr;
}
size_t SBInstructionList::GetSize() {
- LLDB_RECORD_METHOD_NO_ARGS(size_t, SBInstructionList, GetSize);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp)
return m_opaque_sp->GetInstructionList().GetSize();
@@ -63,8 +58,7 @@ size_t SBInstructionList::GetSize() {
}
SBInstruction SBInstructionList::GetInstructionAtIndex(uint32_t idx) {
- LLDB_RECORD_METHOD(lldb::SBInstruction, SBInstructionList,
- GetInstructionAtIndex, (uint32_t), idx);
+ LLDB_INSTRUMENT_VA(this, idx);
SBInstruction inst;
if (m_opaque_sp && idx < m_opaque_sp->GetInstructionList().GetSize())
@@ -77,9 +71,7 @@ SBInstruction SBInstructionList::GetInstructionAtIndex(uint32_t idx) {
size_t SBInstructionList::GetInstructionsCount(const SBAddress &start,
const SBAddress &end,
bool canSetBreakpoint) {
- LLDB_RECORD_METHOD(size_t, SBInstructionList, GetInstructionsCount,
- (const lldb::SBAddress &, const lldb::SBAddress &, bool),
- start, end, canSetBreakpoint);
+ LLDB_INSTRUMENT_VA(this, start, end, canSetBreakpoint);
size_t num_instructions = GetSize();
size_t i = 0;
@@ -104,14 +96,13 @@ size_t SBInstructionList::GetInstructionsCount(const SBAddress &start,
}
void SBInstructionList::Clear() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBInstructionList, Clear);
+ LLDB_INSTRUMENT_VA(this);
m_opaque_sp.reset();
}
void SBInstructionList::AppendInstruction(SBInstruction insn) {
- LLDB_RECORD_METHOD(void, SBInstructionList, AppendInstruction,
- (lldb::SBInstruction), insn);
+ LLDB_INSTRUMENT_VA(this, insn);
}
void SBInstructionList::SetDisassembler(const lldb::DisassemblerSP &opaque_sp) {
@@ -119,7 +110,7 @@ void SBInstructionList::SetDisassembler(const lldb::DisassemblerSP &opaque_sp) {
}
void SBInstructionList::Print(FILE *out) {
- LLDB_RECORD_METHOD(void, SBInstructionList, Print, (FILE *), out);
+ LLDB_INSTRUMENT_VA(this, out);
if (out == nullptr)
return;
StreamFile stream(out, false);
@@ -127,7 +118,7 @@ void SBInstructionList::Print(FILE *out) {
}
void SBInstructionList::Print(SBFile out) {
- LLDB_RECORD_METHOD(void, SBInstructionList, Print, (SBFile), out);
+ LLDB_INSTRUMENT_VA(this, out);
if (!out.IsValid())
return;
StreamFile stream(out.m_opaque_sp);
@@ -135,7 +126,7 @@ void SBInstructionList::Print(SBFile out) {
}
void SBInstructionList::Print(FileSP out_sp) {
- LLDB_RECORD_METHOD(void, SBInstructionList, Print, (FileSP), out_sp);
+ LLDB_INSTRUMENT_VA(this, out_sp);
if (!out_sp || !out_sp->IsValid())
return;
StreamFile stream(out_sp);
@@ -143,8 +134,7 @@ void SBInstructionList::Print(FileSP out_sp) {
}
bool SBInstructionList::GetDescription(lldb::SBStream &stream) {
- LLDB_RECORD_METHOD(bool, SBInstructionList, GetDescription,
- (lldb::SBStream &), stream);
+ LLDB_INSTRUMENT_VA(this, stream);
return GetDescription(stream.ref());
}
@@ -186,8 +176,7 @@ bool SBInstructionList::GetDescription(Stream &sref) {
}
bool SBInstructionList::DumpEmulationForAllInstructions(const char *triple) {
- LLDB_RECORD_METHOD(bool, SBInstructionList, DumpEmulationForAllInstructions,
- (const char *), triple);
+ LLDB_INSTRUMENT_VA(this, triple);
if (m_opaque_sp) {
size_t len = GetSize();
diff --git a/lldb/source/API/SBLanguageRuntime.cpp b/lldb/source/API/SBLanguageRuntime.cpp
index 781c985fc042..d571f282fce0 100644
--- a/lldb/source/API/SBLanguageRuntime.cpp
+++ b/lldb/source/API/SBLanguageRuntime.cpp
@@ -7,25 +7,22 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBLanguageRuntime.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/Target/Language.h"
+#include "lldb/Utility/Instrumentation.h"
using namespace lldb;
using namespace lldb_private;
lldb::LanguageType
SBLanguageRuntime::GetLanguageTypeFromString(const char *string) {
- LLDB_RECORD_STATIC_METHOD(lldb::LanguageType, SBLanguageRuntime,
- GetLanguageTypeFromString, (const char *), string);
+ LLDB_INSTRUMENT_VA(string);
return Language::GetLanguageTypeFromString(llvm::StringRef(string));
}
const char *
SBLanguageRuntime::GetNameForLanguageType(lldb::LanguageType language) {
- LLDB_RECORD_STATIC_METHOD(const char *, SBLanguageRuntime,
- GetNameForLanguageType, (lldb::LanguageType),
- language);
+ LLDB_INSTRUMENT_VA(language);
return Language::GetNameForLanguageType(language);
}
diff --git a/lldb/source/API/SBLaunchInfo.cpp b/lldb/source/API/SBLaunchInfo.cpp
index f47fa5a4ba20..5149feba5e0b 100644
--- a/lldb/source/API/SBLaunchInfo.cpp
+++ b/lldb/source/API/SBLaunchInfo.cpp
@@ -7,7 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBLaunchInfo.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/API/SBEnvironment.h"
#include "lldb/API/SBError.h"
@@ -40,7 +40,7 @@ class lldb_private::SBLaunchInfoImpl : public ProcessLaunchInfo {
SBLaunchInfo::SBLaunchInfo(const char **argv)
: m_opaque_sp(new SBLaunchInfoImpl()) {
- LLDB_RECORD_CONSTRUCTOR(SBLaunchInfo, (const char **), argv);
+ LLDB_INSTRUMENT_VA(this, argv);
m_opaque_sp->GetFlags().Reset(eLaunchFlagDebug | eLaunchFlagDisableASLR);
if (argv && argv[0])
@@ -48,14 +48,13 @@ SBLaunchInfo::SBLaunchInfo(const char **argv)
}
SBLaunchInfo::SBLaunchInfo(const SBLaunchInfo &rhs) {
- LLDB_RECORD_CONSTRUCTOR(SBLaunchInfo, (const lldb::SBLaunchInfo &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_sp = rhs.m_opaque_sp;
}
SBLaunchInfo &SBLaunchInfo::operator=(const SBLaunchInfo &rhs) {
- LLDB_RECORD_METHOD(SBLaunchInfo &,
- SBLaunchInfo, operator=,(const lldb::SBLaunchInfo &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_sp = rhs.m_opaque_sp;
return *this;
@@ -72,90 +71,86 @@ void SBLaunchInfo::set_ref(const ProcessLaunchInfo &info) {
}
lldb::pid_t SBLaunchInfo::GetProcessID() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBLaunchInfo, GetProcessID);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetProcessID();
}
uint32_t SBLaunchInfo::GetUserID() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetUserID);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetUserID();
}
uint32_t SBLaunchInfo::GetGroupID() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetGroupID);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetGroupID();
}
bool SBLaunchInfo::UserIDIsValid() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBLaunchInfo, UserIDIsValid);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->UserIDIsValid();
}
bool SBLaunchInfo::GroupIDIsValid() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBLaunchInfo, GroupIDIsValid);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GroupIDIsValid();
}
void SBLaunchInfo::SetUserID(uint32_t uid) {
- LLDB_RECORD_METHOD(void, SBLaunchInfo, SetUserID, (uint32_t), uid);
+ LLDB_INSTRUMENT_VA(this, uid);
m_opaque_sp->SetUserID(uid);
}
void SBLaunchInfo::SetGroupID(uint32_t gid) {
- LLDB_RECORD_METHOD(void, SBLaunchInfo, SetGroupID, (uint32_t), gid);
+ LLDB_INSTRUMENT_VA(this, gid);
m_opaque_sp->SetGroupID(gid);
}
SBFileSpec SBLaunchInfo::GetExecutableFile() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBLaunchInfo, GetExecutableFile);
+ LLDB_INSTRUMENT_VA(this);
return SBFileSpec(m_opaque_sp->GetExecutableFile());
}
void SBLaunchInfo::SetExecutableFile(SBFileSpec exe_file,
bool add_as_first_arg) {
- LLDB_RECORD_METHOD(void, SBLaunchInfo, SetExecutableFile,
- (lldb::SBFileSpec, bool), exe_file, add_as_first_arg);
+ LLDB_INSTRUMENT_VA(this, exe_file, add_as_first_arg);
m_opaque_sp->SetExecutableFile(exe_file.ref(), add_as_first_arg);
}
SBListener SBLaunchInfo::GetListener() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBLaunchInfo, GetListener);
+ LLDB_INSTRUMENT_VA(this);
return SBListener(m_opaque_sp->GetListener());
}
void SBLaunchInfo::SetListener(SBListener &listener) {
- LLDB_RECORD_METHOD(void, SBLaunchInfo, SetListener, (lldb::SBListener &),
- listener);
+ LLDB_INSTRUMENT_VA(this, listener);
m_opaque_sp->SetListener(listener.GetSP());
}
uint32_t SBLaunchInfo::GetNumArguments() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetNumArguments);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetArguments().GetArgumentCount();
}
const char *SBLaunchInfo::GetArgumentAtIndex(uint32_t idx) {
- LLDB_RECORD_METHOD(const char *, SBLaunchInfo, GetArgumentAtIndex, (uint32_t),
- idx);
+ LLDB_INSTRUMENT_VA(this, idx);
return m_opaque_sp->GetArguments().GetArgumentAtIndex(idx);
}
void SBLaunchInfo::SetArguments(const char **argv, bool append) {
- LLDB_RECORD_METHOD(void, SBLaunchInfo, SetArguments, (const char **, bool),
- argv, append);
+ LLDB_INSTRUMENT_VA(this, argv, append);
if (append) {
if (argv)
@@ -169,14 +164,13 @@ void SBLaunchInfo::SetArguments(const char **argv, bool append) {
}
uint32_t SBLaunchInfo::GetNumEnvironmentEntries() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetNumEnvironmentEntries);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetEnvironment().size();
}
const char *SBLaunchInfo::GetEnvironmentEntryAtIndex(uint32_t idx) {
- LLDB_RECORD_METHOD(const char *, SBLaunchInfo, GetEnvironmentEntryAtIndex,
- (uint32_t), idx);
+ LLDB_INSTRUMENT_VA(this, idx);
if (idx > GetNumEnvironmentEntries())
return nullptr;
@@ -184,14 +178,12 @@ const char *SBLaunchInfo::GetEnvironmentEntryAtIndex(uint32_t idx) {
}
void SBLaunchInfo::SetEnvironmentEntries(const char **envp, bool append) {
- LLDB_RECORD_METHOD(void, SBLaunchInfo, SetEnvironmentEntries,
- (const char **, bool), envp, append);
+ LLDB_INSTRUMENT_VA(this, envp, append);
SetEnvironment(SBEnvironment(Environment(envp)), append);
}
void SBLaunchInfo::SetEnvironment(const SBEnvironment &env, bool append) {
- LLDB_RECORD_METHOD(void, SBLaunchInfo, SetEnvironment,
- (const lldb::SBEnvironment &, bool), env, append);
+ LLDB_INSTRUMENT_VA(this, env, append);
Environment &refEnv = env.ref();
if (append) {
for (auto &KV : refEnv)
@@ -202,57 +194,54 @@ void SBLaunchInfo::SetEnvironment(const SBEnvironment &env, bool append) {
}
SBEnvironment SBLaunchInfo::GetEnvironment() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBEnvironment, SBLaunchInfo, GetEnvironment);
+ LLDB_INSTRUMENT_VA(this);
return SBEnvironment(Environment(m_opaque_sp->GetEnvironment()));
}
void SBLaunchInfo::Clear() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBLaunchInfo, Clear);
+ LLDB_INSTRUMENT_VA(this);
m_opaque_sp->Clear();
}
const char *SBLaunchInfo::GetWorkingDirectory() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBLaunchInfo,
- GetWorkingDirectory);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetWorkingDirectory().GetCString();
}
void SBLaunchInfo::SetWorkingDirectory(const char *working_dir) {
- LLDB_RECORD_METHOD(void, SBLaunchInfo, SetWorkingDirectory, (const char *),
- working_dir);
+ LLDB_INSTRUMENT_VA(this, working_dir);
m_opaque_sp->SetWorkingDirectory(FileSpec(working_dir));
}
uint32_t SBLaunchInfo::GetLaunchFlags() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetLaunchFlags);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetFlags().Get();
}
void SBLaunchInfo::SetLaunchFlags(uint32_t flags) {
- LLDB_RECORD_METHOD(void, SBLaunchInfo, SetLaunchFlags, (uint32_t), flags);
+ LLDB_INSTRUMENT_VA(this, flags);
m_opaque_sp->GetFlags().Reset(flags);
}
const char *SBLaunchInfo::GetProcessPluginName() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBLaunchInfo, GetProcessPluginName);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetProcessPluginName();
}
void SBLaunchInfo::SetProcessPluginName(const char *plugin_name) {
- LLDB_RECORD_METHOD(void, SBLaunchInfo, SetProcessPluginName, (const char *),
- plugin_name);
+ LLDB_INSTRUMENT_VA(this, plugin_name);
return m_opaque_sp->SetProcessPluginName(plugin_name);
}
const char *SBLaunchInfo::GetShell() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBLaunchInfo, GetShell);
+ LLDB_INSTRUMENT_VA(this);
// Constify this string so that it is saved in the string pool. Otherwise it
// would be freed when this function goes out of scope.
@@ -261,93 +250,86 @@ const char *SBLaunchInfo::GetShell() {
}
void SBLaunchInfo::SetShell(const char *path) {
- LLDB_RECORD_METHOD(void, SBLaunchInfo, SetShell, (const char *), path);
+ LLDB_INSTRUMENT_VA(this, path);
m_opaque_sp->SetShell(FileSpec(path));
}
bool SBLaunchInfo::GetShellExpandArguments() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBLaunchInfo, GetShellExpandArguments);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetShellExpandArguments();
}
void SBLaunchInfo::SetShellExpandArguments(bool expand) {
- LLDB_RECORD_METHOD(void, SBLaunchInfo, SetShellExpandArguments, (bool),
- expand);
+ LLDB_INSTRUMENT_VA(this, expand);
m_opaque_sp->SetShellExpandArguments(expand);
}
uint32_t SBLaunchInfo::GetResumeCount() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetResumeCount);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetResumeCount();
}
void SBLaunchInfo::SetResumeCount(uint32_t c) {
- LLDB_RECORD_METHOD(void, SBLaunchInfo, SetResumeCount, (uint32_t), c);
+ LLDB_INSTRUMENT_VA(this, c);
m_opaque_sp->SetResumeCount(c);
}
bool SBLaunchInfo::AddCloseFileAction(int fd) {
- LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddCloseFileAction, (int), fd);
+ LLDB_INSTRUMENT_VA(this, fd);
return m_opaque_sp->AppendCloseFileAction(fd);
}
bool SBLaunchInfo::AddDuplicateFileAction(int fd, int dup_fd) {
- LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddDuplicateFileAction, (int, int), fd,
- dup_fd);
+ LLDB_INSTRUMENT_VA(this, fd, dup_fd);
return m_opaque_sp->AppendDuplicateFileAction(fd, dup_fd);
}
bool SBLaunchInfo::AddOpenFileAction(int fd, const char *path, bool read,
bool write) {
- LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddOpenFileAction,
- (int, const char *, bool, bool), fd, path, read, write);
+ LLDB_INSTRUMENT_VA(this, fd, path, read, write);
return m_opaque_sp->AppendOpenFileAction(fd, FileSpec(path), read, write);
}
bool SBLaunchInfo::AddSuppressFileAction(int fd, bool read, bool write) {
- LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddSuppressFileAction,
- (int, bool, bool), fd, read, write);
+ LLDB_INSTRUMENT_VA(this, fd, read, write);
return m_opaque_sp->AppendSuppressFileAction(fd, read, write);
}
void SBLaunchInfo::SetLaunchEventData(const char *data) {
- LLDB_RECORD_METHOD(void, SBLaunchInfo, SetLaunchEventData, (const char *),
- data);
+ LLDB_INSTRUMENT_VA(this, data);
m_opaque_sp->SetLaunchEventData(data);
}
const char *SBLaunchInfo::GetLaunchEventData() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBLaunchInfo,
- GetLaunchEventData);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetLaunchEventData();
}
void SBLaunchInfo::SetDetachOnError(bool enable) {
- LLDB_RECORD_METHOD(void, SBLaunchInfo, SetDetachOnError, (bool), enable);
+ LLDB_INSTRUMENT_VA(this, enable);
m_opaque_sp->SetDetachOnError(enable);
}
bool SBLaunchInfo::GetDetachOnError() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBLaunchInfo, GetDetachOnError);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetDetachOnError();
}
const char *SBLaunchInfo::GetScriptedProcessClassName() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBLaunchInfo,
- GetScriptedProcessClassName);
+ LLDB_INSTRUMENT_VA(this);
// Constify this string so that it is saved in the string pool. Otherwise it
// would be freed when this function goes out of scope.
@@ -356,15 +338,13 @@ const char *SBLaunchInfo::GetScriptedProcessClassName() const {
}
void SBLaunchInfo::SetScriptedProcessClassName(const char *class_name) {
- LLDB_RECORD_METHOD(void, SBLaunchInfo, SetScriptedProcessClassName,
- (const char *), class_name);
+ LLDB_INSTRUMENT_VA(this, class_name);
m_opaque_sp->SetScriptedProcessClassName(class_name);
}
lldb::SBStructuredData SBLaunchInfo::GetScriptedProcessDictionary() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBStructuredData, SBLaunchInfo,
- GetScriptedProcessDictionary);
+ LLDB_INSTRUMENT_VA(this);
lldb_private::StructuredData::DictionarySP dict_sp =
m_opaque_sp->GetScriptedProcessDictionarySP();
@@ -376,8 +356,7 @@ lldb::SBStructuredData SBLaunchInfo::GetScriptedProcessDictionary() const {
}
void SBLaunchInfo::SetScriptedProcessDictionary(lldb::SBStructuredData dict) {
- LLDB_RECORD_METHOD(void, SBLaunchInfo, SetScriptedProcessDictionary,
- (lldb::SBStructuredData), dict);
+ LLDB_INSTRUMENT_VA(this, dict);
if (!dict.IsValid() || !dict.m_impl_up)
return;
diff --git a/lldb/source/API/SBLineEntry.cpp b/lldb/source/API/SBLineEntry.cpp
index 52623b624534..28d12e65fdaf 100644
--- a/lldb/source/API/SBLineEntry.cpp
+++ b/lldb/source/API/SBLineEntry.cpp
@@ -7,11 +7,11 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBLineEntry.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/API/SBStream.h"
#include "lldb/Host/PosixApi.h"
#include "lldb/Symbol/LineEntry.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/StreamString.h"
#include <climits>
@@ -19,10 +19,10 @@
using namespace lldb;
using namespace lldb_private;
-SBLineEntry::SBLineEntry() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBLineEntry); }
+SBLineEntry::SBLineEntry() { LLDB_INSTRUMENT_VA(this); }
SBLineEntry::SBLineEntry(const SBLineEntry &rhs) {
- LLDB_RECORD_CONSTRUCTOR(SBLineEntry, (const lldb::SBLineEntry &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_up = clone(rhs.m_opaque_up);
}
@@ -33,8 +33,7 @@ SBLineEntry::SBLineEntry(const lldb_private::LineEntry *lldb_object_ptr) {
}
const SBLineEntry &SBLineEntry::operator=(const SBLineEntry &rhs) {
- LLDB_RECORD_METHOD(const lldb::SBLineEntry &,
- SBLineEntry, operator=,(const lldb::SBLineEntry &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
@@ -48,8 +47,7 @@ void SBLineEntry::SetLineEntry(const lldb_private::LineEntry &lldb_object_ref) {
SBLineEntry::~SBLineEntry() = default;
SBAddress SBLineEntry::GetStartAddress() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBLineEntry,
- GetStartAddress);
+ LLDB_INSTRUMENT_VA(this);
SBAddress sb_address;
if (m_opaque_up)
@@ -59,7 +57,7 @@ SBAddress SBLineEntry::GetStartAddress() const {
}
SBAddress SBLineEntry::GetEndAddress() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBLineEntry, GetEndAddress);
+ LLDB_INSTRUMENT_VA(this);
SBAddress sb_address;
if (m_opaque_up) {
@@ -70,17 +68,17 @@ SBAddress SBLineEntry::GetEndAddress() const {
}
bool SBLineEntry::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBLineEntry, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBLineEntry::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBLineEntry, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up.get() && m_opaque_up->IsValid();
}
SBFileSpec SBLineEntry::GetFileSpec() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBLineEntry, GetFileSpec);
+ LLDB_INSTRUMENT_VA(this);
SBFileSpec sb_file_spec;
if (m_opaque_up.get() && m_opaque_up->file)
@@ -90,7 +88,7 @@ SBFileSpec SBLineEntry::GetFileSpec() const {
}
uint32_t SBLineEntry::GetLine() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBLineEntry, GetLine);
+ LLDB_INSTRUMENT_VA(this);
uint32_t line = 0;
if (m_opaque_up)
@@ -100,7 +98,7 @@ uint32_t SBLineEntry::GetLine() const {
}
uint32_t SBLineEntry::GetColumn() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBLineEntry, GetColumn);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_up)
return m_opaque_up->column;
@@ -108,8 +106,7 @@ uint32_t SBLineEntry::GetColumn() const {
}
void SBLineEntry::SetFileSpec(lldb::SBFileSpec filespec) {
- LLDB_RECORD_METHOD(void, SBLineEntry, SetFileSpec, (lldb::SBFileSpec),
- filespec);
+ LLDB_INSTRUMENT_VA(this, filespec);
if (filespec.IsValid())
ref().file = filespec.ref();
@@ -117,20 +114,19 @@ void SBLineEntry::SetFileSpec(lldb::SBFileSpec filespec) {
ref().file.Clear();
}
void SBLineEntry::SetLine(uint32_t line) {
- LLDB_RECORD_METHOD(void, SBLineEntry, SetLine, (uint32_t), line);
+ LLDB_INSTRUMENT_VA(this, line);
ref().line = line;
}
void SBLineEntry::SetColumn(uint32_t column) {
- LLDB_RECORD_METHOD(void, SBLineEntry, SetColumn, (uint32_t), column);
+ LLDB_INSTRUMENT_VA(this, column);
ref().line = column;
}
bool SBLineEntry::operator==(const SBLineEntry &rhs) const {
- LLDB_RECORD_METHOD_CONST(
- bool, SBLineEntry, operator==,(const lldb::SBLineEntry &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
lldb_private::LineEntry *lhs_ptr = m_opaque_up.get();
lldb_private::LineEntry *rhs_ptr = rhs.m_opaque_up.get();
@@ -142,8 +138,7 @@ bool SBLineEntry::operator==(const SBLineEntry &rhs) const {
}
bool SBLineEntry::operator!=(const SBLineEntry &rhs) const {
- LLDB_RECORD_METHOD_CONST(
- bool, SBLineEntry, operator!=,(const lldb::SBLineEntry &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
lldb_private::LineEntry *lhs_ptr = m_opaque_up.get();
lldb_private::LineEntry *rhs_ptr = rhs.m_opaque_up.get();
@@ -167,8 +162,7 @@ lldb_private::LineEntry &SBLineEntry::ref() {
const lldb_private::LineEntry &SBLineEntry::ref() const { return *m_opaque_up; }
bool SBLineEntry::GetDescription(SBStream &description) {
- LLDB_RECORD_METHOD(bool, SBLineEntry, GetDescription, (lldb::SBStream &),
- description);
+ LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();
diff --git a/lldb/source/API/SBListener.cpp b/lldb/source/API/SBListener.cpp
index 50e7abd951d0..2ce17a5f521d 100644
--- a/lldb/source/API/SBListener.cpp
+++ b/lldb/source/API/SBListener.cpp
@@ -7,34 +7,33 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBListener.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBBroadcaster.h"
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBEvent.h"
#include "lldb/API/SBStream.h"
#include "lldb/Core/Debugger.h"
#include "lldb/Utility/Broadcaster.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/Listener.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb;
using namespace lldb_private;
-SBListener::SBListener() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBListener); }
+SBListener::SBListener() { LLDB_INSTRUMENT_VA(this); }
SBListener::SBListener(const char *name)
: m_opaque_sp(Listener::MakeListener(name)), m_unused_ptr(nullptr) {
- LLDB_RECORD_CONSTRUCTOR(SBListener, (const char *), name);
+ LLDB_INSTRUMENT_VA(this, name);
}
SBListener::SBListener(const SBListener &rhs)
: m_opaque_sp(rhs.m_opaque_sp), m_unused_ptr(nullptr) {
- LLDB_RECORD_CONSTRUCTOR(SBListener, (const lldb::SBListener &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
}
const lldb::SBListener &SBListener::operator=(const lldb::SBListener &rhs) {
- LLDB_RECORD_METHOD(const lldb::SBListener &,
- SBListener, operator=,(const lldb::SBListener &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
@@ -49,18 +48,17 @@ SBListener::SBListener(const lldb::ListenerSP &listener_sp)
SBListener::~SBListener() = default;
bool SBListener::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBListener, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBListener::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBListener, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp != nullptr;
}
void SBListener::AddEvent(const SBEvent &event) {
- LLDB_RECORD_METHOD(void, SBListener, AddEvent, (const lldb::SBEvent &),
- event);
+ LLDB_INSTRUMENT_VA(this, event);
EventSP &event_sp = event.GetSP();
if (event_sp)
@@ -68,7 +66,7 @@ void SBListener::AddEvent(const SBEvent &event) {
}
void SBListener::Clear() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBListener, Clear);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp)
m_opaque_sp->Clear();
@@ -77,9 +75,7 @@ void SBListener::Clear() {
uint32_t SBListener::StartListeningForEventClass(SBDebugger &debugger,
const char *broadcaster_class,
uint32_t event_mask) {
- LLDB_RECORD_METHOD(uint32_t, SBListener, StartListeningForEventClass,
- (lldb::SBDebugger &, const char *, uint32_t), debugger,
- broadcaster_class, event_mask);
+ LLDB_INSTRUMENT_VA(this, debugger, broadcaster_class, event_mask);
if (m_opaque_sp) {
Debugger *lldb_debugger = debugger.get();
@@ -95,9 +91,7 @@ uint32_t SBListener::StartListeningForEventClass(SBDebugger &debugger,
bool SBListener::StopListeningForEventClass(SBDebugger &debugger,
const char *broadcaster_class,
uint32_t event_mask) {
- LLDB_RECORD_METHOD(bool, SBListener, StopListeningForEventClass,
- (lldb::SBDebugger &, const char *, uint32_t), debugger,
- broadcaster_class, event_mask);
+ LLDB_INSTRUMENT_VA(this, debugger, broadcaster_class, event_mask);
if (m_opaque_sp) {
Debugger *lldb_debugger = debugger.get();
@@ -112,9 +106,7 @@ bool SBListener::StopListeningForEventClass(SBDebugger &debugger,
uint32_t SBListener::StartListeningForEvents(const SBBroadcaster &broadcaster,
uint32_t event_mask) {
- LLDB_RECORD_METHOD(uint32_t, SBListener, StartListeningForEvents,
- (const lldb::SBBroadcaster &, uint32_t), broadcaster,
- event_mask);
+ LLDB_INSTRUMENT_VA(this, broadcaster, event_mask);
uint32_t acquired_event_mask = 0;
if (m_opaque_sp && broadcaster.IsValid()) {
@@ -127,9 +119,7 @@ uint32_t SBListener::StartListeningForEvents(const SBBroadcaster &broadcaster,
bool SBListener::StopListeningForEvents(const SBBroadcaster &broadcaster,
uint32_t event_mask) {
- LLDB_RECORD_METHOD(bool, SBListener, StopListeningForEvents,
- (const lldb::SBBroadcaster &, uint32_t), broadcaster,
- event_mask);
+ LLDB_INSTRUMENT_VA(this, broadcaster, event_mask);
if (m_opaque_sp && broadcaster.IsValid()) {
return m_opaque_sp->StopListeningForEvents(broadcaster.get(), event_mask);
@@ -138,8 +128,7 @@ bool SBListener::StopListeningForEvents(const SBBroadcaster &broadcaster,
}
bool SBListener::WaitForEvent(uint32_t timeout_secs, SBEvent &event) {
- LLDB_RECORD_METHOD(bool, SBListener, WaitForEvent,
- (uint32_t, lldb::SBEvent &), timeout_secs, event);
+ LLDB_INSTRUMENT_VA(this, timeout_secs, event);
bool success = false;
@@ -165,9 +154,7 @@ bool SBListener::WaitForEvent(uint32_t timeout_secs, SBEvent &event) {
bool SBListener::WaitForEventForBroadcaster(uint32_t num_seconds,
const SBBroadcaster &broadcaster,
SBEvent &event) {
- LLDB_RECORD_METHOD(bool, SBListener, WaitForEventForBroadcaster,
- (uint32_t, const lldb::SBBroadcaster &, lldb::SBEvent &),
- num_seconds, broadcaster, event);
+ LLDB_INSTRUMENT_VA(this, num_seconds, broadcaster, event);
if (m_opaque_sp && broadcaster.IsValid()) {
Timeout<std::micro> timeout(llvm::None);
@@ -187,10 +174,7 @@ bool SBListener::WaitForEventForBroadcaster(uint32_t num_seconds,
bool SBListener::WaitForEventForBroadcasterWithType(
uint32_t num_seconds, const SBBroadcaster &broadcaster,
uint32_t event_type_mask, SBEvent &event) {
- LLDB_RECORD_METHOD(
- bool, SBListener, WaitForEventForBroadcasterWithType,
- (uint32_t, const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &),
- num_seconds, broadcaster, event_type_mask, event);
+ LLDB_INSTRUMENT_VA(this, num_seconds, broadcaster, event_type_mask, event);
if (m_opaque_sp && broadcaster.IsValid()) {
Timeout<std::micro> timeout(llvm::None);
@@ -208,8 +192,7 @@ bool SBListener::WaitForEventForBroadcasterWithType(
}
bool SBListener::PeekAtNextEvent(SBEvent &event) {
- LLDB_RECORD_METHOD(bool, SBListener, PeekAtNextEvent, (lldb::SBEvent &),
- event);
+ LLDB_INSTRUMENT_VA(this, event);
if (m_opaque_sp) {
event.reset(m_opaque_sp->PeekAtNextEvent());
@@ -221,9 +204,7 @@ bool SBListener::PeekAtNextEvent(SBEvent &event) {
bool SBListener::PeekAtNextEventForBroadcaster(const SBBroadcaster &broadcaster,
SBEvent &event) {
- LLDB_RECORD_METHOD(bool, SBListener, PeekAtNextEventForBroadcaster,
- (const lldb::SBBroadcaster &, lldb::SBEvent &),
- broadcaster, event);
+ LLDB_INSTRUMENT_VA(this, broadcaster, event);
if (m_opaque_sp && broadcaster.IsValid()) {
event.reset(m_opaque_sp->PeekAtNextEventForBroadcaster(broadcaster.get()));
@@ -236,9 +217,7 @@ bool SBListener::PeekAtNextEventForBroadcaster(const SBBroadcaster &broadcaster,
bool SBListener::PeekAtNextEventForBroadcasterWithType(
const SBBroadcaster &broadcaster, uint32_t event_type_mask,
SBEvent &event) {
- LLDB_RECORD_METHOD(bool, SBListener, PeekAtNextEventForBroadcasterWithType,
- (const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &),
- broadcaster, event_type_mask, event);
+ LLDB_INSTRUMENT_VA(this, broadcaster, event_type_mask, event);
if (m_opaque_sp && broadcaster.IsValid()) {
event.reset(m_opaque_sp->PeekAtNextEventForBroadcasterWithType(
@@ -250,7 +229,7 @@ bool SBListener::PeekAtNextEventForBroadcasterWithType(
}
bool SBListener::GetNextEvent(SBEvent &event) {
- LLDB_RECORD_METHOD(bool, SBListener, GetNextEvent, (lldb::SBEvent &), event);
+ LLDB_INSTRUMENT_VA(this, event);
if (m_opaque_sp) {
EventSP event_sp;
@@ -265,9 +244,7 @@ bool SBListener::GetNextEvent(SBEvent &event) {
bool SBListener::GetNextEventForBroadcaster(const SBBroadcaster &broadcaster,
SBEvent &event) {
- LLDB_RECORD_METHOD(bool, SBListener, GetNextEventForBroadcaster,
- (const lldb::SBBroadcaster &, lldb::SBEvent &),
- broadcaster, event);
+ LLDB_INSTRUMENT_VA(this, broadcaster, event);
if (m_opaque_sp && broadcaster.IsValid()) {
EventSP event_sp;
@@ -284,9 +261,7 @@ bool SBListener::GetNextEventForBroadcaster(const SBBroadcaster &broadcaster,
bool SBListener::GetNextEventForBroadcasterWithType(
const SBBroadcaster &broadcaster, uint32_t event_type_mask,
SBEvent &event) {
- LLDB_RECORD_METHOD(bool, SBListener, GetNextEventForBroadcasterWithType,
- (const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &),
- broadcaster, event_type_mask, event);
+ LLDB_INSTRUMENT_VA(this, broadcaster, event_type_mask, event);
if (m_opaque_sp && broadcaster.IsValid()) {
EventSP event_sp;
@@ -302,8 +277,7 @@ bool SBListener::GetNextEventForBroadcasterWithType(
}
bool SBListener::HandleBroadcastEvent(const SBEvent &event) {
- LLDB_RECORD_METHOD(bool, SBListener, HandleBroadcastEvent,
- (const lldb::SBEvent &), event);
+ LLDB_INSTRUMENT_VA(this, event);
if (m_opaque_sp)
return m_opaque_sp->HandleBroadcastEvent(event.GetSP());
diff --git a/lldb/source/API/SBMemoryRegionInfo.cpp b/lldb/source/API/SBMemoryRegionInfo.cpp
index 1a0fb7c74230..7d9db478dde1 100644
--- a/lldb/source/API/SBMemoryRegionInfo.cpp
+++ b/lldb/source/API/SBMemoryRegionInfo.cpp
@@ -7,29 +7,26 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBMemoryRegionInfo.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/API/SBDefines.h"
#include "lldb/API/SBError.h"
#include "lldb/API/SBStream.h"
#include "lldb/Target/MemoryRegionInfo.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb;
using namespace lldb_private;
SBMemoryRegionInfo::SBMemoryRegionInfo() : m_opaque_up(new MemoryRegionInfo()) {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBMemoryRegionInfo);
+ LLDB_INSTRUMENT_VA(this);
}
SBMemoryRegionInfo::SBMemoryRegionInfo(const char *name, lldb::addr_t begin,
lldb::addr_t end, uint32_t permissions,
bool mapped, bool stack_memory)
: SBMemoryRegionInfo() {
- LLDB_RECORD_CONSTRUCTOR(
- SBMemoryRegionInfo,
- (const char *, lldb::addr_t, lldb::addr_t, uint32_t, bool, bool), name,
- begin, end, permissions, mapped, stack_memory);
+ LLDB_INSTRUMENT_VA(this, name, begin, end, permissions, mapped, stack_memory);
m_opaque_up->SetName(name);
m_opaque_up->GetRange().SetRangeBase(begin);
m_opaque_up->GetRange().SetRangeEnd(end);
@@ -47,16 +44,13 @@ SBMemoryRegionInfo::SBMemoryRegionInfo(const MemoryRegionInfo *lldb_object_ptr)
}
SBMemoryRegionInfo::SBMemoryRegionInfo(const SBMemoryRegionInfo &rhs) {
- LLDB_RECORD_CONSTRUCTOR(SBMemoryRegionInfo,
- (const lldb::SBMemoryRegionInfo &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_up = clone(rhs.m_opaque_up);
}
const SBMemoryRegionInfo &SBMemoryRegionInfo::
operator=(const SBMemoryRegionInfo &rhs) {
- LLDB_RECORD_METHOD(
- const lldb::SBMemoryRegionInfo &,
- SBMemoryRegionInfo, operator=,(const lldb::SBMemoryRegionInfo &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
@@ -66,23 +60,19 @@ operator=(const SBMemoryRegionInfo &rhs) {
SBMemoryRegionInfo::~SBMemoryRegionInfo() = default;
void SBMemoryRegionInfo::Clear() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBMemoryRegionInfo, Clear);
+ LLDB_INSTRUMENT_VA(this);
m_opaque_up->Clear();
}
bool SBMemoryRegionInfo::operator==(const SBMemoryRegionInfo &rhs) const {
- LLDB_RECORD_METHOD_CONST(
- bool, SBMemoryRegionInfo, operator==,(const lldb::SBMemoryRegionInfo &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
return ref() == rhs.ref();
}
bool SBMemoryRegionInfo::operator!=(const SBMemoryRegionInfo &rhs) const {
- LLDB_RECORD_METHOD_CONST(
- bool, SBMemoryRegionInfo, operator!=,(const lldb::SBMemoryRegionInfo &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
return ref() != rhs.ref();
}
@@ -92,55 +82,55 @@ MemoryRegionInfo &SBMemoryRegionInfo::ref() { return *m_opaque_up; }
const MemoryRegionInfo &SBMemoryRegionInfo::ref() const { return *m_opaque_up; }
lldb::addr_t SBMemoryRegionInfo::GetRegionBase() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBMemoryRegionInfo, GetRegionBase);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetRange().GetRangeBase();
}
lldb::addr_t SBMemoryRegionInfo::GetRegionEnd() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBMemoryRegionInfo, GetRegionEnd);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetRange().GetRangeEnd();
}
bool SBMemoryRegionInfo::IsReadable() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsReadable);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetReadable() == MemoryRegionInfo::eYes;
}
bool SBMemoryRegionInfo::IsWritable() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsWritable);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetWritable() == MemoryRegionInfo::eYes;
}
bool SBMemoryRegionInfo::IsExecutable() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsExecutable);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetExecutable() == MemoryRegionInfo::eYes;
}
bool SBMemoryRegionInfo::IsMapped() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsMapped);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetMapped() == MemoryRegionInfo::eYes;
}
const char *SBMemoryRegionInfo::GetName() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBMemoryRegionInfo, GetName);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetName().AsCString();
}
bool SBMemoryRegionInfo::HasDirtyMemoryPageList() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, HasDirtyMemoryPageList);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetDirtyPageList().hasValue();
}
uint32_t SBMemoryRegionInfo::GetNumDirtyPages() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBMemoryRegionInfo, GetNumDirtyPages);
+ LLDB_INSTRUMENT_VA(this);
uint32_t num_dirty_pages = 0;
llvm::Optional<std::vector<addr_t>> dirty_page_list =
@@ -152,8 +142,7 @@ uint32_t SBMemoryRegionInfo::GetNumDirtyPages() {
}
addr_t SBMemoryRegionInfo::GetDirtyPageAddressAtIndex(uint32_t idx) {
- LLDB_RECORD_METHOD(lldb::addr_t, SBMemoryRegionInfo,
- GetDirtyPageAddressAtIndex, (uint32_t), idx);
+ LLDB_INSTRUMENT_VA(this, idx);
addr_t dirty_page_addr = LLDB_INVALID_ADDRESS;
const llvm::Optional<std::vector<addr_t>> &dirty_page_list =
@@ -165,14 +154,13 @@ addr_t SBMemoryRegionInfo::GetDirtyPageAddressAtIndex(uint32_t idx) {
}
int SBMemoryRegionInfo::GetPageSize() {
- LLDB_RECORD_METHOD_NO_ARGS(int, SBMemoryRegionInfo, GetPageSize);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetPageSize();
}
bool SBMemoryRegionInfo::GetDescription(SBStream &description) {
- LLDB_RECORD_METHOD(bool, SBMemoryRegionInfo, GetDescription,
- (lldb::SBStream &), description);
+ LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();
const addr_t load_addr = m_opaque_up->GetRange().base;
diff --git a/lldb/source/API/SBMemoryRegionInfoList.cpp b/lldb/source/API/SBMemoryRegionInfoList.cpp
index 2de0f0700666..39dee86dc300 100644
--- a/lldb/source/API/SBMemoryRegionInfoList.cpp
+++ b/lldb/source/API/SBMemoryRegionInfoList.cpp
@@ -7,10 +7,10 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBMemoryRegionInfoList.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBMemoryRegionInfo.h"
#include "lldb/API/SBStream.h"
#include "lldb/Target/MemoryRegionInfo.h"
+#include "lldb/Utility/Instrumentation.h"
#include <vector>
@@ -83,24 +83,20 @@ const MemoryRegionInfos &SBMemoryRegionInfoList::ref() const {
SBMemoryRegionInfoList::SBMemoryRegionInfoList()
: m_opaque_up(new MemoryRegionInfoListImpl()) {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBMemoryRegionInfoList);
+ LLDB_INSTRUMENT_VA(this);
}
SBMemoryRegionInfoList::SBMemoryRegionInfoList(
const SBMemoryRegionInfoList &rhs)
: m_opaque_up(new MemoryRegionInfoListImpl(*rhs.m_opaque_up)) {
- LLDB_RECORD_CONSTRUCTOR(SBMemoryRegionInfoList,
- (const lldb::SBMemoryRegionInfoList &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
}
SBMemoryRegionInfoList::~SBMemoryRegionInfoList() = default;
const SBMemoryRegionInfoList &SBMemoryRegionInfoList::
operator=(const SBMemoryRegionInfoList &rhs) {
- LLDB_RECORD_METHOD(
- const lldb::SBMemoryRegionInfoList &,
- SBMemoryRegionInfoList, operator=,(const lldb::SBMemoryRegionInfoList &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
*m_opaque_up = *rhs.m_opaque_up;
@@ -109,44 +105,39 @@ operator=(const SBMemoryRegionInfoList &rhs) {
}
uint32_t SBMemoryRegionInfoList::GetSize() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBMemoryRegionInfoList, GetSize);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetSize();
}
bool SBMemoryRegionInfoList::GetMemoryRegionContainingAddress(
lldb::addr_t addr, SBMemoryRegionInfo ®ion_info) {
- LLDB_RECORD_METHOD(
- bool, SBMemoryRegionInfoList, GetMemoryRegionContainingAddress,
- (lldb::addr_t, lldb::SBMemoryRegionInfo &), addr, region_info);
+ LLDB_INSTRUMENT_VA(this, addr, region_info);
return m_opaque_up->GetMemoryRegionContainingAddress(addr, region_info.ref());
}
bool SBMemoryRegionInfoList::GetMemoryRegionAtIndex(
uint32_t idx, SBMemoryRegionInfo ®ion_info) {
- LLDB_RECORD_METHOD(bool, SBMemoryRegionInfoList, GetMemoryRegionAtIndex,
- (uint32_t, lldb::SBMemoryRegionInfo &), idx, region_info);
+ LLDB_INSTRUMENT_VA(this, idx, region_info);
return m_opaque_up->GetMemoryRegionInfoAtIndex(idx, region_info.ref());
}
void SBMemoryRegionInfoList::Clear() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBMemoryRegionInfoList, Clear);
+ LLDB_INSTRUMENT_VA(this);
m_opaque_up->Clear();
}
void SBMemoryRegionInfoList::Append(SBMemoryRegionInfo &sb_region) {
- LLDB_RECORD_METHOD(void, SBMemoryRegionInfoList, Append,
- (lldb::SBMemoryRegionInfo &), sb_region);
+ LLDB_INSTRUMENT_VA(this, sb_region);
m_opaque_up->Append(sb_region.ref());
}
void SBMemoryRegionInfoList::Append(SBMemoryRegionInfoList &sb_region_list) {
- LLDB_RECORD_METHOD(void, SBMemoryRegionInfoList, Append,
- (lldb::SBMemoryRegionInfoList &), sb_region_list);
+ LLDB_INSTRUMENT_VA(this, sb_region_list);
m_opaque_up->Append(*sb_region_list);
}
diff --git a/lldb/source/API/SBModule.cpp b/lldb/source/API/SBModule.cpp
index 366c920f5756..2483495b97db 100644
--- a/lldb/source/API/SBModule.cpp
+++ b/lldb/source/API/SBModule.cpp
@@ -7,7 +7,6 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBModule.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBFileSpec.h"
#include "lldb/API/SBModuleSpec.h"
@@ -24,17 +23,18 @@
#include "lldb/Symbol/TypeSystem.h"
#include "lldb/Symbol/VariableList.h"
#include "lldb/Target/Target.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb;
using namespace lldb_private;
-SBModule::SBModule() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBModule); }
+SBModule::SBModule() { LLDB_INSTRUMENT_VA(this); }
SBModule::SBModule(const lldb::ModuleSP &module_sp) : m_opaque_sp(module_sp) {}
SBModule::SBModule(const SBModuleSpec &module_spec) {
- LLDB_RECORD_CONSTRUCTOR(SBModule, (const lldb::SBModuleSpec &), module_spec);
+ LLDB_INSTRUMENT_VA(this, module_spec);
ModuleSP module_sp;
Status error = ModuleList::GetSharedModule(
@@ -44,12 +44,11 @@ SBModule::SBModule(const SBModuleSpec &module_spec) {
}
SBModule::SBModule(const SBModule &rhs) : m_opaque_sp(rhs.m_opaque_sp) {
- LLDB_RECORD_CONSTRUCTOR(SBModule, (const lldb::SBModule &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
}
SBModule::SBModule(lldb::SBProcess &process, lldb::addr_t header_addr) {
- LLDB_RECORD_CONSTRUCTOR(SBModule, (lldb::SBProcess &, lldb::addr_t), process,
- header_addr);
+ LLDB_INSTRUMENT_VA(this, process, header_addr);
ProcessSP process_sp(process.GetSP());
if (process_sp) {
@@ -64,8 +63,7 @@ SBModule::SBModule(lldb::SBProcess &process, lldb::addr_t header_addr) {
}
const SBModule &SBModule::operator=(const SBModule &rhs) {
- LLDB_RECORD_METHOD(const lldb::SBModule &, SBModule, operator=,
- (const lldb::SBModule &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_sp = rhs.m_opaque_sp;
@@ -75,23 +73,23 @@ const SBModule &SBModule::operator=(const SBModule &rhs) {
SBModule::~SBModule() = default;
bool SBModule::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModule, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBModule::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModule, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp.get() != nullptr;
}
void SBModule::Clear() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBModule, Clear);
+ LLDB_INSTRUMENT_VA(this);
m_opaque_sp.reset();
}
SBFileSpec SBModule::GetFileSpec() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule, GetFileSpec);
+ LLDB_INSTRUMENT_VA(this);
SBFileSpec file_spec;
ModuleSP module_sp(GetSP());
@@ -102,8 +100,7 @@ SBFileSpec SBModule::GetFileSpec() const {
}
lldb::SBFileSpec SBModule::GetPlatformFileSpec() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule,
- GetPlatformFileSpec);
+ LLDB_INSTRUMENT_VA(this);
SBFileSpec file_spec;
ModuleSP module_sp(GetSP());
@@ -114,8 +111,7 @@ lldb::SBFileSpec SBModule::GetPlatformFileSpec() const {
}
bool SBModule::SetPlatformFileSpec(const lldb::SBFileSpec &platform_file) {
- LLDB_RECORD_METHOD(bool, SBModule, SetPlatformFileSpec,
- (const lldb::SBFileSpec &), platform_file);
+ LLDB_INSTRUMENT_VA(this, platform_file);
bool result = false;
@@ -129,8 +125,7 @@ bool SBModule::SetPlatformFileSpec(const lldb::SBFileSpec &platform_file) {
}
lldb::SBFileSpec SBModule::GetRemoteInstallFileSpec() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModule,
- GetRemoteInstallFileSpec);
+ LLDB_INSTRUMENT_VA(this);
SBFileSpec sb_file_spec;
ModuleSP module_sp(GetSP());
@@ -140,8 +135,7 @@ lldb::SBFileSpec SBModule::GetRemoteInstallFileSpec() {
}
bool SBModule::SetRemoteInstallFileSpec(lldb::SBFileSpec &file) {
- LLDB_RECORD_METHOD(bool, SBModule, SetRemoteInstallFileSpec,
- (lldb::SBFileSpec &), file);
+ LLDB_INSTRUMENT_VA(this, file);
ModuleSP module_sp(GetSP());
if (module_sp) {
@@ -152,7 +146,7 @@ bool SBModule::SetRemoteInstallFileSpec(lldb::SBFileSpec &file) {
}
const uint8_t *SBModule::GetUUIDBytes() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(const uint8_t *, SBModule, GetUUIDBytes);
+ LLDB_INSTRUMENT_VA(this);
const uint8_t *uuid_bytes = nullptr;
ModuleSP module_sp(GetSP());
@@ -163,7 +157,7 @@ const uint8_t *SBModule::GetUUIDBytes() const {
}
const char *SBModule::GetUUIDString() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBModule, GetUUIDString);
+ LLDB_INSTRUMENT_VA(this);
const char *uuid_cstr = nullptr;
ModuleSP module_sp(GetSP());
@@ -183,8 +177,7 @@ const char *SBModule::GetUUIDString() const {
}
bool SBModule::operator==(const SBModule &rhs) const {
- LLDB_RECORD_METHOD_CONST(bool, SBModule, operator==, (const lldb::SBModule &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (m_opaque_sp)
return m_opaque_sp.get() == rhs.m_opaque_sp.get();
@@ -192,8 +185,7 @@ bool SBModule::operator==(const SBModule &rhs) const {
}
bool SBModule::operator!=(const SBModule &rhs) const {
- LLDB_RECORD_METHOD_CONST(bool, SBModule, operator!=, (const lldb::SBModule &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (m_opaque_sp)
return m_opaque_sp.get() != rhs.m_opaque_sp.get();
@@ -205,8 +197,7 @@ ModuleSP SBModule::GetSP() const { return m_opaque_sp; }
void SBModule::SetSP(const ModuleSP &module_sp) { m_opaque_sp = module_sp; }
SBAddress SBModule::ResolveFileAddress(lldb::addr_t vm_addr) {
- LLDB_RECORD_METHOD(lldb::SBAddress, SBModule, ResolveFileAddress,
- (lldb::addr_t), vm_addr);
+ LLDB_INSTRUMENT_VA(this, vm_addr);
lldb::SBAddress sb_addr;
ModuleSP module_sp(GetSP());
@@ -221,9 +212,7 @@ SBAddress SBModule::ResolveFileAddress(lldb::addr_t vm_addr) {
SBSymbolContext
SBModule::ResolveSymbolContextForAddress(const SBAddress &addr,
uint32_t resolve_scope) {
- LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBModule,
- ResolveSymbolContextForAddress,
- (const lldb::SBAddress &, uint32_t), addr, resolve_scope);
+ LLDB_INSTRUMENT_VA(this, addr, resolve_scope);
SBSymbolContext sb_sc;
ModuleSP module_sp(GetSP());
@@ -234,8 +223,7 @@ SBModule::ResolveSymbolContextForAddress(const SBAddress &addr,
}
bool SBModule::GetDescription(SBStream &description) {
- LLDB_RECORD_METHOD(bool, SBModule, GetDescription, (lldb::SBStream &),
- description);
+ LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();
@@ -249,7 +237,7 @@ bool SBModule::GetDescription(SBStream &description) {
}
uint32_t SBModule::GetNumCompileUnits() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBModule, GetNumCompileUnits);
+ LLDB_INSTRUMENT_VA(this);
ModuleSP module_sp(GetSP());
if (module_sp) {
@@ -259,8 +247,7 @@ uint32_t SBModule::GetNumCompileUnits() {
}
SBCompileUnit SBModule::GetCompileUnitAtIndex(uint32_t index) {
- LLDB_RECORD_METHOD(lldb::SBCompileUnit, SBModule, GetCompileUnitAtIndex,
- (uint32_t), index);
+ LLDB_INSTRUMENT_VA(this, index);
SBCompileUnit sb_cu;
ModuleSP module_sp(GetSP());
@@ -272,8 +259,7 @@ SBCompileUnit SBModule::GetCompileUnitAtIndex(uint32_t index) {
}
SBSymbolContextList SBModule::FindCompileUnits(const SBFileSpec &sb_file_spec) {
- LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBModule, FindCompileUnits,
- (const lldb::SBFileSpec &), sb_file_spec);
+ LLDB_INSTRUMENT_VA(this, sb_file_spec);
SBSymbolContextList sb_sc_list;
const ModuleSP module_sp(GetSP());
@@ -290,7 +276,7 @@ static Symtab *GetUnifiedSymbolTable(const lldb::ModuleSP &module_sp) {
}
size_t SBModule::GetNumSymbols() {
- LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModule, GetNumSymbols);
+ LLDB_INSTRUMENT_VA(this);
ModuleSP module_sp(GetSP());
if (Symtab *symtab = GetUnifiedSymbolTable(module_sp))
@@ -299,7 +285,7 @@ size_t SBModule::GetNumSymbols() {
}
SBSymbol SBModule::GetSymbolAtIndex(size_t idx) {
- LLDB_RECORD_METHOD(lldb::SBSymbol, SBModule, GetSymbolAtIndex, (size_t), idx);
+ LLDB_INSTRUMENT_VA(this, idx);
SBSymbol sb_symbol;
ModuleSP module_sp(GetSP());
@@ -311,8 +297,7 @@ SBSymbol SBModule::GetSymbolAtIndex(size_t idx) {
lldb::SBSymbol SBModule::FindSymbol(const char *name,
lldb::SymbolType symbol_type) {
- LLDB_RECORD_METHOD(lldb::SBSymbol, SBModule, FindSymbol,
- (const char *, lldb::SymbolType), name, symbol_type);
+ LLDB_INSTRUMENT_VA(this, name, symbol_type);
SBSymbol sb_symbol;
if (name && name[0]) {
@@ -328,8 +313,7 @@ lldb::SBSymbol SBModule::FindSymbol(const char *name,
lldb::SBSymbolContextList SBModule::FindSymbols(const char *name,
lldb::SymbolType symbol_type) {
- LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBModule, FindSymbols,
- (const char *, lldb::SymbolType), name, symbol_type);
+ LLDB_INSTRUMENT_VA(this, name, symbol_type);
SBSymbolContextList sb_sc_list;
if (name && name[0]) {
@@ -356,7 +340,7 @@ lldb::SBSymbolContextList SBModule::FindSymbols(const char *name,
}
size_t SBModule::GetNumSections() {
- LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModule, GetNumSections);
+ LLDB_INSTRUMENT_VA(this);
ModuleSP module_sp(GetSP());
if (module_sp) {
@@ -370,8 +354,7 @@ size_t SBModule::GetNumSections() {
}
SBSection SBModule::GetSectionAtIndex(size_t idx) {
- LLDB_RECORD_METHOD(lldb::SBSection, SBModule, GetSectionAtIndex, (size_t),
- idx);
+ LLDB_INSTRUMENT_VA(this, idx);
SBSection sb_section;
ModuleSP module_sp(GetSP());
@@ -388,8 +371,7 @@ SBSection SBModule::GetSectionAtIndex(size_t idx) {
lldb::SBSymbolContextList SBModule::FindFunctions(const char *name,
uint32_t name_type_mask) {
- LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBModule, FindFunctions,
- (const char *, uint32_t), name, name_type_mask);
+ LLDB_INSTRUMENT_VA(this, name, name_type_mask);
lldb::SBSymbolContextList sb_sc_list;
ModuleSP module_sp(GetSP());
@@ -407,9 +389,7 @@ lldb::SBSymbolContextList SBModule::FindFunctions(const char *name,
SBValueList SBModule::FindGlobalVariables(SBTarget &target, const char *name,
uint32_t max_matches) {
- LLDB_RECORD_METHOD(lldb::SBValueList, SBModule, FindGlobalVariables,
- (lldb::SBTarget &, const char *, uint32_t), target, name,
- max_matches);
+ LLDB_INSTRUMENT_VA(this, target, name, max_matches);
SBValueList sb_value_list;
ModuleSP module_sp(GetSP());
@@ -431,8 +411,7 @@ SBValueList SBModule::FindGlobalVariables(SBTarget &target, const char *name,
lldb::SBValue SBModule::FindFirstGlobalVariable(lldb::SBTarget &target,
const char *name) {
- LLDB_RECORD_METHOD(lldb::SBValue, SBModule, FindFirstGlobalVariable,
- (lldb::SBTarget &, const char *), target, name);
+ LLDB_INSTRUMENT_VA(this, target, name);
SBValueList sb_value_list(FindGlobalVariables(target, name, 1));
if (sb_value_list.IsValid() && sb_value_list.GetSize() > 0)
@@ -441,8 +420,7 @@ lldb::SBValue SBModule::FindFirstGlobalVariable(lldb::SBTarget &target,
}
lldb::SBType SBModule::FindFirstType(const char *name_cstr) {
- LLDB_RECORD_METHOD(lldb::SBType, SBModule, FindFirstType, (const char *),
- name_cstr);
+ LLDB_INSTRUMENT_VA(this, name_cstr);
SBType sb_type;
ModuleSP module_sp(GetSP());
@@ -467,8 +445,7 @@ lldb::SBType SBModule::FindFirstType(const char *name_cstr) {
}
lldb::SBType SBModule::GetBasicType(lldb::BasicType type) {
- LLDB_RECORD_METHOD(lldb::SBType, SBModule, GetBasicType, (lldb::BasicType),
- type);
+ LLDB_INSTRUMENT_VA(this, type);
ModuleSP module_sp(GetSP());
if (module_sp) {
@@ -484,8 +461,7 @@ lldb::SBType SBModule::GetBasicType(lldb::BasicType type) {
}
lldb::SBTypeList SBModule::FindTypes(const char *type) {
- LLDB_RECORD_METHOD(lldb::SBTypeList, SBModule, FindTypes, (const char *),
- type);
+ LLDB_INSTRUMENT_VA(this, type);
SBTypeList retval;
@@ -521,8 +497,7 @@ lldb::SBTypeList SBModule::FindTypes(const char *type) {
}
lldb::SBType SBModule::GetTypeByID(lldb::user_id_t uid) {
- LLDB_RECORD_METHOD(lldb::SBType, SBModule, GetTypeByID, (lldb::user_id_t),
- uid);
+ LLDB_INSTRUMENT_VA(this, uid);
ModuleSP module_sp(GetSP());
if (module_sp) {
@@ -536,8 +511,7 @@ lldb::SBType SBModule::GetTypeByID(lldb::user_id_t uid) {
}
lldb::SBTypeList SBModule::GetTypes(uint32_t type_mask) {
- LLDB_RECORD_METHOD(lldb::SBTypeList, SBModule, GetTypes, (uint32_t),
- type_mask);
+ LLDB_INSTRUMENT_VA(this, type_mask);
SBTypeList sb_type_list;
@@ -556,8 +530,7 @@ lldb::SBTypeList SBModule::GetTypes(uint32_t type_mask) {
}
SBSection SBModule::FindSection(const char *sect_name) {
- LLDB_RECORD_METHOD(lldb::SBSection, SBModule, FindSection, (const char *),
- sect_name);
+ LLDB_INSTRUMENT_VA(this, sect_name);
SBSection sb_section;
@@ -578,7 +551,7 @@ SBSection SBModule::FindSection(const char *sect_name) {
}
lldb::ByteOrder SBModule::GetByteOrder() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::ByteOrder, SBModule, GetByteOrder);
+ LLDB_INSTRUMENT_VA(this);
ModuleSP module_sp(GetSP());
if (module_sp)
@@ -587,7 +560,7 @@ lldb::ByteOrder SBModule::GetByteOrder() {
}
const char *SBModule::GetTriple() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBModule, GetTriple);
+ LLDB_INSTRUMENT_VA(this);
ModuleSP module_sp(GetSP());
if (module_sp) {
@@ -602,7 +575,7 @@ const char *SBModule::GetTriple() {
}
uint32_t SBModule::GetAddressByteSize() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBModule, GetAddressByteSize);
+ LLDB_INSTRUMENT_VA(this);
ModuleSP module_sp(GetSP());
if (module_sp)
@@ -611,8 +584,7 @@ uint32_t SBModule::GetAddressByteSize() {
}
uint32_t SBModule::GetVersion(uint32_t *versions, uint32_t num_versions) {
- LLDB_RECORD_METHOD(uint32_t, SBModule, GetVersion, (uint32_t *, uint32_t),
- versions, num_versions);
+ LLDB_INSTRUMENT_VA(this, versions, num_versions);
llvm::VersionTuple version;
if (ModuleSP module_sp = GetSP())
@@ -640,8 +612,7 @@ uint32_t SBModule::GetVersion(uint32_t *versions, uint32_t num_versions) {
}
lldb::SBFileSpec SBModule::GetSymbolFileSpec() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule,
- GetSymbolFileSpec);
+ LLDB_INSTRUMENT_VA(this);
lldb::SBFileSpec sb_file_spec;
ModuleSP module_sp(GetSP());
@@ -653,8 +624,7 @@ lldb::SBFileSpec SBModule::GetSymbolFileSpec() const {
}
lldb::SBAddress SBModule::GetObjectFileHeaderAddress() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBModule,
- GetObjectFileHeaderAddress);
+ LLDB_INSTRUMENT_VA(this);
lldb::SBAddress sb_addr;
ModuleSP module_sp(GetSP());
@@ -667,8 +637,7 @@ lldb::SBAddress SBModule::GetObjectFileHeaderAddress() const {
}
lldb::SBAddress SBModule::GetObjectFileEntryPointAddress() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBModule,
- GetObjectFileEntryPointAddress);
+ LLDB_INSTRUMENT_VA(this);
lldb::SBAddress sb_addr;
ModuleSP module_sp(GetSP());
@@ -681,15 +650,13 @@ lldb::SBAddress SBModule::GetObjectFileEntryPointAddress() const {
}
uint32_t SBModule::GetNumberAllocatedModules() {
- LLDB_RECORD_STATIC_METHOD_NO_ARGS(uint32_t, SBModule,
- GetNumberAllocatedModules);
+ LLDB_INSTRUMENT();
return Module::GetNumberAllocatedModules();
}
void SBModule::GarbageCollectAllocatedModules() {
- LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBModule,
- GarbageCollectAllocatedModules);
+ LLDB_INSTRUMENT();
const bool mandatory = false;
ModuleList::RemoveOrphanSharedModules(mandatory);
diff --git a/lldb/source/API/SBModuleSpec.cpp b/lldb/source/API/SBModuleSpec.cpp
index ce2bb3556d4d..7deba8e971f8 100644
--- a/lldb/source/API/SBModuleSpec.cpp
+++ b/lldb/source/API/SBModuleSpec.cpp
@@ -7,31 +7,30 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBModuleSpec.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/API/SBStream.h"
#include "lldb/Core/Module.h"
#include "lldb/Core/ModuleSpec.h"
#include "lldb/Host/Host.h"
#include "lldb/Symbol/ObjectFile.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/Stream.h"
using namespace lldb;
using namespace lldb_private;
SBModuleSpec::SBModuleSpec() : m_opaque_up(new lldb_private::ModuleSpec()) {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBModuleSpec);
+ LLDB_INSTRUMENT_VA(this);
}
SBModuleSpec::SBModuleSpec(const SBModuleSpec &rhs) {
- LLDB_RECORD_CONSTRUCTOR(SBModuleSpec, (const lldb::SBModuleSpec &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_up = clone(rhs.m_opaque_up);
}
const SBModuleSpec &SBModuleSpec::operator=(const SBModuleSpec &rhs) {
- LLDB_RECORD_METHOD(const lldb::SBModuleSpec &,
- SBModuleSpec, operator=,(const lldb::SBModuleSpec &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
@@ -41,76 +40,72 @@ const SBModuleSpec &SBModuleSpec::operator=(const SBModuleSpec &rhs) {
SBModuleSpec::~SBModuleSpec() = default;
bool SBModuleSpec::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModuleSpec, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBModuleSpec::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModuleSpec, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->operator bool();
}
void SBModuleSpec::Clear() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBModuleSpec, Clear);
+ LLDB_INSTRUMENT_VA(this);
m_opaque_up->Clear();
}
SBFileSpec SBModuleSpec::GetFileSpec() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModuleSpec, GetFileSpec);
+ LLDB_INSTRUMENT_VA(this);
SBFileSpec sb_spec(m_opaque_up->GetFileSpec());
return sb_spec;
}
void SBModuleSpec::SetFileSpec(const lldb::SBFileSpec &sb_spec) {
- LLDB_RECORD_METHOD(void, SBModuleSpec, SetFileSpec,
- (const lldb::SBFileSpec &), sb_spec);
+ LLDB_INSTRUMENT_VA(this, sb_spec);
m_opaque_up->GetFileSpec() = *sb_spec;
}
lldb::SBFileSpec SBModuleSpec::GetPlatformFileSpec() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModuleSpec,
- GetPlatformFileSpec);
+ LLDB_INSTRUMENT_VA(this);
return SBFileSpec(m_opaque_up->GetPlatformFileSpec());
}
void SBModuleSpec::SetPlatformFileSpec(const lldb::SBFileSpec &sb_spec) {
- LLDB_RECORD_METHOD(void, SBModuleSpec, SetPlatformFileSpec,
- (const lldb::SBFileSpec &), sb_spec);
+ LLDB_INSTRUMENT_VA(this, sb_spec);
m_opaque_up->GetPlatformFileSpec() = *sb_spec;
}
lldb::SBFileSpec SBModuleSpec::GetSymbolFileSpec() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModuleSpec, GetSymbolFileSpec);
+ LLDB_INSTRUMENT_VA(this);
return SBFileSpec(m_opaque_up->GetSymbolFileSpec());
}
void SBModuleSpec::SetSymbolFileSpec(const lldb::SBFileSpec &sb_spec) {
- LLDB_RECORD_METHOD(void, SBModuleSpec, SetSymbolFileSpec,
- (const lldb::SBFileSpec &), sb_spec);
+ LLDB_INSTRUMENT_VA(this, sb_spec);
m_opaque_up->GetSymbolFileSpec() = *sb_spec;
}
const char *SBModuleSpec::GetObjectName() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBModuleSpec, GetObjectName);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetObjectName().GetCString();
}
void SBModuleSpec::SetObjectName(const char *name) {
- LLDB_RECORD_METHOD(void, SBModuleSpec, SetObjectName, (const char *), name);
+ LLDB_INSTRUMENT_VA(this, name);
m_opaque_up->GetObjectName().SetCString(name);
}
const char *SBModuleSpec::GetTriple() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBModuleSpec, GetTriple);
+ LLDB_INSTRUMENT_VA(this);
std::string triple(m_opaque_up->GetArchitecture().GetTriple().str());
// Unique the string so we don't run into ownership issues since the const
@@ -121,48 +116,46 @@ const char *SBModuleSpec::GetTriple() {
}
void SBModuleSpec::SetTriple(const char *triple) {
- LLDB_RECORD_METHOD(void, SBModuleSpec, SetTriple, (const char *), triple);
+ LLDB_INSTRUMENT_VA(this, triple);
m_opaque_up->GetArchitecture().SetTriple(triple);
}
const uint8_t *SBModuleSpec::GetUUIDBytes() {
+ LLDB_INSTRUMENT_VA(this)
return m_opaque_up->GetUUID().GetBytes().data();
}
size_t SBModuleSpec::GetUUIDLength() {
- LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModuleSpec, GetUUIDLength);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetUUID().GetBytes().size();
}
bool SBModuleSpec::SetUUIDBytes(const uint8_t *uuid, size_t uuid_len) {
+ LLDB_INSTRUMENT_VA(this, uuid, uuid_len)
m_opaque_up->GetUUID() = UUID::fromOptionalData(uuid, uuid_len);
return m_opaque_up->GetUUID().IsValid();
}
bool SBModuleSpec::GetDescription(lldb::SBStream &description) {
- LLDB_RECORD_METHOD(bool, SBModuleSpec, GetDescription, (lldb::SBStream &),
- description);
+ LLDB_INSTRUMENT_VA(this, description);
m_opaque_up->Dump(description.ref());
return true;
}
SBModuleSpecList::SBModuleSpecList() : m_opaque_up(new ModuleSpecList()) {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBModuleSpecList);
+ LLDB_INSTRUMENT_VA(this);
}
SBModuleSpecList::SBModuleSpecList(const SBModuleSpecList &rhs)
: m_opaque_up(new ModuleSpecList(*rhs.m_opaque_up)) {
- LLDB_RECORD_CONSTRUCTOR(SBModuleSpecList, (const lldb::SBModuleSpecList &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
}
SBModuleSpecList &SBModuleSpecList::operator=(const SBModuleSpecList &rhs) {
- LLDB_RECORD_METHOD(
- lldb::SBModuleSpecList &,
- SBModuleSpecList, operator=,(const lldb::SBModuleSpecList &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
*m_opaque_up = *rhs.m_opaque_up;
@@ -172,8 +165,7 @@ SBModuleSpecList &SBModuleSpecList::operator=(const SBModuleSpecList &rhs) {
SBModuleSpecList::~SBModuleSpecList() = default;
SBModuleSpecList SBModuleSpecList::GetModuleSpecifications(const char *path) {
- LLDB_RECORD_STATIC_METHOD(lldb::SBModuleSpecList, SBModuleSpecList,
- GetModuleSpecifications, (const char *), path);
+ LLDB_INSTRUMENT_VA(path);
SBModuleSpecList specs;
FileSpec file_spec(path);
@@ -184,28 +176,25 @@ SBModuleSpecList SBModuleSpecList::GetModuleSpecifications(const char *path) {
}
void SBModuleSpecList::Append(const SBModuleSpec &spec) {
- LLDB_RECORD_METHOD(void, SBModuleSpecList, Append,
- (const lldb::SBModuleSpec &), spec);
+ LLDB_INSTRUMENT_VA(this, spec);
m_opaque_up->Append(*spec.m_opaque_up);
}
void SBModuleSpecList::Append(const SBModuleSpecList &spec_list) {
- LLDB_RECORD_METHOD(void, SBModuleSpecList, Append,
- (const lldb::SBModuleSpecList &), spec_list);
+ LLDB_INSTRUMENT_VA(this, spec_list);
m_opaque_up->Append(*spec_list.m_opaque_up);
}
size_t SBModuleSpecList::GetSize() {
- LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModuleSpecList, GetSize);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetSize();
}
SBModuleSpec SBModuleSpecList::GetSpecAtIndex(size_t i) {
- LLDB_RECORD_METHOD(lldb::SBModuleSpec, SBModuleSpecList, GetSpecAtIndex,
- (size_t), i);
+ LLDB_INSTRUMENT_VA(this, i);
SBModuleSpec sb_module_spec;
m_opaque_up->GetModuleSpecAtIndex(i, *sb_module_spec.m_opaque_up);
@@ -214,9 +203,7 @@ SBModuleSpec SBModuleSpecList::GetSpecAtIndex(size_t i) {
SBModuleSpec
SBModuleSpecList::FindFirstMatchingSpec(const SBModuleSpec &match_spec) {
- LLDB_RECORD_METHOD(lldb::SBModuleSpec, SBModuleSpecList,
- FindFirstMatchingSpec, (const lldb::SBModuleSpec &),
- match_spec);
+ LLDB_INSTRUMENT_VA(this, match_spec);
SBModuleSpec sb_module_spec;
m_opaque_up->FindMatchingModuleSpec(*match_spec.m_opaque_up,
@@ -226,9 +213,7 @@ SBModuleSpecList::FindFirstMatchingSpec(const SBModuleSpec &match_spec) {
SBModuleSpecList
SBModuleSpecList::FindMatchingSpecs(const SBModuleSpec &match_spec) {
- LLDB_RECORD_METHOD(lldb::SBModuleSpecList, SBModuleSpecList,
- FindMatchingSpecs, (const lldb::SBModuleSpec &),
- match_spec);
+ LLDB_INSTRUMENT_VA(this, match_spec);
SBModuleSpecList specs;
m_opaque_up->FindMatchingModuleSpecs(*match_spec.m_opaque_up,
@@ -237,8 +222,7 @@ SBModuleSpecList::FindMatchingSpecs(const SBModuleSpec &match_spec) {
}
bool SBModuleSpecList::GetDescription(lldb::SBStream &description) {
- LLDB_RECORD_METHOD(bool, SBModuleSpecList, GetDescription, (lldb::SBStream &),
- description);
+ LLDB_INSTRUMENT_VA(this, description);
m_opaque_up->Dump(description.ref());
return true;
diff --git a/lldb/source/API/SBPlatform.cpp b/lldb/source/API/SBPlatform.cpp
index 5b0f1c3e1e21..d521a38b30e8 100644
--- a/lldb/source/API/SBPlatform.cpp
+++ b/lldb/source/API/SBPlatform.cpp
@@ -7,7 +7,6 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBPlatform.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBEnvironment.h"
#include "lldb/API/SBError.h"
#include "lldb/API/SBFileSpec.h"
@@ -19,6 +18,7 @@
#include "lldb/Target/Target.h"
#include "lldb/Utility/ArchSpec.h"
#include "lldb/Utility/Args.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/Status.h"
#include "llvm/Support/FileSystem.h"
@@ -75,14 +75,13 @@ struct PlatformShellCommand {
// SBPlatformConnectOptions
SBPlatformConnectOptions::SBPlatformConnectOptions(const char *url)
: m_opaque_ptr(new PlatformConnectOptions(url)) {
- LLDB_RECORD_CONSTRUCTOR(SBPlatformConnectOptions, (const char *), url);
+ LLDB_INSTRUMENT_VA(this, url);
}
SBPlatformConnectOptions::SBPlatformConnectOptions(
const SBPlatformConnectOptions &rhs)
: m_opaque_ptr(new PlatformConnectOptions()) {
- LLDB_RECORD_CONSTRUCTOR(SBPlatformConnectOptions,
- (const lldb::SBPlatformConnectOptions &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
*m_opaque_ptr = *rhs.m_opaque_ptr;
}
@@ -91,18 +90,14 @@ SBPlatformConnectOptions::~SBPlatformConnectOptions() { delete m_opaque_ptr; }
SBPlatformConnectOptions &
SBPlatformConnectOptions::operator=(const SBPlatformConnectOptions &rhs) {
- LLDB_RECORD_METHOD(
- SBPlatformConnectOptions &,
- SBPlatformConnectOptions, operator=,(
- const lldb::SBPlatformConnectOptions &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
*m_opaque_ptr = *rhs.m_opaque_ptr;
return *this;
}
const char *SBPlatformConnectOptions::GetURL() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformConnectOptions, GetURL);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr->m_url.empty())
return nullptr;
@@ -110,8 +105,7 @@ const char *SBPlatformConnectOptions::GetURL() {
}
void SBPlatformConnectOptions::SetURL(const char *url) {
- LLDB_RECORD_METHOD(void, SBPlatformConnectOptions, SetURL, (const char *),
- url);
+ LLDB_INSTRUMENT_VA(this, url);
if (url && url[0])
m_opaque_ptr->m_url = url;
@@ -120,7 +114,7 @@ void SBPlatformConnectOptions::SetURL(const char *url) {
}
bool SBPlatformConnectOptions::GetRsyncEnabled() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBPlatformConnectOptions, GetRsyncEnabled);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_ptr->m_rsync_enabled;
}
@@ -128,9 +122,8 @@ bool SBPlatformConnectOptions::GetRsyncEnabled() {
void SBPlatformConnectOptions::EnableRsync(
const char *options, const char *remote_path_prefix,
bool omit_hostname_from_remote_path) {
- LLDB_RECORD_METHOD(void, SBPlatformConnectOptions, EnableRsync,
- (const char *, const char *, bool), options,
- remote_path_prefix, omit_hostname_from_remote_path);
+ LLDB_INSTRUMENT_VA(this, options, remote_path_prefix,
+ omit_hostname_from_remote_path);
m_opaque_ptr->m_rsync_enabled = true;
m_opaque_ptr->m_rsync_omit_hostname_from_remote_path =
@@ -147,21 +140,19 @@ void SBPlatformConnectOptions::EnableRsync(
}
void SBPlatformConnectOptions::DisableRsync() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatformConnectOptions, DisableRsync);
+ LLDB_INSTRUMENT_VA(this);
m_opaque_ptr->m_rsync_enabled = false;
}
const char *SBPlatformConnectOptions::GetLocalCacheDirectory() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformConnectOptions,
- GetLocalCacheDirectory);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_ptr->m_local_cache_directory.GetCString();
}
void SBPlatformConnectOptions::SetLocalCacheDirectory(const char *path) {
- LLDB_RECORD_METHOD(void, SBPlatformConnectOptions, SetLocalCacheDirectory,
- (const char *), path);
+ LLDB_INSTRUMENT_VA(this, path);
if (path && path[0])
m_opaque_ptr->m_local_cache_directory.SetCString(path);
@@ -173,21 +164,18 @@ void SBPlatformConnectOptions::SetLocalCacheDirectory(const char *path) {
SBPlatformShellCommand::SBPlatformShellCommand(const char *shell_interpreter,
const char *shell_command)
: m_opaque_ptr(new PlatformShellCommand(shell_interpreter, shell_command)) {
- LLDB_RECORD_CONSTRUCTOR(SBPlatformShellCommand, (const char *, const char *),
- shell_interpreter, shell_command);
+ LLDB_INSTRUMENT_VA(this, shell_interpreter, shell_command);
}
SBPlatformShellCommand::SBPlatformShellCommand(const char *shell_command)
: m_opaque_ptr(new PlatformShellCommand(shell_command)) {
- LLDB_RECORD_CONSTRUCTOR(SBPlatformShellCommand, (const char *),
- shell_command);
+ LLDB_INSTRUMENT_VA(this, shell_command);
}
SBPlatformShellCommand::SBPlatformShellCommand(
const SBPlatformShellCommand &rhs)
: m_opaque_ptr(new PlatformShellCommand()) {
- LLDB_RECORD_CONSTRUCTOR(SBPlatformShellCommand,
- (const lldb::SBPlatformShellCommand &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
*m_opaque_ptr = *rhs.m_opaque_ptr;
}
@@ -195,10 +183,7 @@ SBPlatformShellCommand::SBPlatformShellCommand(
SBPlatformShellCommand &
SBPlatformShellCommand::operator=(const SBPlatformShellCommand &rhs) {
- LLDB_RECORD_METHOD(
- SBPlatformShellCommand &,
- SBPlatformShellCommand, operator=,(const lldb::SBPlatformShellCommand &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
*m_opaque_ptr = *rhs.m_opaque_ptr;
return *this;
@@ -207,7 +192,7 @@ SBPlatformShellCommand::operator=(const SBPlatformShellCommand &rhs) {
SBPlatformShellCommand::~SBPlatformShellCommand() { delete m_opaque_ptr; }
void SBPlatformShellCommand::Clear() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatformShellCommand, Clear);
+ LLDB_INSTRUMENT_VA(this);
m_opaque_ptr->m_output = std::string();
m_opaque_ptr->m_status = 0;
@@ -215,7 +200,7 @@ void SBPlatformShellCommand::Clear() {
}
const char *SBPlatformShellCommand::GetShell() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand, GetShell);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr->m_shell.empty())
return nullptr;
@@ -223,8 +208,7 @@ const char *SBPlatformShellCommand::GetShell() {
}
void SBPlatformShellCommand::SetShell(const char *shell_interpreter) {
- LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetShell, (const char *),
- shell_interpreter);
+ LLDB_INSTRUMENT_VA(this, shell_interpreter);
if (shell_interpreter && shell_interpreter[0])
m_opaque_ptr->m_shell = shell_interpreter;
@@ -233,7 +217,7 @@ void SBPlatformShellCommand::SetShell(const char *shell_interpreter) {
}
const char *SBPlatformShellCommand::GetCommand() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand, GetCommand);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr->m_command.empty())
return nullptr;
@@ -241,8 +225,7 @@ const char *SBPlatformShellCommand::GetCommand() {
}
void SBPlatformShellCommand::SetCommand(const char *shell_command) {
- LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetCommand, (const char *),
- shell_command);
+ LLDB_INSTRUMENT_VA(this, shell_command);
if (shell_command && shell_command[0])
m_opaque_ptr->m_command = shell_command;
@@ -251,8 +234,7 @@ void SBPlatformShellCommand::SetCommand(const char *shell_command) {
}
const char *SBPlatformShellCommand::GetWorkingDirectory() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand,
- GetWorkingDirectory);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr->m_working_dir.empty())
return nullptr;
@@ -260,8 +242,7 @@ const char *SBPlatformShellCommand::GetWorkingDirectory() {
}
void SBPlatformShellCommand::SetWorkingDirectory(const char *path) {
- LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetWorkingDirectory,
- (const char *), path);
+ LLDB_INSTRUMENT_VA(this, path);
if (path && path[0])
m_opaque_ptr->m_working_dir = path;
@@ -270,8 +251,7 @@ void SBPlatformShellCommand::SetWorkingDirectory(const char *path) {
}
uint32_t SBPlatformShellCommand::GetTimeoutSeconds() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatformShellCommand,
- GetTimeoutSeconds);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr->m_timeout)
return m_opaque_ptr->m_timeout->count();
@@ -279,8 +259,7 @@ uint32_t SBPlatformShellCommand::GetTimeoutSeconds() {
}
void SBPlatformShellCommand::SetTimeoutSeconds(uint32_t sec) {
- LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetTimeoutSeconds,
- (uint32_t), sec);
+ LLDB_INSTRUMENT_VA(this, sec);
if (sec == UINT32_MAX)
m_opaque_ptr->m_timeout = llvm::None;
@@ -289,19 +268,19 @@ void SBPlatformShellCommand::SetTimeoutSeconds(uint32_t sec) {
}
int SBPlatformShellCommand::GetSignal() {
- LLDB_RECORD_METHOD_NO_ARGS(int, SBPlatformShellCommand, GetSignal);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_ptr->m_signo;
}
int SBPlatformShellCommand::GetStatus() {
- LLDB_RECORD_METHOD_NO_ARGS(int, SBPlatformShellCommand, GetStatus);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_ptr->m_status;
}
const char *SBPlatformShellCommand::GetOutput() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand, GetOutput);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr->m_output.empty())
return nullptr;
@@ -309,10 +288,10 @@ const char *SBPlatformShellCommand::GetOutput() {
}
// SBPlatform
-SBPlatform::SBPlatform() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBPlatform); }
+SBPlatform::SBPlatform() { LLDB_INSTRUMENT_VA(this); }
SBPlatform::SBPlatform(const char *platform_name) {
- LLDB_RECORD_CONSTRUCTOR(SBPlatform, (const char *), platform_name);
+ LLDB_INSTRUMENT_VA(this, platform_name);
Status error;
if (platform_name && platform_name[0])
@@ -320,14 +299,13 @@ SBPlatform::SBPlatform(const char *platform_name) {
}
SBPlatform::SBPlatform(const SBPlatform &rhs) {
- LLDB_RECORD_CONSTRUCTOR(SBPlatform, (const lldb::SBPlatform &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_sp = rhs.m_opaque_sp;
}
SBPlatform &SBPlatform::operator=(const SBPlatform &rhs) {
- LLDB_RECORD_METHOD(SBPlatform &,
- SBPlatform, operator=,(const lldb::SBPlatform &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_sp = rhs.m_opaque_sp;
return *this;
@@ -336,8 +314,7 @@ SBPlatform &SBPlatform::operator=(const SBPlatform &rhs) {
SBPlatform::~SBPlatform() = default;
SBPlatform SBPlatform::GetHostPlatform() {
- LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBPlatform, SBPlatform,
- GetHostPlatform);
+ LLDB_INSTRUMENT();
SBPlatform host_platform;
host_platform.m_opaque_sp = Platform::GetHostPlatform();
@@ -345,23 +322,23 @@ SBPlatform SBPlatform::GetHostPlatform() {
}
bool SBPlatform::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBPlatform, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBPlatform::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBPlatform, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp.get() != nullptr;
}
void SBPlatform::Clear() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatform, Clear);
+ LLDB_INSTRUMENT_VA(this);
m_opaque_sp.reset();
}
const char *SBPlatform::GetName() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetName);
+ LLDB_INSTRUMENT_VA(this);
PlatformSP platform_sp(GetSP());
if (platform_sp)
@@ -376,7 +353,7 @@ void SBPlatform::SetSP(const lldb::PlatformSP &platform_sp) {
}
const char *SBPlatform::GetWorkingDirectory() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetWorkingDirectory);
+ LLDB_INSTRUMENT_VA(this);
PlatformSP platform_sp(GetSP());
if (platform_sp)
@@ -385,8 +362,7 @@ const char *SBPlatform::GetWorkingDirectory() {
}
bool SBPlatform::SetWorkingDirectory(const char *path) {
- LLDB_RECORD_METHOD(bool, SBPlatform, SetWorkingDirectory, (const char *),
- path);
+ LLDB_INSTRUMENT_VA(this, path);
PlatformSP platform_sp(GetSP());
if (platform_sp) {
@@ -400,8 +376,7 @@ bool SBPlatform::SetWorkingDirectory(const char *path) {
}
SBError SBPlatform::ConnectRemote(SBPlatformConnectOptions &connect_options) {
- LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, ConnectRemote,
- (lldb::SBPlatformConnectOptions &), connect_options);
+ LLDB_INSTRUMENT_VA(this, connect_options);
SBError sb_error;
PlatformSP platform_sp(GetSP());
@@ -416,7 +391,7 @@ SBError SBPlatform::ConnectRemote(SBPlatformConnectOptions &connect_options) {
}
void SBPlatform::DisconnectRemote() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatform, DisconnectRemote);
+ LLDB_INSTRUMENT_VA(this);
PlatformSP platform_sp(GetSP());
if (platform_sp)
@@ -424,7 +399,7 @@ void SBPlatform::DisconnectRemote() {
}
bool SBPlatform::IsConnected() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBPlatform, IsConnected);
+ LLDB_INSTRUMENT_VA(this);
PlatformSP platform_sp(GetSP());
if (platform_sp)
@@ -433,7 +408,7 @@ bool SBPlatform::IsConnected() {
}
const char *SBPlatform::GetTriple() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetTriple);
+ LLDB_INSTRUMENT_VA(this);
PlatformSP platform_sp(GetSP());
if (platform_sp) {
@@ -448,7 +423,7 @@ const char *SBPlatform::GetTriple() {
}
const char *SBPlatform::GetOSBuild() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetOSBuild);
+ LLDB_INSTRUMENT_VA(this);
PlatformSP platform_sp(GetSP());
if (platform_sp) {
@@ -463,7 +438,7 @@ const char *SBPlatform::GetOSBuild() {
}
const char *SBPlatform::GetOSDescription() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetOSDescription);
+ LLDB_INSTRUMENT_VA(this);
PlatformSP platform_sp(GetSP());
if (platform_sp) {
@@ -478,7 +453,7 @@ const char *SBPlatform::GetOSDescription() {
}
const char *SBPlatform::GetHostname() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetHostname);
+ LLDB_INSTRUMENT_VA(this);
PlatformSP platform_sp(GetSP());
if (platform_sp)
@@ -487,7 +462,7 @@ const char *SBPlatform::GetHostname() {
}
uint32_t SBPlatform::GetOSMajorVersion() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatform, GetOSMajorVersion);
+ LLDB_INSTRUMENT_VA(this);
llvm::VersionTuple version;
if (PlatformSP platform_sp = GetSP())
@@ -496,7 +471,7 @@ uint32_t SBPlatform::GetOSMajorVersion() {
}
uint32_t SBPlatform::GetOSMinorVersion() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatform, GetOSMinorVersion);
+ LLDB_INSTRUMENT_VA(this);
llvm::VersionTuple version;
if (PlatformSP platform_sp = GetSP())
@@ -505,7 +480,7 @@ uint32_t SBPlatform::GetOSMinorVersion() {
}
uint32_t SBPlatform::GetOSUpdateVersion() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatform, GetOSUpdateVersion);
+ LLDB_INSTRUMENT_VA(this);
llvm::VersionTuple version;
if (PlatformSP platform_sp = GetSP())
@@ -514,14 +489,13 @@ uint32_t SBPlatform::GetOSUpdateVersion() {
}
void SBPlatform::SetSDKRoot(const char *sysroot) {
- LLDB_RECORD_METHOD(void, SBPlatform, SetSDKRoot, (const char *), sysroot);
+ LLDB_INSTRUMENT_VA(this, sysroot);
if (PlatformSP platform_sp = GetSP())
platform_sp->SetSDKRootDirectory(ConstString(sysroot));
}
SBError SBPlatform::Get(SBFileSpec &src, SBFileSpec &dst) {
- LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Get,
- (lldb::SBFileSpec &, lldb::SBFileSpec &), src, dst);
+ LLDB_INSTRUMENT_VA(this, src, dst);
SBError sb_error;
PlatformSP platform_sp(GetSP());
@@ -534,8 +508,7 @@ SBError SBPlatform::Get(SBFileSpec &src, SBFileSpec &dst) {
}
SBError SBPlatform::Put(SBFileSpec &src, SBFileSpec &dst) {
- LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Put,
- (lldb::SBFileSpec &, lldb::SBFileSpec &), src, dst);
+ LLDB_INSTRUMENT_VA(this, src, dst);
return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
if (src.Exists()) {
uint32_t permissions = FileSystem::Instance().GetPermissions(src.ref());
@@ -557,8 +530,7 @@ SBError SBPlatform::Put(SBFileSpec &src, SBFileSpec &dst) {
}
SBError SBPlatform::Install(SBFileSpec &src, SBFileSpec &dst) {
- LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Install,
- (lldb::SBFileSpec &, lldb::SBFileSpec &), src, dst);
+ LLDB_INSTRUMENT_VA(this, src, dst);
return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
if (src.Exists())
return platform_sp->Install(src.ref(), dst.ref());
@@ -571,8 +543,7 @@ SBError SBPlatform::Install(SBFileSpec &src, SBFileSpec &dst) {
}
SBError SBPlatform::Run(SBPlatformShellCommand &shell_command) {
- LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Run,
- (lldb::SBPlatformShellCommand &), shell_command);
+ LLDB_INSTRUMENT_VA(this, shell_command);
return ExecuteConnected(
[&](const lldb::PlatformSP &platform_sp) {
const char *command = shell_command.GetCommand();
@@ -595,8 +566,7 @@ SBError SBPlatform::Run(SBPlatformShellCommand &shell_command) {
}
SBError SBPlatform::Launch(SBLaunchInfo &launch_info) {
- LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Launch, (lldb::SBLaunchInfo &),
- launch_info);
+ LLDB_INSTRUMENT_VA(this, launch_info);
return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
ProcessLaunchInfo info = launch_info.ref();
Status error = platform_sp->LaunchProcess(info);
@@ -606,7 +576,7 @@ SBError SBPlatform::Launch(SBLaunchInfo &launch_info) {
}
SBError SBPlatform::Kill(const lldb::pid_t pid) {
- LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Kill, (const lldb::pid_t), pid);
+ LLDB_INSTRUMENT_VA(this, pid);
return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
return platform_sp->KillProcess(pid);
});
@@ -628,8 +598,7 @@ SBError SBPlatform::ExecuteConnected(
}
SBError SBPlatform::MakeDirectory(const char *path, uint32_t file_permissions) {
- LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, MakeDirectory,
- (const char *, uint32_t), path, file_permissions);
+ LLDB_INSTRUMENT_VA(this, path, file_permissions);
SBError sb_error;
PlatformSP platform_sp(GetSP());
@@ -643,8 +612,7 @@ SBError SBPlatform::MakeDirectory(const char *path, uint32_t file_permissions) {
}
uint32_t SBPlatform::GetFilePermissions(const char *path) {
- LLDB_RECORD_METHOD(uint32_t, SBPlatform, GetFilePermissions, (const char *),
- path);
+ LLDB_INSTRUMENT_VA(this, path);
PlatformSP platform_sp(GetSP());
if (platform_sp) {
@@ -657,8 +625,7 @@ uint32_t SBPlatform::GetFilePermissions(const char *path) {
SBError SBPlatform::SetFilePermissions(const char *path,
uint32_t file_permissions) {
- LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, SetFilePermissions,
- (const char *, uint32_t), path, file_permissions);
+ LLDB_INSTRUMENT_VA(this, path, file_permissions);
SBError sb_error;
PlatformSP platform_sp(GetSP());
@@ -672,8 +639,7 @@ SBError SBPlatform::SetFilePermissions(const char *path,
}
SBUnixSignals SBPlatform::GetUnixSignals() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBUnixSignals, SBPlatform,
- GetUnixSignals);
+ LLDB_INSTRUMENT_VA(this);
if (auto platform_sp = GetSP())
return SBUnixSignals{platform_sp};
@@ -682,7 +648,7 @@ SBUnixSignals SBPlatform::GetUnixSignals() const {
}
SBEnvironment SBPlatform::GetEnvironment() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBEnvironment, SBPlatform, GetEnvironment);
+ LLDB_INSTRUMENT_VA(this);
PlatformSP platform_sp(GetSP());
if (platform_sp) {
diff --git a/lldb/source/API/SBProcess.cpp b/lldb/source/API/SBProcess.cpp
index d598e483028d..2538013412b6 100644
--- a/lldb/source/API/SBProcess.cpp
+++ b/lldb/source/API/SBProcess.cpp
@@ -7,7 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBProcess.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
+#include "lldb/Utility/Instrumentation.h"
#include <cinttypes>
@@ -49,22 +49,21 @@
using namespace lldb;
using namespace lldb_private;
-SBProcess::SBProcess() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBProcess); }
+SBProcess::SBProcess() { LLDB_INSTRUMENT_VA(this); }
// SBProcess constructor
SBProcess::SBProcess(const SBProcess &rhs) : m_opaque_wp(rhs.m_opaque_wp) {
- LLDB_RECORD_CONSTRUCTOR(SBProcess, (const lldb::SBProcess &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
}
SBProcess::SBProcess(const lldb::ProcessSP &process_sp)
: m_opaque_wp(process_sp) {
- LLDB_RECORD_CONSTRUCTOR(SBProcess, (const lldb::ProcessSP &), process_sp);
+ LLDB_INSTRUMENT_VA(this, process_sp);
}
const SBProcess &SBProcess::operator=(const SBProcess &rhs) {
- LLDB_RECORD_METHOD(const lldb::SBProcess &,
- SBProcess, operator=,(const lldb::SBProcess &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_wp = rhs.m_opaque_wp;
@@ -75,14 +74,13 @@ const SBProcess &SBProcess::operator=(const SBProcess &rhs) {
SBProcess::~SBProcess() = default;
const char *SBProcess::GetBroadcasterClassName() {
- LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBProcess,
- GetBroadcasterClassName);
+ LLDB_INSTRUMENT();
return Process::GetStaticBroadcasterClass().AsCString();
}
const char *SBProcess::GetPluginName() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetPluginName);
+ LLDB_INSTRUMENT_VA(this);
ProcessSP process_sp(GetSP());
if (process_sp) {
@@ -92,7 +90,7 @@ const char *SBProcess::GetPluginName() {
}
const char *SBProcess::GetShortPluginName() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetShortPluginName);
+ LLDB_INSTRUMENT_VA(this);
ProcessSP process_sp(GetSP());
if (process_sp) {
@@ -106,17 +104,17 @@ lldb::ProcessSP SBProcess::GetSP() const { return m_opaque_wp.lock(); }
void SBProcess::SetSP(const ProcessSP &process_sp) { m_opaque_wp = process_sp; }
void SBProcess::Clear() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBProcess, Clear);
+ LLDB_INSTRUMENT_VA(this);
m_opaque_wp.reset();
}
bool SBProcess::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcess, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBProcess::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcess, operator bool);
+ LLDB_INSTRUMENT_VA(this);
ProcessSP process_sp(m_opaque_wp.lock());
return ((bool)process_sp && process_sp->IsValid());
@@ -128,11 +126,7 @@ bool SBProcess::RemoteLaunch(char const **argv, char const **envp,
const char *working_directory,
uint32_t launch_flags, bool stop_at_entry,
lldb::SBError &error) {
- LLDB_RECORD_METHOD(bool, SBProcess, RemoteLaunch,
- (const char **, const char **, const char *, const char *,
- const char *, const char *, uint32_t, bool,
- lldb::SBError &),
- argv, envp, stdin_path, stdout_path, stderr_path,
+ LLDB_INSTRUMENT_VA(this, argv, envp, stdin_path, stdout_path, stderr_path,
working_directory, launch_flags, stop_at_entry, error);
ProcessSP process_sp(GetSP());
@@ -165,8 +159,7 @@ bool SBProcess::RemoteLaunch(char const **argv, char const **envp,
bool SBProcess::RemoteAttachToProcessWithID(lldb::pid_t pid,
lldb::SBError &error) {
- LLDB_RECORD_METHOD(bool, SBProcess, RemoteAttachToProcessWithID,
- (lldb::pid_t, lldb::SBError &), pid, error);
+ LLDB_INSTRUMENT_VA(this, pid, error);
ProcessSP process_sp(GetSP());
if (process_sp) {
@@ -188,7 +181,7 @@ bool SBProcess::RemoteAttachToProcessWithID(lldb::pid_t pid,
}
uint32_t SBProcess::GetNumThreads() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumThreads);
+ LLDB_INSTRUMENT_VA(this);
uint32_t num_threads = 0;
ProcessSP process_sp(GetSP());
@@ -205,8 +198,7 @@ uint32_t SBProcess::GetNumThreads() {
}
SBThread SBProcess::GetSelectedThread() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBProcess,
- GetSelectedThread);
+ LLDB_INSTRUMENT_VA(this);
SBThread sb_thread;
ThreadSP thread_sp;
@@ -223,8 +215,7 @@ SBThread SBProcess::GetSelectedThread() const {
SBThread SBProcess::CreateOSPluginThread(lldb::tid_t tid,
lldb::addr_t context) {
- LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, CreateOSPluginThread,
- (lldb::tid_t, lldb::addr_t), tid, context);
+ LLDB_INSTRUMENT_VA(this, tid, context);
SBThread sb_thread;
ThreadSP thread_sp;
@@ -240,7 +231,7 @@ SBThread SBProcess::CreateOSPluginThread(lldb::tid_t tid,
}
SBTarget SBProcess::GetTarget() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBTarget, SBProcess, GetTarget);
+ LLDB_INSTRUMENT_VA(this);
SBTarget sb_target;
TargetSP target_sp;
@@ -254,8 +245,7 @@ SBTarget SBProcess::GetTarget() const {
}
size_t SBProcess::PutSTDIN(const char *src, size_t src_len) {
- LLDB_RECORD_METHOD(size_t, SBProcess, PutSTDIN, (const char *, size_t), src,
- src_len);
+ LLDB_INSTRUMENT_VA(this, src, src_len);
size_t ret_val = 0;
ProcessSP process_sp(GetSP());
@@ -268,8 +258,7 @@ size_t SBProcess::PutSTDIN(const char *src, size_t src_len) {
}
size_t SBProcess::GetSTDOUT(char *dst, size_t dst_len) const {
- LLDB_RECORD_METHOD_CONST(size_t, SBProcess, GetSTDOUT, (char *, size_t), dst,
- "", dst_len);
+ LLDB_INSTRUMENT_VA(this, dst, dst_len);
size_t bytes_read = 0;
ProcessSP process_sp(GetSP());
@@ -282,8 +271,7 @@ size_t SBProcess::GetSTDOUT(char *dst, size_t dst_len) const {
}
size_t SBProcess::GetSTDERR(char *dst, size_t dst_len) const {
- LLDB_RECORD_METHOD_CONST(size_t, SBProcess, GetSTDERR, (char *, size_t), dst,
- "", dst_len);
+ LLDB_INSTRUMENT_VA(this, dst, dst_len);
size_t bytes_read = 0;
ProcessSP process_sp(GetSP());
@@ -296,8 +284,7 @@ size_t SBProcess::GetSTDERR(char *dst, size_t dst_len) const {
}
size_t SBProcess::GetAsyncProfileData(char *dst, size_t dst_len) const {
- LLDB_RECORD_METHOD_CONST(size_t, SBProcess, GetAsyncProfileData,
- (char *, size_t), dst, "", dst_len);
+ LLDB_INSTRUMENT_VA(this, dst, dst_len);
size_t bytes_read = 0;
ProcessSP process_sp(GetSP());
@@ -310,23 +297,20 @@ size_t SBProcess::GetAsyncProfileData(char *dst, size_t dst_len) const {
}
void SBProcess::ReportEventState(const SBEvent &event, SBFile out) const {
- LLDB_RECORD_METHOD_CONST(void, SBProcess, ReportEventState,
- (const SBEvent &, SBFile), event, out);
+ LLDB_INSTRUMENT_VA(this, event, out);
return ReportEventState(event, out.m_opaque_sp);
}
void SBProcess::ReportEventState(const SBEvent &event, FILE *out) const {
- LLDB_RECORD_METHOD_CONST(void, SBProcess, ReportEventState,
- (const lldb::SBEvent &, FILE *), event, out);
+ LLDB_INSTRUMENT_VA(this, event, out);
FileSP outfile = std::make_shared<NativeFile>(out, false);
return ReportEventState(event, outfile);
}
void SBProcess::ReportEventState(const SBEvent &event, FileSP out) const {
- LLDB_RECORD_METHOD_CONST(void, SBProcess, ReportEventState,
- (const SBEvent &, FileSP), event, out);
+ LLDB_INSTRUMENT_VA(this, event, out);
if (!out || !out->IsValid())
return;
@@ -342,9 +326,7 @@ void SBProcess::ReportEventState(const SBEvent &event, FileSP out) const {
void SBProcess::AppendEventStateReport(const SBEvent &event,
SBCommandReturnObject &result) {
- LLDB_RECORD_METHOD(void, SBProcess, AppendEventStateReport,
- (const lldb::SBEvent &, lldb::SBCommandReturnObject &),
- event, result);
+ LLDB_INSTRUMENT_VA(this, event, result);
ProcessSP process_sp(GetSP());
if (process_sp) {
@@ -358,8 +340,7 @@ void SBProcess::AppendEventStateReport(const SBEvent &event,
}
bool SBProcess::SetSelectedThread(const SBThread &thread) {
- LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThread,
- (const lldb::SBThread &), thread);
+ LLDB_INSTRUMENT_VA(this, thread);
ProcessSP process_sp(GetSP());
if (process_sp) {
@@ -372,9 +353,7 @@ bool SBProcess::SetSelectedThread(const SBThread &thread) {
}
bool SBProcess::SetSelectedThreadByID(lldb::tid_t tid) {
- LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByID, (lldb::tid_t),
- tid);
-
+ LLDB_INSTRUMENT_VA(this, tid);
bool ret_val = false;
ProcessSP process_sp(GetSP());
@@ -388,8 +367,7 @@ bool SBProcess::SetSelectedThreadByID(lldb::tid_t tid) {
}
bool SBProcess::SetSelectedThreadByIndexID(uint32_t index_id) {
- LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByIndexID, (uint32_t),
- index_id);
+ LLDB_INSTRUMENT_VA(this, index_id);
bool ret_val = false;
ProcessSP process_sp(GetSP());
@@ -404,8 +382,7 @@ bool SBProcess::SetSelectedThreadByIndexID(uint32_t index_id) {
}
SBThread SBProcess::GetThreadAtIndex(size_t index) {
- LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadAtIndex, (size_t),
- index);
+ LLDB_INSTRUMENT_VA(this, index);
SBThread sb_thread;
ThreadSP thread_sp;
@@ -423,7 +400,7 @@ SBThread SBProcess::GetThreadAtIndex(size_t index) {
}
uint32_t SBProcess::GetNumQueues() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumQueues);
+ LLDB_INSTRUMENT_VA(this);
uint32_t num_queues = 0;
ProcessSP process_sp(GetSP());
@@ -440,8 +417,7 @@ uint32_t SBProcess::GetNumQueues() {
}
SBQueue SBProcess::GetQueueAtIndex(size_t index) {
- LLDB_RECORD_METHOD(lldb::SBQueue, SBProcess, GetQueueAtIndex, (size_t),
- index);
+ LLDB_INSTRUMENT_VA(this, index);
SBQueue sb_queue;
QueueSP queue_sp;
@@ -460,8 +436,7 @@ SBQueue SBProcess::GetQueueAtIndex(size_t index) {
}
uint32_t SBProcess::GetStopID(bool include_expression_stops) {
- LLDB_RECORD_METHOD(uint32_t, SBProcess, GetStopID, (bool),
- include_expression_stops);
+ LLDB_INSTRUMENT_VA(this, include_expression_stops);
ProcessSP process_sp(GetSP());
if (process_sp) {
@@ -476,8 +451,7 @@ uint32_t SBProcess::GetStopID(bool include_expression_stops) {
}
SBEvent SBProcess::GetStopEventForStopID(uint32_t stop_id) {
- LLDB_RECORD_METHOD(lldb::SBEvent, SBProcess, GetStopEventForStopID,
- (uint32_t), stop_id);
+ LLDB_INSTRUMENT_VA(this, stop_id);
SBEvent sb_event;
EventSP event_sp;
@@ -493,7 +467,7 @@ SBEvent SBProcess::GetStopEventForStopID(uint32_t stop_id) {
}
StateType SBProcess::GetState() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::StateType, SBProcess, GetState);
+ LLDB_INSTRUMENT_VA(this);
StateType ret_val = eStateInvalid;
ProcessSP process_sp(GetSP());
@@ -507,7 +481,7 @@ StateType SBProcess::GetState() {
}
int SBProcess::GetExitStatus() {
- LLDB_RECORD_METHOD_NO_ARGS(int, SBProcess, GetExitStatus);
+ LLDB_INSTRUMENT_VA(this);
int exit_status = 0;
ProcessSP process_sp(GetSP());
@@ -521,7 +495,7 @@ int SBProcess::GetExitStatus() {
}
const char *SBProcess::GetExitDescription() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetExitDescription);
+ LLDB_INSTRUMENT_VA(this);
const char *exit_desc = nullptr;
ProcessSP process_sp(GetSP());
@@ -534,7 +508,7 @@ const char *SBProcess::GetExitDescription() {
}
lldb::pid_t SBProcess::GetProcessID() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBProcess, GetProcessID);
+ LLDB_INSTRUMENT_VA(this);
lldb::pid_t ret_val = LLDB_INVALID_PROCESS_ID;
ProcessSP process_sp(GetSP());
@@ -545,7 +519,7 @@ lldb::pid_t SBProcess::GetProcessID() {
}
uint32_t SBProcess::GetUniqueID() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetUniqueID);
+ LLDB_INSTRUMENT_VA(this);
uint32_t ret_val = 0;
ProcessSP process_sp(GetSP());
@@ -555,7 +529,7 @@ uint32_t SBProcess::GetUniqueID() {
}
ByteOrder SBProcess::GetByteOrder() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ByteOrder, SBProcess, GetByteOrder);
+ LLDB_INSTRUMENT_VA(this);
ByteOrder byteOrder = eByteOrderInvalid;
ProcessSP process_sp(GetSP());
@@ -567,7 +541,7 @@ ByteOrder SBProcess::GetByteOrder() const {
}
uint32_t SBProcess::GetAddressByteSize() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBProcess, GetAddressByteSize);
+ LLDB_INSTRUMENT_VA(this);
uint32_t size = 0;
ProcessSP process_sp(GetSP());
@@ -579,7 +553,7 @@ uint32_t SBProcess::GetAddressByteSize() const {
}
SBError SBProcess::Continue() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Continue);
+ LLDB_INSTRUMENT_VA(this);
SBError sb_error;
ProcessSP process_sp(GetSP());
@@ -599,7 +573,7 @@ SBError SBProcess::Continue() {
}
SBError SBProcess::Destroy() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Destroy);
+ LLDB_INSTRUMENT_VA(this);
SBError sb_error;
ProcessSP process_sp(GetSP());
@@ -614,7 +588,7 @@ SBError SBProcess::Destroy() {
}
SBError SBProcess::Stop() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Stop);
+ LLDB_INSTRUMENT_VA(this);
SBError sb_error;
ProcessSP process_sp(GetSP());
@@ -629,7 +603,7 @@ SBError SBProcess::Stop() {
}
SBError SBProcess::Kill() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Kill);
+ LLDB_INSTRUMENT_VA(this);
SBError sb_error;
ProcessSP process_sp(GetSP());
@@ -644,7 +618,7 @@ SBError SBProcess::Kill() {
}
SBError SBProcess::Detach() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Detach);
+ LLDB_INSTRUMENT_VA(this);
// FIXME: This should come from a process default.
bool keep_stopped = false;
@@ -652,7 +626,7 @@ SBError SBProcess::Detach() {
}
SBError SBProcess::Detach(bool keep_stopped) {
- LLDB_RECORD_METHOD(lldb::SBError, SBProcess, Detach, (bool), keep_stopped);
+ LLDB_INSTRUMENT_VA(this, keep_stopped);
SBError sb_error;
ProcessSP process_sp(GetSP());
@@ -667,7 +641,7 @@ SBError SBProcess::Detach(bool keep_stopped) {
}
SBError SBProcess::Signal(int signo) {
- LLDB_RECORD_METHOD(lldb::SBError, SBProcess, Signal, (int), signo);
+ LLDB_INSTRUMENT_VA(this, signo);
SBError sb_error;
ProcessSP process_sp(GetSP());
@@ -682,7 +656,7 @@ SBError SBProcess::Signal(int signo) {
}
SBUnixSignals SBProcess::GetUnixSignals() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBUnixSignals, SBProcess, GetUnixSignals);
+ LLDB_INSTRUMENT_VA(this);
if (auto process_sp = GetSP())
return SBUnixSignals{process_sp};
@@ -691,7 +665,7 @@ SBUnixSignals SBProcess::GetUnixSignals() {
}
void SBProcess::SendAsyncInterrupt() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBProcess, SendAsyncInterrupt);
+ LLDB_INSTRUMENT_VA(this);
ProcessSP process_sp(GetSP());
if (process_sp) {
@@ -700,8 +674,7 @@ void SBProcess::SendAsyncInterrupt() {
}
SBThread SBProcess::GetThreadByID(tid_t tid) {
- LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadByID, (lldb::tid_t),
- tid);
+ LLDB_INSTRUMENT_VA(this, tid);
SBThread sb_thread;
ThreadSP thread_sp;
@@ -719,8 +692,7 @@ SBThread SBProcess::GetThreadByID(tid_t tid) {
}
SBThread SBProcess::GetThreadByIndexID(uint32_t index_id) {
- LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadByIndexID, (uint32_t),
- index_id);
+ LLDB_INSTRUMENT_VA(this, index_id);
SBThread sb_thread;
ThreadSP thread_sp;
@@ -739,8 +711,7 @@ SBThread SBProcess::GetThreadByIndexID(uint32_t index_id) {
}
StateType SBProcess::GetStateFromEvent(const SBEvent &event) {
- LLDB_RECORD_STATIC_METHOD(lldb::StateType, SBProcess, GetStateFromEvent,
- (const lldb::SBEvent &), event);
+ LLDB_INSTRUMENT_VA(event);
StateType ret_val = Process::ProcessEventData::GetStateFromEvent(event.get());
@@ -748,8 +719,7 @@ StateType SBProcess::GetStateFromEvent(const SBEvent &event) {
}
bool SBProcess::GetRestartedFromEvent(const SBEvent &event) {
- LLDB_RECORD_STATIC_METHOD(bool, SBProcess, GetRestartedFromEvent,
- (const lldb::SBEvent &), event);
+ LLDB_INSTRUMENT_VA(event);
bool ret_val = Process::ProcessEventData::GetRestartedFromEvent(event.get());
@@ -757,8 +727,7 @@ bool SBProcess::GetRestartedFromEvent(const SBEvent &event) {
}
size_t SBProcess::GetNumRestartedReasonsFromEvent(const lldb::SBEvent &event) {
- LLDB_RECORD_STATIC_METHOD(size_t, SBProcess, GetNumRestartedReasonsFromEvent,
- (const lldb::SBEvent &), event);
+ LLDB_INSTRUMENT_VA(event);
return Process::ProcessEventData::GetNumRestartedReasons(event.get());
}
@@ -766,16 +735,13 @@ size_t SBProcess::GetNumRestartedReasonsFromEvent(const lldb::SBEvent &event) {
const char *
SBProcess::GetRestartedReasonAtIndexFromEvent(const lldb::SBEvent &event,
size_t idx) {
- LLDB_RECORD_STATIC_METHOD(const char *, SBProcess,
- GetRestartedReasonAtIndexFromEvent,
- (const lldb::SBEvent &, size_t), event, idx);
+ LLDB_INSTRUMENT_VA(event, idx);
return Process::ProcessEventData::GetRestartedReasonAtIndex(event.get(), idx);
}
SBProcess SBProcess::GetProcessFromEvent(const SBEvent &event) {
- LLDB_RECORD_STATIC_METHOD(lldb::SBProcess, SBProcess, GetProcessFromEvent,
- (const lldb::SBEvent &), event);
+ LLDB_INSTRUMENT_VA(event);
ProcessSP process_sp =
Process::ProcessEventData::GetProcessFromEvent(event.get());
@@ -788,32 +754,27 @@ SBProcess SBProcess::GetProcessFromEvent(const SBEvent &event) {
}
bool SBProcess::GetInterruptedFromEvent(const SBEvent &event) {
- LLDB_RECORD_STATIC_METHOD(bool, SBProcess, GetInterruptedFromEvent,
- (const lldb::SBEvent &), event);
+ LLDB_INSTRUMENT_VA(event);
return Process::ProcessEventData::GetInterruptedFromEvent(event.get());
}
lldb::SBStructuredData
SBProcess::GetStructuredDataFromEvent(const lldb::SBEvent &event) {
- LLDB_RECORD_STATIC_METHOD(lldb::SBStructuredData, SBProcess,
- GetStructuredDataFromEvent, (const lldb::SBEvent &),
- event);
+ LLDB_INSTRUMENT_VA(event);
return SBStructuredData(event.GetSP());
}
bool SBProcess::EventIsProcessEvent(const SBEvent &event) {
- LLDB_RECORD_STATIC_METHOD(bool, SBProcess, EventIsProcessEvent,
- (const lldb::SBEvent &), event);
+ LLDB_INSTRUMENT_VA(event);
return (event.GetBroadcasterClass() == SBProcess::GetBroadcasterClass()) &&
!EventIsStructuredDataEvent(event);
}
bool SBProcess::EventIsStructuredDataEvent(const lldb::SBEvent &event) {
- LLDB_RECORD_STATIC_METHOD(bool, SBProcess, EventIsStructuredDataEvent,
- (const lldb::SBEvent &), event);
+ LLDB_INSTRUMENT_VA(event);
EventSP event_sp = event.GetSP();
EventData *event_data = event_sp ? event_sp->GetData() : nullptr;
@@ -822,9 +783,7 @@ bool SBProcess::EventIsStructuredDataEvent(const lldb::SBEvent &event) {
}
SBBroadcaster SBProcess::GetBroadcaster() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBProcess,
- GetBroadcaster);
-
+ LLDB_INSTRUMENT_VA(this);
ProcessSP process_sp(GetSP());
@@ -834,17 +793,14 @@ SBBroadcaster SBProcess::GetBroadcaster() const {
}
const char *SBProcess::GetBroadcasterClass() {
- LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBProcess,
- GetBroadcasterClass);
+ LLDB_INSTRUMENT();
return Process::GetStaticBroadcasterClass().AsCString();
}
size_t SBProcess::ReadMemory(addr_t addr, void *dst, size_t dst_len,
SBError &sb_error) {
- LLDB_RECORD_METHOD(size_t, SBProcess, ReadMemory,
- (lldb::addr_t, void *, size_t, lldb::SBError &), addr, dst,
- dst_len, sb_error);
+ LLDB_INSTRUMENT_VA(this, addr, dst, dst_len, sb_error);
size_t bytes_read = 0;
@@ -869,9 +825,7 @@ size_t SBProcess::ReadMemory(addr_t addr, void *dst, size_t dst_len,
size_t SBProcess::ReadCStringFromMemory(addr_t addr, void *buf, size_t size,
lldb::SBError &sb_error) {
- LLDB_RECORD_METHOD(size_t, SBProcess, ReadCStringFromMemory,
- (lldb::addr_t, void *, size_t, lldb::SBError &), addr, buf,
- size, sb_error);
+ LLDB_INSTRUMENT_VA(this, addr, buf, size, sb_error);
size_t bytes_read = 0;
ProcessSP process_sp(GetSP());
@@ -893,9 +847,7 @@ size_t SBProcess::ReadCStringFromMemory(addr_t addr, void *buf, size_t size,
uint64_t SBProcess::ReadUnsignedFromMemory(addr_t addr, uint32_t byte_size,
lldb::SBError &sb_error) {
- LLDB_RECORD_METHOD(uint64_t, SBProcess, ReadUnsignedFromMemory,
- (lldb::addr_t, uint32_t, lldb::SBError &), addr, byte_size,
- sb_error);
+ LLDB_INSTRUMENT_VA(this, addr, byte_size, sb_error);
uint64_t value = 0;
ProcessSP process_sp(GetSP());
@@ -917,8 +869,7 @@ uint64_t SBProcess::ReadUnsignedFromMemory(addr_t addr, uint32_t byte_size,
lldb::addr_t SBProcess::ReadPointerFromMemory(addr_t addr,
lldb::SBError &sb_error) {
- LLDB_RECORD_METHOD(lldb::addr_t, SBProcess, ReadPointerFromMemory,
- (lldb::addr_t, lldb::SBError &), addr, sb_error);
+ LLDB_INSTRUMENT_VA(this, addr, sb_error);
lldb::addr_t ptr = LLDB_INVALID_ADDRESS;
ProcessSP process_sp(GetSP());
@@ -939,9 +890,7 @@ lldb::addr_t SBProcess::ReadPointerFromMemory(addr_t addr,
size_t SBProcess::WriteMemory(addr_t addr, const void *src, size_t src_len,
SBError &sb_error) {
- LLDB_RECORD_METHOD(size_t, SBProcess, WriteMemory,
- (lldb::addr_t, const void *, size_t, lldb::SBError &),
- addr, src, src_len, sb_error);
+ LLDB_INSTRUMENT_VA(this, addr, src, src_len, sb_error);
size_t bytes_written = 0;
@@ -963,8 +912,7 @@ size_t SBProcess::WriteMemory(addr_t addr, const void *src, size_t src_len,
}
bool SBProcess::GetDescription(SBStream &description) {
- LLDB_RECORD_METHOD(bool, SBProcess, GetDescription, (lldb::SBStream &),
- description);
+ LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();
@@ -988,8 +936,7 @@ bool SBProcess::GetDescription(SBStream &description) {
}
SBStructuredData SBProcess::GetExtendedCrashInformation() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStructuredData, SBProcess,
- GetExtendedCrashInformation);
+ LLDB_INSTRUMENT_VA(this);
SBStructuredData data;
ProcessSP process_sp(GetSP());
if (!process_sp)
@@ -1013,9 +960,7 @@ SBStructuredData SBProcess::GetExtendedCrashInformation() {
uint32_t
SBProcess::GetNumSupportedHardwareWatchpoints(lldb::SBError &sb_error) const {
- LLDB_RECORD_METHOD_CONST(uint32_t, SBProcess,
- GetNumSupportedHardwareWatchpoints,
- (lldb::SBError &), sb_error);
+ LLDB_INSTRUMENT_VA(this, sb_error);
uint32_t num = 0;
ProcessSP process_sp(GetSP());
@@ -1031,9 +976,7 @@ SBProcess::GetNumSupportedHardwareWatchpoints(lldb::SBError &sb_error) const {
uint32_t SBProcess::LoadImage(lldb::SBFileSpec &sb_remote_image_spec,
lldb::SBError &sb_error) {
- LLDB_RECORD_METHOD(uint32_t, SBProcess, LoadImage,
- (lldb::SBFileSpec &, lldb::SBError &),
- sb_remote_image_spec, sb_error);
+ LLDB_INSTRUMENT_VA(this, sb_remote_image_spec, sb_error);
return LoadImage(SBFileSpec(), sb_remote_image_spec, sb_error);
}
@@ -1041,10 +984,7 @@ uint32_t SBProcess::LoadImage(lldb::SBFileSpec &sb_remote_image_spec,
uint32_t SBProcess::LoadImage(const lldb::SBFileSpec &sb_local_image_spec,
const lldb::SBFileSpec &sb_remote_image_spec,
lldb::SBError &sb_error) {
- LLDB_RECORD_METHOD(
- uint32_t, SBProcess, LoadImage,
- (const lldb::SBFileSpec &, const lldb::SBFileSpec &, lldb::SBError &),
- sb_local_image_spec, sb_remote_image_spec, sb_error);
+ LLDB_INSTRUMENT_VA(this, sb_local_image_spec, sb_remote_image_spec, sb_error);
ProcessSP process_sp(GetSP());
if (process_sp) {
@@ -1068,10 +1008,7 @@ uint32_t SBProcess::LoadImageUsingPaths(const lldb::SBFileSpec &image_spec,
SBStringList &paths,
lldb::SBFileSpec &loaded_path,
lldb::SBError &error) {
- LLDB_RECORD_METHOD(uint32_t, SBProcess, LoadImageUsingPaths,
- (const lldb::SBFileSpec &, lldb::SBStringList &,
- lldb::SBFileSpec &, lldb::SBError &),
- image_spec, paths, loaded_path, error);
+ LLDB_INSTRUMENT_VA(this, image_spec, paths, loaded_path, error);
ProcessSP process_sp(GetSP());
if (process_sp) {
@@ -1103,8 +1040,7 @@ uint32_t SBProcess::LoadImageUsingPaths(const lldb::SBFileSpec &image_spec,
}
lldb::SBError SBProcess::UnloadImage(uint32_t image_token) {
- LLDB_RECORD_METHOD(lldb::SBError, SBProcess, UnloadImage, (uint32_t),
- image_token);
+ LLDB_INSTRUMENT_VA(this, image_token);
lldb::SBError sb_error;
ProcessSP process_sp(GetSP());
@@ -1125,8 +1061,7 @@ lldb::SBError SBProcess::UnloadImage(uint32_t image_token) {
}
lldb::SBError SBProcess::SendEventData(const char *event_data) {
- LLDB_RECORD_METHOD(lldb::SBError, SBProcess, SendEventData, (const char *),
- event_data);
+ LLDB_INSTRUMENT_VA(this, event_data);
lldb::SBError sb_error;
ProcessSP process_sp(GetSP());
@@ -1145,7 +1080,7 @@ lldb::SBError SBProcess::SendEventData(const char *event_data) {
}
uint32_t SBProcess::GetNumExtendedBacktraceTypes() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumExtendedBacktraceTypes);
+ LLDB_INSTRUMENT_VA(this);
ProcessSP process_sp(GetSP());
if (process_sp && process_sp->GetSystemRuntime()) {
@@ -1156,8 +1091,7 @@ uint32_t SBProcess::GetNumExtendedBacktraceTypes() {
}
const char *SBProcess::GetExtendedBacktraceTypeAtIndex(uint32_t idx) {
- LLDB_RECORD_METHOD(const char *, SBProcess, GetExtendedBacktraceTypeAtIndex,
- (uint32_t), idx);
+ LLDB_INSTRUMENT_VA(this, idx);
ProcessSP process_sp(GetSP());
if (process_sp && process_sp->GetSystemRuntime()) {
@@ -1172,8 +1106,7 @@ const char *SBProcess::GetExtendedBacktraceTypeAtIndex(uint32_t idx) {
}
SBThreadCollection SBProcess::GetHistoryThreads(addr_t addr) {
- LLDB_RECORD_METHOD(lldb::SBThreadCollection, SBProcess, GetHistoryThreads,
- (lldb::addr_t), addr);
+ LLDB_INSTRUMENT_VA(this, addr);
ProcessSP process_sp(GetSP());
SBThreadCollection threads;
@@ -1185,8 +1118,7 @@ SBThreadCollection SBProcess::GetHistoryThreads(addr_t addr) {
bool SBProcess::IsInstrumentationRuntimePresent(
InstrumentationRuntimeType type) {
- LLDB_RECORD_METHOD(bool, SBProcess, IsInstrumentationRuntimePresent,
- (lldb::InstrumentationRuntimeType), type);
+ LLDB_INSTRUMENT_VA(this, type);
ProcessSP process_sp(GetSP());
if (!process_sp)
@@ -1205,8 +1137,7 @@ bool SBProcess::IsInstrumentationRuntimePresent(
}
lldb::SBError SBProcess::SaveCore(const char *file_name) {
- LLDB_RECORD_METHOD(lldb::SBError, SBProcess, SaveCore, (const char *),
- file_name);
+ LLDB_INSTRUMENT_VA(this, file_name);
lldb::SBError error;
ProcessSP process_sp(GetSP());
@@ -1232,9 +1163,7 @@ lldb::SBError SBProcess::SaveCore(const char *file_name) {
lldb::SBError
SBProcess::GetMemoryRegionInfo(lldb::addr_t load_addr,
SBMemoryRegionInfo &sb_region_info) {
- LLDB_RECORD_METHOD(lldb::SBError, SBProcess, GetMemoryRegionInfo,
- (lldb::addr_t, lldb::SBMemoryRegionInfo &), load_addr,
- sb_region_info);
+ LLDB_INSTRUMENT_VA(this, load_addr, sb_region_info);
lldb::SBError sb_error;
ProcessSP process_sp(GetSP());
@@ -1256,8 +1185,7 @@ SBProcess::GetMemoryRegionInfo(lldb::addr_t load_addr,
}
lldb::SBMemoryRegionInfoList SBProcess::GetMemoryRegions() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBMemoryRegionInfoList, SBProcess,
- GetMemoryRegions);
+ LLDB_INSTRUMENT_VA(this);
lldb::SBMemoryRegionInfoList sb_region_list;
@@ -1274,7 +1202,7 @@ lldb::SBMemoryRegionInfoList SBProcess::GetMemoryRegions() {
}
lldb::SBProcessInfo SBProcess::GetProcessInfo() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcessInfo, SBProcess, GetProcessInfo);
+ LLDB_INSTRUMENT_VA(this);
lldb::SBProcessInfo sb_proc_info;
ProcessSP process_sp(GetSP());
@@ -1287,9 +1215,7 @@ lldb::SBProcessInfo SBProcess::GetProcessInfo() {
lldb::addr_t SBProcess::AllocateMemory(size_t size, uint32_t permissions,
lldb::SBError &sb_error) {
- LLDB_RECORD_METHOD(lldb::addr_t, SBProcess, AllocateMemory,
- (size_t, uint32_t, lldb::SBError &), size, permissions,
- sb_error);
+ LLDB_INSTRUMENT_VA(this, size, permissions, sb_error);
lldb::addr_t addr = LLDB_INVALID_ADDRESS;
ProcessSP process_sp(GetSP());
@@ -1309,8 +1235,7 @@ lldb::addr_t SBProcess::AllocateMemory(size_t size, uint32_t permissions,
}
lldb::SBError SBProcess::DeallocateMemory(lldb::addr_t ptr) {
- LLDB_RECORD_METHOD(lldb::SBError, SBProcess, DeallocateMemory, (lldb::addr_t),
- ptr);
+ LLDB_INSTRUMENT_VA(this, ptr);
lldb::SBError sb_error;
ProcessSP process_sp(GetSP());
diff --git a/lldb/source/API/SBProcessInfo.cpp b/lldb/source/API/SBProcessInfo.cpp
index 93d84d288031..da3db75ff47e 100644
--- a/lldb/source/API/SBProcessInfo.cpp
+++ b/lldb/source/API/SBProcessInfo.cpp
@@ -7,20 +7,18 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBProcessInfo.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/API/SBFileSpec.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/ProcessInfo.h"
using namespace lldb;
using namespace lldb_private;
-SBProcessInfo::SBProcessInfo() {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBProcessInfo);
-}
+SBProcessInfo::SBProcessInfo() { LLDB_INSTRUMENT_VA(this); }
SBProcessInfo::SBProcessInfo(const SBProcessInfo &rhs) {
- LLDB_RECORD_CONSTRUCTOR(SBProcessInfo, (const lldb::SBProcessInfo &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_up = clone(rhs.m_opaque_up);
}
@@ -28,9 +26,7 @@ SBProcessInfo::SBProcessInfo(const SBProcessInfo &rhs) {
SBProcessInfo::~SBProcessInfo() = default;
SBProcessInfo &SBProcessInfo::operator=(const SBProcessInfo &rhs) {
- LLDB_RECORD_METHOD(lldb::SBProcessInfo &,
- SBProcessInfo, operator=,(const lldb::SBProcessInfo &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
@@ -49,17 +45,17 @@ void SBProcessInfo::SetProcessInfo(const ProcessInstanceInfo &proc_info_ref) {
}
bool SBProcessInfo::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcessInfo, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBProcessInfo::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcessInfo, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up != nullptr;
}
const char *SBProcessInfo::GetName() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcessInfo, GetName);
+ LLDB_INSTRUMENT_VA(this);
const char *name = nullptr;
if (m_opaque_up) {
@@ -69,8 +65,7 @@ const char *SBProcessInfo::GetName() {
}
SBFileSpec SBProcessInfo::GetExecutableFile() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBProcessInfo,
- GetExecutableFile);
+ LLDB_INSTRUMENT_VA(this);
SBFileSpec file_spec;
if (m_opaque_up) {
@@ -80,7 +75,7 @@ SBFileSpec SBProcessInfo::GetExecutableFile() {
}
lldb::pid_t SBProcessInfo::GetProcessID() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBProcessInfo, GetProcessID);
+ LLDB_INSTRUMENT_VA(this);
lldb::pid_t proc_id = LLDB_INVALID_PROCESS_ID;
if (m_opaque_up) {
@@ -90,7 +85,7 @@ lldb::pid_t SBProcessInfo::GetProcessID() {
}
uint32_t SBProcessInfo::GetUserID() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetUserID);
+ LLDB_INSTRUMENT_VA(this);
uint32_t user_id = UINT32_MAX;
if (m_opaque_up) {
@@ -100,7 +95,7 @@ uint32_t SBProcessInfo::GetUserID() {
}
uint32_t SBProcessInfo::GetGroupID() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetGroupID);
+ LLDB_INSTRUMENT_VA(this);
uint32_t group_id = UINT32_MAX;
if (m_opaque_up) {
@@ -110,7 +105,7 @@ uint32_t SBProcessInfo::GetGroupID() {
}
bool SBProcessInfo::UserIDIsValid() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, UserIDIsValid);
+ LLDB_INSTRUMENT_VA(this);
bool is_valid = false;
if (m_opaque_up) {
@@ -120,7 +115,7 @@ bool SBProcessInfo::UserIDIsValid() {
}
bool SBProcessInfo::GroupIDIsValid() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, GroupIDIsValid);
+ LLDB_INSTRUMENT_VA(this);
bool is_valid = false;
if (m_opaque_up) {
@@ -130,7 +125,7 @@ bool SBProcessInfo::GroupIDIsValid() {
}
uint32_t SBProcessInfo::GetEffectiveUserID() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetEffectiveUserID);
+ LLDB_INSTRUMENT_VA(this);
uint32_t user_id = UINT32_MAX;
if (m_opaque_up) {
@@ -140,7 +135,7 @@ uint32_t SBProcessInfo::GetEffectiveUserID() {
}
uint32_t SBProcessInfo::GetEffectiveGroupID() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetEffectiveGroupID);
+ LLDB_INSTRUMENT_VA(this);
uint32_t group_id = UINT32_MAX;
if (m_opaque_up) {
@@ -150,7 +145,7 @@ uint32_t SBProcessInfo::GetEffectiveGroupID() {
}
bool SBProcessInfo::EffectiveUserIDIsValid() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, EffectiveUserIDIsValid);
+ LLDB_INSTRUMENT_VA(this);
bool is_valid = false;
if (m_opaque_up) {
@@ -160,7 +155,7 @@ bool SBProcessInfo::EffectiveUserIDIsValid() {
}
bool SBProcessInfo::EffectiveGroupIDIsValid() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, EffectiveGroupIDIsValid);
+ LLDB_INSTRUMENT_VA(this);
bool is_valid = false;
if (m_opaque_up) {
@@ -170,7 +165,7 @@ bool SBProcessInfo::EffectiveGroupIDIsValid() {
}
lldb::pid_t SBProcessInfo::GetParentProcessID() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBProcessInfo, GetParentProcessID);
+ LLDB_INSTRUMENT_VA(this);
lldb::pid_t proc_id = LLDB_INVALID_PROCESS_ID;
if (m_opaque_up) {
@@ -180,7 +175,7 @@ lldb::pid_t SBProcessInfo::GetParentProcessID() {
}
const char *SBProcessInfo::GetTriple() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcessInfo, GetTriple);
+ LLDB_INSTRUMENT_VA(this);
const char *triple = nullptr;
if (m_opaque_up) {
diff --git a/lldb/source/API/SBQueue.cpp b/lldb/source/API/SBQueue.cpp
index debb82173067..b2c143f6357e 100644
--- a/lldb/source/API/SBQueue.cpp
+++ b/lldb/source/API/SBQueue.cpp
@@ -8,8 +8,8 @@
#include <cinttypes>
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBQueue.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/API/SBProcess.h"
#include "lldb/API/SBQueueItem.h"
@@ -215,17 +215,15 @@ class QueueImpl {
};
}
-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;
@@ -234,8 +232,7 @@ 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 *this;
@@ -244,17 +241,17 @@ const lldb::SBQueue &SBQueue::operator=(const lldb::SBQueue &rhs) {
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();
}
@@ -264,65 +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 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 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 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();
}
diff --git a/lldb/source/API/SBQueueItem.cpp b/lldb/source/API/SBQueueItem.cpp
index f28f2d69aa9e..b2204452c0fa 100644
--- a/lldb/source/API/SBQueueItem.cpp
+++ b/lldb/source/API/SBQueueItem.cpp
@@ -8,7 +8,6 @@
#include "lldb/lldb-forward.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBQueueItem.h"
#include "lldb/API/SBThread.h"
@@ -16,47 +15,46 @@
#include "lldb/Target/Process.h"
#include "lldb/Target/QueueItem.h"
#include "lldb/Target/Thread.h"
+#include "lldb/Utility/Instrumentation.h"
using namespace lldb;
using namespace lldb_private;
// Constructors
-SBQueueItem::SBQueueItem() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBQueueItem); }
+SBQueueItem::SBQueueItem() { LLDB_INSTRUMENT_VA(this); }
SBQueueItem::SBQueueItem(const QueueItemSP &queue_item_sp)
: m_queue_item_sp(queue_item_sp) {
- LLDB_RECORD_CONSTRUCTOR(SBQueueItem, (const lldb::QueueItemSP &),
- queue_item_sp);
+ LLDB_INSTRUMENT_VA(this, queue_item_sp);
}
// Destructor
SBQueueItem::~SBQueueItem() { m_queue_item_sp.reset(); }
bool SBQueueItem::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBQueueItem, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBQueueItem::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBQueueItem, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_queue_item_sp.get() != nullptr;
}
void SBQueueItem::Clear() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBQueueItem, Clear);
+ LLDB_INSTRUMENT_VA(this);
m_queue_item_sp.reset();
}
void SBQueueItem::SetQueueItem(const QueueItemSP &queue_item_sp) {
- LLDB_RECORD_METHOD(void, SBQueueItem, SetQueueItem,
- (const lldb::QueueItemSP &), queue_item_sp);
+ LLDB_INSTRUMENT_VA(this, queue_item_sp);
m_queue_item_sp = queue_item_sp;
}
lldb::QueueItemKind SBQueueItem::GetKind() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::QueueItemKind, SBQueueItem, GetKind);
+ LLDB_INSTRUMENT_VA(this);
QueueItemKind result = eQueueItemKindUnknown;
if (m_queue_item_sp) {
@@ -66,7 +64,7 @@ lldb::QueueItemKind SBQueueItem::GetKind() const {
}
void SBQueueItem::SetKind(lldb::QueueItemKind kind) {
- LLDB_RECORD_METHOD(void, SBQueueItem, SetKind, (lldb::QueueItemKind), kind);
+ LLDB_INSTRUMENT_VA(this, kind);
if (m_queue_item_sp) {
m_queue_item_sp->SetKind(kind);
@@ -74,7 +72,7 @@ void SBQueueItem::SetKind(lldb::QueueItemKind kind) {
}
SBAddress SBQueueItem::GetAddress() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBQueueItem, GetAddress);
+ LLDB_INSTRUMENT_VA(this);
SBAddress result;
if (m_queue_item_sp) {
@@ -84,7 +82,7 @@ SBAddress SBQueueItem::GetAddress() const {
}
void SBQueueItem::SetAddress(SBAddress addr) {
- LLDB_RECORD_METHOD(void, SBQueueItem, SetAddress, (lldb::SBAddress), addr);
+ LLDB_INSTRUMENT_VA(this, addr);
if (m_queue_item_sp) {
m_queue_item_sp->SetAddress(addr.ref());
@@ -92,8 +90,7 @@ void SBQueueItem::SetAddress(SBAddress addr) {
}
SBThread SBQueueItem::GetExtendedBacktraceThread(const char *type) {
- LLDB_RECORD_METHOD(lldb::SBThread, SBQueueItem, GetExtendedBacktraceThread,
- (const char *), type);
+ LLDB_INSTRUMENT_VA(this, type);
SBThread result;
if (m_queue_item_sp) {
diff --git a/lldb/source/API/SBReproducer.cpp b/lldb/source/API/SBReproducer.cpp
index ba564c911b72..d3d27cc57748 100644
--- a/lldb/source/API/SBReproducer.cpp
+++ b/lldb/source/API/SBReproducer.cpp
@@ -6,7 +6,7 @@
//
//===----------------------------------------------------------------------===//
-
+#include "lldb/API/SBReproducer.h"
#include "lldb/API/LLDB.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBAttachInfo.h"
@@ -20,12 +20,11 @@
#include "lldb/API/SBError.h"
#include "lldb/API/SBFileSpec.h"
#include "lldb/API/SBHostOS.h"
-#include "lldb/API/SBReproducer.h"
#include "lldb/Host/FileSystem.h"
-#include "lldb/Version/Version.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/Reproducer.h"
#include "lldb/Utility/ReproducerProvider.h"
+#include "lldb/Version/Version.h"
using namespace lldb;
using namespace lldb_private;
@@ -40,25 +39,33 @@ SBReplayOptions::SBReplayOptions(const SBReplayOptions &rhs)
SBReplayOptions::~SBReplayOptions() = default;
SBReplayOptions &SBReplayOptions::operator=(const SBReplayOptions &rhs) {
+ LLDB_INSTRUMENT_VA(this, rhs)
if (this == &rhs)
return *this;
*m_opaque_up = *rhs.m_opaque_up;
return *this;
}
-void SBReplayOptions::SetVerify(bool verify) { m_opaque_up->verify = verify; }
+void SBReplayOptions::SetVerify(bool verify) {
+ LLDB_INSTRUMENT_VA(this, verify) m_opaque_up->verify = verify;
+}
-bool SBReplayOptions::GetVerify() const { return m_opaque_up->verify; }
+bool SBReplayOptions::GetVerify() const {
+ LLDB_INSTRUMENT_VA(this) return m_opaque_up->verify;
+}
void SBReplayOptions::SetCheckVersion(bool check) {
+ LLDB_INSTRUMENT_VA(this, check)
m_opaque_up->check_version = check;
}
bool SBReplayOptions::GetCheckVersion() const {
+ LLDB_INSTRUMENT_VA(this)
return m_opaque_up->check_version;
}
const char *SBReproducer::Capture() {
+ LLDB_INSTRUMENT()
static std::string error;
if (auto e = Reproducer::Initialize(ReproducerMode::Capture, llvm::None)) {
error = llvm::toString(std::move(e));
@@ -69,6 +76,7 @@ const char *SBReproducer::Capture() {
}
const char *SBReproducer::Capture(const char *path) {
+ LLDB_INSTRUMENT_VA(path)
static std::string error;
if (auto e =
Reproducer::Initialize(ReproducerMode::Capture, FileSpec(path))) {
@@ -80,23 +88,28 @@ const char *SBReproducer::Capture(const char *path) {
}
const char *SBReproducer::PassiveReplay(const char *path) {
+ LLDB_INSTRUMENT_VA(path)
return "Reproducer replay has been removed";
}
const char *SBReproducer::Replay(const char *path) {
+ LLDB_INSTRUMENT_VA(path)
return "Reproducer replay has been removed";
}
const char *SBReproducer::Replay(const char *path, bool skip_version_check) {
+ LLDB_INSTRUMENT_VA(path, skip_version_check)
return Replay(path);
}
const char *SBReproducer::Replay(const char *path,
const SBReplayOptions &options) {
+ LLDB_INSTRUMENT_VA(path, options)
return Replay(path);
}
const char *SBReproducer::Finalize(const char *path) {
+ LLDB_INSTRUMENT_VA(path)
static std::string error;
repro::Loader *loader = repro::Reproducer::Instance().GetLoader();
@@ -114,6 +127,7 @@ const char *SBReproducer::Finalize(const char *path) {
}
bool SBReproducer::Generate() {
+ LLDB_INSTRUMENT()
auto &r = Reproducer::Instance();
if (auto generator = r.GetGenerator()) {
generator->Keep();
@@ -123,6 +137,7 @@ bool SBReproducer::Generate() {
}
bool SBReproducer::SetAutoGenerate(bool b) {
+ LLDB_INSTRUMENT_VA(b)
auto &r = Reproducer::Instance();
if (auto generator = r.GetGenerator()) {
generator->SetAutoGenerate(b);
@@ -132,6 +147,7 @@ bool SBReproducer::SetAutoGenerate(bool b) {
}
const char *SBReproducer::GetPath() {
+ LLDB_INSTRUMENT()
ConstString path;
auto &r = Reproducer::Instance();
if (FileSpec reproducer_path = Reproducer::Instance().GetReproducerPath())
@@ -140,6 +156,7 @@ const char *SBReproducer::GetPath() {
}
void SBReproducer::SetWorkingDirectory(const char *path) {
+ LLDB_INSTRUMENT_VA(path)
if (auto *g = lldb_private::repro::Reproducer::Instance().GetGenerator()) {
auto &wp = g->GetOrCreate<repro::WorkingDirectoryProvider>();
wp.SetDirectory(path);
diff --git a/lldb/source/API/SBSection.cpp b/lldb/source/API/SBSection.cpp
index aa068518f946..733e0db0b5ba 100644
--- a/lldb/source/API/SBSection.cpp
+++ b/lldb/source/API/SBSection.cpp
@@ -7,7 +7,6 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBSection.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBTarget.h"
#include "lldb/Core/Module.h"
@@ -15,15 +14,16 @@
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Utility/DataBuffer.h"
#include "lldb/Utility/DataExtractor.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb;
using namespace lldb_private;
-SBSection::SBSection() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSection); }
+SBSection::SBSection() { LLDB_INSTRUMENT_VA(this); }
SBSection::SBSection(const SBSection &rhs) : m_opaque_wp(rhs.m_opaque_wp) {
- LLDB_RECORD_CONSTRUCTOR(SBSection, (const lldb::SBSection &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
}
SBSection::SBSection(const lldb::SectionSP §ion_sp) {
@@ -34,8 +34,7 @@ SBSection::SBSection(const lldb::SectionSP §ion_sp) {
}
const SBSection &SBSection::operator=(const SBSection &rhs) {
- LLDB_RECORD_METHOD(const lldb::SBSection &,
- SBSection, operator=,(const lldb::SBSection &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_wp = rhs.m_opaque_wp;
return *this;
@@ -44,18 +43,18 @@ const SBSection &SBSection::operator=(const SBSection &rhs) {
SBSection::~SBSection() = default;
bool SBSection::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSection, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBSection::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSection, operator bool);
+ LLDB_INSTRUMENT_VA(this);
SectionSP section_sp(GetSP());
return section_sp && section_sp->GetModule().get() != nullptr;
}
const char *SBSection::GetName() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBSection, GetName);
+ LLDB_INSTRUMENT_VA(this);
SectionSP section_sp(GetSP());
if (section_sp)
@@ -64,7 +63,7 @@ const char *SBSection::GetName() {
}
lldb::SBSection SBSection::GetParent() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSection, SBSection, GetParent);
+ LLDB_INSTRUMENT_VA(this);
lldb::SBSection sb_section;
SectionSP section_sp(GetSP());
@@ -77,8 +76,7 @@ lldb::SBSection SBSection::GetParent() {
}
lldb::SBSection SBSection::FindSubSection(const char *sect_name) {
- LLDB_RECORD_METHOD(lldb::SBSection, SBSection, FindSubSection, (const char *),
- sect_name);
+ LLDB_INSTRUMENT_VA(this, sect_name);
lldb::SBSection sb_section;
if (sect_name) {
@@ -93,7 +91,7 @@ lldb::SBSection SBSection::FindSubSection(const char *sect_name) {
}
size_t SBSection::GetNumSubSections() {
- LLDB_RECORD_METHOD_NO_ARGS(size_t, SBSection, GetNumSubSections);
+ LLDB_INSTRUMENT_VA(this);
SectionSP section_sp(GetSP());
if (section_sp)
@@ -102,8 +100,7 @@ size_t SBSection::GetNumSubSections() {
}
lldb::SBSection SBSection::GetSubSectionAtIndex(size_t idx) {
- LLDB_RECORD_METHOD(lldb::SBSection, SBSection, GetSubSectionAtIndex, (size_t),
- idx);
+ LLDB_INSTRUMENT_VA(this, idx);
lldb::SBSection sb_section;
SectionSP section_sp(GetSP());
@@ -119,7 +116,7 @@ void SBSection::SetSP(const lldb::SectionSP §ion_sp) {
}
lldb::addr_t SBSection::GetFileAddress() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBSection, GetFileAddress);
+ LLDB_INSTRUMENT_VA(this);
lldb::addr_t file_addr = LLDB_INVALID_ADDRESS;
SectionSP section_sp(GetSP());
@@ -129,8 +126,7 @@ lldb::addr_t SBSection::GetFileAddress() {
}
lldb::addr_t SBSection::GetLoadAddress(lldb::SBTarget &sb_target) {
- LLDB_RECORD_METHOD(lldb::addr_t, SBSection, GetLoadAddress,
- (lldb::SBTarget &), sb_target);
+ LLDB_INSTRUMENT_VA(this, sb_target);
TargetSP target_sp(sb_target.GetSP());
if (target_sp) {
@@ -142,7 +138,7 @@ lldb::addr_t SBSection::GetLoadAddress(lldb::SBTarget &sb_target) {
}
lldb::addr_t SBSection::GetByteSize() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBSection, GetByteSize);
+ LLDB_INSTRUMENT_VA(this);
SectionSP section_sp(GetSP());
if (section_sp)
@@ -151,7 +147,7 @@ lldb::addr_t SBSection::GetByteSize() {
}
uint64_t SBSection::GetFileOffset() {
- LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBSection, GetFileOffset);
+ LLDB_INSTRUMENT_VA(this);
SectionSP section_sp(GetSP());
if (section_sp) {
@@ -166,7 +162,7 @@ uint64_t SBSection::GetFileOffset() {
}
uint64_t SBSection::GetFileByteSize() {
- LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBSection, GetFileByteSize);
+ LLDB_INSTRUMENT_VA(this);
SectionSP section_sp(GetSP());
if (section_sp)
@@ -175,14 +171,13 @@ uint64_t SBSection::GetFileByteSize() {
}
SBData SBSection::GetSectionData() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBData, SBSection, GetSectionData);
+ LLDB_INSTRUMENT_VA(this);
return GetSectionData(0, UINT64_MAX);
}
SBData SBSection::GetSectionData(uint64_t offset, uint64_t size) {
- LLDB_RECORD_METHOD(lldb::SBData, SBSection, GetSectionData,
- (uint64_t, uint64_t), offset, size);
+ LLDB_INSTRUMENT_VA(this, offset, size);
SBData sb_data;
SectionSP section_sp(GetSP());
@@ -221,7 +216,7 @@ SBData SBSection::GetSectionData(uint64_t offset, uint64_t size) {
}
SectionType SBSection::GetSectionType() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SectionType, SBSection, GetSectionType);
+ LLDB_INSTRUMENT_VA(this);
SectionSP section_sp(GetSP());
if (section_sp.get())
@@ -230,7 +225,7 @@ SectionType SBSection::GetSectionType() {
}
uint32_t SBSection::GetPermissions() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBSection, GetPermissions);
+ LLDB_INSTRUMENT_VA(this);
SectionSP section_sp(GetSP());
if (section_sp)
@@ -239,7 +234,7 @@ uint32_t SBSection::GetPermissions() const {
}
uint32_t SBSection::GetTargetByteSize() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBSection, GetTargetByteSize);
+ LLDB_INSTRUMENT_VA(this);
SectionSP section_sp(GetSP());
if (section_sp.get())
@@ -248,8 +243,7 @@ uint32_t SBSection::GetTargetByteSize() {
}
bool SBSection::operator==(const SBSection &rhs) {
- LLDB_RECORD_METHOD(bool, SBSection, operator==,(const lldb::SBSection &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
SectionSP lhs_section_sp(GetSP());
SectionSP rhs_section_sp(rhs.GetSP());
@@ -259,8 +253,7 @@ bool SBSection::operator==(const SBSection &rhs) {
}
bool SBSection::operator!=(const SBSection &rhs) {
- LLDB_RECORD_METHOD(bool, SBSection, operator!=,(const lldb::SBSection &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
SectionSP lhs_section_sp(GetSP());
SectionSP rhs_section_sp(rhs.GetSP());
@@ -268,8 +261,7 @@ bool SBSection::operator!=(const SBSection &rhs) {
}
bool SBSection::GetDescription(SBStream &description) {
- LLDB_RECORD_METHOD(bool, SBSection, GetDescription, (lldb::SBStream &),
- description);
+ LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();
diff --git a/lldb/source/API/SBSourceManager.cpp b/lldb/source/API/SBSourceManager.cpp
index e1cfb4dfde15..7729f5d9d69f 100644
--- a/lldb/source/API/SBSourceManager.cpp
+++ b/lldb/source/API/SBSourceManager.cpp
@@ -7,10 +7,10 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBSourceManager.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBTarget.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/API/SBFileSpec.h"
#include "lldb/Core/Debugger.h"
@@ -71,21 +71,19 @@ using namespace lldb;
using namespace lldb_private;
SBSourceManager::SBSourceManager(const SBDebugger &debugger) {
- LLDB_RECORD_CONSTRUCTOR(SBSourceManager, (const lldb::SBDebugger &),
- debugger);
+ LLDB_INSTRUMENT_VA(this, debugger);
m_opaque_up = std::make_unique<SourceManagerImpl>(debugger.get_sp());
}
SBSourceManager::SBSourceManager(const SBTarget &target) {
- LLDB_RECORD_CONSTRUCTOR(SBSourceManager, (const lldb::SBTarget &), target);
+ LLDB_INSTRUMENT_VA(this, target);
m_opaque_up = std::make_unique<SourceManagerImpl>(target.GetSP());
}
SBSourceManager::SBSourceManager(const SBSourceManager &rhs) {
- LLDB_RECORD_CONSTRUCTOR(SBSourceManager, (const lldb::SBSourceManager &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (&rhs == this)
return;
@@ -95,9 +93,7 @@ SBSourceManager::SBSourceManager(const SBSourceManager &rhs) {
const lldb::SBSourceManager &SBSourceManager::
operator=(const lldb::SBSourceManager &rhs) {
- LLDB_RECORD_METHOD(const lldb::SBSourceManager &,
- SBSourceManager, operator=,(const lldb::SBSourceManager &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_up = std::make_unique<SourceManagerImpl>(*(rhs.m_opaque_up.get()));
return *this;
@@ -108,10 +104,7 @@ SBSourceManager::~SBSourceManager() = default;
size_t SBSourceManager::DisplaySourceLinesWithLineNumbers(
const SBFileSpec &file, uint32_t line, uint32_t context_before,
uint32_t context_after, const char *current_line_cstr, SBStream &s) {
- LLDB_RECORD_METHOD(size_t, SBSourceManager, DisplaySourceLinesWithLineNumbers,
- (const lldb::SBFileSpec &, uint32_t, uint32_t, uint32_t,
- const char *, lldb::SBStream &),
- file, line, context_before, context_after,
+ LLDB_INSTRUMENT_VA(this, file, line, context_before, context_after,
current_line_cstr, s);
const uint32_t column = 0;
@@ -124,11 +117,8 @@ size_t SBSourceManager::DisplaySourceLinesWithLineNumbersAndColumn(
const SBFileSpec &file, uint32_t line, uint32_t column,
uint32_t context_before, uint32_t context_after,
const char *current_line_cstr, SBStream &s) {
- LLDB_RECORD_METHOD(
- size_t, SBSourceManager, DisplaySourceLinesWithLineNumbersAndColumn,
- (const lldb::SBFileSpec &, uint32_t, uint32_t, uint32_t, uint32_t,
- const char *, lldb::SBStream &),
- file, line, column, context_before, context_after, current_line_cstr, s);
+ LLDB_INSTRUMENT_VA(this, file, line, column, context_before, context_after,
+ current_line_cstr, s);
if (m_opaque_up == nullptr)
return 0;
diff --git a/lldb/source/API/SBStream.cpp b/lldb/source/API/SBStream.cpp
index c3e344802148..9ceef3466f93 100644
--- a/lldb/source/API/SBStream.cpp
+++ b/lldb/source/API/SBStream.cpp
@@ -8,10 +8,10 @@
#include "lldb/API/SBStream.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBFile.h"
#include "lldb/Core/StreamFile.h"
#include "lldb/Host/FileSystem.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/Status.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"
@@ -20,7 +20,7 @@ using namespace lldb;
using namespace lldb_private;
SBStream::SBStream() : m_opaque_up(new StreamString()) {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBStream);
+ LLDB_INSTRUMENT_VA(this);
}
SBStream::SBStream(SBStream &&rhs)
@@ -29,11 +29,11 @@ SBStream::SBStream(SBStream &&rhs)
SBStream::~SBStream() = default;
bool SBStream::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStream, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBStream::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStream, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return (m_opaque_up != nullptr);
}
@@ -41,7 +41,7 @@ SBStream::operator bool() const {
// If this stream is not redirected to a file, it will maintain a local cache
// for the stream data which can be accessed using this accessor.
const char *SBStream::GetData() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBStream, GetData);
+ LLDB_INSTRUMENT_VA(this);
if (m_is_file || m_opaque_up == nullptr)
return nullptr;
@@ -52,7 +52,7 @@ const char *SBStream::GetData() {
// If this stream is not redirected to a file, it will maintain a local cache
// for the stream output whose length can be accessed using this accessor.
size_t SBStream::GetSize() {
- LLDB_RECORD_METHOD_NO_ARGS(size_t, SBStream, GetSize);
+ LLDB_INSTRUMENT_VA(this);
if (m_is_file || m_opaque_up == nullptr)
return 0;
@@ -61,7 +61,7 @@ size_t SBStream::GetSize() {
}
void SBStream::Print(const char *str) {
- LLDB_RECORD_METHOD(void, SBStream, Print, (const char *), str);
+ LLDB_INSTRUMENT_VA(this, str);
Printf("%s", str);
}
@@ -76,8 +76,7 @@ void SBStream::Printf(const char *format, ...) {
}
void SBStream::RedirectToFile(const char *path, bool append) {
- LLDB_RECORD_METHOD(void, SBStream, RedirectToFile, (const char *, bool), path,
- append);
+ LLDB_INSTRUMENT_VA(this, path, append);
if (path == nullptr)
return;
@@ -114,19 +113,18 @@ void SBStream::RedirectToFile(const char *path, bool append) {
}
void SBStream::RedirectToFileHandle(FILE *fh, bool transfer_fh_ownership) {
- LLDB_RECORD_METHOD(void, SBStream, RedirectToFileHandle, (FILE *, bool), fh,
- transfer_fh_ownership);
+ LLDB_INSTRUMENT_VA(this, fh, transfer_fh_ownership);
FileSP file = std::make_unique<NativeFile>(fh, transfer_fh_ownership);
return RedirectToFile(file);
}
void SBStream::RedirectToFile(SBFile file) {
- LLDB_RECORD_METHOD(void, SBStream, RedirectToFile, (SBFile), file)
+ LLDB_INSTRUMENT_VA(this, file)
RedirectToFile(file.GetFile());
}
void SBStream::RedirectToFile(FileSP file_sp) {
- LLDB_RECORD_METHOD(void, SBStream, RedirectToFile, (FileSP), file_sp);
+ LLDB_INSTRUMENT_VA(this, file_sp);
if (!file_sp || !file_sp->IsValid())
return;
@@ -150,8 +148,7 @@ void SBStream::RedirectToFile(FileSP file_sp) {
}
void SBStream::RedirectToFileDescriptor(int fd, bool transfer_fh_ownership) {
- LLDB_RECORD_METHOD(void, SBStream, RedirectToFileDescriptor, (int, bool), fd,
- transfer_fh_ownership);
+ LLDB_INSTRUMENT_VA(this, fd, transfer_fh_ownership);
std::string local_data;
if (m_opaque_up) {
@@ -182,7 +179,7 @@ lldb_private::Stream &SBStream::ref() {
}
void SBStream::Clear() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBStream, Clear);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_up) {
// See if we have any locally backed data. If so, copy it so we can then
diff --git a/lldb/source/API/SBStringList.cpp b/lldb/source/API/SBStringList.cpp
index afafd7429fd7..dfb77b1ab32f 100644
--- a/lldb/source/API/SBStringList.cpp
+++ b/lldb/source/API/SBStringList.cpp
@@ -7,14 +7,14 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBStringList.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/StringList.h"
using namespace lldb;
using namespace lldb_private;
-SBStringList::SBStringList() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBStringList); }
+SBStringList::SBStringList() { LLDB_INSTRUMENT_VA(this); }
SBStringList::SBStringList(const lldb_private::StringList *lldb_strings_ptr) {
if (lldb_strings_ptr)
@@ -22,14 +22,13 @@ SBStringList::SBStringList(const lldb_private::StringList *lldb_strings_ptr) {
}
SBStringList::SBStringList(const SBStringList &rhs) {
- LLDB_RECORD_CONSTRUCTOR(SBStringList, (const lldb::SBStringList &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_up = clone(rhs.m_opaque_up);
}
const SBStringList &SBStringList::operator=(const SBStringList &rhs) {
- LLDB_RECORD_METHOD(const lldb::SBStringList &,
- SBStringList, operator=,(const lldb::SBStringList &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
@@ -47,17 +46,17 @@ const lldb_private::StringList &SBStringList::operator*() const {
}
bool SBStringList::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStringList, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBStringList::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStringList, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return (m_opaque_up != nullptr);
}
void SBStringList::AppendString(const char *str) {
- LLDB_RECORD_METHOD(void, SBStringList, AppendString, (const char *), str);
+ LLDB_INSTRUMENT_VA(this, str);
if (str != nullptr) {
if (IsValid())
@@ -68,8 +67,7 @@ void SBStringList::AppendString(const char *str) {
}
void SBStringList::AppendList(const char **strv, int strc) {
- LLDB_RECORD_METHOD(void, SBStringList, AppendList, (const char **, int), strv,
- strc);
+ LLDB_INSTRUMENT_VA(this, strv, strc);
if ((strv != nullptr) && (strc > 0)) {
if (IsValid())
@@ -80,8 +78,7 @@ void SBStringList::AppendList(const char **strv, int strc) {
}
void SBStringList::AppendList(const SBStringList &strings) {
- LLDB_RECORD_METHOD(void, SBStringList, AppendList,
- (const lldb::SBStringList &), strings);
+ LLDB_INSTRUMENT_VA(this, strings);
if (strings.IsValid()) {
if (!IsValid())
@@ -97,7 +94,7 @@ void SBStringList::AppendList(const StringList &strings) {
}
uint32_t SBStringList::GetSize() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBStringList, GetSize);
+ LLDB_INSTRUMENT_VA(this);
if (IsValid()) {
return m_opaque_up->GetSize();
@@ -106,8 +103,7 @@ uint32_t SBStringList::GetSize() const {
}
const char *SBStringList::GetStringAtIndex(size_t idx) {
- LLDB_RECORD_METHOD(const char *, SBStringList, GetStringAtIndex, (size_t),
- idx);
+ LLDB_INSTRUMENT_VA(this, idx);
if (IsValid()) {
return m_opaque_up->GetStringAtIndex(idx);
@@ -116,8 +112,7 @@ const char *SBStringList::GetStringAtIndex(size_t idx) {
}
const char *SBStringList::GetStringAtIndex(size_t idx) const {
- LLDB_RECORD_METHOD_CONST(const char *, SBStringList, GetStringAtIndex,
- (size_t), idx);
+ LLDB_INSTRUMENT_VA(this, idx);
if (IsValid()) {
return m_opaque_up->GetStringAtIndex(idx);
@@ -126,7 +121,7 @@ const char *SBStringList::GetStringAtIndex(size_t idx) const {
}
void SBStringList::Clear() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBStringList, Clear);
+ LLDB_INSTRUMENT_VA(this);
if (IsValid()) {
m_opaque_up->Clear();
diff --git a/lldb/source/API/SBStructuredData.cpp b/lldb/source/API/SBStructuredData.cpp
index c607e305e0a6..498bcdd39e44 100644
--- a/lldb/source/API/SBStructuredData.cpp
+++ b/lldb/source/API/SBStructuredData.cpp
@@ -7,7 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBStructuredData.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBStringList.h"
@@ -25,41 +25,36 @@ using namespace lldb_private;
#pragma mark SBStructuredData
SBStructuredData::SBStructuredData() : m_impl_up(new StructuredDataImpl()) {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBStructuredData);
+ LLDB_INSTRUMENT_VA(this);
}
SBStructuredData::SBStructuredData(const lldb::SBStructuredData &rhs)
: m_impl_up(new StructuredDataImpl(*rhs.m_impl_up)) {
- LLDB_RECORD_CONSTRUCTOR(SBStructuredData, (const lldb::SBStructuredData &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
}
SBStructuredData::SBStructuredData(const lldb::EventSP &event_sp)
: m_impl_up(new StructuredDataImpl(event_sp)) {
- LLDB_RECORD_CONSTRUCTOR(SBStructuredData, (const lldb::EventSP &), event_sp);
+ LLDB_INSTRUMENT_VA(this, event_sp);
}
SBStructuredData::SBStructuredData(const lldb_private::StructuredDataImpl &impl)
: m_impl_up(new StructuredDataImpl(impl)) {
- LLDB_RECORD_CONSTRUCTOR(SBStructuredData,
- (const lldb_private::StructuredDataImpl &), impl);
+ LLDB_INSTRUMENT_VA(this, impl);
}
SBStructuredData::~SBStructuredData() = default;
SBStructuredData &SBStructuredData::
operator=(const lldb::SBStructuredData &rhs) {
- LLDB_RECORD_METHOD(
- lldb::SBStructuredData &,
- SBStructuredData, operator=,(const lldb::SBStructuredData &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
*m_impl_up = *rhs.m_impl_up;
return *this;
}
lldb::SBError SBStructuredData::SetFromJSON(lldb::SBStream &stream) {
- LLDB_RECORD_METHOD(lldb::SBError, SBStructuredData, SetFromJSON,
- (lldb::SBStream &), stream);
+ LLDB_INSTRUMENT_VA(this, stream);
lldb::SBError error;
std::string json_str(stream.GetData());
@@ -73,33 +68,31 @@ lldb::SBError SBStructuredData::SetFromJSON(lldb::SBStream &stream) {
}
lldb::SBError SBStructuredData::SetFromJSON(const char *json) {
- LLDB_RECORD_METHOD(lldb::SBError, SBStructuredData, SetFromJSON,
- (const char *), json);
+ LLDB_INSTRUMENT_VA(this, json);
lldb::SBStream s;
s.Print(json);
return SetFromJSON(s);
}
bool SBStructuredData::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStructuredData, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBStructuredData::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStructuredData, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_impl_up->IsValid();
}
void SBStructuredData::Clear() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBStructuredData, Clear);
+ LLDB_INSTRUMENT_VA(this);
m_impl_up->Clear();
}
SBError SBStructuredData::GetAsJSON(lldb::SBStream &stream) const {
- LLDB_RECORD_METHOD_CONST(lldb::SBError, SBStructuredData, GetAsJSON,
- (lldb::SBStream &), stream);
+ LLDB_INSTRUMENT_VA(this, stream);
SBError error;
error.SetError(m_impl_up->GetAsJSON(stream.ref()));
@@ -107,8 +100,7 @@ SBError SBStructuredData::GetAsJSON(lldb::SBStream &stream) const {
}
lldb::SBError SBStructuredData::GetDescription(lldb::SBStream &stream) const {
- LLDB_RECORD_METHOD_CONST(lldb::SBError, SBStructuredData, GetDescription,
- (lldb::SBStream &), stream);
+ LLDB_INSTRUMENT_VA(this, stream);
Status error = m_impl_up->GetDescription(stream.ref());
SBError sb_error;
@@ -117,21 +109,19 @@ lldb::SBError SBStructuredData::GetDescription(lldb::SBStream &stream) const {
}
StructuredDataType SBStructuredData::GetType() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::StructuredDataType, SBStructuredData,
- GetType);
+ LLDB_INSTRUMENT_VA(this);
return m_impl_up->GetType();
}
size_t SBStructuredData::GetSize() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBStructuredData, GetSize);
+ LLDB_INSTRUMENT_VA(this);
return m_impl_up->GetSize();
}
bool SBStructuredData::GetKeys(lldb::SBStringList &keys) const {
- LLDB_RECORD_METHOD_CONST(bool, SBStructuredData, GetKeys,
- (lldb::SBStringList &), keys);
+ LLDB_INSTRUMENT_VA(this, keys);
if (GetType() != eStructuredDataTypeDictionary)
return false;
@@ -157,8 +147,7 @@ bool SBStructuredData::GetKeys(lldb::SBStringList &keys) const {
}
lldb::SBStructuredData SBStructuredData::GetValueForKey(const char *key) const {
- LLDB_RECORD_METHOD_CONST(lldb::SBStructuredData, SBStructuredData,
- GetValueForKey, (const char *), key);
+ LLDB_INSTRUMENT_VA(this, key);
SBStructuredData result;
result.m_impl_up->SetObjectSP(m_impl_up->GetValueForKey(key));
@@ -166,8 +155,7 @@ lldb::SBStructuredData SBStructuredData::GetValueForKey(const char *key) const {
}
lldb::SBStructuredData SBStructuredData::GetItemAtIndex(size_t idx) const {
- LLDB_RECORD_METHOD_CONST(lldb::SBStructuredData, SBStructuredData,
- GetItemAtIndex, (size_t), idx);
+ LLDB_INSTRUMENT_VA(this, idx);
SBStructuredData result;
result.m_impl_up->SetObjectSP(m_impl_up->GetItemAtIndex(idx));
@@ -175,29 +163,25 @@ lldb::SBStructuredData SBStructuredData::GetItemAtIndex(size_t idx) const {
}
uint64_t SBStructuredData::GetIntegerValue(uint64_t fail_value) const {
- LLDB_RECORD_METHOD_CONST(uint64_t, SBStructuredData, GetIntegerValue,
- (uint64_t), fail_value);
+ LLDB_INSTRUMENT_VA(this, fail_value);
return m_impl_up->GetIntegerValue(fail_value);
}
double SBStructuredData::GetFloatValue(double fail_value) const {
- LLDB_RECORD_METHOD_CONST(double, SBStructuredData, GetFloatValue, (double),
- fail_value);
+ LLDB_INSTRUMENT_VA(this, fail_value);
return m_impl_up->GetFloatValue(fail_value);
}
bool SBStructuredData::GetBooleanValue(bool fail_value) const {
- LLDB_RECORD_METHOD_CONST(bool, SBStructuredData, GetBooleanValue, (bool),
- fail_value);
+ LLDB_INSTRUMENT_VA(this, fail_value);
return m_impl_up->GetBooleanValue(fail_value);
}
size_t SBStructuredData::GetStringValue(char *dst, size_t dst_len) const {
- LLDB_RECORD_METHOD_CONST(size_t, SBStructuredData, GetStringValue,
- (char *, size_t), dst, "", dst_len);
+ LLDB_INSTRUMENT_VA(this, dst, dst_len);
return m_impl_up->GetStringValue(dst, dst_len);
}
diff --git a/lldb/source/API/SBSymbol.cpp b/lldb/source/API/SBSymbol.cpp
index 96fe5708d344..b671f987dc99 100644
--- a/lldb/source/API/SBSymbol.cpp
+++ b/lldb/source/API/SBSymbol.cpp
@@ -7,29 +7,28 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBSymbol.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBStream.h"
#include "lldb/Core/Disassembler.h"
#include "lldb/Core/Module.h"
#include "lldb/Symbol/Symbol.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Target.h"
+#include "lldb/Utility/Instrumentation.h"
using namespace lldb;
using namespace lldb_private;
-SBSymbol::SBSymbol() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSymbol); }
+SBSymbol::SBSymbol() { LLDB_INSTRUMENT_VA(this); }
SBSymbol::SBSymbol(lldb_private::Symbol *lldb_object_ptr)
: m_opaque_ptr(lldb_object_ptr) {}
SBSymbol::SBSymbol(const lldb::SBSymbol &rhs) : m_opaque_ptr(rhs.m_opaque_ptr) {
- LLDB_RECORD_CONSTRUCTOR(SBSymbol, (const lldb::SBSymbol &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
}
const SBSymbol &SBSymbol::operator=(const SBSymbol &rhs) {
- LLDB_RECORD_METHOD(const lldb::SBSymbol &,
- SBSymbol, operator=,(const lldb::SBSymbol &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_ptr = rhs.m_opaque_ptr;
return *this;
@@ -42,17 +41,17 @@ void SBSymbol::SetSymbol(lldb_private::Symbol *lldb_object_ptr) {
}
bool SBSymbol::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbol, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBSymbol::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbol, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_ptr != nullptr;
}
const char *SBSymbol::GetName() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetName);
+ LLDB_INSTRUMENT_VA(this);
const char *name = nullptr;
if (m_opaque_ptr)
@@ -62,7 +61,7 @@ const char *SBSymbol::GetName() const {
}
const char *SBSymbol::GetDisplayName() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetDisplayName);
+ LLDB_INSTRUMENT_VA(this);
const char *name = nullptr;
if (m_opaque_ptr)
@@ -72,7 +71,7 @@ const char *SBSymbol::GetDisplayName() const {
}
const char *SBSymbol::GetMangledName() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetMangledName);
+ LLDB_INSTRUMENT_VA(this);
const char *name = nullptr;
if (m_opaque_ptr)
@@ -81,22 +80,19 @@ const char *SBSymbol::GetMangledName() const {
}
bool SBSymbol::operator==(const SBSymbol &rhs) const {
- LLDB_RECORD_METHOD_CONST(bool, SBSymbol, operator==,(const lldb::SBSymbol &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
return m_opaque_ptr == rhs.m_opaque_ptr;
}
bool SBSymbol::operator!=(const SBSymbol &rhs) const {
- LLDB_RECORD_METHOD_CONST(bool, SBSymbol, operator!=,(const lldb::SBSymbol &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
return m_opaque_ptr != rhs.m_opaque_ptr;
}
bool SBSymbol::GetDescription(SBStream &description) {
- LLDB_RECORD_METHOD(bool, SBSymbol, GetDescription, (lldb::SBStream &),
- description);
+ LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();
@@ -109,16 +105,14 @@ bool SBSymbol::GetDescription(SBStream &description) {
}
SBInstructionList SBSymbol::GetInstructions(SBTarget target) {
- LLDB_RECORD_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions,
- (lldb::SBTarget), target);
+ LLDB_INSTRUMENT_VA(this, target);
return GetInstructions(target, nullptr);
}
SBInstructionList SBSymbol::GetInstructions(SBTarget target,
const char *flavor_string) {
- LLDB_RECORD_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions,
- (lldb::SBTarget, const char *), target, flavor_string);
+ LLDB_INSTRUMENT_VA(this, target, flavor_string);
SBInstructionList sb_instructions;
if (m_opaque_ptr) {
@@ -145,7 +139,7 @@ lldb_private::Symbol *SBSymbol::get() { return m_opaque_ptr; }
void SBSymbol::reset(lldb_private::Symbol *symbol) { m_opaque_ptr = symbol; }
SBAddress SBSymbol::GetStartAddress() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBSymbol, GetStartAddress);
+ LLDB_INSTRUMENT_VA(this);
SBAddress addr;
if (m_opaque_ptr && m_opaque_ptr->ValueIsAddress()) {
@@ -155,7 +149,7 @@ SBAddress SBSymbol::GetStartAddress() {
}
SBAddress SBSymbol::GetEndAddress() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBSymbol, GetEndAddress);
+ LLDB_INSTRUMENT_VA(this);
SBAddress addr;
if (m_opaque_ptr && m_opaque_ptr->ValueIsAddress()) {
@@ -169,7 +163,7 @@ SBAddress SBSymbol::GetEndAddress() {
}
uint32_t SBSymbol::GetPrologueByteSize() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBSymbol, GetPrologueByteSize);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr)
return m_opaque_ptr->GetPrologueByteSize();
@@ -177,7 +171,7 @@ uint32_t SBSymbol::GetPrologueByteSize() {
}
SymbolType SBSymbol::GetType() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SymbolType, SBSymbol, GetType);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr)
return m_opaque_ptr->GetType();
@@ -185,7 +179,7 @@ SymbolType SBSymbol::GetType() {
}
bool SBSymbol::IsExternal() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBSymbol, IsExternal);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr)
return m_opaque_ptr->IsExternal();
@@ -193,7 +187,7 @@ bool SBSymbol::IsExternal() {
}
bool SBSymbol::IsSynthetic() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBSymbol, IsSynthetic);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr)
return m_opaque_ptr->IsSynthetic();
diff --git a/lldb/source/API/SBSymbolContext.cpp b/lldb/source/API/SBSymbolContext.cpp
index ebe9bcfabb9f..484399c89590 100644
--- a/lldb/source/API/SBSymbolContext.cpp
+++ b/lldb/source/API/SBSymbolContext.cpp
@@ -7,30 +7,26 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBSymbolContext.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/API/SBStream.h"
#include "lldb/Core/Module.h"
#include "lldb/Symbol/Function.h"
#include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/SymbolContext.h"
+#include "lldb/Utility/Instrumentation.h"
using namespace lldb;
using namespace lldb_private;
-SBSymbolContext::SBSymbolContext() {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSymbolContext);
-}
+SBSymbolContext::SBSymbolContext() { LLDB_INSTRUMENT_VA(this); }
SBSymbolContext::SBSymbolContext(const SymbolContext &sc)
: m_opaque_up(std::make_unique<SymbolContext>(sc)) {
- LLDB_RECORD_CONSTRUCTOR(SBSymbolContext,
- (const lldb_private::SymbolContext &), sc);
+ LLDB_INSTRUMENT_VA(this, sc);
}
SBSymbolContext::SBSymbolContext(const SBSymbolContext &rhs) {
- LLDB_RECORD_CONSTRUCTOR(SBSymbolContext, (const lldb::SBSymbolContext &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_up = clone(rhs.m_opaque_up);
}
@@ -38,9 +34,7 @@ SBSymbolContext::SBSymbolContext(const SBSymbolContext &rhs) {
SBSymbolContext::~SBSymbolContext() = default;
const SBSymbolContext &SBSymbolContext::operator=(const SBSymbolContext &rhs) {
- LLDB_RECORD_METHOD(const lldb::SBSymbolContext &,
- SBSymbolContext, operator=,(const lldb::SBSymbolContext &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
@@ -48,17 +42,17 @@ const SBSymbolContext &SBSymbolContext::operator=(const SBSymbolContext &rhs) {
}
bool SBSymbolContext::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContext, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBSymbolContext::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContext, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up != nullptr;
}
SBModule SBSymbolContext::GetModule() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBModule, SBSymbolContext, GetModule);
+ LLDB_INSTRUMENT_VA(this);
SBModule sb_module;
ModuleSP module_sp;
@@ -71,14 +65,13 @@ SBModule SBSymbolContext::GetModule() {
}
SBCompileUnit SBSymbolContext::GetCompileUnit() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCompileUnit, SBSymbolContext,
- GetCompileUnit);
+ LLDB_INSTRUMENT_VA(this);
return SBCompileUnit(m_opaque_up ? m_opaque_up->comp_unit : nullptr);
}
SBFunction SBSymbolContext::GetFunction() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFunction, SBSymbolContext, GetFunction);
+ LLDB_INSTRUMENT_VA(this);
Function *function = nullptr;
@@ -91,13 +84,13 @@ SBFunction SBSymbolContext::GetFunction() {
}
SBBlock SBSymbolContext::GetBlock() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBSymbolContext, GetBlock);
+ LLDB_INSTRUMENT_VA(this);
return SBBlock(m_opaque_up ? m_opaque_up->block : nullptr);
}
SBLineEntry SBSymbolContext::GetLineEntry() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBLineEntry, SBSymbolContext, GetLineEntry);
+ LLDB_INSTRUMENT_VA(this);
SBLineEntry sb_line_entry;
if (m_opaque_up)
@@ -107,7 +100,7 @@ SBLineEntry SBSymbolContext::GetLineEntry() {
}
SBSymbol SBSymbolContext::GetSymbol() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSymbol, SBSymbolContext, GetSymbol);
+ LLDB_INSTRUMENT_VA(this);
Symbol *symbol = nullptr;
@@ -120,35 +113,31 @@ SBSymbol SBSymbolContext::GetSymbol() {
}
void SBSymbolContext::SetModule(lldb::SBModule module) {
- LLDB_RECORD_METHOD(void, SBSymbolContext, SetModule, (lldb::SBModule),
- module);
+ LLDB_INSTRUMENT_VA(this, module);
ref().module_sp = module.GetSP();
}
void SBSymbolContext::SetCompileUnit(lldb::SBCompileUnit compile_unit) {
- LLDB_RECORD_METHOD(void, SBSymbolContext, SetCompileUnit,
- (lldb::SBCompileUnit), compile_unit);
+ LLDB_INSTRUMENT_VA(this, compile_unit);
ref().comp_unit = compile_unit.get();
}
void SBSymbolContext::SetFunction(lldb::SBFunction function) {
- LLDB_RECORD_METHOD(void, SBSymbolContext, SetFunction, (lldb::SBFunction),
- function);
+ LLDB_INSTRUMENT_VA(this, function);
ref().function = function.get();
}
void SBSymbolContext::SetBlock(lldb::SBBlock block) {
- LLDB_RECORD_METHOD(void, SBSymbolContext, SetBlock, (lldb::SBBlock), block);
+ LLDB_INSTRUMENT_VA(this, block);
ref().block = block.GetPtr();
}
void SBSymbolContext::SetLineEntry(lldb::SBLineEntry line_entry) {
- LLDB_RECORD_METHOD(void, SBSymbolContext, SetLineEntry, (lldb::SBLineEntry),
- line_entry);
+ LLDB_INSTRUMENT_VA(this, line_entry);
if (line_entry.IsValid())
ref().line_entry = line_entry.ref();
@@ -157,8 +146,7 @@ void SBSymbolContext::SetLineEntry(lldb::SBLineEntry line_entry) {
}
void SBSymbolContext::SetSymbol(lldb::SBSymbol symbol) {
- LLDB_RECORD_METHOD(void, SBSymbolContext, SetSymbol, (lldb::SBSymbol),
- symbol);
+ LLDB_INSTRUMENT_VA(this, symbol);
ref().symbol = symbol.get();
}
@@ -189,8 +177,7 @@ lldb_private::SymbolContext *SBSymbolContext::get() const {
}
bool SBSymbolContext::GetDescription(SBStream &description) {
- LLDB_RECORD_METHOD(bool, SBSymbolContext, GetDescription, (lldb::SBStream &),
- description);
+ LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();
@@ -205,10 +192,7 @@ bool SBSymbolContext::GetDescription(SBStream &description) {
SBSymbolContext
SBSymbolContext::GetParentOfInlinedScope(const SBAddress &curr_frame_pc,
SBAddress &parent_frame_addr) const {
- LLDB_RECORD_METHOD_CONST(lldb::SBSymbolContext, SBSymbolContext,
- GetParentOfInlinedScope,
- (const lldb::SBAddress &, lldb::SBAddress &),
- curr_frame_pc, parent_frame_addr);
+ LLDB_INSTRUMENT_VA(this, curr_frame_pc, parent_frame_addr);
SBSymbolContext sb_sc;
if (m_opaque_up.get() && curr_frame_pc.IsValid()) {
diff --git a/lldb/source/API/SBSymbolContextList.cpp b/lldb/source/API/SBSymbolContextList.cpp
index 2dddd2805cd7..baa558caebbc 100644
--- a/lldb/source/API/SBSymbolContextList.cpp
+++ b/lldb/source/API/SBSymbolContextList.cpp
@@ -7,22 +7,21 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBSymbolContextList.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/API/SBStream.h"
#include "lldb/Symbol/SymbolContext.h"
+#include "lldb/Utility/Instrumentation.h"
using namespace lldb;
using namespace lldb_private;
SBSymbolContextList::SBSymbolContextList()
: m_opaque_up(new SymbolContextList()) {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSymbolContextList);
+ LLDB_INSTRUMENT_VA(this);
}
SBSymbolContextList::SBSymbolContextList(const SBSymbolContextList &rhs) {
- LLDB_RECORD_CONSTRUCTOR(SBSymbolContextList,
- (const lldb::SBSymbolContextList &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_up = clone(rhs.m_opaque_up);
}
@@ -31,9 +30,7 @@ SBSymbolContextList::~SBSymbolContextList() = default;
const SBSymbolContextList &SBSymbolContextList::
operator=(const SBSymbolContextList &rhs) {
- LLDB_RECORD_METHOD(
- const lldb::SBSymbolContextList &,
- SBSymbolContextList, operator=,(const lldb::SBSymbolContextList &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
@@ -41,7 +38,7 @@ operator=(const SBSymbolContextList &rhs) {
}
uint32_t SBSymbolContextList::GetSize() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBSymbolContextList, GetSize);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_up)
return m_opaque_up->GetSize();
@@ -49,8 +46,7 @@ uint32_t SBSymbolContextList::GetSize() const {
}
SBSymbolContext SBSymbolContextList::GetContextAtIndex(uint32_t idx) {
- LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBSymbolContextList,
- GetContextAtIndex, (uint32_t), idx);
+ LLDB_INSTRUMENT_VA(this, idx);
SBSymbolContext sb_sc;
if (m_opaque_up) {
@@ -62,34 +58,32 @@ SBSymbolContext SBSymbolContextList::GetContextAtIndex(uint32_t idx) {
}
void SBSymbolContextList::Clear() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBSymbolContextList, Clear);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_up)
m_opaque_up->Clear();
}
void SBSymbolContextList::Append(SBSymbolContext &sc) {
- LLDB_RECORD_METHOD(void, SBSymbolContextList, Append,
- (lldb::SBSymbolContext &), sc);
+ LLDB_INSTRUMENT_VA(this, sc);
if (sc.IsValid() && m_opaque_up.get())
m_opaque_up->Append(*sc);
}
void SBSymbolContextList::Append(SBSymbolContextList &sc_list) {
- LLDB_RECORD_METHOD(void, SBSymbolContextList, Append,
- (lldb::SBSymbolContextList &), sc_list);
+ LLDB_INSTRUMENT_VA(this, sc_list);
if (sc_list.IsValid() && m_opaque_up.get())
m_opaque_up->Append(*sc_list);
}
bool SBSymbolContextList::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContextList, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBSymbolContextList::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContextList, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up != nullptr;
}
@@ -104,8 +98,7 @@ lldb_private::SymbolContextList &SBSymbolContextList::operator*() const {
}
bool SBSymbolContextList::GetDescription(lldb::SBStream &description) {
- LLDB_RECORD_METHOD(bool, SBSymbolContextList, GetDescription,
- (lldb::SBStream &), description);
+ LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();
if (m_opaque_up)
diff --git a/lldb/source/API/SBTarget.cpp b/lldb/source/API/SBTarget.cpp
index 5bec5610fcff..75534b2343d4 100644
--- a/lldb/source/API/SBTarget.cpp
+++ b/lldb/source/API/SBTarget.cpp
@@ -7,7 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBTarget.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/lldb-public.h"
@@ -93,19 +93,18 @@ static Status AttachToProcess(ProcessAttachInfo &attach_info, Target &target) {
}
// SBTarget constructor
-SBTarget::SBTarget() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTarget); }
+SBTarget::SBTarget() { LLDB_INSTRUMENT_VA(this); }
SBTarget::SBTarget(const SBTarget &rhs) : m_opaque_sp(rhs.m_opaque_sp) {
- LLDB_RECORD_CONSTRUCTOR(SBTarget, (const lldb::SBTarget &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
}
SBTarget::SBTarget(const TargetSP &target_sp) : m_opaque_sp(target_sp) {
- LLDB_RECORD_CONSTRUCTOR(SBTarget, (const lldb::TargetSP &), target_sp);
+ LLDB_INSTRUMENT_VA(this, target_sp);
}
const SBTarget &SBTarget::operator=(const SBTarget &rhs) {
- LLDB_RECORD_METHOD(const lldb::SBTarget &,
- SBTarget, operator=,(const lldb::SBTarget &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_sp = rhs.m_opaque_sp;
@@ -116,22 +115,19 @@ const SBTarget &SBTarget::operator=(const SBTarget &rhs) {
SBTarget::~SBTarget() = default;
bool SBTarget::EventIsTargetEvent(const SBEvent &event) {
- LLDB_RECORD_STATIC_METHOD(bool, SBTarget, EventIsTargetEvent,
- (const lldb::SBEvent &), event);
+ LLDB_INSTRUMENT_VA(event);
return Target::TargetEventData::GetEventDataFromEvent(event.get()) != nullptr;
}
SBTarget SBTarget::GetTargetFromEvent(const SBEvent &event) {
- LLDB_RECORD_STATIC_METHOD(lldb::SBTarget, SBTarget, GetTargetFromEvent,
- (const lldb::SBEvent &), event);
+ LLDB_INSTRUMENT_VA(event);
return Target::TargetEventData::GetTargetFromEvent(event.get());
}
uint32_t SBTarget::GetNumModulesFromEvent(const SBEvent &event) {
- LLDB_RECORD_STATIC_METHOD(uint32_t, SBTarget, GetNumModulesFromEvent,
- (const lldb::SBEvent &), event);
+ LLDB_INSTRUMENT_VA(event);
const ModuleList module_list =
Target::TargetEventData::GetModuleListFromEvent(event.get());
@@ -140,9 +136,7 @@ uint32_t SBTarget::GetNumModulesFromEvent(const SBEvent &event) {
SBModule SBTarget::GetModuleAtIndexFromEvent(const uint32_t idx,
const SBEvent &event) {
- LLDB_RECORD_STATIC_METHOD(lldb::SBModule, SBTarget, GetModuleAtIndexFromEvent,
- (const uint32_t, const lldb::SBEvent &), idx,
- event);
+ LLDB_INSTRUMENT_VA(idx, event);
const ModuleList module_list =
Target::TargetEventData::GetModuleListFromEvent(event.get());
@@ -150,24 +144,23 @@ SBModule SBTarget::GetModuleAtIndexFromEvent(const uint32_t idx,
}
const char *SBTarget::GetBroadcasterClassName() {
- LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBTarget,
- GetBroadcasterClassName);
+ LLDB_INSTRUMENT();
return Target::GetStaticBroadcasterClass().AsCString();
}
bool SBTarget::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTarget, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBTarget::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTarget, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp.get() != nullptr && m_opaque_sp->IsValid();
}
SBProcess SBTarget::GetProcess() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBTarget, GetProcess);
+ LLDB_INSTRUMENT_VA(this);
SBProcess sb_process;
ProcessSP process_sp;
@@ -181,7 +174,7 @@ SBProcess SBTarget::GetProcess() {
}
SBPlatform SBTarget::GetPlatform() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBPlatform, SBTarget, GetPlatform);
+ LLDB_INSTRUMENT_VA(this);
TargetSP target_sp(GetSP());
if (!target_sp)
@@ -194,7 +187,7 @@ SBPlatform SBTarget::GetPlatform() {
}
SBDebugger SBTarget::GetDebugger() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBDebugger, SBTarget, GetDebugger);
+ LLDB_INSTRUMENT_VA(this);
SBDebugger debugger;
TargetSP target_sp(GetSP());
@@ -204,7 +197,7 @@ SBDebugger SBTarget::GetDebugger() const {
}
SBStructuredData SBTarget::GetStatistics() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStructuredData, SBTarget, GetStatistics);
+ LLDB_INSTRUMENT_VA(this);
SBStructuredData data;
TargetSP target_sp(GetSP());
@@ -219,7 +212,7 @@ SBStructuredData SBTarget::GetStatistics() {
}
void SBTarget::SetCollectingStats(bool v) {
- LLDB_RECORD_METHOD(void, SBTarget, SetCollectingStats, (bool), v);
+ LLDB_INSTRUMENT_VA(this, v);
TargetSP target_sp(GetSP());
if (!target_sp)
@@ -228,7 +221,7 @@ void SBTarget::SetCollectingStats(bool v) {
}
bool SBTarget::GetCollectingStats() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, GetCollectingStats);
+ LLDB_INSTRUMENT_VA(this);
TargetSP target_sp(GetSP());
if (!target_sp)
@@ -237,16 +230,14 @@ bool SBTarget::GetCollectingStats() {
}
SBProcess SBTarget::LoadCore(const char *core_file) {
- LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, LoadCore, (const char *),
- core_file);
+ LLDB_INSTRUMENT_VA(this, core_file);
lldb::SBError error; // Ignored
return LoadCore(core_file, error);
}
SBProcess SBTarget::LoadCore(const char *core_file, lldb::SBError &error) {
- LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, LoadCore,
- (const char *, lldb::SBError &), core_file, error);
+ LLDB_INSTRUMENT_VA(this, core_file, error);
SBProcess sb_process;
TargetSP target_sp(GetSP());
@@ -270,9 +261,7 @@ SBProcess SBTarget::LoadCore(const char *core_file, lldb::SBError &error) {
SBProcess SBTarget::LaunchSimple(char const **argv, char const **envp,
const char *working_directory) {
- LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, LaunchSimple,
- (const char **, const char **, const char *), argv, envp,
- working_directory);
+ LLDB_INSTRUMENT_VA(this, argv, envp, working_directory);
TargetSP target_sp = GetSP();
if (!target_sp)
@@ -295,7 +284,7 @@ SBProcess SBTarget::LaunchSimple(char const **argv, char const **envp,
}
SBError SBTarget::Install() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBTarget, Install);
+ LLDB_INSTRUMENT_VA(this);
SBError sb_error;
TargetSP target_sp(GetSP());
@@ -312,12 +301,9 @@ SBProcess SBTarget::Launch(SBListener &listener, char const **argv,
const char *working_directory,
uint32_t launch_flags, // See LaunchFlags
bool stop_at_entry, lldb::SBError &error) {
- LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, Launch,
- (lldb::SBListener &, const char **, const char **,
- const char *, const char *, const char *, const char *,
- uint32_t, bool, lldb::SBError &),
- listener, argv, envp, stdin_path, stdout_path, stderr_path,
- working_directory, launch_flags, stop_at_entry, error);
+ LLDB_INSTRUMENT_VA(this, listener, argv, envp, stdin_path, stdout_path,
+ stderr_path, working_directory, launch_flags,
+ stop_at_entry, error);
SBProcess sb_process;
ProcessSP process_sp;
@@ -395,10 +381,7 @@ SBProcess SBTarget::Launch(SBListener &listener, char const **argv,
}
SBProcess SBTarget::Launch(SBLaunchInfo &sb_launch_info, SBError &error) {
- LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, Launch,
- (lldb::SBLaunchInfo &, lldb::SBError &), sb_launch_info,
- error);
-
+ LLDB_INSTRUMENT_VA(this, sb_launch_info, error);
SBProcess sb_process;
TargetSP target_sp(GetSP());
@@ -444,9 +427,7 @@ SBProcess SBTarget::Launch(SBLaunchInfo &sb_launch_info, SBError &error) {
}
lldb::SBProcess SBTarget::Attach(SBAttachInfo &sb_attach_info, SBError &error) {
- LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, Attach,
- (lldb::SBAttachInfo &, lldb::SBError &), sb_attach_info,
- error);
+ LLDB_INSTRUMENT_VA(this, sb_attach_info, error);
SBProcess sb_process;
TargetSP target_sp(GetSP());
@@ -483,9 +464,7 @@ lldb::SBProcess SBTarget::AttachToProcessWithID(
lldb::pid_t pid, // The process ID to attach to
SBError &error // An error explaining what went wrong if attach fails
) {
- LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, AttachToProcessWithID,
- (lldb::SBListener &, lldb::pid_t, lldb::SBError &),
- listener, pid, error);
+ LLDB_INSTRUMENT_VA(this, listener, pid, error);
SBProcess sb_process;
TargetSP target_sp(GetSP());
@@ -515,9 +494,7 @@ lldb::SBProcess SBTarget::AttachToProcessWithName(
bool wait_for, // if true wait for a new instance of "name" to be launched
SBError &error // An error explaining what went wrong if attach fails
) {
- LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, AttachToProcessWithName,
- (lldb::SBListener &, const char *, bool, lldb::SBError &),
- listener, name, wait_for, error);
+ LLDB_INSTRUMENT_VA(this, listener, name, wait_for, error);
SBProcess sb_process;
TargetSP target_sp(GetSP());
@@ -541,10 +518,7 @@ lldb::SBProcess SBTarget::AttachToProcessWithName(
lldb::SBProcess SBTarget::ConnectRemote(SBListener &listener, const char *url,
const char *plugin_name,
SBError &error) {
- LLDB_RECORD_METHOD(
- lldb::SBProcess, SBTarget, ConnectRemote,
- (lldb::SBListener &, const char *, const char *, lldb::SBError &),
- listener, url, plugin_name, error);
+ LLDB_INSTRUMENT_VA(this, listener, url, plugin_name, error);
SBProcess sb_process;
ProcessSP process_sp;
@@ -574,7 +548,7 @@ lldb::SBProcess SBTarget::ConnectRemote(SBListener &listener, const char *url,
}
SBFileSpec SBTarget::GetExecutable() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBTarget, GetExecutable);
+ LLDB_INSTRUMENT_VA(this);
SBFileSpec exe_file_spec;
TargetSP target_sp(GetSP());
@@ -588,15 +562,13 @@ SBFileSpec SBTarget::GetExecutable() {
}
bool SBTarget::operator==(const SBTarget &rhs) const {
- LLDB_RECORD_METHOD_CONST(bool, SBTarget, operator==,(const lldb::SBTarget &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
return m_opaque_sp.get() == rhs.m_opaque_sp.get();
}
bool SBTarget::operator!=(const SBTarget &rhs) const {
- LLDB_RECORD_METHOD_CONST(bool, SBTarget, operator!=,(const lldb::SBTarget &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
return m_opaque_sp.get() != rhs.m_opaque_sp.get();
}
@@ -608,8 +580,7 @@ void SBTarget::SetSP(const lldb::TargetSP &target_sp) {
}
lldb::SBAddress SBTarget::ResolveLoadAddress(lldb::addr_t vm_addr) {
- LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolveLoadAddress,
- (lldb::addr_t), vm_addr);
+ LLDB_INSTRUMENT_VA(this, vm_addr);
lldb::SBAddress sb_addr;
Address &addr = sb_addr.ref();
@@ -627,8 +598,7 @@ lldb::SBAddress SBTarget::ResolveLoadAddress(lldb::addr_t vm_addr) {
}
lldb::SBAddress SBTarget::ResolveFileAddress(lldb::addr_t file_addr) {
- LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolveFileAddress,
- (lldb::addr_t), file_addr);
+ LLDB_INSTRUMENT_VA(this, file_addr);
lldb::SBAddress sb_addr;
Address &addr = sb_addr.ref();
@@ -645,8 +615,7 @@ lldb::SBAddress SBTarget::ResolveFileAddress(lldb::addr_t file_addr) {
lldb::SBAddress SBTarget::ResolvePastLoadAddress(uint32_t stop_id,
lldb::addr_t vm_addr) {
- LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolvePastLoadAddress,
- (uint32_t, lldb::addr_t), stop_id, vm_addr);
+ LLDB_INSTRUMENT_VA(this, stop_id, vm_addr);
lldb::SBAddress sb_addr;
Address &addr = sb_addr.ref();
@@ -666,9 +635,7 @@ lldb::SBAddress SBTarget::ResolvePastLoadAddress(uint32_t stop_id,
SBSymbolContext
SBTarget::ResolveSymbolContextForAddress(const SBAddress &addr,
uint32_t resolve_scope) {
- LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBTarget,
- ResolveSymbolContextForAddress,
- (const lldb::SBAddress &, uint32_t), addr, resolve_scope);
+ LLDB_INSTRUMENT_VA(this, addr, resolve_scope);
SBSymbolContext sc;
SymbolContextItem scope = static_cast<SymbolContextItem>(resolve_scope);
@@ -683,9 +650,7 @@ SBTarget::ResolveSymbolContextForAddress(const SBAddress &addr,
size_t SBTarget::ReadMemory(const SBAddress addr, void *buf, size_t size,
lldb::SBError &error) {
- LLDB_RECORD_METHOD(size_t, SBTarget, ReadMemory,
- (const lldb::SBAddress, void *, size_t, lldb::SBError &),
- addr, buf, size, error);
+ LLDB_INSTRUMENT_VA(this, addr, buf, size, error);
SBError sb_error;
size_t bytes_read = 0;
@@ -703,8 +668,7 @@ size_t SBTarget::ReadMemory(const SBAddress addr, void *buf, size_t size,
SBBreakpoint SBTarget::BreakpointCreateByLocation(const char *file,
uint32_t line) {
- LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
- (const char *, uint32_t), file, line);
+ LLDB_INSTRUMENT_VA(this, file, line);
return SBBreakpoint(
BreakpointCreateByLocation(SBFileSpec(file, false), line));
@@ -713,8 +677,7 @@ SBBreakpoint SBTarget::BreakpointCreateByLocation(const char *file,
SBBreakpoint
SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec,
uint32_t line) {
- LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
- (const lldb::SBFileSpec &, uint32_t), sb_file_spec, line);
+ LLDB_INSTRUMENT_VA(this, sb_file_spec, line);
return BreakpointCreateByLocation(sb_file_spec, line, 0);
}
@@ -722,9 +685,7 @@ SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec,
SBBreakpoint
SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec,
uint32_t line, lldb::addr_t offset) {
- LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
- (const lldb::SBFileSpec &, uint32_t, lldb::addr_t),
- sb_file_spec, line, offset);
+ LLDB_INSTRUMENT_VA(this, sb_file_spec, line, offset);
SBFileSpecList empty_list;
return BreakpointCreateByLocation(sb_file_spec, line, offset, empty_list);
@@ -734,10 +695,7 @@ SBBreakpoint
SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec,
uint32_t line, lldb::addr_t offset,
SBFileSpecList &sb_module_list) {
- LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
- (const lldb::SBFileSpec &, uint32_t, lldb::addr_t,
- lldb::SBFileSpecList &),
- sb_file_spec, line, offset, sb_module_list);
+ LLDB_INSTRUMENT_VA(this, sb_file_spec, line, offset, sb_module_list);
return BreakpointCreateByLocation(sb_file_spec, line, 0, offset,
sb_module_list);
@@ -746,10 +704,7 @@ SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec,
SBBreakpoint SBTarget::BreakpointCreateByLocation(
const SBFileSpec &sb_file_spec, uint32_t line, uint32_t column,
lldb::addr_t offset, SBFileSpecList &sb_module_list) {
- LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
- (const lldb::SBFileSpec &, uint32_t, uint32_t,
- lldb::addr_t, lldb::SBFileSpecList &),
- sb_file_spec, line, column, offset, sb_module_list);
+ LLDB_INSTRUMENT_VA(this, sb_file_spec, line, column, offset, sb_module_list);
SBBreakpoint sb_bp;
TargetSP target_sp(GetSP());
@@ -777,10 +732,7 @@ SBBreakpoint SBTarget::BreakpointCreateByLocation(
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_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
- (const lldb::SBFileSpec &, uint32_t, uint32_t,
- lldb::addr_t, lldb::SBFileSpecList &, bool),
- sb_file_spec, line, column, offset, sb_module_list,
+ LLDB_INSTRUMENT_VA(this, sb_file_spec, line, column, offset, sb_module_list,
move_to_nearest_code);
SBBreakpoint sb_bp;
@@ -807,8 +759,7 @@ SBBreakpoint SBTarget::BreakpointCreateByLocation(
SBBreakpoint SBTarget::BreakpointCreateByName(const char *symbol_name,
const char *module_name) {
- LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
- (const char *, const char *), symbol_name, module_name);
+ LLDB_INSTRUMENT_VA(this, symbol_name, module_name);
SBBreakpoint sb_bp;
TargetSP target_sp(GetSP());
@@ -839,10 +790,7 @@ lldb::SBBreakpoint
SBTarget::BreakpointCreateByName(const char *symbol_name,
const SBFileSpecList &module_list,
const SBFileSpecList &comp_unit_list) {
- LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
- (const char *, const lldb::SBFileSpecList &,
- const lldb::SBFileSpecList &),
- symbol_name, module_list, comp_unit_list);
+ LLDB_INSTRUMENT_VA(this, symbol_name, module_list, comp_unit_list);
lldb::FunctionNameType name_type_mask = eFunctionNameTypeAuto;
return BreakpointCreateByName(symbol_name, name_type_mask,
@@ -853,10 +801,8 @@ SBTarget::BreakpointCreateByName(const char *symbol_name,
lldb::SBBreakpoint SBTarget::BreakpointCreateByName(
const char *symbol_name, uint32_t name_type_mask,
const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) {
- LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
- (const char *, uint32_t, const lldb::SBFileSpecList &,
- const lldb::SBFileSpecList &),
- symbol_name, name_type_mask, module_list, comp_unit_list);
+ LLDB_INSTRUMENT_VA(this, symbol_name, name_type_mask, module_list,
+ comp_unit_list);
return BreakpointCreateByName(symbol_name, name_type_mask,
eLanguageTypeUnknown, module_list,
@@ -867,12 +813,8 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateByName(
const char *symbol_name, uint32_t name_type_mask,
LanguageType symbol_language, const SBFileSpecList &module_list,
const SBFileSpecList &comp_unit_list) {
- LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
- (const char *, uint32_t, lldb::LanguageType,
- const lldb::SBFileSpecList &,
- const lldb::SBFileSpecList &),
- symbol_name, name_type_mask, symbol_language, module_list,
- comp_unit_list);
+ LLDB_INSTRUMENT_VA(this, symbol_name, name_type_mask, symbol_language,
+ module_list, comp_unit_list);
SBBreakpoint sb_bp;
TargetSP target_sp(GetSP());
@@ -893,11 +835,8 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateByName(
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_RECORD_METHOD(
- lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
- (const char **, uint32_t, uint32_t, const lldb::SBFileSpecList &,
- const lldb::SBFileSpecList &),
- symbol_names, num_names, name_type_mask, module_list, comp_unit_list);
+ LLDB_INSTRUMENT_VA(this, symbol_names, num_names, name_type_mask, module_list,
+ comp_unit_list);
return BreakpointCreateByNames(symbol_names, num_names, name_type_mask,
eLanguageTypeUnknown, module_list,
@@ -908,12 +847,8 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateByNames(
const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask,
LanguageType symbol_language, const SBFileSpecList &module_list,
const SBFileSpecList &comp_unit_list) {
- LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
- (const char **, uint32_t, uint32_t, lldb::LanguageType,
- const lldb::SBFileSpecList &,
- const lldb::SBFileSpecList &),
- symbol_names, num_names, name_type_mask, symbol_language,
- module_list, comp_unit_list);
+ LLDB_INSTRUMENT_VA(this, symbol_names, num_names, name_type_mask,
+ symbol_language, module_list, comp_unit_list);
return BreakpointCreateByNames(symbol_names, num_names, name_type_mask,
eLanguageTypeUnknown, 0, module_list,
@@ -924,12 +859,8 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateByNames(
const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask,
LanguageType symbol_language, lldb::addr_t offset,
const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) {
- LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
- (const char **, uint32_t, uint32_t, lldb::LanguageType,
- lldb::addr_t, const lldb::SBFileSpecList &,
- const lldb::SBFileSpecList &),
- symbol_names, num_names, name_type_mask, symbol_language,
- offset, module_list, comp_unit_list);
+ LLDB_INSTRUMENT_VA(this, symbol_names, num_names, name_type_mask,
+ symbol_language, offset, module_list, comp_unit_list);
SBBreakpoint sb_bp;
TargetSP target_sp(GetSP());
@@ -949,9 +880,7 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateByNames(
SBBreakpoint SBTarget::BreakpointCreateByRegex(const char *symbol_name_regex,
const char *module_name) {
- LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
- (const char *, const char *), symbol_name_regex,
- module_name);
+ LLDB_INSTRUMENT_VA(this, symbol_name_regex, module_name);
SBFileSpecList module_spec_list;
SBFileSpecList comp_unit_list;
@@ -966,10 +895,7 @@ lldb::SBBreakpoint
SBTarget::BreakpointCreateByRegex(const char *symbol_name_regex,
const SBFileSpecList &module_list,
const SBFileSpecList &comp_unit_list) {
- LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
- (const char *, const lldb::SBFileSpecList &,
- const lldb::SBFileSpecList &),
- symbol_name_regex, module_list, comp_unit_list);
+ LLDB_INSTRUMENT_VA(this, symbol_name_regex, module_list, comp_unit_list);
return BreakpointCreateByRegex(symbol_name_regex, eLanguageTypeUnknown,
module_list, comp_unit_list);
@@ -978,12 +904,8 @@ SBTarget::BreakpointCreateByRegex(const char *symbol_name_regex,
lldb::SBBreakpoint SBTarget::BreakpointCreateByRegex(
const char *symbol_name_regex, LanguageType symbol_language,
const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) {
- LLDB_RECORD_METHOD(
- lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
- (const char *, lldb::LanguageType, const lldb::SBFileSpecList &,
- const lldb::SBFileSpecList &),
- symbol_name_regex, symbol_language, module_list, comp_unit_list);
-
+ LLDB_INSTRUMENT_VA(this, symbol_name_regex, symbol_language, module_list,
+ comp_unit_list);
SBBreakpoint sb_bp;
TargetSP target_sp(GetSP());
@@ -1003,8 +925,7 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateByRegex(
}
SBBreakpoint SBTarget::BreakpointCreateByAddress(addr_t address) {
- LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByAddress,
- (lldb::addr_t), address);
+ LLDB_INSTRUMENT_VA(this, address);
SBBreakpoint sb_bp;
TargetSP target_sp(GetSP());
@@ -1018,8 +939,7 @@ SBBreakpoint SBTarget::BreakpointCreateByAddress(addr_t address) {
}
SBBreakpoint SBTarget::BreakpointCreateBySBAddress(SBAddress &sb_address) {
- LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateBySBAddress,
- (lldb::SBAddress &), sb_address);
+ LLDB_INSTRUMENT_VA(this, sb_address);
SBBreakpoint sb_bp;
TargetSP target_sp(GetSP());
@@ -1040,10 +960,7 @@ lldb::SBBreakpoint
SBTarget::BreakpointCreateBySourceRegex(const char *source_regex,
const lldb::SBFileSpec &source_file,
const char *module_name) {
- LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget,
- BreakpointCreateBySourceRegex,
- (const char *, const lldb::SBFileSpec &, const char *),
- source_regex, source_file, module_name);
+ LLDB_INSTRUMENT_VA(this, source_regex, source_file, module_name);
SBFileSpecList module_spec_list;
@@ -1063,11 +980,7 @@ SBTarget::BreakpointCreateBySourceRegex(const char *source_regex,
lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex(
const char *source_regex, const SBFileSpecList &module_list,
const lldb::SBFileSpecList &source_file_list) {
- LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget,
- BreakpointCreateBySourceRegex,
- (const char *, const lldb::SBFileSpecList &,
- const lldb::SBFileSpecList &),
- source_regex, module_list, source_file_list);
+ LLDB_INSTRUMENT_VA(this, source_regex, module_list, source_file_list);
return BreakpointCreateBySourceRegex(source_regex, module_list,
source_file_list, SBStringList());
@@ -1077,11 +990,8 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex(
const char *source_regex, const SBFileSpecList &module_list,
const lldb::SBFileSpecList &source_file_list,
const SBStringList &func_names) {
- LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget,
- BreakpointCreateBySourceRegex,
- (const char *, const lldb::SBFileSpecList &,
- const lldb::SBFileSpecList &, const lldb::SBStringList &),
- source_regex, module_list, source_file_list, func_names);
+ LLDB_INSTRUMENT_VA(this, source_regex, module_list, source_file_list,
+ func_names);
SBBreakpoint sb_bp;
TargetSP target_sp(GetSP());
@@ -1106,9 +1016,7 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex(
lldb::SBBreakpoint
SBTarget::BreakpointCreateForException(lldb::LanguageType language,
bool catch_bp, bool throw_bp) {
- LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateForException,
- (lldb::LanguageType, bool, bool), language, catch_bp,
- throw_bp);
+ LLDB_INSTRUMENT_VA(this, language, catch_bp, throw_bp);
SBBreakpoint sb_bp;
TargetSP target_sp(GetSP());
@@ -1126,11 +1034,8 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateFromScript(
const char *class_name, SBStructuredData &extra_args,
const SBFileSpecList &module_list, const SBFileSpecList &file_list,
bool request_hardware) {
- LLDB_RECORD_METHOD(
- lldb::SBBreakpoint, SBTarget, BreakpointCreateFromScript,
- (const char *, lldb::SBStructuredData &, const lldb::SBFileSpecList &,
- const lldb::SBFileSpecList &, bool),
- class_name, extra_args, module_list, file_list, request_hardware);
+ LLDB_INSTRUMENT_VA(this, class_name, extra_args, module_list, file_list,
+ request_hardware);
SBBreakpoint sb_bp;
TargetSP target_sp(GetSP());
@@ -1153,7 +1058,7 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateFromScript(
}
uint32_t SBTarget::GetNumBreakpoints() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumBreakpoints);
+ LLDB_INSTRUMENT_VA(this);
TargetSP target_sp(GetSP());
if (target_sp) {
@@ -1164,8 +1069,7 @@ uint32_t SBTarget::GetNumBreakpoints() const {
}
SBBreakpoint SBTarget::GetBreakpointAtIndex(uint32_t idx) const {
- LLDB_RECORD_METHOD_CONST(lldb::SBBreakpoint, SBTarget, GetBreakpointAtIndex,
- (uint32_t), idx);
+ LLDB_INSTRUMENT_VA(this, idx);
SBBreakpoint sb_breakpoint;
TargetSP target_sp(GetSP());
@@ -1177,8 +1081,7 @@ SBBreakpoint SBTarget::GetBreakpointAtIndex(uint32_t idx) const {
}
bool SBTarget::BreakpointDelete(break_id_t bp_id) {
- LLDB_RECORD_METHOD(bool, SBTarget, BreakpointDelete, (lldb::break_id_t),
- bp_id);
+ LLDB_INSTRUMENT_VA(this, bp_id);
bool result = false;
TargetSP target_sp(GetSP());
@@ -1191,8 +1094,7 @@ bool SBTarget::BreakpointDelete(break_id_t bp_id) {
}
SBBreakpoint SBTarget::FindBreakpointByID(break_id_t bp_id) {
- LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, FindBreakpointByID,
- (lldb::break_id_t), bp_id);
+ LLDB_INSTRUMENT_VA(this, bp_id);
SBBreakpoint sb_breakpoint;
TargetSP target_sp(GetSP());
@@ -1206,8 +1108,7 @@ SBBreakpoint SBTarget::FindBreakpointByID(break_id_t bp_id) {
bool SBTarget::FindBreakpointsByName(const char *name,
SBBreakpointList &bkpts) {
- LLDB_RECORD_METHOD(bool, SBTarget, FindBreakpointsByName,
- (const char *, lldb::SBBreakpointList &), name, bkpts);
+ LLDB_INSTRUMENT_VA(this, name, bkpts);
TargetSP target_sp(GetSP());
if (target_sp) {
@@ -1228,8 +1129,7 @@ bool SBTarget::FindBreakpointsByName(const char *name,
}
void SBTarget::GetBreakpointNames(SBStringList &names) {
- LLDB_RECORD_METHOD(void, SBTarget, GetBreakpointNames, (lldb::SBStringList &),
- names);
+ LLDB_INSTRUMENT_VA(this, names);
names.Clear();
@@ -1245,8 +1145,7 @@ void SBTarget::GetBreakpointNames(SBStringList &names) {
}
void SBTarget::DeleteBreakpointName(const char *name) {
- LLDB_RECORD_METHOD(void, SBTarget, DeleteBreakpointName, (const char *),
- name);
+ LLDB_INSTRUMENT_VA(this, name);
TargetSP target_sp(GetSP());
if (target_sp) {
@@ -1256,7 +1155,7 @@ void SBTarget::DeleteBreakpointName(const char *name) {
}
bool SBTarget::EnableAllBreakpoints() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, EnableAllBreakpoints);
+ LLDB_INSTRUMENT_VA(this);
TargetSP target_sp(GetSP());
if (target_sp) {
@@ -1268,7 +1167,7 @@ bool SBTarget::EnableAllBreakpoints() {
}
bool SBTarget::DisableAllBreakpoints() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DisableAllBreakpoints);
+ LLDB_INSTRUMENT_VA(this);
TargetSP target_sp(GetSP());
if (target_sp) {
@@ -1280,7 +1179,7 @@ bool SBTarget::DisableAllBreakpoints() {
}
bool SBTarget::DeleteAllBreakpoints() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DeleteAllBreakpoints);
+ LLDB_INSTRUMENT_VA(this);
TargetSP target_sp(GetSP());
if (target_sp) {
@@ -1293,9 +1192,7 @@ bool SBTarget::DeleteAllBreakpoints() {
lldb::SBError SBTarget::BreakpointsCreateFromFile(SBFileSpec &source_file,
SBBreakpointList &new_bps) {
- LLDB_RECORD_METHOD(lldb::SBError, SBTarget, BreakpointsCreateFromFile,
- (lldb::SBFileSpec &, lldb::SBBreakpointList &),
- source_file, new_bps);
+ LLDB_INSTRUMENT_VA(this, source_file, new_bps);
SBStringList empty_name_list;
return BreakpointsCreateFromFile(source_file, empty_name_list, new_bps);
@@ -1304,10 +1201,7 @@ lldb::SBError SBTarget::BreakpointsCreateFromFile(SBFileSpec &source_file,
lldb::SBError SBTarget::BreakpointsCreateFromFile(SBFileSpec &source_file,
SBStringList &matching_names,
SBBreakpointList &new_bps) {
- LLDB_RECORD_METHOD(
- lldb::SBError, SBTarget, BreakpointsCreateFromFile,
- (lldb::SBFileSpec &, lldb::SBStringList &, lldb::SBBreakpointList &),
- source_file, matching_names, new_bps);
+ LLDB_INSTRUMENT_VA(this, source_file, matching_names, new_bps);
SBError sberr;
TargetSP target_sp(GetSP());
@@ -1339,8 +1233,7 @@ lldb::SBError SBTarget::BreakpointsCreateFromFile(SBFileSpec &source_file,
}
lldb::SBError SBTarget::BreakpointsWriteToFile(SBFileSpec &dest_file) {
- LLDB_RECORD_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile,
- (lldb::SBFileSpec &), dest_file);
+ LLDB_INSTRUMENT_VA(this, dest_file);
SBError sberr;
TargetSP target_sp(GetSP());
@@ -1355,9 +1248,7 @@ lldb::SBError SBTarget::BreakpointsWriteToFile(SBFileSpec &dest_file) {
lldb::SBError SBTarget::BreakpointsWriteToFile(SBFileSpec &dest_file,
SBBreakpointList &bkpt_list,
bool append) {
- LLDB_RECORD_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile,
- (lldb::SBFileSpec &, lldb::SBBreakpointList &, bool),
- dest_file, bkpt_list, append);
+ LLDB_INSTRUMENT_VA(this, dest_file, bkpt_list, append);
SBError sberr;
TargetSP target_sp(GetSP());
@@ -1375,7 +1266,7 @@ lldb::SBError SBTarget::BreakpointsWriteToFile(SBFileSpec &dest_file,
}
uint32_t SBTarget::GetNumWatchpoints() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumWatchpoints);
+ LLDB_INSTRUMENT_VA(this);
TargetSP target_sp(GetSP());
if (target_sp) {
@@ -1386,8 +1277,7 @@ uint32_t SBTarget::GetNumWatchpoints() const {
}
SBWatchpoint SBTarget::GetWatchpointAtIndex(uint32_t idx) const {
- LLDB_RECORD_METHOD_CONST(lldb::SBWatchpoint, SBTarget, GetWatchpointAtIndex,
- (uint32_t), idx);
+ LLDB_INSTRUMENT_VA(this, idx);
SBWatchpoint sb_watchpoint;
TargetSP target_sp(GetSP());
@@ -1399,9 +1289,7 @@ SBWatchpoint SBTarget::GetWatchpointAtIndex(uint32_t idx) const {
}
bool SBTarget::DeleteWatchpoint(watch_id_t wp_id) {
- LLDB_RECORD_METHOD(bool, SBTarget, DeleteWatchpoint, (lldb::watch_id_t),
- wp_id);
-
+ LLDB_INSTRUMENT_VA(this, wp_id);
bool result = false;
TargetSP target_sp(GetSP());
@@ -1416,9 +1304,7 @@ bool SBTarget::DeleteWatchpoint(watch_id_t wp_id) {
}
SBWatchpoint SBTarget::FindWatchpointByID(lldb::watch_id_t wp_id) {
- LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBTarget, FindWatchpointByID,
- (lldb::watch_id_t), wp_id);
-
+ LLDB_INSTRUMENT_VA(this, wp_id);
SBWatchpoint sb_watchpoint;
lldb::WatchpointSP watchpoint_sp;
@@ -1437,9 +1323,7 @@ SBWatchpoint SBTarget::FindWatchpointByID(lldb::watch_id_t wp_id) {
lldb::SBWatchpoint SBTarget::WatchAddress(lldb::addr_t addr, size_t size,
bool read, bool write,
SBError &error) {
- LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBTarget, WatchAddress,
- (lldb::addr_t, size_t, bool, bool, lldb::SBError &), addr,
- size, read, write, error);
+ LLDB_INSTRUMENT_VA(this, addr, size, read, write, error);
SBWatchpoint sb_watchpoint;
lldb::WatchpointSP watchpoint_sp;
@@ -1472,7 +1356,7 @@ lldb::SBWatchpoint SBTarget::WatchAddress(lldb::addr_t addr, size_t size,
}
bool SBTarget::EnableAllWatchpoints() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, EnableAllWatchpoints);
+ LLDB_INSTRUMENT_VA(this);
TargetSP target_sp(GetSP());
if (target_sp) {
@@ -1486,7 +1370,7 @@ bool SBTarget::EnableAllWatchpoints() {
}
bool SBTarget::DisableAllWatchpoints() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DisableAllWatchpoints);
+ LLDB_INSTRUMENT_VA(this);
TargetSP target_sp(GetSP());
if (target_sp) {
@@ -1501,9 +1385,7 @@ bool SBTarget::DisableAllWatchpoints() {
SBValue SBTarget::CreateValueFromAddress(const char *name, SBAddress addr,
SBType type) {
- LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, CreateValueFromAddress,
- (const char *, lldb::SBAddress, lldb::SBType), name, addr,
- type);
+ LLDB_INSTRUMENT_VA(this, name, addr, type);
SBValue sb_value;
lldb::ValueObjectSP new_value_sp;
@@ -1521,9 +1403,7 @@ SBValue SBTarget::CreateValueFromAddress(const char *name, SBAddress addr,
lldb::SBValue SBTarget::CreateValueFromData(const char *name, lldb::SBData data,
lldb::SBType type) {
- LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, CreateValueFromData,
- (const char *, lldb::SBData, lldb::SBType), name, data,
- type);
+ LLDB_INSTRUMENT_VA(this, name, data, type);
SBValue sb_value;
lldb::ValueObjectSP new_value_sp;
@@ -1541,8 +1421,7 @@ lldb::SBValue SBTarget::CreateValueFromData(const char *name, lldb::SBData data,
lldb::SBValue SBTarget::CreateValueFromExpression(const char *name,
const char *expr) {
- LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, CreateValueFromExpression,
- (const char *, const char *), name, expr);
+ LLDB_INSTRUMENT_VA(this, name, expr);
SBValue sb_value;
lldb::ValueObjectSP new_value_sp;
@@ -1557,7 +1436,7 @@ lldb::SBValue SBTarget::CreateValueFromExpression(const char *name,
}
bool SBTarget::DeleteAllWatchpoints() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DeleteAllWatchpoints);
+ LLDB_INSTRUMENT_VA(this);
TargetSP target_sp(GetSP());
if (target_sp) {
@@ -1572,9 +1451,7 @@ bool SBTarget::DeleteAllWatchpoints() {
void SBTarget::AppendImageSearchPath(const char *from, const char *to,
lldb::SBError &error) {
- LLDB_RECORD_METHOD(void, SBTarget, AppendImageSearchPath,
- (const char *, const char *, lldb::SBError &), from, to,
- error);
+ LLDB_INSTRUMENT_VA(this, from, to, error);
TargetSP target_sp(GetSP());
if (!target_sp)
@@ -1591,18 +1468,14 @@ void SBTarget::AppendImageSearchPath(const char *from, const char *to,
lldb::SBModule SBTarget::AddModule(const char *path, const char *triple,
const char *uuid_cstr) {
- LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule,
- (const char *, const char *, const char *), path, triple,
- uuid_cstr);
+ LLDB_INSTRUMENT_VA(this, path, triple, uuid_cstr);
return AddModule(path, triple, uuid_cstr, nullptr);
}
lldb::SBModule SBTarget::AddModule(const char *path, const char *triple,
const char *uuid_cstr, const char *symfile) {
- LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule,
- (const char *, const char *, const char *, const char *),
- path, triple, uuid_cstr, symfile);
+ LLDB_INSTRUMENT_VA(this, path, triple, uuid_cstr, symfile);
lldb::SBModule sb_module;
TargetSP target_sp(GetSP());
@@ -1629,8 +1502,7 @@ lldb::SBModule SBTarget::AddModule(const char *path, const char *triple,
}
lldb::SBModule SBTarget::AddModule(const SBModuleSpec &module_spec) {
- LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule,
- (const lldb::SBModuleSpec &), module_spec);
+ LLDB_INSTRUMENT_VA(this, module_spec);
lldb::SBModule sb_module;
TargetSP target_sp(GetSP());
@@ -1641,7 +1513,7 @@ lldb::SBModule SBTarget::AddModule(const SBModuleSpec &module_spec) {
}
bool SBTarget::AddModule(lldb::SBModule &module) {
- LLDB_RECORD_METHOD(bool, SBTarget, AddModule, (lldb::SBModule &), module);
+ LLDB_INSTRUMENT_VA(this, module);
TargetSP target_sp(GetSP());
if (target_sp) {
@@ -1652,7 +1524,7 @@ bool SBTarget::AddModule(lldb::SBModule &module) {
}
uint32_t SBTarget::GetNumModules() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumModules);
+ LLDB_INSTRUMENT_VA(this);
uint32_t num = 0;
TargetSP target_sp(GetSP());
@@ -1665,14 +1537,13 @@ uint32_t SBTarget::GetNumModules() const {
}
void SBTarget::Clear() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBTarget, Clear);
+ LLDB_INSTRUMENT_VA(this);
m_opaque_sp.reset();
}
SBModule SBTarget::FindModule(const SBFileSpec &sb_file_spec) {
- LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, FindModule,
- (const lldb::SBFileSpec &), sb_file_spec);
+ LLDB_INSTRUMENT_VA(this, sb_file_spec);
SBModule sb_module;
TargetSP target_sp(GetSP());
@@ -1685,8 +1556,7 @@ SBModule SBTarget::FindModule(const SBFileSpec &sb_file_spec) {
}
SBSymbolContextList SBTarget::FindCompileUnits(const SBFileSpec &sb_file_spec) {
- LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindCompileUnits,
- (const lldb::SBFileSpec &), sb_file_spec);
+ LLDB_INSTRUMENT_VA(this, sb_file_spec);
SBSymbolContextList sb_sc_list;
const TargetSP target_sp(GetSP());
@@ -1696,7 +1566,7 @@ SBSymbolContextList SBTarget::FindCompileUnits(const SBFileSpec &sb_file_spec) {
}
lldb::ByteOrder SBTarget::GetByteOrder() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::ByteOrder, SBTarget, GetByteOrder);
+ LLDB_INSTRUMENT_VA(this);
TargetSP target_sp(GetSP());
if (target_sp)
@@ -1705,7 +1575,7 @@ lldb::ByteOrder SBTarget::GetByteOrder() {
}
const char *SBTarget::GetTriple() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTarget, GetTriple);
+ LLDB_INSTRUMENT_VA(this);
TargetSP target_sp(GetSP());
if (target_sp) {
@@ -1720,7 +1590,7 @@ const char *SBTarget::GetTriple() {
}
uint32_t SBTarget::GetDataByteSize() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTarget, GetDataByteSize);
+ LLDB_INSTRUMENT_VA(this);
TargetSP target_sp(GetSP());
if (target_sp) {
@@ -1730,7 +1600,7 @@ uint32_t SBTarget::GetDataByteSize() {
}
uint32_t SBTarget::GetCodeByteSize() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTarget, GetCodeByteSize);
+ LLDB_INSTRUMENT_VA(this);
TargetSP target_sp(GetSP());
if (target_sp) {
@@ -1740,7 +1610,7 @@ uint32_t SBTarget::GetCodeByteSize() {
}
uint32_t SBTarget::GetMaximumNumberOfChildrenToDisplay() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetMaximumNumberOfChildrenToDisplay);
+ LLDB_INSTRUMENT_VA(this);
TargetSP target_sp(GetSP());
if(target_sp){
@@ -1750,7 +1620,7 @@ uint32_t SBTarget::GetMaximumNumberOfChildrenToDisplay() const {
}
uint32_t SBTarget::GetAddressByteSize() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTarget, GetAddressByteSize);
+ LLDB_INSTRUMENT_VA(this);
TargetSP target_sp(GetSP());
if (target_sp)
@@ -1759,8 +1629,7 @@ uint32_t SBTarget::GetAddressByteSize() {
}
SBModule SBTarget::GetModuleAtIndex(uint32_t idx) {
- LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, GetModuleAtIndex, (uint32_t),
- idx);
+ LLDB_INSTRUMENT_VA(this, idx);
SBModule sb_module;
ModuleSP module_sp;
@@ -1775,7 +1644,7 @@ SBModule SBTarget::GetModuleAtIndex(uint32_t idx) {
}
bool SBTarget::RemoveModule(lldb::SBModule module) {
- LLDB_RECORD_METHOD(bool, SBTarget, RemoveModule, (lldb::SBModule), module);
+ LLDB_INSTRUMENT_VA(this, module);
TargetSP target_sp(GetSP());
if (target_sp)
@@ -1784,9 +1653,7 @@ bool SBTarget::RemoveModule(lldb::SBModule module) {
}
SBBroadcaster SBTarget::GetBroadcaster() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBTarget,
- GetBroadcaster);
-
+ LLDB_INSTRUMENT_VA(this);
TargetSP target_sp(GetSP());
SBBroadcaster broadcaster(target_sp.get(), false);
@@ -1796,9 +1663,7 @@ SBBroadcaster SBTarget::GetBroadcaster() const {
bool SBTarget::GetDescription(SBStream &description,
lldb::DescriptionLevel description_level) {
- LLDB_RECORD_METHOD(bool, SBTarget, GetDescription,
- (lldb::SBStream &, lldb::DescriptionLevel), description,
- description_level);
+ LLDB_INSTRUMENT_VA(this, description, description_level);
Stream &strm = description.ref();
@@ -1813,8 +1678,7 @@ bool SBTarget::GetDescription(SBStream &description,
lldb::SBSymbolContextList SBTarget::FindFunctions(const char *name,
uint32_t name_type_mask) {
- LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindFunctions,
- (const char *, uint32_t), name, name_type_mask);
+ LLDB_INSTRUMENT_VA(this, name, name_type_mask);
lldb::SBSymbolContextList sb_sc_list;
if (!name || !name[0])
@@ -1837,9 +1701,7 @@ lldb::SBSymbolContextList SBTarget::FindFunctions(const char *name,
lldb::SBSymbolContextList SBTarget::FindGlobalFunctions(const char *name,
uint32_t max_matches,
MatchType matchtype) {
- LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindGlobalFunctions,
- (const char *, uint32_t, lldb::MatchType), name,
- max_matches, matchtype);
+ LLDB_INSTRUMENT_VA(this, name, max_matches, matchtype);
lldb::SBSymbolContextList sb_sc_list;
if (name && name[0]) {
@@ -1873,8 +1735,7 @@ lldb::SBSymbolContextList SBTarget::FindGlobalFunctions(const char *name,
}
lldb::SBType SBTarget::FindFirstType(const char *typename_cstr) {
- LLDB_RECORD_METHOD(lldb::SBType, SBTarget, FindFirstType, (const char *),
- typename_cstr);
+ LLDB_INSTRUMENT_VA(this, typename_cstr);
TargetSP target_sp(GetSP());
if (typename_cstr && typename_cstr[0] && target_sp) {
@@ -1915,8 +1776,7 @@ lldb::SBType SBTarget::FindFirstType(const char *typename_cstr) {
}
SBType SBTarget::GetBasicType(lldb::BasicType type) {
- LLDB_RECORD_METHOD(lldb::SBType, SBTarget, GetBasicType, (lldb::BasicType),
- type);
+ LLDB_INSTRUMENT_VA(this, type);
TargetSP target_sp(GetSP());
if (target_sp) {
@@ -1928,8 +1788,7 @@ SBType SBTarget::GetBasicType(lldb::BasicType type) {
}
lldb::SBTypeList SBTarget::FindTypes(const char *typename_cstr) {
- LLDB_RECORD_METHOD(lldb::SBTypeList, SBTarget, FindTypes, (const char *),
- typename_cstr);
+ LLDB_INSTRUMENT_VA(this, typename_cstr);
SBTypeList sb_type_list;
TargetSP target_sp(GetSP());
@@ -1973,8 +1832,7 @@ lldb::SBTypeList SBTarget::FindTypes(const char *typename_cstr) {
SBValueList SBTarget::FindGlobalVariables(const char *name,
uint32_t max_matches) {
- LLDB_RECORD_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables,
- (const char *, uint32_t), name, max_matches);
+ LLDB_INSTRUMENT_VA(this, name, max_matches);
SBValueList sb_value_list;
@@ -2002,9 +1860,7 @@ SBValueList SBTarget::FindGlobalVariables(const char *name,
SBValueList SBTarget::FindGlobalVariables(const char *name,
uint32_t max_matches,
MatchType matchtype) {
- LLDB_RECORD_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables,
- (const char *, uint32_t, lldb::MatchType), name,
- max_matches, matchtype);
+ LLDB_INSTRUMENT_VA(this, name, max_matches, matchtype);
SBValueList sb_value_list;
@@ -2046,8 +1902,7 @@ SBValueList SBTarget::FindGlobalVariables(const char *name,
}
lldb::SBValue SBTarget::FindFirstGlobalVariable(const char *name) {
- LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, FindFirstGlobalVariable,
- (const char *), name);
+ LLDB_INSTRUMENT_VA(this, name);
SBValueList sb_value_list(FindGlobalVariables(name, 1));
if (sb_value_list.IsValid() && sb_value_list.GetSize() > 0)
@@ -2056,7 +1911,7 @@ lldb::SBValue SBTarget::FindFirstGlobalVariable(const char *name) {
}
SBSourceManager SBTarget::GetSourceManager() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSourceManager, SBTarget, GetSourceManager);
+ LLDB_INSTRUMENT_VA(this);
SBSourceManager source_manager(*this);
return source_manager;
@@ -2064,8 +1919,7 @@ SBSourceManager SBTarget::GetSourceManager() {
lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr,
uint32_t count) {
- LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions,
- (lldb::SBAddress, uint32_t), base_addr, count);
+ LLDB_INSTRUMENT_VA(this, base_addr, count);
return ReadInstructions(base_addr, count, nullptr);
}
@@ -2073,9 +1927,7 @@ lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr,
lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr,
uint32_t count,
const char *flavor_string) {
- LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions,
- (lldb::SBAddress, uint32_t, const char *), base_addr,
- count, flavor_string);
+ LLDB_INSTRUMENT_VA(this, base_addr, count, flavor_string);
SBInstructionList sb_instructions;
@@ -2105,9 +1957,7 @@ lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr,
lldb::SBInstructionList SBTarget::GetInstructions(lldb::SBAddress base_addr,
const void *buf,
size_t size) {
- LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, GetInstructions,
- (lldb::SBAddress, const void *, size_t), base_addr, buf,
- size);
+ LLDB_INSTRUMENT_VA(this, base_addr, buf, size);
return GetInstructionsWithFlavor(base_addr, nullptr, buf, size);
}
@@ -2116,10 +1966,7 @@ lldb::SBInstructionList
SBTarget::GetInstructionsWithFlavor(lldb::SBAddress base_addr,
const char *flavor_string, const void *buf,
size_t size) {
- LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget,
- GetInstructionsWithFlavor,
- (lldb::SBAddress, const char *, const void *, size_t),
- base_addr, flavor_string, buf, size);
+ LLDB_INSTRUMENT_VA(this, base_addr, flavor_string, buf, size);
SBInstructionList sb_instructions;
@@ -2143,9 +1990,7 @@ SBTarget::GetInstructionsWithFlavor(lldb::SBAddress base_addr,
lldb::SBInstructionList SBTarget::GetInstructions(lldb::addr_t base_addr,
const void *buf,
size_t size) {
- LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, GetInstructions,
- (lldb::addr_t, const void *, size_t), base_addr, buf,
- size);
+ LLDB_INSTRUMENT_VA(this, base_addr, buf, size);
return GetInstructionsWithFlavor(ResolveLoadAddress(base_addr), nullptr, buf,
size);
@@ -2155,10 +2000,7 @@ lldb::SBInstructionList
SBTarget::GetInstructionsWithFlavor(lldb::addr_t base_addr,
const char *flavor_string, const void *buf,
size_t size) {
- LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget,
- GetInstructionsWithFlavor,
- (lldb::addr_t, const char *, const void *, size_t),
- base_addr, flavor_string, buf, size);
+ LLDB_INSTRUMENT_VA(this, base_addr, flavor_string, buf, size);
return GetInstructionsWithFlavor(ResolveLoadAddress(base_addr), flavor_string,
buf, size);
@@ -2166,9 +2008,7 @@ SBTarget::GetInstructionsWithFlavor(lldb::addr_t base_addr,
SBError SBTarget::SetSectionLoadAddress(lldb::SBSection section,
lldb::addr_t section_base_addr) {
- LLDB_RECORD_METHOD(lldb::SBError, SBTarget, SetSectionLoadAddress,
- (lldb::SBSection, lldb::addr_t), section,
- section_base_addr);
+ LLDB_INSTRUMENT_VA(this, section, section_base_addr);
SBError sb_error;
TargetSP target_sp(GetSP());
@@ -2204,8 +2044,7 @@ SBError SBTarget::SetSectionLoadAddress(lldb::SBSection section,
}
SBError SBTarget::ClearSectionLoadAddress(lldb::SBSection section) {
- LLDB_RECORD_METHOD(lldb::SBError, SBTarget, ClearSectionLoadAddress,
- (lldb::SBSection), section);
+ LLDB_INSTRUMENT_VA(this, section);
SBError sb_error;
@@ -2240,8 +2079,7 @@ SBError SBTarget::ClearSectionLoadAddress(lldb::SBSection section) {
SBError SBTarget::SetModuleLoadAddress(lldb::SBModule module,
int64_t slide_offset) {
- LLDB_RECORD_METHOD(lldb::SBError, SBTarget, SetModuleLoadAddress,
- (lldb::SBModule, int64_t), module, slide_offset);
+ LLDB_INSTRUMENT_VA(this, module, slide_offset);
SBError sb_error;
@@ -2274,8 +2112,7 @@ SBError SBTarget::SetModuleLoadAddress(lldb::SBModule module,
}
SBError SBTarget::ClearModuleLoadAddress(lldb::SBModule module) {
- LLDB_RECORD_METHOD(lldb::SBError, SBTarget, ClearModuleLoadAddress,
- (lldb::SBModule), module);
+ LLDB_INSTRUMENT_VA(this, module);
SBError sb_error;
@@ -2327,8 +2164,7 @@ SBError SBTarget::ClearModuleLoadAddress(lldb::SBModule module) {
lldb::SBSymbolContextList SBTarget::FindSymbols(const char *name,
lldb::SymbolType symbol_type) {
- LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindSymbols,
- (const char *, lldb::SymbolType), name, symbol_type);
+ LLDB_INSTRUMENT_VA(this, name, symbol_type);
SBSymbolContextList sb_sc_list;
if (name && name[0]) {
@@ -2341,8 +2177,7 @@ lldb::SBSymbolContextList SBTarget::FindSymbols(const char *name,
}
lldb::SBValue SBTarget::EvaluateExpression(const char *expr) {
- LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, EvaluateExpression,
- (const char *), expr);
+ LLDB_INSTRUMENT_VA(this, expr);
TargetSP target_sp(GetSP());
if (!target_sp)
@@ -2358,9 +2193,7 @@ lldb::SBValue SBTarget::EvaluateExpression(const char *expr) {
lldb::SBValue SBTarget::EvaluateExpression(const char *expr,
const SBExpressionOptions &options) {
- LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, EvaluateExpression,
- (const char *, const lldb::SBExpressionOptions &), expr,
- options);
+ LLDB_INSTRUMENT_VA(this, expr, options);
Log *expr_log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
SBValue expr_result;
@@ -2393,7 +2226,7 @@ lldb::SBValue SBTarget::EvaluateExpression(const char *expr,
}
lldb::addr_t SBTarget::GetStackRedZoneSize() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBTarget, GetStackRedZoneSize);
+ LLDB_INSTRUMENT_VA(this);
TargetSP target_sp(GetSP());
if (target_sp) {
@@ -2410,8 +2243,7 @@ lldb::addr_t SBTarget::GetStackRedZoneSize() {
}
bool SBTarget::IsLoaded(const SBModule &module) const {
- LLDB_RECORD_METHOD_CONST(bool, SBTarget, IsLoaded, (const lldb::SBModule &),
- module);
+ LLDB_INSTRUMENT_VA(this, module);
TargetSP target_sp(GetSP());
if (!target_sp)
@@ -2425,7 +2257,7 @@ bool SBTarget::IsLoaded(const SBModule &module) const {
}
lldb::SBLaunchInfo SBTarget::GetLaunchInfo() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBLaunchInfo, SBTarget, GetLaunchInfo);
+ LLDB_INSTRUMENT_VA(this);
lldb::SBLaunchInfo launch_info(nullptr);
TargetSP target_sp(GetSP());
@@ -2435,8 +2267,7 @@ lldb::SBLaunchInfo SBTarget::GetLaunchInfo() const {
}
void SBTarget::SetLaunchInfo(const lldb::SBLaunchInfo &launch_info) {
- LLDB_RECORD_METHOD(void, SBTarget, SetLaunchInfo,
- (const lldb::SBLaunchInfo &), launch_info);
+ LLDB_INSTRUMENT_VA(this, launch_info);
TargetSP target_sp(GetSP());
if (target_sp)
@@ -2444,7 +2275,7 @@ void SBTarget::SetLaunchInfo(const lldb::SBLaunchInfo &launch_info) {
}
SBEnvironment SBTarget::GetEnvironment() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBEnvironment, SBTarget, GetEnvironment);
+ LLDB_INSTRUMENT_VA(this);
TargetSP target_sp(GetSP());
if (target_sp) {
@@ -2455,7 +2286,7 @@ SBEnvironment SBTarget::GetEnvironment() {
}
lldb::SBTrace SBTarget::GetTrace() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTrace, SBTarget, GetTrace);
+ LLDB_INSTRUMENT_VA(this);
TargetSP target_sp(GetSP());
if (target_sp)
@@ -2465,8 +2296,7 @@ lldb::SBTrace SBTarget::GetTrace() {
}
lldb::SBTrace SBTarget::CreateTrace(lldb::SBError &error) {
- LLDB_RECORD_METHOD(lldb::SBTrace, SBTarget, CreateTrace, (lldb::SBError &),
- error);
+ LLDB_INSTRUMENT_VA(this, error);
TargetSP target_sp(GetSP());
error.Clear();
diff --git a/lldb/source/API/SBThread.cpp b/lldb/source/API/SBThread.cpp
index f10477c55370..46a6c2759140 100644
--- a/lldb/source/API/SBThread.cpp
+++ b/lldb/source/API/SBThread.cpp
@@ -7,7 +7,6 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBThread.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBDebugger.h"
@@ -40,6 +39,7 @@
#include "lldb/Target/ThreadPlanStepInstruction.h"
#include "lldb/Target/ThreadPlanStepOut.h"
#include "lldb/Target/ThreadPlanStepRange.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/State.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StructuredData.h"
@@ -51,24 +51,23 @@ using namespace lldb;
using namespace lldb_private;
const char *SBThread::GetBroadcasterClassName() {
- LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBThread,
- GetBroadcasterClassName);
+ LLDB_INSTRUMENT();
return Thread::GetStaticBroadcasterClass().AsCString();
}
// Constructors
SBThread::SBThread() : m_opaque_sp(new ExecutionContextRef()) {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBThread);
+ LLDB_INSTRUMENT_VA(this);
}
SBThread::SBThread(const ThreadSP &lldb_object_sp)
: m_opaque_sp(new ExecutionContextRef(lldb_object_sp)) {
- LLDB_RECORD_CONSTRUCTOR(SBThread, (const lldb::ThreadSP &), lldb_object_sp);
+ LLDB_INSTRUMENT_VA(this, lldb_object_sp);
}
SBThread::SBThread(const SBThread &rhs) {
- LLDB_RECORD_CONSTRUCTOR(SBThread, (const lldb::SBThread &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_sp = clone(rhs.m_opaque_sp);
}
@@ -76,8 +75,7 @@ SBThread::SBThread(const SBThread &rhs) {
// Assignment operator
const lldb::SBThread &SBThread::operator=(const SBThread &rhs) {
- LLDB_RECORD_METHOD(const lldb::SBThread &,
- SBThread, operator=,(const lldb::SBThread &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_sp = clone(rhs.m_opaque_sp);
@@ -88,7 +86,7 @@ const lldb::SBThread &SBThread::operator=(const SBThread &rhs) {
SBThread::~SBThread() = default;
lldb::SBQueue SBThread::GetQueue() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBQueue, SBThread, GetQueue);
+ LLDB_INSTRUMENT_VA(this);
SBQueue sb_queue;
QueueSP queue_sp;
@@ -109,11 +107,11 @@ lldb::SBQueue SBThread::GetQueue() const {
}
bool SBThread::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThread, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBThread::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThread, operator bool);
+ LLDB_INSTRUMENT_VA(this);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -130,13 +128,13 @@ SBThread::operator bool() const {
}
void SBThread::Clear() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBThread, Clear);
+ LLDB_INSTRUMENT_VA(this);
m_opaque_sp->Clear();
}
StopReason SBThread::GetStopReason() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::StopReason, SBThread, GetStopReason);
+ LLDB_INSTRUMENT_VA(this);
StopReason reason = eStopReasonInvalid;
std::unique_lock<std::recursive_mutex> lock;
@@ -153,7 +151,7 @@ StopReason SBThread::GetStopReason() {
}
size_t SBThread::GetStopReasonDataCount() {
- LLDB_RECORD_METHOD_NO_ARGS(size_t, SBThread, GetStopReasonDataCount);
+ LLDB_INSTRUMENT_VA(this);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -210,8 +208,7 @@ size_t SBThread::GetStopReasonDataCount() {
}
uint64_t SBThread::GetStopReasonDataAtIndex(uint32_t idx) {
- LLDB_RECORD_METHOD(uint64_t, SBThread, GetStopReasonDataAtIndex, (uint32_t),
- idx);
+ LLDB_INSTRUMENT_VA(this, idx);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -280,8 +277,7 @@ uint64_t SBThread::GetStopReasonDataAtIndex(uint32_t idx) {
}
bool SBThread::GetStopReasonExtendedInfoAsJSON(lldb::SBStream &stream) {
- LLDB_RECORD_METHOD(bool, SBThread, GetStopReasonExtendedInfoAsJSON,
- (lldb::SBStream &), stream);
+ LLDB_INSTRUMENT_VA(this, stream);
Stream &strm = stream.ref();
@@ -303,9 +299,7 @@ bool SBThread::GetStopReasonExtendedInfoAsJSON(lldb::SBStream &stream) {
SBThreadCollection
SBThread::GetStopReasonExtendedBacktraces(InstrumentationRuntimeType type) {
- LLDB_RECORD_METHOD(lldb::SBThreadCollection, SBThread,
- GetStopReasonExtendedBacktraces,
- (lldb::InstrumentationRuntimeType), type);
+ LLDB_INSTRUMENT_VA(this, type);
SBThreadCollection threads;
@@ -328,8 +322,7 @@ SBThread::GetStopReasonExtendedBacktraces(InstrumentationRuntimeType type) {
}
size_t SBThread::GetStopDescription(char *dst, size_t dst_len) {
- LLDB_RECORD_METHOD(size_t, SBThread, GetStopDescription, (char *, size_t),
- dst, "", dst_len);
+ LLDB_INSTRUMENT_VA(this, dst, dst_len);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -357,7 +350,7 @@ size_t SBThread::GetStopDescription(char *dst, size_t dst_len) {
}
SBValue SBThread::GetStopReturnValue() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBThread, GetStopReturnValue);
+ LLDB_INSTRUMENT_VA(this);
ValueObjectSP return_valobj_sp;
std::unique_lock<std::recursive_mutex> lock;
@@ -381,7 +374,7 @@ void SBThread::SetThread(const ThreadSP &lldb_object_sp) {
}
lldb::tid_t SBThread::GetThreadID() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::tid_t, SBThread, GetThreadID);
+ LLDB_INSTRUMENT_VA(this);
ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
if (thread_sp)
@@ -390,7 +383,7 @@ lldb::tid_t SBThread::GetThreadID() const {
}
uint32_t SBThread::GetIndexID() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBThread, GetIndexID);
+ LLDB_INSTRUMENT_VA(this);
ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
if (thread_sp)
@@ -399,7 +392,7 @@ uint32_t SBThread::GetIndexID() const {
}
const char *SBThread::GetName() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBThread, GetName);
+ LLDB_INSTRUMENT_VA(this);
const char *name = nullptr;
std::unique_lock<std::recursive_mutex> lock;
@@ -416,7 +409,7 @@ const char *SBThread::GetName() const {
}
const char *SBThread::GetQueueName() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBThread, GetQueueName);
+ LLDB_INSTRUMENT_VA(this);
const char *name = nullptr;
std::unique_lock<std::recursive_mutex> lock;
@@ -433,7 +426,7 @@ const char *SBThread::GetQueueName() const {
}
lldb::queue_id_t SBThread::GetQueueID() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::queue_id_t, SBThread, GetQueueID);
+ LLDB_INSTRUMENT_VA(this);
queue_id_t id = LLDB_INVALID_QUEUE_ID;
std::unique_lock<std::recursive_mutex> lock;
@@ -450,8 +443,7 @@ lldb::queue_id_t SBThread::GetQueueID() const {
}
bool SBThread::GetInfoItemByPathAsString(const char *path, SBStream &strm) {
- LLDB_RECORD_METHOD(bool, SBThread, GetInfoItemByPathAsString,
- (const char *, lldb::SBStream &), path, strm);
+ LLDB_INSTRUMENT_VA(this, path, strm);
bool success = false;
std::unique_lock<std::recursive_mutex> lock;
@@ -532,16 +524,14 @@ SBError SBThread::ResumeNewPlan(ExecutionContext &exe_ctx,
}
void SBThread::StepOver(lldb::RunMode stop_other_threads) {
- LLDB_RECORD_METHOD(void, SBThread, StepOver, (lldb::RunMode),
- stop_other_threads);
+ LLDB_INSTRUMENT_VA(this, stop_other_threads);
SBError error; // Ignored
StepOver(stop_other_threads, error);
}
void SBThread::StepOver(lldb::RunMode stop_other_threads, SBError &error) {
- LLDB_RECORD_METHOD(void, SBThread, StepOver, (lldb::RunMode, lldb::SBError &),
- stop_other_threads, error);
+ LLDB_INSTRUMENT_VA(this, stop_other_threads, error);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -573,16 +563,14 @@ void SBThread::StepOver(lldb::RunMode stop_other_threads, SBError &error) {
}
void SBThread::StepInto(lldb::RunMode stop_other_threads) {
- LLDB_RECORD_METHOD(void, SBThread, StepInto, (lldb::RunMode),
- stop_other_threads);
+ LLDB_INSTRUMENT_VA(this, stop_other_threads);
StepInto(nullptr, stop_other_threads);
}
void SBThread::StepInto(const char *target_name,
lldb::RunMode stop_other_threads) {
- LLDB_RECORD_METHOD(void, SBThread, StepInto, (const char *, lldb::RunMode),
- target_name, stop_other_threads);
+ LLDB_INSTRUMENT_VA(this, target_name, stop_other_threads);
SBError error; // Ignored
StepInto(target_name, LLDB_INVALID_LINE_NUMBER, error, stop_other_threads);
@@ -590,10 +578,7 @@ void SBThread::StepInto(const char *target_name,
void SBThread::StepInto(const char *target_name, uint32_t end_line,
SBError &error, lldb::RunMode stop_other_threads) {
- LLDB_RECORD_METHOD(void, SBThread, StepInto,
- (const char *, uint32_t, lldb::SBError &, lldb::RunMode),
- target_name, end_line, error, stop_other_threads);
-
+ LLDB_INSTRUMENT_VA(this, target_name, end_line, error, stop_other_threads);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -640,14 +625,14 @@ void SBThread::StepInto(const char *target_name, uint32_t end_line,
}
void SBThread::StepOut() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBThread, StepOut);
+ LLDB_INSTRUMENT_VA(this);
SBError error; // Ignored
StepOut(error);
}
void SBThread::StepOut(SBError &error) {
- LLDB_RECORD_METHOD(void, SBThread, StepOut, (lldb::SBError &), error);
+ LLDB_INSTRUMENT_VA(this, error);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -675,17 +660,14 @@ void SBThread::StepOut(SBError &error) {
}
void SBThread::StepOutOfFrame(SBFrame &sb_frame) {
- LLDB_RECORD_METHOD(void, SBThread, StepOutOfFrame, (lldb::SBFrame &),
- sb_frame);
+ LLDB_INSTRUMENT_VA(this, sb_frame);
SBError error; // Ignored
StepOutOfFrame(sb_frame, error);
}
void SBThread::StepOutOfFrame(SBFrame &sb_frame, SBError &error) {
- LLDB_RECORD_METHOD(void, SBThread, StepOutOfFrame,
- (lldb::SBFrame &, lldb::SBError &), sb_frame, error);
-
+ LLDB_INSTRUMENT_VA(this, sb_frame, error);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -722,15 +704,14 @@ void SBThread::StepOutOfFrame(SBFrame &sb_frame, SBError &error) {
}
void SBThread::StepInstruction(bool step_over) {
- LLDB_RECORD_METHOD(void, SBThread, StepInstruction, (bool), step_over);
+ LLDB_INSTRUMENT_VA(this, step_over);
SBError error; // Ignored
StepInstruction(step_over, error);
}
void SBThread::StepInstruction(bool step_over, SBError &error) {
- LLDB_RECORD_METHOD(void, SBThread, StepInstruction, (bool, lldb::SBError &),
- step_over, error);
+ LLDB_INSTRUMENT_VA(this, step_over, error);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -752,15 +733,14 @@ void SBThread::StepInstruction(bool step_over, SBError &error) {
}
void SBThread::RunToAddress(lldb::addr_t addr) {
- LLDB_RECORD_METHOD(void, SBThread, RunToAddress, (lldb::addr_t), addr);
+ LLDB_INSTRUMENT_VA(this, addr);
SBError error; // Ignored
RunToAddress(addr, error);
}
void SBThread::RunToAddress(lldb::addr_t addr, SBError &error) {
- LLDB_RECORD_METHOD(void, SBThread, RunToAddress,
- (lldb::addr_t, lldb::SBError &), addr, error);
+ LLDB_INSTRUMENT_VA(this, addr, error);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -789,9 +769,7 @@ void SBThread::RunToAddress(lldb::addr_t addr, SBError &error) {
SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame,
lldb::SBFileSpec &sb_file_spec, uint32_t line) {
- LLDB_RECORD_METHOD(lldb::SBError, SBThread, StepOverUntil,
- (lldb::SBFrame &, lldb::SBFileSpec &, uint32_t), sb_frame,
- sb_file_spec, line);
+ LLDB_INSTRUMENT_VA(this, sb_frame, sb_file_spec, line);
SBError sb_error;
char path[PATH_MAX];
@@ -908,17 +886,14 @@ SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame,
}
SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name) {
- LLDB_RECORD_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
- (const char *), script_class_name);
+ LLDB_INSTRUMENT_VA(this, script_class_name);
return StepUsingScriptedThreadPlan(script_class_name, true);
}
SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name,
bool resume_immediately) {
- LLDB_RECORD_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
- (const char *, bool), script_class_name,
- resume_immediately);
+ LLDB_INSTRUMENT_VA(this, script_class_name, resume_immediately);
lldb::SBStructuredData no_data;
return StepUsingScriptedThreadPlan(script_class_name, no_data,
@@ -928,9 +903,7 @@ SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name,
SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name,
SBStructuredData &args_data,
bool resume_immediately) {
- LLDB_RECORD_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
- (const char *, lldb::SBStructuredData &, bool),
- script_class_name, args_data, resume_immediately);
+ LLDB_INSTRUMENT_VA(this, script_class_name, args_data, resume_immediately);
SBError error;
@@ -966,8 +939,7 @@ SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name,
}
SBError SBThread::JumpToLine(lldb::SBFileSpec &file_spec, uint32_t line) {
- LLDB_RECORD_METHOD(lldb::SBError, SBThread, JumpToLine,
- (lldb::SBFileSpec &, uint32_t), file_spec, line);
+ LLDB_INSTRUMENT_VA(this, file_spec, line);
SBError sb_error;
@@ -987,8 +959,7 @@ SBError SBThread::JumpToLine(lldb::SBFileSpec &file_spec, uint32_t line) {
}
SBError SBThread::ReturnFromFrame(SBFrame &frame, SBValue &return_value) {
- LLDB_RECORD_METHOD(lldb::SBError, SBThread, ReturnFromFrame,
- (lldb::SBFrame &, lldb::SBValue &), frame, return_value);
+ LLDB_INSTRUMENT_VA(this, frame, return_value);
SBError sb_error;
@@ -1005,8 +976,7 @@ SBError SBThread::ReturnFromFrame(SBFrame &frame, SBValue &return_value) {
}
SBError SBThread::UnwindInnermostExpression() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBThread,
- UnwindInnermostExpression);
+ LLDB_INSTRUMENT_VA(this);
SBError sb_error;
@@ -1024,14 +994,14 @@ SBError SBThread::UnwindInnermostExpression() {
}
bool SBThread::Suspend() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, Suspend);
+ LLDB_INSTRUMENT_VA(this);
SBError error; // Ignored
return Suspend(error);
}
bool SBThread::Suspend(SBError &error) {
- LLDB_RECORD_METHOD(bool, SBThread, Suspend, (lldb::SBError &), error);
+ LLDB_INSTRUMENT_VA(this, error);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -1051,14 +1021,14 @@ bool SBThread::Suspend(SBError &error) {
}
bool SBThread::Resume() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, Resume);
+ LLDB_INSTRUMENT_VA(this);
SBError error; // Ignored
return Resume(error);
}
bool SBThread::Resume(SBError &error) {
- LLDB_RECORD_METHOD(bool, SBThread, Resume, (lldb::SBError &), error);
+ LLDB_INSTRUMENT_VA(this, error);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -1079,7 +1049,7 @@ bool SBThread::Resume(SBError &error) {
}
bool SBThread::IsSuspended() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, IsSuspended);
+ LLDB_INSTRUMENT_VA(this);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -1090,7 +1060,7 @@ bool SBThread::IsSuspended() {
}
bool SBThread::IsStopped() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, IsStopped);
+ LLDB_INSTRUMENT_VA(this);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -1101,7 +1071,7 @@ bool SBThread::IsStopped() {
}
SBProcess SBThread::GetProcess() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBThread, GetProcess);
+ LLDB_INSTRUMENT_VA(this);
SBProcess sb_process;
std::unique_lock<std::recursive_mutex> lock;
@@ -1117,7 +1087,7 @@ SBProcess SBThread::GetProcess() {
}
uint32_t SBThread::GetNumFrames() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBThread, GetNumFrames);
+ LLDB_INSTRUMENT_VA(this);
uint32_t num_frames = 0;
std::unique_lock<std::recursive_mutex> lock;
@@ -1134,7 +1104,7 @@ uint32_t SBThread::GetNumFrames() {
}
SBFrame SBThread::GetFrameAtIndex(uint32_t idx) {
- LLDB_RECORD_METHOD(lldb::SBFrame, SBThread, GetFrameAtIndex, (uint32_t), idx);
+ LLDB_INSTRUMENT_VA(this, idx);
SBFrame sb_frame;
StackFrameSP frame_sp;
@@ -1153,7 +1123,7 @@ SBFrame SBThread::GetFrameAtIndex(uint32_t idx) {
}
lldb::SBFrame SBThread::GetSelectedFrame() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFrame, SBThread, GetSelectedFrame);
+ LLDB_INSTRUMENT_VA(this);
SBFrame sb_frame;
StackFrameSP frame_sp;
@@ -1172,8 +1142,7 @@ lldb::SBFrame SBThread::GetSelectedFrame() {
}
lldb::SBFrame SBThread::SetSelectedFrame(uint32_t idx) {
- LLDB_RECORD_METHOD(lldb::SBFrame, SBThread, SetSelectedFrame, (uint32_t),
- idx);
+ LLDB_INSTRUMENT_VA(this, idx);
SBFrame sb_frame;
StackFrameSP frame_sp;
@@ -1196,45 +1165,39 @@ lldb::SBFrame SBThread::SetSelectedFrame(uint32_t idx) {
}
bool SBThread::EventIsThreadEvent(const SBEvent &event) {
- LLDB_RECORD_STATIC_METHOD(bool, SBThread, EventIsThreadEvent,
- (const lldb::SBEvent &), event);
+ LLDB_INSTRUMENT_VA(event);
return Thread::ThreadEventData::GetEventDataFromEvent(event.get()) != nullptr;
}
SBFrame SBThread::GetStackFrameFromEvent(const SBEvent &event) {
- LLDB_RECORD_STATIC_METHOD(lldb::SBFrame, SBThread, GetStackFrameFromEvent,
- (const lldb::SBEvent &), event);
+ LLDB_INSTRUMENT_VA(event);
return Thread::ThreadEventData::GetStackFrameFromEvent(event.get());
}
SBThread SBThread::GetThreadFromEvent(const SBEvent &event) {
- LLDB_RECORD_STATIC_METHOD(lldb::SBThread, SBThread, GetThreadFromEvent,
- (const lldb::SBEvent &), event);
+ LLDB_INSTRUMENT_VA(event);
return Thread::ThreadEventData::GetThreadFromEvent(event.get());
}
bool SBThread::operator==(const SBThread &rhs) const {
- LLDB_RECORD_METHOD_CONST(bool, SBThread, operator==,(const lldb::SBThread &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
return m_opaque_sp->GetThreadSP().get() ==
rhs.m_opaque_sp->GetThreadSP().get();
}
bool SBThread::operator!=(const SBThread &rhs) const {
- LLDB_RECORD_METHOD_CONST(bool, SBThread, operator!=,(const lldb::SBThread &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
return m_opaque_sp->GetThreadSP().get() !=
rhs.m_opaque_sp->GetThreadSP().get();
}
bool SBThread::GetStatus(SBStream &status) const {
- LLDB_RECORD_METHOD_CONST(bool, SBThread, GetStatus, (lldb::SBStream &),
- status);
+ LLDB_INSTRUMENT_VA(this, status);
Stream &strm = status.ref();
@@ -1250,15 +1213,13 @@ bool SBThread::GetStatus(SBStream &status) const {
}
bool SBThread::GetDescription(SBStream &description) const {
- LLDB_RECORD_METHOD_CONST(bool, SBThread, GetDescription, (lldb::SBStream &),
- description);
+ LLDB_INSTRUMENT_VA(this, description);
return GetDescription(description, false);
}
bool SBThread::GetDescription(SBStream &description, bool stop_format) const {
- LLDB_RECORD_METHOD_CONST(bool, SBThread, GetDescription,
- (lldb::SBStream &, bool), description, stop_format);
+ LLDB_INSTRUMENT_VA(this, description, stop_format);
Stream &strm = description.ref();
@@ -1278,8 +1239,7 @@ bool SBThread::GetDescription(SBStream &description, bool stop_format) const {
}
SBThread SBThread::GetExtendedBacktraceThread(const char *type) {
- LLDB_RECORD_METHOD(lldb::SBThread, SBThread, GetExtendedBacktraceThread,
- (const char *), type);
+ LLDB_INSTRUMENT_VA(this, type);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@@ -1313,8 +1273,7 @@ SBThread SBThread::GetExtendedBacktraceThread(const char *type) {
}
uint32_t SBThread::GetExtendedBacktraceOriginatingIndexID() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBThread,
- GetExtendedBacktraceOriginatingIndexID);
+ LLDB_INSTRUMENT_VA(this);
ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
if (thread_sp)
@@ -1323,7 +1282,7 @@ uint32_t SBThread::GetExtendedBacktraceOriginatingIndexID() {
}
SBValue SBThread::GetCurrentException() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBThread, GetCurrentException);
+ LLDB_INSTRUMENT_VA(this);
ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
if (!thread_sp)
@@ -1333,8 +1292,7 @@ SBValue SBThread::GetCurrentException() {
}
SBThread SBThread::GetCurrentExceptionBacktrace() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBThread, SBThread,
- GetCurrentExceptionBacktrace);
+ LLDB_INSTRUMENT_VA(this);
ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
if (!thread_sp)
@@ -1344,7 +1302,7 @@ SBThread SBThread::GetCurrentExceptionBacktrace() {
}
bool SBThread::SafeToCallFunctions() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, SafeToCallFunctions);
+ LLDB_INSTRUMENT_VA(this);
ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
if (thread_sp)
diff --git a/lldb/source/API/SBThreadCollection.cpp b/lldb/source/API/SBThreadCollection.cpp
index fcf066381c98..9d688e012239 100644
--- a/lldb/source/API/SBThreadCollection.cpp
+++ b/lldb/source/API/SBThreadCollection.cpp
@@ -7,28 +7,23 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBThreadCollection.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBThread.h"
#include "lldb/Target/ThreadList.h"
+#include "lldb/Utility/Instrumentation.h"
using namespace lldb;
using namespace lldb_private;
-SBThreadCollection::SBThreadCollection() {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBThreadCollection);
-}
+SBThreadCollection::SBThreadCollection() { LLDB_INSTRUMENT_VA(this); }
SBThreadCollection::SBThreadCollection(const SBThreadCollection &rhs)
: m_opaque_sp(rhs.m_opaque_sp) {
- LLDB_RECORD_CONSTRUCTOR(SBThreadCollection,
- (const lldb::SBThreadCollection &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
}
const SBThreadCollection &SBThreadCollection::
operator=(const SBThreadCollection &rhs) {
- LLDB_RECORD_METHOD(
- const lldb::SBThreadCollection &,
- SBThreadCollection, operator=,(const lldb::SBThreadCollection &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_sp = rhs.m_opaque_sp;
@@ -61,17 +56,17 @@ const lldb::ThreadCollectionSP &SBThreadCollection::operator*() const {
}
bool SBThreadCollection::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadCollection, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBThreadCollection::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadCollection, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp.get() != nullptr;
}
size_t SBThreadCollection::GetSize() {
- LLDB_RECORD_METHOD_NO_ARGS(size_t, SBThreadCollection, GetSize);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp)
return m_opaque_sp->GetSize();
@@ -79,8 +74,7 @@ size_t SBThreadCollection::GetSize() {
}
SBThread SBThreadCollection::GetThreadAtIndex(size_t idx) {
- LLDB_RECORD_METHOD(lldb::SBThread, SBThreadCollection, GetThreadAtIndex,
- (size_t), idx);
+ LLDB_INSTRUMENT_VA(this, idx);
SBThread thread;
if (m_opaque_sp && idx < m_opaque_sp->GetSize())
diff --git a/lldb/source/API/SBThreadPlan.cpp b/lldb/source/API/SBThreadPlan.cpp
index 26fcca5c2e23..2e66ac120839 100644
--- a/lldb/source/API/SBThreadPlan.cpp
+++ b/lldb/source/API/SBThreadPlan.cpp
@@ -6,8 +6,8 @@
//
//===----------------------------------------------------------------------===//
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBThread.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/API/SBFileSpec.h"
#include "lldb/API/SBStream.h"
@@ -50,22 +50,20 @@ using namespace lldb;
using namespace lldb_private;
// Constructors
-SBThreadPlan::SBThreadPlan() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBThreadPlan); }
+SBThreadPlan::SBThreadPlan() { LLDB_INSTRUMENT_VA(this); }
SBThreadPlan::SBThreadPlan(const ThreadPlanSP &lldb_object_sp)
: m_opaque_wp(lldb_object_sp) {
- LLDB_RECORD_CONSTRUCTOR(SBThreadPlan, (const lldb::ThreadPlanSP &),
- lldb_object_sp);
+ LLDB_INSTRUMENT_VA(this, lldb_object_sp);
}
SBThreadPlan::SBThreadPlan(const SBThreadPlan &rhs)
: m_opaque_wp(rhs.m_opaque_wp) {
- LLDB_RECORD_CONSTRUCTOR(SBThreadPlan, (const lldb::SBThreadPlan &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
}
SBThreadPlan::SBThreadPlan(lldb::SBThread &sb_thread, const char *class_name) {
- LLDB_RECORD_CONSTRUCTOR(SBThreadPlan, (lldb::SBThread &, const char *),
- sb_thread, class_name);
+ LLDB_INSTRUMENT_VA(this, sb_thread, class_name);
Thread *thread = sb_thread.get();
if (thread)
@@ -75,9 +73,7 @@ SBThreadPlan::SBThreadPlan(lldb::SBThread &sb_thread, const char *class_name) {
SBThreadPlan::SBThreadPlan(lldb::SBThread &sb_thread, const char *class_name,
lldb::SBStructuredData &args_data) {
- LLDB_RECORD_CONSTRUCTOR(SBThreadPlan, (lldb::SBThread &, const char *,
- SBStructuredData &),
- sb_thread, class_name, args_data);
+ LLDB_INSTRUMENT_VA(this, sb_thread, class_name, args_data);
Thread *thread = sb_thread.get();
if (thread)
@@ -88,8 +84,7 @@ SBThreadPlan::SBThreadPlan(lldb::SBThread &sb_thread, const char *class_name,
// Assignment operator
const lldb::SBThreadPlan &SBThreadPlan::operator=(const SBThreadPlan &rhs) {
- LLDB_RECORD_METHOD(const lldb::SBThreadPlan &,
- SBThreadPlan, operator=,(const lldb::SBThreadPlan &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_wp = rhs.m_opaque_wp;
@@ -99,42 +94,41 @@ const lldb::SBThreadPlan &SBThreadPlan::operator=(const SBThreadPlan &rhs) {
SBThreadPlan::~SBThreadPlan() = default;
bool SBThreadPlan::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadPlan, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBThreadPlan::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadPlan, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return static_cast<bool>(GetSP());
}
void SBThreadPlan::Clear() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBThreadPlan, Clear);
+ LLDB_INSTRUMENT_VA(this);
m_opaque_wp.reset();
}
lldb::StopReason SBThreadPlan::GetStopReason() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::StopReason, SBThreadPlan, GetStopReason);
+ LLDB_INSTRUMENT_VA(this);
return eStopReasonNone;
}
size_t SBThreadPlan::GetStopReasonDataCount() {
- LLDB_RECORD_METHOD_NO_ARGS(size_t, SBThreadPlan, GetStopReasonDataCount);
+ LLDB_INSTRUMENT_VA(this);
return 0;
}
uint64_t SBThreadPlan::GetStopReasonDataAtIndex(uint32_t idx) {
- LLDB_RECORD_METHOD(uint64_t, SBThreadPlan, GetStopReasonDataAtIndex,
- (uint32_t), idx);
+ LLDB_INSTRUMENT_VA(this, idx);
return 0;
}
SBThread SBThreadPlan::GetThread() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBThreadPlan, GetThread);
+ LLDB_INSTRUMENT_VA(this);
ThreadPlanSP thread_plan_sp(GetSP());
if (thread_plan_sp) {
@@ -144,8 +138,7 @@ SBThread SBThreadPlan::GetThread() const {
}
bool SBThreadPlan::GetDescription(lldb::SBStream &description) const {
- LLDB_RECORD_METHOD_CONST(bool, SBThreadPlan, GetDescription,
- (lldb::SBStream &), description);
+ LLDB_INSTRUMENT_VA(this, description);
ThreadPlanSP thread_plan_sp(GetSP());
if (thread_plan_sp) {
@@ -161,7 +154,7 @@ void SBThreadPlan::SetThreadPlan(const ThreadPlanSP &lldb_object_wp) {
}
void SBThreadPlan::SetPlanComplete(bool success) {
- LLDB_RECORD_METHOD(void, SBThreadPlan, SetPlanComplete, (bool), success);
+ LLDB_INSTRUMENT_VA(this, success);
ThreadPlanSP thread_plan_sp(GetSP());
if (thread_plan_sp)
@@ -169,7 +162,7 @@ void SBThreadPlan::SetPlanComplete(bool success) {
}
bool SBThreadPlan::IsPlanComplete() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, IsPlanComplete);
+ LLDB_INSTRUMENT_VA(this);
ThreadPlanSP thread_plan_sp(GetSP());
if (thread_plan_sp)
@@ -178,7 +171,7 @@ bool SBThreadPlan::IsPlanComplete() {
}
bool SBThreadPlan::IsPlanStale() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, IsPlanStale);
+ LLDB_INSTRUMENT_VA(this);
ThreadPlanSP thread_plan_sp(GetSP());
if (thread_plan_sp)
@@ -187,7 +180,7 @@ bool SBThreadPlan::IsPlanStale() {
}
bool SBThreadPlan::IsValid() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, IsValid);
+ LLDB_INSTRUMENT_VA(this);
ThreadPlanSP thread_plan_sp(GetSP());
if (thread_plan_sp)
@@ -196,7 +189,7 @@ bool SBThreadPlan::IsValid() {
}
bool SBThreadPlan::GetStopOthers() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, GetStopOthers);
+ LLDB_INSTRUMENT_VA(this);
ThreadPlanSP thread_plan_sp(GetSP());
if (thread_plan_sp)
@@ -205,7 +198,7 @@ bool SBThreadPlan::GetStopOthers() {
}
void SBThreadPlan::SetStopOthers(bool stop_others) {
- LLDB_RECORD_METHOD(void, SBThreadPlan, SetStopOthers, (bool), stop_others);
+ LLDB_INSTRUMENT_VA(this, stop_others);
ThreadPlanSP thread_plan_sp(GetSP());
if (thread_plan_sp)
@@ -221,9 +214,7 @@ void SBThreadPlan::SetStopOthers(bool stop_others) {
SBThreadPlan
SBThreadPlan::QueueThreadPlanForStepOverRange(SBAddress &sb_start_address,
lldb::addr_t size) {
- LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
- QueueThreadPlanForStepOverRange,
- (lldb::SBAddress &, lldb::addr_t), sb_start_address, size);
+ LLDB_INSTRUMENT_VA(this, sb_start_address, size);
SBError error;
return QueueThreadPlanForStepOverRange(sb_start_address, size, error);
@@ -231,10 +222,7 @@ SBThreadPlan::QueueThreadPlanForStepOverRange(SBAddress &sb_start_address,
SBThreadPlan SBThreadPlan::QueueThreadPlanForStepOverRange(
SBAddress &sb_start_address, lldb::addr_t size, SBError &error) {
- LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
- QueueThreadPlanForStepOverRange,
- (lldb::SBAddress &, lldb::addr_t, lldb::SBError &),
- sb_start_address, size, error);
+ LLDB_INSTRUMENT_VA(this, sb_start_address, size, error);
ThreadPlanSP thread_plan_sp(GetSP());
if (thread_plan_sp) {
@@ -265,9 +253,7 @@ SBThreadPlan SBThreadPlan::QueueThreadPlanForStepOverRange(
SBThreadPlan
SBThreadPlan::QueueThreadPlanForStepInRange(SBAddress &sb_start_address,
lldb::addr_t size) {
- LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
- QueueThreadPlanForStepInRange,
- (lldb::SBAddress &, lldb::addr_t), sb_start_address, size);
+ LLDB_INSTRUMENT_VA(this, sb_start_address, size);
SBError error;
return QueueThreadPlanForStepInRange(sb_start_address, size, error);
@@ -276,10 +262,7 @@ SBThreadPlan::QueueThreadPlanForStepInRange(SBAddress &sb_start_address,
SBThreadPlan
SBThreadPlan::QueueThreadPlanForStepInRange(SBAddress &sb_start_address,
lldb::addr_t size, SBError &error) {
- LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
- QueueThreadPlanForStepInRange,
- (lldb::SBAddress &, lldb::addr_t, lldb::SBError &),
- sb_start_address, size, error);
+ LLDB_INSTRUMENT_VA(this, sb_start_address, size, error);
ThreadPlanSP thread_plan_sp(GetSP());
if (thread_plan_sp) {
@@ -310,9 +293,7 @@ SBThreadPlan::QueueThreadPlanForStepInRange(SBAddress &sb_start_address,
SBThreadPlan
SBThreadPlan::QueueThreadPlanForStepOut(uint32_t frame_idx_to_step_to,
bool first_insn) {
- LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
- QueueThreadPlanForStepOut, (uint32_t, bool),
- frame_idx_to_step_to, first_insn);
+ LLDB_INSTRUMENT_VA(this, frame_idx_to_step_to, first_insn);
SBError error;
return QueueThreadPlanForStepOut(frame_idx_to_step_to, first_insn, error);
@@ -321,10 +302,7 @@ SBThreadPlan::QueueThreadPlanForStepOut(uint32_t frame_idx_to_step_to,
SBThreadPlan
SBThreadPlan::QueueThreadPlanForStepOut(uint32_t frame_idx_to_step_to,
bool first_insn, SBError &error) {
- LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
- QueueThreadPlanForStepOut,
- (uint32_t, bool, lldb::SBError &), frame_idx_to_step_to,
- first_insn, error);
+ LLDB_INSTRUMENT_VA(this, frame_idx_to_step_to, first_insn, error);
ThreadPlanSP thread_plan_sp(GetSP());
if (thread_plan_sp) {
@@ -350,9 +328,7 @@ SBThreadPlan::QueueThreadPlanForStepOut(uint32_t frame_idx_to_step_to,
SBThreadPlan
SBThreadPlan::QueueThreadPlanForRunToAddress(SBAddress sb_address) {
- LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
- QueueThreadPlanForRunToAddress, (lldb::SBAddress),
- sb_address);
+ LLDB_INSTRUMENT_VA(this, sb_address);
SBError error;
return QueueThreadPlanForRunToAddress(sb_address, error);
@@ -360,9 +336,7 @@ SBThreadPlan::QueueThreadPlanForRunToAddress(SBAddress sb_address) {
SBThreadPlan SBThreadPlan::QueueThreadPlanForRunToAddress(SBAddress sb_address,
SBError &error) {
- LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
- QueueThreadPlanForRunToAddress,
- (lldb::SBAddress, lldb::SBError &), sb_address, error);
+ LLDB_INSTRUMENT_VA(this, sb_address, error);
ThreadPlanSP thread_plan_sp(GetSP());
if (thread_plan_sp) {
@@ -387,9 +361,7 @@ SBThreadPlan SBThreadPlan::QueueThreadPlanForRunToAddress(SBAddress sb_address,
SBThreadPlan
SBThreadPlan::QueueThreadPlanForStepScripted(const char *script_class_name) {
- LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
- QueueThreadPlanForStepScripted, (const char *),
- script_class_name);
+ LLDB_INSTRUMENT_VA(this, script_class_name);
SBError error;
return QueueThreadPlanForStepScripted(script_class_name, error);
@@ -398,9 +370,7 @@ SBThreadPlan::QueueThreadPlanForStepScripted(const char *script_class_name) {
SBThreadPlan
SBThreadPlan::QueueThreadPlanForStepScripted(const char *script_class_name,
SBError &error) {
- LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
- QueueThreadPlanForStepScripted,
- (const char *, lldb::SBError &), script_class_name, error);
+ LLDB_INSTRUMENT_VA(this, script_class_name, error);
ThreadPlanSP thread_plan_sp(GetSP());
if (thread_plan_sp) {
@@ -424,10 +394,7 @@ SBThreadPlan
SBThreadPlan::QueueThreadPlanForStepScripted(const char *script_class_name,
lldb::SBStructuredData &args_data,
SBError &error) {
- LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
- QueueThreadPlanForStepScripted,
- (const char *, lldb::SBStructuredData &, lldb::SBError &),
- script_class_name, args_data, error);
+ LLDB_INSTRUMENT_VA(this, script_class_name, args_data, error);
ThreadPlanSP thread_plan_sp(GetSP());
if (thread_plan_sp) {
diff --git a/lldb/source/API/SBTrace.cpp b/lldb/source/API/SBTrace.cpp
index 4e13e774e366..64a675e2e16c 100644
--- a/lldb/source/API/SBTrace.cpp
+++ b/lldb/source/API/SBTrace.cpp
@@ -6,8 +6,8 @@
//
//===----------------------------------------------------------------------===//
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/Target/Process.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/API/SBStructuredData.h"
#include "lldb/API/SBThread.h"
@@ -20,20 +20,19 @@
using namespace lldb;
using namespace lldb_private;
-SBTrace::SBTrace() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTrace); }
+SBTrace::SBTrace() { LLDB_INSTRUMENT_VA(this); }
SBTrace::SBTrace(const lldb::TraceSP &trace_sp) : m_opaque_sp(trace_sp) {
- LLDB_RECORD_CONSTRUCTOR(SBTrace, (const lldb::TraceSP &), trace_sp);
+ LLDB_INSTRUMENT_VA(this, trace_sp);
}
const char *SBTrace::GetStartConfigurationHelp() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTrace, GetStartConfigurationHelp);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp ? m_opaque_sp->GetStartConfigurationHelp() : nullptr;
}
SBError SBTrace::Start(const SBStructuredData &configuration) {
- LLDB_RECORD_METHOD(SBError, SBTrace, Start, (const SBStructuredData &),
- configuration);
+ LLDB_INSTRUMENT_VA(this, configuration);
SBError error;
if (!m_opaque_sp)
error.SetErrorString("error: invalid trace");
@@ -45,9 +44,7 @@ SBError SBTrace::Start(const SBStructuredData &configuration) {
SBError SBTrace::Start(const SBThread &thread,
const SBStructuredData &configuration) {
- LLDB_RECORD_METHOD(SBError, SBTrace, Start,
- (const SBThread &, const SBStructuredData &), thread,
- configuration);
+ LLDB_INSTRUMENT_VA(this, thread, configuration);
SBError error;
if (!m_opaque_sp)
@@ -63,7 +60,7 @@ SBError SBTrace::Start(const SBThread &thread,
}
SBError SBTrace::Stop() {
- LLDB_RECORD_METHOD_NO_ARGS(SBError, SBTrace, Stop);
+ LLDB_INSTRUMENT_VA(this);
SBError error;
if (!m_opaque_sp)
error.SetErrorString("error: invalid trace");
@@ -73,7 +70,7 @@ SBError SBTrace::Stop() {
}
SBError SBTrace::Stop(const SBThread &thread) {
- LLDB_RECORD_METHOD(SBError, SBTrace, Stop, (const SBThread &), thread);
+ LLDB_INSTRUMENT_VA(this, thread);
SBError error;
if (!m_opaque_sp)
error.SetErrorString("error: invalid trace");
@@ -83,11 +80,11 @@ SBError SBTrace::Stop(const SBThread &thread) {
}
bool SBTrace::IsValid() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBTrace, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBTrace::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTrace, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return (bool)m_opaque_sp;
}
diff --git a/lldb/source/API/SBType.cpp b/lldb/source/API/SBType.cpp
index bd759c8f6bf9..da9202bf9386 100644
--- a/lldb/source/API/SBType.cpp
+++ b/lldb/source/API/SBType.cpp
@@ -7,7 +7,6 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBType.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBDefines.h"
#include "lldb/API/SBModule.h"
#include "lldb/API/SBStream.h"
@@ -17,6 +16,7 @@
#include "lldb/Symbol/Type.h"
#include "lldb/Symbol/TypeSystem.h"
#include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/Stream.h"
#include "llvm/ADT/APSInt.h"
@@ -26,7 +26,7 @@
using namespace lldb;
using namespace lldb_private;
-SBType::SBType() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBType); }
+SBType::SBType() { LLDB_INSTRUMENT_VA(this); }
SBType::SBType(const CompilerType &type)
: m_opaque_sp(new TypeImpl(
@@ -39,7 +39,7 @@ SBType::SBType(const lldb::TypeImplSP &type_impl_sp)
: m_opaque_sp(type_impl_sp) {}
SBType::SBType(const SBType &rhs) {
- LLDB_RECORD_CONSTRUCTOR(SBType, (const lldb::SBType &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
@@ -51,7 +51,7 @@ SBType::SBType(const SBType &rhs) {
//{}
//
bool SBType::operator==(SBType &rhs) {
- LLDB_RECORD_METHOD(bool, SBType, operator==,(lldb::SBType &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (!IsValid())
return !rhs.IsValid();
@@ -63,7 +63,7 @@ bool SBType::operator==(SBType &rhs) {
}
bool SBType::operator!=(SBType &rhs) {
- LLDB_RECORD_METHOD(bool, SBType, operator!=,(lldb::SBType &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (!IsValid())
return rhs.IsValid();
@@ -81,8 +81,7 @@ void SBType::SetSP(const lldb::TypeImplSP &type_impl_sp) {
}
SBType &SBType::operator=(const SBType &rhs) {
- LLDB_RECORD_METHOD(lldb::SBType &, SBType, operator=,(const lldb::SBType &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
@@ -107,11 +106,11 @@ const TypeImpl &SBType::ref() const {
}
bool SBType::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBType, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBType::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBType, operator bool);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp.get() == nullptr)
return false;
@@ -120,7 +119,7 @@ SBType::operator bool() const {
}
uint64_t SBType::GetByteSize() {
- LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBType, GetByteSize);
+ LLDB_INSTRUMENT_VA(this);
if (IsValid())
if (llvm::Optional<uint64_t> size =
@@ -130,7 +129,7 @@ uint64_t SBType::GetByteSize() {
}
bool SBType::IsPointerType() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsPointerType);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return false;
@@ -138,7 +137,7 @@ bool SBType::IsPointerType() {
}
bool SBType::IsArrayType() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsArrayType);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return false;
@@ -147,7 +146,7 @@ bool SBType::IsArrayType() {
}
bool SBType::IsVectorType() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsVectorType);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return false;
@@ -155,7 +154,7 @@ bool SBType::IsVectorType() {
}
bool SBType::IsReferenceType() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsReferenceType);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return false;
@@ -163,7 +162,7 @@ bool SBType::IsReferenceType() {
}
SBType SBType::GetPointerType() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetPointerType);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return SBType();
@@ -172,7 +171,7 @@ SBType SBType::GetPointerType() {
}
SBType SBType::GetPointeeType() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetPointeeType);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return SBType();
@@ -180,7 +179,7 @@ SBType SBType::GetPointeeType() {
}
SBType SBType::GetReferenceType() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetReferenceType);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return SBType();
@@ -188,7 +187,7 @@ SBType SBType::GetReferenceType() {
}
SBType SBType::GetTypedefedType() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetTypedefedType);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return SBType();
@@ -196,7 +195,7 @@ SBType SBType::GetTypedefedType() {
}
SBType SBType::GetDereferencedType() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetDereferencedType);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return SBType();
@@ -204,7 +203,7 @@ SBType SBType::GetDereferencedType() {
}
SBType SBType::GetArrayElementType() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetArrayElementType);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return SBType();
@@ -213,7 +212,7 @@ SBType SBType::GetArrayElementType() {
}
SBType SBType::GetArrayType(uint64_t size) {
- LLDB_RECORD_METHOD(lldb::SBType, SBType, GetArrayType, (uint64_t), size);
+ LLDB_INSTRUMENT_VA(this, size);
if (!IsValid())
return SBType();
@@ -222,7 +221,7 @@ SBType SBType::GetArrayType(uint64_t size) {
}
SBType SBType::GetVectorElementType() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetVectorElementType);
+ LLDB_INSTRUMENT_VA(this);
SBType type_sb;
if (IsValid()) {
@@ -235,7 +234,7 @@ SBType SBType::GetVectorElementType() {
}
bool SBType::IsFunctionType() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsFunctionType);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return false;
@@ -243,7 +242,7 @@ bool SBType::IsFunctionType() {
}
bool SBType::IsPolymorphicClass() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsPolymorphicClass);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return false;
@@ -251,7 +250,7 @@ bool SBType::IsPolymorphicClass() {
}
bool SBType::IsTypedefType() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsTypedefType);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return false;
@@ -259,7 +258,7 @@ bool SBType::IsTypedefType() {
}
bool SBType::IsAnonymousType() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsAnonymousType);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return false;
@@ -267,7 +266,7 @@ bool SBType::IsAnonymousType() {
}
bool SBType::IsScopedEnumerationType() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsScopedEnumerationType);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return false;
@@ -275,7 +274,7 @@ bool SBType::IsScopedEnumerationType() {
}
lldb::SBType SBType::GetFunctionReturnType() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetFunctionReturnType);
+ LLDB_INSTRUMENT_VA(this);
if (IsValid()) {
CompilerType return_type(
@@ -287,8 +286,7 @@ lldb::SBType SBType::GetFunctionReturnType() {
}
lldb::SBTypeList SBType::GetFunctionArgumentTypes() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeList, SBType,
- GetFunctionArgumentTypes);
+ LLDB_INSTRUMENT_VA(this);
SBTypeList sb_type_list;
if (IsValid()) {
@@ -302,7 +300,7 @@ lldb::SBTypeList SBType::GetFunctionArgumentTypes() {
}
uint32_t SBType::GetNumberOfMemberFunctions() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfMemberFunctions);
+ LLDB_INSTRUMENT_VA(this);
if (IsValid()) {
return m_opaque_sp->GetCompilerType(true).GetNumMemberFunctions();
@@ -311,8 +309,7 @@ uint32_t SBType::GetNumberOfMemberFunctions() {
}
lldb::SBTypeMemberFunction SBType::GetMemberFunctionAtIndex(uint32_t idx) {
- LLDB_RECORD_METHOD(lldb::SBTypeMemberFunction, SBType,
- GetMemberFunctionAtIndex, (uint32_t), idx);
+ LLDB_INSTRUMENT_VA(this, idx);
SBTypeMemberFunction sb_func_type;
if (IsValid())
@@ -322,7 +319,7 @@ lldb::SBTypeMemberFunction SBType::GetMemberFunctionAtIndex(uint32_t idx) {
}
lldb::SBType SBType::GetUnqualifiedType() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetUnqualifiedType);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return SBType();
@@ -330,7 +327,7 @@ lldb::SBType SBType::GetUnqualifiedType() {
}
lldb::SBType SBType::GetCanonicalType() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetCanonicalType);
+ LLDB_INSTRUMENT_VA(this);
if (IsValid())
return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetCanonicalType())));
@@ -338,7 +335,7 @@ lldb::SBType SBType::GetCanonicalType() {
}
SBType SBType::GetEnumerationIntegerType() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetEnumerationIntegerType);
+ LLDB_INSTRUMENT_VA(this);
if (IsValid()) {
return SBType(
@@ -348,7 +345,7 @@ SBType SBType::GetEnumerationIntegerType() {
}
lldb::BasicType SBType::GetBasicType() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::BasicType, SBType, GetBasicType);
+ LLDB_INSTRUMENT_VA(this);
if (IsValid())
return m_opaque_sp->GetCompilerType(false).GetBasicTypeEnumeration();
@@ -356,8 +353,7 @@ lldb::BasicType SBType::GetBasicType() {
}
SBType SBType::GetBasicType(lldb::BasicType basic_type) {
- LLDB_RECORD_METHOD(lldb::SBType, SBType, GetBasicType, (lldb::BasicType),
- basic_type);
+ LLDB_INSTRUMENT_VA(this, basic_type);
if (IsValid() && m_opaque_sp->IsValid())
return SBType(
@@ -366,7 +362,7 @@ SBType SBType::GetBasicType(lldb::BasicType basic_type) {
}
uint32_t SBType::GetNumberOfDirectBaseClasses() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfDirectBaseClasses);
+ LLDB_INSTRUMENT_VA(this);
if (IsValid())
return m_opaque_sp->GetCompilerType(true).GetNumDirectBaseClasses();
@@ -374,7 +370,7 @@ uint32_t SBType::GetNumberOfDirectBaseClasses() {
}
uint32_t SBType::GetNumberOfVirtualBaseClasses() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfVirtualBaseClasses);
+ LLDB_INSTRUMENT_VA(this);
if (IsValid())
return m_opaque_sp->GetCompilerType(true).GetNumVirtualBaseClasses();
@@ -382,7 +378,7 @@ uint32_t SBType::GetNumberOfVirtualBaseClasses() {
}
uint32_t SBType::GetNumberOfFields() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfFields);
+ LLDB_INSTRUMENT_VA(this);
if (IsValid())
return m_opaque_sp->GetCompilerType(true).GetNumFields();
@@ -391,9 +387,7 @@ uint32_t SBType::GetNumberOfFields() {
bool SBType::GetDescription(SBStream &description,
lldb::DescriptionLevel description_level) {
- LLDB_RECORD_METHOD(bool, SBType, GetDescription,
- (lldb::SBStream &, lldb::DescriptionLevel), description,
- description_level);
+ LLDB_INSTRUMENT_VA(this, description, description_level);
Stream &strm = description.ref();
@@ -406,8 +400,7 @@ bool SBType::GetDescription(SBStream &description,
}
SBTypeMember SBType::GetDirectBaseClassAtIndex(uint32_t idx) {
- LLDB_RECORD_METHOD(lldb::SBTypeMember, SBType, GetDirectBaseClassAtIndex,
- (uint32_t), idx);
+ LLDB_INSTRUMENT_VA(this, idx);
SBTypeMember sb_type_member;
if (IsValid()) {
@@ -423,8 +416,7 @@ SBTypeMember SBType::GetDirectBaseClassAtIndex(uint32_t idx) {
}
SBTypeMember SBType::GetVirtualBaseClassAtIndex(uint32_t idx) {
- LLDB_RECORD_METHOD(lldb::SBTypeMember, SBType, GetVirtualBaseClassAtIndex,
- (uint32_t), idx);
+ LLDB_INSTRUMENT_VA(this, idx);
SBTypeMember sb_type_member;
if (IsValid()) {
@@ -440,8 +432,7 @@ SBTypeMember SBType::GetVirtualBaseClassAtIndex(uint32_t idx) {
}
SBTypeEnumMemberList SBType::GetEnumMembers() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeEnumMemberList, SBType,
- GetEnumMembers);
+ LLDB_INSTRUMENT_VA(this);
SBTypeEnumMemberList sb_enum_member_list;
if (IsValid()) {
@@ -463,8 +454,7 @@ SBTypeEnumMemberList SBType::GetEnumMembers() {
}
SBTypeMember SBType::GetFieldAtIndex(uint32_t idx) {
- LLDB_RECORD_METHOD(lldb::SBTypeMember, SBType, GetFieldAtIndex, (uint32_t),
- idx);
+ LLDB_INSTRUMENT_VA(this, idx);
SBTypeMember sb_type_member;
if (IsValid()) {
@@ -490,7 +480,7 @@ SBTypeMember SBType::GetFieldAtIndex(uint32_t idx) {
}
bool SBType::IsTypeComplete() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsTypeComplete);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return false;
@@ -498,7 +488,7 @@ bool SBType::IsTypeComplete() {
}
uint32_t SBType::GetTypeFlags() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetTypeFlags);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return 0;
@@ -506,7 +496,7 @@ uint32_t SBType::GetTypeFlags() {
}
lldb::SBModule SBType::GetModule() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBModule, SBType, GetModule);
+ LLDB_INSTRUMENT_VA(this);
lldb::SBModule sb_module;
if (!IsValid())
@@ -517,7 +507,7 @@ lldb::SBModule SBType::GetModule() {
}
const char *SBType::GetName() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBType, GetName);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return "";
@@ -525,7 +515,7 @@ const char *SBType::GetName() {
}
const char *SBType::GetDisplayTypeName() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBType, GetDisplayTypeName);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return "";
@@ -533,7 +523,7 @@ const char *SBType::GetDisplayTypeName() {
}
lldb::TypeClass SBType::GetTypeClass() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::TypeClass, SBType, GetTypeClass);
+ LLDB_INSTRUMENT_VA(this);
if (IsValid())
return m_opaque_sp->GetCompilerType(true).GetTypeClass();
@@ -541,7 +531,7 @@ lldb::TypeClass SBType::GetTypeClass() {
}
uint32_t SBType::GetNumberOfTemplateArguments() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfTemplateArguments);
+ LLDB_INSTRUMENT_VA(this);
if (IsValid())
return m_opaque_sp->GetCompilerType(false).GetNumTemplateArguments();
@@ -549,8 +539,7 @@ uint32_t SBType::GetNumberOfTemplateArguments() {
}
lldb::SBType SBType::GetTemplateArgumentType(uint32_t idx) {
- LLDB_RECORD_METHOD(lldb::SBType, SBType, GetTemplateArgumentType, (uint32_t),
- idx);
+ LLDB_INSTRUMENT_VA(this, idx);
if (!IsValid())
return SBType();
@@ -574,8 +563,7 @@ lldb::SBType SBType::GetTemplateArgumentType(uint32_t idx) {
}
lldb::TemplateArgumentKind SBType::GetTemplateArgumentKind(uint32_t idx) {
- LLDB_RECORD_METHOD(lldb::TemplateArgumentKind, SBType,
- GetTemplateArgumentKind, (uint32_t), idx);
+ LLDB_INSTRUMENT_VA(this, idx);
if (IsValid())
return m_opaque_sp->GetCompilerType(false).GetTemplateArgumentKind(idx);
@@ -583,12 +571,12 @@ lldb::TemplateArgumentKind SBType::GetTemplateArgumentKind(uint32_t idx) {
}
SBTypeList::SBTypeList() : m_opaque_up(new TypeListImpl()) {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeList);
+ LLDB_INSTRUMENT_VA(this);
}
SBTypeList::SBTypeList(const SBTypeList &rhs)
: m_opaque_up(new TypeListImpl()) {
- LLDB_RECORD_CONSTRUCTOR(SBTypeList, (const lldb::SBTypeList &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
for (uint32_t i = 0, rhs_size = const_cast<SBTypeList &>(rhs).GetSize();
i < rhs_size; i++)
@@ -596,18 +584,17 @@ SBTypeList::SBTypeList(const SBTypeList &rhs)
}
bool SBTypeList::IsValid() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeList, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBTypeList::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeList, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return (m_opaque_up != nullptr);
}
SBTypeList &SBTypeList::operator=(const SBTypeList &rhs) {
- LLDB_RECORD_METHOD(lldb::SBTypeList &,
- SBTypeList, operator=,(const lldb::SBTypeList &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
m_opaque_up = std::make_unique<TypeListImpl>();
@@ -619,15 +606,14 @@ SBTypeList &SBTypeList::operator=(const SBTypeList &rhs) {
}
void SBTypeList::Append(SBType type) {
- LLDB_RECORD_METHOD(void, SBTypeList, Append, (lldb::SBType), type);
+ LLDB_INSTRUMENT_VA(this, type);
if (type.IsValid())
m_opaque_up->Append(type.m_opaque_sp);
}
SBType SBTypeList::GetTypeAtIndex(uint32_t index) {
- LLDB_RECORD_METHOD(lldb::SBType, SBTypeList, GetTypeAtIndex, (uint32_t),
- index);
+ LLDB_INSTRUMENT_VA(this, index);
if (m_opaque_up)
return SBType(m_opaque_up->GetTypeAtIndex(index));
@@ -635,19 +621,19 @@ SBType SBTypeList::GetTypeAtIndex(uint32_t index) {
}
uint32_t SBTypeList::GetSize() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeList, GetSize);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetSize();
}
SBTypeList::~SBTypeList() = default;
-SBTypeMember::SBTypeMember() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeMember); }
+SBTypeMember::SBTypeMember() { LLDB_INSTRUMENT_VA(this); }
SBTypeMember::~SBTypeMember() = default;
SBTypeMember::SBTypeMember(const SBTypeMember &rhs) {
- LLDB_RECORD_CONSTRUCTOR(SBTypeMember, (const lldb::SBTypeMember &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
if (rhs.IsValid())
@@ -656,8 +642,7 @@ SBTypeMember::SBTypeMember(const SBTypeMember &rhs) {
}
lldb::SBTypeMember &SBTypeMember::operator=(const lldb::SBTypeMember &rhs) {
- LLDB_RECORD_METHOD(lldb::SBTypeMember &,
- SBTypeMember, operator=,(const lldb::SBTypeMember &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
if (rhs.IsValid())
@@ -667,17 +652,17 @@ lldb::SBTypeMember &SBTypeMember::operator=(const lldb::SBTypeMember &rhs) {
}
bool SBTypeMember::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMember, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBTypeMember::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMember, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up.get();
}
const char *SBTypeMember::GetName() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMember, GetName);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_up)
return m_opaque_up->GetName().GetCString();
@@ -685,7 +670,7 @@ const char *SBTypeMember::GetName() {
}
SBType SBTypeMember::GetType() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeMember, GetType);
+ LLDB_INSTRUMENT_VA(this);
SBType sb_type;
if (m_opaque_up) {
@@ -695,7 +680,7 @@ SBType SBTypeMember::GetType() {
}
uint64_t SBTypeMember::GetOffsetInBytes() {
- LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBTypeMember, GetOffsetInBytes);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_up)
return m_opaque_up->GetBitOffset() / 8u;
@@ -703,7 +688,7 @@ uint64_t SBTypeMember::GetOffsetInBytes() {
}
uint64_t SBTypeMember::GetOffsetInBits() {
- LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBTypeMember, GetOffsetInBits);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_up)
return m_opaque_up->GetBitOffset();
@@ -711,7 +696,7 @@ uint64_t SBTypeMember::GetOffsetInBits() {
}
bool SBTypeMember::IsBitfield() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeMember, IsBitfield);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_up)
return m_opaque_up->GetIsBitfield();
@@ -719,7 +704,7 @@ bool SBTypeMember::IsBitfield() {
}
uint32_t SBTypeMember::GetBitfieldSizeInBits() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeMember, GetBitfieldSizeInBits);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_up)
return m_opaque_up->GetBitfieldBitSize();
@@ -728,9 +713,7 @@ uint32_t SBTypeMember::GetBitfieldSizeInBits() {
bool SBTypeMember::GetDescription(lldb::SBStream &description,
lldb::DescriptionLevel description_level) {
- LLDB_RECORD_METHOD(bool, SBTypeMember, GetDescription,
- (lldb::SBStream &, lldb::DescriptionLevel), description,
- description_level);
+ LLDB_INSTRUMENT_VA(this, description, description_level);
Stream &strm = description.ref();
@@ -771,24 +754,18 @@ TypeMemberImpl &SBTypeMember::ref() {
const TypeMemberImpl &SBTypeMember::ref() const { return *m_opaque_up; }
-SBTypeMemberFunction::SBTypeMemberFunction() {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeMemberFunction);
-}
+SBTypeMemberFunction::SBTypeMemberFunction() { LLDB_INSTRUMENT_VA(this); }
SBTypeMemberFunction::~SBTypeMemberFunction() = default;
SBTypeMemberFunction::SBTypeMemberFunction(const SBTypeMemberFunction &rhs)
: m_opaque_sp(rhs.m_opaque_sp) {
- LLDB_RECORD_CONSTRUCTOR(SBTypeMemberFunction,
- (const lldb::SBTypeMemberFunction &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
}
lldb::SBTypeMemberFunction &SBTypeMemberFunction::
operator=(const lldb::SBTypeMemberFunction &rhs) {
- LLDB_RECORD_METHOD(
- lldb::SBTypeMemberFunction &,
- SBTypeMemberFunction, operator=,(const lldb::SBTypeMemberFunction &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_sp = rhs.m_opaque_sp;
@@ -796,17 +773,17 @@ operator=(const lldb::SBTypeMemberFunction &rhs) {
}
bool SBTypeMemberFunction::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMemberFunction, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBTypeMemberFunction::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMemberFunction, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp.get();
}
const char *SBTypeMemberFunction::GetName() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMemberFunction, GetName);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp)
return m_opaque_sp->GetName().GetCString();
@@ -814,8 +791,7 @@ const char *SBTypeMemberFunction::GetName() {
}
const char *SBTypeMemberFunction::GetDemangledName() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMemberFunction,
- GetDemangledName);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp) {
ConstString mangled_str = m_opaque_sp->GetMangledName();
@@ -828,8 +804,7 @@ const char *SBTypeMemberFunction::GetDemangledName() {
}
const char *SBTypeMemberFunction::GetMangledName() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMemberFunction,
- GetMangledName);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp)
return m_opaque_sp->GetMangledName().GetCString();
@@ -837,7 +812,7 @@ const char *SBTypeMemberFunction::GetMangledName() {
}
SBType SBTypeMemberFunction::GetType() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeMemberFunction, GetType);
+ LLDB_INSTRUMENT_VA(this);
SBType sb_type;
if (m_opaque_sp) {
@@ -847,7 +822,7 @@ SBType SBTypeMemberFunction::GetType() {
}
lldb::SBType SBTypeMemberFunction::GetReturnType() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeMemberFunction, GetReturnType);
+ LLDB_INSTRUMENT_VA(this);
SBType sb_type;
if (m_opaque_sp) {
@@ -857,8 +832,7 @@ lldb::SBType SBTypeMemberFunction::GetReturnType() {
}
uint32_t SBTypeMemberFunction::GetNumberOfArguments() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeMemberFunction,
- GetNumberOfArguments);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp)
return m_opaque_sp->GetNumArguments();
@@ -866,8 +840,7 @@ uint32_t SBTypeMemberFunction::GetNumberOfArguments() {
}
lldb::SBType SBTypeMemberFunction::GetArgumentTypeAtIndex(uint32_t i) {
- LLDB_RECORD_METHOD(lldb::SBType, SBTypeMemberFunction, GetArgumentTypeAtIndex,
- (uint32_t), i);
+ LLDB_INSTRUMENT_VA(this, i);
SBType sb_type;
if (m_opaque_sp) {
@@ -878,8 +851,7 @@ lldb::SBType SBTypeMemberFunction::GetArgumentTypeAtIndex(uint32_t i) {
}
lldb::MemberFunctionKind SBTypeMemberFunction::GetKind() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::MemberFunctionKind, SBTypeMemberFunction,
- GetKind);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp)
return m_opaque_sp->GetKind();
@@ -888,9 +860,7 @@ lldb::MemberFunctionKind SBTypeMemberFunction::GetKind() {
bool SBTypeMemberFunction::GetDescription(
lldb::SBStream &description, lldb::DescriptionLevel description_level) {
- LLDB_RECORD_METHOD(bool, SBTypeMemberFunction, GetDescription,
- (lldb::SBStream &, lldb::DescriptionLevel), description,
- description_level);
+ LLDB_INSTRUMENT_VA(this, description, description_level);
Stream &strm = description.ref();
diff --git a/lldb/source/API/SBTypeCategory.cpp b/lldb/source/API/SBTypeCategory.cpp
index 17aca3267e67..7d929fe49795 100644
--- a/lldb/source/API/SBTypeCategory.cpp
+++ b/lldb/source/API/SBTypeCategory.cpp
@@ -7,7 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBTypeCategory.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBTypeFilter.h"
@@ -26,9 +26,7 @@ using namespace lldb_private;
typedef std::pair<lldb::TypeCategoryImplSP, user_id_t> ImplType;
-SBTypeCategory::SBTypeCategory() {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeCategory);
-}
+SBTypeCategory::SBTypeCategory() { LLDB_INSTRUMENT_VA(this); }
SBTypeCategory::SBTypeCategory(const char *name) {
DataVisualization::Categories::GetCategory(ConstString(name), m_opaque_sp);
@@ -36,23 +34,23 @@ SBTypeCategory::SBTypeCategory(const char *name) {
SBTypeCategory::SBTypeCategory(const lldb::SBTypeCategory &rhs)
: m_opaque_sp(rhs.m_opaque_sp) {
- LLDB_RECORD_CONSTRUCTOR(SBTypeCategory, (const lldb::SBTypeCategory &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
}
SBTypeCategory::~SBTypeCategory() = default;
bool SBTypeCategory::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeCategory, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBTypeCategory::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeCategory, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return (m_opaque_sp.get() != nullptr);
}
bool SBTypeCategory::GetEnabled() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeCategory, GetEnabled);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return false;
@@ -60,7 +58,7 @@ bool SBTypeCategory::GetEnabled() {
}
void SBTypeCategory::SetEnabled(bool enabled) {
- LLDB_RECORD_METHOD(void, SBTypeCategory, SetEnabled, (bool), enabled);
+ LLDB_INSTRUMENT_VA(this, enabled);
if (!IsValid())
return;
@@ -71,7 +69,7 @@ void SBTypeCategory::SetEnabled(bool enabled) {
}
const char *SBTypeCategory::GetName() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeCategory, GetName);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return nullptr;
@@ -79,8 +77,7 @@ const char *SBTypeCategory::GetName() {
}
lldb::LanguageType SBTypeCategory::GetLanguageAtIndex(uint32_t idx) {
- LLDB_RECORD_METHOD(lldb::LanguageType, SBTypeCategory, GetLanguageAtIndex,
- (uint32_t), idx);
+ LLDB_INSTRUMENT_VA(this, idx);
if (IsValid())
return m_opaque_sp->GetLanguageAtIndex(idx);
@@ -88,7 +85,7 @@ lldb::LanguageType SBTypeCategory::GetLanguageAtIndex(uint32_t idx) {
}
uint32_t SBTypeCategory::GetNumLanguages() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumLanguages);
+ LLDB_INSTRUMENT_VA(this);
if (IsValid())
return m_opaque_sp->GetNumLanguages();
@@ -96,15 +93,14 @@ uint32_t SBTypeCategory::GetNumLanguages() {
}
void SBTypeCategory::AddLanguage(lldb::LanguageType language) {
- LLDB_RECORD_METHOD(void, SBTypeCategory, AddLanguage, (lldb::LanguageType),
- language);
+ LLDB_INSTRUMENT_VA(this, language);
if (IsValid())
m_opaque_sp->AddLanguage(language);
}
uint32_t SBTypeCategory::GetNumFormats() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumFormats);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return 0;
@@ -114,7 +110,7 @@ uint32_t SBTypeCategory::GetNumFormats() {
}
uint32_t SBTypeCategory::GetNumSummaries() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumSummaries);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return 0;
@@ -123,7 +119,7 @@ uint32_t SBTypeCategory::GetNumSummaries() {
}
uint32_t SBTypeCategory::GetNumFilters() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumFilters);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return 0;
@@ -132,7 +128,7 @@ uint32_t SBTypeCategory::GetNumFilters() {
}
uint32_t SBTypeCategory::GetNumSynthetics() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumSynthetics);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return 0;
@@ -142,8 +138,7 @@ uint32_t SBTypeCategory::GetNumSynthetics() {
lldb::SBTypeNameSpecifier
SBTypeCategory::GetTypeNameSpecifierForFilterAtIndex(uint32_t index) {
- LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
- GetTypeNameSpecifierForFilterAtIndex, (uint32_t), index);
+ LLDB_INSTRUMENT_VA(this, index);
if (!IsValid())
return SBTypeNameSpecifier();
@@ -153,8 +148,7 @@ SBTypeCategory::GetTypeNameSpecifierForFilterAtIndex(uint32_t index) {
lldb::SBTypeNameSpecifier
SBTypeCategory::GetTypeNameSpecifierForFormatAtIndex(uint32_t index) {
- LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
- GetTypeNameSpecifierForFormatAtIndex, (uint32_t), index);
+ LLDB_INSTRUMENT_VA(this, index);
if (!IsValid())
return SBTypeNameSpecifier();
@@ -164,8 +158,7 @@ SBTypeCategory::GetTypeNameSpecifierForFormatAtIndex(uint32_t index) {
lldb::SBTypeNameSpecifier
SBTypeCategory::GetTypeNameSpecifierForSummaryAtIndex(uint32_t index) {
- LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
- GetTypeNameSpecifierForSummaryAtIndex, (uint32_t), index);
+ LLDB_INSTRUMENT_VA(this, index);
if (!IsValid())
return SBTypeNameSpecifier();
@@ -175,9 +168,7 @@ SBTypeCategory::GetTypeNameSpecifierForSummaryAtIndex(uint32_t index) {
lldb::SBTypeNameSpecifier
SBTypeCategory::GetTypeNameSpecifierForSyntheticAtIndex(uint32_t index) {
- LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
- GetTypeNameSpecifierForSyntheticAtIndex, (uint32_t),
- index);
+ LLDB_INSTRUMENT_VA(this, index);
if (!IsValid())
return SBTypeNameSpecifier();
@@ -186,8 +177,7 @@ SBTypeCategory::GetTypeNameSpecifierForSyntheticAtIndex(uint32_t index) {
}
SBTypeFilter SBTypeCategory::GetFilterForType(SBTypeNameSpecifier spec) {
- LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterForType,
- (lldb::SBTypeNameSpecifier), spec);
+ LLDB_INSTRUMENT_VA(this, spec);
if (!IsValid())
return SBTypeFilter();
@@ -213,8 +203,7 @@ SBTypeFilter SBTypeCategory::GetFilterForType(SBTypeNameSpecifier spec) {
return lldb::SBTypeFilter(filter_sp);
}
SBTypeFormat SBTypeCategory::GetFormatForType(SBTypeNameSpecifier spec) {
- LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatForType,
- (lldb::SBTypeNameSpecifier), spec);
+ LLDB_INSTRUMENT_VA(this, spec);
if (!IsValid())
return SBTypeFormat();
@@ -238,8 +227,7 @@ SBTypeFormat SBTypeCategory::GetFormatForType(SBTypeNameSpecifier spec) {
}
SBTypeSummary SBTypeCategory::GetSummaryForType(SBTypeNameSpecifier spec) {
- LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryForType,
- (lldb::SBTypeNameSpecifier), spec);
+ LLDB_INSTRUMENT_VA(this, spec);
if (!IsValid())
return SBTypeSummary();
@@ -263,8 +251,7 @@ SBTypeSummary SBTypeCategory::GetSummaryForType(SBTypeNameSpecifier spec) {
}
SBTypeSynthetic SBTypeCategory::GetSyntheticForType(SBTypeNameSpecifier spec) {
- LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBTypeCategory, GetSyntheticForType,
- (lldb::SBTypeNameSpecifier), spec);
+ LLDB_INSTRUMENT_VA(this, spec);
if (!IsValid())
return SBTypeSynthetic();
@@ -291,8 +278,7 @@ SBTypeSynthetic SBTypeCategory::GetSyntheticForType(SBTypeNameSpecifier spec) {
}
SBTypeFilter SBTypeCategory::GetFilterAtIndex(uint32_t index) {
- LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterAtIndex,
- (uint32_t), index);
+ LLDB_INSTRUMENT_VA(this, index);
if (!IsValid())
return SBTypeFilter();
@@ -309,8 +295,7 @@ SBTypeFilter SBTypeCategory::GetFilterAtIndex(uint32_t index) {
}
SBTypeFormat SBTypeCategory::GetFormatAtIndex(uint32_t index) {
- LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatAtIndex,
- (uint32_t), index);
+ LLDB_INSTRUMENT_VA(this, index);
if (!IsValid())
return SBTypeFormat();
@@ -318,8 +303,7 @@ SBTypeFormat SBTypeCategory::GetFormatAtIndex(uint32_t index) {
}
SBTypeSummary SBTypeCategory::GetSummaryAtIndex(uint32_t index) {
- LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryAtIndex,
- (uint32_t), index);
+ LLDB_INSTRUMENT_VA(this, index);
if (!IsValid())
return SBTypeSummary();
@@ -327,8 +311,7 @@ SBTypeSummary SBTypeCategory::GetSummaryAtIndex(uint32_t index) {
}
SBTypeSynthetic SBTypeCategory::GetSyntheticAtIndex(uint32_t index) {
- LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBTypeCategory, GetSyntheticAtIndex,
- (uint32_t), index);
+ LLDB_INSTRUMENT_VA(this, index);
if (!IsValid())
return SBTypeSynthetic();
@@ -346,9 +329,7 @@ SBTypeSynthetic SBTypeCategory::GetSyntheticAtIndex(uint32_t index) {
bool SBTypeCategory::AddTypeFormat(SBTypeNameSpecifier type_name,
SBTypeFormat format) {
- LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeFormat,
- (lldb::SBTypeNameSpecifier, lldb::SBTypeFormat), type_name,
- format);
+ LLDB_INSTRUMENT_VA(this, type_name, format);
if (!IsValid())
return false;
@@ -370,8 +351,7 @@ bool SBTypeCategory::AddTypeFormat(SBTypeNameSpecifier type_name,
}
bool SBTypeCategory::DeleteTypeFormat(SBTypeNameSpecifier type_name) {
- LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeFormat,
- (lldb::SBTypeNameSpecifier), type_name);
+ LLDB_INSTRUMENT_VA(this, type_name);
if (!IsValid())
return false;
@@ -389,9 +369,7 @@ bool SBTypeCategory::DeleteTypeFormat(SBTypeNameSpecifier type_name) {
bool SBTypeCategory::AddTypeSummary(SBTypeNameSpecifier type_name,
SBTypeSummary summary) {
- LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeSummary,
- (lldb::SBTypeNameSpecifier, lldb::SBTypeSummary),
- type_name, summary);
+ LLDB_INSTRUMENT_VA(this, type_name, summary);
if (!IsValid())
return false;
@@ -447,8 +425,7 @@ bool SBTypeCategory::AddTypeSummary(SBTypeNameSpecifier type_name,
}
bool SBTypeCategory::DeleteTypeSummary(SBTypeNameSpecifier type_name) {
- LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeSummary,
- (lldb::SBTypeNameSpecifier), type_name);
+ LLDB_INSTRUMENT_VA(this, type_name);
if (!IsValid())
return false;
@@ -466,9 +443,7 @@ bool SBTypeCategory::DeleteTypeSummary(SBTypeNameSpecifier type_name) {
bool SBTypeCategory::AddTypeFilter(SBTypeNameSpecifier type_name,
SBTypeFilter filter) {
- LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeFilter,
- (lldb::SBTypeNameSpecifier, lldb::SBTypeFilter), type_name,
- filter);
+ LLDB_INSTRUMENT_VA(this, type_name, filter);
if (!IsValid())
return false;
@@ -490,8 +465,7 @@ bool SBTypeCategory::AddTypeFilter(SBTypeNameSpecifier type_name,
}
bool SBTypeCategory::DeleteTypeFilter(SBTypeNameSpecifier type_name) {
- LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeFilter,
- (lldb::SBTypeNameSpecifier), type_name);
+ LLDB_INSTRUMENT_VA(this, type_name);
if (!IsValid())
return false;
@@ -509,9 +483,7 @@ bool SBTypeCategory::DeleteTypeFilter(SBTypeNameSpecifier type_name) {
bool SBTypeCategory::AddTypeSynthetic(SBTypeNameSpecifier type_name,
SBTypeSynthetic synth) {
- LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeSynthetic,
- (lldb::SBTypeNameSpecifier, lldb::SBTypeSynthetic),
- type_name, synth);
+ LLDB_INSTRUMENT_VA(this, type_name, synth);
if (!IsValid())
return false;
@@ -567,8 +539,7 @@ bool SBTypeCategory::AddTypeSynthetic(SBTypeNameSpecifier type_name,
}
bool SBTypeCategory::DeleteTypeSynthetic(SBTypeNameSpecifier type_name) {
- LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeSynthetic,
- (lldb::SBTypeNameSpecifier), type_name);
+ LLDB_INSTRUMENT_VA(this, type_name);
if (!IsValid())
return false;
@@ -586,9 +557,7 @@ bool SBTypeCategory::DeleteTypeSynthetic(SBTypeNameSpecifier type_name) {
bool SBTypeCategory::GetDescription(lldb::SBStream &description,
lldb::DescriptionLevel description_level) {
- LLDB_RECORD_METHOD(bool, SBTypeCategory, GetDescription,
- (lldb::SBStream &, lldb::DescriptionLevel), description,
- description_level);
+ LLDB_INSTRUMENT_VA(this, description, description_level);
if (!IsValid())
return false;
@@ -598,9 +567,7 @@ bool SBTypeCategory::GetDescription(lldb::SBStream &description,
lldb::SBTypeCategory &SBTypeCategory::
operator=(const lldb::SBTypeCategory &rhs) {
- LLDB_RECORD_METHOD(lldb::SBTypeCategory &,
- SBTypeCategory, operator=,(const lldb::SBTypeCategory &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
@@ -609,8 +576,7 @@ operator=(const lldb::SBTypeCategory &rhs) {
}
bool SBTypeCategory::operator==(lldb::SBTypeCategory &rhs) {
- LLDB_RECORD_METHOD(bool, SBTypeCategory, operator==,(lldb::SBTypeCategory &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (!IsValid())
return !rhs.IsValid();
@@ -619,8 +585,7 @@ bool SBTypeCategory::operator==(lldb::SBTypeCategory &rhs) {
}
bool SBTypeCategory::operator!=(lldb::SBTypeCategory &rhs) {
- LLDB_RECORD_METHOD(bool, SBTypeCategory, operator!=,(lldb::SBTypeCategory &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (!IsValid())
return rhs.IsValid();
diff --git a/lldb/source/API/SBTypeEnumMember.cpp b/lldb/source/API/SBTypeEnumMember.cpp
index d5fc382a35e8..a3d99bd57e31 100644
--- a/lldb/source/API/SBTypeEnumMember.cpp
+++ b/lldb/source/API/SBTypeEnumMember.cpp
@@ -7,13 +7,13 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBTypeEnumMember.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/API/SBDefines.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBType.h"
#include "lldb/Symbol/CompilerType.h"
#include "lldb/Symbol/Type.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/Stream.h"
#include <memory>
@@ -21,9 +21,7 @@
using namespace lldb;
using namespace lldb_private;
-SBTypeEnumMember::SBTypeEnumMember() {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeEnumMember);
-}
+SBTypeEnumMember::SBTypeEnumMember() { LLDB_INSTRUMENT_VA(this); }
SBTypeEnumMember::~SBTypeEnumMember() = default;
@@ -32,16 +30,13 @@ SBTypeEnumMember::SBTypeEnumMember(
: m_opaque_sp(enum_member_sp) {}
SBTypeEnumMember::SBTypeEnumMember(const SBTypeEnumMember &rhs) {
- LLDB_RECORD_CONSTRUCTOR(SBTypeEnumMember, (const lldb::SBTypeEnumMember &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_sp = clone(rhs.m_opaque_sp);
}
SBTypeEnumMember &SBTypeEnumMember::operator=(const SBTypeEnumMember &rhs) {
- LLDB_RECORD_METHOD(
- SBTypeEnumMember &,
- SBTypeEnumMember, operator=,(const lldb::SBTypeEnumMember &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_sp = clone(rhs.m_opaque_sp);
@@ -49,17 +44,17 @@ SBTypeEnumMember &SBTypeEnumMember::operator=(const SBTypeEnumMember &rhs) {
}
bool SBTypeEnumMember::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMember, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBTypeEnumMember::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMember, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp.get();
}
const char *SBTypeEnumMember::GetName() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeEnumMember, GetName);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp.get())
return m_opaque_sp->GetName().GetCString();
@@ -67,7 +62,7 @@ const char *SBTypeEnumMember::GetName() {
}
int64_t SBTypeEnumMember::GetValueAsSigned() {
- LLDB_RECORD_METHOD_NO_ARGS(int64_t, SBTypeEnumMember, GetValueAsSigned);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp.get())
return m_opaque_sp->GetValueAsSigned();
@@ -75,7 +70,7 @@ int64_t SBTypeEnumMember::GetValueAsSigned() {
}
uint64_t SBTypeEnumMember::GetValueAsUnsigned() {
- LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBTypeEnumMember, GetValueAsUnsigned);
+ LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp.get())
return m_opaque_sp->GetValueAsUnsigned();
@@ -83,7 +78,7 @@ uint64_t SBTypeEnumMember::GetValueAsUnsigned() {
}
SBType SBTypeEnumMember::GetType() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeEnumMember, GetType);
+ LLDB_INSTRUMENT_VA(this);
SBType sb_type;
if (m_opaque_sp.get()) {
@@ -108,13 +103,12 @@ const TypeEnumMemberImpl &SBTypeEnumMember::ref() const {
SBTypeEnumMemberList::SBTypeEnumMemberList()
: m_opaque_up(new TypeEnumMemberListImpl()) {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeEnumMemberList);
+ LLDB_INSTRUMENT_VA(this);
}
SBTypeEnumMemberList::SBTypeEnumMemberList(const SBTypeEnumMemberList &rhs)
: m_opaque_up(new TypeEnumMemberListImpl()) {
- LLDB_RECORD_CONSTRUCTOR(SBTypeEnumMemberList,
- (const lldb::SBTypeEnumMemberList &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
for (uint32_t i = 0,
rhs_size = const_cast<SBTypeEnumMemberList &>(rhs).GetSize();
@@ -123,21 +117,18 @@ SBTypeEnumMemberList::SBTypeEnumMemberList(const SBTypeEnumMemberList &rhs)
}
bool SBTypeEnumMemberList::IsValid() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeEnumMemberList, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBTypeEnumMemberList::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMemberList, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return (m_opaque_up != nullptr);
}
SBTypeEnumMemberList &SBTypeEnumMemberList::
operator=(const SBTypeEnumMemberList &rhs) {
- LLDB_RECORD_METHOD(
- lldb::SBTypeEnumMemberList &,
- SBTypeEnumMemberList, operator=,(const lldb::SBTypeEnumMemberList &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
m_opaque_up = std::make_unique<TypeEnumMemberListImpl>();
@@ -151,8 +142,7 @@ operator=(const SBTypeEnumMemberList &rhs) {
}
void SBTypeEnumMemberList::Append(SBTypeEnumMember enum_member) {
- LLDB_RECORD_METHOD(void, SBTypeEnumMemberList, Append,
- (lldb::SBTypeEnumMember), enum_member);
+ LLDB_INSTRUMENT_VA(this, enum_member);
if (enum_member.IsValid())
m_opaque_up->Append(enum_member.m_opaque_sp);
@@ -160,8 +150,7 @@ void SBTypeEnumMemberList::Append(SBTypeEnumMember enum_member) {
SBTypeEnumMember
SBTypeEnumMemberList::GetTypeEnumMemberAtIndex(uint32_t index) {
- LLDB_RECORD_METHOD(lldb::SBTypeEnumMember, SBTypeEnumMemberList,
- GetTypeEnumMemberAtIndex, (uint32_t), index);
+ LLDB_INSTRUMENT_VA(this, index);
if (m_opaque_up)
return SBTypeEnumMember(m_opaque_up->GetTypeEnumMemberAtIndex(index));
@@ -169,7 +158,7 @@ SBTypeEnumMemberList::GetTypeEnumMemberAtIndex(uint32_t index) {
}
uint32_t SBTypeEnumMemberList::GetSize() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeEnumMemberList, GetSize);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetSize();
}
@@ -178,9 +167,7 @@ SBTypeEnumMemberList::~SBTypeEnumMemberList() = default;
bool SBTypeEnumMember::GetDescription(
lldb::SBStream &description, lldb::DescriptionLevel description_level) {
- LLDB_RECORD_METHOD(bool, SBTypeEnumMember, GetDescription,
- (lldb::SBStream &, lldb::DescriptionLevel), description,
- description_level);
+ LLDB_INSTRUMENT_VA(this, description, description_level);
Stream &strm = description.ref();
diff --git a/lldb/source/API/SBTypeFilter.cpp b/lldb/source/API/SBTypeFilter.cpp
index a36d93854098..94f222b254b2 100644
--- a/lldb/source/API/SBTypeFilter.cpp
+++ b/lldb/source/API/SBTypeFilter.cpp
@@ -7,7 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBTypeFilter.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/API/SBStream.h"
@@ -16,32 +16,32 @@
using namespace lldb;
using namespace lldb_private;
-SBTypeFilter::SBTypeFilter() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeFilter); }
+SBTypeFilter::SBTypeFilter() { LLDB_INSTRUMENT_VA(this); }
SBTypeFilter::SBTypeFilter(uint32_t options)
: m_opaque_sp(TypeFilterImplSP(new TypeFilterImpl(options))) {
- LLDB_RECORD_CONSTRUCTOR(SBTypeFilter, (uint32_t), options);
+ LLDB_INSTRUMENT_VA(this, options);
}
SBTypeFilter::SBTypeFilter(const lldb::SBTypeFilter &rhs)
: m_opaque_sp(rhs.m_opaque_sp) {
- LLDB_RECORD_CONSTRUCTOR(SBTypeFilter, (const lldb::SBTypeFilter &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
}
SBTypeFilter::~SBTypeFilter() = default;
bool SBTypeFilter::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFilter, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBTypeFilter::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFilter, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp.get() != nullptr;
}
uint32_t SBTypeFilter::GetOptions() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeFilter, GetOptions);
+ LLDB_INSTRUMENT_VA(this);
if (IsValid())
return m_opaque_sp->GetOptions();
@@ -49,7 +49,7 @@ uint32_t SBTypeFilter::GetOptions() {
}
void SBTypeFilter::SetOptions(uint32_t value) {
- LLDB_RECORD_METHOD(void, SBTypeFilter, SetOptions, (uint32_t), value);
+ LLDB_INSTRUMENT_VA(this, value);
if (CopyOnWrite_Impl())
m_opaque_sp->SetOptions(value);
@@ -57,9 +57,7 @@ void SBTypeFilter::SetOptions(uint32_t value) {
bool SBTypeFilter::GetDescription(lldb::SBStream &description,
lldb::DescriptionLevel description_level) {
- LLDB_RECORD_METHOD(bool, SBTypeFilter, GetDescription,
- (lldb::SBStream &, lldb::DescriptionLevel), description,
- description_level);
+ LLDB_INSTRUMENT_VA(this, description, description_level);
if (!IsValid())
return false;
@@ -70,15 +68,14 @@ bool SBTypeFilter::GetDescription(lldb::SBStream &description,
}
void SBTypeFilter::Clear() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBTypeFilter, Clear);
+ LLDB_INSTRUMENT_VA(this);
if (CopyOnWrite_Impl())
m_opaque_sp->Clear();
}
uint32_t SBTypeFilter::GetNumberOfExpressionPaths() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeFilter,
- GetNumberOfExpressionPaths);
+ LLDB_INSTRUMENT_VA(this);
if (IsValid())
return m_opaque_sp->GetCount();
@@ -86,8 +83,7 @@ uint32_t SBTypeFilter::GetNumberOfExpressionPaths() {
}
const char *SBTypeFilter::GetExpressionPathAtIndex(uint32_t i) {
- LLDB_RECORD_METHOD(const char *, SBTypeFilter, GetExpressionPathAtIndex,
- (uint32_t), i);
+ LLDB_INSTRUMENT_VA(this, i);
if (IsValid()) {
const char *item = m_opaque_sp->GetExpressionPathAtIndex(i);
@@ -99,8 +95,7 @@ const char *SBTypeFilter::GetExpressionPathAtIndex(uint32_t i) {
}
bool SBTypeFilter::ReplaceExpressionPathAtIndex(uint32_t i, const char *item) {
- LLDB_RECORD_METHOD(bool, SBTypeFilter, ReplaceExpressionPathAtIndex,
- (uint32_t, const char *), i, item);
+ LLDB_INSTRUMENT_VA(this, i, item);
if (CopyOnWrite_Impl())
return m_opaque_sp->SetExpressionPathAtIndex(i, item);
@@ -109,16 +104,14 @@ bool SBTypeFilter::ReplaceExpressionPathAtIndex(uint32_t i, const char *item) {
}
void SBTypeFilter::AppendExpressionPath(const char *item) {
- LLDB_RECORD_METHOD(void, SBTypeFilter, AppendExpressionPath, (const char *),
- item);
+ LLDB_INSTRUMENT_VA(this, item);
if (CopyOnWrite_Impl())
m_opaque_sp->AddExpressionPath(item);
}
lldb::SBTypeFilter &SBTypeFilter::operator=(const lldb::SBTypeFilter &rhs) {
- LLDB_RECORD_METHOD(lldb::SBTypeFilter &,
- SBTypeFilter, operator=,(const lldb::SBTypeFilter &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
@@ -127,8 +120,7 @@ lldb::SBTypeFilter &SBTypeFilter::operator=(const lldb::SBTypeFilter &rhs) {
}
bool SBTypeFilter::operator==(lldb::SBTypeFilter &rhs) {
- LLDB_RECORD_METHOD(bool, SBTypeFilter, operator==,(lldb::SBTypeFilter &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (!IsValid())
return !rhs.IsValid();
@@ -137,8 +129,7 @@ bool SBTypeFilter::operator==(lldb::SBTypeFilter &rhs) {
}
bool SBTypeFilter::IsEqualTo(lldb::SBTypeFilter &rhs) {
- LLDB_RECORD_METHOD(bool, SBTypeFilter, IsEqualTo, (lldb::SBTypeFilter &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (!IsValid())
return !rhs.IsValid();
@@ -155,8 +146,7 @@ bool SBTypeFilter::IsEqualTo(lldb::SBTypeFilter &rhs) {
}
bool SBTypeFilter::operator!=(lldb::SBTypeFilter &rhs) {
- LLDB_RECORD_METHOD(bool, SBTypeFilter, operator!=,(lldb::SBTypeFilter &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (!IsValid())
return !rhs.IsValid();
diff --git a/lldb/source/API/SBTypeFormat.cpp b/lldb/source/API/SBTypeFormat.cpp
index 139bbebaa3f4..86e11e8b8fde 100644
--- a/lldb/source/API/SBTypeFormat.cpp
+++ b/lldb/source/API/SBTypeFormat.cpp
@@ -7,7 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBTypeFormat.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/API/SBStream.h"
@@ -16,41 +16,39 @@
using namespace lldb;
using namespace lldb_private;
-SBTypeFormat::SBTypeFormat() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeFormat); }
+SBTypeFormat::SBTypeFormat() { LLDB_INSTRUMENT_VA(this); }
SBTypeFormat::SBTypeFormat(lldb::Format format, uint32_t options)
: m_opaque_sp(
TypeFormatImplSP(new TypeFormatImpl_Format(format, options))) {
- LLDB_RECORD_CONSTRUCTOR(SBTypeFormat, (lldb::Format, uint32_t), format,
- options);
+ LLDB_INSTRUMENT_VA(this, format, options);
}
SBTypeFormat::SBTypeFormat(const char *type, uint32_t options)
: m_opaque_sp(TypeFormatImplSP(new TypeFormatImpl_EnumType(
ConstString(type ? type : ""), options))) {
- LLDB_RECORD_CONSTRUCTOR(SBTypeFormat, (const char *, uint32_t), type,
- options);
+ LLDB_INSTRUMENT_VA(this, type, options);
}
SBTypeFormat::SBTypeFormat(const lldb::SBTypeFormat &rhs)
: m_opaque_sp(rhs.m_opaque_sp) {
- LLDB_RECORD_CONSTRUCTOR(SBTypeFormat, (const lldb::SBTypeFormat &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
}
SBTypeFormat::~SBTypeFormat() = default;
bool SBTypeFormat::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFormat, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBTypeFormat::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFormat, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp.get() != nullptr;
}
lldb::Format SBTypeFormat::GetFormat() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::Format, SBTypeFormat, GetFormat);
+ LLDB_INSTRUMENT_VA(this);
if (IsValid() && m_opaque_sp->GetType() == TypeFormatImpl::Type::eTypeFormat)
return ((TypeFormatImpl_Format *)m_opaque_sp.get())->GetFormat();
@@ -58,7 +56,7 @@ lldb::Format SBTypeFormat::GetFormat() {
}
const char *SBTypeFormat::GetTypeName() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeFormat, GetTypeName);
+ LLDB_INSTRUMENT_VA(this);
if (IsValid() && m_opaque_sp->GetType() == TypeFormatImpl::Type::eTypeEnum)
return ((TypeFormatImpl_EnumType *)m_opaque_sp.get())
@@ -68,7 +66,7 @@ const char *SBTypeFormat::GetTypeName() {
}
uint32_t SBTypeFormat::GetOptions() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeFormat, GetOptions);
+ LLDB_INSTRUMENT_VA(this);
if (IsValid())
return m_opaque_sp->GetOptions();
@@ -76,14 +74,14 @@ uint32_t SBTypeFormat::GetOptions() {
}
void SBTypeFormat::SetFormat(lldb::Format fmt) {
- LLDB_RECORD_METHOD(void, SBTypeFormat, SetFormat, (lldb::Format), fmt);
+ LLDB_INSTRUMENT_VA(this, fmt);
if (CopyOnWrite_Impl(Type::eTypeFormat))
((TypeFormatImpl_Format *)m_opaque_sp.get())->SetFormat(fmt);
}
void SBTypeFormat::SetTypeName(const char *type) {
- LLDB_RECORD_METHOD(void, SBTypeFormat, SetTypeName, (const char *), type);
+ LLDB_INSTRUMENT_VA(this, type);
if (CopyOnWrite_Impl(Type::eTypeEnum))
((TypeFormatImpl_EnumType *)m_opaque_sp.get())
@@ -91,7 +89,7 @@ void SBTypeFormat::SetTypeName(const char *type) {
}
void SBTypeFormat::SetOptions(uint32_t value) {
- LLDB_RECORD_METHOD(void, SBTypeFormat, SetOptions, (uint32_t), value);
+ LLDB_INSTRUMENT_VA(this, value);
if (CopyOnWrite_Impl(Type::eTypeKeepSame))
m_opaque_sp->SetOptions(value);
@@ -99,9 +97,7 @@ void SBTypeFormat::SetOptions(uint32_t value) {
bool SBTypeFormat::GetDescription(lldb::SBStream &description,
lldb::DescriptionLevel description_level) {
- LLDB_RECORD_METHOD(bool, SBTypeFormat, GetDescription,
- (lldb::SBStream &, lldb::DescriptionLevel), description,
- description_level);
+ LLDB_INSTRUMENT_VA(this, description, description_level);
if (!IsValid())
return false;
@@ -112,8 +108,7 @@ bool SBTypeFormat::GetDescription(lldb::SBStream &description,
}
lldb::SBTypeFormat &SBTypeFormat::operator=(const lldb::SBTypeFormat &rhs) {
- LLDB_RECORD_METHOD(lldb::SBTypeFormat &,
- SBTypeFormat, operator=,(const lldb::SBTypeFormat &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
@@ -122,8 +117,7 @@ lldb::SBTypeFormat &SBTypeFormat::operator=(const lldb::SBTypeFormat &rhs) {
}
bool SBTypeFormat::operator==(lldb::SBTypeFormat &rhs) {
- LLDB_RECORD_METHOD(bool, SBTypeFormat, operator==,(lldb::SBTypeFormat &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (!IsValid())
return !rhs.IsValid();
@@ -131,8 +125,7 @@ bool SBTypeFormat::operator==(lldb::SBTypeFormat &rhs) {
}
bool SBTypeFormat::IsEqualTo(lldb::SBTypeFormat &rhs) {
- LLDB_RECORD_METHOD(bool, SBTypeFormat, IsEqualTo, (lldb::SBTypeFormat &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (!IsValid())
return !rhs.IsValid();
@@ -144,8 +137,7 @@ bool SBTypeFormat::IsEqualTo(lldb::SBTypeFormat &rhs) {
}
bool SBTypeFormat::operator!=(lldb::SBTypeFormat &rhs) {
- LLDB_RECORD_METHOD(bool, SBTypeFormat, operator!=,(lldb::SBTypeFormat &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (!IsValid())
return !rhs.IsValid();
diff --git a/lldb/source/API/SBTypeNameSpecifier.cpp b/lldb/source/API/SBTypeNameSpecifier.cpp
index 3b9dd8300c87..bc83a1d664d0 100644
--- a/lldb/source/API/SBTypeNameSpecifier.cpp
+++ b/lldb/source/API/SBTypeNameSpecifier.cpp
@@ -7,7 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBTypeNameSpecifier.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBType.h"
@@ -17,21 +17,18 @@
using namespace lldb;
using namespace lldb_private;
-SBTypeNameSpecifier::SBTypeNameSpecifier() {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeNameSpecifier);
-}
+SBTypeNameSpecifier::SBTypeNameSpecifier() { LLDB_INSTRUMENT_VA(this); }
SBTypeNameSpecifier::SBTypeNameSpecifier(const char *name, bool is_regex)
: m_opaque_sp(new TypeNameSpecifierImpl(name, is_regex)) {
- LLDB_RECORD_CONSTRUCTOR(SBTypeNameSpecifier, (const char *, bool), name,
- is_regex);
+ LLDB_INSTRUMENT_VA(this, name, is_regex);
if (name == nullptr || (*name) == 0)
m_opaque_sp.reset();
}
SBTypeNameSpecifier::SBTypeNameSpecifier(SBType type) {
- LLDB_RECORD_CONSTRUCTOR(SBTypeNameSpecifier, (lldb::SBType), type);
+ LLDB_INSTRUMENT_VA(this, type);
if (type.IsValid())
m_opaque_sp = TypeNameSpecifierImplSP(
@@ -40,24 +37,23 @@ SBTypeNameSpecifier::SBTypeNameSpecifier(SBType type) {
SBTypeNameSpecifier::SBTypeNameSpecifier(const lldb::SBTypeNameSpecifier &rhs)
: m_opaque_sp(rhs.m_opaque_sp) {
- LLDB_RECORD_CONSTRUCTOR(SBTypeNameSpecifier,
- (const lldb::SBTypeNameSpecifier &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
}
SBTypeNameSpecifier::~SBTypeNameSpecifier() = default;
bool SBTypeNameSpecifier::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeNameSpecifier, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBTypeNameSpecifier::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeNameSpecifier, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp.get() != nullptr;
}
const char *SBTypeNameSpecifier::GetName() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeNameSpecifier, GetName);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return nullptr;
@@ -66,7 +62,7 @@ const char *SBTypeNameSpecifier::GetName() {
}
SBType SBTypeNameSpecifier::GetType() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeNameSpecifier, GetType);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return SBType();
@@ -77,7 +73,7 @@ SBType SBTypeNameSpecifier::GetType() {
}
bool SBTypeNameSpecifier::IsRegex() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeNameSpecifier, IsRegex);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return false;
@@ -87,9 +83,7 @@ bool SBTypeNameSpecifier::IsRegex() {
bool SBTypeNameSpecifier::GetDescription(
lldb::SBStream &description, lldb::DescriptionLevel description_level) {
- LLDB_RECORD_METHOD(bool, SBTypeNameSpecifier, GetDescription,
- (lldb::SBStream &, lldb::DescriptionLevel), description,
- description_level);
+ LLDB_INSTRUMENT_VA(this, description, description_level);
if (!IsValid())
return false;
@@ -100,9 +94,7 @@ bool SBTypeNameSpecifier::GetDescription(
lldb::SBTypeNameSpecifier &SBTypeNameSpecifier::
operator=(const lldb::SBTypeNameSpecifier &rhs) {
- LLDB_RECORD_METHOD(
- lldb::SBTypeNameSpecifier &,
- SBTypeNameSpecifier, operator=,(const lldb::SBTypeNameSpecifier &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
@@ -111,8 +103,7 @@ operator=(const lldb::SBTypeNameSpecifier &rhs) {
}
bool SBTypeNameSpecifier::operator==(lldb::SBTypeNameSpecifier &rhs) {
- LLDB_RECORD_METHOD(
- bool, SBTypeNameSpecifier, operator==,(lldb::SBTypeNameSpecifier &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (!IsValid())
return !rhs.IsValid();
@@ -120,8 +111,7 @@ bool SBTypeNameSpecifier::operator==(lldb::SBTypeNameSpecifier &rhs) {
}
bool SBTypeNameSpecifier::IsEqualTo(lldb::SBTypeNameSpecifier &rhs) {
- LLDB_RECORD_METHOD(bool, SBTypeNameSpecifier, IsEqualTo,
- (lldb::SBTypeNameSpecifier &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (!IsValid())
return !rhs.IsValid();
@@ -135,8 +125,7 @@ bool SBTypeNameSpecifier::IsEqualTo(lldb::SBTypeNameSpecifier &rhs) {
}
bool SBTypeNameSpecifier::operator!=(lldb::SBTypeNameSpecifier &rhs) {
- LLDB_RECORD_METHOD(
- bool, SBTypeNameSpecifier, operator!=,(lldb::SBTypeNameSpecifier &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (!IsValid())
return !rhs.IsValid();
diff --git a/lldb/source/API/SBTypeSummary.cpp b/lldb/source/API/SBTypeSummary.cpp
index af0888078d8f..a65dfc987ad2 100644
--- a/lldb/source/API/SBTypeSummary.cpp
+++ b/lldb/source/API/SBTypeSummary.cpp
@@ -7,11 +7,11 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBTypeSummary.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBValue.h"
#include "lldb/DataFormatters/DataVisualization.h"
+#include "lldb/Utility/Instrumentation.h"
#include "llvm/Support/Casting.h"
@@ -19,15 +19,14 @@ using namespace lldb;
using namespace lldb_private;
SBTypeSummaryOptions::SBTypeSummaryOptions() {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeSummaryOptions);
+ LLDB_INSTRUMENT_VA(this);
m_opaque_up = std::make_unique<TypeSummaryOptions>();
}
SBTypeSummaryOptions::SBTypeSummaryOptions(
const lldb::SBTypeSummaryOptions &rhs) {
- LLDB_RECORD_CONSTRUCTOR(SBTypeSummaryOptions,
- (const lldb::SBTypeSummaryOptions &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_up = clone(rhs.m_opaque_up);
}
@@ -35,18 +34,17 @@ SBTypeSummaryOptions::SBTypeSummaryOptions(
SBTypeSummaryOptions::~SBTypeSummaryOptions() = default;
bool SBTypeSummaryOptions::IsValid() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummaryOptions, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBTypeSummaryOptions::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSummaryOptions, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up.get();
}
lldb::LanguageType SBTypeSummaryOptions::GetLanguage() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::LanguageType, SBTypeSummaryOptions,
- GetLanguage);
+ LLDB_INSTRUMENT_VA(this);
if (IsValid())
return m_opaque_up->GetLanguage();
@@ -54,8 +52,7 @@ lldb::LanguageType SBTypeSummaryOptions::GetLanguage() {
}
lldb::TypeSummaryCapping SBTypeSummaryOptions::GetCapping() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::TypeSummaryCapping, SBTypeSummaryOptions,
- GetCapping);
+ LLDB_INSTRUMENT_VA(this);
if (IsValid())
return m_opaque_up->GetCapping();
@@ -63,16 +60,14 @@ lldb::TypeSummaryCapping SBTypeSummaryOptions::GetCapping() {
}
void SBTypeSummaryOptions::SetLanguage(lldb::LanguageType l) {
- LLDB_RECORD_METHOD(void, SBTypeSummaryOptions, SetLanguage,
- (lldb::LanguageType), l);
+ LLDB_INSTRUMENT_VA(this, l);
if (IsValid())
m_opaque_up->SetLanguage(l);
}
void SBTypeSummaryOptions::SetCapping(lldb::TypeSummaryCapping c) {
- LLDB_RECORD_METHOD(void, SBTypeSummaryOptions, SetCapping,
- (lldb::TypeSummaryCapping), c);
+ LLDB_INSTRUMENT_VA(this, c);
if (IsValid())
m_opaque_up->SetCapping(c);
@@ -102,20 +97,14 @@ const lldb_private::TypeSummaryOptions &SBTypeSummaryOptions::ref() const {
SBTypeSummaryOptions::SBTypeSummaryOptions(
const lldb_private::TypeSummaryOptions &lldb_object)
: m_opaque_up(std::make_unique<TypeSummaryOptions>(lldb_object)) {
- LLDB_RECORD_CONSTRUCTOR(SBTypeSummaryOptions,
- (const lldb_private::TypeSummaryOptions &),
- lldb_object);
+ LLDB_INSTRUMENT_VA(this, lldb_object);
}
-SBTypeSummary::SBTypeSummary() {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeSummary);
-}
+SBTypeSummary::SBTypeSummary() { LLDB_INSTRUMENT_VA(this); }
SBTypeSummary SBTypeSummary::CreateWithSummaryString(const char *data,
uint32_t options) {
- LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
- CreateWithSummaryString, (const char *, uint32_t),
- data, options);
+ LLDB_INSTRUMENT_VA(data, options);
if (!data || data[0] == 0)
return SBTypeSummary();
@@ -126,9 +115,7 @@ SBTypeSummary SBTypeSummary::CreateWithSummaryString(const char *data,
SBTypeSummary SBTypeSummary::CreateWithFunctionName(const char *data,
uint32_t options) {
- LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
- CreateWithFunctionName, (const char *, uint32_t),
- data, options);
+ LLDB_INSTRUMENT_VA(data, options);
if (!data || data[0] == 0)
return SBTypeSummary();
@@ -139,9 +126,7 @@ SBTypeSummary SBTypeSummary::CreateWithFunctionName(const char *data,
SBTypeSummary SBTypeSummary::CreateWithScriptCode(const char *data,
uint32_t options) {
- LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
- CreateWithScriptCode, (const char *, uint32_t),
- data, options);
+ LLDB_INSTRUMENT_VA(data, options);
if (!data || data[0] == 0)
return SBTypeSummary();
@@ -153,10 +138,7 @@ SBTypeSummary SBTypeSummary::CreateWithScriptCode(const char *data,
SBTypeSummary SBTypeSummary::CreateWithCallback(FormatCallback cb,
uint32_t options,
const char *description) {
- LLDB_RECORD_STATIC_METHOD(
- lldb::SBTypeSummary, SBTypeSummary, CreateWithCallback,
- (lldb::SBTypeSummary::FormatCallback, uint32_t, const char *), cb,
- options, description);
+ LLDB_INSTRUMENT_VA(cb, options, description);
SBTypeSummary retval;
if (cb) {
@@ -180,23 +162,23 @@ SBTypeSummary SBTypeSummary::CreateWithCallback(FormatCallback cb,
SBTypeSummary::SBTypeSummary(const lldb::SBTypeSummary &rhs)
: m_opaque_sp(rhs.m_opaque_sp) {
- LLDB_RECORD_CONSTRUCTOR(SBTypeSummary, (const lldb::SBTypeSummary &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
}
SBTypeSummary::~SBTypeSummary() = default;
bool SBTypeSummary::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSummary, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBTypeSummary::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSummary, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp.get() != nullptr;
}
bool SBTypeSummary::IsFunctionCode() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummary, IsFunctionCode);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return false;
@@ -209,7 +191,7 @@ bool SBTypeSummary::IsFunctionCode() {
}
bool SBTypeSummary::IsFunctionName() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummary, IsFunctionName);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return false;
@@ -222,7 +204,7 @@ bool SBTypeSummary::IsFunctionName() {
}
bool SBTypeSummary::IsSummaryString() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummary, IsSummaryString);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return false;
@@ -231,7 +213,7 @@ bool SBTypeSummary::IsSummaryString() {
}
const char *SBTypeSummary::GetData() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeSummary, GetData);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return nullptr;
@@ -249,7 +231,7 @@ const char *SBTypeSummary::GetData() {
}
uint32_t SBTypeSummary::GetOptions() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeSummary, GetOptions);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return lldb::eTypeOptionNone;
@@ -257,7 +239,7 @@ uint32_t SBTypeSummary::GetOptions() {
}
void SBTypeSummary::SetOptions(uint32_t value) {
- LLDB_RECORD_METHOD(void, SBTypeSummary, SetOptions, (uint32_t), value);
+ LLDB_INSTRUMENT_VA(this, value);
if (!CopyOnWrite_Impl())
return;
@@ -265,8 +247,7 @@ void SBTypeSummary::SetOptions(uint32_t value) {
}
void SBTypeSummary::SetSummaryString(const char *data) {
- LLDB_RECORD_METHOD(void, SBTypeSummary, SetSummaryString, (const char *),
- data);
+ LLDB_INSTRUMENT_VA(this, data);
if (!IsValid())
return;
@@ -278,8 +259,7 @@ void SBTypeSummary::SetSummaryString(const char *data) {
}
void SBTypeSummary::SetFunctionName(const char *data) {
- LLDB_RECORD_METHOD(void, SBTypeSummary, SetFunctionName, (const char *),
- data);
+ LLDB_INSTRUMENT_VA(this, data);
if (!IsValid())
return;
@@ -291,8 +271,7 @@ void SBTypeSummary::SetFunctionName(const char *data) {
}
void SBTypeSummary::SetFunctionCode(const char *data) {
- LLDB_RECORD_METHOD(void, SBTypeSummary, SetFunctionCode, (const char *),
- data);
+ LLDB_INSTRUMENT_VA(this, data);
if (!IsValid())
return;
@@ -305,9 +284,7 @@ void SBTypeSummary::SetFunctionCode(const char *data) {
bool SBTypeSummary::GetDescription(lldb::SBStream &description,
lldb::DescriptionLevel description_level) {
- LLDB_RECORD_METHOD(bool, SBTypeSummary, GetDescription,
- (lldb::SBStream &, lldb::DescriptionLevel), description,
- description_level);
+ LLDB_INSTRUMENT_VA(this, description, description_level);
if (!CopyOnWrite_Impl())
return false;
@@ -318,8 +295,7 @@ bool SBTypeSummary::GetDescription(lldb::SBStream &description,
}
bool SBTypeSummary::DoesPrintValue(lldb::SBValue value) {
- LLDB_RECORD_METHOD(bool, SBTypeSummary, DoesPrintValue, (lldb::SBValue),
- value);
+ LLDB_INSTRUMENT_VA(this, value);
if (!IsValid())
return false;
@@ -328,9 +304,7 @@ 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_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
@@ -339,8 +313,7 @@ lldb::SBTypeSummary &SBTypeSummary::operator=(const lldb::SBTypeSummary &rhs) {
}
bool SBTypeSummary::operator==(lldb::SBTypeSummary &rhs) {
- LLDB_RECORD_METHOD(bool, SBTypeSummary, operator==,(lldb::SBTypeSummary &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (!IsValid())
return !rhs.IsValid();
@@ -348,8 +321,7 @@ bool SBTypeSummary::operator==(lldb::SBTypeSummary &rhs) {
}
bool SBTypeSummary::IsEqualTo(lldb::SBTypeSummary &rhs) {
- LLDB_RECORD_METHOD(bool, SBTypeSummary, IsEqualTo, (lldb::SBTypeSummary &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (IsValid()) {
// valid and invalid are
diff erent
@@ -389,8 +361,7 @@ bool SBTypeSummary::IsEqualTo(lldb::SBTypeSummary &rhs) {
}
bool SBTypeSummary::operator!=(lldb::SBTypeSummary &rhs) {
- LLDB_RECORD_METHOD(bool, SBTypeSummary, operator!=,(lldb::SBTypeSummary &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (!IsValid())
return !rhs.IsValid();
diff --git a/lldb/source/API/SBTypeSynthetic.cpp b/lldb/source/API/SBTypeSynthetic.cpp
index 5b8a03b27077..7258ff04745d 100644
--- a/lldb/source/API/SBTypeSynthetic.cpp
+++ b/lldb/source/API/SBTypeSynthetic.cpp
@@ -7,7 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBTypeSynthetic.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/API/SBStream.h"
@@ -16,15 +16,11 @@
using namespace lldb;
using namespace lldb_private;
-SBTypeSynthetic::SBTypeSynthetic() {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeSynthetic);
-}
+SBTypeSynthetic::SBTypeSynthetic() { LLDB_INSTRUMENT_VA(this); }
SBTypeSynthetic SBTypeSynthetic::CreateWithClassName(const char *data,
uint32_t options) {
- LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSynthetic, SBTypeSynthetic,
- CreateWithClassName, (const char *, uint32_t), data,
- options);
+ LLDB_INSTRUMENT_VA(data, options);
if (!data || data[0] == 0)
return SBTypeSynthetic();
@@ -34,9 +30,7 @@ SBTypeSynthetic SBTypeSynthetic::CreateWithClassName(const char *data,
SBTypeSynthetic SBTypeSynthetic::CreateWithScriptCode(const char *data,
uint32_t options) {
- LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSynthetic, SBTypeSynthetic,
- CreateWithScriptCode, (const char *, uint32_t),
- data, options);
+ LLDB_INSTRUMENT_VA(data, options);
if (!data || data[0] == 0)
return SBTypeSynthetic();
@@ -46,24 +40,23 @@ SBTypeSynthetic SBTypeSynthetic::CreateWithScriptCode(const char *data,
SBTypeSynthetic::SBTypeSynthetic(const lldb::SBTypeSynthetic &rhs)
: m_opaque_sp(rhs.m_opaque_sp) {
- LLDB_RECORD_CONSTRUCTOR(SBTypeSynthetic, (const lldb::SBTypeSynthetic &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
}
SBTypeSynthetic::~SBTypeSynthetic() = default;
bool SBTypeSynthetic::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSynthetic, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBTypeSynthetic::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSynthetic, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_sp.get() != nullptr;
}
bool SBTypeSynthetic::IsClassCode() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSynthetic, IsClassCode);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return false;
@@ -72,7 +65,7 @@ bool SBTypeSynthetic::IsClassCode() {
}
bool SBTypeSynthetic::IsClassName() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSynthetic, IsClassName);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return false;
@@ -80,7 +73,7 @@ bool SBTypeSynthetic::IsClassName() {
}
const char *SBTypeSynthetic::GetData() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeSynthetic, GetData);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return nullptr;
@@ -91,21 +84,21 @@ const char *SBTypeSynthetic::GetData() {
}
void SBTypeSynthetic::SetClassName(const char *data) {
- LLDB_RECORD_METHOD(void, SBTypeSynthetic, SetClassName, (const char *), data);
+ LLDB_INSTRUMENT_VA(this, data);
if (IsValid() && data && *data)
m_opaque_sp->SetPythonClassName(data);
}
void SBTypeSynthetic::SetClassCode(const char *data) {
- LLDB_RECORD_METHOD(void, SBTypeSynthetic, SetClassCode, (const char *), data);
+ LLDB_INSTRUMENT_VA(this, data);
if (IsValid() && data && *data)
m_opaque_sp->SetPythonCode(data);
}
uint32_t SBTypeSynthetic::GetOptions() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeSynthetic, GetOptions);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return lldb::eTypeOptionNone;
@@ -113,7 +106,7 @@ uint32_t SBTypeSynthetic::GetOptions() {
}
void SBTypeSynthetic::SetOptions(uint32_t value) {
- LLDB_RECORD_METHOD(void, SBTypeSynthetic, SetOptions, (uint32_t), value);
+ LLDB_INSTRUMENT_VA(this, value);
if (!CopyOnWrite_Impl())
return;
@@ -122,9 +115,7 @@ void SBTypeSynthetic::SetOptions(uint32_t value) {
bool SBTypeSynthetic::GetDescription(lldb::SBStream &description,
lldb::DescriptionLevel description_level) {
- LLDB_RECORD_METHOD(bool, SBTypeSynthetic, GetDescription,
- (lldb::SBStream &, lldb::DescriptionLevel), description,
- description_level);
+ LLDB_INSTRUMENT_VA(this, description, description_level);
if (m_opaque_sp) {
description.Printf("%s\n", m_opaque_sp->GetDescription().c_str());
@@ -135,9 +126,7 @@ bool SBTypeSynthetic::GetDescription(lldb::SBStream &description,
lldb::SBTypeSynthetic &SBTypeSynthetic::
operator=(const lldb::SBTypeSynthetic &rhs) {
- LLDB_RECORD_METHOD(lldb::SBTypeSynthetic &,
- SBTypeSynthetic, operator=,(const lldb::SBTypeSynthetic &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
@@ -146,8 +135,7 @@ operator=(const lldb::SBTypeSynthetic &rhs) {
}
bool SBTypeSynthetic::operator==(lldb::SBTypeSynthetic &rhs) {
- LLDB_RECORD_METHOD(
- bool, SBTypeSynthetic, operator==,(lldb::SBTypeSynthetic &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (!IsValid())
return !rhs.IsValid();
@@ -155,8 +143,7 @@ bool SBTypeSynthetic::operator==(lldb::SBTypeSynthetic &rhs) {
}
bool SBTypeSynthetic::IsEqualTo(lldb::SBTypeSynthetic &rhs) {
- LLDB_RECORD_METHOD(bool, SBTypeSynthetic, IsEqualTo,
- (lldb::SBTypeSynthetic &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (!IsValid())
return !rhs.IsValid();
@@ -174,8 +161,7 @@ bool SBTypeSynthetic::IsEqualTo(lldb::SBTypeSynthetic &rhs) {
}
bool SBTypeSynthetic::operator!=(lldb::SBTypeSynthetic &rhs) {
- LLDB_RECORD_METHOD(
- bool, SBTypeSynthetic, operator!=,(lldb::SBTypeSynthetic &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (!IsValid())
return !rhs.IsValid();
diff --git a/lldb/source/API/SBUnixSignals.cpp b/lldb/source/API/SBUnixSignals.cpp
index 6ee7afb04e7b..dc7a68255d13 100644
--- a/lldb/source/API/SBUnixSignals.cpp
+++ b/lldb/source/API/SBUnixSignals.cpp
@@ -6,10 +6,10 @@
//
//===----------------------------------------------------------------------===//
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/Target/Platform.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/UnixSignals.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/lldb-defines.h"
#include "lldb/API/SBUnixSignals.h"
@@ -17,13 +17,11 @@
using namespace lldb;
using namespace lldb_private;
-SBUnixSignals::SBUnixSignals() {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBUnixSignals);
-}
+SBUnixSignals::SBUnixSignals() { LLDB_INSTRUMENT_VA(this); }
SBUnixSignals::SBUnixSignals(const SBUnixSignals &rhs)
: m_opaque_wp(rhs.m_opaque_wp) {
- LLDB_RECORD_CONSTRUCTOR(SBUnixSignals, (const lldb::SBUnixSignals &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
}
SBUnixSignals::SBUnixSignals(ProcessSP &process_sp)
@@ -33,9 +31,7 @@ SBUnixSignals::SBUnixSignals(PlatformSP &platform_sp)
: m_opaque_wp(platform_sp ? platform_sp->GetUnixSignals() : nullptr) {}
const SBUnixSignals &SBUnixSignals::operator=(const SBUnixSignals &rhs) {
- LLDB_RECORD_METHOD(const lldb::SBUnixSignals &,
- SBUnixSignals, operator=,(const lldb::SBUnixSignals &),
- rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_wp = rhs.m_opaque_wp;
@@ -51,24 +47,23 @@ void SBUnixSignals::SetSP(const UnixSignalsSP &signals_sp) {
}
void SBUnixSignals::Clear() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBUnixSignals, Clear);
+ LLDB_INSTRUMENT_VA(this);
m_opaque_wp.reset();
}
bool SBUnixSignals::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBUnixSignals, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBUnixSignals::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBUnixSignals, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return static_cast<bool>(GetSP());
}
const char *SBUnixSignals::GetSignalAsCString(int32_t signo) const {
- LLDB_RECORD_METHOD_CONST(const char *, SBUnixSignals, GetSignalAsCString,
- (int32_t), signo);
+ LLDB_INSTRUMENT_VA(this, signo);
if (auto signals_sp = GetSP())
return signals_sp->GetSignalAsCString(signo);
@@ -77,8 +72,7 @@ const char *SBUnixSignals::GetSignalAsCString(int32_t signo) const {
}
int32_t SBUnixSignals::GetSignalNumberFromName(const char *name) const {
- LLDB_RECORD_METHOD_CONST(int32_t, SBUnixSignals, GetSignalNumberFromName,
- (const char *), name);
+ LLDB_INSTRUMENT_VA(this, name);
if (auto signals_sp = GetSP())
return signals_sp->GetSignalNumberFromName(name);
@@ -87,8 +81,7 @@ int32_t SBUnixSignals::GetSignalNumberFromName(const char *name) const {
}
bool SBUnixSignals::GetShouldSuppress(int32_t signo) const {
- LLDB_RECORD_METHOD_CONST(bool, SBUnixSignals, GetShouldSuppress, (int32_t),
- signo);
+ LLDB_INSTRUMENT_VA(this, signo);
if (auto signals_sp = GetSP())
return signals_sp->GetShouldSuppress(signo);
@@ -97,8 +90,7 @@ bool SBUnixSignals::GetShouldSuppress(int32_t signo) const {
}
bool SBUnixSignals::SetShouldSuppress(int32_t signo, bool value) {
- LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldSuppress, (int32_t, bool),
- signo, value);
+ LLDB_INSTRUMENT_VA(this, signo, value);
auto signals_sp = GetSP();
@@ -109,8 +101,7 @@ bool SBUnixSignals::SetShouldSuppress(int32_t signo, bool value) {
}
bool SBUnixSignals::GetShouldStop(int32_t signo) const {
- LLDB_RECORD_METHOD_CONST(bool, SBUnixSignals, GetShouldStop, (int32_t),
- signo);
+ LLDB_INSTRUMENT_VA(this, signo);
if (auto signals_sp = GetSP())
return signals_sp->GetShouldStop(signo);
@@ -119,8 +110,7 @@ bool SBUnixSignals::GetShouldStop(int32_t signo) const {
}
bool SBUnixSignals::SetShouldStop(int32_t signo, bool value) {
- LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldStop, (int32_t, bool), signo,
- value);
+ LLDB_INSTRUMENT_VA(this, signo, value);
auto signals_sp = GetSP();
@@ -131,8 +121,7 @@ bool SBUnixSignals::SetShouldStop(int32_t signo, bool value) {
}
bool SBUnixSignals::GetShouldNotify(int32_t signo) const {
- LLDB_RECORD_METHOD_CONST(bool, SBUnixSignals, GetShouldNotify, (int32_t),
- signo);
+ LLDB_INSTRUMENT_VA(this, signo);
if (auto signals_sp = GetSP())
return signals_sp->GetShouldNotify(signo);
@@ -141,8 +130,7 @@ bool SBUnixSignals::GetShouldNotify(int32_t signo) const {
}
bool SBUnixSignals::SetShouldNotify(int32_t signo, bool value) {
- LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldNotify, (int32_t, bool),
- signo, value);
+ LLDB_INSTRUMENT_VA(this, signo, value);
auto signals_sp = GetSP();
@@ -153,7 +141,7 @@ bool SBUnixSignals::SetShouldNotify(int32_t signo, bool value) {
}
int32_t SBUnixSignals::GetNumSignals() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(int32_t, SBUnixSignals, GetNumSignals);
+ LLDB_INSTRUMENT_VA(this);
if (auto signals_sp = GetSP())
return signals_sp->GetNumSignals();
@@ -162,8 +150,7 @@ int32_t SBUnixSignals::GetNumSignals() const {
}
int32_t SBUnixSignals::GetSignalAtIndex(int32_t index) const {
- LLDB_RECORD_METHOD_CONST(int32_t, SBUnixSignals, GetSignalAtIndex, (int32_t),
- index);
+ LLDB_INSTRUMENT_VA(this, index);
if (auto signals_sp = GetSP())
return signals_sp->GetSignalAtIndex(index);
diff --git a/lldb/source/API/SBValue.cpp b/lldb/source/API/SBValue.cpp
index 151ccba8381e..20581cfabdd6 100644
--- a/lldb/source/API/SBValue.cpp
+++ b/lldb/source/API/SBValue.cpp
@@ -7,7 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBValue.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/API/SBDeclaration.h"
#include "lldb/API/SBStream.h"
@@ -215,23 +215,22 @@ class ValueLocker {
Status m_lock_error;
};
-SBValue::SBValue() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBValue); }
+SBValue::SBValue() { LLDB_INSTRUMENT_VA(this); }
SBValue::SBValue(const lldb::ValueObjectSP &value_sp) {
- LLDB_RECORD_CONSTRUCTOR(SBValue, (const lldb::ValueObjectSP &), value_sp);
+ LLDB_INSTRUMENT_VA(this, value_sp);
SetSP(value_sp);
}
SBValue::SBValue(const SBValue &rhs) {
- LLDB_RECORD_CONSTRUCTOR(SBValue, (const lldb::SBValue &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
SetSP(rhs.m_opaque_sp);
}
SBValue &SBValue::operator=(const SBValue &rhs) {
- LLDB_RECORD_METHOD(lldb::SBValue &,
- SBValue, operator=,(const lldb::SBValue &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
SetSP(rhs.m_opaque_sp);
@@ -242,11 +241,11 @@ SBValue &SBValue::operator=(const SBValue &rhs) {
SBValue::~SBValue() = default;
bool SBValue::IsValid() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBValue::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBValue, operator bool);
+ LLDB_INSTRUMENT_VA(this);
// If this function ever changes to anything that does more than just check
// if the opaque shared pointer is non NULL, then we need to update all "if
@@ -256,13 +255,13 @@ SBValue::operator bool() const {
}
void SBValue::Clear() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBValue, Clear);
+ LLDB_INSTRUMENT_VA(this);
m_opaque_sp.reset();
}
SBError SBValue::GetError() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBValue, GetError);
+ LLDB_INSTRUMENT_VA(this);
SBError sb_error;
@@ -278,7 +277,7 @@ SBError SBValue::GetError() {
}
user_id_t SBValue::GetID() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::user_id_t, SBValue, GetID);
+ LLDB_INSTRUMENT_VA(this);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@@ -288,7 +287,7 @@ user_id_t SBValue::GetID() {
}
const char *SBValue::GetName() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetName);
+ LLDB_INSTRUMENT_VA(this);
const char *name = nullptr;
ValueLocker locker;
@@ -300,7 +299,7 @@ const char *SBValue::GetName() {
}
const char *SBValue::GetTypeName() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetTypeName);
+ LLDB_INSTRUMENT_VA(this);
const char *name = nullptr;
ValueLocker locker;
@@ -313,7 +312,7 @@ const char *SBValue::GetTypeName() {
}
const char *SBValue::GetDisplayTypeName() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetDisplayTypeName);
+ LLDB_INSTRUMENT_VA(this);
const char *name = nullptr;
ValueLocker locker;
@@ -326,7 +325,7 @@ const char *SBValue::GetDisplayTypeName() {
}
size_t SBValue::GetByteSize() {
- LLDB_RECORD_METHOD_NO_ARGS(size_t, SBValue, GetByteSize);
+ LLDB_INSTRUMENT_VA(this);
size_t result = 0;
@@ -340,7 +339,7 @@ size_t SBValue::GetByteSize() {
}
bool SBValue::IsInScope() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsInScope);
+ LLDB_INSTRUMENT_VA(this);
bool result = false;
@@ -354,7 +353,7 @@ bool SBValue::IsInScope() {
}
const char *SBValue::GetValue() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetValue);
+ LLDB_INSTRUMENT_VA(this);
const char *cstr = nullptr;
ValueLocker locker;
@@ -367,7 +366,7 @@ const char *SBValue::GetValue() {
}
ValueType SBValue::GetValueType() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::ValueType, SBValue, GetValueType);
+ LLDB_INSTRUMENT_VA(this);
ValueType result = eValueTypeInvalid;
ValueLocker locker;
@@ -379,7 +378,7 @@ ValueType SBValue::GetValueType() {
}
const char *SBValue::GetObjectDescription() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetObjectDescription);
+ LLDB_INSTRUMENT_VA(this);
const char *cstr = nullptr;
ValueLocker locker;
@@ -392,7 +391,7 @@ const char *SBValue::GetObjectDescription() {
}
SBType SBValue::GetType() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBValue, GetType);
+ LLDB_INSTRUMENT_VA(this);
SBType sb_type;
ValueLocker locker;
@@ -407,7 +406,7 @@ SBType SBValue::GetType() {
}
bool SBValue::GetValueDidChange() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, GetValueDidChange);
+ LLDB_INSTRUMENT_VA(this);
bool result = false;
ValueLocker locker;
@@ -421,7 +420,7 @@ bool SBValue::GetValueDidChange() {
}
const char *SBValue::GetSummary() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetSummary);
+ LLDB_INSTRUMENT_VA(this);
const char *cstr = nullptr;
ValueLocker locker;
@@ -435,9 +434,7 @@ const char *SBValue::GetSummary() {
const char *SBValue::GetSummary(lldb::SBStream &stream,
lldb::SBTypeSummaryOptions &options) {
- LLDB_RECORD_METHOD(const char *, SBValue, GetSummary,
- (lldb::SBStream &, lldb::SBTypeSummaryOptions &), stream,
- options);
+ LLDB_INSTRUMENT_VA(this, stream, options);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@@ -451,7 +448,7 @@ const char *SBValue::GetSummary(lldb::SBStream &stream,
}
const char *SBValue::GetLocation() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetLocation);
+ LLDB_INSTRUMENT_VA(this);
const char *cstr = nullptr;
ValueLocker locker;
@@ -464,16 +461,14 @@ const char *SBValue::GetLocation() {
// Deprecated - use the one that takes an lldb::SBError
bool SBValue::SetValueFromCString(const char *value_str) {
- LLDB_RECORD_METHOD(bool, SBValue, SetValueFromCString, (const char *),
- value_str);
+ LLDB_INSTRUMENT_VA(this, value_str);
lldb::SBError dummy;
return SetValueFromCString(value_str, dummy);
}
bool SBValue::SetValueFromCString(const char *value_str, lldb::SBError &error) {
- LLDB_RECORD_METHOD(bool, SBValue, SetValueFromCString,
- (const char *, lldb::SBError &), value_str, error);
+ LLDB_INSTRUMENT_VA(this, value_str, error);
bool success = false;
ValueLocker locker;
@@ -488,7 +483,7 @@ bool SBValue::SetValueFromCString(const char *value_str, lldb::SBError &error) {
}
lldb::SBTypeFormat SBValue::GetTypeFormat() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeFormat, SBValue, GetTypeFormat);
+ LLDB_INSTRUMENT_VA(this);
lldb::SBTypeFormat format;
ValueLocker locker;
@@ -504,7 +499,7 @@ lldb::SBTypeFormat SBValue::GetTypeFormat() {
}
lldb::SBTypeSummary SBValue::GetTypeSummary() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeSummary, SBValue, GetTypeSummary);
+ LLDB_INSTRUMENT_VA(this);
lldb::SBTypeSummary summary;
ValueLocker locker;
@@ -520,7 +515,7 @@ lldb::SBTypeSummary SBValue::GetTypeSummary() {
}
lldb::SBTypeFilter SBValue::GetTypeFilter() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeFilter, SBValue, GetTypeFilter);
+ LLDB_INSTRUMENT_VA(this);
lldb::SBTypeFilter filter;
ValueLocker locker;
@@ -540,7 +535,7 @@ lldb::SBTypeFilter SBValue::GetTypeFilter() {
}
lldb::SBTypeSynthetic SBValue::GetTypeSynthetic() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeSynthetic, SBValue, GetTypeSynthetic);
+ LLDB_INSTRUMENT_VA(this);
lldb::SBTypeSynthetic synthetic;
ValueLocker locker;
@@ -561,9 +556,7 @@ lldb::SBTypeSynthetic SBValue::GetTypeSynthetic() {
lldb::SBValue SBValue::CreateChildAtOffset(const char *name, uint32_t offset,
SBType type) {
- LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateChildAtOffset,
- (const char *, uint32_t, lldb::SBType), name, offset,
- type);
+ LLDB_INSTRUMENT_VA(this, name, offset, type);
lldb::SBValue sb_value;
ValueLocker locker;
@@ -581,7 +574,7 @@ lldb::SBValue SBValue::CreateChildAtOffset(const char *name, uint32_t offset,
}
lldb::SBValue SBValue::Cast(SBType type) {
- LLDB_RECORD_METHOD(lldb::SBValue, SBValue, Cast, (lldb::SBType), type);
+ LLDB_INSTRUMENT_VA(this, type);
lldb::SBValue sb_value;
ValueLocker locker;
@@ -595,8 +588,7 @@ lldb::SBValue SBValue::Cast(SBType type) {
lldb::SBValue SBValue::CreateValueFromExpression(const char *name,
const char *expression) {
- LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateValueFromExpression,
- (const char *, const char *), name, expression);
+ LLDB_INSTRUMENT_VA(this, name, expression);
SBExpressionOptions options;
options.ref().SetKeepInMemory(true);
@@ -606,9 +598,7 @@ lldb::SBValue SBValue::CreateValueFromExpression(const char *name,
lldb::SBValue SBValue::CreateValueFromExpression(const char *name,
const char *expression,
SBExpressionOptions &options) {
- LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateValueFromExpression,
- (const char *, const char *, lldb::SBExpressionOptions &),
- name, expression, options);
+ LLDB_INSTRUMENT_VA(this, name, expression, options);
lldb::SBValue sb_value;
ValueLocker locker;
@@ -628,9 +618,7 @@ lldb::SBValue SBValue::CreateValueFromExpression(const char *name,
lldb::SBValue SBValue::CreateValueFromAddress(const char *name,
lldb::addr_t address,
SBType sb_type) {
- LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateValueFromAddress,
- (const char *, lldb::addr_t, lldb::SBType), name, address,
- sb_type);
+ LLDB_INSTRUMENT_VA(this, name, address, sb_type);
lldb::SBValue sb_value;
ValueLocker locker;
@@ -649,9 +637,7 @@ lldb::SBValue SBValue::CreateValueFromAddress(const char *name,
lldb::SBValue SBValue::CreateValueFromData(const char *name, SBData data,
SBType sb_type) {
- LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateValueFromData,
- (const char *, lldb::SBData, lldb::SBType), name, data,
- sb_type);
+ LLDB_INSTRUMENT_VA(this, name, data, sb_type);
lldb::SBValue sb_value;
lldb::ValueObjectSP new_value_sp;
@@ -669,7 +655,7 @@ lldb::SBValue SBValue::CreateValueFromData(const char *name, SBData data,
}
SBValue SBValue::GetChildAtIndex(uint32_t idx) {
- LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildAtIndex, (uint32_t), idx);
+ LLDB_INSTRUMENT_VA(this, idx);
const bool can_create_synthetic = false;
lldb::DynamicValueType use_dynamic = eNoDynamicValues;
@@ -686,9 +672,7 @@ SBValue SBValue::GetChildAtIndex(uint32_t idx) {
SBValue SBValue::GetChildAtIndex(uint32_t idx,
lldb::DynamicValueType use_dynamic,
bool can_create_synthetic) {
- LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildAtIndex,
- (uint32_t, lldb::DynamicValueType, bool), idx, use_dynamic,
- can_create_synthetic);
+ LLDB_INSTRUMENT_VA(this, idx, use_dynamic, can_create_synthetic);
lldb::ValueObjectSP child_sp;
@@ -709,8 +693,7 @@ SBValue SBValue::GetChildAtIndex(uint32_t idx,
}
uint32_t SBValue::GetIndexOfChildWithName(const char *name) {
- LLDB_RECORD_METHOD(uint32_t, SBValue, GetIndexOfChildWithName, (const char *),
- name);
+ LLDB_INSTRUMENT_VA(this, name);
uint32_t idx = UINT32_MAX;
ValueLocker locker;
@@ -722,8 +705,7 @@ uint32_t SBValue::GetIndexOfChildWithName(const char *name) {
}
SBValue SBValue::GetChildMemberWithName(const char *name) {
- LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName,
- (const char *), name);
+ LLDB_INSTRUMENT_VA(this, name);
lldb::DynamicValueType use_dynamic_value = eNoDynamicValues;
TargetSP target_sp;
@@ -738,9 +720,7 @@ SBValue SBValue::GetChildMemberWithName(const char *name) {
SBValue
SBValue::GetChildMemberWithName(const char *name,
lldb::DynamicValueType use_dynamic_value) {
- LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName,
- (const char *, lldb::DynamicValueType), name,
- use_dynamic_value);
+ LLDB_INSTRUMENT_VA(this, name, use_dynamic_value);
lldb::ValueObjectSP child_sp;
const ConstString str_name(name);
@@ -758,8 +738,7 @@ SBValue::GetChildMemberWithName(const char *name,
}
lldb::SBValue SBValue::GetDynamicValue(lldb::DynamicValueType use_dynamic) {
- LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetDynamicValue,
- (lldb::DynamicValueType), use_dynamic);
+ LLDB_INSTRUMENT_VA(this, use_dynamic);
SBValue value_sb;
if (IsValid()) {
@@ -771,7 +750,7 @@ lldb::SBValue SBValue::GetDynamicValue(lldb::DynamicValueType use_dynamic) {
}
lldb::SBValue SBValue::GetStaticValue() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, GetStaticValue);
+ LLDB_INSTRUMENT_VA(this);
SBValue value_sb;
if (IsValid()) {
@@ -784,7 +763,7 @@ lldb::SBValue SBValue::GetStaticValue() {
}
lldb::SBValue SBValue::GetNonSyntheticValue() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, GetNonSyntheticValue);
+ LLDB_INSTRUMENT_VA(this);
SBValue value_sb;
if (IsValid()) {
@@ -796,8 +775,7 @@ lldb::SBValue SBValue::GetNonSyntheticValue() {
}
lldb::DynamicValueType SBValue::GetPreferDynamicValue() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::DynamicValueType, SBValue,
- GetPreferDynamicValue);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return eNoDynamicValues;
@@ -805,15 +783,14 @@ lldb::DynamicValueType SBValue::GetPreferDynamicValue() {
}
void SBValue::SetPreferDynamicValue(lldb::DynamicValueType use_dynamic) {
- LLDB_RECORD_METHOD(void, SBValue, SetPreferDynamicValue,
- (lldb::DynamicValueType), use_dynamic);
+ LLDB_INSTRUMENT_VA(this, use_dynamic);
if (IsValid())
return m_opaque_sp->SetUseDynamic(use_dynamic);
}
bool SBValue::GetPreferSyntheticValue() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, GetPreferSyntheticValue);
+ LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return false;
@@ -821,15 +798,14 @@ bool SBValue::GetPreferSyntheticValue() {
}
void SBValue::SetPreferSyntheticValue(bool use_synthetic) {
- LLDB_RECORD_METHOD(void, SBValue, SetPreferSyntheticValue, (bool),
- use_synthetic);
+ LLDB_INSTRUMENT_VA(this, use_synthetic);
if (IsValid())
return m_opaque_sp->SetUseSynthetic(use_synthetic);
}
bool SBValue::IsDynamic() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsDynamic);
+ LLDB_INSTRUMENT_VA(this);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@@ -839,7 +815,7 @@ bool SBValue::IsDynamic() {
}
bool SBValue::IsSynthetic() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsSynthetic);
+ LLDB_INSTRUMENT_VA(this);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@@ -849,7 +825,7 @@ bool SBValue::IsSynthetic() {
}
bool SBValue::IsSyntheticChildrenGenerated() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsSyntheticChildrenGenerated);
+ LLDB_INSTRUMENT_VA(this);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@@ -859,7 +835,7 @@ bool SBValue::IsSyntheticChildrenGenerated() {
}
void SBValue::SetSyntheticChildrenGenerated(bool is) {
- LLDB_RECORD_METHOD(void, SBValue, SetSyntheticChildrenGenerated, (bool), is);
+ LLDB_INSTRUMENT_VA(this, is);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@@ -868,8 +844,7 @@ void SBValue::SetSyntheticChildrenGenerated(bool is) {
}
lldb::SBValue SBValue::GetValueForExpressionPath(const char *expr_path) {
- LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetValueForExpressionPath,
- (const char *), expr_path);
+ LLDB_INSTRUMENT_VA(this, expr_path);
lldb::ValueObjectSP child_sp;
ValueLocker locker;
@@ -886,8 +861,7 @@ lldb::SBValue SBValue::GetValueForExpressionPath(const char *expr_path) {
}
int64_t SBValue::GetValueAsSigned(SBError &error, int64_t fail_value) {
- LLDB_RECORD_METHOD(int64_t, SBValue, GetValueAsSigned,
- (lldb::SBError &, int64_t), error, fail_value);
+ LLDB_INSTRUMENT_VA(this, error, fail_value);
error.Clear();
ValueLocker locker;
@@ -907,8 +881,7 @@ int64_t SBValue::GetValueAsSigned(SBError &error, int64_t fail_value) {
}
uint64_t SBValue::GetValueAsUnsigned(SBError &error, uint64_t fail_value) {
- LLDB_RECORD_METHOD(uint64_t, SBValue, GetValueAsUnsigned,
- (lldb::SBError &, uint64_t), error, fail_value);
+ LLDB_INSTRUMENT_VA(this, error, fail_value);
error.Clear();
ValueLocker locker;
@@ -928,7 +901,7 @@ uint64_t SBValue::GetValueAsUnsigned(SBError &error, uint64_t fail_value) {
}
int64_t SBValue::GetValueAsSigned(int64_t fail_value) {
- LLDB_RECORD_METHOD(int64_t, SBValue, GetValueAsSigned, (int64_t), fail_value);
+ LLDB_INSTRUMENT_VA(this, fail_value);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@@ -939,8 +912,7 @@ int64_t SBValue::GetValueAsSigned(int64_t fail_value) {
}
uint64_t SBValue::GetValueAsUnsigned(uint64_t fail_value) {
- LLDB_RECORD_METHOD(uint64_t, SBValue, GetValueAsUnsigned, (uint64_t),
- fail_value);
+ LLDB_INSTRUMENT_VA(this, fail_value);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@@ -951,7 +923,7 @@ uint64_t SBValue::GetValueAsUnsigned(uint64_t fail_value) {
}
bool SBValue::MightHaveChildren() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, MightHaveChildren);
+ LLDB_INSTRUMENT_VA(this);
bool has_children = false;
ValueLocker locker;
@@ -963,7 +935,7 @@ bool SBValue::MightHaveChildren() {
}
bool SBValue::IsRuntimeSupportValue() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsRuntimeSupportValue);
+ LLDB_INSTRUMENT_VA(this);
bool is_support = false;
ValueLocker locker;
@@ -975,13 +947,13 @@ bool SBValue::IsRuntimeSupportValue() {
}
uint32_t SBValue::GetNumChildren() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBValue, GetNumChildren);
+ LLDB_INSTRUMENT_VA(this);
return GetNumChildren(UINT32_MAX);
}
uint32_t SBValue::GetNumChildren(uint32_t max) {
- LLDB_RECORD_METHOD(uint32_t, SBValue, GetNumChildren, (uint32_t), max);
+ LLDB_INSTRUMENT_VA(this, max);
uint32_t num_children = 0;
@@ -994,7 +966,7 @@ uint32_t SBValue::GetNumChildren(uint32_t max) {
}
SBValue SBValue::Dereference() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, Dereference);
+ LLDB_INSTRUMENT_VA(this);
SBValue sb_value;
ValueLocker locker;
@@ -1009,13 +981,13 @@ SBValue SBValue::Dereference() {
// Deprecated - please use GetType().IsPointerType() instead.
bool SBValue::TypeIsPointerType() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, TypeIsPointerType);
+ LLDB_INSTRUMENT_VA(this);
return GetType().IsPointerType();
}
void *SBValue::GetOpaqueType() {
- LLDB_RECORD_METHOD_NO_ARGS(void *, SBValue, GetOpaqueType);
+ LLDB_INSTRUMENT_VA(this);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@@ -1025,7 +997,7 @@ void *SBValue::GetOpaqueType() {
}
lldb::SBTarget SBValue::GetTarget() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBValue, GetTarget);
+ LLDB_INSTRUMENT_VA(this);
SBTarget sb_target;
TargetSP target_sp;
@@ -1038,7 +1010,7 @@ lldb::SBTarget SBValue::GetTarget() {
}
lldb::SBProcess SBValue::GetProcess() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBValue, GetProcess);
+ LLDB_INSTRUMENT_VA(this);
SBProcess sb_process;
ProcessSP process_sp;
@@ -1051,7 +1023,7 @@ lldb::SBProcess SBValue::GetProcess() {
}
lldb::SBThread SBValue::GetThread() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBThread, SBValue, GetThread);
+ LLDB_INSTRUMENT_VA(this);
SBThread sb_thread;
ThreadSP thread_sp;
@@ -1064,7 +1036,7 @@ lldb::SBThread SBValue::GetThread() {
}
lldb::SBFrame SBValue::GetFrame() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFrame, SBValue, GetFrame);
+ LLDB_INSTRUMENT_VA(this);
SBFrame sb_frame;
StackFrameSP frame_sp;
@@ -1085,7 +1057,7 @@ lldb::ValueObjectSP SBValue::GetSP(ValueLocker &locker) const {
}
lldb::ValueObjectSP SBValue::GetSP() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ValueObjectSP, SBValue, GetSP);
+ LLDB_INSTRUMENT_VA(this);
ValueLocker locker;
return GetSP(locker);
@@ -1146,8 +1118,7 @@ void SBValue::SetSP(const lldb::ValueObjectSP &sp,
}
bool SBValue::GetExpressionPath(SBStream &description) {
- LLDB_RECORD_METHOD(bool, SBValue, GetExpressionPath, (lldb::SBStream &),
- description);
+ LLDB_INSTRUMENT_VA(this, description);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@@ -1160,8 +1131,7 @@ bool SBValue::GetExpressionPath(SBStream &description) {
bool SBValue::GetExpressionPath(SBStream &description,
bool qualify_cxx_base_classes) {
- LLDB_RECORD_METHOD(bool, SBValue, GetExpressionPath, (lldb::SBStream &, bool),
- description, qualify_cxx_base_classes);
+ LLDB_INSTRUMENT_VA(this, description, qualify_cxx_base_classes);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@@ -1173,8 +1143,7 @@ bool SBValue::GetExpressionPath(SBStream &description,
}
lldb::SBValue SBValue::EvaluateExpression(const char *expr) const {
- LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValue, EvaluateExpression,
- (const char *), expr);
+ LLDB_INSTRUMENT_VA(this, expr);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@@ -1196,9 +1165,7 @@ lldb::SBValue SBValue::EvaluateExpression(const char *expr) const {
lldb::SBValue
SBValue::EvaluateExpression(const char *expr,
const SBExpressionOptions &options) const {
- LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValue, EvaluateExpression,
- (const char *, const lldb::SBExpressionOptions &),
- expr, options);
+ LLDB_INSTRUMENT_VA(this, expr, options);
return EvaluateExpression(expr, options, nullptr);
}
@@ -1206,11 +1173,7 @@ SBValue::EvaluateExpression(const char *expr,
lldb::SBValue SBValue::EvaluateExpression(const char *expr,
const SBExpressionOptions &options,
const char *name) const {
- LLDB_RECORD_METHOD_CONST(
- lldb::SBValue, SBValue, EvaluateExpression,
- (const char *, const lldb::SBExpressionOptions &, const char *), expr,
- options, name);
-
+ LLDB_INSTRUMENT_VA(this, expr, options, name);
if (!expr || expr[0] == '\0') {
return SBValue();
@@ -1249,8 +1212,7 @@ lldb::SBValue SBValue::EvaluateExpression(const char *expr,
}
bool SBValue::GetDescription(SBStream &description) {
- LLDB_RECORD_METHOD(bool, SBValue, GetDescription, (lldb::SBStream &),
- description);
+ LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();
@@ -1265,7 +1227,7 @@ bool SBValue::GetDescription(SBStream &description) {
}
lldb::Format SBValue::GetFormat() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::Format, SBValue, GetFormat);
+ LLDB_INSTRUMENT_VA(this);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@@ -1275,7 +1237,7 @@ lldb::Format SBValue::GetFormat() {
}
void SBValue::SetFormat(lldb::Format format) {
- LLDB_RECORD_METHOD(void, SBValue, SetFormat, (lldb::Format), format);
+ LLDB_INSTRUMENT_VA(this, format);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@@ -1284,7 +1246,7 @@ void SBValue::SetFormat(lldb::Format format) {
}
lldb::SBValue SBValue::AddressOf() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, AddressOf);
+ LLDB_INSTRUMENT_VA(this);
SBValue sb_value;
ValueLocker locker;
@@ -1299,7 +1261,7 @@ lldb::SBValue SBValue::AddressOf() {
}
lldb::addr_t SBValue::GetLoadAddress() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBValue, GetLoadAddress);
+ LLDB_INSTRUMENT_VA(this);
lldb::addr_t value = LLDB_INVALID_ADDRESS;
ValueLocker locker;
@@ -1329,7 +1291,7 @@ lldb::addr_t SBValue::GetLoadAddress() {
}
lldb::SBAddress SBValue::GetAddress() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBValue, GetAddress);
+ LLDB_INSTRUMENT_VA(this);
Address addr;
ValueLocker locker;
@@ -1358,8 +1320,7 @@ lldb::SBAddress SBValue::GetAddress() {
}
lldb::SBData SBValue::GetPointeeData(uint32_t item_idx, uint32_t item_count) {
- LLDB_RECORD_METHOD(lldb::SBData, SBValue, GetPointeeData,
- (uint32_t, uint32_t), item_idx, item_count);
+ LLDB_INSTRUMENT_VA(this, item_idx, item_count);
lldb::SBData sb_data;
ValueLocker locker;
@@ -1378,7 +1339,7 @@ lldb::SBData SBValue::GetPointeeData(uint32_t item_idx, uint32_t item_count) {
}
lldb::SBData SBValue::GetData() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBData, SBValue, GetData);
+ LLDB_INSTRUMENT_VA(this);
lldb::SBData sb_data;
ValueLocker locker;
@@ -1395,8 +1356,7 @@ lldb::SBData SBValue::GetData() {
}
bool SBValue::SetData(lldb::SBData &data, SBError &error) {
- LLDB_RECORD_METHOD(bool, SBValue, SetData, (lldb::SBData &, lldb::SBError &),
- data, error);
+ LLDB_INSTRUMENT_VA(this, data, error);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@@ -1430,7 +1390,7 @@ bool SBValue::SetData(lldb::SBData &data, SBError &error) {
}
lldb::SBValue SBValue::Clone(const char *new_name) {
- LLDB_RECORD_METHOD(lldb::SBValue, SBValue, Clone, (const char *), new_name);
+ LLDB_INSTRUMENT_VA(this, new_name);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@@ -1442,7 +1402,7 @@ lldb::SBValue SBValue::Clone(const char *new_name) {
}
lldb::SBDeclaration SBValue::GetDeclaration() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBDeclaration, SBValue, GetDeclaration);
+ LLDB_INSTRUMENT_VA(this);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@@ -1457,9 +1417,7 @@ lldb::SBDeclaration SBValue::GetDeclaration() {
lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read, bool write,
SBError &error) {
- LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBValue, Watch,
- (bool, bool, bool, lldb::SBError &), resolve_location,
- read, write, error);
+ LLDB_INSTRUMENT_VA(this, resolve_location, read, write, error);
SBWatchpoint sb_watchpoint;
@@ -1522,8 +1480,7 @@ lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read, bool write,
// Backward compatibility fix in the interim.
lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read,
bool write) {
- LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBValue, Watch, (bool, bool, bool),
- resolve_location, read, write);
+ LLDB_INSTRUMENT_VA(this, resolve_location, read, write);
SBError error;
return Watch(resolve_location, read, write, error);
@@ -1531,9 +1488,7 @@ lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read,
lldb::SBWatchpoint SBValue::WatchPointee(bool resolve_location, bool read,
bool write, SBError &error) {
- LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBValue, WatchPointee,
- (bool, bool, bool, lldb::SBError &), resolve_location,
- read, write, error);
+ LLDB_INSTRUMENT_VA(this, resolve_location, read, write, error);
SBWatchpoint sb_watchpoint;
if (IsInScope() && GetType().IsPointerType())
@@ -1542,7 +1497,7 @@ lldb::SBWatchpoint SBValue::WatchPointee(bool resolve_location, bool read,
}
lldb::SBValue SBValue::Persist() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, Persist);
+ LLDB_INSTRUMENT_VA(this);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
diff --git a/lldb/source/API/SBValueList.cpp b/lldb/source/API/SBValueList.cpp
index 797c615ce585..a67030c506f4 100644
--- a/lldb/source/API/SBValueList.cpp
+++ b/lldb/source/API/SBValueList.cpp
@@ -7,10 +7,10 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBValueList.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBValue.h"
#include "lldb/Core/ValueObjectList.h"
+#include "lldb/Utility/Instrumentation.h"
#include <vector>
@@ -67,10 +67,10 @@ class ValueListImpl {
std::vector<lldb::SBValue> m_values;
};
-SBValueList::SBValueList() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBValueList); }
+SBValueList::SBValueList() { LLDB_INSTRUMENT_VA(this); }
SBValueList::SBValueList(const SBValueList &rhs) {
- LLDB_RECORD_CONSTRUCTOR(SBValueList, (const lldb::SBValueList &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (rhs.IsValid())
m_opaque_up = std::make_unique<ValueListImpl>(*rhs);
@@ -84,24 +84,23 @@ SBValueList::SBValueList(const ValueListImpl *lldb_object_ptr) {
SBValueList::~SBValueList() = default;
bool SBValueList::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBValueList, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBValueList::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBValueList, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return (m_opaque_up != nullptr);
}
void SBValueList::Clear() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBValueList, Clear);
+ LLDB_INSTRUMENT_VA(this);
m_opaque_up.reset();
}
const SBValueList &SBValueList::operator=(const SBValueList &rhs) {
- LLDB_RECORD_METHOD(const lldb::SBValueList &,
- SBValueList, operator=,(const lldb::SBValueList &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
if (rhs.IsValid())
@@ -123,8 +122,7 @@ const ValueListImpl *SBValueList::operator->() const {
const ValueListImpl &SBValueList::operator*() const { return *m_opaque_up; }
void SBValueList::Append(const SBValue &val_obj) {
- LLDB_RECORD_METHOD(void, SBValueList, Append, (const lldb::SBValue &),
- val_obj);
+ LLDB_INSTRUMENT_VA(this, val_obj);
CreateIfNeeded();
m_opaque_up->Append(val_obj);
@@ -138,8 +136,7 @@ void SBValueList::Append(lldb::ValueObjectSP &val_obj_sp) {
}
void SBValueList::Append(const lldb::SBValueList &value_list) {
- LLDB_RECORD_METHOD(void, SBValueList, Append, (const lldb::SBValueList &),
- value_list);
+ LLDB_INSTRUMENT_VA(this, value_list);
if (value_list.IsValid()) {
CreateIfNeeded();
@@ -148,9 +145,7 @@ void SBValueList::Append(const lldb::SBValueList &value_list) {
}
SBValue SBValueList::GetValueAtIndex(uint32_t idx) const {
- LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValueList, GetValueAtIndex,
- (uint32_t), idx);
-
+ LLDB_INSTRUMENT_VA(this, idx);
SBValue sb_value;
if (m_opaque_up)
@@ -160,7 +155,7 @@ SBValue SBValueList::GetValueAtIndex(uint32_t idx) const {
}
uint32_t SBValueList::GetSize() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBValueList, GetSize);
+ LLDB_INSTRUMENT_VA(this);
uint32_t size = 0;
if (m_opaque_up)
@@ -175,8 +170,7 @@ void SBValueList::CreateIfNeeded() {
}
SBValue SBValueList::FindValueObjectByUID(lldb::user_id_t uid) {
- LLDB_RECORD_METHOD(lldb::SBValue, SBValueList, FindValueObjectByUID,
- (lldb::user_id_t), uid);
+ LLDB_INSTRUMENT_VA(this, uid);
SBValue sb_value;
if (m_opaque_up)
@@ -185,8 +179,7 @@ SBValue SBValueList::FindValueObjectByUID(lldb::user_id_t uid) {
}
SBValue SBValueList::GetFirstValueByName(const char *name) const {
- LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValueList, GetFirstValueByName,
- (const char *), name);
+ LLDB_INSTRUMENT_VA(this, name);
SBValue sb_value;
if (m_opaque_up)
diff --git a/lldb/source/API/SBVariablesOptions.cpp b/lldb/source/API/SBVariablesOptions.cpp
index 4057e283e2b2..989d159139cc 100644
--- a/lldb/source/API/SBVariablesOptions.cpp
+++ b/lldb/source/API/SBVariablesOptions.cpp
@@ -7,9 +7,9 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBVariablesOptions.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBTarget.h"
#include "lldb/Target/Target.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/lldb-private.h"
@@ -80,21 +80,17 @@ class VariablesOptionsImpl {
SBVariablesOptions::SBVariablesOptions()
: m_opaque_up(new VariablesOptionsImpl()) {
- LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBVariablesOptions);
+ LLDB_INSTRUMENT_VA(this);
}
SBVariablesOptions::SBVariablesOptions(const SBVariablesOptions &options)
: m_opaque_up(new VariablesOptionsImpl(options.ref())) {
- LLDB_RECORD_CONSTRUCTOR(SBVariablesOptions,
- (const lldb::SBVariablesOptions &), options);
+ LLDB_INSTRUMENT_VA(this, options);
}
SBVariablesOptions &SBVariablesOptions::
operator=(const SBVariablesOptions &options) {
- LLDB_RECORD_METHOD(
- lldb::SBVariablesOptions &,
- SBVariablesOptions, operator=,(const lldb::SBVariablesOptions &),
- options);
+ LLDB_INSTRUMENT_VA(this, options);
m_opaque_up = std::make_unique<VariablesOptionsImpl>(options.ref());
return *this;
@@ -103,109 +99,97 @@ operator=(const SBVariablesOptions &options) {
SBVariablesOptions::~SBVariablesOptions() = default;
bool SBVariablesOptions::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBVariablesOptions::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up != nullptr;
}
bool SBVariablesOptions::GetIncludeArguments() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions,
- GetIncludeArguments);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetIncludeArguments();
}
void SBVariablesOptions::SetIncludeArguments(bool arguments) {
- LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeArguments, (bool),
- arguments);
+ LLDB_INSTRUMENT_VA(this, arguments);
m_opaque_up->SetIncludeArguments(arguments);
}
bool SBVariablesOptions::GetIncludeRecognizedArguments(
const lldb::SBTarget &target) const {
- LLDB_RECORD_METHOD_CONST(bool, SBVariablesOptions,
- GetIncludeRecognizedArguments,
- (const lldb::SBTarget &), target);
+ LLDB_INSTRUMENT_VA(this, target);
return m_opaque_up->GetIncludeRecognizedArguments(target.GetSP());
}
void SBVariablesOptions::SetIncludeRecognizedArguments(bool arguments) {
- LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeRecognizedArguments,
- (bool), arguments);
+ LLDB_INSTRUMENT_VA(this, arguments);
m_opaque_up->SetIncludeRecognizedArguments(arguments);
}
bool SBVariablesOptions::GetIncludeLocals() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, GetIncludeLocals);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetIncludeLocals();
}
void SBVariablesOptions::SetIncludeLocals(bool locals) {
- LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeLocals, (bool),
- locals);
+ LLDB_INSTRUMENT_VA(this, locals);
m_opaque_up->SetIncludeLocals(locals);
}
bool SBVariablesOptions::GetIncludeStatics() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, GetIncludeStatics);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetIncludeStatics();
}
void SBVariablesOptions::SetIncludeStatics(bool statics) {
- LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeStatics, (bool),
- statics);
+ LLDB_INSTRUMENT_VA(this, statics);
m_opaque_up->SetIncludeStatics(statics);
}
bool SBVariablesOptions::GetInScopeOnly() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, GetInScopeOnly);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetInScopeOnly();
}
void SBVariablesOptions::SetInScopeOnly(bool in_scope_only) {
- LLDB_RECORD_METHOD(void, SBVariablesOptions, SetInScopeOnly, (bool),
- in_scope_only);
+ LLDB_INSTRUMENT_VA(this, in_scope_only);
m_opaque_up->SetInScopeOnly(in_scope_only);
}
bool SBVariablesOptions::GetIncludeRuntimeSupportValues() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions,
- GetIncludeRuntimeSupportValues);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetIncludeRuntimeSupportValues();
}
void SBVariablesOptions::SetIncludeRuntimeSupportValues(
bool runtime_support_values) {
- LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeRuntimeSupportValues,
- (bool), runtime_support_values);
+ LLDB_INSTRUMENT_VA(this, runtime_support_values);
m_opaque_up->SetIncludeRuntimeSupportValues(runtime_support_values);
}
lldb::DynamicValueType SBVariablesOptions::GetUseDynamic() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::DynamicValueType, SBVariablesOptions,
- GetUseDynamic);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetUseDynamic();
}
void SBVariablesOptions::SetUseDynamic(lldb::DynamicValueType dynamic) {
- LLDB_RECORD_METHOD(void, SBVariablesOptions, SetUseDynamic,
- (lldb::DynamicValueType), dynamic);
+ LLDB_INSTRUMENT_VA(this, dynamic);
m_opaque_up->SetUseDynamic(dynamic);
}
diff --git a/lldb/source/API/SBWatchpoint.cpp b/lldb/source/API/SBWatchpoint.cpp
index 207141f5dca6..f5bd9cd1a946 100644
--- a/lldb/source/API/SBWatchpoint.cpp
+++ b/lldb/source/API/SBWatchpoint.cpp
@@ -7,12 +7,12 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBWatchpoint.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBDefines.h"
#include "lldb/API/SBEvent.h"
#include "lldb/API/SBStream.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/Breakpoint/Watchpoint.h"
#include "lldb/Breakpoint/WatchpointList.h"
@@ -26,21 +26,20 @@
using namespace lldb;
using namespace lldb_private;
-SBWatchpoint::SBWatchpoint() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBWatchpoint); }
+SBWatchpoint::SBWatchpoint() { LLDB_INSTRUMENT_VA(this); }
SBWatchpoint::SBWatchpoint(const lldb::WatchpointSP &wp_sp)
: m_opaque_wp(wp_sp) {
- LLDB_RECORD_CONSTRUCTOR(SBWatchpoint, (const lldb::WatchpointSP &), wp_sp);
+ LLDB_INSTRUMENT_VA(this, wp_sp);
}
SBWatchpoint::SBWatchpoint(const SBWatchpoint &rhs)
: m_opaque_wp(rhs.m_opaque_wp) {
- LLDB_RECORD_CONSTRUCTOR(SBWatchpoint, (const lldb::SBWatchpoint &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
}
const SBWatchpoint &SBWatchpoint::operator=(const SBWatchpoint &rhs) {
- LLDB_RECORD_METHOD(const lldb::SBWatchpoint &,
- SBWatchpoint, operator=,(const lldb::SBWatchpoint &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_wp = rhs.m_opaque_wp;
return *this;
@@ -49,8 +48,7 @@ const SBWatchpoint &SBWatchpoint::operator=(const SBWatchpoint &rhs) {
SBWatchpoint::~SBWatchpoint() = default;
watch_id_t SBWatchpoint::GetID() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::watch_id_t, SBWatchpoint, GetID);
-
+ LLDB_INSTRUMENT_VA(this);
watch_id_t watch_id = LLDB_INVALID_WATCH_ID;
lldb::WatchpointSP watchpoint_sp(GetSP());
@@ -61,31 +59,29 @@ watch_id_t SBWatchpoint::GetID() {
}
bool SBWatchpoint::IsValid() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBWatchpoint, IsValid);
+ LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBWatchpoint::operator bool() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBWatchpoint, operator bool);
+ LLDB_INSTRUMENT_VA(this);
return bool(m_opaque_wp.lock());
}
bool SBWatchpoint::operator==(const SBWatchpoint &rhs) const {
- LLDB_RECORD_METHOD_CONST(
- bool, SBWatchpoint, operator==,(const SBWatchpoint &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
return GetSP() == rhs.GetSP();
}
bool SBWatchpoint::operator!=(const SBWatchpoint &rhs) const {
- LLDB_RECORD_METHOD_CONST(
- bool, SBWatchpoint, operator!=,(const SBWatchpoint &), rhs);
+ LLDB_INSTRUMENT_VA(this, rhs);
return !(*this == rhs);
}
SBError SBWatchpoint::GetError() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBWatchpoint, GetError);
+ LLDB_INSTRUMENT_VA(this);
SBError sb_error;
lldb::WatchpointSP watchpoint_sp(GetSP());
@@ -96,7 +92,7 @@ SBError SBWatchpoint::GetError() {
}
int32_t SBWatchpoint::GetHardwareIndex() {
- LLDB_RECORD_METHOD_NO_ARGS(int32_t, SBWatchpoint, GetHardwareIndex);
+ LLDB_INSTRUMENT_VA(this);
int32_t hw_index = -1;
@@ -111,7 +107,7 @@ int32_t SBWatchpoint::GetHardwareIndex() {
}
addr_t SBWatchpoint::GetWatchAddress() {
- LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBWatchpoint, GetWatchAddress);
+ LLDB_INSTRUMENT_VA(this);
addr_t ret_addr = LLDB_INVALID_ADDRESS;
@@ -126,7 +122,7 @@ addr_t SBWatchpoint::GetWatchAddress() {
}
size_t SBWatchpoint::GetWatchSize() {
- LLDB_RECORD_METHOD_NO_ARGS(size_t, SBWatchpoint, GetWatchSize);
+ LLDB_INSTRUMENT_VA(this);
size_t watch_size = 0;
@@ -141,7 +137,7 @@ size_t SBWatchpoint::GetWatchSize() {
}
void SBWatchpoint::SetEnabled(bool enabled) {
- LLDB_RECORD_METHOD(void, SBWatchpoint, SetEnabled, (bool), enabled);
+ LLDB_INSTRUMENT_VA(this, enabled);
lldb::WatchpointSP watchpoint_sp(GetSP());
if (watchpoint_sp) {
@@ -161,7 +157,7 @@ void SBWatchpoint::SetEnabled(bool enabled) {
}
bool SBWatchpoint::IsEnabled() {
- LLDB_RECORD_METHOD_NO_ARGS(bool, SBWatchpoint, IsEnabled);
+ LLDB_INSTRUMENT_VA(this);
lldb::WatchpointSP watchpoint_sp(GetSP());
if (watchpoint_sp) {
@@ -173,7 +169,7 @@ bool SBWatchpoint::IsEnabled() {
}
uint32_t SBWatchpoint::GetHitCount() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBWatchpoint, GetHitCount);
+ LLDB_INSTRUMENT_VA(this);
uint32_t count = 0;
lldb::WatchpointSP watchpoint_sp(GetSP());
@@ -187,7 +183,7 @@ uint32_t SBWatchpoint::GetHitCount() {
}
uint32_t SBWatchpoint::GetIgnoreCount() {
- LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBWatchpoint, GetIgnoreCount);
+ LLDB_INSTRUMENT_VA(this);
lldb::WatchpointSP watchpoint_sp(GetSP());
if (watchpoint_sp) {
@@ -199,7 +195,7 @@ uint32_t SBWatchpoint::GetIgnoreCount() {
}
void SBWatchpoint::SetIgnoreCount(uint32_t n) {
- LLDB_RECORD_METHOD(void, SBWatchpoint, SetIgnoreCount, (uint32_t), n);
+ LLDB_INSTRUMENT_VA(this, n);
lldb::WatchpointSP watchpoint_sp(GetSP());
if (watchpoint_sp) {
@@ -210,7 +206,7 @@ void SBWatchpoint::SetIgnoreCount(uint32_t n) {
}
const char *SBWatchpoint::GetCondition() {
- LLDB_RECORD_METHOD_NO_ARGS(const char *, SBWatchpoint, GetCondition);
+ LLDB_INSTRUMENT_VA(this);
lldb::WatchpointSP watchpoint_sp(GetSP());
if (watchpoint_sp) {
@@ -222,8 +218,7 @@ const char *SBWatchpoint::GetCondition() {
}
void SBWatchpoint::SetCondition(const char *condition) {
- LLDB_RECORD_METHOD(void, SBWatchpoint, SetCondition, (const char *),
- condition);
+ LLDB_INSTRUMENT_VA(this, condition);
lldb::WatchpointSP watchpoint_sp(GetSP());
if (watchpoint_sp) {
@@ -235,9 +230,7 @@ void SBWatchpoint::SetCondition(const char *condition) {
bool SBWatchpoint::GetDescription(SBStream &description,
DescriptionLevel level) {
- LLDB_RECORD_METHOD(bool, SBWatchpoint, GetDescription,
- (lldb::SBStream &, lldb::DescriptionLevel), description,
- level);
+ LLDB_INSTRUMENT_VA(this, description, level);
Stream &strm = description.ref();
@@ -254,27 +247,25 @@ bool SBWatchpoint::GetDescription(SBStream &description,
}
void SBWatchpoint::Clear() {
- LLDB_RECORD_METHOD_NO_ARGS(void, SBWatchpoint, Clear);
+ LLDB_INSTRUMENT_VA(this);
m_opaque_wp.reset();
}
lldb::WatchpointSP SBWatchpoint::GetSP() const {
- LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::WatchpointSP, SBWatchpoint, GetSP);
+ LLDB_INSTRUMENT_VA(this);
return m_opaque_wp.lock();
}
void SBWatchpoint::SetSP(const lldb::WatchpointSP &sp) {
- LLDB_RECORD_METHOD(void, SBWatchpoint, SetSP, (const lldb::WatchpointSP &),
- sp);
+ LLDB_INSTRUMENT_VA(this, sp);
m_opaque_wp = sp;
}
bool SBWatchpoint::EventIsWatchpointEvent(const lldb::SBEvent &event) {
- LLDB_RECORD_STATIC_METHOD(bool, SBWatchpoint, EventIsWatchpointEvent,
- (const lldb::SBEvent &), event);
+ LLDB_INSTRUMENT_VA(event);
return Watchpoint::WatchpointEventData::GetEventDataFromEvent(event.get()) !=
nullptr;
@@ -282,9 +273,7 @@ bool SBWatchpoint::EventIsWatchpointEvent(const lldb::SBEvent &event) {
WatchpointEventType
SBWatchpoint::GetWatchpointEventTypeFromEvent(const SBEvent &event) {
- LLDB_RECORD_STATIC_METHOD(lldb::WatchpointEventType, SBWatchpoint,
- GetWatchpointEventTypeFromEvent,
- (const lldb::SBEvent &), event);
+ LLDB_INSTRUMENT_VA(event);
if (event.IsValid())
return Watchpoint::WatchpointEventData::GetWatchpointEventTypeFromEvent(
@@ -293,9 +282,7 @@ SBWatchpoint::GetWatchpointEventTypeFromEvent(const SBEvent &event) {
}
SBWatchpoint SBWatchpoint::GetWatchpointFromEvent(const lldb::SBEvent &event) {
- LLDB_RECORD_STATIC_METHOD(lldb::SBWatchpoint, SBWatchpoint,
- GetWatchpointFromEvent, (const lldb::SBEvent &),
- event);
+ LLDB_INSTRUMENT_VA(event);
SBWatchpoint sb_watchpoint;
if (event.IsValid())
diff --git a/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp b/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp
index 80e986f18c61..1bf647e4acfc 100644
--- a/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp
+++ b/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp
@@ -37,7 +37,7 @@
#include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadPlan.h"
-#include "lldb/Utility/ReproducerInstrumentation.h"
+#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/Timer.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/StringRef.h"
diff --git a/lldb/source/Utility/CMakeLists.txt b/lldb/source/Utility/CMakeLists.txt
index 6790e47d69f2..cc0bf5fdb61a 100644
--- a/lldb/source/Utility/CMakeLists.txt
+++ b/lldb/source/Utility/CMakeLists.txt
@@ -49,7 +49,7 @@ add_lldb_library(lldbUtility
RegisterValue.cpp
RegularExpression.cpp
Reproducer.cpp
- ReproducerInstrumentation.cpp
+ Instrumentation.cpp
ReproducerProvider.cpp
Scalar.cpp
SelectHelper.cpp
diff --git a/lldb/source/Utility/ReproducerInstrumentation.cpp b/lldb/source/Utility/Instrumentation.cpp
similarity index 52%
rename from lldb/source/Utility/ReproducerInstrumentation.cpp
rename to lldb/source/Utility/Instrumentation.cpp
index 8365701f8e3b..d375fcea58c0 100644
--- a/lldb/source/Utility/ReproducerInstrumentation.cpp
+++ b/lldb/source/Utility/Instrumentation.cpp
@@ -1,46 +1,37 @@
-//===-- ReproducerInstrumentation.cpp -------------------------------------===//
-//
+//===-- Instrumentation.cpp -----------------------------------------------===//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
-#include "lldb/Utility/ReproducerInstrumentation.h"
-#include "lldb/Utility/Reproducer.h"
+#include "lldb/Utility/Instrumentation.h"
#include <cstdio>
#include <cstdlib>
#include <limits>
#include <thread>
using namespace lldb_private;
-using namespace lldb_private::repro;
+using namespace lldb_private::instrumentation;
// Whether we're currently across the API boundary.
static thread_local bool g_global_boundary = false;
-Recorder::Recorder() {
- if (!g_global_boundary) {
- g_global_boundary = true;
- m_local_boundary = true;
- }
-}
-
-Recorder::Recorder(llvm::StringRef pretty_func, std::string &&pretty_args)
- : m_local_boundary(false) {
+Instrumenter::Instrumenter(llvm::StringRef pretty_func,
+ std::string &&pretty_args)
+ : m_local_boundary(false) {
if (!g_global_boundary) {
g_global_boundary = true;
m_local_boundary = true;
- LLDB_LOG(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API), "{0} ({1})",
- pretty_func, pretty_args);
}
+ LLDB_LOG(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API), "[{0}] {1} ({2})",
+ m_local_boundary ? "external" : "internal", pretty_func,
+ pretty_args);
}
-Recorder::~Recorder() {
- UpdateBoundary();
-}
+Instrumenter::~Instrumenter() { UpdateBoundary(); }
-void Recorder::UpdateBoundary() {
+void Instrumenter::UpdateBoundary() {
if (m_local_boundary)
g_global_boundary = false;
}
More information about the lldb-commits
mailing list