LIEF::OAT::Binary Class Reference

#include <Binary.hpp>

Inheritance diagram for LIEF::OAT::Binary:

Collaboration diagram for LIEF::OAT::Binary:

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.
	~Binary () override
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.
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)
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
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
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.
Public Member Functions inherited from LIEF::Object
	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
virtual	~Object ()

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 Typedef Documentation

classes_list_t

using LIEF::OAT::Binary::classes_list_t = std::vector<std::unique_ptr<Class>>

classes_t

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

dex2dex_info_t

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

dex_files_t

using LIEF::OAT::Binary::dex_files_t = std::vector<std::unique_ptr<DEX::File>>

it_classes

using LIEF::OAT::Binary::it_classes = ref_iterator<classes_list_t&, Class*>

it_const_classes

using LIEF::OAT::Binary::it_const_classes = const_ref_iterator<const classes_list_t&, const Class*>

it_const_dex_files

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

it_const_methods

using LIEF::OAT::Binary::it_const_methods = const_ref_iterator<const methods_t&, const Method*>

it_const_oat_dex_files

using LIEF::OAT::Binary::it_const_oat_dex_files = const_ref_iterator<const oat_dex_files_t&, const DexFile*>

it_dex_files

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

it_methods

using LIEF::OAT::Binary::it_methods = ref_iterator<methods_t&, Method*>

it_oat_dex_files

using LIEF::OAT::Binary::it_oat_dex_files = ref_iterator<oat_dex_files_t&, DexFile*>

methods_t

using LIEF::OAT::Binary::methods_t = std::vector<std::unique_ptr<Method>>

oat_dex_files_t

using LIEF::OAT::Binary::oat_dex_files_t = std::vector<std::unique_ptr<DexFile>>

Constructor & Destructor Documentation

Binary()

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

delete

~Binary()

LIEF::OAT::Binary::~Binary ( )

override

Member Function Documentation

accept()

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

overridevirtual

Method associated with the visitor pattern.

Reimplemented from LIEF::ELF::Binary.

classes() [1/2]

it_classes LIEF::OAT::Binary::classes

(

)

classes() [2/2]

it_const_classes LIEF::OAT::Binary::classes

(

)

const

Iterator over LIEF::OAT::Class.

classof()

static bool LIEF::OAT::Binary::classof ( const LIEF::Binary * bin )

inlinestatic

References LIEF::Binary::format().

dex2dex_info()

dex2dex_info_t LIEF::OAT::Binary::dex2dex_info

(

)

const

dex2dex_json_info()

std::string LIEF::OAT::Binary::dex2dex_json_info

(

)

dex_files() [1/2]

it_dex_files LIEF::OAT::Binary::dex_files

(

)

Iterator over LIEF::DEX::File.

dex_files() [2/2]

it_const_dex_files LIEF::OAT::Binary::dex_files

(

)

const

get_class() [1/4]

Class * LIEF::OAT::Binary::get_class

(

const std::string &

class_name

)

get_class() [2/4]

const Class * LIEF::OAT::Binary::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.

get_class() [3/4]

Class * LIEF::OAT::Binary::get_class

(

size_t

index

)

get_class() [4/4]

const Class * LIEF::OAT::Binary::get_class

(

size_t

index

)

const

Return the LIEF::OAT::Class at the given index or a nullptr if it does not exist.

has_class()

bool LIEF::OAT::Binary::has_class

(

const std::string &

class_name

)

const

Check if the current OAT has the given class.

has_vdex()

bool LIEF::OAT::Binary::has_vdex ( ) const

inline

header() [1/2]

Header & LIEF::OAT::Binary::header

(

)

header() [2/2]

const Header & LIEF::OAT::Binary::header

(

)

const

OAT Header.

methods() [1/2]

it_methods LIEF::OAT::Binary::methods

(

)

methods() [2/2]

it_const_methods LIEF::OAT::Binary::methods

(

)

const

Iterator over LIEF::OAT::Method.

oat_dex_files() [1/2]

it_oat_dex_files LIEF::OAT::Binary::oat_dex_files

(

)

Iterator over LIEF::OAT::DexFile.

oat_dex_files() [2/2]

it_const_oat_dex_files LIEF::OAT::Binary::oat_dex_files

(

)

const

operator=()

Binary & LIEF::OAT::Binary::operator= ( const Binary & copy )

delete

---

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

• OAT/Binary.hpp