/* Copyright 2017 - 2025 R. Thomas

* Copyright 2017 - 2025 Quarkslab

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

#include <algorithm>

#include <iterator>

#include <numeric>

#include <sstream>

#include <cctype>

#include "LIEF/DWARF/enums.hpp"

#include "logging.hpp"

#include "paging.hpp"

#include "LIEF/utils.hpp"

#include "LIEF/BinaryStream/SpanStream.hpp"

#include "LIEF/ELF/utils.hpp"

#include "LIEF/ELF/EnumToString.hpp"

#include "LIEF/ELF/Binary.hpp"

#include "LIEF/ELF/DynamicEntry.hpp"

#include "LIEF/ELF/DynamicEntryLibrary.hpp"

#include "LIEF/ELF/DynamicEntryArray.hpp"

#include "LIEF/ELF/DynamicEntryFlags.hpp"

#include "LIEF/ELF/DynamicEntryRpath.hpp"

#include "LIEF/ELF/DynamicEntryRunPath.hpp"

#include "LIEF/ELF/DynamicSharedObject.hpp"

#include "LIEF/ELF/Note.hpp"

#include "LIEF/ELF/Builder.hpp"

#include "LIEF/ELF/Section.hpp"

#include "LIEF/ELF/Segment.hpp"

#include "LIEF/ELF/Relocation.hpp"

#include "LIEF/ELF/Symbol.hpp"

#include "LIEF/ELF/SymbolVersion.hpp"

#include "LIEF/ELF/SymbolVersionDefinition.hpp"

#include "LIEF/ELF/SymbolVersionRequirement.hpp"

#include "LIEF/ELF/SymbolVersionAuxRequirement.hpp"

#include "LIEF/ELF/GnuHash.hpp"

#include "LIEF/ELF/SysvHash.hpp"

#include "LIEF/ELF/hash.hpp"

#include "ELF/DataHandler/Handler.hpp"

#include "ELF/SizingInfo.hpp"

#include "Binary.tcc"

#include "Object.tcc"

#include "internal_utils.hpp"

namespace LIEF {

namespace ELF {

inline size_t get_relocation_sizeof(const Binary& bin, const Relocation& R) {

const bool is64 = bin.type() == Header::CLASS::ELF64;

if (R.is_rel() || R.is_rela()) {

return is64 ?

(R.is_rela() ? sizeof(details::Elf64_Rela) : sizeof(details::Elf64_Rel)) :

(R.is_rela() ? sizeof(details::Elf32_Rela) : sizeof(details::Elf32_Rel));

}

LIEF_WARN("get_relocation_sizeof() only supports REL/RELA encoding");

return size_t(-1);

}

Binary::Binary() :

LIEF::Binary(LIEF::Binary::FORMATS::ELF),

sizing_info_{std::make_unique<sizing_info_t>()}

{}

size_t Binary::hash(const std::string& name) {

if (type_ == Header::CLASS::ELF32) {

return hash32(name.c_str());

}

return hash64(name.c_str());

}

LIEF::Binary::sections_t Binary::get_abstract_sections() {

LIEF::Binary::sections_t sections;

sections.reserve(sections_.size());

std::transform(std::begin(sections_), std::end(sections_),

std::back_inserter(sections),

[] (const std::unique_ptr<Section>& s) {

return s.get();

});

return sections;

}

LIEF::Binary::functions_t Binary::get_abstract_exported_functions() const {

functions_t result;

for (const Symbol& symbol : exported_symbols()) {

if (symbol.type() == Symbol::TYPE::FUNC) {

result.emplace_back(symbol.name(), symbol.value(), Function::FLAGS::EXPORTED);

}

}

return result;

}

LIEF::Binary::functions_t Binary::get_abstract_imported_functions() const {

functions_t result;

for (const Symbol& symbol : imported_symbols()) {

if (symbol.type() == Symbol::TYPE::FUNC) {

result.emplace_back(symbol.name(), symbol.value(), Function::FLAGS::IMPORTED);

}

}

return result;

}

std::vector<std::string> Binary::get_abstract_imported_libraries() const {

std::vector<std::string> result;

for (const DynamicEntry& entry : dynamic_entries()) {

if (const auto* lib = entry.cast<DynamicEntryLibrary>()) {

result.push_back(lib->name());

}

}

return result;

}

DynamicEntry& Binary::add(const DynamicEntry& entry) {

std::unique_ptr<DynamicEntry> new_one = entry.clone();

const auto it_new_place = std::find_if(std::begin(dynamic_entries_), std::end(dynamic_entries_),

[&new_one] (const std::unique_ptr<DynamicEntry>& e) {

return e->tag() == new_one->tag() || e->tag() == DynamicEntry::TAG::DT_NULL_;

});

auto* ptr = new_one.get();

dynamic_entries_.insert(it_new_place, std::move(new_one));

return *ptr;

}

Note& Binary::add(const Note& note) {

notes_.push_back(note.clone());

return *notes_.back();

}

void Binary::remove(const DynamicEntry& entry) {

const auto it_entry = std::find_if(std::begin(dynamic_entries_), std::end(dynamic_entries_),

[&entry] (const std::unique_ptr<DynamicEntry>& e) {

return e.get() == &entry;

});

if (it_entry == std::end(dynamic_entries_)) {

LIEF_WARN("Can't find {} in the dynamic table. This entry can't be removed",

to_string(entry));

return;

}

dynamic_entries_.erase(it_entry);

}

void Binary::remove(DynamicEntry::TAG tag) {

dynamic_entries_.erase(

std::remove_if(dynamic_entries_.begin(), dynamic_entries_.end(),

[tag] (const std::unique_ptr<DynamicEntry>& E) { return E->tag() == tag; }

), dynamic_entries_.end());

}

void Binary::remove(const Section& section, bool clear) {

const auto it_section = std::find_if(std::begin(sections_), std::end(sections_),

[&section] (const std::unique_ptr<Section>& s) {

return *s == section;

});

if (it_section == std::end(sections_)) {

LIEF_WARN("Can't find the section '{}'. It can't be removed!", section.name());

return;

}

size_t idx = std::distance(std::begin(sections_), it_section);

Section* s = it_section->get();

// Remove from segments:

for (std::unique_ptr<Segment>& segment : segments_) {

auto& sections = segment->sections_;

sections.erase(std::remove_if(std::begin(sections), std::end(sections),

[&s] (const Section* sec) { return *sec == *s; }), std::end(sections));

}

// Patch Section link

for (std::unique_ptr<Section>& section : sections_) {

if (section->link() == idx) {

section->link(0);

continue;

}

if (section->link() > idx) {

section->link(section->link() - 1);

continue;

}

}

if (clear) {

s->clear(0);

}

datahandler_->remove(s->file_offset(), s->size(), DataHandler::Node::SECTION);

// Patch header

header().numberof_sections(header().numberof_sections() - 1);

if (idx < header().section_name_table_idx()) {

header().section_name_table_idx(header().section_name_table_idx() - 1);

}

sections_.erase(it_section);

}

void Binary::remove(const Note& note) {

const auto it_note = std::find_if(std::begin(notes_), std::end(notes_),

[&note] (const std::unique_ptr<Note>& n) {

return note == *n;

});

if (it_note == std::end(notes_)) {

LIEF_WARN("Can't find the note with the type {}. It can't be removed!",

to_string(static_cast<Note::TYPE>(note.type())));

return;

}

notes_.erase(it_note);

}

void Binary::remove(Note::TYPE type) {

for (auto it = std::begin(notes_); it != std::end(notes_);) {

std::unique_ptr<Note>& n = *it;

if (n->type() == type) {

n.reset(nullptr);

it = notes_.erase(it);

} else {

++it;

}

}

}

int64_t Binary::symtab_idx(const std::string& name) const {

if (symtab_symbols_.empty()) {

return -1;

}

auto it = std::find_if(symtab_symbols_.begin(), symtab_symbols_.end(),

[&name] (const std::unique_ptr<Symbol>& S) {

return S->name() == name;

}

);

if (it == symtab_symbols_.end()) {

return -1;

}

return std::distance(symtab_symbols_.begin(), it);

}

int64_t Binary::symtab_idx(const Symbol& sym) const {

return symtab_idx(sym.name());

}

int64_t Binary::dynsym_idx(const Symbol& sym) const {

return dynsym_idx(sym.name());

}

int64_t Binary::dynsym_idx(const std::string& name) const {

if (dynamic_symbols_.empty()) {

return -1;

}

auto it = std::find_if(dynamic_symbols_.begin(), dynamic_symbols_.end(),

[&name] (const std::unique_ptr<Symbol>& S) {

return S->name() == name;

}

);

if (it == dynamic_symbols_.end()) {

return -1;

}

return std::distance(dynamic_symbols_.begin(), it);

}

Symbol& Binary::export_symbol(const Symbol& symbol) {

// Check if the symbol is in the dynamic symbol table

const auto it_symbol = std::find_if(std::begin(dynamic_symbols_), std::end(dynamic_symbols_),

[&symbol] (const std::unique_ptr<Symbol>& s) {

return *s == symbol;

});

Symbol* s = nullptr;

if (it_symbol == std::end(dynamic_symbols_)) {

// Create a new one

const SymbolVersion& version = SymbolVersion::global();

Symbol& new_sym = add_dynamic_symbol(symbol, &version);

s = &new_sym;

} else {

s = it_symbol->get();

}

const auto it_text = std::find_if(std::begin(sections_), std::end(sections_),

[] (const std::unique_ptr<Section>& s) {

return s->name() == ".text";

});

size_t text_idx = std::distance(std::begin(sections_), it_text);

if (s->binding() != Symbol::BINDING::WEAK || s->binding() != Symbol::BINDING::GLOBAL) {

s->binding(Symbol::BINDING::GLOBAL);

}

if (s->type() == Symbol::TYPE::NOTYPE) {

s->type(Symbol::TYPE::COMMON);

}

if (s->shndx() == 0) {

s->shndx(text_idx);

}

s->visibility(Symbol::VISIBILITY::DEFAULT);

return *s;

}

Symbol& Binary::export_symbol(const std::string& symbol_name, uint64_t value) {

Symbol* s = get_dynamic_symbol(symbol_name);

if (s != nullptr) {

if (value > 0) {

s->value(value);

}

return export_symbol(*s);

}

s = get_symtab_symbol(symbol_name);

if (s != nullptr) {

if (value > 0) {

s->value(value);

}

return export_symbol(*s);

}

// Create a new one

Symbol newsym;

newsym.name(symbol_name);

newsym.type(Symbol::TYPE::COMMON);

newsym.binding(Symbol::BINDING::GLOBAL);

newsym.visibility(Symbol::VISIBILITY::DEFAULT);

newsym.value(value);

newsym.size(0x10);

return export_symbol(newsym);

}

Symbol& Binary::add_exported_function(uint64_t address, const std::string& name) {

std::string funcname = name;

if (funcname.empty()) {

std::stringstream ss;

ss << "func_" << std::hex << address;

funcname = ss.str();

}

// First: Check if a symbol with the given 'name' exists in the **dynamic** table

Symbol* s = get_dynamic_symbol(funcname);

if (s != nullptr) {

s->type(Symbol::TYPE::FUNC);

s->binding(Symbol::BINDING::GLOBAL);

s->visibility(Symbol::VISIBILITY::DEFAULT);

s->value(address);

return export_symbol(*s);

}

// Second: Check if a symbol with the given 'name' exists in the **static**

s = get_symtab_symbol(funcname);

if (s != nullptr) {

s->type(Symbol::TYPE::FUNC);

s->binding(Symbol::BINDING::GLOBAL);

s->visibility(Symbol::VISIBILITY::DEFAULT);

s->value(address);

return export_symbol(*s);

}

// Create a new Symbol

Symbol funcsym;

funcsym.name(funcname);

funcsym.type(Symbol::TYPE::FUNC);

funcsym.binding(Symbol::BINDING::GLOBAL);

funcsym.visibility(Symbol::VISIBILITY::DEFAULT);

funcsym.value(address);

funcsym.size(0x10);

return export_symbol(funcsym);

}

const Symbol* Binary::get_dynamic_symbol(const std::string& name) const {

const auto it_symbol = std::find_if(

std::begin(dynamic_symbols_), std::end(dynamic_symbols_),

[&name] (const std::unique_ptr<Symbol>& s) {

return s->name() == name;

});

if (it_symbol == std::end(dynamic_symbols_)) {

return nullptr;

}

return it_symbol->get();

}

const Symbol* Binary::get_symtab_symbol(const std::string& name) const {

const auto it_symbol = std::find_if(

std::begin(symtab_symbols_), std::end(symtab_symbols_),

[&name] (const std::unique_ptr<Symbol>& s) {

return s->name() == name;

});

if (it_symbol == std::end(symtab_symbols_)) {

return nullptr;

}

return it_symbol->get();

}

Binary::string_list_t Binary::strings(size_t min_size) const {

Binary::string_list_t list;

const Section* rodata = get_section(".rodata");

if (rodata == nullptr) {

return {};

}

span<const uint8_t> data = rodata->content();

std::string current;

current.reserve(100);

for (size_t i = 0; i < data.size(); ++i) {

uint8_t c = data[i];

// Terminator

if (c == '\0') {

if (current.size() >= min_size) {

list.push_back(current);

current.clear();

continue;

}

current.clear();

continue;

}

// Valid char

if (std::isprint(c) == 0) {

current.clear();

continue;

}

current.push_back(static_cast<char>(c));

}

return list;

}

std::vector<Symbol*> Binary::symtab_dyn_symbols() const {

std::vector<Symbol*> symbols;

symbols.reserve(symtab_symbols_.size() + dynamic_symbols_.size());

for (const std::unique_ptr<Symbol>& s : dynamic_symbols_) {

symbols.push_back(s.get());

}

for (const std::unique_ptr<Symbol>& s : symtab_symbols_) {

symbols.push_back(s.get());

}

return symbols;

}

// Exported

// --------

Binary::it_exported_symbols Binary::exported_symbols() {

return {symtab_dyn_symbols(), [] (const Symbol* symbol) {

return symbol->is_exported();

}};

}

Binary::it_const_exported_symbols Binary::exported_symbols() const {

return {symtab_dyn_symbols(), [] (const Symbol* symbol) {

return symbol->is_exported();

}};

}

// Imported

// --------

Binary::it_imported_symbols Binary::imported_symbols() {

return {symtab_dyn_symbols(), [] (const Symbol* symbol) {

return symbol->is_imported();

}};

}

Binary::it_const_imported_symbols Binary::imported_symbols() const {

return {symtab_dyn_symbols(), [] (const Symbol* symbol) {

return symbol->is_imported();

}};

}

void Binary::remove_symbol(const std::string& name) {

remove_symtab_symbol(name);

remove_dynamic_symbol(name);

}

void Binary::remove_symtab_symbol(const std::string& name) {

Symbol* sym = get_symtab_symbol(name);

if (sym == nullptr) {

LIEF_WARN("Can't find the symtab symbol '{}'. It won't be removed", name);

return;

}

remove_symtab_symbol(sym);

}

void Binary::remove_symtab_symbol(Symbol* symbol) {

if (symbol == nullptr) {

return;

}

const auto it_symbol = std::find_if(

std::begin(symtab_symbols_), std::end(symtab_symbols_),

[symbol] (const std::unique_ptr<Symbol>& sym) {

return *symbol == *sym;

}

);

if (it_symbol == std::end(symtab_symbols_)) {

LIEF_WARN("Can't find the symtab symbol '{}'. It won't be removed", symbol->name());

return;

}

symtab_symbols_.erase(it_symbol);

}

void Binary::remove_dynamic_symbol(const std::string& name) {

Symbol* sym = get_dynamic_symbol(name);

if (sym == nullptr) {

LIEF_WARN("Can't find the dynamic symbol '{}'. It won't be removed", name);

return;

}

remove_dynamic_symbol(sym);

}

void Binary::remove_dynamic_symbol(Symbol* symbol) {

if (symbol == nullptr) {

return;

}

const auto it_symbol = std::find_if(

std::begin(dynamic_symbols_), std::end(dynamic_symbols_),

[symbol] (const std::unique_ptr<Symbol>& sym) {

return *symbol == *sym;

}

);

if (it_symbol == std::end(dynamic_symbols_)) {

LIEF_WARN("Can't find the dynamic symbol '{}'. It won't be removed", symbol->name());

return;

}

// Update relocations

auto it_relocation = std::find_if(std::begin(relocations_), std::end(relocations_),

[symbol] (const std::unique_ptr<Relocation>& relocation) {

return relocation->purpose() == Relocation::PURPOSE::PLTGOT &&

relocation->has_symbol() && relocation->symbol() == symbol;

});

if (it_relocation != std::end(relocations_)) {

Relocation& R = **it_relocation;

/* That's the tricky part:

*

* If we remove the JUMP_SLOT relocation associated with the symbols,

* it will break the lazy resolution process.

*

* Let's consider the following relocations:

* [0] 0201018 R_X86_64_JUMP_SLO puts

* [1] 0201020 R_X86_64_JUMP_SLO printf

*

* Which are associated with these resolving stubs:

*

* push 0 // Index of puts in the relocations table

* jmp <resolver>

*

* push 1 // Index of printf in the relocation table

* jmp <resolver>

*

* If we remove 'puts' from the relocation table, 'printf' is shifted

* to the index 0 and the index in the resolving stub is corrupted (push 1).

* Thus for the general case, we can't "shrink" the relocation table.

* Instead, unbinding the 'symbol' from the relocation does not break the layout

* while still removing the symbol.

*/

R.symbol(nullptr);

}

const size_t nb_relocs = relocations_.size();

size_t rel_sizeof = 0;

relocations_.erase(

std::remove_if(relocations_.begin(), relocations_.end(),

[symbol, this, &rel_sizeof] (const std::unique_ptr<Relocation>& reloc) {

if (reloc->purpose() != Relocation::PURPOSE::DYNAMIC) {

return false;

}

if (const Symbol* sym = reloc->symbol(); sym == symbol) {

rel_sizeof = get_relocation_sizeof(*this, *reloc);

return true;

}

return false;

}

), relocations_.end());

const size_t nb_deleted_relocs = nb_relocs - relocations_.size();

if (nb_deleted_relocs > 0) {

const size_t relocs_size = nb_deleted_relocs * rel_sizeof;

if (auto* DT = get(DynamicEntry::TAG::RELASZ)) {

const uint64_t sizes = DT->value();

if (sizes >= relocs_size) {

DT->value(sizes - relocs_size);

}

}

else if (auto* DT = get(DynamicEntry::TAG::RELSZ)) {

const uint64_t sizes = DT->value();

if (sizes >= relocs_size) {

DT->value(sizes - relocs_size);

}

}

}

// Update symbol versions

if (symbol->has_version()) {

const auto it = std::find_if(

std::begin(symbol_version_table_), std::end(symbol_version_table_),

[symbol] (const std::unique_ptr<SymbolVersion>& sv) {

return sv.get() == symbol->symbol_version_;

}

);

if (it != std::end(symbol_version_table_)) {

symbol_version_table_.erase(it);

}

}

dynamic_symbols_.erase(it_symbol);

}

// Relocations

// ===========

// Dynamics

// --------

Binary::it_dynamic_relocations Binary::dynamic_relocations() {

return {relocations_, [] (const std::unique_ptr<Relocation>& reloc) {

return reloc->purpose() == Relocation::PURPOSE::DYNAMIC;

}

};

}

Binary::it_const_dynamic_relocations Binary::dynamic_relocations() const {

return {relocations_, [] (const std::unique_ptr<Relocation>& reloc) {

return reloc->purpose() == Relocation::PURPOSE::DYNAMIC;

}

};

}

Relocation& Binary::add_dynamic_relocation(const Relocation& relocation) {

if (!relocation.is_rel() && !relocation.is_rela()) {

LIEF_WARN("LIEF only supports regulard rel/rela relocations");

static Relocation None;

return None;

}

auto relocation_ptr = std::make_unique<Relocation>(relocation);

relocation_ptr->purpose(Relocation::PURPOSE::DYNAMIC);

relocation_ptr->architecture_ = header().machine_type();

// Add symbol

const Symbol* associated_sym = relocation.symbol();

if (associated_sym != nullptr) {

Symbol* inner_sym = get_dynamic_symbol(associated_sym->name());

if (inner_sym == nullptr) {

inner_sym = &(add_dynamic_symbol(*associated_sym));

}

const auto it_sym = std::find_if(

std::begin(dynamic_symbols_), std::end(dynamic_symbols_),

[inner_sym] (const std::unique_ptr<Symbol>& s) {

return s->name() == inner_sym->name();

});

const size_t idx = std::distance(std::begin(dynamic_symbols_), it_sym);

relocation_ptr->info(idx);

relocation_ptr->symbol(inner_sym);

}

// Update the Dynamic Section (Thanks to @yd0b0N)

bool is_rela = relocation.is_rela();

auto tag_sz = is_rela ? DynamicEntry::TAG::RELASZ :

DynamicEntry::TAG::RELSZ;

auto tag_ent = is_rela ? DynamicEntry::TAG::RELAENT :

DynamicEntry::TAG::RELENT;

DynamicEntry* dt_sz = get(tag_sz);

DynamicEntry* dt_ent = get(tag_ent);

if (dt_sz != nullptr && dt_ent != nullptr) {

dt_sz->value(dt_sz->value() + dt_ent->value());

}

relocations_.push_back(std::move(relocation_ptr));

return *relocations_.back();

}

Relocation& Binary::add_pltgot_relocation(const Relocation& relocation) {

auto relocation_ptr = std::make_unique<Relocation>(relocation);

relocation_ptr->purpose(Relocation::PURPOSE::PLTGOT);

relocation_ptr->architecture_ = header().machine_type();

// Add symbol

const Symbol* associated_sym = relocation.symbol();

if (associated_sym != nullptr) {

Symbol* inner_sym = get_dynamic_symbol(associated_sym->name());

if (inner_sym == nullptr) {

inner_sym = &(add_dynamic_symbol(*associated_sym));

}

const auto it_sym = std::find_if(

std::begin(dynamic_symbols_), std::end(dynamic_symbols_),

[inner_sym] (const std::unique_ptr<Symbol>& s) {

return s->name() == inner_sym->name();

});

const size_t idx = std::distance(std::begin(dynamic_symbols_), it_sym);

relocation_ptr->info(idx);

relocation_ptr->symbol(inner_sym);

}

// Update the Dynamic Section

size_t reloc_size = get_relocation_sizeof(*this, relocation);

DynamicEntry* dt_sz = get(DynamicEntry::TAG::PLTRELSZ);

if (dt_sz != nullptr && has(DynamicEntry::TAG::JMPREL)) {

dt_sz->value(dt_sz->value() + reloc_size);

}

relocations_.push_back(std::move(relocation_ptr));

return *relocations_.back();

}

Relocation* Binary::add_object_relocation(const Relocation& relocation, const Section& section) {

const auto it_section = std::find_if(std::begin(sections_), std::end(sections_),

[&section] (const std::unique_ptr<Section>& sec) {

return &section == sec.get();

});

if (it_section == std::end(sections_)) {

LIEF_ERR("Can't find section '{}'", section.name());

return nullptr;

}

auto relocation_ptr = std::make_unique<Relocation>(relocation);

relocation_ptr->purpose(Relocation::PURPOSE::OBJECT);

relocation_ptr->architecture_ = header().machine_type();

relocation_ptr->section_ = it_section->get();

relocations_.push_back(std::move(relocation_ptr));

return relocations_.back().get();

}

// plt/got

// -------

Binary::it_pltgot_relocations Binary::pltgot_relocations() {

return {relocations_, [] (const std::unique_ptr<Relocation>& reloc) {

return reloc->purpose() == Relocation::PURPOSE::PLTGOT;

}

};

}

Binary::it_const_pltgot_relocations Binary::pltgot_relocations() const {

return {relocations_, [] (const std::unique_ptr<Relocation>& reloc) {

return reloc->purpose() == Relocation::PURPOSE::PLTGOT;

}

};

}

// objects

// -------

Binary::it_object_relocations Binary::object_relocations() {

return {relocations_, [] (const std::unique_ptr<Relocation>& reloc) {

return reloc->purpose() == Relocation::PURPOSE::OBJECT;

}

};

}

Binary::it_const_object_relocations Binary::object_relocations() const {

return {relocations_, [] (const std::unique_ptr<Relocation>& reloc) {

return reloc->purpose() == Relocation::PURPOSE::OBJECT;

}

};

}

LIEF::Binary::relocations_t Binary::get_abstract_relocations() {

LIEF::Binary::relocations_t relocations;

relocations.reserve(relocations_.size());

std::transform(std::begin(relocations_), std::end(relocations_),

std::back_inserter(relocations),

[] (const std::unique_ptr<Relocation>& r) {

return r.get();

});

return relocations;

}

LIEF::Binary::symbols_t Binary::get_abstract_symbols() {

LIEF::Binary::symbols_t symbols;

symbols.reserve(dynamic_symbols_.size() + symtab_symbols_.size());

std::transform(std::begin(dynamic_symbols_), std::end(dynamic_symbols_),

std::back_inserter(symbols),

[] (std::unique_ptr<Symbol>& s) {

return s.get();

});

std::transform(std::begin(symtab_symbols_), std::end(symtab_symbols_),

std::back_inserter(symbols),

[] (std::unique_ptr<Symbol>& s) {

return s.get();

});

return symbols;

}

const Section* Binary::get_section(const std::string& name) const {

const auto it_section = std::find_if(

std::begin(sections_), std::end(sections_),

[&name] (const std::unique_ptr<Section>& section) {

return section->name() == name;

});

if (it_section == std::end(sections_)) {

return nullptr;

}

return it_section->get();

}

Section* Binary::dynamic_section() {

const auto it_dynamic_section = std::find_if(

std::begin(sections_), std::end(sections_),

[] (const std::unique_ptr<Section>& section) {

return section->type() == Section::TYPE::DYNAMIC;

});

if (it_dynamic_section == std::end(sections_)) {

return nullptr;

}

return it_dynamic_section->get();

}

Section* Binary::hash_section() {

const auto it_hash_section = std::find_if(

std::begin(sections_), std::end(sections_),

[] (const std::unique_ptr<Section>& section) {

return section->type() == Section::TYPE::HASH ||

section->type() == Section::TYPE::GNU_HASH;

});

if (it_hash_section == std::end(sections_)) {

return nullptr;

}

return it_hash_section->get();

}

Section* Binary::symtab_symbols_section() {

const auto it_symtab_section = std::find_if(

std::begin(sections_), std::end(sections_),

[] (const std::unique_ptr<Section>& section) {

return section->type() == Section::TYPE::SYMTAB;

});

if (it_symtab_section == std::end(sections_)) {

return nullptr;

}

return it_symtab_section->get();

}

uint64_t Binary::imagebase() const {

auto imagebase = static_cast<uint64_t>(-1);

for (const std::unique_ptr<Segment>& segment : segments_) {

if (segment != nullptr && segment->is_load()) {

imagebase = std::min(imagebase, segment->virtual_address() - segment->file_offset());

}

}

return imagebase;

}

uint64_t Binary::virtual_size() const {

uint64_t virtual_size = 0;

for (const std::unique_ptr<Segment>& segment : segments_) {

if (segment != nullptr && segment->is_load()) {

virtual_size = std::max(virtual_size, segment->virtual_address() + segment->virtual_size());

}

}

virtual_size = align(virtual_size, page_size());

return virtual_size - imagebase();

}

std::vector<uint8_t> Binary::raw() {

Builder builder{*this, Builder::config_t{}};

builder.build();

return builder.get_build();

}

result<uint64_t> Binary::get_function_address(const std::string& func_name) const {

if (auto res = get_function_address(func_name, /* demangle */true)) {

return *res;

}

if (auto res = get_function_address(func_name, /* demangle */false)) {

return *res;

}

return LIEF::Binary::get_function_address(func_name);;

}

result<uint64_t> Binary::get_function_address(const std::string& func_name, bool demangled) const {

const auto it_dynsym = std::find_if(

dynamic_symbols_.begin(), dynamic_symbols_.end(),

[&func_name, demangled] (const std::unique_ptr<Symbol>& symbol) {

std::string sname;

if (demangled) {

sname = symbol->demangled_name();

}

if (sname.empty()) {

sname = symbol->name();

}

return sname == func_name &&

symbol->type() == Symbol::TYPE::FUNC;

});

if (it_dynsym != dynamic_symbols_.end()) {

return (*it_dynsym)->value();

}

const auto it_symtab = std::find_if(

symtab_symbols_.begin(), symtab_symbols_.end(),

[&func_name, demangled] (const std::unique_ptr<Symbol>& symbol) {

std::string sname;

if (demangled) {

sname = symbol->demangled_name();

}

if (sname.empty()) {

sname = symbol->name();

}

return sname == func_name &&

symbol->type() == Symbol::TYPE::FUNC;

});

if (it_symtab != symtab_symbols_.end()) {

uint64_t value = (*it_symtab)->value();

if (value > 0) {

return value;

}

}

return make_error_code(lief_errors::not_found);

}

Section* Binary::add(const Section& section, bool loaded, SEC_INSERT_POS pos) {

if (section.is_frame()) {

return add_frame_section(section);

}

if (loaded) {