//===----------------------------------------------------------------------===//
#include "lldb/API/SBAddress.h"
+#include "SBReproducerPrivate.h"
#include "Utils.h"
#include "lldb/API/SBProcess.h"
#include "lldb/API/SBSection.h"
using namespace lldb;
using namespace lldb_private;
-SBAddress::SBAddress() : m_opaque_up(new Address()) {}
+SBAddress::SBAddress() : m_opaque_up(new Address()) {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBAddress);
+}
SBAddress::SBAddress(const Address *lldb_object_ptr)
: m_opaque_up(new Address()) {
}
SBAddress::SBAddress(const SBAddress &rhs) : m_opaque_up(new Address()) {
+ LLDB_RECORD_CONSTRUCTOR(SBAddress, (const lldb::SBAddress &), rhs);
+
m_opaque_up = clone(rhs.m_opaque_up);
}
SBAddress::SBAddress(lldb::SBSection section, lldb::addr_t offset)
- : m_opaque_up(new Address(section.GetSP(), offset)) {}
+ : m_opaque_up(new Address(section.GetSP(), offset)) {
+ LLDB_RECORD_CONSTRUCTOR(SBAddress, (lldb::SBSection, lldb::addr_t), section,
+ offset);
+}
// Create an address by resolving a load address using the supplied target
SBAddress::SBAddress(lldb::addr_t load_addr, lldb::SBTarget &target)
: m_opaque_up(new Address()) {
+ LLDB_RECORD_CONSTRUCTOR(SBAddress, (lldb::addr_t, lldb::SBTarget &),
+ load_addr, target);
+
SetLoadAddress(load_addr, target);
}
SBAddress::~SBAddress() {}
const SBAddress &SBAddress::operator=(const SBAddress &rhs) {
+ LLDB_RECORD_METHOD(const lldb::SBAddress &,
+ SBAddress, operator=,(const lldb::SBAddress &), rhs);
+
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
return *this;
}
bool SBAddress::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBAddress, IsValid);
+
return m_opaque_up != NULL && m_opaque_up->IsValid();
}
-void SBAddress::Clear() { m_opaque_up.reset(new Address()); }
+void SBAddress::Clear() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBAddress, Clear);
+
+ m_opaque_up.reset(new Address());
+}
void SBAddress::SetAddress(lldb::SBSection section, lldb::addr_t offset) {
+ LLDB_RECORD_METHOD(void, SBAddress, SetAddress,
+ (lldb::SBSection, lldb::addr_t), section, offset);
+
Address &addr = ref();
addr.SetSection(section.GetSP());
addr.SetOffset(offset);
}
lldb::addr_t SBAddress::GetFileAddress() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBAddress, GetFileAddress);
+
if (m_opaque_up->IsValid())
return m_opaque_up->GetFileAddress();
else
}
lldb::addr_t SBAddress::GetLoadAddress(const SBTarget &target) const {
+ LLDB_RECORD_METHOD_CONST(lldb::addr_t, SBAddress, GetLoadAddress,
+ (const lldb::SBTarget &), target);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
lldb::addr_t addr = LLDB_INVALID_ADDRESS;
}
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);
+
// Create the address object if we don't already have one
ref();
if (target.IsValid())
}
bool SBAddress::OffsetAddress(addr_t offset) {
+ LLDB_RECORD_METHOD(bool, SBAddress, OffsetAddress, (lldb::addr_t), offset);
+
if (m_opaque_up->IsValid()) {
addr_t addr_offset = m_opaque_up->GetOffset();
if (addr_offset != LLDB_INVALID_ADDRESS) {
}
lldb::SBSection SBAddress::GetSection() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSection, SBAddress, GetSection);
+
lldb::SBSection sb_section;
if (m_opaque_up->IsValid())
sb_section.SetSP(m_opaque_up->GetSection());
- return sb_section;
+ return LLDB_RECORD_RESULT(sb_section);
}
lldb::addr_t SBAddress::GetOffset() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBAddress, GetOffset);
+
if (m_opaque_up->IsValid())
return m_opaque_up->GetOffset();
return 0;
Address *SBAddress::get() { return m_opaque_up.get(); }
bool SBAddress::GetDescription(SBStream &description) {
+ LLDB_RECORD_METHOD(bool, SBAddress, GetDescription, (lldb::SBStream &),
+ description);
+
// Call "ref()" on the stream to make sure it creates a backing stream in
// case there isn't one already...
Stream &strm = description.ref();
}
SBModule SBAddress::GetModule() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBModule, SBAddress, GetModule);
+
SBModule sb_module;
if (m_opaque_up->IsValid())
sb_module.SetSP(m_opaque_up->GetModule());
- return sb_module;
+ return LLDB_RECORD_RESULT(sb_module);
}
SBSymbolContext SBAddress::GetSymbolContext(uint32_t resolve_scope) {
+ LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBAddress, GetSymbolContext,
+ (uint32_t), resolve_scope);
+
SBSymbolContext sb_sc;
SymbolContextItem scope = static_cast<SymbolContextItem>(resolve_scope);
if (m_opaque_up->IsValid())
m_opaque_up->CalculateSymbolContext(&sb_sc.ref(), scope);
- return sb_sc;
+ return LLDB_RECORD_RESULT(sb_sc);
}
SBCompileUnit SBAddress::GetCompileUnit() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCompileUnit, SBAddress, GetCompileUnit);
+
SBCompileUnit sb_comp_unit;
if (m_opaque_up->IsValid())
sb_comp_unit.reset(m_opaque_up->CalculateSymbolContextCompileUnit());
- return sb_comp_unit;
+ return LLDB_RECORD_RESULT(sb_comp_unit);
}
SBFunction SBAddress::GetFunction() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFunction, SBAddress, GetFunction);
+
SBFunction sb_function;
if (m_opaque_up->IsValid())
sb_function.reset(m_opaque_up->CalculateSymbolContextFunction());
- return sb_function;
+ return LLDB_RECORD_RESULT(sb_function);
}
SBBlock SBAddress::GetBlock() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBAddress, GetBlock);
+
SBBlock sb_block;
if (m_opaque_up->IsValid())
sb_block.SetPtr(m_opaque_up->CalculateSymbolContextBlock());
- return sb_block;
+ return LLDB_RECORD_RESULT(sb_block);
}
SBSymbol SBAddress::GetSymbol() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSymbol, SBAddress, GetSymbol);
+
SBSymbol sb_symbol;
if (m_opaque_up->IsValid())
sb_symbol.reset(m_opaque_up->CalculateSymbolContextSymbol());
- return sb_symbol;
+ return LLDB_RECORD_RESULT(sb_symbol);
}
SBLineEntry SBAddress::GetLineEntry() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBLineEntry, SBAddress, GetLineEntry);
+
SBLineEntry sb_line_entry;
if (m_opaque_up->IsValid()) {
LineEntry line_entry;
if (m_opaque_up->CalculateSymbolContextLineEntry(line_entry))
sb_line_entry.SetLineEntry(line_entry);
}
- return sb_line_entry;
+ return LLDB_RECORD_RESULT(sb_line_entry);
}
//===----------------------------------------------------------------------===//
#include "lldb/API/SBAttachInfo.h"
+#include "SBReproducerPrivate.h"
#include "Utils.h"
#include "lldb/API/SBFileSpec.h"
#include "lldb/API/SBListener.h"
using namespace lldb;
using namespace lldb_private;
-SBAttachInfo::SBAttachInfo() : m_opaque_sp(new ProcessAttachInfo()) {}
+SBAttachInfo::SBAttachInfo() : m_opaque_sp(new ProcessAttachInfo()) {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBAttachInfo);
+}
SBAttachInfo::SBAttachInfo(lldb::pid_t pid)
: m_opaque_sp(new ProcessAttachInfo()) {
+ LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (lldb::pid_t), pid);
+
m_opaque_sp->SetProcessID(pid);
}
SBAttachInfo::SBAttachInfo(const char *path, bool wait_for)
: m_opaque_sp(new ProcessAttachInfo()) {
+ LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (const char *, bool), path, wait_for);
+
if (path && path[0])
m_opaque_sp->GetExecutableFile().SetFile(path, FileSpec::Style::native);
m_opaque_sp->SetWaitForLaunch(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);
+
if (path && path[0])
m_opaque_sp->GetExecutableFile().SetFile(path, FileSpec::Style::native);
m_opaque_sp->SetWaitForLaunch(wait_for);
SBAttachInfo::SBAttachInfo(const SBAttachInfo &rhs)
: m_opaque_sp(new ProcessAttachInfo()) {
+ LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (const lldb::SBAttachInfo &), rhs);
+
m_opaque_sp = clone(rhs.m_opaque_sp);
}
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);
+
if (this != &rhs)
m_opaque_sp = clone(rhs.m_opaque_sp);
return *this;
}
-lldb::pid_t SBAttachInfo::GetProcessID() { return m_opaque_sp->GetProcessID(); }
+lldb::pid_t SBAttachInfo::GetProcessID() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBAttachInfo, GetProcessID);
+
+ return m_opaque_sp->GetProcessID();
+}
void SBAttachInfo::SetProcessID(lldb::pid_t pid) {
+ LLDB_RECORD_METHOD(void, SBAttachInfo, SetProcessID, (lldb::pid_t), pid);
+
m_opaque_sp->SetProcessID(pid);
}
uint32_t SBAttachInfo::GetResumeCount() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetResumeCount);
+
return m_opaque_sp->GetResumeCount();
}
void SBAttachInfo::SetResumeCount(uint32_t c) {
+ LLDB_RECORD_METHOD(void, SBAttachInfo, SetResumeCount, (uint32_t), c);
+
m_opaque_sp->SetResumeCount(c);
}
const char *SBAttachInfo::GetProcessPluginName() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBAttachInfo, GetProcessPluginName);
+
return m_opaque_sp->GetProcessPluginName();
}
void SBAttachInfo::SetProcessPluginName(const char *plugin_name) {
+ LLDB_RECORD_METHOD(void, SBAttachInfo, SetProcessPluginName, (const char *),
+ plugin_name);
+
return m_opaque_sp->SetProcessPluginName(plugin_name);
}
void SBAttachInfo::SetExecutable(const char *path) {
+ LLDB_RECORD_METHOD(void, SBAttachInfo, SetExecutable, (const char *), path);
+
if (path && path[0])
m_opaque_sp->GetExecutableFile().SetFile(path, FileSpec::Style::native);
else
}
void SBAttachInfo::SetExecutable(SBFileSpec exe_file) {
+ LLDB_RECORD_METHOD(void, SBAttachInfo, SetExecutable, (lldb::SBFileSpec),
+ exe_file);
+
if (exe_file.IsValid())
m_opaque_sp->GetExecutableFile() = exe_file.ref();
else
}
bool SBAttachInfo::GetWaitForLaunch() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, GetWaitForLaunch);
+
return m_opaque_sp->GetWaitForLaunch();
}
void SBAttachInfo::SetWaitForLaunch(bool b) {
+ LLDB_RECORD_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool), b);
+
m_opaque_sp->SetWaitForLaunch(b);
}
void SBAttachInfo::SetWaitForLaunch(bool b, bool async) {
+ LLDB_RECORD_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool, bool), b,
+ async);
+
m_opaque_sp->SetWaitForLaunch(b);
m_opaque_sp->SetAsync(async);
}
bool SBAttachInfo::GetIgnoreExisting() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, GetIgnoreExisting);
+
return m_opaque_sp->GetIgnoreExisting();
}
void SBAttachInfo::SetIgnoreExisting(bool b) {
+ LLDB_RECORD_METHOD(void, SBAttachInfo, SetIgnoreExisting, (bool), b);
+
m_opaque_sp->SetIgnoreExisting(b);
}
-uint32_t SBAttachInfo::GetUserID() { return m_opaque_sp->GetUserID(); }
+uint32_t SBAttachInfo::GetUserID() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetUserID);
-uint32_t SBAttachInfo::GetGroupID() { return m_opaque_sp->GetGroupID(); }
+ return m_opaque_sp->GetUserID();
+}
-bool SBAttachInfo::UserIDIsValid() { return m_opaque_sp->UserIDIsValid(); }
+uint32_t SBAttachInfo::GetGroupID() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetGroupID);
-bool SBAttachInfo::GroupIDIsValid() { return m_opaque_sp->GroupIDIsValid(); }
+ return m_opaque_sp->GetGroupID();
+}
-void SBAttachInfo::SetUserID(uint32_t uid) { m_opaque_sp->SetUserID(uid); }
+bool SBAttachInfo::UserIDIsValid() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, UserIDIsValid);
-void SBAttachInfo::SetGroupID(uint32_t gid) { m_opaque_sp->SetGroupID(gid); }
+ return m_opaque_sp->UserIDIsValid();
+}
+
+bool SBAttachInfo::GroupIDIsValid() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, GroupIDIsValid);
+
+ return m_opaque_sp->GroupIDIsValid();
+}
+
+void SBAttachInfo::SetUserID(uint32_t uid) {
+ LLDB_RECORD_METHOD(void, SBAttachInfo, SetUserID, (uint32_t), uid);
+
+ m_opaque_sp->SetUserID(uid);
+}
+
+void SBAttachInfo::SetGroupID(uint32_t gid) {
+ LLDB_RECORD_METHOD(void, SBAttachInfo, SetGroupID, (uint32_t), gid);
+
+ m_opaque_sp->SetGroupID(gid);
+}
uint32_t SBAttachInfo::GetEffectiveUserID() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetEffectiveUserID);
+
return m_opaque_sp->GetEffectiveUserID();
}
uint32_t SBAttachInfo::GetEffectiveGroupID() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetEffectiveGroupID);
+
return m_opaque_sp->GetEffectiveGroupID();
}
bool SBAttachInfo::EffectiveUserIDIsValid() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, EffectiveUserIDIsValid);
+
return m_opaque_sp->EffectiveUserIDIsValid();
}
bool SBAttachInfo::EffectiveGroupIDIsValid() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, EffectiveGroupIDIsValid);
+
return m_opaque_sp->EffectiveGroupIDIsValid();
}
void SBAttachInfo::SetEffectiveUserID(uint32_t uid) {
+ LLDB_RECORD_METHOD(void, SBAttachInfo, SetEffectiveUserID, (uint32_t), uid);
+
m_opaque_sp->SetEffectiveUserID(uid);
}
void SBAttachInfo::SetEffectiveGroupID(uint32_t gid) {
+ LLDB_RECORD_METHOD(void, SBAttachInfo, SetEffectiveGroupID, (uint32_t), gid);
+
m_opaque_sp->SetEffectiveGroupID(gid);
}
lldb::pid_t SBAttachInfo::GetParentProcessID() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBAttachInfo, GetParentProcessID);
+
return m_opaque_sp->GetParentProcessID();
}
void SBAttachInfo::SetParentProcessID(lldb::pid_t pid) {
+ LLDB_RECORD_METHOD(void, SBAttachInfo, SetParentProcessID, (lldb::pid_t),
+ pid);
+
m_opaque_sp->SetParentProcessID(pid);
}
bool SBAttachInfo::ParentProcessIDIsValid() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, ParentProcessIDIsValid);
+
return m_opaque_sp->ParentProcessIDIsValid();
}
SBListener SBAttachInfo::GetListener() {
- return SBListener(m_opaque_sp->GetListener());
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBAttachInfo, GetListener);
+
+ return LLDB_RECORD_RESULT(SBListener(m_opaque_sp->GetListener()));
}
void SBAttachInfo::SetListener(SBListener &listener) {
+ LLDB_RECORD_METHOD(void, SBAttachInfo, SetListener, (lldb::SBListener &),
+ listener);
+
m_opaque_sp->SetListener(listener.GetSP());
}
//===----------------------------------------------------------------------===//
#include "lldb/API/SBBlock.h"
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBFileSpec.h"
#include "lldb/API/SBFrame.h"
using namespace lldb;
using namespace lldb_private;
-SBBlock::SBBlock() : m_opaque_ptr(NULL) {}
+SBBlock::SBBlock() : m_opaque_ptr(NULL) {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBlock);
+}
SBBlock::SBBlock(lldb_private::Block *lldb_object_ptr)
: m_opaque_ptr(lldb_object_ptr) {}
-SBBlock::SBBlock(const SBBlock &rhs) : m_opaque_ptr(rhs.m_opaque_ptr) {}
+SBBlock::SBBlock(const SBBlock &rhs) : m_opaque_ptr(rhs.m_opaque_ptr) {
+ LLDB_RECORD_CONSTRUCTOR(SBBlock, (const lldb::SBBlock &), rhs);
+}
const SBBlock &SBBlock::operator=(const SBBlock &rhs) {
+ LLDB_RECORD_METHOD(const lldb::SBBlock &,
+ SBBlock, operator=,(const lldb::SBBlock &), rhs);
+
m_opaque_ptr = rhs.m_opaque_ptr;
return *this;
}
SBBlock::~SBBlock() { m_opaque_ptr = NULL; }
-bool SBBlock::IsValid() const { return m_opaque_ptr != NULL; }
+bool SBBlock::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBlock, IsValid);
+
+ return m_opaque_ptr != NULL;
+}
bool SBBlock::IsInlined() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBlock, IsInlined);
+
if (m_opaque_ptr)
return m_opaque_ptr->GetInlinedFunctionInfo() != NULL;
return false;
}
const char *SBBlock::GetInlinedName() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBlock, GetInlinedName);
+
if (m_opaque_ptr) {
const InlineFunctionInfo *inlined_info =
m_opaque_ptr->GetInlinedFunctionInfo();
}
SBFileSpec SBBlock::GetInlinedCallSiteFile() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBBlock,
+ GetInlinedCallSiteFile);
+
SBFileSpec sb_file;
if (m_opaque_ptr) {
const InlineFunctionInfo *inlined_info =
if (inlined_info)
sb_file.SetFileSpec(inlined_info->GetCallSite().GetFile());
}
- return sb_file;
+ return LLDB_RECORD_RESULT(sb_file);
}
uint32_t SBBlock::GetInlinedCallSiteLine() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBlock, GetInlinedCallSiteLine);
+
if (m_opaque_ptr) {
const InlineFunctionInfo *inlined_info =
m_opaque_ptr->GetInlinedFunctionInfo();
}
uint32_t SBBlock::GetInlinedCallSiteColumn() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBlock, GetInlinedCallSiteColumn);
+
if (m_opaque_ptr) {
const InlineFunctionInfo *inlined_info =
m_opaque_ptr->GetInlinedFunctionInfo();
}
SBBlock SBBlock::GetParent() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetParent);
+
SBBlock sb_block;
if (m_opaque_ptr)
sb_block.m_opaque_ptr = m_opaque_ptr->GetParent();
- return sb_block;
+ return LLDB_RECORD_RESULT(sb_block);
}
lldb::SBBlock SBBlock::GetContainingInlinedBlock() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetContainingInlinedBlock);
+
SBBlock sb_block;
if (m_opaque_ptr)
sb_block.m_opaque_ptr = m_opaque_ptr->GetContainingInlinedBlock();
- return sb_block;
+ return LLDB_RECORD_RESULT(sb_block);
}
SBBlock SBBlock::GetSibling() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetSibling);
+
SBBlock sb_block;
if (m_opaque_ptr)
sb_block.m_opaque_ptr = m_opaque_ptr->GetSibling();
- return sb_block;
+ return LLDB_RECORD_RESULT(sb_block);
}
SBBlock SBBlock::GetFirstChild() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetFirstChild);
+
SBBlock sb_block;
if (m_opaque_ptr)
sb_block.m_opaque_ptr = m_opaque_ptr->GetFirstChild();
- return sb_block;
+ return LLDB_RECORD_RESULT(sb_block);
}
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);
+
Stream &strm = description.ref();
if (m_opaque_ptr) {
}
uint32_t SBBlock::GetNumRanges() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBBlock, GetNumRanges);
+
if (m_opaque_ptr)
return m_opaque_ptr->GetNumRanges();
return 0;
}
lldb::SBAddress SBBlock::GetRangeStartAddress(uint32_t idx) {
+ LLDB_RECORD_METHOD(lldb::SBAddress, SBBlock, GetRangeStartAddress, (uint32_t),
+ idx);
+
lldb::SBAddress sb_addr;
if (m_opaque_ptr) {
AddressRange range;
sb_addr.ref() = range.GetBaseAddress();
}
}
- return sb_addr;
+ return LLDB_RECORD_RESULT(sb_addr);
}
lldb::SBAddress SBBlock::GetRangeEndAddress(uint32_t idx) {
+ LLDB_RECORD_METHOD(lldb::SBAddress, SBBlock, GetRangeEndAddress, (uint32_t),
+ idx);
+
lldb::SBAddress sb_addr;
if (m_opaque_ptr) {
AddressRange range;
sb_addr.ref().Slide(range.GetByteSize());
}
}
- return sb_addr;
+ return LLDB_RECORD_RESULT(sb_addr);
}
uint32_t SBBlock::GetRangeIndexForBlockAddress(lldb::SBAddress block_addr) {
+ LLDB_RECORD_METHOD(uint32_t, SBBlock, GetRangeIndexForBlockAddress,
+ (lldb::SBAddress), block_addr);
+
if (m_opaque_ptr && block_addr.IsValid()) {
return m_opaque_ptr->GetRangeIndexContainingAddress(block_addr.ref());
}
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);
+
Block *block = GetPtr();
SBValueList value_list;
if (block) {
}
}
}
- return value_list;
+ return LLDB_RECORD_RESULT(value_list);
}
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);
+
Block *block = GetPtr();
SBValueList value_list;
}
}
}
- return value_list;
+ return LLDB_RECORD_RESULT(value_list);
}
//===----------------------------------------------------------------------===//
#include "lldb/API/SBBreakpoint.h"
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBBreakpointLocation.h"
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBEvent.h"
using namespace lldb;
using namespace lldb_private;
-SBBreakpoint::SBBreakpoint() {}
+SBBreakpoint::SBBreakpoint() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBreakpoint); }
SBBreakpoint::SBBreakpoint(const SBBreakpoint &rhs)
- : m_opaque_wp(rhs.m_opaque_wp) {}
+ : m_opaque_wp(rhs.m_opaque_wp) {
+ LLDB_RECORD_CONSTRUCTOR(SBBreakpoint, (const lldb::SBBreakpoint &), rhs);
+}
SBBreakpoint::SBBreakpoint(const lldb::BreakpointSP &bp_sp)
- : m_opaque_wp(bp_sp) {}
+ : m_opaque_wp(bp_sp) {
+ LLDB_RECORD_CONSTRUCTOR(SBBreakpoint, (const lldb::BreakpointSP &), bp_sp);
+}
SBBreakpoint::~SBBreakpoint() = default;
const SBBreakpoint &SBBreakpoint::operator=(const SBBreakpoint &rhs) {
+ LLDB_RECORD_METHOD(const lldb::SBBreakpoint &,
+ SBBreakpoint, operator=,(const lldb::SBBreakpoint &), rhs);
+
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);
+
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);
+
return m_opaque_wp.lock() != rhs.m_opaque_wp.lock();
}
break_id_t SBBreakpoint::GetID() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::break_id_t, SBBreakpoint, GetID);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
break_id_t break_id = LLDB_INVALID_BREAK_ID;
}
bool SBBreakpoint::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, IsValid);
+
BreakpointSP bkpt_sp = GetSP();
if (!bkpt_sp)
return false;
}
void SBBreakpoint::ClearAllBreakpointSites() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBBreakpoint, ClearAllBreakpointSites);
+
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
std::lock_guard<std::recursive_mutex> guard(
}
SBBreakpointLocation SBBreakpoint::FindLocationByAddress(addr_t vm_addr) {
+ LLDB_RECORD_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
+ FindLocationByAddress, (lldb::addr_t), vm_addr);
+
SBBreakpointLocation sb_bp_location;
BreakpointSP bkpt_sp = GetSP();
sb_bp_location.SetLocation(bkpt_sp->FindLocationByAddress(address));
}
}
- return sb_bp_location;
+ return LLDB_RECORD_RESULT(sb_bp_location);
}
break_id_t SBBreakpoint::FindLocationIDByAddress(addr_t vm_addr) {
+ LLDB_RECORD_METHOD(lldb::break_id_t, SBBreakpoint, FindLocationIDByAddress,
+ (lldb::addr_t), vm_addr);
+
break_id_t break_id = LLDB_INVALID_BREAK_ID;
BreakpointSP bkpt_sp = GetSP();
}
SBBreakpointLocation SBBreakpoint::FindLocationByID(break_id_t bp_loc_id) {
+ LLDB_RECORD_METHOD(lldb::SBBreakpointLocation, SBBreakpoint, FindLocationByID,
+ (lldb::break_id_t), bp_loc_id);
+
SBBreakpointLocation sb_bp_location;
BreakpointSP bkpt_sp = GetSP();
sb_bp_location.SetLocation(bkpt_sp->FindLocationByID(bp_loc_id));
}
- return sb_bp_location;
+ return LLDB_RECORD_RESULT(sb_bp_location);
}
SBBreakpointLocation SBBreakpoint::GetLocationAtIndex(uint32_t index) {
+ LLDB_RECORD_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
+ GetLocationAtIndex, (uint32_t), index);
+
SBBreakpointLocation sb_bp_location;
BreakpointSP bkpt_sp = GetSP();
sb_bp_location.SetLocation(bkpt_sp->GetLocationAtIndex(index));
}
- return sb_bp_location;
+ return LLDB_RECORD_RESULT(sb_bp_location);
}
void SBBreakpoint::SetEnabled(bool enable) {
+ LLDB_RECORD_METHOD(void, SBBreakpoint, SetEnabled, (bool), enable);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointSP bkpt_sp = GetSP();
}
bool SBBreakpoint::IsEnabled() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpoint, IsEnabled);
+
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
std::lock_guard<std::recursive_mutex> guard(
}
void SBBreakpoint::SetOneShot(bool one_shot) {
+ LLDB_RECORD_METHOD(void, SBBreakpoint, SetOneShot, (bool), one_shot);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointSP bkpt_sp = GetSP();
}
bool SBBreakpoint::IsOneShot() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, IsOneShot);
+
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
std::lock_guard<std::recursive_mutex> guard(
}
bool SBBreakpoint::IsInternal() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpoint, IsInternal);
+
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
std::lock_guard<std::recursive_mutex> guard(
}
void SBBreakpoint::SetIgnoreCount(uint32_t count) {
+ LLDB_RECORD_METHOD(void, SBBreakpoint, SetIgnoreCount, (uint32_t), count);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointSP bkpt_sp = GetSP();
}
void SBBreakpoint::SetCondition(const char *condition) {
+ LLDB_RECORD_METHOD(void, SBBreakpoint, SetCondition, (const char *),
+ condition);
+
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
std::lock_guard<std::recursive_mutex> guard(
}
const char *SBBreakpoint::GetCondition() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBBreakpoint, GetCondition);
+
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
std::lock_guard<std::recursive_mutex> guard(
}
void SBBreakpoint::SetAutoContinue(bool auto_continue) {
+ LLDB_RECORD_METHOD(void, SBBreakpoint, SetAutoContinue, (bool),
+ auto_continue);
+
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
std::lock_guard<std::recursive_mutex> guard(
}
bool SBBreakpoint::GetAutoContinue() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpoint, GetAutoContinue);
+
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
std::lock_guard<std::recursive_mutex> guard(
}
uint32_t SBBreakpoint::GetHitCount() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpoint, GetHitCount);
+
uint32_t count = 0;
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
}
uint32_t SBBreakpoint::GetIgnoreCount() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpoint, GetIgnoreCount);
+
uint32_t count = 0;
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
}
void SBBreakpoint::SetThreadID(tid_t tid) {
+ LLDB_RECORD_METHOD(void, SBBreakpoint, SetThreadID, (lldb::tid_t), tid);
+
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
std::lock_guard<std::recursive_mutex> guard(
}
tid_t SBBreakpoint::GetThreadID() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBBreakpoint, GetThreadID);
+
tid_t tid = LLDB_INVALID_THREAD_ID;
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
}
void SBBreakpoint::SetThreadIndex(uint32_t index) {
+ LLDB_RECORD_METHOD(void, SBBreakpoint, SetThreadIndex, (uint32_t), index);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointSP bkpt_sp = GetSP();
LLDB_LOG(log, "breakpoint = {0}, index = {1}", bkpt_sp.get(), index);
}
uint32_t SBBreakpoint::GetThreadIndex() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpoint, GetThreadIndex);
+
uint32_t thread_idx = UINT32_MAX;
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
}
void SBBreakpoint::SetThreadName(const char *thread_name) {
+ LLDB_RECORD_METHOD(void, SBBreakpoint, SetThreadName, (const char *),
+ thread_name);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointSP bkpt_sp = GetSP();
LLDB_LOG(log, "breakpoint = {0}, name = {1}", bkpt_sp.get(), thread_name);
}
const char *SBBreakpoint::GetThreadName() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpoint, GetThreadName);
+
const char *name = nullptr;
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
}
void SBBreakpoint::SetQueueName(const char *queue_name) {
+ LLDB_RECORD_METHOD(void, SBBreakpoint, SetQueueName, (const char *),
+ queue_name);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointSP bkpt_sp = GetSP();
LLDB_LOG(log, "breakpoint = {0}, queue_name = {1}", bkpt_sp.get(),
}
const char *SBBreakpoint::GetQueueName() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpoint, GetQueueName);
+
const char *name = nullptr;
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
}
size_t SBBreakpoint::GetNumResolvedLocations() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBBreakpoint,
+ GetNumResolvedLocations);
+
size_t num_resolved = 0;
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
}
size_t SBBreakpoint::GetNumLocations() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBBreakpoint, GetNumLocations);
+
BreakpointSP bkpt_sp = GetSP();
size_t num_locs = 0;
if (bkpt_sp) {
}
void SBBreakpoint::SetCommandLineCommands(SBStringList &commands) {
+ LLDB_RECORD_METHOD(void, SBBreakpoint, SetCommandLineCommands,
+ (lldb::SBStringList &), commands);
+
BreakpointSP bkpt_sp = GetSP();
if (!bkpt_sp)
return;
}
bool SBBreakpoint::GetCommandLineCommands(SBStringList &commands) {
+ LLDB_RECORD_METHOD(bool, SBBreakpoint, GetCommandLineCommands,
+ (lldb::SBStringList &), commands);
+
BreakpointSP bkpt_sp = GetSP();
if (!bkpt_sp)
return false;
}
bool SBBreakpoint::GetDescription(SBStream &s) {
+ LLDB_RECORD_METHOD(bool, SBBreakpoint, GetDescription, (lldb::SBStream &), s);
+
return GetDescription(s, true);
}
bool SBBreakpoint::GetDescription(SBStream &s, bool include_locations) {
+ LLDB_RECORD_METHOD(bool, SBBreakpoint, GetDescription,
+ (lldb::SBStream &, bool), s, include_locations);
+
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
std::lock_guard<std::recursive_mutex> guard(
return false;
}
-SBError
-SBBreakpoint::AddLocation(SBAddress &address) {
- BreakpointSP bkpt_sp = GetSP();
- SBError error;
-
- if (!address.IsValid()) {
- error.SetErrorString("Can't add an invalid address.");
- return error;
- }
-
- if (!bkpt_sp) {
- error.SetErrorString("No breakpoint to add a location to.");
- return error;
- }
-
- if (!llvm::isa<BreakpointResolverScripted>(bkpt_sp->GetResolver().get())) {
- error.SetErrorString("Only a scripted resolver can add locations.");
- return error;
- }
-
- if (bkpt_sp->GetSearchFilter()->AddressPasses(address.ref()))
- bkpt_sp->AddLocation(address.ref());
- else
- {
- StreamString s;
- address.get()->Dump(&s, &bkpt_sp->GetTarget(),
- Address::DumpStyleModuleWithFileAddress);
- error.SetErrorStringWithFormat("Address: %s didn't pass the filter.",
- s.GetData());
- }
- return error;
-}
+SBError SBBreakpoint::AddLocation(SBAddress &address) {
+ LLDB_RECORD_METHOD(lldb::SBError, SBBreakpoint, AddLocation,
+ (lldb::SBAddress &), address);
+ BreakpointSP bkpt_sp = GetSP();
+ SBError error;
+
+ if (!address.IsValid()) {
+ error.SetErrorString("Can't add an invalid address.");
+ return LLDB_RECORD_RESULT(error);
+ }
+
+ if (!bkpt_sp) {
+ error.SetErrorString("No breakpoint to add a location to.");
+ return LLDB_RECORD_RESULT(error);
+ }
+
+ if (!llvm::isa<BreakpointResolverScripted>(bkpt_sp->GetResolver().get())) {
+ error.SetErrorString("Only a scripted resolver can add locations.");
+ return LLDB_RECORD_RESULT(error);
+ }
+
+ if (bkpt_sp->GetSearchFilter()->AddressPasses(address.ref()))
+ bkpt_sp->AddLocation(address.ref());
+ else {
+ StreamString s;
+ address.get()->Dump(&s, &bkpt_sp->GetTarget(),
+ Address::DumpStyleModuleWithFileAddress);
+ error.SetErrorStringWithFormat("Address: %s didn't pass the filter.",
+ s.GetData());
+ }
+ return LLDB_RECORD_RESULT(error);
+}
void SBBreakpoint
::SetCallback(SBBreakpointHitCallback callback,
void SBBreakpoint::SetScriptCallbackFunction(
const char *callback_function_name) {
+ LLDB_RECORD_METHOD(void, SBBreakpoint, SetScriptCallbackFunction,
+ (const char *), callback_function_name);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointSP bkpt_sp = GetSP();
LLDB_LOG(log, "breakpoint = {0}, callback = {1}", bkpt_sp.get(),
}
SBError SBBreakpoint::SetScriptCallbackBody(const char *callback_body_text) {
+ LLDB_RECORD_METHOD(lldb::SBError, SBBreakpoint, SetScriptCallbackBody,
+ (const char *), callback_body_text);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointSP bkpt_sp = GetSP();
LLDB_LOG(log, "breakpoint = {0}, callback body:\n{1}", bkpt_sp.get(),
} else
sb_error.SetErrorString("invalid breakpoint");
- return sb_error;
+ return LLDB_RECORD_RESULT(sb_error);
}
bool SBBreakpoint::AddName(const char *new_name) {
+ LLDB_RECORD_METHOD(bool, SBBreakpoint, AddName, (const char *), new_name);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointSP bkpt_sp = GetSP();
LLDB_LOG(log, "breakpoint = {0}, name = {1}", bkpt_sp.get(), new_name);
}
void SBBreakpoint::RemoveName(const char *name_to_remove) {
+ LLDB_RECORD_METHOD(void, SBBreakpoint, RemoveName, (const char *),
+ name_to_remove);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointSP bkpt_sp = GetSP();
LLDB_LOG(log, "breakpoint = {0}, name = {1}", bkpt_sp.get(), name_to_remove);
}
bool SBBreakpoint::MatchesName(const char *name) {
+ LLDB_RECORD_METHOD(bool, SBBreakpoint, MatchesName, (const char *), name);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointSP bkpt_sp = GetSP();
LLDB_LOG(log, "breakpoint = {0}, name = {1}", bkpt_sp.get(), name);
}
void SBBreakpoint::GetNames(SBStringList &names) {
+ LLDB_RECORD_METHOD(void, SBBreakpoint, GetNames, (lldb::SBStringList &),
+ names);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointSP bkpt_sp = GetSP();
LLDB_LOG(log, "breakpoint = {0}", bkpt_sp.get());
}
bool SBBreakpoint::EventIsBreakpointEvent(const lldb::SBEvent &event) {
+ LLDB_RECORD_STATIC_METHOD(bool, SBBreakpoint, EventIsBreakpointEvent,
+ (const lldb::SBEvent &), event);
+
return Breakpoint::BreakpointEventData::GetEventDataFromEvent(event.get()) !=
nullptr;
}
BreakpointEventType
SBBreakpoint::GetBreakpointEventTypeFromEvent(const SBEvent &event) {
+ LLDB_RECORD_STATIC_METHOD(lldb::BreakpointEventType, SBBreakpoint,
+ GetBreakpointEventTypeFromEvent,
+ (const lldb::SBEvent &), event);
+
if (event.IsValid())
return Breakpoint::BreakpointEventData::GetBreakpointEventTypeFromEvent(
event.GetSP());
}
SBBreakpoint SBBreakpoint::GetBreakpointFromEvent(const lldb::SBEvent &event) {
+ LLDB_RECORD_STATIC_METHOD(lldb::SBBreakpoint, SBBreakpoint,
+ GetBreakpointFromEvent, (const lldb::SBEvent &),
+ event);
+
if (event.IsValid())
- return SBBreakpoint(
- Breakpoint::BreakpointEventData::GetBreakpointFromEvent(event.GetSP()));
- return SBBreakpoint();
+ return LLDB_RECORD_RESULT(
+ SBBreakpoint(Breakpoint::BreakpointEventData::GetBreakpointFromEvent(
+ event.GetSP())));
+ return LLDB_RECORD_RESULT(SBBreakpoint());
}
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);
+
SBBreakpointLocation sb_breakpoint_loc;
if (event.IsValid())
sb_breakpoint_loc.SetLocation(
Breakpoint::BreakpointEventData::GetBreakpointLocationAtIndexFromEvent(
event.GetSP(), loc_idx));
- return sb_breakpoint_loc;
+ return LLDB_RECORD_RESULT(sb_breakpoint_loc);
}
uint32_t
SBBreakpoint::GetNumBreakpointLocationsFromEvent(const lldb::SBEvent &event) {
+ LLDB_RECORD_STATIC_METHOD(uint32_t, SBBreakpoint,
+ GetNumBreakpointLocationsFromEvent,
+ (const lldb::SBEvent &), event);
+
uint32_t num_locations = 0;
if (event.IsValid())
num_locations =
}
bool SBBreakpoint::IsHardware() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, IsHardware);
+
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp)
return bkpt_sp->IsHardware();
};
SBBreakpointList::SBBreakpointList(SBTarget &target)
- : m_opaque_sp(new SBBreakpointListImpl(target.GetSP())) {}
+ : m_opaque_sp(new SBBreakpointListImpl(target.GetSP())) {
+ LLDB_RECORD_CONSTRUCTOR(SBBreakpointList, (lldb::SBTarget &), target);
+}
SBBreakpointList::~SBBreakpointList() {}
size_t SBBreakpointList::GetSize() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBBreakpointList, GetSize);
+
if (!m_opaque_sp)
return 0;
else
}
SBBreakpoint SBBreakpointList::GetBreakpointAtIndex(size_t idx) {
+ LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBBreakpointList, GetBreakpointAtIndex,
+ (size_t), idx);
+
if (!m_opaque_sp)
- return SBBreakpoint();
+ return LLDB_RECORD_RESULT(SBBreakpoint());
BreakpointSP bkpt_sp = m_opaque_sp->GetBreakpointAtIndex(idx);
- return SBBreakpoint(bkpt_sp);
+ return LLDB_RECORD_RESULT(SBBreakpoint(bkpt_sp));
}
SBBreakpoint SBBreakpointList::FindBreakpointByID(lldb::break_id_t id) {
+ LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBBreakpointList, FindBreakpointByID,
+ (lldb::break_id_t), id);
+
if (!m_opaque_sp)
- return SBBreakpoint();
+ return LLDB_RECORD_RESULT(SBBreakpoint());
BreakpointSP bkpt_sp = m_opaque_sp->FindBreakpointByID(id);
- return SBBreakpoint(bkpt_sp);
+ return LLDB_RECORD_RESULT(SBBreakpoint(bkpt_sp));
}
void SBBreakpointList::Append(const SBBreakpoint &sb_bkpt) {
+ LLDB_RECORD_METHOD(void, SBBreakpointList, Append,
+ (const lldb::SBBreakpoint &), sb_bkpt);
+
if (!sb_bkpt.IsValid())
return;
if (!m_opaque_sp)
}
void SBBreakpointList::AppendByID(lldb::break_id_t id) {
+ LLDB_RECORD_METHOD(void, SBBreakpointList, AppendByID, (lldb::break_id_t),
+ id);
+
if (!m_opaque_sp)
return;
m_opaque_sp->AppendByID(id);
}
bool SBBreakpointList::AppendIfUnique(const SBBreakpoint &sb_bkpt) {
+ LLDB_RECORD_METHOD(bool, SBBreakpointList, AppendIfUnique,
+ (const lldb::SBBreakpoint &), sb_bkpt);
+
if (!sb_bkpt.IsValid())
return false;
if (!m_opaque_sp)
}
void SBBreakpointList::Clear() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBBreakpointList, Clear);
+
if (m_opaque_sp)
m_opaque_sp->Clear();
}
//===----------------------------------------------------------------------===//
#include "lldb/API/SBBreakpointLocation.h"
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBDefines.h"
using namespace lldb;
using namespace lldb_private;
-SBBreakpointLocation::SBBreakpointLocation() {}
+SBBreakpointLocation::SBBreakpointLocation() {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBreakpointLocation);
+}
SBBreakpointLocation::SBBreakpointLocation(
const lldb::BreakpointLocationSP &break_loc_sp)
: m_opaque_wp(break_loc_sp) {
+ LLDB_RECORD_CONSTRUCTOR(SBBreakpointLocation,
+ (const lldb::BreakpointLocationSP &), break_loc_sp);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log) {
}
SBBreakpointLocation::SBBreakpointLocation(const SBBreakpointLocation &rhs)
- : m_opaque_wp(rhs.m_opaque_wp) {}
+ : m_opaque_wp(rhs.m_opaque_wp) {
+ LLDB_RECORD_CONSTRUCTOR(SBBreakpointLocation,
+ (const lldb::SBBreakpointLocation &), rhs);
+}
const SBBreakpointLocation &SBBreakpointLocation::
operator=(const SBBreakpointLocation &rhs) {
+ LLDB_RECORD_METHOD(
+ const lldb::SBBreakpointLocation &,
+ SBBreakpointLocation, operator=,(const lldb::SBBreakpointLocation &),
+ rhs);
+
m_opaque_wp = rhs.m_opaque_wp;
return *this;
}
return m_opaque_wp.lock();
}
-bool SBBreakpointLocation::IsValid() const { return bool(GetSP()); }
+bool SBBreakpointLocation::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointLocation, IsValid);
+
+ return bool(GetSP());
+}
SBAddress SBBreakpointLocation::GetAddress() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBBreakpointLocation, GetAddress);
+
BreakpointLocationSP loc_sp = GetSP();
- if (loc_sp)
- return SBAddress(&loc_sp->GetAddress());
- else
- return SBAddress();
+ if (loc_sp) {
+ return LLDB_RECORD_RESULT(SBAddress(&loc_sp->GetAddress()));
+ }
+
+ return LLDB_RECORD_RESULT(SBAddress());
}
addr_t SBBreakpointLocation::GetLoadAddress() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBBreakpointLocation,
+ GetLoadAddress);
+
addr_t ret_addr = LLDB_INVALID_ADDRESS;
BreakpointLocationSP loc_sp = GetSP();
}
void SBBreakpointLocation::SetEnabled(bool enabled) {
+ LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetEnabled, (bool), enabled);
+
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
std::lock_guard<std::recursive_mutex> guard(
}
bool SBBreakpointLocation::IsEnabled() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointLocation, IsEnabled);
+
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
std::lock_guard<std::recursive_mutex> guard(
}
uint32_t SBBreakpointLocation::GetHitCount() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBBreakpointLocation, GetHitCount);
+
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
std::lock_guard<std::recursive_mutex> guard(
}
uint32_t SBBreakpointLocation::GetIgnoreCount() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBBreakpointLocation, GetIgnoreCount);
+
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
std::lock_guard<std::recursive_mutex> guard(
}
void SBBreakpointLocation::SetIgnoreCount(uint32_t n) {
+ LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetIgnoreCount, (uint32_t), n);
+
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
std::lock_guard<std::recursive_mutex> guard(
}
void SBBreakpointLocation::SetCondition(const char *condition) {
+ LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetCondition, (const char *),
+ condition);
+
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
std::lock_guard<std::recursive_mutex> guard(
}
const char *SBBreakpointLocation::GetCondition() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBBreakpointLocation, GetCondition);
+
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
std::lock_guard<std::recursive_mutex> guard(
}
void SBBreakpointLocation::SetAutoContinue(bool auto_continue) {
+ LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetAutoContinue, (bool),
+ auto_continue);
+
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
std::lock_guard<std::recursive_mutex> guard(
}
bool SBBreakpointLocation::GetAutoContinue() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointLocation, GetAutoContinue);
+
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
std::lock_guard<std::recursive_mutex> guard(
void SBBreakpointLocation::SetScriptCallbackFunction(
const char *callback_function_name) {
+ LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetScriptCallbackFunction,
+ (const char *), callback_function_name);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointLocationSP loc_sp = GetSP();
LLDB_LOG(log, "location = {0}, callback = {1}", loc_sp.get(),
SBError
SBBreakpointLocation::SetScriptCallbackBody(const char *callback_body_text) {
+ LLDB_RECORD_METHOD(lldb::SBError, SBBreakpointLocation, SetScriptCallbackBody,
+ (const char *), callback_body_text);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointLocationSP loc_sp = GetSP();
LLDB_LOG(log, "location = {0}: callback body:\n{1}", loc_sp.get(),
} else
sb_error.SetErrorString("invalid breakpoint");
- return sb_error;
+ return LLDB_RECORD_RESULT(sb_error);
}
void SBBreakpointLocation::SetCommandLineCommands(SBStringList &commands) {
+ LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetCommandLineCommands,
+ (lldb::SBStringList &), commands);
+
BreakpointLocationSP loc_sp = GetSP();
if (!loc_sp)
return;
}
bool SBBreakpointLocation::GetCommandLineCommands(SBStringList &commands) {
+ LLDB_RECORD_METHOD(bool, SBBreakpointLocation, GetCommandLineCommands,
+ (lldb::SBStringList &), commands);
+
BreakpointLocationSP loc_sp = GetSP();
if (!loc_sp)
return false;
}
void SBBreakpointLocation::SetThreadID(tid_t thread_id) {
+ LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetThreadID, (lldb::tid_t),
+ thread_id);
+
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
std::lock_guard<std::recursive_mutex> guard(
}
tid_t SBBreakpointLocation::GetThreadID() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBBreakpointLocation, GetThreadID);
+
tid_t tid = LLDB_INVALID_THREAD_ID;
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
}
void SBBreakpointLocation::SetThreadIndex(uint32_t index) {
+ LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetThreadIndex, (uint32_t),
+ index);
+
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
std::lock_guard<std::recursive_mutex> guard(
}
uint32_t SBBreakpointLocation::GetThreadIndex() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointLocation,
+ GetThreadIndex);
+
uint32_t thread_idx = UINT32_MAX;
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
}
void SBBreakpointLocation::SetThreadName(const char *thread_name) {
+ LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetThreadName, (const char *),
+ thread_name);
+
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
std::lock_guard<std::recursive_mutex> guard(
}
const char *SBBreakpointLocation::GetThreadName() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointLocation,
+ GetThreadName);
+
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
std::lock_guard<std::recursive_mutex> guard(
}
void SBBreakpointLocation::SetQueueName(const char *queue_name) {
+ LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetQueueName, (const char *),
+ queue_name);
+
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
std::lock_guard<std::recursive_mutex> guard(
}
const char *SBBreakpointLocation::GetQueueName() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointLocation,
+ GetQueueName);
+
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
std::lock_guard<std::recursive_mutex> guard(
}
bool SBBreakpointLocation::IsResolved() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointLocation, IsResolved);
+
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
std::lock_guard<std::recursive_mutex> guard(
bool SBBreakpointLocation::GetDescription(SBStream &description,
DescriptionLevel level) {
+ LLDB_RECORD_METHOD(bool, SBBreakpointLocation, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel), description,
+ level);
+
Stream &strm = description.ref();
BreakpointLocationSP loc_sp = GetSP();
}
break_id_t SBBreakpointLocation::GetID() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::break_id_t, SBBreakpointLocation, GetID);
+
BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) {
std::lock_guard<std::recursive_mutex> guard(
}
SBBreakpoint SBBreakpointLocation::GetBreakpoint() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBreakpoint, SBBreakpointLocation,
+ GetBreakpoint);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointLocationSP loc_sp = GetSP();
LLDB_LOG(log, "location = {0}, breakpoint = {1} ({2})", loc_sp.get(),
sb_bp.GetSP().get(), sstr.GetData());
}
- return sb_bp;
+ return LLDB_RECORD_RESULT(sb_bp);
}
//===----------------------------------------------------------------------===//
#include "lldb/API/SBBreakpointName.h"
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBError.h"
#include "lldb/API/SBStream.h"
} // namespace lldb
-SBBreakpointName::SBBreakpointName() {}
+SBBreakpointName::SBBreakpointName() {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBreakpointName);
+}
+
+SBBreakpointName::SBBreakpointName(SBTarget &sb_target, const char *name) {
+ LLDB_RECORD_CONSTRUCTOR(SBBreakpointName, (lldb::SBTarget &, const char *),
+ sb_target, name);
-SBBreakpointName::SBBreakpointName(SBTarget &sb_target, const char *name)
-{
m_impl_up.reset(new SBBreakpointNameImpl(sb_target, name));
// Call FindBreakpointName here to make sure the name is valid, reset if not:
BreakpointName *bp_name = GetBreakpointName();
m_impl_up.reset();
}
-SBBreakpointName::SBBreakpointName(SBBreakpoint &sb_bkpt, const char *name)
-{
+SBBreakpointName::SBBreakpointName(SBBreakpoint &sb_bkpt, const char *name) {
+ LLDB_RECORD_CONSTRUCTOR(SBBreakpointName,
+ (lldb::SBBreakpoint &, const char *), sb_bkpt, name);
+
if (!sb_bkpt.IsValid()) {
m_impl_up.reset();
return;
BreakpointName::Permissions());
}
-SBBreakpointName::SBBreakpointName(const SBBreakpointName &rhs)
-{
+SBBreakpointName::SBBreakpointName(const SBBreakpointName &rhs) {
+ LLDB_RECORD_CONSTRUCTOR(SBBreakpointName, (const lldb::SBBreakpointName &),
+ rhs);
+
if (!rhs.m_impl_up)
return;
else
SBBreakpointName::~SBBreakpointName() = default;
-const SBBreakpointName &SBBreakpointName::operator=(const SBBreakpointName &rhs)
-{
+const SBBreakpointName &SBBreakpointName::
+operator=(const SBBreakpointName &rhs) {
+ LLDB_RECORD_METHOD(
+ const lldb::SBBreakpointName &,
+ SBBreakpointName, operator=,(const lldb::SBBreakpointName &), rhs);
+
if (!rhs.m_impl_up) {
m_impl_up.reset();
return *this;
}
bool SBBreakpointName::operator==(const lldb::SBBreakpointName &rhs) {
+ LLDB_RECORD_METHOD(
+ bool, SBBreakpointName, operator==,(const lldb::SBBreakpointName &), rhs);
+
return *m_impl_up == *rhs.m_impl_up;
}
bool SBBreakpointName::operator!=(const lldb::SBBreakpointName &rhs) {
+ LLDB_RECORD_METHOD(
+ bool, SBBreakpointName, operator!=,(const lldb::SBBreakpointName &), rhs);
+
return *m_impl_up != *rhs.m_impl_up;
}
bool SBBreakpointName::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, IsValid);
+
if (!m_impl_up)
return false;
return m_impl_up->IsValid();
}
const char *SBBreakpointName::GetName() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName, GetName);
+
if (!m_impl_up)
return "<Invalid Breakpoint Name Object>";
return m_impl_up->GetName();
}
void SBBreakpointName::SetEnabled(bool enable) {
+ LLDB_RECORD_METHOD(void, SBBreakpointName, SetEnabled, (bool), enable);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointName *bp_name = GetBreakpointName();
}
bool SBBreakpointName::IsEnabled() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, IsEnabled);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointName *bp_name = GetBreakpointName();
}
void SBBreakpointName::SetOneShot(bool one_shot) {
+ LLDB_RECORD_METHOD(void, SBBreakpointName, SetOneShot, (bool), one_shot);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointName *bp_name = GetBreakpointName();
}
bool SBBreakpointName::IsOneShot() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, IsOneShot);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
const BreakpointName *bp_name = GetBreakpointName();
}
void SBBreakpointName::SetIgnoreCount(uint32_t count) {
+ LLDB_RECORD_METHOD(void, SBBreakpointName, SetIgnoreCount, (uint32_t), count);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointName *bp_name = GetBreakpointName();
}
uint32_t SBBreakpointName::GetIgnoreCount() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointName, GetIgnoreCount);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointName *bp_name = GetBreakpointName();
}
void SBBreakpointName::SetCondition(const char *condition) {
+ LLDB_RECORD_METHOD(void, SBBreakpointName, SetCondition, (const char *),
+ condition);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointName *bp_name = GetBreakpointName();
}
const char *SBBreakpointName::GetCondition() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBBreakpointName, GetCondition);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointName *bp_name = GetBreakpointName();
}
void SBBreakpointName::SetAutoContinue(bool auto_continue) {
+ LLDB_RECORD_METHOD(void, SBBreakpointName, SetAutoContinue, (bool),
+ auto_continue);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointName *bp_name = GetBreakpointName();
}
bool SBBreakpointName::GetAutoContinue() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAutoContinue);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointName *bp_name = GetBreakpointName();
}
void SBBreakpointName::SetThreadID(tid_t tid) {
+ LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadID, (lldb::tid_t), tid);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointName *bp_name = GetBreakpointName();
}
tid_t SBBreakpointName::GetThreadID() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBBreakpointName, GetThreadID);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointName *bp_name = GetBreakpointName();
}
void SBBreakpointName::SetThreadIndex(uint32_t index) {
+ LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadIndex, (uint32_t), index);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointName *bp_name = GetBreakpointName();
}
uint32_t SBBreakpointName::GetThreadIndex() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointName, GetThreadIndex);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointName *bp_name = GetBreakpointName();
}
void SBBreakpointName::SetThreadName(const char *thread_name) {
+ LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadName, (const char *),
+ thread_name);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointName *bp_name = GetBreakpointName();
}
const char *SBBreakpointName::GetThreadName() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName,
+ GetThreadName);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointName *bp_name = GetBreakpointName();
}
void SBBreakpointName::SetQueueName(const char *queue_name) {
+ LLDB_RECORD_METHOD(void, SBBreakpointName, SetQueueName, (const char *),
+ queue_name);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointName *bp_name = GetBreakpointName();
}
const char *SBBreakpointName::GetQueueName() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName,
+ GetQueueName);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointName *bp_name = GetBreakpointName();
}
void SBBreakpointName::SetCommandLineCommands(SBStringList &commands) {
+ LLDB_RECORD_METHOD(void, SBBreakpointName, SetCommandLineCommands,
+ (lldb::SBStringList &), commands);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
}
bool SBBreakpointName::GetCommandLineCommands(SBStringList &commands) {
+ LLDB_RECORD_METHOD(bool, SBBreakpointName, GetCommandLineCommands,
+ (lldb::SBStringList &), commands);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointName *bp_name = GetBreakpointName();
}
const char *SBBreakpointName::GetHelpString() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName,
+ GetHelpString);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointName *bp_name = GetBreakpointName();
}
void SBBreakpointName::SetHelpString(const char *help_string) {
+ LLDB_RECORD_METHOD(void, SBBreakpointName, SetHelpString, (const char *),
+ help_string);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
}
bool SBBreakpointName::GetDescription(SBStream &s) {
+ LLDB_RECORD_METHOD(bool, SBBreakpointName, GetDescription, (lldb::SBStream &),
+ s);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointName *bp_name = GetBreakpointName();
void SBBreakpointName::SetScriptCallbackFunction(
const char *callback_function_name) {
+ LLDB_RECORD_METHOD(void, SBBreakpointName, SetScriptCallbackFunction,
+ (const char *), callback_function_name);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointName *bp_name = GetBreakpointName();
UpdateName(*bp_name);
}
-SBError SBBreakpointName::SetScriptCallbackBody(const char *callback_body_text)
-{
+SBError
+SBBreakpointName::SetScriptCallbackBody(const char *callback_body_text) {
+ LLDB_RECORD_METHOD(lldb::SBError, SBBreakpointName, SetScriptCallbackBody,
+ (const char *), callback_body_text);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBError sb_error;
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
- return sb_error;
-
+ return LLDB_RECORD_RESULT(sb_error);
+
LLDB_LOG(log, "Name: {0} callback: {1}\n", bp_name->GetName(),
callback_body_text);
if (!sb_error.Fail())
UpdateName(*bp_name);
- return sb_error;
+ return LLDB_RECORD_RESULT(sb_error);
}
-bool SBBreakpointName::GetAllowList() const
-{
+bool SBBreakpointName::GetAllowList() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, GetAllowList);
+
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
return false;
return bp_name->GetPermissions().GetAllowList();
}
-void SBBreakpointName::SetAllowList(bool value)
-{
+void SBBreakpointName::SetAllowList(bool value) {
+ LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowList, (bool), value);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointName *bp_name = GetBreakpointName();
bp_name->GetName().AsCString());
bp_name->GetPermissions().SetAllowList(value);
}
-
-bool SBBreakpointName::GetAllowDelete()
-{
+
+bool SBBreakpointName::GetAllowDelete() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAllowDelete);
+
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
return false;
return bp_name->GetPermissions().GetAllowDelete();
}
-void SBBreakpointName::SetAllowDelete(bool value)
-{
+void SBBreakpointName::SetAllowDelete(bool value) {
+ LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowDelete, (bool), value);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointName *bp_name = GetBreakpointName();
bp_name->GetName().AsCString());
bp_name->GetPermissions().SetAllowDelete(value);
}
-
-bool SBBreakpointName::GetAllowDisable()
-{
+
+bool SBBreakpointName::GetAllowDisable() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAllowDisable);
+
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
return false;
return bp_name->GetPermissions().GetAllowDisable();
}
-void SBBreakpointName::SetAllowDisable(bool value)
-{
+void SBBreakpointName::SetAllowDisable(bool value) {
+ LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowDisable, (bool), value);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointName *bp_name = GetBreakpointName();
//
//===----------------------------------------------------------------------===//
+#include "SBReproducerPrivate.h"
#include "lldb/Utility/Broadcaster.h"
#include "lldb/Utility/Log.h"
using namespace lldb;
using namespace lldb_private;
-SBBroadcaster::SBBroadcaster() : m_opaque_sp(), m_opaque_ptr(NULL) {}
+SBBroadcaster::SBBroadcaster() : m_opaque_sp(), m_opaque_ptr(NULL) {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBroadcaster);
+}
SBBroadcaster::SBBroadcaster(const char *name)
: m_opaque_sp(new Broadcaster(NULL, name)), m_opaque_ptr(NULL) {
+ LLDB_RECORD_CONSTRUCTOR(SBBroadcaster, (const char *), name);
+
m_opaque_ptr = m_opaque_sp.get();
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
LLDB_LOGV(log, "(name=\"{0}\") => SBBroadcaster({1})", name, m_opaque_ptr);
}
SBBroadcaster::SBBroadcaster(const SBBroadcaster &rhs)
- : m_opaque_sp(rhs.m_opaque_sp), m_opaque_ptr(rhs.m_opaque_ptr) {}
+ : m_opaque_sp(rhs.m_opaque_sp), m_opaque_ptr(rhs.m_opaque_ptr) {
+ LLDB_RECORD_CONSTRUCTOR(SBBroadcaster, (const lldb::SBBroadcaster &), rhs);
+}
const SBBroadcaster &SBBroadcaster::operator=(const SBBroadcaster &rhs) {
+ LLDB_RECORD_METHOD(const lldb::SBBroadcaster &,
+ SBBroadcaster, operator=,(const lldb::SBBroadcaster &),
+ rhs);
+
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
m_opaque_ptr = rhs.m_opaque_ptr;
SBBroadcaster::~SBBroadcaster() { reset(NULL, false); }
void SBBroadcaster::BroadcastEventByType(uint32_t event_type, bool unique) {
+ LLDB_RECORD_METHOD(void, SBBroadcaster, BroadcastEventByType,
+ (uint32_t, bool), event_type, unique);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
}
void SBBroadcaster::BroadcastEvent(const SBEvent &event, bool unique) {
+ LLDB_RECORD_METHOD(void, SBBroadcaster, BroadcastEvent,
+ (const lldb::SBEvent &, bool), event, unique);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
void SBBroadcaster::AddInitialEventsToListener(const SBListener &listener,
uint32_t requested_events) {
+ LLDB_RECORD_METHOD(void, SBBroadcaster, AddInitialEventsToListener,
+ (const lldb::SBListener &, uint32_t), listener,
+ requested_events);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
log->Printf("SBBroadcaster(%p)::AddInitialEventsToListener "
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);
+
if (m_opaque_ptr)
return m_opaque_ptr->AddListener(listener.m_opaque_sp, event_mask);
return 0;
}
const char *SBBroadcaster::GetName() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBroadcaster, GetName);
+
if (m_opaque_ptr)
return m_opaque_ptr->GetBroadcasterName().GetCString();
return NULL;
}
bool SBBroadcaster::EventTypeHasListeners(uint32_t event_type) {
+ LLDB_RECORD_METHOD(bool, SBBroadcaster, EventTypeHasListeners, (uint32_t),
+ event_type);
+
if (m_opaque_ptr)
return m_opaque_ptr->EventTypeHasListeners(event_type);
return false;
bool SBBroadcaster::RemoveListener(const SBListener &listener,
uint32_t event_mask) {
+ LLDB_RECORD_METHOD(bool, SBBroadcaster, RemoveListener,
+ (const lldb::SBListener &, uint32_t), listener,
+ event_mask);
+
if (m_opaque_ptr)
return m_opaque_ptr->RemoveListener(listener.m_opaque_sp, event_mask);
return false;
m_opaque_ptr = broadcaster;
}
-bool SBBroadcaster::IsValid() const { return m_opaque_ptr != NULL; }
+bool SBBroadcaster::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBroadcaster, IsValid);
+
+ return m_opaque_ptr != NULL;
+}
void SBBroadcaster::Clear() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBBroadcaster, Clear);
+
m_opaque_sp.reset();
m_opaque_ptr = NULL;
}
bool SBBroadcaster::operator==(const SBBroadcaster &rhs) const {
+ LLDB_RECORD_METHOD_CONST(
+ bool, SBBroadcaster, operator==,(const lldb::SBBroadcaster &), rhs);
+
return m_opaque_ptr == rhs.m_opaque_ptr;
}
bool SBBroadcaster::operator!=(const SBBroadcaster &rhs) const {
+ LLDB_RECORD_METHOD_CONST(
+ bool, SBBroadcaster, operator!=,(const lldb::SBBroadcaster &), rhs);
+
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);
+
return m_opaque_ptr < rhs.m_opaque_ptr;
}
#include "lldb/lldb-types.h"
+#include "SBReproducerPrivate.h"
#include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/CommandObjectMultiword.h"
#include "lldb/Interpreter/CommandReturnObject.h"
using namespace lldb_private;
SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions() {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommandInterpreterRunOptions);
+
m_opaque_up.reset(new CommandInterpreterRunOptions());
}
SBCommandInterpreterRunOptions::~SBCommandInterpreterRunOptions() = default;
bool SBCommandInterpreterRunOptions::GetStopOnContinue() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
+ GetStopOnContinue);
+
return m_opaque_up->GetStopOnContinue();
}
void SBCommandInterpreterRunOptions::SetStopOnContinue(bool stop_on_continue) {
+ LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnContinue,
+ (bool), stop_on_continue);
+
m_opaque_up->SetStopOnContinue(stop_on_continue);
}
bool SBCommandInterpreterRunOptions::GetStopOnError() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
+ GetStopOnError);
+
return m_opaque_up->GetStopOnError();
}
void SBCommandInterpreterRunOptions::SetStopOnError(bool stop_on_error) {
+ LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnError,
+ (bool), stop_on_error);
+
m_opaque_up->SetStopOnError(stop_on_error);
}
bool SBCommandInterpreterRunOptions::GetStopOnCrash() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
+ GetStopOnCrash);
+
return m_opaque_up->GetStopOnCrash();
}
void SBCommandInterpreterRunOptions::SetStopOnCrash(bool stop_on_crash) {
+ LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnCrash,
+ (bool), stop_on_crash);
+
m_opaque_up->SetStopOnCrash(stop_on_crash);
}
bool SBCommandInterpreterRunOptions::GetEchoCommands() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
+ GetEchoCommands);
+
return m_opaque_up->GetEchoCommands();
}
void SBCommandInterpreterRunOptions::SetEchoCommands(bool echo_commands) {
+ LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetEchoCommands,
+ (bool), echo_commands);
+
m_opaque_up->SetEchoCommands(echo_commands);
}
bool SBCommandInterpreterRunOptions::GetEchoCommentCommands() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
+ GetEchoCommentCommands);
+
return m_opaque_up->GetEchoCommentCommands();
}
void SBCommandInterpreterRunOptions::SetEchoCommentCommands(bool echo) {
+ LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions,
+ SetEchoCommentCommands, (bool), echo);
+
m_opaque_up->SetEchoCommentCommands(echo);
}
bool SBCommandInterpreterRunOptions::GetPrintResults() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
+ GetPrintResults);
+
return m_opaque_up->GetPrintResults();
}
void SBCommandInterpreterRunOptions::SetPrintResults(bool print_results) {
+ LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetPrintResults,
+ (bool), print_results);
+
m_opaque_up->SetPrintResults(print_results);
}
bool SBCommandInterpreterRunOptions::GetAddToHistory() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
+ GetAddToHistory);
+
return m_opaque_up->GetAddToHistory();
}
void SBCommandInterpreterRunOptions::SetAddToHistory(bool add_to_history) {
+ LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetAddToHistory,
+ (bool), add_to_history);
+
m_opaque_up->SetAddToHistory(add_to_history);
}
SBCommandInterpreter::SBCommandInterpreter(CommandInterpreter *interpreter)
: m_opaque_ptr(interpreter) {
+ LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreter,
+ (lldb_private::CommandInterpreter *), interpreter);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
}
SBCommandInterpreter::SBCommandInterpreter(const SBCommandInterpreter &rhs)
- : m_opaque_ptr(rhs.m_opaque_ptr) {}
+ : m_opaque_ptr(rhs.m_opaque_ptr) {
+ LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreter,
+ (const lldb::SBCommandInterpreter &), rhs);
+}
SBCommandInterpreter::~SBCommandInterpreter() = default;
const SBCommandInterpreter &SBCommandInterpreter::
operator=(const SBCommandInterpreter &rhs) {
+ LLDB_RECORD_METHOD(
+ const lldb::SBCommandInterpreter &,
+ SBCommandInterpreter, operator=,(const lldb::SBCommandInterpreter &),
+ rhs);
+
m_opaque_ptr = rhs.m_opaque_ptr;
return *this;
}
-bool SBCommandInterpreter::IsValid() const { return m_opaque_ptr != nullptr; }
+bool SBCommandInterpreter::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, IsValid);
+
+ return m_opaque_ptr != nullptr;
+}
bool SBCommandInterpreter::CommandExists(const char *cmd) {
+ LLDB_RECORD_METHOD(bool, SBCommandInterpreter, CommandExists, (const char *),
+ cmd);
+
return (((cmd != nullptr) && IsValid()) ? m_opaque_ptr->CommandExists(cmd)
: false);
}
bool SBCommandInterpreter::AliasExists(const char *cmd) {
+ LLDB_RECORD_METHOD(bool, SBCommandInterpreter, AliasExists, (const char *),
+ cmd);
+
return (((cmd != nullptr) && IsValid()) ? m_opaque_ptr->AliasExists(cmd)
: false);
}
bool SBCommandInterpreter::IsActive() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, IsActive);
+
return (IsValid() ? m_opaque_ptr->IsActive() : false);
}
bool SBCommandInterpreter::WasInterrupted() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, WasInterrupted);
+
return (IsValid() ? m_opaque_ptr->WasInterrupted() : false);
}
const char *SBCommandInterpreter::GetIOHandlerControlSequence(char ch) {
+ LLDB_RECORD_METHOD(const char *, SBCommandInterpreter,
+ GetIOHandlerControlSequence, (char), ch);
+
return (IsValid()
? m_opaque_ptr->GetDebugger()
.GetTopIOHandlerControlSequence(ch)
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);
+
SBExecutionContext sb_exe_ctx;
return HandleCommand(command_line, sb_exe_ctx, result, add_to_history);
}
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);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
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);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log) {
int SBCommandInterpreter::HandleCompletion(
const char *current_line, const char *cursor, const char *last_char,
int match_start_point, int max_return_elements, SBStringList &matches) {
+ LLDB_RECORD_METHOD(int, SBCommandInterpreter, HandleCompletion,
+ (const char *, const char *, const char *, int, int,
+ lldb::SBStringList &),
+ current_line, cursor, last_char, match_start_point,
+ max_return_elements, matches);
+
SBStringList dummy_descriptions;
return HandleCompletionWithDescriptions(
current_line, cursor, last_char, match_start_point, max_return_elements,
const char *current_line, const char *cursor, const char *last_char,
int match_start_point, int max_return_elements, SBStringList &matches,
SBStringList &descriptions) {
+ LLDB_RECORD_METHOD(int, SBCommandInterpreter,
+ HandleCompletionWithDescriptions,
+ (const char *, const char *, const char *, int, int,
+ lldb::SBStringList &, lldb::SBStringList &),
+ current_line, cursor, last_char, match_start_point,
+ max_return_elements, matches, descriptions);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
int num_completions = 0;
const char *current_line, uint32_t cursor_pos, int match_start_point,
int max_return_elements, SBStringList &matches,
SBStringList &descriptions) {
+ LLDB_RECORD_METHOD(int, SBCommandInterpreter,
+ HandleCompletionWithDescriptions,
+ (const char *, uint32_t, int, int, lldb::SBStringList &,
+ lldb::SBStringList &),
+ current_line, cursor_pos, match_start_point,
+ max_return_elements, matches, descriptions);
+
const char *cursor = current_line + cursor_pos;
const char *last_char = current_line + strlen(current_line);
return HandleCompletionWithDescriptions(
int match_start_point,
int max_return_elements,
lldb::SBStringList &matches) {
+ LLDB_RECORD_METHOD(int, SBCommandInterpreter, HandleCompletion,
+ (const char *, uint32_t, int, int, lldb::SBStringList &),
+ current_line, cursor_pos, match_start_point,
+ max_return_elements, matches);
+
const char *cursor = current_line + cursor_pos;
const char *last_char = current_line + strlen(current_line);
return HandleCompletion(current_line, cursor, last_char, match_start_point,
}
bool SBCommandInterpreter::HasCommands() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasCommands);
+
return (IsValid() ? m_opaque_ptr->HasCommands() : false);
}
bool SBCommandInterpreter::HasAliases() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasAliases);
+
return (IsValid() ? m_opaque_ptr->HasAliases() : false);
}
bool SBCommandInterpreter::HasAliasOptions() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasAliasOptions);
+
return (IsValid() ? m_opaque_ptr->HasAliasOptions() : false);
}
SBProcess SBCommandInterpreter::GetProcess() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBCommandInterpreter, GetProcess);
+
SBProcess sb_process;
ProcessSP process_sp;
if (IsValid()) {
static_cast<void *>(m_opaque_ptr),
static_cast<void *>(process_sp.get()));
- return sb_process;
+ return LLDB_RECORD_RESULT(sb_process);
}
SBDebugger SBCommandInterpreter::GetDebugger() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBDebugger, SBCommandInterpreter,
+ GetDebugger);
+
SBDebugger sb_debugger;
if (IsValid())
sb_debugger.reset(m_opaque_ptr->GetDebugger().shared_from_this());
static_cast<void *>(m_opaque_ptr),
static_cast<void *>(sb_debugger.get()));
- return sb_debugger;
+ return LLDB_RECORD_RESULT(sb_debugger);
}
bool SBCommandInterpreter::GetPromptOnQuit() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, GetPromptOnQuit);
+
return (IsValid() ? m_opaque_ptr->GetPromptOnQuit() : false);
}
void SBCommandInterpreter::SetPromptOnQuit(bool b) {
+ LLDB_RECORD_METHOD(void, SBCommandInterpreter, SetPromptOnQuit, (bool), b);
+
if (IsValid())
m_opaque_ptr->SetPromptOnQuit(b);
}
void SBCommandInterpreter::AllowExitCodeOnQuit(bool allow) {
+ LLDB_RECORD_METHOD(void, SBCommandInterpreter, AllowExitCodeOnQuit, (bool),
+ allow);
+
if (m_opaque_ptr)
m_opaque_ptr->AllowExitCodeOnQuit(allow);
}
bool SBCommandInterpreter::HasCustomQuitExitCode() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasCustomQuitExitCode);
+
bool exited = false;
if (m_opaque_ptr)
m_opaque_ptr->GetQuitExitCode(exited);
}
int SBCommandInterpreter::GetQuitStatus() {
+ LLDB_RECORD_METHOD_NO_ARGS(int, SBCommandInterpreter, GetQuitStatus);
+
bool exited = false;
return (m_opaque_ptr ? m_opaque_ptr->GetQuitExitCode(exited) : 0);
}
void SBCommandInterpreter::ResolveCommand(const char *command_line,
SBCommandReturnObject &result) {
+ LLDB_RECORD_METHOD(void, SBCommandInterpreter, ResolveCommand,
+ (const char *, lldb::SBCommandReturnObject &),
+ command_line, result);
+
result.Clear();
if (command_line && IsValid()) {
m_opaque_ptr->ResolveCommand(command_line, result.ref());
void SBCommandInterpreter::SourceInitFileInHomeDirectory(
SBCommandReturnObject &result) {
+ LLDB_RECORD_METHOD(void, SBCommandInterpreter, SourceInitFileInHomeDirectory,
+ (lldb::SBCommandReturnObject &), result);
+
result.Clear();
if (IsValid()) {
TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
void SBCommandInterpreter::SourceInitFileInCurrentWorkingDirectory(
SBCommandReturnObject &result) {
+ LLDB_RECORD_METHOD(void, SBCommandInterpreter,
+ SourceInitFileInCurrentWorkingDirectory,
+ (lldb::SBCommandReturnObject &), result);
+
result.Clear();
if (IsValid()) {
TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
}
SBBroadcaster SBCommandInterpreter::GetBroadcaster() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBroadcaster, SBCommandInterpreter,
+ GetBroadcaster);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBBroadcaster broadcaster(m_opaque_ptr, false);
static_cast<void *>(m_opaque_ptr),
static_cast<void *>(broadcaster.get()));
- return broadcaster;
+ return LLDB_RECORD_RESULT(broadcaster);
}
const char *SBCommandInterpreter::GetBroadcasterClass() {
+ LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBCommandInterpreter,
+ GetBroadcasterClass);
+
return CommandInterpreter::GetStaticBroadcasterClass().AsCString();
}
const char *SBCommandInterpreter::GetArgumentTypeAsCString(
const lldb::CommandArgumentType arg_type) {
+ LLDB_RECORD_STATIC_METHOD(const char *, SBCommandInterpreter,
+ GetArgumentTypeAsCString,
+ (const lldb::CommandArgumentType), arg_type);
+
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);
+
return CommandObject::GetArgumentDescriptionAsCString(arg_type);
}
bool SBCommandInterpreter::EventIsCommandInterpreterEvent(
const lldb::SBEvent &event) {
+ LLDB_RECORD_STATIC_METHOD(bool, SBCommandInterpreter,
+ EventIsCommandInterpreterEvent,
+ (const lldb::SBEvent &), event);
+
return event.GetBroadcasterClass() ==
SBCommandInterpreter::GetBroadcasterClass();
}
lldb::SBCommand SBCommandInterpreter::AddMultiwordCommand(const char *name,
const char *help) {
+ LLDB_RECORD_METHOD(lldb::SBCommand, SBCommandInterpreter, AddMultiwordCommand,
+ (const char *, const char *), name, help);
+
CommandObjectMultiword *new_command =
new CommandObjectMultiword(*m_opaque_ptr, name, help);
new_command->SetRemovable(true);
lldb::CommandObjectSP new_command_sp(new_command);
if (new_command_sp &&
m_opaque_ptr->AddUserCommand(name, new_command_sp, true))
- return lldb::SBCommand(new_command_sp);
- return lldb::SBCommand();
+ return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp));
+ return LLDB_RECORD_RESULT(lldb::SBCommand());
}
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::CommandObjectSP new_command_sp;
new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>(
*m_opaque_ptr, name, impl, help);
if (new_command_sp &&
m_opaque_ptr->AddUserCommand(name, new_command_sp, true))
- return lldb::SBCommand(new_command_sp);
- return lldb::SBCommand();
+ return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp));
+ return LLDB_RECORD_RESULT(lldb::SBCommand());
}
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::CommandObjectSP new_command_sp;
new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>(
*m_opaque_ptr, name, impl, help, syntax);
if (new_command_sp &&
m_opaque_ptr->AddUserCommand(name, new_command_sp, true))
- return lldb::SBCommand(new_command_sp);
- return lldb::SBCommand();
+ return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp));
+ return LLDB_RECORD_RESULT(lldb::SBCommand());
}
-SBCommand::SBCommand() = default;
+SBCommand::SBCommand() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommand); }
SBCommand::SBCommand(lldb::CommandObjectSP cmd_sp) : m_opaque_sp(cmd_sp) {}
-bool SBCommand::IsValid() { return m_opaque_sp.get() != nullptr; }
+bool SBCommand::IsValid() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommand, IsValid);
+
+ return m_opaque_sp.get() != nullptr;
+}
const char *SBCommand::GetName() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetName);
+
return (IsValid() ? ConstString(m_opaque_sp->GetCommandName()).AsCString() : nullptr);
}
const char *SBCommand::GetHelp() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetHelp);
+
return (IsValid() ? ConstString(m_opaque_sp->GetHelp()).AsCString()
: nullptr);
}
const char *SBCommand::GetHelpLong() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetHelpLong);
+
return (IsValid() ? ConstString(m_opaque_sp->GetHelpLong()).AsCString()
: nullptr);
}
void SBCommand::SetHelp(const char *help) {
+ LLDB_RECORD_METHOD(void, SBCommand, SetHelp, (const char *), help);
+
if (IsValid())
m_opaque_sp->SetHelp(help);
}
void SBCommand::SetHelpLong(const char *help) {
+ LLDB_RECORD_METHOD(void, SBCommand, SetHelpLong, (const char *), help);
+
if (IsValid())
m_opaque_sp->SetHelpLong(help);
}
lldb::SBCommand SBCommand::AddMultiwordCommand(const char *name,
const char *help) {
+ LLDB_RECORD_METHOD(lldb::SBCommand, SBCommand, AddMultiwordCommand,
+ (const char *, const char *), name, help);
+
if (!IsValid())
- return lldb::SBCommand();
+ return LLDB_RECORD_RESULT(lldb::SBCommand());
if (!m_opaque_sp->IsMultiwordObject())
- return lldb::SBCommand();
+ return LLDB_RECORD_RESULT(lldb::SBCommand());
CommandObjectMultiword *new_command = new CommandObjectMultiword(
m_opaque_sp->GetCommandInterpreter(), name, help);
new_command->SetRemovable(true);
lldb::CommandObjectSP new_command_sp(new_command);
if (new_command_sp && m_opaque_sp->LoadSubCommand(name, new_command_sp))
- return lldb::SBCommand(new_command_sp);
- return lldb::SBCommand();
+ return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp));
+ return LLDB_RECORD_RESULT(lldb::SBCommand());
}
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);
+
if (!IsValid())
- return lldb::SBCommand();
+ return LLDB_RECORD_RESULT(lldb::SBCommand());
if (!m_opaque_sp->IsMultiwordObject())
- return lldb::SBCommand();
+ return LLDB_RECORD_RESULT(lldb::SBCommand());
lldb::CommandObjectSP new_command_sp;
new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>(
m_opaque_sp->GetCommandInterpreter(), name, impl, help);
if (new_command_sp && m_opaque_sp->LoadSubCommand(name, new_command_sp))
- return lldb::SBCommand(new_command_sp);
- return lldb::SBCommand();
+ return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp));
+ return LLDB_RECORD_RESULT(lldb::SBCommand());
}
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);
+
if (!IsValid())
- return lldb::SBCommand();
+ return LLDB_RECORD_RESULT(lldb::SBCommand());
if (!m_opaque_sp->IsMultiwordObject())
- return lldb::SBCommand();
+ return LLDB_RECORD_RESULT(lldb::SBCommand());
lldb::CommandObjectSP new_command_sp;
new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>(
m_opaque_sp->GetCommandInterpreter(), name, impl, help, syntax);
if (new_command_sp && m_opaque_sp->LoadSubCommand(name, new_command_sp))
- return lldb::SBCommand(new_command_sp);
- return lldb::SBCommand();
+ return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp));
+ return LLDB_RECORD_RESULT(lldb::SBCommand());
}
uint32_t SBCommand::GetFlags() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBCommand, GetFlags);
+
return (IsValid() ? m_opaque_sp->GetFlags().Get() : 0);
}
void SBCommand::SetFlags(uint32_t flags) {
+ LLDB_RECORD_METHOD(void, SBCommand, SetFlags, (uint32_t), flags);
+
if (IsValid())
m_opaque_sp->GetFlags().Set(flags);
}
//===----------------------------------------------------------------------===//
#include "lldb/API/SBCommandReturnObject.h"
+#include "SBReproducerPrivate.h"
#include "Utils.h"
#include "lldb/API/SBError.h"
#include "lldb/API/SBStream.h"
using namespace lldb_private;
SBCommandReturnObject::SBCommandReturnObject()
- : m_opaque_up(new CommandReturnObject()) {}
+ : m_opaque_up(new CommandReturnObject()) {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommandReturnObject);
+}
SBCommandReturnObject::SBCommandReturnObject(const SBCommandReturnObject &rhs)
: m_opaque_up() {
+ LLDB_RECORD_CONSTRUCTOR(SBCommandReturnObject,
+ (const lldb::SBCommandReturnObject &), rhs);
+
m_opaque_up = clone(rhs.m_opaque_up);
}
SBCommandReturnObject::SBCommandReturnObject(CommandReturnObject *ptr)
- : m_opaque_up(ptr) {}
+ : m_opaque_up(ptr) {
+ LLDB_RECORD_CONSTRUCTOR(SBCommandReturnObject,
+ (lldb_private::CommandReturnObject *), ptr);
+}
SBCommandReturnObject::~SBCommandReturnObject() = default;
CommandReturnObject *SBCommandReturnObject::Release() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb_private::CommandReturnObject *,
+ SBCommandReturnObject, Release);
+
return m_opaque_up.release();
}
const SBCommandReturnObject &SBCommandReturnObject::
operator=(const SBCommandReturnObject &rhs) {
+ LLDB_RECORD_METHOD(
+ const lldb::SBCommandReturnObject &,
+ SBCommandReturnObject, operator=,(const lldb::SBCommandReturnObject &),
+ rhs);
+
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
return *this;
}
-bool SBCommandReturnObject::IsValid() const { return m_opaque_up != nullptr; }
+bool SBCommandReturnObject::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandReturnObject, IsValid);
+
+ return m_opaque_up != nullptr;
+}
const char *SBCommandReturnObject::GetOutput() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommandReturnObject, GetOutput);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (m_opaque_up) {
}
const char *SBCommandReturnObject::GetError() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommandReturnObject, GetError);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (m_opaque_up) {
}
size_t SBCommandReturnObject::GetOutputSize() {
+ LLDB_RECORD_METHOD_NO_ARGS(size_t, SBCommandReturnObject, GetOutputSize);
+
return (m_opaque_up ? m_opaque_up->GetOutputData().size() : 0);
}
size_t SBCommandReturnObject::GetErrorSize() {
+ LLDB_RECORD_METHOD_NO_ARGS(size_t, SBCommandReturnObject, GetErrorSize);
+
return (m_opaque_up ? m_opaque_up->GetErrorData().size() : 0);
}
size_t SBCommandReturnObject::PutOutput(FILE *fh) {
+ LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutOutput, (FILE *), fh);
+
if (fh) {
size_t num_bytes = GetOutputSize();
if (num_bytes)
}
size_t SBCommandReturnObject::PutError(FILE *fh) {
+ LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutError, (FILE *), fh);
+
if (fh) {
size_t num_bytes = GetErrorSize();
if (num_bytes)
}
void SBCommandReturnObject::Clear() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBCommandReturnObject, Clear);
+
if (m_opaque_up)
m_opaque_up->Clear();
}
lldb::ReturnStatus SBCommandReturnObject::GetStatus() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::ReturnStatus, SBCommandReturnObject,
+ GetStatus);
+
return (m_opaque_up ? m_opaque_up->GetStatus() : lldb::eReturnStatusInvalid);
}
void SBCommandReturnObject::SetStatus(lldb::ReturnStatus status) {
+ LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetStatus,
+ (lldb::ReturnStatus), status);
+
if (m_opaque_up)
m_opaque_up->SetStatus(status);
}
bool SBCommandReturnObject::Succeeded() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandReturnObject, Succeeded);
+
return (m_opaque_up ? m_opaque_up->Succeeded() : false);
}
bool SBCommandReturnObject::HasResult() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandReturnObject, HasResult);
+
return (m_opaque_up ? m_opaque_up->HasResult() : false);
}
void SBCommandReturnObject::AppendMessage(const char *message) {
+ LLDB_RECORD_METHOD(void, SBCommandReturnObject, AppendMessage, (const char *),
+ message);
+
if (m_opaque_up)
m_opaque_up->AppendMessage(message);
}
void SBCommandReturnObject::AppendWarning(const char *message) {
+ LLDB_RECORD_METHOD(void, SBCommandReturnObject, AppendWarning, (const char *),
+ message);
+
if (m_opaque_up)
m_opaque_up->AppendWarning(message);
}
}
bool SBCommandReturnObject::GetDescription(SBStream &description) {
+ LLDB_RECORD_METHOD(bool, SBCommandReturnObject, GetDescription,
+ (lldb::SBStream &), description);
+
Stream &strm = description.ref();
if (m_opaque_up) {
}
void SBCommandReturnObject::SetImmediateOutputFile(FILE *fh) {
+ LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
+ (FILE *), fh);
+
SetImmediateOutputFile(fh, false);
}
void SBCommandReturnObject::SetImmediateErrorFile(FILE *fh) {
+ LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
+ (FILE *), fh);
+
SetImmediateErrorFile(fh, false);
}
void SBCommandReturnObject::SetImmediateOutputFile(FILE *fh,
bool transfer_ownership) {
+ LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
+ (FILE *, bool), fh, transfer_ownership);
+
if (m_opaque_up)
m_opaque_up->SetImmediateOutputFile(fh, transfer_ownership);
}
void SBCommandReturnObject::SetImmediateErrorFile(FILE *fh,
bool transfer_ownership) {
+ LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
+ (FILE *, bool), fh, transfer_ownership);
+
if (m_opaque_up)
m_opaque_up->SetImmediateErrorFile(fh, transfer_ownership);
}
void SBCommandReturnObject::PutCString(const char *string, int len) {
+ LLDB_RECORD_METHOD(void, SBCommandReturnObject, PutCString,
+ (const char *, int), string, len);
+
if (m_opaque_up) {
if (len == 0 || string == nullptr || *string == 0) {
return;
}
const char *SBCommandReturnObject::GetOutput(bool only_if_no_immediate) {
+ LLDB_RECORD_METHOD(const char *, SBCommandReturnObject, GetOutput, (bool),
+ only_if_no_immediate);
+
if (!m_opaque_up)
return nullptr;
if (!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);
+
if (!m_opaque_up)
return nullptr;
if (!only_if_no_immediate ||
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);
+
if (m_opaque_up) {
if (error.IsValid())
m_opaque_up->SetError(error.ref(), fallback_error_cstr);
}
void SBCommandReturnObject::SetError(const char *error_cstr) {
+ LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetError, (const char *),
+ error_cstr);
+
if (m_opaque_up && error_cstr)
m_opaque_up->SetError(error_cstr);
}
//===----------------------------------------------------------------------===//
#include "lldb/API/SBCommunication.h"
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBBroadcaster.h"
#include "lldb/Core/Communication.h"
#include "lldb/Host/ConnectionFileDescriptor.h"
using namespace lldb;
using namespace lldb_private;
-SBCommunication::SBCommunication() : m_opaque(NULL), m_opaque_owned(false) {}
+SBCommunication::SBCommunication() : m_opaque(NULL), m_opaque_owned(false) {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommunication);
+}
SBCommunication::SBCommunication(const char *broadcaster_name)
: m_opaque(new Communication(broadcaster_name)), m_opaque_owned(true) {
+ LLDB_RECORD_CONSTRUCTOR(SBCommunication, (const char *), broadcaster_name);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
m_opaque_owned = false;
}
-bool SBCommunication::IsValid() const { return m_opaque != NULL; }
+bool SBCommunication::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommunication, IsValid);
+
+ return m_opaque != NULL;
+}
bool SBCommunication::GetCloseOnEOF() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, GetCloseOnEOF);
+
if (m_opaque)
return m_opaque->GetCloseOnEOF();
return false;
}
void SBCommunication::SetCloseOnEOF(bool b) {
+ LLDB_RECORD_METHOD(void, SBCommunication, SetCloseOnEOF, (bool), b);
+
if (m_opaque)
m_opaque->SetCloseOnEOF(b);
}
ConnectionStatus SBCommunication::Connect(const char *url) {
+ LLDB_RECORD_METHOD(lldb::ConnectionStatus, SBCommunication, Connect,
+ (const char *), url);
+
if (m_opaque) {
if (!m_opaque->HasConnection())
m_opaque->SetConnection(Host::CreateDefaultConnection(url).release());
}
ConnectionStatus SBCommunication::AdoptFileDesriptor(int fd, bool owns_fd) {
+ LLDB_RECORD_METHOD(lldb::ConnectionStatus, SBCommunication,
+ AdoptFileDesriptor, (int, bool), fd, owns_fd);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
ConnectionStatus status = eConnectionStatusNoConnection;
}
ConnectionStatus SBCommunication::Disconnect() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::ConnectionStatus, SBCommunication,
+ Disconnect);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
ConnectionStatus status = eConnectionStatusNoConnection;
}
bool SBCommunication::IsConnected() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommunication, IsConnected);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
bool result = false;
if (m_opaque)
}
bool SBCommunication::ReadThreadStart() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadStart);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
bool success = false;
}
bool SBCommunication::ReadThreadStop() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadStop);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
log->Printf("SBCommunication(%p)::ReadThreadStop ()...",
}
bool SBCommunication::ReadThreadIsRunning() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadIsRunning);
+
bool result = false;
if (m_opaque)
result = m_opaque->ReadThreadIsRunning();
}
SBBroadcaster SBCommunication::GetBroadcaster() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBroadcaster, SBCommunication,
+ GetBroadcaster);
+
SBBroadcaster broadcaster(m_opaque, false);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
static_cast<void *>(m_opaque),
static_cast<void *>(broadcaster.get()));
- return broadcaster;
+ return LLDB_RECORD_RESULT(broadcaster);
}
const char *SBCommunication::GetBroadcasterClass() {
+ LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBCommunication,
+ GetBroadcasterClass);
+
return Communication::GetStaticBroadcasterClass().AsCString();
}
//===----------------------------------------------------------------------===//
#include "lldb/API/SBCompileUnit.h"
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBLineEntry.h"
#include "lldb/API/SBStream.h"
#include "lldb/Core/Module.h"
using namespace lldb;
using namespace lldb_private;
-SBCompileUnit::SBCompileUnit() : m_opaque_ptr(NULL) {}
+SBCompileUnit::SBCompileUnit() : m_opaque_ptr(NULL) {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCompileUnit);
+}
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) {}
+ : m_opaque_ptr(rhs.m_opaque_ptr) {
+ LLDB_RECORD_CONSTRUCTOR(SBCompileUnit, (const lldb::SBCompileUnit &), rhs);
+}
const SBCompileUnit &SBCompileUnit::operator=(const SBCompileUnit &rhs) {
+ LLDB_RECORD_METHOD(const lldb::SBCompileUnit &,
+ SBCompileUnit, operator=,(const lldb::SBCompileUnit &),
+ rhs);
+
m_opaque_ptr = rhs.m_opaque_ptr;
return *this;
}
SBCompileUnit::~SBCompileUnit() { m_opaque_ptr = NULL; }
SBFileSpec SBCompileUnit::GetFileSpec() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBCompileUnit,
+ GetFileSpec);
+
SBFileSpec file_spec;
if (m_opaque_ptr)
file_spec.SetFileSpec(*m_opaque_ptr);
- return file_spec;
+ return LLDB_RECORD_RESULT(file_spec);
}
uint32_t SBCompileUnit::GetNumLineEntries() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBCompileUnit, GetNumLineEntries);
+
if (m_opaque_ptr) {
LineTable *line_table = m_opaque_ptr->GetLineTable();
if (line_table)
}
SBLineEntry SBCompileUnit::GetLineEntryAtIndex(uint32_t idx) const {
+ LLDB_RECORD_METHOD_CONST(lldb::SBLineEntry, SBCompileUnit,
+ GetLineEntryAtIndex, (uint32_t), idx);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBLineEntry sb_line_entry;
static_cast<void *>(sb_line_entry.get()), sstr.GetData());
}
- return sb_line_entry;
+ return LLDB_RECORD_RESULT(sb_line_entry);
}
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);
+
const bool exact = true;
return FindLineEntryIndex(start_idx, line, inline_file_spec, exact);
}
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);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
uint32_t index = UINT32_MAX;
}
uint32_t SBCompileUnit::GetNumSupportFiles() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBCompileUnit, GetNumSupportFiles);
+
if (m_opaque_ptr) {
FileSpecList &support_files = m_opaque_ptr->GetSupportFiles();
return support_files.GetSize();
}
lldb::SBTypeList SBCompileUnit::GetTypes(uint32_t type_mask) {
+ LLDB_RECORD_METHOD(lldb::SBTypeList, SBCompileUnit, GetTypes, (uint32_t),
+ type_mask);
+
SBTypeList sb_type_list;
if (!m_opaque_ptr)
- return sb_type_list;
+ return LLDB_RECORD_RESULT(sb_type_list);
ModuleSP module_sp(m_opaque_ptr->GetModule());
if (!module_sp)
- return sb_type_list;
+ return LLDB_RECORD_RESULT(sb_type_list);
SymbolVendor *vendor = module_sp->GetSymbolVendor();
if (!vendor)
- return sb_type_list;
+ return LLDB_RECORD_RESULT(sb_type_list);
TypeClass type_class = static_cast<TypeClass>(type_mask);
TypeList type_list;
vendor->GetTypes(m_opaque_ptr, type_class, type_list);
sb_type_list.m_opaque_up->Append(type_list);
- return sb_type_list;
+ return LLDB_RECORD_RESULT(sb_type_list);
}
SBFileSpec SBCompileUnit::GetSupportFileAtIndex(uint32_t idx) const {
+ LLDB_RECORD_METHOD_CONST(lldb::SBFileSpec, SBCompileUnit,
+ GetSupportFileAtIndex, (uint32_t), idx);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBFileSpec sb_file_spec;
static_cast<const void *>(sb_file_spec.get()), sstr.GetData());
}
- return sb_file_spec;
+ return LLDB_RECORD_RESULT(sb_file_spec);
}
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);
+
if (m_opaque_ptr) {
FileSpecList &support_files = m_opaque_ptr->GetSupportFiles();
return support_files.FindFileIndex(start_idx, sb_file.ref(), full);
}
lldb::LanguageType SBCompileUnit::GetLanguage() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::LanguageType, SBCompileUnit, GetLanguage);
+
if (m_opaque_ptr)
return m_opaque_ptr->GetLanguage();
return lldb::eLanguageTypeUnknown;
}
-bool SBCompileUnit::IsValid() const { return m_opaque_ptr != NULL; }
+bool SBCompileUnit::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCompileUnit, IsValid);
+
+ return m_opaque_ptr != NULL;
+}
bool SBCompileUnit::operator==(const SBCompileUnit &rhs) const {
+ LLDB_RECORD_METHOD_CONST(
+ bool, SBCompileUnit, operator==,(const lldb::SBCompileUnit &), rhs);
+
return m_opaque_ptr == rhs.m_opaque_ptr;
}
bool SBCompileUnit::operator!=(const SBCompileUnit &rhs) const {
+ LLDB_RECORD_METHOD_CONST(
+ bool, SBCompileUnit, operator!=,(const lldb::SBCompileUnit &), rhs);
+
return m_opaque_ptr != rhs.m_opaque_ptr;
}
}
bool SBCompileUnit::GetDescription(SBStream &description) {
+ LLDB_RECORD_METHOD(bool, SBCompileUnit, GetDescription, (lldb::SBStream &),
+ description);
+
Stream &strm = description.ref();
if (m_opaque_ptr) {
//===----------------------------------------------------------------------===//
#include "lldb/API/SBData.h"
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBError.h"
#include "lldb/API/SBStream.h"
using namespace lldb;
using namespace lldb_private;
-SBData::SBData() : m_opaque_sp(new DataExtractor()) {}
+SBData::SBData() : m_opaque_sp(new DataExtractor()) {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBData);
+}
SBData::SBData(const lldb::DataExtractorSP &data_sp) : m_opaque_sp(data_sp) {}
-SBData::SBData(const SBData &rhs) : m_opaque_sp(rhs.m_opaque_sp) {}
+SBData::SBData(const SBData &rhs) : m_opaque_sp(rhs.m_opaque_sp) {
+ LLDB_RECORD_CONSTRUCTOR(SBData, (const lldb::SBData &), rhs);
+}
const SBData &SBData::operator=(const SBData &rhs) {
+ LLDB_RECORD_METHOD(const lldb::SBData &,
+ SBData, operator=,(const lldb::SBData &), rhs);
+
if (this != &rhs)
m_opaque_sp = rhs.m_opaque_sp;
return *this;
const lldb::DataExtractorSP &SBData::operator*() const { return m_opaque_sp; }
-bool SBData::IsValid() { return m_opaque_sp.get() != NULL; }
+bool SBData::IsValid() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBData, IsValid);
+
+ return m_opaque_sp.get() != NULL;
+}
uint8_t SBData::GetAddressByteSize() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint8_t, SBData, GetAddressByteSize);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
uint8_t value = 0;
if (m_opaque_sp.get())
}
void SBData::SetAddressByteSize(uint8_t addr_byte_size) {
+ LLDB_RECORD_METHOD(void, SBData, SetAddressByteSize, (uint8_t),
+ addr_byte_size);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (m_opaque_sp.get())
m_opaque_sp->SetAddressByteSize(addr_byte_size);
}
void SBData::Clear() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBData, Clear);
+
if (m_opaque_sp.get())
m_opaque_sp->Clear();
}
size_t SBData::GetByteSize() {
+ LLDB_RECORD_METHOD_NO_ARGS(size_t, SBData, GetByteSize);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
size_t value = 0;
if (m_opaque_sp.get())
}
lldb::ByteOrder SBData::GetByteOrder() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::ByteOrder, SBData, GetByteOrder);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
lldb::ByteOrder value = eByteOrderInvalid;
if (m_opaque_sp.get())
}
void SBData::SetByteOrder(lldb::ByteOrder endian) {
+ LLDB_RECORD_METHOD(void, SBData, SetByteOrder, (lldb::ByteOrder), endian);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
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);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
float value = 0;
if (!m_opaque_sp.get()) {
}
double SBData::GetDouble(lldb::SBError &error, lldb::offset_t offset) {
+ LLDB_RECORD_METHOD(double, SBData, GetDouble,
+ (lldb::SBError &, lldb::offset_t), error, offset);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
double value = 0;
if (!m_opaque_sp.get()) {
}
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);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
long double value = 0;
if (!m_opaque_sp.get()) {
}
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);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
lldb::addr_t value = 0;
if (!m_opaque_sp.get()) {
}
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);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
uint8_t value = 0;
if (!m_opaque_sp.get()) {
}
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);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
uint16_t value = 0;
if (!m_opaque_sp.get()) {
}
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);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
uint32_t value = 0;
if (!m_opaque_sp.get()) {
}
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);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
uint64_t value = 0;
if (!m_opaque_sp.get()) {
}
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);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
int8_t value = 0;
if (!m_opaque_sp.get()) {
}
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);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
int16_t value = 0;
if (!m_opaque_sp.get()) {
}
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);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
int32_t value = 0;
if (!m_opaque_sp.get()) {
}
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);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
int64_t value = 0;
if (!m_opaque_sp.get()) {
}
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);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
const char *value = 0;
if (!m_opaque_sp.get()) {
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);
+
Stream &strm = description.ref();
if (m_opaque_sp) {
}
bool SBData::Append(const SBData &rhs) {
+ LLDB_RECORD_METHOD(bool, SBData, Append, (const lldb::SBData &), rhs);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
bool value = false;
if (m_opaque_sp.get() && rhs.m_opaque_sp.get())
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);
+
if (!data || !data[0])
- return SBData();
+ return LLDB_RECORD_RESULT(SBData());
uint32_t data_len = strlen(data);
SBData ret(data_sp);
- return ret;
+ return LLDB_RECORD_RESULT(ret);
}
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);
+
if (!array || array_len == 0)
- return SBData();
+ return LLDB_RECORD_RESULT(SBData());
size_t data_len = array_len * sizeof(uint64_t);
SBData ret(data_sp);
- return ret;
+ return LLDB_RECORD_RESULT(ret);
}
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);
+
if (!array || array_len == 0)
- return SBData();
+ return LLDB_RECORD_RESULT(SBData());
size_t data_len = array_len * sizeof(uint32_t);
SBData ret(data_sp);
- return ret;
+ return LLDB_RECORD_RESULT(ret);
}
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);
+
if (!array || array_len == 0)
- return SBData();
+ return LLDB_RECORD_RESULT(SBData());
size_t data_len = array_len * sizeof(int64_t);
SBData ret(data_sp);
- return ret;
+ return LLDB_RECORD_RESULT(ret);
}
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);
+
if (!array || array_len == 0)
- return SBData();
+ return LLDB_RECORD_RESULT(SBData());
size_t data_len = array_len * sizeof(int32_t);
SBData ret(data_sp);
- return ret;
+ return LLDB_RECORD_RESULT(ret);
}
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);
+
if (!array || array_len == 0)
- return SBData();
+ return LLDB_RECORD_RESULT(SBData());
size_t data_len = array_len * sizeof(double);
SBData ret(data_sp);
- return ret;
+ return LLDB_RECORD_RESULT(ret);
}
bool SBData::SetDataFromCString(const char *data) {
+ LLDB_RECORD_METHOD(bool, SBData, SetDataFromCString, (const char *), data);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (!data) {
}
bool SBData::SetDataFromUInt64Array(uint64_t *array, size_t array_len) {
+ LLDB_RECORD_METHOD(bool, SBData, SetDataFromUInt64Array, (uint64_t *, size_t),
+ array, array_len);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (!array || array_len == 0) {
}
bool SBData::SetDataFromUInt32Array(uint32_t *array, size_t array_len) {
+ LLDB_RECORD_METHOD(bool, SBData, SetDataFromUInt32Array, (uint32_t *, size_t),
+ array, array_len);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (!array || array_len == 0) {
}
bool SBData::SetDataFromSInt64Array(int64_t *array, size_t array_len) {
+ LLDB_RECORD_METHOD(bool, SBData, SetDataFromSInt64Array, (int64_t *, size_t),
+ array, array_len);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (!array || array_len == 0) {
}
bool SBData::SetDataFromSInt32Array(int32_t *array, size_t array_len) {
+ LLDB_RECORD_METHOD(bool, SBData, SetDataFromSInt32Array, (int32_t *, size_t),
+ array, array_len);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (!array || array_len == 0) {
}
bool SBData::SetDataFromDoubleArray(double *array, size_t array_len) {
+ LLDB_RECORD_METHOD(bool, SBData, SetDataFromDoubleArray, (double *, size_t),
+ array, array_len);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (!array || array_len == 0) {
//
//===----------------------------------------------------------------------===//
-
+#include "SBReproducerPrivate.h"
#include "SystemInitializerFull.h"
#include "lldb/API/SBDebugger.h"
return SBError();
}
-void SBInputReader::SetIsDone(bool) {}
+void SBInputReader::SetIsDone(bool b) {
+ LLDB_RECORD_METHOD(void, SBInputReader, SetIsDone, (bool), b);
+}
+
+bool SBInputReader::IsActive() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInputReader, IsActive);
-bool SBInputReader::IsActive() const { return false; }
+ return false;
+}
-SBDebugger::SBDebugger() = default;
+SBDebugger::SBDebugger() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBDebugger); }
SBDebugger::SBDebugger(const lldb::DebuggerSP &debugger_sp)
- : m_opaque_sp(debugger_sp) {}
+ : m_opaque_sp(debugger_sp) {
+ LLDB_RECORD_CONSTRUCTOR(SBDebugger, (const lldb::DebuggerSP &), debugger_sp);
+}
-SBDebugger::SBDebugger(const SBDebugger &rhs) : m_opaque_sp(rhs.m_opaque_sp) {}
+SBDebugger::SBDebugger(const SBDebugger &rhs) : m_opaque_sp(rhs.m_opaque_sp) {
+ LLDB_RECORD_CONSTRUCTOR(SBDebugger, (const lldb::SBDebugger &), rhs);
+}
SBDebugger::~SBDebugger() = default;
SBDebugger &SBDebugger::operator=(const SBDebugger &rhs) {
+ LLDB_RECORD_METHOD(lldb::SBDebugger &,
+ SBDebugger, operator=,(const lldb::SBDebugger &), rhs);
+
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
}
}
void SBDebugger::Initialize() {
+ LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, Initialize);
SBError ignored = SBDebugger::InitializeWithErrorHandling();
}
lldb::SBError SBDebugger::InitializeWithErrorHandling() {
+ LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBError, SBDebugger,
+ InitializeWithErrorHandling);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
llvm::make_unique<SystemInitializerFull>(), LoadPlugin)) {
error.SetError(Status(std::move(e)));
}
- return error;
+ return LLDB_RECORD_RESULT(error);
}
-void SBDebugger::Terminate() { g_debugger_lifetime->Terminate(); }
+void SBDebugger::Terminate() {
+ LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, Terminate);
+
+ g_debugger_lifetime->Terminate();
+}
void SBDebugger::Clear() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, Clear);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
}
SBDebugger SBDebugger::Create() {
- return SBDebugger::Create(false, nullptr, nullptr);
+ LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBDebugger, SBDebugger, Create);
+
+ return LLDB_RECORD_RESULT(SBDebugger::Create(false, nullptr, nullptr));
}
SBDebugger SBDebugger::Create(bool source_init_files) {
- return SBDebugger::Create(source_init_files, nullptr, nullptr);
+ LLDB_RECORD_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, (bool),
+ source_init_files);
+
+ return LLDB_RECORD_RESULT(
+ SBDebugger::Create(source_init_files, nullptr, nullptr));
}
SBDebugger SBDebugger::Create(bool source_init_files,
}
void SBDebugger::Destroy(SBDebugger &debugger) {
+ LLDB_RECORD_STATIC_METHOD(void, SBDebugger, Destroy, (lldb::SBDebugger &),
+ debugger);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log) {
}
void SBDebugger::MemoryPressureDetected() {
+ LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, MemoryPressureDetected);
+
// Since this function can be call asynchronously, we allow it to be non-
// mandatory. We have seen deadlocks with this function when called so we
// need to safeguard against this until we can determine what is causing the
ModuleList::RemoveOrphanSharedModules(mandatory);
}
-bool SBDebugger::IsValid() const { return m_opaque_sp.get() != nullptr; }
+bool SBDebugger::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, IsValid);
+
+ return m_opaque_sp.get() != nullptr;
+}
void SBDebugger::SetAsync(bool b) {
+ LLDB_RECORD_METHOD(void, SBDebugger, SetAsync, (bool), b);
+
if (m_opaque_sp)
m_opaque_sp->SetAsyncExecution(b);
}
bool SBDebugger::GetAsync() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBDebugger, GetAsync);
+
return (m_opaque_sp ? m_opaque_sp->GetAsyncExecution() : false);
}
void SBDebugger::SkipLLDBInitFiles(bool b) {
+ LLDB_RECORD_METHOD(void, SBDebugger, SkipLLDBInitFiles, (bool), b);
+
if (m_opaque_sp)
m_opaque_sp->GetCommandInterpreter().SkipLLDBInitFiles(b);
}
void SBDebugger::SkipAppInitFiles(bool b) {
+ LLDB_RECORD_METHOD(void, SBDebugger, SkipAppInitFiles, (bool), b);
+
if (m_opaque_sp)
m_opaque_sp->GetCommandInterpreter().SkipAppInitFiles(b);
}
// of problems; don't want users trying to switch modes in the middle of a
// debugging session.
void SBDebugger::SetInputFileHandle(FILE *fh, bool transfer_ownership) {
+ LLDB_RECORD_METHOD(void, SBDebugger, SetInputFileHandle, (FILE *, bool), fh,
+ transfer_ownership);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
}
void SBDebugger::SetOutputFileHandle(FILE *fh, bool transfer_ownership) {
+ LLDB_RECORD_METHOD(void, SBDebugger, SetOutputFileHandle, (FILE *, bool), fh,
+ transfer_ownership);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
}
void SBDebugger::SetErrorFileHandle(FILE *fh, bool transfer_ownership) {
+ LLDB_RECORD_METHOD(void, SBDebugger, SetErrorFileHandle, (FILE *, bool), fh,
+ transfer_ownership);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
}
FILE *SBDebugger::GetInputFileHandle() {
+ LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetInputFileHandle);
+
if (m_opaque_sp) {
StreamFileSP stream_file_sp(m_opaque_sp->GetInputFile());
if (stream_file_sp)
}
FILE *SBDebugger::GetOutputFileHandle() {
+ LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetOutputFileHandle);
+
if (m_opaque_sp) {
StreamFileSP stream_file_sp(m_opaque_sp->GetOutputFile());
if (stream_file_sp)
}
FILE *SBDebugger::GetErrorFileHandle() {
+ LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetErrorFileHandle);
+
if (m_opaque_sp) {
StreamFileSP stream_file_sp(m_opaque_sp->GetErrorFile());
if (stream_file_sp)
}
void SBDebugger::SaveInputTerminalState() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, SaveInputTerminalState);
+
if (m_opaque_sp)
m_opaque_sp->SaveInputTerminalState();
}
void SBDebugger::RestoreInputTerminalState() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, RestoreInputTerminalState);
+
if (m_opaque_sp)
m_opaque_sp->RestoreInputTerminalState();
}
SBCommandInterpreter SBDebugger::GetCommandInterpreter() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCommandInterpreter, SBDebugger,
+ GetCommandInterpreter);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBCommandInterpreter sb_interpreter;
static_cast<void *>(m_opaque_sp.get()),
static_cast<void *>(sb_interpreter.get()));
- return sb_interpreter;
+ return LLDB_RECORD_RESULT(sb_interpreter);
}
void SBDebugger::HandleCommand(const char *command) {
+ LLDB_RECORD_METHOD(void, SBDebugger, HandleCommand, (const char *), command);
+
if (m_opaque_sp) {
TargetSP target_sp(m_opaque_sp->GetSelectedTarget());
std::unique_lock<std::recursive_mutex> lock;
}
SBListener SBDebugger::GetListener() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBDebugger, GetListener);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBListener sb_listener;
static_cast<void *>(m_opaque_sp.get()),
static_cast<void *>(sb_listener.get()));
- return sb_listener;
+ return LLDB_RECORD_RESULT(sb_listener);
}
void SBDebugger::HandleProcessEvent(const SBProcess &process,
const SBEvent &event, FILE *out,
FILE *err) {
+ LLDB_RECORD_METHOD(
+ void, SBDebugger, HandleProcessEvent,
+ (const lldb::SBProcess &, const lldb::SBEvent &, FILE *, FILE *), process,
+ event, out, err);
+
if (!process.IsValid())
return;
}
SBSourceManager SBDebugger::GetSourceManager() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSourceManager, SBDebugger,
+ GetSourceManager);
+
SBSourceManager sb_source_manager(*this);
- return sb_source_manager;
+ return LLDB_RECORD_RESULT(sb_source_manager);
}
bool SBDebugger::GetDefaultArchitecture(char *arch_name, size_t arch_name_len) {
+ LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, GetDefaultArchitecture,
+ (char *, size_t), "", arch_name_len);
+
if (arch_name && arch_name_len) {
ArchSpec default_arch = Target::GetDefaultArchitecture();
}
bool SBDebugger::SetDefaultArchitecture(const char *arch_name) {
+ LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, SetDefaultArchitecture,
+ (const char *), arch_name);
+
if (arch_name) {
ArchSpec arch(arch_name);
if (arch.IsValid()) {
ScriptLanguage
SBDebugger::GetScriptingLanguage(const char *script_language_name) {
+ LLDB_RECORD_METHOD(lldb::ScriptLanguage, SBDebugger, GetScriptingLanguage,
+ (const char *), script_language_name);
+
if (!script_language_name) return eScriptLanguageDefault;
return OptionArgParser::ToScriptLanguage(
llvm::StringRef(script_language_name), eScriptLanguageDefault, nullptr);
}
const char *SBDebugger::GetVersionString() {
+ LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBDebugger, GetVersionString);
+
return lldb_private::GetVersion();
}
const char *SBDebugger::StateAsCString(StateType state) {
+ LLDB_RECORD_STATIC_METHOD(const char *, SBDebugger, StateAsCString,
+ (lldb::StateType), state);
+
return lldb_private::StateAsCString(state);
}
}
SBStructuredData SBDebugger::GetBuildConfiguration() {
+ LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBStructuredData, SBDebugger,
+ GetBuildConfiguration);
+
auto config_up = llvm::make_unique<StructuredData::Dictionary>();
AddBoolConfigEntry(
*config_up, "xml", XMLDocument::XMLEnabled(),
SBStructuredData data;
data.m_impl_up->SetObjectSP(std::move(config_up));
- return data;
+ return LLDB_RECORD_RESULT(data);
}
bool SBDebugger::StateIsRunningState(StateType state) {
+ LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, StateIsRunningState,
+ (lldb::StateType), state);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
const bool result = lldb_private::StateIsRunningState(state);
}
bool SBDebugger::StateIsStoppedState(StateType state) {
+ LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, StateIsStoppedState,
+ (lldb::StateType), state);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
const bool result = lldb_private::StateIsStoppedState(state, false);
const char *platform_name,
bool add_dependent_modules,
lldb::SBError &sb_error) {
+ LLDB_RECORD_METHOD(
+ lldb::SBTarget, SBDebugger, CreateTarget,
+ (const char *, const char *, const char *, bool, lldb::SBError &),
+ filename, target_triple, platform_name, add_dependent_modules, sb_error);
+
SBTarget sb_target;
TargetSP target_sp;
if (m_opaque_sp) {
platform_name, add_dependent_modules, sb_error.GetCString(),
static_cast<void *>(target_sp.get()));
- return sb_target;
+ return LLDB_RECORD_RESULT(sb_target);
}
SBTarget
SBDebugger::CreateTargetWithFileAndTargetTriple(const char *filename,
const char *target_triple) {
+ LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger,
+ CreateTargetWithFileAndTargetTriple,
+ (const char *, const char *), filename, target_triple);
+
SBTarget sb_target;
TargetSP target_sp;
if (m_opaque_sp) {
static_cast<void *>(m_opaque_sp.get()), filename, target_triple,
static_cast<void *>(target_sp.get()));
- return sb_target;
+ return LLDB_RECORD_RESULT(sb_target);
}
SBTarget SBDebugger::CreateTargetWithFileAndArch(const char *filename,
const char *arch_cstr) {
+ LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, CreateTargetWithFileAndArch,
+ (const char *, const char *), filename, arch_cstr);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBTarget sb_target;
static_cast<void *>(m_opaque_sp.get()), filename, arch_cstr,
static_cast<void *>(target_sp.get()));
- return sb_target;
+ return LLDB_RECORD_RESULT(sb_target);
}
SBTarget SBDebugger::CreateTarget(const char *filename) {
+ LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, CreateTarget, (const char *),
+ filename);
+
SBTarget sb_target;
TargetSP target_sp;
if (m_opaque_sp) {
"SBDebugger(%p)::CreateTarget (filename=\"%s\") => SBTarget(%p)",
static_cast<void *>(m_opaque_sp.get()), filename,
static_cast<void *>(target_sp.get()));
- return sb_target;
+ return LLDB_RECORD_RESULT(sb_target);
}
SBTarget SBDebugger::GetDummyTarget() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBDebugger, GetDummyTarget);
+
SBTarget sb_target;
if (m_opaque_sp) {
sb_target.SetSP(m_opaque_sp->GetDummyTarget()->shared_from_this());
"SBDebugger(%p)::GetDummyTarget() => SBTarget(%p)",
static_cast<void *>(m_opaque_sp.get()),
static_cast<void *>(sb_target.GetSP().get()));
- return sb_target;
+ return LLDB_RECORD_RESULT(sb_target);
}
bool SBDebugger::DeleteTarget(lldb::SBTarget &target) {
+ LLDB_RECORD_METHOD(bool, SBDebugger, DeleteTarget, (lldb::SBTarget &),
+ target);
+
bool result = false;
if (m_opaque_sp) {
TargetSP target_sp(target.GetSP());
}
SBTarget SBDebugger::GetTargetAtIndex(uint32_t idx) {
+ LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, GetTargetAtIndex, (uint32_t),
+ idx);
+
SBTarget sb_target;
if (m_opaque_sp) {
// No need to lock, the target list is thread safe
sb_target.SetSP(m_opaque_sp->GetTargetList().GetTargetAtIndex(idx));
}
- return sb_target;
+ return LLDB_RECORD_RESULT(sb_target);
}
uint32_t SBDebugger::GetIndexOfTarget(lldb::SBTarget target) {
+ LLDB_RECORD_METHOD(uint32_t, SBDebugger, GetIndexOfTarget, (lldb::SBTarget),
+ target);
lldb::TargetSP target_sp = target.GetSP();
if (!target_sp)
}
SBTarget SBDebugger::FindTargetWithProcessID(lldb::pid_t pid) {
+ LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithProcessID,
+ (lldb::pid_t), pid);
+
SBTarget sb_target;
if (m_opaque_sp) {
// No need to lock, the target list is thread safe
sb_target.SetSP(m_opaque_sp->GetTargetList().FindTargetWithProcessID(pid));
}
- return sb_target;
+ return LLDB_RECORD_RESULT(sb_target);
}
SBTarget SBDebugger::FindTargetWithFileAndArch(const char *filename,
const char *arch_name) {
+ LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithFileAndArch,
+ (const char *, const char *), filename, arch_name);
+
SBTarget sb_target;
if (m_opaque_sp && filename && filename[0]) {
// No need to lock, the target list is thread safe
FileSpec(filename), arch_name ? &arch : nullptr));
sb_target.SetSP(target_sp);
}
- return sb_target;
+ return LLDB_RECORD_RESULT(sb_target);
}
SBTarget SBDebugger::FindTargetWithLLDBProcess(const ProcessSP &process_sp) {
}
uint32_t SBDebugger::GetNumTargets() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumTargets);
+
if (m_opaque_sp) {
// No need to lock, the target list is thread safe
return m_opaque_sp->GetTargetList().GetNumTargets();
}
SBTarget SBDebugger::GetSelectedTarget() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBDebugger, GetSelectedTarget);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBTarget sb_target;
static_cast<void *>(target_sp.get()), sstr.GetData());
}
- return sb_target;
+ return LLDB_RECORD_RESULT(sb_target);
}
void SBDebugger::SetSelectedTarget(SBTarget &sb_target) {
+ LLDB_RECORD_METHOD(void, SBDebugger, SetSelectedTarget, (lldb::SBTarget &),
+ sb_target);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
TargetSP target_sp(sb_target.GetSP());
}
SBPlatform SBDebugger::GetSelectedPlatform() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBPlatform, SBDebugger, GetSelectedPlatform);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBPlatform sb_platform;
static_cast<void *>(m_opaque_sp.get()),
static_cast<void *>(sb_platform.GetSP().get()),
sb_platform.GetName());
- return sb_platform;
+ return LLDB_RECORD_RESULT(sb_platform);
}
void SBDebugger::SetSelectedPlatform(SBPlatform &sb_platform) {
+ LLDB_RECORD_METHOD(void, SBDebugger, SetSelectedPlatform,
+ (lldb::SBPlatform &), sb_platform);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
DebuggerSP debugger_sp(m_opaque_sp);
}
uint32_t SBDebugger::GetNumPlatforms() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumPlatforms);
+
if (m_opaque_sp) {
// No need to lock, the platform list is thread safe
return m_opaque_sp->GetPlatformList().GetSize();
}
SBPlatform SBDebugger::GetPlatformAtIndex(uint32_t idx) {
+ LLDB_RECORD_METHOD(lldb::SBPlatform, SBDebugger, GetPlatformAtIndex,
+ (uint32_t), idx);
+
SBPlatform sb_platform;
if (m_opaque_sp) {
// No need to lock, the platform list is thread safe
sb_platform.SetSP(m_opaque_sp->GetPlatformList().GetAtIndex(idx));
}
- return sb_platform;
+ return LLDB_RECORD_RESULT(sb_platform);
}
uint32_t SBDebugger::GetNumAvailablePlatforms() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumAvailablePlatforms);
+
uint32_t idx = 0;
while (true) {
if (!PluginManager::GetPlatformPluginNameAtIndex(idx)) {
}
SBStructuredData SBDebugger::GetAvailablePlatformInfoAtIndex(uint32_t idx) {
+ LLDB_RECORD_METHOD(lldb::SBStructuredData, SBDebugger,
+ GetAvailablePlatformInfoAtIndex, (uint32_t), idx);
+
SBStructuredData data;
auto platform_dict = llvm::make_unique<StructuredData::Dictionary>();
llvm::StringRef name_str("name"), desc_str("description");
const char *plugin_name =
PluginManager::GetPlatformPluginNameAtIndex(idx - 1);
if (!plugin_name) {
- return data;
+ return LLDB_RECORD_RESULT(data);
}
platform_dict->AddStringItem(name_str, llvm::StringRef(plugin_name));
const char *plugin_desc =
PluginManager::GetPlatformPluginDescriptionAtIndex(idx - 1);
if (!plugin_desc) {
- return data;
+ return LLDB_RECORD_RESULT(data);
}
platform_dict->AddStringItem(desc_str, llvm::StringRef(plugin_desc));
}
data.m_impl_up->SetObjectSP(
StructuredData::ObjectSP(platform_dict.release()));
- return data;
+ return LLDB_RECORD_RESULT(data);
}
void SBDebugger::DispatchInput(void *baton, const void *data, size_t data_len) {
}
void SBDebugger::DispatchInputInterrupt() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, DispatchInputInterrupt);
+
if (m_opaque_sp)
m_opaque_sp->DispatchInputInterrupt();
}
void SBDebugger::DispatchInputEndOfFile() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, DispatchInputEndOfFile);
+
if (m_opaque_sp)
m_opaque_sp->DispatchInputEndOfFile();
}
-void SBDebugger::PushInputReader(SBInputReader &reader) {}
+void SBDebugger::PushInputReader(SBInputReader &reader) {
+ LLDB_RECORD_METHOD(void, SBDebugger, PushInputReader, (lldb::SBInputReader &),
+ reader);
+}
void SBDebugger::RunCommandInterpreter(bool auto_handle_events,
bool spawn_thread) {
+ LLDB_RECORD_METHOD(void, SBDebugger, RunCommandInterpreter, (bool, bool),
+ auto_handle_events, spawn_thread);
+
if (m_opaque_sp) {
CommandInterpreterRunOptions options;
bool &stopped_for_crash)
{
+ LLDB_RECORD_METHOD(void, SBDebugger, RunCommandInterpreter,
+ (bool, bool, lldb::SBCommandInterpreterRunOptions &, int &,
+ bool &, bool &),
+ auto_handle_events, spawn_thread, options, num_errors,
+ quit_requested, stopped_for_crash);
+
if (m_opaque_sp) {
CommandInterpreter &interp = m_opaque_sp->GetCommandInterpreter();
interp.RunCommandInterpreter(auto_handle_events, spawn_thread,
SBError SBDebugger::RunREPL(lldb::LanguageType language,
const char *repl_options) {
+ LLDB_RECORD_METHOD(lldb::SBError, SBDebugger, RunREPL,
+ (lldb::LanguageType, const char *), language,
+ repl_options);
+
SBError error;
if (m_opaque_sp)
error.ref() = m_opaque_sp->RunREPL(language, repl_options);
else
error.SetErrorString("invalid debugger");
- return error;
+ return LLDB_RECORD_RESULT(error);
}
void SBDebugger::reset(const DebuggerSP &debugger_sp) {
const lldb::DebuggerSP &SBDebugger::get_sp() const { return m_opaque_sp; }
SBDebugger SBDebugger::FindDebuggerWithID(int id) {
+ LLDB_RECORD_STATIC_METHOD(lldb::SBDebugger, SBDebugger, FindDebuggerWithID,
+ (int), id);
+
// No need to lock, the debugger list is thread safe
SBDebugger sb_debugger;
DebuggerSP debugger_sp = Debugger::FindDebuggerWithID(id);
if (debugger_sp)
sb_debugger.reset(debugger_sp);
- return sb_debugger;
+ return LLDB_RECORD_RESULT(sb_debugger);
}
const char *SBDebugger::GetInstanceName() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBDebugger, GetInstanceName);
+
return (m_opaque_sp ? m_opaque_sp->GetInstanceName().AsCString() : nullptr);
}
SBError SBDebugger::SetInternalVariable(const char *var_name, const char *value,
const char *debugger_instance_name) {
+ LLDB_RECORD_STATIC_METHOD(lldb::SBError, SBDebugger, SetInternalVariable,
+ (const char *, const char *, const char *),
+ var_name, value, debugger_instance_name);
+
SBError sb_error;
DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName(
ConstString(debugger_instance_name)));
}
if (error.Fail())
sb_error.SetError(error);
- return sb_error;
+ return LLDB_RECORD_RESULT(sb_error);
}
SBStringList
SBDebugger::GetInternalVariableValue(const char *var_name,
const char *debugger_instance_name) {
+ LLDB_RECORD_STATIC_METHOD(
+ lldb::SBStringList, SBDebugger, GetInternalVariableValue,
+ (const char *, const char *), var_name, debugger_instance_name);
+
SBStringList ret_value;
DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName(
ConstString(debugger_instance_name)));
if (!value_str.empty()) {
StringList string_list;
string_list.SplitIntoLines(value_str);
- return SBStringList(&string_list);
+ return LLDB_RECORD_RESULT(SBStringList(&string_list));
}
}
}
- return SBStringList();
+ return LLDB_RECORD_RESULT(SBStringList());
}
uint32_t SBDebugger::GetTerminalWidth() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBDebugger, GetTerminalWidth);
+
return (m_opaque_sp ? m_opaque_sp->GetTerminalWidth() : 0);
}
void SBDebugger::SetTerminalWidth(uint32_t term_width) {
+ LLDB_RECORD_METHOD(void, SBDebugger, SetTerminalWidth, (uint32_t),
+ term_width);
+
if (m_opaque_sp)
m_opaque_sp->SetTerminalWidth(term_width);
}
const char *SBDebugger::GetPrompt() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBDebugger, GetPrompt);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
}
void SBDebugger::SetPrompt(const char *prompt) {
+ LLDB_RECORD_METHOD(void, SBDebugger, SetPrompt, (const char *), prompt);
+
if (m_opaque_sp)
m_opaque_sp->SetPrompt(llvm::StringRef::withNullAsEmpty(prompt));
}
const char *SBDebugger::GetReproducerPath() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBDebugger, GetReproducerPath);
+
return (m_opaque_sp
? ConstString(m_opaque_sp->GetReproducerPath()).GetCString()
: nullptr);
}
ScriptLanguage SBDebugger::GetScriptLanguage() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ScriptLanguage, SBDebugger,
+ GetScriptLanguage);
+
return (m_opaque_sp ? m_opaque_sp->GetScriptLanguage() : eScriptLanguageNone);
}
void SBDebugger::SetScriptLanguage(ScriptLanguage script_lang) {
+ LLDB_RECORD_METHOD(void, SBDebugger, SetScriptLanguage,
+ (lldb::ScriptLanguage), script_lang);
+
if (m_opaque_sp) {
m_opaque_sp->SetScriptLanguage(script_lang);
}
}
bool SBDebugger::SetUseExternalEditor(bool value) {
+ LLDB_RECORD_METHOD(bool, SBDebugger, SetUseExternalEditor, (bool), value);
+
return (m_opaque_sp ? m_opaque_sp->SetUseExternalEditor(value) : false);
}
bool SBDebugger::GetUseExternalEditor() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBDebugger, GetUseExternalEditor);
+
return (m_opaque_sp ? m_opaque_sp->GetUseExternalEditor() : false);
}
bool SBDebugger::SetUseColor(bool value) {
+ LLDB_RECORD_METHOD(bool, SBDebugger, SetUseColor, (bool), value);
+
return (m_opaque_sp ? m_opaque_sp->SetUseColor(value) : false);
}
bool SBDebugger::GetUseColor() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetUseColor);
+
return (m_opaque_sp ? m_opaque_sp->GetUseColor() : false);
}
bool SBDebugger::GetDescription(SBStream &description) {
+ LLDB_RECORD_METHOD(bool, SBDebugger, GetDescription, (lldb::SBStream &),
+ description);
+
Stream &strm = description.ref();
if (m_opaque_sp) {
}
user_id_t SBDebugger::GetID() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::user_id_t, SBDebugger, GetID);
+
return (m_opaque_sp ? m_opaque_sp->GetID() : LLDB_INVALID_UID);
}
SBError SBDebugger::SetCurrentPlatform(const char *platform_name_cstr) {
+ LLDB_RECORD_METHOD(lldb::SBError, SBDebugger, SetCurrentPlatform,
+ (const char *), platform_name_cstr);
+
SBError sb_error;
if (m_opaque_sp) {
if (platform_name_cstr && platform_name_cstr[0]) {
} else {
sb_error.ref().SetErrorString("invalid debugger");
}
- return sb_error;
+ return LLDB_RECORD_RESULT(sb_error);
}
bool SBDebugger::SetCurrentPlatformSDKRoot(const char *sysroot) {
+ LLDB_RECORD_METHOD(bool, SBDebugger, SetCurrentPlatformSDKRoot,
+ (const char *), sysroot);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (m_opaque_sp) {
PlatformSP platform_sp(
}
bool SBDebugger::GetCloseInputOnEOF() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetCloseInputOnEOF);
+
return (m_opaque_sp ? m_opaque_sp->GetCloseInputOnEOF() : false);
}
void SBDebugger::SetCloseInputOnEOF(bool b) {
+ LLDB_RECORD_METHOD(void, SBDebugger, SetCloseInputOnEOF, (bool), b);
+
if (m_opaque_sp)
m_opaque_sp->SetCloseInputOnEOF(b);
}
SBTypeCategory SBDebugger::GetCategory(const char *category_name) {
+ LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory,
+ (const char *), category_name);
+
if (!category_name || *category_name == 0)
- return SBTypeCategory();
+ return LLDB_RECORD_RESULT(SBTypeCategory());
TypeCategoryImplSP category_sp;
if (DataVisualization::Categories::GetCategory(ConstString(category_name),
- category_sp, false))
- return SBTypeCategory(category_sp);
- else
- return SBTypeCategory();
+ category_sp, false)) {
+ return LLDB_RECORD_RESULT(SBTypeCategory(category_sp));
+ } else {
+ return LLDB_RECORD_RESULT(SBTypeCategory());
+ }
}
SBTypeCategory SBDebugger::GetCategory(lldb::LanguageType lang_type) {
+ LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory,
+ (lldb::LanguageType), lang_type);
+
TypeCategoryImplSP category_sp;
- if (DataVisualization::Categories::GetCategory(lang_type, category_sp))
- return SBTypeCategory(category_sp);
- else
- return SBTypeCategory();
+ if (DataVisualization::Categories::GetCategory(lang_type, category_sp)) {
+ return LLDB_RECORD_RESULT(SBTypeCategory(category_sp));
+ } else {
+ return LLDB_RECORD_RESULT(SBTypeCategory());
+ }
}
SBTypeCategory SBDebugger::CreateCategory(const char *category_name) {
+ LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, CreateCategory,
+ (const char *), category_name);
+
if (!category_name || *category_name == 0)
- return SBTypeCategory();
+ return LLDB_RECORD_RESULT(SBTypeCategory());
TypeCategoryImplSP category_sp;
if (DataVisualization::Categories::GetCategory(ConstString(category_name),
- category_sp, true))
- return SBTypeCategory(category_sp);
- else
- return SBTypeCategory();
+ category_sp, true)) {
+ return LLDB_RECORD_RESULT(SBTypeCategory(category_sp));
+ } else {
+ return LLDB_RECORD_RESULT(SBTypeCategory());
+ }
}
bool SBDebugger::DeleteCategory(const char *category_name) {
+ LLDB_RECORD_METHOD(bool, SBDebugger, DeleteCategory, (const char *),
+ category_name);
+
if (!category_name || *category_name == 0)
return false;
}
uint32_t SBDebugger::GetNumCategories() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumCategories);
+
return DataVisualization::Categories::GetCount();
}
SBTypeCategory SBDebugger::GetCategoryAtIndex(uint32_t index) {
- return SBTypeCategory(
- DataVisualization::Categories::GetCategoryAtIndex(index));
+ LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategoryAtIndex,
+ (uint32_t), index);
+
+ return LLDB_RECORD_RESULT(
+ SBTypeCategory(DataVisualization::Categories::GetCategoryAtIndex(index)));
}
SBTypeCategory SBDebugger::GetDefaultCategory() {
- return GetCategory("default");
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeCategory, SBDebugger,
+ GetDefaultCategory);
+
+ return LLDB_RECORD_RESULT(GetCategory("default"));
}
SBTypeFormat SBDebugger::GetFormatForType(SBTypeNameSpecifier type_name) {
+ LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBDebugger, GetFormatForType,
+ (lldb::SBTypeNameSpecifier), type_name);
+
SBTypeCategory default_category_sb = GetDefaultCategory();
if (default_category_sb.GetEnabled())
- return default_category_sb.GetFormatForType(type_name);
- return SBTypeFormat();
+ return LLDB_RECORD_RESULT(default_category_sb.GetFormatForType(type_name));
+ return LLDB_RECORD_RESULT(SBTypeFormat());
}
#ifndef LLDB_DISABLE_PYTHON
SBTypeSummary SBDebugger::GetSummaryForType(SBTypeNameSpecifier type_name) {
+ LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBDebugger, GetSummaryForType,
+ (lldb::SBTypeNameSpecifier), type_name);
+
if (!type_name.IsValid())
- return SBTypeSummary();
- return SBTypeSummary(DataVisualization::GetSummaryForType(type_name.GetSP()));
+ return LLDB_RECORD_RESULT(SBTypeSummary());
+ return LLDB_RECORD_RESULT(
+ SBTypeSummary(DataVisualization::GetSummaryForType(type_name.GetSP())));
}
#endif // LLDB_DISABLE_PYTHON
SBTypeFilter SBDebugger::GetFilterForType(SBTypeNameSpecifier type_name) {
+ LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBDebugger, GetFilterForType,
+ (lldb::SBTypeNameSpecifier), type_name);
+
if (!type_name.IsValid())
- return SBTypeFilter();
- return SBTypeFilter(DataVisualization::GetFilterForType(type_name.GetSP()));
+ return LLDB_RECORD_RESULT(SBTypeFilter());
+ return LLDB_RECORD_RESULT(
+ SBTypeFilter(DataVisualization::GetFilterForType(type_name.GetSP())));
}
#ifndef LLDB_DISABLE_PYTHON
SBTypeSynthetic SBDebugger::GetSyntheticForType(SBTypeNameSpecifier type_name) {
+ LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBDebugger, GetSyntheticForType,
+ (lldb::SBTypeNameSpecifier), type_name);
+
if (!type_name.IsValid())
- return SBTypeSynthetic();
- return SBTypeSynthetic(
- DataVisualization::GetSyntheticForType(type_name.GetSP()));
+ return LLDB_RECORD_RESULT(SBTypeSynthetic());
+ return LLDB_RECORD_RESULT(SBTypeSynthetic(
+ DataVisualization::GetSyntheticForType(type_name.GetSP())));
}
#endif // LLDB_DISABLE_PYTHON
}
bool SBDebugger::EnableLog(const char *channel, const char **categories) {
+ LLDB_RECORD_METHOD(bool, SBDebugger, EnableLog, (const char *, const char **),
+ channel, categories);
+
if (m_opaque_sp) {
uint32_t log_options =
LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME;
//===----------------------------------------------------------------------===//
#include "lldb/API/SBDeclaration.h"
+#include "SBReproducerPrivate.h"
#include "Utils.h"
#include "lldb/API/SBStream.h"
#include "lldb/Host/PosixApi.h"
using namespace lldb;
using namespace lldb_private;
-SBDeclaration::SBDeclaration() : m_opaque_up() {}
+SBDeclaration::SBDeclaration() : m_opaque_up() {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBDeclaration);
+}
SBDeclaration::SBDeclaration(const SBDeclaration &rhs) : m_opaque_up() {
+ LLDB_RECORD_CONSTRUCTOR(SBDeclaration, (const lldb::SBDeclaration &), rhs);
+
m_opaque_up = clone(rhs.m_opaque_up);
}
}
const SBDeclaration &SBDeclaration::operator=(const SBDeclaration &rhs) {
+ LLDB_RECORD_METHOD(const lldb::SBDeclaration &,
+ SBDeclaration, operator=,(const lldb::SBDeclaration &),
+ rhs);
+
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
return *this;
SBDeclaration::~SBDeclaration() {}
bool SBDeclaration::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDeclaration, IsValid);
+
return m_opaque_up.get() && m_opaque_up->IsValid();
}
SBFileSpec SBDeclaration::GetFileSpec() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBDeclaration,
+ GetFileSpec);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBFileSpec sb_file_spec;
static_cast<const void *>(sb_file_spec.get()), sstr.GetData());
}
- return sb_file_spec;
+ return LLDB_RECORD_RESULT(sb_file_spec);
}
uint32_t SBDeclaration::GetLine() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBDeclaration, GetLine);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
uint32_t line = 0;
}
uint32_t SBDeclaration::GetColumn() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBDeclaration, GetColumn);
+
if (m_opaque_up)
return m_opaque_up->GetColumn();
return 0;
}
void SBDeclaration::SetFileSpec(lldb::SBFileSpec filespec) {
+ LLDB_RECORD_METHOD(void, SBDeclaration, SetFileSpec, (lldb::SBFileSpec),
+ filespec);
+
if (filespec.IsValid())
ref().SetFile(filespec.ref());
else
ref().SetFile(FileSpec());
}
-void SBDeclaration::SetLine(uint32_t line) { ref().SetLine(line); }
+void SBDeclaration::SetLine(uint32_t line) {
+ LLDB_RECORD_METHOD(void, SBDeclaration, SetLine, (uint32_t), line);
-void SBDeclaration::SetColumn(uint32_t column) { ref().SetColumn(column); }
+ ref().SetLine(line);
+}
+
+void SBDeclaration::SetColumn(uint32_t column) {
+ LLDB_RECORD_METHOD(void, SBDeclaration, SetColumn, (uint32_t), column);
+
+ ref().SetColumn(column);
+}
bool SBDeclaration::operator==(const SBDeclaration &rhs) const {
+ LLDB_RECORD_METHOD_CONST(
+ bool, SBDeclaration, operator==,(const lldb::SBDeclaration &), rhs);
+
lldb_private::Declaration *lhs_ptr = m_opaque_up.get();
lldb_private::Declaration *rhs_ptr = rhs.m_opaque_up.get();
}
bool SBDeclaration::operator!=(const SBDeclaration &rhs) const {
+ LLDB_RECORD_METHOD_CONST(
+ bool, SBDeclaration, operator!=,(const lldb::SBDeclaration &), rhs);
+
lldb_private::Declaration *lhs_ptr = m_opaque_up.get();
lldb_private::Declaration *rhs_ptr = rhs.m_opaque_up.get();
}
bool SBDeclaration::GetDescription(SBStream &description) {
+ LLDB_RECORD_METHOD(bool, SBDeclaration, GetDescription, (lldb::SBStream &),
+ description);
+
Stream &strm = description.ref();
if (m_opaque_up) {
//===----------------------------------------------------------------------===//
#include "lldb/API/SBError.h"
+#include "SBReproducerPrivate.h"
#include "Utils.h"
#include "lldb/API/SBStream.h"
#include "lldb/Utility/Log.h"
using namespace lldb;
using namespace lldb_private;
-SBError::SBError() : m_opaque_up() {}
+SBError::SBError() : m_opaque_up() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBError); }
SBError::SBError(const SBError &rhs) : m_opaque_up() {
+ LLDB_RECORD_CONSTRUCTOR(SBError, (const lldb::SBError &), rhs);
+
m_opaque_up = clone(rhs.m_opaque_up);
}
SBError::~SBError() {}
const SBError &SBError::operator=(const SBError &rhs) {
+ LLDB_RECORD_METHOD(const lldb::SBError &,
+ SBError, operator=,(const lldb::SBError &), rhs);
+
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
return *this;
}
const char *SBError::GetCString() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBError, GetCString);
+
if (m_opaque_up)
return m_opaque_up->AsCString();
return NULL;
}
void SBError::Clear() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBError, Clear);
+
if (m_opaque_up)
m_opaque_up->Clear();
}
bool SBError::Fail() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, Fail);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
bool ret_value = false;
}
bool SBError::Success() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, Success);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
bool ret_value = true;
if (m_opaque_up)
}
uint32_t SBError::GetError() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBError, GetError);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
uint32_t err = 0;
}
ErrorType SBError::GetType() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ErrorType, SBError, GetType);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
ErrorType err_type = eErrorTypeInvalid;
if (m_opaque_up)
}
void SBError::SetError(uint32_t err, ErrorType type) {
+ LLDB_RECORD_METHOD(void, SBError, SetError, (uint32_t, lldb::ErrorType), err,
+ type);
+
CreateIfNeeded();
m_opaque_up->SetError(err, type);
}
}
void SBError::SetErrorToErrno() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBError, SetErrorToErrno);
+
CreateIfNeeded();
m_opaque_up->SetErrorToErrno();
}
void SBError::SetErrorToGenericError() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBError, SetErrorToGenericError);
+
CreateIfNeeded();
m_opaque_up->SetErrorToErrno();
}
void SBError::SetErrorString(const char *err_str) {
+ LLDB_RECORD_METHOD(void, SBError, SetErrorString, (const char *), err_str);
+
CreateIfNeeded();
m_opaque_up->SetErrorString(err_str);
}
return num_chars;
}
-bool SBError::IsValid() const { return m_opaque_up != NULL; }
+bool SBError::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, IsValid);
+
+ return m_opaque_up != NULL;
+}
void SBError::CreateIfNeeded() {
if (m_opaque_up == NULL)
}
bool SBError::GetDescription(SBStream &description) {
+ LLDB_RECORD_METHOD(bool, SBError, GetDescription, (lldb::SBStream &),
+ description);
+
if (m_opaque_up) {
if (m_opaque_up->Success())
description.Printf("success");
//===----------------------------------------------------------------------===//
#include "lldb/API/SBEvent.h"
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBBroadcaster.h"
#include "lldb/API/SBStream.h"
using namespace lldb;
using namespace lldb_private;
-SBEvent::SBEvent() : m_event_sp(), m_opaque_ptr(NULL) {}
+SBEvent::SBEvent() : m_event_sp(), m_opaque_ptr(NULL) {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBEvent);
+}
SBEvent::SBEvent(uint32_t event_type, const char *cstr, uint32_t cstr_len)
: m_event_sp(new Event(event_type, new EventDataBytes(cstr, cstr_len))),
- m_opaque_ptr(m_event_sp.get()) {}
+ m_opaque_ptr(m_event_sp.get()) {
+ LLDB_RECORD_CONSTRUCTOR(SBEvent, (uint32_t, const char *, uint32_t),
+ event_type, cstr, cstr_len);
+}
SBEvent::SBEvent(EventSP &event_sp)
- : m_event_sp(event_sp), m_opaque_ptr(event_sp.get()) {}
+ : m_event_sp(event_sp), m_opaque_ptr(event_sp.get()) {
+ LLDB_RECORD_CONSTRUCTOR(SBEvent, (lldb::EventSP &), event_sp);
+}
-SBEvent::SBEvent(Event *event_ptr) : m_event_sp(), m_opaque_ptr(event_ptr) {}
+SBEvent::SBEvent(Event *event_ptr) : m_event_sp(), m_opaque_ptr(event_ptr) {
+ LLDB_RECORD_CONSTRUCTOR(SBEvent, (lldb_private::Event *), event_ptr);
+}
SBEvent::SBEvent(const SBEvent &rhs)
- : m_event_sp(rhs.m_event_sp), m_opaque_ptr(rhs.m_opaque_ptr) {}
+ : m_event_sp(rhs.m_event_sp), m_opaque_ptr(rhs.m_opaque_ptr) {
+ LLDB_RECORD_CONSTRUCTOR(SBEvent, (const lldb::SBEvent &), rhs);
+}
const SBEvent &SBEvent::operator=(const SBEvent &rhs) {
+ LLDB_RECORD_METHOD(const lldb::SBEvent &,
+ SBEvent, operator=,(const lldb::SBEvent &), rhs);
+
if (this != &rhs) {
m_event_sp = rhs.m_event_sp;
m_opaque_ptr = rhs.m_opaque_ptr;
SBEvent::~SBEvent() {}
const char *SBEvent::GetDataFlavor() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBEvent, GetDataFlavor);
+
Event *lldb_event = get();
if (lldb_event) {
EventData *event_data = lldb_event->GetData();
}
uint32_t SBEvent::GetType() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBEvent, GetType);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
const Event *lldb_event = get();
}
SBBroadcaster SBEvent::GetBroadcaster() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBEvent,
+ GetBroadcaster);
+
SBBroadcaster broadcaster;
const Event *lldb_event = get();
if (lldb_event)
broadcaster.reset(lldb_event->GetBroadcaster(), false);
- return broadcaster;
+ return LLDB_RECORD_RESULT(broadcaster);
}
const char *SBEvent::GetBroadcasterClass() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBEvent, GetBroadcasterClass);
+
const Event *lldb_event = get();
if (lldb_event)
return lldb_event->GetBroadcaster()->GetBroadcasterClass().AsCString();
}
bool SBEvent::BroadcasterMatchesPtr(const SBBroadcaster *broadcaster) {
+ LLDB_RECORD_METHOD(bool, SBEvent, BroadcasterMatchesPtr,
+ (const lldb::SBBroadcaster *), broadcaster);
+
if (broadcaster)
return BroadcasterMatchesRef(*broadcaster);
return false;
}
bool SBEvent::BroadcasterMatchesRef(const SBBroadcaster &broadcaster) {
+ LLDB_RECORD_METHOD(bool, SBEvent, BroadcasterMatchesRef,
+ (const lldb::SBBroadcaster &), broadcaster);
Event *lldb_event = get();
bool success = false;
}
void SBEvent::Clear() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBEvent, Clear);
+
Event *lldb_event = get();
if (lldb_event)
lldb_event->Clear();
}
bool SBEvent::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBEvent, IsValid);
+
// Do NOT use m_opaque_ptr directly!!! Must use the SBEvent::get() accessor.
// See comments in SBEvent::get()....
return SBEvent::get() != NULL;
}
const char *SBEvent::GetCStringFromEvent(const SBEvent &event) {
+ LLDB_RECORD_STATIC_METHOD(const char *, SBEvent, GetCStringFromEvent,
+ (const lldb::SBEvent &), event);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
}
bool SBEvent::GetDescription(SBStream &description) {
+ LLDB_RECORD_METHOD(bool, SBEvent, GetDescription, (lldb::SBStream &),
+ description);
+
Stream &strm = description.ref();
if (get()) {
}
bool SBEvent::GetDescription(SBStream &description) const {
+ LLDB_RECORD_METHOD_CONST(bool, SBEvent, GetDescription, (lldb::SBStream &),
+ description);
+
Stream &strm = description.ref();
if (get()) {
//===----------------------------------------------------------------------===//
#include "lldb/API/SBExecutionContext.h"
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBFrame.h"
#include "lldb/API/SBProcess.h"
using namespace lldb;
using namespace lldb_private;
-SBExecutionContext::SBExecutionContext() : m_exe_ctx_sp() {}
+SBExecutionContext::SBExecutionContext() : m_exe_ctx_sp() {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBExecutionContext);
+}
SBExecutionContext::SBExecutionContext(const lldb::SBExecutionContext &rhs)
- : m_exe_ctx_sp(rhs.m_exe_ctx_sp) {}
+ : m_exe_ctx_sp(rhs.m_exe_ctx_sp) {
+ LLDB_RECORD_CONSTRUCTOR(SBExecutionContext,
+ (const lldb::SBExecutionContext &), rhs);
+}
SBExecutionContext::SBExecutionContext(
lldb::ExecutionContextRefSP exe_ctx_ref_sp)
- : m_exe_ctx_sp(exe_ctx_ref_sp) {}
+ : m_exe_ctx_sp(exe_ctx_ref_sp) {
+ LLDB_RECORD_CONSTRUCTOR(SBExecutionContext, (lldb::ExecutionContextRefSP),
+ exe_ctx_ref_sp);
+}
SBExecutionContext::SBExecutionContext(const lldb::SBTarget &target)
: m_exe_ctx_sp(new ExecutionContextRef()) {
+ LLDB_RECORD_CONSTRUCTOR(SBExecutionContext, (const lldb::SBTarget &), target);
+
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);
+
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);
+
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);
+
m_exe_ctx_sp->SetFrameSP(frame.GetFrameSP());
}
const SBExecutionContext &SBExecutionContext::
operator=(const lldb::SBExecutionContext &rhs) {
+ LLDB_RECORD_METHOD(
+ const lldb::SBExecutionContext &,
+ SBExecutionContext, operator=,(const lldb::SBExecutionContext &), rhs);
+
m_exe_ctx_sp = rhs.m_exe_ctx_sp;
return *this;
}
}
SBTarget SBExecutionContext::GetTarget() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBTarget, SBExecutionContext,
+ GetTarget);
+
SBTarget sb_target;
if (m_exe_ctx_sp) {
TargetSP target_sp(m_exe_ctx_sp->GetTargetSP());
if (target_sp)
sb_target.SetSP(target_sp);
}
- return sb_target;
+ return LLDB_RECORD_RESULT(sb_target);
}
SBProcess SBExecutionContext::GetProcess() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBProcess, SBExecutionContext,
+ GetProcess);
+
SBProcess sb_process;
if (m_exe_ctx_sp) {
ProcessSP process_sp(m_exe_ctx_sp->GetProcessSP());
if (process_sp)
sb_process.SetSP(process_sp);
}
- return sb_process;
+ return LLDB_RECORD_RESULT(sb_process);
}
SBThread SBExecutionContext::GetThread() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBExecutionContext,
+ GetThread);
+
SBThread sb_thread;
if (m_exe_ctx_sp) {
ThreadSP thread_sp(m_exe_ctx_sp->GetThreadSP());
if (thread_sp)
sb_thread.SetThread(thread_sp);
}
- return sb_thread;
+ return LLDB_RECORD_RESULT(sb_thread);
}
SBFrame SBExecutionContext::GetFrame() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFrame, SBExecutionContext, GetFrame);
+
SBFrame sb_frame;
if (m_exe_ctx_sp) {
StackFrameSP frame_sp(m_exe_ctx_sp->GetFrameSP());
if (frame_sp)
sb_frame.SetFrameSP(frame_sp);
}
- return sb_frame;
+ return LLDB_RECORD_RESULT(sb_frame);
}
//===----------------------------------------------------------------------===//
#include "lldb/API/SBExpressionOptions.h"
+#include "SBReproducerPrivate.h"
#include "Utils.h"
#include "lldb/API/SBStream.h"
#include "lldb/Target/Target.h"
using namespace lldb_private;
SBExpressionOptions::SBExpressionOptions()
- : m_opaque_up(new EvaluateExpressionOptions()) {}
+ : m_opaque_up(new EvaluateExpressionOptions()) {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBExpressionOptions);
+}
SBExpressionOptions::SBExpressionOptions(const SBExpressionOptions &rhs)
: m_opaque_up() {
+ LLDB_RECORD_CONSTRUCTOR(SBExpressionOptions,
+ (const lldb::SBExpressionOptions &), rhs);
+
m_opaque_up = clone(rhs.m_opaque_up);
}
const SBExpressionOptions &SBExpressionOptions::
operator=(const SBExpressionOptions &rhs) {
+ LLDB_RECORD_METHOD(
+ const lldb::SBExpressionOptions &,
+ SBExpressionOptions, operator=,(const lldb::SBExpressionOptions &), rhs);
+
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
return *this;
SBExpressionOptions::~SBExpressionOptions() {}
bool SBExpressionOptions::GetCoerceResultToId() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions,
+ GetCoerceResultToId);
+
return m_opaque_up->DoesCoerceToId();
}
void SBExpressionOptions::SetCoerceResultToId(bool coerce) {
+ LLDB_RECORD_METHOD(void, SBExpressionOptions, SetCoerceResultToId, (bool),
+ coerce);
+
m_opaque_up->SetCoerceToId(coerce);
}
bool SBExpressionOptions::GetUnwindOnError() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, GetUnwindOnError);
+
return m_opaque_up->DoesUnwindOnError();
}
void SBExpressionOptions::SetUnwindOnError(bool unwind) {
+ LLDB_RECORD_METHOD(void, SBExpressionOptions, SetUnwindOnError, (bool),
+ unwind);
+
m_opaque_up->SetUnwindOnError(unwind);
}
bool SBExpressionOptions::GetIgnoreBreakpoints() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions,
+ GetIgnoreBreakpoints);
+
return m_opaque_up->DoesIgnoreBreakpoints();
}
void SBExpressionOptions::SetIgnoreBreakpoints(bool ignore) {
+ LLDB_RECORD_METHOD(void, SBExpressionOptions, SetIgnoreBreakpoints, (bool),
+ ignore);
+
m_opaque_up->SetIgnoreBreakpoints(ignore);
}
lldb::DynamicValueType SBExpressionOptions::GetFetchDynamicValue() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::DynamicValueType, SBExpressionOptions,
+ GetFetchDynamicValue);
+
return m_opaque_up->GetUseDynamic();
}
void SBExpressionOptions::SetFetchDynamicValue(lldb::DynamicValueType dynamic) {
+ LLDB_RECORD_METHOD(void, SBExpressionOptions, SetFetchDynamicValue,
+ (lldb::DynamicValueType), dynamic);
+
m_opaque_up->SetUseDynamic(dynamic);
}
uint32_t SBExpressionOptions::GetTimeoutInMicroSeconds() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBExpressionOptions,
+ GetTimeoutInMicroSeconds);
+
return m_opaque_up->GetTimeout() ? m_opaque_up->GetTimeout()->count() : 0;
}
void SBExpressionOptions::SetTimeoutInMicroSeconds(uint32_t timeout) {
+ LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTimeoutInMicroSeconds,
+ (uint32_t), timeout);
+
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);
+
return m_opaque_up->GetOneThreadTimeout()
? m_opaque_up->GetOneThreadTimeout()->count()
: 0;
}
void SBExpressionOptions::SetOneThreadTimeoutInMicroSeconds(uint32_t timeout) {
+ LLDB_RECORD_METHOD(void, SBExpressionOptions,
+ SetOneThreadTimeoutInMicroSeconds, (uint32_t), timeout);
+
m_opaque_up->SetOneThreadTimeout(timeout == 0
? Timeout<std::micro>(llvm::None)
: std::chrono::microseconds(timeout));
}
bool SBExpressionOptions::GetTryAllThreads() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, GetTryAllThreads);
+
return m_opaque_up->GetTryAllThreads();
}
void SBExpressionOptions::SetTryAllThreads(bool run_others) {
+ LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTryAllThreads, (bool),
+ run_others);
+
m_opaque_up->SetTryAllThreads(run_others);
}
bool SBExpressionOptions::GetStopOthers() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, GetStopOthers);
+
return m_opaque_up->GetStopOthers();
}
void SBExpressionOptions::SetStopOthers(bool run_others) {
+ LLDB_RECORD_METHOD(void, SBExpressionOptions, SetStopOthers, (bool),
+ run_others);
+
m_opaque_up->SetStopOthers(run_others);
}
bool SBExpressionOptions::GetTrapExceptions() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions,
+ GetTrapExceptions);
+
return m_opaque_up->GetTrapExceptions();
}
void SBExpressionOptions::SetTrapExceptions(bool trap_exceptions) {
+ LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTrapExceptions, (bool),
+ trap_exceptions);
+
m_opaque_up->SetTrapExceptions(trap_exceptions);
}
void SBExpressionOptions::SetLanguage(lldb::LanguageType language) {
+ LLDB_RECORD_METHOD(void, SBExpressionOptions, SetLanguage,
+ (lldb::LanguageType), language);
+
m_opaque_up->SetLanguage(language);
}
}
bool SBExpressionOptions::GetGenerateDebugInfo() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetGenerateDebugInfo);
+
return m_opaque_up->GetGenerateDebugInfo();
}
void SBExpressionOptions::SetGenerateDebugInfo(bool b) {
+ LLDB_RECORD_METHOD(void, SBExpressionOptions, SetGenerateDebugInfo, (bool),
+ b);
+
return m_opaque_up->SetGenerateDebugInfo(b);
}
bool SBExpressionOptions::GetSuppressPersistentResult() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions,
+ GetSuppressPersistentResult);
+
return m_opaque_up->GetResultIsInternal();
}
void SBExpressionOptions::SetSuppressPersistentResult(bool b) {
+ LLDB_RECORD_METHOD(void, SBExpressionOptions, SetSuppressPersistentResult,
+ (bool), b);
+
return m_opaque_up->SetResultIsInternal(b);
}
const char *SBExpressionOptions::GetPrefix() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBExpressionOptions,
+ GetPrefix);
+
return m_opaque_up->GetPrefix();
}
void SBExpressionOptions::SetPrefix(const char *prefix) {
+ LLDB_RECORD_METHOD(void, SBExpressionOptions, SetPrefix, (const char *),
+ prefix);
+
return m_opaque_up->SetPrefix(prefix);
}
bool SBExpressionOptions::GetAutoApplyFixIts() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetAutoApplyFixIts);
+
return m_opaque_up->GetAutoApplyFixIts();
}
void SBExpressionOptions::SetAutoApplyFixIts(bool b) {
+ LLDB_RECORD_METHOD(void, SBExpressionOptions, SetAutoApplyFixIts, (bool), b);
+
return m_opaque_up->SetAutoApplyFixIts(b);
}
bool SBExpressionOptions::GetTopLevel() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetTopLevel);
+
return m_opaque_up->GetExecutionPolicy() == eExecutionPolicyTopLevel;
}
void SBExpressionOptions::SetTopLevel(bool b) {
+ LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTopLevel, (bool), b);
+
m_opaque_up->SetExecutionPolicy(b ? eExecutionPolicyTopLevel
: m_opaque_up->default_execution_policy);
}
bool SBExpressionOptions::GetAllowJIT() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetAllowJIT);
+
return m_opaque_up->GetExecutionPolicy() != eExecutionPolicyNever;
}
void SBExpressionOptions::SetAllowJIT(bool allow) {
+ LLDB_RECORD_METHOD(void, SBExpressionOptions, SetAllowJIT, (bool), allow);
+
m_opaque_up->SetExecutionPolicy(allow ? m_opaque_up->default_execution_policy
: eExecutionPolicyNever);
}
//
//===----------------------------------------------------------------------===//
-#include <inttypes.h>
-#include <limits.h>
-
-#include "Utils.h"
#include "lldb/API/SBFileSpec.h"
+#include "SBReproducerPrivate.h"
+#include "Utils.h"
#include "lldb/API/SBStream.h"
#include "lldb/Host/FileSystem.h"
#include "lldb/Host/PosixApi.h"
#include "llvm/ADT/SmallString.h"
+#include <inttypes.h>
+#include <limits.h>
+
using namespace lldb;
using namespace lldb_private;
-SBFileSpec::SBFileSpec() : m_opaque_up(new lldb_private::FileSpec()) {}
+SBFileSpec::SBFileSpec() : m_opaque_up(new lldb_private::FileSpec()) {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFileSpec);
+}
SBFileSpec::SBFileSpec(const SBFileSpec &rhs) : m_opaque_up() {
+ LLDB_RECORD_CONSTRUCTOR(SBFileSpec, (const lldb::SBFileSpec &), rhs);
+
m_opaque_up = clone(rhs.m_opaque_up);
}
// Deprecated!!!
SBFileSpec::SBFileSpec(const char *path) : m_opaque_up(new FileSpec(path)) {
+ LLDB_RECORD_CONSTRUCTOR(SBFileSpec, (const char *), path);
+
FileSystem::Instance().Resolve(*m_opaque_up);
}
SBFileSpec::SBFileSpec(const char *path, bool resolve)
: m_opaque_up(new FileSpec(path)) {
+ LLDB_RECORD_CONSTRUCTOR(SBFileSpec, (const char *, bool), path, resolve);
+
if (resolve)
FileSystem::Instance().Resolve(*m_opaque_up);
}
SBFileSpec::~SBFileSpec() {}
const SBFileSpec &SBFileSpec::operator=(const SBFileSpec &rhs) {
+ LLDB_RECORD_METHOD(const lldb::SBFileSpec &,
+ SBFileSpec, operator=,(const lldb::SBFileSpec &), rhs);
+
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
return *this;
}
-bool SBFileSpec::IsValid() const { return m_opaque_up->operator bool(); }
+bool SBFileSpec::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFileSpec, IsValid);
+
+ return m_opaque_up->operator bool();
+}
bool SBFileSpec::Exists() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFileSpec, Exists);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
bool result = FileSystem::Instance().Exists(*m_opaque_up);
}
bool SBFileSpec::ResolveExecutableLocation() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBFileSpec, ResolveExecutableLocation);
+
return FileSystem::Instance().ResolveExecutableLocation(*m_opaque_up);
}
int SBFileSpec::ResolvePath(const char *src_path, char *dst_path,
size_t dst_len) {
+ LLDB_RECORD_STATIC_METHOD(int, SBFileSpec, ResolvePath,
+ (const char *, char *, size_t), src_path, dst_path,
+ dst_len);
+
llvm::SmallString<64> result(src_path);
FileSystem::Instance().Resolve(result);
::snprintf(dst_path, dst_len, "%s", result.c_str());
}
const char *SBFileSpec::GetFilename() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFileSpec, GetFilename);
+
const char *s = m_opaque_up->GetFilename().AsCString();
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
}
const char *SBFileSpec::GetDirectory() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFileSpec, GetDirectory);
+
FileSpec directory{*m_opaque_up};
directory.GetFilename().Clear();
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
}
void SBFileSpec::SetFilename(const char *filename) {
+ LLDB_RECORD_METHOD(void, SBFileSpec, SetFilename, (const char *), filename);
+
if (filename && filename[0])
m_opaque_up->GetFilename().SetCString(filename);
else
}
void SBFileSpec::SetDirectory(const char *directory) {
+ LLDB_RECORD_METHOD(void, SBFileSpec, SetDirectory, (const char *), directory);
+
if (directory && directory[0])
m_opaque_up->GetDirectory().SetCString(directory);
else
}
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);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
uint32_t result = m_opaque_up->GetPath(dst_path, dst_len);
}
bool SBFileSpec::GetDescription(SBStream &description) const {
+ LLDB_RECORD_METHOD_CONST(bool, SBFileSpec, GetDescription, (lldb::SBStream &),
+ description);
+
Stream &strm = description.ref();
char path[PATH_MAX];
if (m_opaque_up->GetPath(path, sizeof(path)))
}
void SBFileSpec::AppendPathComponent(const char *fn) {
+ LLDB_RECORD_METHOD(void, SBFileSpec, AppendPathComponent, (const char *), fn);
+
m_opaque_up->AppendPathComponent(fn);
}
//
//===----------------------------------------------------------------------===//
-#include <limits.h>
-
+#include "lldb/API/SBFileSpecList.h"
+#include "SBReproducerPrivate.h"
#include "Utils.h"
#include "lldb/API/SBFileSpec.h"
-#include "lldb/API/SBFileSpecList.h"
#include "lldb/API/SBStream.h"
#include "lldb/Core/FileSpecList.h"
#include "lldb/Host/PosixApi.h"
#include "lldb/Utility/Log.h"
#include "lldb/Utility/Stream.h"
+#include <limits.h>
+
using namespace lldb;
using namespace lldb_private;
-SBFileSpecList::SBFileSpecList() : m_opaque_up(new FileSpecList()) {}
+SBFileSpecList::SBFileSpecList() : m_opaque_up(new FileSpecList()) {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFileSpecList);
+}
SBFileSpecList::SBFileSpecList(const SBFileSpecList &rhs) : m_opaque_up() {
+ LLDB_RECORD_CONSTRUCTOR(SBFileSpecList, (const lldb::SBFileSpecList &), rhs);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
m_opaque_up = clone(rhs.m_opaque_up);
SBFileSpecList::~SBFileSpecList() {}
const SBFileSpecList &SBFileSpecList::operator=(const SBFileSpecList &rhs) {
+ LLDB_RECORD_METHOD(const lldb::SBFileSpecList &,
+ SBFileSpecList, operator=,(const lldb::SBFileSpecList &),
+ rhs);
+
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
return *this;
}
-uint32_t SBFileSpecList::GetSize() const { return m_opaque_up->GetSize(); }
+uint32_t SBFileSpecList::GetSize() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBFileSpecList, GetSize);
+
+ return m_opaque_up->GetSize();
+}
void SBFileSpecList::Append(const SBFileSpec &sb_file) {
+ LLDB_RECORD_METHOD(void, SBFileSpecList, Append, (const lldb::SBFileSpec &),
+ sb_file);
+
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);
+
return m_opaque_up->AppendIfUnique(sb_file.ref());
}
-void SBFileSpecList::Clear() { m_opaque_up->Clear(); }
+void SBFileSpecList::Clear() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBFileSpecList, Clear);
+
+ m_opaque_up->Clear();
+}
uint32_t SBFileSpecList::FindFileIndex(uint32_t idx, const SBFileSpec &sb_file,
bool full) {
+ LLDB_RECORD_METHOD(uint32_t, SBFileSpecList, FindFileIndex,
+ (uint32_t, const lldb::SBFileSpec &, bool), idx, sb_file,
+ full);
+
return m_opaque_up->FindFileIndex(idx, sb_file.ref(), full);
}
const SBFileSpec SBFileSpecList::GetFileSpecAtIndex(uint32_t idx) const {
+ LLDB_RECORD_METHOD_CONST(const lldb::SBFileSpec, SBFileSpecList,
+ GetFileSpecAtIndex, (uint32_t), idx);
+
SBFileSpec new_spec;
new_spec.SetFileSpec(m_opaque_up->GetFileSpecAtIndex(idx));
- return new_spec;
+ return LLDB_RECORD_RESULT(new_spec);
}
const lldb_private::FileSpecList *SBFileSpecList::operator->() const {
}
bool SBFileSpecList::GetDescription(SBStream &description) const {
+ LLDB_RECORD_METHOD_CONST(bool, SBFileSpecList, GetDescription,
+ (lldb::SBStream &), description);
+
Stream &strm = description.ref();
if (m_opaque_up) {
#include "lldb/lldb-types.h"
#include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
+#include "SBReproducerPrivate.h"
#include "Utils.h"
#include "lldb/Core/Address.h"
#include "lldb/Core/StreamFile.h"
using namespace lldb;
using namespace lldb_private;
-SBFrame::SBFrame() : m_opaque_sp(new ExecutionContextRef()) {}
+SBFrame::SBFrame() : m_opaque_sp(new ExecutionContextRef()) {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFrame);
+}
SBFrame::SBFrame(const StackFrameSP &lldb_object_sp)
: m_opaque_sp(new ExecutionContextRef(lldb_object_sp)) {
+ LLDB_RECORD_CONSTRUCTOR(SBFrame, (const lldb::StackFrameSP &),
+ lldb_object_sp);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log) {
}
SBFrame::SBFrame(const SBFrame &rhs) : m_opaque_sp() {
+ LLDB_RECORD_CONSTRUCTOR(SBFrame, (const lldb::SBFrame &), rhs);
+
m_opaque_sp = clone(rhs.m_opaque_sp);
}
SBFrame::~SBFrame() = default;
const SBFrame &SBFrame::operator=(const SBFrame &rhs) {
+ LLDB_RECORD_METHOD(const lldb::SBFrame &,
+ SBFrame, operator=,(const lldb::SBFrame &), rhs);
+
if (this != &rhs)
m_opaque_sp = clone(rhs.m_opaque_sp);
return *this;
}
bool SBFrame::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsValid);
+
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
}
SBSymbolContext SBFrame::GetSymbolContext(uint32_t resolve_scope) const {
+ LLDB_RECORD_METHOD_CONST(lldb::SBSymbolContext, SBFrame, GetSymbolContext,
+ (uint32_t), resolve_scope);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBSymbolContext sb_sym_ctx;
std::unique_lock<std::recursive_mutex> lock;
static_cast<void *>(frame), resolve_scope,
static_cast<void *>(sb_sym_ctx.get()));
- return sb_sym_ctx;
+ return LLDB_RECORD_RESULT(sb_sym_ctx);
}
SBModule SBFrame::GetModule() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBModule, SBFrame, GetModule);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBModule sb_module;
ModuleSP module_sp;
static_cast<void *>(frame),
static_cast<void *>(module_sp.get()));
- return sb_module;
+ return LLDB_RECORD_RESULT(sb_module);
}
SBCompileUnit SBFrame::GetCompileUnit() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBCompileUnit, SBFrame,
+ GetCompileUnit);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBCompileUnit sb_comp_unit;
std::unique_lock<std::recursive_mutex> lock;
static_cast<void *>(frame),
static_cast<void *>(sb_comp_unit.get()));
- return sb_comp_unit;
+ return LLDB_RECORD_RESULT(sb_comp_unit);
}
SBFunction SBFrame::GetFunction() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFunction, SBFrame, GetFunction);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBFunction sb_function;
std::unique_lock<std::recursive_mutex> lock;
static_cast<void *>(frame),
static_cast<void *>(sb_function.get()));
- return sb_function;
+ return LLDB_RECORD_RESULT(sb_function);
}
SBSymbol SBFrame::GetSymbol() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBSymbol, SBFrame, GetSymbol);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBSymbol sb_symbol;
std::unique_lock<std::recursive_mutex> lock;
log->Printf("SBFrame(%p)::GetSymbol () => SBSymbol(%p)",
static_cast<void *>(frame),
static_cast<void *>(sb_symbol.get()));
- return sb_symbol;
+ return LLDB_RECORD_RESULT(sb_symbol);
}
SBBlock SBFrame::GetBlock() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBlock, SBFrame, GetBlock);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBBlock sb_block;
std::unique_lock<std::recursive_mutex> lock;
log->Printf("SBFrame(%p)::GetBlock () => SBBlock(%p)",
static_cast<void *>(frame),
static_cast<void *>(sb_block.GetPtr()));
- return sb_block;
+ return LLDB_RECORD_RESULT(sb_block);
}
SBBlock SBFrame::GetFrameBlock() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBlock, SBFrame, GetFrameBlock);
+
SBBlock sb_block;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
log->Printf("SBFrame(%p)::GetFrameBlock () => SBBlock(%p)",
static_cast<void *>(frame),
static_cast<void *>(sb_block.GetPtr()));
- return sb_block;
+ return LLDB_RECORD_RESULT(sb_block);
}
SBLineEntry SBFrame::GetLineEntry() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBLineEntry, SBFrame, GetLineEntry);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBLineEntry sb_line_entry;
std::unique_lock<std::recursive_mutex> lock;
log->Printf("SBFrame(%p)::GetLineEntry () => SBLineEntry(%p)",
static_cast<void *>(frame),
static_cast<void *>(sb_line_entry.get()));
- return sb_line_entry;
+ return LLDB_RECORD_RESULT(sb_line_entry);
}
uint32_t SBFrame::GetFrameID() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBFrame, GetFrameID);
+
uint32_t frame_idx = UINT32_MAX;
std::unique_lock<std::recursive_mutex> lock;
}
lldb::addr_t SBFrame::GetCFA() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetCFA);
+
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
}
addr_t SBFrame::GetPC() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetPC);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
addr_t addr = LLDB_INVALID_ADDRESS;
std::unique_lock<std::recursive_mutex> lock;
}
bool SBFrame::SetPC(addr_t new_pc) {
+ LLDB_RECORD_METHOD(bool, SBFrame, SetPC, (lldb::addr_t), new_pc);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
bool ret_val = false;
std::unique_lock<std::recursive_mutex> lock;
}
addr_t SBFrame::GetSP() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetSP);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
addr_t addr = LLDB_INVALID_ADDRESS;
std::unique_lock<std::recursive_mutex> lock;
}
addr_t SBFrame::GetFP() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetFP);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
addr_t addr = LLDB_INVALID_ADDRESS;
std::unique_lock<std::recursive_mutex> lock;
}
SBAddress SBFrame::GetPCAddress() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBFrame, GetPCAddress);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBAddress sb_addr;
std::unique_lock<std::recursive_mutex> lock;
if (log)
log->Printf("SBFrame(%p)::GetPCAddress () => SBAddress(%p)",
static_cast<void *>(frame), static_cast<void *>(sb_addr.get()));
- return sb_addr;
+ return LLDB_RECORD_RESULT(sb_addr);
}
-void SBFrame::Clear() { m_opaque_sp->Clear(); }
+void SBFrame::Clear() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBFrame, Clear);
+
+ m_opaque_sp->Clear();
+}
lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path) {
+ LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,
+ (const char *), var_path);
+
SBValue sb_value;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
frame->CalculateTarget()->GetPreferDynamicValue();
sb_value = GetValueForVariablePath(var_path, use_dynamic);
}
- return sb_value;
+ return LLDB_RECORD_RESULT(sb_value);
}
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);
+
SBValue sb_value;
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (var_path == nullptr || var_path[0] == '\0') {
if (log)
log->Printf(
"SBFrame::GetValueForVariablePath called with empty variable path.");
- return sb_value;
+ return LLDB_RECORD_RESULT(sb_value);
}
std::unique_lock<std::recursive_mutex> lock;
"SBFrame::GetValueForVariablePath () => error: process is running");
}
}
- return sb_value;
+ return LLDB_RECORD_RESULT(sb_value);
}
SBValue SBFrame::FindVariable(const char *name) {
+ LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindVariable, (const char *),
+ name);
+
SBValue value;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
frame->CalculateTarget()->GetPreferDynamicValue();
value = FindVariable(name, use_dynamic);
}
- return value;
+ return LLDB_RECORD_RESULT(value);
}
SBValue SBFrame::FindVariable(const char *name,
lldb::DynamicValueType use_dynamic) {
+ LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindVariable,
+ (const char *, lldb::DynamicValueType), name, use_dynamic);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
VariableSP var_sp;
SBValue sb_value;
if (name == nullptr || name[0] == '\0') {
if (log)
log->Printf("SBFrame::FindVariable called with empty name");
- return sb_value;
+ return LLDB_RECORD_RESULT(sb_value);
}
ValueObjectSP value_sp;
static_cast<void *>(frame), name,
static_cast<void *>(value_sp.get()));
- return sb_value;
+ return LLDB_RECORD_RESULT(sb_value);
}
SBValue SBFrame::FindValue(const char *name, ValueType value_type) {
+ LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindValue,
+ (const char *, lldb::ValueType), name, value_type);
+
SBValue value;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
frame->CalculateTarget()->GetPreferDynamicValue();
value = FindValue(name, value_type, use_dynamic);
}
- return value;
+ return LLDB_RECORD_RESULT(value);
}
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);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBValue sb_value;
if (name == nullptr || name[0] == '\0') {
if (log)
log->Printf("SBFrame::FindValue called with empty name.");
- return sb_value;
+ return LLDB_RECORD_RESULT(sb_value);
}
ValueObjectSP value_sp;
static_cast<void *>(frame), name, value_type,
static_cast<void *>(value_sp.get()));
- return sb_value;
+ return LLDB_RECORD_RESULT(sb_value);
}
bool SBFrame::IsEqual(const SBFrame &that) const {
+ LLDB_RECORD_METHOD_CONST(bool, SBFrame, IsEqual, (const lldb::SBFrame &),
+ that);
+
lldb::StackFrameSP this_sp = GetFrameSP();
lldb::StackFrameSP that_sp = that.GetFrameSP();
return (this_sp && that_sp && this_sp->GetStackID() == that_sp->GetStackID());
}
-bool SBFrame::operator==(const SBFrame &rhs) const { return IsEqual(rhs); }
+bool SBFrame::operator==(const SBFrame &rhs) const {
+ LLDB_RECORD_METHOD_CONST(bool, SBFrame, operator==,(const lldb::SBFrame &),
+ rhs);
+
+ return IsEqual(rhs);
+}
-bool SBFrame::operator!=(const SBFrame &rhs) const { return !IsEqual(rhs); }
+bool SBFrame::operator!=(const SBFrame &rhs) const {
+ LLDB_RECORD_METHOD_CONST(bool, SBFrame, operator!=,(const lldb::SBFrame &),
+ rhs);
+
+ return !IsEqual(rhs);
+}
SBThread SBFrame::GetThread() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBFrame, GetThread);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
std::unique_lock<std::recursive_mutex> lock;
static_cast<void *>(thread_sp.get()), sstr.GetData());
}
- return sb_thread;
+ return LLDB_RECORD_RESULT(sb_thread);
}
const char *SBFrame::Disassemble() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFrame, Disassemble);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
const char *disassembly = nullptr;
std::unique_lock<std::recursive_mutex> lock;
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);
+
SBValueList value_list;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
value_list = GetVariables(options);
}
- return value_list;
+ return LLDB_RECORD_RESULT(value_list);
}
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);
+
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
options.SetInScopeOnly(in_scope_only);
options.SetIncludeRuntimeSupportValues(include_runtime_support_values);
options.SetUseDynamic(use_dynamic);
- return GetVariables(options);
+ return LLDB_RECORD_RESULT(GetVariables(options));
}
SBValueList SBFrame::GetVariables(const lldb::SBVariablesOptions &options) {
+ LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables,
+ (const lldb::SBVariablesOptions &), options);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBValueList value_list;
static_cast<void *>(frame),
static_cast<void *>(value_list.opaque_ptr()));
- return value_list;
+ return LLDB_RECORD_RESULT(value_list);
}
SBValueList SBFrame::GetRegisters() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValueList, SBFrame, GetRegisters);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBValueList value_list;
static_cast<void *>(frame),
static_cast<void *>(value_list.opaque_ptr()));
- return value_list;
+ return LLDB_RECORD_RESULT(value_list);
}
SBValue SBFrame::FindRegister(const char *name) {
+ LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindRegister, (const char *),
+ name);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBValue result;
static_cast<void *>(frame),
static_cast<void *>(value_sp.get()));
- return result;
+ return LLDB_RECORD_RESULT(result);
}
bool SBFrame::GetDescription(SBStream &description) {
+ LLDB_RECORD_METHOD(bool, SBFrame, GetDescription, (lldb::SBStream &),
+ description);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
Stream &strm = description.ref();
}
SBValue SBFrame::EvaluateExpression(const char *expr) {
+ LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression, (const char *),
+ expr);
+
SBValue result;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
options.SetLanguage(target->GetLanguage());
else
options.SetLanguage(frame->GetLanguage());
- return EvaluateExpression(expr, options);
+ return LLDB_RECORD_RESULT(EvaluateExpression(expr, options));
}
- return result;
+ return LLDB_RECORD_RESULT(result);
}
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);
+
SBExpressionOptions options;
options.SetFetchDynamicValue(fetch_dynamic_value);
options.SetUnwindOnError(true);
options.SetLanguage(target->GetLanguage());
else if (frame)
options.SetLanguage(frame->GetLanguage());
- return EvaluateExpression(expr, options);
+ return LLDB_RECORD_RESULT(EvaluateExpression(expr, options));
}
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);
+
SBExpressionOptions options;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
options.SetLanguage(target->GetLanguage());
else if (frame)
options.SetLanguage(frame->GetLanguage());
- return EvaluateExpression(expr, options);
+ return LLDB_RECORD_RESULT(EvaluateExpression(expr, options));
}
lldb::SBValue SBFrame::EvaluateExpression(const char *expr,
const SBExpressionOptions &options) {
+ LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
+ (const char *, const lldb::SBExpressionOptions &), expr,
+ options);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
#ifndef LLDB_DISABLE_PYTHON
if (log)
log->Printf(
"SBFrame::EvaluateExpression called with an empty expression");
- return expr_result;
+ return LLDB_RECORD_RESULT(expr_result);
}
ValueObjectSP expr_value_sp;
static_cast<void *>(expr_value_sp.get()), exe_results);
#endif
- return expr_result;
+ return LLDB_RECORD_RESULT(expr_result);
}
bool SBFrame::IsInlined() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBFrame, IsInlined);
+
return static_cast<const SBFrame *>(this)->IsInlined();
}
bool SBFrame::IsInlined() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsInlined);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
}
bool SBFrame::IsArtificial() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBFrame, IsArtificial);
+
return static_cast<const SBFrame *>(this)->IsArtificial();
}
bool SBFrame::IsArtificial() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsArtificial);
+
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
}
const char *SBFrame::GetFunctionName() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBFrame, GetFunctionName);
+
return static_cast<const SBFrame *>(this)->GetFunctionName();
}
lldb::LanguageType SBFrame::GuessLanguage() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::LanguageType, SBFrame, GuessLanguage);
+
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
-
+
StackFrame *frame = nullptr;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
}
const char *SBFrame::GetFunctionName() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFrame, GetFunctionName);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
const char *name = nullptr;
std::unique_lock<std::recursive_mutex> lock;
}
const char *SBFrame::GetDisplayFunctionName() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBFrame, GetDisplayFunctionName);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
const char *name = nullptr;
//===----------------------------------------------------------------------===//
#include "lldb/API/SBFunction.h"
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBProcess.h"
#include "lldb/API/SBStream.h"
#include "lldb/Core/Disassembler.h"
using namespace lldb;
using namespace lldb_private;
-SBFunction::SBFunction() : m_opaque_ptr(NULL) {}
+SBFunction::SBFunction() : m_opaque_ptr(NULL) {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFunction);
+}
SBFunction::SBFunction(lldb_private::Function *lldb_object_ptr)
: m_opaque_ptr(lldb_object_ptr) {}
SBFunction::SBFunction(const lldb::SBFunction &rhs)
- : m_opaque_ptr(rhs.m_opaque_ptr) {}
+ : m_opaque_ptr(rhs.m_opaque_ptr) {
+ LLDB_RECORD_CONSTRUCTOR(SBFunction, (const lldb::SBFunction &), rhs);
+}
const SBFunction &SBFunction::operator=(const SBFunction &rhs) {
+ LLDB_RECORD_METHOD(const lldb::SBFunction &,
+ SBFunction, operator=,(const lldb::SBFunction &), rhs);
+
m_opaque_ptr = rhs.m_opaque_ptr;
return *this;
}
SBFunction::~SBFunction() { m_opaque_ptr = NULL; }
-bool SBFunction::IsValid() const { return m_opaque_ptr != NULL; }
+bool SBFunction::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFunction, IsValid);
+
+ return m_opaque_ptr != NULL;
+}
const char *SBFunction::GetName() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFunction, GetName);
+
const char *cstr = NULL;
if (m_opaque_ptr)
cstr = m_opaque_ptr->GetName().AsCString();
}
const char *SBFunction::GetDisplayName() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFunction, GetDisplayName);
+
const char *cstr = NULL;
if (m_opaque_ptr)
cstr = m_opaque_ptr->GetMangled()
}
const char *SBFunction::GetMangledName() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFunction, GetMangledName);
+
const char *cstr = NULL;
if (m_opaque_ptr)
cstr = m_opaque_ptr->GetMangled().GetMangledName().AsCString();
}
bool SBFunction::operator==(const SBFunction &rhs) const {
+ LLDB_RECORD_METHOD_CONST(
+ bool, SBFunction, operator==,(const lldb::SBFunction &), rhs);
+
return m_opaque_ptr == rhs.m_opaque_ptr;
}
bool SBFunction::operator!=(const SBFunction &rhs) const {
+ LLDB_RECORD_METHOD_CONST(
+ bool, SBFunction, operator!=,(const lldb::SBFunction &), rhs);
+
return m_opaque_ptr != rhs.m_opaque_ptr;
}
bool SBFunction::GetDescription(SBStream &s) {
+ LLDB_RECORD_METHOD(bool, SBFunction, GetDescription, (lldb::SBStream &), s);
+
if (m_opaque_ptr) {
s.Printf("SBFunction: id = 0x%8.8" PRIx64 ", name = %s",
m_opaque_ptr->GetID(), m_opaque_ptr->GetName().AsCString());
}
SBInstructionList SBFunction::GetInstructions(SBTarget target) {
- return GetInstructions(target, NULL);
+ LLDB_RECORD_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions,
+ (lldb::SBTarget), target);
+
+ return LLDB_RECORD_RESULT(GetInstructions(target, NULL));
}
SBInstructionList SBFunction::GetInstructions(SBTarget target,
const char *flavor) {
+ LLDB_RECORD_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions,
+ (lldb::SBTarget, const char *), target, flavor);
+
SBInstructionList sb_instructions;
if (m_opaque_ptr) {
ExecutionContext exe_ctx;
m_opaque_ptr->GetAddressRange(), prefer_file_cache));
}
}
- return sb_instructions;
+ return LLDB_RECORD_RESULT(sb_instructions);
}
lldb_private::Function *SBFunction::get() { return m_opaque_ptr; }
}
SBAddress SBFunction::GetStartAddress() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBFunction, GetStartAddress);
+
SBAddress addr;
if (m_opaque_ptr)
addr.SetAddress(&m_opaque_ptr->GetAddressRange().GetBaseAddress());
- return addr;
+ return LLDB_RECORD_RESULT(addr);
}
SBAddress SBFunction::GetEndAddress() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBFunction, GetEndAddress);
+
SBAddress addr;
if (m_opaque_ptr) {
addr_t byte_size = m_opaque_ptr->GetAddressRange().GetByteSize();
addr->Slide(byte_size);
}
}
- return addr;
+ return LLDB_RECORD_RESULT(addr);
}
const char *SBFunction::GetArgumentName(uint32_t arg_idx) {
+ LLDB_RECORD_METHOD(const char *, SBFunction, GetArgumentName, (uint32_t),
+ arg_idx);
+
if (m_opaque_ptr) {
Block &block = m_opaque_ptr->GetBlock(true);
VariableListSP variable_list_sp = block.GetBlockVariableList(true);
}
uint32_t SBFunction::GetPrologueByteSize() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBFunction, GetPrologueByteSize);
+
if (m_opaque_ptr)
return m_opaque_ptr->GetPrologueByteSize();
return 0;
}
SBType SBFunction::GetType() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBFunction, GetType);
+
SBType sb_type;
if (m_opaque_ptr) {
Type *function_type = m_opaque_ptr->GetType();
if (function_type)
sb_type.ref().SetType(function_type->shared_from_this());
}
- return sb_type;
+ return LLDB_RECORD_RESULT(sb_type);
}
SBBlock SBFunction::GetBlock() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBFunction, GetBlock);
+
SBBlock sb_block;
if (m_opaque_ptr)
sb_block.SetPtr(&m_opaque_ptr->GetBlock(true));
- return sb_block;
+ return LLDB_RECORD_RESULT(sb_block);
}
lldb::LanguageType SBFunction::GetLanguage() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::LanguageType, SBFunction, GetLanguage);
+
if (m_opaque_ptr) {
if (m_opaque_ptr->GetCompileUnit())
return m_opaque_ptr->GetCompileUnit()->GetLanguage();
}
bool SBFunction::GetIsOptimized() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBFunction, GetIsOptimized);
+
if (m_opaque_ptr) {
if (m_opaque_ptr->GetCompileUnit())
return m_opaque_ptr->GetCompileUnit()->GetIsOptimized();
#include "Plugins/ScriptInterpreter/Python/lldb-python.h"
#endif
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBError.h"
#include "lldb/API/SBHostOS.h"
#include "lldb/Host/FileSystem.h"
using namespace lldb_private;
SBFileSpec SBHostOS::GetProgramFileSpec() {
+ LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBFileSpec, SBHostOS,
+ GetProgramFileSpec);
+
SBFileSpec sb_filespec;
sb_filespec.SetFileSpec(HostInfo::GetProgramFileSpec());
- return sb_filespec;
+ return LLDB_RECORD_RESULT(sb_filespec);
}
SBFileSpec SBHostOS::GetLLDBPythonPath() {
- return GetLLDBPath(ePathTypePythonDir);
+ LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBFileSpec, SBHostOS,
+ GetLLDBPythonPath);
+
+ return LLDB_RECORD_RESULT(GetLLDBPath(ePathTypePythonDir));
}
SBFileSpec SBHostOS::GetLLDBPath(lldb::PathType path_type) {
+ LLDB_RECORD_STATIC_METHOD(lldb::SBFileSpec, SBHostOS, GetLLDBPath,
+ (lldb::PathType), path_type);
+
FileSpec fspec;
switch (path_type) {
case ePathTypeLLDBShlibDir:
SBFileSpec sb_fspec;
sb_fspec.SetFileSpec(fspec);
- return sb_fspec;
+ return LLDB_RECORD_RESULT(sb_fspec);
}
SBFileSpec SBHostOS::GetUserHomeDirectory() {
+ LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBFileSpec, SBHostOS,
+ GetUserHomeDirectory);
+
SBFileSpec sb_fspec;
llvm::SmallString<64> home_dir_path;
FileSystem::Instance().Resolve(homedir);
sb_fspec.SetFileSpec(homedir);
- return sb_fspec;
+ return LLDB_RECORD_RESULT(sb_fspec);
}
lldb::thread_t SBHostOS::ThreadCreate(const char *name,
return thread.Release();
}
-void SBHostOS::ThreadCreated(const char *name) {}
+void SBHostOS::ThreadCreated(const char *name) {
+ LLDB_RECORD_STATIC_METHOD(void, SBHostOS, ThreadCreated, (const char *),
+ name);
+}
bool SBHostOS::ThreadCancel(lldb::thread_t thread, SBError *error_ptr) {
+ LLDB_RECORD_STATIC_METHOD(bool, SBHostOS, ThreadCancel,
+ (lldb::thread_t, lldb::SBError *), thread,
+ error_ptr);
+
Status error;
HostThread host_thread(thread);
error = host_thread.Cancel();
}
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);
+
Status error;
#if defined(_WIN32)
if (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);
+
Status error;
HostThread host_thread(thread);
error = host_thread.Join(result);
//===----------------------------------------------------------------------===//
#include "lldb/API/SBInstruction.h"
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBFrame.h"
using namespace lldb;
using namespace lldb_private;
-SBInstruction::SBInstruction() : m_opaque_sp() {}
+SBInstruction::SBInstruction() : m_opaque_sp() {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBInstruction);
+}
SBInstruction::SBInstruction(const lldb::DisassemblerSP &disasm_sp,
const lldb::InstructionSP &inst_sp)
: m_opaque_sp(new InstructionImpl(disasm_sp, inst_sp)) {}
SBInstruction::SBInstruction(const SBInstruction &rhs)
- : m_opaque_sp(rhs.m_opaque_sp) {}
+ : m_opaque_sp(rhs.m_opaque_sp) {
+ LLDB_RECORD_CONSTRUCTOR(SBInstruction, (const lldb::SBInstruction &), rhs);
+}
const SBInstruction &SBInstruction::operator=(const SBInstruction &rhs) {
+ LLDB_RECORD_METHOD(const lldb::SBInstruction &,
+ SBInstruction, operator=,(const lldb::SBInstruction &),
+ rhs);
+
if (this != &rhs)
m_opaque_sp = rhs.m_opaque_sp;
return *this;
SBInstruction::~SBInstruction() {}
-bool SBInstruction::IsValid() { return m_opaque_sp && m_opaque_sp->IsValid(); }
+bool SBInstruction::IsValid() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, IsValid);
+
+ return m_opaque_sp && m_opaque_sp->IsValid();
+}
SBAddress SBInstruction::GetAddress() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBInstruction, GetAddress);
+
SBAddress sb_addr;
lldb::InstructionSP inst_sp(GetOpaque());
if (inst_sp && inst_sp->GetAddress().IsValid())
sb_addr.SetAddress(&inst_sp->GetAddress());
- return sb_addr;
+ return LLDB_RECORD_RESULT(sb_addr);
}
const char *SBInstruction::GetMnemonic(SBTarget target) {
+ LLDB_RECORD_METHOD(const char *, SBInstruction, GetMnemonic, (lldb::SBTarget),
+ target);
+
lldb::InstructionSP inst_sp(GetOpaque());
if (inst_sp) {
ExecutionContext exe_ctx;
}
const char *SBInstruction::GetOperands(SBTarget target) {
+ LLDB_RECORD_METHOD(const char *, SBInstruction, GetOperands, (lldb::SBTarget),
+ target);
+
lldb::InstructionSP inst_sp(GetOpaque());
if (inst_sp) {
ExecutionContext exe_ctx;
}
const char *SBInstruction::GetComment(SBTarget target) {
+ LLDB_RECORD_METHOD(const char *, SBInstruction, GetComment, (lldb::SBTarget),
+ target);
+
lldb::InstructionSP inst_sp(GetOpaque());
if (inst_sp) {
ExecutionContext exe_ctx;
}
size_t SBInstruction::GetByteSize() {
+ LLDB_RECORD_METHOD_NO_ARGS(size_t, SBInstruction, GetByteSize);
+
lldb::InstructionSP inst_sp(GetOpaque());
if (inst_sp)
return inst_sp->GetOpcode().GetByteSize();
}
SBData SBInstruction::GetData(SBTarget target) {
+ LLDB_RECORD_METHOD(lldb::SBData, SBInstruction, GetData, (lldb::SBTarget),
+ target);
+
lldb::SBData sb_data;
lldb::InstructionSP inst_sp(GetOpaque());
if (inst_sp) {
sb_data.SetOpaque(data_extractor_sp);
}
}
- return sb_data;
+ return LLDB_RECORD_RESULT(sb_data);
}
bool SBInstruction::DoesBranch() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, DoesBranch);
+
lldb::InstructionSP inst_sp(GetOpaque());
if (inst_sp)
return inst_sp->DoesBranch();
}
bool SBInstruction::HasDelaySlot() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, HasDelaySlot);
+
lldb::InstructionSP inst_sp(GetOpaque());
if (inst_sp)
return inst_sp->HasDelaySlot();
return false;
}
-bool SBInstruction::CanSetBreakpoint () {
+bool SBInstruction::CanSetBreakpoint() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, CanSetBreakpoint);
+
lldb::InstructionSP inst_sp(GetOpaque());
if (inst_sp)
return inst_sp->CanSetBreakpoint();
}
bool SBInstruction::GetDescription(lldb::SBStream &s) {
+ LLDB_RECORD_METHOD(bool, SBInstruction, GetDescription, (lldb::SBStream &),
+ s);
+
lldb::InstructionSP inst_sp(GetOpaque());
if (inst_sp) {
SymbolContext sc;
}
void SBInstruction::Print(FILE *out) {
+ LLDB_RECORD_METHOD(void, SBInstruction, Print, (FILE *), out);
+
if (out == NULL)
return;
bool SBInstruction::EmulateWithFrame(lldb::SBFrame &frame,
uint32_t evaluate_options) {
+ LLDB_RECORD_METHOD(bool, SBInstruction, EmulateWithFrame,
+ (lldb::SBFrame &, uint32_t), frame, evaluate_options);
+
lldb::InstructionSP inst_sp(GetOpaque());
if (inst_sp) {
lldb::StackFrameSP frame_sp(frame.GetFrameSP());
}
bool SBInstruction::DumpEmulation(const char *triple) {
+ LLDB_RECORD_METHOD(bool, SBInstruction, DumpEmulation, (const char *),
+ triple);
+
lldb::InstructionSP inst_sp(GetOpaque());
if (inst_sp && triple) {
return inst_sp->DumpEmulation(HostInfo::GetAugmentedArchSpec(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);
+
if (!m_opaque_sp)
SetOpaque(lldb::DisassemblerSP(),
lldb::InstructionSP(new PseudoInstruction()));
//===----------------------------------------------------------------------===//
#include "lldb/API/SBInstructionList.h"
-#include "lldb/API/SBInstruction.h"
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBAddress.h"
+#include "lldb/API/SBInstruction.h"
#include "lldb/API/SBStream.h"
#include "lldb/Core/Disassembler.h"
#include "lldb/Core/Module.h"
using namespace lldb;
using namespace lldb_private;
-SBInstructionList::SBInstructionList() : m_opaque_sp() {}
+SBInstructionList::SBInstructionList() : m_opaque_sp() {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBInstructionList);
+}
SBInstructionList::SBInstructionList(const SBInstructionList &rhs)
- : m_opaque_sp(rhs.m_opaque_sp) {}
+ : m_opaque_sp(rhs.m_opaque_sp) {
+ LLDB_RECORD_CONSTRUCTOR(SBInstructionList, (const lldb::SBInstructionList &),
+ rhs);
+}
const SBInstructionList &SBInstructionList::
operator=(const SBInstructionList &rhs) {
+ LLDB_RECORD_METHOD(
+ const lldb::SBInstructionList &,
+ SBInstructionList, operator=,(const lldb::SBInstructionList &), rhs);
+
if (this != &rhs)
m_opaque_sp = rhs.m_opaque_sp;
return *this;
SBInstructionList::~SBInstructionList() {}
-bool SBInstructionList::IsValid() const { return m_opaque_sp.get() != NULL; }
+bool SBInstructionList::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInstructionList, IsValid);
+
+ return m_opaque_sp.get() != NULL;
+}
size_t SBInstructionList::GetSize() {
+ LLDB_RECORD_METHOD_NO_ARGS(size_t, SBInstructionList, GetSize);
+
if (m_opaque_sp)
return m_opaque_sp->GetInstructionList().GetSize();
return 0;
}
SBInstruction SBInstructionList::GetInstructionAtIndex(uint32_t idx) {
+ LLDB_RECORD_METHOD(lldb::SBInstruction, SBInstructionList,
+ GetInstructionAtIndex, (uint32_t), idx);
+
SBInstruction inst;
if (m_opaque_sp && idx < m_opaque_sp->GetInstructionList().GetSize())
inst.SetOpaque(
m_opaque_sp,
m_opaque_sp->GetInstructionList().GetInstructionAtIndex(idx));
- return inst;
+ return LLDB_RECORD_RESULT(inst);
}
size_t SBInstructionList::GetInstructionsCount(const SBAddress &start,
- const SBAddress &end,
- bool canSetBreakpoint) {
+ const SBAddress &end,
+ bool canSetBreakpoint) {
+ LLDB_RECORD_METHOD(size_t, SBInstructionList, GetInstructionsCount,
+ (const lldb::SBAddress &, const lldb::SBAddress &, bool),
+ start, end, canSetBreakpoint);
+
size_t num_instructions = GetSize();
size_t i = 0;
SBAddress addr;
return upper_index - lower_index - instructions_to_skip;
}
-void SBInstructionList::Clear() { m_opaque_sp.reset(); }
+void SBInstructionList::Clear() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBInstructionList, Clear);
+
+ m_opaque_sp.reset();
+}
-void SBInstructionList::AppendInstruction(SBInstruction insn) {}
+void SBInstructionList::AppendInstruction(SBInstruction insn) {
+ LLDB_RECORD_METHOD(void, SBInstructionList, AppendInstruction,
+ (lldb::SBInstruction), insn);
+}
void SBInstructionList::SetDisassembler(const lldb::DisassemblerSP &opaque_sp) {
m_opaque_sp = opaque_sp;
}
void SBInstructionList::Print(FILE *out) {
+ LLDB_RECORD_METHOD(void, SBInstructionList, Print, (FILE *), out);
+
if (out == NULL)
return;
}
bool SBInstructionList::GetDescription(lldb::SBStream &description) {
+ LLDB_RECORD_METHOD(bool, SBInstructionList, GetDescription,
+ (lldb::SBStream &), description);
+
if (m_opaque_sp) {
size_t num_instructions = GetSize();
if (num_instructions) {
}
bool SBInstructionList::DumpEmulationForAllInstructions(const char *triple) {
+ LLDB_RECORD_METHOD(bool, SBInstructionList, DumpEmulationForAllInstructions,
+ (const char *), triple);
+
if (m_opaque_sp) {
size_t len = GetSize();
for (size_t i = 0; i < len; ++i) {
//===----------------------------------------------------------------------===//
#include "lldb/API/SBLanguageRuntime.h"
+#include "SBReproducerPrivate.h"
#include "lldb/Target/Language.h"
using namespace lldb;
lldb::LanguageType
SBLanguageRuntime::GetLanguageTypeFromString(const char *string) {
+ LLDB_RECORD_STATIC_METHOD(lldb::LanguageType, SBLanguageRuntime,
+ GetLanguageTypeFromString, (const char *), string);
+
return Language::GetLanguageTypeFromString(
llvm::StringRef::withNullAsEmpty(string));
}
const char *
SBLanguageRuntime::GetNameForLanguageType(lldb::LanguageType language) {
+ LLDB_RECORD_STATIC_METHOD(const char *, SBLanguageRuntime,
+ GetNameForLanguageType, (lldb::LanguageType),
+ language);
+
return Language::GetNameForLanguageType(language);
}
//===----------------------------------------------------------------------===//
#include "lldb/API/SBLaunchInfo.h"
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBFileSpec.h"
#include "lldb/API/SBListener.h"
SBLaunchInfo::SBLaunchInfo(const char **argv)
: m_opaque_sp(new SBLaunchInfoImpl()) {
+ LLDB_RECORD_CONSTRUCTOR(SBLaunchInfo, (const char **), argv);
+
m_opaque_sp->GetFlags().Reset(eLaunchFlagDebug | eLaunchFlagDisableASLR);
if (argv && argv[0])
m_opaque_sp->GetArguments().SetArguments(argv);
*m_opaque_sp = info;
}
-lldb::pid_t SBLaunchInfo::GetProcessID() { return m_opaque_sp->GetProcessID(); }
+lldb::pid_t SBLaunchInfo::GetProcessID() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBLaunchInfo, GetProcessID);
+
+ return m_opaque_sp->GetProcessID();
+}
+
+uint32_t SBLaunchInfo::GetUserID() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetUserID);
+
+ return m_opaque_sp->GetUserID();
+}
+
+uint32_t SBLaunchInfo::GetGroupID() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetGroupID);
+
+ return m_opaque_sp->GetGroupID();
+}
+
+bool SBLaunchInfo::UserIDIsValid() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBLaunchInfo, UserIDIsValid);
+
+ return m_opaque_sp->UserIDIsValid();
+}
-uint32_t SBLaunchInfo::GetUserID() { return m_opaque_sp->GetUserID(); }
+bool SBLaunchInfo::GroupIDIsValid() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBLaunchInfo, GroupIDIsValid);
-uint32_t SBLaunchInfo::GetGroupID() { return m_opaque_sp->GetGroupID(); }
+ return m_opaque_sp->GroupIDIsValid();
+}
-bool SBLaunchInfo::UserIDIsValid() { return m_opaque_sp->UserIDIsValid(); }
+void SBLaunchInfo::SetUserID(uint32_t uid) {
+ LLDB_RECORD_METHOD(void, SBLaunchInfo, SetUserID, (uint32_t), uid);
-bool SBLaunchInfo::GroupIDIsValid() { return m_opaque_sp->GroupIDIsValid(); }
+ m_opaque_sp->SetUserID(uid);
+}
-void SBLaunchInfo::SetUserID(uint32_t uid) { m_opaque_sp->SetUserID(uid); }
+void SBLaunchInfo::SetGroupID(uint32_t gid) {
+ LLDB_RECORD_METHOD(void, SBLaunchInfo, SetGroupID, (uint32_t), gid);
-void SBLaunchInfo::SetGroupID(uint32_t gid) { m_opaque_sp->SetGroupID(gid); }
+ m_opaque_sp->SetGroupID(gid);
+}
SBFileSpec SBLaunchInfo::GetExecutableFile() {
- return SBFileSpec(m_opaque_sp->GetExecutableFile());
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBLaunchInfo, GetExecutableFile);
+
+ return LLDB_RECORD_RESULT(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);
+
m_opaque_sp->SetExecutableFile(exe_file.ref(), add_as_first_arg);
}
SBListener SBLaunchInfo::GetListener() {
- return SBListener(m_opaque_sp->GetListener());
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBLaunchInfo, GetListener);
+
+ return LLDB_RECORD_RESULT(SBListener(m_opaque_sp->GetListener()));
}
void SBLaunchInfo::SetListener(SBListener &listener) {
+ LLDB_RECORD_METHOD(void, SBLaunchInfo, SetListener, (lldb::SBListener &),
+ listener);
+
m_opaque_sp->SetListener(listener.GetSP());
}
uint32_t SBLaunchInfo::GetNumArguments() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetNumArguments);
+
return m_opaque_sp->GetArguments().GetArgumentCount();
}
const char *SBLaunchInfo::GetArgumentAtIndex(uint32_t idx) {
+ LLDB_RECORD_METHOD(const char *, SBLaunchInfo, GetArgumentAtIndex, (uint32_t),
+ idx);
+
return m_opaque_sp->GetArguments().GetArgumentAtIndex(idx);
}
void SBLaunchInfo::SetArguments(const char **argv, bool append) {
+ LLDB_RECORD_METHOD(void, SBLaunchInfo, SetArguments, (const char **, bool),
+ argv, append);
+
if (append) {
if (argv)
m_opaque_sp->GetArguments().AppendArguments(argv);
}
uint32_t SBLaunchInfo::GetNumEnvironmentEntries() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetNumEnvironmentEntries);
+
return m_opaque_sp->GetEnvironment().size();
}
const char *SBLaunchInfo::GetEnvironmentEntryAtIndex(uint32_t idx) {
+ LLDB_RECORD_METHOD(const char *, SBLaunchInfo, GetEnvironmentEntryAtIndex,
+ (uint32_t), idx);
+
if (idx > GetNumEnvironmentEntries())
return nullptr;
return m_opaque_sp->GetEnvp()[idx];
}
void SBLaunchInfo::SetEnvironmentEntries(const char **envp, bool append) {
+ LLDB_RECORD_METHOD(void, SBLaunchInfo, SetEnvironmentEntries,
+ (const char **, bool), envp, append);
+
Environment env(envp);
if (append)
m_opaque_sp->GetEnvironment().insert(env.begin(), env.end());
m_opaque_sp->RegenerateEnvp();
}
-void SBLaunchInfo::Clear() { m_opaque_sp->Clear(); }
+void SBLaunchInfo::Clear() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBLaunchInfo, Clear);
+
+ m_opaque_sp->Clear();
+}
const char *SBLaunchInfo::GetWorkingDirectory() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBLaunchInfo,
+ GetWorkingDirectory);
+
return m_opaque_sp->GetWorkingDirectory().GetCString();
}
void SBLaunchInfo::SetWorkingDirectory(const char *working_dir) {
+ LLDB_RECORD_METHOD(void, SBLaunchInfo, SetWorkingDirectory, (const char *),
+ working_dir);
+
m_opaque_sp->SetWorkingDirectory(FileSpec(working_dir));
}
uint32_t SBLaunchInfo::GetLaunchFlags() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetLaunchFlags);
+
return m_opaque_sp->GetFlags().Get();
}
void SBLaunchInfo::SetLaunchFlags(uint32_t flags) {
+ LLDB_RECORD_METHOD(void, SBLaunchInfo, SetLaunchFlags, (uint32_t), flags);
+
m_opaque_sp->GetFlags().Reset(flags);
}
const char *SBLaunchInfo::GetProcessPluginName() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBLaunchInfo, GetProcessPluginName);
+
return m_opaque_sp->GetProcessPluginName();
}
void SBLaunchInfo::SetProcessPluginName(const char *plugin_name) {
+ LLDB_RECORD_METHOD(void, SBLaunchInfo, SetProcessPluginName, (const char *),
+ plugin_name);
+
return m_opaque_sp->SetProcessPluginName(plugin_name);
}
const char *SBLaunchInfo::GetShell() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBLaunchInfo, GetShell);
+
// Constify this string so that it is saved in the string pool. Otherwise it
// would be freed when this function goes out of scope.
ConstString shell(m_opaque_sp->GetShell().GetPath().c_str());
}
void SBLaunchInfo::SetShell(const char *path) {
+ LLDB_RECORD_METHOD(void, SBLaunchInfo, SetShell, (const char *), path);
+
m_opaque_sp->SetShell(FileSpec(path));
}
bool SBLaunchInfo::GetShellExpandArguments() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBLaunchInfo, GetShellExpandArguments);
+
return m_opaque_sp->GetShellExpandArguments();
}
void SBLaunchInfo::SetShellExpandArguments(bool expand) {
+ LLDB_RECORD_METHOD(void, SBLaunchInfo, SetShellExpandArguments, (bool),
+ expand);
+
m_opaque_sp->SetShellExpandArguments(expand);
}
uint32_t SBLaunchInfo::GetResumeCount() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetResumeCount);
+
return m_opaque_sp->GetResumeCount();
}
void SBLaunchInfo::SetResumeCount(uint32_t c) {
+ LLDB_RECORD_METHOD(void, SBLaunchInfo, SetResumeCount, (uint32_t), c);
+
m_opaque_sp->SetResumeCount(c);
}
bool SBLaunchInfo::AddCloseFileAction(int fd) {
+ LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddCloseFileAction, (int), fd);
+
return m_opaque_sp->AppendCloseFileAction(fd);
}
bool SBLaunchInfo::AddDuplicateFileAction(int fd, int dup_fd) {
+ LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddDuplicateFileAction, (int, int), fd,
+ dup_fd);
+
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);
+
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);
+
return m_opaque_sp->AppendSuppressFileAction(fd, read, write);
}
void SBLaunchInfo::SetLaunchEventData(const char *data) {
+ LLDB_RECORD_METHOD(void, SBLaunchInfo, SetLaunchEventData, (const char *),
+ data);
+
m_opaque_sp->SetLaunchEventData(data);
}
const char *SBLaunchInfo::GetLaunchEventData() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBLaunchInfo,
+ GetLaunchEventData);
+
return m_opaque_sp->GetLaunchEventData();
}
void SBLaunchInfo::SetDetachOnError(bool enable) {
+ LLDB_RECORD_METHOD(void, SBLaunchInfo, SetDetachOnError, (bool), enable);
+
m_opaque_sp->SetDetachOnError(enable);
}
bool SBLaunchInfo::GetDetachOnError() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBLaunchInfo, GetDetachOnError);
+
return m_opaque_sp->GetDetachOnError();
}
//===----------------------------------------------------------------------===//
#include "lldb/API/SBLineEntry.h"
+#include "SBReproducerPrivate.h"
#include "Utils.h"
#include "lldb/API/SBStream.h"
#include "lldb/Host/PosixApi.h"
using namespace lldb;
using namespace lldb_private;
-SBLineEntry::SBLineEntry() : m_opaque_up() {}
+SBLineEntry::SBLineEntry() : m_opaque_up() {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBLineEntry);
+}
SBLineEntry::SBLineEntry(const SBLineEntry &rhs) : m_opaque_up() {
+ LLDB_RECORD_CONSTRUCTOR(SBLineEntry, (const lldb::SBLineEntry &), rhs);
+
m_opaque_up = clone(rhs.m_opaque_up);
}
}
const SBLineEntry &SBLineEntry::operator=(const SBLineEntry &rhs) {
+ LLDB_RECORD_METHOD(const lldb::SBLineEntry &,
+ SBLineEntry, operator=,(const lldb::SBLineEntry &), rhs);
+
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
return *this;
SBLineEntry::~SBLineEntry() {}
SBAddress SBLineEntry::GetStartAddress() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBLineEntry,
+ GetStartAddress);
+
SBAddress sb_address;
if (m_opaque_up)
sb_address.SetAddress(&m_opaque_up->range.GetBaseAddress());
static_cast<void *>(sb_address.get()), sstr.GetData());
}
- return sb_address;
+ return LLDB_RECORD_RESULT(sb_address);
}
SBAddress SBLineEntry::GetEndAddress() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBLineEntry, GetEndAddress);
+
SBAddress sb_address;
if (m_opaque_up) {
sb_address.SetAddress(&m_opaque_up->range.GetBaseAddress());
static_cast<void *>(m_opaque_up.get()),
static_cast<void *>(sb_address.get()), sstr.GetData());
}
- return sb_address;
+ return LLDB_RECORD_RESULT(sb_address);
}
bool SBLineEntry::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBLineEntry, IsValid);
+
return m_opaque_up.get() && m_opaque_up->IsValid();
}
SBFileSpec SBLineEntry::GetFileSpec() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBLineEntry, GetFileSpec);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBFileSpec sb_file_spec;
static_cast<const void *>(sb_file_spec.get()), sstr.GetData());
}
- return sb_file_spec;
+ return LLDB_RECORD_RESULT(sb_file_spec);
}
uint32_t SBLineEntry::GetLine() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBLineEntry, GetLine);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
uint32_t line = 0;
}
uint32_t SBLineEntry::GetColumn() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBLineEntry, GetColumn);
+
if (m_opaque_up)
return m_opaque_up->column;
return 0;
}
void SBLineEntry::SetFileSpec(lldb::SBFileSpec filespec) {
+ LLDB_RECORD_METHOD(void, SBLineEntry, SetFileSpec, (lldb::SBFileSpec),
+ filespec);
+
if (filespec.IsValid())
ref().file = filespec.ref();
else
ref().file.Clear();
}
-void SBLineEntry::SetLine(uint32_t line) { ref().line = line; }
+void SBLineEntry::SetLine(uint32_t line) {
+ LLDB_RECORD_METHOD(void, SBLineEntry, SetLine, (uint32_t), line);
+
+ ref().line = line;
+}
+
+void SBLineEntry::SetColumn(uint32_t column) {
+ LLDB_RECORD_METHOD(void, SBLineEntry, SetColumn, (uint32_t), column);
-void SBLineEntry::SetColumn(uint32_t column) { ref().line = column; }
+ ref().line = column;
+}
bool SBLineEntry::operator==(const SBLineEntry &rhs) const {
+ LLDB_RECORD_METHOD_CONST(
+ bool, SBLineEntry, operator==,(const lldb::SBLineEntry &), rhs);
+
lldb_private::LineEntry *lhs_ptr = m_opaque_up.get();
lldb_private::LineEntry *rhs_ptr = rhs.m_opaque_up.get();
}
bool SBLineEntry::operator!=(const SBLineEntry &rhs) const {
+ LLDB_RECORD_METHOD_CONST(
+ bool, SBLineEntry, operator!=,(const lldb::SBLineEntry &), rhs);
+
lldb_private::LineEntry *lhs_ptr = m_opaque_up.get();
lldb_private::LineEntry *rhs_ptr = rhs.m_opaque_up.get();
const lldb_private::LineEntry &SBLineEntry::ref() const { return *m_opaque_up; }
bool SBLineEntry::GetDescription(SBStream &description) {
+ LLDB_RECORD_METHOD(bool, SBLineEntry, GetDescription, (lldb::SBStream &),
+ description);
+
Stream &strm = description.ref();
if (m_opaque_up) {
//===----------------------------------------------------------------------===//
#include "lldb/API/SBListener.h"
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBBroadcaster.h"
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBEvent.h"
using namespace lldb;
using namespace lldb_private;
-SBListener::SBListener() : m_opaque_sp(), m_unused_ptr(NULL) {}
+SBListener::SBListener() : m_opaque_sp(), m_unused_ptr(NULL) {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBListener);
+}
SBListener::SBListener(const char *name)
: m_opaque_sp(Listener::MakeListener(name)), m_unused_ptr(nullptr) {
+ LLDB_RECORD_CONSTRUCTOR(SBListener, (const char *), name);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
}
SBListener::SBListener(const SBListener &rhs)
- : m_opaque_sp(rhs.m_opaque_sp), m_unused_ptr(nullptr) {}
+ : m_opaque_sp(rhs.m_opaque_sp), m_unused_ptr(nullptr) {
+ LLDB_RECORD_CONSTRUCTOR(SBListener, (const lldb::SBListener &), rhs);
+}
const lldb::SBListener &SBListener::operator=(const lldb::SBListener &rhs) {
+ LLDB_RECORD_METHOD(const lldb::SBListener &,
+ SBListener, operator=,(const lldb::SBListener &), rhs);
+
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
m_unused_ptr = nullptr;
SBListener::~SBListener() {}
-bool SBListener::IsValid() const { return m_opaque_sp != nullptr; }
+bool SBListener::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBListener, IsValid);
+
+ return m_opaque_sp != nullptr;
+}
void SBListener::AddEvent(const SBEvent &event) {
+ LLDB_RECORD_METHOD(void, SBListener, AddEvent, (const lldb::SBEvent &),
+ event);
+
EventSP &event_sp = event.GetSP();
if (event_sp)
m_opaque_sp->AddEvent(event_sp);
}
void SBListener::Clear() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBListener, Clear);
+
if (m_opaque_sp)
m_opaque_sp->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);
+
if (m_opaque_sp) {
Debugger *lldb_debugger = debugger.get();
if (!lldb_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);
+
if (m_opaque_sp) {
Debugger *lldb_debugger = debugger.get();
if (!lldb_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);
+
uint32_t acquired_event_mask = 0;
if (m_opaque_sp && broadcaster.IsValid()) {
acquired_event_mask =
bool SBListener::StopListeningForEvents(const SBBroadcaster &broadcaster,
uint32_t event_mask) {
+ LLDB_RECORD_METHOD(bool, SBListener, StopListeningForEvents,
+ (const lldb::SBBroadcaster &, uint32_t), broadcaster,
+ event_mask);
+
if (m_opaque_sp && broadcaster.IsValid()) {
return m_opaque_sp->StopListeningForEvents(broadcaster.get(), event_mask);
}
}
bool SBListener::WaitForEvent(uint32_t timeout_secs, SBEvent &event) {
+ LLDB_RECORD_METHOD(bool, SBListener, WaitForEvent,
+ (uint32_t, lldb::SBEvent &), timeout_secs, event);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log) {
if (timeout_secs == UINT32_MAX) {
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);
+
if (m_opaque_sp && broadcaster.IsValid()) {
Timeout<std::micro> timeout(llvm::None);
if (num_seconds != UINT32_MAX)
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);
+
if (m_opaque_sp && broadcaster.IsValid()) {
Timeout<std::micro> timeout(llvm::None);
if (num_seconds != UINT32_MAX)
}
bool SBListener::PeekAtNextEvent(SBEvent &event) {
+ LLDB_RECORD_METHOD(bool, SBListener, PeekAtNextEvent, (lldb::SBEvent &),
+ event);
+
if (m_opaque_sp) {
event.reset(m_opaque_sp->PeekAtNextEvent());
return event.IsValid();
bool SBListener::PeekAtNextEventForBroadcaster(const SBBroadcaster &broadcaster,
SBEvent &event) {
+ LLDB_RECORD_METHOD(bool, SBListener, PeekAtNextEventForBroadcaster,
+ (const lldb::SBBroadcaster &, lldb::SBEvent &),
+ broadcaster, event);
+
if (m_opaque_sp && broadcaster.IsValid()) {
event.reset(m_opaque_sp->PeekAtNextEventForBroadcaster(broadcaster.get()));
return event.IsValid();
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);
+
if (m_opaque_sp && broadcaster.IsValid()) {
event.reset(m_opaque_sp->PeekAtNextEventForBroadcasterWithType(
broadcaster.get(), event_type_mask));
}
bool SBListener::GetNextEvent(SBEvent &event) {
+ LLDB_RECORD_METHOD(bool, SBListener, GetNextEvent, (lldb::SBEvent &), event);
+
if (m_opaque_sp) {
EventSP event_sp;
if (m_opaque_sp->GetEvent(event_sp, std::chrono::seconds(0))) {
bool SBListener::GetNextEventForBroadcaster(const SBBroadcaster &broadcaster,
SBEvent &event) {
+ LLDB_RECORD_METHOD(bool, SBListener, GetNextEventForBroadcaster,
+ (const lldb::SBBroadcaster &, lldb::SBEvent &),
+ broadcaster, event);
+
if (m_opaque_sp && broadcaster.IsValid()) {
EventSP event_sp;
if (m_opaque_sp->GetEventForBroadcaster(broadcaster.get(), event_sp,
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);
+
if (m_opaque_sp && broadcaster.IsValid()) {
EventSP event_sp;
if (m_opaque_sp->GetEventForBroadcasterWithType(broadcaster.get(),
}
bool SBListener::HandleBroadcastEvent(const SBEvent &event) {
+ LLDB_RECORD_METHOD(bool, SBListener, HandleBroadcastEvent,
+ (const lldb::SBEvent &), event);
+
if (m_opaque_sp)
return m_opaque_sp->HandleBroadcastEvent(event.GetSP());
return false;
//===----------------------------------------------------------------------===//
#include "lldb/API/SBMemoryRegionInfo.h"
+#include "SBReproducerPrivate.h"
#include "Utils.h"
#include "lldb/API/SBDefines.h"
#include "lldb/API/SBError.h"
using namespace lldb;
using namespace lldb_private;
-SBMemoryRegionInfo::SBMemoryRegionInfo()
- : m_opaque_up(new MemoryRegionInfo()) {}
+SBMemoryRegionInfo::SBMemoryRegionInfo() : m_opaque_up(new MemoryRegionInfo()) {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBMemoryRegionInfo);
+}
SBMemoryRegionInfo::SBMemoryRegionInfo(const MemoryRegionInfo *lldb_object_ptr)
: m_opaque_up(new MemoryRegionInfo()) {
SBMemoryRegionInfo::SBMemoryRegionInfo(const SBMemoryRegionInfo &rhs)
: m_opaque_up() {
+ LLDB_RECORD_CONSTRUCTOR(SBMemoryRegionInfo,
+ (const lldb::SBMemoryRegionInfo &), rhs);
m_opaque_up = clone(rhs.m_opaque_up);
}
const SBMemoryRegionInfo &SBMemoryRegionInfo::
operator=(const SBMemoryRegionInfo &rhs) {
+ LLDB_RECORD_METHOD(
+ const lldb::SBMemoryRegionInfo &,
+ SBMemoryRegionInfo, operator=,(const lldb::SBMemoryRegionInfo &), rhs);
+
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
return *this;
SBMemoryRegionInfo::~SBMemoryRegionInfo() {}
-void SBMemoryRegionInfo::Clear() { m_opaque_up->Clear(); }
+void SBMemoryRegionInfo::Clear() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBMemoryRegionInfo, Clear);
+
+ m_opaque_up->Clear();
+}
bool SBMemoryRegionInfo::operator==(const SBMemoryRegionInfo &rhs) const {
+ LLDB_RECORD_METHOD_CONST(
+ bool, SBMemoryRegionInfo, operator==,(const lldb::SBMemoryRegionInfo &),
+ rhs);
+
return ref() == rhs.ref();
}
bool SBMemoryRegionInfo::operator!=(const SBMemoryRegionInfo &rhs) const {
+ LLDB_RECORD_METHOD_CONST(
+ bool, SBMemoryRegionInfo, operator!=,(const lldb::SBMemoryRegionInfo &),
+ rhs);
+
return ref() != rhs.ref();
}
const MemoryRegionInfo &SBMemoryRegionInfo::ref() const { return *m_opaque_up; }
lldb::addr_t SBMemoryRegionInfo::GetRegionBase() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBMemoryRegionInfo, GetRegionBase);
+
return m_opaque_up->GetRange().GetRangeBase();
}
lldb::addr_t SBMemoryRegionInfo::GetRegionEnd() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBMemoryRegionInfo, GetRegionEnd);
+
return m_opaque_up->GetRange().GetRangeEnd();
}
bool SBMemoryRegionInfo::IsReadable() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsReadable);
+
return m_opaque_up->GetReadable() == MemoryRegionInfo::eYes;
}
bool SBMemoryRegionInfo::IsWritable() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsWritable);
+
return m_opaque_up->GetWritable() == MemoryRegionInfo::eYes;
}
bool SBMemoryRegionInfo::IsExecutable() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsExecutable);
+
return m_opaque_up->GetExecutable() == MemoryRegionInfo::eYes;
}
bool SBMemoryRegionInfo::IsMapped() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsMapped);
+
return m_opaque_up->GetMapped() == MemoryRegionInfo::eYes;
}
const char *SBMemoryRegionInfo::GetName() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBMemoryRegionInfo, GetName);
+
return m_opaque_up->GetName().AsCString();
}
bool SBMemoryRegionInfo::GetDescription(SBStream &description) {
+ LLDB_RECORD_METHOD(bool, SBMemoryRegionInfo, GetDescription,
+ (lldb::SBStream &), description);
+
Stream &strm = description.ref();
const addr_t load_addr = m_opaque_up->GetRange().base;
//===----------------------------------------------------------------------===//
#include "lldb/API/SBMemoryRegionInfoList.h"
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBMemoryRegionInfo.h"
#include "lldb/API/SBStream.h"
#include "lldb/Target/MemoryRegionInfo.h"
}
SBMemoryRegionInfoList::SBMemoryRegionInfoList()
- : m_opaque_up(new MemoryRegionInfoListImpl()) {}
+ : m_opaque_up(new MemoryRegionInfoListImpl()) {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBMemoryRegionInfoList);
+}
SBMemoryRegionInfoList::SBMemoryRegionInfoList(
const SBMemoryRegionInfoList &rhs)
- : m_opaque_up(new MemoryRegionInfoListImpl(*rhs.m_opaque_up)) {}
+ : m_opaque_up(new MemoryRegionInfoListImpl(*rhs.m_opaque_up)) {
+ LLDB_RECORD_CONSTRUCTOR(SBMemoryRegionInfoList,
+ (const lldb::SBMemoryRegionInfoList &), rhs);
+}
SBMemoryRegionInfoList::~SBMemoryRegionInfoList() {}
const SBMemoryRegionInfoList &SBMemoryRegionInfoList::
operator=(const SBMemoryRegionInfoList &rhs) {
+ LLDB_RECORD_METHOD(
+ const lldb::SBMemoryRegionInfoList &,
+ SBMemoryRegionInfoList, operator=,(const lldb::SBMemoryRegionInfoList &),
+ rhs);
+
if (this != &rhs) {
*m_opaque_up = *rhs.m_opaque_up;
}
}
uint32_t SBMemoryRegionInfoList::GetSize() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBMemoryRegionInfoList, GetSize);
+
return m_opaque_up->GetSize();
}
bool SBMemoryRegionInfoList::GetMemoryRegionAtIndex(
uint32_t idx, SBMemoryRegionInfo ®ion_info) {
+ LLDB_RECORD_METHOD(bool, SBMemoryRegionInfoList, GetMemoryRegionAtIndex,
+ (uint32_t, lldb::SBMemoryRegionInfo &), idx, region_info);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
bool result = m_opaque_up->GetMemoryRegionInfoAtIndex(idx, region_info.ref());
return result;
}
-void SBMemoryRegionInfoList::Clear() { m_opaque_up->Clear(); }
+void SBMemoryRegionInfoList::Clear() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBMemoryRegionInfoList, Clear);
+
+ m_opaque_up->Clear();
+}
void SBMemoryRegionInfoList::Append(SBMemoryRegionInfo &sb_region) {
+ LLDB_RECORD_METHOD(void, SBMemoryRegionInfoList, Append,
+ (lldb::SBMemoryRegionInfo &), sb_region);
+
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);
+
m_opaque_up->Append(*sb_region_list);
}
//===----------------------------------------------------------------------===//
#include "lldb/API/SBModule.h"
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBFileSpec.h"
#include "lldb/API/SBModuleSpec.h"
using namespace lldb;
using namespace lldb_private;
-SBModule::SBModule() : m_opaque_sp() {}
+SBModule::SBModule() : m_opaque_sp() {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBModule);
+}
SBModule::SBModule(const lldb::ModuleSP &module_sp) : m_opaque_sp(module_sp) {}
SBModule::SBModule(const SBModuleSpec &module_spec) : m_opaque_sp() {
+ LLDB_RECORD_CONSTRUCTOR(SBModule, (const lldb::SBModuleSpec &), module_spec);
+
ModuleSP module_sp;
Status error = ModuleList::GetSharedModule(*module_spec.m_opaque_up,
module_sp, NULL, NULL, NULL);
SetSP(module_sp);
}
-SBModule::SBModule(const SBModule &rhs) : m_opaque_sp(rhs.m_opaque_sp) {}
+SBModule::SBModule(const SBModule &rhs) : m_opaque_sp(rhs.m_opaque_sp) {
+ LLDB_RECORD_CONSTRUCTOR(SBModule, (const lldb::SBModule &), rhs);
+}
SBModule::SBModule(lldb::SBProcess &process, lldb::addr_t header_addr)
: m_opaque_sp() {
+ LLDB_RECORD_CONSTRUCTOR(SBModule, (lldb::SBProcess &, lldb::addr_t), process,
+ header_addr);
+
ProcessSP process_sp(process.GetSP());
if (process_sp) {
m_opaque_sp = process_sp->ReadModuleFromMemory(FileSpec(), header_addr);
}
const SBModule &SBModule::operator=(const SBModule &rhs) {
+ LLDB_RECORD_METHOD(const lldb::SBModule &,
+ SBModule, operator=,(const lldb::SBModule &), rhs);
+
if (this != &rhs)
m_opaque_sp = rhs.m_opaque_sp;
return *this;
SBModule::~SBModule() {}
-bool SBModule::IsValid() const { return m_opaque_sp.get() != NULL; }
+bool SBModule::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModule, IsValid);
+
+ return m_opaque_sp.get() != NULL;
+}
+
+void SBModule::Clear() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBModule, Clear);
-void SBModule::Clear() { m_opaque_sp.reset(); }
+ m_opaque_sp.reset();
+}
SBFileSpec SBModule::GetFileSpec() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule, GetFileSpec);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBFileSpec file_spec;
static_cast<void *>(module_sp.get()),
static_cast<const void *>(file_spec.get()));
- return file_spec;
+ return LLDB_RECORD_RESULT(file_spec);
}
lldb::SBFileSpec SBModule::GetPlatformFileSpec() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule,
+ GetPlatformFileSpec);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBFileSpec file_spec;
static_cast<void *>(module_sp.get()),
static_cast<const void *>(file_spec.get()));
- return file_spec;
+ return LLDB_RECORD_RESULT(file_spec);
}
bool SBModule::SetPlatformFileSpec(const lldb::SBFileSpec &platform_file) {
+ LLDB_RECORD_METHOD(bool, SBModule, SetPlatformFileSpec,
+ (const lldb::SBFileSpec &), platform_file);
+
bool result = false;
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
}
lldb::SBFileSpec SBModule::GetRemoteInstallFileSpec() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModule,
+ GetRemoteInstallFileSpec);
+
SBFileSpec sb_file_spec;
ModuleSP module_sp(GetSP());
if (module_sp)
sb_file_spec.SetFileSpec(module_sp->GetRemoteInstallFileSpec());
- return sb_file_spec;
+ return LLDB_RECORD_RESULT(sb_file_spec);
}
bool SBModule::SetRemoteInstallFileSpec(lldb::SBFileSpec &file) {
+ LLDB_RECORD_METHOD(bool, SBModule, SetRemoteInstallFileSpec,
+ (lldb::SBFileSpec &), file);
+
ModuleSP module_sp(GetSP());
if (module_sp) {
module_sp->SetRemoteInstallFileSpec(file.ref());
}
const uint8_t *SBModule::GetUUIDBytes() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(const uint8_t *, SBModule, GetUUIDBytes);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
const uint8_t *uuid_bytes = NULL;
}
const char *SBModule::GetUUIDString() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBModule, GetUUIDString);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
const char *uuid_cstr = NULL;
}
bool SBModule::operator==(const SBModule &rhs) const {
+ LLDB_RECORD_METHOD_CONST(bool, SBModule, operator==,(const lldb::SBModule &),
+ rhs);
+
if (m_opaque_sp)
return m_opaque_sp.get() == rhs.m_opaque_sp.get();
return false;
}
bool SBModule::operator!=(const SBModule &rhs) const {
+ LLDB_RECORD_METHOD_CONST(bool, SBModule, operator!=,(const lldb::SBModule &),
+ rhs);
+
if (m_opaque_sp)
return m_opaque_sp.get() != rhs.m_opaque_sp.get();
return false;
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::SBAddress sb_addr;
ModuleSP module_sp(GetSP());
if (module_sp) {
if (module_sp->ResolveFileAddress(vm_addr, addr))
sb_addr.ref() = addr;
}
- return sb_addr;
+ return LLDB_RECORD_RESULT(sb_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);
+
SBSymbolContext sb_sc;
ModuleSP module_sp(GetSP());
SymbolContextItem scope = static_cast<SymbolContextItem>(resolve_scope);
if (module_sp && addr.IsValid())
module_sp->ResolveSymbolContextForAddress(addr.ref(), scope, *sb_sc);
- return sb_sc;
+ return LLDB_RECORD_RESULT(sb_sc);
}
bool SBModule::GetDescription(SBStream &description) {
+ LLDB_RECORD_METHOD(bool, SBModule, GetDescription, (lldb::SBStream &),
+ description);
+
Stream &strm = description.ref();
ModuleSP module_sp(GetSP());
}
uint32_t SBModule::GetNumCompileUnits() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBModule, GetNumCompileUnits);
+
ModuleSP module_sp(GetSP());
if (module_sp) {
return module_sp->GetNumCompileUnits();
}
SBCompileUnit SBModule::GetCompileUnitAtIndex(uint32_t index) {
+ LLDB_RECORD_METHOD(lldb::SBCompileUnit, SBModule, GetCompileUnitAtIndex,
+ (uint32_t), index);
+
SBCompileUnit sb_cu;
ModuleSP module_sp(GetSP());
if (module_sp) {
CompUnitSP cu_sp = module_sp->GetCompileUnitAtIndex(index);
sb_cu.reset(cu_sp.get());
}
- return sb_cu;
+ return LLDB_RECORD_RESULT(sb_cu);
}
-SBSymbolContextList
-SBModule::FindCompileUnits(const SBFileSpec &sb_file_spec) {
+SBSymbolContextList SBModule::FindCompileUnits(const SBFileSpec &sb_file_spec) {
+ LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBModule, FindCompileUnits,
+ (const lldb::SBFileSpec &), sb_file_spec);
+
SBSymbolContextList sb_sc_list;
const ModuleSP module_sp(GetSP());
if (sb_file_spec.IsValid() && module_sp) {
const bool append = true;
module_sp->FindCompileUnits(*sb_file_spec, append, *sb_sc_list);
}
- return sb_sc_list;
+ return LLDB_RECORD_RESULT(sb_sc_list);
}
static Symtab *GetUnifiedSymbolTable(const lldb::ModuleSP &module_sp) {
}
size_t SBModule::GetNumSymbols() {
+ LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModule, GetNumSymbols);
+
ModuleSP module_sp(GetSP());
if (module_sp) {
Symtab *symtab = GetUnifiedSymbolTable(module_sp);
}
SBSymbol SBModule::GetSymbolAtIndex(size_t idx) {
+ LLDB_RECORD_METHOD(lldb::SBSymbol, SBModule, GetSymbolAtIndex, (size_t), idx);
+
SBSymbol sb_symbol;
ModuleSP module_sp(GetSP());
Symtab *symtab = GetUnifiedSymbolTable(module_sp);
if (symtab)
sb_symbol.SetSymbol(symtab->SymbolAtIndex(idx));
- return sb_symbol;
+ return LLDB_RECORD_RESULT(sb_symbol);
}
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);
+
SBSymbol sb_symbol;
if (name && name[0]) {
ModuleSP module_sp(GetSP());
ConstString(name), symbol_type, Symtab::eDebugAny,
Symtab::eVisibilityAny));
}
- return sb_symbol;
+ return LLDB_RECORD_RESULT(sb_symbol);
}
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);
+
SBSymbolContextList sb_sc_list;
if (name && name[0]) {
ModuleSP module_sp(GetSP());
}
}
}
- return sb_sc_list;
+ return LLDB_RECORD_RESULT(sb_sc_list);
}
size_t SBModule::GetNumSections() {
+ LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModule, GetNumSections);
+
ModuleSP module_sp(GetSP());
if (module_sp) {
// Give the symbol vendor a chance to add to the unified section list.
}
SBSection SBModule::GetSectionAtIndex(size_t idx) {
+ LLDB_RECORD_METHOD(lldb::SBSection, SBModule, GetSectionAtIndex, (size_t),
+ idx);
+
SBSection sb_section;
ModuleSP module_sp(GetSP());
if (module_sp) {
if (section_list)
sb_section.SetSP(section_list->GetSectionAtIndex(idx));
}
- return sb_section;
+ return LLDB_RECORD_RESULT(sb_section);
}
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::SBSymbolContextList sb_sc_list;
ModuleSP module_sp(GetSP());
if (name && module_sp) {
module_sp->FindFunctions(ConstString(name), NULL, type, symbols_ok,
inlines_ok, append, *sb_sc_list);
}
- return sb_sc_list;
+ return LLDB_RECORD_RESULT(sb_sc_list);
}
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);
+
SBValueList sb_value_list;
ModuleSP module_sp(GetSP());
if (name && module_sp) {
}
}
- return sb_value_list;
+ return LLDB_RECORD_RESULT(sb_value_list);
}
lldb::SBValue SBModule::FindFirstGlobalVariable(lldb::SBTarget &target,
const char *name) {
+ LLDB_RECORD_METHOD(lldb::SBValue, SBModule, FindFirstGlobalVariable,
+ (lldb::SBTarget &, const char *), target, name);
+
SBValueList sb_value_list(FindGlobalVariables(target, name, 1));
if (sb_value_list.IsValid() && sb_value_list.GetSize() > 0)
- return sb_value_list.GetValueAtIndex(0);
- return SBValue();
+ return LLDB_RECORD_RESULT(sb_value_list.GetValueAtIndex(0));
+ return LLDB_RECORD_RESULT(SBValue());
}
lldb::SBType SBModule::FindFirstType(const char *name_cstr) {
+ LLDB_RECORD_METHOD(lldb::SBType, SBModule, FindFirstType, (const char *),
+ name_cstr);
+
SBType sb_type;
ModuleSP module_sp(GetSP());
if (name_cstr && module_sp) {
sb_type = SBType(type_system->GetBuiltinTypeByName(name));
}
}
- return sb_type;
+ return LLDB_RECORD_RESULT(sb_type);
}
lldb::SBType SBModule::GetBasicType(lldb::BasicType type) {
+ LLDB_RECORD_METHOD(lldb::SBType, SBModule, GetBasicType, (lldb::BasicType),
+ type);
+
ModuleSP module_sp(GetSP());
if (module_sp) {
TypeSystem *type_system =
module_sp->GetTypeSystemForLanguage(eLanguageTypeC);
if (type_system)
- return SBType(type_system->GetBasicTypeFromAST(type));
+ return LLDB_RECORD_RESULT(SBType(type_system->GetBasicTypeFromAST(type)));
}
- return SBType();
+ return LLDB_RECORD_RESULT(SBType());
}
lldb::SBTypeList SBModule::FindTypes(const char *type) {
+ LLDB_RECORD_METHOD(lldb::SBTypeList, SBModule, FindTypes, (const char *),
+ type);
+
SBTypeList retval;
ModuleSP module_sp(GetSP());
}
}
- return retval;
+ return LLDB_RECORD_RESULT(retval);
}
lldb::SBType SBModule::GetTypeByID(lldb::user_id_t uid) {
+ LLDB_RECORD_METHOD(lldb::SBType, SBModule, GetTypeByID, (lldb::user_id_t),
+ uid);
+
ModuleSP module_sp(GetSP());
if (module_sp) {
SymbolVendor *vendor = module_sp->GetSymbolVendor();
if (vendor) {
Type *type_ptr = vendor->ResolveTypeUID(uid);
if (type_ptr)
- return SBType(type_ptr->shared_from_this());
+ return LLDB_RECORD_RESULT(SBType(type_ptr->shared_from_this()));
}
}
- return SBType();
+ return LLDB_RECORD_RESULT(SBType());
}
lldb::SBTypeList SBModule::GetTypes(uint32_t type_mask) {
+ LLDB_RECORD_METHOD(lldb::SBTypeList, SBModule, GetTypes, (uint32_t),
+ type_mask);
+
SBTypeList sb_type_list;
ModuleSP module_sp(GetSP());
if (!module_sp)
- return sb_type_list;
+ return LLDB_RECORD_RESULT(sb_type_list);
SymbolVendor *vendor = module_sp->GetSymbolVendor();
if (!vendor)
- return sb_type_list;
+ return LLDB_RECORD_RESULT(sb_type_list);
TypeClass type_class = static_cast<TypeClass>(type_mask);
TypeList type_list;
vendor->GetTypes(NULL, type_class, type_list);
sb_type_list.m_opaque_up->Append(type_list);
- return sb_type_list;
+ return LLDB_RECORD_RESULT(sb_type_list);
}
SBSection SBModule::FindSection(const char *sect_name) {
+ LLDB_RECORD_METHOD(lldb::SBSection, SBModule, FindSection, (const char *),
+ sect_name);
+
SBSection sb_section;
ModuleSP module_sp(GetSP());
}
}
}
- return sb_section;
+ return LLDB_RECORD_RESULT(sb_section);
}
lldb::ByteOrder SBModule::GetByteOrder() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::ByteOrder, SBModule, GetByteOrder);
+
ModuleSP module_sp(GetSP());
if (module_sp)
return module_sp->GetArchitecture().GetByteOrder();
}
const char *SBModule::GetTriple() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBModule, GetTriple);
+
ModuleSP module_sp(GetSP());
if (module_sp) {
std::string triple(module_sp->GetArchitecture().GetTriple().str());
}
uint32_t SBModule::GetAddressByteSize() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBModule, GetAddressByteSize);
+
ModuleSP module_sp(GetSP());
if (module_sp)
return module_sp->GetArchitecture().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);
+
llvm::VersionTuple version;
if (ModuleSP module_sp = GetSP())
version = module_sp->GetVersion();
}
lldb::SBFileSpec SBModule::GetSymbolFileSpec() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule,
+ GetSymbolFileSpec);
+
lldb::SBFileSpec sb_file_spec;
ModuleSP module_sp(GetSP());
if (module_sp) {
if (symbol_vendor_ptr)
sb_file_spec.SetFileSpec(symbol_vendor_ptr->GetMainFileSpec());
}
- return sb_file_spec;
+ return LLDB_RECORD_RESULT(sb_file_spec);
}
lldb::SBAddress SBModule::GetObjectFileHeaderAddress() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBModule,
+ GetObjectFileHeaderAddress);
+
lldb::SBAddress sb_addr;
ModuleSP module_sp(GetSP());
if (module_sp) {
if (objfile_ptr)
sb_addr.ref() = objfile_ptr->GetBaseAddress();
}
- return sb_addr;
+ return LLDB_RECORD_RESULT(sb_addr);
}
lldb::SBAddress SBModule::GetObjectFileEntryPointAddress() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBModule,
+ GetObjectFileEntryPointAddress);
+
lldb::SBAddress sb_addr;
ModuleSP module_sp(GetSP());
if (module_sp) {
if (objfile_ptr)
sb_addr.ref() = objfile_ptr->GetEntryPointAddress();
}
- return sb_addr;
+ return LLDB_RECORD_RESULT(sb_addr);
}
//===----------------------------------------------------------------------===//
#include "lldb/API/SBModuleSpec.h"
+#include "SBReproducerPrivate.h"
#include "Utils.h"
#include "lldb/API/SBStream.h"
#include "lldb/Core/Module.h"
using namespace lldb;
using namespace lldb_private;
-SBModuleSpec::SBModuleSpec() : m_opaque_up(new lldb_private::ModuleSpec()) {}
+SBModuleSpec::SBModuleSpec() : m_opaque_up(new lldb_private::ModuleSpec()) {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBModuleSpec);
+}
SBModuleSpec::SBModuleSpec(const SBModuleSpec &rhs) : m_opaque_up() {
+ LLDB_RECORD_CONSTRUCTOR(SBModuleSpec, (const lldb::SBModuleSpec &), rhs);
+
m_opaque_up = clone(rhs.m_opaque_up);
}
const SBModuleSpec &SBModuleSpec::operator=(const SBModuleSpec &rhs) {
+ LLDB_RECORD_METHOD(const lldb::SBModuleSpec &,
+ SBModuleSpec, operator=,(const lldb::SBModuleSpec &), rhs);
+
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
return *this;
SBModuleSpec::~SBModuleSpec() {}
-bool SBModuleSpec::IsValid() const { return m_opaque_up->operator bool(); }
+bool SBModuleSpec::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModuleSpec, IsValid);
+
+ return m_opaque_up->operator bool();
+}
+
+void SBModuleSpec::Clear() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBModuleSpec, Clear);
-void SBModuleSpec::Clear() { m_opaque_up->Clear(); }
+ m_opaque_up->Clear();
+}
SBFileSpec SBModuleSpec::GetFileSpec() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModuleSpec, GetFileSpec);
+
SBFileSpec sb_spec(m_opaque_up->GetFileSpec());
- return sb_spec;
+ return LLDB_RECORD_RESULT(sb_spec);
}
void SBModuleSpec::SetFileSpec(const lldb::SBFileSpec &sb_spec) {
+ LLDB_RECORD_METHOD(void, SBModuleSpec, SetFileSpec,
+ (const lldb::SBFileSpec &), sb_spec);
+
m_opaque_up->GetFileSpec() = *sb_spec;
}
lldb::SBFileSpec SBModuleSpec::GetPlatformFileSpec() {
- return SBFileSpec(m_opaque_up->GetPlatformFileSpec());
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModuleSpec,
+ GetPlatformFileSpec);
+
+ return LLDB_RECORD_RESULT(SBFileSpec(m_opaque_up->GetPlatformFileSpec()));
}
void SBModuleSpec::SetPlatformFileSpec(const lldb::SBFileSpec &sb_spec) {
+ LLDB_RECORD_METHOD(void, SBModuleSpec, SetPlatformFileSpec,
+ (const lldb::SBFileSpec &), sb_spec);
+
m_opaque_up->GetPlatformFileSpec() = *sb_spec;
}
lldb::SBFileSpec SBModuleSpec::GetSymbolFileSpec() {
- return SBFileSpec(m_opaque_up->GetSymbolFileSpec());
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModuleSpec, GetSymbolFileSpec);
+
+ return LLDB_RECORD_RESULT(SBFileSpec(m_opaque_up->GetSymbolFileSpec()));
}
void SBModuleSpec::SetSymbolFileSpec(const lldb::SBFileSpec &sb_spec) {
+ LLDB_RECORD_METHOD(void, SBModuleSpec, SetSymbolFileSpec,
+ (const lldb::SBFileSpec &), sb_spec);
+
m_opaque_up->GetSymbolFileSpec() = *sb_spec;
}
const char *SBModuleSpec::GetObjectName() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBModuleSpec, GetObjectName);
+
return m_opaque_up->GetObjectName().GetCString();
}
void SBModuleSpec::SetObjectName(const char *name) {
+ LLDB_RECORD_METHOD(void, SBModuleSpec, SetObjectName, (const char *), name);
+
m_opaque_up->GetObjectName().SetCString(name);
}
const char *SBModuleSpec::GetTriple() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBModuleSpec, GetTriple);
+
std::string triple(m_opaque_up->GetArchitecture().GetTriple().str());
// Unique the string so we don't run into ownership issues since the const
// strings put the string into the string pool once and the strings never
}
void SBModuleSpec::SetTriple(const char *triple) {
+ LLDB_RECORD_METHOD(void, SBModuleSpec, SetTriple, (const char *), triple);
+
m_opaque_up->GetArchitecture().SetTriple(triple);
}
}
size_t SBModuleSpec::GetUUIDLength() {
+ LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModuleSpec, GetUUIDLength);
+
return m_opaque_up->GetUUID().GetBytes().size();
}
}
bool SBModuleSpec::GetDescription(lldb::SBStream &description) {
+ LLDB_RECORD_METHOD(bool, SBModuleSpec, GetDescription, (lldb::SBStream &),
+ description);
+
m_opaque_up->Dump(description.ref());
return true;
}
-SBModuleSpecList::SBModuleSpecList() : m_opaque_up(new ModuleSpecList()) {}
+SBModuleSpecList::SBModuleSpecList() : m_opaque_up(new ModuleSpecList()) {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBModuleSpecList);
+}
SBModuleSpecList::SBModuleSpecList(const SBModuleSpecList &rhs)
- : m_opaque_up(new ModuleSpecList(*rhs.m_opaque_up)) {}
+ : m_opaque_up(new ModuleSpecList(*rhs.m_opaque_up)) {
+ LLDB_RECORD_CONSTRUCTOR(SBModuleSpecList, (const lldb::SBModuleSpecList &),
+ rhs);
+}
SBModuleSpecList &SBModuleSpecList::operator=(const SBModuleSpecList &rhs) {
+ LLDB_RECORD_METHOD(
+ lldb::SBModuleSpecList &,
+ SBModuleSpecList, operator=,(const lldb::SBModuleSpecList &), rhs);
+
if (this != &rhs)
*m_opaque_up = *rhs.m_opaque_up;
return *this;
SBModuleSpecList::~SBModuleSpecList() {}
SBModuleSpecList SBModuleSpecList::GetModuleSpecifications(const char *path) {
+ LLDB_RECORD_STATIC_METHOD(lldb::SBModuleSpecList, SBModuleSpecList,
+ GetModuleSpecifications, (const char *), path);
+
SBModuleSpecList specs;
FileSpec file_spec(path);
FileSystem::Instance().Resolve(file_spec);
Host::ResolveExecutableInBundle(file_spec);
ObjectFile::GetModuleSpecifications(file_spec, 0, 0, *specs.m_opaque_up);
- return specs;
+ return LLDB_RECORD_RESULT(specs);
}
void SBModuleSpecList::Append(const SBModuleSpec &spec) {
+ LLDB_RECORD_METHOD(void, SBModuleSpecList, Append,
+ (const lldb::SBModuleSpec &), spec);
+
m_opaque_up->Append(*spec.m_opaque_up);
}
void SBModuleSpecList::Append(const SBModuleSpecList &spec_list) {
+ LLDB_RECORD_METHOD(void, SBModuleSpecList, Append,
+ (const lldb::SBModuleSpecList &), spec_list);
+
m_opaque_up->Append(*spec_list.m_opaque_up);
}
-size_t SBModuleSpecList::GetSize() { return m_opaque_up->GetSize(); }
+size_t SBModuleSpecList::GetSize() {
+ LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModuleSpecList, GetSize);
+
+ return m_opaque_up->GetSize();
+}
SBModuleSpec SBModuleSpecList::GetSpecAtIndex(size_t i) {
+ LLDB_RECORD_METHOD(lldb::SBModuleSpec, SBModuleSpecList, GetSpecAtIndex,
+ (size_t), i);
+
SBModuleSpec sb_module_spec;
m_opaque_up->GetModuleSpecAtIndex(i, *sb_module_spec.m_opaque_up);
- return sb_module_spec;
+ return LLDB_RECORD_RESULT(sb_module_spec);
}
SBModuleSpec
SBModuleSpecList::FindFirstMatchingSpec(const SBModuleSpec &match_spec) {
+ LLDB_RECORD_METHOD(lldb::SBModuleSpec, SBModuleSpecList,
+ FindFirstMatchingSpec, (const lldb::SBModuleSpec &),
+ match_spec);
+
SBModuleSpec sb_module_spec;
m_opaque_up->FindMatchingModuleSpec(*match_spec.m_opaque_up,
*sb_module_spec.m_opaque_up);
- return sb_module_spec;
+ return LLDB_RECORD_RESULT(sb_module_spec);
}
SBModuleSpecList
SBModuleSpecList::FindMatchingSpecs(const SBModuleSpec &match_spec) {
+ LLDB_RECORD_METHOD(lldb::SBModuleSpecList, SBModuleSpecList,
+ FindMatchingSpecs, (const lldb::SBModuleSpec &),
+ match_spec);
+
SBModuleSpecList specs;
m_opaque_up->FindMatchingModuleSpecs(*match_spec.m_opaque_up,
*specs.m_opaque_up);
- return specs;
+ return LLDB_RECORD_RESULT(specs);
}
bool SBModuleSpecList::GetDescription(lldb::SBStream &description) {
+ LLDB_RECORD_METHOD(bool, SBModuleSpecList, GetDescription, (lldb::SBStream &),
+ description);
+
m_opaque_up->Dump(description.ref());
return true;
}
//===----------------------------------------------------------------------===//
#include "lldb/API/SBPlatform.h"
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBError.h"
#include "lldb/API/SBFileSpec.h"
#include "lldb/API/SBLaunchInfo.h"
// SBPlatformConnectOptions
//----------------------------------------------------------------------
SBPlatformConnectOptions::SBPlatformConnectOptions(const char *url)
- : m_opaque_ptr(new PlatformConnectOptions(url)) {}
+ : m_opaque_ptr(new PlatformConnectOptions(url)) {
+ LLDB_RECORD_CONSTRUCTOR(SBPlatformConnectOptions, (const char *), url);
+}
SBPlatformConnectOptions::SBPlatformConnectOptions(
const SBPlatformConnectOptions &rhs)
: m_opaque_ptr(new PlatformConnectOptions()) {
+ LLDB_RECORD_CONSTRUCTOR(SBPlatformConnectOptions,
+ (const lldb::SBPlatformConnectOptions &), rhs);
+
*m_opaque_ptr = *rhs.m_opaque_ptr;
}
SBPlatformConnectOptions::~SBPlatformConnectOptions() { delete m_opaque_ptr; }
void SBPlatformConnectOptions::operator=(const SBPlatformConnectOptions &rhs) {
+ LLDB_RECORD_METHOD(
+ void,
+ SBPlatformConnectOptions, operator=,(
+ const lldb::SBPlatformConnectOptions &),
+ rhs);
+
*m_opaque_ptr = *rhs.m_opaque_ptr;
}
const char *SBPlatformConnectOptions::GetURL() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformConnectOptions, GetURL);
+
if (m_opaque_ptr->m_url.empty())
return NULL;
return m_opaque_ptr->m_url.c_str();
}
void SBPlatformConnectOptions::SetURL(const char *url) {
+ LLDB_RECORD_METHOD(void, SBPlatformConnectOptions, SetURL, (const char *),
+ url);
+
if (url && url[0])
m_opaque_ptr->m_url = url;
else
}
bool SBPlatformConnectOptions::GetRsyncEnabled() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBPlatformConnectOptions, GetRsyncEnabled);
+
return m_opaque_ptr->m_rsync_enabled;
}
void SBPlatformConnectOptions::EnableRsync(
const char *options, const char *remote_path_prefix,
bool omit_hostname_from_remote_path) {
+ LLDB_RECORD_METHOD(void, SBPlatformConnectOptions, EnableRsync,
+ (const char *, const char *, bool), options,
+ remote_path_prefix, omit_hostname_from_remote_path);
+
m_opaque_ptr->m_rsync_enabled = true;
m_opaque_ptr->m_rsync_omit_hostname_from_remote_path =
omit_hostname_from_remote_path;
}
void SBPlatformConnectOptions::DisableRsync() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatformConnectOptions, DisableRsync);
+
m_opaque_ptr->m_rsync_enabled = false;
}
const char *SBPlatformConnectOptions::GetLocalCacheDirectory() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformConnectOptions,
+ GetLocalCacheDirectory);
+
return m_opaque_ptr->m_local_cache_directory.GetCString();
}
void SBPlatformConnectOptions::SetLocalCacheDirectory(const char *path) {
+ LLDB_RECORD_METHOD(void, SBPlatformConnectOptions, SetLocalCacheDirectory,
+ (const char *), path);
+
if (path && path[0])
m_opaque_ptr->m_local_cache_directory.SetCString(path);
else
// SBPlatformShellCommand
//----------------------------------------------------------------------
SBPlatformShellCommand::SBPlatformShellCommand(const char *shell_command)
- : m_opaque_ptr(new PlatformShellCommand(shell_command)) {}
+ : m_opaque_ptr(new PlatformShellCommand(shell_command)) {
+ LLDB_RECORD_CONSTRUCTOR(SBPlatformShellCommand, (const char *),
+ shell_command);
+}
SBPlatformShellCommand::SBPlatformShellCommand(
const SBPlatformShellCommand &rhs)
: m_opaque_ptr(new PlatformShellCommand()) {
+ LLDB_RECORD_CONSTRUCTOR(SBPlatformShellCommand,
+ (const lldb::SBPlatformShellCommand &), rhs);
+
*m_opaque_ptr = *rhs.m_opaque_ptr;
}
SBPlatformShellCommand::~SBPlatformShellCommand() { delete m_opaque_ptr; }
void SBPlatformShellCommand::Clear() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatformShellCommand, Clear);
+
m_opaque_ptr->m_output = std::string();
m_opaque_ptr->m_status = 0;
m_opaque_ptr->m_signo = 0;
}
const char *SBPlatformShellCommand::GetCommand() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand, GetCommand);
+
if (m_opaque_ptr->m_command.empty())
return NULL;
return m_opaque_ptr->m_command.c_str();
}
void SBPlatformShellCommand::SetCommand(const char *shell_command) {
+ LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetCommand, (const char *),
+ shell_command);
+
if (shell_command && shell_command[0])
m_opaque_ptr->m_command = shell_command;
else
}
const char *SBPlatformShellCommand::GetWorkingDirectory() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand,
+ GetWorkingDirectory);
+
if (m_opaque_ptr->m_working_dir.empty())
return NULL;
return m_opaque_ptr->m_working_dir.c_str();
}
void SBPlatformShellCommand::SetWorkingDirectory(const char *path) {
+ LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetWorkingDirectory,
+ (const char *), path);
+
if (path && path[0])
m_opaque_ptr->m_working_dir = path;
else
}
uint32_t SBPlatformShellCommand::GetTimeoutSeconds() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatformShellCommand,
+ GetTimeoutSeconds);
+
if (m_opaque_ptr->m_timeout)
return m_opaque_ptr->m_timeout->count();
return UINT32_MAX;
}
void SBPlatformShellCommand::SetTimeoutSeconds(uint32_t sec) {
+ LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetTimeoutSeconds,
+ (uint32_t), sec);
+
if (sec == UINT32_MAX)
m_opaque_ptr->m_timeout = llvm::None;
else
m_opaque_ptr->m_timeout = std::chrono::seconds(sec);
}
-int SBPlatformShellCommand::GetSignal() { return m_opaque_ptr->m_signo; }
+int SBPlatformShellCommand::GetSignal() {
+ LLDB_RECORD_METHOD_NO_ARGS(int, SBPlatformShellCommand, GetSignal);
+
+ return m_opaque_ptr->m_signo;
+}
+
+int SBPlatformShellCommand::GetStatus() {
+ LLDB_RECORD_METHOD_NO_ARGS(int, SBPlatformShellCommand, GetStatus);
-int SBPlatformShellCommand::GetStatus() { return m_opaque_ptr->m_status; }
+ return m_opaque_ptr->m_status;
+}
const char *SBPlatformShellCommand::GetOutput() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand, GetOutput);
+
if (m_opaque_ptr->m_output.empty())
return NULL;
return m_opaque_ptr->m_output.c_str();
//----------------------------------------------------------------------
// SBPlatform
//----------------------------------------------------------------------
-SBPlatform::SBPlatform() : m_opaque_sp() {}
+SBPlatform::SBPlatform() : m_opaque_sp() {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBPlatform);
+}
SBPlatform::SBPlatform(const char *platform_name) : m_opaque_sp() {
+ LLDB_RECORD_CONSTRUCTOR(SBPlatform, (const char *), platform_name);
+
Status error;
if (platform_name && platform_name[0])
m_opaque_sp = Platform::Create(ConstString(platform_name), error);
SBPlatform::~SBPlatform() {}
-bool SBPlatform::IsValid() const { return m_opaque_sp.get() != NULL; }
+bool SBPlatform::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBPlatform, IsValid);
+
+ return m_opaque_sp.get() != NULL;
+}
+
+void SBPlatform::Clear() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatform, Clear);
-void SBPlatform::Clear() { m_opaque_sp.reset(); }
+ m_opaque_sp.reset();
+}
const char *SBPlatform::GetName() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetName);
+
PlatformSP platform_sp(GetSP());
if (platform_sp)
return platform_sp->GetName().GetCString();
}
const char *SBPlatform::GetWorkingDirectory() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetWorkingDirectory);
+
PlatformSP platform_sp(GetSP());
if (platform_sp)
return platform_sp->GetWorkingDirectory().GetCString();
}
bool SBPlatform::SetWorkingDirectory(const char *path) {
+ LLDB_RECORD_METHOD(bool, SBPlatform, SetWorkingDirectory, (const char *),
+ path);
+
PlatformSP platform_sp(GetSP());
if (platform_sp) {
if (path)
}
SBError SBPlatform::ConnectRemote(SBPlatformConnectOptions &connect_options) {
+ LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, ConnectRemote,
+ (lldb::SBPlatformConnectOptions &), connect_options);
+
SBError sb_error;
PlatformSP platform_sp(GetSP());
if (platform_sp && connect_options.GetURL()) {
} else {
sb_error.SetErrorString("invalid platform");
}
- return sb_error;
+ return LLDB_RECORD_RESULT(sb_error);
}
void SBPlatform::DisconnectRemote() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatform, DisconnectRemote);
+
PlatformSP platform_sp(GetSP());
if (platform_sp)
platform_sp->DisconnectRemote();
}
bool SBPlatform::IsConnected() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBPlatform, IsConnected);
+
PlatformSP platform_sp(GetSP());
if (platform_sp)
return platform_sp->IsConnected();
}
const char *SBPlatform::GetTriple() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetTriple);
+
PlatformSP platform_sp(GetSP());
if (platform_sp) {
ArchSpec arch(platform_sp->GetSystemArchitecture());
}
const char *SBPlatform::GetOSBuild() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetOSBuild);
+
PlatformSP platform_sp(GetSP());
if (platform_sp) {
std::string s;
}
const char *SBPlatform::GetOSDescription() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetOSDescription);
+
PlatformSP platform_sp(GetSP());
if (platform_sp) {
std::string s;
}
const char *SBPlatform::GetHostname() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetHostname);
+
PlatformSP platform_sp(GetSP());
if (platform_sp)
return platform_sp->GetHostname();
}
uint32_t SBPlatform::GetOSMajorVersion() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatform, GetOSMajorVersion);
+
llvm::VersionTuple version;
if (PlatformSP platform_sp = GetSP())
version = platform_sp->GetOSVersion();
}
uint32_t SBPlatform::GetOSMinorVersion() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatform, GetOSMinorVersion);
+
llvm::VersionTuple version;
if (PlatformSP platform_sp = GetSP())
version = platform_sp->GetOSVersion();
}
uint32_t SBPlatform::GetOSUpdateVersion() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatform, GetOSUpdateVersion);
+
llvm::VersionTuple version;
if (PlatformSP platform_sp = GetSP())
version = platform_sp->GetOSVersion();
}
SBError SBPlatform::Get(SBFileSpec &src, SBFileSpec &dst) {
+ LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Get,
+ (lldb::SBFileSpec &, lldb::SBFileSpec &), src, dst);
+
SBError sb_error;
PlatformSP platform_sp(GetSP());
if (platform_sp) {
} else {
sb_error.SetErrorString("invalid platform");
}
- return sb_error;
+ return LLDB_RECORD_RESULT(sb_error);
}
SBError SBPlatform::Put(SBFileSpec &src, SBFileSpec &dst) {
- return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
- if (src.Exists()) {
- uint32_t permissions = FileSystem::Instance().GetPermissions(src.ref());
- if (permissions == 0) {
- if (FileSystem::Instance().IsDirectory(src.ref()))
- permissions = eFilePermissionsDirectoryDefault;
- else
- permissions = eFilePermissionsFileDefault;
- }
-
- return platform_sp->PutFile(src.ref(), dst.ref(), permissions);
- }
-
- Status error;
- error.SetErrorStringWithFormat("'src' argument doesn't exist: '%s'",
- src.ref().GetPath().c_str());
- return error;
- });
+ LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Put,
+ (lldb::SBFileSpec &, lldb::SBFileSpec &), src, dst);
+ return LLDB_RECORD_RESULT(
+ ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
+ if (src.Exists()) {
+ uint32_t permissions =
+ FileSystem::Instance().GetPermissions(src.ref());
+ if (permissions == 0) {
+ if (FileSystem::Instance().IsDirectory(src.ref()))
+ permissions = eFilePermissionsDirectoryDefault;
+ else
+ permissions = eFilePermissionsFileDefault;
+ }
+
+ return platform_sp->PutFile(src.ref(), dst.ref(), permissions);
+ }
+
+ Status error;
+ error.SetErrorStringWithFormat("'src' argument doesn't exist: '%s'",
+ src.ref().GetPath().c_str());
+ return error;
+ }));
}
SBError SBPlatform::Install(SBFileSpec &src, SBFileSpec &dst) {
- return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
- if (src.Exists())
- return platform_sp->Install(src.ref(), dst.ref());
+ LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Install,
+ (lldb::SBFileSpec &, lldb::SBFileSpec &), src, dst);
+ return LLDB_RECORD_RESULT(
+ ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
+ if (src.Exists())
+ return platform_sp->Install(src.ref(), dst.ref());
- Status error;
- error.SetErrorStringWithFormat("'src' argument doesn't exist: '%s'",
- src.ref().GetPath().c_str());
- return error;
- });
+ Status error;
+ error.SetErrorStringWithFormat("'src' argument doesn't exist: '%s'",
+ src.ref().GetPath().c_str());
+ return error;
+ }));
}
SBError SBPlatform::Run(SBPlatformShellCommand &shell_command) {
- return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
+ LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Run,
+ (lldb::SBPlatformShellCommand &), shell_command);
+ return LLDB_RECORD_RESULT(ExecuteConnected([&](const lldb::PlatformSP
+ &platform_sp) {
const char *command = shell_command.GetCommand();
if (!command)
return Status("invalid shell command (empty)");
&shell_command.m_opaque_ptr->m_signo,
&shell_command.m_opaque_ptr->m_output,
shell_command.m_opaque_ptr->m_timeout);
- });
+ }));
}
SBError SBPlatform::Launch(SBLaunchInfo &launch_info) {
- return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
- ProcessLaunchInfo info = launch_info.ref();
- Status error = platform_sp->LaunchProcess(info);
- launch_info.set_ref(info);
- return error;
- });
+ LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Launch, (lldb::SBLaunchInfo &),
+ launch_info);
+ return LLDB_RECORD_RESULT(
+ ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
+ ProcessLaunchInfo info = launch_info.ref();
+ Status error = platform_sp->LaunchProcess(info);
+ launch_info.set_ref(info);
+ return error;
+ }));
}
SBError SBPlatform::Kill(const lldb::pid_t pid) {
- return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
- return platform_sp->KillProcess(pid);
- });
+ LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Kill, (const lldb::pid_t), pid);
+ return LLDB_RECORD_RESULT(
+ ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
+ return platform_sp->KillProcess(pid);
+ }));
}
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);
+
SBError sb_error;
PlatformSP platform_sp(GetSP());
if (platform_sp) {
} else {
sb_error.SetErrorString("invalid platform");
}
- return sb_error;
+ return LLDB_RECORD_RESULT(sb_error);
}
uint32_t SBPlatform::GetFilePermissions(const char *path) {
+ LLDB_RECORD_METHOD(uint32_t, SBPlatform, GetFilePermissions, (const char *),
+ path);
+
PlatformSP platform_sp(GetSP());
if (platform_sp) {
uint32_t file_permissions = 0;
SBError SBPlatform::SetFilePermissions(const char *path,
uint32_t file_permissions) {
+ LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, SetFilePermissions,
+ (const char *, uint32_t), path, file_permissions);
+
SBError sb_error;
PlatformSP platform_sp(GetSP());
if (platform_sp) {
} else {
sb_error.SetErrorString("invalid platform");
}
- return sb_error;
+ return LLDB_RECORD_RESULT(sb_error);
}
SBUnixSignals SBPlatform::GetUnixSignals() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBUnixSignals, SBPlatform,
+ GetUnixSignals);
+
if (auto platform_sp = GetSP())
- return SBUnixSignals{platform_sp};
+ return LLDB_RECORD_RESULT(SBUnixSignals{platform_sp});
- return {};
+ return LLDB_RECORD_RESULT(SBUnixSignals());
}
//===----------------------------------------------------------------------===//
#include "lldb/API/SBProcess.h"
+#include "SBReproducerPrivate.h"
#include <inttypes.h>
using namespace lldb;
using namespace lldb_private;
-SBProcess::SBProcess() : m_opaque_wp() {}
+SBProcess::SBProcess() : m_opaque_wp() {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBProcess);
+}
//----------------------------------------------------------------------
// SBProcess constructor
//----------------------------------------------------------------------
-SBProcess::SBProcess(const SBProcess &rhs) : m_opaque_wp(rhs.m_opaque_wp) {}
+SBProcess::SBProcess(const SBProcess &rhs) : m_opaque_wp(rhs.m_opaque_wp) {
+ LLDB_RECORD_CONSTRUCTOR(SBProcess, (const lldb::SBProcess &), rhs);
+}
SBProcess::SBProcess(const lldb::ProcessSP &process_sp)
- : m_opaque_wp(process_sp) {}
+ : m_opaque_wp(process_sp) {
+ LLDB_RECORD_CONSTRUCTOR(SBProcess, (const lldb::ProcessSP &), process_sp);
+}
const SBProcess &SBProcess::operator=(const SBProcess &rhs) {
+ LLDB_RECORD_METHOD(const lldb::SBProcess &,
+ SBProcess, operator=,(const lldb::SBProcess &), rhs);
+
if (this != &rhs)
m_opaque_wp = rhs.m_opaque_wp;
return *this;
SBProcess::~SBProcess() {}
const char *SBProcess::GetBroadcasterClassName() {
+ LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBProcess,
+ GetBroadcasterClassName);
+
return Process::GetStaticBroadcasterClass().AsCString();
}
const char *SBProcess::GetPluginName() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetPluginName);
+
ProcessSP process_sp(GetSP());
if (process_sp) {
return process_sp->GetPluginName().GetCString();
}
const char *SBProcess::GetShortPluginName() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetShortPluginName);
+
ProcessSP process_sp(GetSP());
if (process_sp) {
return process_sp->GetPluginName().GetCString();
void SBProcess::SetSP(const ProcessSP &process_sp) { m_opaque_wp = process_sp; }
-void SBProcess::Clear() { m_opaque_wp.reset(); }
+void SBProcess::Clear() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBProcess, Clear);
+
+ m_opaque_wp.reset();
+}
bool SBProcess::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcess, IsValid);
+
ProcessSP process_sp(m_opaque_wp.lock());
return ((bool)process_sp && process_sp->IsValid());
}
const char *working_directory,
uint32_t launch_flags, bool stop_at_entry,
lldb::SBError &error) {
+ LLDB_RECORD_METHOD(bool, SBProcess, RemoteLaunch,
+ (const char **, const char **, const char *, const char *,
+ const char *, const char *, uint32_t, bool,
+ lldb::SBError &),
+ argv, envp, stdin_path, stdout_path, stderr_path,
+ working_directory, launch_flags, stop_at_entry, error);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
log->Printf("SBProcess(%p)::RemoteLaunch (argv=%p, envp=%p, stdin=%s, "
bool SBProcess::RemoteAttachToProcessWithID(lldb::pid_t pid,
lldb::SBError &error) {
+ LLDB_RECORD_METHOD(bool, SBProcess, RemoteAttachToProcessWithID,
+ (lldb::pid_t, lldb::SBError &), pid, error);
+
ProcessSP process_sp(GetSP());
if (process_sp) {
std::lock_guard<std::recursive_mutex> guard(
}
uint32_t SBProcess::GetNumThreads() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumThreads);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
uint32_t num_threads = 0;
}
SBThread SBProcess::GetSelectedThread() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBProcess,
+ GetSelectedThread);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBThread sb_thread;
static_cast<void *>(process_sp.get()),
static_cast<void *>(thread_sp.get()));
- return sb_thread;
+ return LLDB_RECORD_RESULT(sb_thread);
}
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);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBThread sb_thread;
static_cast<void *>(process_sp.get()), tid, context,
static_cast<void *>(thread_sp.get()));
- return sb_thread;
+ return LLDB_RECORD_RESULT(sb_thread);
}
SBTarget SBProcess::GetTarget() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBTarget, SBProcess, GetTarget);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBTarget sb_target;
static_cast<void *>(process_sp.get()),
static_cast<void *>(target_sp.get()));
- return sb_target;
+ return LLDB_RECORD_RESULT(sb_target);
}
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);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
size_t ret_val = 0;
}
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);
+
size_t bytes_read = 0;
ProcessSP process_sp(GetSP());
if (process_sp) {
}
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);
+
size_t bytes_read = 0;
ProcessSP process_sp(GetSP());
if (process_sp) {
}
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);
+
size_t bytes_read = 0;
ProcessSP process_sp(GetSP());
if (process_sp) {
lldb::SBTrace SBProcess::StartTrace(SBTraceOptions &options,
lldb::SBError &error) {
+ LLDB_RECORD_METHOD(lldb::SBTrace, SBProcess, StartTrace,
+ (lldb::SBTraceOptions &, lldb::SBError &), options, error);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
ProcessSP process_sp(GetSP());
error.Clear();
trace_instance.SetTraceUID(uid);
LLDB_LOG(log, "SBProcess::returned uid - {0}", uid);
}
- return trace_instance;
+ return LLDB_RECORD_RESULT(trace_instance);
}
void SBProcess::ReportEventState(const SBEvent &event, FILE *out) const {
+ LLDB_RECORD_METHOD_CONST(void, SBProcess, ReportEventState,
+ (const lldb::SBEvent &, FILE *), event, out);
+
if (out == NULL)
return;
void SBProcess::AppendEventStateReport(const SBEvent &event,
SBCommandReturnObject &result) {
+ LLDB_RECORD_METHOD(void, SBProcess, AppendEventStateReport,
+ (const lldb::SBEvent &, lldb::SBCommandReturnObject &),
+ event, result);
+
ProcessSP process_sp(GetSP());
if (process_sp) {
const StateType event_state = SBProcess::GetStateFromEvent(event);
}
bool SBProcess::SetSelectedThread(const SBThread &thread) {
+ LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThread,
+ (const lldb::SBThread &), thread);
+
ProcessSP process_sp(GetSP());
if (process_sp) {
std::lock_guard<std::recursive_mutex> guard(
}
bool SBProcess::SetSelectedThreadByID(lldb::tid_t tid) {
+ LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByID, (lldb::tid_t),
+ tid);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
bool ret_val = false;
}
bool SBProcess::SetSelectedThreadByIndexID(uint32_t index_id) {
+ LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByIndexID, (uint32_t),
+ index_id);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
bool ret_val = false;
}
SBThread SBProcess::GetThreadAtIndex(size_t index) {
+ LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadAtIndex, (size_t),
+ index);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBThread sb_thread;
static_cast<uint32_t>(index),
static_cast<void *>(thread_sp.get()));
- return sb_thread;
+ return LLDB_RECORD_RESULT(sb_thread);
}
uint32_t SBProcess::GetNumQueues() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumQueues);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
uint32_t num_queues = 0;
}
SBQueue SBProcess::GetQueueAtIndex(size_t index) {
+ LLDB_RECORD_METHOD(lldb::SBQueue, SBProcess, GetQueueAtIndex, (size_t),
+ index);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBQueue sb_queue;
static_cast<uint32_t>(index),
static_cast<void *>(queue_sp.get()));
- return sb_queue;
+ return LLDB_RECORD_RESULT(sb_queue);
}
uint32_t SBProcess::GetStopID(bool include_expression_stops) {
+ LLDB_RECORD_METHOD(uint32_t, SBProcess, GetStopID, (bool),
+ include_expression_stops);
+
ProcessSP process_sp(GetSP());
if (process_sp) {
std::lock_guard<std::recursive_mutex> guard(
}
SBEvent SBProcess::GetStopEventForStopID(uint32_t stop_id) {
+ LLDB_RECORD_METHOD(lldb::SBEvent, SBProcess, GetStopEventForStopID,
+ (uint32_t), stop_id);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBEvent sb_event;
static_cast<void *>(process_sp.get()), stop_id,
static_cast<void *>(event_sp.get()));
- return sb_event;
+ return LLDB_RECORD_RESULT(sb_event);
}
StateType SBProcess::GetState() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::StateType, SBProcess, GetState);
StateType ret_val = eStateInvalid;
ProcessSP process_sp(GetSP());
}
int SBProcess::GetExitStatus() {
+ LLDB_RECORD_METHOD_NO_ARGS(int, SBProcess, GetExitStatus);
+
int exit_status = 0;
ProcessSP process_sp(GetSP());
if (process_sp) {
}
const char *SBProcess::GetExitDescription() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetExitDescription);
+
const char *exit_desc = NULL;
ProcessSP process_sp(GetSP());
if (process_sp) {
}
lldb::pid_t SBProcess::GetProcessID() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBProcess, GetProcessID);
+
lldb::pid_t ret_val = LLDB_INVALID_PROCESS_ID;
ProcessSP process_sp(GetSP());
if (process_sp)
}
uint32_t SBProcess::GetUniqueID() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetUniqueID);
+
uint32_t ret_val = 0;
ProcessSP process_sp(GetSP());
if (process_sp)
}
ByteOrder SBProcess::GetByteOrder() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ByteOrder, SBProcess, GetByteOrder);
+
ByteOrder byteOrder = eByteOrderInvalid;
ProcessSP process_sp(GetSP());
if (process_sp)
}
uint32_t SBProcess::GetAddressByteSize() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBProcess, GetAddressByteSize);
+
uint32_t size = 0;
ProcessSP process_sp(GetSP());
if (process_sp)
}
SBError SBProcess::Continue() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Continue);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBError sb_error;
static_cast<void *>(sb_error.get()), sstr.GetData());
}
- return sb_error;
+ return LLDB_RECORD_RESULT(sb_error);
}
SBError SBProcess::Destroy() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Destroy);
+
SBError sb_error;
ProcessSP process_sp(GetSP());
if (process_sp) {
static_cast<void *>(sb_error.get()), sstr.GetData());
}
- return sb_error;
+ return LLDB_RECORD_RESULT(sb_error);
}
SBError SBProcess::Stop() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Stop);
+
SBError sb_error;
ProcessSP process_sp(GetSP());
if (process_sp) {
static_cast<void *>(sb_error.get()), sstr.GetData());
}
- return sb_error;
+ return LLDB_RECORD_RESULT(sb_error);
}
SBError SBProcess::Kill() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Kill);
+
SBError sb_error;
ProcessSP process_sp(GetSP());
if (process_sp) {
static_cast<void *>(sb_error.get()), sstr.GetData());
}
- return sb_error;
+ return LLDB_RECORD_RESULT(sb_error);
}
SBError SBProcess::Detach() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Detach);
+
// FIXME: This should come from a process default.
bool keep_stopped = false;
- return Detach(keep_stopped);
+ return LLDB_RECORD_RESULT(Detach(keep_stopped));
}
SBError SBProcess::Detach(bool keep_stopped) {
+ LLDB_RECORD_METHOD(lldb::SBError, SBProcess, Detach, (bool), keep_stopped);
+
SBError sb_error;
ProcessSP process_sp(GetSP());
if (process_sp) {
} else
sb_error.SetErrorString("SBProcess is invalid");
- return sb_error;
+ return LLDB_RECORD_RESULT(sb_error);
}
SBError SBProcess::Signal(int signo) {
+ LLDB_RECORD_METHOD(lldb::SBError, SBProcess, Signal, (int), signo);
+
SBError sb_error;
ProcessSP process_sp(GetSP());
if (process_sp) {
static_cast<void *>(process_sp.get()), signo,
static_cast<void *>(sb_error.get()), sstr.GetData());
}
- return sb_error;
+ return LLDB_RECORD_RESULT(sb_error);
}
SBUnixSignals SBProcess::GetUnixSignals() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBUnixSignals, SBProcess, GetUnixSignals);
+
if (auto process_sp = GetSP())
- return SBUnixSignals{process_sp};
+ return LLDB_RECORD_RESULT(SBUnixSignals{process_sp});
- return {};
+ return LLDB_RECORD_RESULT(SBUnixSignals{});
}
void SBProcess::SendAsyncInterrupt() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBProcess, SendAsyncInterrupt);
+
ProcessSP process_sp(GetSP());
if (process_sp) {
process_sp->SendAsyncInterrupt();
}
SBThread SBProcess::GetThreadByID(tid_t tid) {
+ LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadByID, (lldb::tid_t),
+ tid);
+
SBThread sb_thread;
ThreadSP thread_sp;
ProcessSP process_sp(GetSP());
static_cast<void *>(process_sp.get()), tid,
static_cast<void *>(thread_sp.get()));
- return sb_thread;
+ return LLDB_RECORD_RESULT(sb_thread);
}
SBThread SBProcess::GetThreadByIndexID(uint32_t index_id) {
+ LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadByIndexID, (uint32_t),
+ index_id);
+
SBThread sb_thread;
ThreadSP thread_sp;
ProcessSP process_sp(GetSP());
static_cast<void *>(process_sp.get()), index_id,
static_cast<void *>(thread_sp.get()));
- return sb_thread;
+ return LLDB_RECORD_RESULT(sb_thread);
}
StateType SBProcess::GetStateFromEvent(const SBEvent &event) {
+ LLDB_RECORD_STATIC_METHOD(lldb::StateType, SBProcess, GetStateFromEvent,
+ (const lldb::SBEvent &), event);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
StateType ret_val = Process::ProcessEventData::GetStateFromEvent(event.get());
}
bool SBProcess::GetRestartedFromEvent(const SBEvent &event) {
+ LLDB_RECORD_STATIC_METHOD(bool, SBProcess, GetRestartedFromEvent,
+ (const lldb::SBEvent &), event);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
bool ret_val = Process::ProcessEventData::GetRestartedFromEvent(event.get());
}
size_t SBProcess::GetNumRestartedReasonsFromEvent(const lldb::SBEvent &event) {
+ LLDB_RECORD_STATIC_METHOD(size_t, SBProcess, GetNumRestartedReasonsFromEvent,
+ (const lldb::SBEvent &), event);
+
return Process::ProcessEventData::GetNumRestartedReasons(event.get());
}
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);
+
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);
+
ProcessSP process_sp =
Process::ProcessEventData::GetProcessFromEvent(event.get());
if (!process_sp) {
process_sp = EventDataStructuredData::GetProcessFromEvent(event.get());
}
- return SBProcess(process_sp);
+ return LLDB_RECORD_RESULT(SBProcess(process_sp));
}
bool SBProcess::GetInterruptedFromEvent(const SBEvent &event) {
+ LLDB_RECORD_STATIC_METHOD(bool, SBProcess, GetInterruptedFromEvent,
+ (const lldb::SBEvent &), event);
+
return Process::ProcessEventData::GetInterruptedFromEvent(event.get());
}
lldb::SBStructuredData
SBProcess::GetStructuredDataFromEvent(const lldb::SBEvent &event) {
- return SBStructuredData(event.GetSP());
+ LLDB_RECORD_STATIC_METHOD(lldb::SBStructuredData, SBProcess,
+ GetStructuredDataFromEvent, (const lldb::SBEvent &),
+ event);
+
+ return LLDB_RECORD_RESULT(SBStructuredData(event.GetSP()));
}
bool SBProcess::EventIsProcessEvent(const SBEvent &event) {
+ LLDB_RECORD_STATIC_METHOD(bool, SBProcess, EventIsProcessEvent,
+ (const lldb::SBEvent &), event);
+
return (event.GetBroadcasterClass() == SBProcess::GetBroadcasterClass()) &&
!EventIsStructuredDataEvent(event);
}
bool SBProcess::EventIsStructuredDataEvent(const lldb::SBEvent &event) {
+ LLDB_RECORD_STATIC_METHOD(bool, SBProcess, EventIsStructuredDataEvent,
+ (const lldb::SBEvent &), event);
+
EventSP event_sp = event.GetSP();
EventData *event_data = event_sp ? event_sp->GetData() : nullptr;
return event_data && (event_data->GetFlavor() ==
}
SBBroadcaster SBProcess::GetBroadcaster() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBProcess,
+ GetBroadcaster);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
ProcessSP process_sp(GetSP());
static_cast<void *>(process_sp.get()),
static_cast<void *>(broadcaster.get()));
- return broadcaster;
+ return LLDB_RECORD_RESULT(broadcaster);
}
const char *SBProcess::GetBroadcasterClass() {
+ LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBProcess,
+ GetBroadcasterClass);
+
return Process::GetStaticBroadcasterClass().AsCString();
}
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);
+
uint64_t value = 0;
ProcessSP process_sp(GetSP());
if (process_sp) {
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::addr_t ptr = LLDB_INVALID_ADDRESS;
ProcessSP process_sp(GetSP());
if (process_sp) {
}
bool SBProcess::GetDescription(SBStream &description) {
+ LLDB_RECORD_METHOD(bool, SBProcess, GetDescription, (lldb::SBStream &),
+ description);
+
Stream &strm = description.ref();
ProcessSP process_sp(GetSP());
uint32_t
SBProcess::GetNumSupportedHardwareWatchpoints(lldb::SBError &sb_error) const {
+ LLDB_RECORD_METHOD_CONST(uint32_t, SBProcess,
+ GetNumSupportedHardwareWatchpoints,
+ (lldb::SBError &), sb_error);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
uint32_t num = 0;
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);
+
return LoadImage(SBFileSpec(), sb_remote_image_spec, sb_error);
}
uint32_t SBProcess::LoadImage(const lldb::SBFileSpec &sb_local_image_spec,
const lldb::SBFileSpec &sb_remote_image_spec,
lldb::SBError &sb_error) {
+ LLDB_RECORD_METHOD(
+ uint32_t, SBProcess, LoadImage,
+ (const lldb::SBFileSpec &, const lldb::SBFileSpec &, lldb::SBError &),
+ sb_local_image_spec, sb_remote_image_spec, sb_error);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
ProcessSP process_sp(GetSP());
if (process_sp) {
uint32_t SBProcess::LoadImageUsingPaths(const lldb::SBFileSpec &image_spec,
SBStringList &paths,
- lldb::SBFileSpec &loaded_path,
+ 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);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
ProcessSP process_sp(GetSP());
if (process_sp) {
}
lldb::SBError SBProcess::UnloadImage(uint32_t image_token) {
+ LLDB_RECORD_METHOD(lldb::SBError, SBProcess, UnloadImage, (uint32_t),
+ image_token);
+
lldb::SBError sb_error;
ProcessSP process_sp(GetSP());
if (process_sp) {
}
} else
sb_error.SetErrorString("invalid process");
- return sb_error;
+ return LLDB_RECORD_RESULT(sb_error);
}
lldb::SBError SBProcess::SendEventData(const char *event_data) {
+ LLDB_RECORD_METHOD(lldb::SBError, SBProcess, SendEventData, (const char *),
+ event_data);
+
lldb::SBError sb_error;
ProcessSP process_sp(GetSP());
if (process_sp) {
}
} else
sb_error.SetErrorString("invalid process");
- return sb_error;
+ return LLDB_RECORD_RESULT(sb_error);
}
uint32_t SBProcess::GetNumExtendedBacktraceTypes() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumExtendedBacktraceTypes);
+
ProcessSP process_sp(GetSP());
if (process_sp && process_sp->GetSystemRuntime()) {
SystemRuntime *runtime = process_sp->GetSystemRuntime();
}
const char *SBProcess::GetExtendedBacktraceTypeAtIndex(uint32_t idx) {
+ LLDB_RECORD_METHOD(const char *, SBProcess, GetExtendedBacktraceTypeAtIndex,
+ (uint32_t), idx);
+
ProcessSP process_sp(GetSP());
if (process_sp && process_sp->GetSystemRuntime()) {
SystemRuntime *runtime = process_sp->GetSystemRuntime();
}
SBThreadCollection SBProcess::GetHistoryThreads(addr_t addr) {
+ LLDB_RECORD_METHOD(lldb::SBThreadCollection, SBProcess, GetHistoryThreads,
+ (lldb::addr_t), addr);
+
ProcessSP process_sp(GetSP());
SBThreadCollection threads;
if (process_sp) {
threads = SBThreadCollection(process_sp->GetHistoryThreads(addr));
}
- return threads;
+ return LLDB_RECORD_RESULT(threads);
}
bool SBProcess::IsInstrumentationRuntimePresent(
InstrumentationRuntimeType type) {
+ LLDB_RECORD_METHOD(bool, SBProcess, IsInstrumentationRuntimePresent,
+ (lldb::InstrumentationRuntimeType), type);
+
ProcessSP process_sp(GetSP());
if (!process_sp)
return false;
}
lldb::SBError SBProcess::SaveCore(const char *file_name) {
+ LLDB_RECORD_METHOD(lldb::SBError, SBProcess, SaveCore, (const char *),
+ file_name);
+
lldb::SBError error;
ProcessSP process_sp(GetSP());
if (!process_sp) {
error.SetErrorString("SBProcess is invalid");
- return error;
+ return LLDB_RECORD_RESULT(error);
}
std::lock_guard<std::recursive_mutex> guard(
if (process_sp->GetState() != eStateStopped) {
error.SetErrorString("the process is not stopped");
- return error;
+ return LLDB_RECORD_RESULT(error);
}
FileSpec core_file(file_name);
error.ref() = PluginManager::SaveCore(process_sp, core_file);
- return error;
+ return LLDB_RECORD_RESULT(error);
}
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::SBError sb_error;
ProcessSP process_sp(GetSP());
if (process_sp) {
} else {
sb_error.SetErrorString("SBProcess is invalid");
}
- return sb_error;
+ return LLDB_RECORD_RESULT(sb_error);
}
lldb::SBMemoryRegionInfoList SBProcess::GetMemoryRegions() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBMemoryRegionInfoList, SBProcess,
+ GetMemoryRegions);
+
lldb::SBMemoryRegionInfoList sb_region_list;
ProcessSP process_sp(GetSP());
static_cast<void *>(process_sp.get()));
}
- return sb_region_list;
+ return LLDB_RECORD_RESULT(sb_region_list);
}
lldb::SBProcessInfo SBProcess::GetProcessInfo() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcessInfo, SBProcess, GetProcessInfo);
+
lldb::SBProcessInfo sb_proc_info;
ProcessSP process_sp(GetSP());
ProcessInstanceInfo proc_info;
if (process_sp && process_sp->GetProcessInfo(proc_info)) {
sb_proc_info.SetProcessInfo(proc_info);
}
- return sb_proc_info;
+ return LLDB_RECORD_RESULT(sb_proc_info);
}
//===----------------------------------------------------------------------===//
#include "lldb/API/SBProcessInfo.h"
+#include "SBReproducerPrivate.h"
#include "Utils.h"
#include "lldb/API/SBFileSpec.h"
#include "lldb/Utility/ProcessInfo.h"
using namespace lldb;
using namespace lldb_private;
-SBProcessInfo::SBProcessInfo() : m_opaque_up() {}
+SBProcessInfo::SBProcessInfo() : m_opaque_up() {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBProcessInfo);
+}
SBProcessInfo::SBProcessInfo(const SBProcessInfo &rhs) : m_opaque_up() {
+ LLDB_RECORD_CONSTRUCTOR(SBProcessInfo, (const lldb::SBProcessInfo &), rhs);
+
m_opaque_up = clone(rhs.m_opaque_up);
}
SBProcessInfo::~SBProcessInfo() {}
SBProcessInfo &SBProcessInfo::operator=(const SBProcessInfo &rhs) {
+ LLDB_RECORD_METHOD(lldb::SBProcessInfo &,
+ SBProcessInfo, operator=,(const lldb::SBProcessInfo &),
+ rhs);
+
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
return *this;
ref() = proc_info_ref;
}
-bool SBProcessInfo::IsValid() const { return m_opaque_up != nullptr; }
+bool SBProcessInfo::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcessInfo, IsValid);
+
+ return m_opaque_up != nullptr;
+}
const char *SBProcessInfo::GetName() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcessInfo, GetName);
+
const char *name = nullptr;
if (m_opaque_up) {
name = m_opaque_up->GetName();
}
SBFileSpec SBProcessInfo::GetExecutableFile() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBProcessInfo,
+ GetExecutableFile);
+
SBFileSpec file_spec;
if (m_opaque_up) {
file_spec.SetFileSpec(m_opaque_up->GetExecutableFile());
}
- return file_spec;
+ return LLDB_RECORD_RESULT(file_spec);
}
lldb::pid_t SBProcessInfo::GetProcessID() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBProcessInfo, GetProcessID);
+
lldb::pid_t proc_id = LLDB_INVALID_PROCESS_ID;
if (m_opaque_up) {
proc_id = m_opaque_up->GetProcessID();
}
uint32_t SBProcessInfo::GetUserID() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetUserID);
+
uint32_t user_id = UINT32_MAX;
if (m_opaque_up) {
user_id = m_opaque_up->GetUserID();
}
uint32_t SBProcessInfo::GetGroupID() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetGroupID);
+
uint32_t group_id = UINT32_MAX;
if (m_opaque_up) {
group_id = m_opaque_up->GetGroupID();
}
bool SBProcessInfo::UserIDIsValid() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, UserIDIsValid);
+
bool is_valid = false;
if (m_opaque_up) {
is_valid = m_opaque_up->UserIDIsValid();
}
bool SBProcessInfo::GroupIDIsValid() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, GroupIDIsValid);
+
bool is_valid = false;
if (m_opaque_up) {
is_valid = m_opaque_up->GroupIDIsValid();
}
uint32_t SBProcessInfo::GetEffectiveUserID() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetEffectiveUserID);
+
uint32_t user_id = UINT32_MAX;
if (m_opaque_up) {
user_id = m_opaque_up->GetEffectiveUserID();
}
uint32_t SBProcessInfo::GetEffectiveGroupID() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetEffectiveGroupID);
+
uint32_t group_id = UINT32_MAX;
if (m_opaque_up) {
group_id = m_opaque_up->GetEffectiveGroupID();
}
bool SBProcessInfo::EffectiveUserIDIsValid() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, EffectiveUserIDIsValid);
+
bool is_valid = false;
if (m_opaque_up) {
is_valid = m_opaque_up->EffectiveUserIDIsValid();
}
bool SBProcessInfo::EffectiveGroupIDIsValid() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, EffectiveGroupIDIsValid);
+
bool is_valid = false;
if (m_opaque_up) {
is_valid = m_opaque_up->EffectiveGroupIDIsValid();
}
lldb::pid_t SBProcessInfo::GetParentProcessID() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBProcessInfo, GetParentProcessID);
+
lldb::pid_t proc_id = LLDB_INVALID_PROCESS_ID;
if (m_opaque_up) {
proc_id = m_opaque_up->GetParentProcessID();
#include <inttypes.h>
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBQueue.h"
#include "lldb/API/SBProcess.h"
};
}
-SBQueue::SBQueue() : m_opaque_sp(new QueueImpl()) {}
+SBQueue::SBQueue() : m_opaque_sp(new QueueImpl()) {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBQueue);
+}
SBQueue::SBQueue(const QueueSP &queue_sp)
- : m_opaque_sp(new QueueImpl(queue_sp)) {}
+ : m_opaque_sp(new QueueImpl(queue_sp)) {
+ LLDB_RECORD_CONSTRUCTOR(SBQueue, (const lldb::QueueSP &), queue_sp);
+}
SBQueue::SBQueue(const SBQueue &rhs) {
+ LLDB_RECORD_CONSTRUCTOR(SBQueue, (const lldb::SBQueue &), rhs);
+
if (&rhs == this)
return;
}
const lldb::SBQueue &SBQueue::operator=(const lldb::SBQueue &rhs) {
+ LLDB_RECORD_METHOD(const lldb::SBQueue &,
+ SBQueue, operator=,(const lldb::SBQueue &), rhs);
+
m_opaque_sp = rhs.m_opaque_sp;
return *this;
}
SBQueue::~SBQueue() {}
bool SBQueue::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBQueue, IsValid);
+
bool is_valid = m_opaque_sp->IsValid();
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
}
void SBQueue::Clear() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBQueue, Clear);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
log->Printf("SBQueue(0x%" PRIx64 ")::Clear()", m_opaque_sp->GetQueueID());
}
lldb::queue_id_t SBQueue::GetQueueID() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::queue_id_t, SBQueue, GetQueueID);
+
lldb::queue_id_t qid = m_opaque_sp->GetQueueID();
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
}
uint32_t SBQueue::GetIndexID() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBQueue, GetIndexID);
+
uint32_t index_id = m_opaque_sp->GetIndexID();
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
}
const char *SBQueue::GetName() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBQueue, GetName);
+
const char *name = m_opaque_sp->GetName();
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
}
uint32_t SBQueue::GetNumThreads() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBQueue, GetNumThreads);
+
uint32_t numthreads = m_opaque_sp->GetNumThreads();
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
}
SBThread SBQueue::GetThreadAtIndex(uint32_t idx) {
+ LLDB_RECORD_METHOD(lldb::SBThread, SBQueue, GetThreadAtIndex, (uint32_t),
+ idx);
+
SBThread th = m_opaque_sp->GetThreadAtIndex(idx);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
log->Printf("SBQueue(0x%" PRIx64 ")::GetThreadAtIndex(%d)",
m_opaque_sp->GetQueueID(), idx);
- return th;
+ return LLDB_RECORD_RESULT(th);
}
uint32_t SBQueue::GetNumPendingItems() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBQueue, GetNumPendingItems);
+
uint32_t pending_items = m_opaque_sp->GetNumPendingItems();
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
}
SBQueueItem SBQueue::GetPendingItemAtIndex(uint32_t idx) {
+ LLDB_RECORD_METHOD(lldb::SBQueueItem, SBQueue, GetPendingItemAtIndex,
+ (uint32_t), idx);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
log->Printf("SBQueue(0x%" PRIx64 ")::GetPendingItemAtIndex(%d)",
m_opaque_sp->GetQueueID(), idx);
- return m_opaque_sp->GetPendingItemAtIndex(idx);
+ return LLDB_RECORD_RESULT(m_opaque_sp->GetPendingItemAtIndex(idx));
}
uint32_t SBQueue::GetNumRunningItems() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBQueue, GetNumRunningItems);
+
uint32_t running_items = m_opaque_sp->GetNumRunningItems();
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
return running_items;
}
-SBProcess SBQueue::GetProcess() { return m_opaque_sp->GetProcess(); }
+SBProcess SBQueue::GetProcess() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBQueue, GetProcess);
-lldb::QueueKind SBQueue::GetKind() { return m_opaque_sp->GetKind(); }
+ return LLDB_RECORD_RESULT(m_opaque_sp->GetProcess());
+}
+
+lldb::QueueKind SBQueue::GetKind() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::QueueKind, SBQueue, GetKind);
+
+ return m_opaque_sp->GetKind();
+}
#include "lldb/lldb-forward.h"
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBQueueItem.h"
#include "lldb/API/SBThread.h"
//----------------------------------------------------------------------
// Constructors
//----------------------------------------------------------------------
-SBQueueItem::SBQueueItem() : m_queue_item_sp() {}
+SBQueueItem::SBQueueItem() : m_queue_item_sp() {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBQueueItem);
+}
SBQueueItem::SBQueueItem(const QueueItemSP &queue_item_sp)
- : m_queue_item_sp(queue_item_sp) {}
+ : m_queue_item_sp(queue_item_sp) {
+ LLDB_RECORD_CONSTRUCTOR(SBQueueItem, (const lldb::QueueItemSP &),
+ queue_item_sp);
+}
//----------------------------------------------------------------------
// Destructor
SBQueueItem::~SBQueueItem() { m_queue_item_sp.reset(); }
bool SBQueueItem::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBQueueItem, IsValid);
+
bool is_valid = m_queue_item_sp.get() != NULL;
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
}
void SBQueueItem::Clear() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBQueueItem, Clear);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
log->Printf("SBQueueItem(%p)::Clear()",
}
void SBQueueItem::SetQueueItem(const QueueItemSP &queue_item_sp) {
+ LLDB_RECORD_METHOD(void, SBQueueItem, SetQueueItem,
+ (const lldb::QueueItemSP &), queue_item_sp);
+
m_queue_item_sp = queue_item_sp;
}
lldb::QueueItemKind SBQueueItem::GetKind() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::QueueItemKind, SBQueueItem, GetKind);
+
QueueItemKind result = eQueueItemKindUnknown;
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (m_queue_item_sp) {
}
void SBQueueItem::SetKind(lldb::QueueItemKind kind) {
+ LLDB_RECORD_METHOD(void, SBQueueItem, SetKind, (lldb::QueueItemKind), kind);
+
if (m_queue_item_sp) {
m_queue_item_sp->SetKind(kind);
}
}
SBAddress SBQueueItem::GetAddress() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBQueueItem, GetAddress);
+
SBAddress result;
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (m_queue_item_sp) {
static_cast<void *>(m_queue_item_sp.get()),
static_cast<void *>(result.get()), sstr.GetData());
}
- return result;
+ return LLDB_RECORD_RESULT(result);
}
void SBQueueItem::SetAddress(SBAddress addr) {
+ LLDB_RECORD_METHOD(void, SBQueueItem, SetAddress, (lldb::SBAddress), addr);
+
if (m_queue_item_sp) {
m_queue_item_sp->SetAddress(addr.ref());
}
}
SBThread SBQueueItem::GetExtendedBacktraceThread(const char *type) {
+ LLDB_RECORD_METHOD(lldb::SBThread, SBQueueItem, GetExtendedBacktraceThread,
+ (const char *), type);
+
SBThread result;
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (m_queue_item_sp) {
}
}
}
- return result;
+ return LLDB_RECORD_RESULT(result);
}
#include "SBReproducerPrivate.h"
+#include "SBReproducerPrivate.h"
#include "lldb/API/LLDB.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBAttachInfo.h"
using namespace lldb_private;
using namespace lldb_private::repro;
-SBRegistry::SBRegistry() {}
+static void SetFileHandleRedirect(SBDebugger *, FILE *, bool) {
+ // Do nothing.
+}
+
+static bool GetDefaultArchitectureRedirect(char *arch_name,
+ size_t arch_name_len) {
+ // The function is writing to its argument. Without the redirect it would
+ // write into the replay buffer.
+ char buffer[arch_name_len];
+ return SBDebugger::GetDefaultArchitecture(buffer, arch_name_len);
+}
+
+SBRegistry::SBRegistry() {
+
+ // Custom implementation.
+ Register(&invoke<void (SBDebugger::*)(
+ FILE *, bool)>::method<&SBDebugger::SetInputFileHandle>::doit,
+ &SetFileHandleRedirect);
+ Register(&invoke<void (SBDebugger::*)(
+ FILE *, bool)>::method<&SBDebugger::SetErrorFileHandle>::doit,
+ &SetFileHandleRedirect);
+ Register(&invoke<void (SBDebugger::*)(
+ FILE *, bool)>::method<&SBDebugger::SetOutputFileHandle>::doit,
+ &SetFileHandleRedirect);
+ Register<bool(char *, size_t)>(static_cast<bool (*)(char *, size_t)>(
+ &SBDebugger::GetDefaultArchitecture),
+ &GetDefaultArchitectureRedirect);
+
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBAddress, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBAddress, (const lldb::SBAddress &));
+ LLDB_REGISTER_CONSTRUCTOR(SBAddress, (lldb::SBSection, lldb::addr_t));
+ LLDB_REGISTER_CONSTRUCTOR(SBAddress, (lldb::addr_t, lldb::SBTarget &));
+ LLDB_REGISTER_METHOD(const lldb::SBAddress &,
+ SBAddress, operator=,(const lldb::SBAddress &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBAddress, IsValid, ());
+ LLDB_REGISTER_METHOD(void, SBAddress, Clear, ());
+ LLDB_REGISTER_METHOD(void, SBAddress, SetAddress,
+ (lldb::SBSection, lldb::addr_t));
+ LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBAddress, GetFileAddress, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBAddress, GetLoadAddress,
+ (const lldb::SBTarget &));
+ LLDB_REGISTER_METHOD(void, SBAddress, SetLoadAddress,
+ (lldb::addr_t, lldb::SBTarget &));
+ LLDB_REGISTER_METHOD(bool, SBAddress, OffsetAddress, (lldb::addr_t));
+ LLDB_REGISTER_METHOD(lldb::SBSection, SBAddress, GetSection, ());
+ LLDB_REGISTER_METHOD(lldb::addr_t, SBAddress, GetOffset, ());
+ LLDB_REGISTER_METHOD(bool, SBAddress, GetDescription, (lldb::SBStream &));
+ LLDB_REGISTER_METHOD(lldb::SBModule, SBAddress, GetModule, ());
+ LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBAddress, GetSymbolContext,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBCompileUnit, SBAddress, GetCompileUnit, ());
+ LLDB_REGISTER_METHOD(lldb::SBFunction, SBAddress, GetFunction, ());
+ LLDB_REGISTER_METHOD(lldb::SBBlock, SBAddress, GetBlock, ());
+ LLDB_REGISTER_METHOD(lldb::SBSymbol, SBAddress, GetSymbol, ());
+ LLDB_REGISTER_METHOD(lldb::SBLineEntry, SBAddress, GetLineEntry, ());
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (lldb::pid_t));
+ LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (const char *, bool));
+ LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (const char *, bool, bool));
+ LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (const lldb::SBAttachInfo &));
+ LLDB_REGISTER_METHOD(lldb::SBAttachInfo &,
+ SBAttachInfo, operator=,(const lldb::SBAttachInfo &));
+ LLDB_REGISTER_METHOD(lldb::pid_t, SBAttachInfo, GetProcessID, ());
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetProcessID, (lldb::pid_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetResumeCount, ());
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetResumeCount, (uint32_t));
+ LLDB_REGISTER_METHOD(const char *, SBAttachInfo, GetProcessPluginName, ());
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetProcessPluginName,
+ (const char *));
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetExecutable, (const char *));
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetExecutable, (lldb::SBFileSpec));
+ LLDB_REGISTER_METHOD(bool, SBAttachInfo, GetWaitForLaunch, ());
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool));
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool, bool));
+ LLDB_REGISTER_METHOD(bool, SBAttachInfo, GetIgnoreExisting, ());
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetIgnoreExisting, (bool));
+ LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetUserID, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetGroupID, ());
+ LLDB_REGISTER_METHOD(bool, SBAttachInfo, UserIDIsValid, ());
+ LLDB_REGISTER_METHOD(bool, SBAttachInfo, GroupIDIsValid, ());
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetUserID, (uint32_t));
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetGroupID, (uint32_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetEffectiveUserID, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetEffectiveGroupID, ());
+ LLDB_REGISTER_METHOD(bool, SBAttachInfo, EffectiveUserIDIsValid, ());
+ LLDB_REGISTER_METHOD(bool, SBAttachInfo, EffectiveGroupIDIsValid, ());
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetEffectiveUserID, (uint32_t));
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetEffectiveGroupID, (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::pid_t, SBAttachInfo, GetParentProcessID, ());
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetParentProcessID, (lldb::pid_t));
+ LLDB_REGISTER_METHOD(bool, SBAttachInfo, ParentProcessIDIsValid, ());
+ LLDB_REGISTER_METHOD(lldb::SBListener, SBAttachInfo, GetListener, ());
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetListener, (lldb::SBListener &));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBBlock, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBBlock, (const lldb::SBBlock &));
+ LLDB_REGISTER_METHOD(const lldb::SBBlock &,
+ SBBlock, operator=,(const lldb::SBBlock &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBBlock, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBBlock, IsInlined, ());
+ LLDB_REGISTER_METHOD_CONST(const char *, SBBlock, GetInlinedName, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBBlock,
+ GetInlinedCallSiteFile, ());
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBBlock, GetInlinedCallSiteLine, ());
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBBlock, GetInlinedCallSiteColumn, ());
+ LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetParent, ());
+ LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetContainingInlinedBlock, ());
+ LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetSibling, ());
+ LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetFirstChild, ());
+ LLDB_REGISTER_METHOD(bool, SBBlock, GetDescription, (lldb::SBStream &));
+ LLDB_REGISTER_METHOD(uint32_t, SBBlock, GetNumRanges, ());
+ LLDB_REGISTER_METHOD(lldb::SBAddress, SBBlock, GetRangeStartAddress,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBAddress, SBBlock, GetRangeEndAddress,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBBlock, GetRangeIndexForBlockAddress,
+ (lldb::SBAddress));
+ LLDB_REGISTER_METHOD(
+ lldb::SBValueList, SBBlock, GetVariables,
+ (lldb::SBFrame &, bool, bool, bool, lldb::DynamicValueType));
+ LLDB_REGISTER_METHOD(lldb::SBValueList, SBBlock, GetVariables,
+ (lldb::SBTarget &, bool, bool, bool));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBBreakpoint, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBBreakpoint, (const lldb::SBBreakpoint &));
+ LLDB_REGISTER_CONSTRUCTOR(SBBreakpoint, (const lldb::BreakpointSP &));
+ LLDB_REGISTER_METHOD(const lldb::SBBreakpoint &,
+ SBBreakpoint, operator=,(const lldb::SBBreakpoint &));
+ LLDB_REGISTER_METHOD(bool,
+ SBBreakpoint, operator==,(const lldb::SBBreakpoint &));
+ LLDB_REGISTER_METHOD(bool,
+ SBBreakpoint, operator!=,(const lldb::SBBreakpoint &));
+ LLDB_REGISTER_METHOD_CONST(lldb::break_id_t, SBBreakpoint, GetID, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, IsValid, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpoint, ClearAllBreakpointSites, ());
+ LLDB_REGISTER_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
+ FindLocationByAddress, (lldb::addr_t));
+ LLDB_REGISTER_METHOD(lldb::break_id_t, SBBreakpoint,
+ FindLocationIDByAddress, (lldb::addr_t));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
+ FindLocationByID, (lldb::break_id_t));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
+ GetLocationAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(void, SBBreakpoint, SetEnabled, (bool));
+ LLDB_REGISTER_METHOD(bool, SBBreakpoint, IsEnabled, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpoint, SetOneShot, (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, IsOneShot, ());
+ LLDB_REGISTER_METHOD(bool, SBBreakpoint, IsInternal, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpoint, SetIgnoreCount, (uint32_t));
+ LLDB_REGISTER_METHOD(void, SBBreakpoint, SetCondition, (const char *));
+ LLDB_REGISTER_METHOD(const char *, SBBreakpoint, GetCondition, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpoint, SetAutoContinue, (bool));
+ LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetAutoContinue, ());
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpoint, GetHitCount, ());
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpoint, GetIgnoreCount, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpoint, SetThreadID, (lldb::tid_t));
+ LLDB_REGISTER_METHOD(lldb::tid_t, SBBreakpoint, GetThreadID, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpoint, SetThreadIndex, (uint32_t));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpoint, GetThreadIndex, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpoint, SetThreadName, (const char *));
+ LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpoint, GetThreadName, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpoint, SetQueueName, (const char *));
+ LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpoint, GetQueueName, ());
+ LLDB_REGISTER_METHOD_CONST(size_t, SBBreakpoint, GetNumResolvedLocations,
+ ());
+ LLDB_REGISTER_METHOD_CONST(size_t, SBBreakpoint, GetNumLocations, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpoint, SetCommandLineCommands,
+ (lldb::SBStringList &));
+ LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetCommandLineCommands,
+ (lldb::SBStringList &));
+ LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetDescription,
+ (lldb::SBStream &));
+ LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetDescription,
+ (lldb::SBStream &, bool));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpoint, AddLocation,
+ (lldb::SBAddress &));
+ LLDB_REGISTER_METHOD(void, SBBreakpoint, SetScriptCallbackFunction,
+ (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpoint, SetScriptCallbackBody,
+ (const char *));
+ LLDB_REGISTER_METHOD(bool, SBBreakpoint, AddName, (const char *));
+ LLDB_REGISTER_METHOD(void, SBBreakpoint, RemoveName, (const char *));
+ LLDB_REGISTER_METHOD(bool, SBBreakpoint, MatchesName, (const char *));
+ LLDB_REGISTER_METHOD(void, SBBreakpoint, GetNames, (lldb::SBStringList &));
+ LLDB_REGISTER_STATIC_METHOD(bool, SBBreakpoint, EventIsBreakpointEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_STATIC_METHOD(lldb::BreakpointEventType, SBBreakpoint,
+ GetBreakpointEventTypeFromEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBBreakpoint, SBBreakpoint,
+ GetBreakpointFromEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
+ GetBreakpointLocationAtIndexFromEvent,
+ (const lldb::SBEvent &, uint32_t));
+ LLDB_REGISTER_STATIC_METHOD(uint32_t, SBBreakpoint,
+ GetNumBreakpointLocationsFromEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, IsHardware, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBBreakpointList, (lldb::SBTarget &));
+ LLDB_REGISTER_METHOD_CONST(size_t, SBBreakpointList, GetSize, ());
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBBreakpointList,
+ GetBreakpointAtIndex, (size_t));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBBreakpointList,
+ FindBreakpointByID, (lldb::break_id_t));
+ LLDB_REGISTER_METHOD(void, SBBreakpointList, Append,
+ (const lldb::SBBreakpoint &));
+ LLDB_REGISTER_METHOD(void, SBBreakpointList, AppendByID,
+ (lldb::break_id_t));
+ LLDB_REGISTER_METHOD(bool, SBBreakpointList, AppendIfUnique,
+ (const lldb::SBBreakpoint &));
+ LLDB_REGISTER_METHOD(void, SBBreakpointList, Clear, ());
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBBreakpointLocation, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBBreakpointLocation,
+ (const lldb::BreakpointLocationSP &));
+ LLDB_REGISTER_CONSTRUCTOR(SBBreakpointLocation,
+ (const lldb::SBBreakpointLocation &));
+ LLDB_REGISTER_METHOD(
+ const lldb::SBBreakpointLocation &,
+ SBBreakpointLocation, operator=,(const lldb::SBBreakpointLocation &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointLocation, IsValid, ());
+ LLDB_REGISTER_METHOD(lldb::SBAddress, SBBreakpointLocation, GetAddress, ());
+ LLDB_REGISTER_METHOD(lldb::addr_t, SBBreakpointLocation, GetLoadAddress,
+ ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetEnabled, (bool));
+ LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, IsEnabled, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBBreakpointLocation, GetHitCount, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBBreakpointLocation, GetIgnoreCount, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetIgnoreCount,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetCondition,
+ (const char *));
+ LLDB_REGISTER_METHOD(const char *, SBBreakpointLocation, GetCondition, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetAutoContinue, (bool));
+ LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, GetAutoContinue, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetScriptCallbackFunction,
+ (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpointLocation,
+ SetScriptCallbackBody, (const char *));
+ LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetCommandLineCommands,
+ (lldb::SBStringList &));
+ LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, GetCommandLineCommands,
+ (lldb::SBStringList &));
+ LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetThreadID,
+ (lldb::tid_t));
+ LLDB_REGISTER_METHOD(lldb::tid_t, SBBreakpointLocation, GetThreadID, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetThreadIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpointLocation, GetThreadIndex,
+ ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetThreadName,
+ (const char *));
+ LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointLocation,
+ GetThreadName, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetQueueName,
+ (const char *));
+ LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointLocation, GetQueueName,
+ ());
+ LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, IsResolved, ());
+ LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel));
+ LLDB_REGISTER_METHOD(lldb::break_id_t, SBBreakpointLocation, GetID, ());
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBBreakpointLocation,
+ GetBreakpoint, ());
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName,
+ (lldb::SBTarget &, const char *));
+ LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName,
+ (lldb::SBBreakpoint &, const char *));
+ LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName,
+ (const lldb::SBBreakpointName &));
+ LLDB_REGISTER_METHOD(
+ const lldb::SBBreakpointName &,
+ SBBreakpointName, operator=,(const lldb::SBBreakpointName &));
+ LLDB_REGISTER_METHOD(
+ bool, SBBreakpointName, operator==,(const lldb::SBBreakpointName &));
+ LLDB_REGISTER_METHOD(
+ bool, SBBreakpointName, operator!=,(const lldb::SBBreakpointName &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetName, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointName, SetEnabled, (bool));
+ LLDB_REGISTER_METHOD(bool, SBBreakpointName, IsEnabled, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointName, SetOneShot, (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, IsOneShot, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointName, SetIgnoreCount, (uint32_t));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpointName, GetIgnoreCount, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointName, SetCondition, (const char *));
+ LLDB_REGISTER_METHOD(const char *, SBBreakpointName, GetCondition, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAutoContinue, (bool));
+ LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetAutoContinue, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointName, SetThreadID, (lldb::tid_t));
+ LLDB_REGISTER_METHOD(lldb::tid_t, SBBreakpointName, GetThreadID, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointName, SetThreadIndex, (uint32_t));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpointName, GetThreadIndex, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointName, SetThreadName, (const char *));
+ LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetThreadName,
+ ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointName, SetQueueName, (const char *));
+ LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetQueueName,
+ ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointName, SetCommandLineCommands,
+ (lldb::SBStringList &));
+ LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetCommandLineCommands,
+ (lldb::SBStringList &));
+ LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetHelpString,
+ ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointName, SetHelpString, (const char *));
+ LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetDescription,
+ (lldb::SBStream &));
+ LLDB_REGISTER_METHOD(void, SBBreakpointName, SetScriptCallbackFunction,
+ (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpointName, SetScriptCallbackBody,
+ (const char *));
+ LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, GetAllowList, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAllowList, (bool));
+ LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetAllowDelete, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAllowDelete, (bool));
+ LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetAllowDisable, ());
+ LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAllowDisable, (bool));
+ }
+ {} {
+ LLDB_REGISTER_CONSTRUCTOR(SBBroadcaster, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBBroadcaster, (const char *));
+ LLDB_REGISTER_CONSTRUCTOR(SBBroadcaster, (const lldb::SBBroadcaster &));
+ LLDB_REGISTER_METHOD(
+ const lldb::SBBroadcaster &,
+ SBBroadcaster, operator=,(const lldb::SBBroadcaster &));
+ LLDB_REGISTER_METHOD(void, SBBroadcaster, BroadcastEventByType,
+ (uint32_t, bool));
+ LLDB_REGISTER_METHOD(void, SBBroadcaster, BroadcastEvent,
+ (const lldb::SBEvent &, bool));
+ LLDB_REGISTER_METHOD(void, SBBroadcaster, AddInitialEventsToListener,
+ (const lldb::SBListener &, uint32_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBBroadcaster, AddListener,
+ (const lldb::SBListener &, uint32_t));
+ LLDB_REGISTER_METHOD_CONST(const char *, SBBroadcaster, GetName, ());
+ LLDB_REGISTER_METHOD(bool, SBBroadcaster, EventTypeHasListeners,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(bool, SBBroadcaster, RemoveListener,
+ (const lldb::SBListener &, uint32_t));
+ LLDB_REGISTER_METHOD_CONST(bool, SBBroadcaster, IsValid, ());
+ LLDB_REGISTER_METHOD(void, SBBroadcaster, Clear, ());
+ LLDB_REGISTER_METHOD_CONST(
+ bool, SBBroadcaster, operator==,(const lldb::SBBroadcaster &));
+ LLDB_REGISTER_METHOD_CONST(
+ bool, SBBroadcaster, operator!=,(const lldb::SBBroadcaster &));
+ LLDB_REGISTER_METHOD_CONST(
+ bool, SBBroadcaster, operator<,(const lldb::SBBroadcaster &));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreterRunOptions, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
+ GetStopOnContinue, ());
+ LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions,
+ SetStopOnContinue, (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
+ GetStopOnError, ());
+ LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnError,
+ (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
+ GetStopOnCrash, ());
+ LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnCrash,
+ (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
+ GetEchoCommands, ());
+ LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetEchoCommands,
+ (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
+ GetEchoCommentCommands, ());
+ LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions,
+ SetEchoCommentCommands, (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
+ GetPrintResults, ());
+ LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetPrintResults,
+ (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
+ GetAddToHistory, ());
+ LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetAddToHistory,
+ (bool));
+ LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreter,
+ (lldb_private::CommandInterpreter *));
+ LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreter,
+ (const lldb::SBCommandInterpreter &));
+ LLDB_REGISTER_METHOD(
+ const lldb::SBCommandInterpreter &,
+ SBCommandInterpreter, operator=,(const lldb::SBCommandInterpreter &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, IsValid, ());
+ LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, CommandExists,
+ (const char *));
+ LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, AliasExists,
+ (const char *));
+ LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, IsActive, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, WasInterrupted, ());
+ LLDB_REGISTER_METHOD(const char *, SBCommandInterpreter,
+ GetIOHandlerControlSequence, (char));
+ LLDB_REGISTER_METHOD(lldb::ReturnStatus, SBCommandInterpreter,
+ HandleCommand,
+ (const char *, lldb::SBCommandReturnObject &, bool));
+ LLDB_REGISTER_METHOD(lldb::ReturnStatus, SBCommandInterpreter,
+ HandleCommand,
+ (const char *, lldb::SBExecutionContext &,
+ lldb::SBCommandReturnObject &, bool));
+ LLDB_REGISTER_METHOD(void, SBCommandInterpreter, HandleCommandsFromFile,
+ (lldb::SBFileSpec &, lldb::SBExecutionContext &,
+ lldb::SBCommandInterpreterRunOptions &,
+ lldb::SBCommandReturnObject));
+ LLDB_REGISTER_METHOD(int, SBCommandInterpreter, HandleCompletion,
+ (const char *, const char *, const char *, int, int,
+ lldb::SBStringList &));
+ LLDB_REGISTER_METHOD(int, SBCommandInterpreter,
+ HandleCompletionWithDescriptions,
+ (const char *, const char *, const char *, int, int,
+ lldb::SBStringList &, lldb::SBStringList &));
+ LLDB_REGISTER_METHOD(int, SBCommandInterpreter,
+ HandleCompletionWithDescriptions,
+ (const char *, uint32_t, int, int,
+ lldb::SBStringList &, lldb::SBStringList &));
+ LLDB_REGISTER_METHOD(
+ int, SBCommandInterpreter, HandleCompletion,
+ (const char *, uint32_t, int, int, lldb::SBStringList &));
+ LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasCommands, ());
+ LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasAliases, ());
+ LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasAliasOptions, ());
+ LLDB_REGISTER_METHOD(lldb::SBProcess, SBCommandInterpreter, GetProcess, ());
+ LLDB_REGISTER_METHOD(lldb::SBDebugger, SBCommandInterpreter, GetDebugger,
+ ());
+ LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, GetPromptOnQuit, ());
+ LLDB_REGISTER_METHOD(void, SBCommandInterpreter, SetPromptOnQuit, (bool));
+ LLDB_REGISTER_METHOD(void, SBCommandInterpreter, AllowExitCodeOnQuit,
+ (bool));
+ LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasCustomQuitExitCode, ());
+ LLDB_REGISTER_METHOD(int, SBCommandInterpreter, GetQuitStatus, ());
+ LLDB_REGISTER_METHOD(void, SBCommandInterpreter, ResolveCommand,
+ (const char *, lldb::SBCommandReturnObject &));
+ LLDB_REGISTER_METHOD(void, SBCommandInterpreter,
+ SourceInitFileInHomeDirectory,
+ (lldb::SBCommandReturnObject &));
+ LLDB_REGISTER_METHOD(void, SBCommandInterpreter,
+ SourceInitFileInCurrentWorkingDirectory,
+ (lldb::SBCommandReturnObject &));
+ LLDB_REGISTER_METHOD(lldb::SBBroadcaster, SBCommandInterpreter,
+ GetBroadcaster, ());
+ LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter,
+ GetBroadcasterClass, ());
+ LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter,
+ GetArgumentTypeAsCString,
+ (const lldb::CommandArgumentType));
+ LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter,
+ GetArgumentDescriptionAsCString,
+ (const lldb::CommandArgumentType));
+ LLDB_REGISTER_STATIC_METHOD(bool, SBCommandInterpreter,
+ EventIsCommandInterpreterEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommandInterpreter,
+ AddMultiwordCommand, (const char *, const char *));
+ LLDB_REGISTER_METHOD(
+ lldb::SBCommand, SBCommandInterpreter, AddCommand,
+ (const char *, lldb::SBCommandPluginInterface *, const char *));
+ LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand,
+ (const char *, lldb::SBCommandPluginInterface *,
+ const char *, const char *));
+ LLDB_REGISTER_CONSTRUCTOR(SBCommand, ());
+ LLDB_REGISTER_METHOD(bool, SBCommand, IsValid, ());
+ LLDB_REGISTER_METHOD(const char *, SBCommand, GetName, ());
+ LLDB_REGISTER_METHOD(const char *, SBCommand, GetHelp, ());
+ LLDB_REGISTER_METHOD(const char *, SBCommand, GetHelpLong, ());
+ LLDB_REGISTER_METHOD(void, SBCommand, SetHelp, (const char *));
+ LLDB_REGISTER_METHOD(void, SBCommand, SetHelpLong, (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddMultiwordCommand,
+ (const char *, const char *));
+ LLDB_REGISTER_METHOD(
+ lldb::SBCommand, SBCommand, AddCommand,
+ (const char *, lldb::SBCommandPluginInterface *, const char *));
+ LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddCommand,
+ (const char *, lldb::SBCommandPluginInterface *,
+ const char *, const char *));
+ LLDB_REGISTER_METHOD(uint32_t, SBCommand, GetFlags, ());
+ LLDB_REGISTER_METHOD(void, SBCommand, SetFlags, (uint32_t));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBCommandReturnObject, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBCommandReturnObject,
+ (const lldb::SBCommandReturnObject &));
+ LLDB_REGISTER_CONSTRUCTOR(SBCommandReturnObject,
+ (lldb_private::CommandReturnObject *));
+ LLDB_REGISTER_METHOD(lldb_private::CommandReturnObject *,
+ SBCommandReturnObject, Release, ());
+ LLDB_REGISTER_METHOD(
+ const lldb::SBCommandReturnObject &,
+ SBCommandReturnObject, operator=,(const lldb::SBCommandReturnObject &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBCommandReturnObject, IsValid, ());
+ LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetOutput, ());
+ LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetError, ());
+ LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, GetOutputSize, ());
+ LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, GetErrorSize, ());
+ LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutOutput, (FILE *));
+ LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutError, (FILE *));
+ LLDB_REGISTER_METHOD(void, SBCommandReturnObject, Clear, ());
+ LLDB_REGISTER_METHOD(lldb::ReturnStatus, SBCommandReturnObject, GetStatus,
+ ());
+ LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetStatus,
+ (lldb::ReturnStatus));
+ LLDB_REGISTER_METHOD(bool, SBCommandReturnObject, Succeeded, ());
+ LLDB_REGISTER_METHOD(bool, SBCommandReturnObject, HasResult, ());
+ LLDB_REGISTER_METHOD(void, SBCommandReturnObject, AppendMessage,
+ (const char *));
+ LLDB_REGISTER_METHOD(void, SBCommandReturnObject, AppendWarning,
+ (const char *));
+ LLDB_REGISTER_METHOD(bool, SBCommandReturnObject, GetDescription,
+ (lldb::SBStream &));
+ LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
+ (FILE *));
+ LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
+ (FILE *));
+ LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
+ (FILE *, bool));
+ LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
+ (FILE *, bool));
+ LLDB_REGISTER_METHOD(void, SBCommandReturnObject, PutCString,
+ (const char *, int));
+ LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetOutput,
+ (bool));
+ LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetError, (bool));
+ LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetError,
+ (lldb::SBError &, const char *));
+ LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetError, (const char *));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBCommunication, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBCommunication, (const char *));
+ LLDB_REGISTER_METHOD_CONST(bool, SBCommunication, IsValid, ());
+ LLDB_REGISTER_METHOD(bool, SBCommunication, GetCloseOnEOF, ());
+ LLDB_REGISTER_METHOD(void, SBCommunication, SetCloseOnEOF, (bool));
+ LLDB_REGISTER_METHOD(lldb::ConnectionStatus, SBCommunication, Connect,
+ (const char *));
+ LLDB_REGISTER_METHOD(lldb::ConnectionStatus, SBCommunication,
+ AdoptFileDesriptor, (int, bool));
+ LLDB_REGISTER_METHOD(lldb::ConnectionStatus, SBCommunication, Disconnect,
+ ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBCommunication, IsConnected, ());
+ LLDB_REGISTER_METHOD(bool, SBCommunication, ReadThreadStart, ());
+ LLDB_REGISTER_METHOD(bool, SBCommunication, ReadThreadStop, ());
+ LLDB_REGISTER_METHOD(bool, SBCommunication, ReadThreadIsRunning, ());
+ LLDB_REGISTER_METHOD(lldb::SBBroadcaster, SBCommunication, GetBroadcaster,
+ ());
+ LLDB_REGISTER_STATIC_METHOD(const char *, SBCommunication,
+ GetBroadcasterClass, ());
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBCompileUnit, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBCompileUnit, (const lldb::SBCompileUnit &));
+ LLDB_REGISTER_METHOD(
+ const lldb::SBCompileUnit &,
+ SBCompileUnit, operator=,(const lldb::SBCompileUnit &));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBCompileUnit, GetFileSpec,
+ ());
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, GetNumLineEntries, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBLineEntry, SBCompileUnit,
+ GetLineEntryAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex,
+ (uint32_t, uint32_t, lldb::SBFileSpec *));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex,
+ (uint32_t, uint32_t, lldb::SBFileSpec *, bool));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, GetNumSupportFiles, ());
+ LLDB_REGISTER_METHOD(lldb::SBTypeList, SBCompileUnit, GetTypes, (uint32_t));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBCompileUnit,
+ GetSupportFileAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBCompileUnit, FindSupportFileIndex,
+ (uint32_t, const lldb::SBFileSpec &, bool));
+ LLDB_REGISTER_METHOD(lldb::LanguageType, SBCompileUnit, GetLanguage, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBCompileUnit, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(
+ bool, SBCompileUnit, operator==,(const lldb::SBCompileUnit &));
+ LLDB_REGISTER_METHOD_CONST(
+ bool, SBCompileUnit, operator!=,(const lldb::SBCompileUnit &));
+ LLDB_REGISTER_METHOD(bool, SBCompileUnit, GetDescription,
+ (lldb::SBStream &));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBData, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBData, (const lldb::SBData &));
+ LLDB_REGISTER_METHOD(const lldb::SBData &,
+ SBData, operator=,(const lldb::SBData &));
+ LLDB_REGISTER_METHOD(bool, SBData, IsValid, ());
+ LLDB_REGISTER_METHOD(uint8_t, SBData, GetAddressByteSize, ());
+ LLDB_REGISTER_METHOD(void, SBData, SetAddressByteSize, (uint8_t));
+ LLDB_REGISTER_METHOD(void, SBData, Clear, ());
+ LLDB_REGISTER_METHOD(size_t, SBData, GetByteSize, ());
+ LLDB_REGISTER_METHOD(lldb::ByteOrder, SBData, GetByteOrder, ());
+ LLDB_REGISTER_METHOD(void, SBData, SetByteOrder, (lldb::ByteOrder));
+ LLDB_REGISTER_METHOD(float, SBData, GetFloat,
+ (lldb::SBError &, lldb::offset_t));
+ LLDB_REGISTER_METHOD(double, SBData, GetDouble,
+ (lldb::SBError &, lldb::offset_t));
+ LLDB_REGISTER_METHOD(long double, SBData, GetLongDouble,
+ (lldb::SBError &, lldb::offset_t));
+ LLDB_REGISTER_METHOD(lldb::addr_t, SBData, GetAddress,
+ (lldb::SBError &, lldb::offset_t));
+ LLDB_REGISTER_METHOD(uint8_t, SBData, GetUnsignedInt8,
+ (lldb::SBError &, lldb::offset_t));
+ LLDB_REGISTER_METHOD(uint16_t, SBData, GetUnsignedInt16,
+ (lldb::SBError &, lldb::offset_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBData, GetUnsignedInt32,
+ (lldb::SBError &, lldb::offset_t));
+ LLDB_REGISTER_METHOD(uint64_t, SBData, GetUnsignedInt64,
+ (lldb::SBError &, lldb::offset_t));
+ LLDB_REGISTER_METHOD(int8_t, SBData, GetSignedInt8,
+ (lldb::SBError &, lldb::offset_t));
+ LLDB_REGISTER_METHOD(int16_t, SBData, GetSignedInt16,
+ (lldb::SBError &, lldb::offset_t));
+ LLDB_REGISTER_METHOD(int32_t, SBData, GetSignedInt32,
+ (lldb::SBError &, lldb::offset_t));
+ LLDB_REGISTER_METHOD(int64_t, SBData, GetSignedInt64,
+ (lldb::SBError &, lldb::offset_t));
+ LLDB_REGISTER_METHOD(const char *, SBData, GetString,
+ (lldb::SBError &, lldb::offset_t));
+ LLDB_REGISTER_METHOD(bool, SBData, GetDescription,
+ (lldb::SBStream &, lldb::addr_t));
+ LLDB_REGISTER_METHOD(bool, SBData, Append, (const lldb::SBData &));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromCString,
+ (lldb::ByteOrder, uint32_t, const char *));
+ LLDB_REGISTER_STATIC_METHOD(
+ lldb::SBData, SBData, CreateDataFromUInt64Array,
+ (lldb::ByteOrder, uint32_t, uint64_t *, size_t));
+ LLDB_REGISTER_STATIC_METHOD(
+ lldb::SBData, SBData, CreateDataFromUInt32Array,
+ (lldb::ByteOrder, uint32_t, uint32_t *, size_t));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromSInt64Array,
+ (lldb::ByteOrder, uint32_t, int64_t *, size_t));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromSInt32Array,
+ (lldb::ByteOrder, uint32_t, int32_t *, size_t));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromDoubleArray,
+ (lldb::ByteOrder, uint32_t, double *, size_t));
+ LLDB_REGISTER_METHOD(bool, SBData, SetDataFromCString, (const char *));
+ LLDB_REGISTER_METHOD(bool, SBData, SetDataFromUInt64Array,
+ (uint64_t *, size_t));
+ LLDB_REGISTER_METHOD(bool, SBData, SetDataFromUInt32Array,
+ (uint32_t *, size_t));
+ LLDB_REGISTER_METHOD(bool, SBData, SetDataFromSInt64Array,
+ (int64_t *, size_t));
+ LLDB_REGISTER_METHOD(bool, SBData, SetDataFromSInt32Array,
+ (int32_t *, size_t));
+ LLDB_REGISTER_METHOD(bool, SBData, SetDataFromDoubleArray,
+ (double *, size_t));
+ }
+ {
+ LLDB_REGISTER_METHOD(void, SBInputReader, SetIsDone, (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBInputReader, IsActive, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBDebugger, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBDebugger, (const lldb::DebuggerSP &));
+ LLDB_REGISTER_CONSTRUCTOR(SBDebugger, (const lldb::SBDebugger &));
+ LLDB_REGISTER_METHOD(lldb::SBDebugger &,
+ SBDebugger, operator=,(const lldb::SBDebugger &));
+ LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Initialize, ());
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBError, SBDebugger,
+ InitializeWithErrorHandling, ());
+ LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Terminate, ());
+ LLDB_REGISTER_METHOD(void, SBDebugger, Clear, ());
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, ());
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, (bool));
+ LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Destroy,
+ (lldb::SBDebugger &));
+ LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, MemoryPressureDetected, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, IsValid, ());
+ LLDB_REGISTER_METHOD(void, SBDebugger, SetAsync, (bool));
+ LLDB_REGISTER_METHOD(bool, SBDebugger, GetAsync, ());
+ LLDB_REGISTER_METHOD(void, SBDebugger, SkipLLDBInitFiles, (bool));
+ LLDB_REGISTER_METHOD(void, SBDebugger, SkipAppInitFiles, (bool));
+ LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetInputFileHandle, ());
+ LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetOutputFileHandle, ());
+ LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetErrorFileHandle, ());
+ LLDB_REGISTER_METHOD(void, SBDebugger, SaveInputTerminalState, ());
+ LLDB_REGISTER_METHOD(void, SBDebugger, RestoreInputTerminalState, ());
+ LLDB_REGISTER_METHOD(lldb::SBCommandInterpreter, SBDebugger,
+ GetCommandInterpreter, ());
+ LLDB_REGISTER_METHOD(void, SBDebugger, HandleCommand, (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBListener, SBDebugger, GetListener, ());
+ LLDB_REGISTER_METHOD(
+ void, SBDebugger, HandleProcessEvent,
+ (const lldb::SBProcess &, const lldb::SBEvent &, FILE *, FILE *));
+ LLDB_REGISTER_METHOD(lldb::SBSourceManager, SBDebugger, GetSourceManager,
+ ());
+ LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, SetDefaultArchitecture,
+ (const char *));
+ LLDB_REGISTER_METHOD(lldb::ScriptLanguage, SBDebugger, GetScriptingLanguage,
+ (const char *));
+ LLDB_REGISTER_STATIC_METHOD(const char *, SBDebugger, GetVersionString, ());
+ LLDB_REGISTER_STATIC_METHOD(const char *, SBDebugger, StateAsCString,
+ (lldb::StateType));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBStructuredData, SBDebugger,
+ GetBuildConfiguration, ());
+ LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, StateIsRunningState,
+ (lldb::StateType));
+ LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, StateIsStoppedState,
+ (lldb::StateType));
+ LLDB_REGISTER_METHOD(
+ lldb::SBTarget, SBDebugger, CreateTarget,
+ (const char *, const char *, const char *, bool, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger,
+ CreateTargetWithFileAndTargetTriple,
+ (const char *, const char *));
+ LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger,
+ CreateTargetWithFileAndArch,
+ (const char *, const char *));
+ LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, CreateTarget,
+ (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetDummyTarget, ());
+ LLDB_REGISTER_METHOD(bool, SBDebugger, DeleteTarget, (lldb::SBTarget &));
+ LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetTargetAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetIndexOfTarget,
+ (lldb::SBTarget));
+ LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithProcessID,
+ (lldb::pid_t));
+ LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithFileAndArch,
+ (const char *, const char *));
+ LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumTargets, ());
+ LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetSelectedTarget, ());
+ LLDB_REGISTER_METHOD(void, SBDebugger, SetSelectedTarget,
+ (lldb::SBTarget &));
+ LLDB_REGISTER_METHOD(lldb::SBPlatform, SBDebugger, GetSelectedPlatform, ());
+ LLDB_REGISTER_METHOD(void, SBDebugger, SetSelectedPlatform,
+ (lldb::SBPlatform &));
+ LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumPlatforms, ());
+ LLDB_REGISTER_METHOD(lldb::SBPlatform, SBDebugger, GetPlatformAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumAvailablePlatforms, ());
+ LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBDebugger,
+ GetAvailablePlatformInfoAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(void, SBDebugger, DispatchInputInterrupt, ());
+ LLDB_REGISTER_METHOD(void, SBDebugger, DispatchInputEndOfFile, ());
+ LLDB_REGISTER_METHOD(void, SBDebugger, PushInputReader,
+ (lldb::SBInputReader &));
+ LLDB_REGISTER_METHOD(void, SBDebugger, RunCommandInterpreter, (bool, bool));
+ LLDB_REGISTER_METHOD(void, SBDebugger, RunCommandInterpreter,
+ (bool, bool, lldb::SBCommandInterpreterRunOptions &,
+ int &, bool &, bool &));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBDebugger, RunREPL,
+ (lldb::LanguageType, const char *));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger,
+ FindDebuggerWithID, (int));
+ LLDB_REGISTER_METHOD(const char *, SBDebugger, GetInstanceName, ());
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBError, SBDebugger, SetInternalVariable,
+ (const char *, const char *, const char *));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBStringList, SBDebugger,
+ GetInternalVariableValue,
+ (const char *, const char *));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBDebugger, GetTerminalWidth, ());
+ LLDB_REGISTER_METHOD(void, SBDebugger, SetTerminalWidth, (uint32_t));
+ LLDB_REGISTER_METHOD_CONST(const char *, SBDebugger, GetPrompt, ());
+ LLDB_REGISTER_METHOD(void, SBDebugger, SetPrompt, (const char *));
+ LLDB_REGISTER_METHOD_CONST(const char *, SBDebugger, GetReproducerPath, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::ScriptLanguage, SBDebugger,
+ GetScriptLanguage, ());
+ LLDB_REGISTER_METHOD(void, SBDebugger, SetScriptLanguage,
+ (lldb::ScriptLanguage));
+ LLDB_REGISTER_METHOD(bool, SBDebugger, SetUseExternalEditor, (bool));
+ LLDB_REGISTER_METHOD(bool, SBDebugger, GetUseExternalEditor, ());
+ LLDB_REGISTER_METHOD(bool, SBDebugger, SetUseColor, (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, GetUseColor, ());
+ LLDB_REGISTER_METHOD(bool, SBDebugger, GetDescription, (lldb::SBStream &));
+ LLDB_REGISTER_METHOD(lldb::user_id_t, SBDebugger, GetID, ());
+ LLDB_REGISTER_METHOD(lldb::SBError, SBDebugger, SetCurrentPlatform,
+ (const char *));
+ LLDB_REGISTER_METHOD(bool, SBDebugger, SetCurrentPlatformSDKRoot,
+ (const char *));
+ LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, GetCloseInputOnEOF, ());
+ LLDB_REGISTER_METHOD(void, SBDebugger, SetCloseInputOnEOF, (bool));
+ LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory,
+ (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory,
+ (lldb::LanguageType));
+ LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, CreateCategory,
+ (const char *));
+ LLDB_REGISTER_METHOD(bool, SBDebugger, DeleteCategory, (const char *));
+ LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumCategories, ());
+ LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategoryAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetDefaultCategory,
+ ());
+ LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBDebugger, GetFormatForType,
+ (lldb::SBTypeNameSpecifier));
+ LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBDebugger, GetSummaryForType,
+ (lldb::SBTypeNameSpecifier));
+ LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBDebugger, GetFilterForType,
+ (lldb::SBTypeNameSpecifier));
+ LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBDebugger, GetSyntheticForType,
+ (lldb::SBTypeNameSpecifier));
+ LLDB_REGISTER_METHOD(bool, SBDebugger, EnableLog,
+ (const char *, const char **));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBDeclaration, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBDeclaration, (const lldb::SBDeclaration &));
+ LLDB_REGISTER_METHOD(
+ const lldb::SBDeclaration &,
+ SBDeclaration, operator=,(const lldb::SBDeclaration &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBDeclaration, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBDeclaration, GetFileSpec,
+ ());
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBDeclaration, GetLine, ());
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBDeclaration, GetColumn, ());
+ LLDB_REGISTER_METHOD(void, SBDeclaration, SetFileSpec, (lldb::SBFileSpec));
+ LLDB_REGISTER_METHOD(void, SBDeclaration, SetLine, (uint32_t));
+ LLDB_REGISTER_METHOD(void, SBDeclaration, SetColumn, (uint32_t));
+ LLDB_REGISTER_METHOD_CONST(
+ bool, SBDeclaration, operator==,(const lldb::SBDeclaration &));
+ LLDB_REGISTER_METHOD_CONST(
+ bool, SBDeclaration, operator!=,(const lldb::SBDeclaration &));
+ LLDB_REGISTER_METHOD(bool, SBDeclaration, GetDescription,
+ (lldb::SBStream &));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBError, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBError, (const lldb::SBError &));
+ LLDB_REGISTER_METHOD(const lldb::SBError &,
+ SBError, operator=,(const lldb::SBError &));
+ LLDB_REGISTER_METHOD_CONST(const char *, SBError, GetCString, ());
+ LLDB_REGISTER_METHOD(void, SBError, Clear, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBError, Fail, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBError, Success, ());
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBError, GetError, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::ErrorType, SBError, GetType, ());
+ LLDB_REGISTER_METHOD(void, SBError, SetError, (uint32_t, lldb::ErrorType));
+ LLDB_REGISTER_METHOD(void, SBError, SetErrorToErrno, ());
+ LLDB_REGISTER_METHOD(void, SBError, SetErrorToGenericError, ());
+ LLDB_REGISTER_METHOD(void, SBError, SetErrorString, (const char *));
+ LLDB_REGISTER_METHOD_CONST(bool, SBError, IsValid, ());
+ LLDB_REGISTER_METHOD(bool, SBError, GetDescription, (lldb::SBStream &));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBEvent, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBEvent, (uint32_t, const char *, uint32_t));
+ LLDB_REGISTER_CONSTRUCTOR(SBEvent, (lldb::EventSP &));
+ LLDB_REGISTER_CONSTRUCTOR(SBEvent, (lldb_private::Event *));
+ LLDB_REGISTER_CONSTRUCTOR(SBEvent, (const lldb::SBEvent &));
+ LLDB_REGISTER_METHOD(const lldb::SBEvent &,
+ SBEvent, operator=,(const lldb::SBEvent &));
+ LLDB_REGISTER_METHOD(const char *, SBEvent, GetDataFlavor, ());
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBEvent, GetType, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBBroadcaster, SBEvent, GetBroadcaster,
+ ());
+ LLDB_REGISTER_METHOD_CONST(const char *, SBEvent, GetBroadcasterClass, ());
+ LLDB_REGISTER_METHOD(bool, SBEvent, BroadcasterMatchesPtr,
+ (const lldb::SBBroadcaster *));
+ LLDB_REGISTER_METHOD(bool, SBEvent, BroadcasterMatchesRef,
+ (const lldb::SBBroadcaster &));
+ LLDB_REGISTER_METHOD(void, SBEvent, Clear, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBEvent, IsValid, ());
+ LLDB_REGISTER_STATIC_METHOD(const char *, SBEvent, GetCStringFromEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_METHOD(bool, SBEvent, GetDescription, (lldb::SBStream &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBEvent, GetDescription,
+ (lldb::SBStream &));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext,
+ (const lldb::SBExecutionContext &));
+ LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext,
+ (lldb::ExecutionContextRefSP));
+ LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, (const lldb::SBTarget &));
+ LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, (const lldb::SBProcess &));
+ LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, (lldb::SBThread));
+ LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, (const lldb::SBFrame &));
+ LLDB_REGISTER_METHOD(
+ const lldb::SBExecutionContext &,
+ SBExecutionContext, operator=,(const lldb::SBExecutionContext &));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBTarget, SBExecutionContext, GetTarget,
+ ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBProcess, SBExecutionContext, GetProcess,
+ ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBExecutionContext, GetThread,
+ ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBFrame, SBExecutionContext, GetFrame, ());
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBExpressionOptions, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBExpressionOptions,
+ (const lldb::SBExpressionOptions &));
+ LLDB_REGISTER_METHOD(
+ const lldb::SBExpressionOptions &,
+ SBExpressionOptions, operator=,(const lldb::SBExpressionOptions &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetCoerceResultToId,
+ ());
+ LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetCoerceResultToId,
+ (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetUnwindOnError, ());
+ LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetUnwindOnError, (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetIgnoreBreakpoints,
+ ());
+ LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetIgnoreBreakpoints,
+ (bool));
+ LLDB_REGISTER_METHOD_CONST(lldb::DynamicValueType, SBExpressionOptions,
+ GetFetchDynamicValue, ());
+ LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetFetchDynamicValue,
+ (lldb::DynamicValueType));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBExpressionOptions,
+ GetTimeoutInMicroSeconds, ());
+ LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetTimeoutInMicroSeconds,
+ (uint32_t));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBExpressionOptions,
+ GetOneThreadTimeoutInMicroSeconds, ());
+ LLDB_REGISTER_METHOD(void, SBExpressionOptions,
+ SetOneThreadTimeoutInMicroSeconds, (uint32_t));
+ LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetTryAllThreads, ());
+ LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetTryAllThreads, (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetStopOthers, ());
+ LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetStopOthers, (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetTrapExceptions,
+ ());
+ LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetTrapExceptions, (bool));
+ LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetLanguage,
+ (lldb::LanguageType));
+ LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetGenerateDebugInfo, ());
+ LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetGenerateDebugInfo,
+ (bool));
+ LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetSuppressPersistentResult,
+ ());
+ LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetSuppressPersistentResult,
+ (bool));
+ LLDB_REGISTER_METHOD_CONST(const char *, SBExpressionOptions, GetPrefix,
+ ());
+ LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetPrefix, (const char *));
+ LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetAutoApplyFixIts, ());
+ LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetAutoApplyFixIts, (bool));
+ LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetTopLevel, ());
+ LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetTopLevel, (bool));
+ LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetAllowJIT, ());
+ LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetAllowJIT, (bool));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBFileSpec, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBFileSpec, (const lldb::SBFileSpec &));
+ LLDB_REGISTER_CONSTRUCTOR(SBFileSpec, (const char *));
+ LLDB_REGISTER_CONSTRUCTOR(SBFileSpec, (const char *, bool));
+ LLDB_REGISTER_METHOD(const lldb::SBFileSpec &,
+ SBFileSpec, operator=,(const lldb::SBFileSpec &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBFileSpec, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBFileSpec, Exists, ());
+ LLDB_REGISTER_METHOD(bool, SBFileSpec, ResolveExecutableLocation, ());
+ LLDB_REGISTER_STATIC_METHOD(int, SBFileSpec, ResolvePath,
+ (const char *, char *, size_t));
+ LLDB_REGISTER_METHOD_CONST(const char *, SBFileSpec, GetFilename, ());
+ LLDB_REGISTER_METHOD_CONST(const char *, SBFileSpec, GetDirectory, ());
+ LLDB_REGISTER_METHOD(void, SBFileSpec, SetFilename, (const char *));
+ LLDB_REGISTER_METHOD(void, SBFileSpec, SetDirectory, (const char *));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBFileSpec, GetPath, (char *, size_t));
+ LLDB_REGISTER_METHOD_CONST(bool, SBFileSpec, GetDescription,
+ (lldb::SBStream &));
+ LLDB_REGISTER_METHOD(void, SBFileSpec, AppendPathComponent, (const char *));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBFileSpecList, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBFileSpecList, (const lldb::SBFileSpecList &));
+ LLDB_REGISTER_METHOD(
+ const lldb::SBFileSpecList &,
+ SBFileSpecList, operator=,(const lldb::SBFileSpecList &));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBFileSpecList, GetSize, ());
+ LLDB_REGISTER_METHOD(void, SBFileSpecList, Append,
+ (const lldb::SBFileSpec &));
+ LLDB_REGISTER_METHOD(bool, SBFileSpecList, AppendIfUnique,
+ (const lldb::SBFileSpec &));
+ LLDB_REGISTER_METHOD(void, SBFileSpecList, Clear, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBFileSpecList, FindFileIndex,
+ (uint32_t, const lldb::SBFileSpec &, bool));
+ LLDB_REGISTER_METHOD_CONST(const lldb::SBFileSpec, SBFileSpecList,
+ GetFileSpecAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD_CONST(bool, SBFileSpecList, GetDescription,
+ (lldb::SBStream &));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBFrame, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBFrame, (const lldb::StackFrameSP &));
+ LLDB_REGISTER_CONSTRUCTOR(SBFrame, (const lldb::SBFrame &));
+ LLDB_REGISTER_METHOD(const lldb::SBFrame &,
+ SBFrame, operator=,(const lldb::SBFrame &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBSymbolContext, SBFrame, GetSymbolContext,
+ (uint32_t));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBModule, SBFrame, GetModule, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBCompileUnit, SBFrame, GetCompileUnit,
+ ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBFunction, SBFrame, GetFunction, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBSymbol, SBFrame, GetSymbol, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBBlock, SBFrame, GetBlock, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBBlock, SBFrame, GetFrameBlock, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBLineEntry, SBFrame, GetLineEntry, ());
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBFrame, GetFrameID, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetCFA, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetPC, ());
+ LLDB_REGISTER_METHOD(bool, SBFrame, SetPC, (lldb::addr_t));
+ LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetSP, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetFP, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBFrame, GetPCAddress, ());
+ LLDB_REGISTER_METHOD(void, SBFrame, Clear, ());
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,
+ (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,
+ (const char *, lldb::DynamicValueType));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindVariable, (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindVariable,
+ (const char *, lldb::DynamicValueType));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindValue,
+ (const char *, lldb::ValueType));
+ LLDB_REGISTER_METHOD(
+ lldb::SBValue, SBFrame, FindValue,
+ (const char *, lldb::ValueType, lldb::DynamicValueType));
+ LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsEqual, (const lldb::SBFrame &));
+ LLDB_REGISTER_METHOD_CONST(bool,
+ SBFrame, operator==,(const lldb::SBFrame &));
+ LLDB_REGISTER_METHOD_CONST(bool,
+ SBFrame, operator!=,(const lldb::SBFrame &));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBFrame, GetThread, ());
+ LLDB_REGISTER_METHOD_CONST(const char *, SBFrame, Disassemble, ());
+ LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetVariables,
+ (bool, bool, bool, bool));
+ LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetVariables,
+ (bool, bool, bool, bool, lldb::DynamicValueType));
+ LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetVariables,
+ (const lldb::SBVariablesOptions &));
+ LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetRegisters, ());
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindRegister, (const char *));
+ LLDB_REGISTER_METHOD(bool, SBFrame, GetDescription, (lldb::SBStream &));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
+ (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
+ (const char *, lldb::DynamicValueType));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
+ (const char *, lldb::DynamicValueType, bool));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
+ (const char *, const lldb::SBExpressionOptions &));
+ LLDB_REGISTER_METHOD(bool, SBFrame, IsInlined, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsInlined, ());
+ LLDB_REGISTER_METHOD(bool, SBFrame, IsArtificial, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsArtificial, ());
+ LLDB_REGISTER_METHOD(const char *, SBFrame, GetFunctionName, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::LanguageType, SBFrame, GuessLanguage, ());
+ LLDB_REGISTER_METHOD_CONST(const char *, SBFrame, GetFunctionName, ());
+ LLDB_REGISTER_METHOD(const char *, SBFrame, GetDisplayFunctionName, ());
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBFunction, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBFunction, (const lldb::SBFunction &));
+ LLDB_REGISTER_METHOD(const lldb::SBFunction &,
+ SBFunction, operator=,(const lldb::SBFunction &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBFunction, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(const char *, SBFunction, GetName, ());
+ LLDB_REGISTER_METHOD_CONST(const char *, SBFunction, GetDisplayName, ());
+ LLDB_REGISTER_METHOD_CONST(const char *, SBFunction, GetMangledName, ());
+ LLDB_REGISTER_METHOD_CONST(
+ bool, SBFunction, operator==,(const lldb::SBFunction &));
+ LLDB_REGISTER_METHOD_CONST(
+ bool, SBFunction, operator!=,(const lldb::SBFunction &));
+ LLDB_REGISTER_METHOD(bool, SBFunction, GetDescription, (lldb::SBStream &));
+ LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions,
+ (lldb::SBTarget));
+ LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions,
+ (lldb::SBTarget, const char *));
+ LLDB_REGISTER_METHOD(lldb::SBAddress, SBFunction, GetStartAddress, ());
+ LLDB_REGISTER_METHOD(lldb::SBAddress, SBFunction, GetEndAddress, ());
+ LLDB_REGISTER_METHOD(const char *, SBFunction, GetArgumentName, (uint32_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBFunction, GetPrologueByteSize, ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBFunction, GetType, ());
+ LLDB_REGISTER_METHOD(lldb::SBBlock, SBFunction, GetBlock, ());
+ LLDB_REGISTER_METHOD(lldb::LanguageType, SBFunction, GetLanguage, ());
+ LLDB_REGISTER_METHOD(bool, SBFunction, GetIsOptimized, ());
+ }
+ {
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBFileSpec, SBHostOS, GetProgramFileSpec,
+ ());
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBFileSpec, SBHostOS, GetLLDBPythonPath,
+ ());
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBFileSpec, SBHostOS, GetLLDBPath,
+ (lldb::PathType));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBFileSpec, SBHostOS,
+ GetUserHomeDirectory, ());
+ LLDB_REGISTER_STATIC_METHOD(void, SBHostOS, ThreadCreated, (const char *));
+ LLDB_REGISTER_STATIC_METHOD(bool, SBHostOS, ThreadCancel,
+ (lldb::thread_t, lldb::SBError *));
+ LLDB_REGISTER_STATIC_METHOD(bool, SBHostOS, ThreadDetach,
+ (lldb::thread_t, lldb::SBError *));
+ LLDB_REGISTER_STATIC_METHOD(
+ bool, SBHostOS, ThreadJoin,
+ (lldb::thread_t, lldb::thread_result_t *, lldb::SBError *));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBInstruction, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBInstruction, (const lldb::SBInstruction &));
+ LLDB_REGISTER_METHOD(
+ const lldb::SBInstruction &,
+ SBInstruction, operator=,(const lldb::SBInstruction &));
+ LLDB_REGISTER_METHOD(bool, SBInstruction, IsValid, ());
+ LLDB_REGISTER_METHOD(lldb::SBAddress, SBInstruction, GetAddress, ());
+ LLDB_REGISTER_METHOD(const char *, SBInstruction, GetMnemonic,
+ (lldb::SBTarget));
+ LLDB_REGISTER_METHOD(const char *, SBInstruction, GetOperands,
+ (lldb::SBTarget));
+ LLDB_REGISTER_METHOD(const char *, SBInstruction, GetComment,
+ (lldb::SBTarget));
+ LLDB_REGISTER_METHOD(size_t, SBInstruction, GetByteSize, ());
+ LLDB_REGISTER_METHOD(lldb::SBData, SBInstruction, GetData,
+ (lldb::SBTarget));
+ LLDB_REGISTER_METHOD(bool, SBInstruction, DoesBranch, ());
+ LLDB_REGISTER_METHOD(bool, SBInstruction, HasDelaySlot, ());
+ LLDB_REGISTER_METHOD(bool, SBInstruction, CanSetBreakpoint, ());
+ LLDB_REGISTER_METHOD(bool, SBInstruction, GetDescription,
+ (lldb::SBStream &));
+ LLDB_REGISTER_METHOD(void, SBInstruction, Print, (FILE *));
+ LLDB_REGISTER_METHOD(bool, SBInstruction, EmulateWithFrame,
+ (lldb::SBFrame &, uint32_t));
+ LLDB_REGISTER_METHOD(bool, SBInstruction, DumpEmulation, (const char *));
+ LLDB_REGISTER_METHOD(bool, SBInstruction, TestEmulation,
+ (lldb::SBStream &, const char *));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBInstructionList, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBInstructionList,
+ (const lldb::SBInstructionList &));
+ LLDB_REGISTER_METHOD(
+ const lldb::SBInstructionList &,
+ SBInstructionList, operator=,(const lldb::SBInstructionList &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBInstructionList, IsValid, ());
+ LLDB_REGISTER_METHOD(size_t, SBInstructionList, GetSize, ());
+ LLDB_REGISTER_METHOD(lldb::SBInstruction, SBInstructionList,
+ GetInstructionAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(
+ size_t, SBInstructionList, GetInstructionsCount,
+ (const lldb::SBAddress &, const lldb::SBAddress &, bool));
+ LLDB_REGISTER_METHOD(void, SBInstructionList, Clear, ());
+ LLDB_REGISTER_METHOD(void, SBInstructionList, AppendInstruction,
+ (lldb::SBInstruction));
+ LLDB_REGISTER_METHOD(void, SBInstructionList, Print, (FILE *));
+ LLDB_REGISTER_METHOD(bool, SBInstructionList, GetDescription,
+ (lldb::SBStream &));
+ LLDB_REGISTER_METHOD(bool, SBInstructionList,
+ DumpEmulationForAllInstructions, (const char *));
+ }
+ {
+ LLDB_REGISTER_STATIC_METHOD(lldb::LanguageType, SBLanguageRuntime,
+ GetLanguageTypeFromString, (const char *));
+ LLDB_REGISTER_STATIC_METHOD(const char *, SBLanguageRuntime,
+ GetNameForLanguageType, (lldb::LanguageType));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBLaunchInfo, (const char **));
+ LLDB_REGISTER_METHOD(lldb::pid_t, SBLaunchInfo, GetProcessID, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetUserID, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetGroupID, ());
+ LLDB_REGISTER_METHOD(bool, SBLaunchInfo, UserIDIsValid, ());
+ LLDB_REGISTER_METHOD(bool, SBLaunchInfo, GroupIDIsValid, ());
+ LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetUserID, (uint32_t));
+ LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetGroupID, (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBLaunchInfo, GetExecutableFile, ());
+ LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetExecutableFile,
+ (lldb::SBFileSpec, bool));
+ LLDB_REGISTER_METHOD(lldb::SBListener, SBLaunchInfo, GetListener, ());
+ LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetListener, (lldb::SBListener &));
+ LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetNumArguments, ());
+ LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetArgumentAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetArguments,
+ (const char **, bool));
+ LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetNumEnvironmentEntries, ());
+ LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetEnvironmentEntryAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetEnvironmentEntries,
+ (const char **, bool));
+ LLDB_REGISTER_METHOD(void, SBLaunchInfo, Clear, ());
+ LLDB_REGISTER_METHOD_CONST(const char *, SBLaunchInfo, GetWorkingDirectory,
+ ());
+ LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetWorkingDirectory,
+ (const char *));
+ LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetLaunchFlags, ());
+ LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetLaunchFlags, (uint32_t));
+ LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetProcessPluginName, ());
+ LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetProcessPluginName,
+ (const char *));
+ LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetShell, ());
+ LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetShell, (const char *));
+ LLDB_REGISTER_METHOD(bool, SBLaunchInfo, GetShellExpandArguments, ());
+ LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetShellExpandArguments, (bool));
+ LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetResumeCount, ());
+ LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetResumeCount, (uint32_t));
+ LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddCloseFileAction, (int));
+ LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddDuplicateFileAction,
+ (int, int));
+ LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddOpenFileAction,
+ (int, const char *, bool, bool));
+ LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddSuppressFileAction,
+ (int, bool, bool));
+ LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetLaunchEventData,
+ (const char *));
+ LLDB_REGISTER_METHOD_CONST(const char *, SBLaunchInfo, GetLaunchEventData,
+ ());
+ LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetDetachOnError, (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBLaunchInfo, GetDetachOnError, ());
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBLineEntry, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBLineEntry, (const lldb::SBLineEntry &));
+ LLDB_REGISTER_METHOD(const lldb::SBLineEntry &,
+ SBLineEntry, operator=,(const lldb::SBLineEntry &));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBLineEntry, GetStartAddress,
+ ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBLineEntry, GetEndAddress, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBLineEntry, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBLineEntry, GetFileSpec, ());
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBLineEntry, GetLine, ());
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBLineEntry, GetColumn, ());
+ LLDB_REGISTER_METHOD(void, SBLineEntry, SetFileSpec, (lldb::SBFileSpec));
+ LLDB_REGISTER_METHOD(void, SBLineEntry, SetLine, (uint32_t));
+ LLDB_REGISTER_METHOD(void, SBLineEntry, SetColumn, (uint32_t));
+ LLDB_REGISTER_METHOD_CONST(
+ bool, SBLineEntry, operator==,(const lldb::SBLineEntry &));
+ LLDB_REGISTER_METHOD_CONST(
+ bool, SBLineEntry, operator!=,(const lldb::SBLineEntry &));
+ LLDB_REGISTER_METHOD(bool, SBLineEntry, GetDescription, (lldb::SBStream &));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBListener, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBListener, (const char *));
+ LLDB_REGISTER_CONSTRUCTOR(SBListener, (const lldb::SBListener &));
+ LLDB_REGISTER_METHOD(const lldb::SBListener &,
+ SBListener, operator=,(const lldb::SBListener &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBListener, IsValid, ());
+ LLDB_REGISTER_METHOD(void, SBListener, AddEvent, (const lldb::SBEvent &));
+ LLDB_REGISTER_METHOD(void, SBListener, Clear, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBListener, StartListeningForEventClass,
+ (lldb::SBDebugger &, const char *, uint32_t));
+ LLDB_REGISTER_METHOD(bool, SBListener, StopListeningForEventClass,
+ (lldb::SBDebugger &, const char *, uint32_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBListener, StartListeningForEvents,
+ (const lldb::SBBroadcaster &, uint32_t));
+ LLDB_REGISTER_METHOD(bool, SBListener, StopListeningForEvents,
+ (const lldb::SBBroadcaster &, uint32_t));
+ LLDB_REGISTER_METHOD(bool, SBListener, WaitForEvent,
+ (uint32_t, lldb::SBEvent &));
+ LLDB_REGISTER_METHOD(
+ bool, SBListener, WaitForEventForBroadcaster,
+ (uint32_t, const lldb::SBBroadcaster &, lldb::SBEvent &));
+ LLDB_REGISTER_METHOD(
+ bool, SBListener, WaitForEventForBroadcasterWithType,
+ (uint32_t, const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &));
+ LLDB_REGISTER_METHOD(bool, SBListener, PeekAtNextEvent, (lldb::SBEvent &));
+ LLDB_REGISTER_METHOD(bool, SBListener, PeekAtNextEventForBroadcaster,
+ (const lldb::SBBroadcaster &, lldb::SBEvent &));
+ LLDB_REGISTER_METHOD(
+ bool, SBListener, PeekAtNextEventForBroadcasterWithType,
+ (const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &));
+ LLDB_REGISTER_METHOD(bool, SBListener, GetNextEvent, (lldb::SBEvent &));
+ LLDB_REGISTER_METHOD(bool, SBListener, GetNextEventForBroadcaster,
+ (const lldb::SBBroadcaster &, lldb::SBEvent &));
+ LLDB_REGISTER_METHOD(
+ bool, SBListener, GetNextEventForBroadcasterWithType,
+ (const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &));
+ LLDB_REGISTER_METHOD(bool, SBListener, HandleBroadcastEvent,
+ (const lldb::SBEvent &));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfo, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfo,
+ (const lldb::SBMemoryRegionInfo &));
+ LLDB_REGISTER_METHOD(
+ const lldb::SBMemoryRegionInfo &,
+ SBMemoryRegionInfo, operator=,(const lldb::SBMemoryRegionInfo &));
+ LLDB_REGISTER_METHOD(void, SBMemoryRegionInfo, Clear, ());
+ LLDB_REGISTER_METHOD_CONST(
+ bool,
+ SBMemoryRegionInfo, operator==,(const lldb::SBMemoryRegionInfo &));
+ LLDB_REGISTER_METHOD_CONST(
+ bool,
+ SBMemoryRegionInfo, operator!=,(const lldb::SBMemoryRegionInfo &));
+ LLDB_REGISTER_METHOD(lldb::addr_t, SBMemoryRegionInfo, GetRegionBase, ());
+ LLDB_REGISTER_METHOD(lldb::addr_t, SBMemoryRegionInfo, GetRegionEnd, ());
+ LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsReadable, ());
+ LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsWritable, ());
+ LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsExecutable, ());
+ LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsMapped, ());
+ LLDB_REGISTER_METHOD(const char *, SBMemoryRegionInfo, GetName, ());
+ LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, GetDescription,
+ (lldb::SBStream &));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfoList, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfoList,
+ (const lldb::SBMemoryRegionInfoList &));
+ LLDB_REGISTER_METHOD(
+ const lldb::SBMemoryRegionInfoList &,
+ SBMemoryRegionInfoList, operator=,(
+ const lldb::SBMemoryRegionInfoList &));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBMemoryRegionInfoList, GetSize, ());
+ LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfoList, GetMemoryRegionAtIndex,
+ (uint32_t, lldb::SBMemoryRegionInfo &));
+ LLDB_REGISTER_METHOD(void, SBMemoryRegionInfoList, Clear, ());
+ LLDB_REGISTER_METHOD(void, SBMemoryRegionInfoList, Append,
+ (lldb::SBMemoryRegionInfo &));
+ LLDB_REGISTER_METHOD(void, SBMemoryRegionInfoList, Append,
+ (lldb::SBMemoryRegionInfoList &));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBModule, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBModule, (const lldb::SBModuleSpec &));
+ LLDB_REGISTER_CONSTRUCTOR(SBModule, (const lldb::SBModule &));
+ LLDB_REGISTER_CONSTRUCTOR(SBModule, (lldb::SBProcess &, lldb::addr_t));
+ LLDB_REGISTER_METHOD(const lldb::SBModule &,
+ SBModule, operator=,(const lldb::SBModule &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBModule, IsValid, ());
+ LLDB_REGISTER_METHOD(void, SBModule, Clear, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBModule, GetFileSpec, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBModule, GetPlatformFileSpec,
+ ());
+ LLDB_REGISTER_METHOD(bool, SBModule, SetPlatformFileSpec,
+ (const lldb::SBFileSpec &));
+ LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModule, GetRemoteInstallFileSpec,
+ ());
+ LLDB_REGISTER_METHOD(bool, SBModule, SetRemoteInstallFileSpec,
+ (lldb::SBFileSpec &));
+ LLDB_REGISTER_METHOD_CONST(const char *, SBModule, GetUUIDString, ());
+ LLDB_REGISTER_METHOD_CONST(bool,
+ SBModule, operator==,(const lldb::SBModule &));
+ LLDB_REGISTER_METHOD_CONST(bool,
+ SBModule, operator!=,(const lldb::SBModule &));
+ LLDB_REGISTER_METHOD(lldb::SBAddress, SBModule, ResolveFileAddress,
+ (lldb::addr_t));
+ LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBModule,
+ ResolveSymbolContextForAddress,
+ (const lldb::SBAddress &, uint32_t));
+ LLDB_REGISTER_METHOD(bool, SBModule, GetDescription, (lldb::SBStream &));
+ LLDB_REGISTER_METHOD(uint32_t, SBModule, GetNumCompileUnits, ());
+ LLDB_REGISTER_METHOD(lldb::SBCompileUnit, SBModule, GetCompileUnitAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBModule, FindCompileUnits,
+ (const lldb::SBFileSpec &));
+ LLDB_REGISTER_METHOD(size_t, SBModule, GetNumSymbols, ());
+ LLDB_REGISTER_METHOD(lldb::SBSymbol, SBModule, GetSymbolAtIndex, (size_t));
+ LLDB_REGISTER_METHOD(lldb::SBSymbol, SBModule, FindSymbol,
+ (const char *, lldb::SymbolType));
+ LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBModule, FindSymbols,
+ (const char *, lldb::SymbolType));
+ LLDB_REGISTER_METHOD(size_t, SBModule, GetNumSections, ());
+ LLDB_REGISTER_METHOD(lldb::SBSection, SBModule, GetSectionAtIndex,
+ (size_t));
+ LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBModule, FindFunctions,
+ (const char *, uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBValueList, SBModule, FindGlobalVariables,
+ (lldb::SBTarget &, const char *, uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBModule, FindFirstGlobalVariable,
+ (lldb::SBTarget &, const char *));
+ LLDB_REGISTER_METHOD(lldb::SBType, SBModule, FindFirstType, (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBType, SBModule, GetBasicType,
+ (lldb::BasicType));
+ LLDB_REGISTER_METHOD(lldb::SBTypeList, SBModule, FindTypes, (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBType, SBModule, GetTypeByID,
+ (lldb::user_id_t));
+ LLDB_REGISTER_METHOD(lldb::SBTypeList, SBModule, GetTypes, (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBSection, SBModule, FindSection,
+ (const char *));
+ LLDB_REGISTER_METHOD(lldb::ByteOrder, SBModule, GetByteOrder, ());
+ LLDB_REGISTER_METHOD(const char *, SBModule, GetTriple, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBModule, GetAddressByteSize, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBModule, GetVersion,
+ (uint32_t *, uint32_t));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBModule, GetSymbolFileSpec,
+ ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBModule,
+ GetObjectFileHeaderAddress, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBModule,
+ GetObjectFileEntryPointAddress, ());
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBModuleSpec, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBModuleSpec, (const lldb::SBModuleSpec &));
+ LLDB_REGISTER_METHOD(const lldb::SBModuleSpec &,
+ SBModuleSpec, operator=,(const lldb::SBModuleSpec &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBModuleSpec, IsValid, ());
+ LLDB_REGISTER_METHOD(void, SBModuleSpec, Clear, ());
+ LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModuleSpec, GetFileSpec, ());
+ LLDB_REGISTER_METHOD(void, SBModuleSpec, SetFileSpec,
+ (const lldb::SBFileSpec &));
+ LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModuleSpec, GetPlatformFileSpec,
+ ());
+ LLDB_REGISTER_METHOD(void, SBModuleSpec, SetPlatformFileSpec,
+ (const lldb::SBFileSpec &));
+ LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModuleSpec, GetSymbolFileSpec, ());
+ LLDB_REGISTER_METHOD(void, SBModuleSpec, SetSymbolFileSpec,
+ (const lldb::SBFileSpec &));
+ LLDB_REGISTER_METHOD(const char *, SBModuleSpec, GetObjectName, ());
+ LLDB_REGISTER_METHOD(void, SBModuleSpec, SetObjectName, (const char *));
+ LLDB_REGISTER_METHOD(const char *, SBModuleSpec, GetTriple, ());
+ LLDB_REGISTER_METHOD(void, SBModuleSpec, SetTriple, (const char *));
+ LLDB_REGISTER_METHOD(size_t, SBModuleSpec, GetUUIDLength, ());
+ LLDB_REGISTER_METHOD(bool, SBModuleSpec, GetDescription,
+ (lldb::SBStream &));
+ LLDB_REGISTER_CONSTRUCTOR(SBModuleSpecList, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBModuleSpecList,
+ (const lldb::SBModuleSpecList &));
+ LLDB_REGISTER_METHOD(
+ lldb::SBModuleSpecList &,
+ SBModuleSpecList, operator=,(const lldb::SBModuleSpecList &));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBModuleSpecList, SBModuleSpecList,
+ GetModuleSpecifications, (const char *));
+ LLDB_REGISTER_METHOD(void, SBModuleSpecList, Append,
+ (const lldb::SBModuleSpec &));
+ LLDB_REGISTER_METHOD(void, SBModuleSpecList, Append,
+ (const lldb::SBModuleSpecList &));
+ LLDB_REGISTER_METHOD(size_t, SBModuleSpecList, GetSize, ());
+ LLDB_REGISTER_METHOD(lldb::SBModuleSpec, SBModuleSpecList, GetSpecAtIndex,
+ (size_t));
+ LLDB_REGISTER_METHOD(lldb::SBModuleSpec, SBModuleSpecList,
+ FindFirstMatchingSpec, (const lldb::SBModuleSpec &));
+ LLDB_REGISTER_METHOD(lldb::SBModuleSpecList, SBModuleSpecList,
+ FindMatchingSpecs, (const lldb::SBModuleSpec &));
+ LLDB_REGISTER_METHOD(bool, SBModuleSpecList, GetDescription,
+ (lldb::SBStream &));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBPlatformConnectOptions, (const char *));
+ LLDB_REGISTER_CONSTRUCTOR(SBPlatformConnectOptions,
+ (const lldb::SBPlatformConnectOptions &));
+ LLDB_REGISTER_METHOD(
+ void,
+ SBPlatformConnectOptions, operator=,(
+ const lldb::SBPlatformConnectOptions &));
+ LLDB_REGISTER_METHOD(const char *, SBPlatformConnectOptions, GetURL, ());
+ LLDB_REGISTER_METHOD(void, SBPlatformConnectOptions, SetURL,
+ (const char *));
+ LLDB_REGISTER_METHOD(bool, SBPlatformConnectOptions, GetRsyncEnabled, ());
+ LLDB_REGISTER_METHOD(void, SBPlatformConnectOptions, EnableRsync,
+ (const char *, const char *, bool));
+ LLDB_REGISTER_METHOD(void, SBPlatformConnectOptions, DisableRsync, ());
+ LLDB_REGISTER_METHOD(const char *, SBPlatformConnectOptions,
+ GetLocalCacheDirectory, ());
+ LLDB_REGISTER_METHOD(void, SBPlatformConnectOptions, SetLocalCacheDirectory,
+ (const char *));
+ LLDB_REGISTER_CONSTRUCTOR(SBPlatformShellCommand, (const char *));
+ LLDB_REGISTER_CONSTRUCTOR(SBPlatformShellCommand,
+ (const lldb::SBPlatformShellCommand &));
+ LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, Clear, ());
+ LLDB_REGISTER_METHOD(const char *, SBPlatformShellCommand, GetCommand, ());
+ LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, SetCommand,
+ (const char *));
+ LLDB_REGISTER_METHOD(const char *, SBPlatformShellCommand,
+ GetWorkingDirectory, ());
+ LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, SetWorkingDirectory,
+ (const char *));
+ LLDB_REGISTER_METHOD(uint32_t, SBPlatformShellCommand, GetTimeoutSeconds,
+ ());
+ LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, SetTimeoutSeconds,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(int, SBPlatformShellCommand, GetSignal, ());
+ LLDB_REGISTER_METHOD(int, SBPlatformShellCommand, GetStatus, ());
+ LLDB_REGISTER_METHOD(const char *, SBPlatformShellCommand, GetOutput, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBPlatform, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBPlatform, (const char *));
+ LLDB_REGISTER_METHOD_CONST(bool, SBPlatform, IsValid, ());
+ LLDB_REGISTER_METHOD(void, SBPlatform, Clear, ());
+ LLDB_REGISTER_METHOD(const char *, SBPlatform, GetName, ());
+ LLDB_REGISTER_METHOD(const char *, SBPlatform, GetWorkingDirectory, ());
+ LLDB_REGISTER_METHOD(bool, SBPlatform, SetWorkingDirectory, (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, ConnectRemote,
+ (lldb::SBPlatformConnectOptions &));
+ LLDB_REGISTER_METHOD(void, SBPlatform, DisconnectRemote, ());
+ LLDB_REGISTER_METHOD(bool, SBPlatform, IsConnected, ());
+ LLDB_REGISTER_METHOD(const char *, SBPlatform, GetTriple, ());
+ LLDB_REGISTER_METHOD(const char *, SBPlatform, GetOSBuild, ());
+ LLDB_REGISTER_METHOD(const char *, SBPlatform, GetOSDescription, ());
+ LLDB_REGISTER_METHOD(const char *, SBPlatform, GetHostname, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetOSMajorVersion, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetOSMinorVersion, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetOSUpdateVersion, ());
+ LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Get,
+ (lldb::SBFileSpec &, lldb::SBFileSpec &));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Put,
+ (lldb::SBFileSpec &, lldb::SBFileSpec &));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Install,
+ (lldb::SBFileSpec &, lldb::SBFileSpec &));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Run,
+ (lldb::SBPlatformShellCommand &));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Launch,
+ (lldb::SBLaunchInfo &));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Kill, (const lldb::pid_t));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, MakeDirectory,
+ (const char *, uint32_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetFilePermissions,
+ (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, SetFilePermissions,
+ (const char *, uint32_t));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBUnixSignals, SBPlatform, GetUnixSignals,
+ ());
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBProcess, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBProcess, (const lldb::SBProcess &));
+ LLDB_REGISTER_CONSTRUCTOR(SBProcess, (const lldb::ProcessSP &));
+ LLDB_REGISTER_METHOD(const lldb::SBProcess &,
+ SBProcess, operator=,(const lldb::SBProcess &));
+ LLDB_REGISTER_STATIC_METHOD(const char *, SBProcess,
+ GetBroadcasterClassName, ());
+ LLDB_REGISTER_METHOD(const char *, SBProcess, GetPluginName, ());
+ LLDB_REGISTER_METHOD(const char *, SBProcess, GetShortPluginName, ());
+ LLDB_REGISTER_METHOD(void, SBProcess, Clear, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBProcess, IsValid, ());
+ LLDB_REGISTER_METHOD(bool, SBProcess, RemoteLaunch,
+ (const char **, const char **, const char *,
+ const char *, const char *, const char *, uint32_t,
+ bool, lldb::SBError &));
+ LLDB_REGISTER_METHOD(bool, SBProcess, RemoteAttachToProcessWithID,
+ (lldb::pid_t, lldb::SBError &));
+ LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetNumThreads, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBProcess, GetSelectedThread,
+ ());
+ LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, CreateOSPluginThread,
+ (lldb::tid_t, lldb::addr_t));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBTarget, SBProcess, GetTarget, ());
+ LLDB_REGISTER_METHOD(size_t, SBProcess, PutSTDIN, (const char *, size_t));
+ LLDB_REGISTER_METHOD_CONST(size_t, SBProcess, GetSTDOUT, (char *, size_t));
+ LLDB_REGISTER_METHOD_CONST(size_t, SBProcess, GetSTDERR, (char *, size_t));
+ LLDB_REGISTER_METHOD_CONST(size_t, SBProcess, GetAsyncProfileData,
+ (char *, size_t));
+ LLDB_REGISTER_METHOD(lldb::SBTrace, SBProcess, StartTrace,
+ (lldb::SBTraceOptions &, lldb::SBError &));
+ LLDB_REGISTER_METHOD_CONST(void, SBProcess, ReportEventState,
+ (const lldb::SBEvent &, FILE *));
+ LLDB_REGISTER_METHOD(
+ void, SBProcess, AppendEventStateReport,
+ (const lldb::SBEvent &, lldb::SBCommandReturnObject &));
+ LLDB_REGISTER_METHOD(bool, SBProcess, SetSelectedThread,
+ (const lldb::SBThread &));
+ LLDB_REGISTER_METHOD(bool, SBProcess, SetSelectedThreadByID, (lldb::tid_t));
+ LLDB_REGISTER_METHOD(bool, SBProcess, SetSelectedThreadByIndexID,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, GetThreadAtIndex, (size_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetNumQueues, ());
+ LLDB_REGISTER_METHOD(lldb::SBQueue, SBProcess, GetQueueAtIndex, (size_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetStopID, (bool));
+ LLDB_REGISTER_METHOD(lldb::SBEvent, SBProcess, GetStopEventForStopID,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::StateType, SBProcess, GetState, ());
+ LLDB_REGISTER_METHOD(int, SBProcess, GetExitStatus, ());
+ LLDB_REGISTER_METHOD(const char *, SBProcess, GetExitDescription, ());
+ LLDB_REGISTER_METHOD(lldb::pid_t, SBProcess, GetProcessID, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetUniqueID, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::ByteOrder, SBProcess, GetByteOrder, ());
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBProcess, GetAddressByteSize, ());
+ LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Continue, ());
+ LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Destroy, ());
+ LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Stop, ());
+ LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Kill, ());
+ LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Detach, ());
+ LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Detach, (bool));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Signal, (int));
+ LLDB_REGISTER_METHOD(lldb::SBUnixSignals, SBProcess, GetUnixSignals, ());
+ LLDB_REGISTER_METHOD(void, SBProcess, SendAsyncInterrupt, ());
+ LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, GetThreadByID,
+ (lldb::tid_t));
+ LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, GetThreadByIndexID,
+ (uint32_t));
+ LLDB_REGISTER_STATIC_METHOD(lldb::StateType, SBProcess, GetStateFromEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, GetRestartedFromEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_STATIC_METHOD(size_t, SBProcess,
+ GetNumRestartedReasonsFromEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_STATIC_METHOD(const char *, SBProcess,
+ GetRestartedReasonAtIndexFromEvent,
+ (const lldb::SBEvent &, size_t));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBProcess, SBProcess, GetProcessFromEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, GetInterruptedFromEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBStructuredData, SBProcess,
+ GetStructuredDataFromEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, EventIsProcessEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, EventIsStructuredDataEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBBroadcaster, SBProcess, GetBroadcaster,
+ ());
+ LLDB_REGISTER_STATIC_METHOD(const char *, SBProcess, GetBroadcasterClass,
+ ());
+ LLDB_REGISTER_METHOD(uint64_t, SBProcess, ReadUnsignedFromMemory,
+ (lldb::addr_t, uint32_t, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::addr_t, SBProcess, ReadPointerFromMemory,
+ (lldb::addr_t, lldb::SBError &));
+ LLDB_REGISTER_METHOD(bool, SBProcess, GetDescription, (lldb::SBStream &));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBProcess,
+ GetNumSupportedHardwareWatchpoints,
+ (lldb::SBError &));
+ LLDB_REGISTER_METHOD(uint32_t, SBProcess, LoadImage,
+ (lldb::SBFileSpec &, lldb::SBError &));
+ LLDB_REGISTER_METHOD(
+ uint32_t, SBProcess, LoadImage,
+ (const lldb::SBFileSpec &, const lldb::SBFileSpec &, lldb::SBError &));
+ LLDB_REGISTER_METHOD(uint32_t, SBProcess, LoadImageUsingPaths,
+ (const lldb::SBFileSpec &, lldb::SBStringList &,
+ lldb::SBFileSpec &, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, UnloadImage, (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, SendEventData,
+ (const char *));
+ LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetNumExtendedBacktraceTypes, ());
+ LLDB_REGISTER_METHOD(const char *, SBProcess,
+ GetExtendedBacktraceTypeAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBThreadCollection, SBProcess, GetHistoryThreads,
+ (lldb::addr_t));
+ LLDB_REGISTER_METHOD(bool, SBProcess, IsInstrumentationRuntimePresent,
+ (lldb::InstrumentationRuntimeType));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, SaveCore, (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, GetMemoryRegionInfo,
+ (lldb::addr_t, lldb::SBMemoryRegionInfo &));
+ LLDB_REGISTER_METHOD(lldb::SBMemoryRegionInfoList, SBProcess,
+ GetMemoryRegions, ());
+ LLDB_REGISTER_METHOD(lldb::SBProcessInfo, SBProcess, GetProcessInfo, ());
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBProcessInfo, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBProcessInfo, (const lldb::SBProcessInfo &));
+ LLDB_REGISTER_METHOD(
+ lldb::SBProcessInfo &,
+ SBProcessInfo, operator=,(const lldb::SBProcessInfo &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBProcessInfo, IsValid, ());
+ LLDB_REGISTER_METHOD(const char *, SBProcessInfo, GetName, ());
+ LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBProcessInfo, GetExecutableFile,
+ ());
+ LLDB_REGISTER_METHOD(lldb::pid_t, SBProcessInfo, GetProcessID, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetUserID, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetGroupID, ());
+ LLDB_REGISTER_METHOD(bool, SBProcessInfo, UserIDIsValid, ());
+ LLDB_REGISTER_METHOD(bool, SBProcessInfo, GroupIDIsValid, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetEffectiveUserID, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetEffectiveGroupID, ());
+ LLDB_REGISTER_METHOD(bool, SBProcessInfo, EffectiveUserIDIsValid, ());
+ LLDB_REGISTER_METHOD(bool, SBProcessInfo, EffectiveGroupIDIsValid, ());
+ LLDB_REGISTER_METHOD(lldb::pid_t, SBProcessInfo, GetParentProcessID, ());
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBQueue, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBQueue, (const lldb::QueueSP &));
+ LLDB_REGISTER_CONSTRUCTOR(SBQueue, (const lldb::SBQueue &));
+ LLDB_REGISTER_METHOD(const lldb::SBQueue &,
+ SBQueue, operator=,(const lldb::SBQueue &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBQueue, IsValid, ());
+ LLDB_REGISTER_METHOD(void, SBQueue, Clear, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::queue_id_t, SBQueue, GetQueueID, ());
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBQueue, GetIndexID, ());
+ LLDB_REGISTER_METHOD_CONST(const char *, SBQueue, GetName, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBQueue, GetNumThreads, ());
+ LLDB_REGISTER_METHOD(lldb::SBThread, SBQueue, GetThreadAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBQueue, GetNumPendingItems, ());
+ LLDB_REGISTER_METHOD(lldb::SBQueueItem, SBQueue, GetPendingItemAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBQueue, GetNumRunningItems, ());
+ LLDB_REGISTER_METHOD(lldb::SBProcess, SBQueue, GetProcess, ());
+ LLDB_REGISTER_METHOD(lldb::QueueKind, SBQueue, GetKind, ());
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBQueueItem, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBQueueItem, (const lldb::QueueItemSP &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBQueueItem, IsValid, ());
+ LLDB_REGISTER_METHOD(void, SBQueueItem, Clear, ());
+ LLDB_REGISTER_METHOD(void, SBQueueItem, SetQueueItem,
+ (const lldb::QueueItemSP &));
+ LLDB_REGISTER_METHOD_CONST(lldb::QueueItemKind, SBQueueItem, GetKind, ());
+ LLDB_REGISTER_METHOD(void, SBQueueItem, SetKind, (lldb::QueueItemKind));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBQueueItem, GetAddress, ());
+ LLDB_REGISTER_METHOD(void, SBQueueItem, SetAddress, (lldb::SBAddress));
+ LLDB_REGISTER_METHOD(lldb::SBThread, SBQueueItem,
+ GetExtendedBacktraceThread, (const char *));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBSection, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBSection, (const lldb::SBSection &));
+ LLDB_REGISTER_METHOD(const lldb::SBSection &,
+ SBSection, operator=,(const lldb::SBSection &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBSection, IsValid, ());
+ LLDB_REGISTER_METHOD(const char *, SBSection, GetName, ());
+ LLDB_REGISTER_METHOD(lldb::SBSection, SBSection, GetParent, ());
+ LLDB_REGISTER_METHOD(lldb::SBSection, SBSection, FindSubSection,
+ (const char *));
+ LLDB_REGISTER_METHOD(size_t, SBSection, GetNumSubSections, ());
+ LLDB_REGISTER_METHOD(lldb::SBSection, SBSection, GetSubSectionAtIndex,
+ (size_t));
+ LLDB_REGISTER_METHOD(lldb::addr_t, SBSection, GetFileAddress, ());
+ LLDB_REGISTER_METHOD(lldb::addr_t, SBSection, GetLoadAddress,
+ (lldb::SBTarget &));
+ LLDB_REGISTER_METHOD(lldb::addr_t, SBSection, GetByteSize, ());
+ LLDB_REGISTER_METHOD(uint64_t, SBSection, GetFileOffset, ());
+ LLDB_REGISTER_METHOD(uint64_t, SBSection, GetFileByteSize, ());
+ LLDB_REGISTER_METHOD(lldb::SBData, SBSection, GetSectionData, ());
+ LLDB_REGISTER_METHOD(lldb::SBData, SBSection, GetSectionData,
+ (uint64_t, uint64_t));
+ LLDB_REGISTER_METHOD(lldb::SectionType, SBSection, GetSectionType, ());
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBSection, GetPermissions, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBSection, GetTargetByteSize, ());
+ LLDB_REGISTER_METHOD(bool, SBSection, operator==,(const lldb::SBSection &));
+ LLDB_REGISTER_METHOD(bool, SBSection, operator!=,(const lldb::SBSection &));
+ LLDB_REGISTER_METHOD(bool, SBSection, GetDescription, (lldb::SBStream &));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBSourceManager, (const lldb::SBDebugger &));
+ LLDB_REGISTER_CONSTRUCTOR(SBSourceManager, (const lldb::SBTarget &));
+ LLDB_REGISTER_CONSTRUCTOR(SBSourceManager, (const lldb::SBSourceManager &));
+ LLDB_REGISTER_METHOD(
+ const lldb::SBSourceManager &,
+ SBSourceManager, operator=,(const lldb::SBSourceManager &));
+ LLDB_REGISTER_METHOD(size_t, SBSourceManager,
+ DisplaySourceLinesWithLineNumbers,
+ (const lldb::SBFileSpec &, uint32_t, uint32_t,
+ uint32_t, const char *, lldb::SBStream &));
+ LLDB_REGISTER_METHOD(size_t, SBSourceManager,
+ DisplaySourceLinesWithLineNumbersAndColumn,
+ (const lldb::SBFileSpec &, uint32_t, uint32_t,
+ uint32_t, uint32_t, const char *, lldb::SBStream &));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBStream, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBStream, IsValid, ());
+ LLDB_REGISTER_METHOD(const char *, SBStream, GetData, ());
+ LLDB_REGISTER_METHOD(size_t, SBStream, GetSize, ());
+ LLDB_REGISTER_METHOD(void, SBStream, RedirectToFile, (const char *, bool));
+ LLDB_REGISTER_METHOD(void, SBStream, RedirectToFileHandle, (FILE *, bool));
+ LLDB_REGISTER_METHOD(void, SBStream, RedirectToFileDescriptor, (int, bool));
+ LLDB_REGISTER_METHOD(void, SBStream, Clear, ());
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBStringList, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBStringList, (const lldb::SBStringList &));
+ LLDB_REGISTER_METHOD(const lldb::SBStringList &,
+ SBStringList, operator=,(const lldb::SBStringList &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBStringList, IsValid, ());
+ LLDB_REGISTER_METHOD(void, SBStringList, AppendString, (const char *));
+ LLDB_REGISTER_METHOD(void, SBStringList, AppendList, (const char **, int));
+ LLDB_REGISTER_METHOD(void, SBStringList, AppendList,
+ (const lldb::SBStringList &));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBStringList, GetSize, ());
+ LLDB_REGISTER_METHOD(const char *, SBStringList, GetStringAtIndex,
+ (size_t));
+ LLDB_REGISTER_METHOD_CONST(const char *, SBStringList, GetStringAtIndex,
+ (size_t));
+ LLDB_REGISTER_METHOD(void, SBStringList, Clear, ());
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBStructuredData, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBStructuredData,
+ (const lldb::SBStructuredData &));
+ LLDB_REGISTER_CONSTRUCTOR(SBStructuredData, (const lldb::EventSP &));
+ LLDB_REGISTER_CONSTRUCTOR(SBStructuredData,
+ (lldb_private::StructuredDataImpl *));
+ LLDB_REGISTER_METHOD(
+ lldb::SBStructuredData &,
+ SBStructuredData, operator=,(const lldb::SBStructuredData &));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBStructuredData, SetFromJSON,
+ (lldb::SBStream &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, IsValid, ());
+ LLDB_REGISTER_METHOD(void, SBStructuredData, Clear, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBError, SBStructuredData, GetAsJSON,
+ (lldb::SBStream &));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBError, SBStructuredData, GetDescription,
+ (lldb::SBStream &));
+ LLDB_REGISTER_METHOD_CONST(lldb::StructuredDataType, SBStructuredData,
+ GetType, ());
+ LLDB_REGISTER_METHOD_CONST(size_t, SBStructuredData, GetSize, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, GetKeys,
+ (lldb::SBStringList &));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBStructuredData, SBStructuredData,
+ GetValueForKey, (const char *));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBStructuredData, SBStructuredData,
+ GetItemAtIndex, (size_t));
+ LLDB_REGISTER_METHOD_CONST(uint64_t, SBStructuredData, GetIntegerValue,
+ (uint64_t));
+ LLDB_REGISTER_METHOD_CONST(double, SBStructuredData, GetFloatValue,
+ (double));
+ LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, GetBooleanValue, (bool));
+ LLDB_REGISTER_METHOD_CONST(size_t, SBStructuredData, GetStringValue,
+ (char *, size_t));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBSymbol, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBSymbol, (const lldb::SBSymbol &));
+ LLDB_REGISTER_METHOD(const lldb::SBSymbol &,
+ SBSymbol, operator=,(const lldb::SBSymbol &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBSymbol, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(const char *, SBSymbol, GetName, ());
+ LLDB_REGISTER_METHOD_CONST(const char *, SBSymbol, GetDisplayName, ());
+ LLDB_REGISTER_METHOD_CONST(const char *, SBSymbol, GetMangledName, ());
+ LLDB_REGISTER_METHOD_CONST(bool,
+ SBSymbol, operator==,(const lldb::SBSymbol &));
+ LLDB_REGISTER_METHOD_CONST(bool,
+ SBSymbol, operator!=,(const lldb::SBSymbol &));
+ LLDB_REGISTER_METHOD(bool, SBSymbol, GetDescription, (lldb::SBStream &));
+ LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions,
+ (lldb::SBTarget));
+ LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions,
+ (lldb::SBTarget, const char *));
+ LLDB_REGISTER_METHOD(lldb::SBAddress, SBSymbol, GetStartAddress, ());
+ LLDB_REGISTER_METHOD(lldb::SBAddress, SBSymbol, GetEndAddress, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBSymbol, GetPrologueByteSize, ());
+ LLDB_REGISTER_METHOD(lldb::SymbolType, SBSymbol, GetType, ());
+ LLDB_REGISTER_METHOD(bool, SBSymbol, IsExternal, ());
+ LLDB_REGISTER_METHOD(bool, SBSymbol, IsSynthetic, ());
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext,
+ (const lldb_private::SymbolContext *));
+ LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext, (const lldb::SBSymbolContext &));
+ LLDB_REGISTER_METHOD(
+ const lldb::SBSymbolContext &,
+ SBSymbolContext, operator=,(const lldb::SBSymbolContext &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContext, IsValid, ());
+ LLDB_REGISTER_METHOD(lldb::SBModule, SBSymbolContext, GetModule, ());
+ LLDB_REGISTER_METHOD(lldb::SBCompileUnit, SBSymbolContext, GetCompileUnit,
+ ());
+ LLDB_REGISTER_METHOD(lldb::SBFunction, SBSymbolContext, GetFunction, ());
+ LLDB_REGISTER_METHOD(lldb::SBBlock, SBSymbolContext, GetBlock, ());
+ LLDB_REGISTER_METHOD(lldb::SBLineEntry, SBSymbolContext, GetLineEntry, ());
+ LLDB_REGISTER_METHOD(lldb::SBSymbol, SBSymbolContext, GetSymbol, ());
+ LLDB_REGISTER_METHOD(void, SBSymbolContext, SetModule, (lldb::SBModule));
+ LLDB_REGISTER_METHOD(void, SBSymbolContext, SetCompileUnit,
+ (lldb::SBCompileUnit));
+ LLDB_REGISTER_METHOD(void, SBSymbolContext, SetFunction,
+ (lldb::SBFunction));
+ LLDB_REGISTER_METHOD(void, SBSymbolContext, SetBlock, (lldb::SBBlock));
+ LLDB_REGISTER_METHOD(void, SBSymbolContext, SetLineEntry,
+ (lldb::SBLineEntry));
+ LLDB_REGISTER_METHOD(void, SBSymbolContext, SetSymbol, (lldb::SBSymbol));
+ LLDB_REGISTER_METHOD(bool, SBSymbolContext, GetDescription,
+ (lldb::SBStream &));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBSymbolContext, SBSymbolContext,
+ GetParentOfInlinedScope,
+ (const lldb::SBAddress &, lldb::SBAddress &));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBSymbolContextList, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBSymbolContextList,
+ (const lldb::SBSymbolContextList &));
+ LLDB_REGISTER_METHOD(
+ const lldb::SBSymbolContextList &,
+ SBSymbolContextList, operator=,(const lldb::SBSymbolContextList &));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBSymbolContextList, GetSize, ());
+ LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBSymbolContextList,
+ GetContextAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(void, SBSymbolContextList, Clear, ());
+ LLDB_REGISTER_METHOD(void, SBSymbolContextList, Append,
+ (lldb::SBSymbolContext &));
+ LLDB_REGISTER_METHOD(void, SBSymbolContextList, Append,
+ (lldb::SBSymbolContextList &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContextList, IsValid, ());
+ LLDB_REGISTER_METHOD(bool, SBSymbolContextList, GetDescription,
+ (lldb::SBStream &));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBTarget, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBTarget, (const lldb::SBTarget &));
+ LLDB_REGISTER_CONSTRUCTOR(SBTarget, (const lldb::TargetSP &));
+ LLDB_REGISTER_METHOD(const lldb::SBTarget &,
+ SBTarget, operator=,(const lldb::SBTarget &));
+ LLDB_REGISTER_STATIC_METHOD(bool, SBTarget, EventIsTargetEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBTarget, SBTarget, GetTargetFromEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_STATIC_METHOD(uint32_t, SBTarget, GetNumModulesFromEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBModule, SBTarget,
+ GetModuleAtIndexFromEvent,
+ (const uint32_t, const lldb::SBEvent &));
+ LLDB_REGISTER_STATIC_METHOD(const char *, SBTarget, GetBroadcasterClassName,
+ ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBTarget, IsValid, ());
+ LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, GetProcess, ());
+ LLDB_REGISTER_METHOD(lldb::SBPlatform, SBTarget, GetPlatform, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBDebugger, SBTarget, GetDebugger, ());
+ LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBTarget, GetStatistics, ());
+ LLDB_REGISTER_METHOD(void, SBTarget, SetCollectingStats, (bool));
+ LLDB_REGISTER_METHOD(bool, SBTarget, GetCollectingStats, ());
+ LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LoadCore, (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LoadCore,
+ (const char *, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LaunchSimple,
+ (const char **, const char **, const char *));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, Install, ());
+ LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, Launch,
+ (lldb::SBListener &, const char **, const char **,
+ const char *, const char *, const char *,
+ const char *, uint32_t, bool, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, Launch,
+ (lldb::SBLaunchInfo &, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, Attach,
+ (lldb::SBAttachInfo &, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, AttachToProcessWithID,
+ (lldb::SBListener &, lldb::pid_t, lldb::SBError &));
+ LLDB_REGISTER_METHOD(
+ lldb::SBProcess, SBTarget, AttachToProcessWithName,
+ (lldb::SBListener &, const char *, bool, lldb::SBError &));
+ LLDB_REGISTER_METHOD(
+ lldb::SBProcess, SBTarget, ConnectRemote,
+ (lldb::SBListener &, const char *, const char *, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBTarget, GetExecutable, ());
+ LLDB_REGISTER_METHOD_CONST(bool,
+ SBTarget, operator==,(const lldb::SBTarget &));
+ LLDB_REGISTER_METHOD_CONST(bool,
+ SBTarget, operator!=,(const lldb::SBTarget &));
+ LLDB_REGISTER_METHOD(lldb::SBAddress, SBTarget, ResolveLoadAddress,
+ (lldb::addr_t));
+ LLDB_REGISTER_METHOD(lldb::SBAddress, SBTarget, ResolveFileAddress,
+ (lldb::addr_t));
+ LLDB_REGISTER_METHOD(lldb::SBAddress, SBTarget, ResolvePastLoadAddress,
+ (uint32_t, lldb::addr_t));
+ LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBTarget,
+ ResolveSymbolContextForAddress,
+ (const lldb::SBAddress &, uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
+ BreakpointCreateByLocation, (const char *, uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
+ BreakpointCreateByLocation,
+ (const lldb::SBFileSpec &, uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
+ BreakpointCreateByLocation,
+ (const lldb::SBFileSpec &, uint32_t, lldb::addr_t));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
+ BreakpointCreateByLocation,
+ (const lldb::SBFileSpec &, uint32_t, lldb::addr_t,
+ lldb::SBFileSpecList &));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
+ BreakpointCreateByLocation,
+ (const lldb::SBFileSpec &, uint32_t, uint32_t,
+ lldb::addr_t, lldb::SBFileSpecList &));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
+ (const char *, const char *));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
+ (const char *, const lldb::SBFileSpecList &,
+ const lldb::SBFileSpecList &));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
+ (const char *, uint32_t, const lldb::SBFileSpecList &,
+ const lldb::SBFileSpecList &));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
+ (const char *, uint32_t, lldb::LanguageType,
+ const lldb::SBFileSpecList &,
+ const lldb::SBFileSpecList &));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
+ (const char **, uint32_t, uint32_t,
+ const lldb::SBFileSpecList &,
+ const lldb::SBFileSpecList &));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
+ (const char **, uint32_t, uint32_t, lldb::LanguageType,
+ const lldb::SBFileSpecList &,
+ const lldb::SBFileSpecList &));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
+ (const char **, uint32_t, uint32_t, lldb::LanguageType,
+ lldb::addr_t, const lldb::SBFileSpecList &,
+ const lldb::SBFileSpecList &));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
+ (const char *, const char *));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
+ (const char *, const lldb::SBFileSpecList &,
+ const lldb::SBFileSpecList &));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
+ (const char *, lldb::LanguageType,
+ const lldb::SBFileSpecList &,
+ const lldb::SBFileSpecList &));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
+ BreakpointCreateByAddress, (lldb::addr_t));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
+ BreakpointCreateBySBAddress, (lldb::SBAddress &));
+ LLDB_REGISTER_METHOD(
+ lldb::SBBreakpoint, SBTarget, BreakpointCreateBySourceRegex,
+ (const char *, const lldb::SBFileSpec &, const char *));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
+ BreakpointCreateBySourceRegex,
+ (const char *, const lldb::SBFileSpecList &,
+ const lldb::SBFileSpecList &));
+ LLDB_REGISTER_METHOD(
+ lldb::SBBreakpoint, SBTarget, BreakpointCreateBySourceRegex,
+ (const char *, const lldb::SBFileSpecList &,
+ const lldb::SBFileSpecList &, const lldb::SBStringList &));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
+ BreakpointCreateForException,
+ (lldb::LanguageType, bool, bool));
+ LLDB_REGISTER_METHOD(
+ lldb::SBBreakpoint, SBTarget, BreakpointCreateFromScript,
+ (const char *, lldb::SBStructuredData &, const lldb::SBFileSpecList &,
+ const lldb::SBFileSpecList &, bool));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetNumBreakpoints, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBBreakpoint, SBTarget,
+ GetBreakpointAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(bool, SBTarget, BreakpointDelete, (lldb::break_id_t));
+ LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, FindBreakpointByID,
+ (lldb::break_id_t));
+ LLDB_REGISTER_METHOD(bool, SBTarget, FindBreakpointsByName,
+ (const char *, lldb::SBBreakpointList &));
+ LLDB_REGISTER_METHOD(void, SBTarget, GetBreakpointNames,
+ (lldb::SBStringList &));
+ LLDB_REGISTER_METHOD(void, SBTarget, DeleteBreakpointName, (const char *));
+ LLDB_REGISTER_METHOD(bool, SBTarget, EnableAllBreakpoints, ());
+ LLDB_REGISTER_METHOD(bool, SBTarget, DisableAllBreakpoints, ());
+ LLDB_REGISTER_METHOD(bool, SBTarget, DeleteAllBreakpoints, ());
+ LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, BreakpointsCreateFromFile,
+ (lldb::SBFileSpec &, lldb::SBBreakpointList &));
+ LLDB_REGISTER_METHOD(
+ lldb::SBError, SBTarget, BreakpointsCreateFromFile,
+ (lldb::SBFileSpec &, lldb::SBStringList &, lldb::SBBreakpointList &));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile,
+ (lldb::SBFileSpec &));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile,
+ (lldb::SBFileSpec &, lldb::SBBreakpointList &, bool));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetNumWatchpoints, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBWatchpoint, SBTarget,
+ GetWatchpointAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(bool, SBTarget, DeleteWatchpoint, (lldb::watch_id_t));
+ LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBTarget, FindWatchpointByID,
+ (lldb::watch_id_t));
+ LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBTarget, WatchAddress,
+ (lldb::addr_t, size_t, bool, bool, lldb::SBError &));
+ LLDB_REGISTER_METHOD(bool, SBTarget, EnableAllWatchpoints, ());
+ LLDB_REGISTER_METHOD(bool, SBTarget, DisableAllWatchpoints, ());
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, CreateValueFromAddress,
+ (const char *, lldb::SBAddress, lldb::SBType));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, CreateValueFromData,
+ (const char *, lldb::SBData, lldb::SBType));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, CreateValueFromExpression,
+ (const char *, const char *));
+ LLDB_REGISTER_METHOD(bool, SBTarget, DeleteAllWatchpoints, ());
+ LLDB_REGISTER_METHOD(void, SBTarget, AppendImageSearchPath,
+ (const char *, const char *, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, AddModule,
+ (const char *, const char *, const char *));
+ LLDB_REGISTER_METHOD(
+ lldb::SBModule, SBTarget, AddModule,
+ (const char *, const char *, const char *, const char *));
+ LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, AddModule,
+ (const lldb::SBModuleSpec &));
+ LLDB_REGISTER_METHOD(bool, SBTarget, AddModule, (lldb::SBModule &));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetNumModules, ());
+ LLDB_REGISTER_METHOD(void, SBTarget, Clear, ());
+ LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, FindModule,
+ (const lldb::SBFileSpec &));
+ LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, FindCompileUnits,
+ (const lldb::SBFileSpec &));
+ LLDB_REGISTER_METHOD(lldb::ByteOrder, SBTarget, GetByteOrder, ());
+ LLDB_REGISTER_METHOD(const char *, SBTarget, GetTriple, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetDataByteSize, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetCodeByteSize, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetAddressByteSize, ());
+ LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, GetModuleAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(bool, SBTarget, RemoveModule, (lldb::SBModule));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBBroadcaster, SBTarget, GetBroadcaster,
+ ());
+ LLDB_REGISTER_METHOD(bool, SBTarget, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel));
+ LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, FindFunctions,
+ (const char *, uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget,
+ FindGlobalFunctions,
+ (const char *, uint32_t, lldb::MatchType));
+ LLDB_REGISTER_METHOD(lldb::SBType, SBTarget, FindFirstType, (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBType, SBTarget, GetBasicType,
+ (lldb::BasicType));
+ LLDB_REGISTER_METHOD(lldb::SBTypeList, SBTarget, FindTypes, (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables,
+ (const char *, uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables,
+ (const char *, uint32_t, lldb::MatchType));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, FindFirstGlobalVariable,
+ (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBSourceManager, SBTarget, GetSourceManager, ());
+ LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions,
+ (lldb::SBAddress, uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions,
+ (lldb::SBAddress, uint32_t, const char *));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, SetSectionLoadAddress,
+ (lldb::SBSection, lldb::addr_t));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, ClearSectionLoadAddress,
+ (lldb::SBSection));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, SetModuleLoadAddress,
+ (lldb::SBModule, int64_t));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, ClearModuleLoadAddress,
+ (lldb::SBModule));
+ LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, FindSymbols,
+ (const char *, lldb::SymbolType));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, EvaluateExpression,
+ (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, EvaluateExpression,
+ (const char *, const lldb::SBExpressionOptions &));
+ LLDB_REGISTER_METHOD(lldb::addr_t, SBTarget, GetStackRedZoneSize, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBLaunchInfo, SBTarget, GetLaunchInfo, ());
+ LLDB_REGISTER_METHOD(void, SBTarget, SetLaunchInfo,
+ (const lldb::SBLaunchInfo &));
+ }
+ {
+ LLDB_REGISTER_STATIC_METHOD(const char *, SBThread, GetBroadcasterClassName,
+ ());
+ LLDB_REGISTER_CONSTRUCTOR(SBThread, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBThread, (const lldb::ThreadSP &));
+ LLDB_REGISTER_CONSTRUCTOR(SBThread, (const lldb::SBThread &));
+ LLDB_REGISTER_METHOD(const lldb::SBThread &,
+ SBThread, operator=,(const lldb::SBThread &));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBQueue, SBThread, GetQueue, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBThread, IsValid, ());
+ LLDB_REGISTER_METHOD(void, SBThread, Clear, ());
+ LLDB_REGISTER_METHOD(lldb::StopReason, SBThread, GetStopReason, ());
+ LLDB_REGISTER_METHOD(size_t, SBThread, GetStopReasonDataCount, ());
+ LLDB_REGISTER_METHOD(uint64_t, SBThread, GetStopReasonDataAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(bool, SBThread, GetStopReasonExtendedInfoAsJSON,
+ (lldb::SBStream &));
+ LLDB_REGISTER_METHOD(lldb::SBThreadCollection, SBThread,
+ GetStopReasonExtendedBacktraces,
+ (lldb::InstrumentationRuntimeType));
+ LLDB_REGISTER_METHOD(size_t, SBThread, GetStopDescription,
+ (char *, size_t));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBThread, GetStopReturnValue, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::tid_t, SBThread, GetThreadID, ());
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBThread, GetIndexID, ());
+ LLDB_REGISTER_METHOD_CONST(const char *, SBThread, GetName, ());
+ LLDB_REGISTER_METHOD_CONST(const char *, SBThread, GetQueueName, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::queue_id_t, SBThread, GetQueueID, ());
+ LLDB_REGISTER_METHOD(bool, SBThread, GetInfoItemByPathAsString,
+ (const char *, lldb::SBStream &));
+ LLDB_REGISTER_METHOD(void, SBThread, StepOver, (lldb::RunMode));
+ LLDB_REGISTER_METHOD(void, SBThread, StepOver,
+ (lldb::RunMode, lldb::SBError &));
+ LLDB_REGISTER_METHOD(void, SBThread, StepInto, (lldb::RunMode));
+ LLDB_REGISTER_METHOD(void, SBThread, StepInto,
+ (const char *, lldb::RunMode));
+ LLDB_REGISTER_METHOD(
+ void, SBThread, StepInto,
+ (const char *, uint32_t, lldb::SBError &, lldb::RunMode));
+ LLDB_REGISTER_METHOD(void, SBThread, StepOut, ());
+ LLDB_REGISTER_METHOD(void, SBThread, StepOut, (lldb::SBError &));
+ LLDB_REGISTER_METHOD(void, SBThread, StepOutOfFrame, (lldb::SBFrame &));
+ LLDB_REGISTER_METHOD(void, SBThread, StepOutOfFrame,
+ (lldb::SBFrame &, lldb::SBError &));
+ LLDB_REGISTER_METHOD(void, SBThread, StepInstruction, (bool));
+ LLDB_REGISTER_METHOD(void, SBThread, StepInstruction,
+ (bool, lldb::SBError &));
+ LLDB_REGISTER_METHOD(void, SBThread, RunToAddress, (lldb::addr_t));
+ LLDB_REGISTER_METHOD(void, SBThread, RunToAddress,
+ (lldb::addr_t, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBThread, StepOverUntil,
+ (lldb::SBFrame &, lldb::SBFileSpec &, uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
+ (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
+ (const char *, bool));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBThread, JumpToLine,
+ (lldb::SBFileSpec &, uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBThread, ReturnFromFrame,
+ (lldb::SBFrame &, lldb::SBValue &));
+ LLDB_REGISTER_METHOD(lldb::SBError, SBThread, UnwindInnermostExpression,
+ ());
+ LLDB_REGISTER_METHOD(bool, SBThread, Suspend, ());
+ LLDB_REGISTER_METHOD(bool, SBThread, Suspend, (lldb::SBError &));
+ LLDB_REGISTER_METHOD(bool, SBThread, Resume, ());
+ LLDB_REGISTER_METHOD(bool, SBThread, Resume, (lldb::SBError &));
+ LLDB_REGISTER_METHOD(bool, SBThread, IsSuspended, ());
+ LLDB_REGISTER_METHOD(bool, SBThread, IsStopped, ());
+ LLDB_REGISTER_METHOD(lldb::SBProcess, SBThread, GetProcess, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBThread, GetNumFrames, ());
+ LLDB_REGISTER_METHOD(lldb::SBFrame, SBThread, GetFrameAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBFrame, SBThread, GetSelectedFrame, ());
+ LLDB_REGISTER_METHOD(lldb::SBFrame, SBThread, SetSelectedFrame, (uint32_t));
+ LLDB_REGISTER_STATIC_METHOD(bool, SBThread, EventIsThreadEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBFrame, SBThread, GetStackFrameFromEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBThread, SBThread, GetThreadFromEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_METHOD_CONST(bool,
+ SBThread, operator==,(const lldb::SBThread &));
+ LLDB_REGISTER_METHOD_CONST(bool,
+ SBThread, operator!=,(const lldb::SBThread &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBThread, GetStatus, (lldb::SBStream &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBThread, GetDescription,
+ (lldb::SBStream &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBThread, GetDescription,
+ (lldb::SBStream &, bool));
+ LLDB_REGISTER_METHOD(lldb::SBThread, SBThread, GetExtendedBacktraceThread,
+ (const char *));
+ LLDB_REGISTER_METHOD(uint32_t, SBThread,
+ GetExtendedBacktraceOriginatingIndexID, ());
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBThread, GetCurrentException, ());
+ LLDB_REGISTER_METHOD(lldb::SBThread, SBThread, GetCurrentExceptionBacktrace,
+ ());
+ LLDB_REGISTER_METHOD(bool, SBThread, SafeToCallFunctions, ());
+ LLDB_REGISTER_METHOD(lldb_private::Thread *, SBThread, operator->,());
+ LLDB_REGISTER_METHOD(lldb_private::Thread *, SBThread, get, ());
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBThreadCollection, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBThreadCollection,
+ (const lldb::SBThreadCollection &));
+ LLDB_REGISTER_METHOD(
+ const lldb::SBThreadCollection &,
+ SBThreadCollection, operator=,(const lldb::SBThreadCollection &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBThreadCollection, IsValid, ());
+ LLDB_REGISTER_METHOD(size_t, SBThreadCollection, GetSize, ());
+ LLDB_REGISTER_METHOD(lldb::SBThread, SBThreadCollection, GetThreadAtIndex,
+ (size_t));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (const lldb::ThreadPlanSP &));
+ LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (const lldb::SBThreadPlan &));
+ LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (lldb::SBThread &, const char *));
+ LLDB_REGISTER_METHOD(const lldb::SBThreadPlan &,
+ SBThreadPlan, operator=,(const lldb::SBThreadPlan &));
+ LLDB_REGISTER_METHOD(lldb_private::ThreadPlan *, SBThreadPlan, get, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBThreadPlan, IsValid, ());
+ LLDB_REGISTER_METHOD(void, SBThreadPlan, Clear, ());
+ LLDB_REGISTER_METHOD(lldb::StopReason, SBThreadPlan, GetStopReason, ());
+ LLDB_REGISTER_METHOD(size_t, SBThreadPlan, GetStopReasonDataCount, ());
+ LLDB_REGISTER_METHOD(uint64_t, SBThreadPlan, GetStopReasonDataAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBThreadPlan, GetThread, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBThreadPlan, GetDescription,
+ (lldb::SBStream &));
+ LLDB_REGISTER_METHOD(void, SBThreadPlan, SetPlanComplete, (bool));
+ LLDB_REGISTER_METHOD(bool, SBThreadPlan, IsPlanComplete, ());
+ LLDB_REGISTER_METHOD(bool, SBThreadPlan, IsPlanStale, ());
+ LLDB_REGISTER_METHOD(bool, SBThreadPlan, IsValid, ());
+ LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
+ QueueThreadPlanForStepOverRange,
+ (lldb::SBAddress &, lldb::addr_t));
+ LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
+ QueueThreadPlanForStepOverRange,
+ (lldb::SBAddress &, lldb::addr_t, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
+ QueueThreadPlanForStepInRange,
+ (lldb::SBAddress &, lldb::addr_t));
+ LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
+ QueueThreadPlanForStepInRange,
+ (lldb::SBAddress &, lldb::addr_t, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
+ QueueThreadPlanForStepOut, (uint32_t, bool));
+ LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
+ QueueThreadPlanForStepOut,
+ (uint32_t, bool, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
+ QueueThreadPlanForRunToAddress, (lldb::SBAddress));
+ LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
+ QueueThreadPlanForRunToAddress,
+ (lldb::SBAddress, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
+ QueueThreadPlanForStepScripted, (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
+ QueueThreadPlanForStepScripted,
+ (const char *, lldb::SBError &));
+ }
+ {
+ LLDB_REGISTER_METHOD(void, SBTrace, StopTrace,
+ (lldb::SBError &, lldb::tid_t));
+ LLDB_REGISTER_METHOD(void, SBTrace, GetTraceConfig,
+ (lldb::SBTraceOptions &, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::user_id_t, SBTrace, GetTraceUID, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBTrace, ());
+ LLDB_REGISTER_METHOD(bool, SBTrace, IsValid, ());
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBTraceOptions, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::TraceType, SBTraceOptions, getType, ());
+ LLDB_REGISTER_METHOD_CONST(uint64_t, SBTraceOptions, getTraceBufferSize,
+ ());
+ LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBTraceOptions, getTraceParams,
+ (lldb::SBError &));
+ LLDB_REGISTER_METHOD_CONST(uint64_t, SBTraceOptions, getMetaDataBufferSize,
+ ());
+ LLDB_REGISTER_METHOD(void, SBTraceOptions, setTraceParams,
+ (lldb::SBStructuredData &));
+ LLDB_REGISTER_METHOD(void, SBTraceOptions, setType, (lldb::TraceType));
+ LLDB_REGISTER_METHOD(void, SBTraceOptions, setTraceBufferSize, (uint64_t));
+ LLDB_REGISTER_METHOD(void, SBTraceOptions, setMetaDataBufferSize,
+ (uint64_t));
+ LLDB_REGISTER_METHOD(bool, SBTraceOptions, IsValid, ());
+ LLDB_REGISTER_METHOD(void, SBTraceOptions, setThreadID, (lldb::tid_t));
+ LLDB_REGISTER_METHOD(lldb::tid_t, SBTraceOptions, getThreadID, ());
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBType, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBType, (const lldb::SBType &));
+ LLDB_REGISTER_METHOD(bool, SBType, operator==,(lldb::SBType &));
+ LLDB_REGISTER_METHOD(bool, SBType, operator!=,(lldb::SBType &));
+ LLDB_REGISTER_METHOD(lldb::SBType &,
+ SBType, operator=,(const lldb::SBType &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBType, IsValid, ());
+ LLDB_REGISTER_METHOD(uint64_t, SBType, GetByteSize, ());
+ LLDB_REGISTER_METHOD(bool, SBType, IsPointerType, ());
+ LLDB_REGISTER_METHOD(bool, SBType, IsArrayType, ());
+ LLDB_REGISTER_METHOD(bool, SBType, IsVectorType, ());
+ LLDB_REGISTER_METHOD(bool, SBType, IsReferenceType, ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetPointerType, ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetPointeeType, ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetReferenceType, ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetTypedefedType, ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetDereferencedType, ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetArrayElementType, ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetArrayType, (uint64_t));
+ LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetVectorElementType, ());
+ LLDB_REGISTER_METHOD(bool, SBType, IsFunctionType, ());
+ LLDB_REGISTER_METHOD(bool, SBType, IsPolymorphicClass, ());
+ LLDB_REGISTER_METHOD(bool, SBType, IsTypedefType, ());
+ LLDB_REGISTER_METHOD(bool, SBType, IsAnonymousType, ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetFunctionReturnType, ());
+ LLDB_REGISTER_METHOD(lldb::SBTypeList, SBType, GetFunctionArgumentTypes,
+ ());
+ LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfMemberFunctions, ());
+ LLDB_REGISTER_METHOD(lldb::SBTypeMemberFunction, SBType,
+ GetMemberFunctionAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetUnqualifiedType, ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetCanonicalType, ());
+ LLDB_REGISTER_METHOD(lldb::BasicType, SBType, GetBasicType, ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetBasicType, (lldb::BasicType));
+ LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfDirectBaseClasses, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfVirtualBaseClasses, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfFields, ());
+ LLDB_REGISTER_METHOD(bool, SBType, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel));
+ LLDB_REGISTER_METHOD(lldb::SBTypeMember, SBType, GetDirectBaseClassAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBTypeMember, SBType, GetVirtualBaseClassAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBTypeEnumMemberList, SBType, GetEnumMembers,
+ ());
+ LLDB_REGISTER_METHOD(lldb::SBTypeMember, SBType, GetFieldAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(bool, SBType, IsTypeComplete, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBType, GetTypeFlags, ());
+ LLDB_REGISTER_METHOD(const char *, SBType, GetName, ());
+ LLDB_REGISTER_METHOD(const char *, SBType, GetDisplayTypeName, ());
+ LLDB_REGISTER_METHOD(lldb::TypeClass, SBType, GetTypeClass, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfTemplateArguments, ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetTemplateArgumentType,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::TemplateArgumentKind, SBType,
+ GetTemplateArgumentKind, (uint32_t));
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeList, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeList, (const lldb::SBTypeList &));
+ LLDB_REGISTER_METHOD(bool, SBTypeList, IsValid, ());
+ LLDB_REGISTER_METHOD(lldb::SBTypeList &,
+ SBTypeList, operator=,(const lldb::SBTypeList &));
+ LLDB_REGISTER_METHOD(void, SBTypeList, Append, (lldb::SBType));
+ LLDB_REGISTER_METHOD(lldb::SBType, SBTypeList, GetTypeAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBTypeList, GetSize, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeMember, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeMember, (const lldb::SBTypeMember &));
+ LLDB_REGISTER_METHOD(lldb::SBTypeMember &,
+ SBTypeMember, operator=,(const lldb::SBTypeMember &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBTypeMember, IsValid, ());
+ LLDB_REGISTER_METHOD(const char *, SBTypeMember, GetName, ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMember, GetType, ());
+ LLDB_REGISTER_METHOD(uint64_t, SBTypeMember, GetOffsetInBytes, ());
+ LLDB_REGISTER_METHOD(uint64_t, SBTypeMember, GetOffsetInBits, ());
+ LLDB_REGISTER_METHOD(bool, SBTypeMember, IsBitfield, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBTypeMember, GetBitfieldSizeInBits, ());
+ LLDB_REGISTER_METHOD(bool, SBTypeMember, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel));
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeMemberFunction, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeMemberFunction,
+ (const lldb::SBTypeMemberFunction &));
+ LLDB_REGISTER_METHOD(
+ lldb::SBTypeMemberFunction &,
+ SBTypeMemberFunction, operator=,(const lldb::SBTypeMemberFunction &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBTypeMemberFunction, IsValid, ());
+ LLDB_REGISTER_METHOD(const char *, SBTypeMemberFunction, GetName, ());
+ LLDB_REGISTER_METHOD(const char *, SBTypeMemberFunction, GetDemangledName,
+ ());
+ LLDB_REGISTER_METHOD(const char *, SBTypeMemberFunction, GetMangledName,
+ ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMemberFunction, GetType, ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMemberFunction, GetReturnType, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBTypeMemberFunction, GetNumberOfArguments,
+ ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMemberFunction,
+ GetArgumentTypeAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::MemberFunctionKind, SBTypeMemberFunction,
+ GetKind, ());
+ LLDB_REGISTER_METHOD(bool, SBTypeMemberFunction, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeCategory, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeCategory, (const lldb::SBTypeCategory &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBTypeCategory, IsValid, ());
+ LLDB_REGISTER_METHOD(bool, SBTypeCategory, GetEnabled, ());
+ LLDB_REGISTER_METHOD(void, SBTypeCategory, SetEnabled, (bool));
+ LLDB_REGISTER_METHOD(const char *, SBTypeCategory, GetName, ());
+ LLDB_REGISTER_METHOD(lldb::LanguageType, SBTypeCategory, GetLanguageAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumLanguages, ());
+ LLDB_REGISTER_METHOD(void, SBTypeCategory, AddLanguage,
+ (lldb::LanguageType));
+ LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumFormats, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumSummaries, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumFilters, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumSynthetics, ());
+ LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
+ GetTypeNameSpecifierForFilterAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
+ GetTypeNameSpecifierForFormatAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
+ GetTypeNameSpecifierForSummaryAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
+ GetTypeNameSpecifierForSyntheticAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterForType,
+ (lldb::SBTypeNameSpecifier));
+ LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatForType,
+ (lldb::SBTypeNameSpecifier));
+ LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryForType,
+ (lldb::SBTypeNameSpecifier));
+ LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBTypeCategory,
+ GetSyntheticForType, (lldb::SBTypeNameSpecifier));
+ LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBTypeCategory,
+ GetSyntheticAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeFormat,
+ (lldb::SBTypeNameSpecifier, lldb::SBTypeFormat));
+ LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeFormat,
+ (lldb::SBTypeNameSpecifier));
+ LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeSummary,
+ (lldb::SBTypeNameSpecifier, lldb::SBTypeSummary));
+ LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeSummary,
+ (lldb::SBTypeNameSpecifier));
+ LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeFilter,
+ (lldb::SBTypeNameSpecifier, lldb::SBTypeFilter));
+ LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeFilter,
+ (lldb::SBTypeNameSpecifier));
+ LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeSynthetic,
+ (lldb::SBTypeNameSpecifier, lldb::SBTypeSynthetic));
+ LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeSynthetic,
+ (lldb::SBTypeNameSpecifier));
+ LLDB_REGISTER_METHOD(bool, SBTypeCategory, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel));
+ LLDB_REGISTER_METHOD(
+ lldb::SBTypeCategory &,
+ SBTypeCategory, operator=,(const lldb::SBTypeCategory &));
+ LLDB_REGISTER_METHOD(bool,
+ SBTypeCategory, operator==,(lldb::SBTypeCategory &));
+ LLDB_REGISTER_METHOD(bool,
+ SBTypeCategory, operator!=,(lldb::SBTypeCategory &));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMember, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMember,
+ (const lldb::SBTypeEnumMember &));
+ LLDB_REGISTER_METHOD(
+ lldb::SBTypeEnumMember &,
+ SBTypeEnumMember, operator=,(const lldb::SBTypeEnumMember &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBTypeEnumMember, IsValid, ());
+ LLDB_REGISTER_METHOD(const char *, SBTypeEnumMember, GetName, ());
+ LLDB_REGISTER_METHOD(int64_t, SBTypeEnumMember, GetValueAsSigned, ());
+ LLDB_REGISTER_METHOD(uint64_t, SBTypeEnumMember, GetValueAsUnsigned, ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBTypeEnumMember, GetType, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMemberList, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMemberList,
+ (const lldb::SBTypeEnumMemberList &));
+ LLDB_REGISTER_METHOD(bool, SBTypeEnumMemberList, IsValid, ());
+ LLDB_REGISTER_METHOD(
+ lldb::SBTypeEnumMemberList &,
+ SBTypeEnumMemberList, operator=,(const lldb::SBTypeEnumMemberList &));
+ LLDB_REGISTER_METHOD(void, SBTypeEnumMemberList, Append,
+ (lldb::SBTypeEnumMember));
+ LLDB_REGISTER_METHOD(lldb::SBTypeEnumMember, SBTypeEnumMemberList,
+ GetTypeEnumMemberAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBTypeEnumMemberList, GetSize, ());
+ LLDB_REGISTER_METHOD(bool, SBTypeEnumMember, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeFilter, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeFilter, (uint32_t));
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeFilter, (const lldb::SBTypeFilter &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBTypeFilter, IsValid, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBTypeFilter, GetOptions, ());
+ LLDB_REGISTER_METHOD(void, SBTypeFilter, SetOptions, (uint32_t));
+ LLDB_REGISTER_METHOD(bool, SBTypeFilter, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel));
+ LLDB_REGISTER_METHOD(void, SBTypeFilter, Clear, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBTypeFilter, GetNumberOfExpressionPaths,
+ ());
+ LLDB_REGISTER_METHOD(const char *, SBTypeFilter, GetExpressionPathAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD(bool, SBTypeFilter, ReplaceExpressionPathAtIndex,
+ (uint32_t, const char *));
+ LLDB_REGISTER_METHOD(void, SBTypeFilter, AppendExpressionPath,
+ (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBTypeFilter &,
+ SBTypeFilter, operator=,(const lldb::SBTypeFilter &));
+ LLDB_REGISTER_METHOD(bool, SBTypeFilter, operator==,(lldb::SBTypeFilter &));
+ LLDB_REGISTER_METHOD(bool, SBTypeFilter, IsEqualTo, (lldb::SBTypeFilter &));
+ LLDB_REGISTER_METHOD(bool, SBTypeFilter, operator!=,(lldb::SBTypeFilter &));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeFormat, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeFormat, (lldb::Format, uint32_t));
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeFormat, (const char *, uint32_t));
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeFormat, (const lldb::SBTypeFormat &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBTypeFormat, IsValid, ());
+ LLDB_REGISTER_METHOD(lldb::Format, SBTypeFormat, GetFormat, ());
+ LLDB_REGISTER_METHOD(const char *, SBTypeFormat, GetTypeName, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBTypeFormat, GetOptions, ());
+ LLDB_REGISTER_METHOD(void, SBTypeFormat, SetFormat, (lldb::Format));
+ LLDB_REGISTER_METHOD(void, SBTypeFormat, SetTypeName, (const char *));
+ LLDB_REGISTER_METHOD(void, SBTypeFormat, SetOptions, (uint32_t));
+ LLDB_REGISTER_METHOD(bool, SBTypeFormat, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel));
+ LLDB_REGISTER_METHOD(lldb::SBTypeFormat &,
+ SBTypeFormat, operator=,(const lldb::SBTypeFormat &));
+ LLDB_REGISTER_METHOD(bool, SBTypeFormat, operator==,(lldb::SBTypeFormat &));
+ LLDB_REGISTER_METHOD(bool, SBTypeFormat, IsEqualTo, (lldb::SBTypeFormat &));
+ LLDB_REGISTER_METHOD(bool, SBTypeFormat, operator!=,(lldb::SBTypeFormat &));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier, (const char *, bool));
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier, (lldb::SBType));
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier,
+ (const lldb::SBTypeNameSpecifier &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBTypeNameSpecifier, IsValid, ());
+ LLDB_REGISTER_METHOD(const char *, SBTypeNameSpecifier, GetName, ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBTypeNameSpecifier, GetType, ());
+ LLDB_REGISTER_METHOD(bool, SBTypeNameSpecifier, IsRegex, ());
+ LLDB_REGISTER_METHOD(bool, SBTypeNameSpecifier, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel));
+ LLDB_REGISTER_METHOD(
+ lldb::SBTypeNameSpecifier &,
+ SBTypeNameSpecifier, operator=,(const lldb::SBTypeNameSpecifier &));
+ LLDB_REGISTER_METHOD(
+ bool, SBTypeNameSpecifier, operator==,(lldb::SBTypeNameSpecifier &));
+ LLDB_REGISTER_METHOD(bool, SBTypeNameSpecifier, IsEqualTo,
+ (lldb::SBTypeNameSpecifier &));
+ LLDB_REGISTER_METHOD(
+ bool, SBTypeNameSpecifier, operator!=,(lldb::SBTypeNameSpecifier &));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeSummaryOptions, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeSummaryOptions,
+ (const lldb::SBTypeSummaryOptions &));
+ LLDB_REGISTER_METHOD(bool, SBTypeSummaryOptions, IsValid, ());
+ LLDB_REGISTER_METHOD(lldb::LanguageType, SBTypeSummaryOptions, GetLanguage,
+ ());
+ LLDB_REGISTER_METHOD(lldb::TypeSummaryCapping, SBTypeSummaryOptions,
+ GetCapping, ());
+ LLDB_REGISTER_METHOD(void, SBTypeSummaryOptions, SetLanguage,
+ (lldb::LanguageType));
+ LLDB_REGISTER_METHOD(void, SBTypeSummaryOptions, SetCapping,
+ (lldb::TypeSummaryCapping));
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeSummaryOptions,
+ (const lldb_private::TypeSummaryOptions *));
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeSummary, ());
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
+ CreateWithSummaryString,
+ (const char *, uint32_t));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
+ CreateWithFunctionName,
+ (const char *, uint32_t));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
+ CreateWithScriptCode, (const char *, uint32_t));
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeSummary, (const lldb::SBTypeSummary &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBTypeSummary, IsValid, ());
+ LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsFunctionCode, ());
+ LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsFunctionName, ());
+ LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsSummaryString, ());
+ LLDB_REGISTER_METHOD(const char *, SBTypeSummary, GetData, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBTypeSummary, GetOptions, ());
+ LLDB_REGISTER_METHOD(void, SBTypeSummary, SetOptions, (uint32_t));
+ LLDB_REGISTER_METHOD(void, SBTypeSummary, SetSummaryString, (const char *));
+ LLDB_REGISTER_METHOD(void, SBTypeSummary, SetFunctionName, (const char *));
+ LLDB_REGISTER_METHOD(void, SBTypeSummary, SetFunctionCode, (const char *));
+ LLDB_REGISTER_METHOD(bool, SBTypeSummary, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel));
+ LLDB_REGISTER_METHOD(bool, SBTypeSummary, DoesPrintValue, (lldb::SBValue));
+ LLDB_REGISTER_METHOD(
+ lldb::SBTypeSummary &,
+ SBTypeSummary, operator=,(const lldb::SBTypeSummary &));
+ LLDB_REGISTER_METHOD(bool,
+ SBTypeSummary, operator==,(lldb::SBTypeSummary &));
+ LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsEqualTo,
+ (lldb::SBTypeSummary &));
+ LLDB_REGISTER_METHOD(bool,
+ SBTypeSummary, operator!=,(lldb::SBTypeSummary &));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeSynthetic, ());
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSynthetic, SBTypeSynthetic,
+ CreateWithClassName, (const char *, uint32_t));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSynthetic, SBTypeSynthetic,
+ CreateWithScriptCode, (const char *, uint32_t));
+ LLDB_REGISTER_CONSTRUCTOR(SBTypeSynthetic, (const lldb::SBTypeSynthetic &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBTypeSynthetic, IsValid, ());
+ LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, IsClassCode, ());
+ LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, IsClassName, ());
+ LLDB_REGISTER_METHOD(const char *, SBTypeSynthetic, GetData, ());
+ LLDB_REGISTER_METHOD(void, SBTypeSynthetic, SetClassName, (const char *));
+ LLDB_REGISTER_METHOD(void, SBTypeSynthetic, SetClassCode, (const char *));
+ LLDB_REGISTER_METHOD(uint32_t, SBTypeSynthetic, GetOptions, ());
+ LLDB_REGISTER_METHOD(void, SBTypeSynthetic, SetOptions, (uint32_t));
+ LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel));
+ LLDB_REGISTER_METHOD(
+ lldb::SBTypeSynthetic &,
+ SBTypeSynthetic, operator=,(const lldb::SBTypeSynthetic &));
+ LLDB_REGISTER_METHOD(bool,
+ SBTypeSynthetic, operator==,(lldb::SBTypeSynthetic &));
+ LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, IsEqualTo,
+ (lldb::SBTypeSynthetic &));
+ LLDB_REGISTER_METHOD(bool,
+ SBTypeSynthetic, operator!=,(lldb::SBTypeSynthetic &));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBUnixSignals, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBUnixSignals, (const lldb::SBUnixSignals &));
+ LLDB_REGISTER_METHOD(
+ const lldb::SBUnixSignals &,
+ SBUnixSignals, operator=,(const lldb::SBUnixSignals &));
+ LLDB_REGISTER_METHOD(void, SBUnixSignals, Clear, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(const char *, SBUnixSignals, GetSignalAsCString,
+ (int32_t));
+ LLDB_REGISTER_METHOD_CONST(int32_t, SBUnixSignals, GetSignalNumberFromName,
+ (const char *));
+ LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, GetShouldSuppress,
+ (int32_t));
+ LLDB_REGISTER_METHOD(bool, SBUnixSignals, SetShouldSuppress,
+ (int32_t, bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, GetShouldStop, (int32_t));
+ LLDB_REGISTER_METHOD(bool, SBUnixSignals, SetShouldStop, (int32_t, bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, GetShouldNotify, (int32_t));
+ LLDB_REGISTER_METHOD(bool, SBUnixSignals, SetShouldNotify, (int32_t, bool));
+ LLDB_REGISTER_METHOD_CONST(int32_t, SBUnixSignals, GetNumSignals, ());
+ LLDB_REGISTER_METHOD_CONST(int32_t, SBUnixSignals, GetSignalAtIndex,
+ (int32_t));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBValue, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBValue, (const lldb::ValueObjectSP &));
+ LLDB_REGISTER_CONSTRUCTOR(SBValue, (const lldb::SBValue &));
+ LLDB_REGISTER_METHOD(lldb::SBValue &,
+ SBValue, operator=,(const lldb::SBValue &));
+ LLDB_REGISTER_METHOD(bool, SBValue, IsValid, ());
+ LLDB_REGISTER_METHOD(void, SBValue, Clear, ());
+ LLDB_REGISTER_METHOD(lldb::SBError, SBValue, GetError, ());
+ LLDB_REGISTER_METHOD(lldb::user_id_t, SBValue, GetID, ());
+ LLDB_REGISTER_METHOD(const char *, SBValue, GetName, ());
+ LLDB_REGISTER_METHOD(const char *, SBValue, GetTypeName, ());
+ LLDB_REGISTER_METHOD(const char *, SBValue, GetDisplayTypeName, ());
+ LLDB_REGISTER_METHOD(size_t, SBValue, GetByteSize, ());
+ LLDB_REGISTER_METHOD(bool, SBValue, IsInScope, ());
+ LLDB_REGISTER_METHOD(const char *, SBValue, GetValue, ());
+ LLDB_REGISTER_METHOD(lldb::ValueType, SBValue, GetValueType, ());
+ LLDB_REGISTER_METHOD(const char *, SBValue, GetObjectDescription, ());
+ LLDB_REGISTER_METHOD(const char *, SBValue, GetTypeValidatorResult, ());
+ LLDB_REGISTER_METHOD(lldb::SBType, SBValue, GetType, ());
+ LLDB_REGISTER_METHOD(bool, SBValue, GetValueDidChange, ());
+ LLDB_REGISTER_METHOD(const char *, SBValue, GetSummary, ());
+ LLDB_REGISTER_METHOD(const char *, SBValue, GetSummary,
+ (lldb::SBStream &, lldb::SBTypeSummaryOptions &));
+ LLDB_REGISTER_METHOD(const char *, SBValue, GetLocation, ());
+ LLDB_REGISTER_METHOD(bool, SBValue, SetValueFromCString, (const char *));
+ LLDB_REGISTER_METHOD(bool, SBValue, SetValueFromCString,
+ (const char *, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBValue, GetTypeFormat, ());
+ LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBValue, GetTypeSummary, ());
+ LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBValue, GetTypeFilter, ());
+ LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBValue, GetTypeSynthetic, ());
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, CreateChildAtOffset,
+ (const char *, uint32_t, lldb::SBType));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, Cast, (lldb::SBType));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, CreateValueFromExpression,
+ (const char *, const char *));
+ LLDB_REGISTER_METHOD(
+ lldb::SBValue, SBValue, CreateValueFromExpression,
+ (const char *, const char *, lldb::SBExpressionOptions &));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, CreateValueFromAddress,
+ (const char *, lldb::addr_t, lldb::SBType));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, CreateValueFromData,
+ (const char *, lldb::SBData, lldb::SBType));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetChildAtIndex, (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetChildAtIndex,
+ (uint32_t, lldb::DynamicValueType, bool));
+ LLDB_REGISTER_METHOD(uint32_t, SBValue, GetIndexOfChildWithName,
+ (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName,
+ (const char *));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName,
+ (const char *, lldb::DynamicValueType));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetDynamicValue,
+ (lldb::DynamicValueType));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetStaticValue, ());
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetNonSyntheticValue, ());
+ LLDB_REGISTER_METHOD(lldb::DynamicValueType, SBValue, GetPreferDynamicValue,
+ ());
+ LLDB_REGISTER_METHOD(void, SBValue, SetPreferDynamicValue,
+ (lldb::DynamicValueType));
+ LLDB_REGISTER_METHOD(bool, SBValue, GetPreferSyntheticValue, ());
+ LLDB_REGISTER_METHOD(void, SBValue, SetPreferSyntheticValue, (bool));
+ LLDB_REGISTER_METHOD(bool, SBValue, IsDynamic, ());
+ LLDB_REGISTER_METHOD(bool, SBValue, IsSynthetic, ());
+ LLDB_REGISTER_METHOD(bool, SBValue, IsSyntheticChildrenGenerated, ());
+ LLDB_REGISTER_METHOD(void, SBValue, SetSyntheticChildrenGenerated, (bool));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetValueForExpressionPath,
+ (const char *));
+ LLDB_REGISTER_METHOD(int64_t, SBValue, GetValueAsSigned,
+ (lldb::SBError &, int64_t));
+ LLDB_REGISTER_METHOD(uint64_t, SBValue, GetValueAsUnsigned,
+ (lldb::SBError &, uint64_t));
+ LLDB_REGISTER_METHOD(int64_t, SBValue, GetValueAsSigned, (int64_t));
+ LLDB_REGISTER_METHOD(uint64_t, SBValue, GetValueAsUnsigned, (uint64_t));
+ LLDB_REGISTER_METHOD(bool, SBValue, MightHaveChildren, ());
+ LLDB_REGISTER_METHOD(bool, SBValue, IsRuntimeSupportValue, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBValue, GetNumChildren, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBValue, GetNumChildren, (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, Dereference, ());
+ LLDB_REGISTER_METHOD(bool, SBValue, TypeIsPointerType, ());
+ LLDB_REGISTER_METHOD(void *, SBValue, GetOpaqueType, ());
+ LLDB_REGISTER_METHOD(lldb::SBTarget, SBValue, GetTarget, ());
+ LLDB_REGISTER_METHOD(lldb::SBProcess, SBValue, GetProcess, ());
+ LLDB_REGISTER_METHOD(lldb::SBThread, SBValue, GetThread, ());
+ LLDB_REGISTER_METHOD(lldb::SBFrame, SBValue, GetFrame, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::ValueObjectSP, SBValue, GetSP, ());
+ LLDB_REGISTER_METHOD(bool, SBValue, GetExpressionPath, (lldb::SBStream &));
+ LLDB_REGISTER_METHOD(bool, SBValue, GetExpressionPath,
+ (lldb::SBStream &, bool));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBValue, SBValue, EvaluateExpression,
+ (const char *));
+ LLDB_REGISTER_METHOD_CONST(
+ lldb::SBValue, SBValue, EvaluateExpression,
+ (const char *, const lldb::SBExpressionOptions &));
+ LLDB_REGISTER_METHOD_CONST(
+ lldb::SBValue, SBValue, EvaluateExpression,
+ (const char *, const lldb::SBExpressionOptions &, const char *));
+ LLDB_REGISTER_METHOD(bool, SBValue, GetDescription, (lldb::SBStream &));
+ LLDB_REGISTER_METHOD(lldb::Format, SBValue, GetFormat, ());
+ LLDB_REGISTER_METHOD(void, SBValue, SetFormat, (lldb::Format));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, AddressOf, ());
+ LLDB_REGISTER_METHOD(lldb::addr_t, SBValue, GetLoadAddress, ());
+ LLDB_REGISTER_METHOD(lldb::SBAddress, SBValue, GetAddress, ());
+ LLDB_REGISTER_METHOD(lldb::SBData, SBValue, GetPointeeData,
+ (uint32_t, uint32_t));
+ LLDB_REGISTER_METHOD(lldb::SBData, SBValue, GetData, ());
+ LLDB_REGISTER_METHOD(bool, SBValue, SetData,
+ (lldb::SBData &, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::SBDeclaration, SBValue, GetDeclaration, ());
+ LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBValue, Watch,
+ (bool, bool, bool, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBValue, Watch,
+ (bool, bool, bool));
+ LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBValue, WatchPointee,
+ (bool, bool, bool, lldb::SBError &));
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, Persist, ());
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBValueList, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBValueList, (const lldb::SBValueList &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBValueList, IsValid, ());
+ LLDB_REGISTER_METHOD(void, SBValueList, Clear, ());
+ LLDB_REGISTER_METHOD(const lldb::SBValueList &,
+ SBValueList, operator=,(const lldb::SBValueList &));
+ LLDB_REGISTER_METHOD(void, SBValueList, Append, (const lldb::SBValue &));
+ LLDB_REGISTER_METHOD(void, SBValueList, Append,
+ (const lldb::SBValueList &));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBValue, SBValueList, GetValueAtIndex,
+ (uint32_t));
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBValueList, GetSize, ());
+ LLDB_REGISTER_METHOD(lldb::SBValue, SBValueList, FindValueObjectByUID,
+ (lldb::user_id_t));
+ LLDB_REGISTER_METHOD_CONST(lldb::SBValue, SBValueList, GetFirstValueByName,
+ (const char *));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBVariablesOptions, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBVariablesOptions,
+ (const lldb::SBVariablesOptions &));
+ LLDB_REGISTER_METHOD(
+ lldb::SBVariablesOptions &,
+ SBVariablesOptions, operator=,(const lldb::SBVariablesOptions &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetIncludeArguments,
+ ());
+ LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetIncludeArguments, (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions,
+ GetIncludeRecognizedArguments,
+ (const lldb::SBTarget &));
+ LLDB_REGISTER_METHOD(void, SBVariablesOptions,
+ SetIncludeRecognizedArguments, (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetIncludeLocals, ());
+ LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetIncludeLocals, (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetIncludeStatics, ());
+ LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetIncludeStatics, (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetInScopeOnly, ());
+ LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetInScopeOnly, (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions,
+ GetIncludeRuntimeSupportValues, ());
+ LLDB_REGISTER_METHOD(void, SBVariablesOptions,
+ SetIncludeRuntimeSupportValues, (bool));
+ LLDB_REGISTER_METHOD_CONST(lldb::DynamicValueType, SBVariablesOptions,
+ GetUseDynamic, ());
+ LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetUseDynamic,
+ (lldb::DynamicValueType));
+ }
+ {
+ LLDB_REGISTER_CONSTRUCTOR(SBWatchpoint, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBWatchpoint, (const lldb::WatchpointSP &));
+ LLDB_REGISTER_CONSTRUCTOR(SBWatchpoint, (const lldb::SBWatchpoint &));
+ LLDB_REGISTER_METHOD(const lldb::SBWatchpoint &,
+ SBWatchpoint, operator=,(const lldb::SBWatchpoint &));
+ LLDB_REGISTER_METHOD(lldb::watch_id_t, SBWatchpoint, GetID, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBWatchpoint, IsValid, ());
+ LLDB_REGISTER_METHOD(lldb::SBError, SBWatchpoint, GetError, ());
+ LLDB_REGISTER_METHOD(int32_t, SBWatchpoint, GetHardwareIndex, ());
+ LLDB_REGISTER_METHOD(lldb::addr_t, SBWatchpoint, GetWatchAddress, ());
+ LLDB_REGISTER_METHOD(size_t, SBWatchpoint, GetWatchSize, ());
+ LLDB_REGISTER_METHOD(void, SBWatchpoint, SetEnabled, (bool));
+ LLDB_REGISTER_METHOD(bool, SBWatchpoint, IsEnabled, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBWatchpoint, GetHitCount, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBWatchpoint, GetIgnoreCount, ());
+ LLDB_REGISTER_METHOD(void, SBWatchpoint, SetIgnoreCount, (uint32_t));
+ LLDB_REGISTER_METHOD(const char *, SBWatchpoint, GetCondition, ());
+ LLDB_REGISTER_METHOD(void, SBWatchpoint, SetCondition, (const char *));
+ LLDB_REGISTER_METHOD(bool, SBWatchpoint, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel));
+ LLDB_REGISTER_METHOD(void, SBWatchpoint, Clear, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::WatchpointSP, SBWatchpoint, GetSP, ());
+ LLDB_REGISTER_METHOD(void, SBWatchpoint, SetSP,
+ (const lldb::WatchpointSP &));
+ LLDB_REGISTER_STATIC_METHOD(bool, SBWatchpoint, EventIsWatchpointEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_STATIC_METHOD(lldb::WatchpointEventType, SBWatchpoint,
+ GetWatchpointEventTypeFromEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_STATIC_METHOD(lldb::SBWatchpoint, SBWatchpoint,
+ GetWatchpointFromEvent,
+ (const lldb::SBEvent &));
+ }
+}
const char *SBReproducer::Capture(const char *path) {
static std::string error;
//===----------------------------------------------------------------------===//
#include "lldb/API/SBSection.h"
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBTarget.h"
#include "lldb/Core/Module.h"
using namespace lldb;
using namespace lldb_private;
-SBSection::SBSection() : m_opaque_wp() {}
+SBSection::SBSection() : m_opaque_wp() {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSection);
+}
-SBSection::SBSection(const SBSection &rhs) : m_opaque_wp(rhs.m_opaque_wp) {}
+SBSection::SBSection(const SBSection &rhs) : m_opaque_wp(rhs.m_opaque_wp) {
+ LLDB_RECORD_CONSTRUCTOR(SBSection, (const lldb::SBSection &), rhs);
+}
SBSection::SBSection(const lldb::SectionSP §ion_sp)
: m_opaque_wp() // Don't init with section_sp otherwise this will throw if
}
const SBSection &SBSection::operator=(const SBSection &rhs) {
+ LLDB_RECORD_METHOD(const lldb::SBSection &,
+ SBSection, operator=,(const lldb::SBSection &), rhs);
+
m_opaque_wp = rhs.m_opaque_wp;
return *this;
}
SBSection::~SBSection() {}
bool SBSection::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSection, IsValid);
+
SectionSP section_sp(GetSP());
return section_sp && section_sp->GetModule().get() != NULL;
}
const char *SBSection::GetName() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBSection, GetName);
+
SectionSP section_sp(GetSP());
if (section_sp)
return section_sp->GetName().GetCString();
}
lldb::SBSection SBSection::GetParent() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSection, SBSection, GetParent);
+
lldb::SBSection sb_section;
SectionSP section_sp(GetSP());
if (section_sp) {
if (parent_section_sp)
sb_section.SetSP(parent_section_sp);
}
- return sb_section;
+ return LLDB_RECORD_RESULT(sb_section);
}
lldb::SBSection SBSection::FindSubSection(const char *sect_name) {
+ LLDB_RECORD_METHOD(lldb::SBSection, SBSection, FindSubSection, (const char *),
+ sect_name);
+
lldb::SBSection sb_section;
if (sect_name) {
SectionSP section_sp(GetSP());
section_sp->GetChildren().FindSectionByName(const_sect_name));
}
}
- return sb_section;
+ return LLDB_RECORD_RESULT(sb_section);
}
size_t SBSection::GetNumSubSections() {
+ LLDB_RECORD_METHOD_NO_ARGS(size_t, SBSection, GetNumSubSections);
+
SectionSP section_sp(GetSP());
if (section_sp)
return section_sp->GetChildren().GetSize();
}
lldb::SBSection SBSection::GetSubSectionAtIndex(size_t idx) {
+ LLDB_RECORD_METHOD(lldb::SBSection, SBSection, GetSubSectionAtIndex, (size_t),
+ idx);
+
lldb::SBSection sb_section;
SectionSP section_sp(GetSP());
if (section_sp)
sb_section.SetSP(section_sp->GetChildren().GetSectionAtIndex(idx));
- return sb_section;
+ return LLDB_RECORD_RESULT(sb_section);
}
lldb::SectionSP SBSection::GetSP() const { return m_opaque_wp.lock(); }
}
lldb::addr_t SBSection::GetFileAddress() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBSection, GetFileAddress);
+
lldb::addr_t file_addr = LLDB_INVALID_ADDRESS;
SectionSP section_sp(GetSP());
if (section_sp)
}
lldb::addr_t SBSection::GetLoadAddress(lldb::SBTarget &sb_target) {
+ LLDB_RECORD_METHOD(lldb::addr_t, SBSection, GetLoadAddress,
+ (lldb::SBTarget &), sb_target);
+
TargetSP target_sp(sb_target.GetSP());
if (target_sp) {
SectionSP section_sp(GetSP());
}
lldb::addr_t SBSection::GetByteSize() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBSection, GetByteSize);
+
SectionSP section_sp(GetSP());
if (section_sp)
return section_sp->GetByteSize();
}
uint64_t SBSection::GetFileOffset() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBSection, GetFileOffset);
+
SectionSP section_sp(GetSP());
if (section_sp) {
ModuleSP module_sp(section_sp->GetModule());
}
uint64_t SBSection::GetFileByteSize() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBSection, GetFileByteSize);
+
SectionSP section_sp(GetSP());
if (section_sp)
return section_sp->GetFileSize();
return 0;
}
-SBData SBSection::GetSectionData() { return GetSectionData(0, UINT64_MAX); }
+SBData SBSection::GetSectionData() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBData, SBSection, GetSectionData);
+
+ return LLDB_RECORD_RESULT(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);
+
SBData sb_data;
SectionSP section_sp(GetSP());
if (section_sp) {
}
}
}
- return sb_data;
+ return LLDB_RECORD_RESULT(sb_data);
}
SectionType SBSection::GetSectionType() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SectionType, SBSection, GetSectionType);
+
SectionSP section_sp(GetSP());
if (section_sp.get())
return section_sp->GetType();
return eSectionTypeInvalid;
}
-uint32_t
-SBSection::GetPermissions() const
-{
- SectionSP section_sp(GetSP());
- if (section_sp)
- return section_sp->GetPermissions();
- return 0;
+uint32_t SBSection::GetPermissions() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBSection, GetPermissions);
+
+ SectionSP section_sp(GetSP());
+ if (section_sp)
+ return section_sp->GetPermissions();
+ return 0;
}
uint32_t SBSection::GetTargetByteSize() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBSection, GetTargetByteSize);
+
SectionSP section_sp(GetSP());
if (section_sp.get())
return section_sp->GetTargetByteSize();
}
bool SBSection::operator==(const SBSection &rhs) {
+ LLDB_RECORD_METHOD(bool, SBSection, operator==,(const lldb::SBSection &),
+ rhs);
+
SectionSP lhs_section_sp(GetSP());
SectionSP rhs_section_sp(rhs.GetSP());
if (lhs_section_sp && rhs_section_sp)
}
bool SBSection::operator!=(const SBSection &rhs) {
+ LLDB_RECORD_METHOD(bool, SBSection, operator!=,(const lldb::SBSection &),
+ rhs);
+
SectionSP lhs_section_sp(GetSP());
SectionSP rhs_section_sp(rhs.GetSP());
return lhs_section_sp != rhs_section_sp;
}
bool SBSection::GetDescription(SBStream &description) {
+ LLDB_RECORD_METHOD(bool, SBSection, GetDescription, (lldb::SBStream &),
+ description);
+
Stream &strm = description.ref();
SectionSP section_sp(GetSP());
//===----------------------------------------------------------------------===//
#include "lldb/API/SBSourceManager.h"
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBTarget.h"
using namespace lldb_private;
SBSourceManager::SBSourceManager(const SBDebugger &debugger) {
+ LLDB_RECORD_CONSTRUCTOR(SBSourceManager, (const lldb::SBDebugger &),
+ debugger);
+
m_opaque_up.reset(new SourceManagerImpl(debugger.get_sp()));
}
SBSourceManager::SBSourceManager(const SBTarget &target) {
+ LLDB_RECORD_CONSTRUCTOR(SBSourceManager, (const lldb::SBTarget &), target);
+
m_opaque_up.reset(new SourceManagerImpl(target.GetSP()));
}
SBSourceManager::SBSourceManager(const SBSourceManager &rhs) {
+ LLDB_RECORD_CONSTRUCTOR(SBSourceManager, (const lldb::SBSourceManager &),
+ rhs);
+
if (&rhs == this)
return;
const lldb::SBSourceManager &SBSourceManager::
operator=(const lldb::SBSourceManager &rhs) {
+ LLDB_RECORD_METHOD(const lldb::SBSourceManager &,
+ SBSourceManager, operator=,(const lldb::SBSourceManager &),
+ rhs);
+
m_opaque_up.reset(new SourceManagerImpl(*(rhs.m_opaque_up.get())));
return *this;
}
size_t SBSourceManager::DisplaySourceLinesWithLineNumbers(
const SBFileSpec &file, uint32_t line, uint32_t context_before,
uint32_t context_after, const char *current_line_cstr, SBStream &s) {
+ LLDB_RECORD_METHOD(size_t, SBSourceManager, DisplaySourceLinesWithLineNumbers,
+ (const lldb::SBFileSpec &, uint32_t, uint32_t, uint32_t,
+ const char *, lldb::SBStream &),
+ file, line, context_before, context_after,
+ current_line_cstr, s);
+
const uint32_t column = 0;
return DisplaySourceLinesWithLineNumbersAndColumn(
file.ref(), line, column, context_before, context_after,
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);
+
if (m_opaque_up == NULL)
return 0;
#include "lldb/API/SBStream.h"
+#include "SBReproducerPrivate.h"
#include "lldb/Core/StreamFile.h"
#include "lldb/Host/FileSystem.h"
#include "lldb/Utility/Status.h"
using namespace lldb;
using namespace lldb_private;
-SBStream::SBStream() : m_opaque_up(new StreamString()), m_is_file(false) {}
+SBStream::SBStream() : m_opaque_up(new StreamString()), m_is_file(false) {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBStream);
+}
SBStream::SBStream(SBStream &&rhs)
: m_opaque_up(std::move(rhs.m_opaque_up)), m_is_file(rhs.m_is_file) {}
SBStream::~SBStream() {}
-bool SBStream::IsValid() const { return (m_opaque_up != NULL); }
+bool SBStream::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStream, IsValid);
+
+ return (m_opaque_up != NULL);
+}
// 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);
+
if (m_is_file || m_opaque_up == NULL)
return NULL;
// 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);
+
if (m_is_file || m_opaque_up == NULL)
return 0;
}
void SBStream::RedirectToFile(const char *path, bool append) {
+ LLDB_RECORD_METHOD(void, SBStream, RedirectToFile, (const char *, bool), path,
+ append);
+
if (path == nullptr)
return;
}
void SBStream::RedirectToFileHandle(FILE *fh, bool transfer_fh_ownership) {
+ LLDB_RECORD_METHOD(void, SBStream, RedirectToFileHandle, (FILE *, bool), fh,
+ transfer_fh_ownership);
+
if (fh == nullptr)
return;
}
void SBStream::RedirectToFileDescriptor(int fd, bool transfer_fh_ownership) {
+ LLDB_RECORD_METHOD(void, SBStream, RedirectToFileDescriptor, (int, bool), fd,
+ transfer_fh_ownership);
+
std::string local_data;
if (m_opaque_up) {
// See if we have any locally backed data. If so, copy it so we can then
}
void SBStream::Clear() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBStream, Clear);
+
if (m_opaque_up) {
// See if we have any locally backed data. If so, copy it so we can then
// redirect it to the file so we don't lose the data
//===----------------------------------------------------------------------===//
#include "lldb/API/SBStringList.h"
+#include "SBReproducerPrivate.h"
#include "Utils.h"
#include "lldb/Utility/StringList.h"
using namespace lldb;
using namespace lldb_private;
-SBStringList::SBStringList() : m_opaque_up() {}
+SBStringList::SBStringList() : m_opaque_up() {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBStringList);
+}
SBStringList::SBStringList(const lldb_private::StringList *lldb_strings_ptr)
: m_opaque_up() {
}
SBStringList::SBStringList(const SBStringList &rhs) : m_opaque_up() {
+ LLDB_RECORD_CONSTRUCTOR(SBStringList, (const lldb::SBStringList &), rhs);
+
m_opaque_up = clone(rhs.m_opaque_up);
}
const SBStringList &SBStringList::operator=(const SBStringList &rhs) {
+ LLDB_RECORD_METHOD(const lldb::SBStringList &,
+ SBStringList, operator=,(const lldb::SBStringList &), rhs);
+
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
return *this;
return *m_opaque_up;
}
-bool SBStringList::IsValid() const { return (m_opaque_up != NULL); }
+bool SBStringList::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStringList, IsValid);
+
+ return (m_opaque_up != NULL);
+}
void SBStringList::AppendString(const char *str) {
+ LLDB_RECORD_METHOD(void, SBStringList, AppendString, (const char *), str);
+
if (str != NULL) {
if (IsValid())
m_opaque_up->AppendString(str);
}
void SBStringList::AppendList(const char **strv, int strc) {
+ LLDB_RECORD_METHOD(void, SBStringList, AppendList, (const char **, int), strv,
+ strc);
+
if ((strv != NULL) && (strc > 0)) {
if (IsValid())
m_opaque_up->AppendList(strv, strc);
}
void SBStringList::AppendList(const SBStringList &strings) {
+ LLDB_RECORD_METHOD(void, SBStringList, AppendList,
+ (const lldb::SBStringList &), strings);
+
if (strings.IsValid()) {
if (!IsValid())
m_opaque_up.reset(new lldb_private::StringList());
}
uint32_t SBStringList::GetSize() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBStringList, GetSize);
+
if (IsValid()) {
return m_opaque_up->GetSize();
}
}
const char *SBStringList::GetStringAtIndex(size_t idx) {
+ LLDB_RECORD_METHOD(const char *, SBStringList, GetStringAtIndex, (size_t),
+ idx);
+
if (IsValid()) {
return m_opaque_up->GetStringAtIndex(idx);
}
}
const char *SBStringList::GetStringAtIndex(size_t idx) const {
+ LLDB_RECORD_METHOD_CONST(const char *, SBStringList, GetStringAtIndex,
+ (size_t), idx);
+
if (IsValid()) {
return m_opaque_up->GetStringAtIndex(idx);
}
}
void SBStringList::Clear() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBStringList, Clear);
+
if (IsValid()) {
m_opaque_up->Clear();
}
//===----------------------------------------------------------------------===//
#include "lldb/API/SBStructuredData.h"
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBStringList.h"
#pragma mark--
#pragma mark SBStructuredData
-SBStructuredData::SBStructuredData() : m_impl_up(new StructuredDataImpl()) {}
+SBStructuredData::SBStructuredData() : m_impl_up(new StructuredDataImpl()) {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBStructuredData);
+}
SBStructuredData::SBStructuredData(const lldb::SBStructuredData &rhs)
- : m_impl_up(new StructuredDataImpl(*rhs.m_impl_up.get())) {}
+ : m_impl_up(new StructuredDataImpl(*rhs.m_impl_up.get())) {
+ LLDB_RECORD_CONSTRUCTOR(SBStructuredData, (const lldb::SBStructuredData &),
+ rhs);
+}
SBStructuredData::SBStructuredData(const lldb::EventSP &event_sp)
- : m_impl_up(new StructuredDataImpl(event_sp)) {}
+ : m_impl_up(new StructuredDataImpl(event_sp)) {
+ LLDB_RECORD_CONSTRUCTOR(SBStructuredData, (const lldb::EventSP &), event_sp);
+}
SBStructuredData::SBStructuredData(lldb_private::StructuredDataImpl *impl)
- : m_impl_up(impl) {}
+ : m_impl_up(impl) {
+ LLDB_RECORD_CONSTRUCTOR(SBStructuredData,
+ (lldb_private::StructuredDataImpl *), impl);
+}
SBStructuredData::~SBStructuredData() {}
SBStructuredData &SBStructuredData::
operator=(const lldb::SBStructuredData &rhs) {
+ LLDB_RECORD_METHOD(
+ lldb::SBStructuredData &,
+ SBStructuredData, operator=,(const lldb::SBStructuredData &), rhs);
+
*m_impl_up = *rhs.m_impl_up;
return *this;
}
lldb::SBError SBStructuredData::SetFromJSON(lldb::SBStream &stream) {
+ LLDB_RECORD_METHOD(lldb::SBError, SBStructuredData, SetFromJSON,
+ (lldb::SBStream &), stream);
+
lldb::SBError error;
std::string json_str(stream.GetData());
if (!json_obj || json_obj->GetType() != eStructuredDataTypeDictionary)
error.SetErrorString("Invalid Syntax");
- return error;
+ return LLDB_RECORD_RESULT(error);
}
-bool SBStructuredData::IsValid() const { return m_impl_up->IsValid(); }
+bool SBStructuredData::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStructuredData, IsValid);
-void SBStructuredData::Clear() { m_impl_up->Clear(); }
+ return m_impl_up->IsValid();
+}
+
+void SBStructuredData::Clear() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBStructuredData, Clear);
+
+ m_impl_up->Clear();
+}
SBError SBStructuredData::GetAsJSON(lldb::SBStream &stream) const {
+ LLDB_RECORD_METHOD_CONST(lldb::SBError, SBStructuredData, GetAsJSON,
+ (lldb::SBStream &), stream);
+
SBError error;
error.SetError(m_impl_up->GetAsJSON(stream.ref()));
- return error;
+ return LLDB_RECORD_RESULT(error);
}
lldb::SBError SBStructuredData::GetDescription(lldb::SBStream &stream) const {
+ LLDB_RECORD_METHOD_CONST(lldb::SBError, SBStructuredData, GetDescription,
+ (lldb::SBStream &), stream);
+
Status error = m_impl_up->GetDescription(stream.ref());
SBError sb_error;
sb_error.SetError(error);
- return sb_error;
+ return LLDB_RECORD_RESULT(sb_error);
}
StructuredDataType SBStructuredData::GetType() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::StructuredDataType, SBStructuredData,
+ GetType);
+
return (m_impl_up ? m_impl_up->GetType() : eStructuredDataTypeInvalid);
}
size_t SBStructuredData::GetSize() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBStructuredData, GetSize);
+
return (m_impl_up ? m_impl_up->GetSize() : 0);
}
bool SBStructuredData::GetKeys(lldb::SBStringList &keys) const {
+ LLDB_RECORD_METHOD_CONST(bool, SBStructuredData, GetKeys,
+ (lldb::SBStringList &), keys);
+
if (!m_impl_up)
return false;
}
lldb::SBStructuredData SBStructuredData::GetValueForKey(const char *key) const {
+ LLDB_RECORD_METHOD_CONST(lldb::SBStructuredData, SBStructuredData,
+ GetValueForKey, (const char *), key);
+
if (!m_impl_up)
- return SBStructuredData();
+ return LLDB_RECORD_RESULT(SBStructuredData());
SBStructuredData result;
result.m_impl_up->SetObjectSP(m_impl_up->GetValueForKey(key));
- return result;
+ return LLDB_RECORD_RESULT(result);
}
lldb::SBStructuredData SBStructuredData::GetItemAtIndex(size_t idx) const {
+ LLDB_RECORD_METHOD_CONST(lldb::SBStructuredData, SBStructuredData,
+ GetItemAtIndex, (size_t), idx);
+
if (!m_impl_up)
- return SBStructuredData();
+ return LLDB_RECORD_RESULT(SBStructuredData());
SBStructuredData result;
result.m_impl_up->SetObjectSP(m_impl_up->GetItemAtIndex(idx));
- return result;
+ return LLDB_RECORD_RESULT(result);
}
uint64_t SBStructuredData::GetIntegerValue(uint64_t fail_value) const {
+ LLDB_RECORD_METHOD_CONST(uint64_t, SBStructuredData, GetIntegerValue,
+ (uint64_t), fail_value);
+
return (m_impl_up ? m_impl_up->GetIntegerValue(fail_value) : fail_value);
}
double SBStructuredData::GetFloatValue(double fail_value) const {
+ LLDB_RECORD_METHOD_CONST(double, SBStructuredData, GetFloatValue, (double),
+ fail_value);
+
return (m_impl_up ? m_impl_up->GetFloatValue(fail_value) : fail_value);
}
bool SBStructuredData::GetBooleanValue(bool fail_value) const {
+ LLDB_RECORD_METHOD_CONST(bool, SBStructuredData, GetBooleanValue, (bool),
+ fail_value);
+
return (m_impl_up ? m_impl_up->GetBooleanValue(fail_value) : 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);
+
return (m_impl_up ? m_impl_up->GetStringValue(dst, dst_len) : 0);
}
//===----------------------------------------------------------------------===//
#include "lldb/API/SBSymbol.h"
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBStream.h"
#include "lldb/Core/Disassembler.h"
#include "lldb/Core/Module.h"
using namespace lldb;
using namespace lldb_private;
-SBSymbol::SBSymbol() : m_opaque_ptr(NULL) {}
+SBSymbol::SBSymbol() : m_opaque_ptr(NULL) {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSymbol);
+}
SBSymbol::SBSymbol(lldb_private::Symbol *lldb_object_ptr)
: m_opaque_ptr(lldb_object_ptr) {}
-SBSymbol::SBSymbol(const lldb::SBSymbol &rhs)
- : m_opaque_ptr(rhs.m_opaque_ptr) {}
+SBSymbol::SBSymbol(const lldb::SBSymbol &rhs) : m_opaque_ptr(rhs.m_opaque_ptr) {
+ LLDB_RECORD_CONSTRUCTOR(SBSymbol, (const lldb::SBSymbol &), rhs);
+}
const SBSymbol &SBSymbol::operator=(const SBSymbol &rhs) {
+ LLDB_RECORD_METHOD(const lldb::SBSymbol &,
+ SBSymbol, operator=,(const lldb::SBSymbol &), rhs);
+
m_opaque_ptr = rhs.m_opaque_ptr;
return *this;
}
m_opaque_ptr = lldb_object_ptr;
}
-bool SBSymbol::IsValid() const { return m_opaque_ptr != NULL; }
+bool SBSymbol::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbol, IsValid);
+
+ return m_opaque_ptr != NULL;
+}
const char *SBSymbol::GetName() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetName);
+
const char *name = NULL;
if (m_opaque_ptr)
name = m_opaque_ptr->GetName().AsCString();
}
const char *SBSymbol::GetDisplayName() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetDisplayName);
+
const char *name = NULL;
if (m_opaque_ptr)
name = m_opaque_ptr->GetMangled()
}
const char *SBSymbol::GetMangledName() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetMangledName);
+
const char *name = NULL;
if (m_opaque_ptr)
name = m_opaque_ptr->GetMangled().GetMangledName().AsCString();
}
bool SBSymbol::operator==(const SBSymbol &rhs) const {
+ LLDB_RECORD_METHOD_CONST(bool, SBSymbol, operator==,(const lldb::SBSymbol &),
+ rhs);
+
return m_opaque_ptr == rhs.m_opaque_ptr;
}
bool SBSymbol::operator!=(const SBSymbol &rhs) const {
+ LLDB_RECORD_METHOD_CONST(bool, SBSymbol, operator!=,(const lldb::SBSymbol &),
+ rhs);
+
return m_opaque_ptr != rhs.m_opaque_ptr;
}
bool SBSymbol::GetDescription(SBStream &description) {
+ LLDB_RECORD_METHOD(bool, SBSymbol, GetDescription, (lldb::SBStream &),
+ description);
+
Stream &strm = description.ref();
if (m_opaque_ptr) {
}
SBInstructionList SBSymbol::GetInstructions(SBTarget target) {
- return GetInstructions(target, NULL);
+ LLDB_RECORD_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions,
+ (lldb::SBTarget), target);
+
+ return LLDB_RECORD_RESULT(GetInstructions(target, NULL));
}
SBInstructionList SBSymbol::GetInstructions(SBTarget target,
const char *flavor_string) {
+ LLDB_RECORD_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions,
+ (lldb::SBTarget, const char *), target, flavor_string);
+
SBInstructionList sb_instructions;
if (m_opaque_ptr) {
ExecutionContext exe_ctx;
}
}
}
- return sb_instructions;
+ return LLDB_RECORD_RESULT(sb_instructions);
}
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);
+
SBAddress addr;
if (m_opaque_ptr && m_opaque_ptr->ValueIsAddress()) {
addr.SetAddress(&m_opaque_ptr->GetAddressRef());
}
- return addr;
+ return LLDB_RECORD_RESULT(addr);
}
SBAddress SBSymbol::GetEndAddress() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBSymbol, GetEndAddress);
+
SBAddress addr;
if (m_opaque_ptr && m_opaque_ptr->ValueIsAddress()) {
lldb::addr_t range_size = m_opaque_ptr->GetByteSize();
addr->Slide(m_opaque_ptr->GetByteSize());
}
}
- return addr;
+ return LLDB_RECORD_RESULT(addr);
}
uint32_t SBSymbol::GetPrologueByteSize() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBSymbol, GetPrologueByteSize);
+
if (m_opaque_ptr)
return m_opaque_ptr->GetPrologueByteSize();
return 0;
}
SymbolType SBSymbol::GetType() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SymbolType, SBSymbol, GetType);
+
if (m_opaque_ptr)
return m_opaque_ptr->GetType();
return eSymbolTypeInvalid;
}
bool SBSymbol::IsExternal() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBSymbol, IsExternal);
+
if (m_opaque_ptr)
return m_opaque_ptr->IsExternal();
return false;
}
bool SBSymbol::IsSynthetic() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBSymbol, IsSynthetic);
+
if (m_opaque_ptr)
return m_opaque_ptr->IsSynthetic();
return false;
//===----------------------------------------------------------------------===//
#include "lldb/API/SBSymbolContext.h"
+#include "SBReproducerPrivate.h"
#include "Utils.h"
#include "lldb/API/SBStream.h"
#include "lldb/Core/Module.h"
using namespace lldb;
using namespace lldb_private;
-SBSymbolContext::SBSymbolContext() : m_opaque_up() {}
+SBSymbolContext::SBSymbolContext() : m_opaque_up() {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSymbolContext);
+}
SBSymbolContext::SBSymbolContext(const SymbolContext *sc_ptr) : m_opaque_up() {
+ LLDB_RECORD_CONSTRUCTOR(SBSymbolContext,
+ (const lldb_private::SymbolContext *), sc_ptr);
+
if (sc_ptr)
m_opaque_up = llvm::make_unique<SymbolContext>(*sc_ptr);
}
SBSymbolContext::SBSymbolContext(const SBSymbolContext &rhs) : m_opaque_up() {
+ LLDB_RECORD_CONSTRUCTOR(SBSymbolContext, (const lldb::SBSymbolContext &),
+ rhs);
+
m_opaque_up = clone(rhs.m_opaque_up);
}
SBSymbolContext::~SBSymbolContext() {}
const SBSymbolContext &SBSymbolContext::operator=(const SBSymbolContext &rhs) {
+ LLDB_RECORD_METHOD(const lldb::SBSymbolContext &,
+ SBSymbolContext, operator=,(const lldb::SBSymbolContext &),
+ rhs);
+
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
return *this;
m_opaque_up->Clear(true);
}
-bool SBSymbolContext::IsValid() const { return m_opaque_up != NULL; }
+bool SBSymbolContext::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContext, IsValid);
+
+ return m_opaque_up != NULL;
+}
SBModule SBSymbolContext::GetModule() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBModule, SBSymbolContext, GetModule);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBModule sb_module;
static_cast<void *>(module_sp.get()), sstr.GetData());
}
- return sb_module;
+ return LLDB_RECORD_RESULT(sb_module);
}
SBCompileUnit SBSymbolContext::GetCompileUnit() {
- return SBCompileUnit(m_opaque_up ? m_opaque_up->comp_unit : NULL);
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCompileUnit, SBSymbolContext,
+ GetCompileUnit);
+
+ return LLDB_RECORD_RESULT(
+ SBCompileUnit(m_opaque_up ? m_opaque_up->comp_unit : NULL));
}
SBFunction SBSymbolContext::GetFunction() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFunction, SBSymbolContext, GetFunction);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
Function *function = NULL;
static_cast<void *>(m_opaque_up.get()),
static_cast<void *>(function));
- return sb_function;
+ return LLDB_RECORD_RESULT(sb_function);
}
SBBlock SBSymbolContext::GetBlock() {
- return SBBlock(m_opaque_up ? m_opaque_up->block : NULL);
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBSymbolContext, GetBlock);
+
+ return LLDB_RECORD_RESULT(SBBlock(m_opaque_up ? m_opaque_up->block : NULL));
}
SBLineEntry SBSymbolContext::GetLineEntry() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBLineEntry, SBSymbolContext, GetLineEntry);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBLineEntry sb_line_entry;
static_cast<void *>(sb_line_entry.get()));
}
- return sb_line_entry;
+ return LLDB_RECORD_RESULT(sb_line_entry);
}
SBSymbol SBSymbolContext::GetSymbol() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSymbol, SBSymbolContext, GetSymbol);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
Symbol *symbol = NULL;
static_cast<void *>(m_opaque_up.get()),
static_cast<void *>(symbol));
- return sb_symbol;
+ return LLDB_RECORD_RESULT(sb_symbol);
}
void SBSymbolContext::SetModule(lldb::SBModule module) {
+ LLDB_RECORD_METHOD(void, SBSymbolContext, SetModule, (lldb::SBModule),
+ module);
+
ref().module_sp = module.GetSP();
}
void SBSymbolContext::SetCompileUnit(lldb::SBCompileUnit compile_unit) {
+ LLDB_RECORD_METHOD(void, SBSymbolContext, SetCompileUnit,
+ (lldb::SBCompileUnit), compile_unit);
+
ref().comp_unit = compile_unit.get();
}
void SBSymbolContext::SetFunction(lldb::SBFunction function) {
+ LLDB_RECORD_METHOD(void, SBSymbolContext, SetFunction, (lldb::SBFunction),
+ function);
+
ref().function = function.get();
}
void SBSymbolContext::SetBlock(lldb::SBBlock block) {
+ LLDB_RECORD_METHOD(void, SBSymbolContext, SetBlock, (lldb::SBBlock), block);
+
ref().block = block.GetPtr();
}
void SBSymbolContext::SetLineEntry(lldb::SBLineEntry line_entry) {
+ LLDB_RECORD_METHOD(void, SBSymbolContext, SetLineEntry, (lldb::SBLineEntry),
+ line_entry);
+
if (line_entry.IsValid())
ref().line_entry = line_entry.ref();
else
}
void SBSymbolContext::SetSymbol(lldb::SBSymbol symbol) {
+ LLDB_RECORD_METHOD(void, SBSymbolContext, SetSymbol, (lldb::SBSymbol),
+ symbol);
+
ref().symbol = symbol.get();
}
}
bool SBSymbolContext::GetDescription(SBStream &description) {
+ LLDB_RECORD_METHOD(bool, SBSymbolContext, GetDescription, (lldb::SBStream &),
+ description);
+
Stream &strm = description.ref();
if (m_opaque_up) {
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);
+
SBSymbolContext sb_sc;
if (m_opaque_up.get() && curr_frame_pc.IsValid()) {
if (m_opaque_up->GetParentOfInlinedScope(curr_frame_pc.ref(), sb_sc.ref(),
parent_frame_addr.ref()))
- return sb_sc;
+ return LLDB_RECORD_RESULT(sb_sc);
}
- return SBSymbolContext();
+ return LLDB_RECORD_RESULT(SBSymbolContext());
}
//===----------------------------------------------------------------------===//
#include "lldb/API/SBSymbolContextList.h"
+#include "SBReproducerPrivate.h"
#include "Utils.h"
#include "lldb/API/SBStream.h"
#include "lldb/Symbol/SymbolContext.h"
using namespace lldb_private;
SBSymbolContextList::SBSymbolContextList()
- : m_opaque_up(new SymbolContextList()) {}
+ : m_opaque_up(new SymbolContextList()) {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSymbolContextList);
+}
SBSymbolContextList::SBSymbolContextList(const SBSymbolContextList &rhs)
: m_opaque_up() {
+ LLDB_RECORD_CONSTRUCTOR(SBSymbolContextList,
+ (const lldb::SBSymbolContextList &), rhs);
m_opaque_up = clone(rhs.m_opaque_up);
}
const SBSymbolContextList &SBSymbolContextList::
operator=(const SBSymbolContextList &rhs) {
+ LLDB_RECORD_METHOD(
+ const lldb::SBSymbolContextList &,
+ SBSymbolContextList, operator=,(const lldb::SBSymbolContextList &), rhs);
+
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
return *this;
}
uint32_t SBSymbolContextList::GetSize() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBSymbolContextList, GetSize);
+
if (m_opaque_up)
return m_opaque_up->GetSize();
return 0;
}
SBSymbolContext SBSymbolContextList::GetContextAtIndex(uint32_t idx) {
+ LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBSymbolContextList,
+ GetContextAtIndex, (uint32_t), idx);
+
SBSymbolContext sb_sc;
if (m_opaque_up) {
SymbolContext sc;
sb_sc.SetSymbolContext(&sc);
}
}
- return sb_sc;
+ return LLDB_RECORD_RESULT(sb_sc);
}
void SBSymbolContextList::Clear() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBSymbolContextList, Clear);
+
if (m_opaque_up)
m_opaque_up->Clear();
}
void SBSymbolContextList::Append(SBSymbolContext &sc) {
+ LLDB_RECORD_METHOD(void, SBSymbolContextList, Append,
+ (lldb::SBSymbolContext &), sc);
+
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);
+
if (sc_list.IsValid() && m_opaque_up.get())
m_opaque_up->Append(*sc_list);
}
-bool SBSymbolContextList::IsValid() const { return m_opaque_up != NULL; }
+bool SBSymbolContextList::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContextList, IsValid);
+
+ return m_opaque_up != NULL;
+}
lldb_private::SymbolContextList *SBSymbolContextList::operator->() const {
return m_opaque_up.get();
}
bool SBSymbolContextList::GetDescription(lldb::SBStream &description) {
+ LLDB_RECORD_METHOD(bool, SBSymbolContextList, GetDescription,
+ (lldb::SBStream &), description);
+
Stream &strm = description.ref();
if (m_opaque_up)
m_opaque_up->GetDescription(&strm, lldb::eDescriptionLevelFull, NULL);
//===----------------------------------------------------------------------===//
#include "lldb/API/SBTarget.h"
+#include "SBReproducerPrivate.h"
#include "lldb/lldb-public.h"
//----------------------------------------------------------------------
// SBTarget constructor
//----------------------------------------------------------------------
-SBTarget::SBTarget() : m_opaque_sp() {}
+SBTarget::SBTarget() : m_opaque_sp() {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTarget);
+}
-SBTarget::SBTarget(const SBTarget &rhs) : m_opaque_sp(rhs.m_opaque_sp) {}
+SBTarget::SBTarget(const SBTarget &rhs) : m_opaque_sp(rhs.m_opaque_sp) {
+ LLDB_RECORD_CONSTRUCTOR(SBTarget, (const lldb::SBTarget &), rhs);
+}
-SBTarget::SBTarget(const TargetSP &target_sp) : m_opaque_sp(target_sp) {}
+SBTarget::SBTarget(const TargetSP &target_sp) : m_opaque_sp(target_sp) {
+ LLDB_RECORD_CONSTRUCTOR(SBTarget, (const lldb::TargetSP &), target_sp);
+}
const SBTarget &SBTarget::operator=(const SBTarget &rhs) {
+ LLDB_RECORD_METHOD(const lldb::SBTarget &,
+ SBTarget, operator=,(const lldb::SBTarget &), rhs);
+
if (this != &rhs)
m_opaque_sp = rhs.m_opaque_sp;
return *this;
SBTarget::~SBTarget() {}
bool SBTarget::EventIsTargetEvent(const SBEvent &event) {
+ LLDB_RECORD_STATIC_METHOD(bool, SBTarget, EventIsTargetEvent,
+ (const lldb::SBEvent &), event);
+
return Target::TargetEventData::GetEventDataFromEvent(event.get()) != NULL;
}
SBTarget SBTarget::GetTargetFromEvent(const SBEvent &event) {
- return Target::TargetEventData::GetTargetFromEvent(event.get());
+ LLDB_RECORD_STATIC_METHOD(lldb::SBTarget, SBTarget, GetTargetFromEvent,
+ (const lldb::SBEvent &), event);
+
+ return LLDB_RECORD_RESULT(
+ Target::TargetEventData::GetTargetFromEvent(event.get()));
}
uint32_t SBTarget::GetNumModulesFromEvent(const SBEvent &event) {
+ LLDB_RECORD_STATIC_METHOD(uint32_t, SBTarget, GetNumModulesFromEvent,
+ (const lldb::SBEvent &), event);
+
const ModuleList module_list =
Target::TargetEventData::GetModuleListFromEvent(event.get());
return module_list.GetSize();
SBModule SBTarget::GetModuleAtIndexFromEvent(const uint32_t idx,
const SBEvent &event) {
+ LLDB_RECORD_STATIC_METHOD(lldb::SBModule, SBTarget, GetModuleAtIndexFromEvent,
+ (const uint32_t, const lldb::SBEvent &), idx,
+ event);
+
const ModuleList module_list =
Target::TargetEventData::GetModuleListFromEvent(event.get());
- return SBModule(module_list.GetModuleAtIndex(idx));
+ return LLDB_RECORD_RESULT(SBModule(module_list.GetModuleAtIndex(idx)));
}
const char *SBTarget::GetBroadcasterClassName() {
+ LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBTarget,
+ GetBroadcasterClassName);
+
return Target::GetStaticBroadcasterClass().AsCString();
}
bool SBTarget::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTarget, IsValid);
+
return m_opaque_sp.get() != NULL && m_opaque_sp->IsValid();
}
SBProcess SBTarget::GetProcess() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBTarget, GetProcess);
+
SBProcess sb_process;
ProcessSP process_sp;
TargetSP target_sp(GetSP());
static_cast<void *>(target_sp.get()),
static_cast<void *>(process_sp.get()));
- return sb_process;
+ return LLDB_RECORD_RESULT(sb_process);
}
SBPlatform SBTarget::GetPlatform() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBPlatform, SBTarget, GetPlatform);
+
TargetSP target_sp(GetSP());
if (!target_sp)
- return SBPlatform();
+ return LLDB_RECORD_RESULT(SBPlatform());
SBPlatform platform;
platform.m_opaque_sp = target_sp->GetPlatform();
- return platform;
+ return LLDB_RECORD_RESULT(platform);
}
SBDebugger SBTarget::GetDebugger() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBDebugger, SBTarget, GetDebugger);
+
SBDebugger debugger;
TargetSP target_sp(GetSP());
if (target_sp)
debugger.reset(target_sp->GetDebugger().shared_from_this());
- return debugger;
+ return LLDB_RECORD_RESULT(debugger);
}
SBStructuredData SBTarget::GetStatistics() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStructuredData, SBTarget, GetStatistics);
+
SBStructuredData data;
TargetSP target_sp(GetSP());
if (!target_sp)
- return data;
+ return LLDB_RECORD_RESULT(data);
auto stats_up = llvm::make_unique<StructuredData::Dictionary>();
int i = 0;
}
data.m_impl_up->SetObjectSP(std::move(stats_up));
- return data;
+ return LLDB_RECORD_RESULT(data);
}
void SBTarget::SetCollectingStats(bool v) {
+ LLDB_RECORD_METHOD(void, SBTarget, SetCollectingStats, (bool), v);
+
TargetSP target_sp(GetSP());
if (!target_sp)
return;
}
bool SBTarget::GetCollectingStats() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, GetCollectingStats);
+
TargetSP target_sp(GetSP());
if (!target_sp)
return false;
return target_sp->GetCollectingStats();
}
-
SBProcess SBTarget::LoadCore(const char *core_file) {
+ LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, LoadCore, (const char *),
+ core_file);
+
lldb::SBError error; // Ignored
- return LoadCore(core_file, error);
+ return LLDB_RECORD_RESULT(LoadCore(core_file, error));
}
SBProcess SBTarget::LoadCore(const char *core_file, lldb::SBError &error) {
+ LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, LoadCore,
+ (const char *, lldb::SBError &), core_file, error);
+
SBProcess sb_process;
TargetSP target_sp(GetSP());
if (target_sp) {
} else {
error.SetErrorString("SBTarget is invalid");
}
- return sb_process;
+ return LLDB_RECORD_RESULT(sb_process);
}
SBProcess SBTarget::LaunchSimple(char const **argv, char const **envp,
const char *working_directory) {
+ LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, LaunchSimple,
+ (const char **, const char **, const char *), argv, envp,
+ working_directory);
+
char *stdin_path = NULL;
char *stdout_path = NULL;
char *stderr_path = NULL;
bool stop_at_entry = false;
SBError error;
SBListener listener = GetDebugger().GetListener();
- return Launch(listener, argv, envp, stdin_path, stdout_path, stderr_path,
- working_directory, launch_flags, stop_at_entry, error);
+ return LLDB_RECORD_RESULT(Launch(listener, argv, envp, stdin_path,
+ stdout_path, stderr_path, working_directory,
+ launch_flags, stop_at_entry, error));
}
SBError SBTarget::Install() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBTarget, Install);
+
SBError sb_error;
TargetSP target_sp(GetSP());
if (target_sp) {
std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
sb_error.ref() = target_sp->Install(NULL);
}
- return sb_error;
+ return LLDB_RECORD_RESULT(sb_error);
}
SBProcess SBTarget::Launch(SBListener &listener, char const **argv,
const char *working_directory,
uint32_t launch_flags, // See LaunchFlags
bool stop_at_entry, lldb::SBError &error) {
+ LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, Launch,
+ (lldb::SBListener &, const char **, const char **,
+ const char *, const char *, const char *, const char *,
+ uint32_t, bool, lldb::SBError &),
+ listener, argv, envp, stdin_path, stdout_path, stderr_path,
+ working_directory, launch_flags, stop_at_entry, error);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBProcess sb_process;
error.SetErrorString("process attach is in progress");
else
error.SetErrorString("a process is already being debugged");
- return sb_process;
+ return LLDB_RECORD_RESULT(sb_process);
}
}
if (listener.IsValid()) {
error.SetErrorString("process is connected and already has a listener, "
"pass empty listener");
- return sb_process;
+ return LLDB_RECORD_RESULT(sb_process);
}
}
static_cast<void *>(sb_process.GetSP().get()),
error.GetCString());
- return sb_process;
+ return LLDB_RECORD_RESULT(sb_process);
}
SBProcess SBTarget::Launch(SBLaunchInfo &sb_launch_info, SBError &error) {
+ LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, Launch,
+ (lldb::SBLaunchInfo &, lldb::SBError &), sb_launch_info,
+ error);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBProcess sb_process;
error.SetErrorString("process attach is in progress");
else
error.SetErrorString("a process is already being debugged");
- return sb_process;
+ return LLDB_RECORD_RESULT(sb_process);
}
}
}
static_cast<void *>(target_sp.get()),
static_cast<void *>(sb_process.GetSP().get()));
- return sb_process;
+ return LLDB_RECORD_RESULT(sb_process);
}
lldb::SBProcess SBTarget::Attach(SBAttachInfo &sb_attach_info, SBError &error) {
+ LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, Attach,
+ (lldb::SBAttachInfo &, lldb::SBError &), sb_attach_info,
+ error);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBProcess sb_process;
static_cast<void *>(target_sp.get()),
error.GetCString());
}
- return sb_process;
+ return LLDB_RECORD_RESULT(sb_process);
}
}
}
static_cast<void *>(target_sp.get()),
static_cast<void *>(sb_process.GetSP().get()));
- return sb_process;
+ return LLDB_RECORD_RESULT(sb_process);
}
lldb::SBProcess SBTarget::AttachToProcessWithID(
SBListener &listener,
lldb::pid_t pid, // The process ID to attach to
SBError &error // An error explaining what went wrong if attach fails
- ) {
+) {
+ LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, AttachToProcessWithID,
+ (lldb::SBListener &, lldb::pid_t, lldb::SBError &),
+ listener, pid, error);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBProcess sb_process;
log->Printf("SBTarget(%p)::%s (...) => SBProcess(%p)",
static_cast<void *>(target_sp.get()), __FUNCTION__,
static_cast<void *>(sb_process.GetSP().get()));
- return sb_process;
+ return LLDB_RECORD_RESULT(sb_process);
}
lldb::SBProcess SBTarget::AttachToProcessWithName(
const char *name, // basename of process to attach to
bool wait_for, // if true wait for a new instance of "name" to be launched
SBError &error // An error explaining what went wrong if attach fails
- ) {
+) {
+ LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, AttachToProcessWithName,
+ (lldb::SBListener &, const char *, bool, lldb::SBError &),
+ listener, name, wait_for, error);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBProcess sb_process;
log->Printf("SBTarget(%p)::%s (...) => SBProcess(%p)",
static_cast<void *>(target_sp.get()), __FUNCTION__,
static_cast<void *>(sb_process.GetSP().get()));
- return sb_process;
+ return LLDB_RECORD_RESULT(sb_process);
}
lldb::SBProcess SBTarget::ConnectRemote(SBListener &listener, const char *url,
const char *plugin_name,
SBError &error) {
+ LLDB_RECORD_METHOD(
+ lldb::SBProcess, SBTarget, ConnectRemote,
+ (lldb::SBListener &, const char *, const char *, lldb::SBError &),
+ listener, url, plugin_name, error);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBProcess sb_process;
log->Printf("SBTarget(%p)::ConnectRemote (...) => SBProcess(%p)",
static_cast<void *>(target_sp.get()),
static_cast<void *>(process_sp.get()));
- return sb_process;
+ return LLDB_RECORD_RESULT(sb_process);
}
SBFileSpec SBTarget::GetExecutable() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBTarget, GetExecutable);
SBFileSpec exe_file_spec;
TargetSP target_sp(GetSP());
static_cast<const void *>(exe_file_spec.get()));
}
- return exe_file_spec;
+ return LLDB_RECORD_RESULT(exe_file_spec);
}
bool SBTarget::operator==(const SBTarget &rhs) const {
+ LLDB_RECORD_METHOD_CONST(bool, SBTarget, operator==,(const lldb::SBTarget &),
+ rhs);
+
return m_opaque_sp.get() == rhs.m_opaque_sp.get();
}
bool SBTarget::operator!=(const SBTarget &rhs) const {
+ LLDB_RECORD_METHOD_CONST(bool, SBTarget, operator!=,(const lldb::SBTarget &),
+ rhs);
+
return m_opaque_sp.get() != rhs.m_opaque_sp.get();
}
}
lldb::SBAddress SBTarget::ResolveLoadAddress(lldb::addr_t vm_addr) {
+ LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolveLoadAddress,
+ (lldb::addr_t), vm_addr);
+
lldb::SBAddress sb_addr;
Address &addr = sb_addr.ref();
TargetSP target_sp(GetSP());
if (target_sp) {
std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
if (target_sp->ResolveLoadAddress(vm_addr, addr))
- return sb_addr;
+ return LLDB_RECORD_RESULT(sb_addr);
}
// We have a load address that isn't in a section, just return an address
// with the offset filled in (the address) and the section set to NULL
addr.SetRawAddress(vm_addr);
- return sb_addr;
+ return LLDB_RECORD_RESULT(sb_addr);
}
lldb::SBAddress SBTarget::ResolveFileAddress(lldb::addr_t file_addr) {
+ LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolveFileAddress,
+ (lldb::addr_t), file_addr);
+
lldb::SBAddress sb_addr;
Address &addr = sb_addr.ref();
TargetSP target_sp(GetSP());
if (target_sp) {
std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
if (target_sp->ResolveFileAddress(file_addr, addr))
- return sb_addr;
+ return LLDB_RECORD_RESULT(sb_addr);
}
addr.SetRawAddress(file_addr);
- return sb_addr;
+ return LLDB_RECORD_RESULT(sb_addr);
}
lldb::SBAddress SBTarget::ResolvePastLoadAddress(uint32_t stop_id,
lldb::addr_t vm_addr) {
+ LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolvePastLoadAddress,
+ (uint32_t, lldb::addr_t), stop_id, vm_addr);
+
lldb::SBAddress sb_addr;
Address &addr = sb_addr.ref();
TargetSP target_sp(GetSP());
if (target_sp) {
std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
if (target_sp->ResolveLoadAddress(vm_addr, addr))
- return sb_addr;
+ return LLDB_RECORD_RESULT(sb_addr);
}
// We have a load address that isn't in a section, just return an address
// with the offset filled in (the address) and the section set to NULL
addr.SetRawAddress(vm_addr);
- return sb_addr;
+ return LLDB_RECORD_RESULT(sb_addr);
}
SBSymbolContext
SBTarget::ResolveSymbolContextForAddress(const SBAddress &addr,
uint32_t resolve_scope) {
+ LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBTarget,
+ ResolveSymbolContextForAddress,
+ (const lldb::SBAddress &, uint32_t), addr, resolve_scope);
+
SBSymbolContext sc;
SymbolContextItem scope = static_cast<SymbolContextItem>(resolve_scope);
if (addr.IsValid()) {
target_sp->GetImages().ResolveSymbolContextForAddress(addr.ref(), scope,
sc.ref());
}
- return sc;
+ return LLDB_RECORD_RESULT(sc);
}
size_t SBTarget::ReadMemory(const SBAddress addr, void *buf, size_t size,
SBBreakpoint SBTarget::BreakpointCreateByLocation(const char *file,
uint32_t line) {
- return SBBreakpoint(
- BreakpointCreateByLocation(SBFileSpec(file, false), line));
+ LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
+ (const char *, uint32_t), file, line);
+
+ return LLDB_RECORD_RESULT(
+ SBBreakpoint(BreakpointCreateByLocation(SBFileSpec(file, false), line)));
}
SBBreakpoint
SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec,
uint32_t line) {
- return BreakpointCreateByLocation(sb_file_spec, line, 0);
+ LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
+ (const lldb::SBFileSpec &, uint32_t), sb_file_spec, line);
+
+ return LLDB_RECORD_RESULT(BreakpointCreateByLocation(sb_file_spec, line, 0));
}
SBBreakpoint
SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec,
uint32_t line, lldb::addr_t offset) {
+ LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
+ (const lldb::SBFileSpec &, uint32_t, lldb::addr_t),
+ sb_file_spec, line, offset);
+
SBFileSpecList empty_list;
- return BreakpointCreateByLocation(sb_file_spec, line, offset, empty_list);
+ return LLDB_RECORD_RESULT(
+ BreakpointCreateByLocation(sb_file_spec, line, offset, empty_list));
}
SBBreakpoint
SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec,
uint32_t line, lldb::addr_t offset,
SBFileSpecList &sb_module_list) {
- return BreakpointCreateByLocation(sb_file_spec, line, 0, offset,
- sb_module_list);
+ LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
+ (const lldb::SBFileSpec &, uint32_t, lldb::addr_t,
+ lldb::SBFileSpecList &),
+ sb_file_spec, line, offset, sb_module_list);
+
+ return LLDB_RECORD_RESULT(BreakpointCreateByLocation(sb_file_spec, line, 0,
+ offset, sb_module_list));
}
SBBreakpoint SBTarget::BreakpointCreateByLocation(
const SBFileSpec &sb_file_spec, uint32_t line, uint32_t column,
lldb::addr_t offset, SBFileSpecList &sb_module_list) {
+ LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
+ (const lldb::SBFileSpec &, uint32_t, uint32_t,
+ lldb::addr_t, lldb::SBFileSpecList &),
+ sb_file_spec, line, column, offset, sb_module_list);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBBreakpoint sb_bp;
static_cast<void *>(sb_bp.GetSP().get()), sstr.GetData());
}
- return sb_bp;
+ return LLDB_RECORD_RESULT(sb_bp);
}
SBBreakpoint SBTarget::BreakpointCreateByName(const char *symbol_name,
const char *module_name) {
+ LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
+ (const char *, const char *), symbol_name, module_name);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBBreakpoint sb_bp;
static_cast<void *>(target_sp.get()), symbol_name, module_name,
static_cast<void *>(sb_bp.GetSP().get()));
- return sb_bp;
+ return LLDB_RECORD_RESULT(sb_bp);
}
lldb::SBBreakpoint
SBTarget::BreakpointCreateByName(const char *symbol_name,
const SBFileSpecList &module_list,
const SBFileSpecList &comp_unit_list) {
+ LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
+ (const char *, const lldb::SBFileSpecList &,
+ const lldb::SBFileSpecList &),
+ symbol_name, module_list, comp_unit_list);
+
lldb::FunctionNameType name_type_mask = eFunctionNameTypeAuto;
- return BreakpointCreateByName(symbol_name, name_type_mask,
- eLanguageTypeUnknown, module_list,
- comp_unit_list);
+ return LLDB_RECORD_RESULT(
+ BreakpointCreateByName(symbol_name, name_type_mask, eLanguageTypeUnknown,
+ module_list, comp_unit_list));
}
lldb::SBBreakpoint SBTarget::BreakpointCreateByName(
const char *symbol_name, uint32_t name_type_mask,
const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) {
- return BreakpointCreateByName(symbol_name, name_type_mask,
- eLanguageTypeUnknown, module_list,
- comp_unit_list);
+ LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
+ (const char *, uint32_t, const lldb::SBFileSpecList &,
+ const lldb::SBFileSpecList &),
+ symbol_name, name_type_mask, module_list, comp_unit_list);
+
+ return LLDB_RECORD_RESULT(
+ BreakpointCreateByName(symbol_name, name_type_mask, eLanguageTypeUnknown,
+ module_list, comp_unit_list));
}
lldb::SBBreakpoint SBTarget::BreakpointCreateByName(
const char *symbol_name, uint32_t name_type_mask,
LanguageType symbol_language, const SBFileSpecList &module_list,
const SBFileSpecList &comp_unit_list) {
+ LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
+ (const char *, uint32_t, lldb::LanguageType,
+ const lldb::SBFileSpecList &,
+ const lldb::SBFileSpecList &),
+ symbol_name, name_type_mask, symbol_language, module_list,
+ comp_unit_list);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBBreakpoint sb_bp;
static_cast<void *>(target_sp.get()), symbol_name,
name_type_mask, static_cast<void *>(sb_bp.GetSP().get()));
- return sb_bp;
+ return LLDB_RECORD_RESULT(sb_bp);
}
lldb::SBBreakpoint SBTarget::BreakpointCreateByNames(
const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask,
const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) {
- return BreakpointCreateByNames(symbol_names, num_names, name_type_mask,
- eLanguageTypeUnknown, module_list,
- comp_unit_list);
+ LLDB_RECORD_METHOD(
+ lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
+ (const char **, uint32_t, uint32_t, const lldb::SBFileSpecList &,
+ const lldb::SBFileSpecList &),
+ symbol_names, num_names, name_type_mask, module_list, comp_unit_list);
+
+ return LLDB_RECORD_RESULT(BreakpointCreateByNames(
+ symbol_names, num_names, name_type_mask, eLanguageTypeUnknown,
+ module_list, comp_unit_list));
}
lldb::SBBreakpoint SBTarget::BreakpointCreateByNames(
const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask,
LanguageType symbol_language, const SBFileSpecList &module_list,
const SBFileSpecList &comp_unit_list) {
- return BreakpointCreateByNames(symbol_names, num_names, name_type_mask,
- eLanguageTypeUnknown, 0, module_list,
- comp_unit_list);
+ LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
+ (const char **, uint32_t, uint32_t, lldb::LanguageType,
+ const lldb::SBFileSpecList &,
+ const lldb::SBFileSpecList &),
+ symbol_names, num_names, name_type_mask, symbol_language,
+ module_list, comp_unit_list);
+
+ return LLDB_RECORD_RESULT(BreakpointCreateByNames(
+ symbol_names, num_names, name_type_mask, eLanguageTypeUnknown, 0,
+ module_list, comp_unit_list));
}
lldb::SBBreakpoint SBTarget::BreakpointCreateByNames(
const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask,
LanguageType symbol_language, lldb::addr_t offset,
const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) {
+ LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
+ (const char **, uint32_t, uint32_t, lldb::LanguageType,
+ lldb::addr_t, const lldb::SBFileSpecList &,
+ const lldb::SBFileSpecList &),
+ symbol_names, num_names, name_type_mask, symbol_language,
+ offset, module_list, comp_unit_list);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBBreakpoint sb_bp;
static_cast<void *>(sb_bp.GetSP().get()));
}
- return sb_bp;
+ return LLDB_RECORD_RESULT(sb_bp);
}
SBBreakpoint SBTarget::BreakpointCreateByRegex(const char *symbol_name_regex,
const char *module_name) {
+ LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
+ (const char *, const char *), symbol_name_regex,
+ module_name);
+
SBFileSpecList module_spec_list;
SBFileSpecList comp_unit_list;
if (module_name && module_name[0]) {
module_spec_list.Append(FileSpec(module_name));
}
- return BreakpointCreateByRegex(symbol_name_regex, eLanguageTypeUnknown,
- module_spec_list, comp_unit_list);
+ return LLDB_RECORD_RESULT(
+ BreakpointCreateByRegex(symbol_name_regex, eLanguageTypeUnknown,
+ module_spec_list, comp_unit_list));
}
lldb::SBBreakpoint
SBTarget::BreakpointCreateByRegex(const char *symbol_name_regex,
const SBFileSpecList &module_list,
const SBFileSpecList &comp_unit_list) {
- return BreakpointCreateByRegex(symbol_name_regex, eLanguageTypeUnknown,
- module_list, comp_unit_list);
+ LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
+ (const char *, const lldb::SBFileSpecList &,
+ const lldb::SBFileSpecList &),
+ symbol_name_regex, module_list, comp_unit_list);
+
+ return LLDB_RECORD_RESULT(BreakpointCreateByRegex(
+ symbol_name_regex, eLanguageTypeUnknown, module_list, comp_unit_list));
}
lldb::SBBreakpoint SBTarget::BreakpointCreateByRegex(
const char *symbol_name_regex, LanguageType symbol_language,
const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) {
+ LLDB_RECORD_METHOD(
+ lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
+ (const char *, lldb::LanguageType, const lldb::SBFileSpecList &,
+ const lldb::SBFileSpecList &),
+ symbol_name_regex, symbol_language, module_list, comp_unit_list);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBBreakpoint sb_bp;
static_cast<void *>(target_sp.get()), symbol_name_regex,
static_cast<void *>(sb_bp.GetSP().get()));
- return sb_bp;
+ return LLDB_RECORD_RESULT(sb_bp);
}
SBBreakpoint SBTarget::BreakpointCreateByAddress(addr_t address) {
+ LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByAddress,
+ (lldb::addr_t), address);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBBreakpoint sb_bp;
static_cast<uint64_t>(address),
static_cast<void *>(sb_bp.GetSP().get()));
- return sb_bp;
+ return LLDB_RECORD_RESULT(sb_bp);
}
SBBreakpoint SBTarget::BreakpointCreateBySBAddress(SBAddress &sb_address) {
+ LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateBySBAddress,
+ (lldb::SBAddress &), sb_address);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBBreakpoint sb_bp;
log->Printf("SBTarget(%p)::BreakpointCreateBySBAddress called with "
"invalid address",
static_cast<void *>(target_sp.get()));
- return sb_bp;
+ return LLDB_RECORD_RESULT(sb_bp);
}
if (target_sp) {
static_cast<void *>(sb_bp.GetSP().get()));
}
- return sb_bp;
+ return LLDB_RECORD_RESULT(sb_bp);
}
lldb::SBBreakpoint
SBTarget::BreakpointCreateBySourceRegex(const char *source_regex,
const lldb::SBFileSpec &source_file,
const char *module_name) {
+ LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget,
+ BreakpointCreateBySourceRegex,
+ (const char *, const lldb::SBFileSpec &, const char *),
+ source_regex, source_file, module_name);
+
SBFileSpecList module_spec_list;
if (module_name && module_name[0]) {
source_file_list.Append(source_file);
}
- return BreakpointCreateBySourceRegex(source_regex, module_spec_list,
- source_file_list);
+ return LLDB_RECORD_RESULT(BreakpointCreateBySourceRegex(
+ source_regex, module_spec_list, source_file_list));
}
lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex(
const char *source_regex, const SBFileSpecList &module_list,
const lldb::SBFileSpecList &source_file_list) {
- return BreakpointCreateBySourceRegex(source_regex, module_list,
- source_file_list, SBStringList());
+ LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget,
+ BreakpointCreateBySourceRegex,
+ (const char *, const lldb::SBFileSpecList &,
+ const lldb::SBFileSpecList &),
+ source_regex, module_list, source_file_list);
+
+ return LLDB_RECORD_RESULT(BreakpointCreateBySourceRegex(
+ source_regex, module_list, source_file_list, SBStringList()));
}
lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex(
const char *source_regex, const SBFileSpecList &module_list,
const lldb::SBFileSpecList &source_file_list,
const SBStringList &func_names) {
+ LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget,
+ BreakpointCreateBySourceRegex,
+ (const char *, const lldb::SBFileSpecList &,
+ const lldb::SBFileSpecList &, const lldb::SBStringList &),
+ source_regex, module_list, source_file_list, func_names);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBBreakpoint sb_bp;
static_cast<void *>(target_sp.get()), source_regex,
static_cast<void *>(sb_bp.GetSP().get()));
- return sb_bp;
+ return LLDB_RECORD_RESULT(sb_bp);
}
lldb::SBBreakpoint
SBTarget::BreakpointCreateForException(lldb::LanguageType language,
bool catch_bp, bool throw_bp) {
+ LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateForException,
+ (lldb::LanguageType, bool, bool), language, catch_bp,
+ throw_bp);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBBreakpoint sb_bp;
catch_bp ? "on" : "off", throw_bp ? "on" : "off",
static_cast<void *>(sb_bp.GetSP().get()));
- return sb_bp;
+ return LLDB_RECORD_RESULT(sb_bp);
}
-lldb::SBBreakpoint
-SBTarget::BreakpointCreateFromScript(const char *class_name,
- SBStructuredData &extra_args,
- const SBFileSpecList &module_list,
- const SBFileSpecList &file_list,
- bool request_hardware)
-{
+lldb::SBBreakpoint SBTarget::BreakpointCreateFromScript(
+ const char *class_name, SBStructuredData &extra_args,
+ const SBFileSpecList &module_list, const SBFileSpecList &file_list,
+ bool request_hardware) {
+ LLDB_RECORD_METHOD(
+ lldb::SBBreakpoint, SBTarget, BreakpointCreateFromScript,
+ (const char *, lldb::SBStructuredData &, const lldb::SBFileSpecList &,
+ const lldb::SBFileSpecList &, bool),
+ class_name, extra_args, module_list, file_list, request_hardware);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBBreakpoint sb_bp;
class_name,
static_cast<void *>(sb_bp.GetSP().get()));
- return sb_bp;
+ return LLDB_RECORD_RESULT(sb_bp);
}
-
uint32_t SBTarget::GetNumBreakpoints() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumBreakpoints);
+
TargetSP target_sp(GetSP());
if (target_sp) {
// The breakpoint list is thread safe, no need to lock
}
SBBreakpoint SBTarget::GetBreakpointAtIndex(uint32_t idx) const {
+ LLDB_RECORD_METHOD_CONST(lldb::SBBreakpoint, SBTarget, GetBreakpointAtIndex,
+ (uint32_t), idx);
+
SBBreakpoint sb_breakpoint;
TargetSP target_sp(GetSP());
if (target_sp) {
// The breakpoint list is thread safe, no need to lock
sb_breakpoint = target_sp->GetBreakpointList().GetBreakpointAtIndex(idx);
}
- return sb_breakpoint;
+ return LLDB_RECORD_RESULT(sb_breakpoint);
}
bool SBTarget::BreakpointDelete(break_id_t bp_id) {
+ LLDB_RECORD_METHOD(bool, SBTarget, BreakpointDelete, (lldb::break_id_t),
+ bp_id);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
bool result = false;
}
SBBreakpoint SBTarget::FindBreakpointByID(break_id_t bp_id) {
+ LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, FindBreakpointByID,
+ (lldb::break_id_t), bp_id);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBBreakpoint sb_breakpoint;
static_cast<void *>(target_sp.get()), static_cast<uint32_t>(bp_id),
static_cast<void *>(sb_breakpoint.GetSP().get()));
- return sb_breakpoint;
+ return LLDB_RECORD_RESULT(sb_breakpoint);
}
bool SBTarget::FindBreakpointsByName(const char *name,
SBBreakpointList &bkpts) {
+ LLDB_RECORD_METHOD(bool, SBTarget, FindBreakpointsByName,
+ (const char *, lldb::SBBreakpointList &), name, bkpts);
+
TargetSP target_sp(GetSP());
if (target_sp) {
std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
return true;
}
-void SBTarget::GetBreakpointNames(SBStringList &names)
-{
+void SBTarget::GetBreakpointNames(SBStringList &names) {
+ LLDB_RECORD_METHOD(void, SBTarget, GetBreakpointNames, (lldb::SBStringList &),
+ names);
+
names.Clear();
TargetSP target_sp(GetSP());
}
}
-void SBTarget::DeleteBreakpointName(const char *name)
-{
+void SBTarget::DeleteBreakpointName(const char *name) {
+ LLDB_RECORD_METHOD(void, SBTarget, DeleteBreakpointName, (const char *),
+ name);
+
TargetSP target_sp(GetSP());
if (target_sp) {
std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
}
bool SBTarget::EnableAllBreakpoints() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, EnableAllBreakpoints);
+
TargetSP target_sp(GetSP());
if (target_sp) {
std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
}
bool SBTarget::DisableAllBreakpoints() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DisableAllBreakpoints);
+
TargetSP target_sp(GetSP());
if (target_sp) {
std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
}
bool SBTarget::DeleteAllBreakpoints() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DeleteAllBreakpoints);
+
TargetSP target_sp(GetSP());
if (target_sp) {
std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
lldb::SBError SBTarget::BreakpointsCreateFromFile(SBFileSpec &source_file,
SBBreakpointList &new_bps) {
+ LLDB_RECORD_METHOD(lldb::SBError, SBTarget, BreakpointsCreateFromFile,
+ (lldb::SBFileSpec &, lldb::SBBreakpointList &),
+ source_file, new_bps);
+
SBStringList empty_name_list;
- return BreakpointsCreateFromFile(source_file, empty_name_list, new_bps);
+ return LLDB_RECORD_RESULT(
+ BreakpointsCreateFromFile(source_file, empty_name_list, new_bps));
}
lldb::SBError SBTarget::BreakpointsCreateFromFile(SBFileSpec &source_file,
SBStringList &matching_names,
SBBreakpointList &new_bps) {
+ LLDB_RECORD_METHOD(
+ lldb::SBError, SBTarget, BreakpointsCreateFromFile,
+ (lldb::SBFileSpec &, lldb::SBStringList &, lldb::SBBreakpointList &),
+ source_file, matching_names, new_bps);
+
SBError sberr;
TargetSP target_sp(GetSP());
if (!target_sp) {
sberr.SetErrorString(
"BreakpointCreateFromFile called with invalid target.");
- return sberr;
+ return LLDB_RECORD_RESULT(sberr);
}
std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
sberr.ref() = target_sp->CreateBreakpointsFromFile(source_file.ref(),
name_vector, bp_ids);
if (sberr.Fail())
- return sberr;
+ return LLDB_RECORD_RESULT(sberr);
size_t num_bkpts = bp_ids.GetSize();
for (size_t i = 0; i < num_bkpts; i++) {
BreakpointID bp_id = bp_ids.GetBreakpointIDAtIndex(i);
new_bps.AppendByID(bp_id.GetBreakpointID());
}
- return sberr;
+ return LLDB_RECORD_RESULT(sberr);
}
lldb::SBError SBTarget::BreakpointsWriteToFile(SBFileSpec &dest_file) {
+ LLDB_RECORD_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile,
+ (lldb::SBFileSpec &), dest_file);
+
SBError sberr;
TargetSP target_sp(GetSP());
if (!target_sp) {
sberr.SetErrorString("BreakpointWriteToFile called with invalid target.");
- return sberr;
+ return LLDB_RECORD_RESULT(sberr);
}
SBBreakpointList bkpt_list(*this);
- return BreakpointsWriteToFile(dest_file, bkpt_list);
+ return LLDB_RECORD_RESULT(BreakpointsWriteToFile(dest_file, bkpt_list));
}
lldb::SBError SBTarget::BreakpointsWriteToFile(SBFileSpec &dest_file,
SBBreakpointList &bkpt_list,
bool append) {
+ LLDB_RECORD_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile,
+ (lldb::SBFileSpec &, lldb::SBBreakpointList &, bool),
+ dest_file, bkpt_list, append);
+
SBError sberr;
TargetSP target_sp(GetSP());
if (!target_sp) {
sberr.SetErrorString("BreakpointWriteToFile called with invalid target.");
- return sberr;
+ return LLDB_RECORD_RESULT(sberr);
}
std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
bkpt_list.CopyToBreakpointIDList(bp_id_list);
sberr.ref() = target_sp->SerializeBreakpointsToFile(dest_file.ref(),
bp_id_list, append);
- return sberr;
+ return LLDB_RECORD_RESULT(sberr);
}
uint32_t SBTarget::GetNumWatchpoints() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumWatchpoints);
+
TargetSP target_sp(GetSP());
if (target_sp) {
// The watchpoint list is thread safe, no need to lock
}
SBWatchpoint SBTarget::GetWatchpointAtIndex(uint32_t idx) const {
+ LLDB_RECORD_METHOD_CONST(lldb::SBWatchpoint, SBTarget, GetWatchpointAtIndex,
+ (uint32_t), idx);
+
SBWatchpoint sb_watchpoint;
TargetSP target_sp(GetSP());
if (target_sp) {
// The watchpoint list is thread safe, no need to lock
sb_watchpoint.SetSP(target_sp->GetWatchpointList().GetByIndex(idx));
}
- return sb_watchpoint;
+ return LLDB_RECORD_RESULT(sb_watchpoint);
}
bool SBTarget::DeleteWatchpoint(watch_id_t wp_id) {
+ LLDB_RECORD_METHOD(bool, SBTarget, DeleteWatchpoint, (lldb::watch_id_t),
+ wp_id);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
bool result = false;
}
SBWatchpoint SBTarget::FindWatchpointByID(lldb::watch_id_t wp_id) {
+ LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBTarget, FindWatchpointByID,
+ (lldb::watch_id_t), wp_id);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBWatchpoint sb_watchpoint;
static_cast<void *>(target_sp.get()), static_cast<uint32_t>(wp_id),
static_cast<void *>(watchpoint_sp.get()));
- return sb_watchpoint;
+ return LLDB_RECORD_RESULT(sb_watchpoint);
}
lldb::SBWatchpoint SBTarget::WatchAddress(lldb::addr_t addr, size_t size,
bool read, bool write,
SBError &error) {
+ LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBTarget, WatchAddress,
+ (lldb::addr_t, size_t, bool, bool, lldb::SBError &), addr,
+ size, read, write, error);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBWatchpoint sb_watchpoint;
if (watch_type == 0) {
error.SetErrorString(
"Can't create a watchpoint that is neither read nor write.");
- return sb_watchpoint;
+ return LLDB_RECORD_RESULT(sb_watchpoint);
}
// Target::CreateWatchpoint() is thread safe.
static_cast<uint32_t>(size),
static_cast<void *>(watchpoint_sp.get()));
- return sb_watchpoint;
+ return LLDB_RECORD_RESULT(sb_watchpoint);
}
bool SBTarget::EnableAllWatchpoints() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, EnableAllWatchpoints);
+
TargetSP target_sp(GetSP());
if (target_sp) {
std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
}
bool SBTarget::DisableAllWatchpoints() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DisableAllWatchpoints);
+
TargetSP target_sp(GetSP());
if (target_sp) {
std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
SBValue SBTarget::CreateValueFromAddress(const char *name, SBAddress addr,
SBType type) {
+ LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, CreateValueFromAddress,
+ (const char *, lldb::SBAddress, lldb::SBType), name, addr,
+ type);
+
SBValue sb_value;
lldb::ValueObjectSP new_value_sp;
if (IsValid() && name && *name && addr.IsValid() && type.IsValid()) {
log->Printf("SBTarget(%p)::CreateValueFromAddress => NULL",
static_cast<void *>(m_opaque_sp.get()));
}
- return sb_value;
+ return LLDB_RECORD_RESULT(sb_value);
}
lldb::SBValue SBTarget::CreateValueFromData(const char *name, lldb::SBData data,
lldb::SBType type) {
+ LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, CreateValueFromData,
+ (const char *, lldb::SBData, lldb::SBType), name, data,
+ type);
+
SBValue sb_value;
lldb::ValueObjectSP new_value_sp;
if (IsValid() && name && *name && data.IsValid() && type.IsValid()) {
log->Printf("SBTarget(%p)::CreateValueFromData => NULL",
static_cast<void *>(m_opaque_sp.get()));
}
- return sb_value;
+ return LLDB_RECORD_RESULT(sb_value);
}
lldb::SBValue SBTarget::CreateValueFromExpression(const char *name,
const char *expr) {
+ LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, CreateValueFromExpression,
+ (const char *, const char *), name, expr);
+
SBValue sb_value;
lldb::ValueObjectSP new_value_sp;
if (IsValid() && name && *name && expr && *expr) {
log->Printf("SBTarget(%p)::CreateValueFromExpression => NULL",
static_cast<void *>(m_opaque_sp.get()));
}
- return sb_value;
+ return LLDB_RECORD_RESULT(sb_value);
}
bool SBTarget::DeleteAllWatchpoints() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DeleteAllWatchpoints);
+
TargetSP target_sp(GetSP());
if (target_sp) {
std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
void SBTarget::AppendImageSearchPath(const char *from, const char *to,
lldb::SBError &error) {
+ LLDB_RECORD_METHOD(void, SBTarget, AppendImageSearchPath,
+ (const char *, const char *, lldb::SBError &), from, to,
+ error);
+
TargetSP target_sp(GetSP());
if (!target_sp)
return error.SetErrorString("invalid target");
lldb::SBModule SBTarget::AddModule(const char *path, const char *triple,
const char *uuid_cstr) {
- return AddModule(path, triple, uuid_cstr, NULL);
+ LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule,
+ (const char *, const char *, const char *), path, triple,
+ uuid_cstr);
+
+ return LLDB_RECORD_RESULT(AddModule(path, triple, uuid_cstr, NULL));
}
lldb::SBModule SBTarget::AddModule(const char *path, const char *triple,
const char *uuid_cstr, const char *symfile) {
+ LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule,
+ (const char *, const char *, const char *, const char *),
+ path, triple, uuid_cstr, symfile);
+
lldb::SBModule sb_module;
TargetSP target_sp(GetSP());
if (target_sp) {
sb_module.SetSP(target_sp->GetSharedModule(module_spec));
}
- return sb_module;
+ return LLDB_RECORD_RESULT(sb_module);
}
lldb::SBModule SBTarget::AddModule(const SBModuleSpec &module_spec) {
+ LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule,
+ (const lldb::SBModuleSpec &), module_spec);
+
lldb::SBModule sb_module;
TargetSP target_sp(GetSP());
if (target_sp)
sb_module.SetSP(target_sp->GetSharedModule(*module_spec.m_opaque_up));
- return sb_module;
+ return LLDB_RECORD_RESULT(sb_module);
}
bool SBTarget::AddModule(lldb::SBModule &module) {
+ LLDB_RECORD_METHOD(bool, SBTarget, AddModule, (lldb::SBModule &), module);
+
TargetSP target_sp(GetSP());
if (target_sp) {
target_sp->GetImages().AppendIfNeeded(module.GetSP());
}
uint32_t SBTarget::GetNumModules() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumModules);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
uint32_t num = 0;
}
void SBTarget::Clear() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBTarget, Clear);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
}
SBModule SBTarget::FindModule(const SBFileSpec &sb_file_spec) {
+ LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, FindModule,
+ (const lldb::SBFileSpec &), sb_file_spec);
+
SBModule sb_module;
TargetSP target_sp(GetSP());
if (target_sp && sb_file_spec.IsValid()) {
// The module list is thread safe, no need to lock
sb_module.SetSP(target_sp->GetImages().FindFirstModule(module_spec));
}
- return sb_module;
+ return LLDB_RECORD_RESULT(sb_module);
}
-SBSymbolContextList
-SBTarget::FindCompileUnits(const SBFileSpec &sb_file_spec) {
+SBSymbolContextList SBTarget::FindCompileUnits(const SBFileSpec &sb_file_spec) {
+ LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindCompileUnits,
+ (const lldb::SBFileSpec &), sb_file_spec);
+
SBSymbolContextList sb_sc_list;
const TargetSP target_sp(GetSP());
if (target_sp && sb_file_spec.IsValid()) {
target_sp->GetImages().FindCompileUnits(*sb_file_spec,
append, *sb_sc_list);
}
- return sb_sc_list;
+ return LLDB_RECORD_RESULT(sb_sc_list);
}
lldb::ByteOrder SBTarget::GetByteOrder() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::ByteOrder, SBTarget, GetByteOrder);
+
TargetSP target_sp(GetSP());
if (target_sp)
return target_sp->GetArchitecture().GetByteOrder();
}
const char *SBTarget::GetTriple() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTarget, GetTriple);
+
TargetSP target_sp(GetSP());
if (target_sp) {
std::string triple(target_sp->GetArchitecture().GetTriple().str());
}
uint32_t SBTarget::GetDataByteSize() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTarget, GetDataByteSize);
+
TargetSP target_sp(GetSP());
if (target_sp) {
return target_sp->GetArchitecture().GetDataByteSize();
}
uint32_t SBTarget::GetCodeByteSize() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTarget, GetCodeByteSize);
+
TargetSP target_sp(GetSP());
if (target_sp) {
return target_sp->GetArchitecture().GetCodeByteSize();
}
uint32_t SBTarget::GetAddressByteSize() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTarget, GetAddressByteSize);
+
TargetSP target_sp(GetSP());
if (target_sp)
return target_sp->GetArchitecture().GetAddressByteSize();
}
SBModule SBTarget::GetModuleAtIndex(uint32_t idx) {
+ LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, GetModuleAtIndex, (uint32_t),
+ idx);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBModule sb_module;
static_cast<void *>(target_sp.get()), idx,
static_cast<void *>(module_sp.get()));
- return sb_module;
+ return LLDB_RECORD_RESULT(sb_module);
}
bool SBTarget::RemoveModule(lldb::SBModule module) {
+ LLDB_RECORD_METHOD(bool, SBTarget, RemoveModule, (lldb::SBModule), module);
+
TargetSP target_sp(GetSP());
if (target_sp)
return target_sp->GetImages().Remove(module.GetSP());
}
SBBroadcaster SBTarget::GetBroadcaster() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBTarget,
+ GetBroadcaster);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
TargetSP target_sp(GetSP());
static_cast<void *>(target_sp.get()),
static_cast<void *>(broadcaster.get()));
- return broadcaster;
+ return LLDB_RECORD_RESULT(broadcaster);
}
bool SBTarget::GetDescription(SBStream &description,
lldb::DescriptionLevel description_level) {
+ LLDB_RECORD_METHOD(bool, SBTarget, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel), description,
+ description_level);
+
Stream &strm = description.ref();
TargetSP target_sp(GetSP());
lldb::SBSymbolContextList SBTarget::FindFunctions(const char *name,
uint32_t name_type_mask) {
+ LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindFunctions,
+ (const char *, uint32_t), name, name_type_mask);
+
lldb::SBSymbolContextList sb_sc_list;
if (!name | !name[0])
- return sb_sc_list;
+ return LLDB_RECORD_RESULT(sb_sc_list);
TargetSP target_sp(GetSP());
if (!target_sp)
- return sb_sc_list;
+ return LLDB_RECORD_RESULT(sb_sc_list);
const bool symbols_ok = true;
const bool inlines_ok = true;
FunctionNameType mask = static_cast<FunctionNameType>(name_type_mask);
target_sp->GetImages().FindFunctions(ConstString(name), mask, symbols_ok,
inlines_ok, append, *sb_sc_list);
- return sb_sc_list;
+ return LLDB_RECORD_RESULT(sb_sc_list);
}
lldb::SBSymbolContextList SBTarget::FindGlobalFunctions(const char *name,
uint32_t max_matches,
MatchType matchtype) {
+ LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindGlobalFunctions,
+ (const char *, uint32_t, lldb::MatchType), name,
+ max_matches, matchtype);
+
lldb::SBSymbolContextList sb_sc_list;
if (name && name[0]) {
llvm::StringRef name_ref(name);
}
}
}
- return sb_sc_list;
+ return LLDB_RECORD_RESULT(sb_sc_list);
}
lldb::SBType SBTarget::FindFirstType(const char *typename_cstr) {
+ LLDB_RECORD_METHOD(lldb::SBType, SBTarget, FindFirstType, (const char *),
+ typename_cstr);
+
TargetSP target_sp(GetSP());
if (typename_cstr && typename_cstr[0] && target_sp) {
ConstString const_typename(typename_cstr);
TypeSP type_sp(
module_sp->FindFirstType(sc, const_typename, exact_match));
if (type_sp)
- return SBType(type_sp);
+ return LLDB_RECORD_RESULT(SBType(type_sp));
}
}
if (objc_decl_vendor->FindDecls(const_typename, true, 1, decls) > 0) {
if (CompilerType type = ClangASTContext::GetTypeForDecl(decls[0])) {
- return SBType(type);
+ return LLDB_RECORD_RESULT(SBType(type));
}
}
}
// No matches, search for basic typename matches
ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext();
if (clang_ast)
- return SBType(ClangASTContext::GetBasicType(clang_ast->getASTContext(),
- const_typename));
+ return LLDB_RECORD_RESULT(SBType(ClangASTContext::GetBasicType(
+ clang_ast->getASTContext(), const_typename)));
}
- return SBType();
+ return LLDB_RECORD_RESULT(SBType());
}
SBType SBTarget::GetBasicType(lldb::BasicType type) {
+ LLDB_RECORD_METHOD(lldb::SBType, SBTarget, GetBasicType, (lldb::BasicType),
+ type);
+
TargetSP target_sp(GetSP());
if (target_sp) {
ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext();
if (clang_ast)
- return SBType(
- ClangASTContext::GetBasicType(clang_ast->getASTContext(), type));
+ return LLDB_RECORD_RESULT(SBType(
+ ClangASTContext::GetBasicType(clang_ast->getASTContext(), type)));
}
- return SBType();
+ return LLDB_RECORD_RESULT(SBType());
}
lldb::SBTypeList SBTarget::FindTypes(const char *typename_cstr) {
+ LLDB_RECORD_METHOD(lldb::SBTypeList, SBTarget, FindTypes, (const char *),
+ typename_cstr);
+
SBTypeList sb_type_list;
TargetSP target_sp(GetSP());
if (typename_cstr && typename_cstr[0] && target_sp) {
clang_ast->getASTContext(), const_typename)));
}
}
- return sb_type_list;
+ return LLDB_RECORD_RESULT(sb_type_list);
}
SBValueList SBTarget::FindGlobalVariables(const char *name,
uint32_t max_matches) {
+ LLDB_RECORD_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables,
+ (const char *, uint32_t), name, max_matches);
+
SBValueList sb_value_list;
TargetSP target_sp(GetSP());
}
}
- return sb_value_list;
+ return LLDB_RECORD_RESULT(sb_value_list);
}
SBValueList SBTarget::FindGlobalVariables(const char *name,
uint32_t max_matches,
MatchType matchtype) {
+ LLDB_RECORD_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables,
+ (const char *, uint32_t, lldb::MatchType), name,
+ max_matches, matchtype);
+
SBValueList sb_value_list;
TargetSP target_sp(GetSP());
}
}
- return sb_value_list;
+ return LLDB_RECORD_RESULT(sb_value_list);
}
lldb::SBValue SBTarget::FindFirstGlobalVariable(const char *name) {
+ LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, FindFirstGlobalVariable,
+ (const char *), name);
+
SBValueList sb_value_list(FindGlobalVariables(name, 1));
if (sb_value_list.IsValid() && sb_value_list.GetSize() > 0)
- return sb_value_list.GetValueAtIndex(0);
- return SBValue();
+ return LLDB_RECORD_RESULT(sb_value_list.GetValueAtIndex(0));
+ return LLDB_RECORD_RESULT(SBValue());
}
SBSourceManager SBTarget::GetSourceManager() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSourceManager, SBTarget, GetSourceManager);
+
SBSourceManager source_manager(*this);
- return source_manager;
+ return LLDB_RECORD_RESULT(source_manager);
}
lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr,
uint32_t count) {
- return ReadInstructions(base_addr, count, NULL);
+ LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions,
+ (lldb::SBAddress, uint32_t), base_addr, count);
+
+ return LLDB_RECORD_RESULT(ReadInstructions(base_addr, count, NULL));
}
lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr,
uint32_t count,
const char *flavor_string) {
+ LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions,
+ (lldb::SBAddress, uint32_t, const char *), base_addr,
+ count, flavor_string);
+
SBInstructionList sb_instructions;
TargetSP target_sp(GetSP());
}
}
- return sb_instructions;
+ return LLDB_RECORD_RESULT(sb_instructions);
}
lldb::SBInstructionList SBTarget::GetInstructions(lldb::SBAddress base_addr,
SBError SBTarget::SetSectionLoadAddress(lldb::SBSection section,
lldb::addr_t section_base_addr) {
+ LLDB_RECORD_METHOD(lldb::SBError, SBTarget, SetSectionLoadAddress,
+ (lldb::SBSection, lldb::addr_t), section,
+ section_base_addr);
+
SBError sb_error;
TargetSP target_sp(GetSP());
if (target_sp) {
} else {
sb_error.SetErrorString("invalid target");
}
- return sb_error;
+ return LLDB_RECORD_RESULT(sb_error);
}
SBError SBTarget::ClearSectionLoadAddress(lldb::SBSection section) {
+ LLDB_RECORD_METHOD(lldb::SBError, SBTarget, ClearSectionLoadAddress,
+ (lldb::SBSection), section);
+
SBError sb_error;
TargetSP target_sp(GetSP());
} else {
sb_error.SetErrorStringWithFormat("invalid target");
}
- return sb_error;
+ return LLDB_RECORD_RESULT(sb_error);
}
SBError SBTarget::SetModuleLoadAddress(lldb::SBModule module,
int64_t slide_offset) {
+ LLDB_RECORD_METHOD(lldb::SBError, SBTarget, SetModuleLoadAddress,
+ (lldb::SBModule, int64_t), module, slide_offset);
+
SBError sb_error;
TargetSP target_sp(GetSP());
} else {
sb_error.SetErrorStringWithFormat("invalid target");
}
- return sb_error;
+ return LLDB_RECORD_RESULT(sb_error);
}
SBError SBTarget::ClearModuleLoadAddress(lldb::SBModule module) {
+ LLDB_RECORD_METHOD(lldb::SBError, SBTarget, ClearModuleLoadAddress,
+ (lldb::SBModule), module);
+
SBError sb_error;
char path[PATH_MAX];
} else {
sb_error.SetErrorStringWithFormat("invalid target");
}
- return sb_error;
+ return LLDB_RECORD_RESULT(sb_error);
}
lldb::SBSymbolContextList SBTarget::FindSymbols(const char *name,
lldb::SymbolType symbol_type) {
+ LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindSymbols,
+ (const char *, lldb::SymbolType), name, symbol_type);
+
SBSymbolContextList sb_sc_list;
if (name && name[0]) {
TargetSP target_sp(GetSP());
ConstString(name), symbol_type, *sb_sc_list, append);
}
}
- return sb_sc_list;
+ return LLDB_RECORD_RESULT(sb_sc_list);
}
lldb::SBValue SBTarget::EvaluateExpression(const char *expr) {
+ LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, EvaluateExpression,
+ (const char *), expr);
+
TargetSP target_sp(GetSP());
if (!target_sp)
- return SBValue();
+ return LLDB_RECORD_RESULT(SBValue());
SBExpressionOptions options;
lldb::DynamicValueType fetch_dynamic_value =
target_sp->GetPreferDynamicValue();
options.SetFetchDynamicValue(fetch_dynamic_value);
options.SetUnwindOnError(true);
- return EvaluateExpression(expr, options);
+ return LLDB_RECORD_RESULT(EvaluateExpression(expr, options));
}
lldb::SBValue SBTarget::EvaluateExpression(const char *expr,
const SBExpressionOptions &options) {
+ LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, EvaluateExpression,
+ (const char *, const lldb::SBExpressionOptions &), expr,
+ options);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
#if !defined(LLDB_DISABLE_PYTHON)
Log *expr_log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
if (log)
log->Printf(
"SBTarget::EvaluateExpression called with an empty expression");
- return expr_result;
+ return LLDB_RECORD_RESULT(expr_result);
}
std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
static_cast<void *>(expr_value_sp.get()), exe_results);
#endif
- return expr_result;
+ return LLDB_RECORD_RESULT(expr_result);
}
lldb::addr_t SBTarget::GetStackRedZoneSize() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBTarget, GetStackRedZoneSize);
+
TargetSP target_sp(GetSP());
if (target_sp) {
ABISP abi_sp;
}
lldb::SBLaunchInfo SBTarget::GetLaunchInfo() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBLaunchInfo, SBTarget, GetLaunchInfo);
+
lldb::SBLaunchInfo launch_info(NULL);
TargetSP target_sp(GetSP());
if (target_sp)
launch_info.set_ref(m_opaque_sp->GetProcessLaunchInfo());
- return launch_info;
+ return LLDB_RECORD_RESULT(launch_info);
}
void SBTarget::SetLaunchInfo(const lldb::SBLaunchInfo &launch_info) {
+ LLDB_RECORD_METHOD(void, SBTarget, SetLaunchInfo,
+ (const lldb::SBLaunchInfo &), launch_info);
+
TargetSP target_sp(GetSP());
if (target_sp)
m_opaque_sp->SetProcessLaunchInfo(launch_info.ref());
//===----------------------------------------------------------------------===//
#include "lldb/API/SBThread.h"
+#include "SBReproducerPrivate.h"
#include "Utils.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBDebugger.h"
using namespace lldb_private;
const char *SBThread::GetBroadcasterClassName() {
+ LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBThread,
+ GetBroadcasterClassName);
+
return Thread::GetStaticBroadcasterClass().AsCString();
}
//----------------------------------------------------------------------
// Constructors
//----------------------------------------------------------------------
-SBThread::SBThread() : m_opaque_sp(new ExecutionContextRef()) {}
+SBThread::SBThread() : m_opaque_sp(new ExecutionContextRef()) {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBThread);
+}
SBThread::SBThread(const ThreadSP &lldb_object_sp)
- : m_opaque_sp(new ExecutionContextRef(lldb_object_sp)) {}
+ : m_opaque_sp(new ExecutionContextRef(lldb_object_sp)) {
+ LLDB_RECORD_CONSTRUCTOR(SBThread, (const lldb::ThreadSP &), lldb_object_sp);
+}
SBThread::SBThread(const SBThread &rhs) : m_opaque_sp() {
+ LLDB_RECORD_CONSTRUCTOR(SBThread, (const lldb::SBThread &), rhs);
+
m_opaque_sp = clone(rhs.m_opaque_sp);
}
//----------------------------------------------------------------------
const lldb::SBThread &SBThread::operator=(const SBThread &rhs) {
+ LLDB_RECORD_METHOD(const lldb::SBThread &,
+ SBThread, operator=,(const lldb::SBThread &), rhs);
+
if (this != &rhs)
m_opaque_sp = clone(rhs.m_opaque_sp);
return *this;
SBThread::~SBThread() {}
lldb::SBQueue SBThread::GetQueue() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBQueue, SBThread, GetQueue);
+
SBQueue sb_queue;
QueueSP queue_sp;
std::unique_lock<std::recursive_mutex> lock;
static_cast<void *>(exe_ctx.GetThreadPtr()),
static_cast<void *>(queue_sp.get()));
- return sb_queue;
+ return LLDB_RECORD_RESULT(sb_queue);
}
bool SBThread::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThread, IsValid);
+
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
return false;
}
-void SBThread::Clear() { m_opaque_sp->Clear(); }
+void SBThread::Clear() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBThread, Clear);
+
+ m_opaque_sp->Clear();
+}
StopReason SBThread::GetStopReason() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::StopReason, SBThread, GetStopReason);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
StopReason reason = eStopReasonInvalid;
}
size_t SBThread::GetStopReasonDataCount() {
+ LLDB_RECORD_METHOD_NO_ARGS(size_t, SBThread, GetStopReasonDataCount);
+
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
}
uint64_t SBThread::GetStopReasonDataAtIndex(uint32_t idx) {
+ LLDB_RECORD_METHOD(uint64_t, SBThread, GetStopReasonDataAtIndex, (uint32_t),
+ idx);
+
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
}
bool SBThread::GetStopReasonExtendedInfoAsJSON(lldb::SBStream &stream) {
+ LLDB_RECORD_METHOD(bool, SBThread, GetStopReasonExtendedInfoAsJSON,
+ (lldb::SBStream &), stream);
+
Stream &strm = stream.ref();
std::unique_lock<std::recursive_mutex> lock;
SBThreadCollection
SBThread::GetStopReasonExtendedBacktraces(InstrumentationRuntimeType type) {
+ LLDB_RECORD_METHOD(lldb::SBThreadCollection, SBThread,
+ GetStopReasonExtendedBacktraces,
+ (lldb::InstrumentationRuntimeType), type);
+
ThreadCollectionSP threads;
threads = std::make_shared<ThreadCollection>();
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
if (!exe_ctx.HasThreadScope())
- return threads;
+ return LLDB_RECORD_RESULT(threads);
ProcessSP process_sp = exe_ctx.GetProcessSP();
StopInfoSP stop_info = exe_ctx.GetThreadPtr()->GetStopInfo();
StructuredData::ObjectSP info = stop_info->GetExtendedInfo();
if (!info)
- return threads;
+ return LLDB_RECORD_RESULT(threads);
- return process_sp->GetInstrumentationRuntime(type)
- ->GetBacktracesFromExtendedStopInfo(info);
+ return LLDB_RECORD_RESULT(process_sp->GetInstrumentationRuntime(type)
+ ->GetBacktracesFromExtendedStopInfo(info));
}
size_t SBThread::GetStopDescription(char *dst, size_t dst_len) {
+ LLDB_RECORD_METHOD(size_t, SBThread, GetStopDescription, (char *, size_t),
+ dst, dst_len);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
std::unique_lock<std::recursive_mutex> lock;
}
SBValue SBThread::GetStopReturnValue() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBThread, GetStopReturnValue);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
ValueObjectSP return_valobj_sp;
std::unique_lock<std::recursive_mutex> lock;
return_valobj_sp.get() ? return_valobj_sp->GetValueAsCString()
: "<no return value>");
- return SBValue(return_valobj_sp);
+ return LLDB_RECORD_RESULT(SBValue(return_valobj_sp));
}
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);
+
ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
if (thread_sp)
return thread_sp->GetID();
}
uint32_t SBThread::GetIndexID() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBThread, GetIndexID);
+
ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
if (thread_sp)
return thread_sp->GetIndexID();
}
const char *SBThread::GetName() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBThread, GetName);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
const char *name = NULL;
std::unique_lock<std::recursive_mutex> lock;
}
const char *SBThread::GetQueueName() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBThread, GetQueueName);
+
const char *name = NULL;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
}
lldb::queue_id_t SBThread::GetQueueID() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::queue_id_t, SBThread, GetQueueID);
+
queue_id_t id = LLDB_INVALID_QUEUE_ID;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
}
bool SBThread::GetInfoItemByPathAsString(const char *path, SBStream &strm) {
+ LLDB_RECORD_METHOD(bool, SBThread, GetInfoItemByPathAsString,
+ (const char *, lldb::SBStream &), path, strm);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
bool success = false;
std::unique_lock<std::recursive_mutex> lock;
}
void SBThread::StepOver(lldb::RunMode stop_other_threads) {
+ LLDB_RECORD_METHOD(void, SBThread, StepOver, (lldb::RunMode),
+ stop_other_threads);
+
SBError error; // Ignored
StepOver(stop_other_threads, error);
}
void SBThread::StepOver(lldb::RunMode stop_other_threads, SBError &error) {
+ LLDB_RECORD_METHOD(void, SBThread, StepOver, (lldb::RunMode, lldb::SBError &),
+ stop_other_threads, error);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
std::unique_lock<std::recursive_mutex> lock;
}
void SBThread::StepInto(lldb::RunMode stop_other_threads) {
+ LLDB_RECORD_METHOD(void, SBThread, StepInto, (lldb::RunMode),
+ stop_other_threads);
+
StepInto(NULL, 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);
+
SBError error; // Ignored
StepInto(target_name, LLDB_INVALID_LINE_NUMBER, error, stop_other_threads);
}
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);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
std::unique_lock<std::recursive_mutex> lock;
}
void SBThread::StepOut() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBThread, StepOut);
+
SBError error; // Ignored
StepOut(error);
}
void SBThread::StepOut(SBError &error) {
+ LLDB_RECORD_METHOD(void, SBThread, StepOut, (lldb::SBError &), error);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
std::unique_lock<std::recursive_mutex> lock;
}
void SBThread::StepOutOfFrame(SBFrame &sb_frame) {
+ LLDB_RECORD_METHOD(void, SBThread, StepOutOfFrame, (lldb::SBFrame &),
+ sb_frame);
+
SBError error; // Ignored
StepOutOfFrame(sb_frame, error);
}
void SBThread::StepOutOfFrame(SBFrame &sb_frame, SBError &error) {
+ LLDB_RECORD_METHOD(void, SBThread, StepOutOfFrame,
+ (lldb::SBFrame &, lldb::SBError &), sb_frame, error);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
std::unique_lock<std::recursive_mutex> lock;
}
void SBThread::StepInstruction(bool step_over) {
+ LLDB_RECORD_METHOD(void, SBThread, StepInstruction, (bool), step_over);
+
SBError error; // Ignored
StepInstruction(step_over, error);
}
void SBThread::StepInstruction(bool step_over, SBError &error) {
+ LLDB_RECORD_METHOD(void, SBThread, StepInstruction, (bool, lldb::SBError &),
+ step_over, error);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
std::unique_lock<std::recursive_mutex> lock;
}
void SBThread::RunToAddress(lldb::addr_t addr) {
+ LLDB_RECORD_METHOD(void, SBThread, RunToAddress, (lldb::addr_t), addr);
+
SBError error; // Ignored
RunToAddress(addr, error);
}
void SBThread::RunToAddress(lldb::addr_t addr, SBError &error) {
+ LLDB_RECORD_METHOD(void, SBThread, RunToAddress,
+ (lldb::addr_t, lldb::SBError &), addr, error);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
std::unique_lock<std::recursive_mutex> lock;
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);
+
SBError sb_error;
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
char path[PATH_MAX];
if (line == 0) {
sb_error.SetErrorString("invalid line argument");
- return sb_error;
+ return LLDB_RECORD_RESULT(sb_error);
}
if (!frame_sp) {
SymbolContext frame_sc;
if (!frame_sp) {
sb_error.SetErrorString("no valid frames in thread to step");
- return sb_error;
+ return LLDB_RECORD_RESULT(sb_error);
}
// If we have a frame, get its line
if (frame_sc.comp_unit == NULL) {
sb_error.SetErrorStringWithFormat(
"frame %u doesn't have debug information", frame_sp->GetFrameIndex());
- return sb_error;
+ return LLDB_RECORD_RESULT(sb_error);
}
FileSpec step_file_spec;
step_file_spec = frame_sc.line_entry.file;
else {
sb_error.SetErrorString("invalid file argument or no file for frame");
- return sb_error;
+ return LLDB_RECORD_RESULT(sb_error);
}
}
} else {
sb_error.SetErrorString("this SBThread object is invalid");
}
- return sb_error;
+ return LLDB_RECORD_RESULT(sb_error);
}
SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name) {
- return StepUsingScriptedThreadPlan(script_class_name, true);
+ LLDB_RECORD_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
+ (const char *), script_class_name);
+
+ return LLDB_RECORD_RESULT(
+ 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);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBError error;
if (!exe_ctx.HasThreadScope()) {
error.SetErrorString("this SBThread object is invalid");
- return error;
+ return LLDB_RECORD_RESULT(error);
}
Thread *thread = exe_ctx.GetThreadPtr();
if (new_plan_status.Fail()) {
error.SetErrorString(new_plan_status.AsCString());
- return error;
+ return LLDB_RECORD_RESULT(error);
}
if (!resume_immediately)
- return error;
+ return LLDB_RECORD_RESULT(error);
if (new_plan_status.Success())
error = ResumeNewPlan(exe_ctx, new_plan_sp.get());
else
error.SetErrorString(new_plan_status.AsCString());
- return error;
+ return LLDB_RECORD_RESULT(error);
}
SBError SBThread::JumpToLine(lldb::SBFileSpec &file_spec, uint32_t line) {
+ LLDB_RECORD_METHOD(lldb::SBError, SBThread, JumpToLine,
+ (lldb::SBFileSpec &, uint32_t), file_spec, line);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBError sb_error;
if (!exe_ctx.HasThreadScope()) {
sb_error.SetErrorString("this SBThread object is invalid");
- return sb_error;
+ return LLDB_RECORD_RESULT(sb_error);
}
Thread *thread = exe_ctx.GetThreadPtr();
Status err = thread->JumpToLine(file_spec.get(), line, true);
sb_error.SetError(err);
- return sb_error;
+ return LLDB_RECORD_RESULT(sb_error);
}
SBError SBThread::ReturnFromFrame(SBFrame &frame, SBValue &return_value) {
+ LLDB_RECORD_METHOD(lldb::SBError, SBThread, ReturnFromFrame,
+ (lldb::SBFrame &, lldb::SBValue &), frame, return_value);
+
SBError sb_error;
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
thread->ReturnFromFrame(frame.GetFrameSP(), return_value.GetSP()));
}
- return sb_error;
+ return LLDB_RECORD_RESULT(sb_error);
}
SBError SBThread::UnwindInnermostExpression() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBThread,
+ UnwindInnermostExpression);
+
SBError sb_error;
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
thread->SetSelectedFrameByIndex(0, false);
}
- return sb_error;
+ return LLDB_RECORD_RESULT(sb_error);
}
bool SBThread::Suspend() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, Suspend);
+
SBError error; // Ignored
return Suspend(error);
}
bool SBThread::Suspend(SBError &error) {
+ LLDB_RECORD_METHOD(bool, SBThread, Suspend, (lldb::SBError &), error);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
}
bool SBThread::Resume() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, Resume);
+
SBError error; // Ignored
return Resume(error);
}
bool SBThread::Resume(SBError &error) {
+ LLDB_RECORD_METHOD(bool, SBThread, Resume, (lldb::SBError &), error);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
}
bool SBThread::IsSuspended() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, IsSuspended);
+
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
}
bool SBThread::IsStopped() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, IsStopped);
+
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
}
SBProcess SBThread::GetProcess() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBThread, GetProcess);
+
SBProcess sb_process;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
frame_desc_strm.GetData());
}
- return sb_process;
+ return LLDB_RECORD_RESULT(sb_process);
}
uint32_t SBThread::GetNumFrames() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBThread, GetNumFrames);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
uint32_t num_frames = 0;
}
SBFrame SBThread::GetFrameAtIndex(uint32_t idx) {
+ LLDB_RECORD_METHOD(lldb::SBFrame, SBThread, GetFrameAtIndex, (uint32_t), idx);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBFrame sb_frame;
static_cast<void *>(frame_sp.get()), frame_desc_strm.GetData());
}
- return sb_frame;
+ return LLDB_RECORD_RESULT(sb_frame);
}
lldb::SBFrame SBThread::GetSelectedFrame() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFrame, SBThread, GetSelectedFrame);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBFrame sb_frame;
static_cast<void *>(frame_sp.get()), frame_desc_strm.GetData());
}
- return sb_frame;
+ return LLDB_RECORD_RESULT(sb_frame);
}
lldb::SBFrame SBThread::SetSelectedFrame(uint32_t idx) {
+ LLDB_RECORD_METHOD(lldb::SBFrame, SBThread, SetSelectedFrame, (uint32_t),
+ idx);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBFrame sb_frame;
static_cast<void *>(exe_ctx.GetThreadPtr()), idx,
static_cast<void *>(frame_sp.get()), frame_desc_strm.GetData());
}
- return sb_frame;
+ return LLDB_RECORD_RESULT(sb_frame);
}
bool SBThread::EventIsThreadEvent(const SBEvent &event) {
+ LLDB_RECORD_STATIC_METHOD(bool, SBThread, EventIsThreadEvent,
+ (const lldb::SBEvent &), event);
+
return Thread::ThreadEventData::GetEventDataFromEvent(event.get()) != NULL;
}
SBFrame SBThread::GetStackFrameFromEvent(const SBEvent &event) {
- return Thread::ThreadEventData::GetStackFrameFromEvent(event.get());
+ LLDB_RECORD_STATIC_METHOD(lldb::SBFrame, SBThread, GetStackFrameFromEvent,
+ (const lldb::SBEvent &), event);
+
+ return LLDB_RECORD_RESULT(
+ Thread::ThreadEventData::GetStackFrameFromEvent(event.get()));
}
SBThread SBThread::GetThreadFromEvent(const SBEvent &event) {
- return Thread::ThreadEventData::GetThreadFromEvent(event.get());
+ LLDB_RECORD_STATIC_METHOD(lldb::SBThread, SBThread, GetThreadFromEvent,
+ (const lldb::SBEvent &), event);
+
+ return LLDB_RECORD_RESULT(
+ Thread::ThreadEventData::GetThreadFromEvent(event.get()));
}
bool SBThread::operator==(const SBThread &rhs) const {
+ LLDB_RECORD_METHOD_CONST(bool, SBThread, operator==,(const lldb::SBThread &),
+ rhs);
+
return m_opaque_sp->GetThreadSP().get() ==
rhs.m_opaque_sp->GetThreadSP().get();
}
bool SBThread::operator!=(const SBThread &rhs) const {
+ LLDB_RECORD_METHOD_CONST(bool, SBThread, operator!=,(const lldb::SBThread &),
+ rhs);
+
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);
+
Stream &strm = status.ref();
std::unique_lock<std::recursive_mutex> lock;
}
bool SBThread::GetDescription(SBStream &description) const {
- return GetDescription(description, false);
+ LLDB_RECORD_METHOD_CONST(bool, SBThread, GetDescription, (lldb::SBStream &),
+ description);
+
+ return GetDescription(description, false);
}
bool SBThread::GetDescription(SBStream &description, bool stop_format) const {
+ LLDB_RECORD_METHOD_CONST(bool, SBThread, GetDescription,
+ (lldb::SBStream &, bool), description, stop_format);
+
Stream &strm = description.ref();
std::unique_lock<std::recursive_mutex> lock;
}
SBThread SBThread::GetExtendedBacktraceThread(const char *type) {
+ LLDB_RECORD_METHOD(lldb::SBThread, SBThread, GetExtendedBacktraceThread,
+ (const char *), type);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
log->Printf("SBThread(%p)::GetExtendedBacktraceThread() is not returning a "
"Valid thread",
static_cast<void *>(exe_ctx.GetThreadPtr()));
- return sb_origin_thread;
+ return LLDB_RECORD_RESULT(sb_origin_thread);
}
uint32_t SBThread::GetExtendedBacktraceOriginatingIndexID() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBThread,
+ GetExtendedBacktraceOriginatingIndexID);
+
ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
if (thread_sp)
return thread_sp->GetExtendedBacktraceOriginatingIndexID();
}
SBValue SBThread::GetCurrentException() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBThread, GetCurrentException);
+
ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
- if (!thread_sp) return SBValue();
+ if (!thread_sp)
+ return LLDB_RECORD_RESULT(SBValue());
- return SBValue(thread_sp->GetCurrentException());
+ return LLDB_RECORD_RESULT(SBValue(thread_sp->GetCurrentException()));
}
SBThread SBThread::GetCurrentExceptionBacktrace() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBThread, SBThread,
+ GetCurrentExceptionBacktrace);
+
ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
- if (!thread_sp) return SBThread();
+ if (!thread_sp)
+ return LLDB_RECORD_RESULT(SBThread());
- return SBThread(thread_sp->GetCurrentExceptionBacktrace());
+ return LLDB_RECORD_RESULT(
+ SBThread(thread_sp->GetCurrentExceptionBacktrace()));
}
bool SBThread::SafeToCallFunctions() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, SafeToCallFunctions);
+
ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
if (thread_sp)
return thread_sp->SafeToCallFunctions();
}
lldb_private::Thread *SBThread::operator->() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb_private::Thread *, SBThread, operator->);
+
ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
if (thread_sp)
return thread_sp.get();
}
lldb_private::Thread *SBThread::get() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb_private::Thread *, SBThread, get);
+
ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
if (thread_sp)
return thread_sp.get();
//===----------------------------------------------------------------------===//
#include "lldb/API/SBThreadCollection.h"
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBThread.h"
#include "lldb/Target/ThreadList.h"
using namespace lldb;
using namespace lldb_private;
-SBThreadCollection::SBThreadCollection() : m_opaque_sp() {}
+SBThreadCollection::SBThreadCollection() : m_opaque_sp() {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBThreadCollection);
+}
SBThreadCollection::SBThreadCollection(const SBThreadCollection &rhs)
- : m_opaque_sp(rhs.m_opaque_sp) {}
+ : m_opaque_sp(rhs.m_opaque_sp) {
+ LLDB_RECORD_CONSTRUCTOR(SBThreadCollection,
+ (const lldb::SBThreadCollection &), rhs);
+}
const SBThreadCollection &SBThreadCollection::
operator=(const SBThreadCollection &rhs) {
+ LLDB_RECORD_METHOD(
+ const lldb::SBThreadCollection &,
+ SBThreadCollection, operator=,(const lldb::SBThreadCollection &), rhs);
+
if (this != &rhs)
m_opaque_sp = rhs.m_opaque_sp;
return *this;
return m_opaque_sp;
}
-bool SBThreadCollection::IsValid() const { return m_opaque_sp.get() != NULL; }
+bool SBThreadCollection::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadCollection, IsValid);
+
+ return m_opaque_sp.get() != NULL;
+}
size_t SBThreadCollection::GetSize() {
+ LLDB_RECORD_METHOD_NO_ARGS(size_t, SBThreadCollection, GetSize);
+
if (m_opaque_sp)
return m_opaque_sp->GetSize();
return 0;
}
SBThread SBThreadCollection::GetThreadAtIndex(size_t idx) {
+ LLDB_RECORD_METHOD(lldb::SBThread, SBThreadCollection, GetThreadAtIndex,
+ (size_t), idx);
+
SBThread thread;
if (m_opaque_sp && idx < m_opaque_sp->GetSize())
thread = m_opaque_sp->GetThreadAtIndex(idx);
- return thread;
+ return LLDB_RECORD_RESULT(thread);
}
//
//===----------------------------------------------------------------------===//
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBThread.h"
#include "lldb/API/SBFileSpec.h"
//----------------------------------------------------------------------
// Constructors
//----------------------------------------------------------------------
-SBThreadPlan::SBThreadPlan() {}
+SBThreadPlan::SBThreadPlan() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBThreadPlan); }
SBThreadPlan::SBThreadPlan(const ThreadPlanSP &lldb_object_sp)
- : m_opaque_sp(lldb_object_sp) {}
+ : m_opaque_sp(lldb_object_sp) {
+ LLDB_RECORD_CONSTRUCTOR(SBThreadPlan, (const lldb::ThreadPlanSP &),
+ lldb_object_sp);
+}
SBThreadPlan::SBThreadPlan(const SBThreadPlan &rhs)
- : m_opaque_sp(rhs.m_opaque_sp) {}
+ : m_opaque_sp(rhs.m_opaque_sp) {
+ LLDB_RECORD_CONSTRUCTOR(SBThreadPlan, (const lldb::SBThreadPlan &), rhs);
+}
SBThreadPlan::SBThreadPlan(lldb::SBThread &sb_thread, const char *class_name) {
+ LLDB_RECORD_CONSTRUCTOR(SBThreadPlan, (lldb::SBThread &, const char *),
+ sb_thread, class_name);
+
Thread *thread = sb_thread.get();
if (thread)
m_opaque_sp = std::make_shared<ThreadPlanPython>(*thread, class_name);
//----------------------------------------------------------------------
const lldb::SBThreadPlan &SBThreadPlan::operator=(const SBThreadPlan &rhs) {
+ LLDB_RECORD_METHOD(const lldb::SBThreadPlan &,
+ SBThreadPlan, operator=,(const lldb::SBThreadPlan &), rhs);
+
if (this != &rhs)
m_opaque_sp = rhs.m_opaque_sp;
return *this;
//----------------------------------------------------------------------
SBThreadPlan::~SBThreadPlan() {}
-lldb_private::ThreadPlan *SBThreadPlan::get() { return m_opaque_sp.get(); }
+lldb_private::ThreadPlan *SBThreadPlan::get() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb_private::ThreadPlan *, SBThreadPlan, get);
+
+ return m_opaque_sp.get();
+}
+
+bool SBThreadPlan::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadPlan, IsValid);
+
+ return m_opaque_sp.get() != NULL;
+}
+
+void SBThreadPlan::Clear() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBThreadPlan, Clear);
+
+ m_opaque_sp.reset();
+}
-bool SBThreadPlan::IsValid() const { return m_opaque_sp.get() != NULL; }
+lldb::StopReason SBThreadPlan::GetStopReason() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::StopReason, SBThreadPlan, GetStopReason);
-void SBThreadPlan::Clear() { m_opaque_sp.reset(); }
+ return eStopReasonNone;
+}
+
+size_t SBThreadPlan::GetStopReasonDataCount() {
+ LLDB_RECORD_METHOD_NO_ARGS(size_t, SBThreadPlan, GetStopReasonDataCount);
-lldb::StopReason SBThreadPlan::GetStopReason() { return eStopReasonNone; }
+ return 0;
+}
-size_t SBThreadPlan::GetStopReasonDataCount() { return 0; }
+uint64_t SBThreadPlan::GetStopReasonDataAtIndex(uint32_t idx) {
+ LLDB_RECORD_METHOD(uint64_t, SBThreadPlan, GetStopReasonDataAtIndex,
+ (uint32_t), idx);
-uint64_t SBThreadPlan::GetStopReasonDataAtIndex(uint32_t idx) { return 0; }
+ return 0;
+}
SBThread SBThreadPlan::GetThread() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBThreadPlan, GetThread);
+
if (m_opaque_sp) {
- return SBThread(m_opaque_sp->GetThread().shared_from_this());
+ return LLDB_RECORD_RESULT(
+ SBThread(m_opaque_sp->GetThread().shared_from_this()));
} else
- return SBThread();
+ return LLDB_RECORD_RESULT(SBThread());
}
bool SBThreadPlan::GetDescription(lldb::SBStream &description) const {
+ LLDB_RECORD_METHOD_CONST(bool, SBThreadPlan, GetDescription,
+ (lldb::SBStream &), description);
+
if (m_opaque_sp) {
m_opaque_sp->GetDescription(description.get(), eDescriptionLevelFull);
} else {
}
void SBThreadPlan::SetPlanComplete(bool success) {
+ LLDB_RECORD_METHOD(void, SBThreadPlan, SetPlanComplete, (bool), success);
+
if (m_opaque_sp)
m_opaque_sp->SetPlanComplete(success);
}
bool SBThreadPlan::IsPlanComplete() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, IsPlanComplete);
+
if (m_opaque_sp)
return m_opaque_sp->IsPlanComplete();
else
}
bool SBThreadPlan::IsPlanStale() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, IsPlanStale);
+
if (m_opaque_sp)
return m_opaque_sp->IsPlanStale();
else
}
bool SBThreadPlan::IsValid() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, IsValid);
+
if (m_opaque_sp)
return m_opaque_sp->ValidatePlan(nullptr);
else
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);
+
SBError error;
- return QueueThreadPlanForStepOverRange(sb_start_address, size, error);
+ return LLDB_RECORD_RESULT(
+ QueueThreadPlanForStepOverRange(sb_start_address, size, error));
}
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);
+
if (m_opaque_sp) {
Address *start_address = sb_start_address.get();
if (!start_address) {
- return SBThreadPlan();
+ return LLDB_RECORD_RESULT(SBThreadPlan());
}
AddressRange range(*start_address, size);
if (plan_status.Fail())
error.SetErrorString(plan_status.AsCString());
- return plan;
+ return LLDB_RECORD_RESULT(plan);
} else {
- return SBThreadPlan();
+ return LLDB_RECORD_RESULT(SBThreadPlan());
}
}
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);
+
SBError error;
- return QueueThreadPlanForStepInRange(sb_start_address, size, error);
+ return LLDB_RECORD_RESULT(
+ QueueThreadPlanForStepInRange(sb_start_address, size, error));
}
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);
+
if (m_opaque_sp) {
Address *start_address = sb_start_address.get();
if (!start_address) {
- return SBThreadPlan();
+ return LLDB_RECORD_RESULT(SBThreadPlan());
}
AddressRange range(*start_address, size);
if (plan_status.Fail())
error.SetErrorString(plan_status.AsCString());
- return plan;
+ return LLDB_RECORD_RESULT(plan);
} else {
- return SBThreadPlan();
+ return LLDB_RECORD_RESULT(SBThreadPlan());
}
}
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);
+
SBError error;
- return QueueThreadPlanForStepOut(frame_idx_to_step_to, first_insn, error);
+ return LLDB_RECORD_RESULT(
+ QueueThreadPlanForStepOut(frame_idx_to_step_to, first_insn, error));
}
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);
+
if (m_opaque_sp) {
SymbolContext sc;
sc = m_opaque_sp->GetThread().GetStackFrameAtIndex(0)->GetSymbolContext(
if (plan_status.Fail())
error.SetErrorString(plan_status.AsCString());
- return plan;
+ return LLDB_RECORD_RESULT(plan);
} else {
- return SBThreadPlan();
+ return LLDB_RECORD_RESULT(SBThreadPlan());
}
}
SBThreadPlan
SBThreadPlan::QueueThreadPlanForRunToAddress(SBAddress sb_address) {
+ LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
+ QueueThreadPlanForRunToAddress, (lldb::SBAddress),
+ sb_address);
+
SBError error;
- return QueueThreadPlanForRunToAddress(sb_address, error);
+ return LLDB_RECORD_RESULT(QueueThreadPlanForRunToAddress(sb_address, error));
}
SBThreadPlan SBThreadPlan::QueueThreadPlanForRunToAddress(SBAddress sb_address,
SBError &error) {
+ LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
+ QueueThreadPlanForRunToAddress,
+ (lldb::SBAddress, lldb::SBError &), sb_address, error);
+
if (m_opaque_sp) {
Address *address = sb_address.get();
if (!address)
- return SBThreadPlan();
+ return LLDB_RECORD_RESULT(SBThreadPlan());
Status plan_status;
SBThreadPlan plan =
if (plan_status.Fail())
error.SetErrorString(plan_status.AsCString());
- return plan;
+ return LLDB_RECORD_RESULT(plan);
} else {
- return SBThreadPlan();
+ return LLDB_RECORD_RESULT(SBThreadPlan());
}
}
SBThreadPlan
SBThreadPlan::QueueThreadPlanForStepScripted(const char *script_class_name) {
+ LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
+ QueueThreadPlanForStepScripted, (const char *),
+ script_class_name);
+
SBError error;
- return QueueThreadPlanForStepScripted(script_class_name, error);
+ return LLDB_RECORD_RESULT(
+ QueueThreadPlanForStepScripted(script_class_name, error));
}
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);
+
if (m_opaque_sp) {
Status plan_status;
SBThreadPlan plan =
if (plan_status.Fail())
error.SetErrorString(plan_status.AsCString());
- return plan;
+ return LLDB_RECORD_RESULT(plan);
} else {
- return SBThreadPlan();
+ return LLDB_RECORD_RESULT(SBThreadPlan());
}
}
//
//===----------------------------------------------------------------------===//
+#include "SBReproducerPrivate.h"
#include "lldb/Target/Process.h"
#include "lldb/Utility/Log.h"
}
void SBTrace::StopTrace(SBError &error, lldb::tid_t thread_id) {
+ LLDB_RECORD_METHOD(void, SBTrace, StopTrace, (lldb::SBError &, lldb::tid_t),
+ error, thread_id);
+
ProcessSP process_sp(GetSP());
error.Clear();
}
void SBTrace::GetTraceConfig(SBTraceOptions &options, SBError &error) {
+ LLDB_RECORD_METHOD(void, SBTrace, GetTraceConfig,
+ (lldb::SBTraceOptions &, lldb::SBError &), options, error);
+
ProcessSP process_sp(GetSP());
error.Clear();
}
lldb::user_id_t SBTrace::GetTraceUID() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::user_id_t, SBTrace, GetTraceUID);
+
if (m_trace_impl_sp)
return m_trace_impl_sp->uid;
return LLDB_INVALID_UID;
}
SBTrace::SBTrace() {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTrace);
+
m_trace_impl_sp = std::make_shared<TraceImpl>();
if (m_trace_impl_sp)
m_trace_impl_sp->uid = LLDB_INVALID_UID;
void SBTrace::SetSP(const ProcessSP &process_sp) { m_opaque_wp = process_sp; }
bool SBTrace::IsValid() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBTrace, IsValid);
+
if (!m_trace_impl_sp)
return false;
if (!GetSP())
//===----------------------------------------------------------------------===//
#include "lldb/API/SBTraceOptions.h"
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBError.h"
#include "lldb/API/SBStructuredData.h"
#include "lldb/Core/StructuredDataImpl.h"
using namespace lldb_private;
SBTraceOptions::SBTraceOptions() {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTraceOptions);
+
m_traceoptions_sp = std::make_shared<TraceOptions>();
}
lldb::TraceType SBTraceOptions::getType() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::TraceType, SBTraceOptions, getType);
+
if (m_traceoptions_sp)
return m_traceoptions_sp->getType();
return lldb::TraceType::eTraceTypeNone;
}
uint64_t SBTraceOptions::getTraceBufferSize() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(uint64_t, SBTraceOptions,
+ getTraceBufferSize);
+
if (m_traceoptions_sp)
return m_traceoptions_sp->getTraceBufferSize();
return 0;
}
lldb::SBStructuredData SBTraceOptions::getTraceParams(lldb::SBError &error) {
+ LLDB_RECORD_METHOD(lldb::SBStructuredData, SBTraceOptions, getTraceParams,
+ (lldb::SBError &), error);
+
error.Clear();
const lldb_private::StructuredData::DictionarySP dict_obj =
m_traceoptions_sp->getTraceParams();
structData.m_impl_up->SetObjectSP(dict_obj->shared_from_this());
else
error.SetErrorString("Empty trace params");
- return structData;
+ return LLDB_RECORD_RESULT(structData);
}
uint64_t SBTraceOptions::getMetaDataBufferSize() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(uint64_t, SBTraceOptions,
+ getMetaDataBufferSize);
+
if (m_traceoptions_sp)
return m_traceoptions_sp->getTraceBufferSize();
return 0;
}
void SBTraceOptions::setTraceParams(lldb::SBStructuredData ¶ms) {
+ LLDB_RECORD_METHOD(void, SBTraceOptions, setTraceParams,
+ (lldb::SBStructuredData &), params);
+
if (m_traceoptions_sp && params.m_impl_up) {
StructuredData::ObjectSP obj_sp = params.m_impl_up->GetObjectSP();
if (obj_sp && obj_sp->GetAsDictionary() != nullptr)
}
void SBTraceOptions::setType(lldb::TraceType type) {
+ LLDB_RECORD_METHOD(void, SBTraceOptions, setType, (lldb::TraceType), type);
+
if (m_traceoptions_sp)
m_traceoptions_sp->setType(type);
}
void SBTraceOptions::setTraceBufferSize(uint64_t size) {
+ LLDB_RECORD_METHOD(void, SBTraceOptions, setTraceBufferSize, (uint64_t),
+ size);
+
if (m_traceoptions_sp)
m_traceoptions_sp->setTraceBufferSize(size);
}
void SBTraceOptions::setMetaDataBufferSize(uint64_t size) {
+ LLDB_RECORD_METHOD(void, SBTraceOptions, setMetaDataBufferSize, (uint64_t),
+ size);
+
if (m_traceoptions_sp)
m_traceoptions_sp->setMetaDataBufferSize(size);
}
bool SBTraceOptions::IsValid() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBTraceOptions, IsValid);
+
if (m_traceoptions_sp)
return true;
return false;
}
void SBTraceOptions::setThreadID(lldb::tid_t thread_id) {
+ LLDB_RECORD_METHOD(void, SBTraceOptions, setThreadID, (lldb::tid_t),
+ thread_id);
+
if (m_traceoptions_sp)
m_traceoptions_sp->setThreadID(thread_id);
}
lldb::tid_t SBTraceOptions::getThreadID() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBTraceOptions, getThreadID);
+
if (m_traceoptions_sp)
return m_traceoptions_sp->getThreadID();
return LLDB_INVALID_THREAD_ID;
//===----------------------------------------------------------------------===//
#include "lldb/API/SBType.h"
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBDefines.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBTypeEnumMember.h"
using namespace lldb;
using namespace lldb_private;
-SBType::SBType() : m_opaque_sp() {}
+SBType::SBType() : m_opaque_sp() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBType); }
SBType::SBType(const CompilerType &type)
: m_opaque_sp(new TypeImpl(
: m_opaque_sp(type_impl_sp) {}
SBType::SBType(const SBType &rhs) : m_opaque_sp() {
+ LLDB_RECORD_CONSTRUCTOR(SBType, (const lldb::SBType &), rhs);
+
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
}
//{}
//
bool SBType::operator==(SBType &rhs) {
+ LLDB_RECORD_METHOD(bool, SBType, operator==,(lldb::SBType &), rhs);
+
if (!IsValid())
return !rhs.IsValid();
}
bool SBType::operator!=(SBType &rhs) {
+ LLDB_RECORD_METHOD(bool, SBType, operator!=,(lldb::SBType &), rhs);
+
if (!IsValid())
return rhs.IsValid();
}
SBType &SBType::operator=(const SBType &rhs) {
+ LLDB_RECORD_METHOD(lldb::SBType &, SBType, operator=,(const lldb::SBType &),
+ rhs);
+
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
}
}
bool SBType::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBType, IsValid);
+
if (m_opaque_sp.get() == NULL)
return false;
}
uint64_t SBType::GetByteSize() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBType, GetByteSize);
+
if (IsValid())
if (llvm::Optional<uint64_t> size =
m_opaque_sp->GetCompilerType(false).GetByteSize(nullptr))
}
bool SBType::IsPointerType() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsPointerType);
+
if (!IsValid())
return false;
return m_opaque_sp->GetCompilerType(true).IsPointerType();
}
bool SBType::IsArrayType() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsArrayType);
+
if (!IsValid())
return false;
return m_opaque_sp->GetCompilerType(true).IsArrayType(nullptr, nullptr,
}
bool SBType::IsVectorType() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsVectorType);
+
if (!IsValid())
return false;
return m_opaque_sp->GetCompilerType(true).IsVectorType(nullptr, nullptr);
}
bool SBType::IsReferenceType() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsReferenceType);
+
if (!IsValid())
return false;
return m_opaque_sp->GetCompilerType(true).IsReferenceType();
}
SBType SBType::GetPointerType() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetPointerType);
+
if (!IsValid())
- return SBType();
+ return LLDB_RECORD_RESULT(SBType());
- return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetPointerType())));
+ return LLDB_RECORD_RESULT(
+ SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetPointerType()))));
}
SBType SBType::GetPointeeType() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetPointeeType);
+
if (!IsValid())
- return SBType();
- return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetPointeeType())));
+ return LLDB_RECORD_RESULT(SBType());
+ return LLDB_RECORD_RESULT(
+ SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetPointeeType()))));
}
SBType SBType::GetReferenceType() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetReferenceType);
+
if (!IsValid())
- return SBType();
- return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetReferenceType())));
+ return LLDB_RECORD_RESULT(SBType());
+ return LLDB_RECORD_RESULT(
+ SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetReferenceType()))));
}
SBType SBType::GetTypedefedType() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetTypedefedType);
+
if (!IsValid())
- return SBType();
- return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetTypedefedType())));
+ return LLDB_RECORD_RESULT(SBType());
+ return LLDB_RECORD_RESULT(
+ SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetTypedefedType()))));
}
SBType SBType::GetDereferencedType() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetDereferencedType);
+
if (!IsValid())
- return SBType();
- return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetDereferencedType())));
+ return LLDB_RECORD_RESULT(SBType());
+ return LLDB_RECORD_RESULT(
+ SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetDereferencedType()))));
}
SBType SBType::GetArrayElementType() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetArrayElementType);
+
if (!IsValid())
- return SBType();
- return SBType(TypeImplSP(
- new TypeImpl(m_opaque_sp->GetCompilerType(true).GetArrayElementType())));
+ return LLDB_RECORD_RESULT(SBType());
+ return LLDB_RECORD_RESULT(SBType(TypeImplSP(
+ new TypeImpl(m_opaque_sp->GetCompilerType(true).GetArrayElementType()))));
}
SBType SBType::GetArrayType(uint64_t size) {
+ LLDB_RECORD_METHOD(lldb::SBType, SBType, GetArrayType, (uint64_t), size);
+
if (!IsValid())
- return SBType();
- return SBType(TypeImplSP(
- new TypeImpl(m_opaque_sp->GetCompilerType(true).GetArrayType(size))));
+ return LLDB_RECORD_RESULT(SBType());
+ return LLDB_RECORD_RESULT(SBType(TypeImplSP(
+ new TypeImpl(m_opaque_sp->GetCompilerType(true).GetArrayType(size)))));
}
SBType SBType::GetVectorElementType() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetVectorElementType);
+
SBType type_sb;
if (IsValid()) {
CompilerType vector_element_type;
nullptr))
type_sb.SetSP(TypeImplSP(new TypeImpl(vector_element_type)));
}
- return type_sb;
+ return LLDB_RECORD_RESULT(type_sb);
}
bool SBType::IsFunctionType() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsFunctionType);
+
if (!IsValid())
return false;
return m_opaque_sp->GetCompilerType(true).IsFunctionType();
}
bool SBType::IsPolymorphicClass() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsPolymorphicClass);
+
if (!IsValid())
return false;
return m_opaque_sp->GetCompilerType(true).IsPolymorphicClass();
}
bool SBType::IsTypedefType() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsTypedefType);
+
if (!IsValid())
return false;
return m_opaque_sp->GetCompilerType(true).IsTypedefType();
}
bool SBType::IsAnonymousType() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsAnonymousType);
+
if (!IsValid())
return false;
return m_opaque_sp->GetCompilerType(true).IsAnonymousType();
}
lldb::SBType SBType::GetFunctionReturnType() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetFunctionReturnType);
+
if (IsValid()) {
CompilerType return_type(
m_opaque_sp->GetCompilerType(true).GetFunctionReturnType());
if (return_type.IsValid())
- return SBType(return_type);
+ return LLDB_RECORD_RESULT(SBType(return_type));
}
- return lldb::SBType();
+ return LLDB_RECORD_RESULT(lldb::SBType());
}
lldb::SBTypeList SBType::GetFunctionArgumentTypes() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeList, SBType,
+ GetFunctionArgumentTypes);
+
SBTypeList sb_type_list;
if (IsValid()) {
CompilerType func_type(m_opaque_sp->GetCompilerType(true));
sb_type_list.Append(SBType(func_type.GetFunctionArgumentAtIndex(i)));
}
}
- return sb_type_list;
+ return LLDB_RECORD_RESULT(sb_type_list);
}
uint32_t SBType::GetNumberOfMemberFunctions() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfMemberFunctions);
+
if (IsValid()) {
return m_opaque_sp->GetCompilerType(true).GetNumMemberFunctions();
}
}
lldb::SBTypeMemberFunction SBType::GetMemberFunctionAtIndex(uint32_t idx) {
+ LLDB_RECORD_METHOD(lldb::SBTypeMemberFunction, SBType,
+ GetMemberFunctionAtIndex, (uint32_t), idx);
+
SBTypeMemberFunction sb_func_type;
if (IsValid())
sb_func_type.reset(new TypeMemberFunctionImpl(
m_opaque_sp->GetCompilerType(true).GetMemberFunctionAtIndex(idx)));
- return sb_func_type;
+ return LLDB_RECORD_RESULT(sb_func_type);
}
lldb::SBType SBType::GetUnqualifiedType() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetUnqualifiedType);
+
if (!IsValid())
- return SBType();
- return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetUnqualifiedType())));
+ return LLDB_RECORD_RESULT(SBType());
+ return LLDB_RECORD_RESULT(
+ SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetUnqualifiedType()))));
}
lldb::SBType SBType::GetCanonicalType() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetCanonicalType);
+
if (IsValid())
- return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetCanonicalType())));
- return SBType();
+ return LLDB_RECORD_RESULT(
+ SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetCanonicalType()))));
+ return LLDB_RECORD_RESULT(SBType());
}
lldb::BasicType SBType::GetBasicType() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::BasicType, SBType, GetBasicType);
+
if (IsValid())
return m_opaque_sp->GetCompilerType(false).GetBasicTypeEnumeration();
return eBasicTypeInvalid;
}
SBType SBType::GetBasicType(lldb::BasicType basic_type) {
+ LLDB_RECORD_METHOD(lldb::SBType, SBType, GetBasicType, (lldb::BasicType),
+ basic_type);
+
if (IsValid() && m_opaque_sp->IsValid())
- return SBType(
- m_opaque_sp->GetTypeSystem(false)->GetBasicTypeFromAST(basic_type));
- return SBType();
+ return LLDB_RECORD_RESULT(SBType(
+ m_opaque_sp->GetTypeSystem(false)->GetBasicTypeFromAST(basic_type)));
+ return LLDB_RECORD_RESULT(SBType());
}
uint32_t SBType::GetNumberOfDirectBaseClasses() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfDirectBaseClasses);
+
if (IsValid())
return m_opaque_sp->GetCompilerType(true).GetNumDirectBaseClasses();
return 0;
}
uint32_t SBType::GetNumberOfVirtualBaseClasses() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfVirtualBaseClasses);
+
if (IsValid())
return m_opaque_sp->GetCompilerType(true).GetNumVirtualBaseClasses();
return 0;
}
uint32_t SBType::GetNumberOfFields() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfFields);
+
if (IsValid())
return m_opaque_sp->GetCompilerType(true).GetNumFields();
return 0;
bool SBType::GetDescription(SBStream &description,
lldb::DescriptionLevel description_level) {
+ LLDB_RECORD_METHOD(bool, SBType, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel), description,
+ description_level);
+
Stream &strm = description.ref();
if (m_opaque_sp) {
}
SBTypeMember SBType::GetDirectBaseClassAtIndex(uint32_t idx) {
+ LLDB_RECORD_METHOD(lldb::SBTypeMember, SBType, GetDirectBaseClassAtIndex,
+ (uint32_t), idx);
+
SBTypeMember sb_type_member;
if (IsValid()) {
uint32_t bit_offset = 0;
sb_type_member.reset(new TypeMemberImpl(
TypeImplSP(new TypeImpl(base_class_type)), bit_offset));
}
- return sb_type_member;
+ return LLDB_RECORD_RESULT(sb_type_member);
}
SBTypeMember SBType::GetVirtualBaseClassAtIndex(uint32_t idx) {
+ LLDB_RECORD_METHOD(lldb::SBTypeMember, SBType, GetVirtualBaseClassAtIndex,
+ (uint32_t), idx);
+
SBTypeMember sb_type_member;
if (IsValid()) {
uint32_t bit_offset = 0;
sb_type_member.reset(new TypeMemberImpl(
TypeImplSP(new TypeImpl(base_class_type)), bit_offset));
}
- return sb_type_member;
+ return LLDB_RECORD_RESULT(sb_type_member);
}
SBTypeEnumMemberList SBType::GetEnumMembers() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeEnumMemberList, SBType,
+ GetEnumMembers);
+
SBTypeEnumMemberList sb_enum_member_list;
if (IsValid()) {
CompilerType this_type(m_opaque_sp->GetCompilerType(true));
});
}
}
- return sb_enum_member_list;
+ return LLDB_RECORD_RESULT(sb_enum_member_list);
}
SBTypeMember SBType::GetFieldAtIndex(uint32_t idx) {
+ LLDB_RECORD_METHOD(lldb::SBTypeMember, SBType, GetFieldAtIndex, (uint32_t),
+ idx);
+
SBTypeMember sb_type_member;
if (IsValid()) {
CompilerType this_type(m_opaque_sp->GetCompilerType(false));
}
}
}
- return sb_type_member;
+ return LLDB_RECORD_RESULT(sb_type_member);
}
bool SBType::IsTypeComplete() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsTypeComplete);
+
if (!IsValid())
return false;
return m_opaque_sp->GetCompilerType(false).IsCompleteType();
}
uint32_t SBType::GetTypeFlags() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetTypeFlags);
+
if (!IsValid())
return 0;
return m_opaque_sp->GetCompilerType(true).GetTypeInfo();
}
const char *SBType::GetName() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBType, GetName);
+
if (!IsValid())
return "";
return m_opaque_sp->GetName().GetCString();
}
const char *SBType::GetDisplayTypeName() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBType, GetDisplayTypeName);
+
if (!IsValid())
return "";
return m_opaque_sp->GetDisplayTypeName().GetCString();
}
lldb::TypeClass SBType::GetTypeClass() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::TypeClass, SBType, GetTypeClass);
+
if (IsValid())
return m_opaque_sp->GetCompilerType(true).GetTypeClass();
return lldb::eTypeClassInvalid;
}
uint32_t SBType::GetNumberOfTemplateArguments() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfTemplateArguments);
+
if (IsValid())
return m_opaque_sp->GetCompilerType(false).GetNumTemplateArguments();
return 0;
}
lldb::SBType SBType::GetTemplateArgumentType(uint32_t idx) {
+ LLDB_RECORD_METHOD(lldb::SBType, SBType, GetTemplateArgumentType, (uint32_t),
+ idx);
+
if (!IsValid())
- return SBType();
+ return LLDB_RECORD_RESULT(SBType());
CompilerType type;
switch(GetTemplateArgumentKind(idx)) {
break;
}
if (type.IsValid())
- return SBType(type);
- return SBType();
+ return LLDB_RECORD_RESULT(SBType(type));
+ return LLDB_RECORD_RESULT(SBType());
}
lldb::TemplateArgumentKind SBType::GetTemplateArgumentKind(uint32_t idx) {
+ LLDB_RECORD_METHOD(lldb::TemplateArgumentKind, SBType,
+ GetTemplateArgumentKind, (uint32_t), idx);
+
if (IsValid())
return m_opaque_sp->GetCompilerType(false).GetTemplateArgumentKind(idx);
return eTemplateArgumentKindNull;
}
-SBTypeList::SBTypeList() : m_opaque_up(new TypeListImpl()) {}
+SBTypeList::SBTypeList() : m_opaque_up(new TypeListImpl()) {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeList);
+}
SBTypeList::SBTypeList(const SBTypeList &rhs)
: m_opaque_up(new TypeListImpl()) {
+ LLDB_RECORD_CONSTRUCTOR(SBTypeList, (const lldb::SBTypeList &), rhs);
+
for (uint32_t i = 0, rhs_size = const_cast<SBTypeList &>(rhs).GetSize();
i < rhs_size; i++)
Append(const_cast<SBTypeList &>(rhs).GetTypeAtIndex(i));
}
-bool SBTypeList::IsValid() { return (m_opaque_up != NULL); }
+bool SBTypeList::IsValid() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeList, IsValid);
+
+ return (m_opaque_up != NULL);
+}
SBTypeList &SBTypeList::operator=(const SBTypeList &rhs) {
+ LLDB_RECORD_METHOD(lldb::SBTypeList &,
+ SBTypeList, operator=,(const lldb::SBTypeList &), rhs);
+
if (this != &rhs) {
m_opaque_up.reset(new TypeListImpl());
for (uint32_t i = 0, rhs_size = const_cast<SBTypeList &>(rhs).GetSize();
}
void SBTypeList::Append(SBType type) {
+ LLDB_RECORD_METHOD(void, SBTypeList, Append, (lldb::SBType), type);
+
if (type.IsValid())
m_opaque_up->Append(type.m_opaque_sp);
}
SBType SBTypeList::GetTypeAtIndex(uint32_t index) {
+ LLDB_RECORD_METHOD(lldb::SBType, SBTypeList, GetTypeAtIndex, (uint32_t),
+ index);
+
if (m_opaque_up)
- return SBType(m_opaque_up->GetTypeAtIndex(index));
- return SBType();
+ return LLDB_RECORD_RESULT(SBType(m_opaque_up->GetTypeAtIndex(index)));
+ return LLDB_RECORD_RESULT(SBType());
}
-uint32_t SBTypeList::GetSize() { return m_opaque_up->GetSize(); }
+uint32_t SBTypeList::GetSize() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeList, GetSize);
+
+ return m_opaque_up->GetSize();
+}
SBTypeList::~SBTypeList() {}
-SBTypeMember::SBTypeMember() : m_opaque_up() {}
+SBTypeMember::SBTypeMember() : m_opaque_up() {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeMember);
+}
SBTypeMember::~SBTypeMember() {}
SBTypeMember::SBTypeMember(const SBTypeMember &rhs) : m_opaque_up() {
+ LLDB_RECORD_CONSTRUCTOR(SBTypeMember, (const lldb::SBTypeMember &), rhs);
+
if (this != &rhs) {
if (rhs.IsValid())
m_opaque_up.reset(new TypeMemberImpl(rhs.ref()));
}
lldb::SBTypeMember &SBTypeMember::operator=(const lldb::SBTypeMember &rhs) {
+ LLDB_RECORD_METHOD(lldb::SBTypeMember &,
+ SBTypeMember, operator=,(const lldb::SBTypeMember &), rhs);
+
if (this != &rhs) {
if (rhs.IsValid())
m_opaque_up.reset(new TypeMemberImpl(rhs.ref()));
return *this;
}
-bool SBTypeMember::IsValid() const { return m_opaque_up.get(); }
+bool SBTypeMember::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMember, IsValid);
+
+ return m_opaque_up.get();
+}
const char *SBTypeMember::GetName() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMember, GetName);
+
if (m_opaque_up)
return m_opaque_up->GetName().GetCString();
return NULL;
}
SBType SBTypeMember::GetType() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeMember, GetType);
+
SBType sb_type;
if (m_opaque_up) {
sb_type.SetSP(m_opaque_up->GetTypeImpl());
}
- return sb_type;
+ return LLDB_RECORD_RESULT(sb_type);
}
uint64_t SBTypeMember::GetOffsetInBytes() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBTypeMember, GetOffsetInBytes);
+
if (m_opaque_up)
return m_opaque_up->GetBitOffset() / 8u;
return 0;
}
uint64_t SBTypeMember::GetOffsetInBits() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBTypeMember, GetOffsetInBits);
+
if (m_opaque_up)
return m_opaque_up->GetBitOffset();
return 0;
}
bool SBTypeMember::IsBitfield() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeMember, IsBitfield);
+
if (m_opaque_up)
return m_opaque_up->GetIsBitfield();
return false;
}
uint32_t SBTypeMember::GetBitfieldSizeInBits() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeMember, GetBitfieldSizeInBits);
+
if (m_opaque_up)
return m_opaque_up->GetBitfieldBitSize();
return 0;
bool SBTypeMember::GetDescription(lldb::SBStream &description,
lldb::DescriptionLevel description_level) {
+ LLDB_RECORD_METHOD(bool, SBTypeMember, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel), description,
+ description_level);
+
Stream &strm = description.ref();
if (m_opaque_up) {
const TypeMemberImpl &SBTypeMember::ref() const { return *m_opaque_up; }
-SBTypeMemberFunction::SBTypeMemberFunction() : m_opaque_sp() {}
+SBTypeMemberFunction::SBTypeMemberFunction() : m_opaque_sp() {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeMemberFunction);
+}
SBTypeMemberFunction::~SBTypeMemberFunction() {}
SBTypeMemberFunction::SBTypeMemberFunction(const SBTypeMemberFunction &rhs)
- : m_opaque_sp(rhs.m_opaque_sp) {}
+ : m_opaque_sp(rhs.m_opaque_sp) {
+ LLDB_RECORD_CONSTRUCTOR(SBTypeMemberFunction,
+ (const lldb::SBTypeMemberFunction &), rhs);
+}
lldb::SBTypeMemberFunction &SBTypeMemberFunction::
operator=(const lldb::SBTypeMemberFunction &rhs) {
+ LLDB_RECORD_METHOD(
+ lldb::SBTypeMemberFunction &,
+ SBTypeMemberFunction, operator=,(const lldb::SBTypeMemberFunction &),
+ rhs);
+
if (this != &rhs)
m_opaque_sp = rhs.m_opaque_sp;
return *this;
}
-bool SBTypeMemberFunction::IsValid() const { return m_opaque_sp.get(); }
+bool SBTypeMemberFunction::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMemberFunction, IsValid);
+
+ return m_opaque_sp.get();
+}
const char *SBTypeMemberFunction::GetName() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMemberFunction, GetName);
+
if (m_opaque_sp)
return m_opaque_sp->GetName().GetCString();
return NULL;
}
const char *SBTypeMemberFunction::GetDemangledName() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMemberFunction,
+ GetDemangledName);
+
if (m_opaque_sp) {
ConstString mangled_str = m_opaque_sp->GetMangledName();
if (mangled_str) {
}
const char *SBTypeMemberFunction::GetMangledName() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMemberFunction,
+ GetMangledName);
+
if (m_opaque_sp)
return m_opaque_sp->GetMangledName().GetCString();
return NULL;
}
SBType SBTypeMemberFunction::GetType() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeMemberFunction, GetType);
+
SBType sb_type;
if (m_opaque_sp) {
sb_type.SetSP(lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetType())));
}
- return sb_type;
+ return LLDB_RECORD_RESULT(sb_type);
}
lldb::SBType SBTypeMemberFunction::GetReturnType() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeMemberFunction, GetReturnType);
+
SBType sb_type;
if (m_opaque_sp) {
sb_type.SetSP(lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetReturnType())));
}
- return sb_type;
+ return LLDB_RECORD_RESULT(sb_type);
}
uint32_t SBTypeMemberFunction::GetNumberOfArguments() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeMemberFunction,
+ GetNumberOfArguments);
+
if (m_opaque_sp)
return m_opaque_sp->GetNumArguments();
return 0;
}
lldb::SBType SBTypeMemberFunction::GetArgumentTypeAtIndex(uint32_t i) {
+ LLDB_RECORD_METHOD(lldb::SBType, SBTypeMemberFunction, GetArgumentTypeAtIndex,
+ (uint32_t), i);
+
SBType sb_type;
if (m_opaque_sp) {
sb_type.SetSP(
lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetArgumentAtIndex(i))));
}
- return sb_type;
+ return LLDB_RECORD_RESULT(sb_type);
}
lldb::MemberFunctionKind SBTypeMemberFunction::GetKind() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::MemberFunctionKind, SBTypeMemberFunction,
+ GetKind);
+
if (m_opaque_sp)
return m_opaque_sp->GetKind();
return lldb::eMemberFunctionKindUnknown;
bool SBTypeMemberFunction::GetDescription(
lldb::SBStream &description, lldb::DescriptionLevel description_level) {
+ LLDB_RECORD_METHOD(bool, SBTypeMemberFunction, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel), description,
+ description_level);
+
Stream &strm = description.ref();
if (m_opaque_sp)
//===----------------------------------------------------------------------===//
#include "lldb/API/SBTypeCategory.h"
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBTypeFilter.h"
typedef std::pair<lldb::TypeCategoryImplSP, user_id_t> ImplType;
-SBTypeCategory::SBTypeCategory() : m_opaque_sp() {}
+SBTypeCategory::SBTypeCategory() : m_opaque_sp() {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeCategory);
+}
SBTypeCategory::SBTypeCategory(const char *name) : m_opaque_sp() {
DataVisualization::Categories::GetCategory(ConstString(name), m_opaque_sp);
}
SBTypeCategory::SBTypeCategory(const lldb::SBTypeCategory &rhs)
- : m_opaque_sp(rhs.m_opaque_sp) {}
+ : m_opaque_sp(rhs.m_opaque_sp) {
+ LLDB_RECORD_CONSTRUCTOR(SBTypeCategory, (const lldb::SBTypeCategory &), rhs);
+}
SBTypeCategory::~SBTypeCategory() {}
-bool SBTypeCategory::IsValid() const { return (m_opaque_sp.get() != NULL); }
+bool SBTypeCategory::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeCategory, IsValid);
+
+ return (m_opaque_sp.get() != NULL);
+}
bool SBTypeCategory::GetEnabled() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeCategory, GetEnabled);
+
if (!IsValid())
return false;
return m_opaque_sp->IsEnabled();
}
void SBTypeCategory::SetEnabled(bool enabled) {
+ LLDB_RECORD_METHOD(void, SBTypeCategory, SetEnabled, (bool), enabled);
+
if (!IsValid())
return;
if (enabled)
}
const char *SBTypeCategory::GetName() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeCategory, GetName);
+
if (!IsValid())
return NULL;
return m_opaque_sp->GetName();
}
lldb::LanguageType SBTypeCategory::GetLanguageAtIndex(uint32_t idx) {
+ LLDB_RECORD_METHOD(lldb::LanguageType, SBTypeCategory, GetLanguageAtIndex,
+ (uint32_t), idx);
+
if (IsValid())
return m_opaque_sp->GetLanguageAtIndex(idx);
return lldb::eLanguageTypeUnknown;
}
uint32_t SBTypeCategory::GetNumLanguages() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumLanguages);
+
if (IsValid())
return m_opaque_sp->GetNumLanguages();
return 0;
}
void SBTypeCategory::AddLanguage(lldb::LanguageType language) {
+ LLDB_RECORD_METHOD(void, SBTypeCategory, AddLanguage, (lldb::LanguageType),
+ language);
+
if (IsValid())
m_opaque_sp->AddLanguage(language);
}
uint32_t SBTypeCategory::GetNumFormats() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumFormats);
+
if (!IsValid())
return 0;
}
uint32_t SBTypeCategory::GetNumSummaries() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumSummaries);
+
if (!IsValid())
return 0;
return m_opaque_sp->GetTypeSummariesContainer()->GetCount() +
}
uint32_t SBTypeCategory::GetNumFilters() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumFilters);
+
if (!IsValid())
return 0;
return m_opaque_sp->GetTypeFiltersContainer()->GetCount() +
#ifndef LLDB_DISABLE_PYTHON
uint32_t SBTypeCategory::GetNumSynthetics() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumSynthetics);
+
if (!IsValid())
return 0;
return m_opaque_sp->GetTypeSyntheticsContainer()->GetCount() +
lldb::SBTypeNameSpecifier
SBTypeCategory::GetTypeNameSpecifierForFilterAtIndex(uint32_t index) {
+ LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
+ GetTypeNameSpecifierForFilterAtIndex, (uint32_t), index);
+
if (!IsValid())
- return SBTypeNameSpecifier();
- return SBTypeNameSpecifier(
- m_opaque_sp->GetTypeNameSpecifierForFilterAtIndex(index));
+ return LLDB_RECORD_RESULT(SBTypeNameSpecifier());
+ return LLDB_RECORD_RESULT(SBTypeNameSpecifier(
+ m_opaque_sp->GetTypeNameSpecifierForFilterAtIndex(index)));
}
lldb::SBTypeNameSpecifier
SBTypeCategory::GetTypeNameSpecifierForFormatAtIndex(uint32_t index) {
+ LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
+ GetTypeNameSpecifierForFormatAtIndex, (uint32_t), index);
+
if (!IsValid())
- return SBTypeNameSpecifier();
- return SBTypeNameSpecifier(
- m_opaque_sp->GetTypeNameSpecifierForFormatAtIndex(index));
+ return LLDB_RECORD_RESULT(SBTypeNameSpecifier());
+ return LLDB_RECORD_RESULT(SBTypeNameSpecifier(
+ m_opaque_sp->GetTypeNameSpecifierForFormatAtIndex(index)));
}
lldb::SBTypeNameSpecifier
SBTypeCategory::GetTypeNameSpecifierForSummaryAtIndex(uint32_t index) {
+ LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
+ GetTypeNameSpecifierForSummaryAtIndex, (uint32_t), index);
+
if (!IsValid())
- return SBTypeNameSpecifier();
- return SBTypeNameSpecifier(
- m_opaque_sp->GetTypeNameSpecifierForSummaryAtIndex(index));
+ return LLDB_RECORD_RESULT(SBTypeNameSpecifier());
+ return LLDB_RECORD_RESULT(SBTypeNameSpecifier(
+ m_opaque_sp->GetTypeNameSpecifierForSummaryAtIndex(index)));
}
#ifndef LLDB_DISABLE_PYTHON
lldb::SBTypeNameSpecifier
SBTypeCategory::GetTypeNameSpecifierForSyntheticAtIndex(uint32_t index) {
+ LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
+ GetTypeNameSpecifierForSyntheticAtIndex, (uint32_t),
+ index);
+
if (!IsValid())
- return SBTypeNameSpecifier();
- return SBTypeNameSpecifier(
- m_opaque_sp->GetTypeNameSpecifierForSyntheticAtIndex(index));
+ return LLDB_RECORD_RESULT(SBTypeNameSpecifier());
+ return LLDB_RECORD_RESULT(SBTypeNameSpecifier(
+ m_opaque_sp->GetTypeNameSpecifierForSyntheticAtIndex(index)));
}
#endif
SBTypeFilter SBTypeCategory::GetFilterForType(SBTypeNameSpecifier spec) {
+ LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterForType,
+ (lldb::SBTypeNameSpecifier), spec);
+
if (!IsValid())
- return SBTypeFilter();
+ return LLDB_RECORD_RESULT(SBTypeFilter());
if (!spec.IsValid())
- return SBTypeFilter();
+ return LLDB_RECORD_RESULT(SBTypeFilter());
lldb::TypeFilterImplSP children_sp;
ConstString(spec.GetName()), children_sp);
if (!children_sp)
- return lldb::SBTypeFilter();
+ return LLDB_RECORD_RESULT(lldb::SBTypeFilter());
TypeFilterImplSP filter_sp =
std::static_pointer_cast<TypeFilterImpl>(children_sp);
- return lldb::SBTypeFilter(filter_sp);
+ return LLDB_RECORD_RESULT(lldb::SBTypeFilter(filter_sp));
}
SBTypeFormat SBTypeCategory::GetFormatForType(SBTypeNameSpecifier spec) {
+ LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatForType,
+ (lldb::SBTypeNameSpecifier), spec);
+
if (!IsValid())
- return SBTypeFormat();
+ return LLDB_RECORD_RESULT(SBTypeFormat());
if (!spec.IsValid())
- return SBTypeFormat();
+ return LLDB_RECORD_RESULT(SBTypeFormat());
lldb::TypeFormatImplSP format_sp;
ConstString(spec.GetName()), format_sp);
if (!format_sp)
- return lldb::SBTypeFormat();
+ return LLDB_RECORD_RESULT(lldb::SBTypeFormat());
- return lldb::SBTypeFormat(format_sp);
+ return LLDB_RECORD_RESULT(lldb::SBTypeFormat(format_sp));
}
#ifndef LLDB_DISABLE_PYTHON
SBTypeSummary SBTypeCategory::GetSummaryForType(SBTypeNameSpecifier spec) {
+ LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryForType,
+ (lldb::SBTypeNameSpecifier), spec);
+
if (!IsValid())
- return SBTypeSummary();
+ return LLDB_RECORD_RESULT(SBTypeSummary());
if (!spec.IsValid())
- return SBTypeSummary();
+ return LLDB_RECORD_RESULT(SBTypeSummary());
lldb::TypeSummaryImplSP summary_sp;
ConstString(spec.GetName()), summary_sp);
if (!summary_sp)
- return lldb::SBTypeSummary();
+ return LLDB_RECORD_RESULT(lldb::SBTypeSummary());
- return lldb::SBTypeSummary(summary_sp);
+ return LLDB_RECORD_RESULT(lldb::SBTypeSummary(summary_sp));
}
#endif // LLDB_DISABLE_PYTHON
#ifndef LLDB_DISABLE_PYTHON
SBTypeSynthetic SBTypeCategory::GetSyntheticForType(SBTypeNameSpecifier spec) {
+ LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBTypeCategory, GetSyntheticForType,
+ (lldb::SBTypeNameSpecifier), spec);
+
if (!IsValid())
- return SBTypeSynthetic();
+ return LLDB_RECORD_RESULT(SBTypeSynthetic());
if (!spec.IsValid())
- return SBTypeSynthetic();
+ return LLDB_RECORD_RESULT(SBTypeSynthetic());
lldb::SyntheticChildrenSP children_sp;
ConstString(spec.GetName()), children_sp);
if (!children_sp)
- return lldb::SBTypeSynthetic();
+ return LLDB_RECORD_RESULT(lldb::SBTypeSynthetic());
ScriptedSyntheticChildrenSP synth_sp =
std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp);
- return lldb::SBTypeSynthetic(synth_sp);
+ return LLDB_RECORD_RESULT(lldb::SBTypeSynthetic(synth_sp));
}
#endif
#ifndef LLDB_DISABLE_PYTHON
SBTypeFilter SBTypeCategory::GetFilterAtIndex(uint32_t index) {
+ LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterAtIndex,
+ (uint32_t), index);
+
if (!IsValid())
- return SBTypeFilter();
+ return LLDB_RECORD_RESULT(SBTypeFilter());
lldb::SyntheticChildrenSP children_sp =
m_opaque_sp->GetSyntheticAtIndex((index));
if (!children_sp.get())
- return lldb::SBTypeFilter();
+ return LLDB_RECORD_RESULT(lldb::SBTypeFilter());
TypeFilterImplSP filter_sp =
std::static_pointer_cast<TypeFilterImpl>(children_sp);
- return lldb::SBTypeFilter(filter_sp);
+ return LLDB_RECORD_RESULT(lldb::SBTypeFilter(filter_sp));
}
#endif
SBTypeFormat SBTypeCategory::GetFormatAtIndex(uint32_t index) {
+ LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatAtIndex,
+ (uint32_t), index);
+
if (!IsValid())
- return SBTypeFormat();
- return SBTypeFormat(m_opaque_sp->GetFormatAtIndex((index)));
+ return LLDB_RECORD_RESULT(SBTypeFormat());
+ return LLDB_RECORD_RESULT(
+ SBTypeFormat(m_opaque_sp->GetFormatAtIndex((index))));
}
#ifndef LLDB_DISABLE_PYTHON
SBTypeSummary SBTypeCategory::GetSummaryAtIndex(uint32_t index) {
+ LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryAtIndex,
+ (uint32_t), index);
+
if (!IsValid())
- return SBTypeSummary();
- return SBTypeSummary(m_opaque_sp->GetSummaryAtIndex((index)));
+ return LLDB_RECORD_RESULT(SBTypeSummary());
+ return LLDB_RECORD_RESULT(
+ SBTypeSummary(m_opaque_sp->GetSummaryAtIndex((index))));
}
#endif
#ifndef LLDB_DISABLE_PYTHON
SBTypeSynthetic SBTypeCategory::GetSyntheticAtIndex(uint32_t index) {
+ LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBTypeCategory, GetSyntheticAtIndex,
+ (uint32_t), index);
+
if (!IsValid())
- return SBTypeSynthetic();
+ return LLDB_RECORD_RESULT(SBTypeSynthetic());
lldb::SyntheticChildrenSP children_sp =
m_opaque_sp->GetSyntheticAtIndex((index));
if (!children_sp.get())
- return lldb::SBTypeSynthetic();
+ return LLDB_RECORD_RESULT(lldb::SBTypeSynthetic());
ScriptedSyntheticChildrenSP synth_sp =
std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp);
- return lldb::SBTypeSynthetic(synth_sp);
+ return LLDB_RECORD_RESULT(lldb::SBTypeSynthetic(synth_sp));
}
#endif
bool SBTypeCategory::AddTypeFormat(SBTypeNameSpecifier type_name,
SBTypeFormat format) {
+ LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeFormat,
+ (lldb::SBTypeNameSpecifier, lldb::SBTypeFormat), type_name,
+ format);
+
if (!IsValid())
return false;
}
bool SBTypeCategory::DeleteTypeFormat(SBTypeNameSpecifier type_name) {
+ LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeFormat,
+ (lldb::SBTypeNameSpecifier), type_name);
+
if (!IsValid())
return false;
#ifndef LLDB_DISABLE_PYTHON
bool SBTypeCategory::AddTypeSummary(SBTypeNameSpecifier type_name,
SBTypeSummary summary) {
+ LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeSummary,
+ (lldb::SBTypeNameSpecifier, lldb::SBTypeSummary),
+ type_name, summary);
+
if (!IsValid())
return false;
#endif
bool SBTypeCategory::DeleteTypeSummary(SBTypeNameSpecifier type_name) {
+ LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeSummary,
+ (lldb::SBTypeNameSpecifier), type_name);
+
if (!IsValid())
return false;
bool SBTypeCategory::AddTypeFilter(SBTypeNameSpecifier type_name,
SBTypeFilter filter) {
+ LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeFilter,
+ (lldb::SBTypeNameSpecifier, lldb::SBTypeFilter), type_name,
+ filter);
+
if (!IsValid())
return false;
}
bool SBTypeCategory::DeleteTypeFilter(SBTypeNameSpecifier type_name) {
+ LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeFilter,
+ (lldb::SBTypeNameSpecifier), type_name);
+
if (!IsValid())
return false;
#ifndef LLDB_DISABLE_PYTHON
bool SBTypeCategory::AddTypeSynthetic(SBTypeNameSpecifier type_name,
SBTypeSynthetic synth) {
+ LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeSynthetic,
+ (lldb::SBTypeNameSpecifier, lldb::SBTypeSynthetic),
+ type_name, synth);
+
if (!IsValid())
return false;
}
bool SBTypeCategory::DeleteTypeSynthetic(SBTypeNameSpecifier type_name) {
+ LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeSynthetic,
+ (lldb::SBTypeNameSpecifier), type_name);
+
if (!IsValid())
return false;
bool SBTypeCategory::GetDescription(lldb::SBStream &description,
lldb::DescriptionLevel description_level) {
+ LLDB_RECORD_METHOD(bool, SBTypeCategory, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel), description,
+ description_level);
+
if (!IsValid())
return false;
description.Printf("Category name: %s\n", GetName());
lldb::SBTypeCategory &SBTypeCategory::
operator=(const lldb::SBTypeCategory &rhs) {
+ LLDB_RECORD_METHOD(lldb::SBTypeCategory &,
+ SBTypeCategory, operator=,(const lldb::SBTypeCategory &),
+ rhs);
+
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
}
}
bool SBTypeCategory::operator==(lldb::SBTypeCategory &rhs) {
+ LLDB_RECORD_METHOD(bool, SBTypeCategory, operator==,(lldb::SBTypeCategory &),
+ rhs);
+
if (!IsValid())
return !rhs.IsValid();
}
bool SBTypeCategory::operator!=(lldb::SBTypeCategory &rhs) {
+ LLDB_RECORD_METHOD(bool, SBTypeCategory, operator!=,(lldb::SBTypeCategory &),
+ rhs);
+
if (!IsValid())
return rhs.IsValid();
//===----------------------------------------------------------------------===//
#include "lldb/API/SBTypeEnumMember.h"
+#include "SBReproducerPrivate.h"
#include "Utils.h"
#include "lldb/API/SBDefines.h"
#include "lldb/API/SBStream.h"
using namespace lldb;
using namespace lldb_private;
-SBTypeEnumMember::SBTypeEnumMember() : m_opaque_sp() {}
+SBTypeEnumMember::SBTypeEnumMember() : m_opaque_sp() {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeEnumMember);
+}
SBTypeEnumMember::~SBTypeEnumMember() {}
SBTypeEnumMember::SBTypeEnumMember(const SBTypeEnumMember &rhs)
: m_opaque_sp() {
+ LLDB_RECORD_CONSTRUCTOR(SBTypeEnumMember, (const lldb::SBTypeEnumMember &),
+ rhs);
+
m_opaque_sp = clone(rhs.m_opaque_sp);
}
SBTypeEnumMember &SBTypeEnumMember::operator=(const SBTypeEnumMember &rhs) {
+ LLDB_RECORD_CONSTRUCTOR(SBTypeEnumMember, (const lldb::SBTypeEnumMember &),
+ rhs);
+
if (this != &rhs)
m_opaque_sp = clone(rhs.m_opaque_sp);
return *this;
}
-bool SBTypeEnumMember::IsValid() const { return m_opaque_sp.get(); }
+bool SBTypeEnumMember::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMember, IsValid);
+
+ return m_opaque_sp.get();
+}
const char *SBTypeEnumMember::GetName() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeEnumMember, GetName);
+
if (m_opaque_sp.get())
return m_opaque_sp->GetName().GetCString();
return NULL;
}
int64_t SBTypeEnumMember::GetValueAsSigned() {
+ LLDB_RECORD_METHOD_NO_ARGS(int64_t, SBTypeEnumMember, GetValueAsSigned);
+
if (m_opaque_sp.get())
return m_opaque_sp->GetValueAsSigned();
return 0;
}
uint64_t SBTypeEnumMember::GetValueAsUnsigned() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBTypeEnumMember, GetValueAsUnsigned);
+
if (m_opaque_sp.get())
return m_opaque_sp->GetValueAsUnsigned();
return 0;
}
SBType SBTypeEnumMember::GetType() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeEnumMember, GetType);
+
SBType sb_type;
if (m_opaque_sp.get()) {
sb_type.SetSP(m_opaque_sp->GetIntegerType());
}
- return sb_type;
+ return LLDB_RECORD_RESULT(sb_type);
}
void SBTypeEnumMember::reset(TypeEnumMemberImpl *type_member_impl) {
}
SBTypeEnumMemberList::SBTypeEnumMemberList()
- : m_opaque_up(new TypeEnumMemberListImpl()) {}
+ : m_opaque_up(new TypeEnumMemberListImpl()) {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeEnumMemberList);
+}
SBTypeEnumMemberList::SBTypeEnumMemberList(const SBTypeEnumMemberList &rhs)
: m_opaque_up(new TypeEnumMemberListImpl()) {
+ LLDB_RECORD_CONSTRUCTOR(SBTypeEnumMemberList,
+ (const lldb::SBTypeEnumMemberList &), rhs);
+
for (uint32_t i = 0,
rhs_size = const_cast<SBTypeEnumMemberList &>(rhs).GetSize();
i < rhs_size; i++)
Append(const_cast<SBTypeEnumMemberList &>(rhs).GetTypeEnumMemberAtIndex(i));
}
-bool SBTypeEnumMemberList::IsValid() { return (m_opaque_up != NULL); }
+bool SBTypeEnumMemberList::IsValid() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeEnumMemberList, IsValid);
+
+ return (m_opaque_up != NULL);
+}
SBTypeEnumMemberList &SBTypeEnumMemberList::
operator=(const SBTypeEnumMemberList &rhs) {
+ LLDB_RECORD_METHOD(
+ lldb::SBTypeEnumMemberList &,
+ SBTypeEnumMemberList, operator=,(const lldb::SBTypeEnumMemberList &),
+ rhs);
+
if (this != &rhs) {
m_opaque_up.reset(new TypeEnumMemberListImpl());
for (uint32_t i = 0,
}
void SBTypeEnumMemberList::Append(SBTypeEnumMember enum_member) {
+ LLDB_RECORD_METHOD(void, SBTypeEnumMemberList, Append,
+ (lldb::SBTypeEnumMember), enum_member);
+
if (enum_member.IsValid())
m_opaque_up->Append(enum_member.m_opaque_sp);
}
SBTypeEnumMember
SBTypeEnumMemberList::GetTypeEnumMemberAtIndex(uint32_t index) {
+ LLDB_RECORD_METHOD(lldb::SBTypeEnumMember, SBTypeEnumMemberList,
+ GetTypeEnumMemberAtIndex, (uint32_t), index);
+
if (m_opaque_up)
- return SBTypeEnumMember(m_opaque_up->GetTypeEnumMemberAtIndex(index));
- return SBTypeEnumMember();
+ return LLDB_RECORD_RESULT(
+ SBTypeEnumMember(m_opaque_up->GetTypeEnumMemberAtIndex(index)));
+ return LLDB_RECORD_RESULT(SBTypeEnumMember());
}
-uint32_t SBTypeEnumMemberList::GetSize() { return m_opaque_up->GetSize(); }
+uint32_t SBTypeEnumMemberList::GetSize() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeEnumMemberList, GetSize);
+
+ return m_opaque_up->GetSize();
+}
SBTypeEnumMemberList::~SBTypeEnumMemberList() {}
bool SBTypeEnumMember::GetDescription(
lldb::SBStream &description, lldb::DescriptionLevel description_level) {
+ LLDB_RECORD_METHOD(bool, SBTypeEnumMember, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel), description,
+ description_level);
+
Stream &strm = description.ref();
if (m_opaque_sp.get()) {
//===----------------------------------------------------------------------===//
#include "lldb/API/SBTypeFilter.h"
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBStream.h"
using namespace lldb;
using namespace lldb_private;
-SBTypeFilter::SBTypeFilter() : m_opaque_sp() {}
+SBTypeFilter::SBTypeFilter() : m_opaque_sp() {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeFilter);
+}
SBTypeFilter::SBTypeFilter(uint32_t options)
- : m_opaque_sp(TypeFilterImplSP(new TypeFilterImpl(options))) {}
+ : m_opaque_sp(TypeFilterImplSP(new TypeFilterImpl(options))) {
+ LLDB_RECORD_CONSTRUCTOR(SBTypeFilter, (uint32_t), options);
+}
SBTypeFilter::SBTypeFilter(const lldb::SBTypeFilter &rhs)
- : m_opaque_sp(rhs.m_opaque_sp) {}
+ : m_opaque_sp(rhs.m_opaque_sp) {
+ LLDB_RECORD_CONSTRUCTOR(SBTypeFilter, (const lldb::SBTypeFilter &), rhs);
+}
SBTypeFilter::~SBTypeFilter() {}
-bool SBTypeFilter::IsValid() const { return m_opaque_sp.get() != NULL; }
+bool SBTypeFilter::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFilter, IsValid);
+
+ return m_opaque_sp.get() != NULL;
+}
uint32_t SBTypeFilter::GetOptions() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeFilter, GetOptions);
+
if (IsValid())
return m_opaque_sp->GetOptions();
return 0;
}
void SBTypeFilter::SetOptions(uint32_t value) {
+ LLDB_RECORD_METHOD(void, SBTypeFilter, SetOptions, (uint32_t), value);
+
if (CopyOnWrite_Impl())
m_opaque_sp->SetOptions(value);
}
bool SBTypeFilter::GetDescription(lldb::SBStream &description,
lldb::DescriptionLevel description_level) {
+ LLDB_RECORD_METHOD(bool, SBTypeFilter, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel), description,
+ description_level);
+
if (!IsValid())
return false;
else {
}
void SBTypeFilter::Clear() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBTypeFilter, Clear);
+
if (CopyOnWrite_Impl())
m_opaque_sp->Clear();
}
uint32_t SBTypeFilter::GetNumberOfExpressionPaths() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeFilter,
+ GetNumberOfExpressionPaths);
+
if (IsValid())
return m_opaque_sp->GetCount();
return 0;
}
const char *SBTypeFilter::GetExpressionPathAtIndex(uint32_t i) {
+ LLDB_RECORD_METHOD(const char *, SBTypeFilter, GetExpressionPathAtIndex,
+ (uint32_t), i);
+
if (IsValid()) {
const char *item = m_opaque_sp->GetExpressionPathAtIndex(i);
if (item && *item == '.')
}
bool SBTypeFilter::ReplaceExpressionPathAtIndex(uint32_t i, const char *item) {
+ LLDB_RECORD_METHOD(bool, SBTypeFilter, ReplaceExpressionPathAtIndex,
+ (uint32_t, const char *), i, item);
+
if (CopyOnWrite_Impl())
return m_opaque_sp->SetExpressionPathAtIndex(i, item);
else
}
void SBTypeFilter::AppendExpressionPath(const char *item) {
+ LLDB_RECORD_METHOD(void, SBTypeFilter, AppendExpressionPath, (const char *),
+ item);
+
if (CopyOnWrite_Impl())
m_opaque_sp->AddExpressionPath(item);
}
lldb::SBTypeFilter &SBTypeFilter::operator=(const lldb::SBTypeFilter &rhs) {
+ LLDB_RECORD_METHOD(lldb::SBTypeFilter &,
+ SBTypeFilter, operator=,(const lldb::SBTypeFilter &), rhs);
+
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
}
}
bool SBTypeFilter::operator==(lldb::SBTypeFilter &rhs) {
+ LLDB_RECORD_METHOD(bool, SBTypeFilter, operator==,(lldb::SBTypeFilter &),
+ rhs);
+
if (!IsValid())
return !rhs.IsValid();
}
bool SBTypeFilter::IsEqualTo(lldb::SBTypeFilter &rhs) {
+ LLDB_RECORD_METHOD(bool, SBTypeFilter, IsEqualTo, (lldb::SBTypeFilter &),
+ rhs);
+
if (!IsValid())
return !rhs.IsValid();
}
bool SBTypeFilter::operator!=(lldb::SBTypeFilter &rhs) {
+ LLDB_RECORD_METHOD(bool, SBTypeFilter, operator!=,(lldb::SBTypeFilter &),
+ rhs);
+
if (!IsValid())
return !rhs.IsValid();
//===----------------------------------------------------------------------===//
#include "lldb/API/SBTypeFormat.h"
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBStream.h"
using namespace lldb;
using namespace lldb_private;
-SBTypeFormat::SBTypeFormat() : m_opaque_sp() {}
+SBTypeFormat::SBTypeFormat() : m_opaque_sp() {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeFormat);
+}
SBTypeFormat::SBTypeFormat(lldb::Format format, uint32_t options)
: m_opaque_sp(
- TypeFormatImplSP(new TypeFormatImpl_Format(format, options))) {}
+ TypeFormatImplSP(new TypeFormatImpl_Format(format, options))) {
+ LLDB_RECORD_CONSTRUCTOR(SBTypeFormat, (lldb::Format, uint32_t), format,
+ options);
+}
SBTypeFormat::SBTypeFormat(const char *type, uint32_t options)
: m_opaque_sp(TypeFormatImplSP(new TypeFormatImpl_EnumType(
- ConstString(type ? type : ""), options))) {}
+ ConstString(type ? type : ""), options))) {
+ LLDB_RECORD_CONSTRUCTOR(SBTypeFormat, (const char *, uint32_t), type,
+ options);
+}
SBTypeFormat::SBTypeFormat(const lldb::SBTypeFormat &rhs)
- : m_opaque_sp(rhs.m_opaque_sp) {}
+ : m_opaque_sp(rhs.m_opaque_sp) {
+ LLDB_RECORD_CONSTRUCTOR(SBTypeFormat, (const lldb::SBTypeFormat &), rhs);
+}
SBTypeFormat::~SBTypeFormat() {}
-bool SBTypeFormat::IsValid() const { return m_opaque_sp.get() != NULL; }
+bool SBTypeFormat::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFormat, IsValid);
+
+ return m_opaque_sp.get() != NULL;
+}
lldb::Format SBTypeFormat::GetFormat() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::Format, SBTypeFormat, GetFormat);
+
if (IsValid() && m_opaque_sp->GetType() == TypeFormatImpl::Type::eTypeFormat)
return ((TypeFormatImpl_Format *)m_opaque_sp.get())->GetFormat();
return lldb::eFormatInvalid;
}
const char *SBTypeFormat::GetTypeName() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeFormat, GetTypeName);
+
if (IsValid() && m_opaque_sp->GetType() == TypeFormatImpl::Type::eTypeEnum)
return ((TypeFormatImpl_EnumType *)m_opaque_sp.get())
->GetTypeName()
}
uint32_t SBTypeFormat::GetOptions() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeFormat, GetOptions);
+
if (IsValid())
return m_opaque_sp->GetOptions();
return 0;
}
void SBTypeFormat::SetFormat(lldb::Format fmt) {
+ LLDB_RECORD_METHOD(void, SBTypeFormat, SetFormat, (lldb::Format), fmt);
+
if (CopyOnWrite_Impl(Type::eTypeFormat))
((TypeFormatImpl_Format *)m_opaque_sp.get())->SetFormat(fmt);
}
void SBTypeFormat::SetTypeName(const char *type) {
+ LLDB_RECORD_METHOD(void, SBTypeFormat, SetTypeName, (const char *), type);
+
if (CopyOnWrite_Impl(Type::eTypeEnum))
((TypeFormatImpl_EnumType *)m_opaque_sp.get())
->SetTypeName(ConstString(type ? type : ""));
}
void SBTypeFormat::SetOptions(uint32_t value) {
+ LLDB_RECORD_METHOD(void, SBTypeFormat, SetOptions, (uint32_t), value);
+
if (CopyOnWrite_Impl(Type::eTypeKeepSame))
m_opaque_sp->SetOptions(value);
}
bool SBTypeFormat::GetDescription(lldb::SBStream &description,
lldb::DescriptionLevel description_level) {
+ LLDB_RECORD_METHOD(bool, SBTypeFormat, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel), description,
+ description_level);
+
if (!IsValid())
return false;
else {
}
lldb::SBTypeFormat &SBTypeFormat::operator=(const lldb::SBTypeFormat &rhs) {
+ LLDB_RECORD_METHOD(lldb::SBTypeFormat &,
+ SBTypeFormat, operator=,(const lldb::SBTypeFormat &), rhs);
+
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
}
}
bool SBTypeFormat::operator==(lldb::SBTypeFormat &rhs) {
+ LLDB_RECORD_METHOD(bool, SBTypeFormat, operator==,(lldb::SBTypeFormat &),
+ rhs);
+
if (!IsValid())
return !rhs.IsValid();
return m_opaque_sp == rhs.m_opaque_sp;
}
bool SBTypeFormat::IsEqualTo(lldb::SBTypeFormat &rhs) {
+ LLDB_RECORD_METHOD(bool, SBTypeFormat, IsEqualTo, (lldb::SBTypeFormat &),
+ rhs);
+
if (!IsValid())
return !rhs.IsValid();
}
bool SBTypeFormat::operator!=(lldb::SBTypeFormat &rhs) {
+ LLDB_RECORD_METHOD(bool, SBTypeFormat, operator!=,(lldb::SBTypeFormat &),
+ rhs);
+
if (!IsValid())
return !rhs.IsValid();
return m_opaque_sp != rhs.m_opaque_sp;
//===----------------------------------------------------------------------===//
#include "lldb/API/SBTypeNameSpecifier.h"
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBType.h"
using namespace lldb;
using namespace lldb_private;
-SBTypeNameSpecifier::SBTypeNameSpecifier() : m_opaque_sp() {}
+SBTypeNameSpecifier::SBTypeNameSpecifier() : m_opaque_sp() {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeNameSpecifier);
+}
SBTypeNameSpecifier::SBTypeNameSpecifier(const char *name, bool is_regex)
: m_opaque_sp(new TypeNameSpecifierImpl(name, is_regex)) {
+ LLDB_RECORD_CONSTRUCTOR(SBTypeNameSpecifier, (const char *, bool), name,
+ is_regex);
+
if (name == NULL || (*name) == 0)
m_opaque_sp.reset();
}
SBTypeNameSpecifier::SBTypeNameSpecifier(SBType type) : m_opaque_sp() {
+ LLDB_RECORD_CONSTRUCTOR(SBTypeNameSpecifier, (lldb::SBType), type);
+
if (type.IsValid())
m_opaque_sp = TypeNameSpecifierImplSP(
new TypeNameSpecifierImpl(type.m_opaque_sp->GetCompilerType(true)));
}
SBTypeNameSpecifier::SBTypeNameSpecifier(const lldb::SBTypeNameSpecifier &rhs)
- : m_opaque_sp(rhs.m_opaque_sp) {}
+ : m_opaque_sp(rhs.m_opaque_sp) {
+ LLDB_RECORD_CONSTRUCTOR(SBTypeNameSpecifier,
+ (const lldb::SBTypeNameSpecifier &), rhs);
+}
SBTypeNameSpecifier::~SBTypeNameSpecifier() {}
-bool SBTypeNameSpecifier::IsValid() const { return m_opaque_sp.get() != NULL; }
+bool SBTypeNameSpecifier::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeNameSpecifier, IsValid);
+
+ return m_opaque_sp.get() != NULL;
+}
const char *SBTypeNameSpecifier::GetName() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeNameSpecifier, GetName);
+
if (!IsValid())
return NULL;
}
SBType SBTypeNameSpecifier::GetType() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeNameSpecifier, GetType);
+
if (!IsValid())
- return SBType();
+ return LLDB_RECORD_RESULT(SBType());
lldb_private::CompilerType c_type = m_opaque_sp->GetCompilerType();
if (c_type.IsValid())
- return SBType(c_type);
- return SBType();
+ return LLDB_RECORD_RESULT(SBType(c_type));
+ return LLDB_RECORD_RESULT(SBType());
}
bool SBTypeNameSpecifier::IsRegex() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeNameSpecifier, IsRegex);
+
if (!IsValid())
return false;
bool SBTypeNameSpecifier::GetDescription(
lldb::SBStream &description, lldb::DescriptionLevel description_level) {
+ LLDB_RECORD_METHOD(bool, SBTypeNameSpecifier, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel), description,
+ description_level);
+
if (!IsValid())
return false;
description.Printf("SBTypeNameSpecifier(%s,%s)", GetName(),
lldb::SBTypeNameSpecifier &SBTypeNameSpecifier::
operator=(const lldb::SBTypeNameSpecifier &rhs) {
+ LLDB_RECORD_METHOD(
+ lldb::SBTypeNameSpecifier &,
+ SBTypeNameSpecifier, operator=,(const lldb::SBTypeNameSpecifier &), rhs);
+
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
}
}
bool SBTypeNameSpecifier::operator==(lldb::SBTypeNameSpecifier &rhs) {
+ LLDB_RECORD_METHOD(
+ bool, SBTypeNameSpecifier, operator==,(lldb::SBTypeNameSpecifier &), rhs);
+
if (!IsValid())
return !rhs.IsValid();
return m_opaque_sp == rhs.m_opaque_sp;
}
bool SBTypeNameSpecifier::IsEqualTo(lldb::SBTypeNameSpecifier &rhs) {
+ LLDB_RECORD_METHOD(bool, SBTypeNameSpecifier, IsEqualTo,
+ (lldb::SBTypeNameSpecifier &), rhs);
+
if (!IsValid())
return !rhs.IsValid();
}
bool SBTypeNameSpecifier::operator!=(lldb::SBTypeNameSpecifier &rhs) {
+ LLDB_RECORD_METHOD(
+ bool, SBTypeNameSpecifier, operator!=,(lldb::SBTypeNameSpecifier &), rhs);
+
if (!IsValid())
return !rhs.IsValid();
return m_opaque_sp != rhs.m_opaque_sp;
//===----------------------------------------------------------------------===//
#include "lldb/API/SBTypeSummary.h"
+#include "SBReproducerPrivate.h"
#include "Utils.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBValue.h"
using namespace lldb;
using namespace lldb_private;
-SBTypeSummaryOptions::SBTypeSummaryOptions()
- : m_opaque_up(new TypeSummaryOptions()) {}
+SBTypeSummaryOptions::SBTypeSummaryOptions() {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeSummaryOptions);
+
+ m_opaque_up.reset(new TypeSummaryOptions());
+}
SBTypeSummaryOptions::SBTypeSummaryOptions(
const lldb::SBTypeSummaryOptions &rhs) {
+ LLDB_RECORD_CONSTRUCTOR(SBTypeSummaryOptions,
+ (const lldb::SBTypeSummaryOptions &), rhs);
+
m_opaque_up = clone(rhs.m_opaque_up);
}
SBTypeSummaryOptions::~SBTypeSummaryOptions() {}
-bool SBTypeSummaryOptions::IsValid() { return m_opaque_up.get(); }
+bool SBTypeSummaryOptions::IsValid() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummaryOptions, IsValid);
+
+ return m_opaque_up.get();
+}
lldb::LanguageType SBTypeSummaryOptions::GetLanguage() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::LanguageType, SBTypeSummaryOptions,
+ GetLanguage);
+
if (IsValid())
return m_opaque_up->GetLanguage();
return lldb::eLanguageTypeUnknown;
}
lldb::TypeSummaryCapping SBTypeSummaryOptions::GetCapping() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::TypeSummaryCapping, SBTypeSummaryOptions,
+ GetCapping);
+
if (IsValid())
return m_opaque_up->GetCapping();
return eTypeSummaryCapped;
}
void SBTypeSummaryOptions::SetLanguage(lldb::LanguageType l) {
+ LLDB_RECORD_METHOD(void, SBTypeSummaryOptions, SetLanguage,
+ (lldb::LanguageType), l);
+
if (IsValid())
m_opaque_up->SetLanguage(l);
}
void SBTypeSummaryOptions::SetCapping(lldb::TypeSummaryCapping c) {
+ LLDB_RECORD_METHOD(void, SBTypeSummaryOptions, SetCapping,
+ (lldb::TypeSummaryCapping), c);
+
if (IsValid())
m_opaque_up->SetCapping(c);
}
SBTypeSummaryOptions::SBTypeSummaryOptions(
const lldb_private::TypeSummaryOptions *lldb_object_ptr) {
+ LLDB_RECORD_CONSTRUCTOR(SBTypeSummaryOptions,
+ (const lldb_private::TypeSummaryOptions *),
+ lldb_object_ptr);
+
SetOptions(lldb_object_ptr);
}
m_opaque_up.reset(new TypeSummaryOptions());
}
-SBTypeSummary::SBTypeSummary() : m_opaque_sp() {}
+SBTypeSummary::SBTypeSummary() : m_opaque_sp() {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeSummary);
+}
SBTypeSummary SBTypeSummary::CreateWithSummaryString(const char *data,
uint32_t options) {
+ LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
+ CreateWithSummaryString, (const char *, uint32_t),
+ data, options);
+
if (!data || data[0] == 0)
- return SBTypeSummary();
+ return LLDB_RECORD_RESULT(SBTypeSummary());
- return SBTypeSummary(
- TypeSummaryImplSP(new StringSummaryFormat(options, data)));
+ return LLDB_RECORD_RESULT(
+ SBTypeSummary(TypeSummaryImplSP(new StringSummaryFormat(options, data))));
}
SBTypeSummary SBTypeSummary::CreateWithFunctionName(const char *data,
uint32_t options) {
+ LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
+ CreateWithFunctionName, (const char *, uint32_t),
+ data, options);
+
if (!data || data[0] == 0)
- return SBTypeSummary();
+ return LLDB_RECORD_RESULT(SBTypeSummary());
- return SBTypeSummary(
- TypeSummaryImplSP(new ScriptSummaryFormat(options, data)));
+ return LLDB_RECORD_RESULT(
+ SBTypeSummary(TypeSummaryImplSP(new ScriptSummaryFormat(options, data))));
}
SBTypeSummary SBTypeSummary::CreateWithScriptCode(const char *data,
uint32_t options) {
+ LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
+ CreateWithScriptCode, (const char *, uint32_t),
+ data, options);
+
if (!data || data[0] == 0)
- return SBTypeSummary();
+ return LLDB_RECORD_RESULT(SBTypeSummary());
- return SBTypeSummary(
- TypeSummaryImplSP(new ScriptSummaryFormat(options, "", data)));
+ return LLDB_RECORD_RESULT(SBTypeSummary(
+ TypeSummaryImplSP(new ScriptSummaryFormat(options, "", data))));
}
SBTypeSummary SBTypeSummary::CreateWithCallback(FormatCallback cb,
}
SBTypeSummary::SBTypeSummary(const lldb::SBTypeSummary &rhs)
- : m_opaque_sp(rhs.m_opaque_sp) {}
+ : m_opaque_sp(rhs.m_opaque_sp) {
+ LLDB_RECORD_CONSTRUCTOR(SBTypeSummary, (const lldb::SBTypeSummary &), rhs);
+}
SBTypeSummary::~SBTypeSummary() {}
-bool SBTypeSummary::IsValid() const { return m_opaque_sp.get() != NULL; }
+bool SBTypeSummary::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSummary, IsValid);
+
+ return m_opaque_sp.get() != NULL;
+}
bool SBTypeSummary::IsFunctionCode() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummary, IsFunctionCode);
+
if (!IsValid())
return false;
if (ScriptSummaryFormat *script_summary_ptr =
}
bool SBTypeSummary::IsFunctionName() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummary, IsFunctionName);
+
if (!IsValid())
return false;
if (ScriptSummaryFormat *script_summary_ptr =
}
bool SBTypeSummary::IsSummaryString() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummary, IsSummaryString);
+
if (!IsValid())
return false;
}
const char *SBTypeSummary::GetData() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeSummary, GetData);
+
if (!IsValid())
return NULL;
if (ScriptSummaryFormat *script_summary_ptr =
}
uint32_t SBTypeSummary::GetOptions() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeSummary, GetOptions);
+
if (!IsValid())
return lldb::eTypeOptionNone;
return m_opaque_sp->GetOptions();
}
void SBTypeSummary::SetOptions(uint32_t value) {
+ LLDB_RECORD_METHOD(void, SBTypeSummary, SetOptions, (uint32_t), value);
+
if (!CopyOnWrite_Impl())
return;
m_opaque_sp->SetOptions(value);
}
void SBTypeSummary::SetSummaryString(const char *data) {
+ LLDB_RECORD_METHOD(void, SBTypeSummary, SetSummaryString, (const char *),
+ data);
+
if (!IsValid())
return;
if (!llvm::isa<StringSummaryFormat>(m_opaque_sp.get()))
}
void SBTypeSummary::SetFunctionName(const char *data) {
+ LLDB_RECORD_METHOD(void, SBTypeSummary, SetFunctionName, (const char *),
+ data);
+
if (!IsValid())
return;
if (!llvm::isa<ScriptSummaryFormat>(m_opaque_sp.get()))
}
void SBTypeSummary::SetFunctionCode(const char *data) {
+ LLDB_RECORD_METHOD(void, SBTypeSummary, SetFunctionCode, (const char *),
+ data);
+
if (!IsValid())
return;
if (!llvm::isa<ScriptSummaryFormat>(m_opaque_sp.get()))
bool SBTypeSummary::GetDescription(lldb::SBStream &description,
lldb::DescriptionLevel description_level) {
+ LLDB_RECORD_METHOD(bool, SBTypeSummary, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel), description,
+ description_level);
+
if (!CopyOnWrite_Impl())
return false;
else {
}
bool SBTypeSummary::DoesPrintValue(lldb::SBValue value) {
+ LLDB_RECORD_METHOD(bool, SBTypeSummary, DoesPrintValue, (lldb::SBValue),
+ value);
+
if (!IsValid())
return false;
lldb::ValueObjectSP value_sp = value.GetSP();
}
lldb::SBTypeSummary &SBTypeSummary::operator=(const lldb::SBTypeSummary &rhs) {
+ LLDB_RECORD_METHOD(lldb::SBTypeSummary &,
+ SBTypeSummary, operator=,(const lldb::SBTypeSummary &),
+ rhs);
+
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
}
}
bool SBTypeSummary::operator==(lldb::SBTypeSummary &rhs) {
+ LLDB_RECORD_METHOD(bool, SBTypeSummary, operator==,(lldb::SBTypeSummary &),
+ rhs);
+
if (!IsValid())
return !rhs.IsValid();
return m_opaque_sp == rhs.m_opaque_sp;
}
bool SBTypeSummary::IsEqualTo(lldb::SBTypeSummary &rhs) {
+ LLDB_RECORD_METHOD(bool, SBTypeSummary, IsEqualTo, (lldb::SBTypeSummary &),
+ rhs);
+
if (IsValid()) {
// valid and invalid are different
if (!rhs.IsValid())
}
bool SBTypeSummary::operator!=(lldb::SBTypeSummary &rhs) {
+ LLDB_RECORD_METHOD(bool, SBTypeSummary, operator!=,(lldb::SBTypeSummary &),
+ rhs);
+
if (!IsValid())
return !rhs.IsValid();
return m_opaque_sp != rhs.m_opaque_sp;
//===----------------------------------------------------------------------===//
#include "lldb/API/SBTypeSynthetic.h"
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBStream.h"
#ifndef LLDB_DISABLE_PYTHON
-SBTypeSynthetic::SBTypeSynthetic() : m_opaque_sp() {}
+SBTypeSynthetic::SBTypeSynthetic() : m_opaque_sp() {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeSynthetic);
+}
SBTypeSynthetic SBTypeSynthetic::CreateWithClassName(const char *data,
uint32_t options) {
+ LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSynthetic, SBTypeSynthetic,
+ CreateWithClassName, (const char *, uint32_t), data,
+ options);
+
if (!data || data[0] == 0)
- return SBTypeSynthetic();
- return SBTypeSynthetic(ScriptedSyntheticChildrenSP(
- new ScriptedSyntheticChildren(options, data, "")));
+ return LLDB_RECORD_RESULT(SBTypeSynthetic());
+ return LLDB_RECORD_RESULT(SBTypeSynthetic(ScriptedSyntheticChildrenSP(
+ new ScriptedSyntheticChildren(options, data, ""))));
}
SBTypeSynthetic SBTypeSynthetic::CreateWithScriptCode(const char *data,
uint32_t options) {
+ LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSynthetic, SBTypeSynthetic,
+ CreateWithScriptCode, (const char *, uint32_t),
+ data, options);
+
if (!data || data[0] == 0)
- return SBTypeSynthetic();
- return SBTypeSynthetic(ScriptedSyntheticChildrenSP(
- new ScriptedSyntheticChildren(options, "", data)));
+ return LLDB_RECORD_RESULT(SBTypeSynthetic());
+ return LLDB_RECORD_RESULT(SBTypeSynthetic(ScriptedSyntheticChildrenSP(
+ new ScriptedSyntheticChildren(options, "", data))));
}
SBTypeSynthetic::SBTypeSynthetic(const lldb::SBTypeSynthetic &rhs)
- : m_opaque_sp(rhs.m_opaque_sp) {}
+ : m_opaque_sp(rhs.m_opaque_sp) {
+ LLDB_RECORD_CONSTRUCTOR(SBTypeSynthetic, (const lldb::SBTypeSynthetic &),
+ rhs);
+}
SBTypeSynthetic::~SBTypeSynthetic() {}
-bool SBTypeSynthetic::IsValid() const { return m_opaque_sp.get() != NULL; }
+bool SBTypeSynthetic::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSynthetic, IsValid);
+
+ return m_opaque_sp.get() != NULL;
+}
bool SBTypeSynthetic::IsClassCode() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSynthetic, IsClassCode);
+
if (!IsValid())
return false;
const char *code = m_opaque_sp->GetPythonCode();
}
bool SBTypeSynthetic::IsClassName() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSynthetic, IsClassName);
+
if (!IsValid())
return false;
return !IsClassCode();
}
const char *SBTypeSynthetic::GetData() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeSynthetic, GetData);
+
if (!IsValid())
return NULL;
if (IsClassCode())
}
void SBTypeSynthetic::SetClassName(const char *data) {
+ LLDB_RECORD_METHOD(void, SBTypeSynthetic, SetClassName, (const char *), data);
+
if (IsValid() && data && *data)
m_opaque_sp->SetPythonClassName(data);
}
void SBTypeSynthetic::SetClassCode(const char *data) {
+ LLDB_RECORD_METHOD(void, SBTypeSynthetic, SetClassCode, (const char *), data);
+
if (IsValid() && data && *data)
m_opaque_sp->SetPythonCode(data);
}
uint32_t SBTypeSynthetic::GetOptions() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeSynthetic, GetOptions);
+
if (!IsValid())
return lldb::eTypeOptionNone;
return m_opaque_sp->GetOptions();
}
void SBTypeSynthetic::SetOptions(uint32_t value) {
+ LLDB_RECORD_METHOD(void, SBTypeSynthetic, SetOptions, (uint32_t), value);
+
if (!CopyOnWrite_Impl())
return;
m_opaque_sp->SetOptions(value);
bool SBTypeSynthetic::GetDescription(lldb::SBStream &description,
lldb::DescriptionLevel description_level) {
+ LLDB_RECORD_METHOD(bool, SBTypeSynthetic, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel), description,
+ description_level);
+
if (m_opaque_sp) {
description.Printf("%s\n", m_opaque_sp->GetDescription().c_str());
return true;
lldb::SBTypeSynthetic &SBTypeSynthetic::
operator=(const lldb::SBTypeSynthetic &rhs) {
+ LLDB_RECORD_METHOD(lldb::SBTypeSynthetic &,
+ SBTypeSynthetic, operator=,(const lldb::SBTypeSynthetic &),
+ rhs);
+
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
}
}
bool SBTypeSynthetic::operator==(lldb::SBTypeSynthetic &rhs) {
+ LLDB_RECORD_METHOD(
+ bool, SBTypeSynthetic, operator==,(lldb::SBTypeSynthetic &), rhs);
+
if (!IsValid())
return !rhs.IsValid();
return m_opaque_sp == rhs.m_opaque_sp;
}
bool SBTypeSynthetic::IsEqualTo(lldb::SBTypeSynthetic &rhs) {
+ LLDB_RECORD_METHOD(bool, SBTypeSynthetic, IsEqualTo,
+ (lldb::SBTypeSynthetic &), rhs);
+
if (!IsValid())
return !rhs.IsValid();
}
bool SBTypeSynthetic::operator!=(lldb::SBTypeSynthetic &rhs) {
+ LLDB_RECORD_METHOD(
+ bool, SBTypeSynthetic, operator!=,(lldb::SBTypeSynthetic &), rhs);
+
if (!IsValid())
return !rhs.IsValid();
return m_opaque_sp != rhs.m_opaque_sp;
//
//===----------------------------------------------------------------------===//
+#include "SBReproducerPrivate.h"
#include "lldb/Target/Platform.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/UnixSignals.h"
using namespace lldb;
using namespace lldb_private;
-SBUnixSignals::SBUnixSignals() {}
+SBUnixSignals::SBUnixSignals() {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBUnixSignals);
+}
SBUnixSignals::SBUnixSignals(const SBUnixSignals &rhs)
- : m_opaque_wp(rhs.m_opaque_wp) {}
+ : m_opaque_wp(rhs.m_opaque_wp) {
+ LLDB_RECORD_CONSTRUCTOR(SBUnixSignals, (const lldb::SBUnixSignals &), rhs);
+}
SBUnixSignals::SBUnixSignals(ProcessSP &process_sp)
: m_opaque_wp(process_sp ? process_sp->GetUnixSignals() : nullptr) {}
: 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);
+
if (this != &rhs)
m_opaque_wp = rhs.m_opaque_wp;
return *this;
m_opaque_wp = signals_sp;
}
-void SBUnixSignals::Clear() { m_opaque_wp.reset(); }
+void SBUnixSignals::Clear() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBUnixSignals, Clear);
+
+ m_opaque_wp.reset();
+}
-bool SBUnixSignals::IsValid() const { return static_cast<bool>(GetSP()); }
+bool SBUnixSignals::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBUnixSignals, IsValid);
+
+ return static_cast<bool>(GetSP());
+}
const char *SBUnixSignals::GetSignalAsCString(int32_t signo) const {
+ LLDB_RECORD_METHOD_CONST(const char *, SBUnixSignals, GetSignalAsCString,
+ (int32_t), signo);
+
if (auto signals_sp = GetSP())
return signals_sp->GetSignalAsCString(signo);
}
int32_t SBUnixSignals::GetSignalNumberFromName(const char *name) const {
+ LLDB_RECORD_METHOD_CONST(int32_t, SBUnixSignals, GetSignalNumberFromName,
+ (const char *), name);
+
if (auto signals_sp = GetSP())
return signals_sp->GetSignalNumberFromName(name);
}
bool SBUnixSignals::GetShouldSuppress(int32_t signo) const {
+ LLDB_RECORD_METHOD_CONST(bool, SBUnixSignals, GetShouldSuppress, (int32_t),
+ signo);
+
if (auto signals_sp = GetSP())
return signals_sp->GetShouldSuppress(signo);
}
bool SBUnixSignals::SetShouldSuppress(int32_t signo, bool value) {
+ LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldSuppress, (int32_t, bool),
+ signo, value);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
auto signals_sp = GetSP();
}
bool SBUnixSignals::GetShouldStop(int32_t signo) const {
+ LLDB_RECORD_METHOD_CONST(bool, SBUnixSignals, GetShouldStop, (int32_t),
+ signo);
+
if (auto signals_sp = GetSP())
return signals_sp->GetShouldStop(signo);
}
bool SBUnixSignals::SetShouldStop(int32_t signo, bool value) {
+ LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldStop, (int32_t, bool), signo,
+ value);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
auto signals_sp = GetSP();
}
bool SBUnixSignals::GetShouldNotify(int32_t signo) const {
+ LLDB_RECORD_METHOD_CONST(bool, SBUnixSignals, GetShouldNotify, (int32_t),
+ signo);
+
if (auto signals_sp = GetSP())
return signals_sp->GetShouldNotify(signo);
}
bool SBUnixSignals::SetShouldNotify(int32_t signo, bool value) {
+ LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldNotify, (int32_t, bool),
+ signo, value);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
auto signals_sp = GetSP();
}
int32_t SBUnixSignals::GetNumSignals() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(int32_t, SBUnixSignals, GetNumSignals);
+
if (auto signals_sp = GetSP())
return signals_sp->GetNumSignals();
}
int32_t SBUnixSignals::GetSignalAtIndex(int32_t index) const {
+ LLDB_RECORD_METHOD_CONST(int32_t, SBUnixSignals, GetSignalAtIndex, (int32_t),
+ index);
+
if (auto signals_sp = GetSP())
return signals_sp->GetSignalAtIndex(index);
//===----------------------------------------------------------------------===//
#include "lldb/API/SBValue.h"
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBDeclaration.h"
#include "lldb/API/SBStream.h"
Status m_lock_error;
};
-SBValue::SBValue() : m_opaque_sp() {}
+SBValue::SBValue() : m_opaque_sp() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBValue); }
-SBValue::SBValue(const lldb::ValueObjectSP &value_sp) { SetSP(value_sp); }
+SBValue::SBValue(const lldb::ValueObjectSP &value_sp) {
+ LLDB_RECORD_CONSTRUCTOR(SBValue, (const lldb::ValueObjectSP &), value_sp);
-SBValue::SBValue(const SBValue &rhs) { SetSP(rhs.m_opaque_sp); }
+ SetSP(value_sp);
+}
+
+SBValue::SBValue(const SBValue &rhs) {
+ LLDB_RECORD_CONSTRUCTOR(SBValue, (const lldb::SBValue &), rhs);
+
+ SetSP(rhs.m_opaque_sp);
+}
SBValue &SBValue::operator=(const SBValue &rhs) {
+ LLDB_RECORD_METHOD(lldb::SBValue &,
+ SBValue, operator=,(const lldb::SBValue &), rhs);
+
if (this != &rhs) {
SetSP(rhs.m_opaque_sp);
}
SBValue::~SBValue() {}
bool SBValue::IsValid() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsValid);
+
// 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
// (m_opaque_sp)" code in this file.
m_opaque_sp->GetRootSP().get() != NULL;
}
-void SBValue::Clear() { m_opaque_sp.reset(); }
+void SBValue::Clear() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBValue, Clear);
+
+ m_opaque_sp.reset();
+}
SBError SBValue::GetError() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBValue, GetError);
+
SBError sb_error;
ValueLocker locker;
sb_error.SetErrorStringWithFormat("error: %s",
locker.GetError().AsCString());
- return sb_error;
+ return LLDB_RECORD_RESULT(sb_error);
}
user_id_t SBValue::GetID() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::user_id_t, SBValue, GetID);
+
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
}
const char *SBValue::GetName() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetName);
+
const char *name = NULL;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
}
const char *SBValue::GetTypeName() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetTypeName);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
const char *name = NULL;
ValueLocker locker;
}
const char *SBValue::GetDisplayTypeName() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetDisplayTypeName);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
const char *name = NULL;
ValueLocker locker;
}
size_t SBValue::GetByteSize() {
+ LLDB_RECORD_METHOD_NO_ARGS(size_t, SBValue, GetByteSize);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
size_t result = 0;
}
bool SBValue::IsInScope() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsInScope);
+
bool result = false;
ValueLocker locker;
}
const char *SBValue::GetValue() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetValue);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
const char *cstr = NULL;
}
ValueType SBValue::GetValueType() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::ValueType, SBValue, GetValueType);
+
ValueType result = eValueTypeInvalid;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
}
const char *SBValue::GetObjectDescription() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetObjectDescription);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
const char *cstr = NULL;
ValueLocker locker;
}
const char *SBValue::GetTypeValidatorResult() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetTypeValidatorResult);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
const char *cstr = NULL;
ValueLocker locker;
}
SBType SBValue::GetType() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBValue, GetType);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBType sb_type;
ValueLocker locker;
log->Printf("SBValue(%p)::GetType => NULL",
static_cast<void *>(value_sp.get()));
}
- return sb_type;
+ return LLDB_RECORD_RESULT(sb_type);
}
bool SBValue::GetValueDidChange() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, GetValueDidChange);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
bool result = false;
ValueLocker locker;
}
const char *SBValue::GetSummary() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetSummary);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
const char *cstr = NULL;
ValueLocker locker;
const char *SBValue::GetSummary(lldb::SBStream &stream,
lldb::SBTypeSummaryOptions &options) {
+ LLDB_RECORD_METHOD(const char *, SBValue, GetSummary,
+ (lldb::SBStream &, lldb::SBTypeSummaryOptions &), stream,
+ options);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
}
const char *SBValue::GetLocation() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetLocation);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
const char *cstr = NULL;
ValueLocker locker;
// 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::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);
+
bool success = false;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
}
lldb::SBTypeFormat SBValue::GetTypeFormat() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeFormat, SBValue, GetTypeFormat);
+
lldb::SBTypeFormat format;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
format.SetSP(format_sp);
}
}
- return format;
+ return LLDB_RECORD_RESULT(format);
}
lldb::SBTypeSummary SBValue::GetTypeSummary() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeSummary, SBValue, GetTypeSummary);
+
lldb::SBTypeSummary summary;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
summary.SetSP(summary_sp);
}
}
- return summary;
+ return LLDB_RECORD_RESULT(summary);
}
lldb::SBTypeFilter SBValue::GetTypeFilter() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeFilter, SBValue, GetTypeFilter);
+
lldb::SBTypeFilter filter;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
}
}
}
- return filter;
+ return LLDB_RECORD_RESULT(filter);
}
#ifndef LLDB_DISABLE_PYTHON
lldb::SBTypeSynthetic SBValue::GetTypeSynthetic() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeSynthetic, SBValue, GetTypeSynthetic);
+
lldb::SBTypeSynthetic synthetic;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
}
}
}
- return synthetic;
+ return LLDB_RECORD_RESULT(synthetic);
}
#endif
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::SBValue sb_value;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
log->Printf("SBValue(%p)::CreateChildAtOffset => NULL",
static_cast<void *>(value_sp.get()));
}
- return sb_value;
+ return LLDB_RECORD_RESULT(sb_value);
}
lldb::SBValue SBValue::Cast(SBType type) {
+ LLDB_RECORD_METHOD(lldb::SBValue, SBValue, Cast, (lldb::SBType), type);
+
lldb::SBValue sb_value;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp && type_sp)
sb_value.SetSP(value_sp->Cast(type_sp->GetCompilerType(false)),
GetPreferDynamicValue(), GetPreferSyntheticValue());
- return sb_value;
+ return LLDB_RECORD_RESULT(sb_value);
}
lldb::SBValue SBValue::CreateValueFromExpression(const char *name,
const char *expression) {
+ LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateValueFromExpression,
+ (const char *, const char *), name, expression);
+
SBExpressionOptions options;
options.ref().SetKeepInMemory(true);
- return CreateValueFromExpression(name, expression, options);
+ return LLDB_RECORD_RESULT(
+ CreateValueFromExpression(name, expression, options));
}
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);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
lldb::SBValue sb_value;
ValueLocker locker;
"expression=\"%s\") => NULL",
static_cast<void *>(value_sp.get()), name, expression);
}
- return sb_value;
+ return LLDB_RECORD_RESULT(sb_value);
}
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::SBValue sb_value;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
log->Printf("SBValue(%p)::CreateValueFromAddress => NULL",
static_cast<void *>(value_sp.get()));
}
- return sb_value;
+ return LLDB_RECORD_RESULT(sb_value);
}
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::SBValue sb_value;
lldb::ValueObjectSP new_value_sp;
ValueLocker locker;
log->Printf("SBValue(%p)::CreateValueFromData => NULL",
static_cast<void *>(value_sp.get()));
}
- return sb_value;
+ return LLDB_RECORD_RESULT(sb_value);
}
SBValue SBValue::GetChildAtIndex(uint32_t idx) {
+ LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildAtIndex, (uint32_t), idx);
+
const bool can_create_synthetic = false;
lldb::DynamicValueType use_dynamic = eNoDynamicValues;
TargetSP target_sp;
if (target_sp)
use_dynamic = target_sp->GetPreferDynamicValue();
- return GetChildAtIndex(idx, use_dynamic, can_create_synthetic);
+ return LLDB_RECORD_RESULT(
+ GetChildAtIndex(idx, use_dynamic, can_create_synthetic));
}
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::ValueObjectSP child_sp;
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
static_cast<void *>(value_sp.get()), idx,
static_cast<void *>(value_sp.get()));
- return sb_value;
+ return LLDB_RECORD_RESULT(sb_value);
}
uint32_t SBValue::GetIndexOfChildWithName(const char *name) {
+ LLDB_RECORD_METHOD(uint32_t, SBValue, GetIndexOfChildWithName, (const char *),
+ name);
+
uint32_t idx = UINT32_MAX;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
}
SBValue SBValue::GetChildMemberWithName(const char *name) {
+ LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName,
+ (const char *), name);
+
lldb::DynamicValueType use_dynamic_value = eNoDynamicValues;
TargetSP target_sp;
if (m_opaque_sp)
if (target_sp)
use_dynamic_value = target_sp->GetPreferDynamicValue();
- return GetChildMemberWithName(name, use_dynamic_value);
+ return LLDB_RECORD_RESULT(GetChildMemberWithName(name, use_dynamic_value));
}
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::ValueObjectSP child_sp;
const ConstString str_name(name);
static_cast<void *>(value_sp.get()), name,
static_cast<void *>(value_sp.get()));
- return sb_value;
+ return LLDB_RECORD_RESULT(sb_value);
}
lldb::SBValue SBValue::GetDynamicValue(lldb::DynamicValueType use_dynamic) {
+ LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetDynamicValue,
+ (lldb::DynamicValueType), use_dynamic);
+
SBValue value_sb;
if (IsValid()) {
ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(), use_dynamic,
m_opaque_sp->GetUseSynthetic()));
value_sb.SetSP(proxy_sp);
}
- return value_sb;
+ return LLDB_RECORD_RESULT(value_sb);
}
lldb::SBValue SBValue::GetStaticValue() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, GetStaticValue);
+
SBValue value_sb;
if (IsValid()) {
ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(),
m_opaque_sp->GetUseSynthetic()));
value_sb.SetSP(proxy_sp);
}
- return value_sb;
+ return LLDB_RECORD_RESULT(value_sb);
}
lldb::SBValue SBValue::GetNonSyntheticValue() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, GetNonSyntheticValue);
+
SBValue value_sb;
if (IsValid()) {
ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(),
m_opaque_sp->GetUseDynamic(), false));
value_sb.SetSP(proxy_sp);
}
- return value_sb;
+ return LLDB_RECORD_RESULT(value_sb);
}
lldb::DynamicValueType SBValue::GetPreferDynamicValue() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::DynamicValueType, SBValue,
+ GetPreferDynamicValue);
+
if (!IsValid())
return eNoDynamicValues;
return m_opaque_sp->GetUseDynamic();
}
void SBValue::SetPreferDynamicValue(lldb::DynamicValueType use_dynamic) {
+ LLDB_RECORD_METHOD(void, SBValue, SetPreferDynamicValue,
+ (lldb::DynamicValueType), use_dynamic);
+
if (IsValid())
return m_opaque_sp->SetUseDynamic(use_dynamic);
}
bool SBValue::GetPreferSyntheticValue() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, GetPreferSyntheticValue);
+
if (!IsValid())
return false;
return m_opaque_sp->GetUseSynthetic();
}
void SBValue::SetPreferSyntheticValue(bool use_synthetic) {
+ LLDB_RECORD_METHOD(void, SBValue, SetPreferSyntheticValue, (bool),
+ use_synthetic);
+
if (IsValid())
return m_opaque_sp->SetUseSynthetic(use_synthetic);
}
bool SBValue::IsDynamic() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsDynamic);
+
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
}
bool SBValue::IsSynthetic() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsSynthetic);
+
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
}
bool SBValue::IsSyntheticChildrenGenerated() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsSyntheticChildrenGenerated);
+
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
}
void SBValue::SetSyntheticChildrenGenerated(bool is) {
+ LLDB_RECORD_METHOD(void, SBValue, SetSyntheticChildrenGenerated, (bool), is);
+
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
}
lldb::SBValue SBValue::GetValueForExpressionPath(const char *expr_path) {
+ LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetValueForExpressionPath,
+ (const char *), expr_path);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
lldb::ValueObjectSP child_sp;
ValueLocker locker;
static_cast<void *>(value_sp.get()), expr_path,
static_cast<void *>(value_sp.get()));
- return sb_value;
+ return LLDB_RECORD_RESULT(sb_value);
}
int64_t SBValue::GetValueAsSigned(SBError &error, int64_t fail_value) {
+ LLDB_RECORD_METHOD(int64_t, SBValue, GetValueAsSigned,
+ (lldb::SBError &, int64_t), error, fail_value);
+
error.Clear();
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
}
uint64_t SBValue::GetValueAsUnsigned(SBError &error, uint64_t fail_value) {
+ LLDB_RECORD_METHOD(uint64_t, SBValue, GetValueAsUnsigned,
+ (lldb::SBError &, uint64_t), error, fail_value);
+
error.Clear();
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
}
int64_t SBValue::GetValueAsSigned(int64_t fail_value) {
+ LLDB_RECORD_METHOD(int64_t, SBValue, GetValueAsSigned, (int64_t), fail_value);
+
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
}
uint64_t SBValue::GetValueAsUnsigned(uint64_t fail_value) {
+ LLDB_RECORD_METHOD(uint64_t, SBValue, GetValueAsUnsigned, (uint64_t),
+ fail_value);
+
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
}
bool SBValue::MightHaveChildren() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, MightHaveChildren);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
bool has_children = false;
ValueLocker locker;
}
bool SBValue::IsRuntimeSupportValue() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsRuntimeSupportValue);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
bool is_support = false;
ValueLocker locker;
return is_support;
}
-uint32_t SBValue::GetNumChildren() { return GetNumChildren(UINT32_MAX); }
+uint32_t SBValue::GetNumChildren() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBValue, GetNumChildren);
+
+ return GetNumChildren(UINT32_MAX);
+}
uint32_t SBValue::GetNumChildren(uint32_t max) {
+ LLDB_RECORD_METHOD(uint32_t, SBValue, GetNumChildren, (uint32_t), max);
+
uint32_t num_children = 0;
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
}
SBValue SBValue::Dereference() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, Dereference);
+
SBValue sb_value;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
static_cast<void *>(value_sp.get()),
static_cast<void *>(value_sp.get()));
- return sb_value;
+ return LLDB_RECORD_RESULT(sb_value);
}
// Deprecated - please use GetType().IsPointerType() instead.
-bool SBValue::TypeIsPointerType() { return GetType().IsPointerType(); }
+bool SBValue::TypeIsPointerType() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, TypeIsPointerType);
+
+ return GetType().IsPointerType();
+}
void *SBValue::GetOpaqueType() {
+ LLDB_RECORD_METHOD_NO_ARGS(void *, SBValue, GetOpaqueType);
+
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
}
lldb::SBTarget SBValue::GetTarget() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBValue, GetTarget);
+
SBTarget sb_target;
TargetSP target_sp;
if (m_opaque_sp) {
static_cast<void *>(m_opaque_sp.get()),
static_cast<void *>(target_sp.get()));
}
- return sb_target;
+ return LLDB_RECORD_RESULT(sb_target);
}
lldb::SBProcess SBValue::GetProcess() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBValue, GetProcess);
+
SBProcess sb_process;
ProcessSP process_sp;
if (m_opaque_sp) {
static_cast<void *>(m_opaque_sp.get()),
static_cast<void *>(process_sp.get()));
}
- return sb_process;
+ return LLDB_RECORD_RESULT(sb_process);
}
lldb::SBThread SBValue::GetThread() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBThread, SBValue, GetThread);
+
SBThread sb_thread;
ThreadSP thread_sp;
if (m_opaque_sp) {
static_cast<void *>(m_opaque_sp.get()),
static_cast<void *>(thread_sp.get()));
}
- return sb_thread;
+ return LLDB_RECORD_RESULT(sb_thread);
}
lldb::SBFrame SBValue::GetFrame() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFrame, SBValue, GetFrame);
+
SBFrame sb_frame;
StackFrameSP frame_sp;
if (m_opaque_sp) {
static_cast<void *>(m_opaque_sp.get()),
static_cast<void *>(frame_sp.get()));
}
- return sb_frame;
+ return LLDB_RECORD_RESULT(sb_frame);
}
lldb::ValueObjectSP SBValue::GetSP(ValueLocker &locker) const {
}
lldb::ValueObjectSP SBValue::GetSP() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ValueObjectSP, SBValue, GetSP);
+
ValueLocker locker;
- return GetSP(locker);
+ return LLDB_RECORD_RESULT(GetSP(locker));
}
void SBValue::SetSP(ValueImplSP impl_sp) { m_opaque_sp = impl_sp; }
}
bool SBValue::GetExpressionPath(SBStream &description) {
+ LLDB_RECORD_METHOD(bool, SBValue, GetExpressionPath, (lldb::SBStream &),
+ description);
+
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
bool SBValue::GetExpressionPath(SBStream &description,
bool qualify_cxx_base_classes) {
+ LLDB_RECORD_METHOD(bool, SBValue, GetExpressionPath, (lldb::SBStream &, bool),
+ description, qualify_cxx_base_classes);
+
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
return false;
}
-lldb::SBValue SBValue::EvaluateExpression(const char* expr) const {
+lldb::SBValue SBValue::EvaluateExpression(const char *expr) const {
+ LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValue, EvaluateExpression,
+ (const char *), expr);
+
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (!value_sp)
- return SBValue();
+ return LLDB_RECORD_RESULT(SBValue());
lldb::TargetSP target_sp = value_sp->GetTargetSP();
if (!target_sp)
- return SBValue();
+ return LLDB_RECORD_RESULT(SBValue());
lldb::SBExpressionOptions options;
options.SetFetchDynamicValue(target_sp->GetPreferDynamicValue());
options.SetUnwindOnError(true);
options.SetIgnoreBreakpoints(true);
- return EvaluateExpression(expr, options, nullptr);
+ return LLDB_RECORD_RESULT(EvaluateExpression(expr, options, nullptr));
}
lldb::SBValue
SBValue::EvaluateExpression(const char *expr,
const SBExpressionOptions &options) const {
- return EvaluateExpression(expr, options, nullptr);
+ LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValue, EvaluateExpression,
+ (const char *, const lldb::SBExpressionOptions &),
+ expr, options);
+
+ return LLDB_RECORD_RESULT(EvaluateExpression(expr, options, nullptr));
}
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);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (!expr || expr[0] == '\0') {
LLDB_LOG(log,
"SBValue::EvaluateExpression called with an empty expression");
- return SBValue();
+ return LLDB_RECORD_RESULT(SBValue());
}
LLDB_LOG(log, "SBValue()::EvaluateExpression (expr=\"{0}\")...", expr);
if (!value_sp) {
LLDB_LOG(log, "SBValue::EvaluateExpression () => error: could not "
"reconstruct value object for this SBValue");
- return SBValue();
+ return LLDB_RECORD_RESULT(SBValue());
}
lldb::TargetSP target_sp = value_sp->GetTargetSP();
LLDB_LOG(
log,
"SBValue::EvaluateExpression () => error: could not retrieve target");
- return SBValue();
+ return LLDB_RECORD_RESULT(SBValue());
}
std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
if (!frame) {
LLDB_LOG(log, "SBValue::EvaluateExpression () => error: could not retrieve "
"current stack frame");
- return SBValue();
+ return LLDB_RECORD_RESULT(SBValue());
}
ValueObjectSP res_val_sp;
SBValue result;
result.SetSP(res_val_sp, options.GetFetchDynamicValue());
- return result;
+ return LLDB_RECORD_RESULT(result);
}
bool SBValue::GetDescription(SBStream &description) {
+ LLDB_RECORD_METHOD(bool, SBValue, GetDescription, (lldb::SBStream &),
+ description);
+
Stream &strm = description.ref();
ValueLocker locker;
}
lldb::Format SBValue::GetFormat() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::Format, SBValue, GetFormat);
+
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
}
void SBValue::SetFormat(lldb::Format format) {
+ LLDB_RECORD_METHOD(void, SBValue, SetFormat, (lldb::Format), format);
+
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
}
lldb::SBValue SBValue::AddressOf() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, AddressOf);
+
SBValue sb_value;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
static_cast<void *>(value_sp.get()),
static_cast<void *>(value_sp.get()));
- return sb_value;
+ return LLDB_RECORD_RESULT(sb_value);
}
lldb::addr_t SBValue::GetLoadAddress() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBValue, GetLoadAddress);
+
lldb::addr_t value = LLDB_INVALID_ADDRESS;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
}
lldb::SBAddress SBValue::GetAddress() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBValue, GetAddress);
+
Address addr;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
(addr.GetSection() ? addr.GetSection()->GetName().GetCString()
: "NULL"),
addr.GetOffset());
- return SBAddress(new Address(addr));
+ return LLDB_RECORD_RESULT(SBAddress(new Address(addr)));
}
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);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
lldb::SBData sb_data;
ValueLocker locker;
static_cast<void *>(value_sp.get()), item_idx, item_count,
static_cast<void *>(sb_data.get()));
- return sb_data;
+ return LLDB_RECORD_RESULT(sb_data);
}
lldb::SBData SBValue::GetData() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBData, SBValue, GetData);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
lldb::SBData sb_data;
ValueLocker locker;
static_cast<void *>(value_sp.get()),
static_cast<void *>(sb_data.get()));
- return sb_data;
+ return LLDB_RECORD_RESULT(sb_data);
}
bool SBValue::SetData(lldb::SBData &data, SBError &error) {
+ LLDB_RECORD_METHOD(bool, SBValue, SetData, (lldb::SBData &, lldb::SBError &),
+ data, error);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
}
lldb::SBDeclaration SBValue::GetDeclaration() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBDeclaration, SBValue, GetDeclaration);
+
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
SBDeclaration decl_sb;
if (value_sp->GetDeclaration(decl))
decl_sb.SetDeclaration(decl);
}
- return decl_sb;
+ return LLDB_RECORD_RESULT(decl_sb);
}
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);
+
SBWatchpoint sb_watchpoint;
// If the SBValue is not valid, there's no point in even trying to watch it.
if (value_sp && target_sp) {
// Read and Write cannot both be false.
if (!read && !write)
- return sb_watchpoint;
+ return LLDB_RECORD_RESULT(sb_watchpoint);
// If the value is not in scope, don't try and watch and invalid value
if (!IsInScope())
- return sb_watchpoint;
+ return LLDB_RECORD_RESULT(sb_watchpoint);
addr_t addr = GetLoadAddress();
if (addr == LLDB_INVALID_ADDRESS)
- return sb_watchpoint;
+ return LLDB_RECORD_RESULT(sb_watchpoint);
size_t byte_size = GetByteSize();
if (byte_size == 0)
- return sb_watchpoint;
+ return LLDB_RECORD_RESULT(sb_watchpoint);
uint32_t watch_type = 0;
if (read)
error.SetErrorString("could not set watchpoint, a target is required");
}
- return sb_watchpoint;
+ return LLDB_RECORD_RESULT(sb_watchpoint);
}
// FIXME: Remove this method impl (as well as the decl in .h) once it is no
// 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);
+
SBError error;
- return Watch(resolve_location, read, write, error);
+ return LLDB_RECORD_RESULT(Watch(resolve_location, read, write, error));
}
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);
+
SBWatchpoint sb_watchpoint;
if (IsInScope() && GetType().IsPointerType())
sb_watchpoint = Dereference().Watch(resolve_location, read, write, error);
- return sb_watchpoint;
+ return LLDB_RECORD_RESULT(sb_watchpoint);
}
lldb::SBValue SBValue::Persist() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, Persist);
+
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
SBValue persisted_sb;
if (value_sp) {
persisted_sb.SetSP(value_sp->Persist());
}
- return persisted_sb;
+ return LLDB_RECORD_RESULT(persisted_sb);
}
//===----------------------------------------------------------------------===//
#include "lldb/API/SBValueList.h"
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBValue.h"
#include "lldb/Core/ValueObjectList.h"
std::vector<lldb::SBValue> m_values;
};
-SBValueList::SBValueList() : m_opaque_up() {}
+SBValueList::SBValueList() : m_opaque_up() {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBValueList);
+}
SBValueList::SBValueList(const SBValueList &rhs) : m_opaque_up() {
+ LLDB_RECORD_CONSTRUCTOR(SBValueList, (const lldb::SBValueList &), rhs);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (rhs.IsValid())
SBValueList::~SBValueList() {}
-bool SBValueList::IsValid() const { return (m_opaque_up != NULL); }
+bool SBValueList::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBValueList, IsValid);
+
+ return (m_opaque_up != NULL);
+}
-void SBValueList::Clear() { m_opaque_up.reset(); }
+void SBValueList::Clear() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBValueList, Clear);
+
+ m_opaque_up.reset();
+}
const SBValueList &SBValueList::operator=(const SBValueList &rhs) {
+ LLDB_RECORD_METHOD(const lldb::SBValueList &,
+ SBValueList, operator=,(const lldb::SBValueList &), rhs);
+
if (this != &rhs) {
if (rhs.IsValid())
m_opaque_up.reset(new ValueListImpl(*rhs));
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);
+
CreateIfNeeded();
m_opaque_up->Append(val_obj);
}
}
void SBValueList::Append(const lldb::SBValueList &value_list) {
+ LLDB_RECORD_METHOD(void, SBValueList, Append, (const lldb::SBValueList &),
+ value_list);
+
if (value_list.IsValid()) {
CreateIfNeeded();
m_opaque_up->Append(*value_list);
}
SBValue SBValueList::GetValueAtIndex(uint32_t idx) const {
+ LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValueList, GetValueAtIndex,
+ (uint32_t), idx);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
// if (log)
static_cast<void *>(sb_value.GetSP().get()), sstr.GetData());
}
- return sb_value;
+ return LLDB_RECORD_RESULT(sb_value);
}
uint32_t SBValueList::GetSize() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBValueList, GetSize);
+
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
// if (log)
}
SBValue SBValueList::FindValueObjectByUID(lldb::user_id_t uid) {
+ LLDB_RECORD_METHOD(lldb::SBValue, SBValueList, FindValueObjectByUID,
+ (lldb::user_id_t), uid);
+
SBValue sb_value;
if (m_opaque_up)
sb_value = m_opaque_up->FindValueByUID(uid);
- return sb_value;
+ return LLDB_RECORD_RESULT(sb_value);
}
SBValue SBValueList::GetFirstValueByName(const char *name) const {
+ LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValueList, GetFirstValueByName,
+ (const char *), name);
+
SBValue sb_value;
if (m_opaque_up)
sb_value = m_opaque_up->GetFirstValueByName(name);
- return sb_value;
+ return LLDB_RECORD_RESULT(sb_value);
}
void *SBValueList::opaque_ptr() { return m_opaque_up.get(); }
//===----------------------------------------------------------------------===//
#include "lldb/API/SBVariablesOptions.h"
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBTarget.h"
#include "lldb/Target/Target.h"
};
SBVariablesOptions::SBVariablesOptions()
- : m_opaque_up(new VariablesOptionsImpl()) {}
+ : m_opaque_up(new VariablesOptionsImpl()) {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBVariablesOptions);
+}
SBVariablesOptions::SBVariablesOptions(const SBVariablesOptions &options)
- : m_opaque_up(new VariablesOptionsImpl(options.ref())) {}
+ : m_opaque_up(new VariablesOptionsImpl(options.ref())) {
+ LLDB_RECORD_CONSTRUCTOR(SBVariablesOptions,
+ (const lldb::SBVariablesOptions &), options);
+}
SBVariablesOptions &SBVariablesOptions::
operator=(const SBVariablesOptions &options) {
+ LLDB_RECORD_METHOD(
+ lldb::SBVariablesOptions &,
+ SBVariablesOptions, operator=,(const lldb::SBVariablesOptions &),
+ options);
+
m_opaque_up.reset(new VariablesOptionsImpl(options.ref()));
return *this;
}
SBVariablesOptions::~SBVariablesOptions() = default;
-bool SBVariablesOptions::IsValid() const { return m_opaque_up != nullptr; }
+bool SBVariablesOptions::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, IsValid);
+
+ return m_opaque_up != nullptr;
+}
bool SBVariablesOptions::GetIncludeArguments() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions,
+ GetIncludeArguments);
+
return m_opaque_up->GetIncludeArguments();
}
void SBVariablesOptions::SetIncludeArguments(bool arguments) {
+ LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeArguments, (bool),
+ arguments);
+
m_opaque_up->SetIncludeArguments(arguments);
}
bool SBVariablesOptions::GetIncludeRecognizedArguments(
const lldb::SBTarget &target) const {
+ LLDB_RECORD_METHOD_CONST(bool, SBVariablesOptions,
+ GetIncludeRecognizedArguments,
+ (const lldb::SBTarget &), target);
+
return m_opaque_up->GetIncludeRecognizedArguments(target.GetSP());
}
void SBVariablesOptions::SetIncludeRecognizedArguments(bool arguments) {
+ LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeRecognizedArguments,
+ (bool), arguments);
+
m_opaque_up->SetIncludeRecognizedArguments(arguments);
}
bool SBVariablesOptions::GetIncludeLocals() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, GetIncludeLocals);
+
return m_opaque_up->GetIncludeLocals();
}
void SBVariablesOptions::SetIncludeLocals(bool locals) {
+ LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeLocals, (bool),
+ locals);
+
m_opaque_up->SetIncludeLocals(locals);
}
bool SBVariablesOptions::GetIncludeStatics() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, GetIncludeStatics);
+
return m_opaque_up->GetIncludeStatics();
}
void SBVariablesOptions::SetIncludeStatics(bool statics) {
+ LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeStatics, (bool),
+ statics);
+
m_opaque_up->SetIncludeStatics(statics);
}
bool SBVariablesOptions::GetInScopeOnly() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, GetInScopeOnly);
+
return m_opaque_up->GetInScopeOnly();
}
void SBVariablesOptions::SetInScopeOnly(bool in_scope_only) {
+ LLDB_RECORD_METHOD(void, SBVariablesOptions, SetInScopeOnly, (bool),
+ in_scope_only);
+
m_opaque_up->SetInScopeOnly(in_scope_only);
}
bool SBVariablesOptions::GetIncludeRuntimeSupportValues() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions,
+ GetIncludeRuntimeSupportValues);
+
return m_opaque_up->GetIncludeRuntimeSupportValues();
}
void SBVariablesOptions::SetIncludeRuntimeSupportValues(
bool runtime_support_values) {
+ LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeRuntimeSupportValues,
+ (bool), runtime_support_values);
+
m_opaque_up->SetIncludeRuntimeSupportValues(runtime_support_values);
}
lldb::DynamicValueType SBVariablesOptions::GetUseDynamic() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::DynamicValueType, SBVariablesOptions,
+ GetUseDynamic);
+
return m_opaque_up->GetUseDynamic();
}
void SBVariablesOptions::SetUseDynamic(lldb::DynamicValueType dynamic) {
+ LLDB_RECORD_METHOD(void, SBVariablesOptions, SetUseDynamic,
+ (lldb::DynamicValueType), dynamic);
+
m_opaque_up->SetUseDynamic(dynamic);
}
//===----------------------------------------------------------------------===//
#include "lldb/API/SBWatchpoint.h"
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBDefines.h"
using namespace lldb;
using namespace lldb_private;
-SBWatchpoint::SBWatchpoint() {}
+SBWatchpoint::SBWatchpoint() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBWatchpoint); }
SBWatchpoint::SBWatchpoint(const lldb::WatchpointSP &wp_sp)
: m_opaque_wp(wp_sp) {
+ LLDB_RECORD_CONSTRUCTOR(SBWatchpoint, (const lldb::WatchpointSP &), wp_sp);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log) {
}
SBWatchpoint::SBWatchpoint(const SBWatchpoint &rhs)
- : m_opaque_wp(rhs.m_opaque_wp) {}
+ : m_opaque_wp(rhs.m_opaque_wp) {
+ LLDB_RECORD_CONSTRUCTOR(SBWatchpoint, (const lldb::SBWatchpoint &), rhs);
+}
const SBWatchpoint &SBWatchpoint::operator=(const SBWatchpoint &rhs) {
+ LLDB_RECORD_METHOD(const lldb::SBWatchpoint &,
+ SBWatchpoint, operator=,(const lldb::SBWatchpoint &), rhs);
+
m_opaque_wp = rhs.m_opaque_wp;
return *this;
}
SBWatchpoint::~SBWatchpoint() {}
watch_id_t SBWatchpoint::GetID() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::watch_id_t, SBWatchpoint, GetID);
+
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
watch_id_t watch_id = LLDB_INVALID_WATCH_ID;
return watch_id;
}
-bool SBWatchpoint::IsValid() const { return bool(m_opaque_wp.lock()); }
+bool SBWatchpoint::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBWatchpoint, IsValid);
+
+ return bool(m_opaque_wp.lock());
+}
SBError SBWatchpoint::GetError() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBWatchpoint, GetError);
+
SBError sb_error;
lldb::WatchpointSP watchpoint_sp(GetSP());
if (watchpoint_sp) {
sb_error.SetError(watchpoint_sp->GetError());
}
- return sb_error;
+ return LLDB_RECORD_RESULT(sb_error);
}
int32_t SBWatchpoint::GetHardwareIndex() {
+ LLDB_RECORD_METHOD_NO_ARGS(int32_t, SBWatchpoint, GetHardwareIndex);
+
int32_t hw_index = -1;
lldb::WatchpointSP watchpoint_sp(GetSP());
}
addr_t SBWatchpoint::GetWatchAddress() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBWatchpoint, GetWatchAddress);
+
addr_t ret_addr = LLDB_INVALID_ADDRESS;
lldb::WatchpointSP watchpoint_sp(GetSP());
}
size_t SBWatchpoint::GetWatchSize() {
+ LLDB_RECORD_METHOD_NO_ARGS(size_t, SBWatchpoint, GetWatchSize);
+
size_t watch_size = 0;
lldb::WatchpointSP watchpoint_sp(GetSP());
}
void SBWatchpoint::SetEnabled(bool enabled) {
+ LLDB_RECORD_METHOD(void, SBWatchpoint, SetEnabled, (bool), enabled);
+
lldb::WatchpointSP watchpoint_sp(GetSP());
if (watchpoint_sp) {
Target &target = watchpoint_sp->GetTarget();
}
bool SBWatchpoint::IsEnabled() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBWatchpoint, IsEnabled);
+
lldb::WatchpointSP watchpoint_sp(GetSP());
if (watchpoint_sp) {
std::lock_guard<std::recursive_mutex> guard(
}
uint32_t SBWatchpoint::GetHitCount() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBWatchpoint, GetHitCount);
+
uint32_t count = 0;
lldb::WatchpointSP watchpoint_sp(GetSP());
if (watchpoint_sp) {
}
uint32_t SBWatchpoint::GetIgnoreCount() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBWatchpoint, GetIgnoreCount);
+
lldb::WatchpointSP watchpoint_sp(GetSP());
if (watchpoint_sp) {
std::lock_guard<std::recursive_mutex> guard(
}
void SBWatchpoint::SetIgnoreCount(uint32_t n) {
+ LLDB_RECORD_METHOD(void, SBWatchpoint, SetIgnoreCount, (uint32_t), n);
+
lldb::WatchpointSP watchpoint_sp(GetSP());
if (watchpoint_sp) {
std::lock_guard<std::recursive_mutex> guard(
}
const char *SBWatchpoint::GetCondition() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBWatchpoint, GetCondition);
+
lldb::WatchpointSP watchpoint_sp(GetSP());
if (watchpoint_sp) {
std::lock_guard<std::recursive_mutex> guard(
}
void SBWatchpoint::SetCondition(const char *condition) {
+ LLDB_RECORD_METHOD(void, SBWatchpoint, SetCondition, (const char *),
+ condition);
+
lldb::WatchpointSP watchpoint_sp(GetSP());
if (watchpoint_sp) {
std::lock_guard<std::recursive_mutex> guard(
bool SBWatchpoint::GetDescription(SBStream &description,
DescriptionLevel level) {
+ LLDB_RECORD_METHOD(bool, SBWatchpoint, GetDescription,
+ (lldb::SBStream &, lldb::DescriptionLevel), description,
+ level);
+
Stream &strm = description.ref();
lldb::WatchpointSP watchpoint_sp(GetSP());
return true;
}
-void SBWatchpoint::Clear() { m_opaque_wp.reset(); }
+void SBWatchpoint::Clear() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBWatchpoint, Clear);
-lldb::WatchpointSP SBWatchpoint::GetSP() const { return m_opaque_wp.lock(); }
+ m_opaque_wp.reset();
+}
+
+lldb::WatchpointSP SBWatchpoint::GetSP() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::WatchpointSP, SBWatchpoint, GetSP);
-void SBWatchpoint::SetSP(const lldb::WatchpointSP &sp) { m_opaque_wp = sp; }
+ return LLDB_RECORD_RESULT(m_opaque_wp.lock());
+}
+
+void SBWatchpoint::SetSP(const lldb::WatchpointSP &sp) {
+ LLDB_RECORD_METHOD(void, SBWatchpoint, SetSP, (const lldb::WatchpointSP &),
+ sp);
+
+ m_opaque_wp = sp;
+}
bool SBWatchpoint::EventIsWatchpointEvent(const lldb::SBEvent &event) {
+ LLDB_RECORD_STATIC_METHOD(bool, SBWatchpoint, EventIsWatchpointEvent,
+ (const lldb::SBEvent &), event);
+
return Watchpoint::WatchpointEventData::GetEventDataFromEvent(event.get()) !=
NULL;
}
WatchpointEventType
SBWatchpoint::GetWatchpointEventTypeFromEvent(const SBEvent &event) {
+ LLDB_RECORD_STATIC_METHOD(lldb::WatchpointEventType, SBWatchpoint,
+ GetWatchpointEventTypeFromEvent,
+ (const lldb::SBEvent &), event);
+
if (event.IsValid())
return Watchpoint::WatchpointEventData::GetWatchpointEventTypeFromEvent(
event.GetSP());
}
SBWatchpoint SBWatchpoint::GetWatchpointFromEvent(const lldb::SBEvent &event) {
+ LLDB_RECORD_STATIC_METHOD(lldb::SBWatchpoint, SBWatchpoint,
+ GetWatchpointFromEvent, (const lldb::SBEvent &),
+ event);
+
SBWatchpoint sb_watchpoint;
if (event.IsValid())
sb_watchpoint =
Watchpoint::WatchpointEventData::GetWatchpointFromEvent(event.GetSP());
- return sb_watchpoint;
+ return LLDB_RECORD_RESULT(sb_watchpoint);
}
projects / platform / upstream / llvm.git / commitdiff