LIEF: Library to Instrument Executable Formats Version 0.16.0
Loading...
Searching...
No Matches
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&.
 
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

Binaryoperator= (const Binary &copy)=delete
 
 Binary (const Binary &copy)=delete
 
const Headerheader () const
 OAT Header.
 
Headerheader ()
 
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 Classget_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.
 
Classget_class (const std::string &class_name)
 
const Classget_class (size_t index) const
 Return the LIEF::OAT::Class at the given index or a nullptr if it does not exist.
 
Classget_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
Binaryoperator= (const Binary &)=delete
 
 Binary (const Binary &copy)=delete
 
Header::CLASS type () const
 Return binary's class (ELF32 or ELF64)
 
Headerheader ()
 Return Elf header .
 
const Headerheader () 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
 
DynamicEntryadd (const DynamicEntry &entry)
 Add the given dynamic entry and return the new entry.
 
Noteadd (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
 
Relocationadd_dynamic_relocation (const Relocation &relocation)
 Add a new dynamic relocation.
 
Relocationadd_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.
 
Relocationadd_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 Relocationget_relocation (uint64_t address) const
 Return relocation associated with the given address. It returns a nullptr if it is not found.
 
Relocationget_relocation (uint64_t address)
 
const Relocationget_relocation (const Symbol &symbol) const
 Return relocation associated with the given Symbol It returns a nullptr if it is not found.
 
Relocationget_relocation (const Symbol &symbol)
 
const Relocationget_relocation (const std::string &symbol_name) const
 Return relocation associated with the given Symbol name It returns a nullptr if it is not found.
 
Relocationget_relocation (const std::string &symbol_name)
 
bool use_gnu_hash () const
 true if GNU hash is used
 
const GnuHashgnu_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 SysvHashsysv_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.
 
Sectionget_section (const std::string &name)
 Return Section with the given name. If the section can't be found, it returns a nullptr.
 
const Sectionget_section (const std::string &name) const
 
Sectiontext_section ()
 Return the .text section. If the section can't be found, it returns a nullptr.
 
Sectiondynamic_section ()
 Return the .dynamic section. If the section can't be found, it returns a nullptr.
 
Sectionhash_section ()
 Return the hash section. If the section can't be found, it returns a nullptr.
 
Sectionsymtab_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
 
Symbolexport_symbol (const Symbol &symbol)
 Export the given symbol and create it if it doesn't exist.
 
Symbolexport_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 Symbolget_dynamic_symbol (const std::string &name) const
 Get the dynamic symbol from the given name. Return a nullptr if it can't be found.
 
Symbolget_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 Symbolget_symtab_symbol (const std::string &name) const
 Get the symtab symbol from the given name Return a nullptr if it can't be found.
 
Symbolget_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.
 
Sectionadd (const Section &section, bool loaded=true)
 Add a new section in the binary.
 
Sectionextend (const Section &section, uint64_t size)
 
Symboladd_symtab_symbol (const Symbol &symbol)
 Add a symtab symbol.
 
Symboladd_dynamic_symbol (const Symbol &symbol, const SymbolVersion *version=nullptr)
 Add a dynamic symbol with the associated SymbolVersion.
 
Symboladd_exported_function (uint64_t address, const std::string &name="")
 Create a symbol for the function at the given address and export it.
 
DynamicEntryLibraryadd_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.
 
DynamicEntryLibraryget_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 DynamicEntryLibraryget_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.
 
Segmentadd (const Segment &segment, uint64_t base=0)
 Add a new segment in the binary.
 
Segmentreplace (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.
 
Segmentextend (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 Sectionsection_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.
 
Sectionsection_from_offset (uint64_t offset, bool skip_nobits=true)
 
const Sectionsection_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.
 
Sectionsection_from_virtual_address (uint64_t address, bool skip_nobits=true)
 
const Segmentsegment_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.
 
Segmentsegment_from_virtual_address (uint64_t address)
 
const Segmentsegment_from_virtual_address (Segment::TYPE type, uint64_t address) const
 
Segmentsegment_from_virtual_address (Segment::TYPE type, uint64_t address)
 
const Segmentsegment_from_offset (uint64_t offset) const
 Return the ELF::Segment from the offset. Return a nullptr if a segment can't be found.
 
Segmentsegment_from_offset (uint64_t offset)
 
const DynamicEntryget (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.
 
DynamicEntryget (DynamicEntry::TAG tag)
 
const Segmentget (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.
 
Segmentget (Segment::TYPE type)
 
const Noteget (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.
 
Noteget (Note::TYPE type)
 
const Sectionget (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.
 
Sectionget (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)
 
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.
 
size_t hash (const std::string &name)
 
 ~Binary () override
 
std::ostream & print (std::ostream &os) const override
 
Binaryoperator+= (const DynamicEntry &entry)
 
Binaryoperator+= (const Section &section)
 
Binaryoperator+= (const Segment &segment)
 
Binaryoperator+= (const Note &note)
 
Binaryoperator-= (const DynamicEntry &entry)
 
Binaryoperator-= (DynamicEntry::TAG tag)
 
Binaryoperator-= (const Note &note)
 
Binaryoperator-= (Note::TYPE type)
 
Segmentoperator[] (Segment::TYPE type)
 
const Segmentoperator[] (Segment::TYPE type) const
 
DynamicEntryoperator[] (DynamicEntry::TAG tag)
 
const DynamicEntryoperator[] (DynamicEntry::TAG tag) const
 
Noteoperator[] (Note::TYPE type)
 
const Noteoperator[] (Note::TYPE type) const
 
Sectionoperator[] (Section::TYPE type)
 
const Sectionoperator[] (Section::TYPE type) const
 
- Public Member Functions inherited from LIEF::Binary
 Binary ()
 
 Binary (FORMATS fmt)
 
 ~Binary () override
 
Binaryoperator= (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 Symbolget_symbol (const std::string &name) const
 Return the Symbol with the given name If the symbol does not exist, return a nullptr.
 
Symbolget_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.
 
DebugInfodebug_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 a the given virtual address and with the given size.
 
instructions_it disassemble (uint64_t address) const
 Disassemble code starting a 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
 
- Public Member Functions inherited from LIEF::Object
 Object ()
 
 Object (const Object &other)
 
Objectoperator= (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

◆ dex_files_t

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

◆ it_classes

◆ it_const_classes

◆ it_const_dex_files

◆ it_const_methods

◆ it_const_oat_dex_files

◆ it_dex_files

◆ it_methods

◆ it_oat_dex_files

◆ 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

◆ 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

◆ 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: