Cold-Air-Networks/mirror-llvm-project
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 7

[lldb] Decouple instrumentation from the reproducers

Browse source 
Remove the last remaining references to the reproducers from the
instrumentation. This patch renames the relevant files and macros.

Differential revision: https://reviews.llvm.org/D117712
This commit is contained in:
Jonas Devlieghere 2022-01-19 11:38:26 -08:00
parent f811cb82a6
commit 1755f5b1d7
74 changed files with 2230 additions and 3674 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

103
lldb/include/lldb/Utility/Instrumentation.h Normal file
View file

@ -0,0 +1,103 @@
//===-- Instrumentation.h ---------------------------------------*- C++ -*-===//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef LLDB_UTILITY_INSTRUMENTATION_H
#define LLDB_UTILITY_INSTRUMENTATION_H
#include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/Log.h"
#include "lldb/Utility/Logging.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/ErrorHandling.h"
#include <map>
#include <thread>
#include <type_traits>
namespace lldb_private {
namespace instrumentation {
template <typename T,
typename std::enable_if<std::is_fundamental<T>::value, int>::type = 0>
inline void stringify_append(llvm::raw_string_ostream &ss, const T &t) {
ss << t;
}
template <typename T, typename std::enable_if<!std::is_fundamental<T>::value,
int>::type = 0>
inline void stringify_append(llvm::raw_string_ostream &ss, const T &t) {
ss << &t;
}
template <typename T>
inline void stringify_append(llvm::raw_string_ostream &ss, T *t) {
ss << reinterpret_cast<void *>(t);
}
template <typename T>
inline void stringify_append(llvm::raw_string_ostream &ss, const T *t) {
ss << reinterpret_cast<const void *>(t);
}
template <>
inline void stringify_append<char>(llvm::raw_string_ostream &ss,
const char *t) {
ss << '\"' << t << '\"';
}
template <>
inline void stringify_append<std::nullptr_t>(llvm::raw_string_ostream &ss,
const std::nullptr_t &t) {
ss << "\"nullptr\"";
}
template <typename Head>
inline void stringify_helper(llvm::raw_string_ostream &ss, const Head &head) {
stringify_append(ss, head);
}
template <typename Head, typename... Tail>
inline void stringify_helper(llvm::raw_string_ostream &ss, const Head &head,
const Tail &...tail) {
stringify_append(ss, head);
ss << ", ";
stringify_helper(ss, tail...);
}
template <typename... Ts> inline std::string stringify_args(const Ts &...ts) {
std::string buffer;
llvm::raw_string_ostream ss(buffer);
stringify_helper(ss, ts...);
return ss.str();
}
/// RAII object for instrumenting LLDB API functions.
class Instrumenter {
public:
Instrumenter(llvm::StringRef pretty_func, std::string &&pretty_args = {});
~Instrumenter();
private:
void UpdateBoundary();
/// Whether this function call was the one crossing the API boundary.
bool m_local_boundary = false;
};
} // namespace instrumentation
} // namespace lldb_private
#define LLDB_INSTRUMENT() \
lldb_private::instrumentation::Instrumenter _instr(LLVM_PRETTY_FUNCTION);
#define LLDB_INSTRUMENT_VA(...) \
lldb_private::instrumentation::Instrumenter _instr( \
LLVM_PRETTY_FUNCTION, \
lldb_private::instrumentation::stringify_args(__VA_ARGS__));
#endif // LLDB_UTILITY_INSTRUMENTATION_H

151
lldb/include/lldb/Utility/ReproducerInstrumentation.h
View file

@ -1,151 +0,0 @@
//===-- ReproducerInstrumentation.h -----------------------------*- C++ -*-===//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef LLDB_UTILITY_REPRODUCERINSTRUMENTATION_H
#define LLDB_UTILITY_REPRODUCERINSTRUMENTATION_H
#include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/Log.h"
#include "lldb/Utility/Logging.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/ErrorHandling.h"
#include <map>
#include <thread>
#include <type_traits>
template <typename T,
typename std::enable_if<std::is_fundamental<T>::value, int>::type = 0>
inline void stringify_append(llvm::raw_string_ostream &ss, const T &t) {
ss << t;
}
template <typename T, typename std::enable_if<!std::is_fundamental<T>::value,
int>::type = 0>
inline void stringify_append(llvm::raw_string_ostream &ss, const T &t) {
ss << &t;
}
template <typename T>
inline void stringify_append(llvm::raw_string_ostream &ss, T *t) {
ss << reinterpret_cast<void *>(t);
}
template <typename T>
inline void stringify_append(llvm::raw_string_ostream &ss, const T *t) {
ss << reinterpret_cast<const void *>(t);
}
template <>
inline void stringify_append<char>(llvm::raw_string_ostream &ss,
const char *t) {
ss << '\"' << t << '\"';
}
template <>
inline void stringify_append<std::nullptr_t>(llvm::raw_string_ostream &ss,
const std::nullptr_t &t) {
ss << "\"nullptr\"";
}
template <typename Head>
inline void stringify_helper(llvm::raw_string_ostream &ss, const Head &head) {
stringify_append(ss, head);
}
template <typename Head, typename... Tail>
inline void stringify_helper(llvm::raw_string_ostream &ss, const Head &head,
const Tail &... tail) {
stringify_append(ss, head);
ss << ", ";
stringify_helper(ss, tail...);
}
template <typename... Ts> inline std::string stringify_args(const Ts &... ts) {
std::string buffer;
llvm::raw_string_ostream ss(buffer);
stringify_helper(ss, ts...);
return ss.str();
}
#define LLDB_CONSTRUCT_(T, Class, ...) \
lldb_private::repro::Recorder _recorder(LLVM_PRETTY_FUNCTION);
#define LLDB_RECORD_CONSTRUCTOR(Class, Signature, ...) \
LLDB_CONSTRUCT_(Class Signature, this, __VA_ARGS__)
#define LLDB_RECORD_CONSTRUCTOR_NO_ARGS(Class) \
LLDB_CONSTRUCT_(Class(), this, lldb_private::repro::EmptyArg())
#define LLDB_RECORD_(T1, T2, ...) \
lldb_private::repro::Recorder _recorder(LLVM_PRETTY_FUNCTION, \
stringify_args(__VA_ARGS__));
#define LLDB_RECORD_METHOD(Result, Class, Method, Signature, ...) \
LLDB_RECORD_(Result(Class::*) Signature, (&Class::Method), this, __VA_ARGS__)
#define LLDB_RECORD_METHOD_CONST(Result, Class, Method, Signature, ...) \
LLDB_RECORD_(Result(Class::*) Signature const, (&Class::Method), this, \
__VA_ARGS__)
#define LLDB_RECORD_METHOD_NO_ARGS(Result, Class, Method) \
LLDB_RECORD_(Result (Class::*)(), (&Class::Method), this)
#define LLDB_RECORD_METHOD_CONST_NO_ARGS(Result, Class, Method) \
LLDB_RECORD_(Result (Class::*)() const, (&Class::Method), this)
#define LLDB_RECORD_STATIC_METHOD(Result, Class, Method, Signature, ...) \
LLDB_RECORD_(Result(*) Signature, (&Class::Method), __VA_ARGS__)
#define LLDB_RECORD_STATIC_METHOD_NO_ARGS(Result, Class, Method) \
LLDB_RECORD_(Result (*)(), (&Class::Method), lldb_private::repro::EmptyArg())
/// The LLDB_RECORD_DUMMY macro is special because it doesn't actually record
/// anything. It's used to track API boundaries when we cannot record for
/// technical reasons.
#define LLDB_RECORD_DUMMY(Result, Class, Method, Signature, ...) \
lldb_private::repro::Recorder _recorder;
#define LLDB_RECORD_DUMMY_NO_ARGS(Result, Class, Method) \
lldb_private::repro::Recorder _recorder;
namespace lldb_private {
namespace repro {
struct EmptyArg {};
/// RAII object that records function invocations and their return value.
///
/// API calls are only captured when the API boundary is crossed. Once we're in
/// the API layer, and another API function is called, it doesn't need to be
/// recorded.
///
/// When a call is recored, its result is always recorded as well, even if the
/// function returns a void. For functions that return by value, RecordResult
/// should be used. Otherwise a sentinel value (0) will be serialized.
///
/// Because of the functional overlap between logging and recording API calls,
/// this class is also used for logging.
class Recorder {
public:
Recorder();
Recorder(llvm::StringRef pretty_func, std::string &&pretty_args = {});
~Recorder();
private:
void UpdateBoundary();
/// Whether this function call was the one crossing the API boundary.
bool m_local_boundary = false;
};
} // namespace repro
} // namespace lldb_private
#endif // LLDB_UTILITY_REPRODUCERINSTRUMENTATION_H

59
lldb/source/API/SBAddress.cpp
View file

@ -7,7 +7,6 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBAddress.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/API/SBProcess.h"
#include "lldb/API/SBSection.h"
@ -16,35 +15,34 @@
#include "lldb/Core/Module.h"
#include "lldb/Symbol/LineEntry.h"
#include "lldb/Target/Target.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb;
using namespace lldb_private;
SBAddress::SBAddress() : m_opaque_up(new Address()) {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBAddress);
LLDB_INSTRUMENT_VA(this);
}
SBAddress::SBAddress(const Address &address)
: m_opaque_up(std::make_unique<Address>(address)) {}
SBAddress::SBAddress(const SBAddress &rhs) : m_opaque_up(new Address()) {
LLDB_RECORD_CONSTRUCTOR(SBAddress, (const lldb::SBAddress &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_up = clone(rhs.m_opaque_up);
}
SBAddress::SBAddress(lldb::SBSection section, lldb::addr_t offset)
: m_opaque_up(new Address(section.GetSP(), offset)) {
LLDB_RECORD_CONSTRUCTOR(SBAddress, (lldb::SBSection, lldb::addr_t), section,
offset);
LLDB_INSTRUMENT_VA(this, section, offset);
}
// Create an address by resolving a load address using the supplied target
SBAddress::SBAddress(lldb::addr_t load_addr, lldb::SBTarget &target)
: m_opaque_up(new Address()) {
LLDB_RECORD_CONSTRUCTOR(SBAddress, (lldb::addr_t, lldb::SBTarget &),
load_addr, target);
LLDB_INSTRUMENT_VA(this, load_addr, target);
SetLoadAddress(load_addr, target);
}
@ -52,8 +50,7 @@ SBAddress::SBAddress(lldb::addr_t load_addr, lldb::SBTarget &target)
SBAddress::~SBAddress() = default;
const SBAddress &SBAddress::operator=(const SBAddress &rhs) {
LLDB_RECORD_METHOD(const lldb::SBAddress &,
SBAddress, operator=,(const lldb::SBAddress &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
@ -67,31 +64,29 @@ bool lldb::operator==(const SBAddress &lhs, const SBAddress &rhs) {
}
bool SBAddress::operator!=(const SBAddress &rhs) const {
LLDB_RECORD_METHOD_CONST(bool, SBAddress, operator!=,(const SBAddress &),
&rhs);
LLDB_INSTRUMENT_VA(this, rhs);
return !(*this == rhs);
}
bool SBAddress::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBAddress, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBAddress::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBAddress, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up != nullptr && m_opaque_up->IsValid();
}
void SBAddress::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBAddress, Clear);
LLDB_INSTRUMENT_VA(this);
m_opaque_up = std::make_unique<Address>();
}
void SBAddress::SetAddress(lldb::SBSection section, lldb::addr_t offset) {
LLDB_RECORD_METHOD(void, SBAddress, SetAddress,
(lldb::SBSection, lldb::addr_t), section, offset);
LLDB_INSTRUMENT_VA(this, section, offset);
Address &addr = ref();
addr.SetSection(section.GetSP());
@ -101,7 +96,7 @@ void SBAddress::SetAddress(lldb::SBSection section, lldb::addr_t offset) {
void SBAddress::SetAddress(const Address &address) { ref() = address; }
lldb::addr_t SBAddress::GetFileAddress() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBAddress, GetFileAddress);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_up->IsValid())
return m_opaque_up->GetFileAddress();
@ -110,8 +105,7 @@ lldb::addr_t SBAddress::GetFileAddress() const {
}
lldb::addr_t SBAddress::GetLoadAddress(const SBTarget &target) const {
LLDB_RECORD_METHOD_CONST(lldb::addr_t, SBAddress, GetLoadAddress,
(const lldb::SBTarget &), target);
LLDB_INSTRUMENT_VA(this, target);
lldb::addr_t addr = LLDB_INVALID_ADDRESS;
TargetSP target_sp(target.GetSP());
@ -126,8 +120,7 @@ lldb::addr_t SBAddress::GetLoadAddress(const SBTarget &target) const {
}
void SBAddress::SetLoadAddress(lldb::addr_t load_addr, lldb::SBTarget &target) {
LLDB_RECORD_METHOD(void, SBAddress, SetLoadAddress,
(lldb::addr_t, lldb::SBTarget &), load_addr, target);
LLDB_INSTRUMENT_VA(this, load_addr, target);
// Create the address object if we don't already have one
ref();
@ -144,7 +137,7 @@ void SBAddress::SetLoadAddress(lldb::addr_t load_addr, lldb::SBTarget &target) {
}
bool SBAddress::OffsetAddress(addr_t offset) {
LLDB_RECORD_METHOD(bool, SBAddress, OffsetAddress, (lldb::addr_t), offset);
LLDB_INSTRUMENT_VA(this, offset);
if (m_opaque_up->IsValid()) {
addr_t addr_offset = m_opaque_up->GetOffset();
@ -157,7 +150,7 @@ bool SBAddress::OffsetAddress(addr_t offset) {
}
lldb::SBSection SBAddress::GetSection() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSection, SBAddress, GetSection);
LLDB_INSTRUMENT_VA(this);
lldb::SBSection sb_section;
if (m_opaque_up->IsValid())
@ -166,7 +159,7 @@ lldb::SBSection SBAddress::GetSection() {
}
lldb::addr_t SBAddress::GetOffset() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBAddress, GetOffset);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_up->IsValid())
return m_opaque_up->GetOffset();
@ -193,8 +186,7 @@ const Address &SBAddress::ref() const {
Address *SBAddress::get() { return m_opaque_up.get(); }
bool SBAddress::GetDescription(SBStream &description) {
LLDB_RECORD_METHOD(bool, SBAddress, GetDescription, (lldb::SBStream &),
description);
LLDB_INSTRUMENT_VA(this, description);
// Call "ref()" on the stream to make sure it creates a backing stream in
// case there isn't one already...
@ -209,7 +201,7 @@ bool SBAddress::GetDescription(SBStream &description) {
}
SBModule SBAddress::GetModule() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBModule, SBAddress, GetModule);
LLDB_INSTRUMENT_VA(this);
SBModule sb_module;
if (m_opaque_up->IsValid())
@ -218,8 +210,7 @@ SBModule SBAddress::GetModule() {
}
SBSymbolContext SBAddress::GetSymbolContext(uint32_t resolve_scope) {
LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBAddress, GetSymbolContext,
(uint32_t), resolve_scope);
LLDB_INSTRUMENT_VA(this, resolve_scope);
SBSymbolContext sb_sc;
SymbolContextItem scope = static_cast<SymbolContextItem>(resolve_scope);
@ -229,7 +220,7 @@ SBSymbolContext SBAddress::GetSymbolContext(uint32_t resolve_scope) {
}
SBCompileUnit SBAddress::GetCompileUnit() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCompileUnit, SBAddress, GetCompileUnit);
LLDB_INSTRUMENT_VA(this);
SBCompileUnit sb_comp_unit;
if (m_opaque_up->IsValid())
@ -238,7 +229,7 @@ SBCompileUnit SBAddress::GetCompileUnit() {
}
SBFunction SBAddress::GetFunction() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFunction, SBAddress, GetFunction);
LLDB_INSTRUMENT_VA(this);
SBFunction sb_function;
if (m_opaque_up->IsValid())
@ -247,7 +238,7 @@ SBFunction SBAddress::GetFunction() {
}
SBBlock SBAddress::GetBlock() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBAddress, GetBlock);
LLDB_INSTRUMENT_VA(this);
SBBlock sb_block;
if (m_opaque_up->IsValid())
@ -256,7 +247,7 @@ SBBlock SBAddress::GetBlock() {
}
SBSymbol SBAddress::GetSymbol() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSymbol, SBAddress, GetSymbol);
LLDB_INSTRUMENT_VA(this);
SBSymbol sb_symbol;
if (m_opaque_up->IsValid())
@ -265,7 +256,7 @@ SBSymbol SBAddress::GetSymbol() {
}
SBLineEntry SBAddress::GetLineEntry() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBLineEntry, SBAddress, GetLineEntry);
LLDB_INSTRUMENT_VA(this);
SBLineEntry sb_line_entry;
if (m_opaque_up->IsValid()) {

81
lldb/source/API/SBAttachInfo.cpp
View file

@ -7,29 +7,29 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBAttachInfo.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/API/SBFileSpec.h"
#include "lldb/API/SBListener.h"
#include "lldb/Target/Process.h"
#include "lldb/Utility/Instrumentation.h"
using namespace lldb;
using namespace lldb_private;
SBAttachInfo::SBAttachInfo() : m_opaque_sp(new ProcessAttachInfo()) {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBAttachInfo);
LLDB_INSTRUMENT_VA(this);
}
SBAttachInfo::SBAttachInfo(lldb::pid_t pid)
: m_opaque_sp(new ProcessAttachInfo()) {
LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (lldb::pid_t), pid);
LLDB_INSTRUMENT_VA(this, pid);
m_opaque_sp->SetProcessID(pid);
}
SBAttachInfo::SBAttachInfo(const char *path, bool wait_for)
: m_opaque_sp(new ProcessAttachInfo()) {
LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (const char *, bool), path, wait_for);
LLDB_INSTRUMENT_VA(this, path, wait_for);
if (path && path[0])
m_opaque_sp->GetExecutableFile().SetFile(path, FileSpec::Style::native);
@ -38,8 +38,7 @@ SBAttachInfo::SBAttachInfo(const char *path, bool wait_for)
SBAttachInfo::SBAttachInfo(const char *path, bool wait_for, bool async)
: m_opaque_sp(new ProcessAttachInfo()) {
LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (const char *, bool, bool), path,
wait_for, async);
LLDB_INSTRUMENT_VA(this, path, wait_for, async);
if (path && path[0])
m_opaque_sp->GetExecutableFile().SetFile(path, FileSpec::Style::native);
@ -49,7 +48,7 @@ SBAttachInfo::SBAttachInfo(const char *path, bool wait_for, bool async)
SBAttachInfo::SBAttachInfo(const SBAttachInfo &rhs)
: m_opaque_sp(new ProcessAttachInfo()) {
LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (const lldb::SBAttachInfo &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_sp = clone(rhs.m_opaque_sp);
}
@ -59,8 +58,7 @@ SBAttachInfo::~SBAttachInfo() = default;
lldb_private::ProcessAttachInfo &SBAttachInfo::ref() { return *m_opaque_sp; }
SBAttachInfo &SBAttachInfo::operator=(const SBAttachInfo &rhs) {
LLDB_RECORD_METHOD(lldb::SBAttachInfo &,
SBAttachInfo, operator=,(const lldb::SBAttachInfo &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_sp = clone(rhs.m_opaque_sp);
@ -68,44 +66,43 @@ SBAttachInfo &SBAttachInfo::operator=(const SBAttachInfo &rhs) {
}
lldb::pid_t SBAttachInfo::GetProcessID() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBAttachInfo, GetProcessID);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetProcessID();
}
void SBAttachInfo::SetProcessID(lldb::pid_t pid) {
LLDB_RECORD_METHOD(void, SBAttachInfo, SetProcessID, (lldb::pid_t), pid);
LLDB_INSTRUMENT_VA(this, pid);
m_opaque_sp->SetProcessID(pid);
}
uint32_t SBAttachInfo::GetResumeCount() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetResumeCount);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetResumeCount();
}
void SBAttachInfo::SetResumeCount(uint32_t c) {
LLDB_RECORD_METHOD(void, SBAttachInfo, SetResumeCount, (uint32_t), c);
LLDB_INSTRUMENT_VA(this, c);
m_opaque_sp->SetResumeCount(c);
}
const char *SBAttachInfo::GetProcessPluginName() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBAttachInfo, GetProcessPluginName);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetProcessPluginName();
}
void SBAttachInfo::SetProcessPluginName(const char *plugin_name) {
LLDB_RECORD_METHOD(void, SBAttachInfo, SetProcessPluginName, (const char *),
plugin_name);
LLDB_INSTRUMENT_VA(this, plugin_name);
return m_opaque_sp->SetProcessPluginName(plugin_name);
}
void SBAttachInfo::SetExecutable(const char *path) {
LLDB_RECORD_METHOD(void, SBAttachInfo, SetExecutable, (const char *), path);
LLDB_INSTRUMENT_VA(this, path);
if (path && path[0])
m_opaque_sp->GetExecutableFile().SetFile(path, FileSpec::Style::native);
@ -114,8 +111,7 @@ void SBAttachInfo::SetExecutable(const char *path) {
}
void SBAttachInfo::SetExecutable(SBFileSpec exe_file) {
LLDB_RECORD_METHOD(void, SBAttachInfo, SetExecutable, (lldb::SBFileSpec),
exe_file);
LLDB_INSTRUMENT_VA(this, exe_file);
if (exe_file.IsValid())
m_opaque_sp->GetExecutableFile() = exe_file.ref();
@ -124,137 +120,134 @@ void SBAttachInfo::SetExecutable(SBFileSpec exe_file) {
}
bool SBAttachInfo::GetWaitForLaunch() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, GetWaitForLaunch);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetWaitForLaunch();
}
void SBAttachInfo::SetWaitForLaunch(bool b) {
LLDB_RECORD_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool), b);
LLDB_INSTRUMENT_VA(this, b);
m_opaque_sp->SetWaitForLaunch(b);
}
void SBAttachInfo::SetWaitForLaunch(bool b, bool async) {
LLDB_RECORD_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool, bool), b,
async);
LLDB_INSTRUMENT_VA(this, b, async);
m_opaque_sp->SetWaitForLaunch(b);
m_opaque_sp->SetAsync(async);
}
bool SBAttachInfo::GetIgnoreExisting() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, GetIgnoreExisting);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetIgnoreExisting();
}
void SBAttachInfo::SetIgnoreExisting(bool b) {
LLDB_RECORD_METHOD(void, SBAttachInfo, SetIgnoreExisting, (bool), b);
LLDB_INSTRUMENT_VA(this, b);
m_opaque_sp->SetIgnoreExisting(b);
}
uint32_t SBAttachInfo::GetUserID() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetUserID);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetUserID();
}
uint32_t SBAttachInfo::GetGroupID() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetGroupID);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetGroupID();
}
bool SBAttachInfo::UserIDIsValid() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, UserIDIsValid);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->UserIDIsValid();
}
bool SBAttachInfo::GroupIDIsValid() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, GroupIDIsValid);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GroupIDIsValid();
}
void SBAttachInfo::SetUserID(uint32_t uid) {
LLDB_RECORD_METHOD(void, SBAttachInfo, SetUserID, (uint32_t), uid);
LLDB_INSTRUMENT_VA(this, uid);
m_opaque_sp->SetUserID(uid);
}
void SBAttachInfo::SetGroupID(uint32_t gid) {
LLDB_RECORD_METHOD(void, SBAttachInfo, SetGroupID, (uint32_t), gid);
LLDB_INSTRUMENT_VA(this, gid);
m_opaque_sp->SetGroupID(gid);
}
uint32_t SBAttachInfo::GetEffectiveUserID() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetEffectiveUserID);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetEffectiveUserID();
}
uint32_t SBAttachInfo::GetEffectiveGroupID() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetEffectiveGroupID);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetEffectiveGroupID();
}
bool SBAttachInfo::EffectiveUserIDIsValid() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, EffectiveUserIDIsValid);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->EffectiveUserIDIsValid();
}
bool SBAttachInfo::EffectiveGroupIDIsValid() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, EffectiveGroupIDIsValid);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->EffectiveGroupIDIsValid();
}
void SBAttachInfo::SetEffectiveUserID(uint32_t uid) {
LLDB_RECORD_METHOD(void, SBAttachInfo, SetEffectiveUserID, (uint32_t), uid);
LLDB_INSTRUMENT_VA(this, uid);
m_opaque_sp->SetEffectiveUserID(uid);
}
void SBAttachInfo::SetEffectiveGroupID(uint32_t gid) {
LLDB_RECORD_METHOD(void, SBAttachInfo, SetEffectiveGroupID, (uint32_t), gid);
LLDB_INSTRUMENT_VA(this, gid);
m_opaque_sp->SetEffectiveGroupID(gid);
}
lldb::pid_t SBAttachInfo::GetParentProcessID() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBAttachInfo, GetParentProcessID);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetParentProcessID();
}
void SBAttachInfo::SetParentProcessID(lldb::pid_t pid) {
LLDB_RECORD_METHOD(void, SBAttachInfo, SetParentProcessID, (lldb::pid_t),
pid);
LLDB_INSTRUMENT_VA(this, pid);
m_opaque_sp->SetParentProcessID(pid);
}
bool SBAttachInfo::ParentProcessIDIsValid() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, ParentProcessIDIsValid);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->ParentProcessIDIsValid();
}
SBListener SBAttachInfo::GetListener() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBAttachInfo, GetListener);
LLDB_INSTRUMENT_VA(this);
return SBListener(m_opaque_sp->GetListener());
}
void SBAttachInfo::SetListener(SBListener &listener) {
LLDB_RECORD_METHOD(void, SBAttachInfo, SetListener, (lldb::SBListener &),
listener);
LLDB_INSTRUMENT_VA(this, listener);
m_opaque_sp->SetListener(listener.GetSP());
}

55
lldb/source/API/SBBlock.cpp
View file

@ -7,7 +7,6 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBBlock.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBFileSpec.h"
#include "lldb/API/SBFrame.h"
@ -21,22 +20,22 @@
#include "lldb/Symbol/VariableList.h"
#include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h"
#include "lldb/Utility/Instrumentation.h"
using namespace lldb;
using namespace lldb_private;
SBBlock::SBBlock() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBlock); }
SBBlock::SBBlock() { LLDB_INSTRUMENT_VA(this); }
SBBlock::SBBlock(lldb_private::Block *lldb_object_ptr)
: m_opaque_ptr(lldb_object_ptr) {}
SBBlock::SBBlock(const SBBlock &rhs) : m_opaque_ptr(rhs.m_opaque_ptr) {
LLDB_RECORD_CONSTRUCTOR(SBBlock, (const lldb::SBBlock &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
}
const SBBlock &SBBlock::operator=(const SBBlock &rhs) {
LLDB_RECORD_METHOD(const lldb::SBBlock &,
SBBlock, operator=,(const lldb::SBBlock &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_ptr = rhs.m_opaque_ptr;
return *this;
@ -45,17 +44,17 @@ const SBBlock &SBBlock::operator=(const SBBlock &rhs) {
SBBlock::~SBBlock() { m_opaque_ptr = nullptr; }
bool SBBlock::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBlock, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBBlock::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBlock, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_opaque_ptr != nullptr;
}
bool SBBlock::IsInlined() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBlock, IsInlined);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr)
return m_opaque_ptr->GetInlinedFunctionInfo() != nullptr;
@ -63,7 +62,7 @@ bool SBBlock::IsInlined() const {
}
const char *SBBlock::GetInlinedName() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBlock, GetInlinedName);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr) {
const InlineFunctionInfo *inlined_info =
@ -76,8 +75,7 @@ const char *SBBlock::GetInlinedName() const {
}
SBFileSpec SBBlock::GetInlinedCallSiteFile() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBBlock,
GetInlinedCallSiteFile);
LLDB_INSTRUMENT_VA(this);
SBFileSpec sb_file;
if (m_opaque_ptr) {
@ -90,7 +88,7 @@ SBFileSpec SBBlock::GetInlinedCallSiteFile() const {
}
uint32_t SBBlock::GetInlinedCallSiteLine() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBlock, GetInlinedCallSiteLine);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr) {
const InlineFunctionInfo *inlined_info =
@ -102,7 +100,7 @@ uint32_t SBBlock::GetInlinedCallSiteLine() const {
}
uint32_t SBBlock::GetInlinedCallSiteColumn() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBlock, GetInlinedCallSiteColumn);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr) {
const InlineFunctionInfo *inlined_info =
@ -123,7 +121,7 @@ void SBBlock::AppendVariables(bool can_create, bool get_parent_variables,
}
SBBlock SBBlock::GetParent() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetParent);
LLDB_INSTRUMENT_VA(this);
SBBlock sb_block;
if (m_opaque_ptr)
@ -132,7 +130,7 @@ SBBlock SBBlock::GetParent() {
}
lldb::SBBlock SBBlock::GetContainingInlinedBlock() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetContainingInlinedBlock);
LLDB_INSTRUMENT_VA(this);
SBBlock sb_block;
if (m_opaque_ptr)
@ -141,7 +139,7 @@ lldb::SBBlock SBBlock::GetContainingInlinedBlock() {
}
SBBlock SBBlock::GetSibling() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetSibling);
LLDB_INSTRUMENT_VA(this);
SBBlock sb_block;
if (m_opaque_ptr)
@ -150,7 +148,7 @@ SBBlock SBBlock::GetSibling() {
}
SBBlock SBBlock::GetFirstChild() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetFirstChild);
LLDB_INSTRUMENT_VA(this);
SBBlock sb_block;
if (m_opaque_ptr)
@ -163,8 +161,7 @@ lldb_private::Block *SBBlock::GetPtr() { return m_opaque_ptr; }
void SBBlock::SetPtr(lldb_private::Block *block) { m_opaque_ptr = block; }
bool SBBlock::GetDescription(SBStream &description) {
LLDB_RECORD_METHOD(bool, SBBlock, GetDescription, (lldb::SBStream &),
description);
LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();
@ -188,7 +185,7 @@ bool SBBlock::GetDescription(SBStream &description) {
}
uint32_t SBBlock::GetNumRanges() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBBlock, GetNumRanges);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr)
return m_opaque_ptr->GetNumRanges();
@ -196,8 +193,7 @@ uint32_t SBBlock::GetNumRanges() {
}
lldb::SBAddress SBBlock::GetRangeStartAddress(uint32_t idx) {
LLDB_RECORD_METHOD(lldb::SBAddress, SBBlock, GetRangeStartAddress, (uint32_t),
idx);
LLDB_INSTRUMENT_VA(this, idx);
lldb::SBAddress sb_addr;
if (m_opaque_ptr) {
@ -210,8 +206,7 @@ lldb::SBAddress SBBlock::GetRangeStartAddress(uint32_t idx) {
}
lldb::SBAddress SBBlock::GetRangeEndAddress(uint32_t idx) {
LLDB_RECORD_METHOD(lldb::SBAddress, SBBlock, GetRangeEndAddress, (uint32_t),
idx);
LLDB_INSTRUMENT_VA(this, idx);
lldb::SBAddress sb_addr;
if (m_opaque_ptr) {
@ -225,8 +220,7 @@ lldb::SBAddress SBBlock::GetRangeEndAddress(uint32_t idx) {
}
uint32_t SBBlock::GetRangeIndexForBlockAddress(lldb::SBAddress block_addr) {
LLDB_RECORD_METHOD(uint32_t, SBBlock, GetRangeIndexForBlockAddress,
(lldb::SBAddress), block_addr);
LLDB_INSTRUMENT_VA(this, block_addr);
if (m_opaque_ptr && block_addr.IsValid()) {
return m_opaque_ptr->GetRangeIndexContainingAddress(block_addr.ref());
@ -238,10 +232,7 @@ uint32_t SBBlock::GetRangeIndexForBlockAddress(lldb::SBAddress block_addr) {
lldb::SBValueList SBBlock::GetVariables(lldb::SBFrame &frame, bool arguments,
bool locals, bool statics,
lldb::DynamicValueType use_dynamic) {
LLDB_RECORD_METHOD(
lldb::SBValueList, SBBlock, GetVariables,
(lldb::SBFrame &, bool, bool, bool, lldb::DynamicValueType), frame,
arguments, locals, statics, use_dynamic);
LLDB_INSTRUMENT_VA(this, frame, arguments, locals, statics, use_dynamic);
Block *block = GetPtr();
SBValueList value_list;
@ -294,9 +285,7 @@ lldb::SBValueList SBBlock::GetVariables(lldb::SBFrame &frame, bool arguments,
lldb::SBValueList SBBlock::GetVariables(lldb::SBTarget &target, bool arguments,
bool locals, bool statics) {
LLDB_RECORD_METHOD(lldb::SBValueList, SBBlock, GetVariables,
(lldb::SBTarget &, bool, bool, bool), target, arguments,
locals, statics);
LLDB_INSTRUMENT_VA(this, target, arguments, locals, statics);
Block *block = GetPtr();

172
lldb/source/API/SBBreakpoint.cpp
View file

@ -7,7 +7,6 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBBreakpoint.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBBreakpointLocation.h"
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBEvent.h"
@ -16,6 +15,7 @@
#include "lldb/API/SBStringList.h"
#include "lldb/API/SBStructuredData.h"
#include "lldb/API/SBThread.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/Breakpoint/Breakpoint.h"
#include "lldb/Breakpoint/BreakpointIDList.h"
@ -45,44 +45,41 @@
using namespace lldb;
using namespace lldb_private;
SBBreakpoint::SBBreakpoint() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBreakpoint); }
SBBreakpoint::SBBreakpoint() { LLDB_INSTRUMENT_VA(this); }
SBBreakpoint::SBBreakpoint(const SBBreakpoint &rhs)
: m_opaque_wp(rhs.m_opaque_wp) {
LLDB_RECORD_CONSTRUCTOR(SBBreakpoint, (const lldb::SBBreakpoint &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
}
SBBreakpoint::SBBreakpoint(const lldb::BreakpointSP &bp_sp)
: m_opaque_wp(bp_sp) {
LLDB_RECORD_CONSTRUCTOR(SBBreakpoint, (const lldb::BreakpointSP &), bp_sp);
LLDB_INSTRUMENT_VA(this, bp_sp);
}
SBBreakpoint::~SBBreakpoint() = default;
const SBBreakpoint &SBBreakpoint::operator=(const SBBreakpoint &rhs) {
LLDB_RECORD_METHOD(const lldb::SBBreakpoint &,
SBBreakpoint, operator=,(const lldb::SBBreakpoint &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_wp = rhs.m_opaque_wp;
return *this;
}
bool SBBreakpoint::operator==(const lldb::SBBreakpoint &rhs) {
LLDB_RECORD_METHOD(
bool, SBBreakpoint, operator==,(const lldb::SBBreakpoint &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
return m_opaque_wp.lock() == rhs.m_opaque_wp.lock();
}
bool SBBreakpoint::operator!=(const lldb::SBBreakpoint &rhs) {
LLDB_RECORD_METHOD(
bool, SBBreakpoint, operator!=,(const lldb::SBBreakpoint &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
return m_opaque_wp.lock() != rhs.m_opaque_wp.lock();
}
SBTarget SBBreakpoint::GetTarget() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBTarget, SBBreakpoint, GetTarget);
LLDB_INSTRUMENT_VA(this);
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp)
@ -92,7 +89,7 @@ SBTarget SBBreakpoint::GetTarget() const {
}
break_id_t SBBreakpoint::GetID() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::break_id_t, SBBreakpoint, GetID);
LLDB_INSTRUMENT_VA(this);
break_id_t break_id = LLDB_INVALID_BREAK_ID;
BreakpointSP bkpt_sp = GetSP();
@ -103,11 +100,11 @@ break_id_t SBBreakpoint::GetID() const {
}
bool SBBreakpoint::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBBreakpoint::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, operator bool);
LLDB_INSTRUMENT_VA(this);
BreakpointSP bkpt_sp = GetSP();
if (!bkpt_sp)
@ -119,7 +116,7 @@ SBBreakpoint::operator bool() const {
}
void SBBreakpoint::ClearAllBreakpointSites() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBBreakpoint, ClearAllBreakpointSites);
LLDB_INSTRUMENT_VA(this);
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
@ -130,8 +127,7 @@ void SBBreakpoint::ClearAllBreakpointSites() {
}
SBBreakpointLocation SBBreakpoint::FindLocationByAddress(addr_t vm_addr) {
LLDB_RECORD_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
FindLocationByAddress, (lldb::addr_t), vm_addr);
LLDB_INSTRUMENT_VA(this, vm_addr);
SBBreakpointLocation sb_bp_location;
@ -152,8 +148,7 @@ SBBreakpointLocation SBBreakpoint::FindLocationByAddress(addr_t vm_addr) {
}
break_id_t SBBreakpoint::FindLocationIDByAddress(addr_t vm_addr) {
LLDB_RECORD_METHOD(lldb::break_id_t, SBBreakpoint, FindLocationIDByAddress,
(lldb::addr_t), vm_addr);
LLDB_INSTRUMENT_VA(this, vm_addr);
break_id_t break_id = LLDB_INVALID_BREAK_ID;
BreakpointSP bkpt_sp = GetSP();
@ -173,8 +168,7 @@ break_id_t SBBreakpoint::FindLocationIDByAddress(addr_t vm_addr) {
}
SBBreakpointLocation SBBreakpoint::FindLocationByID(break_id_t bp_loc_id) {
LLDB_RECORD_METHOD(lldb::SBBreakpointLocation, SBBreakpoint, FindLocationByID,
(lldb::break_id_t), bp_loc_id);
LLDB_INSTRUMENT_VA(this, bp_loc_id);
SBBreakpointLocation sb_bp_location;
BreakpointSP bkpt_sp = GetSP();
@ -189,8 +183,7 @@ SBBreakpointLocation SBBreakpoint::FindLocationByID(break_id_t bp_loc_id) {
}
SBBreakpointLocation SBBreakpoint::GetLocationAtIndex(uint32_t index) {
LLDB_RECORD_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
GetLocationAtIndex, (uint32_t), index);
LLDB_INSTRUMENT_VA(this, index);
SBBreakpointLocation sb_bp_location;
BreakpointSP bkpt_sp = GetSP();
@ -205,7 +198,7 @@ SBBreakpointLocation SBBreakpoint::GetLocationAtIndex(uint32_t index) {
}
void SBBreakpoint::SetEnabled(bool enable) {
LLDB_RECORD_METHOD(void, SBBreakpoint, SetEnabled, (bool), enable);
LLDB_INSTRUMENT_VA(this, enable);
BreakpointSP bkpt_sp = GetSP();
@ -217,7 +210,7 @@ void SBBreakpoint::SetEnabled(bool enable) {
}
bool SBBreakpoint::IsEnabled() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpoint, IsEnabled);
LLDB_INSTRUMENT_VA(this);
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
@ -229,7 +222,7 @@ bool SBBreakpoint::IsEnabled() {
}
void SBBreakpoint::SetOneShot(bool one_shot) {
LLDB_RECORD_METHOD(void, SBBreakpoint, SetOneShot, (bool), one_shot);
LLDB_INSTRUMENT_VA(this, one_shot);
BreakpointSP bkpt_sp = GetSP();
@ -241,7 +234,7 @@ void SBBreakpoint::SetOneShot(bool one_shot) {
}
bool SBBreakpoint::IsOneShot() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, IsOneShot);
LLDB_INSTRUMENT_VA(this);
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
@ -253,7 +246,7 @@ bool SBBreakpoint::IsOneShot() const {
}
bool SBBreakpoint::IsInternal() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpoint, IsInternal);
LLDB_INSTRUMENT_VA(this);
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
@ -265,7 +258,7 @@ bool SBBreakpoint::IsInternal() {
}
void SBBreakpoint::SetIgnoreCount(uint32_t count) {
LLDB_RECORD_METHOD(void, SBBreakpoint, SetIgnoreCount, (uint32_t), count);
LLDB_INSTRUMENT_VA(this, count);
BreakpointSP bkpt_sp = GetSP();
@ -277,8 +270,7 @@ void SBBreakpoint::SetIgnoreCount(uint32_t count) {
}
void SBBreakpoint::SetCondition(const char *condition) {
LLDB_RECORD_METHOD(void, SBBreakpoint, SetCondition, (const char *),
condition);
LLDB_INSTRUMENT_VA(this, condition);
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
@ -289,7 +281,7 @@ void SBBreakpoint::SetCondition(const char *condition) {
}
const char *SBBreakpoint::GetCondition() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBBreakpoint, GetCondition);
LLDB_INSTRUMENT_VA(this);
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
@ -301,8 +293,7 @@ const char *SBBreakpoint::GetCondition() {
}
void SBBreakpoint::SetAutoContinue(bool auto_continue) {
LLDB_RECORD_METHOD(void, SBBreakpoint, SetAutoContinue, (bool),
auto_continue);
LLDB_INSTRUMENT_VA(this, auto_continue);
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
@ -313,7 +304,7 @@ void SBBreakpoint::SetAutoContinue(bool auto_continue) {
}
bool SBBreakpoint::GetAutoContinue() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpoint, GetAutoContinue);
LLDB_INSTRUMENT_VA(this);
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
@ -325,7 +316,7 @@ bool SBBreakpoint::GetAutoContinue() {
}
uint32_t SBBreakpoint::GetHitCount() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpoint, GetHitCount);
LLDB_INSTRUMENT_VA(this);
uint32_t count = 0;
BreakpointSP bkpt_sp = GetSP();
@ -339,7 +330,7 @@ uint32_t SBBreakpoint::GetHitCount() const {
}
uint32_t SBBreakpoint::GetIgnoreCount() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpoint, GetIgnoreCount);
LLDB_INSTRUMENT_VA(this);
uint32_t count = 0;
BreakpointSP bkpt_sp = GetSP();
@ -353,7 +344,7 @@ uint32_t SBBreakpoint::GetIgnoreCount() const {
}
void SBBreakpoint::SetThreadID(tid_t tid) {
LLDB_RECORD_METHOD(void, SBBreakpoint, SetThreadID, (lldb::tid_t), tid);
LLDB_INSTRUMENT_VA(this, tid);
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
@ -364,7 +355,7 @@ void SBBreakpoint::SetThreadID(tid_t tid) {
}
tid_t SBBreakpoint::GetThreadID() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBBreakpoint, GetThreadID);
LLDB_INSTRUMENT_VA(this);
tid_t tid = LLDB_INVALID_THREAD_ID;
BreakpointSP bkpt_sp = GetSP();
@ -378,7 +369,7 @@ tid_t SBBreakpoint::GetThreadID() {
}
void SBBreakpoint::SetThreadIndex(uint32_t index) {
LLDB_RECORD_METHOD(void, SBBreakpoint, SetThreadIndex, (uint32_t), index);
LLDB_INSTRUMENT_VA(this, index);
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
@ -389,7 +380,7 @@ void SBBreakpoint::SetThreadIndex(uint32_t index) {
}
uint32_t SBBreakpoint::GetThreadIndex() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpoint, GetThreadIndex);
LLDB_INSTRUMENT_VA(this);
uint32_t thread_idx = UINT32_MAX;
BreakpointSP bkpt_sp = GetSP();
@ -406,8 +397,7 @@ uint32_t SBBreakpoint::GetThreadIndex() const {
}
void SBBreakpoint::SetThreadName(const char *thread_name) {
LLDB_RECORD_METHOD(void, SBBreakpoint, SetThreadName, (const char *),
thread_name);
LLDB_INSTRUMENT_VA(this, thread_name);
BreakpointSP bkpt_sp = GetSP();
@ -419,7 +409,7 @@ void SBBreakpoint::SetThreadName(const char *thread_name) {
}
const char *SBBreakpoint::GetThreadName() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpoint, GetThreadName);
LLDB_INSTRUMENT_VA(this);
const char *name = nullptr;
BreakpointSP bkpt_sp = GetSP();
@ -436,8 +426,7 @@ const char *SBBreakpoint::GetThreadName() const {
}
void SBBreakpoint::SetQueueName(const char *queue_name) {
LLDB_RECORD_METHOD(void, SBBreakpoint, SetQueueName, (const char *),
queue_name);
LLDB_INSTRUMENT_VA(this, queue_name);
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
@ -448,7 +437,7 @@ void SBBreakpoint::SetQueueName(const char *queue_name) {
}
const char *SBBreakpoint::GetQueueName() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpoint, GetQueueName);
LLDB_INSTRUMENT_VA(this);
const char *name = nullptr;
BreakpointSP bkpt_sp = GetSP();
@ -465,8 +454,7 @@ const char *SBBreakpoint::GetQueueName() const {
}
size_t SBBreakpoint::GetNumResolvedLocations() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBBreakpoint,
GetNumResolvedLocations);
LLDB_INSTRUMENT_VA(this);
size_t num_resolved = 0;
BreakpointSP bkpt_sp = GetSP();
@ -479,7 +467,7 @@ size_t SBBreakpoint::GetNumResolvedLocations() const {
}
size_t SBBreakpoint::GetNumLocations() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBBreakpoint, GetNumLocations);
LLDB_INSTRUMENT_VA(this);
BreakpointSP bkpt_sp = GetSP();
size_t num_locs = 0;
@ -492,8 +480,7 @@ size_t SBBreakpoint::GetNumLocations() const {
}
void SBBreakpoint::SetCommandLineCommands(SBStringList &commands) {
LLDB_RECORD_METHOD(void, SBBreakpoint, SetCommandLineCommands,
(lldb::SBStringList &), commands);
LLDB_INSTRUMENT_VA(this, commands);
BreakpointSP bkpt_sp = GetSP();
if (!bkpt_sp)
@ -510,8 +497,7 @@ void SBBreakpoint::SetCommandLineCommands(SBStringList &commands) {
}
bool SBBreakpoint::GetCommandLineCommands(SBStringList &commands) {
LLDB_RECORD_METHOD(bool, SBBreakpoint, GetCommandLineCommands,
(lldb::SBStringList &), commands);
LLDB_INSTRUMENT_VA(this, commands);
BreakpointSP bkpt_sp = GetSP();
if (!bkpt_sp)
@ -525,14 +511,13 @@ bool SBBreakpoint::GetCommandLineCommands(SBStringList &commands) {
}
bool SBBreakpoint::GetDescription(SBStream &s) {
LLDB_RECORD_METHOD(bool, SBBreakpoint, GetDescription, (lldb::SBStream &), s);
LLDB_INSTRUMENT_VA(this, s);
return GetDescription(s, true);
}
bool SBBreakpoint::GetDescription(SBStream &s, bool include_locations) {
LLDB_RECORD_METHOD(bool, SBBreakpoint, GetDescription,
(lldb::SBStream &, bool), s, include_locations);
LLDB_INSTRUMENT_VA(this, s, include_locations);
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
@ -552,8 +537,7 @@ bool SBBreakpoint::GetDescription(SBStream &s, bool include_locations) {
}
SBError SBBreakpoint::AddLocation(SBAddress &address) {
LLDB_RECORD_METHOD(lldb::SBError, SBBreakpoint, AddLocation,
(lldb::SBAddress &), address);
LLDB_INSTRUMENT_VA(this, address);
BreakpointSP bkpt_sp = GetSP();
SBError error;
@ -586,8 +570,7 @@ SBError SBBreakpoint::AddLocation(SBAddress &address) {
}
SBStructuredData SBBreakpoint::SerializeToStructuredData() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStructuredData, SBBreakpoint,
SerializeToStructuredData);
LLDB_INSTRUMENT_VA(this);
SBStructuredData data;
BreakpointSP bkpt_sp = GetSP();
@ -601,8 +584,7 @@ SBStructuredData SBBreakpoint::SerializeToStructuredData() {
}
void SBBreakpoint::SetCallback(SBBreakpointHitCallback callback, void *baton) {
LLDB_RECORD_METHOD(void, SBBreakpoint, SetCallback,
(lldb::SBBreakpointHitCallback, void *), callback, baton);
LLDB_INSTRUMENT_VA(this, callback, baton);
BreakpointSP bkpt_sp = GetSP();
@ -618,8 +600,7 @@ void SBBreakpoint::SetCallback(SBBreakpointHitCallback callback, void *baton) {
void SBBreakpoint::SetScriptCallbackFunction(
const char *callback_function_name) {
LLDB_RECORD_METHOD(void, SBBreakpoint, SetScriptCallbackFunction,
(const char *), callback_function_name);
LLDB_INSTRUMENT_VA(this, callback_function_name);
SBStructuredData empty_args;
SetScriptCallbackFunction(callback_function_name, empty_args);
}
@ -627,8 +608,7 @@ LLDB_RECORD_METHOD(void, SBBreakpoint, SetScriptCallbackFunction,
SBError SBBreakpoint::SetScriptCallbackFunction(
const char *callback_function_name,
SBStructuredData &extra_args) {
LLDB_RECORD_METHOD(SBError, SBBreakpoint, SetScriptCallbackFunction,
(const char *, SBStructuredData &), callback_function_name, extra_args);
LLDB_INSTRUMENT_VA(this, callback_function_name, extra_args);
SBError sb_error;
BreakpointSP bkpt_sp = GetSP();
@ -652,8 +632,7 @@ SBError SBBreakpoint::SetScriptCallbackFunction(
}
SBError SBBreakpoint::SetScriptCallbackBody(const char *callback_body_text) {
LLDB_RECORD_METHOD(lldb::SBError, SBBreakpoint, SetScriptCallbackBody,
(const char *), callback_body_text);
LLDB_INSTRUMENT_VA(this, callback_body_text);
BreakpointSP bkpt_sp = GetSP();
@ -675,15 +654,14 @@ SBError SBBreakpoint::SetScriptCallbackBody(const char *callback_body_text) {
}
bool SBBreakpoint::AddName(const char *new_name) {
LLDB_RECORD_METHOD(bool, SBBreakpoint, AddName, (const char *), new_name);
LLDB_INSTRUMENT_VA(this, new_name);
SBError status = AddNameWithErrorHandling(new_name);
return status.Success();
}
SBError SBBreakpoint::AddNameWithErrorHandling(const char *new_name) {
LLDB_RECORD_METHOD(SBError, SBBreakpoint, AddNameWithErrorHandling,
(const char *), new_name);
LLDB_INSTRUMENT_VA(this, new_name);
BreakpointSP bkpt_sp = GetSP();
@ -702,8 +680,7 @@ SBError SBBreakpoint::AddNameWithErrorHandling(const char *new_name) {
}
void SBBreakpoint::RemoveName(const char *name_to_remove) {
LLDB_RECORD_METHOD(void, SBBreakpoint, RemoveName, (const char *),
name_to_remove);
LLDB_INSTRUMENT_VA(this, name_to_remove);
BreakpointSP bkpt_sp = GetSP();
@ -716,7 +693,7 @@ void SBBreakpoint::RemoveName(const char *name_to_remove) {
}
bool SBBreakpoint::MatchesName(const char *name) {
LLDB_RECORD_METHOD(bool, SBBreakpoint, MatchesName, (const char *), name);
LLDB_INSTRUMENT_VA(this, name);
BreakpointSP bkpt_sp = GetSP();
@ -730,8 +707,7 @@ bool SBBreakpoint::MatchesName(const char *name) {
}
void SBBreakpoint::GetNames(SBStringList &names) {
LLDB_RECORD_METHOD(void, SBBreakpoint, GetNames, (lldb::SBStringList &),
names);
LLDB_INSTRUMENT_VA(this, names);
BreakpointSP bkpt_sp = GetSP();
@ -747,8 +723,7 @@ void SBBreakpoint::GetNames(SBStringList &names) {
}
bool SBBreakpoint::EventIsBreakpointEvent(const lldb::SBEvent &event) {
LLDB_RECORD_STATIC_METHOD(bool, SBBreakpoint, EventIsBreakpointEvent,
(const lldb::SBEvent &), event);
LLDB_INSTRUMENT_VA(event);
return Breakpoint::BreakpointEventData::GetEventDataFromEvent(event.get()) !=
nullptr;
@ -756,9 +731,7 @@ bool SBBreakpoint::EventIsBreakpointEvent(const lldb::SBEvent &event) {
BreakpointEventType
SBBreakpoint::GetBreakpointEventTypeFromEvent(const SBEvent &event) {
LLDB_RECORD_STATIC_METHOD(lldb::BreakpointEventType, SBBreakpoint,
GetBreakpointEventTypeFromEvent,
(const lldb::SBEvent &), event);
LLDB_INSTRUMENT_VA(event);
if (event.IsValid())
return Breakpoint::BreakpointEventData::GetBreakpointEventTypeFromEvent(
@ -767,9 +740,7 @@ SBBreakpoint::GetBreakpointEventTypeFromEvent(const SBEvent &event) {
}
SBBreakpoint SBBreakpoint::GetBreakpointFromEvent(const lldb::SBEvent &event) {
LLDB_RECORD_STATIC_METHOD(lldb::SBBreakpoint, SBBreakpoint,
GetBreakpointFromEvent, (const lldb::SBEvent &),
event);
LLDB_INSTRUMENT_VA(event);
if (event.IsValid())
return SBBreakpoint(
@ -780,9 +751,7 @@ SBBreakpoint SBBreakpoint::GetBreakpointFromEvent(const lldb::SBEvent &event) {
SBBreakpointLocation
SBBreakpoint::GetBreakpointLocationAtIndexFromEvent(const lldb::SBEvent &event,
uint32_t loc_idx) {
LLDB_RECORD_STATIC_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
GetBreakpointLocationAtIndexFromEvent,
(const lldb::SBEvent &, uint32_t), event, loc_idx);
LLDB_INSTRUMENT_VA(event, loc_idx);
SBBreakpointLocation sb_breakpoint_loc;
if (event.IsValid())
@ -794,9 +763,7 @@ SBBreakpoint::GetBreakpointLocationAtIndexFromEvent(const lldb::SBEvent &event,
uint32_t
SBBreakpoint::GetNumBreakpointLocationsFromEvent(const lldb::SBEvent &event) {
LLDB_RECORD_STATIC_METHOD(uint32_t, SBBreakpoint,
GetNumBreakpointLocationsFromEvent,
(const lldb::SBEvent &), event);
LLDB_INSTRUMENT_VA(event);
uint32_t num_locations = 0;
if (event.IsValid())
@ -807,7 +774,7 @@ SBBreakpoint::GetNumBreakpointLocationsFromEvent(const lldb::SBEvent &event) {
}
bool SBBreakpoint::IsHardware() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, IsHardware);
LLDB_INSTRUMENT_VA(this);
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp)
@ -903,13 +870,13 @@ private:
SBBreakpointList::SBBreakpointList(SBTarget &target)
: m_opaque_sp(new SBBreakpointListImpl(target.GetSP())) {
LLDB_RECORD_CONSTRUCTOR(SBBreakpointList, (lldb::SBTarget &), target);
LLDB_INSTRUMENT_VA(this, target);
}
SBBreakpointList::~SBBreakpointList() = default;
size_t SBBreakpointList::GetSize() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBBreakpointList, GetSize);
LLDB_INSTRUMENT_VA(this);
if (!m_opaque_sp)
return 0;
@ -918,8 +885,7 @@ size_t SBBreakpointList::GetSize() const {
}
SBBreakpoint SBBreakpointList::GetBreakpointAtIndex(size_t idx) {
LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBBreakpointList, GetBreakpointAtIndex,
(size_t), idx);
LLDB_INSTRUMENT_VA(this, idx);
if (!m_opaque_sp)
return SBBreakpoint();
@ -929,8 +895,7 @@ SBBreakpoint SBBreakpointList::GetBreakpointAtIndex(size_t idx) {
}
SBBreakpoint SBBreakpointList::FindBreakpointByID(lldb::break_id_t id) {
LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBBreakpointList, FindBreakpointByID,
(lldb::break_id_t), id);
LLDB_INSTRUMENT_VA(this, id);
if (!m_opaque_sp)
return SBBreakpoint();
@ -939,8 +904,7 @@ SBBreakpoint SBBreakpointList::FindBreakpointByID(lldb::break_id_t id) {
}
void SBBreakpointList::Append(const SBBreakpoint &sb_bkpt) {
LLDB_RECORD_METHOD(void, SBBreakpointList, Append,
(const lldb::SBBreakpoint &), sb_bkpt);
LLDB_INSTRUMENT_VA(this, sb_bkpt);
if (!sb_bkpt.IsValid())
return;
@ -950,8 +914,7 @@ void SBBreakpointList::Append(const SBBreakpoint &sb_bkpt) {
}
void SBBreakpointList::AppendByID(lldb::break_id_t id) {
LLDB_RECORD_METHOD(void, SBBreakpointList, AppendByID, (lldb::break_id_t),
id);
LLDB_INSTRUMENT_VA(this, id);
if (!m_opaque_sp)
return;
@ -959,8 +922,7 @@ void SBBreakpointList::AppendByID(lldb::break_id_t id) {
}
bool SBBreakpointList::AppendIfUnique(const SBBreakpoint &sb_bkpt) {
LLDB_RECORD_METHOD(bool, SBBreakpointList, AppendIfUnique,
(const lldb::SBBreakpoint &), sb_bkpt);
LLDB_INSTRUMENT_VA(this, sb_bkpt);
if (!sb_bkpt.IsValid())
return false;
@ -970,7 +932,7 @@ bool SBBreakpointList::AppendIfUnique(const SBBreakpoint &sb_bkpt) {
}
void SBBreakpointList::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBBreakpointList, Clear);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp)
m_opaque_sp->Clear();

98
lldb/source/API/SBBreakpointLocation.cpp
View file

@ -7,13 +7,13 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBBreakpointLocation.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBDefines.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBStructuredData.h"
#include "lldb/API/SBStringList.h"
#include "lldb/API/SBStructuredData.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/Breakpoint/Breakpoint.h"
#include "lldb/Breakpoint/BreakpointLocation.h"
@ -31,29 +31,22 @@
using namespace lldb;
using namespace lldb_private;
SBBreakpointLocation::SBBreakpointLocation() {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBreakpointLocation);
}
SBBreakpointLocation::SBBreakpointLocation() { LLDB_INSTRUMENT_VA(this); }
SBBreakpointLocation::SBBreakpointLocation(
const lldb::BreakpointLocationSP &break_loc_sp)
: m_opaque_wp(break_loc_sp) {
LLDB_RECORD_CONSTRUCTOR(SBBreakpointLocation,
(const lldb::BreakpointLocationSP &), break_loc_sp);
LLDB_INSTRUMENT_VA(this, break_loc_sp);
}
SBBreakpointLocation::SBBreakpointLocation(const SBBreakpointLocation &rhs)
: m_opaque_wp(rhs.m_opaque_wp) {
LLDB_RECORD_CONSTRUCTOR(SBBreakpointLocation,
(const lldb::SBBreakpointLocation &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
}
const SBBreakpointLocation &SBBreakpointLocation::
operator=(const SBBreakpointLocation &rhs) {
LLDB_RECORD_METHOD(
const lldb::SBBreakpointLocation &,
SBBreakpointLocation, operator=,(const lldb::SBBreakpointLocation &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_wp = rhs.m_opaque_wp;
return *this;
@ -66,17 +59,17 @@ BreakpointLocationSP SBBreakpointLocation::GetSP() const {
}
bool SBBreakpointLocation::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointLocation, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBBreakpointLocation::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointLocation, operator bool);
LLDB_INSTRUMENT_VA(this);
return bool(GetSP());
}
SBAddress SBBreakpointLocation::GetAddress() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBBreakpointLocation, GetAddress);
LLDB_INSTRUMENT_VA(this);
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
@ -87,8 +80,7 @@ SBAddress SBBreakpointLocation::GetAddress() {
}
addr_t SBBreakpointLocation::GetLoadAddress() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBBreakpointLocation,
GetLoadAddress);
LLDB_INSTRUMENT_VA(this);
addr_t ret_addr = LLDB_INVALID_ADDRESS;
BreakpointLocationSP loc_sp = GetSP();
@ -103,7 +95,7 @@ addr_t SBBreakpointLocation::GetLoadAddress() {
}
void SBBreakpointLocation::SetEnabled(bool enabled) {
LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetEnabled, (bool), enabled);
LLDB_INSTRUMENT_VA(this, enabled);
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
@ -114,7 +106,7 @@ void SBBreakpointLocation::SetEnabled(bool enabled) {
}
bool SBBreakpointLocation::IsEnabled() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointLocation, IsEnabled);
LLDB_INSTRUMENT_VA(this);
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
@ -126,7 +118,7 @@ bool SBBreakpointLocation::IsEnabled() {
}
uint32_t SBBreakpointLocation::GetHitCount() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBBreakpointLocation, GetHitCount);
LLDB_INSTRUMENT_VA(this);
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
@ -138,7 +130,7 @@ uint32_t SBBreakpointLocation::GetHitCount() {
}
uint32_t SBBreakpointLocation::GetIgnoreCount() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBBreakpointLocation, GetIgnoreCount);
LLDB_INSTRUMENT_VA(this);
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
@ -150,7 +142,7 @@ uint32_t SBBreakpointLocation::GetIgnoreCount() {
}
void SBBreakpointLocation::SetIgnoreCount(uint32_t n) {
LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetIgnoreCount, (uint32_t), n);
LLDB_INSTRUMENT_VA(this, n);
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
@ -161,8 +153,7 @@ void SBBreakpointLocation::SetIgnoreCount(uint32_t n) {
}
void SBBreakpointLocation::SetCondition(const char *condition) {
LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetCondition, (const char *),
condition);
LLDB_INSTRUMENT_VA(this, condition);
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
@ -173,7 +164,7 @@ void SBBreakpointLocation::SetCondition(const char *condition) {
}
const char *SBBreakpointLocation::GetCondition() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBBreakpointLocation, GetCondition);
LLDB_INSTRUMENT_VA(this);
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
@ -185,8 +176,7 @@ const char *SBBreakpointLocation::GetCondition() {
}
void SBBreakpointLocation::SetAutoContinue(bool auto_continue) {
LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetAutoContinue, (bool),
auto_continue);
LLDB_INSTRUMENT_VA(this, auto_continue);
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
@ -197,7 +187,7 @@ void SBBreakpointLocation::SetAutoContinue(bool auto_continue) {
}
bool SBBreakpointLocation::GetAutoContinue() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointLocation, GetAutoContinue);
LLDB_INSTRUMENT_VA(this);
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
@ -210,16 +200,13 @@ bool SBBreakpointLocation::GetAutoContinue() {
void SBBreakpointLocation::SetScriptCallbackFunction(
const char *callback_function_name) {
LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetScriptCallbackFunction,
(const char *), callback_function_name);
LLDB_INSTRUMENT_VA(this, callback_function_name);
}
SBError SBBreakpointLocation::SetScriptCallbackFunction(
const char *callback_function_name,
SBStructuredData &extra_args) {
LLDB_RECORD_METHOD(SBError, SBBreakpointLocation, SetScriptCallbackFunction,
(const char *, SBStructuredData &), callback_function_name,
extra_args);
LLDB_INSTRUMENT_VA(this, callback_function_name, extra_args);
SBError sb_error;
BreakpointLocationSP loc_sp = GetSP();
@ -245,8 +232,7 @@ SBError SBBreakpointLocation::SetScriptCallbackFunction(
SBError
SBBreakpointLocation::SetScriptCallbackBody(const char *callback_body_text) {
LLDB_RECORD_METHOD(lldb::SBError, SBBreakpointLocation, SetScriptCallbackBody,
(const char *), callback_body_text);
LLDB_INSTRUMENT_VA(this, callback_body_text);
BreakpointLocationSP loc_sp = GetSP();
@ -269,8 +255,7 @@ SBBreakpointLocation::SetScriptCallbackBody(const char *callback_body_text) {
}
void SBBreakpointLocation::SetCommandLineCommands(SBStringList &commands) {
LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetCommandLineCommands,
(lldb::SBStringList &), commands);
LLDB_INSTRUMENT_VA(this, commands);
BreakpointLocationSP loc_sp = GetSP();
if (!loc_sp)
@ -287,8 +272,7 @@ void SBBreakpointLocation::SetCommandLineCommands(SBStringList &commands) {
}
bool SBBreakpointLocation::GetCommandLineCommands(SBStringList &commands) {
LLDB_RECORD_METHOD(bool, SBBreakpointLocation, GetCommandLineCommands,
(lldb::SBStringList &), commands);
LLDB_INSTRUMENT_VA(this, commands);
BreakpointLocationSP loc_sp = GetSP();
if (!loc_sp)
@ -302,8 +286,7 @@ bool SBBreakpointLocation::GetCommandLineCommands(SBStringList &commands) {
}
void SBBreakpointLocation::SetThreadID(tid_t thread_id) {
LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetThreadID, (lldb::tid_t),
thread_id);
LLDB_INSTRUMENT_VA(this, thread_id);
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
@ -314,7 +297,7 @@ void SBBreakpointLocation::SetThreadID(tid_t thread_id) {
}
tid_t SBBreakpointLocation::GetThreadID() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBBreakpointLocation, GetThreadID);
LLDB_INSTRUMENT_VA(this);
tid_t tid = LLDB_INVALID_THREAD_ID;
BreakpointLocationSP loc_sp = GetSP();
@ -327,8 +310,7 @@ tid_t SBBreakpointLocation::GetThreadID() {
}
void SBBreakpointLocation::SetThreadIndex(uint32_t index) {
LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetThreadIndex, (uint32_t),
index);
LLDB_INSTRUMENT_VA(this, index);
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
@ -339,8 +321,7 @@ void SBBreakpointLocation::SetThreadIndex(uint32_t index) {
}
uint32_t SBBreakpointLocation::GetThreadIndex() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointLocation,
GetThreadIndex);
LLDB_INSTRUMENT_VA(this);
uint32_t thread_idx = UINT32_MAX;
BreakpointLocationSP loc_sp = GetSP();
@ -353,8 +334,7 @@ uint32_t SBBreakpointLocation::GetThreadIndex() const {
}
void SBBreakpointLocation::SetThreadName(const char *thread_name) {
LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetThreadName, (const char *),
thread_name);
LLDB_INSTRUMENT_VA(this, thread_name);
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
@ -365,8 +345,7 @@ void SBBreakpointLocation::SetThreadName(const char *thread_name) {
}
const char *SBBreakpointLocation::GetThreadName() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointLocation,
GetThreadName);
LLDB_INSTRUMENT_VA(this);
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
@ -378,8 +357,7 @@ const char *SBBreakpointLocation::GetThreadName() const {
}
void SBBreakpointLocation::SetQueueName(const char *queue_name) {
LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetQueueName, (const char *),
queue_name);
LLDB_INSTRUMENT_VA(this, queue_name);
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
@ -390,8 +368,7 @@ void SBBreakpointLocation::SetQueueName(const char *queue_name) {
}
const char *SBBreakpointLocation::GetQueueName() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointLocation,
GetQueueName);
LLDB_INSTRUMENT_VA(this);
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
@ -403,7 +380,7 @@ const char *SBBreakpointLocation::GetQueueName() const {
}
bool SBBreakpointLocation::IsResolved() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointLocation, IsResolved);
LLDB_INSTRUMENT_VA(this);
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
@ -422,9 +399,7 @@ void SBBreakpointLocation::SetLocation(
bool SBBreakpointLocation::GetDescription(SBStream &description,
DescriptionLevel level) {
LLDB_RECORD_METHOD(bool, SBBreakpointLocation, GetDescription,
(lldb::SBStream &, lldb::DescriptionLevel), description,
level);
LLDB_INSTRUMENT_VA(this, description, level);
Stream &strm = description.ref();
BreakpointLocationSP loc_sp = GetSP();
@ -441,7 +416,7 @@ bool SBBreakpointLocation::GetDescription(SBStream &description,
}
break_id_t SBBreakpointLocation::GetID() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::break_id_t, SBBreakpointLocation, GetID);
LLDB_INSTRUMENT_VA(this);
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
@ -453,8 +428,7 @@ break_id_t SBBreakpointLocation::GetID() {
}
SBBreakpoint SBBreakpointLocation::GetBreakpoint() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBreakpoint, SBBreakpointLocation,
GetBreakpoint);
LLDB_INSTRUMENT_VA(this);
BreakpointLocationSP loc_sp = GetSP();

115
lldb/source/API/SBBreakpointName.cpp
View file

@ -7,13 +7,13 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBBreakpointName.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBError.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBStringList.h"
#include "lldb/API/SBStructuredData.h"
#include "lldb/API/SBTarget.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/Breakpoint/BreakpointName.h"
#include "lldb/Breakpoint/StoppointCallbackContext.h"
@ -107,13 +107,10 @@ lldb_private::BreakpointName *SBBreakpointNameImpl::GetBreakpointName() const {
} // namespace lldb
SBBreakpointName::SBBreakpointName() {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBreakpointName);
}
SBBreakpointName::SBBreakpointName() { LLDB_INSTRUMENT_VA(this); }
SBBreakpointName::SBBreakpointName(SBTarget &sb_target, const char *name) {
LLDB_RECORD_CONSTRUCTOR(SBBreakpointName, (lldb::SBTarget &, const char *),
sb_target, name);
LLDB_INSTRUMENT_VA(this, sb_target, name);
m_impl_up = std::make_unique<SBBreakpointNameImpl>(sb_target, name);
// Call FindBreakpointName here to make sure the name is valid, reset if not:
@ -123,8 +120,7 @@ SBBreakpointName::SBBreakpointName(SBTarget &sb_target, const char *name) {
}
SBBreakpointName::SBBreakpointName(SBBreakpoint &sb_bkpt, const char *name) {
LLDB_RECORD_CONSTRUCTOR(SBBreakpointName,
(lldb::SBBreakpoint &, const char *), sb_bkpt, name);
LLDB_INSTRUMENT_VA(this, sb_bkpt, name);
if (!sb_bkpt.IsValid()) {
m_impl_up.reset();
@ -149,8 +145,7 @@ SBBreakpointName::SBBreakpointName(SBBreakpoint &sb_bkpt, const char *name) {
}
SBBreakpointName::SBBreakpointName(const SBBreakpointName &rhs) {
LLDB_RECORD_CONSTRUCTOR(SBBreakpointName, (const lldb::SBBreakpointName &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (!rhs.m_impl_up)
return;
@ -163,9 +158,7 @@ SBBreakpointName::~SBBreakpointName() = default;
const SBBreakpointName &SBBreakpointName::
operator=(const SBBreakpointName &rhs) {
LLDB_RECORD_METHOD(
const lldb::SBBreakpointName &,
SBBreakpointName, operator=,(const lldb::SBBreakpointName &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (!rhs.m_impl_up) {
m_impl_up.reset();
@ -178,25 +171,23 @@ operator=(const SBBreakpointName &rhs) {
}
bool SBBreakpointName::operator==(const lldb::SBBreakpointName &rhs) {
LLDB_RECORD_METHOD(
bool, SBBreakpointName, operator==,(const lldb::SBBreakpointName &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
return *m_impl_up == *rhs.m_impl_up;
}
bool SBBreakpointName::operator!=(const lldb::SBBreakpointName &rhs) {
LLDB_RECORD_METHOD(
bool, SBBreakpointName, operator!=,(const lldb::SBBreakpointName &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
return *m_impl_up != *rhs.m_impl_up;
}
bool SBBreakpointName::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBBreakpointName::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, operator bool);
LLDB_INSTRUMENT_VA(this);
if (!m_impl_up)
return false;
@ -204,7 +195,7 @@ SBBreakpointName::operator bool() const {
}
const char *SBBreakpointName::GetName() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName, GetName);
LLDB_INSTRUMENT_VA(this);
if (!m_impl_up)
return "<Invalid Breakpoint Name Object>";
@ -212,7 +203,7 @@ const char *SBBreakpointName::GetName() const {
}
void SBBreakpointName::SetEnabled(bool enable) {
LLDB_RECORD_METHOD(void, SBBreakpointName, SetEnabled, (bool), enable);
LLDB_INSTRUMENT_VA(this, enable);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@ -236,7 +227,7 @@ void SBBreakpointName::UpdateName(BreakpointName &bp_name) {
}
bool SBBreakpointName::IsEnabled() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, IsEnabled);
LLDB_INSTRUMENT_VA(this);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@ -249,7 +240,7 @@ bool SBBreakpointName::IsEnabled() {
}
void SBBreakpointName::SetOneShot(bool one_shot) {
LLDB_RECORD_METHOD(void, SBBreakpointName, SetOneShot, (bool), one_shot);
LLDB_INSTRUMENT_VA(this, one_shot);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@ -263,7 +254,7 @@ void SBBreakpointName::SetOneShot(bool one_shot) {
}
bool SBBreakpointName::IsOneShot() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, IsOneShot);
LLDB_INSTRUMENT_VA(this);
const BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@ -276,7 +267,7 @@ bool SBBreakpointName::IsOneShot() const {
}
void SBBreakpointName::SetIgnoreCount(uint32_t count) {
LLDB_RECORD_METHOD(void, SBBreakpointName, SetIgnoreCount, (uint32_t), count);
LLDB_INSTRUMENT_VA(this, count);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@ -290,7 +281,7 @@ void SBBreakpointName::SetIgnoreCount(uint32_t count) {
}
uint32_t SBBreakpointName::GetIgnoreCount() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointName, GetIgnoreCount);
LLDB_INSTRUMENT_VA(this);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@ -303,8 +294,7 @@ uint32_t SBBreakpointName::GetIgnoreCount() const {
}
void SBBreakpointName::SetCondition(const char *condition) {
LLDB_RECORD_METHOD(void, SBBreakpointName, SetCondition, (const char *),
condition);
LLDB_INSTRUMENT_VA(this, condition);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@ -318,7 +308,7 @@ void SBBreakpointName::SetCondition(const char *condition) {
}
const char *SBBreakpointName::GetCondition() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBBreakpointName, GetCondition);
LLDB_INSTRUMENT_VA(this);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@ -331,8 +321,7 @@ const char *SBBreakpointName::GetCondition() {
}
void SBBreakpointName::SetAutoContinue(bool auto_continue) {
LLDB_RECORD_METHOD(void, SBBreakpointName, SetAutoContinue, (bool),
auto_continue);
LLDB_INSTRUMENT_VA(this, auto_continue);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@ -346,7 +335,7 @@ void SBBreakpointName::SetAutoContinue(bool auto_continue) {
}
bool SBBreakpointName::GetAutoContinue() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAutoContinue);
LLDB_INSTRUMENT_VA(this);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@ -359,7 +348,7 @@ bool SBBreakpointName::GetAutoContinue() {
}
void SBBreakpointName::SetThreadID(tid_t tid) {
LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadID, (lldb::tid_t), tid);
LLDB_INSTRUMENT_VA(this, tid);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@ -373,7 +362,7 @@ void SBBreakpointName::SetThreadID(tid_t tid) {
}
tid_t SBBreakpointName::GetThreadID() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBBreakpointName, GetThreadID);
LLDB_INSTRUMENT_VA(this);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@ -386,7 +375,7 @@ tid_t SBBreakpointName::GetThreadID() {
}
void SBBreakpointName::SetThreadIndex(uint32_t index) {
LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadIndex, (uint32_t), index);
LLDB_INSTRUMENT_VA(this, index);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@ -400,7 +389,7 @@ void SBBreakpointName::SetThreadIndex(uint32_t index) {
}
uint32_t SBBreakpointName::GetThreadIndex() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointName, GetThreadIndex);
LLDB_INSTRUMENT_VA(this);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@ -413,8 +402,7 @@ uint32_t SBBreakpointName::GetThreadIndex() const {
}
void SBBreakpointName::SetThreadName(const char *thread_name) {
LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadName, (const char *),
thread_name);
LLDB_INSTRUMENT_VA(this, thread_name);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@ -428,8 +416,7 @@ void SBBreakpointName::SetThreadName(const char *thread_name) {
}
const char *SBBreakpointName::GetThreadName() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName,
GetThreadName);
LLDB_INSTRUMENT_VA(this);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@ -442,8 +429,7 @@ const char *SBBreakpointName::GetThreadName() const {
}
void SBBreakpointName::SetQueueName(const char *queue_name) {
LLDB_RECORD_METHOD(void, SBBreakpointName, SetQueueName, (const char *),
queue_name);
LLDB_INSTRUMENT_VA(this, queue_name);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@ -457,8 +443,7 @@ void SBBreakpointName::SetQueueName(const char *queue_name) {
}
const char *SBBreakpointName::GetQueueName() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName,
GetQueueName);
LLDB_INSTRUMENT_VA(this);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@ -471,8 +456,7 @@ const char *SBBreakpointName::GetQueueName() const {
}
void SBBreakpointName::SetCommandLineCommands(SBStringList &commands) {
LLDB_RECORD_METHOD(void, SBBreakpointName, SetCommandLineCommands,
(lldb::SBStringList &), commands);
LLDB_INSTRUMENT_VA(this, commands);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@ -491,8 +475,7 @@ void SBBreakpointName::SetCommandLineCommands(SBStringList &commands) {
}
bool SBBreakpointName::GetCommandLineCommands(SBStringList &commands) {
LLDB_RECORD_METHOD(bool, SBBreakpointName, GetCommandLineCommands,
(lldb::SBStringList &), commands);
LLDB_INSTRUMENT_VA(this, commands);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@ -507,8 +490,7 @@ bool SBBreakpointName::GetCommandLineCommands(SBStringList &commands) {
}
const char *SBBreakpointName::GetHelpString() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName,
GetHelpString);
LLDB_INSTRUMENT_VA(this);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@ -518,8 +500,7 @@ const char *SBBreakpointName::GetHelpString() const {
}
void SBBreakpointName::SetHelpString(const char *help_string) {
LLDB_RECORD_METHOD(void, SBBreakpointName, SetHelpString, (const char *),
help_string);
LLDB_INSTRUMENT_VA(this, help_string);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@ -532,8 +513,7 @@ void SBBreakpointName::SetHelpString(const char *help_string) {
}
bool SBBreakpointName::GetDescription(SBStream &s) {
LLDB_RECORD_METHOD(bool, SBBreakpointName, GetDescription, (lldb::SBStream &),
s);
LLDB_INSTRUMENT_VA(this, s);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@ -550,8 +530,7 @@ bool SBBreakpointName::GetDescription(SBStream &s) {
void SBBreakpointName::SetCallback(SBBreakpointHitCallback callback,
void *baton) {
LLDB_RECORD_METHOD(void, SBBreakpointName, SetCallback,
(lldb::SBBreakpointHitCallback, void *), callback, baton);
LLDB_INSTRUMENT_VA(this, callback, baton);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@ -569,8 +548,7 @@ void SBBreakpointName::SetCallback(SBBreakpointHitCallback callback,
void SBBreakpointName::SetScriptCallbackFunction(
const char *callback_function_name) {
LLDB_RECORD_METHOD(void, SBBreakpointName, SetScriptCallbackFunction,
(const char *), callback_function_name);
LLDB_INSTRUMENT_VA(this, callback_function_name);
SBStructuredData empty_args;
SetScriptCallbackFunction(callback_function_name, empty_args);
}
@ -578,9 +556,7 @@ LLDB_RECORD_METHOD(void, SBBreakpointName, SetScriptCallbackFunction,
SBError SBBreakpointName::SetScriptCallbackFunction(
const char *callback_function_name,
SBStructuredData &extra_args) {
LLDB_RECORD_METHOD(SBError, SBBreakpointName, SetScriptCallbackFunction,
(const char *, SBStructuredData &),
callback_function_name, extra_args);
LLDB_INSTRUMENT_VA(this, callback_function_name, extra_args);
SBError sb_error;
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name) {
@ -606,8 +582,7 @@ SBError SBBreakpointName::SetScriptCallbackFunction(
SBError
SBBreakpointName::SetScriptCallbackBody(const char *callback_body_text) {
LLDB_RECORD_METHOD(lldb::SBError, SBBreakpointName, SetScriptCallbackBody,
(const char *), callback_body_text);
LLDB_INSTRUMENT_VA(this, callback_body_text);
SBError sb_error;
BreakpointName *bp_name = GetBreakpointName();
@ -631,7 +606,7 @@ SBBreakpointName::SetScriptCallbackBody(const char *callback_body_text) {
}
bool SBBreakpointName::GetAllowList() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, GetAllowList);
LLDB_INSTRUMENT_VA(this);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@ -640,8 +615,7 @@ bool SBBreakpointName::GetAllowList() const {
}
void SBBreakpointName::SetAllowList(bool value) {
LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowList, (bool), value);
LLDB_INSTRUMENT_VA(this, value);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@ -650,7 +624,7 @@ void SBBreakpointName::SetAllowList(bool value) {
}
bool SBBreakpointName::GetAllowDelete() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAllowDelete);
LLDB_INSTRUMENT_VA(this);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@ -659,8 +633,7 @@ bool SBBreakpointName::GetAllowDelete() {
}
void SBBreakpointName::SetAllowDelete(bool value) {
LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowDelete, (bool), value);
LLDB_INSTRUMENT_VA(this, value);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@ -669,7 +642,7 @@ void SBBreakpointName::SetAllowDelete(bool value) {
}
bool SBBreakpointName::GetAllowDisable() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAllowDisable);
LLDB_INSTRUMENT_VA(this);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
@ -678,7 +651,7 @@ bool SBBreakpointName::GetAllowDisable() {
}
void SBBreakpointName::SetAllowDisable(bool value) {
LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowDisable, (bool), value);
LLDB_INSTRUMENT_VA(this, value);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)

24
lldb/source/API/SBBreakpointOptionCommon.cpp
View file

@ -26,6 +26,7 @@
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadSpec.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/Log.h"
#include "lldb/Utility/Stream.h"
@ -38,19 +39,18 @@
using namespace lldb;
using namespace lldb_private;
SBBreakpointCallbackBaton::SBBreakpointCallbackBaton(SBBreakpointHitCallback
callback,
void *baton)
: TypedBaton(std::make_unique<CallbackData>()) {
getItem()->callback = callback;
getItem()->callback_baton = baton;
}
SBBreakpointCallbackBaton::SBBreakpointCallbackBaton(
SBBreakpointHitCallback callback, void *baton)
: TypedBaton(std::make_unique<CallbackData>()) {
LLDB_INSTRUMENT_VA(this, callback, baton);
getItem()->callback = callback;
getItem()->callback_baton = baton;
}
bool SBBreakpointCallbackBaton::PrivateBreakpointHitCallback(void *baton,
StoppointCallbackContext *ctx,
lldb::user_id_t break_id,
lldb::user_id_t break_loc_id)
{
bool SBBreakpointCallbackBaton::PrivateBreakpointHitCallback(
void *baton, StoppointCallbackContext *ctx, lldb::user_id_t break_id,
lldb::user_id_t break_loc_id) {
LLDB_INSTRUMENT_VA(baton, ctx, break_id, break_loc_id);
ExecutionContext exe_ctx(ctx->exe_ctx_ref);
BreakpointSP bp_sp(
exe_ctx.GetTargetRef().GetBreakpointList().FindBreakpointByID(break_id));

52
lldb/source/API/SBBroadcaster.cpp
View file

@ -6,8 +6,8 @@
//
//===----------------------------------------------------------------------===//
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/Utility/Broadcaster.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/API/SBBroadcaster.h"
#include "lldb/API/SBEvent.h"
@ -16,13 +16,11 @@
using namespace lldb;
using namespace lldb_private;
SBBroadcaster::SBBroadcaster() {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBroadcaster);
}
SBBroadcaster::SBBroadcaster() { LLDB_INSTRUMENT_VA(this); }
SBBroadcaster::SBBroadcaster(const char *name)
: m_opaque_sp(new Broadcaster(nullptr, name)), m_opaque_ptr(nullptr) {
LLDB_RECORD_CONSTRUCTOR(SBBroadcaster, (const char *), name);
LLDB_INSTRUMENT_VA(this, name);
m_opaque_ptr = m_opaque_sp.get();
}
@ -32,13 +30,11 @@ SBBroadcaster::SBBroadcaster(lldb_private::Broadcaster *broadcaster, bool owns)
SBBroadcaster::SBBroadcaster(const SBBroadcaster &rhs)
: m_opaque_sp(rhs.m_opaque_sp), m_opaque_ptr(rhs.m_opaque_ptr) {
LLDB_RECORD_CONSTRUCTOR(SBBroadcaster, (const lldb::SBBroadcaster &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
}
const SBBroadcaster &SBBroadcaster::operator=(const SBBroadcaster &rhs) {
LLDB_RECORD_METHOD(const lldb::SBBroadcaster &,
SBBroadcaster, operator=,(const lldb::SBBroadcaster &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
@ -50,8 +46,7 @@ const SBBroadcaster &SBBroadcaster::operator=(const SBBroadcaster &rhs) {
SBBroadcaster::~SBBroadcaster() { reset(nullptr, false); }
void SBBroadcaster::BroadcastEventByType(uint32_t event_type, bool unique) {
LLDB_RECORD_METHOD(void, SBBroadcaster, BroadcastEventByType,
(uint32_t, bool), event_type, unique);
LLDB_INSTRUMENT_VA(this, event_type, unique);
if (m_opaque_ptr == nullptr)
return;
@ -63,8 +58,7 @@ void SBBroadcaster::BroadcastEventByType(uint32_t event_type, bool unique) {
}
void SBBroadcaster::BroadcastEvent(const SBEvent &event, bool unique) {
LLDB_RECORD_METHOD(void, SBBroadcaster, BroadcastEvent,
(const lldb::SBEvent &, bool), event, unique);
LLDB_INSTRUMENT_VA(this, event, unique);
if (m_opaque_ptr == nullptr)
return;
@ -78,9 +72,7 @@ void SBBroadcaster::BroadcastEvent(const SBEvent &event, bool unique) {
void SBBroadcaster::AddInitialEventsToListener(const SBListener &listener,
uint32_t requested_events) {
LLDB_RECORD_METHOD(void, SBBroadcaster, AddInitialEventsToListener,
(const lldb::SBListener &, uint32_t), listener,
requested_events);
LLDB_INSTRUMENT_VA(this, listener, requested_events);
if (m_opaque_ptr)
m_opaque_ptr->AddInitialEventsToListener(listener.m_opaque_sp,
@ -89,9 +81,7 @@ void SBBroadcaster::AddInitialEventsToListener(const SBListener &listener,
uint32_t SBBroadcaster::AddListener(const SBListener &listener,
uint32_t event_mask) {
LLDB_RECORD_METHOD(uint32_t, SBBroadcaster, AddListener,
(const lldb::SBListener &, uint32_t), listener,
event_mask);
LLDB_INSTRUMENT_VA(this, listener, event_mask);
if (m_opaque_ptr)
return m_opaque_ptr->AddListener(listener.m_opaque_sp, event_mask);
@ -99,7 +89,7 @@ uint32_t SBBroadcaster::AddListener(const SBListener &listener,
}
const char *SBBroadcaster::GetName() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBroadcaster, GetName);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr)
return m_opaque_ptr->GetBroadcasterName().GetCString();
@ -107,8 +97,7 @@ const char *SBBroadcaster::GetName() const {
}
bool SBBroadcaster::EventTypeHasListeners(uint32_t event_type) {
LLDB_RECORD_METHOD(bool, SBBroadcaster, EventTypeHasListeners, (uint32_t),
event_type);
LLDB_INSTRUMENT_VA(this, event_type);
if (m_opaque_ptr)
return m_opaque_ptr->EventTypeHasListeners(event_type);
@ -117,9 +106,7 @@ bool SBBroadcaster::EventTypeHasListeners(uint32_t event_type) {
bool SBBroadcaster::RemoveListener(const SBListener &listener,
uint32_t event_mask) {
LLDB_RECORD_METHOD(bool, SBBroadcaster, RemoveListener,
(const lldb::SBListener &, uint32_t), listener,
event_mask);
LLDB_INSTRUMENT_VA(this, listener, event_mask);
if (m_opaque_ptr)
return m_opaque_ptr->RemoveListener(listener.m_opaque_sp, event_mask);
@ -137,39 +124,36 @@ void SBBroadcaster::reset(Broadcaster *broadcaster, bool owns) {
}
bool SBBroadcaster::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBroadcaster, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBBroadcaster::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBroadcaster, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_opaque_ptr != nullptr;
}
void SBBroadcaster::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBBroadcaster, Clear);
LLDB_INSTRUMENT_VA(this);
m_opaque_sp.reset();
m_opaque_ptr = nullptr;
}
bool SBBroadcaster::operator==(const SBBroadcaster &rhs) const {
LLDB_RECORD_METHOD_CONST(
bool, SBBroadcaster, operator==,(const lldb::SBBroadcaster &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
return m_opaque_ptr == rhs.m_opaque_ptr;
}
bool SBBroadcaster::operator!=(const SBBroadcaster &rhs) const {
LLDB_RECORD_METHOD_CONST(
bool, SBBroadcaster, operator!=,(const lldb::SBBroadcaster &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
return m_opaque_ptr != rhs.m_opaque_ptr;
}
bool SBBroadcaster::operator<(const SBBroadcaster &rhs) const {
LLDB_RECORD_METHOD_CONST(
bool, SBBroadcaster, operator<,(const lldb::SBBroadcaster &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
return m_opaque_ptr < rhs.m_opaque_ptr;
}

183
lldb/source/API/SBCommandInterpreter.cpp
View file

@ -8,11 +8,11 @@
#include "lldb/lldb-types.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/CommandObjectMultiword.h"
#include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Target/Target.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/Listener.h"
#include "lldb/API/SBBroadcaster.h"
@ -78,71 +78,62 @@ protected:
SBCommandInterpreter::SBCommandInterpreter(CommandInterpreter *interpreter)
: m_opaque_ptr(interpreter) {
LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreter,
(lldb_private::CommandInterpreter *), interpreter);
LLDB_INSTRUMENT_VA(this, interpreter);
}
SBCommandInterpreter::SBCommandInterpreter(const SBCommandInterpreter &rhs)
: m_opaque_ptr(rhs.m_opaque_ptr) {
LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreter,
(const lldb::SBCommandInterpreter &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
}
SBCommandInterpreter::~SBCommandInterpreter() = default;
const SBCommandInterpreter &SBCommandInterpreter::
operator=(const SBCommandInterpreter &rhs) {
LLDB_RECORD_METHOD(
const lldb::SBCommandInterpreter &,
SBCommandInterpreter, operator=,(const lldb::SBCommandInterpreter &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_ptr = rhs.m_opaque_ptr;
return *this;
}
bool SBCommandInterpreter::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBCommandInterpreter::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_opaque_ptr != nullptr;
}
bool SBCommandInterpreter::CommandExists(const char *cmd) {
LLDB_RECORD_METHOD(bool, SBCommandInterpreter, CommandExists, (const char *),
cmd);
LLDB_INSTRUMENT_VA(this, cmd);
return (((cmd != nullptr) && IsValid()) ? m_opaque_ptr->CommandExists(cmd)
: false);
}
bool SBCommandInterpreter::AliasExists(const char *cmd) {
LLDB_RECORD_METHOD(bool, SBCommandInterpreter, AliasExists, (const char *),
cmd);
LLDB_INSTRUMENT_VA(this, cmd);
return (((cmd != nullptr) && IsValid()) ? m_opaque_ptr->AliasExists(cmd)
: false);
}
bool SBCommandInterpreter::IsActive() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, IsActive);
LLDB_INSTRUMENT_VA(this);
return (IsValid() ? m_opaque_ptr->IsActive() : false);
}
bool SBCommandInterpreter::WasInterrupted() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, WasInterrupted);
LLDB_INSTRUMENT_VA(this);
return (IsValid() ? m_opaque_ptr->WasInterrupted() : false);
}
const char *SBCommandInterpreter::GetIOHandlerControlSequence(char ch) {
LLDB_RECORD_METHOD(const char *, SBCommandInterpreter,
GetIOHandlerControlSequence, (char), ch);
LLDB_INSTRUMENT_VA(this, ch);
return (IsValid()
? m_opaque_ptr->GetDebugger()
@ -155,9 +146,7 @@ lldb::ReturnStatus
SBCommandInterpreter::HandleCommand(const char *command_line,
SBCommandReturnObject &result,
bool add_to_history) {
LLDB_RECORD_METHOD(lldb::ReturnStatus, SBCommandInterpreter, HandleCommand,
(const char *, lldb::SBCommandReturnObject &, bool),
command_line, result, add_to_history);
LLDB_INSTRUMENT_VA(this, command_line, result, add_to_history);
SBExecutionContext sb_exe_ctx;
return HandleCommand(command_line, sb_exe_ctx, result, add_to_history);
@ -166,10 +155,8 @@ SBCommandInterpreter::HandleCommand(const char *command_line,
lldb::ReturnStatus SBCommandInterpreter::HandleCommand(
const char *command_line, SBExecutionContext &override_context,
SBCommandReturnObject &result, bool add_to_history) {
LLDB_RECORD_METHOD(lldb::ReturnStatus, SBCommandInterpreter, HandleCommand,
(const char *, lldb::SBExecutionContext &,
lldb::SBCommandReturnObject &, bool),
command_line, override_context, result, add_to_history);
LLDB_INSTRUMENT_VA(this, command_line, override_context, result,
add_to_history);
result.Clear();
if (command_line && IsValid()) {
@ -194,11 +181,7 @@ void SBCommandInterpreter::HandleCommandsFromFile(
lldb::SBFileSpec &file, lldb::SBExecutionContext &override_context,
lldb::SBCommandInterpreterRunOptions &options,
lldb::SBCommandReturnObject result) {
LLDB_RECORD_METHOD(void, SBCommandInterpreter, HandleCommandsFromFile,
(lldb::SBFileSpec &, lldb::SBExecutionContext &,
lldb::SBCommandInterpreterRunOptions &,
lldb::SBCommandReturnObject),
file, override_context, options, result);
LLDB_INSTRUMENT_VA(this, file, override_context, options, result);
if (!IsValid()) {
result->AppendError("SBCommandInterpreter is not valid.");
@ -225,10 +208,7 @@ void SBCommandInterpreter::HandleCommandsFromFile(
int SBCommandInterpreter::HandleCompletion(
const char *current_line, const char *cursor, const char *last_char,
int match_start_point, int max_return_elements, SBStringList &matches) {
LLDB_RECORD_METHOD(int, SBCommandInterpreter, HandleCompletion,
(const char *, const char *, const char *, int, int,
lldb::SBStringList &),
current_line, cursor, last_char, match_start_point,
LLDB_INSTRUMENT_VA(this, current_line, cursor, last_char, match_start_point,
max_return_elements, matches);
SBStringList dummy_descriptions;
@ -241,11 +221,7 @@ int SBCommandInterpreter::HandleCompletionWithDescriptions(
const char *current_line, const char *cursor, const char *last_char,
int match_start_point, int max_return_elements, SBStringList &matches,
SBStringList &descriptions) {
LLDB_RECORD_METHOD(int, SBCommandInterpreter,
HandleCompletionWithDescriptions,
(const char *, const char *, const char *, int, int,
lldb::SBStringList &, lldb::SBStringList &),
current_line, cursor, last_char, match_start_point,
LLDB_INSTRUMENT_VA(this, current_line, cursor, last_char, match_start_point,
max_return_elements, matches, descriptions);
// Sanity check the arguments that are passed in: cursor & last_char have to
@ -311,11 +287,7 @@ int SBCommandInterpreter::HandleCompletionWithDescriptions(
const char *current_line, uint32_t cursor_pos, int match_start_point,
int max_return_elements, SBStringList &matches,
SBStringList &descriptions) {
LLDB_RECORD_METHOD(int, SBCommandInterpreter,
HandleCompletionWithDescriptions,
(const char *, uint32_t, int, int, lldb::SBStringList &,
lldb::SBStringList &),
current_line, cursor_pos, match_start_point,
LLDB_INSTRUMENT_VA(this, current_line, cursor_pos, match_start_point,
max_return_elements, matches, descriptions);
const char *cursor = current_line + cursor_pos;
@ -330,9 +302,7 @@ int SBCommandInterpreter::HandleCompletion(const char *current_line,
int match_start_point,
int max_return_elements,
lldb::SBStringList &matches) {
LLDB_RECORD_METHOD(int, SBCommandInterpreter, HandleCompletion,
(const char *, uint32_t, int, int, lldb::SBStringList &),
current_line, cursor_pos, match_start_point,
LLDB_INSTRUMENT_VA(this, current_line, cursor_pos, match_start_point,
max_return_elements, matches);
const char *cursor = current_line + cursor_pos;
@ -342,25 +312,25 @@ int SBCommandInterpreter::HandleCompletion(const char *current_line,
}
bool SBCommandInterpreter::HasCommands() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasCommands);
LLDB_INSTRUMENT_VA(this);
return (IsValid() ? m_opaque_ptr->HasCommands() : false);
}
bool SBCommandInterpreter::HasAliases() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasAliases);
LLDB_INSTRUMENT_VA(this);
return (IsValid() ? m_opaque_ptr->HasAliases() : false);
}
bool SBCommandInterpreter::HasAliasOptions() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasAliasOptions);
LLDB_INSTRUMENT_VA(this);
return (IsValid() ? m_opaque_ptr->HasAliasOptions() : false);
}
SBProcess SBCommandInterpreter::GetProcess() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBCommandInterpreter, GetProcess);
LLDB_INSTRUMENT_VA(this);
SBProcess sb_process;
ProcessSP process_sp;
@ -377,8 +347,7 @@ SBProcess SBCommandInterpreter::GetProcess() {
}
SBDebugger SBCommandInterpreter::GetDebugger() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBDebugger, SBCommandInterpreter,
GetDebugger);
LLDB_INSTRUMENT_VA(this);
SBDebugger sb_debugger;
if (IsValid())
@ -388,28 +357,27 @@ SBDebugger SBCommandInterpreter::GetDebugger() {
}
bool SBCommandInterpreter::GetPromptOnQuit() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, GetPromptOnQuit);
LLDB_INSTRUMENT_VA(this);
return (IsValid() ? m_opaque_ptr->GetPromptOnQuit() : false);
}
void SBCommandInterpreter::SetPromptOnQuit(bool b) {
LLDB_RECORD_METHOD(void, SBCommandInterpreter, SetPromptOnQuit, (bool), b);
LLDB_INSTRUMENT_VA(this, b);
if (IsValid())
m_opaque_ptr->SetPromptOnQuit(b);
}
void SBCommandInterpreter::AllowExitCodeOnQuit(bool allow) {
LLDB_RECORD_METHOD(void, SBCommandInterpreter, AllowExitCodeOnQuit, (bool),
allow);
LLDB_INSTRUMENT_VA(this, allow);
if (m_opaque_ptr)
m_opaque_ptr->AllowExitCodeOnQuit(allow);
}
bool SBCommandInterpreter::HasCustomQuitExitCode() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasCustomQuitExitCode);
LLDB_INSTRUMENT_VA(this);
bool exited = false;
if (m_opaque_ptr)
@ -418,7 +386,7 @@ bool SBCommandInterpreter::HasCustomQuitExitCode() {
}
int SBCommandInterpreter::GetQuitStatus() {
LLDB_RECORD_METHOD_NO_ARGS(int, SBCommandInterpreter, GetQuitStatus);
LLDB_INSTRUMENT_VA(this);
bool exited = false;
return (m_opaque_ptr ? m_opaque_ptr->GetQuitExitCode(exited) : 0);
@ -426,9 +394,7 @@ int SBCommandInterpreter::GetQuitStatus() {
void SBCommandInterpreter::ResolveCommand(const char *command_line,
SBCommandReturnObject &result) {
LLDB_RECORD_METHOD(void, SBCommandInterpreter, ResolveCommand,
(const char *, lldb::SBCommandReturnObject &),
command_line, result);
LLDB_INSTRUMENT_VA(this, command_line, result);
result.Clear();
if (command_line && IsValid()) {
@ -453,8 +419,7 @@ void SBCommandInterpreter::reset(
void SBCommandInterpreter::SourceInitFileInHomeDirectory(
SBCommandReturnObject &result) {
LLDB_RECORD_METHOD(void, SBCommandInterpreter, SourceInitFileInHomeDirectory,
(lldb::SBCommandReturnObject &), result);
LLDB_INSTRUMENT_VA(this, result);
result.Clear();
if (IsValid()) {
@ -470,8 +435,7 @@ void SBCommandInterpreter::SourceInitFileInHomeDirectory(
void SBCommandInterpreter::SourceInitFileInHomeDirectory(
SBCommandReturnObject &result, bool is_repl) {
LLDB_RECORD_METHOD(void, SBCommandInterpreter, SourceInitFileInHomeDirectory,
(lldb::SBCommandReturnObject &, bool), result, is_repl);
LLDB_INSTRUMENT_VA(this, result, is_repl);
result.Clear();
if (IsValid()) {
@ -487,9 +451,7 @@ void SBCommandInterpreter::SourceInitFileInHomeDirectory(
void SBCommandInterpreter::SourceInitFileInCurrentWorkingDirectory(
SBCommandReturnObject &result) {
LLDB_RECORD_METHOD(void, SBCommandInterpreter,
SourceInitFileInCurrentWorkingDirectory,
(lldb::SBCommandReturnObject &), result);
LLDB_INSTRUMENT_VA(this, result);
result.Clear();
if (IsValid()) {
@ -504,9 +466,7 @@ void SBCommandInterpreter::SourceInitFileInCurrentWorkingDirectory(
}
SBBroadcaster SBCommandInterpreter::GetBroadcaster() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBroadcaster, SBCommandInterpreter,
GetBroadcaster);
LLDB_INSTRUMENT_VA(this);
SBBroadcaster broadcaster(m_opaque_ptr, false);
@ -514,35 +474,28 @@ SBBroadcaster SBCommandInterpreter::GetBroadcaster() {
}
const char *SBCommandInterpreter::GetBroadcasterClass() {
LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBCommandInterpreter,
GetBroadcasterClass);
LLDB_INSTRUMENT();
return CommandInterpreter::GetStaticBroadcasterClass().AsCString();
}
const char *SBCommandInterpreter::GetArgumentTypeAsCString(
const lldb::CommandArgumentType arg_type) {
LLDB_RECORD_STATIC_METHOD(const char *, SBCommandInterpreter,
GetArgumentTypeAsCString,
(const lldb::CommandArgumentType), arg_type);
LLDB_INSTRUMENT_VA(arg_type);
return CommandObject::GetArgumentTypeAsCString(arg_type);
}
const char *SBCommandInterpreter::GetArgumentDescriptionAsCString(
const lldb::CommandArgumentType arg_type) {
LLDB_RECORD_STATIC_METHOD(const char *, SBCommandInterpreter,
GetArgumentDescriptionAsCString,
(const lldb::CommandArgumentType), arg_type);
LLDB_INSTRUMENT_VA(arg_type);
return CommandObject::GetArgumentDescriptionAsCString(arg_type);
}
bool SBCommandInterpreter::EventIsCommandInterpreterEvent(
const lldb::SBEvent &event) {
LLDB_RECORD_STATIC_METHOD(bool, SBCommandInterpreter,
EventIsCommandInterpreterEvent,
(const lldb::SBEvent &), event);
LLDB_INSTRUMENT_VA(event);
return event.GetBroadcasterClass() ==
SBCommandInterpreter::GetBroadcasterClass();
@ -551,9 +504,7 @@ bool SBCommandInterpreter::EventIsCommandInterpreterEvent(
bool SBCommandInterpreter::SetCommandOverrideCallback(
const char *command_name, lldb::CommandOverrideCallback callback,
void *baton) {
LLDB_RECORD_METHOD(bool, SBCommandInterpreter, SetCommandOverrideCallback,
(const char *, lldb::CommandOverrideCallback, void *),
command_name, callback, baton);
LLDB_INSTRUMENT_VA(this, command_name, callback, baton);
if (command_name && command_name[0] && IsValid()) {
llvm::StringRef command_name_str = command_name;
@ -570,8 +521,7 @@ bool SBCommandInterpreter::SetCommandOverrideCallback(
lldb::SBCommand SBCommandInterpreter::AddMultiwordCommand(const char *name,
const char *help) {
LLDB_RECORD_METHOD(lldb::SBCommand, SBCommandInterpreter, AddMultiwordCommand,
(const char *, const char *), name, help);
LLDB_INSTRUMENT_VA(this, name, help);
lldb::CommandObjectSP new_command_sp(
new CommandObjectMultiword(*m_opaque_ptr, name, help));
@ -584,10 +534,7 @@ lldb::SBCommand SBCommandInterpreter::AddMultiwordCommand(const char *name,
lldb::SBCommand SBCommandInterpreter::AddCommand(
const char *name, lldb::SBCommandPluginInterface *impl, const char *help) {
LLDB_RECORD_METHOD(
lldb::SBCommand, SBCommandInterpreter, AddCommand,
(const char *, lldb::SBCommandPluginInterface *, const char *), name,
impl, help);
LLDB_INSTRUMENT_VA(this, name, impl, help);
return AddCommand(name, impl, help, /*syntax=*/nullptr,
/*auto_repeat_command=*/"");
@ -597,20 +544,14 @@ lldb::SBCommand
SBCommandInterpreter::AddCommand(const char *name,
lldb::SBCommandPluginInterface *impl,
const char *help, const char *syntax) {
LLDB_RECORD_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand,
(const char *, lldb::SBCommandPluginInterface *,
const char *, const char *),
name, impl, help, syntax);
LLDB_INSTRUMENT_VA(this, name, impl, help, syntax);
return AddCommand(name, impl, help, syntax, /*auto_repeat_command=*/"");
}
lldb::SBCommand SBCommandInterpreter::AddCommand(
const char *name, lldb::SBCommandPluginInterface *impl, const char *help,
const char *syntax, const char *auto_repeat_command) {
LLDB_RECORD_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand,
(const char *, lldb::SBCommandPluginInterface *,
const char *, const char *, const char *),
name, impl, help, syntax, auto_repeat_command);
LLDB_INSTRUMENT_VA(this, name, impl, help, syntax, auto_repeat_command);
lldb::CommandObjectSP new_command_sp;
new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>(
@ -623,49 +564,49 @@ lldb::SBCommand SBCommandInterpreter::AddCommand(
return lldb::SBCommand();
}
SBCommand::SBCommand() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommand); }
SBCommand::SBCommand() { LLDB_INSTRUMENT_VA(this); }
SBCommand::SBCommand(lldb::CommandObjectSP cmd_sp) : m_opaque_sp(cmd_sp) {}
bool SBCommand::IsValid() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommand, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBCommand::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommand, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp.get() != nullptr;
}
const char *SBCommand::GetName() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetName);
LLDB_INSTRUMENT_VA(this);
return (IsValid() ? ConstString(m_opaque_sp->GetCommandName()).AsCString() : nullptr);
}
const char *SBCommand::GetHelp() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetHelp);
LLDB_INSTRUMENT_VA(this);
return (IsValid() ? ConstString(m_opaque_sp->GetHelp()).AsCString()
: nullptr);
}
const char *SBCommand::GetHelpLong() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetHelpLong);
LLDB_INSTRUMENT_VA(this);
return (IsValid() ? ConstString(m_opaque_sp->GetHelpLong()).AsCString()
: nullptr);
}
void SBCommand::SetHelp(const char *help) {
LLDB_RECORD_METHOD(void, SBCommand, SetHelp, (const char *), help);
LLDB_INSTRUMENT_VA(this, help);
if (IsValid())
m_opaque_sp->SetHelp(help);
}
void SBCommand::SetHelpLong(const char *help) {
LLDB_RECORD_METHOD(void, SBCommand, SetHelpLong, (const char *), help);
LLDB_INSTRUMENT_VA(this, help);
if (IsValid())
m_opaque_sp->SetHelpLong(help);
@ -673,8 +614,7 @@ void SBCommand::SetHelpLong(const char *help) {
lldb::SBCommand SBCommand::AddMultiwordCommand(const char *name,
const char *help) {
LLDB_RECORD_METHOD(lldb::SBCommand, SBCommand, AddMultiwordCommand,
(const char *, const char *), name, help);
LLDB_INSTRUMENT_VA(this, name, help);
if (!IsValid())
return lldb::SBCommand();
@ -692,10 +632,7 @@ lldb::SBCommand SBCommand::AddMultiwordCommand(const char *name,
lldb::SBCommand SBCommand::AddCommand(const char *name,
lldb::SBCommandPluginInterface *impl,
const char *help) {
LLDB_RECORD_METHOD(
lldb::SBCommand, SBCommand, AddCommand,
(const char *, lldb::SBCommandPluginInterface *, const char *), name,
impl, help);
LLDB_INSTRUMENT_VA(this, name, impl, help);
return AddCommand(name, impl, help, /*syntax=*/nullptr,
/*auto_repeat_command=*/"");
}
@ -703,10 +640,7 @@ lldb::SBCommand SBCommand::AddCommand(const char *name,
lldb::SBCommand SBCommand::AddCommand(const char *name,
lldb::SBCommandPluginInterface *impl,
const char *help, const char *syntax) {
LLDB_RECORD_METHOD(lldb::SBCommand, SBCommand, AddCommand,
(const char *, lldb::SBCommandPluginInterface *,
const char *, const char *),
name, impl, help, syntax);
LLDB_INSTRUMENT_VA(this, name, impl, help, syntax);
return AddCommand(name, impl, help, syntax, /*auto_repeat_command=*/"");
}
@ -714,10 +648,7 @@ lldb::SBCommand SBCommand::AddCommand(const char *name,
lldb::SBCommandPluginInterface *impl,
const char *help, const char *syntax,
const char *auto_repeat_command) {
LLDB_RECORD_METHOD(lldb::SBCommand, SBCommand, AddCommand,
(const char *, lldb::SBCommandPluginInterface *,
const char *, const char *, const char *),
name, impl, help, syntax, auto_repeat_command);
LLDB_INSTRUMENT_VA(this, name, impl, help, syntax, auto_repeat_command);
if (!IsValid())
return lldb::SBCommand();
@ -733,13 +664,13 @@ lldb::SBCommand SBCommand::AddCommand(const char *name,
}
uint32_t SBCommand::GetFlags() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBCommand, GetFlags);
LLDB_INSTRUMENT_VA(this);
return (IsValid() ? m_opaque_sp->GetFlags().Get() : 0);
}
void SBCommand::SetFlags(uint32_t flags) {
LLDB_RECORD_METHOD(void, SBCommand, SetFlags, (uint32_t), flags);
LLDB_INSTRUMENT_VA(this, flags);
if (IsValid())
m_opaque_sp->GetFlags().Set(flags);

86
lldb/source/API/SBCommandInterpreterRunOptions.cpp
View file

@ -8,7 +8,7 @@
#include "lldb/lldb-types.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/API/SBCommandInterpreterRunOptions.h"
#include "lldb/Interpreter/CommandInterpreter.h"
@ -19,15 +19,14 @@ using namespace lldb;
using namespace lldb_private;
SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions() {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommandInterpreterRunOptions);
LLDB_INSTRUMENT_VA(this);
m_opaque_up = std::make_unique<CommandInterpreterRunOptions>();
}
SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions(
const SBCommandInterpreterRunOptions &rhs) {
LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreterRunOptions,
(const lldb::SBCommandInterpreterRunOptions &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_up = std::make_unique<CommandInterpreterRunOptions>(rhs.ref());
}
@ -36,9 +35,7 @@ SBCommandInterpreterRunOptions::~SBCommandInterpreterRunOptions() = default;
SBCommandInterpreterRunOptions &SBCommandInterpreterRunOptions::operator=(
const SBCommandInterpreterRunOptions &rhs) {
LLDB_RECORD_METHOD(lldb::SBCommandInterpreterRunOptions &,
SBCommandInterpreterRunOptions, operator=,
(const lldb::SBCommandInterpreterRunOptions &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this == &rhs)
return *this;
@ -47,142 +44,122 @@ SBCommandInterpreterRunOptions &SBCommandInterpreterRunOptions::operator=(
}
bool SBCommandInterpreterRunOptions::GetStopOnContinue() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
GetStopOnContinue);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetStopOnContinue();
}
void SBCommandInterpreterRunOptions::SetStopOnContinue(bool stop_on_continue) {
LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnContinue,
(bool), stop_on_continue);
LLDB_INSTRUMENT_VA(this, stop_on_continue);
m_opaque_up->SetStopOnContinue(stop_on_continue);
}
bool SBCommandInterpreterRunOptions::GetStopOnError() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
GetStopOnError);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetStopOnError();
}
void SBCommandInterpreterRunOptions::SetStopOnError(bool stop_on_error) {
LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnError,
(bool), stop_on_error);
LLDB_INSTRUMENT_VA(this, stop_on_error);
m_opaque_up->SetStopOnError(stop_on_error);
}
bool SBCommandInterpreterRunOptions::GetStopOnCrash() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
GetStopOnCrash);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetStopOnCrash();
}
void SBCommandInterpreterRunOptions::SetStopOnCrash(bool stop_on_crash) {
LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnCrash,
(bool), stop_on_crash);
LLDB_INSTRUMENT_VA(this, stop_on_crash);
m_opaque_up->SetStopOnCrash(stop_on_crash);
}
bool SBCommandInterpreterRunOptions::GetEchoCommands() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
GetEchoCommands);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetEchoCommands();
}
void SBCommandInterpreterRunOptions::SetEchoCommands(bool echo_commands) {
LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetEchoCommands,
(bool), echo_commands);
LLDB_INSTRUMENT_VA(this, echo_commands);
m_opaque_up->SetEchoCommands(echo_commands);
}
bool SBCommandInterpreterRunOptions::GetEchoCommentCommands() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
GetEchoCommentCommands);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetEchoCommentCommands();
}
void SBCommandInterpreterRunOptions::SetEchoCommentCommands(bool echo) {
LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions,
SetEchoCommentCommands, (bool), echo);
LLDB_INSTRUMENT_VA(this, echo);
m_opaque_up->SetEchoCommentCommands(echo);
}
bool SBCommandInterpreterRunOptions::GetPrintResults() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
GetPrintResults);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetPrintResults();
}
void SBCommandInterpreterRunOptions::SetPrintResults(bool print_results) {
LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetPrintResults,
(bool), print_results);
LLDB_INSTRUMENT_VA(this, print_results);
m_opaque_up->SetPrintResults(print_results);
}
bool SBCommandInterpreterRunOptions::GetPrintErrors() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
GetPrintErrors);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetPrintErrors();
}
void SBCommandInterpreterRunOptions::SetPrintErrors(bool print_errors) {
LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetPrintErrors,
(bool), print_errors);
LLDB_INSTRUMENT_VA(this, print_errors);
m_opaque_up->SetPrintErrors(print_errors);
}
bool SBCommandInterpreterRunOptions::GetAddToHistory() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
GetAddToHistory);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetAddToHistory();
}
void SBCommandInterpreterRunOptions::SetAddToHistory(bool add_to_history) {
LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetAddToHistory,
(bool), add_to_history);
LLDB_INSTRUMENT_VA(this, add_to_history);
m_opaque_up->SetAddToHistory(add_to_history);
}
bool SBCommandInterpreterRunOptions::GetAutoHandleEvents() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
GetAutoHandleEvents);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetAutoHandleEvents();
}
void SBCommandInterpreterRunOptions::SetAutoHandleEvents(
bool auto_handle_events) {
LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetAutoHandleEvents,
(bool), auto_handle_events);
LLDB_INSTRUMENT_VA(this, auto_handle_events);
m_opaque_up->SetAutoHandleEvents(auto_handle_events);
}
bool SBCommandInterpreterRunOptions::GetSpawnThread() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
GetSpawnThread);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetSpawnThread();
}
void SBCommandInterpreterRunOptions::SetSpawnThread(bool spawn_thread) {
LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetSpawnThread,
(bool), spawn_thread);
LLDB_INSTRUMENT_VA(this, spawn_thread);
m_opaque_up->SetSpawnThread(spawn_thread);
}
@ -201,14 +178,13 @@ SBCommandInterpreterRunResult::SBCommandInterpreterRunResult()
: m_opaque_up(new CommandInterpreterRunResult())
{
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommandInterpreterRunResult);
LLDB_INSTRUMENT_VA(this);
}
SBCommandInterpreterRunResult::SBCommandInterpreterRunResult(
const SBCommandInterpreterRunResult &rhs)
: m_opaque_up(new CommandInterpreterRunResult()) {
LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreterRunResult,
(const lldb::SBCommandInterpreterRunResult &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
*m_opaque_up = *rhs.m_opaque_up;
}
@ -222,9 +198,7 @@ SBCommandInterpreterRunResult::~SBCommandInterpreterRunResult() = default;
SBCommandInterpreterRunResult &SBCommandInterpreterRunResult::operator=(
const SBCommandInterpreterRunResult &rhs) {
LLDB_RECORD_METHOD(lldb::SBCommandInterpreterRunResult &,
SBCommandInterpreterRunResult, operator=,
(const lldb::SBCommandInterpreterRunResult &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this == &rhs)
return *this;
@ -233,16 +207,14 @@ SBCommandInterpreterRunResult &SBCommandInterpreterRunResult::operator=(
}
int SBCommandInterpreterRunResult::GetNumberOfErrors() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(int, SBCommandInterpreterRunResult,
GetNumberOfErrors);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetNumErrors();
}
lldb::CommandInterpreterResult
SBCommandInterpreterRunResult::GetResult() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::CommandInterpreterResult,
SBCommandInterpreterRunResult, GetResult);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetResult();
}

102
lldb/source/API/SBCommandReturnObject.cpp
View file

@ -7,13 +7,13 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBCommandReturnObject.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/API/SBError.h"
#include "lldb/API/SBFile.h"
#include "lldb/API/SBStream.h"
#include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/Status.h"
using namespace lldb;
@ -46,28 +46,23 @@ private:
SBCommandReturnObject::SBCommandReturnObject()
: m_opaque_up(new SBCommandReturnObjectImpl()) {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommandReturnObject);
LLDB_INSTRUMENT_VA(this);
}
SBCommandReturnObject::SBCommandReturnObject(CommandReturnObject &ref)
: m_opaque_up(new SBCommandReturnObjectImpl(ref)) {
LLDB_RECORD_CONSTRUCTOR(SBCommandReturnObject,
(lldb_private::CommandReturnObject &), ref);
LLDB_INSTRUMENT_VA(this, ref);
}
SBCommandReturnObject::SBCommandReturnObject(const SBCommandReturnObject &rhs) {
LLDB_RECORD_CONSTRUCTOR(SBCommandReturnObject,
(const lldb::SBCommandReturnObject &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_up = clone(rhs.m_opaque_up);
}
SBCommandReturnObject &SBCommandReturnObject::
operator=(const SBCommandReturnObject &rhs) {
LLDB_RECORD_METHOD(
lldb::SBCommandReturnObject &,
SBCommandReturnObject, operator=,(const lldb::SBCommandReturnObject &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
@ -77,44 +72,44 @@ operator=(const SBCommandReturnObject &rhs) {
SBCommandReturnObject::~SBCommandReturnObject() = default;
bool SBCommandReturnObject::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandReturnObject, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBCommandReturnObject::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandReturnObject, operator bool);
LLDB_INSTRUMENT_VA(this);
// This method is not useful but it needs to stay to keep SB API stable.
return true;
}
const char *SBCommandReturnObject::GetOutput() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommandReturnObject, GetOutput);
LLDB_INSTRUMENT_VA(this);
ConstString output(ref().GetOutputData());
return output.AsCString(/*value_if_empty*/ "");
}
const char *SBCommandReturnObject::GetError() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommandReturnObject, GetError);
LLDB_INSTRUMENT_VA(this);
ConstString output(ref().GetErrorData());
return output.AsCString(/*value_if_empty*/ "");
}
size_t SBCommandReturnObject::GetOutputSize() {
LLDB_RECORD_METHOD_NO_ARGS(size_t, SBCommandReturnObject, GetOutputSize);
LLDB_INSTRUMENT_VA(this);
return ref().GetOutputData().size();
}
size_t SBCommandReturnObject::GetErrorSize() {
LLDB_RECORD_METHOD_NO_ARGS(size_t, SBCommandReturnObject, GetErrorSize);
LLDB_INSTRUMENT_VA(this);
return ref().GetErrorData().size();
}
size_t SBCommandReturnObject::PutOutput(FILE *fh) {
LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutOutput, (FILE *), fh);
LLDB_INSTRUMENT_VA(this, fh);
if (fh) {
size_t num_bytes = GetOutputSize();
if (num_bytes)
@ -124,22 +119,21 @@ size_t SBCommandReturnObject::PutOutput(FILE *fh) {
}
size_t SBCommandReturnObject::PutOutput(FileSP file_sp) {
LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutOutput, (FileSP),
file_sp);
LLDB_INSTRUMENT_VA(this, file_sp);
if (!file_sp)
return 0;
return file_sp->Printf("%s", GetOutput());
}
size_t SBCommandReturnObject::PutOutput(SBFile file) {
LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutOutput, (SBFile), file);
LLDB_INSTRUMENT_VA(this, file);
if (!file.m_opaque_sp)
return 0;
return file.m_opaque_sp->Printf("%s", GetOutput());
}
size_t SBCommandReturnObject::PutError(FILE *fh) {
LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutError, (FILE *), fh);
LLDB_INSTRUMENT_VA(this, fh);
if (fh) {
size_t num_bytes = GetErrorSize();
if (num_bytes)
@ -149,62 +143,57 @@ size_t SBCommandReturnObject::PutError(FILE *fh) {
}
size_t SBCommandReturnObject::PutError(FileSP file_sp) {
LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutError, (FileSP),
file_sp);
LLDB_INSTRUMENT_VA(this, file_sp);
if (!file_sp)
return 0;
return file_sp->Printf("%s", GetError());
}
size_t SBCommandReturnObject::PutError(SBFile file) {
LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutError, (SBFile), file);
LLDB_INSTRUMENT_VA(this, file);
if (!file.m_opaque_sp)
return 0;
return file.m_opaque_sp->Printf("%s", GetError());
}
void SBCommandReturnObject::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBCommandReturnObject, Clear);
LLDB_INSTRUMENT_VA(this);
ref().Clear();
}
lldb::ReturnStatus SBCommandReturnObject::GetStatus() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::ReturnStatus, SBCommandReturnObject,
GetStatus);
LLDB_INSTRUMENT_VA(this);
return ref().GetStatus();
}
void SBCommandReturnObject::SetStatus(lldb::ReturnStatus status) {
LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetStatus,
(lldb::ReturnStatus), status);
LLDB_INSTRUMENT_VA(this, status);
ref().SetStatus(status);
}
bool SBCommandReturnObject::Succeeded() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandReturnObject, Succeeded);
LLDB_INSTRUMENT_VA(this);
return ref().Succeeded();
}
bool SBCommandReturnObject::HasResult() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandReturnObject, HasResult);
LLDB_INSTRUMENT_VA(this);
return ref().HasResult();
}
void SBCommandReturnObject::AppendMessage(const char *message) {
LLDB_RECORD_METHOD(void, SBCommandReturnObject, AppendMessage, (const char *),
message);
LLDB_INSTRUMENT_VA(this, message);
ref().AppendMessage(message);
}
void SBCommandReturnObject::AppendWarning(const char *message) {
LLDB_RECORD_METHOD(void, SBCommandReturnObject, AppendWarning, (const char *),
message);
LLDB_INSTRUMENT_VA(this, message);
ref().AppendWarning(message);
}
@ -226,8 +215,7 @@ CommandReturnObject &SBCommandReturnObject::ref() const {
}
bool SBCommandReturnObject::GetDescription(SBStream &description) {
LLDB_RECORD_METHOD(bool, SBCommandReturnObject, GetDescription,
(lldb::SBStream &), description);
LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();
@ -252,62 +240,53 @@ bool SBCommandReturnObject::GetDescription(SBStream &description) {
}
void SBCommandReturnObject::SetImmediateOutputFile(FILE *fh) {
LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
(FILE *), fh);
LLDB_INSTRUMENT_VA(this, fh);
SetImmediateOutputFile(fh, false);
}
void SBCommandReturnObject::SetImmediateErrorFile(FILE *fh) {
LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
(FILE *), fh);
LLDB_INSTRUMENT_VA(this, fh);
SetImmediateErrorFile(fh, false);
}
void SBCommandReturnObject::SetImmediateOutputFile(FILE *fh,
bool transfer_ownership) {
LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
(FILE *, bool), fh, transfer_ownership);
LLDB_INSTRUMENT_VA(this, fh, transfer_ownership);
FileSP file = std::make_shared<NativeFile>(fh, transfer_ownership);
ref().SetImmediateOutputFile(file);
}
void SBCommandReturnObject::SetImmediateErrorFile(FILE *fh,
bool transfer_ownership) {
LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
(FILE *, bool), fh, transfer_ownership);
LLDB_INSTRUMENT_VA(this, fh, transfer_ownership);
FileSP file = std::make_shared<NativeFile>(fh, transfer_ownership);
ref().SetImmediateErrorFile(file);
}
void SBCommandReturnObject::SetImmediateOutputFile(SBFile file) {
LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
(SBFile), file);
LLDB_INSTRUMENT_VA(this, file);
ref().SetImmediateOutputFile(file.m_opaque_sp);
}
void SBCommandReturnObject::SetImmediateErrorFile(SBFile file) {
LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
(SBFile), file);
LLDB_INSTRUMENT_VA(this, file);
ref().SetImmediateErrorFile(file.m_opaque_sp);
}
void SBCommandReturnObject::SetImmediateOutputFile(FileSP file_sp) {
LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
(FileSP), file_sp);
LLDB_INSTRUMENT_VA(this, file_sp);
SetImmediateOutputFile(SBFile(file_sp));
}
void SBCommandReturnObject::SetImmediateErrorFile(FileSP file_sp) {
LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
(FileSP), file_sp);
LLDB_INSTRUMENT_VA(this, file_sp);
SetImmediateErrorFile(SBFile(file_sp));
}
void SBCommandReturnObject::PutCString(const char *string, int len) {
LLDB_RECORD_METHOD(void, SBCommandReturnObject, PutCString,
(const char *, int), string, len);
LLDB_INSTRUMENT_VA(this, string, len);
if (len == 0 || string == nullptr || *string == 0) {
return;
@ -319,8 +298,7 @@ void SBCommandReturnObject::PutCString(const char *string, int len) {
}
const char *SBCommandReturnObject::GetOutput(bool only_if_no_immediate) {
LLDB_RECORD_METHOD(const char *, SBCommandReturnObject, GetOutput, (bool),
only_if_no_immediate);
LLDB_INSTRUMENT_VA(this, only_if_no_immediate);
if (!only_if_no_immediate ||
ref().GetImmediateOutputStream().get() == nullptr)
@ -329,8 +307,7 @@ const char *SBCommandReturnObject::GetOutput(bool only_if_no_immediate) {
}
const char *SBCommandReturnObject::GetError(bool only_if_no_immediate) {
LLDB_RECORD_METHOD(const char *, SBCommandReturnObject, GetError, (bool),
only_if_no_immediate);
LLDB_INSTRUMENT_VA(this, only_if_no_immediate);
if (!only_if_no_immediate || ref().GetImmediateErrorStream().get() == nullptr)
return GetError();
@ -347,9 +324,7 @@ size_t SBCommandReturnObject::Printf(const char *format, ...) {
void SBCommandReturnObject::SetError(lldb::SBError &error,
const char *fallback_error_cstr) {
LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetError,
(lldb::SBError &, const char *), error,
fallback_error_cstr);
LLDB_INSTRUMENT_VA(this, error, fallback_error_cstr);
if (error.IsValid())
ref().SetError(error.ref(), fallback_error_cstr);
@ -358,8 +333,7 @@ void SBCommandReturnObject::SetError(lldb::SBError &error,
}
void SBCommandReturnObject::SetError(const char *error_cstr) {
LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetError, (const char *),
error_cstr);
LLDB_INSTRUMENT_VA(this, error_cstr);
if (error_cstr)
ref().AppendError(error_cstr);

51
lldb/source/API/SBCommunication.cpp
View file

@ -7,22 +7,20 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBCommunication.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBBroadcaster.h"
#include "lldb/Core/Communication.h"
#include "lldb/Host/ConnectionFileDescriptor.h"
#include "lldb/Host/Host.h"
#include "lldb/Utility/Instrumentation.h"
using namespace lldb;
using namespace lldb_private;
SBCommunication::SBCommunication() {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommunication);
}
SBCommunication::SBCommunication() { LLDB_INSTRUMENT_VA(this); }
SBCommunication::SBCommunication(const char *broadcaster_name)
: m_opaque(new Communication(broadcaster_name)), m_opaque_owned(true) {
LLDB_RECORD_CONSTRUCTOR(SBCommunication, (const char *), broadcaster_name);
LLDB_INSTRUMENT_VA(this, broadcaster_name);
}
SBCommunication::~SBCommunication() {
@ -33,17 +31,17 @@ SBCommunication::~SBCommunication() {
}
bool SBCommunication::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommunication, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBCommunication::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommunication, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_opaque != nullptr;
}
bool SBCommunication::GetCloseOnEOF() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, GetCloseOnEOF);
LLDB_INSTRUMENT_VA(this);
if (m_opaque)
return m_opaque->GetCloseOnEOF();
@ -51,15 +49,14 @@ bool SBCommunication::GetCloseOnEOF() {
}
void SBCommunication::SetCloseOnEOF(bool b) {
LLDB_RECORD_METHOD(void, SBCommunication, SetCloseOnEOF, (bool), b);
LLDB_INSTRUMENT_VA(this, b);
if (m_opaque)
m_opaque->SetCloseOnEOF(b);
}
ConnectionStatus SBCommunication::Connect(const char *url) {
LLDB_RECORD_METHOD(lldb::ConnectionStatus, SBCommunication, Connect,
(const char *), url);
LLDB_INSTRUMENT_VA(this, url);
if (m_opaque) {
if (!m_opaque->HasConnection())
@ -70,8 +67,7 @@ ConnectionStatus SBCommunication::Connect(const char *url) {
}
ConnectionStatus SBCommunication::AdoptFileDesriptor(int fd, bool owns_fd) {
LLDB_RECORD_METHOD(lldb::ConnectionStatus, SBCommunication,
AdoptFileDesriptor, (int, bool), fd, owns_fd);
LLDB_INSTRUMENT_VA(this, fd, owns_fd);
ConnectionStatus status = eConnectionStatusNoConnection;
if (m_opaque) {
@ -90,8 +86,7 @@ ConnectionStatus SBCommunication::AdoptFileDesriptor(int fd, bool owns_fd) {
}
ConnectionStatus SBCommunication::Disconnect() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::ConnectionStatus, SBCommunication,
Disconnect);
LLDB_INSTRUMENT_VA(this);
ConnectionStatus status = eConnectionStatusNoConnection;
if (m_opaque)
@ -100,16 +95,14 @@ ConnectionStatus SBCommunication::Disconnect() {
}
bool SBCommunication::IsConnected() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommunication, IsConnected);
LLDB_INSTRUMENT_VA(this);
return m_opaque ? m_opaque->IsConnected() : false;
}
size_t SBCommunication::Read(void *dst, size_t dst_len, uint32_t timeout_usec,
ConnectionStatus &status) {
LLDB_RECORD_METHOD(size_t, SBCommunication, Read,
(void *, size_t, uint32_t, lldb::ConnectionStatus &), dst,
dst_len, timeout_usec, status);
LLDB_INSTRUMENT_VA(this, dst, dst_len, timeout_usec, status);
size_t bytes_read = 0;
Timeout<std::micro> timeout = timeout_usec == UINT32_MAX
@ -125,9 +118,7 @@ size_t SBCommunication::Read(void *dst, size_t dst_len, uint32_t timeout_usec,
size_t SBCommunication::Write(const void *src, size_t src_len,
ConnectionStatus &status) {
LLDB_RECORD_METHOD(size_t, SBCommunication, Write,
(const void *, size_t, lldb::ConnectionStatus &), src,
src_len, status);
LLDB_INSTRUMENT_VA(this, src, src_len, status);
size_t bytes_written = 0;
if (m_opaque)
@ -139,28 +130,26 @@ size_t SBCommunication::Write(const void *src, size_t src_len,
}
bool SBCommunication::ReadThreadStart() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadStart);
LLDB_INSTRUMENT_VA(this);
return m_opaque ? m_opaque->StartReadThread() : false;
}
bool SBCommunication::ReadThreadStop() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadStop);
LLDB_INSTRUMENT_VA(this);
return m_opaque ? m_opaque->StopReadThread() : false;
}
bool SBCommunication::ReadThreadIsRunning() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadIsRunning);
LLDB_INSTRUMENT_VA(this);
return m_opaque ? m_opaque->ReadThreadIsRunning() : false;
}
bool SBCommunication::SetReadThreadBytesReceivedCallback(
ReadThreadBytesReceived callback, void *callback_baton) {
LLDB_RECORD_METHOD(bool, SBCommunication, SetReadThreadBytesReceivedCallback,
(lldb::SBCommunication::ReadThreadBytesReceived, void *),
callback, callback_baton);
LLDB_INSTRUMENT_VA(this, callback, callback_baton);
bool result = false;
if (m_opaque) {
@ -171,16 +160,14 @@ bool SBCommunication::SetReadThreadBytesReceivedCallback(
}
SBBroadcaster SBCommunication::GetBroadcaster() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBroadcaster, SBCommunication,
GetBroadcaster);
LLDB_INSTRUMENT_VA(this);
SBBroadcaster broadcaster(m_opaque, false);
return broadcaster;
}
const char *SBCommunication::GetBroadcasterClass() {
LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBCommunication,
GetBroadcasterClass);
LLDB_INSTRUMENT();
return Communication::GetStaticBroadcasterClass().AsCString();
}

55
lldb/source/API/SBCompileUnit.cpp
View file

@ -7,7 +7,6 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBCompileUnit.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBLineEntry.h"
#include "lldb/API/SBStream.h"
#include "lldb/Core/Module.h"
@ -17,26 +16,23 @@
#include "lldb/Symbol/SymbolFile.h"
#include "lldb/Symbol/Type.h"
#include "lldb/Symbol/TypeList.h"
#include "lldb/Utility/Instrumentation.h"
using namespace lldb;
using namespace lldb_private;
SBCompileUnit::SBCompileUnit() {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCompileUnit);
}
SBCompileUnit::SBCompileUnit() { LLDB_INSTRUMENT_VA(this); }
SBCompileUnit::SBCompileUnit(lldb_private::CompileUnit *lldb_object_ptr)
: m_opaque_ptr(lldb_object_ptr) {}
SBCompileUnit::SBCompileUnit(const SBCompileUnit &rhs)
: m_opaque_ptr(rhs.m_opaque_ptr) {
LLDB_RECORD_CONSTRUCTOR(SBCompileUnit, (const lldb::SBCompileUnit &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
}
const SBCompileUnit &SBCompileUnit::operator=(const SBCompileUnit &rhs) {
LLDB_RECORD_METHOD(const lldb::SBCompileUnit &,
SBCompileUnit, operator=,(const lldb::SBCompileUnit &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_ptr = rhs.m_opaque_ptr;
return *this;
@ -45,8 +41,7 @@ const SBCompileUnit &SBCompileUnit::operator=(const SBCompileUnit &rhs) {
SBCompileUnit::~SBCompileUnit() { m_opaque_ptr = nullptr; }
SBFileSpec SBCompileUnit::GetFileSpec() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBCompileUnit,
GetFileSpec);
LLDB_INSTRUMENT_VA(this);
SBFileSpec file_spec;
if (m_opaque_ptr)
@ -55,7 +50,7 @@ SBFileSpec SBCompileUnit::GetFileSpec() const {
}
uint32_t SBCompileUnit::GetNumLineEntries() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBCompileUnit, GetNumLineEntries);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr) {
LineTable *line_table = m_opaque_ptr->GetLineTable();
@ -67,8 +62,7 @@ uint32_t SBCompileUnit::GetNumLineEntries() const {
}
SBLineEntry SBCompileUnit::GetLineEntryAtIndex(uint32_t idx) const {
LLDB_RECORD_METHOD_CONST(lldb::SBLineEntry, SBCompileUnit,
GetLineEntryAtIndex, (uint32_t), idx);
LLDB_INSTRUMENT_VA(this, idx);
SBLineEntry sb_line_entry;
if (m_opaque_ptr) {
@ -85,9 +79,7 @@ SBLineEntry SBCompileUnit::GetLineEntryAtIndex(uint32_t idx) const {
uint32_t SBCompileUnit::FindLineEntryIndex(uint32_t start_idx, uint32_t line,
SBFileSpec *inline_file_spec) const {
LLDB_RECORD_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex,
(uint32_t, uint32_t, lldb::SBFileSpec *), start_idx,
line, inline_file_spec);
LLDB_INSTRUMENT_VA(this, start_idx, line, inline_file_spec);
const bool exact = true;
return FindLineEntryIndex(start_idx, line, inline_file_spec, exact);
@ -96,9 +88,7 @@ uint32_t SBCompileUnit::FindLineEntryIndex(uint32_t start_idx, uint32_t line,
uint32_t SBCompileUnit::FindLineEntryIndex(uint32_t start_idx, uint32_t line,
SBFileSpec *inline_file_spec,
bool exact) const {
LLDB_RECORD_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex,
(uint32_t, uint32_t, lldb::SBFileSpec *, bool),
start_idx, line, inline_file_spec, exact);
LLDB_INSTRUMENT_VA(this, start_idx, line, inline_file_spec, exact);
uint32_t index = UINT32_MAX;
if (m_opaque_ptr) {
@ -118,7 +108,7 @@ uint32_t SBCompileUnit::FindLineEntryIndex(uint32_t start_idx, uint32_t line,
}
uint32_t SBCompileUnit::GetNumSupportFiles() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBCompileUnit, GetNumSupportFiles);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr)
return m_opaque_ptr->GetSupportFiles().GetSize();
@ -127,8 +117,7 @@ uint32_t SBCompileUnit::GetNumSupportFiles() const {
}
lldb::SBTypeList SBCompileUnit::GetTypes(uint32_t type_mask) {
LLDB_RECORD_METHOD(lldb::SBTypeList, SBCompileUnit, GetTypes, (uint32_t),
type_mask);
LLDB_INSTRUMENT_VA(this, type_mask);
SBTypeList sb_type_list;
@ -151,8 +140,7 @@ lldb::SBTypeList SBCompileUnit::GetTypes(uint32_t type_mask) {
}
SBFileSpec SBCompileUnit::GetSupportFileAtIndex(uint32_t idx) const {
LLDB_RECORD_METHOD_CONST(lldb::SBFileSpec, SBCompileUnit,
GetSupportFileAtIndex, (uint32_t), idx);
LLDB_INSTRUMENT_VA(this, idx);
SBFileSpec sb_file_spec;
if (m_opaque_ptr) {
@ -166,9 +154,7 @@ SBFileSpec SBCompileUnit::GetSupportFileAtIndex(uint32_t idx) const {
uint32_t SBCompileUnit::FindSupportFileIndex(uint32_t start_idx,
const SBFileSpec &sb_file,
bool full) {
LLDB_RECORD_METHOD(uint32_t, SBCompileUnit, FindSupportFileIndex,
(uint32_t, const lldb::SBFileSpec &, bool), start_idx,
sb_file, full);
LLDB_INSTRUMENT_VA(this, start_idx, sb_file, full);
if (m_opaque_ptr) {
const FileSpecList &support_files = m_opaque_ptr->GetSupportFiles();
@ -178,7 +164,7 @@ uint32_t SBCompileUnit::FindSupportFileIndex(uint32_t start_idx,
}
lldb::LanguageType SBCompileUnit::GetLanguage() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::LanguageType, SBCompileUnit, GetLanguage);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr)
return m_opaque_ptr->GetLanguage();
@ -186,25 +172,23 @@ lldb::LanguageType SBCompileUnit::GetLanguage() {
}
bool SBCompileUnit::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCompileUnit, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBCompileUnit::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCompileUnit, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_opaque_ptr != nullptr;
}
bool SBCompileUnit::operator==(const SBCompileUnit &rhs) const {
LLDB_RECORD_METHOD_CONST(
bool, SBCompileUnit, operator==,(const lldb::SBCompileUnit &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
return m_opaque_ptr == rhs.m_opaque_ptr;
}
bool SBCompileUnit::operator!=(const SBCompileUnit &rhs) const {
LLDB_RECORD_METHOD_CONST(
bool, SBCompileUnit, operator!=,(const lldb::SBCompileUnit &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
return m_opaque_ptr != rhs.m_opaque_ptr;
}
@ -224,8 +208,7 @@ void SBCompileUnit::reset(lldb_private::CompileUnit *lldb_object_ptr) {
}
bool SBCompileUnit::GetDescription(SBStream &description) {
LLDB_RECORD_METHOD(bool, SBCompileUnit, GetDescription, (lldb::SBStream &),
description);
LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();

131
lldb/source/API/SBData.cpp
View file

@ -7,9 +7,9 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBData.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBError.h"
#include "lldb/API/SBStream.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/Core/DumpDataExtractor.h"
#include "lldb/Utility/DataBufferHeap.h"
@ -23,18 +23,17 @@ using namespace lldb;
using namespace lldb_private;
SBData::SBData() : m_opaque_sp(new DataExtractor()) {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBData);
LLDB_INSTRUMENT_VA(this);
}
SBData::SBData(const lldb::DataExtractorSP &data_sp) : m_opaque_sp(data_sp) {}
SBData::SBData(const SBData &rhs) : m_opaque_sp(rhs.m_opaque_sp) {
LLDB_RECORD_CONSTRUCTOR(SBData, (const lldb::SBData &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
}
const SBData &SBData::operator=(const SBData &rhs) {
LLDB_RECORD_METHOD(const lldb::SBData &,
SBData, operator=,(const lldb::SBData &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_sp = rhs.m_opaque_sp;
@ -58,17 +57,17 @@ lldb::DataExtractorSP &SBData::operator*() { return m_opaque_sp; }
const lldb::DataExtractorSP &SBData::operator*() const { return m_opaque_sp; }
bool SBData::IsValid() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBData, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBData::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBData, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp.get() != nullptr;
}
uint8_t SBData::GetAddressByteSize() {
LLDB_RECORD_METHOD_NO_ARGS(uint8_t, SBData, GetAddressByteSize);
LLDB_INSTRUMENT_VA(this);
uint8_t value = 0;
if (m_opaque_sp.get())
@ -77,22 +76,21 @@ uint8_t SBData::GetAddressByteSize() {
}
void SBData::SetAddressByteSize(uint8_t addr_byte_size) {
LLDB_RECORD_METHOD(void, SBData, SetAddressByteSize, (uint8_t),
addr_byte_size);
LLDB_INSTRUMENT_VA(this, addr_byte_size);
if (m_opaque_sp.get())
m_opaque_sp->SetAddressByteSize(addr_byte_size);
}
void SBData::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBData, Clear);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp.get())
m_opaque_sp->Clear();
}
size_t SBData::GetByteSize() {
LLDB_RECORD_METHOD_NO_ARGS(size_t, SBData, GetByteSize);
LLDB_INSTRUMENT_VA(this);
size_t value = 0;
if (m_opaque_sp.get())
@ -101,7 +99,7 @@ size_t SBData::GetByteSize() {
}
lldb::ByteOrder SBData::GetByteOrder() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::ByteOrder, SBData, GetByteOrder);
LLDB_INSTRUMENT_VA(this);
lldb::ByteOrder value = eByteOrderInvalid;
if (m_opaque_sp.get())
@ -110,15 +108,14 @@ lldb::ByteOrder SBData::GetByteOrder() {
}
void SBData::SetByteOrder(lldb::ByteOrder endian) {
LLDB_RECORD_METHOD(void, SBData, SetByteOrder, (lldb::ByteOrder), endian);
LLDB_INSTRUMENT_VA(this, endian);
if (m_opaque_sp.get())
m_opaque_sp->SetByteOrder(endian);
}
float SBData::GetFloat(lldb::SBError &error, lldb::offset_t offset) {
LLDB_RECORD_METHOD(float, SBData, GetFloat, (lldb::SBError &, lldb::offset_t),
error, offset);
LLDB_INSTRUMENT_VA(this, error, offset);
float value = 0;
if (!m_opaque_sp.get()) {
@ -133,8 +130,7 @@ float SBData::GetFloat(lldb::SBError &error, lldb::offset_t offset) {
}
double SBData::GetDouble(lldb::SBError &error, lldb::offset_t offset) {
LLDB_RECORD_METHOD(double, SBData, GetDouble,
(lldb::SBError &, lldb::offset_t), error, offset);
LLDB_INSTRUMENT_VA(this, error, offset);
double value = 0;
if (!m_opaque_sp.get()) {
@ -149,8 +145,7 @@ double SBData::GetDouble(lldb::SBError &error, lldb::offset_t offset) {
}
long double SBData::GetLongDouble(lldb::SBError &error, lldb::offset_t offset) {
LLDB_RECORD_METHOD(long double, SBData, GetLongDouble,
(lldb::SBError &, lldb::offset_t), error, offset);
LLDB_INSTRUMENT_VA(this, error, offset);
long double value = 0;
if (!m_opaque_sp.get()) {
@ -165,8 +160,7 @@ long double SBData::GetLongDouble(lldb::SBError &error, lldb::offset_t offset) {
}
lldb::addr_t SBData::GetAddress(lldb::SBError &error, lldb::offset_t offset) {
LLDB_RECORD_METHOD(lldb::addr_t, SBData, GetAddress,
(lldb::SBError &, lldb::offset_t), error, offset);
LLDB_INSTRUMENT_VA(this, error, offset);
lldb::addr_t value = 0;
if (!m_opaque_sp.get()) {
@ -181,8 +175,7 @@ lldb::addr_t SBData::GetAddress(lldb::SBError &error, lldb::offset_t offset) {
}
uint8_t SBData::GetUnsignedInt8(lldb::SBError &error, lldb::offset_t offset) {
LLDB_RECORD_METHOD(uint8_t, SBData, GetUnsignedInt8,
(lldb::SBError &, lldb::offset_t), error, offset);
LLDB_INSTRUMENT_VA(this, error, offset);
uint8_t value = 0;
if (!m_opaque_sp.get()) {
@ -197,8 +190,7 @@ uint8_t SBData::GetUnsignedInt8(lldb::SBError &error, lldb::offset_t offset) {
}
uint16_t SBData::GetUnsignedInt16(lldb::SBError &error, lldb::offset_t offset) {
LLDB_RECORD_METHOD(uint16_t, SBData, GetUnsignedInt16,
(lldb::SBError &, lldb::offset_t), error, offset);
LLDB_INSTRUMENT_VA(this, error, offset);
uint16_t value = 0;
if (!m_opaque_sp.get()) {
@ -213,8 +205,7 @@ uint16_t SBData::GetUnsignedInt16(lldb::SBError &error, lldb::offset_t offset) {
}
uint32_t SBData::GetUnsignedInt32(lldb::SBError &error, lldb::offset_t offset) {
LLDB_RECORD_METHOD(uint32_t, SBData, GetUnsignedInt32,
(lldb::SBError &, lldb::offset_t), error, offset);
LLDB_INSTRUMENT_VA(this, error, offset);
uint32_t value = 0;
if (!m_opaque_sp.get()) {
@ -229,8 +220,7 @@ uint32_t SBData::GetUnsignedInt32(lldb::SBError &error, lldb::offset_t offset) {
}
uint64_t SBData::GetUnsignedInt64(lldb::SBError &error, lldb::offset_t offset) {
LLDB_RECORD_METHOD(uint64_t, SBData, GetUnsignedInt64,
(lldb::SBError &, lldb::offset_t), error, offset);
LLDB_INSTRUMENT_VA(this, error, offset);
uint64_t value = 0;
if (!m_opaque_sp.get()) {
@ -245,8 +235,7 @@ uint64_t SBData::GetUnsignedInt64(lldb::SBError &error, lldb::offset_t offset) {
}
int8_t SBData::GetSignedInt8(lldb::SBError &error, lldb::offset_t offset) {
LLDB_RECORD_METHOD(int8_t, SBData, GetSignedInt8,
(lldb::SBError &, lldb::offset_t), error, offset);
LLDB_INSTRUMENT_VA(this, error, offset);
int8_t value = 0;
if (!m_opaque_sp.get()) {
@ -261,8 +250,7 @@ int8_t SBData::GetSignedInt8(lldb::SBError &error, lldb::offset_t offset) {
}
int16_t SBData::GetSignedInt16(lldb::SBError &error, lldb::offset_t offset) {
LLDB_RECORD_METHOD(int16_t, SBData, GetSignedInt16,
(lldb::SBError &, lldb::offset_t), error, offset);
LLDB_INSTRUMENT_VA(this, error, offset);
int16_t value = 0;
if (!m_opaque_sp.get()) {
@ -277,8 +265,7 @@ int16_t SBData::GetSignedInt16(lldb::SBError &error, lldb::offset_t offset) {
}
int32_t SBData::GetSignedInt32(lldb::SBError &error, lldb::offset_t offset) {
LLDB_RECORD_METHOD(int32_t, SBData, GetSignedInt32,
(lldb::SBError &, lldb::offset_t), error, offset);
LLDB_INSTRUMENT_VA(this, error, offset);
int32_t value = 0;
if (!m_opaque_sp.get()) {
@ -293,8 +280,7 @@ int32_t SBData::GetSignedInt32(lldb::SBError &error, lldb::offset_t offset) {
}
int64_t SBData::GetSignedInt64(lldb::SBError &error, lldb::offset_t offset) {
LLDB_RECORD_METHOD(int64_t, SBData, GetSignedInt64,
(lldb::SBError &, lldb::offset_t), error, offset);
LLDB_INSTRUMENT_VA(this, error, offset);
int64_t value = 0;
if (!m_opaque_sp.get()) {
@ -309,8 +295,7 @@ int64_t SBData::GetSignedInt64(lldb::SBError &error, lldb::offset_t offset) {
}
const char *SBData::GetString(lldb::SBError &error, lldb::offset_t offset) {
LLDB_RECORD_METHOD(const char *, SBData, GetString,
(lldb::SBError &, lldb::offset_t), error, offset);
LLDB_INSTRUMENT_VA(this, error, offset);
const char *value = nullptr;
if (!m_opaque_sp.get()) {
@ -326,8 +311,7 @@ const char *SBData::GetString(lldb::SBError &error, lldb::offset_t offset) {
bool SBData::GetDescription(lldb::SBStream &description,
lldb::addr_t base_addr) {
LLDB_RECORD_METHOD(bool, SBData, GetDescription,
(lldb::SBStream &, lldb::addr_t), description, base_addr);
LLDB_INSTRUMENT_VA(this, description, base_addr);
Stream &strm = description.ref();
@ -342,9 +326,7 @@ bool SBData::GetDescription(lldb::SBStream &description,
size_t SBData::ReadRawData(lldb::SBError &error, lldb::offset_t offset,
void *buf, size_t size) {
LLDB_RECORD_METHOD(size_t, SBData, ReadRawData,
(lldb::SBError &, lldb::offset_t, void *, size_t), error,
offset, buf, size);
LLDB_INSTRUMENT_VA(this, error, offset, buf, size);
void *ok = nullptr;
if (!m_opaque_sp.get()) {
@ -360,10 +342,7 @@ size_t SBData::ReadRawData(lldb::SBError &error, lldb::offset_t offset,
void SBData::SetData(lldb::SBError &error, const void *buf, size_t size,
lldb::ByteOrder endian, uint8_t addr_size) {
LLDB_RECORD_METHOD(
void, SBData, SetData,
(lldb::SBError &, const void *, size_t, lldb::ByteOrder, uint8_t), error,
buf, size, endian, addr_size);
LLDB_INSTRUMENT_VA(this, error, buf, size, endian, addr_size);
if (!m_opaque_sp.get())
m_opaque_sp = std::make_shared<DataExtractor>(buf, size, endian, addr_size);
@ -377,10 +356,7 @@ void SBData::SetData(lldb::SBError &error, const void *buf, size_t size,
void SBData::SetDataWithOwnership(lldb::SBError &error, const void *buf,
size_t size, lldb::ByteOrder endian,
uint8_t addr_size) {
LLDB_RECORD_METHOD(
void, SBData, SetData,
(lldb::SBError &, const void *, size_t, lldb::ByteOrder, uint8_t, bool),
error, buf, size, endian, addr_size);
LLDB_INSTRUMENT_VA(this, error, buf, size, endian, addr_size);
lldb::DataBufferSP buffer_sp = std::make_shared<DataBufferHeap>(buf, size);
@ -394,7 +370,7 @@ void SBData::SetDataWithOwnership(lldb::SBError &error, const void *buf,
}
bool SBData::Append(const SBData &rhs) {
LLDB_RECORD_METHOD(bool, SBData, Append, (const lldb::SBData &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
bool value = false;
if (m_opaque_sp.get() && rhs.m_opaque_sp.get())
@ -405,9 +381,7 @@ bool SBData::Append(const SBData &rhs) {
lldb::SBData SBData::CreateDataFromCString(lldb::ByteOrder endian,
uint32_t addr_byte_size,
const char *data) {
LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromCString,
(lldb::ByteOrder, uint32_t, const char *), endian,
addr_byte_size, data);
LLDB_INSTRUMENT_VA(endian, addr_byte_size, data);
if (!data || !data[0])
return SBData();
@ -427,9 +401,7 @@ lldb::SBData SBData::CreateDataFromUInt64Array(lldb::ByteOrder endian,
uint32_t addr_byte_size,
uint64_t *array,
size_t array_len) {
LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromUInt64Array,
(lldb::ByteOrder, uint32_t, uint64_t *, size_t),
endian, addr_byte_size, array, array_len);
LLDB_INSTRUMENT_VA(endian, addr_byte_size, array, array_len);
if (!array || array_len == 0)
return SBData();
@ -449,9 +421,7 @@ lldb::SBData SBData::CreateDataFromUInt32Array(lldb::ByteOrder endian,
uint32_t addr_byte_size,
uint32_t *array,
size_t array_len) {
LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromUInt32Array,
(lldb::ByteOrder, uint32_t, uint32_t *, size_t),
endian, addr_byte_size, array, array_len);
LLDB_INSTRUMENT_VA(endian, addr_byte_size, array, array_len);
if (!array || array_len == 0)
return SBData();
@ -471,9 +441,7 @@ lldb::SBData SBData::CreateDataFromSInt64Array(lldb::ByteOrder endian,
uint32_t addr_byte_size,
int64_t *array,
size_t array_len) {
LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromSInt64Array,
(lldb::ByteOrder, uint32_t, int64_t *, size_t),
endian, addr_byte_size, array, array_len);
LLDB_INSTRUMENT_VA(endian, addr_byte_size, array, array_len);
if (!array || array_len == 0)
return SBData();
@ -493,9 +461,7 @@ lldb::SBData SBData::CreateDataFromSInt32Array(lldb::ByteOrder endian,
uint32_t addr_byte_size,
int32_t *array,
size_t array_len) {
LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromSInt32Array,
(lldb::ByteOrder, uint32_t, int32_t *, size_t),
endian, addr_byte_size, array, array_len);
LLDB_INSTRUMENT_VA(endian, addr_byte_size, array, array_len);
if (!array || array_len == 0)
return SBData();
@ -515,9 +481,7 @@ lldb::SBData SBData::CreateDataFromDoubleArray(lldb::ByteOrder endian,
uint32_t addr_byte_size,
double *array,
size_t array_len) {
LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromDoubleArray,
(lldb::ByteOrder, uint32_t, double *, size_t),
endian, addr_byte_size, array, array_len);
LLDB_INSTRUMENT_VA(endian, addr_byte_size, array, array_len);
if (!array || array_len == 0)
return SBData();
@ -534,8 +498,7 @@ lldb::SBData SBData::CreateDataFromDoubleArray(lldb::ByteOrder endian,
}
bool SBData::SetDataFromCString(const char *data) {
LLDB_RECORD_METHOD(bool, SBData, SetDataFromCString, (const char *), data);
LLDB_INSTRUMENT_VA(this, data);
if (!data) {
return false;
@ -556,9 +519,7 @@ bool SBData::SetDataFromCString(const char *data) {
}
bool SBData::SetDataFromUInt64Array(uint64_t *array, size_t array_len) {
LLDB_RECORD_METHOD(bool, SBData, SetDataFromUInt64Array, (uint64_t *, size_t),
array, array_len);
LLDB_INSTRUMENT_VA(this, array, array_len);
if (!array || array_len == 0) {
return false;
@ -579,9 +540,7 @@ bool SBData::SetDataFromUInt64Array(uint64_t *array, size_t array_len) {
}
bool SBData::SetDataFromUInt32Array(uint32_t *array, size_t array_len) {
LLDB_RECORD_METHOD(bool, SBData, SetDataFromUInt32Array, (uint32_t *, size_t),
array, array_len);
LLDB_INSTRUMENT_VA(this, array, array_len);
if (!array || array_len == 0) {
return false;
@ -601,9 +560,7 @@ bool SBData::SetDataFromUInt32Array(uint32_t *array, size_t array_len) {
}
bool SBData::SetDataFromSInt64Array(int64_t *array, size_t array_len) {
LLDB_RECORD_METHOD(bool, SBData, SetDataFromSInt64Array, (int64_t *, size_t),
array, array_len);
LLDB_INSTRUMENT_VA(this, array, array_len);
if (!array || array_len == 0) {
return false;
@ -623,9 +580,7 @@ bool SBData::SetDataFromSInt64Array(int64_t *array, size_t array_len) {
}
bool SBData::SetDataFromSInt32Array(int32_t *array, size_t array_len) {
LLDB_RECORD_METHOD(bool, SBData, SetDataFromSInt32Array, (int32_t *, size_t),
array, array_len);
LLDB_INSTRUMENT_VA(this, array, array_len);
if (!array || array_len == 0) {
return false;
@ -645,9 +600,7 @@ bool SBData::SetDataFromSInt32Array(int32_t *array, size_t array_len) {
}
bool SBData::SetDataFromDoubleArray(double *array, size_t array_len) {
LLDB_RECORD_METHOD(bool, SBData, SetDataFromDoubleArray, (double *, size_t),
array, array_len);
LLDB_INSTRUMENT_VA(this, array, array_len);
if (!array || array_len == 0) {
return false;

368
lldb/source/API/SBDebugger.cpp
View file

File diff suppressed because it is too large Load diff

41
lldb/source/API/SBDeclaration.cpp
View file

@ -7,11 +7,11 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBDeclaration.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/API/SBStream.h"
#include "lldb/Core/Declaration.h"
#include "lldb/Host/PosixApi.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/Stream.h"
#include <climits>
@ -19,12 +19,10 @@
using namespace lldb;
using namespace lldb_private;
SBDeclaration::SBDeclaration() {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBDeclaration);
}
SBDeclaration::SBDeclaration() { LLDB_INSTRUMENT_VA(this); }
SBDeclaration::SBDeclaration(const SBDeclaration &rhs) {
LLDB_RECORD_CONSTRUCTOR(SBDeclaration, (const lldb::SBDeclaration &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_up = clone(rhs.m_opaque_up);
}
@ -35,9 +33,7 @@ SBDeclaration::SBDeclaration(const lldb_private::Declaration *lldb_object_ptr) {
}
const SBDeclaration &SBDeclaration::operator=(const SBDeclaration &rhs) {
LLDB_RECORD_METHOD(const lldb::SBDeclaration &,
SBDeclaration, operator=,(const lldb::SBDeclaration &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
@ -52,19 +48,17 @@ void SBDeclaration::SetDeclaration(
SBDeclaration::~SBDeclaration() = default;
bool SBDeclaration::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDeclaration, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBDeclaration::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDeclaration, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up.get() && m_opaque_up->IsValid();
}
SBFileSpec SBDeclaration::GetFileSpec() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBDeclaration,
GetFileSpec);
LLDB_INSTRUMENT_VA(this);
SBFileSpec sb_file_spec;
if (m_opaque_up.get() && m_opaque_up->GetFile())
@ -74,8 +68,7 @@ SBFileSpec SBDeclaration::GetFileSpec() const {
}
uint32_t SBDeclaration::GetLine() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBDeclaration, GetLine);
LLDB_INSTRUMENT_VA(this);
uint32_t line = 0;
if (m_opaque_up)
@ -86,7 +79,7 @@ uint32_t SBDeclaration::GetLine() const {
}
uint32_t SBDeclaration::GetColumn() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBDeclaration, GetColumn);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_up)
return m_opaque_up->GetColumn();
@ -94,8 +87,7 @@ uint32_t SBDeclaration::GetColumn() const {
}
void SBDeclaration::SetFileSpec(lldb::SBFileSpec filespec) {
LLDB_RECORD_METHOD(void, SBDeclaration, SetFileSpec, (lldb::SBFileSpec),
filespec);
LLDB_INSTRUMENT_VA(this, filespec);
if (filespec.IsValid())
ref().SetFile(filespec.ref());
@ -103,20 +95,19 @@ void SBDeclaration::SetFileSpec(lldb::SBFileSpec filespec) {
ref().SetFile(FileSpec());
}
void SBDeclaration::SetLine(uint32_t line) {
LLDB_RECORD_METHOD(void, SBDeclaration, SetLine, (uint32_t), line);
LLDB_INSTRUMENT_VA(this, line);
ref().SetLine(line);
}
void SBDeclaration::SetColumn(uint32_t column) {
LLDB_RECORD_METHOD(void, SBDeclaration, SetColumn, (uint32_t), column);
LLDB_INSTRUMENT_VA(this, column);
ref().SetColumn(column);
}
bool SBDeclaration::operator==(const SBDeclaration &rhs) const {
LLDB_RECORD_METHOD_CONST(
bool, SBDeclaration, operator==,(const lldb::SBDeclaration &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
lldb_private::Declaration *lhs_ptr = m_opaque_up.get();
lldb_private::Declaration *rhs_ptr = rhs.m_opaque_up.get();
@ -128,8 +119,7 @@ bool SBDeclaration::operator==(const SBDeclaration &rhs) const {
}
bool SBDeclaration::operator!=(const SBDeclaration &rhs) const {
LLDB_RECORD_METHOD_CONST(
bool, SBDeclaration, operator!=,(const lldb::SBDeclaration &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
lldb_private::Declaration *lhs_ptr = m_opaque_up.get();
lldb_private::Declaration *rhs_ptr = rhs.m_opaque_up.get();
@ -155,8 +145,7 @@ const lldb_private::Declaration &SBDeclaration::ref() const {
}
bool SBDeclaration::GetDescription(SBStream &description) {
LLDB_RECORD_METHOD(bool, SBDeclaration, GetDescription, (lldb::SBStream &),
description);
LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();

36
lldb/source/API/SBEnvironment.cpp
View file

@ -7,22 +7,22 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBEnvironment.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/API/SBStringList.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Environment.h"
#include "lldb/Utility/Instrumentation.h"
using namespace lldb;
using namespace lldb_private;
SBEnvironment::SBEnvironment() : m_opaque_up(new Environment()) {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBEnvironment);
LLDB_INSTRUMENT_VA(this);
}
SBEnvironment::SBEnvironment(const SBEnvironment &rhs)
: m_opaque_up(clone(rhs.m_opaque_up)) {
LLDB_RECORD_CONSTRUCTOR(SBEnvironment, (const lldb::SBEnvironment &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
}
SBEnvironment::SBEnvironment(Environment rhs)
@ -31,9 +31,7 @@ SBEnvironment::SBEnvironment(Environment rhs)
SBEnvironment::~SBEnvironment() = default;
const SBEnvironment &SBEnvironment::operator=(const SBEnvironment &rhs) {
LLDB_RECORD_METHOD(const lldb::SBEnvironment &,
SBEnvironment, operator=,(const lldb::SBEnvironment &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
@ -41,13 +39,13 @@ const SBEnvironment &SBEnvironment::operator=(const SBEnvironment &rhs) {
}
size_t SBEnvironment::GetNumValues() {
LLDB_RECORD_METHOD_NO_ARGS(size_t, SBEnvironment, GetNumValues);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->size();
}
const char *SBEnvironment::Get(const char *name) {
LLDB_RECORD_METHOD(const char *, SBEnvironment, Get, (const char *), name);
LLDB_INSTRUMENT_VA(this, name);
auto entry = m_opaque_up->find(name);
if (entry == m_opaque_up->end()) {
@ -57,8 +55,7 @@ const char *SBEnvironment::Get(const char *name) {
}
const char *SBEnvironment::GetNameAtIndex(size_t index) {
LLDB_RECORD_METHOD(const char *, SBEnvironment, GetNameAtIndex, (size_t),
index);
LLDB_INSTRUMENT_VA(this, index);
if (index >= GetNumValues())
return nullptr;
@ -67,8 +64,7 @@ const char *SBEnvironment::GetNameAtIndex(size_t index) {
}
const char *SBEnvironment::GetValueAtIndex(size_t index) {
LLDB_RECORD_METHOD(const char *, SBEnvironment, GetValueAtIndex, (size_t),
index);
LLDB_INSTRUMENT_VA(this, index);
if (index >= GetNumValues())
return nullptr;
@ -77,9 +73,7 @@ const char *SBEnvironment::GetValueAtIndex(size_t index) {
}
bool SBEnvironment::Set(const char *name, const char *value, bool overwrite) {
LLDB_RECORD_METHOD(bool, SBEnvironment, Set,
(const char *, const char *, bool), name, value,
overwrite);
LLDB_INSTRUMENT_VA(this, name, value, overwrite);
if (overwrite) {
m_opaque_up->insert_or_assign(name, std::string(value));
@ -89,13 +83,13 @@ bool SBEnvironment::Set(const char *name, const char *value, bool overwrite) {
}
bool SBEnvironment::Unset(const char *name) {
LLDB_RECORD_METHOD(bool, SBEnvironment, Unset, (const char *), name);
LLDB_INSTRUMENT_VA(this, name);
return m_opaque_up->erase(name);
}
SBStringList SBEnvironment::GetEntries() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStringList, SBEnvironment, GetEntries);
LLDB_INSTRUMENT_VA(this);
SBStringList entries;
for (const auto &KV : *m_opaque_up) {
@ -105,16 +99,14 @@ SBStringList SBEnvironment::GetEntries() {
}
void SBEnvironment::PutEntry(const char *name_and_value) {
LLDB_RECORD_METHOD(void, SBEnvironment, PutEntry, (const char *),
name_and_value);
LLDB_INSTRUMENT_VA(this, name_and_value);
auto split = llvm::StringRef(name_and_value).split('=');
m_opaque_up->insert_or_assign(split.first.str(), split.second.str());
}
void SBEnvironment::SetEntries(const SBStringList &entries, bool append) {
LLDB_RECORD_METHOD(void, SBEnvironment, SetEntries,
(const lldb::SBStringList &, bool), entries, append);
LLDB_INSTRUMENT_VA(this, entries, append);
if (!append)
m_opaque_up->clear();
@ -124,7 +116,7 @@ void SBEnvironment::SetEntries(const SBStringList &entries, bool append) {
}
void SBEnvironment::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBEnvironment, Clear);
LLDB_INSTRUMENT_VA(this);
m_opaque_up->clear();
}

38
lldb/source/API/SBError.cpp
View file

@ -7,9 +7,9 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBError.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/API/SBStream.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/Status.h"
#include <cstdarg>
@ -17,10 +17,10 @@
using namespace lldb;
using namespace lldb_private;
SBError::SBError() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBError); }
SBError::SBError() { LLDB_INSTRUMENT_VA(this); }
SBError::SBError(const SBError &rhs) {
LLDB_RECORD_CONSTRUCTOR(SBError, (const lldb::SBError &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_up = clone(rhs.m_opaque_up);
}
@ -28,8 +28,7 @@ SBError::SBError(const SBError &rhs) {
SBError::~SBError() = default;
const SBError &SBError::operator=(const SBError &rhs) {
LLDB_RECORD_METHOD(const lldb::SBError &,
SBError, operator=,(const lldb::SBError &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
@ -37,7 +36,7 @@ const SBError &SBError::operator=(const SBError &rhs) {
}
const char *SBError::GetCString() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBError, GetCString);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_up)
return m_opaque_up->AsCString();
@ -45,14 +44,14 @@ const char *SBError::GetCString() const {
}
void SBError::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBError, Clear);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_up)
m_opaque_up->Clear();
}
bool SBError::Fail() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, Fail);
LLDB_INSTRUMENT_VA(this);
bool ret_value = false;
if (m_opaque_up)
@ -63,7 +62,7 @@ bool SBError::Fail() const {
}
bool SBError::Success() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, Success);
LLDB_INSTRUMENT_VA(this);
bool ret_value = true;
if (m_opaque_up)
@ -73,8 +72,7 @@ bool SBError::Success() const {
}
uint32_t SBError::GetError() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBError, GetError);
LLDB_INSTRUMENT_VA(this);
uint32_t err = 0;
if (m_opaque_up)
@ -85,7 +83,7 @@ uint32_t SBError::GetError() const {
}
ErrorType SBError::GetType() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ErrorType, SBError, GetType);
LLDB_INSTRUMENT_VA(this);
ErrorType err_type = eErrorTypeInvalid;
if (m_opaque_up)
@ -95,8 +93,7 @@ ErrorType SBError::GetType() const {
}
void SBError::SetError(uint32_t err, ErrorType type) {
LLDB_RECORD_METHOD(void, SBError, SetError, (uint32_t, lldb::ErrorType), err,
type);
LLDB_INSTRUMENT_VA(this, err, type);
CreateIfNeeded();
m_opaque_up->SetError(err, type);
@ -108,21 +105,21 @@ void SBError::SetError(const Status &lldb_error) {
}
void SBError::SetErrorToErrno() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBError, SetErrorToErrno);
LLDB_INSTRUMENT_VA(this);
CreateIfNeeded();
m_opaque_up->SetErrorToErrno();
}
void SBError::SetErrorToGenericError() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBError, SetErrorToGenericError);
LLDB_INSTRUMENT_VA(this);
CreateIfNeeded();
m_opaque_up->SetErrorToGenericError();
}
void SBError::SetErrorString(const char *err_str) {
LLDB_RECORD_METHOD(void, SBError, SetErrorString, (const char *), err_str);
LLDB_INSTRUMENT_VA(this, err_str);
CreateIfNeeded();
m_opaque_up->SetErrorString(err_str);
@ -138,11 +135,11 @@ int SBError::SetErrorStringWithFormat(const char *format, ...) {
}
bool SBError::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBError::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up != nullptr;
}
@ -167,8 +164,7 @@ const lldb_private::Status &SBError::operator*() const {
}
bool SBError::GetDescription(SBStream &description) {
LLDB_RECORD_METHOD(bool, SBError, GetDescription, (lldb::SBStream &),
description);
LLDB_INSTRUMENT_VA(this, description);
if (m_opaque_up) {
if (m_opaque_up->Success())

47
lldb/source/API/SBEvent.cpp
View file

@ -7,9 +7,9 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBEvent.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBBroadcaster.h"
#include "lldb/API/SBStream.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/Breakpoint/Breakpoint.h"
#include "lldb/Core/StreamFile.h"
@ -22,32 +22,30 @@
using namespace lldb;
using namespace lldb_private;
SBEvent::SBEvent() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBEvent); }
SBEvent::SBEvent() { LLDB_INSTRUMENT_VA(this); }
SBEvent::SBEvent(uint32_t event_type, const char *cstr, uint32_t cstr_len)
: m_event_sp(new Event(event_type, new EventDataBytes(cstr, cstr_len))),
m_opaque_ptr(m_event_sp.get()) {
LLDB_RECORD_CONSTRUCTOR(SBEvent, (uint32_t, const char *, uint32_t),
event_type, cstr, cstr_len);
LLDB_INSTRUMENT_VA(this, event_type, cstr, cstr_len);
}
SBEvent::SBEvent(EventSP &event_sp)
: m_event_sp(event_sp), m_opaque_ptr(event_sp.get()) {
LLDB_RECORD_CONSTRUCTOR(SBEvent, (lldb::EventSP &), event_sp);
LLDB_INSTRUMENT_VA(this, event_sp);
}
SBEvent::SBEvent(Event *event_ptr) : m_opaque_ptr(event_ptr) {
LLDB_RECORD_CONSTRUCTOR(SBEvent, (lldb_private::Event *), event_ptr);
LLDB_INSTRUMENT_VA(this, event_ptr);
}
SBEvent::SBEvent(const SBEvent &rhs)
: m_event_sp(rhs.m_event_sp), m_opaque_ptr(rhs.m_opaque_ptr) {
LLDB_RECORD_CONSTRUCTOR(SBEvent, (const lldb::SBEvent &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
}
const SBEvent &SBEvent::operator=(const SBEvent &rhs) {
LLDB_RECORD_METHOD(const lldb::SBEvent &,
SBEvent, operator=,(const lldb::SBEvent &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
m_event_sp = rhs.m_event_sp;
@ -59,7 +57,7 @@ const SBEvent &SBEvent::operator=(const SBEvent &rhs) {
SBEvent::~SBEvent() = default;
const char *SBEvent::GetDataFlavor() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBEvent, GetDataFlavor);
LLDB_INSTRUMENT_VA(this);
Event *lldb_event = get();
if (lldb_event) {
@ -71,8 +69,7 @@ const char *SBEvent::GetDataFlavor() {
}
uint32_t SBEvent::GetType() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBEvent, GetType);
LLDB_INSTRUMENT_VA(this);
const Event *lldb_event = get();
uint32_t event_type = 0;
@ -84,8 +81,7 @@ uint32_t SBEvent::GetType() const {
}
SBBroadcaster SBEvent::GetBroadcaster() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBEvent,
GetBroadcaster);
LLDB_INSTRUMENT_VA(this);
SBBroadcaster broadcaster;
const Event *lldb_event = get();
@ -95,7 +91,7 @@ SBBroadcaster SBEvent::GetBroadcaster() const {
}
const char *SBEvent::GetBroadcasterClass() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBEvent, GetBroadcasterClass);
LLDB_INSTRUMENT_VA(this);
const Event *lldb_event = get();
if (lldb_event)
@ -105,8 +101,7 @@ const char *SBEvent::GetBroadcasterClass() const {
}
bool SBEvent::BroadcasterMatchesPtr(const SBBroadcaster *broadcaster) {
LLDB_RECORD_METHOD(bool, SBEvent, BroadcasterMatchesPtr,
(const lldb::SBBroadcaster *), broadcaster);
LLDB_INSTRUMENT_VA(this, broadcaster);
if (broadcaster)
return BroadcasterMatchesRef(*broadcaster);
@ -114,8 +109,7 @@ bool SBEvent::BroadcasterMatchesPtr(const SBBroadcaster *broadcaster) {
}
bool SBEvent::BroadcasterMatchesRef(const SBBroadcaster &broadcaster) {
LLDB_RECORD_METHOD(bool, SBEvent, BroadcasterMatchesRef,
(const lldb::SBBroadcaster &), broadcaster);
LLDB_INSTRUMENT_VA(this, broadcaster);
Event *lldb_event = get();
bool success = false;
@ -127,7 +121,7 @@ bool SBEvent::BroadcasterMatchesRef(const SBBroadcaster &broadcaster) {
}
void SBEvent::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBEvent, Clear);
LLDB_INSTRUMENT_VA(this);
Event *lldb_event = get();
if (lldb_event)
@ -158,11 +152,11 @@ void SBEvent::reset(Event *event_ptr) {
}
bool SBEvent::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBEvent, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBEvent::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBEvent, operator bool);
LLDB_INSTRUMENT_VA(this);
// Do NOT use m_opaque_ptr directly!!! Must use the SBEvent::get() accessor.
// See comments in SBEvent::get()....
@ -170,16 +164,14 @@ SBEvent::operator bool() const {
}
const char *SBEvent::GetCStringFromEvent(const SBEvent &event) {
LLDB_RECORD_STATIC_METHOD(const char *, SBEvent, GetCStringFromEvent,
(const lldb::SBEvent &), event);
LLDB_INSTRUMENT_VA(event);
return static_cast<const char *>(
EventDataBytes::GetBytesFromEvent(event.get()));
}
bool SBEvent::GetDescription(SBStream &description) {
LLDB_RECORD_METHOD(bool, SBEvent, GetDescription, (lldb::SBStream &),
description);
LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();
@ -192,8 +184,7 @@ bool SBEvent::GetDescription(SBStream &description) {
}
bool SBEvent::GetDescription(SBStream &description) const {
LLDB_RECORD_METHOD_CONST(bool, SBEvent, GetDescription, (lldb::SBStream &),
description);
LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();

36
lldb/source/API/SBExecutionContext.cpp
View file

@ -7,7 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBExecutionContext.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/API/SBFrame.h"
#include "lldb/API/SBProcess.h"
@ -19,48 +19,43 @@
using namespace lldb;
using namespace lldb_private;
SBExecutionContext::SBExecutionContext() {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBExecutionContext);
}
SBExecutionContext::SBExecutionContext() { LLDB_INSTRUMENT_VA(this); }
SBExecutionContext::SBExecutionContext(const lldb::SBExecutionContext &rhs)
: m_exe_ctx_sp(rhs.m_exe_ctx_sp) {
LLDB_RECORD_CONSTRUCTOR(SBExecutionContext,
(const lldb::SBExecutionContext &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
}
SBExecutionContext::SBExecutionContext(
lldb::ExecutionContextRefSP exe_ctx_ref_sp)
: m_exe_ctx_sp(exe_ctx_ref_sp) {
LLDB_RECORD_CONSTRUCTOR(SBExecutionContext, (lldb::ExecutionContextRefSP),
exe_ctx_ref_sp);
LLDB_INSTRUMENT_VA(this, exe_ctx_ref_sp);
}
SBExecutionContext::SBExecutionContext(const lldb::SBTarget &target)
: m_exe_ctx_sp(new ExecutionContextRef()) {
LLDB_RECORD_CONSTRUCTOR(SBExecutionContext, (const lldb::SBTarget &), target);
LLDB_INSTRUMENT_VA(this, target);
m_exe_ctx_sp->SetTargetSP(target.GetSP());
}
SBExecutionContext::SBExecutionContext(const lldb::SBProcess &process)
: m_exe_ctx_sp(new ExecutionContextRef()) {
LLDB_RECORD_CONSTRUCTOR(SBExecutionContext, (const lldb::SBProcess &),
process);
LLDB_INSTRUMENT_VA(this, process);
m_exe_ctx_sp->SetProcessSP(process.GetSP());
}
SBExecutionContext::SBExecutionContext(lldb::SBThread thread)
: m_exe_ctx_sp(new ExecutionContextRef()) {
LLDB_RECORD_CONSTRUCTOR(SBExecutionContext, (lldb::SBThread), thread);
LLDB_INSTRUMENT_VA(this, thread);
m_exe_ctx_sp->SetThreadPtr(thread.get());
}
SBExecutionContext::SBExecutionContext(const lldb::SBFrame &frame)
: m_exe_ctx_sp(new ExecutionContextRef()) {
LLDB_RECORD_CONSTRUCTOR(SBExecutionContext, (const lldb::SBFrame &), frame);
LLDB_INSTRUMENT_VA(this, frame);
m_exe_ctx_sp->SetFrameSP(frame.GetFrameSP());
}
@ -69,9 +64,7 @@ SBExecutionContext::~SBExecutionContext() = default;
const SBExecutionContext &SBExecutionContext::
operator=(const lldb::SBExecutionContext &rhs) {
LLDB_RECORD_METHOD(
const lldb::SBExecutionContext &,
SBExecutionContext, operator=,(const lldb::SBExecutionContext &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
m_exe_ctx_sp = rhs.m_exe_ctx_sp;
return *this;
@ -82,8 +75,7 @@ ExecutionContextRef *SBExecutionContext::get() const {
}
SBTarget SBExecutionContext::GetTarget() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBTarget, SBExecutionContext,
GetTarget);
LLDB_INSTRUMENT_VA(this);
SBTarget sb_target;
if (m_exe_ctx_sp) {
@ -95,8 +87,7 @@ SBTarget SBExecutionContext::GetTarget() const {
}
SBProcess SBExecutionContext::GetProcess() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBProcess, SBExecutionContext,
GetProcess);
LLDB_INSTRUMENT_VA(this);
SBProcess sb_process;
if (m_exe_ctx_sp) {
@ -108,8 +99,7 @@ SBProcess SBExecutionContext::GetProcess() const {
}
SBThread SBExecutionContext::GetThread() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBExecutionContext,
GetThread);
LLDB_INSTRUMENT_VA(this);
SBThread sb_thread;
if (m_exe_ctx_sp) {
@ -121,7 +111,7 @@ SBThread SBExecutionContext::GetThread() const {
}
SBFrame SBExecutionContext::GetFrame() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFrame, SBExecutionContext, GetFrame);
LLDB_INSTRUMENT_VA(this);
SBFrame sb_frame;
if (m_exe_ctx_sp) {

103
lldb/source/API/SBExpressionOptions.cpp
View file

@ -7,31 +7,28 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBExpressionOptions.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/API/SBStream.h"
#include "lldb/Target/Target.h"
#include "lldb/Utility/Instrumentation.h"
using namespace lldb;
using namespace lldb_private;
SBExpressionOptions::SBExpressionOptions()
: m_opaque_up(new EvaluateExpressionOptions()) {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBExpressionOptions);
LLDB_INSTRUMENT_VA(this);
}
SBExpressionOptions::SBExpressionOptions(const SBExpressionOptions &rhs) {
LLDB_RECORD_CONSTRUCTOR(SBExpressionOptions,
(const lldb::SBExpressionOptions &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_up = clone(rhs.m_opaque_up);
}
const SBExpressionOptions &SBExpressionOptions::
operator=(const SBExpressionOptions &rhs) {
LLDB_RECORD_METHOD(
const lldb::SBExpressionOptions &,
SBExpressionOptions, operator=,(const lldb::SBExpressionOptions &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
@ -41,78 +38,68 @@ operator=(const SBExpressionOptions &rhs) {
SBExpressionOptions::~SBExpressionOptions() = default;
bool SBExpressionOptions::GetCoerceResultToId() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions,
GetCoerceResultToId);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->DoesCoerceToId();
}
void SBExpressionOptions::SetCoerceResultToId(bool coerce) {
LLDB_RECORD_METHOD(void, SBExpressionOptions, SetCoerceResultToId, (bool),
coerce);
LLDB_INSTRUMENT_VA(this, coerce);
m_opaque_up->SetCoerceToId(coerce);
}
bool SBExpressionOptions::GetUnwindOnError() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, GetUnwindOnError);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->DoesUnwindOnError();
}
void SBExpressionOptions::SetUnwindOnError(bool unwind) {
LLDB_RECORD_METHOD(void, SBExpressionOptions, SetUnwindOnError, (bool),
unwind);
LLDB_INSTRUMENT_VA(this, unwind);
m_opaque_up->SetUnwindOnError(unwind);
}
bool SBExpressionOptions::GetIgnoreBreakpoints() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions,
GetIgnoreBreakpoints);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->DoesIgnoreBreakpoints();
}
void SBExpressionOptions::SetIgnoreBreakpoints(bool ignore) {
LLDB_RECORD_METHOD(void, SBExpressionOptions, SetIgnoreBreakpoints, (bool),
ignore);
LLDB_INSTRUMENT_VA(this, ignore);
m_opaque_up->SetIgnoreBreakpoints(ignore);
}
lldb::DynamicValueType SBExpressionOptions::GetFetchDynamicValue() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::DynamicValueType, SBExpressionOptions,
GetFetchDynamicValue);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetUseDynamic();
}
void SBExpressionOptions::SetFetchDynamicValue(lldb::DynamicValueType dynamic) {
LLDB_RECORD_METHOD(void, SBExpressionOptions, SetFetchDynamicValue,
(lldb::DynamicValueType), dynamic);
LLDB_INSTRUMENT_VA(this, dynamic);
m_opaque_up->SetUseDynamic(dynamic);
}
uint32_t SBExpressionOptions::GetTimeoutInMicroSeconds() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBExpressionOptions,
GetTimeoutInMicroSeconds);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetTimeout() ? m_opaque_up->GetTimeout()->count() : 0;
}
void SBExpressionOptions::SetTimeoutInMicroSeconds(uint32_t timeout) {
LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTimeoutInMicroSeconds,
(uint32_t), timeout);
LLDB_INSTRUMENT_VA(this, timeout);
m_opaque_up->SetTimeout(timeout == 0 ? Timeout<std::micro>(llvm::None)
: std::chrono::microseconds(timeout));
}
uint32_t SBExpressionOptions::GetOneThreadTimeoutInMicroSeconds() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBExpressionOptions,
GetOneThreadTimeoutInMicroSeconds);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetOneThreadTimeout()
? m_opaque_up->GetOneThreadTimeout()->count()
@ -120,8 +107,7 @@ uint32_t SBExpressionOptions::GetOneThreadTimeoutInMicroSeconds() const {
}
void SBExpressionOptions::SetOneThreadTimeoutInMicroSeconds(uint32_t timeout) {
LLDB_RECORD_METHOD(void, SBExpressionOptions,
SetOneThreadTimeoutInMicroSeconds, (uint32_t), timeout);
LLDB_INSTRUMENT_VA(this, timeout);
m_opaque_up->SetOneThreadTimeout(timeout == 0
? Timeout<std::micro>(llvm::None)
@ -129,148 +115,135 @@ void SBExpressionOptions::SetOneThreadTimeoutInMicroSeconds(uint32_t timeout) {
}
bool SBExpressionOptions::GetTryAllThreads() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, GetTryAllThreads);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetTryAllThreads();
}
void SBExpressionOptions::SetTryAllThreads(bool run_others) {
LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTryAllThreads, (bool),
run_others);
LLDB_INSTRUMENT_VA(this, run_others);
m_opaque_up->SetTryAllThreads(run_others);
}
bool SBExpressionOptions::GetStopOthers() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, GetStopOthers);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetStopOthers();
}
void SBExpressionOptions::SetStopOthers(bool run_others) {
LLDB_RECORD_METHOD(void, SBExpressionOptions, SetStopOthers, (bool),
run_others);
LLDB_INSTRUMENT_VA(this, run_others);
m_opaque_up->SetStopOthers(run_others);
}
bool SBExpressionOptions::GetTrapExceptions() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions,
GetTrapExceptions);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetTrapExceptions();
}
void SBExpressionOptions::SetTrapExceptions(bool trap_exceptions) {
LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTrapExceptions, (bool),
trap_exceptions);
LLDB_INSTRUMENT_VA(this, trap_exceptions);
m_opaque_up->SetTrapExceptions(trap_exceptions);
}
void SBExpressionOptions::SetLanguage(lldb::LanguageType language) {
LLDB_RECORD_METHOD(void, SBExpressionOptions, SetLanguage,
(lldb::LanguageType), language);
LLDB_INSTRUMENT_VA(this, language);
m_opaque_up->SetLanguage(language);
}
void SBExpressionOptions::SetCancelCallback(
lldb::ExpressionCancelCallback callback, void *baton) {
LLDB_RECORD_METHOD(void, SBExpressionOptions, SetCancelCallback,
(lldb::ExpressionCancelCallback, void *), callback, baton);
LLDB_INSTRUMENT_VA(this, callback, baton);
m_opaque_up->SetCancelCallback(callback, baton);
}
bool SBExpressionOptions::GetGenerateDebugInfo() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetGenerateDebugInfo);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetGenerateDebugInfo();
}
void SBExpressionOptions::SetGenerateDebugInfo(bool b) {
LLDB_RECORD_METHOD(void, SBExpressionOptions, SetGenerateDebugInfo, (bool),
b);
LLDB_INSTRUMENT_VA(this, b);
return m_opaque_up->SetGenerateDebugInfo(b);
}
bool SBExpressionOptions::GetSuppressPersistentResult() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions,
GetSuppressPersistentResult);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetResultIsInternal();
}
void SBExpressionOptions::SetSuppressPersistentResult(bool b) {
LLDB_RECORD_METHOD(void, SBExpressionOptions, SetSuppressPersistentResult,
(bool), b);
LLDB_INSTRUMENT_VA(this, b);
return m_opaque_up->SetResultIsInternal(b);
}
const char *SBExpressionOptions::GetPrefix() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBExpressionOptions,
GetPrefix);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetPrefix();
}
void SBExpressionOptions::SetPrefix(const char *prefix) {
LLDB_RECORD_METHOD(void, SBExpressionOptions, SetPrefix, (const char *),
prefix);
LLDB_INSTRUMENT_VA(this, prefix);
return m_opaque_up->SetPrefix(prefix);
}
bool SBExpressionOptions::GetAutoApplyFixIts() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetAutoApplyFixIts);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetAutoApplyFixIts();
}
void SBExpressionOptions::SetAutoApplyFixIts(bool b) {
LLDB_RECORD_METHOD(void, SBExpressionOptions, SetAutoApplyFixIts, (bool), b);
LLDB_INSTRUMENT_VA(this, b);
return m_opaque_up->SetAutoApplyFixIts(b);
}
uint64_t SBExpressionOptions::GetRetriesWithFixIts() {
LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBExpressionOptions,
GetRetriesWithFixIts);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetRetriesWithFixIts();
}
void SBExpressionOptions::SetRetriesWithFixIts(uint64_t retries) {
LLDB_RECORD_METHOD(void, SBExpressionOptions, SetRetriesWithFixIts,
(uint64_t), retries);
LLDB_INSTRUMENT_VA(this, retries);
return m_opaque_up->SetRetriesWithFixIts(retries);
}
bool SBExpressionOptions::GetTopLevel() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetTopLevel);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetExecutionPolicy() == eExecutionPolicyTopLevel;
}
void SBExpressionOptions::SetTopLevel(bool b) {
LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTopLevel, (bool), b);
LLDB_INSTRUMENT_VA(this, b);
m_opaque_up->SetExecutionPolicy(b ? eExecutionPolicyTopLevel
: m_opaque_up->default_execution_policy);
}
bool SBExpressionOptions::GetAllowJIT() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetAllowJIT);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetExecutionPolicy() != eExecutionPolicyNever;
}
void SBExpressionOptions::SetAllowJIT(bool allow) {
LLDB_RECORD_METHOD(void, SBExpressionOptions, SetAllowJIT, (bool), allow);
LLDB_INSTRUMENT_VA(this, allow);
m_opaque_up->SetExecutionPolicy(allow ? m_opaque_up->default_execution_policy
: eExecutionPolicyNever);

35
lldb/source/API/SBFile.cpp
View file

@ -7,9 +7,9 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBFile.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBError.h"
#include "lldb/Host/File.h"
#include "lldb/Utility/Instrumentation.h"
using namespace lldb;
using namespace lldb_private;
@ -19,33 +19,31 @@ SBFile::~SBFile() = default;
SBFile::SBFile(FileSP file_sp) : m_opaque_sp(file_sp) {
// We have no way to capture the incoming FileSP as the class isn't
// instrumented, so pretend that it's always null.
LLDB_RECORD_CONSTRUCTOR(SBFile, (lldb::FileSP), nullptr);
LLDB_INSTRUMENT_VA(this, file_sp);
}
SBFile::SBFile(const SBFile &rhs) : m_opaque_sp(rhs.m_opaque_sp) {
LLDB_RECORD_CONSTRUCTOR(SBFile, (const lldb::SBFile&), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
}
SBFile &SBFile ::operator=(const SBFile &rhs) {
LLDB_RECORD_METHOD(lldb::SBFile &,
SBFile, operator=,(const lldb::SBFile &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_sp = rhs.m_opaque_sp;
return *this;
}
SBFile::SBFile() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFile); }
SBFile::SBFile() { LLDB_INSTRUMENT_VA(this); }
SBFile::SBFile(FILE *file, bool transfer_ownership) {
LLDB_RECORD_CONSTRUCTOR(SBFile, (FILE *, bool), file, transfer_ownership);
LLDB_INSTRUMENT_VA(this, file, transfer_ownership);
m_opaque_sp = std::make_shared<NativeFile>(file, transfer_ownership);
}
SBFile::SBFile(int fd, const char *mode, bool transfer_owndership) {
LLDB_RECORD_CONSTRUCTOR(SBFile, (int, const char *, bool), fd, mode,
transfer_owndership);
LLDB_INSTRUMENT_VA(this, fd, mode, transfer_owndership);
auto options = File::GetOptionsFromMode(mode);
if (!options) {
@ -57,8 +55,7 @@ SBFile::SBFile(int fd, const char *mode, bool transfer_owndership) {
}
SBError SBFile::Read(uint8_t *buf, size_t num_bytes, size_t *bytes_read) {
LLDB_RECORD_METHOD(lldb::SBError, SBFile, Read, (uint8_t *, size_t, size_t *),
buf, num_bytes, bytes_read);
LLDB_INSTRUMENT_VA(this, buf, num_bytes, bytes_read);
SBError error;
if (!m_opaque_sp) {
@ -74,9 +71,7 @@ SBError SBFile::Read(uint8_t *buf, size_t num_bytes, size_t *bytes_read) {
SBError SBFile::Write(const uint8_t *buf, size_t num_bytes,
size_t *bytes_written) {
LLDB_RECORD_METHOD(lldb::SBError, SBFile, Write,
(const uint8_t *, size_t, size_t *), buf, num_bytes,
bytes_written);
LLDB_INSTRUMENT_VA(this, buf, num_bytes, bytes_written);
SBError error;
if (!m_opaque_sp) {
@ -91,7 +86,7 @@ SBError SBFile::Write(const uint8_t *buf, size_t num_bytes,
}
SBError SBFile::Flush() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBFile, Flush);
LLDB_INSTRUMENT_VA(this);
SBError error;
if (!m_opaque_sp) {
@ -104,12 +99,12 @@ SBError SBFile::Flush() {
}
bool SBFile::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFile, IsValid);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp && m_opaque_sp->IsValid();
}
SBError SBFile::Close() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBFile, Close);
LLDB_INSTRUMENT_VA(this);
SBError error;
if (m_opaque_sp) {
Status status = m_opaque_sp->Close();
@ -119,16 +114,16 @@ SBError SBFile::Close() {
}
SBFile::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFile, operator bool);
LLDB_INSTRUMENT_VA(this);
return IsValid();
}
bool SBFile::operator!() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFile, operator!);
LLDB_INSTRUMENT_VA(this);
return !IsValid();
}
FileSP SBFile::GetFile() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(FileSP, SBFile, GetFile);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp;
}

47
lldb/source/API/SBFileSpec.cpp
View file

@ -7,12 +7,12 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBFileSpec.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/API/SBStream.h"
#include "lldb/Host/FileSystem.h"
#include "lldb/Host/PosixApi.h"
#include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/Stream.h"
#include "llvm/ADT/SmallString.h"
@ -24,11 +24,11 @@ using namespace lldb;
using namespace lldb_private;
SBFileSpec::SBFileSpec() : m_opaque_up(new lldb_private::FileSpec()) {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFileSpec);
LLDB_INSTRUMENT_VA(this);
}
SBFileSpec::SBFileSpec(const SBFileSpec &rhs) {
LLDB_RECORD_CONSTRUCTOR(SBFileSpec, (const lldb::SBFileSpec &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_up = clone(rhs.m_opaque_up);
}
@ -38,14 +38,14 @@ SBFileSpec::SBFileSpec(const lldb_private::FileSpec &fspec)
// Deprecated!!!
SBFileSpec::SBFileSpec(const char *path) : m_opaque_up(new FileSpec(path)) {
LLDB_RECORD_CONSTRUCTOR(SBFileSpec, (const char *), path);
LLDB_INSTRUMENT_VA(this, path);
FileSystem::Instance().Resolve(*m_opaque_up);
}
SBFileSpec::SBFileSpec(const char *path, bool resolve)
: m_opaque_up(new FileSpec(path)) {
LLDB_RECORD_CONSTRUCTOR(SBFileSpec, (const char *, bool), path, resolve);
LLDB_INSTRUMENT_VA(this, path, resolve);
if (resolve)
FileSystem::Instance().Resolve(*m_opaque_up);
@ -54,8 +54,7 @@ SBFileSpec::SBFileSpec(const char *path, bool resolve)
SBFileSpec::~SBFileSpec() = default;
const SBFileSpec &SBFileSpec::operator=(const SBFileSpec &rhs) {
LLDB_RECORD_METHOD(const lldb::SBFileSpec &,
SBFileSpec, operator=,(const lldb::SBFileSpec &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
@ -63,46 +62,42 @@ const SBFileSpec &SBFileSpec::operator=(const SBFileSpec &rhs) {
}
bool SBFileSpec::operator==(const SBFileSpec &rhs) const {
LLDB_RECORD_METHOD_CONST(bool, SBFileSpec, operator==,(const SBFileSpec &rhs),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
return ref() == rhs.ref();
}
bool SBFileSpec::operator!=(const SBFileSpec &rhs) const {
LLDB_RECORD_METHOD_CONST(bool, SBFileSpec, operator!=,(const SBFileSpec &rhs),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
return !(*this == rhs);
}
bool SBFileSpec::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFileSpec, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBFileSpec::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFileSpec, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->operator bool();
}
bool SBFileSpec::Exists() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFileSpec, Exists);
LLDB_INSTRUMENT_VA(this);
return FileSystem::Instance().Exists(*m_opaque_up);
}
bool SBFileSpec::ResolveExecutableLocation() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBFileSpec, ResolveExecutableLocation);
LLDB_INSTRUMENT_VA(this);
return FileSystem::Instance().ResolveExecutableLocation(*m_opaque_up);
}
int SBFileSpec::ResolvePath(const char *src_path, char *dst_path,
size_t dst_len) {
LLDB_RECORD_STATIC_METHOD(int, SBFileSpec, ResolvePath,
(const char *, char *, size_t), src_path, dst_path,
dst_len);
LLDB_INSTRUMENT_VA(src_path, dst_path, dst_len);
llvm::SmallString<64> result(src_path);
FileSystem::Instance().Resolve(result);
@ -111,13 +106,13 @@ int SBFileSpec::ResolvePath(const char *src_path, char *dst_path,
}
const char *SBFileSpec::GetFilename() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFileSpec, GetFilename);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetFilename().AsCString();
}
const char *SBFileSpec::GetDirectory() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFileSpec, GetDirectory);
LLDB_INSTRUMENT_VA(this);
FileSpec directory{*m_opaque_up};
directory.GetFilename().Clear();
@ -125,7 +120,7 @@ const char *SBFileSpec::GetDirectory() const {
}
void SBFileSpec::SetFilename(const char *filename) {
LLDB_RECORD_METHOD(void, SBFileSpec, SetFilename, (const char *), filename);
LLDB_INSTRUMENT_VA(this, filename);
if (filename && filename[0])
m_opaque_up->GetFilename().SetCString(filename);
@ -134,7 +129,7 @@ void SBFileSpec::SetFilename(const char *filename) {
}
void SBFileSpec::SetDirectory(const char *directory) {
LLDB_RECORD_METHOD(void, SBFileSpec, SetDirectory, (const char *), directory);
LLDB_INSTRUMENT_VA(this, directory);
if (directory && directory[0])
m_opaque_up->GetDirectory().SetCString(directory);
@ -143,8 +138,7 @@ void SBFileSpec::SetDirectory(const char *directory) {
}
uint32_t SBFileSpec::GetPath(char *dst_path, size_t dst_len) const {
LLDB_RECORD_METHOD_CONST(uint32_t, SBFileSpec, GetPath, (char *, size_t),
dst_path, "", dst_len);
LLDB_INSTRUMENT_VA(this, dst_path, dst_len);
uint32_t result = m_opaque_up->GetPath(dst_path, dst_len);
@ -172,8 +166,7 @@ void SBFileSpec::SetFileSpec(const lldb_private::FileSpec &fs) {
}
bool SBFileSpec::GetDescription(SBStream &description) const {
LLDB_RECORD_METHOD_CONST(bool, SBFileSpec, GetDescription, (lldb::SBStream &),
description);
LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();
char path[PATH_MAX];
@ -183,7 +176,7 @@ bool SBFileSpec::GetDescription(SBStream &description) const {
}
void SBFileSpec::AppendPathComponent(const char *fn) {
LLDB_RECORD_METHOD(void, SBFileSpec, AppendPathComponent, (const char *), fn);
LLDB_INSTRUMENT_VA(this, fn);
m_opaque_up->AppendPathComponent(fn);
}

30
lldb/source/API/SBFileSpecList.cpp
View file

@ -7,13 +7,13 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBFileSpecList.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/API/SBFileSpec.h"
#include "lldb/API/SBStream.h"
#include "lldb/Core/FileSpecList.h"
#include "lldb/Host/PosixApi.h"
#include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/Stream.h"
#include <climits>
@ -22,11 +22,11 @@ using namespace lldb;
using namespace lldb_private;
SBFileSpecList::SBFileSpecList() : m_opaque_up(new FileSpecList()) {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFileSpecList);
LLDB_INSTRUMENT_VA(this);
}
SBFileSpecList::SBFileSpecList(const SBFileSpecList &rhs) {
LLDB_RECORD_CONSTRUCTOR(SBFileSpecList, (const lldb::SBFileSpecList &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_up = clone(rhs.m_opaque_up);
}
@ -34,9 +34,7 @@ SBFileSpecList::SBFileSpecList(const SBFileSpecList &rhs) {
SBFileSpecList::~SBFileSpecList() = default;
const SBFileSpecList &SBFileSpecList::operator=(const SBFileSpecList &rhs) {
LLDB_RECORD_METHOD(const lldb::SBFileSpecList &,
SBFileSpecList, operator=,(const lldb::SBFileSpecList &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
@ -44,43 +42,38 @@ const SBFileSpecList &SBFileSpecList::operator=(const SBFileSpecList &rhs) {
}
uint32_t SBFileSpecList::GetSize() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBFileSpecList, GetSize);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetSize();
}
void SBFileSpecList::Append(const SBFileSpec &sb_file) {
LLDB_RECORD_METHOD(void, SBFileSpecList, Append, (const lldb::SBFileSpec &),
sb_file);
LLDB_INSTRUMENT_VA(this, sb_file);
m_opaque_up->Append(sb_file.ref());
}
bool SBFileSpecList::AppendIfUnique(const SBFileSpec &sb_file) {
LLDB_RECORD_METHOD(bool, SBFileSpecList, AppendIfUnique,
(const lldb::SBFileSpec &), sb_file);
LLDB_INSTRUMENT_VA(this, sb_file);
return m_opaque_up->AppendIfUnique(sb_file.ref());
}
void SBFileSpecList::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBFileSpecList, Clear);
LLDB_INSTRUMENT_VA(this);
m_opaque_up->Clear();
}
uint32_t SBFileSpecList::FindFileIndex(uint32_t idx, const SBFileSpec &sb_file,
bool full) {
LLDB_RECORD_METHOD(uint32_t, SBFileSpecList, FindFileIndex,
(uint32_t, const lldb::SBFileSpec &, bool), idx, sb_file,
full);
LLDB_INSTRUMENT_VA(this, idx, sb_file, full);
return m_opaque_up->FindFileIndex(idx, sb_file.ref(), full);
}
const SBFileSpec SBFileSpecList::GetFileSpecAtIndex(uint32_t idx) const {
LLDB_RECORD_METHOD_CONST(const lldb::SBFileSpec, SBFileSpecList,
GetFileSpecAtIndex, (uint32_t), idx);
LLDB_INSTRUMENT_VA(this, idx);
SBFileSpec new_spec;
new_spec.SetFileSpec(m_opaque_up->GetFileSpecAtIndex(idx));
@ -104,8 +97,7 @@ const lldb_private::FileSpecList &SBFileSpecList::ref() const {
}
bool SBFileSpecList::GetDescription(SBStream &description) const {
LLDB_RECORD_METHOD_CONST(bool, SBFileSpecList, GetDescription,
(lldb::SBStream &), description);
LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();

134
lldb/source/API/SBFrame.cpp
View file

@ -14,7 +14,6 @@
#include "lldb/lldb-types.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/Core/Address.h"
#include "lldb/Core/StreamFile.h"
@ -38,6 +37,7 @@
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/Stream.h"
#include "lldb/API/SBAddress.h"
@ -55,17 +55,16 @@ using namespace lldb;
using namespace lldb_private;
SBFrame::SBFrame() : m_opaque_sp(new ExecutionContextRef()) {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFrame);
LLDB_INSTRUMENT_VA(this);
}
SBFrame::SBFrame(const StackFrameSP &lldb_object_sp)
: m_opaque_sp(new ExecutionContextRef(lldb_object_sp)) {
LLDB_RECORD_CONSTRUCTOR(SBFrame, (const lldb::StackFrameSP &),
lldb_object_sp);
LLDB_INSTRUMENT_VA(this, lldb_object_sp);
}
SBFrame::SBFrame(const SBFrame &rhs) {
LLDB_RECORD_CONSTRUCTOR(SBFrame, (const lldb::SBFrame &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_sp = clone(rhs.m_opaque_sp);
}
@ -73,8 +72,7 @@ SBFrame::SBFrame(const SBFrame &rhs) {
SBFrame::~SBFrame() = default;
const SBFrame &SBFrame::operator=(const SBFrame &rhs) {
LLDB_RECORD_METHOD(const lldb::SBFrame &,
SBFrame, operator=,(const lldb::SBFrame &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_sp = clone(rhs.m_opaque_sp);
@ -90,11 +88,11 @@ void SBFrame::SetFrameSP(const StackFrameSP &lldb_object_sp) {
}
bool SBFrame::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBFrame::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, operator bool);
LLDB_INSTRUMENT_VA(this);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@ -112,8 +110,7 @@ SBFrame::operator bool() const {
}
SBSymbolContext SBFrame::GetSymbolContext(uint32_t resolve_scope) const {
LLDB_RECORD_METHOD_CONST(lldb::SBSymbolContext, SBFrame, GetSymbolContext,
(uint32_t), resolve_scope);
LLDB_INSTRUMENT_VA(this, resolve_scope);
SBSymbolContext sb_sym_ctx;
std::unique_lock<std::recursive_mutex> lock;
@ -133,7 +130,7 @@ SBSymbolContext SBFrame::GetSymbolContext(uint32_t resolve_scope) const {
}
SBModule SBFrame::GetModule() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBModule, SBFrame, GetModule);
LLDB_INSTRUMENT_VA(this);
SBModule sb_module;
ModuleSP module_sp;
@ -158,8 +155,7 @@ SBModule SBFrame::GetModule() const {
}
SBCompileUnit SBFrame::GetCompileUnit() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBCompileUnit, SBFrame,
GetCompileUnit);
LLDB_INSTRUMENT_VA(this);
SBCompileUnit sb_comp_unit;
std::unique_lock<std::recursive_mutex> lock;
@ -183,7 +179,7 @@ SBCompileUnit SBFrame::GetCompileUnit() const {
}
SBFunction SBFrame::GetFunction() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFunction, SBFrame, GetFunction);
LLDB_INSTRUMENT_VA(this);
SBFunction sb_function;
std::unique_lock<std::recursive_mutex> lock;
@ -207,7 +203,7 @@ SBFunction SBFrame::GetFunction() const {
}
SBSymbol SBFrame::GetSymbol() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBSymbol, SBFrame, GetSymbol);
LLDB_INSTRUMENT_VA(this);
SBSymbol sb_symbol;
std::unique_lock<std::recursive_mutex> lock;
@ -230,7 +226,7 @@ SBSymbol SBFrame::GetSymbol() const {
}
SBBlock SBFrame::GetBlock() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBlock, SBFrame, GetBlock);
LLDB_INSTRUMENT_VA(this);
SBBlock sb_block;
std::unique_lock<std::recursive_mutex> lock;
@ -251,7 +247,7 @@ SBBlock SBFrame::GetBlock() const {
}
SBBlock SBFrame::GetFrameBlock() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBlock, SBFrame, GetFrameBlock);
LLDB_INSTRUMENT_VA(this);
SBBlock sb_block;
std::unique_lock<std::recursive_mutex> lock;
@ -272,7 +268,7 @@ SBBlock SBFrame::GetFrameBlock() const {
}
SBLineEntry SBFrame::GetLineEntry() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBLineEntry, SBFrame, GetLineEntry);
LLDB_INSTRUMENT_VA(this);
SBLineEntry sb_line_entry;
std::unique_lock<std::recursive_mutex> lock;
@ -295,7 +291,7 @@ SBLineEntry SBFrame::GetLineEntry() const {
}
uint32_t SBFrame::GetFrameID() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBFrame, GetFrameID);
LLDB_INSTRUMENT_VA(this);
uint32_t frame_idx = UINT32_MAX;
@ -310,7 +306,7 @@ uint32_t SBFrame::GetFrameID() const {
}
lldb::addr_t SBFrame::GetCFA() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetCFA);
LLDB_INSTRUMENT_VA(this);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@ -322,7 +318,7 @@ lldb::addr_t SBFrame::GetCFA() const {
}
addr_t SBFrame::GetPC() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetPC);
LLDB_INSTRUMENT_VA(this);
addr_t addr = LLDB_INVALID_ADDRESS;
std::unique_lock<std::recursive_mutex> lock;
@ -346,7 +342,7 @@ addr_t SBFrame::GetPC() const {
}
bool SBFrame::SetPC(addr_t new_pc) {
LLDB_RECORD_METHOD(bool, SBFrame, SetPC, (lldb::addr_t), new_pc);
LLDB_INSTRUMENT_VA(this, new_pc);
bool ret_val = false;
std::unique_lock<std::recursive_mutex> lock;
@ -369,7 +365,7 @@ bool SBFrame::SetPC(addr_t new_pc) {
}
addr_t SBFrame::GetSP() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetSP);
LLDB_INSTRUMENT_VA(this);
addr_t addr = LLDB_INVALID_ADDRESS;
std::unique_lock<std::recursive_mutex> lock;
@ -392,7 +388,7 @@ addr_t SBFrame::GetSP() const {
}
addr_t SBFrame::GetFP() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetFP);
LLDB_INSTRUMENT_VA(this);
addr_t addr = LLDB_INVALID_ADDRESS;
std::unique_lock<std::recursive_mutex> lock;
@ -415,7 +411,7 @@ addr_t SBFrame::GetFP() const {
}
SBAddress SBFrame::GetPCAddress() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBFrame, GetPCAddress);
LLDB_INSTRUMENT_VA(this);
SBAddress sb_addr;
std::unique_lock<std::recursive_mutex> lock;
@ -436,14 +432,13 @@ SBAddress SBFrame::GetPCAddress() const {
}
void SBFrame::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBFrame, Clear);
LLDB_INSTRUMENT_VA(this);
m_opaque_sp->Clear();
}
lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path) {
LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,
(const char *), var_path);
LLDB_INSTRUMENT_VA(this, var_path);
SBValue sb_value;
std::unique_lock<std::recursive_mutex> lock;
@ -461,9 +456,7 @@ lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path) {
lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path,
DynamicValueType use_dynamic) {
LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,
(const char *, lldb::DynamicValueType), var_path,
use_dynamic);
LLDB_INSTRUMENT_VA(this, var_path, use_dynamic);
SBValue sb_value;
if (var_path == nullptr || var_path[0] == '\0') {
@ -496,8 +489,7 @@ lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path,
}
SBValue SBFrame::FindVariable(const char *name) {
LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindVariable, (const char *),
name);
LLDB_INSTRUMENT_VA(this, name);
SBValue value;
std::unique_lock<std::recursive_mutex> lock;
@ -515,8 +507,7 @@ SBValue SBFrame::FindVariable(const char *name) {
SBValue SBFrame::FindVariable(const char *name,
lldb::DynamicValueType use_dynamic) {
LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindVariable,
(const char *, lldb::DynamicValueType), name, use_dynamic);
LLDB_INSTRUMENT_VA(this, name, use_dynamic);
VariableSP var_sp;
SBValue sb_value;
@ -549,8 +540,7 @@ SBValue SBFrame::FindVariable(const char *name,
}
SBValue SBFrame::FindValue(const char *name, ValueType value_type) {
LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindValue,
(const char *, lldb::ValueType), name, value_type);
LLDB_INSTRUMENT_VA(this, name, value_type);
SBValue value;
std::unique_lock<std::recursive_mutex> lock;
@ -568,9 +558,7 @@ SBValue SBFrame::FindValue(const char *name, ValueType value_type) {
SBValue SBFrame::FindValue(const char *name, ValueType value_type,
lldb::DynamicValueType use_dynamic) {
LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindValue,
(const char *, lldb::ValueType, lldb::DynamicValueType),
name, value_type, use_dynamic);
LLDB_INSTRUMENT_VA(this, name, value_type, use_dynamic);
SBValue sb_value;
@ -682,8 +670,7 @@ SBValue SBFrame::FindValue(const char *name, ValueType value_type,
}
bool SBFrame::IsEqual(const SBFrame &that) const {
LLDB_RECORD_METHOD_CONST(bool, SBFrame, IsEqual, (const lldb::SBFrame &),
that);
LLDB_INSTRUMENT_VA(this, that);
lldb::StackFrameSP this_sp = GetFrameSP();
lldb::StackFrameSP that_sp = that.GetFrameSP();
@ -691,21 +678,19 @@ bool SBFrame::IsEqual(const SBFrame &that) const {
}
bool SBFrame::operator==(const SBFrame &rhs) const {
LLDB_RECORD_METHOD_CONST(bool, SBFrame, operator==,(const lldb::SBFrame &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
return IsEqual(rhs);
}
bool SBFrame::operator!=(const SBFrame &rhs) const {
LLDB_RECORD_METHOD_CONST(bool, SBFrame, operator!=,(const lldb::SBFrame &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
return !IsEqual(rhs);
}
SBThread SBFrame::GetThread() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBFrame, GetThread);
LLDB_INSTRUMENT_VA(this);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@ -717,7 +702,7 @@ SBThread SBFrame::GetThread() const {
}
const char *SBFrame::Disassemble() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFrame, Disassemble);
LLDB_INSTRUMENT_VA(this);
const char *disassembly = nullptr;
std::unique_lock<std::recursive_mutex> lock;
@ -741,9 +726,7 @@ const char *SBFrame::Disassemble() const {
SBValueList SBFrame::GetVariables(bool arguments, bool locals, bool statics,
bool in_scope_only) {
LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables,
(bool, bool, bool, bool), arguments, locals, statics,
in_scope_only);
LLDB_INSTRUMENT_VA(this, arguments, locals, statics, in_scope_only);
SBValueList value_list;
std::unique_lock<std::recursive_mutex> lock;
@ -773,9 +756,8 @@ SBValueList SBFrame::GetVariables(bool arguments, bool locals, bool statics,
lldb::SBValueList SBFrame::GetVariables(bool arguments, bool locals,
bool statics, bool in_scope_only,
lldb::DynamicValueType use_dynamic) {
LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables,
(bool, bool, bool, bool, lldb::DynamicValueType),
arguments, locals, statics, in_scope_only, use_dynamic);
LLDB_INSTRUMENT_VA(this, arguments, locals, statics, in_scope_only,
use_dynamic);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@ -794,8 +776,7 @@ lldb::SBValueList SBFrame::GetVariables(bool arguments, bool locals,
}
SBValueList SBFrame::GetVariables(const lldb::SBVariablesOptions &options) {
LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables,
(const lldb::SBVariablesOptions &), options);
LLDB_INSTRUMENT_VA(this, options);
SBValueList value_list;
std::unique_lock<std::recursive_mutex> lock;
@ -895,7 +876,7 @@ SBValueList SBFrame::GetVariables(const lldb::SBVariablesOptions &options) {
}
SBValueList SBFrame::GetRegisters() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValueList, SBFrame, GetRegisters);
LLDB_INSTRUMENT_VA(this);
SBValueList value_list;
std::unique_lock<std::recursive_mutex> lock;
@ -925,8 +906,7 @@ SBValueList SBFrame::GetRegisters() {
}
SBValue SBFrame::FindRegister(const char *name) {
LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindRegister, (const char *),
name);
LLDB_INSTRUMENT_VA(this, name);
SBValue result;
ValueObjectSP value_sp;
@ -957,8 +937,7 @@ SBValue SBFrame::FindRegister(const char *name) {
}
bool SBFrame::GetDescription(SBStream &description) {
LLDB_RECORD_METHOD(bool, SBFrame, GetDescription, (lldb::SBStream &),
description);
LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();
@ -984,8 +963,7 @@ bool SBFrame::GetDescription(SBStream &description) {
}
SBValue SBFrame::EvaluateExpression(const char *expr) {
LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression, (const char *),
expr);
LLDB_INSTRUMENT_VA(this, expr);
SBValue result;
std::unique_lock<std::recursive_mutex> lock;
@ -1012,9 +990,7 @@ SBValue SBFrame::EvaluateExpression(const char *expr) {
SBValue
SBFrame::EvaluateExpression(const char *expr,
lldb::DynamicValueType fetch_dynamic_value) {
LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
(const char *, lldb::DynamicValueType), expr,
fetch_dynamic_value);
LLDB_INSTRUMENT_VA(this, expr, fetch_dynamic_value);
SBExpressionOptions options;
options.SetFetchDynamicValue(fetch_dynamic_value);
@ -1035,9 +1011,7 @@ SBFrame::EvaluateExpression(const char *expr,
SBValue SBFrame::EvaluateExpression(const char *expr,
lldb::DynamicValueType fetch_dynamic_value,
bool unwind_on_error) {
LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
(const char *, lldb::DynamicValueType, bool), expr,
fetch_dynamic_value, unwind_on_error);
LLDB_INSTRUMENT_VA(this, expr, fetch_dynamic_value, unwind_on_error);
SBExpressionOptions options;
std::unique_lock<std::recursive_mutex> lock;
@ -1057,9 +1031,7 @@ SBValue SBFrame::EvaluateExpression(const char *expr,
lldb::SBValue SBFrame::EvaluateExpression(const char *expr,
const SBExpressionOptions &options) {
LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
(const char *, const lldb::SBExpressionOptions &), expr,
options);
LLDB_INSTRUMENT_VA(this, expr, options);
Log *expr_log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
@ -1110,13 +1082,13 @@ lldb::SBValue SBFrame::EvaluateExpression(const char *expr,
}
bool SBFrame::IsInlined() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBFrame, IsInlined);
LLDB_INSTRUMENT_VA(this);
return static_cast<const SBFrame *>(this)->IsInlined();
}
bool SBFrame::IsInlined() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsInlined);
LLDB_INSTRUMENT_VA(this);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@ -1140,13 +1112,13 @@ bool SBFrame::IsInlined() const {
}
bool SBFrame::IsArtificial() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBFrame, IsArtificial);
LLDB_INSTRUMENT_VA(this);
return static_cast<const SBFrame *>(this)->IsArtificial();
}
bool SBFrame::IsArtificial() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsArtificial);
LLDB_INSTRUMENT_VA(this);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@ -1159,13 +1131,13 @@ bool SBFrame::IsArtificial() const {
}
const char *SBFrame::GetFunctionName() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBFrame, GetFunctionName);
LLDB_INSTRUMENT_VA(this);
return static_cast<const SBFrame *>(this)->GetFunctionName();
}
lldb::LanguageType SBFrame::GuessLanguage() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::LanguageType, SBFrame, GuessLanguage);
LLDB_INSTRUMENT_VA(this);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@ -1186,7 +1158,7 @@ lldb::LanguageType SBFrame::GuessLanguage() const {
}
const char *SBFrame::GetFunctionName() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFrame, GetFunctionName);
LLDB_INSTRUMENT_VA(this);
const char *name = nullptr;
std::unique_lock<std::recursive_mutex> lock;
@ -1228,7 +1200,7 @@ const char *SBFrame::GetFunctionName() const {
}
const char *SBFrame::GetDisplayFunctionName() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBFrame, GetDisplayFunctionName);
LLDB_INSTRUMENT_VA(this);
const char *name = nullptr;

50
lldb/source/API/SBFunction.cpp
View file

@ -7,7 +7,6 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBFunction.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBProcess.h"
#include "lldb/API/SBStream.h"
#include "lldb/Core/Disassembler.h"
@ -18,23 +17,23 @@
#include "lldb/Symbol/VariableList.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Target.h"
#include "lldb/Utility/Instrumentation.h"
using namespace lldb;
using namespace lldb_private;
SBFunction::SBFunction() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFunction); }
SBFunction::SBFunction() { LLDB_INSTRUMENT_VA(this); }
SBFunction::SBFunction(lldb_private::Function *lldb_object_ptr)
: m_opaque_ptr(lldb_object_ptr) {}
SBFunction::SBFunction(const lldb::SBFunction &rhs)
: m_opaque_ptr(rhs.m_opaque_ptr) {
LLDB_RECORD_CONSTRUCTOR(SBFunction, (const lldb::SBFunction &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
}
const SBFunction &SBFunction::operator=(const SBFunction &rhs) {
LLDB_RECORD_METHOD(const lldb::SBFunction &,
SBFunction, operator=,(const lldb::SBFunction &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_ptr = rhs.m_opaque_ptr;
return *this;
@ -43,17 +42,17 @@ const SBFunction &SBFunction::operator=(const SBFunction &rhs) {
SBFunction::~SBFunction() { m_opaque_ptr = nullptr; }
bool SBFunction::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFunction, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBFunction::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFunction, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_opaque_ptr != nullptr;
}
const char *SBFunction::GetName() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFunction, GetName);
LLDB_INSTRUMENT_VA(this);
const char *cstr = nullptr;
if (m_opaque_ptr)
@ -63,7 +62,7 @@ const char *SBFunction::GetName() const {
}
const char *SBFunction::GetDisplayName() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFunction, GetDisplayName);
LLDB_INSTRUMENT_VA(this);
const char *cstr = nullptr;
if (m_opaque_ptr)
@ -73,7 +72,7 @@ const char *SBFunction::GetDisplayName() const {
}
const char *SBFunction::GetMangledName() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFunction, GetMangledName);
LLDB_INSTRUMENT_VA(this);
const char *cstr = nullptr;
if (m_opaque_ptr)
@ -82,21 +81,19 @@ const char *SBFunction::GetMangledName() const {
}
bool SBFunction::operator==(const SBFunction &rhs) const {
LLDB_RECORD_METHOD_CONST(
bool, SBFunction, operator==,(const lldb::SBFunction &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
return m_opaque_ptr == rhs.m_opaque_ptr;
}
bool SBFunction::operator!=(const SBFunction &rhs) const {
LLDB_RECORD_METHOD_CONST(
bool, SBFunction, operator!=,(const lldb::SBFunction &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
return m_opaque_ptr != rhs.m_opaque_ptr;
}
bool SBFunction::GetDescription(SBStream &s) {
LLDB_RECORD_METHOD(bool, SBFunction, GetDescription, (lldb::SBStream &), s);
LLDB_INSTRUMENT_VA(this, s);
if (m_opaque_ptr) {
s.Printf("SBFunction: id = 0x%8.8" PRIx64 ", name = %s",
@ -111,16 +108,14 @@ bool SBFunction::GetDescription(SBStream &s) {
}
SBInstructionList SBFunction::GetInstructions(SBTarget target) {
LLDB_RECORD_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions,
(lldb::SBTarget), target);
LLDB_INSTRUMENT_VA(this, target);
return GetInstructions(target, nullptr);
}
SBInstructionList SBFunction::GetInstructions(SBTarget target,
const char *flavor) {
LLDB_RECORD_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions,
(lldb::SBTarget, const char *), target, flavor);
LLDB_INSTRUMENT_VA(this, target, flavor);
SBInstructionList sb_instructions;
if (m_opaque_ptr) {
@ -146,7 +141,7 @@ void SBFunction::reset(lldb_private::Function *lldb_object_ptr) {
}
SBAddress SBFunction::GetStartAddress() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBFunction, GetStartAddress);
LLDB_INSTRUMENT_VA(this);
SBAddress addr;
if (m_opaque_ptr)
@ -155,7 +150,7 @@ SBAddress SBFunction::GetStartAddress() {
}
SBAddress SBFunction::GetEndAddress() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBFunction, GetEndAddress);
LLDB_INSTRUMENT_VA(this);
SBAddress addr;
if (m_opaque_ptr) {
@ -169,8 +164,7 @@ SBAddress SBFunction::GetEndAddress() {
}
const char *SBFunction::GetArgumentName(uint32_t arg_idx) {
LLDB_RECORD_METHOD(const char *, SBFunction, GetArgumentName, (uint32_t),
arg_idx);
LLDB_INSTRUMENT_VA(this, arg_idx);
if (m_opaque_ptr) {
Block &block = m_opaque_ptr->GetBlock(true);
@ -188,7 +182,7 @@ const char *SBFunction::GetArgumentName(uint32_t arg_idx) {
}
uint32_t SBFunction::GetPrologueByteSize() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBFunction, GetPrologueByteSize);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr)
return m_opaque_ptr->GetPrologueByteSize();
@ -196,7 +190,7 @@ uint32_t SBFunction::GetPrologueByteSize() {
}
SBType SBFunction::GetType() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBFunction, GetType);
LLDB_INSTRUMENT_VA(this);
SBType sb_type;
if (m_opaque_ptr) {
@ -208,7 +202,7 @@ SBType SBFunction::GetType() {
}
SBBlock SBFunction::GetBlock() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBFunction, GetBlock);
LLDB_INSTRUMENT_VA(this);
SBBlock sb_block;
if (m_opaque_ptr)
@ -217,7 +211,7 @@ SBBlock SBFunction::GetBlock() {
}
lldb::LanguageType SBFunction::GetLanguage() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::LanguageType, SBFunction, GetLanguage);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr) {
if (m_opaque_ptr->GetCompileUnit())
@ -227,7 +221,7 @@ lldb::LanguageType SBFunction::GetLanguage() {
}
bool SBFunction::GetIsOptimized() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBFunction, GetIsOptimized);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr) {
if (m_opaque_ptr->GetCompileUnit())

36
lldb/source/API/SBHostOS.cpp
View file

@ -7,7 +7,6 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBHostOS.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBError.h"
#include "lldb/Host/Config.h"
#include "lldb/Host/FileSystem.h"
@ -17,6 +16,7 @@
#include "lldb/Host/HostThread.h"
#include "lldb/Host/ThreadLauncher.h"
#include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/Instrumentation.h"
#include "Plugins/ExpressionParser/Clang/ClangHost.h"
#if LLDB_ENABLE_PYTHON
@ -30,8 +30,7 @@ using namespace lldb;
using namespace lldb_private;
SBFileSpec SBHostOS::GetProgramFileSpec() {
LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBFileSpec, SBHostOS,
GetProgramFileSpec);
LLDB_INSTRUMENT();
SBFileSpec sb_filespec;
sb_filespec.SetFileSpec(HostInfo::GetProgramFileSpec());
@ -39,15 +38,13 @@ SBFileSpec SBHostOS::GetProgramFileSpec() {
}
SBFileSpec SBHostOS::GetLLDBPythonPath() {
LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBFileSpec, SBHostOS,
GetLLDBPythonPath);
LLDB_INSTRUMENT();
return GetLLDBPath(ePathTypePythonDir);
}
SBFileSpec SBHostOS::GetLLDBPath(lldb::PathType path_type) {
LLDB_RECORD_STATIC_METHOD(lldb::SBFileSpec, SBHostOS, GetLLDBPath,
(lldb::PathType), path_type);
LLDB_INSTRUMENT_VA(path_type);
FileSpec fspec;
switch (path_type) {
@ -88,8 +85,7 @@ SBFileSpec SBHostOS::GetLLDBPath(lldb::PathType path_type) {
}
SBFileSpec SBHostOS::GetUserHomeDirectory() {
LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBFileSpec, SBHostOS,
GetUserHomeDirectory);
LLDB_INSTRUMENT();
FileSpec homedir;
FileSystem::Instance().GetHomeDirectory(homedir);
@ -104,9 +100,7 @@ SBFileSpec SBHostOS::GetUserHomeDirectory() {
lldb::thread_t SBHostOS::ThreadCreate(const char *name,
lldb::thread_func_t thread_function,
void *thread_arg, SBError *error_ptr) {
LLDB_RECORD_STATIC_METHOD(lldb::thread_t, SBHostOS, ThreadCreate,
(lldb::thread_func_t, void *, SBError *), name,
thread_function, thread_arg, error_ptr);
LLDB_INSTRUMENT_VA(name, thread_function, thread_arg, error_ptr);
llvm::Expected<HostThread> thread =
ThreadLauncher::LaunchThread(name, thread_function, thread_arg);
if (!thread) {
@ -120,15 +114,10 @@ lldb::thread_t SBHostOS::ThreadCreate(const char *name,
return thread->Release();
}
void SBHostOS::ThreadCreated(const char *name) {
LLDB_RECORD_STATIC_METHOD(void, SBHostOS, ThreadCreated, (const char *),
name);
}
void SBHostOS::ThreadCreated(const char *name) { LLDB_INSTRUMENT_VA(name); }
bool SBHostOS::ThreadCancel(lldb::thread_t thread, SBError *error_ptr) {
LLDB_RECORD_STATIC_METHOD(bool, SBHostOS, ThreadCancel,
(lldb::thread_t, lldb::SBError *), thread,
error_ptr);
LLDB_INSTRUMENT_VA(thread, error_ptr);
Status error;
HostThread host_thread(thread);
@ -140,9 +129,7 @@ bool SBHostOS::ThreadCancel(lldb::thread_t thread, SBError *error_ptr) {
}
bool SBHostOS::ThreadDetach(lldb::thread_t thread, SBError *error_ptr) {
LLDB_RECORD_STATIC_METHOD(bool, SBHostOS, ThreadDetach,
(lldb::thread_t, lldb::SBError *), thread,
error_ptr);
LLDB_INSTRUMENT_VA(thread, error_ptr);
Status error;
#if defined(_WIN32)
@ -160,10 +147,7 @@ bool SBHostOS::ThreadDetach(lldb::thread_t thread, SBError *error_ptr) {
bool SBHostOS::ThreadJoin(lldb::thread_t thread, lldb::thread_result_t *result,
SBError *error_ptr) {
LLDB_RECORD_STATIC_METHOD(
bool, SBHostOS, ThreadJoin,
(lldb::thread_t, lldb::thread_result_t *, lldb::SBError *), thread,
result, error_ptr);
LLDB_INSTRUMENT_VA(thread, result, error_ptr);
Status error;
HostThread host_thread(thread);

57
lldb/source/API/SBInstruction.cpp
View file

@ -7,7 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBInstruction.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBFrame.h"
@ -66,9 +66,7 @@ protected:
using namespace lldb;
using namespace lldb_private;
SBInstruction::SBInstruction() {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBInstruction);
}
SBInstruction::SBInstruction() { LLDB_INSTRUMENT_VA(this); }
SBInstruction::SBInstruction(const lldb::DisassemblerSP &disasm_sp,
const lldb::InstructionSP &inst_sp)
@ -76,13 +74,11 @@ SBInstruction::SBInstruction(const lldb::DisassemblerSP &disasm_sp,
SBInstruction::SBInstruction(const SBInstruction &rhs)
: m_opaque_sp(rhs.m_opaque_sp) {
LLDB_RECORD_CONSTRUCTOR(SBInstruction, (const lldb::SBInstruction &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
}
const SBInstruction &SBInstruction::operator=(const SBInstruction &rhs) {
LLDB_RECORD_METHOD(const lldb::SBInstruction &,
SBInstruction, operator=,(const lldb::SBInstruction &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_sp = rhs.m_opaque_sp;
@ -92,17 +88,17 @@ const SBInstruction &SBInstruction::operator=(const SBInstruction &rhs) {
SBInstruction::~SBInstruction() = default;
bool SBInstruction::IsValid() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBInstruction::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInstruction, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp && m_opaque_sp->IsValid();
}
SBAddress SBInstruction::GetAddress() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBInstruction, GetAddress);
LLDB_INSTRUMENT_VA(this);
SBAddress sb_addr;
lldb::InstructionSP inst_sp(GetOpaque());
@ -112,8 +108,7 @@ SBAddress SBInstruction::GetAddress() {
}
const char *SBInstruction::GetMnemonic(SBTarget target) {
LLDB_RECORD_METHOD(const char *, SBInstruction, GetMnemonic, (lldb::SBTarget),
target);
LLDB_INSTRUMENT_VA(this, target);
lldb::InstructionSP inst_sp(GetOpaque());
if (inst_sp) {
@ -132,8 +127,7 @@ const char *SBInstruction::GetMnemonic(SBTarget target) {
}
const char *SBInstruction::GetOperands(SBTarget target) {
LLDB_RECORD_METHOD(const char *, SBInstruction, GetOperands, (lldb::SBTarget),
target);
LLDB_INSTRUMENT_VA(this, target);
lldb::InstructionSP inst_sp(GetOpaque());
if (inst_sp) {
@ -152,8 +146,7 @@ const char *SBInstruction::GetOperands(SBTarget target) {
}
const char *SBInstruction::GetComment(SBTarget target) {
LLDB_RECORD_METHOD(const char *, SBInstruction, GetComment, (lldb::SBTarget),
target);
LLDB_INSTRUMENT_VA(this, target);
lldb::InstructionSP inst_sp(GetOpaque());
if (inst_sp) {
@ -172,7 +165,7 @@ const char *SBInstruction::GetComment(SBTarget target) {
}
size_t SBInstruction::GetByteSize() {
LLDB_RECORD_METHOD_NO_ARGS(size_t, SBInstruction, GetByteSize);
LLDB_INSTRUMENT_VA(this);
lldb::InstructionSP inst_sp(GetOpaque());
if (inst_sp)
@ -181,8 +174,7 @@ size_t SBInstruction::GetByteSize() {
}
SBData SBInstruction::GetData(SBTarget target) {
LLDB_RECORD_METHOD(lldb::SBData, SBInstruction, GetData, (lldb::SBTarget),
target);
LLDB_INSTRUMENT_VA(this, target);
lldb::SBData sb_data;
lldb::InstructionSP inst_sp(GetOpaque());
@ -196,7 +188,7 @@ SBData SBInstruction::GetData(SBTarget target) {
}
bool SBInstruction::DoesBranch() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, DoesBranch);
LLDB_INSTRUMENT_VA(this);
lldb::InstructionSP inst_sp(GetOpaque());
if (inst_sp)
@ -205,7 +197,7 @@ bool SBInstruction::DoesBranch() {
}
bool SBInstruction::HasDelaySlot() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, HasDelaySlot);
LLDB_INSTRUMENT_VA(this);
lldb::InstructionSP inst_sp(GetOpaque());
if (inst_sp)
@ -214,7 +206,7 @@ bool SBInstruction::HasDelaySlot() {
}
bool SBInstruction::CanSetBreakpoint() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, CanSetBreakpoint);
LLDB_INSTRUMENT_VA(this);
lldb::InstructionSP inst_sp(GetOpaque());
if (inst_sp)
@ -235,8 +227,7 @@ void SBInstruction::SetOpaque(const lldb::DisassemblerSP &disasm_sp,
}
bool SBInstruction::GetDescription(lldb::SBStream &s) {
LLDB_RECORD_METHOD(bool, SBInstruction, GetDescription, (lldb::SBStream &),
s);
LLDB_INSTRUMENT_VA(this, s);
lldb::InstructionSP inst_sp(GetOpaque());
if (inst_sp) {
@ -257,18 +248,18 @@ bool SBInstruction::GetDescription(lldb::SBStream &s) {
}
void SBInstruction::Print(FILE *outp) {
LLDB_RECORD_METHOD(void, SBInstruction, Print, (FILE *), outp);
LLDB_INSTRUMENT_VA(this, outp);
FileSP out = std::make_shared<NativeFile>(outp, /*take_ownership=*/false);
Print(out);
}
void SBInstruction::Print(SBFile out) {
LLDB_RECORD_METHOD(void, SBInstruction, Print, (SBFile), out);
LLDB_INSTRUMENT_VA(this, out);
Print(out.m_opaque_sp);
}
void SBInstruction::Print(FileSP out_sp) {
LLDB_RECORD_METHOD(void, SBInstruction, Print, (FileSP), out_sp);
LLDB_INSTRUMENT_VA(this, out_sp);
if (!out_sp || !out_sp->IsValid())
return;
@ -291,8 +282,7 @@ void SBInstruction::Print(FileSP out_sp) {
bool SBInstruction::EmulateWithFrame(lldb::SBFrame &frame,
uint32_t evaluate_options) {
LLDB_RECORD_METHOD(bool, SBInstruction, EmulateWithFrame,
(lldb::SBFrame &, uint32_t), frame, evaluate_options);
LLDB_INSTRUMENT_VA(this, frame, evaluate_options);
lldb::InstructionSP inst_sp(GetOpaque());
if (inst_sp) {
@ -316,8 +306,7 @@ bool SBInstruction::EmulateWithFrame(lldb::SBFrame &frame,
}
bool SBInstruction::DumpEmulation(const char *triple) {
LLDB_RECORD_METHOD(bool, SBInstruction, DumpEmulation, (const char *),
triple);
LLDB_INSTRUMENT_VA(this, triple);
lldb::InstructionSP inst_sp(GetOpaque());
if (inst_sp && triple) {
@ -328,9 +317,7 @@ bool SBInstruction::DumpEmulation(const char *triple) {
bool SBInstruction::TestEmulation(lldb::SBStream &output_stream,
const char *test_file) {
LLDB_RECORD_METHOD(bool, SBInstruction, TestEmulation,
(lldb::SBStream &, const char *), output_stream,
test_file);
LLDB_INSTRUMENT_VA(this, output_stream, test_file);
if (!m_opaque_sp)
SetOpaque(lldb::DisassemblerSP(),

45
lldb/source/API/SBInstructionList.cpp
View file

@ -7,35 +7,30 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBInstructionList.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBFile.h"
#include "lldb/API/SBInstruction.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBFile.h"
#include "lldb/Core/Disassembler.h"
#include "lldb/Core/Module.h"
#include "lldb/Core/StreamFile.h"
#include "lldb/Symbol/SymbolContext.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/Stream.h"
using namespace lldb;
using namespace lldb_private;
SBInstructionList::SBInstructionList() {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBInstructionList);
}
SBInstructionList::SBInstructionList() { LLDB_INSTRUMENT_VA(this); }
SBInstructionList::SBInstructionList(const SBInstructionList &rhs)
: m_opaque_sp(rhs.m_opaque_sp) {
LLDB_RECORD_CONSTRUCTOR(SBInstructionList, (const lldb::SBInstructionList &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
}
const SBInstructionList &SBInstructionList::
operator=(const SBInstructionList &rhs) {
LLDB_RECORD_METHOD(
const lldb::SBInstructionList &,
SBInstructionList, operator=,(const lldb::SBInstructionList &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_sp = rhs.m_opaque_sp;
@ -45,17 +40,17 @@ operator=(const SBInstructionList &rhs) {
SBInstructionList::~SBInstructionList() = default;
bool SBInstructionList::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInstructionList, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBInstructionList::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInstructionList, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp.get() != nullptr;
}
size_t SBInstructionList::GetSize() {
LLDB_RECORD_METHOD_NO_ARGS(size_t, SBInstructionList, GetSize);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp)
return m_opaque_sp->GetInstructionList().GetSize();
@ -63,8 +58,7 @@ size_t SBInstructionList::GetSize() {
}
SBInstruction SBInstructionList::GetInstructionAtIndex(uint32_t idx) {
LLDB_RECORD_METHOD(lldb::SBInstruction, SBInstructionList,
GetInstructionAtIndex, (uint32_t), idx);
LLDB_INSTRUMENT_VA(this, idx);
SBInstruction inst;
if (m_opaque_sp && idx < m_opaque_sp->GetInstructionList().GetSize())
@ -77,9 +71,7 @@ SBInstruction SBInstructionList::GetInstructionAtIndex(uint32_t idx) {
size_t SBInstructionList::GetInstructionsCount(const SBAddress &start,
const SBAddress &end,
bool canSetBreakpoint) {
LLDB_RECORD_METHOD(size_t, SBInstructionList, GetInstructionsCount,
(const lldb::SBAddress &, const lldb::SBAddress &, bool),
start, end, canSetBreakpoint);
LLDB_INSTRUMENT_VA(this, start, end, canSetBreakpoint);
size_t num_instructions = GetSize();
size_t i = 0;
@ -104,14 +96,13 @@ size_t SBInstructionList::GetInstructionsCount(const SBAddress &start,
}
void SBInstructionList::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBInstructionList, Clear);
LLDB_INSTRUMENT_VA(this);
m_opaque_sp.reset();
}
void SBInstructionList::AppendInstruction(SBInstruction insn) {
LLDB_RECORD_METHOD(void, SBInstructionList, AppendInstruction,
(lldb::SBInstruction), insn);
LLDB_INSTRUMENT_VA(this, insn);
}
void SBInstructionList::SetDisassembler(const lldb::DisassemblerSP &opaque_sp) {
@ -119,7 +110,7 @@ void SBInstructionList::SetDisassembler(const lldb::DisassemblerSP &opaque_sp) {
}
void SBInstructionList::Print(FILE *out) {
LLDB_RECORD_METHOD(void, SBInstructionList, Print, (FILE *), out);
LLDB_INSTRUMENT_VA(this, out);
if (out == nullptr)
return;
StreamFile stream(out, false);
@ -127,7 +118,7 @@ void SBInstructionList::Print(FILE *out) {
}
void SBInstructionList::Print(SBFile out) {
LLDB_RECORD_METHOD(void, SBInstructionList, Print, (SBFile), out);
LLDB_INSTRUMENT_VA(this, out);
if (!out.IsValid())
return;
StreamFile stream(out.m_opaque_sp);
@ -135,7 +126,7 @@ void SBInstructionList::Print(SBFile out) {
}
void SBInstructionList::Print(FileSP out_sp) {
LLDB_RECORD_METHOD(void, SBInstructionList, Print, (FileSP), out_sp);
LLDB_INSTRUMENT_VA(this, out_sp);
if (!out_sp || !out_sp->IsValid())
return;
StreamFile stream(out_sp);
@ -143,8 +134,7 @@ void SBInstructionList::Print(FileSP out_sp) {
}
bool SBInstructionList::GetDescription(lldb::SBStream &stream) {
LLDB_RECORD_METHOD(bool, SBInstructionList, GetDescription,
(lldb::SBStream &), stream);
LLDB_INSTRUMENT_VA(this, stream);
return GetDescription(stream.ref());
}
@ -186,8 +176,7 @@ bool SBInstructionList::GetDescription(Stream &sref) {
}
bool SBInstructionList::DumpEmulationForAllInstructions(const char *triple) {
LLDB_RECORD_METHOD(bool, SBInstructionList, DumpEmulationForAllInstructions,
(const char *), triple);
LLDB_INSTRUMENT_VA(this, triple);
if (m_opaque_sp) {
size_t len = GetSize();

9
lldb/source/API/SBLanguageRuntime.cpp
View file

@ -7,25 +7,22 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBLanguageRuntime.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/Target/Language.h"
#include "lldb/Utility/Instrumentation.h"
using namespace lldb;
using namespace lldb_private;
lldb::LanguageType
SBLanguageRuntime::GetLanguageTypeFromString(const char *string) {
LLDB_RECORD_STATIC_METHOD(lldb::LanguageType, SBLanguageRuntime,
GetLanguageTypeFromString, (const char *), string);
LLDB_INSTRUMENT_VA(string);
return Language::GetLanguageTypeFromString(llvm::StringRef(string));
}
const char *
SBLanguageRuntime::GetNameForLanguageType(lldb::LanguageType language) {
LLDB_RECORD_STATIC_METHOD(const char *, SBLanguageRuntime,
GetNameForLanguageType, (lldb::LanguageType),
language);
LLDB_INSTRUMENT_VA(language);
return Language::GetNameForLanguageType(language);
}

117
lldb/source/API/SBLaunchInfo.cpp
View file

@ -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 @@ private:
SBLaunchInfo::SBLaunchInfo(const char **argv)
: m_opaque_sp(new SBLaunchInfoImpl()) {
LLDB_RECORD_CONSTRUCTOR(SBLaunchInfo, (const char **), argv);
LLDB_INSTRUMENT_VA(this, argv);
m_opaque_sp->GetFlags().Reset(eLaunchFlagDebug | eLaunchFlagDisableASLR);
if (argv && argv[0])
@ -48,14 +48,13 @@ SBLaunchInfo::SBLaunchInfo(const char **argv)
}
SBLaunchInfo::SBLaunchInfo(const SBLaunchInfo &rhs) {
LLDB_RECORD_CONSTRUCTOR(SBLaunchInfo, (const lldb::SBLaunchInfo &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_sp = rhs.m_opaque_sp;
}
SBLaunchInfo &SBLaunchInfo::operator=(const SBLaunchInfo &rhs) {
LLDB_RECORD_METHOD(SBLaunchInfo &,
SBLaunchInfo, operator=,(const lldb::SBLaunchInfo &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_sp = rhs.m_opaque_sp;
return *this;
@ -72,90 +71,86 @@ void SBLaunchInfo::set_ref(const ProcessLaunchInfo &info) {
}
lldb::pid_t SBLaunchInfo::GetProcessID() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBLaunchInfo, GetProcessID);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetProcessID();
}
uint32_t SBLaunchInfo::GetUserID() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetUserID);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetUserID();
}
uint32_t SBLaunchInfo::GetGroupID() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetGroupID);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetGroupID();
}
bool SBLaunchInfo::UserIDIsValid() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBLaunchInfo, UserIDIsValid);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->UserIDIsValid();
}
bool SBLaunchInfo::GroupIDIsValid() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBLaunchInfo, GroupIDIsValid);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GroupIDIsValid();
}
void SBLaunchInfo::SetUserID(uint32_t uid) {
LLDB_RECORD_METHOD(void, SBLaunchInfo, SetUserID, (uint32_t), uid);
LLDB_INSTRUMENT_VA(this, uid);
m_opaque_sp->SetUserID(uid);
}
void SBLaunchInfo::SetGroupID(uint32_t gid) {
LLDB_RECORD_METHOD(void, SBLaunchInfo, SetGroupID, (uint32_t), gid);
LLDB_INSTRUMENT_VA(this, gid);
m_opaque_sp->SetGroupID(gid);
}
SBFileSpec SBLaunchInfo::GetExecutableFile() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBLaunchInfo, GetExecutableFile);
LLDB_INSTRUMENT_VA(this);
return SBFileSpec(m_opaque_sp->GetExecutableFile());
}
void SBLaunchInfo::SetExecutableFile(SBFileSpec exe_file,
bool add_as_first_arg) {
LLDB_RECORD_METHOD(void, SBLaunchInfo, SetExecutableFile,
(lldb::SBFileSpec, bool), exe_file, add_as_first_arg);
LLDB_INSTRUMENT_VA(this, exe_file, add_as_first_arg);
m_opaque_sp->SetExecutableFile(exe_file.ref(), add_as_first_arg);
}
SBListener SBLaunchInfo::GetListener() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBLaunchInfo, GetListener);
LLDB_INSTRUMENT_VA(this);
return SBListener(m_opaque_sp->GetListener());
}
void SBLaunchInfo::SetListener(SBListener &listener) {
LLDB_RECORD_METHOD(void, SBLaunchInfo, SetListener, (lldb::SBListener &),
listener);
LLDB_INSTRUMENT_VA(this, listener);
m_opaque_sp->SetListener(listener.GetSP());
}
uint32_t SBLaunchInfo::GetNumArguments() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetNumArguments);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetArguments().GetArgumentCount();
}
const char *SBLaunchInfo::GetArgumentAtIndex(uint32_t idx) {
LLDB_RECORD_METHOD(const char *, SBLaunchInfo, GetArgumentAtIndex, (uint32_t),
idx);
LLDB_INSTRUMENT_VA(this, idx);
return m_opaque_sp->GetArguments().GetArgumentAtIndex(idx);
}
void SBLaunchInfo::SetArguments(const char **argv, bool append) {
LLDB_RECORD_METHOD(void, SBLaunchInfo, SetArguments, (const char **, bool),
argv, append);
LLDB_INSTRUMENT_VA(this, argv, append);
if (append) {
if (argv)
@ -169,14 +164,13 @@ void SBLaunchInfo::SetArguments(const char **argv, bool append) {
}
uint32_t SBLaunchInfo::GetNumEnvironmentEntries() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetNumEnvironmentEntries);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetEnvironment().size();
}
const char *SBLaunchInfo::GetEnvironmentEntryAtIndex(uint32_t idx) {
LLDB_RECORD_METHOD(const char *, SBLaunchInfo, GetEnvironmentEntryAtIndex,
(uint32_t), idx);
LLDB_INSTRUMENT_VA(this, idx);
if (idx > GetNumEnvironmentEntries())
return nullptr;
@ -184,14 +178,12 @@ const char *SBLaunchInfo::GetEnvironmentEntryAtIndex(uint32_t idx) {
}
void SBLaunchInfo::SetEnvironmentEntries(const char **envp, bool append) {
LLDB_RECORD_METHOD(void, SBLaunchInfo, SetEnvironmentEntries,
(const char **, bool), envp, append);
LLDB_INSTRUMENT_VA(this, envp, append);
SetEnvironment(SBEnvironment(Environment(envp)), append);
}
void SBLaunchInfo::SetEnvironment(const SBEnvironment &env, bool append) {
LLDB_RECORD_METHOD(void, SBLaunchInfo, SetEnvironment,
(const lldb::SBEnvironment &, bool), env, append);
LLDB_INSTRUMENT_VA(this, env, append);
Environment &refEnv = env.ref();
if (append) {
for (auto &KV : refEnv)
@ -202,57 +194,54 @@ void SBLaunchInfo::SetEnvironment(const SBEnvironment &env, bool append) {
}
SBEnvironment SBLaunchInfo::GetEnvironment() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBEnvironment, SBLaunchInfo, GetEnvironment);
LLDB_INSTRUMENT_VA(this);
return SBEnvironment(Environment(m_opaque_sp->GetEnvironment()));
}
void SBLaunchInfo::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBLaunchInfo, Clear);
LLDB_INSTRUMENT_VA(this);
m_opaque_sp->Clear();
}
const char *SBLaunchInfo::GetWorkingDirectory() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBLaunchInfo,
GetWorkingDirectory);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetWorkingDirectory().GetCString();
}
void SBLaunchInfo::SetWorkingDirectory(const char *working_dir) {
LLDB_RECORD_METHOD(void, SBLaunchInfo, SetWorkingDirectory, (const char *),
working_dir);
LLDB_INSTRUMENT_VA(this, working_dir);
m_opaque_sp->SetWorkingDirectory(FileSpec(working_dir));
}
uint32_t SBLaunchInfo::GetLaunchFlags() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetLaunchFlags);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetFlags().Get();
}
void SBLaunchInfo::SetLaunchFlags(uint32_t flags) {
LLDB_RECORD_METHOD(void, SBLaunchInfo, SetLaunchFlags, (uint32_t), flags);
LLDB_INSTRUMENT_VA(this, flags);
m_opaque_sp->GetFlags().Reset(flags);
}
const char *SBLaunchInfo::GetProcessPluginName() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBLaunchInfo, GetProcessPluginName);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetProcessPluginName();
}
void SBLaunchInfo::SetProcessPluginName(const char *plugin_name) {
LLDB_RECORD_METHOD(void, SBLaunchInfo, SetProcessPluginName, (const char *),
plugin_name);
LLDB_INSTRUMENT_VA(this, plugin_name);
return m_opaque_sp->SetProcessPluginName(plugin_name);
}
const char *SBLaunchInfo::GetShell() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBLaunchInfo, GetShell);
LLDB_INSTRUMENT_VA(this);
// Constify this string so that it is saved in the string pool. Otherwise it
// would be freed when this function goes out of scope.
@ -261,93 +250,86 @@ const char *SBLaunchInfo::GetShell() {
}
void SBLaunchInfo::SetShell(const char *path) {
LLDB_RECORD_METHOD(void, SBLaunchInfo, SetShell, (const char *), path);
LLDB_INSTRUMENT_VA(this, path);
m_opaque_sp->SetShell(FileSpec(path));
}
bool SBLaunchInfo::GetShellExpandArguments() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBLaunchInfo, GetShellExpandArguments);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetShellExpandArguments();
}
void SBLaunchInfo::SetShellExpandArguments(bool expand) {
LLDB_RECORD_METHOD(void, SBLaunchInfo, SetShellExpandArguments, (bool),
expand);
LLDB_INSTRUMENT_VA(this, expand);
m_opaque_sp->SetShellExpandArguments(expand);
}
uint32_t SBLaunchInfo::GetResumeCount() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetResumeCount);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetResumeCount();
}
void SBLaunchInfo::SetResumeCount(uint32_t c) {
LLDB_RECORD_METHOD(void, SBLaunchInfo, SetResumeCount, (uint32_t), c);
LLDB_INSTRUMENT_VA(this, c);
m_opaque_sp->SetResumeCount(c);
}
bool SBLaunchInfo::AddCloseFileAction(int fd) {
LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddCloseFileAction, (int), fd);
LLDB_INSTRUMENT_VA(this, fd);
return m_opaque_sp->AppendCloseFileAction(fd);
}
bool SBLaunchInfo::AddDuplicateFileAction(int fd, int dup_fd) {
LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddDuplicateFileAction, (int, int), fd,
dup_fd);
LLDB_INSTRUMENT_VA(this, fd, dup_fd);
return m_opaque_sp->AppendDuplicateFileAction(fd, dup_fd);
}
bool SBLaunchInfo::AddOpenFileAction(int fd, const char *path, bool read,
bool write) {
LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddOpenFileAction,
(int, const char *, bool, bool), fd, path, read, write);
LLDB_INSTRUMENT_VA(this, fd, path, read, write);
return m_opaque_sp->AppendOpenFileAction(fd, FileSpec(path), read, write);
}
bool SBLaunchInfo::AddSuppressFileAction(int fd, bool read, bool write) {
LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddSuppressFileAction,
(int, bool, bool), fd, read, write);
LLDB_INSTRUMENT_VA(this, fd, read, write);
return m_opaque_sp->AppendSuppressFileAction(fd, read, write);
}
void SBLaunchInfo::SetLaunchEventData(const char *data) {
LLDB_RECORD_METHOD(void, SBLaunchInfo, SetLaunchEventData, (const char *),
data);
LLDB_INSTRUMENT_VA(this, data);
m_opaque_sp->SetLaunchEventData(data);
}
const char *SBLaunchInfo::GetLaunchEventData() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBLaunchInfo,
GetLaunchEventData);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetLaunchEventData();
}
void SBLaunchInfo::SetDetachOnError(bool enable) {
LLDB_RECORD_METHOD(void, SBLaunchInfo, SetDetachOnError, (bool), enable);
LLDB_INSTRUMENT_VA(this, enable);
m_opaque_sp->SetDetachOnError(enable);
}
bool SBLaunchInfo::GetDetachOnError() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBLaunchInfo, GetDetachOnError);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetDetachOnError();
}
const char *SBLaunchInfo::GetScriptedProcessClassName() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBLaunchInfo,
GetScriptedProcessClassName);
LLDB_INSTRUMENT_VA(this);
// Constify this string so that it is saved in the string pool. Otherwise it
// would be freed when this function goes out of scope.
@ -356,15 +338,13 @@ const char *SBLaunchInfo::GetScriptedProcessClassName() const {
}
void SBLaunchInfo::SetScriptedProcessClassName(const char *class_name) {
LLDB_RECORD_METHOD(void, SBLaunchInfo, SetScriptedProcessClassName,
(const char *), class_name);
LLDB_INSTRUMENT_VA(this, class_name);
m_opaque_sp->SetScriptedProcessClassName(class_name);
}
lldb::SBStructuredData SBLaunchInfo::GetScriptedProcessDictionary() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBStructuredData, SBLaunchInfo,
GetScriptedProcessDictionary);
LLDB_INSTRUMENT_VA(this);
lldb_private::StructuredData::DictionarySP dict_sp =
m_opaque_sp->GetScriptedProcessDictionarySP();
@ -376,8 +356,7 @@ lldb::SBStructuredData SBLaunchInfo::GetScriptedProcessDictionary() const {
}
void SBLaunchInfo::SetScriptedProcessDictionary(lldb::SBStructuredData dict) {
LLDB_RECORD_METHOD(void, SBLaunchInfo, SetScriptedProcessDictionary,
(lldb::SBStructuredData), dict);
LLDB_INSTRUMENT_VA(this, dict);
if (!dict.IsValid() || !dict.m_impl_up)
return;

40
lldb/source/API/SBLineEntry.cpp
View file

@ -7,11 +7,11 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBLineEntry.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/API/SBStream.h"
#include "lldb/Host/PosixApi.h"
#include "lldb/Symbol/LineEntry.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/StreamString.h"
#include <climits>
@ -19,10 +19,10 @@
using namespace lldb;
using namespace lldb_private;
SBLineEntry::SBLineEntry() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBLineEntry); }
SBLineEntry::SBLineEntry() { LLDB_INSTRUMENT_VA(this); }
SBLineEntry::SBLineEntry(const SBLineEntry &rhs) {
LLDB_RECORD_CONSTRUCTOR(SBLineEntry, (const lldb::SBLineEntry &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_up = clone(rhs.m_opaque_up);
}
@ -33,8 +33,7 @@ SBLineEntry::SBLineEntry(const lldb_private::LineEntry *lldb_object_ptr) {
}
const SBLineEntry &SBLineEntry::operator=(const SBLineEntry &rhs) {
LLDB_RECORD_METHOD(const lldb::SBLineEntry &,
SBLineEntry, operator=,(const lldb::SBLineEntry &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
@ -48,8 +47,7 @@ void SBLineEntry::SetLineEntry(const lldb_private::LineEntry &lldb_object_ref) {
SBLineEntry::~SBLineEntry() = default;
SBAddress SBLineEntry::GetStartAddress() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBLineEntry,
GetStartAddress);
LLDB_INSTRUMENT_VA(this);
SBAddress sb_address;
if (m_opaque_up)
@ -59,7 +57,7 @@ SBAddress SBLineEntry::GetStartAddress() const {
}
SBAddress SBLineEntry::GetEndAddress() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBLineEntry, GetEndAddress);
LLDB_INSTRUMENT_VA(this);
SBAddress sb_address;
if (m_opaque_up) {
@ -70,17 +68,17 @@ SBAddress SBLineEntry::GetEndAddress() const {
}
bool SBLineEntry::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBLineEntry, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBLineEntry::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBLineEntry, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up.get() && m_opaque_up->IsValid();
}
SBFileSpec SBLineEntry::GetFileSpec() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBLineEntry, GetFileSpec);
LLDB_INSTRUMENT_VA(this);
SBFileSpec sb_file_spec;
if (m_opaque_up.get() && m_opaque_up->file)
@ -90,7 +88,7 @@ SBFileSpec SBLineEntry::GetFileSpec() const {
}
uint32_t SBLineEntry::GetLine() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBLineEntry, GetLine);
LLDB_INSTRUMENT_VA(this);
uint32_t line = 0;
if (m_opaque_up)
@ -100,7 +98,7 @@ uint32_t SBLineEntry::GetLine() const {
}
uint32_t SBLineEntry::GetColumn() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBLineEntry, GetColumn);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_up)
return m_opaque_up->column;
@ -108,8 +106,7 @@ uint32_t SBLineEntry::GetColumn() const {
}
void SBLineEntry::SetFileSpec(lldb::SBFileSpec filespec) {
LLDB_RECORD_METHOD(void, SBLineEntry, SetFileSpec, (lldb::SBFileSpec),
filespec);
LLDB_INSTRUMENT_VA(this, filespec);
if (filespec.IsValid())
ref().file = filespec.ref();
@ -117,20 +114,19 @@ void SBLineEntry::SetFileSpec(lldb::SBFileSpec filespec) {
ref().file.Clear();
}
void SBLineEntry::SetLine(uint32_t line) {
LLDB_RECORD_METHOD(void, SBLineEntry, SetLine, (uint32_t), line);
LLDB_INSTRUMENT_VA(this, line);
ref().line = line;
}
void SBLineEntry::SetColumn(uint32_t column) {
LLDB_RECORD_METHOD(void, SBLineEntry, SetColumn, (uint32_t), column);
LLDB_INSTRUMENT_VA(this, column);
ref().line = column;
}
bool SBLineEntry::operator==(const SBLineEntry &rhs) const {
LLDB_RECORD_METHOD_CONST(
bool, SBLineEntry, operator==,(const lldb::SBLineEntry &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
lldb_private::LineEntry *lhs_ptr = m_opaque_up.get();
lldb_private::LineEntry *rhs_ptr = rhs.m_opaque_up.get();
@ -142,8 +138,7 @@ bool SBLineEntry::operator==(const SBLineEntry &rhs) const {
}
bool SBLineEntry::operator!=(const SBLineEntry &rhs) const {
LLDB_RECORD_METHOD_CONST(
bool, SBLineEntry, operator!=,(const lldb::SBLineEntry &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
lldb_private::LineEntry *lhs_ptr = m_opaque_up.get();
lldb_private::LineEntry *rhs_ptr = rhs.m_opaque_up.get();
@ -167,8 +162,7 @@ lldb_private::LineEntry &SBLineEntry::ref() {
const lldb_private::LineEntry &SBLineEntry::ref() const { return *m_opaque_up; }
bool SBLineEntry::GetDescription(SBStream &description) {
LLDB_RECORD_METHOD(bool, SBLineEntry, GetDescription, (lldb::SBStream &),
description);
LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();

72
lldb/source/API/SBListener.cpp
View file

@ -7,34 +7,33 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBListener.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBBroadcaster.h"
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBEvent.h"
#include "lldb/API/SBStream.h"
#include "lldb/Core/Debugger.h"
#include "lldb/Utility/Broadcaster.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/Listener.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb;
using namespace lldb_private;
SBListener::SBListener() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBListener); }
SBListener::SBListener() { LLDB_INSTRUMENT_VA(this); }
SBListener::SBListener(const char *name)
: m_opaque_sp(Listener::MakeListener(name)), m_unused_ptr(nullptr) {
LLDB_RECORD_CONSTRUCTOR(SBListener, (const char *), name);
LLDB_INSTRUMENT_VA(this, name);
}
SBListener::SBListener(const SBListener &rhs)
: m_opaque_sp(rhs.m_opaque_sp), m_unused_ptr(nullptr) {
LLDB_RECORD_CONSTRUCTOR(SBListener, (const lldb::SBListener &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
}
const lldb::SBListener &SBListener::operator=(const lldb::SBListener &rhs) {
LLDB_RECORD_METHOD(const lldb::SBListener &,
SBListener, operator=,(const lldb::SBListener &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
@ -49,18 +48,17 @@ SBListener::SBListener(const lldb::ListenerSP &listener_sp)
SBListener::~SBListener() = default;
bool SBListener::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBListener, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBListener::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBListener, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp != nullptr;
}
void SBListener::AddEvent(const SBEvent &event) {
LLDB_RECORD_METHOD(void, SBListener, AddEvent, (const lldb::SBEvent &),
event);
LLDB_INSTRUMENT_VA(this, event);
EventSP &event_sp = event.GetSP();
if (event_sp)
@ -68,7 +66,7 @@ void SBListener::AddEvent(const SBEvent &event) {
}
void SBListener::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBListener, Clear);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp)
m_opaque_sp->Clear();
@ -77,9 +75,7 @@ void SBListener::Clear() {
uint32_t SBListener::StartListeningForEventClass(SBDebugger &debugger,
const char *broadcaster_class,
uint32_t event_mask) {
LLDB_RECORD_METHOD(uint32_t, SBListener, StartListeningForEventClass,
(lldb::SBDebugger &, const char *, uint32_t), debugger,
broadcaster_class, event_mask);
LLDB_INSTRUMENT_VA(this, debugger, broadcaster_class, event_mask);
if (m_opaque_sp) {
Debugger *lldb_debugger = debugger.get();
@ -95,9 +91,7 @@ uint32_t SBListener::StartListeningForEventClass(SBDebugger &debugger,
bool SBListener::StopListeningForEventClass(SBDebugger &debugger,
const char *broadcaster_class,
uint32_t event_mask) {
LLDB_RECORD_METHOD(bool, SBListener, StopListeningForEventClass,
(lldb::SBDebugger &, const char *, uint32_t), debugger,
broadcaster_class, event_mask);
LLDB_INSTRUMENT_VA(this, debugger, broadcaster_class, event_mask);
if (m_opaque_sp) {
Debugger *lldb_debugger = debugger.get();
@ -112,9 +106,7 @@ bool SBListener::StopListeningForEventClass(SBDebugger &debugger,
uint32_t SBListener::StartListeningForEvents(const SBBroadcaster &broadcaster,
uint32_t event_mask) {
LLDB_RECORD_METHOD(uint32_t, SBListener, StartListeningForEvents,
(const lldb::SBBroadcaster &, uint32_t), broadcaster,
event_mask);
LLDB_INSTRUMENT_VA(this, broadcaster, event_mask);
uint32_t acquired_event_mask = 0;
if (m_opaque_sp && broadcaster.IsValid()) {
@ -127,9 +119,7 @@ uint32_t SBListener::StartListeningForEvents(const SBBroadcaster &broadcaster,
bool SBListener::StopListeningForEvents(const SBBroadcaster &broadcaster,
uint32_t event_mask) {
LLDB_RECORD_METHOD(bool, SBListener, StopListeningForEvents,
(const lldb::SBBroadcaster &, uint32_t), broadcaster,
event_mask);
LLDB_INSTRUMENT_VA(this, broadcaster, event_mask);
if (m_opaque_sp && broadcaster.IsValid()) {
return m_opaque_sp->StopListeningForEvents(broadcaster.get(), event_mask);
@ -138,8 +128,7 @@ bool SBListener::StopListeningForEvents(const SBBroadcaster &broadcaster,
}
bool SBListener::WaitForEvent(uint32_t timeout_secs, SBEvent &event) {
LLDB_RECORD_METHOD(bool, SBListener, WaitForEvent,
(uint32_t, lldb::SBEvent &), timeout_secs, event);
LLDB_INSTRUMENT_VA(this, timeout_secs, event);
bool success = false;
@ -165,9 +154,7 @@ bool SBListener::WaitForEvent(uint32_t timeout_secs, SBEvent &event) {
bool SBListener::WaitForEventForBroadcaster(uint32_t num_seconds,
const SBBroadcaster &broadcaster,
SBEvent &event) {
LLDB_RECORD_METHOD(bool, SBListener, WaitForEventForBroadcaster,
(uint32_t, const lldb::SBBroadcaster &, lldb::SBEvent &),
num_seconds, broadcaster, event);
LLDB_INSTRUMENT_VA(this, num_seconds, broadcaster, event);
if (m_opaque_sp && broadcaster.IsValid()) {
Timeout<std::micro> timeout(llvm::None);
@ -187,10 +174,7 @@ bool SBListener::WaitForEventForBroadcaster(uint32_t num_seconds,
bool SBListener::WaitForEventForBroadcasterWithType(
uint32_t num_seconds, const SBBroadcaster &broadcaster,
uint32_t event_type_mask, SBEvent &event) {
LLDB_RECORD_METHOD(
bool, SBListener, WaitForEventForBroadcasterWithType,
(uint32_t, const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &),
num_seconds, broadcaster, event_type_mask, event);
LLDB_INSTRUMENT_VA(this, num_seconds, broadcaster, event_type_mask, event);
if (m_opaque_sp && broadcaster.IsValid()) {
Timeout<std::micro> timeout(llvm::None);
@ -208,8 +192,7 @@ bool SBListener::WaitForEventForBroadcasterWithType(
}
bool SBListener::PeekAtNextEvent(SBEvent &event) {
LLDB_RECORD_METHOD(bool, SBListener, PeekAtNextEvent, (lldb::SBEvent &),
event);
LLDB_INSTRUMENT_VA(this, event);
if (m_opaque_sp) {
event.reset(m_opaque_sp->PeekAtNextEvent());
@ -221,9 +204,7 @@ bool SBListener::PeekAtNextEvent(SBEvent &event) {
bool SBListener::PeekAtNextEventForBroadcaster(const SBBroadcaster &broadcaster,
SBEvent &event) {
LLDB_RECORD_METHOD(bool, SBListener, PeekAtNextEventForBroadcaster,
(const lldb::SBBroadcaster &, lldb::SBEvent &),
broadcaster, event);
LLDB_INSTRUMENT_VA(this, broadcaster, event);
if (m_opaque_sp && broadcaster.IsValid()) {
event.reset(m_opaque_sp->PeekAtNextEventForBroadcaster(broadcaster.get()));
@ -236,9 +217,7 @@ bool SBListener::PeekAtNextEventForBroadcaster(const SBBroadcaster &broadcaster,
bool SBListener::PeekAtNextEventForBroadcasterWithType(
const SBBroadcaster &broadcaster, uint32_t event_type_mask,
SBEvent &event) {
LLDB_RECORD_METHOD(bool, SBListener, PeekAtNextEventForBroadcasterWithType,
(const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &),
broadcaster, event_type_mask, event);
LLDB_INSTRUMENT_VA(this, broadcaster, event_type_mask, event);
if (m_opaque_sp && broadcaster.IsValid()) {
event.reset(m_opaque_sp->PeekAtNextEventForBroadcasterWithType(
@ -250,7 +229,7 @@ bool SBListener::PeekAtNextEventForBroadcasterWithType(
}
bool SBListener::GetNextEvent(SBEvent &event) {
LLDB_RECORD_METHOD(bool, SBListener, GetNextEvent, (lldb::SBEvent &), event);
LLDB_INSTRUMENT_VA(this, event);
if (m_opaque_sp) {
EventSP event_sp;
@ -265,9 +244,7 @@ bool SBListener::GetNextEvent(SBEvent &event) {
bool SBListener::GetNextEventForBroadcaster(const SBBroadcaster &broadcaster,
SBEvent &event) {
LLDB_RECORD_METHOD(bool, SBListener, GetNextEventForBroadcaster,
(const lldb::SBBroadcaster &, lldb::SBEvent &),
broadcaster, event);
LLDB_INSTRUMENT_VA(this, broadcaster, event);
if (m_opaque_sp && broadcaster.IsValid()) {
EventSP event_sp;
@ -284,9 +261,7 @@ bool SBListener::GetNextEventForBroadcaster(const SBBroadcaster &broadcaster,
bool SBListener::GetNextEventForBroadcasterWithType(
const SBBroadcaster &broadcaster, uint32_t event_type_mask,
SBEvent &event) {
LLDB_RECORD_METHOD(bool, SBListener, GetNextEventForBroadcasterWithType,
(const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &),
broadcaster, event_type_mask, event);
LLDB_INSTRUMENT_VA(this, broadcaster, event_type_mask, event);
if (m_opaque_sp && broadcaster.IsValid()) {
EventSP event_sp;
@ -302,8 +277,7 @@ bool SBListener::GetNextEventForBroadcasterWithType(
}
bool SBListener::HandleBroadcastEvent(const SBEvent &event) {
LLDB_RECORD_METHOD(bool, SBListener, HandleBroadcastEvent,
(const lldb::SBEvent &), event);
LLDB_INSTRUMENT_VA(this, event);
if (m_opaque_sp)
return m_opaque_sp->HandleBroadcastEvent(event.GetSP());

52
lldb/source/API/SBMemoryRegionInfo.cpp
View file

@ -7,29 +7,26 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBMemoryRegionInfo.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/API/SBDefines.h"
#include "lldb/API/SBError.h"
#include "lldb/API/SBStream.h"
#include "lldb/Target/MemoryRegionInfo.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb;
using namespace lldb_private;
SBMemoryRegionInfo::SBMemoryRegionInfo() : m_opaque_up(new MemoryRegionInfo()) {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBMemoryRegionInfo);
LLDB_INSTRUMENT_VA(this);
}
SBMemoryRegionInfo::SBMemoryRegionInfo(const char *name, lldb::addr_t begin,
lldb::addr_t end, uint32_t permissions,
bool mapped, bool stack_memory)
: SBMemoryRegionInfo() {
LLDB_RECORD_CONSTRUCTOR(
SBMemoryRegionInfo,
(const char *, lldb::addr_t, lldb::addr_t, uint32_t, bool, bool), name,
begin, end, permissions, mapped, stack_memory);
LLDB_INSTRUMENT_VA(this, name, begin, end, permissions, mapped, stack_memory);
m_opaque_up->SetName(name);
m_opaque_up->GetRange().SetRangeBase(begin);
m_opaque_up->GetRange().SetRangeEnd(end);
@ -47,16 +44,13 @@ SBMemoryRegionInfo::SBMemoryRegionInfo(const MemoryRegionInfo *lldb_object_ptr)
}
SBMemoryRegionInfo::SBMemoryRegionInfo(const SBMemoryRegionInfo &rhs) {
LLDB_RECORD_CONSTRUCTOR(SBMemoryRegionInfo,
(const lldb::SBMemoryRegionInfo &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_up = clone(rhs.m_opaque_up);
}
const SBMemoryRegionInfo &SBMemoryRegionInfo::
operator=(const SBMemoryRegionInfo &rhs) {
LLDB_RECORD_METHOD(
const lldb::SBMemoryRegionInfo &,
SBMemoryRegionInfo, operator=,(const lldb::SBMemoryRegionInfo &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
@ -66,23 +60,19 @@ operator=(const SBMemoryRegionInfo &rhs) {
SBMemoryRegionInfo::~SBMemoryRegionInfo() = default;
void SBMemoryRegionInfo::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBMemoryRegionInfo, Clear);
LLDB_INSTRUMENT_VA(this);
m_opaque_up->Clear();
}
bool SBMemoryRegionInfo::operator==(const SBMemoryRegionInfo &rhs) const {
LLDB_RECORD_METHOD_CONST(
bool, SBMemoryRegionInfo, operator==,(const lldb::SBMemoryRegionInfo &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
return ref() == rhs.ref();
}
bool SBMemoryRegionInfo::operator!=(const SBMemoryRegionInfo &rhs) const {
LLDB_RECORD_METHOD_CONST(
bool, SBMemoryRegionInfo, operator!=,(const lldb::SBMemoryRegionInfo &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
return ref() != rhs.ref();
}
@ -92,55 +82,55 @@ MemoryRegionInfo &SBMemoryRegionInfo::ref() { return *m_opaque_up; }
const MemoryRegionInfo &SBMemoryRegionInfo::ref() const { return *m_opaque_up; }
lldb::addr_t SBMemoryRegionInfo::GetRegionBase() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBMemoryRegionInfo, GetRegionBase);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetRange().GetRangeBase();
}
lldb::addr_t SBMemoryRegionInfo::GetRegionEnd() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBMemoryRegionInfo, GetRegionEnd);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetRange().GetRangeEnd();
}
bool SBMemoryRegionInfo::IsReadable() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsReadable);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetReadable() == MemoryRegionInfo::eYes;
}
bool SBMemoryRegionInfo::IsWritable() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsWritable);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetWritable() == MemoryRegionInfo::eYes;
}
bool SBMemoryRegionInfo::IsExecutable() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsExecutable);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetExecutable() == MemoryRegionInfo::eYes;
}
bool SBMemoryRegionInfo::IsMapped() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsMapped);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetMapped() == MemoryRegionInfo::eYes;
}
const char *SBMemoryRegionInfo::GetName() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBMemoryRegionInfo, GetName);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetName().AsCString();
}
bool SBMemoryRegionInfo::HasDirtyMemoryPageList() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, HasDirtyMemoryPageList);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetDirtyPageList().hasValue();
}
uint32_t SBMemoryRegionInfo::GetNumDirtyPages() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBMemoryRegionInfo, GetNumDirtyPages);
LLDB_INSTRUMENT_VA(this);
uint32_t num_dirty_pages = 0;
llvm::Optional<std::vector<addr_t>> dirty_page_list =
@ -152,8 +142,7 @@ uint32_t SBMemoryRegionInfo::GetNumDirtyPages() {
}
addr_t SBMemoryRegionInfo::GetDirtyPageAddressAtIndex(uint32_t idx) {
LLDB_RECORD_METHOD(lldb::addr_t, SBMemoryRegionInfo,
GetDirtyPageAddressAtIndex, (uint32_t), idx);
LLDB_INSTRUMENT_VA(this, idx);
addr_t dirty_page_addr = LLDB_INVALID_ADDRESS;
const llvm::Optional<std::vector<addr_t>> &dirty_page_list =
@ -165,14 +154,13 @@ addr_t SBMemoryRegionInfo::GetDirtyPageAddressAtIndex(uint32_t idx) {
}
int SBMemoryRegionInfo::GetPageSize() {
LLDB_RECORD_METHOD_NO_ARGS(int, SBMemoryRegionInfo, GetPageSize);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetPageSize();
}
bool SBMemoryRegionInfo::GetDescription(SBStream &description) {
LLDB_RECORD_METHOD(bool, SBMemoryRegionInfo, GetDescription,
(lldb::SBStream &), description);
LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();
const addr_t load_addr = m_opaque_up->GetRange().base;

29
lldb/source/API/SBMemoryRegionInfoList.cpp
View file

@ -7,10 +7,10 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBMemoryRegionInfoList.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBMemoryRegionInfo.h"
#include "lldb/API/SBStream.h"
#include "lldb/Target/MemoryRegionInfo.h"
#include "lldb/Utility/Instrumentation.h"
#include <vector>
@ -83,24 +83,20 @@ const MemoryRegionInfos &SBMemoryRegionInfoList::ref() const {
SBMemoryRegionInfoList::SBMemoryRegionInfoList()
: m_opaque_up(new MemoryRegionInfoListImpl()) {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBMemoryRegionInfoList);
LLDB_INSTRUMENT_VA(this);
}
SBMemoryRegionInfoList::SBMemoryRegionInfoList(
const SBMemoryRegionInfoList &rhs)
: m_opaque_up(new MemoryRegionInfoListImpl(*rhs.m_opaque_up)) {
LLDB_RECORD_CONSTRUCTOR(SBMemoryRegionInfoList,
(const lldb::SBMemoryRegionInfoList &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
}
SBMemoryRegionInfoList::~SBMemoryRegionInfoList() = default;
const SBMemoryRegionInfoList &SBMemoryRegionInfoList::
operator=(const SBMemoryRegionInfoList &rhs) {
LLDB_RECORD_METHOD(
const lldb::SBMemoryRegionInfoList &,
SBMemoryRegionInfoList, operator=,(const lldb::SBMemoryRegionInfoList &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
*m_opaque_up = *rhs.m_opaque_up;
@ -109,44 +105,39 @@ operator=(const SBMemoryRegionInfoList &rhs) {
}
uint32_t SBMemoryRegionInfoList::GetSize() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBMemoryRegionInfoList, GetSize);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetSize();
}
bool SBMemoryRegionInfoList::GetMemoryRegionContainingAddress(
lldb::addr_t addr, SBMemoryRegionInfo &region_info) {
LLDB_RECORD_METHOD(
bool, SBMemoryRegionInfoList, GetMemoryRegionContainingAddress,
(lldb::addr_t, lldb::SBMemoryRegionInfo &), addr, region_info);
LLDB_INSTRUMENT_VA(this, addr, region_info);
return m_opaque_up->GetMemoryRegionContainingAddress(addr, region_info.ref());
}
bool SBMemoryRegionInfoList::GetMemoryRegionAtIndex(
uint32_t idx, SBMemoryRegionInfo &region_info) {
LLDB_RECORD_METHOD(bool, SBMemoryRegionInfoList, GetMemoryRegionAtIndex,
(uint32_t, lldb::SBMemoryRegionInfo &), idx, region_info);
LLDB_INSTRUMENT_VA(this, idx, region_info);
return m_opaque_up->GetMemoryRegionInfoAtIndex(idx, region_info.ref());
}
void SBMemoryRegionInfoList::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBMemoryRegionInfoList, Clear);
LLDB_INSTRUMENT_VA(this);
m_opaque_up->Clear();
}
void SBMemoryRegionInfoList::Append(SBMemoryRegionInfo &sb_region) {
LLDB_RECORD_METHOD(void, SBMemoryRegionInfoList, Append,
(lldb::SBMemoryRegionInfo &), sb_region);
LLDB_INSTRUMENT_VA(this, sb_region);
m_opaque_up->Append(sb_region.ref());
}
void SBMemoryRegionInfoList::Append(SBMemoryRegionInfoList &sb_region_list) {
LLDB_RECORD_METHOD(void, SBMemoryRegionInfoList, Append,
(lldb::SBMemoryRegionInfoList &), sb_region_list);
LLDB_INSTRUMENT_VA(this, sb_region_list);
m_opaque_up->Append(*sb_region_list);
}

129
lldb/source/API/SBModule.cpp
View file

@ -7,7 +7,6 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBModule.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBFileSpec.h"
#include "lldb/API/SBModuleSpec.h"
@ -24,17 +23,18 @@
#include "lldb/Symbol/TypeSystem.h"
#include "lldb/Symbol/VariableList.h"
#include "lldb/Target/Target.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb;
using namespace lldb_private;
SBModule::SBModule() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBModule); }
SBModule::SBModule() { LLDB_INSTRUMENT_VA(this); }
SBModule::SBModule(const lldb::ModuleSP &module_sp) : m_opaque_sp(module_sp) {}
SBModule::SBModule(const SBModuleSpec &module_spec) {
LLDB_RECORD_CONSTRUCTOR(SBModule, (const lldb::SBModuleSpec &), module_spec);
LLDB_INSTRUMENT_VA(this, module_spec);
ModuleSP module_sp;
Status error = ModuleList::GetSharedModule(
@ -44,12 +44,11 @@ SBModule::SBModule(const SBModuleSpec &module_spec) {
}
SBModule::SBModule(const SBModule &rhs) : m_opaque_sp(rhs.m_opaque_sp) {
LLDB_RECORD_CONSTRUCTOR(SBModule, (const lldb::SBModule &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
}
SBModule::SBModule(lldb::SBProcess &process, lldb::addr_t header_addr) {
LLDB_RECORD_CONSTRUCTOR(SBModule, (lldb::SBProcess &, lldb::addr_t), process,
header_addr);
LLDB_INSTRUMENT_VA(this, process, header_addr);
ProcessSP process_sp(process.GetSP());
if (process_sp) {
@ -64,8 +63,7 @@ SBModule::SBModule(lldb::SBProcess &process, lldb::addr_t header_addr) {
}
const SBModule &SBModule::operator=(const SBModule &rhs) {
LLDB_RECORD_METHOD(const lldb::SBModule &, SBModule, operator=,
(const lldb::SBModule &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_sp = rhs.m_opaque_sp;
@ -75,23 +73,23 @@ const SBModule &SBModule::operator=(const SBModule &rhs) {
SBModule::~SBModule() = default;
bool SBModule::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModule, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBModule::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModule, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp.get() != nullptr;
}
void SBModule::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBModule, Clear);
LLDB_INSTRUMENT_VA(this);
m_opaque_sp.reset();
}
SBFileSpec SBModule::GetFileSpec() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule, GetFileSpec);
LLDB_INSTRUMENT_VA(this);
SBFileSpec file_spec;
ModuleSP module_sp(GetSP());
@ -102,8 +100,7 @@ SBFileSpec SBModule::GetFileSpec() const {
}
lldb::SBFileSpec SBModule::GetPlatformFileSpec() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule,
GetPlatformFileSpec);
LLDB_INSTRUMENT_VA(this);
SBFileSpec file_spec;
ModuleSP module_sp(GetSP());
@ -114,8 +111,7 @@ lldb::SBFileSpec SBModule::GetPlatformFileSpec() const {
}
bool SBModule::SetPlatformFileSpec(const lldb::SBFileSpec &platform_file) {
LLDB_RECORD_METHOD(bool, SBModule, SetPlatformFileSpec,
(const lldb::SBFileSpec &), platform_file);
LLDB_INSTRUMENT_VA(this, platform_file);
bool result = false;
@ -129,8 +125,7 @@ bool SBModule::SetPlatformFileSpec(const lldb::SBFileSpec &platform_file) {
}
lldb::SBFileSpec SBModule::GetRemoteInstallFileSpec() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModule,
GetRemoteInstallFileSpec);
LLDB_INSTRUMENT_VA(this);
SBFileSpec sb_file_spec;
ModuleSP module_sp(GetSP());
@ -140,8 +135,7 @@ lldb::SBFileSpec SBModule::GetRemoteInstallFileSpec() {
}
bool SBModule::SetRemoteInstallFileSpec(lldb::SBFileSpec &file) {
LLDB_RECORD_METHOD(bool, SBModule, SetRemoteInstallFileSpec,
(lldb::SBFileSpec &), file);
LLDB_INSTRUMENT_VA(this, file);
ModuleSP module_sp(GetSP());
if (module_sp) {
@ -152,7 +146,7 @@ bool SBModule::SetRemoteInstallFileSpec(lldb::SBFileSpec &file) {
}
const uint8_t *SBModule::GetUUIDBytes() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(const uint8_t *, SBModule, GetUUIDBytes);
LLDB_INSTRUMENT_VA(this);
const uint8_t *uuid_bytes = nullptr;
ModuleSP module_sp(GetSP());
@ -163,7 +157,7 @@ const uint8_t *SBModule::GetUUIDBytes() const {
}
const char *SBModule::GetUUIDString() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBModule, GetUUIDString);
LLDB_INSTRUMENT_VA(this);
const char *uuid_cstr = nullptr;
ModuleSP module_sp(GetSP());
@ -183,8 +177,7 @@ const char *SBModule::GetUUIDString() const {
}
bool SBModule::operator==(const SBModule &rhs) const {
LLDB_RECORD_METHOD_CONST(bool, SBModule, operator==, (const lldb::SBModule &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (m_opaque_sp)
return m_opaque_sp.get() == rhs.m_opaque_sp.get();
@ -192,8 +185,7 @@ bool SBModule::operator==(const SBModule &rhs) const {
}
bool SBModule::operator!=(const SBModule &rhs) const {
LLDB_RECORD_METHOD_CONST(bool, SBModule, operator!=, (const lldb::SBModule &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (m_opaque_sp)
return m_opaque_sp.get() != rhs.m_opaque_sp.get();
@ -205,8 +197,7 @@ ModuleSP SBModule::GetSP() const { return m_opaque_sp; }
void SBModule::SetSP(const ModuleSP &module_sp) { m_opaque_sp = module_sp; }
SBAddress SBModule::ResolveFileAddress(lldb::addr_t vm_addr) {
LLDB_RECORD_METHOD(lldb::SBAddress, SBModule, ResolveFileAddress,
(lldb::addr_t), vm_addr);
LLDB_INSTRUMENT_VA(this, vm_addr);
lldb::SBAddress sb_addr;
ModuleSP module_sp(GetSP());
@ -221,9 +212,7 @@ SBAddress SBModule::ResolveFileAddress(lldb::addr_t vm_addr) {
SBSymbolContext
SBModule::ResolveSymbolContextForAddress(const SBAddress &addr,
uint32_t resolve_scope) {
LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBModule,
ResolveSymbolContextForAddress,
(const lldb::SBAddress &, uint32_t), addr, resolve_scope);
LLDB_INSTRUMENT_VA(this, addr, resolve_scope);
SBSymbolContext sb_sc;
ModuleSP module_sp(GetSP());
@ -234,8 +223,7 @@ SBModule::ResolveSymbolContextForAddress(const SBAddress &addr,
}
bool SBModule::GetDescription(SBStream &description) {
LLDB_RECORD_METHOD(bool, SBModule, GetDescription, (lldb::SBStream &),
description);
LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();
@ -249,7 +237,7 @@ bool SBModule::GetDescription(SBStream &description) {
}
uint32_t SBModule::GetNumCompileUnits() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBModule, GetNumCompileUnits);
LLDB_INSTRUMENT_VA(this);
ModuleSP module_sp(GetSP());
if (module_sp) {
@ -259,8 +247,7 @@ uint32_t SBModule::GetNumCompileUnits() {
}
SBCompileUnit SBModule::GetCompileUnitAtIndex(uint32_t index) {
LLDB_RECORD_METHOD(lldb::SBCompileUnit, SBModule, GetCompileUnitAtIndex,
(uint32_t), index);
LLDB_INSTRUMENT_VA(this, index);
SBCompileUnit sb_cu;
ModuleSP module_sp(GetSP());
@ -272,8 +259,7 @@ SBCompileUnit SBModule::GetCompileUnitAtIndex(uint32_t index) {
}
SBSymbolContextList SBModule::FindCompileUnits(const SBFileSpec &sb_file_spec) {
LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBModule, FindCompileUnits,
(const lldb::SBFileSpec &), sb_file_spec);
LLDB_INSTRUMENT_VA(this, sb_file_spec);
SBSymbolContextList sb_sc_list;
const ModuleSP module_sp(GetSP());
@ -290,7 +276,7 @@ static Symtab *GetUnifiedSymbolTable(const lldb::ModuleSP &module_sp) {
}
size_t SBModule::GetNumSymbols() {
LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModule, GetNumSymbols);
LLDB_INSTRUMENT_VA(this);
ModuleSP module_sp(GetSP());
if (Symtab *symtab = GetUnifiedSymbolTable(module_sp))
@ -299,7 +285,7 @@ size_t SBModule::GetNumSymbols() {
}
SBSymbol SBModule::GetSymbolAtIndex(size_t idx) {
LLDB_RECORD_METHOD(lldb::SBSymbol, SBModule, GetSymbolAtIndex, (size_t), idx);
LLDB_INSTRUMENT_VA(this, idx);
SBSymbol sb_symbol;
ModuleSP module_sp(GetSP());
@ -311,8 +297,7 @@ SBSymbol SBModule::GetSymbolAtIndex(size_t idx) {
lldb::SBSymbol SBModule::FindSymbol(const char *name,
lldb::SymbolType symbol_type) {
LLDB_RECORD_METHOD(lldb::SBSymbol, SBModule, FindSymbol,
(const char *, lldb::SymbolType), name, symbol_type);
LLDB_INSTRUMENT_VA(this, name, symbol_type);
SBSymbol sb_symbol;
if (name && name[0]) {
@ -328,8 +313,7 @@ lldb::SBSymbol SBModule::FindSymbol(const char *name,
lldb::SBSymbolContextList SBModule::FindSymbols(const char *name,
lldb::SymbolType symbol_type) {
LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBModule, FindSymbols,
(const char *, lldb::SymbolType), name, symbol_type);
LLDB_INSTRUMENT_VA(this, name, symbol_type);
SBSymbolContextList sb_sc_list;
if (name && name[0]) {
@ -356,7 +340,7 @@ lldb::SBSymbolContextList SBModule::FindSymbols(const char *name,
}
size_t SBModule::GetNumSections() {
LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModule, GetNumSections);
LLDB_INSTRUMENT_VA(this);
ModuleSP module_sp(GetSP());
if (module_sp) {
@ -370,8 +354,7 @@ size_t SBModule::GetNumSections() {
}
SBSection SBModule::GetSectionAtIndex(size_t idx) {
LLDB_RECORD_METHOD(lldb::SBSection, SBModule, GetSectionAtIndex, (size_t),
idx);
LLDB_INSTRUMENT_VA(this, idx);
SBSection sb_section;
ModuleSP module_sp(GetSP());
@ -388,8 +371,7 @@ SBSection SBModule::GetSectionAtIndex(size_t idx) {
lldb::SBSymbolContextList SBModule::FindFunctions(const char *name,
uint32_t name_type_mask) {
LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBModule, FindFunctions,
(const char *, uint32_t), name, name_type_mask);
LLDB_INSTRUMENT_VA(this, name, name_type_mask);
lldb::SBSymbolContextList sb_sc_list;
ModuleSP module_sp(GetSP());
@ -407,9 +389,7 @@ lldb::SBSymbolContextList SBModule::FindFunctions(const char *name,
SBValueList SBModule::FindGlobalVariables(SBTarget &target, const char *name,
uint32_t max_matches) {
LLDB_RECORD_METHOD(lldb::SBValueList, SBModule, FindGlobalVariables,
(lldb::SBTarget &, const char *, uint32_t), target, name,
max_matches);
LLDB_INSTRUMENT_VA(this, target, name, max_matches);
SBValueList sb_value_list;
ModuleSP module_sp(GetSP());
@ -431,8 +411,7 @@ SBValueList SBModule::FindGlobalVariables(SBTarget &target, const char *name,
lldb::SBValue SBModule::FindFirstGlobalVariable(lldb::SBTarget &target,
const char *name) {
LLDB_RECORD_METHOD(lldb::SBValue, SBModule, FindFirstGlobalVariable,
(lldb::SBTarget &, const char *), target, name);
LLDB_INSTRUMENT_VA(this, target, name);
SBValueList sb_value_list(FindGlobalVariables(target, name, 1));
if (sb_value_list.IsValid() && sb_value_list.GetSize() > 0)
@ -441,8 +420,7 @@ lldb::SBValue SBModule::FindFirstGlobalVariable(lldb::SBTarget &target,
}
lldb::SBType SBModule::FindFirstType(const char *name_cstr) {
LLDB_RECORD_METHOD(lldb::SBType, SBModule, FindFirstType, (const char *),
name_cstr);
LLDB_INSTRUMENT_VA(this, name_cstr);
SBType sb_type;
ModuleSP module_sp(GetSP());
@ -467,8 +445,7 @@ lldb::SBType SBModule::FindFirstType(const char *name_cstr) {
}
lldb::SBType SBModule::GetBasicType(lldb::BasicType type) {
LLDB_RECORD_METHOD(lldb::SBType, SBModule, GetBasicType, (lldb::BasicType),
type);
LLDB_INSTRUMENT_VA(this, type);
ModuleSP module_sp(GetSP());
if (module_sp) {
@ -484,8 +461,7 @@ lldb::SBType SBModule::GetBasicType(lldb::BasicType type) {
}
lldb::SBTypeList SBModule::FindTypes(const char *type) {
LLDB_RECORD_METHOD(lldb::SBTypeList, SBModule, FindTypes, (const char *),
type);
LLDB_INSTRUMENT_VA(this, type);
SBTypeList retval;
@ -521,8 +497,7 @@ lldb::SBTypeList SBModule::FindTypes(const char *type) {
}
lldb::SBType SBModule::GetTypeByID(lldb::user_id_t uid) {
LLDB_RECORD_METHOD(lldb::SBType, SBModule, GetTypeByID, (lldb::user_id_t),
uid);
LLDB_INSTRUMENT_VA(this, uid);
ModuleSP module_sp(GetSP());
if (module_sp) {
@ -536,8 +511,7 @@ lldb::SBType SBModule::GetTypeByID(lldb::user_id_t uid) {
}
lldb::SBTypeList SBModule::GetTypes(uint32_t type_mask) {
LLDB_RECORD_METHOD(lldb::SBTypeList, SBModule, GetTypes, (uint32_t),
type_mask);
LLDB_INSTRUMENT_VA(this, type_mask);
SBTypeList sb_type_list;
@ -556,8 +530,7 @@ lldb::SBTypeList SBModule::GetTypes(uint32_t type_mask) {
}
SBSection SBModule::FindSection(const char *sect_name) {
LLDB_RECORD_METHOD(lldb::SBSection, SBModule, FindSection, (const char *),
sect_name);
LLDB_INSTRUMENT_VA(this, sect_name);
SBSection sb_section;
@ -578,7 +551,7 @@ SBSection SBModule::FindSection(const char *sect_name) {
}
lldb::ByteOrder SBModule::GetByteOrder() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::ByteOrder, SBModule, GetByteOrder);
LLDB_INSTRUMENT_VA(this);
ModuleSP module_sp(GetSP());
if (module_sp)
@ -587,7 +560,7 @@ lldb::ByteOrder SBModule::GetByteOrder() {
}
const char *SBModule::GetTriple() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBModule, GetTriple);
LLDB_INSTRUMENT_VA(this);
ModuleSP module_sp(GetSP());
if (module_sp) {
@ -602,7 +575,7 @@ const char *SBModule::GetTriple() {
}
uint32_t SBModule::GetAddressByteSize() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBModule, GetAddressByteSize);
LLDB_INSTRUMENT_VA(this);
ModuleSP module_sp(GetSP());
if (module_sp)
@ -611,8 +584,7 @@ uint32_t SBModule::GetAddressByteSize() {
}
uint32_t SBModule::GetVersion(uint32_t *versions, uint32_t num_versions) {
LLDB_RECORD_METHOD(uint32_t, SBModule, GetVersion, (uint32_t *, uint32_t),
versions, num_versions);
LLDB_INSTRUMENT_VA(this, versions, num_versions);
llvm::VersionTuple version;
if (ModuleSP module_sp = GetSP())
@ -640,8 +612,7 @@ uint32_t SBModule::GetVersion(uint32_t *versions, uint32_t num_versions) {
}
lldb::SBFileSpec SBModule::GetSymbolFileSpec() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule,
GetSymbolFileSpec);
LLDB_INSTRUMENT_VA(this);
lldb::SBFileSpec sb_file_spec;
ModuleSP module_sp(GetSP());
@ -653,8 +624,7 @@ lldb::SBFileSpec SBModule::GetSymbolFileSpec() const {
}
lldb::SBAddress SBModule::GetObjectFileHeaderAddress() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBModule,
GetObjectFileHeaderAddress);
LLDB_INSTRUMENT_VA(this);
lldb::SBAddress sb_addr;
ModuleSP module_sp(GetSP());
@ -667,8 +637,7 @@ lldb::SBAddress SBModule::GetObjectFileHeaderAddress() const {
}
lldb::SBAddress SBModule::GetObjectFileEntryPointAddress() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBModule,
GetObjectFileEntryPointAddress);
LLDB_INSTRUMENT_VA(this);
lldb::SBAddress sb_addr;
ModuleSP module_sp(GetSP());
@ -681,15 +650,13 @@ lldb::SBAddress SBModule::GetObjectFileEntryPointAddress() const {
}
uint32_t SBModule::GetNumberAllocatedModules() {
LLDB_RECORD_STATIC_METHOD_NO_ARGS(uint32_t, SBModule,
GetNumberAllocatedModules);
LLDB_INSTRUMENT();
return Module::GetNumberAllocatedModules();
}
void SBModule::GarbageCollectAllocatedModules() {
LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBModule,
GarbageCollectAllocatedModules);
LLDB_INSTRUMENT();
const bool mandatory = false;
ModuleList::RemoveOrphanSharedModules(mandatory);

80
lldb/source/API/SBModuleSpec.cpp
View file

@ -7,31 +7,30 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBModuleSpec.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/API/SBStream.h"
#include "lldb/Core/Module.h"
#include "lldb/Core/ModuleSpec.h"
#include "lldb/Host/Host.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/Stream.h"
using namespace lldb;
using namespace lldb_private;
SBModuleSpec::SBModuleSpec() : m_opaque_up(new lldb_private::ModuleSpec()) {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBModuleSpec);
LLDB_INSTRUMENT_VA(this);
}
SBModuleSpec::SBModuleSpec(const SBModuleSpec &rhs) {
LLDB_RECORD_CONSTRUCTOR(SBModuleSpec, (const lldb::SBModuleSpec &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_up = clone(rhs.m_opaque_up);
}
const SBModuleSpec &SBModuleSpec::operator=(const SBModuleSpec &rhs) {
LLDB_RECORD_METHOD(const lldb::SBModuleSpec &,
SBModuleSpec, operator=,(const lldb::SBModuleSpec &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
@ -41,76 +40,72 @@ const SBModuleSpec &SBModuleSpec::operator=(const SBModuleSpec &rhs) {
SBModuleSpec::~SBModuleSpec() = default;
bool SBModuleSpec::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModuleSpec, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBModuleSpec::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModuleSpec, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->operator bool();
}
void SBModuleSpec::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBModuleSpec, Clear);
LLDB_INSTRUMENT_VA(this);
m_opaque_up->Clear();
}
SBFileSpec SBModuleSpec::GetFileSpec() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModuleSpec, GetFileSpec);
LLDB_INSTRUMENT_VA(this);
SBFileSpec sb_spec(m_opaque_up->GetFileSpec());
return sb_spec;
}
void SBModuleSpec::SetFileSpec(const lldb::SBFileSpec &sb_spec) {
LLDB_RECORD_METHOD(void, SBModuleSpec, SetFileSpec,
(const lldb::SBFileSpec &), sb_spec);
LLDB_INSTRUMENT_VA(this, sb_spec);
m_opaque_up->GetFileSpec() = *sb_spec;
}
lldb::SBFileSpec SBModuleSpec::GetPlatformFileSpec() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModuleSpec,
GetPlatformFileSpec);
LLDB_INSTRUMENT_VA(this);
return SBFileSpec(m_opaque_up->GetPlatformFileSpec());
}
void SBModuleSpec::SetPlatformFileSpec(const lldb::SBFileSpec &sb_spec) {
LLDB_RECORD_METHOD(void, SBModuleSpec, SetPlatformFileSpec,
(const lldb::SBFileSpec &), sb_spec);
LLDB_INSTRUMENT_VA(this, sb_spec);
m_opaque_up->GetPlatformFileSpec() = *sb_spec;
}
lldb::SBFileSpec SBModuleSpec::GetSymbolFileSpec() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModuleSpec, GetSymbolFileSpec);
LLDB_INSTRUMENT_VA(this);
return SBFileSpec(m_opaque_up->GetSymbolFileSpec());
}
void SBModuleSpec::SetSymbolFileSpec(const lldb::SBFileSpec &sb_spec) {
LLDB_RECORD_METHOD(void, SBModuleSpec, SetSymbolFileSpec,
(const lldb::SBFileSpec &), sb_spec);
LLDB_INSTRUMENT_VA(this, sb_spec);
m_opaque_up->GetSymbolFileSpec() = *sb_spec;
}
const char *SBModuleSpec::GetObjectName() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBModuleSpec, GetObjectName);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetObjectName().GetCString();
}
void SBModuleSpec::SetObjectName(const char *name) {
LLDB_RECORD_METHOD(void, SBModuleSpec, SetObjectName, (const char *), name);
LLDB_INSTRUMENT_VA(this, name);
m_opaque_up->GetObjectName().SetCString(name);
}
const char *SBModuleSpec::GetTriple() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBModuleSpec, GetTriple);
LLDB_INSTRUMENT_VA(this);
std::string triple(m_opaque_up->GetArchitecture().GetTriple().str());
// Unique the string so we don't run into ownership issues since the const
@ -121,48 +116,46 @@ const char *SBModuleSpec::GetTriple() {
}
void SBModuleSpec::SetTriple(const char *triple) {
LLDB_RECORD_METHOD(void, SBModuleSpec, SetTriple, (const char *), triple);
LLDB_INSTRUMENT_VA(this, triple);
m_opaque_up->GetArchitecture().SetTriple(triple);
}
const uint8_t *SBModuleSpec::GetUUIDBytes() {
LLDB_INSTRUMENT_VA(this)
return m_opaque_up->GetUUID().GetBytes().data();
}
size_t SBModuleSpec::GetUUIDLength() {
LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModuleSpec, GetUUIDLength);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetUUID().GetBytes().size();
}
bool SBModuleSpec::SetUUIDBytes(const uint8_t *uuid, size_t uuid_len) {
LLDB_INSTRUMENT_VA(this, uuid, uuid_len)
m_opaque_up->GetUUID() = UUID::fromOptionalData(uuid, uuid_len);
return m_opaque_up->GetUUID().IsValid();
}
bool SBModuleSpec::GetDescription(lldb::SBStream &description) {
LLDB_RECORD_METHOD(bool, SBModuleSpec, GetDescription, (lldb::SBStream &),
description);
LLDB_INSTRUMENT_VA(this, description);
m_opaque_up->Dump(description.ref());
return true;
}
SBModuleSpecList::SBModuleSpecList() : m_opaque_up(new ModuleSpecList()) {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBModuleSpecList);
LLDB_INSTRUMENT_VA(this);
}
SBModuleSpecList::SBModuleSpecList(const SBModuleSpecList &rhs)
: m_opaque_up(new ModuleSpecList(*rhs.m_opaque_up)) {
LLDB_RECORD_CONSTRUCTOR(SBModuleSpecList, (const lldb::SBModuleSpecList &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
}
SBModuleSpecList &SBModuleSpecList::operator=(const SBModuleSpecList &rhs) {
LLDB_RECORD_METHOD(
lldb::SBModuleSpecList &,
SBModuleSpecList, operator=,(const lldb::SBModuleSpecList &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
*m_opaque_up = *rhs.m_opaque_up;
@ -172,8 +165,7 @@ SBModuleSpecList &SBModuleSpecList::operator=(const SBModuleSpecList &rhs) {
SBModuleSpecList::~SBModuleSpecList() = default;
SBModuleSpecList SBModuleSpecList::GetModuleSpecifications(const char *path) {
LLDB_RECORD_STATIC_METHOD(lldb::SBModuleSpecList, SBModuleSpecList,
GetModuleSpecifications, (const char *), path);
LLDB_INSTRUMENT_VA(path);
SBModuleSpecList specs;
FileSpec file_spec(path);
@ -184,28 +176,25 @@ SBModuleSpecList SBModuleSpecList::GetModuleSpecifications(const char *path) {
}
void SBModuleSpecList::Append(const SBModuleSpec &spec) {
LLDB_RECORD_METHOD(void, SBModuleSpecList, Append,
(const lldb::SBModuleSpec &), spec);
LLDB_INSTRUMENT_VA(this, spec);
m_opaque_up->Append(*spec.m_opaque_up);
}
void SBModuleSpecList::Append(const SBModuleSpecList &spec_list) {
LLDB_RECORD_METHOD(void, SBModuleSpecList, Append,
(const lldb::SBModuleSpecList &), spec_list);
LLDB_INSTRUMENT_VA(this, spec_list);
m_opaque_up->Append(*spec_list.m_opaque_up);
}
size_t SBModuleSpecList::GetSize() {
LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModuleSpecList, GetSize);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetSize();
}
SBModuleSpec SBModuleSpecList::GetSpecAtIndex(size_t i) {
LLDB_RECORD_METHOD(lldb::SBModuleSpec, SBModuleSpecList, GetSpecAtIndex,
(size_t), i);
LLDB_INSTRUMENT_VA(this, i);
SBModuleSpec sb_module_spec;
m_opaque_up->GetModuleSpecAtIndex(i, *sb_module_spec.m_opaque_up);
@ -214,9 +203,7 @@ SBModuleSpec SBModuleSpecList::GetSpecAtIndex(size_t i) {
SBModuleSpec
SBModuleSpecList::FindFirstMatchingSpec(const SBModuleSpec &match_spec) {
LLDB_RECORD_METHOD(lldb::SBModuleSpec, SBModuleSpecList,
FindFirstMatchingSpec, (const lldb::SBModuleSpec &),
match_spec);
LLDB_INSTRUMENT_VA(this, match_spec);
SBModuleSpec sb_module_spec;
m_opaque_up->FindMatchingModuleSpec(*match_spec.m_opaque_up,
@ -226,9 +213,7 @@ SBModuleSpecList::FindFirstMatchingSpec(const SBModuleSpec &match_spec) {
SBModuleSpecList
SBModuleSpecList::FindMatchingSpecs(const SBModuleSpec &match_spec) {
LLDB_RECORD_METHOD(lldb::SBModuleSpecList, SBModuleSpecList,
FindMatchingSpecs, (const lldb::SBModuleSpec &),
match_spec);
LLDB_INSTRUMENT_VA(this, match_spec);
SBModuleSpecList specs;
m_opaque_up->FindMatchingModuleSpecs(*match_spec.m_opaque_up,
@ -237,8 +222,7 @@ SBModuleSpecList::FindMatchingSpecs(const SBModuleSpec &match_spec) {
}
bool SBModuleSpecList::GetDescription(lldb::SBStream &description) {
LLDB_RECORD_METHOD(bool, SBModuleSpecList, GetDescription, (lldb::SBStream &),
description);
LLDB_INSTRUMENT_VA(this, description);
m_opaque_up->Dump(description.ref());
return true;

156
lldb/source/API/SBPlatform.cpp
View file

@ -7,7 +7,6 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBPlatform.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBEnvironment.h"
#include "lldb/API/SBError.h"
#include "lldb/API/SBFileSpec.h"
@ -19,6 +18,7 @@
#include "lldb/Target/Target.h"
#include "lldb/Utility/ArchSpec.h"
#include "lldb/Utility/Args.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/Status.h"
#include "llvm/Support/FileSystem.h"
@ -75,14 +75,13 @@ struct PlatformShellCommand {
// SBPlatformConnectOptions
SBPlatformConnectOptions::SBPlatformConnectOptions(const char *url)
: m_opaque_ptr(new PlatformConnectOptions(url)) {
LLDB_RECORD_CONSTRUCTOR(SBPlatformConnectOptions, (const char *), url);
LLDB_INSTRUMENT_VA(this, url);
}
SBPlatformConnectOptions::SBPlatformConnectOptions(
const SBPlatformConnectOptions &rhs)
: m_opaque_ptr(new PlatformConnectOptions()) {
LLDB_RECORD_CONSTRUCTOR(SBPlatformConnectOptions,
(const lldb::SBPlatformConnectOptions &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
*m_opaque_ptr = *rhs.m_opaque_ptr;
}
@ -91,18 +90,14 @@ SBPlatformConnectOptions::~SBPlatformConnectOptions() { delete m_opaque_ptr; }
SBPlatformConnectOptions &
SBPlatformConnectOptions::operator=(const SBPlatformConnectOptions &rhs) {
LLDB_RECORD_METHOD(
SBPlatformConnectOptions &,
SBPlatformConnectOptions, operator=,(
const lldb::SBPlatformConnectOptions &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
*m_opaque_ptr = *rhs.m_opaque_ptr;
return *this;
}
const char *SBPlatformConnectOptions::GetURL() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformConnectOptions, GetURL);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr->m_url.empty())
return nullptr;
@ -110,8 +105,7 @@ const char *SBPlatformConnectOptions::GetURL() {
}
void SBPlatformConnectOptions::SetURL(const char *url) {
LLDB_RECORD_METHOD(void, SBPlatformConnectOptions, SetURL, (const char *),
url);
LLDB_INSTRUMENT_VA(this, url);
if (url && url[0])
m_opaque_ptr->m_url = url;
@ -120,7 +114,7 @@ void SBPlatformConnectOptions::SetURL(const char *url) {
}
bool SBPlatformConnectOptions::GetRsyncEnabled() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBPlatformConnectOptions, GetRsyncEnabled);
LLDB_INSTRUMENT_VA(this);
return m_opaque_ptr->m_rsync_enabled;
}
@ -128,9 +122,8 @@ bool SBPlatformConnectOptions::GetRsyncEnabled() {
void SBPlatformConnectOptions::EnableRsync(
const char *options, const char *remote_path_prefix,
bool omit_hostname_from_remote_path) {
LLDB_RECORD_METHOD(void, SBPlatformConnectOptions, EnableRsync,
(const char *, const char *, bool), options,
remote_path_prefix, omit_hostname_from_remote_path);
LLDB_INSTRUMENT_VA(this, options, remote_path_prefix,
omit_hostname_from_remote_path);
m_opaque_ptr->m_rsync_enabled = true;
m_opaque_ptr->m_rsync_omit_hostname_from_remote_path =
@ -147,21 +140,19 @@ void SBPlatformConnectOptions::EnableRsync(
}
void SBPlatformConnectOptions::DisableRsync() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatformConnectOptions, DisableRsync);
LLDB_INSTRUMENT_VA(this);
m_opaque_ptr->m_rsync_enabled = false;
}
const char *SBPlatformConnectOptions::GetLocalCacheDirectory() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformConnectOptions,
GetLocalCacheDirectory);
LLDB_INSTRUMENT_VA(this);
return m_opaque_ptr->m_local_cache_directory.GetCString();
}
void SBPlatformConnectOptions::SetLocalCacheDirectory(const char *path) {
LLDB_RECORD_METHOD(void, SBPlatformConnectOptions, SetLocalCacheDirectory,
(const char *), path);
LLDB_INSTRUMENT_VA(this, path);
if (path && path[0])
m_opaque_ptr->m_local_cache_directory.SetCString(path);
@ -173,21 +164,18 @@ void SBPlatformConnectOptions::SetLocalCacheDirectory(const char *path) {
SBPlatformShellCommand::SBPlatformShellCommand(const char *shell_interpreter,
const char *shell_command)
: m_opaque_ptr(new PlatformShellCommand(shell_interpreter, shell_command)) {
LLDB_RECORD_CONSTRUCTOR(SBPlatformShellCommand, (const char *, const char *),
shell_interpreter, shell_command);
LLDB_INSTRUMENT_VA(this, shell_interpreter, shell_command);
}
SBPlatformShellCommand::SBPlatformShellCommand(const char *shell_command)
: m_opaque_ptr(new PlatformShellCommand(shell_command)) {
LLDB_RECORD_CONSTRUCTOR(SBPlatformShellCommand, (const char *),
shell_command);
LLDB_INSTRUMENT_VA(this, shell_command);
}
SBPlatformShellCommand::SBPlatformShellCommand(
const SBPlatformShellCommand &rhs)
: m_opaque_ptr(new PlatformShellCommand()) {
LLDB_RECORD_CONSTRUCTOR(SBPlatformShellCommand,
(const lldb::SBPlatformShellCommand &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
*m_opaque_ptr = *rhs.m_opaque_ptr;
}
@ -195,10 +183,7 @@ SBPlatformShellCommand::SBPlatformShellCommand(
SBPlatformShellCommand &
SBPlatformShellCommand::operator=(const SBPlatformShellCommand &rhs) {
LLDB_RECORD_METHOD(
SBPlatformShellCommand &,
SBPlatformShellCommand, operator=,(const lldb::SBPlatformShellCommand &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
*m_opaque_ptr = *rhs.m_opaque_ptr;
return *this;
@ -207,7 +192,7 @@ SBPlatformShellCommand::operator=(const SBPlatformShellCommand &rhs) {
SBPlatformShellCommand::~SBPlatformShellCommand() { delete m_opaque_ptr; }
void SBPlatformShellCommand::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatformShellCommand, Clear);
LLDB_INSTRUMENT_VA(this);
m_opaque_ptr->m_output = std::string();
m_opaque_ptr->m_status = 0;
@ -215,7 +200,7 @@ void SBPlatformShellCommand::Clear() {
}
const char *SBPlatformShellCommand::GetShell() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand, GetShell);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr->m_shell.empty())
return nullptr;
@ -223,8 +208,7 @@ const char *SBPlatformShellCommand::GetShell() {
}
void SBPlatformShellCommand::SetShell(const char *shell_interpreter) {
LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetShell, (const char *),
shell_interpreter);
LLDB_INSTRUMENT_VA(this, shell_interpreter);
if (shell_interpreter && shell_interpreter[0])
m_opaque_ptr->m_shell = shell_interpreter;
@ -233,7 +217,7 @@ void SBPlatformShellCommand::SetShell(const char *shell_interpreter) {
}
const char *SBPlatformShellCommand::GetCommand() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand, GetCommand);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr->m_command.empty())
return nullptr;
@ -241,8 +225,7 @@ const char *SBPlatformShellCommand::GetCommand() {
}
void SBPlatformShellCommand::SetCommand(const char *shell_command) {
LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetCommand, (const char *),
shell_command);
LLDB_INSTRUMENT_VA(this, shell_command);
if (shell_command && shell_command[0])
m_opaque_ptr->m_command = shell_command;
@ -251,8 +234,7 @@ void SBPlatformShellCommand::SetCommand(const char *shell_command) {
}
const char *SBPlatformShellCommand::GetWorkingDirectory() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand,
GetWorkingDirectory);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr->m_working_dir.empty())
return nullptr;
@ -260,8 +242,7 @@ const char *SBPlatformShellCommand::GetWorkingDirectory() {
}
void SBPlatformShellCommand::SetWorkingDirectory(const char *path) {
LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetWorkingDirectory,
(const char *), path);
LLDB_INSTRUMENT_VA(this, path);
if (path && path[0])
m_opaque_ptr->m_working_dir = path;
@ -270,8 +251,7 @@ void SBPlatformShellCommand::SetWorkingDirectory(const char *path) {
}
uint32_t SBPlatformShellCommand::GetTimeoutSeconds() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatformShellCommand,
GetTimeoutSeconds);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr->m_timeout)
return m_opaque_ptr->m_timeout->count();
@ -279,8 +259,7 @@ uint32_t SBPlatformShellCommand::GetTimeoutSeconds() {
}
void SBPlatformShellCommand::SetTimeoutSeconds(uint32_t sec) {
LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetTimeoutSeconds,
(uint32_t), sec);
LLDB_INSTRUMENT_VA(this, sec);
if (sec == UINT32_MAX)
m_opaque_ptr->m_timeout = llvm::None;
@ -289,19 +268,19 @@ void SBPlatformShellCommand::SetTimeoutSeconds(uint32_t sec) {
}
int SBPlatformShellCommand::GetSignal() {
LLDB_RECORD_METHOD_NO_ARGS(int, SBPlatformShellCommand, GetSignal);
LLDB_INSTRUMENT_VA(this);
return m_opaque_ptr->m_signo;
}
int SBPlatformShellCommand::GetStatus() {
LLDB_RECORD_METHOD_NO_ARGS(int, SBPlatformShellCommand, GetStatus);
LLDB_INSTRUMENT_VA(this);
return m_opaque_ptr->m_status;
}
const char *SBPlatformShellCommand::GetOutput() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand, GetOutput);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr->m_output.empty())
return nullptr;
@ -309,10 +288,10 @@ const char *SBPlatformShellCommand::GetOutput() {
}
// SBPlatform
SBPlatform::SBPlatform() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBPlatform); }
SBPlatform::SBPlatform() { LLDB_INSTRUMENT_VA(this); }
SBPlatform::SBPlatform(const char *platform_name) {
LLDB_RECORD_CONSTRUCTOR(SBPlatform, (const char *), platform_name);
LLDB_INSTRUMENT_VA(this, platform_name);
Status error;
if (platform_name && platform_name[0])
@ -320,14 +299,13 @@ SBPlatform::SBPlatform(const char *platform_name) {
}
SBPlatform::SBPlatform(const SBPlatform &rhs) {
LLDB_RECORD_CONSTRUCTOR(SBPlatform, (const lldb::SBPlatform &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_sp = rhs.m_opaque_sp;
}
SBPlatform &SBPlatform::operator=(const SBPlatform &rhs) {
LLDB_RECORD_METHOD(SBPlatform &,
SBPlatform, operator=,(const lldb::SBPlatform &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_sp = rhs.m_opaque_sp;
return *this;
@ -336,8 +314,7 @@ SBPlatform &SBPlatform::operator=(const SBPlatform &rhs) {
SBPlatform::~SBPlatform() = default;
SBPlatform SBPlatform::GetHostPlatform() {
LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBPlatform, SBPlatform,
GetHostPlatform);
LLDB_INSTRUMENT();
SBPlatform host_platform;
host_platform.m_opaque_sp = Platform::GetHostPlatform();
@ -345,23 +322,23 @@ SBPlatform SBPlatform::GetHostPlatform() {
}
bool SBPlatform::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBPlatform, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBPlatform::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBPlatform, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp.get() != nullptr;
}
void SBPlatform::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatform, Clear);
LLDB_INSTRUMENT_VA(this);
m_opaque_sp.reset();
}
const char *SBPlatform::GetName() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetName);
LLDB_INSTRUMENT_VA(this);
PlatformSP platform_sp(GetSP());
if (platform_sp)
@ -376,7 +353,7 @@ void SBPlatform::SetSP(const lldb::PlatformSP &platform_sp) {
}
const char *SBPlatform::GetWorkingDirectory() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetWorkingDirectory);
LLDB_INSTRUMENT_VA(this);
PlatformSP platform_sp(GetSP());
if (platform_sp)
@ -385,8 +362,7 @@ const char *SBPlatform::GetWorkingDirectory() {
}
bool SBPlatform::SetWorkingDirectory(const char *path) {
LLDB_RECORD_METHOD(bool, SBPlatform, SetWorkingDirectory, (const char *),
path);
LLDB_INSTRUMENT_VA(this, path);
PlatformSP platform_sp(GetSP());
if (platform_sp) {
@ -400,8 +376,7 @@ bool SBPlatform::SetWorkingDirectory(const char *path) {
}
SBError SBPlatform::ConnectRemote(SBPlatformConnectOptions &connect_options) {
LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, ConnectRemote,
(lldb::SBPlatformConnectOptions &), connect_options);
LLDB_INSTRUMENT_VA(this, connect_options);
SBError sb_error;
PlatformSP platform_sp(GetSP());
@ -416,7 +391,7 @@ SBError SBPlatform::ConnectRemote(SBPlatformConnectOptions &connect_options) {
}
void SBPlatform::DisconnectRemote() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatform, DisconnectRemote);
LLDB_INSTRUMENT_VA(this);
PlatformSP platform_sp(GetSP());
if (platform_sp)
@ -424,7 +399,7 @@ void SBPlatform::DisconnectRemote() {
}
bool SBPlatform::IsConnected() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBPlatform, IsConnected);
LLDB_INSTRUMENT_VA(this);
PlatformSP platform_sp(GetSP());
if (platform_sp)
@ -433,7 +408,7 @@ bool SBPlatform::IsConnected() {
}
const char *SBPlatform::GetTriple() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetTriple);
LLDB_INSTRUMENT_VA(this);
PlatformSP platform_sp(GetSP());
if (platform_sp) {
@ -448,7 +423,7 @@ const char *SBPlatform::GetTriple() {
}
const char *SBPlatform::GetOSBuild() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetOSBuild);
LLDB_INSTRUMENT_VA(this);
PlatformSP platform_sp(GetSP());
if (platform_sp) {
@ -463,7 +438,7 @@ const char *SBPlatform::GetOSBuild() {
}
const char *SBPlatform::GetOSDescription() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetOSDescription);
LLDB_INSTRUMENT_VA(this);
PlatformSP platform_sp(GetSP());
if (platform_sp) {
@ -478,7 +453,7 @@ const char *SBPlatform::GetOSDescription() {
}
const char *SBPlatform::GetHostname() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetHostname);
LLDB_INSTRUMENT_VA(this);
PlatformSP platform_sp(GetSP());
if (platform_sp)
@ -487,7 +462,7 @@ const char *SBPlatform::GetHostname() {
}
uint32_t SBPlatform::GetOSMajorVersion() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatform, GetOSMajorVersion);
LLDB_INSTRUMENT_VA(this);
llvm::VersionTuple version;
if (PlatformSP platform_sp = GetSP())
@ -496,7 +471,7 @@ uint32_t SBPlatform::GetOSMajorVersion() {
}
uint32_t SBPlatform::GetOSMinorVersion() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatform, GetOSMinorVersion);
LLDB_INSTRUMENT_VA(this);
llvm::VersionTuple version;
if (PlatformSP platform_sp = GetSP())
@ -505,7 +480,7 @@ uint32_t SBPlatform::GetOSMinorVersion() {
}
uint32_t SBPlatform::GetOSUpdateVersion() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatform, GetOSUpdateVersion);
LLDB_INSTRUMENT_VA(this);
llvm::VersionTuple version;
if (PlatformSP platform_sp = GetSP())
@ -514,14 +489,13 @@ uint32_t SBPlatform::GetOSUpdateVersion() {
}
void SBPlatform::SetSDKRoot(const char *sysroot) {
LLDB_RECORD_METHOD(void, SBPlatform, SetSDKRoot, (const char *), sysroot);
LLDB_INSTRUMENT_VA(this, sysroot);
if (PlatformSP platform_sp = GetSP())
platform_sp->SetSDKRootDirectory(ConstString(sysroot));
}
SBError SBPlatform::Get(SBFileSpec &src, SBFileSpec &dst) {
LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Get,
(lldb::SBFileSpec &, lldb::SBFileSpec &), src, dst);
LLDB_INSTRUMENT_VA(this, src, dst);
SBError sb_error;
PlatformSP platform_sp(GetSP());
@ -534,8 +508,7 @@ SBError SBPlatform::Get(SBFileSpec &src, SBFileSpec &dst) {
}
SBError SBPlatform::Put(SBFileSpec &src, SBFileSpec &dst) {
LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Put,
(lldb::SBFileSpec &, lldb::SBFileSpec &), src, dst);
LLDB_INSTRUMENT_VA(this, src, dst);
return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
if (src.Exists()) {
uint32_t permissions = FileSystem::Instance().GetPermissions(src.ref());
@ -557,8 +530,7 @@ SBError SBPlatform::Put(SBFileSpec &src, SBFileSpec &dst) {
}
SBError SBPlatform::Install(SBFileSpec &src, SBFileSpec &dst) {
LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Install,
(lldb::SBFileSpec &, lldb::SBFileSpec &), src, dst);
LLDB_INSTRUMENT_VA(this, src, dst);
return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
if (src.Exists())
return platform_sp->Install(src.ref(), dst.ref());
@ -571,8 +543,7 @@ SBError SBPlatform::Install(SBFileSpec &src, SBFileSpec &dst) {
}
SBError SBPlatform::Run(SBPlatformShellCommand &shell_command) {
LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Run,
(lldb::SBPlatformShellCommand &), shell_command);
LLDB_INSTRUMENT_VA(this, shell_command);
return ExecuteConnected(
[&](const lldb::PlatformSP &platform_sp) {
const char *command = shell_command.GetCommand();
@ -595,8 +566,7 @@ SBError SBPlatform::Run(SBPlatformShellCommand &shell_command) {
}
SBError SBPlatform::Launch(SBLaunchInfo &launch_info) {
LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Launch, (lldb::SBLaunchInfo &),
launch_info);
LLDB_INSTRUMENT_VA(this, launch_info);
return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
ProcessLaunchInfo info = launch_info.ref();
Status error = platform_sp->LaunchProcess(info);
@ -606,7 +576,7 @@ SBError SBPlatform::Launch(SBLaunchInfo &launch_info) {
}
SBError SBPlatform::Kill(const lldb::pid_t pid) {
LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Kill, (const lldb::pid_t), pid);
LLDB_INSTRUMENT_VA(this, pid);
return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
return platform_sp->KillProcess(pid);
});
@ -628,8 +598,7 @@ SBError SBPlatform::ExecuteConnected(
}
SBError SBPlatform::MakeDirectory(const char *path, uint32_t file_permissions) {
LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, MakeDirectory,
(const char *, uint32_t), path, file_permissions);
LLDB_INSTRUMENT_VA(this, path, file_permissions);
SBError sb_error;
PlatformSP platform_sp(GetSP());
@ -643,8 +612,7 @@ SBError SBPlatform::MakeDirectory(const char *path, uint32_t file_permissions) {
}
uint32_t SBPlatform::GetFilePermissions(const char *path) {
LLDB_RECORD_METHOD(uint32_t, SBPlatform, GetFilePermissions, (const char *),
path);
LLDB_INSTRUMENT_VA(this, path);
PlatformSP platform_sp(GetSP());
if (platform_sp) {
@ -657,8 +625,7 @@ uint32_t SBPlatform::GetFilePermissions(const char *path) {
SBError SBPlatform::SetFilePermissions(const char *path,
uint32_t file_permissions) {
LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, SetFilePermissions,
(const char *, uint32_t), path, file_permissions);
LLDB_INSTRUMENT_VA(this, path, file_permissions);
SBError sb_error;
PlatformSP platform_sp(GetSP());
@ -672,8 +639,7 @@ SBError SBPlatform::SetFilePermissions(const char *path,
}
SBUnixSignals SBPlatform::GetUnixSignals() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBUnixSignals, SBPlatform,
GetUnixSignals);
LLDB_INSTRUMENT_VA(this);
if (auto platform_sp = GetSP())
return SBUnixSignals{platform_sp};
@ -682,7 +648,7 @@ SBUnixSignals SBPlatform::GetUnixSignals() const {
}
SBEnvironment SBPlatform::GetEnvironment() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBEnvironment, SBPlatform, GetEnvironment);
LLDB_INSTRUMENT_VA(this);
PlatformSP platform_sp(GetSP());
if (platform_sp) {

245
lldb/source/API/SBProcess.cpp
View file

@ -7,7 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBProcess.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/Utility/Instrumentation.h"
#include <cinttypes>
@ -49,22 +49,21 @@
using namespace lldb;
using namespace lldb_private;
SBProcess::SBProcess() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBProcess); }
SBProcess::SBProcess() { LLDB_INSTRUMENT_VA(this); }
// SBProcess constructor
SBProcess::SBProcess(const SBProcess &rhs) : m_opaque_wp(rhs.m_opaque_wp) {
LLDB_RECORD_CONSTRUCTOR(SBProcess, (const lldb::SBProcess &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
}
SBProcess::SBProcess(const lldb::ProcessSP &process_sp)
: m_opaque_wp(process_sp) {
LLDB_RECORD_CONSTRUCTOR(SBProcess, (const lldb::ProcessSP &), process_sp);
LLDB_INSTRUMENT_VA(this, process_sp);
}
const SBProcess &SBProcess::operator=(const SBProcess &rhs) {
LLDB_RECORD_METHOD(const lldb::SBProcess &,
SBProcess, operator=,(const lldb::SBProcess &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_wp = rhs.m_opaque_wp;
@ -75,14 +74,13 @@ const SBProcess &SBProcess::operator=(const SBProcess &rhs) {
SBProcess::~SBProcess() = default;
const char *SBProcess::GetBroadcasterClassName() {
LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBProcess,
GetBroadcasterClassName);
LLDB_INSTRUMENT();
return Process::GetStaticBroadcasterClass().AsCString();
}
const char *SBProcess::GetPluginName() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetPluginName);
LLDB_INSTRUMENT_VA(this);
ProcessSP process_sp(GetSP());
if (process_sp) {
@ -92,7 +90,7 @@ const char *SBProcess::GetPluginName() {
}
const char *SBProcess::GetShortPluginName() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetShortPluginName);
LLDB_INSTRUMENT_VA(this);
ProcessSP process_sp(GetSP());
if (process_sp) {
@ -106,17 +104,17 @@ lldb::ProcessSP SBProcess::GetSP() const { return m_opaque_wp.lock(); }
void SBProcess::SetSP(const ProcessSP &process_sp) { m_opaque_wp = process_sp; }
void SBProcess::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBProcess, Clear);
LLDB_INSTRUMENT_VA(this);
m_opaque_wp.reset();
}
bool SBProcess::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcess, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBProcess::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcess, operator bool);
LLDB_INSTRUMENT_VA(this);
ProcessSP process_sp(m_opaque_wp.lock());
return ((bool)process_sp && process_sp->IsValid());
@ -128,11 +126,7 @@ bool SBProcess::RemoteLaunch(char const **argv, char const **envp,
const char *working_directory,
uint32_t launch_flags, bool stop_at_entry,
lldb::SBError &error) {
LLDB_RECORD_METHOD(bool, SBProcess, RemoteLaunch,
(const char **, const char **, const char *, const char *,
const char *, const char *, uint32_t, bool,
lldb::SBError &),
argv, envp, stdin_path, stdout_path, stderr_path,
LLDB_INSTRUMENT_VA(this, argv, envp, stdin_path, stdout_path, stderr_path,
working_directory, launch_flags, stop_at_entry, error);
ProcessSP process_sp(GetSP());
@ -165,8 +159,7 @@ bool SBProcess::RemoteLaunch(char const **argv, char const **envp,
bool SBProcess::RemoteAttachToProcessWithID(lldb::pid_t pid,
lldb::SBError &error) {
LLDB_RECORD_METHOD(bool, SBProcess, RemoteAttachToProcessWithID,
(lldb::pid_t, lldb::SBError &), pid, error);
LLDB_INSTRUMENT_VA(this, pid, error);
ProcessSP process_sp(GetSP());
if (process_sp) {
@ -188,7 +181,7 @@ bool SBProcess::RemoteAttachToProcessWithID(lldb::pid_t pid,
}
uint32_t SBProcess::GetNumThreads() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumThreads);
LLDB_INSTRUMENT_VA(this);
uint32_t num_threads = 0;
ProcessSP process_sp(GetSP());
@ -205,8 +198,7 @@ uint32_t SBProcess::GetNumThreads() {
}
SBThread SBProcess::GetSelectedThread() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBProcess,
GetSelectedThread);
LLDB_INSTRUMENT_VA(this);
SBThread sb_thread;
ThreadSP thread_sp;
@ -223,8 +215,7 @@ SBThread SBProcess::GetSelectedThread() const {
SBThread SBProcess::CreateOSPluginThread(lldb::tid_t tid,
lldb::addr_t context) {
LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, CreateOSPluginThread,
(lldb::tid_t, lldb::addr_t), tid, context);
LLDB_INSTRUMENT_VA(this, tid, context);
SBThread sb_thread;
ThreadSP thread_sp;
@ -240,7 +231,7 @@ SBThread SBProcess::CreateOSPluginThread(lldb::tid_t tid,
}
SBTarget SBProcess::GetTarget() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBTarget, SBProcess, GetTarget);
LLDB_INSTRUMENT_VA(this);
SBTarget sb_target;
TargetSP target_sp;
@ -254,8 +245,7 @@ SBTarget SBProcess::GetTarget() const {
}
size_t SBProcess::PutSTDIN(const char *src, size_t src_len) {
LLDB_RECORD_METHOD(size_t, SBProcess, PutSTDIN, (const char *, size_t), src,
src_len);
LLDB_INSTRUMENT_VA(this, src, src_len);
size_t ret_val = 0;
ProcessSP process_sp(GetSP());
@ -268,8 +258,7 @@ size_t SBProcess::PutSTDIN(const char *src, size_t src_len) {
}
size_t SBProcess::GetSTDOUT(char *dst, size_t dst_len) const {
LLDB_RECORD_METHOD_CONST(size_t, SBProcess, GetSTDOUT, (char *, size_t), dst,
"", dst_len);
LLDB_INSTRUMENT_VA(this, dst, dst_len);
size_t bytes_read = 0;
ProcessSP process_sp(GetSP());
@ -282,8 +271,7 @@ size_t SBProcess::GetSTDOUT(char *dst, size_t dst_len) const {
}
size_t SBProcess::GetSTDERR(char *dst, size_t dst_len) const {
LLDB_RECORD_METHOD_CONST(size_t, SBProcess, GetSTDERR, (char *, size_t), dst,
"", dst_len);
LLDB_INSTRUMENT_VA(this, dst, dst_len);
size_t bytes_read = 0;
ProcessSP process_sp(GetSP());
@ -296,8 +284,7 @@ size_t SBProcess::GetSTDERR(char *dst, size_t dst_len) const {
}
size_t SBProcess::GetAsyncProfileData(char *dst, size_t dst_len) const {
LLDB_RECORD_METHOD_CONST(size_t, SBProcess, GetAsyncProfileData,
(char *, size_t), dst, "", dst_len);
LLDB_INSTRUMENT_VA(this, dst, dst_len);
size_t bytes_read = 0;
ProcessSP process_sp(GetSP());
@ -310,23 +297,20 @@ size_t SBProcess::GetAsyncProfileData(char *dst, size_t dst_len) const {
}
void SBProcess::ReportEventState(const SBEvent &event, SBFile out) const {
LLDB_RECORD_METHOD_CONST(void, SBProcess, ReportEventState,
(const SBEvent &, SBFile), event, out);
LLDB_INSTRUMENT_VA(this, event, out);
return ReportEventState(event, out.m_opaque_sp);
}
void SBProcess::ReportEventState(const SBEvent &event, FILE *out) const {
LLDB_RECORD_METHOD_CONST(void, SBProcess, ReportEventState,
(const lldb::SBEvent &, FILE *), event, out);
LLDB_INSTRUMENT_VA(this, event, out);
FileSP outfile = std::make_shared<NativeFile>(out, false);
return ReportEventState(event, outfile);
}
void SBProcess::ReportEventState(const SBEvent &event, FileSP out) const {
LLDB_RECORD_METHOD_CONST(void, SBProcess, ReportEventState,
(const SBEvent &, FileSP), event, out);
LLDB_INSTRUMENT_VA(this, event, out);
if (!out || !out->IsValid())
return;
@ -342,9 +326,7 @@ void SBProcess::ReportEventState(const SBEvent &event, FileSP out) const {
void SBProcess::AppendEventStateReport(const SBEvent &event,
SBCommandReturnObject &result) {
LLDB_RECORD_METHOD(void, SBProcess, AppendEventStateReport,
(const lldb::SBEvent &, lldb::SBCommandReturnObject &),
event, result);
LLDB_INSTRUMENT_VA(this, event, result);
ProcessSP process_sp(GetSP());
if (process_sp) {
@ -358,8 +340,7 @@ void SBProcess::AppendEventStateReport(const SBEvent &event,
}
bool SBProcess::SetSelectedThread(const SBThread &thread) {
LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThread,
(const lldb::SBThread &), thread);
LLDB_INSTRUMENT_VA(this, thread);
ProcessSP process_sp(GetSP());
if (process_sp) {
@ -372,9 +353,7 @@ bool SBProcess::SetSelectedThread(const SBThread &thread) {
}
bool SBProcess::SetSelectedThreadByID(lldb::tid_t tid) {
LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByID, (lldb::tid_t),
tid);
LLDB_INSTRUMENT_VA(this, tid);
bool ret_val = false;
ProcessSP process_sp(GetSP());
@ -388,8 +367,7 @@ bool SBProcess::SetSelectedThreadByID(lldb::tid_t tid) {
}
bool SBProcess::SetSelectedThreadByIndexID(uint32_t index_id) {
LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByIndexID, (uint32_t),
index_id);
LLDB_INSTRUMENT_VA(this, index_id);
bool ret_val = false;
ProcessSP process_sp(GetSP());
@ -404,8 +382,7 @@ bool SBProcess::SetSelectedThreadByIndexID(uint32_t index_id) {
}
SBThread SBProcess::GetThreadAtIndex(size_t index) {
LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadAtIndex, (size_t),
index);
LLDB_INSTRUMENT_VA(this, index);
SBThread sb_thread;
ThreadSP thread_sp;
@ -423,7 +400,7 @@ SBThread SBProcess::GetThreadAtIndex(size_t index) {
}
uint32_t SBProcess::GetNumQueues() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumQueues);
LLDB_INSTRUMENT_VA(this);
uint32_t num_queues = 0;
ProcessSP process_sp(GetSP());
@ -440,8 +417,7 @@ uint32_t SBProcess::GetNumQueues() {
}
SBQueue SBProcess::GetQueueAtIndex(size_t index) {
LLDB_RECORD_METHOD(lldb::SBQueue, SBProcess, GetQueueAtIndex, (size_t),
index);
LLDB_INSTRUMENT_VA(this, index);
SBQueue sb_queue;
QueueSP queue_sp;
@ -460,8 +436,7 @@ SBQueue SBProcess::GetQueueAtIndex(size_t index) {
}
uint32_t SBProcess::GetStopID(bool include_expression_stops) {
LLDB_RECORD_METHOD(uint32_t, SBProcess, GetStopID, (bool),
include_expression_stops);
LLDB_INSTRUMENT_VA(this, include_expression_stops);
ProcessSP process_sp(GetSP());
if (process_sp) {
@ -476,8 +451,7 @@ uint32_t SBProcess::GetStopID(bool include_expression_stops) {
}
SBEvent SBProcess::GetStopEventForStopID(uint32_t stop_id) {
LLDB_RECORD_METHOD(lldb::SBEvent, SBProcess, GetStopEventForStopID,
(uint32_t), stop_id);
LLDB_INSTRUMENT_VA(this, stop_id);
SBEvent sb_event;
EventSP event_sp;
@ -493,7 +467,7 @@ SBEvent SBProcess::GetStopEventForStopID(uint32_t stop_id) {
}
StateType SBProcess::GetState() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::StateType, SBProcess, GetState);
LLDB_INSTRUMENT_VA(this);
StateType ret_val = eStateInvalid;
ProcessSP process_sp(GetSP());
@ -507,7 +481,7 @@ StateType SBProcess::GetState() {
}
int SBProcess::GetExitStatus() {
LLDB_RECORD_METHOD_NO_ARGS(int, SBProcess, GetExitStatus);
LLDB_INSTRUMENT_VA(this);
int exit_status = 0;
ProcessSP process_sp(GetSP());
@ -521,7 +495,7 @@ int SBProcess::GetExitStatus() {
}
const char *SBProcess::GetExitDescription() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetExitDescription);
LLDB_INSTRUMENT_VA(this);
const char *exit_desc = nullptr;
ProcessSP process_sp(GetSP());
@ -534,7 +508,7 @@ const char *SBProcess::GetExitDescription() {
}
lldb::pid_t SBProcess::GetProcessID() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBProcess, GetProcessID);
LLDB_INSTRUMENT_VA(this);
lldb::pid_t ret_val = LLDB_INVALID_PROCESS_ID;
ProcessSP process_sp(GetSP());
@ -545,7 +519,7 @@ lldb::pid_t SBProcess::GetProcessID() {
}
uint32_t SBProcess::GetUniqueID() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetUniqueID);
LLDB_INSTRUMENT_VA(this);
uint32_t ret_val = 0;
ProcessSP process_sp(GetSP());
@ -555,7 +529,7 @@ uint32_t SBProcess::GetUniqueID() {
}
ByteOrder SBProcess::GetByteOrder() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ByteOrder, SBProcess, GetByteOrder);
LLDB_INSTRUMENT_VA(this);
ByteOrder byteOrder = eByteOrderInvalid;
ProcessSP process_sp(GetSP());
@ -567,7 +541,7 @@ ByteOrder SBProcess::GetByteOrder() const {
}
uint32_t SBProcess::GetAddressByteSize() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBProcess, GetAddressByteSize);
LLDB_INSTRUMENT_VA(this);
uint32_t size = 0;
ProcessSP process_sp(GetSP());
@ -579,7 +553,7 @@ uint32_t SBProcess::GetAddressByteSize() const {
}
SBError SBProcess::Continue() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Continue);
LLDB_INSTRUMENT_VA(this);
SBError sb_error;
ProcessSP process_sp(GetSP());
@ -599,7 +573,7 @@ SBError SBProcess::Continue() {
}
SBError SBProcess::Destroy() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Destroy);
LLDB_INSTRUMENT_VA(this);
SBError sb_error;
ProcessSP process_sp(GetSP());
@ -614,7 +588,7 @@ SBError SBProcess::Destroy() {
}
SBError SBProcess::Stop() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Stop);
LLDB_INSTRUMENT_VA(this);
SBError sb_error;
ProcessSP process_sp(GetSP());
@ -629,7 +603,7 @@ SBError SBProcess::Stop() {
}
SBError SBProcess::Kill() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Kill);
LLDB_INSTRUMENT_VA(this);
SBError sb_error;
ProcessSP process_sp(GetSP());
@ -644,7 +618,7 @@ SBError SBProcess::Kill() {
}
SBError SBProcess::Detach() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Detach);
LLDB_INSTRUMENT_VA(this);
// FIXME: This should come from a process default.
bool keep_stopped = false;
@ -652,7 +626,7 @@ SBError SBProcess::Detach() {
}
SBError SBProcess::Detach(bool keep_stopped) {
LLDB_RECORD_METHOD(lldb::SBError, SBProcess, Detach, (bool), keep_stopped);
LLDB_INSTRUMENT_VA(this, keep_stopped);
SBError sb_error;
ProcessSP process_sp(GetSP());
@ -667,7 +641,7 @@ SBError SBProcess::Detach(bool keep_stopped) {
}
SBError SBProcess::Signal(int signo) {
LLDB_RECORD_METHOD(lldb::SBError, SBProcess, Signal, (int), signo);
LLDB_INSTRUMENT_VA(this, signo);
SBError sb_error;
ProcessSP process_sp(GetSP());
@ -682,7 +656,7 @@ SBError SBProcess::Signal(int signo) {
}
SBUnixSignals SBProcess::GetUnixSignals() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBUnixSignals, SBProcess, GetUnixSignals);
LLDB_INSTRUMENT_VA(this);
if (auto process_sp = GetSP())
return SBUnixSignals{process_sp};
@ -691,7 +665,7 @@ SBUnixSignals SBProcess::GetUnixSignals() {
}
void SBProcess::SendAsyncInterrupt() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBProcess, SendAsyncInterrupt);
LLDB_INSTRUMENT_VA(this);
ProcessSP process_sp(GetSP());
if (process_sp) {
@ -700,8 +674,7 @@ void SBProcess::SendAsyncInterrupt() {
}
SBThread SBProcess::GetThreadByID(tid_t tid) {
LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadByID, (lldb::tid_t),
tid);
LLDB_INSTRUMENT_VA(this, tid);
SBThread sb_thread;
ThreadSP thread_sp;
@ -719,8 +692,7 @@ SBThread SBProcess::GetThreadByID(tid_t tid) {
}
SBThread SBProcess::GetThreadByIndexID(uint32_t index_id) {
LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadByIndexID, (uint32_t),
index_id);
LLDB_INSTRUMENT_VA(this, index_id);
SBThread sb_thread;
ThreadSP thread_sp;
@ -739,8 +711,7 @@ SBThread SBProcess::GetThreadByIndexID(uint32_t index_id) {
}
StateType SBProcess::GetStateFromEvent(const SBEvent &event) {
LLDB_RECORD_STATIC_METHOD(lldb::StateType, SBProcess, GetStateFromEvent,
(const lldb::SBEvent &), event);
LLDB_INSTRUMENT_VA(event);
StateType ret_val = Process::ProcessEventData::GetStateFromEvent(event.get());
@ -748,8 +719,7 @@ StateType SBProcess::GetStateFromEvent(const SBEvent &event) {
}
bool SBProcess::GetRestartedFromEvent(const SBEvent &event) {
LLDB_RECORD_STATIC_METHOD(bool, SBProcess, GetRestartedFromEvent,
(const lldb::SBEvent &), event);
LLDB_INSTRUMENT_VA(event);
bool ret_val = Process::ProcessEventData::GetRestartedFromEvent(event.get());
@ -757,8 +727,7 @@ bool SBProcess::GetRestartedFromEvent(const SBEvent &event) {
}
size_t SBProcess::GetNumRestartedReasonsFromEvent(const lldb::SBEvent &event) {
LLDB_RECORD_STATIC_METHOD(size_t, SBProcess, GetNumRestartedReasonsFromEvent,
(const lldb::SBEvent &), event);
LLDB_INSTRUMENT_VA(event);
return Process::ProcessEventData::GetNumRestartedReasons(event.get());
}
@ -766,16 +735,13 @@ size_t SBProcess::GetNumRestartedReasonsFromEvent(const lldb::SBEvent &event) {
const char *
SBProcess::GetRestartedReasonAtIndexFromEvent(const lldb::SBEvent &event,
size_t idx) {
LLDB_RECORD_STATIC_METHOD(const char *, SBProcess,
GetRestartedReasonAtIndexFromEvent,
(const lldb::SBEvent &, size_t), event, idx);
LLDB_INSTRUMENT_VA(event, idx);
return Process::ProcessEventData::GetRestartedReasonAtIndex(event.get(), idx);
}
SBProcess SBProcess::GetProcessFromEvent(const SBEvent &event) {
LLDB_RECORD_STATIC_METHOD(lldb::SBProcess, SBProcess, GetProcessFromEvent,
(const lldb::SBEvent &), event);
LLDB_INSTRUMENT_VA(event);
ProcessSP process_sp =
Process::ProcessEventData::GetProcessFromEvent(event.get());
@ -788,32 +754,27 @@ SBProcess SBProcess::GetProcessFromEvent(const SBEvent &event) {
}
bool SBProcess::GetInterruptedFromEvent(const SBEvent &event) {
LLDB_RECORD_STATIC_METHOD(bool, SBProcess, GetInterruptedFromEvent,
(const lldb::SBEvent &), event);
LLDB_INSTRUMENT_VA(event);
return Process::ProcessEventData::GetInterruptedFromEvent(event.get());
}
lldb::SBStructuredData
SBProcess::GetStructuredDataFromEvent(const lldb::SBEvent &event) {
LLDB_RECORD_STATIC_METHOD(lldb::SBStructuredData, SBProcess,
GetStructuredDataFromEvent, (const lldb::SBEvent &),
event);
LLDB_INSTRUMENT_VA(event);
return SBStructuredData(event.GetSP());
}
bool SBProcess::EventIsProcessEvent(const SBEvent &event) {
LLDB_RECORD_STATIC_METHOD(bool, SBProcess, EventIsProcessEvent,
(const lldb::SBEvent &), event);
LLDB_INSTRUMENT_VA(event);
return (event.GetBroadcasterClass() == SBProcess::GetBroadcasterClass()) &&
!EventIsStructuredDataEvent(event);
}
bool SBProcess::EventIsStructuredDataEvent(const lldb::SBEvent &event) {
LLDB_RECORD_STATIC_METHOD(bool, SBProcess, EventIsStructuredDataEvent,
(const lldb::SBEvent &), event);
LLDB_INSTRUMENT_VA(event);
EventSP event_sp = event.GetSP();
EventData *event_data = event_sp ? event_sp->GetData() : nullptr;
@ -822,9 +783,7 @@ bool SBProcess::EventIsStructuredDataEvent(const lldb::SBEvent &event) {
}
SBBroadcaster SBProcess::GetBroadcaster() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBProcess,
GetBroadcaster);
LLDB_INSTRUMENT_VA(this);
ProcessSP process_sp(GetSP());
@ -834,17 +793,14 @@ SBBroadcaster SBProcess::GetBroadcaster() const {
}
const char *SBProcess::GetBroadcasterClass() {
LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBProcess,
GetBroadcasterClass);
LLDB_INSTRUMENT();
return Process::GetStaticBroadcasterClass().AsCString();
}
size_t SBProcess::ReadMemory(addr_t addr, void *dst, size_t dst_len,
SBError &sb_error) {
LLDB_RECORD_METHOD(size_t, SBProcess, ReadMemory,
(lldb::addr_t, void *, size_t, lldb::SBError &), addr, dst,
dst_len, sb_error);
LLDB_INSTRUMENT_VA(this, addr, dst, dst_len, sb_error);
size_t bytes_read = 0;
@ -869,9 +825,7 @@ size_t SBProcess::ReadMemory(addr_t addr, void *dst, size_t dst_len,
size_t SBProcess::ReadCStringFromMemory(addr_t addr, void *buf, size_t size,
lldb::SBError &sb_error) {
LLDB_RECORD_METHOD(size_t, SBProcess, ReadCStringFromMemory,
(lldb::addr_t, void *, size_t, lldb::SBError &), addr, buf,
size, sb_error);
LLDB_INSTRUMENT_VA(this, addr, buf, size, sb_error);
size_t bytes_read = 0;
ProcessSP process_sp(GetSP());
@ -893,9 +847,7 @@ size_t SBProcess::ReadCStringFromMemory(addr_t addr, void *buf, size_t size,
uint64_t SBProcess::ReadUnsignedFromMemory(addr_t addr, uint32_t byte_size,
lldb::SBError &sb_error) {
LLDB_RECORD_METHOD(uint64_t, SBProcess, ReadUnsignedFromMemory,
(lldb::addr_t, uint32_t, lldb::SBError &), addr, byte_size,
sb_error);
LLDB_INSTRUMENT_VA(this, addr, byte_size, sb_error);
uint64_t value = 0;
ProcessSP process_sp(GetSP());
@ -917,8 +869,7 @@ uint64_t SBProcess::ReadUnsignedFromMemory(addr_t addr, uint32_t byte_size,
lldb::addr_t SBProcess::ReadPointerFromMemory(addr_t addr,
lldb::SBError &sb_error) {
LLDB_RECORD_METHOD(lldb::addr_t, SBProcess, ReadPointerFromMemory,
(lldb::addr_t, lldb::SBError &), addr, sb_error);
LLDB_INSTRUMENT_VA(this, addr, sb_error);
lldb::addr_t ptr = LLDB_INVALID_ADDRESS;
ProcessSP process_sp(GetSP());
@ -939,9 +890,7 @@ lldb::addr_t SBProcess::ReadPointerFromMemory(addr_t addr,
size_t SBProcess::WriteMemory(addr_t addr, const void *src, size_t src_len,
SBError &sb_error) {
LLDB_RECORD_METHOD(size_t, SBProcess, WriteMemory,
(lldb::addr_t, const void *, size_t, lldb::SBError &),
addr, src, src_len, sb_error);
LLDB_INSTRUMENT_VA(this, addr, src, src_len, sb_error);
size_t bytes_written = 0;
@ -963,8 +912,7 @@ size_t SBProcess::WriteMemory(addr_t addr, const void *src, size_t src_len,
}
bool SBProcess::GetDescription(SBStream &description) {
LLDB_RECORD_METHOD(bool, SBProcess, GetDescription, (lldb::SBStream &),
description);
LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();
@ -988,8 +936,7 @@ bool SBProcess::GetDescription(SBStream &description) {
}
SBStructuredData SBProcess::GetExtendedCrashInformation() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStructuredData, SBProcess,
GetExtendedCrashInformation);
LLDB_INSTRUMENT_VA(this);
SBStructuredData data;
ProcessSP process_sp(GetSP());
if (!process_sp)
@ -1013,9 +960,7 @@ SBStructuredData SBProcess::GetExtendedCrashInformation() {
uint32_t
SBProcess::GetNumSupportedHardwareWatchpoints(lldb::SBError &sb_error) const {
LLDB_RECORD_METHOD_CONST(uint32_t, SBProcess,
GetNumSupportedHardwareWatchpoints,
(lldb::SBError &), sb_error);
LLDB_INSTRUMENT_VA(this, sb_error);
uint32_t num = 0;
ProcessSP process_sp(GetSP());
@ -1031,9 +976,7 @@ SBProcess::GetNumSupportedHardwareWatchpoints(lldb::SBError &sb_error) const {
uint32_t SBProcess::LoadImage(lldb::SBFileSpec &sb_remote_image_spec,
lldb::SBError &sb_error) {
LLDB_RECORD_METHOD(uint32_t, SBProcess, LoadImage,
(lldb::SBFileSpec &, lldb::SBError &),
sb_remote_image_spec, sb_error);
LLDB_INSTRUMENT_VA(this, sb_remote_image_spec, sb_error);
return LoadImage(SBFileSpec(), sb_remote_image_spec, sb_error);
}
@ -1041,10 +984,7 @@ uint32_t SBProcess::LoadImage(lldb::SBFileSpec &sb_remote_image_spec,
uint32_t SBProcess::LoadImage(const lldb::SBFileSpec &sb_local_image_spec,
const lldb::SBFileSpec &sb_remote_image_spec,
lldb::SBError &sb_error) {
LLDB_RECORD_METHOD(
uint32_t, SBProcess, LoadImage,
(const lldb::SBFileSpec &, const lldb::SBFileSpec &, lldb::SBError &),
sb_local_image_spec, sb_remote_image_spec, sb_error);
LLDB_INSTRUMENT_VA(this, sb_local_image_spec, sb_remote_image_spec, sb_error);
ProcessSP process_sp(GetSP());
if (process_sp) {
@ -1068,10 +1008,7 @@ uint32_t SBProcess::LoadImageUsingPaths(const lldb::SBFileSpec &image_spec,
SBStringList &paths,
lldb::SBFileSpec &loaded_path,
lldb::SBError &error) {
LLDB_RECORD_METHOD(uint32_t, SBProcess, LoadImageUsingPaths,
(const lldb::SBFileSpec &, lldb::SBStringList &,
lldb::SBFileSpec &, lldb::SBError &),
image_spec, paths, loaded_path, error);
LLDB_INSTRUMENT_VA(this, image_spec, paths, loaded_path, error);
ProcessSP process_sp(GetSP());
if (process_sp) {
@ -1103,8 +1040,7 @@ uint32_t SBProcess::LoadImageUsingPaths(const lldb::SBFileSpec &image_spec,
}
lldb::SBError SBProcess::UnloadImage(uint32_t image_token) {
LLDB_RECORD_METHOD(lldb::SBError, SBProcess, UnloadImage, (uint32_t),
image_token);
LLDB_INSTRUMENT_VA(this, image_token);
lldb::SBError sb_error;
ProcessSP process_sp(GetSP());
@ -1125,8 +1061,7 @@ lldb::SBError SBProcess::UnloadImage(uint32_t image_token) {
}
lldb::SBError SBProcess::SendEventData(const char *event_data) {
LLDB_RECORD_METHOD(lldb::SBError, SBProcess, SendEventData, (const char *),
event_data);
LLDB_INSTRUMENT_VA(this, event_data);
lldb::SBError sb_error;
ProcessSP process_sp(GetSP());
@ -1145,7 +1080,7 @@ lldb::SBError SBProcess::SendEventData(const char *event_data) {
}
uint32_t SBProcess::GetNumExtendedBacktraceTypes() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumExtendedBacktraceTypes);
LLDB_INSTRUMENT_VA(this);
ProcessSP process_sp(GetSP());
if (process_sp && process_sp->GetSystemRuntime()) {
@ -1156,8 +1091,7 @@ uint32_t SBProcess::GetNumExtendedBacktraceTypes() {
}
const char *SBProcess::GetExtendedBacktraceTypeAtIndex(uint32_t idx) {
LLDB_RECORD_METHOD(const char *, SBProcess, GetExtendedBacktraceTypeAtIndex,
(uint32_t), idx);
LLDB_INSTRUMENT_VA(this, idx);
ProcessSP process_sp(GetSP());
if (process_sp && process_sp->GetSystemRuntime()) {
@ -1172,8 +1106,7 @@ const char *SBProcess::GetExtendedBacktraceTypeAtIndex(uint32_t idx) {
}
SBThreadCollection SBProcess::GetHistoryThreads(addr_t addr) {
LLDB_RECORD_METHOD(lldb::SBThreadCollection, SBProcess, GetHistoryThreads,
(lldb::addr_t), addr);
LLDB_INSTRUMENT_VA(this, addr);
ProcessSP process_sp(GetSP());
SBThreadCollection threads;
@ -1185,8 +1118,7 @@ SBThreadCollection SBProcess::GetHistoryThreads(addr_t addr) {
bool SBProcess::IsInstrumentationRuntimePresent(
InstrumentationRuntimeType type) {
LLDB_RECORD_METHOD(bool, SBProcess, IsInstrumentationRuntimePresent,
(lldb::InstrumentationRuntimeType), type);
LLDB_INSTRUMENT_VA(this, type);
ProcessSP process_sp(GetSP());
if (!process_sp)
@ -1205,8 +1137,7 @@ bool SBProcess::IsInstrumentationRuntimePresent(
}
lldb::SBError SBProcess::SaveCore(const char *file_name) {
LLDB_RECORD_METHOD(lldb::SBError, SBProcess, SaveCore, (const char *),
file_name);
LLDB_INSTRUMENT_VA(this, file_name);
lldb::SBError error;
ProcessSP process_sp(GetSP());
@ -1232,9 +1163,7 @@ lldb::SBError SBProcess::SaveCore(const char *file_name) {
lldb::SBError
SBProcess::GetMemoryRegionInfo(lldb::addr_t load_addr,
SBMemoryRegionInfo &sb_region_info) {
LLDB_RECORD_METHOD(lldb::SBError, SBProcess, GetMemoryRegionInfo,
(lldb::addr_t, lldb::SBMemoryRegionInfo &), load_addr,
sb_region_info);
LLDB_INSTRUMENT_VA(this, load_addr, sb_region_info);
lldb::SBError sb_error;
ProcessSP process_sp(GetSP());
@ -1256,8 +1185,7 @@ SBProcess::GetMemoryRegionInfo(lldb::addr_t load_addr,
}
lldb::SBMemoryRegionInfoList SBProcess::GetMemoryRegions() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBMemoryRegionInfoList, SBProcess,
GetMemoryRegions);
LLDB_INSTRUMENT_VA(this);
lldb::SBMemoryRegionInfoList sb_region_list;
@ -1274,7 +1202,7 @@ lldb::SBMemoryRegionInfoList SBProcess::GetMemoryRegions() {
}
lldb::SBProcessInfo SBProcess::GetProcessInfo() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcessInfo, SBProcess, GetProcessInfo);
LLDB_INSTRUMENT_VA(this);
lldb::SBProcessInfo sb_proc_info;
ProcessSP process_sp(GetSP());
@ -1287,9 +1215,7 @@ lldb::SBProcessInfo SBProcess::GetProcessInfo() {
lldb::addr_t SBProcess::AllocateMemory(size_t size, uint32_t permissions,
lldb::SBError &sb_error) {
LLDB_RECORD_METHOD(lldb::addr_t, SBProcess, AllocateMemory,
(size_t, uint32_t, lldb::SBError &), size, permissions,
sb_error);
LLDB_INSTRUMENT_VA(this, size, permissions, sb_error);
lldb::addr_t addr = LLDB_INVALID_ADDRESS;
ProcessSP process_sp(GetSP());
@ -1309,8 +1235,7 @@ lldb::addr_t SBProcess::AllocateMemory(size_t size, uint32_t permissions,
}
lldb::SBError SBProcess::DeallocateMemory(lldb::addr_t ptr) {
LLDB_RECORD_METHOD(lldb::SBError, SBProcess, DeallocateMemory, (lldb::addr_t),
ptr);
LLDB_INSTRUMENT_VA(this, ptr);
lldb::SBError sb_error;
ProcessSP process_sp(GetSP());

43
lldb/source/API/SBProcessInfo.cpp
View file

@ -7,20 +7,18 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBProcessInfo.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/API/SBFileSpec.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/ProcessInfo.h"
using namespace lldb;
using namespace lldb_private;
SBProcessInfo::SBProcessInfo() {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBProcessInfo);
}
SBProcessInfo::SBProcessInfo() { LLDB_INSTRUMENT_VA(this); }
SBProcessInfo::SBProcessInfo(const SBProcessInfo &rhs) {
LLDB_RECORD_CONSTRUCTOR(SBProcessInfo, (const lldb::SBProcessInfo &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_up = clone(rhs.m_opaque_up);
}
@ -28,9 +26,7 @@ SBProcessInfo::SBProcessInfo(const SBProcessInfo &rhs) {
SBProcessInfo::~SBProcessInfo() = default;
SBProcessInfo &SBProcessInfo::operator=(const SBProcessInfo &rhs) {
LLDB_RECORD_METHOD(lldb::SBProcessInfo &,
SBProcessInfo, operator=,(const lldb::SBProcessInfo &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
@ -49,17 +45,17 @@ void SBProcessInfo::SetProcessInfo(const ProcessInstanceInfo &proc_info_ref) {
}
bool SBProcessInfo::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcessInfo, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBProcessInfo::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcessInfo, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up != nullptr;
}
const char *SBProcessInfo::GetName() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcessInfo, GetName);
LLDB_INSTRUMENT_VA(this);
const char *name = nullptr;
if (m_opaque_up) {
@ -69,8 +65,7 @@ const char *SBProcessInfo::GetName() {
}
SBFileSpec SBProcessInfo::GetExecutableFile() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBProcessInfo,
GetExecutableFile);
LLDB_INSTRUMENT_VA(this);
SBFileSpec file_spec;
if (m_opaque_up) {
@ -80,7 +75,7 @@ SBFileSpec SBProcessInfo::GetExecutableFile() {
}
lldb::pid_t SBProcessInfo::GetProcessID() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBProcessInfo, GetProcessID);
LLDB_INSTRUMENT_VA(this);
lldb::pid_t proc_id = LLDB_INVALID_PROCESS_ID;
if (m_opaque_up) {
@ -90,7 +85,7 @@ lldb::pid_t SBProcessInfo::GetProcessID() {
}
uint32_t SBProcessInfo::GetUserID() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetUserID);
LLDB_INSTRUMENT_VA(this);
uint32_t user_id = UINT32_MAX;
if (m_opaque_up) {
@ -100,7 +95,7 @@ uint32_t SBProcessInfo::GetUserID() {
}
uint32_t SBProcessInfo::GetGroupID() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetGroupID);
LLDB_INSTRUMENT_VA(this);
uint32_t group_id = UINT32_MAX;
if (m_opaque_up) {
@ -110,7 +105,7 @@ uint32_t SBProcessInfo::GetGroupID() {
}
bool SBProcessInfo::UserIDIsValid() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, UserIDIsValid);
LLDB_INSTRUMENT_VA(this);
bool is_valid = false;
if (m_opaque_up) {
@ -120,7 +115,7 @@ bool SBProcessInfo::UserIDIsValid() {
}
bool SBProcessInfo::GroupIDIsValid() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, GroupIDIsValid);
LLDB_INSTRUMENT_VA(this);
bool is_valid = false;
if (m_opaque_up) {
@ -130,7 +125,7 @@ bool SBProcessInfo::GroupIDIsValid() {
}
uint32_t SBProcessInfo::GetEffectiveUserID() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetEffectiveUserID);
LLDB_INSTRUMENT_VA(this);
uint32_t user_id = UINT32_MAX;
if (m_opaque_up) {
@ -140,7 +135,7 @@ uint32_t SBProcessInfo::GetEffectiveUserID() {
}
uint32_t SBProcessInfo::GetEffectiveGroupID() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetEffectiveGroupID);
LLDB_INSTRUMENT_VA(this);
uint32_t group_id = UINT32_MAX;
if (m_opaque_up) {
@ -150,7 +145,7 @@ uint32_t SBProcessInfo::GetEffectiveGroupID() {
}
bool SBProcessInfo::EffectiveUserIDIsValid() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, EffectiveUserIDIsValid);
LLDB_INSTRUMENT_VA(this);
bool is_valid = false;
if (m_opaque_up) {
@ -160,7 +155,7 @@ bool SBProcessInfo::EffectiveUserIDIsValid() {
}
bool SBProcessInfo::EffectiveGroupIDIsValid() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, EffectiveGroupIDIsValid);
LLDB_INSTRUMENT_VA(this);
bool is_valid = false;
if (m_opaque_up) {
@ -170,7 +165,7 @@ bool SBProcessInfo::EffectiveGroupIDIsValid() {
}
lldb::pid_t SBProcessInfo::GetParentProcessID() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBProcessInfo, GetParentProcessID);
LLDB_INSTRUMENT_VA(this);
lldb::pid_t proc_id = LLDB_INVALID_PROCESS_ID;
if (m_opaque_up) {
@ -180,7 +175,7 @@ lldb::pid_t SBProcessInfo::GetParentProcessID() {
}
const char *SBProcessInfo::GetTriple() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcessInfo, GetTriple);
LLDB_INSTRUMENT_VA(this);
const char *triple = nullptr;
if (m_opaque_up) {

41
lldb/source/API/SBQueue.cpp
View file

@ -8,8 +8,8 @@
#include <cinttypes>
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBQueue.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/API/SBProcess.h"
#include "lldb/API/SBQueueItem.h"
@ -215,17 +215,15 @@ private:
};
}
SBQueue::SBQueue() : m_opaque_sp(new QueueImpl()) {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBQueue);
}
SBQueue::SBQueue() : m_opaque_sp(new QueueImpl()) { LLDB_INSTRUMENT_VA(this); }
SBQueue::SBQueue(const QueueSP &queue_sp)
: m_opaque_sp(new QueueImpl(queue_sp)) {
LLDB_RECORD_CONSTRUCTOR(SBQueue, (const lldb::QueueSP &), queue_sp);
LLDB_INSTRUMENT_VA(this, queue_sp);
}
SBQueue::SBQueue(const SBQueue &rhs) {
LLDB_RECORD_CONSTRUCTOR(SBQueue, (const lldb::SBQueue &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (&rhs == this)
return;
@ -234,8 +232,7 @@ SBQueue::SBQueue(const SBQueue &rhs) {
}
const lldb::SBQueue &SBQueue::operator=(const lldb::SBQueue &rhs) {
LLDB_RECORD_METHOD(const lldb::SBQueue &,
SBQueue, operator=,(const lldb::SBQueue &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_sp = rhs.m_opaque_sp;
return *this;
@ -244,17 +241,17 @@ const lldb::SBQueue &SBQueue::operator=(const lldb::SBQueue &rhs) {
SBQueue::~SBQueue() = default;
bool SBQueue::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBQueue, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBQueue::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBQueue, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->IsValid();
}
void SBQueue::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBQueue, Clear);
LLDB_INSTRUMENT_VA(this);
m_opaque_sp->Clear();
}
@ -264,65 +261,63 @@ void SBQueue::SetQueue(const QueueSP &queue_sp) {
}
lldb::queue_id_t SBQueue::GetQueueID() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::queue_id_t, SBQueue, GetQueueID);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetQueueID();
}
uint32_t SBQueue::GetIndexID() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBQueue, GetIndexID);
LLDB_INSTRUMENT_VA(this);
uint32_t index_id = m_opaque_sp->GetIndexID();
return index_id;
}
const char *SBQueue::GetName() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBQueue, GetName);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetName();
}
uint32_t SBQueue::GetNumThreads() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBQueue, GetNumThreads);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetNumThreads();
}
SBThread SBQueue::GetThreadAtIndex(uint32_t idx) {
LLDB_RECORD_METHOD(lldb::SBThread, SBQueue, GetThreadAtIndex, (uint32_t),
idx);
LLDB_INSTRUMENT_VA(this, idx);
SBThread th = m_opaque_sp->GetThreadAtIndex(idx);
return th;
}
uint32_t SBQueue::GetNumPendingItems() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBQueue, GetNumPendingItems);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetNumPendingItems();
}
SBQueueItem SBQueue::GetPendingItemAtIndex(uint32_t idx) {
LLDB_RECORD_METHOD(lldb::SBQueueItem, SBQueue, GetPendingItemAtIndex,
(uint32_t), idx);
LLDB_INSTRUMENT_VA(this, idx);
return m_opaque_sp->GetPendingItemAtIndex(idx);
}
uint32_t SBQueue::GetNumRunningItems() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBQueue, GetNumRunningItems);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetNumRunningItems();
}
SBProcess SBQueue::GetProcess() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBQueue, GetProcess);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetProcess();
}
lldb::QueueKind SBQueue::GetKind() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::QueueKind, SBQueue, GetKind);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp->GetKind();
}

27
lldb/source/API/SBQueueItem.cpp
View file

@ -8,7 +8,6 @@
#include "lldb/lldb-forward.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBQueueItem.h"
#include "lldb/API/SBThread.h"
@ -16,47 +15,46 @@
#include "lldb/Target/Process.h"
#include "lldb/Target/QueueItem.h"
#include "lldb/Target/Thread.h"
#include "lldb/Utility/Instrumentation.h"
using namespace lldb;
using namespace lldb_private;
// Constructors
SBQueueItem::SBQueueItem() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBQueueItem); }
SBQueueItem::SBQueueItem() { LLDB_INSTRUMENT_VA(this); }
SBQueueItem::SBQueueItem(const QueueItemSP &queue_item_sp)
: m_queue_item_sp(queue_item_sp) {
LLDB_RECORD_CONSTRUCTOR(SBQueueItem, (const lldb::QueueItemSP &),
queue_item_sp);
LLDB_INSTRUMENT_VA(this, queue_item_sp);
}
// Destructor
SBQueueItem::~SBQueueItem() { m_queue_item_sp.reset(); }
bool SBQueueItem::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBQueueItem, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBQueueItem::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBQueueItem, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_queue_item_sp.get() != nullptr;
}
void SBQueueItem::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBQueueItem, Clear);
LLDB_INSTRUMENT_VA(this);
m_queue_item_sp.reset();
}
void SBQueueItem::SetQueueItem(const QueueItemSP &queue_item_sp) {
LLDB_RECORD_METHOD(void, SBQueueItem, SetQueueItem,
(const lldb::QueueItemSP &), queue_item_sp);
LLDB_INSTRUMENT_VA(this, queue_item_sp);
m_queue_item_sp = queue_item_sp;
}
lldb::QueueItemKind SBQueueItem::GetKind() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::QueueItemKind, SBQueueItem, GetKind);
LLDB_INSTRUMENT_VA(this);
QueueItemKind result = eQueueItemKindUnknown;
if (m_queue_item_sp) {
@ -66,7 +64,7 @@ lldb::QueueItemKind SBQueueItem::GetKind() const {
}
void SBQueueItem::SetKind(lldb::QueueItemKind kind) {
LLDB_RECORD_METHOD(void, SBQueueItem, SetKind, (lldb::QueueItemKind), kind);
LLDB_INSTRUMENT_VA(this, kind);
if (m_queue_item_sp) {
m_queue_item_sp->SetKind(kind);
@ -74,7 +72,7 @@ void SBQueueItem::SetKind(lldb::QueueItemKind kind) {
}
SBAddress SBQueueItem::GetAddress() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBQueueItem, GetAddress);
LLDB_INSTRUMENT_VA(this);
SBAddress result;
if (m_queue_item_sp) {
@ -84,7 +82,7 @@ SBAddress SBQueueItem::GetAddress() const {
}
void SBQueueItem::SetAddress(SBAddress addr) {
LLDB_RECORD_METHOD(void, SBQueueItem, SetAddress, (lldb::SBAddress), addr);
LLDB_INSTRUMENT_VA(this, addr);
if (m_queue_item_sp) {
m_queue_item_sp->SetAddress(addr.ref());
@ -92,8 +90,7 @@ void SBQueueItem::SetAddress(SBAddress addr) {
}
SBThread SBQueueItem::GetExtendedBacktraceThread(const char *type) {
LLDB_RECORD_METHOD(lldb::SBThread, SBQueueItem, GetExtendedBacktraceThread,
(const char *), type);
LLDB_INSTRUMENT_VA(this, type);
SBThread result;
if (m_queue_item_sp) {

29
lldb/source/API/SBReproducer.cpp
View file

@ -6,7 +6,7 @@
//
//===----------------------------------------------------------------------===//
#include "lldb/API/SBReproducer.h"
#include "lldb/API/LLDB.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBAttachInfo.h"
@ -20,12 +20,11 @@
#include "lldb/API/SBError.h"
#include "lldb/API/SBFileSpec.h"
#include "lldb/API/SBHostOS.h"
#include "lldb/API/SBReproducer.h"
#include "lldb/Host/FileSystem.h"
#include "lldb/Version/Version.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/Reproducer.h"
#include "lldb/Utility/ReproducerProvider.h"
#include "lldb/Version/Version.h"
using namespace lldb;
using namespace lldb_private;
@ -40,25 +39,33 @@ SBReplayOptions::SBReplayOptions(const SBReplayOptions &rhs)
SBReplayOptions::~SBReplayOptions() = default;
SBReplayOptions &SBReplayOptions::operator=(const SBReplayOptions &rhs) {
LLDB_INSTRUMENT_VA(this, rhs)
if (this == &rhs)
return *this;
*m_opaque_up = *rhs.m_opaque_up;
return *this;
}
void SBReplayOptions::SetVerify(bool verify) { m_opaque_up->verify = verify; }
void SBReplayOptions::SetVerify(bool verify) {
LLDB_INSTRUMENT_VA(this, verify) m_opaque_up->verify = verify;
}
bool SBReplayOptions::GetVerify() const { return m_opaque_up->verify; }
bool SBReplayOptions::GetVerify() const {
LLDB_INSTRUMENT_VA(this) return m_opaque_up->verify;
}
void SBReplayOptions::SetCheckVersion(bool check) {
LLDB_INSTRUMENT_VA(this, check)
m_opaque_up->check_version = check;
}
bool SBReplayOptions::GetCheckVersion() const {
LLDB_INSTRUMENT_VA(this)
return m_opaque_up->check_version;
}
const char *SBReproducer::Capture() {
LLDB_INSTRUMENT()
static std::string error;
if (auto e = Reproducer::Initialize(ReproducerMode::Capture, llvm::None)) {
error = llvm::toString(std::move(e));
@ -69,6 +76,7 @@ const char *SBReproducer::Capture() {
}
const char *SBReproducer::Capture(const char *path) {
LLDB_INSTRUMENT_VA(path)
static std::string error;
if (auto e =
Reproducer::Initialize(ReproducerMode::Capture, FileSpec(path))) {
@ -80,23 +88,28 @@ const char *SBReproducer::Capture(const char *path) {
}
const char *SBReproducer::PassiveReplay(const char *path) {
LLDB_INSTRUMENT_VA(path)
return "Reproducer replay has been removed";
}
const char *SBReproducer::Replay(const char *path) {
LLDB_INSTRUMENT_VA(path)
return "Reproducer replay has been removed";
}
const char *SBReproducer::Replay(const char *path, bool skip_version_check) {
LLDB_INSTRUMENT_VA(path, skip_version_check)
return Replay(path);
}
const char *SBReproducer::Replay(const char *path,
const SBReplayOptions &options) {
LLDB_INSTRUMENT_VA(path, options)
return Replay(path);
}
const char *SBReproducer::Finalize(const char *path) {
LLDB_INSTRUMENT_VA(path)
static std::string error;
repro::Loader *loader = repro::Reproducer::Instance().GetLoader();
@ -114,6 +127,7 @@ const char *SBReproducer::Finalize(const char *path) {
}
bool SBReproducer::Generate() {
LLDB_INSTRUMENT()
auto &r = Reproducer::Instance();
if (auto generator = r.GetGenerator()) {
generator->Keep();
@ -123,6 +137,7 @@ bool SBReproducer::Generate() {
}
bool SBReproducer::SetAutoGenerate(bool b) {
LLDB_INSTRUMENT_VA(b)
auto &r = Reproducer::Instance();
if (auto generator = r.GetGenerator()) {
generator->SetAutoGenerate(b);
@ -132,6 +147,7 @@ bool SBReproducer::SetAutoGenerate(bool b) {
}
const char *SBReproducer::GetPath() {
LLDB_INSTRUMENT()
ConstString path;
auto &r = Reproducer::Instance();
if (FileSpec reproducer_path = Reproducer::Instance().GetReproducerPath())
@ -140,6 +156,7 @@ const char *SBReproducer::GetPath() {
}
void SBReproducer::SetWorkingDirectory(const char *path) {
LLDB_INSTRUMENT_VA(path)
if (auto *g = lldb_private::repro::Reproducer::Instance().GetGenerator()) {
auto &wp = g->GetOrCreate<repro::WorkingDirectoryProvider>();
wp.SetDirectory(path);

56
lldb/source/API/SBSection.cpp
View file

@ -7,7 +7,6 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBSection.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBTarget.h"
#include "lldb/Core/Module.h"
@ -15,15 +14,16 @@
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Utility/DataBuffer.h"
#include "lldb/Utility/DataExtractor.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb;
using namespace lldb_private;
SBSection::SBSection() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSection); }
SBSection::SBSection() { LLDB_INSTRUMENT_VA(this); }
SBSection::SBSection(const SBSection &rhs) : m_opaque_wp(rhs.m_opaque_wp) {
LLDB_RECORD_CONSTRUCTOR(SBSection, (const lldb::SBSection &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
}
SBSection::SBSection(const lldb::SectionSP &section_sp) {
@ -34,8 +34,7 @@ SBSection::SBSection(const lldb::SectionSP &section_sp) {
}
const SBSection &SBSection::operator=(const SBSection &rhs) {
LLDB_RECORD_METHOD(const lldb::SBSection &,
SBSection, operator=,(const lldb::SBSection &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_wp = rhs.m_opaque_wp;
return *this;
@ -44,18 +43,18 @@ const SBSection &SBSection::operator=(const SBSection &rhs) {
SBSection::~SBSection() = default;
bool SBSection::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSection, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBSection::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSection, operator bool);
LLDB_INSTRUMENT_VA(this);
SectionSP section_sp(GetSP());
return section_sp && section_sp->GetModule().get() != nullptr;
}
const char *SBSection::GetName() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBSection, GetName);
LLDB_INSTRUMENT_VA(this);
SectionSP section_sp(GetSP());
if (section_sp)
@ -64,7 +63,7 @@ const char *SBSection::GetName() {
}
lldb::SBSection SBSection::GetParent() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSection, SBSection, GetParent);
LLDB_INSTRUMENT_VA(this);
lldb::SBSection sb_section;
SectionSP section_sp(GetSP());
@ -77,8 +76,7 @@ lldb::SBSection SBSection::GetParent() {
}
lldb::SBSection SBSection::FindSubSection(const char *sect_name) {
LLDB_RECORD_METHOD(lldb::SBSection, SBSection, FindSubSection, (const char *),
sect_name);
LLDB_INSTRUMENT_VA(this, sect_name);
lldb::SBSection sb_section;
if (sect_name) {
@ -93,7 +91,7 @@ lldb::SBSection SBSection::FindSubSection(const char *sect_name) {
}
size_t SBSection::GetNumSubSections() {
LLDB_RECORD_METHOD_NO_ARGS(size_t, SBSection, GetNumSubSections);
LLDB_INSTRUMENT_VA(this);
SectionSP section_sp(GetSP());
if (section_sp)
@ -102,8 +100,7 @@ size_t SBSection::GetNumSubSections() {
}
lldb::SBSection SBSection::GetSubSectionAtIndex(size_t idx) {
LLDB_RECORD_METHOD(lldb::SBSection, SBSection, GetSubSectionAtIndex, (size_t),
idx);
LLDB_INSTRUMENT_VA(this, idx);
lldb::SBSection sb_section;
SectionSP section_sp(GetSP());
@ -119,7 +116,7 @@ void SBSection::SetSP(const lldb::SectionSP &section_sp) {
}
lldb::addr_t SBSection::GetFileAddress() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBSection, GetFileAddress);
LLDB_INSTRUMENT_VA(this);
lldb::addr_t file_addr = LLDB_INVALID_ADDRESS;
SectionSP section_sp(GetSP());
@ -129,8 +126,7 @@ lldb::addr_t SBSection::GetFileAddress() {
}
lldb::addr_t SBSection::GetLoadAddress(lldb::SBTarget &sb_target) {
LLDB_RECORD_METHOD(lldb::addr_t, SBSection, GetLoadAddress,
(lldb::SBTarget &), sb_target);
LLDB_INSTRUMENT_VA(this, sb_target);
TargetSP target_sp(sb_target.GetSP());
if (target_sp) {
@ -142,7 +138,7 @@ lldb::addr_t SBSection::GetLoadAddress(lldb::SBTarget &sb_target) {
}
lldb::addr_t SBSection::GetByteSize() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBSection, GetByteSize);
LLDB_INSTRUMENT_VA(this);
SectionSP section_sp(GetSP());
if (section_sp)
@ -151,7 +147,7 @@ lldb::addr_t SBSection::GetByteSize() {
}
uint64_t SBSection::GetFileOffset() {
LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBSection, GetFileOffset);
LLDB_INSTRUMENT_VA(this);
SectionSP section_sp(GetSP());
if (section_sp) {
@ -166,7 +162,7 @@ uint64_t SBSection::GetFileOffset() {
}
uint64_t SBSection::GetFileByteSize() {
LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBSection, GetFileByteSize);
LLDB_INSTRUMENT_VA(this);
SectionSP section_sp(GetSP());
if (section_sp)
@ -175,14 +171,13 @@ uint64_t SBSection::GetFileByteSize() {
}
SBData SBSection::GetSectionData() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBData, SBSection, GetSectionData);
LLDB_INSTRUMENT_VA(this);
return GetSectionData(0, UINT64_MAX);
}
SBData SBSection::GetSectionData(uint64_t offset, uint64_t size) {
LLDB_RECORD_METHOD(lldb::SBData, SBSection, GetSectionData,
(uint64_t, uint64_t), offset, size);
LLDB_INSTRUMENT_VA(this, offset, size);
SBData sb_data;
SectionSP section_sp(GetSP());
@ -221,7 +216,7 @@ SBData SBSection::GetSectionData(uint64_t offset, uint64_t size) {
}
SectionType SBSection::GetSectionType() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SectionType, SBSection, GetSectionType);
LLDB_INSTRUMENT_VA(this);
SectionSP section_sp(GetSP());
if (section_sp.get())
@ -230,7 +225,7 @@ SectionType SBSection::GetSectionType() {
}
uint32_t SBSection::GetPermissions() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBSection, GetPermissions);
LLDB_INSTRUMENT_VA(this);
SectionSP section_sp(GetSP());
if (section_sp)
@ -239,7 +234,7 @@ uint32_t SBSection::GetPermissions() const {
}
uint32_t SBSection::GetTargetByteSize() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBSection, GetTargetByteSize);
LLDB_INSTRUMENT_VA(this);
SectionSP section_sp(GetSP());
if (section_sp.get())
@ -248,8 +243,7 @@ uint32_t SBSection::GetTargetByteSize() {
}
bool SBSection::operator==(const SBSection &rhs) {
LLDB_RECORD_METHOD(bool, SBSection, operator==,(const lldb::SBSection &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
SectionSP lhs_section_sp(GetSP());
SectionSP rhs_section_sp(rhs.GetSP());
@ -259,8 +253,7 @@ bool SBSection::operator==(const SBSection &rhs) {
}
bool SBSection::operator!=(const SBSection &rhs) {
LLDB_RECORD_METHOD(bool, SBSection, operator!=,(const lldb::SBSection &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
SectionSP lhs_section_sp(GetSP());
SectionSP rhs_section_sp(rhs.GetSP());
@ -268,8 +261,7 @@ bool SBSection::operator!=(const SBSection &rhs) {
}
bool SBSection::GetDescription(SBStream &description) {
LLDB_RECORD_METHOD(bool, SBSection, GetDescription, (lldb::SBStream &),
description);
LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();

26
lldb/source/API/SBSourceManager.cpp
View file

@ -7,10 +7,10 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBSourceManager.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBTarget.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/API/SBFileSpec.h"
#include "lldb/Core/Debugger.h"
@ -71,21 +71,19 @@ using namespace lldb;
using namespace lldb_private;
SBSourceManager::SBSourceManager(const SBDebugger &debugger) {
LLDB_RECORD_CONSTRUCTOR(SBSourceManager, (const lldb::SBDebugger &),
debugger);
LLDB_INSTRUMENT_VA(this, debugger);
m_opaque_up = std::make_unique<SourceManagerImpl>(debugger.get_sp());
}
SBSourceManager::SBSourceManager(const SBTarget &target) {
LLDB_RECORD_CONSTRUCTOR(SBSourceManager, (const lldb::SBTarget &), target);
LLDB_INSTRUMENT_VA(this, target);
m_opaque_up = std::make_unique<SourceManagerImpl>(target.GetSP());
}
SBSourceManager::SBSourceManager(const SBSourceManager &rhs) {
LLDB_RECORD_CONSTRUCTOR(SBSourceManager, (const lldb::SBSourceManager &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (&rhs == this)
return;
@ -95,9 +93,7 @@ SBSourceManager::SBSourceManager(const SBSourceManager &rhs) {
const lldb::SBSourceManager &SBSourceManager::
operator=(const lldb::SBSourceManager &rhs) {
LLDB_RECORD_METHOD(const lldb::SBSourceManager &,
SBSourceManager, operator=,(const lldb::SBSourceManager &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_up = std::make_unique<SourceManagerImpl>(*(rhs.m_opaque_up.get()));
return *this;
@ -108,10 +104,7 @@ SBSourceManager::~SBSourceManager() = default;
size_t SBSourceManager::DisplaySourceLinesWithLineNumbers(
const SBFileSpec &file, uint32_t line, uint32_t context_before,
uint32_t context_after, const char *current_line_cstr, SBStream &s) {
LLDB_RECORD_METHOD(size_t, SBSourceManager, DisplaySourceLinesWithLineNumbers,
(const lldb::SBFileSpec &, uint32_t, uint32_t, uint32_t,
const char *, lldb::SBStream &),
file, line, context_before, context_after,
LLDB_INSTRUMENT_VA(this, file, line, context_before, context_after,
current_line_cstr, s);
const uint32_t column = 0;
@ -124,11 +117,8 @@ size_t SBSourceManager::DisplaySourceLinesWithLineNumbersAndColumn(
const SBFileSpec &file, uint32_t line, uint32_t column,
uint32_t context_before, uint32_t context_after,
const char *current_line_cstr, SBStream &s) {
LLDB_RECORD_METHOD(
size_t, SBSourceManager, DisplaySourceLinesWithLineNumbersAndColumn,
(const lldb::SBFileSpec &, uint32_t, uint32_t, uint32_t, uint32_t,
const char *, lldb::SBStream &),
file, line, column, context_before, context_after, current_line_cstr, s);
LLDB_INSTRUMENT_VA(this, file, line, column, context_before, context_after,
current_line_cstr, s);
if (m_opaque_up == nullptr)
return 0;

29
lldb/source/API/SBStream.cpp
View file

@ -8,10 +8,10 @@
#include "lldb/API/SBStream.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBFile.h"
#include "lldb/Core/StreamFile.h"
#include "lldb/Host/FileSystem.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/Status.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"
@ -20,7 +20,7 @@ using namespace lldb;
using namespace lldb_private;
SBStream::SBStream() : m_opaque_up(new StreamString()) {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBStream);
LLDB_INSTRUMENT_VA(this);
}
SBStream::SBStream(SBStream &&rhs)
@ -29,11 +29,11 @@ SBStream::SBStream(SBStream &&rhs)
SBStream::~SBStream() = default;
bool SBStream::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStream, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBStream::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStream, operator bool);
LLDB_INSTRUMENT_VA(this);
return (m_opaque_up != nullptr);
}
@ -41,7 +41,7 @@ SBStream::operator bool() const {
// If this stream is not redirected to a file, it will maintain a local cache
// for the stream data which can be accessed using this accessor.
const char *SBStream::GetData() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBStream, GetData);
LLDB_INSTRUMENT_VA(this);
if (m_is_file || m_opaque_up == nullptr)
return nullptr;
@ -52,7 +52,7 @@ const char *SBStream::GetData() {
// If this stream is not redirected to a file, it will maintain a local cache
// for the stream output whose length can be accessed using this accessor.
size_t SBStream::GetSize() {
LLDB_RECORD_METHOD_NO_ARGS(size_t, SBStream, GetSize);
LLDB_INSTRUMENT_VA(this);
if (m_is_file || m_opaque_up == nullptr)
return 0;
@ -61,7 +61,7 @@ size_t SBStream::GetSize() {
}
void SBStream::Print(const char *str) {
LLDB_RECORD_METHOD(void, SBStream, Print, (const char *), str);
LLDB_INSTRUMENT_VA(this, str);
Printf("%s", str);
}
@ -76,8 +76,7 @@ void SBStream::Printf(const char *format, ...) {
}
void SBStream::RedirectToFile(const char *path, bool append) {
LLDB_RECORD_METHOD(void, SBStream, RedirectToFile, (const char *, bool), path,
append);
LLDB_INSTRUMENT_VA(this, path, append);
if (path == nullptr)
return;
@ -114,19 +113,18 @@ void SBStream::RedirectToFile(const char *path, bool append) {
}
void SBStream::RedirectToFileHandle(FILE *fh, bool transfer_fh_ownership) {
LLDB_RECORD_METHOD(void, SBStream, RedirectToFileHandle, (FILE *, bool), fh,
transfer_fh_ownership);
LLDB_INSTRUMENT_VA(this, fh, transfer_fh_ownership);
FileSP file = std::make_unique<NativeFile>(fh, transfer_fh_ownership);
return RedirectToFile(file);
}
void SBStream::RedirectToFile(SBFile file) {
LLDB_RECORD_METHOD(void, SBStream, RedirectToFile, (SBFile), file)
LLDB_INSTRUMENT_VA(this, file)
RedirectToFile(file.GetFile());
}
void SBStream::RedirectToFile(FileSP file_sp) {
LLDB_RECORD_METHOD(void, SBStream, RedirectToFile, (FileSP), file_sp);
LLDB_INSTRUMENT_VA(this, file_sp);
if (!file_sp || !file_sp->IsValid())
return;
@ -150,8 +148,7 @@ void SBStream::RedirectToFile(FileSP file_sp) {
}
void SBStream::RedirectToFileDescriptor(int fd, bool transfer_fh_ownership) {
LLDB_RECORD_METHOD(void, SBStream, RedirectToFileDescriptor, (int, bool), fd,
transfer_fh_ownership);
LLDB_INSTRUMENT_VA(this, fd, transfer_fh_ownership);
std::string local_data;
if (m_opaque_up) {
@ -182,7 +179,7 @@ lldb_private::Stream &SBStream::ref() {
}
void SBStream::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBStream, Clear);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_up) {
// See if we have any locally backed data. If so, copy it so we can then

31
lldb/source/API/SBStringList.cpp
View file

@ -7,14 +7,14 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBStringList.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/StringList.h"
using namespace lldb;
using namespace lldb_private;
SBStringList::SBStringList() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBStringList); }
SBStringList::SBStringList() { LLDB_INSTRUMENT_VA(this); }
SBStringList::SBStringList(const lldb_private::StringList *lldb_strings_ptr) {
if (lldb_strings_ptr)
@ -22,14 +22,13 @@ SBStringList::SBStringList(const lldb_private::StringList *lldb_strings_ptr) {
}
SBStringList::SBStringList(const SBStringList &rhs) {
LLDB_RECORD_CONSTRUCTOR(SBStringList, (const lldb::SBStringList &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_up = clone(rhs.m_opaque_up);
}
const SBStringList &SBStringList::operator=(const SBStringList &rhs) {
LLDB_RECORD_METHOD(const lldb::SBStringList &,
SBStringList, operator=,(const lldb::SBStringList &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
@ -47,17 +46,17 @@ const lldb_private::StringList &SBStringList::operator*() const {
}
bool SBStringList::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStringList, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBStringList::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStringList, operator bool);
LLDB_INSTRUMENT_VA(this);
return (m_opaque_up != nullptr);
}
void SBStringList::AppendString(const char *str) {
LLDB_RECORD_METHOD(void, SBStringList, AppendString, (const char *), str);
LLDB_INSTRUMENT_VA(this, str);
if (str != nullptr) {
if (IsValid())
@ -68,8 +67,7 @@ void SBStringList::AppendString(const char *str) {
}
void SBStringList::AppendList(const char **strv, int strc) {
LLDB_RECORD_METHOD(void, SBStringList, AppendList, (const char **, int), strv,
strc);
LLDB_INSTRUMENT_VA(this, strv, strc);
if ((strv != nullptr) && (strc > 0)) {
if (IsValid())
@ -80,8 +78,7 @@ void SBStringList::AppendList(const char **strv, int strc) {
}
void SBStringList::AppendList(const SBStringList &strings) {
LLDB_RECORD_METHOD(void, SBStringList, AppendList,
(const lldb::SBStringList &), strings);
LLDB_INSTRUMENT_VA(this, strings);
if (strings.IsValid()) {
if (!IsValid())
@ -97,7 +94,7 @@ void SBStringList::AppendList(const StringList &strings) {
}
uint32_t SBStringList::GetSize() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBStringList, GetSize);
LLDB_INSTRUMENT_VA(this);
if (IsValid()) {
return m_opaque_up->GetSize();
@ -106,8 +103,7 @@ uint32_t SBStringList::GetSize() const {
}
const char *SBStringList::GetStringAtIndex(size_t idx) {
LLDB_RECORD_METHOD(const char *, SBStringList, GetStringAtIndex, (size_t),
idx);
LLDB_INSTRUMENT_VA(this, idx);
if (IsValid()) {
return m_opaque_up->GetStringAtIndex(idx);
@ -116,8 +112,7 @@ const char *SBStringList::GetStringAtIndex(size_t idx) {
}
const char *SBStringList::GetStringAtIndex(size_t idx) const {
LLDB_RECORD_METHOD_CONST(const char *, SBStringList, GetStringAtIndex,
(size_t), idx);
LLDB_INSTRUMENT_VA(this, idx);
if (IsValid()) {
return m_opaque_up->GetStringAtIndex(idx);
@ -126,7 +121,7 @@ const char *SBStringList::GetStringAtIndex(size_t idx) const {
}
void SBStringList::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBStringList, Clear);
LLDB_INSTRUMENT_VA(this);
if (IsValid()) {
m_opaque_up->Clear();

60
lldb/source/API/SBStructuredData.cpp
View file

@ -7,7 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBStructuredData.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBStringList.h"
@ -25,41 +25,36 @@ using namespace lldb_private;
#pragma mark SBStructuredData
SBStructuredData::SBStructuredData() : m_impl_up(new StructuredDataImpl()) {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBStructuredData);
LLDB_INSTRUMENT_VA(this);
}
SBStructuredData::SBStructuredData(const lldb::SBStructuredData &rhs)
: m_impl_up(new StructuredDataImpl(*rhs.m_impl_up)) {
LLDB_RECORD_CONSTRUCTOR(SBStructuredData, (const lldb::SBStructuredData &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
}
SBStructuredData::SBStructuredData(const lldb::EventSP &event_sp)
: m_impl_up(new StructuredDataImpl(event_sp)) {
LLDB_RECORD_CONSTRUCTOR(SBStructuredData, (const lldb::EventSP &), event_sp);
LLDB_INSTRUMENT_VA(this, event_sp);
}
SBStructuredData::SBStructuredData(const lldb_private::StructuredDataImpl &impl)
: m_impl_up(new StructuredDataImpl(impl)) {
LLDB_RECORD_CONSTRUCTOR(SBStructuredData,
(const lldb_private::StructuredDataImpl &), impl);
LLDB_INSTRUMENT_VA(this, impl);
}
SBStructuredData::~SBStructuredData() = default;
SBStructuredData &SBStructuredData::
operator=(const lldb::SBStructuredData &rhs) {
LLDB_RECORD_METHOD(
lldb::SBStructuredData &,
SBStructuredData, operator=,(const lldb::SBStructuredData &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
*m_impl_up = *rhs.m_impl_up;
return *this;
}
lldb::SBError SBStructuredData::SetFromJSON(lldb::SBStream &stream) {
LLDB_RECORD_METHOD(lldb::SBError, SBStructuredData, SetFromJSON,
(lldb::SBStream &), stream);
LLDB_INSTRUMENT_VA(this, stream);
lldb::SBError error;
std::string json_str(stream.GetData());
@ -73,33 +68,31 @@ lldb::SBError SBStructuredData::SetFromJSON(lldb::SBStream &stream) {
}
lldb::SBError SBStructuredData::SetFromJSON(const char *json) {
LLDB_RECORD_METHOD(lldb::SBError, SBStructuredData, SetFromJSON,
(const char *), json);
LLDB_INSTRUMENT_VA(this, json);
lldb::SBStream s;
s.Print(json);
return SetFromJSON(s);
}
bool SBStructuredData::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStructuredData, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBStructuredData::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStructuredData, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_impl_up->IsValid();
}
void SBStructuredData::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBStructuredData, Clear);
LLDB_INSTRUMENT_VA(this);
m_impl_up->Clear();
}
SBError SBStructuredData::GetAsJSON(lldb::SBStream &stream) const {
LLDB_RECORD_METHOD_CONST(lldb::SBError, SBStructuredData, GetAsJSON,
(lldb::SBStream &), stream);
LLDB_INSTRUMENT_VA(this, stream);
SBError error;
error.SetError(m_impl_up->GetAsJSON(stream.ref()));
@ -107,8 +100,7 @@ SBError SBStructuredData::GetAsJSON(lldb::SBStream &stream) const {
}
lldb::SBError SBStructuredData::GetDescription(lldb::SBStream &stream) const {
LLDB_RECORD_METHOD_CONST(lldb::SBError, SBStructuredData, GetDescription,
(lldb::SBStream &), stream);
LLDB_INSTRUMENT_VA(this, stream);
Status error = m_impl_up->GetDescription(stream.ref());
SBError sb_error;
@ -117,21 +109,19 @@ lldb::SBError SBStructuredData::GetDescription(lldb::SBStream &stream) const {
}
StructuredDataType SBStructuredData::GetType() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::StructuredDataType, SBStructuredData,
GetType);
LLDB_INSTRUMENT_VA(this);
return m_impl_up->GetType();
}
size_t SBStructuredData::GetSize() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBStructuredData, GetSize);
LLDB_INSTRUMENT_VA(this);
return m_impl_up->GetSize();
}
bool SBStructuredData::GetKeys(lldb::SBStringList &keys) const {
LLDB_RECORD_METHOD_CONST(bool, SBStructuredData, GetKeys,
(lldb::SBStringList &), keys);
LLDB_INSTRUMENT_VA(this, keys);
if (GetType() != eStructuredDataTypeDictionary)
return false;
@ -157,8 +147,7 @@ bool SBStructuredData::GetKeys(lldb::SBStringList &keys) const {
}
lldb::SBStructuredData SBStructuredData::GetValueForKey(const char *key) const {
LLDB_RECORD_METHOD_CONST(lldb::SBStructuredData, SBStructuredData,
GetValueForKey, (const char *), key);
LLDB_INSTRUMENT_VA(this, key);
SBStructuredData result;
result.m_impl_up->SetObjectSP(m_impl_up->GetValueForKey(key));
@ -166,8 +155,7 @@ lldb::SBStructuredData SBStructuredData::GetValueForKey(const char *key) const {
}
lldb::SBStructuredData SBStructuredData::GetItemAtIndex(size_t idx) const {
LLDB_RECORD_METHOD_CONST(lldb::SBStructuredData, SBStructuredData,
GetItemAtIndex, (size_t), idx);
LLDB_INSTRUMENT_VA(this, idx);
SBStructuredData result;
result.m_impl_up->SetObjectSP(m_impl_up->GetItemAtIndex(idx));
@ -175,29 +163,25 @@ lldb::SBStructuredData SBStructuredData::GetItemAtIndex(size_t idx) const {
}
uint64_t SBStructuredData::GetIntegerValue(uint64_t fail_value) const {
LLDB_RECORD_METHOD_CONST(uint64_t, SBStructuredData, GetIntegerValue,
(uint64_t), fail_value);
LLDB_INSTRUMENT_VA(this, fail_value);
return m_impl_up->GetIntegerValue(fail_value);
}
double SBStructuredData::GetFloatValue(double fail_value) const {
LLDB_RECORD_METHOD_CONST(double, SBStructuredData, GetFloatValue, (double),
fail_value);
LLDB_INSTRUMENT_VA(this, fail_value);
return m_impl_up->GetFloatValue(fail_value);
}
bool SBStructuredData::GetBooleanValue(bool fail_value) const {
LLDB_RECORD_METHOD_CONST(bool, SBStructuredData, GetBooleanValue, (bool),
fail_value);
LLDB_INSTRUMENT_VA(this, fail_value);
return m_impl_up->GetBooleanValue(fail_value);
}
size_t SBStructuredData::GetStringValue(char *dst, size_t dst_len) const {
LLDB_RECORD_METHOD_CONST(size_t, SBStructuredData, GetStringValue,
(char *, size_t), dst, "", dst_len);
LLDB_INSTRUMENT_VA(this, dst, dst_len);
return m_impl_up->GetStringValue(dst, dst_len);
}

46
lldb/source/API/SBSymbol.cpp
View file

@ -7,29 +7,28 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBSymbol.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBStream.h"
#include "lldb/Core/Disassembler.h"
#include "lldb/Core/Module.h"
#include "lldb/Symbol/Symbol.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Target.h"
#include "lldb/Utility/Instrumentation.h"
using namespace lldb;
using namespace lldb_private;
SBSymbol::SBSymbol() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSymbol); }
SBSymbol::SBSymbol() { LLDB_INSTRUMENT_VA(this); }
SBSymbol::SBSymbol(lldb_private::Symbol *lldb_object_ptr)
: m_opaque_ptr(lldb_object_ptr) {}
SBSymbol::SBSymbol(const lldb::SBSymbol &rhs) : m_opaque_ptr(rhs.m_opaque_ptr) {
LLDB_RECORD_CONSTRUCTOR(SBSymbol, (const lldb::SBSymbol &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
}
const SBSymbol &SBSymbol::operator=(const SBSymbol &rhs) {
LLDB_RECORD_METHOD(const lldb::SBSymbol &,
SBSymbol, operator=,(const lldb::SBSymbol &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_ptr = rhs.m_opaque_ptr;
return *this;
@ -42,17 +41,17 @@ void SBSymbol::SetSymbol(lldb_private::Symbol *lldb_object_ptr) {
}
bool SBSymbol::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbol, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBSymbol::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbol, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_opaque_ptr != nullptr;
}
const char *SBSymbol::GetName() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetName);
LLDB_INSTRUMENT_VA(this);
const char *name = nullptr;
if (m_opaque_ptr)
@ -62,7 +61,7 @@ const char *SBSymbol::GetName() const {
}
const char *SBSymbol::GetDisplayName() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetDisplayName);
LLDB_INSTRUMENT_VA(this);
const char *name = nullptr;
if (m_opaque_ptr)
@ -72,7 +71,7 @@ const char *SBSymbol::GetDisplayName() const {
}
const char *SBSymbol::GetMangledName() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetMangledName);
LLDB_INSTRUMENT_VA(this);
const char *name = nullptr;
if (m_opaque_ptr)
@ -81,22 +80,19 @@ const char *SBSymbol::GetMangledName() const {
}
bool SBSymbol::operator==(const SBSymbol &rhs) const {
LLDB_RECORD_METHOD_CONST(bool, SBSymbol, operator==,(const lldb::SBSymbol &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
return m_opaque_ptr == rhs.m_opaque_ptr;
}
bool SBSymbol::operator!=(const SBSymbol &rhs) const {
LLDB_RECORD_METHOD_CONST(bool, SBSymbol, operator!=,(const lldb::SBSymbol &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
return m_opaque_ptr != rhs.m_opaque_ptr;
}
bool SBSymbol::GetDescription(SBStream &description) {
LLDB_RECORD_METHOD(bool, SBSymbol, GetDescription, (lldb::SBStream &),
description);
LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();
@ -109,16 +105,14 @@ bool SBSymbol::GetDescription(SBStream &description) {
}
SBInstructionList SBSymbol::GetInstructions(SBTarget target) {
LLDB_RECORD_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions,
(lldb::SBTarget), target);
LLDB_INSTRUMENT_VA(this, target);
return GetInstructions(target, nullptr);
}
SBInstructionList SBSymbol::GetInstructions(SBTarget target,
const char *flavor_string) {
LLDB_RECORD_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions,
(lldb::SBTarget, const char *), target, flavor_string);
LLDB_INSTRUMENT_VA(this, target, flavor_string);
SBInstructionList sb_instructions;
if (m_opaque_ptr) {
@ -145,7 +139,7 @@ lldb_private::Symbol *SBSymbol::get() { return m_opaque_ptr; }
void SBSymbol::reset(lldb_private::Symbol *symbol) { m_opaque_ptr = symbol; }
SBAddress SBSymbol::GetStartAddress() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBSymbol, GetStartAddress);
LLDB_INSTRUMENT_VA(this);
SBAddress addr;
if (m_opaque_ptr && m_opaque_ptr->ValueIsAddress()) {
@ -155,7 +149,7 @@ SBAddress SBSymbol::GetStartAddress() {
}
SBAddress SBSymbol::GetEndAddress() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBSymbol, GetEndAddress);
LLDB_INSTRUMENT_VA(this);
SBAddress addr;
if (m_opaque_ptr && m_opaque_ptr->ValueIsAddress()) {
@ -169,7 +163,7 @@ SBAddress SBSymbol::GetEndAddress() {
}
uint32_t SBSymbol::GetPrologueByteSize() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBSymbol, GetPrologueByteSize);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr)
return m_opaque_ptr->GetPrologueByteSize();
@ -177,7 +171,7 @@ uint32_t SBSymbol::GetPrologueByteSize() {
}
SymbolType SBSymbol::GetType() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SymbolType, SBSymbol, GetType);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr)
return m_opaque_ptr->GetType();
@ -185,7 +179,7 @@ SymbolType SBSymbol::GetType() {
}
bool SBSymbol::IsExternal() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBSymbol, IsExternal);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr)
return m_opaque_ptr->IsExternal();
@ -193,7 +187,7 @@ bool SBSymbol::IsExternal() {
}
bool SBSymbol::IsSynthetic() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBSymbol, IsSynthetic);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_ptr)
return m_opaque_ptr->IsSynthetic();

58
lldb/source/API/SBSymbolContext.cpp
View file

@ -7,30 +7,26 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBSymbolContext.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/API/SBStream.h"
#include "lldb/Core/Module.h"
#include "lldb/Symbol/Function.h"
#include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/SymbolContext.h"
#include "lldb/Utility/Instrumentation.h"
using namespace lldb;
using namespace lldb_private;
SBSymbolContext::SBSymbolContext() {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSymbolContext);
}
SBSymbolContext::SBSymbolContext() { LLDB_INSTRUMENT_VA(this); }
SBSymbolContext::SBSymbolContext(const SymbolContext &sc)
: m_opaque_up(std::make_unique<SymbolContext>(sc)) {
LLDB_RECORD_CONSTRUCTOR(SBSymbolContext,
(const lldb_private::SymbolContext &), sc);
LLDB_INSTRUMENT_VA(this, sc);
}
SBSymbolContext::SBSymbolContext(const SBSymbolContext &rhs) {
LLDB_RECORD_CONSTRUCTOR(SBSymbolContext, (const lldb::SBSymbolContext &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_up = clone(rhs.m_opaque_up);
}
@ -38,9 +34,7 @@ SBSymbolContext::SBSymbolContext(const SBSymbolContext &rhs) {
SBSymbolContext::~SBSymbolContext() = default;
const SBSymbolContext &SBSymbolContext::operator=(const SBSymbolContext &rhs) {
LLDB_RECORD_METHOD(const lldb::SBSymbolContext &,
SBSymbolContext, operator=,(const lldb::SBSymbolContext &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
@ -48,17 +42,17 @@ const SBSymbolContext &SBSymbolContext::operator=(const SBSymbolContext &rhs) {
}
bool SBSymbolContext::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContext, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBSymbolContext::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContext, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up != nullptr;
}
SBModule SBSymbolContext::GetModule() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBModule, SBSymbolContext, GetModule);
LLDB_INSTRUMENT_VA(this);
SBModule sb_module;
ModuleSP module_sp;
@ -71,14 +65,13 @@ SBModule SBSymbolContext::GetModule() {
}
SBCompileUnit SBSymbolContext::GetCompileUnit() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCompileUnit, SBSymbolContext,
GetCompileUnit);
LLDB_INSTRUMENT_VA(this);
return SBCompileUnit(m_opaque_up ? m_opaque_up->comp_unit : nullptr);
}
SBFunction SBSymbolContext::GetFunction() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFunction, SBSymbolContext, GetFunction);
LLDB_INSTRUMENT_VA(this);
Function *function = nullptr;
@ -91,13 +84,13 @@ SBFunction SBSymbolContext::GetFunction() {
}
SBBlock SBSymbolContext::GetBlock() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBSymbolContext, GetBlock);
LLDB_INSTRUMENT_VA(this);
return SBBlock(m_opaque_up ? m_opaque_up->block : nullptr);
}
SBLineEntry SBSymbolContext::GetLineEntry() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBLineEntry, SBSymbolContext, GetLineEntry);
LLDB_INSTRUMENT_VA(this);
SBLineEntry sb_line_entry;
if (m_opaque_up)
@ -107,7 +100,7 @@ SBLineEntry SBSymbolContext::GetLineEntry() {
}
SBSymbol SBSymbolContext::GetSymbol() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSymbol, SBSymbolContext, GetSymbol);
LLDB_INSTRUMENT_VA(this);
Symbol *symbol = nullptr;
@ -120,35 +113,31 @@ SBSymbol SBSymbolContext::GetSymbol() {
}
void SBSymbolContext::SetModule(lldb::SBModule module) {
LLDB_RECORD_METHOD(void, SBSymbolContext, SetModule, (lldb::SBModule),
module);
LLDB_INSTRUMENT_VA(this, module);
ref().module_sp = module.GetSP();
}
void SBSymbolContext::SetCompileUnit(lldb::SBCompileUnit compile_unit) {
LLDB_RECORD_METHOD(void, SBSymbolContext, SetCompileUnit,
(lldb::SBCompileUnit), compile_unit);
LLDB_INSTRUMENT_VA(this, compile_unit);
ref().comp_unit = compile_unit.get();
}
void SBSymbolContext::SetFunction(lldb::SBFunction function) {
LLDB_RECORD_METHOD(void, SBSymbolContext, SetFunction, (lldb::SBFunction),
function);
LLDB_INSTRUMENT_VA(this, function);
ref().function = function.get();
}
void SBSymbolContext::SetBlock(lldb::SBBlock block) {
LLDB_RECORD_METHOD(void, SBSymbolContext, SetBlock, (lldb::SBBlock), block);
LLDB_INSTRUMENT_VA(this, block);
ref().block = block.GetPtr();
}
void SBSymbolContext::SetLineEntry(lldb::SBLineEntry line_entry) {
LLDB_RECORD_METHOD(void, SBSymbolContext, SetLineEntry, (lldb::SBLineEntry),
line_entry);
LLDB_INSTRUMENT_VA(this, line_entry);
if (line_entry.IsValid())
ref().line_entry = line_entry.ref();
@ -157,8 +146,7 @@ void SBSymbolContext::SetLineEntry(lldb::SBLineEntry line_entry) {
}
void SBSymbolContext::SetSymbol(lldb::SBSymbol symbol) {
LLDB_RECORD_METHOD(void, SBSymbolContext, SetSymbol, (lldb::SBSymbol),
symbol);
LLDB_INSTRUMENT_VA(this, symbol);
ref().symbol = symbol.get();
}
@ -189,8 +177,7 @@ lldb_private::SymbolContext *SBSymbolContext::get() const {
}
bool SBSymbolContext::GetDescription(SBStream &description) {
LLDB_RECORD_METHOD(bool, SBSymbolContext, GetDescription, (lldb::SBStream &),
description);
LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();
@ -205,10 +192,7 @@ bool SBSymbolContext::GetDescription(SBStream &description) {
SBSymbolContext
SBSymbolContext::GetParentOfInlinedScope(const SBAddress &curr_frame_pc,
SBAddress &parent_frame_addr) const {
LLDB_RECORD_METHOD_CONST(lldb::SBSymbolContext, SBSymbolContext,
GetParentOfInlinedScope,
(const lldb::SBAddress &, lldb::SBAddress &),
curr_frame_pc, parent_frame_addr);
LLDB_INSTRUMENT_VA(this, curr_frame_pc, parent_frame_addr);
SBSymbolContext sb_sc;
if (m_opaque_up.get() && curr_frame_pc.IsValid()) {

31
lldb/source/API/SBSymbolContextList.cpp
View file

@ -7,22 +7,21 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBSymbolContextList.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/API/SBStream.h"
#include "lldb/Symbol/SymbolContext.h"
#include "lldb/Utility/Instrumentation.h"
using namespace lldb;
using namespace lldb_private;
SBSymbolContextList::SBSymbolContextList()
: m_opaque_up(new SymbolContextList()) {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSymbolContextList);
LLDB_INSTRUMENT_VA(this);
}
SBSymbolContextList::SBSymbolContextList(const SBSymbolContextList &rhs) {
LLDB_RECORD_CONSTRUCTOR(SBSymbolContextList,
(const lldb::SBSymbolContextList &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_up = clone(rhs.m_opaque_up);
}
@ -31,9 +30,7 @@ SBSymbolContextList::~SBSymbolContextList() = default;
const SBSymbolContextList &SBSymbolContextList::
operator=(const SBSymbolContextList &rhs) {
LLDB_RECORD_METHOD(
const lldb::SBSymbolContextList &,
SBSymbolContextList, operator=,(const lldb::SBSymbolContextList &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
@ -41,7 +38,7 @@ operator=(const SBSymbolContextList &rhs) {
}
uint32_t SBSymbolContextList::GetSize() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBSymbolContextList, GetSize);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_up)
return m_opaque_up->GetSize();
@ -49,8 +46,7 @@ uint32_t SBSymbolContextList::GetSize() const {
}
SBSymbolContext SBSymbolContextList::GetContextAtIndex(uint32_t idx) {
LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBSymbolContextList,
GetContextAtIndex, (uint32_t), idx);
LLDB_INSTRUMENT_VA(this, idx);
SBSymbolContext sb_sc;
if (m_opaque_up) {
@ -62,34 +58,32 @@ SBSymbolContext SBSymbolContextList::GetContextAtIndex(uint32_t idx) {
}
void SBSymbolContextList::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBSymbolContextList, Clear);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_up)
m_opaque_up->Clear();
}
void SBSymbolContextList::Append(SBSymbolContext &sc) {
LLDB_RECORD_METHOD(void, SBSymbolContextList, Append,
(lldb::SBSymbolContext &), sc);
LLDB_INSTRUMENT_VA(this, sc);
if (sc.IsValid() && m_opaque_up.get())
m_opaque_up->Append(*sc);
}
void SBSymbolContextList::Append(SBSymbolContextList &sc_list) {
LLDB_RECORD_METHOD(void, SBSymbolContextList, Append,
(lldb::SBSymbolContextList &), sc_list);
LLDB_INSTRUMENT_VA(this, sc_list);
if (sc_list.IsValid() && m_opaque_up.get())
m_opaque_up->Append(*sc_list);
}
bool SBSymbolContextList::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContextList, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBSymbolContextList::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContextList, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up != nullptr;
}
@ -104,8 +98,7 @@ lldb_private::SymbolContextList &SBSymbolContextList::operator*() const {
}
bool SBSymbolContextList::GetDescription(lldb::SBStream &description) {
LLDB_RECORD_METHOD(bool, SBSymbolContextList, GetDescription,
(lldb::SBStream &), description);
LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();
if (m_opaque_up)

454
lldb/source/API/SBTarget.cpp
View file

File diff suppressed because it is too large Load diff

176
lldb/source/API/SBThread.cpp
View file

@ -7,7 +7,6 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBThread.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBDebugger.h"
@ -40,6 +39,7 @@
#include "lldb/Target/ThreadPlanStepInstruction.h"
#include "lldb/Target/ThreadPlanStepOut.h"
#include "lldb/Target/ThreadPlanStepRange.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/State.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StructuredData.h"
@ -51,24 +51,23 @@ using namespace lldb;
using namespace lldb_private;
const char *SBThread::GetBroadcasterClassName() {
LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBThread,
GetBroadcasterClassName);
LLDB_INSTRUMENT();
return Thread::GetStaticBroadcasterClass().AsCString();
}
// Constructors
SBThread::SBThread() : m_opaque_sp(new ExecutionContextRef()) {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBThread);
LLDB_INSTRUMENT_VA(this);
}
SBThread::SBThread(const ThreadSP &lldb_object_sp)
: m_opaque_sp(new ExecutionContextRef(lldb_object_sp)) {
LLDB_RECORD_CONSTRUCTOR(SBThread, (const lldb::ThreadSP &), lldb_object_sp);
LLDB_INSTRUMENT_VA(this, lldb_object_sp);
}
SBThread::SBThread(const SBThread &rhs) {
LLDB_RECORD_CONSTRUCTOR(SBThread, (const lldb::SBThread &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_sp = clone(rhs.m_opaque_sp);
}
@ -76,8 +75,7 @@ SBThread::SBThread(const SBThread &rhs) {
// Assignment operator
const lldb::SBThread &SBThread::operator=(const SBThread &rhs) {
LLDB_RECORD_METHOD(const lldb::SBThread &,
SBThread, operator=,(const lldb::SBThread &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_sp = clone(rhs.m_opaque_sp);
@ -88,7 +86,7 @@ const lldb::SBThread &SBThread::operator=(const SBThread &rhs) {
SBThread::~SBThread() = default;
lldb::SBQueue SBThread::GetQueue() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBQueue, SBThread, GetQueue);
LLDB_INSTRUMENT_VA(this);
SBQueue sb_queue;
QueueSP queue_sp;
@ -109,11 +107,11 @@ lldb::SBQueue SBThread::GetQueue() const {
}
bool SBThread::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThread, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBThread::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThread, operator bool);
LLDB_INSTRUMENT_VA(this);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@ -130,13 +128,13 @@ SBThread::operator bool() const {
}
void SBThread::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBThread, Clear);
LLDB_INSTRUMENT_VA(this);
m_opaque_sp->Clear();
}
StopReason SBThread::GetStopReason() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::StopReason, SBThread, GetStopReason);
LLDB_INSTRUMENT_VA(this);
StopReason reason = eStopReasonInvalid;
std::unique_lock<std::recursive_mutex> lock;
@ -153,7 +151,7 @@ StopReason SBThread::GetStopReason() {
}
size_t SBThread::GetStopReasonDataCount() {
LLDB_RECORD_METHOD_NO_ARGS(size_t, SBThread, GetStopReasonDataCount);
LLDB_INSTRUMENT_VA(this);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@ -210,8 +208,7 @@ size_t SBThread::GetStopReasonDataCount() {
}
uint64_t SBThread::GetStopReasonDataAtIndex(uint32_t idx) {
LLDB_RECORD_METHOD(uint64_t, SBThread, GetStopReasonDataAtIndex, (uint32_t),
idx);
LLDB_INSTRUMENT_VA(this, idx);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@ -280,8 +277,7 @@ uint64_t SBThread::GetStopReasonDataAtIndex(uint32_t idx) {
}
bool SBThread::GetStopReasonExtendedInfoAsJSON(lldb::SBStream &stream) {
LLDB_RECORD_METHOD(bool, SBThread, GetStopReasonExtendedInfoAsJSON,
(lldb::SBStream &), stream);
LLDB_INSTRUMENT_VA(this, stream);
Stream &strm = stream.ref();
@ -303,9 +299,7 @@ bool SBThread::GetStopReasonExtendedInfoAsJSON(lldb::SBStream &stream) {
SBThreadCollection
SBThread::GetStopReasonExtendedBacktraces(InstrumentationRuntimeType type) {
LLDB_RECORD_METHOD(lldb::SBThreadCollection, SBThread,
GetStopReasonExtendedBacktraces,
(lldb::InstrumentationRuntimeType), type);
LLDB_INSTRUMENT_VA(this, type);
SBThreadCollection threads;
@ -328,8 +322,7 @@ SBThread::GetStopReasonExtendedBacktraces(InstrumentationRuntimeType type) {
}
size_t SBThread::GetStopDescription(char *dst, size_t dst_len) {
LLDB_RECORD_METHOD(size_t, SBThread, GetStopDescription, (char *, size_t),
dst, "", dst_len);
LLDB_INSTRUMENT_VA(this, dst, dst_len);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@ -357,7 +350,7 @@ size_t SBThread::GetStopDescription(char *dst, size_t dst_len) {
}
SBValue SBThread::GetStopReturnValue() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBThread, GetStopReturnValue);
LLDB_INSTRUMENT_VA(this);
ValueObjectSP return_valobj_sp;
std::unique_lock<std::recursive_mutex> lock;
@ -381,7 +374,7 @@ void SBThread::SetThread(const ThreadSP &lldb_object_sp) {
}
lldb::tid_t SBThread::GetThreadID() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::tid_t, SBThread, GetThreadID);
LLDB_INSTRUMENT_VA(this);
ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
if (thread_sp)
@ -390,7 +383,7 @@ lldb::tid_t SBThread::GetThreadID() const {
}
uint32_t SBThread::GetIndexID() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBThread, GetIndexID);
LLDB_INSTRUMENT_VA(this);
ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
if (thread_sp)
@ -399,7 +392,7 @@ uint32_t SBThread::GetIndexID() const {
}
const char *SBThread::GetName() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBThread, GetName);
LLDB_INSTRUMENT_VA(this);
const char *name = nullptr;
std::unique_lock<std::recursive_mutex> lock;
@ -416,7 +409,7 @@ const char *SBThread::GetName() const {
}
const char *SBThread::GetQueueName() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBThread, GetQueueName);
LLDB_INSTRUMENT_VA(this);
const char *name = nullptr;
std::unique_lock<std::recursive_mutex> lock;
@ -433,7 +426,7 @@ const char *SBThread::GetQueueName() const {
}
lldb::queue_id_t SBThread::GetQueueID() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::queue_id_t, SBThread, GetQueueID);
LLDB_INSTRUMENT_VA(this);
queue_id_t id = LLDB_INVALID_QUEUE_ID;
std::unique_lock<std::recursive_mutex> lock;
@ -450,8 +443,7 @@ lldb::queue_id_t SBThread::GetQueueID() const {
}
bool SBThread::GetInfoItemByPathAsString(const char *path, SBStream &strm) {
LLDB_RECORD_METHOD(bool, SBThread, GetInfoItemByPathAsString,
(const char *, lldb::SBStream &), path, strm);
LLDB_INSTRUMENT_VA(this, path, strm);
bool success = false;
std::unique_lock<std::recursive_mutex> lock;
@ -532,16 +524,14 @@ SBError SBThread::ResumeNewPlan(ExecutionContext &exe_ctx,
}
void SBThread::StepOver(lldb::RunMode stop_other_threads) {
LLDB_RECORD_METHOD(void, SBThread, StepOver, (lldb::RunMode),
stop_other_threads);
LLDB_INSTRUMENT_VA(this, stop_other_threads);
SBError error; // Ignored
StepOver(stop_other_threads, error);
}
void SBThread::StepOver(lldb::RunMode stop_other_threads, SBError &error) {
LLDB_RECORD_METHOD(void, SBThread, StepOver, (lldb::RunMode, lldb::SBError &),
stop_other_threads, error);
LLDB_INSTRUMENT_VA(this, stop_other_threads, error);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@ -573,16 +563,14 @@ void SBThread::StepOver(lldb::RunMode stop_other_threads, SBError &error) {
}
void SBThread::StepInto(lldb::RunMode stop_other_threads) {
LLDB_RECORD_METHOD(void, SBThread, StepInto, (lldb::RunMode),
stop_other_threads);
LLDB_INSTRUMENT_VA(this, stop_other_threads);
StepInto(nullptr, stop_other_threads);
}
void SBThread::StepInto(const char *target_name,
lldb::RunMode stop_other_threads) {
LLDB_RECORD_METHOD(void, SBThread, StepInto, (const char *, lldb::RunMode),
target_name, stop_other_threads);
LLDB_INSTRUMENT_VA(this, target_name, stop_other_threads);
SBError error; // Ignored
StepInto(target_name, LLDB_INVALID_LINE_NUMBER, error, stop_other_threads);
@ -590,10 +578,7 @@ void SBThread::StepInto(const char *target_name,
void SBThread::StepInto(const char *target_name, uint32_t end_line,
SBError &error, lldb::RunMode stop_other_threads) {
LLDB_RECORD_METHOD(void, SBThread, StepInto,
(const char *, uint32_t, lldb::SBError &, lldb::RunMode),
target_name, end_line, error, stop_other_threads);
LLDB_INSTRUMENT_VA(this, target_name, end_line, error, stop_other_threads);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@ -640,14 +625,14 @@ void SBThread::StepInto(const char *target_name, uint32_t end_line,
}
void SBThread::StepOut() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBThread, StepOut);
LLDB_INSTRUMENT_VA(this);
SBError error; // Ignored
StepOut(error);
}
void SBThread::StepOut(SBError &error) {
LLDB_RECORD_METHOD(void, SBThread, StepOut, (lldb::SBError &), error);
LLDB_INSTRUMENT_VA(this, error);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@ -675,17 +660,14 @@ void SBThread::StepOut(SBError &error) {
}
void SBThread::StepOutOfFrame(SBFrame &sb_frame) {
LLDB_RECORD_METHOD(void, SBThread, StepOutOfFrame, (lldb::SBFrame &),
sb_frame);
LLDB_INSTRUMENT_VA(this, sb_frame);
SBError error; // Ignored
StepOutOfFrame(sb_frame, error);
}
void SBThread::StepOutOfFrame(SBFrame &sb_frame, SBError &error) {
LLDB_RECORD_METHOD(void, SBThread, StepOutOfFrame,
(lldb::SBFrame &, lldb::SBError &), sb_frame, error);
LLDB_INSTRUMENT_VA(this, sb_frame, error);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@ -722,15 +704,14 @@ void SBThread::StepOutOfFrame(SBFrame &sb_frame, SBError &error) {
}
void SBThread::StepInstruction(bool step_over) {
LLDB_RECORD_METHOD(void, SBThread, StepInstruction, (bool), step_over);
LLDB_INSTRUMENT_VA(this, step_over);
SBError error; // Ignored
StepInstruction(step_over, error);
}
void SBThread::StepInstruction(bool step_over, SBError &error) {
LLDB_RECORD_METHOD(void, SBThread, StepInstruction, (bool, lldb::SBError &),
step_over, error);
LLDB_INSTRUMENT_VA(this, step_over, error);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@ -752,15 +733,14 @@ void SBThread::StepInstruction(bool step_over, SBError &error) {
}
void SBThread::RunToAddress(lldb::addr_t addr) {
LLDB_RECORD_METHOD(void, SBThread, RunToAddress, (lldb::addr_t), addr);
LLDB_INSTRUMENT_VA(this, addr);
SBError error; // Ignored
RunToAddress(addr, error);
}
void SBThread::RunToAddress(lldb::addr_t addr, SBError &error) {
LLDB_RECORD_METHOD(void, SBThread, RunToAddress,
(lldb::addr_t, lldb::SBError &), addr, error);
LLDB_INSTRUMENT_VA(this, addr, error);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@ -789,9 +769,7 @@ void SBThread::RunToAddress(lldb::addr_t addr, SBError &error) {
SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame,
lldb::SBFileSpec &sb_file_spec, uint32_t line) {
LLDB_RECORD_METHOD(lldb::SBError, SBThread, StepOverUntil,
(lldb::SBFrame &, lldb::SBFileSpec &, uint32_t), sb_frame,
sb_file_spec, line);
LLDB_INSTRUMENT_VA(this, sb_frame, sb_file_spec, line);
SBError sb_error;
char path[PATH_MAX];
@ -908,17 +886,14 @@ SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame,
}
SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name) {
LLDB_RECORD_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
(const char *), script_class_name);
LLDB_INSTRUMENT_VA(this, script_class_name);
return StepUsingScriptedThreadPlan(script_class_name, true);
}
SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name,
bool resume_immediately) {
LLDB_RECORD_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
(const char *, bool), script_class_name,
resume_immediately);
LLDB_INSTRUMENT_VA(this, script_class_name, resume_immediately);
lldb::SBStructuredData no_data;
return StepUsingScriptedThreadPlan(script_class_name, no_data,
@ -928,9 +903,7 @@ SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name,
SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name,
SBStructuredData &args_data,
bool resume_immediately) {
LLDB_RECORD_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
(const char *, lldb::SBStructuredData &, bool),
script_class_name, args_data, resume_immediately);
LLDB_INSTRUMENT_VA(this, script_class_name, args_data, resume_immediately);
SBError error;
@ -966,8 +939,7 @@ SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name,
}
SBError SBThread::JumpToLine(lldb::SBFileSpec &file_spec, uint32_t line) {
LLDB_RECORD_METHOD(lldb::SBError, SBThread, JumpToLine,
(lldb::SBFileSpec &, uint32_t), file_spec, line);
LLDB_INSTRUMENT_VA(this, file_spec, line);
SBError sb_error;
@ -987,8 +959,7 @@ SBError SBThread::JumpToLine(lldb::SBFileSpec &file_spec, uint32_t line) {
}
SBError SBThread::ReturnFromFrame(SBFrame &frame, SBValue &return_value) {
LLDB_RECORD_METHOD(lldb::SBError, SBThread, ReturnFromFrame,
(lldb::SBFrame &, lldb::SBValue &), frame, return_value);
LLDB_INSTRUMENT_VA(this, frame, return_value);
SBError sb_error;
@ -1005,8 +976,7 @@ SBError SBThread::ReturnFromFrame(SBFrame &frame, SBValue &return_value) {
}
SBError SBThread::UnwindInnermostExpression() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBThread,
UnwindInnermostExpression);
LLDB_INSTRUMENT_VA(this);
SBError sb_error;
@ -1024,14 +994,14 @@ SBError SBThread::UnwindInnermostExpression() {
}
bool SBThread::Suspend() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, Suspend);
LLDB_INSTRUMENT_VA(this);
SBError error; // Ignored
return Suspend(error);
}
bool SBThread::Suspend(SBError &error) {
LLDB_RECORD_METHOD(bool, SBThread, Suspend, (lldb::SBError &), error);
LLDB_INSTRUMENT_VA(this, error);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@ -1051,14 +1021,14 @@ bool SBThread::Suspend(SBError &error) {
}
bool SBThread::Resume() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, Resume);
LLDB_INSTRUMENT_VA(this);
SBError error; // Ignored
return Resume(error);
}
bool SBThread::Resume(SBError &error) {
LLDB_RECORD_METHOD(bool, SBThread, Resume, (lldb::SBError &), error);
LLDB_INSTRUMENT_VA(this, error);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@ -1079,7 +1049,7 @@ bool SBThread::Resume(SBError &error) {
}
bool SBThread::IsSuspended() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, IsSuspended);
LLDB_INSTRUMENT_VA(this);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@ -1090,7 +1060,7 @@ bool SBThread::IsSuspended() {
}
bool SBThread::IsStopped() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, IsStopped);
LLDB_INSTRUMENT_VA(this);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@ -1101,7 +1071,7 @@ bool SBThread::IsStopped() {
}
SBProcess SBThread::GetProcess() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBThread, GetProcess);
LLDB_INSTRUMENT_VA(this);
SBProcess sb_process;
std::unique_lock<std::recursive_mutex> lock;
@ -1117,7 +1087,7 @@ SBProcess SBThread::GetProcess() {
}
uint32_t SBThread::GetNumFrames() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBThread, GetNumFrames);
LLDB_INSTRUMENT_VA(this);
uint32_t num_frames = 0;
std::unique_lock<std::recursive_mutex> lock;
@ -1134,7 +1104,7 @@ uint32_t SBThread::GetNumFrames() {
}
SBFrame SBThread::GetFrameAtIndex(uint32_t idx) {
LLDB_RECORD_METHOD(lldb::SBFrame, SBThread, GetFrameAtIndex, (uint32_t), idx);
LLDB_INSTRUMENT_VA(this, idx);
SBFrame sb_frame;
StackFrameSP frame_sp;
@ -1153,7 +1123,7 @@ SBFrame SBThread::GetFrameAtIndex(uint32_t idx) {
}
lldb::SBFrame SBThread::GetSelectedFrame() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFrame, SBThread, GetSelectedFrame);
LLDB_INSTRUMENT_VA(this);
SBFrame sb_frame;
StackFrameSP frame_sp;
@ -1172,8 +1142,7 @@ lldb::SBFrame SBThread::GetSelectedFrame() {
}
lldb::SBFrame SBThread::SetSelectedFrame(uint32_t idx) {
LLDB_RECORD_METHOD(lldb::SBFrame, SBThread, SetSelectedFrame, (uint32_t),
idx);
LLDB_INSTRUMENT_VA(this, idx);
SBFrame sb_frame;
StackFrameSP frame_sp;
@ -1196,45 +1165,39 @@ lldb::SBFrame SBThread::SetSelectedFrame(uint32_t idx) {
}
bool SBThread::EventIsThreadEvent(const SBEvent &event) {
LLDB_RECORD_STATIC_METHOD(bool, SBThread, EventIsThreadEvent,
(const lldb::SBEvent &), event);
LLDB_INSTRUMENT_VA(event);
return Thread::ThreadEventData::GetEventDataFromEvent(event.get()) != nullptr;
}
SBFrame SBThread::GetStackFrameFromEvent(const SBEvent &event) {
LLDB_RECORD_STATIC_METHOD(lldb::SBFrame, SBThread, GetStackFrameFromEvent,
(const lldb::SBEvent &), event);
LLDB_INSTRUMENT_VA(event);
return Thread::ThreadEventData::GetStackFrameFromEvent(event.get());
}
SBThread SBThread::GetThreadFromEvent(const SBEvent &event) {
LLDB_RECORD_STATIC_METHOD(lldb::SBThread, SBThread, GetThreadFromEvent,
(const lldb::SBEvent &), event);
LLDB_INSTRUMENT_VA(event);
return Thread::ThreadEventData::GetThreadFromEvent(event.get());
}
bool SBThread::operator==(const SBThread &rhs) const {
LLDB_RECORD_METHOD_CONST(bool, SBThread, operator==,(const lldb::SBThread &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
return m_opaque_sp->GetThreadSP().get() ==
rhs.m_opaque_sp->GetThreadSP().get();
}
bool SBThread::operator!=(const SBThread &rhs) const {
LLDB_RECORD_METHOD_CONST(bool, SBThread, operator!=,(const lldb::SBThread &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
return m_opaque_sp->GetThreadSP().get() !=
rhs.m_opaque_sp->GetThreadSP().get();
}
bool SBThread::GetStatus(SBStream &status) const {
LLDB_RECORD_METHOD_CONST(bool, SBThread, GetStatus, (lldb::SBStream &),
status);
LLDB_INSTRUMENT_VA(this, status);
Stream &strm = status.ref();
@ -1250,15 +1213,13 @@ bool SBThread::GetStatus(SBStream &status) const {
}
bool SBThread::GetDescription(SBStream &description) const {
LLDB_RECORD_METHOD_CONST(bool, SBThread, GetDescription, (lldb::SBStream &),
description);
LLDB_INSTRUMENT_VA(this, description);
return GetDescription(description, false);
}
bool SBThread::GetDescription(SBStream &description, bool stop_format) const {
LLDB_RECORD_METHOD_CONST(bool, SBThread, GetDescription,
(lldb::SBStream &, bool), description, stop_format);
LLDB_INSTRUMENT_VA(this, description, stop_format);
Stream &strm = description.ref();
@ -1278,8 +1239,7 @@ bool SBThread::GetDescription(SBStream &description, bool stop_format) const {
}
SBThread SBThread::GetExtendedBacktraceThread(const char *type) {
LLDB_RECORD_METHOD(lldb::SBThread, SBThread, GetExtendedBacktraceThread,
(const char *), type);
LLDB_INSTRUMENT_VA(this, type);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@ -1313,8 +1273,7 @@ SBThread SBThread::GetExtendedBacktraceThread(const char *type) {
}
uint32_t SBThread::GetExtendedBacktraceOriginatingIndexID() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBThread,
GetExtendedBacktraceOriginatingIndexID);
LLDB_INSTRUMENT_VA(this);
ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
if (thread_sp)
@ -1323,7 +1282,7 @@ uint32_t SBThread::GetExtendedBacktraceOriginatingIndexID() {
}
SBValue SBThread::GetCurrentException() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBThread, GetCurrentException);
LLDB_INSTRUMENT_VA(this);
ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
if (!thread_sp)
@ -1333,8 +1292,7 @@ SBValue SBThread::GetCurrentException() {
}
SBThread SBThread::GetCurrentExceptionBacktrace() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBThread, SBThread,
GetCurrentExceptionBacktrace);
LLDB_INSTRUMENT_VA(this);
ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
if (!thread_sp)
@ -1344,7 +1302,7 @@ SBThread SBThread::GetCurrentExceptionBacktrace() {
}
bool SBThread::SafeToCallFunctions() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, SafeToCallFunctions);
LLDB_INSTRUMENT_VA(this);
ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
if (thread_sp)

22
lldb/source/API/SBThreadCollection.cpp
View file

@ -7,28 +7,23 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBThreadCollection.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBThread.h"
#include "lldb/Target/ThreadList.h"
#include "lldb/Utility/Instrumentation.h"
using namespace lldb;
using namespace lldb_private;
SBThreadCollection::SBThreadCollection() {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBThreadCollection);
}
SBThreadCollection::SBThreadCollection() { LLDB_INSTRUMENT_VA(this); }
SBThreadCollection::SBThreadCollection(const SBThreadCollection &rhs)
: m_opaque_sp(rhs.m_opaque_sp) {
LLDB_RECORD_CONSTRUCTOR(SBThreadCollection,
(const lldb::SBThreadCollection &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
}
const SBThreadCollection &SBThreadCollection::
operator=(const SBThreadCollection &rhs) {
LLDB_RECORD_METHOD(
const lldb::SBThreadCollection &,
SBThreadCollection, operator=,(const lldb::SBThreadCollection &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_sp = rhs.m_opaque_sp;
@ -61,17 +56,17 @@ const lldb::ThreadCollectionSP &SBThreadCollection::operator*() const {
}
bool SBThreadCollection::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadCollection, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBThreadCollection::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadCollection, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp.get() != nullptr;
}
size_t SBThreadCollection::GetSize() {
LLDB_RECORD_METHOD_NO_ARGS(size_t, SBThreadCollection, GetSize);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp)
return m_opaque_sp->GetSize();
@ -79,8 +74,7 @@ size_t SBThreadCollection::GetSize() {
}
SBThread SBThreadCollection::GetThreadAtIndex(size_t idx) {
LLDB_RECORD_METHOD(lldb::SBThread, SBThreadCollection, GetThreadAtIndex,
(size_t), idx);
LLDB_INSTRUMENT_VA(this, idx);
SBThread thread;
if (m_opaque_sp && idx < m_opaque_sp->GetSize())

97
lldb/source/API/SBThreadPlan.cpp
View file

@ -6,8 +6,8 @@
//
//===----------------------------------------------------------------------===//
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBThread.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/API/SBFileSpec.h"
#include "lldb/API/SBStream.h"
@ -50,22 +50,20 @@ using namespace lldb;
using namespace lldb_private;
// Constructors
SBThreadPlan::SBThreadPlan() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBThreadPlan); }
SBThreadPlan::SBThreadPlan() { LLDB_INSTRUMENT_VA(this); }
SBThreadPlan::SBThreadPlan(const ThreadPlanSP &lldb_object_sp)
: m_opaque_wp(lldb_object_sp) {
LLDB_RECORD_CONSTRUCTOR(SBThreadPlan, (const lldb::ThreadPlanSP &),
lldb_object_sp);
LLDB_INSTRUMENT_VA(this, lldb_object_sp);
}
SBThreadPlan::SBThreadPlan(const SBThreadPlan &rhs)
: m_opaque_wp(rhs.m_opaque_wp) {
LLDB_RECORD_CONSTRUCTOR(SBThreadPlan, (const lldb::SBThreadPlan &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
}
SBThreadPlan::SBThreadPlan(lldb::SBThread &sb_thread, const char *class_name) {
LLDB_RECORD_CONSTRUCTOR(SBThreadPlan, (lldb::SBThread &, const char *),
sb_thread, class_name);
LLDB_INSTRUMENT_VA(this, sb_thread, class_name);
Thread *thread = sb_thread.get();
if (thread)
@ -75,9 +73,7 @@ SBThreadPlan::SBThreadPlan(lldb::SBThread &sb_thread, const char *class_name) {
SBThreadPlan::SBThreadPlan(lldb::SBThread &sb_thread, const char *class_name,
lldb::SBStructuredData &args_data) {
LLDB_RECORD_CONSTRUCTOR(SBThreadPlan, (lldb::SBThread &, const char *,
SBStructuredData &),
sb_thread, class_name, args_data);
LLDB_INSTRUMENT_VA(this, sb_thread, class_name, args_data);
Thread *thread = sb_thread.get();
if (thread)
@ -88,8 +84,7 @@ SBThreadPlan::SBThreadPlan(lldb::SBThread &sb_thread, const char *class_name,
// Assignment operator
const lldb::SBThreadPlan &SBThreadPlan::operator=(const SBThreadPlan &rhs) {
LLDB_RECORD_METHOD(const lldb::SBThreadPlan &,
SBThreadPlan, operator=,(const lldb::SBThreadPlan &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_wp = rhs.m_opaque_wp;
@ -99,42 +94,41 @@ const lldb::SBThreadPlan &SBThreadPlan::operator=(const SBThreadPlan &rhs) {
SBThreadPlan::~SBThreadPlan() = default;
bool SBThreadPlan::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadPlan, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBThreadPlan::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadPlan, operator bool);
LLDB_INSTRUMENT_VA(this);
return static_cast<bool>(GetSP());
}
void SBThreadPlan::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBThreadPlan, Clear);
LLDB_INSTRUMENT_VA(this);
m_opaque_wp.reset();
}
lldb::StopReason SBThreadPlan::GetStopReason() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::StopReason, SBThreadPlan, GetStopReason);
LLDB_INSTRUMENT_VA(this);
return eStopReasonNone;
}
size_t SBThreadPlan::GetStopReasonDataCount() {
LLDB_RECORD_METHOD_NO_ARGS(size_t, SBThreadPlan, GetStopReasonDataCount);
LLDB_INSTRUMENT_VA(this);
return 0;
}
uint64_t SBThreadPlan::GetStopReasonDataAtIndex(uint32_t idx) {
LLDB_RECORD_METHOD(uint64_t, SBThreadPlan, GetStopReasonDataAtIndex,
(uint32_t), idx);
LLDB_INSTRUMENT_VA(this, idx);
return 0;
}
SBThread SBThreadPlan::GetThread() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBThreadPlan, GetThread);
LLDB_INSTRUMENT_VA(this);
ThreadPlanSP thread_plan_sp(GetSP());
if (thread_plan_sp) {
@ -144,8 +138,7 @@ SBThread SBThreadPlan::GetThread() const {
}
bool SBThreadPlan::GetDescription(lldb::SBStream &description) const {
LLDB_RECORD_METHOD_CONST(bool, SBThreadPlan, GetDescription,
(lldb::SBStream &), description);
LLDB_INSTRUMENT_VA(this, description);
ThreadPlanSP thread_plan_sp(GetSP());
if (thread_plan_sp) {
@ -161,7 +154,7 @@ void SBThreadPlan::SetThreadPlan(const ThreadPlanSP &lldb_object_wp) {
}
void SBThreadPlan::SetPlanComplete(bool success) {
LLDB_RECORD_METHOD(void, SBThreadPlan, SetPlanComplete, (bool), success);
LLDB_INSTRUMENT_VA(this, success);
ThreadPlanSP thread_plan_sp(GetSP());
if (thread_plan_sp)
@ -169,7 +162,7 @@ void SBThreadPlan::SetPlanComplete(bool success) {
}
bool SBThreadPlan::IsPlanComplete() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, IsPlanComplete);
LLDB_INSTRUMENT_VA(this);
ThreadPlanSP thread_plan_sp(GetSP());
if (thread_plan_sp)
@ -178,7 +171,7 @@ bool SBThreadPlan::IsPlanComplete() {
}
bool SBThreadPlan::IsPlanStale() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, IsPlanStale);
LLDB_INSTRUMENT_VA(this);
ThreadPlanSP thread_plan_sp(GetSP());
if (thread_plan_sp)
@ -187,7 +180,7 @@ bool SBThreadPlan::IsPlanStale() {
}
bool SBThreadPlan::IsValid() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, IsValid);
LLDB_INSTRUMENT_VA(this);
ThreadPlanSP thread_plan_sp(GetSP());
if (thread_plan_sp)
@ -196,7 +189,7 @@ bool SBThreadPlan::IsValid() {
}
bool SBThreadPlan::GetStopOthers() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, GetStopOthers);
LLDB_INSTRUMENT_VA(this);
ThreadPlanSP thread_plan_sp(GetSP());
if (thread_plan_sp)
@ -205,7 +198,7 @@ bool SBThreadPlan::GetStopOthers() {
}
void SBThreadPlan::SetStopOthers(bool stop_others) {
LLDB_RECORD_METHOD(void, SBThreadPlan, SetStopOthers, (bool), stop_others);
LLDB_INSTRUMENT_VA(this, stop_others);
ThreadPlanSP thread_plan_sp(GetSP());
if (thread_plan_sp)
@ -221,9 +214,7 @@ void SBThreadPlan::SetStopOthers(bool stop_others) {
SBThreadPlan
SBThreadPlan::QueueThreadPlanForStepOverRange(SBAddress &sb_start_address,
lldb::addr_t size) {
LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
QueueThreadPlanForStepOverRange,
(lldb::SBAddress &, lldb::addr_t), sb_start_address, size);
LLDB_INSTRUMENT_VA(this, sb_start_address, size);
SBError error;
return QueueThreadPlanForStepOverRange(sb_start_address, size, error);
@ -231,10 +222,7 @@ SBThreadPlan::QueueThreadPlanForStepOverRange(SBAddress &sb_start_address,
SBThreadPlan SBThreadPlan::QueueThreadPlanForStepOverRange(
SBAddress &sb_start_address, lldb::addr_t size, SBError &error) {
LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
QueueThreadPlanForStepOverRange,
(lldb::SBAddress &, lldb::addr_t, lldb::SBError &),
sb_start_address, size, error);
LLDB_INSTRUMENT_VA(this, sb_start_address, size, error);
ThreadPlanSP thread_plan_sp(GetSP());
if (thread_plan_sp) {
@ -265,9 +253,7 @@ SBThreadPlan SBThreadPlan::QueueThreadPlanForStepOverRange(
SBThreadPlan
SBThreadPlan::QueueThreadPlanForStepInRange(SBAddress &sb_start_address,
lldb::addr_t size) {
LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
QueueThreadPlanForStepInRange,
(lldb::SBAddress &, lldb::addr_t), sb_start_address, size);
LLDB_INSTRUMENT_VA(this, sb_start_address, size);
SBError error;
return QueueThreadPlanForStepInRange(sb_start_address, size, error);
@ -276,10 +262,7 @@ SBThreadPlan::QueueThreadPlanForStepInRange(SBAddress &sb_start_address,
SBThreadPlan
SBThreadPlan::QueueThreadPlanForStepInRange(SBAddress &sb_start_address,
lldb::addr_t size, SBError &error) {
LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
QueueThreadPlanForStepInRange,
(lldb::SBAddress &, lldb::addr_t, lldb::SBError &),
sb_start_address, size, error);
LLDB_INSTRUMENT_VA(this, sb_start_address, size, error);
ThreadPlanSP thread_plan_sp(GetSP());
if (thread_plan_sp) {
@ -310,9 +293,7 @@ SBThreadPlan::QueueThreadPlanForStepInRange(SBAddress &sb_start_address,
SBThreadPlan
SBThreadPlan::QueueThreadPlanForStepOut(uint32_t frame_idx_to_step_to,
bool first_insn) {
LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
QueueThreadPlanForStepOut, (uint32_t, bool),
frame_idx_to_step_to, first_insn);
LLDB_INSTRUMENT_VA(this, frame_idx_to_step_to, first_insn);
SBError error;
return QueueThreadPlanForStepOut(frame_idx_to_step_to, first_insn, error);
@ -321,10 +302,7 @@ SBThreadPlan::QueueThreadPlanForStepOut(uint32_t frame_idx_to_step_to,
SBThreadPlan
SBThreadPlan::QueueThreadPlanForStepOut(uint32_t frame_idx_to_step_to,
bool first_insn, SBError &error) {
LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
QueueThreadPlanForStepOut,
(uint32_t, bool, lldb::SBError &), frame_idx_to_step_to,
first_insn, error);
LLDB_INSTRUMENT_VA(this, frame_idx_to_step_to, first_insn, error);
ThreadPlanSP thread_plan_sp(GetSP());
if (thread_plan_sp) {
@ -350,9 +328,7 @@ SBThreadPlan::QueueThreadPlanForStepOut(uint32_t frame_idx_to_step_to,
SBThreadPlan
SBThreadPlan::QueueThreadPlanForRunToAddress(SBAddress sb_address) {
LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
QueueThreadPlanForRunToAddress, (lldb::SBAddress),
sb_address);
LLDB_INSTRUMENT_VA(this, sb_address);
SBError error;
return QueueThreadPlanForRunToAddress(sb_address, error);
@ -360,9 +336,7 @@ SBThreadPlan::QueueThreadPlanForRunToAddress(SBAddress sb_address) {
SBThreadPlan SBThreadPlan::QueueThreadPlanForRunToAddress(SBAddress sb_address,
SBError &error) {
LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
QueueThreadPlanForRunToAddress,
(lldb::SBAddress, lldb::SBError &), sb_address, error);
LLDB_INSTRUMENT_VA(this, sb_address, error);
ThreadPlanSP thread_plan_sp(GetSP());
if (thread_plan_sp) {
@ -387,9 +361,7 @@ SBThreadPlan SBThreadPlan::QueueThreadPlanForRunToAddress(SBAddress sb_address,
SBThreadPlan
SBThreadPlan::QueueThreadPlanForStepScripted(const char *script_class_name) {
LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
QueueThreadPlanForStepScripted, (const char *),
script_class_name);
LLDB_INSTRUMENT_VA(this, script_class_name);
SBError error;
return QueueThreadPlanForStepScripted(script_class_name, error);
@ -398,9 +370,7 @@ SBThreadPlan::QueueThreadPlanForStepScripted(const char *script_class_name) {
SBThreadPlan
SBThreadPlan::QueueThreadPlanForStepScripted(const char *script_class_name,
SBError &error) {
LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
QueueThreadPlanForStepScripted,
(const char *, lldb::SBError &), script_class_name, error);
LLDB_INSTRUMENT_VA(this, script_class_name, error);
ThreadPlanSP thread_plan_sp(GetSP());
if (thread_plan_sp) {
@ -424,10 +394,7 @@ SBThreadPlan
SBThreadPlan::QueueThreadPlanForStepScripted(const char *script_class_name,
lldb::SBStructuredData &args_data,
SBError &error) {
LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
QueueThreadPlanForStepScripted,
(const char *, lldb::SBStructuredData &, lldb::SBError &),
script_class_name, args_data, error);
LLDB_INSTRUMENT_VA(this, script_class_name, args_data, error);
ThreadPlanSP thread_plan_sp(GetSP());
if (thread_plan_sp) {

23
lldb/source/API/SBTrace.cpp
View file

@ -6,8 +6,8 @@
//
//===----------------------------------------------------------------------===//
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/Target/Process.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/API/SBStructuredData.h"
#include "lldb/API/SBThread.h"
@ -20,20 +20,19 @@
using namespace lldb;
using namespace lldb_private;
SBTrace::SBTrace() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTrace); }
SBTrace::SBTrace() { LLDB_INSTRUMENT_VA(this); }
SBTrace::SBTrace(const lldb::TraceSP &trace_sp) : m_opaque_sp(trace_sp) {
LLDB_RECORD_CONSTRUCTOR(SBTrace, (const lldb::TraceSP &), trace_sp);
LLDB_INSTRUMENT_VA(this, trace_sp);
}
const char *SBTrace::GetStartConfigurationHelp() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTrace, GetStartConfigurationHelp);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp ? m_opaque_sp->GetStartConfigurationHelp() : nullptr;
}
SBError SBTrace::Start(const SBStructuredData &configuration) {
LLDB_RECORD_METHOD(SBError, SBTrace, Start, (const SBStructuredData &),
configuration);
LLDB_INSTRUMENT_VA(this, configuration);
SBError error;
if (!m_opaque_sp)
error.SetErrorString("error: invalid trace");
@ -45,9 +44,7 @@ SBError SBTrace::Start(const SBStructuredData &configuration) {
SBError SBTrace::Start(const SBThread &thread,
const SBStructuredData &configuration) {
LLDB_RECORD_METHOD(SBError, SBTrace, Start,
(const SBThread &, const SBStructuredData &), thread,
configuration);
LLDB_INSTRUMENT_VA(this, thread, configuration);
SBError error;
if (!m_opaque_sp)
@ -63,7 +60,7 @@ SBError SBTrace::Start(const SBThread &thread,
}
SBError SBTrace::Stop() {
LLDB_RECORD_METHOD_NO_ARGS(SBError, SBTrace, Stop);
LLDB_INSTRUMENT_VA(this);
SBError error;
if (!m_opaque_sp)
error.SetErrorString("error: invalid trace");
@ -73,7 +70,7 @@ SBError SBTrace::Stop() {
}
SBError SBTrace::Stop(const SBThread &thread) {
LLDB_RECORD_METHOD(SBError, SBTrace, Stop, (const SBThread &), thread);
LLDB_INSTRUMENT_VA(this, thread);
SBError error;
if (!m_opaque_sp)
error.SetErrorString("error: invalid trace");
@ -83,11 +80,11 @@ SBError SBTrace::Stop(const SBThread &thread) {
}
bool SBTrace::IsValid() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBTrace, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBTrace::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTrace, operator bool);
LLDB_INSTRUMENT_VA(this);
return (bool)m_opaque_sp;
}

202
lldb/source/API/SBType.cpp
View file

@ -7,7 +7,6 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBType.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBDefines.h"
#include "lldb/API/SBModule.h"
#include "lldb/API/SBStream.h"
@ -17,6 +16,7 @@
#include "lldb/Symbol/Type.h"
#include "lldb/Symbol/TypeSystem.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/Stream.h"
#include "llvm/ADT/APSInt.h"
@ -26,7 +26,7 @@
using namespace lldb;
using namespace lldb_private;
SBType::SBType() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBType); }
SBType::SBType() { LLDB_INSTRUMENT_VA(this); }
SBType::SBType(const CompilerType &type)
: m_opaque_sp(new TypeImpl(
@ -39,7 +39,7 @@ SBType::SBType(const lldb::TypeImplSP &type_impl_sp)
: m_opaque_sp(type_impl_sp) {}
SBType::SBType(const SBType &rhs) {
LLDB_RECORD_CONSTRUCTOR(SBType, (const lldb::SBType &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
@ -51,7 +51,7 @@ SBType::SBType(const SBType &rhs) {
//{}
//
bool SBType::operator==(SBType &rhs) {
LLDB_RECORD_METHOD(bool, SBType, operator==,(lldb::SBType &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (!IsValid())
return !rhs.IsValid();
@ -63,7 +63,7 @@ bool SBType::operator==(SBType &rhs) {
}
bool SBType::operator!=(SBType &rhs) {
LLDB_RECORD_METHOD(bool, SBType, operator!=,(lldb::SBType &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (!IsValid())
return rhs.IsValid();
@ -81,8 +81,7 @@ void SBType::SetSP(const lldb::TypeImplSP &type_impl_sp) {
}
SBType &SBType::operator=(const SBType &rhs) {
LLDB_RECORD_METHOD(lldb::SBType &, SBType, operator=,(const lldb::SBType &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
@ -107,11 +106,11 @@ const TypeImpl &SBType::ref() const {
}
bool SBType::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBType, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBType::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBType, operator bool);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp.get() == nullptr)
return false;
@ -120,7 +119,7 @@ SBType::operator bool() const {
}
uint64_t SBType::GetByteSize() {
LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBType, GetByteSize);
LLDB_INSTRUMENT_VA(this);
if (IsValid())
if (llvm::Optional<uint64_t> size =
@ -130,7 +129,7 @@ uint64_t SBType::GetByteSize() {
}
bool SBType::IsPointerType() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsPointerType);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return false;
@ -138,7 +137,7 @@ bool SBType::IsPointerType() {
}
bool SBType::IsArrayType() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsArrayType);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return false;
@ -147,7 +146,7 @@ bool SBType::IsArrayType() {
}
bool SBType::IsVectorType() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsVectorType);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return false;
@ -155,7 +154,7 @@ bool SBType::IsVectorType() {
}
bool SBType::IsReferenceType() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsReferenceType);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return false;
@ -163,7 +162,7 @@ bool SBType::IsReferenceType() {
}
SBType SBType::GetPointerType() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetPointerType);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return SBType();
@ -172,7 +171,7 @@ SBType SBType::GetPointerType() {
}
SBType SBType::GetPointeeType() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetPointeeType);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return SBType();
@ -180,7 +179,7 @@ SBType SBType::GetPointeeType() {
}
SBType SBType::GetReferenceType() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetReferenceType);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return SBType();
@ -188,7 +187,7 @@ SBType SBType::GetReferenceType() {
}
SBType SBType::GetTypedefedType() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetTypedefedType);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return SBType();
@ -196,7 +195,7 @@ SBType SBType::GetTypedefedType() {
}
SBType SBType::GetDereferencedType() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetDereferencedType);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return SBType();
@ -204,7 +203,7 @@ SBType SBType::GetDereferencedType() {
}
SBType SBType::GetArrayElementType() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetArrayElementType);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return SBType();
@ -213,7 +212,7 @@ SBType SBType::GetArrayElementType() {
}
SBType SBType::GetArrayType(uint64_t size) {
LLDB_RECORD_METHOD(lldb::SBType, SBType, GetArrayType, (uint64_t), size);
LLDB_INSTRUMENT_VA(this, size);
if (!IsValid())
return SBType();
@ -222,7 +221,7 @@ SBType SBType::GetArrayType(uint64_t size) {
}
SBType SBType::GetVectorElementType() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetVectorElementType);
LLDB_INSTRUMENT_VA(this);
SBType type_sb;
if (IsValid()) {
@ -235,7 +234,7 @@ SBType SBType::GetVectorElementType() {
}
bool SBType::IsFunctionType() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsFunctionType);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return false;
@ -243,7 +242,7 @@ bool SBType::IsFunctionType() {
}
bool SBType::IsPolymorphicClass() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsPolymorphicClass);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return false;
@ -251,7 +250,7 @@ bool SBType::IsPolymorphicClass() {
}
bool SBType::IsTypedefType() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsTypedefType);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return false;
@ -259,7 +258,7 @@ bool SBType::IsTypedefType() {
}
bool SBType::IsAnonymousType() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsAnonymousType);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return false;
@ -267,7 +266,7 @@ bool SBType::IsAnonymousType() {
}
bool SBType::IsScopedEnumerationType() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsScopedEnumerationType);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return false;
@ -275,7 +274,7 @@ bool SBType::IsScopedEnumerationType() {
}
lldb::SBType SBType::GetFunctionReturnType() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetFunctionReturnType);
LLDB_INSTRUMENT_VA(this);
if (IsValid()) {
CompilerType return_type(
@ -287,8 +286,7 @@ lldb::SBType SBType::GetFunctionReturnType() {
}
lldb::SBTypeList SBType::GetFunctionArgumentTypes() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeList, SBType,
GetFunctionArgumentTypes);
LLDB_INSTRUMENT_VA(this);
SBTypeList sb_type_list;
if (IsValid()) {
@ -302,7 +300,7 @@ lldb::SBTypeList SBType::GetFunctionArgumentTypes() {
}
uint32_t SBType::GetNumberOfMemberFunctions() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfMemberFunctions);
LLDB_INSTRUMENT_VA(this);
if (IsValid()) {
return m_opaque_sp->GetCompilerType(true).GetNumMemberFunctions();
@ -311,8 +309,7 @@ uint32_t SBType::GetNumberOfMemberFunctions() {
}
lldb::SBTypeMemberFunction SBType::GetMemberFunctionAtIndex(uint32_t idx) {
LLDB_RECORD_METHOD(lldb::SBTypeMemberFunction, SBType,
GetMemberFunctionAtIndex, (uint32_t), idx);
LLDB_INSTRUMENT_VA(this, idx);
SBTypeMemberFunction sb_func_type;
if (IsValid())
@ -322,7 +319,7 @@ lldb::SBTypeMemberFunction SBType::GetMemberFunctionAtIndex(uint32_t idx) {
}
lldb::SBType SBType::GetUnqualifiedType() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetUnqualifiedType);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return SBType();
@ -330,7 +327,7 @@ lldb::SBType SBType::GetUnqualifiedType() {
}
lldb::SBType SBType::GetCanonicalType() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetCanonicalType);
LLDB_INSTRUMENT_VA(this);
if (IsValid())
return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetCanonicalType())));
@ -338,7 +335,7 @@ lldb::SBType SBType::GetCanonicalType() {
}
SBType SBType::GetEnumerationIntegerType() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetEnumerationIntegerType);
LLDB_INSTRUMENT_VA(this);
if (IsValid()) {
return SBType(
@ -348,7 +345,7 @@ SBType SBType::GetEnumerationIntegerType() {
}
lldb::BasicType SBType::GetBasicType() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::BasicType, SBType, GetBasicType);
LLDB_INSTRUMENT_VA(this);
if (IsValid())
return m_opaque_sp->GetCompilerType(false).GetBasicTypeEnumeration();
@ -356,8 +353,7 @@ lldb::BasicType SBType::GetBasicType() {
}
SBType SBType::GetBasicType(lldb::BasicType basic_type) {
LLDB_RECORD_METHOD(lldb::SBType, SBType, GetBasicType, (lldb::BasicType),
basic_type);
LLDB_INSTRUMENT_VA(this, basic_type);
if (IsValid() && m_opaque_sp->IsValid())
return SBType(
@ -366,7 +362,7 @@ SBType SBType::GetBasicType(lldb::BasicType basic_type) {
}
uint32_t SBType::GetNumberOfDirectBaseClasses() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfDirectBaseClasses);
LLDB_INSTRUMENT_VA(this);
if (IsValid())
return m_opaque_sp->GetCompilerType(true).GetNumDirectBaseClasses();
@ -374,7 +370,7 @@ uint32_t SBType::GetNumberOfDirectBaseClasses() {
}
uint32_t SBType::GetNumberOfVirtualBaseClasses() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfVirtualBaseClasses);
LLDB_INSTRUMENT_VA(this);
if (IsValid())
return m_opaque_sp->GetCompilerType(true).GetNumVirtualBaseClasses();
@ -382,7 +378,7 @@ uint32_t SBType::GetNumberOfVirtualBaseClasses() {
}
uint32_t SBType::GetNumberOfFields() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfFields);
LLDB_INSTRUMENT_VA(this);
if (IsValid())
return m_opaque_sp->GetCompilerType(true).GetNumFields();
@ -391,9 +387,7 @@ uint32_t SBType::GetNumberOfFields() {
bool SBType::GetDescription(SBStream &description,
lldb::DescriptionLevel description_level) {
LLDB_RECORD_METHOD(bool, SBType, GetDescription,
(lldb::SBStream &, lldb::DescriptionLevel), description,
description_level);
LLDB_INSTRUMENT_VA(this, description, description_level);
Stream &strm = description.ref();
@ -406,8 +400,7 @@ bool SBType::GetDescription(SBStream &description,
}
SBTypeMember SBType::GetDirectBaseClassAtIndex(uint32_t idx) {
LLDB_RECORD_METHOD(lldb::SBTypeMember, SBType, GetDirectBaseClassAtIndex,
(uint32_t), idx);
LLDB_INSTRUMENT_VA(this, idx);
SBTypeMember sb_type_member;
if (IsValid()) {
@ -423,8 +416,7 @@ SBTypeMember SBType::GetDirectBaseClassAtIndex(uint32_t idx) {
}
SBTypeMember SBType::GetVirtualBaseClassAtIndex(uint32_t idx) {
LLDB_RECORD_METHOD(lldb::SBTypeMember, SBType, GetVirtualBaseClassAtIndex,
(uint32_t), idx);
LLDB_INSTRUMENT_VA(this, idx);
SBTypeMember sb_type_member;
if (IsValid()) {
@ -440,8 +432,7 @@ SBTypeMember SBType::GetVirtualBaseClassAtIndex(uint32_t idx) {
}
SBTypeEnumMemberList SBType::GetEnumMembers() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeEnumMemberList, SBType,
GetEnumMembers);
LLDB_INSTRUMENT_VA(this);
SBTypeEnumMemberList sb_enum_member_list;
if (IsValid()) {
@ -463,8 +454,7 @@ SBTypeEnumMemberList SBType::GetEnumMembers() {
}
SBTypeMember SBType::GetFieldAtIndex(uint32_t idx) {
LLDB_RECORD_METHOD(lldb::SBTypeMember, SBType, GetFieldAtIndex, (uint32_t),
idx);
LLDB_INSTRUMENT_VA(this, idx);
SBTypeMember sb_type_member;
if (IsValid()) {
@ -490,7 +480,7 @@ SBTypeMember SBType::GetFieldAtIndex(uint32_t idx) {
}
bool SBType::IsTypeComplete() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsTypeComplete);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return false;
@ -498,7 +488,7 @@ bool SBType::IsTypeComplete() {
}
uint32_t SBType::GetTypeFlags() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetTypeFlags);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return 0;
@ -506,7 +496,7 @@ uint32_t SBType::GetTypeFlags() {
}
lldb::SBModule SBType::GetModule() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBModule, SBType, GetModule);
LLDB_INSTRUMENT_VA(this);
lldb::SBModule sb_module;
if (!IsValid())
@ -517,7 +507,7 @@ lldb::SBModule SBType::GetModule() {
}
const char *SBType::GetName() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBType, GetName);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return "";
@ -525,7 +515,7 @@ const char *SBType::GetName() {
}
const char *SBType::GetDisplayTypeName() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBType, GetDisplayTypeName);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return "";
@ -533,7 +523,7 @@ const char *SBType::GetDisplayTypeName() {
}
lldb::TypeClass SBType::GetTypeClass() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::TypeClass, SBType, GetTypeClass);
LLDB_INSTRUMENT_VA(this);
if (IsValid())
return m_opaque_sp->GetCompilerType(true).GetTypeClass();
@ -541,7 +531,7 @@ lldb::TypeClass SBType::GetTypeClass() {
}
uint32_t SBType::GetNumberOfTemplateArguments() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfTemplateArguments);
LLDB_INSTRUMENT_VA(this);
if (IsValid())
return m_opaque_sp->GetCompilerType(false).GetNumTemplateArguments();
@ -549,8 +539,7 @@ uint32_t SBType::GetNumberOfTemplateArguments() {
}
lldb::SBType SBType::GetTemplateArgumentType(uint32_t idx) {
LLDB_RECORD_METHOD(lldb::SBType, SBType, GetTemplateArgumentType, (uint32_t),
idx);
LLDB_INSTRUMENT_VA(this, idx);
if (!IsValid())
return SBType();
@ -574,8 +563,7 @@ lldb::SBType SBType::GetTemplateArgumentType(uint32_t idx) {
}
lldb::TemplateArgumentKind SBType::GetTemplateArgumentKind(uint32_t idx) {
LLDB_RECORD_METHOD(lldb::TemplateArgumentKind, SBType,
GetTemplateArgumentKind, (uint32_t), idx);
LLDB_INSTRUMENT_VA(this, idx);
if (IsValid())
return m_opaque_sp->GetCompilerType(false).GetTemplateArgumentKind(idx);
@ -583,12 +571,12 @@ lldb::TemplateArgumentKind SBType::GetTemplateArgumentKind(uint32_t idx) {
}
SBTypeList::SBTypeList() : m_opaque_up(new TypeListImpl()) {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeList);
LLDB_INSTRUMENT_VA(this);
}
SBTypeList::SBTypeList(const SBTypeList &rhs)
: m_opaque_up(new TypeListImpl()) {
LLDB_RECORD_CONSTRUCTOR(SBTypeList, (const lldb::SBTypeList &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
for (uint32_t i = 0, rhs_size = const_cast<SBTypeList &>(rhs).GetSize();
i < rhs_size; i++)
@ -596,18 +584,17 @@ SBTypeList::SBTypeList(const SBTypeList &rhs)
}
bool SBTypeList::IsValid() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeList, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBTypeList::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeList, operator bool);
LLDB_INSTRUMENT_VA(this);
return (m_opaque_up != nullptr);
}
SBTypeList &SBTypeList::operator=(const SBTypeList &rhs) {
LLDB_RECORD_METHOD(lldb::SBTypeList &,
SBTypeList, operator=,(const lldb::SBTypeList &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
m_opaque_up = std::make_unique<TypeListImpl>();
@ -619,15 +606,14 @@ SBTypeList &SBTypeList::operator=(const SBTypeList &rhs) {
}
void SBTypeList::Append(SBType type) {
LLDB_RECORD_METHOD(void, SBTypeList, Append, (lldb::SBType), type);
LLDB_INSTRUMENT_VA(this, type);
if (type.IsValid())
m_opaque_up->Append(type.m_opaque_sp);
}
SBType SBTypeList::GetTypeAtIndex(uint32_t index) {
LLDB_RECORD_METHOD(lldb::SBType, SBTypeList, GetTypeAtIndex, (uint32_t),
index);
LLDB_INSTRUMENT_VA(this, index);
if (m_opaque_up)
return SBType(m_opaque_up->GetTypeAtIndex(index));
@ -635,19 +621,19 @@ SBType SBTypeList::GetTypeAtIndex(uint32_t index) {
}
uint32_t SBTypeList::GetSize() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeList, GetSize);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetSize();
}
SBTypeList::~SBTypeList() = default;
SBTypeMember::SBTypeMember() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeMember); }
SBTypeMember::SBTypeMember() { LLDB_INSTRUMENT_VA(this); }
SBTypeMember::~SBTypeMember() = default;
SBTypeMember::SBTypeMember(const SBTypeMember &rhs) {
LLDB_RECORD_CONSTRUCTOR(SBTypeMember, (const lldb::SBTypeMember &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
if (rhs.IsValid())
@ -656,8 +642,7 @@ SBTypeMember::SBTypeMember(const SBTypeMember &rhs) {
}
lldb::SBTypeMember &SBTypeMember::operator=(const lldb::SBTypeMember &rhs) {
LLDB_RECORD_METHOD(lldb::SBTypeMember &,
SBTypeMember, operator=,(const lldb::SBTypeMember &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
if (rhs.IsValid())
@ -667,17 +652,17 @@ lldb::SBTypeMember &SBTypeMember::operator=(const lldb::SBTypeMember &rhs) {
}
bool SBTypeMember::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMember, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBTypeMember::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMember, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up.get();
}
const char *SBTypeMember::GetName() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMember, GetName);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_up)
return m_opaque_up->GetName().GetCString();
@ -685,7 +670,7 @@ const char *SBTypeMember::GetName() {
}
SBType SBTypeMember::GetType() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeMember, GetType);
LLDB_INSTRUMENT_VA(this);
SBType sb_type;
if (m_opaque_up) {
@ -695,7 +680,7 @@ SBType SBTypeMember::GetType() {
}
uint64_t SBTypeMember::GetOffsetInBytes() {
LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBTypeMember, GetOffsetInBytes);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_up)
return m_opaque_up->GetBitOffset() / 8u;
@ -703,7 +688,7 @@ uint64_t SBTypeMember::GetOffsetInBytes() {
}
uint64_t SBTypeMember::GetOffsetInBits() {
LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBTypeMember, GetOffsetInBits);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_up)
return m_opaque_up->GetBitOffset();
@ -711,7 +696,7 @@ uint64_t SBTypeMember::GetOffsetInBits() {
}
bool SBTypeMember::IsBitfield() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeMember, IsBitfield);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_up)
return m_opaque_up->GetIsBitfield();
@ -719,7 +704,7 @@ bool SBTypeMember::IsBitfield() {
}
uint32_t SBTypeMember::GetBitfieldSizeInBits() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeMember, GetBitfieldSizeInBits);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_up)
return m_opaque_up->GetBitfieldBitSize();
@ -728,9 +713,7 @@ uint32_t SBTypeMember::GetBitfieldSizeInBits() {
bool SBTypeMember::GetDescription(lldb::SBStream &description,
lldb::DescriptionLevel description_level) {
LLDB_RECORD_METHOD(bool, SBTypeMember, GetDescription,
(lldb::SBStream &, lldb::DescriptionLevel), description,
description_level);
LLDB_INSTRUMENT_VA(this, description, description_level);
Stream &strm = description.ref();
@ -771,24 +754,18 @@ TypeMemberImpl &SBTypeMember::ref() {
const TypeMemberImpl &SBTypeMember::ref() const { return *m_opaque_up; }
SBTypeMemberFunction::SBTypeMemberFunction() {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeMemberFunction);
}
SBTypeMemberFunction::SBTypeMemberFunction() { LLDB_INSTRUMENT_VA(this); }
SBTypeMemberFunction::~SBTypeMemberFunction() = default;
SBTypeMemberFunction::SBTypeMemberFunction(const SBTypeMemberFunction &rhs)
: m_opaque_sp(rhs.m_opaque_sp) {
LLDB_RECORD_CONSTRUCTOR(SBTypeMemberFunction,
(const lldb::SBTypeMemberFunction &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
}
lldb::SBTypeMemberFunction &SBTypeMemberFunction::
operator=(const lldb::SBTypeMemberFunction &rhs) {
LLDB_RECORD_METHOD(
lldb::SBTypeMemberFunction &,
SBTypeMemberFunction, operator=,(const lldb::SBTypeMemberFunction &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_sp = rhs.m_opaque_sp;
@ -796,17 +773,17 @@ operator=(const lldb::SBTypeMemberFunction &rhs) {
}
bool SBTypeMemberFunction::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMemberFunction, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBTypeMemberFunction::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMemberFunction, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp.get();
}
const char *SBTypeMemberFunction::GetName() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMemberFunction, GetName);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp)
return m_opaque_sp->GetName().GetCString();
@ -814,8 +791,7 @@ const char *SBTypeMemberFunction::GetName() {
}
const char *SBTypeMemberFunction::GetDemangledName() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMemberFunction,
GetDemangledName);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp) {
ConstString mangled_str = m_opaque_sp->GetMangledName();
@ -828,8 +804,7 @@ const char *SBTypeMemberFunction::GetDemangledName() {
}
const char *SBTypeMemberFunction::GetMangledName() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMemberFunction,
GetMangledName);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp)
return m_opaque_sp->GetMangledName().GetCString();
@ -837,7 +812,7 @@ const char *SBTypeMemberFunction::GetMangledName() {
}
SBType SBTypeMemberFunction::GetType() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeMemberFunction, GetType);
LLDB_INSTRUMENT_VA(this);
SBType sb_type;
if (m_opaque_sp) {
@ -847,7 +822,7 @@ SBType SBTypeMemberFunction::GetType() {
}
lldb::SBType SBTypeMemberFunction::GetReturnType() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeMemberFunction, GetReturnType);
LLDB_INSTRUMENT_VA(this);
SBType sb_type;
if (m_opaque_sp) {
@ -857,8 +832,7 @@ lldb::SBType SBTypeMemberFunction::GetReturnType() {
}
uint32_t SBTypeMemberFunction::GetNumberOfArguments() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeMemberFunction,
GetNumberOfArguments);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp)
return m_opaque_sp->GetNumArguments();
@ -866,8 +840,7 @@ uint32_t SBTypeMemberFunction::GetNumberOfArguments() {
}
lldb::SBType SBTypeMemberFunction::GetArgumentTypeAtIndex(uint32_t i) {
LLDB_RECORD_METHOD(lldb::SBType, SBTypeMemberFunction, GetArgumentTypeAtIndex,
(uint32_t), i);
LLDB_INSTRUMENT_VA(this, i);
SBType sb_type;
if (m_opaque_sp) {
@ -878,8 +851,7 @@ lldb::SBType SBTypeMemberFunction::GetArgumentTypeAtIndex(uint32_t i) {
}
lldb::MemberFunctionKind SBTypeMemberFunction::GetKind() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::MemberFunctionKind, SBTypeMemberFunction,
GetKind);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp)
return m_opaque_sp->GetKind();
@ -888,9 +860,7 @@ lldb::MemberFunctionKind SBTypeMemberFunction::GetKind() {
bool SBTypeMemberFunction::GetDescription(
lldb::SBStream &description, lldb::DescriptionLevel description_level) {
LLDB_RECORD_METHOD(bool, SBTypeMemberFunction, GetDescription,
(lldb::SBStream &, lldb::DescriptionLevel), description,
description_level);
LLDB_INSTRUMENT_VA(this, description, description_level);
Stream &strm = description.ref();

113
lldb/source/API/SBTypeCategory.cpp
View file

@ -7,7 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBTypeCategory.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBTypeFilter.h"
@ -26,9 +26,7 @@ using namespace lldb_private;
typedef std::pair<lldb::TypeCategoryImplSP, user_id_t> ImplType;
SBTypeCategory::SBTypeCategory() {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeCategory);
}
SBTypeCategory::SBTypeCategory() { LLDB_INSTRUMENT_VA(this); }
SBTypeCategory::SBTypeCategory(const char *name) {
DataVisualization::Categories::GetCategory(ConstString(name), m_opaque_sp);
@ -36,23 +34,23 @@ SBTypeCategory::SBTypeCategory(const char *name) {
SBTypeCategory::SBTypeCategory(const lldb::SBTypeCategory &rhs)
: m_opaque_sp(rhs.m_opaque_sp) {
LLDB_RECORD_CONSTRUCTOR(SBTypeCategory, (const lldb::SBTypeCategory &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
}
SBTypeCategory::~SBTypeCategory() = default;
bool SBTypeCategory::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeCategory, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBTypeCategory::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeCategory, operator bool);
LLDB_INSTRUMENT_VA(this);
return (m_opaque_sp.get() != nullptr);
}
bool SBTypeCategory::GetEnabled() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeCategory, GetEnabled);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return false;
@ -60,7 +58,7 @@ bool SBTypeCategory::GetEnabled() {
}
void SBTypeCategory::SetEnabled(bool enabled) {
LLDB_RECORD_METHOD(void, SBTypeCategory, SetEnabled, (bool), enabled);
LLDB_INSTRUMENT_VA(this, enabled);
if (!IsValid())
return;
@ -71,7 +69,7 @@ void SBTypeCategory::SetEnabled(bool enabled) {
}
const char *SBTypeCategory::GetName() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeCategory, GetName);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return nullptr;
@ -79,8 +77,7 @@ const char *SBTypeCategory::GetName() {
}
lldb::LanguageType SBTypeCategory::GetLanguageAtIndex(uint32_t idx) {
LLDB_RECORD_METHOD(lldb::LanguageType, SBTypeCategory, GetLanguageAtIndex,
(uint32_t), idx);
LLDB_INSTRUMENT_VA(this, idx);
if (IsValid())
return m_opaque_sp->GetLanguageAtIndex(idx);
@ -88,7 +85,7 @@ lldb::LanguageType SBTypeCategory::GetLanguageAtIndex(uint32_t idx) {
}
uint32_t SBTypeCategory::GetNumLanguages() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumLanguages);
LLDB_INSTRUMENT_VA(this);
if (IsValid())
return m_opaque_sp->GetNumLanguages();
@ -96,15 +93,14 @@ uint32_t SBTypeCategory::GetNumLanguages() {
}
void SBTypeCategory::AddLanguage(lldb::LanguageType language) {
LLDB_RECORD_METHOD(void, SBTypeCategory, AddLanguage, (lldb::LanguageType),
language);
LLDB_INSTRUMENT_VA(this, language);
if (IsValid())
m_opaque_sp->AddLanguage(language);
}
uint32_t SBTypeCategory::GetNumFormats() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumFormats);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return 0;
@ -114,7 +110,7 @@ uint32_t SBTypeCategory::GetNumFormats() {
}
uint32_t SBTypeCategory::GetNumSummaries() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumSummaries);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return 0;
@ -123,7 +119,7 @@ uint32_t SBTypeCategory::GetNumSummaries() {
}
uint32_t SBTypeCategory::GetNumFilters() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumFilters);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return 0;
@ -132,7 +128,7 @@ uint32_t SBTypeCategory::GetNumFilters() {
}
uint32_t SBTypeCategory::GetNumSynthetics() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumSynthetics);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return 0;
@ -142,8 +138,7 @@ uint32_t SBTypeCategory::GetNumSynthetics() {
lldb::SBTypeNameSpecifier
SBTypeCategory::GetTypeNameSpecifierForFilterAtIndex(uint32_t index) {
LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
GetTypeNameSpecifierForFilterAtIndex, (uint32_t), index);
LLDB_INSTRUMENT_VA(this, index);
if (!IsValid())
return SBTypeNameSpecifier();
@ -153,8 +148,7 @@ SBTypeCategory::GetTypeNameSpecifierForFilterAtIndex(uint32_t index) {
lldb::SBTypeNameSpecifier
SBTypeCategory::GetTypeNameSpecifierForFormatAtIndex(uint32_t index) {
LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
GetTypeNameSpecifierForFormatAtIndex, (uint32_t), index);
LLDB_INSTRUMENT_VA(this, index);
if (!IsValid())
return SBTypeNameSpecifier();
@ -164,8 +158,7 @@ SBTypeCategory::GetTypeNameSpecifierForFormatAtIndex(uint32_t index) {
lldb::SBTypeNameSpecifier
SBTypeCategory::GetTypeNameSpecifierForSummaryAtIndex(uint32_t index) {
LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
GetTypeNameSpecifierForSummaryAtIndex, (uint32_t), index);
LLDB_INSTRUMENT_VA(this, index);
if (!IsValid())
return SBTypeNameSpecifier();
@ -175,9 +168,7 @@ SBTypeCategory::GetTypeNameSpecifierForSummaryAtIndex(uint32_t index) {
lldb::SBTypeNameSpecifier
SBTypeCategory::GetTypeNameSpecifierForSyntheticAtIndex(uint32_t index) {
LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
GetTypeNameSpecifierForSyntheticAtIndex, (uint32_t),
index);
LLDB_INSTRUMENT_VA(this, index);
if (!IsValid())
return SBTypeNameSpecifier();
@ -186,8 +177,7 @@ SBTypeCategory::GetTypeNameSpecifierForSyntheticAtIndex(uint32_t index) {
}
SBTypeFilter SBTypeCategory::GetFilterForType(SBTypeNameSpecifier spec) {
LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterForType,
(lldb::SBTypeNameSpecifier), spec);
LLDB_INSTRUMENT_VA(this, spec);
if (!IsValid())
return SBTypeFilter();
@ -213,8 +203,7 @@ SBTypeFilter SBTypeCategory::GetFilterForType(SBTypeNameSpecifier spec) {
return lldb::SBTypeFilter(filter_sp);
}
SBTypeFormat SBTypeCategory::GetFormatForType(SBTypeNameSpecifier spec) {
LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatForType,
(lldb::SBTypeNameSpecifier), spec);
LLDB_INSTRUMENT_VA(this, spec);
if (!IsValid())
return SBTypeFormat();
@ -238,8 +227,7 @@ SBTypeFormat SBTypeCategory::GetFormatForType(SBTypeNameSpecifier spec) {
}
SBTypeSummary SBTypeCategory::GetSummaryForType(SBTypeNameSpecifier spec) {
LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryForType,
(lldb::SBTypeNameSpecifier), spec);
LLDB_INSTRUMENT_VA(this, spec);
if (!IsValid())
return SBTypeSummary();
@ -263,8 +251,7 @@ SBTypeSummary SBTypeCategory::GetSummaryForType(SBTypeNameSpecifier spec) {
}
SBTypeSynthetic SBTypeCategory::GetSyntheticForType(SBTypeNameSpecifier spec) {
LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBTypeCategory, GetSyntheticForType,
(lldb::SBTypeNameSpecifier), spec);
LLDB_INSTRUMENT_VA(this, spec);
if (!IsValid())
return SBTypeSynthetic();
@ -291,8 +278,7 @@ SBTypeSynthetic SBTypeCategory::GetSyntheticForType(SBTypeNameSpecifier spec) {
}
SBTypeFilter SBTypeCategory::GetFilterAtIndex(uint32_t index) {
LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterAtIndex,
(uint32_t), index);
LLDB_INSTRUMENT_VA(this, index);
if (!IsValid())
return SBTypeFilter();
@ -309,8 +295,7 @@ SBTypeFilter SBTypeCategory::GetFilterAtIndex(uint32_t index) {
}
SBTypeFormat SBTypeCategory::GetFormatAtIndex(uint32_t index) {
LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatAtIndex,
(uint32_t), index);
LLDB_INSTRUMENT_VA(this, index);
if (!IsValid())
return SBTypeFormat();
@ -318,8 +303,7 @@ SBTypeFormat SBTypeCategory::GetFormatAtIndex(uint32_t index) {
}
SBTypeSummary SBTypeCategory::GetSummaryAtIndex(uint32_t index) {
LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryAtIndex,
(uint32_t), index);
LLDB_INSTRUMENT_VA(this, index);
if (!IsValid())
return SBTypeSummary();
@ -327,8 +311,7 @@ SBTypeSummary SBTypeCategory::GetSummaryAtIndex(uint32_t index) {
}
SBTypeSynthetic SBTypeCategory::GetSyntheticAtIndex(uint32_t index) {
LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBTypeCategory, GetSyntheticAtIndex,
(uint32_t), index);
LLDB_INSTRUMENT_VA(this, index);
if (!IsValid())
return SBTypeSynthetic();
@ -346,9 +329,7 @@ SBTypeSynthetic SBTypeCategory::GetSyntheticAtIndex(uint32_t index) {
bool SBTypeCategory::AddTypeFormat(SBTypeNameSpecifier type_name,
SBTypeFormat format) {
LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeFormat,
(lldb::SBTypeNameSpecifier, lldb::SBTypeFormat), type_name,
format);
LLDB_INSTRUMENT_VA(this, type_name, format);
if (!IsValid())
return false;
@ -370,8 +351,7 @@ bool SBTypeCategory::AddTypeFormat(SBTypeNameSpecifier type_name,
}
bool SBTypeCategory::DeleteTypeFormat(SBTypeNameSpecifier type_name) {
LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeFormat,
(lldb::SBTypeNameSpecifier), type_name);
LLDB_INSTRUMENT_VA(this, type_name);
if (!IsValid())
return false;
@ -389,9 +369,7 @@ bool SBTypeCategory::DeleteTypeFormat(SBTypeNameSpecifier type_name) {
bool SBTypeCategory::AddTypeSummary(SBTypeNameSpecifier type_name,
SBTypeSummary summary) {
LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeSummary,
(lldb::SBTypeNameSpecifier, lldb::SBTypeSummary),
type_name, summary);
LLDB_INSTRUMENT_VA(this, type_name, summary);
if (!IsValid())
return false;
@ -447,8 +425,7 @@ bool SBTypeCategory::AddTypeSummary(SBTypeNameSpecifier type_name,
}
bool SBTypeCategory::DeleteTypeSummary(SBTypeNameSpecifier type_name) {
LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeSummary,
(lldb::SBTypeNameSpecifier), type_name);
LLDB_INSTRUMENT_VA(this, type_name);
if (!IsValid())
return false;
@ -466,9 +443,7 @@ bool SBTypeCategory::DeleteTypeSummary(SBTypeNameSpecifier type_name) {
bool SBTypeCategory::AddTypeFilter(SBTypeNameSpecifier type_name,
SBTypeFilter filter) {
LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeFilter,
(lldb::SBTypeNameSpecifier, lldb::SBTypeFilter), type_name,
filter);
LLDB_INSTRUMENT_VA(this, type_name, filter);
if (!IsValid())
return false;
@ -490,8 +465,7 @@ bool SBTypeCategory::AddTypeFilter(SBTypeNameSpecifier type_name,
}
bool SBTypeCategory::DeleteTypeFilter(SBTypeNameSpecifier type_name) {
LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeFilter,
(lldb::SBTypeNameSpecifier), type_name);
LLDB_INSTRUMENT_VA(this, type_name);
if (!IsValid())
return false;
@ -509,9 +483,7 @@ bool SBTypeCategory::DeleteTypeFilter(SBTypeNameSpecifier type_name) {
bool SBTypeCategory::AddTypeSynthetic(SBTypeNameSpecifier type_name,
SBTypeSynthetic synth) {
LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeSynthetic,
(lldb::SBTypeNameSpecifier, lldb::SBTypeSynthetic),
type_name, synth);
LLDB_INSTRUMENT_VA(this, type_name, synth);
if (!IsValid())
return false;
@ -567,8 +539,7 @@ bool SBTypeCategory::AddTypeSynthetic(SBTypeNameSpecifier type_name,
}
bool SBTypeCategory::DeleteTypeSynthetic(SBTypeNameSpecifier type_name) {
LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeSynthetic,
(lldb::SBTypeNameSpecifier), type_name);
LLDB_INSTRUMENT_VA(this, type_name);
if (!IsValid())
return false;
@ -586,9 +557,7 @@ bool SBTypeCategory::DeleteTypeSynthetic(SBTypeNameSpecifier type_name) {
bool SBTypeCategory::GetDescription(lldb::SBStream &description,
lldb::DescriptionLevel description_level) {
LLDB_RECORD_METHOD(bool, SBTypeCategory, GetDescription,
(lldb::SBStream &, lldb::DescriptionLevel), description,
description_level);
LLDB_INSTRUMENT_VA(this, description, description_level);
if (!IsValid())
return false;
@ -598,9 +567,7 @@ bool SBTypeCategory::GetDescription(lldb::SBStream &description,
lldb::SBTypeCategory &SBTypeCategory::
operator=(const lldb::SBTypeCategory &rhs) {
LLDB_RECORD_METHOD(lldb::SBTypeCategory &,
SBTypeCategory, operator=,(const lldb::SBTypeCategory &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
@ -609,8 +576,7 @@ operator=(const lldb::SBTypeCategory &rhs) {
}
bool SBTypeCategory::operator==(lldb::SBTypeCategory &rhs) {
LLDB_RECORD_METHOD(bool, SBTypeCategory, operator==,(lldb::SBTypeCategory &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (!IsValid())
return !rhs.IsValid();
@ -619,8 +585,7 @@ bool SBTypeCategory::operator==(lldb::SBTypeCategory &rhs) {
}
bool SBTypeCategory::operator!=(lldb::SBTypeCategory &rhs) {
LLDB_RECORD_METHOD(bool, SBTypeCategory, operator!=,(lldb::SBTypeCategory &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (!IsValid())
return rhs.IsValid();

51
lldb/source/API/SBTypeEnumMember.cpp
View file

@ -7,13 +7,13 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBTypeEnumMember.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/API/SBDefines.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBType.h"
#include "lldb/Symbol/CompilerType.h"
#include "lldb/Symbol/Type.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/Stream.h"
#include <memory>
@ -21,9 +21,7 @@
using namespace lldb;
using namespace lldb_private;
SBTypeEnumMember::SBTypeEnumMember() {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeEnumMember);
}
SBTypeEnumMember::SBTypeEnumMember() { LLDB_INSTRUMENT_VA(this); }
SBTypeEnumMember::~SBTypeEnumMember() = default;
@ -32,16 +30,13 @@ SBTypeEnumMember::SBTypeEnumMember(
: m_opaque_sp(enum_member_sp) {}
SBTypeEnumMember::SBTypeEnumMember(const SBTypeEnumMember &rhs) {
LLDB_RECORD_CONSTRUCTOR(SBTypeEnumMember, (const lldb::SBTypeEnumMember &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_sp = clone(rhs.m_opaque_sp);
}
SBTypeEnumMember &SBTypeEnumMember::operator=(const SBTypeEnumMember &rhs) {
LLDB_RECORD_METHOD(
SBTypeEnumMember &,
SBTypeEnumMember, operator=,(const lldb::SBTypeEnumMember &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_sp = clone(rhs.m_opaque_sp);
@ -49,17 +44,17 @@ SBTypeEnumMember &SBTypeEnumMember::operator=(const SBTypeEnumMember &rhs) {
}
bool SBTypeEnumMember::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMember, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBTypeEnumMember::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMember, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp.get();
}
const char *SBTypeEnumMember::GetName() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeEnumMember, GetName);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp.get())
return m_opaque_sp->GetName().GetCString();
@ -67,7 +62,7 @@ const char *SBTypeEnumMember::GetName() {
}
int64_t SBTypeEnumMember::GetValueAsSigned() {
LLDB_RECORD_METHOD_NO_ARGS(int64_t, SBTypeEnumMember, GetValueAsSigned);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp.get())
return m_opaque_sp->GetValueAsSigned();
@ -75,7 +70,7 @@ int64_t SBTypeEnumMember::GetValueAsSigned() {
}
uint64_t SBTypeEnumMember::GetValueAsUnsigned() {
LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBTypeEnumMember, GetValueAsUnsigned);
LLDB_INSTRUMENT_VA(this);
if (m_opaque_sp.get())
return m_opaque_sp->GetValueAsUnsigned();
@ -83,7 +78,7 @@ uint64_t SBTypeEnumMember::GetValueAsUnsigned() {
}
SBType SBTypeEnumMember::GetType() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeEnumMember, GetType);
LLDB_INSTRUMENT_VA(this);
SBType sb_type;
if (m_opaque_sp.get()) {
@ -108,13 +103,12 @@ const TypeEnumMemberImpl &SBTypeEnumMember::ref() const {
SBTypeEnumMemberList::SBTypeEnumMemberList()
: m_opaque_up(new TypeEnumMemberListImpl()) {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeEnumMemberList);
LLDB_INSTRUMENT_VA(this);
}
SBTypeEnumMemberList::SBTypeEnumMemberList(const SBTypeEnumMemberList &rhs)
: m_opaque_up(new TypeEnumMemberListImpl()) {
LLDB_RECORD_CONSTRUCTOR(SBTypeEnumMemberList,
(const lldb::SBTypeEnumMemberList &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
for (uint32_t i = 0,
rhs_size = const_cast<SBTypeEnumMemberList &>(rhs).GetSize();
@ -123,21 +117,18 @@ SBTypeEnumMemberList::SBTypeEnumMemberList(const SBTypeEnumMemberList &rhs)
}
bool SBTypeEnumMemberList::IsValid() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeEnumMemberList, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBTypeEnumMemberList::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMemberList, operator bool);
LLDB_INSTRUMENT_VA(this);
return (m_opaque_up != nullptr);
}
SBTypeEnumMemberList &SBTypeEnumMemberList::
operator=(const SBTypeEnumMemberList &rhs) {
LLDB_RECORD_METHOD(
lldb::SBTypeEnumMemberList &,
SBTypeEnumMemberList, operator=,(const lldb::SBTypeEnumMemberList &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
m_opaque_up = std::make_unique<TypeEnumMemberListImpl>();
@ -151,8 +142,7 @@ operator=(const SBTypeEnumMemberList &rhs) {
}
void SBTypeEnumMemberList::Append(SBTypeEnumMember enum_member) {
LLDB_RECORD_METHOD(void, SBTypeEnumMemberList, Append,
(lldb::SBTypeEnumMember), enum_member);
LLDB_INSTRUMENT_VA(this, enum_member);
if (enum_member.IsValid())
m_opaque_up->Append(enum_member.m_opaque_sp);
@ -160,8 +150,7 @@ void SBTypeEnumMemberList::Append(SBTypeEnumMember enum_member) {
SBTypeEnumMember
SBTypeEnumMemberList::GetTypeEnumMemberAtIndex(uint32_t index) {
LLDB_RECORD_METHOD(lldb::SBTypeEnumMember, SBTypeEnumMemberList,
GetTypeEnumMemberAtIndex, (uint32_t), index);
LLDB_INSTRUMENT_VA(this, index);
if (m_opaque_up)
return SBTypeEnumMember(m_opaque_up->GetTypeEnumMemberAtIndex(index));
@ -169,7 +158,7 @@ SBTypeEnumMemberList::GetTypeEnumMemberAtIndex(uint32_t index) {
}
uint32_t SBTypeEnumMemberList::GetSize() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeEnumMemberList, GetSize);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetSize();
}
@ -178,9 +167,7 @@ SBTypeEnumMemberList::~SBTypeEnumMemberList() = default;
bool SBTypeEnumMember::GetDescription(
lldb::SBStream &description, lldb::DescriptionLevel description_level) {
LLDB_RECORD_METHOD(bool, SBTypeEnumMember, GetDescription,
(lldb::SBStream &, lldb::DescriptionLevel), description,
description_level);
LLDB_INSTRUMENT_VA(this, description, description_level);
Stream &strm = description.ref();

46
lldb/source/API/SBTypeFilter.cpp
View file

@ -7,7 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBTypeFilter.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/API/SBStream.h"
@ -16,32 +16,32 @@
using namespace lldb;
using namespace lldb_private;
SBTypeFilter::SBTypeFilter() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeFilter); }
SBTypeFilter::SBTypeFilter() { LLDB_INSTRUMENT_VA(this); }
SBTypeFilter::SBTypeFilter(uint32_t options)
: m_opaque_sp(TypeFilterImplSP(new TypeFilterImpl(options))) {
LLDB_RECORD_CONSTRUCTOR(SBTypeFilter, (uint32_t), options);
LLDB_INSTRUMENT_VA(this, options);
}
SBTypeFilter::SBTypeFilter(const lldb::SBTypeFilter &rhs)
: m_opaque_sp(rhs.m_opaque_sp) {
LLDB_RECORD_CONSTRUCTOR(SBTypeFilter, (const lldb::SBTypeFilter &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
}
SBTypeFilter::~SBTypeFilter() = default;
bool SBTypeFilter::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFilter, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBTypeFilter::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFilter, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp.get() != nullptr;
}
uint32_t SBTypeFilter::GetOptions() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeFilter, GetOptions);
LLDB_INSTRUMENT_VA(this);
if (IsValid())
return m_opaque_sp->GetOptions();
@ -49,7 +49,7 @@ uint32_t SBTypeFilter::GetOptions() {
}
void SBTypeFilter::SetOptions(uint32_t value) {
LLDB_RECORD_METHOD(void, SBTypeFilter, SetOptions, (uint32_t), value);
LLDB_INSTRUMENT_VA(this, value);
if (CopyOnWrite_Impl())
m_opaque_sp->SetOptions(value);
@ -57,9 +57,7 @@ void SBTypeFilter::SetOptions(uint32_t value) {
bool SBTypeFilter::GetDescription(lldb::SBStream &description,
lldb::DescriptionLevel description_level) {
LLDB_RECORD_METHOD(bool, SBTypeFilter, GetDescription,
(lldb::SBStream &, lldb::DescriptionLevel), description,
description_level);
LLDB_INSTRUMENT_VA(this, description, description_level);
if (!IsValid())
return false;
@ -70,15 +68,14 @@ bool SBTypeFilter::GetDescription(lldb::SBStream &description,
}
void SBTypeFilter::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBTypeFilter, Clear);
LLDB_INSTRUMENT_VA(this);
if (CopyOnWrite_Impl())
m_opaque_sp->Clear();
}
uint32_t SBTypeFilter::GetNumberOfExpressionPaths() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeFilter,
GetNumberOfExpressionPaths);
LLDB_INSTRUMENT_VA(this);
if (IsValid())
return m_opaque_sp->GetCount();
@ -86,8 +83,7 @@ uint32_t SBTypeFilter::GetNumberOfExpressionPaths() {
}
const char *SBTypeFilter::GetExpressionPathAtIndex(uint32_t i) {
LLDB_RECORD_METHOD(const char *, SBTypeFilter, GetExpressionPathAtIndex,
(uint32_t), i);
LLDB_INSTRUMENT_VA(this, i);
if (IsValid()) {
const char *item = m_opaque_sp->GetExpressionPathAtIndex(i);
@ -99,8 +95,7 @@ const char *SBTypeFilter::GetExpressionPathAtIndex(uint32_t i) {
}
bool SBTypeFilter::ReplaceExpressionPathAtIndex(uint32_t i, const char *item) {
LLDB_RECORD_METHOD(bool, SBTypeFilter, ReplaceExpressionPathAtIndex,
(uint32_t, const char *), i, item);
LLDB_INSTRUMENT_VA(this, i, item);
if (CopyOnWrite_Impl())
return m_opaque_sp->SetExpressionPathAtIndex(i, item);
@ -109,16 +104,14 @@ bool SBTypeFilter::ReplaceExpressionPathAtIndex(uint32_t i, const char *item) {
}
void SBTypeFilter::AppendExpressionPath(const char *item) {
LLDB_RECORD_METHOD(void, SBTypeFilter, AppendExpressionPath, (const char *),
item);
LLDB_INSTRUMENT_VA(this, item);
if (CopyOnWrite_Impl())
m_opaque_sp->AddExpressionPath(item);
}
lldb::SBTypeFilter &SBTypeFilter::operator=(const lldb::SBTypeFilter &rhs) {
LLDB_RECORD_METHOD(lldb::SBTypeFilter &,
SBTypeFilter, operator=,(const lldb::SBTypeFilter &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
@ -127,8 +120,7 @@ lldb::SBTypeFilter &SBTypeFilter::operator=(const lldb::SBTypeFilter &rhs) {
}
bool SBTypeFilter::operator==(lldb::SBTypeFilter &rhs) {
LLDB_RECORD_METHOD(bool, SBTypeFilter, operator==,(lldb::SBTypeFilter &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (!IsValid())
return !rhs.IsValid();
@ -137,8 +129,7 @@ bool SBTypeFilter::operator==(lldb::SBTypeFilter &rhs) {
}
bool SBTypeFilter::IsEqualTo(lldb::SBTypeFilter &rhs) {
LLDB_RECORD_METHOD(bool, SBTypeFilter, IsEqualTo, (lldb::SBTypeFilter &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (!IsValid())
return !rhs.IsValid();
@ -155,8 +146,7 @@ bool SBTypeFilter::IsEqualTo(lldb::SBTypeFilter &rhs) {
}
bool SBTypeFilter::operator!=(lldb::SBTypeFilter &rhs) {
LLDB_RECORD_METHOD(bool, SBTypeFilter, operator!=,(lldb::SBTypeFilter &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (!IsValid())
return !rhs.IsValid();

44
lldb/source/API/SBTypeFormat.cpp
View file

@ -7,7 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBTypeFormat.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/API/SBStream.h"
@ -16,41 +16,39 @@
using namespace lldb;
using namespace lldb_private;
SBTypeFormat::SBTypeFormat() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeFormat); }
SBTypeFormat::SBTypeFormat() { LLDB_INSTRUMENT_VA(this); }
SBTypeFormat::SBTypeFormat(lldb::Format format, uint32_t options)
: m_opaque_sp(
TypeFormatImplSP(new TypeFormatImpl_Format(format, options))) {
LLDB_RECORD_CONSTRUCTOR(SBTypeFormat, (lldb::Format, uint32_t), format,
options);
LLDB_INSTRUMENT_VA(this, format, options);
}
SBTypeFormat::SBTypeFormat(const char *type, uint32_t options)
: m_opaque_sp(TypeFormatImplSP(new TypeFormatImpl_EnumType(
ConstString(type ? type : ""), options))) {
LLDB_RECORD_CONSTRUCTOR(SBTypeFormat, (const char *, uint32_t), type,
options);
LLDB_INSTRUMENT_VA(this, type, options);
}
SBTypeFormat::SBTypeFormat(const lldb::SBTypeFormat &rhs)
: m_opaque_sp(rhs.m_opaque_sp) {
LLDB_RECORD_CONSTRUCTOR(SBTypeFormat, (const lldb::SBTypeFormat &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
}
SBTypeFormat::~SBTypeFormat() = default;
bool SBTypeFormat::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFormat, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBTypeFormat::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFormat, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp.get() != nullptr;
}
lldb::Format SBTypeFormat::GetFormat() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::Format, SBTypeFormat, GetFormat);
LLDB_INSTRUMENT_VA(this);
if (IsValid() && m_opaque_sp->GetType() == TypeFormatImpl::Type::eTypeFormat)
return ((TypeFormatImpl_Format *)m_opaque_sp.get())->GetFormat();
@ -58,7 +56,7 @@ lldb::Format SBTypeFormat::GetFormat() {
}
const char *SBTypeFormat::GetTypeName() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeFormat, GetTypeName);
LLDB_INSTRUMENT_VA(this);
if (IsValid() && m_opaque_sp->GetType() == TypeFormatImpl::Type::eTypeEnum)
return ((TypeFormatImpl_EnumType *)m_opaque_sp.get())
@ -68,7 +66,7 @@ const char *SBTypeFormat::GetTypeName() {
}
uint32_t SBTypeFormat::GetOptions() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeFormat, GetOptions);
LLDB_INSTRUMENT_VA(this);
if (IsValid())
return m_opaque_sp->GetOptions();
@ -76,14 +74,14 @@ uint32_t SBTypeFormat::GetOptions() {
}
void SBTypeFormat::SetFormat(lldb::Format fmt) {
LLDB_RECORD_METHOD(void, SBTypeFormat, SetFormat, (lldb::Format), fmt);
LLDB_INSTRUMENT_VA(this, fmt);
if (CopyOnWrite_Impl(Type::eTypeFormat))
((TypeFormatImpl_Format *)m_opaque_sp.get())->SetFormat(fmt);
}
void SBTypeFormat::SetTypeName(const char *type) {
LLDB_RECORD_METHOD(void, SBTypeFormat, SetTypeName, (const char *), type);
LLDB_INSTRUMENT_VA(this, type);
if (CopyOnWrite_Impl(Type::eTypeEnum))
((TypeFormatImpl_EnumType *)m_opaque_sp.get())
@ -91,7 +89,7 @@ void SBTypeFormat::SetTypeName(const char *type) {
}
void SBTypeFormat::SetOptions(uint32_t value) {
LLDB_RECORD_METHOD(void, SBTypeFormat, SetOptions, (uint32_t), value);
LLDB_INSTRUMENT_VA(this, value);
if (CopyOnWrite_Impl(Type::eTypeKeepSame))
m_opaque_sp->SetOptions(value);
@ -99,9 +97,7 @@ void SBTypeFormat::SetOptions(uint32_t value) {
bool SBTypeFormat::GetDescription(lldb::SBStream &description,
lldb::DescriptionLevel description_level) {
LLDB_RECORD_METHOD(bool, SBTypeFormat, GetDescription,
(lldb::SBStream &, lldb::DescriptionLevel), description,
description_level);
LLDB_INSTRUMENT_VA(this, description, description_level);
if (!IsValid())
return false;
@ -112,8 +108,7 @@ bool SBTypeFormat::GetDescription(lldb::SBStream &description,
}
lldb::SBTypeFormat &SBTypeFormat::operator=(const lldb::SBTypeFormat &rhs) {
LLDB_RECORD_METHOD(lldb::SBTypeFormat &,
SBTypeFormat, operator=,(const lldb::SBTypeFormat &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
@ -122,8 +117,7 @@ lldb::SBTypeFormat &SBTypeFormat::operator=(const lldb::SBTypeFormat &rhs) {
}
bool SBTypeFormat::operator==(lldb::SBTypeFormat &rhs) {
LLDB_RECORD_METHOD(bool, SBTypeFormat, operator==,(lldb::SBTypeFormat &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (!IsValid())
return !rhs.IsValid();
@ -131,8 +125,7 @@ bool SBTypeFormat::operator==(lldb::SBTypeFormat &rhs) {
}
bool SBTypeFormat::IsEqualTo(lldb::SBTypeFormat &rhs) {
LLDB_RECORD_METHOD(bool, SBTypeFormat, IsEqualTo, (lldb::SBTypeFormat &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (!IsValid())
return !rhs.IsValid();
@ -144,8 +137,7 @@ bool SBTypeFormat::IsEqualTo(lldb::SBTypeFormat &rhs) {
}
bool SBTypeFormat::operator!=(lldb::SBTypeFormat &rhs) {
LLDB_RECORD_METHOD(bool, SBTypeFormat, operator!=,(lldb::SBTypeFormat &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (!IsValid())
return !rhs.IsValid();

41
lldb/source/API/SBTypeNameSpecifier.cpp
View file

@ -7,7 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBTypeNameSpecifier.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBType.h"
@ -17,21 +17,18 @@
using namespace lldb;
using namespace lldb_private;
SBTypeNameSpecifier::SBTypeNameSpecifier() {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeNameSpecifier);
}
SBTypeNameSpecifier::SBTypeNameSpecifier() { LLDB_INSTRUMENT_VA(this); }
SBTypeNameSpecifier::SBTypeNameSpecifier(const char *name, bool is_regex)
: m_opaque_sp(new TypeNameSpecifierImpl(name, is_regex)) {
LLDB_RECORD_CONSTRUCTOR(SBTypeNameSpecifier, (const char *, bool), name,
is_regex);
LLDB_INSTRUMENT_VA(this, name, is_regex);
if (name == nullptr || (*name) == 0)
m_opaque_sp.reset();
}
SBTypeNameSpecifier::SBTypeNameSpecifier(SBType type) {
LLDB_RECORD_CONSTRUCTOR(SBTypeNameSpecifier, (lldb::SBType), type);
LLDB_INSTRUMENT_VA(this, type);
if (type.IsValid())
m_opaque_sp = TypeNameSpecifierImplSP(
@ -40,24 +37,23 @@ SBTypeNameSpecifier::SBTypeNameSpecifier(SBType type) {
SBTypeNameSpecifier::SBTypeNameSpecifier(const lldb::SBTypeNameSpecifier &rhs)
: m_opaque_sp(rhs.m_opaque_sp) {
LLDB_RECORD_CONSTRUCTOR(SBTypeNameSpecifier,
(const lldb::SBTypeNameSpecifier &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
}
SBTypeNameSpecifier::~SBTypeNameSpecifier() = default;
bool SBTypeNameSpecifier::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeNameSpecifier, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBTypeNameSpecifier::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeNameSpecifier, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp.get() != nullptr;
}
const char *SBTypeNameSpecifier::GetName() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeNameSpecifier, GetName);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return nullptr;
@ -66,7 +62,7 @@ const char *SBTypeNameSpecifier::GetName() {
}
SBType SBTypeNameSpecifier::GetType() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeNameSpecifier, GetType);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return SBType();
@ -77,7 +73,7 @@ SBType SBTypeNameSpecifier::GetType() {
}
bool SBTypeNameSpecifier::IsRegex() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeNameSpecifier, IsRegex);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return false;
@ -87,9 +83,7 @@ bool SBTypeNameSpecifier::IsRegex() {
bool SBTypeNameSpecifier::GetDescription(
lldb::SBStream &description, lldb::DescriptionLevel description_level) {
LLDB_RECORD_METHOD(bool, SBTypeNameSpecifier, GetDescription,
(lldb::SBStream &, lldb::DescriptionLevel), description,
description_level);
LLDB_INSTRUMENT_VA(this, description, description_level);
if (!IsValid())
return false;
@ -100,9 +94,7 @@ bool SBTypeNameSpecifier::GetDescription(
lldb::SBTypeNameSpecifier &SBTypeNameSpecifier::
operator=(const lldb::SBTypeNameSpecifier &rhs) {
LLDB_RECORD_METHOD(
lldb::SBTypeNameSpecifier &,
SBTypeNameSpecifier, operator=,(const lldb::SBTypeNameSpecifier &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
@ -111,8 +103,7 @@ operator=(const lldb::SBTypeNameSpecifier &rhs) {
}
bool SBTypeNameSpecifier::operator==(lldb::SBTypeNameSpecifier &rhs) {
LLDB_RECORD_METHOD(
bool, SBTypeNameSpecifier, operator==,(lldb::SBTypeNameSpecifier &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (!IsValid())
return !rhs.IsValid();
@ -120,8 +111,7 @@ bool SBTypeNameSpecifier::operator==(lldb::SBTypeNameSpecifier &rhs) {
}
bool SBTypeNameSpecifier::IsEqualTo(lldb::SBTypeNameSpecifier &rhs) {
LLDB_RECORD_METHOD(bool, SBTypeNameSpecifier, IsEqualTo,
(lldb::SBTypeNameSpecifier &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (!IsValid())
return !rhs.IsValid();
@ -135,8 +125,7 @@ bool SBTypeNameSpecifier::IsEqualTo(lldb::SBTypeNameSpecifier &rhs) {
}
bool SBTypeNameSpecifier::operator!=(lldb::SBTypeNameSpecifier &rhs) {
LLDB_RECORD_METHOD(
bool, SBTypeNameSpecifier, operator!=,(lldb::SBTypeNameSpecifier &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (!IsValid())
return !rhs.IsValid();

95
lldb/source/API/SBTypeSummary.cpp
View file

@ -7,11 +7,11 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBTypeSummary.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "Utils.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBValue.h"
#include "lldb/DataFormatters/DataVisualization.h"
#include "lldb/Utility/Instrumentation.h"
#include "llvm/Support/Casting.h"
@ -19,15 +19,14 @@ using namespace lldb;
using namespace lldb_private;
SBTypeSummaryOptions::SBTypeSummaryOptions() {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeSummaryOptions);
LLDB_INSTRUMENT_VA(this);
m_opaque_up = std::make_unique<TypeSummaryOptions>();
}
SBTypeSummaryOptions::SBTypeSummaryOptions(
const lldb::SBTypeSummaryOptions &rhs) {
LLDB_RECORD_CONSTRUCTOR(SBTypeSummaryOptions,
(const lldb::SBTypeSummaryOptions &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_up = clone(rhs.m_opaque_up);
}
@ -35,18 +34,17 @@ SBTypeSummaryOptions::SBTypeSummaryOptions(
SBTypeSummaryOptions::~SBTypeSummaryOptions() = default;
bool SBTypeSummaryOptions::IsValid() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummaryOptions, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBTypeSummaryOptions::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSummaryOptions, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up.get();
}
lldb::LanguageType SBTypeSummaryOptions::GetLanguage() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::LanguageType, SBTypeSummaryOptions,
GetLanguage);
LLDB_INSTRUMENT_VA(this);
if (IsValid())
return m_opaque_up->GetLanguage();
@ -54,8 +52,7 @@ lldb::LanguageType SBTypeSummaryOptions::GetLanguage() {
}
lldb::TypeSummaryCapping SBTypeSummaryOptions::GetCapping() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::TypeSummaryCapping, SBTypeSummaryOptions,
GetCapping);
LLDB_INSTRUMENT_VA(this);
if (IsValid())
return m_opaque_up->GetCapping();
@ -63,16 +60,14 @@ lldb::TypeSummaryCapping SBTypeSummaryOptions::GetCapping() {
}
void SBTypeSummaryOptions::SetLanguage(lldb::LanguageType l) {
LLDB_RECORD_METHOD(void, SBTypeSummaryOptions, SetLanguage,
(lldb::LanguageType), l);
LLDB_INSTRUMENT_VA(this, l);
if (IsValid())
m_opaque_up->SetLanguage(l);
}
void SBTypeSummaryOptions::SetCapping(lldb::TypeSummaryCapping c) {
LLDB_RECORD_METHOD(void, SBTypeSummaryOptions, SetCapping,
(lldb::TypeSummaryCapping), c);
LLDB_INSTRUMENT_VA(this, c);
if (IsValid())
m_opaque_up->SetCapping(c);
@ -102,20 +97,14 @@ const lldb_private::TypeSummaryOptions &SBTypeSummaryOptions::ref() const {
SBTypeSummaryOptions::SBTypeSummaryOptions(
const lldb_private::TypeSummaryOptions &lldb_object)
: m_opaque_up(std::make_unique<TypeSummaryOptions>(lldb_object)) {
LLDB_RECORD_CONSTRUCTOR(SBTypeSummaryOptions,
(const lldb_private::TypeSummaryOptions &),
lldb_object);
LLDB_INSTRUMENT_VA(this, lldb_object);
}
SBTypeSummary::SBTypeSummary() {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeSummary);
}
SBTypeSummary::SBTypeSummary() { LLDB_INSTRUMENT_VA(this); }
SBTypeSummary SBTypeSummary::CreateWithSummaryString(const char *data,
uint32_t options) {
LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
CreateWithSummaryString, (const char *, uint32_t),
data, options);
LLDB_INSTRUMENT_VA(data, options);
if (!data || data[0] == 0)
return SBTypeSummary();
@ -126,9 +115,7 @@ SBTypeSummary SBTypeSummary::CreateWithSummaryString(const char *data,
SBTypeSummary SBTypeSummary::CreateWithFunctionName(const char *data,
uint32_t options) {
LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
CreateWithFunctionName, (const char *, uint32_t),
data, options);
LLDB_INSTRUMENT_VA(data, options);
if (!data || data[0] == 0)
return SBTypeSummary();
@ -139,9 +126,7 @@ SBTypeSummary SBTypeSummary::CreateWithFunctionName(const char *data,
SBTypeSummary SBTypeSummary::CreateWithScriptCode(const char *data,
uint32_t options) {
LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
CreateWithScriptCode, (const char *, uint32_t),
data, options);
LLDB_INSTRUMENT_VA(data, options);
if (!data || data[0] == 0)
return SBTypeSummary();
@ -153,10 +138,7 @@ SBTypeSummary SBTypeSummary::CreateWithScriptCode(const char *data,
SBTypeSummary SBTypeSummary::CreateWithCallback(FormatCallback cb,
uint32_t options,
const char *description) {
LLDB_RECORD_STATIC_METHOD(
lldb::SBTypeSummary, SBTypeSummary, CreateWithCallback,
(lldb::SBTypeSummary::FormatCallback, uint32_t, const char *), cb,
options, description);
LLDB_INSTRUMENT_VA(cb, options, description);
SBTypeSummary retval;
if (cb) {
@ -180,23 +162,23 @@ SBTypeSummary SBTypeSummary::CreateWithCallback(FormatCallback cb,
SBTypeSummary::SBTypeSummary(const lldb::SBTypeSummary &rhs)
: m_opaque_sp(rhs.m_opaque_sp) {
LLDB_RECORD_CONSTRUCTOR(SBTypeSummary, (const lldb::SBTypeSummary &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
}
SBTypeSummary::~SBTypeSummary() = default;
bool SBTypeSummary::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSummary, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBTypeSummary::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSummary, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp.get() != nullptr;
}
bool SBTypeSummary::IsFunctionCode() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummary, IsFunctionCode);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return false;
@ -209,7 +191,7 @@ bool SBTypeSummary::IsFunctionCode() {
}
bool SBTypeSummary::IsFunctionName() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummary, IsFunctionName);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return false;
@ -222,7 +204,7 @@ bool SBTypeSummary::IsFunctionName() {
}
bool SBTypeSummary::IsSummaryString() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummary, IsSummaryString);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return false;
@ -231,7 +213,7 @@ bool SBTypeSummary::IsSummaryString() {
}
const char *SBTypeSummary::GetData() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeSummary, GetData);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return nullptr;
@ -249,7 +231,7 @@ const char *SBTypeSummary::GetData() {
}
uint32_t SBTypeSummary::GetOptions() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeSummary, GetOptions);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return lldb::eTypeOptionNone;
@ -257,7 +239,7 @@ uint32_t SBTypeSummary::GetOptions() {
}
void SBTypeSummary::SetOptions(uint32_t value) {
LLDB_RECORD_METHOD(void, SBTypeSummary, SetOptions, (uint32_t), value);
LLDB_INSTRUMENT_VA(this, value);
if (!CopyOnWrite_Impl())
return;
@ -265,8 +247,7 @@ void SBTypeSummary::SetOptions(uint32_t value) {
}
void SBTypeSummary::SetSummaryString(const char *data) {
LLDB_RECORD_METHOD(void, SBTypeSummary, SetSummaryString, (const char *),
data);
LLDB_INSTRUMENT_VA(this, data);
if (!IsValid())
return;
@ -278,8 +259,7 @@ void SBTypeSummary::SetSummaryString(const char *data) {
}
void SBTypeSummary::SetFunctionName(const char *data) {
LLDB_RECORD_METHOD(void, SBTypeSummary, SetFunctionName, (const char *),
data);
LLDB_INSTRUMENT_VA(this, data);
if (!IsValid())
return;
@ -291,8 +271,7 @@ void SBTypeSummary::SetFunctionName(const char *data) {
}
void SBTypeSummary::SetFunctionCode(const char *data) {
LLDB_RECORD_METHOD(void, SBTypeSummary, SetFunctionCode, (const char *),
data);
LLDB_INSTRUMENT_VA(this, data);
if (!IsValid())
return;
@ -305,9 +284,7 @@ void SBTypeSummary::SetFunctionCode(const char *data) {
bool SBTypeSummary::GetDescription(lldb::SBStream &description,
lldb::DescriptionLevel description_level) {
LLDB_RECORD_METHOD(bool, SBTypeSummary, GetDescription,
(lldb::SBStream &, lldb::DescriptionLevel), description,
description_level);
LLDB_INSTRUMENT_VA(this, description, description_level);
if (!CopyOnWrite_Impl())
return false;
@ -318,8 +295,7 @@ bool SBTypeSummary::GetDescription(lldb::SBStream &description,
}
bool SBTypeSummary::DoesPrintValue(lldb::SBValue value) {
LLDB_RECORD_METHOD(bool, SBTypeSummary, DoesPrintValue, (lldb::SBValue),
value);
LLDB_INSTRUMENT_VA(this, value);
if (!IsValid())
return false;
@ -328,9 +304,7 @@ bool SBTypeSummary::DoesPrintValue(lldb::SBValue value) {
}
lldb::SBTypeSummary &SBTypeSummary::operator=(const lldb::SBTypeSummary &rhs) {
LLDB_RECORD_METHOD(lldb::SBTypeSummary &,
SBTypeSummary, operator=,(const lldb::SBTypeSummary &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
@ -339,8 +313,7 @@ lldb::SBTypeSummary &SBTypeSummary::operator=(const lldb::SBTypeSummary &rhs) {
}
bool SBTypeSummary::operator==(lldb::SBTypeSummary &rhs) {
LLDB_RECORD_METHOD(bool, SBTypeSummary, operator==,(lldb::SBTypeSummary &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (!IsValid())
return !rhs.IsValid();
@ -348,8 +321,7 @@ bool SBTypeSummary::operator==(lldb::SBTypeSummary &rhs) {
}
bool SBTypeSummary::IsEqualTo(lldb::SBTypeSummary &rhs) {
LLDB_RECORD_METHOD(bool, SBTypeSummary, IsEqualTo, (lldb::SBTypeSummary &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (IsValid()) {
// valid and invalid are different
@ -389,8 +361,7 @@ bool SBTypeSummary::IsEqualTo(lldb::SBTypeSummary &rhs) {
}
bool SBTypeSummary::operator!=(lldb::SBTypeSummary &rhs) {
LLDB_RECORD_METHOD(bool, SBTypeSummary, operator!=,(lldb::SBTypeSummary &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (!IsValid())
return !rhs.IsValid();

52
lldb/source/API/SBTypeSynthetic.cpp
View file

@ -7,7 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBTypeSynthetic.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/API/SBStream.h"
@ -16,15 +16,11 @@
using namespace lldb;
using namespace lldb_private;
SBTypeSynthetic::SBTypeSynthetic() {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeSynthetic);
}
SBTypeSynthetic::SBTypeSynthetic() { LLDB_INSTRUMENT_VA(this); }
SBTypeSynthetic SBTypeSynthetic::CreateWithClassName(const char *data,
uint32_t options) {
LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSynthetic, SBTypeSynthetic,
CreateWithClassName, (const char *, uint32_t), data,
options);
LLDB_INSTRUMENT_VA(data, options);
if (!data || data[0] == 0)
return SBTypeSynthetic();
@ -34,9 +30,7 @@ SBTypeSynthetic SBTypeSynthetic::CreateWithClassName(const char *data,
SBTypeSynthetic SBTypeSynthetic::CreateWithScriptCode(const char *data,
uint32_t options) {
LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSynthetic, SBTypeSynthetic,
CreateWithScriptCode, (const char *, uint32_t),
data, options);
LLDB_INSTRUMENT_VA(data, options);
if (!data || data[0] == 0)
return SBTypeSynthetic();
@ -46,24 +40,23 @@ SBTypeSynthetic SBTypeSynthetic::CreateWithScriptCode(const char *data,
SBTypeSynthetic::SBTypeSynthetic(const lldb::SBTypeSynthetic &rhs)
: m_opaque_sp(rhs.m_opaque_sp) {
LLDB_RECORD_CONSTRUCTOR(SBTypeSynthetic, (const lldb::SBTypeSynthetic &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
}
SBTypeSynthetic::~SBTypeSynthetic() = default;
bool SBTypeSynthetic::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSynthetic, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBTypeSynthetic::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSynthetic, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp.get() != nullptr;
}
bool SBTypeSynthetic::IsClassCode() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSynthetic, IsClassCode);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return false;
@ -72,7 +65,7 @@ bool SBTypeSynthetic::IsClassCode() {
}
bool SBTypeSynthetic::IsClassName() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSynthetic, IsClassName);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return false;
@ -80,7 +73,7 @@ bool SBTypeSynthetic::IsClassName() {
}
const char *SBTypeSynthetic::GetData() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeSynthetic, GetData);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return nullptr;
@ -91,21 +84,21 @@ const char *SBTypeSynthetic::GetData() {
}
void SBTypeSynthetic::SetClassName(const char *data) {
LLDB_RECORD_METHOD(void, SBTypeSynthetic, SetClassName, (const char *), data);
LLDB_INSTRUMENT_VA(this, data);
if (IsValid() && data && *data)
m_opaque_sp->SetPythonClassName(data);
}
void SBTypeSynthetic::SetClassCode(const char *data) {
LLDB_RECORD_METHOD(void, SBTypeSynthetic, SetClassCode, (const char *), data);
LLDB_INSTRUMENT_VA(this, data);
if (IsValid() && data && *data)
m_opaque_sp->SetPythonCode(data);
}
uint32_t SBTypeSynthetic::GetOptions() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeSynthetic, GetOptions);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return lldb::eTypeOptionNone;
@ -113,7 +106,7 @@ uint32_t SBTypeSynthetic::GetOptions() {
}
void SBTypeSynthetic::SetOptions(uint32_t value) {
LLDB_RECORD_METHOD(void, SBTypeSynthetic, SetOptions, (uint32_t), value);
LLDB_INSTRUMENT_VA(this, value);
if (!CopyOnWrite_Impl())
return;
@ -122,9 +115,7 @@ void SBTypeSynthetic::SetOptions(uint32_t value) {
bool SBTypeSynthetic::GetDescription(lldb::SBStream &description,
lldb::DescriptionLevel description_level) {
LLDB_RECORD_METHOD(bool, SBTypeSynthetic, GetDescription,
(lldb::SBStream &, lldb::DescriptionLevel), description,
description_level);
LLDB_INSTRUMENT_VA(this, description, description_level);
if (m_opaque_sp) {
description.Printf("%s\n", m_opaque_sp->GetDescription().c_str());
@ -135,9 +126,7 @@ bool SBTypeSynthetic::GetDescription(lldb::SBStream &description,
lldb::SBTypeSynthetic &SBTypeSynthetic::
operator=(const lldb::SBTypeSynthetic &rhs) {
LLDB_RECORD_METHOD(lldb::SBTypeSynthetic &,
SBTypeSynthetic, operator=,(const lldb::SBTypeSynthetic &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
@ -146,8 +135,7 @@ operator=(const lldb::SBTypeSynthetic &rhs) {
}
bool SBTypeSynthetic::operator==(lldb::SBTypeSynthetic &rhs) {
LLDB_RECORD_METHOD(
bool, SBTypeSynthetic, operator==,(lldb::SBTypeSynthetic &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (!IsValid())
return !rhs.IsValid();
@ -155,8 +143,7 @@ bool SBTypeSynthetic::operator==(lldb::SBTypeSynthetic &rhs) {
}
bool SBTypeSynthetic::IsEqualTo(lldb::SBTypeSynthetic &rhs) {
LLDB_RECORD_METHOD(bool, SBTypeSynthetic, IsEqualTo,
(lldb::SBTypeSynthetic &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (!IsValid())
return !rhs.IsValid();
@ -174,8 +161,7 @@ bool SBTypeSynthetic::IsEqualTo(lldb::SBTypeSynthetic &rhs) {
}
bool SBTypeSynthetic::operator!=(lldb::SBTypeSynthetic &rhs) {
LLDB_RECORD_METHOD(
bool, SBTypeSynthetic, operator!=,(lldb::SBTypeSynthetic &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (!IsValid())
return !rhs.IsValid();

47
lldb/source/API/SBUnixSignals.cpp
View file

@ -6,10 +6,10 @@
//
//===----------------------------------------------------------------------===//
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/Target/Platform.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/UnixSignals.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/lldb-defines.h"
#include "lldb/API/SBUnixSignals.h"
@ -17,13 +17,11 @@
using namespace lldb;
using namespace lldb_private;
SBUnixSignals::SBUnixSignals() {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBUnixSignals);
}
SBUnixSignals::SBUnixSignals() { LLDB_INSTRUMENT_VA(this); }
SBUnixSignals::SBUnixSignals(const SBUnixSignals &rhs)
: m_opaque_wp(rhs.m_opaque_wp) {
LLDB_RECORD_CONSTRUCTOR(SBUnixSignals, (const lldb::SBUnixSignals &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
}
SBUnixSignals::SBUnixSignals(ProcessSP &process_sp)
@ -33,9 +31,7 @@ SBUnixSignals::SBUnixSignals(PlatformSP &platform_sp)
: m_opaque_wp(platform_sp ? platform_sp->GetUnixSignals() : nullptr) {}
const SBUnixSignals &SBUnixSignals::operator=(const SBUnixSignals &rhs) {
LLDB_RECORD_METHOD(const lldb::SBUnixSignals &,
SBUnixSignals, operator=,(const lldb::SBUnixSignals &),
rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_wp = rhs.m_opaque_wp;
@ -51,24 +47,23 @@ void SBUnixSignals::SetSP(const UnixSignalsSP &signals_sp) {
}
void SBUnixSignals::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBUnixSignals, Clear);
LLDB_INSTRUMENT_VA(this);
m_opaque_wp.reset();
}
bool SBUnixSignals::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBUnixSignals, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBUnixSignals::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBUnixSignals, operator bool);
LLDB_INSTRUMENT_VA(this);
return static_cast<bool>(GetSP());
}
const char *SBUnixSignals::GetSignalAsCString(int32_t signo) const {
LLDB_RECORD_METHOD_CONST(const char *, SBUnixSignals, GetSignalAsCString,
(int32_t), signo);
LLDB_INSTRUMENT_VA(this, signo);
if (auto signals_sp = GetSP())
return signals_sp->GetSignalAsCString(signo);
@ -77,8 +72,7 @@ const char *SBUnixSignals::GetSignalAsCString(int32_t signo) const {
}
int32_t SBUnixSignals::GetSignalNumberFromName(const char *name) const {
LLDB_RECORD_METHOD_CONST(int32_t, SBUnixSignals, GetSignalNumberFromName,
(const char *), name);
LLDB_INSTRUMENT_VA(this, name);
if (auto signals_sp = GetSP())
return signals_sp->GetSignalNumberFromName(name);
@ -87,8 +81,7 @@ int32_t SBUnixSignals::GetSignalNumberFromName(const char *name) const {
}
bool SBUnixSignals::GetShouldSuppress(int32_t signo) const {
LLDB_RECORD_METHOD_CONST(bool, SBUnixSignals, GetShouldSuppress, (int32_t),
signo);
LLDB_INSTRUMENT_VA(this, signo);
if (auto signals_sp = GetSP())
return signals_sp->GetShouldSuppress(signo);
@ -97,8 +90,7 @@ bool SBUnixSignals::GetShouldSuppress(int32_t signo) const {
}
bool SBUnixSignals::SetShouldSuppress(int32_t signo, bool value) {
LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldSuppress, (int32_t, bool),
signo, value);
LLDB_INSTRUMENT_VA(this, signo, value);
auto signals_sp = GetSP();
@ -109,8 +101,7 @@ bool SBUnixSignals::SetShouldSuppress(int32_t signo, bool value) {
}
bool SBUnixSignals::GetShouldStop(int32_t signo) const {
LLDB_RECORD_METHOD_CONST(bool, SBUnixSignals, GetShouldStop, (int32_t),
signo);
LLDB_INSTRUMENT_VA(this, signo);
if (auto signals_sp = GetSP())
return signals_sp->GetShouldStop(signo);
@ -119,8 +110,7 @@ bool SBUnixSignals::GetShouldStop(int32_t signo) const {
}
bool SBUnixSignals::SetShouldStop(int32_t signo, bool value) {
LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldStop, (int32_t, bool), signo,
value);
LLDB_INSTRUMENT_VA(this, signo, value);
auto signals_sp = GetSP();
@ -131,8 +121,7 @@ bool SBUnixSignals::SetShouldStop(int32_t signo, bool value) {
}
bool SBUnixSignals::GetShouldNotify(int32_t signo) const {
LLDB_RECORD_METHOD_CONST(bool, SBUnixSignals, GetShouldNotify, (int32_t),
signo);
LLDB_INSTRUMENT_VA(this, signo);
if (auto signals_sp = GetSP())
return signals_sp->GetShouldNotify(signo);
@ -141,8 +130,7 @@ bool SBUnixSignals::GetShouldNotify(int32_t signo) const {
}
bool SBUnixSignals::SetShouldNotify(int32_t signo, bool value) {
LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldNotify, (int32_t, bool),
signo, value);
LLDB_INSTRUMENT_VA(this, signo, value);
auto signals_sp = GetSP();
@ -153,7 +141,7 @@ bool SBUnixSignals::SetShouldNotify(int32_t signo, bool value) {
}
int32_t SBUnixSignals::GetNumSignals() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(int32_t, SBUnixSignals, GetNumSignals);
LLDB_INSTRUMENT_VA(this);
if (auto signals_sp = GetSP())
return signals_sp->GetNumSignals();
@ -162,8 +150,7 @@ int32_t SBUnixSignals::GetNumSignals() const {
}
int32_t SBUnixSignals::GetSignalAtIndex(int32_t index) const {
LLDB_RECORD_METHOD_CONST(int32_t, SBUnixSignals, GetSignalAtIndex, (int32_t),
index);
LLDB_INSTRUMENT_VA(this, index);
if (auto signals_sp = GetSP())
return signals_sp->GetSignalAtIndex(index);

221
lldb/source/API/SBValue.cpp
View file

@ -7,7 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBValue.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/API/SBDeclaration.h"
#include "lldb/API/SBStream.h"
@ -215,23 +215,22 @@ private:
Status m_lock_error;
};
SBValue::SBValue() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBValue); }
SBValue::SBValue() { LLDB_INSTRUMENT_VA(this); }
SBValue::SBValue(const lldb::ValueObjectSP &value_sp) {
LLDB_RECORD_CONSTRUCTOR(SBValue, (const lldb::ValueObjectSP &), value_sp);
LLDB_INSTRUMENT_VA(this, value_sp);
SetSP(value_sp);
}
SBValue::SBValue(const SBValue &rhs) {
LLDB_RECORD_CONSTRUCTOR(SBValue, (const lldb::SBValue &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
SetSP(rhs.m_opaque_sp);
}
SBValue &SBValue::operator=(const SBValue &rhs) {
LLDB_RECORD_METHOD(lldb::SBValue &,
SBValue, operator=,(const lldb::SBValue &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
SetSP(rhs.m_opaque_sp);
@ -242,11 +241,11 @@ SBValue &SBValue::operator=(const SBValue &rhs) {
SBValue::~SBValue() = default;
bool SBValue::IsValid() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBValue::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBValue, operator bool);
LLDB_INSTRUMENT_VA(this);
// If this function ever changes to anything that does more than just check
// if the opaque shared pointer is non NULL, then we need to update all "if
@ -256,13 +255,13 @@ SBValue::operator bool() const {
}
void SBValue::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBValue, Clear);
LLDB_INSTRUMENT_VA(this);
m_opaque_sp.reset();
}
SBError SBValue::GetError() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBValue, GetError);
LLDB_INSTRUMENT_VA(this);
SBError sb_error;
@ -278,7 +277,7 @@ SBError SBValue::GetError() {
}
user_id_t SBValue::GetID() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::user_id_t, SBValue, GetID);
LLDB_INSTRUMENT_VA(this);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@ -288,7 +287,7 @@ user_id_t SBValue::GetID() {
}
const char *SBValue::GetName() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetName);
LLDB_INSTRUMENT_VA(this);
const char *name = nullptr;
ValueLocker locker;
@ -300,7 +299,7 @@ const char *SBValue::GetName() {
}
const char *SBValue::GetTypeName() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetTypeName);
LLDB_INSTRUMENT_VA(this);
const char *name = nullptr;
ValueLocker locker;
@ -313,7 +312,7 @@ const char *SBValue::GetTypeName() {
}
const char *SBValue::GetDisplayTypeName() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetDisplayTypeName);
LLDB_INSTRUMENT_VA(this);
const char *name = nullptr;
ValueLocker locker;
@ -326,7 +325,7 @@ const char *SBValue::GetDisplayTypeName() {
}
size_t SBValue::GetByteSize() {
LLDB_RECORD_METHOD_NO_ARGS(size_t, SBValue, GetByteSize);
LLDB_INSTRUMENT_VA(this);
size_t result = 0;
@ -340,7 +339,7 @@ size_t SBValue::GetByteSize() {
}
bool SBValue::IsInScope() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsInScope);
LLDB_INSTRUMENT_VA(this);
bool result = false;
@ -354,7 +353,7 @@ bool SBValue::IsInScope() {
}
const char *SBValue::GetValue() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetValue);
LLDB_INSTRUMENT_VA(this);
const char *cstr = nullptr;
ValueLocker locker;
@ -367,7 +366,7 @@ const char *SBValue::GetValue() {
}
ValueType SBValue::GetValueType() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::ValueType, SBValue, GetValueType);
LLDB_INSTRUMENT_VA(this);
ValueType result = eValueTypeInvalid;
ValueLocker locker;
@ -379,7 +378,7 @@ ValueType SBValue::GetValueType() {
}
const char *SBValue::GetObjectDescription() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetObjectDescription);
LLDB_INSTRUMENT_VA(this);
const char *cstr = nullptr;
ValueLocker locker;
@ -392,7 +391,7 @@ const char *SBValue::GetObjectDescription() {
}
SBType SBValue::GetType() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBValue, GetType);
LLDB_INSTRUMENT_VA(this);
SBType sb_type;
ValueLocker locker;
@ -407,7 +406,7 @@ SBType SBValue::GetType() {
}
bool SBValue::GetValueDidChange() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, GetValueDidChange);
LLDB_INSTRUMENT_VA(this);
bool result = false;
ValueLocker locker;
@ -421,7 +420,7 @@ bool SBValue::GetValueDidChange() {
}
const char *SBValue::GetSummary() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetSummary);
LLDB_INSTRUMENT_VA(this);
const char *cstr = nullptr;
ValueLocker locker;
@ -435,9 +434,7 @@ const char *SBValue::GetSummary() {
const char *SBValue::GetSummary(lldb::SBStream &stream,
lldb::SBTypeSummaryOptions &options) {
LLDB_RECORD_METHOD(const char *, SBValue, GetSummary,
(lldb::SBStream &, lldb::SBTypeSummaryOptions &), stream,
options);
LLDB_INSTRUMENT_VA(this, stream, options);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@ -451,7 +448,7 @@ const char *SBValue::GetSummary(lldb::SBStream &stream,
}
const char *SBValue::GetLocation() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetLocation);
LLDB_INSTRUMENT_VA(this);
const char *cstr = nullptr;
ValueLocker locker;
@ -464,16 +461,14 @@ const char *SBValue::GetLocation() {
// Deprecated - use the one that takes an lldb::SBError
bool SBValue::SetValueFromCString(const char *value_str) {
LLDB_RECORD_METHOD(bool, SBValue, SetValueFromCString, (const char *),
value_str);
LLDB_INSTRUMENT_VA(this, value_str);
lldb::SBError dummy;
return SetValueFromCString(value_str, dummy);
}
bool SBValue::SetValueFromCString(const char *value_str, lldb::SBError &error) {
LLDB_RECORD_METHOD(bool, SBValue, SetValueFromCString,
(const char *, lldb::SBError &), value_str, error);
LLDB_INSTRUMENT_VA(this, value_str, error);
bool success = false;
ValueLocker locker;
@ -488,7 +483,7 @@ bool SBValue::SetValueFromCString(const char *value_str, lldb::SBError &error) {
}
lldb::SBTypeFormat SBValue::GetTypeFormat() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeFormat, SBValue, GetTypeFormat);
LLDB_INSTRUMENT_VA(this);
lldb::SBTypeFormat format;
ValueLocker locker;
@ -504,7 +499,7 @@ lldb::SBTypeFormat SBValue::GetTypeFormat() {
}
lldb::SBTypeSummary SBValue::GetTypeSummary() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeSummary, SBValue, GetTypeSummary);
LLDB_INSTRUMENT_VA(this);
lldb::SBTypeSummary summary;
ValueLocker locker;
@ -520,7 +515,7 @@ lldb::SBTypeSummary SBValue::GetTypeSummary() {
}
lldb::SBTypeFilter SBValue::GetTypeFilter() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeFilter, SBValue, GetTypeFilter);
LLDB_INSTRUMENT_VA(this);
lldb::SBTypeFilter filter;
ValueLocker locker;
@ -540,7 +535,7 @@ lldb::SBTypeFilter SBValue::GetTypeFilter() {
}
lldb::SBTypeSynthetic SBValue::GetTypeSynthetic() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeSynthetic, SBValue, GetTypeSynthetic);
LLDB_INSTRUMENT_VA(this);
lldb::SBTypeSynthetic synthetic;
ValueLocker locker;
@ -561,9 +556,7 @@ lldb::SBTypeSynthetic SBValue::GetTypeSynthetic() {
lldb::SBValue SBValue::CreateChildAtOffset(const char *name, uint32_t offset,
SBType type) {
LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateChildAtOffset,
(const char *, uint32_t, lldb::SBType), name, offset,
type);
LLDB_INSTRUMENT_VA(this, name, offset, type);
lldb::SBValue sb_value;
ValueLocker locker;
@ -581,7 +574,7 @@ lldb::SBValue SBValue::CreateChildAtOffset(const char *name, uint32_t offset,
}
lldb::SBValue SBValue::Cast(SBType type) {
LLDB_RECORD_METHOD(lldb::SBValue, SBValue, Cast, (lldb::SBType), type);
LLDB_INSTRUMENT_VA(this, type);
lldb::SBValue sb_value;
ValueLocker locker;
@ -595,8 +588,7 @@ lldb::SBValue SBValue::Cast(SBType type) {
lldb::SBValue SBValue::CreateValueFromExpression(const char *name,
const char *expression) {
LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateValueFromExpression,
(const char *, const char *), name, expression);
LLDB_INSTRUMENT_VA(this, name, expression);
SBExpressionOptions options;
options.ref().SetKeepInMemory(true);
@ -606,9 +598,7 @@ lldb::SBValue SBValue::CreateValueFromExpression(const char *name,
lldb::SBValue SBValue::CreateValueFromExpression(const char *name,
const char *expression,
SBExpressionOptions &options) {
LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateValueFromExpression,
(const char *, const char *, lldb::SBExpressionOptions &),
name, expression, options);
LLDB_INSTRUMENT_VA(this, name, expression, options);
lldb::SBValue sb_value;
ValueLocker locker;
@ -628,9 +618,7 @@ lldb::SBValue SBValue::CreateValueFromExpression(const char *name,
lldb::SBValue SBValue::CreateValueFromAddress(const char *name,
lldb::addr_t address,
SBType sb_type) {
LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateValueFromAddress,
(const char *, lldb::addr_t, lldb::SBType), name, address,
sb_type);
LLDB_INSTRUMENT_VA(this, name, address, sb_type);
lldb::SBValue sb_value;
ValueLocker locker;
@ -649,9 +637,7 @@ lldb::SBValue SBValue::CreateValueFromAddress(const char *name,
lldb::SBValue SBValue::CreateValueFromData(const char *name, SBData data,
SBType sb_type) {
LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateValueFromData,
(const char *, lldb::SBData, lldb::SBType), name, data,
sb_type);
LLDB_INSTRUMENT_VA(this, name, data, sb_type);
lldb::SBValue sb_value;
lldb::ValueObjectSP new_value_sp;
@ -669,7 +655,7 @@ lldb::SBValue SBValue::CreateValueFromData(const char *name, SBData data,
}
SBValue SBValue::GetChildAtIndex(uint32_t idx) {
LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildAtIndex, (uint32_t), idx);
LLDB_INSTRUMENT_VA(this, idx);
const bool can_create_synthetic = false;
lldb::DynamicValueType use_dynamic = eNoDynamicValues;
@ -686,9 +672,7 @@ SBValue SBValue::GetChildAtIndex(uint32_t idx) {
SBValue SBValue::GetChildAtIndex(uint32_t idx,
lldb::DynamicValueType use_dynamic,
bool can_create_synthetic) {
LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildAtIndex,
(uint32_t, lldb::DynamicValueType, bool), idx, use_dynamic,
can_create_synthetic);
LLDB_INSTRUMENT_VA(this, idx, use_dynamic, can_create_synthetic);
lldb::ValueObjectSP child_sp;
@ -709,8 +693,7 @@ SBValue SBValue::GetChildAtIndex(uint32_t idx,
}
uint32_t SBValue::GetIndexOfChildWithName(const char *name) {
LLDB_RECORD_METHOD(uint32_t, SBValue, GetIndexOfChildWithName, (const char *),
name);
LLDB_INSTRUMENT_VA(this, name);
uint32_t idx = UINT32_MAX;
ValueLocker locker;
@ -722,8 +705,7 @@ uint32_t SBValue::GetIndexOfChildWithName(const char *name) {
}
SBValue SBValue::GetChildMemberWithName(const char *name) {
LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName,
(const char *), name);
LLDB_INSTRUMENT_VA(this, name);
lldb::DynamicValueType use_dynamic_value = eNoDynamicValues;
TargetSP target_sp;
@ -738,9 +720,7 @@ SBValue SBValue::GetChildMemberWithName(const char *name) {
SBValue
SBValue::GetChildMemberWithName(const char *name,
lldb::DynamicValueType use_dynamic_value) {
LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName,
(const char *, lldb::DynamicValueType), name,
use_dynamic_value);
LLDB_INSTRUMENT_VA(this, name, use_dynamic_value);
lldb::ValueObjectSP child_sp;
const ConstString str_name(name);
@ -758,8 +738,7 @@ SBValue::GetChildMemberWithName(const char *name,
}
lldb::SBValue SBValue::GetDynamicValue(lldb::DynamicValueType use_dynamic) {
LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetDynamicValue,
(lldb::DynamicValueType), use_dynamic);
LLDB_INSTRUMENT_VA(this, use_dynamic);
SBValue value_sb;
if (IsValid()) {
@ -771,7 +750,7 @@ lldb::SBValue SBValue::GetDynamicValue(lldb::DynamicValueType use_dynamic) {
}
lldb::SBValue SBValue::GetStaticValue() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, GetStaticValue);
LLDB_INSTRUMENT_VA(this);
SBValue value_sb;
if (IsValid()) {
@ -784,7 +763,7 @@ lldb::SBValue SBValue::GetStaticValue() {
}
lldb::SBValue SBValue::GetNonSyntheticValue() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, GetNonSyntheticValue);
LLDB_INSTRUMENT_VA(this);
SBValue value_sb;
if (IsValid()) {
@ -796,8 +775,7 @@ lldb::SBValue SBValue::GetNonSyntheticValue() {
}
lldb::DynamicValueType SBValue::GetPreferDynamicValue() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::DynamicValueType, SBValue,
GetPreferDynamicValue);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return eNoDynamicValues;
@ -805,15 +783,14 @@ lldb::DynamicValueType SBValue::GetPreferDynamicValue() {
}
void SBValue::SetPreferDynamicValue(lldb::DynamicValueType use_dynamic) {
LLDB_RECORD_METHOD(void, SBValue, SetPreferDynamicValue,
(lldb::DynamicValueType), use_dynamic);
LLDB_INSTRUMENT_VA(this, use_dynamic);
if (IsValid())
return m_opaque_sp->SetUseDynamic(use_dynamic);
}
bool SBValue::GetPreferSyntheticValue() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, GetPreferSyntheticValue);
LLDB_INSTRUMENT_VA(this);
if (!IsValid())
return false;
@ -821,15 +798,14 @@ bool SBValue::GetPreferSyntheticValue() {
}
void SBValue::SetPreferSyntheticValue(bool use_synthetic) {
LLDB_RECORD_METHOD(void, SBValue, SetPreferSyntheticValue, (bool),
use_synthetic);
LLDB_INSTRUMENT_VA(this, use_synthetic);
if (IsValid())
return m_opaque_sp->SetUseSynthetic(use_synthetic);
}
bool SBValue::IsDynamic() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsDynamic);
LLDB_INSTRUMENT_VA(this);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@ -839,7 +815,7 @@ bool SBValue::IsDynamic() {
}
bool SBValue::IsSynthetic() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsSynthetic);
LLDB_INSTRUMENT_VA(this);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@ -849,7 +825,7 @@ bool SBValue::IsSynthetic() {
}
bool SBValue::IsSyntheticChildrenGenerated() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsSyntheticChildrenGenerated);
LLDB_INSTRUMENT_VA(this);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@ -859,7 +835,7 @@ bool SBValue::IsSyntheticChildrenGenerated() {
}
void SBValue::SetSyntheticChildrenGenerated(bool is) {
LLDB_RECORD_METHOD(void, SBValue, SetSyntheticChildrenGenerated, (bool), is);
LLDB_INSTRUMENT_VA(this, is);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@ -868,8 +844,7 @@ void SBValue::SetSyntheticChildrenGenerated(bool is) {
}
lldb::SBValue SBValue::GetValueForExpressionPath(const char *expr_path) {
LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetValueForExpressionPath,
(const char *), expr_path);
LLDB_INSTRUMENT_VA(this, expr_path);
lldb::ValueObjectSP child_sp;
ValueLocker locker;
@ -886,8 +861,7 @@ lldb::SBValue SBValue::GetValueForExpressionPath(const char *expr_path) {
}
int64_t SBValue::GetValueAsSigned(SBError &error, int64_t fail_value) {
LLDB_RECORD_METHOD(int64_t, SBValue, GetValueAsSigned,
(lldb::SBError &, int64_t), error, fail_value);
LLDB_INSTRUMENT_VA(this, error, fail_value);
error.Clear();
ValueLocker locker;
@ -907,8 +881,7 @@ int64_t SBValue::GetValueAsSigned(SBError &error, int64_t fail_value) {
}
uint64_t SBValue::GetValueAsUnsigned(SBError &error, uint64_t fail_value) {
LLDB_RECORD_METHOD(uint64_t, SBValue, GetValueAsUnsigned,
(lldb::SBError &, uint64_t), error, fail_value);
LLDB_INSTRUMENT_VA(this, error, fail_value);
error.Clear();
ValueLocker locker;
@ -928,7 +901,7 @@ uint64_t SBValue::GetValueAsUnsigned(SBError &error, uint64_t fail_value) {
}
int64_t SBValue::GetValueAsSigned(int64_t fail_value) {
LLDB_RECORD_METHOD(int64_t, SBValue, GetValueAsSigned, (int64_t), fail_value);
LLDB_INSTRUMENT_VA(this, fail_value);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@ -939,8 +912,7 @@ int64_t SBValue::GetValueAsSigned(int64_t fail_value) {
}
uint64_t SBValue::GetValueAsUnsigned(uint64_t fail_value) {
LLDB_RECORD_METHOD(uint64_t, SBValue, GetValueAsUnsigned, (uint64_t),
fail_value);
LLDB_INSTRUMENT_VA(this, fail_value);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@ -951,7 +923,7 @@ uint64_t SBValue::GetValueAsUnsigned(uint64_t fail_value) {
}
bool SBValue::MightHaveChildren() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, MightHaveChildren);
LLDB_INSTRUMENT_VA(this);
bool has_children = false;
ValueLocker locker;
@ -963,7 +935,7 @@ bool SBValue::MightHaveChildren() {
}
bool SBValue::IsRuntimeSupportValue() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsRuntimeSupportValue);
LLDB_INSTRUMENT_VA(this);
bool is_support = false;
ValueLocker locker;
@ -975,13 +947,13 @@ bool SBValue::IsRuntimeSupportValue() {
}
uint32_t SBValue::GetNumChildren() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBValue, GetNumChildren);
LLDB_INSTRUMENT_VA(this);
return GetNumChildren(UINT32_MAX);
}
uint32_t SBValue::GetNumChildren(uint32_t max) {
LLDB_RECORD_METHOD(uint32_t, SBValue, GetNumChildren, (uint32_t), max);
LLDB_INSTRUMENT_VA(this, max);
uint32_t num_children = 0;
@ -994,7 +966,7 @@ uint32_t SBValue::GetNumChildren(uint32_t max) {
}
SBValue SBValue::Dereference() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, Dereference);
LLDB_INSTRUMENT_VA(this);
SBValue sb_value;
ValueLocker locker;
@ -1009,13 +981,13 @@ SBValue SBValue::Dereference() {
// Deprecated - please use GetType().IsPointerType() instead.
bool SBValue::TypeIsPointerType() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, TypeIsPointerType);
LLDB_INSTRUMENT_VA(this);
return GetType().IsPointerType();
}
void *SBValue::GetOpaqueType() {
LLDB_RECORD_METHOD_NO_ARGS(void *, SBValue, GetOpaqueType);
LLDB_INSTRUMENT_VA(this);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@ -1025,7 +997,7 @@ void *SBValue::GetOpaqueType() {
}
lldb::SBTarget SBValue::GetTarget() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBValue, GetTarget);
LLDB_INSTRUMENT_VA(this);
SBTarget sb_target;
TargetSP target_sp;
@ -1038,7 +1010,7 @@ lldb::SBTarget SBValue::GetTarget() {
}
lldb::SBProcess SBValue::GetProcess() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBValue, GetProcess);
LLDB_INSTRUMENT_VA(this);
SBProcess sb_process;
ProcessSP process_sp;
@ -1051,7 +1023,7 @@ lldb::SBProcess SBValue::GetProcess() {
}
lldb::SBThread SBValue::GetThread() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBThread, SBValue, GetThread);
LLDB_INSTRUMENT_VA(this);
SBThread sb_thread;
ThreadSP thread_sp;
@ -1064,7 +1036,7 @@ lldb::SBThread SBValue::GetThread() {
}
lldb::SBFrame SBValue::GetFrame() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFrame, SBValue, GetFrame);
LLDB_INSTRUMENT_VA(this);
SBFrame sb_frame;
StackFrameSP frame_sp;
@ -1085,7 +1057,7 @@ lldb::ValueObjectSP SBValue::GetSP(ValueLocker &locker) const {
}
lldb::ValueObjectSP SBValue::GetSP() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ValueObjectSP, SBValue, GetSP);
LLDB_INSTRUMENT_VA(this);
ValueLocker locker;
return GetSP(locker);
@ -1146,8 +1118,7 @@ void SBValue::SetSP(const lldb::ValueObjectSP &sp,
}
bool SBValue::GetExpressionPath(SBStream &description) {
LLDB_RECORD_METHOD(bool, SBValue, GetExpressionPath, (lldb::SBStream &),
description);
LLDB_INSTRUMENT_VA(this, description);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@ -1160,8 +1131,7 @@ bool SBValue::GetExpressionPath(SBStream &description) {
bool SBValue::GetExpressionPath(SBStream &description,
bool qualify_cxx_base_classes) {
LLDB_RECORD_METHOD(bool, SBValue, GetExpressionPath, (lldb::SBStream &, bool),
description, qualify_cxx_base_classes);
LLDB_INSTRUMENT_VA(this, description, qualify_cxx_base_classes);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@ -1173,8 +1143,7 @@ bool SBValue::GetExpressionPath(SBStream &description,
}
lldb::SBValue SBValue::EvaluateExpression(const char *expr) const {
LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValue, EvaluateExpression,
(const char *), expr);
LLDB_INSTRUMENT_VA(this, expr);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@ -1196,9 +1165,7 @@ lldb::SBValue SBValue::EvaluateExpression(const char *expr) const {
lldb::SBValue
SBValue::EvaluateExpression(const char *expr,
const SBExpressionOptions &options) const {
LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValue, EvaluateExpression,
(const char *, const lldb::SBExpressionOptions &),
expr, options);
LLDB_INSTRUMENT_VA(this, expr, options);
return EvaluateExpression(expr, options, nullptr);
}
@ -1206,11 +1173,7 @@ SBValue::EvaluateExpression(const char *expr,
lldb::SBValue SBValue::EvaluateExpression(const char *expr,
const SBExpressionOptions &options,
const char *name) const {
LLDB_RECORD_METHOD_CONST(
lldb::SBValue, SBValue, EvaluateExpression,
(const char *, const lldb::SBExpressionOptions &, const char *), expr,
options, name);
LLDB_INSTRUMENT_VA(this, expr, options, name);
if (!expr || expr[0] == '\0') {
return SBValue();
@ -1249,8 +1212,7 @@ lldb::SBValue SBValue::EvaluateExpression(const char *expr,
}
bool SBValue::GetDescription(SBStream &description) {
LLDB_RECORD_METHOD(bool, SBValue, GetDescription, (lldb::SBStream &),
description);
LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();
@ -1265,7 +1227,7 @@ bool SBValue::GetDescription(SBStream &description) {
}
lldb::Format SBValue::GetFormat() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::Format, SBValue, GetFormat);
LLDB_INSTRUMENT_VA(this);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@ -1275,7 +1237,7 @@ lldb::Format SBValue::GetFormat() {
}
void SBValue::SetFormat(lldb::Format format) {
LLDB_RECORD_METHOD(void, SBValue, SetFormat, (lldb::Format), format);
LLDB_INSTRUMENT_VA(this, format);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@ -1284,7 +1246,7 @@ void SBValue::SetFormat(lldb::Format format) {
}
lldb::SBValue SBValue::AddressOf() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, AddressOf);
LLDB_INSTRUMENT_VA(this);
SBValue sb_value;
ValueLocker locker;
@ -1299,7 +1261,7 @@ lldb::SBValue SBValue::AddressOf() {
}
lldb::addr_t SBValue::GetLoadAddress() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBValue, GetLoadAddress);
LLDB_INSTRUMENT_VA(this);
lldb::addr_t value = LLDB_INVALID_ADDRESS;
ValueLocker locker;
@ -1329,7 +1291,7 @@ lldb::addr_t SBValue::GetLoadAddress() {
}
lldb::SBAddress SBValue::GetAddress() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBValue, GetAddress);
LLDB_INSTRUMENT_VA(this);
Address addr;
ValueLocker locker;
@ -1358,8 +1320,7 @@ lldb::SBAddress SBValue::GetAddress() {
}
lldb::SBData SBValue::GetPointeeData(uint32_t item_idx, uint32_t item_count) {
LLDB_RECORD_METHOD(lldb::SBData, SBValue, GetPointeeData,
(uint32_t, uint32_t), item_idx, item_count);
LLDB_INSTRUMENT_VA(this, item_idx, item_count);
lldb::SBData sb_data;
ValueLocker locker;
@ -1378,7 +1339,7 @@ lldb::SBData SBValue::GetPointeeData(uint32_t item_idx, uint32_t item_count) {
}
lldb::SBData SBValue::GetData() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBData, SBValue, GetData);
LLDB_INSTRUMENT_VA(this);
lldb::SBData sb_data;
ValueLocker locker;
@ -1395,8 +1356,7 @@ lldb::SBData SBValue::GetData() {
}
bool SBValue::SetData(lldb::SBData &data, SBError &error) {
LLDB_RECORD_METHOD(bool, SBValue, SetData, (lldb::SBData &, lldb::SBError &),
data, error);
LLDB_INSTRUMENT_VA(this, data, error);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@ -1430,7 +1390,7 @@ bool SBValue::SetData(lldb::SBData &data, SBError &error) {
}
lldb::SBValue SBValue::Clone(const char *new_name) {
LLDB_RECORD_METHOD(lldb::SBValue, SBValue, Clone, (const char *), new_name);
LLDB_INSTRUMENT_VA(this, new_name);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@ -1442,7 +1402,7 @@ lldb::SBValue SBValue::Clone(const char *new_name) {
}
lldb::SBDeclaration SBValue::GetDeclaration() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBDeclaration, SBValue, GetDeclaration);
LLDB_INSTRUMENT_VA(this);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@ -1457,9 +1417,7 @@ lldb::SBDeclaration SBValue::GetDeclaration() {
lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read, bool write,
SBError &error) {
LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBValue, Watch,
(bool, bool, bool, lldb::SBError &), resolve_location,
read, write, error);
LLDB_INSTRUMENT_VA(this, resolve_location, read, write, error);
SBWatchpoint sb_watchpoint;
@ -1522,8 +1480,7 @@ lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read, bool write,
// Backward compatibility fix in the interim.
lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read,
bool write) {
LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBValue, Watch, (bool, bool, bool),
resolve_location, read, write);
LLDB_INSTRUMENT_VA(this, resolve_location, read, write);
SBError error;
return Watch(resolve_location, read, write, error);
@ -1531,9 +1488,7 @@ lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read,
lldb::SBWatchpoint SBValue::WatchPointee(bool resolve_location, bool read,
bool write, SBError &error) {
LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBValue, WatchPointee,
(bool, bool, bool, lldb::SBError &), resolve_location,
read, write, error);
LLDB_INSTRUMENT_VA(this, resolve_location, read, write, error);
SBWatchpoint sb_watchpoint;
if (IsInScope() && GetType().IsPointerType())
@ -1542,7 +1497,7 @@ lldb::SBWatchpoint SBValue::WatchPointee(bool resolve_location, bool read,
}
lldb::SBValue SBValue::Persist() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, Persist);
LLDB_INSTRUMENT_VA(this);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));

33
lldb/source/API/SBValueList.cpp
View file

@ -7,10 +7,10 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBValueList.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBValue.h"
#include "lldb/Core/ValueObjectList.h"
#include "lldb/Utility/Instrumentation.h"
#include <vector>
@ -67,10 +67,10 @@ private:
std::vector<lldb::SBValue> m_values;
};
SBValueList::SBValueList() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBValueList); }
SBValueList::SBValueList() { LLDB_INSTRUMENT_VA(this); }
SBValueList::SBValueList(const SBValueList &rhs) {
LLDB_RECORD_CONSTRUCTOR(SBValueList, (const lldb::SBValueList &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (rhs.IsValid())
m_opaque_up = std::make_unique<ValueListImpl>(*rhs);
@ -84,24 +84,23 @@ SBValueList::SBValueList(const ValueListImpl *lldb_object_ptr) {
SBValueList::~SBValueList() = default;
bool SBValueList::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBValueList, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBValueList::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBValueList, operator bool);
LLDB_INSTRUMENT_VA(this);
return (m_opaque_up != nullptr);
}
void SBValueList::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBValueList, Clear);
LLDB_INSTRUMENT_VA(this);
m_opaque_up.reset();
}
const SBValueList &SBValueList::operator=(const SBValueList &rhs) {
LLDB_RECORD_METHOD(const lldb::SBValueList &,
SBValueList, operator=,(const lldb::SBValueList &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs) {
if (rhs.IsValid())
@ -123,8 +122,7 @@ const ValueListImpl *SBValueList::operator->() const {
const ValueListImpl &SBValueList::operator*() const { return *m_opaque_up; }
void SBValueList::Append(const SBValue &val_obj) {
LLDB_RECORD_METHOD(void, SBValueList, Append, (const lldb::SBValue &),
val_obj);
LLDB_INSTRUMENT_VA(this, val_obj);
CreateIfNeeded();
m_opaque_up->Append(val_obj);
@ -138,8 +136,7 @@ void SBValueList::Append(lldb::ValueObjectSP &val_obj_sp) {
}
void SBValueList::Append(const lldb::SBValueList &value_list) {
LLDB_RECORD_METHOD(void, SBValueList, Append, (const lldb::SBValueList &),
value_list);
LLDB_INSTRUMENT_VA(this, value_list);
if (value_list.IsValid()) {
CreateIfNeeded();
@ -148,9 +145,7 @@ void SBValueList::Append(const lldb::SBValueList &value_list) {
}
SBValue SBValueList::GetValueAtIndex(uint32_t idx) const {
LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValueList, GetValueAtIndex,
(uint32_t), idx);
LLDB_INSTRUMENT_VA(this, idx);
SBValue sb_value;
if (m_opaque_up)
@ -160,7 +155,7 @@ SBValue SBValueList::GetValueAtIndex(uint32_t idx) const {
}
uint32_t SBValueList::GetSize() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBValueList, GetSize);
LLDB_INSTRUMENT_VA(this);
uint32_t size = 0;
if (m_opaque_up)
@ -175,8 +170,7 @@ void SBValueList::CreateIfNeeded() {
}
SBValue SBValueList::FindValueObjectByUID(lldb::user_id_t uid) {
LLDB_RECORD_METHOD(lldb::SBValue, SBValueList, FindValueObjectByUID,
(lldb::user_id_t), uid);
LLDB_INSTRUMENT_VA(this, uid);
SBValue sb_value;
if (m_opaque_up)
@ -185,8 +179,7 @@ SBValue SBValueList::FindValueObjectByUID(lldb::user_id_t uid) {
}
SBValue SBValueList::GetFirstValueByName(const char *name) const {
LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValueList, GetFirstValueByName,
(const char *), name);
LLDB_INSTRUMENT_VA(this, name);
SBValue sb_value;
if (m_opaque_up)

56
lldb/source/API/SBVariablesOptions.cpp
View file

@ -7,9 +7,9 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBVariablesOptions.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBTarget.h"
#include "lldb/Target/Target.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/lldb-private.h"
@ -80,21 +80,17 @@ private:
SBVariablesOptions::SBVariablesOptions()
: m_opaque_up(new VariablesOptionsImpl()) {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBVariablesOptions);
LLDB_INSTRUMENT_VA(this);
}
SBVariablesOptions::SBVariablesOptions(const SBVariablesOptions &options)
: m_opaque_up(new VariablesOptionsImpl(options.ref())) {
LLDB_RECORD_CONSTRUCTOR(SBVariablesOptions,
(const lldb::SBVariablesOptions &), options);
LLDB_INSTRUMENT_VA(this, options);
}
SBVariablesOptions &SBVariablesOptions::
operator=(const SBVariablesOptions &options) {
LLDB_RECORD_METHOD(
lldb::SBVariablesOptions &,
SBVariablesOptions, operator=,(const lldb::SBVariablesOptions &),
options);
LLDB_INSTRUMENT_VA(this, options);
m_opaque_up = std::make_unique<VariablesOptionsImpl>(options.ref());
return *this;
@ -103,109 +99,97 @@ operator=(const SBVariablesOptions &options) {
SBVariablesOptions::~SBVariablesOptions() = default;
bool SBVariablesOptions::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBVariablesOptions::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, operator bool);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up != nullptr;
}
bool SBVariablesOptions::GetIncludeArguments() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions,
GetIncludeArguments);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetIncludeArguments();
}
void SBVariablesOptions::SetIncludeArguments(bool arguments) {
LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeArguments, (bool),
arguments);
LLDB_INSTRUMENT_VA(this, arguments);
m_opaque_up->SetIncludeArguments(arguments);
}
bool SBVariablesOptions::GetIncludeRecognizedArguments(
const lldb::SBTarget &target) const {
LLDB_RECORD_METHOD_CONST(bool, SBVariablesOptions,
GetIncludeRecognizedArguments,
(const lldb::SBTarget &), target);
LLDB_INSTRUMENT_VA(this, target);
return m_opaque_up->GetIncludeRecognizedArguments(target.GetSP());
}
void SBVariablesOptions::SetIncludeRecognizedArguments(bool arguments) {
LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeRecognizedArguments,
(bool), arguments);
LLDB_INSTRUMENT_VA(this, arguments);
m_opaque_up->SetIncludeRecognizedArguments(arguments);
}
bool SBVariablesOptions::GetIncludeLocals() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, GetIncludeLocals);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetIncludeLocals();
}
void SBVariablesOptions::SetIncludeLocals(bool locals) {
LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeLocals, (bool),
locals);
LLDB_INSTRUMENT_VA(this, locals);
m_opaque_up->SetIncludeLocals(locals);
}
bool SBVariablesOptions::GetIncludeStatics() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, GetIncludeStatics);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetIncludeStatics();
}
void SBVariablesOptions::SetIncludeStatics(bool statics) {
LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeStatics, (bool),
statics);
LLDB_INSTRUMENT_VA(this, statics);
m_opaque_up->SetIncludeStatics(statics);
}
bool SBVariablesOptions::GetInScopeOnly() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, GetInScopeOnly);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetInScopeOnly();
}
void SBVariablesOptions::SetInScopeOnly(bool in_scope_only) {
LLDB_RECORD_METHOD(void, SBVariablesOptions, SetInScopeOnly, (bool),
in_scope_only);
LLDB_INSTRUMENT_VA(this, in_scope_only);
m_opaque_up->SetInScopeOnly(in_scope_only);
}
bool SBVariablesOptions::GetIncludeRuntimeSupportValues() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions,
GetIncludeRuntimeSupportValues);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetIncludeRuntimeSupportValues();
}
void SBVariablesOptions::SetIncludeRuntimeSupportValues(
bool runtime_support_values) {
LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeRuntimeSupportValues,
(bool), runtime_support_values);
LLDB_INSTRUMENT_VA(this, runtime_support_values);
m_opaque_up->SetIncludeRuntimeSupportValues(runtime_support_values);
}
lldb::DynamicValueType SBVariablesOptions::GetUseDynamic() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::DynamicValueType, SBVariablesOptions,
GetUseDynamic);
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetUseDynamic();
}
void SBVariablesOptions::SetUseDynamic(lldb::DynamicValueType dynamic) {
LLDB_RECORD_METHOD(void, SBVariablesOptions, SetUseDynamic,
(lldb::DynamicValueType), dynamic);
LLDB_INSTRUMENT_VA(this, dynamic);
m_opaque_up->SetUseDynamic(dynamic);
}

69
lldb/source/API/SBWatchpoint.cpp
View file

@ -7,12 +7,12 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBWatchpoint.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBDefines.h"
#include "lldb/API/SBEvent.h"
#include "lldb/API/SBStream.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/Breakpoint/Watchpoint.h"
#include "lldb/Breakpoint/WatchpointList.h"
@ -26,21 +26,20 @@
using namespace lldb;
using namespace lldb_private;
SBWatchpoint::SBWatchpoint() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBWatchpoint); }
SBWatchpoint::SBWatchpoint() { LLDB_INSTRUMENT_VA(this); }
SBWatchpoint::SBWatchpoint(const lldb::WatchpointSP &wp_sp)
: m_opaque_wp(wp_sp) {
LLDB_RECORD_CONSTRUCTOR(SBWatchpoint, (const lldb::WatchpointSP &), wp_sp);
LLDB_INSTRUMENT_VA(this, wp_sp);
}
SBWatchpoint::SBWatchpoint(const SBWatchpoint &rhs)
: m_opaque_wp(rhs.m_opaque_wp) {
LLDB_RECORD_CONSTRUCTOR(SBWatchpoint, (const lldb::SBWatchpoint &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
}
const SBWatchpoint &SBWatchpoint::operator=(const SBWatchpoint &rhs) {
LLDB_RECORD_METHOD(const lldb::SBWatchpoint &,
SBWatchpoint, operator=,(const lldb::SBWatchpoint &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_wp = rhs.m_opaque_wp;
return *this;
@ -49,8 +48,7 @@ const SBWatchpoint &SBWatchpoint::operator=(const SBWatchpoint &rhs) {
SBWatchpoint::~SBWatchpoint() = default;
watch_id_t SBWatchpoint::GetID() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::watch_id_t, SBWatchpoint, GetID);
LLDB_INSTRUMENT_VA(this);
watch_id_t watch_id = LLDB_INVALID_WATCH_ID;
lldb::WatchpointSP watchpoint_sp(GetSP());
@ -61,31 +59,29 @@ watch_id_t SBWatchpoint::GetID() {
}
bool SBWatchpoint::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBWatchpoint, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBWatchpoint::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBWatchpoint, operator bool);
LLDB_INSTRUMENT_VA(this);
return bool(m_opaque_wp.lock());
}
bool SBWatchpoint::operator==(const SBWatchpoint &rhs) const {
LLDB_RECORD_METHOD_CONST(
bool, SBWatchpoint, operator==,(const SBWatchpoint &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
return GetSP() == rhs.GetSP();
}
bool SBWatchpoint::operator!=(const SBWatchpoint &rhs) const {
LLDB_RECORD_METHOD_CONST(
bool, SBWatchpoint, operator!=,(const SBWatchpoint &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
return !(*this == rhs);
}
SBError SBWatchpoint::GetError() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBWatchpoint, GetError);
LLDB_INSTRUMENT_VA(this);
SBError sb_error;
lldb::WatchpointSP watchpoint_sp(GetSP());
@ -96,7 +92,7 @@ SBError SBWatchpoint::GetError() {
}
int32_t SBWatchpoint::GetHardwareIndex() {
LLDB_RECORD_METHOD_NO_ARGS(int32_t, SBWatchpoint, GetHardwareIndex);
LLDB_INSTRUMENT_VA(this);
int32_t hw_index = -1;
@ -111,7 +107,7 @@ int32_t SBWatchpoint::GetHardwareIndex() {
}
addr_t SBWatchpoint::GetWatchAddress() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBWatchpoint, GetWatchAddress);
LLDB_INSTRUMENT_VA(this);
addr_t ret_addr = LLDB_INVALID_ADDRESS;
@ -126,7 +122,7 @@ addr_t SBWatchpoint::GetWatchAddress() {
}
size_t SBWatchpoint::GetWatchSize() {
LLDB_RECORD_METHOD_NO_ARGS(size_t, SBWatchpoint, GetWatchSize);
LLDB_INSTRUMENT_VA(this);
size_t watch_size = 0;
@ -141,7 +137,7 @@ size_t SBWatchpoint::GetWatchSize() {
}
void SBWatchpoint::SetEnabled(bool enabled) {
LLDB_RECORD_METHOD(void, SBWatchpoint, SetEnabled, (bool), enabled);
LLDB_INSTRUMENT_VA(this, enabled);
lldb::WatchpointSP watchpoint_sp(GetSP());
if (watchpoint_sp) {
@ -161,7 +157,7 @@ void SBWatchpoint::SetEnabled(bool enabled) {
}
bool SBWatchpoint::IsEnabled() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBWatchpoint, IsEnabled);
LLDB_INSTRUMENT_VA(this);
lldb::WatchpointSP watchpoint_sp(GetSP());
if (watchpoint_sp) {
@ -173,7 +169,7 @@ bool SBWatchpoint::IsEnabled() {
}
uint32_t SBWatchpoint::GetHitCount() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBWatchpoint, GetHitCount);
LLDB_INSTRUMENT_VA(this);
uint32_t count = 0;
lldb::WatchpointSP watchpoint_sp(GetSP());
@ -187,7 +183,7 @@ uint32_t SBWatchpoint::GetHitCount() {
}
uint32_t SBWatchpoint::GetIgnoreCount() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBWatchpoint, GetIgnoreCount);
LLDB_INSTRUMENT_VA(this);
lldb::WatchpointSP watchpoint_sp(GetSP());
if (watchpoint_sp) {
@ -199,7 +195,7 @@ uint32_t SBWatchpoint::GetIgnoreCount() {
}
void SBWatchpoint::SetIgnoreCount(uint32_t n) {
LLDB_RECORD_METHOD(void, SBWatchpoint, SetIgnoreCount, (uint32_t), n);
LLDB_INSTRUMENT_VA(this, n);
lldb::WatchpointSP watchpoint_sp(GetSP());
if (watchpoint_sp) {
@ -210,7 +206,7 @@ void SBWatchpoint::SetIgnoreCount(uint32_t n) {
}
const char *SBWatchpoint::GetCondition() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBWatchpoint, GetCondition);
LLDB_INSTRUMENT_VA(this);
lldb::WatchpointSP watchpoint_sp(GetSP());
if (watchpoint_sp) {
@ -222,8 +218,7 @@ const char *SBWatchpoint::GetCondition() {
}
void SBWatchpoint::SetCondition(const char *condition) {
LLDB_RECORD_METHOD(void, SBWatchpoint, SetCondition, (const char *),
condition);
LLDB_INSTRUMENT_VA(this, condition);
lldb::WatchpointSP watchpoint_sp(GetSP());
if (watchpoint_sp) {
@ -235,9 +230,7 @@ void SBWatchpoint::SetCondition(const char *condition) {
bool SBWatchpoint::GetDescription(SBStream &description,
DescriptionLevel level) {
LLDB_RECORD_METHOD(bool, SBWatchpoint, GetDescription,
(lldb::SBStream &, lldb::DescriptionLevel), description,
level);
LLDB_INSTRUMENT_VA(this, description, level);
Stream &strm = description.ref();
@ -254,27 +247,25 @@ bool SBWatchpoint::GetDescription(SBStream &description,
}
void SBWatchpoint::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBWatchpoint, Clear);
LLDB_INSTRUMENT_VA(this);
m_opaque_wp.reset();
}
lldb::WatchpointSP SBWatchpoint::GetSP() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::WatchpointSP, SBWatchpoint, GetSP);
LLDB_INSTRUMENT_VA(this);
return m_opaque_wp.lock();
}
void SBWatchpoint::SetSP(const lldb::WatchpointSP &sp) {
LLDB_RECORD_METHOD(void, SBWatchpoint, SetSP, (const lldb::WatchpointSP &),
sp);
LLDB_INSTRUMENT_VA(this, sp);
m_opaque_wp = sp;
}
bool SBWatchpoint::EventIsWatchpointEvent(const lldb::SBEvent &event) {
LLDB_RECORD_STATIC_METHOD(bool, SBWatchpoint, EventIsWatchpointEvent,
(const lldb::SBEvent &), event);
LLDB_INSTRUMENT_VA(event);
return Watchpoint::WatchpointEventData::GetEventDataFromEvent(event.get()) !=
nullptr;
@ -282,9 +273,7 @@ bool SBWatchpoint::EventIsWatchpointEvent(const lldb::SBEvent &event) {
WatchpointEventType
SBWatchpoint::GetWatchpointEventTypeFromEvent(const SBEvent &event) {
LLDB_RECORD_STATIC_METHOD(lldb::WatchpointEventType, SBWatchpoint,
GetWatchpointEventTypeFromEvent,
(const lldb::SBEvent &), event);
LLDB_INSTRUMENT_VA(event);
if (event.IsValid())
return Watchpoint::WatchpointEventData::GetWatchpointEventTypeFromEvent(
@ -293,9 +282,7 @@ SBWatchpoint::GetWatchpointEventTypeFromEvent(const SBEvent &event) {
}
SBWatchpoint SBWatchpoint::GetWatchpointFromEvent(const lldb::SBEvent &event) {
LLDB_RECORD_STATIC_METHOD(lldb::SBWatchpoint, SBWatchpoint,
GetWatchpointFromEvent, (const lldb::SBEvent &),
event);
LLDB_INSTRUMENT_VA(event);
SBWatchpoint sb_watchpoint;
if (event.IsValid())

2
lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp
View file

@ -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"

2
lldb/source/Utility/CMakeLists.txt
View file

@ -49,7 +49,7 @@ add_lldb_library(lldbUtility
RegisterValue.cpp
RegularExpression.cpp
Reproducer.cpp
ReproducerInstrumentation.cpp
Instrumentation.cpp
ReproducerProvider.cpp
Scalar.cpp
SelectHelper.cpp

31
lldb/source/Utility/ReproducerInstrumentation.cpp → lldb/source/Utility/Instrumentation.cpp
View file

@ -1,46 +1,37 @@
//===-- ReproducerInstrumentation.cpp -------------------------------------===//
//
//===-- Instrumentation.cpp -----------------------------------------------===//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/Utility/Reproducer.h"
#include "lldb/Utility/Instrumentation.h"
#include <cstdio>
#include <cstdlib>
#include <limits>
#include <thread>
using namespace lldb_private;
using namespace lldb_private::repro;
using namespace lldb_private::instrumentation;
// Whether we're currently across the API boundary.
static thread_local bool g_global_boundary = false;
Recorder::Recorder() {
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} ({2})",
m_local_boundary ? "external" : "internal", pretty_func,
pretty_args);
}
Recorder::Recorder(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);
}
}
Instrumenter::~Instrumenter() { UpdateBoundary(); }
Recorder::~Recorder() {
UpdateBoundary();
}
void Recorder::UpdateBoundary() {
void Instrumenter::UpdateBoundary() {
if (m_local_boundary)
g_global_boundary = false;
}