maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

[Reproducers] Add SBReproducer macros 

This patch adds the SBReproducer macros needed to capture and reply the
corresponding calls. This patch was generated by running the lldb-instr
tool on the API source files.

Differential revision: https://reviews.llvm.org/D57475

llvm-svn: 355459
This commit is contained in:
Jonas Devlieghere 2019-03-06 00:06:00 +00:00
parent bd4bf82a48
commit baf5664f50
66 changed files with 8848 additions and 989 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

77
lldb/source/API/SBAddress.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBAddress.h"
#include "SBReproducerPrivate.h"
#include "Utils.h"
#include "lldb/API/SBProcess.h"
#include "lldb/API/SBSection.h"
@ -21,7 +22,9 @@
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()) {
@ -30,21 +33,32 @@ SBAddress::SBAddress(const Address *lldb_object_ptr)
}
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;
@ -57,12 +71,21 @@ bool lldb::operator==(const SBAddress &lhs, const SBAddress &rhs) {
}
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);
@ -76,6 +99,8 @@ void SBAddress::SetAddress(const Address *lldb_object_ptr) {
}
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
@ -83,6 +108,9 @@ lldb::addr_t SBAddress::GetFileAddress() const {
}
lldb::addr_t SBAddress::GetLoadAddress(const SBTarget &target) const {
LLDB_RECORD_METHOD_CONST(lldb::addr_t, SBAddress, GetLoadAddress,
(const lldb::SBTarget &), target);
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
lldb::addr_t addr = LLDB_INVALID_ADDRESS;
@ -108,6 +136,9 @@ lldb::addr_t SBAddress::GetLoadAddress(const SBTarget &target) const {
}
void SBAddress::SetLoadAddress(lldb::addr_t load_addr, lldb::SBTarget &target) {
LLDB_RECORD_METHOD(void, SBAddress, SetLoadAddress,
(lldb::addr_t, lldb::SBTarget &), load_addr, target);
// Create the address object if we don't already have one
ref();
if (target.IsValid())
@ -123,6 +154,8 @@ void SBAddress::SetLoadAddress(lldb::addr_t load_addr, lldb::SBTarget &target) {
}
bool SBAddress::OffsetAddress(addr_t offset) {
LLDB_RECORD_METHOD(bool, SBAddress, OffsetAddress, (lldb::addr_t), offset);
if (m_opaque_up->IsValid()) {
addr_t addr_offset = m_opaque_up->GetOffset();
if (addr_offset != LLDB_INVALID_ADDRESS) {
@ -134,13 +167,17 @@ bool SBAddress::OffsetAddress(addr_t offset) {
}
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;
@ -166,6 +203,9 @@ const Address &SBAddress::ref() const {
Address *SBAddress::get() { return m_opaque_up.get(); }
bool SBAddress::GetDescription(SBStream &description) {
LLDB_RECORD_METHOD(bool, SBAddress, GetDescription, (lldb::SBStream &),
description);
// Call "ref()" on the stream to make sure it creates a backing stream in
// case there isn't one already...
Stream &strm = description.ref();
@ -185,54 +225,69 @@ bool SBAddress::GetDescription(SBStream &description) {
}
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);
}

112
lldb/source/API/SBAttachInfo.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBAttachInfo.h"
#include "SBReproducerPrivate.h"
#include "Utils.h"
#include "lldb/API/SBFileSpec.h"
#include "lldb/API/SBListener.h"
@ -15,15 +16,21 @@
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);
@ -31,6 +38,9 @@ SBAttachInfo::SBAttachInfo(const char *path, bool wait_for)
SBAttachInfo::SBAttachInfo(const char *path, bool wait_for, bool async)
: m_opaque_sp(new ProcessAttachInfo()) {
LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (const char *, bool, bool), path,
wait_for, async);
if (path && path[0])
m_opaque_sp->GetExecutableFile().SetFile(path, FileSpec::Style::native);
m_opaque_sp->SetWaitForLaunch(wait_for);
@ -39,6 +49,8 @@ SBAttachInfo::SBAttachInfo(const char *path, bool wait_for, bool async)
SBAttachInfo::SBAttachInfo(const SBAttachInfo &rhs)
: m_opaque_sp(new ProcessAttachInfo()) {
LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (const lldb::SBAttachInfo &), rhs);
m_opaque_sp = clone(rhs.m_opaque_sp);
}
@ -47,34 +59,54 @@ SBAttachInfo::~SBAttachInfo() {}
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
@ -82,6 +114,9 @@ void SBAttachInfo::SetExecutable(const char *path) {
}
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
@ -89,78 +124,137 @@ void SBAttachInfo::SetExecutable(SBFileSpec exe_file) {
}
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());
}

78
lldb/source/API/SBBlock.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBBlock.h"
#include "SBReproducerPrivate.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBFileSpec.h"
#include "lldb/API/SBFrame.h"
@ -25,29 +26,44 @@
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();
@ -65,6 +81,9 @@ const char *SBBlock::GetInlinedName() const {
}
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 =
@ -72,10 +91,12 @@ SBFileSpec SBBlock::GetInlinedCallSiteFile() const {
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();
@ -86,6 +107,8 @@ uint32_t SBBlock::GetInlinedCallSiteLine() const {
}
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();
@ -105,31 +128,39 @@ void SBBlock::AppendVariables(bool can_create, bool get_parent_variables,
}
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; }
@ -137,6 +168,9 @@ 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) {
@ -159,12 +193,17 @@ bool SBBlock::GetDescription(SBStream &description) {
}
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;
@ -172,10 +211,13 @@ lldb::SBAddress SBBlock::GetRangeStartAddress(uint32_t idx) {
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;
@ -184,10 +226,13 @@ lldb::SBAddress SBBlock::GetRangeEndAddress(uint32_t idx) {
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());
}
@ -198,6 +243,11 @@ uint32_t SBBlock::GetRangeIndexForBlockAddress(lldb::SBAddress block_addr) {
lldb::SBValueList SBBlock::GetVariables(lldb::SBFrame &frame, bool arguments,
bool locals, bool statics,
lldb::DynamicValueType use_dynamic) {
LLDB_RECORD_METHOD(
lldb::SBValueList, SBBlock, GetVariables,
(lldb::SBFrame &, bool, bool, bool, lldb::DynamicValueType), frame,
arguments, locals, statics, use_dynamic);
Block *block = GetPtr();
SBValueList value_list;
if (block) {
@ -244,11 +294,15 @@ lldb::SBValueList SBBlock::GetVariables(lldb::SBFrame &frame, bool arguments,
}
}
}
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;
@ -292,5 +346,5 @@ lldb::SBValueList SBBlock::GetVariables(lldb::SBTarget &target, bool arguments,
}
}
}
return value_list;
return LLDB_RECORD_RESULT(value_list);
}

247
lldb/source/API/SBBreakpoint.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBBreakpoint.h"
#include "SBReproducerPrivate.h"
#include "lldb/API/SBBreakpointLocation.h"
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBEvent.h"
@ -43,30 +44,45 @@
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;
@ -79,6 +95,8 @@ break_id_t SBBreakpoint::GetID() const {
}
bool SBBreakpoint::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, IsValid);
BreakpointSP bkpt_sp = GetSP();
if (!bkpt_sp)
return false;
@ -89,6 +107,8 @@ bool SBBreakpoint::IsValid() const {
}
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(
@ -98,6 +118,9 @@ void SBBreakpoint::ClearAllBreakpointSites() {
}
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();
@ -113,10 +136,13 @@ SBBreakpointLocation SBBreakpoint::FindLocationByAddress(addr_t vm_addr) {
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();
@ -135,6 +161,9 @@ break_id_t SBBreakpoint::FindLocationIDByAddress(addr_t vm_addr) {
}
SBBreakpointLocation SBBreakpoint::FindLocationByID(break_id_t bp_loc_id) {
LLDB_RECORD_METHOD(lldb::SBBreakpointLocation, SBBreakpoint, FindLocationByID,
(lldb::break_id_t), bp_loc_id);
SBBreakpointLocation sb_bp_location;
BreakpointSP bkpt_sp = GetSP();
@ -144,10 +173,13 @@ SBBreakpointLocation SBBreakpoint::FindLocationByID(break_id_t bp_loc_id) {
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();
@ -157,10 +189,12 @@ SBBreakpointLocation SBBreakpoint::GetLocationAtIndex(uint32_t index) {
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();
@ -174,6 +208,8 @@ void SBBreakpoint::SetEnabled(bool enable) {
}
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(
@ -184,6 +220,8 @@ bool SBBreakpoint::IsEnabled() {
}
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();
@ -197,6 +235,8 @@ void SBBreakpoint::SetOneShot(bool one_shot) {
}
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(
@ -207,6 +247,8 @@ bool SBBreakpoint::IsOneShot() const {
}
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(
@ -217,6 +259,8 @@ bool SBBreakpoint::IsInternal() {
}
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();
@ -230,6 +274,9 @@ void SBBreakpoint::SetIgnoreCount(uint32_t count) {
}
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(
@ -239,6 +286,8 @@ void SBBreakpoint::SetCondition(const char *condition) {
}
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(
@ -249,6 +298,9 @@ const char *SBBreakpoint::GetCondition() {
}
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(
@ -258,6 +310,8 @@ void SBBreakpoint::SetAutoContinue(bool auto_continue) {
}
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(
@ -268,6 +322,8 @@ bool SBBreakpoint::GetAutoContinue() {
}
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) {
@ -283,6 +339,8 @@ uint32_t SBBreakpoint::GetHitCount() const {
}
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) {
@ -298,6 +356,8 @@ uint32_t SBBreakpoint::GetIgnoreCount() const {
}
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(
@ -309,6 +369,8 @@ void SBBreakpoint::SetThreadID(tid_t tid) {
}
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) {
@ -323,6 +385,8 @@ tid_t SBBreakpoint::GetThreadID() {
}
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);
@ -334,6 +398,8 @@ void SBBreakpoint::SetThreadIndex(uint32_t 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) {
@ -351,6 +417,9 @@ uint32_t SBBreakpoint::GetThreadIndex() const {
}
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);
@ -363,6 +432,8 @@ void SBBreakpoint::SetThreadName(const char *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) {
@ -380,6 +451,9 @@ const char *SBBreakpoint::GetThreadName() const {
}
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(),
@ -392,6 +466,8 @@ void SBBreakpoint::SetQueueName(const char *queue_name) {
}
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) {
@ -409,6 +485,9 @@ const char *SBBreakpoint::GetQueueName() const {
}
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) {
@ -423,6 +502,8 @@ size_t SBBreakpoint::GetNumResolvedLocations() const {
}
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) {
@ -436,6 +517,9 @@ size_t SBBreakpoint::GetNumLocations() const {
}
void SBBreakpoint::SetCommandLineCommands(SBStringList &commands) {
LLDB_RECORD_METHOD(void, SBBreakpoint, SetCommandLineCommands,
(lldb::SBStringList &), commands);
BreakpointSP bkpt_sp = GetSP();
if (!bkpt_sp)
return;
@ -451,6 +535,9 @@ void SBBreakpoint::SetCommandLineCommands(SBStringList &commands) {
}
bool SBBreakpoint::GetCommandLineCommands(SBStringList &commands) {
LLDB_RECORD_METHOD(bool, SBBreakpoint, GetCommandLineCommands,
(lldb::SBStringList &), commands);
BreakpointSP bkpt_sp = GetSP();
if (!bkpt_sp)
return false;
@ -463,10 +550,15 @@ bool SBBreakpoint::GetCommandLineCommands(SBStringList &commands) {
}
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(
@ -484,39 +576,39 @@ bool SBBreakpoint::GetDescription(SBStream &s, bool include_locations) {
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,
@ -538,6 +630,9 @@ void SBBreakpoint
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(),
@ -557,6 +652,9 @@ void SBBreakpoint::SetScriptCallbackFunction(
}
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(),
@ -577,10 +675,12 @@ SBError SBBreakpoint::SetScriptCallbackBody(const char *callback_body_text) {
} 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);
@ -604,6 +704,9 @@ bool SBBreakpoint::AddName(const char *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);
@ -617,6 +720,8 @@ void SBBreakpoint::RemoveName(const char *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);
@ -631,6 +736,9 @@ bool SBBreakpoint::MatchesName(const char *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());
@ -647,12 +755,19 @@ void SBBreakpoint::GetNames(SBStringList &names) {
}
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());
@ -660,25 +775,38 @@ SBBreakpoint::GetBreakpointEventTypeFromEvent(const SBEvent &event) {
}
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 =
@ -688,6 +816,8 @@ SBBreakpoint::GetNumBreakpointLocationsFromEvent(const lldb::SBEvent &event) {
}
bool SBBreakpoint::IsHardware() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, IsHardware);
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp)
return bkpt_sp->IsHardware();
@ -781,11 +911,15 @@ private:
};
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
@ -793,21 +927,30 @@ size_t SBBreakpointList::GetSize() const {
}
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)
@ -816,12 +959,18 @@ void SBBreakpointList::Append(const SBBreakpoint &sb_bkpt) {
}
void SBBreakpointList::AppendByID(lldb::break_id_t id) {
LLDB_RECORD_METHOD(void, SBBreakpointList, AppendByID, (lldb::break_id_t),
id);
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)
@ -830,6 +979,8 @@ bool SBBreakpointList::AppendIfUnique(const SBBreakpoint &sb_bkpt) {
}
void SBBreakpointList::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBBreakpointList, Clear);
if (m_opaque_sp)
m_opaque_sp->Clear();
}

108
lldb/source/API/SBBreakpointLocation.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBBreakpointLocation.h"
#include "SBReproducerPrivate.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBDefines.h"
@ -29,11 +30,16 @@
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) {
@ -44,10 +50,18 @@ SBBreakpointLocation::SBBreakpointLocation(
}
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;
}
@ -58,17 +72,27 @@ BreakpointLocationSP SBBreakpointLocation::GetSP() const {
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();
@ -82,6 +106,8 @@ addr_t SBBreakpointLocation::GetLoadAddress() {
}
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(
@ -91,6 +117,8 @@ void SBBreakpointLocation::SetEnabled(bool enabled) {
}
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(
@ -101,6 +129,8 @@ bool SBBreakpointLocation::IsEnabled() {
}
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(
@ -111,6 +141,8 @@ uint32_t SBBreakpointLocation::GetHitCount() {
}
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(
@ -121,6 +153,8 @@ uint32_t SBBreakpointLocation::GetIgnoreCount() {
}
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(
@ -130,6 +164,9 @@ void SBBreakpointLocation::SetIgnoreCount(uint32_t n) {
}
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(
@ -139,6 +176,8 @@ void SBBreakpointLocation::SetCondition(const char *condition) {
}
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(
@ -149,6 +188,9 @@ const char *SBBreakpointLocation::GetCondition() {
}
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(
@ -158,6 +200,8 @@ void SBBreakpointLocation::SetAutoContinue(bool auto_continue) {
}
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(
@ -169,6 +213,9 @@ bool SBBreakpointLocation::GetAutoContinue() {
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(),
@ -190,6 +237,9 @@ void SBBreakpointLocation::SetScriptCallbackFunction(
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(),
@ -211,10 +261,13 @@ SBBreakpointLocation::SetScriptCallbackBody(const char *callback_body_text) {
} 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;
@ -230,6 +283,9 @@ void SBBreakpointLocation::SetCommandLineCommands(SBStringList &commands) {
}
bool SBBreakpointLocation::GetCommandLineCommands(SBStringList &commands) {
LLDB_RECORD_METHOD(bool, SBBreakpointLocation, GetCommandLineCommands,
(lldb::SBStringList &), commands);
BreakpointLocationSP loc_sp = GetSP();
if (!loc_sp)
return false;
@ -242,6 +298,9 @@ bool SBBreakpointLocation::GetCommandLineCommands(SBStringList &commands) {
}
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(
@ -251,6 +310,8 @@ void SBBreakpointLocation::SetThreadID(tid_t thread_id) {
}
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) {
@ -262,6 +323,9 @@ tid_t SBBreakpointLocation::GetThreadID() {
}
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(
@ -271,6 +335,9 @@ void SBBreakpointLocation::SetThreadIndex(uint32_t index) {
}
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) {
@ -282,6 +349,9 @@ uint32_t SBBreakpointLocation::GetThreadIndex() const {
}
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(
@ -291,6 +361,9 @@ void SBBreakpointLocation::SetThreadName(const char *thread_name) {
}
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(
@ -301,6 +374,9 @@ const char *SBBreakpointLocation::GetThreadName() const {
}
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(
@ -310,6 +386,9 @@ void SBBreakpointLocation::SetQueueName(const char *queue_name) {
}
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(
@ -320,6 +399,8 @@ const char *SBBreakpointLocation::GetQueueName() const {
}
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(
@ -337,6 +418,10 @@ void SBBreakpointLocation::SetLocation(
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();
@ -352,6 +437,8 @@ bool SBBreakpointLocation::GetDescription(SBStream &description,
}
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(
@ -362,6 +449,9 @@ break_id_t SBBreakpointLocation::GetID() {
}
SBBreakpoint SBBreakpointLocation::GetBreakpoint() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBreakpoint, SBBreakpointLocation,
GetBreakpoint);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointLocationSP loc_sp = GetSP();
@ -378,5 +468,5 @@ SBBreakpoint SBBreakpointLocation::GetBreakpoint() {
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);
}

148
lldb/source/API/SBBreakpointName.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBBreakpointName.h"
#include "SBReproducerPrivate.h"
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBError.h"
#include "lldb/API/SBStream.h"
@ -105,10 +106,14 @@ lldb_private::BreakpointName *SBBreakpointNameImpl::GetBreakpointName() const {
} // 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();
@ -116,8 +121,10 @@ SBBreakpointName::SBBreakpointName(SBTarget &sb_target, const char *name)
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;
@ -139,8 +146,10 @@ SBBreakpointName::SBBreakpointName(SBBreakpoint &sb_bkpt, const char *name)
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
@ -150,8 +159,12 @@ SBBreakpointName::SBBreakpointName(const SBBreakpointName &rhs)
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;
@ -163,26 +176,38 @@ const SBBreakpointName &SBBreakpointName::operator=(const SBBreakpointName &rhs)
}
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();
@ -208,6 +233,8 @@ void SBBreakpointName::UpdateName(BreakpointName &bp_name) {
}
bool SBBreakpointName::IsEnabled() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, IsEnabled);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointName *bp_name = GetBreakpointName();
@ -222,6 +249,8 @@ bool SBBreakpointName::IsEnabled() {
}
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();
@ -237,6 +266,8 @@ void SBBreakpointName::SetOneShot(bool one_shot) {
}
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();
@ -251,6 +282,8 @@ bool SBBreakpointName::IsOneShot() const {
}
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();
@ -266,6 +299,8 @@ void SBBreakpointName::SetIgnoreCount(uint32_t count) {
}
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();
@ -280,6 +315,9 @@ uint32_t SBBreakpointName::GetIgnoreCount() const {
}
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();
@ -297,6 +335,8 @@ void SBBreakpointName::SetCondition(const char *condition) {
}
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();
@ -311,6 +351,9 @@ const char *SBBreakpointName::GetCondition() {
}
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();
@ -327,6 +370,8 @@ void SBBreakpointName::SetAutoContinue(bool auto_continue) {
}
bool SBBreakpointName::GetAutoContinue() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAutoContinue);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
BreakpointName *bp_name = GetBreakpointName();
@ -341,6 +386,8 @@ bool SBBreakpointName::GetAutoContinue() {
}
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();
@ -357,6 +404,8 @@ void SBBreakpointName::SetThreadID(tid_t tid) {
}
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();
@ -371,6 +420,8 @@ tid_t SBBreakpointName::GetThreadID() {
}
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();
@ -387,6 +438,8 @@ void SBBreakpointName::SetThreadIndex(uint32_t index) {
}
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();
@ -401,6 +454,9 @@ uint32_t SBBreakpointName::GetThreadIndex() const {
}
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();
@ -417,6 +473,9 @@ void SBBreakpointName::SetThreadName(const char *thread_name) {
}
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();
@ -431,6 +490,9 @@ const char *SBBreakpointName::GetThreadName() const {
}
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();
@ -447,6 +509,9 @@ void SBBreakpointName::SetQueueName(const char *queue_name) {
}
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();
@ -461,6 +526,9 @@ const char *SBBreakpointName::GetQueueName() const {
}
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)
@ -480,6 +548,9 @@ void SBBreakpointName::SetCommandLineCommands(SBStringList &commands) {
}
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();
@ -496,6 +567,9 @@ bool SBBreakpointName::GetCommandLineCommands(SBStringList &commands) {
}
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();
@ -507,6 +581,9 @@ const char *SBBreakpointName::GetHelpString() const {
}
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)
@ -520,6 +597,9 @@ void SBBreakpointName::SetHelpString(const char *help_string) {
}
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();
@ -556,6 +636,9 @@ void SBBreakpointName::SetCallback(SBBreakpointHitCallback callback,
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();
@ -578,14 +661,17 @@ void SBBreakpointName::SetScriptCallbackFunction(
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);
@ -603,19 +689,21 @@ SBError SBBreakpointName::SetScriptCallbackBody(const char *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();
@ -626,17 +714,19 @@ void SBBreakpointName::SetAllowList(bool value)
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();
@ -647,17 +737,19 @@ void SBBreakpointName::SetAllowDelete(bool value)
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();

55
lldb/source/API/SBBroadcaster.cpp
View File

@ -6,6 +6,7 @@
//
//===----------------------------------------------------------------------===//
#include "SBReproducerPrivate.h"
#include "lldb/Utility/Broadcaster.h"
#include "lldb/Utility/Log.h"
@ -16,10 +17,14 @@
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);
@ -33,9 +38,15 @@ SBBroadcaster::SBBroadcaster(lldb_private::Broadcaster *broadcaster, bool owns)
}
SBBroadcaster::SBBroadcaster(const SBBroadcaster &rhs)
: m_opaque_sp(rhs.m_opaque_sp), m_opaque_ptr(rhs.m_opaque_ptr) {}
: 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;
@ -46,6 +57,9 @@ const SBBroadcaster &SBBroadcaster::operator=(const SBBroadcaster &rhs) {
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)
@ -63,6 +77,9 @@ void SBBroadcaster::BroadcastEventByType(uint32_t event_type, bool unique) {
}
void SBBroadcaster::BroadcastEvent(const SBEvent &event, bool unique) {
LLDB_RECORD_METHOD(void, SBBroadcaster, BroadcastEvent,
(const lldb::SBEvent &, bool), event, unique);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
@ -83,6 +100,10 @@ void SBBroadcaster::BroadcastEvent(const SBEvent &event, bool unique) {
void SBBroadcaster::AddInitialEventsToListener(const SBListener &listener,
uint32_t requested_events) {
LLDB_RECORD_METHOD(void, SBBroadcaster, AddInitialEventsToListener,
(const lldb::SBListener &, uint32_t), listener,
requested_events);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
log->Printf("SBBroadcaster(%p)::AddInitialEventsToListener "
@ -96,18 +117,27 @@ void SBBroadcaster::AddInitialEventsToListener(const SBListener &listener,
uint32_t SBBroadcaster::AddListener(const SBListener &listener,
uint32_t event_mask) {
LLDB_RECORD_METHOD(uint32_t, SBBroadcaster, AddListener,
(const lldb::SBListener &, uint32_t), listener,
event_mask);
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;
@ -115,6 +145,10 @@ bool SBBroadcaster::EventTypeHasListeners(uint32_t event_type) {
bool SBBroadcaster::RemoveListener(const SBListener &listener,
uint32_t event_mask) {
LLDB_RECORD_METHOD(bool, SBBroadcaster, RemoveListener,
(const lldb::SBListener &, uint32_t), listener,
event_mask);
if (m_opaque_ptr)
return m_opaque_ptr->RemoveListener(listener.m_opaque_sp, event_mask);
return false;
@ -130,21 +164,36 @@ void SBBroadcaster::reset(Broadcaster *broadcaster, bool owns) {
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;
}

258
lldb/source/API/SBCommandInterpreter.cpp
View File

@ -8,6 +8,7 @@
#include "lldb/lldb-types.h"
#include "SBReproducerPrivate.h"
#include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/CommandObjectMultiword.h"
#include "lldb/Interpreter/CommandReturnObject.h"
@ -31,64 +32,108 @@ using namespace lldb;
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);
}
@ -130,6 +175,9 @@ protected:
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)
@ -140,37 +188,62 @@ SBCommandInterpreter::SBCommandInterpreter(CommandInterpreter *interpreter)
}
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)
@ -182,6 +255,10 @@ lldb::ReturnStatus
SBCommandInterpreter::HandleCommand(const char *command_line,
SBCommandReturnObject &result,
bool add_to_history) {
LLDB_RECORD_METHOD(lldb::ReturnStatus, SBCommandInterpreter, HandleCommand,
(const char *, lldb::SBCommandReturnObject &, bool),
command_line, result, add_to_history);
SBExecutionContext sb_exe_ctx;
return HandleCommand(command_line, sb_exe_ctx, result, add_to_history);
}
@ -189,6 +266,11 @@ SBCommandInterpreter::HandleCommand(const char *command_line,
lldb::ReturnStatus SBCommandInterpreter::HandleCommand(
const char *command_line, SBExecutionContext &override_context,
SBCommandReturnObject &result, bool add_to_history) {
LLDB_RECORD_METHOD(lldb::ReturnStatus, SBCommandInterpreter, HandleCommand,
(const char *, lldb::SBExecutionContext &,
lldb::SBCommandReturnObject &, bool),
command_line, override_context, result, add_to_history);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
@ -235,6 +317,12 @@ void SBCommandInterpreter::HandleCommandsFromFile(
lldb::SBFileSpec &file, lldb::SBExecutionContext &override_context,
lldb::SBCommandInterpreterRunOptions &options,
lldb::SBCommandReturnObject result) {
LLDB_RECORD_METHOD(void, SBCommandInterpreter, HandleCommandsFromFile,
(lldb::SBFileSpec &, lldb::SBExecutionContext &,
lldb::SBCommandInterpreterRunOptions &,
lldb::SBCommandReturnObject),
file, override_context, options, result);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log) {
@ -274,6 +362,12 @@ void SBCommandInterpreter::HandleCommandsFromFile(
int SBCommandInterpreter::HandleCompletion(
const char *current_line, const char *cursor, const char *last_char,
int match_start_point, int max_return_elements, SBStringList &matches) {
LLDB_RECORD_METHOD(int, SBCommandInterpreter, HandleCompletion,
(const char *, const char *, const char *, int, int,
lldb::SBStringList &),
current_line, cursor, last_char, match_start_point,
max_return_elements, matches);
SBStringList dummy_descriptions;
return HandleCompletionWithDescriptions(
current_line, cursor, last_char, match_start_point, max_return_elements,
@ -284,6 +378,13 @@ int SBCommandInterpreter::HandleCompletionWithDescriptions(
const char *current_line, const char *cursor, const char *last_char,
int match_start_point, int max_return_elements, SBStringList &matches,
SBStringList &descriptions) {
LLDB_RECORD_METHOD(int, SBCommandInterpreter,
HandleCompletionWithDescriptions,
(const char *, const char *, const char *, int, int,
lldb::SBStringList &, lldb::SBStringList &),
current_line, cursor, last_char, match_start_point,
max_return_elements, matches, descriptions);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
int num_completions = 0;
@ -333,6 +434,13 @@ int SBCommandInterpreter::HandleCompletionWithDescriptions(
const char *current_line, uint32_t cursor_pos, int match_start_point,
int max_return_elements, SBStringList &matches,
SBStringList &descriptions) {
LLDB_RECORD_METHOD(int, SBCommandInterpreter,
HandleCompletionWithDescriptions,
(const char *, uint32_t, int, int, lldb::SBStringList &,
lldb::SBStringList &),
current_line, cursor_pos, match_start_point,
max_return_elements, matches, descriptions);
const char *cursor = current_line + cursor_pos;
const char *last_char = current_line + strlen(current_line);
return HandleCompletionWithDescriptions(
@ -345,6 +453,11 @@ int SBCommandInterpreter::HandleCompletion(const char *current_line,
int match_start_point,
int max_return_elements,
lldb::SBStringList &matches) {
LLDB_RECORD_METHOD(int, SBCommandInterpreter, HandleCompletion,
(const char *, uint32_t, int, int, lldb::SBStringList &),
current_line, cursor_pos, match_start_point,
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,
@ -352,18 +465,26 @@ int SBCommandInterpreter::HandleCompletion(const char *current_line,
}
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()) {
@ -381,10 +502,13 @@ SBProcess SBCommandInterpreter::GetProcess() {
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());
@ -395,24 +519,33 @@ SBDebugger SBCommandInterpreter::GetDebugger() {
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);
@ -420,12 +553,18 @@ bool SBCommandInterpreter::HasCustomQuitExitCode() {
}
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());
@ -450,6 +589,9 @@ void SBCommandInterpreter::reset(
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());
@ -472,6 +614,10 @@ void SBCommandInterpreter::SourceInitFileInHomeDirectory(
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());
@ -493,6 +639,9 @@ void SBCommandInterpreter::SourceInitFileInCurrentWorkingDirectory(
}
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);
@ -503,25 +652,40 @@ SBBroadcaster SBCommandInterpreter::GetBroadcaster() {
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();
}
@ -544,122 +708,166 @@ bool SBCommandInterpreter::SetCommandOverrideCallback(
lldb::SBCommand SBCommandInterpreter::AddMultiwordCommand(const char *name,
const char *help) {
LLDB_RECORD_METHOD(lldb::SBCommand, SBCommandInterpreter, AddMultiwordCommand,
(const char *, const char *), name, help);
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);
}

88
lldb/source/API/SBCommandReturnObject.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBCommandReturnObject.h"
#include "SBReproducerPrivate.h"
#include "Utils.h"
#include "lldb/API/SBError.h"
#include "lldb/API/SBStream.h"
@ -19,32 +20,54 @@ using namespace lldb;
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) {
@ -66,6 +89,8 @@ const char *SBCommandReturnObject::GetOutput() {
}
const char *SBCommandReturnObject::GetError() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommandReturnObject, GetError);
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (m_opaque_up) {
@ -86,14 +111,20 @@ const char *SBCommandReturnObject::GetError() {
}
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)
@ -103,6 +134,8 @@ size_t SBCommandReturnObject::PutOutput(FILE *fh) {
}
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)
@ -112,33 +145,51 @@ size_t SBCommandReturnObject::PutError(FILE *fh) {
}
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);
}
@ -167,6 +218,9 @@ void SBCommandReturnObject::SetLLDBObjectPtr(CommandReturnObject *ptr) {
}
bool SBCommandReturnObject::GetDescription(SBStream &description) {
LLDB_RECORD_METHOD(bool, SBCommandReturnObject, GetDescription,
(lldb::SBStream &), description);
Stream &strm = description.ref();
if (m_opaque_up) {
@ -193,26 +247,41 @@ bool SBCommandReturnObject::GetDescription(SBStream &description) {
}
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;
@ -225,6 +294,9 @@ void SBCommandReturnObject::PutCString(const char *string, int len) {
}
const char *SBCommandReturnObject::GetOutput(bool only_if_no_immediate) {
LLDB_RECORD_METHOD(const char *, SBCommandReturnObject, GetOutput, (bool),
only_if_no_immediate);
if (!m_opaque_up)
return nullptr;
if (!only_if_no_immediate ||
@ -234,6 +306,9 @@ const char *SBCommandReturnObject::GetOutput(bool only_if_no_immediate) {
}
const char *SBCommandReturnObject::GetError(bool only_if_no_immediate) {
LLDB_RECORD_METHOD(const char *, SBCommandReturnObject, GetError, (bool),
only_if_no_immediate);
if (!m_opaque_up)
return nullptr;
if (!only_if_no_immediate ||
@ -255,6 +330,10 @@ size_t SBCommandReturnObject::Printf(const char *format, ...) {
void SBCommandReturnObject::SetError(lldb::SBError &error,
const char *fallback_error_cstr) {
LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetError,
(lldb::SBError &, const char *), error,
fallback_error_cstr);
if (m_opaque_up) {
if (error.IsValid())
m_opaque_up->SetError(error.ref(), fallback_error_cstr);
@ -264,6 +343,9 @@ void SBCommandReturnObject::SetError(lldb::SBError &error,
}
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);
}

42
lldb/source/API/SBCommunication.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBCommunication.h"
#include "SBReproducerPrivate.h"
#include "lldb/API/SBBroadcaster.h"
#include "lldb/Core/Communication.h"
#include "lldb/Host/ConnectionFileDescriptor.h"
@ -16,10 +17,14 @@
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)
@ -35,20 +40,31 @@ SBCommunication::~SBCommunication() {
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());
@ -58,6 +74,9 @@ ConnectionStatus SBCommunication::Connect(const char *url) {
}
ConnectionStatus SBCommunication::AdoptFileDesriptor(int fd, bool owns_fd) {
LLDB_RECORD_METHOD(lldb::ConnectionStatus, SBCommunication,
AdoptFileDesriptor, (int, bool), fd, owns_fd);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
ConnectionStatus status = eConnectionStatusNoConnection;
@ -83,6 +102,9 @@ ConnectionStatus SBCommunication::AdoptFileDesriptor(int fd, bool owns_fd) {
}
ConnectionStatus SBCommunication::Disconnect() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::ConnectionStatus, SBCommunication,
Disconnect);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
ConnectionStatus status = eConnectionStatusNoConnection;
@ -98,6 +120,8 @@ ConnectionStatus SBCommunication::Disconnect() {
}
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)
@ -158,6 +182,8 @@ size_t SBCommunication::Write(const void *src, size_t src_len,
}
bool SBCommunication::ReadThreadStart() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadStart);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
bool success = false;
@ -172,6 +198,8 @@ bool SBCommunication::ReadThreadStart() {
}
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 ()...",
@ -189,6 +217,8 @@ bool SBCommunication::ReadThreadStop() {
}
bool SBCommunication::ReadThreadIsRunning() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadIsRunning);
bool result = false;
if (m_opaque)
result = m_opaque->ReadThreadIsRunning();
@ -220,6 +250,9 @@ bool SBCommunication::SetReadThreadBytesReceivedCallback(
}
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));
@ -229,10 +262,13 @@ SBBroadcaster SBCommunication::GetBroadcaster() {
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();
}

72
lldb/source/API/SBCompileUnit.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBCompileUnit.h"
#include "SBReproducerPrivate.h"
#include "lldb/API/SBLineEntry.h"
#include "lldb/API/SBStream.h"
#include "lldb/Core/Module.h"
@ -20,15 +21,23 @@
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;
}
@ -36,13 +45,18 @@ const SBCompileUnit &SBCompileUnit::operator=(const SBCompileUnit &rhs) {
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)
@ -52,6 +66,9 @@ uint32_t SBCompileUnit::GetNumLineEntries() const {
}
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;
@ -73,11 +90,15 @@ SBLineEntry SBCompileUnit::GetLineEntryAtIndex(uint32_t idx) const {
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);
}
@ -85,6 +106,10 @@ uint32_t SBCompileUnit::FindLineEntryIndex(uint32_t start_idx, uint32_t line,
uint32_t SBCompileUnit::FindLineEntryIndex(uint32_t start_idx, uint32_t line,
SBFileSpec *inline_file_spec,
bool exact) const {
LLDB_RECORD_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex,
(uint32_t, uint32_t, lldb::SBFileSpec *, bool),
start_idx, line, inline_file_spec, exact);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
uint32_t index = UINT32_MAX;
@ -124,6 +149,8 @@ uint32_t SBCompileUnit::FindLineEntryIndex(uint32_t start_idx, uint32_t line,
}
uint32_t SBCompileUnit::GetNumSupportFiles() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBCompileUnit, GetNumSupportFiles);
if (m_opaque_ptr) {
FileSpecList &support_files = m_opaque_ptr->GetSupportFiles();
return support_files.GetSize();
@ -132,27 +159,33 @@ uint32_t SBCompileUnit::GetNumSupportFiles() const {
}
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;
@ -171,12 +204,16 @@ SBFileSpec SBCompileUnit::GetSupportFileAtIndex(uint32_t idx) const {
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);
@ -185,18 +222,30 @@ uint32_t SBCompileUnit::FindSupportFileIndex(uint32_t start_idx,
}
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;
}
@ -215,6 +264,9 @@ void SBCompileUnit::reset(lldb_private::CompileUnit *lldb_object_ptr) {
}
bool SBCompileUnit::GetDescription(SBStream &description) {
LLDB_RECORD_METHOD(bool, SBCompileUnit, GetDescription, (lldb::SBStream &),
description);
Stream &strm = description.ref();
if (m_opaque_ptr) {

140
lldb/source/API/SBData.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBData.h"
#include "SBReproducerPrivate.h"
#include "lldb/API/SBError.h"
#include "lldb/API/SBStream.h"
@ -22,13 +23,20 @@
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;
@ -50,9 +58,15 @@ lldb::DataExtractorSP &SBData::operator*() { return m_opaque_sp; }
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())
@ -65,6 +79,9 @@ uint8_t SBData::GetAddressByteSize() {
}
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);
@ -73,11 +90,15 @@ void SBData::SetAddressByteSize(uint8_t 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())
@ -90,6 +111,8 @@ size_t SBData::GetByteSize() {
}
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())
@ -102,6 +125,8 @@ lldb::ByteOrder SBData::GetByteOrder() {
}
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);
@ -110,6 +135,9 @@ void SBData::SetByteOrder(lldb::ByteOrder 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()) {
@ -127,6 +155,9 @@ float SBData::GetFloat(lldb::SBError &error, lldb::offset_t offset) {
}
double SBData::GetDouble(lldb::SBError &error, lldb::offset_t offset) {
LLDB_RECORD_METHOD(double, SBData, GetDouble,
(lldb::SBError &, lldb::offset_t), error, offset);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
double value = 0;
if (!m_opaque_sp.get()) {
@ -145,6 +176,9 @@ double SBData::GetDouble(lldb::SBError &error, lldb::offset_t offset) {
}
long double SBData::GetLongDouble(lldb::SBError &error, lldb::offset_t offset) {
LLDB_RECORD_METHOD(long double, SBData, GetLongDouble,
(lldb::SBError &, lldb::offset_t), error, offset);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
long double value = 0;
if (!m_opaque_sp.get()) {
@ -163,6 +197,9 @@ long double SBData::GetLongDouble(lldb::SBError &error, lldb::offset_t offset) {
}
lldb::addr_t SBData::GetAddress(lldb::SBError &error, lldb::offset_t offset) {
LLDB_RECORD_METHOD(lldb::addr_t, SBData, GetAddress,
(lldb::SBError &, lldb::offset_t), error, offset);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
lldb::addr_t value = 0;
if (!m_opaque_sp.get()) {
@ -182,6 +219,9 @@ lldb::addr_t SBData::GetAddress(lldb::SBError &error, lldb::offset_t offset) {
}
uint8_t SBData::GetUnsignedInt8(lldb::SBError &error, lldb::offset_t offset) {
LLDB_RECORD_METHOD(uint8_t, SBData, GetUnsignedInt8,
(lldb::SBError &, lldb::offset_t), error, offset);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
uint8_t value = 0;
if (!m_opaque_sp.get()) {
@ -200,6 +240,9 @@ uint8_t SBData::GetUnsignedInt8(lldb::SBError &error, lldb::offset_t offset) {
}
uint16_t SBData::GetUnsignedInt16(lldb::SBError &error, lldb::offset_t offset) {
LLDB_RECORD_METHOD(uint16_t, SBData, GetUnsignedInt16,
(lldb::SBError &, lldb::offset_t), error, offset);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
uint16_t value = 0;
if (!m_opaque_sp.get()) {
@ -218,6 +261,9 @@ uint16_t SBData::GetUnsignedInt16(lldb::SBError &error, lldb::offset_t offset) {
}
uint32_t SBData::GetUnsignedInt32(lldb::SBError &error, lldb::offset_t offset) {
LLDB_RECORD_METHOD(uint32_t, SBData, GetUnsignedInt32,
(lldb::SBError &, lldb::offset_t), error, offset);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
uint32_t value = 0;
if (!m_opaque_sp.get()) {
@ -236,6 +282,9 @@ uint32_t SBData::GetUnsignedInt32(lldb::SBError &error, lldb::offset_t offset) {
}
uint64_t SBData::GetUnsignedInt64(lldb::SBError &error, lldb::offset_t offset) {
LLDB_RECORD_METHOD(uint64_t, SBData, GetUnsignedInt64,
(lldb::SBError &, lldb::offset_t), error, offset);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
uint64_t value = 0;
if (!m_opaque_sp.get()) {
@ -254,6 +303,9 @@ uint64_t SBData::GetUnsignedInt64(lldb::SBError &error, lldb::offset_t offset) {
}
int8_t SBData::GetSignedInt8(lldb::SBError &error, lldb::offset_t offset) {
LLDB_RECORD_METHOD(int8_t, SBData, GetSignedInt8,
(lldb::SBError &, lldb::offset_t), error, offset);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
int8_t value = 0;
if (!m_opaque_sp.get()) {
@ -272,6 +324,9 @@ int8_t SBData::GetSignedInt8(lldb::SBError &error, lldb::offset_t offset) {
}
int16_t SBData::GetSignedInt16(lldb::SBError &error, lldb::offset_t offset) {
LLDB_RECORD_METHOD(int16_t, SBData, GetSignedInt16,
(lldb::SBError &, lldb::offset_t), error, offset);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
int16_t value = 0;
if (!m_opaque_sp.get()) {
@ -290,6 +345,9 @@ int16_t SBData::GetSignedInt16(lldb::SBError &error, lldb::offset_t offset) {
}
int32_t SBData::GetSignedInt32(lldb::SBError &error, lldb::offset_t offset) {
LLDB_RECORD_METHOD(int32_t, SBData, GetSignedInt32,
(lldb::SBError &, lldb::offset_t), error, offset);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
int32_t value = 0;
if (!m_opaque_sp.get()) {
@ -308,6 +366,9 @@ int32_t SBData::GetSignedInt32(lldb::SBError &error, lldb::offset_t offset) {
}
int64_t SBData::GetSignedInt64(lldb::SBError &error, lldb::offset_t offset) {
LLDB_RECORD_METHOD(int64_t, SBData, GetSignedInt64,
(lldb::SBError &, lldb::offset_t), error, offset);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
int64_t value = 0;
if (!m_opaque_sp.get()) {
@ -326,6 +387,9 @@ int64_t SBData::GetSignedInt64(lldb::SBError &error, lldb::offset_t offset) {
}
const char *SBData::GetString(lldb::SBError &error, lldb::offset_t offset) {
LLDB_RECORD_METHOD(const char *, SBData, GetString,
(lldb::SBError &, lldb::offset_t), error, offset);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
const char *value = 0;
if (!m_opaque_sp.get()) {
@ -345,6 +409,9 @@ const char *SBData::GetString(lldb::SBError &error, lldb::offset_t offset) {
bool SBData::GetDescription(lldb::SBStream &description,
lldb::addr_t base_addr) {
LLDB_RECORD_METHOD(bool, SBData, GetDescription,
(lldb::SBStream &, lldb::addr_t), description, base_addr);
Stream &strm = description.ref();
if (m_opaque_sp) {
@ -399,6 +466,8 @@ void SBData::SetData(lldb::SBError &error, const void *buf, size_t size,
}
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())
@ -412,8 +481,12 @@ bool SBData::Append(const SBData &rhs) {
lldb::SBData SBData::CreateDataFromCString(lldb::ByteOrder endian,
uint32_t addr_byte_size,
const char *data) {
LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromCString,
(lldb::ByteOrder, uint32_t, const char *), endian,
addr_byte_size, data);
if (!data || !data[0])
return SBData();
return LLDB_RECORD_RESULT(SBData());
uint32_t data_len = strlen(data);
@ -423,15 +496,19 @@ lldb::SBData SBData::CreateDataFromCString(lldb::ByteOrder endian,
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);
@ -441,15 +518,19 @@ lldb::SBData SBData::CreateDataFromUInt64Array(lldb::ByteOrder endian,
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);
@ -459,15 +540,19 @@ lldb::SBData SBData::CreateDataFromUInt32Array(lldb::ByteOrder endian,
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);
@ -477,15 +562,19 @@ lldb::SBData SBData::CreateDataFromSInt64Array(lldb::ByteOrder endian,
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);
@ -495,15 +584,19 @@ lldb::SBData SBData::CreateDataFromSInt32Array(lldb::ByteOrder endian,
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);
@ -513,10 +606,12 @@ lldb::SBData SBData::CreateDataFromDoubleArray(lldb::ByteOrder endian,
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) {
@ -544,6 +639,9 @@ bool SBData::SetDataFromCString(const char *data) {
}
bool SBData::SetDataFromUInt64Array(uint64_t *array, size_t array_len) {
LLDB_RECORD_METHOD(bool, SBData, SetDataFromUInt64Array, (uint64_t *, size_t),
array, array_len);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (!array || array_len == 0) {
@ -576,6 +674,9 @@ bool SBData::SetDataFromUInt64Array(uint64_t *array, size_t array_len) {
}
bool SBData::SetDataFromUInt32Array(uint32_t *array, size_t array_len) {
LLDB_RECORD_METHOD(bool, SBData, SetDataFromUInt32Array, (uint32_t *, size_t),
array, array_len);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (!array || array_len == 0) {
@ -608,6 +709,9 @@ bool SBData::SetDataFromUInt32Array(uint32_t *array, size_t array_len) {
}
bool SBData::SetDataFromSInt64Array(int64_t *array, size_t array_len) {
LLDB_RECORD_METHOD(bool, SBData, SetDataFromSInt64Array, (int64_t *, size_t),
array, array_len);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (!array || array_len == 0) {
@ -640,6 +744,9 @@ bool SBData::SetDataFromSInt64Array(int64_t *array, size_t array_len) {
}
bool SBData::SetDataFromSInt32Array(int32_t *array, size_t array_len) {
LLDB_RECORD_METHOD(bool, SBData, SetDataFromSInt32Array, (int32_t *, size_t),
array, array_len);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (!array || array_len == 0) {
@ -672,6 +779,9 @@ bool SBData::SetDataFromSInt32Array(int32_t *array, size_t array_len) {
}
bool SBData::SetDataFromDoubleArray(double *array, size_t array_len) {
LLDB_RECORD_METHOD(bool, SBData, SetDataFromDoubleArray, (double *, size_t),
array, array_len);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (!array || array_len == 0) {

393
lldb/source/API/SBDebugger.cpp
View File

@ -6,7 +6,7 @@
//
//===----------------------------------------------------------------------===//
#include "SBReproducerPrivate.h"
#include "SystemInitializerFull.h"
#include "lldb/API/SBDebugger.h"
@ -142,20 +142,33 @@ SBError SBInputReader::Initialize(
return SBError();
}
void SBInputReader::SetIsDone(bool) {}
void SBInputReader::SetIsDone(bool b) {
LLDB_RECORD_METHOD(void, SBInputReader, SetIsDone, (bool), b);
}
bool SBInputReader::IsActive() const { return false; }
bool SBInputReader::IsActive() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInputReader, IsActive);
SBDebugger::SBDebugger() = default;
return false;
}
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;
}
@ -163,10 +176,14 @@ SBDebugger &SBDebugger::operator=(const SBDebugger &rhs) {
}
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)
@ -177,12 +194,18 @@ lldb::SBError SBDebugger::InitializeWithErrorHandling() {
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)
@ -196,11 +219,17 @@ void SBDebugger::Clear() {
}
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,
@ -243,6 +272,9 @@ 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) {
@ -260,6 +292,8 @@ void SBDebugger::Destroy(SBDebugger &debugger) {
}
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
@ -275,23 +309,35 @@ void SBDebugger::MemoryPressureDetected() {
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);
}
@ -300,6 +346,9 @@ void SBDebugger::SkipAppInitFiles(bool 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)
@ -323,6 +372,9 @@ void SBDebugger::SetInputFileHandle(FILE *fh, bool transfer_ownership) {
}
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)
@ -336,6 +388,9 @@ void SBDebugger::SetOutputFileHandle(FILE *fh, bool transfer_ownership) {
}
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)
@ -349,6 +404,8 @@ void SBDebugger::SetErrorFileHandle(FILE *fh, bool transfer_ownership) {
}
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)
@ -358,6 +415,8 @@ FILE *SBDebugger::GetInputFileHandle() {
}
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)
@ -367,6 +426,8 @@ FILE *SBDebugger::GetOutputFileHandle() {
}
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)
@ -376,15 +437,22 @@ FILE *SBDebugger::GetErrorFileHandle() {
}
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;
@ -397,10 +465,12 @@ SBCommandInterpreter SBDebugger::GetCommandInterpreter() {
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;
@ -435,6 +505,8 @@ void SBDebugger::HandleCommand(const char *command) {
}
SBListener SBDebugger::GetListener() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBDebugger, GetListener);
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBListener sb_listener;
@ -446,12 +518,17 @@ SBListener SBDebugger::GetListener() {
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;
@ -494,11 +571,17 @@ void SBDebugger::HandleProcessEvent(const SBProcess &process,
}
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();
@ -518,6 +601,9 @@ bool SBDebugger::GetDefaultArchitecture(char *arch_name, size_t arch_name_len) {
}
bool SBDebugger::SetDefaultArchitecture(const char *arch_name) {
LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, SetDefaultArchitecture,
(const char *), arch_name);
if (arch_name) {
ArchSpec arch(arch_name);
if (arch.IsValid()) {
@ -530,16 +616,24 @@ bool SBDebugger::SetDefaultArchitecture(const char *arch_name) {
ScriptLanguage
SBDebugger::GetScriptingLanguage(const char *script_language_name) {
LLDB_RECORD_METHOD(lldb::ScriptLanguage, SBDebugger, GetScriptingLanguage,
(const char *), script_language_name);
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);
}
@ -564,6 +658,9 @@ static void AddLLVMTargets(StructuredData::Dictionary &dict) {
}
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(),
@ -572,10 +669,13 @@ SBStructuredData SBDebugger::GetBuildConfiguration() {
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);
@ -587,6 +687,9 @@ bool SBDebugger::StateIsRunningState(StateType 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);
@ -602,6 +705,11 @@ lldb::SBTarget SBDebugger::CreateTarget(const char *filename,
const char *platform_name,
bool add_dependent_modules,
lldb::SBError &sb_error) {
LLDB_RECORD_METHOD(
lldb::SBTarget, SBDebugger, CreateTarget,
(const char *, const char *, const char *, bool, lldb::SBError &),
filename, target_triple, platform_name, add_dependent_modules, sb_error);
SBTarget sb_target;
TargetSP target_sp;
if (m_opaque_sp) {
@ -629,12 +737,16 @@ lldb::SBTarget SBDebugger::CreateTarget(const char *filename,
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) {
@ -653,11 +765,14 @@ SBDebugger::CreateTargetWithFileAndTargetTriple(const char *filename,
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;
@ -683,10 +798,13 @@ SBTarget SBDebugger::CreateTargetWithFileAndArch(const char *filename,
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) {
@ -708,10 +826,12 @@ SBTarget SBDebugger::CreateTarget(const char *filename) {
"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());
@ -722,10 +842,13 @@ SBTarget SBDebugger::GetDummyTarget() {
"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());
@ -749,15 +872,20 @@ bool SBDebugger::DeleteTarget(lldb::SBTarget &target) {
}
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)
@ -770,16 +898,22 @@ uint32_t SBDebugger::GetIndexOfTarget(lldb::SBTarget target) {
}
SBTarget SBDebugger::FindTargetWithProcessID(lldb::pid_t pid) {
LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithProcessID,
(lldb::pid_t), pid);
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
@ -790,7 +924,7 @@ SBTarget SBDebugger::FindTargetWithFileAndArch(const char *filename,
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) {
@ -804,6 +938,8 @@ 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();
@ -812,6 +948,8 @@ uint32_t SBDebugger::GetNumTargets() {
}
SBTarget SBDebugger::GetSelectedTarget() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBDebugger, GetSelectedTarget);
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBTarget sb_target;
@ -830,10 +968,13 @@ SBTarget SBDebugger::GetSelectedTarget() {
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());
@ -850,6 +991,8 @@ void SBDebugger::SetSelectedTarget(SBTarget &sb_target) {
}
SBPlatform SBDebugger::GetSelectedPlatform() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBPlatform, SBDebugger, GetSelectedPlatform);
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBPlatform sb_platform;
@ -862,10 +1005,13 @@ SBPlatform SBDebugger::GetSelectedPlatform() {
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);
@ -881,6 +1027,8 @@ void SBDebugger::SetSelectedPlatform(SBPlatform &sb_platform) {
}
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();
@ -889,15 +1037,20 @@ uint32_t SBDebugger::GetNumPlatforms() {
}
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)) {
@ -910,6 +1063,9 @@ uint32_t SBDebugger::GetNumAvailablePlatforms() {
}
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");
@ -924,21 +1080,21 @@ SBStructuredData SBDebugger::GetAvailablePlatformInfoAtIndex(uint32_t idx) {
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) {
@ -961,19 +1117,29 @@ void SBDebugger::DispatchInput(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;
@ -989,6 +1155,12 @@ void SBDebugger::RunCommandInterpreter(bool auto_handle_events,
bool &stopped_for_crash)
{
LLDB_RECORD_METHOD(void, SBDebugger, RunCommandInterpreter,
(bool, bool, lldb::SBCommandInterpreterRunOptions &, int &,
bool &, bool &),
auto_handle_events, spawn_thread, options, num_errors,
quit_requested, stopped_for_crash);
if (m_opaque_sp) {
CommandInterpreter &interp = m_opaque_sp->GetCommandInterpreter();
interp.RunCommandInterpreter(auto_handle_events, spawn_thread,
@ -1001,12 +1173,16 @@ void SBDebugger::RunCommandInterpreter(bool auto_handle_events,
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) {
@ -1023,20 +1199,29 @@ Debugger &SBDebugger::ref() const {
const lldb::DebuggerSP &SBDebugger::get_sp() const { return m_opaque_sp; }
SBDebugger SBDebugger::FindDebuggerWithID(int id) {
LLDB_RECORD_STATIC_METHOD(lldb::SBDebugger, SBDebugger, FindDebuggerWithID,
(int), id);
// 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)));
@ -1052,12 +1237,16 @@ SBError SBDebugger::SetInternalVariable(const char *var_name, const char *value,
}
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)));
@ -1074,23 +1263,30 @@ SBDebugger::GetInternalVariableValue(const char *var_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)
@ -1103,43 +1299,64 @@ const char *SBDebugger::GetPrompt() const {
}
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) {
@ -1153,10 +1370,15 @@ bool SBDebugger::GetDescription(SBStream &description) {
}
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]) {
@ -1181,10 +1403,13 @@ SBError SBDebugger::SetCurrentPlatform(const char *platform_name_cstr) {
} 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(
@ -1201,49 +1426,68 @@ bool SBDebugger::SetCurrentPlatformSDKRoot(const char *sysroot) {
}
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;
@ -1251,45 +1495,67 @@ bool SBDebugger::DeleteCategory(const char *category_name) {
}
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
@ -1303,6 +1569,9 @@ static llvm::ArrayRef<const char *> GetCategoryArray(const char **categories) {
}
bool SBDebugger::EnableLog(const char *channel, const char **categories) {
LLDB_RECORD_METHOD(bool, SBDebugger, EnableLog, (const char *, const char **),
channel, categories);
if (m_opaque_sp) {
uint32_t log_options =
LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME;

46
lldb/source/API/SBDeclaration.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBDeclaration.h"
#include "SBReproducerPrivate.h"
#include "Utils.h"
#include "lldb/API/SBStream.h"
#include "lldb/Host/PosixApi.h"
@ -19,9 +20,13 @@
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);
}
@ -32,6 +37,10 @@ SBDeclaration::SBDeclaration(const lldb_private::Declaration *lldb_object_ptr)
}
const SBDeclaration &SBDeclaration::operator=(const SBDeclaration &rhs) {
LLDB_RECORD_METHOD(const lldb::SBDeclaration &,
SBDeclaration, operator=,(const lldb::SBDeclaration &),
rhs);
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
return *this;
@ -45,10 +54,15 @@ void SBDeclaration::SetDeclaration(
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;
@ -63,10 +77,12 @@ SBFileSpec SBDeclaration::GetFileSpec() const {
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;
@ -81,22 +97,38 @@ uint32_t SBDeclaration::GetLine() const {
}
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();
@ -107,6 +139,9 @@ bool SBDeclaration::operator==(const SBDeclaration &rhs) const {
}
bool SBDeclaration::operator!=(const SBDeclaration &rhs) const {
LLDB_RECORD_METHOD_CONST(
bool, SBDeclaration, operator!=,(const lldb::SBDeclaration &), rhs);
lldb_private::Declaration *lhs_ptr = m_opaque_up.get();
lldb_private::Declaration *rhs_ptr = rhs.m_opaque_up.get();
@ -131,6 +166,9 @@ const lldb_private::Declaration &SBDeclaration::ref() const {
}
bool SBDeclaration::GetDescription(SBStream &description) {
LLDB_RECORD_METHOD(bool, SBDeclaration, GetDescription, (lldb::SBStream &),
description);
Stream &strm = description.ref();
if (m_opaque_up) {

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

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBError.h"
#include "SBReproducerPrivate.h"
#include "Utils.h"
#include "lldb/API/SBStream.h"
#include "lldb/Utility/Log.h"
@ -17,32 +18,43 @@
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;
@ -57,6 +69,8 @@ bool SBError::Fail() const {
}
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)
@ -70,6 +84,8 @@ bool SBError::Success() const {
}
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;
@ -84,6 +100,8 @@ uint32_t SBError::GetError() const {
}
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)
@ -97,6 +115,9 @@ ErrorType SBError::GetType() const {
}
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);
}
@ -107,16 +128,22 @@ void SBError::SetError(const Status &lldb_error) {
}
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);
}
@ -130,7 +157,11 @@ int SBError::SetErrorStringWithFormat(const char *format, ...) {
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)
@ -152,6 +183,9 @@ const lldb_private::Status &SBError::operator*() const {
}
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");

54
lldb/source/API/SBEvent.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBEvent.h"
#include "SBReproducerPrivate.h"
#include "lldb/API/SBBroadcaster.h"
#include "lldb/API/SBStream.h"
@ -21,21 +22,35 @@
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;
@ -46,6 +61,8 @@ const SBEvent &SBEvent::operator=(const SBEvent &rhs) {
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();
@ -56,6 +73,8 @@ const char *SBEvent::GetDataFlavor() {
}
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();
@ -78,14 +97,19 @@ uint32_t SBEvent::GetType() const {
}
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();
@ -94,12 +118,17 @@ const char *SBEvent::GetBroadcasterClass() const {
}
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;
@ -116,6 +145,8 @@ bool SBEvent::BroadcasterMatchesRef(const SBBroadcaster &broadcaster) {
}
void SBEvent::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBEvent, Clear);
Event *lldb_event = get();
if (lldb_event)
lldb_event->Clear();
@ -145,12 +176,17 @@ void SBEvent::reset(Event *event_ptr) {
}
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)
@ -164,6 +200,9 @@ const char *SBEvent::GetCStringFromEvent(const SBEvent &event) {
}
bool SBEvent::GetDescription(SBStream &description) {
LLDB_RECORD_METHOD(bool, SBEvent, GetDescription, (lldb::SBStream &),
description);
Stream &strm = description.ref();
if (get()) {
@ -175,6 +214,9 @@ bool SBEvent::GetDescription(SBStream &description) {
}
bool SBEvent::GetDescription(SBStream &description) const {
LLDB_RECORD_METHOD_CONST(bool, SBEvent, GetDescription, (lldb::SBStream &),
description);
Stream &strm = description.ref();
if (get()) {

47
lldb/source/API/SBExecutionContext.cpp
View File

@ -8,6 +8,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBExecutionContext.h"
#include "SBReproducerPrivate.h"
#include "lldb/API/SBFrame.h"
#include "lldb/API/SBProcess.h"
@ -19,32 +20,49 @@
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());
}
@ -52,6 +70,10 @@ SBExecutionContext::~SBExecutionContext() {}
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;
}
@ -61,41 +83,52 @@ ExecutionContextRef *SBExecutionContext::get() const {
}
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);
}

95
lldb/source/API/SBExpressionOptions.cpp
View File

@ -8,6 +8,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBExpressionOptions.h"
#include "SBReproducerPrivate.h"
#include "Utils.h"
#include "lldb/API/SBStream.h"
#include "lldb/Target/Target.h"
@ -16,15 +17,24 @@ using namespace lldb;
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;
@ -33,83 +43,137 @@ operator=(const SBExpressionOptions &rhs) {
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);
}
@ -119,51 +183,80 @@ void SBExpressionOptions::SetCancelCallback(
}
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);
}

52
lldb/source/API/SBFileSpec.cpp
View File

@ -6,11 +6,9 @@
//
//===----------------------------------------------------------------------===//
#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"
@ -20,12 +18,19 @@
#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);
}
@ -34,11 +39,15 @@ SBFileSpec::SBFileSpec(const lldb_private::FileSpec &fspec)
// Deprecated!!!
SBFileSpec::SBFileSpec(const char *path) : m_opaque_up(new FileSpec(path)) {
LLDB_RECORD_CONSTRUCTOR(SBFileSpec, (const char *), path);
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);
}
@ -46,14 +55,23 @@ SBFileSpec::SBFileSpec(const char *path, bool resolve)
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);
@ -67,11 +85,17 @@ bool SBFileSpec::Exists() const {
}
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());
@ -79,6 +103,8 @@ int SBFileSpec::ResolvePath(const char *src_path, char *dst_path,
}
const char *SBFileSpec::GetFilename() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFileSpec, GetFilename);
const char *s = m_opaque_up->GetFilename().AsCString();
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
@ -95,6 +121,8 @@ const char *SBFileSpec::GetFilename() const {
}
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));
@ -111,6 +139,8 @@ const char *SBFileSpec::GetDirectory() const {
}
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
@ -118,6 +148,8 @@ void SBFileSpec::SetFilename(const char *filename) {
}
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
@ -125,6 +157,9 @@ void SBFileSpec::SetDirectory(const char *directory) {
}
uint32_t SBFileSpec::GetPath(char *dst_path, size_t dst_len) const {
LLDB_RECORD_METHOD_CONST(uint32_t, SBFileSpec, GetPath, (char *, size_t),
dst_path, dst_len);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
uint32_t result = m_opaque_up->GetPath(dst_path, dst_len);
@ -159,6 +194,9 @@ void SBFileSpec::SetFileSpec(const lldb_private::FileSpec &fs) {
}
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)))
@ -167,5 +205,7 @@ bool SBFileSpec::GetDescription(SBStream &description) const {
}
void SBFileSpec::AppendPathComponent(const char *fn) {
LLDB_RECORD_METHOD(void, SBFileSpec, AppendPathComponent, (const char *), fn);
m_opaque_up->AppendPathComponent(fn);
}

47
lldb/source/API/SBFileSpecList.cpp
View File

@ -6,11 +6,10 @@
//
//===----------------------------------------------------------------------===//
#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"
@ -18,12 +17,18 @@
#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);
@ -39,32 +44,57 @@ SBFileSpecList::SBFileSpecList(const SBFileSpecList &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 {
@ -84,6 +114,9 @@ const lldb_private::FileSpecList &SBFileSpecList::ref() 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) {

206
lldb/source/API/SBFrame.cpp
View File

@ -15,6 +15,7 @@
#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"
@ -54,10 +55,15 @@
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) {
@ -70,12 +76,17 @@ SBFrame::SBFrame(const StackFrameSP &lldb_object_sp)
}
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;
@ -90,6 +101,8 @@ void SBFrame::SetFrameSP(const StackFrameSP &lldb_object_sp) {
}
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);
@ -106,6 +119,9 @@ bool SBFrame::IsValid() const {
}
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;
@ -138,10 +154,12 @@ SBSymbolContext SBFrame::GetSymbolContext(uint32_t resolve_scope) const {
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;
@ -174,10 +192,13 @@ SBModule SBFrame::GetModule() const {
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;
@ -208,10 +229,12 @@ SBCompileUnit SBFrame::GetCompileUnit() const {
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;
@ -242,10 +265,12 @@ SBFunction SBFrame::GetFunction() const {
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;
@ -274,10 +299,12 @@ SBSymbol SBFrame::GetSymbol() const {
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;
@ -307,10 +334,12 @@ SBBlock SBFrame::GetBlock() const {
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);
@ -339,10 +368,12 @@ SBBlock SBFrame::GetFrameBlock() const {
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;
@ -372,10 +403,12 @@ SBLineEntry SBFrame::GetLineEntry() const {
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;
@ -393,6 +426,8 @@ uint32_t SBFrame::GetFrameID() const {
}
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);
@ -403,6 +438,8 @@ lldb::addr_t SBFrame::GetCFA() const {
}
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;
@ -437,6 +474,8 @@ addr_t SBFrame::GetPC() const {
}
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;
@ -470,6 +509,8 @@ bool SBFrame::SetPC(addr_t new_pc) {
}
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;
@ -502,6 +543,8 @@ addr_t SBFrame::GetSP() const {
}
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;
@ -534,6 +577,8 @@ addr_t SBFrame::GetFP() const {
}
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;
@ -561,12 +606,19 @@ SBAddress SBFrame::GetPCAddress() const {
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);
@ -578,18 +630,22 @@ lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path) {
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;
@ -622,10 +678,13 @@ lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path,
"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);
@ -637,11 +696,14 @@ SBValue SBFrame::FindVariable(const char *name) {
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;
@ -649,7 +711,7 @@ SBValue SBFrame::FindVariable(const char *name,
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;
@ -684,10 +746,13 @@ SBValue SBFrame::FindVariable(const char *name,
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);
@ -699,18 +764,22 @@ SBValue SBFrame::FindValue(const char *name, ValueType value_type) {
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;
@ -834,20 +903,35 @@ SBValue SBFrame::FindValue(const char *name, ValueType value_type,
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);
bool SBFrame::operator!=(const SBFrame &rhs) const { return !IsEqual(rhs); }
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;
@ -864,10 +948,12 @@ SBThread SBFrame::GetThread() const {
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;
@ -902,6 +988,10 @@ const char *SBFrame::Disassemble() const {
SBValueList SBFrame::GetVariables(bool arguments, bool locals, bool statics,
bool in_scope_only) {
LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables,
(bool, bool, bool, bool), arguments, locals, statics,
in_scope_only);
SBValueList value_list;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@ -924,12 +1014,16 @@ SBValueList SBFrame::GetVariables(bool arguments, bool locals, bool statics,
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);
@ -943,10 +1037,13 @@ lldb::SBValueList SBFrame::GetVariables(bool arguments, bool locals,
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;
@ -1063,10 +1160,12 @@ SBValueList SBFrame::GetVariables(const lldb::SBVariablesOptions &options) {
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;
@ -1105,10 +1204,13 @@ SBValueList SBFrame::GetRegisters() {
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;
@ -1156,10 +1258,13 @@ SBValue SBFrame::FindRegister(const char *name) {
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();
@ -1192,6 +1297,9 @@ bool SBFrame::GetDescription(SBStream &description) {
}
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);
@ -1209,14 +1317,18 @@ SBValue SBFrame::EvaluateExpression(const char *expr) {
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);
@ -1230,12 +1342,16 @@ SBFrame::EvaluateExpression(const char *expr,
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);
@ -1249,11 +1365,15 @@ SBValue SBFrame::EvaluateExpression(const char *expr,
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
@ -1267,7 +1387,7 @@ lldb::SBValue SBFrame::EvaluateExpression(const char *expr,
if (log)
log->Printf(
"SBFrame::EvaluateExpression called with an empty expression");
return expr_result;
return LLDB_RECORD_RESULT(expr_result);
}
ValueObjectSP expr_value_sp;
@ -1326,14 +1446,18 @@ lldb::SBValue SBFrame::EvaluateExpression(const char *expr,
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);
@ -1364,10 +1488,14 @@ bool SBFrame::IsInlined() const {
}
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);
@ -1379,13 +1507,17 @@ bool SBFrame::IsArtificial() const {
}
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();
@ -1402,6 +1534,8 @@ lldb::LanguageType SBFrame::GuessLanguage() const {
}
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;
@ -1451,6 +1585,8 @@ const char *SBFrame::GetFunctionName() const {
}
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;

67
lldb/source/API/SBFunction.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBFunction.h"
#include "SBReproducerPrivate.h"
#include "lldb/API/SBProcess.h"
#include "lldb/API/SBStream.h"
#include "lldb/Core/Disassembler.h"
@ -22,24 +23,37 @@
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();
@ -57,6 +71,8 @@ const char *SBFunction::GetName() const {
}
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()
@ -76,6 +92,8 @@ const char *SBFunction::GetDisplayName() const {
}
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();
@ -92,14 +110,22 @@ const char *SBFunction::GetMangledName() const {
}
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());
@ -113,11 +139,17 @@ bool SBFunction::GetDescription(SBStream &s) {
}
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;
@ -137,7 +169,7 @@ SBInstructionList SBFunction::GetInstructions(SBTarget target,
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; }
@ -147,13 +179,17 @@ void SBFunction::reset(lldb_private::Function *lldb_object_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();
@ -162,10 +198,13 @@ SBAddress SBFunction::GetEndAddress() {
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);
@ -182,29 +221,37 @@ const char *SBFunction::GetArgumentName(uint32_t arg_idx) {
}
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();
@ -213,6 +260,8 @@ lldb::LanguageType SBFunction::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();

39
lldb/source/API/SBHostOS.cpp
View File

@ -10,6 +10,7 @@
#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"
@ -33,16 +34,25 @@ using namespace lldb;
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:
@ -78,10 +88,13 @@ SBFileSpec SBHostOS::GetLLDBPath(lldb::PathType path_type) {
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;
@ -90,7 +103,7 @@ SBFileSpec SBHostOS::GetUserHomeDirectory() {
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,
@ -113,9 +126,16 @@ 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();
@ -126,6 +146,10 @@ bool SBHostOS::ThreadCancel(lldb::thread_t thread, SBError *error_ptr) {
}
bool SBHostOS::ThreadDetach(lldb::thread_t thread, SBError *error_ptr) {
LLDB_RECORD_STATIC_METHOD(bool, SBHostOS, ThreadDetach,
(lldb::thread_t, lldb::SBError *), thread,
error_ptr);
Status error;
#if defined(_WIN32)
if (error_ptr)
@ -142,6 +166,11 @@ bool SBHostOS::ThreadDetach(lldb::thread_t thread, SBError *error_ptr) {
bool SBHostOS::ThreadJoin(lldb::thread_t thread, lldb::thread_result_t *result,
SBError *error_ptr) {
LLDB_RECORD_STATIC_METHOD(
bool, SBHostOS, ThreadJoin,
(lldb::thread_t, lldb::thread_result_t *, lldb::SBError *), thread,
result, error_ptr);
Status error;
HostThread host_thread(thread);
error = host_thread.Join(result);

62
lldb/source/API/SBInstruction.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBInstruction.h"
#include "SBReproducerPrivate.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBFrame.h"
@ -66,16 +67,24 @@ protected:
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;
@ -83,17 +92,26 @@ const SBInstruction &SBInstruction::operator=(const SBInstruction &rhs) {
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;
@ -111,6 +129,9 @@ const char *SBInstruction::GetMnemonic(SBTarget target) {
}
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;
@ -128,6 +149,9 @@ const char *SBInstruction::GetOperands(SBTarget target) {
}
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;
@ -145,6 +169,8 @@ const char *SBInstruction::GetComment(SBTarget target) {
}
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();
@ -152,6 +178,9 @@ size_t SBInstruction::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) {
@ -160,10 +189,12 @@ SBData SBInstruction::GetData(SBTarget target) {
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();
@ -171,13 +202,17 @@ bool SBInstruction::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();
@ -197,6 +232,9 @@ void SBInstruction::SetOpaque(const lldb::DisassemblerSP &disasm_sp,
}
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;
@ -216,6 +254,8 @@ bool SBInstruction::GetDescription(lldb::SBStream &s) {
}
void SBInstruction::Print(FILE *out) {
LLDB_RECORD_METHOD(void, SBInstruction, Print, (FILE *), out);
if (out == NULL)
return;
@ -236,6 +276,9 @@ void SBInstruction::Print(FILE *out) {
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());
@ -258,6 +301,9 @@ bool SBInstruction::EmulateWithFrame(lldb::SBFrame &frame,
}
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));
@ -267,6 +313,10 @@ bool SBInstruction::DumpEmulation(const char *triple) {
bool SBInstruction::TestEmulation(lldb::SBStream &output_stream,
const char *test_file) {
LLDB_RECORD_METHOD(bool, SBInstruction, TestEmulation,
(lldb::SBStream &, const char *), output_stream,
test_file);
if (!m_opaque_sp)
SetOpaque(lldb::DisassemblerSP(),
lldb::InstructionSP(new PseudoInstruction()));

56
lldb/source/API/SBInstructionList.cpp
View File

@ -7,8 +7,9 @@
//===----------------------------------------------------------------------===//
#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"
@ -18,13 +19,22 @@
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;
@ -32,26 +42,39 @@ operator=(const SBInstructionList &rhs) {
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;
@ -74,20 +97,32 @@ size_t SBInstructionList::GetInstructionsCount(const SBAddress &start,
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);
void SBInstructionList::AppendInstruction(SBInstruction insn) {}
m_opaque_sp.reset();
}
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) {
@ -125,6 +160,9 @@ bool SBInstructionList::GetDescription(lldb::SBStream &description) {
}
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) {

8
lldb/source/API/SBLanguageRuntime.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBLanguageRuntime.h"
#include "SBReproducerPrivate.h"
#include "lldb/Target/Language.h"
using namespace lldb;
@ -14,11 +15,18 @@ using namespace lldb_private;
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);
}

130
lldb/source/API/SBLaunchInfo.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBLaunchInfo.h"
#include "SBReproducerPrivate.h"
#include "lldb/API/SBFileSpec.h"
#include "lldb/API/SBListener.h"
@ -35,6 +36,8 @@ private:
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);
@ -50,46 +53,92 @@ void SBLaunchInfo::set_ref(const ProcessLaunchInfo &info) {
*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);
uint32_t SBLaunchInfo::GetUserID() { return m_opaque_sp->GetUserID(); }
return m_opaque_sp->GetProcessID();
}
uint32_t SBLaunchInfo::GetGroupID() { return m_opaque_sp->GetGroupID(); }
uint32_t SBLaunchInfo::GetUserID() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetUserID);
bool SBLaunchInfo::UserIDIsValid() { return m_opaque_sp->UserIDIsValid(); }
return m_opaque_sp->GetUserID();
}
bool SBLaunchInfo::GroupIDIsValid() { return m_opaque_sp->GroupIDIsValid(); }
uint32_t SBLaunchInfo::GetGroupID() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetGroupID);
void SBLaunchInfo::SetUserID(uint32_t uid) { m_opaque_sp->SetUserID(uid); }
return m_opaque_sp->GetGroupID();
}
void SBLaunchInfo::SetGroupID(uint32_t gid) { m_opaque_sp->SetGroupID(gid); }
bool SBLaunchInfo::UserIDIsValid() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBLaunchInfo, UserIDIsValid);
return m_opaque_sp->UserIDIsValid();
}
bool SBLaunchInfo::GroupIDIsValid() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBLaunchInfo, GroupIDIsValid);
return m_opaque_sp->GroupIDIsValid();
}
void SBLaunchInfo::SetUserID(uint32_t uid) {
LLDB_RECORD_METHOD(void, SBLaunchInfo, SetUserID, (uint32_t), uid);
m_opaque_sp->SetUserID(uid);
}
void SBLaunchInfo::SetGroupID(uint32_t gid) {
LLDB_RECORD_METHOD(void, SBLaunchInfo, SetGroupID, (uint32_t), 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);
@ -102,16 +151,24 @@ void SBLaunchInfo::SetArguments(const char **argv, bool append) {
}
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());
@ -120,33 +177,54 @@ void SBLaunchInfo::SetEnvironmentEntries(const char **envp, bool append) {
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());
@ -154,54 +232,86 @@ const char *SBLaunchInfo::GetShell() {
}
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();
}

53
lldb/source/API/SBLineEntry.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBLineEntry.h"
#include "SBReproducerPrivate.h"
#include "Utils.h"
#include "lldb/API/SBStream.h"
#include "lldb/Host/PosixApi.h"
@ -19,9 +20,13 @@
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);
}
@ -32,6 +37,9 @@ SBLineEntry::SBLineEntry(const lldb_private::LineEntry *lldb_object_ptr)
}
const SBLineEntry &SBLineEntry::operator=(const SBLineEntry &rhs) {
LLDB_RECORD_METHOD(const lldb::SBLineEntry &,
SBLineEntry, operator=,(const lldb::SBLineEntry &), rhs);
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
return *this;
@ -44,6 +52,9 @@ void SBLineEntry::SetLineEntry(const lldb_private::LineEntry &lldb_object_ref) {
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());
@ -60,10 +71,12 @@ SBAddress SBLineEntry::GetStartAddress() const {
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());
@ -80,14 +93,18 @@ SBAddress SBLineEntry::GetEndAddress() const {
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;
@ -102,10 +119,12 @@ SBFileSpec SBLineEntry::GetFileSpec() const {
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;
@ -120,22 +139,38 @@ uint32_t SBLineEntry::GetLine() const {
}
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);
void SBLineEntry::SetColumn(uint32_t column) { ref().line = column; }
ref().line = line;
}
void SBLineEntry::SetColumn(uint32_t column) {
LLDB_RECORD_METHOD(void, SBLineEntry, SetColumn, (uint32_t), column);
ref().line = column;
}
bool SBLineEntry::operator==(const SBLineEntry &rhs) const {
LLDB_RECORD_METHOD_CONST(
bool, SBLineEntry, operator==,(const lldb::SBLineEntry &), rhs);
lldb_private::LineEntry *lhs_ptr = m_opaque_up.get();
lldb_private::LineEntry *rhs_ptr = rhs.m_opaque_up.get();
@ -146,6 +181,9 @@ bool SBLineEntry::operator==(const SBLineEntry &rhs) const {
}
bool SBLineEntry::operator!=(const SBLineEntry &rhs) const {
LLDB_RECORD_METHOD_CONST(
bool, SBLineEntry, operator!=,(const lldb::SBLineEntry &), rhs);
lldb_private::LineEntry *lhs_ptr = m_opaque_up.get();
lldb_private::LineEntry *rhs_ptr = rhs.m_opaque_up.get();
@ -168,6 +206,9 @@ lldb_private::LineEntry &SBLineEntry::ref() {
const lldb_private::LineEntry &SBLineEntry::ref() const { return *m_opaque_up; }
bool SBLineEntry::GetDescription(SBStream &description) {
LLDB_RECORD_METHOD(bool, SBLineEntry, GetDescription, (lldb::SBStream &),
description);
Stream &strm = description.ref();
if (m_opaque_up) {

77
lldb/source/API/SBListener.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBListener.h"
#include "SBReproducerPrivate.h"
#include "lldb/API/SBBroadcaster.h"
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBEvent.h"
@ -20,10 +21,14 @@
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)
@ -32,9 +37,14 @@ SBListener::SBListener(const char *name)
}
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;
@ -47,15 +57,24 @@ SBListener::SBListener(const lldb::ListenerSP &listener_sp)
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();
}
@ -63,6 +82,10 @@ void SBListener::Clear() {
uint32_t SBListener::StartListeningForEventClass(SBDebugger &debugger,
const char *broadcaster_class,
uint32_t event_mask) {
LLDB_RECORD_METHOD(uint32_t, SBListener, StartListeningForEventClass,
(lldb::SBDebugger &, const char *, uint32_t), debugger,
broadcaster_class, event_mask);
if (m_opaque_sp) {
Debugger *lldb_debugger = debugger.get();
if (!lldb_debugger)
@ -77,6 +100,10 @@ uint32_t SBListener::StartListeningForEventClass(SBDebugger &debugger,
bool SBListener::StopListeningForEventClass(SBDebugger &debugger,
const char *broadcaster_class,
uint32_t event_mask) {
LLDB_RECORD_METHOD(bool, SBListener, StopListeningForEventClass,
(lldb::SBDebugger &, const char *, uint32_t), debugger,
broadcaster_class, event_mask);
if (m_opaque_sp) {
Debugger *lldb_debugger = debugger.get();
if (!lldb_debugger)
@ -90,6 +117,10 @@ bool SBListener::StopListeningForEventClass(SBDebugger &debugger,
uint32_t SBListener::StartListeningForEvents(const SBBroadcaster &broadcaster,
uint32_t event_mask) {
LLDB_RECORD_METHOD(uint32_t, SBListener, StartListeningForEvents,
(const lldb::SBBroadcaster &, uint32_t), broadcaster,
event_mask);
uint32_t acquired_event_mask = 0;
if (m_opaque_sp && broadcaster.IsValid()) {
acquired_event_mask =
@ -131,6 +162,10 @@ uint32_t SBListener::StartListeningForEvents(const SBBroadcaster &broadcaster,
bool SBListener::StopListeningForEvents(const SBBroadcaster &broadcaster,
uint32_t event_mask) {
LLDB_RECORD_METHOD(bool, SBListener, StopListeningForEvents,
(const lldb::SBBroadcaster &, uint32_t), broadcaster,
event_mask);
if (m_opaque_sp && broadcaster.IsValid()) {
return m_opaque_sp->StopListeningForEvents(broadcaster.get(), event_mask);
}
@ -138,6 +173,9 @@ bool SBListener::StopListeningForEvents(const SBBroadcaster &broadcaster,
}
bool SBListener::WaitForEvent(uint32_t timeout_secs, SBEvent &event) {
LLDB_RECORD_METHOD(bool, SBListener, WaitForEvent,
(uint32_t, lldb::SBEvent &), timeout_secs, event);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log) {
if (timeout_secs == UINT32_MAX) {
@ -189,6 +227,10 @@ bool SBListener::WaitForEvent(uint32_t timeout_secs, SBEvent &event) {
bool SBListener::WaitForEventForBroadcaster(uint32_t num_seconds,
const SBBroadcaster &broadcaster,
SBEvent &event) {
LLDB_RECORD_METHOD(bool, SBListener, WaitForEventForBroadcaster,
(uint32_t, const lldb::SBBroadcaster &, lldb::SBEvent &),
num_seconds, broadcaster, event);
if (m_opaque_sp && broadcaster.IsValid()) {
Timeout<std::micro> timeout(llvm::None);
if (num_seconds != UINT32_MAX)
@ -207,6 +249,11 @@ bool SBListener::WaitForEventForBroadcaster(uint32_t num_seconds,
bool SBListener::WaitForEventForBroadcasterWithType(
uint32_t num_seconds, const SBBroadcaster &broadcaster,
uint32_t event_type_mask, SBEvent &event) {
LLDB_RECORD_METHOD(
bool, SBListener, WaitForEventForBroadcasterWithType,
(uint32_t, const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &),
num_seconds, broadcaster, event_type_mask, event);
if (m_opaque_sp && broadcaster.IsValid()) {
Timeout<std::micro> timeout(llvm::None);
if (num_seconds != UINT32_MAX)
@ -223,6 +270,9 @@ bool SBListener::WaitForEventForBroadcasterWithType(
}
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();
@ -233,6 +283,10 @@ bool SBListener::PeekAtNextEvent(SBEvent &event) {
bool SBListener::PeekAtNextEventForBroadcaster(const SBBroadcaster &broadcaster,
SBEvent &event) {
LLDB_RECORD_METHOD(bool, SBListener, PeekAtNextEventForBroadcaster,
(const lldb::SBBroadcaster &, lldb::SBEvent &),
broadcaster, event);
if (m_opaque_sp && broadcaster.IsValid()) {
event.reset(m_opaque_sp->PeekAtNextEventForBroadcaster(broadcaster.get()));
return event.IsValid();
@ -244,6 +298,10 @@ bool SBListener::PeekAtNextEventForBroadcaster(const SBBroadcaster &broadcaster,
bool SBListener::PeekAtNextEventForBroadcasterWithType(
const SBBroadcaster &broadcaster, uint32_t event_type_mask,
SBEvent &event) {
LLDB_RECORD_METHOD(bool, SBListener, PeekAtNextEventForBroadcasterWithType,
(const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &),
broadcaster, event_type_mask, event);
if (m_opaque_sp && broadcaster.IsValid()) {
event.reset(m_opaque_sp->PeekAtNextEventForBroadcasterWithType(
broadcaster.get(), event_type_mask));
@ -254,6 +312,8 @@ bool SBListener::PeekAtNextEventForBroadcasterWithType(
}
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))) {
@ -267,6 +327,10 @@ bool SBListener::GetNextEvent(SBEvent &event) {
bool SBListener::GetNextEventForBroadcaster(const SBBroadcaster &broadcaster,
SBEvent &event) {
LLDB_RECORD_METHOD(bool, SBListener, GetNextEventForBroadcaster,
(const lldb::SBBroadcaster &, lldb::SBEvent &),
broadcaster, event);
if (m_opaque_sp && broadcaster.IsValid()) {
EventSP event_sp;
if (m_opaque_sp->GetEventForBroadcaster(broadcaster.get(), event_sp,
@ -282,6 +346,10 @@ bool SBListener::GetNextEventForBroadcaster(const SBBroadcaster &broadcaster,
bool SBListener::GetNextEventForBroadcasterWithType(
const SBBroadcaster &broadcaster, uint32_t event_type_mask,
SBEvent &event) {
LLDB_RECORD_METHOD(bool, SBListener, GetNextEventForBroadcasterWithType,
(const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &),
broadcaster, event_type_mask, event);
if (m_opaque_sp && broadcaster.IsValid()) {
EventSP event_sp;
if (m_opaque_sp->GetEventForBroadcasterWithType(broadcaster.get(),
@ -296,6 +364,9 @@ bool SBListener::GetNextEventForBroadcasterWithType(
}
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;

43
lldb/source/API/SBMemoryRegionInfo.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBMemoryRegionInfo.h"
#include "SBReproducerPrivate.h"
#include "Utils.h"
#include "lldb/API/SBDefines.h"
#include "lldb/API/SBError.h"
@ -17,8 +18,9 @@
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()) {
@ -28,11 +30,17 @@ SBMemoryRegionInfo::SBMemoryRegionInfo(const MemoryRegionInfo *lldb_object_ptr)
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;
@ -40,13 +48,25 @@ operator=(const SBMemoryRegionInfo &rhs) {
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();
}
@ -55,34 +75,51 @@ MemoryRegionInfo &SBMemoryRegionInfo::ref() { return *m_opaque_up; }
const MemoryRegionInfo &SBMemoryRegionInfo::ref() const { return *m_opaque_up; }
lldb::addr_t SBMemoryRegionInfo::GetRegionBase() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBMemoryRegionInfo, GetRegionBase);
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;

32
lldb/source/API/SBMemoryRegionInfoList.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBMemoryRegionInfoList.h"
#include "SBReproducerPrivate.h"
#include "lldb/API/SBMemoryRegionInfo.h"
#include "lldb/API/SBStream.h"
#include "lldb/Target/MemoryRegionInfo.h"
@ -71,16 +72,26 @@ const MemoryRegionInfos &SBMemoryRegionInfoList::ref() const {
}
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;
}
@ -88,11 +99,16 @@ operator=(const SBMemoryRegionInfoList &rhs) {
}
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 &region_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());
@ -110,13 +126,23 @@ bool SBMemoryRegionInfoList::GetMemoryRegionAtIndex(
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);
}

191
lldb/source/API/SBModule.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBModule.h"
#include "SBReproducerPrivate.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBFileSpec.h"
#include "lldb/API/SBModuleSpec.h"
@ -30,11 +31,15 @@
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);
@ -42,10 +47,15 @@ SBModule::SBModule(const SBModuleSpec &module_spec) : m_opaque_sp() {
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);
@ -59,6 +69,9 @@ SBModule::SBModule(lldb::SBProcess &process, lldb::addr_t header_addr)
}
const SBModule &SBModule::operator=(const SBModule &rhs) {
LLDB_RECORD_METHOD(const lldb::SBModule &,
SBModule, operator=,(const lldb::SBModule &), rhs);
if (this != &rhs)
m_opaque_sp = rhs.m_opaque_sp;
return *this;
@ -66,11 +79,21 @@ const SBModule &SBModule::operator=(const SBModule &rhs) {
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);
void SBModule::Clear() { m_opaque_sp.reset(); }
return m_opaque_sp.get() != NULL;
}
void SBModule::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBModule, Clear);
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;
@ -83,10 +106,13 @@ SBFileSpec SBModule::GetFileSpec() const {
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;
@ -99,10 +125,13 @@ lldb::SBFileSpec SBModule::GetPlatformFileSpec() const {
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));
@ -121,14 +150,20 @@ bool SBModule::SetPlatformFileSpec(const lldb::SBFileSpec &platform_file) {
}
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());
@ -138,6 +173,8 @@ bool SBModule::SetRemoteInstallFileSpec(lldb::SBFileSpec &file) {
}
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;
@ -159,6 +196,8 @@ const uint8_t *SBModule::GetUUIDBytes() const {
}
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;
@ -185,12 +224,18 @@ const char *SBModule::GetUUIDString() const {
}
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;
@ -201,6 +246,9 @@ ModuleSP SBModule::GetSP() const { return m_opaque_sp; }
void SBModule::SetSP(const ModuleSP &module_sp) { m_opaque_sp = module_sp; }
SBAddress SBModule::ResolveFileAddress(lldb::addr_t vm_addr) {
LLDB_RECORD_METHOD(lldb::SBAddress, SBModule, ResolveFileAddress,
(lldb::addr_t), vm_addr);
lldb::SBAddress sb_addr;
ModuleSP module_sp(GetSP());
if (module_sp) {
@ -208,21 +256,28 @@ SBAddress SBModule::ResolveFileAddress(lldb::addr_t vm_addr) {
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());
@ -235,6 +290,8 @@ bool SBModule::GetDescription(SBStream &description) {
}
uint32_t SBModule::GetNumCompileUnits() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBModule, GetNumCompileUnits);
ModuleSP module_sp(GetSP());
if (module_sp) {
return module_sp->GetNumCompileUnits();
@ -243,24 +300,29 @@ uint32_t SBModule::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) {
@ -273,6 +335,8 @@ 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);
@ -283,16 +347,21 @@ size_t SBModule::GetNumSymbols() {
}
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());
@ -302,11 +371,14 @@ lldb::SBSymbol SBModule::FindSymbol(const char *name,
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());
@ -327,10 +399,12 @@ lldb::SBSymbolContextList SBModule::FindSymbols(const char *name,
}
}
}
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.
@ -343,6 +417,9 @@ size_t SBModule::GetNumSections() {
}
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) {
@ -353,11 +430,14 @@ SBSection SBModule::GetSectionAtIndex(size_t idx) {
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) {
@ -368,11 +448,15 @@ lldb::SBSymbolContextList SBModule::FindFunctions(const char *name,
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) {
@ -392,18 +476,24 @@ SBValueList SBModule::FindGlobalVariables(SBTarget &target, const char *name,
}
}
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) {
@ -420,21 +510,27 @@ lldb::SBType SBModule::FindFirstType(const char *name_cstr) {
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());
@ -463,40 +559,49 @@ lldb::SBTypeList SBModule::FindTypes(const char *type) {
}
}
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());
@ -512,10 +617,12 @@ SBSection SBModule::FindSection(const char *sect_name) {
}
}
}
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();
@ -523,6 +630,8 @@ lldb::ByteOrder SBModule::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());
@ -536,6 +645,8 @@ const char *SBModule::GetTriple() {
}
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();
@ -543,6 +654,9 @@ uint32_t SBModule::GetAddressByteSize() {
}
uint32_t SBModule::GetVersion(uint32_t *versions, uint32_t num_versions) {
LLDB_RECORD_METHOD(uint32_t, SBModule, GetVersion, (uint32_t *, uint32_t),
versions, num_versions);
llvm::VersionTuple version;
if (ModuleSP module_sp = GetSP())
version = module_sp->GetVersion();
@ -569,6 +683,9 @@ uint32_t SBModule::GetVersion(uint32_t *versions, uint32_t num_versions) {
}
lldb::SBFileSpec SBModule::GetSymbolFileSpec() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule,
GetSymbolFileSpec);
lldb::SBFileSpec sb_file_spec;
ModuleSP module_sp(GetSP());
if (module_sp) {
@ -576,10 +693,13 @@ lldb::SBFileSpec SBModule::GetSymbolFileSpec() const {
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) {
@ -587,10 +707,13 @@ lldb::SBAddress SBModule::GetObjectFileHeaderAddress() const {
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) {
@ -598,5 +721,5 @@ lldb::SBAddress SBModule::GetObjectFileEntryPointAddress() const {
if (objfile_ptr)
sb_addr.ref() = objfile_ptr->GetEntryPointAddress();
}
return sb_addr;
return LLDB_RECORD_RESULT(sb_addr);
}

107
lldb/source/API/SBModuleSpec.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBModuleSpec.h"
#include "SBReproducerPrivate.h"
#include "Utils.h"
#include "lldb/API/SBStream.h"
#include "lldb/Core/Module.h"
@ -18,13 +19,20 @@
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;
@ -32,44 +40,74 @@ const SBModuleSpec &SBModuleSpec::operator=(const SBModuleSpec &rhs) {
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);
void SBModuleSpec::Clear() { m_opaque_up->Clear(); }
return m_opaque_up->operator bool();
}
void SBModuleSpec::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBModuleSpec, 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
@ -79,6 +117,8 @@ const char *SBModuleSpec::GetTriple() {
}
void SBModuleSpec::SetTriple(const char *triple) {
LLDB_RECORD_METHOD(void, SBModuleSpec, SetTriple, (const char *), triple);
m_opaque_up->GetArchitecture().SetTriple(triple);
}
@ -87,6 +127,8 @@ const uint8_t *SBModuleSpec::GetUUIDBytes() {
}
size_t SBModuleSpec::GetUUIDLength() {
LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModuleSpec, GetUUIDLength);
return m_opaque_up->GetUUID().GetBytes().size();
}
@ -96,16 +138,28 @@ bool SBModuleSpec::SetUUIDBytes(const uint8_t *uuid, size_t uuid_len) {
}
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;
@ -114,47 +168,74 @@ SBModuleSpecList &SBModuleSpecList::operator=(const SBModuleSpecList &rhs) {
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;
}

234
lldb/source/API/SBPlatform.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBPlatform.h"
#include "SBReproducerPrivate.h"
#include "lldb/API/SBError.h"
#include "lldb/API/SBFileSpec.h"
#include "lldb/API/SBLaunchInfo.h"
@ -70,27 +71,43 @@ struct PlatformShellCommand {
// 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
@ -98,12 +115,18 @@ void SBPlatformConnectOptions::SetURL(const char *url) {
}
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;
@ -119,14 +142,22 @@ void SBPlatformConnectOptions::EnableRsync(
}
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
@ -137,29 +168,42 @@ void SBPlatformConnectOptions::SetLocalCacheDirectory(const char *path) {
// 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
@ -167,12 +211,18 @@ void SBPlatformShellCommand::SetCommand(const char *shell_command) {
}
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
@ -180,23 +230,39 @@ void SBPlatformShellCommand::SetWorkingDirectory(const char *path) {
}
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);
int SBPlatformShellCommand::GetStatus() { return m_opaque_ptr->m_status; }
return m_opaque_ptr->m_signo;
}
int SBPlatformShellCommand::GetStatus() {
LLDB_RECORD_METHOD_NO_ARGS(int, SBPlatformShellCommand, GetStatus);
return m_opaque_ptr->m_status;
}
const char *SBPlatformShellCommand::GetOutput() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand, GetOutput);
if (m_opaque_ptr->m_output.empty())
return NULL;
return m_opaque_ptr->m_output.c_str();
@ -205,9 +271,13 @@ const char *SBPlatformShellCommand::GetOutput() {
//----------------------------------------------------------------------
// 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);
@ -215,11 +285,21 @@ SBPlatform::SBPlatform(const char *platform_name) : m_opaque_sp() {
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);
void SBPlatform::Clear() { m_opaque_sp.reset(); }
return m_opaque_sp.get() != NULL;
}
void SBPlatform::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatform, Clear);
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();
@ -233,6 +313,8 @@ void SBPlatform::SetSP(const lldb::PlatformSP &platform_sp) {
}
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();
@ -240,6 +322,9 @@ const char *SBPlatform::GetWorkingDirectory() {
}
bool SBPlatform::SetWorkingDirectory(const char *path) {
LLDB_RECORD_METHOD(bool, SBPlatform, SetWorkingDirectory, (const char *),
path);
PlatformSP platform_sp(GetSP());
if (platform_sp) {
if (path)
@ -252,6 +337,9 @@ bool SBPlatform::SetWorkingDirectory(const char *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()) {
@ -262,16 +350,20 @@ SBError SBPlatform::ConnectRemote(SBPlatformConnectOptions &connect_options) {
} 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();
@ -279,6 +371,8 @@ bool SBPlatform::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());
@ -292,6 +386,8 @@ const char *SBPlatform::GetTriple() {
}
const char *SBPlatform::GetOSBuild() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetOSBuild);
PlatformSP platform_sp(GetSP());
if (platform_sp) {
std::string s;
@ -307,6 +403,8 @@ const char *SBPlatform::GetOSBuild() {
}
const char *SBPlatform::GetOSDescription() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetOSDescription);
PlatformSP platform_sp(GetSP());
if (platform_sp) {
std::string s;
@ -322,6 +420,8 @@ const char *SBPlatform::GetOSDescription() {
}
const char *SBPlatform::GetHostname() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetHostname);
PlatformSP platform_sp(GetSP());
if (platform_sp)
return platform_sp->GetHostname();
@ -329,6 +429,8 @@ const char *SBPlatform::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();
@ -336,6 +438,8 @@ uint32_t SBPlatform::GetOSMajorVersion() {
}
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();
@ -343,6 +447,8 @@ uint32_t SBPlatform::GetOSMinorVersion() {
}
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();
@ -350,6 +456,9 @@ uint32_t SBPlatform::GetOSUpdateVersion() {
}
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) {
@ -357,44 +466,54 @@ SBError SBPlatform::Get(SBFileSpec &src, SBFileSpec &dst) {
} 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;
}
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);
}
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;
});
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)");
@ -410,22 +529,27 @@ SBError SBPlatform::Run(SBPlatformShellCommand &shell_command) {
&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(
@ -444,6 +568,9 @@ 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) {
@ -452,10 +579,13 @@ SBError SBPlatform::MakeDirectory(const char *path, uint32_t file_permissions) {
} 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;
@ -467,6 +597,9 @@ uint32_t SBPlatform::GetFilePermissions(const char *path) {
SBError SBPlatform::SetFilePermissions(const char *path,
uint32_t file_permissions) {
LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, SetFilePermissions,
(const char *, uint32_t), path, file_permissions);
SBError sb_error;
PlatformSP platform_sp(GetSP());
if (platform_sp) {
@ -475,12 +608,15 @@ SBError SBPlatform::SetFilePermissions(const char *path,
} else {
sb_error.SetErrorString("invalid platform");
}
return sb_error;
return LLDB_RECORD_RESULT(sb_error);
}
SBUnixSignals SBPlatform::GetUnixSignals() const {
if (auto platform_sp = GetSP())
return SBUnixSignals{platform_sp};
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBUnixSignals, SBPlatform,
GetUnixSignals);
return {};
if (auto platform_sp = GetSP())
return LLDB_RECORD_RESULT(SBUnixSignals{platform_sp});
return LLDB_RECORD_RESULT(SBUnixSignals());
}

289
lldb/source/API/SBProcess.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBProcess.h"
#include "SBReproducerPrivate.h"
#include <inttypes.h>
@ -49,18 +50,27 @@
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;
@ -72,10 +82,15 @@ const SBProcess &SBProcess::operator=(const SBProcess &rhs) {
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();
@ -84,6 +99,8 @@ const char *SBProcess::GetPluginName() {
}
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();
@ -95,9 +112,15 @@ lldb::ProcessSP SBProcess::GetSP() const { return m_opaque_wp.lock(); }
void SBProcess::SetSP(const ProcessSP &process_sp) { m_opaque_wp = process_sp; }
void SBProcess::Clear() { 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());
}
@ -108,6 +131,13 @@ bool SBProcess::RemoteLaunch(char const **argv, char const **envp,
const char *working_directory,
uint32_t launch_flags, bool stop_at_entry,
lldb::SBError &error) {
LLDB_RECORD_METHOD(bool, SBProcess, RemoteLaunch,
(const char **, const char **, const char *, const char *,
const char *, const char *, uint32_t, bool,
lldb::SBError &),
argv, envp, stdin_path, stdout_path, stderr_path,
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, "
@ -159,6 +189,9 @@ bool SBProcess::RemoteLaunch(char const **argv, char const **envp,
bool SBProcess::RemoteAttachToProcessWithID(lldb::pid_t pid,
lldb::SBError &error) {
LLDB_RECORD_METHOD(bool, SBProcess, RemoteAttachToProcessWithID,
(lldb::pid_t, lldb::SBError &), pid, error);
ProcessSP process_sp(GetSP());
if (process_sp) {
std::lock_guard<std::recursive_mutex> guard(
@ -189,6 +222,8 @@ bool SBProcess::RemoteAttachToProcessWithID(lldb::pid_t pid,
}
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;
@ -210,6 +245,9 @@ uint32_t SBProcess::GetNumThreads() {
}
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;
@ -227,11 +265,14 @@ SBThread SBProcess::GetSelectedThread() const {
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;
@ -250,10 +291,12 @@ SBThread SBProcess::CreateOSPluginThread(lldb::tid_t tid,
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;
@ -269,10 +312,13 @@ SBTarget SBProcess::GetTarget() const {
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;
@ -292,6 +338,9 @@ size_t SBProcess::PutSTDIN(const char *src, size_t src_len) {
}
size_t SBProcess::GetSTDOUT(char *dst, size_t dst_len) const {
LLDB_RECORD_METHOD_CONST(size_t, SBProcess, GetSTDOUT, (char *, size_t), dst,
dst_len);
size_t bytes_read = 0;
ProcessSP process_sp(GetSP());
if (process_sp) {
@ -311,6 +360,9 @@ size_t SBProcess::GetSTDOUT(char *dst, size_t dst_len) const {
}
size_t SBProcess::GetSTDERR(char *dst, size_t dst_len) const {
LLDB_RECORD_METHOD_CONST(size_t, SBProcess, GetSTDERR, (char *, size_t), dst,
dst_len);
size_t bytes_read = 0;
ProcessSP process_sp(GetSP());
if (process_sp) {
@ -330,6 +382,9 @@ size_t SBProcess::GetSTDERR(char *dst, size_t dst_len) const {
}
size_t SBProcess::GetAsyncProfileData(char *dst, size_t dst_len) const {
LLDB_RECORD_METHOD_CONST(size_t, SBProcess, GetAsyncProfileData,
(char *, size_t), dst, dst_len);
size_t bytes_read = 0;
ProcessSP process_sp(GetSP());
if (process_sp) {
@ -350,6 +405,9 @@ size_t SBProcess::GetAsyncProfileData(char *dst, size_t dst_len) const {
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();
@ -364,10 +422,13 @@ lldb::SBTrace SBProcess::StartTrace(SBTraceOptions &options,
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;
@ -386,6 +447,10 @@ void SBProcess::ReportEventState(const SBEvent &event, FILE *out) const {
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);
@ -398,6 +463,9 @@ void SBProcess::AppendEventStateReport(const SBEvent &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(
@ -409,6 +477,9 @@ bool SBProcess::SetSelectedThread(const SBThread &thread) {
}
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;
@ -429,6 +500,9 @@ bool SBProcess::SetSelectedThreadByID(lldb::tid_t tid) {
}
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;
@ -448,6 +522,9 @@ bool SBProcess::SetSelectedThreadByIndexID(uint32_t index_id) {
}
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;
@ -468,10 +545,12 @@ SBThread SBProcess::GetThreadAtIndex(size_t index) {
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;
@ -493,6 +572,9 @@ uint32_t SBProcess::GetNumQueues() {
}
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;
@ -514,10 +596,13 @@ SBQueue SBProcess::GetQueueAtIndex(size_t index) {
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(
@ -531,6 +616,9 @@ uint32_t SBProcess::GetStopID(bool include_expression_stops) {
}
SBEvent SBProcess::GetStopEventForStopID(uint32_t stop_id) {
LLDB_RECORD_METHOD(lldb::SBEvent, SBProcess, GetStopEventForStopID,
(uint32_t), stop_id);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBEvent sb_event;
@ -549,10 +637,11 @@ SBEvent SBProcess::GetStopEventForStopID(uint32_t stop_id) {
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());
@ -572,6 +661,8 @@ StateType SBProcess::GetState() {
}
int SBProcess::GetExitStatus() {
LLDB_RECORD_METHOD_NO_ARGS(int, SBProcess, GetExitStatus);
int exit_status = 0;
ProcessSP process_sp(GetSP());
if (process_sp) {
@ -589,6 +680,8 @@ int SBProcess::GetExitStatus() {
}
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) {
@ -604,6 +697,8 @@ const char *SBProcess::GetExitDescription() {
}
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)
@ -618,6 +713,8 @@ lldb::pid_t SBProcess::GetProcessID() {
}
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)
@ -630,6 +727,8 @@ uint32_t SBProcess::GetUniqueID() {
}
ByteOrder SBProcess::GetByteOrder() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ByteOrder, SBProcess, GetByteOrder);
ByteOrder byteOrder = eByteOrderInvalid;
ProcessSP process_sp(GetSP());
if (process_sp)
@ -644,6 +743,8 @@ ByteOrder SBProcess::GetByteOrder() const {
}
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)
@ -658,6 +759,8 @@ uint32_t SBProcess::GetAddressByteSize() const {
}
SBError SBProcess::Continue() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Continue);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBError sb_error;
@ -686,10 +789,12 @@ SBError SBProcess::Continue() {
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) {
@ -708,10 +813,12 @@ SBError SBProcess::Destroy() {
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) {
@ -730,10 +837,12 @@ SBError SBProcess::Stop() {
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) {
@ -752,16 +861,20 @@ SBError SBProcess::Kill() {
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) {
@ -771,10 +884,12 @@ SBError SBProcess::Detach(bool keep_stopped) {
} 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) {
@ -791,17 +906,21 @@ SBError SBProcess::Signal(int signo) {
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() {
if (auto process_sp = GetSP())
return SBUnixSignals{process_sp};
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBUnixSignals, SBProcess, GetUnixSignals);
return {};
if (auto process_sp = GetSP())
return LLDB_RECORD_RESULT(SBUnixSignals{process_sp});
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();
@ -809,6 +928,9 @@ void SBProcess::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());
@ -828,10 +950,13 @@ SBThread SBProcess::GetThreadByID(tid_t tid) {
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());
@ -851,10 +976,13 @@ SBThread SBProcess::GetThreadByIndexID(uint32_t index_id) {
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());
@ -868,6 +996,9 @@ StateType SBProcess::GetStateFromEvent(const SBEvent &event) {
}
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());
@ -880,16 +1011,26 @@ bool SBProcess::GetRestartedFromEvent(const SBEvent &event) {
}
size_t SBProcess::GetNumRestartedReasonsFromEvent(const lldb::SBEvent &event) {
LLDB_RECORD_STATIC_METHOD(size_t, SBProcess, GetNumRestartedReasonsFromEvent,
(const lldb::SBEvent &), event);
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) {
@ -897,24 +1038,37 @@ SBProcess SBProcess::GetProcessFromEvent(const SBEvent &event) {
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() ==
@ -922,6 +1076,9 @@ bool SBProcess::EventIsStructuredDataEvent(const lldb::SBEvent &event) {
}
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());
@ -933,10 +1090,13 @@ SBBroadcaster SBProcess::GetBroadcaster() const {
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();
}
@ -1012,6 +1172,10 @@ size_t SBProcess::ReadCStringFromMemory(addr_t addr, void *buf, size_t size,
uint64_t SBProcess::ReadUnsignedFromMemory(addr_t addr, uint32_t byte_size,
lldb::SBError &sb_error) {
LLDB_RECORD_METHOD(uint64_t, SBProcess, ReadUnsignedFromMemory,
(lldb::addr_t, uint32_t, lldb::SBError &), addr, byte_size,
sb_error);
uint64_t value = 0;
ProcessSP process_sp(GetSP());
if (process_sp) {
@ -1037,6 +1201,9 @@ uint64_t SBProcess::ReadUnsignedFromMemory(addr_t addr, uint32_t byte_size,
lldb::addr_t SBProcess::ReadPointerFromMemory(addr_t addr,
lldb::SBError &sb_error) {
LLDB_RECORD_METHOD(lldb::addr_t, SBProcess, ReadPointerFromMemory,
(lldb::addr_t, lldb::SBError &), addr, sb_error);
lldb::addr_t ptr = LLDB_INVALID_ADDRESS;
ProcessSP process_sp(GetSP());
if (process_sp) {
@ -1104,6 +1271,9 @@ size_t SBProcess::WriteMemory(addr_t addr, const void *src, size_t src_len,
}
bool SBProcess::GetDescription(SBStream &description) {
LLDB_RECORD_METHOD(bool, SBProcess, GetDescription, (lldb::SBStream &),
description);
Stream &strm = description.ref();
ProcessSP process_sp(GetSP());
@ -1127,6 +1297,10 @@ bool SBProcess::GetDescription(SBStream &description) {
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;
@ -1146,12 +1320,21 @@ SBProcess::GetNumSupportedHardwareWatchpoints(lldb::SBError &sb_error) const {
uint32_t SBProcess::LoadImage(lldb::SBFileSpec &sb_remote_image_spec,
lldb::SBError &sb_error) {
LLDB_RECORD_METHOD(uint32_t, SBProcess, LoadImage,
(lldb::SBFileSpec &, lldb::SBError &),
sb_remote_image_spec, sb_error);
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) {
@ -1186,8 +1369,13 @@ uint32_t SBProcess::LoadImage(const lldb::SBFileSpec &sb_local_image_spec,
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) {
@ -1236,6 +1424,9 @@ uint32_t SBProcess::LoadImageUsingPaths(const lldb::SBFileSpec &image_spec,
}
lldb::SBError SBProcess::UnloadImage(uint32_t image_token) {
LLDB_RECORD_METHOD(lldb::SBError, SBProcess, UnloadImage, (uint32_t),
image_token);
lldb::SBError sb_error;
ProcessSP process_sp(GetSP());
if (process_sp) {
@ -1255,10 +1446,13 @@ lldb::SBError SBProcess::UnloadImage(uint32_t image_token) {
}
} 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) {
@ -1277,10 +1471,12 @@ lldb::SBError SBProcess::SendEventData(const char *event_data) {
}
} 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();
@ -1290,6 +1486,9 @@ uint32_t SBProcess::GetNumExtendedBacktraceTypes() {
}
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();
@ -1309,16 +1508,22 @@ const char *SBProcess::GetExtendedBacktraceTypeAtIndex(uint32_t idx) {
}
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;
@ -1333,11 +1538,14 @@ bool SBProcess::IsInstrumentationRuntimePresent(
}
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(
@ -1345,17 +1553,21 @@ lldb::SBError SBProcess::SaveCore(const char *file_name) {
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) {
@ -1377,10 +1589,13 @@ SBProcess::GetMemoryRegionInfo(lldb::addr_t load_addr,
} 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());
@ -1398,15 +1613,17 @@ lldb::SBMemoryRegionInfoList SBProcess::GetMemoryRegions() {
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);
}

44
lldb/source/API/SBProcessInfo.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBProcessInfo.h"
#include "SBReproducerPrivate.h"
#include "Utils.h"
#include "lldb/API/SBFileSpec.h"
#include "lldb/Utility/ProcessInfo.h"
@ -14,15 +15,23 @@
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;
@ -39,9 +48,15 @@ void SBProcessInfo::SetProcessInfo(const ProcessInstanceInfo &proc_info_ref) {
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();
@ -50,14 +65,19 @@ const char *SBProcessInfo::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();
@ -66,6 +86,8 @@ lldb::pid_t SBProcessInfo::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();
@ -74,6 +96,8 @@ uint32_t SBProcessInfo::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();
@ -82,6 +106,8 @@ uint32_t SBProcessInfo::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();
@ -90,6 +116,8 @@ bool SBProcessInfo::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();
@ -98,6 +126,8 @@ bool SBProcessInfo::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();
@ -106,6 +136,8 @@ uint32_t SBProcessInfo::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();
@ -114,6 +146,8 @@ uint32_t SBProcessInfo::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();
@ -122,6 +156,8 @@ bool SBProcessInfo::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();
@ -130,6 +166,8 @@ bool SBProcessInfo::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();

52
lldb/source/API/SBQueue.cpp
View File

@ -8,6 +8,7 @@
#include <inttypes.h>
#include "SBReproducerPrivate.h"
#include "lldb/API/SBQueue.h"
#include "lldb/API/SBProcess.h"
@ -231,12 +232,18 @@ private:
};
}
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;
@ -244,6 +251,9 @@ SBQueue::SBQueue(const SBQueue &rhs) {
}
const lldb::SBQueue &SBQueue::operator=(const lldb::SBQueue &rhs) {
LLDB_RECORD_METHOD(const lldb::SBQueue &,
SBQueue, operator=,(const lldb::SBQueue &), rhs);
m_opaque_sp = rhs.m_opaque_sp;
return *this;
}
@ -251,6 +261,8 @@ const lldb::SBQueue &SBQueue::operator=(const lldb::SBQueue &rhs) {
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)
@ -260,6 +272,8 @@ bool SBQueue::IsValid() const {
}
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());
@ -271,6 +285,8 @@ void SBQueue::SetQueue(const QueueSP &queue_sp) {
}
lldb::queue_id_t SBQueue::GetQueueID() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::queue_id_t, SBQueue, GetQueueID);
lldb::queue_id_t qid = m_opaque_sp->GetQueueID();
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
@ -280,6 +296,8 @@ lldb::queue_id_t SBQueue::GetQueueID() const {
}
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)
@ -289,6 +307,8 @@ uint32_t SBQueue::GetIndexID() const {
}
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)
@ -298,6 +318,8 @@ const char *SBQueue::GetName() const {
}
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)
@ -307,15 +329,20 @@ uint32_t SBQueue::GetNumThreads() {
}
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)
@ -325,14 +352,19 @@ uint32_t SBQueue::GetNumPendingItems() {
}
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)
@ -341,6 +373,14 @@ uint32_t SBQueue::GetNumRunningItems() {
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();
}

32
lldb/source/API/SBQueueItem.cpp
View File

@ -8,6 +8,7 @@
#include "lldb/lldb-forward.h"
#include "SBReproducerPrivate.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBQueueItem.h"
#include "lldb/API/SBThread.h"
@ -23,10 +24,15 @@ using namespace lldb_private;
//----------------------------------------------------------------------
// 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
@ -34,6 +40,8 @@ SBQueueItem::SBQueueItem(const QueueItemSP &queue_item_sp)
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)
@ -44,6 +52,8 @@ bool SBQueueItem::IsValid() const {
}
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()",
@ -52,10 +62,15 @@ void SBQueueItem::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) {
@ -69,12 +84,16 @@ lldb::QueueItemKind SBQueueItem::GetKind() const {
}
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) {
@ -90,16 +109,21 @@ SBAddress SBQueueItem::GetAddress() const {
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) {
@ -128,5 +152,5 @@ SBThread SBQueueItem::GetExtendedBacktraceThread(const char *type) {
}
}
}
return result;
return LLDB_RECORD_RESULT(result);
}

2852
lldb/source/API/SBReproducer.cpp
View File

File diff suppressed because it is too large Load Diff

81
lldb/source/API/SBSection.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBSection.h"
#include "SBReproducerPrivate.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBTarget.h"
#include "lldb/Core/Module.h"
@ -20,9 +21,13 @@
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 &section_sp)
: m_opaque_wp() // Don't init with section_sp otherwise this will throw if
@ -33,6 +38,9 @@ SBSection::SBSection(const lldb::SectionSP &section_sp)
}
const SBSection &SBSection::operator=(const SBSection &rhs) {
LLDB_RECORD_METHOD(const lldb::SBSection &,
SBSection, operator=,(const lldb::SBSection &), rhs);
m_opaque_wp = rhs.m_opaque_wp;
return *this;
}
@ -40,11 +48,15 @@ const SBSection &SBSection::operator=(const SBSection &rhs) {
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();
@ -52,6 +64,8 @@ const char *SBSection::GetName() {
}
lldb::SBSection SBSection::GetParent() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSection, SBSection, GetParent);
lldb::SBSection sb_section;
SectionSP section_sp(GetSP());
if (section_sp) {
@ -59,10 +73,13 @@ lldb::SBSection SBSection::GetParent() {
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());
@ -72,10 +89,12 @@ lldb::SBSection SBSection::FindSubSection(const char *sect_name) {
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();
@ -83,11 +102,14 @@ size_t SBSection::GetNumSubSections() {
}
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(); }
@ -97,6 +119,8 @@ void SBSection::SetSP(const lldb::SectionSP &section_sp) {
}
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)
@ -105,6 +129,9 @@ lldb::addr_t SBSection::GetFileAddress() {
}
lldb::addr_t SBSection::GetLoadAddress(lldb::SBTarget &sb_target) {
LLDB_RECORD_METHOD(lldb::addr_t, SBSection, GetLoadAddress,
(lldb::SBTarget &), sb_target);
TargetSP target_sp(sb_target.GetSP());
if (target_sp) {
SectionSP section_sp(GetSP());
@ -115,6 +142,8 @@ lldb::addr_t SBSection::GetLoadAddress(lldb::SBTarget &sb_target) {
}
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();
@ -122,6 +151,8 @@ lldb::addr_t SBSection::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());
@ -135,15 +166,24 @@ uint64_t SBSection::GetFileOffset() {
}
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) {
@ -177,26 +217,30 @@ SBData SBSection::GetSectionData(uint64_t offset, uint64_t size) {
}
}
}
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();
@ -204,6 +248,9 @@ uint32_t SBSection::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)
@ -212,12 +259,18 @@ bool SBSection::operator==(const SBSection &rhs) {
}
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());

25
lldb/source/API/SBSourceManager.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBSourceManager.h"
#include "SBReproducerPrivate.h"
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBTarget.h"
@ -71,14 +72,22 @@ using namespace lldb;
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;
@ -87,6 +96,10 @@ SBSourceManager::SBSourceManager(const SBSourceManager &rhs) {
const lldb::SBSourceManager &SBSourceManager::
operator=(const lldb::SBSourceManager &rhs) {
LLDB_RECORD_METHOD(const lldb::SBSourceManager &,
SBSourceManager, operator=,(const lldb::SBSourceManager &),
rhs);
m_opaque_up.reset(new SourceManagerImpl(*(rhs.m_opaque_up.get())));
return *this;
}
@ -96,6 +109,12 @@ SBSourceManager::~SBSourceManager() {}
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,
@ -106,6 +125,12 @@ size_t SBSourceManager::DisplaySourceLinesWithLineNumbersAndColumn(
const SBFileSpec &file, uint32_t line, uint32_t column,
uint32_t context_before, uint32_t context_after,
const char *current_line_cstr, SBStream &s) {
LLDB_RECORD_METHOD(
size_t, SBSourceManager, DisplaySourceLinesWithLineNumbersAndColumn,
(const lldb::SBFileSpec &, uint32_t, uint32_t, uint32_t, uint32_t,
const char *, lldb::SBStream &),
file, line, column, context_before, context_after, current_line_cstr, s);
if (m_opaque_up == NULL)
return 0;

26
lldb/source/API/SBStream.cpp
View File

@ -8,6 +8,7 @@
#include "lldb/API/SBStream.h"
#include "SBReproducerPrivate.h"
#include "lldb/Core/StreamFile.h"
#include "lldb/Host/FileSystem.h"
#include "lldb/Utility/Status.h"
@ -17,18 +18,26 @@
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;
@ -38,6 +47,8 @@ const char *SBStream::GetData() {
// If this stream is not redirected to a file, it will maintain a local cache
// for the stream output whose length can be accessed using this accessor.
size_t SBStream::GetSize() {
LLDB_RECORD_METHOD_NO_ARGS(size_t, SBStream, GetSize);
if (m_is_file || m_opaque_up == NULL)
return 0;
@ -54,6 +65,9 @@ void SBStream::Printf(const char *format, ...) {
}
void SBStream::RedirectToFile(const char *path, bool append) {
LLDB_RECORD_METHOD(void, SBStream, RedirectToFile, (const char *, bool), path,
append);
if (path == nullptr)
return;
@ -87,6 +101,9 @@ void SBStream::RedirectToFile(const char *path, bool append) {
}
void SBStream::RedirectToFileHandle(FILE *fh, bool transfer_fh_ownership) {
LLDB_RECORD_METHOD(void, SBStream, RedirectToFileHandle, (FILE *, bool), fh,
transfer_fh_ownership);
if (fh == nullptr)
return;
@ -111,6 +128,9 @@ void SBStream::RedirectToFileHandle(FILE *fh, bool transfer_fh_ownership) {
}
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
@ -142,6 +162,8 @@ lldb_private::Stream &SBStream::ref() {
}
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

34
lldb/source/API/SBStringList.cpp
View File

@ -7,13 +7,16 @@
//===----------------------------------------------------------------------===//
#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() {
@ -22,10 +25,15 @@ SBStringList::SBStringList(const lldb_private::StringList *lldb_strings_ptr)
}
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;
@ -41,9 +49,15 @@ const lldb_private::StringList &SBStringList::operator*() const {
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);
@ -53,6 +67,9 @@ void SBStringList::AppendString(const char *str) {
}
void SBStringList::AppendList(const char **strv, int strc) {
LLDB_RECORD_METHOD(void, SBStringList, AppendList, (const char **, int), strv,
strc);
if ((strv != NULL) && (strc > 0)) {
if (IsValid())
m_opaque_up->AppendList(strv, strc);
@ -62,6 +79,9 @@ void SBStringList::AppendList(const char **strv, int 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());
@ -76,6 +96,8 @@ void SBStringList::AppendList(const StringList &strings) {
}
uint32_t SBStringList::GetSize() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBStringList, GetSize);
if (IsValid()) {
return m_opaque_up->GetSize();
}
@ -83,6 +105,9 @@ uint32_t SBStringList::GetSize() const {
}
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);
}
@ -90,6 +115,9 @@ const char *SBStringList::GetStringAtIndex(size_t idx) {
}
const char *SBStringList::GetStringAtIndex(size_t idx) const {
LLDB_RECORD_METHOD_CONST(const char *, SBStringList, GetStringAtIndex,
(size_t), idx);
if (IsValid()) {
return m_opaque_up->GetStringAtIndex(idx);
}
@ -97,6 +125,8 @@ const char *SBStringList::GetStringAtIndex(size_t idx) const {
}
void SBStringList::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBStringList, Clear);
if (IsValid()) {
m_opaque_up->Clear();
}

84
lldb/source/API/SBStructuredData.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBStructuredData.h"
#include "SBReproducerPrivate.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBStringList.h"
@ -23,26 +24,43 @@ using namespace lldb_private;
#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());
@ -51,35 +69,57 @@ lldb::SBError SBStructuredData::SetFromJSON(lldb::SBStream &stream) {
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;
@ -107,35 +147,53 @@ bool SBStructuredData::GetKeys(lldb::SBStringList &keys) const {
}
lldb::SBStructuredData SBStructuredData::GetValueForKey(const char *key) const {
LLDB_RECORD_METHOD_CONST(lldb::SBStructuredData, SBStructuredData,
GetValueForKey, (const char *), key);
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);
}

60
lldb/source/API/SBSymbol.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBSymbol.h"
#include "SBReproducerPrivate.h"
#include "lldb/API/SBStream.h"
#include "lldb/Core/Disassembler.h"
#include "lldb/Core/Module.h"
@ -18,15 +19,21 @@
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;
}
@ -37,9 +44,15 @@ void SBSymbol::SetSymbol(lldb_private::Symbol *lldb_object_ptr) {
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();
@ -52,6 +65,8 @@ const char *SBSymbol::GetName() const {
}
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()
@ -66,6 +81,8 @@ const char *SBSymbol::GetDisplayName() const {
}
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();
@ -78,14 +95,23 @@ const char *SBSymbol::GetMangledName() const {
}
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) {
@ -97,11 +123,17 @@ bool SBSymbol::GetDescription(SBStream &description) {
}
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;
@ -124,7 +156,7 @@ SBInstructionList SBSymbol::GetInstructions(SBTarget target,
}
}
}
return sb_instructions;
return LLDB_RECORD_RESULT(sb_instructions);
}
lldb_private::Symbol *SBSymbol::get() { return m_opaque_ptr; }
@ -132,14 +164,18 @@ 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();
@ -148,28 +184,36 @@ SBAddress SBSymbol::GetEndAddress() {
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;

76
lldb/source/API/SBSymbolContext.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBSymbolContext.h"
#include "SBReproducerPrivate.h"
#include "Utils.h"
#include "lldb/API/SBStream.h"
#include "lldb/Core/Module.h"
@ -18,20 +19,32 @@
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;
@ -44,9 +57,15 @@ void SBSymbolContext::SetSymbolContext(const SymbolContext *sc_ptr) {
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;
@ -64,14 +83,20 @@ SBModule SBSymbolContext::GetModule() {
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;
@ -86,14 +111,18 @@ SBFunction SBSymbolContext::GetFunction() {
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;
@ -106,10 +135,12 @@ SBLineEntry SBSymbolContext::GetLineEntry() {
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;
@ -124,26 +155,40 @@ SBSymbol SBSymbolContext::GetSymbol() {
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
@ -151,6 +196,9 @@ void SBSymbolContext::SetLineEntry(lldb::SBLineEntry line_entry) {
}
void SBSymbolContext::SetSymbol(lldb::SBSymbol symbol) {
LLDB_RECORD_METHOD(void, SBSymbolContext, SetSymbol, (lldb::SBSymbol),
symbol);
ref().symbol = symbol.get();
}
@ -180,6 +228,9 @@ lldb_private::SymbolContext *SBSymbolContext::get() const {
}
bool SBSymbolContext::GetDescription(SBStream &description) {
LLDB_RECORD_METHOD(bool, SBSymbolContext, GetDescription, (lldb::SBStream &),
description);
Stream &strm = description.ref();
if (m_opaque_up) {
@ -193,11 +244,16 @@ bool SBSymbolContext::GetDescription(SBStream &description) {
SBSymbolContext
SBSymbolContext::GetParentOfInlinedScope(const SBAddress &curr_frame_pc,
SBAddress &parent_frame_addr) const {
LLDB_RECORD_METHOD_CONST(lldb::SBSymbolContext, SBSymbolContext,
GetParentOfInlinedScope,
(const lldb::SBAddress &, lldb::SBAddress &),
curr_frame_pc, parent_frame_addr);
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());
}

35
lldb/source/API/SBSymbolContextList.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBSymbolContextList.h"
#include "SBReproducerPrivate.h"
#include "Utils.h"
#include "lldb/API/SBStream.h"
#include "lldb/Symbol/SymbolContext.h"
@ -15,10 +16,14 @@ using namespace lldb;
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);
}
@ -27,18 +32,27 @@ SBSymbolContextList::~SBSymbolContextList() {}
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;
@ -46,25 +60,37 @@ SBSymbolContext SBSymbolContextList::GetContextAtIndex(uint32_t idx) {
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();
@ -76,6 +102,9 @@ lldb_private::SymbolContextList &SBSymbolContextList::operator*() const {
}
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);

677
lldb/source/API/SBTarget.cpp
View File

File diff suppressed because it is too large Load Diff

253
lldb/source/API/SBThread.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBThread.h"
#include "SBReproducerPrivate.h"
#include "Utils.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBDebugger.h"
@ -49,18 +50,27 @@ using namespace lldb;
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);
}
@ -69,6 +79,9 @@ SBThread::SBThread(const SBThread &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;
@ -80,6 +93,8 @@ const lldb::SBThread &SBThread::operator=(const SBThread &rhs) {
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;
@ -105,10 +120,12 @@ lldb::SBQueue SBThread::GetQueue() const {
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);
@ -123,9 +140,15 @@ bool SBThread::IsValid() const {
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;
@ -153,6 +176,8 @@ StopReason SBThread::GetStopReason() {
}
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);
@ -206,6 +231,9 @@ size_t SBThread::GetStopReasonDataCount() {
}
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);
@ -271,6 +299,9 @@ uint64_t SBThread::GetStopReasonDataAtIndex(uint32_t idx) {
}
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;
@ -291,6 +322,10 @@ bool SBThread::GetStopReasonExtendedInfoAsJSON(lldb::SBStream &stream) {
SBThreadCollection
SBThread::GetStopReasonExtendedBacktraces(InstrumentationRuntimeType type) {
LLDB_RECORD_METHOD(lldb::SBThreadCollection, SBThread,
GetStopReasonExtendedBacktraces,
(lldb::InstrumentationRuntimeType), type);
ThreadCollectionSP threads;
threads = std::make_shared<ThreadCollection>();
@ -298,20 +333,23 @@ SBThread::GetStopReasonExtendedBacktraces(InstrumentationRuntimeType type) {
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;
@ -423,6 +461,8 @@ size_t SBThread::GetStopDescription(char *dst, size_t dst_len) {
}
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;
@ -449,7 +489,7 @@ SBValue SBThread::GetStopReturnValue() {
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) {
@ -457,6 +497,8 @@ 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();
@ -464,6 +506,8 @@ lldb::tid_t SBThread::GetThreadID() const {
}
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();
@ -471,6 +515,8 @@ uint32_t SBThread::GetIndexID() const {
}
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;
@ -496,6 +542,8 @@ const char *SBThread::GetName() const {
}
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);
@ -521,6 +569,8 @@ const char *SBThread::GetQueueName() const {
}
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);
@ -545,6 +595,9 @@ lldb::queue_id_t SBThread::GetQueueID() const {
}
bool SBThread::GetInfoItemByPathAsString(const char *path, SBStream &strm) {
LLDB_RECORD_METHOD(bool, SBThread, GetInfoItemByPathAsString,
(const char *, lldb::SBStream &), path, strm);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
bool success = false;
std::unique_lock<std::recursive_mutex> lock;
@ -634,11 +687,17 @@ SBError SBThread::ResumeNewPlan(ExecutionContext &exe_ctx,
}
void SBThread::StepOver(lldb::RunMode stop_other_threads) {
LLDB_RECORD_METHOD(void, SBThread, StepOver, (lldb::RunMode),
stop_other_threads);
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;
@ -676,17 +735,27 @@ void SBThread::StepOver(lldb::RunMode stop_other_threads, SBError &error) {
}
void SBThread::StepInto(lldb::RunMode stop_other_threads) {
LLDB_RECORD_METHOD(void, SBThread, StepInto, (lldb::RunMode),
stop_other_threads);
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;
@ -741,11 +810,15 @@ void SBThread::StepInto(const char *target_name, uint32_t end_line,
}
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;
@ -778,11 +851,17 @@ void SBThread::StepOut(SBError &error) {
}
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;
@ -835,11 +914,16 @@ void SBThread::StepOutOfFrame(SBFrame &sb_frame, SBError &error) {
}
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;
@ -866,11 +950,16 @@ void SBThread::StepInstruction(bool step_over, SBError &error) {
}
void SBThread::RunToAddress(lldb::addr_t addr) {
LLDB_RECORD_METHOD(void, SBThread, RunToAddress, (lldb::addr_t), addr);
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;
@ -904,6 +993,10 @@ void SBThread::RunToAddress(lldb::addr_t addr, SBError &error) {
SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame,
lldb::SBFileSpec &sb_file_spec, uint32_t line) {
LLDB_RECORD_METHOD(lldb::SBError, SBThread, StepOverUntil,
(lldb::SBFrame &, lldb::SBFileSpec &, uint32_t), sb_frame,
sb_file_spec, line);
SBError sb_error;
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
char path[PATH_MAX];
@ -930,7 +1023,7 @@ SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame,
if (line == 0) {
sb_error.SetErrorString("invalid line argument");
return sb_error;
return LLDB_RECORD_RESULT(sb_error);
}
if (!frame_sp) {
@ -942,7 +1035,7 @@ SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame,
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
@ -953,7 +1046,7 @@ SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame,
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;
@ -965,7 +1058,7 @@ SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame,
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);
}
}
@ -1025,15 +1118,23 @@ SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame,
} 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;
@ -1047,7 +1148,7 @@ SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name,
if (!exe_ctx.HasThreadScope()) {
error.SetErrorString("this SBThread object is invalid");
return error;
return LLDB_RECORD_RESULT(error);
}
Thread *thread = exe_ctx.GetThreadPtr();
@ -1057,21 +1158,24 @@ SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name,
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;
@ -1085,17 +1189,20 @@ SBError SBThread::JumpToLine(lldb::SBFileSpec &file_spec, uint32_t line) {
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));
@ -1114,10 +1221,13 @@ SBError SBThread::ReturnFromFrame(SBFrame &frame, SBValue &return_value) {
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));
@ -1136,15 +1246,19 @@ SBError SBThread::UnwindInnermostExpression() {
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);
@ -1170,11 +1284,15 @@ bool SBThread::Suspend(SBError &error) {
}
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);
@ -1201,6 +1319,8 @@ bool SBThread::Resume(SBError &error) {
}
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);
@ -1210,6 +1330,8 @@ bool SBThread::IsSuspended() {
}
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);
@ -1219,6 +1341,8 @@ bool SBThread::IsStopped() {
}
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);
@ -1239,10 +1363,12 @@ SBProcess SBThread::GetProcess() {
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;
@ -1268,6 +1394,8 @@ uint32_t SBThread::GetNumFrames() {
}
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;
@ -1296,10 +1424,12 @@ SBFrame SBThread::GetFrameAtIndex(uint32_t idx) {
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;
@ -1328,10 +1458,13 @@ lldb::SBFrame SBThread::GetSelectedFrame() {
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;
@ -1363,32 +1496,52 @@ lldb::SBFrame SBThread::SetSelectedFrame(uint32_t idx) {
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;
@ -1403,10 +1556,16 @@ bool SBThread::GetStatus(SBStream &status) const {
}
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;
@ -1425,6 +1584,9 @@ bool SBThread::GetDescription(SBStream &description, bool stop_format) const {
}
SBThread SBThread::GetExtendedBacktraceThread(const char *type) {
LLDB_RECORD_METHOD(lldb::SBThread, SBThread, GetExtendedBacktraceThread,
(const char *), type);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
@ -1475,10 +1637,13 @@ SBThread SBThread::GetExtendedBacktraceThread(const char *type) {
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();
@ -1486,20 +1651,30 @@ uint32_t SBThread::GetExtendedBacktraceOriginatingIndexID() {
}
SBValue SBThread::GetCurrentException() {
ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
if (!thread_sp) return SBValue();
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBThread, GetCurrentException);
return SBValue(thread_sp->GetCurrentException());
ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
if (!thread_sp)
return LLDB_RECORD_RESULT(SBValue());
return LLDB_RECORD_RESULT(SBValue(thread_sp->GetCurrentException()));
}
SBThread SBThread::GetCurrentExceptionBacktrace() {
ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
if (!thread_sp) return SBThread();
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBThread, SBThread,
GetCurrentExceptionBacktrace);
return SBThread(thread_sp->GetCurrentExceptionBacktrace());
ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
if (!thread_sp)
return LLDB_RECORD_RESULT(SBThread());
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();
@ -1507,6 +1682,8 @@ bool SBThread::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();
@ -1515,6 +1692,8 @@ lldb_private::Thread *SBThread::operator->() {
}
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();

27
lldb/source/API/SBThreadCollection.cpp
View File

@ -7,19 +7,29 @@
//===----------------------------------------------------------------------===//
#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;
@ -50,17 +60,26 @@ const lldb::ThreadCollectionSP &SBThreadCollection::operator*() const {
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);
}

156
lldb/source/API/SBThreadPlan.cpp
View File

@ -6,6 +6,7 @@
//
//===----------------------------------------------------------------------===//
#include "SBReproducerPrivate.h"
#include "lldb/API/SBThread.h"
#include "lldb/API/SBFileSpec.h"
@ -49,15 +50,23 @@ using namespace lldb_private;
//----------------------------------------------------------------------
// 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);
@ -68,6 +77,9 @@ SBThreadPlan::SBThreadPlan(lldb::SBThread &sb_thread, const char *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;
@ -77,26 +89,57 @@ const lldb::SBThreadPlan &SBThreadPlan::operator=(const SBThreadPlan &rhs) {
//----------------------------------------------------------------------
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);
bool SBThreadPlan::IsValid() const { return m_opaque_sp.get() != NULL; }
return m_opaque_sp.get();
}
void SBThreadPlan::Clear() { m_opaque_sp.reset(); }
bool SBThreadPlan::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadPlan, IsValid);
lldb::StopReason SBThreadPlan::GetStopReason() { return eStopReasonNone; }
return m_opaque_sp.get() != NULL;
}
size_t SBThreadPlan::GetStopReasonDataCount() { return 0; }
void SBThreadPlan::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBThreadPlan, Clear);
uint64_t SBThreadPlan::GetStopReasonDataAtIndex(uint32_t idx) { return 0; }
m_opaque_sp.reset();
}
lldb::StopReason SBThreadPlan::GetStopReason() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::StopReason, SBThreadPlan, GetStopReason);
return eStopReasonNone;
}
size_t SBThreadPlan::GetStopReasonDataCount() {
LLDB_RECORD_METHOD_NO_ARGS(size_t, SBThreadPlan, GetStopReasonDataCount);
return 0;
}
uint64_t SBThreadPlan::GetStopReasonDataAtIndex(uint32_t idx) {
LLDB_RECORD_METHOD(uint64_t, SBThreadPlan, GetStopReasonDataAtIndex,
(uint32_t), idx);
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 {
@ -110,11 +153,15 @@ void SBThreadPlan::SetThreadPlan(const ThreadPlanSP &lldb_object_sp) {
}
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
@ -122,6 +169,8 @@ bool SBThreadPlan::IsPlanComplete() {
}
bool SBThreadPlan::IsPlanStale() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, IsPlanStale);
if (m_opaque_sp)
return m_opaque_sp->IsPlanStale();
else
@ -129,6 +178,8 @@ bool SBThreadPlan::IsPlanStale() {
}
bool SBThreadPlan::IsValid() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, IsValid);
if (m_opaque_sp)
return m_opaque_sp->ValidatePlan(nullptr);
else
@ -144,16 +195,26 @@ bool SBThreadPlan::IsValid() {
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);
@ -168,26 +229,36 @@ SBThreadPlan SBThreadPlan::QueueThreadPlanForStepOverRange(
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);
@ -202,22 +273,32 @@ SBThreadPlan::QueueThreadPlanForStepInRange(SBAddress &sb_start_address,
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(
@ -232,24 +313,32 @@ SBThreadPlan::QueueThreadPlanForStepOut(uint32_t frame_idx_to_step_to,
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 =
@ -259,21 +348,30 @@ SBThreadPlan SBThreadPlan::QueueThreadPlanForRunToAddress(SBAddress sb_address,
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 =
@ -283,8 +381,8 @@ SBThreadPlan::QueueThreadPlanForStepScripted(const char *script_class_name,
if (plan_status.Fail())
error.SetErrorString(plan_status.AsCString());
return plan;
return LLDB_RECORD_RESULT(plan);
} else {
return SBThreadPlan();
return LLDB_RECORD_RESULT(SBThreadPlan());
}
}

13
lldb/source/API/SBTrace.cpp
View File

@ -6,6 +6,7 @@
//
//===----------------------------------------------------------------------===//
#include "SBReproducerPrivate.h"
#include "lldb/Target/Process.h"
#include "lldb/Utility/Log.h"
@ -60,6 +61,9 @@ size_t SBTrace::GetMetaData(SBError &error, void *buf, size_t size,
}
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();
@ -71,6 +75,9 @@ void SBTrace::StopTrace(SBError &error, lldb::tid_t thread_id) {
}
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();
@ -83,6 +90,8 @@ void SBTrace::GetTraceConfig(SBTraceOptions &options, SBError &error) {
}
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;
@ -94,6 +103,8 @@ void SBTrace::SetTraceUID(lldb::user_id_t 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;
@ -102,6 +113,8 @@ SBTrace::SBTrace() {
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())

34
lldb/source/API/SBTraceOptions.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBTraceOptions.h"
#include "SBReproducerPrivate.h"
#include "lldb/API/SBError.h"
#include "lldb/API/SBStructuredData.h"
#include "lldb/Core/StructuredDataImpl.h"
@ -19,22 +20,32 @@ using namespace lldb;
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();
@ -43,16 +54,22 @@ lldb::SBStructuredData SBTraceOptions::getTraceParams(lldb::SBError &error) {
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 &params) {
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)
@ -63,32 +80,47 @@ void SBTraceOptions::setTraceParams(lldb::SBStructuredData &params) {
}
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;

300
lldb/source/API/SBType.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBType.h"
#include "SBReproducerPrivate.h"
#include "lldb/API/SBDefines.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBTypeEnumMember.h"
@ -25,7 +26,7 @@
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(
@ -38,6 +39,8 @@ SBType::SBType(const lldb::TypeImplSP &type_impl_sp)
: 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;
}
@ -48,6 +51,8 @@ SBType::SBType(const SBType &rhs) : m_opaque_sp() {
//{}
//
bool SBType::operator==(SBType &rhs) {
LLDB_RECORD_METHOD(bool, SBType, operator==,(lldb::SBType &), rhs);
if (!IsValid())
return !rhs.IsValid();
@ -58,6 +63,8 @@ bool SBType::operator==(SBType &rhs) {
}
bool SBType::operator!=(SBType &rhs) {
LLDB_RECORD_METHOD(bool, SBType, operator!=,(lldb::SBType &), rhs);
if (!IsValid())
return rhs.IsValid();
@ -74,6 +81,9 @@ void SBType::SetSP(const lldb::TypeImplSP &type_impl_sp) {
}
SBType &SBType::operator=(const SBType &rhs) {
LLDB_RECORD_METHOD(lldb::SBType &, SBType, operator=,(const lldb::SBType &),
rhs);
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
}
@ -97,6 +107,8 @@ const TypeImpl &SBType::ref() const {
}
bool SBType::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBType, IsValid);
if (m_opaque_sp.get() == NULL)
return false;
@ -104,6 +116,8 @@ bool SBType::IsValid() const {
}
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))
@ -112,12 +126,16 @@ uint64_t SBType::GetByteSize() {
}
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,
@ -125,63 +143,88 @@ bool SBType::IsArrayType() {
}
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() {
if (!IsValid())
return SBType();
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetPointerType);
return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetPointerType())));
if (!IsValid())
return LLDB_RECORD_RESULT(SBType());
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;
@ -189,44 +232,57 @@ SBType SBType::GetVectorElementType() {
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));
@ -235,10 +291,12 @@ lldb::SBTypeList SBType::GetFunctionArgumentTypes() {
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();
}
@ -246,51 +304,71 @@ uint32_t SBType::GetNumberOfMemberFunctions() {
}
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;
@ -298,6 +376,10 @@ uint32_t SBType::GetNumberOfFields() {
bool SBType::GetDescription(SBStream &description,
lldb::DescriptionLevel description_level) {
LLDB_RECORD_METHOD(bool, SBType, GetDescription,
(lldb::SBStream &, lldb::DescriptionLevel), description,
description_level);
Stream &strm = description.ref();
if (m_opaque_sp) {
@ -309,6 +391,9 @@ bool SBType::GetDescription(SBStream &description,
}
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;
@ -319,10 +404,13 @@ SBTypeMember SBType::GetDirectBaseClassAtIndex(uint32_t idx) {
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;
@ -333,10 +421,13 @@ SBTypeMember SBType::GetVirtualBaseClassAtIndex(uint32_t idx) {
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));
@ -353,10 +444,13 @@ SBTypeEnumMemberList SBType::GetEnumMembers() {
});
}
}
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));
@ -377,48 +471,63 @@ SBTypeMember SBType::GetFieldAtIndex(uint32_t idx) {
}
}
}
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)) {
@ -434,28 +543,42 @@ lldb::SBType SBType::GetTemplateArgumentType(uint32_t 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();
@ -466,25 +589,38 @@ SBTypeList &SBTypeList::operator=(const SBTypeList &rhs) {
}
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()));
@ -492,6 +628,9 @@ SBTypeMember::SBTypeMember(const SBTypeMember &rhs) : m_opaque_up() {
}
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()));
@ -499,41 +638,57 @@ lldb::SBTypeMember &SBTypeMember::operator=(const lldb::SBTypeMember &rhs) {
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;
@ -541,6 +696,10 @@ uint32_t SBTypeMember::GetBitfieldSizeInBits() {
bool SBTypeMember::GetDescription(lldb::SBStream &description,
lldb::DescriptionLevel description_level) {
LLDB_RECORD_METHOD(bool, SBTypeMember, GetDescription,
(lldb::SBStream &, lldb::DescriptionLevel), description,
description_level);
Stream &strm = description.ref();
if (m_opaque_up) {
@ -580,29 +739,48 @@ TypeMemberImpl &SBTypeMember::ref() {
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) {
@ -614,43 +792,59 @@ const char *SBTypeMemberFunction::GetDemangledName() {
}
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;
@ -658,6 +852,10 @@ lldb::MemberFunctionKind SBTypeMemberFunction::GetKind() {
bool SBTypeMemberFunction::GetDescription(
lldb::SBStream &description, lldb::DescriptionLevel description_level) {
LLDB_RECORD_METHOD(bool, SBTypeMemberFunction, GetDescription,
(lldb::SBStream &, lldb::DescriptionLevel), description,
description_level);
Stream &strm = description.ref();
if (m_opaque_sp)

194
lldb/source/API/SBTypeCategory.cpp
View File

@ -8,6 +8,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBTypeCategory.h"
#include "SBReproducerPrivate.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBTypeFilter.h"
@ -26,26 +27,38 @@ using namespace lldb_private;
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)
@ -55,29 +68,41 @@ void SBTypeCategory::SetEnabled(bool 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;
@ -86,6 +111,8 @@ uint32_t SBTypeCategory::GetNumFormats() {
}
uint32_t SBTypeCategory::GetNumSummaries() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumSummaries);
if (!IsValid())
return 0;
return m_opaque_sp->GetTypeSummariesContainer()->GetCount() +
@ -93,6 +120,8 @@ uint32_t SBTypeCategory::GetNumSummaries() {
}
uint32_t SBTypeCategory::GetNumFilters() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumFilters);
if (!IsValid())
return 0;
return m_opaque_sp->GetTypeFiltersContainer()->GetCount() +
@ -101,6 +130,8 @@ uint32_t SBTypeCategory::GetNumFilters() {
#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() +
@ -110,44 +141,60 @@ uint32_t SBTypeCategory::GetNumSynthetics() {
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;
@ -159,19 +206,22 @@ SBTypeFilter SBTypeCategory::GetFilterForType(SBTypeNameSpecifier spec) {
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;
@ -183,18 +233,21 @@ SBTypeFormat SBTypeCategory::GetFormatForType(SBTypeNameSpecifier spec) {
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;
@ -206,19 +259,22 @@ SBTypeSummary SBTypeCategory::GetSummaryForType(SBTypeNameSpecifier spec) {
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;
@ -230,65 +286,83 @@ SBTypeSynthetic SBTypeCategory::GetSyntheticForType(SBTypeNameSpecifier spec) {
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;
@ -311,6 +385,9 @@ bool SBTypeCategory::AddTypeFormat(SBTypeNameSpecifier type_name,
}
bool SBTypeCategory::DeleteTypeFormat(SBTypeNameSpecifier type_name) {
LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeFormat,
(lldb::SBTypeNameSpecifier), type_name);
if (!IsValid())
return false;
@ -328,6 +405,10 @@ bool SBTypeCategory::DeleteTypeFormat(SBTypeNameSpecifier type_name) {
#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;
@ -385,6 +466,9 @@ bool SBTypeCategory::AddTypeSummary(SBTypeNameSpecifier type_name,
#endif
bool SBTypeCategory::DeleteTypeSummary(SBTypeNameSpecifier type_name) {
LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeSummary,
(lldb::SBTypeNameSpecifier), type_name);
if (!IsValid())
return false;
@ -401,6 +485,10 @@ bool SBTypeCategory::DeleteTypeSummary(SBTypeNameSpecifier type_name) {
bool SBTypeCategory::AddTypeFilter(SBTypeNameSpecifier type_name,
SBTypeFilter filter) {
LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeFilter,
(lldb::SBTypeNameSpecifier, lldb::SBTypeFilter), type_name,
filter);
if (!IsValid())
return false;
@ -423,6 +511,9 @@ bool SBTypeCategory::AddTypeFilter(SBTypeNameSpecifier type_name,
}
bool SBTypeCategory::DeleteTypeFilter(SBTypeNameSpecifier type_name) {
LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeFilter,
(lldb::SBTypeNameSpecifier), type_name);
if (!IsValid())
return false;
@ -440,6 +531,10 @@ bool SBTypeCategory::DeleteTypeFilter(SBTypeNameSpecifier type_name) {
#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;
@ -496,6 +591,9 @@ bool SBTypeCategory::AddTypeSynthetic(SBTypeNameSpecifier type_name,
}
bool SBTypeCategory::DeleteTypeSynthetic(SBTypeNameSpecifier type_name) {
LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeSynthetic,
(lldb::SBTypeNameSpecifier), type_name);
if (!IsValid())
return false;
@ -513,6 +611,10 @@ bool SBTypeCategory::DeleteTypeSynthetic(SBTypeNameSpecifier type_name) {
bool SBTypeCategory::GetDescription(lldb::SBStream &description,
lldb::DescriptionLevel description_level) {
LLDB_RECORD_METHOD(bool, SBTypeCategory, GetDescription,
(lldb::SBStream &, lldb::DescriptionLevel), description,
description_level);
if (!IsValid())
return false;
description.Printf("Category name: %s\n", GetName());
@ -521,6 +623,10 @@ bool SBTypeCategory::GetDescription(lldb::SBStream &description,
lldb::SBTypeCategory &SBTypeCategory::
operator=(const lldb::SBTypeCategory &rhs) {
LLDB_RECORD_METHOD(lldb::SBTypeCategory &,
SBTypeCategory, operator=,(const lldb::SBTypeCategory &),
rhs);
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
}
@ -528,6 +634,9 @@ operator=(const lldb::SBTypeCategory &rhs) {
}
bool SBTypeCategory::operator==(lldb::SBTypeCategory &rhs) {
LLDB_RECORD_METHOD(bool, SBTypeCategory, operator==,(lldb::SBTypeCategory &),
rhs);
if (!IsValid())
return !rhs.IsValid();
@ -535,6 +644,9 @@ bool SBTypeCategory::operator==(lldb::SBTypeCategory &rhs) {
}
bool SBTypeCategory::operator!=(lldb::SBTypeCategory &rhs) {
LLDB_RECORD_METHOD(bool, SBTypeCategory, operator!=,(lldb::SBTypeCategory &),
rhs);
if (!IsValid())
return rhs.IsValid();

66
lldb/source/API/SBTypeEnumMember.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBTypeEnumMember.h"
#include "SBReproducerPrivate.h"
#include "Utils.h"
#include "lldb/API/SBDefines.h"
#include "lldb/API/SBStream.h"
@ -20,7 +21,9 @@
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() {}
@ -30,41 +33,59 @@ 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) {
@ -82,20 +103,34 @@ const TypeEnumMemberImpl &SBTypeEnumMember::ref() const {
}
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,
@ -108,23 +143,38 @@ operator=(const SBTypeEnumMemberList &rhs) {
}
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()) {

53
lldb/source/API/SBTypeFilter.cpp
View File

@ -8,6 +8,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBTypeFilter.h"
#include "SBReproducerPrivate.h"
#include "lldb/API/SBStream.h"
@ -16,31 +17,49 @@
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 {
@ -50,17 +69,25 @@ bool SBTypeFilter::GetDescription(lldb::SBStream &description,
}
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 == '.')
@ -71,6 +98,9 @@ const char *SBTypeFilter::GetExpressionPathAtIndex(uint32_t i) {
}
bool SBTypeFilter::ReplaceExpressionPathAtIndex(uint32_t i, const char *item) {
LLDB_RECORD_METHOD(bool, SBTypeFilter, ReplaceExpressionPathAtIndex,
(uint32_t, const char *), i, item);
if (CopyOnWrite_Impl())
return m_opaque_sp->SetExpressionPathAtIndex(i, item);
else
@ -78,11 +108,17 @@ bool SBTypeFilter::ReplaceExpressionPathAtIndex(uint32_t i, const char *item) {
}
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;
}
@ -90,6 +126,9 @@ lldb::SBTypeFilter &SBTypeFilter::operator=(const lldb::SBTypeFilter &rhs) {
}
bool SBTypeFilter::operator==(lldb::SBTypeFilter &rhs) {
LLDB_RECORD_METHOD(bool, SBTypeFilter, operator==,(lldb::SBTypeFilter &),
rhs);
if (!IsValid())
return !rhs.IsValid();
@ -97,6 +136,9 @@ bool SBTypeFilter::operator==(lldb::SBTypeFilter &rhs) {
}
bool SBTypeFilter::IsEqualTo(lldb::SBTypeFilter &rhs) {
LLDB_RECORD_METHOD(bool, SBTypeFilter, IsEqualTo, (lldb::SBTypeFilter &),
rhs);
if (!IsValid())
return !rhs.IsValid();
@ -112,6 +154,9 @@ bool SBTypeFilter::IsEqualTo(lldb::SBTypeFilter &rhs) {
}
bool SBTypeFilter::operator!=(lldb::SBTypeFilter &rhs) {
LLDB_RECORD_METHOD(bool, SBTypeFilter, operator!=,(lldb::SBTypeFilter &),
rhs);
if (!IsValid())
return !rhs.IsValid();

53
lldb/source/API/SBTypeFormat.cpp
View File

@ -8,6 +8,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBTypeFormat.h"
#include "SBReproducerPrivate.h"
#include "lldb/API/SBStream.h"
@ -16,30 +17,48 @@
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()
@ -48,29 +67,41 @@ const char *SBTypeFormat::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 {
@ -80,6 +111,9 @@ bool SBTypeFormat::GetDescription(lldb::SBStream &description,
}
lldb::SBTypeFormat &SBTypeFormat::operator=(const lldb::SBTypeFormat &rhs) {
LLDB_RECORD_METHOD(lldb::SBTypeFormat &,
SBTypeFormat, operator=,(const lldb::SBTypeFormat &), rhs);
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
}
@ -87,12 +121,18 @@ lldb::SBTypeFormat &SBTypeFormat::operator=(const lldb::SBTypeFormat &rhs) {
}
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();
@ -103,6 +143,9 @@ bool SBTypeFormat::IsEqualTo(lldb::SBTypeFormat &rhs) {
}
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;

50
lldb/source/API/SBTypeNameSpecifier.cpp
View File

@ -8,6 +8,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBTypeNameSpecifier.h"
#include "SBReproducerPrivate.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBType.h"
@ -17,28 +18,44 @@
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;
@ -46,15 +63,19 @@ const char *SBTypeNameSpecifier::GetName() {
}
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;
@ -63,6 +84,10 @@ bool SBTypeNameSpecifier::IsRegex() {
bool SBTypeNameSpecifier::GetDescription(
lldb::SBStream &description, lldb::DescriptionLevel description_level) {
LLDB_RECORD_METHOD(bool, SBTypeNameSpecifier, GetDescription,
(lldb::SBStream &, lldb::DescriptionLevel), description,
description_level);
if (!IsValid())
return false;
description.Printf("SBTypeNameSpecifier(%s,%s)", GetName(),
@ -72,6 +97,10 @@ bool SBTypeNameSpecifier::GetDescription(
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;
}
@ -79,12 +108,18 @@ operator=(const lldb::SBTypeNameSpecifier &rhs) {
}
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();
@ -97,6 +132,9 @@ bool SBTypeNameSpecifier::IsEqualTo(lldb::SBTypeNameSpecifier &rhs) {
}
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;

124
lldb/source/API/SBTypeSummary.cpp
View File

@ -8,6 +8,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBTypeSummary.h"
#include "SBReproducerPrivate.h"
#include "Utils.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBValue.h"
@ -18,36 +19,58 @@
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);
}
@ -75,6 +98,10 @@ const lldb_private::TypeSummaryOptions &SBTypeSummaryOptions::ref() const {
SBTypeSummaryOptions::SBTypeSummaryOptions(
const lldb_private::TypeSummaryOptions *lldb_object_ptr) {
LLDB_RECORD_CONSTRUCTOR(SBTypeSummaryOptions,
(const lldb_private::TypeSummaryOptions *),
lldb_object_ptr);
SetOptions(lldb_object_ptr);
}
@ -86,33 +113,47 @@ void SBTypeSummaryOptions::SetOptions(
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) {
if (!data || data[0] == 0)
return SBTypeSummary();
LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
CreateWithSummaryString, (const char *, uint32_t),
data, options);
return SBTypeSummary(
TypeSummaryImplSP(new StringSummaryFormat(options, data)));
if (!data || data[0] == 0)
return LLDB_RECORD_RESULT(SBTypeSummary());
return LLDB_RECORD_RESULT(
SBTypeSummary(TypeSummaryImplSP(new StringSummaryFormat(options, data))));
}
SBTypeSummary SBTypeSummary::CreateWithFunctionName(const char *data,
uint32_t options) {
if (!data || data[0] == 0)
return SBTypeSummary();
LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
CreateWithFunctionName, (const char *, uint32_t),
data, options);
return SBTypeSummary(
TypeSummaryImplSP(new ScriptSummaryFormat(options, data)));
if (!data || data[0] == 0)
return LLDB_RECORD_RESULT(SBTypeSummary());
return LLDB_RECORD_RESULT(
SBTypeSummary(TypeSummaryImplSP(new ScriptSummaryFormat(options, data))));
}
SBTypeSummary SBTypeSummary::CreateWithScriptCode(const char *data,
uint32_t options) {
if (!data || data[0] == 0)
return SBTypeSummary();
LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
CreateWithScriptCode, (const char *, uint32_t),
data, options);
return SBTypeSummary(
TypeSummaryImplSP(new ScriptSummaryFormat(options, "", data)));
if (!data || data[0] == 0)
return LLDB_RECORD_RESULT(SBTypeSummary());
return LLDB_RECORD_RESULT(SBTypeSummary(
TypeSummaryImplSP(new ScriptSummaryFormat(options, "", data))));
}
SBTypeSummary SBTypeSummary::CreateWithCallback(FormatCallback cb,
@ -139,13 +180,21 @@ 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 =
@ -157,6 +206,8 @@ bool SBTypeSummary::IsFunctionCode() {
}
bool SBTypeSummary::IsFunctionName() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummary, IsFunctionName);
if (!IsValid())
return false;
if (ScriptSummaryFormat *script_summary_ptr =
@ -168,6 +219,8 @@ bool SBTypeSummary::IsFunctionName() {
}
bool SBTypeSummary::IsSummaryString() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummary, IsSummaryString);
if (!IsValid())
return false;
@ -175,6 +228,8 @@ bool SBTypeSummary::IsSummaryString() {
}
const char *SBTypeSummary::GetData() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeSummary, GetData);
if (!IsValid())
return NULL;
if (ScriptSummaryFormat *script_summary_ptr =
@ -191,18 +246,25 @@ const char *SBTypeSummary::GetData() {
}
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()))
@ -213,6 +275,9 @@ void SBTypeSummary::SetSummaryString(const char *data) {
}
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()))
@ -223,6 +288,9 @@ void SBTypeSummary::SetFunctionName(const char *data) {
}
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()))
@ -234,6 +302,10 @@ void SBTypeSummary::SetFunctionCode(const char *data) {
bool SBTypeSummary::GetDescription(lldb::SBStream &description,
lldb::DescriptionLevel description_level) {
LLDB_RECORD_METHOD(bool, SBTypeSummary, GetDescription,
(lldb::SBStream &, lldb::DescriptionLevel), description,
description_level);
if (!CopyOnWrite_Impl())
return false;
else {
@ -243,6 +315,9 @@ bool SBTypeSummary::GetDescription(lldb::SBStream &description,
}
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();
@ -250,6 +325,10 @@ bool SBTypeSummary::DoesPrintValue(lldb::SBValue value) {
}
lldb::SBTypeSummary &SBTypeSummary::operator=(const lldb::SBTypeSummary &rhs) {
LLDB_RECORD_METHOD(lldb::SBTypeSummary &,
SBTypeSummary, operator=,(const lldb::SBTypeSummary &),
rhs);
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
}
@ -257,12 +336,18 @@ lldb::SBTypeSummary &SBTypeSummary::operator=(const lldb::SBTypeSummary &rhs) {
}
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())
@ -301,6 +386,9 @@ bool SBTypeSummary::IsEqualTo(lldb::SBTypeSummary &rhs) {
}
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;

67
lldb/source/API/SBTypeSynthetic.cpp
View File

@ -8,6 +8,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBTypeSynthetic.h"
#include "SBReproducerPrivate.h"
#include "lldb/API/SBStream.h"
@ -18,32 +19,51 @@ using namespace lldb_private;
#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();
@ -51,12 +71,16 @@ bool SBTypeSynthetic::IsClassCode() {
}
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())
@ -66,22 +90,30 @@ const char *SBTypeSynthetic::GetData() {
}
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);
@ -89,6 +121,10 @@ void SBTypeSynthetic::SetOptions(uint32_t value) {
bool SBTypeSynthetic::GetDescription(lldb::SBStream &description,
lldb::DescriptionLevel description_level) {
LLDB_RECORD_METHOD(bool, SBTypeSynthetic, GetDescription,
(lldb::SBStream &, lldb::DescriptionLevel), description,
description_level);
if (m_opaque_sp) {
description.Printf("%s\n", m_opaque_sp->GetDescription().c_str());
return true;
@ -98,6 +134,10 @@ bool SBTypeSynthetic::GetDescription(lldb::SBStream &description,
lldb::SBTypeSynthetic &SBTypeSynthetic::
operator=(const lldb::SBTypeSynthetic &rhs) {
LLDB_RECORD_METHOD(lldb::SBTypeSynthetic &,
SBTypeSynthetic, operator=,(const lldb::SBTypeSynthetic &),
rhs);
if (this != &rhs) {
m_opaque_sp = rhs.m_opaque_sp;
}
@ -105,12 +145,18 @@ operator=(const lldb::SBTypeSynthetic &rhs) {
}
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();
@ -127,6 +173,9 @@ bool SBTypeSynthetic::IsEqualTo(lldb::SBTypeSynthetic &rhs) {
}
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;

54
lldb/source/API/SBUnixSignals.cpp
View File

@ -7,6 +7,7 @@
//
//===----------------------------------------------------------------------===//
#include "SBReproducerPrivate.h"
#include "lldb/Target/Platform.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/UnixSignals.h"
@ -18,10 +19,14 @@
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) {}
@ -30,6 +35,10 @@ SBUnixSignals::SBUnixSignals(PlatformSP &platform_sp)
: m_opaque_wp(platform_sp ? platform_sp->GetUnixSignals() : nullptr) {}
const SBUnixSignals &SBUnixSignals::operator=(const SBUnixSignals &rhs) {
LLDB_RECORD_METHOD(const lldb::SBUnixSignals &,
SBUnixSignals, operator=,(const lldb::SBUnixSignals &),
rhs);
if (this != &rhs)
m_opaque_wp = rhs.m_opaque_wp;
return *this;
@ -43,11 +52,22 @@ void SBUnixSignals::SetSP(const UnixSignalsSP &signals_sp) {
m_opaque_wp = signals_sp;
}
void SBUnixSignals::Clear() { m_opaque_wp.reset(); }
void SBUnixSignals::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBUnixSignals, Clear);
bool SBUnixSignals::IsValid() const { return static_cast<bool>(GetSP()); }
m_opaque_wp.reset();
}
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);
@ -55,6 +75,9 @@ const char *SBUnixSignals::GetSignalAsCString(int32_t signo) const {
}
int32_t SBUnixSignals::GetSignalNumberFromName(const char *name) const {
LLDB_RECORD_METHOD_CONST(int32_t, SBUnixSignals, GetSignalNumberFromName,
(const char *), name);
if (auto signals_sp = GetSP())
return signals_sp->GetSignalNumberFromName(name);
@ -62,6 +85,9 @@ int32_t SBUnixSignals::GetSignalNumberFromName(const char *name) const {
}
bool SBUnixSignals::GetShouldSuppress(int32_t signo) const {
LLDB_RECORD_METHOD_CONST(bool, SBUnixSignals, GetShouldSuppress, (int32_t),
signo);
if (auto signals_sp = GetSP())
return signals_sp->GetShouldSuppress(signo);
@ -69,6 +95,9 @@ bool SBUnixSignals::GetShouldSuppress(int32_t signo) const {
}
bool SBUnixSignals::SetShouldSuppress(int32_t signo, bool value) {
LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldSuppress, (int32_t, bool),
signo, value);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
auto signals_sp = GetSP();
@ -84,6 +113,9 @@ bool SBUnixSignals::SetShouldSuppress(int32_t signo, bool value) {
}
bool SBUnixSignals::GetShouldStop(int32_t signo) const {
LLDB_RECORD_METHOD_CONST(bool, SBUnixSignals, GetShouldStop, (int32_t),
signo);
if (auto signals_sp = GetSP())
return signals_sp->GetShouldStop(signo);
@ -91,6 +123,9 @@ bool SBUnixSignals::GetShouldStop(int32_t signo) const {
}
bool SBUnixSignals::SetShouldStop(int32_t signo, bool value) {
LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldStop, (int32_t, bool), signo,
value);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
auto signals_sp = GetSP();
@ -106,6 +141,9 @@ bool SBUnixSignals::SetShouldStop(int32_t signo, bool value) {
}
bool SBUnixSignals::GetShouldNotify(int32_t signo) const {
LLDB_RECORD_METHOD_CONST(bool, SBUnixSignals, GetShouldNotify, (int32_t),
signo);
if (auto signals_sp = GetSP())
return signals_sp->GetShouldNotify(signo);
@ -113,6 +151,9 @@ bool SBUnixSignals::GetShouldNotify(int32_t signo) const {
}
bool SBUnixSignals::SetShouldNotify(int32_t signo, bool value) {
LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldNotify, (int32_t, bool),
signo, value);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
auto signals_sp = GetSP();
@ -128,6 +169,8 @@ bool SBUnixSignals::SetShouldNotify(int32_t signo, bool value) {
}
int32_t SBUnixSignals::GetNumSignals() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(int32_t, SBUnixSignals, GetNumSignals);
if (auto signals_sp = GetSP())
return signals_sp->GetNumSignals();
@ -135,6 +178,9 @@ int32_t SBUnixSignals::GetNumSignals() const {
}
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);

337
lldb/source/API/SBValue.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBValue.h"
#include "SBReproducerPrivate.h"
#include "lldb/API/SBDeclaration.h"
#include "lldb/API/SBStream.h"
@ -219,13 +220,24 @@ private:
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);
}
@ -235,6 +247,8 @@ SBValue &SBValue::operator=(const SBValue &rhs) {
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.
@ -242,9 +256,15 @@ bool SBValue::IsValid() {
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;
@ -255,10 +275,12 @@ SBError SBValue::GetError() {
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)
@ -267,6 +289,8 @@ user_id_t SBValue::GetID() {
}
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));
@ -287,6 +311,8 @@ const char *SBValue::GetName() {
}
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;
@ -308,6 +334,8 @@ const char *SBValue::GetTypeName() {
}
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;
@ -329,6 +357,8 @@ const char *SBValue::GetDisplayTypeName() {
}
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;
@ -347,6 +377,8 @@ size_t SBValue::GetByteSize() {
}
bool SBValue::IsInScope() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsInScope);
bool result = false;
ValueLocker locker;
@ -364,6 +396,8 @@ bool SBValue::IsInScope() {
}
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;
@ -385,6 +419,8 @@ const char *SBValue::GetValue() {
}
ValueType SBValue::GetValueType() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::ValueType, SBValue, GetValueType);
ValueType result = eValueTypeInvalid;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@ -437,6 +473,8 @@ ValueType SBValue::GetValueType() {
}
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;
@ -456,6 +494,8 @@ const char *SBValue::GetObjectDescription() {
}
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;
@ -481,6 +521,8 @@ const char *SBValue::GetTypeValidatorResult() {
}
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;
@ -499,10 +541,12 @@ SBType SBValue::GetType() {
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;
@ -519,6 +563,8 @@ bool SBValue::GetValueDidChange() {
}
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;
@ -539,6 +585,10 @@ const char *SBValue::GetSummary() {
const char *SBValue::GetSummary(lldb::SBStream &stream,
lldb::SBTypeSummaryOptions &options) {
LLDB_RECORD_METHOD(const char *, SBValue, GetSummary,
(lldb::SBStream &, lldb::SBTypeSummaryOptions &), stream,
options);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@ -560,6 +610,8 @@ const char *SBValue::GetSummary(lldb::SBStream &stream,
}
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;
@ -580,11 +632,17 @@ const char *SBValue::GetLocation() {
// Deprecated - use the one that takes an lldb::SBError
bool SBValue::SetValueFromCString(const char *value_str) {
LLDB_RECORD_METHOD(bool, SBValue, SetValueFromCString, (const char *),
value_str);
lldb::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));
@ -603,6 +661,8 @@ bool SBValue::SetValueFromCString(const char *value_str, lldb::SBError &error) {
}
lldb::SBTypeFormat SBValue::GetTypeFormat() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeFormat, SBValue, GetTypeFormat);
lldb::SBTypeFormat format;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@ -613,10 +673,12 @@ lldb::SBTypeFormat SBValue::GetTypeFormat() {
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));
@ -627,10 +689,12 @@ lldb::SBTypeSummary SBValue::GetTypeSummary() {
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));
@ -645,11 +709,13 @@ lldb::SBTypeFilter SBValue::GetTypeFilter() {
}
}
}
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));
@ -664,12 +730,16 @@ lldb::SBTypeSynthetic SBValue::GetTypeSynthetic() {
}
}
}
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));
@ -692,10 +762,12 @@ lldb::SBValue SBValue::CreateChildAtOffset(const char *name, uint32_t offset,
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));
@ -703,19 +775,27 @@ lldb::SBValue SBValue::Cast(SBType type) {
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;
@ -740,12 +820,16 @@ lldb::SBValue SBValue::CreateValueFromExpression(const char *name,
"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));
@ -768,11 +852,15 @@ lldb::SBValue SBValue::CreateValueFromAddress(const char *name,
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;
@ -795,10 +883,12 @@ lldb::SBValue SBValue::CreateValueFromData(const char *name, SBData data,
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;
@ -808,12 +898,17 @@ SBValue SBValue::GetChildAtIndex(uint32_t idx) {
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));
@ -834,10 +929,13 @@ SBValue SBValue::GetChildAtIndex(uint32_t idx,
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));
@ -858,6 +956,9 @@ uint32_t SBValue::GetIndexOfChildWithName(const char *name) {
}
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)
@ -865,12 +966,16 @@ SBValue SBValue::GetChildMemberWithName(const char *name) {
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);
@ -891,20 +996,25 @@ SBValue::GetChildMemberWithName(const char *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(),
@ -912,42 +1022,57 @@ lldb::SBValue SBValue::GetStaticValue() {
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)
@ -956,6 +1081,8 @@ bool SBValue::IsDynamic() {
}
bool SBValue::IsSynthetic() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsSynthetic);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
@ -964,6 +1091,8 @@ bool SBValue::IsSynthetic() {
}
bool SBValue::IsSyntheticChildrenGenerated() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsSyntheticChildrenGenerated);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
@ -972,6 +1101,8 @@ bool SBValue::IsSyntheticChildrenGenerated() {
}
void SBValue::SetSyntheticChildrenGenerated(bool is) {
LLDB_RECORD_METHOD(void, SBValue, SetSyntheticChildrenGenerated, (bool), is);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
@ -979,6 +1110,9 @@ void SBValue::SetSyntheticChildrenGenerated(bool is) {
}
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;
@ -997,10 +1131,13 @@ lldb::SBValue SBValue::GetValueForExpressionPath(const char *expr_path) {
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));
@ -1019,6 +1156,9 @@ int64_t SBValue::GetValueAsSigned(SBError &error, int64_t fail_value) {
}
uint64_t SBValue::GetValueAsUnsigned(SBError &error, uint64_t fail_value) {
LLDB_RECORD_METHOD(uint64_t, SBValue, GetValueAsUnsigned,
(lldb::SBError &, uint64_t), error, fail_value);
error.Clear();
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@ -1037,6 +1177,8 @@ uint64_t SBValue::GetValueAsUnsigned(SBError &error, uint64_t fail_value) {
}
int64_t SBValue::GetValueAsSigned(int64_t fail_value) {
LLDB_RECORD_METHOD(int64_t, SBValue, GetValueAsSigned, (int64_t), fail_value);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
@ -1046,6 +1188,9 @@ int64_t SBValue::GetValueAsSigned(int64_t fail_value) {
}
uint64_t SBValue::GetValueAsUnsigned(uint64_t fail_value) {
LLDB_RECORD_METHOD(uint64_t, SBValue, GetValueAsUnsigned, (uint64_t),
fail_value);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
@ -1055,6 +1200,8 @@ uint64_t SBValue::GetValueAsUnsigned(uint64_t fail_value) {
}
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;
@ -1069,6 +1216,8 @@ bool SBValue::MightHaveChildren() {
}
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;
@ -1082,9 +1231,15 @@ bool SBValue::IsRuntimeSupportValue() {
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));
@ -1101,6 +1256,8 @@ uint32_t SBValue::GetNumChildren(uint32_t max) {
}
SBValue SBValue::Dereference() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, Dereference);
SBValue sb_value;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@ -1114,13 +1271,19 @@ SBValue SBValue::Dereference() {
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)
@ -1129,6 +1292,8 @@ void *SBValue::GetOpaqueType() {
}
lldb::SBTarget SBValue::GetTarget() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBValue, GetTarget);
SBTarget sb_target;
TargetSP target_sp;
if (m_opaque_sp) {
@ -1145,10 +1310,12 @@ lldb::SBTarget SBValue::GetTarget() {
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) {
@ -1165,10 +1332,12 @@ lldb::SBProcess SBValue::GetProcess() {
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) {
@ -1185,10 +1354,12 @@ lldb::SBThread SBValue::GetThread() {
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) {
@ -1205,7 +1376,7 @@ lldb::SBFrame SBValue::GetFrame() {
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 {
@ -1217,8 +1388,10 @@ 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; }
@ -1276,6 +1449,9 @@ void SBValue::SetSP(const lldb::ValueObjectSP &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) {
@ -1287,6 +1463,9 @@ bool SBValue::GetExpressionPath(SBStream &description) {
bool SBValue::GetExpressionPath(SBStream &description,
bool qualify_cxx_base_classes) {
LLDB_RECORD_METHOD(bool, SBValue, GetExpressionPath, (lldb::SBStream &, bool),
description, qualify_cxx_base_classes);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
@ -1296,39 +1475,51 @@ bool SBValue::GetExpressionPath(SBStream &description,
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);
@ -1338,7 +1529,7 @@ lldb::SBValue SBValue::EvaluateExpression(const char *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();
@ -1346,7 +1537,7 @@ lldb::SBValue SBValue::EvaluateExpression(const char *expr,
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());
@ -1356,7 +1547,7 @@ lldb::SBValue SBValue::EvaluateExpression(const char *expr,
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;
@ -1374,10 +1565,13 @@ lldb::SBValue SBValue::EvaluateExpression(const char *expr,
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;
@ -1391,6 +1585,8 @@ bool SBValue::GetDescription(SBStream &description) {
}
lldb::Format SBValue::GetFormat() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::Format, SBValue, GetFormat);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
@ -1399,6 +1595,8 @@ lldb::Format SBValue::GetFormat() {
}
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)
@ -1406,6 +1604,8 @@ void SBValue::SetFormat(lldb::Format format) {
}
lldb::SBValue SBValue::AddressOf() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, AddressOf);
SBValue sb_value;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@ -1420,10 +1620,12 @@ lldb::SBValue SBValue::AddressOf() {
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));
@ -1456,6 +1658,8 @@ lldb::addr_t SBValue::GetLoadAddress() {
}
lldb::SBAddress SBValue::GetAddress() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBValue, GetAddress);
Address addr;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
@ -1485,10 +1689,13 @@ lldb::SBAddress SBValue::GetAddress() {
(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;
@ -1507,10 +1714,12 @@ lldb::SBData SBValue::GetPointeeData(uint32_t item_idx, uint32_t item_count) {
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;
@ -1527,10 +1736,13 @@ lldb::SBData SBValue::GetData() {
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));
@ -1572,6 +1784,8 @@ bool SBValue::SetData(lldb::SBData &data, SBError &error) {
}
lldb::SBDeclaration SBValue::GetDeclaration() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBDeclaration, SBValue, GetDeclaration);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
SBDeclaration decl_sb;
@ -1580,11 +1794,15 @@ lldb::SBDeclaration SBValue::GetDeclaration() {
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.
@ -1594,18 +1812,18 @@ lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read, bool write,
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)
@ -1648,7 +1866,7 @@ lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read, bool write,
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
@ -1656,24 +1874,33 @@ lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read, bool write,
// Backward compatibility fix in the interim.
lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read,
bool write) {
LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBValue, Watch, (bool, bool, bool),
resolve_location, read, write);
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);
}

45
lldb/source/API/SBValueList.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBValueList.h"
#include "SBReproducerPrivate.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBValue.h"
#include "lldb/Core/ValueObjectList.h"
@ -67,9 +68,13 @@ private:
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())
@ -98,11 +103,22 @@ SBValueList::SBValueList(const ValueListImpl *lldb_object_ptr) : m_opaque_up() {
SBValueList::~SBValueList() {}
bool SBValueList::IsValid() const { return (m_opaque_up != NULL); }
bool SBValueList::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBValueList, IsValid);
void SBValueList::Clear() { m_opaque_up.reset(); }
return (m_opaque_up != NULL);
}
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));
@ -123,6 +139,9 @@ const ValueListImpl *SBValueList::operator->() const {
const ValueListImpl &SBValueList::operator*() const { return *m_opaque_up; }
void SBValueList::Append(const SBValue &val_obj) {
LLDB_RECORD_METHOD(void, SBValueList, Append, (const lldb::SBValue &),
val_obj);
CreateIfNeeded();
m_opaque_up->Append(val_obj);
}
@ -135,6 +154,9 @@ void SBValueList::Append(lldb::ValueObjectSP &val_obj_sp) {
}
void SBValueList::Append(const lldb::SBValueList &value_list) {
LLDB_RECORD_METHOD(void, SBValueList, Append, (const lldb::SBValueList &),
value_list);
if (value_list.IsValid()) {
CreateIfNeeded();
m_opaque_up->Append(*value_list);
@ -142,6 +164,9 @@ void SBValueList::Append(const lldb::SBValueList &value_list) {
}
SBValue SBValueList::GetValueAtIndex(uint32_t idx) const {
LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValueList, GetValueAtIndex,
(uint32_t), idx);
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
// if (log)
@ -161,10 +186,12 @@ SBValue SBValueList::GetValueAtIndex(uint32_t idx) const {
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)
@ -187,17 +214,23 @@ void SBValueList::CreateIfNeeded() {
}
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(); }

61
lldb/source/API/SBVariablesOptions.cpp
View File

@ -8,6 +8,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBVariablesOptions.h"
#include "SBReproducerPrivate.h"
#include "lldb/API/SBTarget.h"
#include "lldb/Target/Target.h"
@ -80,76 +81,130 @@ private:
};
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);
}

81
lldb/source/API/SBWatchpoint.cpp
View File

@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBWatchpoint.h"
#include "SBReproducerPrivate.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBDefines.h"
@ -26,10 +27,12 @@
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) {
@ -40,9 +43,14 @@ SBWatchpoint::SBWatchpoint(const lldb::WatchpointSP &wp_sp)
}
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;
}
@ -50,6 +58,8 @@ const SBWatchpoint &SBWatchpoint::operator=(const SBWatchpoint &rhs) {
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;
@ -69,18 +79,26 @@ watch_id_t SBWatchpoint::GetID() {
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());
@ -94,6 +112,8 @@ int32_t SBWatchpoint::GetHardwareIndex() {
}
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());
@ -107,6 +127,8 @@ addr_t SBWatchpoint::GetWatchAddress() {
}
size_t SBWatchpoint::GetWatchSize() {
LLDB_RECORD_METHOD_NO_ARGS(size_t, SBWatchpoint, GetWatchSize);
size_t watch_size = 0;
lldb::WatchpointSP watchpoint_sp(GetSP());
@ -120,6 +142,8 @@ size_t SBWatchpoint::GetWatchSize() {
}
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();
@ -138,6 +162,8 @@ void SBWatchpoint::SetEnabled(bool enabled) {
}
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(
@ -148,6 +174,8 @@ bool SBWatchpoint::IsEnabled() {
}
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) {
@ -165,6 +193,8 @@ uint32_t SBWatchpoint::GetHitCount() {
}
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(
@ -175,6 +205,8 @@ uint32_t SBWatchpoint::GetIgnoreCount() {
}
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(
@ -184,6 +216,8 @@ void SBWatchpoint::SetIgnoreCount(uint32_t n) {
}
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(
@ -194,6 +228,9 @@ const char *SBWatchpoint::GetCondition() {
}
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(
@ -204,6 +241,10 @@ void SBWatchpoint::SetCondition(const char *condition) {
bool SBWatchpoint::GetDescription(SBStream &description,
DescriptionLevel level) {
LLDB_RECORD_METHOD(bool, SBWatchpoint, GetDescription,
(lldb::SBStream &, lldb::DescriptionLevel), description,
level);
Stream &strm = description.ref();
lldb::WatchpointSP watchpoint_sp(GetSP());
@ -218,19 +259,39 @@ bool SBWatchpoint::GetDescription(SBStream &description,
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();
}
void SBWatchpoint::SetSP(const lldb::WatchpointSP &sp) { m_opaque_wp = sp; }
lldb::WatchpointSP SBWatchpoint::GetSP() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::WatchpointSP, SBWatchpoint, GetSP);
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());
@ -238,9 +299,13 @@ SBWatchpoint::GetWatchpointEventTypeFromEvent(const SBEvent &event) {
}
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);
}