diff options
Diffstat (limited to 'source/API/SBSymbolContext.cpp')
| -rw-r--r-- | source/API/SBSymbolContext.cpp | 236 |
1 files changed, 146 insertions, 90 deletions
diff --git a/source/API/SBSymbolContext.cpp b/source/API/SBSymbolContext.cpp index ab70c6f6ca68..365f0ccc2fbf 100644 --- a/source/API/SBSymbolContext.cpp +++ b/source/API/SBSymbolContext.cpp @@ -1,161 +1,166 @@ //===-- SBSymbolContext.cpp -------------------------------------*- C++ -*-===// // -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. +// 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" -#include "lldb/Utility/Log.h" using namespace lldb; using namespace lldb_private; -SBSymbolContext::SBSymbolContext() : m_opaque_ap() {} +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); -SBSymbolContext::SBSymbolContext(const SymbolContext *sc_ptr) : m_opaque_ap() { if (sc_ptr) - m_opaque_ap.reset(new SymbolContext(*sc_ptr)); + m_opaque_up = llvm::make_unique<SymbolContext>(*sc_ptr); } -SBSymbolContext::SBSymbolContext(const SBSymbolContext &rhs) : m_opaque_ap() { - if (rhs.IsValid()) { - if (m_opaque_ap) - *m_opaque_ap = *rhs.m_opaque_ap; - else - ref() = *rhs.m_opaque_ap; - } +SBSymbolContext::SBSymbolContext(const SBSymbolContext &rhs) : m_opaque_up() { + LLDB_RECORD_CONSTRUCTOR(SBSymbolContext, (const lldb::SBSymbolContext &), + rhs); + + m_opaque_up = clone(rhs.m_opaque_up); } SBSymbolContext::~SBSymbolContext() {} const SBSymbolContext &SBSymbolContext::operator=(const SBSymbolContext &rhs) { - if (this != &rhs) { - if (rhs.IsValid()) - m_opaque_ap.reset(new lldb_private::SymbolContext(*rhs.m_opaque_ap)); - } - return *this; + 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) { - if (m_opaque_ap) - *m_opaque_ap = *sc_ptr; - else - m_opaque_ap.reset(new SymbolContext(*sc_ptr)); - } else { - if (m_opaque_ap) - m_opaque_ap->Clear(true); - } + if (sc_ptr) + m_opaque_up = llvm::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); -bool SBSymbolContext::IsValid() const { return m_opaque_ap != NULL; } + return m_opaque_up != nullptr; +} SBModule SBSymbolContext::GetModule() { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBModule, SBSymbolContext, GetModule); SBModule sb_module; ModuleSP module_sp; - if (m_opaque_ap) { - module_sp = m_opaque_ap->module_sp; + if (m_opaque_up) { + module_sp = m_opaque_up->module_sp; sb_module.SetSP(module_sp); } - if (log) { - SBStream sstr; - sb_module.GetDescription(sstr); - log->Printf("SBSymbolContext(%p)::GetModule () => SBModule(%p): %s", - static_cast<void *>(m_opaque_ap.get()), - static_cast<void *>(module_sp.get()), sstr.GetData()); - } - - return sb_module; + return LLDB_RECORD_RESULT(sb_module); } SBCompileUnit SBSymbolContext::GetCompileUnit() { - return SBCompileUnit(m_opaque_ap ? m_opaque_ap->comp_unit : NULL); + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCompileUnit, SBSymbolContext, + GetCompileUnit); + + return LLDB_RECORD_RESULT( + SBCompileUnit(m_opaque_up ? m_opaque_up->comp_unit : nullptr)); } SBFunction SBSymbolContext::GetFunction() { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFunction, SBSymbolContext, GetFunction); - Function *function = NULL; + Function *function = nullptr; - if (m_opaque_ap) - function = m_opaque_ap->function; + if (m_opaque_up) + function = m_opaque_up->function; SBFunction sb_function(function); - if (log) - log->Printf("SBSymbolContext(%p)::GetFunction () => SBFunction(%p)", - static_cast<void *>(m_opaque_ap.get()), - static_cast<void *>(function)); - - return sb_function; + return LLDB_RECORD_RESULT(sb_function); } SBBlock SBSymbolContext::GetBlock() { - return SBBlock(m_opaque_ap ? m_opaque_ap->block : NULL); + 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() { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBLineEntry, SBSymbolContext, GetLineEntry); SBLineEntry sb_line_entry; - if (m_opaque_ap) - sb_line_entry.SetLineEntry(m_opaque_ap->line_entry); - - if (log) { - log->Printf("SBSymbolContext(%p)::GetLineEntry () => SBLineEntry(%p)", - static_cast<void *>(m_opaque_ap.get()), - static_cast<void *>(sb_line_entry.get())); - } + if (m_opaque_up) + sb_line_entry.SetLineEntry(m_opaque_up->line_entry); - return sb_line_entry; + return LLDB_RECORD_RESULT(sb_line_entry); } SBSymbol SBSymbolContext::GetSymbol() { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSymbol, SBSymbolContext, GetSymbol); - Symbol *symbol = NULL; + Symbol *symbol = nullptr; - if (m_opaque_ap) - symbol = m_opaque_ap->symbol; + if (m_opaque_up) + symbol = m_opaque_up->symbol; SBSymbol sb_symbol(symbol); - if (log) - log->Printf("SBSymbolContext(%p)::GetSymbol () => SBSymbol(%p)", - static_cast<void *>(m_opaque_ap.get()), - static_cast<void *>(symbol)); - - return sb_symbol; + return LLDB_RECORD_RESULT(sb_symbol); } void SBSymbolContext::SetModule(lldb::SBModule module) { + LLDB_RECORD_METHOD(void, SBSymbolContext, SetModule, (lldb::SBModule), + module); + ref().module_sp = module.GetSP(); } void SBSymbolContext::SetCompileUnit(lldb::SBCompileUnit compile_unit) { + LLDB_RECORD_METHOD(void, SBSymbolContext, SetCompileUnit, + (lldb::SBCompileUnit), compile_unit); + ref().comp_unit = compile_unit.get(); } void SBSymbolContext::SetFunction(lldb::SBFunction function) { + LLDB_RECORD_METHOD(void, SBSymbolContext, SetFunction, (lldb::SBFunction), + function); + ref().function = function.get(); } void SBSymbolContext::SetBlock(lldb::SBBlock block) { + LLDB_RECORD_METHOD(void, SBSymbolContext, SetBlock, (lldb::SBBlock), block); + ref().block = block.GetPtr(); } void SBSymbolContext::SetLineEntry(lldb::SBLineEntry line_entry) { + LLDB_RECORD_METHOD(void, SBSymbolContext, SetLineEntry, (lldb::SBLineEntry), + line_entry); + if (line_entry.IsValid()) ref().line_entry = line_entry.ref(); else @@ -163,39 +168,45 @@ void SBSymbolContext::SetLineEntry(lldb::SBLineEntry line_entry) { } void SBSymbolContext::SetSymbol(lldb::SBSymbol symbol) { + LLDB_RECORD_METHOD(void, SBSymbolContext, SetSymbol, (lldb::SBSymbol), + symbol); + ref().symbol = symbol.get(); } lldb_private::SymbolContext *SBSymbolContext::operator->() const { - return m_opaque_ap.get(); + return m_opaque_up.get(); } const lldb_private::SymbolContext &SBSymbolContext::operator*() const { - assert(m_opaque_ap.get()); - return *m_opaque_ap; + assert(m_opaque_up.get()); + return *m_opaque_up; } lldb_private::SymbolContext &SBSymbolContext::operator*() { - if (m_opaque_ap == NULL) - m_opaque_ap.reset(new SymbolContext); - return *m_opaque_ap; + if (m_opaque_up == nullptr) + m_opaque_up.reset(new SymbolContext); + return *m_opaque_up; } lldb_private::SymbolContext &SBSymbolContext::ref() { - if (m_opaque_ap == NULL) - m_opaque_ap.reset(new SymbolContext); - return *m_opaque_ap; + if (m_opaque_up == nullptr) + m_opaque_up.reset(new SymbolContext); + return *m_opaque_up; } lldb_private::SymbolContext *SBSymbolContext::get() const { - return m_opaque_ap.get(); + 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_ap) { - m_opaque_ap->GetDescription(&strm, lldb::eDescriptionLevelFull, NULL); + if (m_opaque_up) { + m_opaque_up->GetDescription(&strm, lldb::eDescriptionLevelFull, nullptr); } else strm.PutCString("No value"); @@ -205,11 +216,56 @@ bool SBSymbolContext::GetDescription(SBStream &description) { SBSymbolContext SBSymbolContext::GetParentOfInlinedScope(const SBAddress &curr_frame_pc, SBAddress &parent_frame_addr) const { + LLDB_RECORD_METHOD_CONST(lldb::SBSymbolContext, SBSymbolContext, + GetParentOfInlinedScope, + (const lldb::SBAddress &, lldb::SBAddress &), + curr_frame_pc, parent_frame_addr); + SBSymbolContext sb_sc; - if (m_opaque_ap.get() && curr_frame_pc.IsValid()) { - if (m_opaque_ap->GetParentOfInlinedScope(curr_frame_pc.ref(), sb_sc.ref(), + if (m_opaque_up.get() && curr_frame_pc.IsValid()) { + if (m_opaque_up->GetParentOfInlinedScope(curr_frame_pc.ref(), sb_sc.ref(), parent_frame_addr.ref())) - return sb_sc; + return LLDB_RECORD_RESULT(sb_sc); } - return SBSymbolContext(); + return LLDB_RECORD_RESULT(SBSymbolContext()); +} + +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 &)); +} + +} } |