diff options
Diffstat (limited to 'contrib/llvm-project/lldb/source/API/SBSection.cpp')
| -rw-r--r-- | contrib/llvm-project/lldb/source/API/SBSection.cpp | 328 |
1 files changed, 328 insertions, 0 deletions
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..14e1e14f59aa --- /dev/null +++ b/contrib/llvm-project/lldb/source/API/SBSection.cpp @@ -0,0 +1,328 @@ +//===-- SBSection.cpp -------------------------------------------*- 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 +// +//===----------------------------------------------------------------------===// + +#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() {} + +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); + } 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 &)); +} + +} +} |