Index: lldb/include/lldb/Utility/Instrumentation.h =================================================================== --- /dev/null +++ lldb/include/lldb/Utility/Instrumentation.h @@ -0,0 +1,130 @@ +//===-- 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 +#include +#include + +template ::value, int>::type = 0> +inline void stringify_append(llvm::raw_string_ostream &ss, const T &t) { + ss << t; +} + +template ::value, + int>::type = 0> +inline void stringify_append(llvm::raw_string_ostream &ss, const T &t) { + ss << &t; +} + +template +inline void stringify_append(llvm::raw_string_ostream &ss, T *t) { + ss << reinterpret_cast(t); +} + +template +inline void stringify_append(llvm::raw_string_ostream &ss, const T *t) { + ss << reinterpret_cast(t); +} + +template <> +inline void stringify_append(llvm::raw_string_ostream &ss, + const char *t) { + ss << '\"' << t << '\"'; +} + +template <> +inline void stringify_append(llvm::raw_string_ostream &ss, + const std::nullptr_t &t) { + ss << "\"nullptr\""; +} + +template +inline void stringify_helper(llvm::raw_string_ostream &ss, const Head &head) { + stringify_append(ss, head); +} + +template +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 inline std::string stringify_args(const Ts &...ts) { + std::string buffer; + llvm::raw_string_ostream ss(buffer); + stringify_helper(ss, ts...); + return ss.str(); +} + +namespace lldb_private { +/// RAII object for instrumenting LLDB API functions. +class Instrumenter { +public: + Instrumenter(); + Instrumenter(llvm::StringRef pretty_func, std::string &&pretty_args = {}); + ~Instrumenter(); + + struct EmptyArg {}; + +private: + void UpdateBoundary(); + + /// Whether this function call was the one crossing the API boundary. + bool m_local_boundary = false; +}; +} // namespace lldb_private + +#define LLDB_API_CONSTRUCT_HELPER(T, Class, ...) \ + lldb_private::Instrumenter _recorder(LLVM_PRETTY_FUNCTION); + +#define LLDB_INSTRUMENT_CONSTRUCTOR(Class, Signature, ...) \ + LLDB_API_CONSTRUCT_HELPER(Class Signature, this, __VA_ARGS__) + +#define LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(Class) \ + LLDB_API_CONSTRUCT_HELPER(Class(), this, \ + lldb_private::Instrumenter::EmptyArg()) + +#define LLDB_API_METHOD_HELPER(T1, T2, ...) \ + lldb_private::Instrumenter _recorder(LLVM_PRETTY_FUNCTION, \ + stringify_args(__VA_ARGS__)); + +#define LLDB_INSTRUMENT_METHOD(Result, Class, Method, Signature, ...) \ + LLDB_API_METHOD_HELPER(Result(Class::*) Signature, (&Class::Method), this, \ + __VA_ARGS__) + +#define LLDB_INSTRUMENT_METHOD_CONST(Result, Class, Method, Signature, ...) \ + LLDB_API_METHOD_HELPER(Result(Class::*) Signature const, (&Class::Method), \ + this, __VA_ARGS__) + +#define LLDB_INSTRUMENT_METHOD_NO_ARGS(Result, Class, Method) \ + LLDB_API_METHOD_HELPER(Result (Class::*)(), (&Class::Method), this) + +#define LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(Result, Class, Method) \ + LLDB_API_METHOD_HELPER(Result (Class::*)() const, (&Class::Method), this) + +#define LLDB_INSTRUMENT_STATIC_METHOD(Result, Class, Method, Signature, ...) \ + LLDB_API_METHOD_HELPER(Result(*) Signature, (&Class::Method), __VA_ARGS__) + +#define LLDB_INSTRUMENT_STATIC_METHOD_NO_ARGS(Result, Class, Method) \ + LLDB_API_METHOD_HELPER(Result (*)(), (&Class::Method), \ + lldb_private::Instrumenter::EmptyArg()) + +#endif // LLDB_UTILITY_INSTRUMENTATION_H Index: lldb/include/lldb/Utility/ReproducerInstrumentation.h =================================================================== --- lldb/include/lldb/Utility/ReproducerInstrumentation.h +++ /dev/null @@ -1,142 +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 -#include -#include - -template ::value, int>::type = 0> -inline void stringify_append(llvm::raw_string_ostream &ss, const T &t) { - ss << t; -} - -template ::value, - int>::type = 0> -inline void stringify_append(llvm::raw_string_ostream &ss, const T &t) { - ss << &t; -} - -template -inline void stringify_append(llvm::raw_string_ostream &ss, T *t) { - ss << reinterpret_cast(t); -} - -template -inline void stringify_append(llvm::raw_string_ostream &ss, const T *t) { - ss << reinterpret_cast(t); -} - -template <> -inline void stringify_append(llvm::raw_string_ostream &ss, - const char *t) { - ss << '\"' << t << '\"'; -} - -template <> -inline void stringify_append(llvm::raw_string_ostream &ss, - const std::nullptr_t &t) { - ss << "\"nullptr\""; -} - -template -inline void stringify_helper(llvm::raw_string_ostream &ss, const Head &head) { - stringify_append(ss, head); -} - -template -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 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()) - -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 Index: lldb/source/API/SBAddress.cpp =================================================================== --- lldb/source/API/SBAddress.cpp +++ 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,36 @@ #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_CONSTRUCTOR_NO_ARGS(SBAddress); } SBAddress::SBAddress(const Address &address) : m_opaque_up(std::make_unique
(address)) {} SBAddress::SBAddress(const SBAddress &rhs) : m_opaque_up(new Address()) { - LLDB_RECORD_CONSTRUCTOR(SBAddress, (const lldb::SBAddress &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBAddress, (const lldb::SBAddress &), rhs); m_opaque_up = clone(rhs.m_opaque_up); } SBAddress::SBAddress(lldb::SBSection section, lldb::addr_t offset) : m_opaque_up(new Address(section.GetSP(), offset)) { - LLDB_RECORD_CONSTRUCTOR(SBAddress, (lldb::SBSection, lldb::addr_t), section, - offset); + LLDB_INSTRUMENT_CONSTRUCTOR(SBAddress, (lldb::SBSection, lldb::addr_t), + section, offset); } // Create an address by resolving a load address using the supplied target SBAddress::SBAddress(lldb::addr_t load_addr, lldb::SBTarget &target) : m_opaque_up(new Address()) { - LLDB_RECORD_CONSTRUCTOR(SBAddress, (lldb::addr_t, lldb::SBTarget &), - load_addr, target); + LLDB_INSTRUMENT_CONSTRUCTOR(SBAddress, (lldb::addr_t, lldb::SBTarget &), + load_addr, target); SetLoadAddress(load_addr, target); } @@ -52,8 +52,8 @@ SBAddress::~SBAddress() = default; const SBAddress &SBAddress::operator=(const SBAddress &rhs) { - LLDB_RECORD_METHOD(const lldb::SBAddress &, - SBAddress, operator=,(const lldb::SBAddress &), rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBAddress &, SBAddress, operator=, + (const lldb::SBAddress &), rhs); if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); @@ -67,31 +67,31 @@ } bool SBAddress::operator!=(const SBAddress &rhs) const { - LLDB_RECORD_METHOD_CONST(bool, SBAddress, operator!=,(const SBAddress &), - &rhs); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBAddress, operator!=, (const SBAddress &), + &rhs); return !(*this == rhs); } bool SBAddress::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBAddress, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBAddress, IsValid); return this->operator bool(); } SBAddress::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBAddress, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBAddress, operator bool); return m_opaque_up != nullptr && m_opaque_up->IsValid(); } void SBAddress::Clear() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBAddress, Clear); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBAddress, Clear); m_opaque_up = std::make_unique
(); } 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_METHOD(void, SBAddress, SetAddress, + (lldb::SBSection, lldb::addr_t), section, offset); Address &addr = ref(); addr.SetSection(section.GetSP()); @@ -101,7 +101,7 @@ 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_METHOD_CONST_NO_ARGS(lldb::addr_t, SBAddress, GetFileAddress); if (m_opaque_up->IsValid()) return m_opaque_up->GetFileAddress(); @@ -110,8 +110,8 @@ } lldb::addr_t SBAddress::GetLoadAddress(const SBTarget &target) const { - LLDB_RECORD_METHOD_CONST(lldb::addr_t, SBAddress, GetLoadAddress, - (const lldb::SBTarget &), target); + LLDB_INSTRUMENT_METHOD_CONST(lldb::addr_t, SBAddress, GetLoadAddress, + (const lldb::SBTarget &), target); lldb::addr_t addr = LLDB_INVALID_ADDRESS; TargetSP target_sp(target.GetSP()); @@ -126,8 +126,8 @@ } 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_METHOD(void, SBAddress, SetLoadAddress, + (lldb::addr_t, lldb::SBTarget &), load_addr, target); // Create the address object if we don't already have one ref(); @@ -144,7 +144,8 @@ } bool SBAddress::OffsetAddress(addr_t offset) { - LLDB_RECORD_METHOD(bool, SBAddress, OffsetAddress, (lldb::addr_t), offset); + LLDB_INSTRUMENT_METHOD(bool, SBAddress, OffsetAddress, (lldb::addr_t), + offset); if (m_opaque_up->IsValid()) { addr_t addr_offset = m_opaque_up->GetOffset(); @@ -157,7 +158,7 @@ } lldb::SBSection SBAddress::GetSection() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSection, SBAddress, GetSection); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBSection, SBAddress, GetSection); lldb::SBSection sb_section; if (m_opaque_up->IsValid()) @@ -166,7 +167,7 @@ } lldb::addr_t SBAddress::GetOffset() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBAddress, GetOffset); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::addr_t, SBAddress, GetOffset); if (m_opaque_up->IsValid()) return m_opaque_up->GetOffset(); @@ -193,8 +194,8 @@ Address *SBAddress::get() { return m_opaque_up.get(); } bool SBAddress::GetDescription(SBStream &description) { - LLDB_RECORD_METHOD(bool, SBAddress, GetDescription, (lldb::SBStream &), - description); + LLDB_INSTRUMENT_METHOD(bool, SBAddress, GetDescription, (lldb::SBStream &), + description); // Call "ref()" on the stream to make sure it creates a backing stream in // case there isn't one already... @@ -209,7 +210,7 @@ } SBModule SBAddress::GetModule() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBModule, SBAddress, GetModule); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBModule, SBAddress, GetModule); SBModule sb_module; if (m_opaque_up->IsValid()) @@ -218,8 +219,8 @@ } SBSymbolContext SBAddress::GetSymbolContext(uint32_t resolve_scope) { - LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBAddress, GetSymbolContext, - (uint32_t), resolve_scope); + LLDB_INSTRUMENT_METHOD(lldb::SBSymbolContext, SBAddress, GetSymbolContext, + (uint32_t), resolve_scope); SBSymbolContext sb_sc; SymbolContextItem scope = static_cast(resolve_scope); @@ -229,7 +230,8 @@ } SBCompileUnit SBAddress::GetCompileUnit() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCompileUnit, SBAddress, GetCompileUnit); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBCompileUnit, SBAddress, + GetCompileUnit); SBCompileUnit sb_comp_unit; if (m_opaque_up->IsValid()) @@ -238,7 +240,7 @@ } SBFunction SBAddress::GetFunction() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFunction, SBAddress, GetFunction); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBFunction, SBAddress, GetFunction); SBFunction sb_function; if (m_opaque_up->IsValid()) @@ -247,7 +249,7 @@ } SBBlock SBAddress::GetBlock() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBAddress, GetBlock); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBBlock, SBAddress, GetBlock); SBBlock sb_block; if (m_opaque_up->IsValid()) @@ -256,7 +258,7 @@ } SBSymbol SBAddress::GetSymbol() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSymbol, SBAddress, GetSymbol); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBSymbol, SBAddress, GetSymbol); SBSymbol sb_symbol; if (m_opaque_up->IsValid()) @@ -265,7 +267,7 @@ } SBLineEntry SBAddress::GetLineEntry() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBLineEntry, SBAddress, GetLineEntry); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBLineEntry, SBAddress, GetLineEntry); SBLineEntry sb_line_entry; if (m_opaque_up->IsValid()) { Index: lldb/source/API/SBAttachInfo.cpp =================================================================== --- lldb/source/API/SBAttachInfo.cpp +++ lldb/source/API/SBAttachInfo.cpp @@ -7,29 +7,30 @@ //===----------------------------------------------------------------------===// #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_CONSTRUCTOR_NO_ARGS(SBAttachInfo); } SBAttachInfo::SBAttachInfo(lldb::pid_t pid) : m_opaque_sp(new ProcessAttachInfo()) { - LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (lldb::pid_t), pid); + LLDB_INSTRUMENT_CONSTRUCTOR(SBAttachInfo, (lldb::pid_t), pid); m_opaque_sp->SetProcessID(pid); } SBAttachInfo::SBAttachInfo(const char *path, bool wait_for) : m_opaque_sp(new ProcessAttachInfo()) { - LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (const char *, bool), path, wait_for); + LLDB_INSTRUMENT_CONSTRUCTOR(SBAttachInfo, (const char *, bool), path, + wait_for); if (path && path[0]) m_opaque_sp->GetExecutableFile().SetFile(path, FileSpec::Style::native); @@ -38,8 +39,8 @@ 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_CONSTRUCTOR(SBAttachInfo, (const char *, bool, bool), path, + wait_for, async); if (path && path[0]) m_opaque_sp->GetExecutableFile().SetFile(path, FileSpec::Style::native); @@ -49,7 +50,7 @@ SBAttachInfo::SBAttachInfo(const SBAttachInfo &rhs) : m_opaque_sp(new ProcessAttachInfo()) { - LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (const lldb::SBAttachInfo &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBAttachInfo, (const lldb::SBAttachInfo &), rhs); m_opaque_sp = clone(rhs.m_opaque_sp); } @@ -59,8 +60,8 @@ 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_METHOD(lldb::SBAttachInfo &, SBAttachInfo, operator=, + (const lldb::SBAttachInfo &), rhs); if (this != &rhs) m_opaque_sp = clone(rhs.m_opaque_sp); @@ -68,44 +69,46 @@ } lldb::pid_t SBAttachInfo::GetProcessID() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBAttachInfo, GetProcessID); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::pid_t, SBAttachInfo, GetProcessID); return m_opaque_sp->GetProcessID(); } void SBAttachInfo::SetProcessID(lldb::pid_t pid) { - LLDB_RECORD_METHOD(void, SBAttachInfo, SetProcessID, (lldb::pid_t), pid); + LLDB_INSTRUMENT_METHOD(void, SBAttachInfo, SetProcessID, (lldb::pid_t), pid); m_opaque_sp->SetProcessID(pid); } uint32_t SBAttachInfo::GetResumeCount() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetResumeCount); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetResumeCount); return m_opaque_sp->GetResumeCount(); } void SBAttachInfo::SetResumeCount(uint32_t c) { - LLDB_RECORD_METHOD(void, SBAttachInfo, SetResumeCount, (uint32_t), c); + LLDB_INSTRUMENT_METHOD(void, SBAttachInfo, SetResumeCount, (uint32_t), c); m_opaque_sp->SetResumeCount(c); } const char *SBAttachInfo::GetProcessPluginName() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBAttachInfo, GetProcessPluginName); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBAttachInfo, + GetProcessPluginName); return m_opaque_sp->GetProcessPluginName(); } void SBAttachInfo::SetProcessPluginName(const char *plugin_name) { - LLDB_RECORD_METHOD(void, SBAttachInfo, SetProcessPluginName, (const char *), - plugin_name); + LLDB_INSTRUMENT_METHOD(void, SBAttachInfo, SetProcessPluginName, + (const char *), plugin_name); return m_opaque_sp->SetProcessPluginName(plugin_name); } void SBAttachInfo::SetExecutable(const char *path) { - LLDB_RECORD_METHOD(void, SBAttachInfo, SetExecutable, (const char *), path); + LLDB_INSTRUMENT_METHOD(void, SBAttachInfo, SetExecutable, (const char *), + path); if (path && path[0]) m_opaque_sp->GetExecutableFile().SetFile(path, FileSpec::Style::native); @@ -114,8 +117,8 @@ } void SBAttachInfo::SetExecutable(SBFileSpec exe_file) { - LLDB_RECORD_METHOD(void, SBAttachInfo, SetExecutable, (lldb::SBFileSpec), - exe_file); + LLDB_INSTRUMENT_METHOD(void, SBAttachInfo, SetExecutable, (lldb::SBFileSpec), + exe_file); if (exe_file.IsValid()) m_opaque_sp->GetExecutableFile() = exe_file.ref(); @@ -124,137 +127,139 @@ } bool SBAttachInfo::GetWaitForLaunch() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, GetWaitForLaunch); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBAttachInfo, GetWaitForLaunch); return m_opaque_sp->GetWaitForLaunch(); } void SBAttachInfo::SetWaitForLaunch(bool b) { - LLDB_RECORD_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool), b); + LLDB_INSTRUMENT_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool), b); m_opaque_sp->SetWaitForLaunch(b); } void SBAttachInfo::SetWaitForLaunch(bool b, bool async) { - LLDB_RECORD_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool, bool), b, - async); + LLDB_INSTRUMENT_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool, bool), b, + async); m_opaque_sp->SetWaitForLaunch(b); m_opaque_sp->SetAsync(async); } bool SBAttachInfo::GetIgnoreExisting() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, GetIgnoreExisting); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBAttachInfo, GetIgnoreExisting); return m_opaque_sp->GetIgnoreExisting(); } void SBAttachInfo::SetIgnoreExisting(bool b) { - LLDB_RECORD_METHOD(void, SBAttachInfo, SetIgnoreExisting, (bool), b); + LLDB_INSTRUMENT_METHOD(void, SBAttachInfo, SetIgnoreExisting, (bool), b); m_opaque_sp->SetIgnoreExisting(b); } uint32_t SBAttachInfo::GetUserID() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetUserID); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetUserID); return m_opaque_sp->GetUserID(); } uint32_t SBAttachInfo::GetGroupID() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetGroupID); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetGroupID); return m_opaque_sp->GetGroupID(); } bool SBAttachInfo::UserIDIsValid() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, UserIDIsValid); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBAttachInfo, UserIDIsValid); return m_opaque_sp->UserIDIsValid(); } bool SBAttachInfo::GroupIDIsValid() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, GroupIDIsValid); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBAttachInfo, GroupIDIsValid); return m_opaque_sp->GroupIDIsValid(); } void SBAttachInfo::SetUserID(uint32_t uid) { - LLDB_RECORD_METHOD(void, SBAttachInfo, SetUserID, (uint32_t), uid); + LLDB_INSTRUMENT_METHOD(void, SBAttachInfo, SetUserID, (uint32_t), uid); m_opaque_sp->SetUserID(uid); } void SBAttachInfo::SetGroupID(uint32_t gid) { - LLDB_RECORD_METHOD(void, SBAttachInfo, SetGroupID, (uint32_t), gid); + LLDB_INSTRUMENT_METHOD(void, SBAttachInfo, SetGroupID, (uint32_t), gid); m_opaque_sp->SetGroupID(gid); } uint32_t SBAttachInfo::GetEffectiveUserID() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetEffectiveUserID); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetEffectiveUserID); return m_opaque_sp->GetEffectiveUserID(); } uint32_t SBAttachInfo::GetEffectiveGroupID() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetEffectiveGroupID); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetEffectiveGroupID); return m_opaque_sp->GetEffectiveGroupID(); } bool SBAttachInfo::EffectiveUserIDIsValid() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, EffectiveUserIDIsValid); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBAttachInfo, EffectiveUserIDIsValid); return m_opaque_sp->EffectiveUserIDIsValid(); } bool SBAttachInfo::EffectiveGroupIDIsValid() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, EffectiveGroupIDIsValid); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBAttachInfo, EffectiveGroupIDIsValid); return m_opaque_sp->EffectiveGroupIDIsValid(); } void SBAttachInfo::SetEffectiveUserID(uint32_t uid) { - LLDB_RECORD_METHOD(void, SBAttachInfo, SetEffectiveUserID, (uint32_t), uid); + LLDB_INSTRUMENT_METHOD(void, SBAttachInfo, SetEffectiveUserID, (uint32_t), + uid); m_opaque_sp->SetEffectiveUserID(uid); } void SBAttachInfo::SetEffectiveGroupID(uint32_t gid) { - LLDB_RECORD_METHOD(void, SBAttachInfo, SetEffectiveGroupID, (uint32_t), gid); + LLDB_INSTRUMENT_METHOD(void, SBAttachInfo, SetEffectiveGroupID, (uint32_t), + gid); m_opaque_sp->SetEffectiveGroupID(gid); } lldb::pid_t SBAttachInfo::GetParentProcessID() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBAttachInfo, GetParentProcessID); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::pid_t, SBAttachInfo, GetParentProcessID); return m_opaque_sp->GetParentProcessID(); } void SBAttachInfo::SetParentProcessID(lldb::pid_t pid) { - LLDB_RECORD_METHOD(void, SBAttachInfo, SetParentProcessID, (lldb::pid_t), - pid); + LLDB_INSTRUMENT_METHOD(void, SBAttachInfo, SetParentProcessID, (lldb::pid_t), + pid); m_opaque_sp->SetParentProcessID(pid); } bool SBAttachInfo::ParentProcessIDIsValid() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, ParentProcessIDIsValid); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBAttachInfo, ParentProcessIDIsValid); return m_opaque_sp->ParentProcessIDIsValid(); } SBListener SBAttachInfo::GetListener() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBAttachInfo, GetListener); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBListener, SBAttachInfo, GetListener); return SBListener(m_opaque_sp->GetListener()); } void SBAttachInfo::SetListener(SBListener &listener) { - LLDB_RECORD_METHOD(void, SBAttachInfo, SetListener, (lldb::SBListener &), - listener); + LLDB_INSTRUMENT_METHOD(void, SBAttachInfo, SetListener, (lldb::SBListener &), + listener); m_opaque_sp->SetListener(listener.GetSP()); } Index: lldb/source/API/SBBlock.cpp =================================================================== --- lldb/source/API/SBBlock.cpp +++ 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,23 @@ #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_CONSTRUCTOR_NO_ARGS(SBBlock); } SBBlock::SBBlock(lldb_private::Block *lldb_object_ptr) : m_opaque_ptr(lldb_object_ptr) {} SBBlock::SBBlock(const SBBlock &rhs) : m_opaque_ptr(rhs.m_opaque_ptr) { - LLDB_RECORD_CONSTRUCTOR(SBBlock, (const lldb::SBBlock &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBBlock, (const lldb::SBBlock &), rhs); } const SBBlock &SBBlock::operator=(const SBBlock &rhs) { - LLDB_RECORD_METHOD(const lldb::SBBlock &, - SBBlock, operator=,(const lldb::SBBlock &), rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBBlock &, SBBlock, operator=, + (const lldb::SBBlock &), rhs); m_opaque_ptr = rhs.m_opaque_ptr; return *this; @@ -45,17 +45,17 @@ SBBlock::~SBBlock() { m_opaque_ptr = nullptr; } bool SBBlock::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBlock, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBBlock, IsValid); return this->operator bool(); } SBBlock::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBlock, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBBlock, operator bool); return m_opaque_ptr != nullptr; } bool SBBlock::IsInlined() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBlock, IsInlined); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBBlock, IsInlined); if (m_opaque_ptr) return m_opaque_ptr->GetInlinedFunctionInfo() != nullptr; @@ -63,7 +63,7 @@ } const char *SBBlock::GetInlinedName() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBlock, GetInlinedName); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(const char *, SBBlock, GetInlinedName); if (m_opaque_ptr) { const InlineFunctionInfo *inlined_info = @@ -76,8 +76,8 @@ } SBFileSpec SBBlock::GetInlinedCallSiteFile() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBBlock, - GetInlinedCallSiteFile); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBBlock, + GetInlinedCallSiteFile); SBFileSpec sb_file; if (m_opaque_ptr) { @@ -90,7 +90,8 @@ } uint32_t SBBlock::GetInlinedCallSiteLine() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBlock, GetInlinedCallSiteLine); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(uint32_t, SBBlock, + GetInlinedCallSiteLine); if (m_opaque_ptr) { const InlineFunctionInfo *inlined_info = @@ -102,7 +103,8 @@ } uint32_t SBBlock::GetInlinedCallSiteColumn() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBlock, GetInlinedCallSiteColumn); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(uint32_t, SBBlock, + GetInlinedCallSiteColumn); if (m_opaque_ptr) { const InlineFunctionInfo *inlined_info = @@ -123,7 +125,7 @@ } SBBlock SBBlock::GetParent() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetParent); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetParent); SBBlock sb_block; if (m_opaque_ptr) @@ -132,7 +134,8 @@ } lldb::SBBlock SBBlock::GetContainingInlinedBlock() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetContainingInlinedBlock); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, + GetContainingInlinedBlock); SBBlock sb_block; if (m_opaque_ptr) @@ -141,7 +144,7 @@ } SBBlock SBBlock::GetSibling() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetSibling); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetSibling); SBBlock sb_block; if (m_opaque_ptr) @@ -150,7 +153,7 @@ } SBBlock SBBlock::GetFirstChild() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetFirstChild); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetFirstChild); SBBlock sb_block; if (m_opaque_ptr) @@ -163,8 +166,8 @@ 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_METHOD(bool, SBBlock, GetDescription, (lldb::SBStream &), + description); Stream &strm = description.ref(); @@ -188,7 +191,7 @@ } uint32_t SBBlock::GetNumRanges() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBBlock, GetNumRanges); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBBlock, GetNumRanges); if (m_opaque_ptr) return m_opaque_ptr->GetNumRanges(); @@ -196,8 +199,8 @@ } lldb::SBAddress SBBlock::GetRangeStartAddress(uint32_t idx) { - LLDB_RECORD_METHOD(lldb::SBAddress, SBBlock, GetRangeStartAddress, (uint32_t), - idx); + LLDB_INSTRUMENT_METHOD(lldb::SBAddress, SBBlock, GetRangeStartAddress, + (uint32_t), idx); lldb::SBAddress sb_addr; if (m_opaque_ptr) { @@ -210,8 +213,8 @@ } lldb::SBAddress SBBlock::GetRangeEndAddress(uint32_t idx) { - LLDB_RECORD_METHOD(lldb::SBAddress, SBBlock, GetRangeEndAddress, (uint32_t), - idx); + LLDB_INSTRUMENT_METHOD(lldb::SBAddress, SBBlock, GetRangeEndAddress, + (uint32_t), idx); lldb::SBAddress sb_addr; if (m_opaque_ptr) { @@ -225,8 +228,8 @@ } uint32_t SBBlock::GetRangeIndexForBlockAddress(lldb::SBAddress block_addr) { - LLDB_RECORD_METHOD(uint32_t, SBBlock, GetRangeIndexForBlockAddress, - (lldb::SBAddress), block_addr); + LLDB_INSTRUMENT_METHOD(uint32_t, SBBlock, GetRangeIndexForBlockAddress, + (lldb::SBAddress), block_addr); if (m_opaque_ptr && block_addr.IsValid()) { return m_opaque_ptr->GetRangeIndexContainingAddress(block_addr.ref()); @@ -238,7 +241,7 @@ lldb::SBValueList SBBlock::GetVariables(lldb::SBFrame &frame, bool arguments, bool locals, bool statics, lldb::DynamicValueType use_dynamic) { - LLDB_RECORD_METHOD( + LLDB_INSTRUMENT_METHOD( lldb::SBValueList, SBBlock, GetVariables, (lldb::SBFrame &, bool, bool, bool, lldb::DynamicValueType), frame, arguments, locals, statics, use_dynamic); @@ -294,9 +297,9 @@ 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_METHOD(lldb::SBValueList, SBBlock, GetVariables, + (lldb::SBTarget &, bool, bool, bool), target, + arguments, locals, statics); Block *block = GetPtr(); Index: lldb/source/API/SBBreakpoint.cpp =================================================================== --- lldb/source/API/SBBreakpoint.cpp +++ 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,47 @@ using namespace lldb; using namespace lldb_private; -SBBreakpoint::SBBreakpoint() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBreakpoint); } +SBBreakpoint::SBBreakpoint() { + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBBreakpoint); +} SBBreakpoint::SBBreakpoint(const SBBreakpoint &rhs) : m_opaque_wp(rhs.m_opaque_wp) { - LLDB_RECORD_CONSTRUCTOR(SBBreakpoint, (const lldb::SBBreakpoint &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBBreakpoint, (const lldb::SBBreakpoint &), rhs); } SBBreakpoint::SBBreakpoint(const lldb::BreakpointSP &bp_sp) : m_opaque_wp(bp_sp) { - LLDB_RECORD_CONSTRUCTOR(SBBreakpoint, (const lldb::BreakpointSP &), bp_sp); + LLDB_INSTRUMENT_CONSTRUCTOR(SBBreakpoint, (const lldb::BreakpointSP &), + bp_sp); } SBBreakpoint::~SBBreakpoint() = default; const SBBreakpoint &SBBreakpoint::operator=(const SBBreakpoint &rhs) { - LLDB_RECORD_METHOD(const lldb::SBBreakpoint &, - SBBreakpoint, operator=,(const lldb::SBBreakpoint &), rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBBreakpoint &, SBBreakpoint, operator=, + (const lldb::SBBreakpoint &), rhs); m_opaque_wp = rhs.m_opaque_wp; return *this; } bool SBBreakpoint::operator==(const lldb::SBBreakpoint &rhs) { - LLDB_RECORD_METHOD( - bool, SBBreakpoint, operator==,(const lldb::SBBreakpoint &), rhs); + LLDB_INSTRUMENT_METHOD(bool, SBBreakpoint, operator==, + (const lldb::SBBreakpoint &), rhs); return m_opaque_wp.lock() == rhs.m_opaque_wp.lock(); } bool SBBreakpoint::operator!=(const lldb::SBBreakpoint &rhs) { - LLDB_RECORD_METHOD( - bool, SBBreakpoint, operator!=,(const lldb::SBBreakpoint &), rhs); + LLDB_INSTRUMENT_METHOD(bool, SBBreakpoint, operator!=, + (const lldb::SBBreakpoint &), 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_METHOD_CONST_NO_ARGS(lldb::SBTarget, SBBreakpoint, GetTarget); BreakpointSP bkpt_sp = GetSP(); if (bkpt_sp) @@ -92,7 +95,7 @@ } break_id_t SBBreakpoint::GetID() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::break_id_t, SBBreakpoint, GetID); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::break_id_t, SBBreakpoint, GetID); break_id_t break_id = LLDB_INVALID_BREAK_ID; BreakpointSP bkpt_sp = GetSP(); @@ -103,11 +106,11 @@ } bool SBBreakpoint::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, IsValid); return this->operator bool(); } SBBreakpoint::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, operator bool); BreakpointSP bkpt_sp = GetSP(); if (!bkpt_sp) @@ -119,7 +122,7 @@ } void SBBreakpoint::ClearAllBreakpointSites() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBBreakpoint, ClearAllBreakpointSites); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBBreakpoint, ClearAllBreakpointSites); BreakpointSP bkpt_sp = GetSP(); if (bkpt_sp) { @@ -130,8 +133,8 @@ } SBBreakpointLocation SBBreakpoint::FindLocationByAddress(addr_t vm_addr) { - LLDB_RECORD_METHOD(lldb::SBBreakpointLocation, SBBreakpoint, - FindLocationByAddress, (lldb::addr_t), vm_addr); + LLDB_INSTRUMENT_METHOD(lldb::SBBreakpointLocation, SBBreakpoint, + FindLocationByAddress, (lldb::addr_t), vm_addr); SBBreakpointLocation sb_bp_location; @@ -152,8 +155,8 @@ } 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_METHOD(lldb::break_id_t, SBBreakpoint, + FindLocationIDByAddress, (lldb::addr_t), vm_addr); break_id_t break_id = LLDB_INVALID_BREAK_ID; BreakpointSP bkpt_sp = GetSP(); @@ -173,8 +176,8 @@ } 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_METHOD(lldb::SBBreakpointLocation, SBBreakpoint, + FindLocationByID, (lldb::break_id_t), bp_loc_id); SBBreakpointLocation sb_bp_location; BreakpointSP bkpt_sp = GetSP(); @@ -189,8 +192,8 @@ } SBBreakpointLocation SBBreakpoint::GetLocationAtIndex(uint32_t index) { - LLDB_RECORD_METHOD(lldb::SBBreakpointLocation, SBBreakpoint, - GetLocationAtIndex, (uint32_t), index); + LLDB_INSTRUMENT_METHOD(lldb::SBBreakpointLocation, SBBreakpoint, + GetLocationAtIndex, (uint32_t), index); SBBreakpointLocation sb_bp_location; BreakpointSP bkpt_sp = GetSP(); @@ -205,7 +208,7 @@ } void SBBreakpoint::SetEnabled(bool enable) { - LLDB_RECORD_METHOD(void, SBBreakpoint, SetEnabled, (bool), enable); + LLDB_INSTRUMENT_METHOD(void, SBBreakpoint, SetEnabled, (bool), enable); BreakpointSP bkpt_sp = GetSP(); @@ -217,7 +220,7 @@ } bool SBBreakpoint::IsEnabled() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpoint, IsEnabled); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBBreakpoint, IsEnabled); BreakpointSP bkpt_sp = GetSP(); if (bkpt_sp) { @@ -229,7 +232,7 @@ } void SBBreakpoint::SetOneShot(bool one_shot) { - LLDB_RECORD_METHOD(void, SBBreakpoint, SetOneShot, (bool), one_shot); + LLDB_INSTRUMENT_METHOD(void, SBBreakpoint, SetOneShot, (bool), one_shot); BreakpointSP bkpt_sp = GetSP(); @@ -241,7 +244,7 @@ } bool SBBreakpoint::IsOneShot() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, IsOneShot); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, IsOneShot); BreakpointSP bkpt_sp = GetSP(); if (bkpt_sp) { @@ -253,7 +256,7 @@ } bool SBBreakpoint::IsInternal() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpoint, IsInternal); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBBreakpoint, IsInternal); BreakpointSP bkpt_sp = GetSP(); if (bkpt_sp) { @@ -265,7 +268,7 @@ } void SBBreakpoint::SetIgnoreCount(uint32_t count) { - LLDB_RECORD_METHOD(void, SBBreakpoint, SetIgnoreCount, (uint32_t), count); + LLDB_INSTRUMENT_METHOD(void, SBBreakpoint, SetIgnoreCount, (uint32_t), count); BreakpointSP bkpt_sp = GetSP(); @@ -277,8 +280,8 @@ } void SBBreakpoint::SetCondition(const char *condition) { - LLDB_RECORD_METHOD(void, SBBreakpoint, SetCondition, (const char *), - condition); + LLDB_INSTRUMENT_METHOD(void, SBBreakpoint, SetCondition, (const char *), + condition); BreakpointSP bkpt_sp = GetSP(); if (bkpt_sp) { @@ -289,7 +292,7 @@ } const char *SBBreakpoint::GetCondition() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBBreakpoint, GetCondition); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBBreakpoint, GetCondition); BreakpointSP bkpt_sp = GetSP(); if (bkpt_sp) { @@ -301,8 +304,8 @@ } void SBBreakpoint::SetAutoContinue(bool auto_continue) { - LLDB_RECORD_METHOD(void, SBBreakpoint, SetAutoContinue, (bool), - auto_continue); + LLDB_INSTRUMENT_METHOD(void, SBBreakpoint, SetAutoContinue, (bool), + auto_continue); BreakpointSP bkpt_sp = GetSP(); if (bkpt_sp) { @@ -313,7 +316,7 @@ } bool SBBreakpoint::GetAutoContinue() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpoint, GetAutoContinue); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBBreakpoint, GetAutoContinue); BreakpointSP bkpt_sp = GetSP(); if (bkpt_sp) { @@ -325,7 +328,7 @@ } uint32_t SBBreakpoint::GetHitCount() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpoint, GetHitCount); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpoint, GetHitCount); uint32_t count = 0; BreakpointSP bkpt_sp = GetSP(); @@ -339,7 +342,7 @@ } uint32_t SBBreakpoint::GetIgnoreCount() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpoint, GetIgnoreCount); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpoint, GetIgnoreCount); uint32_t count = 0; BreakpointSP bkpt_sp = GetSP(); @@ -353,7 +356,7 @@ } void SBBreakpoint::SetThreadID(tid_t tid) { - LLDB_RECORD_METHOD(void, SBBreakpoint, SetThreadID, (lldb::tid_t), tid); + LLDB_INSTRUMENT_METHOD(void, SBBreakpoint, SetThreadID, (lldb::tid_t), tid); BreakpointSP bkpt_sp = GetSP(); if (bkpt_sp) { @@ -364,7 +367,7 @@ } tid_t SBBreakpoint::GetThreadID() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBBreakpoint, GetThreadID); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::tid_t, SBBreakpoint, GetThreadID); tid_t tid = LLDB_INVALID_THREAD_ID; BreakpointSP bkpt_sp = GetSP(); @@ -378,7 +381,7 @@ } void SBBreakpoint::SetThreadIndex(uint32_t index) { - LLDB_RECORD_METHOD(void, SBBreakpoint, SetThreadIndex, (uint32_t), index); + LLDB_INSTRUMENT_METHOD(void, SBBreakpoint, SetThreadIndex, (uint32_t), index); BreakpointSP bkpt_sp = GetSP(); if (bkpt_sp) { @@ -389,7 +392,7 @@ } uint32_t SBBreakpoint::GetThreadIndex() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpoint, GetThreadIndex); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpoint, GetThreadIndex); uint32_t thread_idx = UINT32_MAX; BreakpointSP bkpt_sp = GetSP(); @@ -406,8 +409,8 @@ } void SBBreakpoint::SetThreadName(const char *thread_name) { - LLDB_RECORD_METHOD(void, SBBreakpoint, SetThreadName, (const char *), - thread_name); + LLDB_INSTRUMENT_METHOD(void, SBBreakpoint, SetThreadName, (const char *), + thread_name); BreakpointSP bkpt_sp = GetSP(); @@ -419,7 +422,8 @@ } const char *SBBreakpoint::GetThreadName() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpoint, GetThreadName); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(const char *, SBBreakpoint, + GetThreadName); const char *name = nullptr; BreakpointSP bkpt_sp = GetSP(); @@ -436,8 +440,8 @@ } void SBBreakpoint::SetQueueName(const char *queue_name) { - LLDB_RECORD_METHOD(void, SBBreakpoint, SetQueueName, (const char *), - queue_name); + LLDB_INSTRUMENT_METHOD(void, SBBreakpoint, SetQueueName, (const char *), + queue_name); BreakpointSP bkpt_sp = GetSP(); if (bkpt_sp) { @@ -448,7 +452,8 @@ } const char *SBBreakpoint::GetQueueName() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpoint, GetQueueName); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(const char *, SBBreakpoint, + GetQueueName); const char *name = nullptr; BreakpointSP bkpt_sp = GetSP(); @@ -465,8 +470,8 @@ } size_t SBBreakpoint::GetNumResolvedLocations() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBBreakpoint, - GetNumResolvedLocations); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(size_t, SBBreakpoint, + GetNumResolvedLocations); size_t num_resolved = 0; BreakpointSP bkpt_sp = GetSP(); @@ -479,7 +484,7 @@ } size_t SBBreakpoint::GetNumLocations() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBBreakpoint, GetNumLocations); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(size_t, SBBreakpoint, GetNumLocations); BreakpointSP bkpt_sp = GetSP(); size_t num_locs = 0; @@ -492,8 +497,8 @@ } void SBBreakpoint::SetCommandLineCommands(SBStringList &commands) { - LLDB_RECORD_METHOD(void, SBBreakpoint, SetCommandLineCommands, - (lldb::SBStringList &), commands); + LLDB_INSTRUMENT_METHOD(void, SBBreakpoint, SetCommandLineCommands, + (lldb::SBStringList &), commands); BreakpointSP bkpt_sp = GetSP(); if (!bkpt_sp) @@ -510,8 +515,8 @@ } bool SBBreakpoint::GetCommandLineCommands(SBStringList &commands) { - LLDB_RECORD_METHOD(bool, SBBreakpoint, GetCommandLineCommands, - (lldb::SBStringList &), commands); + LLDB_INSTRUMENT_METHOD(bool, SBBreakpoint, GetCommandLineCommands, + (lldb::SBStringList &), commands); BreakpointSP bkpt_sp = GetSP(); if (!bkpt_sp) @@ -525,14 +530,15 @@ } bool SBBreakpoint::GetDescription(SBStream &s) { - LLDB_RECORD_METHOD(bool, SBBreakpoint, GetDescription, (lldb::SBStream &), s); + LLDB_INSTRUMENT_METHOD(bool, SBBreakpoint, GetDescription, (lldb::SBStream &), + s); return GetDescription(s, true); } bool SBBreakpoint::GetDescription(SBStream &s, bool include_locations) { - LLDB_RECORD_METHOD(bool, SBBreakpoint, GetDescription, - (lldb::SBStream &, bool), s, include_locations); + LLDB_INSTRUMENT_METHOD(bool, SBBreakpoint, GetDescription, + (lldb::SBStream &, bool), s, include_locations); BreakpointSP bkpt_sp = GetSP(); if (bkpt_sp) { @@ -552,8 +558,8 @@ } SBError SBBreakpoint::AddLocation(SBAddress &address) { - LLDB_RECORD_METHOD(lldb::SBError, SBBreakpoint, AddLocation, - (lldb::SBAddress &), address); + LLDB_INSTRUMENT_METHOD(lldb::SBError, SBBreakpoint, AddLocation, + (lldb::SBAddress &), address); BreakpointSP bkpt_sp = GetSP(); SBError error; @@ -586,8 +592,8 @@ } SBStructuredData SBBreakpoint::SerializeToStructuredData() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStructuredData, SBBreakpoint, - SerializeToStructuredData); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBStructuredData, SBBreakpoint, + SerializeToStructuredData); SBStructuredData data; BreakpointSP bkpt_sp = GetSP(); @@ -601,8 +607,9 @@ } void SBBreakpoint::SetCallback(SBBreakpointHitCallback callback, void *baton) { - LLDB_RECORD_METHOD(void, SBBreakpoint, SetCallback, - (lldb::SBBreakpointHitCallback, void *), callback, baton); + LLDB_INSTRUMENT_METHOD(void, SBBreakpoint, SetCallback, + (lldb::SBBreakpointHitCallback, void *), callback, + baton); BreakpointSP bkpt_sp = GetSP(); @@ -618,8 +625,8 @@ void SBBreakpoint::SetScriptCallbackFunction( const char *callback_function_name) { -LLDB_RECORD_METHOD(void, SBBreakpoint, SetScriptCallbackFunction, - (const char *), callback_function_name); + LLDB_INSTRUMENT_METHOD(void, SBBreakpoint, SetScriptCallbackFunction, + (const char *), callback_function_name); SBStructuredData empty_args; SetScriptCallbackFunction(callback_function_name, empty_args); } @@ -627,8 +634,9 @@ 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_METHOD(SBError, SBBreakpoint, SetScriptCallbackFunction, + (const char *, SBStructuredData &), + callback_function_name, extra_args); SBError sb_error; BreakpointSP bkpt_sp = GetSP(); @@ -652,8 +660,8 @@ } SBError SBBreakpoint::SetScriptCallbackBody(const char *callback_body_text) { - LLDB_RECORD_METHOD(lldb::SBError, SBBreakpoint, SetScriptCallbackBody, - (const char *), callback_body_text); + LLDB_INSTRUMENT_METHOD(lldb::SBError, SBBreakpoint, SetScriptCallbackBody, + (const char *), callback_body_text); BreakpointSP bkpt_sp = GetSP(); @@ -675,15 +683,15 @@ } bool SBBreakpoint::AddName(const char *new_name) { - LLDB_RECORD_METHOD(bool, SBBreakpoint, AddName, (const char *), new_name); + LLDB_INSTRUMENT_METHOD(bool, SBBreakpoint, AddName, (const char *), 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_METHOD(SBError, SBBreakpoint, AddNameWithErrorHandling, + (const char *), new_name); BreakpointSP bkpt_sp = GetSP(); @@ -702,8 +710,8 @@ } void SBBreakpoint::RemoveName(const char *name_to_remove) { - LLDB_RECORD_METHOD(void, SBBreakpoint, RemoveName, (const char *), - name_to_remove); + LLDB_INSTRUMENT_METHOD(void, SBBreakpoint, RemoveName, (const char *), + name_to_remove); BreakpointSP bkpt_sp = GetSP(); @@ -716,7 +724,7 @@ } bool SBBreakpoint::MatchesName(const char *name) { - LLDB_RECORD_METHOD(bool, SBBreakpoint, MatchesName, (const char *), name); + LLDB_INSTRUMENT_METHOD(bool, SBBreakpoint, MatchesName, (const char *), name); BreakpointSP bkpt_sp = GetSP(); @@ -730,8 +738,8 @@ } void SBBreakpoint::GetNames(SBStringList &names) { - LLDB_RECORD_METHOD(void, SBBreakpoint, GetNames, (lldb::SBStringList &), - names); + LLDB_INSTRUMENT_METHOD(void, SBBreakpoint, GetNames, (lldb::SBStringList &), + names); BreakpointSP bkpt_sp = GetSP(); @@ -747,8 +755,8 @@ } bool SBBreakpoint::EventIsBreakpointEvent(const lldb::SBEvent &event) { - LLDB_RECORD_STATIC_METHOD(bool, SBBreakpoint, EventIsBreakpointEvent, - (const lldb::SBEvent &), event); + LLDB_INSTRUMENT_STATIC_METHOD(bool, SBBreakpoint, EventIsBreakpointEvent, + (const lldb::SBEvent &), event); return Breakpoint::BreakpointEventData::GetEventDataFromEvent(event.get()) != nullptr; @@ -756,9 +764,9 @@ BreakpointEventType SBBreakpoint::GetBreakpointEventTypeFromEvent(const SBEvent &event) { - LLDB_RECORD_STATIC_METHOD(lldb::BreakpointEventType, SBBreakpoint, - GetBreakpointEventTypeFromEvent, - (const lldb::SBEvent &), event); + LLDB_INSTRUMENT_STATIC_METHOD(lldb::BreakpointEventType, SBBreakpoint, + GetBreakpointEventTypeFromEvent, + (const lldb::SBEvent &), event); if (event.IsValid()) return Breakpoint::BreakpointEventData::GetBreakpointEventTypeFromEvent( @@ -767,9 +775,9 @@ } SBBreakpoint SBBreakpoint::GetBreakpointFromEvent(const lldb::SBEvent &event) { - LLDB_RECORD_STATIC_METHOD(lldb::SBBreakpoint, SBBreakpoint, - GetBreakpointFromEvent, (const lldb::SBEvent &), - event); + LLDB_INSTRUMENT_STATIC_METHOD(lldb::SBBreakpoint, SBBreakpoint, + GetBreakpointFromEvent, (const lldb::SBEvent &), + event); if (event.IsValid()) return SBBreakpoint( @@ -780,9 +788,10 @@ 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_STATIC_METHOD(lldb::SBBreakpointLocation, SBBreakpoint, + GetBreakpointLocationAtIndexFromEvent, + (const lldb::SBEvent &, uint32_t), event, + loc_idx); SBBreakpointLocation sb_breakpoint_loc; if (event.IsValid()) @@ -794,9 +803,9 @@ uint32_t SBBreakpoint::GetNumBreakpointLocationsFromEvent(const lldb::SBEvent &event) { - LLDB_RECORD_STATIC_METHOD(uint32_t, SBBreakpoint, - GetNumBreakpointLocationsFromEvent, - (const lldb::SBEvent &), event); + LLDB_INSTRUMENT_STATIC_METHOD(uint32_t, SBBreakpoint, + GetNumBreakpointLocationsFromEvent, + (const lldb::SBEvent &), event); uint32_t num_locations = 0; if (event.IsValid()) @@ -807,7 +816,7 @@ } bool SBBreakpoint::IsHardware() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, IsHardware); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, IsHardware); BreakpointSP bkpt_sp = GetSP(); if (bkpt_sp) @@ -903,13 +912,13 @@ SBBreakpointList::SBBreakpointList(SBTarget &target) : m_opaque_sp(new SBBreakpointListImpl(target.GetSP())) { - LLDB_RECORD_CONSTRUCTOR(SBBreakpointList, (lldb::SBTarget &), target); + LLDB_INSTRUMENT_CONSTRUCTOR(SBBreakpointList, (lldb::SBTarget &), target); } SBBreakpointList::~SBBreakpointList() = default; size_t SBBreakpointList::GetSize() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBBreakpointList, GetSize); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(size_t, SBBreakpointList, GetSize); if (!m_opaque_sp) return 0; @@ -918,8 +927,8 @@ } SBBreakpoint SBBreakpointList::GetBreakpointAtIndex(size_t idx) { - LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBBreakpointList, GetBreakpointAtIndex, - (size_t), idx); + LLDB_INSTRUMENT_METHOD(lldb::SBBreakpoint, SBBreakpointList, + GetBreakpointAtIndex, (size_t), idx); if (!m_opaque_sp) return SBBreakpoint(); @@ -929,8 +938,8 @@ } SBBreakpoint SBBreakpointList::FindBreakpointByID(lldb::break_id_t id) { - LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBBreakpointList, FindBreakpointByID, - (lldb::break_id_t), id); + LLDB_INSTRUMENT_METHOD(lldb::SBBreakpoint, SBBreakpointList, + FindBreakpointByID, (lldb::break_id_t), id); if (!m_opaque_sp) return SBBreakpoint(); @@ -939,8 +948,8 @@ } void SBBreakpointList::Append(const SBBreakpoint &sb_bkpt) { - LLDB_RECORD_METHOD(void, SBBreakpointList, Append, - (const lldb::SBBreakpoint &), sb_bkpt); + LLDB_INSTRUMENT_METHOD(void, SBBreakpointList, Append, + (const lldb::SBBreakpoint &), sb_bkpt); if (!sb_bkpt.IsValid()) return; @@ -950,8 +959,8 @@ } void SBBreakpointList::AppendByID(lldb::break_id_t id) { - LLDB_RECORD_METHOD(void, SBBreakpointList, AppendByID, (lldb::break_id_t), - id); + LLDB_INSTRUMENT_METHOD(void, SBBreakpointList, AppendByID, (lldb::break_id_t), + id); if (!m_opaque_sp) return; @@ -959,8 +968,8 @@ } bool SBBreakpointList::AppendIfUnique(const SBBreakpoint &sb_bkpt) { - LLDB_RECORD_METHOD(bool, SBBreakpointList, AppendIfUnique, - (const lldb::SBBreakpoint &), sb_bkpt); + LLDB_INSTRUMENT_METHOD(bool, SBBreakpointList, AppendIfUnique, + (const lldb::SBBreakpoint &), sb_bkpt); if (!sb_bkpt.IsValid()) return false; @@ -970,7 +979,7 @@ } void SBBreakpointList::Clear() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBBreakpointList, Clear); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBBreakpointList, Clear); if (m_opaque_sp) m_opaque_sp->Clear(); Index: lldb/source/API/SBBreakpointLocation.cpp =================================================================== --- lldb/source/API/SBBreakpointLocation.cpp +++ 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" @@ -32,28 +32,27 @@ using namespace lldb_private; SBBreakpointLocation::SBBreakpointLocation() { - LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBreakpointLocation); + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBBreakpointLocation); } SBBreakpointLocation::SBBreakpointLocation( const lldb::BreakpointLocationSP &break_loc_sp) : m_opaque_wp(break_loc_sp) { - LLDB_RECORD_CONSTRUCTOR(SBBreakpointLocation, - (const lldb::BreakpointLocationSP &), break_loc_sp); + LLDB_INSTRUMENT_CONSTRUCTOR( + SBBreakpointLocation, (const lldb::BreakpointLocationSP &), 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_CONSTRUCTOR(SBBreakpointLocation, + (const lldb::SBBreakpointLocation &), rhs); } const SBBreakpointLocation &SBBreakpointLocation:: operator=(const SBBreakpointLocation &rhs) { - LLDB_RECORD_METHOD( - const lldb::SBBreakpointLocation &, - SBBreakpointLocation, operator=,(const lldb::SBBreakpointLocation &), - rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBBreakpointLocation &, + SBBreakpointLocation, operator=, + (const lldb::SBBreakpointLocation &), rhs); m_opaque_wp = rhs.m_opaque_wp; return *this; @@ -66,17 +65,19 @@ } bool SBBreakpointLocation::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointLocation, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBBreakpointLocation, IsValid); return this->operator bool(); } SBBreakpointLocation::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointLocation, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, + SBBreakpointLocation, operator bool); return bool(GetSP()); } SBAddress SBBreakpointLocation::GetAddress() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBBreakpointLocation, GetAddress); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBAddress, SBBreakpointLocation, + GetAddress); BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { @@ -87,8 +88,8 @@ } addr_t SBBreakpointLocation::GetLoadAddress() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBBreakpointLocation, - GetLoadAddress); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::addr_t, SBBreakpointLocation, + GetLoadAddress); addr_t ret_addr = LLDB_INVALID_ADDRESS; BreakpointLocationSP loc_sp = GetSP(); @@ -103,7 +104,8 @@ } void SBBreakpointLocation::SetEnabled(bool enabled) { - LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetEnabled, (bool), enabled); + LLDB_INSTRUMENT_METHOD(void, SBBreakpointLocation, SetEnabled, (bool), + enabled); BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { @@ -114,7 +116,7 @@ } bool SBBreakpointLocation::IsEnabled() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointLocation, IsEnabled); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBBreakpointLocation, IsEnabled); BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { @@ -126,7 +128,7 @@ } uint32_t SBBreakpointLocation::GetHitCount() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBBreakpointLocation, GetHitCount); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBBreakpointLocation, GetHitCount); BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { @@ -138,7 +140,8 @@ } uint32_t SBBreakpointLocation::GetIgnoreCount() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBBreakpointLocation, GetIgnoreCount); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBBreakpointLocation, + GetIgnoreCount); BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { @@ -150,7 +153,8 @@ } void SBBreakpointLocation::SetIgnoreCount(uint32_t n) { - LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetIgnoreCount, (uint32_t), n); + LLDB_INSTRUMENT_METHOD(void, SBBreakpointLocation, SetIgnoreCount, (uint32_t), + n); BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { @@ -161,8 +165,8 @@ } void SBBreakpointLocation::SetCondition(const char *condition) { - LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetCondition, (const char *), - condition); + LLDB_INSTRUMENT_METHOD(void, SBBreakpointLocation, SetCondition, + (const char *), condition); BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { @@ -173,7 +177,8 @@ } const char *SBBreakpointLocation::GetCondition() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBBreakpointLocation, GetCondition); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBBreakpointLocation, + GetCondition); BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { @@ -185,8 +190,8 @@ } void SBBreakpointLocation::SetAutoContinue(bool auto_continue) { - LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetAutoContinue, (bool), - auto_continue); + LLDB_INSTRUMENT_METHOD(void, SBBreakpointLocation, SetAutoContinue, (bool), + auto_continue); BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { @@ -197,7 +202,7 @@ } bool SBBreakpointLocation::GetAutoContinue() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointLocation, GetAutoContinue); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBBreakpointLocation, GetAutoContinue); BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { @@ -210,16 +215,16 @@ void SBBreakpointLocation::SetScriptCallbackFunction( const char *callback_function_name) { -LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetScriptCallbackFunction, - (const char *), callback_function_name); + LLDB_INSTRUMENT_METHOD(void, SBBreakpointLocation, SetScriptCallbackFunction, + (const char *), 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_METHOD( + SBError, SBBreakpointLocation, SetScriptCallbackFunction, + (const char *, SBStructuredData &), callback_function_name, extra_args); SBError sb_error; BreakpointLocationSP loc_sp = GetSP(); @@ -245,8 +250,9 @@ SBError SBBreakpointLocation::SetScriptCallbackBody(const char *callback_body_text) { - LLDB_RECORD_METHOD(lldb::SBError, SBBreakpointLocation, SetScriptCallbackBody, - (const char *), callback_body_text); + LLDB_INSTRUMENT_METHOD(lldb::SBError, SBBreakpointLocation, + SetScriptCallbackBody, (const char *), + callback_body_text); BreakpointLocationSP loc_sp = GetSP(); @@ -269,8 +275,8 @@ } void SBBreakpointLocation::SetCommandLineCommands(SBStringList &commands) { - LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetCommandLineCommands, - (lldb::SBStringList &), commands); + LLDB_INSTRUMENT_METHOD(void, SBBreakpointLocation, SetCommandLineCommands, + (lldb::SBStringList &), commands); BreakpointLocationSP loc_sp = GetSP(); if (!loc_sp) @@ -287,8 +293,8 @@ } bool SBBreakpointLocation::GetCommandLineCommands(SBStringList &commands) { - LLDB_RECORD_METHOD(bool, SBBreakpointLocation, GetCommandLineCommands, - (lldb::SBStringList &), commands); + LLDB_INSTRUMENT_METHOD(bool, SBBreakpointLocation, GetCommandLineCommands, + (lldb::SBStringList &), commands); BreakpointLocationSP loc_sp = GetSP(); if (!loc_sp) @@ -302,8 +308,8 @@ } void SBBreakpointLocation::SetThreadID(tid_t thread_id) { - LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetThreadID, (lldb::tid_t), - thread_id); + LLDB_INSTRUMENT_METHOD(void, SBBreakpointLocation, SetThreadID, (lldb::tid_t), + thread_id); BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { @@ -314,7 +320,8 @@ } tid_t SBBreakpointLocation::GetThreadID() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBBreakpointLocation, GetThreadID); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::tid_t, SBBreakpointLocation, + GetThreadID); tid_t tid = LLDB_INVALID_THREAD_ID; BreakpointLocationSP loc_sp = GetSP(); @@ -327,8 +334,8 @@ } void SBBreakpointLocation::SetThreadIndex(uint32_t index) { - LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetThreadIndex, (uint32_t), - index); + LLDB_INSTRUMENT_METHOD(void, SBBreakpointLocation, SetThreadIndex, (uint32_t), + index); BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { @@ -339,8 +346,8 @@ } uint32_t SBBreakpointLocation::GetThreadIndex() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointLocation, - GetThreadIndex); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointLocation, + GetThreadIndex); uint32_t thread_idx = UINT32_MAX; BreakpointLocationSP loc_sp = GetSP(); @@ -353,8 +360,8 @@ } void SBBreakpointLocation::SetThreadName(const char *thread_name) { - LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetThreadName, (const char *), - thread_name); + LLDB_INSTRUMENT_METHOD(void, SBBreakpointLocation, SetThreadName, + (const char *), thread_name); BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { @@ -365,8 +372,8 @@ } const char *SBBreakpointLocation::GetThreadName() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointLocation, - GetThreadName); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(const char *, SBBreakpointLocation, + GetThreadName); BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { @@ -378,8 +385,8 @@ } void SBBreakpointLocation::SetQueueName(const char *queue_name) { - LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetQueueName, (const char *), - queue_name); + LLDB_INSTRUMENT_METHOD(void, SBBreakpointLocation, SetQueueName, + (const char *), queue_name); BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { @@ -390,8 +397,8 @@ } const char *SBBreakpointLocation::GetQueueName() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointLocation, - GetQueueName); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(const char *, SBBreakpointLocation, + GetQueueName); BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { @@ -403,7 +410,7 @@ } bool SBBreakpointLocation::IsResolved() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointLocation, IsResolved); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBBreakpointLocation, IsResolved); BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { @@ -422,9 +429,9 @@ bool SBBreakpointLocation::GetDescription(SBStream &description, DescriptionLevel level) { - LLDB_RECORD_METHOD(bool, SBBreakpointLocation, GetDescription, - (lldb::SBStream &, lldb::DescriptionLevel), description, - level); + LLDB_INSTRUMENT_METHOD(bool, SBBreakpointLocation, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel), + description, level); Stream &strm = description.ref(); BreakpointLocationSP loc_sp = GetSP(); @@ -441,7 +448,7 @@ } break_id_t SBBreakpointLocation::GetID() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::break_id_t, SBBreakpointLocation, GetID); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::break_id_t, SBBreakpointLocation, GetID); BreakpointLocationSP loc_sp = GetSP(); if (loc_sp) { @@ -453,8 +460,8 @@ } SBBreakpoint SBBreakpointLocation::GetBreakpoint() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBreakpoint, SBBreakpointLocation, - GetBreakpoint); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBBreakpoint, SBBreakpointLocation, + GetBreakpoint); BreakpointLocationSP loc_sp = GetSP(); Index: lldb/source/API/SBBreakpointName.cpp =================================================================== --- lldb/source/API/SBBreakpointName.cpp +++ 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" @@ -108,12 +108,12 @@ } // namespace lldb SBBreakpointName::SBBreakpointName() { - LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBreakpointName); + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBBreakpointName); } SBBreakpointName::SBBreakpointName(SBTarget &sb_target, const char *name) { - LLDB_RECORD_CONSTRUCTOR(SBBreakpointName, (lldb::SBTarget &, const char *), - sb_target, name); + LLDB_INSTRUMENT_CONSTRUCTOR( + SBBreakpointName, (lldb::SBTarget &, const char *), sb_target, name); m_impl_up = std::make_unique(sb_target, name); // Call FindBreakpointName here to make sure the name is valid, reset if not: @@ -123,8 +123,8 @@ } SBBreakpointName::SBBreakpointName(SBBreakpoint &sb_bkpt, const char *name) { - LLDB_RECORD_CONSTRUCTOR(SBBreakpointName, - (lldb::SBBreakpoint &, const char *), sb_bkpt, name); + LLDB_INSTRUMENT_CONSTRUCTOR( + SBBreakpointName, (lldb::SBBreakpoint &, const char *), sb_bkpt, name); if (!sb_bkpt.IsValid()) { m_impl_up.reset(); @@ -149,8 +149,8 @@ } SBBreakpointName::SBBreakpointName(const SBBreakpointName &rhs) { - LLDB_RECORD_CONSTRUCTOR(SBBreakpointName, (const lldb::SBBreakpointName &), - rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBBreakpointName, + (const lldb::SBBreakpointName &), rhs); if (!rhs.m_impl_up) return; @@ -163,9 +163,9 @@ const SBBreakpointName &SBBreakpointName:: operator=(const SBBreakpointName &rhs) { - LLDB_RECORD_METHOD( - const lldb::SBBreakpointName &, - SBBreakpointName, operator=,(const lldb::SBBreakpointName &), rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBBreakpointName &, + SBBreakpointName, operator=, + (const lldb::SBBreakpointName &), rhs); if (!rhs.m_impl_up) { m_impl_up.reset(); @@ -178,25 +178,25 @@ } bool SBBreakpointName::operator==(const lldb::SBBreakpointName &rhs) { - LLDB_RECORD_METHOD( - bool, SBBreakpointName, operator==,(const lldb::SBBreakpointName &), rhs); + LLDB_INSTRUMENT_METHOD(bool, SBBreakpointName, operator==, + (const lldb::SBBreakpointName &), rhs); return *m_impl_up == *rhs.m_impl_up; } bool SBBreakpointName::operator!=(const lldb::SBBreakpointName &rhs) { - LLDB_RECORD_METHOD( - bool, SBBreakpointName, operator!=,(const lldb::SBBreakpointName &), rhs); + LLDB_INSTRUMENT_METHOD(bool, SBBreakpointName, operator!=, + (const lldb::SBBreakpointName &), rhs); return *m_impl_up != *rhs.m_impl_up; } bool SBBreakpointName::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, IsValid); return this->operator bool(); } SBBreakpointName::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, operator bool); if (!m_impl_up) return false; @@ -204,7 +204,7 @@ } const char *SBBreakpointName::GetName() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName, GetName); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName, GetName); if (!m_impl_up) return ""; @@ -212,7 +212,7 @@ } void SBBreakpointName::SetEnabled(bool enable) { - LLDB_RECORD_METHOD(void, SBBreakpointName, SetEnabled, (bool), enable); + LLDB_INSTRUMENT_METHOD(void, SBBreakpointName, SetEnabled, (bool), enable); BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) @@ -236,7 +236,7 @@ } bool SBBreakpointName::IsEnabled() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, IsEnabled); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBBreakpointName, IsEnabled); BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) @@ -249,7 +249,7 @@ } void SBBreakpointName::SetOneShot(bool one_shot) { - LLDB_RECORD_METHOD(void, SBBreakpointName, SetOneShot, (bool), one_shot); + LLDB_INSTRUMENT_METHOD(void, SBBreakpointName, SetOneShot, (bool), one_shot); BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) @@ -263,7 +263,7 @@ } bool SBBreakpointName::IsOneShot() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, IsOneShot); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, IsOneShot); const BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) @@ -276,7 +276,8 @@ } void SBBreakpointName::SetIgnoreCount(uint32_t count) { - LLDB_RECORD_METHOD(void, SBBreakpointName, SetIgnoreCount, (uint32_t), count); + LLDB_INSTRUMENT_METHOD(void, SBBreakpointName, SetIgnoreCount, (uint32_t), + count); BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) @@ -290,7 +291,8 @@ } uint32_t SBBreakpointName::GetIgnoreCount() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointName, GetIgnoreCount); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointName, + GetIgnoreCount); BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) @@ -303,8 +305,8 @@ } void SBBreakpointName::SetCondition(const char *condition) { - LLDB_RECORD_METHOD(void, SBBreakpointName, SetCondition, (const char *), - condition); + LLDB_INSTRUMENT_METHOD(void, SBBreakpointName, SetCondition, (const char *), + condition); BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) @@ -318,7 +320,7 @@ } const char *SBBreakpointName::GetCondition() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBBreakpointName, GetCondition); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBBreakpointName, GetCondition); BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) @@ -331,8 +333,8 @@ } void SBBreakpointName::SetAutoContinue(bool auto_continue) { - LLDB_RECORD_METHOD(void, SBBreakpointName, SetAutoContinue, (bool), - auto_continue); + LLDB_INSTRUMENT_METHOD(void, SBBreakpointName, SetAutoContinue, (bool), + auto_continue); BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) @@ -346,7 +348,7 @@ } bool SBBreakpointName::GetAutoContinue() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAutoContinue); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBBreakpointName, GetAutoContinue); BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) @@ -359,7 +361,8 @@ } void SBBreakpointName::SetThreadID(tid_t tid) { - LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadID, (lldb::tid_t), tid); + LLDB_INSTRUMENT_METHOD(void, SBBreakpointName, SetThreadID, (lldb::tid_t), + tid); BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) @@ -373,7 +376,7 @@ } tid_t SBBreakpointName::GetThreadID() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBBreakpointName, GetThreadID); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::tid_t, SBBreakpointName, GetThreadID); BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) @@ -386,7 +389,8 @@ } void SBBreakpointName::SetThreadIndex(uint32_t index) { - LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadIndex, (uint32_t), index); + LLDB_INSTRUMENT_METHOD(void, SBBreakpointName, SetThreadIndex, (uint32_t), + index); BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) @@ -400,7 +404,8 @@ } uint32_t SBBreakpointName::GetThreadIndex() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointName, GetThreadIndex); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointName, + GetThreadIndex); BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) @@ -413,8 +418,8 @@ } void SBBreakpointName::SetThreadName(const char *thread_name) { - LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadName, (const char *), - thread_name); + LLDB_INSTRUMENT_METHOD(void, SBBreakpointName, SetThreadName, (const char *), + thread_name); BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) @@ -428,8 +433,8 @@ } const char *SBBreakpointName::GetThreadName() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName, - GetThreadName); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName, + GetThreadName); BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) @@ -442,8 +447,8 @@ } void SBBreakpointName::SetQueueName(const char *queue_name) { - LLDB_RECORD_METHOD(void, SBBreakpointName, SetQueueName, (const char *), - queue_name); + LLDB_INSTRUMENT_METHOD(void, SBBreakpointName, SetQueueName, (const char *), + queue_name); BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) @@ -457,8 +462,8 @@ } const char *SBBreakpointName::GetQueueName() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName, - GetQueueName); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName, + GetQueueName); BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) @@ -471,8 +476,8 @@ } void SBBreakpointName::SetCommandLineCommands(SBStringList &commands) { - LLDB_RECORD_METHOD(void, SBBreakpointName, SetCommandLineCommands, - (lldb::SBStringList &), commands); + LLDB_INSTRUMENT_METHOD(void, SBBreakpointName, SetCommandLineCommands, + (lldb::SBStringList &), commands); BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) @@ -491,8 +496,8 @@ } bool SBBreakpointName::GetCommandLineCommands(SBStringList &commands) { - LLDB_RECORD_METHOD(bool, SBBreakpointName, GetCommandLineCommands, - (lldb::SBStringList &), commands); + LLDB_INSTRUMENT_METHOD(bool, SBBreakpointName, GetCommandLineCommands, + (lldb::SBStringList &), commands); BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) @@ -507,8 +512,8 @@ } const char *SBBreakpointName::GetHelpString() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName, - GetHelpString); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName, + GetHelpString); BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) @@ -518,8 +523,8 @@ } void SBBreakpointName::SetHelpString(const char *help_string) { - LLDB_RECORD_METHOD(void, SBBreakpointName, SetHelpString, (const char *), - help_string); + LLDB_INSTRUMENT_METHOD(void, SBBreakpointName, SetHelpString, (const char *), + help_string); BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) @@ -532,8 +537,8 @@ } bool SBBreakpointName::GetDescription(SBStream &s) { - LLDB_RECORD_METHOD(bool, SBBreakpointName, GetDescription, (lldb::SBStream &), - s); + LLDB_INSTRUMENT_METHOD(bool, SBBreakpointName, GetDescription, + (lldb::SBStream &), s); BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) @@ -550,8 +555,9 @@ void SBBreakpointName::SetCallback(SBBreakpointHitCallback callback, void *baton) { - LLDB_RECORD_METHOD(void, SBBreakpointName, SetCallback, - (lldb::SBBreakpointHitCallback, void *), callback, baton); + LLDB_INSTRUMENT_METHOD(void, SBBreakpointName, SetCallback, + (lldb::SBBreakpointHitCallback, void *), callback, + baton); BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) @@ -569,8 +575,8 @@ void SBBreakpointName::SetScriptCallbackFunction( const char *callback_function_name) { -LLDB_RECORD_METHOD(void, SBBreakpointName, SetScriptCallbackFunction, - (const char *), callback_function_name); + LLDB_INSTRUMENT_METHOD(void, SBBreakpointName, SetScriptCallbackFunction, + (const char *), callback_function_name); SBStructuredData empty_args; SetScriptCallbackFunction(callback_function_name, empty_args); } @@ -578,9 +584,9 @@ 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_METHOD(SBError, SBBreakpointName, SetScriptCallbackFunction, + (const char *, SBStructuredData &), + callback_function_name, extra_args); SBError sb_error; BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) { @@ -606,8 +612,8 @@ SBError SBBreakpointName::SetScriptCallbackBody(const char *callback_body_text) { - LLDB_RECORD_METHOD(lldb::SBError, SBBreakpointName, SetScriptCallbackBody, - (const char *), callback_body_text); + LLDB_INSTRUMENT_METHOD(lldb::SBError, SBBreakpointName, SetScriptCallbackBody, + (const char *), callback_body_text); SBError sb_error; BreakpointName *bp_name = GetBreakpointName(); @@ -631,7 +637,7 @@ } bool SBBreakpointName::GetAllowList() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, GetAllowList); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, GetAllowList); BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) @@ -640,8 +646,7 @@ } void SBBreakpointName::SetAllowList(bool value) { - LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowList, (bool), value); - + LLDB_INSTRUMENT_METHOD(void, SBBreakpointName, SetAllowList, (bool), value); BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) @@ -650,7 +655,7 @@ } bool SBBreakpointName::GetAllowDelete() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAllowDelete); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBBreakpointName, GetAllowDelete); BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) @@ -659,8 +664,7 @@ } void SBBreakpointName::SetAllowDelete(bool value) { - LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowDelete, (bool), value); - + LLDB_INSTRUMENT_METHOD(void, SBBreakpointName, SetAllowDelete, (bool), value); BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) @@ -669,7 +673,7 @@ } bool SBBreakpointName::GetAllowDisable() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAllowDisable); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBBreakpointName, GetAllowDisable); BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) @@ -678,7 +682,8 @@ } void SBBreakpointName::SetAllowDisable(bool value) { - LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowDisable, (bool), value); + LLDB_INSTRUMENT_METHOD(void, SBBreakpointName, SetAllowDisable, (bool), + value); BreakpointName *bp_name = GetBreakpointName(); if (!bp_name) Index: lldb/source/API/SBBroadcaster.cpp =================================================================== --- lldb/source/API/SBBroadcaster.cpp +++ 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" @@ -17,12 +17,12 @@ using namespace lldb_private; SBBroadcaster::SBBroadcaster() { - LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBroadcaster); + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBBroadcaster); } 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_CONSTRUCTOR(SBBroadcaster, (const char *), name); m_opaque_ptr = m_opaque_sp.get(); } @@ -32,13 +32,13 @@ 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_CONSTRUCTOR(SBBroadcaster, (const lldb::SBBroadcaster &), + rhs); } const SBBroadcaster &SBBroadcaster::operator=(const SBBroadcaster &rhs) { - LLDB_RECORD_METHOD(const lldb::SBBroadcaster &, - SBBroadcaster, operator=,(const lldb::SBBroadcaster &), - rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBBroadcaster &, SBBroadcaster, operator=, + (const lldb::SBBroadcaster &), rhs); if (this != &rhs) { m_opaque_sp = rhs.m_opaque_sp; @@ -50,8 +50,8 @@ 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_METHOD(void, SBBroadcaster, BroadcastEventByType, + (uint32_t, bool), event_type, unique); if (m_opaque_ptr == nullptr) return; @@ -63,8 +63,8 @@ } void SBBroadcaster::BroadcastEvent(const SBEvent &event, bool unique) { - LLDB_RECORD_METHOD(void, SBBroadcaster, BroadcastEvent, - (const lldb::SBEvent &, bool), event, unique); + LLDB_INSTRUMENT_METHOD(void, SBBroadcaster, BroadcastEvent, + (const lldb::SBEvent &, bool), event, unique); if (m_opaque_ptr == nullptr) return; @@ -78,9 +78,9 @@ 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_METHOD(void, SBBroadcaster, AddInitialEventsToListener, + (const lldb::SBListener &, uint32_t), listener, + requested_events); if (m_opaque_ptr) m_opaque_ptr->AddInitialEventsToListener(listener.m_opaque_sp, @@ -89,9 +89,9 @@ 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_METHOD(uint32_t, SBBroadcaster, AddListener, + (const lldb::SBListener &, uint32_t), listener, + event_mask); if (m_opaque_ptr) return m_opaque_ptr->AddListener(listener.m_opaque_sp, event_mask); @@ -99,7 +99,7 @@ } const char *SBBroadcaster::GetName() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBroadcaster, GetName); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(const char *, SBBroadcaster, GetName); if (m_opaque_ptr) return m_opaque_ptr->GetBroadcasterName().GetCString(); @@ -107,8 +107,8 @@ } bool SBBroadcaster::EventTypeHasListeners(uint32_t event_type) { - LLDB_RECORD_METHOD(bool, SBBroadcaster, EventTypeHasListeners, (uint32_t), - event_type); + LLDB_INSTRUMENT_METHOD(bool, SBBroadcaster, EventTypeHasListeners, (uint32_t), + event_type); if (m_opaque_ptr) return m_opaque_ptr->EventTypeHasListeners(event_type); @@ -117,9 +117,9 @@ 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_METHOD(bool, SBBroadcaster, RemoveListener, + (const lldb::SBListener &, uint32_t), listener, + event_mask); if (m_opaque_ptr) return m_opaque_ptr->RemoveListener(listener.m_opaque_sp, event_mask); @@ -137,39 +137,39 @@ } bool SBBroadcaster::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBroadcaster, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBBroadcaster, IsValid); return this->operator bool(); } SBBroadcaster::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBroadcaster, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBBroadcaster, operator bool); return m_opaque_ptr != nullptr; } void SBBroadcaster::Clear() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBBroadcaster, Clear); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBBroadcaster, Clear); 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_METHOD_CONST(bool, SBBroadcaster, operator==, + (const lldb::SBBroadcaster &), rhs); return m_opaque_ptr == rhs.m_opaque_ptr; } bool SBBroadcaster::operator!=(const SBBroadcaster &rhs) const { - LLDB_RECORD_METHOD_CONST( - bool, SBBroadcaster, operator!=,(const lldb::SBBroadcaster &), rhs); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBBroadcaster, operator!=, + (const lldb::SBBroadcaster &), rhs); return m_opaque_ptr != rhs.m_opaque_ptr; } bool SBBroadcaster::operator<(const SBBroadcaster &rhs) const { - LLDB_RECORD_METHOD_CONST( - bool, SBBroadcaster, operator<,(const lldb::SBBroadcaster &), rhs); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBBroadcaster, operator<, + (const lldb::SBBroadcaster &), rhs); return m_opaque_ptr < rhs.m_opaque_ptr; } Index: lldb/source/API/SBCommandInterpreter.cpp =================================================================== --- lldb/source/API/SBCommandInterpreter.cpp +++ lldb/source/API/SBCommandInterpreter.cpp @@ -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,71 @@ SBCommandInterpreter::SBCommandInterpreter(CommandInterpreter *interpreter) : m_opaque_ptr(interpreter) { - LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreter, - (lldb_private::CommandInterpreter *), interpreter); - + LLDB_INSTRUMENT_CONSTRUCTOR( + SBCommandInterpreter, (lldb_private::CommandInterpreter *), interpreter); } SBCommandInterpreter::SBCommandInterpreter(const SBCommandInterpreter &rhs) : m_opaque_ptr(rhs.m_opaque_ptr) { - LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreter, - (const lldb::SBCommandInterpreter &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBCommandInterpreter, + (const lldb::SBCommandInterpreter &), rhs); } SBCommandInterpreter::~SBCommandInterpreter() = default; const SBCommandInterpreter &SBCommandInterpreter:: operator=(const SBCommandInterpreter &rhs) { - LLDB_RECORD_METHOD( - const lldb::SBCommandInterpreter &, - SBCommandInterpreter, operator=,(const lldb::SBCommandInterpreter &), - rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBCommandInterpreter &, + SBCommandInterpreter, operator=, + (const lldb::SBCommandInterpreter &), 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_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, IsValid); return this->operator bool(); } SBCommandInterpreter::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, + SBCommandInterpreter, operator bool); return m_opaque_ptr != nullptr; } bool SBCommandInterpreter::CommandExists(const char *cmd) { - LLDB_RECORD_METHOD(bool, SBCommandInterpreter, CommandExists, (const char *), - cmd); + LLDB_INSTRUMENT_METHOD(bool, SBCommandInterpreter, CommandExists, + (const char *), cmd); return (((cmd != nullptr) && IsValid()) ? m_opaque_ptr->CommandExists(cmd) : false); } bool SBCommandInterpreter::AliasExists(const char *cmd) { - LLDB_RECORD_METHOD(bool, SBCommandInterpreter, AliasExists, (const char *), - cmd); + LLDB_INSTRUMENT_METHOD(bool, SBCommandInterpreter, AliasExists, + (const char *), cmd); return (((cmd != nullptr) && IsValid()) ? m_opaque_ptr->AliasExists(cmd) : false); } bool SBCommandInterpreter::IsActive() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, IsActive); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBCommandInterpreter, IsActive); return (IsValid() ? m_opaque_ptr->IsActive() : false); } bool SBCommandInterpreter::WasInterrupted() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, WasInterrupted); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, + WasInterrupted); return (IsValid() ? m_opaque_ptr->WasInterrupted() : false); } const char *SBCommandInterpreter::GetIOHandlerControlSequence(char ch) { - LLDB_RECORD_METHOD(const char *, SBCommandInterpreter, - GetIOHandlerControlSequence, (char), ch); + LLDB_INSTRUMENT_METHOD(const char *, SBCommandInterpreter, + GetIOHandlerControlSequence, (char), ch); return (IsValid() ? m_opaque_ptr->GetDebugger() @@ -155,9 +155,10 @@ 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_METHOD(lldb::ReturnStatus, SBCommandInterpreter, + HandleCommand, + (const char *, lldb::SBCommandReturnObject &, bool), + command_line, result, add_to_history); SBExecutionContext sb_exe_ctx; return HandleCommand(command_line, sb_exe_ctx, result, add_to_history); @@ -166,10 +167,11 @@ 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_METHOD( + lldb::ReturnStatus, SBCommandInterpreter, HandleCommand, + (const char *, lldb::SBExecutionContext &, lldb::SBCommandReturnObject &, + bool), + command_line, override_context, result, add_to_history); result.Clear(); if (command_line && IsValid()) { @@ -194,11 +196,11 @@ 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_METHOD(void, SBCommandInterpreter, HandleCommandsFromFile, + (lldb::SBFileSpec &, lldb::SBExecutionContext &, + lldb::SBCommandInterpreterRunOptions &, + lldb::SBCommandReturnObject), + file, override_context, options, result); if (!IsValid()) { result->AppendError("SBCommandInterpreter is not valid."); @@ -225,11 +227,11 @@ int SBCommandInterpreter::HandleCompletion( const char *current_line, const char *cursor, const char *last_char, int match_start_point, int max_return_elements, SBStringList &matches) { - LLDB_RECORD_METHOD(int, SBCommandInterpreter, HandleCompletion, - (const char *, const char *, const char *, int, int, - lldb::SBStringList &), - current_line, cursor, last_char, match_start_point, - max_return_elements, matches); + LLDB_INSTRUMENT_METHOD(int, SBCommandInterpreter, HandleCompletion, + (const char *, const char *, const char *, int, int, + lldb::SBStringList &), + current_line, cursor, last_char, match_start_point, + max_return_elements, matches); SBStringList dummy_descriptions; return HandleCompletionWithDescriptions( @@ -241,12 +243,12 @@ const char *current_line, const char *cursor, const char *last_char, int match_start_point, int max_return_elements, SBStringList &matches, SBStringList &descriptions) { - LLDB_RECORD_METHOD(int, SBCommandInterpreter, - HandleCompletionWithDescriptions, - (const char *, const char *, const char *, int, int, - lldb::SBStringList &, lldb::SBStringList &), - current_line, cursor, last_char, match_start_point, - max_return_elements, matches, descriptions); + LLDB_INSTRUMENT_METHOD(int, SBCommandInterpreter, + HandleCompletionWithDescriptions, + (const char *, const char *, const char *, int, int, + lldb::SBStringList &, lldb::SBStringList &), + current_line, cursor, last_char, match_start_point, + max_return_elements, matches, descriptions); // Sanity check the arguments that are passed in: cursor & last_char have to // be within the current_line. @@ -311,12 +313,12 @@ const char *current_line, uint32_t cursor_pos, int match_start_point, int max_return_elements, SBStringList &matches, SBStringList &descriptions) { - LLDB_RECORD_METHOD(int, SBCommandInterpreter, - HandleCompletionWithDescriptions, - (const char *, uint32_t, int, int, lldb::SBStringList &, - lldb::SBStringList &), - current_line, cursor_pos, match_start_point, - max_return_elements, matches, descriptions); + LLDB_INSTRUMENT_METHOD(int, SBCommandInterpreter, + HandleCompletionWithDescriptions, + (const char *, uint32_t, int, int, + lldb::SBStringList &, lldb::SBStringList &), + current_line, cursor_pos, match_start_point, + max_return_elements, matches, descriptions); const char *cursor = current_line + cursor_pos; const char *last_char = current_line + strlen(current_line); @@ -330,10 +332,10 @@ int match_start_point, int max_return_elements, lldb::SBStringList &matches) { - LLDB_RECORD_METHOD(int, SBCommandInterpreter, HandleCompletion, - (const char *, uint32_t, int, int, lldb::SBStringList &), - current_line, cursor_pos, match_start_point, - max_return_elements, matches); + LLDB_INSTRUMENT_METHOD( + int, SBCommandInterpreter, HandleCompletion, + (const char *, uint32_t, int, int, lldb::SBStringList &), current_line, + cursor_pos, match_start_point, max_return_elements, matches); const char *cursor = current_line + cursor_pos; const char *last_char = current_line + strlen(current_line); @@ -342,25 +344,26 @@ } bool SBCommandInterpreter::HasCommands() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasCommands); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasCommands); return (IsValid() ? m_opaque_ptr->HasCommands() : false); } bool SBCommandInterpreter::HasAliases() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasAliases); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasAliases); return (IsValid() ? m_opaque_ptr->HasAliases() : false); } bool SBCommandInterpreter::HasAliasOptions() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasAliasOptions); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasAliasOptions); return (IsValid() ? m_opaque_ptr->HasAliasOptions() : false); } SBProcess SBCommandInterpreter::GetProcess() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBCommandInterpreter, GetProcess); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBProcess, SBCommandInterpreter, + GetProcess); SBProcess sb_process; ProcessSP process_sp; @@ -377,8 +380,8 @@ } SBDebugger SBCommandInterpreter::GetDebugger() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBDebugger, SBCommandInterpreter, - GetDebugger); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBDebugger, SBCommandInterpreter, + GetDebugger); SBDebugger sb_debugger; if (IsValid()) @@ -388,28 +391,30 @@ } bool SBCommandInterpreter::GetPromptOnQuit() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, GetPromptOnQuit); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBCommandInterpreter, GetPromptOnQuit); return (IsValid() ? m_opaque_ptr->GetPromptOnQuit() : false); } void SBCommandInterpreter::SetPromptOnQuit(bool b) { - LLDB_RECORD_METHOD(void, SBCommandInterpreter, SetPromptOnQuit, (bool), b); + LLDB_INSTRUMENT_METHOD(void, SBCommandInterpreter, SetPromptOnQuit, (bool), + b); if (IsValid()) m_opaque_ptr->SetPromptOnQuit(b); } void SBCommandInterpreter::AllowExitCodeOnQuit(bool allow) { - LLDB_RECORD_METHOD(void, SBCommandInterpreter, AllowExitCodeOnQuit, (bool), - allow); + LLDB_INSTRUMENT_METHOD(void, SBCommandInterpreter, AllowExitCodeOnQuit, + (bool), allow); if (m_opaque_ptr) m_opaque_ptr->AllowExitCodeOnQuit(allow); } bool SBCommandInterpreter::HasCustomQuitExitCode() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasCustomQuitExitCode); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBCommandInterpreter, + HasCustomQuitExitCode); bool exited = false; if (m_opaque_ptr) @@ -418,7 +423,7 @@ } int SBCommandInterpreter::GetQuitStatus() { - LLDB_RECORD_METHOD_NO_ARGS(int, SBCommandInterpreter, GetQuitStatus); + LLDB_INSTRUMENT_METHOD_NO_ARGS(int, SBCommandInterpreter, GetQuitStatus); bool exited = false; return (m_opaque_ptr ? m_opaque_ptr->GetQuitExitCode(exited) : 0); @@ -426,9 +431,9 @@ void SBCommandInterpreter::ResolveCommand(const char *command_line, SBCommandReturnObject &result) { - LLDB_RECORD_METHOD(void, SBCommandInterpreter, ResolveCommand, - (const char *, lldb::SBCommandReturnObject &), - command_line, result); + LLDB_INSTRUMENT_METHOD(void, SBCommandInterpreter, ResolveCommand, + (const char *, lldb::SBCommandReturnObject &), + command_line, result); result.Clear(); if (command_line && IsValid()) { @@ -453,8 +458,9 @@ void SBCommandInterpreter::SourceInitFileInHomeDirectory( SBCommandReturnObject &result) { - LLDB_RECORD_METHOD(void, SBCommandInterpreter, SourceInitFileInHomeDirectory, - (lldb::SBCommandReturnObject &), result); + LLDB_INSTRUMENT_METHOD(void, SBCommandInterpreter, + SourceInitFileInHomeDirectory, + (lldb::SBCommandReturnObject &), result); result.Clear(); if (IsValid()) { @@ -470,8 +476,9 @@ void SBCommandInterpreter::SourceInitFileInHomeDirectory( SBCommandReturnObject &result, bool is_repl) { - LLDB_RECORD_METHOD(void, SBCommandInterpreter, SourceInitFileInHomeDirectory, - (lldb::SBCommandReturnObject &, bool), result, is_repl); + LLDB_INSTRUMENT_METHOD( + void, SBCommandInterpreter, SourceInitFileInHomeDirectory, + (lldb::SBCommandReturnObject &, bool), result, is_repl); result.Clear(); if (IsValid()) { @@ -487,9 +494,9 @@ void SBCommandInterpreter::SourceInitFileInCurrentWorkingDirectory( SBCommandReturnObject &result) { - LLDB_RECORD_METHOD(void, SBCommandInterpreter, - SourceInitFileInCurrentWorkingDirectory, - (lldb::SBCommandReturnObject &), result); + LLDB_INSTRUMENT_METHOD(void, SBCommandInterpreter, + SourceInitFileInCurrentWorkingDirectory, + (lldb::SBCommandReturnObject &), result); result.Clear(); if (IsValid()) { @@ -504,9 +511,8 @@ } SBBroadcaster SBCommandInterpreter::GetBroadcaster() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBroadcaster, SBCommandInterpreter, - GetBroadcaster); - + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBBroadcaster, SBCommandInterpreter, + GetBroadcaster); SBBroadcaster broadcaster(m_opaque_ptr, false); @@ -514,35 +520,35 @@ } const char *SBCommandInterpreter::GetBroadcasterClass() { - LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBCommandInterpreter, - GetBroadcasterClass); + LLDB_INSTRUMENT_STATIC_METHOD_NO_ARGS(const char *, SBCommandInterpreter, + GetBroadcasterClass); return CommandInterpreter::GetStaticBroadcasterClass().AsCString(); } const char *SBCommandInterpreter::GetArgumentTypeAsCString( const lldb::CommandArgumentType arg_type) { - LLDB_RECORD_STATIC_METHOD(const char *, SBCommandInterpreter, - GetArgumentTypeAsCString, - (const lldb::CommandArgumentType), arg_type); + LLDB_INSTRUMENT_STATIC_METHOD(const char *, SBCommandInterpreter, + GetArgumentTypeAsCString, + (const lldb::CommandArgumentType), arg_type); return CommandObject::GetArgumentTypeAsCString(arg_type); } const char *SBCommandInterpreter::GetArgumentDescriptionAsCString( const lldb::CommandArgumentType arg_type) { - LLDB_RECORD_STATIC_METHOD(const char *, SBCommandInterpreter, - GetArgumentDescriptionAsCString, - (const lldb::CommandArgumentType), arg_type); + LLDB_INSTRUMENT_STATIC_METHOD(const char *, SBCommandInterpreter, + GetArgumentDescriptionAsCString, + (const lldb::CommandArgumentType), arg_type); return CommandObject::GetArgumentDescriptionAsCString(arg_type); } bool SBCommandInterpreter::EventIsCommandInterpreterEvent( const lldb::SBEvent &event) { - LLDB_RECORD_STATIC_METHOD(bool, SBCommandInterpreter, - EventIsCommandInterpreterEvent, - (const lldb::SBEvent &), event); + LLDB_INSTRUMENT_STATIC_METHOD(bool, SBCommandInterpreter, + EventIsCommandInterpreterEvent, + (const lldb::SBEvent &), event); return event.GetBroadcasterClass() == SBCommandInterpreter::GetBroadcasterClass(); @@ -551,9 +557,9 @@ 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_METHOD(bool, SBCommandInterpreter, SetCommandOverrideCallback, + (const char *, lldb::CommandOverrideCallback, void *), + command_name, callback, baton); if (command_name && command_name[0] && IsValid()) { llvm::StringRef command_name_str = command_name; @@ -570,8 +576,9 @@ 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_METHOD(lldb::SBCommand, SBCommandInterpreter, + AddMultiwordCommand, (const char *, const char *), + name, help); lldb::CommandObjectSP new_command_sp( new CommandObjectMultiword(*m_opaque_ptr, name, help)); @@ -584,7 +591,7 @@ lldb::SBCommand SBCommandInterpreter::AddCommand( const char *name, lldb::SBCommandPluginInterface *impl, const char *help) { - LLDB_RECORD_METHOD( + LLDB_INSTRUMENT_METHOD( lldb::SBCommand, SBCommandInterpreter, AddCommand, (const char *, lldb::SBCommandPluginInterface *, const char *), name, impl, help); @@ -597,20 +604,20 @@ 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_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand, + (const char *, lldb::SBCommandPluginInterface *, + const char *, const char *), + 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_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand, + (const char *, lldb::SBCommandPluginInterface *, + const char *, const char *, const char *), + name, impl, help, syntax, auto_repeat_command); lldb::CommandObjectSP new_command_sp; new_command_sp = std::make_shared( @@ -623,49 +630,49 @@ return lldb::SBCommand(); } -SBCommand::SBCommand() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommand); } +SBCommand::SBCommand() { LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBCommand); } SBCommand::SBCommand(lldb::CommandObjectSP cmd_sp) : m_opaque_sp(cmd_sp) {} bool SBCommand::IsValid() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommand, IsValid); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBCommand, IsValid); return this->operator bool(); } SBCommand::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommand, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBCommand, operator bool); return m_opaque_sp.get() != nullptr; } const char *SBCommand::GetName() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetName); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBCommand, GetName); return (IsValid() ? ConstString(m_opaque_sp->GetCommandName()).AsCString() : nullptr); } const char *SBCommand::GetHelp() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetHelp); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBCommand, GetHelp); return (IsValid() ? ConstString(m_opaque_sp->GetHelp()).AsCString() : nullptr); } const char *SBCommand::GetHelpLong() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetHelpLong); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBCommand, GetHelpLong); return (IsValid() ? ConstString(m_opaque_sp->GetHelpLong()).AsCString() : nullptr); } void SBCommand::SetHelp(const char *help) { - LLDB_RECORD_METHOD(void, SBCommand, SetHelp, (const char *), help); + LLDB_INSTRUMENT_METHOD(void, SBCommand, SetHelp, (const char *), help); if (IsValid()) m_opaque_sp->SetHelp(help); } void SBCommand::SetHelpLong(const char *help) { - LLDB_RECORD_METHOD(void, SBCommand, SetHelpLong, (const char *), help); + LLDB_INSTRUMENT_METHOD(void, SBCommand, SetHelpLong, (const char *), help); if (IsValid()) m_opaque_sp->SetHelpLong(help); @@ -673,8 +680,8 @@ 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_METHOD(lldb::SBCommand, SBCommand, AddMultiwordCommand, + (const char *, const char *), name, help); if (!IsValid()) return lldb::SBCommand(); @@ -692,7 +699,7 @@ lldb::SBCommand SBCommand::AddCommand(const char *name, lldb::SBCommandPluginInterface *impl, const char *help) { - LLDB_RECORD_METHOD( + LLDB_INSTRUMENT_METHOD( lldb::SBCommand, SBCommand, AddCommand, (const char *, lldb::SBCommandPluginInterface *, const char *), name, impl, help); @@ -703,10 +710,10 @@ 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_METHOD(lldb::SBCommand, SBCommand, AddCommand, + (const char *, lldb::SBCommandPluginInterface *, + const char *, const char *), + name, impl, help, syntax); return AddCommand(name, impl, help, syntax, /*auto_repeat_command=*/""); } @@ -714,10 +721,10 @@ 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_METHOD(lldb::SBCommand, SBCommand, AddCommand, + (const char *, lldb::SBCommandPluginInterface *, + const char *, const char *, const char *), + name, impl, help, syntax, auto_repeat_command); if (!IsValid()) return lldb::SBCommand(); @@ -733,13 +740,13 @@ } uint32_t SBCommand::GetFlags() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBCommand, GetFlags); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBCommand, GetFlags); return (IsValid() ? m_opaque_sp->GetFlags().Get() : 0); } void SBCommand::SetFlags(uint32_t flags) { - LLDB_RECORD_METHOD(void, SBCommand, SetFlags, (uint32_t), flags); + LLDB_INSTRUMENT_METHOD(void, SBCommand, SetFlags, (uint32_t), flags); if (IsValid()) m_opaque_sp->GetFlags().Set(flags); Index: lldb/source/API/SBCommandInterpreterRunOptions.cpp =================================================================== --- lldb/source/API/SBCommandInterpreterRunOptions.cpp +++ 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,16 @@ using namespace lldb_private; SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions() { - LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommandInterpreterRunOptions); + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBCommandInterpreterRunOptions); m_opaque_up = std::make_unique(); } SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions( const SBCommandInterpreterRunOptions &rhs) { - LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreterRunOptions, - (const lldb::SBCommandInterpreterRunOptions &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBCommandInterpreterRunOptions, + (const lldb::SBCommandInterpreterRunOptions &), + rhs); m_opaque_up = std::make_unique(rhs.ref()); } @@ -36,9 +37,9 @@ SBCommandInterpreterRunOptions &SBCommandInterpreterRunOptions::operator=( const SBCommandInterpreterRunOptions &rhs) { - LLDB_RECORD_METHOD(lldb::SBCommandInterpreterRunOptions &, - SBCommandInterpreterRunOptions, operator=, - (const lldb::SBCommandInterpreterRunOptions &), rhs); + LLDB_INSTRUMENT_METHOD(lldb::SBCommandInterpreterRunOptions &, + SBCommandInterpreterRunOptions, operator=, + (const lldb::SBCommandInterpreterRunOptions &), rhs); if (this == &rhs) return *this; @@ -47,142 +48,142 @@ } bool SBCommandInterpreterRunOptions::GetStopOnContinue() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, - GetStopOnContinue); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, + GetStopOnContinue); return m_opaque_up->GetStopOnContinue(); } void SBCommandInterpreterRunOptions::SetStopOnContinue(bool stop_on_continue) { - LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnContinue, - (bool), stop_on_continue); + LLDB_INSTRUMENT_METHOD(void, SBCommandInterpreterRunOptions, + SetStopOnContinue, (bool), stop_on_continue); m_opaque_up->SetStopOnContinue(stop_on_continue); } bool SBCommandInterpreterRunOptions::GetStopOnError() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, - GetStopOnError); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, + GetStopOnError); return m_opaque_up->GetStopOnError(); } void SBCommandInterpreterRunOptions::SetStopOnError(bool stop_on_error) { - LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnError, - (bool), stop_on_error); + LLDB_INSTRUMENT_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnError, + (bool), stop_on_error); m_opaque_up->SetStopOnError(stop_on_error); } bool SBCommandInterpreterRunOptions::GetStopOnCrash() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, - GetStopOnCrash); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, + GetStopOnCrash); return m_opaque_up->GetStopOnCrash(); } void SBCommandInterpreterRunOptions::SetStopOnCrash(bool stop_on_crash) { - LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnCrash, - (bool), stop_on_crash); + LLDB_INSTRUMENT_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnCrash, + (bool), stop_on_crash); m_opaque_up->SetStopOnCrash(stop_on_crash); } bool SBCommandInterpreterRunOptions::GetEchoCommands() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, - GetEchoCommands); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, + GetEchoCommands); return m_opaque_up->GetEchoCommands(); } void SBCommandInterpreterRunOptions::SetEchoCommands(bool echo_commands) { - LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetEchoCommands, - (bool), echo_commands); + LLDB_INSTRUMENT_METHOD(void, SBCommandInterpreterRunOptions, SetEchoCommands, + (bool), echo_commands); m_opaque_up->SetEchoCommands(echo_commands); } bool SBCommandInterpreterRunOptions::GetEchoCommentCommands() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, - GetEchoCommentCommands); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, + GetEchoCommentCommands); return m_opaque_up->GetEchoCommentCommands(); } void SBCommandInterpreterRunOptions::SetEchoCommentCommands(bool echo) { - LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, - SetEchoCommentCommands, (bool), echo); + LLDB_INSTRUMENT_METHOD(void, SBCommandInterpreterRunOptions, + SetEchoCommentCommands, (bool), echo); m_opaque_up->SetEchoCommentCommands(echo); } bool SBCommandInterpreterRunOptions::GetPrintResults() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, - GetPrintResults); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, + GetPrintResults); return m_opaque_up->GetPrintResults(); } void SBCommandInterpreterRunOptions::SetPrintResults(bool print_results) { - LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetPrintResults, - (bool), print_results); + LLDB_INSTRUMENT_METHOD(void, SBCommandInterpreterRunOptions, SetPrintResults, + (bool), print_results); m_opaque_up->SetPrintResults(print_results); } bool SBCommandInterpreterRunOptions::GetPrintErrors() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, - GetPrintErrors); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, + GetPrintErrors); return m_opaque_up->GetPrintErrors(); } void SBCommandInterpreterRunOptions::SetPrintErrors(bool print_errors) { - LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetPrintErrors, - (bool), print_errors); + LLDB_INSTRUMENT_METHOD(void, SBCommandInterpreterRunOptions, SetPrintErrors, + (bool), print_errors); m_opaque_up->SetPrintErrors(print_errors); } bool SBCommandInterpreterRunOptions::GetAddToHistory() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, - GetAddToHistory); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, + GetAddToHistory); return m_opaque_up->GetAddToHistory(); } void SBCommandInterpreterRunOptions::SetAddToHistory(bool add_to_history) { - LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetAddToHistory, - (bool), add_to_history); + LLDB_INSTRUMENT_METHOD(void, SBCommandInterpreterRunOptions, SetAddToHistory, + (bool), 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_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, + GetAutoHandleEvents); return m_opaque_up->GetAutoHandleEvents(); } void SBCommandInterpreterRunOptions::SetAutoHandleEvents( bool auto_handle_events) { - LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetAutoHandleEvents, - (bool), auto_handle_events); + LLDB_INSTRUMENT_METHOD(void, SBCommandInterpreterRunOptions, + SetAutoHandleEvents, (bool), 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_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, + GetSpawnThread); return m_opaque_up->GetSpawnThread(); } void SBCommandInterpreterRunOptions::SetSpawnThread(bool spawn_thread) { - LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetSpawnThread, - (bool), spawn_thread); + LLDB_INSTRUMENT_METHOD(void, SBCommandInterpreterRunOptions, SetSpawnThread, + (bool), spawn_thread); m_opaque_up->SetSpawnThread(spawn_thread); } @@ -201,14 +202,15 @@ : m_opaque_up(new CommandInterpreterRunResult()) { - LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommandInterpreterRunResult); + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBCommandInterpreterRunResult); } SBCommandInterpreterRunResult::SBCommandInterpreterRunResult( const SBCommandInterpreterRunResult &rhs) : m_opaque_up(new CommandInterpreterRunResult()) { - LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreterRunResult, - (const lldb::SBCommandInterpreterRunResult &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBCommandInterpreterRunResult, + (const lldb::SBCommandInterpreterRunResult &), + rhs); *m_opaque_up = *rhs.m_opaque_up; } @@ -222,9 +224,9 @@ SBCommandInterpreterRunResult &SBCommandInterpreterRunResult::operator=( const SBCommandInterpreterRunResult &rhs) { - LLDB_RECORD_METHOD(lldb::SBCommandInterpreterRunResult &, - SBCommandInterpreterRunResult, operator=, - (const lldb::SBCommandInterpreterRunResult &), rhs); + LLDB_INSTRUMENT_METHOD(lldb::SBCommandInterpreterRunResult &, + SBCommandInterpreterRunResult, operator=, + (const lldb::SBCommandInterpreterRunResult &), rhs); if (this == &rhs) return *this; @@ -233,16 +235,16 @@ } int SBCommandInterpreterRunResult::GetNumberOfErrors() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(int, SBCommandInterpreterRunResult, - GetNumberOfErrors); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(int, SBCommandInterpreterRunResult, + GetNumberOfErrors); return m_opaque_up->GetNumErrors(); } lldb::CommandInterpreterResult SBCommandInterpreterRunResult::GetResult() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::CommandInterpreterResult, - SBCommandInterpreterRunResult, GetResult); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS( + lldb::CommandInterpreterResult, SBCommandInterpreterRunResult, GetResult); return m_opaque_up->GetResult(); } Index: lldb/source/API/SBCommandReturnObject.cpp =================================================================== --- lldb/source/API/SBCommandReturnObject.cpp +++ 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,27 @@ SBCommandReturnObject::SBCommandReturnObject() : m_opaque_up(new SBCommandReturnObjectImpl()) { - LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommandReturnObject); + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBCommandReturnObject); } SBCommandReturnObject::SBCommandReturnObject(CommandReturnObject &ref) : m_opaque_up(new SBCommandReturnObjectImpl(ref)) { - LLDB_RECORD_CONSTRUCTOR(SBCommandReturnObject, - (lldb_private::CommandReturnObject &), ref); + LLDB_INSTRUMENT_CONSTRUCTOR(SBCommandReturnObject, + (lldb_private::CommandReturnObject &), ref); } SBCommandReturnObject::SBCommandReturnObject(const SBCommandReturnObject &rhs) { - LLDB_RECORD_CONSTRUCTOR(SBCommandReturnObject, - (const lldb::SBCommandReturnObject &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBCommandReturnObject, + (const lldb::SBCommandReturnObject &), 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_METHOD(lldb::SBCommandReturnObject &, + SBCommandReturnObject, operator=, + (const lldb::SBCommandReturnObject &), rhs); if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); @@ -77,44 +76,47 @@ SBCommandReturnObject::~SBCommandReturnObject() = default; bool SBCommandReturnObject::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandReturnObject, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBCommandReturnObject, IsValid); return this->operator bool(); } SBCommandReturnObject::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandReturnObject, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, + SBCommandReturnObject, operator bool); // 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_METHOD_NO_ARGS(const char *, SBCommandReturnObject, + GetOutput); 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_METHOD_NO_ARGS(const char *, SBCommandReturnObject, GetError); 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_METHOD_NO_ARGS(size_t, SBCommandReturnObject, GetOutputSize); return ref().GetOutputData().size(); } size_t SBCommandReturnObject::GetErrorSize() { - LLDB_RECORD_METHOD_NO_ARGS(size_t, SBCommandReturnObject, GetErrorSize); + LLDB_INSTRUMENT_METHOD_NO_ARGS(size_t, SBCommandReturnObject, GetErrorSize); return ref().GetErrorData().size(); } size_t SBCommandReturnObject::PutOutput(FILE *fh) { - LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutOutput, (FILE *), fh); + LLDB_INSTRUMENT_METHOD(size_t, SBCommandReturnObject, PutOutput, (FILE *), + fh); if (fh) { size_t num_bytes = GetOutputSize(); if (num_bytes) @@ -124,22 +126,23 @@ } size_t SBCommandReturnObject::PutOutput(FileSP file_sp) { - LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutOutput, (FileSP), - file_sp); + LLDB_INSTRUMENT_METHOD(size_t, SBCommandReturnObject, PutOutput, (FileSP), + 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_METHOD(size_t, SBCommandReturnObject, PutOutput, (SBFile), + 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_METHOD(size_t, SBCommandReturnObject, PutError, (FILE *), fh); if (fh) { size_t num_bytes = GetErrorSize(); if (num_bytes) @@ -149,62 +152,63 @@ } size_t SBCommandReturnObject::PutError(FileSP file_sp) { - LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutError, (FileSP), - file_sp); + LLDB_INSTRUMENT_METHOD(size_t, SBCommandReturnObject, PutError, (FileSP), + 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_METHOD(size_t, SBCommandReturnObject, PutError, (SBFile), + 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_METHOD_NO_ARGS(void, SBCommandReturnObject, Clear); ref().Clear(); } lldb::ReturnStatus SBCommandReturnObject::GetStatus() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::ReturnStatus, SBCommandReturnObject, - GetStatus); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::ReturnStatus, SBCommandReturnObject, + GetStatus); return ref().GetStatus(); } void SBCommandReturnObject::SetStatus(lldb::ReturnStatus status) { - LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetStatus, - (lldb::ReturnStatus), status); + LLDB_INSTRUMENT_METHOD(void, SBCommandReturnObject, SetStatus, + (lldb::ReturnStatus), status); ref().SetStatus(status); } bool SBCommandReturnObject::Succeeded() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandReturnObject, Succeeded); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBCommandReturnObject, Succeeded); return ref().Succeeded(); } bool SBCommandReturnObject::HasResult() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandReturnObject, HasResult); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBCommandReturnObject, HasResult); return ref().HasResult(); } void SBCommandReturnObject::AppendMessage(const char *message) { - LLDB_RECORD_METHOD(void, SBCommandReturnObject, AppendMessage, (const char *), - message); + LLDB_INSTRUMENT_METHOD(void, SBCommandReturnObject, AppendMessage, + (const char *), message); ref().AppendMessage(message); } void SBCommandReturnObject::AppendWarning(const char *message) { - LLDB_RECORD_METHOD(void, SBCommandReturnObject, AppendWarning, (const char *), - message); + LLDB_INSTRUMENT_METHOD(void, SBCommandReturnObject, AppendWarning, + (const char *), message); ref().AppendWarning(message); } @@ -226,8 +230,8 @@ } bool SBCommandReturnObject::GetDescription(SBStream &description) { - LLDB_RECORD_METHOD(bool, SBCommandReturnObject, GetDescription, - (lldb::SBStream &), description); + LLDB_INSTRUMENT_METHOD(bool, SBCommandReturnObject, GetDescription, + (lldb::SBStream &), description); Stream &strm = description.ref(); @@ -252,62 +256,62 @@ } void SBCommandReturnObject::SetImmediateOutputFile(FILE *fh) { - LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile, - (FILE *), fh); + LLDB_INSTRUMENT_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile, + (FILE *), fh); SetImmediateOutputFile(fh, false); } void SBCommandReturnObject::SetImmediateErrorFile(FILE *fh) { - LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile, - (FILE *), fh); + LLDB_INSTRUMENT_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile, + (FILE *), fh); SetImmediateErrorFile(fh, false); } void SBCommandReturnObject::SetImmediateOutputFile(FILE *fh, bool transfer_ownership) { - LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile, - (FILE *, bool), fh, transfer_ownership); + LLDB_INSTRUMENT_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile, + (FILE *, bool), fh, transfer_ownership); FileSP file = std::make_shared(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_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile, + (FILE *, bool), fh, transfer_ownership); FileSP file = std::make_shared(fh, transfer_ownership); ref().SetImmediateErrorFile(file); } void SBCommandReturnObject::SetImmediateOutputFile(SBFile file) { - LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile, - (SBFile), file); + LLDB_INSTRUMENT_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile, + (SBFile), file); ref().SetImmediateOutputFile(file.m_opaque_sp); } void SBCommandReturnObject::SetImmediateErrorFile(SBFile file) { - LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile, - (SBFile), file); + LLDB_INSTRUMENT_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile, + (SBFile), file); ref().SetImmediateErrorFile(file.m_opaque_sp); } void SBCommandReturnObject::SetImmediateOutputFile(FileSP file_sp) { - LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile, - (FileSP), file_sp); + LLDB_INSTRUMENT_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile, + (FileSP), file_sp); SetImmediateOutputFile(SBFile(file_sp)); } void SBCommandReturnObject::SetImmediateErrorFile(FileSP file_sp) { - LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile, - (FileSP), file_sp); + LLDB_INSTRUMENT_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile, + (FileSP), 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_METHOD(void, SBCommandReturnObject, PutCString, + (const char *, int), string, len); if (len == 0 || string == nullptr || *string == 0) { return; @@ -319,8 +323,8 @@ } const char *SBCommandReturnObject::GetOutput(bool only_if_no_immediate) { - LLDB_RECORD_METHOD(const char *, SBCommandReturnObject, GetOutput, (bool), - only_if_no_immediate); + LLDB_INSTRUMENT_METHOD(const char *, SBCommandReturnObject, GetOutput, (bool), + only_if_no_immediate); if (!only_if_no_immediate || ref().GetImmediateOutputStream().get() == nullptr) @@ -329,8 +333,8 @@ } const char *SBCommandReturnObject::GetError(bool only_if_no_immediate) { - LLDB_RECORD_METHOD(const char *, SBCommandReturnObject, GetError, (bool), - only_if_no_immediate); + LLDB_INSTRUMENT_METHOD(const char *, SBCommandReturnObject, GetError, (bool), + only_if_no_immediate); if (!only_if_no_immediate || ref().GetImmediateErrorStream().get() == nullptr) return GetError(); @@ -347,9 +351,9 @@ 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_METHOD(void, SBCommandReturnObject, SetError, + (lldb::SBError &, const char *), error, + fallback_error_cstr); if (error.IsValid()) ref().SetError(error.ref(), fallback_error_cstr); @@ -358,8 +362,8 @@ } void SBCommandReturnObject::SetError(const char *error_cstr) { - LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetError, (const char *), - error_cstr); + LLDB_INSTRUMENT_METHOD(void, SBCommandReturnObject, SetError, (const char *), + error_cstr); if (error_cstr) ref().AppendError(error_cstr); Index: lldb/source/API/SBCommunication.cpp =================================================================== --- lldb/source/API/SBCommunication.cpp +++ lldb/source/API/SBCommunication.cpp @@ -7,22 +7,23 @@ //===----------------------------------------------------------------------===// #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); + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBCommunication); } SBCommunication::SBCommunication(const char *broadcaster_name) : m_opaque(new Communication(broadcaster_name)), m_opaque_owned(true) { - LLDB_RECORD_CONSTRUCTOR(SBCommunication, (const char *), broadcaster_name); + LLDB_INSTRUMENT_CONSTRUCTOR(SBCommunication, (const char *), + broadcaster_name); } SBCommunication::~SBCommunication() { @@ -33,17 +34,17 @@ } bool SBCommunication::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommunication, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBCommunication, IsValid); return this->operator bool(); } SBCommunication::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommunication, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBCommunication, operator bool); return m_opaque != nullptr; } bool SBCommunication::GetCloseOnEOF() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, GetCloseOnEOF); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBCommunication, GetCloseOnEOF); if (m_opaque) return m_opaque->GetCloseOnEOF(); @@ -51,15 +52,15 @@ } void SBCommunication::SetCloseOnEOF(bool b) { - LLDB_RECORD_METHOD(void, SBCommunication, SetCloseOnEOF, (bool), b); + LLDB_INSTRUMENT_METHOD(void, SBCommunication, SetCloseOnEOF, (bool), b); if (m_opaque) m_opaque->SetCloseOnEOF(b); } ConnectionStatus SBCommunication::Connect(const char *url) { - LLDB_RECORD_METHOD(lldb::ConnectionStatus, SBCommunication, Connect, - (const char *), url); + LLDB_INSTRUMENT_METHOD(lldb::ConnectionStatus, SBCommunication, Connect, + (const char *), url); if (m_opaque) { if (!m_opaque->HasConnection()) @@ -70,8 +71,8 @@ } ConnectionStatus SBCommunication::AdoptFileDesriptor(int fd, bool owns_fd) { - LLDB_RECORD_METHOD(lldb::ConnectionStatus, SBCommunication, - AdoptFileDesriptor, (int, bool), fd, owns_fd); + LLDB_INSTRUMENT_METHOD(lldb::ConnectionStatus, SBCommunication, + AdoptFileDesriptor, (int, bool), fd, owns_fd); ConnectionStatus status = eConnectionStatusNoConnection; if (m_opaque) { @@ -90,8 +91,8 @@ } ConnectionStatus SBCommunication::Disconnect() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::ConnectionStatus, SBCommunication, - Disconnect); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::ConnectionStatus, SBCommunication, + Disconnect); ConnectionStatus status = eConnectionStatusNoConnection; if (m_opaque) @@ -100,16 +101,16 @@ } bool SBCommunication::IsConnected() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommunication, IsConnected); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBCommunication, IsConnected); return m_opaque ? m_opaque->IsConnected() : false; } size_t SBCommunication::Read(void *dst, size_t dst_len, uint32_t timeout_usec, ConnectionStatus &status) { - LLDB_RECORD_METHOD(size_t, SBCommunication, Read, - (void *, size_t, uint32_t, lldb::ConnectionStatus &), dst, - dst_len, timeout_usec, status); + LLDB_INSTRUMENT_METHOD(size_t, SBCommunication, Read, + (void *, size_t, uint32_t, lldb::ConnectionStatus &), + dst, dst_len, timeout_usec, status); size_t bytes_read = 0; Timeout timeout = timeout_usec == UINT32_MAX @@ -125,9 +126,9 @@ 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_METHOD(size_t, SBCommunication, Write, + (const void *, size_t, lldb::ConnectionStatus &), src, + src_len, status); size_t bytes_written = 0; if (m_opaque) @@ -139,28 +140,29 @@ } bool SBCommunication::ReadThreadStart() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadStart); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadStart); return m_opaque ? m_opaque->StartReadThread() : false; } bool SBCommunication::ReadThreadStop() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadStop); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadStop); return m_opaque ? m_opaque->StopReadThread() : false; } bool SBCommunication::ReadThreadIsRunning() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadIsRunning); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadIsRunning); 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_METHOD( + bool, SBCommunication, SetReadThreadBytesReceivedCallback, + (lldb::SBCommunication::ReadThreadBytesReceived, void *), callback, + callback_baton); bool result = false; if (m_opaque) { @@ -171,16 +173,16 @@ } SBBroadcaster SBCommunication::GetBroadcaster() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBroadcaster, SBCommunication, - GetBroadcaster); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBBroadcaster, SBCommunication, + GetBroadcaster); SBBroadcaster broadcaster(m_opaque, false); return broadcaster; } const char *SBCommunication::GetBroadcasterClass() { - LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBCommunication, - GetBroadcasterClass); + LLDB_INSTRUMENT_STATIC_METHOD_NO_ARGS(const char *, SBCommunication, + GetBroadcasterClass); return Communication::GetStaticBroadcasterClass().AsCString(); } Index: lldb/source/API/SBCompileUnit.cpp =================================================================== --- lldb/source/API/SBCompileUnit.cpp +++ 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,12 +16,13 @@ #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); + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBCompileUnit); } SBCompileUnit::SBCompileUnit(lldb_private::CompileUnit *lldb_object_ptr) @@ -30,13 +30,13 @@ SBCompileUnit::SBCompileUnit(const SBCompileUnit &rhs) : m_opaque_ptr(rhs.m_opaque_ptr) { - LLDB_RECORD_CONSTRUCTOR(SBCompileUnit, (const lldb::SBCompileUnit &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBCompileUnit, (const lldb::SBCompileUnit &), + rhs); } const SBCompileUnit &SBCompileUnit::operator=(const SBCompileUnit &rhs) { - LLDB_RECORD_METHOD(const lldb::SBCompileUnit &, - SBCompileUnit, operator=,(const lldb::SBCompileUnit &), - rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBCompileUnit &, SBCompileUnit, operator=, + (const lldb::SBCompileUnit &), rhs); m_opaque_ptr = rhs.m_opaque_ptr; return *this; @@ -45,8 +45,8 @@ SBCompileUnit::~SBCompileUnit() { m_opaque_ptr = nullptr; } SBFileSpec SBCompileUnit::GetFileSpec() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBCompileUnit, - GetFileSpec); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBCompileUnit, + GetFileSpec); SBFileSpec file_spec; if (m_opaque_ptr) @@ -55,7 +55,8 @@ } uint32_t SBCompileUnit::GetNumLineEntries() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBCompileUnit, GetNumLineEntries); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(uint32_t, SBCompileUnit, + GetNumLineEntries); if (m_opaque_ptr) { LineTable *line_table = m_opaque_ptr->GetLineTable(); @@ -67,8 +68,8 @@ } SBLineEntry SBCompileUnit::GetLineEntryAtIndex(uint32_t idx) const { - LLDB_RECORD_METHOD_CONST(lldb::SBLineEntry, SBCompileUnit, - GetLineEntryAtIndex, (uint32_t), idx); + LLDB_INSTRUMENT_METHOD_CONST(lldb::SBLineEntry, SBCompileUnit, + GetLineEntryAtIndex, (uint32_t), idx); SBLineEntry sb_line_entry; if (m_opaque_ptr) { @@ -85,9 +86,9 @@ 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_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex, + (uint32_t, uint32_t, lldb::SBFileSpec *), + start_idx, line, inline_file_spec); const bool exact = true; return FindLineEntryIndex(start_idx, line, inline_file_spec, exact); @@ -96,9 +97,9 @@ 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_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex, + (uint32_t, uint32_t, lldb::SBFileSpec *, bool), + start_idx, line, inline_file_spec, exact); uint32_t index = UINT32_MAX; if (m_opaque_ptr) { @@ -118,7 +119,8 @@ } uint32_t SBCompileUnit::GetNumSupportFiles() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBCompileUnit, GetNumSupportFiles); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(uint32_t, SBCompileUnit, + GetNumSupportFiles); if (m_opaque_ptr) return m_opaque_ptr->GetSupportFiles().GetSize(); @@ -127,8 +129,8 @@ } lldb::SBTypeList SBCompileUnit::GetTypes(uint32_t type_mask) { - LLDB_RECORD_METHOD(lldb::SBTypeList, SBCompileUnit, GetTypes, (uint32_t), - type_mask); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeList, SBCompileUnit, GetTypes, (uint32_t), + type_mask); SBTypeList sb_type_list; @@ -151,8 +153,8 @@ } SBFileSpec SBCompileUnit::GetSupportFileAtIndex(uint32_t idx) const { - LLDB_RECORD_METHOD_CONST(lldb::SBFileSpec, SBCompileUnit, - GetSupportFileAtIndex, (uint32_t), idx); + LLDB_INSTRUMENT_METHOD_CONST(lldb::SBFileSpec, SBCompileUnit, + GetSupportFileAtIndex, (uint32_t), idx); SBFileSpec sb_file_spec; if (m_opaque_ptr) { @@ -166,9 +168,9 @@ 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_METHOD(uint32_t, SBCompileUnit, FindSupportFileIndex, + (uint32_t, const lldb::SBFileSpec &, bool), start_idx, + sb_file, full); if (m_opaque_ptr) { const FileSpecList &support_files = m_opaque_ptr->GetSupportFiles(); @@ -178,7 +180,8 @@ } lldb::LanguageType SBCompileUnit::GetLanguage() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::LanguageType, SBCompileUnit, GetLanguage); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::LanguageType, SBCompileUnit, + GetLanguage); if (m_opaque_ptr) return m_opaque_ptr->GetLanguage(); @@ -186,25 +189,25 @@ } bool SBCompileUnit::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCompileUnit, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBCompileUnit, IsValid); return this->operator bool(); } SBCompileUnit::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCompileUnit, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBCompileUnit, operator bool); return m_opaque_ptr != nullptr; } bool SBCompileUnit::operator==(const SBCompileUnit &rhs) const { - LLDB_RECORD_METHOD_CONST( - bool, SBCompileUnit, operator==,(const lldb::SBCompileUnit &), rhs); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBCompileUnit, operator==, + (const lldb::SBCompileUnit &), rhs); return m_opaque_ptr == rhs.m_opaque_ptr; } bool SBCompileUnit::operator!=(const SBCompileUnit &rhs) const { - LLDB_RECORD_METHOD_CONST( - bool, SBCompileUnit, operator!=,(const lldb::SBCompileUnit &), rhs); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBCompileUnit, operator!=, + (const lldb::SBCompileUnit &), rhs); return m_opaque_ptr != rhs.m_opaque_ptr; } @@ -224,8 +227,8 @@ } bool SBCompileUnit::GetDescription(SBStream &description) { - LLDB_RECORD_METHOD(bool, SBCompileUnit, GetDescription, (lldb::SBStream &), - description); + LLDB_INSTRUMENT_METHOD(bool, SBCompileUnit, GetDescription, + (lldb::SBStream &), description); Stream &strm = description.ref(); Index: lldb/source/API/SBData.cpp =================================================================== --- lldb/source/API/SBData.cpp +++ 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,18 @@ using namespace lldb_private; SBData::SBData() : m_opaque_sp(new DataExtractor()) { - LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBData); + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBData); } SBData::SBData(const lldb::DataExtractorSP &data_sp) : m_opaque_sp(data_sp) {} SBData::SBData(const SBData &rhs) : m_opaque_sp(rhs.m_opaque_sp) { - LLDB_RECORD_CONSTRUCTOR(SBData, (const lldb::SBData &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBData, (const lldb::SBData &), rhs); } const SBData &SBData::operator=(const SBData &rhs) { - LLDB_RECORD_METHOD(const lldb::SBData &, - SBData, operator=,(const lldb::SBData &), rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBData &, SBData, operator=, + (const lldb::SBData &), rhs); if (this != &rhs) m_opaque_sp = rhs.m_opaque_sp; @@ -58,17 +58,17 @@ const lldb::DataExtractorSP &SBData::operator*() const { return m_opaque_sp; } bool SBData::IsValid() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBData, IsValid); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBData, IsValid); return this->operator bool(); } SBData::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBData, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBData, operator bool); return m_opaque_sp.get() != nullptr; } uint8_t SBData::GetAddressByteSize() { - LLDB_RECORD_METHOD_NO_ARGS(uint8_t, SBData, GetAddressByteSize); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint8_t, SBData, GetAddressByteSize); uint8_t value = 0; if (m_opaque_sp.get()) @@ -77,22 +77,22 @@ } void SBData::SetAddressByteSize(uint8_t addr_byte_size) { - LLDB_RECORD_METHOD(void, SBData, SetAddressByteSize, (uint8_t), - addr_byte_size); + LLDB_INSTRUMENT_METHOD(void, SBData, SetAddressByteSize, (uint8_t), + 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_METHOD_NO_ARGS(void, SBData, Clear); if (m_opaque_sp.get()) m_opaque_sp->Clear(); } size_t SBData::GetByteSize() { - LLDB_RECORD_METHOD_NO_ARGS(size_t, SBData, GetByteSize); + LLDB_INSTRUMENT_METHOD_NO_ARGS(size_t, SBData, GetByteSize); size_t value = 0; if (m_opaque_sp.get()) @@ -101,7 +101,7 @@ } lldb::ByteOrder SBData::GetByteOrder() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::ByteOrder, SBData, GetByteOrder); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::ByteOrder, SBData, GetByteOrder); lldb::ByteOrder value = eByteOrderInvalid; if (m_opaque_sp.get()) @@ -110,15 +110,15 @@ } void SBData::SetByteOrder(lldb::ByteOrder endian) { - LLDB_RECORD_METHOD(void, SBData, SetByteOrder, (lldb::ByteOrder), endian); + LLDB_INSTRUMENT_METHOD(void, SBData, SetByteOrder, (lldb::ByteOrder), 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_METHOD(float, SBData, GetFloat, + (lldb::SBError &, lldb::offset_t), error, offset); float value = 0; if (!m_opaque_sp.get()) { @@ -133,8 +133,8 @@ } 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_METHOD(double, SBData, GetDouble, + (lldb::SBError &, lldb::offset_t), error, offset); double value = 0; if (!m_opaque_sp.get()) { @@ -149,8 +149,8 @@ } 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_METHOD(long double, SBData, GetLongDouble, + (lldb::SBError &, lldb::offset_t), error, offset); long double value = 0; if (!m_opaque_sp.get()) { @@ -165,8 +165,8 @@ } 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_METHOD(lldb::addr_t, SBData, GetAddress, + (lldb::SBError &, lldb::offset_t), error, offset); lldb::addr_t value = 0; if (!m_opaque_sp.get()) { @@ -181,8 +181,8 @@ } 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_METHOD(uint8_t, SBData, GetUnsignedInt8, + (lldb::SBError &, lldb::offset_t), error, offset); uint8_t value = 0; if (!m_opaque_sp.get()) { @@ -197,8 +197,8 @@ } 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_METHOD(uint16_t, SBData, GetUnsignedInt16, + (lldb::SBError &, lldb::offset_t), error, offset); uint16_t value = 0; if (!m_opaque_sp.get()) { @@ -213,8 +213,8 @@ } 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_METHOD(uint32_t, SBData, GetUnsignedInt32, + (lldb::SBError &, lldb::offset_t), error, offset); uint32_t value = 0; if (!m_opaque_sp.get()) { @@ -229,8 +229,8 @@ } 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_METHOD(uint64_t, SBData, GetUnsignedInt64, + (lldb::SBError &, lldb::offset_t), error, offset); uint64_t value = 0; if (!m_opaque_sp.get()) { @@ -245,8 +245,8 @@ } 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_METHOD(int8_t, SBData, GetSignedInt8, + (lldb::SBError &, lldb::offset_t), error, offset); int8_t value = 0; if (!m_opaque_sp.get()) { @@ -261,8 +261,8 @@ } 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_METHOD(int16_t, SBData, GetSignedInt16, + (lldb::SBError &, lldb::offset_t), error, offset); int16_t value = 0; if (!m_opaque_sp.get()) { @@ -277,8 +277,8 @@ } 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_METHOD(int32_t, SBData, GetSignedInt32, + (lldb::SBError &, lldb::offset_t), error, offset); int32_t value = 0; if (!m_opaque_sp.get()) { @@ -293,8 +293,8 @@ } 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_METHOD(int64_t, SBData, GetSignedInt64, + (lldb::SBError &, lldb::offset_t), error, offset); int64_t value = 0; if (!m_opaque_sp.get()) { @@ -309,8 +309,8 @@ } 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_METHOD(const char *, SBData, GetString, + (lldb::SBError &, lldb::offset_t), error, offset); const char *value = nullptr; if (!m_opaque_sp.get()) { @@ -326,8 +326,9 @@ 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_METHOD(bool, SBData, GetDescription, + (lldb::SBStream &, lldb::addr_t), description, + base_addr); Stream &strm = description.ref(); @@ -342,9 +343,9 @@ 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_METHOD(size_t, SBData, ReadRawData, + (lldb::SBError &, lldb::offset_t, void *, size_t), + error, offset, buf, size); void *ok = nullptr; if (!m_opaque_sp.get()) { @@ -360,7 +361,7 @@ void SBData::SetData(lldb::SBError &error, const void *buf, size_t size, lldb::ByteOrder endian, uint8_t addr_size) { - LLDB_RECORD_METHOD( + LLDB_INSTRUMENT_METHOD( void, SBData, SetData, (lldb::SBError &, const void *, size_t, lldb::ByteOrder, uint8_t), error, buf, size, endian, addr_size); @@ -377,7 +378,7 @@ void SBData::SetDataWithOwnership(lldb::SBError &error, const void *buf, size_t size, lldb::ByteOrder endian, uint8_t addr_size) { - LLDB_RECORD_METHOD( + LLDB_INSTRUMENT_METHOD( void, SBData, SetData, (lldb::SBError &, const void *, size_t, lldb::ByteOrder, uint8_t, bool), error, buf, size, endian, addr_size); @@ -394,7 +395,7 @@ } bool SBData::Append(const SBData &rhs) { - LLDB_RECORD_METHOD(bool, SBData, Append, (const lldb::SBData &), rhs); + LLDB_INSTRUMENT_METHOD(bool, SBData, Append, (const lldb::SBData &), rhs); bool value = false; if (m_opaque_sp.get() && rhs.m_opaque_sp.get()) @@ -405,9 +406,9 @@ 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_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromCString, + (lldb::ByteOrder, uint32_t, const char *), + endian, addr_byte_size, data); if (!data || !data[0]) return SBData(); @@ -427,9 +428,9 @@ 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_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromUInt64Array, + (lldb::ByteOrder, uint32_t, uint64_t *, size_t), + endian, addr_byte_size, array, array_len); if (!array || array_len == 0) return SBData(); @@ -449,9 +450,9 @@ 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_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromUInt32Array, + (lldb::ByteOrder, uint32_t, uint32_t *, size_t), + endian, addr_byte_size, array, array_len); if (!array || array_len == 0) return SBData(); @@ -471,9 +472,9 @@ 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_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromSInt64Array, + (lldb::ByteOrder, uint32_t, int64_t *, size_t), + endian, addr_byte_size, array, array_len); if (!array || array_len == 0) return SBData(); @@ -493,9 +494,9 @@ 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_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromSInt32Array, + (lldb::ByteOrder, uint32_t, int32_t *, size_t), + endian, addr_byte_size, array, array_len); if (!array || array_len == 0) return SBData(); @@ -515,9 +516,9 @@ 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_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromDoubleArray, + (lldb::ByteOrder, uint32_t, double *, size_t), + endian, addr_byte_size, array, array_len); if (!array || array_len == 0) return SBData(); @@ -534,8 +535,8 @@ } bool SBData::SetDataFromCString(const char *data) { - LLDB_RECORD_METHOD(bool, SBData, SetDataFromCString, (const char *), data); - + LLDB_INSTRUMENT_METHOD(bool, SBData, SetDataFromCString, (const char *), + data); if (!data) { return false; @@ -556,9 +557,8 @@ } 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_METHOD(bool, SBData, SetDataFromUInt64Array, + (uint64_t *, size_t), array, array_len); if (!array || array_len == 0) { return false; @@ -579,9 +579,8 @@ } 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_METHOD(bool, SBData, SetDataFromUInt32Array, + (uint32_t *, size_t), array, array_len); if (!array || array_len == 0) { return false; @@ -601,9 +600,8 @@ } 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_METHOD(bool, SBData, SetDataFromSInt64Array, + (int64_t *, size_t), array, array_len); if (!array || array_len == 0) { return false; @@ -623,9 +621,8 @@ } 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_METHOD(bool, SBData, SetDataFromSInt32Array, + (int32_t *, size_t), array, array_len); if (!array || array_len == 0) { return false; @@ -645,9 +642,8 @@ } bool SBData::SetDataFromDoubleArray(double *array, size_t array_len) { - LLDB_RECORD_METHOD(bool, SBData, SetDataFromDoubleArray, (double *, size_t), - array, array_len); - + LLDB_INSTRUMENT_METHOD(bool, SBData, SetDataFromDoubleArray, + (double *, size_t), array, array_len); if (!array || array_len == 0) { return false; Index: lldb/source/API/SBDebugger.cpp =================================================================== --- lldb/source/API/SBDebugger.cpp +++ lldb/source/API/SBDebugger.cpp @@ -6,8 +6,8 @@ // //===----------------------------------------------------------------------===// -#include "lldb/Utility/ReproducerInstrumentation.h" #include "SystemInitializerFull.h" +#include "lldb/Utility/Instrumentation.h" #include "lldb/API/SBDebugger.h" @@ -105,7 +105,7 @@ unsigned long), void *a, lldb::InputReaderGranularity b, char const *c, char const *d, bool e) { - LLDB_RECORD_METHOD( + LLDB_INSTRUMENT_METHOD( lldb::SBError, SBInputReader, Initialize, (lldb::SBDebugger &, unsigned long (*)(void *, lldb::SBInputReader *, lldb::InputReaderAction, @@ -117,31 +117,32 @@ } void SBInputReader::SetIsDone(bool b) { - LLDB_RECORD_METHOD(void, SBInputReader, SetIsDone, (bool), b); + LLDB_INSTRUMENT_METHOD(void, SBInputReader, SetIsDone, (bool), b); } bool SBInputReader::IsActive() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInputReader, IsActive); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBInputReader, IsActive); return false; } -SBDebugger::SBDebugger() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBDebugger); } +SBDebugger::SBDebugger() { LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBDebugger); } SBDebugger::SBDebugger(const lldb::DebuggerSP &debugger_sp) : m_opaque_sp(debugger_sp) { - LLDB_RECORD_CONSTRUCTOR(SBDebugger, (const lldb::DebuggerSP &), debugger_sp); + LLDB_INSTRUMENT_CONSTRUCTOR(SBDebugger, (const lldb::DebuggerSP &), + debugger_sp); } SBDebugger::SBDebugger(const SBDebugger &rhs) : m_opaque_sp(rhs.m_opaque_sp) { - LLDB_RECORD_CONSTRUCTOR(SBDebugger, (const lldb::SBDebugger &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBDebugger, (const lldb::SBDebugger &), rhs); } SBDebugger::~SBDebugger() = default; SBDebugger &SBDebugger::operator=(const SBDebugger &rhs) { - LLDB_RECORD_METHOD(lldb::SBDebugger &, - SBDebugger, operator=,(const lldb::SBDebugger &), rhs); + LLDB_INSTRUMENT_METHOD(lldb::SBDebugger &, SBDebugger, operator=, + (const lldb::SBDebugger &), rhs); if (this != &rhs) { m_opaque_sp = rhs.m_opaque_sp; @@ -150,8 +151,8 @@ } const char *SBDebugger::GetBroadcasterClass() { - LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBDebugger, - GetBroadcasterClass); + LLDB_INSTRUMENT_STATIC_METHOD_NO_ARGS(const char *, SBDebugger, + GetBroadcasterClass); return Debugger::GetStaticBroadcasterClass().AsCString(); } @@ -171,7 +172,7 @@ is_debugger_specific = progress_data->IsDebuggerSpecific(); // We must record the static method _after_ the out parameters have been // filled in. - LLDB_RECORD_STATIC_METHOD( + LLDB_INSTRUMENT_STATIC_METHOD( const char *, SBDebugger, GetProgressFromEvent, (const lldb::SBEvent &, uint64_t &, uint64_t &, uint64_t &, bool &), event, progress_id, completed, total, is_debugger_specific); @@ -179,19 +180,20 @@ } SBBroadcaster SBDebugger::GetBroadcaster() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBroadcaster, SBDebugger, GetBroadcaster); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBBroadcaster, SBDebugger, + GetBroadcaster); SBBroadcaster broadcaster(&m_opaque_sp->GetBroadcaster(), false); return broadcaster; } void SBDebugger::Initialize() { - LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, Initialize); + LLDB_INSTRUMENT_STATIC_METHOD_NO_ARGS(void, SBDebugger, Initialize); SBError ignored = SBDebugger::InitializeWithErrorHandling(); } lldb::SBError SBDebugger::InitializeWithErrorHandling() { - LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBError, SBDebugger, - InitializeWithErrorHandling); + LLDB_INSTRUMENT_STATIC_METHOD_NO_ARGS(lldb::SBError, SBDebugger, + InitializeWithErrorHandling); SBError error; if (auto e = g_debugger_lifetime->Initialize( @@ -202,13 +204,13 @@ } void SBDebugger::Terminate() { - LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, Terminate); + LLDB_INSTRUMENT_STATIC_METHOD_NO_ARGS(void, SBDebugger, Terminate); g_debugger_lifetime->Terminate(); } void SBDebugger::Clear() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, Clear); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBDebugger, Clear); if (m_opaque_sp) m_opaque_sp->ClearIOHandlers(); @@ -217,14 +219,14 @@ } SBDebugger SBDebugger::Create() { - LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBDebugger, SBDebugger, Create); + LLDB_INSTRUMENT_STATIC_METHOD_NO_ARGS(lldb::SBDebugger, SBDebugger, Create); 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_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, (bool), + source_init_files); return SBDebugger::Create(source_init_files, nullptr, nullptr); } @@ -233,9 +235,9 @@ lldb::LogOutputCallback callback, void *baton) { - LLDB_RECORD_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, - (bool, lldb::LogOutputCallback, void *), - source_init_files, callback, baton); + LLDB_INSTRUMENT_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, + (bool, lldb::LogOutputCallback, void *), + source_init_files, callback, baton); SBDebugger debugger; @@ -263,8 +265,8 @@ } void SBDebugger::Destroy(SBDebugger &debugger) { - LLDB_RECORD_STATIC_METHOD(void, SBDebugger, Destroy, (lldb::SBDebugger &), - debugger); + LLDB_INSTRUMENT_STATIC_METHOD(void, SBDebugger, Destroy, (lldb::SBDebugger &), + debugger); Debugger::Destroy(debugger.m_opaque_sp); @@ -273,7 +275,8 @@ } void SBDebugger::MemoryPressureDetected() { - LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, MemoryPressureDetected); + LLDB_INSTRUMENT_STATIC_METHOD_NO_ARGS(void, SBDebugger, + MemoryPressureDetected); // Since this function can be call asynchronously, we allow it to be non- // mandatory. We have seen deadlocks with this function when called so we @@ -286,52 +289,53 @@ } bool SBDebugger::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBDebugger, IsValid); return this->operator bool(); } SBDebugger::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBDebugger, operator bool); return m_opaque_sp.get() != nullptr; } void SBDebugger::SetAsync(bool b) { - LLDB_RECORD_METHOD(void, SBDebugger, SetAsync, (bool), b); + LLDB_INSTRUMENT_METHOD(void, SBDebugger, SetAsync, (bool), b); if (m_opaque_sp) m_opaque_sp->SetAsyncExecution(b); } bool SBDebugger::GetAsync() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBDebugger, GetAsync); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBDebugger, GetAsync); return (m_opaque_sp ? m_opaque_sp->GetAsyncExecution() : false); } void SBDebugger::SkipLLDBInitFiles(bool b) { - LLDB_RECORD_METHOD(void, SBDebugger, SkipLLDBInitFiles, (bool), b); + LLDB_INSTRUMENT_METHOD(void, SBDebugger, SkipLLDBInitFiles, (bool), b); if (m_opaque_sp) m_opaque_sp->GetCommandInterpreter().SkipLLDBInitFiles(b); } void SBDebugger::SkipAppInitFiles(bool b) { - LLDB_RECORD_METHOD(void, SBDebugger, SkipAppInitFiles, (bool), b); + LLDB_INSTRUMENT_METHOD(void, SBDebugger, SkipAppInitFiles, (bool), 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_METHOD(void, SBDebugger, SetInputFileHandle, (FILE *, bool), + fh, transfer_ownership); if (m_opaque_sp) m_opaque_sp->SetInputFile( (FileSP)std::make_shared(fh, transfer_ownership)); } SBError SBDebugger::SetInputString(const char *data) { - LLDB_RECORD_METHOD(SBError, SBDebugger, SetInputString, (const char *), data); + LLDB_INSTRUMENT_METHOD(SBError, SBDebugger, SetInputString, (const char *), + data); SBError sb_error; if (data == nullptr) { sb_error.SetErrorString("String data is null"); @@ -357,7 +361,7 @@ // 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_METHOD(SBError, SBDebugger, SetInputFile, (SBFile), file); SBError error; if (!m_opaque_sp) { @@ -369,23 +373,24 @@ } SBError SBDebugger::SetInputFile(FileSP file_sp) { - LLDB_RECORD_METHOD(SBError, SBDebugger, SetInputFile, (FileSP), file_sp); + LLDB_INSTRUMENT_METHOD(SBError, SBDebugger, SetInputFile, (FileSP), file_sp); return SetInputFile(SBFile(file_sp)); } SBError SBDebugger::SetOutputFile(FileSP file_sp) { - LLDB_RECORD_METHOD(SBError, SBDebugger, SetOutputFile, (FileSP), file_sp); + LLDB_INSTRUMENT_METHOD(SBError, SBDebugger, SetOutputFile, (FileSP), 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_METHOD(void, SBDebugger, SetOutputFileHandle, (FILE *, bool), + fh, transfer_ownership); SetOutputFile((FileSP)std::make_shared(fh, transfer_ownership)); } SBError SBDebugger::SetOutputFile(SBFile file) { - LLDB_RECORD_METHOD(SBError, SBDebugger, SetOutputFile, (SBFile file), file); + LLDB_INSTRUMENT_METHOD(SBError, SBDebugger, SetOutputFile, (SBFile file), + file); SBError error; if (!m_opaque_sp) { error.ref().SetErrorString("invalid debugger"); @@ -400,18 +405,19 @@ } void SBDebugger::SetErrorFileHandle(FILE *fh, bool transfer_ownership) { - LLDB_RECORD_METHOD(void, SBDebugger, SetErrorFileHandle, (FILE *, bool), fh, - transfer_ownership); + LLDB_INSTRUMENT_METHOD(void, SBDebugger, SetErrorFileHandle, (FILE *, bool), + fh, transfer_ownership); SetErrorFile((FileSP)std::make_shared(fh, transfer_ownership)); } SBError SBDebugger::SetErrorFile(FileSP file_sp) { - LLDB_RECORD_METHOD(SBError, SBDebugger, SetErrorFile, (FileSP), file_sp); + LLDB_INSTRUMENT_METHOD(SBError, SBDebugger, SetErrorFile, (FileSP), file_sp); return SetErrorFile(SBFile(file_sp)); } SBError SBDebugger::SetErrorFile(SBFile file) { - LLDB_RECORD_METHOD(SBError, SBDebugger, SetErrorFile, (SBFile file), file); + LLDB_INSTRUMENT_METHOD(SBError, SBDebugger, SetErrorFile, (SBFile file), + file); SBError error; if (!m_opaque_sp) { error.ref().SetErrorString("invalid debugger"); @@ -426,7 +432,7 @@ } FILE *SBDebugger::GetInputFileHandle() { - LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetInputFileHandle); + LLDB_INSTRUMENT_METHOD_NO_ARGS(FILE *, SBDebugger, GetInputFileHandle); if (m_opaque_sp) { File &file_sp = m_opaque_sp->GetInputFile(); return file_sp.GetStream(); @@ -435,7 +441,7 @@ } SBFile SBDebugger::GetInputFile() { - LLDB_RECORD_METHOD_NO_ARGS(SBFile, SBDebugger, GetInputFile); + LLDB_INSTRUMENT_METHOD_NO_ARGS(SBFile, SBDebugger, GetInputFile); if (m_opaque_sp) { return SBFile(m_opaque_sp->GetInputFileSP()); } @@ -443,7 +449,7 @@ } FILE *SBDebugger::GetOutputFileHandle() { - LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetOutputFileHandle); + LLDB_INSTRUMENT_METHOD_NO_ARGS(FILE *, SBDebugger, GetOutputFileHandle); if (m_opaque_sp) { StreamFile &stream_file = m_opaque_sp->GetOutputStream(); return stream_file.GetFile().GetStream(); @@ -452,7 +458,7 @@ } SBFile SBDebugger::GetOutputFile() { - LLDB_RECORD_METHOD_NO_ARGS(SBFile, SBDebugger, GetOutputFile); + LLDB_INSTRUMENT_METHOD_NO_ARGS(SBFile, SBDebugger, GetOutputFile); if (m_opaque_sp) { SBFile file(m_opaque_sp->GetOutputStream().GetFileSP()); return file; @@ -461,7 +467,7 @@ } FILE *SBDebugger::GetErrorFileHandle() { - LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetErrorFileHandle); + LLDB_INSTRUMENT_METHOD_NO_ARGS(FILE *, SBDebugger, GetErrorFileHandle); if (m_opaque_sp) { StreamFile &stream_file = m_opaque_sp->GetErrorStream(); @@ -471,7 +477,7 @@ } SBFile SBDebugger::GetErrorFile() { - LLDB_RECORD_METHOD_NO_ARGS(SBFile, SBDebugger, GetErrorFile); + LLDB_INSTRUMENT_METHOD_NO_ARGS(SBFile, SBDebugger, GetErrorFile); SBFile file; if (m_opaque_sp) { SBFile file(m_opaque_sp->GetErrorStream().GetFileSP()); @@ -481,21 +487,21 @@ } void SBDebugger::SaveInputTerminalState() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, SaveInputTerminalState); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBDebugger, SaveInputTerminalState); if (m_opaque_sp) m_opaque_sp->SaveInputTerminalState(); } void SBDebugger::RestoreInputTerminalState() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, RestoreInputTerminalState); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBDebugger, RestoreInputTerminalState); if (m_opaque_sp) m_opaque_sp->RestoreInputTerminalState(); } SBCommandInterpreter SBDebugger::GetCommandInterpreter() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCommandInterpreter, SBDebugger, - GetCommandInterpreter); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBCommandInterpreter, SBDebugger, + GetCommandInterpreter); SBCommandInterpreter sb_interpreter; if (m_opaque_sp) @@ -505,7 +511,8 @@ } void SBDebugger::HandleCommand(const char *command) { - LLDB_RECORD_METHOD(void, SBDebugger, HandleCommand, (const char *), command); + LLDB_INSTRUMENT_METHOD(void, SBDebugger, HandleCommand, (const char *), + command); if (m_opaque_sp) { TargetSP target_sp(m_opaque_sp->GetSelectedTarget()); @@ -538,7 +545,7 @@ } SBListener SBDebugger::GetListener() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBDebugger, GetListener); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBListener, SBDebugger, GetListener); SBListener sb_listener; if (m_opaque_sp) @@ -550,7 +557,7 @@ void SBDebugger::HandleProcessEvent(const SBProcess &process, const SBEvent &event, SBFile out, SBFile err) { - LLDB_RECORD_METHOD( + LLDB_INSTRUMENT_METHOD( void, SBDebugger, HandleProcessEvent, (const lldb::SBProcess &, const lldb::SBEvent &, SBFile, SBFile), process, event, out, err); @@ -561,7 +568,7 @@ void SBDebugger::HandleProcessEvent(const SBProcess &process, const SBEvent &event, FILE *out, FILE *err) { - LLDB_RECORD_METHOD( + LLDB_INSTRUMENT_METHOD( void, SBDebugger, HandleProcessEvent, (const lldb::SBProcess &, const lldb::SBEvent &, FILE *, FILE *), process, event, out, err); @@ -575,7 +582,7 @@ const SBEvent &event, FileSP out_sp, FileSP err_sp) { - LLDB_RECORD_METHOD( + LLDB_INSTRUMENT_METHOD( void, SBDebugger, HandleProcessEvent, (const lldb::SBProcess &, const lldb::SBEvent &, FileSP, FileSP), process, event, out_sp, err_sp); @@ -622,16 +629,16 @@ } SBSourceManager SBDebugger::GetSourceManager() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSourceManager, SBDebugger, - GetSourceManager); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBSourceManager, SBDebugger, + GetSourceManager); 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_STATIC_METHOD(bool, SBDebugger, GetDefaultArchitecture, + (char *, size_t), arch_name, "", arch_name_len); if (arch_name && arch_name_len) { ArchSpec default_arch = Target::GetDefaultArchitecture(); @@ -652,8 +659,8 @@ } bool SBDebugger::SetDefaultArchitecture(const char *arch_name) { - LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, SetDefaultArchitecture, - (const char *), arch_name); + LLDB_INSTRUMENT_STATIC_METHOD(bool, SBDebugger, SetDefaultArchitecture, + (const char *), arch_name); if (arch_name) { ArchSpec arch(arch_name); @@ -667,8 +674,8 @@ ScriptLanguage SBDebugger::GetScriptingLanguage(const char *script_language_name) { - LLDB_RECORD_METHOD(lldb::ScriptLanguage, SBDebugger, GetScriptingLanguage, - (const char *), script_language_name); + LLDB_INSTRUMENT_METHOD(lldb::ScriptLanguage, SBDebugger, GetScriptingLanguage, + (const char *), script_language_name); if (!script_language_name) return eScriptLanguageDefault; @@ -678,8 +685,8 @@ SBStructuredData SBDebugger::GetScriptInterpreterInfo(lldb::ScriptLanguage language) { - LLDB_RECORD_METHOD(SBStructuredData, SBDebugger, GetScriptInterpreterInfo, - (lldb::ScriptLanguage), language); + LLDB_INSTRUMENT_METHOD(SBStructuredData, SBDebugger, GetScriptInterpreterInfo, + (lldb::ScriptLanguage), language); SBStructuredData data; if (m_opaque_sp) { lldb_private::ScriptInterpreter *interp = @@ -692,14 +699,15 @@ } const char *SBDebugger::GetVersionString() { - LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBDebugger, GetVersionString); + LLDB_INSTRUMENT_STATIC_METHOD_NO_ARGS(const char *, SBDebugger, + GetVersionString); return lldb_private::GetVersion(); } const char *SBDebugger::StateAsCString(StateType state) { - LLDB_RECORD_STATIC_METHOD(const char *, SBDebugger, StateAsCString, - (lldb::StateType), state); + LLDB_INSTRUMENT_STATIC_METHOD(const char *, SBDebugger, StateAsCString, + (lldb::StateType), state); return lldb_private::StateAsCString(state); } @@ -725,8 +733,8 @@ } SBStructuredData SBDebugger::GetBuildConfiguration() { - LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBStructuredData, SBDebugger, - GetBuildConfiguration); + LLDB_INSTRUMENT_STATIC_METHOD_NO_ARGS(lldb::SBStructuredData, SBDebugger, + GetBuildConfiguration); auto config_up = std::make_unique(); AddBoolConfigEntry( @@ -758,8 +766,8 @@ } bool SBDebugger::StateIsRunningState(StateType state) { - LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, StateIsRunningState, - (lldb::StateType), state); + LLDB_INSTRUMENT_STATIC_METHOD(bool, SBDebugger, StateIsRunningState, + (lldb::StateType), state); const bool result = lldb_private::StateIsRunningState(state); @@ -767,8 +775,8 @@ } bool SBDebugger::StateIsStoppedState(StateType state) { - LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, StateIsStoppedState, - (lldb::StateType), state); + LLDB_INSTRUMENT_STATIC_METHOD(bool, SBDebugger, StateIsStoppedState, + (lldb::StateType), state); const bool result = lldb_private::StateIsStoppedState(state, false); @@ -780,7 +788,7 @@ const char *platform_name, bool add_dependent_modules, lldb::SBError &sb_error) { - LLDB_RECORD_METHOD( + LLDB_INSTRUMENT_METHOD( lldb::SBTarget, SBDebugger, CreateTarget, (const char *, const char *, const char *, bool, lldb::SBError &), filename, target_triple, platform_name, add_dependent_modules, sb_error); @@ -818,9 +826,9 @@ 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_METHOD(lldb::SBTarget, SBDebugger, + CreateTargetWithFileAndTargetTriple, + (const char *, const char *), filename, target_triple); SBTarget sb_target; TargetSP target_sp; @@ -845,8 +853,9 @@ 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_METHOD(lldb::SBTarget, SBDebugger, + CreateTargetWithFileAndArch, + (const char *, const char *), filename, arch_cstr); Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); @@ -887,8 +896,8 @@ } SBTarget SBDebugger::CreateTarget(const char *filename) { - LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, CreateTarget, (const char *), - filename); + LLDB_INSTRUMENT_METHOD(lldb::SBTarget, SBDebugger, CreateTarget, + (const char *), filename); SBTarget sb_target; TargetSP target_sp; @@ -912,7 +921,7 @@ } SBTarget SBDebugger::GetDummyTarget() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBDebugger, GetDummyTarget); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBTarget, SBDebugger, GetDummyTarget); SBTarget sb_target; if (m_opaque_sp) { @@ -926,8 +935,8 @@ } bool SBDebugger::DeleteTarget(lldb::SBTarget &target) { - LLDB_RECORD_METHOD(bool, SBDebugger, DeleteTarget, (lldb::SBTarget &), - target); + LLDB_INSTRUMENT_METHOD(bool, SBDebugger, DeleteTarget, (lldb::SBTarget &), + target); bool result = false; if (m_opaque_sp) { @@ -949,8 +958,8 @@ } SBTarget SBDebugger::GetTargetAtIndex(uint32_t idx) { - LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, GetTargetAtIndex, (uint32_t), - idx); + LLDB_INSTRUMENT_METHOD(lldb::SBTarget, SBDebugger, GetTargetAtIndex, + (uint32_t), idx); SBTarget sb_target; if (m_opaque_sp) { @@ -961,8 +970,8 @@ } uint32_t SBDebugger::GetIndexOfTarget(lldb::SBTarget target) { - LLDB_RECORD_METHOD(uint32_t, SBDebugger, GetIndexOfTarget, (lldb::SBTarget), - target); + LLDB_INSTRUMENT_METHOD(uint32_t, SBDebugger, GetIndexOfTarget, + (lldb::SBTarget), target); lldb::TargetSP target_sp = target.GetSP(); if (!target_sp) @@ -975,8 +984,8 @@ } SBTarget SBDebugger::FindTargetWithProcessID(lldb::pid_t pid) { - LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithProcessID, - (lldb::pid_t), pid); + LLDB_INSTRUMENT_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithProcessID, + (lldb::pid_t), pid); SBTarget sb_target; if (m_opaque_sp) { @@ -988,8 +997,8 @@ 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_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithFileAndArch, + (const char *, const char *), filename, arch_name); SBTarget sb_target; if (m_opaque_sp && filename && filename[0]) { @@ -1015,7 +1024,7 @@ } uint32_t SBDebugger::GetNumTargets() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumTargets); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumTargets); if (m_opaque_sp) { // No need to lock, the target list is thread safe @@ -1025,7 +1034,7 @@ } SBTarget SBDebugger::GetSelectedTarget() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBDebugger, GetSelectedTarget); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBTarget, SBDebugger, GetSelectedTarget); Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); @@ -1049,8 +1058,8 @@ } void SBDebugger::SetSelectedTarget(SBTarget &sb_target) { - LLDB_RECORD_METHOD(void, SBDebugger, SetSelectedTarget, (lldb::SBTarget &), - sb_target); + LLDB_INSTRUMENT_METHOD(void, SBDebugger, SetSelectedTarget, + (lldb::SBTarget &), sb_target); Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); @@ -1068,7 +1077,8 @@ } SBPlatform SBDebugger::GetSelectedPlatform() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBPlatform, SBDebugger, GetSelectedPlatform); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBPlatform, SBDebugger, + GetSelectedPlatform); Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); @@ -1085,8 +1095,8 @@ } void SBDebugger::SetSelectedPlatform(SBPlatform &sb_platform) { - LLDB_RECORD_METHOD(void, SBDebugger, SetSelectedPlatform, - (lldb::SBPlatform &), sb_platform); + LLDB_INSTRUMENT_METHOD(void, SBDebugger, SetSelectedPlatform, + (lldb::SBPlatform &), sb_platform); Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); @@ -1102,7 +1112,7 @@ } uint32_t SBDebugger::GetNumPlatforms() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumPlatforms); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumPlatforms); if (m_opaque_sp) { // No need to lock, the platform list is thread safe @@ -1112,8 +1122,8 @@ } SBPlatform SBDebugger::GetPlatformAtIndex(uint32_t idx) { - LLDB_RECORD_METHOD(lldb::SBPlatform, SBDebugger, GetPlatformAtIndex, - (uint32_t), idx); + LLDB_INSTRUMENT_METHOD(lldb::SBPlatform, SBDebugger, GetPlatformAtIndex, + (uint32_t), idx); SBPlatform sb_platform; if (m_opaque_sp) { @@ -1124,7 +1134,8 @@ } uint32_t SBDebugger::GetNumAvailablePlatforms() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumAvailablePlatforms); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBDebugger, + GetNumAvailablePlatforms); uint32_t idx = 0; while (true) { @@ -1138,8 +1149,8 @@ } SBStructuredData SBDebugger::GetAvailablePlatformInfoAtIndex(uint32_t idx) { - LLDB_RECORD_METHOD(lldb::SBStructuredData, SBDebugger, - GetAvailablePlatformInfoAtIndex, (uint32_t), idx); + LLDB_INSTRUMENT_METHOD(lldb::SBStructuredData, SBDebugger, + GetAvailablePlatformInfoAtIndex, (uint32_t), idx); SBStructuredData data; auto platform_dict = std::make_unique(); @@ -1169,15 +1180,15 @@ } 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_METHOD(void, SBDebugger, DispatchInput, + (void *, const void *, size_t), 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_METHOD(void, SBDebugger, DispatchInput, + (const void *, size_t), data, data_len); // Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); // @@ -1194,28 +1205,28 @@ } void SBDebugger::DispatchInputInterrupt() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, DispatchInputInterrupt); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBDebugger, DispatchInputInterrupt); if (m_opaque_sp) m_opaque_sp->DispatchInputInterrupt(); } void SBDebugger::DispatchInputEndOfFile() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, DispatchInputEndOfFile); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBDebugger, DispatchInputEndOfFile); if (m_opaque_sp) m_opaque_sp->DispatchInputEndOfFile(); } void SBDebugger::PushInputReader(SBInputReader &reader) { - LLDB_RECORD_METHOD(void, SBDebugger, PushInputReader, (lldb::SBInputReader &), - reader); + LLDB_INSTRUMENT_METHOD(void, SBDebugger, PushInputReader, + (lldb::SBInputReader &), reader); } void SBDebugger::RunCommandInterpreter(bool auto_handle_events, bool spawn_thread) { - LLDB_RECORD_METHOD(void, SBDebugger, RunCommandInterpreter, (bool, bool), - auto_handle_events, spawn_thread); + LLDB_INSTRUMENT_METHOD(void, SBDebugger, RunCommandInterpreter, (bool, bool), + auto_handle_events, spawn_thread); if (m_opaque_sp) { CommandInterpreterRunOptions options; @@ -1232,11 +1243,11 @@ 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_METHOD(void, SBDebugger, RunCommandInterpreter, + (bool, bool, lldb::SBCommandInterpreterRunOptions &, + int &, bool &, bool &), + auto_handle_events, spawn_thread, options, num_errors, + quit_requested, stopped_for_crash); if (m_opaque_sp) { options.SetAutoHandleEvents(auto_handle_events); @@ -1254,9 +1265,9 @@ SBCommandInterpreterRunResult SBDebugger::RunCommandInterpreter( const SBCommandInterpreterRunOptions &options) { - LLDB_RECORD_METHOD(lldb::SBCommandInterpreterRunResult, SBDebugger, - RunCommandInterpreter, - (const lldb::SBCommandInterpreterRunOptions &), options); + LLDB_INSTRUMENT_METHOD( + lldb::SBCommandInterpreterRunResult, SBDebugger, RunCommandInterpreter, + (const lldb::SBCommandInterpreterRunOptions &), options); if (!m_opaque_sp) return SBCommandInterpreterRunResult(); @@ -1270,9 +1281,9 @@ 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_METHOD(lldb::SBError, SBDebugger, RunREPL, + (lldb::LanguageType, const char *), language, + repl_options); SBError error; if (m_opaque_sp) @@ -1296,8 +1307,8 @@ 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_STATIC_METHOD(lldb::SBDebugger, SBDebugger, + FindDebuggerWithID, (int), id); // No need to lock, the debugger list is thread safe SBDebugger sb_debugger; @@ -1308,16 +1319,16 @@ } const char *SBDebugger::GetInstanceName() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBDebugger, GetInstanceName); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBDebugger, GetInstanceName); return (m_opaque_sp ? m_opaque_sp->GetInstanceName().AsCString() : nullptr); } SBError SBDebugger::SetInternalVariable(const char *var_name, const char *value, const char *debugger_instance_name) { - LLDB_RECORD_STATIC_METHOD(lldb::SBError, SBDebugger, SetInternalVariable, - (const char *, const char *, const char *), - var_name, value, debugger_instance_name); + LLDB_INSTRUMENT_STATIC_METHOD(lldb::SBError, SBDebugger, SetInternalVariable, + (const char *, const char *, const char *), + var_name, value, debugger_instance_name); SBError sb_error; DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName( @@ -1340,7 +1351,7 @@ SBStringList SBDebugger::GetInternalVariableValue(const char *var_name, const char *debugger_instance_name) { - LLDB_RECORD_STATIC_METHOD( + LLDB_INSTRUMENT_STATIC_METHOD( lldb::SBStringList, SBDebugger, GetInternalVariableValue, (const char *, const char *), var_name, debugger_instance_name); @@ -1367,21 +1378,21 @@ } uint32_t SBDebugger::GetTerminalWidth() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBDebugger, GetTerminalWidth); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(uint32_t, SBDebugger, GetTerminalWidth); return (m_opaque_sp ? m_opaque_sp->GetTerminalWidth() : 0); } void SBDebugger::SetTerminalWidth(uint32_t term_width) { - LLDB_RECORD_METHOD(void, SBDebugger, SetTerminalWidth, (uint32_t), - term_width); + LLDB_INSTRUMENT_METHOD(void, SBDebugger, SetTerminalWidth, (uint32_t), + term_width); if (m_opaque_sp) m_opaque_sp->SetTerminalWidth(term_width); } const char *SBDebugger::GetPrompt() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBDebugger, GetPrompt); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(const char *, SBDebugger, GetPrompt); Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); @@ -1394,14 +1405,15 @@ } void SBDebugger::SetPrompt(const char *prompt) { - LLDB_RECORD_METHOD(void, SBDebugger, SetPrompt, (const char *), prompt); + LLDB_INSTRUMENT_METHOD(void, SBDebugger, SetPrompt, (const char *), 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_METHOD_CONST_NO_ARGS(const char *, SBDebugger, + GetReproducerPath); return (m_opaque_sp ? ConstString(m_opaque_sp->GetReproducerPath()).GetCString() @@ -1409,15 +1421,15 @@ } ScriptLanguage SBDebugger::GetScriptLanguage() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ScriptLanguage, SBDebugger, - GetScriptLanguage); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::ScriptLanguage, SBDebugger, + GetScriptLanguage); return (m_opaque_sp ? m_opaque_sp->GetScriptLanguage() : eScriptLanguageNone); } void SBDebugger::SetScriptLanguage(ScriptLanguage script_lang) { - LLDB_RECORD_METHOD(void, SBDebugger, SetScriptLanguage, - (lldb::ScriptLanguage), script_lang); + LLDB_INSTRUMENT_METHOD(void, SBDebugger, SetScriptLanguage, + (lldb::ScriptLanguage), script_lang); if (m_opaque_sp) { m_opaque_sp->SetScriptLanguage(script_lang); @@ -1425,15 +1437,15 @@ } LanguageType SBDebugger::GetREPLLanguage() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::LanguageType, SBDebugger, - GetREPLLanguage); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::LanguageType, SBDebugger, + GetREPLLanguage); 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_METHOD(void, SBDebugger, SetREPLLanguage, + (lldb::LanguageType), repl_lang); if (m_opaque_sp) { m_opaque_sp->SetREPLLanguage(repl_lang); @@ -1441,44 +1453,44 @@ } bool SBDebugger::SetUseExternalEditor(bool value) { - LLDB_RECORD_METHOD(bool, SBDebugger, SetUseExternalEditor, (bool), value); + LLDB_INSTRUMENT_METHOD(bool, SBDebugger, SetUseExternalEditor, (bool), value); return (m_opaque_sp ? m_opaque_sp->SetUseExternalEditor(value) : false); } bool SBDebugger::GetUseExternalEditor() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBDebugger, GetUseExternalEditor); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBDebugger, GetUseExternalEditor); return (m_opaque_sp ? m_opaque_sp->GetUseExternalEditor() : false); } bool SBDebugger::SetUseColor(bool value) { - LLDB_RECORD_METHOD(bool, SBDebugger, SetUseColor, (bool), value); + LLDB_INSTRUMENT_METHOD(bool, SBDebugger, SetUseColor, (bool), value); return (m_opaque_sp ? m_opaque_sp->SetUseColor(value) : false); } bool SBDebugger::GetUseColor() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetUseColor); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetUseColor); return (m_opaque_sp ? m_opaque_sp->GetUseColor() : false); } bool SBDebugger::SetUseSourceCache(bool value) { - LLDB_RECORD_METHOD(bool, SBDebugger, SetUseSourceCache, (bool), value); + LLDB_INSTRUMENT_METHOD(bool, SBDebugger, SetUseSourceCache, (bool), 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_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetUseSourceCache); 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_METHOD(bool, SBDebugger, GetDescription, (lldb::SBStream &), + description); Stream &strm = description.ref(); @@ -1493,14 +1505,14 @@ } user_id_t SBDebugger::GetID() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::user_id_t, SBDebugger, GetID); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::user_id_t, SBDebugger, GetID); return (m_opaque_sp ? m_opaque_sp->GetID() : LLDB_INVALID_UID); } SBError SBDebugger::SetCurrentPlatform(const char *platform_name_cstr) { - LLDB_RECORD_METHOD(lldb::SBError, SBDebugger, SetCurrentPlatform, - (const char *), platform_name_cstr); + LLDB_INSTRUMENT_METHOD(lldb::SBError, SBDebugger, SetCurrentPlatform, + (const char *), platform_name_cstr); SBError sb_error; if (m_opaque_sp) { @@ -1530,8 +1542,8 @@ } bool SBDebugger::SetCurrentPlatformSDKRoot(const char *sysroot) { - LLDB_RECORD_METHOD(bool, SBDebugger, SetCurrentPlatformSDKRoot, - (const char *), sysroot); + LLDB_INSTRUMENT_METHOD(bool, SBDebugger, SetCurrentPlatformSDKRoot, + (const char *), sysroot); if (SBPlatform platform = GetSelectedPlatform()) { platform.SetSDKRoot(sysroot); @@ -1541,21 +1553,21 @@ } bool SBDebugger::GetCloseInputOnEOF() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetCloseInputOnEOF); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetCloseInputOnEOF); return (m_opaque_sp ? m_opaque_sp->GetCloseInputOnEOF() : false); } void SBDebugger::SetCloseInputOnEOF(bool b) { - LLDB_RECORD_METHOD(void, SBDebugger, SetCloseInputOnEOF, (bool), b); + LLDB_INSTRUMENT_METHOD(void, SBDebugger, SetCloseInputOnEOF, (bool), b); if (m_opaque_sp) m_opaque_sp->SetCloseInputOnEOF(b); } SBTypeCategory SBDebugger::GetCategory(const char *category_name) { - LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory, - (const char *), category_name); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory, + (const char *), category_name); if (!category_name || *category_name == 0) return SBTypeCategory(); @@ -1571,8 +1583,8 @@ } SBTypeCategory SBDebugger::GetCategory(lldb::LanguageType lang_type) { - LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory, - (lldb::LanguageType), lang_type); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory, + (lldb::LanguageType), lang_type); TypeCategoryImplSP category_sp; if (DataVisualization::Categories::GetCategory(lang_type, category_sp)) { @@ -1583,8 +1595,8 @@ } SBTypeCategory SBDebugger::CreateCategory(const char *category_name) { - LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, CreateCategory, - (const char *), category_name); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeCategory, SBDebugger, CreateCategory, + (const char *), category_name); if (!category_name || *category_name == 0) return SBTypeCategory(); @@ -1600,8 +1612,8 @@ } bool SBDebugger::DeleteCategory(const char *category_name) { - LLDB_RECORD_METHOD(bool, SBDebugger, DeleteCategory, (const char *), - category_name); + LLDB_INSTRUMENT_METHOD(bool, SBDebugger, DeleteCategory, (const char *), + category_name); if (!category_name || *category_name == 0) return false; @@ -1610,29 +1622,29 @@ } uint32_t SBDebugger::GetNumCategories() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumCategories); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumCategories); return DataVisualization::Categories::GetCount(); } SBTypeCategory SBDebugger::GetCategoryAtIndex(uint32_t index) { - LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategoryAtIndex, - (uint32_t), index); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategoryAtIndex, + (uint32_t), index); return SBTypeCategory( DataVisualization::Categories::GetCategoryAtIndex(index)); } SBTypeCategory SBDebugger::GetDefaultCategory() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeCategory, SBDebugger, - GetDefaultCategory); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBTypeCategory, SBDebugger, + GetDefaultCategory); return GetCategory("default"); } SBTypeFormat SBDebugger::GetFormatForType(SBTypeNameSpecifier type_name) { - LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBDebugger, GetFormatForType, - (lldb::SBTypeNameSpecifier), type_name); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeFormat, SBDebugger, GetFormatForType, + (lldb::SBTypeNameSpecifier), type_name); SBTypeCategory default_category_sb = GetDefaultCategory(); if (default_category_sb.GetEnabled()) @@ -1641,8 +1653,8 @@ } SBTypeSummary SBDebugger::GetSummaryForType(SBTypeNameSpecifier type_name) { - LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBDebugger, GetSummaryForType, - (lldb::SBTypeNameSpecifier), type_name); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeSummary, SBDebugger, GetSummaryForType, + (lldb::SBTypeNameSpecifier), type_name); if (!type_name.IsValid()) return SBTypeSummary(); @@ -1650,8 +1662,8 @@ } SBTypeFilter SBDebugger::GetFilterForType(SBTypeNameSpecifier type_name) { - LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBDebugger, GetFilterForType, - (lldb::SBTypeNameSpecifier), type_name); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeFilter, SBDebugger, GetFilterForType, + (lldb::SBTypeNameSpecifier), type_name); if (!type_name.IsValid()) return SBTypeFilter(); @@ -1659,8 +1671,8 @@ } SBTypeSynthetic SBDebugger::GetSyntheticForType(SBTypeNameSpecifier type_name) { - LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBDebugger, GetSyntheticForType, - (lldb::SBTypeNameSpecifier), type_name); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeSynthetic, SBDebugger, GetSyntheticForType, + (lldb::SBTypeNameSpecifier), type_name); if (!type_name.IsValid()) return SBTypeSynthetic(); @@ -1678,8 +1690,8 @@ } bool SBDebugger::EnableLog(const char *channel, const char **categories) { - LLDB_RECORD_METHOD(bool, SBDebugger, EnableLog, (const char *, const char **), - channel, categories); + LLDB_INSTRUMENT_METHOD(bool, SBDebugger, EnableLog, + (const char *, const char **), channel, categories); if (m_opaque_sp) { uint32_t log_options = @@ -1694,8 +1706,9 @@ void SBDebugger::SetLoggingCallback(lldb::LogOutputCallback log_callback, void *baton) { - LLDB_RECORD_METHOD(void, SBDebugger, SetLoggingCallback, - (lldb::LogOutputCallback, void *), log_callback, baton); + LLDB_INSTRUMENT_METHOD(void, SBDebugger, SetLoggingCallback, + (lldb::LogOutputCallback, void *), log_callback, + baton); if (m_opaque_sp) { return m_opaque_sp->SetLoggingCallback(log_callback, baton); Index: lldb/source/API/SBDeclaration.cpp =================================================================== --- lldb/source/API/SBDeclaration.cpp +++ 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 @@ -20,11 +20,12 @@ using namespace lldb_private; SBDeclaration::SBDeclaration() { - LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBDeclaration); + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBDeclaration); } SBDeclaration::SBDeclaration(const SBDeclaration &rhs) { - LLDB_RECORD_CONSTRUCTOR(SBDeclaration, (const lldb::SBDeclaration &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBDeclaration, (const lldb::SBDeclaration &), + rhs); m_opaque_up = clone(rhs.m_opaque_up); } @@ -35,9 +36,8 @@ } const SBDeclaration &SBDeclaration::operator=(const SBDeclaration &rhs) { - LLDB_RECORD_METHOD(const lldb::SBDeclaration &, - SBDeclaration, operator=,(const lldb::SBDeclaration &), - rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBDeclaration &, SBDeclaration, operator=, + (const lldb::SBDeclaration &), rhs); if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); @@ -52,19 +52,18 @@ SBDeclaration::~SBDeclaration() = default; bool SBDeclaration::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDeclaration, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBDeclaration, IsValid); return this->operator bool(); } SBDeclaration::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDeclaration, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBDeclaration, operator bool); 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_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBDeclaration, + GetFileSpec); SBFileSpec sb_file_spec; if (m_opaque_up.get() && m_opaque_up->GetFile()) @@ -74,8 +73,7 @@ } uint32_t SBDeclaration::GetLine() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBDeclaration, GetLine); - + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(uint32_t, SBDeclaration, GetLine); uint32_t line = 0; if (m_opaque_up) @@ -86,7 +84,7 @@ } uint32_t SBDeclaration::GetColumn() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBDeclaration, GetColumn); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(uint32_t, SBDeclaration, GetColumn); if (m_opaque_up) return m_opaque_up->GetColumn(); @@ -94,8 +92,8 @@ } void SBDeclaration::SetFileSpec(lldb::SBFileSpec filespec) { - LLDB_RECORD_METHOD(void, SBDeclaration, SetFileSpec, (lldb::SBFileSpec), - filespec); + LLDB_INSTRUMENT_METHOD(void, SBDeclaration, SetFileSpec, (lldb::SBFileSpec), + filespec); if (filespec.IsValid()) ref().SetFile(filespec.ref()); @@ -103,20 +101,20 @@ ref().SetFile(FileSpec()); } void SBDeclaration::SetLine(uint32_t line) { - LLDB_RECORD_METHOD(void, SBDeclaration, SetLine, (uint32_t), line); + LLDB_INSTRUMENT_METHOD(void, SBDeclaration, SetLine, (uint32_t), line); ref().SetLine(line); } void SBDeclaration::SetColumn(uint32_t column) { - LLDB_RECORD_METHOD(void, SBDeclaration, SetColumn, (uint32_t), column); + LLDB_INSTRUMENT_METHOD(void, SBDeclaration, SetColumn, (uint32_t), column); ref().SetColumn(column); } bool SBDeclaration::operator==(const SBDeclaration &rhs) const { - LLDB_RECORD_METHOD_CONST( - bool, SBDeclaration, operator==,(const lldb::SBDeclaration &), rhs); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBDeclaration, operator==, + (const lldb::SBDeclaration &), rhs); lldb_private::Declaration *lhs_ptr = m_opaque_up.get(); lldb_private::Declaration *rhs_ptr = rhs.m_opaque_up.get(); @@ -128,8 +126,8 @@ } bool SBDeclaration::operator!=(const SBDeclaration &rhs) const { - LLDB_RECORD_METHOD_CONST( - bool, SBDeclaration, operator!=,(const lldb::SBDeclaration &), rhs); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBDeclaration, operator!=, + (const lldb::SBDeclaration &), rhs); lldb_private::Declaration *lhs_ptr = m_opaque_up.get(); lldb_private::Declaration *rhs_ptr = rhs.m_opaque_up.get(); @@ -155,8 +153,8 @@ } bool SBDeclaration::GetDescription(SBStream &description) { - LLDB_RECORD_METHOD(bool, SBDeclaration, GetDescription, (lldb::SBStream &), - description); + LLDB_INSTRUMENT_METHOD(bool, SBDeclaration, GetDescription, + (lldb::SBStream &), description); Stream &strm = description.ref(); Index: lldb/source/API/SBEnvironment.cpp =================================================================== --- lldb/source/API/SBEnvironment.cpp +++ lldb/source/API/SBEnvironment.cpp @@ -7,22 +7,23 @@ //===----------------------------------------------------------------------===// #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_CONSTRUCTOR_NO_ARGS(SBEnvironment); } SBEnvironment::SBEnvironment(const SBEnvironment &rhs) : m_opaque_up(clone(rhs.m_opaque_up)) { - LLDB_RECORD_CONSTRUCTOR(SBEnvironment, (const lldb::SBEnvironment &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBEnvironment, (const lldb::SBEnvironment &), + rhs); } SBEnvironment::SBEnvironment(Environment rhs) @@ -31,9 +32,8 @@ SBEnvironment::~SBEnvironment() = default; const SBEnvironment &SBEnvironment::operator=(const SBEnvironment &rhs) { - LLDB_RECORD_METHOD(const lldb::SBEnvironment &, - SBEnvironment, operator=,(const lldb::SBEnvironment &), - rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBEnvironment &, SBEnvironment, operator=, + (const lldb::SBEnvironment &), rhs); if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); @@ -41,13 +41,14 @@ } size_t SBEnvironment::GetNumValues() { - LLDB_RECORD_METHOD_NO_ARGS(size_t, SBEnvironment, GetNumValues); + LLDB_INSTRUMENT_METHOD_NO_ARGS(size_t, SBEnvironment, GetNumValues); return m_opaque_up->size(); } const char *SBEnvironment::Get(const char *name) { - LLDB_RECORD_METHOD(const char *, SBEnvironment, Get, (const char *), name); + LLDB_INSTRUMENT_METHOD(const char *, SBEnvironment, Get, (const char *), + name); auto entry = m_opaque_up->find(name); if (entry == m_opaque_up->end()) { @@ -57,8 +58,8 @@ } const char *SBEnvironment::GetNameAtIndex(size_t index) { - LLDB_RECORD_METHOD(const char *, SBEnvironment, GetNameAtIndex, (size_t), - index); + LLDB_INSTRUMENT_METHOD(const char *, SBEnvironment, GetNameAtIndex, (size_t), + index); if (index >= GetNumValues()) return nullptr; @@ -67,8 +68,8 @@ } const char *SBEnvironment::GetValueAtIndex(size_t index) { - LLDB_RECORD_METHOD(const char *, SBEnvironment, GetValueAtIndex, (size_t), - index); + LLDB_INSTRUMENT_METHOD(const char *, SBEnvironment, GetValueAtIndex, (size_t), + index); if (index >= GetNumValues()) return nullptr; @@ -77,9 +78,9 @@ } 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_METHOD(bool, SBEnvironment, Set, + (const char *, const char *, bool), name, value, + overwrite); if (overwrite) { m_opaque_up->insert_or_assign(name, std::string(value)); @@ -89,13 +90,13 @@ } bool SBEnvironment::Unset(const char *name) { - LLDB_RECORD_METHOD(bool, SBEnvironment, Unset, (const char *), name); + LLDB_INSTRUMENT_METHOD(bool, SBEnvironment, Unset, (const char *), name); return m_opaque_up->erase(name); } SBStringList SBEnvironment::GetEntries() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStringList, SBEnvironment, GetEntries); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBStringList, SBEnvironment, GetEntries); SBStringList entries; for (const auto &KV : *m_opaque_up) { @@ -105,16 +106,16 @@ } void SBEnvironment::PutEntry(const char *name_and_value) { - LLDB_RECORD_METHOD(void, SBEnvironment, PutEntry, (const char *), - name_and_value); + LLDB_INSTRUMENT_METHOD(void, SBEnvironment, PutEntry, (const char *), + 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_METHOD(void, SBEnvironment, SetEntries, + (const lldb::SBStringList &, bool), entries, append); if (!append) m_opaque_up->clear(); @@ -124,7 +125,7 @@ } void SBEnvironment::Clear() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBEnvironment, Clear); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBEnvironment, Clear); m_opaque_up->clear(); } Index: lldb/source/API/SBError.cpp =================================================================== --- lldb/source/API/SBError.cpp +++ lldb/source/API/SBError.cpp @@ -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 @@ -17,10 +17,10 @@ using namespace lldb; using namespace lldb_private; -SBError::SBError() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBError); } +SBError::SBError() { LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBError); } SBError::SBError(const SBError &rhs) { - LLDB_RECORD_CONSTRUCTOR(SBError, (const lldb::SBError &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBError, (const lldb::SBError &), rhs); m_opaque_up = clone(rhs.m_opaque_up); } @@ -28,8 +28,8 @@ SBError::~SBError() = default; const SBError &SBError::operator=(const SBError &rhs) { - LLDB_RECORD_METHOD(const lldb::SBError &, - SBError, operator=,(const lldb::SBError &), rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBError &, SBError, operator=, + (const lldb::SBError &), rhs); if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); @@ -37,7 +37,7 @@ } const char *SBError::GetCString() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBError, GetCString); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(const char *, SBError, GetCString); if (m_opaque_up) return m_opaque_up->AsCString(); @@ -45,14 +45,14 @@ } void SBError::Clear() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBError, Clear); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBError, Clear); if (m_opaque_up) m_opaque_up->Clear(); } bool SBError::Fail() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, Fail); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBError, Fail); bool ret_value = false; if (m_opaque_up) @@ -63,7 +63,7 @@ } bool SBError::Success() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, Success); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBError, Success); bool ret_value = true; if (m_opaque_up) @@ -73,8 +73,7 @@ } uint32_t SBError::GetError() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBError, GetError); - + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(uint32_t, SBError, GetError); uint32_t err = 0; if (m_opaque_up) @@ -85,7 +84,7 @@ } ErrorType SBError::GetType() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ErrorType, SBError, GetType); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::ErrorType, SBError, GetType); ErrorType err_type = eErrorTypeInvalid; if (m_opaque_up) @@ -95,8 +94,8 @@ } void SBError::SetError(uint32_t err, ErrorType type) { - LLDB_RECORD_METHOD(void, SBError, SetError, (uint32_t, lldb::ErrorType), err, - type); + LLDB_INSTRUMENT_METHOD(void, SBError, SetError, (uint32_t, lldb::ErrorType), + err, type); CreateIfNeeded(); m_opaque_up->SetError(err, type); @@ -108,21 +107,22 @@ } void SBError::SetErrorToErrno() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBError, SetErrorToErrno); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBError, SetErrorToErrno); CreateIfNeeded(); m_opaque_up->SetErrorToErrno(); } void SBError::SetErrorToGenericError() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBError, SetErrorToGenericError); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBError, SetErrorToGenericError); CreateIfNeeded(); m_opaque_up->SetErrorToGenericError(); } void SBError::SetErrorString(const char *err_str) { - LLDB_RECORD_METHOD(void, SBError, SetErrorString, (const char *), err_str); + LLDB_INSTRUMENT_METHOD(void, SBError, SetErrorString, (const char *), + err_str); CreateIfNeeded(); m_opaque_up->SetErrorString(err_str); @@ -138,11 +138,11 @@ } bool SBError::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBError, IsValid); return this->operator bool(); } SBError::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBError, operator bool); return m_opaque_up != nullptr; } @@ -167,8 +167,8 @@ } bool SBError::GetDescription(SBStream &description) { - LLDB_RECORD_METHOD(bool, SBError, GetDescription, (lldb::SBStream &), - description); + LLDB_INSTRUMENT_METHOD(bool, SBError, GetDescription, (lldb::SBStream &), + description); if (m_opaque_up) { if (m_opaque_up->Success()) Index: lldb/source/API/SBEvent.cpp =================================================================== --- lldb/source/API/SBEvent.cpp +++ 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,32 @@ using namespace lldb; using namespace lldb_private; -SBEvent::SBEvent() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBEvent); } +SBEvent::SBEvent() { LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBEvent); } SBEvent::SBEvent(uint32_t event_type, const char *cstr, uint32_t cstr_len) : m_event_sp(new Event(event_type, new EventDataBytes(cstr, cstr_len))), m_opaque_ptr(m_event_sp.get()) { - LLDB_RECORD_CONSTRUCTOR(SBEvent, (uint32_t, const char *, uint32_t), - event_type, cstr, cstr_len); + LLDB_INSTRUMENT_CONSTRUCTOR(SBEvent, (uint32_t, const char *, uint32_t), + event_type, cstr, cstr_len); } SBEvent::SBEvent(EventSP &event_sp) : m_event_sp(event_sp), m_opaque_ptr(event_sp.get()) { - LLDB_RECORD_CONSTRUCTOR(SBEvent, (lldb::EventSP &), event_sp); + LLDB_INSTRUMENT_CONSTRUCTOR(SBEvent, (lldb::EventSP &), event_sp); } SBEvent::SBEvent(Event *event_ptr) : m_opaque_ptr(event_ptr) { - LLDB_RECORD_CONSTRUCTOR(SBEvent, (lldb_private::Event *), event_ptr); + LLDB_INSTRUMENT_CONSTRUCTOR(SBEvent, (lldb_private::Event *), event_ptr); } SBEvent::SBEvent(const SBEvent &rhs) : m_event_sp(rhs.m_event_sp), m_opaque_ptr(rhs.m_opaque_ptr) { - LLDB_RECORD_CONSTRUCTOR(SBEvent, (const lldb::SBEvent &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBEvent, (const lldb::SBEvent &), rhs); } const SBEvent &SBEvent::operator=(const SBEvent &rhs) { - LLDB_RECORD_METHOD(const lldb::SBEvent &, - SBEvent, operator=,(const lldb::SBEvent &), rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBEvent &, SBEvent, operator=, + (const lldb::SBEvent &), rhs); if (this != &rhs) { m_event_sp = rhs.m_event_sp; @@ -59,7 +59,7 @@ SBEvent::~SBEvent() = default; const char *SBEvent::GetDataFlavor() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBEvent, GetDataFlavor); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBEvent, GetDataFlavor); Event *lldb_event = get(); if (lldb_event) { @@ -71,8 +71,7 @@ } uint32_t SBEvent::GetType() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBEvent, GetType); - + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(uint32_t, SBEvent, GetType); const Event *lldb_event = get(); uint32_t event_type = 0; @@ -84,8 +83,8 @@ } SBBroadcaster SBEvent::GetBroadcaster() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBEvent, - GetBroadcaster); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBEvent, + GetBroadcaster); SBBroadcaster broadcaster; const Event *lldb_event = get(); @@ -95,7 +94,8 @@ } const char *SBEvent::GetBroadcasterClass() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBEvent, GetBroadcasterClass); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(const char *, SBEvent, + GetBroadcasterClass); const Event *lldb_event = get(); if (lldb_event) @@ -105,8 +105,8 @@ } bool SBEvent::BroadcasterMatchesPtr(const SBBroadcaster *broadcaster) { - LLDB_RECORD_METHOD(bool, SBEvent, BroadcasterMatchesPtr, - (const lldb::SBBroadcaster *), broadcaster); + LLDB_INSTRUMENT_METHOD(bool, SBEvent, BroadcasterMatchesPtr, + (const lldb::SBBroadcaster *), broadcaster); if (broadcaster) return BroadcasterMatchesRef(*broadcaster); @@ -114,8 +114,8 @@ } bool SBEvent::BroadcasterMatchesRef(const SBBroadcaster &broadcaster) { - LLDB_RECORD_METHOD(bool, SBEvent, BroadcasterMatchesRef, - (const lldb::SBBroadcaster &), broadcaster); + LLDB_INSTRUMENT_METHOD(bool, SBEvent, BroadcasterMatchesRef, + (const lldb::SBBroadcaster &), broadcaster); Event *lldb_event = get(); bool success = false; @@ -127,7 +127,7 @@ } void SBEvent::Clear() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBEvent, Clear); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBEvent, Clear); Event *lldb_event = get(); if (lldb_event) @@ -158,11 +158,11 @@ } bool SBEvent::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBEvent, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBEvent, IsValid); return this->operator bool(); } SBEvent::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBEvent, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBEvent, operator bool); // Do NOT use m_opaque_ptr directly!!! Must use the SBEvent::get() accessor. // See comments in SBEvent::get().... @@ -170,16 +170,16 @@ } const char *SBEvent::GetCStringFromEvent(const SBEvent &event) { - LLDB_RECORD_STATIC_METHOD(const char *, SBEvent, GetCStringFromEvent, - (const lldb::SBEvent &), event); + LLDB_INSTRUMENT_STATIC_METHOD(const char *, SBEvent, GetCStringFromEvent, + (const lldb::SBEvent &), event); return static_cast( EventDataBytes::GetBytesFromEvent(event.get())); } bool SBEvent::GetDescription(SBStream &description) { - LLDB_RECORD_METHOD(bool, SBEvent, GetDescription, (lldb::SBStream &), - description); + LLDB_INSTRUMENT_METHOD(bool, SBEvent, GetDescription, (lldb::SBStream &), + description); Stream &strm = description.ref(); @@ -192,8 +192,8 @@ } bool SBEvent::GetDescription(SBStream &description) const { - LLDB_RECORD_METHOD_CONST(bool, SBEvent, GetDescription, (lldb::SBStream &), - description); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBEvent, GetDescription, + (lldb::SBStream &), description); Stream &strm = description.ref(); Index: lldb/source/API/SBExecutionContext.cpp =================================================================== --- lldb/source/API/SBExecutionContext.cpp +++ 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" @@ -20,47 +20,49 @@ using namespace lldb_private; SBExecutionContext::SBExecutionContext() { - LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBExecutionContext); + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBExecutionContext); } 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_CONSTRUCTOR(SBExecutionContext, + (const lldb::SBExecutionContext &), 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_CONSTRUCTOR(SBExecutionContext, (lldb::ExecutionContextRefSP), + exe_ctx_ref_sp); } SBExecutionContext::SBExecutionContext(const lldb::SBTarget &target) : m_exe_ctx_sp(new ExecutionContextRef()) { - LLDB_RECORD_CONSTRUCTOR(SBExecutionContext, (const lldb::SBTarget &), target); + LLDB_INSTRUMENT_CONSTRUCTOR(SBExecutionContext, (const lldb::SBTarget &), + target); m_exe_ctx_sp->SetTargetSP(target.GetSP()); } SBExecutionContext::SBExecutionContext(const lldb::SBProcess &process) : m_exe_ctx_sp(new ExecutionContextRef()) { - LLDB_RECORD_CONSTRUCTOR(SBExecutionContext, (const lldb::SBProcess &), - process); + LLDB_INSTRUMENT_CONSTRUCTOR(SBExecutionContext, (const lldb::SBProcess &), + process); m_exe_ctx_sp->SetProcessSP(process.GetSP()); } SBExecutionContext::SBExecutionContext(lldb::SBThread thread) : m_exe_ctx_sp(new ExecutionContextRef()) { - LLDB_RECORD_CONSTRUCTOR(SBExecutionContext, (lldb::SBThread), thread); + LLDB_INSTRUMENT_CONSTRUCTOR(SBExecutionContext, (lldb::SBThread), thread); m_exe_ctx_sp->SetThreadPtr(thread.get()); } SBExecutionContext::SBExecutionContext(const lldb::SBFrame &frame) : m_exe_ctx_sp(new ExecutionContextRef()) { - LLDB_RECORD_CONSTRUCTOR(SBExecutionContext, (const lldb::SBFrame &), frame); + LLDB_INSTRUMENT_CONSTRUCTOR(SBExecutionContext, (const lldb::SBFrame &), + frame); m_exe_ctx_sp->SetFrameSP(frame.GetFrameSP()); } @@ -69,9 +71,9 @@ const SBExecutionContext &SBExecutionContext:: operator=(const lldb::SBExecutionContext &rhs) { - LLDB_RECORD_METHOD( - const lldb::SBExecutionContext &, - SBExecutionContext, operator=,(const lldb::SBExecutionContext &), rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBExecutionContext &, + SBExecutionContext, operator=, + (const lldb::SBExecutionContext &), rhs); m_exe_ctx_sp = rhs.m_exe_ctx_sp; return *this; @@ -82,8 +84,8 @@ } SBTarget SBExecutionContext::GetTarget() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBTarget, SBExecutionContext, - GetTarget); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::SBTarget, SBExecutionContext, + GetTarget); SBTarget sb_target; if (m_exe_ctx_sp) { @@ -95,8 +97,8 @@ } SBProcess SBExecutionContext::GetProcess() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBProcess, SBExecutionContext, - GetProcess); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::SBProcess, SBExecutionContext, + GetProcess); SBProcess sb_process; if (m_exe_ctx_sp) { @@ -108,8 +110,8 @@ } SBThread SBExecutionContext::GetThread() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBExecutionContext, - GetThread); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::SBThread, SBExecutionContext, + GetThread); SBThread sb_thread; if (m_exe_ctx_sp) { @@ -121,7 +123,8 @@ } SBFrame SBExecutionContext::GetFrame() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFrame, SBExecutionContext, GetFrame); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::SBFrame, SBExecutionContext, + GetFrame); SBFrame sb_frame; if (m_exe_ctx_sp) { Index: lldb/source/API/SBExpressionOptions.cpp =================================================================== --- lldb/source/API/SBExpressionOptions.cpp +++ lldb/source/API/SBExpressionOptions.cpp @@ -7,31 +7,31 @@ //===----------------------------------------------------------------------===// #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_CONSTRUCTOR_NO_ARGS(SBExpressionOptions); } SBExpressionOptions::SBExpressionOptions(const SBExpressionOptions &rhs) { - LLDB_RECORD_CONSTRUCTOR(SBExpressionOptions, - (const lldb::SBExpressionOptions &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBExpressionOptions, + (const lldb::SBExpressionOptions &), rhs); m_opaque_up = clone(rhs.m_opaque_up); } const SBExpressionOptions &SBExpressionOptions:: operator=(const SBExpressionOptions &rhs) { - LLDB_RECORD_METHOD( - const lldb::SBExpressionOptions &, - SBExpressionOptions, operator=,(const lldb::SBExpressionOptions &), rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBExpressionOptions &, + SBExpressionOptions, operator=, + (const lldb::SBExpressionOptions &), rhs); if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); @@ -41,78 +41,79 @@ SBExpressionOptions::~SBExpressionOptions() = default; bool SBExpressionOptions::GetCoerceResultToId() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, - GetCoerceResultToId); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, + GetCoerceResultToId); return m_opaque_up->DoesCoerceToId(); } void SBExpressionOptions::SetCoerceResultToId(bool coerce) { - LLDB_RECORD_METHOD(void, SBExpressionOptions, SetCoerceResultToId, (bool), - coerce); + LLDB_INSTRUMENT_METHOD(void, SBExpressionOptions, SetCoerceResultToId, (bool), + coerce); m_opaque_up->SetCoerceToId(coerce); } bool SBExpressionOptions::GetUnwindOnError() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, GetUnwindOnError); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, + GetUnwindOnError); return m_opaque_up->DoesUnwindOnError(); } void SBExpressionOptions::SetUnwindOnError(bool unwind) { - LLDB_RECORD_METHOD(void, SBExpressionOptions, SetUnwindOnError, (bool), - unwind); + LLDB_INSTRUMENT_METHOD(void, SBExpressionOptions, SetUnwindOnError, (bool), + unwind); m_opaque_up->SetUnwindOnError(unwind); } bool SBExpressionOptions::GetIgnoreBreakpoints() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, - GetIgnoreBreakpoints); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, + GetIgnoreBreakpoints); return m_opaque_up->DoesIgnoreBreakpoints(); } void SBExpressionOptions::SetIgnoreBreakpoints(bool ignore) { - LLDB_RECORD_METHOD(void, SBExpressionOptions, SetIgnoreBreakpoints, (bool), - ignore); + LLDB_INSTRUMENT_METHOD(void, SBExpressionOptions, SetIgnoreBreakpoints, + (bool), ignore); m_opaque_up->SetIgnoreBreakpoints(ignore); } lldb::DynamicValueType SBExpressionOptions::GetFetchDynamicValue() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::DynamicValueType, SBExpressionOptions, - GetFetchDynamicValue); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS( + lldb::DynamicValueType, SBExpressionOptions, GetFetchDynamicValue); return m_opaque_up->GetUseDynamic(); } void SBExpressionOptions::SetFetchDynamicValue(lldb::DynamicValueType dynamic) { - LLDB_RECORD_METHOD(void, SBExpressionOptions, SetFetchDynamicValue, - (lldb::DynamicValueType), dynamic); + LLDB_INSTRUMENT_METHOD(void, SBExpressionOptions, SetFetchDynamicValue, + (lldb::DynamicValueType), dynamic); m_opaque_up->SetUseDynamic(dynamic); } uint32_t SBExpressionOptions::GetTimeoutInMicroSeconds() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBExpressionOptions, - GetTimeoutInMicroSeconds); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(uint32_t, SBExpressionOptions, + GetTimeoutInMicroSeconds); return m_opaque_up->GetTimeout() ? m_opaque_up->GetTimeout()->count() : 0; } void SBExpressionOptions::SetTimeoutInMicroSeconds(uint32_t timeout) { - LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTimeoutInMicroSeconds, - (uint32_t), timeout); + LLDB_INSTRUMENT_METHOD(void, SBExpressionOptions, SetTimeoutInMicroSeconds, + (uint32_t), timeout); m_opaque_up->SetTimeout(timeout == 0 ? Timeout(llvm::None) : std::chrono::microseconds(timeout)); } uint32_t SBExpressionOptions::GetOneThreadTimeoutInMicroSeconds() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBExpressionOptions, - GetOneThreadTimeoutInMicroSeconds); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(uint32_t, SBExpressionOptions, + GetOneThreadTimeoutInMicroSeconds); return m_opaque_up->GetOneThreadTimeout() ? m_opaque_up->GetOneThreadTimeout()->count() @@ -120,8 +121,9 @@ } void SBExpressionOptions::SetOneThreadTimeoutInMicroSeconds(uint32_t timeout) { - LLDB_RECORD_METHOD(void, SBExpressionOptions, - SetOneThreadTimeoutInMicroSeconds, (uint32_t), timeout); + LLDB_INSTRUMENT_METHOD(void, SBExpressionOptions, + SetOneThreadTimeoutInMicroSeconds, (uint32_t), + timeout); m_opaque_up->SetOneThreadTimeout(timeout == 0 ? Timeout(llvm::None) @@ -129,148 +131,153 @@ } bool SBExpressionOptions::GetTryAllThreads() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, GetTryAllThreads); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, + GetTryAllThreads); return m_opaque_up->GetTryAllThreads(); } void SBExpressionOptions::SetTryAllThreads(bool run_others) { - LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTryAllThreads, (bool), - run_others); + LLDB_INSTRUMENT_METHOD(void, SBExpressionOptions, SetTryAllThreads, (bool), + run_others); m_opaque_up->SetTryAllThreads(run_others); } bool SBExpressionOptions::GetStopOthers() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, GetStopOthers); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, + GetStopOthers); return m_opaque_up->GetStopOthers(); } void SBExpressionOptions::SetStopOthers(bool run_others) { - LLDB_RECORD_METHOD(void, SBExpressionOptions, SetStopOthers, (bool), - run_others); + LLDB_INSTRUMENT_METHOD(void, SBExpressionOptions, SetStopOthers, (bool), + run_others); m_opaque_up->SetStopOthers(run_others); } bool SBExpressionOptions::GetTrapExceptions() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, - GetTrapExceptions); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, + GetTrapExceptions); return m_opaque_up->GetTrapExceptions(); } void SBExpressionOptions::SetTrapExceptions(bool trap_exceptions) { - LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTrapExceptions, (bool), - trap_exceptions); + LLDB_INSTRUMENT_METHOD(void, SBExpressionOptions, SetTrapExceptions, (bool), + trap_exceptions); m_opaque_up->SetTrapExceptions(trap_exceptions); } void SBExpressionOptions::SetLanguage(lldb::LanguageType language) { - LLDB_RECORD_METHOD(void, SBExpressionOptions, SetLanguage, - (lldb::LanguageType), language); + LLDB_INSTRUMENT_METHOD(void, SBExpressionOptions, SetLanguage, + (lldb::LanguageType), 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_METHOD(void, SBExpressionOptions, SetCancelCallback, + (lldb::ExpressionCancelCallback, void *), callback, + baton); m_opaque_up->SetCancelCallback(callback, baton); } bool SBExpressionOptions::GetGenerateDebugInfo() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetGenerateDebugInfo); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBExpressionOptions, + GetGenerateDebugInfo); return m_opaque_up->GetGenerateDebugInfo(); } void SBExpressionOptions::SetGenerateDebugInfo(bool b) { - LLDB_RECORD_METHOD(void, SBExpressionOptions, SetGenerateDebugInfo, (bool), - b); + LLDB_INSTRUMENT_METHOD(void, SBExpressionOptions, SetGenerateDebugInfo, + (bool), b); return m_opaque_up->SetGenerateDebugInfo(b); } bool SBExpressionOptions::GetSuppressPersistentResult() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, - GetSuppressPersistentResult); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBExpressionOptions, + GetSuppressPersistentResult); return m_opaque_up->GetResultIsInternal(); } void SBExpressionOptions::SetSuppressPersistentResult(bool b) { - LLDB_RECORD_METHOD(void, SBExpressionOptions, SetSuppressPersistentResult, - (bool), b); + LLDB_INSTRUMENT_METHOD(void, SBExpressionOptions, SetSuppressPersistentResult, + (bool), b); return m_opaque_up->SetResultIsInternal(b); } const char *SBExpressionOptions::GetPrefix() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBExpressionOptions, - GetPrefix); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(const char *, SBExpressionOptions, + GetPrefix); return m_opaque_up->GetPrefix(); } void SBExpressionOptions::SetPrefix(const char *prefix) { - LLDB_RECORD_METHOD(void, SBExpressionOptions, SetPrefix, (const char *), - prefix); + LLDB_INSTRUMENT_METHOD(void, SBExpressionOptions, SetPrefix, (const char *), + prefix); return m_opaque_up->SetPrefix(prefix); } bool SBExpressionOptions::GetAutoApplyFixIts() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetAutoApplyFixIts); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBExpressionOptions, GetAutoApplyFixIts); return m_opaque_up->GetAutoApplyFixIts(); } void SBExpressionOptions::SetAutoApplyFixIts(bool b) { - LLDB_RECORD_METHOD(void, SBExpressionOptions, SetAutoApplyFixIts, (bool), b); + LLDB_INSTRUMENT_METHOD(void, SBExpressionOptions, SetAutoApplyFixIts, (bool), + b); return m_opaque_up->SetAutoApplyFixIts(b); } uint64_t SBExpressionOptions::GetRetriesWithFixIts() { - LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBExpressionOptions, - GetRetriesWithFixIts); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint64_t, SBExpressionOptions, + GetRetriesWithFixIts); return m_opaque_up->GetRetriesWithFixIts(); } void SBExpressionOptions::SetRetriesWithFixIts(uint64_t retries) { - LLDB_RECORD_METHOD(void, SBExpressionOptions, SetRetriesWithFixIts, - (uint64_t), retries); + LLDB_INSTRUMENT_METHOD(void, SBExpressionOptions, SetRetriesWithFixIts, + (uint64_t), retries); return m_opaque_up->SetRetriesWithFixIts(retries); } bool SBExpressionOptions::GetTopLevel() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetTopLevel); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBExpressionOptions, GetTopLevel); return m_opaque_up->GetExecutionPolicy() == eExecutionPolicyTopLevel; } void SBExpressionOptions::SetTopLevel(bool b) { - LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTopLevel, (bool), b); + LLDB_INSTRUMENT_METHOD(void, SBExpressionOptions, SetTopLevel, (bool), b); m_opaque_up->SetExecutionPolicy(b ? eExecutionPolicyTopLevel : m_opaque_up->default_execution_policy); } bool SBExpressionOptions::GetAllowJIT() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetAllowJIT); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBExpressionOptions, GetAllowJIT); return m_opaque_up->GetExecutionPolicy() != eExecutionPolicyNever; } void SBExpressionOptions::SetAllowJIT(bool allow) { - LLDB_RECORD_METHOD(void, SBExpressionOptions, SetAllowJIT, (bool), allow); + LLDB_INSTRUMENT_METHOD(void, SBExpressionOptions, SetAllowJIT, (bool), allow); m_opaque_up->SetExecutionPolicy(allow ? m_opaque_up->default_execution_policy : eExecutionPolicyNever); Index: lldb/source/API/SBFile.cpp =================================================================== --- lldb/source/API/SBFile.cpp +++ 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,33 @@ 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_CONSTRUCTOR(SBFile, (lldb::FileSP), nullptr); } SBFile::SBFile(const SBFile &rhs) : m_opaque_sp(rhs.m_opaque_sp) { - LLDB_RECORD_CONSTRUCTOR(SBFile, (const lldb::SBFile&), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBFile, (const lldb::SBFile &), rhs); } SBFile &SBFile ::operator=(const SBFile &rhs) { - LLDB_RECORD_METHOD(lldb::SBFile &, - SBFile, operator=,(const lldb::SBFile &), rhs); + LLDB_INSTRUMENT_METHOD(lldb::SBFile &, SBFile, operator=, + (const lldb::SBFile &), 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_CONSTRUCTOR_NO_ARGS(SBFile); } SBFile::SBFile(FILE *file, bool transfer_ownership) { - LLDB_RECORD_CONSTRUCTOR(SBFile, (FILE *, bool), file, transfer_ownership); + LLDB_INSTRUMENT_CONSTRUCTOR(SBFile, (FILE *, bool), file, transfer_ownership); m_opaque_sp = std::make_shared(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_CONSTRUCTOR(SBFile, (int, const char *, bool), fd, mode, + transfer_owndership); auto options = File::GetOptionsFromMode(mode); if (!options) { @@ -57,8 +57,9 @@ } 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_METHOD(lldb::SBError, SBFile, Read, + (uint8_t *, size_t, size_t *), buf, num_bytes, + bytes_read); SBError error; if (!m_opaque_sp) { @@ -74,9 +75,9 @@ 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_METHOD(lldb::SBError, SBFile, Write, + (const uint8_t *, size_t, size_t *), buf, num_bytes, + bytes_written); SBError error; if (!m_opaque_sp) { @@ -91,7 +92,7 @@ } SBError SBFile::Flush() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBFile, Flush); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBError, SBFile, Flush); SBError error; if (!m_opaque_sp) { @@ -104,12 +105,12 @@ } bool SBFile::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFile, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBFile, IsValid); return m_opaque_sp && m_opaque_sp->IsValid(); } SBError SBFile::Close() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBFile, Close); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBError, SBFile, Close); SBError error; if (m_opaque_sp) { Status status = m_opaque_sp->Close(); @@ -119,16 +120,16 @@ } SBFile::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFile, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBFile, operator bool); return IsValid(); } bool SBFile::operator!() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFile, operator!); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBFile, operator!); return !IsValid(); } FileSP SBFile::GetFile() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(FileSP, SBFile, GetFile); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(FileSP, SBFile, GetFile); return m_opaque_sp; } Index: lldb/source/API/SBFileSpec.cpp =================================================================== --- lldb/source/API/SBFileSpec.cpp +++ lldb/source/API/SBFileSpec.cpp @@ -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_private; SBFileSpec::SBFileSpec() : m_opaque_up(new lldb_private::FileSpec()) { - LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFileSpec); + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBFileSpec); } SBFileSpec::SBFileSpec(const SBFileSpec &rhs) { - LLDB_RECORD_CONSTRUCTOR(SBFileSpec, (const lldb::SBFileSpec &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBFileSpec, (const lldb::SBFileSpec &), rhs); m_opaque_up = clone(rhs.m_opaque_up); } @@ -38,14 +38,14 @@ // Deprecated!!! SBFileSpec::SBFileSpec(const char *path) : m_opaque_up(new FileSpec(path)) { - LLDB_RECORD_CONSTRUCTOR(SBFileSpec, (const char *), path); + LLDB_INSTRUMENT_CONSTRUCTOR(SBFileSpec, (const char *), path); FileSystem::Instance().Resolve(*m_opaque_up); } SBFileSpec::SBFileSpec(const char *path, bool resolve) : m_opaque_up(new FileSpec(path)) { - LLDB_RECORD_CONSTRUCTOR(SBFileSpec, (const char *, bool), path, resolve); + LLDB_INSTRUMENT_CONSTRUCTOR(SBFileSpec, (const char *, bool), path, resolve); if (resolve) FileSystem::Instance().Resolve(*m_opaque_up); @@ -54,8 +54,8 @@ SBFileSpec::~SBFileSpec() = default; const SBFileSpec &SBFileSpec::operator=(const SBFileSpec &rhs) { - LLDB_RECORD_METHOD(const lldb::SBFileSpec &, - SBFileSpec, operator=,(const lldb::SBFileSpec &), rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBFileSpec &, SBFileSpec, operator=, + (const lldb::SBFileSpec &), rhs); if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); @@ -63,46 +63,46 @@ } bool SBFileSpec::operator==(const SBFileSpec &rhs) const { - LLDB_RECORD_METHOD_CONST(bool, SBFileSpec, operator==,(const SBFileSpec &rhs), - rhs); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBFileSpec, operator==, + (const SBFileSpec &rhs), rhs); return ref() == rhs.ref(); } bool SBFileSpec::operator!=(const SBFileSpec &rhs) const { - LLDB_RECORD_METHOD_CONST(bool, SBFileSpec, operator!=,(const SBFileSpec &rhs), - rhs); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBFileSpec, operator!=, + (const SBFileSpec &rhs), rhs); return !(*this == rhs); } bool SBFileSpec::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFileSpec, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBFileSpec, IsValid); return this->operator bool(); } SBFileSpec::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFileSpec, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBFileSpec, operator bool); return m_opaque_up->operator bool(); } bool SBFileSpec::Exists() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFileSpec, Exists); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBFileSpec, Exists); return FileSystem::Instance().Exists(*m_opaque_up); } bool SBFileSpec::ResolveExecutableLocation() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBFileSpec, ResolveExecutableLocation); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBFileSpec, ResolveExecutableLocation); return FileSystem::Instance().ResolveExecutableLocation(*m_opaque_up); } int SBFileSpec::ResolvePath(const char *src_path, char *dst_path, size_t dst_len) { - LLDB_RECORD_STATIC_METHOD(int, SBFileSpec, ResolvePath, - (const char *, char *, size_t), src_path, dst_path, - dst_len); + LLDB_INSTRUMENT_STATIC_METHOD(int, SBFileSpec, ResolvePath, + (const char *, char *, size_t), src_path, + dst_path, dst_len); llvm::SmallString<64> result(src_path); FileSystem::Instance().Resolve(result); @@ -111,13 +111,13 @@ } const char *SBFileSpec::GetFilename() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFileSpec, GetFilename); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(const char *, SBFileSpec, GetFilename); return m_opaque_up->GetFilename().AsCString(); } const char *SBFileSpec::GetDirectory() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFileSpec, GetDirectory); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(const char *, SBFileSpec, GetDirectory); FileSpec directory{*m_opaque_up}; directory.GetFilename().Clear(); @@ -125,7 +125,8 @@ } void SBFileSpec::SetFilename(const char *filename) { - LLDB_RECORD_METHOD(void, SBFileSpec, SetFilename, (const char *), filename); + LLDB_INSTRUMENT_METHOD(void, SBFileSpec, SetFilename, (const char *), + filename); if (filename && filename[0]) m_opaque_up->GetFilename().SetCString(filename); @@ -134,7 +135,8 @@ } void SBFileSpec::SetDirectory(const char *directory) { - LLDB_RECORD_METHOD(void, SBFileSpec, SetDirectory, (const char *), directory); + LLDB_INSTRUMENT_METHOD(void, SBFileSpec, SetDirectory, (const char *), + directory); if (directory && directory[0]) m_opaque_up->GetDirectory().SetCString(directory); @@ -143,8 +145,8 @@ } 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_METHOD_CONST(uint32_t, SBFileSpec, GetPath, (char *, size_t), + dst_path, "", dst_len); uint32_t result = m_opaque_up->GetPath(dst_path, dst_len); @@ -172,8 +174,8 @@ } bool SBFileSpec::GetDescription(SBStream &description) const { - LLDB_RECORD_METHOD_CONST(bool, SBFileSpec, GetDescription, (lldb::SBStream &), - description); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBFileSpec, GetDescription, + (lldb::SBStream &), description); Stream &strm = description.ref(); char path[PATH_MAX]; @@ -183,7 +185,8 @@ } void SBFileSpec::AppendPathComponent(const char *fn) { - LLDB_RECORD_METHOD(void, SBFileSpec, AppendPathComponent, (const char *), fn); + LLDB_INSTRUMENT_METHOD(void, SBFileSpec, AppendPathComponent, (const char *), + fn); m_opaque_up->AppendPathComponent(fn); } Index: lldb/source/API/SBFileSpecList.cpp =================================================================== --- lldb/source/API/SBFileSpecList.cpp +++ lldb/source/API/SBFileSpecList.cpp @@ -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 @@ -22,11 +22,12 @@ using namespace lldb_private; SBFileSpecList::SBFileSpecList() : m_opaque_up(new FileSpecList()) { - LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFileSpecList); + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBFileSpecList); } SBFileSpecList::SBFileSpecList(const SBFileSpecList &rhs) { - LLDB_RECORD_CONSTRUCTOR(SBFileSpecList, (const lldb::SBFileSpecList &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBFileSpecList, (const lldb::SBFileSpecList &), + rhs); m_opaque_up = clone(rhs.m_opaque_up); } @@ -34,9 +35,9 @@ SBFileSpecList::~SBFileSpecList() = default; const SBFileSpecList &SBFileSpecList::operator=(const SBFileSpecList &rhs) { - LLDB_RECORD_METHOD(const lldb::SBFileSpecList &, - SBFileSpecList, operator=,(const lldb::SBFileSpecList &), - rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBFileSpecList &, + SBFileSpecList, operator=, + (const lldb::SBFileSpecList &), rhs); if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); @@ -44,43 +45,43 @@ } uint32_t SBFileSpecList::GetSize() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBFileSpecList, GetSize); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(uint32_t, SBFileSpecList, GetSize); return m_opaque_up->GetSize(); } void SBFileSpecList::Append(const SBFileSpec &sb_file) { - LLDB_RECORD_METHOD(void, SBFileSpecList, Append, (const lldb::SBFileSpec &), - sb_file); + LLDB_INSTRUMENT_METHOD(void, SBFileSpecList, Append, + (const lldb::SBFileSpec &), sb_file); m_opaque_up->Append(sb_file.ref()); } bool SBFileSpecList::AppendIfUnique(const SBFileSpec &sb_file) { - LLDB_RECORD_METHOD(bool, SBFileSpecList, AppendIfUnique, - (const lldb::SBFileSpec &), sb_file); + LLDB_INSTRUMENT_METHOD(bool, SBFileSpecList, AppendIfUnique, + (const lldb::SBFileSpec &), sb_file); return m_opaque_up->AppendIfUnique(sb_file.ref()); } void SBFileSpecList::Clear() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBFileSpecList, Clear); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBFileSpecList, Clear); m_opaque_up->Clear(); } uint32_t SBFileSpecList::FindFileIndex(uint32_t idx, const SBFileSpec &sb_file, bool full) { - LLDB_RECORD_METHOD(uint32_t, SBFileSpecList, FindFileIndex, - (uint32_t, const lldb::SBFileSpec &, bool), idx, sb_file, - full); + LLDB_INSTRUMENT_METHOD(uint32_t, SBFileSpecList, FindFileIndex, + (uint32_t, const lldb::SBFileSpec &, bool), idx, + sb_file, full); return m_opaque_up->FindFileIndex(idx, sb_file.ref(), full); } const SBFileSpec SBFileSpecList::GetFileSpecAtIndex(uint32_t idx) const { - LLDB_RECORD_METHOD_CONST(const lldb::SBFileSpec, SBFileSpecList, - GetFileSpecAtIndex, (uint32_t), idx); + LLDB_INSTRUMENT_METHOD_CONST(const lldb::SBFileSpec, SBFileSpecList, + GetFileSpecAtIndex, (uint32_t), idx); SBFileSpec new_spec; new_spec.SetFileSpec(m_opaque_up->GetFileSpecAtIndex(idx)); @@ -104,8 +105,8 @@ } bool SBFileSpecList::GetDescription(SBStream &description) const { - LLDB_RECORD_METHOD_CONST(bool, SBFileSpecList, GetDescription, - (lldb::SBStream &), description); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBFileSpecList, GetDescription, + (lldb::SBStream &), description); Stream &strm = description.ref(); Index: lldb/source/API/SBFrame.cpp =================================================================== --- lldb/source/API/SBFrame.cpp +++ 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,17 @@ using namespace lldb_private; SBFrame::SBFrame() : m_opaque_sp(new ExecutionContextRef()) { - LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFrame); + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBFrame); } SBFrame::SBFrame(const StackFrameSP &lldb_object_sp) : m_opaque_sp(new ExecutionContextRef(lldb_object_sp)) { - LLDB_RECORD_CONSTRUCTOR(SBFrame, (const lldb::StackFrameSP &), - lldb_object_sp); + LLDB_INSTRUMENT_CONSTRUCTOR(SBFrame, (const lldb::StackFrameSP &), + lldb_object_sp); } SBFrame::SBFrame(const SBFrame &rhs) { - LLDB_RECORD_CONSTRUCTOR(SBFrame, (const lldb::SBFrame &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBFrame, (const lldb::SBFrame &), rhs); m_opaque_sp = clone(rhs.m_opaque_sp); } @@ -73,8 +73,8 @@ SBFrame::~SBFrame() = default; const SBFrame &SBFrame::operator=(const SBFrame &rhs) { - LLDB_RECORD_METHOD(const lldb::SBFrame &, - SBFrame, operator=,(const lldb::SBFrame &), rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBFrame &, SBFrame, operator=, + (const lldb::SBFrame &), rhs); if (this != &rhs) m_opaque_sp = clone(rhs.m_opaque_sp); @@ -90,11 +90,11 @@ } bool SBFrame::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBFrame, IsValid); return this->operator bool(); } SBFrame::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBFrame, operator bool); std::unique_lock lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -112,8 +112,8 @@ } SBSymbolContext SBFrame::GetSymbolContext(uint32_t resolve_scope) const { - LLDB_RECORD_METHOD_CONST(lldb::SBSymbolContext, SBFrame, GetSymbolContext, - (uint32_t), resolve_scope); + LLDB_INSTRUMENT_METHOD_CONST(lldb::SBSymbolContext, SBFrame, GetSymbolContext, + (uint32_t), resolve_scope); SBSymbolContext sb_sym_ctx; std::unique_lock lock; @@ -133,7 +133,7 @@ } SBModule SBFrame::GetModule() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBModule, SBFrame, GetModule); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::SBModule, SBFrame, GetModule); SBModule sb_module; ModuleSP module_sp; @@ -158,8 +158,8 @@ } SBCompileUnit SBFrame::GetCompileUnit() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBCompileUnit, SBFrame, - GetCompileUnit); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::SBCompileUnit, SBFrame, + GetCompileUnit); SBCompileUnit sb_comp_unit; std::unique_lock lock; @@ -183,7 +183,7 @@ } SBFunction SBFrame::GetFunction() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFunction, SBFrame, GetFunction); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::SBFunction, SBFrame, GetFunction); SBFunction sb_function; std::unique_lock lock; @@ -207,7 +207,7 @@ } SBSymbol SBFrame::GetSymbol() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBSymbol, SBFrame, GetSymbol); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::SBSymbol, SBFrame, GetSymbol); SBSymbol sb_symbol; std::unique_lock lock; @@ -230,7 +230,7 @@ } SBBlock SBFrame::GetBlock() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBlock, SBFrame, GetBlock); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::SBBlock, SBFrame, GetBlock); SBBlock sb_block; std::unique_lock lock; @@ -251,7 +251,7 @@ } SBBlock SBFrame::GetFrameBlock() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBlock, SBFrame, GetFrameBlock); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::SBBlock, SBFrame, GetFrameBlock); SBBlock sb_block; std::unique_lock lock; @@ -272,7 +272,8 @@ } SBLineEntry SBFrame::GetLineEntry() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBLineEntry, SBFrame, GetLineEntry); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::SBLineEntry, SBFrame, + GetLineEntry); SBLineEntry sb_line_entry; std::unique_lock lock; @@ -295,7 +296,7 @@ } uint32_t SBFrame::GetFrameID() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBFrame, GetFrameID); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(uint32_t, SBFrame, GetFrameID); uint32_t frame_idx = UINT32_MAX; @@ -310,7 +311,7 @@ } lldb::addr_t SBFrame::GetCFA() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetCFA); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetCFA); std::unique_lock lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -322,7 +323,7 @@ } addr_t SBFrame::GetPC() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetPC); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetPC); addr_t addr = LLDB_INVALID_ADDRESS; std::unique_lock lock; @@ -346,7 +347,7 @@ } bool SBFrame::SetPC(addr_t new_pc) { - LLDB_RECORD_METHOD(bool, SBFrame, SetPC, (lldb::addr_t), new_pc); + LLDB_INSTRUMENT_METHOD(bool, SBFrame, SetPC, (lldb::addr_t), new_pc); bool ret_val = false; std::unique_lock lock; @@ -369,7 +370,7 @@ } addr_t SBFrame::GetSP() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetSP); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetSP); addr_t addr = LLDB_INVALID_ADDRESS; std::unique_lock lock; @@ -392,7 +393,7 @@ } addr_t SBFrame::GetFP() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetFP); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetFP); addr_t addr = LLDB_INVALID_ADDRESS; std::unique_lock lock; @@ -415,7 +416,7 @@ } SBAddress SBFrame::GetPCAddress() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBFrame, GetPCAddress); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBFrame, GetPCAddress); SBAddress sb_addr; std::unique_lock lock; @@ -436,14 +437,14 @@ } void SBFrame::Clear() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBFrame, Clear); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBFrame, Clear); m_opaque_sp->Clear(); } lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path) { - LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath, - (const char *), var_path); + LLDB_INSTRUMENT_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath, + (const char *), var_path); SBValue sb_value; std::unique_lock lock; @@ -461,9 +462,9 @@ 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_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath, + (const char *, lldb::DynamicValueType), var_path, + use_dynamic); SBValue sb_value; if (var_path == nullptr || var_path[0] == '\0') { @@ -496,8 +497,8 @@ } SBValue SBFrame::FindVariable(const char *name) { - LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindVariable, (const char *), - name); + LLDB_INSTRUMENT_METHOD(lldb::SBValue, SBFrame, FindVariable, (const char *), + name); SBValue value; std::unique_lock lock; @@ -515,8 +516,9 @@ 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_METHOD(lldb::SBValue, SBFrame, FindVariable, + (const char *, lldb::DynamicValueType), name, + use_dynamic); VariableSP var_sp; SBValue sb_value; @@ -549,8 +551,8 @@ } 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_METHOD(lldb::SBValue, SBFrame, FindValue, + (const char *, lldb::ValueType), name, value_type); SBValue value; std::unique_lock lock; @@ -568,9 +570,10 @@ 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_METHOD( + lldb::SBValue, SBFrame, FindValue, + (const char *, lldb::ValueType, lldb::DynamicValueType), name, value_type, + use_dynamic); SBValue sb_value; @@ -682,8 +685,8 @@ } bool SBFrame::IsEqual(const SBFrame &that) const { - LLDB_RECORD_METHOD_CONST(bool, SBFrame, IsEqual, (const lldb::SBFrame &), - that); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBFrame, IsEqual, (const lldb::SBFrame &), + that); lldb::StackFrameSP this_sp = GetFrameSP(); lldb::StackFrameSP that_sp = that.GetFrameSP(); @@ -691,21 +694,21 @@ } bool SBFrame::operator==(const SBFrame &rhs) const { - LLDB_RECORD_METHOD_CONST(bool, SBFrame, operator==,(const lldb::SBFrame &), - rhs); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBFrame, operator==, + (const lldb::SBFrame &), rhs); return IsEqual(rhs); } bool SBFrame::operator!=(const SBFrame &rhs) const { - LLDB_RECORD_METHOD_CONST(bool, SBFrame, operator!=,(const lldb::SBFrame &), - rhs); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBFrame, operator!=, + (const lldb::SBFrame &), rhs); return !IsEqual(rhs); } SBThread SBFrame::GetThread() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBFrame, GetThread); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::SBThread, SBFrame, GetThread); std::unique_lock lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -717,7 +720,7 @@ } const char *SBFrame::Disassemble() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFrame, Disassemble); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(const char *, SBFrame, Disassemble); const char *disassembly = nullptr; std::unique_lock lock; @@ -741,9 +744,9 @@ 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_METHOD(lldb::SBValueList, SBFrame, GetVariables, + (bool, bool, bool, bool), arguments, locals, statics, + in_scope_only); SBValueList value_list; std::unique_lock lock; @@ -773,9 +776,10 @@ 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_METHOD(lldb::SBValueList, SBFrame, GetVariables, + (bool, bool, bool, bool, lldb::DynamicValueType), + arguments, locals, statics, in_scope_only, + use_dynamic); std::unique_lock lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -794,8 +798,8 @@ } SBValueList SBFrame::GetVariables(const lldb::SBVariablesOptions &options) { - LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables, - (const lldb::SBVariablesOptions &), options); + LLDB_INSTRUMENT_METHOD(lldb::SBValueList, SBFrame, GetVariables, + (const lldb::SBVariablesOptions &), options); SBValueList value_list; std::unique_lock lock; @@ -895,7 +899,7 @@ } SBValueList SBFrame::GetRegisters() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValueList, SBFrame, GetRegisters); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBValueList, SBFrame, GetRegisters); SBValueList value_list; std::unique_lock lock; @@ -925,8 +929,8 @@ } SBValue SBFrame::FindRegister(const char *name) { - LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindRegister, (const char *), - name); + LLDB_INSTRUMENT_METHOD(lldb::SBValue, SBFrame, FindRegister, (const char *), + name); SBValue result; ValueObjectSP value_sp; @@ -957,8 +961,8 @@ } bool SBFrame::GetDescription(SBStream &description) { - LLDB_RECORD_METHOD(bool, SBFrame, GetDescription, (lldb::SBStream &), - description); + LLDB_INSTRUMENT_METHOD(bool, SBFrame, GetDescription, (lldb::SBStream &), + description); Stream &strm = description.ref(); @@ -984,8 +988,8 @@ } SBValue SBFrame::EvaluateExpression(const char *expr) { - LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression, (const char *), - expr); + LLDB_INSTRUMENT_METHOD(lldb::SBValue, SBFrame, EvaluateExpression, + (const char *), expr); SBValue result; std::unique_lock lock; @@ -1012,9 +1016,9 @@ 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_METHOD(lldb::SBValue, SBFrame, EvaluateExpression, + (const char *, lldb::DynamicValueType), expr, + fetch_dynamic_value); SBExpressionOptions options; options.SetFetchDynamicValue(fetch_dynamic_value); @@ -1035,9 +1039,9 @@ 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_METHOD(lldb::SBValue, SBFrame, EvaluateExpression, + (const char *, lldb::DynamicValueType, bool), expr, + fetch_dynamic_value, unwind_on_error); SBExpressionOptions options; std::unique_lock lock; @@ -1057,9 +1061,9 @@ 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_METHOD(lldb::SBValue, SBFrame, EvaluateExpression, + (const char *, const lldb::SBExpressionOptions &), + expr, options); Log *expr_log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); @@ -1110,13 +1114,13 @@ } bool SBFrame::IsInlined() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBFrame, IsInlined); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBFrame, IsInlined); return static_cast(this)->IsInlined(); } bool SBFrame::IsInlined() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsInlined); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBFrame, IsInlined); std::unique_lock lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -1140,13 +1144,13 @@ } bool SBFrame::IsArtificial() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBFrame, IsArtificial); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBFrame, IsArtificial); return static_cast(this)->IsArtificial(); } bool SBFrame::IsArtificial() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsArtificial); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBFrame, IsArtificial); std::unique_lock lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -1159,13 +1163,14 @@ } const char *SBFrame::GetFunctionName() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBFrame, GetFunctionName); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBFrame, GetFunctionName); return static_cast(this)->GetFunctionName(); } lldb::LanguageType SBFrame::GuessLanguage() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::LanguageType, SBFrame, GuessLanguage); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::LanguageType, SBFrame, + GuessLanguage); std::unique_lock lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -1186,7 +1191,7 @@ } const char *SBFrame::GetFunctionName() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFrame, GetFunctionName); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(const char *, SBFrame, GetFunctionName); const char *name = nullptr; std::unique_lock lock; @@ -1228,7 +1233,7 @@ } const char *SBFrame::GetDisplayFunctionName() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBFrame, GetDisplayFunctionName); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBFrame, GetDisplayFunctionName); const char *name = nullptr; Index: lldb/source/API/SBFunction.cpp =================================================================== --- lldb/source/API/SBFunction.cpp +++ lldb/source/API/SBFunction.cpp @@ -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,24 @@ #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_CONSTRUCTOR_NO_ARGS(SBFunction); } SBFunction::SBFunction(lldb_private::Function *lldb_object_ptr) : m_opaque_ptr(lldb_object_ptr) {} SBFunction::SBFunction(const lldb::SBFunction &rhs) : m_opaque_ptr(rhs.m_opaque_ptr) { - LLDB_RECORD_CONSTRUCTOR(SBFunction, (const lldb::SBFunction &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBFunction, (const lldb::SBFunction &), rhs); } const SBFunction &SBFunction::operator=(const SBFunction &rhs) { - LLDB_RECORD_METHOD(const lldb::SBFunction &, - SBFunction, operator=,(const lldb::SBFunction &), rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBFunction &, SBFunction, operator=, + (const lldb::SBFunction &), rhs); m_opaque_ptr = rhs.m_opaque_ptr; return *this; @@ -43,17 +43,17 @@ SBFunction::~SBFunction() { m_opaque_ptr = nullptr; } bool SBFunction::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFunction, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBFunction, IsValid); return this->operator bool(); } SBFunction::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFunction, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBFunction, operator bool); return m_opaque_ptr != nullptr; } const char *SBFunction::GetName() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFunction, GetName); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(const char *, SBFunction, GetName); const char *cstr = nullptr; if (m_opaque_ptr) @@ -63,7 +63,8 @@ } const char *SBFunction::GetDisplayName() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFunction, GetDisplayName); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(const char *, SBFunction, + GetDisplayName); const char *cstr = nullptr; if (m_opaque_ptr) @@ -73,7 +74,8 @@ } const char *SBFunction::GetMangledName() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFunction, GetMangledName); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(const char *, SBFunction, + GetMangledName); const char *cstr = nullptr; if (m_opaque_ptr) @@ -82,21 +84,22 @@ } bool SBFunction::operator==(const SBFunction &rhs) const { - LLDB_RECORD_METHOD_CONST( - bool, SBFunction, operator==,(const lldb::SBFunction &), rhs); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBFunction, operator==, + (const lldb::SBFunction &), rhs); return m_opaque_ptr == rhs.m_opaque_ptr; } bool SBFunction::operator!=(const SBFunction &rhs) const { - LLDB_RECORD_METHOD_CONST( - bool, SBFunction, operator!=,(const lldb::SBFunction &), rhs); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBFunction, operator!=, + (const lldb::SBFunction &), rhs); return m_opaque_ptr != rhs.m_opaque_ptr; } bool SBFunction::GetDescription(SBStream &s) { - LLDB_RECORD_METHOD(bool, SBFunction, GetDescription, (lldb::SBStream &), s); + LLDB_INSTRUMENT_METHOD(bool, SBFunction, GetDescription, (lldb::SBStream &), + s); if (m_opaque_ptr) { s.Printf("SBFunction: id = 0x%8.8" PRIx64 ", name = %s", @@ -111,16 +114,16 @@ } SBInstructionList SBFunction::GetInstructions(SBTarget target) { - LLDB_RECORD_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions, - (lldb::SBTarget), target); + LLDB_INSTRUMENT_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions, + (lldb::SBTarget), 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_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions, + (lldb::SBTarget, const char *), target, flavor); SBInstructionList sb_instructions; if (m_opaque_ptr) { @@ -146,7 +149,7 @@ } SBAddress SBFunction::GetStartAddress() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBFunction, GetStartAddress); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBAddress, SBFunction, GetStartAddress); SBAddress addr; if (m_opaque_ptr) @@ -155,7 +158,7 @@ } SBAddress SBFunction::GetEndAddress() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBFunction, GetEndAddress); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBAddress, SBFunction, GetEndAddress); SBAddress addr; if (m_opaque_ptr) { @@ -169,8 +172,8 @@ } const char *SBFunction::GetArgumentName(uint32_t arg_idx) { - LLDB_RECORD_METHOD(const char *, SBFunction, GetArgumentName, (uint32_t), - arg_idx); + LLDB_INSTRUMENT_METHOD(const char *, SBFunction, GetArgumentName, (uint32_t), + arg_idx); if (m_opaque_ptr) { Block &block = m_opaque_ptr->GetBlock(true); @@ -188,7 +191,7 @@ } uint32_t SBFunction::GetPrologueByteSize() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBFunction, GetPrologueByteSize); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBFunction, GetPrologueByteSize); if (m_opaque_ptr) return m_opaque_ptr->GetPrologueByteSize(); @@ -196,7 +199,7 @@ } SBType SBFunction::GetType() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBFunction, GetType); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBType, SBFunction, GetType); SBType sb_type; if (m_opaque_ptr) { @@ -208,7 +211,7 @@ } SBBlock SBFunction::GetBlock() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBFunction, GetBlock); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBBlock, SBFunction, GetBlock); SBBlock sb_block; if (m_opaque_ptr) @@ -217,7 +220,7 @@ } lldb::LanguageType SBFunction::GetLanguage() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::LanguageType, SBFunction, GetLanguage); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::LanguageType, SBFunction, GetLanguage); if (m_opaque_ptr) { if (m_opaque_ptr->GetCompileUnit()) @@ -227,7 +230,7 @@ } bool SBFunction::GetIsOptimized() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBFunction, GetIsOptimized); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBFunction, GetIsOptimized); if (m_opaque_ptr) { if (m_opaque_ptr->GetCompileUnit()) Index: lldb/source/API/SBHostOS.cpp =================================================================== --- lldb/source/API/SBHostOS.cpp +++ 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,8 @@ using namespace lldb_private; SBFileSpec SBHostOS::GetProgramFileSpec() { - LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBFileSpec, SBHostOS, - GetProgramFileSpec); + LLDB_INSTRUMENT_STATIC_METHOD_NO_ARGS(lldb::SBFileSpec, SBHostOS, + GetProgramFileSpec); SBFileSpec sb_filespec; sb_filespec.SetFileSpec(HostInfo::GetProgramFileSpec()); @@ -39,15 +39,15 @@ } SBFileSpec SBHostOS::GetLLDBPythonPath() { - LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBFileSpec, SBHostOS, - GetLLDBPythonPath); + LLDB_INSTRUMENT_STATIC_METHOD_NO_ARGS(lldb::SBFileSpec, SBHostOS, + GetLLDBPythonPath); return GetLLDBPath(ePathTypePythonDir); } SBFileSpec SBHostOS::GetLLDBPath(lldb::PathType path_type) { - LLDB_RECORD_STATIC_METHOD(lldb::SBFileSpec, SBHostOS, GetLLDBPath, - (lldb::PathType), path_type); + LLDB_INSTRUMENT_STATIC_METHOD(lldb::SBFileSpec, SBHostOS, GetLLDBPath, + (lldb::PathType), path_type); FileSpec fspec; switch (path_type) { @@ -88,8 +88,8 @@ } SBFileSpec SBHostOS::GetUserHomeDirectory() { - LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBFileSpec, SBHostOS, - GetUserHomeDirectory); + LLDB_INSTRUMENT_STATIC_METHOD_NO_ARGS(lldb::SBFileSpec, SBHostOS, + GetUserHomeDirectory); FileSpec homedir; FileSystem::Instance().GetHomeDirectory(homedir); @@ -104,9 +104,9 @@ 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_STATIC_METHOD(lldb::thread_t, SBHostOS, ThreadCreate, + (lldb::thread_func_t, void *, SBError *), name, + thread_function, thread_arg, error_ptr); llvm::Expected thread = ThreadLauncher::LaunchThread(name, thread_function, thread_arg); if (!thread) { @@ -121,14 +121,14 @@ } void SBHostOS::ThreadCreated(const char *name) { - LLDB_RECORD_STATIC_METHOD(void, SBHostOS, ThreadCreated, (const char *), - name); + LLDB_INSTRUMENT_STATIC_METHOD(void, SBHostOS, ThreadCreated, (const char *), + name); } bool SBHostOS::ThreadCancel(lldb::thread_t thread, SBError *error_ptr) { - LLDB_RECORD_STATIC_METHOD(bool, SBHostOS, ThreadCancel, - (lldb::thread_t, lldb::SBError *), thread, - error_ptr); + LLDB_INSTRUMENT_STATIC_METHOD(bool, SBHostOS, ThreadCancel, + (lldb::thread_t, lldb::SBError *), thread, + error_ptr); Status error; HostThread host_thread(thread); @@ -140,9 +140,9 @@ } 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_STATIC_METHOD(bool, SBHostOS, ThreadDetach, + (lldb::thread_t, lldb::SBError *), thread, + error_ptr); Status error; #if defined(_WIN32) @@ -160,7 +160,7 @@ bool SBHostOS::ThreadJoin(lldb::thread_t thread, lldb::thread_result_t *result, SBError *error_ptr) { - LLDB_RECORD_STATIC_METHOD( + LLDB_INSTRUMENT_STATIC_METHOD( bool, SBHostOS, ThreadJoin, (lldb::thread_t, lldb::thread_result_t *, lldb::SBError *), thread, result, error_ptr); Index: lldb/source/API/SBInstruction.cpp =================================================================== --- lldb/source/API/SBInstruction.cpp +++ 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" @@ -67,7 +67,7 @@ using namespace lldb_private; SBInstruction::SBInstruction() { - LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBInstruction); + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBInstruction); } SBInstruction::SBInstruction(const lldb::DisassemblerSP &disasm_sp, @@ -76,13 +76,13 @@ SBInstruction::SBInstruction(const SBInstruction &rhs) : m_opaque_sp(rhs.m_opaque_sp) { - LLDB_RECORD_CONSTRUCTOR(SBInstruction, (const lldb::SBInstruction &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBInstruction, (const lldb::SBInstruction &), + rhs); } const SBInstruction &SBInstruction::operator=(const SBInstruction &rhs) { - LLDB_RECORD_METHOD(const lldb::SBInstruction &, - SBInstruction, operator=,(const lldb::SBInstruction &), - rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBInstruction &, SBInstruction, operator=, + (const lldb::SBInstruction &), rhs); if (this != &rhs) m_opaque_sp = rhs.m_opaque_sp; @@ -92,17 +92,17 @@ SBInstruction::~SBInstruction() = default; bool SBInstruction::IsValid() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, IsValid); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBInstruction, IsValid); return this->operator bool(); } SBInstruction::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInstruction, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBInstruction, operator bool); return m_opaque_sp && m_opaque_sp->IsValid(); } SBAddress SBInstruction::GetAddress() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBInstruction, GetAddress); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBAddress, SBInstruction, GetAddress); SBAddress sb_addr; lldb::InstructionSP inst_sp(GetOpaque()); @@ -112,8 +112,8 @@ } const char *SBInstruction::GetMnemonic(SBTarget target) { - LLDB_RECORD_METHOD(const char *, SBInstruction, GetMnemonic, (lldb::SBTarget), - target); + LLDB_INSTRUMENT_METHOD(const char *, SBInstruction, GetMnemonic, + (lldb::SBTarget), target); lldb::InstructionSP inst_sp(GetOpaque()); if (inst_sp) { @@ -132,8 +132,8 @@ } const char *SBInstruction::GetOperands(SBTarget target) { - LLDB_RECORD_METHOD(const char *, SBInstruction, GetOperands, (lldb::SBTarget), - target); + LLDB_INSTRUMENT_METHOD(const char *, SBInstruction, GetOperands, + (lldb::SBTarget), target); lldb::InstructionSP inst_sp(GetOpaque()); if (inst_sp) { @@ -152,8 +152,8 @@ } const char *SBInstruction::GetComment(SBTarget target) { - LLDB_RECORD_METHOD(const char *, SBInstruction, GetComment, (lldb::SBTarget), - target); + LLDB_INSTRUMENT_METHOD(const char *, SBInstruction, GetComment, + (lldb::SBTarget), target); lldb::InstructionSP inst_sp(GetOpaque()); if (inst_sp) { @@ -172,7 +172,7 @@ } size_t SBInstruction::GetByteSize() { - LLDB_RECORD_METHOD_NO_ARGS(size_t, SBInstruction, GetByteSize); + LLDB_INSTRUMENT_METHOD_NO_ARGS(size_t, SBInstruction, GetByteSize); lldb::InstructionSP inst_sp(GetOpaque()); if (inst_sp) @@ -181,8 +181,8 @@ } SBData SBInstruction::GetData(SBTarget target) { - LLDB_RECORD_METHOD(lldb::SBData, SBInstruction, GetData, (lldb::SBTarget), - target); + LLDB_INSTRUMENT_METHOD(lldb::SBData, SBInstruction, GetData, (lldb::SBTarget), + target); lldb::SBData sb_data; lldb::InstructionSP inst_sp(GetOpaque()); @@ -196,7 +196,7 @@ } bool SBInstruction::DoesBranch() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, DoesBranch); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBInstruction, DoesBranch); lldb::InstructionSP inst_sp(GetOpaque()); if (inst_sp) @@ -205,7 +205,7 @@ } bool SBInstruction::HasDelaySlot() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, HasDelaySlot); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBInstruction, HasDelaySlot); lldb::InstructionSP inst_sp(GetOpaque()); if (inst_sp) @@ -214,7 +214,7 @@ } bool SBInstruction::CanSetBreakpoint() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, CanSetBreakpoint); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBInstruction, CanSetBreakpoint); lldb::InstructionSP inst_sp(GetOpaque()); if (inst_sp) @@ -235,8 +235,8 @@ } bool SBInstruction::GetDescription(lldb::SBStream &s) { - LLDB_RECORD_METHOD(bool, SBInstruction, GetDescription, (lldb::SBStream &), - s); + LLDB_INSTRUMENT_METHOD(bool, SBInstruction, GetDescription, + (lldb::SBStream &), s); lldb::InstructionSP inst_sp(GetOpaque()); if (inst_sp) { @@ -257,18 +257,18 @@ } void SBInstruction::Print(FILE *outp) { - LLDB_RECORD_METHOD(void, SBInstruction, Print, (FILE *), outp); + LLDB_INSTRUMENT_METHOD(void, SBInstruction, Print, (FILE *), outp); FileSP out = std::make_shared(outp, /*take_ownership=*/false); Print(out); } void SBInstruction::Print(SBFile out) { - LLDB_RECORD_METHOD(void, SBInstruction, Print, (SBFile), out); + LLDB_INSTRUMENT_METHOD(void, SBInstruction, Print, (SBFile), out); Print(out.m_opaque_sp); } void SBInstruction::Print(FileSP out_sp) { - LLDB_RECORD_METHOD(void, SBInstruction, Print, (FileSP), out_sp); + LLDB_INSTRUMENT_METHOD(void, SBInstruction, Print, (FileSP), out_sp); if (!out_sp || !out_sp->IsValid()) return; @@ -291,8 +291,8 @@ 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_METHOD(bool, SBInstruction, EmulateWithFrame, + (lldb::SBFrame &, uint32_t), frame, evaluate_options); lldb::InstructionSP inst_sp(GetOpaque()); if (inst_sp) { @@ -316,8 +316,8 @@ } bool SBInstruction::DumpEmulation(const char *triple) { - LLDB_RECORD_METHOD(bool, SBInstruction, DumpEmulation, (const char *), - triple); + LLDB_INSTRUMENT_METHOD(bool, SBInstruction, DumpEmulation, (const char *), + triple); lldb::InstructionSP inst_sp(GetOpaque()); if (inst_sp && triple) { @@ -328,9 +328,9 @@ 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_METHOD(bool, SBInstruction, TestEmulation, + (lldb::SBStream &, const char *), output_stream, + test_file); if (!m_opaque_sp) SetOpaque(lldb::DisassemblerSP(), Index: lldb/source/API/SBInstructionList.cpp =================================================================== --- lldb/source/API/SBInstructionList.cpp +++ lldb/source/API/SBInstructionList.cpp @@ -7,35 +7,35 @@ //===----------------------------------------------------------------------===// #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); + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBInstructionList); } SBInstructionList::SBInstructionList(const SBInstructionList &rhs) : m_opaque_sp(rhs.m_opaque_sp) { - LLDB_RECORD_CONSTRUCTOR(SBInstructionList, (const lldb::SBInstructionList &), - rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBInstructionList, + (const lldb::SBInstructionList &), rhs); } const SBInstructionList &SBInstructionList:: operator=(const SBInstructionList &rhs) { - LLDB_RECORD_METHOD( - const lldb::SBInstructionList &, - SBInstructionList, operator=,(const lldb::SBInstructionList &), rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBInstructionList &, + SBInstructionList, operator=, + (const lldb::SBInstructionList &), rhs); if (this != &rhs) m_opaque_sp = rhs.m_opaque_sp; @@ -45,17 +45,17 @@ SBInstructionList::~SBInstructionList() = default; bool SBInstructionList::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInstructionList, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBInstructionList, IsValid); return this->operator bool(); } SBInstructionList::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInstructionList, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBInstructionList, operator bool); return m_opaque_sp.get() != nullptr; } size_t SBInstructionList::GetSize() { - LLDB_RECORD_METHOD_NO_ARGS(size_t, SBInstructionList, GetSize); + LLDB_INSTRUMENT_METHOD_NO_ARGS(size_t, SBInstructionList, GetSize); if (m_opaque_sp) return m_opaque_sp->GetInstructionList().GetSize(); @@ -63,8 +63,8 @@ } SBInstruction SBInstructionList::GetInstructionAtIndex(uint32_t idx) { - LLDB_RECORD_METHOD(lldb::SBInstruction, SBInstructionList, - GetInstructionAtIndex, (uint32_t), idx); + LLDB_INSTRUMENT_METHOD(lldb::SBInstruction, SBInstructionList, + GetInstructionAtIndex, (uint32_t), idx); SBInstruction inst; if (m_opaque_sp && idx < m_opaque_sp->GetInstructionList().GetSize()) @@ -77,9 +77,10 @@ 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_METHOD( + size_t, SBInstructionList, GetInstructionsCount, + (const lldb::SBAddress &, const lldb::SBAddress &, bool), start, end, + canSetBreakpoint); size_t num_instructions = GetSize(); size_t i = 0; @@ -104,14 +105,14 @@ } void SBInstructionList::Clear() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBInstructionList, Clear); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBInstructionList, Clear); m_opaque_sp.reset(); } void SBInstructionList::AppendInstruction(SBInstruction insn) { - LLDB_RECORD_METHOD(void, SBInstructionList, AppendInstruction, - (lldb::SBInstruction), insn); + LLDB_INSTRUMENT_METHOD(void, SBInstructionList, AppendInstruction, + (lldb::SBInstruction), insn); } void SBInstructionList::SetDisassembler(const lldb::DisassemblerSP &opaque_sp) { @@ -119,7 +120,7 @@ } void SBInstructionList::Print(FILE *out) { - LLDB_RECORD_METHOD(void, SBInstructionList, Print, (FILE *), out); + LLDB_INSTRUMENT_METHOD(void, SBInstructionList, Print, (FILE *), out); if (out == nullptr) return; StreamFile stream(out, false); @@ -127,7 +128,7 @@ } void SBInstructionList::Print(SBFile out) { - LLDB_RECORD_METHOD(void, SBInstructionList, Print, (SBFile), out); + LLDB_INSTRUMENT_METHOD(void, SBInstructionList, Print, (SBFile), out); if (!out.IsValid()) return; StreamFile stream(out.m_opaque_sp); @@ -135,7 +136,7 @@ } void SBInstructionList::Print(FileSP out_sp) { - LLDB_RECORD_METHOD(void, SBInstructionList, Print, (FileSP), out_sp); + LLDB_INSTRUMENT_METHOD(void, SBInstructionList, Print, (FileSP), out_sp); if (!out_sp || !out_sp->IsValid()) return; StreamFile stream(out_sp); @@ -143,8 +144,8 @@ } bool SBInstructionList::GetDescription(lldb::SBStream &stream) { - LLDB_RECORD_METHOD(bool, SBInstructionList, GetDescription, - (lldb::SBStream &), stream); + LLDB_INSTRUMENT_METHOD(bool, SBInstructionList, GetDescription, + (lldb::SBStream &), stream); return GetDescription(stream.ref()); } @@ -186,8 +187,9 @@ } bool SBInstructionList::DumpEmulationForAllInstructions(const char *triple) { - LLDB_RECORD_METHOD(bool, SBInstructionList, DumpEmulationForAllInstructions, - (const char *), triple); + LLDB_INSTRUMENT_METHOD(bool, SBInstructionList, + DumpEmulationForAllInstructions, (const char *), + triple); if (m_opaque_sp) { size_t len = GetSize(); Index: lldb/source/API/SBLanguageRuntime.cpp =================================================================== --- lldb/source/API/SBLanguageRuntime.cpp +++ lldb/source/API/SBLanguageRuntime.cpp @@ -7,25 +7,26 @@ //===----------------------------------------------------------------------===// #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_STATIC_METHOD(lldb::LanguageType, SBLanguageRuntime, + GetLanguageTypeFromString, (const char *), + 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_STATIC_METHOD(const char *, SBLanguageRuntime, + GetNameForLanguageType, (lldb::LanguageType), + language); return Language::GetNameForLanguageType(language); } Index: lldb/source/API/SBLaunchInfo.cpp =================================================================== --- lldb/source/API/SBLaunchInfo.cpp +++ 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 @@ SBLaunchInfo::SBLaunchInfo(const char **argv) : m_opaque_sp(new SBLaunchInfoImpl()) { - LLDB_RECORD_CONSTRUCTOR(SBLaunchInfo, (const char **), argv); + LLDB_INSTRUMENT_CONSTRUCTOR(SBLaunchInfo, (const char **), argv); m_opaque_sp->GetFlags().Reset(eLaunchFlagDebug | eLaunchFlagDisableASLR); if (argv && argv[0]) @@ -48,14 +48,14 @@ } SBLaunchInfo::SBLaunchInfo(const SBLaunchInfo &rhs) { - LLDB_RECORD_CONSTRUCTOR(SBLaunchInfo, (const lldb::SBLaunchInfo &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBLaunchInfo, (const lldb::SBLaunchInfo &), 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_METHOD(SBLaunchInfo &, SBLaunchInfo, operator=, + (const lldb::SBLaunchInfo &), rhs); m_opaque_sp = rhs.m_opaque_sp; return *this; @@ -72,90 +72,91 @@ } lldb::pid_t SBLaunchInfo::GetProcessID() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBLaunchInfo, GetProcessID); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::pid_t, SBLaunchInfo, GetProcessID); return m_opaque_sp->GetProcessID(); } uint32_t SBLaunchInfo::GetUserID() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetUserID); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetUserID); return m_opaque_sp->GetUserID(); } uint32_t SBLaunchInfo::GetGroupID() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetGroupID); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetGroupID); return m_opaque_sp->GetGroupID(); } bool SBLaunchInfo::UserIDIsValid() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBLaunchInfo, UserIDIsValid); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBLaunchInfo, UserIDIsValid); return m_opaque_sp->UserIDIsValid(); } bool SBLaunchInfo::GroupIDIsValid() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBLaunchInfo, GroupIDIsValid); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBLaunchInfo, GroupIDIsValid); return m_opaque_sp->GroupIDIsValid(); } void SBLaunchInfo::SetUserID(uint32_t uid) { - LLDB_RECORD_METHOD(void, SBLaunchInfo, SetUserID, (uint32_t), uid); + LLDB_INSTRUMENT_METHOD(void, SBLaunchInfo, SetUserID, (uint32_t), uid); m_opaque_sp->SetUserID(uid); } void SBLaunchInfo::SetGroupID(uint32_t gid) { - LLDB_RECORD_METHOD(void, SBLaunchInfo, SetGroupID, (uint32_t), gid); + LLDB_INSTRUMENT_METHOD(void, SBLaunchInfo, SetGroupID, (uint32_t), gid); m_opaque_sp->SetGroupID(gid); } SBFileSpec SBLaunchInfo::GetExecutableFile() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBLaunchInfo, GetExecutableFile); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBFileSpec, SBLaunchInfo, + GetExecutableFile); return SBFileSpec(m_opaque_sp->GetExecutableFile()); } void SBLaunchInfo::SetExecutableFile(SBFileSpec exe_file, bool add_as_first_arg) { - LLDB_RECORD_METHOD(void, SBLaunchInfo, SetExecutableFile, - (lldb::SBFileSpec, bool), exe_file, add_as_first_arg); + LLDB_INSTRUMENT_METHOD(void, SBLaunchInfo, SetExecutableFile, + (lldb::SBFileSpec, bool), exe_file, add_as_first_arg); m_opaque_sp->SetExecutableFile(exe_file.ref(), add_as_first_arg); } SBListener SBLaunchInfo::GetListener() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBLaunchInfo, GetListener); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBListener, SBLaunchInfo, GetListener); return SBListener(m_opaque_sp->GetListener()); } void SBLaunchInfo::SetListener(SBListener &listener) { - LLDB_RECORD_METHOD(void, SBLaunchInfo, SetListener, (lldb::SBListener &), - listener); + LLDB_INSTRUMENT_METHOD(void, SBLaunchInfo, SetListener, (lldb::SBListener &), + listener); m_opaque_sp->SetListener(listener.GetSP()); } uint32_t SBLaunchInfo::GetNumArguments() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetNumArguments); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetNumArguments); return m_opaque_sp->GetArguments().GetArgumentCount(); } const char *SBLaunchInfo::GetArgumentAtIndex(uint32_t idx) { - LLDB_RECORD_METHOD(const char *, SBLaunchInfo, GetArgumentAtIndex, (uint32_t), - idx); + LLDB_INSTRUMENT_METHOD(const char *, SBLaunchInfo, GetArgumentAtIndex, + (uint32_t), idx); return m_opaque_sp->GetArguments().GetArgumentAtIndex(idx); } void SBLaunchInfo::SetArguments(const char **argv, bool append) { - LLDB_RECORD_METHOD(void, SBLaunchInfo, SetArguments, (const char **, bool), - argv, append); + LLDB_INSTRUMENT_METHOD(void, SBLaunchInfo, SetArguments, + (const char **, bool), argv, append); if (append) { if (argv) @@ -169,14 +170,15 @@ } uint32_t SBLaunchInfo::GetNumEnvironmentEntries() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetNumEnvironmentEntries); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, + GetNumEnvironmentEntries); return m_opaque_sp->GetEnvironment().size(); } const char *SBLaunchInfo::GetEnvironmentEntryAtIndex(uint32_t idx) { - LLDB_RECORD_METHOD(const char *, SBLaunchInfo, GetEnvironmentEntryAtIndex, - (uint32_t), idx); + LLDB_INSTRUMENT_METHOD(const char *, SBLaunchInfo, GetEnvironmentEntryAtIndex, + (uint32_t), idx); if (idx > GetNumEnvironmentEntries()) return nullptr; @@ -184,14 +186,14 @@ } void SBLaunchInfo::SetEnvironmentEntries(const char **envp, bool append) { - LLDB_RECORD_METHOD(void, SBLaunchInfo, SetEnvironmentEntries, - (const char **, bool), envp, append); + LLDB_INSTRUMENT_METHOD(void, SBLaunchInfo, SetEnvironmentEntries, + (const char **, bool), 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_METHOD(void, SBLaunchInfo, SetEnvironment, + (const lldb::SBEnvironment &, bool), env, append); Environment &refEnv = env.ref(); if (append) { for (auto &KV : refEnv) @@ -202,57 +204,59 @@ } SBEnvironment SBLaunchInfo::GetEnvironment() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBEnvironment, SBLaunchInfo, GetEnvironment); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBEnvironment, SBLaunchInfo, + GetEnvironment); return SBEnvironment(Environment(m_opaque_sp->GetEnvironment())); } void SBLaunchInfo::Clear() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBLaunchInfo, Clear); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBLaunchInfo, Clear); m_opaque_sp->Clear(); } const char *SBLaunchInfo::GetWorkingDirectory() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBLaunchInfo, - GetWorkingDirectory); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(const char *, SBLaunchInfo, + GetWorkingDirectory); return m_opaque_sp->GetWorkingDirectory().GetCString(); } void SBLaunchInfo::SetWorkingDirectory(const char *working_dir) { - LLDB_RECORD_METHOD(void, SBLaunchInfo, SetWorkingDirectory, (const char *), - working_dir); + LLDB_INSTRUMENT_METHOD(void, SBLaunchInfo, SetWorkingDirectory, + (const char *), working_dir); m_opaque_sp->SetWorkingDirectory(FileSpec(working_dir)); } uint32_t SBLaunchInfo::GetLaunchFlags() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetLaunchFlags); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetLaunchFlags); return m_opaque_sp->GetFlags().Get(); } void SBLaunchInfo::SetLaunchFlags(uint32_t flags) { - LLDB_RECORD_METHOD(void, SBLaunchInfo, SetLaunchFlags, (uint32_t), flags); + LLDB_INSTRUMENT_METHOD(void, SBLaunchInfo, SetLaunchFlags, (uint32_t), flags); m_opaque_sp->GetFlags().Reset(flags); } const char *SBLaunchInfo::GetProcessPluginName() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBLaunchInfo, GetProcessPluginName); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBLaunchInfo, + GetProcessPluginName); return m_opaque_sp->GetProcessPluginName(); } void SBLaunchInfo::SetProcessPluginName(const char *plugin_name) { - LLDB_RECORD_METHOD(void, SBLaunchInfo, SetProcessPluginName, (const char *), - plugin_name); + LLDB_INSTRUMENT_METHOD(void, SBLaunchInfo, SetProcessPluginName, + (const char *), plugin_name); return m_opaque_sp->SetProcessPluginName(plugin_name); } const char *SBLaunchInfo::GetShell() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBLaunchInfo, GetShell); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBLaunchInfo, GetShell); // Constify this string so that it is saved in the string pool. Otherwise it // would be freed when this function goes out of scope. @@ -261,93 +265,94 @@ } void SBLaunchInfo::SetShell(const char *path) { - LLDB_RECORD_METHOD(void, SBLaunchInfo, SetShell, (const char *), path); + LLDB_INSTRUMENT_METHOD(void, SBLaunchInfo, SetShell, (const char *), path); m_opaque_sp->SetShell(FileSpec(path)); } bool SBLaunchInfo::GetShellExpandArguments() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBLaunchInfo, GetShellExpandArguments); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBLaunchInfo, GetShellExpandArguments); return m_opaque_sp->GetShellExpandArguments(); } void SBLaunchInfo::SetShellExpandArguments(bool expand) { - LLDB_RECORD_METHOD(void, SBLaunchInfo, SetShellExpandArguments, (bool), - expand); + LLDB_INSTRUMENT_METHOD(void, SBLaunchInfo, SetShellExpandArguments, (bool), + expand); m_opaque_sp->SetShellExpandArguments(expand); } uint32_t SBLaunchInfo::GetResumeCount() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetResumeCount); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetResumeCount); return m_opaque_sp->GetResumeCount(); } void SBLaunchInfo::SetResumeCount(uint32_t c) { - LLDB_RECORD_METHOD(void, SBLaunchInfo, SetResumeCount, (uint32_t), c); + LLDB_INSTRUMENT_METHOD(void, SBLaunchInfo, SetResumeCount, (uint32_t), c); m_opaque_sp->SetResumeCount(c); } bool SBLaunchInfo::AddCloseFileAction(int fd) { - LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddCloseFileAction, (int), fd); + LLDB_INSTRUMENT_METHOD(bool, SBLaunchInfo, AddCloseFileAction, (int), fd); return m_opaque_sp->AppendCloseFileAction(fd); } bool SBLaunchInfo::AddDuplicateFileAction(int fd, int dup_fd) { - LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddDuplicateFileAction, (int, int), fd, - dup_fd); + LLDB_INSTRUMENT_METHOD(bool, SBLaunchInfo, AddDuplicateFileAction, (int, int), + fd, dup_fd); return m_opaque_sp->AppendDuplicateFileAction(fd, dup_fd); } bool SBLaunchInfo::AddOpenFileAction(int fd, const char *path, bool read, bool write) { - LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddOpenFileAction, - (int, const char *, bool, bool), fd, path, read, write); + LLDB_INSTRUMENT_METHOD(bool, SBLaunchInfo, AddOpenFileAction, + (int, const char *, bool, bool), fd, path, read, + write); return m_opaque_sp->AppendOpenFileAction(fd, FileSpec(path), read, write); } bool SBLaunchInfo::AddSuppressFileAction(int fd, bool read, bool write) { - LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddSuppressFileAction, - (int, bool, bool), fd, read, write); + LLDB_INSTRUMENT_METHOD(bool, SBLaunchInfo, AddSuppressFileAction, + (int, bool, bool), fd, read, write); return m_opaque_sp->AppendSuppressFileAction(fd, read, write); } void SBLaunchInfo::SetLaunchEventData(const char *data) { - LLDB_RECORD_METHOD(void, SBLaunchInfo, SetLaunchEventData, (const char *), - data); + LLDB_INSTRUMENT_METHOD(void, SBLaunchInfo, SetLaunchEventData, (const char *), + data); m_opaque_sp->SetLaunchEventData(data); } const char *SBLaunchInfo::GetLaunchEventData() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBLaunchInfo, - GetLaunchEventData); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(const char *, SBLaunchInfo, + GetLaunchEventData); return m_opaque_sp->GetLaunchEventData(); } void SBLaunchInfo::SetDetachOnError(bool enable) { - LLDB_RECORD_METHOD(void, SBLaunchInfo, SetDetachOnError, (bool), enable); + LLDB_INSTRUMENT_METHOD(void, SBLaunchInfo, SetDetachOnError, (bool), enable); m_opaque_sp->SetDetachOnError(enable); } bool SBLaunchInfo::GetDetachOnError() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBLaunchInfo, GetDetachOnError); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBLaunchInfo, GetDetachOnError); return m_opaque_sp->GetDetachOnError(); } const char *SBLaunchInfo::GetScriptedProcessClassName() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBLaunchInfo, - GetScriptedProcessClassName); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(const char *, SBLaunchInfo, + GetScriptedProcessClassName); // 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 +361,15 @@ } void SBLaunchInfo::SetScriptedProcessClassName(const char *class_name) { - LLDB_RECORD_METHOD(void, SBLaunchInfo, SetScriptedProcessClassName, - (const char *), class_name); + LLDB_INSTRUMENT_METHOD(void, SBLaunchInfo, SetScriptedProcessClassName, + (const char *), 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_METHOD_CONST_NO_ARGS(lldb::SBStructuredData, SBLaunchInfo, + GetScriptedProcessDictionary); lldb_private::StructuredData::DictionarySP dict_sp = m_opaque_sp->GetScriptedProcessDictionarySP(); @@ -376,8 +381,8 @@ } void SBLaunchInfo::SetScriptedProcessDictionary(lldb::SBStructuredData dict) { - LLDB_RECORD_METHOD(void, SBLaunchInfo, SetScriptedProcessDictionary, - (lldb::SBStructuredData), dict); + LLDB_INSTRUMENT_METHOD(void, SBLaunchInfo, SetScriptedProcessDictionary, + (lldb::SBStructuredData), dict); if (!dict.IsValid() || !dict.m_impl_up) return; Index: lldb/source/API/SBLineEntry.cpp =================================================================== --- lldb/source/API/SBLineEntry.cpp +++ 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 @@ -19,10 +19,10 @@ using namespace lldb; using namespace lldb_private; -SBLineEntry::SBLineEntry() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBLineEntry); } +SBLineEntry::SBLineEntry() { LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBLineEntry); } SBLineEntry::SBLineEntry(const SBLineEntry &rhs) { - LLDB_RECORD_CONSTRUCTOR(SBLineEntry, (const lldb::SBLineEntry &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBLineEntry, (const lldb::SBLineEntry &), rhs); m_opaque_up = clone(rhs.m_opaque_up); } @@ -33,8 +33,8 @@ } const SBLineEntry &SBLineEntry::operator=(const SBLineEntry &rhs) { - LLDB_RECORD_METHOD(const lldb::SBLineEntry &, - SBLineEntry, operator=,(const lldb::SBLineEntry &), rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBLineEntry &, SBLineEntry, operator=, + (const lldb::SBLineEntry &), rhs); if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); @@ -48,8 +48,8 @@ SBLineEntry::~SBLineEntry() = default; SBAddress SBLineEntry::GetStartAddress() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBLineEntry, - GetStartAddress); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBLineEntry, + GetStartAddress); SBAddress sb_address; if (m_opaque_up) @@ -59,7 +59,8 @@ } SBAddress SBLineEntry::GetEndAddress() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBLineEntry, GetEndAddress); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBLineEntry, + GetEndAddress); SBAddress sb_address; if (m_opaque_up) { @@ -70,17 +71,18 @@ } bool SBLineEntry::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBLineEntry, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBLineEntry, IsValid); return this->operator bool(); } SBLineEntry::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBLineEntry, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBLineEntry, operator bool); 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_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBLineEntry, + GetFileSpec); SBFileSpec sb_file_spec; if (m_opaque_up.get() && m_opaque_up->file) @@ -90,7 +92,7 @@ } uint32_t SBLineEntry::GetLine() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBLineEntry, GetLine); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(uint32_t, SBLineEntry, GetLine); uint32_t line = 0; if (m_opaque_up) @@ -100,7 +102,7 @@ } uint32_t SBLineEntry::GetColumn() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBLineEntry, GetColumn); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(uint32_t, SBLineEntry, GetColumn); if (m_opaque_up) return m_opaque_up->column; @@ -108,8 +110,8 @@ } void SBLineEntry::SetFileSpec(lldb::SBFileSpec filespec) { - LLDB_RECORD_METHOD(void, SBLineEntry, SetFileSpec, (lldb::SBFileSpec), - filespec); + LLDB_INSTRUMENT_METHOD(void, SBLineEntry, SetFileSpec, (lldb::SBFileSpec), + filespec); if (filespec.IsValid()) ref().file = filespec.ref(); @@ -117,20 +119,20 @@ ref().file.Clear(); } void SBLineEntry::SetLine(uint32_t line) { - LLDB_RECORD_METHOD(void, SBLineEntry, SetLine, (uint32_t), line); + LLDB_INSTRUMENT_METHOD(void, SBLineEntry, SetLine, (uint32_t), line); ref().line = line; } void SBLineEntry::SetColumn(uint32_t column) { - LLDB_RECORD_METHOD(void, SBLineEntry, SetColumn, (uint32_t), column); + LLDB_INSTRUMENT_METHOD(void, SBLineEntry, SetColumn, (uint32_t), column); ref().line = column; } bool SBLineEntry::operator==(const SBLineEntry &rhs) const { - LLDB_RECORD_METHOD_CONST( - bool, SBLineEntry, operator==,(const lldb::SBLineEntry &), rhs); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBLineEntry, operator==, + (const lldb::SBLineEntry &), rhs); lldb_private::LineEntry *lhs_ptr = m_opaque_up.get(); lldb_private::LineEntry *rhs_ptr = rhs.m_opaque_up.get(); @@ -142,8 +144,8 @@ } bool SBLineEntry::operator!=(const SBLineEntry &rhs) const { - LLDB_RECORD_METHOD_CONST( - bool, SBLineEntry, operator!=,(const lldb::SBLineEntry &), rhs); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBLineEntry, operator!=, + (const lldb::SBLineEntry &), rhs); lldb_private::LineEntry *lhs_ptr = m_opaque_up.get(); lldb_private::LineEntry *rhs_ptr = rhs.m_opaque_up.get(); @@ -167,8 +169,8 @@ 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_METHOD(bool, SBLineEntry, GetDescription, (lldb::SBStream &), + description); Stream &strm = description.ref(); Index: lldb/source/API/SBListener.cpp =================================================================== --- lldb/source/API/SBListener.cpp +++ lldb/source/API/SBListener.cpp @@ -7,34 +7,34 @@ //===----------------------------------------------------------------------===// #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_CONSTRUCTOR_NO_ARGS(SBListener); } SBListener::SBListener(const char *name) : m_opaque_sp(Listener::MakeListener(name)), m_unused_ptr(nullptr) { - LLDB_RECORD_CONSTRUCTOR(SBListener, (const char *), name); + LLDB_INSTRUMENT_CONSTRUCTOR(SBListener, (const char *), 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_CONSTRUCTOR(SBListener, (const lldb::SBListener &), rhs); } const lldb::SBListener &SBListener::operator=(const lldb::SBListener &rhs) { - LLDB_RECORD_METHOD(const lldb::SBListener &, - SBListener, operator=,(const lldb::SBListener &), rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBListener &, SBListener, operator=, + (const lldb::SBListener &), rhs); if (this != &rhs) { m_opaque_sp = rhs.m_opaque_sp; @@ -49,18 +49,18 @@ SBListener::~SBListener() = default; bool SBListener::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBListener, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBListener, IsValid); return this->operator bool(); } SBListener::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBListener, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBListener, operator bool); return m_opaque_sp != nullptr; } void SBListener::AddEvent(const SBEvent &event) { - LLDB_RECORD_METHOD(void, SBListener, AddEvent, (const lldb::SBEvent &), - event); + LLDB_INSTRUMENT_METHOD(void, SBListener, AddEvent, (const lldb::SBEvent &), + event); EventSP &event_sp = event.GetSP(); if (event_sp) @@ -68,7 +68,7 @@ } void SBListener::Clear() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBListener, Clear); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBListener, Clear); if (m_opaque_sp) m_opaque_sp->Clear(); @@ -77,9 +77,9 @@ 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_METHOD(uint32_t, SBListener, StartListeningForEventClass, + (lldb::SBDebugger &, const char *, uint32_t), debugger, + broadcaster_class, event_mask); if (m_opaque_sp) { Debugger *lldb_debugger = debugger.get(); @@ -95,9 +95,9 @@ 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_METHOD(bool, SBListener, StopListeningForEventClass, + (lldb::SBDebugger &, const char *, uint32_t), debugger, + broadcaster_class, event_mask); if (m_opaque_sp) { Debugger *lldb_debugger = debugger.get(); @@ -112,9 +112,9 @@ 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_METHOD(uint32_t, SBListener, StartListeningForEvents, + (const lldb::SBBroadcaster &, uint32_t), broadcaster, + event_mask); uint32_t acquired_event_mask = 0; if (m_opaque_sp && broadcaster.IsValid()) { @@ -127,9 +127,9 @@ 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_METHOD(bool, SBListener, StopListeningForEvents, + (const lldb::SBBroadcaster &, uint32_t), broadcaster, + event_mask); if (m_opaque_sp && broadcaster.IsValid()) { return m_opaque_sp->StopListeningForEvents(broadcaster.get(), event_mask); @@ -138,8 +138,8 @@ } bool SBListener::WaitForEvent(uint32_t timeout_secs, SBEvent &event) { - LLDB_RECORD_METHOD(bool, SBListener, WaitForEvent, - (uint32_t, lldb::SBEvent &), timeout_secs, event); + LLDB_INSTRUMENT_METHOD(bool, SBListener, WaitForEvent, + (uint32_t, lldb::SBEvent &), timeout_secs, event); bool success = false; @@ -165,9 +165,10 @@ 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_METHOD( + bool, SBListener, WaitForEventForBroadcaster, + (uint32_t, const lldb::SBBroadcaster &, lldb::SBEvent &), num_seconds, + broadcaster, event); if (m_opaque_sp && broadcaster.IsValid()) { Timeout timeout(llvm::None); @@ -187,7 +188,7 @@ bool SBListener::WaitForEventForBroadcasterWithType( uint32_t num_seconds, const SBBroadcaster &broadcaster, uint32_t event_type_mask, SBEvent &event) { - LLDB_RECORD_METHOD( + LLDB_INSTRUMENT_METHOD( bool, SBListener, WaitForEventForBroadcasterWithType, (uint32_t, const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &), num_seconds, broadcaster, event_type_mask, event); @@ -208,8 +209,8 @@ } bool SBListener::PeekAtNextEvent(SBEvent &event) { - LLDB_RECORD_METHOD(bool, SBListener, PeekAtNextEvent, (lldb::SBEvent &), - event); + LLDB_INSTRUMENT_METHOD(bool, SBListener, PeekAtNextEvent, (lldb::SBEvent &), + event); if (m_opaque_sp) { event.reset(m_opaque_sp->PeekAtNextEvent()); @@ -221,9 +222,9 @@ bool SBListener::PeekAtNextEventForBroadcaster(const SBBroadcaster &broadcaster, SBEvent &event) { - LLDB_RECORD_METHOD(bool, SBListener, PeekAtNextEventForBroadcaster, - (const lldb::SBBroadcaster &, lldb::SBEvent &), - broadcaster, event); + LLDB_INSTRUMENT_METHOD(bool, SBListener, PeekAtNextEventForBroadcaster, + (const lldb::SBBroadcaster &, lldb::SBEvent &), + broadcaster, event); if (m_opaque_sp && broadcaster.IsValid()) { event.reset(m_opaque_sp->PeekAtNextEventForBroadcaster(broadcaster.get())); @@ -236,9 +237,10 @@ 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_METHOD( + bool, SBListener, PeekAtNextEventForBroadcasterWithType, + (const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &), broadcaster, + event_type_mask, event); if (m_opaque_sp && broadcaster.IsValid()) { event.reset(m_opaque_sp->PeekAtNextEventForBroadcasterWithType( @@ -250,7 +252,8 @@ } bool SBListener::GetNextEvent(SBEvent &event) { - LLDB_RECORD_METHOD(bool, SBListener, GetNextEvent, (lldb::SBEvent &), event); + LLDB_INSTRUMENT_METHOD(bool, SBListener, GetNextEvent, (lldb::SBEvent &), + event); if (m_opaque_sp) { EventSP event_sp; @@ -265,9 +268,9 @@ bool SBListener::GetNextEventForBroadcaster(const SBBroadcaster &broadcaster, SBEvent &event) { - LLDB_RECORD_METHOD(bool, SBListener, GetNextEventForBroadcaster, - (const lldb::SBBroadcaster &, lldb::SBEvent &), - broadcaster, event); + LLDB_INSTRUMENT_METHOD(bool, SBListener, GetNextEventForBroadcaster, + (const lldb::SBBroadcaster &, lldb::SBEvent &), + broadcaster, event); if (m_opaque_sp && broadcaster.IsValid()) { EventSP event_sp; @@ -284,9 +287,10 @@ 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_METHOD( + bool, SBListener, GetNextEventForBroadcasterWithType, + (const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &), broadcaster, + event_type_mask, event); if (m_opaque_sp && broadcaster.IsValid()) { EventSP event_sp; @@ -302,8 +306,8 @@ } bool SBListener::HandleBroadcastEvent(const SBEvent &event) { - LLDB_RECORD_METHOD(bool, SBListener, HandleBroadcastEvent, - (const lldb::SBEvent &), event); + LLDB_INSTRUMENT_METHOD(bool, SBListener, HandleBroadcastEvent, + (const lldb::SBEvent &), event); if (m_opaque_sp) return m_opaque_sp->HandleBroadcastEvent(event.GetSP()); Index: lldb/source/API/SBMemoryRegionInfo.cpp =================================================================== --- lldb/source/API/SBMemoryRegionInfo.cpp +++ lldb/source/API/SBMemoryRegionInfo.cpp @@ -7,26 +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_CONSTRUCTOR_NO_ARGS(SBMemoryRegionInfo); } 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( + LLDB_INSTRUMENT_CONSTRUCTOR( SBMemoryRegionInfo, (const char *, lldb::addr_t, lldb::addr_t, uint32_t, bool, bool), name, begin, end, permissions, mapped, stack_memory); @@ -47,16 +47,16 @@ } SBMemoryRegionInfo::SBMemoryRegionInfo(const SBMemoryRegionInfo &rhs) { - LLDB_RECORD_CONSTRUCTOR(SBMemoryRegionInfo, - (const lldb::SBMemoryRegionInfo &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBMemoryRegionInfo, + (const lldb::SBMemoryRegionInfo &), rhs); m_opaque_up = clone(rhs.m_opaque_up); } const SBMemoryRegionInfo &SBMemoryRegionInfo:: operator=(const SBMemoryRegionInfo &rhs) { - LLDB_RECORD_METHOD( - const lldb::SBMemoryRegionInfo &, - SBMemoryRegionInfo, operator=,(const lldb::SBMemoryRegionInfo &), rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBMemoryRegionInfo &, + SBMemoryRegionInfo, operator=, + (const lldb::SBMemoryRegionInfo &), rhs); if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); @@ -66,23 +66,21 @@ SBMemoryRegionInfo::~SBMemoryRegionInfo() = default; void SBMemoryRegionInfo::Clear() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBMemoryRegionInfo, Clear); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBMemoryRegionInfo, Clear); m_opaque_up->Clear(); } bool SBMemoryRegionInfo::operator==(const SBMemoryRegionInfo &rhs) const { - LLDB_RECORD_METHOD_CONST( - bool, SBMemoryRegionInfo, operator==,(const lldb::SBMemoryRegionInfo &), - rhs); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBMemoryRegionInfo, operator==, + (const lldb::SBMemoryRegionInfo &), rhs); return ref() == rhs.ref(); } bool SBMemoryRegionInfo::operator!=(const SBMemoryRegionInfo &rhs) const { - LLDB_RECORD_METHOD_CONST( - bool, SBMemoryRegionInfo, operator!=,(const lldb::SBMemoryRegionInfo &), - rhs); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBMemoryRegionInfo, operator!=, + (const lldb::SBMemoryRegionInfo &), rhs); return ref() != rhs.ref(); } @@ -92,55 +90,59 @@ 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_METHOD_NO_ARGS(lldb::addr_t, SBMemoryRegionInfo, + GetRegionBase); return m_opaque_up->GetRange().GetRangeBase(); } lldb::addr_t SBMemoryRegionInfo::GetRegionEnd() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBMemoryRegionInfo, GetRegionEnd); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::addr_t, SBMemoryRegionInfo, + GetRegionEnd); return m_opaque_up->GetRange().GetRangeEnd(); } bool SBMemoryRegionInfo::IsReadable() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsReadable); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsReadable); return m_opaque_up->GetReadable() == MemoryRegionInfo::eYes; } bool SBMemoryRegionInfo::IsWritable() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsWritable); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsWritable); return m_opaque_up->GetWritable() == MemoryRegionInfo::eYes; } bool SBMemoryRegionInfo::IsExecutable() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsExecutable); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsExecutable); return m_opaque_up->GetExecutable() == MemoryRegionInfo::eYes; } bool SBMemoryRegionInfo::IsMapped() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsMapped); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsMapped); return m_opaque_up->GetMapped() == MemoryRegionInfo::eYes; } const char *SBMemoryRegionInfo::GetName() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBMemoryRegionInfo, GetName); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBMemoryRegionInfo, GetName); return m_opaque_up->GetName().AsCString(); } bool SBMemoryRegionInfo::HasDirtyMemoryPageList() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, HasDirtyMemoryPageList); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, + HasDirtyMemoryPageList); return m_opaque_up->GetDirtyPageList().hasValue(); } uint32_t SBMemoryRegionInfo::GetNumDirtyPages() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBMemoryRegionInfo, GetNumDirtyPages); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBMemoryRegionInfo, + GetNumDirtyPages); uint32_t num_dirty_pages = 0; llvm::Optional> dirty_page_list = @@ -152,8 +154,8 @@ } addr_t SBMemoryRegionInfo::GetDirtyPageAddressAtIndex(uint32_t idx) { - LLDB_RECORD_METHOD(lldb::addr_t, SBMemoryRegionInfo, - GetDirtyPageAddressAtIndex, (uint32_t), idx); + LLDB_INSTRUMENT_METHOD(lldb::addr_t, SBMemoryRegionInfo, + GetDirtyPageAddressAtIndex, (uint32_t), idx); addr_t dirty_page_addr = LLDB_INVALID_ADDRESS; const llvm::Optional> &dirty_page_list = @@ -165,14 +167,14 @@ } int SBMemoryRegionInfo::GetPageSize() { - LLDB_RECORD_METHOD_NO_ARGS(int, SBMemoryRegionInfo, GetPageSize); + LLDB_INSTRUMENT_METHOD_NO_ARGS(int, SBMemoryRegionInfo, GetPageSize); return m_opaque_up->GetPageSize(); } bool SBMemoryRegionInfo::GetDescription(SBStream &description) { - LLDB_RECORD_METHOD(bool, SBMemoryRegionInfo, GetDescription, - (lldb::SBStream &), description); + LLDB_INSTRUMENT_METHOD(bool, SBMemoryRegionInfo, GetDescription, + (lldb::SBStream &), description); Stream &strm = description.ref(); const addr_t load_addr = m_opaque_up->GetRange().base; Index: lldb/source/API/SBMemoryRegionInfoList.cpp =================================================================== --- lldb/source/API/SBMemoryRegionInfoList.cpp +++ 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 @@ -83,24 +83,23 @@ SBMemoryRegionInfoList::SBMemoryRegionInfoList() : m_opaque_up(new MemoryRegionInfoListImpl()) { - LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBMemoryRegionInfoList); + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBMemoryRegionInfoList); } SBMemoryRegionInfoList::SBMemoryRegionInfoList( const SBMemoryRegionInfoList &rhs) : m_opaque_up(new MemoryRegionInfoListImpl(*rhs.m_opaque_up)) { - LLDB_RECORD_CONSTRUCTOR(SBMemoryRegionInfoList, - (const lldb::SBMemoryRegionInfoList &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBMemoryRegionInfoList, + (const lldb::SBMemoryRegionInfoList &), 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_METHOD(const lldb::SBMemoryRegionInfoList &, + SBMemoryRegionInfoList, operator=, + (const lldb::SBMemoryRegionInfoList &), rhs); if (this != &rhs) { *m_opaque_up = *rhs.m_opaque_up; @@ -109,14 +108,15 @@ } uint32_t SBMemoryRegionInfoList::GetSize() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBMemoryRegionInfoList, GetSize); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(uint32_t, SBMemoryRegionInfoList, + GetSize); return m_opaque_up->GetSize(); } bool SBMemoryRegionInfoList::GetMemoryRegionContainingAddress( lldb::addr_t addr, SBMemoryRegionInfo ®ion_info) { - LLDB_RECORD_METHOD( + LLDB_INSTRUMENT_METHOD( bool, SBMemoryRegionInfoList, GetMemoryRegionContainingAddress, (lldb::addr_t, lldb::SBMemoryRegionInfo &), addr, region_info); @@ -125,28 +125,29 @@ bool SBMemoryRegionInfoList::GetMemoryRegionAtIndex( uint32_t idx, SBMemoryRegionInfo ®ion_info) { - LLDB_RECORD_METHOD(bool, SBMemoryRegionInfoList, GetMemoryRegionAtIndex, - (uint32_t, lldb::SBMemoryRegionInfo &), idx, region_info); + LLDB_INSTRUMENT_METHOD(bool, SBMemoryRegionInfoList, GetMemoryRegionAtIndex, + (uint32_t, lldb::SBMemoryRegionInfo &), 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_METHOD_NO_ARGS(void, SBMemoryRegionInfoList, Clear); m_opaque_up->Clear(); } void SBMemoryRegionInfoList::Append(SBMemoryRegionInfo &sb_region) { - LLDB_RECORD_METHOD(void, SBMemoryRegionInfoList, Append, - (lldb::SBMemoryRegionInfo &), sb_region); + LLDB_INSTRUMENT_METHOD(void, SBMemoryRegionInfoList, Append, + (lldb::SBMemoryRegionInfo &), sb_region); m_opaque_up->Append(sb_region.ref()); } void SBMemoryRegionInfoList::Append(SBMemoryRegionInfoList &sb_region_list) { - LLDB_RECORD_METHOD(void, SBMemoryRegionInfoList, Append, - (lldb::SBMemoryRegionInfoList &), sb_region_list); + LLDB_INSTRUMENT_METHOD(void, SBMemoryRegionInfoList, Append, + (lldb::SBMemoryRegionInfoList &), sb_region_list); m_opaque_up->Append(*sb_region_list); } Index: lldb/source/API/SBModule.cpp =================================================================== --- lldb/source/API/SBModule.cpp +++ 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,19 @@ #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_CONSTRUCTOR_NO_ARGS(SBModule); } 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_CONSTRUCTOR(SBModule, (const lldb::SBModuleSpec &), + module_spec); ModuleSP module_sp; Status error = ModuleList::GetSharedModule( @@ -44,12 +45,12 @@ } SBModule::SBModule(const SBModule &rhs) : m_opaque_sp(rhs.m_opaque_sp) { - LLDB_RECORD_CONSTRUCTOR(SBModule, (const lldb::SBModule &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBModule, (const lldb::SBModule &), 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_CONSTRUCTOR(SBModule, (lldb::SBProcess &, lldb::addr_t), + process, header_addr); ProcessSP process_sp(process.GetSP()); if (process_sp) { @@ -64,8 +65,8 @@ } const SBModule &SBModule::operator=(const SBModule &rhs) { - LLDB_RECORD_METHOD(const lldb::SBModule &, SBModule, operator=, - (const lldb::SBModule &), rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBModule &, SBModule, operator=, + (const lldb::SBModule &), rhs); if (this != &rhs) m_opaque_sp = rhs.m_opaque_sp; @@ -75,23 +76,23 @@ SBModule::~SBModule() = default; bool SBModule::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModule, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBModule, IsValid); return this->operator bool(); } SBModule::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModule, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBModule, operator bool); return m_opaque_sp.get() != nullptr; } void SBModule::Clear() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBModule, Clear); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBModule, Clear); m_opaque_sp.reset(); } SBFileSpec SBModule::GetFileSpec() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule, GetFileSpec); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule, GetFileSpec); SBFileSpec file_spec; ModuleSP module_sp(GetSP()); @@ -102,8 +103,8 @@ } lldb::SBFileSpec SBModule::GetPlatformFileSpec() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule, - GetPlatformFileSpec); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule, + GetPlatformFileSpec); SBFileSpec file_spec; ModuleSP module_sp(GetSP()); @@ -114,8 +115,8 @@ } bool SBModule::SetPlatformFileSpec(const lldb::SBFileSpec &platform_file) { - LLDB_RECORD_METHOD(bool, SBModule, SetPlatformFileSpec, - (const lldb::SBFileSpec &), platform_file); + LLDB_INSTRUMENT_METHOD(bool, SBModule, SetPlatformFileSpec, + (const lldb::SBFileSpec &), platform_file); bool result = false; @@ -129,8 +130,8 @@ } lldb::SBFileSpec SBModule::GetRemoteInstallFileSpec() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModule, - GetRemoteInstallFileSpec); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBFileSpec, SBModule, + GetRemoteInstallFileSpec); SBFileSpec sb_file_spec; ModuleSP module_sp(GetSP()); @@ -140,8 +141,8 @@ } bool SBModule::SetRemoteInstallFileSpec(lldb::SBFileSpec &file) { - LLDB_RECORD_METHOD(bool, SBModule, SetRemoteInstallFileSpec, - (lldb::SBFileSpec &), file); + LLDB_INSTRUMENT_METHOD(bool, SBModule, SetRemoteInstallFileSpec, + (lldb::SBFileSpec &), file); ModuleSP module_sp(GetSP()); if (module_sp) { @@ -152,7 +153,7 @@ } const uint8_t *SBModule::GetUUIDBytes() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(const uint8_t *, SBModule, GetUUIDBytes); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(const uint8_t *, SBModule, GetUUIDBytes); const uint8_t *uuid_bytes = nullptr; ModuleSP module_sp(GetSP()); @@ -163,7 +164,7 @@ } const char *SBModule::GetUUIDString() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBModule, GetUUIDString); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(const char *, SBModule, GetUUIDString); const char *uuid_cstr = nullptr; ModuleSP module_sp(GetSP()); @@ -183,8 +184,8 @@ } bool SBModule::operator==(const SBModule &rhs) const { - LLDB_RECORD_METHOD_CONST(bool, SBModule, operator==, (const lldb::SBModule &), - rhs); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBModule, operator==, + (const lldb::SBModule &), rhs); if (m_opaque_sp) return m_opaque_sp.get() == rhs.m_opaque_sp.get(); @@ -192,8 +193,8 @@ } bool SBModule::operator!=(const SBModule &rhs) const { - LLDB_RECORD_METHOD_CONST(bool, SBModule, operator!=, (const lldb::SBModule &), - rhs); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBModule, operator!=, + (const lldb::SBModule &), rhs); if (m_opaque_sp) return m_opaque_sp.get() != rhs.m_opaque_sp.get(); @@ -205,8 +206,8 @@ 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_METHOD(lldb::SBAddress, SBModule, ResolveFileAddress, + (lldb::addr_t), vm_addr); lldb::SBAddress sb_addr; ModuleSP module_sp(GetSP()); @@ -221,9 +222,9 @@ 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_METHOD( + lldb::SBSymbolContext, SBModule, ResolveSymbolContextForAddress, + (const lldb::SBAddress &, uint32_t), addr, resolve_scope); SBSymbolContext sb_sc; ModuleSP module_sp(GetSP()); @@ -234,8 +235,8 @@ } bool SBModule::GetDescription(SBStream &description) { - LLDB_RECORD_METHOD(bool, SBModule, GetDescription, (lldb::SBStream &), - description); + LLDB_INSTRUMENT_METHOD(bool, SBModule, GetDescription, (lldb::SBStream &), + description); Stream &strm = description.ref(); @@ -249,7 +250,7 @@ } uint32_t SBModule::GetNumCompileUnits() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBModule, GetNumCompileUnits); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBModule, GetNumCompileUnits); ModuleSP module_sp(GetSP()); if (module_sp) { @@ -259,8 +260,8 @@ } SBCompileUnit SBModule::GetCompileUnitAtIndex(uint32_t index) { - LLDB_RECORD_METHOD(lldb::SBCompileUnit, SBModule, GetCompileUnitAtIndex, - (uint32_t), index); + LLDB_INSTRUMENT_METHOD(lldb::SBCompileUnit, SBModule, GetCompileUnitAtIndex, + (uint32_t), index); SBCompileUnit sb_cu; ModuleSP module_sp(GetSP()); @@ -272,8 +273,8 @@ } SBSymbolContextList SBModule::FindCompileUnits(const SBFileSpec &sb_file_spec) { - LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBModule, FindCompileUnits, - (const lldb::SBFileSpec &), sb_file_spec); + LLDB_INSTRUMENT_METHOD(lldb::SBSymbolContextList, SBModule, FindCompileUnits, + (const lldb::SBFileSpec &), sb_file_spec); SBSymbolContextList sb_sc_list; const ModuleSP module_sp(GetSP()); @@ -290,7 +291,7 @@ } size_t SBModule::GetNumSymbols() { - LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModule, GetNumSymbols); + LLDB_INSTRUMENT_METHOD_NO_ARGS(size_t, SBModule, GetNumSymbols); ModuleSP module_sp(GetSP()); if (Symtab *symtab = GetUnifiedSymbolTable(module_sp)) @@ -299,7 +300,8 @@ } SBSymbol SBModule::GetSymbolAtIndex(size_t idx) { - LLDB_RECORD_METHOD(lldb::SBSymbol, SBModule, GetSymbolAtIndex, (size_t), idx); + LLDB_INSTRUMENT_METHOD(lldb::SBSymbol, SBModule, GetSymbolAtIndex, (size_t), + idx); SBSymbol sb_symbol; ModuleSP module_sp(GetSP()); @@ -311,8 +313,8 @@ 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_METHOD(lldb::SBSymbol, SBModule, FindSymbol, + (const char *, lldb::SymbolType), name, symbol_type); SBSymbol sb_symbol; if (name && name[0]) { @@ -328,8 +330,8 @@ 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_METHOD(lldb::SBSymbolContextList, SBModule, FindSymbols, + (const char *, lldb::SymbolType), name, symbol_type); SBSymbolContextList sb_sc_list; if (name && name[0]) { @@ -356,7 +358,7 @@ } size_t SBModule::GetNumSections() { - LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModule, GetNumSections); + LLDB_INSTRUMENT_METHOD_NO_ARGS(size_t, SBModule, GetNumSections); ModuleSP module_sp(GetSP()); if (module_sp) { @@ -370,8 +372,8 @@ } SBSection SBModule::GetSectionAtIndex(size_t idx) { - LLDB_RECORD_METHOD(lldb::SBSection, SBModule, GetSectionAtIndex, (size_t), - idx); + LLDB_INSTRUMENT_METHOD(lldb::SBSection, SBModule, GetSectionAtIndex, (size_t), + idx); SBSection sb_section; ModuleSP module_sp(GetSP()); @@ -388,8 +390,8 @@ 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_METHOD(lldb::SBSymbolContextList, SBModule, FindFunctions, + (const char *, uint32_t), name, name_type_mask); lldb::SBSymbolContextList sb_sc_list; ModuleSP module_sp(GetSP()); @@ -407,9 +409,9 @@ 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_METHOD(lldb::SBValueList, SBModule, FindGlobalVariables, + (lldb::SBTarget &, const char *, uint32_t), target, + name, max_matches); SBValueList sb_value_list; ModuleSP module_sp(GetSP()); @@ -431,8 +433,8 @@ 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_METHOD(lldb::SBValue, SBModule, FindFirstGlobalVariable, + (lldb::SBTarget &, const char *), target, name); SBValueList sb_value_list(FindGlobalVariables(target, name, 1)); if (sb_value_list.IsValid() && sb_value_list.GetSize() > 0) @@ -441,8 +443,8 @@ } lldb::SBType SBModule::FindFirstType(const char *name_cstr) { - LLDB_RECORD_METHOD(lldb::SBType, SBModule, FindFirstType, (const char *), - name_cstr); + LLDB_INSTRUMENT_METHOD(lldb::SBType, SBModule, FindFirstType, (const char *), + name_cstr); SBType sb_type; ModuleSP module_sp(GetSP()); @@ -467,8 +469,8 @@ } lldb::SBType SBModule::GetBasicType(lldb::BasicType type) { - LLDB_RECORD_METHOD(lldb::SBType, SBModule, GetBasicType, (lldb::BasicType), - type); + LLDB_INSTRUMENT_METHOD(lldb::SBType, SBModule, GetBasicType, + (lldb::BasicType), type); ModuleSP module_sp(GetSP()); if (module_sp) { @@ -484,8 +486,8 @@ } lldb::SBTypeList SBModule::FindTypes(const char *type) { - LLDB_RECORD_METHOD(lldb::SBTypeList, SBModule, FindTypes, (const char *), - type); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeList, SBModule, FindTypes, (const char *), + type); SBTypeList retval; @@ -521,8 +523,8 @@ } lldb::SBType SBModule::GetTypeByID(lldb::user_id_t uid) { - LLDB_RECORD_METHOD(lldb::SBType, SBModule, GetTypeByID, (lldb::user_id_t), - uid); + LLDB_INSTRUMENT_METHOD(lldb::SBType, SBModule, GetTypeByID, (lldb::user_id_t), + uid); ModuleSP module_sp(GetSP()); if (module_sp) { @@ -536,8 +538,8 @@ } lldb::SBTypeList SBModule::GetTypes(uint32_t type_mask) { - LLDB_RECORD_METHOD(lldb::SBTypeList, SBModule, GetTypes, (uint32_t), - type_mask); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeList, SBModule, GetTypes, (uint32_t), + type_mask); SBTypeList sb_type_list; @@ -556,8 +558,8 @@ } SBSection SBModule::FindSection(const char *sect_name) { - LLDB_RECORD_METHOD(lldb::SBSection, SBModule, FindSection, (const char *), - sect_name); + LLDB_INSTRUMENT_METHOD(lldb::SBSection, SBModule, FindSection, (const char *), + sect_name); SBSection sb_section; @@ -578,7 +580,7 @@ } lldb::ByteOrder SBModule::GetByteOrder() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::ByteOrder, SBModule, GetByteOrder); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::ByteOrder, SBModule, GetByteOrder); ModuleSP module_sp(GetSP()); if (module_sp) @@ -587,7 +589,7 @@ } const char *SBModule::GetTriple() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBModule, GetTriple); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBModule, GetTriple); ModuleSP module_sp(GetSP()); if (module_sp) { @@ -602,7 +604,7 @@ } uint32_t SBModule::GetAddressByteSize() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBModule, GetAddressByteSize); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBModule, GetAddressByteSize); ModuleSP module_sp(GetSP()); if (module_sp) @@ -611,8 +613,8 @@ } 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_METHOD(uint32_t, SBModule, GetVersion, (uint32_t *, uint32_t), + versions, num_versions); llvm::VersionTuple version; if (ModuleSP module_sp = GetSP()) @@ -640,8 +642,8 @@ } lldb::SBFileSpec SBModule::GetSymbolFileSpec() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule, - GetSymbolFileSpec); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule, + GetSymbolFileSpec); lldb::SBFileSpec sb_file_spec; ModuleSP module_sp(GetSP()); @@ -653,8 +655,8 @@ } lldb::SBAddress SBModule::GetObjectFileHeaderAddress() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBModule, - GetObjectFileHeaderAddress); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBModule, + GetObjectFileHeaderAddress); lldb::SBAddress sb_addr; ModuleSP module_sp(GetSP()); @@ -667,8 +669,8 @@ } lldb::SBAddress SBModule::GetObjectFileEntryPointAddress() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBModule, - GetObjectFileEntryPointAddress); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBModule, + GetObjectFileEntryPointAddress); lldb::SBAddress sb_addr; ModuleSP module_sp(GetSP()); @@ -681,15 +683,15 @@ } uint32_t SBModule::GetNumberAllocatedModules() { - LLDB_RECORD_STATIC_METHOD_NO_ARGS(uint32_t, SBModule, - GetNumberAllocatedModules); + LLDB_INSTRUMENT_STATIC_METHOD_NO_ARGS(uint32_t, SBModule, + GetNumberAllocatedModules); return Module::GetNumberAllocatedModules(); } void SBModule::GarbageCollectAllocatedModules() { - LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBModule, - GarbageCollectAllocatedModules); + LLDB_INSTRUMENT_STATIC_METHOD_NO_ARGS(void, SBModule, + GarbageCollectAllocatedModules); const bool mandatory = false; ModuleList::RemoveOrphanSharedModules(mandatory); Index: lldb/source/API/SBModuleSpec.cpp =================================================================== --- lldb/source/API/SBModuleSpec.cpp +++ lldb/source/API/SBModuleSpec.cpp @@ -7,31 +7,31 @@ //===----------------------------------------------------------------------===// #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_CONSTRUCTOR_NO_ARGS(SBModuleSpec); } SBModuleSpec::SBModuleSpec(const SBModuleSpec &rhs) { - LLDB_RECORD_CONSTRUCTOR(SBModuleSpec, (const lldb::SBModuleSpec &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBModuleSpec, (const lldb::SBModuleSpec &), rhs); m_opaque_up = clone(rhs.m_opaque_up); } const SBModuleSpec &SBModuleSpec::operator=(const SBModuleSpec &rhs) { - LLDB_RECORD_METHOD(const lldb::SBModuleSpec &, - SBModuleSpec, operator=,(const lldb::SBModuleSpec &), rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBModuleSpec &, SBModuleSpec, operator=, + (const lldb::SBModuleSpec &), rhs); if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); @@ -41,76 +41,78 @@ SBModuleSpec::~SBModuleSpec() = default; bool SBModuleSpec::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModuleSpec, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBModuleSpec, IsValid); return this->operator bool(); } SBModuleSpec::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModuleSpec, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBModuleSpec, operator bool); return m_opaque_up->operator bool(); } void SBModuleSpec::Clear() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBModuleSpec, Clear); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBModuleSpec, Clear); m_opaque_up->Clear(); } SBFileSpec SBModuleSpec::GetFileSpec() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModuleSpec, GetFileSpec); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBFileSpec, SBModuleSpec, GetFileSpec); 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_METHOD(void, SBModuleSpec, SetFileSpec, + (const lldb::SBFileSpec &), sb_spec); m_opaque_up->GetFileSpec() = *sb_spec; } lldb::SBFileSpec SBModuleSpec::GetPlatformFileSpec() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModuleSpec, - GetPlatformFileSpec); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBFileSpec, SBModuleSpec, + GetPlatformFileSpec); 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_METHOD(void, SBModuleSpec, SetPlatformFileSpec, + (const lldb::SBFileSpec &), sb_spec); m_opaque_up->GetPlatformFileSpec() = *sb_spec; } lldb::SBFileSpec SBModuleSpec::GetSymbolFileSpec() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModuleSpec, GetSymbolFileSpec); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBFileSpec, SBModuleSpec, + GetSymbolFileSpec); 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_METHOD(void, SBModuleSpec, SetSymbolFileSpec, + (const lldb::SBFileSpec &), sb_spec); m_opaque_up->GetSymbolFileSpec() = *sb_spec; } const char *SBModuleSpec::GetObjectName() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBModuleSpec, GetObjectName); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBModuleSpec, GetObjectName); return m_opaque_up->GetObjectName().GetCString(); } void SBModuleSpec::SetObjectName(const char *name) { - LLDB_RECORD_METHOD(void, SBModuleSpec, SetObjectName, (const char *), name); + LLDB_INSTRUMENT_METHOD(void, SBModuleSpec, SetObjectName, (const char *), + name); m_opaque_up->GetObjectName().SetCString(name); } const char *SBModuleSpec::GetTriple() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBModuleSpec, GetTriple); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBModuleSpec, GetTriple); std::string triple(m_opaque_up->GetArchitecture().GetTriple().str()); // Unique the string so we don't run into ownership issues since the const @@ -121,7 +123,7 @@ } void SBModuleSpec::SetTriple(const char *triple) { - LLDB_RECORD_METHOD(void, SBModuleSpec, SetTriple, (const char *), triple); + LLDB_INSTRUMENT_METHOD(void, SBModuleSpec, SetTriple, (const char *), triple); m_opaque_up->GetArchitecture().SetTriple(triple); } @@ -131,7 +133,7 @@ } size_t SBModuleSpec::GetUUIDLength() { - LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModuleSpec, GetUUIDLength); + LLDB_INSTRUMENT_METHOD_NO_ARGS(size_t, SBModuleSpec, GetUUIDLength); return m_opaque_up->GetUUID().GetBytes().size(); } @@ -142,27 +144,26 @@ } bool SBModuleSpec::GetDescription(lldb::SBStream &description) { - LLDB_RECORD_METHOD(bool, SBModuleSpec, GetDescription, (lldb::SBStream &), - description); + LLDB_INSTRUMENT_METHOD(bool, SBModuleSpec, GetDescription, (lldb::SBStream &), + description); m_opaque_up->Dump(description.ref()); return true; } SBModuleSpecList::SBModuleSpecList() : m_opaque_up(new ModuleSpecList()) { - LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBModuleSpecList); + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBModuleSpecList); } SBModuleSpecList::SBModuleSpecList(const SBModuleSpecList &rhs) : m_opaque_up(new ModuleSpecList(*rhs.m_opaque_up)) { - LLDB_RECORD_CONSTRUCTOR(SBModuleSpecList, (const lldb::SBModuleSpecList &), - rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBModuleSpecList, + (const lldb::SBModuleSpecList &), rhs); } SBModuleSpecList &SBModuleSpecList::operator=(const SBModuleSpecList &rhs) { - LLDB_RECORD_METHOD( - lldb::SBModuleSpecList &, - SBModuleSpecList, operator=,(const lldb::SBModuleSpecList &), rhs); + LLDB_INSTRUMENT_METHOD(lldb::SBModuleSpecList &, SBModuleSpecList, operator=, + (const lldb::SBModuleSpecList &), rhs); if (this != &rhs) *m_opaque_up = *rhs.m_opaque_up; @@ -172,8 +173,8 @@ SBModuleSpecList::~SBModuleSpecList() = default; SBModuleSpecList SBModuleSpecList::GetModuleSpecifications(const char *path) { - LLDB_RECORD_STATIC_METHOD(lldb::SBModuleSpecList, SBModuleSpecList, - GetModuleSpecifications, (const char *), path); + LLDB_INSTRUMENT_STATIC_METHOD(lldb::SBModuleSpecList, SBModuleSpecList, + GetModuleSpecifications, (const char *), path); SBModuleSpecList specs; FileSpec file_spec(path); @@ -184,28 +185,28 @@ } void SBModuleSpecList::Append(const SBModuleSpec &spec) { - LLDB_RECORD_METHOD(void, SBModuleSpecList, Append, - (const lldb::SBModuleSpec &), spec); + LLDB_INSTRUMENT_METHOD(void, SBModuleSpecList, Append, + (const lldb::SBModuleSpec &), spec); m_opaque_up->Append(*spec.m_opaque_up); } void SBModuleSpecList::Append(const SBModuleSpecList &spec_list) { - LLDB_RECORD_METHOD(void, SBModuleSpecList, Append, - (const lldb::SBModuleSpecList &), spec_list); + LLDB_INSTRUMENT_METHOD(void, SBModuleSpecList, Append, + (const lldb::SBModuleSpecList &), 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_METHOD_NO_ARGS(size_t, SBModuleSpecList, GetSize); return m_opaque_up->GetSize(); } SBModuleSpec SBModuleSpecList::GetSpecAtIndex(size_t i) { - LLDB_RECORD_METHOD(lldb::SBModuleSpec, SBModuleSpecList, GetSpecAtIndex, - (size_t), i); + LLDB_INSTRUMENT_METHOD(lldb::SBModuleSpec, SBModuleSpecList, GetSpecAtIndex, + (size_t), i); SBModuleSpec sb_module_spec; m_opaque_up->GetModuleSpecAtIndex(i, *sb_module_spec.m_opaque_up); @@ -214,9 +215,9 @@ SBModuleSpec SBModuleSpecList::FindFirstMatchingSpec(const SBModuleSpec &match_spec) { - LLDB_RECORD_METHOD(lldb::SBModuleSpec, SBModuleSpecList, - FindFirstMatchingSpec, (const lldb::SBModuleSpec &), - match_spec); + LLDB_INSTRUMENT_METHOD(lldb::SBModuleSpec, SBModuleSpecList, + FindFirstMatchingSpec, (const lldb::SBModuleSpec &), + match_spec); SBModuleSpec sb_module_spec; m_opaque_up->FindMatchingModuleSpec(*match_spec.m_opaque_up, @@ -226,9 +227,9 @@ SBModuleSpecList SBModuleSpecList::FindMatchingSpecs(const SBModuleSpec &match_spec) { - LLDB_RECORD_METHOD(lldb::SBModuleSpecList, SBModuleSpecList, - FindMatchingSpecs, (const lldb::SBModuleSpec &), - match_spec); + LLDB_INSTRUMENT_METHOD(lldb::SBModuleSpecList, SBModuleSpecList, + FindMatchingSpecs, (const lldb::SBModuleSpec &), + match_spec); SBModuleSpecList specs; m_opaque_up->FindMatchingModuleSpecs(*match_spec.m_opaque_up, @@ -237,8 +238,8 @@ } bool SBModuleSpecList::GetDescription(lldb::SBStream &description) { - LLDB_RECORD_METHOD(bool, SBModuleSpecList, GetDescription, (lldb::SBStream &), - description); + LLDB_INSTRUMENT_METHOD(bool, SBModuleSpecList, GetDescription, + (lldb::SBStream &), description); m_opaque_up->Dump(description.ref()); return true; Index: lldb/source/API/SBPlatform.cpp =================================================================== --- lldb/source/API/SBPlatform.cpp +++ 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,14 @@ // SBPlatformConnectOptions SBPlatformConnectOptions::SBPlatformConnectOptions(const char *url) : m_opaque_ptr(new PlatformConnectOptions(url)) { - LLDB_RECORD_CONSTRUCTOR(SBPlatformConnectOptions, (const char *), url); + LLDB_INSTRUMENT_CONSTRUCTOR(SBPlatformConnectOptions, (const char *), url); } SBPlatformConnectOptions::SBPlatformConnectOptions( const SBPlatformConnectOptions &rhs) : m_opaque_ptr(new PlatformConnectOptions()) { - LLDB_RECORD_CONSTRUCTOR(SBPlatformConnectOptions, - (const lldb::SBPlatformConnectOptions &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBPlatformConnectOptions, + (const lldb::SBPlatformConnectOptions &), rhs); *m_opaque_ptr = *rhs.m_opaque_ptr; } @@ -91,18 +91,17 @@ SBPlatformConnectOptions & SBPlatformConnectOptions::operator=(const SBPlatformConnectOptions &rhs) { - LLDB_RECORD_METHOD( - SBPlatformConnectOptions &, - SBPlatformConnectOptions, operator=,( - const lldb::SBPlatformConnectOptions &), - rhs); + LLDB_INSTRUMENT_METHOD(SBPlatformConnectOptions &, + SBPlatformConnectOptions, operator=, + (const lldb::SBPlatformConnectOptions &), 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_METHOD_NO_ARGS(const char *, SBPlatformConnectOptions, + GetURL); if (m_opaque_ptr->m_url.empty()) return nullptr; @@ -110,8 +109,8 @@ } void SBPlatformConnectOptions::SetURL(const char *url) { - LLDB_RECORD_METHOD(void, SBPlatformConnectOptions, SetURL, (const char *), - url); + LLDB_INSTRUMENT_METHOD(void, SBPlatformConnectOptions, SetURL, (const char *), + url); if (url && url[0]) m_opaque_ptr->m_url = url; @@ -120,7 +119,8 @@ } bool SBPlatformConnectOptions::GetRsyncEnabled() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBPlatformConnectOptions, GetRsyncEnabled); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBPlatformConnectOptions, + GetRsyncEnabled); return m_opaque_ptr->m_rsync_enabled; } @@ -128,9 +128,9 @@ 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_METHOD(void, SBPlatformConnectOptions, EnableRsync, + (const char *, const char *, bool), options, + remote_path_prefix, omit_hostname_from_remote_path); m_opaque_ptr->m_rsync_enabled = true; m_opaque_ptr->m_rsync_omit_hostname_from_remote_path = @@ -147,21 +147,21 @@ } void SBPlatformConnectOptions::DisableRsync() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatformConnectOptions, DisableRsync); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBPlatformConnectOptions, DisableRsync); m_opaque_ptr->m_rsync_enabled = false; } const char *SBPlatformConnectOptions::GetLocalCacheDirectory() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformConnectOptions, - GetLocalCacheDirectory); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBPlatformConnectOptions, + GetLocalCacheDirectory); return m_opaque_ptr->m_local_cache_directory.GetCString(); } void SBPlatformConnectOptions::SetLocalCacheDirectory(const char *path) { - LLDB_RECORD_METHOD(void, SBPlatformConnectOptions, SetLocalCacheDirectory, - (const char *), path); + LLDB_INSTRUMENT_METHOD(void, SBPlatformConnectOptions, SetLocalCacheDirectory, + (const char *), path); if (path && path[0]) m_opaque_ptr->m_local_cache_directory.SetCString(path); @@ -173,21 +173,22 @@ 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_CONSTRUCTOR(SBPlatformShellCommand, + (const char *, const char *), 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_CONSTRUCTOR(SBPlatformShellCommand, (const char *), + shell_command); } SBPlatformShellCommand::SBPlatformShellCommand( const SBPlatformShellCommand &rhs) : m_opaque_ptr(new PlatformShellCommand()) { - LLDB_RECORD_CONSTRUCTOR(SBPlatformShellCommand, - (const lldb::SBPlatformShellCommand &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBPlatformShellCommand, + (const lldb::SBPlatformShellCommand &), rhs); *m_opaque_ptr = *rhs.m_opaque_ptr; } @@ -195,10 +196,9 @@ SBPlatformShellCommand & SBPlatformShellCommand::operator=(const SBPlatformShellCommand &rhs) { - LLDB_RECORD_METHOD( - SBPlatformShellCommand &, - SBPlatformShellCommand, operator=,(const lldb::SBPlatformShellCommand &), - rhs); + LLDB_INSTRUMENT_METHOD(SBPlatformShellCommand &, + SBPlatformShellCommand, operator=, + (const lldb::SBPlatformShellCommand &), rhs); *m_opaque_ptr = *rhs.m_opaque_ptr; return *this; @@ -207,7 +207,7 @@ SBPlatformShellCommand::~SBPlatformShellCommand() { delete m_opaque_ptr; } void SBPlatformShellCommand::Clear() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatformShellCommand, Clear); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBPlatformShellCommand, Clear); m_opaque_ptr->m_output = std::string(); m_opaque_ptr->m_status = 0; @@ -215,7 +215,8 @@ } const char *SBPlatformShellCommand::GetShell() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand, GetShell); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBPlatformShellCommand, + GetShell); if (m_opaque_ptr->m_shell.empty()) return nullptr; @@ -223,8 +224,8 @@ } void SBPlatformShellCommand::SetShell(const char *shell_interpreter) { - LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetShell, (const char *), - shell_interpreter); + LLDB_INSTRUMENT_METHOD(void, SBPlatformShellCommand, SetShell, (const char *), + shell_interpreter); if (shell_interpreter && shell_interpreter[0]) m_opaque_ptr->m_shell = shell_interpreter; @@ -233,7 +234,8 @@ } const char *SBPlatformShellCommand::GetCommand() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand, GetCommand); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBPlatformShellCommand, + GetCommand); if (m_opaque_ptr->m_command.empty()) return nullptr; @@ -241,8 +243,8 @@ } void SBPlatformShellCommand::SetCommand(const char *shell_command) { - LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetCommand, (const char *), - shell_command); + LLDB_INSTRUMENT_METHOD(void, SBPlatformShellCommand, SetCommand, + (const char *), shell_command); if (shell_command && shell_command[0]) m_opaque_ptr->m_command = shell_command; @@ -251,8 +253,8 @@ } const char *SBPlatformShellCommand::GetWorkingDirectory() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand, - GetWorkingDirectory); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBPlatformShellCommand, + GetWorkingDirectory); if (m_opaque_ptr->m_working_dir.empty()) return nullptr; @@ -260,8 +262,8 @@ } void SBPlatformShellCommand::SetWorkingDirectory(const char *path) { - LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetWorkingDirectory, - (const char *), path); + LLDB_INSTRUMENT_METHOD(void, SBPlatformShellCommand, SetWorkingDirectory, + (const char *), path); if (path && path[0]) m_opaque_ptr->m_working_dir = path; @@ -270,8 +272,8 @@ } uint32_t SBPlatformShellCommand::GetTimeoutSeconds() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatformShellCommand, - GetTimeoutSeconds); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBPlatformShellCommand, + GetTimeoutSeconds); if (m_opaque_ptr->m_timeout) return m_opaque_ptr->m_timeout->count(); @@ -279,8 +281,8 @@ } void SBPlatformShellCommand::SetTimeoutSeconds(uint32_t sec) { - LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetTimeoutSeconds, - (uint32_t), sec); + LLDB_INSTRUMENT_METHOD(void, SBPlatformShellCommand, SetTimeoutSeconds, + (uint32_t), sec); if (sec == UINT32_MAX) m_opaque_ptr->m_timeout = llvm::None; @@ -289,19 +291,20 @@ } int SBPlatformShellCommand::GetSignal() { - LLDB_RECORD_METHOD_NO_ARGS(int, SBPlatformShellCommand, GetSignal); + LLDB_INSTRUMENT_METHOD_NO_ARGS(int, SBPlatformShellCommand, GetSignal); return m_opaque_ptr->m_signo; } int SBPlatformShellCommand::GetStatus() { - LLDB_RECORD_METHOD_NO_ARGS(int, SBPlatformShellCommand, GetStatus); + LLDB_INSTRUMENT_METHOD_NO_ARGS(int, SBPlatformShellCommand, GetStatus); return m_opaque_ptr->m_status; } const char *SBPlatformShellCommand::GetOutput() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand, GetOutput); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBPlatformShellCommand, + GetOutput); if (m_opaque_ptr->m_output.empty()) return nullptr; @@ -309,10 +312,10 @@ } // SBPlatform -SBPlatform::SBPlatform() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBPlatform); } +SBPlatform::SBPlatform() { LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBPlatform); } SBPlatform::SBPlatform(const char *platform_name) { - LLDB_RECORD_CONSTRUCTOR(SBPlatform, (const char *), platform_name); + LLDB_INSTRUMENT_CONSTRUCTOR(SBPlatform, (const char *), platform_name); Status error; if (platform_name && platform_name[0]) @@ -320,14 +323,14 @@ } SBPlatform::SBPlatform(const SBPlatform &rhs) { - LLDB_RECORD_CONSTRUCTOR(SBPlatform, (const lldb::SBPlatform &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBPlatform, (const lldb::SBPlatform &), 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_METHOD(SBPlatform &, SBPlatform, operator=, + (const lldb::SBPlatform &), rhs); m_opaque_sp = rhs.m_opaque_sp; return *this; @@ -336,8 +339,8 @@ SBPlatform::~SBPlatform() = default; SBPlatform SBPlatform::GetHostPlatform() { - LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBPlatform, SBPlatform, - GetHostPlatform); + LLDB_INSTRUMENT_STATIC_METHOD_NO_ARGS(lldb::SBPlatform, SBPlatform, + GetHostPlatform); SBPlatform host_platform; host_platform.m_opaque_sp = Platform::GetHostPlatform(); @@ -345,23 +348,23 @@ } bool SBPlatform::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBPlatform, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBPlatform, IsValid); return this->operator bool(); } SBPlatform::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBPlatform, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBPlatform, operator bool); return m_opaque_sp.get() != nullptr; } void SBPlatform::Clear() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatform, Clear); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBPlatform, Clear); m_opaque_sp.reset(); } const char *SBPlatform::GetName() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetName); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBPlatform, GetName); PlatformSP platform_sp(GetSP()); if (platform_sp) @@ -376,7 +379,7 @@ } const char *SBPlatform::GetWorkingDirectory() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetWorkingDirectory); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBPlatform, GetWorkingDirectory); PlatformSP platform_sp(GetSP()); if (platform_sp) @@ -385,8 +388,8 @@ } bool SBPlatform::SetWorkingDirectory(const char *path) { - LLDB_RECORD_METHOD(bool, SBPlatform, SetWorkingDirectory, (const char *), - path); + LLDB_INSTRUMENT_METHOD(bool, SBPlatform, SetWorkingDirectory, (const char *), + path); PlatformSP platform_sp(GetSP()); if (platform_sp) { @@ -400,8 +403,8 @@ } SBError SBPlatform::ConnectRemote(SBPlatformConnectOptions &connect_options) { - LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, ConnectRemote, - (lldb::SBPlatformConnectOptions &), connect_options); + LLDB_INSTRUMENT_METHOD(lldb::SBError, SBPlatform, ConnectRemote, + (lldb::SBPlatformConnectOptions &), connect_options); SBError sb_error; PlatformSP platform_sp(GetSP()); @@ -416,7 +419,7 @@ } void SBPlatform::DisconnectRemote() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatform, DisconnectRemote); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBPlatform, DisconnectRemote); PlatformSP platform_sp(GetSP()); if (platform_sp) @@ -424,7 +427,7 @@ } bool SBPlatform::IsConnected() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBPlatform, IsConnected); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBPlatform, IsConnected); PlatformSP platform_sp(GetSP()); if (platform_sp) @@ -433,7 +436,7 @@ } const char *SBPlatform::GetTriple() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetTriple); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBPlatform, GetTriple); PlatformSP platform_sp(GetSP()); if (platform_sp) { @@ -448,7 +451,7 @@ } const char *SBPlatform::GetOSBuild() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetOSBuild); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBPlatform, GetOSBuild); PlatformSP platform_sp(GetSP()); if (platform_sp) { @@ -463,7 +466,7 @@ } const char *SBPlatform::GetOSDescription() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetOSDescription); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBPlatform, GetOSDescription); PlatformSP platform_sp(GetSP()); if (platform_sp) { @@ -478,7 +481,7 @@ } const char *SBPlatform::GetHostname() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetHostname); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBPlatform, GetHostname); PlatformSP platform_sp(GetSP()); if (platform_sp) @@ -487,7 +490,7 @@ } uint32_t SBPlatform::GetOSMajorVersion() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatform, GetOSMajorVersion); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBPlatform, GetOSMajorVersion); llvm::VersionTuple version; if (PlatformSP platform_sp = GetSP()) @@ -496,7 +499,7 @@ } uint32_t SBPlatform::GetOSMinorVersion() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatform, GetOSMinorVersion); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBPlatform, GetOSMinorVersion); llvm::VersionTuple version; if (PlatformSP platform_sp = GetSP()) @@ -505,7 +508,7 @@ } uint32_t SBPlatform::GetOSUpdateVersion() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatform, GetOSUpdateVersion); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBPlatform, GetOSUpdateVersion); llvm::VersionTuple version; if (PlatformSP platform_sp = GetSP()) @@ -514,14 +517,14 @@ } void SBPlatform::SetSDKRoot(const char *sysroot) { - LLDB_RECORD_METHOD(void, SBPlatform, SetSDKRoot, (const char *), sysroot); + LLDB_INSTRUMENT_METHOD(void, SBPlatform, SetSDKRoot, (const char *), 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_METHOD(lldb::SBError, SBPlatform, Get, + (lldb::SBFileSpec &, lldb::SBFileSpec &), src, dst); SBError sb_error; PlatformSP platform_sp(GetSP()); @@ -534,8 +537,8 @@ } SBError SBPlatform::Put(SBFileSpec &src, SBFileSpec &dst) { - LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Put, - (lldb::SBFileSpec &, lldb::SBFileSpec &), src, dst); + LLDB_INSTRUMENT_METHOD(lldb::SBError, SBPlatform, Put, + (lldb::SBFileSpec &, lldb::SBFileSpec &), src, dst); return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) { if (src.Exists()) { uint32_t permissions = FileSystem::Instance().GetPermissions(src.ref()); @@ -557,8 +560,8 @@ } SBError SBPlatform::Install(SBFileSpec &src, SBFileSpec &dst) { - LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Install, - (lldb::SBFileSpec &, lldb::SBFileSpec &), src, dst); + LLDB_INSTRUMENT_METHOD(lldb::SBError, SBPlatform, Install, + (lldb::SBFileSpec &, lldb::SBFileSpec &), src, dst); return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) { if (src.Exists()) return platform_sp->Install(src.ref(), dst.ref()); @@ -571,8 +574,8 @@ } SBError SBPlatform::Run(SBPlatformShellCommand &shell_command) { - LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Run, - (lldb::SBPlatformShellCommand &), shell_command); + LLDB_INSTRUMENT_METHOD(lldb::SBError, SBPlatform, Run, + (lldb::SBPlatformShellCommand &), shell_command); return ExecuteConnected( [&](const lldb::PlatformSP &platform_sp) { const char *command = shell_command.GetCommand(); @@ -595,8 +598,8 @@ } SBError SBPlatform::Launch(SBLaunchInfo &launch_info) { - LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Launch, (lldb::SBLaunchInfo &), - launch_info); + LLDB_INSTRUMENT_METHOD(lldb::SBError, SBPlatform, Launch, + (lldb::SBLaunchInfo &), launch_info); return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) { ProcessLaunchInfo info = launch_info.ref(); Status error = platform_sp->LaunchProcess(info); @@ -606,7 +609,8 @@ } SBError SBPlatform::Kill(const lldb::pid_t pid) { - LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Kill, (const lldb::pid_t), pid); + LLDB_INSTRUMENT_METHOD(lldb::SBError, SBPlatform, Kill, (const lldb::pid_t), + pid); return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) { return platform_sp->KillProcess(pid); }); @@ -628,8 +632,8 @@ } 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_METHOD(lldb::SBError, SBPlatform, MakeDirectory, + (const char *, uint32_t), path, file_permissions); SBError sb_error; PlatformSP platform_sp(GetSP()); @@ -643,8 +647,8 @@ } uint32_t SBPlatform::GetFilePermissions(const char *path) { - LLDB_RECORD_METHOD(uint32_t, SBPlatform, GetFilePermissions, (const char *), - path); + LLDB_INSTRUMENT_METHOD(uint32_t, SBPlatform, GetFilePermissions, + (const char *), path); PlatformSP platform_sp(GetSP()); if (platform_sp) { @@ -657,8 +661,8 @@ 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_METHOD(lldb::SBError, SBPlatform, SetFilePermissions, + (const char *, uint32_t), path, file_permissions); SBError sb_error; PlatformSP platform_sp(GetSP()); @@ -672,8 +676,8 @@ } SBUnixSignals SBPlatform::GetUnixSignals() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBUnixSignals, SBPlatform, - GetUnixSignals); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::SBUnixSignals, SBPlatform, + GetUnixSignals); if (auto platform_sp = GetSP()) return SBUnixSignals{platform_sp}; @@ -682,7 +686,8 @@ } SBEnvironment SBPlatform::GetEnvironment() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBEnvironment, SBPlatform, GetEnvironment); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBEnvironment, SBPlatform, + GetEnvironment); PlatformSP platform_sp(GetSP()); if (platform_sp) { Index: lldb/source/API/SBProcess.cpp =================================================================== --- lldb/source/API/SBProcess.cpp +++ 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 @@ -49,22 +49,22 @@ using namespace lldb; using namespace lldb_private; -SBProcess::SBProcess() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBProcess); } +SBProcess::SBProcess() { LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBProcess); } // SBProcess constructor SBProcess::SBProcess(const SBProcess &rhs) : m_opaque_wp(rhs.m_opaque_wp) { - LLDB_RECORD_CONSTRUCTOR(SBProcess, (const lldb::SBProcess &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBProcess, (const lldb::SBProcess &), rhs); } SBProcess::SBProcess(const lldb::ProcessSP &process_sp) : m_opaque_wp(process_sp) { - LLDB_RECORD_CONSTRUCTOR(SBProcess, (const lldb::ProcessSP &), process_sp); + LLDB_INSTRUMENT_CONSTRUCTOR(SBProcess, (const lldb::ProcessSP &), process_sp); } const SBProcess &SBProcess::operator=(const SBProcess &rhs) { - LLDB_RECORD_METHOD(const lldb::SBProcess &, - SBProcess, operator=,(const lldb::SBProcess &), rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBProcess &, SBProcess, operator=, + (const lldb::SBProcess &), rhs); if (this != &rhs) m_opaque_wp = rhs.m_opaque_wp; @@ -75,14 +75,14 @@ SBProcess::~SBProcess() = default; const char *SBProcess::GetBroadcasterClassName() { - LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBProcess, - GetBroadcasterClassName); + LLDB_INSTRUMENT_STATIC_METHOD_NO_ARGS(const char *, SBProcess, + GetBroadcasterClassName); return Process::GetStaticBroadcasterClass().AsCString(); } const char *SBProcess::GetPluginName() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetPluginName); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBProcess, GetPluginName); ProcessSP process_sp(GetSP()); if (process_sp) { @@ -92,7 +92,7 @@ } const char *SBProcess::GetShortPluginName() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetShortPluginName); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBProcess, GetShortPluginName); ProcessSP process_sp(GetSP()); if (process_sp) { @@ -106,17 +106,17 @@ 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_METHOD_NO_ARGS(void, SBProcess, Clear); m_opaque_wp.reset(); } bool SBProcess::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcess, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBProcess, IsValid); return this->operator bool(); } SBProcess::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcess, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBProcess, operator bool); ProcessSP process_sp(m_opaque_wp.lock()); return ((bool)process_sp && process_sp->IsValid()); @@ -128,12 +128,12 @@ const char *working_directory, uint32_t launch_flags, bool stop_at_entry, lldb::SBError &error) { - LLDB_RECORD_METHOD(bool, SBProcess, RemoteLaunch, - (const char **, const char **, const char *, const char *, - const char *, const char *, uint32_t, bool, - lldb::SBError &), - argv, envp, stdin_path, stdout_path, stderr_path, - working_directory, launch_flags, stop_at_entry, error); + LLDB_INSTRUMENT_METHOD(bool, SBProcess, RemoteLaunch, + (const char **, const char **, const char *, + const char *, const char *, const char *, uint32_t, + bool, lldb::SBError &), + argv, envp, stdin_path, stdout_path, stderr_path, + working_directory, launch_flags, stop_at_entry, error); ProcessSP process_sp(GetSP()); if (process_sp) { @@ -165,8 +165,8 @@ 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_METHOD(bool, SBProcess, RemoteAttachToProcessWithID, + (lldb::pid_t, lldb::SBError &), pid, error); ProcessSP process_sp(GetSP()); if (process_sp) { @@ -188,7 +188,7 @@ } uint32_t SBProcess::GetNumThreads() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumThreads); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumThreads); uint32_t num_threads = 0; ProcessSP process_sp(GetSP()); @@ -205,8 +205,8 @@ } SBThread SBProcess::GetSelectedThread() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBProcess, - GetSelectedThread); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::SBThread, SBProcess, + GetSelectedThread); SBThread sb_thread; ThreadSP thread_sp; @@ -223,8 +223,8 @@ 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_METHOD(lldb::SBThread, SBProcess, CreateOSPluginThread, + (lldb::tid_t, lldb::addr_t), tid, context); SBThread sb_thread; ThreadSP thread_sp; @@ -240,7 +240,7 @@ } SBTarget SBProcess::GetTarget() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBTarget, SBProcess, GetTarget); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::SBTarget, SBProcess, GetTarget); SBTarget sb_target; TargetSP target_sp; @@ -254,8 +254,8 @@ } 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_METHOD(size_t, SBProcess, PutSTDIN, (const char *, size_t), + src, src_len); size_t ret_val = 0; ProcessSP process_sp(GetSP()); @@ -268,8 +268,8 @@ } 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_METHOD_CONST(size_t, SBProcess, GetSTDOUT, (char *, size_t), + dst, "", dst_len); size_t bytes_read = 0; ProcessSP process_sp(GetSP()); @@ -282,8 +282,8 @@ } 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_METHOD_CONST(size_t, SBProcess, GetSTDERR, (char *, size_t), + dst, "", dst_len); size_t bytes_read = 0; ProcessSP process_sp(GetSP()); @@ -296,8 +296,8 @@ } 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_METHOD_CONST(size_t, SBProcess, GetAsyncProfileData, + (char *, size_t), dst, "", dst_len); size_t bytes_read = 0; ProcessSP process_sp(GetSP()); @@ -310,23 +310,23 @@ } void SBProcess::ReportEventState(const SBEvent &event, SBFile out) const { - LLDB_RECORD_METHOD_CONST(void, SBProcess, ReportEventState, - (const SBEvent &, SBFile), event, out); + LLDB_INSTRUMENT_METHOD_CONST(void, SBProcess, ReportEventState, + (const SBEvent &, SBFile), 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_METHOD_CONST(void, SBProcess, ReportEventState, + (const lldb::SBEvent &, FILE *), event, out); FileSP outfile = std::make_shared(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_METHOD_CONST(void, SBProcess, ReportEventState, + (const SBEvent &, FileSP), event, out); if (!out || !out->IsValid()) return; @@ -342,9 +342,9 @@ void SBProcess::AppendEventStateReport(const SBEvent &event, SBCommandReturnObject &result) { - LLDB_RECORD_METHOD(void, SBProcess, AppendEventStateReport, - (const lldb::SBEvent &, lldb::SBCommandReturnObject &), - event, result); + LLDB_INSTRUMENT_METHOD(void, SBProcess, AppendEventStateReport, + (const lldb::SBEvent &, lldb::SBCommandReturnObject &), + event, result); ProcessSP process_sp(GetSP()); if (process_sp) { @@ -358,8 +358,8 @@ } bool SBProcess::SetSelectedThread(const SBThread &thread) { - LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThread, - (const lldb::SBThread &), thread); + LLDB_INSTRUMENT_METHOD(bool, SBProcess, SetSelectedThread, + (const lldb::SBThread &), thread); ProcessSP process_sp(GetSP()); if (process_sp) { @@ -372,9 +372,8 @@ } bool SBProcess::SetSelectedThreadByID(lldb::tid_t tid) { - LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByID, (lldb::tid_t), - tid); - + LLDB_INSTRUMENT_METHOD(bool, SBProcess, SetSelectedThreadByID, (lldb::tid_t), + tid); bool ret_val = false; ProcessSP process_sp(GetSP()); @@ -388,8 +387,8 @@ } bool SBProcess::SetSelectedThreadByIndexID(uint32_t index_id) { - LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByIndexID, (uint32_t), - index_id); + LLDB_INSTRUMENT_METHOD(bool, SBProcess, SetSelectedThreadByIndexID, + (uint32_t), index_id); bool ret_val = false; ProcessSP process_sp(GetSP()); @@ -404,8 +403,8 @@ } SBThread SBProcess::GetThreadAtIndex(size_t index) { - LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadAtIndex, (size_t), - index); + LLDB_INSTRUMENT_METHOD(lldb::SBThread, SBProcess, GetThreadAtIndex, (size_t), + index); SBThread sb_thread; ThreadSP thread_sp; @@ -423,7 +422,7 @@ } uint32_t SBProcess::GetNumQueues() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumQueues); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumQueues); uint32_t num_queues = 0; ProcessSP process_sp(GetSP()); @@ -440,8 +439,8 @@ } SBQueue SBProcess::GetQueueAtIndex(size_t index) { - LLDB_RECORD_METHOD(lldb::SBQueue, SBProcess, GetQueueAtIndex, (size_t), - index); + LLDB_INSTRUMENT_METHOD(lldb::SBQueue, SBProcess, GetQueueAtIndex, (size_t), + index); SBQueue sb_queue; QueueSP queue_sp; @@ -460,8 +459,8 @@ } uint32_t SBProcess::GetStopID(bool include_expression_stops) { - LLDB_RECORD_METHOD(uint32_t, SBProcess, GetStopID, (bool), - include_expression_stops); + LLDB_INSTRUMENT_METHOD(uint32_t, SBProcess, GetStopID, (bool), + include_expression_stops); ProcessSP process_sp(GetSP()); if (process_sp) { @@ -476,8 +475,8 @@ } SBEvent SBProcess::GetStopEventForStopID(uint32_t stop_id) { - LLDB_RECORD_METHOD(lldb::SBEvent, SBProcess, GetStopEventForStopID, - (uint32_t), stop_id); + LLDB_INSTRUMENT_METHOD(lldb::SBEvent, SBProcess, GetStopEventForStopID, + (uint32_t), stop_id); SBEvent sb_event; EventSP event_sp; @@ -493,7 +492,7 @@ } StateType SBProcess::GetState() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::StateType, SBProcess, GetState); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::StateType, SBProcess, GetState); StateType ret_val = eStateInvalid; ProcessSP process_sp(GetSP()); @@ -507,7 +506,7 @@ } int SBProcess::GetExitStatus() { - LLDB_RECORD_METHOD_NO_ARGS(int, SBProcess, GetExitStatus); + LLDB_INSTRUMENT_METHOD_NO_ARGS(int, SBProcess, GetExitStatus); int exit_status = 0; ProcessSP process_sp(GetSP()); @@ -521,7 +520,7 @@ } const char *SBProcess::GetExitDescription() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetExitDescription); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBProcess, GetExitDescription); const char *exit_desc = nullptr; ProcessSP process_sp(GetSP()); @@ -534,7 +533,7 @@ } lldb::pid_t SBProcess::GetProcessID() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBProcess, GetProcessID); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::pid_t, SBProcess, GetProcessID); lldb::pid_t ret_val = LLDB_INVALID_PROCESS_ID; ProcessSP process_sp(GetSP()); @@ -545,7 +544,7 @@ } uint32_t SBProcess::GetUniqueID() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetUniqueID); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBProcess, GetUniqueID); uint32_t ret_val = 0; ProcessSP process_sp(GetSP()); @@ -555,7 +554,8 @@ } ByteOrder SBProcess::GetByteOrder() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ByteOrder, SBProcess, GetByteOrder); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::ByteOrder, SBProcess, + GetByteOrder); ByteOrder byteOrder = eByteOrderInvalid; ProcessSP process_sp(GetSP()); @@ -567,7 +567,7 @@ } uint32_t SBProcess::GetAddressByteSize() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBProcess, GetAddressByteSize); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(uint32_t, SBProcess, GetAddressByteSize); uint32_t size = 0; ProcessSP process_sp(GetSP()); @@ -579,7 +579,7 @@ } SBError SBProcess::Continue() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Continue); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBError, SBProcess, Continue); SBError sb_error; ProcessSP process_sp(GetSP()); @@ -599,7 +599,7 @@ } SBError SBProcess::Destroy() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Destroy); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBError, SBProcess, Destroy); SBError sb_error; ProcessSP process_sp(GetSP()); @@ -614,7 +614,7 @@ } SBError SBProcess::Stop() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Stop); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBError, SBProcess, Stop); SBError sb_error; ProcessSP process_sp(GetSP()); @@ -629,7 +629,7 @@ } SBError SBProcess::Kill() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Kill); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBError, SBProcess, Kill); SBError sb_error; ProcessSP process_sp(GetSP()); @@ -644,7 +644,7 @@ } SBError SBProcess::Detach() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Detach); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBError, SBProcess, Detach); // FIXME: This should come from a process default. bool keep_stopped = false; @@ -652,7 +652,8 @@ } SBError SBProcess::Detach(bool keep_stopped) { - LLDB_RECORD_METHOD(lldb::SBError, SBProcess, Detach, (bool), keep_stopped); + LLDB_INSTRUMENT_METHOD(lldb::SBError, SBProcess, Detach, (bool), + keep_stopped); SBError sb_error; ProcessSP process_sp(GetSP()); @@ -667,7 +668,7 @@ } SBError SBProcess::Signal(int signo) { - LLDB_RECORD_METHOD(lldb::SBError, SBProcess, Signal, (int), signo); + LLDB_INSTRUMENT_METHOD(lldb::SBError, SBProcess, Signal, (int), signo); SBError sb_error; ProcessSP process_sp(GetSP()); @@ -682,7 +683,8 @@ } SBUnixSignals SBProcess::GetUnixSignals() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBUnixSignals, SBProcess, GetUnixSignals); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBUnixSignals, SBProcess, + GetUnixSignals); if (auto process_sp = GetSP()) return SBUnixSignals{process_sp}; @@ -691,7 +693,7 @@ } void SBProcess::SendAsyncInterrupt() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBProcess, SendAsyncInterrupt); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBProcess, SendAsyncInterrupt); ProcessSP process_sp(GetSP()); if (process_sp) { @@ -700,8 +702,8 @@ } SBThread SBProcess::GetThreadByID(tid_t tid) { - LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadByID, (lldb::tid_t), - tid); + LLDB_INSTRUMENT_METHOD(lldb::SBThread, SBProcess, GetThreadByID, + (lldb::tid_t), tid); SBThread sb_thread; ThreadSP thread_sp; @@ -719,8 +721,8 @@ } SBThread SBProcess::GetThreadByIndexID(uint32_t index_id) { - LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadByIndexID, (uint32_t), - index_id); + LLDB_INSTRUMENT_METHOD(lldb::SBThread, SBProcess, GetThreadByIndexID, + (uint32_t), index_id); SBThread sb_thread; ThreadSP thread_sp; @@ -739,8 +741,8 @@ } StateType SBProcess::GetStateFromEvent(const SBEvent &event) { - LLDB_RECORD_STATIC_METHOD(lldb::StateType, SBProcess, GetStateFromEvent, - (const lldb::SBEvent &), event); + LLDB_INSTRUMENT_STATIC_METHOD(lldb::StateType, SBProcess, GetStateFromEvent, + (const lldb::SBEvent &), event); StateType ret_val = Process::ProcessEventData::GetStateFromEvent(event.get()); @@ -748,8 +750,8 @@ } bool SBProcess::GetRestartedFromEvent(const SBEvent &event) { - LLDB_RECORD_STATIC_METHOD(bool, SBProcess, GetRestartedFromEvent, - (const lldb::SBEvent &), event); + LLDB_INSTRUMENT_STATIC_METHOD(bool, SBProcess, GetRestartedFromEvent, + (const lldb::SBEvent &), event); bool ret_val = Process::ProcessEventData::GetRestartedFromEvent(event.get()); @@ -757,8 +759,9 @@ } size_t SBProcess::GetNumRestartedReasonsFromEvent(const lldb::SBEvent &event) { - LLDB_RECORD_STATIC_METHOD(size_t, SBProcess, GetNumRestartedReasonsFromEvent, - (const lldb::SBEvent &), event); + LLDB_INSTRUMENT_STATIC_METHOD(size_t, SBProcess, + GetNumRestartedReasonsFromEvent, + (const lldb::SBEvent &), event); return Process::ProcessEventData::GetNumRestartedReasons(event.get()); } @@ -766,16 +769,16 @@ 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_STATIC_METHOD(const char *, SBProcess, + GetRestartedReasonAtIndexFromEvent, + (const lldb::SBEvent &, size_t), event, idx); return Process::ProcessEventData::GetRestartedReasonAtIndex(event.get(), idx); } SBProcess SBProcess::GetProcessFromEvent(const SBEvent &event) { - LLDB_RECORD_STATIC_METHOD(lldb::SBProcess, SBProcess, GetProcessFromEvent, - (const lldb::SBEvent &), event); + LLDB_INSTRUMENT_STATIC_METHOD(lldb::SBProcess, SBProcess, GetProcessFromEvent, + (const lldb::SBEvent &), event); ProcessSP process_sp = Process::ProcessEventData::GetProcessFromEvent(event.get()); @@ -788,32 +791,32 @@ } bool SBProcess::GetInterruptedFromEvent(const SBEvent &event) { - LLDB_RECORD_STATIC_METHOD(bool, SBProcess, GetInterruptedFromEvent, - (const lldb::SBEvent &), event); + LLDB_INSTRUMENT_STATIC_METHOD(bool, SBProcess, GetInterruptedFromEvent, + (const lldb::SBEvent &), 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_STATIC_METHOD(lldb::SBStructuredData, SBProcess, + GetStructuredDataFromEvent, + (const lldb::SBEvent &), event); return SBStructuredData(event.GetSP()); } bool SBProcess::EventIsProcessEvent(const SBEvent &event) { - LLDB_RECORD_STATIC_METHOD(bool, SBProcess, EventIsProcessEvent, - (const lldb::SBEvent &), event); + LLDB_INSTRUMENT_STATIC_METHOD(bool, SBProcess, EventIsProcessEvent, + (const lldb::SBEvent &), event); return (event.GetBroadcasterClass() == SBProcess::GetBroadcasterClass()) && !EventIsStructuredDataEvent(event); } bool SBProcess::EventIsStructuredDataEvent(const lldb::SBEvent &event) { - LLDB_RECORD_STATIC_METHOD(bool, SBProcess, EventIsStructuredDataEvent, - (const lldb::SBEvent &), event); + LLDB_INSTRUMENT_STATIC_METHOD(bool, SBProcess, EventIsStructuredDataEvent, + (const lldb::SBEvent &), event); EventSP event_sp = event.GetSP(); EventData *event_data = event_sp ? event_sp->GetData() : nullptr; @@ -822,9 +825,8 @@ } SBBroadcaster SBProcess::GetBroadcaster() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBProcess, - GetBroadcaster); - + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBProcess, + GetBroadcaster); ProcessSP process_sp(GetSP()); @@ -834,17 +836,17 @@ } const char *SBProcess::GetBroadcasterClass() { - LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBProcess, - GetBroadcasterClass); + LLDB_INSTRUMENT_STATIC_METHOD_NO_ARGS(const char *, SBProcess, + GetBroadcasterClass); 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_METHOD(size_t, SBProcess, ReadMemory, + (lldb::addr_t, void *, size_t, lldb::SBError &), addr, + dst, dst_len, sb_error); size_t bytes_read = 0; @@ -869,9 +871,9 @@ 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_METHOD(size_t, SBProcess, ReadCStringFromMemory, + (lldb::addr_t, void *, size_t, lldb::SBError &), addr, + buf, size, sb_error); size_t bytes_read = 0; ProcessSP process_sp(GetSP()); @@ -893,9 +895,9 @@ 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_METHOD(uint64_t, SBProcess, ReadUnsignedFromMemory, + (lldb::addr_t, uint32_t, lldb::SBError &), addr, + byte_size, sb_error); uint64_t value = 0; ProcessSP process_sp(GetSP()); @@ -917,8 +919,8 @@ 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_METHOD(lldb::addr_t, SBProcess, ReadPointerFromMemory, + (lldb::addr_t, lldb::SBError &), addr, sb_error); lldb::addr_t ptr = LLDB_INVALID_ADDRESS; ProcessSP process_sp(GetSP()); @@ -939,9 +941,9 @@ 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_METHOD(size_t, SBProcess, WriteMemory, + (lldb::addr_t, const void *, size_t, lldb::SBError &), + addr, src, src_len, sb_error); size_t bytes_written = 0; @@ -963,8 +965,8 @@ } bool SBProcess::GetDescription(SBStream &description) { - LLDB_RECORD_METHOD(bool, SBProcess, GetDescription, (lldb::SBStream &), - description); + LLDB_INSTRUMENT_METHOD(bool, SBProcess, GetDescription, (lldb::SBStream &), + description); Stream &strm = description.ref(); @@ -988,8 +990,8 @@ } SBStructuredData SBProcess::GetExtendedCrashInformation() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStructuredData, SBProcess, - GetExtendedCrashInformation); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBStructuredData, SBProcess, + GetExtendedCrashInformation); SBStructuredData data; ProcessSP process_sp(GetSP()); if (!process_sp) @@ -1013,9 +1015,9 @@ uint32_t SBProcess::GetNumSupportedHardwareWatchpoints(lldb::SBError &sb_error) const { - LLDB_RECORD_METHOD_CONST(uint32_t, SBProcess, - GetNumSupportedHardwareWatchpoints, - (lldb::SBError &), sb_error); + LLDB_INSTRUMENT_METHOD_CONST(uint32_t, SBProcess, + GetNumSupportedHardwareWatchpoints, + (lldb::SBError &), sb_error); uint32_t num = 0; ProcessSP process_sp(GetSP()); @@ -1031,9 +1033,9 @@ 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_METHOD(uint32_t, SBProcess, LoadImage, + (lldb::SBFileSpec &, lldb::SBError &), + sb_remote_image_spec, sb_error); return LoadImage(SBFileSpec(), sb_remote_image_spec, sb_error); } @@ -1041,7 +1043,7 @@ 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( + LLDB_INSTRUMENT_METHOD( uint32_t, SBProcess, LoadImage, (const lldb::SBFileSpec &, const lldb::SBFileSpec &, lldb::SBError &), sb_local_image_spec, sb_remote_image_spec, sb_error); @@ -1068,10 +1070,10 @@ 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_METHOD(uint32_t, SBProcess, LoadImageUsingPaths, + (const lldb::SBFileSpec &, lldb::SBStringList &, + lldb::SBFileSpec &, lldb::SBError &), + image_spec, paths, loaded_path, error); ProcessSP process_sp(GetSP()); if (process_sp) { @@ -1103,8 +1105,8 @@ } lldb::SBError SBProcess::UnloadImage(uint32_t image_token) { - LLDB_RECORD_METHOD(lldb::SBError, SBProcess, UnloadImage, (uint32_t), - image_token); + LLDB_INSTRUMENT_METHOD(lldb::SBError, SBProcess, UnloadImage, (uint32_t), + image_token); lldb::SBError sb_error; ProcessSP process_sp(GetSP()); @@ -1125,8 +1127,8 @@ } lldb::SBError SBProcess::SendEventData(const char *event_data) { - LLDB_RECORD_METHOD(lldb::SBError, SBProcess, SendEventData, (const char *), - event_data); + LLDB_INSTRUMENT_METHOD(lldb::SBError, SBProcess, SendEventData, + (const char *), event_data); lldb::SBError sb_error; ProcessSP process_sp(GetSP()); @@ -1145,7 +1147,8 @@ } uint32_t SBProcess::GetNumExtendedBacktraceTypes() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumExtendedBacktraceTypes); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBProcess, + GetNumExtendedBacktraceTypes); ProcessSP process_sp(GetSP()); if (process_sp && process_sp->GetSystemRuntime()) { @@ -1156,8 +1159,8 @@ } const char *SBProcess::GetExtendedBacktraceTypeAtIndex(uint32_t idx) { - LLDB_RECORD_METHOD(const char *, SBProcess, GetExtendedBacktraceTypeAtIndex, - (uint32_t), idx); + LLDB_INSTRUMENT_METHOD(const char *, SBProcess, + GetExtendedBacktraceTypeAtIndex, (uint32_t), idx); ProcessSP process_sp(GetSP()); if (process_sp && process_sp->GetSystemRuntime()) { @@ -1172,8 +1175,8 @@ } SBThreadCollection SBProcess::GetHistoryThreads(addr_t addr) { - LLDB_RECORD_METHOD(lldb::SBThreadCollection, SBProcess, GetHistoryThreads, - (lldb::addr_t), addr); + LLDB_INSTRUMENT_METHOD(lldb::SBThreadCollection, SBProcess, GetHistoryThreads, + (lldb::addr_t), addr); ProcessSP process_sp(GetSP()); SBThreadCollection threads; @@ -1185,8 +1188,8 @@ bool SBProcess::IsInstrumentationRuntimePresent( InstrumentationRuntimeType type) { - LLDB_RECORD_METHOD(bool, SBProcess, IsInstrumentationRuntimePresent, - (lldb::InstrumentationRuntimeType), type); + LLDB_INSTRUMENT_METHOD(bool, SBProcess, IsInstrumentationRuntimePresent, + (lldb::InstrumentationRuntimeType), type); ProcessSP process_sp(GetSP()); if (!process_sp) @@ -1205,8 +1208,8 @@ } lldb::SBError SBProcess::SaveCore(const char *file_name) { - LLDB_RECORD_METHOD(lldb::SBError, SBProcess, SaveCore, (const char *), - file_name); + LLDB_INSTRUMENT_METHOD(lldb::SBError, SBProcess, SaveCore, (const char *), + file_name); lldb::SBError error; ProcessSP process_sp(GetSP()); @@ -1232,9 +1235,9 @@ 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_METHOD(lldb::SBError, SBProcess, GetMemoryRegionInfo, + (lldb::addr_t, lldb::SBMemoryRegionInfo &), load_addr, + sb_region_info); lldb::SBError sb_error; ProcessSP process_sp(GetSP()); @@ -1256,8 +1259,8 @@ } lldb::SBMemoryRegionInfoList SBProcess::GetMemoryRegions() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBMemoryRegionInfoList, SBProcess, - GetMemoryRegions); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBMemoryRegionInfoList, SBProcess, + GetMemoryRegions); lldb::SBMemoryRegionInfoList sb_region_list; @@ -1274,7 +1277,8 @@ } lldb::SBProcessInfo SBProcess::GetProcessInfo() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcessInfo, SBProcess, GetProcessInfo); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBProcessInfo, SBProcess, + GetProcessInfo); lldb::SBProcessInfo sb_proc_info; ProcessSP process_sp(GetSP()); @@ -1287,9 +1291,9 @@ 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_METHOD(lldb::addr_t, SBProcess, AllocateMemory, + (size_t, uint32_t, lldb::SBError &), size, permissions, + sb_error); lldb::addr_t addr = LLDB_INVALID_ADDRESS; ProcessSP process_sp(GetSP()); @@ -1309,8 +1313,8 @@ } lldb::SBError SBProcess::DeallocateMemory(lldb::addr_t ptr) { - LLDB_RECORD_METHOD(lldb::SBError, SBProcess, DeallocateMemory, (lldb::addr_t), - ptr); + LLDB_INSTRUMENT_METHOD(lldb::SBError, SBProcess, DeallocateMemory, + (lldb::addr_t), ptr); lldb::SBError sb_error; ProcessSP process_sp(GetSP()); Index: lldb/source/API/SBProcessInfo.cpp =================================================================== --- lldb/source/API/SBProcessInfo.cpp +++ lldb/source/API/SBProcessInfo.cpp @@ -7,20 +7,21 @@ //===----------------------------------------------------------------------===// #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); + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBProcessInfo); } SBProcessInfo::SBProcessInfo(const SBProcessInfo &rhs) { - LLDB_RECORD_CONSTRUCTOR(SBProcessInfo, (const lldb::SBProcessInfo &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBProcessInfo, (const lldb::SBProcessInfo &), + rhs); m_opaque_up = clone(rhs.m_opaque_up); } @@ -28,9 +29,8 @@ SBProcessInfo::~SBProcessInfo() = default; SBProcessInfo &SBProcessInfo::operator=(const SBProcessInfo &rhs) { - LLDB_RECORD_METHOD(lldb::SBProcessInfo &, - SBProcessInfo, operator=,(const lldb::SBProcessInfo &), - rhs); + LLDB_INSTRUMENT_METHOD(lldb::SBProcessInfo &, SBProcessInfo, operator=, + (const lldb::SBProcessInfo &), rhs); if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); @@ -49,17 +49,17 @@ } bool SBProcessInfo::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcessInfo, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBProcessInfo, IsValid); return this->operator bool(); } SBProcessInfo::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcessInfo, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBProcessInfo, operator bool); return m_opaque_up != nullptr; } const char *SBProcessInfo::GetName() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcessInfo, GetName); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBProcessInfo, GetName); const char *name = nullptr; if (m_opaque_up) { @@ -69,8 +69,8 @@ } SBFileSpec SBProcessInfo::GetExecutableFile() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBProcessInfo, - GetExecutableFile); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBFileSpec, SBProcessInfo, + GetExecutableFile); SBFileSpec file_spec; if (m_opaque_up) { @@ -80,7 +80,7 @@ } lldb::pid_t SBProcessInfo::GetProcessID() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBProcessInfo, GetProcessID); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::pid_t, SBProcessInfo, GetProcessID); lldb::pid_t proc_id = LLDB_INVALID_PROCESS_ID; if (m_opaque_up) { @@ -90,7 +90,7 @@ } uint32_t SBProcessInfo::GetUserID() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetUserID); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetUserID); uint32_t user_id = UINT32_MAX; if (m_opaque_up) { @@ -100,7 +100,7 @@ } uint32_t SBProcessInfo::GetGroupID() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetGroupID); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetGroupID); uint32_t group_id = UINT32_MAX; if (m_opaque_up) { @@ -110,7 +110,7 @@ } bool SBProcessInfo::UserIDIsValid() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, UserIDIsValid); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBProcessInfo, UserIDIsValid); bool is_valid = false; if (m_opaque_up) { @@ -120,7 +120,7 @@ } bool SBProcessInfo::GroupIDIsValid() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, GroupIDIsValid); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBProcessInfo, GroupIDIsValid); bool is_valid = false; if (m_opaque_up) { @@ -130,7 +130,7 @@ } uint32_t SBProcessInfo::GetEffectiveUserID() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetEffectiveUserID); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetEffectiveUserID); uint32_t user_id = UINT32_MAX; if (m_opaque_up) { @@ -140,7 +140,7 @@ } uint32_t SBProcessInfo::GetEffectiveGroupID() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetEffectiveGroupID); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetEffectiveGroupID); uint32_t group_id = UINT32_MAX; if (m_opaque_up) { @@ -150,7 +150,7 @@ } bool SBProcessInfo::EffectiveUserIDIsValid() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, EffectiveUserIDIsValid); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBProcessInfo, EffectiveUserIDIsValid); bool is_valid = false; if (m_opaque_up) { @@ -160,7 +160,7 @@ } bool SBProcessInfo::EffectiveGroupIDIsValid() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, EffectiveGroupIDIsValid); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBProcessInfo, EffectiveGroupIDIsValid); bool is_valid = false; if (m_opaque_up) { @@ -170,7 +170,8 @@ } lldb::pid_t SBProcessInfo::GetParentProcessID() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBProcessInfo, GetParentProcessID); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::pid_t, SBProcessInfo, + GetParentProcessID); lldb::pid_t proc_id = LLDB_INVALID_PROCESS_ID; if (m_opaque_up) { @@ -180,7 +181,7 @@ } const char *SBProcessInfo::GetTriple() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcessInfo, GetTriple); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBProcessInfo, GetTriple); const char *triple = nullptr; if (m_opaque_up) { Index: lldb/source/API/SBQueue.cpp =================================================================== --- lldb/source/API/SBQueue.cpp +++ lldb/source/API/SBQueue.cpp @@ -8,8 +8,8 @@ #include -#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" @@ -216,16 +216,16 @@ } SBQueue::SBQueue() : m_opaque_sp(new QueueImpl()) { - LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBQueue); + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBQueue); } SBQueue::SBQueue(const QueueSP &queue_sp) : m_opaque_sp(new QueueImpl(queue_sp)) { - LLDB_RECORD_CONSTRUCTOR(SBQueue, (const lldb::QueueSP &), queue_sp); + LLDB_INSTRUMENT_CONSTRUCTOR(SBQueue, (const lldb::QueueSP &), queue_sp); } SBQueue::SBQueue(const SBQueue &rhs) { - LLDB_RECORD_CONSTRUCTOR(SBQueue, (const lldb::SBQueue &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBQueue, (const lldb::SBQueue &), rhs); if (&rhs == this) return; @@ -234,8 +234,8 @@ } const lldb::SBQueue &SBQueue::operator=(const lldb::SBQueue &rhs) { - LLDB_RECORD_METHOD(const lldb::SBQueue &, - SBQueue, operator=,(const lldb::SBQueue &), rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBQueue &, SBQueue, operator=, + (const lldb::SBQueue &), rhs); m_opaque_sp = rhs.m_opaque_sp; return *this; @@ -244,17 +244,17 @@ SBQueue::~SBQueue() = default; bool SBQueue::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBQueue, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBQueue, IsValid); return this->operator bool(); } SBQueue::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBQueue, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBQueue, operator bool); return m_opaque_sp->IsValid(); } void SBQueue::Clear() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBQueue, Clear); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBQueue, Clear); m_opaque_sp->Clear(); } @@ -264,65 +264,65 @@ } lldb::queue_id_t SBQueue::GetQueueID() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::queue_id_t, SBQueue, GetQueueID); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::queue_id_t, SBQueue, GetQueueID); return m_opaque_sp->GetQueueID(); } uint32_t SBQueue::GetIndexID() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBQueue, GetIndexID); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(uint32_t, SBQueue, GetIndexID); 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_METHOD_CONST_NO_ARGS(const char *, SBQueue, GetName); return m_opaque_sp->GetName(); } uint32_t SBQueue::GetNumThreads() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBQueue, GetNumThreads); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBQueue, GetNumThreads); return m_opaque_sp->GetNumThreads(); } SBThread SBQueue::GetThreadAtIndex(uint32_t idx) { - LLDB_RECORD_METHOD(lldb::SBThread, SBQueue, GetThreadAtIndex, (uint32_t), - idx); + LLDB_INSTRUMENT_METHOD(lldb::SBThread, SBQueue, GetThreadAtIndex, (uint32_t), + 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_METHOD_NO_ARGS(uint32_t, SBQueue, GetNumPendingItems); return m_opaque_sp->GetNumPendingItems(); } SBQueueItem SBQueue::GetPendingItemAtIndex(uint32_t idx) { - LLDB_RECORD_METHOD(lldb::SBQueueItem, SBQueue, GetPendingItemAtIndex, - (uint32_t), idx); + LLDB_INSTRUMENT_METHOD(lldb::SBQueueItem, SBQueue, GetPendingItemAtIndex, + (uint32_t), idx); return m_opaque_sp->GetPendingItemAtIndex(idx); } uint32_t SBQueue::GetNumRunningItems() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBQueue, GetNumRunningItems); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBQueue, GetNumRunningItems); return m_opaque_sp->GetNumRunningItems(); } SBProcess SBQueue::GetProcess() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBQueue, GetProcess); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBProcess, SBQueue, GetProcess); return m_opaque_sp->GetProcess(); } lldb::QueueKind SBQueue::GetKind() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::QueueKind, SBQueue, GetKind); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::QueueKind, SBQueue, GetKind); return m_opaque_sp->GetKind(); } Index: lldb/source/API/SBQueueItem.cpp =================================================================== --- lldb/source/API/SBQueueItem.cpp +++ lldb/source/API/SBQueueItem.cpp @@ -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,49 @@ #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_CONSTRUCTOR_NO_ARGS(SBQueueItem); } 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_CONSTRUCTOR(SBQueueItem, (const lldb::QueueItemSP &), + 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_METHOD_CONST_NO_ARGS(bool, SBQueueItem, IsValid); return this->operator bool(); } SBQueueItem::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBQueueItem, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBQueueItem, operator bool); return m_queue_item_sp.get() != nullptr; } void SBQueueItem::Clear() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBQueueItem, Clear); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBQueueItem, Clear); 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_METHOD(void, SBQueueItem, SetQueueItem, + (const lldb::QueueItemSP &), queue_item_sp); m_queue_item_sp = queue_item_sp; } lldb::QueueItemKind SBQueueItem::GetKind() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::QueueItemKind, SBQueueItem, GetKind); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::QueueItemKind, SBQueueItem, + GetKind); QueueItemKind result = eQueueItemKindUnknown; if (m_queue_item_sp) { @@ -66,7 +67,8 @@ } void SBQueueItem::SetKind(lldb::QueueItemKind kind) { - LLDB_RECORD_METHOD(void, SBQueueItem, SetKind, (lldb::QueueItemKind), kind); + LLDB_INSTRUMENT_METHOD(void, SBQueueItem, SetKind, (lldb::QueueItemKind), + kind); if (m_queue_item_sp) { m_queue_item_sp->SetKind(kind); @@ -74,7 +76,8 @@ } SBAddress SBQueueItem::GetAddress() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBQueueItem, GetAddress); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBQueueItem, + GetAddress); SBAddress result; if (m_queue_item_sp) { @@ -84,7 +87,8 @@ } void SBQueueItem::SetAddress(SBAddress addr) { - LLDB_RECORD_METHOD(void, SBQueueItem, SetAddress, (lldb::SBAddress), addr); + LLDB_INSTRUMENT_METHOD(void, SBQueueItem, SetAddress, (lldb::SBAddress), + addr); if (m_queue_item_sp) { m_queue_item_sp->SetAddress(addr.ref()); @@ -92,8 +96,8 @@ } SBThread SBQueueItem::GetExtendedBacktraceThread(const char *type) { - LLDB_RECORD_METHOD(lldb::SBThread, SBQueueItem, GetExtendedBacktraceThread, - (const char *), type); + LLDB_INSTRUMENT_METHOD(lldb::SBThread, SBQueueItem, + GetExtendedBacktraceThread, (const char *), type); SBThread result; if (m_queue_item_sp) { Index: lldb/source/API/SBReproducer.cpp =================================================================== --- lldb/source/API/SBReproducer.cpp +++ 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; Index: lldb/source/API/SBSection.cpp =================================================================== --- lldb/source/API/SBSection.cpp +++ 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_CONSTRUCTOR_NO_ARGS(SBSection); } SBSection::SBSection(const SBSection &rhs) : m_opaque_wp(rhs.m_opaque_wp) { - LLDB_RECORD_CONSTRUCTOR(SBSection, (const lldb::SBSection &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBSection, (const lldb::SBSection &), rhs); } SBSection::SBSection(const lldb::SectionSP §ion_sp) { @@ -34,8 +34,8 @@ } const SBSection &SBSection::operator=(const SBSection &rhs) { - LLDB_RECORD_METHOD(const lldb::SBSection &, - SBSection, operator=,(const lldb::SBSection &), rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBSection &, SBSection, operator=, + (const lldb::SBSection &), rhs); m_opaque_wp = rhs.m_opaque_wp; return *this; @@ -44,18 +44,18 @@ SBSection::~SBSection() = default; bool SBSection::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSection, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBSection, IsValid); return this->operator bool(); } SBSection::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSection, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBSection, operator bool); 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_METHOD_NO_ARGS(const char *, SBSection, GetName); SectionSP section_sp(GetSP()); if (section_sp) @@ -64,7 +64,7 @@ } lldb::SBSection SBSection::GetParent() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSection, SBSection, GetParent); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBSection, SBSection, GetParent); lldb::SBSection sb_section; SectionSP section_sp(GetSP()); @@ -77,8 +77,8 @@ } lldb::SBSection SBSection::FindSubSection(const char *sect_name) { - LLDB_RECORD_METHOD(lldb::SBSection, SBSection, FindSubSection, (const char *), - sect_name); + LLDB_INSTRUMENT_METHOD(lldb::SBSection, SBSection, FindSubSection, + (const char *), sect_name); lldb::SBSection sb_section; if (sect_name) { @@ -93,7 +93,7 @@ } size_t SBSection::GetNumSubSections() { - LLDB_RECORD_METHOD_NO_ARGS(size_t, SBSection, GetNumSubSections); + LLDB_INSTRUMENT_METHOD_NO_ARGS(size_t, SBSection, GetNumSubSections); SectionSP section_sp(GetSP()); if (section_sp) @@ -102,8 +102,8 @@ } lldb::SBSection SBSection::GetSubSectionAtIndex(size_t idx) { - LLDB_RECORD_METHOD(lldb::SBSection, SBSection, GetSubSectionAtIndex, (size_t), - idx); + LLDB_INSTRUMENT_METHOD(lldb::SBSection, SBSection, GetSubSectionAtIndex, + (size_t), idx); lldb::SBSection sb_section; SectionSP section_sp(GetSP()); @@ -119,7 +119,7 @@ } lldb::addr_t SBSection::GetFileAddress() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBSection, GetFileAddress); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::addr_t, SBSection, GetFileAddress); lldb::addr_t file_addr = LLDB_INVALID_ADDRESS; SectionSP section_sp(GetSP()); @@ -129,8 +129,8 @@ } lldb::addr_t SBSection::GetLoadAddress(lldb::SBTarget &sb_target) { - LLDB_RECORD_METHOD(lldb::addr_t, SBSection, GetLoadAddress, - (lldb::SBTarget &), sb_target); + LLDB_INSTRUMENT_METHOD(lldb::addr_t, SBSection, GetLoadAddress, + (lldb::SBTarget &), sb_target); TargetSP target_sp(sb_target.GetSP()); if (target_sp) { @@ -142,7 +142,7 @@ } lldb::addr_t SBSection::GetByteSize() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBSection, GetByteSize); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::addr_t, SBSection, GetByteSize); SectionSP section_sp(GetSP()); if (section_sp) @@ -151,7 +151,7 @@ } uint64_t SBSection::GetFileOffset() { - LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBSection, GetFileOffset); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint64_t, SBSection, GetFileOffset); SectionSP section_sp(GetSP()); if (section_sp) { @@ -166,7 +166,7 @@ } uint64_t SBSection::GetFileByteSize() { - LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBSection, GetFileByteSize); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint64_t, SBSection, GetFileByteSize); SectionSP section_sp(GetSP()); if (section_sp) @@ -175,14 +175,14 @@ } SBData SBSection::GetSectionData() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBData, SBSection, GetSectionData); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBData, SBSection, GetSectionData); 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_METHOD(lldb::SBData, SBSection, GetSectionData, + (uint64_t, uint64_t), offset, size); SBData sb_data; SectionSP section_sp(GetSP()); @@ -221,7 +221,7 @@ } SectionType SBSection::GetSectionType() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SectionType, SBSection, GetSectionType); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SectionType, SBSection, GetSectionType); SectionSP section_sp(GetSP()); if (section_sp.get()) @@ -230,7 +230,7 @@ } uint32_t SBSection::GetPermissions() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBSection, GetPermissions); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(uint32_t, SBSection, GetPermissions); SectionSP section_sp(GetSP()); if (section_sp) @@ -239,7 +239,7 @@ } uint32_t SBSection::GetTargetByteSize() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBSection, GetTargetByteSize); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBSection, GetTargetByteSize); SectionSP section_sp(GetSP()); if (section_sp.get()) @@ -248,8 +248,8 @@ } bool SBSection::operator==(const SBSection &rhs) { - LLDB_RECORD_METHOD(bool, SBSection, operator==,(const lldb::SBSection &), - rhs); + LLDB_INSTRUMENT_METHOD(bool, SBSection, operator==, (const lldb::SBSection &), + rhs); SectionSP lhs_section_sp(GetSP()); SectionSP rhs_section_sp(rhs.GetSP()); @@ -259,8 +259,8 @@ } bool SBSection::operator!=(const SBSection &rhs) { - LLDB_RECORD_METHOD(bool, SBSection, operator!=,(const lldb::SBSection &), - rhs); + LLDB_INSTRUMENT_METHOD(bool, SBSection, operator!=, (const lldb::SBSection &), + rhs); SectionSP lhs_section_sp(GetSP()); SectionSP rhs_section_sp(rhs.GetSP()); @@ -268,8 +268,8 @@ } bool SBSection::GetDescription(SBStream &description) { - LLDB_RECORD_METHOD(bool, SBSection, GetDescription, (lldb::SBStream &), - description); + LLDB_INSTRUMENT_METHOD(bool, SBSection, GetDescription, (lldb::SBStream &), + description); Stream &strm = description.ref(); Index: lldb/source/API/SBSourceManager.cpp =================================================================== --- lldb/source/API/SBSourceManager.cpp +++ 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,22 @@ using namespace lldb_private; SBSourceManager::SBSourceManager(const SBDebugger &debugger) { - LLDB_RECORD_CONSTRUCTOR(SBSourceManager, (const lldb::SBDebugger &), - debugger); + LLDB_INSTRUMENT_CONSTRUCTOR(SBSourceManager, (const lldb::SBDebugger &), + debugger); m_opaque_up = std::make_unique(debugger.get_sp()); } SBSourceManager::SBSourceManager(const SBTarget &target) { - LLDB_RECORD_CONSTRUCTOR(SBSourceManager, (const lldb::SBTarget &), target); + LLDB_INSTRUMENT_CONSTRUCTOR(SBSourceManager, (const lldb::SBTarget &), + target); m_opaque_up = std::make_unique(target.GetSP()); } SBSourceManager::SBSourceManager(const SBSourceManager &rhs) { - LLDB_RECORD_CONSTRUCTOR(SBSourceManager, (const lldb::SBSourceManager &), - rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBSourceManager, (const lldb::SBSourceManager &), + rhs); if (&rhs == this) return; @@ -95,9 +96,9 @@ const lldb::SBSourceManager &SBSourceManager:: operator=(const lldb::SBSourceManager &rhs) { - LLDB_RECORD_METHOD(const lldb::SBSourceManager &, - SBSourceManager, operator=,(const lldb::SBSourceManager &), - rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBSourceManager &, + SBSourceManager, operator=, + (const lldb::SBSourceManager &), rhs); m_opaque_up = std::make_unique(*(rhs.m_opaque_up.get())); return *this; @@ -108,11 +109,11 @@ size_t SBSourceManager::DisplaySourceLinesWithLineNumbers( const SBFileSpec &file, uint32_t line, uint32_t context_before, uint32_t context_after, const char *current_line_cstr, SBStream &s) { - LLDB_RECORD_METHOD(size_t, SBSourceManager, DisplaySourceLinesWithLineNumbers, - (const lldb::SBFileSpec &, uint32_t, uint32_t, uint32_t, - const char *, lldb::SBStream &), - file, line, context_before, context_after, - current_line_cstr, s); + LLDB_INSTRUMENT_METHOD( + size_t, SBSourceManager, DisplaySourceLinesWithLineNumbers, + (const lldb::SBFileSpec &, uint32_t, uint32_t, uint32_t, const char *, + lldb::SBStream &), + file, line, context_before, context_after, current_line_cstr, s); const uint32_t column = 0; return DisplaySourceLinesWithLineNumbersAndColumn( @@ -124,7 +125,7 @@ const SBFileSpec &file, uint32_t line, uint32_t column, uint32_t context_before, uint32_t context_after, const char *current_line_cstr, SBStream &s) { - LLDB_RECORD_METHOD( + LLDB_INSTRUMENT_METHOD( size_t, SBSourceManager, DisplaySourceLinesWithLineNumbersAndColumn, (const lldb::SBFileSpec &, uint32_t, uint32_t, uint32_t, uint32_t, const char *, lldb::SBStream &), Index: lldb/source/API/SBStream.cpp =================================================================== --- lldb/source/API/SBStream.cpp +++ 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_private; SBStream::SBStream() : m_opaque_up(new StreamString()) { - LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBStream); + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBStream); } SBStream::SBStream(SBStream &&rhs) @@ -29,11 +29,11 @@ SBStream::~SBStream() = default; bool SBStream::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStream, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBStream, IsValid); return this->operator bool(); } SBStream::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStream, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBStream, operator bool); return (m_opaque_up != nullptr); } @@ -41,7 +41,7 @@ // If this stream is not redirected to a file, it will maintain a local cache // for the stream data which can be accessed using this accessor. const char *SBStream::GetData() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBStream, GetData); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBStream, GetData); if (m_is_file || m_opaque_up == nullptr) return nullptr; @@ -52,7 +52,7 @@ // If this stream is not redirected to a file, it will maintain a local cache // for the stream output whose length can be accessed using this accessor. size_t SBStream::GetSize() { - LLDB_RECORD_METHOD_NO_ARGS(size_t, SBStream, GetSize); + LLDB_INSTRUMENT_METHOD_NO_ARGS(size_t, SBStream, GetSize); if (m_is_file || m_opaque_up == nullptr) return 0; @@ -61,7 +61,7 @@ } void SBStream::Print(const char *str) { - LLDB_RECORD_METHOD(void, SBStream, Print, (const char *), str); + LLDB_INSTRUMENT_METHOD(void, SBStream, Print, (const char *), str); Printf("%s", str); } @@ -76,8 +76,8 @@ } void SBStream::RedirectToFile(const char *path, bool append) { - LLDB_RECORD_METHOD(void, SBStream, RedirectToFile, (const char *, bool), path, - append); + LLDB_INSTRUMENT_METHOD(void, SBStream, RedirectToFile, (const char *, bool), + path, append); if (path == nullptr) return; @@ -114,19 +114,19 @@ } void SBStream::RedirectToFileHandle(FILE *fh, bool transfer_fh_ownership) { - LLDB_RECORD_METHOD(void, SBStream, RedirectToFileHandle, (FILE *, bool), fh, - transfer_fh_ownership); + LLDB_INSTRUMENT_METHOD(void, SBStream, RedirectToFileHandle, (FILE *, bool), + fh, transfer_fh_ownership); FileSP file = std::make_unique(fh, transfer_fh_ownership); return RedirectToFile(file); } void SBStream::RedirectToFile(SBFile file) { - LLDB_RECORD_METHOD(void, SBStream, RedirectToFile, (SBFile), file) + LLDB_INSTRUMENT_METHOD(void, SBStream, RedirectToFile, (SBFile), file) RedirectToFile(file.GetFile()); } void SBStream::RedirectToFile(FileSP file_sp) { - LLDB_RECORD_METHOD(void, SBStream, RedirectToFile, (FileSP), file_sp); + LLDB_INSTRUMENT_METHOD(void, SBStream, RedirectToFile, (FileSP), file_sp); if (!file_sp || !file_sp->IsValid()) return; @@ -150,8 +150,8 @@ } void SBStream::RedirectToFileDescriptor(int fd, bool transfer_fh_ownership) { - LLDB_RECORD_METHOD(void, SBStream, RedirectToFileDescriptor, (int, bool), fd, - transfer_fh_ownership); + LLDB_INSTRUMENT_METHOD(void, SBStream, RedirectToFileDescriptor, (int, bool), + fd, transfer_fh_ownership); std::string local_data; if (m_opaque_up) { @@ -182,7 +182,7 @@ } void SBStream::Clear() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBStream, Clear); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBStream, Clear); if (m_opaque_up) { // See if we have any locally backed data. If so, copy it so we can then Index: lldb/source/API/SBStringList.cpp =================================================================== --- lldb/source/API/SBStringList.cpp +++ lldb/source/API/SBStringList.cpp @@ -7,14 +7,16 @@ //===----------------------------------------------------------------------===// #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_CONSTRUCTOR_NO_ARGS(SBStringList); +} SBStringList::SBStringList(const lldb_private::StringList *lldb_strings_ptr) { if (lldb_strings_ptr) @@ -22,14 +24,14 @@ } SBStringList::SBStringList(const SBStringList &rhs) { - LLDB_RECORD_CONSTRUCTOR(SBStringList, (const lldb::SBStringList &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBStringList, (const lldb::SBStringList &), rhs); m_opaque_up = clone(rhs.m_opaque_up); } const SBStringList &SBStringList::operator=(const SBStringList &rhs) { - LLDB_RECORD_METHOD(const lldb::SBStringList &, - SBStringList, operator=,(const lldb::SBStringList &), rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBStringList &, SBStringList, operator=, + (const lldb::SBStringList &), rhs); if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); @@ -47,17 +49,17 @@ } bool SBStringList::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStringList, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBStringList, IsValid); return this->operator bool(); } SBStringList::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStringList, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBStringList, operator bool); return (m_opaque_up != nullptr); } void SBStringList::AppendString(const char *str) { - LLDB_RECORD_METHOD(void, SBStringList, AppendString, (const char *), str); + LLDB_INSTRUMENT_METHOD(void, SBStringList, AppendString, (const char *), str); if (str != nullptr) { if (IsValid()) @@ -68,8 +70,8 @@ } void SBStringList::AppendList(const char **strv, int strc) { - LLDB_RECORD_METHOD(void, SBStringList, AppendList, (const char **, int), strv, - strc); + LLDB_INSTRUMENT_METHOD(void, SBStringList, AppendList, (const char **, int), + strv, strc); if ((strv != nullptr) && (strc > 0)) { if (IsValid()) @@ -80,8 +82,8 @@ } void SBStringList::AppendList(const SBStringList &strings) { - LLDB_RECORD_METHOD(void, SBStringList, AppendList, - (const lldb::SBStringList &), strings); + LLDB_INSTRUMENT_METHOD(void, SBStringList, AppendList, + (const lldb::SBStringList &), strings); if (strings.IsValid()) { if (!IsValid()) @@ -97,7 +99,7 @@ } uint32_t SBStringList::GetSize() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBStringList, GetSize); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(uint32_t, SBStringList, GetSize); if (IsValid()) { return m_opaque_up->GetSize(); @@ -106,8 +108,8 @@ } const char *SBStringList::GetStringAtIndex(size_t idx) { - LLDB_RECORD_METHOD(const char *, SBStringList, GetStringAtIndex, (size_t), - idx); + LLDB_INSTRUMENT_METHOD(const char *, SBStringList, GetStringAtIndex, (size_t), + idx); if (IsValid()) { return m_opaque_up->GetStringAtIndex(idx); @@ -116,8 +118,8 @@ } const char *SBStringList::GetStringAtIndex(size_t idx) const { - LLDB_RECORD_METHOD_CONST(const char *, SBStringList, GetStringAtIndex, - (size_t), idx); + LLDB_INSTRUMENT_METHOD_CONST(const char *, SBStringList, GetStringAtIndex, + (size_t), idx); if (IsValid()) { return m_opaque_up->GetStringAtIndex(idx); @@ -126,7 +128,7 @@ } void SBStringList::Clear() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBStringList, Clear); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBStringList, Clear); if (IsValid()) { m_opaque_up->Clear(); Index: lldb/source/API/SBStructuredData.cpp =================================================================== --- lldb/source/API/SBStructuredData.cpp +++ 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,41 @@ #pragma mark SBStructuredData SBStructuredData::SBStructuredData() : m_impl_up(new StructuredDataImpl()) { - LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBStructuredData); + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBStructuredData); } 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_CONSTRUCTOR(SBStructuredData, + (const lldb::SBStructuredData &), 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_CONSTRUCTOR(SBStructuredData, (const lldb::EventSP &), + 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_CONSTRUCTOR(SBStructuredData, + (const lldb_private::StructuredDataImpl &), impl); } SBStructuredData::~SBStructuredData() = default; SBStructuredData &SBStructuredData:: operator=(const lldb::SBStructuredData &rhs) { - LLDB_RECORD_METHOD( - lldb::SBStructuredData &, - SBStructuredData, operator=,(const lldb::SBStructuredData &), rhs); + LLDB_INSTRUMENT_METHOD(lldb::SBStructuredData &, SBStructuredData, operator=, + (const lldb::SBStructuredData &), rhs); *m_impl_up = *rhs.m_impl_up; return *this; } lldb::SBError SBStructuredData::SetFromJSON(lldb::SBStream &stream) { - LLDB_RECORD_METHOD(lldb::SBError, SBStructuredData, SetFromJSON, - (lldb::SBStream &), stream); + LLDB_INSTRUMENT_METHOD(lldb::SBError, SBStructuredData, SetFromJSON, + (lldb::SBStream &), stream); lldb::SBError error; std::string json_str(stream.GetData()); @@ -73,33 +73,33 @@ } lldb::SBError SBStructuredData::SetFromJSON(const char *json) { - LLDB_RECORD_METHOD(lldb::SBError, SBStructuredData, SetFromJSON, - (const char *), json); + LLDB_INSTRUMENT_METHOD(lldb::SBError, SBStructuredData, SetFromJSON, + (const char *), 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_METHOD_CONST_NO_ARGS(bool, SBStructuredData, IsValid); return this->operator bool(); } SBStructuredData::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStructuredData, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBStructuredData, operator bool); return m_impl_up->IsValid(); } void SBStructuredData::Clear() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBStructuredData, Clear); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBStructuredData, Clear); m_impl_up->Clear(); } SBError SBStructuredData::GetAsJSON(lldb::SBStream &stream) const { - LLDB_RECORD_METHOD_CONST(lldb::SBError, SBStructuredData, GetAsJSON, - (lldb::SBStream &), stream); + LLDB_INSTRUMENT_METHOD_CONST(lldb::SBError, SBStructuredData, GetAsJSON, + (lldb::SBStream &), stream); SBError error; error.SetError(m_impl_up->GetAsJSON(stream.ref())); @@ -107,8 +107,8 @@ } lldb::SBError SBStructuredData::GetDescription(lldb::SBStream &stream) const { - LLDB_RECORD_METHOD_CONST(lldb::SBError, SBStructuredData, GetDescription, - (lldb::SBStream &), stream); + LLDB_INSTRUMENT_METHOD_CONST(lldb::SBError, SBStructuredData, GetDescription, + (lldb::SBStream &), stream); Status error = m_impl_up->GetDescription(stream.ref()); SBError sb_error; @@ -117,21 +117,21 @@ } StructuredDataType SBStructuredData::GetType() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::StructuredDataType, SBStructuredData, - GetType); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::StructuredDataType, + SBStructuredData, GetType); return m_impl_up->GetType(); } size_t SBStructuredData::GetSize() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBStructuredData, GetSize); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(size_t, SBStructuredData, GetSize); return m_impl_up->GetSize(); } bool SBStructuredData::GetKeys(lldb::SBStringList &keys) const { - LLDB_RECORD_METHOD_CONST(bool, SBStructuredData, GetKeys, - (lldb::SBStringList &), keys); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBStructuredData, GetKeys, + (lldb::SBStringList &), keys); if (GetType() != eStructuredDataTypeDictionary) return false; @@ -157,8 +157,8 @@ } lldb::SBStructuredData SBStructuredData::GetValueForKey(const char *key) const { - LLDB_RECORD_METHOD_CONST(lldb::SBStructuredData, SBStructuredData, - GetValueForKey, (const char *), key); + LLDB_INSTRUMENT_METHOD_CONST(lldb::SBStructuredData, SBStructuredData, + GetValueForKey, (const char *), key); SBStructuredData result; result.m_impl_up->SetObjectSP(m_impl_up->GetValueForKey(key)); @@ -166,8 +166,8 @@ } lldb::SBStructuredData SBStructuredData::GetItemAtIndex(size_t idx) const { - LLDB_RECORD_METHOD_CONST(lldb::SBStructuredData, SBStructuredData, - GetItemAtIndex, (size_t), idx); + LLDB_INSTRUMENT_METHOD_CONST(lldb::SBStructuredData, SBStructuredData, + GetItemAtIndex, (size_t), idx); SBStructuredData result; result.m_impl_up->SetObjectSP(m_impl_up->GetItemAtIndex(idx)); @@ -175,29 +175,29 @@ } uint64_t SBStructuredData::GetIntegerValue(uint64_t fail_value) const { - LLDB_RECORD_METHOD_CONST(uint64_t, SBStructuredData, GetIntegerValue, - (uint64_t), fail_value); + LLDB_INSTRUMENT_METHOD_CONST(uint64_t, SBStructuredData, GetIntegerValue, + (uint64_t), 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_METHOD_CONST(double, SBStructuredData, GetFloatValue, + (double), 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_METHOD_CONST(bool, SBStructuredData, GetBooleanValue, (bool), + 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_METHOD_CONST(size_t, SBStructuredData, GetStringValue, + (char *, size_t), dst, "", dst_len); return m_impl_up->GetStringValue(dst, dst_len); } Index: lldb/source/API/SBSymbol.cpp =================================================================== --- lldb/source/API/SBSymbol.cpp +++ lldb/source/API/SBSymbol.cpp @@ -7,29 +7,29 @@ //===----------------------------------------------------------------------===// #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_CONSTRUCTOR_NO_ARGS(SBSymbol); } SBSymbol::SBSymbol(lldb_private::Symbol *lldb_object_ptr) : m_opaque_ptr(lldb_object_ptr) {} SBSymbol::SBSymbol(const lldb::SBSymbol &rhs) : m_opaque_ptr(rhs.m_opaque_ptr) { - LLDB_RECORD_CONSTRUCTOR(SBSymbol, (const lldb::SBSymbol &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBSymbol, (const lldb::SBSymbol &), rhs); } const SBSymbol &SBSymbol::operator=(const SBSymbol &rhs) { - LLDB_RECORD_METHOD(const lldb::SBSymbol &, - SBSymbol, operator=,(const lldb::SBSymbol &), rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBSymbol &, SBSymbol, operator=, + (const lldb::SBSymbol &), rhs); m_opaque_ptr = rhs.m_opaque_ptr; return *this; @@ -42,17 +42,17 @@ } bool SBSymbol::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbol, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBSymbol, IsValid); return this->operator bool(); } SBSymbol::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbol, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBSymbol, operator bool); return m_opaque_ptr != nullptr; } const char *SBSymbol::GetName() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetName); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetName); const char *name = nullptr; if (m_opaque_ptr) @@ -62,7 +62,7 @@ } const char *SBSymbol::GetDisplayName() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetDisplayName); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetDisplayName); const char *name = nullptr; if (m_opaque_ptr) @@ -72,7 +72,7 @@ } const char *SBSymbol::GetMangledName() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetMangledName); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetMangledName); const char *name = nullptr; if (m_opaque_ptr) @@ -81,22 +81,22 @@ } bool SBSymbol::operator==(const SBSymbol &rhs) const { - LLDB_RECORD_METHOD_CONST(bool, SBSymbol, operator==,(const lldb::SBSymbol &), - rhs); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBSymbol, operator==, + (const lldb::SBSymbol &), rhs); return m_opaque_ptr == rhs.m_opaque_ptr; } bool SBSymbol::operator!=(const SBSymbol &rhs) const { - LLDB_RECORD_METHOD_CONST(bool, SBSymbol, operator!=,(const lldb::SBSymbol &), - rhs); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBSymbol, operator!=, + (const lldb::SBSymbol &), rhs); return m_opaque_ptr != rhs.m_opaque_ptr; } bool SBSymbol::GetDescription(SBStream &description) { - LLDB_RECORD_METHOD(bool, SBSymbol, GetDescription, (lldb::SBStream &), - description); + LLDB_INSTRUMENT_METHOD(bool, SBSymbol, GetDescription, (lldb::SBStream &), + description); Stream &strm = description.ref(); @@ -109,16 +109,16 @@ } SBInstructionList SBSymbol::GetInstructions(SBTarget target) { - LLDB_RECORD_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions, - (lldb::SBTarget), target); + LLDB_INSTRUMENT_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions, + (lldb::SBTarget), 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_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions, + (lldb::SBTarget, const char *), target, flavor_string); SBInstructionList sb_instructions; if (m_opaque_ptr) { @@ -145,7 +145,7 @@ 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_METHOD_NO_ARGS(lldb::SBAddress, SBSymbol, GetStartAddress); SBAddress addr; if (m_opaque_ptr && m_opaque_ptr->ValueIsAddress()) { @@ -155,7 +155,7 @@ } SBAddress SBSymbol::GetEndAddress() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBSymbol, GetEndAddress); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBAddress, SBSymbol, GetEndAddress); SBAddress addr; if (m_opaque_ptr && m_opaque_ptr->ValueIsAddress()) { @@ -169,7 +169,7 @@ } uint32_t SBSymbol::GetPrologueByteSize() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBSymbol, GetPrologueByteSize); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBSymbol, GetPrologueByteSize); if (m_opaque_ptr) return m_opaque_ptr->GetPrologueByteSize(); @@ -177,7 +177,7 @@ } SymbolType SBSymbol::GetType() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SymbolType, SBSymbol, GetType); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SymbolType, SBSymbol, GetType); if (m_opaque_ptr) return m_opaque_ptr->GetType(); @@ -185,7 +185,7 @@ } bool SBSymbol::IsExternal() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBSymbol, IsExternal); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBSymbol, IsExternal); if (m_opaque_ptr) return m_opaque_ptr->IsExternal(); @@ -193,7 +193,7 @@ } bool SBSymbol::IsSynthetic() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBSymbol, IsSynthetic); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBSymbol, IsSynthetic); if (m_opaque_ptr) return m_opaque_ptr->IsSynthetic(); Index: lldb/source/API/SBSymbolContext.cpp =================================================================== --- lldb/source/API/SBSymbolContext.cpp +++ lldb/source/API/SBSymbolContext.cpp @@ -7,30 +7,30 @@ //===----------------------------------------------------------------------===// #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); + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBSymbolContext); } SBSymbolContext::SBSymbolContext(const SymbolContext &sc) : m_opaque_up(std::make_unique(sc)) { - LLDB_RECORD_CONSTRUCTOR(SBSymbolContext, - (const lldb_private::SymbolContext &), sc); + LLDB_INSTRUMENT_CONSTRUCTOR(SBSymbolContext, + (const lldb_private::SymbolContext &), sc); } SBSymbolContext::SBSymbolContext(const SBSymbolContext &rhs) { - LLDB_RECORD_CONSTRUCTOR(SBSymbolContext, (const lldb::SBSymbolContext &), - rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBSymbolContext, (const lldb::SBSymbolContext &), + rhs); m_opaque_up = clone(rhs.m_opaque_up); } @@ -38,9 +38,9 @@ SBSymbolContext::~SBSymbolContext() = default; const SBSymbolContext &SBSymbolContext::operator=(const SBSymbolContext &rhs) { - LLDB_RECORD_METHOD(const lldb::SBSymbolContext &, - SBSymbolContext, operator=,(const lldb::SBSymbolContext &), - rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBSymbolContext &, + SBSymbolContext, operator=, + (const lldb::SBSymbolContext &), rhs); if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); @@ -48,17 +48,17 @@ } bool SBSymbolContext::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContext, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBSymbolContext, IsValid); return this->operator bool(); } SBSymbolContext::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContext, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBSymbolContext, operator bool); return m_opaque_up != nullptr; } SBModule SBSymbolContext::GetModule() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBModule, SBSymbolContext, GetModule); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBModule, SBSymbolContext, GetModule); SBModule sb_module; ModuleSP module_sp; @@ -71,14 +71,15 @@ } SBCompileUnit SBSymbolContext::GetCompileUnit() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCompileUnit, SBSymbolContext, - GetCompileUnit); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBCompileUnit, SBSymbolContext, + GetCompileUnit); 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_METHOD_NO_ARGS(lldb::SBFunction, SBSymbolContext, + GetFunction); Function *function = nullptr; @@ -91,13 +92,14 @@ } SBBlock SBSymbolContext::GetBlock() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBSymbolContext, GetBlock); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBBlock, SBSymbolContext, GetBlock); return SBBlock(m_opaque_up ? m_opaque_up->block : nullptr); } SBLineEntry SBSymbolContext::GetLineEntry() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBLineEntry, SBSymbolContext, GetLineEntry); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBLineEntry, SBSymbolContext, + GetLineEntry); SBLineEntry sb_line_entry; if (m_opaque_up) @@ -107,7 +109,7 @@ } SBSymbol SBSymbolContext::GetSymbol() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSymbol, SBSymbolContext, GetSymbol); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBSymbol, SBSymbolContext, GetSymbol); Symbol *symbol = nullptr; @@ -120,35 +122,36 @@ } void SBSymbolContext::SetModule(lldb::SBModule module) { - LLDB_RECORD_METHOD(void, SBSymbolContext, SetModule, (lldb::SBModule), - module); + LLDB_INSTRUMENT_METHOD(void, SBSymbolContext, SetModule, (lldb::SBModule), + module); ref().module_sp = module.GetSP(); } void SBSymbolContext::SetCompileUnit(lldb::SBCompileUnit compile_unit) { - LLDB_RECORD_METHOD(void, SBSymbolContext, SetCompileUnit, - (lldb::SBCompileUnit), compile_unit); + LLDB_INSTRUMENT_METHOD(void, SBSymbolContext, SetCompileUnit, + (lldb::SBCompileUnit), compile_unit); ref().comp_unit = compile_unit.get(); } void SBSymbolContext::SetFunction(lldb::SBFunction function) { - LLDB_RECORD_METHOD(void, SBSymbolContext, SetFunction, (lldb::SBFunction), - function); + LLDB_INSTRUMENT_METHOD(void, SBSymbolContext, SetFunction, (lldb::SBFunction), + function); ref().function = function.get(); } void SBSymbolContext::SetBlock(lldb::SBBlock block) { - LLDB_RECORD_METHOD(void, SBSymbolContext, SetBlock, (lldb::SBBlock), block); + LLDB_INSTRUMENT_METHOD(void, SBSymbolContext, SetBlock, (lldb::SBBlock), + block); ref().block = block.GetPtr(); } void SBSymbolContext::SetLineEntry(lldb::SBLineEntry line_entry) { - LLDB_RECORD_METHOD(void, SBSymbolContext, SetLineEntry, (lldb::SBLineEntry), - line_entry); + LLDB_INSTRUMENT_METHOD(void, SBSymbolContext, SetLineEntry, + (lldb::SBLineEntry), line_entry); if (line_entry.IsValid()) ref().line_entry = line_entry.ref(); @@ -157,8 +160,8 @@ } void SBSymbolContext::SetSymbol(lldb::SBSymbol symbol) { - LLDB_RECORD_METHOD(void, SBSymbolContext, SetSymbol, (lldb::SBSymbol), - symbol); + LLDB_INSTRUMENT_METHOD(void, SBSymbolContext, SetSymbol, (lldb::SBSymbol), + symbol); ref().symbol = symbol.get(); } @@ -189,8 +192,8 @@ } bool SBSymbolContext::GetDescription(SBStream &description) { - LLDB_RECORD_METHOD(bool, SBSymbolContext, GetDescription, (lldb::SBStream &), - description); + LLDB_INSTRUMENT_METHOD(bool, SBSymbolContext, GetDescription, + (lldb::SBStream &), description); Stream &strm = description.ref(); @@ -205,10 +208,10 @@ 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_METHOD_CONST(lldb::SBSymbolContext, SBSymbolContext, + GetParentOfInlinedScope, + (const lldb::SBAddress &, lldb::SBAddress &), + curr_frame_pc, parent_frame_addr); SBSymbolContext sb_sc; if (m_opaque_up.get() && curr_frame_pc.IsValid()) { Index: lldb/source/API/SBSymbolContextList.cpp =================================================================== --- lldb/source/API/SBSymbolContextList.cpp +++ lldb/source/API/SBSymbolContextList.cpp @@ -7,22 +7,22 @@ //===----------------------------------------------------------------------===// #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_CONSTRUCTOR_NO_ARGS(SBSymbolContextList); } SBSymbolContextList::SBSymbolContextList(const SBSymbolContextList &rhs) { - LLDB_RECORD_CONSTRUCTOR(SBSymbolContextList, - (const lldb::SBSymbolContextList &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBSymbolContextList, + (const lldb::SBSymbolContextList &), rhs); m_opaque_up = clone(rhs.m_opaque_up); } @@ -31,9 +31,9 @@ const SBSymbolContextList &SBSymbolContextList:: operator=(const SBSymbolContextList &rhs) { - LLDB_RECORD_METHOD( - const lldb::SBSymbolContextList &, - SBSymbolContextList, operator=,(const lldb::SBSymbolContextList &), rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBSymbolContextList &, + SBSymbolContextList, operator=, + (const lldb::SBSymbolContextList &), rhs); if (this != &rhs) m_opaque_up = clone(rhs.m_opaque_up); @@ -41,7 +41,7 @@ } uint32_t SBSymbolContextList::GetSize() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBSymbolContextList, GetSize); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(uint32_t, SBSymbolContextList, GetSize); if (m_opaque_up) return m_opaque_up->GetSize(); @@ -49,8 +49,8 @@ } SBSymbolContext SBSymbolContextList::GetContextAtIndex(uint32_t idx) { - LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBSymbolContextList, - GetContextAtIndex, (uint32_t), idx); + LLDB_INSTRUMENT_METHOD(lldb::SBSymbolContext, SBSymbolContextList, + GetContextAtIndex, (uint32_t), idx); SBSymbolContext sb_sc; if (m_opaque_up) { @@ -62,34 +62,35 @@ } void SBSymbolContextList::Clear() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBSymbolContextList, Clear); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBSymbolContextList, Clear); if (m_opaque_up) m_opaque_up->Clear(); } void SBSymbolContextList::Append(SBSymbolContext &sc) { - LLDB_RECORD_METHOD(void, SBSymbolContextList, Append, - (lldb::SBSymbolContext &), sc); + LLDB_INSTRUMENT_METHOD(void, SBSymbolContextList, Append, + (lldb::SBSymbolContext &), sc); if (sc.IsValid() && m_opaque_up.get()) m_opaque_up->Append(*sc); } void SBSymbolContextList::Append(SBSymbolContextList &sc_list) { - LLDB_RECORD_METHOD(void, SBSymbolContextList, Append, - (lldb::SBSymbolContextList &), sc_list); + LLDB_INSTRUMENT_METHOD(void, SBSymbolContextList, Append, + (lldb::SBSymbolContextList &), sc_list); if (sc_list.IsValid() && m_opaque_up.get()) m_opaque_up->Append(*sc_list); } bool SBSymbolContextList::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContextList, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBSymbolContextList, IsValid); return this->operator bool(); } SBSymbolContextList::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContextList, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, + SBSymbolContextList, operator bool); return m_opaque_up != nullptr; } @@ -104,8 +105,8 @@ } bool SBSymbolContextList::GetDescription(lldb::SBStream &description) { - LLDB_RECORD_METHOD(bool, SBSymbolContextList, GetDescription, - (lldb::SBStream &), description); + LLDB_INSTRUMENT_METHOD(bool, SBSymbolContextList, GetDescription, + (lldb::SBStream &), description); Stream &strm = description.ref(); if (m_opaque_up) Index: lldb/source/API/SBTarget.cpp =================================================================== --- lldb/source/API/SBTarget.cpp +++ 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,19 @@ } // SBTarget constructor -SBTarget::SBTarget() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTarget); } +SBTarget::SBTarget() { LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBTarget); } SBTarget::SBTarget(const SBTarget &rhs) : m_opaque_sp(rhs.m_opaque_sp) { - LLDB_RECORD_CONSTRUCTOR(SBTarget, (const lldb::SBTarget &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBTarget, (const lldb::SBTarget &), rhs); } SBTarget::SBTarget(const TargetSP &target_sp) : m_opaque_sp(target_sp) { - LLDB_RECORD_CONSTRUCTOR(SBTarget, (const lldb::TargetSP &), target_sp); + LLDB_INSTRUMENT_CONSTRUCTOR(SBTarget, (const lldb::TargetSP &), target_sp); } const SBTarget &SBTarget::operator=(const SBTarget &rhs) { - LLDB_RECORD_METHOD(const lldb::SBTarget &, - SBTarget, operator=,(const lldb::SBTarget &), rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBTarget &, SBTarget, operator=, + (const lldb::SBTarget &), rhs); if (this != &rhs) m_opaque_sp = rhs.m_opaque_sp; @@ -116,22 +116,22 @@ SBTarget::~SBTarget() = default; bool SBTarget::EventIsTargetEvent(const SBEvent &event) { - LLDB_RECORD_STATIC_METHOD(bool, SBTarget, EventIsTargetEvent, - (const lldb::SBEvent &), event); + LLDB_INSTRUMENT_STATIC_METHOD(bool, SBTarget, EventIsTargetEvent, + (const lldb::SBEvent &), 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_STATIC_METHOD(lldb::SBTarget, SBTarget, GetTargetFromEvent, + (const lldb::SBEvent &), 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_STATIC_METHOD(uint32_t, SBTarget, GetNumModulesFromEvent, + (const lldb::SBEvent &), event); const ModuleList module_list = Target::TargetEventData::GetModuleListFromEvent(event.get()); @@ -140,9 +140,9 @@ 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_STATIC_METHOD( + lldb::SBModule, SBTarget, GetModuleAtIndexFromEvent, + (const uint32_t, const lldb::SBEvent &), idx, event); const ModuleList module_list = Target::TargetEventData::GetModuleListFromEvent(event.get()); @@ -150,24 +150,24 @@ } const char *SBTarget::GetBroadcasterClassName() { - LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBTarget, - GetBroadcasterClassName); + LLDB_INSTRUMENT_STATIC_METHOD_NO_ARGS(const char *, SBTarget, + GetBroadcasterClassName); return Target::GetStaticBroadcasterClass().AsCString(); } bool SBTarget::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTarget, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBTarget, IsValid); return this->operator bool(); } SBTarget::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTarget, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBTarget, operator bool); return m_opaque_sp.get() != nullptr && m_opaque_sp->IsValid(); } SBProcess SBTarget::GetProcess() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBTarget, GetProcess); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBProcess, SBTarget, GetProcess); SBProcess sb_process; ProcessSP process_sp; @@ -181,7 +181,7 @@ } SBPlatform SBTarget::GetPlatform() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBPlatform, SBTarget, GetPlatform); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBPlatform, SBTarget, GetPlatform); TargetSP target_sp(GetSP()); if (!target_sp) @@ -194,7 +194,7 @@ } SBDebugger SBTarget::GetDebugger() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBDebugger, SBTarget, GetDebugger); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::SBDebugger, SBTarget, GetDebugger); SBDebugger debugger; TargetSP target_sp(GetSP()); @@ -204,7 +204,8 @@ } SBStructuredData SBTarget::GetStatistics() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStructuredData, SBTarget, GetStatistics); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBStructuredData, SBTarget, + GetStatistics); SBStructuredData data; TargetSP target_sp(GetSP()); @@ -219,7 +220,7 @@ } void SBTarget::SetCollectingStats(bool v) { - LLDB_RECORD_METHOD(void, SBTarget, SetCollectingStats, (bool), v); + LLDB_INSTRUMENT_METHOD(void, SBTarget, SetCollectingStats, (bool), v); TargetSP target_sp(GetSP()); if (!target_sp) @@ -228,7 +229,7 @@ } bool SBTarget::GetCollectingStats() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, GetCollectingStats); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBTarget, GetCollectingStats); TargetSP target_sp(GetSP()); if (!target_sp) @@ -237,16 +238,16 @@ } SBProcess SBTarget::LoadCore(const char *core_file) { - LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, LoadCore, (const char *), - core_file); + LLDB_INSTRUMENT_METHOD(lldb::SBProcess, SBTarget, LoadCore, (const char *), + 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_METHOD(lldb::SBProcess, SBTarget, LoadCore, + (const char *, lldb::SBError &), core_file, error); SBProcess sb_process; TargetSP target_sp(GetSP()); @@ -270,9 +271,9 @@ 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_METHOD(lldb::SBProcess, SBTarget, LaunchSimple, + (const char **, const char **, const char *), argv, + envp, working_directory); TargetSP target_sp = GetSP(); if (!target_sp) @@ -295,7 +296,7 @@ } SBError SBTarget::Install() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBTarget, Install); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBError, SBTarget, Install); SBError sb_error; TargetSP target_sp(GetSP()); @@ -312,12 +313,13 @@ 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_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); SBProcess sb_process; ProcessSP process_sp; @@ -395,10 +397,9 @@ } 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_METHOD(lldb::SBProcess, SBTarget, Launch, + (lldb::SBLaunchInfo &, lldb::SBError &), + sb_launch_info, error); SBProcess sb_process; TargetSP target_sp(GetSP()); @@ -444,9 +445,9 @@ } 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_METHOD(lldb::SBProcess, SBTarget, Attach, + (lldb::SBAttachInfo &, lldb::SBError &), + sb_attach_info, error); SBProcess sb_process; TargetSP target_sp(GetSP()); @@ -483,9 +484,9 @@ 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_METHOD(lldb::SBProcess, SBTarget, AttachToProcessWithID, + (lldb::SBListener &, lldb::pid_t, lldb::SBError &), + listener, pid, error); SBProcess sb_process; TargetSP target_sp(GetSP()); @@ -515,9 +516,10 @@ 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_METHOD( + lldb::SBProcess, SBTarget, AttachToProcessWithName, + (lldb::SBListener &, const char *, bool, lldb::SBError &), listener, name, + wait_for, error); SBProcess sb_process; TargetSP target_sp(GetSP()); @@ -541,7 +543,7 @@ lldb::SBProcess SBTarget::ConnectRemote(SBListener &listener, const char *url, const char *plugin_name, SBError &error) { - LLDB_RECORD_METHOD( + LLDB_INSTRUMENT_METHOD( lldb::SBProcess, SBTarget, ConnectRemote, (lldb::SBListener &, const char *, const char *, lldb::SBError &), listener, url, plugin_name, error); @@ -574,7 +576,7 @@ } SBFileSpec SBTarget::GetExecutable() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBTarget, GetExecutable); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBFileSpec, SBTarget, GetExecutable); SBFileSpec exe_file_spec; TargetSP target_sp(GetSP()); @@ -588,15 +590,15 @@ } bool SBTarget::operator==(const SBTarget &rhs) const { - LLDB_RECORD_METHOD_CONST(bool, SBTarget, operator==,(const lldb::SBTarget &), - rhs); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBTarget, operator==, + (const lldb::SBTarget &), rhs); return m_opaque_sp.get() == rhs.m_opaque_sp.get(); } bool SBTarget::operator!=(const SBTarget &rhs) const { - LLDB_RECORD_METHOD_CONST(bool, SBTarget, operator!=,(const lldb::SBTarget &), - rhs); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBTarget, operator!=, + (const lldb::SBTarget &), rhs); return m_opaque_sp.get() != rhs.m_opaque_sp.get(); } @@ -608,8 +610,8 @@ } lldb::SBAddress SBTarget::ResolveLoadAddress(lldb::addr_t vm_addr) { - LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolveLoadAddress, - (lldb::addr_t), vm_addr); + LLDB_INSTRUMENT_METHOD(lldb::SBAddress, SBTarget, ResolveLoadAddress, + (lldb::addr_t), vm_addr); lldb::SBAddress sb_addr; Address &addr = sb_addr.ref(); @@ -627,8 +629,8 @@ } lldb::SBAddress SBTarget::ResolveFileAddress(lldb::addr_t file_addr) { - LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolveFileAddress, - (lldb::addr_t), file_addr); + LLDB_INSTRUMENT_METHOD(lldb::SBAddress, SBTarget, ResolveFileAddress, + (lldb::addr_t), file_addr); lldb::SBAddress sb_addr; Address &addr = sb_addr.ref(); @@ -645,8 +647,8 @@ 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_METHOD(lldb::SBAddress, SBTarget, ResolvePastLoadAddress, + (uint32_t, lldb::addr_t), stop_id, vm_addr); lldb::SBAddress sb_addr; Address &addr = sb_addr.ref(); @@ -666,9 +668,9 @@ 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_METHOD( + lldb::SBSymbolContext, SBTarget, ResolveSymbolContextForAddress, + (const lldb::SBAddress &, uint32_t), addr, resolve_scope); SBSymbolContext sc; SymbolContextItem scope = static_cast(resolve_scope); @@ -683,9 +685,10 @@ 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_METHOD( + size_t, SBTarget, ReadMemory, + (const lldb::SBAddress, void *, size_t, lldb::SBError &), addr, buf, size, + error); SBError sb_error; size_t bytes_read = 0; @@ -703,8 +706,9 @@ SBBreakpoint SBTarget::BreakpointCreateByLocation(const char *file, uint32_t line) { - LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation, - (const char *, uint32_t), file, line); + LLDB_INSTRUMENT_METHOD(lldb::SBBreakpoint, SBTarget, + BreakpointCreateByLocation, (const char *, uint32_t), + file, line); return SBBreakpoint( BreakpointCreateByLocation(SBFileSpec(file, false), line)); @@ -713,8 +717,9 @@ 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_METHOD( + lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation, + (const lldb::SBFileSpec &, uint32_t), sb_file_spec, line); return BreakpointCreateByLocation(sb_file_spec, line, 0); } @@ -722,9 +727,10 @@ 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_METHOD(lldb::SBBreakpoint, SBTarget, + BreakpointCreateByLocation, + (const lldb::SBFileSpec &, uint32_t, lldb::addr_t), + sb_file_spec, line, offset); SBFileSpecList empty_list; return BreakpointCreateByLocation(sb_file_spec, line, offset, empty_list); @@ -734,10 +740,11 @@ 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_METHOD(lldb::SBBreakpoint, SBTarget, + BreakpointCreateByLocation, + (const lldb::SBFileSpec &, uint32_t, lldb::addr_t, + lldb::SBFileSpecList &), + sb_file_spec, line, offset, sb_module_list); return BreakpointCreateByLocation(sb_file_spec, line, 0, offset, sb_module_list); @@ -746,10 +753,11 @@ 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_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); SBBreakpoint sb_bp; TargetSP target_sp(GetSP()); @@ -777,11 +785,11 @@ 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, - move_to_nearest_code); + LLDB_INSTRUMENT_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, move_to_nearest_code); SBBreakpoint sb_bp; TargetSP target_sp(GetSP()); @@ -807,8 +815,9 @@ 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_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName, + (const char *, const char *), symbol_name, + module_name); SBBreakpoint sb_bp; TargetSP target_sp(GetSP()); @@ -839,10 +848,10 @@ 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_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName, + (const char *, const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &), + symbol_name, module_list, comp_unit_list); lldb::FunctionNameType name_type_mask = eFunctionNameTypeAuto; return BreakpointCreateByName(symbol_name, name_type_mask, @@ -853,10 +862,11 @@ 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_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName, + (const char *, uint32_t, const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &), + symbol_name, name_type_mask, module_list, + comp_unit_list); return BreakpointCreateByName(symbol_name, name_type_mask, eLanguageTypeUnknown, module_list, @@ -867,12 +877,12 @@ 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_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); SBBreakpoint sb_bp; TargetSP target_sp(GetSP()); @@ -893,7 +903,7 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateByNames( const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask, const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { - LLDB_RECORD_METHOD( + LLDB_INSTRUMENT_METHOD( lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames, (const char **, uint32_t, uint32_t, const lldb::SBFileSpecList &, const lldb::SBFileSpecList &), @@ -908,12 +918,12 @@ 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_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames, + (const char **, uint32_t, uint32_t, lldb::LanguageType, + const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &), + symbol_names, num_names, name_type_mask, + symbol_language, module_list, comp_unit_list); return BreakpointCreateByNames(symbol_names, num_names, name_type_mask, eLanguageTypeUnknown, 0, module_list, @@ -924,12 +934,12 @@ 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_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); SBBreakpoint sb_bp; TargetSP target_sp(GetSP()); @@ -949,9 +959,9 @@ 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_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex, + (const char *, const char *), symbol_name_regex, + module_name); SBFileSpecList module_spec_list; SBFileSpecList comp_unit_list; @@ -966,10 +976,10 @@ 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_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex, + (const char *, const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &), + symbol_name_regex, module_list, comp_unit_list); return BreakpointCreateByRegex(symbol_name_regex, eLanguageTypeUnknown, module_list, comp_unit_list); @@ -978,13 +988,12 @@ 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_INSTRUMENT_METHOD( lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex, (const char *, lldb::LanguageType, const lldb::SBFileSpecList &, const lldb::SBFileSpecList &), symbol_name_regex, symbol_language, module_list, comp_unit_list); - SBBreakpoint sb_bp; TargetSP target_sp(GetSP()); if (target_sp && symbol_name_regex && symbol_name_regex[0]) { @@ -1003,8 +1012,8 @@ } SBBreakpoint SBTarget::BreakpointCreateByAddress(addr_t address) { - LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByAddress, - (lldb::addr_t), address); + LLDB_INSTRUMENT_METHOD(lldb::SBBreakpoint, SBTarget, + BreakpointCreateByAddress, (lldb::addr_t), address); SBBreakpoint sb_bp; TargetSP target_sp(GetSP()); @@ -1018,8 +1027,9 @@ } SBBreakpoint SBTarget::BreakpointCreateBySBAddress(SBAddress &sb_address) { - LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateBySBAddress, - (lldb::SBAddress &), sb_address); + LLDB_INSTRUMENT_METHOD(lldb::SBBreakpoint, SBTarget, + BreakpointCreateBySBAddress, (lldb::SBAddress &), + sb_address); SBBreakpoint sb_bp; TargetSP target_sp(GetSP()); @@ -1040,10 +1050,10 @@ 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_METHOD(lldb::SBBreakpoint, SBTarget, + BreakpointCreateBySourceRegex, + (const char *, const lldb::SBFileSpec &, const char *), + source_regex, source_file, module_name); SBFileSpecList module_spec_list; @@ -1063,11 +1073,11 @@ 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_METHOD(lldb::SBBreakpoint, SBTarget, + BreakpointCreateBySourceRegex, + (const char *, const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &), + source_regex, module_list, source_file_list); return BreakpointCreateBySourceRegex(source_regex, module_list, source_file_list, SBStringList()); @@ -1077,11 +1087,11 @@ 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_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); SBBreakpoint sb_bp; TargetSP target_sp(GetSP()); @@ -1106,9 +1116,9 @@ 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_METHOD( + lldb::SBBreakpoint, SBTarget, BreakpointCreateForException, + (lldb::LanguageType, bool, bool), language, catch_bp, throw_bp); SBBreakpoint sb_bp; TargetSP target_sp(GetSP()); @@ -1126,7 +1136,7 @@ const char *class_name, SBStructuredData &extra_args, const SBFileSpecList &module_list, const SBFileSpecList &file_list, bool request_hardware) { - LLDB_RECORD_METHOD( + LLDB_INSTRUMENT_METHOD( lldb::SBBreakpoint, SBTarget, BreakpointCreateFromScript, (const char *, lldb::SBStructuredData &, const lldb::SBFileSpecList &, const lldb::SBFileSpecList &, bool), @@ -1153,7 +1163,7 @@ } uint32_t SBTarget::GetNumBreakpoints() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumBreakpoints); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumBreakpoints); TargetSP target_sp(GetSP()); if (target_sp) { @@ -1164,8 +1174,8 @@ } SBBreakpoint SBTarget::GetBreakpointAtIndex(uint32_t idx) const { - LLDB_RECORD_METHOD_CONST(lldb::SBBreakpoint, SBTarget, GetBreakpointAtIndex, - (uint32_t), idx); + LLDB_INSTRUMENT_METHOD_CONST(lldb::SBBreakpoint, SBTarget, + GetBreakpointAtIndex, (uint32_t), idx); SBBreakpoint sb_breakpoint; TargetSP target_sp(GetSP()); @@ -1177,8 +1187,8 @@ } bool SBTarget::BreakpointDelete(break_id_t bp_id) { - LLDB_RECORD_METHOD(bool, SBTarget, BreakpointDelete, (lldb::break_id_t), - bp_id); + LLDB_INSTRUMENT_METHOD(bool, SBTarget, BreakpointDelete, (lldb::break_id_t), + bp_id); bool result = false; TargetSP target_sp(GetSP()); @@ -1191,8 +1201,8 @@ } SBBreakpoint SBTarget::FindBreakpointByID(break_id_t bp_id) { - LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, FindBreakpointByID, - (lldb::break_id_t), bp_id); + LLDB_INSTRUMENT_METHOD(lldb::SBBreakpoint, SBTarget, FindBreakpointByID, + (lldb::break_id_t), bp_id); SBBreakpoint sb_breakpoint; TargetSP target_sp(GetSP()); @@ -1206,8 +1216,8 @@ bool SBTarget::FindBreakpointsByName(const char *name, SBBreakpointList &bkpts) { - LLDB_RECORD_METHOD(bool, SBTarget, FindBreakpointsByName, - (const char *, lldb::SBBreakpointList &), name, bkpts); + LLDB_INSTRUMENT_METHOD(bool, SBTarget, FindBreakpointsByName, + (const char *, lldb::SBBreakpointList &), name, bkpts); TargetSP target_sp(GetSP()); if (target_sp) { @@ -1228,8 +1238,8 @@ } void SBTarget::GetBreakpointNames(SBStringList &names) { - LLDB_RECORD_METHOD(void, SBTarget, GetBreakpointNames, (lldb::SBStringList &), - names); + LLDB_INSTRUMENT_METHOD(void, SBTarget, GetBreakpointNames, + (lldb::SBStringList &), names); names.Clear(); @@ -1245,8 +1255,8 @@ } void SBTarget::DeleteBreakpointName(const char *name) { - LLDB_RECORD_METHOD(void, SBTarget, DeleteBreakpointName, (const char *), - name); + LLDB_INSTRUMENT_METHOD(void, SBTarget, DeleteBreakpointName, (const char *), + name); TargetSP target_sp(GetSP()); if (target_sp) { @@ -1256,7 +1266,7 @@ } bool SBTarget::EnableAllBreakpoints() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, EnableAllBreakpoints); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBTarget, EnableAllBreakpoints); TargetSP target_sp(GetSP()); if (target_sp) { @@ -1268,7 +1278,7 @@ } bool SBTarget::DisableAllBreakpoints() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DisableAllBreakpoints); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBTarget, DisableAllBreakpoints); TargetSP target_sp(GetSP()); if (target_sp) { @@ -1280,7 +1290,7 @@ } bool SBTarget::DeleteAllBreakpoints() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DeleteAllBreakpoints); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBTarget, DeleteAllBreakpoints); TargetSP target_sp(GetSP()); if (target_sp) { @@ -1293,9 +1303,9 @@ 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_METHOD(lldb::SBError, SBTarget, BreakpointsCreateFromFile, + (lldb::SBFileSpec &, lldb::SBBreakpointList &), + source_file, new_bps); SBStringList empty_name_list; return BreakpointsCreateFromFile(source_file, empty_name_list, new_bps); @@ -1304,7 +1314,7 @@ lldb::SBError SBTarget::BreakpointsCreateFromFile(SBFileSpec &source_file, SBStringList &matching_names, SBBreakpointList &new_bps) { - LLDB_RECORD_METHOD( + LLDB_INSTRUMENT_METHOD( lldb::SBError, SBTarget, BreakpointsCreateFromFile, (lldb::SBFileSpec &, lldb::SBStringList &, lldb::SBBreakpointList &), source_file, matching_names, new_bps); @@ -1339,8 +1349,8 @@ } lldb::SBError SBTarget::BreakpointsWriteToFile(SBFileSpec &dest_file) { - LLDB_RECORD_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile, - (lldb::SBFileSpec &), dest_file); + LLDB_INSTRUMENT_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile, + (lldb::SBFileSpec &), dest_file); SBError sberr; TargetSP target_sp(GetSP()); @@ -1355,9 +1365,9 @@ 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_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile, + (lldb::SBFileSpec &, lldb::SBBreakpointList &, bool), + dest_file, bkpt_list, append); SBError sberr; TargetSP target_sp(GetSP()); @@ -1375,7 +1385,7 @@ } uint32_t SBTarget::GetNumWatchpoints() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumWatchpoints); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumWatchpoints); TargetSP target_sp(GetSP()); if (target_sp) { @@ -1386,8 +1396,8 @@ } SBWatchpoint SBTarget::GetWatchpointAtIndex(uint32_t idx) const { - LLDB_RECORD_METHOD_CONST(lldb::SBWatchpoint, SBTarget, GetWatchpointAtIndex, - (uint32_t), idx); + LLDB_INSTRUMENT_METHOD_CONST(lldb::SBWatchpoint, SBTarget, + GetWatchpointAtIndex, (uint32_t), idx); SBWatchpoint sb_watchpoint; TargetSP target_sp(GetSP()); @@ -1399,9 +1409,8 @@ } bool SBTarget::DeleteWatchpoint(watch_id_t wp_id) { - LLDB_RECORD_METHOD(bool, SBTarget, DeleteWatchpoint, (lldb::watch_id_t), - wp_id); - + LLDB_INSTRUMENT_METHOD(bool, SBTarget, DeleteWatchpoint, (lldb::watch_id_t), + wp_id); bool result = false; TargetSP target_sp(GetSP()); @@ -1416,9 +1425,8 @@ } SBWatchpoint SBTarget::FindWatchpointByID(lldb::watch_id_t wp_id) { - LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBTarget, FindWatchpointByID, - (lldb::watch_id_t), wp_id); - + LLDB_INSTRUMENT_METHOD(lldb::SBWatchpoint, SBTarget, FindWatchpointByID, + (lldb::watch_id_t), wp_id); SBWatchpoint sb_watchpoint; lldb::WatchpointSP watchpoint_sp; @@ -1437,9 +1445,9 @@ 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_METHOD(lldb::SBWatchpoint, SBTarget, WatchAddress, + (lldb::addr_t, size_t, bool, bool, lldb::SBError &), + addr, size, read, write, error); SBWatchpoint sb_watchpoint; lldb::WatchpointSP watchpoint_sp; @@ -1472,7 +1480,7 @@ } bool SBTarget::EnableAllWatchpoints() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, EnableAllWatchpoints); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBTarget, EnableAllWatchpoints); TargetSP target_sp(GetSP()); if (target_sp) { @@ -1486,7 +1494,7 @@ } bool SBTarget::DisableAllWatchpoints() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DisableAllWatchpoints); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBTarget, DisableAllWatchpoints); TargetSP target_sp(GetSP()); if (target_sp) { @@ -1501,9 +1509,9 @@ 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_METHOD(lldb::SBValue, SBTarget, CreateValueFromAddress, + (const char *, lldb::SBAddress, lldb::SBType), name, + addr, type); SBValue sb_value; lldb::ValueObjectSP new_value_sp; @@ -1521,9 +1529,9 @@ 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_METHOD(lldb::SBValue, SBTarget, CreateValueFromData, + (const char *, lldb::SBData, lldb::SBType), name, data, + type); SBValue sb_value; lldb::ValueObjectSP new_value_sp; @@ -1541,8 +1549,8 @@ 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_METHOD(lldb::SBValue, SBTarget, CreateValueFromExpression, + (const char *, const char *), name, expr); SBValue sb_value; lldb::ValueObjectSP new_value_sp; @@ -1557,7 +1565,7 @@ } bool SBTarget::DeleteAllWatchpoints() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DeleteAllWatchpoints); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBTarget, DeleteAllWatchpoints); TargetSP target_sp(GetSP()); if (target_sp) { @@ -1572,9 +1580,9 @@ 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_METHOD(void, SBTarget, AppendImageSearchPath, + (const char *, const char *, lldb::SBError &), from, + to, error); TargetSP target_sp(GetSP()); if (!target_sp) @@ -1591,18 +1599,19 @@ 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_METHOD(lldb::SBModule, SBTarget, AddModule, + (const char *, const char *, const char *), 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_METHOD( + lldb::SBModule, SBTarget, AddModule, + (const char *, const char *, const char *, const char *), path, triple, + uuid_cstr, symfile); lldb::SBModule sb_module; TargetSP target_sp(GetSP()); @@ -1629,8 +1638,8 @@ } lldb::SBModule SBTarget::AddModule(const SBModuleSpec &module_spec) { - LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule, - (const lldb::SBModuleSpec &), module_spec); + LLDB_INSTRUMENT_METHOD(lldb::SBModule, SBTarget, AddModule, + (const lldb::SBModuleSpec &), module_spec); lldb::SBModule sb_module; TargetSP target_sp(GetSP()); @@ -1641,7 +1650,7 @@ } bool SBTarget::AddModule(lldb::SBModule &module) { - LLDB_RECORD_METHOD(bool, SBTarget, AddModule, (lldb::SBModule &), module); + LLDB_INSTRUMENT_METHOD(bool, SBTarget, AddModule, (lldb::SBModule &), module); TargetSP target_sp(GetSP()); if (target_sp) { @@ -1652,7 +1661,7 @@ } uint32_t SBTarget::GetNumModules() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumModules); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumModules); uint32_t num = 0; TargetSP target_sp(GetSP()); @@ -1665,14 +1674,14 @@ } void SBTarget::Clear() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBTarget, Clear); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBTarget, Clear); 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_METHOD(lldb::SBModule, SBTarget, FindModule, + (const lldb::SBFileSpec &), sb_file_spec); SBModule sb_module; TargetSP target_sp(GetSP()); @@ -1685,8 +1694,8 @@ } SBSymbolContextList SBTarget::FindCompileUnits(const SBFileSpec &sb_file_spec) { - LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindCompileUnits, - (const lldb::SBFileSpec &), sb_file_spec); + LLDB_INSTRUMENT_METHOD(lldb::SBSymbolContextList, SBTarget, FindCompileUnits, + (const lldb::SBFileSpec &), sb_file_spec); SBSymbolContextList sb_sc_list; const TargetSP target_sp(GetSP()); @@ -1696,7 +1705,7 @@ } lldb::ByteOrder SBTarget::GetByteOrder() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::ByteOrder, SBTarget, GetByteOrder); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::ByteOrder, SBTarget, GetByteOrder); TargetSP target_sp(GetSP()); if (target_sp) @@ -1705,7 +1714,7 @@ } const char *SBTarget::GetTriple() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTarget, GetTriple); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBTarget, GetTriple); TargetSP target_sp(GetSP()); if (target_sp) { @@ -1720,7 +1729,7 @@ } uint32_t SBTarget::GetDataByteSize() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTarget, GetDataByteSize); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBTarget, GetDataByteSize); TargetSP target_sp(GetSP()); if (target_sp) { @@ -1730,7 +1739,7 @@ } uint32_t SBTarget::GetCodeByteSize() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTarget, GetCodeByteSize); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBTarget, GetCodeByteSize); TargetSP target_sp(GetSP()); if (target_sp) { @@ -1740,7 +1749,8 @@ } uint32_t SBTarget::GetMaximumNumberOfChildrenToDisplay() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetMaximumNumberOfChildrenToDisplay); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, + GetMaximumNumberOfChildrenToDisplay); TargetSP target_sp(GetSP()); if(target_sp){ @@ -1750,7 +1760,7 @@ } uint32_t SBTarget::GetAddressByteSize() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTarget, GetAddressByteSize); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBTarget, GetAddressByteSize); TargetSP target_sp(GetSP()); if (target_sp) @@ -1759,8 +1769,8 @@ } SBModule SBTarget::GetModuleAtIndex(uint32_t idx) { - LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, GetModuleAtIndex, (uint32_t), - idx); + LLDB_INSTRUMENT_METHOD(lldb::SBModule, SBTarget, GetModuleAtIndex, (uint32_t), + idx); SBModule sb_module; ModuleSP module_sp; @@ -1775,7 +1785,8 @@ } bool SBTarget::RemoveModule(lldb::SBModule module) { - LLDB_RECORD_METHOD(bool, SBTarget, RemoveModule, (lldb::SBModule), module); + LLDB_INSTRUMENT_METHOD(bool, SBTarget, RemoveModule, (lldb::SBModule), + module); TargetSP target_sp(GetSP()); if (target_sp) @@ -1784,9 +1795,8 @@ } SBBroadcaster SBTarget::GetBroadcaster() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBTarget, - GetBroadcaster); - + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBTarget, + GetBroadcaster); TargetSP target_sp(GetSP()); SBBroadcaster broadcaster(target_sp.get(), false); @@ -1796,9 +1806,9 @@ bool SBTarget::GetDescription(SBStream &description, lldb::DescriptionLevel description_level) { - LLDB_RECORD_METHOD(bool, SBTarget, GetDescription, - (lldb::SBStream &, lldb::DescriptionLevel), description, - description_level); + LLDB_INSTRUMENT_METHOD(bool, SBTarget, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel), + description, description_level); Stream &strm = description.ref(); @@ -1813,8 +1823,8 @@ 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_METHOD(lldb::SBSymbolContextList, SBTarget, FindFunctions, + (const char *, uint32_t), name, name_type_mask); lldb::SBSymbolContextList sb_sc_list; if (!name || !name[0]) @@ -1837,9 +1847,9 @@ 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_METHOD( + lldb::SBSymbolContextList, SBTarget, FindGlobalFunctions, + (const char *, uint32_t, lldb::MatchType), name, max_matches, matchtype); lldb::SBSymbolContextList sb_sc_list; if (name && name[0]) { @@ -1873,8 +1883,8 @@ } lldb::SBType SBTarget::FindFirstType(const char *typename_cstr) { - LLDB_RECORD_METHOD(lldb::SBType, SBTarget, FindFirstType, (const char *), - typename_cstr); + LLDB_INSTRUMENT_METHOD(lldb::SBType, SBTarget, FindFirstType, (const char *), + typename_cstr); TargetSP target_sp(GetSP()); if (typename_cstr && typename_cstr[0] && target_sp) { @@ -1915,8 +1925,8 @@ } SBType SBTarget::GetBasicType(lldb::BasicType type) { - LLDB_RECORD_METHOD(lldb::SBType, SBTarget, GetBasicType, (lldb::BasicType), - type); + LLDB_INSTRUMENT_METHOD(lldb::SBType, SBTarget, GetBasicType, + (lldb::BasicType), type); TargetSP target_sp(GetSP()); if (target_sp) { @@ -1928,8 +1938,8 @@ } lldb::SBTypeList SBTarget::FindTypes(const char *typename_cstr) { - LLDB_RECORD_METHOD(lldb::SBTypeList, SBTarget, FindTypes, (const char *), - typename_cstr); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeList, SBTarget, FindTypes, (const char *), + typename_cstr); SBTypeList sb_type_list; TargetSP target_sp(GetSP()); @@ -1973,8 +1983,8 @@ 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_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables, + (const char *, uint32_t), name, max_matches); SBValueList sb_value_list; @@ -2002,9 +2012,9 @@ 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_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables, + (const char *, uint32_t, lldb::MatchType), name, + max_matches, matchtype); SBValueList sb_value_list; @@ -2046,8 +2056,8 @@ } lldb::SBValue SBTarget::FindFirstGlobalVariable(const char *name) { - LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, FindFirstGlobalVariable, - (const char *), name); + LLDB_INSTRUMENT_METHOD(lldb::SBValue, SBTarget, FindFirstGlobalVariable, + (const char *), name); SBValueList sb_value_list(FindGlobalVariables(name, 1)); if (sb_value_list.IsValid() && sb_value_list.GetSize() > 0) @@ -2056,7 +2066,8 @@ } SBSourceManager SBTarget::GetSourceManager() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSourceManager, SBTarget, GetSourceManager); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBSourceManager, SBTarget, + GetSourceManager); SBSourceManager source_manager(*this); return source_manager; @@ -2064,8 +2075,8 @@ 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_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions, + (lldb::SBAddress, uint32_t), base_addr, count); return ReadInstructions(base_addr, count, nullptr); } @@ -2073,9 +2084,9 @@ 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_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions, + (lldb::SBAddress, uint32_t, const char *), base_addr, + count, flavor_string); SBInstructionList sb_instructions; @@ -2105,9 +2116,9 @@ 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_METHOD(lldb::SBInstructionList, SBTarget, GetInstructions, + (lldb::SBAddress, const void *, size_t), base_addr, + buf, size); return GetInstructionsWithFlavor(base_addr, nullptr, buf, size); } @@ -2116,10 +2127,10 @@ 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_METHOD(lldb::SBInstructionList, SBTarget, + GetInstructionsWithFlavor, + (lldb::SBAddress, const char *, const void *, size_t), + base_addr, flavor_string, buf, size); SBInstructionList sb_instructions; @@ -2143,9 +2154,9 @@ 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_METHOD(lldb::SBInstructionList, SBTarget, GetInstructions, + (lldb::addr_t, const void *, size_t), base_addr, buf, + size); return GetInstructionsWithFlavor(ResolveLoadAddress(base_addr), nullptr, buf, size); @@ -2155,10 +2166,10 @@ 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_METHOD(lldb::SBInstructionList, SBTarget, + GetInstructionsWithFlavor, + (lldb::addr_t, const char *, const void *, size_t), + base_addr, flavor_string, buf, size); return GetInstructionsWithFlavor(ResolveLoadAddress(base_addr), flavor_string, buf, size); @@ -2166,9 +2177,9 @@ 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_METHOD(lldb::SBError, SBTarget, SetSectionLoadAddress, + (lldb::SBSection, lldb::addr_t), section, + section_base_addr); SBError sb_error; TargetSP target_sp(GetSP()); @@ -2204,8 +2215,8 @@ } SBError SBTarget::ClearSectionLoadAddress(lldb::SBSection section) { - LLDB_RECORD_METHOD(lldb::SBError, SBTarget, ClearSectionLoadAddress, - (lldb::SBSection), section); + LLDB_INSTRUMENT_METHOD(lldb::SBError, SBTarget, ClearSectionLoadAddress, + (lldb::SBSection), section); SBError sb_error; @@ -2240,8 +2251,8 @@ 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_METHOD(lldb::SBError, SBTarget, SetModuleLoadAddress, + (lldb::SBModule, int64_t), module, slide_offset); SBError sb_error; @@ -2274,8 +2285,8 @@ } SBError SBTarget::ClearModuleLoadAddress(lldb::SBModule module) { - LLDB_RECORD_METHOD(lldb::SBError, SBTarget, ClearModuleLoadAddress, - (lldb::SBModule), module); + LLDB_INSTRUMENT_METHOD(lldb::SBError, SBTarget, ClearModuleLoadAddress, + (lldb::SBModule), module); SBError sb_error; @@ -2327,8 +2338,8 @@ 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_METHOD(lldb::SBSymbolContextList, SBTarget, FindSymbols, + (const char *, lldb::SymbolType), name, symbol_type); SBSymbolContextList sb_sc_list; if (name && name[0]) { @@ -2341,8 +2352,8 @@ } lldb::SBValue SBTarget::EvaluateExpression(const char *expr) { - LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, EvaluateExpression, - (const char *), expr); + LLDB_INSTRUMENT_METHOD(lldb::SBValue, SBTarget, EvaluateExpression, + (const char *), expr); TargetSP target_sp(GetSP()); if (!target_sp) @@ -2358,9 +2369,9 @@ 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_METHOD(lldb::SBValue, SBTarget, EvaluateExpression, + (const char *, const lldb::SBExpressionOptions &), + expr, options); Log *expr_log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); SBValue expr_result; @@ -2393,7 +2404,7 @@ } lldb::addr_t SBTarget::GetStackRedZoneSize() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBTarget, GetStackRedZoneSize); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::addr_t, SBTarget, GetStackRedZoneSize); TargetSP target_sp(GetSP()); if (target_sp) { @@ -2410,8 +2421,8 @@ } bool SBTarget::IsLoaded(const SBModule &module) const { - LLDB_RECORD_METHOD_CONST(bool, SBTarget, IsLoaded, (const lldb::SBModule &), - module); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBTarget, IsLoaded, + (const lldb::SBModule &), module); TargetSP target_sp(GetSP()); if (!target_sp) @@ -2425,7 +2436,8 @@ } lldb::SBLaunchInfo SBTarget::GetLaunchInfo() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBLaunchInfo, SBTarget, GetLaunchInfo); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::SBLaunchInfo, SBTarget, + GetLaunchInfo); lldb::SBLaunchInfo launch_info(nullptr); TargetSP target_sp(GetSP()); @@ -2435,8 +2447,8 @@ } void SBTarget::SetLaunchInfo(const lldb::SBLaunchInfo &launch_info) { - LLDB_RECORD_METHOD(void, SBTarget, SetLaunchInfo, - (const lldb::SBLaunchInfo &), launch_info); + LLDB_INSTRUMENT_METHOD(void, SBTarget, SetLaunchInfo, + (const lldb::SBLaunchInfo &), launch_info); TargetSP target_sp(GetSP()); if (target_sp) @@ -2444,7 +2456,7 @@ } SBEnvironment SBTarget::GetEnvironment() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBEnvironment, SBTarget, GetEnvironment); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBEnvironment, SBTarget, GetEnvironment); TargetSP target_sp(GetSP()); if (target_sp) { @@ -2455,7 +2467,7 @@ } lldb::SBTrace SBTarget::GetTrace() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTrace, SBTarget, GetTrace); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBTrace, SBTarget, GetTrace); TargetSP target_sp(GetSP()); if (target_sp) @@ -2465,8 +2477,8 @@ } lldb::SBTrace SBTarget::CreateTrace(lldb::SBError &error) { - LLDB_RECORD_METHOD(lldb::SBTrace, SBTarget, CreateTrace, (lldb::SBError &), - error); + LLDB_INSTRUMENT_METHOD(lldb::SBTrace, SBTarget, CreateTrace, + (lldb::SBError &), error); TargetSP target_sp(GetSP()); error.Clear(); Index: lldb/source/API/SBThread.cpp =================================================================== --- lldb/source/API/SBThread.cpp +++ 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,25 @@ using namespace lldb_private; const char *SBThread::GetBroadcasterClassName() { - LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBThread, - GetBroadcasterClassName); + LLDB_INSTRUMENT_STATIC_METHOD_NO_ARGS(const char *, SBThread, + GetBroadcasterClassName); return Thread::GetStaticBroadcasterClass().AsCString(); } // Constructors SBThread::SBThread() : m_opaque_sp(new ExecutionContextRef()) { - LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBThread); + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBThread); } 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_CONSTRUCTOR(SBThread, (const lldb::ThreadSP &), + lldb_object_sp); } SBThread::SBThread(const SBThread &rhs) { - LLDB_RECORD_CONSTRUCTOR(SBThread, (const lldb::SBThread &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBThread, (const lldb::SBThread &), rhs); m_opaque_sp = clone(rhs.m_opaque_sp); } @@ -76,8 +77,8 @@ // Assignment operator const lldb::SBThread &SBThread::operator=(const SBThread &rhs) { - LLDB_RECORD_METHOD(const lldb::SBThread &, - SBThread, operator=,(const lldb::SBThread &), rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBThread &, SBThread, operator=, + (const lldb::SBThread &), rhs); if (this != &rhs) m_opaque_sp = clone(rhs.m_opaque_sp); @@ -88,7 +89,7 @@ SBThread::~SBThread() = default; lldb::SBQueue SBThread::GetQueue() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBQueue, SBThread, GetQueue); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::SBQueue, SBThread, GetQueue); SBQueue sb_queue; QueueSP queue_sp; @@ -109,11 +110,11 @@ } bool SBThread::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThread, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBThread, IsValid); return this->operator bool(); } SBThread::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThread, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBThread, operator bool); std::unique_lock lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -130,13 +131,13 @@ } void SBThread::Clear() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBThread, Clear); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBThread, Clear); m_opaque_sp->Clear(); } StopReason SBThread::GetStopReason() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::StopReason, SBThread, GetStopReason); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::StopReason, SBThread, GetStopReason); StopReason reason = eStopReasonInvalid; std::unique_lock lock; @@ -153,7 +154,7 @@ } size_t SBThread::GetStopReasonDataCount() { - LLDB_RECORD_METHOD_NO_ARGS(size_t, SBThread, GetStopReasonDataCount); + LLDB_INSTRUMENT_METHOD_NO_ARGS(size_t, SBThread, GetStopReasonDataCount); std::unique_lock lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -210,8 +211,8 @@ } uint64_t SBThread::GetStopReasonDataAtIndex(uint32_t idx) { - LLDB_RECORD_METHOD(uint64_t, SBThread, GetStopReasonDataAtIndex, (uint32_t), - idx); + LLDB_INSTRUMENT_METHOD(uint64_t, SBThread, GetStopReasonDataAtIndex, + (uint32_t), idx); std::unique_lock lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -280,8 +281,8 @@ } bool SBThread::GetStopReasonExtendedInfoAsJSON(lldb::SBStream &stream) { - LLDB_RECORD_METHOD(bool, SBThread, GetStopReasonExtendedInfoAsJSON, - (lldb::SBStream &), stream); + LLDB_INSTRUMENT_METHOD(bool, SBThread, GetStopReasonExtendedInfoAsJSON, + (lldb::SBStream &), stream); Stream &strm = stream.ref(); @@ -303,9 +304,9 @@ SBThreadCollection SBThread::GetStopReasonExtendedBacktraces(InstrumentationRuntimeType type) { - LLDB_RECORD_METHOD(lldb::SBThreadCollection, SBThread, - GetStopReasonExtendedBacktraces, - (lldb::InstrumentationRuntimeType), type); + LLDB_INSTRUMENT_METHOD(lldb::SBThreadCollection, SBThread, + GetStopReasonExtendedBacktraces, + (lldb::InstrumentationRuntimeType), type); SBThreadCollection threads; @@ -328,8 +329,8 @@ } 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_METHOD(size_t, SBThread, GetStopDescription, (char *, size_t), + dst, "", dst_len); std::unique_lock lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -357,7 +358,7 @@ } SBValue SBThread::GetStopReturnValue() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBThread, GetStopReturnValue); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBValue, SBThread, GetStopReturnValue); ValueObjectSP return_valobj_sp; std::unique_lock lock; @@ -381,7 +382,7 @@ } lldb::tid_t SBThread::GetThreadID() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::tid_t, SBThread, GetThreadID); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::tid_t, SBThread, GetThreadID); ThreadSP thread_sp(m_opaque_sp->GetThreadSP()); if (thread_sp) @@ -390,7 +391,7 @@ } uint32_t SBThread::GetIndexID() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBThread, GetIndexID); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(uint32_t, SBThread, GetIndexID); ThreadSP thread_sp(m_opaque_sp->GetThreadSP()); if (thread_sp) @@ -399,7 +400,7 @@ } const char *SBThread::GetName() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBThread, GetName); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(const char *, SBThread, GetName); const char *name = nullptr; std::unique_lock lock; @@ -416,7 +417,7 @@ } const char *SBThread::GetQueueName() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBThread, GetQueueName); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(const char *, SBThread, GetQueueName); const char *name = nullptr; std::unique_lock lock; @@ -433,7 +434,7 @@ } lldb::queue_id_t SBThread::GetQueueID() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::queue_id_t, SBThread, GetQueueID); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::queue_id_t, SBThread, GetQueueID); queue_id_t id = LLDB_INVALID_QUEUE_ID; std::unique_lock lock; @@ -450,8 +451,8 @@ } bool SBThread::GetInfoItemByPathAsString(const char *path, SBStream &strm) { - LLDB_RECORD_METHOD(bool, SBThread, GetInfoItemByPathAsString, - (const char *, lldb::SBStream &), path, strm); + LLDB_INSTRUMENT_METHOD(bool, SBThread, GetInfoItemByPathAsString, + (const char *, lldb::SBStream &), path, strm); bool success = false; std::unique_lock lock; @@ -532,16 +533,17 @@ } void SBThread::StepOver(lldb::RunMode stop_other_threads) { - LLDB_RECORD_METHOD(void, SBThread, StepOver, (lldb::RunMode), - stop_other_threads); + LLDB_INSTRUMENT_METHOD(void, SBThread, StepOver, (lldb::RunMode), + stop_other_threads); SBError error; // Ignored StepOver(stop_other_threads, error); } void SBThread::StepOver(lldb::RunMode stop_other_threads, SBError &error) { - LLDB_RECORD_METHOD(void, SBThread, StepOver, (lldb::RunMode, lldb::SBError &), - stop_other_threads, error); + LLDB_INSTRUMENT_METHOD(void, SBThread, StepOver, + (lldb::RunMode, lldb::SBError &), stop_other_threads, + error); std::unique_lock lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -573,16 +575,17 @@ } void SBThread::StepInto(lldb::RunMode stop_other_threads) { - LLDB_RECORD_METHOD(void, SBThread, StepInto, (lldb::RunMode), - stop_other_threads); + LLDB_INSTRUMENT_METHOD(void, SBThread, StepInto, (lldb::RunMode), + 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_METHOD(void, SBThread, StepInto, + (const char *, lldb::RunMode), target_name, + stop_other_threads); SBError error; // Ignored StepInto(target_name, LLDB_INVALID_LINE_NUMBER, error, stop_other_threads); @@ -590,10 +593,10 @@ 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_METHOD( + void, SBThread, StepInto, + (const char *, uint32_t, lldb::SBError &, lldb::RunMode), target_name, + end_line, error, stop_other_threads); std::unique_lock lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -640,14 +643,14 @@ } void SBThread::StepOut() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBThread, StepOut); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBThread, StepOut); SBError error; // Ignored StepOut(error); } void SBThread::StepOut(SBError &error) { - LLDB_RECORD_METHOD(void, SBThread, StepOut, (lldb::SBError &), error); + LLDB_INSTRUMENT_METHOD(void, SBThread, StepOut, (lldb::SBError &), error); std::unique_lock lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -675,17 +678,16 @@ } void SBThread::StepOutOfFrame(SBFrame &sb_frame) { - LLDB_RECORD_METHOD(void, SBThread, StepOutOfFrame, (lldb::SBFrame &), - sb_frame); + LLDB_INSTRUMENT_METHOD(void, SBThread, StepOutOfFrame, (lldb::SBFrame &), + sb_frame); SBError error; // Ignored StepOutOfFrame(sb_frame, error); } void SBThread::StepOutOfFrame(SBFrame &sb_frame, SBError &error) { - LLDB_RECORD_METHOD(void, SBThread, StepOutOfFrame, - (lldb::SBFrame &, lldb::SBError &), sb_frame, error); - + LLDB_INSTRUMENT_METHOD(void, SBThread, StepOutOfFrame, + (lldb::SBFrame &, lldb::SBError &), sb_frame, error); std::unique_lock lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -722,15 +724,15 @@ } void SBThread::StepInstruction(bool step_over) { - LLDB_RECORD_METHOD(void, SBThread, StepInstruction, (bool), step_over); + LLDB_INSTRUMENT_METHOD(void, SBThread, StepInstruction, (bool), step_over); SBError error; // Ignored StepInstruction(step_over, error); } void SBThread::StepInstruction(bool step_over, SBError &error) { - LLDB_RECORD_METHOD(void, SBThread, StepInstruction, (bool, lldb::SBError &), - step_over, error); + LLDB_INSTRUMENT_METHOD(void, SBThread, StepInstruction, + (bool, lldb::SBError &), step_over, error); std::unique_lock lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -752,15 +754,15 @@ } void SBThread::RunToAddress(lldb::addr_t addr) { - LLDB_RECORD_METHOD(void, SBThread, RunToAddress, (lldb::addr_t), addr); + LLDB_INSTRUMENT_METHOD(void, SBThread, RunToAddress, (lldb::addr_t), addr); SBError error; // Ignored RunToAddress(addr, error); } void SBThread::RunToAddress(lldb::addr_t addr, SBError &error) { - LLDB_RECORD_METHOD(void, SBThread, RunToAddress, - (lldb::addr_t, lldb::SBError &), addr, error); + LLDB_INSTRUMENT_METHOD(void, SBThread, RunToAddress, + (lldb::addr_t, lldb::SBError &), addr, error); std::unique_lock lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -789,9 +791,9 @@ 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_METHOD(lldb::SBError, SBThread, StepOverUntil, + (lldb::SBFrame &, lldb::SBFileSpec &, uint32_t), + sb_frame, sb_file_spec, line); SBError sb_error; char path[PATH_MAX]; @@ -908,17 +910,17 @@ } SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name) { - LLDB_RECORD_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan, - (const char *), script_class_name); + LLDB_INSTRUMENT_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan, + (const char *), 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_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan, + (const char *, bool), script_class_name, + resume_immediately); lldb::SBStructuredData no_data; return StepUsingScriptedThreadPlan(script_class_name, no_data, @@ -928,9 +930,9 @@ 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_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan, + (const char *, lldb::SBStructuredData &, bool), + script_class_name, args_data, resume_immediately); SBError error; @@ -966,8 +968,8 @@ } 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_METHOD(lldb::SBError, SBThread, JumpToLine, + (lldb::SBFileSpec &, uint32_t), file_spec, line); SBError sb_error; @@ -987,8 +989,9 @@ } SBError SBThread::ReturnFromFrame(SBFrame &frame, SBValue &return_value) { - LLDB_RECORD_METHOD(lldb::SBError, SBThread, ReturnFromFrame, - (lldb::SBFrame &, lldb::SBValue &), frame, return_value); + LLDB_INSTRUMENT_METHOD(lldb::SBError, SBThread, ReturnFromFrame, + (lldb::SBFrame &, lldb::SBValue &), frame, + return_value); SBError sb_error; @@ -1005,8 +1008,8 @@ } SBError SBThread::UnwindInnermostExpression() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBThread, - UnwindInnermostExpression); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBError, SBThread, + UnwindInnermostExpression); SBError sb_error; @@ -1024,14 +1027,14 @@ } bool SBThread::Suspend() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, Suspend); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBThread, Suspend); SBError error; // Ignored return Suspend(error); } bool SBThread::Suspend(SBError &error) { - LLDB_RECORD_METHOD(bool, SBThread, Suspend, (lldb::SBError &), error); + LLDB_INSTRUMENT_METHOD(bool, SBThread, Suspend, (lldb::SBError &), error); std::unique_lock lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -1051,14 +1054,14 @@ } bool SBThread::Resume() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, Resume); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBThread, Resume); SBError error; // Ignored return Resume(error); } bool SBThread::Resume(SBError &error) { - LLDB_RECORD_METHOD(bool, SBThread, Resume, (lldb::SBError &), error); + LLDB_INSTRUMENT_METHOD(bool, SBThread, Resume, (lldb::SBError &), error); std::unique_lock lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -1079,7 +1082,7 @@ } bool SBThread::IsSuspended() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, IsSuspended); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBThread, IsSuspended); std::unique_lock lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -1090,7 +1093,7 @@ } bool SBThread::IsStopped() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, IsStopped); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBThread, IsStopped); std::unique_lock lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -1101,7 +1104,7 @@ } SBProcess SBThread::GetProcess() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBThread, GetProcess); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBProcess, SBThread, GetProcess); SBProcess sb_process; std::unique_lock lock; @@ -1117,7 +1120,7 @@ } uint32_t SBThread::GetNumFrames() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBThread, GetNumFrames); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBThread, GetNumFrames); uint32_t num_frames = 0; std::unique_lock lock; @@ -1134,7 +1137,8 @@ } SBFrame SBThread::GetFrameAtIndex(uint32_t idx) { - LLDB_RECORD_METHOD(lldb::SBFrame, SBThread, GetFrameAtIndex, (uint32_t), idx); + LLDB_INSTRUMENT_METHOD(lldb::SBFrame, SBThread, GetFrameAtIndex, (uint32_t), + idx); SBFrame sb_frame; StackFrameSP frame_sp; @@ -1153,7 +1157,7 @@ } lldb::SBFrame SBThread::GetSelectedFrame() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFrame, SBThread, GetSelectedFrame); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBFrame, SBThread, GetSelectedFrame); SBFrame sb_frame; StackFrameSP frame_sp; @@ -1172,8 +1176,8 @@ } lldb::SBFrame SBThread::SetSelectedFrame(uint32_t idx) { - LLDB_RECORD_METHOD(lldb::SBFrame, SBThread, SetSelectedFrame, (uint32_t), - idx); + LLDB_INSTRUMENT_METHOD(lldb::SBFrame, SBThread, SetSelectedFrame, (uint32_t), + idx); SBFrame sb_frame; StackFrameSP frame_sp; @@ -1196,45 +1200,45 @@ } bool SBThread::EventIsThreadEvent(const SBEvent &event) { - LLDB_RECORD_STATIC_METHOD(bool, SBThread, EventIsThreadEvent, - (const lldb::SBEvent &), event); + LLDB_INSTRUMENT_STATIC_METHOD(bool, SBThread, EventIsThreadEvent, + (const lldb::SBEvent &), 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_STATIC_METHOD(lldb::SBFrame, SBThread, GetStackFrameFromEvent, + (const lldb::SBEvent &), 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_STATIC_METHOD(lldb::SBThread, SBThread, GetThreadFromEvent, + (const lldb::SBEvent &), 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_METHOD_CONST(bool, SBThread, operator==, + (const lldb::SBThread &), rhs); return m_opaque_sp->GetThreadSP().get() == rhs.m_opaque_sp->GetThreadSP().get(); } bool SBThread::operator!=(const SBThread &rhs) const { - LLDB_RECORD_METHOD_CONST(bool, SBThread, operator!=,(const lldb::SBThread &), - rhs); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBThread, operator!=, + (const lldb::SBThread &), rhs); return m_opaque_sp->GetThreadSP().get() != rhs.m_opaque_sp->GetThreadSP().get(); } bool SBThread::GetStatus(SBStream &status) const { - LLDB_RECORD_METHOD_CONST(bool, SBThread, GetStatus, (lldb::SBStream &), - status); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBThread, GetStatus, (lldb::SBStream &), + status); Stream &strm = status.ref(); @@ -1250,15 +1254,16 @@ } bool SBThread::GetDescription(SBStream &description) const { - LLDB_RECORD_METHOD_CONST(bool, SBThread, GetDescription, (lldb::SBStream &), - description); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBThread, GetDescription, + (lldb::SBStream &), description); return GetDescription(description, false); } bool SBThread::GetDescription(SBStream &description, bool stop_format) const { - LLDB_RECORD_METHOD_CONST(bool, SBThread, GetDescription, - (lldb::SBStream &, bool), description, stop_format); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBThread, GetDescription, + (lldb::SBStream &, bool), description, + stop_format); Stream &strm = description.ref(); @@ -1278,8 +1283,8 @@ } SBThread SBThread::GetExtendedBacktraceThread(const char *type) { - LLDB_RECORD_METHOD(lldb::SBThread, SBThread, GetExtendedBacktraceThread, - (const char *), type); + LLDB_INSTRUMENT_METHOD(lldb::SBThread, SBThread, GetExtendedBacktraceThread, + (const char *), type); std::unique_lock lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); @@ -1313,8 +1318,8 @@ } uint32_t SBThread::GetExtendedBacktraceOriginatingIndexID() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBThread, - GetExtendedBacktraceOriginatingIndexID); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBThread, + GetExtendedBacktraceOriginatingIndexID); ThreadSP thread_sp(m_opaque_sp->GetThreadSP()); if (thread_sp) @@ -1323,7 +1328,7 @@ } SBValue SBThread::GetCurrentException() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBThread, GetCurrentException); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBValue, SBThread, GetCurrentException); ThreadSP thread_sp(m_opaque_sp->GetThreadSP()); if (!thread_sp) @@ -1333,8 +1338,8 @@ } SBThread SBThread::GetCurrentExceptionBacktrace() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBThread, SBThread, - GetCurrentExceptionBacktrace); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBThread, SBThread, + GetCurrentExceptionBacktrace); ThreadSP thread_sp(m_opaque_sp->GetThreadSP()); if (!thread_sp) @@ -1344,7 +1349,7 @@ } bool SBThread::SafeToCallFunctions() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, SafeToCallFunctions); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBThread, SafeToCallFunctions); ThreadSP thread_sp(m_opaque_sp->GetThreadSP()); if (thread_sp) Index: lldb/source/API/SBThreadCollection.cpp =================================================================== --- lldb/source/API/SBThreadCollection.cpp +++ lldb/source/API/SBThreadCollection.cpp @@ -7,28 +7,28 @@ //===----------------------------------------------------------------------===// #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); + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBThreadCollection); } SBThreadCollection::SBThreadCollection(const SBThreadCollection &rhs) : m_opaque_sp(rhs.m_opaque_sp) { - LLDB_RECORD_CONSTRUCTOR(SBThreadCollection, - (const lldb::SBThreadCollection &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBThreadCollection, + (const lldb::SBThreadCollection &), rhs); } const SBThreadCollection &SBThreadCollection:: operator=(const SBThreadCollection &rhs) { - LLDB_RECORD_METHOD( - const lldb::SBThreadCollection &, - SBThreadCollection, operator=,(const lldb::SBThreadCollection &), rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBThreadCollection &, + SBThreadCollection, operator=, + (const lldb::SBThreadCollection &), rhs); if (this != &rhs) m_opaque_sp = rhs.m_opaque_sp; @@ -61,17 +61,17 @@ } bool SBThreadCollection::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadCollection, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBThreadCollection, IsValid); return this->operator bool(); } SBThreadCollection::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadCollection, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBThreadCollection, operator bool); return m_opaque_sp.get() != nullptr; } size_t SBThreadCollection::GetSize() { - LLDB_RECORD_METHOD_NO_ARGS(size_t, SBThreadCollection, GetSize); + LLDB_INSTRUMENT_METHOD_NO_ARGS(size_t, SBThreadCollection, GetSize); if (m_opaque_sp) return m_opaque_sp->GetSize(); @@ -79,8 +79,8 @@ } SBThread SBThreadCollection::GetThreadAtIndex(size_t idx) { - LLDB_RECORD_METHOD(lldb::SBThread, SBThreadCollection, GetThreadAtIndex, - (size_t), idx); + LLDB_INSTRUMENT_METHOD(lldb::SBThread, SBThreadCollection, GetThreadAtIndex, + (size_t), idx); SBThread thread; if (m_opaque_sp && idx < m_opaque_sp->GetSize()) Index: lldb/source/API/SBThreadPlan.cpp =================================================================== --- lldb/source/API/SBThreadPlan.cpp +++ 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,24 @@ using namespace lldb_private; // Constructors -SBThreadPlan::SBThreadPlan() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBThreadPlan); } +SBThreadPlan::SBThreadPlan() { + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBThreadPlan); +} 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_CONSTRUCTOR(SBThreadPlan, (const lldb::ThreadPlanSP &), + 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_CONSTRUCTOR(SBThreadPlan, (const lldb::SBThreadPlan &), rhs); } SBThreadPlan::SBThreadPlan(lldb::SBThread &sb_thread, const char *class_name) { - LLDB_RECORD_CONSTRUCTOR(SBThreadPlan, (lldb::SBThread &, const char *), - sb_thread, class_name); + LLDB_INSTRUMENT_CONSTRUCTOR(SBThreadPlan, (lldb::SBThread &, const char *), + sb_thread, class_name); Thread *thread = sb_thread.get(); if (thread) @@ -75,9 +77,9 @@ 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_CONSTRUCTOR( + SBThreadPlan, (lldb::SBThread &, const char *, SBStructuredData &), + sb_thread, class_name, args_data); Thread *thread = sb_thread.get(); if (thread) @@ -88,8 +90,8 @@ // Assignment operator const lldb::SBThreadPlan &SBThreadPlan::operator=(const SBThreadPlan &rhs) { - LLDB_RECORD_METHOD(const lldb::SBThreadPlan &, - SBThreadPlan, operator=,(const lldb::SBThreadPlan &), rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBThreadPlan &, SBThreadPlan, operator=, + (const lldb::SBThreadPlan &), rhs); if (this != &rhs) m_opaque_wp = rhs.m_opaque_wp; @@ -99,42 +101,42 @@ SBThreadPlan::~SBThreadPlan() = default; bool SBThreadPlan::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadPlan, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBThreadPlan, IsValid); return this->operator bool(); } SBThreadPlan::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadPlan, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBThreadPlan, operator bool); return static_cast(GetSP()); } void SBThreadPlan::Clear() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBThreadPlan, Clear); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBThreadPlan, Clear); m_opaque_wp.reset(); } lldb::StopReason SBThreadPlan::GetStopReason() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::StopReason, SBThreadPlan, GetStopReason); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::StopReason, SBThreadPlan, GetStopReason); return eStopReasonNone; } size_t SBThreadPlan::GetStopReasonDataCount() { - LLDB_RECORD_METHOD_NO_ARGS(size_t, SBThreadPlan, GetStopReasonDataCount); + LLDB_INSTRUMENT_METHOD_NO_ARGS(size_t, SBThreadPlan, GetStopReasonDataCount); return 0; } uint64_t SBThreadPlan::GetStopReasonDataAtIndex(uint32_t idx) { - LLDB_RECORD_METHOD(uint64_t, SBThreadPlan, GetStopReasonDataAtIndex, - (uint32_t), idx); + LLDB_INSTRUMENT_METHOD(uint64_t, SBThreadPlan, GetStopReasonDataAtIndex, + (uint32_t), idx); return 0; } SBThread SBThreadPlan::GetThread() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBThreadPlan, GetThread); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::SBThread, SBThreadPlan, GetThread); ThreadPlanSP thread_plan_sp(GetSP()); if (thread_plan_sp) { @@ -144,8 +146,8 @@ } bool SBThreadPlan::GetDescription(lldb::SBStream &description) const { - LLDB_RECORD_METHOD_CONST(bool, SBThreadPlan, GetDescription, - (lldb::SBStream &), description); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBThreadPlan, GetDescription, + (lldb::SBStream &), description); ThreadPlanSP thread_plan_sp(GetSP()); if (thread_plan_sp) { @@ -161,7 +163,7 @@ } void SBThreadPlan::SetPlanComplete(bool success) { - LLDB_RECORD_METHOD(void, SBThreadPlan, SetPlanComplete, (bool), success); + LLDB_INSTRUMENT_METHOD(void, SBThreadPlan, SetPlanComplete, (bool), success); ThreadPlanSP thread_plan_sp(GetSP()); if (thread_plan_sp) @@ -169,7 +171,7 @@ } bool SBThreadPlan::IsPlanComplete() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, IsPlanComplete); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBThreadPlan, IsPlanComplete); ThreadPlanSP thread_plan_sp(GetSP()); if (thread_plan_sp) @@ -178,7 +180,7 @@ } bool SBThreadPlan::IsPlanStale() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, IsPlanStale); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBThreadPlan, IsPlanStale); ThreadPlanSP thread_plan_sp(GetSP()); if (thread_plan_sp) @@ -187,7 +189,7 @@ } bool SBThreadPlan::IsValid() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, IsValid); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBThreadPlan, IsValid); ThreadPlanSP thread_plan_sp(GetSP()); if (thread_plan_sp) @@ -196,7 +198,7 @@ } bool SBThreadPlan::GetStopOthers() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, GetStopOthers); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBThreadPlan, GetStopOthers); ThreadPlanSP thread_plan_sp(GetSP()); if (thread_plan_sp) @@ -205,7 +207,8 @@ } void SBThreadPlan::SetStopOthers(bool stop_others) { - LLDB_RECORD_METHOD(void, SBThreadPlan, SetStopOthers, (bool), stop_others); + LLDB_INSTRUMENT_METHOD(void, SBThreadPlan, SetStopOthers, (bool), + stop_others); ThreadPlanSP thread_plan_sp(GetSP()); if (thread_plan_sp) @@ -221,9 +224,9 @@ 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_METHOD( + lldb::SBThreadPlan, SBThreadPlan, QueueThreadPlanForStepOverRange, + (lldb::SBAddress &, lldb::addr_t), sb_start_address, size); SBError error; return QueueThreadPlanForStepOverRange(sb_start_address, size, error); @@ -231,10 +234,10 @@ 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_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForStepOverRange, + (lldb::SBAddress &, lldb::addr_t, lldb::SBError &), + sb_start_address, size, error); ThreadPlanSP thread_plan_sp(GetSP()); if (thread_plan_sp) { @@ -265,9 +268,9 @@ 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_METHOD( + lldb::SBThreadPlan, SBThreadPlan, QueueThreadPlanForStepInRange, + (lldb::SBAddress &, lldb::addr_t), sb_start_address, size); SBError error; return QueueThreadPlanForStepInRange(sb_start_address, size, error); @@ -276,10 +279,10 @@ 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_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForStepInRange, + (lldb::SBAddress &, lldb::addr_t, lldb::SBError &), + sb_start_address, size, error); ThreadPlanSP thread_plan_sp(GetSP()); if (thread_plan_sp) { @@ -310,9 +313,9 @@ 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_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForStepOut, (uint32_t, bool), + frame_idx_to_step_to, first_insn); SBError error; return QueueThreadPlanForStepOut(frame_idx_to_step_to, first_insn, error); @@ -321,10 +324,10 @@ 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_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForStepOut, + (uint32_t, bool, lldb::SBError &), + frame_idx_to_step_to, first_insn, error); ThreadPlanSP thread_plan_sp(GetSP()); if (thread_plan_sp) { @@ -350,9 +353,9 @@ SBThreadPlan SBThreadPlan::QueueThreadPlanForRunToAddress(SBAddress sb_address) { - LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan, - QueueThreadPlanForRunToAddress, (lldb::SBAddress), - sb_address); + LLDB_INSTRUMENT_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForRunToAddress, (lldb::SBAddress), + sb_address); SBError error; return QueueThreadPlanForRunToAddress(sb_address, error); @@ -360,9 +363,9 @@ SBThreadPlan SBThreadPlan::QueueThreadPlanForRunToAddress(SBAddress sb_address, SBError &error) { - LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan, - QueueThreadPlanForRunToAddress, - (lldb::SBAddress, lldb::SBError &), sb_address, error); + LLDB_INSTRUMENT_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForRunToAddress, + (lldb::SBAddress, lldb::SBError &), sb_address, error); ThreadPlanSP thread_plan_sp(GetSP()); if (thread_plan_sp) { @@ -387,9 +390,9 @@ SBThreadPlan SBThreadPlan::QueueThreadPlanForStepScripted(const char *script_class_name) { - LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan, - QueueThreadPlanForStepScripted, (const char *), - script_class_name); + LLDB_INSTRUMENT_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForStepScripted, (const char *), + script_class_name); SBError error; return QueueThreadPlanForStepScripted(script_class_name, error); @@ -398,9 +401,9 @@ 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_METHOD( + lldb::SBThreadPlan, SBThreadPlan, QueueThreadPlanForStepScripted, + (const char *, lldb::SBError &), script_class_name, error); ThreadPlanSP thread_plan_sp(GetSP()); if (thread_plan_sp) { @@ -424,10 +427,10 @@ 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_METHOD( + lldb::SBThreadPlan, SBThreadPlan, QueueThreadPlanForStepScripted, + (const char *, lldb::SBStructuredData &, lldb::SBError &), + script_class_name, args_data, error); ThreadPlanSP thread_plan_sp(GetSP()); if (thread_plan_sp) { Index: lldb/source/API/SBTrace.cpp =================================================================== --- lldb/source/API/SBTrace.cpp +++ 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,21 @@ using namespace lldb; using namespace lldb_private; -SBTrace::SBTrace() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTrace); } +SBTrace::SBTrace() { LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBTrace); } SBTrace::SBTrace(const lldb::TraceSP &trace_sp) : m_opaque_sp(trace_sp) { - LLDB_RECORD_CONSTRUCTOR(SBTrace, (const lldb::TraceSP &), trace_sp); + LLDB_INSTRUMENT_CONSTRUCTOR(SBTrace, (const lldb::TraceSP &), trace_sp); } const char *SBTrace::GetStartConfigurationHelp() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTrace, GetStartConfigurationHelp); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBTrace, + GetStartConfigurationHelp); 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_METHOD(SBError, SBTrace, Start, (const SBStructuredData &), + configuration); SBError error; if (!m_opaque_sp) error.SetErrorString("error: invalid trace"); @@ -45,9 +46,9 @@ SBError SBTrace::Start(const SBThread &thread, const SBStructuredData &configuration) { - LLDB_RECORD_METHOD(SBError, SBTrace, Start, - (const SBThread &, const SBStructuredData &), thread, - configuration); + LLDB_INSTRUMENT_METHOD(SBError, SBTrace, Start, + (const SBThread &, const SBStructuredData &), thread, + configuration); SBError error; if (!m_opaque_sp) @@ -63,7 +64,7 @@ } SBError SBTrace::Stop() { - LLDB_RECORD_METHOD_NO_ARGS(SBError, SBTrace, Stop); + LLDB_INSTRUMENT_METHOD_NO_ARGS(SBError, SBTrace, Stop); SBError error; if (!m_opaque_sp) error.SetErrorString("error: invalid trace"); @@ -73,7 +74,7 @@ } SBError SBTrace::Stop(const SBThread &thread) { - LLDB_RECORD_METHOD(SBError, SBTrace, Stop, (const SBThread &), thread); + LLDB_INSTRUMENT_METHOD(SBError, SBTrace, Stop, (const SBThread &), thread); SBError error; if (!m_opaque_sp) error.SetErrorString("error: invalid trace"); @@ -83,11 +84,11 @@ } bool SBTrace::IsValid() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBTrace, IsValid); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBTrace, IsValid); return this->operator bool(); } SBTrace::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTrace, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBTrace, operator bool); return (bool)m_opaque_sp; } Index: lldb/source/API/SBType.cpp =================================================================== --- lldb/source/API/SBType.cpp +++ lldb/source/API/SBType.cpp @@ -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_CONSTRUCTOR_NO_ARGS(SBType); } SBType::SBType(const CompilerType &type) : m_opaque_sp(new TypeImpl( @@ -39,7 +39,7 @@ : m_opaque_sp(type_impl_sp) {} SBType::SBType(const SBType &rhs) { - LLDB_RECORD_CONSTRUCTOR(SBType, (const lldb::SBType &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBType, (const lldb::SBType &), rhs); if (this != &rhs) { m_opaque_sp = rhs.m_opaque_sp; @@ -51,7 +51,7 @@ //{} // bool SBType::operator==(SBType &rhs) { - LLDB_RECORD_METHOD(bool, SBType, operator==,(lldb::SBType &), rhs); + LLDB_INSTRUMENT_METHOD(bool, SBType, operator==, (lldb::SBType &), rhs); if (!IsValid()) return !rhs.IsValid(); @@ -63,7 +63,7 @@ } bool SBType::operator!=(SBType &rhs) { - LLDB_RECORD_METHOD(bool, SBType, operator!=,(lldb::SBType &), rhs); + LLDB_INSTRUMENT_METHOD(bool, SBType, operator!=, (lldb::SBType &), rhs); if (!IsValid()) return rhs.IsValid(); @@ -81,8 +81,8 @@ } SBType &SBType::operator=(const SBType &rhs) { - LLDB_RECORD_METHOD(lldb::SBType &, SBType, operator=,(const lldb::SBType &), - rhs); + LLDB_INSTRUMENT_METHOD(lldb::SBType &, SBType, operator=, + (const lldb::SBType &), rhs); if (this != &rhs) { m_opaque_sp = rhs.m_opaque_sp; @@ -107,11 +107,11 @@ } bool SBType::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBType, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBType, IsValid); return this->operator bool(); } SBType::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBType, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBType, operator bool); if (m_opaque_sp.get() == nullptr) return false; @@ -120,7 +120,7 @@ } uint64_t SBType::GetByteSize() { - LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBType, GetByteSize); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint64_t, SBType, GetByteSize); if (IsValid()) if (llvm::Optional size = @@ -130,7 +130,7 @@ } bool SBType::IsPointerType() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsPointerType); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBType, IsPointerType); if (!IsValid()) return false; @@ -138,7 +138,7 @@ } bool SBType::IsArrayType() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsArrayType); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBType, IsArrayType); if (!IsValid()) return false; @@ -147,7 +147,7 @@ } bool SBType::IsVectorType() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsVectorType); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBType, IsVectorType); if (!IsValid()) return false; @@ -155,7 +155,7 @@ } bool SBType::IsReferenceType() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsReferenceType); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBType, IsReferenceType); if (!IsValid()) return false; @@ -163,7 +163,7 @@ } SBType SBType::GetPointerType() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetPointerType); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBType, SBType, GetPointerType); if (!IsValid()) return SBType(); @@ -172,7 +172,7 @@ } SBType SBType::GetPointeeType() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetPointeeType); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBType, SBType, GetPointeeType); if (!IsValid()) return SBType(); @@ -180,7 +180,7 @@ } SBType SBType::GetReferenceType() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetReferenceType); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBType, SBType, GetReferenceType); if (!IsValid()) return SBType(); @@ -188,7 +188,7 @@ } SBType SBType::GetTypedefedType() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetTypedefedType); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBType, SBType, GetTypedefedType); if (!IsValid()) return SBType(); @@ -196,7 +196,7 @@ } SBType SBType::GetDereferencedType() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetDereferencedType); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBType, SBType, GetDereferencedType); if (!IsValid()) return SBType(); @@ -204,7 +204,7 @@ } SBType SBType::GetArrayElementType() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetArrayElementType); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBType, SBType, GetArrayElementType); if (!IsValid()) return SBType(); @@ -213,7 +213,7 @@ } SBType SBType::GetArrayType(uint64_t size) { - LLDB_RECORD_METHOD(lldb::SBType, SBType, GetArrayType, (uint64_t), size); + LLDB_INSTRUMENT_METHOD(lldb::SBType, SBType, GetArrayType, (uint64_t), size); if (!IsValid()) return SBType(); @@ -222,7 +222,7 @@ } SBType SBType::GetVectorElementType() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetVectorElementType); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBType, SBType, GetVectorElementType); SBType type_sb; if (IsValid()) { @@ -235,7 +235,7 @@ } bool SBType::IsFunctionType() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsFunctionType); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBType, IsFunctionType); if (!IsValid()) return false; @@ -243,7 +243,7 @@ } bool SBType::IsPolymorphicClass() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsPolymorphicClass); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBType, IsPolymorphicClass); if (!IsValid()) return false; @@ -251,7 +251,7 @@ } bool SBType::IsTypedefType() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsTypedefType); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBType, IsTypedefType); if (!IsValid()) return false; @@ -259,7 +259,7 @@ } bool SBType::IsAnonymousType() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsAnonymousType); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBType, IsAnonymousType); if (!IsValid()) return false; @@ -267,7 +267,7 @@ } bool SBType::IsScopedEnumerationType() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsScopedEnumerationType); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBType, IsScopedEnumerationType); if (!IsValid()) return false; @@ -275,7 +275,7 @@ } lldb::SBType SBType::GetFunctionReturnType() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetFunctionReturnType); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBType, SBType, GetFunctionReturnType); if (IsValid()) { CompilerType return_type( @@ -287,8 +287,8 @@ } lldb::SBTypeList SBType::GetFunctionArgumentTypes() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeList, SBType, - GetFunctionArgumentTypes); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBTypeList, SBType, + GetFunctionArgumentTypes); SBTypeList sb_type_list; if (IsValid()) { @@ -302,7 +302,7 @@ } uint32_t SBType::GetNumberOfMemberFunctions() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfMemberFunctions); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfMemberFunctions); if (IsValid()) { return m_opaque_sp->GetCompilerType(true).GetNumMemberFunctions(); @@ -311,8 +311,8 @@ } lldb::SBTypeMemberFunction SBType::GetMemberFunctionAtIndex(uint32_t idx) { - LLDB_RECORD_METHOD(lldb::SBTypeMemberFunction, SBType, - GetMemberFunctionAtIndex, (uint32_t), idx); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeMemberFunction, SBType, + GetMemberFunctionAtIndex, (uint32_t), idx); SBTypeMemberFunction sb_func_type; if (IsValid()) @@ -322,7 +322,7 @@ } lldb::SBType SBType::GetUnqualifiedType() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetUnqualifiedType); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBType, SBType, GetUnqualifiedType); if (!IsValid()) return SBType(); @@ -330,7 +330,7 @@ } lldb::SBType SBType::GetCanonicalType() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetCanonicalType); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBType, SBType, GetCanonicalType); if (IsValid()) return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetCanonicalType()))); @@ -338,7 +338,8 @@ } SBType SBType::GetEnumerationIntegerType() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetEnumerationIntegerType); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBType, SBType, + GetEnumerationIntegerType); if (IsValid()) { return SBType( @@ -348,7 +349,7 @@ } lldb::BasicType SBType::GetBasicType() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::BasicType, SBType, GetBasicType); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::BasicType, SBType, GetBasicType); if (IsValid()) return m_opaque_sp->GetCompilerType(false).GetBasicTypeEnumeration(); @@ -356,8 +357,8 @@ } SBType SBType::GetBasicType(lldb::BasicType basic_type) { - LLDB_RECORD_METHOD(lldb::SBType, SBType, GetBasicType, (lldb::BasicType), - basic_type); + LLDB_INSTRUMENT_METHOD(lldb::SBType, SBType, GetBasicType, (lldb::BasicType), + basic_type); if (IsValid() && m_opaque_sp->IsValid()) return SBType( @@ -366,7 +367,8 @@ } uint32_t SBType::GetNumberOfDirectBaseClasses() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfDirectBaseClasses); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBType, + GetNumberOfDirectBaseClasses); if (IsValid()) return m_opaque_sp->GetCompilerType(true).GetNumDirectBaseClasses(); @@ -374,7 +376,8 @@ } uint32_t SBType::GetNumberOfVirtualBaseClasses() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfVirtualBaseClasses); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBType, + GetNumberOfVirtualBaseClasses); if (IsValid()) return m_opaque_sp->GetCompilerType(true).GetNumVirtualBaseClasses(); @@ -382,7 +385,7 @@ } uint32_t SBType::GetNumberOfFields() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfFields); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfFields); if (IsValid()) return m_opaque_sp->GetCompilerType(true).GetNumFields(); @@ -391,9 +394,9 @@ bool SBType::GetDescription(SBStream &description, lldb::DescriptionLevel description_level) { - LLDB_RECORD_METHOD(bool, SBType, GetDescription, - (lldb::SBStream &, lldb::DescriptionLevel), description, - description_level); + LLDB_INSTRUMENT_METHOD(bool, SBType, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel), + description, description_level); Stream &strm = description.ref(); @@ -406,8 +409,8 @@ } SBTypeMember SBType::GetDirectBaseClassAtIndex(uint32_t idx) { - LLDB_RECORD_METHOD(lldb::SBTypeMember, SBType, GetDirectBaseClassAtIndex, - (uint32_t), idx); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeMember, SBType, GetDirectBaseClassAtIndex, + (uint32_t), idx); SBTypeMember sb_type_member; if (IsValid()) { @@ -423,8 +426,8 @@ } SBTypeMember SBType::GetVirtualBaseClassAtIndex(uint32_t idx) { - LLDB_RECORD_METHOD(lldb::SBTypeMember, SBType, GetVirtualBaseClassAtIndex, - (uint32_t), idx); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeMember, SBType, GetVirtualBaseClassAtIndex, + (uint32_t), idx); SBTypeMember sb_type_member; if (IsValid()) { @@ -440,8 +443,8 @@ } SBTypeEnumMemberList SBType::GetEnumMembers() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeEnumMemberList, SBType, - GetEnumMembers); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBTypeEnumMemberList, SBType, + GetEnumMembers); SBTypeEnumMemberList sb_enum_member_list; if (IsValid()) { @@ -463,8 +466,8 @@ } SBTypeMember SBType::GetFieldAtIndex(uint32_t idx) { - LLDB_RECORD_METHOD(lldb::SBTypeMember, SBType, GetFieldAtIndex, (uint32_t), - idx); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeMember, SBType, GetFieldAtIndex, + (uint32_t), idx); SBTypeMember sb_type_member; if (IsValid()) { @@ -490,7 +493,7 @@ } bool SBType::IsTypeComplete() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsTypeComplete); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBType, IsTypeComplete); if (!IsValid()) return false; @@ -498,7 +501,7 @@ } uint32_t SBType::GetTypeFlags() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetTypeFlags); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBType, GetTypeFlags); if (!IsValid()) return 0; @@ -506,7 +509,7 @@ } lldb::SBModule SBType::GetModule() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBModule, SBType, GetModule); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBModule, SBType, GetModule); lldb::SBModule sb_module; if (!IsValid()) @@ -517,7 +520,7 @@ } const char *SBType::GetName() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBType, GetName); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBType, GetName); if (!IsValid()) return ""; @@ -525,7 +528,7 @@ } const char *SBType::GetDisplayTypeName() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBType, GetDisplayTypeName); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBType, GetDisplayTypeName); if (!IsValid()) return ""; @@ -533,7 +536,7 @@ } lldb::TypeClass SBType::GetTypeClass() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::TypeClass, SBType, GetTypeClass); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::TypeClass, SBType, GetTypeClass); if (IsValid()) return m_opaque_sp->GetCompilerType(true).GetTypeClass(); @@ -541,7 +544,8 @@ } uint32_t SBType::GetNumberOfTemplateArguments() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfTemplateArguments); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBType, + GetNumberOfTemplateArguments); if (IsValid()) return m_opaque_sp->GetCompilerType(false).GetNumTemplateArguments(); @@ -549,8 +553,8 @@ } lldb::SBType SBType::GetTemplateArgumentType(uint32_t idx) { - LLDB_RECORD_METHOD(lldb::SBType, SBType, GetTemplateArgumentType, (uint32_t), - idx); + LLDB_INSTRUMENT_METHOD(lldb::SBType, SBType, GetTemplateArgumentType, + (uint32_t), idx); if (!IsValid()) return SBType(); @@ -574,8 +578,8 @@ } lldb::TemplateArgumentKind SBType::GetTemplateArgumentKind(uint32_t idx) { - LLDB_RECORD_METHOD(lldb::TemplateArgumentKind, SBType, - GetTemplateArgumentKind, (uint32_t), idx); + LLDB_INSTRUMENT_METHOD(lldb::TemplateArgumentKind, SBType, + GetTemplateArgumentKind, (uint32_t), idx); if (IsValid()) return m_opaque_sp->GetCompilerType(false).GetTemplateArgumentKind(idx); @@ -583,12 +587,12 @@ } SBTypeList::SBTypeList() : m_opaque_up(new TypeListImpl()) { - LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeList); + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBTypeList); } SBTypeList::SBTypeList(const SBTypeList &rhs) : m_opaque_up(new TypeListImpl()) { - LLDB_RECORD_CONSTRUCTOR(SBTypeList, (const lldb::SBTypeList &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBTypeList, (const lldb::SBTypeList &), rhs); for (uint32_t i = 0, rhs_size = const_cast(rhs).GetSize(); i < rhs_size; i++) @@ -596,18 +600,18 @@ } bool SBTypeList::IsValid() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeList, IsValid); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBTypeList, IsValid); return this->operator bool(); } SBTypeList::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeList, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBTypeList, operator bool); return (m_opaque_up != nullptr); } SBTypeList &SBTypeList::operator=(const SBTypeList &rhs) { - LLDB_RECORD_METHOD(lldb::SBTypeList &, - SBTypeList, operator=,(const lldb::SBTypeList &), rhs); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeList &, SBTypeList, operator=, + (const lldb::SBTypeList &), rhs); if (this != &rhs) { m_opaque_up = std::make_unique(); @@ -619,15 +623,15 @@ } void SBTypeList::Append(SBType type) { - LLDB_RECORD_METHOD(void, SBTypeList, Append, (lldb::SBType), type); + LLDB_INSTRUMENT_METHOD(void, SBTypeList, Append, (lldb::SBType), type); if (type.IsValid()) m_opaque_up->Append(type.m_opaque_sp); } SBType SBTypeList::GetTypeAtIndex(uint32_t index) { - LLDB_RECORD_METHOD(lldb::SBType, SBTypeList, GetTypeAtIndex, (uint32_t), - index); + LLDB_INSTRUMENT_METHOD(lldb::SBType, SBTypeList, GetTypeAtIndex, (uint32_t), + index); if (m_opaque_up) return SBType(m_opaque_up->GetTypeAtIndex(index)); @@ -635,19 +639,21 @@ } uint32_t SBTypeList::GetSize() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeList, GetSize); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBTypeList, GetSize); return m_opaque_up->GetSize(); } SBTypeList::~SBTypeList() = default; -SBTypeMember::SBTypeMember() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeMember); } +SBTypeMember::SBTypeMember() { + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBTypeMember); +} SBTypeMember::~SBTypeMember() = default; SBTypeMember::SBTypeMember(const SBTypeMember &rhs) { - LLDB_RECORD_CONSTRUCTOR(SBTypeMember, (const lldb::SBTypeMember &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBTypeMember, (const lldb::SBTypeMember &), rhs); if (this != &rhs) { if (rhs.IsValid()) @@ -656,8 +662,8 @@ } lldb::SBTypeMember &SBTypeMember::operator=(const lldb::SBTypeMember &rhs) { - LLDB_RECORD_METHOD(lldb::SBTypeMember &, - SBTypeMember, operator=,(const lldb::SBTypeMember &), rhs); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeMember &, SBTypeMember, operator=, + (const lldb::SBTypeMember &), rhs); if (this != &rhs) { if (rhs.IsValid()) @@ -667,17 +673,17 @@ } bool SBTypeMember::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMember, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBTypeMember, IsValid); return this->operator bool(); } SBTypeMember::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMember, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBTypeMember, operator bool); return m_opaque_up.get(); } const char *SBTypeMember::GetName() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMember, GetName); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBTypeMember, GetName); if (m_opaque_up) return m_opaque_up->GetName().GetCString(); @@ -685,7 +691,7 @@ } SBType SBTypeMember::GetType() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeMember, GetType); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBType, SBTypeMember, GetType); SBType sb_type; if (m_opaque_up) { @@ -695,7 +701,7 @@ } uint64_t SBTypeMember::GetOffsetInBytes() { - LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBTypeMember, GetOffsetInBytes); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint64_t, SBTypeMember, GetOffsetInBytes); if (m_opaque_up) return m_opaque_up->GetBitOffset() / 8u; @@ -703,7 +709,7 @@ } uint64_t SBTypeMember::GetOffsetInBits() { - LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBTypeMember, GetOffsetInBits); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint64_t, SBTypeMember, GetOffsetInBits); if (m_opaque_up) return m_opaque_up->GetBitOffset(); @@ -711,7 +717,7 @@ } bool SBTypeMember::IsBitfield() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeMember, IsBitfield); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBTypeMember, IsBitfield); if (m_opaque_up) return m_opaque_up->GetIsBitfield(); @@ -719,7 +725,7 @@ } uint32_t SBTypeMember::GetBitfieldSizeInBits() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeMember, GetBitfieldSizeInBits); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBTypeMember, GetBitfieldSizeInBits); if (m_opaque_up) return m_opaque_up->GetBitfieldBitSize(); @@ -728,9 +734,9 @@ 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_METHOD(bool, SBTypeMember, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel), + description, description_level); Stream &strm = description.ref(); @@ -772,23 +778,22 @@ const TypeMemberImpl &SBTypeMember::ref() const { return *m_opaque_up; } SBTypeMemberFunction::SBTypeMemberFunction() { - LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeMemberFunction); + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBTypeMemberFunction); } 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_CONSTRUCTOR(SBTypeMemberFunction, + (const lldb::SBTypeMemberFunction &), rhs); } lldb::SBTypeMemberFunction &SBTypeMemberFunction:: operator=(const lldb::SBTypeMemberFunction &rhs) { - LLDB_RECORD_METHOD( - lldb::SBTypeMemberFunction &, - SBTypeMemberFunction, operator=,(const lldb::SBTypeMemberFunction &), - rhs); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeMemberFunction &, + SBTypeMemberFunction, operator=, + (const lldb::SBTypeMemberFunction &), rhs); if (this != &rhs) m_opaque_sp = rhs.m_opaque_sp; @@ -796,17 +801,18 @@ } bool SBTypeMemberFunction::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMemberFunction, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBTypeMemberFunction, IsValid); return this->operator bool(); } SBTypeMemberFunction::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMemberFunction, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, + SBTypeMemberFunction, operator bool); return m_opaque_sp.get(); } const char *SBTypeMemberFunction::GetName() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMemberFunction, GetName); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBTypeMemberFunction, GetName); if (m_opaque_sp) return m_opaque_sp->GetName().GetCString(); @@ -814,8 +820,8 @@ } const char *SBTypeMemberFunction::GetDemangledName() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMemberFunction, - GetDemangledName); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBTypeMemberFunction, + GetDemangledName); if (m_opaque_sp) { ConstString mangled_str = m_opaque_sp->GetMangledName(); @@ -828,8 +834,8 @@ } const char *SBTypeMemberFunction::GetMangledName() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMemberFunction, - GetMangledName); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBTypeMemberFunction, + GetMangledName); if (m_opaque_sp) return m_opaque_sp->GetMangledName().GetCString(); @@ -837,7 +843,7 @@ } SBType SBTypeMemberFunction::GetType() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeMemberFunction, GetType); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBType, SBTypeMemberFunction, GetType); SBType sb_type; if (m_opaque_sp) { @@ -847,7 +853,8 @@ } lldb::SBType SBTypeMemberFunction::GetReturnType() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeMemberFunction, GetReturnType); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBType, SBTypeMemberFunction, + GetReturnType); SBType sb_type; if (m_opaque_sp) { @@ -857,8 +864,8 @@ } uint32_t SBTypeMemberFunction::GetNumberOfArguments() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeMemberFunction, - GetNumberOfArguments); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBTypeMemberFunction, + GetNumberOfArguments); if (m_opaque_sp) return m_opaque_sp->GetNumArguments(); @@ -866,8 +873,8 @@ } lldb::SBType SBTypeMemberFunction::GetArgumentTypeAtIndex(uint32_t i) { - LLDB_RECORD_METHOD(lldb::SBType, SBTypeMemberFunction, GetArgumentTypeAtIndex, - (uint32_t), i); + LLDB_INSTRUMENT_METHOD(lldb::SBType, SBTypeMemberFunction, + GetArgumentTypeAtIndex, (uint32_t), i); SBType sb_type; if (m_opaque_sp) { @@ -878,8 +885,8 @@ } lldb::MemberFunctionKind SBTypeMemberFunction::GetKind() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::MemberFunctionKind, SBTypeMemberFunction, - GetKind); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::MemberFunctionKind, SBTypeMemberFunction, + GetKind); if (m_opaque_sp) return m_opaque_sp->GetKind(); @@ -888,9 +895,9 @@ 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_METHOD(bool, SBTypeMemberFunction, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel), + description, description_level); Stream &strm = description.ref(); Index: lldb/source/API/SBTypeCategory.cpp =================================================================== --- lldb/source/API/SBTypeCategory.cpp +++ 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" @@ -27,7 +27,7 @@ typedef std::pair ImplType; SBTypeCategory::SBTypeCategory() { - LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeCategory); + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBTypeCategory); } SBTypeCategory::SBTypeCategory(const char *name) { @@ -36,23 +36,24 @@ SBTypeCategory::SBTypeCategory(const lldb::SBTypeCategory &rhs) : m_opaque_sp(rhs.m_opaque_sp) { - LLDB_RECORD_CONSTRUCTOR(SBTypeCategory, (const lldb::SBTypeCategory &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBTypeCategory, (const lldb::SBTypeCategory &), + rhs); } SBTypeCategory::~SBTypeCategory() = default; bool SBTypeCategory::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeCategory, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBTypeCategory, IsValid); return this->operator bool(); } SBTypeCategory::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeCategory, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBTypeCategory, operator bool); return (m_opaque_sp.get() != nullptr); } bool SBTypeCategory::GetEnabled() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeCategory, GetEnabled); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBTypeCategory, GetEnabled); if (!IsValid()) return false; @@ -60,7 +61,7 @@ } void SBTypeCategory::SetEnabled(bool enabled) { - LLDB_RECORD_METHOD(void, SBTypeCategory, SetEnabled, (bool), enabled); + LLDB_INSTRUMENT_METHOD(void, SBTypeCategory, SetEnabled, (bool), enabled); if (!IsValid()) return; @@ -71,7 +72,7 @@ } const char *SBTypeCategory::GetName() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeCategory, GetName); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBTypeCategory, GetName); if (!IsValid()) return nullptr; @@ -79,8 +80,8 @@ } lldb::LanguageType SBTypeCategory::GetLanguageAtIndex(uint32_t idx) { - LLDB_RECORD_METHOD(lldb::LanguageType, SBTypeCategory, GetLanguageAtIndex, - (uint32_t), idx); + LLDB_INSTRUMENT_METHOD(lldb::LanguageType, SBTypeCategory, GetLanguageAtIndex, + (uint32_t), idx); if (IsValid()) return m_opaque_sp->GetLanguageAtIndex(idx); @@ -88,7 +89,7 @@ } uint32_t SBTypeCategory::GetNumLanguages() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumLanguages); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumLanguages); if (IsValid()) return m_opaque_sp->GetNumLanguages(); @@ -96,15 +97,15 @@ } void SBTypeCategory::AddLanguage(lldb::LanguageType language) { - LLDB_RECORD_METHOD(void, SBTypeCategory, AddLanguage, (lldb::LanguageType), - language); + LLDB_INSTRUMENT_METHOD(void, SBTypeCategory, AddLanguage, + (lldb::LanguageType), language); if (IsValid()) m_opaque_sp->AddLanguage(language); } uint32_t SBTypeCategory::GetNumFormats() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumFormats); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumFormats); if (!IsValid()) return 0; @@ -114,7 +115,7 @@ } uint32_t SBTypeCategory::GetNumSummaries() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumSummaries); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumSummaries); if (!IsValid()) return 0; @@ -123,7 +124,7 @@ } uint32_t SBTypeCategory::GetNumFilters() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumFilters); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumFilters); if (!IsValid()) return 0; @@ -132,7 +133,7 @@ } uint32_t SBTypeCategory::GetNumSynthetics() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumSynthetics); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumSynthetics); if (!IsValid()) return 0; @@ -142,8 +143,9 @@ lldb::SBTypeNameSpecifier SBTypeCategory::GetTypeNameSpecifierForFilterAtIndex(uint32_t index) { - LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory, - GetTypeNameSpecifierForFilterAtIndex, (uint32_t), index); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory, + GetTypeNameSpecifierForFilterAtIndex, (uint32_t), + index); if (!IsValid()) return SBTypeNameSpecifier(); @@ -153,8 +155,9 @@ lldb::SBTypeNameSpecifier SBTypeCategory::GetTypeNameSpecifierForFormatAtIndex(uint32_t index) { - LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory, - GetTypeNameSpecifierForFormatAtIndex, (uint32_t), index); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory, + GetTypeNameSpecifierForFormatAtIndex, (uint32_t), + index); if (!IsValid()) return SBTypeNameSpecifier(); @@ -164,8 +167,9 @@ lldb::SBTypeNameSpecifier SBTypeCategory::GetTypeNameSpecifierForSummaryAtIndex(uint32_t index) { - LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory, - GetTypeNameSpecifierForSummaryAtIndex, (uint32_t), index); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory, + GetTypeNameSpecifierForSummaryAtIndex, (uint32_t), + index); if (!IsValid()) return SBTypeNameSpecifier(); @@ -175,9 +179,9 @@ lldb::SBTypeNameSpecifier SBTypeCategory::GetTypeNameSpecifierForSyntheticAtIndex(uint32_t index) { - LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory, - GetTypeNameSpecifierForSyntheticAtIndex, (uint32_t), - index); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory, + GetTypeNameSpecifierForSyntheticAtIndex, (uint32_t), + index); if (!IsValid()) return SBTypeNameSpecifier(); @@ -186,8 +190,8 @@ } SBTypeFilter SBTypeCategory::GetFilterForType(SBTypeNameSpecifier spec) { - LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterForType, - (lldb::SBTypeNameSpecifier), spec); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterForType, + (lldb::SBTypeNameSpecifier), spec); if (!IsValid()) return SBTypeFilter(); @@ -213,8 +217,8 @@ return lldb::SBTypeFilter(filter_sp); } SBTypeFormat SBTypeCategory::GetFormatForType(SBTypeNameSpecifier spec) { - LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatForType, - (lldb::SBTypeNameSpecifier), spec); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatForType, + (lldb::SBTypeNameSpecifier), spec); if (!IsValid()) return SBTypeFormat(); @@ -238,8 +242,8 @@ } SBTypeSummary SBTypeCategory::GetSummaryForType(SBTypeNameSpecifier spec) { - LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryForType, - (lldb::SBTypeNameSpecifier), spec); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryForType, + (lldb::SBTypeNameSpecifier), spec); if (!IsValid()) return SBTypeSummary(); @@ -263,8 +267,9 @@ } SBTypeSynthetic SBTypeCategory::GetSyntheticForType(SBTypeNameSpecifier spec) { - LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBTypeCategory, GetSyntheticForType, - (lldb::SBTypeNameSpecifier), spec); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeSynthetic, SBTypeCategory, + GetSyntheticForType, (lldb::SBTypeNameSpecifier), + spec); if (!IsValid()) return SBTypeSynthetic(); @@ -291,8 +296,8 @@ } SBTypeFilter SBTypeCategory::GetFilterAtIndex(uint32_t index) { - LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterAtIndex, - (uint32_t), index); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterAtIndex, + (uint32_t), index); if (!IsValid()) return SBTypeFilter(); @@ -309,8 +314,8 @@ } SBTypeFormat SBTypeCategory::GetFormatAtIndex(uint32_t index) { - LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatAtIndex, - (uint32_t), index); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatAtIndex, + (uint32_t), index); if (!IsValid()) return SBTypeFormat(); @@ -318,8 +323,8 @@ } SBTypeSummary SBTypeCategory::GetSummaryAtIndex(uint32_t index) { - LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryAtIndex, - (uint32_t), index); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryAtIndex, + (uint32_t), index); if (!IsValid()) return SBTypeSummary(); @@ -327,8 +332,8 @@ } SBTypeSynthetic SBTypeCategory::GetSyntheticAtIndex(uint32_t index) { - LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBTypeCategory, GetSyntheticAtIndex, - (uint32_t), index); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeSynthetic, SBTypeCategory, + GetSyntheticAtIndex, (uint32_t), index); if (!IsValid()) return SBTypeSynthetic(); @@ -346,9 +351,9 @@ bool SBTypeCategory::AddTypeFormat(SBTypeNameSpecifier type_name, SBTypeFormat format) { - LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeFormat, - (lldb::SBTypeNameSpecifier, lldb::SBTypeFormat), type_name, - format); + LLDB_INSTRUMENT_METHOD(bool, SBTypeCategory, AddTypeFormat, + (lldb::SBTypeNameSpecifier, lldb::SBTypeFormat), + type_name, format); if (!IsValid()) return false; @@ -370,8 +375,8 @@ } bool SBTypeCategory::DeleteTypeFormat(SBTypeNameSpecifier type_name) { - LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeFormat, - (lldb::SBTypeNameSpecifier), type_name); + LLDB_INSTRUMENT_METHOD(bool, SBTypeCategory, DeleteTypeFormat, + (lldb::SBTypeNameSpecifier), type_name); if (!IsValid()) return false; @@ -389,9 +394,9 @@ bool SBTypeCategory::AddTypeSummary(SBTypeNameSpecifier type_name, SBTypeSummary summary) { - LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeSummary, - (lldb::SBTypeNameSpecifier, lldb::SBTypeSummary), - type_name, summary); + LLDB_INSTRUMENT_METHOD(bool, SBTypeCategory, AddTypeSummary, + (lldb::SBTypeNameSpecifier, lldb::SBTypeSummary), + type_name, summary); if (!IsValid()) return false; @@ -447,8 +452,8 @@ } bool SBTypeCategory::DeleteTypeSummary(SBTypeNameSpecifier type_name) { - LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeSummary, - (lldb::SBTypeNameSpecifier), type_name); + LLDB_INSTRUMENT_METHOD(bool, SBTypeCategory, DeleteTypeSummary, + (lldb::SBTypeNameSpecifier), type_name); if (!IsValid()) return false; @@ -466,9 +471,9 @@ bool SBTypeCategory::AddTypeFilter(SBTypeNameSpecifier type_name, SBTypeFilter filter) { - LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeFilter, - (lldb::SBTypeNameSpecifier, lldb::SBTypeFilter), type_name, - filter); + LLDB_INSTRUMENT_METHOD(bool, SBTypeCategory, AddTypeFilter, + (lldb::SBTypeNameSpecifier, lldb::SBTypeFilter), + type_name, filter); if (!IsValid()) return false; @@ -490,8 +495,8 @@ } bool SBTypeCategory::DeleteTypeFilter(SBTypeNameSpecifier type_name) { - LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeFilter, - (lldb::SBTypeNameSpecifier), type_name); + LLDB_INSTRUMENT_METHOD(bool, SBTypeCategory, DeleteTypeFilter, + (lldb::SBTypeNameSpecifier), type_name); if (!IsValid()) return false; @@ -509,9 +514,9 @@ bool SBTypeCategory::AddTypeSynthetic(SBTypeNameSpecifier type_name, SBTypeSynthetic synth) { - LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeSynthetic, - (lldb::SBTypeNameSpecifier, lldb::SBTypeSynthetic), - type_name, synth); + LLDB_INSTRUMENT_METHOD(bool, SBTypeCategory, AddTypeSynthetic, + (lldb::SBTypeNameSpecifier, lldb::SBTypeSynthetic), + type_name, synth); if (!IsValid()) return false; @@ -567,8 +572,8 @@ } bool SBTypeCategory::DeleteTypeSynthetic(SBTypeNameSpecifier type_name) { - LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeSynthetic, - (lldb::SBTypeNameSpecifier), type_name); + LLDB_INSTRUMENT_METHOD(bool, SBTypeCategory, DeleteTypeSynthetic, + (lldb::SBTypeNameSpecifier), type_name); if (!IsValid()) return false; @@ -586,9 +591,9 @@ 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_METHOD(bool, SBTypeCategory, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel), + description, description_level); if (!IsValid()) return false; @@ -598,9 +603,8 @@ lldb::SBTypeCategory &SBTypeCategory:: operator=(const lldb::SBTypeCategory &rhs) { - LLDB_RECORD_METHOD(lldb::SBTypeCategory &, - SBTypeCategory, operator=,(const lldb::SBTypeCategory &), - rhs); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeCategory &, SBTypeCategory, operator=, + (const lldb::SBTypeCategory &), rhs); if (this != &rhs) { m_opaque_sp = rhs.m_opaque_sp; @@ -609,8 +613,8 @@ } bool SBTypeCategory::operator==(lldb::SBTypeCategory &rhs) { - LLDB_RECORD_METHOD(bool, SBTypeCategory, operator==,(lldb::SBTypeCategory &), - rhs); + LLDB_INSTRUMENT_METHOD(bool, SBTypeCategory, operator==, + (lldb::SBTypeCategory &), rhs); if (!IsValid()) return !rhs.IsValid(); @@ -619,8 +623,8 @@ } bool SBTypeCategory::operator!=(lldb::SBTypeCategory &rhs) { - LLDB_RECORD_METHOD(bool, SBTypeCategory, operator!=,(lldb::SBTypeCategory &), - rhs); + LLDB_INSTRUMENT_METHOD(bool, SBTypeCategory, operator!=, + (lldb::SBTypeCategory &), rhs); if (!IsValid()) return rhs.IsValid(); Index: lldb/source/API/SBTypeEnumMember.cpp =================================================================== --- lldb/source/API/SBTypeEnumMember.cpp +++ 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 @@ -22,7 +22,7 @@ using namespace lldb_private; SBTypeEnumMember::SBTypeEnumMember() { - LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeEnumMember); + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBTypeEnumMember); } SBTypeEnumMember::~SBTypeEnumMember() = default; @@ -32,16 +32,15 @@ : m_opaque_sp(enum_member_sp) {} SBTypeEnumMember::SBTypeEnumMember(const SBTypeEnumMember &rhs) { - LLDB_RECORD_CONSTRUCTOR(SBTypeEnumMember, (const lldb::SBTypeEnumMember &), - rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBTypeEnumMember, + (const lldb::SBTypeEnumMember &), 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_METHOD(SBTypeEnumMember &, SBTypeEnumMember, operator=, + (const lldb::SBTypeEnumMember &), rhs); if (this != &rhs) m_opaque_sp = clone(rhs.m_opaque_sp); @@ -49,17 +48,17 @@ } bool SBTypeEnumMember::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMember, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMember, IsValid); return this->operator bool(); } SBTypeEnumMember::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMember, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMember, operator bool); return m_opaque_sp.get(); } const char *SBTypeEnumMember::GetName() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeEnumMember, GetName); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBTypeEnumMember, GetName); if (m_opaque_sp.get()) return m_opaque_sp->GetName().GetCString(); @@ -67,7 +66,7 @@ } int64_t SBTypeEnumMember::GetValueAsSigned() { - LLDB_RECORD_METHOD_NO_ARGS(int64_t, SBTypeEnumMember, GetValueAsSigned); + LLDB_INSTRUMENT_METHOD_NO_ARGS(int64_t, SBTypeEnumMember, GetValueAsSigned); if (m_opaque_sp.get()) return m_opaque_sp->GetValueAsSigned(); @@ -75,7 +74,8 @@ } uint64_t SBTypeEnumMember::GetValueAsUnsigned() { - LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBTypeEnumMember, GetValueAsUnsigned); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint64_t, SBTypeEnumMember, + GetValueAsUnsigned); if (m_opaque_sp.get()) return m_opaque_sp->GetValueAsUnsigned(); @@ -83,7 +83,7 @@ } SBType SBTypeEnumMember::GetType() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeEnumMember, GetType); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBType, SBTypeEnumMember, GetType); SBType sb_type; if (m_opaque_sp.get()) { @@ -108,13 +108,13 @@ SBTypeEnumMemberList::SBTypeEnumMemberList() : m_opaque_up(new TypeEnumMemberListImpl()) { - LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeEnumMemberList); + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBTypeEnumMemberList); } SBTypeEnumMemberList::SBTypeEnumMemberList(const SBTypeEnumMemberList &rhs) : m_opaque_up(new TypeEnumMemberListImpl()) { - LLDB_RECORD_CONSTRUCTOR(SBTypeEnumMemberList, - (const lldb::SBTypeEnumMemberList &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBTypeEnumMemberList, + (const lldb::SBTypeEnumMemberList &), rhs); for (uint32_t i = 0, rhs_size = const_cast(rhs).GetSize(); @@ -123,21 +123,21 @@ } bool SBTypeEnumMemberList::IsValid() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeEnumMemberList, IsValid); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBTypeEnumMemberList, IsValid); return this->operator bool(); } SBTypeEnumMemberList::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMemberList, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, + SBTypeEnumMemberList, operator bool); return (m_opaque_up != nullptr); } SBTypeEnumMemberList &SBTypeEnumMemberList:: operator=(const SBTypeEnumMemberList &rhs) { - LLDB_RECORD_METHOD( - lldb::SBTypeEnumMemberList &, - SBTypeEnumMemberList, operator=,(const lldb::SBTypeEnumMemberList &), - rhs); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeEnumMemberList &, + SBTypeEnumMemberList, operator=, + (const lldb::SBTypeEnumMemberList &), rhs); if (this != &rhs) { m_opaque_up = std::make_unique(); @@ -151,8 +151,8 @@ } void SBTypeEnumMemberList::Append(SBTypeEnumMember enum_member) { - LLDB_RECORD_METHOD(void, SBTypeEnumMemberList, Append, - (lldb::SBTypeEnumMember), enum_member); + LLDB_INSTRUMENT_METHOD(void, SBTypeEnumMemberList, Append, + (lldb::SBTypeEnumMember), enum_member); if (enum_member.IsValid()) m_opaque_up->Append(enum_member.m_opaque_sp); @@ -160,8 +160,8 @@ SBTypeEnumMember SBTypeEnumMemberList::GetTypeEnumMemberAtIndex(uint32_t index) { - LLDB_RECORD_METHOD(lldb::SBTypeEnumMember, SBTypeEnumMemberList, - GetTypeEnumMemberAtIndex, (uint32_t), index); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeEnumMember, SBTypeEnumMemberList, + GetTypeEnumMemberAtIndex, (uint32_t), index); if (m_opaque_up) return SBTypeEnumMember(m_opaque_up->GetTypeEnumMemberAtIndex(index)); @@ -169,7 +169,7 @@ } uint32_t SBTypeEnumMemberList::GetSize() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeEnumMemberList, GetSize); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBTypeEnumMemberList, GetSize); return m_opaque_up->GetSize(); } @@ -178,9 +178,9 @@ 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_METHOD(bool, SBTypeEnumMember, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel), + description, description_level); Stream &strm = description.ref(); Index: lldb/source/API/SBTypeFilter.cpp =================================================================== --- lldb/source/API/SBTypeFilter.cpp +++ 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,34 @@ using namespace lldb; using namespace lldb_private; -SBTypeFilter::SBTypeFilter() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeFilter); } +SBTypeFilter::SBTypeFilter() { + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBTypeFilter); +} SBTypeFilter::SBTypeFilter(uint32_t options) : m_opaque_sp(TypeFilterImplSP(new TypeFilterImpl(options))) { - LLDB_RECORD_CONSTRUCTOR(SBTypeFilter, (uint32_t), options); + LLDB_INSTRUMENT_CONSTRUCTOR(SBTypeFilter, (uint32_t), options); } SBTypeFilter::SBTypeFilter(const lldb::SBTypeFilter &rhs) : m_opaque_sp(rhs.m_opaque_sp) { - LLDB_RECORD_CONSTRUCTOR(SBTypeFilter, (const lldb::SBTypeFilter &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBTypeFilter, (const lldb::SBTypeFilter &), rhs); } SBTypeFilter::~SBTypeFilter() = default; bool SBTypeFilter::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFilter, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBTypeFilter, IsValid); return this->operator bool(); } SBTypeFilter::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFilter, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBTypeFilter, operator bool); return m_opaque_sp.get() != nullptr; } uint32_t SBTypeFilter::GetOptions() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeFilter, GetOptions); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBTypeFilter, GetOptions); if (IsValid()) return m_opaque_sp->GetOptions(); @@ -49,7 +51,7 @@ } void SBTypeFilter::SetOptions(uint32_t value) { - LLDB_RECORD_METHOD(void, SBTypeFilter, SetOptions, (uint32_t), value); + LLDB_INSTRUMENT_METHOD(void, SBTypeFilter, SetOptions, (uint32_t), value); if (CopyOnWrite_Impl()) m_opaque_sp->SetOptions(value); @@ -57,9 +59,9 @@ 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_METHOD(bool, SBTypeFilter, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel), + description, description_level); if (!IsValid()) return false; @@ -70,15 +72,15 @@ } void SBTypeFilter::Clear() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBTypeFilter, Clear); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBTypeFilter, Clear); if (CopyOnWrite_Impl()) m_opaque_sp->Clear(); } uint32_t SBTypeFilter::GetNumberOfExpressionPaths() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeFilter, - GetNumberOfExpressionPaths); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBTypeFilter, + GetNumberOfExpressionPaths); if (IsValid()) return m_opaque_sp->GetCount(); @@ -86,8 +88,8 @@ } const char *SBTypeFilter::GetExpressionPathAtIndex(uint32_t i) { - LLDB_RECORD_METHOD(const char *, SBTypeFilter, GetExpressionPathAtIndex, - (uint32_t), i); + LLDB_INSTRUMENT_METHOD(const char *, SBTypeFilter, GetExpressionPathAtIndex, + (uint32_t), i); if (IsValid()) { const char *item = m_opaque_sp->GetExpressionPathAtIndex(i); @@ -99,8 +101,8 @@ } bool SBTypeFilter::ReplaceExpressionPathAtIndex(uint32_t i, const char *item) { - LLDB_RECORD_METHOD(bool, SBTypeFilter, ReplaceExpressionPathAtIndex, - (uint32_t, const char *), i, item); + LLDB_INSTRUMENT_METHOD(bool, SBTypeFilter, ReplaceExpressionPathAtIndex, + (uint32_t, const char *), i, item); if (CopyOnWrite_Impl()) return m_opaque_sp->SetExpressionPathAtIndex(i, item); @@ -109,16 +111,16 @@ } void SBTypeFilter::AppendExpressionPath(const char *item) { - LLDB_RECORD_METHOD(void, SBTypeFilter, AppendExpressionPath, (const char *), - item); + LLDB_INSTRUMENT_METHOD(void, SBTypeFilter, AppendExpressionPath, + (const char *), item); if (CopyOnWrite_Impl()) m_opaque_sp->AddExpressionPath(item); } lldb::SBTypeFilter &SBTypeFilter::operator=(const lldb::SBTypeFilter &rhs) { - LLDB_RECORD_METHOD(lldb::SBTypeFilter &, - SBTypeFilter, operator=,(const lldb::SBTypeFilter &), rhs); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeFilter &, SBTypeFilter, operator=, + (const lldb::SBTypeFilter &), rhs); if (this != &rhs) { m_opaque_sp = rhs.m_opaque_sp; @@ -127,8 +129,8 @@ } bool SBTypeFilter::operator==(lldb::SBTypeFilter &rhs) { - LLDB_RECORD_METHOD(bool, SBTypeFilter, operator==,(lldb::SBTypeFilter &), - rhs); + LLDB_INSTRUMENT_METHOD(bool, SBTypeFilter, operator==, (lldb::SBTypeFilter &), + rhs); if (!IsValid()) return !rhs.IsValid(); @@ -137,8 +139,8 @@ } bool SBTypeFilter::IsEqualTo(lldb::SBTypeFilter &rhs) { - LLDB_RECORD_METHOD(bool, SBTypeFilter, IsEqualTo, (lldb::SBTypeFilter &), - rhs); + LLDB_INSTRUMENT_METHOD(bool, SBTypeFilter, IsEqualTo, (lldb::SBTypeFilter &), + rhs); if (!IsValid()) return !rhs.IsValid(); @@ -155,8 +157,8 @@ } bool SBTypeFilter::operator!=(lldb::SBTypeFilter &rhs) { - LLDB_RECORD_METHOD(bool, SBTypeFilter, operator!=,(lldb::SBTypeFilter &), - rhs); + LLDB_INSTRUMENT_METHOD(bool, SBTypeFilter, operator!=, (lldb::SBTypeFilter &), + rhs); if (!IsValid()) return !rhs.IsValid(); Index: lldb/source/API/SBTypeFormat.cpp =================================================================== --- lldb/source/API/SBTypeFormat.cpp +++ 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,43 @@ using namespace lldb; using namespace lldb_private; -SBTypeFormat::SBTypeFormat() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeFormat); } +SBTypeFormat::SBTypeFormat() { + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBTypeFormat); +} 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_CONSTRUCTOR(SBTypeFormat, (lldb::Format, uint32_t), format, + options); } SBTypeFormat::SBTypeFormat(const char *type, uint32_t options) : m_opaque_sp(TypeFormatImplSP(new TypeFormatImpl_EnumType( ConstString(type ? type : ""), options))) { - LLDB_RECORD_CONSTRUCTOR(SBTypeFormat, (const char *, uint32_t), type, - options); + LLDB_INSTRUMENT_CONSTRUCTOR(SBTypeFormat, (const char *, uint32_t), 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_CONSTRUCTOR(SBTypeFormat, (const lldb::SBTypeFormat &), rhs); } SBTypeFormat::~SBTypeFormat() = default; bool SBTypeFormat::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFormat, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBTypeFormat, IsValid); return this->operator bool(); } SBTypeFormat::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFormat, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBTypeFormat, operator bool); return m_opaque_sp.get() != nullptr; } lldb::Format SBTypeFormat::GetFormat() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::Format, SBTypeFormat, GetFormat); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::Format, SBTypeFormat, GetFormat); if (IsValid() && m_opaque_sp->GetType() == TypeFormatImpl::Type::eTypeFormat) return ((TypeFormatImpl_Format *)m_opaque_sp.get())->GetFormat(); @@ -58,7 +60,7 @@ } const char *SBTypeFormat::GetTypeName() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeFormat, GetTypeName); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBTypeFormat, GetTypeName); if (IsValid() && m_opaque_sp->GetType() == TypeFormatImpl::Type::eTypeEnum) return ((TypeFormatImpl_EnumType *)m_opaque_sp.get()) @@ -68,7 +70,7 @@ } uint32_t SBTypeFormat::GetOptions() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeFormat, GetOptions); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBTypeFormat, GetOptions); if (IsValid()) return m_opaque_sp->GetOptions(); @@ -76,14 +78,14 @@ } void SBTypeFormat::SetFormat(lldb::Format fmt) { - LLDB_RECORD_METHOD(void, SBTypeFormat, SetFormat, (lldb::Format), fmt); + LLDB_INSTRUMENT_METHOD(void, SBTypeFormat, SetFormat, (lldb::Format), fmt); if (CopyOnWrite_Impl(Type::eTypeFormat)) ((TypeFormatImpl_Format *)m_opaque_sp.get())->SetFormat(fmt); } void SBTypeFormat::SetTypeName(const char *type) { - LLDB_RECORD_METHOD(void, SBTypeFormat, SetTypeName, (const char *), type); + LLDB_INSTRUMENT_METHOD(void, SBTypeFormat, SetTypeName, (const char *), type); if (CopyOnWrite_Impl(Type::eTypeEnum)) ((TypeFormatImpl_EnumType *)m_opaque_sp.get()) @@ -91,7 +93,7 @@ } void SBTypeFormat::SetOptions(uint32_t value) { - LLDB_RECORD_METHOD(void, SBTypeFormat, SetOptions, (uint32_t), value); + LLDB_INSTRUMENT_METHOD(void, SBTypeFormat, SetOptions, (uint32_t), value); if (CopyOnWrite_Impl(Type::eTypeKeepSame)) m_opaque_sp->SetOptions(value); @@ -99,9 +101,9 @@ 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_METHOD(bool, SBTypeFormat, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel), + description, description_level); if (!IsValid()) return false; @@ -112,8 +114,8 @@ } lldb::SBTypeFormat &SBTypeFormat::operator=(const lldb::SBTypeFormat &rhs) { - LLDB_RECORD_METHOD(lldb::SBTypeFormat &, - SBTypeFormat, operator=,(const lldb::SBTypeFormat &), rhs); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeFormat &, SBTypeFormat, operator=, + (const lldb::SBTypeFormat &), rhs); if (this != &rhs) { m_opaque_sp = rhs.m_opaque_sp; @@ -122,8 +124,8 @@ } bool SBTypeFormat::operator==(lldb::SBTypeFormat &rhs) { - LLDB_RECORD_METHOD(bool, SBTypeFormat, operator==,(lldb::SBTypeFormat &), - rhs); + LLDB_INSTRUMENT_METHOD(bool, SBTypeFormat, operator==, (lldb::SBTypeFormat &), + rhs); if (!IsValid()) return !rhs.IsValid(); @@ -131,8 +133,8 @@ } bool SBTypeFormat::IsEqualTo(lldb::SBTypeFormat &rhs) { - LLDB_RECORD_METHOD(bool, SBTypeFormat, IsEqualTo, (lldb::SBTypeFormat &), - rhs); + LLDB_INSTRUMENT_METHOD(bool, SBTypeFormat, IsEqualTo, (lldb::SBTypeFormat &), + rhs); if (!IsValid()) return !rhs.IsValid(); @@ -144,8 +146,8 @@ } bool SBTypeFormat::operator!=(lldb::SBTypeFormat &rhs) { - LLDB_RECORD_METHOD(bool, SBTypeFormat, operator!=,(lldb::SBTypeFormat &), - rhs); + LLDB_INSTRUMENT_METHOD(bool, SBTypeFormat, operator!=, (lldb::SBTypeFormat &), + rhs); if (!IsValid()) return !rhs.IsValid(); Index: lldb/source/API/SBTypeNameSpecifier.cpp =================================================================== --- lldb/source/API/SBTypeNameSpecifier.cpp +++ 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" @@ -18,20 +18,20 @@ using namespace lldb_private; SBTypeNameSpecifier::SBTypeNameSpecifier() { - LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeNameSpecifier); + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBTypeNameSpecifier); } SBTypeNameSpecifier::SBTypeNameSpecifier(const char *name, bool is_regex) : m_opaque_sp(new TypeNameSpecifierImpl(name, is_regex)) { - LLDB_RECORD_CONSTRUCTOR(SBTypeNameSpecifier, (const char *, bool), name, - is_regex); + LLDB_INSTRUMENT_CONSTRUCTOR(SBTypeNameSpecifier, (const char *, bool), 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_CONSTRUCTOR(SBTypeNameSpecifier, (lldb::SBType), type); if (type.IsValid()) m_opaque_sp = TypeNameSpecifierImplSP( @@ -40,24 +40,25 @@ SBTypeNameSpecifier::SBTypeNameSpecifier(const lldb::SBTypeNameSpecifier &rhs) : m_opaque_sp(rhs.m_opaque_sp) { - LLDB_RECORD_CONSTRUCTOR(SBTypeNameSpecifier, - (const lldb::SBTypeNameSpecifier &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBTypeNameSpecifier, + (const lldb::SBTypeNameSpecifier &), rhs); } SBTypeNameSpecifier::~SBTypeNameSpecifier() = default; bool SBTypeNameSpecifier::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeNameSpecifier, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBTypeNameSpecifier, IsValid); return this->operator bool(); } SBTypeNameSpecifier::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeNameSpecifier, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, + SBTypeNameSpecifier, operator bool); return m_opaque_sp.get() != nullptr; } const char *SBTypeNameSpecifier::GetName() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeNameSpecifier, GetName); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBTypeNameSpecifier, GetName); if (!IsValid()) return nullptr; @@ -66,7 +67,7 @@ } SBType SBTypeNameSpecifier::GetType() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeNameSpecifier, GetType); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBType, SBTypeNameSpecifier, GetType); if (!IsValid()) return SBType(); @@ -77,7 +78,7 @@ } bool SBTypeNameSpecifier::IsRegex() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeNameSpecifier, IsRegex); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBTypeNameSpecifier, IsRegex); if (!IsValid()) return false; @@ -87,9 +88,9 @@ 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_METHOD(bool, SBTypeNameSpecifier, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel), + description, description_level); if (!IsValid()) return false; @@ -100,9 +101,9 @@ lldb::SBTypeNameSpecifier &SBTypeNameSpecifier:: operator=(const lldb::SBTypeNameSpecifier &rhs) { - LLDB_RECORD_METHOD( - lldb::SBTypeNameSpecifier &, - SBTypeNameSpecifier, operator=,(const lldb::SBTypeNameSpecifier &), rhs); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeNameSpecifier &, + SBTypeNameSpecifier, operator=, + (const lldb::SBTypeNameSpecifier &), rhs); if (this != &rhs) { m_opaque_sp = rhs.m_opaque_sp; @@ -111,8 +112,8 @@ } bool SBTypeNameSpecifier::operator==(lldb::SBTypeNameSpecifier &rhs) { - LLDB_RECORD_METHOD( - bool, SBTypeNameSpecifier, operator==,(lldb::SBTypeNameSpecifier &), rhs); + LLDB_INSTRUMENT_METHOD(bool, SBTypeNameSpecifier, operator==, + (lldb::SBTypeNameSpecifier &), rhs); if (!IsValid()) return !rhs.IsValid(); @@ -120,8 +121,8 @@ } bool SBTypeNameSpecifier::IsEqualTo(lldb::SBTypeNameSpecifier &rhs) { - LLDB_RECORD_METHOD(bool, SBTypeNameSpecifier, IsEqualTo, - (lldb::SBTypeNameSpecifier &), rhs); + LLDB_INSTRUMENT_METHOD(bool, SBTypeNameSpecifier, IsEqualTo, + (lldb::SBTypeNameSpecifier &), rhs); if (!IsValid()) return !rhs.IsValid(); @@ -135,8 +136,8 @@ } bool SBTypeNameSpecifier::operator!=(lldb::SBTypeNameSpecifier &rhs) { - LLDB_RECORD_METHOD( - bool, SBTypeNameSpecifier, operator!=,(lldb::SBTypeNameSpecifier &), rhs); + LLDB_INSTRUMENT_METHOD(bool, SBTypeNameSpecifier, operator!=, + (lldb::SBTypeNameSpecifier &), rhs); if (!IsValid()) return !rhs.IsValid(); Index: lldb/source/API/SBTypeSummary.cpp =================================================================== --- lldb/source/API/SBTypeSummary.cpp +++ lldb/source/API/SBTypeSummary.cpp @@ -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,15 @@ using namespace lldb_private; SBTypeSummaryOptions::SBTypeSummaryOptions() { - LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeSummaryOptions); + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBTypeSummaryOptions); m_opaque_up = std::make_unique(); } SBTypeSummaryOptions::SBTypeSummaryOptions( const lldb::SBTypeSummaryOptions &rhs) { - LLDB_RECORD_CONSTRUCTOR(SBTypeSummaryOptions, - (const lldb::SBTypeSummaryOptions &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBTypeSummaryOptions, + (const lldb::SBTypeSummaryOptions &), rhs); m_opaque_up = clone(rhs.m_opaque_up); } @@ -35,18 +35,19 @@ SBTypeSummaryOptions::~SBTypeSummaryOptions() = default; bool SBTypeSummaryOptions::IsValid() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummaryOptions, IsValid); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBTypeSummaryOptions, IsValid); return this->operator bool(); } SBTypeSummaryOptions::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSummaryOptions, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, + SBTypeSummaryOptions, operator bool); return m_opaque_up.get(); } lldb::LanguageType SBTypeSummaryOptions::GetLanguage() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::LanguageType, SBTypeSummaryOptions, - GetLanguage); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::LanguageType, SBTypeSummaryOptions, + GetLanguage); if (IsValid()) return m_opaque_up->GetLanguage(); @@ -54,8 +55,8 @@ } lldb::TypeSummaryCapping SBTypeSummaryOptions::GetCapping() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::TypeSummaryCapping, SBTypeSummaryOptions, - GetCapping); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::TypeSummaryCapping, SBTypeSummaryOptions, + GetCapping); if (IsValid()) return m_opaque_up->GetCapping(); @@ -63,16 +64,16 @@ } void SBTypeSummaryOptions::SetLanguage(lldb::LanguageType l) { - LLDB_RECORD_METHOD(void, SBTypeSummaryOptions, SetLanguage, - (lldb::LanguageType), l); + LLDB_INSTRUMENT_METHOD(void, SBTypeSummaryOptions, SetLanguage, + (lldb::LanguageType), l); if (IsValid()) m_opaque_up->SetLanguage(l); } void SBTypeSummaryOptions::SetCapping(lldb::TypeSummaryCapping c) { - LLDB_RECORD_METHOD(void, SBTypeSummaryOptions, SetCapping, - (lldb::TypeSummaryCapping), c); + LLDB_INSTRUMENT_METHOD(void, SBTypeSummaryOptions, SetCapping, + (lldb::TypeSummaryCapping), c); if (IsValid()) m_opaque_up->SetCapping(c); @@ -102,20 +103,20 @@ SBTypeSummaryOptions::SBTypeSummaryOptions( const lldb_private::TypeSummaryOptions &lldb_object) : m_opaque_up(std::make_unique(lldb_object)) { - LLDB_RECORD_CONSTRUCTOR(SBTypeSummaryOptions, - (const lldb_private::TypeSummaryOptions &), - lldb_object); + LLDB_INSTRUMENT_CONSTRUCTOR(SBTypeSummaryOptions, + (const lldb_private::TypeSummaryOptions &), + lldb_object); } SBTypeSummary::SBTypeSummary() { - LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeSummary); + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBTypeSummary); } SBTypeSummary SBTypeSummary::CreateWithSummaryString(const char *data, uint32_t options) { - LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary, - CreateWithSummaryString, (const char *, uint32_t), - data, options); + LLDB_INSTRUMENT_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary, + CreateWithSummaryString, + (const char *, uint32_t), data, options); if (!data || data[0] == 0) return SBTypeSummary(); @@ -126,9 +127,9 @@ 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_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary, + CreateWithFunctionName, + (const char *, uint32_t), data, options); if (!data || data[0] == 0) return SBTypeSummary(); @@ -139,9 +140,9 @@ 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_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary, + CreateWithScriptCode, (const char *, uint32_t), + data, options); if (!data || data[0] == 0) return SBTypeSummary(); @@ -153,7 +154,7 @@ SBTypeSummary SBTypeSummary::CreateWithCallback(FormatCallback cb, uint32_t options, const char *description) { - LLDB_RECORD_STATIC_METHOD( + LLDB_INSTRUMENT_STATIC_METHOD( lldb::SBTypeSummary, SBTypeSummary, CreateWithCallback, (lldb::SBTypeSummary::FormatCallback, uint32_t, const char *), cb, options, description); @@ -180,23 +181,24 @@ SBTypeSummary::SBTypeSummary(const lldb::SBTypeSummary &rhs) : m_opaque_sp(rhs.m_opaque_sp) { - LLDB_RECORD_CONSTRUCTOR(SBTypeSummary, (const lldb::SBTypeSummary &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBTypeSummary, (const lldb::SBTypeSummary &), + rhs); } SBTypeSummary::~SBTypeSummary() = default; bool SBTypeSummary::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSummary, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBTypeSummary, IsValid); return this->operator bool(); } SBTypeSummary::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSummary, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBTypeSummary, operator bool); return m_opaque_sp.get() != nullptr; } bool SBTypeSummary::IsFunctionCode() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummary, IsFunctionCode); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBTypeSummary, IsFunctionCode); if (!IsValid()) return false; @@ -209,7 +211,7 @@ } bool SBTypeSummary::IsFunctionName() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummary, IsFunctionName); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBTypeSummary, IsFunctionName); if (!IsValid()) return false; @@ -222,7 +224,7 @@ } bool SBTypeSummary::IsSummaryString() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummary, IsSummaryString); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBTypeSummary, IsSummaryString); if (!IsValid()) return false; @@ -231,7 +233,7 @@ } const char *SBTypeSummary::GetData() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeSummary, GetData); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBTypeSummary, GetData); if (!IsValid()) return nullptr; @@ -249,7 +251,7 @@ } uint32_t SBTypeSummary::GetOptions() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeSummary, GetOptions); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBTypeSummary, GetOptions); if (!IsValid()) return lldb::eTypeOptionNone; @@ -257,7 +259,7 @@ } void SBTypeSummary::SetOptions(uint32_t value) { - LLDB_RECORD_METHOD(void, SBTypeSummary, SetOptions, (uint32_t), value); + LLDB_INSTRUMENT_METHOD(void, SBTypeSummary, SetOptions, (uint32_t), value); if (!CopyOnWrite_Impl()) return; @@ -265,8 +267,8 @@ } void SBTypeSummary::SetSummaryString(const char *data) { - LLDB_RECORD_METHOD(void, SBTypeSummary, SetSummaryString, (const char *), - data); + LLDB_INSTRUMENT_METHOD(void, SBTypeSummary, SetSummaryString, (const char *), + data); if (!IsValid()) return; @@ -278,8 +280,8 @@ } void SBTypeSummary::SetFunctionName(const char *data) { - LLDB_RECORD_METHOD(void, SBTypeSummary, SetFunctionName, (const char *), - data); + LLDB_INSTRUMENT_METHOD(void, SBTypeSummary, SetFunctionName, (const char *), + data); if (!IsValid()) return; @@ -291,8 +293,8 @@ } void SBTypeSummary::SetFunctionCode(const char *data) { - LLDB_RECORD_METHOD(void, SBTypeSummary, SetFunctionCode, (const char *), - data); + LLDB_INSTRUMENT_METHOD(void, SBTypeSummary, SetFunctionCode, (const char *), + data); if (!IsValid()) return; @@ -305,9 +307,9 @@ 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_METHOD(bool, SBTypeSummary, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel), + description, description_level); if (!CopyOnWrite_Impl()) return false; @@ -318,8 +320,8 @@ } bool SBTypeSummary::DoesPrintValue(lldb::SBValue value) { - LLDB_RECORD_METHOD(bool, SBTypeSummary, DoesPrintValue, (lldb::SBValue), - value); + LLDB_INSTRUMENT_METHOD(bool, SBTypeSummary, DoesPrintValue, (lldb::SBValue), + value); if (!IsValid()) return false; @@ -328,9 +330,8 @@ } lldb::SBTypeSummary &SBTypeSummary::operator=(const lldb::SBTypeSummary &rhs) { - LLDB_RECORD_METHOD(lldb::SBTypeSummary &, - SBTypeSummary, operator=,(const lldb::SBTypeSummary &), - rhs); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeSummary &, SBTypeSummary, operator=, + (const lldb::SBTypeSummary &), rhs); if (this != &rhs) { m_opaque_sp = rhs.m_opaque_sp; @@ -339,8 +340,8 @@ } bool SBTypeSummary::operator==(lldb::SBTypeSummary &rhs) { - LLDB_RECORD_METHOD(bool, SBTypeSummary, operator==,(lldb::SBTypeSummary &), - rhs); + LLDB_INSTRUMENT_METHOD(bool, SBTypeSummary, operator==, + (lldb::SBTypeSummary &), rhs); if (!IsValid()) return !rhs.IsValid(); @@ -348,8 +349,8 @@ } bool SBTypeSummary::IsEqualTo(lldb::SBTypeSummary &rhs) { - LLDB_RECORD_METHOD(bool, SBTypeSummary, IsEqualTo, (lldb::SBTypeSummary &), - rhs); + LLDB_INSTRUMENT_METHOD(bool, SBTypeSummary, IsEqualTo, + (lldb::SBTypeSummary &), rhs); if (IsValid()) { // valid and invalid are different @@ -389,8 +390,8 @@ } bool SBTypeSummary::operator!=(lldb::SBTypeSummary &rhs) { - LLDB_RECORD_METHOD(bool, SBTypeSummary, operator!=,(lldb::SBTypeSummary &), - rhs); + LLDB_INSTRUMENT_METHOD(bool, SBTypeSummary, operator!=, + (lldb::SBTypeSummary &), rhs); if (!IsValid()) return !rhs.IsValid(); Index: lldb/source/API/SBTypeSynthetic.cpp =================================================================== --- lldb/source/API/SBTypeSynthetic.cpp +++ 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" @@ -17,14 +17,14 @@ using namespace lldb_private; SBTypeSynthetic::SBTypeSynthetic() { - LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeSynthetic); + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBTypeSynthetic); } SBTypeSynthetic SBTypeSynthetic::CreateWithClassName(const char *data, uint32_t options) { - LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSynthetic, SBTypeSynthetic, - CreateWithClassName, (const char *, uint32_t), data, - options); + LLDB_INSTRUMENT_STATIC_METHOD(lldb::SBTypeSynthetic, SBTypeSynthetic, + CreateWithClassName, (const char *, uint32_t), + data, options); if (!data || data[0] == 0) return SBTypeSynthetic(); @@ -34,9 +34,9 @@ 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_STATIC_METHOD(lldb::SBTypeSynthetic, SBTypeSynthetic, + CreateWithScriptCode, (const char *, uint32_t), + data, options); if (!data || data[0] == 0) return SBTypeSynthetic(); @@ -46,24 +46,24 @@ SBTypeSynthetic::SBTypeSynthetic(const lldb::SBTypeSynthetic &rhs) : m_opaque_sp(rhs.m_opaque_sp) { - LLDB_RECORD_CONSTRUCTOR(SBTypeSynthetic, (const lldb::SBTypeSynthetic &), - rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBTypeSynthetic, (const lldb::SBTypeSynthetic &), + rhs); } SBTypeSynthetic::~SBTypeSynthetic() = default; bool SBTypeSynthetic::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSynthetic, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBTypeSynthetic, IsValid); return this->operator bool(); } SBTypeSynthetic::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSynthetic, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBTypeSynthetic, operator bool); return m_opaque_sp.get() != nullptr; } bool SBTypeSynthetic::IsClassCode() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSynthetic, IsClassCode); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBTypeSynthetic, IsClassCode); if (!IsValid()) return false; @@ -72,7 +72,7 @@ } bool SBTypeSynthetic::IsClassName() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSynthetic, IsClassName); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBTypeSynthetic, IsClassName); if (!IsValid()) return false; @@ -80,7 +80,7 @@ } const char *SBTypeSynthetic::GetData() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeSynthetic, GetData); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBTypeSynthetic, GetData); if (!IsValid()) return nullptr; @@ -91,21 +91,23 @@ } void SBTypeSynthetic::SetClassName(const char *data) { - LLDB_RECORD_METHOD(void, SBTypeSynthetic, SetClassName, (const char *), data); + LLDB_INSTRUMENT_METHOD(void, SBTypeSynthetic, SetClassName, (const char *), + data); if (IsValid() && data && *data) m_opaque_sp->SetPythonClassName(data); } void SBTypeSynthetic::SetClassCode(const char *data) { - LLDB_RECORD_METHOD(void, SBTypeSynthetic, SetClassCode, (const char *), data); + LLDB_INSTRUMENT_METHOD(void, SBTypeSynthetic, SetClassCode, (const char *), + data); if (IsValid() && data && *data) m_opaque_sp->SetPythonCode(data); } uint32_t SBTypeSynthetic::GetOptions() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeSynthetic, GetOptions); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBTypeSynthetic, GetOptions); if (!IsValid()) return lldb::eTypeOptionNone; @@ -113,7 +115,7 @@ } void SBTypeSynthetic::SetOptions(uint32_t value) { - LLDB_RECORD_METHOD(void, SBTypeSynthetic, SetOptions, (uint32_t), value); + LLDB_INSTRUMENT_METHOD(void, SBTypeSynthetic, SetOptions, (uint32_t), value); if (!CopyOnWrite_Impl()) return; @@ -122,9 +124,9 @@ 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_METHOD(bool, SBTypeSynthetic, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel), + description, description_level); if (m_opaque_sp) { description.Printf("%s\n", m_opaque_sp->GetDescription().c_str()); @@ -135,9 +137,8 @@ lldb::SBTypeSynthetic &SBTypeSynthetic:: operator=(const lldb::SBTypeSynthetic &rhs) { - LLDB_RECORD_METHOD(lldb::SBTypeSynthetic &, - SBTypeSynthetic, operator=,(const lldb::SBTypeSynthetic &), - rhs); + LLDB_INSTRUMENT_METHOD(lldb::SBTypeSynthetic &, SBTypeSynthetic, operator=, + (const lldb::SBTypeSynthetic &), rhs); if (this != &rhs) { m_opaque_sp = rhs.m_opaque_sp; @@ -146,8 +147,8 @@ } bool SBTypeSynthetic::operator==(lldb::SBTypeSynthetic &rhs) { - LLDB_RECORD_METHOD( - bool, SBTypeSynthetic, operator==,(lldb::SBTypeSynthetic &), rhs); + LLDB_INSTRUMENT_METHOD(bool, SBTypeSynthetic, operator==, + (lldb::SBTypeSynthetic &), rhs); if (!IsValid()) return !rhs.IsValid(); @@ -155,8 +156,8 @@ } bool SBTypeSynthetic::IsEqualTo(lldb::SBTypeSynthetic &rhs) { - LLDB_RECORD_METHOD(bool, SBTypeSynthetic, IsEqualTo, - (lldb::SBTypeSynthetic &), rhs); + LLDB_INSTRUMENT_METHOD(bool, SBTypeSynthetic, IsEqualTo, + (lldb::SBTypeSynthetic &), rhs); if (!IsValid()) return !rhs.IsValid(); @@ -174,8 +175,8 @@ } bool SBTypeSynthetic::operator!=(lldb::SBTypeSynthetic &rhs) { - LLDB_RECORD_METHOD( - bool, SBTypeSynthetic, operator!=,(lldb::SBTypeSynthetic &), rhs); + LLDB_INSTRUMENT_METHOD(bool, SBTypeSynthetic, operator!=, + (lldb::SBTypeSynthetic &), rhs); if (!IsValid()) return !rhs.IsValid(); Index: lldb/source/API/SBUnixSignals.cpp =================================================================== --- lldb/source/API/SBUnixSignals.cpp +++ lldb/source/API/SBUnixSignals.cpp @@ -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" @@ -18,12 +18,13 @@ using namespace lldb_private; SBUnixSignals::SBUnixSignals() { - LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBUnixSignals); + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBUnixSignals); } SBUnixSignals::SBUnixSignals(const SBUnixSignals &rhs) : m_opaque_wp(rhs.m_opaque_wp) { - LLDB_RECORD_CONSTRUCTOR(SBUnixSignals, (const lldb::SBUnixSignals &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBUnixSignals, (const lldb::SBUnixSignals &), + rhs); } SBUnixSignals::SBUnixSignals(ProcessSP &process_sp) @@ -33,9 +34,8 @@ : 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_METHOD(const lldb::SBUnixSignals &, SBUnixSignals, operator=, + (const lldb::SBUnixSignals &), rhs); if (this != &rhs) m_opaque_wp = rhs.m_opaque_wp; @@ -51,24 +51,24 @@ } void SBUnixSignals::Clear() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBUnixSignals, Clear); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBUnixSignals, Clear); m_opaque_wp.reset(); } bool SBUnixSignals::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBUnixSignals, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBUnixSignals, IsValid); return this->operator bool(); } SBUnixSignals::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBUnixSignals, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBUnixSignals, operator bool); return static_cast(GetSP()); } const char *SBUnixSignals::GetSignalAsCString(int32_t signo) const { - LLDB_RECORD_METHOD_CONST(const char *, SBUnixSignals, GetSignalAsCString, - (int32_t), signo); + LLDB_INSTRUMENT_METHOD_CONST(const char *, SBUnixSignals, GetSignalAsCString, + (int32_t), signo); if (auto signals_sp = GetSP()) return signals_sp->GetSignalAsCString(signo); @@ -77,8 +77,8 @@ } int32_t SBUnixSignals::GetSignalNumberFromName(const char *name) const { - LLDB_RECORD_METHOD_CONST(int32_t, SBUnixSignals, GetSignalNumberFromName, - (const char *), name); + LLDB_INSTRUMENT_METHOD_CONST(int32_t, SBUnixSignals, GetSignalNumberFromName, + (const char *), name); if (auto signals_sp = GetSP()) return signals_sp->GetSignalNumberFromName(name); @@ -87,8 +87,8 @@ } bool SBUnixSignals::GetShouldSuppress(int32_t signo) const { - LLDB_RECORD_METHOD_CONST(bool, SBUnixSignals, GetShouldSuppress, (int32_t), - signo); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBUnixSignals, GetShouldSuppress, + (int32_t), signo); if (auto signals_sp = GetSP()) return signals_sp->GetShouldSuppress(signo); @@ -97,8 +97,8 @@ } bool SBUnixSignals::SetShouldSuppress(int32_t signo, bool value) { - LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldSuppress, (int32_t, bool), - signo, value); + LLDB_INSTRUMENT_METHOD(bool, SBUnixSignals, SetShouldSuppress, + (int32_t, bool), signo, value); auto signals_sp = GetSP(); @@ -109,8 +109,8 @@ } bool SBUnixSignals::GetShouldStop(int32_t signo) const { - LLDB_RECORD_METHOD_CONST(bool, SBUnixSignals, GetShouldStop, (int32_t), - signo); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBUnixSignals, GetShouldStop, (int32_t), + signo); if (auto signals_sp = GetSP()) return signals_sp->GetShouldStop(signo); @@ -119,8 +119,8 @@ } bool SBUnixSignals::SetShouldStop(int32_t signo, bool value) { - LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldStop, (int32_t, bool), signo, - value); + LLDB_INSTRUMENT_METHOD(bool, SBUnixSignals, SetShouldStop, (int32_t, bool), + signo, value); auto signals_sp = GetSP(); @@ -131,8 +131,8 @@ } bool SBUnixSignals::GetShouldNotify(int32_t signo) const { - LLDB_RECORD_METHOD_CONST(bool, SBUnixSignals, GetShouldNotify, (int32_t), - signo); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBUnixSignals, GetShouldNotify, (int32_t), + signo); if (auto signals_sp = GetSP()) return signals_sp->GetShouldNotify(signo); @@ -141,8 +141,8 @@ } bool SBUnixSignals::SetShouldNotify(int32_t signo, bool value) { - LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldNotify, (int32_t, bool), - signo, value); + LLDB_INSTRUMENT_METHOD(bool, SBUnixSignals, SetShouldNotify, (int32_t, bool), + signo, value); auto signals_sp = GetSP(); @@ -153,7 +153,7 @@ } int32_t SBUnixSignals::GetNumSignals() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(int32_t, SBUnixSignals, GetNumSignals); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(int32_t, SBUnixSignals, GetNumSignals); if (auto signals_sp = GetSP()) return signals_sp->GetNumSignals(); @@ -162,8 +162,8 @@ } int32_t SBUnixSignals::GetSignalAtIndex(int32_t index) const { - LLDB_RECORD_METHOD_CONST(int32_t, SBUnixSignals, GetSignalAtIndex, (int32_t), - index); + LLDB_INSTRUMENT_METHOD_CONST(int32_t, SBUnixSignals, GetSignalAtIndex, + (int32_t), index); if (auto signals_sp = GetSP()) return signals_sp->GetSignalAtIndex(index); Index: lldb/source/API/SBValue.cpp =================================================================== --- lldb/source/API/SBValue.cpp +++ 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,23 @@ Status m_lock_error; }; -SBValue::SBValue() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBValue); } +SBValue::SBValue() { LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBValue); } SBValue::SBValue(const lldb::ValueObjectSP &value_sp) { - LLDB_RECORD_CONSTRUCTOR(SBValue, (const lldb::ValueObjectSP &), value_sp); + LLDB_INSTRUMENT_CONSTRUCTOR(SBValue, (const lldb::ValueObjectSP &), value_sp); SetSP(value_sp); } SBValue::SBValue(const SBValue &rhs) { - LLDB_RECORD_CONSTRUCTOR(SBValue, (const lldb::SBValue &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBValue, (const lldb::SBValue &), rhs); SetSP(rhs.m_opaque_sp); } SBValue &SBValue::operator=(const SBValue &rhs) { - LLDB_RECORD_METHOD(lldb::SBValue &, - SBValue, operator=,(const lldb::SBValue &), rhs); + LLDB_INSTRUMENT_METHOD(lldb::SBValue &, SBValue, operator=, + (const lldb::SBValue &), rhs); if (this != &rhs) { SetSP(rhs.m_opaque_sp); @@ -242,11 +242,11 @@ SBValue::~SBValue() = default; bool SBValue::IsValid() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsValid); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBValue, IsValid); return this->operator bool(); } SBValue::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBValue, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBValue, operator bool); // 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 +256,13 @@ } void SBValue::Clear() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBValue, Clear); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBValue, Clear); m_opaque_sp.reset(); } SBError SBValue::GetError() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBValue, GetError); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBError, SBValue, GetError); SBError sb_error; @@ -278,7 +278,7 @@ } user_id_t SBValue::GetID() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::user_id_t, SBValue, GetID); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::user_id_t, SBValue, GetID); ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -288,7 +288,7 @@ } const char *SBValue::GetName() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetName); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBValue, GetName); const char *name = nullptr; ValueLocker locker; @@ -300,7 +300,7 @@ } const char *SBValue::GetTypeName() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetTypeName); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBValue, GetTypeName); const char *name = nullptr; ValueLocker locker; @@ -313,7 +313,7 @@ } const char *SBValue::GetDisplayTypeName() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetDisplayTypeName); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBValue, GetDisplayTypeName); const char *name = nullptr; ValueLocker locker; @@ -326,7 +326,7 @@ } size_t SBValue::GetByteSize() { - LLDB_RECORD_METHOD_NO_ARGS(size_t, SBValue, GetByteSize); + LLDB_INSTRUMENT_METHOD_NO_ARGS(size_t, SBValue, GetByteSize); size_t result = 0; @@ -340,7 +340,7 @@ } bool SBValue::IsInScope() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsInScope); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBValue, IsInScope); bool result = false; @@ -354,7 +354,7 @@ } const char *SBValue::GetValue() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetValue); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBValue, GetValue); const char *cstr = nullptr; ValueLocker locker; @@ -367,7 +367,7 @@ } ValueType SBValue::GetValueType() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::ValueType, SBValue, GetValueType); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::ValueType, SBValue, GetValueType); ValueType result = eValueTypeInvalid; ValueLocker locker; @@ -379,7 +379,7 @@ } const char *SBValue::GetObjectDescription() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetObjectDescription); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBValue, GetObjectDescription); const char *cstr = nullptr; ValueLocker locker; @@ -392,7 +392,7 @@ } SBType SBValue::GetType() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBValue, GetType); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBType, SBValue, GetType); SBType sb_type; ValueLocker locker; @@ -407,7 +407,7 @@ } bool SBValue::GetValueDidChange() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, GetValueDidChange); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBValue, GetValueDidChange); bool result = false; ValueLocker locker; @@ -421,7 +421,7 @@ } const char *SBValue::GetSummary() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetSummary); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBValue, GetSummary); const char *cstr = nullptr; ValueLocker locker; @@ -435,9 +435,9 @@ 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_METHOD(const char *, SBValue, GetSummary, + (lldb::SBStream &, lldb::SBTypeSummaryOptions &), + stream, options); ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -451,7 +451,7 @@ } const char *SBValue::GetLocation() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetLocation); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBValue, GetLocation); const char *cstr = nullptr; ValueLocker locker; @@ -464,16 +464,16 @@ // 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_METHOD(bool, SBValue, SetValueFromCString, (const char *), + value_str); lldb::SBError dummy; return SetValueFromCString(value_str, dummy); } bool SBValue::SetValueFromCString(const char *value_str, lldb::SBError &error) { - LLDB_RECORD_METHOD(bool, SBValue, SetValueFromCString, - (const char *, lldb::SBError &), value_str, error); + LLDB_INSTRUMENT_METHOD(bool, SBValue, SetValueFromCString, + (const char *, lldb::SBError &), value_str, error); bool success = false; ValueLocker locker; @@ -488,7 +488,7 @@ } lldb::SBTypeFormat SBValue::GetTypeFormat() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeFormat, SBValue, GetTypeFormat); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBTypeFormat, SBValue, GetTypeFormat); lldb::SBTypeFormat format; ValueLocker locker; @@ -504,7 +504,7 @@ } lldb::SBTypeSummary SBValue::GetTypeSummary() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeSummary, SBValue, GetTypeSummary); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBTypeSummary, SBValue, GetTypeSummary); lldb::SBTypeSummary summary; ValueLocker locker; @@ -520,7 +520,7 @@ } lldb::SBTypeFilter SBValue::GetTypeFilter() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeFilter, SBValue, GetTypeFilter); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBTypeFilter, SBValue, GetTypeFilter); lldb::SBTypeFilter filter; ValueLocker locker; @@ -540,7 +540,8 @@ } lldb::SBTypeSynthetic SBValue::GetTypeSynthetic() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeSynthetic, SBValue, GetTypeSynthetic); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBTypeSynthetic, SBValue, + GetTypeSynthetic); lldb::SBTypeSynthetic synthetic; ValueLocker locker; @@ -561,9 +562,9 @@ 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_METHOD(lldb::SBValue, SBValue, CreateChildAtOffset, + (const char *, uint32_t, lldb::SBType), name, offset, + type); lldb::SBValue sb_value; ValueLocker locker; @@ -581,7 +582,7 @@ } lldb::SBValue SBValue::Cast(SBType type) { - LLDB_RECORD_METHOD(lldb::SBValue, SBValue, Cast, (lldb::SBType), type); + LLDB_INSTRUMENT_METHOD(lldb::SBValue, SBValue, Cast, (lldb::SBType), type); lldb::SBValue sb_value; ValueLocker locker; @@ -595,8 +596,8 @@ 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_METHOD(lldb::SBValue, SBValue, CreateValueFromExpression, + (const char *, const char *), name, expression); SBExpressionOptions options; options.ref().SetKeepInMemory(true); @@ -606,9 +607,10 @@ 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_METHOD( + lldb::SBValue, SBValue, CreateValueFromExpression, + (const char *, const char *, lldb::SBExpressionOptions &), name, + expression, options); lldb::SBValue sb_value; ValueLocker locker; @@ -628,9 +630,9 @@ 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_METHOD(lldb::SBValue, SBValue, CreateValueFromAddress, + (const char *, lldb::addr_t, lldb::SBType), name, + address, sb_type); lldb::SBValue sb_value; ValueLocker locker; @@ -649,9 +651,9 @@ 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_METHOD(lldb::SBValue, SBValue, CreateValueFromData, + (const char *, lldb::SBData, lldb::SBType), name, data, + sb_type); lldb::SBValue sb_value; lldb::ValueObjectSP new_value_sp; @@ -669,7 +671,8 @@ } SBValue SBValue::GetChildAtIndex(uint32_t idx) { - LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildAtIndex, (uint32_t), idx); + LLDB_INSTRUMENT_METHOD(lldb::SBValue, SBValue, GetChildAtIndex, (uint32_t), + idx); const bool can_create_synthetic = false; lldb::DynamicValueType use_dynamic = eNoDynamicValues; @@ -686,9 +689,9 @@ 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_METHOD(lldb::SBValue, SBValue, GetChildAtIndex, + (uint32_t, lldb::DynamicValueType, bool), idx, + use_dynamic, can_create_synthetic); lldb::ValueObjectSP child_sp; @@ -709,8 +712,8 @@ } uint32_t SBValue::GetIndexOfChildWithName(const char *name) { - LLDB_RECORD_METHOD(uint32_t, SBValue, GetIndexOfChildWithName, (const char *), - name); + LLDB_INSTRUMENT_METHOD(uint32_t, SBValue, GetIndexOfChildWithName, + (const char *), name); uint32_t idx = UINT32_MAX; ValueLocker locker; @@ -722,8 +725,8 @@ } SBValue SBValue::GetChildMemberWithName(const char *name) { - LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName, - (const char *), name); + LLDB_INSTRUMENT_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName, + (const char *), name); lldb::DynamicValueType use_dynamic_value = eNoDynamicValues; TargetSP target_sp; @@ -738,9 +741,9 @@ 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_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName, + (const char *, lldb::DynamicValueType), name, + use_dynamic_value); lldb::ValueObjectSP child_sp; const ConstString str_name(name); @@ -758,8 +761,8 @@ } lldb::SBValue SBValue::GetDynamicValue(lldb::DynamicValueType use_dynamic) { - LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetDynamicValue, - (lldb::DynamicValueType), use_dynamic); + LLDB_INSTRUMENT_METHOD(lldb::SBValue, SBValue, GetDynamicValue, + (lldb::DynamicValueType), use_dynamic); SBValue value_sb; if (IsValid()) { @@ -771,7 +774,7 @@ } lldb::SBValue SBValue::GetStaticValue() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, GetStaticValue); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBValue, SBValue, GetStaticValue); SBValue value_sb; if (IsValid()) { @@ -784,7 +787,7 @@ } lldb::SBValue SBValue::GetNonSyntheticValue() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, GetNonSyntheticValue); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBValue, SBValue, GetNonSyntheticValue); SBValue value_sb; if (IsValid()) { @@ -796,8 +799,8 @@ } lldb::DynamicValueType SBValue::GetPreferDynamicValue() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::DynamicValueType, SBValue, - GetPreferDynamicValue); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::DynamicValueType, SBValue, + GetPreferDynamicValue); if (!IsValid()) return eNoDynamicValues; @@ -805,15 +808,15 @@ } void SBValue::SetPreferDynamicValue(lldb::DynamicValueType use_dynamic) { - LLDB_RECORD_METHOD(void, SBValue, SetPreferDynamicValue, - (lldb::DynamicValueType), use_dynamic); + LLDB_INSTRUMENT_METHOD(void, SBValue, SetPreferDynamicValue, + (lldb::DynamicValueType), use_dynamic); if (IsValid()) return m_opaque_sp->SetUseDynamic(use_dynamic); } bool SBValue::GetPreferSyntheticValue() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, GetPreferSyntheticValue); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBValue, GetPreferSyntheticValue); if (!IsValid()) return false; @@ -821,15 +824,15 @@ } void SBValue::SetPreferSyntheticValue(bool use_synthetic) { - LLDB_RECORD_METHOD(void, SBValue, SetPreferSyntheticValue, (bool), - use_synthetic); + LLDB_INSTRUMENT_METHOD(void, SBValue, SetPreferSyntheticValue, (bool), + use_synthetic); if (IsValid()) return m_opaque_sp->SetUseSynthetic(use_synthetic); } bool SBValue::IsDynamic() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsDynamic); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBValue, IsDynamic); ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -839,7 +842,7 @@ } bool SBValue::IsSynthetic() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsSynthetic); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBValue, IsSynthetic); ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -849,7 +852,7 @@ } bool SBValue::IsSyntheticChildrenGenerated() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsSyntheticChildrenGenerated); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBValue, IsSyntheticChildrenGenerated); ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -859,7 +862,8 @@ } void SBValue::SetSyntheticChildrenGenerated(bool is) { - LLDB_RECORD_METHOD(void, SBValue, SetSyntheticChildrenGenerated, (bool), is); + LLDB_INSTRUMENT_METHOD(void, SBValue, SetSyntheticChildrenGenerated, (bool), + is); ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -868,8 +872,8 @@ } lldb::SBValue SBValue::GetValueForExpressionPath(const char *expr_path) { - LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetValueForExpressionPath, - (const char *), expr_path); + LLDB_INSTRUMENT_METHOD(lldb::SBValue, SBValue, GetValueForExpressionPath, + (const char *), expr_path); lldb::ValueObjectSP child_sp; ValueLocker locker; @@ -886,8 +890,8 @@ } 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_METHOD(int64_t, SBValue, GetValueAsSigned, + (lldb::SBError &, int64_t), error, fail_value); error.Clear(); ValueLocker locker; @@ -907,8 +911,8 @@ } 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_METHOD(uint64_t, SBValue, GetValueAsUnsigned, + (lldb::SBError &, uint64_t), error, fail_value); error.Clear(); ValueLocker locker; @@ -928,7 +932,8 @@ } int64_t SBValue::GetValueAsSigned(int64_t fail_value) { - LLDB_RECORD_METHOD(int64_t, SBValue, GetValueAsSigned, (int64_t), fail_value); + LLDB_INSTRUMENT_METHOD(int64_t, SBValue, GetValueAsSigned, (int64_t), + fail_value); ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -939,8 +944,8 @@ } uint64_t SBValue::GetValueAsUnsigned(uint64_t fail_value) { - LLDB_RECORD_METHOD(uint64_t, SBValue, GetValueAsUnsigned, (uint64_t), - fail_value); + LLDB_INSTRUMENT_METHOD(uint64_t, SBValue, GetValueAsUnsigned, (uint64_t), + fail_value); ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -951,7 +956,7 @@ } bool SBValue::MightHaveChildren() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, MightHaveChildren); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBValue, MightHaveChildren); bool has_children = false; ValueLocker locker; @@ -963,7 +968,7 @@ } bool SBValue::IsRuntimeSupportValue() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsRuntimeSupportValue); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBValue, IsRuntimeSupportValue); bool is_support = false; ValueLocker locker; @@ -975,13 +980,13 @@ } uint32_t SBValue::GetNumChildren() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBValue, GetNumChildren); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBValue, GetNumChildren); return GetNumChildren(UINT32_MAX); } uint32_t SBValue::GetNumChildren(uint32_t max) { - LLDB_RECORD_METHOD(uint32_t, SBValue, GetNumChildren, (uint32_t), max); + LLDB_INSTRUMENT_METHOD(uint32_t, SBValue, GetNumChildren, (uint32_t), max); uint32_t num_children = 0; @@ -994,7 +999,7 @@ } SBValue SBValue::Dereference() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, Dereference); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBValue, SBValue, Dereference); SBValue sb_value; ValueLocker locker; @@ -1009,13 +1014,13 @@ // Deprecated - please use GetType().IsPointerType() instead. bool SBValue::TypeIsPointerType() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, TypeIsPointerType); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBValue, TypeIsPointerType); return GetType().IsPointerType(); } void *SBValue::GetOpaqueType() { - LLDB_RECORD_METHOD_NO_ARGS(void *, SBValue, GetOpaqueType); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void *, SBValue, GetOpaqueType); ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -1025,7 +1030,7 @@ } lldb::SBTarget SBValue::GetTarget() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBValue, GetTarget); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBTarget, SBValue, GetTarget); SBTarget sb_target; TargetSP target_sp; @@ -1038,7 +1043,7 @@ } lldb::SBProcess SBValue::GetProcess() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBValue, GetProcess); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBProcess, SBValue, GetProcess); SBProcess sb_process; ProcessSP process_sp; @@ -1051,7 +1056,7 @@ } lldb::SBThread SBValue::GetThread() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBThread, SBValue, GetThread); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBThread, SBValue, GetThread); SBThread sb_thread; ThreadSP thread_sp; @@ -1064,7 +1069,7 @@ } lldb::SBFrame SBValue::GetFrame() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFrame, SBValue, GetFrame); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBFrame, SBValue, GetFrame); SBFrame sb_frame; StackFrameSP frame_sp; @@ -1085,7 +1090,7 @@ } lldb::ValueObjectSP SBValue::GetSP() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ValueObjectSP, SBValue, GetSP); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::ValueObjectSP, SBValue, GetSP); ValueLocker locker; return GetSP(locker); @@ -1146,8 +1151,8 @@ } bool SBValue::GetExpressionPath(SBStream &description) { - LLDB_RECORD_METHOD(bool, SBValue, GetExpressionPath, (lldb::SBStream &), - description); + LLDB_INSTRUMENT_METHOD(bool, SBValue, GetExpressionPath, (lldb::SBStream &), + description); ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -1160,8 +1165,9 @@ 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_METHOD(bool, SBValue, GetExpressionPath, + (lldb::SBStream &, bool), description, + qualify_cxx_base_classes); ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -1173,8 +1179,8 @@ } lldb::SBValue SBValue::EvaluateExpression(const char *expr) const { - LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValue, EvaluateExpression, - (const char *), expr); + LLDB_INSTRUMENT_METHOD_CONST(lldb::SBValue, SBValue, EvaluateExpression, + (const char *), expr); ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -1196,9 +1202,9 @@ 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_METHOD_CONST( + lldb::SBValue, SBValue, EvaluateExpression, + (const char *, const lldb::SBExpressionOptions &), expr, options); return EvaluateExpression(expr, options, nullptr); } @@ -1206,12 +1212,11 @@ lldb::SBValue SBValue::EvaluateExpression(const char *expr, const SBExpressionOptions &options, const char *name) const { - LLDB_RECORD_METHOD_CONST( + LLDB_INSTRUMENT_METHOD_CONST( lldb::SBValue, SBValue, EvaluateExpression, (const char *, const lldb::SBExpressionOptions &, const char *), expr, options, name); - if (!expr || expr[0] == '\0') { return SBValue(); } @@ -1249,8 +1254,8 @@ } bool SBValue::GetDescription(SBStream &description) { - LLDB_RECORD_METHOD(bool, SBValue, GetDescription, (lldb::SBStream &), - description); + LLDB_INSTRUMENT_METHOD(bool, SBValue, GetDescription, (lldb::SBStream &), + description); Stream &strm = description.ref(); @@ -1265,7 +1270,7 @@ } lldb::Format SBValue::GetFormat() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::Format, SBValue, GetFormat); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::Format, SBValue, GetFormat); ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -1275,7 +1280,7 @@ } void SBValue::SetFormat(lldb::Format format) { - LLDB_RECORD_METHOD(void, SBValue, SetFormat, (lldb::Format), format); + LLDB_INSTRUMENT_METHOD(void, SBValue, SetFormat, (lldb::Format), format); ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -1284,7 +1289,7 @@ } lldb::SBValue SBValue::AddressOf() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, AddressOf); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBValue, SBValue, AddressOf); SBValue sb_value; ValueLocker locker; @@ -1299,7 +1304,7 @@ } lldb::addr_t SBValue::GetLoadAddress() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBValue, GetLoadAddress); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::addr_t, SBValue, GetLoadAddress); lldb::addr_t value = LLDB_INVALID_ADDRESS; ValueLocker locker; @@ -1329,7 +1334,7 @@ } lldb::SBAddress SBValue::GetAddress() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBValue, GetAddress); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBAddress, SBValue, GetAddress); Address addr; ValueLocker locker; @@ -1358,8 +1363,8 @@ } 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_METHOD(lldb::SBData, SBValue, GetPointeeData, + (uint32_t, uint32_t), item_idx, item_count); lldb::SBData sb_data; ValueLocker locker; @@ -1378,7 +1383,7 @@ } lldb::SBData SBValue::GetData() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBData, SBValue, GetData); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBData, SBValue, GetData); lldb::SBData sb_data; ValueLocker locker; @@ -1395,8 +1400,8 @@ } bool SBValue::SetData(lldb::SBData &data, SBError &error) { - LLDB_RECORD_METHOD(bool, SBValue, SetData, (lldb::SBData &, lldb::SBError &), - data, error); + LLDB_INSTRUMENT_METHOD(bool, SBValue, SetData, + (lldb::SBData &, lldb::SBError &), data, error); ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -1430,7 +1435,8 @@ } lldb::SBValue SBValue::Clone(const char *new_name) { - LLDB_RECORD_METHOD(lldb::SBValue, SBValue, Clone, (const char *), new_name); + LLDB_INSTRUMENT_METHOD(lldb::SBValue, SBValue, Clone, (const char *), + new_name); ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -1442,7 +1448,7 @@ } lldb::SBDeclaration SBValue::GetDeclaration() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBDeclaration, SBValue, GetDeclaration); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBDeclaration, SBValue, GetDeclaration); ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -1457,9 +1463,9 @@ 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_METHOD(lldb::SBWatchpoint, SBValue, Watch, + (bool, bool, bool, lldb::SBError &), resolve_location, + read, write, error); SBWatchpoint sb_watchpoint; @@ -1522,8 +1528,8 @@ // 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_METHOD(lldb::SBWatchpoint, SBValue, Watch, (bool, bool, bool), + resolve_location, read, write); SBError error; return Watch(resolve_location, read, write, error); @@ -1531,9 +1537,9 @@ 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_METHOD(lldb::SBWatchpoint, SBValue, WatchPointee, + (bool, bool, bool, lldb::SBError &), resolve_location, + read, write, error); SBWatchpoint sb_watchpoint; if (IsInScope() && GetType().IsPointerType()) @@ -1542,7 +1548,7 @@ } lldb::SBValue SBValue::Persist() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, Persist); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBValue, SBValue, Persist); ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); Index: lldb/source/API/SBValueList.cpp =================================================================== --- lldb/source/API/SBValueList.cpp +++ 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 @@ -67,10 +67,10 @@ std::vector m_values; }; -SBValueList::SBValueList() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBValueList); } +SBValueList::SBValueList() { LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBValueList); } SBValueList::SBValueList(const SBValueList &rhs) { - LLDB_RECORD_CONSTRUCTOR(SBValueList, (const lldb::SBValueList &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBValueList, (const lldb::SBValueList &), rhs); if (rhs.IsValid()) m_opaque_up = std::make_unique(*rhs); @@ -84,24 +84,24 @@ SBValueList::~SBValueList() = default; bool SBValueList::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBValueList, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBValueList, IsValid); return this->operator bool(); } SBValueList::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBValueList, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBValueList, operator bool); return (m_opaque_up != nullptr); } void SBValueList::Clear() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBValueList, Clear); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBValueList, Clear); m_opaque_up.reset(); } const SBValueList &SBValueList::operator=(const SBValueList &rhs) { - LLDB_RECORD_METHOD(const lldb::SBValueList &, - SBValueList, operator=,(const lldb::SBValueList &), rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBValueList &, SBValueList, operator=, + (const lldb::SBValueList &), rhs); if (this != &rhs) { if (rhs.IsValid()) @@ -123,8 +123,8 @@ 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_METHOD(void, SBValueList, Append, (const lldb::SBValue &), + val_obj); CreateIfNeeded(); m_opaque_up->Append(val_obj); @@ -138,8 +138,8 @@ } void SBValueList::Append(const lldb::SBValueList &value_list) { - LLDB_RECORD_METHOD(void, SBValueList, Append, (const lldb::SBValueList &), - value_list); + LLDB_INSTRUMENT_METHOD(void, SBValueList, Append, (const lldb::SBValueList &), + value_list); if (value_list.IsValid()) { CreateIfNeeded(); @@ -148,9 +148,8 @@ } SBValue SBValueList::GetValueAtIndex(uint32_t idx) const { - LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValueList, GetValueAtIndex, - (uint32_t), idx); - + LLDB_INSTRUMENT_METHOD_CONST(lldb::SBValue, SBValueList, GetValueAtIndex, + (uint32_t), idx); SBValue sb_value; if (m_opaque_up) @@ -160,7 +159,7 @@ } uint32_t SBValueList::GetSize() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBValueList, GetSize); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(uint32_t, SBValueList, GetSize); uint32_t size = 0; if (m_opaque_up) @@ -175,8 +174,8 @@ } SBValue SBValueList::FindValueObjectByUID(lldb::user_id_t uid) { - LLDB_RECORD_METHOD(lldb::SBValue, SBValueList, FindValueObjectByUID, - (lldb::user_id_t), uid); + LLDB_INSTRUMENT_METHOD(lldb::SBValue, SBValueList, FindValueObjectByUID, + (lldb::user_id_t), uid); SBValue sb_value; if (m_opaque_up) @@ -185,8 +184,8 @@ } SBValue SBValueList::GetFirstValueByName(const char *name) const { - LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValueList, GetFirstValueByName, - (const char *), name); + LLDB_INSTRUMENT_METHOD_CONST(lldb::SBValue, SBValueList, GetFirstValueByName, + (const char *), name); SBValue sb_value; if (m_opaque_up) Index: lldb/source/API/SBVariablesOptions.cpp =================================================================== --- lldb/source/API/SBVariablesOptions.cpp +++ 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,20 @@ SBVariablesOptions::SBVariablesOptions() : m_opaque_up(new VariablesOptionsImpl()) { - LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBVariablesOptions); + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBVariablesOptions); } SBVariablesOptions::SBVariablesOptions(const SBVariablesOptions &options) : m_opaque_up(new VariablesOptionsImpl(options.ref())) { - LLDB_RECORD_CONSTRUCTOR(SBVariablesOptions, - (const lldb::SBVariablesOptions &), options); + LLDB_INSTRUMENT_CONSTRUCTOR(SBVariablesOptions, + (const lldb::SBVariablesOptions &), options); } SBVariablesOptions &SBVariablesOptions:: operator=(const SBVariablesOptions &options) { - LLDB_RECORD_METHOD( - lldb::SBVariablesOptions &, - SBVariablesOptions, operator=,(const lldb::SBVariablesOptions &), - options); + LLDB_INSTRUMENT_METHOD(lldb::SBVariablesOptions &, + SBVariablesOptions, operator=, + (const lldb::SBVariablesOptions &), options); m_opaque_up = std::make_unique(options.ref()); return *this; @@ -103,109 +102,113 @@ SBVariablesOptions::~SBVariablesOptions() = default; bool SBVariablesOptions::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, IsValid); return this->operator bool(); } SBVariablesOptions::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, operator bool); return m_opaque_up != nullptr; } bool SBVariablesOptions::GetIncludeArguments() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, - GetIncludeArguments); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, + GetIncludeArguments); return m_opaque_up->GetIncludeArguments(); } void SBVariablesOptions::SetIncludeArguments(bool arguments) { - LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeArguments, (bool), - arguments); + LLDB_INSTRUMENT_METHOD(void, SBVariablesOptions, SetIncludeArguments, (bool), + arguments); m_opaque_up->SetIncludeArguments(arguments); } bool SBVariablesOptions::GetIncludeRecognizedArguments( const lldb::SBTarget &target) const { - LLDB_RECORD_METHOD_CONST(bool, SBVariablesOptions, - GetIncludeRecognizedArguments, - (const lldb::SBTarget &), target); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBVariablesOptions, + GetIncludeRecognizedArguments, + (const lldb::SBTarget &), target); return m_opaque_up->GetIncludeRecognizedArguments(target.GetSP()); } void SBVariablesOptions::SetIncludeRecognizedArguments(bool arguments) { - LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeRecognizedArguments, - (bool), arguments); + LLDB_INSTRUMENT_METHOD(void, SBVariablesOptions, + SetIncludeRecognizedArguments, (bool), arguments); m_opaque_up->SetIncludeRecognizedArguments(arguments); } bool SBVariablesOptions::GetIncludeLocals() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, GetIncludeLocals); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, + GetIncludeLocals); return m_opaque_up->GetIncludeLocals(); } void SBVariablesOptions::SetIncludeLocals(bool locals) { - LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeLocals, (bool), - locals); + LLDB_INSTRUMENT_METHOD(void, SBVariablesOptions, SetIncludeLocals, (bool), + locals); m_opaque_up->SetIncludeLocals(locals); } bool SBVariablesOptions::GetIncludeStatics() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, GetIncludeStatics); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, + GetIncludeStatics); return m_opaque_up->GetIncludeStatics(); } void SBVariablesOptions::SetIncludeStatics(bool statics) { - LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeStatics, (bool), - statics); + LLDB_INSTRUMENT_METHOD(void, SBVariablesOptions, SetIncludeStatics, (bool), + statics); m_opaque_up->SetIncludeStatics(statics); } bool SBVariablesOptions::GetInScopeOnly() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, GetInScopeOnly); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, + GetInScopeOnly); return m_opaque_up->GetInScopeOnly(); } void SBVariablesOptions::SetInScopeOnly(bool in_scope_only) { - LLDB_RECORD_METHOD(void, SBVariablesOptions, SetInScopeOnly, (bool), - in_scope_only); + LLDB_INSTRUMENT_METHOD(void, SBVariablesOptions, SetInScopeOnly, (bool), + in_scope_only); m_opaque_up->SetInScopeOnly(in_scope_only); } bool SBVariablesOptions::GetIncludeRuntimeSupportValues() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, - GetIncludeRuntimeSupportValues); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, + GetIncludeRuntimeSupportValues); return m_opaque_up->GetIncludeRuntimeSupportValues(); } void SBVariablesOptions::SetIncludeRuntimeSupportValues( bool runtime_support_values) { - LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeRuntimeSupportValues, - (bool), runtime_support_values); + LLDB_INSTRUMENT_METHOD(void, SBVariablesOptions, + SetIncludeRuntimeSupportValues, (bool), + runtime_support_values); m_opaque_up->SetIncludeRuntimeSupportValues(runtime_support_values); } lldb::DynamicValueType SBVariablesOptions::GetUseDynamic() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::DynamicValueType, SBVariablesOptions, - GetUseDynamic); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::DynamicValueType, + SBVariablesOptions, GetUseDynamic); return m_opaque_up->GetUseDynamic(); } void SBVariablesOptions::SetUseDynamic(lldb::DynamicValueType dynamic) { - LLDB_RECORD_METHOD(void, SBVariablesOptions, SetUseDynamic, - (lldb::DynamicValueType), dynamic); + LLDB_INSTRUMENT_METHOD(void, SBVariablesOptions, SetUseDynamic, + (lldb::DynamicValueType), dynamic); m_opaque_up->SetUseDynamic(dynamic); } Index: lldb/source/API/SBWatchpoint.cpp =================================================================== --- lldb/source/API/SBWatchpoint.cpp +++ 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,24 @@ using namespace lldb; using namespace lldb_private; -SBWatchpoint::SBWatchpoint() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBWatchpoint); } +SBWatchpoint::SBWatchpoint() { + LLDB_INSTRUMENT_CONSTRUCTOR_NO_ARGS(SBWatchpoint); +} SBWatchpoint::SBWatchpoint(const lldb::WatchpointSP &wp_sp) : m_opaque_wp(wp_sp) { - LLDB_RECORD_CONSTRUCTOR(SBWatchpoint, (const lldb::WatchpointSP &), wp_sp); + LLDB_INSTRUMENT_CONSTRUCTOR(SBWatchpoint, (const lldb::WatchpointSP &), + wp_sp); } SBWatchpoint::SBWatchpoint(const SBWatchpoint &rhs) : m_opaque_wp(rhs.m_opaque_wp) { - LLDB_RECORD_CONSTRUCTOR(SBWatchpoint, (const lldb::SBWatchpoint &), rhs); + LLDB_INSTRUMENT_CONSTRUCTOR(SBWatchpoint, (const lldb::SBWatchpoint &), rhs); } const SBWatchpoint &SBWatchpoint::operator=(const SBWatchpoint &rhs) { - LLDB_RECORD_METHOD(const lldb::SBWatchpoint &, - SBWatchpoint, operator=,(const lldb::SBWatchpoint &), rhs); + LLDB_INSTRUMENT_METHOD(const lldb::SBWatchpoint &, SBWatchpoint, operator=, + (const lldb::SBWatchpoint &), rhs); m_opaque_wp = rhs.m_opaque_wp; return *this; @@ -49,8 +52,7 @@ SBWatchpoint::~SBWatchpoint() = default; watch_id_t SBWatchpoint::GetID() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::watch_id_t, SBWatchpoint, GetID); - + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::watch_id_t, SBWatchpoint, GetID); watch_id_t watch_id = LLDB_INVALID_WATCH_ID; lldb::WatchpointSP watchpoint_sp(GetSP()); @@ -61,31 +63,31 @@ } bool SBWatchpoint::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBWatchpoint, IsValid); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBWatchpoint, IsValid); return this->operator bool(); } SBWatchpoint::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBWatchpoint, operator bool); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(bool, SBWatchpoint, operator bool); return bool(m_opaque_wp.lock()); } bool SBWatchpoint::operator==(const SBWatchpoint &rhs) const { - LLDB_RECORD_METHOD_CONST( - bool, SBWatchpoint, operator==,(const SBWatchpoint &), rhs); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBWatchpoint, operator==, + (const SBWatchpoint &), rhs); return GetSP() == rhs.GetSP(); } bool SBWatchpoint::operator!=(const SBWatchpoint &rhs) const { - LLDB_RECORD_METHOD_CONST( - bool, SBWatchpoint, operator!=,(const SBWatchpoint &), rhs); + LLDB_INSTRUMENT_METHOD_CONST(bool, SBWatchpoint, operator!=, + (const SBWatchpoint &), rhs); return !(*this == rhs); } SBError SBWatchpoint::GetError() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBWatchpoint, GetError); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::SBError, SBWatchpoint, GetError); SBError sb_error; lldb::WatchpointSP watchpoint_sp(GetSP()); @@ -96,7 +98,7 @@ } int32_t SBWatchpoint::GetHardwareIndex() { - LLDB_RECORD_METHOD_NO_ARGS(int32_t, SBWatchpoint, GetHardwareIndex); + LLDB_INSTRUMENT_METHOD_NO_ARGS(int32_t, SBWatchpoint, GetHardwareIndex); int32_t hw_index = -1; @@ -111,7 +113,7 @@ } addr_t SBWatchpoint::GetWatchAddress() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBWatchpoint, GetWatchAddress); + LLDB_INSTRUMENT_METHOD_NO_ARGS(lldb::addr_t, SBWatchpoint, GetWatchAddress); addr_t ret_addr = LLDB_INVALID_ADDRESS; @@ -126,7 +128,7 @@ } size_t SBWatchpoint::GetWatchSize() { - LLDB_RECORD_METHOD_NO_ARGS(size_t, SBWatchpoint, GetWatchSize); + LLDB_INSTRUMENT_METHOD_NO_ARGS(size_t, SBWatchpoint, GetWatchSize); size_t watch_size = 0; @@ -141,7 +143,7 @@ } void SBWatchpoint::SetEnabled(bool enabled) { - LLDB_RECORD_METHOD(void, SBWatchpoint, SetEnabled, (bool), enabled); + LLDB_INSTRUMENT_METHOD(void, SBWatchpoint, SetEnabled, (bool), enabled); lldb::WatchpointSP watchpoint_sp(GetSP()); if (watchpoint_sp) { @@ -161,7 +163,7 @@ } bool SBWatchpoint::IsEnabled() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBWatchpoint, IsEnabled); + LLDB_INSTRUMENT_METHOD_NO_ARGS(bool, SBWatchpoint, IsEnabled); lldb::WatchpointSP watchpoint_sp(GetSP()); if (watchpoint_sp) { @@ -173,7 +175,7 @@ } uint32_t SBWatchpoint::GetHitCount() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBWatchpoint, GetHitCount); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBWatchpoint, GetHitCount); uint32_t count = 0; lldb::WatchpointSP watchpoint_sp(GetSP()); @@ -187,7 +189,7 @@ } uint32_t SBWatchpoint::GetIgnoreCount() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBWatchpoint, GetIgnoreCount); + LLDB_INSTRUMENT_METHOD_NO_ARGS(uint32_t, SBWatchpoint, GetIgnoreCount); lldb::WatchpointSP watchpoint_sp(GetSP()); if (watchpoint_sp) { @@ -199,7 +201,7 @@ } void SBWatchpoint::SetIgnoreCount(uint32_t n) { - LLDB_RECORD_METHOD(void, SBWatchpoint, SetIgnoreCount, (uint32_t), n); + LLDB_INSTRUMENT_METHOD(void, SBWatchpoint, SetIgnoreCount, (uint32_t), n); lldb::WatchpointSP watchpoint_sp(GetSP()); if (watchpoint_sp) { @@ -210,7 +212,7 @@ } const char *SBWatchpoint::GetCondition() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBWatchpoint, GetCondition); + LLDB_INSTRUMENT_METHOD_NO_ARGS(const char *, SBWatchpoint, GetCondition); lldb::WatchpointSP watchpoint_sp(GetSP()); if (watchpoint_sp) { @@ -222,8 +224,8 @@ } void SBWatchpoint::SetCondition(const char *condition) { - LLDB_RECORD_METHOD(void, SBWatchpoint, SetCondition, (const char *), - condition); + LLDB_INSTRUMENT_METHOD(void, SBWatchpoint, SetCondition, (const char *), + condition); lldb::WatchpointSP watchpoint_sp(GetSP()); if (watchpoint_sp) { @@ -235,9 +237,9 @@ bool SBWatchpoint::GetDescription(SBStream &description, DescriptionLevel level) { - LLDB_RECORD_METHOD(bool, SBWatchpoint, GetDescription, - (lldb::SBStream &, lldb::DescriptionLevel), description, - level); + LLDB_INSTRUMENT_METHOD(bool, SBWatchpoint, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel), + description, level); Stream &strm = description.ref(); @@ -254,27 +256,27 @@ } void SBWatchpoint::Clear() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBWatchpoint, Clear); + LLDB_INSTRUMENT_METHOD_NO_ARGS(void, SBWatchpoint, Clear); m_opaque_wp.reset(); } lldb::WatchpointSP SBWatchpoint::GetSP() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::WatchpointSP, SBWatchpoint, GetSP); + LLDB_INSTRUMENT_METHOD_CONST_NO_ARGS(lldb::WatchpointSP, SBWatchpoint, GetSP); return m_opaque_wp.lock(); } void SBWatchpoint::SetSP(const lldb::WatchpointSP &sp) { - LLDB_RECORD_METHOD(void, SBWatchpoint, SetSP, (const lldb::WatchpointSP &), - sp); + LLDB_INSTRUMENT_METHOD(void, SBWatchpoint, SetSP, + (const lldb::WatchpointSP &), sp); m_opaque_wp = sp; } bool SBWatchpoint::EventIsWatchpointEvent(const lldb::SBEvent &event) { - LLDB_RECORD_STATIC_METHOD(bool, SBWatchpoint, EventIsWatchpointEvent, - (const lldb::SBEvent &), event); + LLDB_INSTRUMENT_STATIC_METHOD(bool, SBWatchpoint, EventIsWatchpointEvent, + (const lldb::SBEvent &), event); return Watchpoint::WatchpointEventData::GetEventDataFromEvent(event.get()) != nullptr; @@ -282,9 +284,9 @@ WatchpointEventType SBWatchpoint::GetWatchpointEventTypeFromEvent(const SBEvent &event) { - LLDB_RECORD_STATIC_METHOD(lldb::WatchpointEventType, SBWatchpoint, - GetWatchpointEventTypeFromEvent, - (const lldb::SBEvent &), event); + LLDB_INSTRUMENT_STATIC_METHOD(lldb::WatchpointEventType, SBWatchpoint, + GetWatchpointEventTypeFromEvent, + (const lldb::SBEvent &), event); if (event.IsValid()) return Watchpoint::WatchpointEventData::GetWatchpointEventTypeFromEvent( @@ -293,9 +295,9 @@ } SBWatchpoint SBWatchpoint::GetWatchpointFromEvent(const lldb::SBEvent &event) { - LLDB_RECORD_STATIC_METHOD(lldb::SBWatchpoint, SBWatchpoint, - GetWatchpointFromEvent, (const lldb::SBEvent &), - event); + LLDB_INSTRUMENT_STATIC_METHOD(lldb::SBWatchpoint, SBWatchpoint, + GetWatchpointFromEvent, (const lldb::SBEvent &), + event); SBWatchpoint sb_watchpoint; if (event.IsValid()) Index: lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp =================================================================== --- lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp +++ 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" Index: lldb/source/Utility/CMakeLists.txt =================================================================== --- lldb/source/Utility/CMakeLists.txt +++ lldb/source/Utility/CMakeLists.txt @@ -49,7 +49,7 @@ RegisterValue.cpp RegularExpression.cpp Reproducer.cpp - ReproducerInstrumentation.cpp + Instrumentation.cpp ReproducerProvider.cpp Scalar.cpp SelectHelper.cpp Index: lldb/source/Utility/Instrumentation.cpp =================================================================== --- lldb/source/Utility/Instrumentation.cpp +++ lldb/source/Utility/Instrumentation.cpp @@ -1,46 +1,43 @@ -//===-- 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 #include #include #include using namespace lldb_private; -using namespace lldb_private::repro; // Whether we're currently across the API boundary. static thread_local bool g_global_boundary = false; -Recorder::Recorder() { +Instrumenter::Instrumenter() { 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; }