diff options
Diffstat (limited to 'contrib/llvm-project/lldb/source/API')
78 files changed, 31440 insertions, 0 deletions
diff --git a/contrib/llvm-project/lldb/source/API/SBAddress.cpp b/contrib/llvm-project/lldb/source/API/SBAddress.cpp new file mode 100644 index 000000000000..6444a006c0ff --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBAddress.cpp @@ -0,0 +1,325 @@ +//===-- SBAddress.cpp -----------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBAddress.h" +#include "SBReproducerPrivate.h" +#include "Utils.h" +#include "lldb/API/SBProcess.h" +#include "lldb/API/SBSection.h" +#include "lldb/API/SBStream.h" +#include "lldb/Core/Address.h" +#include "lldb/Core/Module.h" +#include "lldb/Symbol/LineEntry.h" +#include "lldb/Target/Target.h" +#include "lldb/Utility/StreamString.h" + +using namespace lldb; +using namespace lldb_private; + +SBAddress::SBAddress() : m_opaque_up(new Address()) { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBAddress); +} + +SBAddress::SBAddress(const Address *lldb_object_ptr) + : m_opaque_up(new Address()) { + if (lldb_object_ptr) + m_opaque_up = std::make_unique<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)) { + 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() = default; + +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 LLDB_RECORD_RESULT(*this); +} + +bool lldb::operator==(const SBAddress &lhs, const SBAddress &rhs) { + if (lhs.IsValid() && rhs.IsValid()) + return lhs.ref() == rhs.ref(); + return false; +} + +bool SBAddress::operator!=(const SBAddress &rhs) const { + LLDB_RECORD_METHOD_CONST(bool, SBAddress, operator!=,(const SBAddress &), + &rhs); + + return !(*this == rhs); +} + +bool SBAddress::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBAddress, IsValid); + return this->operator bool(); +} +SBAddress::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBAddress, operator bool); + + return m_opaque_up != nullptr && m_opaque_up->IsValid(); +} + +void SBAddress::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBAddress, Clear); + + m_opaque_up = std::make_unique<Address>(); +} + +void SBAddress::SetAddress(lldb::SBSection section, lldb::addr_t offset) { + LLDB_RECORD_METHOD(void, SBAddress, SetAddress, + (lldb::SBSection, lldb::addr_t), section, offset); + + Address &addr = ref(); + addr.SetSection(section.GetSP()); + addr.SetOffset(offset); +} + +void SBAddress::SetAddress(const Address *lldb_object_ptr) { + if (lldb_object_ptr) + ref() = *lldb_object_ptr; + else + m_opaque_up = std::make_unique<Address>(); +} + +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 + return LLDB_INVALID_ADDRESS; +} + +lldb::addr_t SBAddress::GetLoadAddress(const SBTarget &target) const { + LLDB_RECORD_METHOD_CONST(lldb::addr_t, SBAddress, GetLoadAddress, + (const lldb::SBTarget &), target); + + lldb::addr_t addr = LLDB_INVALID_ADDRESS; + TargetSP target_sp(target.GetSP()); + if (target_sp) { + if (m_opaque_up->IsValid()) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + addr = m_opaque_up->GetLoadAddress(target_sp.get()); + } + } + + return addr; +} + +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()) + *this = target.ResolveLoadAddress(load_addr); + else + m_opaque_up->Clear(); + + // Check if we weren't were able to resolve a section offset address. If we + // weren't it is ok, the load address might be a location on the stack or + // heap, so we should just have an address with no section and a valid offset + if (!m_opaque_up->IsValid()) + m_opaque_up->SetOffset(load_addr); +} + +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) { + m_opaque_up->SetOffset(addr_offset + offset); + return true; + } + } + return false; +} + +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 LLDB_RECORD_RESULT(sb_section); +} + +lldb::addr_t SBAddress::GetOffset() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBAddress, GetOffset); + + if (m_opaque_up->IsValid()) + return m_opaque_up->GetOffset(); + return 0; +} + +Address *SBAddress::operator->() { return m_opaque_up.get(); } + +const Address *SBAddress::operator->() const { return m_opaque_up.get(); } + +Address &SBAddress::ref() { + if (m_opaque_up == nullptr) + m_opaque_up = std::make_unique<Address>(); + return *m_opaque_up; +} + +const Address &SBAddress::ref() const { + // This object should already have checked with "IsValid()" prior to calling + // this function. In case you didn't we will assert and die to let you know. + assert(m_opaque_up.get()); + return *m_opaque_up; +} + +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(); + if (m_opaque_up->IsValid()) { + m_opaque_up->Dump(&strm, nullptr, Address::DumpStyleResolvedDescription, + Address::DumpStyleModuleWithFileAddress, 4); + } else + strm.PutCString("No value"); + + return true; +} + +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 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 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 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 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 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 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 LLDB_RECORD_RESULT(sb_line_entry); +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBAddress>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBAddress, ()); + LLDB_REGISTER_CONSTRUCTOR(SBAddress, (const lldb::SBAddress &)); + LLDB_REGISTER_CONSTRUCTOR(SBAddress, (lldb::SBSection, lldb::addr_t)); + LLDB_REGISTER_CONSTRUCTOR(SBAddress, (lldb::addr_t, lldb::SBTarget &)); + LLDB_REGISTER_METHOD(const lldb::SBAddress &, + SBAddress, operator=,(const lldb::SBAddress &)); + LLDB_REGISTER_METHOD_CONST(bool, + SBAddress, operator!=,(const lldb::SBAddress &)); + LLDB_REGISTER_METHOD_CONST(bool, SBAddress, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBAddress, operator bool, ()); + LLDB_REGISTER_METHOD(void, SBAddress, Clear, ()); + LLDB_REGISTER_METHOD(void, SBAddress, SetAddress, + (lldb::SBSection, lldb::addr_t)); + LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBAddress, GetFileAddress, ()); + LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBAddress, GetLoadAddress, + (const lldb::SBTarget &)); + LLDB_REGISTER_METHOD(void, SBAddress, SetLoadAddress, + (lldb::addr_t, lldb::SBTarget &)); + LLDB_REGISTER_METHOD(bool, SBAddress, OffsetAddress, (lldb::addr_t)); + LLDB_REGISTER_METHOD(lldb::SBSection, SBAddress, GetSection, ()); + LLDB_REGISTER_METHOD(lldb::addr_t, SBAddress, GetOffset, ()); + LLDB_REGISTER_METHOD(bool, SBAddress, GetDescription, (lldb::SBStream &)); + LLDB_REGISTER_METHOD(lldb::SBModule, SBAddress, GetModule, ()); + LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBAddress, GetSymbolContext, + (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBCompileUnit, SBAddress, GetCompileUnit, ()); + LLDB_REGISTER_METHOD(lldb::SBFunction, SBAddress, GetFunction, ()); + LLDB_REGISTER_METHOD(lldb::SBBlock, SBAddress, GetBlock, ()); + LLDB_REGISTER_METHOD(lldb::SBSymbol, SBAddress, GetSymbol, ()); + LLDB_REGISTER_METHOD(lldb::SBLineEntry, SBAddress, GetLineEntry, ()); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBAttachInfo.cpp b/contrib/llvm-project/lldb/source/API/SBAttachInfo.cpp new file mode 100644 index 000000000000..b21589cf2708 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBAttachInfo.cpp @@ -0,0 +1,308 @@ +//===-- SBAttachInfo.cpp --------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBAttachInfo.h" +#include "SBReproducerPrivate.h" +#include "Utils.h" +#include "lldb/API/SBFileSpec.h" +#include "lldb/API/SBListener.h" +#include "lldb/Target/Process.h" + +using namespace lldb; +using namespace lldb_private; + +SBAttachInfo::SBAttachInfo() : m_opaque_sp(new ProcessAttachInfo()) { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBAttachInfo); +} + +SBAttachInfo::SBAttachInfo(lldb::pid_t pid) + : m_opaque_sp(new ProcessAttachInfo()) { + LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (lldb::pid_t), pid); + + m_opaque_sp->SetProcessID(pid); +} + +SBAttachInfo::SBAttachInfo(const char *path, bool wait_for) + : m_opaque_sp(new ProcessAttachInfo()) { + LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (const char *, bool), path, wait_for); + + if (path && path[0]) + m_opaque_sp->GetExecutableFile().SetFile(path, FileSpec::Style::native); + m_opaque_sp->SetWaitForLaunch(wait_for); +} + +SBAttachInfo::SBAttachInfo(const char *path, bool wait_for, bool async) + : m_opaque_sp(new ProcessAttachInfo()) { + LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (const char *, bool, bool), path, + wait_for, async); + + if (path && path[0]) + m_opaque_sp->GetExecutableFile().SetFile(path, FileSpec::Style::native); + m_opaque_sp->SetWaitForLaunch(wait_for); + m_opaque_sp->SetAsync(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); +} + +SBAttachInfo::~SBAttachInfo() = default; + +lldb_private::ProcessAttachInfo &SBAttachInfo::ref() { return *m_opaque_sp; } + +SBAttachInfo &SBAttachInfo::operator=(const SBAttachInfo &rhs) { + LLDB_RECORD_METHOD(lldb::SBAttachInfo &, + SBAttachInfo, operator=,(const lldb::SBAttachInfo &), rhs); + + if (this != &rhs) + m_opaque_sp = clone(rhs.m_opaque_sp); + return LLDB_RECORD_RESULT(*this); +} + +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 + m_opaque_sp->GetExecutableFile().Clear(); +} + +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 + m_opaque_sp->GetExecutableFile().Clear(); +} + +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() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetUserID); + + return m_opaque_sp->GetUserID(); +} + +uint32_t SBAttachInfo::GetGroupID() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetGroupID); + + return m_opaque_sp->GetGroupID(); +} + +bool SBAttachInfo::UserIDIsValid() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, UserIDIsValid); + + 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() { + 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()); +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBAttachInfo>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, ()); + LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (lldb::pid_t)); + LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (const char *, bool)); + LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (const char *, bool, bool)); + LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (const lldb::SBAttachInfo &)); + LLDB_REGISTER_METHOD(lldb::SBAttachInfo &, + SBAttachInfo, operator=,(const lldb::SBAttachInfo &)); + LLDB_REGISTER_METHOD(lldb::pid_t, SBAttachInfo, GetProcessID, ()); + LLDB_REGISTER_METHOD(void, SBAttachInfo, SetProcessID, (lldb::pid_t)); + LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetResumeCount, ()); + LLDB_REGISTER_METHOD(void, SBAttachInfo, SetResumeCount, (uint32_t)); + LLDB_REGISTER_METHOD(const char *, SBAttachInfo, GetProcessPluginName, ()); + LLDB_REGISTER_METHOD(void, SBAttachInfo, SetProcessPluginName, + (const char *)); + LLDB_REGISTER_METHOD(void, SBAttachInfo, SetExecutable, (const char *)); + LLDB_REGISTER_METHOD(void, SBAttachInfo, SetExecutable, (lldb::SBFileSpec)); + LLDB_REGISTER_METHOD(bool, SBAttachInfo, GetWaitForLaunch, ()); + LLDB_REGISTER_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool)); + LLDB_REGISTER_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool, bool)); + LLDB_REGISTER_METHOD(bool, SBAttachInfo, GetIgnoreExisting, ()); + LLDB_REGISTER_METHOD(void, SBAttachInfo, SetIgnoreExisting, (bool)); + LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetUserID, ()); + LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetGroupID, ()); + LLDB_REGISTER_METHOD(bool, SBAttachInfo, UserIDIsValid, ()); + LLDB_REGISTER_METHOD(bool, SBAttachInfo, GroupIDIsValid, ()); + LLDB_REGISTER_METHOD(void, SBAttachInfo, SetUserID, (uint32_t)); + LLDB_REGISTER_METHOD(void, SBAttachInfo, SetGroupID, (uint32_t)); + LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetEffectiveUserID, ()); + LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetEffectiveGroupID, ()); + LLDB_REGISTER_METHOD(bool, SBAttachInfo, EffectiveUserIDIsValid, ()); + LLDB_REGISTER_METHOD(bool, SBAttachInfo, EffectiveGroupIDIsValid, ()); + LLDB_REGISTER_METHOD(void, SBAttachInfo, SetEffectiveUserID, (uint32_t)); + LLDB_REGISTER_METHOD(void, SBAttachInfo, SetEffectiveGroupID, (uint32_t)); + LLDB_REGISTER_METHOD(lldb::pid_t, SBAttachInfo, GetParentProcessID, ()); + LLDB_REGISTER_METHOD(void, SBAttachInfo, SetParentProcessID, (lldb::pid_t)); + LLDB_REGISTER_METHOD(bool, SBAttachInfo, ParentProcessIDIsValid, ()); + LLDB_REGISTER_METHOD(lldb::SBListener, SBAttachInfo, GetListener, ()); + LLDB_REGISTER_METHOD(void, SBAttachInfo, SetListener, (lldb::SBListener &)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBBlock.cpp b/contrib/llvm-project/lldb/source/API/SBBlock.cpp new file mode 100644 index 000000000000..a5fee445d5c6 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBBlock.cpp @@ -0,0 +1,386 @@ +//===-- SBBlock.cpp -------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBBlock.h" +#include "SBReproducerPrivate.h" +#include "lldb/API/SBAddress.h" +#include "lldb/API/SBFileSpec.h" +#include "lldb/API/SBFrame.h" +#include "lldb/API/SBStream.h" +#include "lldb/API/SBValue.h" +#include "lldb/Core/AddressRange.h" +#include "lldb/Core/ValueObjectVariable.h" +#include "lldb/Symbol/Block.h" +#include "lldb/Symbol/Function.h" +#include "lldb/Symbol/SymbolContext.h" +#include "lldb/Symbol/VariableList.h" +#include "lldb/Target/StackFrame.h" +#include "lldb/Target/Target.h" + +using namespace lldb; +using namespace lldb_private; + +SBBlock::SBBlock() : m_opaque_ptr(nullptr) { + 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) { + 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 LLDB_RECORD_RESULT(*this); +} + +SBBlock::~SBBlock() { m_opaque_ptr = nullptr; } + +bool SBBlock::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBlock, IsValid); + return this->operator bool(); +} +SBBlock::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBlock, operator bool); + + return m_opaque_ptr != nullptr; +} + +bool SBBlock::IsInlined() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBlock, IsInlined); + + if (m_opaque_ptr) + return m_opaque_ptr->GetInlinedFunctionInfo() != nullptr; + 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(); + if (inlined_info) { + return inlined_info->GetName().AsCString(nullptr); + } + } + return nullptr; +} + +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 = + m_opaque_ptr->GetInlinedFunctionInfo(); + if (inlined_info) + sb_file.SetFileSpec(inlined_info->GetCallSite().GetFile()); + } + 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(); + if (inlined_info) + return inlined_info->GetCallSite().GetLine(); + } + return 0; +} + +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(); + if (inlined_info) + return inlined_info->GetCallSite().GetColumn(); + } + return 0; +} + +void SBBlock::AppendVariables(bool can_create, bool get_parent_variables, + lldb_private::VariableList *var_list) { + if (IsValid()) { + bool show_inline = true; + m_opaque_ptr->AppendVariables(can_create, get_parent_variables, show_inline, + [](Variable *) { return true; }, var_list); + } +} + +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 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 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 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 LLDB_RECORD_RESULT(sb_block); +} + +lldb_private::Block *SBBlock::GetPtr() { return m_opaque_ptr; } + +void SBBlock::SetPtr(lldb_private::Block *block) { m_opaque_ptr = block; } + +bool SBBlock::GetDescription(SBStream &description) { + LLDB_RECORD_METHOD(bool, SBBlock, GetDescription, (lldb::SBStream &), + description); + + Stream &strm = description.ref(); + + if (m_opaque_ptr) { + lldb::user_id_t id = m_opaque_ptr->GetID(); + strm.Printf("Block: {id: %" PRIu64 "} ", id); + if (IsInlined()) { + strm.Printf(" (inlined, '%s') ", GetInlinedName()); + } + lldb_private::SymbolContext sc; + m_opaque_ptr->CalculateSymbolContext(&sc); + if (sc.function) { + m_opaque_ptr->DumpAddressRanges( + &strm, + sc.function->GetAddressRange().GetBaseAddress().GetFileAddress()); + } + } else + strm.PutCString("No value"); + + return true; +} + +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; + if (m_opaque_ptr->GetRangeAtIndex(idx, range)) { + sb_addr.ref() = range.GetBaseAddress(); + } + } + 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; + if (m_opaque_ptr->GetRangeAtIndex(idx, range)) { + sb_addr.ref() = range.GetBaseAddress(); + sb_addr.ref().Slide(range.GetByteSize()); + } + } + 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()); + } + + return UINT32_MAX; +} + +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) { + StackFrameSP frame_sp(frame.GetFrameSP()); + VariableListSP variable_list_sp(block->GetBlockVariableList(true)); + + if (variable_list_sp) { + const size_t num_variables = variable_list_sp->GetSize(); + if (num_variables) { + for (size_t i = 0; i < num_variables; ++i) { + VariableSP variable_sp(variable_list_sp->GetVariableAtIndex(i)); + if (variable_sp) { + bool add_variable = false; + switch (variable_sp->GetScope()) { + case eValueTypeVariableGlobal: + case eValueTypeVariableStatic: + case eValueTypeVariableThreadLocal: + add_variable = statics; + break; + + case eValueTypeVariableArgument: + add_variable = arguments; + break; + + case eValueTypeVariableLocal: + add_variable = locals; + break; + + default: + break; + } + if (add_variable) { + if (frame_sp) { + lldb::ValueObjectSP valobj_sp( + frame_sp->GetValueObjectForFrameVariable(variable_sp, + eNoDynamicValues)); + SBValue value_sb; + value_sb.SetSP(valobj_sp, use_dynamic); + value_list.Append(value_sb); + } + } + } + } + } + } + } + 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; + if (block) { + TargetSP target_sp(target.GetSP()); + + VariableListSP variable_list_sp(block->GetBlockVariableList(true)); + + if (variable_list_sp) { + const size_t num_variables = variable_list_sp->GetSize(); + if (num_variables) { + for (size_t i = 0; i < num_variables; ++i) { + VariableSP variable_sp(variable_list_sp->GetVariableAtIndex(i)); + if (variable_sp) { + bool add_variable = false; + switch (variable_sp->GetScope()) { + case eValueTypeVariableGlobal: + case eValueTypeVariableStatic: + case eValueTypeVariableThreadLocal: + add_variable = statics; + break; + + case eValueTypeVariableArgument: + add_variable = arguments; + break; + + case eValueTypeVariableLocal: + add_variable = locals; + break; + + default: + break; + } + if (add_variable) { + if (target_sp) + value_list.Append( + ValueObjectVariable::Create(target_sp.get(), variable_sp)); + } + } + } + } + } + } + return LLDB_RECORD_RESULT(value_list); +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBBlock>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBBlock, ()); + LLDB_REGISTER_CONSTRUCTOR(SBBlock, (const lldb::SBBlock &)); + LLDB_REGISTER_METHOD(const lldb::SBBlock &, + SBBlock, operator=,(const lldb::SBBlock &)); + LLDB_REGISTER_METHOD_CONST(bool, SBBlock, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBBlock, operator bool, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBBlock, IsInlined, ()); + LLDB_REGISTER_METHOD_CONST(const char *, SBBlock, GetInlinedName, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBBlock, + GetInlinedCallSiteFile, ()); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBBlock, GetInlinedCallSiteLine, ()); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBBlock, GetInlinedCallSiteColumn, ()); + LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetParent, ()); + LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetContainingInlinedBlock, ()); + LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetSibling, ()); + LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetFirstChild, ()); + LLDB_REGISTER_METHOD(bool, SBBlock, GetDescription, (lldb::SBStream &)); + LLDB_REGISTER_METHOD(uint32_t, SBBlock, GetNumRanges, ()); + LLDB_REGISTER_METHOD(lldb::SBAddress, SBBlock, GetRangeStartAddress, + (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBAddress, SBBlock, GetRangeEndAddress, + (uint32_t)); + LLDB_REGISTER_METHOD(uint32_t, SBBlock, GetRangeIndexForBlockAddress, + (lldb::SBAddress)); + LLDB_REGISTER_METHOD( + lldb::SBValueList, SBBlock, GetVariables, + (lldb::SBFrame &, bool, bool, bool, lldb::DynamicValueType)); + LLDB_REGISTER_METHOD(lldb::SBValueList, SBBlock, GetVariables, + (lldb::SBTarget &, bool, bool, bool)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBBreakpoint.cpp b/contrib/llvm-project/lldb/source/API/SBBreakpoint.cpp new file mode 100644 index 000000000000..eb75bf8b33f4 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBBreakpoint.cpp @@ -0,0 +1,1067 @@ +//===-- SBBreakpoint.cpp --------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBBreakpoint.h" +#include "SBReproducerPrivate.h" +#include "lldb/API/SBBreakpointLocation.h" +#include "lldb/API/SBDebugger.h" +#include "lldb/API/SBEvent.h" +#include "lldb/API/SBProcess.h" +#include "lldb/API/SBStream.h" +#include "lldb/API/SBStringList.h" +#include "lldb/API/SBStructuredData.h" +#include "lldb/API/SBThread.h" + +#include "lldb/Breakpoint/Breakpoint.h" +#include "lldb/Breakpoint/BreakpointIDList.h" +#include "lldb/Breakpoint/BreakpointLocation.h" +#include "lldb/Breakpoint/BreakpointResolver.h" +#include "lldb/Breakpoint/BreakpointResolverScripted.h" +#include "lldb/Breakpoint/StoppointCallbackContext.h" +#include "lldb/Core/Address.h" +#include "lldb/Core/Debugger.h" +#include "lldb/Core/StreamFile.h" +#include "lldb/Core/StructuredDataImpl.h" +#include "lldb/Interpreter/CommandInterpreter.h" +#include "lldb/Interpreter/ScriptInterpreter.h" +#include "lldb/Target/Process.h" +#include "lldb/Target/SectionLoadList.h" +#include "lldb/Target/Target.h" +#include "lldb/Target/Thread.h" +#include "lldb/Target/ThreadSpec.h" +#include "lldb/Utility/Stream.h" + +#include "SBBreakpointOptionCommon.h" + +#include "lldb/lldb-enumerations.h" + +#include "llvm/ADT/STLExtras.h" + +using namespace lldb; +using namespace lldb_private; + +SBBreakpoint::SBBreakpoint() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBreakpoint); } + +SBBreakpoint::SBBreakpoint(const SBBreakpoint &rhs) + : 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) { + 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 LLDB_RECORD_RESULT(*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); + + break_id_t break_id = LLDB_INVALID_BREAK_ID; + BreakpointSP bkpt_sp = GetSP(); + if (bkpt_sp) + break_id = bkpt_sp->GetID(); + + return break_id; +} + +bool SBBreakpoint::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, IsValid); + return this->operator bool(); +} +SBBreakpoint::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, operator bool); + + BreakpointSP bkpt_sp = GetSP(); + if (!bkpt_sp) + return false; + else if (bkpt_sp->GetTarget().GetBreakpointByID(bkpt_sp->GetID())) + return true; + else + return false; +} + +void SBBreakpoint::ClearAllBreakpointSites() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBBreakpoint, ClearAllBreakpointSites); + + BreakpointSP bkpt_sp = GetSP(); + if (bkpt_sp) { + std::lock_guard<std::recursive_mutex> guard( + bkpt_sp->GetTarget().GetAPIMutex()); + bkpt_sp->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(); + if (bkpt_sp) { + if (vm_addr != LLDB_INVALID_ADDRESS) { + std::lock_guard<std::recursive_mutex> guard( + bkpt_sp->GetTarget().GetAPIMutex()); + Address address; + Target &target = bkpt_sp->GetTarget(); + if (!target.GetSectionLoadList().ResolveLoadAddress(vm_addr, address)) { + address.SetRawAddress(vm_addr); + } + sb_bp_location.SetLocation(bkpt_sp->FindLocationByAddress(address)); + } + } + 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(); + + if (bkpt_sp && vm_addr != LLDB_INVALID_ADDRESS) { + std::lock_guard<std::recursive_mutex> guard( + bkpt_sp->GetTarget().GetAPIMutex()); + Address address; + Target &target = bkpt_sp->GetTarget(); + if (!target.GetSectionLoadList().ResolveLoadAddress(vm_addr, address)) { + address.SetRawAddress(vm_addr); + } + break_id = bkpt_sp->FindLocationIDByAddress(address); + } + + return break_id; +} + +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(); + + if (bkpt_sp) { + std::lock_guard<std::recursive_mutex> guard( + bkpt_sp->GetTarget().GetAPIMutex()); + sb_bp_location.SetLocation(bkpt_sp->FindLocationByID(bp_loc_id)); + } + + 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(); + + if (bkpt_sp) { + std::lock_guard<std::recursive_mutex> guard( + bkpt_sp->GetTarget().GetAPIMutex()); + sb_bp_location.SetLocation(bkpt_sp->GetLocationAtIndex(index)); + } + + return LLDB_RECORD_RESULT(sb_bp_location); +} + +void SBBreakpoint::SetEnabled(bool enable) { + LLDB_RECORD_METHOD(void, SBBreakpoint, SetEnabled, (bool), enable); + + BreakpointSP bkpt_sp = GetSP(); + + if (bkpt_sp) { + std::lock_guard<std::recursive_mutex> guard( + bkpt_sp->GetTarget().GetAPIMutex()); + bkpt_sp->SetEnabled(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( + bkpt_sp->GetTarget().GetAPIMutex()); + return bkpt_sp->IsEnabled(); + } else + return false; +} + +void SBBreakpoint::SetOneShot(bool one_shot) { + LLDB_RECORD_METHOD(void, SBBreakpoint, SetOneShot, (bool), one_shot); + + BreakpointSP bkpt_sp = GetSP(); + + if (bkpt_sp) { + std::lock_guard<std::recursive_mutex> guard( + bkpt_sp->GetTarget().GetAPIMutex()); + bkpt_sp->SetOneShot(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( + bkpt_sp->GetTarget().GetAPIMutex()); + return bkpt_sp->IsOneShot(); + } else + return false; +} + +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( + bkpt_sp->GetTarget().GetAPIMutex()); + return bkpt_sp->IsInternal(); + } else + return false; +} + +void SBBreakpoint::SetIgnoreCount(uint32_t count) { + LLDB_RECORD_METHOD(void, SBBreakpoint, SetIgnoreCount, (uint32_t), count); + + BreakpointSP bkpt_sp = GetSP(); + + if (bkpt_sp) { + std::lock_guard<std::recursive_mutex> guard( + bkpt_sp->GetTarget().GetAPIMutex()); + bkpt_sp->SetIgnoreCount(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( + bkpt_sp->GetTarget().GetAPIMutex()); + bkpt_sp->SetCondition(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( + bkpt_sp->GetTarget().GetAPIMutex()); + return bkpt_sp->GetConditionText(); + } + return nullptr; +} + +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( + bkpt_sp->GetTarget().GetAPIMutex()); + bkpt_sp->SetAutoContinue(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( + bkpt_sp->GetTarget().GetAPIMutex()); + return bkpt_sp->IsAutoContinue(); + } + return false; +} + +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) { + std::lock_guard<std::recursive_mutex> guard( + bkpt_sp->GetTarget().GetAPIMutex()); + count = bkpt_sp->GetHitCount(); + } + + return count; +} + +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) { + std::lock_guard<std::recursive_mutex> guard( + bkpt_sp->GetTarget().GetAPIMutex()); + count = bkpt_sp->GetIgnoreCount(); + } + + return count; +} + +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( + bkpt_sp->GetTarget().GetAPIMutex()); + bkpt_sp->SetThreadID(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) { + std::lock_guard<std::recursive_mutex> guard( + bkpt_sp->GetTarget().GetAPIMutex()); + tid = bkpt_sp->GetThreadID(); + } + + return tid; +} + +void SBBreakpoint::SetThreadIndex(uint32_t index) { + LLDB_RECORD_METHOD(void, SBBreakpoint, SetThreadIndex, (uint32_t), index); + + BreakpointSP bkpt_sp = GetSP(); + if (bkpt_sp) { + std::lock_guard<std::recursive_mutex> guard( + bkpt_sp->GetTarget().GetAPIMutex()); + bkpt_sp->GetOptions()->GetThreadSpec()->SetIndex(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) { + std::lock_guard<std::recursive_mutex> guard( + bkpt_sp->GetTarget().GetAPIMutex()); + const ThreadSpec *thread_spec = + bkpt_sp->GetOptions()->GetThreadSpecNoCreate(); + if (thread_spec != nullptr) + thread_idx = thread_spec->GetIndex(); + } + + return thread_idx; +} + +void SBBreakpoint::SetThreadName(const char *thread_name) { + LLDB_RECORD_METHOD(void, SBBreakpoint, SetThreadName, (const char *), + thread_name); + + BreakpointSP bkpt_sp = GetSP(); + + if (bkpt_sp) { + std::lock_guard<std::recursive_mutex> guard( + bkpt_sp->GetTarget().GetAPIMutex()); + bkpt_sp->GetOptions()->GetThreadSpec()->SetName(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) { + std::lock_guard<std::recursive_mutex> guard( + bkpt_sp->GetTarget().GetAPIMutex()); + const ThreadSpec *thread_spec = + bkpt_sp->GetOptions()->GetThreadSpecNoCreate(); + if (thread_spec != nullptr) + name = thread_spec->GetName(); + } + + return name; +} + +void SBBreakpoint::SetQueueName(const char *queue_name) { + LLDB_RECORD_METHOD(void, SBBreakpoint, SetQueueName, (const char *), + queue_name); + + BreakpointSP bkpt_sp = GetSP(); + if (bkpt_sp) { + std::lock_guard<std::recursive_mutex> guard( + bkpt_sp->GetTarget().GetAPIMutex()); + bkpt_sp->GetOptions()->GetThreadSpec()->SetQueueName(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) { + std::lock_guard<std::recursive_mutex> guard( + bkpt_sp->GetTarget().GetAPIMutex()); + const ThreadSpec *thread_spec = + bkpt_sp->GetOptions()->GetThreadSpecNoCreate(); + if (thread_spec) + name = thread_spec->GetQueueName(); + } + + return name; +} + +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) { + std::lock_guard<std::recursive_mutex> guard( + bkpt_sp->GetTarget().GetAPIMutex()); + num_resolved = bkpt_sp->GetNumResolvedLocations(); + } + return num_resolved; +} + +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) { + std::lock_guard<std::recursive_mutex> guard( + bkpt_sp->GetTarget().GetAPIMutex()); + num_locs = bkpt_sp->GetNumLocations(); + } + return num_locs; +} + +void SBBreakpoint::SetCommandLineCommands(SBStringList &commands) { + LLDB_RECORD_METHOD(void, SBBreakpoint, SetCommandLineCommands, + (lldb::SBStringList &), commands); + + BreakpointSP bkpt_sp = GetSP(); + if (!bkpt_sp) + return; + if (commands.GetSize() == 0) + return; + + std::lock_guard<std::recursive_mutex> guard( + bkpt_sp->GetTarget().GetAPIMutex()); + std::unique_ptr<BreakpointOptions::CommandData> cmd_data_up( + new BreakpointOptions::CommandData(*commands, eScriptLanguageNone)); + + bkpt_sp->GetOptions()->SetCommandDataCallback(cmd_data_up); +} + +bool SBBreakpoint::GetCommandLineCommands(SBStringList &commands) { + LLDB_RECORD_METHOD(bool, SBBreakpoint, GetCommandLineCommands, + (lldb::SBStringList &), commands); + + BreakpointSP bkpt_sp = GetSP(); + if (!bkpt_sp) + return false; + StringList command_list; + bool has_commands = + bkpt_sp->GetOptions()->GetCommandLineCallbacks(command_list); + if (has_commands) + commands.AppendList(command_list); + return has_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( + bkpt_sp->GetTarget().GetAPIMutex()); + s.Printf("SBBreakpoint: id = %i, ", bkpt_sp->GetID()); + bkpt_sp->GetResolverDescription(s.get()); + bkpt_sp->GetFilterDescription(s.get()); + if (include_locations) { + const size_t num_locations = bkpt_sp->GetNumLocations(); + s.Printf(", locations = %" PRIu64, (uint64_t)num_locations); + } + return true; + } + s.Printf("No value"); + return false; +} + +SBError SBBreakpoint::AddLocation(SBAddress &address) { + LLDB_RECORD_METHOD(lldb::SBError, SBBreakpoint, AddLocation, + (lldb::SBAddress &), address); + + BreakpointSP bkpt_sp = GetSP(); + SBError error; + + if (!address.IsValid()) { + error.SetErrorString("Can't add an invalid address."); + return LLDB_RECORD_RESULT(error); + } + + if (!bkpt_sp) { + error.SetErrorString("No breakpoint to add a location to."); + return LLDB_RECORD_RESULT(error); + } + + if (!llvm::isa<BreakpointResolverScripted>(bkpt_sp->GetResolver().get())) { + error.SetErrorString("Only a scripted resolver can add locations."); + return LLDB_RECORD_RESULT(error); + } + + if (bkpt_sp->GetSearchFilter()->AddressPasses(address.ref())) + bkpt_sp->AddLocation(address.ref()); + else { + StreamString s; + address.get()->Dump(&s, &bkpt_sp->GetTarget(), + Address::DumpStyleModuleWithFileAddress); + error.SetErrorStringWithFormat("Address: %s didn't pass the filter.", + s.GetData()); + } + return LLDB_RECORD_RESULT(error); +} + +void SBBreakpoint ::SetCallback(SBBreakpointHitCallback callback, void *baton) { + LLDB_RECORD_DUMMY(void, SBBreakpoint, SetCallback, + (lldb::SBBreakpointHitCallback, void *), callback, baton); + + BreakpointSP bkpt_sp = GetSP(); + + if (bkpt_sp) { + std::lock_guard<std::recursive_mutex> guard( + bkpt_sp->GetTarget().GetAPIMutex()); + BatonSP baton_sp(new SBBreakpointCallbackBaton(callback, baton)); + bkpt_sp->SetCallback(SBBreakpointCallbackBaton + ::PrivateBreakpointHitCallback, baton_sp, + false); + } +} + +void SBBreakpoint::SetScriptCallbackFunction( + const char *callback_function_name) { +LLDB_RECORD_METHOD(void, SBBreakpoint, SetScriptCallbackFunction, + (const char *), callback_function_name); + SBStructuredData empty_args; + SetScriptCallbackFunction(callback_function_name, empty_args); +} + +SBError SBBreakpoint::SetScriptCallbackFunction( + const char *callback_function_name, + SBStructuredData &extra_args) { + LLDB_RECORD_METHOD(SBError, SBBreakpoint, SetScriptCallbackFunction, + (const char *, SBStructuredData &), callback_function_name, extra_args); + SBError sb_error; + BreakpointSP bkpt_sp = GetSP(); + + if (bkpt_sp) { + Status error; + std::lock_guard<std::recursive_mutex> guard( + bkpt_sp->GetTarget().GetAPIMutex()); + BreakpointOptions *bp_options = bkpt_sp->GetOptions(); + error = bkpt_sp->GetTarget() + .GetDebugger() + .GetScriptInterpreter() + ->SetBreakpointCommandCallbackFunction(bp_options, + callback_function_name, + extra_args.m_impl_up + ->GetObjectSP()); + sb_error.SetError(error); + } else + sb_error.SetErrorString("invalid breakpoint"); + + return LLDB_RECORD_RESULT(sb_error); +} + +SBError SBBreakpoint::SetScriptCallbackBody(const char *callback_body_text) { + LLDB_RECORD_METHOD(lldb::SBError, SBBreakpoint, SetScriptCallbackBody, + (const char *), callback_body_text); + + BreakpointSP bkpt_sp = GetSP(); + + SBError sb_error; + if (bkpt_sp) { + std::lock_guard<std::recursive_mutex> guard( + bkpt_sp->GetTarget().GetAPIMutex()); + BreakpointOptions *bp_options = bkpt_sp->GetOptions(); + Status error = + bkpt_sp->GetTarget() + .GetDebugger() + .GetScriptInterpreter() + ->SetBreakpointCommandCallback(bp_options, callback_body_text); + sb_error.SetError(error); + } else + sb_error.SetErrorString("invalid breakpoint"); + + return LLDB_RECORD_RESULT(sb_error); +} + +bool SBBreakpoint::AddName(const char *new_name) { + LLDB_RECORD_METHOD(bool, SBBreakpoint, AddName, (const char *), new_name); + + SBError status = AddNameWithErrorHandling(new_name); + return status.Success(); +} + +SBError SBBreakpoint::AddNameWithErrorHandling(const char *new_name) { + LLDB_RECORD_METHOD(SBError, SBBreakpoint, AddNameWithErrorHandling, + (const char *), new_name); + + BreakpointSP bkpt_sp = GetSP(); + + SBError status; + if (bkpt_sp) { + std::lock_guard<std::recursive_mutex> guard( + bkpt_sp->GetTarget().GetAPIMutex()); + Status error; + bkpt_sp->GetTarget().AddNameToBreakpoint(bkpt_sp, new_name, error); + status.SetError(error); + } else { + status.SetErrorString("invalid breakpoint"); + } + + return LLDB_RECORD_RESULT(status); +} + +void SBBreakpoint::RemoveName(const char *name_to_remove) { + LLDB_RECORD_METHOD(void, SBBreakpoint, RemoveName, (const char *), + name_to_remove); + + BreakpointSP bkpt_sp = GetSP(); + + if (bkpt_sp) { + std::lock_guard<std::recursive_mutex> guard( + bkpt_sp->GetTarget().GetAPIMutex()); + bkpt_sp->GetTarget().RemoveNameFromBreakpoint(bkpt_sp, + ConstString(name_to_remove)); + } +} + +bool SBBreakpoint::MatchesName(const char *name) { + LLDB_RECORD_METHOD(bool, SBBreakpoint, MatchesName, (const char *), name); + + BreakpointSP bkpt_sp = GetSP(); + + if (bkpt_sp) { + std::lock_guard<std::recursive_mutex> guard( + bkpt_sp->GetTarget().GetAPIMutex()); + return bkpt_sp->MatchesName(name); + } + + return false; +} + +void SBBreakpoint::GetNames(SBStringList &names) { + LLDB_RECORD_METHOD(void, SBBreakpoint, GetNames, (lldb::SBStringList &), + names); + + BreakpointSP bkpt_sp = GetSP(); + + if (bkpt_sp) { + std::lock_guard<std::recursive_mutex> guard( + bkpt_sp->GetTarget().GetAPIMutex()); + std::vector<std::string> names_vec; + bkpt_sp->GetNames(names_vec); + for (std::string name : names_vec) { + names.AppendString(name.c_str()); + } + } +} + +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()); + return eBreakpointEventTypeInvalidType; +} + +SBBreakpoint SBBreakpoint::GetBreakpointFromEvent(const lldb::SBEvent &event) { + LLDB_RECORD_STATIC_METHOD(lldb::SBBreakpoint, SBBreakpoint, + GetBreakpointFromEvent, (const lldb::SBEvent &), + event); + + if (event.IsValid()) + 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 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 = + (Breakpoint::BreakpointEventData::GetNumBreakpointLocationsFromEvent( + event.GetSP())); + return num_locations; +} + +bool SBBreakpoint::IsHardware() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, IsHardware); + + BreakpointSP bkpt_sp = GetSP(); + if (bkpt_sp) + return bkpt_sp->IsHardware(); + return false; +} + +BreakpointSP SBBreakpoint::GetSP() const { return m_opaque_wp.lock(); } + +// This is simple collection of breakpoint id's and their target. +class SBBreakpointListImpl { +public: + SBBreakpointListImpl(lldb::TargetSP target_sp) : m_target_wp() { + if (target_sp && target_sp->IsValid()) + m_target_wp = target_sp; + } + + ~SBBreakpointListImpl() = default; + + size_t GetSize() { return m_break_ids.size(); } + + BreakpointSP GetBreakpointAtIndex(size_t idx) { + if (idx >= m_break_ids.size()) + return BreakpointSP(); + TargetSP target_sp = m_target_wp.lock(); + if (!target_sp) + return BreakpointSP(); + lldb::break_id_t bp_id = m_break_ids[idx]; + return target_sp->GetBreakpointList().FindBreakpointByID(bp_id); + } + + BreakpointSP FindBreakpointByID(lldb::break_id_t desired_id) { + TargetSP target_sp = m_target_wp.lock(); + if (!target_sp) + return BreakpointSP(); + + for (lldb::break_id_t &break_id : m_break_ids) { + if (break_id == desired_id) + return target_sp->GetBreakpointList().FindBreakpointByID(break_id); + } + return BreakpointSP(); + } + + bool Append(BreakpointSP bkpt) { + TargetSP target_sp = m_target_wp.lock(); + if (!target_sp || !bkpt) + return false; + if (bkpt->GetTargetSP() != target_sp) + return false; + m_break_ids.push_back(bkpt->GetID()); + return true; + } + + bool AppendIfUnique(BreakpointSP bkpt) { + TargetSP target_sp = m_target_wp.lock(); + if (!target_sp || !bkpt) + return false; + if (bkpt->GetTargetSP() != target_sp) + return false; + lldb::break_id_t bp_id = bkpt->GetID(); + if (find(m_break_ids.begin(), m_break_ids.end(), bp_id) == + m_break_ids.end()) + return false; + + m_break_ids.push_back(bkpt->GetID()); + return true; + } + + bool AppendByID(lldb::break_id_t id) { + TargetSP target_sp = m_target_wp.lock(); + if (!target_sp) + return false; + if (id == LLDB_INVALID_BREAK_ID) + return false; + m_break_ids.push_back(id); + return true; + } + + void Clear() { m_break_ids.clear(); } + + void CopyToBreakpointIDList(lldb_private::BreakpointIDList &bp_list) { + for (lldb::break_id_t id : m_break_ids) { + bp_list.AddBreakpointID(BreakpointID(id)); + } + } + + TargetSP GetTarget() { return m_target_wp.lock(); } + +private: + std::vector<lldb::break_id_t> m_break_ids; + TargetWP m_target_wp; +}; + +SBBreakpointList::SBBreakpointList(SBTarget &target) + : m_opaque_sp(new SBBreakpointListImpl(target.GetSP())) { + LLDB_RECORD_CONSTRUCTOR(SBBreakpointList, (lldb::SBTarget &), target); +} + +SBBreakpointList::~SBBreakpointList() = default; + +size_t SBBreakpointList::GetSize() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBBreakpointList, GetSize); + + if (!m_opaque_sp) + return 0; + else + return m_opaque_sp->GetSize(); +} + +SBBreakpoint SBBreakpointList::GetBreakpointAtIndex(size_t idx) { + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBBreakpointList, GetBreakpointAtIndex, + (size_t), idx); + + if (!m_opaque_sp) + return LLDB_RECORD_RESULT(SBBreakpoint()); + + BreakpointSP bkpt_sp = m_opaque_sp->GetBreakpointAtIndex(idx); + 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 LLDB_RECORD_RESULT(SBBreakpoint()); + BreakpointSP bkpt_sp = m_opaque_sp->FindBreakpointByID(id); + 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) + return; + m_opaque_sp->Append(sb_bkpt.m_opaque_wp.lock()); +} + +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) + return false; + return m_opaque_sp->AppendIfUnique(sb_bkpt.GetSP()); +} + +void SBBreakpointList::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBBreakpointList, Clear); + + if (m_opaque_sp) + m_opaque_sp->Clear(); +} + +void SBBreakpointList::CopyToBreakpointIDList( + lldb_private::BreakpointIDList &bp_id_list) { + if (m_opaque_sp) + m_opaque_sp->CopyToBreakpointIDList(bp_id_list); +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBBreakpoint>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBBreakpoint, ()); + LLDB_REGISTER_CONSTRUCTOR(SBBreakpoint, (const lldb::SBBreakpoint &)); + LLDB_REGISTER_CONSTRUCTOR(SBBreakpoint, (const lldb::BreakpointSP &)); + LLDB_REGISTER_METHOD(const lldb::SBBreakpoint &, + SBBreakpoint, operator=,(const lldb::SBBreakpoint &)); + LLDB_REGISTER_METHOD(bool, + SBBreakpoint, operator==,(const lldb::SBBreakpoint &)); + LLDB_REGISTER_METHOD(bool, + SBBreakpoint, operator!=,(const lldb::SBBreakpoint &)); + LLDB_REGISTER_METHOD_CONST(lldb::break_id_t, SBBreakpoint, GetID, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, operator bool, ()); + LLDB_REGISTER_METHOD(void, SBBreakpoint, ClearAllBreakpointSites, ()); + LLDB_REGISTER_METHOD(lldb::SBBreakpointLocation, SBBreakpoint, + FindLocationByAddress, (lldb::addr_t)); + LLDB_REGISTER_METHOD(lldb::break_id_t, SBBreakpoint, + FindLocationIDByAddress, (lldb::addr_t)); + LLDB_REGISTER_METHOD(lldb::SBBreakpointLocation, SBBreakpoint, + FindLocationByID, (lldb::break_id_t)); + LLDB_REGISTER_METHOD(lldb::SBBreakpointLocation, SBBreakpoint, + GetLocationAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(void, SBBreakpoint, SetEnabled, (bool)); + LLDB_REGISTER_METHOD(bool, SBBreakpoint, IsEnabled, ()); + LLDB_REGISTER_METHOD(void, SBBreakpoint, SetOneShot, (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, IsOneShot, ()); + LLDB_REGISTER_METHOD(bool, SBBreakpoint, IsInternal, ()); + LLDB_REGISTER_METHOD(void, SBBreakpoint, SetIgnoreCount, (uint32_t)); + LLDB_REGISTER_METHOD(void, SBBreakpoint, SetCondition, (const char *)); + LLDB_REGISTER_METHOD(const char *, SBBreakpoint, GetCondition, ()); + LLDB_REGISTER_METHOD(void, SBBreakpoint, SetAutoContinue, (bool)); + LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetAutoContinue, ()); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpoint, GetHitCount, ()); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpoint, GetIgnoreCount, ()); + LLDB_REGISTER_METHOD(void, SBBreakpoint, SetThreadID, (lldb::tid_t)); + LLDB_REGISTER_METHOD(lldb::tid_t, SBBreakpoint, GetThreadID, ()); + LLDB_REGISTER_METHOD(void, SBBreakpoint, SetThreadIndex, (uint32_t)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpoint, GetThreadIndex, ()); + LLDB_REGISTER_METHOD(void, SBBreakpoint, SetThreadName, (const char *)); + LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpoint, GetThreadName, ()); + LLDB_REGISTER_METHOD(void, SBBreakpoint, SetQueueName, (const char *)); + LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpoint, GetQueueName, ()); + LLDB_REGISTER_METHOD_CONST(size_t, SBBreakpoint, GetNumResolvedLocations, + ()); + LLDB_REGISTER_METHOD_CONST(size_t, SBBreakpoint, GetNumLocations, ()); + LLDB_REGISTER_METHOD(void, SBBreakpoint, SetCommandLineCommands, + (lldb::SBStringList &)); + LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetCommandLineCommands, + (lldb::SBStringList &)); + LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetDescription, + (lldb::SBStream &)); + LLDB_REGISTER_METHOD(bool, SBBreakpoint, GetDescription, + (lldb::SBStream &, bool)); + LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpoint, AddLocation, + (lldb::SBAddress &)); + LLDB_REGISTER_METHOD(void, SBBreakpoint, SetScriptCallbackFunction, + (const char *)); + LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpoint, SetScriptCallbackFunction, + (const char *, SBStructuredData &)); + LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpoint, SetScriptCallbackBody, + (const char *)); + LLDB_REGISTER_METHOD(bool, SBBreakpoint, AddName, (const char *)); + LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpoint, AddNameWithErrorHandling, + (const char *)); + LLDB_REGISTER_METHOD(void, SBBreakpoint, RemoveName, (const char *)); + LLDB_REGISTER_METHOD(bool, SBBreakpoint, MatchesName, (const char *)); + LLDB_REGISTER_METHOD(void, SBBreakpoint, GetNames, (lldb::SBStringList &)); + LLDB_REGISTER_STATIC_METHOD(bool, SBBreakpoint, EventIsBreakpointEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_STATIC_METHOD(lldb::BreakpointEventType, SBBreakpoint, + GetBreakpointEventTypeFromEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBBreakpoint, SBBreakpoint, + GetBreakpointFromEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBBreakpointLocation, SBBreakpoint, + GetBreakpointLocationAtIndexFromEvent, + (const lldb::SBEvent &, uint32_t)); + LLDB_REGISTER_STATIC_METHOD(uint32_t, SBBreakpoint, + GetNumBreakpointLocationsFromEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, IsHardware, ()); +} + +template <> +void RegisterMethods<SBBreakpointList>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBBreakpointList, (lldb::SBTarget &)); + LLDB_REGISTER_METHOD_CONST(size_t, SBBreakpointList, GetSize, ()); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBBreakpointList, + GetBreakpointAtIndex, (size_t)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBBreakpointList, + FindBreakpointByID, (lldb::break_id_t)); + LLDB_REGISTER_METHOD(void, SBBreakpointList, Append, + (const lldb::SBBreakpoint &)); + LLDB_REGISTER_METHOD(void, SBBreakpointList, AppendByID, + (lldb::break_id_t)); + LLDB_REGISTER_METHOD(bool, SBBreakpointList, AppendIfUnique, + (const lldb::SBBreakpoint &)); + LLDB_REGISTER_METHOD(void, SBBreakpointList, Clear, ()); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBBreakpointLocation.cpp b/contrib/llvm-project/lldb/source/API/SBBreakpointLocation.cpp new file mode 100644 index 000000000000..e29f3fd9c50e --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBBreakpointLocation.cpp @@ -0,0 +1,534 @@ +//===-- SBBreakpointLocation.cpp ------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBBreakpointLocation.h" +#include "SBReproducerPrivate.h" +#include "lldb/API/SBAddress.h" +#include "lldb/API/SBDebugger.h" +#include "lldb/API/SBDefines.h" +#include "lldb/API/SBStream.h" +#include "lldb/API/SBStructuredData.h" +#include "lldb/API/SBStringList.h" + +#include "lldb/Breakpoint/Breakpoint.h" +#include "lldb/Breakpoint/BreakpointLocation.h" +#include "lldb/Core/Debugger.h" +#include "lldb/Core/StreamFile.h" +#include "lldb/Core/StructuredDataImpl.h" +#include "lldb/Interpreter/CommandInterpreter.h" +#include "lldb/Interpreter/ScriptInterpreter.h" +#include "lldb/Target/Target.h" +#include "lldb/Target/ThreadSpec.h" +#include "lldb/Utility/Stream.h" +#include "lldb/lldb-defines.h" +#include "lldb/lldb-types.h" + +using namespace lldb; +using namespace lldb_private; + +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); +} + +SBBreakpointLocation::SBBreakpointLocation(const SBBreakpointLocation &rhs) + : 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 LLDB_RECORD_RESULT(*this); +} + +SBBreakpointLocation::~SBBreakpointLocation() = default; + +BreakpointLocationSP SBBreakpointLocation::GetSP() const { + return m_opaque_wp.lock(); +} + +bool SBBreakpointLocation::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointLocation, IsValid); + return this->operator bool(); +} +SBBreakpointLocation::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointLocation, operator bool); + + return bool(GetSP()); +} + +SBAddress SBBreakpointLocation::GetAddress() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBBreakpointLocation, GetAddress); + + BreakpointLocationSP loc_sp = GetSP(); + 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(); + + if (loc_sp) { + std::lock_guard<std::recursive_mutex> guard( + loc_sp->GetTarget().GetAPIMutex()); + ret_addr = loc_sp->GetLoadAddress(); + } + + return ret_addr; +} + +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( + loc_sp->GetTarget().GetAPIMutex()); + loc_sp->SetEnabled(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( + loc_sp->GetTarget().GetAPIMutex()); + return loc_sp->IsEnabled(); + } else + return false; +} + +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( + loc_sp->GetTarget().GetAPIMutex()); + return loc_sp->GetHitCount(); + } else + return 0; +} + +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( + loc_sp->GetTarget().GetAPIMutex()); + return loc_sp->GetIgnoreCount(); + } else + return 0; +} + +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( + loc_sp->GetTarget().GetAPIMutex()); + loc_sp->SetIgnoreCount(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( + loc_sp->GetTarget().GetAPIMutex()); + loc_sp->SetCondition(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( + loc_sp->GetTarget().GetAPIMutex()); + return loc_sp->GetConditionText(); + } + return nullptr; +} + +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( + loc_sp->GetTarget().GetAPIMutex()); + loc_sp->SetAutoContinue(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( + loc_sp->GetTarget().GetAPIMutex()); + return loc_sp->IsAutoContinue(); + } + return false; +} + +void SBBreakpointLocation::SetScriptCallbackFunction( + const char *callback_function_name) { +LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetScriptCallbackFunction, + (const char *), callback_function_name); +} + +SBError SBBreakpointLocation::SetScriptCallbackFunction( + const char *callback_function_name, + SBStructuredData &extra_args) { + LLDB_RECORD_METHOD(SBError, SBBreakpointLocation, SetScriptCallbackFunction, + (const char *, SBStructuredData &), + callback_function_name, extra_args); + SBError sb_error; + BreakpointLocationSP loc_sp = GetSP(); + + if (loc_sp) { + Status error; + std::lock_guard<std::recursive_mutex> guard( + loc_sp->GetTarget().GetAPIMutex()); + BreakpointOptions *bp_options = loc_sp->GetLocationOptions(); + error = loc_sp->GetBreakpoint() + .GetTarget() + .GetDebugger() + .GetScriptInterpreter() + ->SetBreakpointCommandCallbackFunction(bp_options, + callback_function_name, + extra_args.m_impl_up + ->GetObjectSP()); + sb_error.SetError(error); + } else + sb_error.SetErrorString("invalid breakpoint"); + + return LLDB_RECORD_RESULT(sb_error); +} + +SBError +SBBreakpointLocation::SetScriptCallbackBody(const char *callback_body_text) { + LLDB_RECORD_METHOD(lldb::SBError, SBBreakpointLocation, SetScriptCallbackBody, + (const char *), callback_body_text); + + BreakpointLocationSP loc_sp = GetSP(); + + SBError sb_error; + if (loc_sp) { + std::lock_guard<std::recursive_mutex> guard( + loc_sp->GetTarget().GetAPIMutex()); + BreakpointOptions *bp_options = loc_sp->GetLocationOptions(); + Status error = + loc_sp->GetBreakpoint() + .GetTarget() + .GetDebugger() + .GetScriptInterpreter() + ->SetBreakpointCommandCallback(bp_options, callback_body_text); + sb_error.SetError(error); + } else + sb_error.SetErrorString("invalid breakpoint"); + + 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; + if (commands.GetSize() == 0) + return; + + std::lock_guard<std::recursive_mutex> guard( + loc_sp->GetTarget().GetAPIMutex()); + std::unique_ptr<BreakpointOptions::CommandData> cmd_data_up( + new BreakpointOptions::CommandData(*commands, eScriptLanguageNone)); + + loc_sp->GetLocationOptions()->SetCommandDataCallback(cmd_data_up); +} + +bool SBBreakpointLocation::GetCommandLineCommands(SBStringList &commands) { + LLDB_RECORD_METHOD(bool, SBBreakpointLocation, GetCommandLineCommands, + (lldb::SBStringList &), commands); + + BreakpointLocationSP loc_sp = GetSP(); + if (!loc_sp) + return false; + StringList command_list; + bool has_commands = + loc_sp->GetLocationOptions()->GetCommandLineCallbacks(command_list); + if (has_commands) + commands.AppendList(command_list); + return has_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( + loc_sp->GetTarget().GetAPIMutex()); + loc_sp->SetThreadID(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) { + std::lock_guard<std::recursive_mutex> guard( + loc_sp->GetTarget().GetAPIMutex()); + return loc_sp->GetThreadID(); + } + return tid; +} + +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( + loc_sp->GetTarget().GetAPIMutex()); + loc_sp->SetThreadIndex(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) { + std::lock_guard<std::recursive_mutex> guard( + loc_sp->GetTarget().GetAPIMutex()); + return loc_sp->GetThreadIndex(); + } + return thread_idx; +} + +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( + loc_sp->GetTarget().GetAPIMutex()); + loc_sp->SetThreadName(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( + loc_sp->GetTarget().GetAPIMutex()); + return loc_sp->GetThreadName(); + } + return nullptr; +} + +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( + loc_sp->GetTarget().GetAPIMutex()); + loc_sp->SetQueueName(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( + loc_sp->GetTarget().GetAPIMutex()); + loc_sp->GetQueueName(); + } + return nullptr; +} + +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( + loc_sp->GetTarget().GetAPIMutex()); + return loc_sp->IsResolved(); + } + return false; +} + +void SBBreakpointLocation::SetLocation( + const lldb::BreakpointLocationSP &break_loc_sp) { + // Uninstall the callbacks? + m_opaque_wp = break_loc_sp; +} + +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(); + + if (loc_sp) { + std::lock_guard<std::recursive_mutex> guard( + loc_sp->GetTarget().GetAPIMutex()); + loc_sp->GetDescription(&strm, level); + strm.EOL(); + } else + strm.PutCString("No value"); + + return true; +} + +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( + loc_sp->GetTarget().GetAPIMutex()); + return loc_sp->GetID(); + } else + return LLDB_INVALID_BREAK_ID; +} + +SBBreakpoint SBBreakpointLocation::GetBreakpoint() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBreakpoint, SBBreakpointLocation, + GetBreakpoint); + + BreakpointLocationSP loc_sp = GetSP(); + + SBBreakpoint sb_bp; + if (loc_sp) { + std::lock_guard<std::recursive_mutex> guard( + loc_sp->GetTarget().GetAPIMutex()); + sb_bp = loc_sp->GetBreakpoint().shared_from_this(); + } + + return LLDB_RECORD_RESULT(sb_bp); +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBBreakpointLocation>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBBreakpointLocation, ()); + LLDB_REGISTER_CONSTRUCTOR(SBBreakpointLocation, + (const lldb::BreakpointLocationSP &)); + LLDB_REGISTER_CONSTRUCTOR(SBBreakpointLocation, + (const lldb::SBBreakpointLocation &)); + LLDB_REGISTER_METHOD( + const lldb::SBBreakpointLocation &, + SBBreakpointLocation, operator=,(const lldb::SBBreakpointLocation &)); + LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointLocation, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointLocation, operator bool, ()); + LLDB_REGISTER_METHOD(lldb::SBAddress, SBBreakpointLocation, GetAddress, ()); + LLDB_REGISTER_METHOD(lldb::addr_t, SBBreakpointLocation, GetLoadAddress, + ()); + LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetEnabled, (bool)); + LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, IsEnabled, ()); + LLDB_REGISTER_METHOD(uint32_t, SBBreakpointLocation, GetHitCount, ()); + LLDB_REGISTER_METHOD(uint32_t, SBBreakpointLocation, GetIgnoreCount, ()); + LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetIgnoreCount, + (uint32_t)); + LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetCondition, + (const char *)); + LLDB_REGISTER_METHOD(const char *, SBBreakpointLocation, GetCondition, ()); + LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetAutoContinue, (bool)); + LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, GetAutoContinue, ()); + LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetScriptCallbackFunction, + (const char *)); + LLDB_REGISTER_METHOD(SBError, SBBreakpointLocation, SetScriptCallbackFunction, + (const char *, SBStructuredData &)); + LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpointLocation, + SetScriptCallbackBody, (const char *)); + LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetCommandLineCommands, + (lldb::SBStringList &)); + LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, GetCommandLineCommands, + (lldb::SBStringList &)); + LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetThreadID, + (lldb::tid_t)); + LLDB_REGISTER_METHOD(lldb::tid_t, SBBreakpointLocation, GetThreadID, ()); + LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetThreadIndex, + (uint32_t)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpointLocation, GetThreadIndex, + ()); + LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetThreadName, + (const char *)); + LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointLocation, + GetThreadName, ()); + LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetQueueName, + (const char *)); + LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointLocation, GetQueueName, + ()); + LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, IsResolved, ()); + LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel)); + LLDB_REGISTER_METHOD(lldb::break_id_t, SBBreakpointLocation, GetID, ()); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBBreakpointLocation, + GetBreakpoint, ()); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBBreakpointName.cpp b/contrib/llvm-project/lldb/source/API/SBBreakpointName.cpp new file mode 100644 index 000000000000..3995defcf97c --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBBreakpointName.cpp @@ -0,0 +1,764 @@ +//===-- SBBreakpointName.cpp ----------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBBreakpointName.h" +#include "SBReproducerPrivate.h" +#include "lldb/API/SBDebugger.h" +#include "lldb/API/SBError.h" +#include "lldb/API/SBStream.h" +#include "lldb/API/SBStringList.h" +#include "lldb/API/SBStructuredData.h" +#include "lldb/API/SBTarget.h" + +#include "lldb/Breakpoint/BreakpointName.h" +#include "lldb/Breakpoint/StoppointCallbackContext.h" +#include "lldb/Core/Debugger.h" +#include "lldb/Core/StructuredDataImpl.h" +#include "lldb/Interpreter/CommandInterpreter.h" +#include "lldb/Interpreter/ScriptInterpreter.h" +#include "lldb/Target/Target.h" +#include "lldb/Target/ThreadSpec.h" +#include "lldb/Utility/Stream.h" + +#include "SBBreakpointOptionCommon.h" + +using namespace lldb; +using namespace lldb_private; + +namespace lldb +{ +class SBBreakpointNameImpl { +public: + SBBreakpointNameImpl(TargetSP target_sp, const char *name) { + if (!name || name[0] == '\0') + return; + m_name.assign(name); + + if (!target_sp) + return; + + m_target_wp = target_sp; + } + + SBBreakpointNameImpl(SBTarget &sb_target, const char *name); + bool operator==(const SBBreakpointNameImpl &rhs); + bool operator!=(const SBBreakpointNameImpl &rhs); + + // For now we take a simple approach and only keep the name, and relook up + // the location when we need it. + + TargetSP GetTarget() const { + return m_target_wp.lock(); + } + + const char *GetName() const { + return m_name.c_str(); + } + + bool IsValid() const { + return !m_name.empty() && m_target_wp.lock(); + } + + lldb_private::BreakpointName *GetBreakpointName() const; + +private: + TargetWP m_target_wp; + std::string m_name; +}; + +SBBreakpointNameImpl::SBBreakpointNameImpl(SBTarget &sb_target, + const char *name) { + if (!name || name[0] == '\0') + return; + m_name.assign(name); + + if (!sb_target.IsValid()) + return; + + TargetSP target_sp = sb_target.GetSP(); + if (!target_sp) + return; + + m_target_wp = target_sp; +} + +bool SBBreakpointNameImpl::operator==(const SBBreakpointNameImpl &rhs) { + return m_name == rhs.m_name && m_target_wp.lock() == rhs.m_target_wp.lock(); +} + +bool SBBreakpointNameImpl::operator!=(const SBBreakpointNameImpl &rhs) { + return m_name != rhs.m_name || m_target_wp.lock() != rhs.m_target_wp.lock(); +} + +lldb_private::BreakpointName *SBBreakpointNameImpl::GetBreakpointName() const { + if (!IsValid()) + return nullptr; + TargetSP target_sp = GetTarget(); + if (!target_sp) + return nullptr; + Status error; + return target_sp->FindBreakpointName(ConstString(m_name), true, error); +} + +} // namespace lldb + +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); + + m_impl_up = std::make_unique<SBBreakpointNameImpl>(sb_target, name); + // Call FindBreakpointName here to make sure the name is valid, reset if not: + BreakpointName *bp_name = GetBreakpointName(); + if (!bp_name) + m_impl_up.reset(); +} + +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; + } + BreakpointSP bkpt_sp = sb_bkpt.GetSP(); + Target &target = bkpt_sp->GetTarget(); + + m_impl_up = + std::make_unique<SBBreakpointNameImpl>(target.shared_from_this(), name); + + // Call FindBreakpointName here to make sure the name is valid, reset if not: + BreakpointName *bp_name = GetBreakpointName(); + if (!bp_name) { + m_impl_up.reset(); + return; + } + + // Now copy over the breakpoint's options: + target.ConfigureBreakpointName(*bp_name, *bkpt_sp->GetOptions(), + BreakpointName::Permissions()); +} + +SBBreakpointName::SBBreakpointName(const SBBreakpointName &rhs) { + LLDB_RECORD_CONSTRUCTOR(SBBreakpointName, (const lldb::SBBreakpointName &), + rhs); + + if (!rhs.m_impl_up) + return; + else + m_impl_up = std::make_unique<SBBreakpointNameImpl>( + rhs.m_impl_up->GetTarget(), rhs.m_impl_up->GetName()); +} + +SBBreakpointName::~SBBreakpointName() = default; + +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 LLDB_RECORD_RESULT(*this); + } + + m_impl_up = std::make_unique<SBBreakpointNameImpl>(rhs.m_impl_up->GetTarget(), + rhs.m_impl_up->GetName()); + return LLDB_RECORD_RESULT(*this); +} + +bool SBBreakpointName::operator==(const lldb::SBBreakpointName &rhs) { + LLDB_RECORD_METHOD( + bool, SBBreakpointName, operator==,(const lldb::SBBreakpointName &), rhs); + + return *m_impl_up == *rhs.m_impl_up; +} + +bool SBBreakpointName::operator!=(const lldb::SBBreakpointName &rhs) { + LLDB_RECORD_METHOD( + bool, SBBreakpointName, operator!=,(const lldb::SBBreakpointName &), rhs); + + return *m_impl_up != *rhs.m_impl_up; +} + +bool SBBreakpointName::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, IsValid); + return this->operator bool(); +} +SBBreakpointName::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, operator bool); + + 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); + + BreakpointName *bp_name = GetBreakpointName(); + if (!bp_name) + return; + + std::lock_guard<std::recursive_mutex> guard( + m_impl_up->GetTarget()->GetAPIMutex()); + + bp_name->GetOptions().SetEnabled(enable); +} + +void SBBreakpointName::UpdateName(BreakpointName &bp_name) { + if (!IsValid()) + return; + + TargetSP target_sp = m_impl_up->GetTarget(); + if (!target_sp) + return; + target_sp->ApplyNameToBreakpoints(bp_name); + +} + +bool SBBreakpointName::IsEnabled() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, IsEnabled); + + BreakpointName *bp_name = GetBreakpointName(); + if (!bp_name) + return false; + + std::lock_guard<std::recursive_mutex> guard( + m_impl_up->GetTarget()->GetAPIMutex()); + + return bp_name->GetOptions().IsEnabled(); +} + +void SBBreakpointName::SetOneShot(bool one_shot) { + LLDB_RECORD_METHOD(void, SBBreakpointName, SetOneShot, (bool), one_shot); + + BreakpointName *bp_name = GetBreakpointName(); + if (!bp_name) + return; + + std::lock_guard<std::recursive_mutex> guard( + m_impl_up->GetTarget()->GetAPIMutex()); + + bp_name->GetOptions().SetOneShot(one_shot); + UpdateName(*bp_name); +} + +bool SBBreakpointName::IsOneShot() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, IsOneShot); + + const BreakpointName *bp_name = GetBreakpointName(); + if (!bp_name) + return false; + + std::lock_guard<std::recursive_mutex> guard( + m_impl_up->GetTarget()->GetAPIMutex()); + + return bp_name->GetOptions().IsOneShot(); +} + +void SBBreakpointName::SetIgnoreCount(uint32_t count) { + LLDB_RECORD_METHOD(void, SBBreakpointName, SetIgnoreCount, (uint32_t), count); + + BreakpointName *bp_name = GetBreakpointName(); + if (!bp_name) + return; + + std::lock_guard<std::recursive_mutex> guard( + m_impl_up->GetTarget()->GetAPIMutex()); + + bp_name->GetOptions().SetIgnoreCount(count); + UpdateName(*bp_name); +} + +uint32_t SBBreakpointName::GetIgnoreCount() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointName, GetIgnoreCount); + + BreakpointName *bp_name = GetBreakpointName(); + if (!bp_name) + return false; + + std::lock_guard<std::recursive_mutex> guard( + m_impl_up->GetTarget()->GetAPIMutex()); + + return bp_name->GetOptions().GetIgnoreCount(); +} + +void SBBreakpointName::SetCondition(const char *condition) { + LLDB_RECORD_METHOD(void, SBBreakpointName, SetCondition, (const char *), + condition); + + BreakpointName *bp_name = GetBreakpointName(); + if (!bp_name) + return; + + std::lock_guard<std::recursive_mutex> guard( + m_impl_up->GetTarget()->GetAPIMutex()); + + bp_name->GetOptions().SetCondition(condition); + UpdateName(*bp_name); +} + +const char *SBBreakpointName::GetCondition() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBBreakpointName, GetCondition); + + BreakpointName *bp_name = GetBreakpointName(); + if (!bp_name) + return nullptr; + + std::lock_guard<std::recursive_mutex> guard( + m_impl_up->GetTarget()->GetAPIMutex()); + + return bp_name->GetOptions().GetConditionText(); +} + +void SBBreakpointName::SetAutoContinue(bool auto_continue) { + LLDB_RECORD_METHOD(void, SBBreakpointName, SetAutoContinue, (bool), + auto_continue); + + BreakpointName *bp_name = GetBreakpointName(); + if (!bp_name) + return; + + std::lock_guard<std::recursive_mutex> guard( + m_impl_up->GetTarget()->GetAPIMutex()); + + bp_name->GetOptions().SetAutoContinue(auto_continue); + UpdateName(*bp_name); +} + +bool SBBreakpointName::GetAutoContinue() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAutoContinue); + + BreakpointName *bp_name = GetBreakpointName(); + if (!bp_name) + return false; + + std::lock_guard<std::recursive_mutex> guard( + m_impl_up->GetTarget()->GetAPIMutex()); + + return bp_name->GetOptions().IsAutoContinue(); +} + +void SBBreakpointName::SetThreadID(tid_t tid) { + LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadID, (lldb::tid_t), tid); + + BreakpointName *bp_name = GetBreakpointName(); + if (!bp_name) + return; + + std::lock_guard<std::recursive_mutex> guard( + m_impl_up->GetTarget()->GetAPIMutex()); + + bp_name->GetOptions().SetThreadID(tid); + UpdateName(*bp_name); +} + +tid_t SBBreakpointName::GetThreadID() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBBreakpointName, GetThreadID); + + BreakpointName *bp_name = GetBreakpointName(); + if (!bp_name) + return LLDB_INVALID_THREAD_ID; + + std::lock_guard<std::recursive_mutex> guard( + m_impl_up->GetTarget()->GetAPIMutex()); + + return bp_name->GetOptions().GetThreadSpec()->GetTID(); +} + +void SBBreakpointName::SetThreadIndex(uint32_t index) { + LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadIndex, (uint32_t), index); + + BreakpointName *bp_name = GetBreakpointName(); + if (!bp_name) + return; + + std::lock_guard<std::recursive_mutex> guard( + m_impl_up->GetTarget()->GetAPIMutex()); + + bp_name->GetOptions().GetThreadSpec()->SetIndex(index); + UpdateName(*bp_name); +} + +uint32_t SBBreakpointName::GetThreadIndex() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointName, GetThreadIndex); + + BreakpointName *bp_name = GetBreakpointName(); + if (!bp_name) + return LLDB_INVALID_THREAD_ID; + + std::lock_guard<std::recursive_mutex> guard( + m_impl_up->GetTarget()->GetAPIMutex()); + + return bp_name->GetOptions().GetThreadSpec()->GetIndex(); +} + +void SBBreakpointName::SetThreadName(const char *thread_name) { + LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadName, (const char *), + thread_name); + + BreakpointName *bp_name = GetBreakpointName(); + if (!bp_name) + return; + + std::lock_guard<std::recursive_mutex> guard( + m_impl_up->GetTarget()->GetAPIMutex()); + + bp_name->GetOptions().GetThreadSpec()->SetName(thread_name); + UpdateName(*bp_name); +} + +const char *SBBreakpointName::GetThreadName() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName, + GetThreadName); + + BreakpointName *bp_name = GetBreakpointName(); + if (!bp_name) + return nullptr; + + std::lock_guard<std::recursive_mutex> guard( + m_impl_up->GetTarget()->GetAPIMutex()); + + return bp_name->GetOptions().GetThreadSpec()->GetName(); +} + +void SBBreakpointName::SetQueueName(const char *queue_name) { + LLDB_RECORD_METHOD(void, SBBreakpointName, SetQueueName, (const char *), + queue_name); + + BreakpointName *bp_name = GetBreakpointName(); + if (!bp_name) + return; + + std::lock_guard<std::recursive_mutex> guard( + m_impl_up->GetTarget()->GetAPIMutex()); + + bp_name->GetOptions().GetThreadSpec()->SetQueueName(queue_name); + UpdateName(*bp_name); +} + +const char *SBBreakpointName::GetQueueName() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName, + GetQueueName); + + BreakpointName *bp_name = GetBreakpointName(); + if (!bp_name) + return nullptr; + + std::lock_guard<std::recursive_mutex> guard( + m_impl_up->GetTarget()->GetAPIMutex()); + + return bp_name->GetOptions().GetThreadSpec()->GetQueueName(); +} + +void SBBreakpointName::SetCommandLineCommands(SBStringList &commands) { + LLDB_RECORD_METHOD(void, SBBreakpointName, SetCommandLineCommands, + (lldb::SBStringList &), commands); + + BreakpointName *bp_name = GetBreakpointName(); + if (!bp_name) + return; + if (commands.GetSize() == 0) + return; + + + std::lock_guard<std::recursive_mutex> guard( + m_impl_up->GetTarget()->GetAPIMutex()); + std::unique_ptr<BreakpointOptions::CommandData> cmd_data_up( + new BreakpointOptions::CommandData(*commands, eScriptLanguageNone)); + + bp_name->GetOptions().SetCommandDataCallback(cmd_data_up); + UpdateName(*bp_name); +} + +bool SBBreakpointName::GetCommandLineCommands(SBStringList &commands) { + LLDB_RECORD_METHOD(bool, SBBreakpointName, GetCommandLineCommands, + (lldb::SBStringList &), commands); + + BreakpointName *bp_name = GetBreakpointName(); + if (!bp_name) + return false; + + StringList command_list; + bool has_commands = + bp_name->GetOptions().GetCommandLineCallbacks(command_list); + if (has_commands) + commands.AppendList(command_list); + return has_commands; +} + +const char *SBBreakpointName::GetHelpString() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName, + GetHelpString); + + BreakpointName *bp_name = GetBreakpointName(); + if (!bp_name) + return ""; + + return bp_name->GetHelp(); +} + +void SBBreakpointName::SetHelpString(const char *help_string) { + LLDB_RECORD_METHOD(void, SBBreakpointName, SetHelpString, (const char *), + help_string); + + BreakpointName *bp_name = GetBreakpointName(); + if (!bp_name) + return; + + + std::lock_guard<std::recursive_mutex> guard( + m_impl_up->GetTarget()->GetAPIMutex()); + bp_name->SetHelp(help_string); +} + +bool SBBreakpointName::GetDescription(SBStream &s) { + LLDB_RECORD_METHOD(bool, SBBreakpointName, GetDescription, (lldb::SBStream &), + s); + + BreakpointName *bp_name = GetBreakpointName(); + if (!bp_name) + { + s.Printf("No value"); + return false; + } + + std::lock_guard<std::recursive_mutex> guard( + m_impl_up->GetTarget()->GetAPIMutex()); + bp_name->GetDescription(s.get(), eDescriptionLevelFull); + return true; +} + +void SBBreakpointName::SetCallback(SBBreakpointHitCallback callback, + void *baton) { + LLDB_RECORD_DUMMY(void, SBBreakpointName, SetCallback, + (lldb::SBBreakpointHitCallback, void *), callback, baton); + + BreakpointName *bp_name = GetBreakpointName(); + if (!bp_name) + return; + std::lock_guard<std::recursive_mutex> guard( + m_impl_up->GetTarget()->GetAPIMutex()); + + BatonSP baton_sp(new SBBreakpointCallbackBaton(callback, baton)); + bp_name->GetOptions().SetCallback(SBBreakpointCallbackBaton + ::PrivateBreakpointHitCallback, + baton_sp, + false); + UpdateName(*bp_name); +} + +void SBBreakpointName::SetScriptCallbackFunction( + const char *callback_function_name) { +LLDB_RECORD_METHOD(void, SBBreakpointName, SetScriptCallbackFunction, + (const char *), callback_function_name); + SBStructuredData empty_args; + SetScriptCallbackFunction(callback_function_name, empty_args); +} + +SBError SBBreakpointName::SetScriptCallbackFunction( + const char *callback_function_name, + SBStructuredData &extra_args) { + LLDB_RECORD_METHOD(SBError, SBBreakpointName, SetScriptCallbackFunction, + (const char *, SBStructuredData &), + callback_function_name, extra_args); + SBError sb_error; + BreakpointName *bp_name = GetBreakpointName(); + if (!bp_name) { + sb_error.SetErrorString("unrecognized breakpoint name"); + return LLDB_RECORD_RESULT(sb_error); + } + + std::lock_guard<std::recursive_mutex> guard( + m_impl_up->GetTarget()->GetAPIMutex()); + + BreakpointOptions &bp_options = bp_name->GetOptions(); + Status error; + error = m_impl_up->GetTarget() + ->GetDebugger() + .GetScriptInterpreter() + ->SetBreakpointCommandCallbackFunction(&bp_options, + callback_function_name, + extra_args.m_impl_up + ->GetObjectSP()); + sb_error.SetError(error); + UpdateName(*bp_name); + return LLDB_RECORD_RESULT(sb_error); +} + +SBError +SBBreakpointName::SetScriptCallbackBody(const char *callback_body_text) { + LLDB_RECORD_METHOD(lldb::SBError, SBBreakpointName, SetScriptCallbackBody, + (const char *), callback_body_text); + + SBError sb_error; + BreakpointName *bp_name = GetBreakpointName(); + if (!bp_name) + return LLDB_RECORD_RESULT(sb_error); + + std::lock_guard<std::recursive_mutex> guard( + m_impl_up->GetTarget()->GetAPIMutex()); + + BreakpointOptions &bp_options = bp_name->GetOptions(); + Status error = + m_impl_up->GetTarget() + ->GetDebugger() + .GetScriptInterpreter() + ->SetBreakpointCommandCallback(&bp_options, callback_body_text); + sb_error.SetError(error); + if (!sb_error.Fail()) + UpdateName(*bp_name); + + return LLDB_RECORD_RESULT(sb_error); +} + +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) { + LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowList, (bool), value); + + + BreakpointName *bp_name = GetBreakpointName(); + if (!bp_name) + return; + bp_name->GetPermissions().SetAllowList(value); +} + +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) { + LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowDelete, (bool), value); + + + BreakpointName *bp_name = GetBreakpointName(); + if (!bp_name) + return; + bp_name->GetPermissions().SetAllowDelete(value); +} + +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) { + LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowDisable, (bool), value); + + BreakpointName *bp_name = GetBreakpointName(); + if (!bp_name) + return; + bp_name->GetPermissions().SetAllowDisable(value); +} + +lldb_private::BreakpointName *SBBreakpointName::GetBreakpointName() const +{ + if (!IsValid()) + return nullptr; + return m_impl_up->GetBreakpointName(); +} + + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBBreakpointName>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName, ()); + LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName, + (lldb::SBTarget &, const char *)); + LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName, + (lldb::SBBreakpoint &, const char *)); + LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName, + (const lldb::SBBreakpointName &)); + LLDB_REGISTER_METHOD( + const lldb::SBBreakpointName &, + SBBreakpointName, operator=,(const lldb::SBBreakpointName &)); + LLDB_REGISTER_METHOD( + bool, SBBreakpointName, operator==,(const lldb::SBBreakpointName &)); + LLDB_REGISTER_METHOD( + bool, SBBreakpointName, operator!=,(const lldb::SBBreakpointName &)); + LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, operator bool, ()); + LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetName, ()); + LLDB_REGISTER_METHOD(void, SBBreakpointName, SetEnabled, (bool)); + LLDB_REGISTER_METHOD(bool, SBBreakpointName, IsEnabled, ()); + LLDB_REGISTER_METHOD(void, SBBreakpointName, SetOneShot, (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, IsOneShot, ()); + LLDB_REGISTER_METHOD(void, SBBreakpointName, SetIgnoreCount, (uint32_t)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpointName, GetIgnoreCount, ()); + LLDB_REGISTER_METHOD(void, SBBreakpointName, SetCondition, (const char *)); + LLDB_REGISTER_METHOD(const char *, SBBreakpointName, GetCondition, ()); + LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAutoContinue, (bool)); + LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetAutoContinue, ()); + LLDB_REGISTER_METHOD(void, SBBreakpointName, SetThreadID, (lldb::tid_t)); + LLDB_REGISTER_METHOD(lldb::tid_t, SBBreakpointName, GetThreadID, ()); + LLDB_REGISTER_METHOD(void, SBBreakpointName, SetThreadIndex, (uint32_t)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpointName, GetThreadIndex, ()); + LLDB_REGISTER_METHOD(void, SBBreakpointName, SetThreadName, (const char *)); + LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetThreadName, + ()); + LLDB_REGISTER_METHOD(void, SBBreakpointName, SetQueueName, (const char *)); + LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetQueueName, + ()); + LLDB_REGISTER_METHOD(void, SBBreakpointName, SetCommandLineCommands, + (lldb::SBStringList &)); + LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetCommandLineCommands, + (lldb::SBStringList &)); + LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetHelpString, + ()); + LLDB_REGISTER_METHOD(void, SBBreakpointName, SetHelpString, (const char *)); + LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetDescription, + (lldb::SBStream &)); + LLDB_REGISTER_METHOD(void, SBBreakpointName, SetScriptCallbackFunction, + (const char *)); + LLDB_REGISTER_METHOD(SBError, SBBreakpointName, SetScriptCallbackFunction, + (const char *, SBStructuredData &)); + LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpointName, SetScriptCallbackBody, + (const char *)); + LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, GetAllowList, ()); + LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAllowList, (bool)); + LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetAllowDelete, ()); + LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAllowDelete, (bool)); + LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetAllowDisable, ()); + LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAllowDisable, (bool)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBBreakpointOptionCommon.cpp b/contrib/llvm-project/lldb/source/API/SBBreakpointOptionCommon.cpp new file mode 100644 index 000000000000..2ee47ff7795c --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBBreakpointOptionCommon.cpp @@ -0,0 +1,80 @@ +//===-- SBBreakpointOptionCommon.cpp --------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBBreakpointName.h" +#include "lldb/API/SBBreakpointLocation.h" +#include "lldb/API/SBDebugger.h" +#include "lldb/API/SBEvent.h" +#include "lldb/API/SBProcess.h" +#include "lldb/API/SBStream.h" +#include "lldb/API/SBStringList.h" +#include "lldb/API/SBThread.h" + +#include "lldb/Breakpoint/BreakpointName.h" +#include "lldb/Breakpoint/StoppointCallbackContext.h" +#include "lldb/Core/Address.h" +#include "lldb/Core/Debugger.h" +#include "lldb/Core/StreamFile.h" +#include "lldb/Interpreter/CommandInterpreter.h" +#include "lldb/Interpreter/ScriptInterpreter.h" +#include "lldb/Target/Process.h" +#include "lldb/Target/Target.h" +#include "lldb/Target/Thread.h" +#include "lldb/Target/ThreadSpec.h" +#include "lldb/Utility/Log.h" +#include "lldb/Utility/Stream.h" + +#include "lldb/lldb-enumerations.h" + +#include "SBBreakpointOptionCommon.h" + +#include "llvm/ADT/STLExtras.h" + +using namespace lldb; +using namespace lldb_private; + +SBBreakpointCallbackBaton::SBBreakpointCallbackBaton(SBBreakpointHitCallback + callback, + void *baton) + : TypedBaton(std::make_unique<CallbackData>()) { + getItem()->callback = callback; + getItem()->callback_baton = baton; + } + + bool SBBreakpointCallbackBaton::PrivateBreakpointHitCallback(void *baton, + StoppointCallbackContext *ctx, + lldb::user_id_t break_id, + lldb::user_id_t break_loc_id) +{ + ExecutionContext exe_ctx(ctx->exe_ctx_ref); + BreakpointSP bp_sp( + exe_ctx.GetTargetRef().GetBreakpointList().FindBreakpointByID(break_id)); + if (baton && bp_sp) { + CallbackData *data = (CallbackData *)baton; + lldb_private::Breakpoint *bp = bp_sp.get(); + if (bp && data->callback) { + Process *process = exe_ctx.GetProcessPtr(); + if (process) { + SBProcess sb_process(process->shared_from_this()); + SBThread sb_thread; + SBBreakpointLocation sb_location; + assert(bp_sp); + sb_location.SetLocation(bp_sp->FindLocationByID(break_loc_id)); + Thread *thread = exe_ctx.GetThreadPtr(); + if (thread) + sb_thread.SetThread(thread->shared_from_this()); + + return data->callback(data->callback_baton, sb_process, sb_thread, + sb_location); + } + } + } + return true; // Return true if we should stop at this breakpoint +} + +SBBreakpointCallbackBaton::~SBBreakpointCallbackBaton() = default; diff --git a/contrib/llvm-project/lldb/source/API/SBBreakpointOptionCommon.h b/contrib/llvm-project/lldb/source/API/SBBreakpointOptionCommon.h new file mode 100644 index 000000000000..0ceb90290de5 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBBreakpointOptionCommon.h @@ -0,0 +1,36 @@ +//===-- SBBreakpointOptionCommon.h ------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLDB_SOURCE_API_SBBREAKPOINTOPTIONCOMMON_H +#define LLDB_SOURCE_API_SBBREAKPOINTOPTIONCOMMON_H + +#include "lldb/API/SBDefines.h" +#include "lldb/Utility/Baton.h" + +namespace lldb +{ +struct CallbackData { + SBBreakpointHitCallback callback; + void *callback_baton; +}; + +class SBBreakpointCallbackBaton : public lldb_private::TypedBaton<CallbackData> { +public: + SBBreakpointCallbackBaton(SBBreakpointHitCallback callback, + void *baton); + + ~SBBreakpointCallbackBaton() override; + + static bool PrivateBreakpointHitCallback(void *baton, + lldb_private::StoppointCallbackContext *ctx, + lldb::user_id_t break_id, + lldb::user_id_t break_loc_id); +}; + +} // namespace lldb +#endif // LLDB_SOURCE_API_SBBREAKPOINTOPTIONCOMMON_H diff --git a/contrib/llvm-project/lldb/source/API/SBBroadcaster.cpp b/contrib/llvm-project/lldb/source/API/SBBroadcaster.cpp new file mode 100644 index 000000000000..d42d7ce2a536 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBBroadcaster.cpp @@ -0,0 +1,213 @@ +//===-- SBBroadcaster.cpp -------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "SBReproducerPrivate.h" +#include "lldb/Utility/Broadcaster.h" + +#include "lldb/API/SBBroadcaster.h" +#include "lldb/API/SBEvent.h" +#include "lldb/API/SBListener.h" + +using namespace lldb; +using namespace lldb_private; + +SBBroadcaster::SBBroadcaster() : m_opaque_sp(), m_opaque_ptr(nullptr) { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBroadcaster); +} + +SBBroadcaster::SBBroadcaster(const char *name) + : m_opaque_sp(new Broadcaster(nullptr, name)), m_opaque_ptr(nullptr) { + LLDB_RECORD_CONSTRUCTOR(SBBroadcaster, (const char *), name); + + m_opaque_ptr = m_opaque_sp.get(); +} + +SBBroadcaster::SBBroadcaster(lldb_private::Broadcaster *broadcaster, bool owns) + : m_opaque_sp(owns ? broadcaster : nullptr), m_opaque_ptr(broadcaster) {} + +SBBroadcaster::SBBroadcaster(const SBBroadcaster &rhs) + : m_opaque_sp(rhs.m_opaque_sp), m_opaque_ptr(rhs.m_opaque_ptr) { + LLDB_RECORD_CONSTRUCTOR(SBBroadcaster, (const lldb::SBBroadcaster &), rhs); +} + +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; + } + return LLDB_RECORD_RESULT(*this); +} + +SBBroadcaster::~SBBroadcaster() { reset(nullptr, false); } + +void SBBroadcaster::BroadcastEventByType(uint32_t event_type, bool unique) { + LLDB_RECORD_METHOD(void, SBBroadcaster, BroadcastEventByType, + (uint32_t, bool), event_type, unique); + + if (m_opaque_ptr == nullptr) + return; + + if (unique) + m_opaque_ptr->BroadcastEventIfUnique(event_type); + else + m_opaque_ptr->BroadcastEvent(event_type); +} + +void SBBroadcaster::BroadcastEvent(const SBEvent &event, bool unique) { + LLDB_RECORD_METHOD(void, SBBroadcaster, BroadcastEvent, + (const lldb::SBEvent &, bool), event, unique); + + if (m_opaque_ptr == nullptr) + return; + + EventSP event_sp = event.GetSP(); + if (unique) + m_opaque_ptr->BroadcastEventIfUnique(event_sp); + else + m_opaque_ptr->BroadcastEvent(event_sp); +} + +void SBBroadcaster::AddInitialEventsToListener(const SBListener &listener, + uint32_t requested_events) { + LLDB_RECORD_METHOD(void, SBBroadcaster, AddInitialEventsToListener, + (const lldb::SBListener &, uint32_t), listener, + requested_events); + + if (m_opaque_ptr) + m_opaque_ptr->AddInitialEventsToListener(listener.m_opaque_sp, + requested_events); +} + +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 nullptr; +} + +bool SBBroadcaster::EventTypeHasListeners(uint32_t event_type) { + LLDB_RECORD_METHOD(bool, SBBroadcaster, EventTypeHasListeners, (uint32_t), + event_type); + + if (m_opaque_ptr) + return m_opaque_ptr->EventTypeHasListeners(event_type); + return false; +} + +bool SBBroadcaster::RemoveListener(const SBListener &listener, + uint32_t event_mask) { + LLDB_RECORD_METHOD(bool, SBBroadcaster, RemoveListener, + (const lldb::SBListener &, uint32_t), listener, + event_mask); + + if (m_opaque_ptr) + return m_opaque_ptr->RemoveListener(listener.m_opaque_sp, event_mask); + return false; +} + +Broadcaster *SBBroadcaster::get() const { return m_opaque_ptr; } + +void SBBroadcaster::reset(Broadcaster *broadcaster, bool owns) { + if (owns) + m_opaque_sp.reset(broadcaster); + else + m_opaque_sp.reset(); + m_opaque_ptr = broadcaster; +} + +bool SBBroadcaster::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBroadcaster, IsValid); + return this->operator bool(); +} +SBBroadcaster::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBroadcaster, operator bool); + + return m_opaque_ptr != nullptr; +} + +void SBBroadcaster::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBBroadcaster, Clear); + + m_opaque_sp.reset(); + m_opaque_ptr = nullptr; +} + +bool SBBroadcaster::operator==(const SBBroadcaster &rhs) const { + LLDB_RECORD_METHOD_CONST( + bool, SBBroadcaster, operator==,(const lldb::SBBroadcaster &), rhs); + + 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; +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBBroadcaster>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBBroadcaster, ()); + LLDB_REGISTER_CONSTRUCTOR(SBBroadcaster, (const char *)); + LLDB_REGISTER_CONSTRUCTOR(SBBroadcaster, (const lldb::SBBroadcaster &)); + LLDB_REGISTER_METHOD( + const lldb::SBBroadcaster &, + SBBroadcaster, operator=,(const lldb::SBBroadcaster &)); + LLDB_REGISTER_METHOD(void, SBBroadcaster, BroadcastEventByType, + (uint32_t, bool)); + LLDB_REGISTER_METHOD(void, SBBroadcaster, BroadcastEvent, + (const lldb::SBEvent &, bool)); + LLDB_REGISTER_METHOD(void, SBBroadcaster, AddInitialEventsToListener, + (const lldb::SBListener &, uint32_t)); + LLDB_REGISTER_METHOD(uint32_t, SBBroadcaster, AddListener, + (const lldb::SBListener &, uint32_t)); + LLDB_REGISTER_METHOD_CONST(const char *, SBBroadcaster, GetName, ()); + LLDB_REGISTER_METHOD(bool, SBBroadcaster, EventTypeHasListeners, + (uint32_t)); + LLDB_REGISTER_METHOD(bool, SBBroadcaster, RemoveListener, + (const lldb::SBListener &, uint32_t)); + LLDB_REGISTER_METHOD_CONST(bool, SBBroadcaster, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBBroadcaster, operator bool, ()); + LLDB_REGISTER_METHOD(void, SBBroadcaster, Clear, ()); + LLDB_REGISTER_METHOD_CONST( + bool, SBBroadcaster, operator==,(const lldb::SBBroadcaster &)); + LLDB_REGISTER_METHOD_CONST( + bool, SBBroadcaster, operator!=,(const lldb::SBBroadcaster &)); + LLDB_REGISTER_METHOD_CONST( + bool, SBBroadcaster, operator<,(const lldb::SBBroadcaster &)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBCommandInterpreter.cpp b/contrib/llvm-project/lldb/source/API/SBCommandInterpreter.cpp new file mode 100644 index 000000000000..f4f19577b36c --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBCommandInterpreter.cpp @@ -0,0 +1,859 @@ +//===-- SBCommandInterpreter.cpp ------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/lldb-types.h" + +#include "SBReproducerPrivate.h" +#include "lldb/Interpreter/CommandInterpreter.h" +#include "lldb/Interpreter/CommandObjectMultiword.h" +#include "lldb/Interpreter/CommandReturnObject.h" +#include "lldb/Target/Target.h" +#include "lldb/Utility/Listener.h" + +#include "lldb/API/SBBroadcaster.h" +#include "lldb/API/SBCommandInterpreter.h" +#include "lldb/API/SBCommandInterpreterRunOptions.h" +#include "lldb/API/SBCommandReturnObject.h" +#include "lldb/API/SBEvent.h" +#include "lldb/API/SBExecutionContext.h" +#include "lldb/API/SBListener.h" +#include "lldb/API/SBProcess.h" +#include "lldb/API/SBStream.h" +#include "lldb/API/SBStringList.h" +#include "lldb/API/SBTarget.h" + +#include <memory> + +using namespace lldb; +using namespace lldb_private; + +class CommandPluginInterfaceImplementation : public CommandObjectParsed { +public: + CommandPluginInterfaceImplementation(CommandInterpreter &interpreter, + const char *name, + lldb::SBCommandPluginInterface *backend, + const char *help = nullptr, + const char *syntax = nullptr, + uint32_t flags = 0, + const char *auto_repeat_command = "") + : CommandObjectParsed(interpreter, name, help, syntax, flags), + m_backend(backend) { + m_auto_repeat_command = + auto_repeat_command == nullptr + ? llvm::None + : llvm::Optional<std::string>(auto_repeat_command); + } + + bool IsRemovable() const override { return true; } + + /// More documentation is available in lldb::CommandObject::GetRepeatCommand, + /// but in short, if nullptr is returned, the previous command will be + /// repeated, and if an empty string is returned, no commands will be + /// executed. + const char *GetRepeatCommand(Args ¤t_command_args, + uint32_t index) override { + if (!m_auto_repeat_command) + return nullptr; + else + return m_auto_repeat_command->c_str(); + } + +protected: + bool DoExecute(Args &command, CommandReturnObject &result) override { + SBCommandReturnObject sb_return(result); + SBCommandInterpreter sb_interpreter(&m_interpreter); + SBDebugger debugger_sb(m_interpreter.GetDebugger().shared_from_this()); + bool ret = m_backend->DoExecute( + debugger_sb, command.GetArgumentVector(), sb_return); + return ret; + } + std::shared_ptr<lldb::SBCommandPluginInterface> m_backend; + llvm::Optional<std::string> m_auto_repeat_command; +}; + +SBCommandInterpreter::SBCommandInterpreter(CommandInterpreter *interpreter) + : m_opaque_ptr(interpreter) { + LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreter, + (lldb_private::CommandInterpreter *), interpreter); + +} + +SBCommandInterpreter::SBCommandInterpreter(const SBCommandInterpreter &rhs) + : m_opaque_ptr(rhs.m_opaque_ptr) { + LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreter, + (const lldb::SBCommandInterpreter &), rhs); +} + +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 LLDB_RECORD_RESULT(*this); +} + +bool SBCommandInterpreter::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, IsValid); + return this->operator bool(); +} +SBCommandInterpreter::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, operator bool); + + 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) + .GetCString() + : nullptr); +} + +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); +} + +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); + + + ExecutionContext ctx, *ctx_ptr; + if (override_context.get()) { + ctx = override_context.get()->Lock(true); + ctx_ptr = &ctx; + } else + ctx_ptr = nullptr; + + result.Clear(); + if (command_line && IsValid()) { + result.ref().SetInteractive(false); + m_opaque_ptr->HandleCommand(command_line, + add_to_history ? eLazyBoolYes : eLazyBoolNo, + result.ref(), ctx_ptr); + } else { + result->AppendError( + "SBCommandInterpreter or the command line is not valid"); + result->SetStatus(eReturnStatusFailed); + } + + + return result.GetStatus(); +} + +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); + + if (!IsValid()) { + result->AppendError("SBCommandInterpreter is not valid."); + result->SetStatus(eReturnStatusFailed); + return; + } + + if (!file.IsValid()) { + SBStream s; + file.GetDescription(s); + result->AppendErrorWithFormat("File is not valid: %s.", s.GetData()); + result->SetStatus(eReturnStatusFailed); + } + + FileSpec tmp_spec = file.ref(); + ExecutionContext ctx, *ctx_ptr; + if (override_context.get()) { + ctx = override_context.get()->Lock(true); + ctx_ptr = &ctx; + } else + ctx_ptr = nullptr; + + m_opaque_ptr->HandleCommandsFromFile(tmp_spec, ctx_ptr, options.ref(), + result.ref()); +} + +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, + matches, dummy_descriptions); +} + +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); + + // Sanity check the arguments that are passed in: cursor & last_char have to + // be within the current_line. + if (current_line == nullptr || cursor == nullptr || last_char == nullptr) + return 0; + + if (cursor < current_line || last_char < current_line) + return 0; + + size_t current_line_size = strlen(current_line); + if (cursor - current_line > static_cast<ptrdiff_t>(current_line_size) || + last_char - current_line > static_cast<ptrdiff_t>(current_line_size)) + return 0; + + if (!IsValid()) + return 0; + + lldb_private::StringList lldb_matches, lldb_descriptions; + CompletionResult result; + CompletionRequest request(current_line, cursor - current_line, result); + m_opaque_ptr->HandleCompletion(request); + result.GetMatches(lldb_matches); + result.GetDescriptions(lldb_descriptions); + + // Make the result array indexed from 1 again by adding the 'common prefix' + // of all completions as element 0. This is done to emulate the old API. + if (request.GetParsedLine().GetArgumentCount() == 0) { + // If we got an empty string, insert nothing. + lldb_matches.InsertStringAtIndex(0, ""); + lldb_descriptions.InsertStringAtIndex(0, ""); + } else { + // Now figure out if there is a common substring, and if so put that in + // element 0, otherwise put an empty string in element 0. + std::string command_partial_str = request.GetCursorArgumentPrefix().str(); + + std::string common_prefix = lldb_matches.LongestCommonPrefix(); + const size_t partial_name_len = command_partial_str.size(); + common_prefix.erase(0, partial_name_len); + + // If we matched a unique single command, add a space... Only do this if + // the completer told us this was a complete word, however... + if (lldb_matches.GetSize() == 1) { + char quote_char = request.GetParsedArg().GetQuoteChar(); + common_prefix = + Args::EscapeLLDBCommandArgument(common_prefix, quote_char); + if (request.GetParsedArg().IsQuoted()) + common_prefix.push_back(quote_char); + common_prefix.push_back(' '); + } + lldb_matches.InsertStringAtIndex(0, common_prefix.c_str()); + lldb_descriptions.InsertStringAtIndex(0, ""); + } + + SBStringList temp_matches_list(&lldb_matches); + matches.AppendList(temp_matches_list); + SBStringList temp_descriptions_list(&lldb_descriptions); + descriptions.AppendList(temp_descriptions_list); + return result.GetNumberOfResults(); +} + +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( + current_line, cursor, last_char, match_start_point, max_return_elements, + matches, descriptions); +} + +int SBCommandInterpreter::HandleCompletion(const char *current_line, + uint32_t cursor_pos, + 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, + max_return_elements, matches); +} + +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()) { + TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget()); + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + process_sp = target_sp->GetProcessSP(); + sb_process.SetSP(process_sp); + } + } + + 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()); + + 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); + return exited; +} + +int SBCommandInterpreter::GetQuitStatus() { + LLDB_RECORD_METHOD_NO_ARGS(int, SBCommandInterpreter, GetQuitStatus); + + bool exited = false; + return (m_opaque_ptr ? m_opaque_ptr->GetQuitExitCode(exited) : 0); +} + +void SBCommandInterpreter::ResolveCommand(const char *command_line, + SBCommandReturnObject &result) { + LLDB_RECORD_METHOD(void, SBCommandInterpreter, ResolveCommand, + (const char *, lldb::SBCommandReturnObject &), + command_line, result); + + result.Clear(); + if (command_line && IsValid()) { + m_opaque_ptr->ResolveCommand(command_line, result.ref()); + } else { + result->AppendError( + "SBCommandInterpreter or the command line is not valid"); + result->SetStatus(eReturnStatusFailed); + } +} + +CommandInterpreter *SBCommandInterpreter::get() { return m_opaque_ptr; } + +CommandInterpreter &SBCommandInterpreter::ref() { + assert(m_opaque_ptr); + return *m_opaque_ptr; +} + +void SBCommandInterpreter::reset( + lldb_private::CommandInterpreter *interpreter) { + m_opaque_ptr = interpreter; +} + +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()); + std::unique_lock<std::recursive_mutex> lock; + if (target_sp) + lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex()); + m_opaque_ptr->SourceInitFileHome(result.ref()); + } else { + result->AppendError("SBCommandInterpreter is not valid"); + result->SetStatus(eReturnStatusFailed); + } +} + +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()); + std::unique_lock<std::recursive_mutex> lock; + if (target_sp) + lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex()); + m_opaque_ptr->SourceInitFileCwd(result.ref()); + } else { + result->AppendError("SBCommandInterpreter is not valid"); + result->SetStatus(eReturnStatusFailed); + } +} + +SBBroadcaster SBCommandInterpreter::GetBroadcaster() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBroadcaster, SBCommandInterpreter, + GetBroadcaster); + + + SBBroadcaster broadcaster(m_opaque_ptr, false); + + + 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(); +} + +bool SBCommandInterpreter::SetCommandOverrideCallback( + const char *command_name, lldb::CommandOverrideCallback callback, + void *baton) { + LLDB_RECORD_DUMMY(bool, SBCommandInterpreter, SetCommandOverrideCallback, + (const char *, lldb::CommandOverrideCallback, void *), + command_name, callback, baton); + + if (command_name && command_name[0] && IsValid()) { + llvm::StringRef command_name_str = command_name; + CommandObject *cmd_obj = + m_opaque_ptr->GetCommandObjectForCommand(command_name_str); + if (cmd_obj) { + assert(command_name_str.empty()); + cmd_obj->SetOverrideCallback(callback, baton); + return true; + } + } + return false; +} + +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_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); + + return LLDB_RECORD_RESULT(AddCommand(name, impl, help, /*syntax=*/nullptr, + /*auto_repeat_command=*/"")) +} + +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); + return LLDB_RECORD_RESULT( + AddCommand(name, impl, help, syntax, /*auto_repeat_command=*/"")) +} + +lldb::SBCommand SBCommandInterpreter::AddCommand( + const char *name, lldb::SBCommandPluginInterface *impl, const char *help, + const char *syntax, const char *auto_repeat_command) { + LLDB_RECORD_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand, + (const char *, lldb::SBCommandPluginInterface *, + const char *, const char *, const char *), + name, impl, help, syntax, auto_repeat_command); + + lldb::CommandObjectSP new_command_sp; + new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>( + *m_opaque_ptr, name, impl, help, syntax, /*flags=*/0, + auto_repeat_command); + + if (new_command_sp && + m_opaque_ptr->AddUserCommand(name, new_command_sp, true)) + return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp)); + return LLDB_RECORD_RESULT(lldb::SBCommand()); +} + +SBCommand::SBCommand() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommand); } + +SBCommand::SBCommand(lldb::CommandObjectSP cmd_sp) : m_opaque_sp(cmd_sp) {} + +bool SBCommand::IsValid() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommand, IsValid); + return this->operator bool(); +} +SBCommand::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommand, operator bool); + + return m_opaque_sp.get() != nullptr; +} + +const char *SBCommand::GetName() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetName); + + 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_RECORD_RESULT(lldb::SBCommand()); + if (!m_opaque_sp->IsMultiwordObject()) + 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_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); + return LLDB_RECORD_RESULT(AddCommand(name, impl, help, /*syntax=*/nullptr, + /*auto_repeat_command=*/"")) +} + +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); + return LLDB_RECORD_RESULT( + AddCommand(name, impl, help, syntax, /*auto_repeat_command=*/"")) +} + +lldb::SBCommand SBCommand::AddCommand(const char *name, + lldb::SBCommandPluginInterface *impl, + const char *help, const char *syntax, + const char *auto_repeat_command) { + LLDB_RECORD_METHOD(lldb::SBCommand, SBCommand, AddCommand, + (const char *, lldb::SBCommandPluginInterface *, + const char *, const char *, const char *), + name, impl, help, syntax, auto_repeat_command); + + if (!IsValid()) + return LLDB_RECORD_RESULT(lldb::SBCommand()); + if (!m_opaque_sp->IsMultiwordObject()) + 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, + /*flags=*/0, auto_repeat_command); + if (new_command_sp && m_opaque_sp->LoadSubCommand(name, new_command_sp)) + 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); +} + +namespace lldb_private { +namespace repro { + +template <> void RegisterMethods<SBCommandInterpreter>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreter, + (lldb_private::CommandInterpreter *)); + LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreter, + (const lldb::SBCommandInterpreter &)); + LLDB_REGISTER_METHOD( + const lldb::SBCommandInterpreter &, + SBCommandInterpreter, operator=,(const lldb::SBCommandInterpreter &)); + LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, operator bool, ()); + LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, CommandExists, + (const char *)); + LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, AliasExists, + (const char *)); + LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, IsActive, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, WasInterrupted, ()); + LLDB_REGISTER_METHOD(const char *, SBCommandInterpreter, + GetIOHandlerControlSequence, (char)); + LLDB_REGISTER_METHOD(lldb::ReturnStatus, SBCommandInterpreter, + HandleCommand, + (const char *, lldb::SBCommandReturnObject &, bool)); + LLDB_REGISTER_METHOD(lldb::ReturnStatus, SBCommandInterpreter, + HandleCommand, + (const char *, lldb::SBExecutionContext &, + lldb::SBCommandReturnObject &, bool)); + LLDB_REGISTER_METHOD(void, SBCommandInterpreter, HandleCommandsFromFile, + (lldb::SBFileSpec &, lldb::SBExecutionContext &, + lldb::SBCommandInterpreterRunOptions &, + lldb::SBCommandReturnObject)); + LLDB_REGISTER_METHOD(int, SBCommandInterpreter, HandleCompletion, + (const char *, const char *, const char *, int, int, + lldb::SBStringList &)); + LLDB_REGISTER_METHOD(int, SBCommandInterpreter, + HandleCompletionWithDescriptions, + (const char *, const char *, const char *, int, int, + lldb::SBStringList &, lldb::SBStringList &)); + LLDB_REGISTER_METHOD(int, SBCommandInterpreter, + HandleCompletionWithDescriptions, + (const char *, uint32_t, int, int, + lldb::SBStringList &, lldb::SBStringList &)); + LLDB_REGISTER_METHOD( + int, SBCommandInterpreter, HandleCompletion, + (const char *, uint32_t, int, int, lldb::SBStringList &)); + LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasCommands, ()); + LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasAliases, ()); + LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasAliasOptions, ()); + LLDB_REGISTER_METHOD(lldb::SBProcess, SBCommandInterpreter, GetProcess, ()); + LLDB_REGISTER_METHOD(lldb::SBDebugger, SBCommandInterpreter, GetDebugger, + ()); + LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, GetPromptOnQuit, ()); + LLDB_REGISTER_METHOD(void, SBCommandInterpreter, SetPromptOnQuit, (bool)); + LLDB_REGISTER_METHOD(void, SBCommandInterpreter, AllowExitCodeOnQuit, + (bool)); + LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasCustomQuitExitCode, ()); + LLDB_REGISTER_METHOD(int, SBCommandInterpreter, GetQuitStatus, ()); + LLDB_REGISTER_METHOD(void, SBCommandInterpreter, ResolveCommand, + (const char *, lldb::SBCommandReturnObject &)); + LLDB_REGISTER_METHOD(void, SBCommandInterpreter, + SourceInitFileInHomeDirectory, + (lldb::SBCommandReturnObject &)); + LLDB_REGISTER_METHOD(void, SBCommandInterpreter, + SourceInitFileInCurrentWorkingDirectory, + (lldb::SBCommandReturnObject &)); + LLDB_REGISTER_METHOD(lldb::SBBroadcaster, SBCommandInterpreter, + GetBroadcaster, ()); + LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter, + GetBroadcasterClass, ()); + LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter, + GetArgumentTypeAsCString, + (const lldb::CommandArgumentType)); + LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter, + GetArgumentDescriptionAsCString, + (const lldb::CommandArgumentType)); + LLDB_REGISTER_STATIC_METHOD(bool, SBCommandInterpreter, + EventIsCommandInterpreterEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommandInterpreter, + AddMultiwordCommand, (const char *, const char *)); + LLDB_REGISTER_METHOD( + lldb::SBCommand, SBCommandInterpreter, AddCommand, + (const char *, lldb::SBCommandPluginInterface *, const char *)); + LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand, + (const char *, lldb::SBCommandPluginInterface *, + const char *, const char *)); + LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand, + (const char *, lldb::SBCommandPluginInterface *, + const char *, const char *, const char *)); + LLDB_REGISTER_CONSTRUCTOR(SBCommand, ()); + LLDB_REGISTER_METHOD(bool, SBCommand, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBCommand, operator bool, ()); + LLDB_REGISTER_METHOD(const char *, SBCommand, GetName, ()); + LLDB_REGISTER_METHOD(const char *, SBCommand, GetHelp, ()); + LLDB_REGISTER_METHOD(const char *, SBCommand, GetHelpLong, ()); + LLDB_REGISTER_METHOD(void, SBCommand, SetHelp, (const char *)); + LLDB_REGISTER_METHOD(void, SBCommand, SetHelpLong, (const char *)); + LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddMultiwordCommand, + (const char *, const char *)); + LLDB_REGISTER_METHOD( + lldb::SBCommand, SBCommand, AddCommand, + (const char *, lldb::SBCommandPluginInterface *, const char *)); + LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddCommand, + (const char *, lldb::SBCommandPluginInterface *, + const char *, const char *)); + LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddCommand, + (const char *, lldb::SBCommandPluginInterface *, + const char *, const char *, const char *)); + LLDB_REGISTER_METHOD(uint32_t, SBCommand, GetFlags, ()); + LLDB_REGISTER_METHOD(void, SBCommand, SetFlags, (uint32_t)); +} +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBCommandInterpreterRunOptions.cpp b/contrib/llvm-project/lldb/source/API/SBCommandInterpreterRunOptions.cpp new file mode 100644 index 000000000000..fcfbf5e5401a --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBCommandInterpreterRunOptions.cpp @@ -0,0 +1,272 @@ +//===-- SBCommandInterpreterRunOptions.cpp --------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/lldb-types.h" + +#include "SBReproducerPrivate.h" + +#include "lldb/API/SBCommandInterpreterRunOptions.h" +#include "lldb/Interpreter/CommandInterpreter.h" + +#include <memory> + +using namespace lldb; +using namespace lldb_private; + +SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommandInterpreterRunOptions); + + m_opaque_up = std::make_unique<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); +} + +bool SBCommandInterpreterRunOptions::GetAutoHandleEvents() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, + GetAutoHandleEvents); + + return m_opaque_up->GetAutoHandleEvents(); +} + +void SBCommandInterpreterRunOptions::SetAutoHandleEvents( + bool auto_handle_events) { + LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetAutoHandleEvents, + (bool), auto_handle_events); + + m_opaque_up->SetAutoHandleEvents(auto_handle_events); +} + +bool SBCommandInterpreterRunOptions::GetSpawnThread() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions, + GetSpawnThread); + + return m_opaque_up->GetSpawnThread(); +} + +void SBCommandInterpreterRunOptions::SetSpawnThread(bool spawn_thread) { + LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetSpawnThread, + (bool), spawn_thread); + + m_opaque_up->SetSpawnThread(spawn_thread); +} + +lldb_private::CommandInterpreterRunOptions * +SBCommandInterpreterRunOptions::get() const { + return m_opaque_up.get(); +} + +lldb_private::CommandInterpreterRunOptions & +SBCommandInterpreterRunOptions::ref() const { + return *m_opaque_up; +} + +SBCommandInterpreterRunResult::SBCommandInterpreterRunResult() + : m_opaque_up(new CommandInterpreterRunResult()) + +{ + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommandInterpreterRunResult); +} + +SBCommandInterpreterRunResult::SBCommandInterpreterRunResult( + const SBCommandInterpreterRunResult &rhs) + : m_opaque_up(new CommandInterpreterRunResult()) { + LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreterRunResult, + (const lldb::SBCommandInterpreterRunResult &), rhs); + + *m_opaque_up = *rhs.m_opaque_up; +} + +SBCommandInterpreterRunResult::SBCommandInterpreterRunResult( + const CommandInterpreterRunResult &rhs) + : m_opaque_up() { + m_opaque_up = std::make_unique<CommandInterpreterRunResult>(rhs); +} + +SBCommandInterpreterRunResult::~SBCommandInterpreterRunResult() = default; + +SBCommandInterpreterRunResult &SBCommandInterpreterRunResult::operator=( + const SBCommandInterpreterRunResult &rhs) { + LLDB_RECORD_METHOD(lldb::SBCommandInterpreterRunResult &, + SBCommandInterpreterRunResult, + operator=,(const lldb::SBCommandInterpreterRunResult &), + rhs); + + if (this == &rhs) + return *this; + *m_opaque_up = *rhs.m_opaque_up; + return LLDB_RECORD_RESULT(*this); +} + +int SBCommandInterpreterRunResult::GetNumberOfErrors() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(int, SBCommandInterpreterRunResult, + GetNumberOfErrors); + + return m_opaque_up->GetNumErrors(); +} + +lldb::CommandInterpreterResult +SBCommandInterpreterRunResult::GetResult() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::CommandInterpreterResult, + SBCommandInterpreterRunResult, GetResult); + + return m_opaque_up->GetResult(); +} + +namespace lldb_private { +namespace repro { + +template <> void RegisterMethods<SBCommandInterpreterRunOptions>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreterRunOptions, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions, + GetStopOnContinue, ()); + LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnContinue, + (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions, + GetStopOnError, ()); + LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnError, + (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions, + GetStopOnCrash, ()); + LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnCrash, + (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions, + GetEchoCommands, ()); + LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetEchoCommands, + (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions, + GetEchoCommentCommands, ()); + LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, + SetEchoCommentCommands, (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions, + GetPrintResults, ()); + LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetPrintResults, + (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions, + GetAddToHistory, ()); + LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetAddToHistory, + (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions, + GetAutoHandleEvents, ()); + LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, + SetAutoHandleEvents, (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions, + GetSpawnThread, ()); + LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetSpawnThread, + (bool)); + LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreterRunResult, ()); + LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreterRunResult, + (const lldb::SBCommandInterpreterRunResult &)); + LLDB_REGISTER_METHOD(lldb::SBCommandInterpreterRunResult &, + SBCommandInterpreterRunResult, + operator=,(const lldb::SBCommandInterpreterRunResult &)); + LLDB_REGISTER_METHOD_CONST(int, SBCommandInterpreterRunResult, + GetNumberOfErrors, ()); + LLDB_REGISTER_METHOD_CONST(lldb::CommandInterpreterResult, + SBCommandInterpreterRunResult, GetResult, ()); +} + +} // namespace repro +} // namespace lldb_private diff --git a/contrib/llvm-project/lldb/source/API/SBCommandReturnObject.cpp b/contrib/llvm-project/lldb/source/API/SBCommandReturnObject.cpp new file mode 100644 index 000000000000..fddf90b66481 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBCommandReturnObject.cpp @@ -0,0 +1,435 @@ +//===-- SBCommandReturnObject.cpp -----------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBCommandReturnObject.h" +#include "SBReproducerPrivate.h" +#include "Utils.h" +#include "lldb/API/SBError.h" +#include "lldb/API/SBFile.h" +#include "lldb/API/SBStream.h" +#include "lldb/Interpreter/CommandReturnObject.h" +#include "lldb/Utility/ConstString.h" +#include "lldb/Utility/Status.h" + +using namespace lldb; +using namespace lldb_private; + +class lldb_private::SBCommandReturnObjectImpl { +public: + SBCommandReturnObjectImpl() + : m_ptr(new CommandReturnObject(false)), m_owned(true) {} + SBCommandReturnObjectImpl(CommandReturnObject &ref) + : m_ptr(&ref), m_owned(false) {} + SBCommandReturnObjectImpl(const SBCommandReturnObjectImpl &rhs) + : m_ptr(new CommandReturnObject(*rhs.m_ptr)), m_owned(rhs.m_owned) {} + SBCommandReturnObjectImpl &operator=(const SBCommandReturnObjectImpl &rhs) { + SBCommandReturnObjectImpl copy(rhs); + std::swap(*this, copy); + return *this; + } + // rvalue ctor+assignment are not used by SBCommandReturnObject. + ~SBCommandReturnObjectImpl() { + if (m_owned) + delete m_ptr; + } + + CommandReturnObject &operator*() const { return *m_ptr; } + +private: + CommandReturnObject *m_ptr; + bool m_owned; +}; + +SBCommandReturnObject::SBCommandReturnObject() + : m_opaque_up(new SBCommandReturnObjectImpl()) { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommandReturnObject); +} + +SBCommandReturnObject::SBCommandReturnObject(CommandReturnObject &ref) + : m_opaque_up(new SBCommandReturnObjectImpl(ref)) { + LLDB_RECORD_CONSTRUCTOR(SBCommandReturnObject, + (lldb_private::CommandReturnObject &), ref); +} + +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:: +operator=(const SBCommandReturnObject &rhs) { + LLDB_RECORD_METHOD( + lldb::SBCommandReturnObject &, + SBCommandReturnObject, operator=,(const lldb::SBCommandReturnObject &), + rhs); + + if (this != &rhs) + m_opaque_up = clone(rhs.m_opaque_up); + return LLDB_RECORD_RESULT(*this); +} + +SBCommandReturnObject::~SBCommandReturnObject() = default; + +bool SBCommandReturnObject::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandReturnObject, IsValid); + return this->operator bool(); +} +SBCommandReturnObject::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandReturnObject, operator bool); + + // This method is not useful but it needs to stay to keep SB API stable. + return true; +} + +const char *SBCommandReturnObject::GetOutput() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommandReturnObject, GetOutput); + + ConstString output(ref().GetOutputData()); + return output.AsCString(/*value_if_empty*/ ""); +} + +const char *SBCommandReturnObject::GetError() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommandReturnObject, GetError); + + ConstString output(ref().GetErrorData()); + return output.AsCString(/*value_if_empty*/ ""); +} + +size_t SBCommandReturnObject::GetOutputSize() { + LLDB_RECORD_METHOD_NO_ARGS(size_t, SBCommandReturnObject, GetOutputSize); + + return ref().GetOutputData().size(); +} + +size_t SBCommandReturnObject::GetErrorSize() { + LLDB_RECORD_METHOD_NO_ARGS(size_t, SBCommandReturnObject, GetErrorSize); + + return ref().GetErrorData().size(); +} + +size_t SBCommandReturnObject::PutOutput(FILE *fh) { + LLDB_RECORD_DUMMY(size_t, SBCommandReturnObject, PutOutput, (FILE *), fh); + if (fh) { + size_t num_bytes = GetOutputSize(); + if (num_bytes) + return ::fprintf(fh, "%s", GetOutput()); + } + return 0; +} + +size_t SBCommandReturnObject::PutOutput(FileSP file_sp) { + LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutOutput, (FileSP), + file_sp); + if (!file_sp) + return 0; + return file_sp->Printf("%s", GetOutput()); +} + +size_t SBCommandReturnObject::PutOutput(SBFile file) { + LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutOutput, (SBFile), file); + if (!file.m_opaque_sp) + return 0; + return file.m_opaque_sp->Printf("%s", GetOutput()); +} + +size_t SBCommandReturnObject::PutError(FILE *fh) { + LLDB_RECORD_DUMMY(size_t, SBCommandReturnObject, PutError, (FILE *), fh); + if (fh) { + size_t num_bytes = GetErrorSize(); + if (num_bytes) + return ::fprintf(fh, "%s", GetError()); + } + return 0; +} + +size_t SBCommandReturnObject::PutError(FileSP file_sp) { + LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutError, (FileSP), + file_sp); + if (!file_sp) + return 0; + return file_sp->Printf("%s", GetError()); +} + +size_t SBCommandReturnObject::PutError(SBFile file) { + LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutError, (SBFile), file); + if (!file.m_opaque_sp) + return 0; + return file.m_opaque_sp->Printf("%s", GetError()); +} + +void SBCommandReturnObject::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBCommandReturnObject, Clear); + + ref().Clear(); +} + +lldb::ReturnStatus SBCommandReturnObject::GetStatus() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::ReturnStatus, SBCommandReturnObject, + GetStatus); + + return ref().GetStatus(); +} + +void SBCommandReturnObject::SetStatus(lldb::ReturnStatus status) { + LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetStatus, + (lldb::ReturnStatus), status); + + ref().SetStatus(status); +} + +bool SBCommandReturnObject::Succeeded() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandReturnObject, Succeeded); + + return ref().Succeeded(); +} + +bool SBCommandReturnObject::HasResult() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandReturnObject, HasResult); + + return ref().HasResult(); +} + +void SBCommandReturnObject::AppendMessage(const char *message) { + LLDB_RECORD_METHOD(void, SBCommandReturnObject, AppendMessage, (const char *), + message); + + ref().AppendMessage(message); +} + +void SBCommandReturnObject::AppendWarning(const char *message) { + LLDB_RECORD_METHOD(void, SBCommandReturnObject, AppendWarning, (const char *), + message); + + ref().AppendWarning(message); +} + +CommandReturnObject *SBCommandReturnObject::operator->() const { + return &**m_opaque_up; +} + +CommandReturnObject *SBCommandReturnObject::get() const { + return &**m_opaque_up; +} + +CommandReturnObject &SBCommandReturnObject::operator*() const { + return **m_opaque_up; +} + +CommandReturnObject &SBCommandReturnObject::ref() const { + return **m_opaque_up; +} + +bool SBCommandReturnObject::GetDescription(SBStream &description) { + LLDB_RECORD_METHOD(bool, SBCommandReturnObject, GetDescription, + (lldb::SBStream &), description); + + Stream &strm = description.ref(); + + description.Printf("Error: "); + lldb::ReturnStatus status = ref().GetStatus(); + if (status == lldb::eReturnStatusStarted) + strm.PutCString("Started"); + else if (status == lldb::eReturnStatusInvalid) + strm.PutCString("Invalid"); + else if (ref().Succeeded()) + strm.PutCString("Success"); + else + strm.PutCString("Fail"); + + if (GetOutputSize() > 0) + strm.Printf("\nOutput Message:\n%s", GetOutput()); + + if (GetErrorSize() > 0) + strm.Printf("\nError Message:\n%s", GetError()); + + return true; +} + +void SBCommandReturnObject::SetImmediateOutputFile(FILE *fh) { + LLDB_RECORD_DUMMY(void, SBCommandReturnObject, SetImmediateOutputFile, + (FILE *), fh); + + SetImmediateOutputFile(fh, false); +} + +void SBCommandReturnObject::SetImmediateErrorFile(FILE *fh) { + LLDB_RECORD_DUMMY(void, SBCommandReturnObject, SetImmediateErrorFile, + (FILE *), fh); + + SetImmediateErrorFile(fh, false); +} + +void SBCommandReturnObject::SetImmediateOutputFile(FILE *fh, + bool transfer_ownership) { + LLDB_RECORD_DUMMY(void, SBCommandReturnObject, SetImmediateOutputFile, + (FILE *, bool), fh, transfer_ownership); + FileSP file = std::make_shared<NativeFile>(fh, transfer_ownership); + ref().SetImmediateOutputFile(file); +} + +void SBCommandReturnObject::SetImmediateErrorFile(FILE *fh, + bool transfer_ownership) { + LLDB_RECORD_DUMMY(void, SBCommandReturnObject, SetImmediateErrorFile, + (FILE *, bool), fh, transfer_ownership); + FileSP file = std::make_shared<NativeFile>(fh, transfer_ownership); + ref().SetImmediateErrorFile(file); +} + +void SBCommandReturnObject::SetImmediateOutputFile(SBFile file) { + LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile, + (SBFile), file); + ref().SetImmediateOutputFile(file.m_opaque_sp); +} + +void SBCommandReturnObject::SetImmediateErrorFile(SBFile file) { + LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile, + (SBFile), file); + ref().SetImmediateErrorFile(file.m_opaque_sp); +} + +void SBCommandReturnObject::SetImmediateOutputFile(FileSP file_sp) { + LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile, + (FileSP), file_sp); + SetImmediateOutputFile(SBFile(file_sp)); +} + +void SBCommandReturnObject::SetImmediateErrorFile(FileSP file_sp) { + LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile, + (FileSP), file_sp); + SetImmediateErrorFile(SBFile(file_sp)); +} + +void SBCommandReturnObject::PutCString(const char *string, int len) { + LLDB_RECORD_METHOD(void, SBCommandReturnObject, PutCString, + (const char *, int), string, len); + + if (len == 0 || string == nullptr || *string == 0) { + return; + } else if (len > 0) { + std::string buffer(string, len); + ref().AppendMessage(buffer.c_str()); + } else + ref().AppendMessage(string); +} + +const char *SBCommandReturnObject::GetOutput(bool only_if_no_immediate) { + LLDB_RECORD_METHOD(const char *, SBCommandReturnObject, GetOutput, (bool), + only_if_no_immediate); + + if (!only_if_no_immediate || + ref().GetImmediateOutputStream().get() == nullptr) + return GetOutput(); + return nullptr; +} + +const char *SBCommandReturnObject::GetError(bool only_if_no_immediate) { + LLDB_RECORD_METHOD(const char *, SBCommandReturnObject, GetError, (bool), + only_if_no_immediate); + + if (!only_if_no_immediate || ref().GetImmediateErrorStream().get() == nullptr) + return GetError(); + return nullptr; +} + +size_t SBCommandReturnObject::Printf(const char *format, ...) { + va_list args; + va_start(args, format); + size_t result = ref().GetOutputStream().PrintfVarArg(format, args); + va_end(args); + return result; +} + +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 (error.IsValid()) + ref().SetError(error.ref(), fallback_error_cstr); + else if (fallback_error_cstr) + ref().SetError(Status(), fallback_error_cstr); +} + +void SBCommandReturnObject::SetError(const char *error_cstr) { + LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetError, (const char *), + error_cstr); + + if (error_cstr) + ref().SetError(error_cstr); +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBCommandReturnObject>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBCommandReturnObject, ()); + LLDB_REGISTER_CONSTRUCTOR(SBCommandReturnObject, + (lldb_private::CommandReturnObject &)); + LLDB_REGISTER_CONSTRUCTOR(SBCommandReturnObject, + (const lldb::SBCommandReturnObject &)); + LLDB_REGISTER_METHOD( + lldb::SBCommandReturnObject &, + SBCommandReturnObject, operator=,(const lldb::SBCommandReturnObject &)); + LLDB_REGISTER_METHOD_CONST(bool, SBCommandReturnObject, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBCommandReturnObject, operator bool, ()); + LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetOutput, ()); + LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetError, ()); + LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, GetOutputSize, ()); + LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, GetErrorSize, ()); + LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutOutput, (FILE *)); + LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutError, (FILE *)); + LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutOutput, (SBFile)); + LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutError, (SBFile)); + LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutOutput, (FileSP)); + LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutError, (FileSP)); + LLDB_REGISTER_METHOD(void, SBCommandReturnObject, Clear, ()); + LLDB_REGISTER_METHOD(lldb::ReturnStatus, SBCommandReturnObject, GetStatus, + ()); + LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetStatus, + (lldb::ReturnStatus)); + LLDB_REGISTER_METHOD(bool, SBCommandReturnObject, Succeeded, ()); + LLDB_REGISTER_METHOD(bool, SBCommandReturnObject, HasResult, ()); + LLDB_REGISTER_METHOD(void, SBCommandReturnObject, AppendMessage, + (const char *)); + LLDB_REGISTER_METHOD(void, SBCommandReturnObject, AppendWarning, + (const char *)); + LLDB_REGISTER_METHOD(bool, SBCommandReturnObject, GetDescription, + (lldb::SBStream &)); + LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile, + (FILE *)); + LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile, + (FILE *)); + LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile, + (SBFile)); + LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile, + (SBFile)); + LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile, + (FileSP)); + LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile, + (FileSP)); + LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile, + (FILE *, bool)); + LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile, + (FILE *, bool)); + LLDB_REGISTER_METHOD(void, SBCommandReturnObject, PutCString, + (const char *, int)); + LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetOutput, + (bool)); + LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetError, (bool)); + LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetError, + (lldb::SBError &, const char *)); + LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetError, (const char *)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBCommunication.cpp b/contrib/llvm-project/lldb/source/API/SBCommunication.cpp new file mode 100644 index 000000000000..d55ecd35b557 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBCommunication.cpp @@ -0,0 +1,216 @@ +//===-- SBCommunication.cpp -----------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBCommunication.h" +#include "SBReproducerPrivate.h" +#include "lldb/API/SBBroadcaster.h" +#include "lldb/Core/Communication.h" +#include "lldb/Host/ConnectionFileDescriptor.h" +#include "lldb/Host/Host.h" + +using namespace lldb; +using namespace lldb_private; + +SBCommunication::SBCommunication() : m_opaque(nullptr), 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); +} + +SBCommunication::~SBCommunication() { + if (m_opaque && m_opaque_owned) + delete m_opaque; + m_opaque = nullptr; + m_opaque_owned = false; +} + +bool SBCommunication::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommunication, IsValid); + return this->operator bool(); +} +SBCommunication::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommunication, operator bool); + + return m_opaque != nullptr; +} + +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)); + return m_opaque->Connect(url, nullptr); + } + return eConnectionStatusNoConnection; +} + +ConnectionStatus SBCommunication::AdoptFileDesriptor(int fd, bool owns_fd) { + LLDB_RECORD_METHOD(lldb::ConnectionStatus, SBCommunication, + AdoptFileDesriptor, (int, bool), fd, owns_fd); + + ConnectionStatus status = eConnectionStatusNoConnection; + if (m_opaque) { + if (m_opaque->HasConnection()) { + if (m_opaque->IsConnected()) + m_opaque->Disconnect(); + } + m_opaque->SetConnection( + std::make_unique<ConnectionFileDescriptor>(fd, owns_fd)); + if (m_opaque->IsConnected()) + status = eConnectionStatusSuccess; + else + status = eConnectionStatusLostConnection; + } + return status; +} + +ConnectionStatus SBCommunication::Disconnect() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::ConnectionStatus, SBCommunication, + Disconnect); + + ConnectionStatus status = eConnectionStatusNoConnection; + if (m_opaque) + status = m_opaque->Disconnect(); + return status; +} + +bool SBCommunication::IsConnected() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommunication, IsConnected); + + return m_opaque ? m_opaque->IsConnected() : false; +} + +size_t SBCommunication::Read(void *dst, size_t dst_len, uint32_t timeout_usec, + ConnectionStatus &status) { + LLDB_RECORD_DUMMY(size_t, SBCommunication, Read, + (void *, size_t, uint32_t, lldb::ConnectionStatus &), dst, + dst_len, timeout_usec, status); + + size_t bytes_read = 0; + Timeout<std::micro> timeout = timeout_usec == UINT32_MAX + ? Timeout<std::micro>(llvm::None) + : std::chrono::microseconds(timeout_usec); + if (m_opaque) + bytes_read = m_opaque->Read(dst, dst_len, timeout, status, nullptr); + else + status = eConnectionStatusNoConnection; + + return bytes_read; +} + +size_t SBCommunication::Write(const void *src, size_t src_len, + ConnectionStatus &status) { + LLDB_RECORD_DUMMY(size_t, SBCommunication, Write, + (const void *, size_t, lldb::ConnectionStatus &), src, + src_len, status); + + size_t bytes_written = 0; + if (m_opaque) + bytes_written = m_opaque->Write(src, src_len, status, nullptr); + else + status = eConnectionStatusNoConnection; + + return bytes_written; +} + +bool SBCommunication::ReadThreadStart() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadStart); + + return m_opaque ? m_opaque->StartReadThread() : false; +} + +bool SBCommunication::ReadThreadStop() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadStop); + + return m_opaque ? m_opaque->StopReadThread() : false; +} + +bool SBCommunication::ReadThreadIsRunning() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadIsRunning); + + return m_opaque ? m_opaque->ReadThreadIsRunning() : false; +} + +bool SBCommunication::SetReadThreadBytesReceivedCallback( + ReadThreadBytesReceived callback, void *callback_baton) { + LLDB_RECORD_DUMMY(bool, SBCommunication, SetReadThreadBytesReceivedCallback, + (lldb::SBCommunication::ReadThreadBytesReceived, void *), + callback, callback_baton); + + bool result = false; + if (m_opaque) { + m_opaque->SetReadThreadBytesReceivedCallback(callback, callback_baton); + result = true; + } + return result; +} + +SBBroadcaster SBCommunication::GetBroadcaster() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBroadcaster, SBCommunication, + GetBroadcaster); + + SBBroadcaster broadcaster(m_opaque, false); + return LLDB_RECORD_RESULT(broadcaster); +} + +const char *SBCommunication::GetBroadcasterClass() { + LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBCommunication, + GetBroadcasterClass); + + return Communication::GetStaticBroadcasterClass().AsCString(); +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBCommunication>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBCommunication, ()); + LLDB_REGISTER_CONSTRUCTOR(SBCommunication, (const char *)); + LLDB_REGISTER_METHOD_CONST(bool, SBCommunication, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBCommunication, operator bool, ()); + LLDB_REGISTER_METHOD(bool, SBCommunication, GetCloseOnEOF, ()); + LLDB_REGISTER_METHOD(void, SBCommunication, SetCloseOnEOF, (bool)); + LLDB_REGISTER_METHOD(lldb::ConnectionStatus, SBCommunication, Connect, + (const char *)); + LLDB_REGISTER_METHOD(lldb::ConnectionStatus, SBCommunication, + AdoptFileDesriptor, (int, bool)); + LLDB_REGISTER_METHOD(lldb::ConnectionStatus, SBCommunication, Disconnect, + ()); + LLDB_REGISTER_METHOD_CONST(bool, SBCommunication, IsConnected, ()); + LLDB_REGISTER_METHOD(bool, SBCommunication, ReadThreadStart, ()); + LLDB_REGISTER_METHOD(bool, SBCommunication, ReadThreadStop, ()); + LLDB_REGISTER_METHOD(bool, SBCommunication, ReadThreadIsRunning, ()); + LLDB_REGISTER_METHOD(lldb::SBBroadcaster, SBCommunication, GetBroadcaster, + ()); + LLDB_REGISTER_STATIC_METHOD(const char *, SBCommunication, + GetBroadcasterClass, ()); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBCompileUnit.cpp b/contrib/llvm-project/lldb/source/API/SBCompileUnit.cpp new file mode 100644 index 000000000000..765957d680c9 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBCompileUnit.cpp @@ -0,0 +1,277 @@ +//===-- SBCompileUnit.cpp -------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBCompileUnit.h" +#include "SBReproducerPrivate.h" +#include "lldb/API/SBLineEntry.h" +#include "lldb/API/SBStream.h" +#include "lldb/Core/Module.h" +#include "lldb/Symbol/CompileUnit.h" +#include "lldb/Symbol/LineEntry.h" +#include "lldb/Symbol/LineTable.h" +#include "lldb/Symbol/SymbolFile.h" +#include "lldb/Symbol/Type.h" +#include "lldb/Symbol/TypeList.h" + +using namespace lldb; +using namespace lldb_private; + +SBCompileUnit::SBCompileUnit() : m_opaque_ptr(nullptr) { + 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) { + 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 LLDB_RECORD_RESULT(*this); +} + +SBCompileUnit::~SBCompileUnit() { m_opaque_ptr = nullptr; } + +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->GetPrimaryFile()); + 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) { + return line_table->GetSize(); + } + } + return 0; +} + +SBLineEntry SBCompileUnit::GetLineEntryAtIndex(uint32_t idx) const { + LLDB_RECORD_METHOD_CONST(lldb::SBLineEntry, SBCompileUnit, + GetLineEntryAtIndex, (uint32_t), idx); + + SBLineEntry sb_line_entry; + if (m_opaque_ptr) { + LineTable *line_table = m_opaque_ptr->GetLineTable(); + if (line_table) { + LineEntry line_entry; + if (line_table->GetLineEntryAtIndex(idx, line_entry)) + sb_line_entry.SetLineEntry(line_entry); + } + } + + return LLDB_RECORD_RESULT(sb_line_entry); +} + +uint32_t SBCompileUnit::FindLineEntryIndex(uint32_t start_idx, uint32_t line, + SBFileSpec *inline_file_spec) const { + LLDB_RECORD_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex, + (uint32_t, uint32_t, lldb::SBFileSpec *), start_idx, + line, inline_file_spec); + + const bool exact = true; + return FindLineEntryIndex(start_idx, line, inline_file_spec, exact); +} + +uint32_t SBCompileUnit::FindLineEntryIndex(uint32_t start_idx, uint32_t line, + SBFileSpec *inline_file_spec, + bool exact) const { + LLDB_RECORD_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex, + (uint32_t, uint32_t, lldb::SBFileSpec *, bool), + start_idx, line, inline_file_spec, exact); + + uint32_t index = UINT32_MAX; + if (m_opaque_ptr) { + FileSpec file_spec; + if (inline_file_spec && inline_file_spec->IsValid()) + file_spec = inline_file_spec->ref(); + else + file_spec = m_opaque_ptr->GetPrimaryFile(); + + index = m_opaque_ptr->FindLineEntry( + start_idx, line, inline_file_spec ? inline_file_spec->get() : nullptr, + exact, nullptr); + } + + return index; +} + +uint32_t SBCompileUnit::GetNumSupportFiles() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBCompileUnit, GetNumSupportFiles); + + if (m_opaque_ptr) + return m_opaque_ptr->GetSupportFiles().GetSize(); + + return 0; +} + +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 LLDB_RECORD_RESULT(sb_type_list); + + ModuleSP module_sp(m_opaque_ptr->GetModule()); + if (!module_sp) + return LLDB_RECORD_RESULT(sb_type_list); + + SymbolFile *symfile = module_sp->GetSymbolFile(); + if (!symfile) + return LLDB_RECORD_RESULT(sb_type_list); + + TypeClass type_class = static_cast<TypeClass>(type_mask); + TypeList type_list; + symfile->GetTypes(m_opaque_ptr, type_class, type_list); + sb_type_list.m_opaque_up->Append(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); + + SBFileSpec sb_file_spec; + if (m_opaque_ptr) { + FileSpec spec = m_opaque_ptr->GetSupportFiles().GetFileSpecAtIndex(idx); + sb_file_spec.SetFileSpec(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) { + const FileSpecList &support_files = m_opaque_ptr->GetSupportFiles(); + return support_files.FindFileIndex(start_idx, sb_file.ref(), full); + } + return 0; +} + +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 { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCompileUnit, IsValid); + return this->operator bool(); +} +SBCompileUnit::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCompileUnit, operator bool); + + return m_opaque_ptr != nullptr; +} + +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; +} + +const lldb_private::CompileUnit *SBCompileUnit::operator->() const { + return m_opaque_ptr; +} + +const lldb_private::CompileUnit &SBCompileUnit::operator*() const { + return *m_opaque_ptr; +} + +lldb_private::CompileUnit *SBCompileUnit::get() { return m_opaque_ptr; } + +void SBCompileUnit::reset(lldb_private::CompileUnit *lldb_object_ptr) { + m_opaque_ptr = 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) { + m_opaque_ptr->Dump(&strm, false); + } else + strm.PutCString("No value"); + + return true; +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBCompileUnit>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBCompileUnit, ()); + LLDB_REGISTER_CONSTRUCTOR(SBCompileUnit, (const lldb::SBCompileUnit &)); + LLDB_REGISTER_METHOD( + const lldb::SBCompileUnit &, + SBCompileUnit, operator=,(const lldb::SBCompileUnit &)); + LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBCompileUnit, GetFileSpec, + ()); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, GetNumLineEntries, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBLineEntry, SBCompileUnit, + GetLineEntryAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex, + (uint32_t, uint32_t, lldb::SBFileSpec *)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex, + (uint32_t, uint32_t, lldb::SBFileSpec *, bool)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, GetNumSupportFiles, ()); + LLDB_REGISTER_METHOD(lldb::SBTypeList, SBCompileUnit, GetTypes, (uint32_t)); + LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBCompileUnit, + GetSupportFileAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(uint32_t, SBCompileUnit, FindSupportFileIndex, + (uint32_t, const lldb::SBFileSpec &, bool)); + LLDB_REGISTER_METHOD(lldb::LanguageType, SBCompileUnit, GetLanguage, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBCompileUnit, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBCompileUnit, operator bool, ()); + LLDB_REGISTER_METHOD_CONST( + bool, SBCompileUnit, operator==,(const lldb::SBCompileUnit &)); + LLDB_REGISTER_METHOD_CONST( + bool, SBCompileUnit, operator!=,(const lldb::SBCompileUnit &)); + LLDB_REGISTER_METHOD(bool, SBCompileUnit, GetDescription, + (lldb::SBStream &)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBData.cpp b/contrib/llvm-project/lldb/source/API/SBData.cpp new file mode 100644 index 000000000000..daf313ad55c9 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBData.cpp @@ -0,0 +1,724 @@ +//===-- SBData.cpp --------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBData.h" +#include "SBReproducerPrivate.h" +#include "lldb/API/SBError.h" +#include "lldb/API/SBStream.h" + +#include "lldb/Core/DumpDataExtractor.h" +#include "lldb/Utility/DataBufferHeap.h" +#include "lldb/Utility/DataExtractor.h" +#include "lldb/Utility/Stream.h" + +#include <cinttypes> +#include <memory> + +using namespace lldb; +using namespace lldb_private; + +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) { + 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 LLDB_RECORD_RESULT(*this); +} + +SBData::~SBData() = default; + +void SBData::SetOpaque(const lldb::DataExtractorSP &data_sp) { + m_opaque_sp = data_sp; +} + +lldb_private::DataExtractor *SBData::get() const { return m_opaque_sp.get(); } + +lldb_private::DataExtractor *SBData::operator->() const { + return m_opaque_sp.operator->(); +} + +lldb::DataExtractorSP &SBData::operator*() { return m_opaque_sp; } + +const lldb::DataExtractorSP &SBData::operator*() const { return m_opaque_sp; } + +bool SBData::IsValid() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBData, IsValid); + return this->operator bool(); +} +SBData::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBData, operator bool); + + return m_opaque_sp.get() != nullptr; +} + +uint8_t SBData::GetAddressByteSize() { + LLDB_RECORD_METHOD_NO_ARGS(uint8_t, SBData, GetAddressByteSize); + + uint8_t value = 0; + if (m_opaque_sp.get()) + value = m_opaque_sp->GetAddressByteSize(); + return value; +} + +void SBData::SetAddressByteSize(uint8_t addr_byte_size) { + LLDB_RECORD_METHOD(void, SBData, SetAddressByteSize, (uint8_t), + addr_byte_size); + + if (m_opaque_sp.get()) + m_opaque_sp->SetAddressByteSize(addr_byte_size); +} + +void SBData::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBData, Clear); + + if (m_opaque_sp.get()) + m_opaque_sp->Clear(); +} + +size_t SBData::GetByteSize() { + LLDB_RECORD_METHOD_NO_ARGS(size_t, SBData, GetByteSize); + + size_t value = 0; + if (m_opaque_sp.get()) + value = m_opaque_sp->GetByteSize(); + return value; +} + +lldb::ByteOrder SBData::GetByteOrder() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::ByteOrder, SBData, GetByteOrder); + + lldb::ByteOrder value = eByteOrderInvalid; + if (m_opaque_sp.get()) + value = m_opaque_sp->GetByteOrder(); + return value; +} + +void SBData::SetByteOrder(lldb::ByteOrder endian) { + LLDB_RECORD_METHOD(void, SBData, SetByteOrder, (lldb::ByteOrder), endian); + + if (m_opaque_sp.get()) + m_opaque_sp->SetByteOrder(endian); +} + +float SBData::GetFloat(lldb::SBError &error, lldb::offset_t offset) { + LLDB_RECORD_METHOD(float, SBData, GetFloat, (lldb::SBError &, lldb::offset_t), + error, offset); + + float value = 0; + if (!m_opaque_sp.get()) { + error.SetErrorString("no value to read from"); + } else { + uint32_t old_offset = offset; + value = m_opaque_sp->GetFloat(&offset); + if (offset == old_offset) + error.SetErrorString("unable to read data"); + } + return value; +} + +double SBData::GetDouble(lldb::SBError &error, lldb::offset_t offset) { + LLDB_RECORD_METHOD(double, SBData, GetDouble, + (lldb::SBError &, lldb::offset_t), error, offset); + + double value = 0; + if (!m_opaque_sp.get()) { + error.SetErrorString("no value to read from"); + } else { + uint32_t old_offset = offset; + value = m_opaque_sp->GetDouble(&offset); + if (offset == old_offset) + error.SetErrorString("unable to read data"); + } + return value; +} + +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); + + long double value = 0; + if (!m_opaque_sp.get()) { + error.SetErrorString("no value to read from"); + } else { + uint32_t old_offset = offset; + value = m_opaque_sp->GetLongDouble(&offset); + if (offset == old_offset) + error.SetErrorString("unable to read data"); + } + return value; +} + +lldb::addr_t SBData::GetAddress(lldb::SBError &error, lldb::offset_t offset) { + LLDB_RECORD_METHOD(lldb::addr_t, SBData, GetAddress, + (lldb::SBError &, lldb::offset_t), error, offset); + + lldb::addr_t value = 0; + if (!m_opaque_sp.get()) { + error.SetErrorString("no value to read from"); + } else { + uint32_t old_offset = offset; + value = m_opaque_sp->GetAddress(&offset); + if (offset == old_offset) + error.SetErrorString("unable to read data"); + } + return value; +} + +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); + + uint8_t value = 0; + if (!m_opaque_sp.get()) { + error.SetErrorString("no value to read from"); + } else { + uint32_t old_offset = offset; + value = m_opaque_sp->GetU8(&offset); + if (offset == old_offset) + error.SetErrorString("unable to read data"); + } + return value; +} + +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); + + uint16_t value = 0; + if (!m_opaque_sp.get()) { + error.SetErrorString("no value to read from"); + } else { + uint32_t old_offset = offset; + value = m_opaque_sp->GetU16(&offset); + if (offset == old_offset) + error.SetErrorString("unable to read data"); + } + return value; +} + +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); + + uint32_t value = 0; + if (!m_opaque_sp.get()) { + error.SetErrorString("no value to read from"); + } else { + uint32_t old_offset = offset; + value = m_opaque_sp->GetU32(&offset); + if (offset == old_offset) + error.SetErrorString("unable to read data"); + } + return value; +} + +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); + + uint64_t value = 0; + if (!m_opaque_sp.get()) { + error.SetErrorString("no value to read from"); + } else { + uint32_t old_offset = offset; + value = m_opaque_sp->GetU64(&offset); + if (offset == old_offset) + error.SetErrorString("unable to read data"); + } + return value; +} + +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); + + int8_t value = 0; + if (!m_opaque_sp.get()) { + error.SetErrorString("no value to read from"); + } else { + uint32_t old_offset = offset; + value = (int8_t)m_opaque_sp->GetMaxS64(&offset, 1); + if (offset == old_offset) + error.SetErrorString("unable to read data"); + } + return value; +} + +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); + + int16_t value = 0; + if (!m_opaque_sp.get()) { + error.SetErrorString("no value to read from"); + } else { + uint32_t old_offset = offset; + value = (int16_t)m_opaque_sp->GetMaxS64(&offset, 2); + if (offset == old_offset) + error.SetErrorString("unable to read data"); + } + return value; +} + +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); + + int32_t value = 0; + if (!m_opaque_sp.get()) { + error.SetErrorString("no value to read from"); + } else { + uint32_t old_offset = offset; + value = (int32_t)m_opaque_sp->GetMaxS64(&offset, 4); + if (offset == old_offset) + error.SetErrorString("unable to read data"); + } + return value; +} + +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); + + int64_t value = 0; + if (!m_opaque_sp.get()) { + error.SetErrorString("no value to read from"); + } else { + uint32_t old_offset = offset; + value = (int64_t)m_opaque_sp->GetMaxS64(&offset, 8); + if (offset == old_offset) + error.SetErrorString("unable to read data"); + } + return value; +} + +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); + + const char *value = nullptr; + if (!m_opaque_sp.get()) { + error.SetErrorString("no value to read from"); + } else { + uint32_t old_offset = offset; + value = m_opaque_sp->GetCStr(&offset); + if (offset == old_offset || (value == nullptr)) + error.SetErrorString("unable to read data"); + } + return value; +} + +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) { + DumpDataExtractor(*m_opaque_sp, &strm, 0, lldb::eFormatBytesWithASCII, 1, + m_opaque_sp->GetByteSize(), 16, base_addr, 0, 0); + } else + strm.PutCString("No value"); + + return true; +} + +size_t SBData::ReadRawData(lldb::SBError &error, lldb::offset_t offset, + void *buf, size_t size) { + LLDB_RECORD_DUMMY(size_t, SBData, ReadRawData, + (lldb::SBError &, lldb::offset_t, void *, size_t), error, + offset, buf, size); + + void *ok = nullptr; + if (!m_opaque_sp.get()) { + error.SetErrorString("no value to read from"); + } else { + uint32_t old_offset = offset; + ok = m_opaque_sp->GetU8(&offset, buf, size); + if ((offset == old_offset) || (ok == nullptr)) + error.SetErrorString("unable to read data"); + } + return ok ? size : 0; +} + +void SBData::SetData(lldb::SBError &error, const void *buf, size_t size, + lldb::ByteOrder endian, uint8_t addr_size) { + LLDB_RECORD_DUMMY( + void, SBData, SetData, + (lldb::SBError &, const void *, size_t, lldb::ByteOrder, uint8_t), error, + buf, size, endian, addr_size); + + if (!m_opaque_sp.get()) + m_opaque_sp = std::make_shared<DataExtractor>(buf, size, endian, addr_size); + else + { + m_opaque_sp->SetData(buf, size, endian); + m_opaque_sp->SetAddressByteSize(addr_size); + } +} + +bool SBData::Append(const SBData &rhs) { + LLDB_RECORD_METHOD(bool, SBData, Append, (const lldb::SBData &), rhs); + + bool value = false; + if (m_opaque_sp.get() && rhs.m_opaque_sp.get()) + value = m_opaque_sp.get()->Append(*rhs.m_opaque_sp); + return value; +} + +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 LLDB_RECORD_RESULT(SBData()); + + uint32_t data_len = strlen(data); + + lldb::DataBufferSP buffer_sp(new DataBufferHeap(data, data_len)); + lldb::DataExtractorSP data_sp( + new DataExtractor(buffer_sp, endian, addr_byte_size)); + + SBData ret(data_sp); + + 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 LLDB_RECORD_RESULT(SBData()); + + size_t data_len = array_len * sizeof(uint64_t); + + lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len)); + lldb::DataExtractorSP data_sp( + new DataExtractor(buffer_sp, endian, addr_byte_size)); + + SBData ret(data_sp); + + 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 LLDB_RECORD_RESULT(SBData()); + + size_t data_len = array_len * sizeof(uint32_t); + + lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len)); + lldb::DataExtractorSP data_sp( + new DataExtractor(buffer_sp, endian, addr_byte_size)); + + SBData ret(data_sp); + + 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 LLDB_RECORD_RESULT(SBData()); + + size_t data_len = array_len * sizeof(int64_t); + + lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len)); + lldb::DataExtractorSP data_sp( + new DataExtractor(buffer_sp, endian, addr_byte_size)); + + SBData ret(data_sp); + + 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 LLDB_RECORD_RESULT(SBData()); + + size_t data_len = array_len * sizeof(int32_t); + + lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len)); + lldb::DataExtractorSP data_sp( + new DataExtractor(buffer_sp, endian, addr_byte_size)); + + SBData ret(data_sp); + + 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 LLDB_RECORD_RESULT(SBData()); + + size_t data_len = array_len * sizeof(double); + + lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len)); + lldb::DataExtractorSP data_sp( + new DataExtractor(buffer_sp, endian, addr_byte_size)); + + SBData ret(data_sp); + + return LLDB_RECORD_RESULT(ret); +} + +bool SBData::SetDataFromCString(const char *data) { + LLDB_RECORD_METHOD(bool, SBData, SetDataFromCString, (const char *), data); + + + if (!data) { + return false; + } + + size_t data_len = strlen(data); + + lldb::DataBufferSP buffer_sp(new DataBufferHeap(data, data_len)); + + if (!m_opaque_sp.get()) + m_opaque_sp = std::make_shared<DataExtractor>(buffer_sp, GetByteOrder(), + GetAddressByteSize()); + else + m_opaque_sp->SetData(buffer_sp); + + + return true; +} + +bool SBData::SetDataFromUInt64Array(uint64_t *array, size_t array_len) { + LLDB_RECORD_METHOD(bool, SBData, SetDataFromUInt64Array, (uint64_t *, size_t), + array, array_len); + + + if (!array || array_len == 0) { + return false; + } + + size_t data_len = array_len * sizeof(uint64_t); + + lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len)); + + if (!m_opaque_sp.get()) + m_opaque_sp = std::make_shared<DataExtractor>(buffer_sp, GetByteOrder(), + GetAddressByteSize()); + else + m_opaque_sp->SetData(buffer_sp); + + + return true; +} + +bool SBData::SetDataFromUInt32Array(uint32_t *array, size_t array_len) { + LLDB_RECORD_METHOD(bool, SBData, SetDataFromUInt32Array, (uint32_t *, size_t), + array, array_len); + + + if (!array || array_len == 0) { + return false; + } + + size_t data_len = array_len * sizeof(uint32_t); + + lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len)); + + if (!m_opaque_sp.get()) + m_opaque_sp = std::make_shared<DataExtractor>(buffer_sp, GetByteOrder(), + GetAddressByteSize()); + else + m_opaque_sp->SetData(buffer_sp); + + return true; +} + +bool SBData::SetDataFromSInt64Array(int64_t *array, size_t array_len) { + LLDB_RECORD_METHOD(bool, SBData, SetDataFromSInt64Array, (int64_t *, size_t), + array, array_len); + + + if (!array || array_len == 0) { + return false; + } + + size_t data_len = array_len * sizeof(int64_t); + + lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len)); + + if (!m_opaque_sp.get()) + m_opaque_sp = std::make_shared<DataExtractor>(buffer_sp, GetByteOrder(), + GetAddressByteSize()); + else + m_opaque_sp->SetData(buffer_sp); + + return true; +} + +bool SBData::SetDataFromSInt32Array(int32_t *array, size_t array_len) { + LLDB_RECORD_METHOD(bool, SBData, SetDataFromSInt32Array, (int32_t *, size_t), + array, array_len); + + + if (!array || array_len == 0) { + return false; + } + + size_t data_len = array_len * sizeof(int32_t); + + lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len)); + + if (!m_opaque_sp.get()) + m_opaque_sp = std::make_shared<DataExtractor>(buffer_sp, GetByteOrder(), + GetAddressByteSize()); + else + m_opaque_sp->SetData(buffer_sp); + + return true; +} + +bool SBData::SetDataFromDoubleArray(double *array, size_t array_len) { + LLDB_RECORD_METHOD(bool, SBData, SetDataFromDoubleArray, (double *, size_t), + array, array_len); + + + if (!array || array_len == 0) { + return false; + } + + size_t data_len = array_len * sizeof(double); + + lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len)); + + if (!m_opaque_sp.get()) + m_opaque_sp = std::make_shared<DataExtractor>(buffer_sp, GetByteOrder(), + GetAddressByteSize()); + else + m_opaque_sp->SetData(buffer_sp); + + return true; +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBData>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBData, ()); + LLDB_REGISTER_CONSTRUCTOR(SBData, (const lldb::SBData &)); + LLDB_REGISTER_METHOD(const lldb::SBData &, + SBData, operator=,(const lldb::SBData &)); + LLDB_REGISTER_METHOD(bool, SBData, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBData, operator bool, ()); + LLDB_REGISTER_METHOD(uint8_t, SBData, GetAddressByteSize, ()); + LLDB_REGISTER_METHOD(void, SBData, SetAddressByteSize, (uint8_t)); + LLDB_REGISTER_METHOD(void, SBData, Clear, ()); + LLDB_REGISTER_METHOD(size_t, SBData, GetByteSize, ()); + LLDB_REGISTER_METHOD(lldb::ByteOrder, SBData, GetByteOrder, ()); + LLDB_REGISTER_METHOD(void, SBData, SetByteOrder, (lldb::ByteOrder)); + LLDB_REGISTER_METHOD(float, SBData, GetFloat, + (lldb::SBError &, lldb::offset_t)); + LLDB_REGISTER_METHOD(double, SBData, GetDouble, + (lldb::SBError &, lldb::offset_t)); + LLDB_REGISTER_METHOD(long double, SBData, GetLongDouble, + (lldb::SBError &, lldb::offset_t)); + LLDB_REGISTER_METHOD(lldb::addr_t, SBData, GetAddress, + (lldb::SBError &, lldb::offset_t)); + LLDB_REGISTER_METHOD(uint8_t, SBData, GetUnsignedInt8, + (lldb::SBError &, lldb::offset_t)); + LLDB_REGISTER_METHOD(uint16_t, SBData, GetUnsignedInt16, + (lldb::SBError &, lldb::offset_t)); + LLDB_REGISTER_METHOD(uint32_t, SBData, GetUnsignedInt32, + (lldb::SBError &, lldb::offset_t)); + LLDB_REGISTER_METHOD(uint64_t, SBData, GetUnsignedInt64, + (lldb::SBError &, lldb::offset_t)); + LLDB_REGISTER_METHOD(int8_t, SBData, GetSignedInt8, + (lldb::SBError &, lldb::offset_t)); + LLDB_REGISTER_METHOD(int16_t, SBData, GetSignedInt16, + (lldb::SBError &, lldb::offset_t)); + LLDB_REGISTER_METHOD(int32_t, SBData, GetSignedInt32, + (lldb::SBError &, lldb::offset_t)); + LLDB_REGISTER_METHOD(int64_t, SBData, GetSignedInt64, + (lldb::SBError &, lldb::offset_t)); + LLDB_REGISTER_METHOD(const char *, SBData, GetString, + (lldb::SBError &, lldb::offset_t)); + LLDB_REGISTER_METHOD(bool, SBData, GetDescription, + (lldb::SBStream &, lldb::addr_t)); + LLDB_REGISTER_METHOD(bool, SBData, Append, (const lldb::SBData &)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromCString, + (lldb::ByteOrder, uint32_t, const char *)); + LLDB_REGISTER_STATIC_METHOD( + lldb::SBData, SBData, CreateDataFromUInt64Array, + (lldb::ByteOrder, uint32_t, uint64_t *, size_t)); + LLDB_REGISTER_STATIC_METHOD( + lldb::SBData, SBData, CreateDataFromUInt32Array, + (lldb::ByteOrder, uint32_t, uint32_t *, size_t)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromSInt64Array, + (lldb::ByteOrder, uint32_t, int64_t *, size_t)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromSInt32Array, + (lldb::ByteOrder, uint32_t, int32_t *, size_t)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromDoubleArray, + (lldb::ByteOrder, uint32_t, double *, size_t)); + LLDB_REGISTER_METHOD(bool, SBData, SetDataFromCString, (const char *)); + LLDB_REGISTER_METHOD(bool, SBData, SetDataFromUInt64Array, + (uint64_t *, size_t)); + LLDB_REGISTER_METHOD(bool, SBData, SetDataFromUInt32Array, + (uint32_t *, size_t)); + LLDB_REGISTER_METHOD(bool, SBData, SetDataFromSInt64Array, + (int64_t *, size_t)); + LLDB_REGISTER_METHOD(bool, SBData, SetDataFromSInt32Array, + (int32_t *, size_t)); + LLDB_REGISTER_METHOD(bool, SBData, SetDataFromDoubleArray, + (double *, size_t)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBDebugger.cpp b/contrib/llvm-project/lldb/source/API/SBDebugger.cpp new file mode 100644 index 000000000000..5f62987f37da --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBDebugger.cpp @@ -0,0 +1,1851 @@ +//===-- SBDebugger.cpp ----------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "SBReproducerPrivate.h" +#include "SystemInitializerFull.h" + +#include "lldb/API/SBDebugger.h" + +#include "lldb/lldb-private.h" + +#include "lldb/API/SBBroadcaster.h" +#include "lldb/API/SBCommandInterpreter.h" +#include "lldb/API/SBCommandInterpreterRunOptions.h" +#include "lldb/API/SBCommandReturnObject.h" +#include "lldb/API/SBError.h" +#include "lldb/API/SBEvent.h" +#include "lldb/API/SBFile.h" +#include "lldb/API/SBFrame.h" +#include "lldb/API/SBListener.h" +#include "lldb/API/SBProcess.h" +#include "lldb/API/SBSourceManager.h" +#include "lldb/API/SBStream.h" +#include "lldb/API/SBStringList.h" +#include "lldb/API/SBStructuredData.h" +#include "lldb/API/SBTarget.h" +#include "lldb/API/SBThread.h" +#include "lldb/API/SBTypeCategory.h" +#include "lldb/API/SBTypeFilter.h" +#include "lldb/API/SBTypeFormat.h" +#include "lldb/API/SBTypeNameSpecifier.h" +#include "lldb/API/SBTypeSummary.h" +#include "lldb/API/SBTypeSynthetic.h" + +#include "lldb/Core/Debugger.h" +#include "lldb/Core/PluginManager.h" +#include "lldb/Core/StreamFile.h" +#include "lldb/Core/StructuredDataImpl.h" +#include "lldb/DataFormatters/DataVisualization.h" +#include "lldb/Host/Config.h" +#include "lldb/Host/XML.h" +#include "lldb/Initialization/SystemLifetimeManager.h" +#include "lldb/Interpreter/CommandInterpreter.h" +#include "lldb/Interpreter/OptionArgParser.h" +#include "lldb/Interpreter/OptionGroupPlatform.h" +#include "lldb/Target/Process.h" +#include "lldb/Target/TargetList.h" +#include "lldb/Utility/Args.h" +#include "lldb/Utility/State.h" + +#include "llvm/ADT/STLExtras.h" +#include "llvm/ADT/StringRef.h" +#include "llvm/Support/DynamicLibrary.h" +#include "llvm/Support/ManagedStatic.h" + +using namespace lldb; +using namespace lldb_private; + +static llvm::sys::DynamicLibrary LoadPlugin(const lldb::DebuggerSP &debugger_sp, + const FileSpec &spec, + Status &error) { + llvm::sys::DynamicLibrary dynlib = + llvm::sys::DynamicLibrary::getPermanentLibrary(spec.GetPath().c_str()); + if (dynlib.isValid()) { + typedef bool (*LLDBCommandPluginInit)(lldb::SBDebugger & debugger); + + lldb::SBDebugger debugger_sb(debugger_sp); + // This calls the bool lldb::PluginInitialize(lldb::SBDebugger debugger) + // function. + // TODO: mangle this differently for your system - on OSX, the first + // underscore needs to be removed and the second one stays + LLDBCommandPluginInit init_func = + (LLDBCommandPluginInit)(uintptr_t)dynlib.getAddressOfSymbol( + "_ZN4lldb16PluginInitializeENS_10SBDebuggerE"); + if (init_func) { + if (init_func(debugger_sb)) + return dynlib; + else + error.SetErrorString("plug-in refused to load " + "(lldb::PluginInitialize(lldb::SBDebugger) " + "returned false)"); + } else { + error.SetErrorString("plug-in is missing the required initialization: " + "lldb::PluginInitialize(lldb::SBDebugger)"); + } + } else { + if (FileSystem::Instance().Exists(spec)) + error.SetErrorString("this file does not represent a loadable dylib"); + else + error.SetErrorString("no such file"); + } + return llvm::sys::DynamicLibrary(); +} + +static llvm::ManagedStatic<SystemLifetimeManager> g_debugger_lifetime; + +SBError SBInputReader::Initialize( + lldb::SBDebugger &sb_debugger, + unsigned long (*callback)(void *, lldb::SBInputReader *, + lldb::InputReaderAction, char const *, + unsigned long), + void *a, lldb::InputReaderGranularity b, char const *c, char const *d, + bool e) { + LLDB_RECORD_DUMMY( + lldb::SBError, SBInputReader, Initialize, + (lldb::SBDebugger &, + unsigned long (*)(void *, lldb::SBInputReader *, lldb::InputReaderAction, + const char *, unsigned long), + void *, lldb::InputReaderGranularity, const char *, const char *, bool), + sb_debugger, callback, a, b, c, d, e); + + return SBError(); +} + +void SBInputReader::SetIsDone(bool b) { + LLDB_RECORD_METHOD(void, SBInputReader, SetIsDone, (bool), b); +} + +bool SBInputReader::IsActive() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInputReader, IsActive); + + return false; +} + +SBDebugger::SBDebugger() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBDebugger); } + +SBDebugger::SBDebugger(const lldb::DebuggerSP &debugger_sp) + : m_opaque_sp(debugger_sp) { + LLDB_RECORD_CONSTRUCTOR(SBDebugger, (const lldb::DebuggerSP &), debugger_sp); +} + +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; + } + return LLDB_RECORD_RESULT(*this); +} + +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); + + SBError error; + if (auto e = g_debugger_lifetime->Initialize( + std::make_unique<SystemInitializerFull>(), LoadPlugin)) { + error.SetError(Status(std::move(e))); + } + return LLDB_RECORD_RESULT(error); +} + +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); + + if (m_opaque_sp) + m_opaque_sp->ClearIOHandlers(); + + m_opaque_sp.reset(); +} + +SBDebugger SBDebugger::Create() { + 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) { + 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, + lldb::LogOutputCallback callback, void *baton) + +{ + LLDB_RECORD_DUMMY(lldb::SBDebugger, SBDebugger, Create, + (bool, lldb::LogOutputCallback, void *), source_init_files, + callback, baton); + + SBDebugger debugger; + + // Currently we have issues if this function is called simultaneously on two + // different threads. The issues mainly revolve around the fact that the + // lldb_private::FormatManager uses global collections and having two threads + // parsing the .lldbinit files can cause mayhem. So to get around this for + // now we need to use a mutex to prevent bad things from happening. + static std::recursive_mutex g_mutex; + std::lock_guard<std::recursive_mutex> guard(g_mutex); + + debugger.reset(Debugger::CreateInstance(callback, baton)); + + SBCommandInterpreter interp = debugger.GetCommandInterpreter(); + if (source_init_files) { + interp.get()->SkipLLDBInitFiles(false); + interp.get()->SkipAppInitFiles(false); + SBCommandReturnObject result; + interp.SourceInitFileInHomeDirectory(result); + } else { + interp.get()->SkipLLDBInitFiles(true); + interp.get()->SkipAppInitFiles(true); + } + return debugger; +} + +void SBDebugger::Destroy(SBDebugger &debugger) { + LLDB_RECORD_STATIC_METHOD(void, SBDebugger, Destroy, (lldb::SBDebugger &), + debugger); + + Debugger::Destroy(debugger.m_opaque_sp); + + if (debugger.m_opaque_sp.get() != nullptr) + debugger.m_opaque_sp.reset(); +} + +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 + // deadlocks. + + const bool mandatory = false; + + ModuleList::RemoveOrphanSharedModules(mandatory); +} + +bool SBDebugger::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, IsValid); + return this->operator bool(); +} +SBDebugger::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, operator bool); + + 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); +} + +void SBDebugger::SetInputFileHandle(FILE *fh, bool transfer_ownership) { + LLDB_RECORD_METHOD(void, SBDebugger, SetInputFileHandle, (FILE *, bool), fh, + transfer_ownership); + SetInputFile((FileSP)std::make_shared<NativeFile>(fh, transfer_ownership)); +} + +SBError SBDebugger::SetInputFile(FileSP file_sp) { + LLDB_RECORD_METHOD(SBError, SBDebugger, SetInputFile, (FileSP), file_sp); + return LLDB_RECORD_RESULT(SetInputFile(SBFile(file_sp))); +} + +// Shouldn't really be settable after initialization as this could cause lots +// of problems; don't want users trying to switch modes in the middle of a +// debugging session. +SBError SBDebugger::SetInputFile(SBFile file) { + LLDB_RECORD_METHOD(SBError, SBDebugger, SetInputFile, (SBFile), file); + + SBError error; + if (!m_opaque_sp) { + error.ref().SetErrorString("invalid debugger"); + return LLDB_RECORD_RESULT(error); + } + + repro::DataRecorder *recorder = nullptr; + if (repro::Generator *g = repro::Reproducer::Instance().GetGenerator()) + recorder = g->GetOrCreate<repro::CommandProvider>().GetNewRecorder(); + + FileSP file_sp = file.m_opaque_sp; + + static std::unique_ptr<repro::MultiLoader<repro::CommandProvider>> loader = + repro::MultiLoader<repro::CommandProvider>::Create( + repro::Reproducer::Instance().GetLoader()); + if (loader) { + llvm::Optional<std::string> nextfile = loader->GetNextFile(); + FILE *fh = nextfile ? FileSystem::Instance().Fopen(nextfile->c_str(), "r") + : nullptr; + // FIXME Jonas Devlieghere: shouldn't this error be propagated out to the + // reproducer somehow if fh is NULL? + if (fh) { + file_sp = std::make_shared<NativeFile>(fh, true); + } + } + + if (!file_sp || !file_sp->IsValid()) { + error.ref().SetErrorString("invalid file"); + return LLDB_RECORD_RESULT(error); + } + + m_opaque_sp->SetInputFile(file_sp, recorder); + return LLDB_RECORD_RESULT(error); +} + +SBError SBDebugger::SetOutputFile(FileSP file_sp) { + LLDB_RECORD_METHOD(SBError, SBDebugger, SetOutputFile, (FileSP), file_sp); + return LLDB_RECORD_RESULT(SetOutputFile(SBFile(file_sp))); +} + +void SBDebugger::SetOutputFileHandle(FILE *fh, bool transfer_ownership) { + LLDB_RECORD_METHOD(void, SBDebugger, SetOutputFileHandle, (FILE *, bool), fh, + transfer_ownership); + SetOutputFile((FileSP)std::make_shared<NativeFile>(fh, transfer_ownership)); +} + +SBError SBDebugger::SetOutputFile(SBFile file) { + LLDB_RECORD_METHOD(SBError, SBDebugger, SetOutputFile, (SBFile file), file); + SBError error; + if (!m_opaque_sp) { + error.ref().SetErrorString("invalid debugger"); + return LLDB_RECORD_RESULT(error); + } + if (!file) { + error.ref().SetErrorString("invalid file"); + return LLDB_RECORD_RESULT(error); + } + m_opaque_sp->SetOutputFile(file.m_opaque_sp); + return LLDB_RECORD_RESULT(error); +} + +void SBDebugger::SetErrorFileHandle(FILE *fh, bool transfer_ownership) { + LLDB_RECORD_METHOD(void, SBDebugger, SetErrorFileHandle, (FILE *, bool), fh, + transfer_ownership); + SetErrorFile((FileSP)std::make_shared<NativeFile>(fh, transfer_ownership)); +} + +SBError SBDebugger::SetErrorFile(FileSP file_sp) { + LLDB_RECORD_METHOD(SBError, SBDebugger, SetErrorFile, (FileSP), file_sp); + return LLDB_RECORD_RESULT(SetErrorFile(SBFile(file_sp))); +} + +SBError SBDebugger::SetErrorFile(SBFile file) { + LLDB_RECORD_METHOD(SBError, SBDebugger, SetErrorFile, (SBFile file), file); + SBError error; + if (!m_opaque_sp) { + error.ref().SetErrorString("invalid debugger"); + return LLDB_RECORD_RESULT(error); + } + if (!file) { + error.ref().SetErrorString("invalid file"); + return LLDB_RECORD_RESULT(error); + } + m_opaque_sp->SetErrorFile(file.m_opaque_sp); + return LLDB_RECORD_RESULT(error); +} + +FILE *SBDebugger::GetInputFileHandle() { + LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetInputFileHandle); + if (m_opaque_sp) { + File &file_sp = m_opaque_sp->GetInputFile(); + return LLDB_RECORD_RESULT(file_sp.GetStream()); + } + return LLDB_RECORD_RESULT(nullptr); +} + +SBFile SBDebugger::GetInputFile() { + LLDB_RECORD_METHOD_NO_ARGS(SBFile, SBDebugger, GetInputFile); + if (m_opaque_sp) { + return LLDB_RECORD_RESULT(SBFile(m_opaque_sp->GetInputFileSP())); + } + return LLDB_RECORD_RESULT(SBFile()); +} + +FILE *SBDebugger::GetOutputFileHandle() { + LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetOutputFileHandle); + if (m_opaque_sp) { + StreamFile &stream_file = m_opaque_sp->GetOutputStream(); + return LLDB_RECORD_RESULT(stream_file.GetFile().GetStream()); + } + return LLDB_RECORD_RESULT(nullptr); +} + +SBFile SBDebugger::GetOutputFile() { + LLDB_RECORD_METHOD_NO_ARGS(SBFile, SBDebugger, GetOutputFile); + if (m_opaque_sp) { + SBFile file(m_opaque_sp->GetOutputStream().GetFileSP()); + return LLDB_RECORD_RESULT(file); + } + return LLDB_RECORD_RESULT(SBFile()); +} + +FILE *SBDebugger::GetErrorFileHandle() { + LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetErrorFileHandle); + + if (m_opaque_sp) { + StreamFile &stream_file = m_opaque_sp->GetErrorStream(); + return LLDB_RECORD_RESULT(stream_file.GetFile().GetStream()); + } + return LLDB_RECORD_RESULT(nullptr); +} + +SBFile SBDebugger::GetErrorFile() { + LLDB_RECORD_METHOD_NO_ARGS(SBFile, SBDebugger, GetErrorFile); + SBFile file; + if (m_opaque_sp) { + SBFile file(m_opaque_sp->GetErrorStream().GetFileSP()); + return LLDB_RECORD_RESULT(file); + } + return LLDB_RECORD_RESULT(SBFile()); +} + +void SBDebugger::SaveInputTerminalState() { + LLDB_RECORD_DUMMY_NO_ARGS(void, SBDebugger, SaveInputTerminalState); + + if (m_opaque_sp) + m_opaque_sp->SaveInputTerminalState(); +} + +void SBDebugger::RestoreInputTerminalState() { + LLDB_RECORD_DUMMY_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); + + SBCommandInterpreter sb_interpreter; + if (m_opaque_sp) + sb_interpreter.reset(&m_opaque_sp->GetCommandInterpreter()); + + 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; + if (target_sp) + lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex()); + + SBCommandInterpreter sb_interpreter(GetCommandInterpreter()); + SBCommandReturnObject result; + + sb_interpreter.HandleCommand(command, result, false); + + result.PutError(m_opaque_sp->GetErrorStream().GetFileSP()); + result.PutOutput(m_opaque_sp->GetOutputStream().GetFileSP()); + + if (!m_opaque_sp->GetAsyncExecution()) { + SBProcess process(GetCommandInterpreter().GetProcess()); + ProcessSP process_sp(process.GetSP()); + if (process_sp) { + EventSP event_sp; + ListenerSP lldb_listener_sp = m_opaque_sp->GetListener(); + while (lldb_listener_sp->GetEventForBroadcaster( + process_sp.get(), event_sp, std::chrono::seconds(0))) { + SBEvent event(event_sp); + HandleProcessEvent(process, event, GetOutputFile(), GetErrorFile()); + } + } + } + } +} + +SBListener SBDebugger::GetListener() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBDebugger, GetListener); + + SBListener sb_listener; + if (m_opaque_sp) + sb_listener.reset(m_opaque_sp->GetListener()); + + return LLDB_RECORD_RESULT(sb_listener); +} + +void SBDebugger::HandleProcessEvent(const SBProcess &process, + const SBEvent &event, SBFile out, + SBFile err) { + LLDB_RECORD_METHOD( + void, SBDebugger, HandleProcessEvent, + (const lldb::SBProcess &, const lldb::SBEvent &, SBFile, SBFile), process, + event, out, err); + + return HandleProcessEvent(process, event, out.m_opaque_sp, err.m_opaque_sp); +} + +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); + + FileSP outfile = std::make_shared<NativeFile>(out, false); + FileSP errfile = std::make_shared<NativeFile>(err, false); + return HandleProcessEvent(process, event, outfile, errfile); +} + +void SBDebugger::HandleProcessEvent(const SBProcess &process, + const SBEvent &event, FileSP out_sp, + FileSP err_sp) { + + LLDB_RECORD_METHOD( + void, SBDebugger, HandleProcessEvent, + (const lldb::SBProcess &, const lldb::SBEvent &, FileSP, FileSP), process, + event, out_sp, err_sp); + + if (!process.IsValid()) + return; + + TargetSP target_sp(process.GetTarget().GetSP()); + if (!target_sp) + return; + + const uint32_t event_type = event.GetType(); + char stdio_buffer[1024]; + size_t len; + + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + + if (event_type & + (Process::eBroadcastBitSTDOUT | Process::eBroadcastBitStateChanged)) { + // Drain stdout when we stop just in case we have any bytes + while ((len = process.GetSTDOUT(stdio_buffer, sizeof(stdio_buffer))) > 0) + if (out_sp) + out_sp->Write(stdio_buffer, len); + } + + if (event_type & + (Process::eBroadcastBitSTDERR | Process::eBroadcastBitStateChanged)) { + // Drain stderr when we stop just in case we have any bytes + while ((len = process.GetSTDERR(stdio_buffer, sizeof(stdio_buffer))) > 0) + if (err_sp) + err_sp->Write(stdio_buffer, len); + } + + if (event_type & Process::eBroadcastBitStateChanged) { + StateType event_state = SBProcess::GetStateFromEvent(event); + + if (event_state == eStateInvalid) + return; + + bool is_stopped = StateIsStoppedState(event_state); + if (!is_stopped) + process.ReportEventState(event, out_sp); + } +} + +SBSourceManager SBDebugger::GetSourceManager() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSourceManager, SBDebugger, + GetSourceManager); + + SBSourceManager sb_source_manager(*this); + return LLDB_RECORD_RESULT(sb_source_manager); +} + +bool SBDebugger::GetDefaultArchitecture(char *arch_name, size_t arch_name_len) { + LLDB_RECORD_CHAR_PTR_STATIC_METHOD(bool, SBDebugger, GetDefaultArchitecture, + (char *, size_t), arch_name, "", + arch_name_len); + + if (arch_name && arch_name_len) { + ArchSpec default_arch = Target::GetDefaultArchitecture(); + + if (default_arch.IsValid()) { + const std::string &triple_str = default_arch.GetTriple().str(); + if (!triple_str.empty()) + ::snprintf(arch_name, arch_name_len, "%s", triple_str.c_str()); + else + ::snprintf(arch_name, arch_name_len, "%s", + default_arch.GetArchitectureName()); + return true; + } + } + if (arch_name && arch_name_len) + arch_name[0] = '\0'; + return false; +} + +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()) { + Target::SetDefaultArchitecture(arch); + return true; + } + } + return false; +} + +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); +} + +static void AddBoolConfigEntry(StructuredData::Dictionary &dict, + llvm::StringRef name, bool value, + llvm::StringRef description) { + auto entry_up = std::make_unique<StructuredData::Dictionary>(); + entry_up->AddBooleanItem("value", value); + entry_up->AddStringItem("description", description); + dict.AddItem(name, std::move(entry_up)); +} + +static void AddLLVMTargets(StructuredData::Dictionary &dict) { + auto array_up = std::make_unique<StructuredData::Array>(); +#define LLVM_TARGET(target) \ + array_up->AddItem(std::make_unique<StructuredData::String>(#target)); +#include "llvm/Config/Targets.def" + auto entry_up = std::make_unique<StructuredData::Dictionary>(); + entry_up->AddItem("value", std::move(array_up)); + entry_up->AddStringItem("description", "A list of configured LLVM targets."); + dict.AddItem("targets", std::move(entry_up)); +} + +SBStructuredData SBDebugger::GetBuildConfiguration() { + LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBStructuredData, SBDebugger, + GetBuildConfiguration); + + auto config_up = std::make_unique<StructuredData::Dictionary>(); + AddBoolConfigEntry( + *config_up, "xml", XMLDocument::XMLEnabled(), + "A boolean value that indicates if XML support is enabled in LLDB"); + AddBoolConfigEntry( + *config_up, "curses", LLDB_ENABLE_CURSES, + "A boolean value that indicates if curses support is enabled in LLDB"); + AddBoolConfigEntry( + *config_up, "editline", LLDB_ENABLE_LIBEDIT, + "A boolean value that indicates if editline support is enabled in LLDB"); + AddBoolConfigEntry( + *config_up, "lzma", LLDB_ENABLE_LZMA, + "A boolean value that indicates if lzma support is enabled in LLDB"); + AddBoolConfigEntry( + *config_up, "python", LLDB_ENABLE_PYTHON, + "A boolean value that indicates if python support is enabled in LLDB"); + AddBoolConfigEntry( + *config_up, "lua", LLDB_ENABLE_LUA, + "A boolean value that indicates if lua support is enabled in LLDB"); + AddLLVMTargets(*config_up); + + SBStructuredData data; + data.m_impl_up->SetObjectSP(std::move(config_up)); + return LLDB_RECORD_RESULT(data); +} + +bool SBDebugger::StateIsRunningState(StateType state) { + LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, StateIsRunningState, + (lldb::StateType), state); + + const bool result = lldb_private::StateIsRunningState(state); + + return result; +} + +bool SBDebugger::StateIsStoppedState(StateType state) { + LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, StateIsStoppedState, + (lldb::StateType), state); + + const bool result = lldb_private::StateIsStoppedState(state, false); + + return result; +} + +lldb::SBTarget SBDebugger::CreateTarget(const char *filename, + const char *target_triple, + 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) { + sb_error.Clear(); + OptionGroupPlatform platform_options(false); + platform_options.SetPlatformName(platform_name); + + sb_error.ref() = m_opaque_sp->GetTargetList().CreateTarget( + *m_opaque_sp, filename, target_triple, + add_dependent_modules ? eLoadDependentsYes : eLoadDependentsNo, + &platform_options, target_sp); + + if (sb_error.Success()) + sb_target.SetSP(target_sp); + } else { + sb_error.SetErrorString("invalid debugger"); + } + + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_LOGF(log, + "SBDebugger(%p)::CreateTarget (filename=\"%s\", triple=%s, " + "platform_name=%s, add_dependent_modules=%u, error=%s) => " + "SBTarget(%p)", + static_cast<void *>(m_opaque_sp.get()), filename, target_triple, + platform_name, add_dependent_modules, sb_error.GetCString(), + static_cast<void *>(target_sp.get())); + + 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) { + const bool add_dependent_modules = true; + Status error(m_opaque_sp->GetTargetList().CreateTarget( + *m_opaque_sp, filename, target_triple, + add_dependent_modules ? eLoadDependentsYes : eLoadDependentsNo, nullptr, + target_sp)); + sb_target.SetSP(target_sp); + } + + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_LOGF(log, + "SBDebugger(%p)::CreateTargetWithFileAndTargetTriple " + "(filename=\"%s\", triple=%s) => SBTarget(%p)", + static_cast<void *>(m_opaque_sp.get()), filename, target_triple, + static_cast<void *>(target_sp.get())); + + 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; + TargetSP target_sp; + if (m_opaque_sp) { + Status error; + const bool add_dependent_modules = true; + + error = m_opaque_sp->GetTargetList().CreateTarget( + *m_opaque_sp, filename, arch_cstr, + add_dependent_modules ? eLoadDependentsYes : eLoadDependentsNo, nullptr, + target_sp); + + if (error.Success()) { + m_opaque_sp->GetTargetList().SetSelectedTarget(target_sp.get()); + sb_target.SetSP(target_sp); + } + } + + LLDB_LOGF(log, + "SBDebugger(%p)::CreateTargetWithFileAndArch (filename=\"%s\", " + "arch=%s) => SBTarget(%p)", + static_cast<void *>(m_opaque_sp.get()), filename, arch_cstr, + static_cast<void *>(target_sp.get())); + + 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) { + Status error; + const bool add_dependent_modules = true; + error = m_opaque_sp->GetTargetList().CreateTarget( + *m_opaque_sp, filename, "", + add_dependent_modules ? eLoadDependentsYes : eLoadDependentsNo, nullptr, + target_sp); + + if (error.Success()) { + m_opaque_sp->GetTargetList().SetSelectedTarget(target_sp.get()); + sb_target.SetSP(target_sp); + } + } + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_LOGF(log, + "SBDebugger(%p)::CreateTarget (filename=\"%s\") => SBTarget(%p)", + static_cast<void *>(m_opaque_sp.get()), filename, + static_cast<void *>(target_sp.get())); + 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()); + } + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_LOGF(log, "SBDebugger(%p)::GetDummyTarget() => SBTarget(%p)", + static_cast<void *>(m_opaque_sp.get()), + static_cast<void *>(sb_target.GetSP().get())); + 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()); + if (target_sp) { + // No need to lock, the target list is thread safe + result = m_opaque_sp->GetTargetList().DeleteTarget(target_sp); + target_sp->Destroy(); + target.Clear(); + const bool mandatory = true; + ModuleList::RemoveOrphanSharedModules(mandatory); + } + } + + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_LOGF(log, "SBDebugger(%p)::DeleteTarget (SBTarget(%p)) => %i", + static_cast<void *>(m_opaque_sp.get()), + static_cast<void *>(target.m_opaque_sp.get()), result); + + return result; +} + +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 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) + return UINT32_MAX; + + if (!m_opaque_sp) + return UINT32_MAX; + + return m_opaque_sp->GetTargetList().GetIndexOfTarget(target.GetSP()); +} + +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 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 + ArchSpec arch = Platform::GetAugmentedArchSpec( + m_opaque_sp->GetPlatformList().GetSelectedPlatform().get(), arch_name); + TargetSP target_sp( + m_opaque_sp->GetTargetList().FindTargetWithExecutableAndArchitecture( + FileSpec(filename), arch_name ? &arch : nullptr)); + sb_target.SetSP(target_sp); + } + return LLDB_RECORD_RESULT(sb_target); +} + +SBTarget SBDebugger::FindTargetWithLLDBProcess(const ProcessSP &process_sp) { + SBTarget sb_target; + if (m_opaque_sp) { + // No need to lock, the target list is thread safe + sb_target.SetSP( + m_opaque_sp->GetTargetList().FindTargetWithProcess(process_sp.get())); + } + return sb_target; +} + +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(); + } + return 0; +} + +SBTarget SBDebugger::GetSelectedTarget() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBDebugger, GetSelectedTarget); + + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + + SBTarget sb_target; + TargetSP target_sp; + if (m_opaque_sp) { + // No need to lock, the target list is thread safe + target_sp = m_opaque_sp->GetTargetList().GetSelectedTarget(); + sb_target.SetSP(target_sp); + } + + if (log) { + SBStream sstr; + sb_target.GetDescription(sstr, eDescriptionLevelBrief); + LLDB_LOGF(log, "SBDebugger(%p)::GetSelectedTarget () => SBTarget(%p): %s", + static_cast<void *>(m_opaque_sp.get()), + static_cast<void *>(target_sp.get()), sstr.GetData()); + } + + 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()); + if (m_opaque_sp) { + m_opaque_sp->GetTargetList().SetSelectedTarget(target_sp.get()); + } + if (log) { + SBStream sstr; + sb_target.GetDescription(sstr, eDescriptionLevelBrief); + LLDB_LOGF(log, "SBDebugger(%p)::SetSelectedTarget () => SBTarget(%p): %s", + static_cast<void *>(m_opaque_sp.get()), + static_cast<void *>(target_sp.get()), sstr.GetData()); + } +} + +SBPlatform SBDebugger::GetSelectedPlatform() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBPlatform, SBDebugger, GetSelectedPlatform); + + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + + SBPlatform sb_platform; + DebuggerSP debugger_sp(m_opaque_sp); + if (debugger_sp) { + sb_platform.SetSP(debugger_sp->GetPlatformList().GetSelectedPlatform()); + } + LLDB_LOGF(log, "SBDebugger(%p)::GetSelectedPlatform () => SBPlatform(%p): %s", + static_cast<void *>(m_opaque_sp.get()), + static_cast<void *>(sb_platform.GetSP().get()), + sb_platform.GetName()); + 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); + if (debugger_sp) { + debugger_sp->GetPlatformList().SetSelectedPlatform(sb_platform.GetSP()); + } + + LLDB_LOGF(log, "SBDebugger(%p)::SetSelectedPlatform (SBPlatform(%p) %s)", + static_cast<void *>(m_opaque_sp.get()), + static_cast<void *>(sb_platform.GetSP().get()), + sb_platform.GetName()); +} + +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(); + } + return 0; +} + +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 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)) { + break; + } + ++idx; + } + // +1 for the host platform, which should always appear first in the list. + return idx + 1; +} + +SBStructuredData SBDebugger::GetAvailablePlatformInfoAtIndex(uint32_t idx) { + LLDB_RECORD_METHOD(lldb::SBStructuredData, SBDebugger, + GetAvailablePlatformInfoAtIndex, (uint32_t), idx); + + SBStructuredData data; + auto platform_dict = std::make_unique<StructuredData::Dictionary>(); + llvm::StringRef name_str("name"), desc_str("description"); + + if (idx == 0) { + PlatformSP host_platform_sp(Platform::GetHostPlatform()); + platform_dict->AddStringItem( + name_str, host_platform_sp->GetPluginName().GetStringRef()); + platform_dict->AddStringItem( + desc_str, llvm::StringRef(host_platform_sp->GetDescription())); + } else if (idx > 0) { + const char *plugin_name = + PluginManager::GetPlatformPluginNameAtIndex(idx - 1); + if (!plugin_name) { + 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 LLDB_RECORD_RESULT(data); + } + platform_dict->AddStringItem(desc_str, llvm::StringRef(plugin_desc)); + } + + data.m_impl_up->SetObjectSP( + StructuredData::ObjectSP(platform_dict.release())); + return LLDB_RECORD_RESULT(data); +} + +void SBDebugger::DispatchInput(void *baton, const void *data, size_t data_len) { + LLDB_RECORD_DUMMY(void, SBDebugger, DispatchInput, + (void *, const void *, size_t), baton, data, data_len); + + DispatchInput(data, data_len); +} + +void SBDebugger::DispatchInput(const void *data, size_t data_len) { + LLDB_RECORD_DUMMY(void, SBDebugger, DispatchInput, (const void *, size_t), + data, data_len); + + // Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); + // + // if (log) + // LLDB_LOGF(log, "SBDebugger(%p)::DispatchInput (data=\"%.*s\", + // size_t=%" PRIu64 ")", + // m_opaque_sp.get(), + // (int) data_len, + // (const char *) data, + // (uint64_t)data_len); + // + // if (m_opaque_sp) + // m_opaque_sp->DispatchInput ((const char *) data, data_len); +} + +void SBDebugger::DispatchInputInterrupt() { + LLDB_RECORD_DUMMY_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) { + 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; + options.SetAutoHandleEvents(auto_handle_events); + options.SetSpawnThread(spawn_thread); + m_opaque_sp->GetCommandInterpreter().RunCommandInterpreter(options); + } +} + +void SBDebugger::RunCommandInterpreter(bool auto_handle_events, + bool spawn_thread, + SBCommandInterpreterRunOptions &options, + int &num_errors, bool &quit_requested, + 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) { + options.SetAutoHandleEvents(auto_handle_events); + options.SetSpawnThread(spawn_thread); + CommandInterpreter &interp = m_opaque_sp->GetCommandInterpreter(); + CommandInterpreterRunResult result = + interp.RunCommandInterpreter(options.ref()); + num_errors = result.GetNumErrors(); + quit_requested = + result.IsResult(lldb::eCommandInterpreterResultQuitRequested); + stopped_for_crash = + result.IsResult(lldb::eCommandInterpreterResultInferiorCrash); + } +} + +SBCommandInterpreterRunResult SBDebugger::RunCommandInterpreter( + const SBCommandInterpreterRunOptions &options) { + LLDB_RECORD_METHOD(lldb::SBCommandInterpreterRunResult, SBDebugger, + RunCommandInterpreter, + (const lldb::SBCommandInterpreterRunOptions &), options); + + if (!m_opaque_sp) + return LLDB_RECORD_RESULT(SBCommandInterpreterRunResult()); + + CommandInterpreter &interp = m_opaque_sp->GetCommandInterpreter(); + CommandInterpreterRunResult result = + interp.RunCommandInterpreter(options.ref()); + + return LLDB_RECORD_RESULT(SBCommandInterpreterRunResult(result)); +} + +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 LLDB_RECORD_RESULT(error); +} + +void SBDebugger::reset(const DebuggerSP &debugger_sp) { + m_opaque_sp = debugger_sp; +} + +Debugger *SBDebugger::get() const { return m_opaque_sp.get(); } + +Debugger &SBDebugger::ref() const { + assert(m_opaque_sp.get()); + return *m_opaque_sp; +} + +const lldb::DebuggerSP &SBDebugger::get_sp() const { return m_opaque_sp; } + +SBDebugger SBDebugger::FindDebuggerWithID(int id) { + LLDB_RECORD_STATIC_METHOD(lldb::SBDebugger, SBDebugger, FindDebuggerWithID, + (int), id); + + // No need to lock, the debugger list is thread safe + SBDebugger sb_debugger; + DebuggerSP debugger_sp = Debugger::FindDebuggerWithID(id); + if (debugger_sp) + sb_debugger.reset(debugger_sp); + return 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))); + Status error; + if (debugger_sp) { + ExecutionContext exe_ctx( + debugger_sp->GetCommandInterpreter().GetExecutionContext()); + error = debugger_sp->SetPropertyValue(&exe_ctx, eVarSetOperationAssign, + var_name, value); + } else { + error.SetErrorStringWithFormat("invalid debugger instance name '%s'", + debugger_instance_name); + } + if (error.Fail()) + sb_error.SetError(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))); + Status error; + if (debugger_sp) { + ExecutionContext exe_ctx( + debugger_sp->GetCommandInterpreter().GetExecutionContext()); + lldb::OptionValueSP value_sp( + debugger_sp->GetPropertyValue(&exe_ctx, var_name, false, error)); + if (value_sp) { + StreamString value_strm; + value_sp->DumpValue(&exe_ctx, value_strm, OptionValue::eDumpOptionValue); + const std::string &value_str = std::string(value_strm.GetString()); + if (!value_str.empty()) { + StringList string_list; + string_list.SplitIntoLines(value_str); + return LLDB_RECORD_RESULT(SBStringList(&string_list)); + } + } + } + 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_DUMMY(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)); + + LLDB_LOGF(log, "SBDebugger(%p)::GetPrompt () => \"%s\"", + static_cast<void *>(m_opaque_sp.get()), + (m_opaque_sp ? m_opaque_sp->GetPrompt().str().c_str() : "")); + + return (m_opaque_sp ? ConstString(m_opaque_sp->GetPrompt()).GetCString() + : nullptr); +} + +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::SetUseSourceCache(bool value) { + LLDB_RECORD_METHOD(bool, SBDebugger, SetUseSourceCache, (bool), value); + + return (m_opaque_sp ? m_opaque_sp->SetUseSourceCache(value) : false); +} + +bool SBDebugger::GetUseSourceCache() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetUseSourceCache); + + return (m_opaque_sp ? m_opaque_sp->GetUseSourceCache() : false); +} + +bool SBDebugger::GetDescription(SBStream &description) { + LLDB_RECORD_METHOD(bool, SBDebugger, GetDescription, (lldb::SBStream &), + description); + + Stream &strm = description.ref(); + + if (m_opaque_sp) { + const char *name = m_opaque_sp->GetInstanceName().AsCString(); + user_id_t id = m_opaque_sp->GetID(); + strm.Printf("Debugger (instance: \"%s\", id: %" PRIu64 ")", name, id); + } else + strm.PutCString("No value"); + + return true; +} + +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]) { + ConstString platform_name(platform_name_cstr); + PlatformSP platform_sp(Platform::Find(platform_name)); + + if (platform_sp) { + // Already have a platform with this name, just select it + m_opaque_sp->GetPlatformList().SetSelectedPlatform(platform_sp); + } else { + // We don't have a platform by this name yet, create one + platform_sp = Platform::Create(platform_name, sb_error.ref()); + if (platform_sp) { + // We created the platform, now append and select it + bool make_selected = true; + m_opaque_sp->GetPlatformList().Append(platform_sp, make_selected); + } + } + } else { + sb_error.ref().SetErrorString("invalid platform name"); + } + } else { + sb_error.ref().SetErrorString("invalid debugger"); + } + 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( + m_opaque_sp->GetPlatformList().GetSelectedPlatform()); + + if (platform_sp) { + if (log && sysroot) + LLDB_LOGF(log, "SBDebugger::SetCurrentPlatformSDKRoot (\"%s\")", + sysroot); + platform_sp->SetSDKRootDirectory(ConstString(sysroot)); + return true; + } + } + return false; +} + +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 LLDB_RECORD_RESULT(SBTypeCategory()); + + TypeCategoryImplSP category_sp; + + if (DataVisualization::Categories::GetCategory(ConstString(category_name), + 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 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 LLDB_RECORD_RESULT(SBTypeCategory()); + + TypeCategoryImplSP category_sp; + + if (DataVisualization::Categories::GetCategory(ConstString(category_name), + 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; + + return DataVisualization::Categories::Delete(ConstString(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) { + LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategoryAtIndex, + (uint32_t), index); + + return LLDB_RECORD_RESULT( + SBTypeCategory(DataVisualization::Categories::GetCategoryAtIndex(index))); +} + +SBTypeCategory SBDebugger::GetDefaultCategory() { + 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 LLDB_RECORD_RESULT(default_category_sb.GetFormatForType(type_name)); + return LLDB_RECORD_RESULT(SBTypeFormat()); +} + +SBTypeSummary SBDebugger::GetSummaryForType(SBTypeNameSpecifier type_name) { + LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBDebugger, GetSummaryForType, + (lldb::SBTypeNameSpecifier), type_name); + + if (!type_name.IsValid()) + return LLDB_RECORD_RESULT(SBTypeSummary()); + return LLDB_RECORD_RESULT( + SBTypeSummary(DataVisualization::GetSummaryForType(type_name.GetSP()))); +} + +SBTypeFilter SBDebugger::GetFilterForType(SBTypeNameSpecifier type_name) { + LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBDebugger, GetFilterForType, + (lldb::SBTypeNameSpecifier), type_name); + + if (!type_name.IsValid()) + return LLDB_RECORD_RESULT(SBTypeFilter()); + return LLDB_RECORD_RESULT( + SBTypeFilter(DataVisualization::GetFilterForType(type_name.GetSP()))); +} + +SBTypeSynthetic SBDebugger::GetSyntheticForType(SBTypeNameSpecifier type_name) { + LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBDebugger, GetSyntheticForType, + (lldb::SBTypeNameSpecifier), type_name); + + if (!type_name.IsValid()) + return LLDB_RECORD_RESULT(SBTypeSynthetic()); + return LLDB_RECORD_RESULT(SBTypeSynthetic( + DataVisualization::GetSyntheticForType(type_name.GetSP()))); +} + +static llvm::ArrayRef<const char *> GetCategoryArray(const char **categories) { + if (categories == nullptr) + return {}; + size_t len = 0; + while (categories[len] != nullptr) + ++len; + return llvm::makeArrayRef(categories, len); +} + +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; + std::string error; + llvm::raw_string_ostream error_stream(error); + return m_opaque_sp->EnableLog(channel, GetCategoryArray(categories), "", + log_options, error_stream); + } else + return false; +} + +void SBDebugger::SetLoggingCallback(lldb::LogOutputCallback log_callback, + void *baton) { + LLDB_RECORD_DUMMY(void, SBDebugger, SetLoggingCallback, + (lldb::LogOutputCallback, void *), log_callback, baton); + + if (m_opaque_sp) { + return m_opaque_sp->SetLoggingCallback(log_callback, baton); + } +} + +namespace lldb_private { +namespace repro { + +template <> void RegisterMethods<SBInputReader>(Registry &R) { + LLDB_REGISTER_METHOD(void, SBInputReader, SetIsDone, (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBInputReader, IsActive, ()); +} + +static void SetFileHandleRedirect(SBDebugger *, FILE *, bool) { + // Do nothing. +} + +static SBError SetFileRedirect(SBDebugger *, SBFile file) { return SBError(); } + +static SBError SetFileRedirect(SBDebugger *, FileSP file) { return SBError(); } + +template <> void RegisterMethods<SBDebugger>(Registry &R) { + // Custom implementation. + R.Register(&invoke<void (SBDebugger::*)(FILE *, bool)>::method< + &SBDebugger::SetErrorFileHandle>::record, + &SetFileHandleRedirect); + R.Register(&invoke<void (SBDebugger::*)(FILE *, bool)>::method< + &SBDebugger::SetOutputFileHandle>::record, + &SetFileHandleRedirect); + + R.Register(&invoke<SBError (SBDebugger::*)( + SBFile)>::method<&SBDebugger::SetInputFile>::record, + &SetFileRedirect); + R.Register(&invoke<SBError (SBDebugger::*)( + SBFile)>::method<&SBDebugger::SetOutputFile>::record, + &SetFileRedirect); + R.Register(&invoke<SBError (SBDebugger::*)( + SBFile)>::method<&SBDebugger::SetErrorFile>::record, + &SetFileRedirect); + + R.Register(&invoke<SBError (SBDebugger::*)( + FileSP)>::method<&SBDebugger::SetInputFile>::record, + &SetFileRedirect); + R.Register(&invoke<SBError (SBDebugger::*)( + FileSP)>::method<&SBDebugger::SetOutputFile>::record, + &SetFileRedirect); + R.Register(&invoke<SBError (SBDebugger::*)( + FileSP)>::method<&SBDebugger::SetErrorFile>::record, + &SetFileRedirect); + + LLDB_REGISTER_CHAR_PTR_METHOD_STATIC(bool, SBDebugger, + GetDefaultArchitecture); + + LLDB_REGISTER_CONSTRUCTOR(SBDebugger, ()); + LLDB_REGISTER_CONSTRUCTOR(SBDebugger, (const lldb::DebuggerSP &)); + LLDB_REGISTER_CONSTRUCTOR(SBDebugger, (const lldb::SBDebugger &)); + LLDB_REGISTER_METHOD(lldb::SBDebugger &, + SBDebugger, operator=,(const lldb::SBDebugger &)); + LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Initialize, ()); + LLDB_REGISTER_STATIC_METHOD(lldb::SBError, SBDebugger, + InitializeWithErrorHandling, ()); + LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Terminate, ()); + LLDB_REGISTER_METHOD(void, SBDebugger, Clear, ()); + LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, ()); + LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, (bool)); + LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Destroy, (lldb::SBDebugger &)); + LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, MemoryPressureDetected, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, operator bool,()); + LLDB_REGISTER_METHOD(void, SBDebugger, SetAsync, (bool)); + LLDB_REGISTER_METHOD(bool, SBDebugger, GetAsync, ()); + LLDB_REGISTER_METHOD(void, SBDebugger, SkipLLDBInitFiles, (bool)); + LLDB_REGISTER_METHOD(void, SBDebugger, SkipAppInitFiles, (bool)); + LLDB_REGISTER_METHOD(void, SBDebugger, SetInputFileHandle, (FILE *, bool)); + LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetInputFileHandle, ()); + LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetOutputFileHandle, ()); + LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetErrorFileHandle, ()); + LLDB_REGISTER_METHOD(SBFile, SBDebugger, GetInputFile, ()); + LLDB_REGISTER_METHOD(SBFile, SBDebugger, GetOutputFile, ()); + LLDB_REGISTER_METHOD(SBFile, SBDebugger, GetErrorFile, ()); + LLDB_REGISTER_METHOD(void, SBDebugger, SaveInputTerminalState, ()); + LLDB_REGISTER_METHOD(void, SBDebugger, RestoreInputTerminalState, ()); + LLDB_REGISTER_METHOD(lldb::SBCommandInterpreter, SBDebugger, + GetCommandInterpreter, ()); + LLDB_REGISTER_METHOD(void, SBDebugger, HandleCommand, (const char *)); + LLDB_REGISTER_METHOD(lldb::SBListener, SBDebugger, GetListener, ()); + LLDB_REGISTER_METHOD( + void, SBDebugger, HandleProcessEvent, + (const lldb::SBProcess &, const lldb::SBEvent &, FILE *, FILE *)); + LLDB_REGISTER_METHOD( + void, SBDebugger, HandleProcessEvent, + (const lldb::SBProcess &, const lldb::SBEvent &, SBFile, SBFile)); + LLDB_REGISTER_METHOD( + void, SBDebugger, HandleProcessEvent, + (const lldb::SBProcess &, const lldb::SBEvent &, FileSP, FileSP)); + LLDB_REGISTER_METHOD(lldb::SBSourceManager, SBDebugger, GetSourceManager, ()); + LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, SetDefaultArchitecture, + (const char *)); + LLDB_REGISTER_METHOD(lldb::ScriptLanguage, SBDebugger, GetScriptingLanguage, + (const char *)); + LLDB_REGISTER_STATIC_METHOD(const char *, SBDebugger, GetVersionString, ()); + LLDB_REGISTER_STATIC_METHOD(const char *, SBDebugger, StateAsCString, + (lldb::StateType)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBStructuredData, SBDebugger, + GetBuildConfiguration, ()); + LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, StateIsRunningState, + (lldb::StateType)); + LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, StateIsStoppedState, + (lldb::StateType)); + LLDB_REGISTER_METHOD( + lldb::SBTarget, SBDebugger, CreateTarget, + (const char *, const char *, const char *, bool, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, + CreateTargetWithFileAndTargetTriple, + (const char *, const char *)); + LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, CreateTargetWithFileAndArch, + (const char *, const char *)); + LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, CreateTarget, + (const char *)); + LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetDummyTarget, ()); + LLDB_REGISTER_METHOD(bool, SBDebugger, DeleteTarget, (lldb::SBTarget &)); + LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetTargetAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetIndexOfTarget, + (lldb::SBTarget)); + LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithProcessID, + (lldb::pid_t)); + LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithFileAndArch, + (const char *, const char *)); + LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumTargets, ()); + LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetSelectedTarget, ()); + LLDB_REGISTER_METHOD(void, SBDebugger, SetSelectedTarget, (lldb::SBTarget &)); + LLDB_REGISTER_METHOD(lldb::SBPlatform, SBDebugger, GetSelectedPlatform, ()); + LLDB_REGISTER_METHOD(void, SBDebugger, SetSelectedPlatform, + (lldb::SBPlatform &)); + LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumPlatforms, ()); + LLDB_REGISTER_METHOD(lldb::SBPlatform, SBDebugger, GetPlatformAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumAvailablePlatforms, ()); + LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBDebugger, + GetAvailablePlatformInfoAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(void, SBDebugger, DispatchInputInterrupt, ()); + LLDB_REGISTER_METHOD(void, SBDebugger, DispatchInputEndOfFile, ()); + LLDB_REGISTER_METHOD(void, SBDebugger, PushInputReader, + (lldb::SBInputReader &)); + LLDB_REGISTER_METHOD(void, SBDebugger, RunCommandInterpreter, (bool, bool)); + LLDB_REGISTER_METHOD(void, SBDebugger, RunCommandInterpreter, + (bool, bool, lldb::SBCommandInterpreterRunOptions &, + int &, bool &, bool &)); + LLDB_REGISTER_METHOD(lldb::SBError, SBDebugger, RunREPL, + (lldb::LanguageType, const char *)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, FindDebuggerWithID, + (int)); + LLDB_REGISTER_METHOD(const char *, SBDebugger, GetInstanceName, ()); + LLDB_REGISTER_STATIC_METHOD(lldb::SBError, SBDebugger, SetInternalVariable, + (const char *, const char *, const char *)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBStringList, SBDebugger, + GetInternalVariableValue, + (const char *, const char *)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBDebugger, GetTerminalWidth, ()); + LLDB_REGISTER_METHOD(void, SBDebugger, SetTerminalWidth, (uint32_t)); + LLDB_REGISTER_METHOD_CONST(const char *, SBDebugger, GetPrompt, ()); + LLDB_REGISTER_METHOD(void, SBDebugger, SetPrompt, (const char *)); + LLDB_REGISTER_METHOD_CONST(const char *, SBDebugger, GetReproducerPath, ()); + LLDB_REGISTER_METHOD_CONST(lldb::ScriptLanguage, SBDebugger, + GetScriptLanguage, ()); + LLDB_REGISTER_METHOD(void, SBDebugger, SetScriptLanguage, + (lldb::ScriptLanguage)); + LLDB_REGISTER_METHOD(bool, SBDebugger, SetUseExternalEditor, (bool)); + LLDB_REGISTER_METHOD(bool, SBDebugger, GetUseExternalEditor, ()); + LLDB_REGISTER_METHOD(bool, SBDebugger, SetUseColor, (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, GetUseColor, ()); + LLDB_REGISTER_METHOD(bool, SBDebugger, GetDescription, (lldb::SBStream &)); + LLDB_REGISTER_METHOD(lldb::user_id_t, SBDebugger, GetID, ()); + LLDB_REGISTER_METHOD(lldb::SBError, SBDebugger, SetCurrentPlatform, + (const char *)); + LLDB_REGISTER_METHOD(bool, SBDebugger, SetCurrentPlatformSDKRoot, + (const char *)); + LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, GetCloseInputOnEOF, ()); + LLDB_REGISTER_METHOD(void, SBDebugger, SetCloseInputOnEOF, (bool)); + LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory, + (const char *)); + LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory, + (lldb::LanguageType)); + LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, CreateCategory, + (const char *)); + LLDB_REGISTER_METHOD(bool, SBDebugger, DeleteCategory, (const char *)); + LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumCategories, ()); + LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategoryAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetDefaultCategory, + ()); + LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBDebugger, GetFormatForType, + (lldb::SBTypeNameSpecifier)); + LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBDebugger, GetSummaryForType, + (lldb::SBTypeNameSpecifier)); + LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBDebugger, GetSyntheticForType, + (lldb::SBTypeNameSpecifier)); + LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBDebugger, GetFilterForType, + (lldb::SBTypeNameSpecifier)); + LLDB_REGISTER_METHOD(bool, SBDebugger, EnableLog, + (const char *, const char **)); + LLDB_REGISTER_METHOD(lldb::SBCommandInterpreterRunResult, SBDebugger, + RunCommandInterpreter, + (const lldb::SBCommandInterpreterRunOptions &)); +} + +} // namespace repro +} // namespace lldb_private diff --git a/contrib/llvm-project/lldb/source/API/SBDeclaration.cpp b/contrib/llvm-project/lldb/source/API/SBDeclaration.cpp new file mode 100644 index 000000000000..f1066d63c06a --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBDeclaration.cpp @@ -0,0 +1,207 @@ +//===-- SBDeclaration.cpp -------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBDeclaration.h" +#include "SBReproducerPrivate.h" +#include "Utils.h" +#include "lldb/API/SBStream.h" +#include "lldb/Host/PosixApi.h" +#include "lldb/Symbol/Declaration.h" +#include "lldb/Utility/Stream.h" + +#include <limits.h> + +using namespace lldb; +using namespace lldb_private; + +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); +} + +SBDeclaration::SBDeclaration(const lldb_private::Declaration *lldb_object_ptr) + : m_opaque_up() { + if (lldb_object_ptr) + m_opaque_up = std::make_unique<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 LLDB_RECORD_RESULT(*this); +} + +void SBDeclaration::SetDeclaration( + const lldb_private::Declaration &lldb_object_ref) { + ref() = lldb_object_ref; +} + +SBDeclaration::~SBDeclaration() = default; + +bool SBDeclaration::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDeclaration, IsValid); + return this->operator bool(); +} +SBDeclaration::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDeclaration, operator bool); + + return m_opaque_up.get() && m_opaque_up->IsValid(); +} + +SBFileSpec SBDeclaration::GetFileSpec() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBDeclaration, + GetFileSpec); + + + SBFileSpec sb_file_spec; + if (m_opaque_up.get() && m_opaque_up->GetFile()) + sb_file_spec.SetFileSpec(m_opaque_up->GetFile()); + + + return LLDB_RECORD_RESULT(sb_file_spec); +} + +uint32_t SBDeclaration::GetLine() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBDeclaration, GetLine); + + + uint32_t line = 0; + if (m_opaque_up) + line = m_opaque_up->GetLine(); + + + return line; +} + +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) { + LLDB_RECORD_METHOD(void, SBDeclaration, SetLine, (uint32_t), line); + + ref().SetLine(line); +} + +void SBDeclaration::SetColumn(uint32_t column) { + LLDB_RECORD_METHOD(void, SBDeclaration, SetColumn, (uint32_t), column); + + 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(); + + if (lhs_ptr && rhs_ptr) + return lldb_private::Declaration::Compare(*lhs_ptr, *rhs_ptr) == 0; + + return lhs_ptr == rhs_ptr; +} + +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(); + + if (lhs_ptr && rhs_ptr) + return lldb_private::Declaration::Compare(*lhs_ptr, *rhs_ptr) != 0; + + return lhs_ptr != rhs_ptr; +} + +const lldb_private::Declaration *SBDeclaration::operator->() const { + return m_opaque_up.get(); +} + +lldb_private::Declaration &SBDeclaration::ref() { + if (m_opaque_up == nullptr) + m_opaque_up = std::make_unique<lldb_private::Declaration>(); + return *m_opaque_up; +} + +const lldb_private::Declaration &SBDeclaration::ref() const { + return *m_opaque_up; +} + +bool SBDeclaration::GetDescription(SBStream &description) { + LLDB_RECORD_METHOD(bool, SBDeclaration, GetDescription, (lldb::SBStream &), + description); + + Stream &strm = description.ref(); + + if (m_opaque_up) { + char file_path[PATH_MAX * 2]; + m_opaque_up->GetFile().GetPath(file_path, sizeof(file_path)); + strm.Printf("%s:%u", file_path, GetLine()); + if (GetColumn() > 0) + strm.Printf(":%u", GetColumn()); + } else + strm.PutCString("No value"); + + return true; +} + +lldb_private::Declaration *SBDeclaration::get() { return m_opaque_up.get(); } + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBDeclaration>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBDeclaration, ()); + LLDB_REGISTER_CONSTRUCTOR(SBDeclaration, (const lldb::SBDeclaration &)); + LLDB_REGISTER_METHOD( + const lldb::SBDeclaration &, + SBDeclaration, operator=,(const lldb::SBDeclaration &)); + LLDB_REGISTER_METHOD_CONST(bool, SBDeclaration, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBDeclaration, operator bool, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBDeclaration, GetFileSpec, + ()); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBDeclaration, GetLine, ()); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBDeclaration, GetColumn, ()); + LLDB_REGISTER_METHOD(void, SBDeclaration, SetFileSpec, (lldb::SBFileSpec)); + LLDB_REGISTER_METHOD(void, SBDeclaration, SetLine, (uint32_t)); + LLDB_REGISTER_METHOD(void, SBDeclaration, SetColumn, (uint32_t)); + LLDB_REGISTER_METHOD_CONST( + bool, SBDeclaration, operator==,(const lldb::SBDeclaration &)); + LLDB_REGISTER_METHOD_CONST( + bool, SBDeclaration, operator!=,(const lldb::SBDeclaration &)); + LLDB_REGISTER_METHOD(bool, SBDeclaration, GetDescription, + (lldb::SBStream &)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBEnvironment.cpp b/contrib/llvm-project/lldb/source/API/SBEnvironment.cpp new file mode 100644 index 000000000000..d4de89c32567 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBEnvironment.cpp @@ -0,0 +1,155 @@ +//===-- SBEnvironment.cpp -------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBEnvironment.h" +#include "SBReproducerPrivate.h" +#include "Utils.h" +#include "lldb/API/SBStringList.h" +#include "lldb/Utility/ConstString.h" +#include "lldb/Utility/Environment.h" + +using namespace lldb; +using namespace lldb_private; + +SBEnvironment::SBEnvironment() : m_opaque_up(new Environment()) { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBEnvironment); +} + +SBEnvironment::SBEnvironment(const SBEnvironment &rhs) + : m_opaque_up(clone(rhs.m_opaque_up)) { + LLDB_RECORD_CONSTRUCTOR(SBEnvironment, (const lldb::SBEnvironment &), rhs); +} + +SBEnvironment::SBEnvironment(Environment rhs) + : m_opaque_up(new Environment(std::move(rhs))) {} + +SBEnvironment::~SBEnvironment() = default; + +const SBEnvironment &SBEnvironment::operator=(const SBEnvironment &rhs) { + LLDB_RECORD_METHOD(const lldb::SBEnvironment &, + SBEnvironment, operator=,(const lldb::SBEnvironment &), + rhs); + + if (this != &rhs) + m_opaque_up = clone(rhs.m_opaque_up); + return LLDB_RECORD_RESULT(*this); +} + +size_t SBEnvironment::GetNumValues() { + LLDB_RECORD_METHOD_NO_ARGS(size_t, SBEnvironment, GetNumValues); + + return m_opaque_up->size(); +} + +const char *SBEnvironment::Get(const char *name) { + LLDB_RECORD_METHOD(const char *, SBEnvironment, Get, (const char *), name); + + auto entry = m_opaque_up->find(name); + if (entry == m_opaque_up->end()) { + return nullptr; + } + return ConstString(entry->second).AsCString(""); +} + +const char *SBEnvironment::GetNameAtIndex(size_t index) { + LLDB_RECORD_METHOD(const char *, SBEnvironment, GetNameAtIndex, (size_t), + index); + + if (index >= GetNumValues()) + return nullptr; + return ConstString(std::next(m_opaque_up->begin(), index)->first()) + .AsCString(""); +} + +const char *SBEnvironment::GetValueAtIndex(size_t index) { + LLDB_RECORD_METHOD(const char *, SBEnvironment, GetValueAtIndex, (size_t), + index); + + if (index >= GetNumValues()) + return nullptr; + return ConstString(std::next(m_opaque_up->begin(), index)->second) + .AsCString(""); +} + +bool SBEnvironment::Set(const char *name, const char *value, bool overwrite) { + LLDB_RECORD_METHOD(bool, SBEnvironment, Set, + (const char *, const char *, bool), name, value, + overwrite); + + if (overwrite) { + m_opaque_up->insert_or_assign(name, std::string(value)); + return true; + } + return m_opaque_up->try_emplace(name, std::string(value)).second; +} + +bool SBEnvironment::Unset(const char *name) { + LLDB_RECORD_METHOD(bool, SBEnvironment, Unset, (const char *), name); + + return m_opaque_up->erase(name); +} + +SBStringList SBEnvironment::GetEntries() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStringList, SBEnvironment, GetEntries); + + SBStringList entries; + for (const auto &KV : *m_opaque_up) { + entries.AppendString(Environment::compose(KV).c_str()); + } + return LLDB_RECORD_RESULT(entries); +} + +void SBEnvironment::PutEntry(const char *name_and_value) { + LLDB_RECORD_METHOD(void, SBEnvironment, PutEntry, (const char *), + name_and_value); + + auto split = llvm::StringRef(name_and_value).split('='); + m_opaque_up->insert_or_assign(split.first.str(), split.second.str()); +} + +void SBEnvironment::SetEntries(const SBStringList &entries, bool append) { + LLDB_RECORD_METHOD(void, SBEnvironment, SetEntries, + (const lldb::SBStringList &, bool), entries, append); + + if (!append) + m_opaque_up->clear(); + for (size_t i = 0; i < entries.GetSize(); i++) { + PutEntry(entries.GetStringAtIndex(i)); + } +} + +void SBEnvironment::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBEnvironment, Clear); + + m_opaque_up->clear(); +} + +Environment &SBEnvironment::ref() const { return *m_opaque_up; } + +namespace lldb_private { +namespace repro { +template <> void RegisterMethods<SBEnvironment>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBEnvironment, ()); + LLDB_REGISTER_CONSTRUCTOR(SBEnvironment, (const lldb::SBEnvironment &)); + LLDB_REGISTER_METHOD(const lldb::SBEnvironment &, + SBEnvironment, operator=,(const lldb::SBEnvironment &)); + LLDB_REGISTER_METHOD(size_t, SBEnvironment, GetNumValues, ()); + LLDB_REGISTER_METHOD(const char *, SBEnvironment, Get, (const char *)); + LLDB_REGISTER_METHOD(const char *, SBEnvironment, GetNameAtIndex, (size_t)); + LLDB_REGISTER_METHOD(const char *, SBEnvironment, GetValueAtIndex, (size_t)); + LLDB_REGISTER_METHOD(bool, SBEnvironment, Set, + (const char *, const char *, bool)); + LLDB_REGISTER_METHOD(bool, SBEnvironment, Unset, (const char *)); + LLDB_REGISTER_METHOD(lldb::SBStringList, SBEnvironment, GetEntries, ()); + LLDB_REGISTER_METHOD(void, SBEnvironment, PutEntry, (const char *)); + LLDB_REGISTER_METHOD(void, SBEnvironment, SetEntries, + (const lldb::SBStringList &, bool)); + LLDB_REGISTER_METHOD(void, SBEnvironment, Clear, ()); +} +} // namespace repro +} // namespace lldb_private diff --git a/contrib/llvm-project/lldb/source/API/SBError.cpp b/contrib/llvm-project/lldb/source/API/SBError.cpp new file mode 100644 index 000000000000..67c7663d3583 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBError.cpp @@ -0,0 +1,212 @@ +//===-- SBError.cpp -------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBError.h" +#include "SBReproducerPrivate.h" +#include "Utils.h" +#include "lldb/API/SBStream.h" +#include "lldb/Utility/Status.h" + +#include <stdarg.h> + +using namespace lldb; +using namespace lldb_private; + +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() = default; + +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 LLDB_RECORD_RESULT(*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 nullptr; +} + +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); + + bool ret_value = false; + if (m_opaque_up) + ret_value = m_opaque_up->Fail(); + + + return ret_value; +} + +bool SBError::Success() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, Success); + + bool ret_value = true; + if (m_opaque_up) + ret_value = m_opaque_up->Success(); + + return ret_value; +} + +uint32_t SBError::GetError() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBError, GetError); + + + uint32_t err = 0; + if (m_opaque_up) + err = m_opaque_up->GetError(); + + + return err; +} + +ErrorType SBError::GetType() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ErrorType, SBError, GetType); + + ErrorType err_type = eErrorTypeInvalid; + if (m_opaque_up) + err_type = m_opaque_up->GetType(); + + return err_type; +} + +void SBError::SetError(uint32_t err, ErrorType type) { + LLDB_RECORD_METHOD(void, SBError, SetError, (uint32_t, lldb::ErrorType), err, + type); + + CreateIfNeeded(); + m_opaque_up->SetError(err, type); +} + +void SBError::SetError(const Status &lldb_error) { + CreateIfNeeded(); + *m_opaque_up = 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); +} + +int SBError::SetErrorStringWithFormat(const char *format, ...) { + CreateIfNeeded(); + va_list args; + va_start(args, format); + int num_chars = m_opaque_up->SetErrorStringWithVarArg(format, args); + va_end(args); + return num_chars; +} + +bool SBError::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, IsValid); + return this->operator bool(); +} +SBError::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, operator bool); + + return m_opaque_up != nullptr; +} + +void SBError::CreateIfNeeded() { + if (m_opaque_up == nullptr) + m_opaque_up = std::make_unique<Status>(); +} + +lldb_private::Status *SBError::operator->() { return m_opaque_up.get(); } + +lldb_private::Status *SBError::get() { return m_opaque_up.get(); } + +lldb_private::Status &SBError::ref() { + CreateIfNeeded(); + return *m_opaque_up; +} + +const lldb_private::Status &SBError::operator*() const { + // Be sure to call "IsValid()" before calling this function or it will crash + return *m_opaque_up; +} + +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"); + else { + const char *err_string = GetCString(); + description.Printf("error: %s", + (err_string != nullptr ? err_string : "")); + } + } else + description.Printf("error: <NULL>"); + + return true; +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBError>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBError, ()); + LLDB_REGISTER_CONSTRUCTOR(SBError, (const lldb::SBError &)); + LLDB_REGISTER_METHOD(const lldb::SBError &, + SBError, operator=,(const lldb::SBError &)); + LLDB_REGISTER_METHOD_CONST(const char *, SBError, GetCString, ()); + LLDB_REGISTER_METHOD(void, SBError, Clear, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBError, Fail, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBError, Success, ()); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBError, GetError, ()); + LLDB_REGISTER_METHOD_CONST(lldb::ErrorType, SBError, GetType, ()); + LLDB_REGISTER_METHOD(void, SBError, SetError, (uint32_t, lldb::ErrorType)); + LLDB_REGISTER_METHOD(void, SBError, SetErrorToErrno, ()); + LLDB_REGISTER_METHOD(void, SBError, SetErrorToGenericError, ()); + LLDB_REGISTER_METHOD(void, SBError, SetErrorString, (const char *)); + LLDB_REGISTER_METHOD_CONST(bool, SBError, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBError, operator bool, ()); + LLDB_REGISTER_METHOD(bool, SBError, GetDescription, (lldb::SBStream &)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBEvent.cpp b/contrib/llvm-project/lldb/source/API/SBEvent.cpp new file mode 100644 index 000000000000..2776ec49c092 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBEvent.cpp @@ -0,0 +1,242 @@ +//===-- SBEvent.cpp -------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBEvent.h" +#include "SBReproducerPrivate.h" +#include "lldb/API/SBBroadcaster.h" +#include "lldb/API/SBStream.h" + +#include "lldb/Breakpoint/Breakpoint.h" +#include "lldb/Core/StreamFile.h" +#include "lldb/Interpreter/CommandInterpreter.h" +#include "lldb/Target/Process.h" +#include "lldb/Utility/ConstString.h" +#include "lldb/Utility/Event.h" +#include "lldb/Utility/Stream.h" + +using namespace lldb; +using namespace lldb_private; + +SBEvent::SBEvent() : m_event_sp(), m_opaque_ptr(nullptr) { + 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()) { + 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()) { + LLDB_RECORD_CONSTRUCTOR(SBEvent, (lldb::EventSP &), event_sp); +} + +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) { + 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; + } + return LLDB_RECORD_RESULT(*this); +} + +SBEvent::~SBEvent() = default; + +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(); + if (event_data) + return lldb_event->GetData()->GetFlavor().AsCString(); + } + return nullptr; +} + +uint32_t SBEvent::GetType() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBEvent, GetType); + + + const Event *lldb_event = get(); + uint32_t event_type = 0; + if (lldb_event) + event_type = lldb_event->GetType(); + + + return event_type; +} + +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 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(); + else + return "unknown class"; +} + +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; + if (lldb_event) + success = lldb_event->BroadcasterIs(broadcaster.get()); + + + return success; +} + +void SBEvent::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBEvent, Clear); + + Event *lldb_event = get(); + if (lldb_event) + lldb_event->Clear(); +} + +EventSP &SBEvent::GetSP() const { return m_event_sp; } + +Event *SBEvent::get() const { + // There is a dangerous accessor call GetSharedPtr which can be used, so if + // we have anything valid in m_event_sp, we must use that since if it gets + // used by a function that puts something in there, then it won't update + // m_opaque_ptr... + if (m_event_sp) + m_opaque_ptr = m_event_sp.get(); + + return m_opaque_ptr; +} + +void SBEvent::reset(EventSP &event_sp) { + m_event_sp = event_sp; + m_opaque_ptr = m_event_sp.get(); +} + +void SBEvent::reset(Event *event_ptr) { + m_opaque_ptr = event_ptr; + m_event_sp.reset(); +} + +bool SBEvent::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBEvent, IsValid); + return this->operator bool(); +} +SBEvent::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBEvent, operator bool); + + // Do NOT use m_opaque_ptr directly!!! Must use the SBEvent::get() accessor. + // See comments in SBEvent::get().... + return SBEvent::get() != nullptr; +} + +const char *SBEvent::GetCStringFromEvent(const SBEvent &event) { + LLDB_RECORD_STATIC_METHOD(const char *, SBEvent, GetCStringFromEvent, + (const lldb::SBEvent &), event); + + return static_cast<const char *>( + EventDataBytes::GetBytesFromEvent(event.get())); +} + +bool SBEvent::GetDescription(SBStream &description) { + LLDB_RECORD_METHOD(bool, SBEvent, GetDescription, (lldb::SBStream &), + description); + + Stream &strm = description.ref(); + + if (get()) { + m_opaque_ptr->Dump(&strm); + } else + strm.PutCString("No value"); + + return true; +} + +bool SBEvent::GetDescription(SBStream &description) const { + LLDB_RECORD_METHOD_CONST(bool, SBEvent, GetDescription, (lldb::SBStream &), + description); + + Stream &strm = description.ref(); + + if (get()) { + m_opaque_ptr->Dump(&strm); + } else + strm.PutCString("No value"); + + return true; +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBEvent>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBEvent, ()); + LLDB_REGISTER_CONSTRUCTOR(SBEvent, (uint32_t, const char *, uint32_t)); + LLDB_REGISTER_CONSTRUCTOR(SBEvent, (lldb::EventSP &)); + LLDB_REGISTER_CONSTRUCTOR(SBEvent, (lldb_private::Event *)); + LLDB_REGISTER_CONSTRUCTOR(SBEvent, (const lldb::SBEvent &)); + LLDB_REGISTER_METHOD(const lldb::SBEvent &, + SBEvent, operator=,(const lldb::SBEvent &)); + LLDB_REGISTER_METHOD(const char *, SBEvent, GetDataFlavor, ()); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBEvent, GetType, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBBroadcaster, SBEvent, GetBroadcaster, + ()); + LLDB_REGISTER_METHOD_CONST(const char *, SBEvent, GetBroadcasterClass, ()); + LLDB_REGISTER_METHOD(bool, SBEvent, BroadcasterMatchesPtr, + (const lldb::SBBroadcaster *)); + LLDB_REGISTER_METHOD(bool, SBEvent, BroadcasterMatchesRef, + (const lldb::SBBroadcaster &)); + LLDB_REGISTER_METHOD(void, SBEvent, Clear, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBEvent, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBEvent, operator bool, ()); + LLDB_REGISTER_STATIC_METHOD(const char *, SBEvent, GetCStringFromEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_METHOD(bool, SBEvent, GetDescription, (lldb::SBStream &)); + LLDB_REGISTER_METHOD_CONST(bool, SBEvent, GetDescription, + (lldb::SBStream &)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBExecutionContext.cpp b/contrib/llvm-project/lldb/source/API/SBExecutionContext.cpp new file mode 100644 index 000000000000..caf02b4164ea --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBExecutionContext.cpp @@ -0,0 +1,162 @@ +//===-- SBExecutionContext.cpp --------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBExecutionContext.h" +#include "SBReproducerPrivate.h" + +#include "lldb/API/SBFrame.h" +#include "lldb/API/SBProcess.h" +#include "lldb/API/SBTarget.h" +#include "lldb/API/SBThread.h" + +#include "lldb/Target/ExecutionContext.h" + +using namespace lldb; +using namespace lldb_private; + +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) { + LLDB_RECORD_CONSTRUCTOR(SBExecutionContext, + (const lldb::SBExecutionContext &), rhs); +} + +SBExecutionContext::SBExecutionContext( + lldb::ExecutionContextRefSP exe_ctx_ref_sp) + : m_exe_ctx_sp(exe_ctx_ref_sp) { + LLDB_RECORD_CONSTRUCTOR(SBExecutionContext, (lldb::ExecutionContextRefSP), + exe_ctx_ref_sp); +} + +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()); +} + +SBExecutionContext::~SBExecutionContext() = default; + +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 LLDB_RECORD_RESULT(*this); +} + +ExecutionContextRef *SBExecutionContext::get() const { + return m_exe_ctx_sp.get(); +} + +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 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 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 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 LLDB_RECORD_RESULT(sb_frame); +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBExecutionContext>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, ()); + LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, + (const lldb::SBExecutionContext &)); + LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, + (lldb::ExecutionContextRefSP)); + LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, (const lldb::SBTarget &)); + LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, (const lldb::SBProcess &)); + LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, (lldb::SBThread)); + LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, (const lldb::SBFrame &)); + LLDB_REGISTER_METHOD( + const lldb::SBExecutionContext &, + SBExecutionContext, operator=,(const lldb::SBExecutionContext &)); + LLDB_REGISTER_METHOD_CONST(lldb::SBTarget, SBExecutionContext, GetTarget, + ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBProcess, SBExecutionContext, GetProcess, + ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBExecutionContext, GetThread, + ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBFrame, SBExecutionContext, GetFrame, ()); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBExpressionOptions.cpp b/contrib/llvm-project/lldb/source/API/SBExpressionOptions.cpp new file mode 100644 index 000000000000..217e8ad5c21b --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBExpressionOptions.cpp @@ -0,0 +1,352 @@ +//===-- SBExpressionOptions.cpp -------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBExpressionOptions.h" +#include "SBReproducerPrivate.h" +#include "Utils.h" +#include "lldb/API/SBStream.h" +#include "lldb/Target/Target.h" + +using namespace lldb; +using namespace lldb_private; + +SBExpressionOptions::SBExpressionOptions() + : 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 LLDB_RECORD_RESULT(*this); +} + +SBExpressionOptions::~SBExpressionOptions() = default; + +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); +} + +void SBExpressionOptions::SetCancelCallback( + lldb::ExpressionCancelCallback callback, void *baton) { + LLDB_RECORD_DUMMY(void, SBExpressionOptions, SetCancelCallback, + (lldb::ExpressionCancelCallback, void *), callback, baton); + + m_opaque_up->SetCancelCallback(callback, baton); +} + +bool SBExpressionOptions::GetGenerateDebugInfo() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetGenerateDebugInfo); + + 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); +} + +uint64_t SBExpressionOptions::GetRetriesWithFixIts() { + LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBExpressionOptions, + GetRetriesWithFixIts); + + return m_opaque_up->GetRetriesWithFixIts(); +} + +void SBExpressionOptions::SetRetriesWithFixIts(uint64_t retries) { + LLDB_RECORD_METHOD(void, SBExpressionOptions, SetRetriesWithFixIts, + (uint64_t), retries); + + return m_opaque_up->SetRetriesWithFixIts(retries); +} + +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); +} + +EvaluateExpressionOptions *SBExpressionOptions::get() const { + return m_opaque_up.get(); +} + +EvaluateExpressionOptions &SBExpressionOptions::ref() const { + return *(m_opaque_up.get()); +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBExpressionOptions>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBExpressionOptions, ()); + LLDB_REGISTER_CONSTRUCTOR(SBExpressionOptions, + (const lldb::SBExpressionOptions &)); + LLDB_REGISTER_METHOD( + const lldb::SBExpressionOptions &, + SBExpressionOptions, operator=,(const lldb::SBExpressionOptions &)); + LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetCoerceResultToId, + ()); + LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetCoerceResultToId, + (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetUnwindOnError, ()); + LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetUnwindOnError, (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetIgnoreBreakpoints, + ()); + LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetIgnoreBreakpoints, + (bool)); + LLDB_REGISTER_METHOD_CONST(lldb::DynamicValueType, SBExpressionOptions, + GetFetchDynamicValue, ()); + LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetFetchDynamicValue, + (lldb::DynamicValueType)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBExpressionOptions, + GetTimeoutInMicroSeconds, ()); + LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetTimeoutInMicroSeconds, + (uint32_t)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBExpressionOptions, + GetOneThreadTimeoutInMicroSeconds, ()); + LLDB_REGISTER_METHOD(void, SBExpressionOptions, + SetOneThreadTimeoutInMicroSeconds, (uint32_t)); + LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetTryAllThreads, ()); + LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetTryAllThreads, (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetStopOthers, ()); + LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetStopOthers, (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetTrapExceptions, + ()); + LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetTrapExceptions, (bool)); + LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetLanguage, + (lldb::LanguageType)); + LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetGenerateDebugInfo, ()); + LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetGenerateDebugInfo, + (bool)); + LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetSuppressPersistentResult, + ()); + LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetSuppressPersistentResult, + (bool)); + LLDB_REGISTER_METHOD_CONST(const char *, SBExpressionOptions, GetPrefix, + ()); + LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetPrefix, (const char *)); + LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetAutoApplyFixIts, ()); + LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetAutoApplyFixIts, (bool)); + LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetTopLevel, ()); + LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetTopLevel, (bool)); + LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetAllowJIT, ()); + LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetAllowJIT, (bool)); + LLDB_REGISTER_METHOD(uint64_t, SBExpressionOptions, GetRetriesWithFixIts, ()); + LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetRetriesWithFixIts, + (uint64_t)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBFile.cpp b/contrib/llvm-project/lldb/source/API/SBFile.cpp new file mode 100644 index 000000000000..41ccdbe76b91 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBFile.cpp @@ -0,0 +1,158 @@ +//===-- SBFile.cpp --------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBFile.h" +#include "SBReproducerPrivate.h" +#include "lldb/API/SBError.h" +#include "lldb/Host/File.h" + +using namespace lldb; +using namespace lldb_private; + +SBFile::~SBFile() = default; + +SBFile::SBFile(FileSP file_sp) : m_opaque_sp(file_sp) { + // We have no way to capture the incoming FileSP as the class isn't + // instrumented, so pretend that it's always null. + LLDB_RECORD_CONSTRUCTOR(SBFile, (lldb::FileSP), nullptr); +} + +SBFile::SBFile(const SBFile &rhs) : m_opaque_sp(rhs.m_opaque_sp) { + LLDB_RECORD_CONSTRUCTOR(SBFile, (const lldb::SBFile&), rhs); +} + +SBFile &SBFile ::operator=(const SBFile &rhs) { + LLDB_RECORD_METHOD(lldb::SBFile &, + SBFile, operator=,(const lldb::SBFile &), rhs); + + if (this != &rhs) + m_opaque_sp = rhs.m_opaque_sp; + return LLDB_RECORD_RESULT(*this); +} + +SBFile::SBFile() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFile); } + +SBFile::SBFile(FILE *file, bool transfer_ownership) { + LLDB_RECORD_CONSTRUCTOR(SBFile, (FILE *, bool), file, transfer_ownership); + + m_opaque_sp = std::make_shared<NativeFile>(file, transfer_ownership); +} + +SBFile::SBFile(int fd, const char *mode, bool transfer_owndership) { + LLDB_RECORD_CONSTRUCTOR(SBFile, (int, const char *, bool), fd, mode, + transfer_owndership); + + auto options = File::GetOptionsFromMode(mode); + if (!options) { + llvm::consumeError(options.takeError()); + return; + } + m_opaque_sp = + std::make_shared<NativeFile>(fd, options.get(), transfer_owndership); +} + +SBError SBFile::Read(uint8_t *buf, size_t num_bytes, size_t *bytes_read) { + LLDB_RECORD_METHOD(lldb::SBError, SBFile, Read, (uint8_t *, size_t, size_t *), + buf, num_bytes, bytes_read); + + SBError error; + if (!m_opaque_sp) { + error.SetErrorString("invalid SBFile"); + *bytes_read = 0; + } else { + Status status = m_opaque_sp->Read(buf, num_bytes); + error.SetError(status); + *bytes_read = num_bytes; + } + return LLDB_RECORD_RESULT(error); +} + +SBError SBFile::Write(const uint8_t *buf, size_t num_bytes, + size_t *bytes_written) { + LLDB_RECORD_METHOD(lldb::SBError, SBFile, Write, + (const uint8_t *, size_t, size_t *), buf, num_bytes, + bytes_written); + + SBError error; + if (!m_opaque_sp) { + error.SetErrorString("invalid SBFile"); + *bytes_written = 0; + } else { + Status status = m_opaque_sp->Write(buf, num_bytes); + error.SetError(status); + *bytes_written = num_bytes; + } + return LLDB_RECORD_RESULT(error); +} + +SBError SBFile::Flush() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBFile, Flush); + + SBError error; + if (!m_opaque_sp) { + error.SetErrorString("invalid SBFile"); + } else { + Status status = m_opaque_sp->Flush(); + error.SetError(status); + } + return LLDB_RECORD_RESULT(error); +} + +bool SBFile::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFile, IsValid); + return m_opaque_sp && m_opaque_sp->IsValid(); +} + +SBError SBFile::Close() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBFile, Close); + SBError error; + if (m_opaque_sp) { + Status status = m_opaque_sp->Close(); + error.SetError(status); + } + return LLDB_RECORD_RESULT(error); +} + +SBFile::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFile, operator bool); + return IsValid(); +} + +bool SBFile::operator!() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFile, operator!); + return !IsValid(); +} + +FileSP SBFile::GetFile() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(FileSP, SBFile, GetFile); + return LLDB_RECORD_RESULT(m_opaque_sp); +} + +namespace lldb_private { +namespace repro { + +template <> void RegisterMethods<SBFile>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBFile, ()); + LLDB_REGISTER_CONSTRUCTOR(SBFile, (FileSP)); + LLDB_REGISTER_CONSTRUCTOR(SBFile, (const SBFile&)); + LLDB_REGISTER_CONSTRUCTOR(SBFile, (FILE *, bool)); + LLDB_REGISTER_CONSTRUCTOR(SBFile, (int, const char *, bool)); + LLDB_REGISTER_METHOD(SBFile&, SBFile, operator=,(const SBFile&)); + LLDB_REGISTER_METHOD(lldb::SBError, SBFile, Flush, ()); + LLDB_REGISTER_METHOD(lldb::SBError, SBFile, Read, + (uint8_t *, size_t, size_t *)); + LLDB_REGISTER_METHOD(lldb::SBError, SBFile, Write, + (const uint8_t *, size_t, size_t *)); + LLDB_REGISTER_METHOD_CONST(bool, SBFile, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBFile, operator bool,()); + LLDB_REGISTER_METHOD_CONST(bool, SBFile, operator!,()); + LLDB_REGISTER_METHOD_CONST(FileSP, SBFile, GetFile, ()); + LLDB_REGISTER_METHOD(lldb::SBError, SBFile, Close, ()); +} +} // namespace repro +} // namespace lldb_private diff --git a/contrib/llvm-project/lldb/source/API/SBFileSpec.cpp b/contrib/llvm-project/lldb/source/API/SBFileSpec.cpp new file mode 100644 index 000000000000..7bfb665df4fb --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBFileSpec.cpp @@ -0,0 +1,223 @@ +//===-- SBFileSpec.cpp ----------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBFileSpec.h" +#include "SBReproducerPrivate.h" +#include "Utils.h" +#include "lldb/API/SBStream.h" +#include "lldb/Host/FileSystem.h" +#include "lldb/Host/PosixApi.h" +#include "lldb/Utility/FileSpec.h" +#include "lldb/Utility/Stream.h" + +#include "llvm/ADT/SmallString.h" + +#include <inttypes.h> +#include <limits.h> + +using namespace lldb; +using namespace lldb_private; + +SBFileSpec::SBFileSpec() : m_opaque_up(new lldb_private::FileSpec()) { + 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); +} + +SBFileSpec::SBFileSpec(const lldb_private::FileSpec &fspec) + : m_opaque_up(new 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); +} + +SBFileSpec::~SBFileSpec() = default; + +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 LLDB_RECORD_RESULT(*this); +} + +bool SBFileSpec::operator==(const SBFileSpec &rhs) const { + LLDB_RECORD_METHOD_CONST(bool, SBFileSpec, operator==,(const SBFileSpec &rhs), + rhs); + + return ref() == rhs.ref(); +} + +bool SBFileSpec::operator!=(const SBFileSpec &rhs) const { + LLDB_RECORD_METHOD_CONST(bool, SBFileSpec, operator!=,(const SBFileSpec &rhs), + rhs); + + return !(*this == rhs); +} + +bool SBFileSpec::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFileSpec, IsValid); + return this->operator bool(); +} +SBFileSpec::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFileSpec, operator bool); + + return m_opaque_up->operator bool(); +} + +bool SBFileSpec::Exists() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFileSpec, Exists); + + return FileSystem::Instance().Exists(*m_opaque_up); +} + +bool SBFileSpec::ResolveExecutableLocation() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBFileSpec, ResolveExecutableLocation); + + 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()); + return std::min(dst_len - 1, result.size()); +} + +const char *SBFileSpec::GetFilename() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFileSpec, GetFilename); + + return m_opaque_up->GetFilename().AsCString(); +} + +const char *SBFileSpec::GetDirectory() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFileSpec, GetDirectory); + + FileSpec directory{*m_opaque_up}; + directory.GetFilename().Clear(); + return directory.GetCString(); +} + +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 + m_opaque_up->GetFilename().Clear(); +} + +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 + m_opaque_up->GetDirectory().Clear(); +} + +uint32_t SBFileSpec::GetPath(char *dst_path, size_t dst_len) const { + LLDB_RECORD_CHAR_PTR_METHOD_CONST(uint32_t, SBFileSpec, GetPath, + (char *, size_t), dst_path, "", dst_len); + + uint32_t result = m_opaque_up->GetPath(dst_path, dst_len); + + if (result == 0 && dst_path && dst_len > 0) + *dst_path = '\0'; + return result; +} + +const lldb_private::FileSpec *SBFileSpec::operator->() const { + return m_opaque_up.get(); +} + +const lldb_private::FileSpec *SBFileSpec::get() const { + return m_opaque_up.get(); +} + +const lldb_private::FileSpec &SBFileSpec::operator*() const { + return *m_opaque_up; +} + +const lldb_private::FileSpec &SBFileSpec::ref() const { return *m_opaque_up; } + +void SBFileSpec::SetFileSpec(const lldb_private::FileSpec &fs) { + *m_opaque_up = 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))) + strm.PutCString(path); + return true; +} + +void SBFileSpec::AppendPathComponent(const char *fn) { + LLDB_RECORD_METHOD(void, SBFileSpec, AppendPathComponent, (const char *), fn); + + m_opaque_up->AppendPathComponent(fn); +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBFileSpec>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBFileSpec, ()); + LLDB_REGISTER_CONSTRUCTOR(SBFileSpec, (const lldb::SBFileSpec &)); + LLDB_REGISTER_CONSTRUCTOR(SBFileSpec, (const char *)); + LLDB_REGISTER_CONSTRUCTOR(SBFileSpec, (const char *, bool)); + LLDB_REGISTER_METHOD(const lldb::SBFileSpec &, + SBFileSpec, operator=,(const lldb::SBFileSpec &)); + LLDB_REGISTER_METHOD_CONST(bool, + SBFileSpec, operator==,(const lldb::SBFileSpec &)); + LLDB_REGISTER_METHOD_CONST(bool, + SBFileSpec, operator!=,(const lldb::SBFileSpec &)); + LLDB_REGISTER_METHOD_CONST(bool, SBFileSpec, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBFileSpec, operator bool, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBFileSpec, Exists, ()); + LLDB_REGISTER_METHOD(bool, SBFileSpec, ResolveExecutableLocation, ()); + LLDB_REGISTER_STATIC_METHOD(int, SBFileSpec, ResolvePath, + (const char *, char *, size_t)); + LLDB_REGISTER_METHOD_CONST(const char *, SBFileSpec, GetFilename, ()); + LLDB_REGISTER_METHOD_CONST(const char *, SBFileSpec, GetDirectory, ()); + LLDB_REGISTER_METHOD(void, SBFileSpec, SetFilename, (const char *)); + LLDB_REGISTER_METHOD(void, SBFileSpec, SetDirectory, (const char *)); + LLDB_REGISTER_METHOD_CONST(bool, SBFileSpec, GetDescription, + (lldb::SBStream &)); + LLDB_REGISTER_METHOD(void, SBFileSpec, AppendPathComponent, (const char *)); + LLDB_REGISTER_CHAR_PTR_METHOD_CONST(uint32_t, SBFileSpec, GetPath); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBFileSpecList.cpp b/contrib/llvm-project/lldb/source/API/SBFileSpecList.cpp new file mode 100644 index 000000000000..7afa34363271 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBFileSpecList.cpp @@ -0,0 +1,152 @@ +//===-- SBFileSpecList.cpp ------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBFileSpecList.h" +#include "SBReproducerPrivate.h" +#include "Utils.h" +#include "lldb/API/SBFileSpec.h" +#include "lldb/API/SBStream.h" +#include "lldb/Core/FileSpecList.h" +#include "lldb/Host/PosixApi.h" +#include "lldb/Utility/FileSpec.h" +#include "lldb/Utility/Stream.h" + +#include <limits.h> + +using namespace lldb; +using namespace lldb_private; + +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); + + + m_opaque_up = clone(rhs.m_opaque_up); +} + +SBFileSpecList::~SBFileSpecList() = default; + +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 LLDB_RECORD_RESULT(*this); +} + +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() { + 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 LLDB_RECORD_RESULT(new_spec); +} + +const lldb_private::FileSpecList *SBFileSpecList::operator->() const { + return m_opaque_up.get(); +} + +const lldb_private::FileSpecList *SBFileSpecList::get() const { + return m_opaque_up.get(); +} + +const lldb_private::FileSpecList &SBFileSpecList::operator*() const { + return *m_opaque_up; +} + +const lldb_private::FileSpecList &SBFileSpecList::ref() const { + return *m_opaque_up; +} + +bool SBFileSpecList::GetDescription(SBStream &description) const { + LLDB_RECORD_METHOD_CONST(bool, SBFileSpecList, GetDescription, + (lldb::SBStream &), description); + + Stream &strm = description.ref(); + + if (m_opaque_up) { + uint32_t num_files = m_opaque_up->GetSize(); + strm.Printf("%d files: ", num_files); + for (uint32_t i = 0; i < num_files; i++) { + char path[PATH_MAX]; + if (m_opaque_up->GetFileSpecAtIndex(i).GetPath(path, sizeof(path))) + strm.Printf("\n %s", path); + } + } else + strm.PutCString("No value"); + + return true; +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBFileSpecList>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBFileSpecList, ()); + LLDB_REGISTER_CONSTRUCTOR(SBFileSpecList, (const lldb::SBFileSpecList &)); + LLDB_REGISTER_METHOD( + const lldb::SBFileSpecList &, + SBFileSpecList, operator=,(const lldb::SBFileSpecList &)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBFileSpecList, GetSize, ()); + LLDB_REGISTER_METHOD(void, SBFileSpecList, Append, + (const lldb::SBFileSpec &)); + LLDB_REGISTER_METHOD(bool, SBFileSpecList, AppendIfUnique, + (const lldb::SBFileSpec &)); + LLDB_REGISTER_METHOD(void, SBFileSpecList, Clear, ()); + LLDB_REGISTER_METHOD(uint32_t, SBFileSpecList, FindFileIndex, + (uint32_t, const lldb::SBFileSpec &, bool)); + LLDB_REGISTER_METHOD_CONST(const lldb::SBFileSpec, SBFileSpecList, + GetFileSpecAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD_CONST(bool, SBFileSpecList, GetDescription, + (lldb::SBStream &)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBFrame.cpp b/contrib/llvm-project/lldb/source/API/SBFrame.cpp new file mode 100644 index 000000000000..81782dbf838f --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBFrame.cpp @@ -0,0 +1,1368 @@ +//===-- SBFrame.cpp -------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include <algorithm> +#include <set> +#include <string> + +#include "lldb/API/SBFrame.h" + +#include "lldb/lldb-types.h" + +#include "SBReproducerPrivate.h" +#include "Utils.h" +#include "lldb/Core/Address.h" +#include "lldb/Core/StreamFile.h" +#include "lldb/Core/ValueObjectRegister.h" +#include "lldb/Core/ValueObjectVariable.h" +#include "lldb/Expression/ExpressionVariable.h" +#include "lldb/Expression/UserExpression.h" +#include "lldb/Host/Host.h" +#include "lldb/Symbol/Block.h" +#include "lldb/Symbol/Function.h" +#include "lldb/Symbol/Symbol.h" +#include "lldb/Symbol/SymbolContext.h" +#include "lldb/Symbol/Variable.h" +#include "lldb/Symbol/VariableList.h" +#include "lldb/Target/ExecutionContext.h" +#include "lldb/Target/Process.h" +#include "lldb/Target/RegisterContext.h" +#include "lldb/Target/StackFrame.h" +#include "lldb/Target/StackFrameRecognizer.h" +#include "lldb/Target/StackID.h" +#include "lldb/Target/Target.h" +#include "lldb/Target/Thread.h" +#include "lldb/Utility/ConstString.h" +#include "lldb/Utility/Stream.h" + +#include "lldb/API/SBAddress.h" +#include "lldb/API/SBDebugger.h" +#include "lldb/API/SBExpressionOptions.h" +#include "lldb/API/SBStream.h" +#include "lldb/API/SBSymbolContext.h" +#include "lldb/API/SBThread.h" +#include "lldb/API/SBValue.h" +#include "lldb/API/SBVariablesOptions.h" + +#include "llvm/Support/PrettyStackTrace.h" + +using namespace lldb; +using namespace lldb_private; + +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); +} + +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 LLDB_RECORD_RESULT(*this); +} + +StackFrameSP SBFrame::GetFrameSP() const { + return (m_opaque_sp ? m_opaque_sp->GetFrameSP() : StackFrameSP()); +} + +void SBFrame::SetFrameSP(const StackFrameSP &lldb_object_sp) { + return m_opaque_sp->SetFrameSP(lldb_object_sp); +} + +bool SBFrame::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsValid); + return this->operator bool(); +} +SBFrame::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, operator bool); + + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + Target *target = exe_ctx.GetTargetPtr(); + Process *process = exe_ctx.GetProcessPtr(); + if (target && process) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process->GetRunLock())) + return GetFrameSP().get() != nullptr; + } + + // Without a target & process we can't have a valid stack frame. + return false; +} + +SBSymbolContext SBFrame::GetSymbolContext(uint32_t resolve_scope) const { + LLDB_RECORD_METHOD_CONST(lldb::SBSymbolContext, SBFrame, GetSymbolContext, + (uint32_t), resolve_scope); + + SBSymbolContext sb_sym_ctx; + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + SymbolContextItem scope = static_cast<SymbolContextItem>(resolve_scope); + StackFrame *frame = nullptr; + Target *target = exe_ctx.GetTargetPtr(); + Process *process = exe_ctx.GetProcessPtr(); + if (target && process) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process->GetRunLock())) { + frame = exe_ctx.GetFramePtr(); + if (frame) + sb_sym_ctx.SetSymbolContext(&frame->GetSymbolContext(scope)); + } + } + + return LLDB_RECORD_RESULT(sb_sym_ctx); +} + +SBModule SBFrame::GetModule() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBModule, SBFrame, GetModule); + + SBModule sb_module; + ModuleSP module_sp; + 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(); + if (target && process) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process->GetRunLock())) { + frame = exe_ctx.GetFramePtr(); + if (frame) { + module_sp = frame->GetSymbolContext(eSymbolContextModule).module_sp; + sb_module.SetSP(module_sp); + } + } + } + + return LLDB_RECORD_RESULT(sb_module); +} + +SBCompileUnit SBFrame::GetCompileUnit() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBCompileUnit, SBFrame, + GetCompileUnit); + + SBCompileUnit sb_comp_unit; + 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(); + if (target && process) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process->GetRunLock())) { + frame = exe_ctx.GetFramePtr(); + if (frame) { + sb_comp_unit.reset( + frame->GetSymbolContext(eSymbolContextCompUnit).comp_unit); + } + } + } + + return LLDB_RECORD_RESULT(sb_comp_unit); +} + +SBFunction SBFrame::GetFunction() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFunction, SBFrame, GetFunction); + + SBFunction sb_function; + 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(); + if (target && process) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process->GetRunLock())) { + frame = exe_ctx.GetFramePtr(); + if (frame) { + sb_function.reset( + frame->GetSymbolContext(eSymbolContextFunction).function); + } + } + } + + return LLDB_RECORD_RESULT(sb_function); +} + +SBSymbol SBFrame::GetSymbol() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBSymbol, SBFrame, GetSymbol); + + SBSymbol sb_symbol; + 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(); + if (target && process) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process->GetRunLock())) { + frame = exe_ctx.GetFramePtr(); + if (frame) { + sb_symbol.reset(frame->GetSymbolContext(eSymbolContextSymbol).symbol); + } + } + } + + return LLDB_RECORD_RESULT(sb_symbol); +} + +SBBlock SBFrame::GetBlock() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBlock, SBFrame, GetBlock); + + SBBlock sb_block; + 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(); + if (target && process) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process->GetRunLock())) { + frame = exe_ctx.GetFramePtr(); + if (frame) + sb_block.SetPtr(frame->GetSymbolContext(eSymbolContextBlock).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); + + StackFrame *frame = nullptr; + Target *target = exe_ctx.GetTargetPtr(); + Process *process = exe_ctx.GetProcessPtr(); + if (target && process) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process->GetRunLock())) { + frame = exe_ctx.GetFramePtr(); + if (frame) + sb_block.SetPtr(frame->GetFrameBlock()); + } + } + return LLDB_RECORD_RESULT(sb_block); +} + +SBLineEntry SBFrame::GetLineEntry() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBLineEntry, SBFrame, GetLineEntry); + + SBLineEntry sb_line_entry; + 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(); + if (target && process) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process->GetRunLock())) { + frame = exe_ctx.GetFramePtr(); + if (frame) { + sb_line_entry.SetLineEntry( + frame->GetSymbolContext(eSymbolContextLineEntry).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; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + StackFrame *frame = exe_ctx.GetFramePtr(); + if (frame) + frame_idx = frame->GetFrameIndex(); + + return frame_idx; +} + +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); + + StackFrame *frame = exe_ctx.GetFramePtr(); + if (frame) + return frame->GetStackID().GetCallFrameAddress(); + return LLDB_INVALID_ADDRESS; +} + +addr_t SBFrame::GetPC() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetPC); + + addr_t addr = LLDB_INVALID_ADDRESS; + 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(); + if (target && process) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process->GetRunLock())) { + frame = exe_ctx.GetFramePtr(); + if (frame) { + addr = frame->GetFrameCodeAddress().GetOpcodeLoadAddress( + target, AddressClass::eCode); + } + } + } + + return addr; +} + +bool SBFrame::SetPC(addr_t new_pc) { + LLDB_RECORD_METHOD(bool, SBFrame, SetPC, (lldb::addr_t), new_pc); + + bool ret_val = false; + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + Target *target = exe_ctx.GetTargetPtr(); + Process *process = exe_ctx.GetProcessPtr(); + if (target && process) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process->GetRunLock())) { + if (StackFrame *frame = exe_ctx.GetFramePtr()) { + if (RegisterContextSP reg_ctx_sp = frame->GetRegisterContext()) { + ret_val = reg_ctx_sp->SetPC(new_pc); + } + } + } + } + + return ret_val; +} + +addr_t SBFrame::GetSP() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetSP); + + addr_t addr = LLDB_INVALID_ADDRESS; + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + Target *target = exe_ctx.GetTargetPtr(); + Process *process = exe_ctx.GetProcessPtr(); + if (target && process) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process->GetRunLock())) { + if (StackFrame *frame = exe_ctx.GetFramePtr()) { + if (RegisterContextSP reg_ctx_sp = frame->GetRegisterContext()) { + addr = reg_ctx_sp->GetSP(); + } + } + } + } + + return addr; +} + +addr_t SBFrame::GetFP() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetFP); + + addr_t addr = LLDB_INVALID_ADDRESS; + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + Target *target = exe_ctx.GetTargetPtr(); + Process *process = exe_ctx.GetProcessPtr(); + if (target && process) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process->GetRunLock())) { + if (StackFrame *frame = exe_ctx.GetFramePtr()) { + if (RegisterContextSP reg_ctx_sp = frame->GetRegisterContext()) { + addr = reg_ctx_sp->GetFP(); + } + } + } + } + + return addr; +} + +SBAddress SBFrame::GetPCAddress() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBFrame, GetPCAddress); + + SBAddress sb_addr; + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + StackFrame *frame = exe_ctx.GetFramePtr(); + Target *target = exe_ctx.GetTargetPtr(); + Process *process = exe_ctx.GetProcessPtr(); + if (target && process) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process->GetRunLock())) { + frame = exe_ctx.GetFramePtr(); + if (frame) + sb_addr.SetAddress(&frame->GetFrameCodeAddress()); + } + } + return LLDB_RECORD_RESULT(sb_addr); +} + +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); + + StackFrame *frame = exe_ctx.GetFramePtr(); + Target *target = exe_ctx.GetTargetPtr(); + if (frame && target) { + lldb::DynamicValueType use_dynamic = + frame->CalculateTarget()->GetPreferDynamicValue(); + sb_value = GetValueForVariablePath(var_path, use_dynamic); + } + 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; + if (var_path == nullptr || var_path[0] == '\0') { + return LLDB_RECORD_RESULT(sb_value); + } + + 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(); + if (target && process) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process->GetRunLock())) { + frame = exe_ctx.GetFramePtr(); + if (frame) { + VariableSP var_sp; + Status error; + ValueObjectSP value_sp(frame->GetValueForVariableExpressionPath( + var_path, eNoDynamicValues, + StackFrame::eExpressionPathOptionCheckPtrVsMember | + StackFrame::eExpressionPathOptionsAllowDirectIVarAccess, + var_sp, error)); + sb_value.SetSP(value_sp, use_dynamic); + } + } + } + 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); + + StackFrame *frame = exe_ctx.GetFramePtr(); + Target *target = exe_ctx.GetTargetPtr(); + if (frame && target) { + lldb::DynamicValueType use_dynamic = + frame->CalculateTarget()->GetPreferDynamicValue(); + value = FindVariable(name, use_dynamic); + } + 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); + + VariableSP var_sp; + SBValue sb_value; + + if (name == nullptr || name[0] == '\0') { + return LLDB_RECORD_RESULT(sb_value); + } + + ValueObjectSP value_sp; + 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(); + if (target && process) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process->GetRunLock())) { + frame = exe_ctx.GetFramePtr(); + if (frame) { + value_sp = frame->FindVariable(ConstString(name)); + + if (value_sp) + sb_value.SetSP(value_sp, use_dynamic); + } + } + } + + 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); + + StackFrame *frame = exe_ctx.GetFramePtr(); + Target *target = exe_ctx.GetTargetPtr(); + if (frame && target) { + lldb::DynamicValueType use_dynamic = + frame->CalculateTarget()->GetPreferDynamicValue(); + value = FindValue(name, value_type, use_dynamic); + } + 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); + + SBValue sb_value; + + if (name == nullptr || name[0] == '\0') { + return LLDB_RECORD_RESULT(sb_value); + } + + ValueObjectSP value_sp; + 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(); + if (target && process) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process->GetRunLock())) { + frame = exe_ctx.GetFramePtr(); + if (frame) { + VariableList variable_list; + + switch (value_type) { + case eValueTypeVariableGlobal: // global variable + case eValueTypeVariableStatic: // static variable + case eValueTypeVariableArgument: // function argument variables + case eValueTypeVariableLocal: // function local variables + case eValueTypeVariableThreadLocal: // thread local variables + { + SymbolContext sc(frame->GetSymbolContext(eSymbolContextBlock)); + + const bool can_create = true; + const bool get_parent_variables = true; + const bool stop_if_block_is_inlined_function = true; + + if (sc.block) + sc.block->AppendVariables( + can_create, get_parent_variables, + stop_if_block_is_inlined_function, + [frame](Variable *v) { return v->IsInScope(frame); }, + &variable_list); + if (value_type == eValueTypeVariableGlobal) { + const bool get_file_globals = true; + VariableList *frame_vars = frame->GetVariableList(get_file_globals); + if (frame_vars) + frame_vars->AppendVariablesIfUnique(variable_list); + } + ConstString const_name(name); + VariableSP variable_sp( + variable_list.FindVariable(const_name, value_type)); + if (variable_sp) { + value_sp = frame->GetValueObjectForFrameVariable(variable_sp, + eNoDynamicValues); + sb_value.SetSP(value_sp, use_dynamic); + } + } break; + + case eValueTypeRegister: // stack frame register value + { + RegisterContextSP reg_ctx(frame->GetRegisterContext()); + if (reg_ctx) { + const uint32_t num_regs = reg_ctx->GetRegisterCount(); + for (uint32_t reg_idx = 0; reg_idx < num_regs; ++reg_idx) { + const RegisterInfo *reg_info = + reg_ctx->GetRegisterInfoAtIndex(reg_idx); + if (reg_info && + ((reg_info->name && strcasecmp(reg_info->name, name) == 0) || + (reg_info->alt_name && + strcasecmp(reg_info->alt_name, name) == 0))) { + value_sp = ValueObjectRegister::Create(frame, reg_ctx, reg_idx); + sb_value.SetSP(value_sp); + break; + } + } + } + } break; + + case eValueTypeRegisterSet: // A collection of stack frame register + // values + { + RegisterContextSP reg_ctx(frame->GetRegisterContext()); + if (reg_ctx) { + const uint32_t num_sets = reg_ctx->GetRegisterSetCount(); + for (uint32_t set_idx = 0; set_idx < num_sets; ++set_idx) { + const RegisterSet *reg_set = reg_ctx->GetRegisterSet(set_idx); + if (reg_set && + ((reg_set->name && strcasecmp(reg_set->name, name) == 0) || + (reg_set->short_name && + strcasecmp(reg_set->short_name, name) == 0))) { + value_sp = + ValueObjectRegisterSet::Create(frame, reg_ctx, set_idx); + sb_value.SetSP(value_sp); + break; + } + } + } + } break; + + case eValueTypeConstResult: // constant result variables + { + ConstString const_name(name); + ExpressionVariableSP expr_var_sp( + target->GetPersistentVariable(const_name)); + if (expr_var_sp) { + value_sp = expr_var_sp->GetValueObject(); + sb_value.SetSP(value_sp, use_dynamic); + } + } break; + + default: + break; + } + } + } + } + + 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 { + LLDB_RECORD_METHOD_CONST(bool, SBFrame, operator==,(const lldb::SBFrame &), + rhs); + + return IsEqual(rhs); +} + +bool SBFrame::operator!=(const SBFrame &rhs) const { + LLDB_RECORD_METHOD_CONST(bool, SBFrame, operator!=,(const lldb::SBFrame &), + rhs); + + return !IsEqual(rhs); +} + +SBThread SBFrame::GetThread() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBFrame, GetThread); + + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + ThreadSP thread_sp(exe_ctx.GetThreadSP()); + SBThread sb_thread(thread_sp); + + return LLDB_RECORD_RESULT(sb_thread); +} + +const char *SBFrame::Disassemble() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFrame, Disassemble); + + const char *disassembly = nullptr; + 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(); + if (target && process) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process->GetRunLock())) { + frame = exe_ctx.GetFramePtr(); + if (frame) { + disassembly = frame->Disassemble(); + } + } + } + + return disassembly; +} + +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); + + StackFrame *frame = exe_ctx.GetFramePtr(); + Target *target = exe_ctx.GetTargetPtr(); + if (frame && target) { + lldb::DynamicValueType use_dynamic = + frame->CalculateTarget()->GetPreferDynamicValue(); + const bool include_runtime_support_values = + target ? target->GetDisplayRuntimeSupportValues() : false; + + SBVariablesOptions options; + options.SetIncludeArguments(arguments); + options.SetIncludeLocals(locals); + options.SetIncludeStatics(statics); + options.SetInScopeOnly(in_scope_only); + options.SetIncludeRuntimeSupportValues(include_runtime_support_values); + options.SetUseDynamic(use_dynamic); + + value_list = GetVariables(options); + } + 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); + + Target *target = exe_ctx.GetTargetPtr(); + const bool include_runtime_support_values = + target ? target->GetDisplayRuntimeSupportValues() : false; + SBVariablesOptions options; + options.SetIncludeArguments(arguments); + options.SetIncludeLocals(locals); + options.SetIncludeStatics(statics); + options.SetInScopeOnly(in_scope_only); + options.SetIncludeRuntimeSupportValues(include_runtime_support_values); + options.SetUseDynamic(use_dynamic); + return LLDB_RECORD_RESULT(GetVariables(options)); +} + +SBValueList SBFrame::GetVariables(const lldb::SBVariablesOptions &options) { + LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables, + (const lldb::SBVariablesOptions &), options); + + SBValueList value_list; + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + StackFrame *frame = nullptr; + Target *target = exe_ctx.GetTargetPtr(); + + const bool statics = options.GetIncludeStatics(); + const bool arguments = options.GetIncludeArguments(); + const bool recognized_arguments = + options.GetIncludeRecognizedArguments(SBTarget(exe_ctx.GetTargetSP())); + const bool locals = options.GetIncludeLocals(); + const bool in_scope_only = options.GetInScopeOnly(); + const bool include_runtime_support_values = + options.GetIncludeRuntimeSupportValues(); + const lldb::DynamicValueType use_dynamic = options.GetUseDynamic(); + + + std::set<VariableSP> variable_set; + Process *process = exe_ctx.GetProcessPtr(); + if (target && process) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process->GetRunLock())) { + frame = exe_ctx.GetFramePtr(); + if (frame) { + VariableList *variable_list = nullptr; + variable_list = frame->GetVariableList(true); + if (variable_list) { + const size_t num_variables = variable_list->GetSize(); + if (num_variables) { + for (const VariableSP &variable_sp : *variable_list) { + if (variable_sp) { + bool add_variable = false; + switch (variable_sp->GetScope()) { + case eValueTypeVariableGlobal: + case eValueTypeVariableStatic: + case eValueTypeVariableThreadLocal: + add_variable = statics; + break; + + case eValueTypeVariableArgument: + add_variable = arguments; + break; + + case eValueTypeVariableLocal: + add_variable = locals; + break; + + default: + break; + } + if (add_variable) { + // Only add variables once so we don't end up with duplicates + if (variable_set.find(variable_sp) == variable_set.end()) + variable_set.insert(variable_sp); + else + continue; + + if (in_scope_only && !variable_sp->IsInScope(frame)) + continue; + + ValueObjectSP valobj_sp(frame->GetValueObjectForFrameVariable( + variable_sp, eNoDynamicValues)); + + if (!include_runtime_support_values && valobj_sp != nullptr && + valobj_sp->IsRuntimeSupportValue()) + continue; + + SBValue value_sb; + value_sb.SetSP(valobj_sp, use_dynamic); + value_list.Append(value_sb); + } + } + } + } + } + if (recognized_arguments) { + auto recognized_frame = frame->GetRecognizedFrame(); + if (recognized_frame) { + ValueObjectListSP recognized_arg_list = + recognized_frame->GetRecognizedArguments(); + if (recognized_arg_list) { + for (auto &rec_value_sp : recognized_arg_list->GetObjects()) { + SBValue value_sb; + value_sb.SetSP(rec_value_sp, use_dynamic); + value_list.Append(value_sb); + } + } + } + } + } + } + } + + return LLDB_RECORD_RESULT(value_list); +} + +SBValueList SBFrame::GetRegisters() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValueList, SBFrame, GetRegisters); + + SBValueList value_list; + 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(); + if (target && process) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process->GetRunLock())) { + frame = exe_ctx.GetFramePtr(); + if (frame) { + RegisterContextSP reg_ctx(frame->GetRegisterContext()); + if (reg_ctx) { + const uint32_t num_sets = reg_ctx->GetRegisterSetCount(); + for (uint32_t set_idx = 0; set_idx < num_sets; ++set_idx) { + value_list.Append( + ValueObjectRegisterSet::Create(frame, reg_ctx, set_idx)); + } + } + } + } + } + + return LLDB_RECORD_RESULT(value_list); +} + +SBValue SBFrame::FindRegister(const char *name) { + LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindRegister, (const char *), + name); + + SBValue result; + ValueObjectSP value_sp; + 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(); + if (target && process) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process->GetRunLock())) { + frame = exe_ctx.GetFramePtr(); + if (frame) { + RegisterContextSP reg_ctx(frame->GetRegisterContext()); + if (reg_ctx) { + const uint32_t num_regs = reg_ctx->GetRegisterCount(); + for (uint32_t reg_idx = 0; reg_idx < num_regs; ++reg_idx) { + const RegisterInfo *reg_info = + reg_ctx->GetRegisterInfoAtIndex(reg_idx); + if (reg_info && + ((reg_info->name && strcasecmp(reg_info->name, name) == 0) || + (reg_info->alt_name && + strcasecmp(reg_info->alt_name, name) == 0))) { + value_sp = ValueObjectRegister::Create(frame, reg_ctx, reg_idx); + result.SetSP(value_sp); + break; + } + } + } + } + } + } + + return LLDB_RECORD_RESULT(result); +} + +bool SBFrame::GetDescription(SBStream &description) { + LLDB_RECORD_METHOD(bool, SBFrame, GetDescription, (lldb::SBStream &), + description); + + Stream &strm = description.ref(); + + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + StackFrame *frame; + Target *target = exe_ctx.GetTargetPtr(); + Process *process = exe_ctx.GetProcessPtr(); + if (target && process) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process->GetRunLock())) { + frame = exe_ctx.GetFramePtr(); + if (frame) { + frame->DumpUsingSettingsFormat(&strm); + } + } + + } else + strm.PutCString("No value"); + + return true; +} + +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); + + StackFrame *frame = exe_ctx.GetFramePtr(); + Target *target = exe_ctx.GetTargetPtr(); + if (frame && target) { + SBExpressionOptions options; + lldb::DynamicValueType fetch_dynamic_value = + frame->CalculateTarget()->GetPreferDynamicValue(); + options.SetFetchDynamicValue(fetch_dynamic_value); + options.SetUnwindOnError(true); + options.SetIgnoreBreakpoints(true); + if (target->GetLanguage() != eLanguageTypeUnknown) + options.SetLanguage(target->GetLanguage()); + else + options.SetLanguage(frame->GetLanguage()); + return LLDB_RECORD_RESULT(EvaluateExpression(expr, options)); + } + return LLDB_RECORD_RESULT(result); +} + +SBValue +SBFrame::EvaluateExpression(const char *expr, + lldb::DynamicValueType fetch_dynamic_value) { + LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression, + (const char *, lldb::DynamicValueType), expr, + fetch_dynamic_value); + + SBExpressionOptions options; + options.SetFetchDynamicValue(fetch_dynamic_value); + options.SetUnwindOnError(true); + options.SetIgnoreBreakpoints(true); + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + StackFrame *frame = exe_ctx.GetFramePtr(); + Target *target = exe_ctx.GetTargetPtr(); + if (target && target->GetLanguage() != eLanguageTypeUnknown) + options.SetLanguage(target->GetLanguage()); + else if (frame) + options.SetLanguage(frame->GetLanguage()); + return LLDB_RECORD_RESULT(EvaluateExpression(expr, options)); +} + +SBValue SBFrame::EvaluateExpression(const char *expr, + lldb::DynamicValueType fetch_dynamic_value, + bool unwind_on_error) { + LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression, + (const char *, lldb::DynamicValueType, bool), expr, + fetch_dynamic_value, unwind_on_error); + + SBExpressionOptions options; + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + options.SetFetchDynamicValue(fetch_dynamic_value); + options.SetUnwindOnError(unwind_on_error); + options.SetIgnoreBreakpoints(true); + StackFrame *frame = exe_ctx.GetFramePtr(); + Target *target = exe_ctx.GetTargetPtr(); + if (target && target->GetLanguage() != eLanguageTypeUnknown) + options.SetLanguage(target->GetLanguage()); + else if (frame) + options.SetLanguage(frame->GetLanguage()); + 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 *expr_log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); + + SBValue expr_result; + + if (expr == nullptr || expr[0] == '\0') { + return LLDB_RECORD_RESULT(expr_result); + } + + ValueObjectSP expr_value_sp; + + 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(); + + if (target && process) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process->GetRunLock())) { + frame = exe_ctx.GetFramePtr(); + if (frame) { + std::unique_ptr<llvm::PrettyStackTraceFormat> stack_trace; + if (target->GetDisplayExpressionsInCrashlogs()) { + StreamString frame_description; + frame->DumpUsingSettingsFormat(&frame_description); + stack_trace = std::make_unique<llvm::PrettyStackTraceFormat>( + "SBFrame::EvaluateExpression (expr = \"%s\", fetch_dynamic_value " + "= %u) %s", + expr, options.GetFetchDynamicValue(), + frame_description.GetData()); + } + + target->EvaluateExpression(expr, frame, expr_value_sp, options.ref()); + expr_result.SetSP(expr_value_sp, options.GetFetchDynamicValue()); + } + } + } + + LLDB_LOGF(expr_log, + "** [SBFrame::EvaluateExpression] Expression result is " + "%s, summary %s **", + expr_result.GetValue(), expr_result.GetSummary()); + + 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); + + 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(); + if (target && process) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process->GetRunLock())) { + frame = exe_ctx.GetFramePtr(); + if (frame) { + + Block *block = frame->GetSymbolContext(eSymbolContextBlock).block; + if (block) + return block->GetContainingInlinedBlock() != nullptr; + } + } + } + return false; +} + +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); + + StackFrame *frame = exe_ctx.GetFramePtr(); + if (frame) + return frame->IsArtificial(); + + return false; +} + +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(); + if (target && process) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process->GetRunLock())) { + frame = exe_ctx.GetFramePtr(); + if (frame) { + return frame->GuessLanguage(); + } + } + } + return eLanguageTypeUnknown; +} + +const char *SBFrame::GetFunctionName() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFrame, GetFunctionName); + + const char *name = nullptr; + 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(); + if (target && process) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process->GetRunLock())) { + frame = exe_ctx.GetFramePtr(); + if (frame) { + SymbolContext sc(frame->GetSymbolContext(eSymbolContextFunction | + eSymbolContextBlock | + eSymbolContextSymbol)); + if (sc.block) { + Block *inlined_block = sc.block->GetContainingInlinedBlock(); + if (inlined_block) { + const InlineFunctionInfo *inlined_info = + inlined_block->GetInlinedFunctionInfo(); + name = inlined_info->GetName().AsCString(); + } + } + + if (name == nullptr) { + if (sc.function) + name = sc.function->GetName().GetCString(); + } + + if (name == nullptr) { + if (sc.symbol) + name = sc.symbol->GetName().GetCString(); + } + } + } + } + return name; +} + +const char *SBFrame::GetDisplayFunctionName() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBFrame, GetDisplayFunctionName); + + const char *name = nullptr; + + 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(); + if (target && process) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process->GetRunLock())) { + frame = exe_ctx.GetFramePtr(); + if (frame) { + SymbolContext sc(frame->GetSymbolContext(eSymbolContextFunction | + eSymbolContextBlock | + eSymbolContextSymbol)); + if (sc.block) { + Block *inlined_block = sc.block->GetContainingInlinedBlock(); + if (inlined_block) { + const InlineFunctionInfo *inlined_info = + inlined_block->GetInlinedFunctionInfo(); + name = inlined_info->GetDisplayName().AsCString(); + } + } + + if (name == nullptr) { + if (sc.function) + name = sc.function->GetDisplayName().GetCString(); + } + + if (name == nullptr) { + if (sc.symbol) + name = sc.symbol->GetDisplayName().GetCString(); + } + } + } + } + return name; +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBFrame>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBFrame, ()); + LLDB_REGISTER_CONSTRUCTOR(SBFrame, (const lldb::StackFrameSP &)); + LLDB_REGISTER_CONSTRUCTOR(SBFrame, (const lldb::SBFrame &)); + LLDB_REGISTER_METHOD(const lldb::SBFrame &, + SBFrame, operator=,(const lldb::SBFrame &)); + LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBFrame, operator bool, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBSymbolContext, SBFrame, GetSymbolContext, + (uint32_t)); + LLDB_REGISTER_METHOD_CONST(lldb::SBModule, SBFrame, GetModule, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBCompileUnit, SBFrame, GetCompileUnit, + ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBFunction, SBFrame, GetFunction, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBSymbol, SBFrame, GetSymbol, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBBlock, SBFrame, GetBlock, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBBlock, SBFrame, GetFrameBlock, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBLineEntry, SBFrame, GetLineEntry, ()); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBFrame, GetFrameID, ()); + LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetCFA, ()); + LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetPC, ()); + LLDB_REGISTER_METHOD(bool, SBFrame, SetPC, (lldb::addr_t)); + LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetSP, ()); + LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetFP, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBFrame, GetPCAddress, ()); + LLDB_REGISTER_METHOD(void, SBFrame, Clear, ()); + LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath, + (const char *)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath, + (const char *, lldb::DynamicValueType)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindVariable, (const char *)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindVariable, + (const char *, lldb::DynamicValueType)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindValue, + (const char *, lldb::ValueType)); + LLDB_REGISTER_METHOD( + lldb::SBValue, SBFrame, FindValue, + (const char *, lldb::ValueType, lldb::DynamicValueType)); + LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsEqual, (const lldb::SBFrame &)); + LLDB_REGISTER_METHOD_CONST(bool, + SBFrame, operator==,(const lldb::SBFrame &)); + LLDB_REGISTER_METHOD_CONST(bool, + SBFrame, operator!=,(const lldb::SBFrame &)); + LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBFrame, GetThread, ()); + LLDB_REGISTER_METHOD_CONST(const char *, SBFrame, Disassemble, ()); + LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetVariables, + (bool, bool, bool, bool)); + LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetVariables, + (bool, bool, bool, bool, lldb::DynamicValueType)); + LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetVariables, + (const lldb::SBVariablesOptions &)); + LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetRegisters, ()); + LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindRegister, (const char *)); + LLDB_REGISTER_METHOD(bool, SBFrame, GetDescription, (lldb::SBStream &)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression, + (const char *)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression, + (const char *, lldb::DynamicValueType)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression, + (const char *, lldb::DynamicValueType, bool)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression, + (const char *, const lldb::SBExpressionOptions &)); + LLDB_REGISTER_METHOD(bool, SBFrame, IsInlined, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsInlined, ()); + LLDB_REGISTER_METHOD(bool, SBFrame, IsArtificial, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsArtificial, ()); + LLDB_REGISTER_METHOD(const char *, SBFrame, GetFunctionName, ()); + LLDB_REGISTER_METHOD_CONST(lldb::LanguageType, SBFrame, GuessLanguage, ()); + LLDB_REGISTER_METHOD_CONST(const char *, SBFrame, GetFunctionName, ()); + LLDB_REGISTER_METHOD(const char *, SBFrame, GetDisplayFunctionName, ()); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBFunction.cpp b/contrib/llvm-project/lldb/source/API/SBFunction.cpp new file mode 100644 index 000000000000..e49513bd0da5 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBFunction.cpp @@ -0,0 +1,275 @@ +//===-- SBFunction.cpp ----------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBFunction.h" +#include "SBReproducerPrivate.h" +#include "lldb/API/SBProcess.h" +#include "lldb/API/SBStream.h" +#include "lldb/Core/Disassembler.h" +#include "lldb/Core/Module.h" +#include "lldb/Symbol/CompileUnit.h" +#include "lldb/Symbol/Function.h" +#include "lldb/Symbol/Type.h" +#include "lldb/Symbol/VariableList.h" +#include "lldb/Target/ExecutionContext.h" +#include "lldb/Target/Target.h" + +using namespace lldb; +using namespace lldb_private; + +SBFunction::SBFunction() : m_opaque_ptr(nullptr) { + 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) { + 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 LLDB_RECORD_RESULT(*this); +} + +SBFunction::~SBFunction() { m_opaque_ptr = nullptr; } + +bool SBFunction::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFunction, IsValid); + return this->operator bool(); +} +SBFunction::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFunction, operator bool); + + return m_opaque_ptr != nullptr; +} + +const char *SBFunction::GetName() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFunction, GetName); + + const char *cstr = nullptr; + if (m_opaque_ptr) + cstr = m_opaque_ptr->GetName().AsCString(); + + return cstr; +} + +const char *SBFunction::GetDisplayName() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFunction, GetDisplayName); + + const char *cstr = nullptr; + if (m_opaque_ptr) + cstr = m_opaque_ptr->GetMangled().GetDisplayDemangledName().AsCString(); + + return cstr; +} + +const char *SBFunction::GetMangledName() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFunction, GetMangledName); + + const char *cstr = nullptr; + if (m_opaque_ptr) + cstr = m_opaque_ptr->GetMangled().GetMangledName().AsCString(); + return cstr; +} + +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()); + Type *func_type = m_opaque_ptr->GetType(); + if (func_type) + s.Printf(", type = %s", func_type->GetName().AsCString()); + return true; + } + s.Printf("No value"); + return false; +} + +SBInstructionList SBFunction::GetInstructions(SBTarget target) { + LLDB_RECORD_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions, + (lldb::SBTarget), target); + + return LLDB_RECORD_RESULT(GetInstructions(target, nullptr)); +} + +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) { + TargetSP target_sp(target.GetSP()); + std::unique_lock<std::recursive_mutex> lock; + ModuleSP module_sp( + m_opaque_ptr->GetAddressRange().GetBaseAddress().GetModule()); + if (target_sp && module_sp) { + lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex()); + const bool prefer_file_cache = false; + sb_instructions.SetDisassembler(Disassembler::DisassembleRange( + module_sp->GetArchitecture(), nullptr, flavor, *target_sp, + m_opaque_ptr->GetAddressRange(), prefer_file_cache)); + } + } + return LLDB_RECORD_RESULT(sb_instructions); +} + +lldb_private::Function *SBFunction::get() { return m_opaque_ptr; } + +void SBFunction::reset(lldb_private::Function *lldb_object_ptr) { + m_opaque_ptr = 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 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(); + if (byte_size > 0) { + addr.SetAddress(&m_opaque_ptr->GetAddressRange().GetBaseAddress()); + addr->Slide(byte_size); + } + } + 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); + if (variable_list_sp) { + VariableList arguments; + variable_list_sp->AppendVariablesWithScope(eValueTypeVariableArgument, + arguments, true); + lldb::VariableSP variable_sp = arguments.GetVariableAtIndex(arg_idx); + if (variable_sp) + return variable_sp->GetName().GetCString(); + } + } + return nullptr; +} + +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 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 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(); + } + return lldb::eLanguageTypeUnknown; +} + +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(); + } + return false; +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBFunction>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBFunction, ()); + LLDB_REGISTER_CONSTRUCTOR(SBFunction, (const lldb::SBFunction &)); + LLDB_REGISTER_METHOD(const lldb::SBFunction &, + SBFunction, operator=,(const lldb::SBFunction &)); + LLDB_REGISTER_METHOD_CONST(bool, SBFunction, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBFunction, operator bool, ()); + LLDB_REGISTER_METHOD_CONST(const char *, SBFunction, GetName, ()); + LLDB_REGISTER_METHOD_CONST(const char *, SBFunction, GetDisplayName, ()); + LLDB_REGISTER_METHOD_CONST(const char *, SBFunction, GetMangledName, ()); + LLDB_REGISTER_METHOD_CONST( + bool, SBFunction, operator==,(const lldb::SBFunction &)); + LLDB_REGISTER_METHOD_CONST( + bool, SBFunction, operator!=,(const lldb::SBFunction &)); + LLDB_REGISTER_METHOD(bool, SBFunction, GetDescription, (lldb::SBStream &)); + LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions, + (lldb::SBTarget)); + LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions, + (lldb::SBTarget, const char *)); + LLDB_REGISTER_METHOD(lldb::SBAddress, SBFunction, GetStartAddress, ()); + LLDB_REGISTER_METHOD(lldb::SBAddress, SBFunction, GetEndAddress, ()); + LLDB_REGISTER_METHOD(const char *, SBFunction, GetArgumentName, (uint32_t)); + LLDB_REGISTER_METHOD(uint32_t, SBFunction, GetPrologueByteSize, ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBFunction, GetType, ()); + LLDB_REGISTER_METHOD(lldb::SBBlock, SBFunction, GetBlock, ()); + LLDB_REGISTER_METHOD(lldb::LanguageType, SBFunction, GetLanguage, ()); + LLDB_REGISTER_METHOD(bool, SBFunction, GetIsOptimized, ()); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBHostOS.cpp b/contrib/llvm-project/lldb/source/API/SBHostOS.cpp new file mode 100644 index 000000000000..9d3d119e4c2a --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBHostOS.cpp @@ -0,0 +1,195 @@ +//===-- SBHostOS.cpp ------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBHostOS.h" +#include "SBReproducerPrivate.h" +#include "lldb/API/SBError.h" +#include "lldb/Host/Config.h" +#include "lldb/Host/FileSystem.h" +#include "lldb/Host/Host.h" +#include "lldb/Host/HostInfo.h" +#include "lldb/Host/HostNativeThread.h" +#include "lldb/Host/HostThread.h" +#include "lldb/Host/ThreadLauncher.h" +#include "lldb/Utility/FileSpec.h" + +#include "Plugins/ExpressionParser/Clang/ClangHost.h" +#if LLDB_ENABLE_PYTHON +#include "Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h" +#endif + +#include "llvm/ADT/SmallString.h" +#include "llvm/Support/Path.h" + +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 LLDB_RECORD_RESULT(sb_filespec); +} + +SBFileSpec SBHostOS::GetLLDBPythonPath() { + 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: + fspec = HostInfo::GetShlibDir(); + break; + case ePathTypeSupportExecutableDir: + fspec = HostInfo::GetSupportExeDir(); + break; + case ePathTypeHeaderDir: + fspec = HostInfo::GetHeaderDir(); + break; + case ePathTypePythonDir: +#if LLDB_ENABLE_PYTHON + fspec = ScriptInterpreterPython::GetPythonDir(); +#endif + break; + case ePathTypeLLDBSystemPlugins: + fspec = HostInfo::GetSystemPluginDir(); + break; + case ePathTypeLLDBUserPlugins: + fspec = HostInfo::GetUserPluginDir(); + break; + case ePathTypeLLDBTempSystemDir: + fspec = HostInfo::GetProcessTempDir(); + break; + case ePathTypeGlobalLLDBTempSystemDir: + fspec = HostInfo::GetGlobalTempDir(); + break; + case ePathTypeClangDir: + fspec = GetClangResourceDir(); + break; + } + + SBFileSpec sb_fspec; + sb_fspec.SetFileSpec(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; + llvm::sys::path::home_directory(home_dir_path); + FileSpec homedir(home_dir_path.c_str()); + FileSystem::Instance().Resolve(homedir); + + sb_fspec.SetFileSpec(homedir); + return LLDB_RECORD_RESULT(sb_fspec); +} + +lldb::thread_t SBHostOS::ThreadCreate(const char *name, + lldb::thread_func_t thread_function, + void *thread_arg, SBError *error_ptr) { + LLDB_RECORD_DUMMY(lldb::thread_t, SBHostOS, ThreadCreate, + (lldb::thread_func_t, void *, SBError *), name, + thread_function, thread_arg, error_ptr); + llvm::Expected<HostThread> thread = + ThreadLauncher::LaunchThread(name, thread_function, thread_arg); + if (!thread) { + if (error_ptr) + error_ptr->SetError(Status(thread.takeError())); + else + llvm::consumeError(thread.takeError()); + return LLDB_INVALID_HOST_THREAD; + } + + return thread->Release(); +} + +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_DUMMY(bool, SBHostOS, ThreadCancel, + (lldb::thread_t, lldb::SBError *), thread, + error_ptr); + + Status error; + HostThread host_thread(thread); + error = host_thread.Cancel(); + if (error_ptr) + error_ptr->SetError(error); + host_thread.Release(); + return error.Success(); +} + +bool SBHostOS::ThreadDetach(lldb::thread_t thread, SBError *error_ptr) { + LLDB_RECORD_DUMMY(bool, SBHostOS, ThreadDetach, + (lldb::thread_t, lldb::SBError *), thread, + error_ptr); + + Status error; +#if defined(_WIN32) + if (error_ptr) + error_ptr->SetErrorString("ThreadDetach is not supported on this platform"); +#else + HostThread host_thread(thread); + error = host_thread.GetNativeThread().Detach(); + if (error_ptr) + error_ptr->SetError(error); + host_thread.Release(); +#endif + return error.Success(); +} + +bool SBHostOS::ThreadJoin(lldb::thread_t thread, lldb::thread_result_t *result, + SBError *error_ptr) { + LLDB_RECORD_DUMMY( + 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); + if (error_ptr) + error_ptr->SetError(error); + host_thread.Release(); + return error.Success(); +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBHostOS>(Registry &R) { + LLDB_REGISTER_STATIC_METHOD(lldb::SBFileSpec, SBHostOS, GetProgramFileSpec, + ()); + LLDB_REGISTER_STATIC_METHOD(lldb::SBFileSpec, SBHostOS, GetLLDBPythonPath, + ()); + LLDB_REGISTER_STATIC_METHOD(lldb::SBFileSpec, SBHostOS, GetLLDBPath, + (lldb::PathType)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBFileSpec, SBHostOS, + GetUserHomeDirectory, ()); + LLDB_REGISTER_STATIC_METHOD(void, SBHostOS, ThreadCreated, (const char *)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBInstruction.cpp b/contrib/llvm-project/lldb/source/API/SBInstruction.cpp new file mode 100644 index 000000000000..207e81272e50 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBInstruction.cpp @@ -0,0 +1,383 @@ +//===-- SBInstruction.cpp -------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBInstruction.h" +#include "SBReproducerPrivate.h" + +#include "lldb/API/SBAddress.h" +#include "lldb/API/SBFrame.h" +#include "lldb/API/SBFile.h" + +#include "lldb/API/SBInstruction.h" +#include "lldb/API/SBStream.h" +#include "lldb/API/SBTarget.h" +#include "lldb/Core/Disassembler.h" +#include "lldb/Core/EmulateInstruction.h" +#include "lldb/Core/Module.h" +#include "lldb/Core/StreamFile.h" +#include "lldb/Host/HostInfo.h" +#include "lldb/Target/ExecutionContext.h" +#include "lldb/Target/StackFrame.h" +#include "lldb/Target/Target.h" +#include "lldb/Utility/ArchSpec.h" +#include "lldb/Utility/DataBufferHeap.h" +#include "lldb/Utility/DataExtractor.h" + +#include <memory> + +// We recently fixed a leak in one of the Instruction subclasses where the +// instruction will only hold a weak reference to the disassembler to avoid a +// cycle that was keeping both objects alive (leak) and we need the +// InstructionImpl class to make sure our public API behaves as users would +// expect. Calls in our public API allow clients to do things like: +// +// 1 lldb::SBInstruction inst; +// 2 inst = target.ReadInstructions(pc, 1).GetInstructionAtIndex(0) +// 3 if (inst.DoesBranch()) +// 4 ... +// +// There was a temporary lldb::DisassemblerSP object created in the +// SBInstructionList that was returned by lldb.target.ReadInstructions() that +// will go away after line 2 but the "inst" object should be able to still +// answer questions about itself. So we make sure that any SBInstruction +// objects that are given out have a strong reference to the disassembler and +// the instruction so that the object can live and successfully respond to all +// queries. +class InstructionImpl { +public: + InstructionImpl(const lldb::DisassemblerSP &disasm_sp, + const lldb::InstructionSP &inst_sp) + : m_disasm_sp(disasm_sp), m_inst_sp(inst_sp) {} + + lldb::InstructionSP GetSP() const { return m_inst_sp; } + + bool IsValid() const { return (bool)m_inst_sp; } + +protected: + lldb::DisassemblerSP m_disasm_sp; // Can be empty/invalid + lldb::InstructionSP m_inst_sp; +}; + +using namespace lldb; +using namespace lldb_private; + +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) { + 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 LLDB_RECORD_RESULT(*this); +} + +SBInstruction::~SBInstruction() = default; + +bool SBInstruction::IsValid() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, IsValid); + return this->operator bool(); +} +SBInstruction::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInstruction, operator bool); + + return m_opaque_sp && m_opaque_sp->IsValid(); +} + +SBAddress SBInstruction::GetAddress() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBInstruction, GetAddress); + + SBAddress sb_addr; + lldb::InstructionSP inst_sp(GetOpaque()); + if (inst_sp && inst_sp->GetAddress().IsValid()) + sb_addr.SetAddress(&inst_sp->GetAddress()); + 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; + TargetSP target_sp(target.GetSP()); + std::unique_lock<std::recursive_mutex> lock; + if (target_sp) { + lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex()); + + target_sp->CalculateExecutionContext(exe_ctx); + exe_ctx.SetProcessSP(target_sp->GetProcessSP()); + } + return inst_sp->GetMnemonic(&exe_ctx); + } + return nullptr; +} + +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; + TargetSP target_sp(target.GetSP()); + std::unique_lock<std::recursive_mutex> lock; + if (target_sp) { + lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex()); + + target_sp->CalculateExecutionContext(exe_ctx); + exe_ctx.SetProcessSP(target_sp->GetProcessSP()); + } + return inst_sp->GetOperands(&exe_ctx); + } + return nullptr; +} + +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; + TargetSP target_sp(target.GetSP()); + std::unique_lock<std::recursive_mutex> lock; + if (target_sp) { + lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex()); + + target_sp->CalculateExecutionContext(exe_ctx); + exe_ctx.SetProcessSP(target_sp->GetProcessSP()); + } + return inst_sp->GetComment(&exe_ctx); + } + return nullptr; +} + +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(); + return 0; +} + +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) { + DataExtractorSP data_extractor_sp(new DataExtractor()); + if (inst_sp->GetData(*data_extractor_sp)) { + sb_data.SetOpaque(data_extractor_sp); + } + } + 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(); + return false; +} + +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() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, CanSetBreakpoint); + + lldb::InstructionSP inst_sp(GetOpaque()); + if (inst_sp) + return inst_sp->CanSetBreakpoint(); + return false; +} + +lldb::InstructionSP SBInstruction::GetOpaque() { + if (m_opaque_sp) + return m_opaque_sp->GetSP(); + else + return lldb::InstructionSP(); +} + +void SBInstruction::SetOpaque(const lldb::DisassemblerSP &disasm_sp, + const lldb::InstructionSP &inst_sp) { + m_opaque_sp = std::make_shared<InstructionImpl>(disasm_sp, inst_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; + const Address &addr = inst_sp->GetAddress(); + ModuleSP module_sp(addr.GetModule()); + if (module_sp) + module_sp->ResolveSymbolContextForAddress(addr, eSymbolContextEverything, + sc); + // Use the "ref()" instead of the "get()" accessor in case the SBStream + // didn't have a stream already created, one will get created... + FormatEntity::Entry format; + FormatEntity::Parse("${addr}: ", format); + inst_sp->Dump(&s.ref(), 0, true, false, nullptr, &sc, nullptr, &format, 0); + return true; + } + return false; +} + +void SBInstruction::Print(FILE *outp) { + LLDB_RECORD_METHOD(void, SBInstruction, Print, (FILE *), outp); + FileSP out = std::make_shared<NativeFile>(outp, /*take_ownership=*/false); + Print(out); +} + +void SBInstruction::Print(SBFile out) { + LLDB_RECORD_METHOD(void, SBInstruction, Print, (SBFile), out); + Print(out.m_opaque_sp); +} + +void SBInstruction::Print(FileSP out_sp) { + LLDB_RECORD_METHOD(void, SBInstruction, Print, (FileSP), out_sp); + + if (!out_sp || !out_sp->IsValid()) + return; + + lldb::InstructionSP inst_sp(GetOpaque()); + if (inst_sp) { + SymbolContext sc; + const Address &addr = inst_sp->GetAddress(); + ModuleSP module_sp(addr.GetModule()); + if (module_sp) + module_sp->ResolveSymbolContextForAddress(addr, eSymbolContextEverything, + sc); + StreamFile out_stream(out_sp); + FormatEntity::Entry format; + FormatEntity::Parse("${addr}: ", format); + inst_sp->Dump(&out_stream, 0, true, false, nullptr, &sc, nullptr, &format, + 0); + } +} + +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()); + + if (frame_sp) { + lldb_private::ExecutionContext exe_ctx; + frame_sp->CalculateExecutionContext(exe_ctx); + lldb_private::Target *target = exe_ctx.GetTargetPtr(); + lldb_private::ArchSpec arch = target->GetArchitecture(); + + return inst_sp->Emulate( + arch, evaluate_options, (void *)frame_sp.get(), + &lldb_private::EmulateInstruction::ReadMemoryFrame, + &lldb_private::EmulateInstruction::WriteMemoryFrame, + &lldb_private::EmulateInstruction::ReadRegisterFrame, + &lldb_private::EmulateInstruction::WriteRegisterFrame); + } + } + return false; +} + +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)); + } + return false; +} + +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())); + + lldb::InstructionSP inst_sp(GetOpaque()); + if (inst_sp) + return inst_sp->TestEmulation(output_stream.get(), test_file); + return false; +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBInstruction>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBInstruction, ()); + LLDB_REGISTER_CONSTRUCTOR(SBInstruction, (const lldb::SBInstruction &)); + LLDB_REGISTER_METHOD( + const lldb::SBInstruction &, + SBInstruction, operator=,(const lldb::SBInstruction &)); + LLDB_REGISTER_METHOD(bool, SBInstruction, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBInstruction, operator bool, ()); + LLDB_REGISTER_METHOD(lldb::SBAddress, SBInstruction, GetAddress, ()); + LLDB_REGISTER_METHOD(const char *, SBInstruction, GetMnemonic, + (lldb::SBTarget)); + LLDB_REGISTER_METHOD(const char *, SBInstruction, GetOperands, + (lldb::SBTarget)); + LLDB_REGISTER_METHOD(const char *, SBInstruction, GetComment, + (lldb::SBTarget)); + LLDB_REGISTER_METHOD(size_t, SBInstruction, GetByteSize, ()); + LLDB_REGISTER_METHOD(lldb::SBData, SBInstruction, GetData, + (lldb::SBTarget)); + LLDB_REGISTER_METHOD(bool, SBInstruction, DoesBranch, ()); + LLDB_REGISTER_METHOD(bool, SBInstruction, HasDelaySlot, ()); + LLDB_REGISTER_METHOD(bool, SBInstruction, CanSetBreakpoint, ()); + LLDB_REGISTER_METHOD(bool, SBInstruction, GetDescription, + (lldb::SBStream &)); + LLDB_REGISTER_METHOD(void, SBInstruction, Print, (FILE *)); + LLDB_REGISTER_METHOD(void, SBInstruction, Print, (SBFile)); + LLDB_REGISTER_METHOD(void, SBInstruction, Print, (FileSP)); + LLDB_REGISTER_METHOD(bool, SBInstruction, EmulateWithFrame, + (lldb::SBFrame &, uint32_t)); + LLDB_REGISTER_METHOD(bool, SBInstruction, DumpEmulation, (const char *)); + LLDB_REGISTER_METHOD(bool, SBInstruction, TestEmulation, + (lldb::SBStream &, const char *)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBInstructionList.cpp b/contrib/llvm-project/lldb/source/API/SBInstructionList.cpp new file mode 100644 index 000000000000..a0c6fbe7e338 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBInstructionList.cpp @@ -0,0 +1,234 @@ +//===-- SBInstructionList.cpp ---------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBInstructionList.h" +#include "SBReproducerPrivate.h" +#include "lldb/API/SBAddress.h" +#include "lldb/API/SBInstruction.h" +#include "lldb/API/SBStream.h" +#include "lldb/API/SBFile.h" +#include "lldb/Core/Disassembler.h" +#include "lldb/Core/Module.h" +#include "lldb/Core/StreamFile.h" +#include "lldb/Symbol/SymbolContext.h" +#include "lldb/Utility/Stream.h" + +using namespace lldb; +using namespace lldb_private; + +SBInstructionList::SBInstructionList() : m_opaque_sp() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBInstructionList); +} + +SBInstructionList::SBInstructionList(const SBInstructionList &rhs) + : 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 LLDB_RECORD_RESULT(*this); +} + +SBInstructionList::~SBInstructionList() = default; + +bool SBInstructionList::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInstructionList, IsValid); + return this->operator bool(); +} +SBInstructionList::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInstructionList, operator bool); + + return m_opaque_sp.get() != nullptr; +} + +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 LLDB_RECORD_RESULT(inst); +} + +size_t SBInstructionList::GetInstructionsCount(const SBAddress &start, + const SBAddress &end, + bool canSetBreakpoint) { + LLDB_RECORD_METHOD(size_t, SBInstructionList, GetInstructionsCount, + (const lldb::SBAddress &, const lldb::SBAddress &, bool), + start, end, canSetBreakpoint); + + size_t num_instructions = GetSize(); + size_t i = 0; + SBAddress addr; + size_t lower_index = 0; + size_t upper_index = 0; + size_t instructions_to_skip = 0; + for (i = 0; i < num_instructions; ++i) { + addr = GetInstructionAtIndex(i).GetAddress(); + if (start == addr) + lower_index = i; + if (end == addr) + upper_index = i; + } + if (canSetBreakpoint) + for (i = lower_index; i <= upper_index; ++i) { + SBInstruction insn = GetInstructionAtIndex(i); + if (!insn.CanSetBreakpoint()) + ++instructions_to_skip; + } + return upper_index - lower_index - instructions_to_skip; +} + +void SBInstructionList::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBInstructionList, Clear); + + 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 == nullptr) + return; + StreamFile stream(out, false); + GetDescription(stream); +} + +void SBInstructionList::Print(SBFile out) { + LLDB_RECORD_METHOD(void, SBInstructionList, Print, (SBFile), out); + if (!out.IsValid()) + return; + StreamFile stream(out.m_opaque_sp); + GetDescription(stream); +} + +void SBInstructionList::Print(FileSP out_sp) { + LLDB_RECORD_METHOD(void, SBInstructionList, Print, (FileSP), out_sp); + if (!out_sp || !out_sp->IsValid()) + return; + StreamFile stream(out_sp); + GetDescription(stream); +} + +bool SBInstructionList::GetDescription(lldb::SBStream &stream) { + LLDB_RECORD_METHOD(bool, SBInstructionList, GetDescription, + (lldb::SBStream &), stream); + return GetDescription(stream.ref()); +} + +bool SBInstructionList::GetDescription(Stream &sref) { + + if (m_opaque_sp) { + size_t num_instructions = GetSize(); + if (num_instructions) { + // Call the ref() to make sure a stream is created if one deesn't exist + // already inside description... + const uint32_t max_opcode_byte_size = + m_opaque_sp->GetInstructionList().GetMaxOpcocdeByteSize(); + FormatEntity::Entry format; + FormatEntity::Parse("${addr}: ", format); + SymbolContext sc; + SymbolContext prev_sc; + for (size_t i = 0; i < num_instructions; ++i) { + Instruction *inst = + m_opaque_sp->GetInstructionList().GetInstructionAtIndex(i).get(); + if (inst == nullptr) + break; + + const Address &addr = inst->GetAddress(); + prev_sc = sc; + ModuleSP module_sp(addr.GetModule()); + if (module_sp) { + module_sp->ResolveSymbolContextForAddress( + addr, eSymbolContextEverything, sc); + } + + inst->Dump(&sref, max_opcode_byte_size, true, false, nullptr, &sc, + &prev_sc, &format, 0); + sref.EOL(); + } + return true; + } + } + return false; +} + +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) { + if (!GetInstructionAtIndex((uint32_t)i).DumpEmulation(triple)) + return false; + } + } + return true; +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBInstructionList>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBInstructionList, ()); + LLDB_REGISTER_CONSTRUCTOR(SBInstructionList, + (const lldb::SBInstructionList &)); + LLDB_REGISTER_METHOD( + const lldb::SBInstructionList &, + SBInstructionList, operator=,(const lldb::SBInstructionList &)); + LLDB_REGISTER_METHOD_CONST(bool, SBInstructionList, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBInstructionList, operator bool, ()); + LLDB_REGISTER_METHOD(size_t, SBInstructionList, GetSize, ()); + LLDB_REGISTER_METHOD(lldb::SBInstruction, SBInstructionList, + GetInstructionAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD( + size_t, SBInstructionList, GetInstructionsCount, + (const lldb::SBAddress &, const lldb::SBAddress &, bool)); + LLDB_REGISTER_METHOD(void, SBInstructionList, Clear, ()); + LLDB_REGISTER_METHOD(void, SBInstructionList, AppendInstruction, + (lldb::SBInstruction)); + LLDB_REGISTER_METHOD(void, SBInstructionList, Print, (FILE *)); + LLDB_REGISTER_METHOD(void, SBInstructionList, Print, (SBFile)); + LLDB_REGISTER_METHOD(void, SBInstructionList, Print, (FileSP)); + LLDB_REGISTER_METHOD(bool, SBInstructionList, GetDescription, + (lldb::SBStream &)); + LLDB_REGISTER_METHOD(bool, SBInstructionList, + DumpEmulationForAllInstructions, (const char *)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBLanguageRuntime.cpp b/contrib/llvm-project/lldb/source/API/SBLanguageRuntime.cpp new file mode 100644 index 000000000000..33c900d20c31 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBLanguageRuntime.cpp @@ -0,0 +1,46 @@ +//===-- SBLanguageRuntime.cpp ---------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBLanguageRuntime.h" +#include "SBReproducerPrivate.h" +#include "lldb/Target/Language.h" + +using namespace lldb; +using namespace lldb_private; + +lldb::LanguageType +SBLanguageRuntime::GetLanguageTypeFromString(const char *string) { + LLDB_RECORD_STATIC_METHOD(lldb::LanguageType, SBLanguageRuntime, + GetLanguageTypeFromString, (const char *), string); + + 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); +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBLanguageRuntime>(Registry &R) { + LLDB_REGISTER_STATIC_METHOD(lldb::LanguageType, SBLanguageRuntime, + GetLanguageTypeFromString, (const char *)); + LLDB_REGISTER_STATIC_METHOD(const char *, SBLanguageRuntime, + GetNameForLanguageType, (lldb::LanguageType)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBLaunchInfo.cpp b/contrib/llvm-project/lldb/source/API/SBLaunchInfo.cpp new file mode 100644 index 000000000000..ba13072e8f9b --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBLaunchInfo.cpp @@ -0,0 +1,411 @@ +//===-- SBLaunchInfo.cpp --------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBLaunchInfo.h" +#include "SBReproducerPrivate.h" + +#include "lldb/API/SBEnvironment.h" +#include "lldb/API/SBFileSpec.h" +#include "lldb/API/SBListener.h" +#include "lldb/Host/ProcessLaunchInfo.h" + +using namespace lldb; +using namespace lldb_private; + +class lldb_private::SBLaunchInfoImpl : public ProcessLaunchInfo { +public: + SBLaunchInfoImpl() + : ProcessLaunchInfo(), m_envp(GetEnvironment().getEnvp()) {} + + const char *const *GetEnvp() const { return m_envp; } + void RegenerateEnvp() { m_envp = GetEnvironment().getEnvp(); } + + SBLaunchInfoImpl &operator=(const ProcessLaunchInfo &rhs) { + ProcessLaunchInfo::operator=(rhs); + RegenerateEnvp(); + return *this; + } + +private: + Environment::Envp m_envp; +}; + +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); +} + +SBLaunchInfo::SBLaunchInfo(const SBLaunchInfo &rhs) { + LLDB_RECORD_CONSTRUCTOR(SBLaunchInfo, (const lldb::SBLaunchInfo &), rhs); + + m_opaque_sp = rhs.m_opaque_sp; +} + +SBLaunchInfo &SBLaunchInfo::operator=(const SBLaunchInfo &rhs) { + LLDB_RECORD_METHOD(SBLaunchInfo &, + SBLaunchInfo, operator=,(const lldb::SBLaunchInfo &), rhs); + + m_opaque_sp = rhs.m_opaque_sp; + return LLDB_RECORD_RESULT(*this); +} + +SBLaunchInfo::~SBLaunchInfo() = default; + +const lldb_private::ProcessLaunchInfo &SBLaunchInfo::ref() const { + return *m_opaque_sp; +} + +void SBLaunchInfo::set_ref(const ProcessLaunchInfo &info) { + *m_opaque_sp = info; +} + +lldb::pid_t SBLaunchInfo::GetProcessID() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBLaunchInfo, GetProcessID); + + return m_opaque_sp->GetProcessID(); +} + +uint32_t SBLaunchInfo::GetUserID() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetUserID); + + return m_opaque_sp->GetUserID(); +} + +uint32_t SBLaunchInfo::GetGroupID() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetGroupID); + + return m_opaque_sp->GetGroupID(); +} + +bool SBLaunchInfo::UserIDIsValid() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBLaunchInfo, UserIDIsValid); + + return m_opaque_sp->UserIDIsValid(); +} + +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() { + 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() { + 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); + } else { + if (argv) + m_opaque_sp->GetArguments().SetArguments(argv); + else + m_opaque_sp->GetArguments().Clear(); + } +} + +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); + SetEnvironment(SBEnvironment(Environment(envp)), append); +} + +void SBLaunchInfo::SetEnvironment(const SBEnvironment &env, bool append) { + LLDB_RECORD_METHOD(void, SBLaunchInfo, SetEnvironment, + (const lldb::SBEnvironment &, bool), env, append); + Environment &refEnv = env.ref(); + if (append) + m_opaque_sp->GetEnvironment().insert(refEnv.begin(), refEnv.end()); + else + m_opaque_sp->GetEnvironment() = refEnv; + m_opaque_sp->RegenerateEnvp(); +} + +SBEnvironment SBLaunchInfo::GetEnvironment() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBEnvironment, SBLaunchInfo, GetEnvironment); + return LLDB_RECORD_RESULT( + SBEnvironment(Environment(m_opaque_sp->GetEnvironment()))); +} + +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()); + return shell.AsCString(); +} + +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(); +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBLaunchInfo>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBLaunchInfo, (const char **)); + LLDB_REGISTER_CONSTRUCTOR(SBLaunchInfo, (const lldb::SBLaunchInfo &)); + LLDB_REGISTER_METHOD(SBLaunchInfo &, + SBLaunchInfo, operator=,(const lldb::SBLaunchInfo &)); + LLDB_REGISTER_METHOD(lldb::pid_t, SBLaunchInfo, GetProcessID, ()); + LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetUserID, ()); + LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetGroupID, ()); + LLDB_REGISTER_METHOD(bool, SBLaunchInfo, UserIDIsValid, ()); + LLDB_REGISTER_METHOD(bool, SBLaunchInfo, GroupIDIsValid, ()); + LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetUserID, (uint32_t)); + LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetGroupID, (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBLaunchInfo, GetExecutableFile, ()); + LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetExecutableFile, + (lldb::SBFileSpec, bool)); + LLDB_REGISTER_METHOD(lldb::SBListener, SBLaunchInfo, GetListener, ()); + LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetListener, (lldb::SBListener &)); + LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetNumArguments, ()); + LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetArgumentAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetArguments, + (const char **, bool)); + LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetNumEnvironmentEntries, ()); + LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetEnvironmentEntryAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetEnvironmentEntries, + (const char **, bool)); + LLDB_REGISTER_METHOD(void, SBLaunchInfo, Clear, ()); + LLDB_REGISTER_METHOD_CONST(const char *, SBLaunchInfo, GetWorkingDirectory, + ()); + LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetWorkingDirectory, + (const char *)); + LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetLaunchFlags, ()); + LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetLaunchFlags, (uint32_t)); + LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetProcessPluginName, ()); + LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetProcessPluginName, + (const char *)); + LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetShell, ()); + LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetShell, (const char *)); + LLDB_REGISTER_METHOD(bool, SBLaunchInfo, GetShellExpandArguments, ()); + LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetShellExpandArguments, (bool)); + LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetResumeCount, ()); + LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetResumeCount, (uint32_t)); + LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddCloseFileAction, (int)); + LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddDuplicateFileAction, + (int, int)); + LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddOpenFileAction, + (int, const char *, bool, bool)); + LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddSuppressFileAction, + (int, bool, bool)); + LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetLaunchEventData, + (const char *)); + LLDB_REGISTER_METHOD_CONST(const char *, SBLaunchInfo, GetLaunchEventData, + ()); + LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetDetachOnError, (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBLaunchInfo, GetDetachOnError, ()); + LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetEnvironment, + (const lldb::SBEnvironment &, bool)); + LLDB_REGISTER_METHOD(lldb::SBEnvironment, SBLaunchInfo, GetEnvironment, ()); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBLineEntry.cpp b/contrib/llvm-project/lldb/source/API/SBLineEntry.cpp new file mode 100644 index 000000000000..cefbe3ee1a1e --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBLineEntry.cpp @@ -0,0 +1,220 @@ +//===-- SBLineEntry.cpp ---------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBLineEntry.h" +#include "SBReproducerPrivate.h" +#include "Utils.h" +#include "lldb/API/SBStream.h" +#include "lldb/Host/PosixApi.h" +#include "lldb/Symbol/LineEntry.h" +#include "lldb/Utility/StreamString.h" + +#include <limits.h> + +using namespace lldb; +using namespace lldb_private; + +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); +} + +SBLineEntry::SBLineEntry(const lldb_private::LineEntry *lldb_object_ptr) + : m_opaque_up() { + if (lldb_object_ptr) + m_opaque_up = std::make_unique<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 LLDB_RECORD_RESULT(*this); +} + +void SBLineEntry::SetLineEntry(const lldb_private::LineEntry &lldb_object_ref) { + m_opaque_up = std::make_unique<LineEntry>(lldb_object_ref); +} + +SBLineEntry::~SBLineEntry() = default; + +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()); + + 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()); + sb_address.OffsetAddress(m_opaque_up->range.GetByteSize()); + } + return LLDB_RECORD_RESULT(sb_address); +} + +bool SBLineEntry::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBLineEntry, IsValid); + return this->operator bool(); +} +SBLineEntry::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBLineEntry, operator bool); + + return m_opaque_up.get() && m_opaque_up->IsValid(); +} + +SBFileSpec SBLineEntry::GetFileSpec() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBLineEntry, GetFileSpec); + + SBFileSpec sb_file_spec; + if (m_opaque_up.get() && m_opaque_up->file) + sb_file_spec.SetFileSpec(m_opaque_up->file); + + return LLDB_RECORD_RESULT(sb_file_spec); +} + +uint32_t SBLineEntry::GetLine() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBLineEntry, GetLine); + + uint32_t line = 0; + if (m_opaque_up) + line = m_opaque_up->line; + + return line; +} + +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) { + LLDB_RECORD_METHOD(void, SBLineEntry, SetLine, (uint32_t), line); + + ref().line = line; +} + +void SBLineEntry::SetColumn(uint32_t column) { + LLDB_RECORD_METHOD(void, SBLineEntry, SetColumn, (uint32_t), column); + + 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(); + + if (lhs_ptr && rhs_ptr) + return lldb_private::LineEntry::Compare(*lhs_ptr, *rhs_ptr) == 0; + + return lhs_ptr == rhs_ptr; +} + +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(); + + if (lhs_ptr && rhs_ptr) + return lldb_private::LineEntry::Compare(*lhs_ptr, *rhs_ptr) != 0; + + return lhs_ptr != rhs_ptr; +} + +const lldb_private::LineEntry *SBLineEntry::operator->() const { + return m_opaque_up.get(); +} + +lldb_private::LineEntry &SBLineEntry::ref() { + if (m_opaque_up == nullptr) + m_opaque_up = std::make_unique<lldb_private::LineEntry>(); + return *m_opaque_up; +} + +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) { + char file_path[PATH_MAX * 2]; + m_opaque_up->file.GetPath(file_path, sizeof(file_path)); + strm.Printf("%s:%u", file_path, GetLine()); + if (GetColumn() > 0) + strm.Printf(":%u", GetColumn()); + } else + strm.PutCString("No value"); + + return true; +} + +lldb_private::LineEntry *SBLineEntry::get() { return m_opaque_up.get(); } + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBLineEntry>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBLineEntry, ()); + LLDB_REGISTER_CONSTRUCTOR(SBLineEntry, (const lldb::SBLineEntry &)); + LLDB_REGISTER_METHOD(const lldb::SBLineEntry &, + SBLineEntry, operator=,(const lldb::SBLineEntry &)); + LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBLineEntry, GetStartAddress, + ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBLineEntry, GetEndAddress, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBLineEntry, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBLineEntry, operator bool, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBLineEntry, GetFileSpec, ()); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBLineEntry, GetLine, ()); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBLineEntry, GetColumn, ()); + LLDB_REGISTER_METHOD(void, SBLineEntry, SetFileSpec, (lldb::SBFileSpec)); + LLDB_REGISTER_METHOD(void, SBLineEntry, SetLine, (uint32_t)); + LLDB_REGISTER_METHOD(void, SBLineEntry, SetColumn, (uint32_t)); + LLDB_REGISTER_METHOD_CONST( + bool, SBLineEntry, operator==,(const lldb::SBLineEntry &)); + LLDB_REGISTER_METHOD_CONST( + bool, SBLineEntry, operator!=,(const lldb::SBLineEntry &)); + LLDB_REGISTER_METHOD(bool, SBLineEntry, GetDescription, (lldb::SBStream &)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBListener.cpp b/contrib/llvm-project/lldb/source/API/SBListener.cpp new file mode 100644 index 000000000000..f3463268b3b5 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBListener.cpp @@ -0,0 +1,373 @@ +//===-- SBListener.cpp ----------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBListener.h" +#include "SBReproducerPrivate.h" +#include "lldb/API/SBBroadcaster.h" +#include "lldb/API/SBDebugger.h" +#include "lldb/API/SBEvent.h" +#include "lldb/API/SBStream.h" +#include "lldb/Core/Debugger.h" +#include "lldb/Utility/Broadcaster.h" +#include "lldb/Utility/Listener.h" +#include "lldb/Utility/StreamString.h" + +using namespace lldb; +using namespace lldb_private; + +SBListener::SBListener() : m_opaque_sp(), m_unused_ptr(nullptr) { + 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); +} + +SBListener::SBListener(const SBListener &rhs) + : 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; + } + return LLDB_RECORD_RESULT(*this); +} + +SBListener::SBListener(const lldb::ListenerSP &listener_sp) + : m_opaque_sp(listener_sp), m_unused_ptr(nullptr) {} + +SBListener::~SBListener() = default; + +bool SBListener::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBListener, IsValid); + return this->operator bool(); +} +SBListener::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBListener, operator bool); + + return m_opaque_sp != nullptr; +} + +void SBListener::AddEvent(const SBEvent &event) { + LLDB_RECORD_METHOD(void, SBListener, AddEvent, (const lldb::SBEvent &), + event); + + EventSP &event_sp = event.GetSP(); + if (event_sp) + m_opaque_sp->AddEvent(event_sp); +} + +void SBListener::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBListener, Clear); + + if (m_opaque_sp) + m_opaque_sp->Clear(); +} + +uint32_t SBListener::StartListeningForEventClass(SBDebugger &debugger, + const char *broadcaster_class, + uint32_t event_mask) { + LLDB_RECORD_METHOD(uint32_t, SBListener, StartListeningForEventClass, + (lldb::SBDebugger &, const char *, uint32_t), debugger, + broadcaster_class, event_mask); + + if (m_opaque_sp) { + Debugger *lldb_debugger = debugger.get(); + if (!lldb_debugger) + return 0; + BroadcastEventSpec event_spec(ConstString(broadcaster_class), event_mask); + return m_opaque_sp->StartListeningForEventSpec( + lldb_debugger->GetBroadcasterManager(), event_spec); + } else + return 0; +} + +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) + return false; + BroadcastEventSpec event_spec(ConstString(broadcaster_class), event_mask); + return m_opaque_sp->StopListeningForEventSpec( + lldb_debugger->GetBroadcasterManager(), event_spec); + } else + return false; +} + +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 = + m_opaque_sp->StartListeningForEvents(broadcaster.get(), event_mask); + } + + return acquired_event_mask; +} + +bool SBListener::StopListeningForEvents(const SBBroadcaster &broadcaster, + uint32_t event_mask) { + LLDB_RECORD_METHOD(bool, SBListener, StopListeningForEvents, + (const lldb::SBBroadcaster &, uint32_t), broadcaster, + event_mask); + + if (m_opaque_sp && broadcaster.IsValid()) { + return m_opaque_sp->StopListeningForEvents(broadcaster.get(), event_mask); + } + return false; +} + +bool SBListener::WaitForEvent(uint32_t timeout_secs, SBEvent &event) { + LLDB_RECORD_METHOD(bool, SBListener, WaitForEvent, + (uint32_t, lldb::SBEvent &), timeout_secs, event); + + bool success = false; + + if (m_opaque_sp) { + Timeout<std::micro> timeout(llvm::None); + if (timeout_secs != UINT32_MAX) { + assert(timeout_secs != 0); // Take this out after all calls with timeout + // set to zero have been removed.... + timeout = std::chrono::seconds(timeout_secs); + } + EventSP event_sp; + if (m_opaque_sp->GetEvent(event_sp, timeout)) { + event.reset(event_sp); + success = true; + } + } + + if (!success) + event.reset(nullptr); + return success; +} + +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) + timeout = std::chrono::seconds(num_seconds); + EventSP event_sp; + if (m_opaque_sp->GetEventForBroadcaster(broadcaster.get(), event_sp, + timeout)) { + event.reset(event_sp); + return true; + } + } + event.reset(nullptr); + return false; +} + +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) + timeout = std::chrono::seconds(num_seconds); + EventSP event_sp; + if (m_opaque_sp->GetEventForBroadcasterWithType( + broadcaster.get(), event_type_mask, event_sp, timeout)) { + event.reset(event_sp); + return true; + } + } + event.reset(nullptr); + return false; +} + +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(); + } + event.reset(nullptr); + return false; +} + +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(); + } + event.reset(nullptr); + return false; +} + +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)); + return event.IsValid(); + } + event.reset(nullptr); + return false; +} + +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))) { + event.reset(event_sp); + return true; + } + } + event.reset(nullptr); + return false; +} + +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, + std::chrono::seconds(0))) { + event.reset(event_sp); + return true; + } + } + event.reset(nullptr); + return false; +} + +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(), + event_type_mask, event_sp, + std::chrono::seconds(0))) { + event.reset(event_sp); + return true; + } + } + event.reset(nullptr); + return false; +} + +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; +} + +lldb::ListenerSP SBListener::GetSP() { return m_opaque_sp; } + +Listener *SBListener::operator->() const { return m_opaque_sp.get(); } + +Listener *SBListener::get() const { return m_opaque_sp.get(); } + +void SBListener::reset(ListenerSP listener_sp) { + m_opaque_sp = listener_sp; + m_unused_ptr = nullptr; +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBListener>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBListener, ()); + LLDB_REGISTER_CONSTRUCTOR(SBListener, (const char *)); + LLDB_REGISTER_CONSTRUCTOR(SBListener, (const lldb::SBListener &)); + LLDB_REGISTER_METHOD(const lldb::SBListener &, + SBListener, operator=,(const lldb::SBListener &)); + LLDB_REGISTER_METHOD_CONST(bool, SBListener, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBListener, operator bool, ()); + LLDB_REGISTER_METHOD(void, SBListener, AddEvent, (const lldb::SBEvent &)); + LLDB_REGISTER_METHOD(void, SBListener, Clear, ()); + LLDB_REGISTER_METHOD(uint32_t, SBListener, StartListeningForEventClass, + (lldb::SBDebugger &, const char *, uint32_t)); + LLDB_REGISTER_METHOD(bool, SBListener, StopListeningForEventClass, + (lldb::SBDebugger &, const char *, uint32_t)); + LLDB_REGISTER_METHOD(uint32_t, SBListener, StartListeningForEvents, + (const lldb::SBBroadcaster &, uint32_t)); + LLDB_REGISTER_METHOD(bool, SBListener, StopListeningForEvents, + (const lldb::SBBroadcaster &, uint32_t)); + LLDB_REGISTER_METHOD(bool, SBListener, WaitForEvent, + (uint32_t, lldb::SBEvent &)); + LLDB_REGISTER_METHOD( + bool, SBListener, WaitForEventForBroadcaster, + (uint32_t, const lldb::SBBroadcaster &, lldb::SBEvent &)); + LLDB_REGISTER_METHOD( + bool, SBListener, WaitForEventForBroadcasterWithType, + (uint32_t, const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &)); + LLDB_REGISTER_METHOD(bool, SBListener, PeekAtNextEvent, (lldb::SBEvent &)); + LLDB_REGISTER_METHOD(bool, SBListener, PeekAtNextEventForBroadcaster, + (const lldb::SBBroadcaster &, lldb::SBEvent &)); + LLDB_REGISTER_METHOD( + bool, SBListener, PeekAtNextEventForBroadcasterWithType, + (const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &)); + LLDB_REGISTER_METHOD(bool, SBListener, GetNextEvent, (lldb::SBEvent &)); + LLDB_REGISTER_METHOD(bool, SBListener, GetNextEventForBroadcaster, + (const lldb::SBBroadcaster &, lldb::SBEvent &)); + LLDB_REGISTER_METHOD( + bool, SBListener, GetNextEventForBroadcasterWithType, + (const lldb::SBBroadcaster &, uint32_t, lldb::SBEvent &)); + LLDB_REGISTER_METHOD(bool, SBListener, HandleBroadcastEvent, + (const lldb::SBEvent &)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBMemoryRegionInfo.cpp b/contrib/llvm-project/lldb/source/API/SBMemoryRegionInfo.cpp new file mode 100644 index 000000000000..2a28b99c72d7 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBMemoryRegionInfo.cpp @@ -0,0 +1,166 @@ +//===-- SBMemoryRegionInfo.cpp --------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBMemoryRegionInfo.h" +#include "SBReproducerPrivate.h" +#include "Utils.h" +#include "lldb/API/SBDefines.h" +#include "lldb/API/SBError.h" +#include "lldb/API/SBStream.h" +#include "lldb/Target/MemoryRegionInfo.h" +#include "lldb/Utility/StreamString.h" + +using namespace lldb; +using namespace lldb_private; + +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()) { + if (lldb_object_ptr) + ref() = *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 LLDB_RECORD_RESULT(*this); +} + +SBMemoryRegionInfo::~SBMemoryRegionInfo() = default; + +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(); +} + +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; + + strm.Printf("[0x%16.16" PRIx64 "-0x%16.16" PRIx64 " ", load_addr, + load_addr + m_opaque_up->GetRange().size); + strm.Printf(m_opaque_up->GetReadable() ? "R" : "-"); + strm.Printf(m_opaque_up->GetWritable() ? "W" : "-"); + strm.Printf(m_opaque_up->GetExecutable() ? "X" : "-"); + strm.Printf("]"); + + return true; +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBMemoryRegionInfo>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfo, ()); + LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfo, + (const lldb::SBMemoryRegionInfo &)); + LLDB_REGISTER_METHOD( + const lldb::SBMemoryRegionInfo &, + SBMemoryRegionInfo, operator=,(const lldb::SBMemoryRegionInfo &)); + LLDB_REGISTER_METHOD(void, SBMemoryRegionInfo, Clear, ()); + LLDB_REGISTER_METHOD_CONST( + bool, + SBMemoryRegionInfo, operator==,(const lldb::SBMemoryRegionInfo &)); + LLDB_REGISTER_METHOD_CONST( + bool, + SBMemoryRegionInfo, operator!=,(const lldb::SBMemoryRegionInfo &)); + LLDB_REGISTER_METHOD(lldb::addr_t, SBMemoryRegionInfo, GetRegionBase, ()); + LLDB_REGISTER_METHOD(lldb::addr_t, SBMemoryRegionInfo, GetRegionEnd, ()); + LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsReadable, ()); + LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsWritable, ()); + LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsExecutable, ()); + LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsMapped, ()); + LLDB_REGISTER_METHOD(const char *, SBMemoryRegionInfo, GetName, ()); + LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, GetDescription, + (lldb::SBStream &)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBMemoryRegionInfoList.cpp b/contrib/llvm-project/lldb/source/API/SBMemoryRegionInfoList.cpp new file mode 100644 index 000000000000..0f3f9c1b8177 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBMemoryRegionInfoList.cpp @@ -0,0 +1,166 @@ +//===-- SBMemoryRegionInfoList.cpp ----------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBMemoryRegionInfoList.h" +#include "SBReproducerPrivate.h" +#include "lldb/API/SBMemoryRegionInfo.h" +#include "lldb/API/SBStream.h" +#include "lldb/Target/MemoryRegionInfo.h" + +#include <vector> + +using namespace lldb; +using namespace lldb_private; + +class MemoryRegionInfoListImpl { +public: + MemoryRegionInfoListImpl() : m_regions() {} + + MemoryRegionInfoListImpl(const MemoryRegionInfoListImpl &rhs) + : m_regions(rhs.m_regions) {} + + MemoryRegionInfoListImpl &operator=(const MemoryRegionInfoListImpl &rhs) { + if (this == &rhs) + return *this; + m_regions = rhs.m_regions; + return *this; + } + + size_t GetSize() const { return m_regions.size(); } + + void Reserve(size_t capacity) { return m_regions.reserve(capacity); } + + void Append(const MemoryRegionInfo &sb_region) { + m_regions.push_back(sb_region); + } + + void Append(const MemoryRegionInfoListImpl &list) { + Reserve(GetSize() + list.GetSize()); + + for (const auto &val : list.m_regions) + Append(val); + } + + void Clear() { m_regions.clear(); } + + bool GetMemoryRegionInfoAtIndex(size_t index, + MemoryRegionInfo ®ion_info) { + if (index >= GetSize()) + return false; + region_info = m_regions[index]; + return true; + } + + MemoryRegionInfos &Ref() { return m_regions; } + + const MemoryRegionInfos &Ref() const { return m_regions; } + +private: + MemoryRegionInfos m_regions; +}; + +MemoryRegionInfos &SBMemoryRegionInfoList::ref() { return m_opaque_up->Ref(); } + +const MemoryRegionInfos &SBMemoryRegionInfoList::ref() const { + return m_opaque_up->Ref(); +} + +SBMemoryRegionInfoList::SBMemoryRegionInfoList() + : 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)) { + LLDB_RECORD_CONSTRUCTOR(SBMemoryRegionInfoList, + (const lldb::SBMemoryRegionInfoList &), rhs); +} + +SBMemoryRegionInfoList::~SBMemoryRegionInfoList() = default; + +const SBMemoryRegionInfoList &SBMemoryRegionInfoList:: +operator=(const SBMemoryRegionInfoList &rhs) { + LLDB_RECORD_METHOD( + const lldb::SBMemoryRegionInfoList &, + SBMemoryRegionInfoList, operator=,(const lldb::SBMemoryRegionInfoList &), + rhs); + + if (this != &rhs) { + *m_opaque_up = *rhs.m_opaque_up; + } + return LLDB_RECORD_RESULT(*this); +} + +uint32_t SBMemoryRegionInfoList::GetSize() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBMemoryRegionInfoList, GetSize); + + return m_opaque_up->GetSize(); +} + +bool SBMemoryRegionInfoList::GetMemoryRegionAtIndex( + uint32_t idx, SBMemoryRegionInfo ®ion_info) { + LLDB_RECORD_METHOD(bool, SBMemoryRegionInfoList, GetMemoryRegionAtIndex, + (uint32_t, lldb::SBMemoryRegionInfo &), idx, region_info); + + return m_opaque_up->GetMemoryRegionInfoAtIndex(idx, region_info.ref()); +} + +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); +} + +const MemoryRegionInfoListImpl *SBMemoryRegionInfoList::operator->() const { + return m_opaque_up.get(); +} + +const MemoryRegionInfoListImpl &SBMemoryRegionInfoList::operator*() const { + assert(m_opaque_up.get()); + return *m_opaque_up; +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBMemoryRegionInfoList>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfoList, ()); + LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfoList, + (const lldb::SBMemoryRegionInfoList &)); + LLDB_REGISTER_METHOD( + const lldb::SBMemoryRegionInfoList &, + SBMemoryRegionInfoList, operator=,( + const lldb::SBMemoryRegionInfoList &)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBMemoryRegionInfoList, GetSize, ()); + LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfoList, GetMemoryRegionAtIndex, + (uint32_t, lldb::SBMemoryRegionInfo &)); + LLDB_REGISTER_METHOD(void, SBMemoryRegionInfoList, Clear, ()); + LLDB_REGISTER_METHOD(void, SBMemoryRegionInfoList, Append, + (lldb::SBMemoryRegionInfo &)); + LLDB_REGISTER_METHOD(void, SBMemoryRegionInfoList, Append, + (lldb::SBMemoryRegionInfoList &)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBModule.cpp b/contrib/llvm-project/lldb/source/API/SBModule.cpp new file mode 100644 index 000000000000..c30529b37eb1 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBModule.cpp @@ -0,0 +1,772 @@ +//===-- SBModule.cpp ------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBModule.h" +#include "SBReproducerPrivate.h" +#include "lldb/API/SBAddress.h" +#include "lldb/API/SBFileSpec.h" +#include "lldb/API/SBModuleSpec.h" +#include "lldb/API/SBProcess.h" +#include "lldb/API/SBStream.h" +#include "lldb/API/SBSymbolContextList.h" +#include "lldb/Core/Module.h" +#include "lldb/Core/Section.h" +#include "lldb/Core/ValueObjectList.h" +#include "lldb/Core/ValueObjectVariable.h" +#include "lldb/Symbol/ObjectFile.h" +#include "lldb/Symbol/SymbolFile.h" +#include "lldb/Symbol/Symtab.h" +#include "lldb/Symbol/TypeSystem.h" +#include "lldb/Symbol/VariableList.h" +#include "lldb/Target/Target.h" +#include "lldb/Utility/StreamString.h" + +using namespace lldb; +using namespace lldb_private; + +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, nullptr, nullptr, nullptr); + if (module_sp) + SetSP(module_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); + if (m_opaque_sp) { + Target &target = process_sp->GetTarget(); + bool changed = false; + m_opaque_sp->SetLoadAddress(target, 0, true, changed); + target.GetImages().Append(m_opaque_sp); + } + } +} + +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 LLDB_RECORD_RESULT(*this); +} + +SBModule::~SBModule() = default; + +bool SBModule::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModule, IsValid); + return this->operator bool(); +} +SBModule::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModule, operator bool); + + return m_opaque_sp.get() != nullptr; +} + +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); + + SBFileSpec file_spec; + ModuleSP module_sp(GetSP()); + if (module_sp) + file_spec.SetFileSpec(module_sp->GetFileSpec()); + + return LLDB_RECORD_RESULT(file_spec); +} + +lldb::SBFileSpec SBModule::GetPlatformFileSpec() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule, + GetPlatformFileSpec); + + + SBFileSpec file_spec; + ModuleSP module_sp(GetSP()); + if (module_sp) + file_spec.SetFileSpec(module_sp->GetPlatformFileSpec()); + + 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; + + ModuleSP module_sp(GetSP()); + if (module_sp) { + module_sp->SetPlatformFileSpec(*platform_file); + result = true; + } + + return result; +} + +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 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()); + return true; + } + return false; +} + +const uint8_t *SBModule::GetUUIDBytes() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const uint8_t *, SBModule, GetUUIDBytes); + + const uint8_t *uuid_bytes = nullptr; + ModuleSP module_sp(GetSP()); + if (module_sp) + uuid_bytes = module_sp->GetUUID().GetBytes().data(); + + return uuid_bytes; +} + +const char *SBModule::GetUUIDString() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBModule, GetUUIDString); + + const char *uuid_cstr = nullptr; + ModuleSP module_sp(GetSP()); + if (module_sp) { + // We are going to return a "const char *" value through the public API, so + // we need to constify it so it gets added permanently the string pool and + // then we don't need to worry about the lifetime of the string as it will + // never go away once it has been put into the ConstString string pool + uuid_cstr = ConstString(module_sp->GetUUID().GetAsString()).GetCString(); + } + + if (uuid_cstr && uuid_cstr[0]) { + return uuid_cstr; + } + + return nullptr; +} + +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; +} + +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) { + Address addr; + if (module_sp->ResolveFileAddress(vm_addr, addr)) + sb_addr.ref() = 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 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()); + if (module_sp) { + module_sp->GetDescription(strm.AsRawOstream()); + } else + strm.PutCString("No value"); + + return true; +} + +uint32_t SBModule::GetNumCompileUnits() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBModule, GetNumCompileUnits); + + ModuleSP module_sp(GetSP()); + if (module_sp) { + return module_sp->GetNumCompileUnits(); + } + return 0; +} + +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 LLDB_RECORD_RESULT(sb_cu); +} + +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) { + module_sp->FindCompileUnits(*sb_file_spec, *sb_sc_list); + } + return LLDB_RECORD_RESULT(sb_sc_list); +} + +static Symtab *GetUnifiedSymbolTable(const lldb::ModuleSP &module_sp) { + if (module_sp) + return module_sp->GetSymtab(); + return nullptr; +} + +size_t SBModule::GetNumSymbols() { + LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModule, GetNumSymbols); + + ModuleSP module_sp(GetSP()); + if (Symtab *symtab = GetUnifiedSymbolTable(module_sp)) + return symtab->GetNumSymbols(); + return 0; +} + +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 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()); + Symtab *symtab = GetUnifiedSymbolTable(module_sp); + if (symtab) + sb_symbol.SetSymbol(symtab->FindFirstSymbolWithNameAndType( + ConstString(name), symbol_type, Symtab::eDebugAny, + Symtab::eVisibilityAny)); + } + 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()); + Symtab *symtab = GetUnifiedSymbolTable(module_sp); + if (symtab) { + std::vector<uint32_t> matching_symbol_indexes; + symtab->FindAllSymbolsWithNameAndType(ConstString(name), symbol_type, + matching_symbol_indexes); + const size_t num_matches = matching_symbol_indexes.size(); + if (num_matches) { + SymbolContext sc; + sc.module_sp = module_sp; + SymbolContextList &sc_list = *sb_sc_list; + for (size_t i = 0; i < num_matches; ++i) { + sc.symbol = symtab->SymbolAtIndex(matching_symbol_indexes[i]); + if (sc.symbol) + sc_list.Append(sc); + } + } + } + } + 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. + module_sp->GetSymbolFile(); + SectionList *section_list = module_sp->GetSectionList(); + if (section_list) + return section_list->GetSize(); + } + return 0; +} + +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) { + // Give the symbol vendor a chance to add to the unified section list. + module_sp->GetSymbolFile(); + SectionList *section_list = module_sp->GetSectionList(); + + if (section_list) + sb_section.SetSP(section_list->GetSectionAtIndex(idx)); + } + 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) { + const bool symbols_ok = true; + const bool inlines_ok = true; + FunctionNameType type = static_cast<FunctionNameType>(name_type_mask); + module_sp->FindFunctions(ConstString(name), CompilerDeclContext(), type, + symbols_ok, inlines_ok, *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) { + VariableList variable_list; + module_sp->FindGlobalVariables(ConstString(name), CompilerDeclContext(), + max_matches, variable_list); + for (const VariableSP &var_sp : variable_list) { + lldb::ValueObjectSP valobj_sp; + TargetSP target_sp(target.GetSP()); + valobj_sp = ValueObjectVariable::Create(target_sp.get(), var_sp); + if (valobj_sp) + sb_value_list.Append(SBValue(valobj_sp)); + } + } + + 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 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) { + SymbolContext sc; + const bool exact_match = false; + ConstString name(name_cstr); + + sb_type = SBType(module_sp->FindFirstType(sc, name, exact_match)); + + if (!sb_type.IsValid()) { + auto type_system_or_err = + module_sp->GetTypeSystemForLanguage(eLanguageTypeC); + if (auto err = type_system_or_err.takeError()) { + llvm::consumeError(std::move(err)); + return LLDB_RECORD_RESULT(SBType()); + } + sb_type = SBType(type_system_or_err->GetBuiltinTypeByName(name)); + } + } + 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) { + auto type_system_or_err = + module_sp->GetTypeSystemForLanguage(eLanguageTypeC); + if (auto err = type_system_or_err.takeError()) { + llvm::consumeError(std::move(err)); + } else { + return LLDB_RECORD_RESULT( + SBType(type_system_or_err->GetBasicTypeFromAST(type))); + } + } + 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()); + if (type && module_sp) { + TypeList type_list; + const bool exact_match = false; + ConstString name(type); + llvm::DenseSet<SymbolFile *> searched_symbol_files; + module_sp->FindTypes(name, exact_match, UINT32_MAX, searched_symbol_files, + type_list); + + if (type_list.Empty()) { + auto type_system_or_err = + module_sp->GetTypeSystemForLanguage(eLanguageTypeC); + if (auto err = type_system_or_err.takeError()) { + llvm::consumeError(std::move(err)); + } else { + CompilerType compiler_type = + type_system_or_err->GetBuiltinTypeByName(name); + if (compiler_type) + retval.Append(SBType(compiler_type)); + } + } else { + for (size_t idx = 0; idx < type_list.GetSize(); idx++) { + TypeSP type_sp(type_list.GetTypeAtIndex(idx)); + if (type_sp) + retval.Append(SBType(type_sp)); + } + } + } + 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) { + if (SymbolFile *symfile = module_sp->GetSymbolFile()) { + Type *type_ptr = symfile->ResolveTypeUID(uid); + if (type_ptr) + return LLDB_RECORD_RESULT(SBType(type_ptr->shared_from_this())); + } + } + 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 LLDB_RECORD_RESULT(sb_type_list); + SymbolFile *symfile = module_sp->GetSymbolFile(); + if (!symfile) + return LLDB_RECORD_RESULT(sb_type_list); + + TypeClass type_class = static_cast<TypeClass>(type_mask); + TypeList type_list; + symfile->GetTypes(nullptr, type_class, type_list); + sb_type_list.m_opaque_up->Append(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()); + if (sect_name && module_sp) { + // Give the symbol vendor a chance to add to the unified section list. + module_sp->GetSymbolFile(); + SectionList *section_list = module_sp->GetSectionList(); + if (section_list) { + ConstString const_sect_name(sect_name); + SectionSP section_sp(section_list->FindSectionByName(const_sect_name)); + if (section_sp) { + sb_section.SetSP(section_sp); + } + } + } + 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(); + return eByteOrderInvalid; +} + +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()); + // 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 + // comes out + ConstString const_triple(triple.c_str()); + return const_triple.GetCString(); + } + return nullptr; +} + +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(); + return sizeof(void *); +} + +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(); + uint32_t result = 0; + if (!version.empty()) + ++result; + if (version.getMinor()) + ++result; + if(version.getSubminor()) + ++result; + + if (!versions) + return result; + + if (num_versions > 0) + versions[0] = version.empty() ? UINT32_MAX : version.getMajor(); + if (num_versions > 1) + versions[1] = version.getMinor().getValueOr(UINT32_MAX); + if (num_versions > 2) + versions[2] = version.getSubminor().getValueOr(UINT32_MAX); + for (uint32_t i = 3; i < num_versions; ++i) + versions[i] = UINT32_MAX; + return result; +} + +lldb::SBFileSpec SBModule::GetSymbolFileSpec() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule, + GetSymbolFileSpec); + + lldb::SBFileSpec sb_file_spec; + ModuleSP module_sp(GetSP()); + if (module_sp) { + if (SymbolFile *symfile = module_sp->GetSymbolFile()) + sb_file_spec.SetFileSpec(symfile->GetObjectFile()->GetFileSpec()); + } + 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) { + ObjectFile *objfile_ptr = module_sp->GetObjectFile(); + if (objfile_ptr) + sb_addr.ref() = objfile_ptr->GetBaseAddress(); + } + 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) { + ObjectFile *objfile_ptr = module_sp->GetObjectFile(); + if (objfile_ptr) + sb_addr.ref() = objfile_ptr->GetEntryPointAddress(); + } + return LLDB_RECORD_RESULT(sb_addr); +} + +uint32_t SBModule::GetNumberAllocatedModules() { + LLDB_RECORD_STATIC_METHOD_NO_ARGS(uint32_t, SBModule, + GetNumberAllocatedModules); + + return Module::GetNumberAllocatedModules(); +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBModule>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBModule, ()); + LLDB_REGISTER_CONSTRUCTOR(SBModule, (const lldb::SBModuleSpec &)); + LLDB_REGISTER_CONSTRUCTOR(SBModule, (const lldb::SBModule &)); + LLDB_REGISTER_CONSTRUCTOR(SBModule, (lldb::SBProcess &, lldb::addr_t)); + LLDB_REGISTER_METHOD(const lldb::SBModule &, + SBModule, operator=,(const lldb::SBModule &)); + LLDB_REGISTER_METHOD_CONST(bool, SBModule, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBModule, operator bool, ()); + LLDB_REGISTER_METHOD(void, SBModule, Clear, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBModule, GetFileSpec, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBModule, GetPlatformFileSpec, + ()); + LLDB_REGISTER_METHOD(bool, SBModule, SetPlatformFileSpec, + (const lldb::SBFileSpec &)); + LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModule, GetRemoteInstallFileSpec, + ()); + LLDB_REGISTER_METHOD(bool, SBModule, SetRemoteInstallFileSpec, + (lldb::SBFileSpec &)); + LLDB_REGISTER_METHOD_CONST(const char *, SBModule, GetUUIDString, ()); + LLDB_REGISTER_METHOD_CONST(bool, + SBModule, operator==,(const lldb::SBModule &)); + LLDB_REGISTER_METHOD_CONST(bool, + SBModule, operator!=,(const lldb::SBModule &)); + LLDB_REGISTER_METHOD(lldb::SBAddress, SBModule, ResolveFileAddress, + (lldb::addr_t)); + LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBModule, + ResolveSymbolContextForAddress, + (const lldb::SBAddress &, uint32_t)); + LLDB_REGISTER_METHOD(bool, SBModule, GetDescription, (lldb::SBStream &)); + LLDB_REGISTER_METHOD(uint32_t, SBModule, GetNumCompileUnits, ()); + LLDB_REGISTER_METHOD(lldb::SBCompileUnit, SBModule, GetCompileUnitAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBModule, FindCompileUnits, + (const lldb::SBFileSpec &)); + LLDB_REGISTER_METHOD(size_t, SBModule, GetNumSymbols, ()); + LLDB_REGISTER_METHOD(lldb::SBSymbol, SBModule, GetSymbolAtIndex, (size_t)); + LLDB_REGISTER_METHOD(lldb::SBSymbol, SBModule, FindSymbol, + (const char *, lldb::SymbolType)); + LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBModule, FindSymbols, + (const char *, lldb::SymbolType)); + LLDB_REGISTER_METHOD(size_t, SBModule, GetNumSections, ()); + LLDB_REGISTER_METHOD(lldb::SBSection, SBModule, GetSectionAtIndex, + (size_t)); + LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBModule, FindFunctions, + (const char *, uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBValueList, SBModule, FindGlobalVariables, + (lldb::SBTarget &, const char *, uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBModule, FindFirstGlobalVariable, + (lldb::SBTarget &, const char *)); + LLDB_REGISTER_METHOD(lldb::SBType, SBModule, FindFirstType, (const char *)); + LLDB_REGISTER_METHOD(lldb::SBType, SBModule, GetBasicType, + (lldb::BasicType)); + LLDB_REGISTER_METHOD(lldb::SBTypeList, SBModule, FindTypes, (const char *)); + LLDB_REGISTER_METHOD(lldb::SBType, SBModule, GetTypeByID, + (lldb::user_id_t)); + LLDB_REGISTER_METHOD(lldb::SBTypeList, SBModule, GetTypes, (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBSection, SBModule, FindSection, + (const char *)); + LLDB_REGISTER_METHOD(lldb::ByteOrder, SBModule, GetByteOrder, ()); + LLDB_REGISTER_METHOD(const char *, SBModule, GetTriple, ()); + LLDB_REGISTER_METHOD(uint32_t, SBModule, GetAddressByteSize, ()); + LLDB_REGISTER_METHOD(uint32_t, SBModule, GetVersion, + (uint32_t *, uint32_t)); + LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBModule, GetSymbolFileSpec, + ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBModule, + GetObjectFileHeaderAddress, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBModule, + GetObjectFileEntryPointAddress, ()); + LLDB_REGISTER_STATIC_METHOD(uint32_t, SBModule, GetNumberAllocatedModules, + ()); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBModuleSpec.cpp b/contrib/llvm-project/lldb/source/API/SBModuleSpec.cpp new file mode 100644 index 000000000000..5d88272a399b --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBModuleSpec.cpp @@ -0,0 +1,300 @@ +//===-- SBModuleSpec.cpp --------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBModuleSpec.h" +#include "SBReproducerPrivate.h" +#include "Utils.h" +#include "lldb/API/SBStream.h" +#include "lldb/Core/Module.h" +#include "lldb/Core/ModuleSpec.h" +#include "lldb/Host/Host.h" +#include "lldb/Symbol/ObjectFile.h" +#include "lldb/Utility/Stream.h" + +using namespace lldb; +using namespace lldb_private; + +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 LLDB_RECORD_RESULT(*this); +} + +SBModuleSpec::~SBModuleSpec() = default; + +bool SBModuleSpec::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModuleSpec, IsValid); + return this->operator bool(); +} +SBModuleSpec::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModuleSpec, operator bool); + + 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 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() { + 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() { + 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 + // comes out + ConstString const_triple(triple.c_str()); + return const_triple.GetCString(); +} + +void SBModuleSpec::SetTriple(const char *triple) { + LLDB_RECORD_METHOD(void, SBModuleSpec, SetTriple, (const char *), triple); + + m_opaque_up->GetArchitecture().SetTriple(triple); +} + +const uint8_t *SBModuleSpec::GetUUIDBytes() { + return m_opaque_up->GetUUID().GetBytes().data(); +} + +size_t SBModuleSpec::GetUUIDLength() { + LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModuleSpec, GetUUIDLength); + + return m_opaque_up->GetUUID().GetBytes().size(); +} + +bool SBModuleSpec::SetUUIDBytes(const uint8_t *uuid, size_t uuid_len) { + m_opaque_up->GetUUID() = UUID::fromOptionalData(uuid, uuid_len); + return m_opaque_up->GetUUID().IsValid(); +} + +bool SBModuleSpec::GetDescription(lldb::SBStream &description) { + LLDB_RECORD_METHOD(bool, SBModuleSpec, GetDescription, (lldb::SBStream &), + description); + + m_opaque_up->Dump(description.ref()); + return true; +} + +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)) { + 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 LLDB_RECORD_RESULT(*this); +} + +SBModuleSpecList::~SBModuleSpecList() = default; + +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 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() { + 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 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 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 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; +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBModuleSpec>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBModuleSpec, ()); + LLDB_REGISTER_CONSTRUCTOR(SBModuleSpec, (const lldb::SBModuleSpec &)); + LLDB_REGISTER_METHOD(const lldb::SBModuleSpec &, + SBModuleSpec, operator=,(const lldb::SBModuleSpec &)); + LLDB_REGISTER_METHOD_CONST(bool, SBModuleSpec, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBModuleSpec, operator bool, ()); + LLDB_REGISTER_METHOD(void, SBModuleSpec, Clear, ()); + LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModuleSpec, GetFileSpec, ()); + LLDB_REGISTER_METHOD(void, SBModuleSpec, SetFileSpec, + (const lldb::SBFileSpec &)); + LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModuleSpec, GetPlatformFileSpec, + ()); + LLDB_REGISTER_METHOD(void, SBModuleSpec, SetPlatformFileSpec, + (const lldb::SBFileSpec &)); + LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModuleSpec, GetSymbolFileSpec, ()); + LLDB_REGISTER_METHOD(void, SBModuleSpec, SetSymbolFileSpec, + (const lldb::SBFileSpec &)); + LLDB_REGISTER_METHOD(const char *, SBModuleSpec, GetObjectName, ()); + LLDB_REGISTER_METHOD(void, SBModuleSpec, SetObjectName, (const char *)); + LLDB_REGISTER_METHOD(const char *, SBModuleSpec, GetTriple, ()); + LLDB_REGISTER_METHOD(void, SBModuleSpec, SetTriple, (const char *)); + LLDB_REGISTER_METHOD(size_t, SBModuleSpec, GetUUIDLength, ()); + LLDB_REGISTER_METHOD(bool, SBModuleSpec, GetDescription, + (lldb::SBStream &)); + LLDB_REGISTER_CONSTRUCTOR(SBModuleSpecList, ()); + LLDB_REGISTER_CONSTRUCTOR(SBModuleSpecList, + (const lldb::SBModuleSpecList &)); + LLDB_REGISTER_METHOD( + lldb::SBModuleSpecList &, + SBModuleSpecList, operator=,(const lldb::SBModuleSpecList &)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBModuleSpecList, SBModuleSpecList, + GetModuleSpecifications, (const char *)); + LLDB_REGISTER_METHOD(void, SBModuleSpecList, Append, + (const lldb::SBModuleSpec &)); + LLDB_REGISTER_METHOD(void, SBModuleSpecList, Append, + (const lldb::SBModuleSpecList &)); + LLDB_REGISTER_METHOD(size_t, SBModuleSpecList, GetSize, ()); + LLDB_REGISTER_METHOD(lldb::SBModuleSpec, SBModuleSpecList, GetSpecAtIndex, + (size_t)); + LLDB_REGISTER_METHOD(lldb::SBModuleSpec, SBModuleSpecList, + FindFirstMatchingSpec, (const lldb::SBModuleSpec &)); + LLDB_REGISTER_METHOD(lldb::SBModuleSpecList, SBModuleSpecList, + FindMatchingSpecs, (const lldb::SBModuleSpec &)); + LLDB_REGISTER_METHOD(bool, SBModuleSpecList, GetDescription, + (lldb::SBStream &)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBPlatform.cpp b/contrib/llvm-project/lldb/source/API/SBPlatform.cpp new file mode 100644 index 000000000000..7ac852488ffb --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBPlatform.cpp @@ -0,0 +1,767 @@ +//===-- SBPlatform.cpp ----------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBPlatform.h" +#include "SBReproducerPrivate.h" +#include "lldb/API/SBEnvironment.h" +#include "lldb/API/SBError.h" +#include "lldb/API/SBFileSpec.h" +#include "lldb/API/SBLaunchInfo.h" +#include "lldb/API/SBPlatform.h" +#include "lldb/API/SBUnixSignals.h" +#include "lldb/Host/File.h" +#include "lldb/Target/Platform.h" +#include "lldb/Target/Target.h" +#include "lldb/Utility/ArchSpec.h" +#include "lldb/Utility/Args.h" +#include "lldb/Utility/Status.h" + +#include "llvm/Support/FileSystem.h" + +#include <functional> + +using namespace lldb; +using namespace lldb_private; + +// PlatformConnectOptions +struct PlatformConnectOptions { + PlatformConnectOptions(const char *url = nullptr) + : m_url(), m_rsync_options(), m_rsync_remote_path_prefix(), + m_rsync_enabled(false), m_rsync_omit_hostname_from_remote_path(false), + m_local_cache_directory() { + if (url && url[0]) + m_url = url; + } + + ~PlatformConnectOptions() = default; + + std::string m_url; + std::string m_rsync_options; + std::string m_rsync_remote_path_prefix; + bool m_rsync_enabled; + bool m_rsync_omit_hostname_from_remote_path; + ConstString m_local_cache_directory; +}; + +// PlatformShellCommand +struct PlatformShellCommand { + PlatformShellCommand(const char *shell_command = nullptr) + : m_command(), m_working_dir(), m_status(0), m_signo(0) { + if (shell_command && shell_command[0]) + m_command = shell_command; + } + + ~PlatformShellCommand() = default; + + std::string m_command; + std::string m_working_dir; + std::string m_output; + int m_status; + int m_signo; + Timeout<std::ratio<1>> m_timeout = llvm::None; +}; +// SBPlatformConnectOptions +SBPlatformConnectOptions::SBPlatformConnectOptions(const char *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; } + +SBPlatformConnectOptions &SBPlatformConnectOptions:: +operator=(const SBPlatformConnectOptions &rhs) { + LLDB_RECORD_METHOD( + SBPlatformConnectOptions &, + SBPlatformConnectOptions, operator=,( + const lldb::SBPlatformConnectOptions &), + rhs); + + *m_opaque_ptr = *rhs.m_opaque_ptr; + return LLDB_RECORD_RESULT(*this); +} + +const char *SBPlatformConnectOptions::GetURL() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformConnectOptions, GetURL); + + if (m_opaque_ptr->m_url.empty()) + return nullptr; + 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 + m_opaque_ptr->m_url.clear(); +} + +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; + if (remote_path_prefix && remote_path_prefix[0]) + m_opaque_ptr->m_rsync_remote_path_prefix = remote_path_prefix; + else + m_opaque_ptr->m_rsync_remote_path_prefix.clear(); + + if (options && options[0]) + m_opaque_ptr->m_rsync_options = options; + else + m_opaque_ptr->m_rsync_options.clear(); +} + +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 + m_opaque_ptr->m_local_cache_directory = ConstString(); +} + +// SBPlatformShellCommand +SBPlatformShellCommand::SBPlatformShellCommand(const char *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:: +operator=(const SBPlatformShellCommand &rhs) { + + LLDB_RECORD_METHOD( + SBPlatformShellCommand &, + SBPlatformShellCommand, operator=,(const lldb::SBPlatformShellCommand &), + rhs); + + *m_opaque_ptr = *rhs.m_opaque_ptr; + return LLDB_RECORD_RESULT(*this); +} + +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 nullptr; + 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 + m_opaque_ptr->m_command.clear(); +} + +const char *SBPlatformShellCommand::GetWorkingDirectory() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand, + GetWorkingDirectory); + + if (m_opaque_ptr->m_working_dir.empty()) + return nullptr; + 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 + m_opaque_ptr->m_working_dir.clear(); +} + +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() { + LLDB_RECORD_METHOD_NO_ARGS(int, SBPlatformShellCommand, GetSignal); + + return m_opaque_ptr->m_signo; +} + +int SBPlatformShellCommand::GetStatus() { + LLDB_RECORD_METHOD_NO_ARGS(int, SBPlatformShellCommand, GetStatus); + + 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 nullptr; + return m_opaque_ptr->m_output.c_str(); +} + +// SBPlatform +SBPlatform::SBPlatform() : m_opaque_sp() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBPlatform); +} + +SBPlatform::SBPlatform(const char *platform_name) : m_opaque_sp() { + LLDB_RECORD_CONSTRUCTOR(SBPlatform, (const char *), platform_name); + + Status error; + if (platform_name && platform_name[0]) + m_opaque_sp = Platform::Create(ConstString(platform_name), error); +} + +SBPlatform::SBPlatform(const SBPlatform &rhs) { + LLDB_RECORD_CONSTRUCTOR(SBPlatform, (const lldb::SBPlatform &), rhs); + + m_opaque_sp = rhs.m_opaque_sp; +} + +SBPlatform &SBPlatform::operator=(const SBPlatform &rhs) { + LLDB_RECORD_METHOD(SBPlatform &, + SBPlatform, operator=,(const lldb::SBPlatform &), rhs); + + m_opaque_sp = rhs.m_opaque_sp; + return LLDB_RECORD_RESULT(*this); +} + +SBPlatform::~SBPlatform() = default; + +SBPlatform SBPlatform::GetHostPlatform() { + LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBPlatform, SBPlatform, + GetHostPlatform); + + SBPlatform host_platform; + host_platform.m_opaque_sp = Platform::GetHostPlatform(); + return LLDB_RECORD_RESULT(host_platform); +} + +bool SBPlatform::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBPlatform, IsValid); + return this->operator bool(); +} +SBPlatform::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBPlatform, operator bool); + + return m_opaque_sp.get() != nullptr; +} + +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(); + return nullptr; +} + +lldb::PlatformSP SBPlatform::GetSP() const { return m_opaque_sp; } + +void SBPlatform::SetSP(const lldb::PlatformSP &platform_sp) { + m_opaque_sp = 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(); + return nullptr; +} + +bool SBPlatform::SetWorkingDirectory(const char *path) { + LLDB_RECORD_METHOD(bool, SBPlatform, SetWorkingDirectory, (const char *), + path); + + PlatformSP platform_sp(GetSP()); + if (platform_sp) { + if (path) + platform_sp->SetWorkingDirectory(FileSpec(path)); + else + platform_sp->SetWorkingDirectory(FileSpec()); + return true; + } + return false; +} + +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()) { + Args args; + args.AppendArgument( + llvm::StringRef::withNullAsEmpty(connect_options.GetURL())); + sb_error.ref() = platform_sp->ConnectRemote(args); + } else { + sb_error.SetErrorString("invalid platform"); + } + 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(); + return false; +} + +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()); + if (arch.IsValid()) { + // Const-ify the string so we don't need to worry about the lifetime of + // the string + return ConstString(arch.GetTriple().getTriple().c_str()).GetCString(); + } + } + return nullptr; +} + +const char *SBPlatform::GetOSBuild() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetOSBuild); + + PlatformSP platform_sp(GetSP()); + if (platform_sp) { + std::string s; + if (platform_sp->GetOSBuildString(s)) { + if (!s.empty()) { + // Const-ify the string so we don't need to worry about the lifetime of + // the string + return ConstString(s.c_str()).GetCString(); + } + } + } + return nullptr; +} + +const char *SBPlatform::GetOSDescription() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetOSDescription); + + PlatformSP platform_sp(GetSP()); + if (platform_sp) { + std::string s; + if (platform_sp->GetOSKernelDescription(s)) { + if (!s.empty()) { + // Const-ify the string so we don't need to worry about the lifetime of + // the string + return ConstString(s.c_str()).GetCString(); + } + } + } + return nullptr; +} + +const char *SBPlatform::GetHostname() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetHostname); + + PlatformSP platform_sp(GetSP()); + if (platform_sp) + return platform_sp->GetHostname(); + return nullptr; +} + +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(); + return version.empty() ? UINT32_MAX : version.getMajor(); +} + +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(); + return version.getMinor().getValueOr(UINT32_MAX); +} + +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(); + return version.getSubminor().getValueOr(UINT32_MAX); +} + +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) { + sb_error.ref() = platform_sp->GetFile(src.ref(), dst.ref()); + } else { + sb_error.SetErrorString("invalid platform"); + } + return LLDB_RECORD_RESULT(sb_error); +} + +SBError SBPlatform::Put(SBFileSpec &src, SBFileSpec &dst) { + LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Put, + (lldb::SBFileSpec &, lldb::SBFileSpec &), src, dst); + return LLDB_RECORD_RESULT( + ExecuteConnected([&](const lldb::PlatformSP &platform_sp) { + if (src.Exists()) { + uint32_t permissions = + FileSystem::Instance().GetPermissions(src.ref()); + if (permissions == 0) { + if (FileSystem::Instance().IsDirectory(src.ref())) + permissions = eFilePermissionsDirectoryDefault; + else + permissions = eFilePermissionsFileDefault; + } + + return platform_sp->PutFile(src.ref(), dst.ref(), permissions); + } + + Status error; + error.SetErrorStringWithFormat("'src' argument doesn't exist: '%s'", + src.ref().GetPath().c_str()); + return error; + })); +} + +SBError SBPlatform::Install(SBFileSpec &src, SBFileSpec &dst) { + 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; + })); +} + +SBError SBPlatform::Run(SBPlatformShellCommand &shell_command) { + 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)"); + + const char *working_dir = shell_command.GetWorkingDirectory(); + if (working_dir == nullptr) { + working_dir = platform_sp->GetWorkingDirectory().GetCString(); + if (working_dir) + shell_command.SetWorkingDirectory(working_dir); + } + return platform_sp->RunShellCommand(command, FileSpec(working_dir), + &shell_command.m_opaque_ptr->m_status, + &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) { + 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) { + 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( + const std::function<Status(const lldb::PlatformSP &)> &func) { + SBError sb_error; + const auto platform_sp(GetSP()); + if (platform_sp) { + if (platform_sp->IsConnected()) + sb_error.ref() = func(platform_sp); + else + sb_error.SetErrorString("not connected"); + } else + sb_error.SetErrorString("invalid platform"); + + return sb_error; +} + +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) { + sb_error.ref() = + platform_sp->MakeDirectory(FileSpec(path), file_permissions); + } else { + sb_error.SetErrorString("invalid platform"); + } + 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; + platform_sp->GetFilePermissions(FileSpec(path), file_permissions); + return file_permissions; + } + return 0; +} + +SBError SBPlatform::SetFilePermissions(const char *path, + uint32_t file_permissions) { + LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, SetFilePermissions, + (const char *, uint32_t), path, file_permissions); + + SBError sb_error; + PlatformSP platform_sp(GetSP()); + if (platform_sp) { + sb_error.ref() = + platform_sp->SetFilePermissions(FileSpec(path), file_permissions); + } else { + sb_error.SetErrorString("invalid platform"); + } + return LLDB_RECORD_RESULT(sb_error); +} + +SBUnixSignals SBPlatform::GetUnixSignals() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBUnixSignals, SBPlatform, + GetUnixSignals); + + if (auto platform_sp = GetSP()) + return LLDB_RECORD_RESULT(SBUnixSignals{platform_sp}); + + return LLDB_RECORD_RESULT(SBUnixSignals()); +} + +SBEnvironment SBPlatform::GetEnvironment() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBEnvironment, SBPlatform, GetEnvironment); + PlatformSP platform_sp(GetSP()); + + if (platform_sp) { + return LLDB_RECORD_RESULT(SBEnvironment(platform_sp->GetEnvironment())); + } + + return LLDB_RECORD_RESULT(SBEnvironment()); +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBPlatformConnectOptions>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBPlatformConnectOptions, (const char *)); + LLDB_REGISTER_CONSTRUCTOR(SBPlatformConnectOptions, + (const lldb::SBPlatformConnectOptions &)); + LLDB_REGISTER_METHOD( + SBPlatformConnectOptions &, + SBPlatformConnectOptions, operator=,( + const lldb::SBPlatformConnectOptions &)); + LLDB_REGISTER_METHOD(const char *, SBPlatformConnectOptions, GetURL, ()); + LLDB_REGISTER_METHOD(void, SBPlatformConnectOptions, SetURL, + (const char *)); + LLDB_REGISTER_METHOD(bool, SBPlatformConnectOptions, GetRsyncEnabled, ()); + LLDB_REGISTER_METHOD(void, SBPlatformConnectOptions, EnableRsync, + (const char *, const char *, bool)); + LLDB_REGISTER_METHOD(void, SBPlatformConnectOptions, DisableRsync, ()); + LLDB_REGISTER_METHOD(const char *, SBPlatformConnectOptions, + GetLocalCacheDirectory, ()); + LLDB_REGISTER_METHOD(void, SBPlatformConnectOptions, SetLocalCacheDirectory, + (const char *)); +} + +template <> +void RegisterMethods<SBPlatformShellCommand>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBPlatformShellCommand, (const char *)); + LLDB_REGISTER_CONSTRUCTOR(SBPlatformShellCommand, + (const lldb::SBPlatformShellCommand &)); + LLDB_REGISTER_METHOD( + SBPlatformShellCommand &, + SBPlatformShellCommand, operator=,(const lldb::SBPlatformShellCommand &)); + LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, Clear, ()); + LLDB_REGISTER_METHOD(const char *, SBPlatformShellCommand, GetCommand, ()); + LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, SetCommand, + (const char *)); + LLDB_REGISTER_METHOD(const char *, SBPlatformShellCommand, + GetWorkingDirectory, ()); + LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, SetWorkingDirectory, + (const char *)); + LLDB_REGISTER_METHOD(uint32_t, SBPlatformShellCommand, GetTimeoutSeconds, + ()); + LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, SetTimeoutSeconds, + (uint32_t)); + LLDB_REGISTER_METHOD(int, SBPlatformShellCommand, GetSignal, ()); + LLDB_REGISTER_METHOD(int, SBPlatformShellCommand, GetStatus, ()); + LLDB_REGISTER_METHOD(const char *, SBPlatformShellCommand, GetOutput, ()); +} + +template <> +void RegisterMethods<SBPlatform>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBPlatform, ()); + LLDB_REGISTER_CONSTRUCTOR(SBPlatform, (const char *)); + LLDB_REGISTER_CONSTRUCTOR(SBPlatform, (const lldb::SBPlatform &)); + LLDB_REGISTER_METHOD(SBPlatform &, + SBPlatform, operator=,(const lldb::SBPlatform &)); + LLDB_REGISTER_METHOD_CONST(bool, SBPlatform, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBPlatform, operator bool, ()); + LLDB_REGISTER_METHOD(void, SBPlatform, Clear, ()); + LLDB_REGISTER_METHOD(const char *, SBPlatform, GetName, ()); + LLDB_REGISTER_METHOD(const char *, SBPlatform, GetWorkingDirectory, ()); + LLDB_REGISTER_METHOD(bool, SBPlatform, SetWorkingDirectory, (const char *)); + LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, ConnectRemote, + (lldb::SBPlatformConnectOptions &)); + LLDB_REGISTER_METHOD(void, SBPlatform, DisconnectRemote, ()); + LLDB_REGISTER_METHOD(bool, SBPlatform, IsConnected, ()); + LLDB_REGISTER_METHOD(const char *, SBPlatform, GetTriple, ()); + LLDB_REGISTER_METHOD(const char *, SBPlatform, GetOSBuild, ()); + LLDB_REGISTER_METHOD(const char *, SBPlatform, GetOSDescription, ()); + LLDB_REGISTER_METHOD(const char *, SBPlatform, GetHostname, ()); + LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetOSMajorVersion, ()); + LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetOSMinorVersion, ()); + LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetOSUpdateVersion, ()); + LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Get, + (lldb::SBFileSpec &, lldb::SBFileSpec &)); + LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Put, + (lldb::SBFileSpec &, lldb::SBFileSpec &)); + LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Install, + (lldb::SBFileSpec &, lldb::SBFileSpec &)); + LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Run, + (lldb::SBPlatformShellCommand &)); + LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Launch, + (lldb::SBLaunchInfo &)); + LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Kill, (const lldb::pid_t)); + LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, MakeDirectory, + (const char *, uint32_t)); + LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetFilePermissions, + (const char *)); + LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, SetFilePermissions, + (const char *, uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBEnvironment, SBPlatform, GetEnvironment, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBUnixSignals, SBPlatform, GetUnixSignals, + ()); + LLDB_REGISTER_STATIC_METHOD(lldb::SBPlatform, SBPlatform, GetHostPlatform, + ()); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBProcess.cpp b/contrib/llvm-project/lldb/source/API/SBProcess.cpp new file mode 100644 index 000000000000..d7b7fd7cacad --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBProcess.cpp @@ -0,0 +1,1449 @@ +//===-- SBProcess.cpp -----------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBProcess.h" +#include "SBReproducerPrivate.h" + +#include <inttypes.h> + +#include "lldb/lldb-defines.h" +#include "lldb/lldb-types.h" + +#include "lldb/Core/Debugger.h" +#include "lldb/Core/Module.h" +#include "lldb/Core/PluginManager.h" +#include "lldb/Core/StreamFile.h" +#include "lldb/Core/StructuredDataImpl.h" +#include "lldb/Target/MemoryRegionInfo.h" +#include "lldb/Target/Process.h" +#include "lldb/Target/RegisterContext.h" +#include "lldb/Target/SystemRuntime.h" +#include "lldb/Target/Target.h" +#include "lldb/Target/Thread.h" +#include "lldb/Utility/Args.h" +#include "lldb/Utility/ProcessInfo.h" +#include "lldb/Utility/State.h" +#include "lldb/Utility/Stream.h" + +#include "lldb/API/SBBroadcaster.h" +#include "lldb/API/SBCommandReturnObject.h" +#include "lldb/API/SBDebugger.h" +#include "lldb/API/SBEvent.h" +#include "lldb/API/SBFile.h" +#include "lldb/API/SBFileSpec.h" +#include "lldb/API/SBMemoryRegionInfo.h" +#include "lldb/API/SBMemoryRegionInfoList.h" +#include "lldb/API/SBStream.h" +#include "lldb/API/SBStringList.h" +#include "lldb/API/SBStructuredData.h" +#include "lldb/API/SBThread.h" +#include "lldb/API/SBThreadCollection.h" +#include "lldb/API/SBTrace.h" +#include "lldb/API/SBTraceOptions.h" +#include "lldb/API/SBUnixSignals.h" + +using namespace lldb; +using namespace lldb_private; + +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) { + LLDB_RECORD_CONSTRUCTOR(SBProcess, (const lldb::SBProcess &), rhs); +} + +SBProcess::SBProcess(const lldb::ProcessSP &process_sp) + : m_opaque_wp(process_sp) { + LLDB_RECORD_CONSTRUCTOR(SBProcess, (const lldb::ProcessSP &), process_sp); +} + +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 LLDB_RECORD_RESULT(*this); +} + +// Destructor +SBProcess::~SBProcess() = default; + +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(); + } + return "<Unknown>"; +} + +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(); + } + return "<Unknown>"; +} + +lldb::ProcessSP SBProcess::GetSP() const { return m_opaque_wp.lock(); } + +void SBProcess::SetSP(const ProcessSP &process_sp) { m_opaque_wp = process_sp; } + +void SBProcess::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBProcess, Clear); + + m_opaque_wp.reset(); +} + +bool SBProcess::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcess, IsValid); + return this->operator bool(); +} +SBProcess::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcess, operator bool); + + ProcessSP process_sp(m_opaque_wp.lock()); + return ((bool)process_sp && process_sp->IsValid()); +} + +bool SBProcess::RemoteLaunch(char const **argv, char const **envp, + const char *stdin_path, const char *stdout_path, + const char *stderr_path, + 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); + + ProcessSP process_sp(GetSP()); + if (process_sp) { + std::lock_guard<std::recursive_mutex> guard( + process_sp->GetTarget().GetAPIMutex()); + if (process_sp->GetState() == eStateConnected) { + if (stop_at_entry) + launch_flags |= eLaunchFlagStopAtEntry; + ProcessLaunchInfo launch_info(FileSpec(stdin_path), FileSpec(stdout_path), + FileSpec(stderr_path), + FileSpec(working_directory), launch_flags); + Module *exe_module = process_sp->GetTarget().GetExecutableModulePointer(); + if (exe_module) + launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), true); + if (argv) + launch_info.GetArguments().AppendArguments(argv); + if (envp) + launch_info.GetEnvironment() = Environment(envp); + error.SetError(process_sp->Launch(launch_info)); + } else { + error.SetErrorString("must be in eStateConnected to call RemoteLaunch"); + } + } else { + error.SetErrorString("unable to attach pid"); + } + + return error.Success(); +} + +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( + process_sp->GetTarget().GetAPIMutex()); + if (process_sp->GetState() == eStateConnected) { + ProcessAttachInfo attach_info; + attach_info.SetProcessID(pid); + error.SetError(process_sp->Attach(attach_info)); + } else { + error.SetErrorString( + "must be in eStateConnected to call RemoteAttachToProcessWithID"); + } + } else { + error.SetErrorString("unable to attach pid"); + } + + return error.Success(); +} + +uint32_t SBProcess::GetNumThreads() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumThreads); + + uint32_t num_threads = 0; + ProcessSP process_sp(GetSP()); + if (process_sp) { + Process::StopLocker stop_locker; + + const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock()); + std::lock_guard<std::recursive_mutex> guard( + process_sp->GetTarget().GetAPIMutex()); + num_threads = process_sp->GetThreadList().GetSize(can_update); + } + + return num_threads; +} + +SBThread SBProcess::GetSelectedThread() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBProcess, + GetSelectedThread); + + SBThread sb_thread; + ThreadSP thread_sp; + ProcessSP process_sp(GetSP()); + if (process_sp) { + std::lock_guard<std::recursive_mutex> guard( + process_sp->GetTarget().GetAPIMutex()); + thread_sp = process_sp->GetThreadList().GetSelectedThread(); + sb_thread.SetThread(thread_sp); + } + + 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); + + SBThread sb_thread; + ThreadSP thread_sp; + ProcessSP process_sp(GetSP()); + if (process_sp) { + std::lock_guard<std::recursive_mutex> guard( + process_sp->GetTarget().GetAPIMutex()); + thread_sp = process_sp->CreateOSPluginThread(tid, context); + sb_thread.SetThread(thread_sp); + } + + return LLDB_RECORD_RESULT(sb_thread); +} + +SBTarget SBProcess::GetTarget() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBTarget, SBProcess, GetTarget); + + SBTarget sb_target; + TargetSP target_sp; + ProcessSP process_sp(GetSP()); + if (process_sp) { + target_sp = process_sp->GetTarget().shared_from_this(); + sb_target.SetSP(target_sp); + } + + 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); + + size_t ret_val = 0; + ProcessSP process_sp(GetSP()); + if (process_sp) { + Status error; + ret_val = process_sp->PutSTDIN(src, src_len, error); + } + + return ret_val; +} + +size_t SBProcess::GetSTDOUT(char *dst, size_t dst_len) const { + LLDB_RECORD_CHAR_PTR_METHOD_CONST(size_t, SBProcess, GetSTDOUT, + (char *, size_t), dst, "", dst_len); + + size_t bytes_read = 0; + ProcessSP process_sp(GetSP()); + if (process_sp) { + Status error; + bytes_read = process_sp->GetSTDOUT(dst, dst_len, error); + } + + return bytes_read; +} + +size_t SBProcess::GetSTDERR(char *dst, size_t dst_len) const { + LLDB_RECORD_CHAR_PTR_METHOD_CONST(size_t, SBProcess, GetSTDERR, + (char *, size_t), dst, "", dst_len); + + size_t bytes_read = 0; + ProcessSP process_sp(GetSP()); + if (process_sp) { + Status error; + bytes_read = process_sp->GetSTDERR(dst, dst_len, error); + } + + return bytes_read; +} + +size_t SBProcess::GetAsyncProfileData(char *dst, size_t dst_len) const { + LLDB_RECORD_CHAR_PTR_METHOD_CONST(size_t, SBProcess, GetAsyncProfileData, + (char *, size_t), dst, "", dst_len); + + size_t bytes_read = 0; + ProcessSP process_sp(GetSP()); + if (process_sp) { + Status error; + bytes_read = process_sp->GetAsyncProfileData(dst, dst_len, error); + } + + return bytes_read; +} + +lldb::SBTrace SBProcess::StartTrace(SBTraceOptions &options, + lldb::SBError &error) { + LLDB_RECORD_METHOD(lldb::SBTrace, SBProcess, StartTrace, + (lldb::SBTraceOptions &, lldb::SBError &), options, error); + + ProcessSP process_sp(GetSP()); + error.Clear(); + SBTrace trace_instance; + trace_instance.SetSP(process_sp); + lldb::user_id_t uid = LLDB_INVALID_UID; + + if (!process_sp) { + error.SetErrorString("invalid process"); + } else { + uid = process_sp->StartTrace(*(options.m_traceoptions_sp), error.ref()); + trace_instance.SetTraceUID(uid); + } + return LLDB_RECORD_RESULT(trace_instance); +} + +void SBProcess::ReportEventState(const SBEvent &event, SBFile out) const { + LLDB_RECORD_METHOD_CONST(void, SBProcess, ReportEventState, + (const SBEvent &, SBFile), event, out); + + return ReportEventState(event, out.m_opaque_sp); +} + +void SBProcess::ReportEventState(const SBEvent &event, FILE *out) const { + LLDB_RECORD_METHOD_CONST(void, SBProcess, ReportEventState, + (const lldb::SBEvent &, FILE *), event, out); + FileSP outfile = std::make_shared<NativeFile>(out, false); + return ReportEventState(event, outfile); +} + +void SBProcess::ReportEventState(const SBEvent &event, FileSP out) const { + + LLDB_RECORD_METHOD_CONST(void, SBProcess, ReportEventState, + (const SBEvent &, FileSP), event, out); + + if (!out || !out->IsValid()) + return; + + ProcessSP process_sp(GetSP()); + if (process_sp) { + StreamFile stream(out); + const StateType event_state = SBProcess::GetStateFromEvent(event); + stream.Printf("Process %" PRIu64 " %s\n", + process_sp->GetID(), SBDebugger::StateAsCString(event_state)); + } +} + +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); + char message[1024]; + ::snprintf(message, sizeof(message), "Process %" PRIu64 " %s\n", + process_sp->GetID(), SBDebugger::StateAsCString(event_state)); + + result.AppendMessage(message); + } +} + +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( + process_sp->GetTarget().GetAPIMutex()); + return process_sp->GetThreadList().SetSelectedThreadByID( + thread.GetThreadID()); + } + return false; +} + +bool SBProcess::SetSelectedThreadByID(lldb::tid_t tid) { + LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByID, (lldb::tid_t), + tid); + + + bool ret_val = false; + ProcessSP process_sp(GetSP()); + if (process_sp) { + std::lock_guard<std::recursive_mutex> guard( + process_sp->GetTarget().GetAPIMutex()); + ret_val = process_sp->GetThreadList().SetSelectedThreadByID(tid); + } + + return ret_val; +} + +bool SBProcess::SetSelectedThreadByIndexID(uint32_t index_id) { + LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByIndexID, (uint32_t), + index_id); + + bool ret_val = false; + ProcessSP process_sp(GetSP()); + if (process_sp) { + std::lock_guard<std::recursive_mutex> guard( + process_sp->GetTarget().GetAPIMutex()); + ret_val = process_sp->GetThreadList().SetSelectedThreadByIndexID(index_id); + } + + + return ret_val; +} + +SBThread SBProcess::GetThreadAtIndex(size_t index) { + LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadAtIndex, (size_t), + index); + + SBThread sb_thread; + ThreadSP thread_sp; + ProcessSP process_sp(GetSP()); + if (process_sp) { + Process::StopLocker stop_locker; + const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock()); + std::lock_guard<std::recursive_mutex> guard( + process_sp->GetTarget().GetAPIMutex()); + thread_sp = process_sp->GetThreadList().GetThreadAtIndex(index, can_update); + sb_thread.SetThread(thread_sp); + } + + return LLDB_RECORD_RESULT(sb_thread); +} + +uint32_t SBProcess::GetNumQueues() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumQueues); + + uint32_t num_queues = 0; + ProcessSP process_sp(GetSP()); + if (process_sp) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process_sp->GetRunLock())) { + std::lock_guard<std::recursive_mutex> guard( + process_sp->GetTarget().GetAPIMutex()); + num_queues = process_sp->GetQueueList().GetSize(); + } + } + + return num_queues; +} + +SBQueue SBProcess::GetQueueAtIndex(size_t index) { + LLDB_RECORD_METHOD(lldb::SBQueue, SBProcess, GetQueueAtIndex, (size_t), + index); + + SBQueue sb_queue; + QueueSP queue_sp; + ProcessSP process_sp(GetSP()); + if (process_sp) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process_sp->GetRunLock())) { + std::lock_guard<std::recursive_mutex> guard( + process_sp->GetTarget().GetAPIMutex()); + queue_sp = process_sp->GetQueueList().GetQueueAtIndex(index); + sb_queue.SetQueue(queue_sp); + } + } + + 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( + process_sp->GetTarget().GetAPIMutex()); + if (include_expression_stops) + return process_sp->GetStopID(); + else + return process_sp->GetLastNaturalStopID(); + } + return 0; +} + +SBEvent SBProcess::GetStopEventForStopID(uint32_t stop_id) { + LLDB_RECORD_METHOD(lldb::SBEvent, SBProcess, GetStopEventForStopID, + (uint32_t), stop_id); + + SBEvent sb_event; + EventSP event_sp; + ProcessSP process_sp(GetSP()); + if (process_sp) { + std::lock_guard<std::recursive_mutex> guard( + process_sp->GetTarget().GetAPIMutex()); + event_sp = process_sp->GetStopEventForStopID(stop_id); + sb_event.reset(event_sp); + } + + 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()); + if (process_sp) { + std::lock_guard<std::recursive_mutex> guard( + process_sp->GetTarget().GetAPIMutex()); + ret_val = process_sp->GetState(); + } + + return ret_val; +} + +int SBProcess::GetExitStatus() { + LLDB_RECORD_METHOD_NO_ARGS(int, SBProcess, GetExitStatus); + + int exit_status = 0; + ProcessSP process_sp(GetSP()); + if (process_sp) { + std::lock_guard<std::recursive_mutex> guard( + process_sp->GetTarget().GetAPIMutex()); + exit_status = process_sp->GetExitStatus(); + } + + return exit_status; +} + +const char *SBProcess::GetExitDescription() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetExitDescription); + + const char *exit_desc = nullptr; + ProcessSP process_sp(GetSP()); + if (process_sp) { + std::lock_guard<std::recursive_mutex> guard( + process_sp->GetTarget().GetAPIMutex()); + exit_desc = process_sp->GetExitDescription(); + } + return exit_desc; +} + +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) + ret_val = process_sp->GetID(); + + return ret_val; +} + +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) + ret_val = process_sp->GetUniqueID(); + return ret_val; +} + +ByteOrder SBProcess::GetByteOrder() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ByteOrder, SBProcess, GetByteOrder); + + ByteOrder byteOrder = eByteOrderInvalid; + ProcessSP process_sp(GetSP()); + if (process_sp) + byteOrder = process_sp->GetTarget().GetArchitecture().GetByteOrder(); + + + return byteOrder; +} + +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) + size = process_sp->GetTarget().GetArchitecture().GetAddressByteSize(); + + + return size; +} + +SBError SBProcess::Continue() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Continue); + + SBError sb_error; + ProcessSP process_sp(GetSP()); + + if (process_sp) { + std::lock_guard<std::recursive_mutex> guard( + process_sp->GetTarget().GetAPIMutex()); + + if (process_sp->GetTarget().GetDebugger().GetAsyncExecution()) + sb_error.ref() = process_sp->Resume(); + else + sb_error.ref() = process_sp->ResumeSynchronous(nullptr); + } else + sb_error.SetErrorString("SBProcess is invalid"); + + 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) { + std::lock_guard<std::recursive_mutex> guard( + process_sp->GetTarget().GetAPIMutex()); + sb_error.SetError(process_sp->Destroy(false)); + } else + sb_error.SetErrorString("SBProcess is invalid"); + + 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) { + std::lock_guard<std::recursive_mutex> guard( + process_sp->GetTarget().GetAPIMutex()); + sb_error.SetError(process_sp->Halt()); + } else + sb_error.SetErrorString("SBProcess is invalid"); + + 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) { + std::lock_guard<std::recursive_mutex> guard( + process_sp->GetTarget().GetAPIMutex()); + sb_error.SetError(process_sp->Destroy(true)); + } else + sb_error.SetErrorString("SBProcess is invalid"); + + 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 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) { + std::lock_guard<std::recursive_mutex> guard( + process_sp->GetTarget().GetAPIMutex()); + sb_error.SetError(process_sp->Detach(keep_stopped)); + } else + sb_error.SetErrorString("SBProcess is invalid"); + + 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) { + std::lock_guard<std::recursive_mutex> guard( + process_sp->GetTarget().GetAPIMutex()); + sb_error.SetError(process_sp->Signal(signo)); + } else + sb_error.SetErrorString("SBProcess is invalid"); + + return LLDB_RECORD_RESULT(sb_error); +} + +SBUnixSignals SBProcess::GetUnixSignals() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBUnixSignals, SBProcess, GetUnixSignals); + + 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(); + } +} + +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()); + if (process_sp) { + Process::StopLocker stop_locker; + const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock()); + std::lock_guard<std::recursive_mutex> guard( + process_sp->GetTarget().GetAPIMutex()); + thread_sp = process_sp->GetThreadList().FindThreadByID(tid, can_update); + sb_thread.SetThread(thread_sp); + } + + 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()); + if (process_sp) { + Process::StopLocker stop_locker; + const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock()); + std::lock_guard<std::recursive_mutex> guard( + process_sp->GetTarget().GetAPIMutex()); + thread_sp = + process_sp->GetThreadList().FindThreadByIndexID(index_id, can_update); + sb_thread.SetThread(thread_sp); + } + + return LLDB_RECORD_RESULT(sb_thread); +} + +StateType SBProcess::GetStateFromEvent(const SBEvent &event) { + LLDB_RECORD_STATIC_METHOD(lldb::StateType, SBProcess, GetStateFromEvent, + (const lldb::SBEvent &), event); + + StateType ret_val = Process::ProcessEventData::GetStateFromEvent(event.get()); + + return ret_val; +} + +bool SBProcess::GetRestartedFromEvent(const SBEvent &event) { + LLDB_RECORD_STATIC_METHOD(bool, SBProcess, GetRestartedFromEvent, + (const lldb::SBEvent &), event); + + bool ret_val = Process::ProcessEventData::GetRestartedFromEvent(event.get()); + + return ret_val; +} + +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) { + // StructuredData events also know the process they come from. Try that. + process_sp = EventDataStructuredData::GetProcessFromEvent(event.get()); + } + + 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) { + 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() == + EventDataStructuredData::GetFlavorString()); +} + +SBBroadcaster SBProcess::GetBroadcaster() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBProcess, + GetBroadcaster); + + + ProcessSP process_sp(GetSP()); + + SBBroadcaster broadcaster(process_sp.get(), false); + + + return LLDB_RECORD_RESULT(broadcaster); +} + +const char *SBProcess::GetBroadcasterClass() { + LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBProcess, + GetBroadcasterClass); + + return Process::GetStaticBroadcasterClass().AsCString(); +} + +size_t SBProcess::ReadMemory(addr_t addr, void *dst, size_t dst_len, + SBError &sb_error) { + LLDB_RECORD_DUMMY(size_t, SBProcess, ReadMemory, + (lldb::addr_t, void *, size_t, lldb::SBError &), addr, dst, + dst_len, sb_error); + + size_t bytes_read = 0; + + ProcessSP process_sp(GetSP()); + + + if (process_sp) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process_sp->GetRunLock())) { + std::lock_guard<std::recursive_mutex> guard( + process_sp->GetTarget().GetAPIMutex()); + bytes_read = process_sp->ReadMemory(addr, dst, dst_len, sb_error.ref()); + } else { + sb_error.SetErrorString("process is running"); + } + } else { + sb_error.SetErrorString("SBProcess is invalid"); + } + + return bytes_read; +} + +size_t SBProcess::ReadCStringFromMemory(addr_t addr, void *buf, size_t size, + lldb::SBError &sb_error) { + LLDB_RECORD_DUMMY(size_t, SBProcess, ReadCStringFromMemory, + (lldb::addr_t, void *, size_t, lldb::SBError &), addr, buf, + size, sb_error); + + size_t bytes_read = 0; + ProcessSP process_sp(GetSP()); + if (process_sp) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process_sp->GetRunLock())) { + std::lock_guard<std::recursive_mutex> guard( + process_sp->GetTarget().GetAPIMutex()); + bytes_read = process_sp->ReadCStringFromMemory(addr, (char *)buf, size, + sb_error.ref()); + } else { + sb_error.SetErrorString("process is running"); + } + } else { + sb_error.SetErrorString("SBProcess is invalid"); + } + return bytes_read; +} + +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) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process_sp->GetRunLock())) { + std::lock_guard<std::recursive_mutex> guard( + process_sp->GetTarget().GetAPIMutex()); + value = process_sp->ReadUnsignedIntegerFromMemory(addr, byte_size, 0, + sb_error.ref()); + } else { + sb_error.SetErrorString("process is running"); + } + } else { + sb_error.SetErrorString("SBProcess is invalid"); + } + return value; +} + +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) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process_sp->GetRunLock())) { + std::lock_guard<std::recursive_mutex> guard( + process_sp->GetTarget().GetAPIMutex()); + ptr = process_sp->ReadPointerFromMemory(addr, sb_error.ref()); + } else { + sb_error.SetErrorString("process is running"); + } + } else { + sb_error.SetErrorString("SBProcess is invalid"); + } + return ptr; +} + +size_t SBProcess::WriteMemory(addr_t addr, const void *src, size_t src_len, + SBError &sb_error) { + LLDB_RECORD_DUMMY(size_t, SBProcess, WriteMemory, + (lldb::addr_t, const void *, size_t, lldb::SBError &), addr, + src, src_len, sb_error); + + size_t bytes_written = 0; + + ProcessSP process_sp(GetSP()); + + if (process_sp) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process_sp->GetRunLock())) { + std::lock_guard<std::recursive_mutex> guard( + process_sp->GetTarget().GetAPIMutex()); + bytes_written = + process_sp->WriteMemory(addr, src, src_len, sb_error.ref()); + } else { + sb_error.SetErrorString("process is running"); + } + } + + return bytes_written; +} + +bool SBProcess::GetDescription(SBStream &description) { + LLDB_RECORD_METHOD(bool, SBProcess, GetDescription, (lldb::SBStream &), + description); + + Stream &strm = description.ref(); + + ProcessSP process_sp(GetSP()); + if (process_sp) { + char path[PATH_MAX]; + GetTarget().GetExecutable().GetPath(path, sizeof(path)); + Module *exe_module = process_sp->GetTarget().GetExecutableModulePointer(); + const char *exe_name = nullptr; + if (exe_module) + exe_name = exe_module->GetFileSpec().GetFilename().AsCString(); + + strm.Printf("SBProcess: pid = %" PRIu64 ", state = %s, threads = %d%s%s", + process_sp->GetID(), lldb_private::StateAsCString(GetState()), + GetNumThreads(), exe_name ? ", executable = " : "", + exe_name ? exe_name : ""); + } else + strm.PutCString("No value"); + + return true; +} + +SBStructuredData SBProcess::GetExtendedCrashInformation() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStructuredData, SBProcess, + GetExtendedCrashInformation); + SBStructuredData data; + ProcessSP process_sp(GetSP()); + if (!process_sp) + return LLDB_RECORD_RESULT(data); + + PlatformSP platform_sp = process_sp->GetTarget().GetPlatform(); + + if (!platform_sp) + return LLDB_RECORD_RESULT(data); + + auto expected_data = + platform_sp->FetchExtendedCrashInformation(*process_sp.get()); + + if (!expected_data) + return LLDB_RECORD_RESULT(data); + + StructuredData::ObjectSP fetched_data = *expected_data; + data.m_impl_up->SetObjectSP(fetched_data); + return LLDB_RECORD_RESULT(data); +} + +uint32_t +SBProcess::GetNumSupportedHardwareWatchpoints(lldb::SBError &sb_error) const { + LLDB_RECORD_METHOD_CONST(uint32_t, SBProcess, + GetNumSupportedHardwareWatchpoints, + (lldb::SBError &), sb_error); + + uint32_t num = 0; + ProcessSP process_sp(GetSP()); + if (process_sp) { + std::lock_guard<std::recursive_mutex> guard( + process_sp->GetTarget().GetAPIMutex()); + sb_error.SetError(process_sp->GetWatchpointSupportInfo(num)); + } else { + sb_error.SetErrorString("SBProcess is invalid"); + } + return num; +} + +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); + + ProcessSP process_sp(GetSP()); + if (process_sp) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process_sp->GetRunLock())) { + std::lock_guard<std::recursive_mutex> guard( + process_sp->GetTarget().GetAPIMutex()); + PlatformSP platform_sp = process_sp->GetTarget().GetPlatform(); + return platform_sp->LoadImage(process_sp.get(), *sb_local_image_spec, + *sb_remote_image_spec, sb_error.ref()); + } else { + sb_error.SetErrorString("process is running"); + } + } else { + sb_error.SetErrorString("process is invalid"); + } + return LLDB_INVALID_IMAGE_TOKEN; +} + +uint32_t SBProcess::LoadImageUsingPaths(const lldb::SBFileSpec &image_spec, + SBStringList &paths, + lldb::SBFileSpec &loaded_path, + lldb::SBError &error) { + LLDB_RECORD_METHOD(uint32_t, SBProcess, LoadImageUsingPaths, + (const lldb::SBFileSpec &, lldb::SBStringList &, + lldb::SBFileSpec &, lldb::SBError &), + image_spec, paths, loaded_path, error); + + ProcessSP process_sp(GetSP()); + if (process_sp) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process_sp->GetRunLock())) { + std::lock_guard<std::recursive_mutex> guard( + process_sp->GetTarget().GetAPIMutex()); + PlatformSP platform_sp = process_sp->GetTarget().GetPlatform(); + size_t num_paths = paths.GetSize(); + std::vector<std::string> paths_vec; + paths_vec.reserve(num_paths); + for (size_t i = 0; i < num_paths; i++) + paths_vec.push_back(paths.GetStringAtIndex(i)); + FileSpec loaded_spec; + + uint32_t token = platform_sp->LoadImageUsingPaths( + process_sp.get(), *image_spec, paths_vec, error.ref(), &loaded_spec); + if (token != LLDB_INVALID_IMAGE_TOKEN) + loaded_path = loaded_spec; + return token; + } else { + error.SetErrorString("process is running"); + } + } else { + error.SetErrorString("process is invalid"); + } + + return LLDB_INVALID_IMAGE_TOKEN; +} + +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) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process_sp->GetRunLock())) { + std::lock_guard<std::recursive_mutex> guard( + process_sp->GetTarget().GetAPIMutex()); + PlatformSP platform_sp = process_sp->GetTarget().GetPlatform(); + sb_error.SetError( + platform_sp->UnloadImage(process_sp.get(), image_token)); + } else { + sb_error.SetErrorString("process is running"); + } + } else + sb_error.SetErrorString("invalid process"); + 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) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process_sp->GetRunLock())) { + std::lock_guard<std::recursive_mutex> guard( + process_sp->GetTarget().GetAPIMutex()); + sb_error.SetError(process_sp->SendEventData(event_data)); + } else { + sb_error.SetErrorString("process is running"); + } + } else + sb_error.SetErrorString("invalid process"); + 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(); + return runtime->GetExtendedBacktraceTypes().size(); + } + return 0; +} + +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(); + const std::vector<ConstString> &names = + runtime->GetExtendedBacktraceTypes(); + if (idx < names.size()) { + return names[idx].AsCString(); + } + } + return nullptr; +} + +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 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; + + std::lock_guard<std::recursive_mutex> guard( + process_sp->GetTarget().GetAPIMutex()); + + InstrumentationRuntimeSP runtime_sp = + process_sp->GetInstrumentationRuntime(type); + + if (!runtime_sp.get()) + return false; + + return runtime_sp->IsActive(); +} + +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 LLDB_RECORD_RESULT(error); + } + + std::lock_guard<std::recursive_mutex> guard( + process_sp->GetTarget().GetAPIMutex()); + + if (process_sp->GetState() != eStateStopped) { + error.SetErrorString("the process is not stopped"); + return LLDB_RECORD_RESULT(error); + } + + FileSpec core_file(file_name); + error.ref() = PluginManager::SaveCore(process_sp, core_file); + 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) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process_sp->GetRunLock())) { + std::lock_guard<std::recursive_mutex> guard( + process_sp->GetTarget().GetAPIMutex()); + + sb_error.ref() = + process_sp->GetMemoryRegionInfo(load_addr, sb_region_info.ref()); + } else { + sb_error.SetErrorString("process is running"); + } + } else { + sb_error.SetErrorString("SBProcess is invalid"); + } + 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()); + Process::StopLocker stop_locker; + if (process_sp && stop_locker.TryLock(&process_sp->GetRunLock())) { + std::lock_guard<std::recursive_mutex> guard( + process_sp->GetTarget().GetAPIMutex()); + + process_sp->GetMemoryRegions(sb_region_list.ref()); + } + + 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 LLDB_RECORD_RESULT(sb_proc_info); +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBProcess>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBProcess, ()); + LLDB_REGISTER_CONSTRUCTOR(SBProcess, (const lldb::SBProcess &)); + LLDB_REGISTER_CONSTRUCTOR(SBProcess, (const lldb::ProcessSP &)); + LLDB_REGISTER_METHOD(const lldb::SBProcess &, + SBProcess, operator=,(const lldb::SBProcess &)); + LLDB_REGISTER_STATIC_METHOD(const char *, SBProcess, + GetBroadcasterClassName, ()); + LLDB_REGISTER_METHOD(const char *, SBProcess, GetPluginName, ()); + LLDB_REGISTER_METHOD(const char *, SBProcess, GetShortPluginName, ()); + LLDB_REGISTER_METHOD(void, SBProcess, Clear, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBProcess, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBProcess, operator bool, ()); + LLDB_REGISTER_METHOD(bool, SBProcess, RemoteLaunch, + (const char **, const char **, const char *, + const char *, const char *, const char *, uint32_t, + bool, lldb::SBError &)); + LLDB_REGISTER_METHOD(bool, SBProcess, RemoteAttachToProcessWithID, + (lldb::pid_t, lldb::SBError &)); + LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetNumThreads, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBProcess, GetSelectedThread, + ()); + LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, CreateOSPluginThread, + (lldb::tid_t, lldb::addr_t)); + LLDB_REGISTER_METHOD_CONST(lldb::SBTarget, SBProcess, GetTarget, ()); + LLDB_REGISTER_METHOD(size_t, SBProcess, PutSTDIN, (const char *, size_t)); + LLDB_REGISTER_METHOD(lldb::SBTrace, SBProcess, StartTrace, + (lldb::SBTraceOptions &, lldb::SBError &)); + LLDB_REGISTER_METHOD_CONST(void, SBProcess, ReportEventState, + (const lldb::SBEvent &, FILE *)); + LLDB_REGISTER_METHOD_CONST(void, SBProcess, ReportEventState, + (const lldb::SBEvent &, FileSP)); + LLDB_REGISTER_METHOD_CONST(void, SBProcess, ReportEventState, + (const lldb::SBEvent &, SBFile)); + LLDB_REGISTER_METHOD( + void, SBProcess, AppendEventStateReport, + (const lldb::SBEvent &, lldb::SBCommandReturnObject &)); + LLDB_REGISTER_METHOD(bool, SBProcess, SetSelectedThread, + (const lldb::SBThread &)); + LLDB_REGISTER_METHOD(bool, SBProcess, SetSelectedThreadByID, (lldb::tid_t)); + LLDB_REGISTER_METHOD(bool, SBProcess, SetSelectedThreadByIndexID, + (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, GetThreadAtIndex, (size_t)); + LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetNumQueues, ()); + LLDB_REGISTER_METHOD(lldb::SBQueue, SBProcess, GetQueueAtIndex, (size_t)); + LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetStopID, (bool)); + LLDB_REGISTER_METHOD(lldb::SBEvent, SBProcess, GetStopEventForStopID, + (uint32_t)); + LLDB_REGISTER_METHOD(lldb::StateType, SBProcess, GetState, ()); + LLDB_REGISTER_METHOD(int, SBProcess, GetExitStatus, ()); + LLDB_REGISTER_METHOD(const char *, SBProcess, GetExitDescription, ()); + LLDB_REGISTER_METHOD(lldb::pid_t, SBProcess, GetProcessID, ()); + LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetUniqueID, ()); + LLDB_REGISTER_METHOD_CONST(lldb::ByteOrder, SBProcess, GetByteOrder, ()); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBProcess, GetAddressByteSize, ()); + LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Continue, ()); + LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Destroy, ()); + LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Stop, ()); + LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Kill, ()); + LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Detach, ()); + LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Detach, (bool)); + LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Signal, (int)); + LLDB_REGISTER_METHOD(lldb::SBUnixSignals, SBProcess, GetUnixSignals, ()); + LLDB_REGISTER_METHOD(void, SBProcess, SendAsyncInterrupt, ()); + LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, GetThreadByID, + (lldb::tid_t)); + LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, GetThreadByIndexID, + (uint32_t)); + LLDB_REGISTER_STATIC_METHOD(lldb::StateType, SBProcess, GetStateFromEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, GetRestartedFromEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_STATIC_METHOD(size_t, SBProcess, + GetNumRestartedReasonsFromEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_STATIC_METHOD(const char *, SBProcess, + GetRestartedReasonAtIndexFromEvent, + (const lldb::SBEvent &, size_t)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBProcess, SBProcess, GetProcessFromEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, GetInterruptedFromEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBStructuredData, SBProcess, + GetStructuredDataFromEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, EventIsProcessEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, EventIsStructuredDataEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_METHOD_CONST(lldb::SBBroadcaster, SBProcess, GetBroadcaster, + ()); + LLDB_REGISTER_STATIC_METHOD(const char *, SBProcess, GetBroadcasterClass, + ()); + LLDB_REGISTER_METHOD(uint64_t, SBProcess, ReadUnsignedFromMemory, + (lldb::addr_t, uint32_t, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::addr_t, SBProcess, ReadPointerFromMemory, + (lldb::addr_t, lldb::SBError &)); + LLDB_REGISTER_METHOD(bool, SBProcess, GetDescription, (lldb::SBStream &)); + LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBProcess, + GetExtendedCrashInformation, ()); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBProcess, + GetNumSupportedHardwareWatchpoints, + (lldb::SBError &)); + LLDB_REGISTER_METHOD(uint32_t, SBProcess, LoadImage, + (lldb::SBFileSpec &, lldb::SBError &)); + LLDB_REGISTER_METHOD( + uint32_t, SBProcess, LoadImage, + (const lldb::SBFileSpec &, const lldb::SBFileSpec &, lldb::SBError &)); + LLDB_REGISTER_METHOD(uint32_t, SBProcess, LoadImageUsingPaths, + (const lldb::SBFileSpec &, lldb::SBStringList &, + lldb::SBFileSpec &, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, UnloadImage, (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, SendEventData, + (const char *)); + LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetNumExtendedBacktraceTypes, ()); + LLDB_REGISTER_METHOD(const char *, SBProcess, + GetExtendedBacktraceTypeAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBThreadCollection, SBProcess, GetHistoryThreads, + (lldb::addr_t)); + LLDB_REGISTER_METHOD(bool, SBProcess, IsInstrumentationRuntimePresent, + (lldb::InstrumentationRuntimeType)); + LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, SaveCore, (const char *)); + LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, GetMemoryRegionInfo, + (lldb::addr_t, lldb::SBMemoryRegionInfo &)); + LLDB_REGISTER_METHOD(lldb::SBMemoryRegionInfoList, SBProcess, + GetMemoryRegions, ()); + LLDB_REGISTER_METHOD(lldb::SBProcessInfo, SBProcess, GetProcessInfo, ()); + + LLDB_REGISTER_CHAR_PTR_METHOD_CONST(size_t, SBProcess, GetSTDOUT); + LLDB_REGISTER_CHAR_PTR_METHOD_CONST(size_t, SBProcess, GetSTDERR); + LLDB_REGISTER_CHAR_PTR_METHOD_CONST(size_t, SBProcess, GetAsyncProfileData); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBProcessInfo.cpp b/contrib/llvm-project/lldb/source/API/SBProcessInfo.cpp new file mode 100644 index 000000000000..29a9c7b24b5a --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBProcessInfo.cpp @@ -0,0 +1,210 @@ +//===-- SBProcessInfo.cpp -------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBProcessInfo.h" +#include "SBReproducerPrivate.h" +#include "Utils.h" +#include "lldb/API/SBFileSpec.h" +#include "lldb/Utility/ProcessInfo.h" + +using namespace lldb; +using namespace lldb_private; + +SBProcessInfo::SBProcessInfo() : m_opaque_up() { + 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() = default; + +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 LLDB_RECORD_RESULT(*this); +} + +ProcessInstanceInfo &SBProcessInfo::ref() { + if (m_opaque_up == nullptr) { + m_opaque_up = std::make_unique<ProcessInstanceInfo>(); + } + return *m_opaque_up; +} + +void SBProcessInfo::SetProcessInfo(const ProcessInstanceInfo &proc_info_ref) { + ref() = proc_info_ref; +} + +bool SBProcessInfo::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcessInfo, IsValid); + return this->operator bool(); +} +SBProcessInfo::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcessInfo, operator bool); + + 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(); + } + return name; +} + +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 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(); + } + return proc_id; +} + +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(); + } + return user_id; +} + +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(); + } + return group_id; +} + +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(); + } + return is_valid; +} + +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(); + } + return is_valid; +} + +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(); + } + return user_id; +} + +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(); + } + return group_id; +} + +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(); + } + return is_valid; +} + +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(); + } + return is_valid; +} + +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(); + } + return proc_id; +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBProcessInfo>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBProcessInfo, ()); + LLDB_REGISTER_CONSTRUCTOR(SBProcessInfo, (const lldb::SBProcessInfo &)); + LLDB_REGISTER_METHOD( + lldb::SBProcessInfo &, + SBProcessInfo, operator=,(const lldb::SBProcessInfo &)); + LLDB_REGISTER_METHOD_CONST(bool, SBProcessInfo, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBProcessInfo, operator bool, ()); + LLDB_REGISTER_METHOD(const char *, SBProcessInfo, GetName, ()); + LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBProcessInfo, GetExecutableFile, + ()); + LLDB_REGISTER_METHOD(lldb::pid_t, SBProcessInfo, GetProcessID, ()); + LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetUserID, ()); + LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetGroupID, ()); + LLDB_REGISTER_METHOD(bool, SBProcessInfo, UserIDIsValid, ()); + LLDB_REGISTER_METHOD(bool, SBProcessInfo, GroupIDIsValid, ()); + LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetEffectiveUserID, ()); + LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetEffectiveGroupID, ()); + LLDB_REGISTER_METHOD(bool, SBProcessInfo, EffectiveUserIDIsValid, ()); + LLDB_REGISTER_METHOD(bool, SBProcessInfo, EffectiveGroupIDIsValid, ()); + LLDB_REGISTER_METHOD(lldb::pid_t, SBProcessInfo, GetParentProcessID, ()); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBQueue.cpp b/contrib/llvm-project/lldb/source/API/SBQueue.cpp new file mode 100644 index 000000000000..2e6571392ea1 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBQueue.cpp @@ -0,0 +1,359 @@ +//===-- SBQueue.cpp -------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include <inttypes.h> + +#include "SBReproducerPrivate.h" +#include "lldb/API/SBQueue.h" + +#include "lldb/API/SBProcess.h" +#include "lldb/API/SBQueueItem.h" +#include "lldb/API/SBThread.h" + +#include "lldb/Target/Process.h" +#include "lldb/Target/Queue.h" +#include "lldb/Target/QueueItem.h" +#include "lldb/Target/Thread.h" + +using namespace lldb; +using namespace lldb_private; + +namespace lldb_private { + +class QueueImpl { +public: + QueueImpl() + : m_queue_wp(), m_threads(), m_thread_list_fetched(false), + m_pending_items(), m_pending_items_fetched(false) {} + + QueueImpl(const lldb::QueueSP &queue_sp) + : m_queue_wp(), m_threads(), m_thread_list_fetched(false), + m_pending_items(), m_pending_items_fetched(false) { + m_queue_wp = queue_sp; + } + + QueueImpl(const QueueImpl &rhs) { + if (&rhs == this) + return; + m_queue_wp = rhs.m_queue_wp; + m_threads = rhs.m_threads; + m_thread_list_fetched = rhs.m_thread_list_fetched; + m_pending_items = rhs.m_pending_items; + m_pending_items_fetched = rhs.m_pending_items_fetched; + } + + ~QueueImpl() = default; + + bool IsValid() { return m_queue_wp.lock() != nullptr; } + + void Clear() { + m_queue_wp.reset(); + m_thread_list_fetched = false; + m_threads.clear(); + m_pending_items_fetched = false; + m_pending_items.clear(); + } + + void SetQueue(const lldb::QueueSP &queue_sp) { + Clear(); + m_queue_wp = queue_sp; + } + + lldb::queue_id_t GetQueueID() const { + lldb::queue_id_t result = LLDB_INVALID_QUEUE_ID; + lldb::QueueSP queue_sp = m_queue_wp.lock(); + if (queue_sp) { + result = queue_sp->GetID(); + } + return result; + } + + uint32_t GetIndexID() const { + uint32_t result = LLDB_INVALID_INDEX32; + lldb::QueueSP queue_sp = m_queue_wp.lock(); + if (queue_sp) { + result = queue_sp->GetIndexID(); + } + return result; + } + + const char *GetName() const { + const char *name = nullptr; + lldb::QueueSP queue_sp = m_queue_wp.lock(); + if (queue_sp.get()) { + name = queue_sp->GetName(); + } + return name; + } + + void FetchThreads() { + if (!m_thread_list_fetched) { + lldb::QueueSP queue_sp = m_queue_wp.lock(); + if (queue_sp) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&queue_sp->GetProcess()->GetRunLock())) { + const std::vector<ThreadSP> thread_list(queue_sp->GetThreads()); + m_thread_list_fetched = true; + const uint32_t num_threads = thread_list.size(); + for (uint32_t idx = 0; idx < num_threads; ++idx) { + ThreadSP thread_sp = thread_list[idx]; + if (thread_sp && thread_sp->IsValid()) { + m_threads.push_back(thread_sp); + } + } + } + } + } + } + + void FetchItems() { + if (!m_pending_items_fetched) { + QueueSP queue_sp = m_queue_wp.lock(); + if (queue_sp) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&queue_sp->GetProcess()->GetRunLock())) { + const std::vector<QueueItemSP> queue_items( + queue_sp->GetPendingItems()); + m_pending_items_fetched = true; + const uint32_t num_pending_items = queue_items.size(); + for (uint32_t idx = 0; idx < num_pending_items; ++idx) { + QueueItemSP item = queue_items[idx]; + if (item && item->IsValid()) { + m_pending_items.push_back(item); + } + } + } + } + } + } + + uint32_t GetNumThreads() { + uint32_t result = 0; + + FetchThreads(); + if (m_thread_list_fetched) { + result = m_threads.size(); + } + return result; + } + + lldb::SBThread GetThreadAtIndex(uint32_t idx) { + FetchThreads(); + + SBThread sb_thread; + QueueSP queue_sp = m_queue_wp.lock(); + if (queue_sp && idx < m_threads.size()) { + ProcessSP process_sp = queue_sp->GetProcess(); + if (process_sp) { + ThreadSP thread_sp = m_threads[idx].lock(); + if (thread_sp) { + sb_thread.SetThread(thread_sp); + } + } + } + return sb_thread; + } + + uint32_t GetNumPendingItems() { + uint32_t result = 0; + + QueueSP queue_sp = m_queue_wp.lock(); + if (!m_pending_items_fetched && queue_sp) { + result = queue_sp->GetNumPendingWorkItems(); + } else { + result = m_pending_items.size(); + } + return result; + } + + lldb::SBQueueItem GetPendingItemAtIndex(uint32_t idx) { + SBQueueItem result; + FetchItems(); + if (m_pending_items_fetched && idx < m_pending_items.size()) { + result.SetQueueItem(m_pending_items[idx]); + } + return result; + } + + uint32_t GetNumRunningItems() { + uint32_t result = 0; + QueueSP queue_sp = m_queue_wp.lock(); + if (queue_sp) + result = queue_sp->GetNumRunningWorkItems(); + return result; + } + + lldb::SBProcess GetProcess() { + SBProcess result; + QueueSP queue_sp = m_queue_wp.lock(); + if (queue_sp) { + result.SetSP(queue_sp->GetProcess()); + } + return result; + } + + lldb::QueueKind GetKind() { + lldb::QueueKind kind = eQueueKindUnknown; + QueueSP queue_sp = m_queue_wp.lock(); + if (queue_sp) + kind = queue_sp->GetKind(); + + return kind; + } + +private: + lldb::QueueWP m_queue_wp; + std::vector<lldb::ThreadWP> + m_threads; // threads currently executing this queue's items + bool + m_thread_list_fetched; // have we tried to fetch the threads list already? + std::vector<lldb::QueueItemSP> m_pending_items; // items currently enqueued + bool m_pending_items_fetched; // have we tried to fetch the item list already? +}; +} + +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)) { + 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; + + m_opaque_sp = rhs.m_opaque_sp; +} + +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 LLDB_RECORD_RESULT(*this); +} + +SBQueue::~SBQueue() = default; + +bool SBQueue::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBQueue, IsValid); + return this->operator bool(); +} +SBQueue::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBQueue, operator bool); + + return m_opaque_sp->IsValid(); +} + +void SBQueue::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBQueue, Clear); + + m_opaque_sp->Clear(); +} + +void SBQueue::SetQueue(const QueueSP &queue_sp) { + m_opaque_sp->SetQueue(queue_sp); +} + +lldb::queue_id_t SBQueue::GetQueueID() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::queue_id_t, SBQueue, GetQueueID); + + return m_opaque_sp->GetQueueID(); +} + +uint32_t SBQueue::GetIndexID() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBQueue, GetIndexID); + + uint32_t index_id = m_opaque_sp->GetIndexID(); + return index_id; +} + +const char *SBQueue::GetName() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBQueue, GetName); + + return m_opaque_sp->GetName(); +} + +uint32_t SBQueue::GetNumThreads() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBQueue, GetNumThreads); + + return m_opaque_sp->GetNumThreads(); +} + +SBThread SBQueue::GetThreadAtIndex(uint32_t idx) { + LLDB_RECORD_METHOD(lldb::SBThread, SBQueue, GetThreadAtIndex, (uint32_t), + idx); + + SBThread th = m_opaque_sp->GetThreadAtIndex(idx); + return LLDB_RECORD_RESULT(th); +} + +uint32_t SBQueue::GetNumPendingItems() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBQueue, GetNumPendingItems); + + return m_opaque_sp->GetNumPendingItems(); +} + +SBQueueItem SBQueue::GetPendingItemAtIndex(uint32_t idx) { + LLDB_RECORD_METHOD(lldb::SBQueueItem, SBQueue, GetPendingItemAtIndex, + (uint32_t), idx); + + return LLDB_RECORD_RESULT(m_opaque_sp->GetPendingItemAtIndex(idx)); +} + +uint32_t SBQueue::GetNumRunningItems() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBQueue, GetNumRunningItems); + + return m_opaque_sp->GetNumRunningItems(); +} + +SBProcess SBQueue::GetProcess() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBQueue, GetProcess); + + 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(); +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBQueue>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBQueue, ()); + LLDB_REGISTER_CONSTRUCTOR(SBQueue, (const lldb::QueueSP &)); + LLDB_REGISTER_CONSTRUCTOR(SBQueue, (const lldb::SBQueue &)); + LLDB_REGISTER_METHOD(const lldb::SBQueue &, + SBQueue, operator=,(const lldb::SBQueue &)); + LLDB_REGISTER_METHOD_CONST(bool, SBQueue, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBQueue, operator bool, ()); + LLDB_REGISTER_METHOD(void, SBQueue, Clear, ()); + LLDB_REGISTER_METHOD_CONST(lldb::queue_id_t, SBQueue, GetQueueID, ()); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBQueue, GetIndexID, ()); + LLDB_REGISTER_METHOD_CONST(const char *, SBQueue, GetName, ()); + LLDB_REGISTER_METHOD(uint32_t, SBQueue, GetNumThreads, ()); + LLDB_REGISTER_METHOD(lldb::SBThread, SBQueue, GetThreadAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(uint32_t, SBQueue, GetNumPendingItems, ()); + LLDB_REGISTER_METHOD(lldb::SBQueueItem, SBQueue, GetPendingItemAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD(uint32_t, SBQueue, GetNumRunningItems, ()); + LLDB_REGISTER_METHOD(lldb::SBProcess, SBQueue, GetProcess, ()); + LLDB_REGISTER_METHOD(lldb::QueueKind, SBQueue, GetKind, ()); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBQueueItem.cpp b/contrib/llvm-project/lldb/source/API/SBQueueItem.cpp new file mode 100644 index 000000000000..0f92e2e04126 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBQueueItem.cpp @@ -0,0 +1,140 @@ +//===-- SBQueueItem.cpp ---------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/lldb-forward.h" + +#include "SBReproducerPrivate.h" +#include "lldb/API/SBAddress.h" +#include "lldb/API/SBQueueItem.h" +#include "lldb/API/SBThread.h" +#include "lldb/Core/Address.h" +#include "lldb/Target/Process.h" +#include "lldb/Target/QueueItem.h" +#include "lldb/Target/Thread.h" + +using namespace lldb; +using namespace lldb_private; + +// Constructors +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) { + LLDB_RECORD_CONSTRUCTOR(SBQueueItem, (const lldb::QueueItemSP &), + queue_item_sp); +} + +// Destructor +SBQueueItem::~SBQueueItem() { m_queue_item_sp.reset(); } + +bool SBQueueItem::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBQueueItem, IsValid); + return this->operator bool(); +} +SBQueueItem::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBQueueItem, operator bool); + + return m_queue_item_sp.get() != nullptr; +} + +void SBQueueItem::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBQueueItem, Clear); + + m_queue_item_sp.reset(); +} + +void SBQueueItem::SetQueueItem(const QueueItemSP &queue_item_sp) { + LLDB_RECORD_METHOD(void, SBQueueItem, SetQueueItem, + (const lldb::QueueItemSP &), queue_item_sp); + + 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; + if (m_queue_item_sp) { + result = m_queue_item_sp->GetKind(); + } + return result; +} + +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; + if (m_queue_item_sp) { + result.SetAddress(&m_queue_item_sp->GetAddress()); + } + 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; + if (m_queue_item_sp) { + ProcessSP process_sp = m_queue_item_sp->GetProcessSP(); + Process::StopLocker stop_locker; + if (process_sp && stop_locker.TryLock(&process_sp->GetRunLock())) { + ThreadSP thread_sp; + ConstString type_const(type); + thread_sp = m_queue_item_sp->GetExtendedBacktraceThread(type_const); + if (thread_sp) { + // Save this in the Process' ExtendedThreadList so a strong pointer + // retains the object + process_sp->GetExtendedThreadList().AddThread(thread_sp); + result.SetThread(thread_sp); + } + } + } + return LLDB_RECORD_RESULT(result); +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBQueueItem>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBQueueItem, ()); + LLDB_REGISTER_CONSTRUCTOR(SBQueueItem, (const lldb::QueueItemSP &)); + LLDB_REGISTER_METHOD_CONST(bool, SBQueueItem, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBQueueItem, operator bool, ()); + LLDB_REGISTER_METHOD(void, SBQueueItem, Clear, ()); + LLDB_REGISTER_METHOD(void, SBQueueItem, SetQueueItem, + (const lldb::QueueItemSP &)); + LLDB_REGISTER_METHOD_CONST(lldb::QueueItemKind, SBQueueItem, GetKind, ()); + LLDB_REGISTER_METHOD(void, SBQueueItem, SetKind, (lldb::QueueItemKind)); + LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBQueueItem, GetAddress, ()); + LLDB_REGISTER_METHOD(void, SBQueueItem, SetAddress, (lldb::SBAddress)); + LLDB_REGISTER_METHOD(lldb::SBThread, SBQueueItem, + GetExtendedBacktraceThread, (const char *)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBReproducer.cpp b/contrib/llvm-project/lldb/source/API/SBReproducer.cpp new file mode 100644 index 000000000000..0eb3429c4fef --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBReproducer.cpp @@ -0,0 +1,243 @@ +//===-- SBReproducer.cpp --------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "SBReproducerPrivate.h" + +#include "SBReproducerPrivate.h" +#include "lldb/API/LLDB.h" +#include "lldb/API/SBAddress.h" +#include "lldb/API/SBAttachInfo.h" +#include "lldb/API/SBBlock.h" +#include "lldb/API/SBBreakpoint.h" +#include "lldb/API/SBCommandInterpreter.h" +#include "lldb/API/SBCommandInterpreterRunOptions.h" +#include "lldb/API/SBData.h" +#include "lldb/API/SBDebugger.h" +#include "lldb/API/SBDeclaration.h" +#include "lldb/API/SBError.h" +#include "lldb/API/SBFileSpec.h" +#include "lldb/API/SBHostOS.h" +#include "lldb/API/SBReproducer.h" +#include "lldb/Host/FileSystem.h" +#include "lldb/lldb-private.h" + +using namespace lldb; +using namespace lldb_private; +using namespace lldb_private::repro; + +SBRegistry::SBRegistry() { + Registry &R = *this; + + RegisterMethods<SBAddress>(R); + RegisterMethods<SBAttachInfo>(R); + RegisterMethods<SBBlock>(R); + RegisterMethods<SBBreakpoint>(R); + RegisterMethods<SBBreakpointList>(R); + RegisterMethods<SBBreakpointLocation>(R); + RegisterMethods<SBBreakpointName>(R); + RegisterMethods<SBBroadcaster>(R); + RegisterMethods<SBCommandInterpreter>(R); + RegisterMethods<SBCommandInterpreterRunOptions>(R); + RegisterMethods<SBCommandReturnObject>(R); + RegisterMethods<SBCommunication>(R); + RegisterMethods<SBCompileUnit>(R); + RegisterMethods<SBData>(R); + RegisterMethods<SBDebugger>(R); + RegisterMethods<SBDeclaration>(R); + RegisterMethods<SBEnvironment>(R); + RegisterMethods<SBError>(R); + RegisterMethods<SBEvent>(R); + RegisterMethods<SBExecutionContext>(R); + RegisterMethods<SBExpressionOptions>(R); + RegisterMethods<SBFile>(R); + RegisterMethods<SBFileSpec>(R); + RegisterMethods<SBFileSpecList>(R); + RegisterMethods<SBFrame>(R); + RegisterMethods<SBFunction>(R); + RegisterMethods<SBHostOS>(R); + RegisterMethods<SBInputReader>(R); + RegisterMethods<SBInstruction>(R); + RegisterMethods<SBInstructionList>(R); + RegisterMethods<SBLanguageRuntime>(R); + RegisterMethods<SBLaunchInfo>(R); + RegisterMethods<SBLineEntry>(R); + RegisterMethods<SBListener>(R); + RegisterMethods<SBMemoryRegionInfo>(R); + RegisterMethods<SBMemoryRegionInfoList>(R); + RegisterMethods<SBModule>(R); + RegisterMethods<SBModuleSpec>(R); + RegisterMethods<SBPlatform>(R); + RegisterMethods<SBPlatformConnectOptions>(R); + RegisterMethods<SBPlatformShellCommand>(R); + RegisterMethods<SBProcess>(R); + RegisterMethods<SBProcessInfo>(R); + RegisterMethods<SBQueue>(R); + RegisterMethods<SBQueueItem>(R); + RegisterMethods<SBSection>(R); + RegisterMethods<SBSourceManager>(R); + RegisterMethods<SBStream>(R); + RegisterMethods<SBStringList>(R); + RegisterMethods<SBStructuredData>(R); + RegisterMethods<SBSymbol>(R); + RegisterMethods<SBSymbolContext>(R); + RegisterMethods<SBSymbolContextList>(R); + RegisterMethods<SBTarget>(R); + RegisterMethods<SBThread>(R); + RegisterMethods<SBThreadCollection>(R); + RegisterMethods<SBThreadPlan>(R); + RegisterMethods<SBTrace>(R); + RegisterMethods<SBTraceOptions>(R); + RegisterMethods<SBType>(R); + RegisterMethods<SBTypeCategory>(R); + RegisterMethods<SBTypeEnumMember>(R); + RegisterMethods<SBTypeFilter>(R); + RegisterMethods<SBTypeFormat>(R); + RegisterMethods<SBTypeNameSpecifier>(R); + RegisterMethods<SBTypeSummary>(R); + RegisterMethods<SBTypeSummaryOptions>(R); + RegisterMethods<SBTypeSynthetic>(R); + RegisterMethods<SBUnixSignals>(R); + RegisterMethods<SBValue>(R); + RegisterMethods<SBValueList>(R); + RegisterMethods<SBVariablesOptions>(R); + RegisterMethods<SBWatchpoint>(R); +} + +const char *SBReproducer::Capture() { + static std::string error; + if (auto e = Reproducer::Initialize(ReproducerMode::Capture, llvm::None)) { + error = llvm::toString(std::move(e)); + return error.c_str(); + } + + if (auto *g = lldb_private::repro::Reproducer::Instance().GetGenerator()) { + auto &p = g->GetOrCreate<SBProvider>(); + InstrumentationData::Initialize(p.GetSerializer(), p.GetRegistry()); + } + + return nullptr; +} + +const char *SBReproducer::Capture(const char *path) { + static std::string error; + if (auto e = + Reproducer::Initialize(ReproducerMode::Capture, FileSpec(path))) { + error = llvm::toString(std::move(e)); + return error.c_str(); + } + + if (auto *g = lldb_private::repro::Reproducer::Instance().GetGenerator()) { + auto &p = g->GetOrCreate<SBProvider>(); + InstrumentationData::Initialize(p.GetSerializer(), p.GetRegistry()); + } + + return nullptr; +} + +const char *SBReproducer::PassiveReplay(const char *path) { + static std::string error; + if (auto e = Reproducer::Initialize(ReproducerMode::PassiveReplay, + FileSpec(path))) { + error = llvm::toString(std::move(e)); + return error.c_str(); + } + + if (auto *l = lldb_private::repro::Reproducer::Instance().GetLoader()) { + FileSpec file = l->GetFile<SBProvider::Info>(); + auto error_or_file = llvm::MemoryBuffer::getFile(file.GetPath()); + if (!error_or_file) { + error = + "unable to read SB API data: " + error_or_file.getError().message(); + return error.c_str(); + } + static ReplayData r(std::move(*error_or_file)); + InstrumentationData::Initialize(r.GetDeserializer(), r.GetRegistry()); + } + + return nullptr; +} + +const char *SBReproducer::Replay(const char *path) { + return SBReproducer::Replay(path, false); +} + +const char *SBReproducer::Replay(const char *path, bool skip_version_check) { + static std::string error; + if (auto e = Reproducer::Initialize(ReproducerMode::Replay, FileSpec(path))) { + error = llvm::toString(std::move(e)); + return error.c_str(); + } + + repro::Loader *loader = repro::Reproducer::Instance().GetLoader(); + if (!loader) { + error = "unable to get replay loader."; + return error.c_str(); + } + + if (!skip_version_check) { + llvm::Expected<std::string> version = loader->LoadBuffer<VersionProvider>(); + if (!version) { + error = llvm::toString(version.takeError()); + return error.c_str(); + } + if (lldb_private::GetVersion() != llvm::StringRef(*version).rtrim()) { + error = "reproducer capture and replay version don't match:\n"; + error.append("reproducer captured with:\n"); + error.append(*version); + error.append("reproducer replayed with:\n"); + error.append(lldb_private::GetVersion()); + return error.c_str(); + } + } + + FileSpec file = loader->GetFile<SBProvider::Info>(); + if (!file) { + error = "unable to get replay data from reproducer."; + return error.c_str(); + } + + SBRegistry registry; + registry.Replay(file); + + return nullptr; +} + +bool SBReproducer::Generate() { + auto &r = Reproducer::Instance(); + if (auto generator = r.GetGenerator()) { + generator->Keep(); + return true; + } + return false; +} + +bool SBReproducer::SetAutoGenerate(bool b) { + auto &r = Reproducer::Instance(); + if (auto generator = r.GetGenerator()) { + generator->SetAutoGenerate(b); + return true; + } + return false; +} + +const char *SBReproducer::GetPath() { + static std::string path; + auto &r = Reproducer::Instance(); + path = r.GetReproducerPath().GetCString(); + return path.c_str(); +} + +void SBReproducer::SetWorkingDirectory(const char *path) { + if (auto *g = lldb_private::repro::Reproducer::Instance().GetGenerator()) { + g->GetOrCreate<WorkingDirectoryProvider>().Update(path); + } +} + +char lldb_private::repro::SBProvider::ID = 0; +const char *SBProvider::Info::name = "sbapi"; +const char *SBProvider::Info::file = "sbapi.bin"; diff --git a/contrib/llvm-project/lldb/source/API/SBReproducerPrivate.h b/contrib/llvm-project/lldb/source/API/SBReproducerPrivate.h new file mode 100644 index 000000000000..a4c6eb94627b --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBReproducerPrivate.h @@ -0,0 +1,77 @@ +//===-- SBReproducerPrivate.h -----------------------------------*- C++ -*-===// +// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLDB_SOURCE_API_SBREPRODUCERPRIVATE_H +#define LLDB_SOURCE_API_SBREPRODUCERPRIVATE_H + +#include "lldb/API/SBReproducer.h" + +#include "lldb/Utility/FileSpec.h" +#include "lldb/Utility/Log.h" +#include "lldb/Utility/Reproducer.h" +#include "lldb/Utility/ReproducerInstrumentation.h" + +#include "llvm/ADT/DenseMap.h" + +#define LLDB_GET_INSTRUMENTATION_DATA() \ + lldb_private::repro::InstrumentationData::Instance() + +namespace lldb_private { +namespace repro { + +class SBRegistry : public Registry { +public: + SBRegistry(); +}; + +class SBProvider : public Provider<SBProvider> { +public: + struct Info { + static const char *name; + static const char *file; + }; + + SBProvider(const FileSpec &directory) + : Provider(directory), + m_stream(directory.CopyByAppendingPathComponent("sbapi.bin").GetPath(), + m_ec, llvm::sys::fs::OpenFlags::OF_None), + m_serializer(m_stream) {} + + Serializer &GetSerializer() { return m_serializer; } + Registry &GetRegistry() { return m_registry; } + + static char ID; + +private: + std::error_code m_ec; + llvm::raw_fd_ostream m_stream; + Serializer m_serializer; + SBRegistry m_registry; +}; + +class ReplayData { +public: + ReplayData(std::unique_ptr<llvm::MemoryBuffer> memory_buffer) + : m_memory_buffer(std::move(memory_buffer)), m_registry(), + m_deserializer(m_memory_buffer->getBuffer()) {} + Deserializer &GetDeserializer() { return m_deserializer; } + Registry &GetRegistry() { return m_registry; } + +private: + std::unique_ptr<llvm::MemoryBuffer> m_memory_buffer; + SBRegistry m_registry; + Deserializer m_deserializer; +}; + +template <typename T> void RegisterMethods(Registry &R); + +} // namespace repro +} // namespace lldb_private + +#endif diff --git a/contrib/llvm-project/lldb/source/API/SBSection.cpp b/contrib/llvm-project/lldb/source/API/SBSection.cpp new file mode 100644 index 000000000000..bb56fa18d9ca --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBSection.cpp @@ -0,0 +1,328 @@ +//===-- SBSection.cpp -----------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBSection.h" +#include "SBReproducerPrivate.h" +#include "lldb/API/SBStream.h" +#include "lldb/API/SBTarget.h" +#include "lldb/Core/Module.h" +#include "lldb/Core/Section.h" +#include "lldb/Symbol/ObjectFile.h" +#include "lldb/Utility/DataBuffer.h" +#include "lldb/Utility/DataExtractor.h" +#include "lldb/Utility/StreamString.h" + +using namespace lldb; +using namespace lldb_private; + +SBSection::SBSection() : m_opaque_wp() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSection); +} + +SBSection::SBSection(const SBSection &rhs) : m_opaque_wp(rhs.m_opaque_wp) { + LLDB_RECORD_CONSTRUCTOR(SBSection, (const lldb::SBSection &), rhs); +} + +SBSection::SBSection(const lldb::SectionSP §ion_sp) + : m_opaque_wp() // Don't init with section_sp otherwise this will throw if + // section_sp doesn't contain a valid Section * +{ + if (section_sp) + m_opaque_wp = 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 LLDB_RECORD_RESULT(*this); +} + +SBSection::~SBSection() = default; + +bool SBSection::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSection, IsValid); + return this->operator bool(); +} +SBSection::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSection, operator bool); + + SectionSP section_sp(GetSP()); + return section_sp && section_sp->GetModule().get() != nullptr; +} + +const char *SBSection::GetName() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBSection, GetName); + + SectionSP section_sp(GetSP()); + if (section_sp) + return section_sp->GetName().GetCString(); + return nullptr; +} + +lldb::SBSection SBSection::GetParent() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSection, SBSection, GetParent); + + lldb::SBSection sb_section; + SectionSP section_sp(GetSP()); + if (section_sp) { + SectionSP parent_section_sp(section_sp->GetParent()); + if (parent_section_sp) + sb_section.SetSP(parent_section_sp); + } + 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()); + if (section_sp) { + ConstString const_sect_name(sect_name); + sb_section.SetSP( + section_sp->GetChildren().FindSectionByName(const_sect_name)); + } + } + 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(); + return 0; +} + +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 LLDB_RECORD_RESULT(sb_section); +} + +lldb::SectionSP SBSection::GetSP() const { return m_opaque_wp.lock(); } + +void SBSection::SetSP(const lldb::SectionSP §ion_sp) { + m_opaque_wp = 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) + return section_sp->GetFileAddress(); + return file_addr; +} + +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()); + if (section_sp) + return section_sp->GetLoadBaseAddress(target_sp.get()); + } + return LLDB_INVALID_ADDRESS; +} + +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(); + return 0; +} + +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()); + if (module_sp) { + ObjectFile *objfile = module_sp->GetObjectFile(); + if (objfile) + return objfile->GetFileOffset() + section_sp->GetFileOffset(); + } + } + return UINT64_MAX; +} + +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() { + 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) { + const uint64_t sect_file_size = section_sp->GetFileSize(); + if (sect_file_size > 0) { + ModuleSP module_sp(section_sp->GetModule()); + if (module_sp) { + ObjectFile *objfile = module_sp->GetObjectFile(); + if (objfile) { + const uint64_t sect_file_offset = + objfile->GetFileOffset() + section_sp->GetFileOffset(); + const uint64_t file_offset = sect_file_offset + offset; + uint64_t file_size = size; + if (file_size == UINT64_MAX) { + file_size = section_sp->GetByteSize(); + if (file_size > offset) + file_size -= offset; + else + file_size = 0; + } + auto data_buffer_sp = FileSystem::Instance().CreateDataBuffer( + objfile->GetFileSpec().GetPath(), file_size, file_offset); + if (data_buffer_sp && data_buffer_sp->GetByteSize() > 0) { + DataExtractorSP data_extractor_sp( + new DataExtractor(data_buffer_sp, objfile->GetByteOrder(), + objfile->GetAddressByteSize())); + + sb_data.SetOpaque(data_extractor_sp); + } + } + } + } + } + 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 { + 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(); + return 0; +} + +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) + return lhs_section_sp == rhs_section_sp; + return false; +} + +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()); + if (section_sp) { + const addr_t file_addr = section_sp->GetFileAddress(); + strm.Printf("[0x%16.16" PRIx64 "-0x%16.16" PRIx64 ") ", file_addr, + file_addr + section_sp->GetByteSize()); + section_sp->DumpName(strm.AsRawOstream()); + } else { + strm.PutCString("No value"); + } + + return true; +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBSection>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBSection, ()); + LLDB_REGISTER_CONSTRUCTOR(SBSection, (const lldb::SBSection &)); + LLDB_REGISTER_METHOD(const lldb::SBSection &, + SBSection, operator=,(const lldb::SBSection &)); + LLDB_REGISTER_METHOD_CONST(bool, SBSection, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBSection, operator bool, ()); + LLDB_REGISTER_METHOD(const char *, SBSection, GetName, ()); + LLDB_REGISTER_METHOD(lldb::SBSection, SBSection, GetParent, ()); + LLDB_REGISTER_METHOD(lldb::SBSection, SBSection, FindSubSection, + (const char *)); + LLDB_REGISTER_METHOD(size_t, SBSection, GetNumSubSections, ()); + LLDB_REGISTER_METHOD(lldb::SBSection, SBSection, GetSubSectionAtIndex, + (size_t)); + LLDB_REGISTER_METHOD(lldb::addr_t, SBSection, GetFileAddress, ()); + LLDB_REGISTER_METHOD(lldb::addr_t, SBSection, GetLoadAddress, + (lldb::SBTarget &)); + LLDB_REGISTER_METHOD(lldb::addr_t, SBSection, GetByteSize, ()); + LLDB_REGISTER_METHOD(uint64_t, SBSection, GetFileOffset, ()); + LLDB_REGISTER_METHOD(uint64_t, SBSection, GetFileByteSize, ()); + LLDB_REGISTER_METHOD(lldb::SBData, SBSection, GetSectionData, ()); + LLDB_REGISTER_METHOD(lldb::SBData, SBSection, GetSectionData, + (uint64_t, uint64_t)); + LLDB_REGISTER_METHOD(lldb::SectionType, SBSection, GetSectionType, ()); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBSection, GetPermissions, ()); + LLDB_REGISTER_METHOD(uint32_t, SBSection, GetTargetByteSize, ()); + LLDB_REGISTER_METHOD(bool, SBSection, operator==,(const lldb::SBSection &)); + LLDB_REGISTER_METHOD(bool, SBSection, operator!=,(const lldb::SBSection &)); + LLDB_REGISTER_METHOD(bool, SBSection, GetDescription, (lldb::SBStream &)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBSourceManager.cpp b/contrib/llvm-project/lldb/source/API/SBSourceManager.cpp new file mode 100644 index 000000000000..43c3443672f7 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBSourceManager.cpp @@ -0,0 +1,164 @@ +//===-- SBSourceManager.cpp -----------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBSourceManager.h" +#include "SBReproducerPrivate.h" +#include "lldb/API/SBDebugger.h" +#include "lldb/API/SBStream.h" +#include "lldb/API/SBTarget.h" + +#include "lldb/API/SBFileSpec.h" +#include "lldb/Core/Debugger.h" +#include "lldb/Core/SourceManager.h" +#include "lldb/Core/StreamFile.h" +#include "lldb/Utility/Stream.h" + +#include "lldb/Target/Target.h" + +namespace lldb_private { +class SourceManagerImpl { +public: + SourceManagerImpl(const lldb::DebuggerSP &debugger_sp) + : m_debugger_wp(debugger_sp), m_target_wp() {} + + SourceManagerImpl(const lldb::TargetSP &target_sp) + : m_debugger_wp(), m_target_wp(target_sp) {} + + SourceManagerImpl(const SourceManagerImpl &rhs) { + if (&rhs == this) + return; + m_debugger_wp = rhs.m_debugger_wp; + m_target_wp = rhs.m_target_wp; + } + + size_t DisplaySourceLinesWithLineNumbers(const lldb_private::FileSpec &file, + uint32_t line, uint32_t column, + uint32_t context_before, + uint32_t context_after, + const char *current_line_cstr, + lldb_private::Stream *s) { + if (!file) + return 0; + + lldb::TargetSP target_sp(m_target_wp.lock()); + if (target_sp) { + return target_sp->GetSourceManager().DisplaySourceLinesWithLineNumbers( + file, line, column, context_before, context_after, current_line_cstr, + s); + } else { + lldb::DebuggerSP debugger_sp(m_debugger_wp.lock()); + if (debugger_sp) { + return debugger_sp->GetSourceManager() + .DisplaySourceLinesWithLineNumbers(file, line, column, + context_before, context_after, + current_line_cstr, s); + } + } + return 0; + } + +private: + lldb::DebuggerWP m_debugger_wp; + lldb::TargetWP m_target_wp; +}; +} + +using namespace lldb; +using namespace lldb_private; + +SBSourceManager::SBSourceManager(const SBDebugger &debugger) { + LLDB_RECORD_CONSTRUCTOR(SBSourceManager, (const lldb::SBDebugger &), + debugger); + + m_opaque_up = std::make_unique<SourceManagerImpl>(debugger.get_sp()); +} + +SBSourceManager::SBSourceManager(const SBTarget &target) { + LLDB_RECORD_CONSTRUCTOR(SBSourceManager, (const lldb::SBTarget &), target); + + m_opaque_up = std::make_unique<SourceManagerImpl>(target.GetSP()); +} + +SBSourceManager::SBSourceManager(const SBSourceManager &rhs) { + LLDB_RECORD_CONSTRUCTOR(SBSourceManager, (const lldb::SBSourceManager &), + rhs); + + if (&rhs == this) + return; + + m_opaque_up = std::make_unique<SourceManagerImpl>(*(rhs.m_opaque_up.get())); +} + +const lldb::SBSourceManager &SBSourceManager:: +operator=(const lldb::SBSourceManager &rhs) { + LLDB_RECORD_METHOD(const lldb::SBSourceManager &, + SBSourceManager, operator=,(const lldb::SBSourceManager &), + rhs); + + m_opaque_up = std::make_unique<SourceManagerImpl>(*(rhs.m_opaque_up.get())); + return LLDB_RECORD_RESULT(*this); +} + +SBSourceManager::~SBSourceManager() = default; + +size_t SBSourceManager::DisplaySourceLinesWithLineNumbers( + const SBFileSpec &file, uint32_t line, uint32_t context_before, + uint32_t context_after, const char *current_line_cstr, SBStream &s) { + LLDB_RECORD_METHOD(size_t, SBSourceManager, DisplaySourceLinesWithLineNumbers, + (const lldb::SBFileSpec &, uint32_t, uint32_t, uint32_t, + const char *, lldb::SBStream &), + file, line, context_before, context_after, + current_line_cstr, s); + + const uint32_t column = 0; + return DisplaySourceLinesWithLineNumbersAndColumn( + file.ref(), line, column, context_before, context_after, + current_line_cstr, s); +} + +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 == nullptr) + return 0; + + return m_opaque_up->DisplaySourceLinesWithLineNumbers( + file.ref(), line, column, context_before, context_after, + current_line_cstr, s.get()); +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBSourceManager>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBSourceManager, (const lldb::SBDebugger &)); + LLDB_REGISTER_CONSTRUCTOR(SBSourceManager, (const lldb::SBTarget &)); + LLDB_REGISTER_CONSTRUCTOR(SBSourceManager, (const lldb::SBSourceManager &)); + LLDB_REGISTER_METHOD( + const lldb::SBSourceManager &, + SBSourceManager, operator=,(const lldb::SBSourceManager &)); + LLDB_REGISTER_METHOD(size_t, SBSourceManager, + DisplaySourceLinesWithLineNumbers, + (const lldb::SBFileSpec &, uint32_t, uint32_t, + uint32_t, const char *, lldb::SBStream &)); + LLDB_REGISTER_METHOD(size_t, SBSourceManager, + DisplaySourceLinesWithLineNumbersAndColumn, + (const lldb::SBFileSpec &, uint32_t, uint32_t, + uint32_t, uint32_t, const char *, lldb::SBStream &)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBStream.cpp b/contrib/llvm-project/lldb/source/API/SBStream.cpp new file mode 100644 index 000000000000..eb81153084e8 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBStream.cpp @@ -0,0 +1,217 @@ +//===-- SBStream.cpp ------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBStream.h" + +#include "SBReproducerPrivate.h" +#include "lldb/API/SBFile.h" +#include "lldb/Core/StreamFile.h" +#include "lldb/Host/FileSystem.h" +#include "lldb/Utility/Status.h" +#include "lldb/Utility/Stream.h" +#include "lldb/Utility/StreamString.h" + +using namespace lldb; +using namespace lldb_private; + +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() = default; + +bool SBStream::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStream, IsValid); + return this->operator bool(); +} +SBStream::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStream, operator bool); + + return (m_opaque_up != nullptr); +} + +// 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 == nullptr) + return nullptr; + + return static_cast<StreamString *>(m_opaque_up.get())->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 == nullptr) + return 0; + + return static_cast<StreamString *>(m_opaque_up.get())->GetSize(); +} + +void SBStream::Print(const char *str) { + LLDB_RECORD_METHOD(void, SBStream, Print, (const char *), str); + + Printf("%s", str); +} + +void SBStream::Printf(const char *format, ...) { + if (!format) + return; + va_list args; + va_start(args, format); + ref().PrintfVarArg(format, args); + va_end(args); +} + +void SBStream::RedirectToFile(const char *path, bool append) { + LLDB_RECORD_METHOD(void, SBStream, RedirectToFile, (const char *, bool), path, + append); + + if (path == nullptr) + return; + + std::string local_data; + 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 + if (!m_is_file) + local_data = std::string( + static_cast<StreamString *>(m_opaque_up.get())->GetString()); + } + auto open_options = File::eOpenOptionWrite | File::eOpenOptionCanCreate; + if (append) + open_options |= File::eOpenOptionAppend; + else + open_options |= File::eOpenOptionTruncate; + + llvm::Expected<FileUP> file = + FileSystem::Instance().Open(FileSpec(path), open_options); + if (!file) { + LLDB_LOG_ERROR(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API), file.takeError(), + "Cannot open {1}: {0}", path); + return; + } + + m_opaque_up = std::make_unique<StreamFile>(std::move(file.get())); + m_is_file = true; + + // If we had any data locally in our StreamString, then pass that along to + // the to new file we are redirecting to. + if (!local_data.empty()) + m_opaque_up->Write(&local_data[0], local_data.size()); +} + +void SBStream::RedirectToFileHandle(FILE *fh, bool transfer_fh_ownership) { + LLDB_RECORD_METHOD(void, SBStream, RedirectToFileHandle, (FILE *, bool), fh, + transfer_fh_ownership); + FileSP file = std::make_unique<NativeFile>(fh, transfer_fh_ownership); + return RedirectToFile(file); +} + +void SBStream::RedirectToFile(SBFile file) { + LLDB_RECORD_METHOD(void, SBStream, RedirectToFile, (SBFile), file) + RedirectToFile(file.GetFile()); +} + +void SBStream::RedirectToFile(FileSP file_sp) { + LLDB_RECORD_METHOD(void, SBStream, RedirectToFile, (FileSP), file_sp); + + if (!file_sp || !file_sp->IsValid()) + return; + + std::string local_data; + 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 + if (!m_is_file) + local_data = std::string( + static_cast<StreamString *>(m_opaque_up.get())->GetString()); + } + + m_opaque_up = std::make_unique<StreamFile>(file_sp); + m_is_file = true; + + // If we had any data locally in our StreamString, then pass that along to + // the to new file we are redirecting to. + if (!local_data.empty()) + m_opaque_up->Write(&local_data[0], local_data.size()); +} + +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 + // redirect it to the file so we don't lose the data + if (!m_is_file) + local_data = std::string( + static_cast<StreamString *>(m_opaque_up.get())->GetString()); + } + + m_opaque_up = std::make_unique<StreamFile>(fd, transfer_fh_ownership); + m_is_file = true; + + // If we had any data locally in our StreamString, then pass that along to + // the to new file we are redirecting to. + if (!local_data.empty()) + m_opaque_up->Write(&local_data[0], local_data.size()); +} + +lldb_private::Stream *SBStream::operator->() { return m_opaque_up.get(); } + +lldb_private::Stream *SBStream::get() { return m_opaque_up.get(); } + +lldb_private::Stream &SBStream::ref() { + if (m_opaque_up == nullptr) + m_opaque_up = std::make_unique<StreamString>(); + return *m_opaque_up; +} + +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 + if (m_is_file) + m_opaque_up.reset(); + else + static_cast<StreamString *>(m_opaque_up.get())->Clear(); + } +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBStream>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBStream, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBStream, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBStream, operator bool, ()); + LLDB_REGISTER_METHOD(const char *, SBStream, GetData, ()); + LLDB_REGISTER_METHOD(size_t, SBStream, GetSize, ()); + LLDB_REGISTER_METHOD(void, SBStream, RedirectToFile, (const char *, bool)); + LLDB_REGISTER_METHOD(void, SBStream, RedirectToFile, (FileSP)); + LLDB_REGISTER_METHOD(void, SBStream, RedirectToFile, (SBFile)); + LLDB_REGISTER_METHOD(void, SBStream, RedirectToFileHandle, (FILE *, bool)); + LLDB_REGISTER_METHOD(void, SBStream, RedirectToFileDescriptor, (int, bool)); + LLDB_REGISTER_METHOD(void, SBStream, Clear, ()); + LLDB_REGISTER_METHOD(void, SBStream, Print, (const char *)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBStringList.cpp b/contrib/llvm-project/lldb/source/API/SBStringList.cpp new file mode 100644 index 000000000000..d9b03692ec0e --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBStringList.cpp @@ -0,0 +1,163 @@ +//===-- SBStringList.cpp --------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/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() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBStringList); +} + +SBStringList::SBStringList(const lldb_private::StringList *lldb_strings_ptr) + : m_opaque_up() { + if (lldb_strings_ptr) + m_opaque_up = std::make_unique<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 LLDB_RECORD_RESULT(*this); +} + +SBStringList::~SBStringList() = default; + +const lldb_private::StringList *SBStringList::operator->() const { + return m_opaque_up.get(); +} + +const lldb_private::StringList &SBStringList::operator*() const { + return *m_opaque_up; +} + +bool SBStringList::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStringList, IsValid); + return this->operator bool(); +} +SBStringList::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStringList, operator bool); + + return (m_opaque_up != nullptr); +} + +void SBStringList::AppendString(const char *str) { + LLDB_RECORD_METHOD(void, SBStringList, AppendString, (const char *), str); + + if (str != nullptr) { + if (IsValid()) + m_opaque_up->AppendString(str); + else + m_opaque_up = std::make_unique<lldb_private::StringList>(str); + } +} + +void SBStringList::AppendList(const char **strv, int strc) { + LLDB_RECORD_METHOD(void, SBStringList, AppendList, (const char **, int), strv, + strc); + + if ((strv != nullptr) && (strc > 0)) { + if (IsValid()) + m_opaque_up->AppendList(strv, strc); + else + m_opaque_up = std::make_unique<lldb_private::StringList>(strv, strc); + } +} + +void SBStringList::AppendList(const SBStringList &strings) { + LLDB_RECORD_METHOD(void, SBStringList, AppendList, + (const lldb::SBStringList &), strings); + + if (strings.IsValid()) { + if (!IsValid()) + m_opaque_up = std::make_unique<lldb_private::StringList>(); + m_opaque_up->AppendList(*(strings.m_opaque_up)); + } +} + +void SBStringList::AppendList(const StringList &strings) { + if (!IsValid()) + m_opaque_up = std::make_unique<lldb_private::StringList>(); + m_opaque_up->AppendList(strings); +} + +uint32_t SBStringList::GetSize() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBStringList, GetSize); + + if (IsValid()) { + return m_opaque_up->GetSize(); + } + return 0; +} + +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); + } + return nullptr; +} + +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); + } + return nullptr; +} + +void SBStringList::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBStringList, Clear); + + if (IsValid()) { + m_opaque_up->Clear(); + } +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBStringList>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBStringList, ()); + LLDB_REGISTER_CONSTRUCTOR(SBStringList, (const lldb::SBStringList &)); + LLDB_REGISTER_METHOD(const lldb::SBStringList &, + SBStringList, operator=,(const lldb::SBStringList &)); + LLDB_REGISTER_METHOD_CONST(bool, SBStringList, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBStringList, operator bool, ()); + LLDB_REGISTER_METHOD(void, SBStringList, AppendString, (const char *)); + LLDB_REGISTER_METHOD(void, SBStringList, AppendList, (const char **, int)); + LLDB_REGISTER_METHOD(void, SBStringList, AppendList, + (const lldb::SBStringList &)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBStringList, GetSize, ()); + LLDB_REGISTER_METHOD(const char *, SBStringList, GetStringAtIndex, + (size_t)); + LLDB_REGISTER_METHOD_CONST(const char *, SBStringList, GetStringAtIndex, + (size_t)); + LLDB_REGISTER_METHOD(void, SBStringList, Clear, ()); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBStructuredData.cpp b/contrib/llvm-project/lldb/source/API/SBStructuredData.cpp new file mode 100644 index 000000000000..2ae3005fd8d1 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBStructuredData.cpp @@ -0,0 +1,243 @@ +//===-- SBStructuredData.cpp ----------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBStructuredData.h" +#include "SBReproducerPrivate.h" + +#include "lldb/API/SBStream.h" +#include "lldb/API/SBStringList.h" +#include "lldb/Core/StructuredDataImpl.h" +#include "lldb/Target/StructuredDataPlugin.h" +#include "lldb/Utility/Event.h" +#include "lldb/Utility/Status.h" +#include "lldb/Utility/Stream.h" +#include "lldb/Utility/StructuredData.h" + +using namespace lldb; +using namespace lldb_private; + +#pragma mark-- +#pragma mark SBStructuredData + +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())) { + LLDB_RECORD_CONSTRUCTOR(SBStructuredData, (const lldb::SBStructuredData &), + rhs); +} + +SBStructuredData::SBStructuredData(const lldb::EventSP &event_sp) + : m_impl_up(new StructuredDataImpl(event_sp)) { + LLDB_RECORD_CONSTRUCTOR(SBStructuredData, (const lldb::EventSP &), event_sp); +} + +SBStructuredData::SBStructuredData(lldb_private::StructuredDataImpl *impl) + : m_impl_up(impl) { + LLDB_RECORD_CONSTRUCTOR(SBStructuredData, + (lldb_private::StructuredDataImpl *), impl); +} + +SBStructuredData::~SBStructuredData() = default; + +SBStructuredData &SBStructuredData:: +operator=(const lldb::SBStructuredData &rhs) { + LLDB_RECORD_METHOD( + lldb::SBStructuredData &, + SBStructuredData, operator=,(const lldb::SBStructuredData &), rhs); + + *m_impl_up = *rhs.m_impl_up; + return LLDB_RECORD_RESULT(*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()); + + StructuredData::ObjectSP json_obj = StructuredData::ParseJSON(json_str); + m_impl_up->SetObjectSP(json_obj); + + if (!json_obj || json_obj->GetType() != eStructuredDataTypeDictionary) + error.SetErrorString("Invalid Syntax"); + return LLDB_RECORD_RESULT(error); +} + +bool SBStructuredData::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStructuredData, IsValid); + return this->operator bool(); +} +SBStructuredData::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStructuredData, operator bool); + + 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 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 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; + + if (GetType() != eStructuredDataTypeDictionary) + return false; + + StructuredData::ObjectSP obj_sp = m_impl_up->GetObjectSP(); + if (!obj_sp) + return false; + + StructuredData::Dictionary *dict = obj_sp->GetAsDictionary(); + // We claimed we were a dictionary, so this can't be null. + assert(dict); + // The return kind of GetKeys is an Array: + StructuredData::ObjectSP array_sp = dict->GetKeys(); + StructuredData::Array *key_arr = array_sp->GetAsArray(); + assert(key_arr); + + key_arr->ForEach([&keys] (StructuredData::Object *object) -> bool { + llvm::StringRef key = object->GetStringValue(""); + keys.AppendString(key.str().c_str()); + return true; + }); + return true; +} + +lldb::SBStructuredData SBStructuredData::GetValueForKey(const char *key) const { + LLDB_RECORD_METHOD_CONST(lldb::SBStructuredData, SBStructuredData, + GetValueForKey, (const char *), key); + + if (!m_impl_up) + return LLDB_RECORD_RESULT(SBStructuredData()); + + SBStructuredData result; + result.m_impl_up->SetObjectSP(m_impl_up->GetValueForKey(key)); + 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 LLDB_RECORD_RESULT(SBStructuredData()); + + SBStructuredData result; + result.m_impl_up->SetObjectSP(m_impl_up->GetItemAtIndex(idx)); + 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_CHAR_PTR_METHOD_CONST(size_t, SBStructuredData, GetStringValue, + (char *, size_t), dst, "", dst_len); + + return (m_impl_up ? m_impl_up->GetStringValue(dst, dst_len) : 0); +} + +namespace lldb_private { +namespace repro { + +template <> void RegisterMethods<SBStructuredData>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBStructuredData, ()); + LLDB_REGISTER_CONSTRUCTOR(SBStructuredData, (const lldb::SBStructuredData &)); + LLDB_REGISTER_CONSTRUCTOR(SBStructuredData, (const lldb::EventSP &)); + LLDB_REGISTER_CONSTRUCTOR(SBStructuredData, + (lldb_private::StructuredDataImpl *)); + LLDB_REGISTER_METHOD( + lldb::SBStructuredData &, + SBStructuredData, operator=,(const lldb::SBStructuredData &)); + LLDB_REGISTER_METHOD(lldb::SBError, SBStructuredData, SetFromJSON, + (lldb::SBStream &)); + LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, operator bool, ()); + LLDB_REGISTER_METHOD(void, SBStructuredData, Clear, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBError, SBStructuredData, GetAsJSON, + (lldb::SBStream &)); + LLDB_REGISTER_METHOD_CONST(lldb::SBError, SBStructuredData, GetDescription, + (lldb::SBStream &)); + LLDB_REGISTER_METHOD_CONST(lldb::StructuredDataType, SBStructuredData, + GetType, ()); + LLDB_REGISTER_METHOD_CONST(size_t, SBStructuredData, GetSize, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, GetKeys, + (lldb::SBStringList &)); + LLDB_REGISTER_METHOD_CONST(lldb::SBStructuredData, SBStructuredData, + GetValueForKey, (const char *)); + LLDB_REGISTER_METHOD_CONST(lldb::SBStructuredData, SBStructuredData, + GetItemAtIndex, (size_t)); + LLDB_REGISTER_METHOD_CONST(uint64_t, SBStructuredData, GetIntegerValue, + (uint64_t)); + LLDB_REGISTER_METHOD_CONST(double, SBStructuredData, GetFloatValue, (double)); + LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, GetBooleanValue, (bool)); + LLDB_REGISTER_CHAR_PTR_METHOD_CONST(size_t, SBStructuredData, GetStringValue); +} + +} // namespace repro +} // namespace lldb_private diff --git a/contrib/llvm-project/lldb/source/API/SBSymbol.cpp b/contrib/llvm-project/lldb/source/API/SBSymbol.cpp new file mode 100644 index 000000000000..e4f2f3518270 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBSymbol.cpp @@ -0,0 +1,237 @@ +//===-- SBSymbol.cpp ------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBSymbol.h" +#include "SBReproducerPrivate.h" +#include "lldb/API/SBStream.h" +#include "lldb/Core/Disassembler.h" +#include "lldb/Core/Module.h" +#include "lldb/Symbol/Symbol.h" +#include "lldb/Target/ExecutionContext.h" +#include "lldb/Target/Target.h" + +using namespace lldb; +using namespace lldb_private; + +SBSymbol::SBSymbol() : m_opaque_ptr(nullptr) { + 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) { + 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 LLDB_RECORD_RESULT(*this); +} + +SBSymbol::~SBSymbol() { m_opaque_ptr = nullptr; } + +void SBSymbol::SetSymbol(lldb_private::Symbol *lldb_object_ptr) { + m_opaque_ptr = lldb_object_ptr; +} + +bool SBSymbol::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbol, IsValid); + return this->operator bool(); +} +SBSymbol::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbol, operator bool); + + return m_opaque_ptr != nullptr; +} + +const char *SBSymbol::GetName() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetName); + + const char *name = nullptr; + if (m_opaque_ptr) + name = m_opaque_ptr->GetName().AsCString(); + + return name; +} + +const char *SBSymbol::GetDisplayName() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetDisplayName); + + const char *name = nullptr; + if (m_opaque_ptr) + name = m_opaque_ptr->GetMangled().GetDisplayDemangledName().AsCString(); + + return name; +} + +const char *SBSymbol::GetMangledName() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetMangledName); + + const char *name = nullptr; + if (m_opaque_ptr) + name = m_opaque_ptr->GetMangled().GetMangledName().AsCString(); + return name; +} + +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) { + m_opaque_ptr->GetDescription(&strm, lldb::eDescriptionLevelFull, nullptr); + } else + strm.PutCString("No value"); + + return true; +} + +SBInstructionList SBSymbol::GetInstructions(SBTarget target) { + LLDB_RECORD_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions, + (lldb::SBTarget), target); + + return LLDB_RECORD_RESULT(GetInstructions(target, nullptr)); +} + +SBInstructionList SBSymbol::GetInstructions(SBTarget target, + const char *flavor_string) { + LLDB_RECORD_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions, + (lldb::SBTarget, const char *), target, flavor_string); + + SBInstructionList sb_instructions; + if (m_opaque_ptr) { + TargetSP target_sp(target.GetSP()); + std::unique_lock<std::recursive_mutex> lock; + if (target_sp && m_opaque_ptr->ValueIsAddress()) { + lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex()); + const Address &symbol_addr = m_opaque_ptr->GetAddressRef(); + ModuleSP module_sp = symbol_addr.GetModule(); + if (module_sp) { + AddressRange symbol_range(symbol_addr, m_opaque_ptr->GetByteSize()); + const bool prefer_file_cache = false; + sb_instructions.SetDisassembler(Disassembler::DisassembleRange( + module_sp->GetArchitecture(), nullptr, flavor_string, *target_sp, + symbol_range, prefer_file_cache)); + } + } + } + return LLDB_RECORD_RESULT(sb_instructions); +} + +lldb_private::Symbol *SBSymbol::get() { return m_opaque_ptr; } + +void SBSymbol::reset(lldb_private::Symbol *symbol) { m_opaque_ptr = symbol; } + +SBAddress SBSymbol::GetStartAddress() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBSymbol, GetStartAddress); + + SBAddress addr; + if (m_opaque_ptr && m_opaque_ptr->ValueIsAddress()) { + addr.SetAddress(&m_opaque_ptr->GetAddressRef()); + } + return 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(); + if (range_size > 0) { + addr.SetAddress(&m_opaque_ptr->GetAddressRef()); + addr->Slide(m_opaque_ptr->GetByteSize()); + } + } + 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; +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBSymbol>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBSymbol, ()); + LLDB_REGISTER_CONSTRUCTOR(SBSymbol, (const lldb::SBSymbol &)); + LLDB_REGISTER_METHOD(const lldb::SBSymbol &, + SBSymbol, operator=,(const lldb::SBSymbol &)); + LLDB_REGISTER_METHOD_CONST(bool, SBSymbol, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBSymbol, operator bool, ()); + LLDB_REGISTER_METHOD_CONST(const char *, SBSymbol, GetName, ()); + LLDB_REGISTER_METHOD_CONST(const char *, SBSymbol, GetDisplayName, ()); + LLDB_REGISTER_METHOD_CONST(const char *, SBSymbol, GetMangledName, ()); + LLDB_REGISTER_METHOD_CONST(bool, + SBSymbol, operator==,(const lldb::SBSymbol &)); + LLDB_REGISTER_METHOD_CONST(bool, + SBSymbol, operator!=,(const lldb::SBSymbol &)); + LLDB_REGISTER_METHOD(bool, SBSymbol, GetDescription, (lldb::SBStream &)); + LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions, + (lldb::SBTarget)); + LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions, + (lldb::SBTarget, const char *)); + LLDB_REGISTER_METHOD(lldb::SBAddress, SBSymbol, GetStartAddress, ()); + LLDB_REGISTER_METHOD(lldb::SBAddress, SBSymbol, GetEndAddress, ()); + LLDB_REGISTER_METHOD(uint32_t, SBSymbol, GetPrologueByteSize, ()); + LLDB_REGISTER_METHOD(lldb::SymbolType, SBSymbol, GetType, ()); + LLDB_REGISTER_METHOD(bool, SBSymbol, IsExternal, ()); + LLDB_REGISTER_METHOD(bool, SBSymbol, IsSynthetic, ()); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBSymbolContext.cpp b/contrib/llvm-project/lldb/source/API/SBSymbolContext.cpp new file mode 100644 index 000000000000..488d49884903 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBSymbolContext.cpp @@ -0,0 +1,271 @@ +//===-- SBSymbolContext.cpp -----------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBSymbolContext.h" +#include "SBReproducerPrivate.h" +#include "Utils.h" +#include "lldb/API/SBStream.h" +#include "lldb/Core/Module.h" +#include "lldb/Symbol/Function.h" +#include "lldb/Symbol/Symbol.h" +#include "lldb/Symbol/SymbolContext.h" + +using namespace lldb; +using namespace lldb_private; + +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 = std::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() = default; + +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 LLDB_RECORD_RESULT(*this); +} + +void SBSymbolContext::SetSymbolContext(const SymbolContext *sc_ptr) { + if (sc_ptr) + m_opaque_up = std::make_unique<SymbolContext>(*sc_ptr); + else + m_opaque_up->Clear(true); +} + +bool SBSymbolContext::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContext, IsValid); + return this->operator bool(); +} +SBSymbolContext::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContext, operator bool); + + return m_opaque_up != nullptr; +} + +SBModule SBSymbolContext::GetModule() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBModule, SBSymbolContext, GetModule); + + SBModule sb_module; + ModuleSP module_sp; + if (m_opaque_up) { + module_sp = m_opaque_up->module_sp; + sb_module.SetSP(module_sp); + } + + return LLDB_RECORD_RESULT(sb_module); +} + +SBCompileUnit SBSymbolContext::GetCompileUnit() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCompileUnit, SBSymbolContext, + GetCompileUnit); + + return LLDB_RECORD_RESULT( + SBCompileUnit(m_opaque_up ? m_opaque_up->comp_unit : nullptr)); +} + +SBFunction SBSymbolContext::GetFunction() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFunction, SBSymbolContext, GetFunction); + + Function *function = nullptr; + + if (m_opaque_up) + function = m_opaque_up->function; + + SBFunction sb_function(function); + + return LLDB_RECORD_RESULT(sb_function); +} + +SBBlock SBSymbolContext::GetBlock() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBSymbolContext, GetBlock); + + return LLDB_RECORD_RESULT( + SBBlock(m_opaque_up ? m_opaque_up->block : nullptr)); +} + +SBLineEntry SBSymbolContext::GetLineEntry() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBLineEntry, SBSymbolContext, GetLineEntry); + + SBLineEntry sb_line_entry; + if (m_opaque_up) + sb_line_entry.SetLineEntry(m_opaque_up->line_entry); + + return LLDB_RECORD_RESULT(sb_line_entry); +} + +SBSymbol SBSymbolContext::GetSymbol() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSymbol, SBSymbolContext, GetSymbol); + + Symbol *symbol = nullptr; + + if (m_opaque_up) + symbol = m_opaque_up->symbol; + + SBSymbol sb_symbol(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 + ref().line_entry.Clear(); +} + +void SBSymbolContext::SetSymbol(lldb::SBSymbol symbol) { + LLDB_RECORD_METHOD(void, SBSymbolContext, SetSymbol, (lldb::SBSymbol), + symbol); + + ref().symbol = symbol.get(); +} + +lldb_private::SymbolContext *SBSymbolContext::operator->() const { + return m_opaque_up.get(); +} + +const lldb_private::SymbolContext &SBSymbolContext::operator*() const { + assert(m_opaque_up.get()); + return *m_opaque_up; +} + +lldb_private::SymbolContext &SBSymbolContext::operator*() { + if (m_opaque_up == nullptr) + m_opaque_up = std::make_unique<SymbolContext>(); + return *m_opaque_up; +} + +lldb_private::SymbolContext &SBSymbolContext::ref() { + if (m_opaque_up == nullptr) + m_opaque_up = std::make_unique<SymbolContext>(); + return *m_opaque_up; +} + +lldb_private::SymbolContext *SBSymbolContext::get() const { + return m_opaque_up.get(); +} + +bool SBSymbolContext::GetDescription(SBStream &description) { + LLDB_RECORD_METHOD(bool, SBSymbolContext, GetDescription, (lldb::SBStream &), + description); + + Stream &strm = description.ref(); + + if (m_opaque_up) { + m_opaque_up->GetDescription(&strm, lldb::eDescriptionLevelFull, nullptr); + } else + strm.PutCString("No value"); + + return true; +} + +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 LLDB_RECORD_RESULT(sb_sc); + } + return LLDB_RECORD_RESULT(SBSymbolContext()); +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBSymbolContext>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext, ()); + LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext, + (const lldb_private::SymbolContext *)); + LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext, (const lldb::SBSymbolContext &)); + LLDB_REGISTER_METHOD( + const lldb::SBSymbolContext &, + SBSymbolContext, operator=,(const lldb::SBSymbolContext &)); + LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContext, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContext, operator bool, ()); + LLDB_REGISTER_METHOD(lldb::SBModule, SBSymbolContext, GetModule, ()); + LLDB_REGISTER_METHOD(lldb::SBCompileUnit, SBSymbolContext, GetCompileUnit, + ()); + LLDB_REGISTER_METHOD(lldb::SBFunction, SBSymbolContext, GetFunction, ()); + LLDB_REGISTER_METHOD(lldb::SBBlock, SBSymbolContext, GetBlock, ()); + LLDB_REGISTER_METHOD(lldb::SBLineEntry, SBSymbolContext, GetLineEntry, ()); + LLDB_REGISTER_METHOD(lldb::SBSymbol, SBSymbolContext, GetSymbol, ()); + LLDB_REGISTER_METHOD(void, SBSymbolContext, SetModule, (lldb::SBModule)); + LLDB_REGISTER_METHOD(void, SBSymbolContext, SetCompileUnit, + (lldb::SBCompileUnit)); + LLDB_REGISTER_METHOD(void, SBSymbolContext, SetFunction, + (lldb::SBFunction)); + LLDB_REGISTER_METHOD(void, SBSymbolContext, SetBlock, (lldb::SBBlock)); + LLDB_REGISTER_METHOD(void, SBSymbolContext, SetLineEntry, + (lldb::SBLineEntry)); + LLDB_REGISTER_METHOD(void, SBSymbolContext, SetSymbol, (lldb::SBSymbol)); + LLDB_REGISTER_METHOD(bool, SBSymbolContext, GetDescription, + (lldb::SBStream &)); + LLDB_REGISTER_METHOD_CONST(lldb::SBSymbolContext, SBSymbolContext, + GetParentOfInlinedScope, + (const lldb::SBAddress &, lldb::SBAddress &)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBSymbolContextList.cpp b/contrib/llvm-project/lldb/source/API/SBSymbolContextList.cpp new file mode 100644 index 000000000000..9db84dc1bf4b --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBSymbolContextList.cpp @@ -0,0 +1,144 @@ +//===-- SBSymbolContextList.cpp -------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBSymbolContextList.h" +#include "SBReproducerPrivate.h" +#include "Utils.h" +#include "lldb/API/SBStream.h" +#include "lldb/Symbol/SymbolContext.h" + +using namespace lldb; +using namespace lldb_private; + +SBSymbolContextList::SBSymbolContextList() + : 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); +} + +SBSymbolContextList::~SBSymbolContextList() = default; + +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 LLDB_RECORD_RESULT(*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; + if (m_opaque_up->GetContextAtIndex(idx, sc)) { + sb_sc.SetSymbolContext(&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 { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContextList, IsValid); + return this->operator bool(); +} +SBSymbolContextList::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContextList, operator bool); + + return m_opaque_up != nullptr; +} + +lldb_private::SymbolContextList *SBSymbolContextList::operator->() const { + return m_opaque_up.get(); +} + +lldb_private::SymbolContextList &SBSymbolContextList::operator*() const { + assert(m_opaque_up.get()); + return *m_opaque_up; +} + +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, nullptr); + return true; +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBSymbolContextList>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBSymbolContextList, ()); + LLDB_REGISTER_CONSTRUCTOR(SBSymbolContextList, + (const lldb::SBSymbolContextList &)); + LLDB_REGISTER_METHOD( + const lldb::SBSymbolContextList &, + SBSymbolContextList, operator=,(const lldb::SBSymbolContextList &)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBSymbolContextList, GetSize, ()); + LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBSymbolContextList, + GetContextAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(void, SBSymbolContextList, Clear, ()); + LLDB_REGISTER_METHOD(void, SBSymbolContextList, Append, + (lldb::SBSymbolContext &)); + LLDB_REGISTER_METHOD(void, SBSymbolContextList, Append, + (lldb::SBSymbolContextList &)); + LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContextList, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContextList, operator bool, ()); + LLDB_REGISTER_METHOD(bool, SBSymbolContextList, GetDescription, + (lldb::SBStream &)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBTarget.cpp b/contrib/llvm-project/lldb/source/API/SBTarget.cpp new file mode 100644 index 000000000000..b84e9f10fafe --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBTarget.cpp @@ -0,0 +1,2661 @@ +//===-- SBTarget.cpp ------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBTarget.h" +#include "SBReproducerPrivate.h" + +#include "lldb/lldb-public.h" + +#include "lldb/API/SBBreakpoint.h" +#include "lldb/API/SBDebugger.h" +#include "lldb/API/SBEnvironment.h" +#include "lldb/API/SBEvent.h" +#include "lldb/API/SBExpressionOptions.h" +#include "lldb/API/SBFileSpec.h" +#include "lldb/API/SBListener.h" +#include "lldb/API/SBModule.h" +#include "lldb/API/SBModuleSpec.h" +#include "lldb/API/SBProcess.h" +#include "lldb/API/SBSourceManager.h" +#include "lldb/API/SBStream.h" +#include "lldb/API/SBStringList.h" +#include "lldb/API/SBStructuredData.h" +#include "lldb/API/SBSymbolContextList.h" +#include "lldb/Breakpoint/BreakpointID.h" +#include "lldb/Breakpoint/BreakpointIDList.h" +#include "lldb/Breakpoint/BreakpointList.h" +#include "lldb/Breakpoint/BreakpointLocation.h" +#include "lldb/Core/Address.h" +#include "lldb/Core/AddressResolver.h" +#include "lldb/Core/AddressResolverName.h" +#include "lldb/Core/Debugger.h" +#include "lldb/Core/Disassembler.h" +#include "lldb/Core/Module.h" +#include "lldb/Core/ModuleSpec.h" +#include "lldb/Core/SearchFilter.h" +#include "lldb/Core/Section.h" +#include "lldb/Core/StructuredDataImpl.h" +#include "lldb/Core/ValueObjectConstResult.h" +#include "lldb/Core/ValueObjectList.h" +#include "lldb/Core/ValueObjectVariable.h" +#include "lldb/Host/Host.h" +#include "lldb/Symbol/DeclVendor.h" +#include "lldb/Symbol/ObjectFile.h" +#include "lldb/Symbol/SymbolFile.h" +#include "lldb/Symbol/SymbolVendor.h" +#include "lldb/Symbol/TypeSystem.h" +#include "lldb/Symbol/VariableList.h" +#include "lldb/Target/ABI.h" +#include "lldb/Target/Language.h" +#include "lldb/Target/LanguageRuntime.h" +#include "lldb/Target/Process.h" +#include "lldb/Target/StackFrame.h" +#include "lldb/Target/Target.h" +#include "lldb/Target/TargetList.h" +#include "lldb/Utility/ArchSpec.h" +#include "lldb/Utility/Args.h" +#include "lldb/Utility/FileSpec.h" +#include "lldb/Utility/ProcessInfo.h" +#include "lldb/Utility/RegularExpression.h" + +#include "Commands/CommandObjectBreakpoint.h" +#include "lldb/Interpreter/CommandReturnObject.h" +#include "llvm/Support/PrettyStackTrace.h" +#include "llvm/Support/Regex.h" + +using namespace lldb; +using namespace lldb_private; + +#define DEFAULT_DISASM_BYTE_SIZE 32 + +namespace { + +Status AttachToProcess(ProcessAttachInfo &attach_info, Target &target) { + std::lock_guard<std::recursive_mutex> guard(target.GetAPIMutex()); + + auto process_sp = target.GetProcessSP(); + if (process_sp) { + const auto state = process_sp->GetState(); + if (process_sp->IsAlive() && state == eStateConnected) { + // If we are already connected, then we have already specified the + // listener, so if a valid listener is supplied, we need to error out to + // let the client know. + if (attach_info.GetListener()) + return Status("process is connected and already has a listener, pass " + "empty listener"); + } + } + + return target.Attach(attach_info, nullptr); +} + +} // namespace + +// SBTarget constructor +SBTarget::SBTarget() : m_opaque_sp() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTarget); +} + +SBTarget::SBTarget(const SBTarget &rhs) : m_opaque_sp(rhs.m_opaque_sp) { + LLDB_RECORD_CONSTRUCTOR(SBTarget, (const lldb::SBTarget &), rhs); +} + +SBTarget::SBTarget(const TargetSP &target_sp) : m_opaque_sp(target_sp) { + LLDB_RECORD_CONSTRUCTOR(SBTarget, (const lldb::TargetSP &), target_sp); +} + +const SBTarget &SBTarget::operator=(const SBTarget &rhs) { + LLDB_RECORD_METHOD(const lldb::SBTarget &, + SBTarget, operator=,(const lldb::SBTarget &), rhs); + + if (this != &rhs) + m_opaque_sp = rhs.m_opaque_sp; + return LLDB_RECORD_RESULT(*this); +} + +// Destructor +SBTarget::~SBTarget() = default; + +bool SBTarget::EventIsTargetEvent(const SBEvent &event) { + LLDB_RECORD_STATIC_METHOD(bool, SBTarget, EventIsTargetEvent, + (const lldb::SBEvent &), event); + + return Target::TargetEventData::GetEventDataFromEvent(event.get()) != nullptr; +} + +SBTarget SBTarget::GetTargetFromEvent(const SBEvent &event) { + LLDB_RECORD_STATIC_METHOD(lldb::SBTarget, SBTarget, GetTargetFromEvent, + (const lldb::SBEvent &), event); + + return LLDB_RECORD_RESULT( + Target::TargetEventData::GetTargetFromEvent(event.get())); +} + +uint32_t SBTarget::GetNumModulesFromEvent(const SBEvent &event) { + LLDB_RECORD_STATIC_METHOD(uint32_t, SBTarget, GetNumModulesFromEvent, + (const lldb::SBEvent &), event); + + const ModuleList module_list = + Target::TargetEventData::GetModuleListFromEvent(event.get()); + return module_list.GetSize(); +} + +SBModule SBTarget::GetModuleAtIndexFromEvent(const uint32_t idx, + const SBEvent &event) { + LLDB_RECORD_STATIC_METHOD(lldb::SBModule, SBTarget, GetModuleAtIndexFromEvent, + (const uint32_t, const lldb::SBEvent &), idx, + event); + + const ModuleList module_list = + Target::TargetEventData::GetModuleListFromEvent(event.get()); + return LLDB_RECORD_RESULT(SBModule(module_list.GetModuleAtIndex(idx))); +} + +const char *SBTarget::GetBroadcasterClassName() { + LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBTarget, + GetBroadcasterClassName); + + return Target::GetStaticBroadcasterClass().AsCString(); +} + +bool SBTarget::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTarget, IsValid); + return this->operator bool(); +} +SBTarget::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTarget, operator bool); + + return m_opaque_sp.get() != nullptr && m_opaque_sp->IsValid(); +} + +SBProcess SBTarget::GetProcess() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBTarget, GetProcess); + + SBProcess sb_process; + ProcessSP process_sp; + TargetSP target_sp(GetSP()); + if (target_sp) { + process_sp = target_sp->GetProcessSP(); + sb_process.SetSP(process_sp); + } + + return LLDB_RECORD_RESULT(sb_process); +} + +SBPlatform SBTarget::GetPlatform() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBPlatform, SBTarget, GetPlatform); + + TargetSP target_sp(GetSP()); + if (!target_sp) + return LLDB_RECORD_RESULT(SBPlatform()); + + SBPlatform platform; + platform.m_opaque_sp = target_sp->GetPlatform(); + + return LLDB_RECORD_RESULT(platform); +} + +SBDebugger SBTarget::GetDebugger() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBDebugger, SBTarget, GetDebugger); + + SBDebugger debugger; + TargetSP target_sp(GetSP()); + if (target_sp) + debugger.reset(target_sp->GetDebugger().shared_from_this()); + return LLDB_RECORD_RESULT(debugger); +} + +SBStructuredData SBTarget::GetStatistics() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStructuredData, SBTarget, GetStatistics); + + SBStructuredData data; + TargetSP target_sp(GetSP()); + if (!target_sp) + return LLDB_RECORD_RESULT(data); + + auto stats_up = std::make_unique<StructuredData::Dictionary>(); + int i = 0; + for (auto &Entry : target_sp->GetStatistics()) { + std::string Desc = lldb_private::GetStatDescription( + static_cast<lldb_private::StatisticKind>(i)); + stats_up->AddIntegerItem(Desc, Entry); + i += 1; + } + + data.m_impl_up->SetObjectSP(std::move(stats_up)); + return LLDB_RECORD_RESULT(data); +} + +void SBTarget::SetCollectingStats(bool v) { + LLDB_RECORD_METHOD(void, SBTarget, SetCollectingStats, (bool), v); + + TargetSP target_sp(GetSP()); + if (!target_sp) + return; + return target_sp->SetCollectingStats(v); +} + +bool SBTarget::GetCollectingStats() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, GetCollectingStats); + + TargetSP target_sp(GetSP()); + if (!target_sp) + return false; + return target_sp->GetCollectingStats(); +} + +SBProcess SBTarget::LoadCore(const char *core_file) { + LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, LoadCore, (const char *), + core_file); + + lldb::SBError error; // Ignored + return LLDB_RECORD_RESULT(LoadCore(core_file, error)); +} + +SBProcess SBTarget::LoadCore(const char *core_file, lldb::SBError &error) { + LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, LoadCore, + (const char *, lldb::SBError &), core_file, error); + + SBProcess sb_process; + TargetSP target_sp(GetSP()); + if (target_sp) { + FileSpec filespec(core_file); + FileSystem::Instance().Resolve(filespec); + ProcessSP process_sp(target_sp->CreateProcess( + target_sp->GetDebugger().GetListener(), "", &filespec)); + if (process_sp) { + error.SetError(process_sp->LoadCore()); + if (error.Success()) + sb_process.SetSP(process_sp); + } else { + error.SetErrorString("Failed to create the process"); + } + } else { + error.SetErrorString("SBTarget is invalid"); + } + return LLDB_RECORD_RESULT(sb_process); +} + +SBProcess SBTarget::LaunchSimple(char const **argv, char const **envp, + const char *working_directory) { + LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, LaunchSimple, + (const char **, const char **, const char *), argv, envp, + working_directory); + + char *stdin_path = nullptr; + char *stdout_path = nullptr; + char *stderr_path = nullptr; + uint32_t launch_flags = 0; + bool stop_at_entry = false; + SBError error; + SBListener listener = GetDebugger().GetListener(); + return LLDB_RECORD_RESULT(Launch(listener, argv, envp, stdin_path, + stdout_path, stderr_path, working_directory, + launch_flags, stop_at_entry, error)); +} + +SBError SBTarget::Install() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBTarget, Install); + + SBError sb_error; + TargetSP target_sp(GetSP()); + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + sb_error.ref() = target_sp->Install(nullptr); + } + return LLDB_RECORD_RESULT(sb_error); +} + +SBProcess SBTarget::Launch(SBListener &listener, char const **argv, + char const **envp, const char *stdin_path, + const char *stdout_path, const char *stderr_path, + const char *working_directory, + uint32_t launch_flags, // See LaunchFlags + bool stop_at_entry, lldb::SBError &error) { + LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, Launch, + (lldb::SBListener &, const char **, const char **, + const char *, const char *, const char *, const char *, + uint32_t, bool, lldb::SBError &), + listener, argv, envp, stdin_path, stdout_path, stderr_path, + working_directory, launch_flags, stop_at_entry, error); + + SBProcess sb_process; + ProcessSP process_sp; + TargetSP target_sp(GetSP()); + + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + + if (stop_at_entry) + launch_flags |= eLaunchFlagStopAtEntry; + + if (getenv("LLDB_LAUNCH_FLAG_DISABLE_ASLR")) + launch_flags |= eLaunchFlagDisableASLR; + + StateType state = eStateInvalid; + process_sp = target_sp->GetProcessSP(); + if (process_sp) { + state = process_sp->GetState(); + + if (process_sp->IsAlive() && state != eStateConnected) { + if (state == eStateAttaching) + error.SetErrorString("process attach is in progress"); + else + error.SetErrorString("a process is already being debugged"); + return LLDB_RECORD_RESULT(sb_process); + } + } + + if (state == eStateConnected) { + // If we are already connected, then we have already specified the + // listener, so if a valid listener is supplied, we need to error out to + // let the client know. + if (listener.IsValid()) { + error.SetErrorString("process is connected and already has a listener, " + "pass empty listener"); + return LLDB_RECORD_RESULT(sb_process); + } + } + + if (getenv("LLDB_LAUNCH_FLAG_DISABLE_STDIO")) + launch_flags |= eLaunchFlagDisableSTDIO; + + ProcessLaunchInfo launch_info(FileSpec(stdin_path), FileSpec(stdout_path), + FileSpec(stderr_path), + FileSpec(working_directory), launch_flags); + + Module *exe_module = target_sp->GetExecutableModulePointer(); + if (exe_module) + launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), true); + if (argv) { + launch_info.GetArguments().AppendArguments(argv); + } else { + auto default_launch_info = target_sp->GetProcessLaunchInfo(); + launch_info.GetArguments().AppendArguments( + default_launch_info.GetArguments()); + } + if (envp) { + launch_info.GetEnvironment() = Environment(envp); + } else { + auto default_launch_info = target_sp->GetProcessLaunchInfo(); + launch_info.GetEnvironment() = default_launch_info.GetEnvironment(); + } + + if (listener.IsValid()) + launch_info.SetListener(listener.GetSP()); + + error.SetError(target_sp->Launch(launch_info, nullptr)); + + sb_process.SetSP(target_sp->GetProcessSP()); + } else { + error.SetErrorString("SBTarget is invalid"); + } + + return LLDB_RECORD_RESULT(sb_process); +} + +SBProcess SBTarget::Launch(SBLaunchInfo &sb_launch_info, SBError &error) { + LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, Launch, + (lldb::SBLaunchInfo &, lldb::SBError &), sb_launch_info, + error); + + + SBProcess sb_process; + TargetSP target_sp(GetSP()); + + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + StateType state = eStateInvalid; + { + ProcessSP process_sp = target_sp->GetProcessSP(); + if (process_sp) { + state = process_sp->GetState(); + + if (process_sp->IsAlive() && state != eStateConnected) { + if (state == eStateAttaching) + error.SetErrorString("process attach is in progress"); + else + error.SetErrorString("a process is already being debugged"); + return LLDB_RECORD_RESULT(sb_process); + } + } + } + + lldb_private::ProcessLaunchInfo launch_info = sb_launch_info.ref(); + + if (!launch_info.GetExecutableFile()) { + Module *exe_module = target_sp->GetExecutableModulePointer(); + if (exe_module) + launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), true); + } + + const ArchSpec &arch_spec = target_sp->GetArchitecture(); + if (arch_spec.IsValid()) + launch_info.GetArchitecture() = arch_spec; + + error.SetError(target_sp->Launch(launch_info, nullptr)); + sb_launch_info.set_ref(launch_info); + sb_process.SetSP(target_sp->GetProcessSP()); + } else { + error.SetErrorString("SBTarget is invalid"); + } + + return LLDB_RECORD_RESULT(sb_process); +} + +lldb::SBProcess SBTarget::Attach(SBAttachInfo &sb_attach_info, SBError &error) { + LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, Attach, + (lldb::SBAttachInfo &, lldb::SBError &), sb_attach_info, + error); + + SBProcess sb_process; + TargetSP target_sp(GetSP()); + + if (target_sp) { + ProcessAttachInfo &attach_info = sb_attach_info.ref(); + if (attach_info.ProcessIDIsValid() && !attach_info.UserIDIsValid()) { + PlatformSP platform_sp = target_sp->GetPlatform(); + // See if we can pre-verify if a process exists or not + if (platform_sp && platform_sp->IsConnected()) { + lldb::pid_t attach_pid = attach_info.GetProcessID(); + ProcessInstanceInfo instance_info; + if (platform_sp->GetProcessInfo(attach_pid, instance_info)) { + attach_info.SetUserID(instance_info.GetEffectiveUserID()); + } else { + error.ref().SetErrorStringWithFormat( + "no process found with process ID %" PRIu64, attach_pid); + return LLDB_RECORD_RESULT(sb_process); + } + } + } + error.SetError(AttachToProcess(attach_info, *target_sp)); + if (error.Success()) + sb_process.SetSP(target_sp->GetProcessSP()); + } else { + error.SetErrorString("SBTarget is invalid"); + } + + return LLDB_RECORD_RESULT(sb_process); +} + +lldb::SBProcess SBTarget::AttachToProcessWithID( + SBListener &listener, + lldb::pid_t pid, // The process ID to attach to + SBError &error // An error explaining what went wrong if attach fails +) { + LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, AttachToProcessWithID, + (lldb::SBListener &, lldb::pid_t, lldb::SBError &), + listener, pid, error); + + SBProcess sb_process; + TargetSP target_sp(GetSP()); + + if (target_sp) { + ProcessAttachInfo attach_info; + attach_info.SetProcessID(pid); + if (listener.IsValid()) + attach_info.SetListener(listener.GetSP()); + + ProcessInstanceInfo instance_info; + if (target_sp->GetPlatform()->GetProcessInfo(pid, instance_info)) + attach_info.SetUserID(instance_info.GetEffectiveUserID()); + + error.SetError(AttachToProcess(attach_info, *target_sp)); + if (error.Success()) + sb_process.SetSP(target_sp->GetProcessSP()); + } else + error.SetErrorString("SBTarget is invalid"); + + return LLDB_RECORD_RESULT(sb_process); +} + +lldb::SBProcess SBTarget::AttachToProcessWithName( + SBListener &listener, + const char *name, // basename of process to attach to + bool wait_for, // if true wait for a new instance of "name" to be launched + SBError &error // An error explaining what went wrong if attach fails +) { + LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, AttachToProcessWithName, + (lldb::SBListener &, const char *, bool, lldb::SBError &), + listener, name, wait_for, error); + + SBProcess sb_process; + TargetSP target_sp(GetSP()); + + if (name && target_sp) { + ProcessAttachInfo attach_info; + attach_info.GetExecutableFile().SetFile(name, FileSpec::Style::native); + attach_info.SetWaitForLaunch(wait_for); + if (listener.IsValid()) + attach_info.SetListener(listener.GetSP()); + + error.SetError(AttachToProcess(attach_info, *target_sp)); + if (error.Success()) + sb_process.SetSP(target_sp->GetProcessSP()); + } else + error.SetErrorString("SBTarget is invalid"); + + return LLDB_RECORD_RESULT(sb_process); +} + +lldb::SBProcess SBTarget::ConnectRemote(SBListener &listener, const char *url, + const char *plugin_name, + SBError &error) { + LLDB_RECORD_METHOD( + lldb::SBProcess, SBTarget, ConnectRemote, + (lldb::SBListener &, const char *, const char *, lldb::SBError &), + listener, url, plugin_name, error); + + SBProcess sb_process; + ProcessSP process_sp; + TargetSP target_sp(GetSP()); + + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + if (listener.IsValid()) + process_sp = + target_sp->CreateProcess(listener.m_opaque_sp, plugin_name, nullptr); + else + process_sp = target_sp->CreateProcess( + target_sp->GetDebugger().GetListener(), plugin_name, nullptr); + + if (process_sp) { + sb_process.SetSP(process_sp); + error.SetError(process_sp->ConnectRemote(url)); + } else { + error.SetErrorString("unable to create lldb_private::Process"); + } + } else { + error.SetErrorString("SBTarget is invalid"); + } + + return LLDB_RECORD_RESULT(sb_process); +} + +SBFileSpec SBTarget::GetExecutable() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBTarget, GetExecutable); + + SBFileSpec exe_file_spec; + TargetSP target_sp(GetSP()); + if (target_sp) { + Module *exe_module = target_sp->GetExecutableModulePointer(); + if (exe_module) + exe_file_spec.SetFileSpec(exe_module->GetFileSpec()); + } + + return LLDB_RECORD_RESULT(exe_file_spec); +} + +bool SBTarget::operator==(const SBTarget &rhs) const { + LLDB_RECORD_METHOD_CONST(bool, SBTarget, operator==,(const lldb::SBTarget &), + rhs); + + return m_opaque_sp.get() == rhs.m_opaque_sp.get(); +} + +bool SBTarget::operator!=(const SBTarget &rhs) const { + LLDB_RECORD_METHOD_CONST(bool, SBTarget, operator!=,(const lldb::SBTarget &), + rhs); + + return m_opaque_sp.get() != rhs.m_opaque_sp.get(); +} + +lldb::TargetSP SBTarget::GetSP() const { return m_opaque_sp; } + +void SBTarget::SetSP(const lldb::TargetSP &target_sp) { + m_opaque_sp = target_sp; +} + +lldb::SBAddress SBTarget::ResolveLoadAddress(lldb::addr_t vm_addr) { + LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolveLoadAddress, + (lldb::addr_t), vm_addr); + + lldb::SBAddress sb_addr; + Address &addr = sb_addr.ref(); + TargetSP target_sp(GetSP()); + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + if (target_sp->ResolveLoadAddress(vm_addr, addr)) + return LLDB_RECORD_RESULT(sb_addr); + } + + // We have a load address that isn't in a section, just return an address + // with the offset filled in (the address) and the section set to NULL + addr.SetRawAddress(vm_addr); + return LLDB_RECORD_RESULT(sb_addr); +} + +lldb::SBAddress SBTarget::ResolveFileAddress(lldb::addr_t file_addr) { + LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolveFileAddress, + (lldb::addr_t), file_addr); + + lldb::SBAddress sb_addr; + Address &addr = sb_addr.ref(); + TargetSP target_sp(GetSP()); + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + if (target_sp->ResolveFileAddress(file_addr, addr)) + return LLDB_RECORD_RESULT(sb_addr); + } + + addr.SetRawAddress(file_addr); + return LLDB_RECORD_RESULT(sb_addr); +} + +lldb::SBAddress SBTarget::ResolvePastLoadAddress(uint32_t stop_id, + lldb::addr_t vm_addr) { + LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolvePastLoadAddress, + (uint32_t, lldb::addr_t), stop_id, vm_addr); + + lldb::SBAddress sb_addr; + Address &addr = sb_addr.ref(); + TargetSP target_sp(GetSP()); + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + if (target_sp->ResolveLoadAddress(vm_addr, addr)) + return LLDB_RECORD_RESULT(sb_addr); + } + + // We have a load address that isn't in a section, just return an address + // with the offset filled in (the address) and the section set to NULL + addr.SetRawAddress(vm_addr); + return LLDB_RECORD_RESULT(sb_addr); +} + +SBSymbolContext +SBTarget::ResolveSymbolContextForAddress(const SBAddress &addr, + uint32_t resolve_scope) { + LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBTarget, + ResolveSymbolContextForAddress, + (const lldb::SBAddress &, uint32_t), addr, resolve_scope); + + SBSymbolContext sc; + SymbolContextItem scope = static_cast<SymbolContextItem>(resolve_scope); + if (addr.IsValid()) { + TargetSP target_sp(GetSP()); + if (target_sp) + target_sp->GetImages().ResolveSymbolContextForAddress(addr.ref(), scope, + sc.ref()); + } + return LLDB_RECORD_RESULT(sc); +} + +size_t SBTarget::ReadMemory(const SBAddress addr, void *buf, size_t size, + lldb::SBError &error) { + LLDB_RECORD_METHOD(size_t, SBTarget, ReadMemory, + (const lldb::SBAddress, void *, size_t, lldb::SBError &), + addr, buf, size, error); + + SBError sb_error; + size_t bytes_read = 0; + TargetSP target_sp(GetSP()); + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + bytes_read = + target_sp->ReadMemory(addr.ref(), false, buf, size, sb_error.ref()); + } else { + sb_error.SetErrorString("invalid target"); + } + + return bytes_read; +} + +SBBreakpoint SBTarget::BreakpointCreateByLocation(const char *file, + uint32_t line) { + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation, + (const char *, uint32_t), file, line); + + return LLDB_RECORD_RESULT( + SBBreakpoint(BreakpointCreateByLocation(SBFileSpec(file, false), line))); +} + +SBBreakpoint +SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec, + uint32_t line) { + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation, + (const lldb::SBFileSpec &, uint32_t), sb_file_spec, line); + + return LLDB_RECORD_RESULT(BreakpointCreateByLocation(sb_file_spec, line, 0)); +} + +SBBreakpoint +SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec, + uint32_t line, lldb::addr_t offset) { + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation, + (const lldb::SBFileSpec &, uint32_t, lldb::addr_t), + sb_file_spec, line, offset); + + SBFileSpecList empty_list; + return LLDB_RECORD_RESULT( + BreakpointCreateByLocation(sb_file_spec, line, offset, empty_list)); +} + +SBBreakpoint +SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec, + uint32_t line, lldb::addr_t offset, + SBFileSpecList &sb_module_list) { + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation, + (const lldb::SBFileSpec &, uint32_t, lldb::addr_t, + lldb::SBFileSpecList &), + sb_file_spec, line, offset, sb_module_list); + + return LLDB_RECORD_RESULT(BreakpointCreateByLocation(sb_file_spec, line, 0, + offset, sb_module_list)); +} + +SBBreakpoint SBTarget::BreakpointCreateByLocation( + const SBFileSpec &sb_file_spec, uint32_t line, uint32_t column, + lldb::addr_t offset, SBFileSpecList &sb_module_list) { + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation, + (const lldb::SBFileSpec &, uint32_t, uint32_t, + lldb::addr_t, lldb::SBFileSpecList &), + sb_file_spec, line, column, offset, sb_module_list); + + SBBreakpoint sb_bp; + TargetSP target_sp(GetSP()); + if (target_sp && line != 0) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + + const LazyBool check_inlines = eLazyBoolCalculate; + const LazyBool skip_prologue = eLazyBoolCalculate; + const bool internal = false; + const bool hardware = false; + const LazyBool move_to_nearest_code = eLazyBoolCalculate; + const FileSpecList *module_list = nullptr; + if (sb_module_list.GetSize() > 0) { + module_list = sb_module_list.get(); + } + sb_bp = target_sp->CreateBreakpoint( + module_list, *sb_file_spec, line, column, offset, check_inlines, + skip_prologue, internal, hardware, move_to_nearest_code); + } + + return LLDB_RECORD_RESULT(sb_bp); +} + +SBBreakpoint SBTarget::BreakpointCreateByName(const char *symbol_name, + const char *module_name) { + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName, + (const char *, const char *), symbol_name, module_name); + + SBBreakpoint sb_bp; + TargetSP target_sp(GetSP()); + if (target_sp.get()) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + + const bool internal = false; + const bool hardware = false; + const LazyBool skip_prologue = eLazyBoolCalculate; + const lldb::addr_t offset = 0; + if (module_name && module_name[0]) { + FileSpecList module_spec_list; + module_spec_list.Append(FileSpec(module_name)); + sb_bp = target_sp->CreateBreakpoint( + &module_spec_list, nullptr, symbol_name, eFunctionNameTypeAuto, + eLanguageTypeUnknown, offset, skip_prologue, internal, hardware); + } else { + sb_bp = target_sp->CreateBreakpoint( + nullptr, nullptr, symbol_name, eFunctionNameTypeAuto, + eLanguageTypeUnknown, offset, skip_prologue, internal, hardware); + } + } + + return LLDB_RECORD_RESULT(sb_bp); +} + +lldb::SBBreakpoint +SBTarget::BreakpointCreateByName(const char *symbol_name, + const SBFileSpecList &module_list, + const SBFileSpecList &comp_unit_list) { + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName, + (const char *, const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &), + symbol_name, module_list, comp_unit_list); + + lldb::FunctionNameType name_type_mask = eFunctionNameTypeAuto; + return LLDB_RECORD_RESULT( + BreakpointCreateByName(symbol_name, name_type_mask, eLanguageTypeUnknown, + module_list, comp_unit_list)); +} + +lldb::SBBreakpoint SBTarget::BreakpointCreateByName( + const char *symbol_name, uint32_t name_type_mask, + const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName, + (const char *, uint32_t, const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &), + symbol_name, name_type_mask, module_list, comp_unit_list); + + return LLDB_RECORD_RESULT( + BreakpointCreateByName(symbol_name, name_type_mask, eLanguageTypeUnknown, + module_list, comp_unit_list)); +} + +lldb::SBBreakpoint SBTarget::BreakpointCreateByName( + const char *symbol_name, uint32_t name_type_mask, + LanguageType symbol_language, const SBFileSpecList &module_list, + const SBFileSpecList &comp_unit_list) { + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName, + (const char *, uint32_t, lldb::LanguageType, + const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &), + symbol_name, name_type_mask, symbol_language, module_list, + comp_unit_list); + + SBBreakpoint sb_bp; + TargetSP target_sp(GetSP()); + if (target_sp && symbol_name && symbol_name[0]) { + const bool internal = false; + const bool hardware = false; + const LazyBool skip_prologue = eLazyBoolCalculate; + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + FunctionNameType mask = static_cast<FunctionNameType>(name_type_mask); + sb_bp = target_sp->CreateBreakpoint(module_list.get(), comp_unit_list.get(), + symbol_name, mask, symbol_language, 0, + skip_prologue, internal, hardware); + } + + return LLDB_RECORD_RESULT(sb_bp); +} + +lldb::SBBreakpoint SBTarget::BreakpointCreateByNames( + const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask, + const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { + LLDB_RECORD_METHOD( + lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames, + (const char **, uint32_t, uint32_t, const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &), + symbol_names, num_names, name_type_mask, module_list, comp_unit_list); + + return LLDB_RECORD_RESULT(BreakpointCreateByNames( + symbol_names, num_names, name_type_mask, eLanguageTypeUnknown, + module_list, comp_unit_list)); +} + +lldb::SBBreakpoint SBTarget::BreakpointCreateByNames( + const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask, + LanguageType symbol_language, const SBFileSpecList &module_list, + const SBFileSpecList &comp_unit_list) { + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames, + (const char **, uint32_t, uint32_t, lldb::LanguageType, + const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &), + symbol_names, num_names, name_type_mask, symbol_language, + module_list, comp_unit_list); + + return LLDB_RECORD_RESULT(BreakpointCreateByNames( + symbol_names, num_names, name_type_mask, eLanguageTypeUnknown, 0, + module_list, comp_unit_list)); +} + +lldb::SBBreakpoint SBTarget::BreakpointCreateByNames( + const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask, + LanguageType symbol_language, lldb::addr_t offset, + const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames, + (const char **, uint32_t, uint32_t, lldb::LanguageType, + lldb::addr_t, const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &), + symbol_names, num_names, name_type_mask, symbol_language, + offset, module_list, comp_unit_list); + + SBBreakpoint sb_bp; + TargetSP target_sp(GetSP()); + if (target_sp && num_names > 0) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + const bool internal = false; + const bool hardware = false; + FunctionNameType mask = static_cast<FunctionNameType>(name_type_mask); + const LazyBool skip_prologue = eLazyBoolCalculate; + sb_bp = target_sp->CreateBreakpoint( + module_list.get(), comp_unit_list.get(), symbol_names, num_names, mask, + symbol_language, offset, skip_prologue, internal, hardware); + } + + return LLDB_RECORD_RESULT(sb_bp); +} + +SBBreakpoint SBTarget::BreakpointCreateByRegex(const char *symbol_name_regex, + const char *module_name) { + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex, + (const char *, const char *), symbol_name_regex, + module_name); + + SBFileSpecList module_spec_list; + SBFileSpecList comp_unit_list; + if (module_name && module_name[0]) { + module_spec_list.Append(FileSpec(module_name)); + } + return LLDB_RECORD_RESULT( + BreakpointCreateByRegex(symbol_name_regex, eLanguageTypeUnknown, + module_spec_list, comp_unit_list)); +} + +lldb::SBBreakpoint +SBTarget::BreakpointCreateByRegex(const char *symbol_name_regex, + const SBFileSpecList &module_list, + const SBFileSpecList &comp_unit_list) { + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex, + (const char *, const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &), + symbol_name_regex, module_list, comp_unit_list); + + return LLDB_RECORD_RESULT(BreakpointCreateByRegex( + symbol_name_regex, eLanguageTypeUnknown, module_list, comp_unit_list)); +} + +lldb::SBBreakpoint SBTarget::BreakpointCreateByRegex( + const char *symbol_name_regex, LanguageType symbol_language, + const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { + LLDB_RECORD_METHOD( + lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex, + (const char *, lldb::LanguageType, const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &), + symbol_name_regex, symbol_language, module_list, comp_unit_list); + + + SBBreakpoint sb_bp; + TargetSP target_sp(GetSP()); + if (target_sp && symbol_name_regex && symbol_name_regex[0]) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + RegularExpression regexp((llvm::StringRef(symbol_name_regex))); + const bool internal = false; + const bool hardware = false; + const LazyBool skip_prologue = eLazyBoolCalculate; + + sb_bp = target_sp->CreateFuncRegexBreakpoint( + module_list.get(), comp_unit_list.get(), std::move(regexp), + symbol_language, skip_prologue, internal, hardware); + } + + return LLDB_RECORD_RESULT(sb_bp); +} + +SBBreakpoint SBTarget::BreakpointCreateByAddress(addr_t address) { + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByAddress, + (lldb::addr_t), address); + + SBBreakpoint sb_bp; + TargetSP target_sp(GetSP()); + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + const bool hardware = false; + sb_bp = target_sp->CreateBreakpoint(address, false, hardware); + } + + return LLDB_RECORD_RESULT(sb_bp); +} + +SBBreakpoint SBTarget::BreakpointCreateBySBAddress(SBAddress &sb_address) { + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateBySBAddress, + (lldb::SBAddress &), sb_address); + + SBBreakpoint sb_bp; + TargetSP target_sp(GetSP()); + if (!sb_address.IsValid()) { + return LLDB_RECORD_RESULT(sb_bp); + } + + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + const bool hardware = false; + sb_bp = target_sp->CreateBreakpoint(sb_address.ref(), false, hardware); + } + + return LLDB_RECORD_RESULT(sb_bp); +} + +lldb::SBBreakpoint +SBTarget::BreakpointCreateBySourceRegex(const char *source_regex, + const lldb::SBFileSpec &source_file, + const char *module_name) { + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, + BreakpointCreateBySourceRegex, + (const char *, const lldb::SBFileSpec &, const char *), + source_regex, source_file, module_name); + + SBFileSpecList module_spec_list; + + if (module_name && module_name[0]) { + module_spec_list.Append(FileSpec(module_name)); + } + + SBFileSpecList source_file_list; + if (source_file.IsValid()) { + source_file_list.Append(source_file); + } + + return LLDB_RECORD_RESULT(BreakpointCreateBySourceRegex( + source_regex, module_spec_list, source_file_list)); +} + +lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex( + const char *source_regex, const SBFileSpecList &module_list, + const lldb::SBFileSpecList &source_file_list) { + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, + BreakpointCreateBySourceRegex, + (const char *, const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &), + source_regex, module_list, source_file_list); + + return LLDB_RECORD_RESULT(BreakpointCreateBySourceRegex( + source_regex, module_list, source_file_list, SBStringList())); +} + +lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex( + const char *source_regex, const SBFileSpecList &module_list, + const lldb::SBFileSpecList &source_file_list, + const SBStringList &func_names) { + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, + BreakpointCreateBySourceRegex, + (const char *, const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &, const lldb::SBStringList &), + source_regex, module_list, source_file_list, func_names); + + SBBreakpoint sb_bp; + TargetSP target_sp(GetSP()); + if (target_sp && source_regex && source_regex[0]) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + const bool hardware = false; + const LazyBool move_to_nearest_code = eLazyBoolCalculate; + RegularExpression regexp((llvm::StringRef(source_regex))); + std::unordered_set<std::string> func_names_set; + for (size_t i = 0; i < func_names.GetSize(); i++) { + func_names_set.insert(func_names.GetStringAtIndex(i)); + } + + sb_bp = target_sp->CreateSourceRegexBreakpoint( + module_list.get(), source_file_list.get(), func_names_set, + std::move(regexp), false, hardware, move_to_nearest_code); + } + + return LLDB_RECORD_RESULT(sb_bp); +} + +lldb::SBBreakpoint +SBTarget::BreakpointCreateForException(lldb::LanguageType language, + bool catch_bp, bool throw_bp) { + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateForException, + (lldb::LanguageType, bool, bool), language, catch_bp, + throw_bp); + + SBBreakpoint sb_bp; + TargetSP target_sp(GetSP()); + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + const bool hardware = false; + sb_bp = target_sp->CreateExceptionBreakpoint(language, catch_bp, throw_bp, + hardware); + } + + return LLDB_RECORD_RESULT(sb_bp); +} + +lldb::SBBreakpoint SBTarget::BreakpointCreateFromScript( + const char *class_name, SBStructuredData &extra_args, + const SBFileSpecList &module_list, const SBFileSpecList &file_list, + bool request_hardware) { + LLDB_RECORD_METHOD( + lldb::SBBreakpoint, SBTarget, BreakpointCreateFromScript, + (const char *, lldb::SBStructuredData &, const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &, bool), + class_name, extra_args, module_list, file_list, request_hardware); + + SBBreakpoint sb_bp; + TargetSP target_sp(GetSP()); + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + Status error; + + StructuredData::ObjectSP obj_sp = extra_args.m_impl_up->GetObjectSP(); + sb_bp = + target_sp->CreateScriptedBreakpoint(class_name, + module_list.get(), + file_list.get(), + false, /* internal */ + request_hardware, + obj_sp, + &error); + } + + return LLDB_RECORD_RESULT(sb_bp); +} + +uint32_t SBTarget::GetNumBreakpoints() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumBreakpoints); + + TargetSP target_sp(GetSP()); + if (target_sp) { + // The breakpoint list is thread safe, no need to lock + return target_sp->GetBreakpointList().GetSize(); + } + return 0; +} + +SBBreakpoint SBTarget::GetBreakpointAtIndex(uint32_t idx) const { + LLDB_RECORD_METHOD_CONST(lldb::SBBreakpoint, SBTarget, GetBreakpointAtIndex, + (uint32_t), idx); + + SBBreakpoint sb_breakpoint; + TargetSP target_sp(GetSP()); + if (target_sp) { + // The breakpoint list is thread safe, no need to lock + sb_breakpoint = target_sp->GetBreakpointList().GetBreakpointAtIndex(idx); + } + return LLDB_RECORD_RESULT(sb_breakpoint); +} + +bool SBTarget::BreakpointDelete(break_id_t bp_id) { + LLDB_RECORD_METHOD(bool, SBTarget, BreakpointDelete, (lldb::break_id_t), + bp_id); + + bool result = false; + TargetSP target_sp(GetSP()); + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + result = target_sp->RemoveBreakpointByID(bp_id); + } + + return result; +} + +SBBreakpoint SBTarget::FindBreakpointByID(break_id_t bp_id) { + LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, FindBreakpointByID, + (lldb::break_id_t), bp_id); + + SBBreakpoint sb_breakpoint; + TargetSP target_sp(GetSP()); + if (target_sp && bp_id != LLDB_INVALID_BREAK_ID) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + sb_breakpoint = target_sp->GetBreakpointByID(bp_id); + } + + return LLDB_RECORD_RESULT(sb_breakpoint); +} + +bool SBTarget::FindBreakpointsByName(const char *name, + SBBreakpointList &bkpts) { + LLDB_RECORD_METHOD(bool, SBTarget, FindBreakpointsByName, + (const char *, lldb::SBBreakpointList &), name, bkpts); + + TargetSP target_sp(GetSP()); + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + llvm::Expected<std::vector<BreakpointSP>> expected_vector = + target_sp->GetBreakpointList().FindBreakpointsByName(name); + if (!expected_vector) { + LLDB_LOG(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS), + "invalid breakpoint name: {}", + llvm::toString(expected_vector.takeError())); + return false; + } + for (BreakpointSP bkpt_sp : *expected_vector) { + bkpts.AppendByID(bkpt_sp->GetID()); + } + } + return true; +} + +void SBTarget::GetBreakpointNames(SBStringList &names) { + LLDB_RECORD_METHOD(void, SBTarget, GetBreakpointNames, (lldb::SBStringList &), + names); + + names.Clear(); + + TargetSP target_sp(GetSP()); + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + + std::vector<std::string> name_vec; + target_sp->GetBreakpointNames(name_vec); + for (auto name : name_vec) + names.AppendString(name.c_str()); + } +} + +void SBTarget::DeleteBreakpointName(const char *name) { + LLDB_RECORD_METHOD(void, SBTarget, DeleteBreakpointName, (const char *), + name); + + TargetSP target_sp(GetSP()); + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + target_sp->DeleteBreakpointName(ConstString(name)); + } +} + +bool SBTarget::EnableAllBreakpoints() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, EnableAllBreakpoints); + + TargetSP target_sp(GetSP()); + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + target_sp->EnableAllowedBreakpoints(); + return true; + } + return false; +} + +bool SBTarget::DisableAllBreakpoints() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DisableAllBreakpoints); + + TargetSP target_sp(GetSP()); + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + target_sp->DisableAllowedBreakpoints(); + return true; + } + return false; +} + +bool SBTarget::DeleteAllBreakpoints() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DeleteAllBreakpoints); + + TargetSP target_sp(GetSP()); + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + target_sp->RemoveAllowedBreakpoints(); + return true; + } + return false; +} + +lldb::SBError SBTarget::BreakpointsCreateFromFile(SBFileSpec &source_file, + SBBreakpointList &new_bps) { + LLDB_RECORD_METHOD(lldb::SBError, SBTarget, BreakpointsCreateFromFile, + (lldb::SBFileSpec &, lldb::SBBreakpointList &), + source_file, new_bps); + + SBStringList empty_name_list; + return LLDB_RECORD_RESULT( + BreakpointsCreateFromFile(source_file, empty_name_list, new_bps)); +} + +lldb::SBError SBTarget::BreakpointsCreateFromFile(SBFileSpec &source_file, + SBStringList &matching_names, + SBBreakpointList &new_bps) { + LLDB_RECORD_METHOD( + lldb::SBError, SBTarget, BreakpointsCreateFromFile, + (lldb::SBFileSpec &, lldb::SBStringList &, lldb::SBBreakpointList &), + source_file, matching_names, new_bps); + + SBError sberr; + TargetSP target_sp(GetSP()); + if (!target_sp) { + sberr.SetErrorString( + "BreakpointCreateFromFile called with invalid target."); + return LLDB_RECORD_RESULT(sberr); + } + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + + BreakpointIDList bp_ids; + + std::vector<std::string> name_vector; + size_t num_names = matching_names.GetSize(); + for (size_t i = 0; i < num_names; i++) + name_vector.push_back(matching_names.GetStringAtIndex(i)); + + sberr.ref() = target_sp->CreateBreakpointsFromFile(source_file.ref(), + name_vector, bp_ids); + if (sberr.Fail()) + return LLDB_RECORD_RESULT(sberr); + + size_t num_bkpts = bp_ids.GetSize(); + for (size_t i = 0; i < num_bkpts; i++) { + BreakpointID bp_id = bp_ids.GetBreakpointIDAtIndex(i); + new_bps.AppendByID(bp_id.GetBreakpointID()); + } + return LLDB_RECORD_RESULT(sberr); +} + +lldb::SBError SBTarget::BreakpointsWriteToFile(SBFileSpec &dest_file) { + LLDB_RECORD_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile, + (lldb::SBFileSpec &), dest_file); + + SBError sberr; + TargetSP target_sp(GetSP()); + if (!target_sp) { + sberr.SetErrorString("BreakpointWriteToFile called with invalid target."); + return LLDB_RECORD_RESULT(sberr); + } + SBBreakpointList bkpt_list(*this); + return LLDB_RECORD_RESULT(BreakpointsWriteToFile(dest_file, bkpt_list)); +} + +lldb::SBError SBTarget::BreakpointsWriteToFile(SBFileSpec &dest_file, + SBBreakpointList &bkpt_list, + bool append) { + LLDB_RECORD_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile, + (lldb::SBFileSpec &, lldb::SBBreakpointList &, bool), + dest_file, bkpt_list, append); + + SBError sberr; + TargetSP target_sp(GetSP()); + if (!target_sp) { + sberr.SetErrorString("BreakpointWriteToFile called with invalid target."); + return LLDB_RECORD_RESULT(sberr); + } + + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + BreakpointIDList bp_id_list; + bkpt_list.CopyToBreakpointIDList(bp_id_list); + sberr.ref() = target_sp->SerializeBreakpointsToFile(dest_file.ref(), + bp_id_list, append); + return LLDB_RECORD_RESULT(sberr); +} + +uint32_t SBTarget::GetNumWatchpoints() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumWatchpoints); + + TargetSP target_sp(GetSP()); + if (target_sp) { + // The watchpoint list is thread safe, no need to lock + return target_sp->GetWatchpointList().GetSize(); + } + return 0; +} + +SBWatchpoint SBTarget::GetWatchpointAtIndex(uint32_t idx) const { + LLDB_RECORD_METHOD_CONST(lldb::SBWatchpoint, SBTarget, GetWatchpointAtIndex, + (uint32_t), idx); + + SBWatchpoint sb_watchpoint; + TargetSP target_sp(GetSP()); + if (target_sp) { + // The watchpoint list is thread safe, no need to lock + sb_watchpoint.SetSP(target_sp->GetWatchpointList().GetByIndex(idx)); + } + return LLDB_RECORD_RESULT(sb_watchpoint); +} + +bool SBTarget::DeleteWatchpoint(watch_id_t wp_id) { + LLDB_RECORD_METHOD(bool, SBTarget, DeleteWatchpoint, (lldb::watch_id_t), + wp_id); + + + bool result = false; + TargetSP target_sp(GetSP()); + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + std::unique_lock<std::recursive_mutex> lock; + target_sp->GetWatchpointList().GetListMutex(lock); + result = target_sp->RemoveWatchpointByID(wp_id); + } + + return result; +} + +SBWatchpoint SBTarget::FindWatchpointByID(lldb::watch_id_t wp_id) { + LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBTarget, FindWatchpointByID, + (lldb::watch_id_t), wp_id); + + + SBWatchpoint sb_watchpoint; + lldb::WatchpointSP watchpoint_sp; + TargetSP target_sp(GetSP()); + if (target_sp && wp_id != LLDB_INVALID_WATCH_ID) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + std::unique_lock<std::recursive_mutex> lock; + target_sp->GetWatchpointList().GetListMutex(lock); + watchpoint_sp = target_sp->GetWatchpointList().FindByID(wp_id); + sb_watchpoint.SetSP(watchpoint_sp); + } + + return LLDB_RECORD_RESULT(sb_watchpoint); +} + +lldb::SBWatchpoint SBTarget::WatchAddress(lldb::addr_t addr, size_t size, + bool read, bool write, + SBError &error) { + LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBTarget, WatchAddress, + (lldb::addr_t, size_t, bool, bool, lldb::SBError &), addr, + size, read, write, error); + + SBWatchpoint sb_watchpoint; + lldb::WatchpointSP watchpoint_sp; + TargetSP target_sp(GetSP()); + if (target_sp && (read || write) && addr != LLDB_INVALID_ADDRESS && + size > 0) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + uint32_t watch_type = 0; + if (read) + watch_type |= LLDB_WATCH_TYPE_READ; + if (write) + watch_type |= LLDB_WATCH_TYPE_WRITE; + if (watch_type == 0) { + error.SetErrorString( + "Can't create a watchpoint that is neither read nor write."); + return LLDB_RECORD_RESULT(sb_watchpoint); + } + + // Target::CreateWatchpoint() is thread safe. + Status cw_error; + // This API doesn't take in a type, so we can't figure out what it is. + CompilerType *type = nullptr; + watchpoint_sp = + target_sp->CreateWatchpoint(addr, size, type, watch_type, cw_error); + error.SetError(cw_error); + sb_watchpoint.SetSP(watchpoint_sp); + } + + return LLDB_RECORD_RESULT(sb_watchpoint); +} + +bool SBTarget::EnableAllWatchpoints() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, EnableAllWatchpoints); + + TargetSP target_sp(GetSP()); + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + std::unique_lock<std::recursive_mutex> lock; + target_sp->GetWatchpointList().GetListMutex(lock); + target_sp->EnableAllWatchpoints(); + return true; + } + return false; +} + +bool SBTarget::DisableAllWatchpoints() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DisableAllWatchpoints); + + TargetSP target_sp(GetSP()); + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + std::unique_lock<std::recursive_mutex> lock; + target_sp->GetWatchpointList().GetListMutex(lock); + target_sp->DisableAllWatchpoints(); + return true; + } + return false; +} + +SBValue SBTarget::CreateValueFromAddress(const char *name, SBAddress addr, + SBType type) { + LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, CreateValueFromAddress, + (const char *, lldb::SBAddress, lldb::SBType), name, addr, + type); + + SBValue sb_value; + lldb::ValueObjectSP new_value_sp; + if (IsValid() && name && *name && addr.IsValid() && type.IsValid()) { + lldb::addr_t load_addr(addr.GetLoadAddress(*this)); + ExecutionContext exe_ctx( + ExecutionContextRef(ExecutionContext(m_opaque_sp.get(), false))); + CompilerType ast_type(type.GetSP()->GetCompilerType(true)); + new_value_sp = ValueObject::CreateValueObjectFromAddress(name, load_addr, + exe_ctx, ast_type); + } + sb_value.SetSP(new_value_sp); + return LLDB_RECORD_RESULT(sb_value); +} + +lldb::SBValue SBTarget::CreateValueFromData(const char *name, lldb::SBData data, + lldb::SBType type) { + LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, CreateValueFromData, + (const char *, lldb::SBData, lldb::SBType), name, data, + type); + + SBValue sb_value; + lldb::ValueObjectSP new_value_sp; + if (IsValid() && name && *name && data.IsValid() && type.IsValid()) { + DataExtractorSP extractor(*data); + ExecutionContext exe_ctx( + ExecutionContextRef(ExecutionContext(m_opaque_sp.get(), false))); + CompilerType ast_type(type.GetSP()->GetCompilerType(true)); + new_value_sp = ValueObject::CreateValueObjectFromData(name, *extractor, + exe_ctx, ast_type); + } + sb_value.SetSP(new_value_sp); + return LLDB_RECORD_RESULT(sb_value); +} + +lldb::SBValue SBTarget::CreateValueFromExpression(const char *name, + const char *expr) { + LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, CreateValueFromExpression, + (const char *, const char *), name, expr); + + SBValue sb_value; + lldb::ValueObjectSP new_value_sp; + if (IsValid() && name && *name && expr && *expr) { + ExecutionContext exe_ctx( + ExecutionContextRef(ExecutionContext(m_opaque_sp.get(), false))); + new_value_sp = + ValueObject::CreateValueObjectFromExpression(name, expr, exe_ctx); + } + sb_value.SetSP(new_value_sp); + return LLDB_RECORD_RESULT(sb_value); +} + +bool SBTarget::DeleteAllWatchpoints() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DeleteAllWatchpoints); + + TargetSP target_sp(GetSP()); + if (target_sp) { + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + std::unique_lock<std::recursive_mutex> lock; + target_sp->GetWatchpointList().GetListMutex(lock); + target_sp->RemoveAllWatchpoints(); + return true; + } + return false; +} + +void SBTarget::AppendImageSearchPath(const char *from, const char *to, + lldb::SBError &error) { + LLDB_RECORD_METHOD(void, SBTarget, AppendImageSearchPath, + (const char *, const char *, lldb::SBError &), from, to, + error); + + TargetSP target_sp(GetSP()); + if (!target_sp) + return error.SetErrorString("invalid target"); + + const ConstString csFrom(from), csTo(to); + if (!csFrom) + return error.SetErrorString("<from> path can't be empty"); + if (!csTo) + return error.SetErrorString("<to> path can't be empty"); + + target_sp->GetImageSearchPathList().Append(csFrom, csTo, true); +} + +lldb::SBModule SBTarget::AddModule(const char *path, const char *triple, + const char *uuid_cstr) { + LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule, + (const char *, const char *, const char *), path, triple, + uuid_cstr); + + return LLDB_RECORD_RESULT(AddModule(path, triple, uuid_cstr, nullptr)); +} + +lldb::SBModule SBTarget::AddModule(const char *path, const char *triple, + const char *uuid_cstr, const char *symfile) { + LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule, + (const char *, const char *, const char *, const char *), + path, triple, uuid_cstr, symfile); + + lldb::SBModule sb_module; + TargetSP target_sp(GetSP()); + if (target_sp) { + ModuleSpec module_spec; + if (path) + module_spec.GetFileSpec().SetFile(path, FileSpec::Style::native); + + if (uuid_cstr) + module_spec.GetUUID().SetFromStringRef(uuid_cstr); + + if (triple) + module_spec.GetArchitecture() = Platform::GetAugmentedArchSpec( + target_sp->GetPlatform().get(), triple); + else + module_spec.GetArchitecture() = target_sp->GetArchitecture(); + + if (symfile) + module_spec.GetSymbolFileSpec().SetFile(symfile, FileSpec::Style::native); + + sb_module.SetSP(target_sp->GetOrCreateModule(module_spec, true /* notify */)); + } + return LLDB_RECORD_RESULT(sb_module); +} + +lldb::SBModule SBTarget::AddModule(const SBModuleSpec &module_spec) { + LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule, + (const lldb::SBModuleSpec &), module_spec); + + lldb::SBModule sb_module; + TargetSP target_sp(GetSP()); + if (target_sp) + sb_module.SetSP(target_sp->GetOrCreateModule(*module_spec.m_opaque_up, + true /* notify */)); + return LLDB_RECORD_RESULT(sb_module); +} + +bool SBTarget::AddModule(lldb::SBModule &module) { + LLDB_RECORD_METHOD(bool, SBTarget, AddModule, (lldb::SBModule &), module); + + TargetSP target_sp(GetSP()); + if (target_sp) { + target_sp->GetImages().AppendIfNeeded(module.GetSP()); + return true; + } + return false; +} + +uint32_t SBTarget::GetNumModules() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumModules); + + uint32_t num = 0; + TargetSP target_sp(GetSP()); + if (target_sp) { + // The module list is thread safe, no need to lock + num = target_sp->GetImages().GetSize(); + } + + return num; +} + +void SBTarget::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBTarget, Clear); + + m_opaque_sp.reset(); +} + +SBModule SBTarget::FindModule(const SBFileSpec &sb_file_spec) { + LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, FindModule, + (const lldb::SBFileSpec &), sb_file_spec); + + SBModule sb_module; + TargetSP target_sp(GetSP()); + if (target_sp && sb_file_spec.IsValid()) { + ModuleSpec module_spec(*sb_file_spec); + // The module list is thread safe, no need to lock + sb_module.SetSP(target_sp->GetImages().FindFirstModule(module_spec)); + } + return LLDB_RECORD_RESULT(sb_module); +} + +SBSymbolContextList SBTarget::FindCompileUnits(const SBFileSpec &sb_file_spec) { + LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindCompileUnits, + (const lldb::SBFileSpec &), sb_file_spec); + + SBSymbolContextList sb_sc_list; + const TargetSP target_sp(GetSP()); + if (target_sp && sb_file_spec.IsValid()) + target_sp->GetImages().FindCompileUnits(*sb_file_spec, *sb_sc_list); + return LLDB_RECORD_RESULT(sb_sc_list); +} + +lldb::ByteOrder SBTarget::GetByteOrder() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::ByteOrder, SBTarget, GetByteOrder); + + TargetSP target_sp(GetSP()); + if (target_sp) + return target_sp->GetArchitecture().GetByteOrder(); + return eByteOrderInvalid; +} + +const char *SBTarget::GetTriple() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTarget, GetTriple); + + TargetSP target_sp(GetSP()); + if (target_sp) { + std::string triple(target_sp->GetArchitecture().GetTriple().str()); + // 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 + // comes out + ConstString const_triple(triple.c_str()); + return const_triple.GetCString(); + } + return nullptr; +} + +uint32_t SBTarget::GetDataByteSize() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTarget, GetDataByteSize); + + TargetSP target_sp(GetSP()); + if (target_sp) { + return target_sp->GetArchitecture().GetDataByteSize(); + } + return 0; +} + +uint32_t SBTarget::GetCodeByteSize() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTarget, GetCodeByteSize); + + TargetSP target_sp(GetSP()); + if (target_sp) { + return target_sp->GetArchitecture().GetCodeByteSize(); + } + return 0; +} + +uint32_t SBTarget::GetAddressByteSize() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTarget, GetAddressByteSize); + + TargetSP target_sp(GetSP()); + if (target_sp) + return target_sp->GetArchitecture().GetAddressByteSize(); + return sizeof(void *); +} + +SBModule SBTarget::GetModuleAtIndex(uint32_t idx) { + LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, GetModuleAtIndex, (uint32_t), + idx); + + SBModule sb_module; + ModuleSP module_sp; + TargetSP target_sp(GetSP()); + if (target_sp) { + // The module list is thread safe, no need to lock + module_sp = target_sp->GetImages().GetModuleAtIndex(idx); + sb_module.SetSP(module_sp); + } + + return LLDB_RECORD_RESULT(sb_module); +} + +bool SBTarget::RemoveModule(lldb::SBModule module) { + LLDB_RECORD_METHOD(bool, SBTarget, RemoveModule, (lldb::SBModule), module); + + TargetSP target_sp(GetSP()); + if (target_sp) + return target_sp->GetImages().Remove(module.GetSP()); + return false; +} + +SBBroadcaster SBTarget::GetBroadcaster() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBTarget, + GetBroadcaster); + + + TargetSP target_sp(GetSP()); + SBBroadcaster broadcaster(target_sp.get(), false); + + + return LLDB_RECORD_RESULT(broadcaster); +} + +bool SBTarget::GetDescription(SBStream &description, + lldb::DescriptionLevel description_level) { + LLDB_RECORD_METHOD(bool, SBTarget, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel), description, + description_level); + + Stream &strm = description.ref(); + + TargetSP target_sp(GetSP()); + if (target_sp) { + target_sp->Dump(&strm, description_level); + } else + strm.PutCString("No value"); + + return true; +} + +lldb::SBSymbolContextList SBTarget::FindFunctions(const char *name, + uint32_t name_type_mask) { + LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindFunctions, + (const char *, uint32_t), name, name_type_mask); + + lldb::SBSymbolContextList sb_sc_list; + if (!name | !name[0]) + return LLDB_RECORD_RESULT(sb_sc_list); + + TargetSP target_sp(GetSP()); + if (!target_sp) + return LLDB_RECORD_RESULT(sb_sc_list); + + const bool symbols_ok = true; + const bool inlines_ok = true; + FunctionNameType mask = static_cast<FunctionNameType>(name_type_mask); + target_sp->GetImages().FindFunctions(ConstString(name), mask, symbols_ok, + inlines_ok, *sb_sc_list); + return LLDB_RECORD_RESULT(sb_sc_list); +} + +lldb::SBSymbolContextList SBTarget::FindGlobalFunctions(const char *name, + uint32_t max_matches, + MatchType matchtype) { + LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindGlobalFunctions, + (const char *, uint32_t, lldb::MatchType), name, + max_matches, matchtype); + + lldb::SBSymbolContextList sb_sc_list; + if (name && name[0]) { + llvm::StringRef name_ref(name); + TargetSP target_sp(GetSP()); + if (target_sp) { + std::string regexstr; + switch (matchtype) { + case eMatchTypeRegex: + target_sp->GetImages().FindFunctions(RegularExpression(name_ref), true, + true, *sb_sc_list); + break; + case eMatchTypeStartsWith: + regexstr = llvm::Regex::escape(name) + ".*"; + target_sp->GetImages().FindFunctions(RegularExpression(regexstr), true, + true, *sb_sc_list); + break; + default: + target_sp->GetImages().FindFunctions( + ConstString(name), eFunctionNameTypeAny, true, true, *sb_sc_list); + break; + } + } + } + return LLDB_RECORD_RESULT(sb_sc_list); +} + +lldb::SBType SBTarget::FindFirstType(const char *typename_cstr) { + LLDB_RECORD_METHOD(lldb::SBType, SBTarget, FindFirstType, (const char *), + typename_cstr); + + TargetSP target_sp(GetSP()); + if (typename_cstr && typename_cstr[0] && target_sp) { + ConstString const_typename(typename_cstr); + SymbolContext sc; + const bool exact_match = false; + + const ModuleList &module_list = target_sp->GetImages(); + size_t count = module_list.GetSize(); + for (size_t idx = 0; idx < count; idx++) { + ModuleSP module_sp(module_list.GetModuleAtIndex(idx)); + if (module_sp) { + TypeSP type_sp( + module_sp->FindFirstType(sc, const_typename, exact_match)); + if (type_sp) + return LLDB_RECORD_RESULT(SBType(type_sp)); + } + } + + // Didn't find the type in the symbols; Try the loaded language runtimes + if (auto process_sp = target_sp->GetProcessSP()) { + for (auto *runtime : process_sp->GetLanguageRuntimes()) { + if (auto vendor = runtime->GetDeclVendor()) { + auto types = vendor->FindTypes(const_typename, /*max_matches*/ 1); + if (!types.empty()) + return LLDB_RECORD_RESULT(SBType(types.front())); + } + } + } + + // No matches, search for basic typename matches + for (auto *type_system : target_sp->GetScratchTypeSystems()) + if (auto type = type_system->GetBuiltinTypeByName(const_typename)) + return LLDB_RECORD_RESULT(SBType(type)); + } + + return LLDB_RECORD_RESULT(SBType()); +} + +SBType SBTarget::GetBasicType(lldb::BasicType type) { + LLDB_RECORD_METHOD(lldb::SBType, SBTarget, GetBasicType, (lldb::BasicType), + type); + + TargetSP target_sp(GetSP()); + if (target_sp) { + for (auto *type_system : target_sp->GetScratchTypeSystems()) + if (auto compiler_type = type_system->GetBasicTypeFromAST(type)) + return LLDB_RECORD_RESULT(SBType(compiler_type)); + } + return LLDB_RECORD_RESULT(SBType()); +} + +lldb::SBTypeList SBTarget::FindTypes(const char *typename_cstr) { + LLDB_RECORD_METHOD(lldb::SBTypeList, SBTarget, FindTypes, (const char *), + typename_cstr); + + SBTypeList sb_type_list; + TargetSP target_sp(GetSP()); + if (typename_cstr && typename_cstr[0] && target_sp) { + ModuleList &images = target_sp->GetImages(); + ConstString const_typename(typename_cstr); + bool exact_match = false; + TypeList type_list; + llvm::DenseSet<SymbolFile *> searched_symbol_files; + images.FindTypes(nullptr, const_typename, exact_match, UINT32_MAX, + searched_symbol_files, type_list); + + for (size_t idx = 0; idx < type_list.GetSize(); idx++) { + TypeSP type_sp(type_list.GetTypeAtIndex(idx)); + if (type_sp) + sb_type_list.Append(SBType(type_sp)); + } + + // Try the loaded language runtimes + if (auto process_sp = target_sp->GetProcessSP()) { + for (auto *runtime : process_sp->GetLanguageRuntimes()) { + if (auto *vendor = runtime->GetDeclVendor()) { + auto types = + vendor->FindTypes(const_typename, /*max_matches*/ UINT32_MAX); + for (auto type : types) + sb_type_list.Append(SBType(type)); + } + } + } + + if (sb_type_list.GetSize() == 0) { + // No matches, search for basic typename matches + for (auto *type_system : target_sp->GetScratchTypeSystems()) + if (auto compiler_type = + type_system->GetBuiltinTypeByName(const_typename)) + sb_type_list.Append(SBType(compiler_type)); + } + } + return LLDB_RECORD_RESULT(sb_type_list); +} + +SBValueList SBTarget::FindGlobalVariables(const char *name, + uint32_t max_matches) { + LLDB_RECORD_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables, + (const char *, uint32_t), name, max_matches); + + SBValueList sb_value_list; + + TargetSP target_sp(GetSP()); + if (name && target_sp) { + VariableList variable_list; + target_sp->GetImages().FindGlobalVariables(ConstString(name), max_matches, + variable_list); + if (!variable_list.Empty()) { + ExecutionContextScope *exe_scope = target_sp->GetProcessSP().get(); + if (exe_scope == nullptr) + exe_scope = target_sp.get(); + for (const VariableSP &var_sp : variable_list) { + lldb::ValueObjectSP valobj_sp( + ValueObjectVariable::Create(exe_scope, var_sp)); + if (valobj_sp) + sb_value_list.Append(SBValue(valobj_sp)); + } + } + } + + return LLDB_RECORD_RESULT(sb_value_list); +} + +SBValueList SBTarget::FindGlobalVariables(const char *name, + uint32_t max_matches, + MatchType matchtype) { + LLDB_RECORD_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables, + (const char *, uint32_t, lldb::MatchType), name, + max_matches, matchtype); + + SBValueList sb_value_list; + + TargetSP target_sp(GetSP()); + if (name && target_sp) { + llvm::StringRef name_ref(name); + VariableList variable_list; + + std::string regexstr; + switch (matchtype) { + case eMatchTypeNormal: + target_sp->GetImages().FindGlobalVariables(ConstString(name), max_matches, + variable_list); + break; + case eMatchTypeRegex: + target_sp->GetImages().FindGlobalVariables(RegularExpression(name_ref), + max_matches, variable_list); + break; + case eMatchTypeStartsWith: + regexstr = llvm::Regex::escape(name) + ".*"; + target_sp->GetImages().FindGlobalVariables(RegularExpression(regexstr), + max_matches, variable_list); + break; + } + if (!variable_list.Empty()) { + ExecutionContextScope *exe_scope = target_sp->GetProcessSP().get(); + if (exe_scope == nullptr) + exe_scope = target_sp.get(); + for (const VariableSP &var_sp : variable_list) { + lldb::ValueObjectSP valobj_sp( + ValueObjectVariable::Create(exe_scope, var_sp)); + if (valobj_sp) + sb_value_list.Append(SBValue(valobj_sp)); + } + } + } + + return LLDB_RECORD_RESULT(sb_value_list); +} + +lldb::SBValue SBTarget::FindFirstGlobalVariable(const char *name) { + LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, FindFirstGlobalVariable, + (const char *), name); + + SBValueList sb_value_list(FindGlobalVariables(name, 1)); + if (sb_value_list.IsValid() && sb_value_list.GetSize() > 0) + return LLDB_RECORD_RESULT(sb_value_list.GetValueAtIndex(0)); + return LLDB_RECORD_RESULT(SBValue()); +} + +SBSourceManager SBTarget::GetSourceManager() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSourceManager, SBTarget, GetSourceManager); + + SBSourceManager source_manager(*this); + return LLDB_RECORD_RESULT(source_manager); +} + +lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr, + uint32_t count) { + LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions, + (lldb::SBAddress, uint32_t), base_addr, count); + + return LLDB_RECORD_RESULT(ReadInstructions(base_addr, count, nullptr)); +} + +lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr, + uint32_t count, + const char *flavor_string) { + LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions, + (lldb::SBAddress, uint32_t, const char *), base_addr, + count, flavor_string); + + SBInstructionList sb_instructions; + + TargetSP target_sp(GetSP()); + if (target_sp) { + Address *addr_ptr = base_addr.get(); + + if (addr_ptr) { + DataBufferHeap data( + target_sp->GetArchitecture().GetMaximumOpcodeByteSize() * count, 0); + bool prefer_file_cache = false; + lldb_private::Status error; + lldb::addr_t load_addr = LLDB_INVALID_ADDRESS; + const size_t bytes_read = + target_sp->ReadMemory(*addr_ptr, prefer_file_cache, data.GetBytes(), + data.GetByteSize(), error, &load_addr); + const bool data_from_file = load_addr == LLDB_INVALID_ADDRESS; + sb_instructions.SetDisassembler(Disassembler::DisassembleBytes( + target_sp->GetArchitecture(), nullptr, flavor_string, *addr_ptr, + data.GetBytes(), bytes_read, count, data_from_file)); + } + } + + return LLDB_RECORD_RESULT(sb_instructions); +} + +lldb::SBInstructionList SBTarget::GetInstructions(lldb::SBAddress base_addr, + const void *buf, + size_t size) { + LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, GetInstructions, + (lldb::SBAddress, const void *, size_t), base_addr, buf, + size); + + return LLDB_RECORD_RESULT( + GetInstructionsWithFlavor(base_addr, nullptr, buf, size)); +} + +lldb::SBInstructionList +SBTarget::GetInstructionsWithFlavor(lldb::SBAddress base_addr, + const char *flavor_string, const void *buf, + size_t size) { + LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, + GetInstructionsWithFlavor, + (lldb::SBAddress, const char *, const void *, size_t), + base_addr, flavor_string, buf, size); + + SBInstructionList sb_instructions; + + TargetSP target_sp(GetSP()); + if (target_sp) { + Address addr; + + if (base_addr.get()) + addr = *base_addr.get(); + + const bool data_from_file = true; + + sb_instructions.SetDisassembler(Disassembler::DisassembleBytes( + target_sp->GetArchitecture(), nullptr, flavor_string, addr, buf, size, + UINT32_MAX, data_from_file)); + } + + return LLDB_RECORD_RESULT(sb_instructions); +} + +lldb::SBInstructionList SBTarget::GetInstructions(lldb::addr_t base_addr, + const void *buf, + size_t size) { + LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, GetInstructions, + (lldb::addr_t, const void *, size_t), base_addr, buf, + size); + + return LLDB_RECORD_RESULT(GetInstructionsWithFlavor( + ResolveLoadAddress(base_addr), nullptr, buf, size)); +} + +lldb::SBInstructionList +SBTarget::GetInstructionsWithFlavor(lldb::addr_t base_addr, + const char *flavor_string, const void *buf, + size_t size) { + LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, + GetInstructionsWithFlavor, + (lldb::addr_t, const char *, const void *, size_t), + base_addr, flavor_string, buf, size); + + return LLDB_RECORD_RESULT(GetInstructionsWithFlavor( + ResolveLoadAddress(base_addr), flavor_string, buf, size)); +} + +SBError SBTarget::SetSectionLoadAddress(lldb::SBSection section, + lldb::addr_t section_base_addr) { + LLDB_RECORD_METHOD(lldb::SBError, SBTarget, SetSectionLoadAddress, + (lldb::SBSection, lldb::addr_t), section, + section_base_addr); + + SBError sb_error; + TargetSP target_sp(GetSP()); + if (target_sp) { + if (!section.IsValid()) { + sb_error.SetErrorStringWithFormat("invalid section"); + } else { + SectionSP section_sp(section.GetSP()); + if (section_sp) { + if (section_sp->IsThreadSpecific()) { + sb_error.SetErrorString( + "thread specific sections are not yet supported"); + } else { + ProcessSP process_sp(target_sp->GetProcessSP()); + if (target_sp->SetSectionLoadAddress(section_sp, section_base_addr)) { + ModuleSP module_sp(section_sp->GetModule()); + if (module_sp) { + ModuleList module_list; + module_list.Append(module_sp); + target_sp->ModulesDidLoad(module_list); + } + // Flush info in the process (stack frames, etc) + if (process_sp) + process_sp->Flush(); + } + } + } + } + } else { + sb_error.SetErrorString("invalid target"); + } + return LLDB_RECORD_RESULT(sb_error); +} + +SBError SBTarget::ClearSectionLoadAddress(lldb::SBSection section) { + LLDB_RECORD_METHOD(lldb::SBError, SBTarget, ClearSectionLoadAddress, + (lldb::SBSection), section); + + SBError sb_error; + + TargetSP target_sp(GetSP()); + if (target_sp) { + if (!section.IsValid()) { + sb_error.SetErrorStringWithFormat("invalid section"); + } else { + SectionSP section_sp(section.GetSP()); + if (section_sp) { + ProcessSP process_sp(target_sp->GetProcessSP()); + if (target_sp->SetSectionUnloaded(section_sp)) { + ModuleSP module_sp(section_sp->GetModule()); + if (module_sp) { + ModuleList module_list; + module_list.Append(module_sp); + target_sp->ModulesDidUnload(module_list, false); + } + // Flush info in the process (stack frames, etc) + if (process_sp) + process_sp->Flush(); + } + } else { + sb_error.SetErrorStringWithFormat("invalid section"); + } + } + } else { + sb_error.SetErrorStringWithFormat("invalid target"); + } + return LLDB_RECORD_RESULT(sb_error); +} + +SBError SBTarget::SetModuleLoadAddress(lldb::SBModule module, + int64_t slide_offset) { + LLDB_RECORD_METHOD(lldb::SBError, SBTarget, SetModuleLoadAddress, + (lldb::SBModule, int64_t), module, slide_offset); + + SBError sb_error; + + TargetSP target_sp(GetSP()); + if (target_sp) { + ModuleSP module_sp(module.GetSP()); + if (module_sp) { + bool changed = false; + if (module_sp->SetLoadAddress(*target_sp, slide_offset, true, changed)) { + // The load was successful, make sure that at least some sections + // changed before we notify that our module was loaded. + if (changed) { + ModuleList module_list; + module_list.Append(module_sp); + target_sp->ModulesDidLoad(module_list); + // Flush info in the process (stack frames, etc) + ProcessSP process_sp(target_sp->GetProcessSP()); + if (process_sp) + process_sp->Flush(); + } + } + } else { + sb_error.SetErrorStringWithFormat("invalid module"); + } + + } else { + sb_error.SetErrorStringWithFormat("invalid target"); + } + return LLDB_RECORD_RESULT(sb_error); +} + +SBError SBTarget::ClearModuleLoadAddress(lldb::SBModule module) { + LLDB_RECORD_METHOD(lldb::SBError, SBTarget, ClearModuleLoadAddress, + (lldb::SBModule), module); + + SBError sb_error; + + char path[PATH_MAX]; + TargetSP target_sp(GetSP()); + if (target_sp) { + ModuleSP module_sp(module.GetSP()); + if (module_sp) { + ObjectFile *objfile = module_sp->GetObjectFile(); + if (objfile) { + SectionList *section_list = objfile->GetSectionList(); + if (section_list) { + ProcessSP process_sp(target_sp->GetProcessSP()); + + bool changed = false; + const size_t num_sections = section_list->GetSize(); + for (size_t sect_idx = 0; sect_idx < num_sections; ++sect_idx) { + SectionSP section_sp(section_list->GetSectionAtIndex(sect_idx)); + if (section_sp) + changed |= target_sp->SetSectionUnloaded(section_sp); + } + if (changed) { + ModuleList module_list; + module_list.Append(module_sp); + target_sp->ModulesDidUnload(module_list, false); + // Flush info in the process (stack frames, etc) + ProcessSP process_sp(target_sp->GetProcessSP()); + if (process_sp) + process_sp->Flush(); + } + } else { + module_sp->GetFileSpec().GetPath(path, sizeof(path)); + sb_error.SetErrorStringWithFormat("no sections in object file '%s'", + path); + } + } else { + module_sp->GetFileSpec().GetPath(path, sizeof(path)); + sb_error.SetErrorStringWithFormat("no object file for module '%s'", + path); + } + } else { + sb_error.SetErrorStringWithFormat("invalid module"); + } + } else { + sb_error.SetErrorStringWithFormat("invalid target"); + } + return LLDB_RECORD_RESULT(sb_error); +} + +lldb::SBSymbolContextList SBTarget::FindSymbols(const char *name, + lldb::SymbolType symbol_type) { + LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindSymbols, + (const char *, lldb::SymbolType), name, symbol_type); + + SBSymbolContextList sb_sc_list; + if (name && name[0]) { + TargetSP target_sp(GetSP()); + if (target_sp) + target_sp->GetImages().FindSymbolsWithNameAndType( + ConstString(name), symbol_type, *sb_sc_list); + } + return LLDB_RECORD_RESULT(sb_sc_list); +} + +lldb::SBValue SBTarget::EvaluateExpression(const char *expr) { + LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, EvaluateExpression, + (const char *), expr); + + TargetSP target_sp(GetSP()); + if (!target_sp) + return LLDB_RECORD_RESULT(SBValue()); + + SBExpressionOptions options; + lldb::DynamicValueType fetch_dynamic_value = + target_sp->GetPreferDynamicValue(); + options.SetFetchDynamicValue(fetch_dynamic_value); + options.SetUnwindOnError(true); + return LLDB_RECORD_RESULT(EvaluateExpression(expr, options)); +} + +lldb::SBValue SBTarget::EvaluateExpression(const char *expr, + const SBExpressionOptions &options) { + LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, EvaluateExpression, + (const char *, const lldb::SBExpressionOptions &), expr, + options); + + Log *expr_log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); + SBValue expr_result; + ValueObjectSP expr_value_sp; + TargetSP target_sp(GetSP()); + StackFrame *frame = nullptr; + if (target_sp) { + if (expr == nullptr || expr[0] == '\0') { + return LLDB_RECORD_RESULT(expr_result); + } + + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + ExecutionContext exe_ctx(m_opaque_sp.get()); + + + frame = exe_ctx.GetFramePtr(); + Target *target = exe_ctx.GetTargetPtr(); + + if (target) { + target->EvaluateExpression(expr, frame, expr_value_sp, options.ref()); + + expr_result.SetSP(expr_value_sp, options.GetFetchDynamicValue()); + } + } + LLDB_LOGF(expr_log, + "** [SBTarget::EvaluateExpression] Expression result is " + "%s, summary %s **", + expr_result.GetValue(), expr_result.GetSummary()); + return LLDB_RECORD_RESULT(expr_result); +} + +lldb::addr_t SBTarget::GetStackRedZoneSize() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBTarget, GetStackRedZoneSize); + + TargetSP target_sp(GetSP()); + if (target_sp) { + ABISP abi_sp; + ProcessSP process_sp(target_sp->GetProcessSP()); + if (process_sp) + abi_sp = process_sp->GetABI(); + else + abi_sp = ABI::FindPlugin(ProcessSP(), target_sp->GetArchitecture()); + if (abi_sp) + return abi_sp->GetRedZoneSize(); + } + return 0; +} + +lldb::SBLaunchInfo SBTarget::GetLaunchInfo() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBLaunchInfo, SBTarget, GetLaunchInfo); + + lldb::SBLaunchInfo launch_info(nullptr); + TargetSP target_sp(GetSP()); + if (target_sp) + launch_info.set_ref(m_opaque_sp->GetProcessLaunchInfo()); + return LLDB_RECORD_RESULT(launch_info); +} + +void SBTarget::SetLaunchInfo(const lldb::SBLaunchInfo &launch_info) { + LLDB_RECORD_METHOD(void, SBTarget, SetLaunchInfo, + (const lldb::SBLaunchInfo &), launch_info); + + TargetSP target_sp(GetSP()); + if (target_sp) + m_opaque_sp->SetProcessLaunchInfo(launch_info.ref()); +} + +SBEnvironment SBTarget::GetEnvironment() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBEnvironment, SBTarget, GetEnvironment); + TargetSP target_sp(GetSP()); + + if (target_sp) { + return LLDB_RECORD_RESULT(SBEnvironment(target_sp->GetEnvironment())); + } + + return LLDB_RECORD_RESULT(SBEnvironment()); +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBTarget>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBTarget, ()); + LLDB_REGISTER_CONSTRUCTOR(SBTarget, (const lldb::SBTarget &)); + LLDB_REGISTER_CONSTRUCTOR(SBTarget, (const lldb::TargetSP &)); + LLDB_REGISTER_METHOD(const lldb::SBTarget &, + SBTarget, operator=,(const lldb::SBTarget &)); + LLDB_REGISTER_STATIC_METHOD(bool, SBTarget, EventIsTargetEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBTarget, SBTarget, GetTargetFromEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_STATIC_METHOD(uint32_t, SBTarget, GetNumModulesFromEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBModule, SBTarget, + GetModuleAtIndexFromEvent, + (const uint32_t, const lldb::SBEvent &)); + LLDB_REGISTER_STATIC_METHOD(const char *, SBTarget, GetBroadcasterClassName, + ()); + LLDB_REGISTER_METHOD_CONST(bool, SBTarget, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBTarget, operator bool, ()); + LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, GetProcess, ()); + LLDB_REGISTER_METHOD(lldb::SBPlatform, SBTarget, GetPlatform, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBDebugger, SBTarget, GetDebugger, ()); + LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBTarget, GetStatistics, ()); + LLDB_REGISTER_METHOD(void, SBTarget, SetCollectingStats, (bool)); + LLDB_REGISTER_METHOD(bool, SBTarget, GetCollectingStats, ()); + LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LoadCore, (const char *)); + LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LoadCore, + (const char *, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LaunchSimple, + (const char **, const char **, const char *)); + LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, Install, ()); + LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, Launch, + (lldb::SBListener &, const char **, const char **, + const char *, const char *, const char *, + const char *, uint32_t, bool, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, Launch, + (lldb::SBLaunchInfo &, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, Attach, + (lldb::SBAttachInfo &, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, AttachToProcessWithID, + (lldb::SBListener &, lldb::pid_t, lldb::SBError &)); + LLDB_REGISTER_METHOD( + lldb::SBProcess, SBTarget, AttachToProcessWithName, + (lldb::SBListener &, const char *, bool, lldb::SBError &)); + LLDB_REGISTER_METHOD( + lldb::SBProcess, SBTarget, ConnectRemote, + (lldb::SBListener &, const char *, const char *, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBTarget, GetExecutable, ()); + LLDB_REGISTER_METHOD_CONST(bool, + SBTarget, operator==,(const lldb::SBTarget &)); + LLDB_REGISTER_METHOD_CONST(bool, + SBTarget, operator!=,(const lldb::SBTarget &)); + LLDB_REGISTER_METHOD(lldb::SBAddress, SBTarget, ResolveLoadAddress, + (lldb::addr_t)); + LLDB_REGISTER_METHOD(lldb::SBAddress, SBTarget, ResolveFileAddress, + (lldb::addr_t)); + LLDB_REGISTER_METHOD(lldb::SBAddress, SBTarget, ResolvePastLoadAddress, + (uint32_t, lldb::addr_t)); + LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBTarget, + ResolveSymbolContextForAddress, + (const lldb::SBAddress &, uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, + BreakpointCreateByLocation, (const char *, uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, + BreakpointCreateByLocation, + (const lldb::SBFileSpec &, uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, + BreakpointCreateByLocation, + (const lldb::SBFileSpec &, uint32_t, lldb::addr_t)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, + BreakpointCreateByLocation, + (const lldb::SBFileSpec &, uint32_t, lldb::addr_t, + lldb::SBFileSpecList &)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, + BreakpointCreateByLocation, + (const lldb::SBFileSpec &, uint32_t, uint32_t, + lldb::addr_t, lldb::SBFileSpecList &)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName, + (const char *, const char *)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName, + (const char *, const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName, + (const char *, uint32_t, const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName, + (const char *, uint32_t, lldb::LanguageType, + const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames, + (const char **, uint32_t, uint32_t, + const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames, + (const char **, uint32_t, uint32_t, lldb::LanguageType, + const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames, + (const char **, uint32_t, uint32_t, lldb::LanguageType, + lldb::addr_t, const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex, + (const char *, const char *)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex, + (const char *, const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex, + (const char *, lldb::LanguageType, + const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, + BreakpointCreateByAddress, (lldb::addr_t)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, + BreakpointCreateBySBAddress, (lldb::SBAddress &)); + LLDB_REGISTER_METHOD( + lldb::SBBreakpoint, SBTarget, BreakpointCreateBySourceRegex, + (const char *, const lldb::SBFileSpec &, const char *)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, + BreakpointCreateBySourceRegex, + (const char *, const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &)); + LLDB_REGISTER_METHOD( + lldb::SBBreakpoint, SBTarget, BreakpointCreateBySourceRegex, + (const char *, const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &, const lldb::SBStringList &)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, + BreakpointCreateForException, + (lldb::LanguageType, bool, bool)); + LLDB_REGISTER_METHOD( + lldb::SBBreakpoint, SBTarget, BreakpointCreateFromScript, + (const char *, lldb::SBStructuredData &, const lldb::SBFileSpecList &, + const lldb::SBFileSpecList &, bool)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetNumBreakpoints, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBBreakpoint, SBTarget, + GetBreakpointAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(bool, SBTarget, BreakpointDelete, (lldb::break_id_t)); + LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, FindBreakpointByID, + (lldb::break_id_t)); + LLDB_REGISTER_METHOD(bool, SBTarget, FindBreakpointsByName, + (const char *, lldb::SBBreakpointList &)); + LLDB_REGISTER_METHOD(void, SBTarget, GetBreakpointNames, + (lldb::SBStringList &)); + LLDB_REGISTER_METHOD(void, SBTarget, DeleteBreakpointName, (const char *)); + LLDB_REGISTER_METHOD(bool, SBTarget, EnableAllBreakpoints, ()); + LLDB_REGISTER_METHOD(bool, SBTarget, DisableAllBreakpoints, ()); + LLDB_REGISTER_METHOD(bool, SBTarget, DeleteAllBreakpoints, ()); + LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, BreakpointsCreateFromFile, + (lldb::SBFileSpec &, lldb::SBBreakpointList &)); + LLDB_REGISTER_METHOD( + lldb::SBError, SBTarget, BreakpointsCreateFromFile, + (lldb::SBFileSpec &, lldb::SBStringList &, lldb::SBBreakpointList &)); + LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile, + (lldb::SBFileSpec &)); + LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile, + (lldb::SBFileSpec &, lldb::SBBreakpointList &, bool)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetNumWatchpoints, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBWatchpoint, SBTarget, + GetWatchpointAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(bool, SBTarget, DeleteWatchpoint, (lldb::watch_id_t)); + LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBTarget, FindWatchpointByID, + (lldb::watch_id_t)); + LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBTarget, WatchAddress, + (lldb::addr_t, size_t, bool, bool, lldb::SBError &)); + LLDB_REGISTER_METHOD(bool, SBTarget, EnableAllWatchpoints, ()); + LLDB_REGISTER_METHOD(bool, SBTarget, DisableAllWatchpoints, ()); + LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, CreateValueFromAddress, + (const char *, lldb::SBAddress, lldb::SBType)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, CreateValueFromData, + (const char *, lldb::SBData, lldb::SBType)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, CreateValueFromExpression, + (const char *, const char *)); + LLDB_REGISTER_METHOD(bool, SBTarget, DeleteAllWatchpoints, ()); + LLDB_REGISTER_METHOD(void, SBTarget, AppendImageSearchPath, + (const char *, const char *, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, AddModule, + (const char *, const char *, const char *)); + LLDB_REGISTER_METHOD( + lldb::SBModule, SBTarget, AddModule, + (const char *, const char *, const char *, const char *)); + LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, AddModule, + (const lldb::SBModuleSpec &)); + LLDB_REGISTER_METHOD(bool, SBTarget, AddModule, (lldb::SBModule &)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetNumModules, ()); + LLDB_REGISTER_METHOD(void, SBTarget, Clear, ()); + LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, FindModule, + (const lldb::SBFileSpec &)); + LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, FindCompileUnits, + (const lldb::SBFileSpec &)); + LLDB_REGISTER_METHOD(lldb::ByteOrder, SBTarget, GetByteOrder, ()); + LLDB_REGISTER_METHOD(const char *, SBTarget, GetTriple, ()); + LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetDataByteSize, ()); + LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetCodeByteSize, ()); + LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetAddressByteSize, ()); + LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, GetModuleAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD(bool, SBTarget, RemoveModule, (lldb::SBModule)); + LLDB_REGISTER_METHOD_CONST(lldb::SBBroadcaster, SBTarget, GetBroadcaster, + ()); + LLDB_REGISTER_METHOD(bool, SBTarget, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel)); + LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, FindFunctions, + (const char *, uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, + FindGlobalFunctions, + (const char *, uint32_t, lldb::MatchType)); + LLDB_REGISTER_METHOD(lldb::SBType, SBTarget, FindFirstType, (const char *)); + LLDB_REGISTER_METHOD(lldb::SBType, SBTarget, GetBasicType, + (lldb::BasicType)); + LLDB_REGISTER_METHOD(lldb::SBTypeList, SBTarget, FindTypes, (const char *)); + LLDB_REGISTER_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables, + (const char *, uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables, + (const char *, uint32_t, lldb::MatchType)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, FindFirstGlobalVariable, + (const char *)); + LLDB_REGISTER_METHOD(lldb::SBSourceManager, SBTarget, GetSourceManager, ()); + LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions, + (lldb::SBAddress, uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions, + (lldb::SBAddress, uint32_t, const char *)); + LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, SetSectionLoadAddress, + (lldb::SBSection, lldb::addr_t)); + LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, ClearSectionLoadAddress, + (lldb::SBSection)); + LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, SetModuleLoadAddress, + (lldb::SBModule, int64_t)); + LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, ClearModuleLoadAddress, + (lldb::SBModule)); + LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, FindSymbols, + (const char *, lldb::SymbolType)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, EvaluateExpression, + (const char *)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, EvaluateExpression, + (const char *, const lldb::SBExpressionOptions &)); + LLDB_REGISTER_METHOD(lldb::addr_t, SBTarget, GetStackRedZoneSize, ()); + LLDB_REGISTER_METHOD_CONST(lldb::SBLaunchInfo, SBTarget, GetLaunchInfo, ()); + LLDB_REGISTER_METHOD(void, SBTarget, SetLaunchInfo, + (const lldb::SBLaunchInfo &)); + LLDB_REGISTER_METHOD( + size_t, SBTarget, ReadMemory, + (const lldb::SBAddress, void *, size_t, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, GetInstructions, + (lldb::SBAddress, const void *, size_t)); + LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, + GetInstructionsWithFlavor, + (lldb::SBAddress, const char *, const void *, size_t)); + LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, GetInstructions, + (lldb::addr_t, const void *, size_t)); + LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, + GetInstructionsWithFlavor, + (lldb::addr_t, const char *, const void *, size_t)); + LLDB_REGISTER_METHOD(lldb::SBEnvironment, SBTarget, GetEnvironment, ()); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBThread.cpp b/contrib/llvm-project/lldb/source/API/SBThread.cpp new file mode 100644 index 000000000000..0d50aceee5e4 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBThread.cpp @@ -0,0 +1,1455 @@ +//===-- SBThread.cpp ------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBThread.h" +#include "SBReproducerPrivate.h" +#include "Utils.h" +#include "lldb/API/SBAddress.h" +#include "lldb/API/SBDebugger.h" +#include "lldb/API/SBEvent.h" +#include "lldb/API/SBFileSpec.h" +#include "lldb/API/SBFrame.h" +#include "lldb/API/SBProcess.h" +#include "lldb/API/SBStream.h" +#include "lldb/API/SBStructuredData.h" +#include "lldb/API/SBSymbolContext.h" +#include "lldb/API/SBThreadCollection.h" +#include "lldb/API/SBThreadPlan.h" +#include "lldb/API/SBValue.h" +#include "lldb/Breakpoint/BreakpointLocation.h" +#include "lldb/Core/Debugger.h" +#include "lldb/Core/StreamFile.h" +#include "lldb/Core/StructuredDataImpl.h" +#include "lldb/Core/ValueObject.h" +#include "lldb/Interpreter/CommandInterpreter.h" +#include "lldb/Symbol/CompileUnit.h" +#include "lldb/Symbol/SymbolContext.h" +#include "lldb/Target/Process.h" +#include "lldb/Target/Queue.h" +#include "lldb/Target/StopInfo.h" +#include "lldb/Target/SystemRuntime.h" +#include "lldb/Target/Target.h" +#include "lldb/Target/Thread.h" +#include "lldb/Target/ThreadPlan.h" +#include "lldb/Target/ThreadPlanStepInRange.h" +#include "lldb/Target/ThreadPlanStepInstruction.h" +#include "lldb/Target/ThreadPlanStepOut.h" +#include "lldb/Target/ThreadPlanStepRange.h" +#include "lldb/Utility/State.h" +#include "lldb/Utility/Stream.h" +#include "lldb/Utility/StructuredData.h" +#include "lldb/lldb-enumerations.h" + +#include <memory> + +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()) { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBThread); +} + +SBThread::SBThread(const ThreadSP &lldb_object_sp) + : m_opaque_sp(new ExecutionContextRef(lldb_object_sp)) { + LLDB_RECORD_CONSTRUCTOR(SBThread, (const lldb::ThreadSP &), lldb_object_sp); +} + +SBThread::SBThread(const SBThread &rhs) : m_opaque_sp() { + LLDB_RECORD_CONSTRUCTOR(SBThread, (const lldb::SBThread &), rhs); + + m_opaque_sp = clone(rhs.m_opaque_sp); +} + +// Assignment operator + +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 LLDB_RECORD_RESULT(*this); +} + +// Destructor +SBThread::~SBThread() = default; + +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; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + if (exe_ctx.HasThreadScope()) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { + queue_sp = exe_ctx.GetThreadPtr()->GetQueue(); + if (queue_sp) { + sb_queue.SetQueue(queue_sp); + } + } + } + + return LLDB_RECORD_RESULT(sb_queue); +} + +bool SBThread::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThread, IsValid); + return this->operator bool(); +} +SBThread::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThread, operator bool); + + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + Target *target = exe_ctx.GetTargetPtr(); + Process *process = exe_ctx.GetProcessPtr(); + if (target && process) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&process->GetRunLock())) + return m_opaque_sp->GetThreadSP().get() != nullptr; + } + // Without a valid target & process, this thread can't be valid. + return false; +} + +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); + + StopReason reason = eStopReasonInvalid; + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + if (exe_ctx.HasThreadScope()) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { + return exe_ctx.GetThreadPtr()->GetStopReason(); + } + } + + return reason; +} + +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); + + if (exe_ctx.HasThreadScope()) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { + StopInfoSP stop_info_sp = exe_ctx.GetThreadPtr()->GetStopInfo(); + if (stop_info_sp) { + StopReason reason = stop_info_sp->GetStopReason(); + switch (reason) { + case eStopReasonInvalid: + case eStopReasonNone: + case eStopReasonTrace: + case eStopReasonExec: + case eStopReasonPlanComplete: + case eStopReasonThreadExiting: + case eStopReasonInstrumentation: + // There is no data for these stop reasons. + return 0; + + case eStopReasonBreakpoint: { + break_id_t site_id = stop_info_sp->GetValue(); + lldb::BreakpointSiteSP bp_site_sp( + exe_ctx.GetProcessPtr()->GetBreakpointSiteList().FindByID( + site_id)); + if (bp_site_sp) + return bp_site_sp->GetNumberOfOwners() * 2; + else + return 0; // Breakpoint must have cleared itself... + } break; + + case eStopReasonWatchpoint: + return 1; + + case eStopReasonSignal: + return 1; + + case eStopReasonException: + return 1; + } + } + } + } + return 0; +} + +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); + + if (exe_ctx.HasThreadScope()) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { + Thread *thread = exe_ctx.GetThreadPtr(); + StopInfoSP stop_info_sp = thread->GetStopInfo(); + if (stop_info_sp) { + StopReason reason = stop_info_sp->GetStopReason(); + switch (reason) { + case eStopReasonInvalid: + case eStopReasonNone: + case eStopReasonTrace: + case eStopReasonExec: + case eStopReasonPlanComplete: + case eStopReasonThreadExiting: + case eStopReasonInstrumentation: + // There is no data for these stop reasons. + return 0; + + case eStopReasonBreakpoint: { + break_id_t site_id = stop_info_sp->GetValue(); + lldb::BreakpointSiteSP bp_site_sp( + exe_ctx.GetProcessPtr()->GetBreakpointSiteList().FindByID( + site_id)); + if (bp_site_sp) { + uint32_t bp_index = idx / 2; + BreakpointLocationSP bp_loc_sp( + bp_site_sp->GetOwnerAtIndex(bp_index)); + if (bp_loc_sp) { + if (idx & 1) { + // Odd idx, return the breakpoint location ID + return bp_loc_sp->GetID(); + } else { + // Even idx, return the breakpoint ID + return bp_loc_sp->GetBreakpoint().GetID(); + } + } + } + return LLDB_INVALID_BREAK_ID; + } break; + + case eStopReasonWatchpoint: + return stop_info_sp->GetValue(); + + case eStopReasonSignal: + return stop_info_sp->GetValue(); + + case eStopReasonException: + return stop_info_sp->GetValue(); + } + } + } + } + return 0; +} + +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; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + if (!exe_ctx.HasThreadScope()) + return false; + + StopInfoSP stop_info = exe_ctx.GetThreadPtr()->GetStopInfo(); + StructuredData::ObjectSP info = stop_info->GetExtendedInfo(); + if (!info) + return false; + + info->Dump(strm); + + return true; +} + +SBThreadCollection +SBThread::GetStopReasonExtendedBacktraces(InstrumentationRuntimeType type) { + LLDB_RECORD_METHOD(lldb::SBThreadCollection, SBThread, + GetStopReasonExtendedBacktraces, + (lldb::InstrumentationRuntimeType), type); + + SBThreadCollection threads; + + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + if (!exe_ctx.HasThreadScope()) + return LLDB_RECORD_RESULT(SBThreadCollection()); + + ProcessSP process_sp = exe_ctx.GetProcessSP(); + + StopInfoSP stop_info = exe_ctx.GetThreadPtr()->GetStopInfo(); + StructuredData::ObjectSP info = stop_info->GetExtendedInfo(); + if (!info) + return LLDB_RECORD_RESULT(threads); + + threads = process_sp->GetInstrumentationRuntime(type) + ->GetBacktracesFromExtendedStopInfo(info); + return LLDB_RECORD_RESULT(threads); +} + +size_t SBThread::GetStopDescription(char *dst, size_t dst_len) { + LLDB_RECORD_CHAR_PTR_METHOD(size_t, SBThread, GetStopDescription, + (char *, size_t), dst, "", dst_len); + + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + if (dst) + *dst = 0; + + if (!exe_ctx.HasThreadScope()) + return 0; + + Process::StopLocker stop_locker; + if (!stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) + return 0; + + std::string thread_stop_desc = exe_ctx.GetThreadPtr()->GetStopDescription(); + if (thread_stop_desc.empty()) + return 0; + + if (dst) + return ::snprintf(dst, dst_len, "%s", thread_stop_desc.c_str()) + 1; + + // NULL dst passed in, return the length needed to contain the + // description. + return thread_stop_desc.size() + 1; // Include the NULL byte for size +} + +SBValue SBThread::GetStopReturnValue() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBThread, GetStopReturnValue); + + ValueObjectSP return_valobj_sp; + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + if (exe_ctx.HasThreadScope()) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { + StopInfoSP stop_info_sp = exe_ctx.GetThreadPtr()->GetStopInfo(); + if (stop_info_sp) { + return_valobj_sp = StopInfo::GetReturnValueObject(stop_info_sp); + } + } + } + + return LLDB_RECORD_RESULT(SBValue(return_valobj_sp)); +} + +void SBThread::SetThread(const ThreadSP &lldb_object_sp) { + m_opaque_sp->SetThreadSP(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(); + return LLDB_INVALID_THREAD_ID; +} + +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(); + return LLDB_INVALID_INDEX32; +} + +const char *SBThread::GetName() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBThread, GetName); + + const char *name = nullptr; + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + if (exe_ctx.HasThreadScope()) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { + name = exe_ctx.GetThreadPtr()->GetName(); + } + } + + return name; +} + +const char *SBThread::GetQueueName() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBThread, GetQueueName); + + const char *name = nullptr; + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + if (exe_ctx.HasThreadScope()) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { + name = exe_ctx.GetThreadPtr()->GetQueueName(); + } + } + + return name; +} + +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); + + if (exe_ctx.HasThreadScope()) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { + id = exe_ctx.GetThreadPtr()->GetQueueID(); + } + } + + return id; +} + +bool SBThread::GetInfoItemByPathAsString(const char *path, SBStream &strm) { + LLDB_RECORD_METHOD(bool, SBThread, GetInfoItemByPathAsString, + (const char *, lldb::SBStream &), path, strm); + + bool success = false; + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + if (exe_ctx.HasThreadScope()) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { + Thread *thread = exe_ctx.GetThreadPtr(); + StructuredData::ObjectSP info_root_sp = thread->GetExtendedInfo(); + if (info_root_sp) { + StructuredData::ObjectSP node = + info_root_sp->GetObjectForDotSeparatedPath(path); + if (node) { + if (node->GetType() == eStructuredDataTypeString) { + strm.Printf("%s", node->GetAsString()->GetValue().str().c_str()); + success = true; + } + if (node->GetType() == eStructuredDataTypeInteger) { + strm.Printf("0x%" PRIx64, node->GetAsInteger()->GetValue()); + success = true; + } + if (node->GetType() == eStructuredDataTypeFloat) { + strm.Printf("0x%f", node->GetAsFloat()->GetValue()); + success = true; + } + if (node->GetType() == eStructuredDataTypeBoolean) { + if (node->GetAsBoolean()->GetValue()) + strm.Printf("true"); + else + strm.Printf("false"); + success = true; + } + if (node->GetType() == eStructuredDataTypeNull) { + strm.Printf("null"); + success = true; + } + } + } + } + } + + return success; +} + +SBError SBThread::ResumeNewPlan(ExecutionContext &exe_ctx, + ThreadPlan *new_plan) { + SBError sb_error; + + Process *process = exe_ctx.GetProcessPtr(); + if (!process) { + sb_error.SetErrorString("No process in SBThread::ResumeNewPlan"); + return sb_error; + } + + Thread *thread = exe_ctx.GetThreadPtr(); + if (!thread) { + sb_error.SetErrorString("No thread in SBThread::ResumeNewPlan"); + return sb_error; + } + + // User level plans should be Master Plans so they can be interrupted, other + // plans executed, and then a "continue" will resume the plan. + if (new_plan != nullptr) { + new_plan->SetIsMasterPlan(true); + new_plan->SetOkayToDiscard(false); + } + + // Why do we need to set the current thread by ID here??? + process->GetThreadList().SetSelectedThreadByID(thread->GetID()); + + if (process->GetTarget().GetDebugger().GetAsyncExecution()) + sb_error.ref() = process->Resume(); + else + sb_error.ref() = process->ResumeSynchronous(nullptr); + + return sb_error; +} + +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); + + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + if (!exe_ctx.HasThreadScope()) { + error.SetErrorString("this SBThread object is invalid"); + return; + } + + Thread *thread = exe_ctx.GetThreadPtr(); + bool abort_other_plans = false; + StackFrameSP frame_sp(thread->GetStackFrameAtIndex(0)); + + Status new_plan_status; + ThreadPlanSP new_plan_sp; + if (frame_sp) { + if (frame_sp->HasDebugInformation()) { + const LazyBool avoid_no_debug = eLazyBoolCalculate; + SymbolContext sc(frame_sp->GetSymbolContext(eSymbolContextEverything)); + new_plan_sp = thread->QueueThreadPlanForStepOverRange( + abort_other_plans, sc.line_entry, sc, stop_other_threads, + new_plan_status, avoid_no_debug); + } else { + new_plan_sp = thread->QueueThreadPlanForStepSingleInstruction( + true, abort_other_plans, stop_other_threads, new_plan_status); + } + } + error = ResumeNewPlan(exe_ctx, new_plan_sp.get()); +} + +void SBThread::StepInto(lldb::RunMode stop_other_threads) { + LLDB_RECORD_METHOD(void, SBThread, StepInto, (lldb::RunMode), + stop_other_threads); + + StepInto(nullptr, stop_other_threads); +} + +void SBThread::StepInto(const char *target_name, + lldb::RunMode stop_other_threads) { + LLDB_RECORD_METHOD(void, SBThread, StepInto, (const char *, lldb::RunMode), + target_name, stop_other_threads); + + 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); + + + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + if (!exe_ctx.HasThreadScope()) { + error.SetErrorString("this SBThread object is invalid"); + return; + } + + bool abort_other_plans = false; + + Thread *thread = exe_ctx.GetThreadPtr(); + StackFrameSP frame_sp(thread->GetStackFrameAtIndex(0)); + ThreadPlanSP new_plan_sp; + Status new_plan_status; + + if (frame_sp && frame_sp->HasDebugInformation()) { + SymbolContext sc(frame_sp->GetSymbolContext(eSymbolContextEverything)); + AddressRange range; + if (end_line == LLDB_INVALID_LINE_NUMBER) + range = sc.line_entry.range; + else { + if (!sc.GetAddressRangeFromHereToEndLine(end_line, range, error.ref())) + return; + } + + const LazyBool step_out_avoids_code_without_debug_info = + eLazyBoolCalculate; + const LazyBool step_in_avoids_code_without_debug_info = + eLazyBoolCalculate; + new_plan_sp = thread->QueueThreadPlanForStepInRange( + abort_other_plans, range, sc, target_name, stop_other_threads, + new_plan_status, step_in_avoids_code_without_debug_info, + step_out_avoids_code_without_debug_info); + } else { + new_plan_sp = thread->QueueThreadPlanForStepSingleInstruction( + false, abort_other_plans, stop_other_threads, new_plan_status); + } + + if (new_plan_status.Success()) + error = ResumeNewPlan(exe_ctx, new_plan_sp.get()); + else + error.SetErrorString(new_plan_status.AsCString()); +} + +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); + + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + if (!exe_ctx.HasThreadScope()) { + error.SetErrorString("this SBThread object is invalid"); + return; + } + + bool abort_other_plans = false; + bool stop_other_threads = false; + + Thread *thread = exe_ctx.GetThreadPtr(); + + const LazyBool avoid_no_debug = eLazyBoolCalculate; + Status new_plan_status; + ThreadPlanSP new_plan_sp(thread->QueueThreadPlanForStepOut( + abort_other_plans, nullptr, false, stop_other_threads, eVoteYes, + eVoteNoOpinion, 0, new_plan_status, avoid_no_debug)); + + if (new_plan_status.Success()) + error = ResumeNewPlan(exe_ctx, new_plan_sp.get()); + else + error.SetErrorString(new_plan_status.AsCString()); +} + +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); + + + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + if (!sb_frame.IsValid()) { + error.SetErrorString("passed invalid SBFrame object"); + return; + } + + StackFrameSP frame_sp(sb_frame.GetFrameSP()); + + if (!exe_ctx.HasThreadScope()) { + error.SetErrorString("this SBThread object is invalid"); + return; + } + + bool abort_other_plans = false; + bool stop_other_threads = false; + Thread *thread = exe_ctx.GetThreadPtr(); + if (sb_frame.GetThread().GetThreadID() != thread->GetID()) { + error.SetErrorString("passed a frame from another thread"); + return; + } + + Status new_plan_status; + ThreadPlanSP new_plan_sp(thread->QueueThreadPlanForStepOut( + abort_other_plans, nullptr, false, stop_other_threads, eVoteYes, + eVoteNoOpinion, frame_sp->GetFrameIndex(), new_plan_status)); + + if (new_plan_status.Success()) + error = ResumeNewPlan(exe_ctx, new_plan_sp.get()); + else + error.SetErrorString(new_plan_status.AsCString()); +} + +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); + + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + if (!exe_ctx.HasThreadScope()) { + error.SetErrorString("this SBThread object is invalid"); + return; + } + + Thread *thread = exe_ctx.GetThreadPtr(); + Status new_plan_status; + ThreadPlanSP new_plan_sp(thread->QueueThreadPlanForStepSingleInstruction( + step_over, true, true, new_plan_status)); + + if (new_plan_status.Success()) + error = ResumeNewPlan(exe_ctx, new_plan_sp.get()); + else + error.SetErrorString(new_plan_status.AsCString()); +} + +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); + + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + if (!exe_ctx.HasThreadScope()) { + error.SetErrorString("this SBThread object is invalid"); + return; + } + + bool abort_other_plans = false; + bool stop_other_threads = true; + + Address target_addr(addr); + + Thread *thread = exe_ctx.GetThreadPtr(); + + Status new_plan_status; + ThreadPlanSP new_plan_sp(thread->QueueThreadPlanForRunToAddress( + abort_other_plans, target_addr, stop_other_threads, new_plan_status)); + + if (new_plan_status.Success()) + error = ResumeNewPlan(exe_ctx, new_plan_sp.get()); + else + error.SetErrorString(new_plan_status.AsCString()); +} + +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; + char path[PATH_MAX]; + + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + StackFrameSP frame_sp(sb_frame.GetFrameSP()); + + if (exe_ctx.HasThreadScope()) { + Target *target = exe_ctx.GetTargetPtr(); + Thread *thread = exe_ctx.GetThreadPtr(); + + if (line == 0) { + sb_error.SetErrorString("invalid line argument"); + return LLDB_RECORD_RESULT(sb_error); + } + + if (!frame_sp) { + frame_sp = thread->GetSelectedFrame(); + if (!frame_sp) + frame_sp = thread->GetStackFrameAtIndex(0); + } + + SymbolContext frame_sc; + if (!frame_sp) { + sb_error.SetErrorString("no valid frames in thread to step"); + return LLDB_RECORD_RESULT(sb_error); + } + + // If we have a frame, get its line + frame_sc = frame_sp->GetSymbolContext( + eSymbolContextCompUnit | eSymbolContextFunction | + eSymbolContextLineEntry | eSymbolContextSymbol); + + if (frame_sc.comp_unit == nullptr) { + sb_error.SetErrorStringWithFormat( + "frame %u doesn't have debug information", frame_sp->GetFrameIndex()); + return LLDB_RECORD_RESULT(sb_error); + } + + FileSpec step_file_spec; + if (sb_file_spec.IsValid()) { + // The file spec passed in was valid, so use it + step_file_spec = sb_file_spec.ref(); + } else { + if (frame_sc.line_entry.IsValid()) + step_file_spec = frame_sc.line_entry.file; + else { + sb_error.SetErrorString("invalid file argument or no file for frame"); + return LLDB_RECORD_RESULT(sb_error); + } + } + + // Grab the current function, then we will make sure the "until" address is + // within the function. We discard addresses that are out of the current + // function, and then if there are no addresses remaining, give an + // appropriate error message. + + bool all_in_function = true; + AddressRange fun_range = frame_sc.function->GetAddressRange(); + + std::vector<addr_t> step_over_until_addrs; + const bool abort_other_plans = false; + const bool stop_other_threads = false; + const bool check_inlines = true; + const bool exact = false; + + SymbolContextList sc_list; + frame_sc.comp_unit->ResolveSymbolContext(step_file_spec, line, + check_inlines, exact, + eSymbolContextLineEntry, sc_list); + const uint32_t num_matches = sc_list.GetSize(); + if (num_matches > 0) { + SymbolContext sc; + for (uint32_t i = 0; i < num_matches; ++i) { + if (sc_list.GetContextAtIndex(i, sc)) { + addr_t step_addr = + sc.line_entry.range.GetBaseAddress().GetLoadAddress(target); + if (step_addr != LLDB_INVALID_ADDRESS) { + if (fun_range.ContainsLoadAddress(step_addr, target)) + step_over_until_addrs.push_back(step_addr); + else + all_in_function = false; + } + } + } + } + + if (step_over_until_addrs.empty()) { + if (all_in_function) { + step_file_spec.GetPath(path, sizeof(path)); + sb_error.SetErrorStringWithFormat("No line entries for %s:%u", path, + line); + } else + sb_error.SetErrorString("step until target not in current function"); + } else { + Status new_plan_status; + ThreadPlanSP new_plan_sp(thread->QueueThreadPlanForStepUntil( + abort_other_plans, &step_over_until_addrs[0], + step_over_until_addrs.size(), stop_other_threads, + frame_sp->GetFrameIndex(), new_plan_status)); + + if (new_plan_status.Success()) + sb_error = ResumeNewPlan(exe_ctx, new_plan_sp.get()); + else + sb_error.SetErrorString(new_plan_status.AsCString()); + } + } else { + sb_error.SetErrorString("this SBThread object is invalid"); + } + return LLDB_RECORD_RESULT(sb_error); +} + +SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name) { + 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); + + lldb::SBStructuredData no_data; + return LLDB_RECORD_RESULT(StepUsingScriptedThreadPlan( + script_class_name, no_data, resume_immediately)); +} + +SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name, + SBStructuredData &args_data, + bool resume_immediately) { + LLDB_RECORD_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan, + (const char *, lldb::SBStructuredData &, bool), + script_class_name, args_data, resume_immediately); + + SBError error; + + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + if (!exe_ctx.HasThreadScope()) { + error.SetErrorString("this SBThread object is invalid"); + return LLDB_RECORD_RESULT(error); + } + + Thread *thread = exe_ctx.GetThreadPtr(); + Status new_plan_status; + StructuredData::ObjectSP obj_sp = args_data.m_impl_up->GetObjectSP(); + + ThreadPlanSP new_plan_sp = thread->QueueThreadPlanForStepScripted( + false, script_class_name, obj_sp, false, new_plan_status); + + if (new_plan_status.Fail()) { + error.SetErrorString(new_plan_status.AsCString()); + return LLDB_RECORD_RESULT(error); + } + + if (!resume_immediately) + 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 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); + + SBError sb_error; + + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + if (!exe_ctx.HasThreadScope()) { + sb_error.SetErrorString("this SBThread object is invalid"); + return LLDB_RECORD_RESULT(sb_error); + } + + Thread *thread = exe_ctx.GetThreadPtr(); + + Status err = thread->JumpToLine(file_spec.ref(), line, true); + sb_error.SetError(err); + 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; + + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + if (exe_ctx.HasThreadScope()) { + Thread *thread = exe_ctx.GetThreadPtr(); + sb_error.SetError( + thread->ReturnFromFrame(frame.GetFrameSP(), return_value.GetSP())); + } + + return LLDB_RECORD_RESULT(sb_error); +} + +SBError SBThread::UnwindInnermostExpression() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBThread, + UnwindInnermostExpression); + + SBError sb_error; + + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + if (exe_ctx.HasThreadScope()) { + Thread *thread = exe_ctx.GetThreadPtr(); + sb_error.SetError(thread->UnwindInnermostExpression()); + if (sb_error.Success()) + thread->SetSelectedFrameByIndex(0, false); + } + + 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); + + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + bool result = false; + if (exe_ctx.HasThreadScope()) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { + exe_ctx.GetThreadPtr()->SetResumeState(eStateSuspended); + result = true; + } else { + error.SetErrorString("process is running"); + } + } else + error.SetErrorString("this SBThread object is invalid"); + return result; +} + +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); + + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + bool result = false; + if (exe_ctx.HasThreadScope()) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { + const bool override_suspend = true; + exe_ctx.GetThreadPtr()->SetResumeState(eStateRunning, override_suspend); + result = true; + } else { + error.SetErrorString("process is running"); + } + } else + error.SetErrorString("this SBThread object is invalid"); + return result; +} + +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); + + if (exe_ctx.HasThreadScope()) + return exe_ctx.GetThreadPtr()->GetResumeState() == eStateSuspended; + return false; +} + +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); + + if (exe_ctx.HasThreadScope()) + return StateIsStoppedState(exe_ctx.GetThreadPtr()->GetState(), true); + return false; +} + +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); + + if (exe_ctx.HasThreadScope()) { + // Have to go up to the target so we can get a shared pointer to our + // process... + sb_process.SetSP(exe_ctx.GetProcessSP()); + } + + return LLDB_RECORD_RESULT(sb_process); +} + +uint32_t SBThread::GetNumFrames() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBThread, GetNumFrames); + + uint32_t num_frames = 0; + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + if (exe_ctx.HasThreadScope()) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { + num_frames = exe_ctx.GetThreadPtr()->GetStackFrameCount(); + } + } + + return num_frames; +} + +SBFrame SBThread::GetFrameAtIndex(uint32_t idx) { + LLDB_RECORD_METHOD(lldb::SBFrame, SBThread, GetFrameAtIndex, (uint32_t), idx); + + SBFrame sb_frame; + StackFrameSP frame_sp; + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + if (exe_ctx.HasThreadScope()) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { + frame_sp = exe_ctx.GetThreadPtr()->GetStackFrameAtIndex(idx); + sb_frame.SetFrameSP(frame_sp); + } + } + + return LLDB_RECORD_RESULT(sb_frame); +} + +lldb::SBFrame SBThread::GetSelectedFrame() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFrame, SBThread, GetSelectedFrame); + + SBFrame sb_frame; + StackFrameSP frame_sp; + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + if (exe_ctx.HasThreadScope()) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { + frame_sp = exe_ctx.GetThreadPtr()->GetSelectedFrame(); + sb_frame.SetFrameSP(frame_sp); + } + } + + return LLDB_RECORD_RESULT(sb_frame); +} + +lldb::SBFrame SBThread::SetSelectedFrame(uint32_t idx) { + LLDB_RECORD_METHOD(lldb::SBFrame, SBThread, SetSelectedFrame, (uint32_t), + idx); + + SBFrame sb_frame; + StackFrameSP frame_sp; + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + if (exe_ctx.HasThreadScope()) { + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { + Thread *thread = exe_ctx.GetThreadPtr(); + frame_sp = thread->GetStackFrameAtIndex(idx); + if (frame_sp) { + thread->SetSelectedFrame(frame_sp.get()); + sb_frame.SetFrameSP(frame_sp); + } + } + } + + 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()) != nullptr; +} + +SBFrame SBThread::GetStackFrameFromEvent(const SBEvent &event) { + 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) { + 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; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + if (exe_ctx.HasThreadScope()) { + exe_ctx.GetThreadPtr()->GetStatus(strm, 0, 1, 1, true); + } else + strm.PutCString("No status"); + + return true; +} + +bool SBThread::GetDescription(SBStream &description) const { + 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; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + + if (exe_ctx.HasThreadScope()) { + exe_ctx.GetThreadPtr()->DumpUsingSettingsFormat(strm, + LLDB_INVALID_THREAD_ID, + stop_format); + // strm.Printf("SBThread: tid = 0x%4.4" PRIx64, + // exe_ctx.GetThreadPtr()->GetID()); + } else + strm.PutCString("No value"); + + return true; +} + +SBThread SBThread::GetExtendedBacktraceThread(const char *type) { + LLDB_RECORD_METHOD(lldb::SBThread, SBThread, GetExtendedBacktraceThread, + (const char *), type); + + std::unique_lock<std::recursive_mutex> lock; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + SBThread sb_origin_thread; + + Process::StopLocker stop_locker; + if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { + if (exe_ctx.HasThreadScope()) { + ThreadSP real_thread(exe_ctx.GetThreadSP()); + if (real_thread) { + ConstString type_const(type); + Process *process = exe_ctx.GetProcessPtr(); + if (process) { + SystemRuntime *runtime = process->GetSystemRuntime(); + if (runtime) { + ThreadSP new_thread_sp( + runtime->GetExtendedBacktraceThread(real_thread, type_const)); + if (new_thread_sp) { + // Save this in the Process' ExtendedThreadList so a strong + // pointer retains the object. + process->GetExtendedThreadList().AddThread(new_thread_sp); + sb_origin_thread.SetThread(new_thread_sp); + } + } + } + } + } + } + + 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(); + return LLDB_INVALID_INDEX32; +} + +SBValue SBThread::GetCurrentException() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBThread, 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() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBThread, SBThread, + 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(); + return true; +} + +lldb_private::Thread *SBThread::operator->() { + return get(); +} + +lldb_private::Thread *SBThread::get() { + return m_opaque_sp->GetThreadSP().get(); +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBThread>(Registry &R) { + LLDB_REGISTER_STATIC_METHOD(const char *, SBThread, GetBroadcasterClassName, + ()); + LLDB_REGISTER_CONSTRUCTOR(SBThread, ()); + LLDB_REGISTER_CONSTRUCTOR(SBThread, (const lldb::ThreadSP &)); + LLDB_REGISTER_CONSTRUCTOR(SBThread, (const lldb::SBThread &)); + LLDB_REGISTER_METHOD(const lldb::SBThread &, + SBThread, operator=,(const lldb::SBThread &)); + LLDB_REGISTER_METHOD_CONST(lldb::SBQueue, SBThread, GetQueue, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBThread, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBThread, operator bool, ()); + LLDB_REGISTER_METHOD(void, SBThread, Clear, ()); + LLDB_REGISTER_METHOD(lldb::StopReason, SBThread, GetStopReason, ()); + LLDB_REGISTER_METHOD(size_t, SBThread, GetStopReasonDataCount, ()); + LLDB_REGISTER_METHOD(uint64_t, SBThread, GetStopReasonDataAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD(bool, SBThread, GetStopReasonExtendedInfoAsJSON, + (lldb::SBStream &)); + LLDB_REGISTER_METHOD(lldb::SBThreadCollection, SBThread, + GetStopReasonExtendedBacktraces, + (lldb::InstrumentationRuntimeType)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBThread, GetStopReturnValue, ()); + LLDB_REGISTER_METHOD_CONST(lldb::tid_t, SBThread, GetThreadID, ()); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBThread, GetIndexID, ()); + LLDB_REGISTER_METHOD_CONST(const char *, SBThread, GetName, ()); + LLDB_REGISTER_METHOD_CONST(const char *, SBThread, GetQueueName, ()); + LLDB_REGISTER_METHOD_CONST(lldb::queue_id_t, SBThread, GetQueueID, ()); + LLDB_REGISTER_METHOD(bool, SBThread, GetInfoItemByPathAsString, + (const char *, lldb::SBStream &)); + LLDB_REGISTER_METHOD(void, SBThread, StepOver, (lldb::RunMode)); + LLDB_REGISTER_METHOD(void, SBThread, StepOver, + (lldb::RunMode, lldb::SBError &)); + LLDB_REGISTER_METHOD(void, SBThread, StepInto, (lldb::RunMode)); + LLDB_REGISTER_METHOD(void, SBThread, StepInto, + (const char *, lldb::RunMode)); + LLDB_REGISTER_METHOD( + void, SBThread, StepInto, + (const char *, uint32_t, lldb::SBError &, lldb::RunMode)); + LLDB_REGISTER_METHOD(void, SBThread, StepOut, ()); + LLDB_REGISTER_METHOD(void, SBThread, StepOut, (lldb::SBError &)); + LLDB_REGISTER_METHOD(void, SBThread, StepOutOfFrame, (lldb::SBFrame &)); + LLDB_REGISTER_METHOD(void, SBThread, StepOutOfFrame, + (lldb::SBFrame &, lldb::SBError &)); + LLDB_REGISTER_METHOD(void, SBThread, StepInstruction, (bool)); + LLDB_REGISTER_METHOD(void, SBThread, StepInstruction, + (bool, lldb::SBError &)); + LLDB_REGISTER_METHOD(void, SBThread, RunToAddress, (lldb::addr_t)); + LLDB_REGISTER_METHOD(void, SBThread, RunToAddress, + (lldb::addr_t, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBError, SBThread, StepOverUntil, + (lldb::SBFrame &, lldb::SBFileSpec &, uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan, + (const char *)); + LLDB_REGISTER_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan, + (const char *, bool)); + LLDB_REGISTER_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan, + (const char *, SBStructuredData &, bool)); + LLDB_REGISTER_METHOD(lldb::SBError, SBThread, JumpToLine, + (lldb::SBFileSpec &, uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBError, SBThread, ReturnFromFrame, + (lldb::SBFrame &, lldb::SBValue &)); + LLDB_REGISTER_METHOD(lldb::SBError, SBThread, UnwindInnermostExpression, + ()); + LLDB_REGISTER_METHOD(bool, SBThread, Suspend, ()); + LLDB_REGISTER_METHOD(bool, SBThread, Suspend, (lldb::SBError &)); + LLDB_REGISTER_METHOD(bool, SBThread, Resume, ()); + LLDB_REGISTER_METHOD(bool, SBThread, Resume, (lldb::SBError &)); + LLDB_REGISTER_METHOD(bool, SBThread, IsSuspended, ()); + LLDB_REGISTER_METHOD(bool, SBThread, IsStopped, ()); + LLDB_REGISTER_METHOD(lldb::SBProcess, SBThread, GetProcess, ()); + LLDB_REGISTER_METHOD(uint32_t, SBThread, GetNumFrames, ()); + LLDB_REGISTER_METHOD(lldb::SBFrame, SBThread, GetFrameAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBFrame, SBThread, GetSelectedFrame, ()); + LLDB_REGISTER_METHOD(lldb::SBFrame, SBThread, SetSelectedFrame, (uint32_t)); + LLDB_REGISTER_STATIC_METHOD(bool, SBThread, EventIsThreadEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBFrame, SBThread, GetStackFrameFromEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBThread, SBThread, GetThreadFromEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_METHOD_CONST(bool, + SBThread, operator==,(const lldb::SBThread &)); + LLDB_REGISTER_METHOD_CONST(bool, + SBThread, operator!=,(const lldb::SBThread &)); + LLDB_REGISTER_METHOD_CONST(bool, SBThread, GetStatus, (lldb::SBStream &)); + LLDB_REGISTER_METHOD_CONST(bool, SBThread, GetDescription, + (lldb::SBStream &)); + LLDB_REGISTER_METHOD_CONST(bool, SBThread, GetDescription, + (lldb::SBStream &, bool)); + LLDB_REGISTER_METHOD(lldb::SBThread, SBThread, GetExtendedBacktraceThread, + (const char *)); + LLDB_REGISTER_METHOD(uint32_t, SBThread, + GetExtendedBacktraceOriginatingIndexID, ()); + LLDB_REGISTER_METHOD(lldb::SBValue, SBThread, GetCurrentException, ()); + LLDB_REGISTER_METHOD(lldb::SBThread, SBThread, GetCurrentExceptionBacktrace, + ()); + LLDB_REGISTER_METHOD(bool, SBThread, SafeToCallFunctions, ()); + LLDB_REGISTER_CHAR_PTR_METHOD(size_t, SBThread, GetStopDescription); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBThreadCollection.cpp b/contrib/llvm-project/lldb/source/API/SBThreadCollection.cpp new file mode 100644 index 000000000000..bfca864d6bcd --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBThreadCollection.cpp @@ -0,0 +1,110 @@ +//===-- SBThreadCollection.cpp --------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/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() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBThreadCollection); +} + +SBThreadCollection::SBThreadCollection(const SBThreadCollection &rhs) + : 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 LLDB_RECORD_RESULT(*this); +} + +SBThreadCollection::SBThreadCollection(const ThreadCollectionSP &threads) + : m_opaque_sp(threads) {} + +SBThreadCollection::~SBThreadCollection() = default; + +void SBThreadCollection::SetOpaque(const lldb::ThreadCollectionSP &threads) { + m_opaque_sp = threads; +} + +lldb_private::ThreadCollection *SBThreadCollection::get() const { + return m_opaque_sp.get(); +} + +lldb_private::ThreadCollection *SBThreadCollection::operator->() const { + return m_opaque_sp.operator->(); +} + +lldb::ThreadCollectionSP &SBThreadCollection::operator*() { + return m_opaque_sp; +} + +const lldb::ThreadCollectionSP &SBThreadCollection::operator*() const { + return m_opaque_sp; +} + +bool SBThreadCollection::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadCollection, IsValid); + return this->operator bool(); +} +SBThreadCollection::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadCollection, operator bool); + + return m_opaque_sp.get() != nullptr; +} + +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 LLDB_RECORD_RESULT(thread); +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBThreadCollection>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBThreadCollection, ()); + LLDB_REGISTER_CONSTRUCTOR(SBThreadCollection, + (const lldb::SBThreadCollection &)); + LLDB_REGISTER_METHOD( + const lldb::SBThreadCollection &, + SBThreadCollection, operator=,(const lldb::SBThreadCollection &)); + LLDB_REGISTER_METHOD_CONST(bool, SBThreadCollection, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBThreadCollection, operator bool, ()); + LLDB_REGISTER_METHOD(size_t, SBThreadCollection, GetSize, ()); + LLDB_REGISTER_METHOD(lldb::SBThread, SBThreadCollection, GetThreadAtIndex, + (size_t)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBThreadPlan.cpp b/contrib/llvm-project/lldb/source/API/SBThreadPlan.cpp new file mode 100644 index 000000000000..1a947bbc2608 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBThreadPlan.cpp @@ -0,0 +1,498 @@ +//===-- SBThreadPlan.cpp --------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "SBReproducerPrivate.h" +#include "lldb/API/SBThread.h" + +#include "lldb/API/SBFileSpec.h" +#include "lldb/API/SBStream.h" +#include "lldb/API/SBStructuredData.h" +#include "lldb/API/SBSymbolContext.h" +#include "lldb/Breakpoint/BreakpointLocation.h" +#include "lldb/Core/Debugger.h" +#include "lldb/Core/StreamFile.h" +#include "lldb/Core/StructuredDataImpl.h" +#include "lldb/Interpreter/CommandInterpreter.h" +#include "lldb/Symbol/CompileUnit.h" +#include "lldb/Symbol/SymbolContext.h" +#include "lldb/Target/Process.h" +#include "lldb/Target/Queue.h" +#include "lldb/Target/StopInfo.h" +#include "lldb/Target/SystemRuntime.h" +#include "lldb/Target/Target.h" +#include "lldb/Target/Thread.h" +#include "lldb/Target/ThreadPlan.h" +#include "lldb/Target/ThreadPlanPython.h" +#include "lldb/Target/ThreadPlanStepInRange.h" +#include "lldb/Target/ThreadPlanStepInstruction.h" +#include "lldb/Target/ThreadPlanStepOut.h" +#include "lldb/Target/ThreadPlanStepRange.h" +#include "lldb/Utility/State.h" +#include "lldb/Utility/Stream.h" +#include "lldb/Utility/StructuredData.h" + +#include "lldb/API/SBAddress.h" +#include "lldb/API/SBDebugger.h" +#include "lldb/API/SBEvent.h" +#include "lldb/API/SBFrame.h" +#include "lldb/API/SBProcess.h" +#include "lldb/API/SBThreadPlan.h" +#include "lldb/API/SBValue.h" + +#include <memory> + +using namespace lldb; +using namespace lldb_private; + +// Constructors +SBThreadPlan::SBThreadPlan() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBThreadPlan); } + +SBThreadPlan::SBThreadPlan(const ThreadPlanSP &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) { + 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, + nullptr); +} + +SBThreadPlan::SBThreadPlan(lldb::SBThread &sb_thread, const char *class_name, + lldb::SBStructuredData &args_data) { + LLDB_RECORD_CONSTRUCTOR(SBThreadPlan, (lldb::SBThread &, const char *, + SBStructuredData &), + sb_thread, class_name, args_data); + + Thread *thread = sb_thread.get(); + if (thread) + m_opaque_sp = std::make_shared<ThreadPlanPython>(*thread, class_name, + args_data.m_impl_up.get()); +} + +// Assignment operator + +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 LLDB_RECORD_RESULT(*this); +} +// Destructor +SBThreadPlan::~SBThreadPlan() = default; + +lldb_private::ThreadPlan *SBThreadPlan::get() { return m_opaque_sp.get(); } + +bool SBThreadPlan::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadPlan, IsValid); + return this->operator bool(); +} +SBThreadPlan::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadPlan, operator bool); + + return m_opaque_sp.get() != nullptr; +} + +void SBThreadPlan::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBThreadPlan, Clear); + + 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 LLDB_RECORD_RESULT( + SBThread(m_opaque_sp->GetThread().shared_from_this())); + } else + 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 { + description.Printf("Empty SBThreadPlan"); + } + return true; +} + +void SBThreadPlan::SetThreadPlan(const ThreadPlanSP &lldb_object_sp) { + m_opaque_sp = 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 + return true; +} + +bool SBThreadPlan::IsPlanStale() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, IsPlanStale); + + if (m_opaque_sp) + return m_opaque_sp->IsPlanStale(); + else + return true; +} + +bool SBThreadPlan::IsValid() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, IsValid); + + if (m_opaque_sp) + return m_opaque_sp->ValidatePlan(nullptr); + else + return false; +} + +// This section allows an SBThreadPlan to push another of the common types of +// plans... +// +// FIXME, you should only be able to queue thread plans from inside the methods +// of a Scripted Thread Plan. Need a way to enforce that. + +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 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 LLDB_RECORD_RESULT(SBThreadPlan()); + } + + AddressRange range(*start_address, size); + SymbolContext sc; + start_address->CalculateSymbolContext(&sc); + Status plan_status; + + SBThreadPlan plan = + SBThreadPlan(m_opaque_sp->GetThread().QueueThreadPlanForStepOverRange( + false, range, sc, eAllThreads, plan_status)); + + if (plan_status.Fail()) + error.SetErrorString(plan_status.AsCString()); + else + plan.m_opaque_sp->SetPrivate(true); + + return LLDB_RECORD_RESULT(plan); + } else { + 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 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 LLDB_RECORD_RESULT(SBThreadPlan()); + } + + AddressRange range(*start_address, size); + SymbolContext sc; + start_address->CalculateSymbolContext(&sc); + + Status plan_status; + SBThreadPlan plan = + SBThreadPlan(m_opaque_sp->GetThread().QueueThreadPlanForStepInRange( + false, range, sc, nullptr, eAllThreads, plan_status)); + + if (plan_status.Fail()) + error.SetErrorString(plan_status.AsCString()); + else + plan.m_opaque_sp->SetPrivate(true); + + return LLDB_RECORD_RESULT(plan); + } else { + 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 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( + lldb::eSymbolContextEverything); + + Status plan_status; + SBThreadPlan plan = + SBThreadPlan(m_opaque_sp->GetThread().QueueThreadPlanForStepOut( + false, &sc, first_insn, false, eVoteYes, eVoteNoOpinion, + frame_idx_to_step_to, plan_status)); + + if (plan_status.Fail()) + error.SetErrorString(plan_status.AsCString()); + else + plan.m_opaque_sp->SetPrivate(true); + + return LLDB_RECORD_RESULT(plan); + } else { + 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 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 LLDB_RECORD_RESULT(SBThreadPlan()); + + Status plan_status; + SBThreadPlan plan = + SBThreadPlan(m_opaque_sp->GetThread().QueueThreadPlanForRunToAddress( + false, *address, false, plan_status)); + + if (plan_status.Fail()) + error.SetErrorString(plan_status.AsCString()); + else + plan.m_opaque_sp->SetPrivate(true); + + return LLDB_RECORD_RESULT(plan); + } else { + 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 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; + StructuredData::ObjectSP empty_args; + SBThreadPlan plan = + SBThreadPlan(m_opaque_sp->GetThread().QueueThreadPlanForStepScripted( + false, script_class_name, empty_args, false, plan_status)); + + if (plan_status.Fail()) + error.SetErrorString(plan_status.AsCString()); + else + plan.m_opaque_sp->SetPrivate(true); + + return LLDB_RECORD_RESULT(plan); + } else { + return LLDB_RECORD_RESULT(SBThreadPlan()); + } +} + +SBThreadPlan +SBThreadPlan::QueueThreadPlanForStepScripted(const char *script_class_name, + lldb::SBStructuredData &args_data, + SBError &error) { + LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForStepScripted, + (const char *, lldb::SBStructuredData &, lldb::SBError &), + script_class_name, args_data, error); + + if (m_opaque_sp) { + Status plan_status; + StructuredData::ObjectSP args_obj = args_data.m_impl_up->GetObjectSP(); + SBThreadPlan plan = + SBThreadPlan(m_opaque_sp->GetThread().QueueThreadPlanForStepScripted( + false, script_class_name, args_obj, false, plan_status)); + + if (plan_status.Fail()) + error.SetErrorString(plan_status.AsCString()); + else + plan.m_opaque_sp->SetPrivate(true); + + return LLDB_RECORD_RESULT(plan); + } else { + return LLDB_RECORD_RESULT(SBThreadPlan()); + } +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBThreadPlan>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, ()); + LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (const lldb::ThreadPlanSP &)); + LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (const lldb::SBThreadPlan &)); + LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (lldb::SBThread &, const char *)); + LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (lldb::SBThread &, const char *, + lldb::SBStructuredData &)); + LLDB_REGISTER_METHOD(const lldb::SBThreadPlan &, + SBThreadPlan, operator=,(const lldb::SBThreadPlan &)); + LLDB_REGISTER_METHOD_CONST(bool, SBThreadPlan, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBThreadPlan, operator bool, ()); + LLDB_REGISTER_METHOD(void, SBThreadPlan, Clear, ()); + LLDB_REGISTER_METHOD(lldb::StopReason, SBThreadPlan, GetStopReason, ()); + LLDB_REGISTER_METHOD(size_t, SBThreadPlan, GetStopReasonDataCount, ()); + LLDB_REGISTER_METHOD(uint64_t, SBThreadPlan, GetStopReasonDataAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBThreadPlan, GetThread, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBThreadPlan, GetDescription, + (lldb::SBStream &)); + LLDB_REGISTER_METHOD(void, SBThreadPlan, SetPlanComplete, (bool)); + LLDB_REGISTER_METHOD(bool, SBThreadPlan, IsPlanComplete, ()); + LLDB_REGISTER_METHOD(bool, SBThreadPlan, IsPlanStale, ()); + LLDB_REGISTER_METHOD(bool, SBThreadPlan, IsValid, ()); + LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForStepOverRange, + (lldb::SBAddress &, lldb::addr_t)); + LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForStepOverRange, + (lldb::SBAddress &, lldb::addr_t, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForStepInRange, + (lldb::SBAddress &, lldb::addr_t)); + LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForStepInRange, + (lldb::SBAddress &, lldb::addr_t, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForStepOut, (uint32_t, bool)); + LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForStepOut, + (uint32_t, bool, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForRunToAddress, (lldb::SBAddress)); + LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForRunToAddress, + (lldb::SBAddress, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForStepScripted, (const char *)); + LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForStepScripted, + (const char *, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan, + QueueThreadPlanForStepScripted, + (const char *, lldb::SBStructuredData &, + lldb::SBError &)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBTrace.cpp b/contrib/llvm-project/lldb/source/API/SBTrace.cpp new file mode 100644 index 000000000000..3fdabaa29ac2 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBTrace.cpp @@ -0,0 +1,147 @@ +//===-- SBTrace.cpp -------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "SBReproducerPrivate.h" +#include "lldb/Target/Process.h" + +#include "lldb/API/SBTrace.h" +#include "lldb/API/SBTraceOptions.h" + +#include <memory> + +using namespace lldb; +using namespace lldb_private; + +class TraceImpl { +public: + lldb::user_id_t uid; +}; + +lldb::ProcessSP SBTrace::GetSP() const { return m_opaque_wp.lock(); } + +size_t SBTrace::GetTraceData(SBError &error, void *buf, size_t size, + size_t offset, lldb::tid_t thread_id) { + LLDB_RECORD_DUMMY(size_t, SBTrace, GetTraceData, + (lldb::SBError &, void *, size_t, size_t, lldb::tid_t), + error, buf, size, offset, thread_id); + + ProcessSP process_sp(GetSP()); + llvm::MutableArrayRef<uint8_t> buffer(static_cast<uint8_t *>(buf), size); + error.Clear(); + + if (!process_sp) { + error.SetErrorString("invalid process"); + } else { + error.SetError( + process_sp->GetData(GetTraceUID(), thread_id, buffer, offset)); + } + return buffer.size(); +} + +size_t SBTrace::GetMetaData(SBError &error, void *buf, size_t size, + size_t offset, lldb::tid_t thread_id) { + LLDB_RECORD_DUMMY(size_t, SBTrace, GetMetaData, + (lldb::SBError &, void *, size_t, size_t, lldb::tid_t), + error, buf, size, offset, thread_id); + + ProcessSP process_sp(GetSP()); + llvm::MutableArrayRef<uint8_t> buffer(static_cast<uint8_t *>(buf), size); + error.Clear(); + + if (!process_sp) { + error.SetErrorString("invalid process"); + } else { + error.SetError( + process_sp->GetMetaData(GetTraceUID(), thread_id, buffer, offset)); + } + return buffer.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(); + + if (!process_sp) { + error.SetErrorString("invalid process"); + return; + } + error.SetError(process_sp->StopTrace(GetTraceUID(), 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(); + + if (!process_sp) { + error.SetErrorString("invalid process"); + } else { + error.SetError(process_sp->GetTraceConfig(GetTraceUID(), + *(options.m_traceoptions_sp))); + } +} + +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; +} + +void SBTrace::SetTraceUID(lldb::user_id_t uid) { + if (m_trace_impl_sp) + m_trace_impl_sp->uid = uid; +} + +SBTrace::SBTrace() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTrace); + + m_trace_impl_sp = std::make_shared<TraceImpl>(); + if (m_trace_impl_sp) + m_trace_impl_sp->uid = LLDB_INVALID_UID; +} + +void SBTrace::SetSP(const ProcessSP &process_sp) { m_opaque_wp = process_sp; } + +bool SBTrace::IsValid() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBTrace, IsValid); + return this->operator bool(); +} +SBTrace::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTrace, operator bool); + + if (!m_trace_impl_sp) + return false; + if (!GetSP()) + return false; + return true; +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBTrace>(Registry &R) { + LLDB_REGISTER_METHOD(void, SBTrace, StopTrace, + (lldb::SBError &, lldb::tid_t)); + LLDB_REGISTER_METHOD(void, SBTrace, GetTraceConfig, + (lldb::SBTraceOptions &, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::user_id_t, SBTrace, GetTraceUID, ()); + LLDB_REGISTER_CONSTRUCTOR(SBTrace, ()); + LLDB_REGISTER_METHOD(bool, SBTrace, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBTrace, operator bool, ()); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBTraceOptions.cpp b/contrib/llvm-project/lldb/source/API/SBTraceOptions.cpp new file mode 100644 index 000000000000..f1f5a63edf06 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBTraceOptions.cpp @@ -0,0 +1,159 @@ +//===-- SBTraceOptions.cpp ------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBTraceOptions.h" +#include "SBReproducerPrivate.h" +#include "lldb/API/SBError.h" +#include "lldb/API/SBStructuredData.h" +#include "lldb/Core/StructuredDataImpl.h" +#include "lldb/Utility/Log.h" +#include "lldb/Utility/TraceOptions.h" + +#include <memory> + +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(); + lldb::SBStructuredData structData; + if (dict_obj && structData.m_impl_up) + structData.m_impl_up->SetObjectSP(dict_obj->shared_from_this()); + else + error.SetErrorString("Empty trace params"); + return LLDB_RECORD_RESULT(structData); +} + +uint64_t SBTraceOptions::getMetaDataBufferSize() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint64_t, SBTraceOptions, + getMetaDataBufferSize); + + if (m_traceoptions_sp) + return m_traceoptions_sp->getTraceBufferSize(); + return 0; +} + +void SBTraceOptions::setTraceParams(lldb::SBStructuredData ¶ms) { + LLDB_RECORD_METHOD(void, SBTraceOptions, setTraceParams, + (lldb::SBStructuredData &), params); + + if (m_traceoptions_sp && params.m_impl_up) { + StructuredData::ObjectSP obj_sp = params.m_impl_up->GetObjectSP(); + if (obj_sp && obj_sp->GetAsDictionary() != nullptr) + m_traceoptions_sp->setTraceParams( + std::static_pointer_cast<StructuredData::Dictionary>(obj_sp)); + } + return; +} + +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); + return this->operator bool(); +} +SBTraceOptions::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTraceOptions, operator bool); + + 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; +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBTraceOptions>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBTraceOptions, ()); + LLDB_REGISTER_METHOD_CONST(lldb::TraceType, SBTraceOptions, getType, ()); + LLDB_REGISTER_METHOD_CONST(uint64_t, SBTraceOptions, getTraceBufferSize, + ()); + LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBTraceOptions, getTraceParams, + (lldb::SBError &)); + LLDB_REGISTER_METHOD_CONST(uint64_t, SBTraceOptions, getMetaDataBufferSize, + ()); + LLDB_REGISTER_METHOD(void, SBTraceOptions, setTraceParams, + (lldb::SBStructuredData &)); + LLDB_REGISTER_METHOD(void, SBTraceOptions, setType, (lldb::TraceType)); + LLDB_REGISTER_METHOD(void, SBTraceOptions, setTraceBufferSize, (uint64_t)); + LLDB_REGISTER_METHOD(void, SBTraceOptions, setMetaDataBufferSize, + (uint64_t)); + LLDB_REGISTER_METHOD(bool, SBTraceOptions, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBTraceOptions, operator bool, ()); + LLDB_REGISTER_METHOD(void, SBTraceOptions, setThreadID, (lldb::tid_t)); + LLDB_REGISTER_METHOD(lldb::tid_t, SBTraceOptions, getThreadID, ()); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBType.cpp b/contrib/llvm-project/lldb/source/API/SBType.cpp new file mode 100644 index 000000000000..852630f2d01a --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBType.cpp @@ -0,0 +1,1010 @@ +//===-- SBType.cpp --------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBType.h" +#include "SBReproducerPrivate.h" +#include "lldb/API/SBDefines.h" +#include "lldb/API/SBStream.h" +#include "lldb/API/SBTypeEnumMember.h" +#include "lldb/Core/Mangled.h" +#include "lldb/Symbol/CompilerType.h" +#include "lldb/Symbol/Type.h" +#include "lldb/Symbol/TypeSystem.h" +#include "lldb/Utility/ConstString.h" +#include "lldb/Utility/Stream.h" + +#include "llvm/ADT/APSInt.h" + +#include <memory> + +using namespace lldb; +using namespace lldb_private; + +SBType::SBType() : m_opaque_sp() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBType); } + +SBType::SBType(const CompilerType &type) + : m_opaque_sp(new TypeImpl( + CompilerType(type.GetTypeSystem(), type.GetOpaqueQualType()))) {} + +SBType::SBType(const lldb::TypeSP &type_sp) + : m_opaque_sp(new TypeImpl(type_sp)) {} + +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; + } +} + +// SBType::SBType (TypeImpl* impl) : +// m_opaque_up(impl) +//{} +// +bool SBType::operator==(SBType &rhs) { + LLDB_RECORD_METHOD(bool, SBType, operator==,(lldb::SBType &), rhs); + + if (!IsValid()) + return !rhs.IsValid(); + + if (!rhs.IsValid()) + return false; + + return *m_opaque_sp.get() == *rhs.m_opaque_sp.get(); +} + +bool SBType::operator!=(SBType &rhs) { + LLDB_RECORD_METHOD(bool, SBType, operator!=,(lldb::SBType &), rhs); + + if (!IsValid()) + return rhs.IsValid(); + + if (!rhs.IsValid()) + return true; + + return *m_opaque_sp.get() != *rhs.m_opaque_sp.get(); +} + +lldb::TypeImplSP SBType::GetSP() { return m_opaque_sp; } + +void SBType::SetSP(const lldb::TypeImplSP &type_impl_sp) { + m_opaque_sp = 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; + } + return LLDB_RECORD_RESULT(*this); +} + +SBType::~SBType() = default; + +TypeImpl &SBType::ref() { + if (m_opaque_sp.get() == nullptr) + m_opaque_sp = std::make_shared<TypeImpl>(); + return *m_opaque_sp; +} + +const TypeImpl &SBType::ref() const { + // "const SBAddress &addr" should already have checked "addr.IsValid()" prior + // to calling this function. In case you didn't we will assert and die to let + // you know. + assert(m_opaque_sp.get()); + return *m_opaque_sp; +} + +bool SBType::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBType, IsValid); + return this->operator bool(); +} +SBType::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBType, operator bool); + + if (m_opaque_sp.get() == nullptr) + return false; + + return m_opaque_sp->IsValid(); +} + +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)) + return *size; + return 0; +} + +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, + nullptr); +} + +bool SBType::IsVectorType() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsVectorType); + + if (!IsValid()) + return false; + return m_opaque_sp->GetCompilerType(true).IsVectorType(nullptr, nullptr); +} + +bool SBType::IsReferenceType() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsReferenceType); + + if (!IsValid()) + return false; + return m_opaque_sp->GetCompilerType(true).IsReferenceType(); +} + +SBType SBType::GetPointerType() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetPointerType); + + if (!IsValid()) + return 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 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 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 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 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 LLDB_RECORD_RESULT(SBType()); + CompilerType canonical_type = + m_opaque_sp->GetCompilerType(true).GetCanonicalType(); + return LLDB_RECORD_RESULT( + SBType(TypeImplSP(new TypeImpl(canonical_type.GetArrayElementType())))); +} + +SBType SBType::GetArrayType(uint64_t size) { + LLDB_RECORD_METHOD(lldb::SBType, SBType, GetArrayType, (uint64_t), size); + + if (!IsValid()) + 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; + if (m_opaque_sp->GetCompilerType(true).IsVectorType(&vector_element_type, + nullptr)) + type_sb.SetSP(TypeImplSP(new TypeImpl(vector_element_type))); + } + 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 LLDB_RECORD_RESULT(SBType(return_type)); + } + 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)); + size_t count = func_type.GetNumberOfFunctionArguments(); + for (size_t i = 0; i < count; i++) { + sb_type_list.Append(SBType(func_type.GetFunctionArgumentAtIndex(i))); + } + } + 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(); + } + return 0; +} + +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 LLDB_RECORD_RESULT(sb_func_type); +} + +lldb::SBType SBType::GetUnqualifiedType() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetUnqualifiedType); + + if (!IsValid()) + 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 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 LLDB_RECORD_RESULT(SBType( + m_opaque_sp->GetTypeSystem(false)->GetBasicTypeFromAST(basic_type))); + return LLDB_RECORD_RESULT(SBType()); +} + +uint32_t SBType::GetNumberOfDirectBaseClasses() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfDirectBaseClasses); + + if (IsValid()) + return m_opaque_sp->GetCompilerType(true).GetNumDirectBaseClasses(); + return 0; +} + +uint32_t SBType::GetNumberOfVirtualBaseClasses() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfVirtualBaseClasses); + + if (IsValid()) + return m_opaque_sp->GetCompilerType(true).GetNumVirtualBaseClasses(); + return 0; +} + +uint32_t SBType::GetNumberOfFields() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfFields); + + if (IsValid()) + return m_opaque_sp->GetCompilerType(true).GetNumFields(); + return 0; +} + +bool SBType::GetDescription(SBStream &description, + lldb::DescriptionLevel description_level) { + LLDB_RECORD_METHOD(bool, SBType, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel), description, + description_level); + + Stream &strm = description.ref(); + + if (m_opaque_sp) { + m_opaque_sp->GetDescription(strm, description_level); + } else + strm.PutCString("No value"); + + return true; +} + +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; + CompilerType base_class_type = + m_opaque_sp->GetCompilerType(true).GetDirectBaseClassAtIndex( + idx, &bit_offset); + if (base_class_type.IsValid()) + sb_type_member.reset(new TypeMemberImpl( + TypeImplSP(new TypeImpl(base_class_type)), bit_offset)); + } + 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; + CompilerType base_class_type = + m_opaque_sp->GetCompilerType(true).GetVirtualBaseClassAtIndex( + idx, &bit_offset); + if (base_class_type.IsValid()) + sb_type_member.reset(new TypeMemberImpl( + TypeImplSP(new TypeImpl(base_class_type)), bit_offset)); + } + 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)); + if (this_type.IsValid()) { + this_type.ForEachEnumerator([&sb_enum_member_list]( + const CompilerType &integer_type, + ConstString name, + const llvm::APSInt &value) -> bool { + SBTypeEnumMember enum_member( + lldb::TypeEnumMemberImplSP(new TypeEnumMemberImpl( + lldb::TypeImplSP(new TypeImpl(integer_type)), name, value))); + sb_enum_member_list.Append(enum_member); + return true; // Keep iterating + }); + } + } + 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)); + if (this_type.IsValid()) { + uint64_t bit_offset = 0; + uint32_t bitfield_bit_size = 0; + bool is_bitfield = false; + std::string name_sstr; + CompilerType field_type(this_type.GetFieldAtIndex( + idx, name_sstr, &bit_offset, &bitfield_bit_size, &is_bitfield)); + if (field_type.IsValid()) { + ConstString name; + if (!name_sstr.empty()) + name.SetCString(name_sstr.c_str()); + sb_type_member.reset( + new TypeMemberImpl(TypeImplSP(new TypeImpl(field_type)), bit_offset, + name, bitfield_bit_size, is_bitfield)); + } + } + } + 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 LLDB_RECORD_RESULT(SBType()); + + CompilerType type; + switch(GetTemplateArgumentKind(idx)) { + case eTemplateArgumentKindType: + type = m_opaque_sp->GetCompilerType(false).GetTypeTemplateArgument(idx); + break; + case eTemplateArgumentKindIntegral: + type = m_opaque_sp->GetCompilerType(false) + .GetIntegralTemplateArgument(idx) + ->type; + break; + default: + break; + } + if (type.IsValid()) + 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()) { + 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() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeList, IsValid); + return this->operator bool(); +} +SBTypeList::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeList, operator bool); + + return (m_opaque_up != nullptr); +} + +SBTypeList &SBTypeList::operator=(const SBTypeList &rhs) { + LLDB_RECORD_METHOD(lldb::SBTypeList &, + SBTypeList, operator=,(const lldb::SBTypeList &), rhs); + + if (this != &rhs) { + m_opaque_up = std::make_unique<TypeListImpl>(); + for (uint32_t i = 0, rhs_size = const_cast<SBTypeList &>(rhs).GetSize(); + i < rhs_size; i++) + Append(const_cast<SBTypeList &>(rhs).GetTypeAtIndex(i)); + } + return LLDB_RECORD_RESULT(*this); +} + +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 LLDB_RECORD_RESULT(SBType(m_opaque_up->GetTypeAtIndex(index))); + return LLDB_RECORD_RESULT(SBType()); +} + +uint32_t SBTypeList::GetSize() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeList, GetSize); + + return m_opaque_up->GetSize(); +} + +SBTypeList::~SBTypeList() = default; + +SBTypeMember::SBTypeMember() : m_opaque_up() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeMember); +} + +SBTypeMember::~SBTypeMember() = default; + +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 = std::make_unique<TypeMemberImpl>(rhs.ref()); + } +} + +lldb::SBTypeMember &SBTypeMember::operator=(const lldb::SBTypeMember &rhs) { + LLDB_RECORD_METHOD(lldb::SBTypeMember &, + SBTypeMember, operator=,(const lldb::SBTypeMember &), rhs); + + if (this != &rhs) { + if (rhs.IsValid()) + m_opaque_up = std::make_unique<TypeMemberImpl>(rhs.ref()); + } + return LLDB_RECORD_RESULT(*this); +} + +bool SBTypeMember::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMember, IsValid); + return this->operator bool(); +} +SBTypeMember::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMember, operator bool); + + 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 nullptr; +} + +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 LLDB_RECORD_RESULT(sb_type); +} + +uint64_t SBTypeMember::GetOffsetInBytes() { + LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBTypeMember, GetOffsetInBytes); + + if (m_opaque_up) + return m_opaque_up->GetBitOffset() / 8u; + return 0; +} + +uint64_t SBTypeMember::GetOffsetInBits() { + LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBTypeMember, GetOffsetInBits); + + if (m_opaque_up) + return m_opaque_up->GetBitOffset(); + return 0; +} + +bool SBTypeMember::IsBitfield() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeMember, IsBitfield); + + if (m_opaque_up) + return m_opaque_up->GetIsBitfield(); + return false; +} + +uint32_t SBTypeMember::GetBitfieldSizeInBits() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeMember, GetBitfieldSizeInBits); + + if (m_opaque_up) + return m_opaque_up->GetBitfieldBitSize(); + return 0; +} + +bool SBTypeMember::GetDescription(lldb::SBStream &description, + lldb::DescriptionLevel description_level) { + LLDB_RECORD_METHOD(bool, SBTypeMember, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel), description, + description_level); + + Stream &strm = description.ref(); + + if (m_opaque_up) { + const uint32_t bit_offset = m_opaque_up->GetBitOffset(); + const uint32_t byte_offset = bit_offset / 8u; + const uint32_t byte_bit_offset = bit_offset % 8u; + const char *name = m_opaque_up->GetName().GetCString(); + if (byte_bit_offset) + strm.Printf("+%u + %u bits: (", byte_offset, byte_bit_offset); + else + strm.Printf("+%u: (", byte_offset); + + TypeImplSP type_impl_sp(m_opaque_up->GetTypeImpl()); + if (type_impl_sp) + type_impl_sp->GetDescription(strm, description_level); + + strm.Printf(") %s", name); + if (m_opaque_up->GetIsBitfield()) { + const uint32_t bitfield_bit_size = m_opaque_up->GetBitfieldBitSize(); + strm.Printf(" : %u", bitfield_bit_size); + } + } else { + strm.PutCString("No value"); + } + return true; +} + +void SBTypeMember::reset(TypeMemberImpl *type_member_impl) { + m_opaque_up.reset(type_member_impl); +} + +TypeMemberImpl &SBTypeMember::ref() { + if (m_opaque_up == nullptr) + m_opaque_up = std::make_unique<TypeMemberImpl>(); + return *m_opaque_up; +} + +const TypeMemberImpl &SBTypeMember::ref() const { return *m_opaque_up; } + +SBTypeMemberFunction::SBTypeMemberFunction() : m_opaque_sp() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeMemberFunction); +} + +SBTypeMemberFunction::~SBTypeMemberFunction() = default; + +SBTypeMemberFunction::SBTypeMemberFunction(const SBTypeMemberFunction &rhs) + : m_opaque_sp(rhs.m_opaque_sp) { + LLDB_RECORD_CONSTRUCTOR(SBTypeMemberFunction, + (const lldb::SBTypeMemberFunction &), rhs); +} + +lldb::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 LLDB_RECORD_RESULT(*this); +} + +bool SBTypeMemberFunction::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMemberFunction, IsValid); + return this->operator bool(); +} +SBTypeMemberFunction::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMemberFunction, operator bool); + + 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 nullptr; +} + +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) { + Mangled mangled(mangled_str); + return mangled.GetDemangledName().GetCString(); + } + } + return nullptr; +} + +const char *SBTypeMemberFunction::GetMangledName() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMemberFunction, + GetMangledName); + + if (m_opaque_sp) + return m_opaque_sp->GetMangledName().GetCString(); + return nullptr; +} + +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 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 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 LLDB_RECORD_RESULT(sb_type); +} + +lldb::MemberFunctionKind SBTypeMemberFunction::GetKind() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::MemberFunctionKind, SBTypeMemberFunction, + GetKind); + + if (m_opaque_sp) + return m_opaque_sp->GetKind(); + return lldb::eMemberFunctionKindUnknown; +} + +bool SBTypeMemberFunction::GetDescription( + lldb::SBStream &description, lldb::DescriptionLevel description_level) { + LLDB_RECORD_METHOD(bool, SBTypeMemberFunction, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel), description, + description_level); + + Stream &strm = description.ref(); + + if (m_opaque_sp) + return m_opaque_sp->GetDescription(strm); + + return false; +} + +void SBTypeMemberFunction::reset(TypeMemberFunctionImpl *type_member_impl) { + m_opaque_sp.reset(type_member_impl); +} + +TypeMemberFunctionImpl &SBTypeMemberFunction::ref() { + if (!m_opaque_sp) + m_opaque_sp = std::make_shared<TypeMemberFunctionImpl>(); + return *m_opaque_sp.get(); +} + +const TypeMemberFunctionImpl &SBTypeMemberFunction::ref() const { + return *m_opaque_sp.get(); +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBType>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBType, ()); + LLDB_REGISTER_CONSTRUCTOR(SBType, (const lldb::SBType &)); + LLDB_REGISTER_METHOD(bool, SBType, operator==,(lldb::SBType &)); + LLDB_REGISTER_METHOD(bool, SBType, operator!=,(lldb::SBType &)); + LLDB_REGISTER_METHOD(lldb::SBType &, + SBType, operator=,(const lldb::SBType &)); + LLDB_REGISTER_METHOD_CONST(bool, SBType, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBType, operator bool, ()); + LLDB_REGISTER_METHOD(uint64_t, SBType, GetByteSize, ()); + LLDB_REGISTER_METHOD(bool, SBType, IsPointerType, ()); + LLDB_REGISTER_METHOD(bool, SBType, IsArrayType, ()); + LLDB_REGISTER_METHOD(bool, SBType, IsVectorType, ()); + LLDB_REGISTER_METHOD(bool, SBType, IsReferenceType, ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetPointerType, ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetPointeeType, ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetReferenceType, ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetTypedefedType, ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetDereferencedType, ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetArrayElementType, ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetArrayType, (uint64_t)); + LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetVectorElementType, ()); + LLDB_REGISTER_METHOD(bool, SBType, IsFunctionType, ()); + LLDB_REGISTER_METHOD(bool, SBType, IsPolymorphicClass, ()); + LLDB_REGISTER_METHOD(bool, SBType, IsTypedefType, ()); + LLDB_REGISTER_METHOD(bool, SBType, IsAnonymousType, ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetFunctionReturnType, ()); + LLDB_REGISTER_METHOD(lldb::SBTypeList, SBType, GetFunctionArgumentTypes, + ()); + LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfMemberFunctions, ()); + LLDB_REGISTER_METHOD(lldb::SBTypeMemberFunction, SBType, + GetMemberFunctionAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetUnqualifiedType, ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetCanonicalType, ()); + LLDB_REGISTER_METHOD(lldb::BasicType, SBType, GetBasicType, ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetBasicType, (lldb::BasicType)); + LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfDirectBaseClasses, ()); + LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfVirtualBaseClasses, ()); + LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfFields, ()); + LLDB_REGISTER_METHOD(bool, SBType, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel)); + LLDB_REGISTER_METHOD(lldb::SBTypeMember, SBType, GetDirectBaseClassAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBTypeMember, SBType, GetVirtualBaseClassAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBTypeEnumMemberList, SBType, GetEnumMembers, + ()); + LLDB_REGISTER_METHOD(lldb::SBTypeMember, SBType, GetFieldAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD(bool, SBType, IsTypeComplete, ()); + LLDB_REGISTER_METHOD(uint32_t, SBType, GetTypeFlags, ()); + LLDB_REGISTER_METHOD(const char *, SBType, GetName, ()); + LLDB_REGISTER_METHOD(const char *, SBType, GetDisplayTypeName, ()); + LLDB_REGISTER_METHOD(lldb::TypeClass, SBType, GetTypeClass, ()); + LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfTemplateArguments, ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetTemplateArgumentType, + (uint32_t)); + LLDB_REGISTER_METHOD(lldb::TemplateArgumentKind, SBType, + GetTemplateArgumentKind, (uint32_t)); + LLDB_REGISTER_CONSTRUCTOR(SBTypeList, ()); + LLDB_REGISTER_CONSTRUCTOR(SBTypeList, (const lldb::SBTypeList &)); + LLDB_REGISTER_METHOD(bool, SBTypeList, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBTypeList, operator bool, ()); + LLDB_REGISTER_METHOD(lldb::SBTypeList &, + SBTypeList, operator=,(const lldb::SBTypeList &)); + LLDB_REGISTER_METHOD(void, SBTypeList, Append, (lldb::SBType)); + LLDB_REGISTER_METHOD(lldb::SBType, SBTypeList, GetTypeAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(uint32_t, SBTypeList, GetSize, ()); + LLDB_REGISTER_CONSTRUCTOR(SBTypeMember, ()); + LLDB_REGISTER_CONSTRUCTOR(SBTypeMember, (const lldb::SBTypeMember &)); + LLDB_REGISTER_METHOD(lldb::SBTypeMember &, + SBTypeMember, operator=,(const lldb::SBTypeMember &)); + LLDB_REGISTER_METHOD_CONST(bool, SBTypeMember, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBTypeMember, operator bool, ()); + LLDB_REGISTER_METHOD(const char *, SBTypeMember, GetName, ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMember, GetType, ()); + LLDB_REGISTER_METHOD(uint64_t, SBTypeMember, GetOffsetInBytes, ()); + LLDB_REGISTER_METHOD(uint64_t, SBTypeMember, GetOffsetInBits, ()); + LLDB_REGISTER_METHOD(bool, SBTypeMember, IsBitfield, ()); + LLDB_REGISTER_METHOD(uint32_t, SBTypeMember, GetBitfieldSizeInBits, ()); + LLDB_REGISTER_METHOD(bool, SBTypeMember, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel)); + LLDB_REGISTER_CONSTRUCTOR(SBTypeMemberFunction, ()); + LLDB_REGISTER_CONSTRUCTOR(SBTypeMemberFunction, + (const lldb::SBTypeMemberFunction &)); + LLDB_REGISTER_METHOD( + lldb::SBTypeMemberFunction &, + SBTypeMemberFunction, operator=,(const lldb::SBTypeMemberFunction &)); + LLDB_REGISTER_METHOD_CONST(bool, SBTypeMemberFunction, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBTypeMemberFunction, operator bool, ()); + LLDB_REGISTER_METHOD(const char *, SBTypeMemberFunction, GetName, ()); + LLDB_REGISTER_METHOD(const char *, SBTypeMemberFunction, GetDemangledName, + ()); + LLDB_REGISTER_METHOD(const char *, SBTypeMemberFunction, GetMangledName, + ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMemberFunction, GetType, ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMemberFunction, GetReturnType, ()); + LLDB_REGISTER_METHOD(uint32_t, SBTypeMemberFunction, GetNumberOfArguments, + ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMemberFunction, + GetArgumentTypeAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(lldb::MemberFunctionKind, SBTypeMemberFunction, + GetKind, ()); + LLDB_REGISTER_METHOD(bool, SBTypeMemberFunction, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBTypeCategory.cpp b/contrib/llvm-project/lldb/source/API/SBTypeCategory.cpp new file mode 100644 index 000000000000..9ce1a57ec4f7 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBTypeCategory.cpp @@ -0,0 +1,736 @@ +//===-- SBTypeCategory.cpp ------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBTypeCategory.h" +#include "SBReproducerPrivate.h" + +#include "lldb/API/SBStream.h" +#include "lldb/API/SBTypeFilter.h" +#include "lldb/API/SBTypeFormat.h" +#include "lldb/API/SBTypeNameSpecifier.h" +#include "lldb/API/SBTypeSummary.h" +#include "lldb/API/SBTypeSynthetic.h" + +#include "lldb/Core/Debugger.h" +#include "lldb/DataFormatters/DataVisualization.h" +#include "lldb/Interpreter/CommandInterpreter.h" +#include "lldb/Interpreter/ScriptInterpreter.h" + +using namespace lldb; +using namespace lldb_private; + +typedef std::pair<lldb::TypeCategoryImplSP, user_id_t> ImplType; + +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) { + LLDB_RECORD_CONSTRUCTOR(SBTypeCategory, (const lldb::SBTypeCategory &), rhs); +} + +SBTypeCategory::~SBTypeCategory() = default; + +bool SBTypeCategory::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeCategory, IsValid); + return this->operator bool(); +} +SBTypeCategory::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeCategory, operator bool); + + return (m_opaque_sp.get() != nullptr); +} + +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) + DataVisualization::Categories::Enable(m_opaque_sp); + else + DataVisualization::Categories::Disable(m_opaque_sp); +} + +const char *SBTypeCategory::GetName() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeCategory, GetName); + + if (!IsValid()) + return nullptr; + 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; + + return m_opaque_sp->GetTypeFormatsContainer()->GetCount() + + m_opaque_sp->GetRegexTypeFormatsContainer()->GetCount(); +} + +uint32_t SBTypeCategory::GetNumSummaries() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumSummaries); + + if (!IsValid()) + return 0; + return m_opaque_sp->GetTypeSummariesContainer()->GetCount() + + m_opaque_sp->GetRegexTypeSummariesContainer()->GetCount(); +} + +uint32_t SBTypeCategory::GetNumFilters() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumFilters); + + if (!IsValid()) + return 0; + return m_opaque_sp->GetTypeFiltersContainer()->GetCount() + + m_opaque_sp->GetRegexTypeFiltersContainer()->GetCount(); +} + +uint32_t SBTypeCategory::GetNumSynthetics() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumSynthetics); + + if (!IsValid()) + return 0; + return m_opaque_sp->GetTypeSyntheticsContainer()->GetCount() + + m_opaque_sp->GetRegexTypeSyntheticsContainer()->GetCount(); +} + +lldb::SBTypeNameSpecifier +SBTypeCategory::GetTypeNameSpecifierForFilterAtIndex(uint32_t index) { + LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory, + GetTypeNameSpecifierForFilterAtIndex, (uint32_t), index); + + if (!IsValid()) + 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 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 LLDB_RECORD_RESULT(SBTypeNameSpecifier()); + return LLDB_RECORD_RESULT(SBTypeNameSpecifier( + m_opaque_sp->GetTypeNameSpecifierForSummaryAtIndex(index))); +} + +lldb::SBTypeNameSpecifier +SBTypeCategory::GetTypeNameSpecifierForSyntheticAtIndex(uint32_t index) { + LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory, + GetTypeNameSpecifierForSyntheticAtIndex, (uint32_t), + index); + + if (!IsValid()) + return LLDB_RECORD_RESULT(SBTypeNameSpecifier()); + return LLDB_RECORD_RESULT(SBTypeNameSpecifier( + m_opaque_sp->GetTypeNameSpecifierForSyntheticAtIndex(index))); +} + +SBTypeFilter SBTypeCategory::GetFilterForType(SBTypeNameSpecifier spec) { + LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterForType, + (lldb::SBTypeNameSpecifier), spec); + + if (!IsValid()) + return LLDB_RECORD_RESULT(SBTypeFilter()); + + if (!spec.IsValid()) + return LLDB_RECORD_RESULT(SBTypeFilter()); + + lldb::TypeFilterImplSP children_sp; + + if (spec.IsRegex()) + m_opaque_sp->GetRegexTypeFiltersContainer()->GetExact( + ConstString(spec.GetName()), children_sp); + else + m_opaque_sp->GetTypeFiltersContainer()->GetExact( + ConstString(spec.GetName()), children_sp); + + if (!children_sp) + return LLDB_RECORD_RESULT(lldb::SBTypeFilter()); + + TypeFilterImplSP filter_sp = + std::static_pointer_cast<TypeFilterImpl>(children_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 LLDB_RECORD_RESULT(SBTypeFormat()); + + if (!spec.IsValid()) + return LLDB_RECORD_RESULT(SBTypeFormat()); + + lldb::TypeFormatImplSP format_sp; + + if (spec.IsRegex()) + m_opaque_sp->GetRegexTypeFormatsContainer()->GetExact( + ConstString(spec.GetName()), format_sp); + else + m_opaque_sp->GetTypeFormatsContainer()->GetExact( + ConstString(spec.GetName()), format_sp); + + if (!format_sp) + return LLDB_RECORD_RESULT(lldb::SBTypeFormat()); + + return LLDB_RECORD_RESULT(lldb::SBTypeFormat(format_sp)); +} + +SBTypeSummary SBTypeCategory::GetSummaryForType(SBTypeNameSpecifier spec) { + LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryForType, + (lldb::SBTypeNameSpecifier), spec); + + if (!IsValid()) + return LLDB_RECORD_RESULT(SBTypeSummary()); + + if (!spec.IsValid()) + return LLDB_RECORD_RESULT(SBTypeSummary()); + + lldb::TypeSummaryImplSP summary_sp; + + if (spec.IsRegex()) + m_opaque_sp->GetRegexTypeSummariesContainer()->GetExact( + ConstString(spec.GetName()), summary_sp); + else + m_opaque_sp->GetTypeSummariesContainer()->GetExact( + ConstString(spec.GetName()), summary_sp); + + if (!summary_sp) + return LLDB_RECORD_RESULT(lldb::SBTypeSummary()); + + return LLDB_RECORD_RESULT(lldb::SBTypeSummary(summary_sp)); +} + +SBTypeSynthetic SBTypeCategory::GetSyntheticForType(SBTypeNameSpecifier spec) { + LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBTypeCategory, GetSyntheticForType, + (lldb::SBTypeNameSpecifier), spec); + + if (!IsValid()) + return LLDB_RECORD_RESULT(SBTypeSynthetic()); + + if (!spec.IsValid()) + return LLDB_RECORD_RESULT(SBTypeSynthetic()); + + lldb::SyntheticChildrenSP children_sp; + + if (spec.IsRegex()) + m_opaque_sp->GetRegexTypeSyntheticsContainer()->GetExact( + ConstString(spec.GetName()), children_sp); + else + m_opaque_sp->GetTypeSyntheticsContainer()->GetExact( + ConstString(spec.GetName()), children_sp); + + if (!children_sp) + return LLDB_RECORD_RESULT(lldb::SBTypeSynthetic()); + + ScriptedSyntheticChildrenSP synth_sp = + std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp); + + return LLDB_RECORD_RESULT(lldb::SBTypeSynthetic(synth_sp)); +} + +SBTypeFilter SBTypeCategory::GetFilterAtIndex(uint32_t index) { + LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterAtIndex, + (uint32_t), index); + + if (!IsValid()) + return LLDB_RECORD_RESULT(SBTypeFilter()); + lldb::SyntheticChildrenSP children_sp = + m_opaque_sp->GetSyntheticAtIndex((index)); + + if (!children_sp.get()) + return LLDB_RECORD_RESULT(lldb::SBTypeFilter()); + + TypeFilterImplSP filter_sp = + std::static_pointer_cast<TypeFilterImpl>(children_sp); + + return LLDB_RECORD_RESULT(lldb::SBTypeFilter(filter_sp)); +} + +SBTypeFormat SBTypeCategory::GetFormatAtIndex(uint32_t index) { + LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatAtIndex, + (uint32_t), index); + + if (!IsValid()) + return LLDB_RECORD_RESULT(SBTypeFormat()); + return LLDB_RECORD_RESULT( + SBTypeFormat(m_opaque_sp->GetFormatAtIndex((index)))); +} + +SBTypeSummary SBTypeCategory::GetSummaryAtIndex(uint32_t index) { + LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryAtIndex, + (uint32_t), index); + + if (!IsValid()) + return LLDB_RECORD_RESULT(SBTypeSummary()); + return LLDB_RECORD_RESULT( + SBTypeSummary(m_opaque_sp->GetSummaryAtIndex((index)))); +} + +SBTypeSynthetic SBTypeCategory::GetSyntheticAtIndex(uint32_t index) { + LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBTypeCategory, GetSyntheticAtIndex, + (uint32_t), index); + + if (!IsValid()) + return LLDB_RECORD_RESULT(SBTypeSynthetic()); + lldb::SyntheticChildrenSP children_sp = + m_opaque_sp->GetSyntheticAtIndex((index)); + + if (!children_sp.get()) + return LLDB_RECORD_RESULT(lldb::SBTypeSynthetic()); + + ScriptedSyntheticChildrenSP synth_sp = + std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp); + + return LLDB_RECORD_RESULT(lldb::SBTypeSynthetic(synth_sp)); +} + +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; + + if (!type_name.IsValid()) + return false; + + if (!format.IsValid()) + return false; + + if (type_name.IsRegex()) + m_opaque_sp->GetRegexTypeFormatsContainer()->Add( + RegularExpression( + llvm::StringRef::withNullAsEmpty(type_name.GetName())), + format.GetSP()); + else + m_opaque_sp->GetTypeFormatsContainer()->Add( + ConstString(type_name.GetName()), format.GetSP()); + + return true; +} + +bool SBTypeCategory::DeleteTypeFormat(SBTypeNameSpecifier type_name) { + LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeFormat, + (lldb::SBTypeNameSpecifier), type_name); + + if (!IsValid()) + return false; + + if (!type_name.IsValid()) + return false; + + if (type_name.IsRegex()) + return m_opaque_sp->GetRegexTypeFormatsContainer()->Delete( + ConstString(type_name.GetName())); + else + return m_opaque_sp->GetTypeFormatsContainer()->Delete( + ConstString(type_name.GetName())); +} + +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; + + if (!type_name.IsValid()) + return false; + + if (!summary.IsValid()) + return false; + + // FIXME: we need to iterate over all the Debugger objects and have each of + // them contain a copy of the function + // since we currently have formatters live in a global space, while Python + // code lives in a specific Debugger-related environment this should + // eventually be fixed by deciding a final location in the LLDB object space + // for formatters + if (summary.IsFunctionCode()) { + const void *name_token = + (const void *)ConstString(type_name.GetName()).GetCString(); + const char *script = summary.GetData(); + StringList input; + input.SplitIntoLines(script, strlen(script)); + uint32_t num_debuggers = lldb_private::Debugger::GetNumDebuggers(); + bool need_set = true; + for (uint32_t j = 0; j < num_debuggers; j++) { + DebuggerSP debugger_sp = lldb_private::Debugger::GetDebuggerAtIndex(j); + if (debugger_sp) { + ScriptInterpreter *interpreter_ptr = + debugger_sp->GetScriptInterpreter(); + if (interpreter_ptr) { + std::string output; + if (interpreter_ptr->GenerateTypeScriptFunction(input, output, + name_token) && + !output.empty()) { + if (need_set) { + need_set = false; + summary.SetFunctionName(output.c_str()); + } + } + } + } + } + } + + if (type_name.IsRegex()) + m_opaque_sp->GetRegexTypeSummariesContainer()->Add( + RegularExpression( + llvm::StringRef::withNullAsEmpty(type_name.GetName())), + summary.GetSP()); + else + m_opaque_sp->GetTypeSummariesContainer()->Add( + ConstString(type_name.GetName()), summary.GetSP()); + + return true; +} + +bool SBTypeCategory::DeleteTypeSummary(SBTypeNameSpecifier type_name) { + LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeSummary, + (lldb::SBTypeNameSpecifier), type_name); + + if (!IsValid()) + return false; + + if (!type_name.IsValid()) + return false; + + if (type_name.IsRegex()) + return m_opaque_sp->GetRegexTypeSummariesContainer()->Delete( + ConstString(type_name.GetName())); + else + return m_opaque_sp->GetTypeSummariesContainer()->Delete( + ConstString(type_name.GetName())); +} + +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; + + if (!type_name.IsValid()) + return false; + + if (!filter.IsValid()) + return false; + + if (type_name.IsRegex()) + m_opaque_sp->GetRegexTypeFiltersContainer()->Add( + RegularExpression( + llvm::StringRef::withNullAsEmpty(type_name.GetName())), + filter.GetSP()); + else + m_opaque_sp->GetTypeFiltersContainer()->Add( + ConstString(type_name.GetName()), filter.GetSP()); + + return true; +} + +bool SBTypeCategory::DeleteTypeFilter(SBTypeNameSpecifier type_name) { + LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeFilter, + (lldb::SBTypeNameSpecifier), type_name); + + if (!IsValid()) + return false; + + if (!type_name.IsValid()) + return false; + + if (type_name.IsRegex()) + return m_opaque_sp->GetRegexTypeFiltersContainer()->Delete( + ConstString(type_name.GetName())); + else + return m_opaque_sp->GetTypeFiltersContainer()->Delete( + ConstString(type_name.GetName())); +} + +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; + + if (!type_name.IsValid()) + return false; + + if (!synth.IsValid()) + return false; + + // FIXME: we need to iterate over all the Debugger objects and have each of + // them contain a copy of the function + // since we currently have formatters live in a global space, while Python + // code lives in a specific Debugger-related environment this should + // eventually be fixed by deciding a final location in the LLDB object space + // for formatters + if (synth.IsClassCode()) { + const void *name_token = + (const void *)ConstString(type_name.GetName()).GetCString(); + const char *script = synth.GetData(); + StringList input; + input.SplitIntoLines(script, strlen(script)); + uint32_t num_debuggers = lldb_private::Debugger::GetNumDebuggers(); + bool need_set = true; + for (uint32_t j = 0; j < num_debuggers; j++) { + DebuggerSP debugger_sp = lldb_private::Debugger::GetDebuggerAtIndex(j); + if (debugger_sp) { + ScriptInterpreter *interpreter_ptr = + debugger_sp->GetScriptInterpreter(); + if (interpreter_ptr) { + std::string output; + if (interpreter_ptr->GenerateTypeSynthClass(input, output, + name_token) && + !output.empty()) { + if (need_set) { + need_set = false; + synth.SetClassName(output.c_str()); + } + } + } + } + } + } + + if (type_name.IsRegex()) + m_opaque_sp->GetRegexTypeSyntheticsContainer()->Add( + RegularExpression( + llvm::StringRef::withNullAsEmpty(type_name.GetName())), + synth.GetSP()); + else + m_opaque_sp->GetTypeSyntheticsContainer()->Add( + ConstString(type_name.GetName()), synth.GetSP()); + + return true; +} + +bool SBTypeCategory::DeleteTypeSynthetic(SBTypeNameSpecifier type_name) { + LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeSynthetic, + (lldb::SBTypeNameSpecifier), type_name); + + if (!IsValid()) + return false; + + if (!type_name.IsValid()) + return false; + + if (type_name.IsRegex()) + return m_opaque_sp->GetRegexTypeSyntheticsContainer()->Delete( + ConstString(type_name.GetName())); + else + return m_opaque_sp->GetTypeSyntheticsContainer()->Delete( + ConstString(type_name.GetName())); +} + +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()); + return true; +} + +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; + } + return LLDB_RECORD_RESULT(*this); +} + +bool SBTypeCategory::operator==(lldb::SBTypeCategory &rhs) { + LLDB_RECORD_METHOD(bool, SBTypeCategory, operator==,(lldb::SBTypeCategory &), + rhs); + + if (!IsValid()) + return !rhs.IsValid(); + + return m_opaque_sp.get() == rhs.m_opaque_sp.get(); +} + +bool SBTypeCategory::operator!=(lldb::SBTypeCategory &rhs) { + LLDB_RECORD_METHOD(bool, SBTypeCategory, operator!=,(lldb::SBTypeCategory &), + rhs); + + if (!IsValid()) + return rhs.IsValid(); + + return m_opaque_sp.get() != rhs.m_opaque_sp.get(); +} + +lldb::TypeCategoryImplSP SBTypeCategory::GetSP() { + if (!IsValid()) + return lldb::TypeCategoryImplSP(); + return m_opaque_sp; +} + +void SBTypeCategory::SetSP( + const lldb::TypeCategoryImplSP &typecategory_impl_sp) { + m_opaque_sp = typecategory_impl_sp; +} + +SBTypeCategory::SBTypeCategory( + const lldb::TypeCategoryImplSP &typecategory_impl_sp) + : m_opaque_sp(typecategory_impl_sp) {} + +bool SBTypeCategory::IsDefaultCategory() { + if (!IsValid()) + return false; + + return (strcmp(m_opaque_sp->GetName(), "default") == 0); +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBTypeCategory>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBTypeCategory, ()); + LLDB_REGISTER_CONSTRUCTOR(SBTypeCategory, (const lldb::SBTypeCategory &)); + LLDB_REGISTER_METHOD_CONST(bool, SBTypeCategory, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBTypeCategory, operator bool, ()); + LLDB_REGISTER_METHOD(bool, SBTypeCategory, GetEnabled, ()); + LLDB_REGISTER_METHOD(void, SBTypeCategory, SetEnabled, (bool)); + LLDB_REGISTER_METHOD(const char *, SBTypeCategory, GetName, ()); + LLDB_REGISTER_METHOD(lldb::LanguageType, SBTypeCategory, GetLanguageAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumLanguages, ()); + LLDB_REGISTER_METHOD(void, SBTypeCategory, AddLanguage, + (lldb::LanguageType)); + LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumFormats, ()); + LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumSummaries, ()); + LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumFilters, ()); + LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumSynthetics, ()); + LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory, + GetTypeNameSpecifierForSyntheticAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryForType, + (lldb::SBTypeNameSpecifier)); + LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBTypeCategory, + GetSyntheticForType, (lldb::SBTypeNameSpecifier)); + LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBTypeCategory, + GetSyntheticAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeSummary, + (lldb::SBTypeNameSpecifier, lldb::SBTypeSummary)); + LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeSynthetic, + (lldb::SBTypeNameSpecifier, lldb::SBTypeSynthetic)); + LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeSynthetic, + (lldb::SBTypeNameSpecifier)); + LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory, + GetTypeNameSpecifierForFilterAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory, + GetTypeNameSpecifierForFormatAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory, + GetTypeNameSpecifierForSummaryAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterForType, + (lldb::SBTypeNameSpecifier)); + LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatForType, + (lldb::SBTypeNameSpecifier)); + LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeFormat, + (lldb::SBTypeNameSpecifier, lldb::SBTypeFormat)); + LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeFormat, + (lldb::SBTypeNameSpecifier)); + LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeSummary, + (lldb::SBTypeNameSpecifier)); + LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeFilter, + (lldb::SBTypeNameSpecifier, lldb::SBTypeFilter)); + LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeFilter, + (lldb::SBTypeNameSpecifier)); + LLDB_REGISTER_METHOD(bool, SBTypeCategory, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel)); + LLDB_REGISTER_METHOD( + lldb::SBTypeCategory &, + SBTypeCategory, operator=,(const lldb::SBTypeCategory &)); + LLDB_REGISTER_METHOD(bool, + SBTypeCategory, operator==,(lldb::SBTypeCategory &)); + LLDB_REGISTER_METHOD(bool, + SBTypeCategory, operator!=,(lldb::SBTypeCategory &)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBTypeEnumMember.cpp b/contrib/llvm-project/lldb/source/API/SBTypeEnumMember.cpp new file mode 100644 index 000000000000..43a4891b54b1 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBTypeEnumMember.cpp @@ -0,0 +1,235 @@ +//===-- SBTypeEnumMember.cpp ----------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBTypeEnumMember.h" +#include "SBReproducerPrivate.h" +#include "Utils.h" +#include "lldb/API/SBDefines.h" +#include "lldb/API/SBStream.h" +#include "lldb/API/SBType.h" +#include "lldb/Symbol/CompilerType.h" +#include "lldb/Symbol/Type.h" +#include "lldb/Utility/Stream.h" + +#include <memory> + +using namespace lldb; +using namespace lldb_private; + +SBTypeEnumMember::SBTypeEnumMember() : m_opaque_sp() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeEnumMember); +} + +SBTypeEnumMember::~SBTypeEnumMember() = default; + +SBTypeEnumMember::SBTypeEnumMember( + const lldb::TypeEnumMemberImplSP &enum_member_sp) + : m_opaque_sp(enum_member_sp) {} + +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_METHOD( + SBTypeEnumMember &, + SBTypeEnumMember, operator=,(const lldb::SBTypeEnumMember &), rhs); + + if (this != &rhs) + m_opaque_sp = clone(rhs.m_opaque_sp); + return LLDB_RECORD_RESULT(*this); +} + +bool SBTypeEnumMember::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMember, IsValid); + return this->operator bool(); +} +SBTypeEnumMember::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMember, operator bool); + + 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 nullptr; +} + +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 LLDB_RECORD_RESULT(sb_type); +} + +void SBTypeEnumMember::reset(TypeEnumMemberImpl *type_member_impl) { + m_opaque_sp.reset(type_member_impl); +} + +TypeEnumMemberImpl &SBTypeEnumMember::ref() { + if (m_opaque_sp.get() == nullptr) + m_opaque_sp = std::make_shared<TypeEnumMemberImpl>(); + return *m_opaque_sp.get(); +} + +const TypeEnumMemberImpl &SBTypeEnumMember::ref() const { + return *m_opaque_sp.get(); +} + +SBTypeEnumMemberList::SBTypeEnumMemberList() + : 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() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeEnumMemberList, IsValid); + return this->operator bool(); +} +SBTypeEnumMemberList::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMemberList, operator bool); + + return (m_opaque_up != nullptr); +} + +SBTypeEnumMemberList &SBTypeEnumMemberList:: +operator=(const SBTypeEnumMemberList &rhs) { + LLDB_RECORD_METHOD( + lldb::SBTypeEnumMemberList &, + SBTypeEnumMemberList, operator=,(const lldb::SBTypeEnumMemberList &), + rhs); + + if (this != &rhs) { + m_opaque_up = std::make_unique<TypeEnumMemberListImpl>(); + for (uint32_t i = 0, + rhs_size = const_cast<SBTypeEnumMemberList &>(rhs).GetSize(); + i < rhs_size; i++) + Append( + const_cast<SBTypeEnumMemberList &>(rhs).GetTypeEnumMemberAtIndex(i)); + } + return LLDB_RECORD_RESULT(*this); +} + +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 LLDB_RECORD_RESULT( + SBTypeEnumMember(m_opaque_up->GetTypeEnumMemberAtIndex(index))); + return LLDB_RECORD_RESULT(SBTypeEnumMember()); +} + +uint32_t SBTypeEnumMemberList::GetSize() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeEnumMemberList, GetSize); + + return m_opaque_up->GetSize(); +} + +SBTypeEnumMemberList::~SBTypeEnumMemberList() = default; + +bool SBTypeEnumMember::GetDescription( + lldb::SBStream &description, lldb::DescriptionLevel description_level) { + LLDB_RECORD_METHOD(bool, SBTypeEnumMember, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel), description, + description_level); + + Stream &strm = description.ref(); + + if (m_opaque_sp.get()) { + if (m_opaque_sp->GetIntegerType()->GetDescription(strm, + description_level)) { + strm.Printf(" %s", m_opaque_sp->GetName().GetCString()); + } + } else { + strm.PutCString("No value"); + } + return true; +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBTypeEnumMember>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMember, ()); + LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMember, + (const lldb::SBTypeEnumMember &)); + LLDB_REGISTER_METHOD( + lldb::SBTypeEnumMember &, + SBTypeEnumMember, operator=,(const lldb::SBTypeEnumMember &)); + LLDB_REGISTER_METHOD_CONST(bool, SBTypeEnumMember, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBTypeEnumMember, operator bool, ()); + LLDB_REGISTER_METHOD(const char *, SBTypeEnumMember, GetName, ()); + LLDB_REGISTER_METHOD(int64_t, SBTypeEnumMember, GetValueAsSigned, ()); + LLDB_REGISTER_METHOD(uint64_t, SBTypeEnumMember, GetValueAsUnsigned, ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBTypeEnumMember, GetType, ()); + LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMemberList, ()); + LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMemberList, + (const lldb::SBTypeEnumMemberList &)); + LLDB_REGISTER_METHOD(bool, SBTypeEnumMemberList, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBTypeEnumMemberList, operator bool, ()); + LLDB_REGISTER_METHOD( + lldb::SBTypeEnumMemberList &, + SBTypeEnumMemberList, operator=,(const lldb::SBTypeEnumMemberList &)); + LLDB_REGISTER_METHOD(void, SBTypeEnumMemberList, Append, + (lldb::SBTypeEnumMember)); + LLDB_REGISTER_METHOD(lldb::SBTypeEnumMember, SBTypeEnumMemberList, + GetTypeEnumMemberAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(uint32_t, SBTypeEnumMemberList, GetSize, ()); + LLDB_REGISTER_METHOD(bool, SBTypeEnumMember, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBTypeFilter.cpp b/contrib/llvm-project/lldb/source/API/SBTypeFilter.cpp new file mode 100644 index 000000000000..5f91a194f16b --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBTypeFilter.cpp @@ -0,0 +1,225 @@ +//===-- SBTypeFilter.cpp --------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBTypeFilter.h" +#include "SBReproducerPrivate.h" + +#include "lldb/API/SBStream.h" + +#include "lldb/DataFormatters/DataVisualization.h" + +using namespace lldb; +using namespace lldb_private; + +SBTypeFilter::SBTypeFilter() : m_opaque_sp() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeFilter); +} + +SBTypeFilter::SBTypeFilter(uint32_t 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) { + LLDB_RECORD_CONSTRUCTOR(SBTypeFilter, (const lldb::SBTypeFilter &), rhs); +} + +SBTypeFilter::~SBTypeFilter() = default; + +bool SBTypeFilter::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFilter, IsValid); + return this->operator bool(); +} +SBTypeFilter::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFilter, operator bool); + + return m_opaque_sp.get() != nullptr; +} + +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 { + description.Printf("%s\n", m_opaque_sp->GetDescription().c_str()); + return true; + } +} + +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 == '.') + item++; + return item; + } + return nullptr; +} + +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 + return false; +} + +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; + } + return LLDB_RECORD_RESULT(*this); +} + +bool SBTypeFilter::operator==(lldb::SBTypeFilter &rhs) { + LLDB_RECORD_METHOD(bool, SBTypeFilter, operator==,(lldb::SBTypeFilter &), + rhs); + + if (!IsValid()) + return !rhs.IsValid(); + + return m_opaque_sp == rhs.m_opaque_sp; +} + +bool SBTypeFilter::IsEqualTo(lldb::SBTypeFilter &rhs) { + LLDB_RECORD_METHOD(bool, SBTypeFilter, IsEqualTo, (lldb::SBTypeFilter &), + rhs); + + if (!IsValid()) + return !rhs.IsValid(); + + if (GetNumberOfExpressionPaths() != rhs.GetNumberOfExpressionPaths()) + return false; + + for (uint32_t j = 0; j < GetNumberOfExpressionPaths(); j++) + if (strcmp(GetExpressionPathAtIndex(j), rhs.GetExpressionPathAtIndex(j)) != + 0) + return false; + + return GetOptions() == rhs.GetOptions(); +} + +bool SBTypeFilter::operator!=(lldb::SBTypeFilter &rhs) { + LLDB_RECORD_METHOD(bool, SBTypeFilter, operator!=,(lldb::SBTypeFilter &), + rhs); + + if (!IsValid()) + return !rhs.IsValid(); + + return m_opaque_sp != rhs.m_opaque_sp; +} + +lldb::TypeFilterImplSP SBTypeFilter::GetSP() { return m_opaque_sp; } + +void SBTypeFilter::SetSP(const lldb::TypeFilterImplSP &typefilter_impl_sp) { + m_opaque_sp = typefilter_impl_sp; +} + +SBTypeFilter::SBTypeFilter(const lldb::TypeFilterImplSP &typefilter_impl_sp) + : m_opaque_sp(typefilter_impl_sp) {} + +bool SBTypeFilter::CopyOnWrite_Impl() { + if (!IsValid()) + return false; + if (m_opaque_sp.unique()) + return true; + + TypeFilterImplSP new_sp(new TypeFilterImpl(GetOptions())); + + for (uint32_t j = 0; j < GetNumberOfExpressionPaths(); j++) + new_sp->AddExpressionPath(GetExpressionPathAtIndex(j)); + + SetSP(new_sp); + + return true; +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBTypeFilter>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBTypeFilter, ()); + LLDB_REGISTER_CONSTRUCTOR(SBTypeFilter, (uint32_t)); + LLDB_REGISTER_CONSTRUCTOR(SBTypeFilter, (const lldb::SBTypeFilter &)); + LLDB_REGISTER_METHOD_CONST(bool, SBTypeFilter, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBTypeFilter, operator bool, ()); + LLDB_REGISTER_METHOD(uint32_t, SBTypeFilter, GetOptions, ()); + LLDB_REGISTER_METHOD(void, SBTypeFilter, SetOptions, (uint32_t)); + LLDB_REGISTER_METHOD(bool, SBTypeFilter, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel)); + LLDB_REGISTER_METHOD(void, SBTypeFilter, Clear, ()); + LLDB_REGISTER_METHOD(uint32_t, SBTypeFilter, GetNumberOfExpressionPaths, + ()); + LLDB_REGISTER_METHOD(const char *, SBTypeFilter, GetExpressionPathAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD(bool, SBTypeFilter, ReplaceExpressionPathAtIndex, + (uint32_t, const char *)); + LLDB_REGISTER_METHOD(void, SBTypeFilter, AppendExpressionPath, + (const char *)); + LLDB_REGISTER_METHOD(lldb::SBTypeFilter &, + SBTypeFilter, operator=,(const lldb::SBTypeFilter &)); + LLDB_REGISTER_METHOD(bool, SBTypeFilter, operator==,(lldb::SBTypeFilter &)); + LLDB_REGISTER_METHOD(bool, SBTypeFilter, IsEqualTo, (lldb::SBTypeFilter &)); + LLDB_REGISTER_METHOD(bool, SBTypeFilter, operator!=,(lldb::SBTypeFilter &)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBTypeFormat.cpp b/contrib/llvm-project/lldb/source/API/SBTypeFormat.cpp new file mode 100644 index 000000000000..70289bef8db5 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBTypeFormat.cpp @@ -0,0 +1,222 @@ +//===-- SBTypeFormat.cpp --------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBTypeFormat.h" +#include "SBReproducerPrivate.h" + +#include "lldb/API/SBStream.h" + +#include "lldb/DataFormatters/DataVisualization.h" + +using namespace lldb; +using namespace lldb_private; + +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))) { + 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))) { + LLDB_RECORD_CONSTRUCTOR(SBTypeFormat, (const char *, uint32_t), type, + options); +} + +SBTypeFormat::SBTypeFormat(const lldb::SBTypeFormat &rhs) + : m_opaque_sp(rhs.m_opaque_sp) { + LLDB_RECORD_CONSTRUCTOR(SBTypeFormat, (const lldb::SBTypeFormat &), rhs); +} + +SBTypeFormat::~SBTypeFormat() = default; + +bool SBTypeFormat::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFormat, IsValid); + return this->operator bool(); +} +SBTypeFormat::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFormat, operator bool); + + return m_opaque_sp.get() != nullptr; +} + +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() + .AsCString(""); + return ""; +} + +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 { + description.Printf("%s\n", m_opaque_sp->GetDescription().c_str()); + return true; + } +} + +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; + } + return LLDB_RECORD_RESULT(*this); +} + +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(); + + if (GetFormat() == rhs.GetFormat()) + return GetOptions() == rhs.GetOptions(); + else + return false; +} + +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; +} + +lldb::TypeFormatImplSP SBTypeFormat::GetSP() { return m_opaque_sp; } + +void SBTypeFormat::SetSP(const lldb::TypeFormatImplSP &typeformat_impl_sp) { + m_opaque_sp = typeformat_impl_sp; +} + +SBTypeFormat::SBTypeFormat(const lldb::TypeFormatImplSP &typeformat_impl_sp) + : m_opaque_sp(typeformat_impl_sp) {} + +bool SBTypeFormat::CopyOnWrite_Impl(Type type) { + if (!IsValid()) + return false; + + if (m_opaque_sp.unique() && + ((type == Type::eTypeKeepSame) || + (type == Type::eTypeFormat && + m_opaque_sp->GetType() == TypeFormatImpl::Type::eTypeFormat) || + (type == Type::eTypeEnum && + m_opaque_sp->GetType() == TypeFormatImpl::Type::eTypeEnum))) + return true; + + if (type == Type::eTypeKeepSame) { + if (m_opaque_sp->GetType() == TypeFormatImpl::Type::eTypeFormat) + type = Type::eTypeFormat; + else + type = Type::eTypeEnum; + } + + if (type == Type::eTypeFormat) + SetSP( + TypeFormatImplSP(new TypeFormatImpl_Format(GetFormat(), GetOptions()))); + else + SetSP(TypeFormatImplSP( + new TypeFormatImpl_EnumType(ConstString(GetTypeName()), GetOptions()))); + + return true; +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBTypeFormat>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBTypeFormat, ()); + LLDB_REGISTER_CONSTRUCTOR(SBTypeFormat, (lldb::Format, uint32_t)); + LLDB_REGISTER_CONSTRUCTOR(SBTypeFormat, (const char *, uint32_t)); + LLDB_REGISTER_CONSTRUCTOR(SBTypeFormat, (const lldb::SBTypeFormat &)); + LLDB_REGISTER_METHOD_CONST(bool, SBTypeFormat, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBTypeFormat, operator bool, ()); + LLDB_REGISTER_METHOD(lldb::Format, SBTypeFormat, GetFormat, ()); + LLDB_REGISTER_METHOD(const char *, SBTypeFormat, GetTypeName, ()); + LLDB_REGISTER_METHOD(uint32_t, SBTypeFormat, GetOptions, ()); + LLDB_REGISTER_METHOD(void, SBTypeFormat, SetFormat, (lldb::Format)); + LLDB_REGISTER_METHOD(void, SBTypeFormat, SetTypeName, (const char *)); + LLDB_REGISTER_METHOD(void, SBTypeFormat, SetOptions, (uint32_t)); + LLDB_REGISTER_METHOD(bool, SBTypeFormat, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel)); + LLDB_REGISTER_METHOD(lldb::SBTypeFormat &, + SBTypeFormat, operator=,(const lldb::SBTypeFormat &)); + LLDB_REGISTER_METHOD(bool, SBTypeFormat, operator==,(lldb::SBTypeFormat &)); + LLDB_REGISTER_METHOD(bool, SBTypeFormat, IsEqualTo, (lldb::SBTypeFormat &)); + LLDB_REGISTER_METHOD(bool, SBTypeFormat, operator!=,(lldb::SBTypeFormat &)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBTypeNameSpecifier.cpp b/contrib/llvm-project/lldb/source/API/SBTypeNameSpecifier.cpp new file mode 100644 index 000000000000..3673a5024530 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBTypeNameSpecifier.cpp @@ -0,0 +1,188 @@ +//===-- SBTypeNameSpecifier.cpp -------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBTypeNameSpecifier.h" +#include "SBReproducerPrivate.h" + +#include "lldb/API/SBStream.h" +#include "lldb/API/SBType.h" + +#include "lldb/DataFormatters/DataVisualization.h" + +using namespace lldb; +using namespace lldb_private; + +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 == nullptr || (*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) { + LLDB_RECORD_CONSTRUCTOR(SBTypeNameSpecifier, + (const lldb::SBTypeNameSpecifier &), rhs); +} + +SBTypeNameSpecifier::~SBTypeNameSpecifier() = default; + +bool SBTypeNameSpecifier::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeNameSpecifier, IsValid); + return this->operator bool(); +} +SBTypeNameSpecifier::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeNameSpecifier, operator bool); + + return m_opaque_sp.get() != nullptr; +} + +const char *SBTypeNameSpecifier::GetName() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeNameSpecifier, GetName); + + if (!IsValid()) + return nullptr; + + return m_opaque_sp->GetName(); +} + +SBType SBTypeNameSpecifier::GetType() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeNameSpecifier, GetType); + + if (!IsValid()) + return LLDB_RECORD_RESULT(SBType()); + lldb_private::CompilerType c_type = m_opaque_sp->GetCompilerType(); + if (c_type.IsValid()) + 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; + + return m_opaque_sp->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(), + IsRegex() ? "regex" : "plain"); + return true; +} + +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; + } + return LLDB_RECORD_RESULT(*this); +} + +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(); + + if (IsRegex() != rhs.IsRegex()) + return false; + if (GetName() == nullptr || rhs.GetName() == nullptr) + return false; + + return (strcmp(GetName(), rhs.GetName()) == 0); +} + +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; +} + +lldb::TypeNameSpecifierImplSP SBTypeNameSpecifier::GetSP() { + return m_opaque_sp; +} + +void SBTypeNameSpecifier::SetSP( + const lldb::TypeNameSpecifierImplSP &type_namespec_sp) { + m_opaque_sp = type_namespec_sp; +} + +SBTypeNameSpecifier::SBTypeNameSpecifier( + const lldb::TypeNameSpecifierImplSP &type_namespec_sp) + : m_opaque_sp(type_namespec_sp) {} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBTypeNameSpecifier>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier, ()); + LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier, (const char *, bool)); + LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier, (lldb::SBType)); + LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier, + (const lldb::SBTypeNameSpecifier &)); + LLDB_REGISTER_METHOD_CONST(bool, SBTypeNameSpecifier, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBTypeNameSpecifier, operator bool, ()); + LLDB_REGISTER_METHOD(const char *, SBTypeNameSpecifier, GetName, ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBTypeNameSpecifier, GetType, ()); + LLDB_REGISTER_METHOD(bool, SBTypeNameSpecifier, IsRegex, ()); + LLDB_REGISTER_METHOD(bool, SBTypeNameSpecifier, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel)); + LLDB_REGISTER_METHOD( + lldb::SBTypeNameSpecifier &, + SBTypeNameSpecifier, operator=,(const lldb::SBTypeNameSpecifier &)); + LLDB_REGISTER_METHOD( + bool, SBTypeNameSpecifier, operator==,(lldb::SBTypeNameSpecifier &)); + LLDB_REGISTER_METHOD(bool, SBTypeNameSpecifier, IsEqualTo, + (lldb::SBTypeNameSpecifier &)); + LLDB_REGISTER_METHOD( + bool, SBTypeNameSpecifier, operator!=,(lldb::SBTypeNameSpecifier &)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBTypeSummary.cpp b/contrib/llvm-project/lldb/source/API/SBTypeSummary.cpp new file mode 100644 index 000000000000..3800ae940c70 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBTypeSummary.cpp @@ -0,0 +1,536 @@ +//===-- SBTypeSummary.cpp -------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBTypeSummary.h" +#include "SBReproducerPrivate.h" +#include "Utils.h" +#include "lldb/API/SBStream.h" +#include "lldb/API/SBValue.h" +#include "lldb/DataFormatters/DataVisualization.h" + +#include "llvm/Support/Casting.h" + +using namespace lldb; +using namespace lldb_private; + +SBTypeSummaryOptions::SBTypeSummaryOptions() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeSummaryOptions); + + m_opaque_up = std::make_unique<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() = default; + +bool SBTypeSummaryOptions::IsValid() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummaryOptions, IsValid); + return this->operator bool(); +} +SBTypeSummaryOptions::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSummaryOptions, operator bool); + + return m_opaque_up.get(); +} + +lldb::LanguageType SBTypeSummaryOptions::GetLanguage() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::LanguageType, SBTypeSummaryOptions, + GetLanguage); + + 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); +} + +lldb_private::TypeSummaryOptions *SBTypeSummaryOptions::operator->() { + return m_opaque_up.get(); +} + +const lldb_private::TypeSummaryOptions *SBTypeSummaryOptions:: +operator->() const { + return m_opaque_up.get(); +} + +lldb_private::TypeSummaryOptions *SBTypeSummaryOptions::get() { + return m_opaque_up.get(); +} + +lldb_private::TypeSummaryOptions &SBTypeSummaryOptions::ref() { + return *m_opaque_up; +} + +const lldb_private::TypeSummaryOptions &SBTypeSummaryOptions::ref() const { + return *m_opaque_up; +} + +SBTypeSummaryOptions::SBTypeSummaryOptions( + const lldb_private::TypeSummaryOptions *lldb_object_ptr) { + LLDB_RECORD_CONSTRUCTOR(SBTypeSummaryOptions, + (const lldb_private::TypeSummaryOptions *), + lldb_object_ptr); + + SetOptions(lldb_object_ptr); +} + +void SBTypeSummaryOptions::SetOptions( + const lldb_private::TypeSummaryOptions *lldb_object_ptr) { + if (lldb_object_ptr) + m_opaque_up = std::make_unique<TypeSummaryOptions>(*lldb_object_ptr); + else + m_opaque_up = std::make_unique<TypeSummaryOptions>(); +} + +SBTypeSummary::SBTypeSummary() : m_opaque_sp() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeSummary); +} + +SBTypeSummary SBTypeSummary::CreateWithSummaryString(const char *data, + uint32_t options) { + LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary, + CreateWithSummaryString, (const char *, uint32_t), + data, options); + + if (!data || data[0] == 0) + return LLDB_RECORD_RESULT(SBTypeSummary()); + + return LLDB_RECORD_RESULT( + SBTypeSummary(TypeSummaryImplSP(new StringSummaryFormat(options, data)))); +} + +SBTypeSummary SBTypeSummary::CreateWithFunctionName(const char *data, + uint32_t options) { + LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary, + CreateWithFunctionName, (const char *, uint32_t), + data, options); + + if (!data || data[0] == 0) + return LLDB_RECORD_RESULT(SBTypeSummary()); + + return LLDB_RECORD_RESULT( + SBTypeSummary(TypeSummaryImplSP(new ScriptSummaryFormat(options, data)))); +} + +SBTypeSummary SBTypeSummary::CreateWithScriptCode(const char *data, + uint32_t options) { + LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary, + CreateWithScriptCode, (const char *, uint32_t), + data, options); + + if (!data || data[0] == 0) + return LLDB_RECORD_RESULT(SBTypeSummary()); + + return LLDB_RECORD_RESULT(SBTypeSummary( + TypeSummaryImplSP(new ScriptSummaryFormat(options, "", data)))); +} + +SBTypeSummary SBTypeSummary::CreateWithCallback(FormatCallback cb, + uint32_t options, + const char *description) { + LLDB_RECORD_DUMMY( + lldb::SBTypeSummary, SBTypeSummary, CreateWithCallback, + (lldb::SBTypeSummary::FormatCallback, uint32_t, const char *), cb, + options, description); + + SBTypeSummary retval; + if (cb) { + retval.SetSP(TypeSummaryImplSP(new CXXFunctionSummaryFormat( + options, + [cb](ValueObject &valobj, Stream &stm, + const TypeSummaryOptions &opt) -> bool { + SBStream stream; + SBValue sb_value(valobj.GetSP()); + SBTypeSummaryOptions options(&opt); + if (!cb(sb_value, options, stream)) + return false; + stm.Write(stream.GetData(), stream.GetSize()); + return true; + }, + description ? description : "callback summary formatter"))); + } + + return retval; +} + +SBTypeSummary::SBTypeSummary(const lldb::SBTypeSummary &rhs) + : m_opaque_sp(rhs.m_opaque_sp) { + LLDB_RECORD_CONSTRUCTOR(SBTypeSummary, (const lldb::SBTypeSummary &), rhs); +} + +SBTypeSummary::~SBTypeSummary() = default; + +bool SBTypeSummary::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSummary, IsValid); + return this->operator bool(); +} +SBTypeSummary::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSummary, operator bool); + + return m_opaque_sp.get() != nullptr; +} + +bool SBTypeSummary::IsFunctionCode() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummary, IsFunctionCode); + + if (!IsValid()) + return false; + if (ScriptSummaryFormat *script_summary_ptr = + llvm::dyn_cast<ScriptSummaryFormat>(m_opaque_sp.get())) { + const char *ftext = script_summary_ptr->GetPythonScript(); + return (ftext && *ftext != 0); + } + return false; +} + +bool SBTypeSummary::IsFunctionName() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummary, IsFunctionName); + + if (!IsValid()) + return false; + if (ScriptSummaryFormat *script_summary_ptr = + llvm::dyn_cast<ScriptSummaryFormat>(m_opaque_sp.get())) { + const char *ftext = script_summary_ptr->GetPythonScript(); + return (!ftext || *ftext == 0); + } + return false; +} + +bool SBTypeSummary::IsSummaryString() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummary, IsSummaryString); + + if (!IsValid()) + return false; + + return m_opaque_sp->GetKind() == TypeSummaryImpl::Kind::eSummaryString; +} + +const char *SBTypeSummary::GetData() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeSummary, GetData); + + if (!IsValid()) + return nullptr; + if (ScriptSummaryFormat *script_summary_ptr = + llvm::dyn_cast<ScriptSummaryFormat>(m_opaque_sp.get())) { + const char *fname = script_summary_ptr->GetFunctionName(); + const char *ftext = script_summary_ptr->GetPythonScript(); + if (ftext && *ftext) + return ftext; + return fname; + } else if (StringSummaryFormat *string_summary_ptr = + llvm::dyn_cast<StringSummaryFormat>(m_opaque_sp.get())) + return string_summary_ptr->GetSummaryString(); + return nullptr; +} + +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())) + ChangeSummaryType(false); + if (StringSummaryFormat *string_summary_ptr = + llvm::dyn_cast<StringSummaryFormat>(m_opaque_sp.get())) + string_summary_ptr->SetSummaryString(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())) + ChangeSummaryType(true); + if (ScriptSummaryFormat *script_summary_ptr = + llvm::dyn_cast<ScriptSummaryFormat>(m_opaque_sp.get())) + script_summary_ptr->SetFunctionName(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())) + ChangeSummaryType(true); + if (ScriptSummaryFormat *script_summary_ptr = + llvm::dyn_cast<ScriptSummaryFormat>(m_opaque_sp.get())) + script_summary_ptr->SetPythonScript(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 { + description.Printf("%s\n", m_opaque_sp->GetDescription().c_str()); + return true; + } +} + +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(); + return m_opaque_sp->DoesPrintValue(value_sp.get()); +} + +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; + } + return LLDB_RECORD_RESULT(*this); +} + +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()) + return false; + } else { + // invalid and valid are different + if (rhs.IsValid()) + return false; + else + // both invalid are the same + return true; + } + + if (m_opaque_sp->GetKind() != rhs.m_opaque_sp->GetKind()) + return false; + + switch (m_opaque_sp->GetKind()) { + case TypeSummaryImpl::Kind::eCallback: + return llvm::dyn_cast<CXXFunctionSummaryFormat>(m_opaque_sp.get()) == + llvm::dyn_cast<CXXFunctionSummaryFormat>(rhs.m_opaque_sp.get()); + case TypeSummaryImpl::Kind::eScript: + if (IsFunctionCode() != rhs.IsFunctionCode()) + return false; + if (IsFunctionName() != rhs.IsFunctionName()) + return false; + return GetOptions() == rhs.GetOptions(); + case TypeSummaryImpl::Kind::eSummaryString: + if (IsSummaryString() != rhs.IsSummaryString()) + return false; + return GetOptions() == rhs.GetOptions(); + case TypeSummaryImpl::Kind::eInternal: + return (m_opaque_sp.get() == rhs.m_opaque_sp.get()); + } + + return false; +} + +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; +} + +lldb::TypeSummaryImplSP SBTypeSummary::GetSP() { return m_opaque_sp; } + +void SBTypeSummary::SetSP(const lldb::TypeSummaryImplSP &typesummary_impl_sp) { + m_opaque_sp = typesummary_impl_sp; +} + +SBTypeSummary::SBTypeSummary(const lldb::TypeSummaryImplSP &typesummary_impl_sp) + : m_opaque_sp(typesummary_impl_sp) {} + +bool SBTypeSummary::CopyOnWrite_Impl() { + if (!IsValid()) + return false; + + if (m_opaque_sp.unique()) + return true; + + TypeSummaryImplSP new_sp; + + if (CXXFunctionSummaryFormat *current_summary_ptr = + llvm::dyn_cast<CXXFunctionSummaryFormat>(m_opaque_sp.get())) { + new_sp = TypeSummaryImplSP(new CXXFunctionSummaryFormat( + GetOptions(), current_summary_ptr->m_impl, + current_summary_ptr->m_description.c_str())); + } else if (ScriptSummaryFormat *current_summary_ptr = + llvm::dyn_cast<ScriptSummaryFormat>(m_opaque_sp.get())) { + new_sp = TypeSummaryImplSP(new ScriptSummaryFormat( + GetOptions(), current_summary_ptr->GetFunctionName(), + current_summary_ptr->GetPythonScript())); + } else if (StringSummaryFormat *current_summary_ptr = + llvm::dyn_cast<StringSummaryFormat>(m_opaque_sp.get())) { + new_sp = TypeSummaryImplSP(new StringSummaryFormat( + GetOptions(), current_summary_ptr->GetSummaryString())); + } + + SetSP(new_sp); + + return nullptr != new_sp.get(); +} + +bool SBTypeSummary::ChangeSummaryType(bool want_script) { + if (!IsValid()) + return false; + + TypeSummaryImplSP new_sp; + + if (want_script == + (m_opaque_sp->GetKind() == TypeSummaryImpl::Kind::eScript)) { + if (m_opaque_sp->GetKind() == + lldb_private::TypeSummaryImpl::Kind::eCallback && + !want_script) + new_sp = TypeSummaryImplSP(new StringSummaryFormat(GetOptions(), "")); + else + return CopyOnWrite_Impl(); + } + + if (!new_sp) { + if (want_script) + new_sp = TypeSummaryImplSP(new ScriptSummaryFormat(GetOptions(), "", "")); + else + new_sp = TypeSummaryImplSP(new StringSummaryFormat(GetOptions(), "")); + } + + SetSP(new_sp); + + return true; +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBTypeSummaryOptions>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBTypeSummaryOptions, ()); + LLDB_REGISTER_CONSTRUCTOR(SBTypeSummaryOptions, + (const lldb::SBTypeSummaryOptions &)); + LLDB_REGISTER_METHOD(bool, SBTypeSummaryOptions, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBTypeSummaryOptions, operator bool, ()); + LLDB_REGISTER_METHOD(lldb::LanguageType, SBTypeSummaryOptions, GetLanguage, + ()); + LLDB_REGISTER_METHOD(lldb::TypeSummaryCapping, SBTypeSummaryOptions, + GetCapping, ()); + LLDB_REGISTER_METHOD(void, SBTypeSummaryOptions, SetLanguage, + (lldb::LanguageType)); + LLDB_REGISTER_METHOD(void, SBTypeSummaryOptions, SetCapping, + (lldb::TypeSummaryCapping)); + LLDB_REGISTER_CONSTRUCTOR(SBTypeSummaryOptions, + (const lldb_private::TypeSummaryOptions *)); +} + +template <> +void RegisterMethods<SBTypeSummary>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBTypeSummary, ()); + LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary, + CreateWithSummaryString, + (const char *, uint32_t)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary, + CreateWithFunctionName, + (const char *, uint32_t)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary, + CreateWithScriptCode, (const char *, uint32_t)); + LLDB_REGISTER_CONSTRUCTOR(SBTypeSummary, (const lldb::SBTypeSummary &)); + LLDB_REGISTER_METHOD_CONST(bool, SBTypeSummary, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBTypeSummary, operator bool, ()); + LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsFunctionCode, ()); + LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsFunctionName, ()); + LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsSummaryString, ()); + LLDB_REGISTER_METHOD(const char *, SBTypeSummary, GetData, ()); + LLDB_REGISTER_METHOD(uint32_t, SBTypeSummary, GetOptions, ()); + LLDB_REGISTER_METHOD(void, SBTypeSummary, SetOptions, (uint32_t)); + LLDB_REGISTER_METHOD(void, SBTypeSummary, SetSummaryString, (const char *)); + LLDB_REGISTER_METHOD(void, SBTypeSummary, SetFunctionName, (const char *)); + LLDB_REGISTER_METHOD(void, SBTypeSummary, SetFunctionCode, (const char *)); + LLDB_REGISTER_METHOD(bool, SBTypeSummary, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel)); + LLDB_REGISTER_METHOD(bool, SBTypeSummary, DoesPrintValue, (lldb::SBValue)); + LLDB_REGISTER_METHOD( + lldb::SBTypeSummary &, + SBTypeSummary, operator=,(const lldb::SBTypeSummary &)); + LLDB_REGISTER_METHOD(bool, + SBTypeSummary, operator==,(lldb::SBTypeSummary &)); + LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsEqualTo, + (lldb::SBTypeSummary &)); + LLDB_REGISTER_METHOD(bool, + SBTypeSummary, operator!=,(lldb::SBTypeSummary &)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBTypeSynthetic.cpp b/contrib/llvm-project/lldb/source/API/SBTypeSynthetic.cpp new file mode 100644 index 000000000000..af5e167b9c24 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBTypeSynthetic.cpp @@ -0,0 +1,247 @@ +//===-- SBTypeSynthetic.cpp -----------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBTypeSynthetic.h" +#include "SBReproducerPrivate.h" + +#include "lldb/API/SBStream.h" + +#include "lldb/DataFormatters/DataVisualization.h" + +using namespace lldb; +using namespace lldb_private; + +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 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 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) { + LLDB_RECORD_CONSTRUCTOR(SBTypeSynthetic, (const lldb::SBTypeSynthetic &), + rhs); +} + +SBTypeSynthetic::~SBTypeSynthetic() = default; + +bool SBTypeSynthetic::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSynthetic, IsValid); + return this->operator bool(); +} +SBTypeSynthetic::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSynthetic, operator bool); + + return m_opaque_sp.get() != nullptr; +} + +bool SBTypeSynthetic::IsClassCode() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSynthetic, IsClassCode); + + if (!IsValid()) + return false; + const char *code = m_opaque_sp->GetPythonCode(); + return (code && *code); +} + +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 nullptr; + if (IsClassCode()) + return m_opaque_sp->GetPythonCode(); + else + return m_opaque_sp->GetPythonClassName(); +} + +void SBTypeSynthetic::SetClassName(const char *data) { + LLDB_RECORD_METHOD(void, SBTypeSynthetic, SetClassName, (const char *), data); + + if (IsValid() && data && *data) + m_opaque_sp->SetPythonClassName(data); +} + +void SBTypeSynthetic::SetClassCode(const char *data) { + LLDB_RECORD_METHOD(void, SBTypeSynthetic, SetClassCode, (const char *), data); + + if (IsValid() && data && *data) + m_opaque_sp->SetPythonCode(data); +} + +uint32_t SBTypeSynthetic::GetOptions() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeSynthetic, GetOptions); + + if (!IsValid()) + return lldb::eTypeOptionNone; + return m_opaque_sp->GetOptions(); +} + +void SBTypeSynthetic::SetOptions(uint32_t value) { + LLDB_RECORD_METHOD(void, SBTypeSynthetic, SetOptions, (uint32_t), value); + + if (!CopyOnWrite_Impl()) + return; + m_opaque_sp->SetOptions(value); +} + +bool SBTypeSynthetic::GetDescription(lldb::SBStream &description, + lldb::DescriptionLevel description_level) { + LLDB_RECORD_METHOD(bool, SBTypeSynthetic, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel), description, + description_level); + + if (m_opaque_sp) { + description.Printf("%s\n", m_opaque_sp->GetDescription().c_str()); + return true; + } + return false; +} + +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; + } + return LLDB_RECORD_RESULT(*this); +} + +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(); + + if (m_opaque_sp->IsScripted() != rhs.m_opaque_sp->IsScripted()) + return false; + + if (IsClassCode() != rhs.IsClassCode()) + return false; + + if (strcmp(GetData(), rhs.GetData())) + return false; + + return GetOptions() == rhs.GetOptions(); +} + +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; +} + +lldb::ScriptedSyntheticChildrenSP SBTypeSynthetic::GetSP() { + return m_opaque_sp; +} + +void SBTypeSynthetic::SetSP( + const lldb::ScriptedSyntheticChildrenSP &TypeSynthetic_impl_sp) { + m_opaque_sp = TypeSynthetic_impl_sp; +} + +SBTypeSynthetic::SBTypeSynthetic( + const lldb::ScriptedSyntheticChildrenSP &TypeSynthetic_impl_sp) + : m_opaque_sp(TypeSynthetic_impl_sp) {} + +bool SBTypeSynthetic::CopyOnWrite_Impl() { + if (!IsValid()) + return false; + if (m_opaque_sp.unique()) + return true; + + ScriptedSyntheticChildrenSP new_sp(new ScriptedSyntheticChildren( + m_opaque_sp->GetOptions(), m_opaque_sp->GetPythonClassName(), + m_opaque_sp->GetPythonCode())); + + SetSP(new_sp); + + return true; +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBTypeSynthetic>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBTypeSynthetic, ()); + LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSynthetic, SBTypeSynthetic, + CreateWithClassName, (const char *, uint32_t)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSynthetic, SBTypeSynthetic, + CreateWithScriptCode, (const char *, uint32_t)); + LLDB_REGISTER_CONSTRUCTOR(SBTypeSynthetic, (const lldb::SBTypeSynthetic &)); + LLDB_REGISTER_METHOD_CONST(bool, SBTypeSynthetic, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBTypeSynthetic, operator bool, ()); + LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, IsClassCode, ()); + LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, IsClassName, ()); + LLDB_REGISTER_METHOD(const char *, SBTypeSynthetic, GetData, ()); + LLDB_REGISTER_METHOD(void, SBTypeSynthetic, SetClassName, (const char *)); + LLDB_REGISTER_METHOD(void, SBTypeSynthetic, SetClassCode, (const char *)); + LLDB_REGISTER_METHOD(uint32_t, SBTypeSynthetic, GetOptions, ()); + LLDB_REGISTER_METHOD(void, SBTypeSynthetic, SetOptions, (uint32_t)); + LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel)); + LLDB_REGISTER_METHOD( + lldb::SBTypeSynthetic &, + SBTypeSynthetic, operator=,(const lldb::SBTypeSynthetic &)); + LLDB_REGISTER_METHOD(bool, + SBTypeSynthetic, operator==,(lldb::SBTypeSynthetic &)); + LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, IsEqualTo, + (lldb::SBTypeSynthetic &)); + LLDB_REGISTER_METHOD(bool, + SBTypeSynthetic, operator!=,(lldb::SBTypeSynthetic &)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBUnixSignals.cpp b/contrib/llvm-project/lldb/source/API/SBUnixSignals.cpp new file mode 100644 index 000000000000..a933f6d22333 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBUnixSignals.cpp @@ -0,0 +1,205 @@ +//===-- SBUnixSignals.cpp -------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "SBReproducerPrivate.h" +#include "lldb/Target/Platform.h" +#include "lldb/Target/Process.h" +#include "lldb/Target/UnixSignals.h" +#include "lldb/lldb-defines.h" + +#include "lldb/API/SBUnixSignals.h" + +using namespace lldb; +using namespace lldb_private; + +SBUnixSignals::SBUnixSignals() { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBUnixSignals); +} + +SBUnixSignals::SBUnixSignals(const SBUnixSignals &rhs) + : 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) {} + +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 LLDB_RECORD_RESULT(*this); +} + +SBUnixSignals::~SBUnixSignals() = default; + +UnixSignalsSP SBUnixSignals::GetSP() const { return m_opaque_wp.lock(); } + +void SBUnixSignals::SetSP(const UnixSignalsSP &signals_sp) { + m_opaque_wp = signals_sp; +} + +void SBUnixSignals::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBUnixSignals, Clear); + + m_opaque_wp.reset(); +} + +bool SBUnixSignals::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBUnixSignals, IsValid); + return this->operator bool(); +} +SBUnixSignals::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBUnixSignals, operator bool); + + 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); + + return nullptr; +} + +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); + + return LLDB_INVALID_SIGNAL_NUMBER; +} + +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); + + return false; +} + +bool SBUnixSignals::SetShouldSuppress(int32_t signo, bool value) { + LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldSuppress, (int32_t, bool), + signo, value); + + auto signals_sp = GetSP(); + + if (signals_sp) + return signals_sp->SetShouldSuppress(signo, value); + + return false; +} + +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); + + return false; +} + +bool SBUnixSignals::SetShouldStop(int32_t signo, bool value) { + LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldStop, (int32_t, bool), signo, + value); + + auto signals_sp = GetSP(); + + if (signals_sp) + return signals_sp->SetShouldStop(signo, value); + + return false; +} + +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); + + return false; +} + +bool SBUnixSignals::SetShouldNotify(int32_t signo, bool value) { + LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldNotify, (int32_t, bool), + signo, value); + + auto signals_sp = GetSP(); + + if (signals_sp) + return signals_sp->SetShouldNotify(signo, value); + + return false; +} + +int32_t SBUnixSignals::GetNumSignals() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(int32_t, SBUnixSignals, GetNumSignals); + + if (auto signals_sp = GetSP()) + return signals_sp->GetNumSignals(); + + return -1; +} + +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); + + return LLDB_INVALID_SIGNAL_NUMBER; +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBUnixSignals>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBUnixSignals, ()); + LLDB_REGISTER_CONSTRUCTOR(SBUnixSignals, (const lldb::SBUnixSignals &)); + LLDB_REGISTER_METHOD( + const lldb::SBUnixSignals &, + SBUnixSignals, operator=,(const lldb::SBUnixSignals &)); + LLDB_REGISTER_METHOD(void, SBUnixSignals, Clear, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, operator bool, ()); + LLDB_REGISTER_METHOD_CONST(const char *, SBUnixSignals, GetSignalAsCString, + (int32_t)); + LLDB_REGISTER_METHOD_CONST(int32_t, SBUnixSignals, GetSignalNumberFromName, + (const char *)); + LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, GetShouldSuppress, + (int32_t)); + LLDB_REGISTER_METHOD(bool, SBUnixSignals, SetShouldSuppress, + (int32_t, bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, GetShouldStop, (int32_t)); + LLDB_REGISTER_METHOD(bool, SBUnixSignals, SetShouldStop, (int32_t, bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, GetShouldNotify, (int32_t)); + LLDB_REGISTER_METHOD(bool, SBUnixSignals, SetShouldNotify, (int32_t, bool)); + LLDB_REGISTER_METHOD_CONST(int32_t, SBUnixSignals, GetNumSignals, ()); + LLDB_REGISTER_METHOD_CONST(int32_t, SBUnixSignals, GetSignalAtIndex, + (int32_t)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBValue.cpp b/contrib/llvm-project/lldb/source/API/SBValue.cpp new file mode 100644 index 000000000000..7485b0ee1838 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBValue.cpp @@ -0,0 +1,1670 @@ +//===-- SBValue.cpp -------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBValue.h" +#include "SBReproducerPrivate.h" + +#include "lldb/API/SBDeclaration.h" +#include "lldb/API/SBStream.h" +#include "lldb/API/SBTypeFilter.h" +#include "lldb/API/SBTypeFormat.h" +#include "lldb/API/SBTypeSummary.h" +#include "lldb/API/SBTypeSynthetic.h" + +#include "lldb/Breakpoint/Watchpoint.h" +#include "lldb/Core/Module.h" +#include "lldb/Core/Section.h" +#include "lldb/Core/StreamFile.h" +#include "lldb/Core/Value.h" +#include "lldb/Core/ValueObject.h" +#include "lldb/Core/ValueObjectConstResult.h" +#include "lldb/DataFormatters/DataVisualization.h" +#include "lldb/Symbol/Block.h" +#include "lldb/Symbol/Declaration.h" +#include "lldb/Symbol/ObjectFile.h" +#include "lldb/Symbol/Type.h" +#include "lldb/Symbol/Variable.h" +#include "lldb/Symbol/VariableList.h" +#include "lldb/Target/ExecutionContext.h" +#include "lldb/Target/Process.h" +#include "lldb/Target/StackFrame.h" +#include "lldb/Target/Target.h" +#include "lldb/Target/Thread.h" +#include "lldb/Utility/DataExtractor.h" +#include "lldb/Utility/Scalar.h" +#include "lldb/Utility/Stream.h" + +#include "lldb/API/SBDebugger.h" +#include "lldb/API/SBExpressionOptions.h" +#include "lldb/API/SBFrame.h" +#include "lldb/API/SBProcess.h" +#include "lldb/API/SBTarget.h" +#include "lldb/API/SBThread.h" + +#include <memory> + +using namespace lldb; +using namespace lldb_private; + +class ValueImpl { +public: + ValueImpl() = default; + + ValueImpl(lldb::ValueObjectSP in_valobj_sp, + lldb::DynamicValueType use_dynamic, bool use_synthetic, + const char *name = nullptr) + : m_valobj_sp(), m_use_dynamic(use_dynamic), + m_use_synthetic(use_synthetic), m_name(name) { + if (in_valobj_sp) { + if ((m_valobj_sp = in_valobj_sp->GetQualifiedRepresentationIfAvailable( + lldb::eNoDynamicValues, false))) { + if (!m_name.IsEmpty()) + m_valobj_sp->SetName(m_name); + } + } + } + + ValueImpl(const ValueImpl &rhs) + : m_valobj_sp(rhs.m_valobj_sp), m_use_dynamic(rhs.m_use_dynamic), + m_use_synthetic(rhs.m_use_synthetic), m_name(rhs.m_name) {} + + ValueImpl &operator=(const ValueImpl &rhs) { + if (this != &rhs) { + m_valobj_sp = rhs.m_valobj_sp; + m_use_dynamic = rhs.m_use_dynamic; + m_use_synthetic = rhs.m_use_synthetic; + m_name = rhs.m_name; + } + return *this; + } + + bool IsValid() { + if (m_valobj_sp.get() == nullptr) + return false; + else { + // FIXME: This check is necessary but not sufficient. We for sure don't + // want to touch SBValues whose owning + // targets have gone away. This check is a little weak in that it + // enforces that restriction when you call IsValid, but since IsValid + // doesn't lock the target, you have no guarantee that the SBValue won't + // go invalid after you call this... Also, an SBValue could depend on + // data from one of the modules in the target, and those could go away + // independently of the target, for instance if a module is unloaded. + // But right now, neither SBValues nor ValueObjects know which modules + // they depend on. So I have no good way to make that check without + // tracking that in all the ValueObject subclasses. + TargetSP target_sp = m_valobj_sp->GetTargetSP(); + return target_sp && target_sp->IsValid(); + } + } + + lldb::ValueObjectSP GetRootSP() { return m_valobj_sp; } + + lldb::ValueObjectSP GetSP(Process::StopLocker &stop_locker, + std::unique_lock<std::recursive_mutex> &lock, + Status &error) { + if (!m_valobj_sp) { + error.SetErrorString("invalid value object"); + return m_valobj_sp; + } + + lldb::ValueObjectSP value_sp = m_valobj_sp; + + Target *target = value_sp->GetTargetSP().get(); + if (!target) + return ValueObjectSP(); + + lock = std::unique_lock<std::recursive_mutex>(target->GetAPIMutex()); + + ProcessSP process_sp(value_sp->GetProcessSP()); + if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) { + // We don't allow people to play around with ValueObject if the process + // is running. If you want to look at values, pause the process, then + // look. + error.SetErrorString("process must be stopped."); + return ValueObjectSP(); + } + + if (m_use_dynamic != eNoDynamicValues) { + ValueObjectSP dynamic_sp = value_sp->GetDynamicValue(m_use_dynamic); + if (dynamic_sp) + value_sp = dynamic_sp; + } + + if (m_use_synthetic) { + ValueObjectSP synthetic_sp = value_sp->GetSyntheticValue(); + if (synthetic_sp) + value_sp = synthetic_sp; + } + + if (!value_sp) + error.SetErrorString("invalid value object"); + if (!m_name.IsEmpty()) + value_sp->SetName(m_name); + + return value_sp; + } + + void SetUseDynamic(lldb::DynamicValueType use_dynamic) { + m_use_dynamic = use_dynamic; + } + + void SetUseSynthetic(bool use_synthetic) { m_use_synthetic = use_synthetic; } + + lldb::DynamicValueType GetUseDynamic() { return m_use_dynamic; } + + bool GetUseSynthetic() { return m_use_synthetic; } + + // All the derived values that we would make from the m_valobj_sp will share + // the ExecutionContext with m_valobj_sp, so we don't need to do the + // calculations in GetSP to return the Target, Process, Thread or Frame. It + // is convenient to provide simple accessors for these, which I do here. + TargetSP GetTargetSP() { + if (m_valobj_sp) + return m_valobj_sp->GetTargetSP(); + else + return TargetSP(); + } + + ProcessSP GetProcessSP() { + if (m_valobj_sp) + return m_valobj_sp->GetProcessSP(); + else + return ProcessSP(); + } + + ThreadSP GetThreadSP() { + if (m_valobj_sp) + return m_valobj_sp->GetThreadSP(); + else + return ThreadSP(); + } + + StackFrameSP GetFrameSP() { + if (m_valobj_sp) + return m_valobj_sp->GetFrameSP(); + else + return StackFrameSP(); + } + +private: + lldb::ValueObjectSP m_valobj_sp; + lldb::DynamicValueType m_use_dynamic; + bool m_use_synthetic; + ConstString m_name; +}; + +class ValueLocker { +public: + ValueLocker() = default; + + ValueObjectSP GetLockedSP(ValueImpl &in_value) { + return in_value.GetSP(m_stop_locker, m_lock, m_lock_error); + } + + Status &GetError() { return m_lock_error; } + +private: + Process::StopLocker m_stop_locker; + std::unique_lock<std::recursive_mutex> m_lock; + Status m_lock_error; +}; + +SBValue::SBValue() : m_opaque_sp() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBValue); } + +SBValue::SBValue(const lldb::ValueObjectSP &value_sp) { + LLDB_RECORD_CONSTRUCTOR(SBValue, (const lldb::ValueObjectSP &), value_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); + } + return LLDB_RECORD_RESULT(*this); +} + +SBValue::~SBValue() = default; + +bool SBValue::IsValid() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsValid); + return this->operator bool(); +} +SBValue::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBValue, operator bool); + + // If this function ever changes to anything that does more than just check + // if the opaque shared pointer is non NULL, then we need to update all "if + // (m_opaque_sp)" code in this file. + return m_opaque_sp.get() != nullptr && m_opaque_sp->IsValid() && + m_opaque_sp->GetRootSP().get() != nullptr; +} + +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; + lldb::ValueObjectSP value_sp(GetSP(locker)); + if (value_sp) + sb_error.SetError(value_sp->GetError()); + else + sb_error.SetErrorStringWithFormat("error: %s", + locker.GetError().AsCString()); + + 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) + return value_sp->GetID(); + return LLDB_INVALID_UID; +} + +const char *SBValue::GetName() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetName); + + const char *name = nullptr; + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + if (value_sp) + name = value_sp->GetName().GetCString(); + + return name; +} + +const char *SBValue::GetTypeName() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetTypeName); + + const char *name = nullptr; + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + if (value_sp) { + name = value_sp->GetQualifiedTypeName().GetCString(); + } + + return name; +} + +const char *SBValue::GetDisplayTypeName() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetDisplayTypeName); + + const char *name = nullptr; + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + if (value_sp) { + name = value_sp->GetDisplayTypeName().GetCString(); + } + + return name; +} + +size_t SBValue::GetByteSize() { + LLDB_RECORD_METHOD_NO_ARGS(size_t, SBValue, GetByteSize); + + size_t result = 0; + + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + if (value_sp) { + result = value_sp->GetByteSize(); + } + + return result; +} + +bool SBValue::IsInScope() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsInScope); + + bool result = false; + + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + if (value_sp) { + result = value_sp->IsInScope(); + } + + return result; +} + +const char *SBValue::GetValue() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetValue); + + const char *cstr = nullptr; + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + if (value_sp) { + cstr = value_sp->GetValueAsCString(); + } + + return cstr; +} + +ValueType SBValue::GetValueType() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::ValueType, SBValue, GetValueType); + + ValueType result = eValueTypeInvalid; + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + if (value_sp) + result = value_sp->GetValueType(); + + return result; +} + +const char *SBValue::GetObjectDescription() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetObjectDescription); + + const char *cstr = nullptr; + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + if (value_sp) { + cstr = value_sp->GetObjectDescription(); + } + + return cstr; +} + +SBType SBValue::GetType() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBValue, GetType); + + SBType sb_type; + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + TypeImplSP type_sp; + if (value_sp) { + type_sp = std::make_shared<TypeImpl>(value_sp->GetTypeImpl()); + sb_type.SetSP(type_sp); + } + + return LLDB_RECORD_RESULT(sb_type); +} + +bool SBValue::GetValueDidChange() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, GetValueDidChange); + + bool result = false; + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + if (value_sp) { + if (value_sp->UpdateValueIfNeeded(false)) + result = value_sp->GetValueDidChange(); + } + + return result; +} + +const char *SBValue::GetSummary() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetSummary); + + const char *cstr = nullptr; + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + if (value_sp) { + cstr = value_sp->GetSummaryAsCString(); + } + + return cstr; +} + +const char *SBValue::GetSummary(lldb::SBStream &stream, + lldb::SBTypeSummaryOptions &options) { + LLDB_RECORD_METHOD(const char *, SBValue, GetSummary, + (lldb::SBStream &, lldb::SBTypeSummaryOptions &), stream, + options); + + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + if (value_sp) { + std::string buffer; + if (value_sp->GetSummaryAsCString(buffer, options.ref()) && !buffer.empty()) + stream.Printf("%s", buffer.c_str()); + } + const char *cstr = stream.GetData(); + return cstr; +} + +const char *SBValue::GetLocation() { + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetLocation); + + const char *cstr = nullptr; + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + if (value_sp) { + cstr = value_sp->GetLocationAsCString(); + } + return cstr; +} + +// 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)); + if (value_sp) { + success = value_sp->SetValueFromCString(value_str, error.ref()); + } else + error.SetErrorStringWithFormat("Could not get value: %s", + locker.GetError().AsCString()); + + return success; +} + +lldb::SBTypeFormat SBValue::GetTypeFormat() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeFormat, SBValue, GetTypeFormat); + + lldb::SBTypeFormat format; + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + if (value_sp) { + if (value_sp->UpdateValueIfNeeded(true)) { + lldb::TypeFormatImplSP format_sp = value_sp->GetValueFormat(); + if (format_sp) + format.SetSP(format_sp); + } + } + 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)); + if (value_sp) { + if (value_sp->UpdateValueIfNeeded(true)) { + lldb::TypeSummaryImplSP summary_sp = value_sp->GetSummaryFormat(); + if (summary_sp) + summary.SetSP(summary_sp); + } + } + 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)); + if (value_sp) { + if (value_sp->UpdateValueIfNeeded(true)) { + lldb::SyntheticChildrenSP synthetic_sp = value_sp->GetSyntheticChildren(); + + if (synthetic_sp && !synthetic_sp->IsScripted()) { + TypeFilterImplSP filter_sp = + std::static_pointer_cast<TypeFilterImpl>(synthetic_sp); + filter.SetSP(filter_sp); + } + } + } + return LLDB_RECORD_RESULT(filter); +} + +lldb::SBTypeSynthetic SBValue::GetTypeSynthetic() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeSynthetic, SBValue, GetTypeSynthetic); + + lldb::SBTypeSynthetic synthetic; + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + if (value_sp) { + if (value_sp->UpdateValueIfNeeded(true)) { + lldb::SyntheticChildrenSP children_sp = value_sp->GetSyntheticChildren(); + + if (children_sp && children_sp->IsScripted()) { + ScriptedSyntheticChildrenSP synth_sp = + std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp); + synthetic.SetSP(synth_sp); + } + } + } + return LLDB_RECORD_RESULT(synthetic); +} + +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)); + lldb::ValueObjectSP new_value_sp; + if (value_sp) { + TypeImplSP type_sp(type.GetSP()); + if (type.IsValid()) { + sb_value.SetSP(value_sp->GetSyntheticChildAtOffset( + offset, type_sp->GetCompilerType(false), true), + GetPreferDynamicValue(), GetPreferSyntheticValue(), name); + } + } + 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)); + TypeImplSP type_sp(type.GetSP()); + if (value_sp && type_sp) + sb_value.SetSP(value_sp->Cast(type_sp->GetCompilerType(false)), + GetPreferDynamicValue(), GetPreferSyntheticValue()); + 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 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); + + lldb::SBValue sb_value; + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + lldb::ValueObjectSP new_value_sp; + if (value_sp) { + ExecutionContext exe_ctx(value_sp->GetExecutionContextRef()); + new_value_sp = ValueObject::CreateValueObjectFromExpression( + name, expression, exe_ctx, options.ref()); + if (new_value_sp) + new_value_sp->SetName(ConstString(name)); + } + sb_value.SetSP(new_value_sp); + 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)); + lldb::ValueObjectSP new_value_sp; + lldb::TypeImplSP type_impl_sp(sb_type.GetSP()); + if (value_sp && type_impl_sp) { + CompilerType ast_type(type_impl_sp->GetCompilerType(true)); + ExecutionContext exe_ctx(value_sp->GetExecutionContextRef()); + new_value_sp = ValueObject::CreateValueObjectFromAddress(name, address, + exe_ctx, ast_type); + } + sb_value.SetSP(new_value_sp); + 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; + lldb::ValueObjectSP value_sp(GetSP(locker)); + lldb::TypeImplSP type_impl_sp(sb_type.GetSP()); + if (value_sp && type_impl_sp) { + ExecutionContext exe_ctx(value_sp->GetExecutionContextRef()); + new_value_sp = ValueObject::CreateValueObjectFromData( + name, **data, exe_ctx, type_impl_sp->GetCompilerType(true)); + new_value_sp->SetAddressTypeOfChildren(eAddressTypeLoad); + } + sb_value.SetSP(new_value_sp); + return LLDB_RECORD_RESULT(sb_value); +} + +SBValue SBValue::GetChildAtIndex(uint32_t idx) { + LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildAtIndex, (uint32_t), idx); + + const bool can_create_synthetic = false; + lldb::DynamicValueType use_dynamic = eNoDynamicValues; + TargetSP target_sp; + if (m_opaque_sp) + target_sp = m_opaque_sp->GetTargetSP(); + + if (target_sp) + use_dynamic = target_sp->GetPreferDynamicValue(); + + 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; + + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + if (value_sp) { + const bool can_create = true; + child_sp = value_sp->GetChildAtIndex(idx, can_create); + if (can_create_synthetic && !child_sp) { + child_sp = value_sp->GetSyntheticArrayMember(idx, can_create); + } + } + + SBValue sb_value; + sb_value.SetSP(child_sp, use_dynamic, GetPreferSyntheticValue()); + + 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)); + if (value_sp) { + idx = value_sp->GetIndexOfChildWithName(ConstString(name)); + } + return idx; +} + +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) + target_sp = m_opaque_sp->GetTargetSP(); + + if (target_sp) + use_dynamic_value = target_sp->GetPreferDynamicValue(); + 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); + + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + if (value_sp) { + child_sp = value_sp->GetChildMemberWithName(str_name, true); + } + + SBValue sb_value; + sb_value.SetSP(child_sp, use_dynamic_value, GetPreferSyntheticValue()); + + 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 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(), + eNoDynamicValues, + m_opaque_sp->GetUseSynthetic())); + value_sb.SetSP(proxy_sp); + } + 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 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) + return value_sp->IsDynamic(); + return false; +} + +bool SBValue::IsSynthetic() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsSynthetic); + + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + if (value_sp) + return value_sp->IsSynthetic(); + return false; +} + +bool SBValue::IsSyntheticChildrenGenerated() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsSyntheticChildrenGenerated); + + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + if (value_sp) + return value_sp->IsSyntheticChildrenGenerated(); + return false; +} + +void SBValue::SetSyntheticChildrenGenerated(bool is) { + LLDB_RECORD_METHOD(void, SBValue, SetSyntheticChildrenGenerated, (bool), is); + + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + if (value_sp) + return value_sp->SetSyntheticChildrenGenerated(is); +} + +lldb::SBValue SBValue::GetValueForExpressionPath(const char *expr_path) { + LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetValueForExpressionPath, + (const char *), expr_path); + + lldb::ValueObjectSP child_sp; + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + if (value_sp) { + // using default values for all the fancy options, just do it if you can + child_sp = value_sp->GetValueForExpressionPath(expr_path); + } + + SBValue sb_value; + sb_value.SetSP(child_sp, GetPreferDynamicValue(), GetPreferSyntheticValue()); + + 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)); + if (value_sp) { + bool success = true; + uint64_t ret_val = fail_value; + ret_val = value_sp->GetValueAsSigned(fail_value, &success); + if (!success) + error.SetErrorString("could not resolve value"); + return ret_val; + } else + error.SetErrorStringWithFormat("could not get SBValue: %s", + locker.GetError().AsCString()); + + return 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)); + if (value_sp) { + bool success = true; + uint64_t ret_val = fail_value; + ret_val = value_sp->GetValueAsUnsigned(fail_value, &success); + if (!success) + error.SetErrorString("could not resolve value"); + return ret_val; + } else + error.SetErrorStringWithFormat("could not get SBValue: %s", + locker.GetError().AsCString()); + + return 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) { + return value_sp->GetValueAsSigned(fail_value); + } + return 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) { + return value_sp->GetValueAsUnsigned(fail_value); + } + return fail_value; +} + +bool SBValue::MightHaveChildren() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, MightHaveChildren); + + bool has_children = false; + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + if (value_sp) + has_children = value_sp->MightHaveChildren(); + + return has_children; +} + +bool SBValue::IsRuntimeSupportValue() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsRuntimeSupportValue); + + bool is_support = false; + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + if (value_sp) + is_support = value_sp->IsRuntimeSupportValue(); + + return is_support; +} + +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; + + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + if (value_sp) + num_children = value_sp->GetNumChildren(max); + + return num_children; +} + +SBValue SBValue::Dereference() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, Dereference); + + SBValue sb_value; + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + if (value_sp) { + Status error; + sb_value = value_sp->Dereference(error); + } + + return LLDB_RECORD_RESULT(sb_value); +} + +// Deprecated - please use GetType().IsPointerType() instead. +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) + return value_sp->GetCompilerType().GetOpaqueQualType(); + return nullptr; +} + +lldb::SBTarget SBValue::GetTarget() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBValue, GetTarget); + + SBTarget sb_target; + TargetSP target_sp; + if (m_opaque_sp) { + target_sp = m_opaque_sp->GetTargetSP(); + sb_target.SetSP(target_sp); + } + + 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) { + process_sp = m_opaque_sp->GetProcessSP(); + sb_process.SetSP(process_sp); + } + + 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) { + thread_sp = m_opaque_sp->GetThreadSP(); + sb_thread.SetThread(thread_sp); + } + + 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) { + frame_sp = m_opaque_sp->GetFrameSP(); + sb_frame.SetFrameSP(frame_sp); + } + + return LLDB_RECORD_RESULT(sb_frame); +} + +lldb::ValueObjectSP SBValue::GetSP(ValueLocker &locker) const { + if (!m_opaque_sp || !m_opaque_sp->IsValid()) { + locker.GetError().SetErrorString("No value"); + return ValueObjectSP(); + } + return locker.GetLockedSP(*m_opaque_sp.get()); +} + +lldb::ValueObjectSP SBValue::GetSP() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ValueObjectSP, SBValue, GetSP); + + ValueLocker locker; + return LLDB_RECORD_RESULT(GetSP(locker)); +} + +void SBValue::SetSP(ValueImplSP impl_sp) { m_opaque_sp = impl_sp; } + +void SBValue::SetSP(const lldb::ValueObjectSP &sp) { + if (sp) { + lldb::TargetSP target_sp(sp->GetTargetSP()); + if (target_sp) { + lldb::DynamicValueType use_dynamic = target_sp->GetPreferDynamicValue(); + bool use_synthetic = + target_sp->TargetProperties::GetEnableSyntheticValue(); + m_opaque_sp = ValueImplSP(new ValueImpl(sp, use_dynamic, use_synthetic)); + } else + m_opaque_sp = ValueImplSP(new ValueImpl(sp, eNoDynamicValues, true)); + } else + m_opaque_sp = ValueImplSP(new ValueImpl(sp, eNoDynamicValues, false)); +} + +void SBValue::SetSP(const lldb::ValueObjectSP &sp, + lldb::DynamicValueType use_dynamic) { + if (sp) { + lldb::TargetSP target_sp(sp->GetTargetSP()); + if (target_sp) { + bool use_synthetic = + target_sp->TargetProperties::GetEnableSyntheticValue(); + SetSP(sp, use_dynamic, use_synthetic); + } else + SetSP(sp, use_dynamic, true); + } else + SetSP(sp, use_dynamic, false); +} + +void SBValue::SetSP(const lldb::ValueObjectSP &sp, bool use_synthetic) { + if (sp) { + lldb::TargetSP target_sp(sp->GetTargetSP()); + if (target_sp) { + lldb::DynamicValueType use_dynamic = target_sp->GetPreferDynamicValue(); + SetSP(sp, use_dynamic, use_synthetic); + } else + SetSP(sp, eNoDynamicValues, use_synthetic); + } else + SetSP(sp, eNoDynamicValues, use_synthetic); +} + +void SBValue::SetSP(const lldb::ValueObjectSP &sp, + lldb::DynamicValueType use_dynamic, bool use_synthetic) { + m_opaque_sp = ValueImplSP(new ValueImpl(sp, use_dynamic, use_synthetic)); +} + +void SBValue::SetSP(const lldb::ValueObjectSP &sp, + lldb::DynamicValueType use_dynamic, bool use_synthetic, + const char *name) { + m_opaque_sp = + ValueImplSP(new ValueImpl(sp, use_dynamic, use_synthetic, name)); +} + +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) { + value_sp->GetExpressionPath(description.ref()); + return true; + } + return false; +} + +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) { + value_sp->GetExpressionPath(description.ref()); + return true; + } + return false; +} + +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 LLDB_RECORD_RESULT(SBValue()); + + lldb::TargetSP target_sp = value_sp->GetTargetSP(); + if (!target_sp) + return LLDB_RECORD_RESULT(SBValue()); + + lldb::SBExpressionOptions options; + options.SetFetchDynamicValue(target_sp->GetPreferDynamicValue()); + options.SetUnwindOnError(true); + options.SetIgnoreBreakpoints(true); + + return LLDB_RECORD_RESULT(EvaluateExpression(expr, options, nullptr)); +} + +lldb::SBValue +SBValue::EvaluateExpression(const char *expr, + const SBExpressionOptions &options) const { + LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValue, EvaluateExpression, + (const char *, const lldb::SBExpressionOptions &), + expr, options); + + 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); + + + if (!expr || expr[0] == '\0') { + return LLDB_RECORD_RESULT(SBValue()); + } + + + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + if (!value_sp) { + return LLDB_RECORD_RESULT(SBValue()); + } + + lldb::TargetSP target_sp = value_sp->GetTargetSP(); + if (!target_sp) { + return LLDB_RECORD_RESULT(SBValue()); + } + + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + ExecutionContext exe_ctx(target_sp.get()); + + StackFrame *frame = exe_ctx.GetFramePtr(); + if (!frame) { + return LLDB_RECORD_RESULT(SBValue()); + } + + ValueObjectSP res_val_sp; + target_sp->EvaluateExpression(expr, frame, res_val_sp, options.ref(), nullptr, + value_sp.get()); + + if (name) + res_val_sp->SetName(ConstString(name)); + + SBValue result; + result.SetSP(res_val_sp, options.GetFetchDynamicValue()); + return LLDB_RECORD_RESULT(result); +} + +bool SBValue::GetDescription(SBStream &description) { + LLDB_RECORD_METHOD(bool, SBValue, GetDescription, (lldb::SBStream &), + description); + + Stream &strm = description.ref(); + + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + if (value_sp) + value_sp->Dump(strm); + else + strm.PutCString("No value"); + + return true; +} + +lldb::Format SBValue::GetFormat() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::Format, SBValue, GetFormat); + + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + if (value_sp) + return value_sp->GetFormat(); + return eFormatDefault; +} + +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) + value_sp->SetFormat(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)); + if (value_sp) { + Status error; + sb_value.SetSP(value_sp->AddressOf(error), GetPreferDynamicValue(), + GetPreferSyntheticValue()); + } + + 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)); + if (value_sp) { + TargetSP target_sp(value_sp->GetTargetSP()); + if (target_sp) { + const bool scalar_is_load_address = true; + AddressType addr_type; + value = value_sp->GetAddressOf(scalar_is_load_address, &addr_type); + if (addr_type == eAddressTypeFile) { + ModuleSP module_sp(value_sp->GetModule()); + if (!module_sp) + value = LLDB_INVALID_ADDRESS; + else { + Address addr; + module_sp->ResolveFileAddress(value, addr); + value = addr.GetLoadAddress(target_sp.get()); + } + } else if (addr_type == eAddressTypeHost || + addr_type == eAddressTypeInvalid) + value = LLDB_INVALID_ADDRESS; + } + } + + return value; +} + +lldb::SBAddress SBValue::GetAddress() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBValue, GetAddress); + + Address addr; + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + if (value_sp) { + TargetSP target_sp(value_sp->GetTargetSP()); + if (target_sp) { + lldb::addr_t value = LLDB_INVALID_ADDRESS; + const bool scalar_is_load_address = true; + AddressType addr_type; + value = value_sp->GetAddressOf(scalar_is_load_address, &addr_type); + if (addr_type == eAddressTypeFile) { + ModuleSP module_sp(value_sp->GetModule()); + if (module_sp) + module_sp->ResolveFileAddress(value, addr); + } else if (addr_type == eAddressTypeLoad) { + // no need to check the return value on this.. if it can actually do + // the resolve addr will be in the form (section,offset), otherwise it + // will simply be returned as (NULL, value) + addr.SetLoadAddress(value, target_sp.get()); + } + } + } + + 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); + + lldb::SBData sb_data; + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + if (value_sp) { + TargetSP target_sp(value_sp->GetTargetSP()); + if (target_sp) { + DataExtractorSP data_sp(new DataExtractor()); + value_sp->GetPointeeData(*data_sp, item_idx, item_count); + if (data_sp->GetByteSize() > 0) + *sb_data = data_sp; + } + } + + return LLDB_RECORD_RESULT(sb_data); +} + +lldb::SBData SBValue::GetData() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBData, SBValue, GetData); + + lldb::SBData sb_data; + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + if (value_sp) { + DataExtractorSP data_sp(new DataExtractor()); + Status error; + value_sp->GetData(*data_sp, error); + if (error.Success()) + *sb_data = data_sp; + } + + 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); + + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + bool ret = true; + + if (value_sp) { + DataExtractor *data_extractor = data.get(); + + if (!data_extractor) { + error.SetErrorString("No data to set"); + ret = false; + } else { + Status set_error; + + value_sp->SetData(*data_extractor, set_error); + + if (!set_error.Success()) { + error.SetErrorStringWithFormat("Couldn't set data: %s", + set_error.AsCString()); + ret = false; + } + } + } else { + error.SetErrorStringWithFormat( + "Couldn't set data: could not get SBValue: %s", + locker.GetError().AsCString()); + ret = false; + } + + return ret; +} + +lldb::SBDeclaration SBValue::GetDeclaration() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBDeclaration, SBValue, GetDeclaration); + + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + SBDeclaration decl_sb; + if (value_sp) { + Declaration decl; + if (value_sp->GetDeclaration(decl)) + decl_sb.SetDeclaration(decl); + } + 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. + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + TargetSP target_sp(GetTarget().GetSP()); + if (value_sp && target_sp) { + // Read and Write cannot both be false. + if (!read && !write) + return LLDB_RECORD_RESULT(sb_watchpoint); + + // If the value is not in scope, don't try and watch and invalid value + if (!IsInScope()) + return LLDB_RECORD_RESULT(sb_watchpoint); + + addr_t addr = GetLoadAddress(); + if (addr == LLDB_INVALID_ADDRESS) + return LLDB_RECORD_RESULT(sb_watchpoint); + size_t byte_size = GetByteSize(); + if (byte_size == 0) + return LLDB_RECORD_RESULT(sb_watchpoint); + + uint32_t watch_type = 0; + if (read) + watch_type |= LLDB_WATCH_TYPE_READ; + if (write) + watch_type |= LLDB_WATCH_TYPE_WRITE; + + Status rc; + CompilerType type(value_sp->GetCompilerType()); + WatchpointSP watchpoint_sp = + target_sp->CreateWatchpoint(addr, byte_size, &type, watch_type, rc); + error.SetError(rc); + + if (watchpoint_sp) { + sb_watchpoint.SetSP(watchpoint_sp); + Declaration decl; + if (value_sp->GetDeclaration(decl)) { + if (decl.GetFile()) { + StreamString ss; + // True to show fullpath for declaration file. + decl.DumpStopContext(&ss, true); + watchpoint_sp->SetDeclInfo(std::string(ss.GetString())); + } + } + } + } else if (target_sp) { + error.SetErrorStringWithFormat("could not get SBValue: %s", + locker.GetError().AsCString()); + } else { + error.SetErrorString("could not set watchpoint, a target is required"); + } + + return LLDB_RECORD_RESULT(sb_watchpoint); +} + +// FIXME: Remove this method impl (as well as the decl in .h) once it is no +// longer needed. +// 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 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 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 LLDB_RECORD_RESULT(persisted_sb); +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBValue>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBValue, ()); + LLDB_REGISTER_CONSTRUCTOR(SBValue, (const lldb::ValueObjectSP &)); + LLDB_REGISTER_CONSTRUCTOR(SBValue, (const lldb::SBValue &)); + LLDB_REGISTER_METHOD(lldb::SBValue &, + SBValue, operator=,(const lldb::SBValue &)); + LLDB_REGISTER_METHOD(bool, SBValue, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBValue, operator bool, ()); + LLDB_REGISTER_METHOD(void, SBValue, Clear, ()); + LLDB_REGISTER_METHOD(lldb::SBError, SBValue, GetError, ()); + LLDB_REGISTER_METHOD(lldb::user_id_t, SBValue, GetID, ()); + LLDB_REGISTER_METHOD(const char *, SBValue, GetName, ()); + LLDB_REGISTER_METHOD(const char *, SBValue, GetTypeName, ()); + LLDB_REGISTER_METHOD(const char *, SBValue, GetDisplayTypeName, ()); + LLDB_REGISTER_METHOD(size_t, SBValue, GetByteSize, ()); + LLDB_REGISTER_METHOD(bool, SBValue, IsInScope, ()); + LLDB_REGISTER_METHOD(const char *, SBValue, GetValue, ()); + LLDB_REGISTER_METHOD(lldb::ValueType, SBValue, GetValueType, ()); + LLDB_REGISTER_METHOD(const char *, SBValue, GetObjectDescription, ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBValue, GetType, ()); + LLDB_REGISTER_METHOD(bool, SBValue, GetValueDidChange, ()); + LLDB_REGISTER_METHOD(const char *, SBValue, GetSummary, ()); + LLDB_REGISTER_METHOD(const char *, SBValue, GetSummary, + (lldb::SBStream &, lldb::SBTypeSummaryOptions &)); + LLDB_REGISTER_METHOD(const char *, SBValue, GetLocation, ()); + LLDB_REGISTER_METHOD(bool, SBValue, SetValueFromCString, (const char *)); + LLDB_REGISTER_METHOD(bool, SBValue, SetValueFromCString, + (const char *, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBValue, GetTypeFormat, ()); + LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBValue, GetTypeSummary, ()); + LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBValue, GetTypeFilter, ()); + LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBValue, GetTypeSynthetic, ()); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, CreateChildAtOffset, + (const char *, uint32_t, lldb::SBType)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, Cast, (lldb::SBType)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, CreateValueFromExpression, + (const char *, const char *)); + LLDB_REGISTER_METHOD( + lldb::SBValue, SBValue, CreateValueFromExpression, + (const char *, const char *, lldb::SBExpressionOptions &)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, CreateValueFromAddress, + (const char *, lldb::addr_t, lldb::SBType)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, CreateValueFromData, + (const char *, lldb::SBData, lldb::SBType)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetChildAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetChildAtIndex, + (uint32_t, lldb::DynamicValueType, bool)); + LLDB_REGISTER_METHOD(uint32_t, SBValue, GetIndexOfChildWithName, + (const char *)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName, + (const char *)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName, + (const char *, lldb::DynamicValueType)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetDynamicValue, + (lldb::DynamicValueType)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetStaticValue, ()); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetNonSyntheticValue, ()); + LLDB_REGISTER_METHOD(lldb::DynamicValueType, SBValue, GetPreferDynamicValue, + ()); + LLDB_REGISTER_METHOD(void, SBValue, SetPreferDynamicValue, + (lldb::DynamicValueType)); + LLDB_REGISTER_METHOD(bool, SBValue, GetPreferSyntheticValue, ()); + LLDB_REGISTER_METHOD(void, SBValue, SetPreferSyntheticValue, (bool)); + LLDB_REGISTER_METHOD(bool, SBValue, IsDynamic, ()); + LLDB_REGISTER_METHOD(bool, SBValue, IsSynthetic, ()); + LLDB_REGISTER_METHOD(bool, SBValue, IsSyntheticChildrenGenerated, ()); + LLDB_REGISTER_METHOD(void, SBValue, SetSyntheticChildrenGenerated, (bool)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetValueForExpressionPath, + (const char *)); + LLDB_REGISTER_METHOD(int64_t, SBValue, GetValueAsSigned, + (lldb::SBError &, int64_t)); + LLDB_REGISTER_METHOD(uint64_t, SBValue, GetValueAsUnsigned, + (lldb::SBError &, uint64_t)); + LLDB_REGISTER_METHOD(int64_t, SBValue, GetValueAsSigned, (int64_t)); + LLDB_REGISTER_METHOD(uint64_t, SBValue, GetValueAsUnsigned, (uint64_t)); + LLDB_REGISTER_METHOD(bool, SBValue, MightHaveChildren, ()); + LLDB_REGISTER_METHOD(bool, SBValue, IsRuntimeSupportValue, ()); + LLDB_REGISTER_METHOD(uint32_t, SBValue, GetNumChildren, ()); + LLDB_REGISTER_METHOD(uint32_t, SBValue, GetNumChildren, (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, Dereference, ()); + LLDB_REGISTER_METHOD(bool, SBValue, TypeIsPointerType, ()); + LLDB_REGISTER_METHOD(void *, SBValue, GetOpaqueType, ()); + LLDB_REGISTER_METHOD(lldb::SBTarget, SBValue, GetTarget, ()); + LLDB_REGISTER_METHOD(lldb::SBProcess, SBValue, GetProcess, ()); + LLDB_REGISTER_METHOD(lldb::SBThread, SBValue, GetThread, ()); + LLDB_REGISTER_METHOD(lldb::SBFrame, SBValue, GetFrame, ()); + LLDB_REGISTER_METHOD_CONST(lldb::ValueObjectSP, SBValue, GetSP, ()); + LLDB_REGISTER_METHOD(bool, SBValue, GetExpressionPath, (lldb::SBStream &)); + LLDB_REGISTER_METHOD(bool, SBValue, GetExpressionPath, + (lldb::SBStream &, bool)); + LLDB_REGISTER_METHOD_CONST(lldb::SBValue, SBValue, EvaluateExpression, + (const char *)); + LLDB_REGISTER_METHOD_CONST( + lldb::SBValue, SBValue, EvaluateExpression, + (const char *, const lldb::SBExpressionOptions &)); + LLDB_REGISTER_METHOD_CONST( + lldb::SBValue, SBValue, EvaluateExpression, + (const char *, const lldb::SBExpressionOptions &, const char *)); + LLDB_REGISTER_METHOD(bool, SBValue, GetDescription, (lldb::SBStream &)); + LLDB_REGISTER_METHOD(lldb::Format, SBValue, GetFormat, ()); + LLDB_REGISTER_METHOD(void, SBValue, SetFormat, (lldb::Format)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, AddressOf, ()); + LLDB_REGISTER_METHOD(lldb::addr_t, SBValue, GetLoadAddress, ()); + LLDB_REGISTER_METHOD(lldb::SBAddress, SBValue, GetAddress, ()); + LLDB_REGISTER_METHOD(lldb::SBData, SBValue, GetPointeeData, + (uint32_t, uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBData, SBValue, GetData, ()); + LLDB_REGISTER_METHOD(bool, SBValue, SetData, + (lldb::SBData &, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBDeclaration, SBValue, GetDeclaration, ()); + LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBValue, Watch, + (bool, bool, bool, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBValue, Watch, + (bool, bool, bool)); + LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBValue, WatchPointee, + (bool, bool, bool, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, Persist, ()); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBValueList.cpp b/contrib/llvm-project/lldb/source/API/SBValueList.cpp new file mode 100644 index 000000000000..0fd2a591c321 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBValueList.cpp @@ -0,0 +1,231 @@ +//===-- SBValueList.cpp ---------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBValueList.h" +#include "SBReproducerPrivate.h" +#include "lldb/API/SBStream.h" +#include "lldb/API/SBValue.h" +#include "lldb/Core/ValueObjectList.h" + +#include <vector> + +using namespace lldb; +using namespace lldb_private; + +class ValueListImpl { +public: + ValueListImpl() : m_values() {} + + ValueListImpl(const ValueListImpl &rhs) : m_values(rhs.m_values) {} + + ValueListImpl &operator=(const ValueListImpl &rhs) { + if (this == &rhs) + return *this; + m_values = rhs.m_values; + return *this; + } + + uint32_t GetSize() { return m_values.size(); } + + void Append(const lldb::SBValue &sb_value) { m_values.push_back(sb_value); } + + void Append(const ValueListImpl &list) { + for (auto val : list.m_values) + Append(val); + } + + lldb::SBValue GetValueAtIndex(uint32_t index) { + if (index >= GetSize()) + return lldb::SBValue(); + return m_values[index]; + } + + lldb::SBValue FindValueByUID(lldb::user_id_t uid) { + for (auto val : m_values) { + if (val.IsValid() && val.GetID() == uid) + return val; + } + return lldb::SBValue(); + } + + lldb::SBValue GetFirstValueByName(const char *name) const { + if (name) { + for (auto val : m_values) { + if (val.IsValid() && val.GetName() && strcmp(name, val.GetName()) == 0) + return val; + } + } + return lldb::SBValue(); + } + +private: + std::vector<lldb::SBValue> m_values; +}; + +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); + + if (rhs.IsValid()) + m_opaque_up = std::make_unique<ValueListImpl>(*rhs); +} + +SBValueList::SBValueList(const ValueListImpl *lldb_object_ptr) : m_opaque_up() { + if (lldb_object_ptr) + m_opaque_up = std::make_unique<ValueListImpl>(*lldb_object_ptr); +} + +SBValueList::~SBValueList() = default; + +bool SBValueList::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBValueList, IsValid); + return this->operator bool(); +} +SBValueList::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBValueList, operator bool); + + return (m_opaque_up != nullptr); +} + +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 = std::make_unique<ValueListImpl>(*rhs); + else + m_opaque_up.reset(); + } + return LLDB_RECORD_RESULT(*this); +} + +ValueListImpl *SBValueList::operator->() { return m_opaque_up.get(); } + +ValueListImpl &SBValueList::operator*() { return *m_opaque_up; } + +const ValueListImpl *SBValueList::operator->() const { + return m_opaque_up.get(); +} + +const ValueListImpl &SBValueList::operator*() const { return *m_opaque_up; } + +void SBValueList::Append(const SBValue &val_obj) { + LLDB_RECORD_METHOD(void, SBValueList, Append, (const lldb::SBValue &), + val_obj); + + CreateIfNeeded(); + m_opaque_up->Append(val_obj); +} + +void SBValueList::Append(lldb::ValueObjectSP &val_obj_sp) { + if (val_obj_sp) { + CreateIfNeeded(); + m_opaque_up->Append(SBValue(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); + } +} + +SBValue SBValueList::GetValueAtIndex(uint32_t idx) const { + LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValueList, GetValueAtIndex, + (uint32_t), idx); + + + SBValue sb_value; + if (m_opaque_up) + sb_value = m_opaque_up->GetValueAtIndex(idx); + + return LLDB_RECORD_RESULT(sb_value); +} + +uint32_t SBValueList::GetSize() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBValueList, GetSize); + + uint32_t size = 0; + if (m_opaque_up) + size = m_opaque_up->GetSize(); + + return size; +} + +void SBValueList::CreateIfNeeded() { + if (m_opaque_up == nullptr) + m_opaque_up = std::make_unique<ValueListImpl>(); +} + +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 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 LLDB_RECORD_RESULT(sb_value); +} + +void *SBValueList::opaque_ptr() { return m_opaque_up.get(); } + +ValueListImpl &SBValueList::ref() { + CreateIfNeeded(); + return *m_opaque_up; +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBValueList>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBValueList, ()); + LLDB_REGISTER_CONSTRUCTOR(SBValueList, (const lldb::SBValueList &)); + LLDB_REGISTER_METHOD_CONST(bool, SBValueList, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBValueList, operator bool, ()); + LLDB_REGISTER_METHOD(void, SBValueList, Clear, ()); + LLDB_REGISTER_METHOD(const lldb::SBValueList &, + SBValueList, operator=,(const lldb::SBValueList &)); + LLDB_REGISTER_METHOD(void, SBValueList, Append, (const lldb::SBValue &)); + LLDB_REGISTER_METHOD(void, SBValueList, Append, + (const lldb::SBValueList &)); + LLDB_REGISTER_METHOD_CONST(lldb::SBValue, SBValueList, GetValueAtIndex, + (uint32_t)); + LLDB_REGISTER_METHOD_CONST(uint32_t, SBValueList, GetSize, ()); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValueList, FindValueObjectByUID, + (lldb::user_id_t)); + LLDB_REGISTER_METHOD_CONST(lldb::SBValue, SBValueList, GetFirstValueByName, + (const char *)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBVariablesOptions.cpp b/contrib/llvm-project/lldb/source/API/SBVariablesOptions.cpp new file mode 100644 index 000000000000..4ef16364e628 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBVariablesOptions.cpp @@ -0,0 +1,275 @@ +//===-- SBVariablesOptions.cpp --------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBVariablesOptions.h" +#include "SBReproducerPrivate.h" +#include "lldb/API/SBTarget.h" +#include "lldb/Target/Target.h" + +#include "lldb/lldb-private.h" + +using namespace lldb; +using namespace lldb_private; + +class VariablesOptionsImpl { +public: + VariablesOptionsImpl() + : m_include_arguments(false), m_include_locals(false), + m_include_statics(false), m_in_scope_only(false), + m_include_runtime_support_values(false), + m_include_recognized_arguments(eLazyBoolCalculate), + m_use_dynamic(lldb::eNoDynamicValues) {} + + VariablesOptionsImpl(const VariablesOptionsImpl &) = default; + + ~VariablesOptionsImpl() = default; + + VariablesOptionsImpl &operator=(const VariablesOptionsImpl &) = default; + + bool GetIncludeArguments() const { return m_include_arguments; } + + void SetIncludeArguments(bool b) { m_include_arguments = b; } + + bool GetIncludeRecognizedArguments(const lldb::TargetSP &target_sp) const { + if (m_include_recognized_arguments != eLazyBoolCalculate) + return m_include_recognized_arguments; + return target_sp ? target_sp->GetDisplayRecognizedArguments() : false; + } + + void SetIncludeRecognizedArguments(bool b) { + m_include_recognized_arguments = b ? eLazyBoolYes : eLazyBoolNo; + } + + bool GetIncludeLocals() const { return m_include_locals; } + + void SetIncludeLocals(bool b) { m_include_locals = b; } + + bool GetIncludeStatics() const { return m_include_statics; } + + void SetIncludeStatics(bool b) { m_include_statics = b; } + + bool GetInScopeOnly() const { return m_in_scope_only; } + + void SetInScopeOnly(bool b) { m_in_scope_only = b; } + + bool GetIncludeRuntimeSupportValues() const { + return m_include_runtime_support_values; + } + + void SetIncludeRuntimeSupportValues(bool b) { + m_include_runtime_support_values = b; + } + + lldb::DynamicValueType GetUseDynamic() const { return m_use_dynamic; } + + void SetUseDynamic(lldb::DynamicValueType d) { m_use_dynamic = d; } + +private: + bool m_include_arguments : 1; + bool m_include_locals : 1; + bool m_include_statics : 1; + bool m_in_scope_only : 1; + bool m_include_runtime_support_values : 1; + LazyBool m_include_recognized_arguments; // can be overridden with a setting + lldb::DynamicValueType m_use_dynamic; +}; + +SBVariablesOptions::SBVariablesOptions() + : m_opaque_up(new VariablesOptionsImpl()) { + LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBVariablesOptions); +} + +SBVariablesOptions::SBVariablesOptions(const SBVariablesOptions &options) + : 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 = std::make_unique<VariablesOptionsImpl>(options.ref()); + return LLDB_RECORD_RESULT(*this); +} + +SBVariablesOptions::~SBVariablesOptions() = default; + +bool SBVariablesOptions::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, IsValid); + return this->operator bool(); +} +SBVariablesOptions::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, operator bool); + + 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); +} + +VariablesOptionsImpl *SBVariablesOptions::operator->() { + return m_opaque_up.operator->(); +} + +const VariablesOptionsImpl *SBVariablesOptions::operator->() const { + return m_opaque_up.operator->(); +} + +VariablesOptionsImpl *SBVariablesOptions::get() { return m_opaque_up.get(); } + +VariablesOptionsImpl &SBVariablesOptions::ref() { return *m_opaque_up; } + +const VariablesOptionsImpl &SBVariablesOptions::ref() const { + return *m_opaque_up; +} + +SBVariablesOptions::SBVariablesOptions(VariablesOptionsImpl *lldb_object_ptr) + : m_opaque_up(std::move(lldb_object_ptr)) {} + +void SBVariablesOptions::SetOptions(VariablesOptionsImpl *lldb_object_ptr) { + m_opaque_up.reset(std::move(lldb_object_ptr)); +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBVariablesOptions>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBVariablesOptions, ()); + LLDB_REGISTER_CONSTRUCTOR(SBVariablesOptions, + (const lldb::SBVariablesOptions &)); + LLDB_REGISTER_METHOD( + lldb::SBVariablesOptions &, + SBVariablesOptions, operator=,(const lldb::SBVariablesOptions &)); + LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, operator bool, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetIncludeArguments, + ()); + LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetIncludeArguments, (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, + GetIncludeRecognizedArguments, + (const lldb::SBTarget &)); + LLDB_REGISTER_METHOD(void, SBVariablesOptions, + SetIncludeRecognizedArguments, (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetIncludeLocals, ()); + LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetIncludeLocals, (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetIncludeStatics, ()); + LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetIncludeStatics, (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetInScopeOnly, ()); + LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetInScopeOnly, (bool)); + LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, + GetIncludeRuntimeSupportValues, ()); + LLDB_REGISTER_METHOD(void, SBVariablesOptions, + SetIncludeRuntimeSupportValues, (bool)); + LLDB_REGISTER_METHOD_CONST(lldb::DynamicValueType, SBVariablesOptions, + GetUseDynamic, ()); + LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetUseDynamic, + (lldb::DynamicValueType)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SBWatchpoint.cpp b/contrib/llvm-project/lldb/source/API/SBWatchpoint.cpp new file mode 100644 index 000000000000..eba75dea8f8d --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBWatchpoint.cpp @@ -0,0 +1,352 @@ +//===-- SBWatchpoint.cpp --------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/API/SBWatchpoint.h" +#include "SBReproducerPrivate.h" +#include "lldb/API/SBAddress.h" +#include "lldb/API/SBDebugger.h" +#include "lldb/API/SBDefines.h" +#include "lldb/API/SBEvent.h" +#include "lldb/API/SBStream.h" + +#include "lldb/Breakpoint/Watchpoint.h" +#include "lldb/Breakpoint/WatchpointList.h" +#include "lldb/Core/StreamFile.h" +#include "lldb/Target/Process.h" +#include "lldb/Target/Target.h" +#include "lldb/Utility/Stream.h" +#include "lldb/lldb-defines.h" +#include "lldb/lldb-types.h" + +using namespace lldb; +using namespace lldb_private; + +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); +} + +SBWatchpoint::SBWatchpoint(const SBWatchpoint &rhs) + : 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 LLDB_RECORD_RESULT(*this); +} + +SBWatchpoint::~SBWatchpoint() = default; + +watch_id_t SBWatchpoint::GetID() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::watch_id_t, SBWatchpoint, GetID); + + + watch_id_t watch_id = LLDB_INVALID_WATCH_ID; + lldb::WatchpointSP watchpoint_sp(GetSP()); + if (watchpoint_sp) + watch_id = watchpoint_sp->GetID(); + + return watch_id; +} + +bool SBWatchpoint::IsValid() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBWatchpoint, IsValid); + return this->operator bool(); +} +SBWatchpoint::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBWatchpoint, operator bool); + + return bool(m_opaque_wp.lock()); +} + +bool SBWatchpoint::operator==(const SBWatchpoint &rhs) const { + LLDB_RECORD_METHOD_CONST( + bool, SBWatchpoint, operator==,(const SBWatchpoint &), rhs); + + return GetSP() == rhs.GetSP(); +} + +bool SBWatchpoint::operator!=(const SBWatchpoint &rhs) const { + LLDB_RECORD_METHOD_CONST( + bool, SBWatchpoint, operator!=,(const SBWatchpoint &), rhs); + + return !(*this == rhs); +} + +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 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()); + if (watchpoint_sp) { + std::lock_guard<std::recursive_mutex> guard( + watchpoint_sp->GetTarget().GetAPIMutex()); + hw_index = watchpoint_sp->GetHardwareIndex(); + } + + return hw_index; +} + +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()); + if (watchpoint_sp) { + std::lock_guard<std::recursive_mutex> guard( + watchpoint_sp->GetTarget().GetAPIMutex()); + ret_addr = watchpoint_sp->GetLoadAddress(); + } + + return ret_addr; +} + +size_t SBWatchpoint::GetWatchSize() { + LLDB_RECORD_METHOD_NO_ARGS(size_t, SBWatchpoint, GetWatchSize); + + size_t watch_size = 0; + + lldb::WatchpointSP watchpoint_sp(GetSP()); + if (watchpoint_sp) { + std::lock_guard<std::recursive_mutex> guard( + watchpoint_sp->GetTarget().GetAPIMutex()); + watch_size = watchpoint_sp->GetByteSize(); + } + + return watch_size; +} + +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(); + std::lock_guard<std::recursive_mutex> guard(target.GetAPIMutex()); + ProcessSP process_sp = target.GetProcessSP(); + const bool notify = true; + if (process_sp) { + if (enabled) + process_sp->EnableWatchpoint(watchpoint_sp.get(), notify); + else + process_sp->DisableWatchpoint(watchpoint_sp.get(), notify); + } else { + watchpoint_sp->SetEnabled(enabled, notify); + } + } +} + +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( + watchpoint_sp->GetTarget().GetAPIMutex()); + return watchpoint_sp->IsEnabled(); + } else + return false; +} + +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) { + std::lock_guard<std::recursive_mutex> guard( + watchpoint_sp->GetTarget().GetAPIMutex()); + count = watchpoint_sp->GetHitCount(); + } + + return count; +} + +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( + watchpoint_sp->GetTarget().GetAPIMutex()); + return watchpoint_sp->GetIgnoreCount(); + } else + return 0; +} + +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( + watchpoint_sp->GetTarget().GetAPIMutex()); + watchpoint_sp->SetIgnoreCount(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( + watchpoint_sp->GetTarget().GetAPIMutex()); + return watchpoint_sp->GetConditionText(); + } + return nullptr; +} + +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( + watchpoint_sp->GetTarget().GetAPIMutex()); + watchpoint_sp->SetCondition(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()); + if (watchpoint_sp) { + std::lock_guard<std::recursive_mutex> guard( + watchpoint_sp->GetTarget().GetAPIMutex()); + watchpoint_sp->GetDescription(&strm, level); + strm.EOL(); + } else + strm.PutCString("No value"); + + return true; +} + +void SBWatchpoint::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBWatchpoint, Clear); + + m_opaque_wp.reset(); +} + +lldb::WatchpointSP SBWatchpoint::GetSP() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::WatchpointSP, SBWatchpoint, GetSP); + + 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()) != + nullptr; +} + +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()); + return eWatchpointEventTypeInvalidType; +} + +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 LLDB_RECORD_RESULT(sb_watchpoint); +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBWatchpoint>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBWatchpoint, ()); + LLDB_REGISTER_CONSTRUCTOR(SBWatchpoint, (const lldb::WatchpointSP &)); + LLDB_REGISTER_CONSTRUCTOR(SBWatchpoint, (const lldb::SBWatchpoint &)); + LLDB_REGISTER_METHOD(const lldb::SBWatchpoint &, + SBWatchpoint, operator=,(const lldb::SBWatchpoint &)); + LLDB_REGISTER_METHOD(lldb::watch_id_t, SBWatchpoint, GetID, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBWatchpoint, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBWatchpoint, operator bool, ()); + LLDB_REGISTER_METHOD_CONST( + bool, SBWatchpoint, operator==,(const lldb::SBWatchpoint &)); + LLDB_REGISTER_METHOD_CONST( + bool, SBWatchpoint, operator!=,(const lldb::SBWatchpoint &)); + LLDB_REGISTER_METHOD(lldb::SBError, SBWatchpoint, GetError, ()); + LLDB_REGISTER_METHOD(int32_t, SBWatchpoint, GetHardwareIndex, ()); + LLDB_REGISTER_METHOD(lldb::addr_t, SBWatchpoint, GetWatchAddress, ()); + LLDB_REGISTER_METHOD(size_t, SBWatchpoint, GetWatchSize, ()); + LLDB_REGISTER_METHOD(void, SBWatchpoint, SetEnabled, (bool)); + LLDB_REGISTER_METHOD(bool, SBWatchpoint, IsEnabled, ()); + LLDB_REGISTER_METHOD(uint32_t, SBWatchpoint, GetHitCount, ()); + LLDB_REGISTER_METHOD(uint32_t, SBWatchpoint, GetIgnoreCount, ()); + LLDB_REGISTER_METHOD(void, SBWatchpoint, SetIgnoreCount, (uint32_t)); + LLDB_REGISTER_METHOD(const char *, SBWatchpoint, GetCondition, ()); + LLDB_REGISTER_METHOD(void, SBWatchpoint, SetCondition, (const char *)); + LLDB_REGISTER_METHOD(bool, SBWatchpoint, GetDescription, + (lldb::SBStream &, lldb::DescriptionLevel)); + LLDB_REGISTER_METHOD(void, SBWatchpoint, Clear, ()); + LLDB_REGISTER_METHOD_CONST(lldb::WatchpointSP, SBWatchpoint, GetSP, ()); + LLDB_REGISTER_METHOD(void, SBWatchpoint, SetSP, + (const lldb::WatchpointSP &)); + LLDB_REGISTER_STATIC_METHOD(bool, SBWatchpoint, EventIsWatchpointEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_STATIC_METHOD(lldb::WatchpointEventType, SBWatchpoint, + GetWatchpointEventTypeFromEvent, + (const lldb::SBEvent &)); + LLDB_REGISTER_STATIC_METHOD(lldb::SBWatchpoint, SBWatchpoint, + GetWatchpointFromEvent, + (const lldb::SBEvent &)); +} + +} +} diff --git a/contrib/llvm-project/lldb/source/API/SystemInitializerFull.cpp b/contrib/llvm-project/lldb/source/API/SystemInitializerFull.cpp new file mode 100644 index 000000000000..7f95e7acf62a --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SystemInitializerFull.cpp @@ -0,0 +1,72 @@ +//===-- SystemInitializerFull.cpp -----------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "SystemInitializerFull.h" +#include "lldb/API/SBCommandInterpreter.h" +#include "lldb/Core/Debugger.h" +#include "lldb/Core/PluginManager.h" +#include "lldb/Host/Config.h" +#include "lldb/Host/Host.h" +#include "lldb/Initialization/SystemInitializerCommon.h" +#include "lldb/Interpreter/CommandInterpreter.h" +#include "lldb/Utility/Timer.h" +#include "llvm/Support/TargetSelect.h" + +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wglobal-constructors" +#include "llvm/ExecutionEngine/MCJIT.h" +#pragma clang diagnostic pop + +#include <string> + +#define LLDB_PLUGIN(p) LLDB_PLUGIN_DECLARE(p) +#include "Plugins/Plugins.def" + +using namespace lldb_private; + +SystemInitializerFull::SystemInitializerFull() = default; +SystemInitializerFull::~SystemInitializerFull() = default; + +llvm::Error SystemInitializerFull::Initialize() { + if (auto e = SystemInitializerCommon::Initialize()) + return e; + + // Initialize LLVM and Clang + llvm::InitializeAllTargets(); + llvm::InitializeAllAsmPrinters(); + llvm::InitializeAllTargetMCs(); + llvm::InitializeAllDisassemblers(); + +#define LLDB_PLUGIN(p) LLDB_PLUGIN_INITIALIZE(p); +#include "Plugins/Plugins.def" + + // Scan for any system or user LLDB plug-ins + PluginManager::Initialize(); + + // The process settings need to know about installed plug-ins, so the + // Settings must be initialized AFTER PluginManager::Initialize is called. + Debugger::SettingsInitialize(); + + return llvm::Error::success(); +} + +void SystemInitializerFull::Terminate() { + static Timer::Category func_cat(LLVM_PRETTY_FUNCTION); + Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION); + + Debugger::SettingsTerminate(); + + // Terminate and unload and loaded system or user LLDB plug-ins + PluginManager::Terminate(); + +#define LLDB_PLUGIN(p) LLDB_PLUGIN_TERMINATE(p); +#include "Plugins/Plugins.def" + + // Now shutdown the common parts, in reverse order. + SystemInitializerCommon::Terminate(); +} diff --git a/contrib/llvm-project/lldb/source/API/SystemInitializerFull.h b/contrib/llvm-project/lldb/source/API/SystemInitializerFull.h new file mode 100644 index 000000000000..7cab6cb97533 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SystemInitializerFull.h @@ -0,0 +1,32 @@ +//===-- SystemInitializerFull.h ---------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLDB_SOURCE_API_SYSTEMINITIALIZERFULL_H +#define LLDB_SOURCE_API_SYSTEMINITIALIZERFULL_H + +#include "lldb/Initialization/SystemInitializerCommon.h" + +namespace lldb_private { +/// Initializes lldb. +/// +/// This class is responsible for initializing all of lldb system +/// services needed to use the full LLDB application. This class is +/// not intended to be used externally, but is instead used +/// internally by SBDebugger to initialize the system. +class SystemInitializerFull : public SystemInitializerCommon { +public: + SystemInitializerFull(); + ~SystemInitializerFull() override; + + llvm::Error Initialize() override; + void Terminate() override; +}; + +} // namespace lldb_private + +#endif // LLDB_SOURCE_API_SYSTEMINITIALIZERFULL_H diff --git a/contrib/llvm-project/lldb/source/API/Utils.h b/contrib/llvm-project/lldb/source/API/Utils.h new file mode 100644 index 000000000000..4201e825c446 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/Utils.h @@ -0,0 +1,30 @@ +//===-- Utils.h -------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLDB_SOURCE_API_UTILS_H +#define LLDB_SOURCE_API_UTILS_H + +#include "llvm/ADT/STLExtras.h" +#include <memory> + +namespace lldb_private { + +template <typename T> std::unique_ptr<T> clone(const std::unique_ptr<T> &src) { + if (src) + return std::make_unique<T>(*src); + return nullptr; +} + +template <typename T> std::shared_ptr<T> clone(const std::shared_ptr<T> &src) { + if (src) + return std::make_shared<T>(*src); + return nullptr; +} + +} // namespace lldb_private +#endif diff --git a/contrib/llvm-project/lldb/source/API/liblldb-private.exports b/contrib/llvm-project/lldb/source/API/liblldb-private.exports new file mode 100644 index 000000000000..9b3d86dfc892 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/liblldb-private.exports @@ -0,0 +1,6 @@ +_ZN4lldb* +_ZNK4lldb* +_ZN12lldb_private* +_ZNK12lldb_private* +init_lld* +PyInit__lldb* diff --git a/contrib/llvm-project/lldb/source/API/liblldb.exports b/contrib/llvm-project/lldb/source/API/liblldb.exports new file mode 100644 index 000000000000..3ceb562c7ed1 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/liblldb.exports @@ -0,0 +1,4 @@ +_ZN4lldb* +_ZNK4lldb* +init_lld* +PyInit__lldb* diff --git a/contrib/llvm-project/lldb/source/API/liblldb.xcode.exports b/contrib/llvm-project/lldb/source/API/liblldb.xcode.exports new file mode 100644 index 000000000000..9c194fa6ff67 --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/liblldb.xcode.exports @@ -0,0 +1,3 @@ +__ZN4lldb* +__ZNK4lldb* +_init_lld* |