Class which represents an ELF binary. More...

#include <Binary.hpp>

Inheritance diagram for LIEF::ELF::Binary:

[legend]

Collaboration diagram for LIEF::ELF::Binary:

[legend]

Public Types
enum	PHDR_RELOC { AUTO = 0 , PIE_SHIFT , BSS_END , BINARY_END , SEGMENT_GAP }
enum class	SEC_INSERT_POS { AUTO = 0 , POST_SEGMENT , POST_SECTION }
	This enum defines where the content of a newly added section should be inserted. More...
using	string_list_t = std::vector<std::string>
using	notes_t = std::vector<std::unique_ptr<Note>>
	Internal container for storing notes.
using	it_notes = ref_iterator<notes_t&, Note*>
	Iterator which outputs Note& object.
using	it_const_notes = const_ref_iterator<const notes_t&, const Note*>
	Iterator which outputs const Note& object.
using	symbols_version_requirement_t = std::vector<std::unique_ptr<SymbolVersionRequirement>>
	Internal container for storing SymbolVersionRequirement.
using	it_symbols_version_requirement = ref_iterator<symbols_version_requirement_t&, SymbolVersionRequirement*>
	Iterator which outputs SymbolVersionRequirement& object.
using	it_const_symbols_version_requirement = const_ref_iterator<const symbols_version_requirement_t&, const SymbolVersionRequirement*>
	Iterator which outputs const SymbolVersionRequirement& object.
using	symbols_version_definition_t = std::vector<std::unique_ptr<SymbolVersionDefinition>>
	Internal container for storing SymbolVersionDefinition.
using	it_symbols_version_definition = ref_iterator<symbols_version_definition_t&, SymbolVersionDefinition*>
	Iterator which outputs SymbolVersionDefinition& object.
using	it_const_symbols_version_definition = const_ref_iterator<const symbols_version_definition_t&, const SymbolVersionDefinition*>
	Iterator which outputs const SymbolVersionDefinition& object.
using	segments_t = std::vector<std::unique_ptr<Segment>>
	Internal container for storing ELF's Segment.
using	it_segments = ref_iterator<segments_t&, Segment*>
	Iterator which outputs Segment& object.
using	it_const_segments = const_ref_iterator<const segments_t&, const Segment*>
	Iterator which outputs const Segment& object.
using	dynamic_entries_t = std::vector<std::unique_ptr<DynamicEntry>>
	Internal container for storing ELF's DynamicEntry.
using	it_dynamic_entries = ref_iterator<dynamic_entries_t&, DynamicEntry*>
	Iterator which outputs DynamicEntry& object.
using	it_const_dynamic_entries = const_ref_iterator<const dynamic_entries_t&, const DynamicEntry*>
	Iterator which outputs const DynamicEntry& object.
using	symbols_version_t = std::vector<std::unique_ptr<SymbolVersion>>
	Internal container for storing ELF's SymbolVersion.
using	it_symbols_version = ref_iterator<symbols_version_t&, SymbolVersion*>
	Iterator which outputs SymbolVersion& object.
using	it_const_symbols_version = const_ref_iterator<const symbols_version_t&, const SymbolVersion*>
	Iterator which outputs const SymbolVersion& object.
using	relocations_t = std::vector<std::unique_ptr<Relocation>>
	Internal container for storing ELF's Relocation.
using	it_pltgot_relocations = filter_iterator<relocations_t&, Relocation*>
	Iterator which outputs plt/got Relocation& object.
using	it_const_pltgot_relocations = const_filter_iterator<const relocations_t&, const Relocation*>
	Iterator which outputs plt/got const Relocation& object.
using	it_dynamic_relocations = filter_iterator<relocations_t&, Relocation*>
	Iterator which outputs dynamic Relocation& object (not related to the PLT/GOT mechanism).
using	it_const_dynamic_relocations = const_filter_iterator<const relocations_t&, const Relocation*>
	Iterator which outputs dynamic const Relocation& object (not related to the PLT/GOT mechanism).
using	it_object_relocations = filter_iterator<relocations_t&, Relocation*>
	Iterator which outputs Relocation& object found in object files (.o).
using	it_const_object_relocations = const_filter_iterator<const relocations_t&, const Relocation*>
	Iterator which outputs const Relocation& object found in object files (.o).
using	it_relocations = ref_iterator<relocations_t&, Relocation*>
	Iterator which outputs Relocation& object.
using	it_const_relocations = const_ref_iterator<const relocations_t&, const Relocation*>
	Iterator which outputs const Relocation& object.
using	symbols_t = std::vector<std::unique_ptr<Symbol>>
	Internal container for storing ELF's Symbol.
using	it_dynamic_symbols = ref_iterator<symbols_t&, Symbol*>
	Iterator which outputs the Dynamic Symbol& object.
using	it_const_dynamic_symbols = const_ref_iterator<const symbols_t&, const Symbol*>
	Iterator which outputs the Dynamic const Symbol& object.
using	it_symtab_symbols = ref_iterator<symbols_t&, Symbol*>
	Iterator which outputs the static/debug Symbol& object.
using	it_const_symtab_symbols = const_ref_iterator<const symbols_t&, const Symbol*>
	Iterator which outputs the static/debug const Symbol& object.
using	it_symbols = ref_iterator<std::vector<Symbol*>>
	Iterator which outputs static and dynamic Symbol& object.
using	it_const_symbols = const_ref_iterator<std::vector<Symbol*>>
	Iterator which outputs static and dynamic const Symbol& object.
using	it_exported_symbols = filter_iterator<std::vector<Symbol*>>
	Iterator which outputs exported Symbol& object.
using	it_const_exported_symbols = const_filter_iterator<std::vector<Symbol*>>
	Iterator which outputs exported const Symbol& object.
using	it_imported_symbols = filter_iterator<std::vector<Symbol*>>
	Iterator which outputs imported Symbol& object.
using	it_const_imported_symbols = const_filter_iterator<std::vector<Symbol*>>
	Iterator which outputs imported const Symbol& object.
using	sections_t = std::vector<std::unique_ptr<Section>>
	Internal container for storing ELF's Section.
using	it_sections = ref_iterator<sections_t&, Section*>
	Iterator which outputs Section& object.
using	it_const_sections = const_ref_iterator<const sections_t&, const Section*>
	Iterator which outputs const Section& object.
Public Types inherited from LIEF::Binary
enum class	VA_TYPES { AUTO = 0 , RVA = 1 , VA = 2 }
	Enumeration of virtual address types used for patching and memory access. More...
enum	FORMATS { UNKNOWN = 0 , ELF , PE , MACHO , OAT }
using	functions_t = std::vector<Function>
using	sections_t = std::vector<Section*>
	Internal container.
using	it_sections = ref_iterator<sections_t>
	Iterator that outputs LIEF::Section&.
using	it_const_sections = const_ref_iterator<sections_t>
	Iterator that outputs const LIEF::Section&.
using	symbols_t = std::vector<Symbol*>
	Internal container.
using	it_symbols = ref_iterator<symbols_t>
	Iterator that outputs LIEF::Symbol&.
using	it_const_symbols = const_ref_iterator<symbols_t>
	Iterator that outputs const LIEF::Symbol&.
using	relocations_t = std::vector<Relocation*>
	Internal container.
using	it_relocations = ref_iterator<relocations_t>
	Iterator that outputs LIEF::Relocation&.
using	it_const_relocations = const_ref_iterator<relocations_t>
	Iterator that outputs const LIEF::Relocation&.
using	instructions_it = iterator_range<assembly::Instruction::Iterator>
	Instruction iterator.
Public Types inherited from LIEF::Object
template<class T>
using	output_t = add_pointer_t<decay_t<T>>
template<class T>
using	output_const_t = add_pointer_t<add_const_t<decay_t<T>>>

Public Member Functions
Binary &	operator= (const Binary &)=delete
	Binary (const Binary &copy)=delete
Header::CLASS	type () const
	Return binary's class (ELF32 or ELF64).
Header &	header ()
	Return Elf header .
const Header &	header () const
uint64_t	last_offset_section () const
	Return the last offset used in binary according to sections table.
uint64_t	last_offset_segment () const
	Return the last offset used in binary according to segments table.
uint64_t	next_virtual_address () const
	Return the next virtual address available.
it_sections	sections ()
	Return an iterator over the binary's sections.
it_const_sections	sections () const
uint64_t	entrypoint () const override
	Return the binary's entrypoint.
it_segments	segments ()
	Return binary's segments.
it_const_segments	segments () const
it_dynamic_entries	dynamic_entries ()
	Return binary's dynamic entries.
it_const_dynamic_entries	dynamic_entries () const
DynamicEntry &	add (const DynamicEntry &entry)
	Add the given dynamic entry and return the new entry.
Note &	add (const Note &note)
	Add the given note and return the created entry.
void	remove (const DynamicEntry &entry)
	Remove the given dynamic entry.
void	remove (DynamicEntry::TAG tag)
	Remove all dynamic entries with the given tag.
void	remove (const Section &section, bool clear=false)
	Remove the given section. The clear parameter can be used to zeroize the original content beforehand.
void	remove (const Note &note)
	Remove the given note.
void	remove (Note::TYPE type)
	Remove all notes with the given type.
void	remove (const Segment &seg, bool clear=false)
	Remove the given segment. If `clear` is set, the original content of the segment will be filled with zeros before removal.
void	remove (Segment::TYPE type, bool clear=false)
	Remove all segments associated with the given type.
it_dynamic_symbols	dynamic_symbols ()
	Return an iterator over the binary's dynamic symbols The dynamic symbols are those located in the .dynsym section.
it_const_dynamic_symbols	dynamic_symbols () const
it_exported_symbols	exported_symbols ()
	Return symbols which are exported by the binary.
it_const_exported_symbols	exported_symbols () const
it_imported_symbols	imported_symbols ()
	Return symbols which are imported by the binary.
it_const_imported_symbols	imported_symbols () const
it_symtab_symbols	symtab_symbols ()
	Return the debug symbols from the .symtab section.
it_const_symtab_symbols	symtab_symbols () const
it_symbols_version	symbols_version ()
	Return the symbol versions.
it_const_symbols_version	symbols_version () const
it_symbols_version_definition	symbols_version_definition ()
	Return symbols version definition.
it_const_symbols_version_definition	symbols_version_definition () const
it_symbols_version_requirement	symbols_version_requirement ()
	Return Symbol version requirement.
it_const_symbols_version_requirement	symbols_version_requirement () const
it_dynamic_relocations	dynamic_relocations ()
	Return dynamic relocations.
it_const_dynamic_relocations	dynamic_relocations () const
Relocation &	add_dynamic_relocation (const Relocation &relocation)
	Add a new dynamic relocation.
Relocation &	add_pltgot_relocation (const Relocation &relocation)
	Add a .plt.got relocation. This kind of relocation is usually associated with a PLT stub that aims at resolving the underlying symbol.
Relocation *	add_object_relocation (const Relocation &relocation, const Section &section)
	Add relocation for object file (.o).
it_pltgot_relocations	pltgot_relocations ()
	Return plt.got relocations.
it_const_pltgot_relocations	pltgot_relocations () const
it_object_relocations	object_relocations ()
	Return relocations used in an object file (*.o).
it_const_object_relocations	object_relocations () const
it_relocations	relocations ()
	Return all relocations present in the binary.
it_const_relocations	relocations () const
const Relocation *	get_relocation (uint64_t address) const
	Return relocation associated with the given address. It returns a nullptr if it is not found.
Relocation *	get_relocation (uint64_t address)
const Relocation *	get_relocation (const Symbol &symbol) const
	Return relocation associated with the given Symbol It returns a nullptr if it is not found.
Relocation *	get_relocation (const Symbol &symbol)
const Relocation *	get_relocation (const std::string &symbol_name) const
	Return relocation associated with the given Symbol name It returns a nullptr if it is not found.
Relocation *	get_relocation (const std::string &symbol_name)
bool	use_gnu_hash () const
	true if GNU hash is used
const GnuHash *	gnu_hash () const
	Return the GnuHash object in readonly If the ELF binary does not use the GNU hash table, return a nullptr.
bool	use_sysv_hash () const
	true if SYSV hash is used
const SysvHash *	sysv_hash () const
	Return the SysvHash object as a read-only object If the ELF binary does not use the legacy sysv hash table, return a nullptr.
bool	has_section (const std::string &name) const
	Check if a section with the given name exists in the binary.
bool	has_section_with_offset (uint64_t offset) const
	Check if a section that handles the given offset exists.
bool	has_section_with_va (uint64_t va) const
	Check if a section that handles the given virtual address exists.
Section *	get_section (const std::string &name)
	Return Section with the given name. If the section can't be found, it returns a nullptr.
const Section *	get_section (const std::string &name) const
Section *	text_section ()
	Return the .text section. If the section can't be found, it returns a nullptr.
Section *	dynamic_section ()
	Return the .dynamic section. If the section can't be found, it returns a nullptr.
Section *	hash_section ()
	Return the hash section. If the section can't be found, it returns a nullptr.
Section *	symtab_symbols_section ()
	Return section which holds the symtab symbols. If the section can't be found, it returns a nullptr.
uint64_t	imagebase () const override
	Return program image base. For instance 0x40000.
uint64_t	virtual_size () const
	Return the size of the mapped binary.
bool	has_interpreter () const
	Check if the binary uses a loader (also named linker or interpreter).
const std::string &	interpreter () const
	Return the ELF interpreter if any. (e.g. /lib64/ld-linux-x86-64.so.2) If the binary does not have an interpreter, it returns an empty string.
void	interpreter (const std::string &interpreter)
	Change the interpreter.
it_symbols	symbols ()
	Return an iterator on both static and dynamic symbols.
it_const_symbols	symbols () const
Symbol &	export_symbol (const Symbol &symbol)
	Export the given symbol and create it if it doesn't exist.
Symbol &	export_symbol (const std::string &symbol_name, uint64_t value=0)
	Export the symbol with the given name and create it if it doesn't exist.
bool	has_dynamic_symbol (const std::string &name) const
	Check if the symbol with the given name exists in the dynamic symbols table.
const Symbol *	get_dynamic_symbol (const std::string &name) const
	Get the dynamic symbol from the given name. Return a nullptr if it can't be found.
Symbol *	get_dynamic_symbol (const std::string &name)
bool	has_symtab_symbol (const std::string &name) const
	Check if the symbol with the given name exists in the symtab symbol table.
const Symbol *	get_symtab_symbol (const std::string &name) const
	Get the symtab symbol from the given name Return a nullptr if it can't be found.
Symbol *	get_symtab_symbol (const std::string &name)
string_list_t	strings (size_t min_size=5) const
	Return list of the strings used by the ELF binary.
void	remove_symbol (const std::string &name)
	Remove symbols with the given name in both:
void	remove_symtab_symbol (const std::string &name)
	Remove symtabl symbols with the given name.
void	remove_symtab_symbol (Symbol *symbol)
void	remove_dynamic_symbol (const std::string &name)
	Remove dynamic symbols with the given name.
void	remove_dynamic_symbol (Symbol *symbol)
	Remove the given symbol from the dynamic symbols table.
result< uint64_t >	get_function_address (const std::string &func_name) const override
	Return the address of the given function name.
result< uint64_t >	get_function_address (const std::string &func_name, bool demangled) const
	Return the address of the given function name.
Section *	add (const Section &section, bool loaded=true, SEC_INSERT_POS pos=SEC_INSERT_POS::AUTO)
	Add a new section in the binary.
Section *	extend (const Section &section, uint64_t size)
Symbol &	add_symtab_symbol (const Symbol &symbol)
	Add a symtab symbol.
Symbol &	add_dynamic_symbol (const Symbol &symbol, const SymbolVersion *version=nullptr)
	Add a dynamic symbol with the associated SymbolVersion.
Symbol &	add_exported_function (uint64_t address, const std::string &name="")
	Create a symbol for the function at the given address and export it.
DynamicEntryLibrary &	add_library (const std::string &library_name)
	Add a library as dependency.
void	remove_library (const std::string &library_name)
	Remove the given library from the dependencies.
DynamicEntryLibrary *	get_library (const std::string &library_name)
	Get the library object (DynamicEntryLibrary) from the given name If the library can't be found, it returns a nullptr.
const DynamicEntryLibrary *	get_library (const std::string &library_name) const
	Get the library object (DynamicEntryLibrary) from the given name If the library can't be found, it returns a nullptr.
bool	has_library (const std::string &name) const
	Check if the given library name exists in the current binary.
Segment *	add (const Segment &segment, uint64_t base=0)
	Add a new segment in the binary.
Segment *	replace (const Segment &new_segment, const Segment &original_segment, uint64_t base=0)
	Replace the segment given in 2nd parameter with the segment given in the first one and return the updated segment.
Segment *	extend (const Segment &segment, uint64_t size)
void	patch_address (uint64_t address, const std::vector< uint8_t > &patch_value, LIEF::Binary::VA_TYPES addr_type=LIEF::Binary::VA_TYPES::AUTO) override
	Patch the content at virtual address `address` with `patch_value`.
void	patch_address (uint64_t address, uint64_t patch_value, size_t size=sizeof(uint64_t), LIEF::Binary::VA_TYPES addr_type=LIEF::Binary::VA_TYPES::AUTO) override
	Patch the address with the given value.
void	patch_pltgot (const Symbol &symbol, uint64_t address)
	Patch the imported symbol with the address.
void	patch_pltgot (const std::string &symbol_name, uint64_t address)
	Patch the imported symbol's name with the address.
void	strip ()
	Strip the binary by removing symtab symbols.
void	remove_section (const std::string &name, bool clear=false) override
	Remove a binary's section.
void	write (const std::string &filename)
	Reconstruct the binary object and write it in filename.
void	write (const std::string &filename, const Builder::config_t &config)
	Reconstruct the binary object with the given config and write it in filename.
void	write (std::ostream &os)
	Reconstruct the binary object and write it in os stream.
void	write (std::ostream &os, const Builder::config_t &config)
	Reconstruct the binary object with the given config and write it in os stream.
std::vector< uint8_t >	raw ()
	Reconstruct the binary object and return its content as a byte vector.
result< uint64_t >	virtual_address_to_offset (uint64_t virtual_address) const
	Convert a virtual address to a file offset.
result< uint64_t >	offset_to_virtual_address (uint64_t offset, uint64_t slide=0) const override
	Convert the given offset into a virtual address.
bool	is_pie () const override
	Check if the binary has been compiled with -fpie -pie flags.
bool	has_nx () const override
	Check if the binary uses the NX protection (Non executable stack).
int64_t	dynsym_idx (const std::string &name) const
	Symbol index in the dynamic symbol table or -1 if the symbol does not exist.
int64_t	dynsym_idx (const Symbol &sym) const
int64_t	symtab_idx (const std::string &name) const
	Symbol index from the .symtab section or -1 if the symbol is not present.
int64_t	symtab_idx (const Symbol &sym) const
const Section *	section_from_offset (uint64_t offset, bool skip_nobits=true) const
	Return the ELF::Section from the given `offset`. Return a nullptr if a section can't be found.
Section *	section_from_offset (uint64_t offset, bool skip_nobits=true)
const Section *	section_from_virtual_address (uint64_t address, bool skip_nobits=true) const
	Return the ELF::Section from the given `address`. Return a nullptr if a section can't be found.
Section *	section_from_virtual_address (uint64_t address, bool skip_nobits=true)
const Segment *	segment_from_virtual_address (uint64_t address) const
	Return the ELF::Segment from the given `address`. Return a nullptr if a segment can't be found.
Segment *	segment_from_virtual_address (uint64_t address)
const Segment *	segment_from_virtual_address (Segment::TYPE type, uint64_t address) const
Segment *	segment_from_virtual_address (Segment::TYPE type, uint64_t address)
const Segment *	segment_from_offset (uint64_t offset) const
	Return the ELF::Segment from the `offset`. Return a nullptr if a segment can't be found.
Segment *	segment_from_offset (uint64_t offset)
const DynamicEntry *	get (DynamicEntry::TAG tag) const
	Return the first ELF::DynamicEntry associated with the given tag If the tag can't be found, it returns a nullptr.
DynamicEntry *	get (DynamicEntry::TAG tag)
const Segment *	get (Segment::TYPE type) const
	Return the first ELF::Segment associated with the given type. If a segment can't be found, it returns a nullptr.
Segment *	get (Segment::TYPE type)
const Note *	get (Note::TYPE type) const
	Return the first ELF::Note associated with the given type If a note can't be found, it returns a nullptr.
Note *	get (Note::TYPE type)
const Section *	get (Section::TYPE type) const
	Return the first ELF::Section associated with the given type If a section can't be found, it returns a nullptr.
Section *	get (Section::TYPE type)
bool	has (DynamicEntry::TAG tag) const
	Check if an ELF::DynamicEntry associated with the given tag exists.
bool	has (Segment::TYPE type) const
	Check if ELF::Segment associated with the given type exists.
bool	has (Note::TYPE type) const
	Check if a ELF::Note associated with the given type exists.
bool	has (Section::TYPE type) const
	Check if a ELF::Section associated with the given type exists.
span< const uint8_t >	get_content_from_virtual_address (uint64_t virtual_address, uint64_t size, Binary::VA_TYPES addr_type=Binary::VA_TYPES::AUTO) const override
	Return the content located at virtual address.
void	accept (LIEF::Visitor &visitor) const override
	Method associated with the visitor pattern.
void	permute_dynamic_symbols (const std::vector< size_t > &permutation)
	Apply the given permutation on the dynamic symbols table.
LIEF::Binary::functions_t	ctor_functions () const override
	List of binary constructors (typically, the functions located in the .init_array).
LIEF::Binary::functions_t	dtor_functions () const
	List of the binary destructors (typically, the functions located in the .fini_array).
LIEF::Binary::functions_t	functions () const
	List of the functions found the in the binary.
bool	has_notes () const
	true if the binary embeds notes
it_const_notes	notes () const
	Return an iterator over the ELF's LIEF::ELF::Note.
it_notes	notes ()
uint64_t	eof_offset () const
	Return the last offset used by the ELF binary according to both: the sections table and the segments table.
bool	has_overlay () const
	True if data are present at the end of the binary.
span< const uint8_t >	overlay () const
	Overlay data (if any).
void	overlay (std::vector< uint8_t > overlay)
	Function to set the overlay.
uint64_t	relocate_phdr_table (PHDR_RELOC type)
	Force relocating the segments table in a specific way.
std::vector< uint64_t >	get_relocated_dynamic_array (DynamicEntry::TAG tag) const
	Return the array defined by the given tag (e.g. DynamicEntry::TAG::INIT_ARRAY) with relocations applied (if any).
bool	is_targeting_android () const
	True if the current ELF is targeting Android.
result< size_t >	get_section_idx (const Section &section) const
	Find the index of the section given in the first parameter.
result< size_t >	get_section_idx (const std::string &name) const
	Find the index of the section with the name given in the first parameter.
const SymbolVersionRequirement *	find_version_requirement (const std::string &libname) const
	Try to find the SymbolVersionRequirement associated with the given library name (e.g. libc.so.6).
SymbolVersionRequirement *	find_version_requirement (const std::string &name)
bool	remove_version_requirement (const std::string &libname)
	Deletes all required symbol versions linked to the specified library name. The function returns true if the operation succeed, false otherwise.
uint8_t	ptr_size () const
uint64_t	page_size () const override
	Get the default memory page size according to the architecture and the format of the current binary.
size_t	hash (const std::string &name)
	~Binary () override
std::ostream &	print (std::ostream &os) const override
Binary &	operator+= (const DynamicEntry &entry)
Binary &	operator+= (const Section &section)
Binary &	operator+= (const Segment &segment)
Binary &	operator+= (const Note &note)
Binary &	operator-= (const DynamicEntry &entry)
Binary &	operator-= (DynamicEntry::TAG tag)
Binary &	operator-= (const Note &note)
Binary &	operator-= (Note::TYPE type)
Segment *	operator[] (Segment::TYPE type)
const Segment *	operator[] (Segment::TYPE type) const
DynamicEntry *	operator[] (DynamicEntry::TAG tag)
const DynamicEntry *	operator[] (DynamicEntry::TAG tag) const
Note *	operator[] (Note::TYPE type)
const Note *	operator[] (Note::TYPE type) const
Section *	operator[] (Section::TYPE type)
const Section *	operator[] (Section::TYPE type) const
bool	should_swap () const
Public Member Functions inherited from LIEF::Binary
	Binary ()
	Binary (FORMATS fmt)
	~Binary () override
Binary &	operator= (const Binary &)=delete
	Binary (const Binary &)=delete
FORMATS	format () const
	Executable format (ELF, PE, Mach-O) of the underlying binary.
Header	header () const
	Return the abstract header of the binary.
it_symbols	symbols ()
	Return an iterator over the abstracted symbols in which the elements can be modified.
it_const_symbols	symbols () const
	Return an iterator over the abstracted symbols in which the elements can't be modified.
bool	has_symbol (const std::string &name) const
	Check if a Symbol with the given name exists.
const Symbol *	get_symbol (const std::string &name) const
	Return the Symbol with the given name If the symbol does not exist, return a nullptr.
Symbol *	get_symbol (const std::string &name)
it_sections	sections ()
	Return an iterator over the binary's sections (LIEF::Section).
it_const_sections	sections () const
it_relocations	relocations ()
	Return an iterator over the binary relocation (LIEF::Relocation).
it_const_relocations	relocations () const
uint64_t	original_size () const
	Binary's original size.
functions_t	exported_functions () const
	Return the functions exported by the binary.
std::vector< std::string >	imported_libraries () const
	Return libraries which are imported by the binary.
functions_t	imported_functions () const
	Return functions imported by the binary.
std::vector< uint64_t >	xref (uint64_t address) const
template<class T>
LIEF::result< T >	get_int_from_virtual_address (uint64_t va, VA_TYPES addr_type=VA_TYPES::AUTO) const
	Get the integer value at the given virtual address.
void	original_size (uint64_t size)
	Change binary's original size.
DebugInfo *	debug_info () const
	Return the debug info if present. It can be either a LIEF::dwarf::DebugInfo or a LIEF::pdb::DebugInfo.
instructions_it	disassemble (uint64_t address, size_t size) const
	Disassemble code starting at the given virtual address and with the given size.
instructions_it	disassemble (uint64_t address) const
	Disassemble code starting at the given virtual address.
instructions_it	disassemble (const std::string &function) const
	Disassemble code for the given symbol name.
instructions_it	disassemble (const uint8_t *buffer, size_t size, uint64_t address=0) const
	Disassemble code provided by the given buffer at the specified address parameter.
instructions_it	disassemble (const std::vector< uint8_t > &buffer, uint64_t address=0) const
	Disassemble code provided by the given vector of bytes at the specified address parameter.
instructions_it	disassemble (LIEF::span< const uint8_t > buffer, uint64_t address=0) const
instructions_it	disassemble (LIEF::span< uint8_t > buffer, uint64_t address=0) const
std::vector< uint8_t >	assemble (uint64_t address, const std::string &Asm, assembly::AssemblerConfig &config=assembly::AssemblerConfig::default_config())
	Assemble and patch the provided assembly code at the specified address.
std::vector< uint8_t >	assemble (uint64_t address, const llvm::MCInst &inst)
	Assemble and patch the address with the given LLVM MCInst.
std::vector< uint8_t >	assemble (uint64_t address, const std::vector< llvm::MCInst > &insts)
	Assemble and patch the address with the given LLVM MCInst.
DebugInfo *	load_debug_info (const std::string &path)
	Load and associate an external debug file (e.g., DWARF or PDB) with this binary.
Public Member Functions inherited from LIEF::Object
	Object ()
	Object (const Object &other)
Object &	operator= (const Object &other)
	Object (Object &&other) noexcept=default
Object &	operator= (Object &&other) noexcept=default
template<class T>
output_t< T >	as ()
template<class T>
output_const_t< T >	as () const
virtual bool	operator== (const Object &other) const
virtual bool	operator!= (const Object &other) const
virtual	~Object ()

Static Public Member Functions
static bool	classof (const LIEF::Binary *bin)

Detailed Description

Class which represents an ELF binary.

Member Typedef Documentation

◆ dynamic_entries_t

using LIEF::ELF::Binary::dynamic_entries_t = std::vector<std::unique_ptr<DynamicEntry>>

Internal container for storing ELF's DynamicEntry.

◆ it_const_dynamic_entries

using LIEF::ELF::Binary::it_const_dynamic_entries = const_ref_iterator<const dynamic_entries_t&, const DynamicEntry*>

Iterator which outputs const DynamicEntry& object.

◆ it_const_dynamic_relocations

using LIEF::ELF::Binary::it_const_dynamic_relocations = const_filter_iterator<const relocations_t&, const Relocation*>

Iterator which outputs dynamic const Relocation& object (not related to the PLT/GOT mechanism).

◆ it_const_dynamic_symbols

using LIEF::ELF::Binary::it_const_dynamic_symbols = const_ref_iterator<const symbols_t&, const Symbol*>

Iterator which outputs the Dynamic const Symbol& object.

◆ it_const_exported_symbols

using LIEF::ELF::Binary::it_const_exported_symbols = const_filter_iterator<std::vector<Symbol*>>

Iterator which outputs exported const Symbol& object.

◆ it_const_imported_symbols

using LIEF::ELF::Binary::it_const_imported_symbols = const_filter_iterator<std::vector<Symbol*>>

Iterator which outputs imported const Symbol& object.

◆ it_const_notes

using LIEF::ELF::Binary::it_const_notes = const_ref_iterator<const notes_t&, const Note*>

Iterator which outputs const Note& object.

◆ it_const_object_relocations

using LIEF::ELF::Binary::it_const_object_relocations = const_filter_iterator<const relocations_t&, const Relocation*>

Iterator which outputs const Relocation& object found in object files (.o).

◆ it_const_pltgot_relocations

using LIEF::ELF::Binary::it_const_pltgot_relocations = const_filter_iterator<const relocations_t&, const Relocation*>

Iterator which outputs plt/got const Relocation& object.

◆ it_const_relocations

using LIEF::ELF::Binary::it_const_relocations = const_ref_iterator<const relocations_t&, const Relocation*>

Iterator which outputs const Relocation& object.

◆ it_const_sections

using LIEF::ELF::Binary::it_const_sections = const_ref_iterator<const sections_t&, const Section*>

Iterator which outputs const Section& object.

◆ it_const_segments

using LIEF::ELF::Binary::it_const_segments = const_ref_iterator<const segments_t&, const Segment*>

Iterator which outputs const Segment& object.

◆ it_const_symbols

using LIEF::ELF::Binary::it_const_symbols = const_ref_iterator<std::vector<Symbol*>>

Iterator which outputs static and dynamic const Symbol& object.

◆ it_const_symbols_version

using LIEF::ELF::Binary::it_const_symbols_version = const_ref_iterator<const symbols_version_t&, const SymbolVersion*>

Iterator which outputs const SymbolVersion& object.

◆ it_const_symbols_version_definition

using LIEF::ELF::Binary::it_const_symbols_version_definition = const_ref_iterator<const symbols_version_definition_t&, const SymbolVersionDefinition*>

Iterator which outputs const SymbolVersionDefinition& object.

◆ it_const_symbols_version_requirement

using LIEF::ELF::Binary::it_const_symbols_version_requirement = const_ref_iterator<const symbols_version_requirement_t&, const SymbolVersionRequirement*>

Iterator which outputs const SymbolVersionRequirement& object.

◆ it_const_symtab_symbols

using LIEF::ELF::Binary::it_const_symtab_symbols = const_ref_iterator<const symbols_t&, const Symbol*>

Iterator which outputs the static/debug const Symbol& object.

◆ it_dynamic_entries

using LIEF::ELF::Binary::it_dynamic_entries = ref_iterator<dynamic_entries_t&, DynamicEntry*>

Iterator which outputs DynamicEntry& object.

◆ it_dynamic_relocations

using LIEF::ELF::Binary::it_dynamic_relocations = filter_iterator<relocations_t&, Relocation*>

Iterator which outputs dynamic Relocation& object (not related to the PLT/GOT mechanism).

◆ it_dynamic_symbols

using LIEF::ELF::Binary::it_dynamic_symbols = ref_iterator<symbols_t&, Symbol*>

Iterator which outputs the Dynamic Symbol& object.

◆ it_exported_symbols

using LIEF::ELF::Binary::it_exported_symbols = filter_iterator<std::vector<Symbol*>>

Iterator which outputs exported Symbol& object.

◆ it_imported_symbols

using LIEF::ELF::Binary::it_imported_symbols = filter_iterator<std::vector<Symbol*>>

Iterator which outputs imported Symbol& object.

◆ it_notes

using LIEF::ELF::Binary::it_notes = ref_iterator<notes_t&, Note*>

Iterator which outputs Note& object.

◆ it_object_relocations

using LIEF::ELF::Binary::it_object_relocations = filter_iterator<relocations_t&, Relocation*>

Iterator which outputs Relocation& object found in object files (.o).

◆ it_pltgot_relocations

using LIEF::ELF::Binary::it_pltgot_relocations = filter_iterator<relocations_t&, Relocation*>

Iterator which outputs plt/got Relocation& object.

◆ it_relocations

using LIEF::ELF::Binary::it_relocations = ref_iterator<relocations_t&, Relocation*>

Iterator which outputs Relocation& object.

◆ it_sections

using LIEF::ELF::Binary::it_sections = ref_iterator<sections_t&, Section*>

Iterator which outputs Section& object.

◆ it_segments

using LIEF::ELF::Binary::it_segments = ref_iterator<segments_t&, Segment*>

Iterator which outputs Segment& object.

◆ it_symbols

using LIEF::ELF::Binary::it_symbols = ref_iterator<std::vector<Symbol*>>

Iterator which outputs static and dynamic Symbol& object.

◆ it_symbols_version

using LIEF::ELF::Binary::it_symbols_version = ref_iterator<symbols_version_t&, SymbolVersion*>

Iterator which outputs SymbolVersion& object.

◆ it_symbols_version_definition

using LIEF::ELF::Binary::it_symbols_version_definition = ref_iterator<symbols_version_definition_t&, SymbolVersionDefinition*>

Iterator which outputs SymbolVersionDefinition& object.

◆ it_symbols_version_requirement

using LIEF::ELF::Binary::it_symbols_version_requirement = ref_iterator<symbols_version_requirement_t&, SymbolVersionRequirement*>

Iterator which outputs SymbolVersionRequirement& object.

◆ it_symtab_symbols

using LIEF::ELF::Binary::it_symtab_symbols = ref_iterator<symbols_t&, Symbol*>

Iterator which outputs the static/debug Symbol& object.

◆ notes_t

using LIEF::ELF::Binary::notes_t = std::vector<std::unique_ptr<Note>>

Internal container for storing notes.

◆ relocations_t

using LIEF::ELF::Binary::relocations_t = std::vector<std::unique_ptr<Relocation>>

Internal container for storing ELF's Relocation.

◆ sections_t

using LIEF::ELF::Binary::sections_t = std::vector<std::unique_ptr<Section>>

Internal container for storing ELF's Section.

◆ segments_t

using LIEF::ELF::Binary::segments_t = std::vector<std::unique_ptr<Segment>>

Internal container for storing ELF's Segment.

◆ string_list_t

using LIEF::ELF::Binary::string_list_t = std::vector<std::string>

◆ symbols_t

using LIEF::ELF::Binary::symbols_t = std::vector<std::unique_ptr<Symbol>>

Internal container for storing ELF's Symbol.

◆ symbols_version_definition_t

using LIEF::ELF::Binary::symbols_version_definition_t = std::vector<std::unique_ptr<SymbolVersionDefinition>>

Internal container for storing SymbolVersionDefinition.

◆ symbols_version_requirement_t

using LIEF::ELF::Binary::symbols_version_requirement_t = std::vector<std::unique_ptr<SymbolVersionRequirement>>

Internal container for storing SymbolVersionRequirement.

◆ symbols_version_t

using LIEF::ELF::Binary::symbols_version_t = std::vector<std::unique_ptr<SymbolVersion>>

Internal container for storing ELF's SymbolVersion.

Member Enumeration Documentation

◆ PHDR_RELOC

enum LIEF::ELF::Binary::PHDR_RELOC

This enum describes the different ways to relocate the segments table.

Enumerator
AUTO	Defer the choice of the layout to LIEF.
PIE_SHIFT	The content of the binary right after the segments table is shifted and the relocations are updated accordingly. This kind of shift only works with PIE binaries.
BSS_END	The new segments table is relocated right after the first bss-like segment.
BINARY_END	The new segments table is relocated at the end of the binary.
SEGMENT_GAP	The new segments table is relocated between two LOAD segments. This kind of relocation is only doable when there is an alignment enforcement.

◆ SEC_INSERT_POS

enum class LIEF::ELF::Binary::SEC_INSERT_POS

strong

This enum defines where the content of a newly added section should be inserted.

Enumerator

AUTO

Defer the choice to LIEF.

POST_SEGMENT

Insert the section after the last valid offset in the segments table.

With this choice, the section is inserted after the loaded content but before any debug information.

POST_SECTION

Insert the section after the last valid offset in the section table.

With this choice, the section is inserted at the very end of the binary.

Constructor & Destructor Documentation

◆ Binary()

LIEF::ELF::Binary::Binary ( const Binary & copy )

delete

◆ ~Binary()

LIEF::ELF::Binary::~Binary ( )

override

Member Function Documentation

◆ accept()

void LIEF::ELF::Binary::accept ( LIEF::Visitor & visitor ) const

overridevirtual

Method associated with the visitor pattern.

Reimplemented from LIEF::Binary.

Reimplemented in LIEF::OAT::Binary.

◆ add() [1/4]

DynamicEntry & LIEF::ELF::Binary::add ( const DynamicEntry & entry )

Add the given dynamic entry and return the new entry.

Referenced by operator+=(), operator+=(), operator+=(), and operator+=().

◆ add() [2/4]

Note & LIEF::ELF::Binary::add ( const Note & note )

Add the given note and return the created entry.

◆ add() [3/4]

Section * LIEF::ELF::Binary::add	(	const Section &	section,
		bool	loaded = true,
		SEC_INSERT_POS	pos = SEC_INSERT_POS::AUTO )

Add a new section in the binary.

Parameters

[in]	section	The section object to insert
[in]	loaded	Boolean value to indicate that section's data must be loaded by a PT_LOAD segment
[in]	pos	Position where to insert the data in the sections table

Returns: The section added. The size and the virtual address might change.

This function requires a well-formed ELF binary

References AUTO.

◆ add() [4/4]

Segment * LIEF::ELF::Binary::add	(	const Segment &	segment,
		uint64_t	base = 0 )

Add a new segment in the binary.

The segment is inserted at the end

Returns: The segment added. Virtual address and File Offset might change.

This function requires a well-formed ELF binary

◆ add_dynamic_relocation()

Relocation & LIEF::ELF::Binary::add_dynamic_relocation ( const Relocation & relocation )

Add a new dynamic relocation.

We consider a dynamic relocation as a relocation which is not plt-related

See: add_pltgot_relocation

◆ add_dynamic_symbol()

Symbol & LIEF::ELF::Binary::add_dynamic_symbol	(	const Symbol &	symbol,
		const SymbolVersion *	version = nullptr )

Add a dynamic symbol with the associated SymbolVersion.

References LIEF::version().

◆ add_exported_function()

Symbol & LIEF::ELF::Binary::add_exported_function	(	uint64_t	address,
		const std::string &	name = "" )

Create a symbol for the function at the given address and export it.

◆ add_library()

DynamicEntryLibrary & LIEF::ELF::Binary::add_library ( const std::string & library_name )

Add a library as dependency.

◆ add_object_relocation()

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

Add relocation for object file (.o).

The first parameter is the section to add while the second parameter is the LIEF::ELF::Section associated with the relocation.

If there is an error, this function returns a nullptr. Otherwise, it returns the relocation added.

◆ add_pltgot_relocation()

Relocation & LIEF::ELF::Binary::add_pltgot_relocation ( const Relocation & relocation )

Add a .plt.got relocation. This kind of relocation is usually associated with a PLT stub that aims at resolving the underlying symbol.

◆ add_symtab_symbol()

Symbol & LIEF::ELF::Binary::add_symtab_symbol ( const Symbol & symbol )

Add a symtab symbol.

◆ classof()

bool LIEF::ELF::Binary::classof ( const LIEF::Binary * bin )

inlinestatic

References LIEF::Binary::ELF, LIEF::Binary::format(), and LIEF::Binary::OAT.

◆ ctor_functions()

LIEF::Binary::functions_t LIEF::ELF::Binary::ctor_functions ( ) const

overridevirtual

List of binary constructors (typically, the functions located in the .init_array).

Implements LIEF::Binary.

◆ dtor_functions()

LIEF::Binary::functions_t LIEF::ELF::Binary::dtor_functions ( ) const

List of the binary destructors (typically, the functions located in the .fini_array).

◆ dynamic_entries() [1/2]

it_dynamic_entries LIEF::ELF::Binary::dynamic_entries ( )

inline

Return binary's dynamic entries.

◆ dynamic_entries() [2/2]

it_const_dynamic_entries LIEF::ELF::Binary::dynamic_entries ( ) const

inline

◆ dynamic_relocations() [1/2]

it_dynamic_relocations LIEF::ELF::Binary::dynamic_relocations ( )

Return dynamic relocations.

◆ dynamic_relocations() [2/2]

it_const_dynamic_relocations LIEF::ELF::Binary::dynamic_relocations ( ) const

◆ dynamic_section()

Section * LIEF::ELF::Binary::dynamic_section ( )

Return the .dynamic section. If the section can't be found, it returns a nullptr.

◆ dynamic_symbols() [1/2]

it_dynamic_symbols LIEF::ELF::Binary::dynamic_symbols ( )

inline

Return an iterator over the binary's dynamic symbols The dynamic symbols are those located in the .dynsym section.

◆ dynamic_symbols() [2/2]

it_const_dynamic_symbols LIEF::ELF::Binary::dynamic_symbols ( ) const

inline

◆ dynsym_idx() [1/2]

int64_t LIEF::ELF::Binary::dynsym_idx ( const std::string & name ) const

Symbol index in the dynamic symbol table or -1 if the symbol does not exist.

◆ dynsym_idx() [2/2]

int64_t LIEF::ELF::Binary::dynsym_idx ( const Symbol & sym ) const

◆ entrypoint()

uint64_t LIEF::ELF::Binary::entrypoint ( ) const

inlineoverridevirtual

Return the binary's entrypoint.

Implements LIEF::Binary.

◆ eof_offset()

uint64_t LIEF::ELF::Binary::eof_offset ( ) const

Return the last offset used by the ELF binary according to both: the sections table and the segments table.

◆ export_symbol() [1/2]

Symbol & LIEF::ELF::Binary::export_symbol	(	const std::string &	symbol_name,
		uint64_t	value = 0 )

Export the symbol with the given name and create it if it doesn't exist.

◆ export_symbol() [2/2]

Symbol & LIEF::ELF::Binary::export_symbol ( const Symbol & symbol )

Export the given symbol and create it if it doesn't exist.

◆ exported_symbols() [1/2]

it_exported_symbols LIEF::ELF::Binary::exported_symbols ( )

Return symbols which are exported by the binary.

◆ exported_symbols() [2/2]

it_const_exported_symbols LIEF::ELF::Binary::exported_symbols ( ) const

◆ extend() [1/2]

Section * LIEF::ELF::Binary::extend	(	const Section &	section,
		uint64_t	size )

◆ extend() [2/2]

Segment * LIEF::ELF::Binary::extend	(	const Segment &	segment,
		uint64_t	size )

◆ find_version_requirement() [1/2]

const SymbolVersionRequirement * LIEF::ELF::Binary::find_version_requirement ( const std::string & libname ) const

Try to find the SymbolVersionRequirement associated with the given library name (e.g. libc.so.6).

◆ find_version_requirement() [2/2]

SymbolVersionRequirement * LIEF::ELF::Binary::find_version_requirement ( const std::string & name )

inline

References Binary().

◆ functions()

LIEF::Binary::functions_t LIEF::ELF::Binary::functions ( ) const

List of the functions found the in the binary.

◆ get() [1/8]

DynamicEntry * LIEF::ELF::Binary::get ( DynamicEntry::TAG tag )

inline

References Binary().

◆ get() [2/8]

const DynamicEntry * LIEF::ELF::Binary::get ( DynamicEntry::TAG tag ) const

Return the first ELF::DynamicEntry associated with the given tag If the tag can't be found, it returns a nullptr.

Referenced by has(), has(), has(), has(), operator[](), operator[](), operator[](), operator[](), operator[](), operator[](), operator[](), and operator[]().

◆ get() [3/8]

Note * LIEF::ELF::Binary::get ( Note::TYPE type )

inline

References Binary(), and type().

◆ get() [4/8]

const Note * LIEF::ELF::Binary::get ( Note::TYPE type ) const

Return the first ELF::Note associated with the given type If a note can't be found, it returns a nullptr.

References type().

◆ get() [5/8]

Section * LIEF::ELF::Binary::get ( Section::TYPE type )

inline

References Binary(), and type().

◆ get() [6/8]

const Section * LIEF::ELF::Binary::get ( Section::TYPE type ) const

Return the first ELF::Section associated with the given type If a section can't be found, it returns a nullptr.

References type().

◆ get() [7/8]

Segment * LIEF::ELF::Binary::get ( Segment::TYPE type )

inline

References Binary(), and type().

◆ get() [8/8]

const Segment * LIEF::ELF::Binary::get ( Segment::TYPE type ) const

Return the first ELF::Segment associated with the given type. If a segment can't be found, it returns a nullptr.

References type().

◆ get_content_from_virtual_address()

span< const uint8_t > LIEF::ELF::Binary::get_content_from_virtual_address	(	uint64_t	virtual_address,
		uint64_t	size,
		Binary::VA_TYPES	addr_type = Binary::VA_TYPES::AUTO ) const

overridevirtual

Return the content located at virtual address.

Implements LIEF::Binary.

References LIEF::Binary::AUTO.

◆ get_dynamic_symbol() [1/2]

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

inline

References Binary().

◆ get_dynamic_symbol() [2/2]

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

Get the dynamic symbol from the given name. Return a nullptr if it can't be found.

Referenced by has_dynamic_symbol().

◆ get_function_address() [1/2]

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

overridevirtual

Return the address of the given function name.

Reimplemented from LIEF::Binary.

◆ get_function_address() [2/2]

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

Return the address of the given function name.

Parameters

[in]	func_name	The function's name target
[in]	demangled	Use the demangled name

◆ get_library() [1/2]

DynamicEntryLibrary * LIEF::ELF::Binary::get_library ( const std::string & library_name )

inline

Get the library object (DynamicEntryLibrary) from the given name If the library can't be found, it returns a nullptr.

References Binary().

Referenced by has_library().

◆ get_library() [2/2]

const DynamicEntryLibrary * LIEF::ELF::Binary::get_library ( const std::string & library_name ) const

Get the library object (DynamicEntryLibrary) from the given name If the library can't be found, it returns a nullptr.

◆ get_relocated_dynamic_array()

std::vector< uint64_t > LIEF::ELF::Binary::get_relocated_dynamic_array ( DynamicEntry::TAG tag ) const

Return the array defined by the given tag (e.g. DynamicEntry::TAG::INIT_ARRAY) with relocations applied (if any).

◆ get_relocation() [1/6]

Relocation * LIEF::ELF::Binary::get_relocation ( const std::string & symbol_name )

inline

References Binary().

◆ get_relocation() [2/6]

const Relocation * LIEF::ELF::Binary::get_relocation ( const std::string & symbol_name ) const

Return relocation associated with the given Symbol name It returns a nullptr if it is not found.

◆ get_relocation() [3/6]

Relocation * LIEF::ELF::Binary::get_relocation ( const Symbol & symbol )

inline

References Binary().

◆ get_relocation() [4/6]

const Relocation * LIEF::ELF::Binary::get_relocation ( const Symbol & symbol ) const

Return relocation associated with the given Symbol It returns a nullptr if it is not found.

◆ get_relocation() [5/6]

Relocation * LIEF::ELF::Binary::get_relocation ( uint64_t address )

inline

References Binary().

◆ get_relocation() [6/6]

const Relocation * LIEF::ELF::Binary::get_relocation ( uint64_t address ) const

Return relocation associated with the given address. It returns a nullptr if it is not found.

◆ get_section() [1/2]

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

inline

Return Section with the given name. If the section can't be found, it returns a nullptr.

References Binary().

Referenced by has_section(), and text_section().

◆ get_section() [2/2]

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

◆ get_section_idx() [1/2]

result< size_t > LIEF::ELF::Binary::get_section_idx ( const Section & section ) const

inline

Find the index of the section given in the first parameter.

References make_error_code(), and not_found.

◆ get_section_idx() [2/2]

result< size_t > LIEF::ELF::Binary::get_section_idx ( const std::string & name ) const

inline

Find the index of the section with the name given in the first parameter.

References make_error_code(), and not_found.

◆ get_symtab_symbol() [1/2]

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

inline

References Binary().

◆ get_symtab_symbol() [2/2]

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

Get the symtab symbol from the given name Return a nullptr if it can't be found.

Referenced by has_symtab_symbol().

◆ gnu_hash()

const GnuHash * LIEF::ELF::Binary::gnu_hash ( ) const

inline

Return the GnuHash object in readonly If the ELF binary does not use the GNU hash table, return a nullptr.

References use_gnu_hash().

◆ has() [1/4]

bool LIEF::ELF::Binary::has ( DynamicEntry::TAG tag ) const

inline

Check if an ELF::DynamicEntry associated with the given tag exists.

References get().

Referenced by use_gnu_hash(), and use_sysv_hash().

◆ has() [2/4]

bool LIEF::ELF::Binary::has ( Note::TYPE type ) const

inline

Check if a ELF::Note associated with the given type exists.

References get(), and type().

◆ has() [3/4]

bool LIEF::ELF::Binary::has ( Section::TYPE type ) const

inline

Check if a ELF::Section associated with the given type exists.

References get(), and type().

◆ has() [4/4]

bool LIEF::ELF::Binary::has ( Segment::TYPE type ) const

inline

Check if ELF::Segment associated with the given type exists.

References get(), and type().

◆ has_dynamic_symbol()

bool LIEF::ELF::Binary::has_dynamic_symbol ( const std::string & name ) const

inline

Check if the symbol with the given name exists in the dynamic symbols table.

References get_dynamic_symbol().

◆ has_interpreter()

bool LIEF::ELF::Binary::has_interpreter ( ) const

Check if the binary uses a loader (also named linker or interpreter).

See also: interpreter

◆ has_library()

bool LIEF::ELF::Binary::has_library ( const std::string & name ) const

inline

Check if the given library name exists in the current binary.

References get_library().

◆ has_notes()

bool LIEF::ELF::Binary::has_notes ( ) const

true if the binary embeds notes

◆ has_nx()

bool LIEF::ELF::Binary::has_nx ( ) const

overridevirtual

Check if the binary uses the NX protection (Non executable stack).

Implements LIEF::Binary.

◆ has_overlay()

bool LIEF::ELF::Binary::has_overlay ( ) const

inline

True if data are present at the end of the binary.

◆ has_section()

bool LIEF::ELF::Binary::has_section ( const std::string & name ) const

inline

Check if a section with the given name exists in the binary.

References get_section().

◆ has_section_with_offset()

bool LIEF::ELF::Binary::has_section_with_offset ( uint64_t offset ) const

Check if a section that handles the given offset exists.

◆ has_section_with_va()

bool LIEF::ELF::Binary::has_section_with_va ( uint64_t va ) const

Check if a section that handles the given virtual address exists.

◆ has_symtab_symbol()

bool LIEF::ELF::Binary::has_symtab_symbol ( const std::string & name ) const

inline

Check if the symbol with the given name exists in the symtab symbol table.

References get_symtab_symbol().

◆ hash()

size_t LIEF::ELF::Binary::hash ( const std::string & name )

◆ hash_section()

Section * LIEF::ELF::Binary::hash_section ( )

Return the hash section. If the section can't be found, it returns a nullptr.

◆ header() [1/2]

Header & LIEF::ELF::Binary::header ( )

inline

Return Elf header .

◆ header() [2/2]

const Header & LIEF::ELF::Binary::header ( ) const

inline

◆ imagebase()

uint64_t LIEF::ELF::Binary::imagebase ( ) const

overridevirtual

Return program image base. For instance 0x40000.

To compute the image base, we look for the PT_PHDR segment header (phdr), and we return phdr->p_vaddr - phdr->p_offset

Implements LIEF::Binary.

◆ imported_symbols() [1/2]

it_imported_symbols LIEF::ELF::Binary::imported_symbols ( )

Return symbols which are imported by the binary.

◆ imported_symbols() [2/2]

it_const_imported_symbols LIEF::ELF::Binary::imported_symbols ( ) const

◆ interpreter() [1/2]

const std::string & LIEF::ELF::Binary::interpreter ( ) const

inline

Return the ELF interpreter if any. (e.g. /lib64/ld-linux-x86-64.so.2) If the binary does not have an interpreter, it returns an empty string.

See also: has_interpreter

Referenced by interpreter().

◆ interpreter() [2/2]

void LIEF::ELF::Binary::interpreter ( const std::string & interpreter )

inline

Change the interpreter.

References interpreter().

◆ is_pie()

bool LIEF::ELF::Binary::is_pie ( ) const

overridevirtual

Check if the binary has been compiled with -fpie -pie flags.

To do so we check if there is a PT_INTERP segment and if the binary type is ET_DYN (Shared object)

Implements LIEF::Binary.

◆ is_targeting_android()

bool LIEF::ELF::Binary::is_targeting_android ( ) const

True if the current ELF is targeting Android.

◆ last_offset_section()

uint64_t LIEF::ELF::Binary::last_offset_section ( ) const

Return the last offset used in binary according to sections table.

◆ last_offset_segment()

uint64_t LIEF::ELF::Binary::last_offset_segment ( ) const

Return the last offset used in binary according to segments table.

◆ next_virtual_address()

uint64_t LIEF::ELF::Binary::next_virtual_address ( ) const

Return the next virtual address available.

◆ notes() [1/2]

it_notes LIEF::ELF::Binary::notes ( )

inline

◆ notes() [2/2]

it_const_notes LIEF::ELF::Binary::notes ( ) const

inline

Return an iterator over the ELF's LIEF::ELF::Note.

See also: has_note

◆ object_relocations() [1/2]

it_object_relocations LIEF::ELF::Binary::object_relocations ( )

Return relocations used in an object file (*.o).

◆ object_relocations() [2/2]

it_const_object_relocations LIEF::ELF::Binary::object_relocations ( ) const

◆ offset_to_virtual_address()

result< uint64_t > LIEF::ELF::Binary::offset_to_virtual_address	(	uint64_t	offset,
		uint64_t	slide = 0 ) const

overridevirtual

Convert the given offset into a virtual address.

Parameters

[in]	offset	The offset to convert.
[in]	slide	If not 0, it will replace the default base address (if any)

Implements LIEF::Binary.

◆ operator+=() [1/4]

Binary & LIEF::ELF::Binary::operator+= ( const DynamicEntry & entry )

inline

References add(), and Binary().

◆ operator+=() [2/4]

Binary & LIEF::ELF::Binary::operator+= ( const Note & note )

inline

References add(), and Binary().

◆ operator+=() [3/4]

Binary & LIEF::ELF::Binary::operator+= ( const Section & section )

inline

References add(), and Binary().

◆ operator+=() [4/4]

Binary & LIEF::ELF::Binary::operator+= ( const Segment & segment )

inline

References add(), and Binary().

◆ operator-=() [1/4]

Binary & LIEF::ELF::Binary::operator-= ( const DynamicEntry & entry )

inline

References Binary(), and remove().

◆ operator-=() [2/4]

Binary & LIEF::ELF::Binary::operator-= ( const Note & note )

inline

References Binary(), and remove().

◆ operator-=() [3/4]

Binary & LIEF::ELF::Binary::operator-= ( DynamicEntry::TAG tag )

inline

References Binary(), and remove().

◆ operator-=() [4/4]

Binary & LIEF::ELF::Binary::operator-= ( Note::TYPE type )

inline

References Binary(), remove(), and type().

◆ operator=()

Binary & LIEF::ELF::Binary::operator= ( const Binary & )

delete

References Binary().

◆ operator[]() [1/8]

DynamicEntry * LIEF::ELF::Binary::operator[] ( DynamicEntry::TAG tag )

inline

References get().

◆ operator[]() [2/8]

const DynamicEntry * LIEF::ELF::Binary::operator[] ( DynamicEntry::TAG tag ) const

inline

References get().

◆ operator[]() [3/8]

Note * LIEF::ELF::Binary::operator[] ( Note::TYPE type )

inline

References get(), and type().

◆ operator[]() [4/8]

const Note * LIEF::ELF::Binary::operator[] ( Note::TYPE type ) const

inline

References get(), and type().

◆ operator[]() [5/8]

Section * LIEF::ELF::Binary::operator[] ( Section::TYPE type )

inline

References get(), and type().

◆ operator[]() [6/8]

const Section * LIEF::ELF::Binary::operator[] ( Section::TYPE type ) const

inline

References get(), and type().

◆ operator[]() [7/8]

Segment * LIEF::ELF::Binary::operator[] ( Segment::TYPE type )

inline

References get(), and type().

◆ operator[]() [8/8]

const Segment * LIEF::ELF::Binary::operator[] ( Segment::TYPE type ) const

inline

References get(), and type().

◆ overlay() [1/2]

span< const uint8_t > LIEF::ELF::Binary::overlay ( ) const

inline

Overlay data (if any).

Referenced by overlay().

◆ overlay() [2/2]

void LIEF::ELF::Binary::overlay ( std::vector< uint8_t > overlay )

inline

Function to set the overlay.

References overlay().

◆ page_size()

uint64_t LIEF::ELF::Binary::page_size ( ) const

overridevirtual

Get the default memory page size according to the architecture and the format of the current binary.

Reimplemented from LIEF::Binary.

◆ patch_address() [1/2]

void LIEF::ELF::Binary::patch_address	(	uint64_t	address,
		const std::vector< uint8_t > &	patch_value,
		LIEF::Binary::VA_TYPES	addr_type = LIEF::Binary::VA_TYPES::AUTO )

overridevirtual

Patch the content at virtual address address with patch_value.

Parameters

[in]	address	Address to patch
[in]	patch_value	Patch to apply
[in]	addr_type	Specify if the address should be used as an absolute virtual address or an RVA

Implements LIEF::Binary.

References LIEF::Binary::AUTO.

◆ patch_address() [2/2]

void LIEF::ELF::Binary::patch_address	(	uint64_t	address,
		uint64_t	patch_value,
		size_t	size = sizeof(uint64_t),
		LIEF::Binary::VA_TYPES	addr_type = LIEF::Binary::VA_TYPES::AUTO )

overridevirtual

Patch the address with the given value.

Parameters

[in]	address	Address to patch
[in]	patch_value	Patch to apply
[in]	size	Size of the value in bytes (1, 2, ... 8)
[in]	addr_type	Specify if the address should be used as an absolute virtual address or an RVA

Implements LIEF::Binary.

References LIEF::Binary::AUTO.

◆ patch_pltgot() [1/2]

void LIEF::ELF::Binary::patch_pltgot	(	const std::string &	symbol_name,
		uint64_t	address )

Patch the imported symbol's name with the address.

Parameters

[in]	symbol_name	Imported symbol's name to patch
[in]	address	New address

◆ patch_pltgot() [2/2]

void LIEF::ELF::Binary::patch_pltgot	(	const Symbol &	symbol,
		uint64_t	address )

Patch the imported symbol with the address.

Parameters

[in]	symbol	Imported symbol to patch
[in]	address	New address

◆ permute_dynamic_symbols()

void LIEF::ELF::Binary::permute_dynamic_symbols ( const std::vector< size_t > & permutation )

Apply the given permutation on the dynamic symbols table.

◆ pltgot_relocations() [1/2]

it_pltgot_relocations LIEF::ELF::Binary::pltgot_relocations ( )

Return plt.got relocations.

◆ pltgot_relocations() [2/2]

it_const_pltgot_relocations LIEF::ELF::Binary::pltgot_relocations ( ) const

◆ print()

std::ostream & LIEF::ELF::Binary::print ( std::ostream & os ) const

overridevirtual

Reimplemented from LIEF::Binary.

◆ ptr_size()

uint8_t LIEF::ELF::Binary::ptr_size ( ) const

inline

References LIEF::ELF::Header::ELF32, LIEF::ELF::Header::ELF64, and type().

◆ raw()

std::vector< uint8_t > LIEF::ELF::Binary::raw ( )

Reconstruct the binary object and return its content as a byte vector.

◆ relocate_phdr_table()

uint64_t LIEF::ELF::Binary::relocate_phdr_table ( PHDR_RELOC type )

Force relocating the segments table in a specific way.

This function can be used to enforce a specific relocation of the segments table.

Parameters

[in] type The relocation type to apply

Returns: The offset of the new segments table or 0 if it fails with the given method.

References type().

◆ relocations() [1/2]

it_relocations LIEF::ELF::Binary::relocations ( )

inline

Return all relocations present in the binary.

◆ relocations() [2/2]

it_const_relocations LIEF::ELF::Binary::relocations ( ) const

inline

◆ remove() [1/7]

void LIEF::ELF::Binary::remove ( const DynamicEntry & entry )

Remove the given dynamic entry.

Referenced by operator-=(), operator-=(), operator-=(), and operator-=().

◆ remove() [2/7]

void LIEF::ELF::Binary::remove ( const Note & note )

Remove the given note.

◆ remove() [3/7]

void LIEF::ELF::Binary::remove	(	const Section &	section,
		bool	clear = false )

Remove the given section. The clear parameter can be used to zeroize the original content beforehand.

Parameters

[in]	section	The section to remove
[in]	clear	Whether zeroize the original content

◆ remove() [4/7]

void LIEF::ELF::Binary::remove	(	const Segment &	seg,
		bool	clear = false )

Remove the given segment. If clear is set, the original content of the segment will be filled with zeros before removal.

◆ remove() [5/7]

void LIEF::ELF::Binary::remove ( DynamicEntry::TAG tag )

Remove all dynamic entries with the given tag.

◆ remove() [6/7]

void LIEF::ELF::Binary::remove ( Note::TYPE type )

Remove all notes with the given type.

References type().

◆ remove() [7/7]

void LIEF::ELF::Binary::remove	(	Segment::TYPE	type,
		bool	clear = false )

Remove all segments associated with the given type.

If clear is set, the original content of the segment will be filled with zeros before removal.

References type().

◆ remove_dynamic_symbol() [1/2]

void LIEF::ELF::Binary::remove_dynamic_symbol ( const std::string & name )

Remove dynamic symbols with the given name.

◆ remove_dynamic_symbol() [2/2]

void LIEF::ELF::Binary::remove_dynamic_symbol ( Symbol * symbol )

Remove the given symbol from the dynamic symbols table.

As a side effect, it will remove any ELF::Relocation that refers to this symbol and the SymbolVersion (if any) associated with this symbol

◆ remove_library()

void LIEF::ELF::Binary::remove_library ( const std::string & library_name )

Remove the given library from the dependencies.

◆ remove_section()

void LIEF::ELF::Binary::remove_section	(	const std::string &	name,
		bool	clear = false )

overridevirtual

Remove a binary's section.

Parameters

[in]	name	The name of the section to remove
[in]	clear	Whether zeroize the original content

Implements LIEF::Binary.

◆ remove_symbol()

void LIEF::ELF::Binary::remove_symbol ( const std::string & name )

Remove symbols with the given name in both:

dynamic symbols
symtab symbols

See also: remove_symtab_symbol, remove_dynamic_symbol

◆ remove_symtab_symbol() [1/2]

void LIEF::ELF::Binary::remove_symtab_symbol ( const std::string & name )

Remove symtabl symbols with the given name.

◆ remove_symtab_symbol() [2/2]

void LIEF::ELF::Binary::remove_symtab_symbol ( Symbol * symbol )

◆ remove_version_requirement()

bool LIEF::ELF::Binary::remove_version_requirement ( const std::string & libname )

Deletes all required symbol versions linked to the specified library name. The function returns true if the operation succeed, false otherwise.

Warning: To maintain consistency, this function also removes versions associated with dynamic symbols that are linked to the specified library name.

◆ replace()

Segment * LIEF::ELF::Binary::replace	(	const Segment &	new_segment,
		const Segment &	original_segment,
		uint64_t	base = 0 )

Replace the segment given in 2nd parameter with the segment given in the first one and return the updated segment.

Warning: The original_segment is no longer valid after this function

◆ section_from_offset() [1/2]

Section * LIEF::ELF::Binary::section_from_offset	(	uint64_t	offset,
		bool	skip_nobits = true )

inline

References Binary().

◆ section_from_offset() [2/2]

const Section * LIEF::ELF::Binary::section_from_offset	(	uint64_t	offset,
		bool	skip_nobits = true ) const

Return the ELF::Section from the given offset. Return a nullptr if a section can't be found.

If skip_nobits is set (which is the case by default), this function won't consider section for which the type is SHT_NOBITS (like .bss, .tbss, ...)

◆ section_from_virtual_address() [1/2]

Section * LIEF::ELF::Binary::section_from_virtual_address	(	uint64_t	address,
		bool	skip_nobits = true )

inline

References Binary().

◆ section_from_virtual_address() [2/2]

const Section * LIEF::ELF::Binary::section_from_virtual_address	(	uint64_t	address,
		bool	skip_nobits = true ) const

Return the ELF::Section from the given address. Return a nullptr if a section can't be found.

If skip_nobits is set (which is the case by default), this function won't consider section for which type is SHT_NOBITS (like .bss, .tbss, ...)

◆ sections() [1/2]

it_sections LIEF::ELF::Binary::sections ( )

inline

Return an iterator over the binary's sections.

◆ sections() [2/2]

it_const_sections LIEF::ELF::Binary::sections ( ) const

inline

◆ segment_from_offset() [1/2]

Segment * LIEF::ELF::Binary::segment_from_offset ( uint64_t offset )

inline

References Binary().

◆ segment_from_offset() [2/2]

const Segment * LIEF::ELF::Binary::segment_from_offset ( uint64_t offset ) const

Return the ELF::Segment from the offset. Return a nullptr if a segment can't be found.

◆ segment_from_virtual_address() [1/4]

Segment * LIEF::ELF::Binary::segment_from_virtual_address	(	Segment::TYPE	type,
		uint64_t	address )

inline

References Binary(), and type().

◆ segment_from_virtual_address() [2/4]

const Segment * LIEF::ELF::Binary::segment_from_virtual_address	(	Segment::TYPE	type,
		uint64_t	address ) const

References type().

◆ segment_from_virtual_address() [3/4]

Segment * LIEF::ELF::Binary::segment_from_virtual_address ( uint64_t address )

inline

References Binary().

◆ segment_from_virtual_address() [4/4]

const Segment * LIEF::ELF::Binary::segment_from_virtual_address ( uint64_t address ) const

Return the ELF::Segment from the given address. Return a nullptr if a segment can't be found.

◆ segments() [1/2]

it_segments LIEF::ELF::Binary::segments ( )

inline

Return binary's segments.

◆ segments() [2/2]

it_const_segments LIEF::ELF::Binary::segments ( ) const

inline

◆ should_swap()

bool LIEF::ELF::Binary::should_swap ( ) const

inline

◆ strings()

string_list_t LIEF::ELF::Binary::strings ( size_t min_size = 5 ) const

Return list of the strings used by the ELF binary.

Basically, this function looks for string in the .roadata section

◆ strip()

void LIEF::ELF::Binary::strip ( )

Strip the binary by removing symtab symbols.

◆ symbols() [1/2]

it_symbols LIEF::ELF::Binary::symbols ( )

inline

Return an iterator on both static and dynamic symbols.

◆ symbols() [2/2]

it_const_symbols LIEF::ELF::Binary::symbols ( ) const

inline

◆ symbols_version() [1/2]

it_symbols_version LIEF::ELF::Binary::symbols_version ( )

inline

Return the symbol versions.

◆ symbols_version() [2/2]

it_const_symbols_version LIEF::ELF::Binary::symbols_version ( ) const

inline

◆ symbols_version_definition() [1/2]

it_symbols_version_definition LIEF::ELF::Binary::symbols_version_definition ( )

inline

Return symbols version definition.

◆ symbols_version_definition() [2/2]

it_const_symbols_version_definition LIEF::ELF::Binary::symbols_version_definition ( ) const

inline

◆ symbols_version_requirement() [1/2]

it_symbols_version_requirement LIEF::ELF::Binary::symbols_version_requirement ( )

inline

Return Symbol version requirement.

◆ symbols_version_requirement() [2/2]

it_const_symbols_version_requirement LIEF::ELF::Binary::symbols_version_requirement ( ) const

inline

◆ symtab_idx() [1/2]

int64_t LIEF::ELF::Binary::symtab_idx ( const std::string & name ) const

Symbol index from the .symtab section or -1 if the symbol is not present.

◆ symtab_idx() [2/2]

int64_t LIEF::ELF::Binary::symtab_idx ( const Symbol & sym ) const

◆ symtab_symbols() [1/2]

it_symtab_symbols LIEF::ELF::Binary::symtab_symbols ( )

inline

Return the debug symbols from the .symtab section.

◆ symtab_symbols() [2/2]

it_const_symtab_symbols LIEF::ELF::Binary::symtab_symbols ( ) const

inline

◆ symtab_symbols_section()

Section * LIEF::ELF::Binary::symtab_symbols_section ( )

Return section which holds the symtab symbols. If the section can't be found, it returns a nullptr.

◆ sysv_hash()

const SysvHash * LIEF::ELF::Binary::sysv_hash ( ) const

inline

Return the SysvHash object as a read-only object If the ELF binary does not use the legacy sysv hash table, return a nullptr.

References use_sysv_hash().

◆ text_section()

Section * LIEF::ELF::Binary::text_section ( )

inline

Return the .text section. If the section can't be found, it returns a nullptr.

References get_section().

◆ type()

Header::CLASS LIEF::ELF::Binary::type ( ) const

inline

Return binary's class (ELF32 or ELF64).

Referenced by get(), get(), get(), get(), get(), get(), has(), has(), has(), operator-=(), operator[](), operator[](), operator[](), operator[](), operator[](), operator[](), ptr_size(), relocate_phdr_table(), remove(), remove(), segment_from_virtual_address(), and segment_from_virtual_address().

◆ use_gnu_hash()

bool LIEF::ELF::Binary::use_gnu_hash ( ) const

inline

true if GNU hash is used

See also: gnu_hash and use_sysv_hash

References LIEF::ELF::DynamicEntry::GNU_HASH, and has().

Referenced by gnu_hash().

◆ use_sysv_hash()

bool LIEF::ELF::Binary::use_sysv_hash ( ) const

inline

true if SYSV hash is used

See also: sysv_hash and use_gnu_hash

References has(), and LIEF::ELF::DynamicEntry::HASH.

Referenced by sysv_hash().

◆ virtual_address_to_offset()

result< uint64_t > LIEF::ELF::Binary::virtual_address_to_offset ( uint64_t virtual_address ) const

Convert a virtual address to a file offset.

◆ virtual_size()

uint64_t LIEF::ELF::Binary::virtual_size ( ) const

Return the size of the mapped binary.

◆ write() [1/4]

void LIEF::ELF::Binary::write ( const std::string & filename )

inline

Reconstruct the binary object and write it in filename.

This function assumes that the layout of the current ELF binary is correct (i.e. the binary can run).

Parameters

filename Path for the written ELF binary

References write().

Referenced by write(), and write().

◆ write() [2/4]

void LIEF::ELF::Binary::write	(	const std::string &	filename,
		const Builder::config_t &	config )

Reconstruct the binary object with the given config and write it in filename.

This function assumes that the layout of the current ELF binary is correct (i.e. the binary can run).

Parameters

filename	Path for the written ELF binary
config	Builder configuration

◆ write() [3/4]

void LIEF::ELF::Binary::write ( std::ostream & os )

inline

Reconstruct the binary object and write it in os stream.

This function assumes that the layout of the current ELF binary is correct (i.e. the binary can run).

Parameters

os	Output stream for the written ELF binary

References write().

◆ write() [4/4]

void LIEF::ELF::Binary::write	(	std::ostream &	os,
		const Builder::config_t &	config )

Reconstruct the binary object with the given config and write it in os stream.

Parameters

os	Output stream for the written ELF binary
config	Builder configuration

The documentation for this class was generated from the following file:

ELF/Binary.hpp

Public Types

Public Member Functions

Static Public Member Functions

Detailed Description

Member Typedef Documentation

◆ dynamic_entries_t

◆ it_const_dynamic_entries

◆ it_const_dynamic_relocations

◆ it_const_dynamic_symbols

◆ it_const_exported_symbols

◆ it_const_imported_symbols

◆ it_const_notes

◆ it_const_object_relocations

◆ it_const_pltgot_relocations

◆ it_const_relocations

◆ it_const_sections

◆ it_const_segments

◆ it_const_symbols

◆ it_const_symbols_version

◆ it_const_symbols_version_definition

◆ it_const_symbols_version_requirement

◆ it_const_symtab_symbols

◆ it_dynamic_entries

◆ it_dynamic_relocations

◆ it_dynamic_symbols

◆ it_exported_symbols

◆ it_imported_symbols

◆ it_notes

◆ it_object_relocations

◆ it_pltgot_relocations

◆ it_relocations

◆ it_sections

◆ it_segments

◆ it_symbols

◆ it_symbols_version

◆ it_symbols_version_definition

◆ it_symbols_version_requirement

◆ it_symtab_symbols

◆ notes_t

◆ relocations_t

◆ sections_t

◆ segments_t

◆ string_list_t

◆ symbols_t

◆ symbols_version_definition_t

◆ symbols_version_requirement_t

◆ symbols_version_t

Member Enumeration Documentation

◆ PHDR_RELOC

◆ SEC_INSERT_POS

Constructor & Destructor Documentation

◆ Binary()

◆ ~Binary()

Member Function Documentation

◆ accept()

◆ add() [1/4]

◆ add() [2/4]

◆ add() [3/4]

◆ add() [4/4]

◆ add_dynamic_relocation()

◆ add_dynamic_symbol()

◆ add_exported_function()

◆ add_library()

◆ add_object_relocation()

◆ add_pltgot_relocation()

◆ add_symtab_symbol()

◆ classof()

◆ ctor_functions()

◆ dtor_functions()

◆ dynamic_entries() [1/2]

◆ dynamic_entries() [2/2]

◆ dynamic_relocations() [1/2]

◆ dynamic_relocations() [2/2]

◆ dynamic_section()

◆ dynamic_symbols() [1/2]

◆ dynamic_symbols() [2/2]

◆ dynsym_idx() [1/2]

◆ dynsym_idx() [2/2]

◆ entrypoint()

◆ eof_offset()