Inheritance diagram for LIEF::OAT::Binary:

[legend]

Collaboration diagram for LIEF::OAT::Binary:

[legend]

Public Types
using	dex_files_t = std::vector<std::unique_ptr<DEX::File>>

using	it_dex_files = ref_iterator<dex_files_t&, DEX::File*>

using	it_const_dex_files = const_ref_iterator<const dex_files_t&, const DEX::File*>

using	classes_t = std::unordered_map<std::string, Class*>

using	classes_list_t = std::vector<std::unique_ptr<Class>>

using	it_classes = ref_iterator<classes_list_t&, Class*>

using	it_const_classes = const_ref_iterator<const classes_list_t&, const Class*>

using	oat_dex_files_t = std::vector<std::unique_ptr<DexFile>>

using	it_oat_dex_files = ref_iterator<oat_dex_files_t&, DexFile*>

using	it_const_oat_dex_files = const_ref_iterator<const oat_dex_files_t&, const DexFile*>

using	methods_t = std::vector<std::unique_ptr<Method>>

using	it_methods = ref_iterator<methods_t&, Method*>

using	it_const_methods = const_ref_iterator<const methods_t&, const Method*>

using	dex2dex_info_t = std::unordered_map<const DEX::File*, DEX::dex2dex_info_t>

Public Types inherited from LIEF::ELF::Binary
enum	PHDR_RELOC { AUTO = 0 , PIE_SHIFT , BSS_END , BINARY_END , SEGMENT_GAP }

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 }
	Type of a virtual address. 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&.

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 &copy)=delete

	Binary (const Binary &copy)=delete

const Header &	header () const
	OAT Header.

Header &	header ()

it_dex_files	dex_files ()
	Iterator over LIEF::DEX::File.

it_const_dex_files	dex_files () const

it_oat_dex_files	oat_dex_files ()
	Iterator over LIEF::OAT::DexFile.

it_const_oat_dex_files	oat_dex_files () const

it_const_classes	classes () const
	Iterator over LIEF::OAT::Class.

it_classes	classes ()

bool	has_class (const std::string &class_name) const
	Check if the current OAT has the given class.

const Class *	get_class (const std::string &class_name) const
	Return the LIEF::OAT::Class with the given name or a nullptr if the class can't be found.

Class *	get_class (const std::string &class_name)

const Class *	get_class (size_t index) const
	Return the LIEF::OAT::Class at the given index or a nullptr if it does not exist.

Class *	get_class (size_t index)

it_const_methods	methods () const
	Iterator over LIEF::OAT::Method.

it_methods	methods ()

dex2dex_info_t	dex2dex_info () const

std::string	dex2dex_json_info ()

bool	has_vdex () const

void	accept (Visitor &visitor) const override
	Method associated with the visitor pattern.

Public Member Functions inherited from LIEF::ELF::Binary
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)
	Remove the given segment.

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)
	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) override
	Reconstruct the binary object and write it in `filename`

void	write (const std::string &filename, Builder::config_t config)
	Reconstruct the binary object with the given config and write it in `filename`

void	write (std::ostream &os) override
	Reconstruct the binary object and write it in `os` stream.

void	write (std::ostream &os, 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	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.

size_t	hash (const std::string &name)

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

Public Member Functions inherited from LIEF::Binary
	Binary (FORMATS fmt)

Binary &	operator= (const Binary &)

	Binary (const Binary &)

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

void	original_size (uint64_t size)
	Change binary's original size.

Public Member Functions inherited from LIEF::Object
	Object (const Object &other)

Object &	operator= (const Object &other)

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

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

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

Member Function Documentation

◆ accept()

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

overridevirtual

Method associated with the visitor pattern.

Reimplemented from LIEF::ELF::Binary.

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

OAT/Binary.hpp

Public Types

Public Member Functions

Static Public Member Functions

Member Function Documentation

◆ accept()