summaryrefslogtreecommitdiff
path: root/source/API/SBAddress.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'source/API/SBAddress.cpp')
-rw-r--r--source/API/SBAddress.cpp250
1 files changed, 169 insertions, 81 deletions
diff --git a/source/API/SBAddress.cpp b/source/API/SBAddress.cpp
index 09ec6c3f10db..358cb400a76c 100644
--- a/source/API/SBAddress.cpp
+++ b/source/API/SBAddress.cpp
@@ -1,13 +1,14 @@
//===-- SBAddress.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/SBAddress.h"
+#include "SBReproducerPrivate.h"
+#include "Utils.h"
#include "lldb/API/SBProcess.h"
#include "lldb/API/SBSection.h"
#include "lldb/API/SBStream.h"
@@ -15,44 +16,51 @@
#include "lldb/Core/Module.h"
#include "lldb/Symbol/LineEntry.h"
#include "lldb/Target/Target.h"
-#include "lldb/Utility/Log.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb;
using namespace lldb_private;
-SBAddress::SBAddress() : m_opaque_ap(new Address()) {}
+SBAddress::SBAddress() : m_opaque_up(new Address()) {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBAddress);
+}
SBAddress::SBAddress(const Address *lldb_object_ptr)
- : m_opaque_ap(new Address()) {
+ : m_opaque_up(new Address()) {
if (lldb_object_ptr)
- ref() = *lldb_object_ptr;
+ m_opaque_up = llvm::make_unique<Address>(*lldb_object_ptr);
}
-SBAddress::SBAddress(const SBAddress &rhs) : m_opaque_ap(new Address()) {
- if (rhs.IsValid())
- ref() = rhs.ref();
+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_ap(new Address(section.GetSP(), offset)) {}
+ : m_opaque_up(new Address(section.GetSP(), offset)) {
+ LLDB_RECORD_CONSTRUCTOR(SBAddress, (lldb::SBSection, lldb::addr_t), section,
+ offset);
+}
// Create an address by resolving a load address using the supplied target
SBAddress::SBAddress(lldb::addr_t load_addr, lldb::SBTarget &target)
- : m_opaque_ap(new Address()) {
+ : m_opaque_up(new Address()) {
+ LLDB_RECORD_CONSTRUCTOR(SBAddress, (lldb::addr_t, lldb::SBTarget &),
+ load_addr, target);
+
SetLoadAddress(load_addr, target);
}
SBAddress::~SBAddress() {}
const SBAddress &SBAddress::operator=(const SBAddress &rhs) {
- if (this != &rhs) {
- if (rhs.IsValid())
- ref() = rhs.ref();
- else
- m_opaque_ap.reset(new Address());
- }
- return *this;
+ 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) {
@@ -61,13 +69,33 @@ bool lldb::operator==(const SBAddress &lhs, const SBAddress &rhs) {
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 {
- return m_opaque_ap != NULL && m_opaque_ap->IsValid();
+ 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);
-void SBAddress::Clear() { m_opaque_ap.reset(new Address()); }
+ return m_opaque_up != nullptr && m_opaque_up->IsValid();
+}
+
+void SBAddress::Clear() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBAddress, Clear);
+
+ m_opaque_up.reset(new Address());
+}
void SBAddress::SetAddress(lldb::SBSection section, lldb::addr_t offset) {
+ LLDB_RECORD_METHOD(void, SBAddress, SetAddress,
+ (lldb::SBSection, lldb::addr_t), section, offset);
+
Address &addr = ref();
addr.SetSection(section.GetSP());
addr.SetOffset(offset);
@@ -77,61 +105,59 @@ void SBAddress::SetAddress(const Address *lldb_object_ptr) {
if (lldb_object_ptr)
ref() = *lldb_object_ptr;
else
- m_opaque_ap.reset(new Address());
+ m_opaque_up.reset(new Address());
}
lldb::addr_t SBAddress::GetFileAddress() const {
- if (m_opaque_ap->IsValid())
- return m_opaque_ap->GetFileAddress();
+ 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 {
- Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+ 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_ap->IsValid()) {
+ if (m_opaque_up->IsValid()) {
std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
- addr = m_opaque_ap->GetLoadAddress(target_sp.get());
+ addr = m_opaque_up->GetLoadAddress(target_sp.get());
}
}
- if (log) {
- if (addr == LLDB_INVALID_ADDRESS)
- log->Printf(
- "SBAddress::GetLoadAddress (SBTarget(%p)) => LLDB_INVALID_ADDRESS",
- static_cast<void *>(target_sp.get()));
- else
- log->Printf("SBAddress::GetLoadAddress (SBTarget(%p)) => 0x%" PRIx64,
- static_cast<void *>(target_sp.get()), addr);
- }
-
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_ap->Clear();
+ 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_ap->IsValid())
- m_opaque_ap->SetOffset(load_addr);
+ if (!m_opaque_up->IsValid())
+ m_opaque_up->SetOffset(load_addr);
}
bool SBAddress::OffsetAddress(addr_t offset) {
- if (m_opaque_ap->IsValid()) {
- addr_t addr_offset = m_opaque_ap->GetOffset();
+ 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_ap->SetOffset(addr_offset + offset);
+ m_opaque_up->SetOffset(addr_offset + offset);
return true;
}
}
@@ -139,46 +165,53 @@ bool SBAddress::OffsetAddress(addr_t offset) {
}
lldb::SBSection SBAddress::GetSection() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSection, SBAddress, GetSection);
+
lldb::SBSection sb_section;
- if (m_opaque_ap->IsValid())
- sb_section.SetSP(m_opaque_ap->GetSection());
- return 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() {
- if (m_opaque_ap->IsValid())
- return m_opaque_ap->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_ap.get(); }
+Address *SBAddress::operator->() { return m_opaque_up.get(); }
-const Address *SBAddress::operator->() const { return m_opaque_ap.get(); }
+const Address *SBAddress::operator->() const { return m_opaque_up.get(); }
Address &SBAddress::ref() {
- if (m_opaque_ap == NULL)
- m_opaque_ap.reset(new Address());
- return *m_opaque_ap;
+ if (m_opaque_up == nullptr)
+ m_opaque_up.reset(new 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_ap.get());
- return *m_opaque_ap;
+ assert(m_opaque_up.get());
+ return *m_opaque_up;
}
-Address *SBAddress::get() { return m_opaque_ap.get(); }
+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_ap->IsValid()) {
- m_opaque_ap->Dump(&strm, NULL, Address::DumpStyleResolvedDescription,
+ if (m_opaque_up->IsValid()) {
+ m_opaque_up->Dump(&strm, nullptr, Address::DumpStyleResolvedDescription,
Address::DumpStyleModuleWithFileAddress, 4);
StreamString sstrm;
- // m_opaque_ap->Dump (&sstrm, NULL,
+ // m_opaque_up->Dump (&sstrm, NULL,
// Address::DumpStyleResolvedDescription, Address::DumpStyleInvalid,
// 4);
// if (sstrm.GetData())
@@ -190,54 +223,109 @@ bool SBAddress::GetDescription(SBStream &description) {
}
SBModule SBAddress::GetModule() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBModule, SBAddress, GetModule);
+
SBModule sb_module;
- if (m_opaque_ap->IsValid())
- sb_module.SetSP(m_opaque_ap->GetModule());
- return 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_ap->IsValid())
- m_opaque_ap->CalculateSymbolContext(&sb_sc.ref(), scope);
- return sb_sc;
+ 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_ap->IsValid())
- sb_comp_unit.reset(m_opaque_ap->CalculateSymbolContextCompileUnit());
- return 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_ap->IsValid())
- sb_function.reset(m_opaque_ap->CalculateSymbolContextFunction());
- return 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_ap->IsValid())
- sb_block.SetPtr(m_opaque_ap->CalculateSymbolContextBlock());
- return 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_ap->IsValid())
- sb_symbol.reset(m_opaque_ap->CalculateSymbolContextSymbol());
- return 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_ap->IsValid()) {
+ if (m_opaque_up->IsValid()) {
LineEntry line_entry;
- if (m_opaque_ap->CalculateSymbolContextLineEntry(line_entry))
+ if (m_opaque_up->CalculateSymbolContextLineEntry(line_entry))
sb_line_entry.SetLineEntry(line_entry);
}
- return sb_line_entry;
+ return LLDB_RECORD_RESULT(sb_line_entry);
+}
+
+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, ());
+}
+
+}
}
generated by cgit v1.2.3 (git 2.25.1) at 2025-10-04 10:14:50 +0000