#include <elf.h>

#include <stdint.h>

#include <memory>

#include <string>

#include <utility>

#include <unwindstack/DwarfError.h>

#include <unwindstack/DwarfSection.h>

#include <unwindstack/ElfInterface.h>

#include <unwindstack/Log.h>

#include <unwindstack/Regs.h>

#ifdef WITH_DEBUG_FRAME

#include "DwarfDebugFrame.h"

#endif

#include "DwarfEhFrame.h"

#include "DwarfEhFrameWithHdr.h"

#include "MemoryBuffer.h"

#ifdef WITH_DEBUG_FRAME

#include "MemoryXz.h"

#endif

#include "Symbols.h"

namespace unwindstack {

ElfInterface::~ElfInterface() {

for (auto symbol : symbols_) {

delete symbol;

}

}

bool ElfInterface::IsValidPc(uint64_t pc) {

}

bool ElfInterface::GetTextRange(uint64_t* addr, uint64_t* size) {

}

#ifdef WITH_DEBUG_FRAME

std::unique_ptr<Memory> ElfInterface::CreateGnuDebugdataMemory() {

}

#endif

template <typename ElfTypes>

void ElfInterfaceImpl<ElfTypes>::InitHeaders() {

if (eh_frame_hdr_offset_ != 0) {

DwarfEhFrameWithHdr<AddressType>* eh_frame_hdr = new DwarfEhFrameWithHdr<AddressType>(memory_);

eh_frame_.reset(eh_frame_hdr);

if (!eh_frame_hdr->EhFrameInit(eh_frame_offset_, eh_frame_size_, eh_frame_section_bias_) ||

!eh_frame_->Init(eh_frame_hdr_offset_, eh_frame_hdr_size_, eh_frame_hdr_section_bias_)) {

eh_frame_.reset(nullptr);

}

}

if (eh_frame_.get() == nullptr && eh_frame_offset_ != 0) {

// If there is an eh_frame section without an eh_frame_hdr section,

// or using the frame hdr object failed to init.

eh_frame_.reset(new DwarfEhFrame<AddressType>(memory_));

if (!eh_frame_->Init(eh_frame_offset_, eh_frame_size_, eh_frame_section_bias_)) {

eh_frame_.reset(nullptr);

}

}

if (eh_frame_.get() == nullptr) {

eh_frame_hdr_offset_ = 0;

eh_frame_hdr_section_bias_ = 0;

eh_frame_hdr_size_ = static_cast<uint64_t>(-1);

eh_frame_offset_ = 0;

eh_frame_section_bias_ = 0;

eh_frame_size_ = static_cast<uint64_t>(-1);

}

#ifdef WITH_DEBUG_FRAME

if (debug_frame_offset_ != 0) {

debug_frame_.reset(new DwarfDebugFrame<AddressType>(memory_));

if (!debug_frame_->Init(debug_frame_offset_, debug_frame_size_, debug_frame_section_bias_)) {

debug_frame_.reset(nullptr);

debug_frame_offset_ = 0;

debug_frame_size_ = static_cast<uint64_t>(-1);

}

}

#endif

}

template <typename ElfTypes>

bool ElfInterfaceImpl<ElfTypes>::ReadAllHeaders(int64_t* load_bias) {

EhdrType ehdr;

if (!memory_->ReadFully(0, &ehdr, sizeof(ehdr))) {

last_error_.code = ERROR_MEMORY_INVALID;

last_error_.address = 0;

return false;

}

// If we have enough information that this is an elf file, then allow

// malformed program and section headers.

ReadProgramHeaders(ehdr, load_bias);

ReadSectionHeaders(ehdr);

return true;

}

template <typename EhdrType, typename PhdrType>

int64_t ElfInterface::GetLoadBias(Memory* memory) {

}

template <typename ElfTypes>

void ElfInterfaceImpl<ElfTypes>::ReadProgramHeaders(const EhdrType& ehdr, int64_t* load_bias) {

uint64_t offset = ehdr.e_phoff;

bool first_exec_load_header = true;

for (size_t i = 0; i < ehdr.e_phnum; i++, offset += ehdr.e_phentsize) {

PhdrType phdr;

if (!memory_->ReadFully(offset, &phdr, sizeof(phdr))) {

return;

}

switch (phdr.p_type) {

case PT_LOAD:

{

if ((phdr.p_flags & PF_X) == 0) {

continue;

}

pt_loads_[phdr.p_offset] = LoadInfo{phdr.p_offset, phdr.p_vaddr,

static_cast<size_t>(phdr.p_memsz)};

// Only set the load bias from the first executable load header.

if (first_exec_load_header) {

*load_bias = static_cast<uint64_t>(phdr.p_vaddr) - phdr.p_offset;

}

first_exec_load_header = false;

break;

}

case PT_GNU_EH_FRAME:

// This is really the pointer to the .eh_frame_hdr section.

eh_frame_hdr_offset_ = phdr.p_offset;

eh_frame_hdr_section_bias_ = static_cast<uint64_t>(phdr.p_vaddr) - phdr.p_offset;

eh_frame_hdr_size_ = phdr.p_memsz;

break;

case PT_DYNAMIC:

dynamic_offset_ = phdr.p_offset;

dynamic_vaddr_start_ = phdr.p_vaddr;

if (__builtin_add_overflow(dynamic_vaddr_start_, phdr.p_memsz, &dynamic_vaddr_end_)) {

dynamic_offset_ = 0;

dynamic_vaddr_start_ = 0;

dynamic_vaddr_end_ = 0;

}

break;

default:

HandleUnknownType(phdr.p_type, phdr.p_offset, phdr.p_filesz);

break;

}

}

}

template <typename ElfTypes>

std::string ElfInterfaceImpl<ElfTypes>::ReadBuildID() {

// Ensure there is no overflow in any of the calulations below.

uint64_t tmp;

if (__builtin_add_overflow(gnu_build_id_offset_, gnu_build_id_size_, &tmp)) {

return "";

}

uint64_t offset = 0;

while (offset < gnu_build_id_size_) {

if (gnu_build_id_size_ - offset < sizeof(NhdrType)) {

return "";

}

NhdrType hdr;

if (!memory_->ReadFully(gnu_build_id_offset_ + offset, &hdr, sizeof(hdr))) {

return "";

}

offset += sizeof(hdr);

if (gnu_build_id_size_ - offset < hdr.n_namesz) {

return "";

}

if (hdr.n_namesz > 0) {

std::string name(hdr.n_namesz, '\0');

if (!memory_->ReadFully(gnu_build_id_offset_ + offset, &(name[0]), hdr.n_namesz)) {

return "";

}

// Trim trailing \0 as GNU is stored as a C string in the ELF file.

if (name.back() == '\0')

name.resize(name.size() - 1);

// Align hdr.n_namesz to next power multiple of 4. See man 5 elf.

offset += (hdr.n_namesz + 3) & ~3;

if (name == "GNU" && hdr.n_type == NT_GNU_BUILD_ID) {

if (gnu_build_id_size_ - offset < hdr.n_descsz || hdr.n_descsz == 0) {

return "";

}

std::string build_id(hdr.n_descsz, '\0');

if (memory_->ReadFully(gnu_build_id_offset_ + offset, &build_id[0], hdr.n_descsz)) {

return build_id;

}

return "";

}

}

// Align hdr.n_descsz to next power multiple of 4. See man 5 elf.

offset += (hdr.n_descsz + 3) & ~3;

}

return "";

}

template <typename ElfTypes>

void ElfInterfaceImpl<ElfTypes>::ReadSectionHeaders(const EhdrType& ehdr) {

uint64_t offset = ehdr.e_shoff;

uint64_t sec_offset = 0;

uint64_t sec_size = 0;

// Get the location of the section header names.

// If something is malformed in the header table data, we aren't going

// to terminate, we'll simply ignore this part.

ShdrType shdr;

if (ehdr.e_shstrndx < ehdr.e_shnum) {

uint64_t sh_offset = offset + ehdr.e_shstrndx * ehdr.e_shentsize;

if (memory_->ReadFully(sh_offset, &shdr, sizeof(shdr))) {

sec_offset = shdr.sh_offset;

sec_size = shdr.sh_size;

}

}

// Skip the first header, it's always going to be NULL.

offset += ehdr.e_shentsize;

for (size_t i = 1; i < ehdr.e_shnum; i++, offset += ehdr.e_shentsize) {

if (!memory_->ReadFully(offset, &shdr, sizeof(shdr))) {

return;

}

if (shdr.sh_type == SHT_SYMTAB || shdr.sh_type == SHT_DYNSYM) {

// Need to go get the information about the section that contains

// the string terminated names.

ShdrType str_shdr;

if (shdr.sh_link >= ehdr.e_shnum) {

continue;

}

uint64_t str_offset = ehdr.e_shoff + shdr.sh_link * ehdr.e_shentsize;

if (!memory_->ReadFully(str_offset, &str_shdr, sizeof(str_shdr))) {

continue;

}

if (str_shdr.sh_type != SHT_STRTAB) {

continue;

}

symbols_.push_back(new Symbols(shdr.sh_offset, shdr.sh_size, shdr.sh_entsize,

str_shdr.sh_offset, str_shdr.sh_size));

} else if ((shdr.sh_type == SHT_PROGBITS || shdr.sh_type == SHT_NOBITS) && sec_size != 0) {

// Look for the .debug_frame and .gnu_debugdata.

if (shdr.sh_name < sec_size) {

std::string name;

if (memory_->ReadString(sec_offset + shdr.sh_name, &name, sec_size - shdr.sh_name)) {

if (name == ".debug_frame") {

debug_frame_offset_ = shdr.sh_offset;

debug_frame_size_ = shdr.sh_size;

debug_frame_section_bias_ = static_cast<uint64_t>(shdr.sh_addr) - shdr.sh_offset;

} else if (name == ".gnu_debugdata") {

gnu_debugdata_offset_ = shdr.sh_offset;

gnu_debugdata_size_ = shdr.sh_size;

} else if (name == ".eh_frame") {

eh_frame_offset_ = shdr.sh_offset;

eh_frame_section_bias_ = static_cast<uint64_t>(shdr.sh_addr) - shdr.sh_offset;

eh_frame_size_ = shdr.sh_size;

} else if (eh_frame_hdr_offset_ == 0 && name == ".eh_frame_hdr") {

eh_frame_hdr_offset_ = shdr.sh_offset;

eh_frame_hdr_section_bias_ = static_cast<uint64_t>(shdr.sh_addr) - shdr.sh_offset;

eh_frame_hdr_size_ = shdr.sh_size;

} else if (name == ".data") {

data_offset_ = shdr.sh_offset;

data_vaddr_start_ = shdr.sh_addr;

if (__builtin_add_overflow(data_vaddr_start_, shdr.sh_size, &data_vaddr_end_)) {

data_offset_ = 0;

data_vaddr_start_ = 0;

data_vaddr_end_ = 0;

}

} else if (name == ".text") {

text_addr_ = shdr.sh_addr;

text_size_ = shdr.sh_size;

}

}

}

} else if (shdr.sh_type == SHT_STRTAB) {

// In order to read soname, keep track of address to offset mapping.

strtabs_.push_back(std::make_pair<uint64_t, uint64_t>(static_cast<uint64_t>(shdr.sh_addr),

static_cast<uint64_t>(shdr.sh_offset)));

} else if (shdr.sh_type == SHT_NOTE) {

if (shdr.sh_name < sec_size) {

std::string name;

if (memory_->ReadString(sec_offset + shdr.sh_name, &name, sec_size - shdr.sh_name) &&

name == ".note.gnu.build-id") {

gnu_build_id_offset_ = shdr.sh_offset;

gnu_build_id_size_ = shdr.sh_size;

}

}

}

}

}

template <typename ElfTypes>

std::string ElfInterfaceImpl<ElfTypes>::GetSoname() {

if (soname_type_ == SONAME_INVALID) {

return "";

}

if (soname_type_ == SONAME_VALID) {

return soname_;

}

soname_type_ = SONAME_INVALID;

uint64_t soname_offset = 0;

uint64_t strtab_addr = 0;

uint64_t strtab_size = 0;

// Find the soname location from the dynamic headers section.

DynType dyn;

uint64_t offset = dynamic_offset_;

uint64_t max_offset = offset + dynamic_vaddr_end_ - dynamic_vaddr_start_;

for (uint64_t offset = dynamic_offset_; offset < max_offset; offset += sizeof(DynType)) {

if (!memory_->ReadFully(offset, &dyn, sizeof(dyn))) {

last_error_.code = ERROR_MEMORY_INVALID;

last_error_.address = offset;

return "";

}

if (dyn.d_tag == DT_STRTAB) {

strtab_addr = dyn.d_un.d_ptr;

} else if (dyn.d_tag == DT_STRSZ) {

strtab_size = dyn.d_un.d_val;

} else if (dyn.d_tag == DT_SONAME) {

soname_offset = dyn.d_un.d_val;

} else if (dyn.d_tag == DT_NULL) {

break;

}

}

// Need to map the strtab address to the real offset.

for (const auto& entry : strtabs_) {

if (entry.first == strtab_addr) {

soname_offset = entry.second + soname_offset;

uint64_t soname_max = entry.second + strtab_size;

if (soname_offset >= soname_max) {

return "";

}

if (!memory_->ReadString(soname_offset, &soname_, soname_max - soname_offset)) {

return "";

}

soname_type_ = SONAME_VALID;

return soname_;

}

}

return "";

}

template <typename ElfTypes>

bool ElfInterfaceImpl<ElfTypes>::GetFunctionName(uint64_t addr, SharedString* name,

uint64_t* func_offset) {

if (symbols_.empty()) {

return false;

}

for (const auto symbol : symbols_) {

if (symbol->template GetName<SymType>(addr, memory_, name, func_offset)) {

return true;

}

}

return false;

}

template <typename ElfTypes>

bool ElfInterfaceImpl<ElfTypes>::GetGlobalVariable(const std::string& name,

uint64_t* memory_address) {

if (symbols_.empty()) {

return false;

}

for (const auto symbol : symbols_) {

if (symbol->template GetGlobal<SymType>(memory_, name, memory_address)) {

return true;

}

}

return false;

}

bool ElfInterface::Step(uint64_t pc, Regs* regs, Memory* process_memory, bool* finished,

}

template <typename ElfTypes>

void ElfInterfaceImpl<ElfTypes>::GetMaxSize(Memory* memory, uint64_t* size) {

EhdrType ehdr;

if (!memory->ReadFully(0, &ehdr, sizeof(ehdr))) {

*size = 0;

return;

}

// If this winds up as zero, the PT_LOAD reading will get a better value.

uint64_t elf_size = ehdr.e_shoff + ehdr.e_shentsize * ehdr.e_shnum;

// Search through the PT_LOAD values and if any result in a larger elf

// size, use that.

uint64_t offset = ehdr.e_phoff;

for (size_t i = 0; i < ehdr.e_phnum; i++, offset += ehdr.e_phentsize) {

PhdrType phdr;

if (!memory->ReadFully(offset, &phdr, sizeof(phdr))) {

break;

}

if (phdr.p_type == PT_LOAD) {

uint64_t end_offset;

if (__builtin_add_overflow(phdr.p_offset, phdr.p_memsz, &end_offset)) {

continue;

}

if (end_offset > elf_size) {

elf_size = end_offset;

}

}

}

*size = elf_size;

}

template <typename EhdrType, typename ShdrType>

bool GetBuildIDInfo(Memory* memory, uint64_t* build_id_offset, uint64_t* build_id_size) {

}

template <typename EhdrType, typename ShdrType, typename NhdrType>

std::string ElfInterface::ReadBuildIDFromMemory(Memory* memory) {

}

template class ElfInterfaceImpl<ElfTypes32>;

template class ElfInterfaceImpl<ElfTypes64>;

template int64_t ElfInterface::GetLoadBias<Elf32_Ehdr, Elf32_Phdr>(Memory*);

template int64_t ElfInterface::GetLoadBias<Elf64_Ehdr, Elf64_Phdr>(Memory*);

template std::string ElfInterface::ReadBuildIDFromMemory<Elf32_Ehdr, Elf32_Shdr, Elf32_Nhdr>(

Memory*);

template std::string ElfInterface::ReadBuildIDFromMemory<Elf64_Ehdr, Elf64_Shdr, Elf64_Nhdr>(

Memory*);

} // namespace unwindstack