llvm/lldb/source/Plugins/ObjectFile/ELF/ELFHeader.cpp

//===-- ELFHeader.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 <cstring>

#include "lldb/Core/Section.h"
#include "lldb/Utility/DataExtractor.h"
#include "lldb/Utility/Stream.h"

#include "ELFHeader.h"

usingnamespaceelf;
usingnamespacelldb;
usingnamespacellvm::ELF;

// Static utility functions.
//
// GetMaxU64 and GetMaxS64 wrap the similarly named methods from DataExtractor
// with error handling code and provide for parsing a sequence of values.
static bool GetMaxU64(const lldb_private::DataExtractor &data,
                      lldb::offset_t *offset, uint64_t *value,
                      uint32_t byte_size) { … }

static bool GetMaxU64(const lldb_private::DataExtractor &data,
                      lldb::offset_t *offset, uint64_t *value,
                      uint32_t byte_size, uint32_t count) { … }

static bool GetMaxS64(const lldb_private::DataExtractor &data,
                      lldb::offset_t *offset, int64_t *value,
                      uint32_t byte_size) { … }

static bool GetMaxS64(const lldb_private::DataExtractor &data,
                      lldb::offset_t *offset, int64_t *value,
                      uint32_t byte_size, uint32_t count) { … }

// ELFHeader

ELFHeader::ELFHeader() { … }

ByteOrder ELFHeader::GetByteOrder() const { … }

bool ELFHeader::HasHeaderExtension() const { … }

void ELFHeader::ParseHeaderExtension(lldb_private::DataExtractor &data) { … }

bool ELFHeader::Parse(lldb_private::DataExtractor &data,
                      lldb::offset_t *offset) { … }

bool ELFHeader::MagicBytesMatch(const uint8_t *magic) { … }

unsigned ELFHeader::AddressSizeInBytes(const uint8_t *magic) { … }

unsigned ELFHeader::GetRelocationJumpSlotType() const { … }

// ELFSectionHeader

ELFSectionHeader::ELFSectionHeader() { … }

bool ELFSectionHeader::Parse(const lldb_private::DataExtractor &data,
                             lldb::offset_t *offset) { … }

// ELFSymbol

ELFSymbol::ELFSymbol() { … }

#define ENUM_TO_CSTR(e) …

const char *ELFSymbol::bindingToCString(unsigned char binding) { … }

const char *ELFSymbol::typeToCString(unsigned char type) { … }

const char *ELFSymbol::sectionIndexToCString(
    elf_half shndx, const lldb_private::SectionList *section_list) { … }

void ELFSymbol::Dump(lldb_private::Stream *s, uint32_t idx,
                     const lldb_private::DataExtractor *strtab_data,
                     const lldb_private::SectionList *section_list) { … }

bool ELFSymbol::Parse(const lldb_private::DataExtractor &data,
                      lldb::offset_t *offset) { … }

// ELFProgramHeader

ELFProgramHeader::ELFProgramHeader() { … }

bool ELFProgramHeader::Parse(const lldb_private::DataExtractor &data,
                             lldb::offset_t *offset) { … }

// ELFDynamic

ELFDynamic::ELFDynamic() { … }

bool ELFDynamic::Parse(const lldb_private::DataExtractor &data,
                       lldb::offset_t *offset) { … }

// ELFRel

ELFRel::ELFRel() { … }

bool ELFRel::Parse(const lldb_private::DataExtractor &data,
                   lldb::offset_t *offset) { … }

// ELFRela

ELFRela::ELFRela() { … }

bool ELFRela::Parse(const lldb_private::DataExtractor &data,
                    lldb::offset_t *offset) { … }