elf.h File Reference

#include <rz_types.h>
#include <rz_util.h>
#include <rz_lib.h>
#include <rz_bin.h>
#include "elf_specs.h"

Go to the source code of this file.

Classes
struct	gnu_hash_table
struct	rz_bin_elf_gnu_hash_table_t
struct	elf_hash_table
struct	rz_bin_elf_hash_table_
struct	prstatus_layout_t
	Information about the binary layout in a NT_PRSTATUS note for core files of a certain architecture and os. More...
struct	rz_bin_elf_section_t
struct	rz_bin_elf_symbol_t
struct	rz_bin_elf_reloc_t
struct	rz_bin_elf_note_prstatus_t
	Parsed PT_NOTE of type NT_PRSTATUS. More...

Macros
#define	RZ_BIN_ELF_SCN_IS_EXECUTABLE(x)   x &SHF_EXECINSTR
#define	RZ_BIN_ELF_SCN_IS_READABLE(x)   x &SHF_ALLOC
#define	RZ_BIN_ELF_SCN_IS_WRITABLE(x)   x &SHF_WRITE
#define	RZ_BIN_ELF_NO_RELRO   0
#define	RZ_BIN_ELF_PART_RELRO   1
#define	RZ_BIN_ELF_FULL_RELRO   2
#define	ELFOBJ   struct Elf_(rz_bin_elf_obj_t)
#define	rz_bin_elf_foreach_segments(bin, segment)
#define	rz_bin_elf_foreach_sections(bin, section)
#define	rz_bin_elf_enumerate_sections(bin, section, i)
#define	rz_bin_elf_foreach_relocs(bin, reloc)
#define	rz_bin_elf_foreach_notes_segment(bin, notes)
#define	rz_bin_elf_foreach_symbols(bin, symbol)
#define	rz_bin_elf_foreach_imports(bin, import)
#define	rz_bin_elf_fix_arm_thumb_object_dispatch(object)    Elf_(rz_bin_elf_fix_arm_thumb_object)(&object->paddr, &object->vaddr, &object->bits)

Typedefs
typedef struct rz_bin_elf_gnu_hash_table_t	RzBinElfGnuHashTable
typedef struct rz_bin_elf_hash_table_	RzBinElfHashTable
typedef struct prstatus_layout_t	RzBinElfPrStatusLayout
	Information about the binary layout in a NT_PRSTATUS note for core files of a certain architecture and os. More...
typedef struct rz_bin_elf_section_t	RzBinElfSection
typedef struct rz_bin_elf_symbol_t	RzBinElfSymbol
typedef struct rz_bin_elf_reloc_t	RzBinElfReloc
typedef struct rz_bin_elf_dt_dynamic_t	RzBinElfDtDynamic
typedef struct rz_bin_elf_note_prstatus_t	RzBinElfNotePrStatus
	Parsed PT_NOTE of type NT_PRSTATUS. More...
typedef struct rz_bin_elf_strtab	RzBinElfStrtab
typedef bool(*	RzBinElfSymbolFilter) (ELFOBJ *bin, Elf_(Sym) *entry, bool is_dynamic)

Functions
struct	Elf_ (rz_bin_elf_segment_t)
struct	Elf_ (rz_bin_elf_note_file_t)
	A single file entry in a PT_NOTE of type NT_FILE. More...
struct	Elf_ (rz_bin_elf_note_t)
	A single PT_NOTE entry, parsed from an ElfW(Nhdr) and associated data. More...
struct	Elf_ (rz_bin_elf_obj_t)
RZ_OWN ELFOBJ *Elf_()	rz_bin_elf_new_buf (RZ_NONNULL RzBuffer *buf, RZ_NONNULL RzBinObjectLoadOptions *options)
void Elf_()	rz_bin_elf_free (RZ_NONNULL ELFOBJ *bin)
	Free the elf binary. More...
ut64 Elf_()	rz_bin_elf_p2v (RZ_NONNULL ELFOBJ *bin, ut64 paddr)
	Convert a physical address to the virtual address. More...
ut64 Elf_()	rz_bin_elf_v2p (RZ_NONNULL ELFOBJ *bin, ut64 vaddr)
	Convert a virtual address to the physical address. More...
bool Elf_()	rz_bin_elf_is_arm_binary_supporting_thumb (RZ_NONNULL ELFOBJ *bin)
bool Elf_()	rz_bin_elf_is_thumb_addr (ut64 addr)
void Elf_()	rz_bin_elf_fix_arm_thumb_addr (ut64 *addr)
void Elf_()	rz_bin_elf_fix_arm_thumb_object (RZ_NONNULL ut64 *paddr, RZ_NONNULL ut64 *vaddr, RZ_NONNULL int *bits)
void Elf_()	rz_bin_elf_fix_arm_thumb_symbol (RZ_NONNULL RzBinSymbol *symbol)
ut64 Elf_()	rz_bin_elf_get_sp_val (RZ_NONNULL ELFOBJ *bin)
	Get the stack pointer value. More...
RZ_BORROW RzVector *Elf_()	rz_bin_elf_get_dt_needed (RZ_NONNULL ELFOBJ *bin)
RZ_OWN RzBinElfDtDynamic *Elf_()	rz_bin_elf_dt_dynamic_new (RZ_NONNULL ELFOBJ *bin)
bool Elf_()	rz_bin_elf_get_dt_info (RZ_NONNULL ELFOBJ *bin, ut64 key, RZ_OUT ut64 *info)
bool Elf_()	rz_bin_elf_has_dt_dynamic (RZ_NONNULL ELFOBJ *bin)
void Elf_()	rz_bin_elf_dt_dynamic_free (RzBinElfDtDynamic *ptr)
RZ_OWN char *Elf_()	rz_bin_elf_get_e_ehsize_as_string (RZ_NONNULL ELFOBJ *bin)
RZ_OWN char *Elf_()	rz_bin_elf_get_e_entry_as_string (RZ_NONNULL ELFOBJ *bin)
RZ_OWN char *Elf_()	rz_bin_elf_get_e_flags_as_string (RZ_NONNULL ELFOBJ *bin)
RZ_OWN char *Elf_()	rz_bin_elf_get_e_indent_as_string (RZ_NONNULL ELFOBJ *bin)
RZ_OWN char *Elf_()	rz_bin_elf_get_e_machine_as_string (RZ_NONNULL ELFOBJ *bin)
RZ_OWN char *Elf_()	rz_bin_elf_get_e_phentsize_as_string (RZ_NONNULL ELFOBJ *bin)
RZ_OWN char *Elf_()	rz_bin_elf_get_e_phnum_as_string (RZ_NONNULL ELFOBJ *bin)
RZ_OWN char *Elf_()	rz_bin_elf_get_e_phoff_as_string (RZ_NONNULL ELFOBJ *bin)
RZ_OWN char *Elf_()	rz_bin_elf_get_e_shentsize_as_string (RZ_NONNULL ELFOBJ *bin)
RZ_OWN char *Elf_()	rz_bin_elf_get_e_shnum_as_string (RZ_NONNULL ELFOBJ *bin)
RZ_OWN char *Elf_()	rz_bin_elf_get_e_shoff_as_string (RZ_NONNULL ELFOBJ *bin)
RZ_OWN char *Elf_()	rz_bin_elf_get_e_shstrndx_as_string (RZ_NONNULL ELFOBJ *bin)
RZ_OWN char *Elf_()	rz_bin_elf_get_e_type_as_string (RZ_NONNULL ELFOBJ *bin)
RZ_OWN char *Elf_()	rz_bin_elf_get_e_version_as_string (RZ_NONNULL ELFOBJ *bin)
bool Elf_()	rz_bin_elf_get_ehdr (RZ_NONNULL ELFOBJ *bin)
bool Elf_()	rz_bin_elf_print_ehdr (ELFOBJ *bin, RZ_NONNULL PrintfCallback cb)
bool Elf_()	rz_bin_elf_get_gnu_hash_table (RZ_NONNULL ELFOBJ *bin, RzBinElfGnuHashTable *result)
bool Elf_()	rz_bin_elf_get_hash_table (RZ_NONNULL ELFOBJ *bin, RzBinElfHashTable *result)
size_t Elf_()	rz_bin_elf_get_number_of_symbols_from_gnu_hash_table (RZ_NONNULL ELFOBJ *bin)
size_t Elf_()	rz_bin_elf_get_number_of_symbols_from_hash_table (RZ_NONNULL ELFOBJ *bin)
RZ_BORROW RzBinElfSymbol *Elf_()	rz_bin_elf_get_import (RZ_NONNULL ELFOBJ *bin, ut32 ordinal)
RZ_OWN RzVector *Elf_()	rz_bin_elf_analyse_imports (RZ_NONNULL ELFOBJ *bin)
bool Elf_()	rz_bin_elf_has_imports (RZ_NONNULL ELFOBJ *bin)
ut64 Elf_()	rz_bin_elf_get_targets_map_base (ELFOBJ *bin)
RZ_OWN RzList *Elf_()	rz_bin_elf_get_libs (RZ_NONNULL ELFOBJ *bin)
	List all imported lib. More...
RZ_OWN Sdb *Elf_()	rz_bin_elf_get_symbols_info (RZ_NONNULL ELFOBJ *bin)
RZ_OWN char *Elf_()	rz_bin_elf_get_abi (RZ_NONNULL ELFOBJ *bin)
	Return a string representing the application binary interface. More...
RZ_OWN char *Elf_()	rz_bin_elf_get_arch (RZ_NONNULL ELFOBJ *bin)
	Get the elf binary architecture. More...
RZ_OWN char *Elf_()	rz_bin_elf_get_compiler (RZ_NONNULL ELFOBJ *bin)
	Get the compiler info from the .comment section. More...
RZ_OWN char *Elf_()	rz_bin_elf_get_cpu (RZ_NONNULL ELFOBJ *bin)
	Return a string representing the cpu. More...
RZ_OWN char *Elf_()	rz_bin_elf_get_elf_class (RZ_NONNULL ELFOBJ *bin)
	Return a string representing the elf class. More...
RZ_OWN char *Elf_()	rz_bin_elf_get_file_type (RZ_NONNULL ELFOBJ *bin)
	Return a string representing the file type. More...
RZ_OWN char *Elf_()	rz_bin_elf_get_head_flag (RZ_NONNULL ELFOBJ *bin)
	Return the head flag. More...
RZ_OWN char *Elf_()	rz_bin_elf_get_intrp (RZ_NONNULL ELFOBJ *bin)
	Get the program interpreter. More...
RZ_OWN char *Elf_()	rz_bin_elf_get_machine_name (RZ_NONNULL ELFOBJ *bin)
	Return a string representing the machine name. More...
RZ_OWN char *Elf_()	rz_bin_elf_get_osabi_name (RZ_NONNULL ELFOBJ *bin)
	Return the os application binary interface name. More...
RZ_OWN char *Elf_()	rz_bin_elf_get_rpath (RZ_NONNULL ELFOBJ *bin)
	Get the rpath. More...
bool Elf_()	rz_bin_elf_has_nx (RZ_NONNULL ELFOBJ *bin)
	Check if the stack is not executable. More...
bool Elf_()	rz_bin_elf_has_va (ELFOBJ *bin)
	Check if the elf use virtual address. More...
bool Elf_()	rz_bin_elf_is_big_endian (RZ_NONNULL ELFOBJ *bin)
	Check the binary endianness. More...
bool Elf_()	rz_bin_elf_is_executable (RZ_NONNULL ELFOBJ *bin)
	Check if the elf binary is executable. More...
bool Elf_()	rz_bin_elf_is_relocatable (RZ_NONNULL ELFOBJ *bin)
	Check if the elf binary is relocatable. More...
bool Elf_()	rz_bin_elf_is_static (RZ_NONNULL ELFOBJ *bin)
	Check if the binary is statically-linked library. More...
bool Elf_()	rz_bin_elf_is_stripped (RZ_NONNULL ELFOBJ *bin)
	Check if the binary is stripped. More...
int Elf_()	rz_bin_elf_get_bits (RZ_NONNULL ELFOBJ *bin)
	Return the elf bits. More...
int Elf_()	rz_bin_elf_has_relro (RZ_NONNULL ELFOBJ *bin)
	Analyse if the elf binary has relro or partial relro. More...
ut64 Elf_()	rz_bin_elf_get_baddr (RZ_NONNULL ELFOBJ *bin)
	Compute the base address of the binary. More...
ut64 Elf_()	rz_bin_elf_get_boffset (RZ_NONNULL ELFOBJ *bin)
	Compute the base offset of the binary. More...
ut64 Elf_()	rz_bin_elf_get_entry_offset (RZ_NONNULL ELFOBJ *bin)
	Get the entry offset. More...
ut64 Elf_()	rz_bin_elf_get_fini_offset (RZ_NONNULL ELFOBJ *bin)
	Compute the fini offset of the binary. More...
ut64 Elf_()	rz_bin_elf_get_init_offset (RZ_NONNULL ELFOBJ *bin)
	Compute the init offset of the binary. More...
ut64 Elf_()	rz_bin_elf_get_main_offset (RZ_NONNULL ELFOBJ *bin)
	Compute the main offset of the binary. More...
RZ_BORROW RzBinElfPrStatusLayout *Elf_()	rz_bin_elf_get_prstatus_layout (RZ_NONNULL ELFOBJ *bin)
RZ_OWN RzVector *Elf_()	rz_bin_elf_notes_new (RZ_NONNULL ELFOBJ *bin)
bool Elf_()	rz_bin_elf_has_notes (RZ_NONNULL ELFOBJ *bin)
bool Elf_()	rz_bin_elf_check_array (RZ_NONNULL ELFOBJ *bin, Elf_(Off) offset, Elf_(Off) length, Elf_(Off) entry_size)
bool Elf_()	rz_bin_elf_read_addr (RZ_NONNULL ELFOBJ *bin, RZ_NONNULL RZ_INOUT ut64 *offset, RZ_NONNULL RZ_OUT Elf_(Addr) *result)
bool Elf_()	rz_bin_elf_read_char (RZ_NONNULL ELFOBJ *bin, RZ_NONNULL RZ_INOUT ut64 *offset, RZ_NONNULL RZ_OUT ut8 *result)
bool Elf_()	rz_bin_elf_read_half (RZ_NONNULL ELFOBJ *bin, RZ_NONNULL RZ_INOUT ut64 *offset, RZ_NONNULL RZ_OUT Elf_(Half) *result)
bool Elf_()	rz_bin_elf_read_off (RZ_NONNULL ELFOBJ *bin, RZ_NONNULL RZ_INOUT ut64 *offset, RZ_NONNULL RZ_OUT Elf_(Off) *result)
bool Elf_()	rz_bin_elf_read_section (RZ_NONNULL ELFOBJ *bin, RZ_NONNULL RZ_INOUT ut64 *offset, RZ_NONNULL RZ_OUT Elf_(Section) *result)
bool Elf_()	rz_bin_elf_read_sword (RZ_NONNULL ELFOBJ *bin, RZ_NONNULL RZ_INOUT ut64 *offset, RZ_NONNULL RZ_OUT Elf_(Sword) *result)
bool Elf_()	rz_bin_elf_read_sxword (RZ_NONNULL ELFOBJ *bin, RZ_NONNULL RZ_INOUT ut64 *offset, RZ_NONNULL RZ_OUT Elf_(Sxword) *result)
bool Elf_()	rz_bin_elf_read_versym (RZ_NONNULL ELFOBJ *bin, RZ_NONNULL RZ_INOUT ut64 *offset, RZ_NONNULL RZ_OUT Elf_(Versym) *result)
bool Elf_()	rz_bin_elf_read_word (RZ_NONNULL ELFOBJ *bin, RZ_NONNULL RZ_INOUT ut64 *offset, RZ_NONNULL RZ_OUT Elf_(Word) *result)
bool Elf_()	rz_bin_elf_read_xword (RZ_NONNULL ELFOBJ *bin, RZ_NONNULL RZ_INOUT ut64 *offset, RZ_NONNULL RZ_OUT Elf_(Xword) *result)
bool Elf_()	rz_bin_elf_read_word_xword (RZ_NONNULL ELFOBJ *bin, RZ_NONNULL RZ_INOUT ut64 *offset, RZ_NONNULL RZ_OUT Elf_(Word) *result)
bool Elf_()	rz_bin_elf_read_sword_sxword (RZ_NONNULL ELFOBJ *bin, RZ_NONNULL RZ_INOUT ut64 *offset, RZ_NONNULL RZ_OUT Elf_(Sword) *result)
bool Elf_()	rz_bin_elf_add_addr (Elf_(Addr) *result, Elf_(Addr) addr, Elf_(Addr) value)
bool Elf_()	rz_bin_elf_add_off (Elf_(Off) *result, Elf_(Off) addr, Elf_(Off) value)
bool Elf_()	rz_bin_elf_mul_addr (Elf_(Addr) *result, Elf_(Addr) addr, Elf_(Addr) value)
bool Elf_()	rz_bin_elf_mul_off (Elf_(Off) *result, Elf_(Off) addr, Elf_(Off) value)
RZ_OWN RzVector *Elf_()	rz_bin_elf_relocs_new (RZ_NONNULL ELFOBJ *bin)
bool Elf_()	rz_bin_elf_has_relocs (RZ_NONNULL ELFOBJ *bin)
size_t Elf_()	rz_bin_elf_get_relocs_count (RZ_NONNULL ELFOBJ *bin)
ut64 Elf_()	rz_bin_elf_get_num_relocs_dynamic_plt (RZ_NONNULL ELFOBJ *bin)
RZ_BORROW RzBinElfSegment *Elf_()	rz_bin_elf_get_segment_with_type (RZ_NONNULL ELFOBJ *bin, Elf_(Word) type)
RZ_OWN RzVector *Elf_()	rz_bin_elf_segments_new (RZ_NONNULL ELFOBJ *bin, RzVector *sections, RZ_NONNULL RzBinObjectLoadOptions *options)
bool Elf_()	rz_bin_elf_has_segments (RZ_NONNULL ELFOBJ *bin)
RZ_BORROW RzBinElfSection *Elf_()	rz_bin_elf_get_section (RZ_NONNULL ELFOBJ *bin, Elf_(Half) index)
RZ_BORROW RzBinElfSection *Elf_()	rz_bin_elf_get_section_with_name (RZ_NONNULL ELFOBJ *bin, RZ_NONNULL const char *name)
RZ_OWN RzList *Elf_()	rz_bin_elf_section_flag_to_rzlist (ut64 flag)
	Return a list of string representing flag options. More...
RZ_OWN RzVector *Elf_()	rz_bin_elf_convert_sections (RZ_NONNULL ELFOBJ *bin, RZ_NONNULL RzBinObjectLoadOptions *options, RzVector *sections)
RZ_OWN RzVector *Elf_()	rz_bin_elf_sections_new (RZ_NONNULL ELFOBJ *bin)
RZ_OWN char *Elf_()	rz_bin_elf_section_type_to_string (ut64 type)
	Return a string representing the elf type. More...
bool Elf_()	rz_bin_elf_has_sections (RZ_NONNULL ELFOBJ *bin)
RZ_BORROW const char *Elf_()	rz_bin_elf_strtab_get (RZ_NONNULL RzBinElfStrtab *strtab, ut64 index)
RZ_OWN RzBinElfStrtab *Elf_()	rz_bin_elf_strtab_new (RZ_NONNULL ELFOBJ *bin, ut64 offset, ut64 size)
RZ_OWN char *Elf_()	rz_bin_elf_strtab_get_dup (RZ_NONNULL RzBinElfStrtab *strtab, ut64 index)
bool Elf_()	rz_bin_elf_strtab_has_index (RZ_NONNULL RzBinElfStrtab *strtab, ut64 index)
void Elf_()	rz_bin_elf_strtab_free (RzBinElfStrtab *ptr)
	Elf_ (Word) Elf_(rz_bin_elf_get_number_of_dynamic_symbols)(RZ_NONNULL ELFOBJ *bin)
RZ_BORROW RzBinElfSymbol *Elf_()	rz_bin_elf_get_symbol (RZ_NONNULL ELFOBJ *bin, ut32 ordinal)
RZ_OWN RzVector *Elf_()	rz_bin_elf_compute_symbols (ELFOBJ *bin, RzBinElfSymbolFilter filter)
RZ_OWN RzVector *Elf_()	rz_bin_elf_symbols_new (RZ_NONNULL ELFOBJ *bin)
bool Elf_()	rz_bin_elf_has_symbols (RZ_NONNULL ELFOBJ *bin)

Variables
	RzBinElfSegment
	RzBinElfNoteFile
	RzBinElfNote

Macro Definition Documentation

ELFOBJ

#define ELFOBJ   struct Elf_(rz_bin_elf_obj_t)

Definition at line 24 of file elf.h.

rz_bin_elf_enumerate_sections

#define rz_bin_elf_enumerate_sections	(		bin,
			section,
			i
	)

Value:

    if (Elf_(rz_bin_elf_has_sections)(bin)) \
    rz_vector_enumerate((bin)->sections, section, i)

Definition at line 34 of file elf.h.

rz_bin_elf_fix_arm_thumb_object_dispatch

#define rz_bin_elf_fix_arm_thumb_object_dispatch

(

object

)

Elf_(rz_bin_elf_fix_arm_thumb_object)(&object->paddr, &object->vaddr, &object->bits)

Definition at line 228 of file elf.h.

rz_bin_elf_foreach_imports

#define rz_bin_elf_foreach_imports	(		bin,
			import
	)

Value:

    if (Elf_(rz_bin_elf_has_imports)(bin)) \
    rz_vector_foreach(bin->imports, import)

Definition at line 50 of file elf.h.

rz_bin_elf_foreach_notes_segment

#define rz_bin_elf_foreach_notes_segment	(		bin,
			notes
	)

Value:

    if (Elf_(rz_bin_elf_has_notes)(bin)) \
    rz_vector_foreach((bin)->notes, notes)

Definition at line 42 of file elf.h.

rz_bin_elf_foreach_relocs

#define rz_bin_elf_foreach_relocs	(		bin,
			reloc
	)

Value:

    if (Elf_(rz_bin_elf_has_relocs)(bin)) \
    rz_vector_foreach((bin)->relocs, reloc)

Definition at line 38 of file elf.h.

rz_bin_elf_foreach_sections

#define rz_bin_elf_foreach_sections	(		bin,
			section
	)

Value:

    if (Elf_(rz_bin_elf_has_sections)(bin)) \
    rz_vector_foreach((bin)->sections, section)

Definition at line 30 of file elf.h.

rz_bin_elf_foreach_segments

#define rz_bin_elf_foreach_segments	(		bin,
			segment
	)

Value:

    if (Elf_(rz_bin_elf_has_segments)(bin)) \
    rz_vector_foreach((bin)->segments, segment)

Definition at line 26 of file elf.h.

rz_bin_elf_foreach_symbols

#define rz_bin_elf_foreach_symbols	(		bin,
			symbol
	)

Value:

    if (Elf_(rz_bin_elf_has_symbols)(bin)) \
    rz_vector_foreach(bin->symbols, symbol)

Definition at line 46 of file elf.h.

RZ_BIN_ELF_FULL_RELRO

#define RZ_BIN_ELF_FULL_RELRO   2

Definition at line 22 of file elf.h.

RZ_BIN_ELF_NO_RELRO

#define RZ_BIN_ELF_NO_RELRO   0

Definition at line 20 of file elf.h.

RZ_BIN_ELF_PART_RELRO

#define RZ_BIN_ELF_PART_RELRO   1

Definition at line 21 of file elf.h.

RZ_BIN_ELF_SCN_IS_EXECUTABLE

#define RZ_BIN_ELF_SCN_IS_EXECUTABLE

(

x

)

x &SHF_EXECINSTR

Definition at line 16 of file elf.h.

RZ_BIN_ELF_SCN_IS_READABLE

#define RZ_BIN_ELF_SCN_IS_READABLE

(

x

)

x &SHF_ALLOC

Definition at line 17 of file elf.h.

RZ_BIN_ELF_SCN_IS_WRITABLE

#define RZ_BIN_ELF_SCN_IS_WRITABLE

(

x

)

x &SHF_WRITE

Definition at line 18 of file elf.h.

Typedef Documentation

RzBinElfDtDynamic

typedef struct rz_bin_elf_dt_dynamic_t RzBinElfDtDynamic

Definition at line 131 of file elf.h.

RzBinElfGnuHashTable

typedef struct rz_bin_elf_gnu_hash_table_t RzBinElfGnuHashTable

RzBinElfHashTable

typedef struct rz_bin_elf_hash_table_ RzBinElfHashTable

RzBinElfNotePrStatus

typedef struct rz_bin_elf_note_prstatus_t RzBinElfNotePrStatus

Parsed PT_NOTE of type NT_PRSTATUS.

RzBinElfPrStatusLayout

typedef struct prstatus_layout_t RzBinElfPrStatusLayout

Information about the binary layout in a NT_PRSTATUS note for core files of a certain architecture and os.

RzBinElfReloc

typedef struct rz_bin_elf_reloc_t RzBinElfReloc

RzBinElfSection

typedef struct rz_bin_elf_section_t RzBinElfSection

RzBinElfStrtab

typedef struct rz_bin_elf_strtab RzBinElfStrtab

Definition at line 182 of file elf.h.

RzBinElfSymbol

typedef struct rz_bin_elf_symbol_t RzBinElfSymbol

RzBinElfSymbolFilter

typedef bool(* RzBinElfSymbolFilter) (ELFOBJ *bin, Elf_(Sym) *entry, bool is_dynamic)

Definition at line 366 of file elf.h.

Function Documentation

Elf_() [1/5]

struct Elf_

(

rz_bin_elf_note_file_t

)

A single file entry in a PT_NOTE of type NT_FILE.

Definition at line 131 of file elf.h.

                                            {
    Elf_(Addr) start_vaddr;
    Elf_(Addr) end_vaddr;
    Elf_(Addr) file_off;
    char *file;
}

Elf_() [2/5]

struct Elf_

(

rz_bin_elf_note_t

)

A single PT_NOTE entry, parsed from an ElfW(Nhdr) and associated data.

Definition at line 165 of file elf.h.

                                       {
    Elf_(Word) type;
    union {
        RzBinElfNoteFile file; //< for type == NT_FILE
        RzBinElfNotePrStatus prstatus; //< for type = NT_PRSTATUS
    };
}

Elf_() [3/5]

struct Elf_

(

rz_bin_elf_obj_t

)

< overlay over the original file with relocs patched

Definition at line 182 of file elf.h.

                              {
    RzBuffer *b;
 
    RzBuffer *buf_patched; 
    bool relocs_patched;
    ut64 reloc_targets_map_base;
 
    Sdb *kv;
 
    ut64 size;
 
    bool big_endian;
    int bits;
    ut64 baddr;
    ut64 boffset;
 
    Elf_(Ehdr) ehdr;
 
    RzVector *segments; // should be use with elf_segments.c
    RzVector *sections; // should be use with elf_sections.c
 
    RzBinElfDtDynamic *dt_dynamic; // should be use with elf_dynamic.c
 
    RzBinElfStrtab *dynstr; // should be use with elf_strtab.c
    RzBinElfStrtab *shstrtab; // should be use with elf_strtab.c
 
    RzVector *relocs; // should be use with elf_relocs.c
 
    // This is RzVector of note segment reprensented as RzVector<RzBinElfNote>
    RzVector *notes; // RzVector<RzVector<RzBinElfNote>>
 
    RzVector *symbols; // RzVector<RzBinElfSymbol>
    RzVector *imports; // RzVector<RzBinElfSymbol>
};

Elf_() [4/5]

struct Elf_

(

rz_bin_elf_segment_t

)

Definition at line 1 of file elf.h.

                                          {
    Elf_(Phdr) data;
    bool is_valid;
}

Elf_() [5/5]

Elf_

(

Word

)

Definition at line 75 of file elf_symbols.c.

                                                                    {
    ut64 symtab_addr;
    ut64 strtab_addr;
    if (!Elf_(rz_bin_elf_get_dt_info)(bin, DT_SYMTAB, &symtab_addr) || !Elf_(rz_bin_elf_get_dt_info)(bin, DT_STRTAB, &strtab_addr)) {
        return 0;
    }
 
    ut64 symtab_offset = Elf_(rz_bin_elf_v2p)(bin, symtab_addr);
    ut64 strtab_offset = Elf_(rz_bin_elf_v2p)(bin, strtab_addr);
    if (symtab_offset == UT64_MAX || strtab_offset == UT64_MAX) {
        return 0;
    }
 
    return get_number_of_symbols_from_heuristic_aux(bin, symtab_offset, strtab_offset);
}

References DT_STRTAB, DT_SYMTAB, Elf_(), rz_bin_elf_get_dt_info(), rz_bin_elf_v2p(), ut64(), and UT64_MAX.

rz_bin_elf_add_addr()

bool Elf_() rz_bin_elf_add_addr	(	Elf_(Addr) *	result,
		Elf_(Addr)	addr,
		Elf_(Addr)	value
	)

Definition at line 138 of file elf_misc.c.

                                                                                       {
#if RZ_BIN_ELF64
    return UT64_ADD((ut64 *)result, addr, value);
#else
    return UT32_ADD((ut32 *)result, addr, value);
#endif
}

References addr, UT32_ADD(), ut64(), UT64_ADD(), and value.

Referenced by verify_phdr_entry(), and verify_shdr_entry().

rz_bin_elf_add_off()

bool Elf_() rz_bin_elf_add_off	(	Elf_(Off) *	result,
		Elf_(Off)	addr,
		Elf_(Off)	value
	)

Definition at line 146 of file elf_misc.c.

                                                                                   {
#if RZ_BIN_ELF64
    return UT64_ADD((ut64 *)result, addr, value);
#else
    return UT32_ADD((ut32 *)result, addr, value);
#endif
}

References addr, UT32_ADD(), ut64(), UT64_ADD(), and value.

Referenced by rz_bin_elf_check_array(), verify_phdr_entry(), and verify_shdr_entry().

rz_bin_elf_analyse_imports()

RZ_OWN RzVector* Elf_() rz_bin_elf_analyse_imports

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 329 of file elf_imports.c.

                                                                          {
    rz_return_val_if_fail(bin, NULL);
 
    RzVector *result = Elf_(rz_bin_elf_compute_symbols)(bin, filter_import);
    if (!result) {
        return NULL;
    }
 
    convert_elf_symbols_to_elf_imports(bin, result);
 
    return result;
}

References convert_elf_symbols_to_elf_imports(), Elf_, filter_import(), NULL, rz_bin_elf_compute_symbols(), and rz_return_val_if_fail.

Referenced by init().

rz_bin_elf_check_array()

bool Elf_() rz_bin_elf_check_array	(	RZ_NONNULL ELFOBJ *	bin,
		Elf_(Off)	offset,
		Elf_(Off)	length,
		Elf_(Off)	entry_size
	)

Definition at line 32 of file elf_misc.c.

                                                                                                                    {
    rz_return_val_if_fail(bin, false);
 
    Elf_(Off) array_size;
    if (!Elf_(rz_bin_elf_mul_off)(&array_size, length, entry_size)) {
        return false;
    }
 
    Elf_(Off) end_off;
    if (!Elf_(rz_bin_elf_add_off)(&end_off, offset, array_size)) {
        return false;
    }
 
    if (!array_size || end_off > bin->size) {
        return false;
    }
 
    return true;
}

References Elf_, length, rz_bin_elf_add_off(), rz_bin_elf_mul_off(), and rz_return_val_if_fail.

Referenced by rz_bin_elf_sections_new(), rz_bin_elf_segments_new(), and rz_bin_elf_strtab_new().

rz_bin_elf_compute_symbols()

RZ_OWN RzVector* Elf_() rz_bin_elf_compute_symbols	(	ELFOBJ *	bin,
		RzBinElfSymbolFilter	filter
	)

Definition at line 486 of file elf_symbols.c.

                                                                                            {
    RzVector *result = rz_vector_new(sizeof(RzBinElfSymbol), elf_symbol_fini, NULL);
    if (!result) {
        return NULL;
    }
 
    HtUU *set = ht_uu_new0();
    if (!set) {
        rz_vector_free(result);
        return NULL;
    }
 
    if (!get_dynamic_elf_symbols(bin, result, filter, set)) {
        rz_vector_free(result);
        ht_uu_free(set);
        return NULL;
    }
 
    if (!get_section_elf_symbols(bin, result, filter, set)) {
        rz_vector_free(result);
        ht_uu_free(set);
        return NULL;
    }
 
    // Parsing .gnu_debugdata is completely optional, ignore errors if any and just continue
    (void)get_gnu_debugdata_elf_symbols(bin, result, filter, set);
 
    ht_uu_free(set);
 
    if (!rz_vector_len(result)) {
        rz_vector_free(result);
        return NULL;
    }
 
    return result;
}

References elf_symbol_fini(), get_dynamic_elf_symbols(), get_gnu_debugdata_elf_symbols(), get_section_elf_symbols(), NULL, rz_vector_free(), rz_vector_len(), and rz_vector_new().

Referenced by get_gnu_debugdata_elf_symbols(), rz_bin_elf_analyse_imports(), and rz_bin_elf_symbols_new().

rz_bin_elf_convert_sections()

RZ_OWN RzVector* Elf_() rz_bin_elf_convert_sections	(	RZ_NONNULL ELFOBJ *	bin,
		RZ_NONNULL RzBinObjectLoadOptions *	options,
		RzVector *	sections
	)

Definition at line 362 of file elf_sections.c.

                                                                                                                                           {
    rz_return_val_if_fail(bin && options, NULL);
 
    RzVector *result = convert_sections(bin, options, sections);
    if (!result) {
        return NULL;
    }
 
    if (!rz_vector_len(result)) {
        rz_vector_free(result);
        return NULL;
    }
 
    return result;
}

References convert_sections(), NULL, options, rz_return_val_if_fail, rz_vector_free(), rz_vector_len(), and sections().

Referenced by init_shdr_aux().

rz_bin_elf_dt_dynamic_free()

void Elf_() rz_bin_elf_dt_dynamic_free

(

RzBinElfDtDynamic *

ptr

)

Definition at line 135 of file elf_dynamic.c.

                                                              {
    if (!ptr) {
        return;
    }
 
    ht_uu_free(ptr->info);
    rz_vector_fini(&ptr->dt_needed);
    free(ptr);
}

References free(), and rz_vector_fini().

Referenced by rz_bin_elf_dt_dynamic_new(), and rz_bin_elf_free().

rz_bin_elf_dt_dynamic_new()

RZ_OWN RzBinElfDtDynamic* Elf_() rz_bin_elf_dt_dynamic_new

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 98 of file elf_dynamic.c.

                                                                                  {
    RzBinElfDtDynamic *result = RZ_NEW0(RzBinElfDtDynamic);
    if (!result) {
        return NULL;
    }
 
    result->info = ht_uu_new0();
    if (!result->info) {
        Elf_(rz_bin_elf_dt_dynamic_free)(result);
        return NULL;
    }
 
    rz_vector_init(&result->dt_needed, sizeof(ut64), NULL, NULL);
 
    if (!init_dt_dynamic(bin, result)) {
        Elf_(rz_bin_elf_dt_dynamic_free)(result);
        return NULL;
    }
 
    return result;
}

References rz_bin_elf_dt_dynamic_t::dt_needed, Elf_, rz_bin_elf_dt_dynamic_t::info, init_dt_dynamic(), NULL, rz_bin_elf_dt_dynamic_free(), RZ_NEW0, rz_vector_init(), and ut64().

Referenced by init_dt_dynamic_aux().

rz_bin_elf_fix_arm_thumb_addr()

void Elf_() rz_bin_elf_fix_arm_thumb_addr

(

ut64 *

addr

)

Definition at line 28 of file elf_arm.c.

                                                     {
    rz_return_if_fail(Elf_(rz_bin_elf_is_thumb_addr(*addr)));
    *addr -= 1;
}

References addr, Elf_, rz_bin_elf_is_thumb_addr(), and rz_return_if_fail.

Referenced by rz_bin_elf_fix_arm_thumb_object().

rz_bin_elf_fix_arm_thumb_object()

void Elf_() rz_bin_elf_fix_arm_thumb_object	(	RZ_NONNULL ut64 *	paddr,
		RZ_NONNULL ut64 *	vaddr,
		RZ_NONNULL int *	bits
	)

Definition at line 33 of file elf_arm.c.

                                                                                                                 {
    rz_return_if_fail(paddr && vaddr && bits);
 
    *bits = 32;
 
    if (Elf_(rz_bin_elf_is_thumb_addr)(*paddr)) {
        Elf_(rz_bin_elf_fix_arm_thumb_addr)(paddr);
        *bits = 16;
    }
 
    if (Elf_(rz_bin_elf_is_thumb_addr)(*vaddr)) {
        Elf_(rz_bin_elf_fix_arm_thumb_addr)(vaddr);
        *bits = 16;
    }
}

References bits(), Elf_, rz_bin_elf_fix_arm_thumb_addr(), rz_bin_elf_is_thumb_addr(), and rz_return_if_fail.

rz_bin_elf_fix_arm_thumb_symbol()

void Elf_() rz_bin_elf_fix_arm_thumb_symbol

(

RZ_NONNULL RzBinSymbol *

symbol

)

Definition at line 49 of file elf_arm.c.

                                                                           {
    rz_return_if_fail(symbol && symbol->name);
 
    if (start_a_sequence_of_instruction(symbol)) {
        symbol->bits = 32;
    } else if (start_a_sequence_of_thumb_instruction(symbol) || !start_a_sequence_of_data(symbol)) {
        rz_bin_elf_fix_arm_thumb_object_dispatch(symbol);
    }
}

References rz_bin_elf_fix_arm_thumb_object_dispatch, rz_return_if_fail, start_a_sequence_of_data(), start_a_sequence_of_instruction(), and start_a_sequence_of_thumb_instruction().

rz_bin_elf_free()

void Elf_() rz_bin_elf_free

(

RZ_NONNULL ELFOBJ *

bin

)

Free the elf binary.

Parameters

elf

binary

...

Definition at line 366 of file elf.c.

                                                   {
    rz_return_if_fail(bin);
 
    rz_buf_free(bin->b);
    rz_buf_free(bin->buf_patched);
 
    sdb_free(bin->kv);
 
    rz_vector_free(bin->segments);
    rz_vector_free(bin->sections);
 
    Elf_(rz_bin_elf_dt_dynamic_free)(bin->dt_dynamic);
 
    Elf_(rz_bin_elf_strtab_free)(bin->dynstr);
    Elf_(rz_bin_elf_strtab_free)(bin->shstrtab);
 
    rz_vector_free(bin->relocs);
 
    rz_vector_free(bin->notes);
 
    rz_vector_free(bin->symbols);
    rz_vector_free(bin->imports);
 
    free(bin);
}

References Elf_, free(), rz_bin_elf_dt_dynamic_free(), rz_bin_elf_strtab_free(), rz_buf_free(), rz_return_if_fail, rz_vector_free(), and sdb_free().

Referenced by get_gnu_debugdata_elf_symbols(), and rz_bin_elf_new_buf().

rz_bin_elf_get_abi()

RZ_OWN char* Elf_() rz_bin_elf_get_abi

(

RZ_NONNULL ELFOBJ *

bin

)

Return a string representing the application binary interface.

Parameters

elf

type

Returns

allocated string

Only work on mips right now. Use the elf header to deduce the application binary interface

Definition at line 1386 of file elf_info.c.

                                                              {
    rz_return_val_if_fail(bin, NULL);
 
    if (bin->ehdr.e_machine == EM_MIPS) {
        return get_abi_mips(bin);
    }
 
    return NULL;
}

References EM_MIPS, get_abi_mips(), NULL, and rz_return_val_if_fail.

Referenced by add_abi_info().

rz_bin_elf_get_arch()

RZ_OWN char* Elf_() rz_bin_elf_get_arch

(

RZ_NONNULL ELFOBJ *

bin

)

Get the elf binary architecture.

Parameters

elf

binary

Returns

an allocated string

With the elf header (e_machine) deduce the elf architecture

Definition at line 1403 of file elf_info.c.

                                                               {
    rz_return_val_if_fail(bin, NULL);
 
    for (size_t i = 0; i < RZ_ARRAY_SIZE(arch_translation_table); i++) {
        if (bin->ehdr.e_machine == arch_translation_table[i].arch) {
            return strdup(arch_translation_table[i].name);
        }
    }
 
    return strdup("");
}

References arch_translation_table, i, NULL, RZ_ARRAY_SIZE, rz_return_val_if_fail, and strdup().

rz_bin_elf_get_baddr()

ut64 Elf_() rz_bin_elf_get_baddr

(

RZ_NONNULL ELFOBJ *

bin

)

Compute the base address of the binary.

Parameters

elf

binary

Returns

the base address

To compute the base address, one determines the memory address associated with the lowest p_vaddr value for a PT_LOAD segment.

Definition at line 1772 of file elf_info.c.

                                                        {
    rz_return_val_if_fail(bin, 0);
 
    if (Elf_(rz_bin_elf_is_relocatable)(bin)) {
        return 0x08000000;
    }
 
    if (Elf_(rz_bin_elf_has_segments)(bin)) {
        return compute_baddr_from_phdr(bin);
    }
 
    return 0;
}

References compute_baddr_from_phdr(), Elf_(), rz_bin_elf_has_segments(), rz_bin_elf_is_relocatable(), and rz_return_val_if_fail.

Referenced by get_main_offset_x86_pie(), and init().

rz_bin_elf_get_bits()

int Elf_() rz_bin_elf_get_bits

(

RZ_NONNULL ELFOBJ *

bin

)

Return the elf bits.

Parameters

elf

binary

Returns

the number of bits

...

Definition at line 1697 of file elf_info.c.

                                                      {
    rz_return_val_if_fail(bin, 0);
 
    /* Hack for ARCompact */
    if (arch_is_arcompact(bin)) {
        return 16;
    }
 
    /* Hack for Ps2 */
    if (arch_is_mips(bin)) {
        return get_bits_mips(bin);
    }
 
    /* Hack for Thumb */
    if (Elf_(rz_bin_elf_is_arm_binary_supporting_thumb)(bin)) {
        if (!Elf_(rz_bin_elf_is_static)(bin) && has_thumb_symbol(bin)) {
            return 16;
        }
 
        ut64 entry = Elf_(rz_bin_elf_get_entry_offset)(bin);
        if (Elf_(rz_bin_elf_is_thumb_addr)(entry)) {
            return 16;
        }
    }
 
    return get_bits_common(bin);
}

References arch_is_arcompact(), arch_is_mips(), Elf_(), get_bits_common(), get_bits_mips(), has_thumb_symbol(), rz_bin_elf_get_entry_offset(), rz_bin_elf_is_arm_binary_supporting_thumb(), rz_bin_elf_is_static(), rz_bin_elf_is_thumb_addr(), rz_return_val_if_fail, and ut64().

Referenced by init().

rz_bin_elf_get_boffset()

ut64 Elf_() rz_bin_elf_get_boffset

(

RZ_NONNULL ELFOBJ *

bin

)

Compute the base offset of the binary.

Parameters

elf

binary

Returns

the base offset

To compute the base address, one determines the memory address associated with the lowest p_offset value for a PT_LOAD segment.

Definition at line 1795 of file elf_info.c.

                                                          {
    rz_return_val_if_fail(bin, 0);
 
    if (Elf_(rz_bin_elf_has_segments)(bin)) {
        return compute_boffset_from_phdr(bin);
    }
 
    return 0;
}

References compute_boffset_from_phdr(), Elf_(), rz_bin_elf_has_segments(), and rz_return_val_if_fail.

Referenced by init().

rz_bin_elf_get_compiler()

RZ_OWN char* Elf_() rz_bin_elf_get_compiler

(

RZ_NONNULL ELFOBJ *

bin

)

Get the compiler info from the .comment section.

Parameters

elf

binary

Returns

a ptr to an allocated string

...

Definition at line 1339 of file elf_info.c.

                                                                   {
    rz_return_val_if_fail(bin, NULL);
 
    RzBinElfSection *section = Elf_(rz_bin_elf_get_section_with_name)(bin, ".comment");
    if (!section) {
        return NULL;
    }
 
    ut64 offset = section->offset;
    ut64 size = RZ_MIN(section->size, 128);
    if (size < 1) {
        return NULL;
    }
 
    char *result = malloc(size + 1);
    if (!result) {
        return NULL;
    }
 
    if (rz_buf_read_at(bin->b, offset, (ut8 *)result, size) < 1) {
        free(result);
        return NULL;
    }
    result[size] = 0;
 
    size_t result_len = strlen(result);
    char *end = result + result_len;
 
    if (result_len != size && end[1]) {
        end[0] = ' ';
    }
 
    rz_str_trim(result);
    char *res = rz_str_escape(result);
 
    free(result);
    return res;
}

References Elf_(), test_evm::end, free(), malloc(), NULL, section::offset, rz_bin_elf_get_section_with_name(), rz_buf_read_at(), RZ_MIN, rz_return_val_if_fail, rz_str_escape(), rz_str_trim(), section::size, and ut64().

rz_bin_elf_get_cpu()

RZ_OWN char* Elf_() rz_bin_elf_get_cpu

(

RZ_NONNULL ELFOBJ *

bin

)

Return a string representing the cpu.

Parameters

elf

type

Returns

allocated string

Only work on mips right now. Use the elf header to deduce the cpu

Definition at line 1422 of file elf_info.c.

                                                              {
    rz_return_val_if_fail(bin, NULL);
 
    if (!Elf_(rz_bin_elf_has_segments)(bin)) {
        return NULL;
    }
 
    if (bin->ehdr.e_machine == EM_MIPS) {
        return get_cpu_mips(bin);
    }
 
    return NULL;
}

References Elf_(), EM_MIPS, get_cpu_mips(), NULL, rz_bin_elf_has_segments(), and rz_return_val_if_fail.

Referenced by add_cpu_info().

rz_bin_elf_get_dt_info()

bool Elf_() rz_bin_elf_get_dt_info	(	RZ_NONNULL ELFOBJ *	bin,
		ut64	key,
		RZ_OUT ut64 *	info
	)

Definition at line 120 of file elf_dynamic.c.

                                                                                       {
    rz_return_val_if_fail(bin, false);
 
    if (!Elf_(rz_bin_elf_has_dt_dynamic)(bin)) {
        return false;
    }
 
    return get_dt_info(bin->dt_dynamic, key, info);
}

References Elf_, get_dt_info(), info(), key, rz_bin_elf_has_dt_dynamic(), and rz_return_val_if_fail.

Referenced by create_section_plt(), Elf_(), elf_is_bind_now(), get_dynamic_elf_symbols(), get_gnu_verneed(), get_gnu_versym(), get_import_addr_arm(), get_import_addr_mips(), get_import_addr_ppc(), get_import_addr_riscv(), get_import_addr_x86(), get_import_addr_x86_manual(), get_main_offset_mips(), get_plt_name(), get_relocs_entry_from_dt_dynamic(), get_relocs_entry_from_dt_dynamic_aux(), get_sections_from_dt_dynamic(), get_versym_entry_sdb_from_verdef(), get_versym_entry_sdb_from_verneed(), has_dt_rpath_entry(), init_dynstr_aux(), rz_bin_elf_get_fini_offset(), rz_bin_elf_get_gnu_hash_table(), rz_bin_elf_get_hash_table(), rz_bin_elf_get_init_offset(), and rz_bin_elf_get_num_relocs_dynamic_plt().

rz_bin_elf_get_dt_needed()

RZ_BORROW RzVector* Elf_() rz_bin_elf_get_dt_needed

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 88 of file elf_dynamic.c.

                                                                           {
    rz_return_val_if_fail(bin, NULL);
 
    if (!Elf_(rz_bin_elf_has_dt_dynamic)(bin)) {
        return NULL;
    }
 
    return &bin->dt_dynamic->dt_needed;
}

References Elf_, NULL, rz_bin_elf_has_dt_dynamic(), and rz_return_val_if_fail.

Referenced by rz_bin_elf_get_libs().

rz_bin_elf_get_e_ehsize_as_string()

RZ_OWN char* Elf_() rz_bin_elf_get_e_ehsize_as_string

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 82 of file elf_ehdr.c.

                                                                             {
    rz_return_val_if_fail(bin, NULL);
 
    return rz_str_newf("%d", bin->ehdr.e_ehsize);
}

References NULL, rz_return_val_if_fail, and rz_str_newf().

Referenced by rz_bin_elf_print_ehdr().

rz_bin_elf_get_e_entry_as_string()

RZ_OWN char* Elf_() rz_bin_elf_get_e_entry_as_string

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 88 of file elf_ehdr.c.

                                                                            {
    rz_return_val_if_fail(bin, NULL);
 
    return rz_str_newf("0x%08" PFMT64x, (ut64)bin->ehdr.e_entry);
}

References NULL, PFMT64x, rz_return_val_if_fail, rz_str_newf(), and ut64().

Referenced by rz_bin_elf_print_ehdr().

rz_bin_elf_get_e_flags_as_string()

RZ_OWN char* Elf_() rz_bin_elf_get_e_flags_as_string

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 94 of file elf_ehdr.c.

                                                                            {
    rz_return_val_if_fail(bin, NULL);
 
    return rz_str_newf("0x%04x", bin->ehdr.e_flags);
}

References NULL, rz_return_val_if_fail, and rz_str_newf().

Referenced by rz_bin_elf_print_ehdr().

rz_bin_elf_get_e_indent_as_string()

RZ_OWN char* Elf_() rz_bin_elf_get_e_indent_as_string

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 100 of file elf_ehdr.c.

                                                                             {
    rz_return_val_if_fail(bin, NULL);
 
    return rz_str_newf("%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x",
        bin->ehdr.e_ident[0],
        bin->ehdr.e_ident[1],
        bin->ehdr.e_ident[2],
        bin->ehdr.e_ident[3],
        bin->ehdr.e_ident[4],
        bin->ehdr.e_ident[5],
        bin->ehdr.e_ident[6],
        bin->ehdr.e_ident[7],
        bin->ehdr.e_ident[8],
        bin->ehdr.e_ident[9],
        bin->ehdr.e_ident[10],
        bin->ehdr.e_ident[11],
        bin->ehdr.e_ident[12],
        bin->ehdr.e_ident[13],
        bin->ehdr.e_ident[14],
        bin->ehdr.e_ident[15]);
}

References NULL, rz_return_val_if_fail, and rz_str_newf().

Referenced by rz_bin_elf_print_ehdr().

rz_bin_elf_get_e_machine_as_string()

RZ_OWN char* Elf_() rz_bin_elf_get_e_machine_as_string

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 122 of file elf_ehdr.c.

                                                                              {
    rz_return_val_if_fail(bin, NULL);
 
    return rz_str_newf("0x%04x", bin->ehdr.e_machine);
}

References NULL, rz_return_val_if_fail, and rz_str_newf().

Referenced by rz_bin_elf_print_ehdr().

rz_bin_elf_get_e_phentsize_as_string()

RZ_OWN char* Elf_() rz_bin_elf_get_e_phentsize_as_string

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 128 of file elf_ehdr.c.

                                                                                {
    rz_return_val_if_fail(bin, NULL);
 
    return rz_str_newf("%d", bin->ehdr.e_phentsize);
}

References NULL, rz_return_val_if_fail, and rz_str_newf().

Referenced by rz_bin_elf_print_ehdr().

rz_bin_elf_get_e_phnum_as_string()

RZ_OWN char* Elf_() rz_bin_elf_get_e_phnum_as_string

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 134 of file elf_ehdr.c.

                                                                            {
    rz_return_val_if_fail(bin, NULL);
 
    return rz_str_newf("%d", bin->ehdr.e_phnum);
}

References NULL, rz_return_val_if_fail, and rz_str_newf().

Referenced by rz_bin_elf_print_ehdr().

rz_bin_elf_get_e_phoff_as_string()

RZ_OWN char* Elf_() rz_bin_elf_get_e_phoff_as_string

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 140 of file elf_ehdr.c.

                                                                            {
    rz_return_val_if_fail(bin, NULL);
 
    return rz_str_newf("0x%08" PFMT64x, (ut64)bin->ehdr.e_phoff);
}

References NULL, PFMT64x, rz_return_val_if_fail, rz_str_newf(), and ut64().

Referenced by rz_bin_elf_print_ehdr().

rz_bin_elf_get_e_shentsize_as_string()

RZ_OWN char* Elf_() rz_bin_elf_get_e_shentsize_as_string

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 146 of file elf_ehdr.c.

                                                                                {
    rz_return_val_if_fail(bin, NULL);
 
    return rz_str_newf("%d", bin->ehdr.e_shentsize);
}

References NULL, rz_return_val_if_fail, and rz_str_newf().

Referenced by rz_bin_elf_print_ehdr().

rz_bin_elf_get_e_shnum_as_string()

RZ_OWN char* Elf_() rz_bin_elf_get_e_shnum_as_string

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 152 of file elf_ehdr.c.

                                                                            {
    rz_return_val_if_fail(bin, NULL);
 
    return rz_str_newf("%d", bin->ehdr.e_shnum);
}

References NULL, rz_return_val_if_fail, and rz_str_newf().

Referenced by rz_bin_elf_print_ehdr().

rz_bin_elf_get_e_shoff_as_string()

RZ_OWN char* Elf_() rz_bin_elf_get_e_shoff_as_string

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 158 of file elf_ehdr.c.

                                                                            {
    rz_return_val_if_fail(bin, NULL);
 
    return rz_str_newf("0x%08" PFMT64x, (ut64)bin->ehdr.e_shoff);
}

References NULL, PFMT64x, rz_return_val_if_fail, rz_str_newf(), and ut64().

Referenced by rz_bin_elf_print_ehdr().

rz_bin_elf_get_e_shstrndx_as_string()

RZ_OWN char* Elf_() rz_bin_elf_get_e_shstrndx_as_string

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 164 of file elf_ehdr.c.

                                                                               {
    rz_return_val_if_fail(bin, NULL);
 
    return rz_str_newf("%d", bin->ehdr.e_shstrndx);
}

References NULL, rz_return_val_if_fail, and rz_str_newf().

Referenced by rz_bin_elf_print_ehdr().

rz_bin_elf_get_e_type_as_string()

RZ_OWN char* Elf_() rz_bin_elf_get_e_type_as_string

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 170 of file elf_ehdr.c.

                                                                           {
    rz_return_val_if_fail(bin, NULL);
 
    return rz_str_newf("0x%04x", bin->ehdr.e_type);
}

References NULL, rz_return_val_if_fail, and rz_str_newf().

Referenced by rz_bin_elf_print_ehdr().

rz_bin_elf_get_e_version_as_string()

RZ_OWN char* Elf_() rz_bin_elf_get_e_version_as_string

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 176 of file elf_ehdr.c.

                                                                              {
    rz_return_val_if_fail(bin, NULL);
 
    return rz_str_newf("0x%08x", bin->ehdr.e_version);
}

References NULL, rz_return_val_if_fail, and rz_str_newf().

Referenced by rz_bin_elf_print_ehdr().

rz_bin_elf_get_ehdr()

bool Elf_() rz_bin_elf_get_ehdr

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 182 of file elf_ehdr.c.

                                                       {
    rz_return_val_if_fail(bin, false);
 
    memset(&bin->ehdr, 0, sizeof(Elf_(Ehdr)));
 
    if (rz_buf_read_at(bin->b, 0, bin->ehdr.e_ident, EI_NIDENT) < EI_NIDENT) {
        RZ_LOG_WARN("Failed to read ELF header e_ident.\n")
        return false;
    }
 
    if (!is_valid_elf_ident(bin->ehdr.e_ident)) {
        RZ_LOG_WARN("Invalid ELF identification.\n");
        return false;
    }
 
    bin->big_endian = bin->ehdr.e_ident[EI_DATA] == ELFDATA2MSB;
 
    return read_ehdr_other(bin);
}

References EI_DATA, EI_NIDENT, Elf_(), ELFDATA2MSB, is_valid_elf_ident(), memset(), read_ehdr_other(), rz_buf_read_at(), RZ_LOG_WARN, and rz_return_val_if_fail.

Referenced by init_ehdr().

rz_bin_elf_get_elf_class()

RZ_OWN char* Elf_() rz_bin_elf_get_elf_class

(

RZ_NONNULL ELFOBJ *

bin

)

Return a string representing the elf class.

Parameters

elf

binary

Returns

allocated string

Check the elf header (e_ident) to deduce the elf class

Definition at line 1443 of file elf_info.c.

                                                                    {
    rz_return_val_if_fail(bin, NULL);
 
    for (size_t i = 0; i < RZ_ARRAY_SIZE(class_translation_table); i++) {
        if (bin->ehdr.e_ident[EI_CLASS] == class_translation_table[i].class) {
            return strdup(class_translation_table[i].name);
        }
    }
 
    return rz_str_newf("<unknown: %x>", bin->ehdr.e_ident[EI_CLASS]);
}

References class_translation::class, class_translation_table, EI_CLASS, i, NULL, RZ_ARRAY_SIZE, rz_return_val_if_fail, rz_str_newf(), and strdup().

rz_bin_elf_get_entry_offset()

ut64 Elf_() rz_bin_elf_get_entry_offset

(

RZ_NONNULL ELFOBJ *

bin

)

Get the entry offset.

Parameters

elf

binary

Returns

the entry offset

Get the entry offset from the elf header (e_entry), and if the information isn't defined section header will be used.

Definition at line 1813 of file elf_info.c.

                                                               {
    rz_return_val_if_fail(bin, UT64_MAX);
 
    if (!Elf_(rz_bin_elf_is_executable)(bin)) {
        return UT64_MAX;
    }
 
    ut64 entry = bin->ehdr.e_entry;
    if (entry) {
        ut64 tmp = Elf_(rz_bin_elf_v2p)(bin, entry);
        if (tmp == UT64_MAX) {
            return entry;
        }
 
        return tmp;
    }
 
    return get_entry_offset_from_shdr(bin);
}

References Elf_(), get_entry_offset_from_shdr(), rz_bin_elf_is_executable(), rz_bin_elf_v2p(), rz_return_val_if_fail, autogen_x86imm::tmp, ut64(), and UT64_MAX.

Referenced by rz_bin_elf_get_bits(), and rz_bin_elf_get_main_offset().

rz_bin_elf_get_file_type()

RZ_OWN char* Elf_() rz_bin_elf_get_file_type

(

RZ_NONNULL ELFOBJ *

bin

)

Return a string representing the file type.

Parameters

elf

binary

Returns

allocated string

Use the elf header (e_type) to deduce the file type

Definition at line 1462 of file elf_info.c.

                                                                    {
    rz_return_val_if_fail(bin, NULL);
 
    char *result = get_file_type_basic(bin);
    if (result) {
        return result;
    }
 
    if (file_type_is_processor_specific(bin)) {
        return rz_str_newf("Processor Specific: %x", bin->ehdr.e_type);
    }
 
    if (file_type_is_os_specific(bin)) {
        return rz_str_newf("OS Specific: %x", bin->ehdr.e_type);
    }
 
    return rz_str_newf("<unknown>: %x", bin->ehdr.e_type);
}

References file_type_is_os_specific(), file_type_is_processor_specific(), get_file_type_basic(), NULL, rz_return_val_if_fail, and rz_str_newf().

rz_bin_elf_get_fini_offset()

ut64 Elf_() rz_bin_elf_get_fini_offset

(

RZ_NONNULL ELFOBJ *

bin

)

Compute the fini offset of the binary.

Parameters

elf

binary

Returns

the init offset

Get the offset from the vaddr store in the dynamic section (dt_fini)

Definition at line 1840 of file elf_info.c.

                                                              {
    rz_return_val_if_fail(bin, 0);
 
    ut64 addr;
 
    if (!Elf_(rz_bin_elf_has_dt_dynamic)(bin)) {
        return 0;
    }
 
    if (!Elf_(rz_bin_elf_get_dt_info)(bin, DT_FINI, &addr)) {
        return 0;
    }
 
    return Elf_(rz_bin_elf_v2p)(bin, addr);
}

References addr, DT_FINI, Elf_(), rz_bin_elf_get_dt_info(), rz_bin_elf_has_dt_dynamic(), rz_bin_elf_v2p(), rz_return_val_if_fail, and ut64().

rz_bin_elf_get_gnu_hash_table()

bool Elf_() rz_bin_elf_get_gnu_hash_table	(	RZ_NONNULL ELFOBJ *	bin,
		RzBinElfGnuHashTable *	result
	)

Definition at line 64 of file elf_hash.c.

                                                                                               {
    rz_return_val_if_fail(bin && result, false);
 
    ut64 addr;
    if (!Elf_(rz_bin_elf_get_dt_info)(bin, DT_GNU_HASH, &addr)) {
        return false;
    }
 
    result->offset = Elf_(rz_bin_elf_v2p)(bin, addr);
    if (result->offset == UT64_MAX) {
        return false;
    }
 
    if (!read_gnu_hash_table(bin, result)) {
        RZ_LOG_WARN("Failed to read the GNU hash table (DT_GNU_HASH) at 0x%" PFMT64x ".\n", result->offset);
        return false;
    }
 
    return true;
}

References addr, DT_GNU_HASH, Elf_, PFMT64x, read_gnu_hash_table(), rz_bin_elf_get_dt_info(), rz_bin_elf_v2p(), RZ_LOG_WARN, rz_return_val_if_fail, ut64(), and UT64_MAX.

Referenced by rz_bin_elf_get_number_of_symbols_from_gnu_hash_table().

rz_bin_elf_get_hash_table()

bool Elf_() rz_bin_elf_get_hash_table	(	RZ_NONNULL ELFOBJ *	bin,
		RzBinElfHashTable *	result
	)

Definition at line 85 of file elf_hash.c.

                                                                                        {
    rz_return_val_if_fail(bin && result, false);
 
    ut64 addr;
    if (!Elf_(rz_bin_elf_get_dt_info)(bin, DT_HASH, &addr)) {
        return false;
    }
 
    result->offset = Elf_(rz_bin_elf_v2p)(bin, addr);
    if (result->offset == UT64_MAX) {
        return false;
    }
 
    if (!read_hash_table(bin, result)) {
        RZ_LOG_WARN("Failed to read the hash table (DT_HASH) at 0x%" PFMT64x ".\n", result->offset);
        return false;
    }
 
    return true;
}

References addr, DT_HASH, Elf_, PFMT64x, read_hash_table(), rz_bin_elf_get_dt_info(), rz_bin_elf_v2p(), RZ_LOG_WARN, rz_return_val_if_fail, ut64(), and UT64_MAX.

Referenced by rz_bin_elf_get_number_of_symbols_from_hash_table().

rz_bin_elf_get_head_flag()

RZ_OWN char* Elf_() rz_bin_elf_get_head_flag

(

RZ_NONNULL ELFOBJ *

bin

)

Return the head flag.

Returns

allocated string

...

Definition at line 1487 of file elf_info.c.

                                                                    {
    rz_return_val_if_fail(bin, NULL);
 
    char *head_flag = get_head_flag(bin);
 
    if (RZ_STR_ISEMPTY(head_flag)) {
        free(head_flag);
        return strdup("unknown_flag");
    }
 
    return head_flag;
}

References free(), get_head_flag(), NULL, rz_return_val_if_fail, RZ_STR_ISEMPTY, and strdup().

rz_bin_elf_get_import()

RZ_BORROW RzBinElfSymbol* Elf_() rz_bin_elf_get_import	(	RZ_NONNULL ELFOBJ *	bin,
		ut32	ordinal
	)

Definition at line 316 of file elf_imports.c.

                                                                                            {
    rz_return_val_if_fail(bin, NULL);
 
    RzBinElfSymbol *import;
    rz_bin_elf_foreach_imports(bin, import) {
        if (import->ordinal == ordinal) {
            return import;
        }
    }
 
    return NULL;
}

References NULL, rz_bin_elf_foreach_imports, and rz_return_val_if_fail.

rz_bin_elf_get_init_offset()

ut64 Elf_() rz_bin_elf_get_init_offset

(

RZ_NONNULL ELFOBJ *

bin

)

Compute the init offset of the binary.

Parameters

elf

binary

Returns

the init offset

Get the offset from the vaddr store in the dynamic section (dt_init)

Definition at line 1863 of file elf_info.c.

                                                              {
    rz_return_val_if_fail(bin, 0);
 
    ut64 addr;
 
    if (!Elf_(rz_bin_elf_has_dt_dynamic)(bin)) {
        return 0;
    }
 
    if (!Elf_(rz_bin_elf_get_dt_info)(bin, DT_INIT, &addr)) {
        return 0;
    }
 
    return Elf_(rz_bin_elf_v2p)(bin, addr);
}

References addr, DT_INIT, Elf_(), rz_bin_elf_get_dt_info(), rz_bin_elf_has_dt_dynamic(), rz_bin_elf_v2p(), rz_return_val_if_fail, and ut64().

rz_bin_elf_get_intrp()

RZ_OWN char* Elf_() rz_bin_elf_get_intrp

(

RZ_NONNULL ELFOBJ *

bin

)

Get the program interpreter.

Parameters

elf

binary

Returns

an allocated string

Get the program interpreter from the phdr

Definition at line 1568 of file elf_info.c.

                                                                {
    rz_return_val_if_fail(bin, NULL);
 
    if (!Elf_(rz_bin_elf_has_segments)(bin)) {
        return NULL;
    }
 
    RzBinElfSegment *segment = Elf_(rz_bin_elf_get_segment_with_type)(bin, PT_INTERP);
    if (!segment || !segment->is_valid) {
        return NULL;
    }
 
    return get_elf_intrp(bin, segment);
}

References Elf_(), get_elf_intrp(), NULL, PT_INTERP, rz_bin_elf_get_segment_with_type(), rz_bin_elf_has_segments(), rz_return_val_if_fail, and RzBinElfSegment.

rz_bin_elf_get_libs()

RZ_OWN RzList* Elf_() rz_bin_elf_get_libs

(

RZ_NONNULL ELFOBJ *

bin

)

List all imported lib.

Parameters

elf

binary

Returns

an allocated list of RzBinElfLib

Use dynamic information (dt_needed) to generate a list of imported lib

Definition at line 877 of file elf_info.c.

                                                                 {
    rz_return_val_if_fail(bin, NULL);
 
    if (!Elf_(rz_bin_elf_has_dt_dynamic)(bin) || !bin->dynstr) {
        return NULL;
    }
 
    RzVector *dt_needed = Elf_(rz_bin_elf_get_dt_needed)(bin);
    if (!dt_needed) {
        return NULL;
    }
 
    RzList *result = rz_list_newf(free);
    if (!result) {
        return NULL;
    }
 
    ut64 *iter = NULL;
    rz_vector_foreach(dt_needed, iter) {
        char *tmp = Elf_(rz_bin_elf_strtab_get_dup)(bin->dynstr, *iter);
        if (!tmp) {
            rz_list_free(result);
            return NULL;
        }
 
        if (!rz_list_append(result, tmp)) {
            rz_list_free(result);
            return NULL;
        }
    }
 
    return result;
}

References Elf_(), free(), NULL, rz_bin_elf_get_dt_needed(), rz_bin_elf_has_dt_dynamic(), rz_bin_elf_strtab_get_dup(), rz_list_append(), rz_list_free(), rz_list_newf(), rz_return_val_if_fail, rz_vector_foreach, autogen_x86imm::tmp, and ut64().

rz_bin_elf_get_machine_name()

RZ_OWN char* Elf_() rz_bin_elf_get_machine_name

(

RZ_NONNULL ELFOBJ *

bin

)

Return a string representing the machine name.

Parameters

elf

type

Returns

allocated string

Use http://www.sco.com/developers/gabi/latest/ch4.eheader.html and the elf header (e_machine)

Definition at line 1508 of file elf_info.c.

                                                                       {
    rz_return_val_if_fail(bin, NULL);
 
    for (size_t i = 0; i < RZ_ARRAY_SIZE(machine_name_translation_table); i++) {
        if (bin->ehdr.e_machine == machine_name_translation_table[i].machine) {
            return strdup(machine_name_translation_table[i].name);
        }
    }
 
    return rz_str_newf("<unknown>: 0x%x", bin->ehdr.e_machine);
}

References i, machine_name_translation_table, NULL, RZ_ARRAY_SIZE, rz_return_val_if_fail, rz_str_newf(), and strdup().

rz_bin_elf_get_main_offset()

ut64 Elf_() rz_bin_elf_get_main_offset

(

RZ_NONNULL ELFOBJ *

bin

)

Compute the main offset of the binary.

Parameters

elf

binary

Returns

the main offset

...

Definition at line 1886 of file elf_info.c.

                                                              {
    rz_return_val_if_fail(bin, UT64_MAX);
 
    ut8 buf[256] = { 0 };
    ut64 entry = Elf_(rz_bin_elf_get_entry_offset)(bin);
    ut64 main_addr;
 
    if (entry == UT64_MAX || entry > bin->size || (entry + sizeof(buf)) > bin->size) {
        return UT64_MAX;
    }
 
    if (rz_buf_read_at(bin->b, entry, buf, sizeof(buf)) < 0) {
        return UT64_MAX;
    }
 
    main_addr = get_main_offset_arm64(bin, entry, buf);
    if (main_addr != UT64_MAX) {
        return main_addr;
    }
 
    main_addr = get_main_offset_arm_glibc(bin, entry, buf);
    if (main_addr != UT64_MAX) {
        return main_addr;
    }
 
    main_addr = get_main_offset_mips(bin, entry, buf, RZ_ARRAY_SIZE(buf));
    if (main_addr != UT64_MAX) {
        return main_addr;
    }
 
    main_addr = get_main_offset_x86_gcc(bin, entry, buf);
    if (main_addr != UT64_MAX) {
        return main_addr;
    }
 
    main_addr = get_main_offset_x86_pie(bin, entry, buf);
    if (main_addr != UT64_MAX) {
        return main_addr;
    }
 
    main_addr = get_main_offset_x86_non_pie(bin, entry, buf);
    if (main_addr != UT64_MAX) {
        return main_addr;
    }
 
    main_addr = get_main_offset_linux_64_pie(bin, entry, buf);
    if (main_addr != UT64_MAX) {
        return main_addr;
    }
 
    return get_main_offset_from_symbol(bin);
}

References Elf_(), get_main_offset_arm64(), get_main_offset_arm_glibc(), get_main_offset_from_symbol(), get_main_offset_linux_64_pie(), get_main_offset_mips(), get_main_offset_x86_gcc(), get_main_offset_x86_non_pie(), get_main_offset_x86_pie(), RZ_ARRAY_SIZE, rz_bin_elf_get_entry_offset(), rz_buf_read_at(), rz_return_val_if_fail, ut64(), and UT64_MAX.

rz_bin_elf_get_num_relocs_dynamic_plt()

ut64 Elf_() rz_bin_elf_get_num_relocs_dynamic_plt

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 255 of file elf_relocs.c.

                                                                         {
    rz_return_val_if_fail(bin, 0);
 
    ut64 dt_pltrel;
    ut64 size;
 
    if (!Elf_(rz_bin_elf_get_dt_info)(bin, DT_PLTREL, &dt_pltrel) || !Elf_(rz_bin_elf_get_dt_info)(bin, DT_PLTRELSZ, &size)) {
        return 0;
    }
 
    ut64 entry_size = get_size_rel_mode(dt_pltrel);
    return size / entry_size;
}

References DT_PLTREL, DT_PLTRELSZ, Elf_, relocs_segment::entry_size, get_size_rel_mode(), rz_bin_elf_get_dt_info(), rz_return_val_if_fail, and ut64().

Referenced by get_import_addr_ppc().

rz_bin_elf_get_number_of_symbols_from_gnu_hash_table()

size_t Elf_() rz_bin_elf_get_number_of_symbols_from_gnu_hash_table

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 106 of file elf_hash.c.

                                                                                          {
    rz_return_val_if_fail(bin, false);
 
    RzBinElfGnuHashTable table;
    if (!Elf_(rz_bin_elf_get_gnu_hash_table)(bin, &table)) {
        return 0;
    }
 
    ut64 bloom_offset = table.offset + sizeof(struct gnu_hash_table);
    ut64 bucket_offset = bloom_offset + table.data.bloom_size * sizeof(Elf_(Addr));
    ut64 chain_offset = bucket_offset + table.data.nbuckets * sizeof(Elf_(Word));
 
    size_t index = get_highest_chain_index_in_gnu_hash_table_buckets(bin, &table, bucket_offset);
    return get_highest_symbol_index_in_gnu_hash_table_chains(bin, &table, chain_offset, index);
}

References rz_bin_elf_gnu_hash_table_t::data, Elf_, get_highest_chain_index_in_gnu_hash_table_buckets(), get_highest_symbol_index_in_gnu_hash_table_chains(), rz_bin_elf_gnu_hash_table_t::offset, rz_bin_elf_get_gnu_hash_table(), rz_return_val_if_fail, and ut64().

rz_bin_elf_get_number_of_symbols_from_hash_table()

size_t Elf_() rz_bin_elf_get_number_of_symbols_from_hash_table

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 122 of file elf_hash.c.

                                                                                      {
    rz_return_val_if_fail(bin, false);
 
    RzBinElfHashTable table;
    if (!Elf_(rz_bin_elf_get_hash_table)(bin, &table)) {
        return 0;
    }
 
    return table.data.nchains;
}

References rz_bin_elf_hash_table_::data, Elf_, rz_bin_elf_get_hash_table(), and rz_return_val_if_fail.

rz_bin_elf_get_osabi_name()

RZ_OWN char* Elf_() rz_bin_elf_get_osabi_name

(

RZ_NONNULL ELFOBJ *

bin

)

Return the os application binary interface name.

Parameters

elf

binary

Returns

an allocated string

Check the ehdr or the shdr to get the os name

Definition at line 1527 of file elf_info.c.

                                                                     {
    rz_return_val_if_fail(bin, NULL);
 
    char *name = get_osabi_name_from_ehdr(bin);
    if (name) {
        return name;
    }
 
    name = get_osabi_name_from_shdr(bin);
    if (name) {
        return name;
    }
 
    return strdup("linux");
}

References get_osabi_name_from_ehdr(), get_osabi_name_from_shdr(), name, NULL, rz_return_val_if_fail, and strdup().

rz_bin_elf_get_prstatus_layout()

RZ_BORROW RzBinElfPrStatusLayout* Elf_() rz_bin_elf_get_prstatus_layout

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 201 of file elf_notes.c.

                                                                                               {
    rz_return_val_if_fail(bin, NULL);
 
    switch (bin->ehdr.e_machine) {
    case EM_AARCH64:
        return prstatus_layouts + AARCH64;
    case EM_ARM:
        return prstatus_layouts + ARM;
    case EM_386:
        return prstatus_layouts + X86;
    case EM_X86_64:
        return prstatus_layouts + X86_64;
    }
 
    return NULL;
}

References AARCH64, ARM, EM_386, EM_AARCH64, EM_ARM, EM_X86_64, NULL, prstatus_layouts, rz_return_val_if_fail, X86, and X86_64.

Referenced by parse_note_prstatus(), and rz_bin_elf_get_sp_val().

rz_bin_elf_get_relocs_count()

size_t Elf_() rz_bin_elf_get_relocs_count

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 245 of file elf_relocs.c.

                                                                 {
    rz_return_val_if_fail(bin, 0);
 
    if (!bin->relocs) {
        return 0;
    }
 
    return rz_vector_len(bin->relocs);
}

References rz_return_val_if_fail, and rz_vector_len().

rz_bin_elf_get_rpath()

RZ_OWN char* Elf_() rz_bin_elf_get_rpath

(

RZ_NONNULL ELFOBJ *

bin

)

Get the rpath.

Parameters

elf

binary

Returns

allocated string

Use DT_RPATH or DT_RUNPATH to return the string

Definition at line 1550 of file elf_info.c.

                                                                {
    rz_return_val_if_fail(bin, NULL);
 
    if (!Elf_(rz_bin_elf_has_segments)(bin) || !bin->dynstr || !has_dt_rpath_entry(bin)) {
        return NULL;
    }
 
    Elf_(Xword) val = get_dt_rpath(bin);
    return Elf_(rz_bin_elf_strtab_get_dup)(bin->dynstr, val);
}

References Elf_(), has_dt_rpath_entry(), NULL, rz_bin_elf_has_segments(), rz_bin_elf_strtab_get_dup(), rz_return_val_if_fail, and val.

rz_bin_elf_get_section()

RZ_BORROW RzBinElfSection* Elf_() rz_bin_elf_get_section	(	RZ_NONNULL ELFOBJ *	bin,
		Elf_(Half)	index
	)

Definition at line 264 of file elf_sections.c.

                                                                                                  {
    rz_return_val_if_fail(bin, NULL);
 
    if (!bin->sections) {
        return NULL;
    }
 
    if (index < rz_vector_len(bin->sections)) {
        return rz_vector_index_ptr(bin->sections, index);
    }
 
    return NULL;
}

References NULL, rz_return_val_if_fail, rz_vector_index_ptr(), and rz_vector_len().

Referenced by convert_elf_symbol_entry(), fix_rva_and_offset_relocable_file(), and get_section_elf_symbols().

rz_bin_elf_get_section_with_name()

RZ_BORROW RzBinElfSection* Elf_() rz_bin_elf_get_section_with_name	(	RZ_NONNULL ELFOBJ *	bin,
		RZ_NONNULL const char *	name
	)

Definition at line 278 of file elf_sections.c.

                                                                                                                       {
    rz_return_val_if_fail(bin, NULL);
 
    RzBinElfSection *section;
    rz_bin_elf_foreach_sections(bin, section) {
        if (section->is_valid && section->name && !strcmp(section->name, name)) {
            return section;
        }
    }
 
    return NULL;
}

References NULL, rz_bin_elf_foreach_sections, and rz_return_val_if_fail.

Referenced by get_entry_offset_from_shdr(), get_gnu_debugdata_elf_symbols(), get_import_addr_x86(), get_import_addr_x86_manual(), and rz_bin_elf_get_compiler().

rz_bin_elf_get_segment_with_type()

RZ_BORROW RzBinElfSegment* Elf_() rz_bin_elf_get_segment_with_type	(	RZ_NONNULL ELFOBJ *	bin,
		Elf_(Word)	type
	)

Definition at line 120 of file elf_segments.c.

                                                                                                           {
    rz_return_val_if_fail(bin, NULL);
 
    RzBinElfSegment *iter;
    rz_bin_elf_foreach_segments(bin, iter) {
        if (iter->data.p_type == type) {
            return iter;
        }
    }
 
    return NULL;
}

References NULL, rz_bin_elf_foreach_segments, rz_return_val_if_fail, RzBinElfSegment, and type.

Referenced by elf_has_gnu_relro(), init_dt_dynamic(), rz_bin_elf_get_intrp(), rz_bin_elf_has_nx(), and rz_bin_elf_is_static().

rz_bin_elf_get_sp_val()

ut64 Elf_() rz_bin_elf_get_sp_val

(

RZ_NONNULL ELFOBJ *

bin

)

Get the stack pointer value.

Parameters

elf

binary

Returns

allocated string

Get the value of the stack pointer register in a core file from NT_PRSTATUS

Definition at line 16 of file elf_corefile.c.

                                                         {
    rz_return_val_if_fail(bin, UT64_MAX);
 
    RzBinElfPrStatusLayout *layout = Elf_(rz_bin_elf_get_prstatus_layout)(bin);
    if (!layout) {
        return UT64_MAX;
    }
 
    RzVector *notes;
    rz_bin_elf_foreach_notes_segment(bin, notes) {
        RzBinElfNote *tmp;
        rz_vector_foreach(notes, tmp) {
            if (tmp->type != NT_PRSTATUS) {
                continue;
            }
 
            RzBinElfNotePrStatus *note = &tmp->prstatus;
            if (layout->sp_offset + layout->sp_size / 8 > note->regstate_size) {
                return UT64_MAX;
            }
 
            return rz_read_ble(note->regstate + layout->sp_offset, bin->big_endian, layout->sp_size);
        }
    }
 
    return UT64_MAX;
}

References Elf_, NT_PRSTATUS, rz_bin_elf_note_prstatus_t::regstate, rz_bin_elf_note_prstatus_t::regstate_size, rz_bin_elf_foreach_notes_segment, rz_bin_elf_get_prstatus_layout(), rz_read_ble(), rz_return_val_if_fail, rz_vector_foreach, RzBinElfNote, prstatus_layout_t::sp_offset, prstatus_layout_t::sp_size, autogen_x86imm::tmp, and UT64_MAX.

rz_bin_elf_get_symbol()

RZ_BORROW RzBinElfSymbol* Elf_() rz_bin_elf_get_symbol	(	RZ_NONNULL ELFOBJ *	bin,
		ut32	ordinal
	)

Definition at line 473 of file elf_symbols.c.

                                                                                            {
    rz_return_val_if_fail(bin, NULL);
 
    RzBinElfSymbol *symbol;
    rz_bin_elf_foreach_symbols(bin, symbol) {
        if (symbol->ordinal == ordinal) {
            return symbol;
        }
    }
 
    return NULL;
}

References NULL, rz_bin_elf_symbol_t::ordinal, rz_bin_elf_foreach_symbols, and rz_return_val_if_fail.

rz_bin_elf_get_symbols_info()

RZ_OWN Sdb* Elf_() rz_bin_elf_get_symbols_info

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 1301 of file elf_info.c.

                                                                             {
    rz_return_val_if_fail(bin, false);
 
    if (!Elf_(rz_bin_elf_is_executable)(bin)) {
        return NULL;
    }
 
    Sdb *res = sdb_new0();
    if (!res) {
        return NULL;
    }
 
    Sdb *sdb = get_gnu_verneed(bin);
    if (sdb && !sdb_ns_set(res, "verneed", sdb)) {
        sdb_free(res);
        sdb_free(sdb);
        return NULL;
    }
    sdb_free(sdb);
 
    sdb = get_gnu_versym(bin);
    if (sdb && !sdb_ns_set(res, "versym", sdb)) {
        sdb_free(res);
        sdb_free(sdb);
        return NULL;
    }
    sdb_free(sdb);
 
    return res;
}

References Elf_(), get_gnu_verneed(), get_gnu_versym(), NULL, rz_bin_elf_is_executable(), rz_return_val_if_fail, sdb_free(), sdb_new0(), and sdb_ns_set().

Referenced by init_symbols_info_aux().

rz_bin_elf_get_targets_map_base()

ut64 Elf_() rz_bin_elf_get_targets_map_base

(

ELFOBJ *

bin

)

Definition at line 44 of file elf_map.c.

                                                        {
    ut64 result = get_targets_map_base(bin);
    result += 0x8; // small additional shift to not overlap with symbols like _end
    return result + rz_num_align_delta(result, sizeof(Elf_(Addr)));
}

References Elf_, get_targets_map_base(), rz_num_align_delta(), and ut64().

Referenced by init().

rz_bin_elf_has_dt_dynamic()

bool Elf_() rz_bin_elf_has_dt_dynamic

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 130 of file elf_dynamic.c.

                                                             {
    rz_return_val_if_fail(bin, false);
    return bin->dt_dynamic;
}

References rz_return_val_if_fail.

Referenced by get_import_addr(), get_relocs_entry_from_dt_dynamic(), rz_bin_elf_get_dt_info(), rz_bin_elf_get_dt_needed(), rz_bin_elf_get_fini_offset(), rz_bin_elf_get_init_offset(), and rz_bin_elf_get_libs().

rz_bin_elf_has_imports()

bool Elf_() rz_bin_elf_has_imports

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 342 of file elf_imports.c.

                                                          {
    rz_return_val_if_fail(bin, false);
    return bin->imports;
}

References rz_return_val_if_fail.

rz_bin_elf_has_notes()

bool Elf_() rz_bin_elf_has_notes

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 255 of file elf_notes.c.

                                                        {
    rz_return_val_if_fail(bin, false);
    return bin->notes;
}

References rz_return_val_if_fail.

rz_bin_elf_has_nx()

bool Elf_() rz_bin_elf_has_nx

(

RZ_NONNULL ELFOBJ *

bin

)

Check if the stack is not executable.

Parameters

elf

binary

Returns

true, false

Check p_flags from the segment PT_GNU_STACK

Definition at line 1615 of file elf_info.c.

                                                     {
    rz_return_val_if_fail(bin, false);
 
    if (!Elf_(rz_bin_elf_has_segments)(bin)) {
        return false;
    }
 
    RzBinElfSegment *segment = Elf_(rz_bin_elf_get_segment_with_type)(bin, PT_GNU_STACK);
    if (!segment || !segment->is_valid) {
        return false;
    }
 
    return !(segment->data.p_flags & PF_X);
}

References Elf_(), PF_X, PT_GNU_STACK, rz_bin_elf_get_segment_with_type(), rz_bin_elf_has_segments(), rz_return_val_if_fail, and RzBinElfSegment.

rz_bin_elf_has_relocs()

bool Elf_() rz_bin_elf_has_relocs

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 239 of file elf_relocs.c.

                                                         {
    rz_return_val_if_fail(bin, false);
 
    return bin->relocs;
}

References rz_return_val_if_fail.

Referenced by get_import_addr().

rz_bin_elf_has_relro()

int Elf_() rz_bin_elf_has_relro

(

RZ_NONNULL ELFOBJ *

bin

)

Analyse if the elf binary has relro or partial relro.

Parameters

elf

binary

Returns

RZ_BIN_ELF_NO_RELRO, RZ_BIN_ELF_PART_RELRO or RZ_BIN_ELF_FULL_RELRO

Check if the elf has bind now enable and with PT_GNU_RELRO can deduct the relro type

Definition at line 1733 of file elf_info.c.

                                                       {
    rz_return_val_if_fail(bin, RZ_BIN_ELF_NO_RELRO);
 
    bool is_bind_now = elf_is_bind_now(bin);
    bool has_gnu_relro = elf_has_gnu_relro(bin);
 
    if (has_gnu_relro) {
        if (is_bind_now) {
            return RZ_BIN_ELF_FULL_RELRO;
        }
 
        return RZ_BIN_ELF_PART_RELRO;
    }
 
    return RZ_BIN_ELF_NO_RELRO;
}

References elf_has_gnu_relro(), elf_is_bind_now(), RZ_BIN_ELF_FULL_RELRO, RZ_BIN_ELF_NO_RELRO, RZ_BIN_ELF_PART_RELRO, and rz_return_val_if_fail.

Referenced by get_import_addr_x86_manual(), and init_dt_dynamic_sdb().

rz_bin_elf_has_sections()

bool Elf_() rz_bin_elf_has_sections

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 440 of file elf_sections.c.

                                                           {
    rz_return_val_if_fail(bin, false);
 
    return bin->sections;
}

References rz_return_val_if_fail.

Referenced by rz_bin_elf_is_stripped().

rz_bin_elf_has_segments()

bool Elf_() rz_bin_elf_has_segments

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 149 of file elf_segments.c.

                                                           {
    rz_return_val_if_fail(bin, false);
    return bin->segments;
}

References rz_return_val_if_fail.

Referenced by arch_is_mips(), convert_sections(), elf_has_gnu_relro(), get_main_offset_x86_pie(), get_targets_map_base(), rz_bin_elf_get_baddr(), rz_bin_elf_get_boffset(), rz_bin_elf_get_cpu(), rz_bin_elf_get_intrp(), rz_bin_elf_get_rpath(), rz_bin_elf_has_nx(), rz_bin_elf_p2v(), and rz_bin_elf_v2p().

rz_bin_elf_has_symbols()

bool Elf_() rz_bin_elf_has_symbols

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 534 of file elf_symbols.c.

                                                          {
    rz_return_val_if_fail(bin, false);
    return bin->symbols;
}

References rz_return_val_if_fail.

rz_bin_elf_has_va()

bool Elf_() rz_bin_elf_has_va

(

ELFOBJ *

bin

)

Check if the elf use virtual address.

Parameters

elf

binary

Returns

always true

Return always true

Definition at line 1637 of file elf_info.c.

                                          {
    return true;
}

rz_bin_elf_is_arm_binary_supporting_thumb()

bool Elf_() rz_bin_elf_is_arm_binary_supporting_thumb

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 19 of file elf_arm.c.

                                                                             {
    rz_return_val_if_fail(bin, false);
    return bin->ehdr.e_machine == EM_ARM;
}

References EM_ARM, and rz_return_val_if_fail.

Referenced by rz_bin_elf_get_bits().

rz_bin_elf_is_big_endian()

bool Elf_() rz_bin_elf_is_big_endian

(

RZ_NONNULL ELFOBJ *

bin

)

Check the binary endianness.

Parameters

elf

type

Returns

is_big_endian ?

Use the elf header (e_ident[EI_DATA]) to check the binary endianness

Definition at line 1757 of file elf_info.c.

                                                            {
    rz_return_val_if_fail(bin, false);
 
    return bin->ehdr.e_ident[EI_DATA] == ELFDATA2MSB;
}

References EI_DATA, ELFDATA2MSB, and rz_return_val_if_fail.

rz_bin_elf_is_executable()

bool Elf_() rz_bin_elf_is_executable

(

RZ_NONNULL ELFOBJ *

bin

)

Check if the elf binary is executable.

Parameters

elf

binary

Returns

is_executable ?

Use the elf header entry e_type to deduct if the elf is executable.

Definition at line 1648 of file elf_info.c.

                                                            {
    rz_return_val_if_fail(bin, false);
 
    const Elf_(Half) type = bin->ehdr.e_type;
    return type == ET_EXEC || type == ET_DYN;
}

References Elf_(), ET_DYN, ET_EXEC, rz_return_val_if_fail, and type.

Referenced by get_dynamic_elf_symbols(), is_playstation_hack(), rz_bin_elf_get_entry_offset(), and rz_bin_elf_get_symbols_info().

rz_bin_elf_is_relocatable()

bool Elf_() rz_bin_elf_is_relocatable

(

RZ_NONNULL ELFOBJ *

bin

)

Check if the elf binary is relocatable.

Parameters

elf

binary

Returns

is_relocatable ?

Use the elf header entry e_type to deduct if the elf is relocatable.

Definition at line 1662 of file elf_info.c.

                                                             {
    rz_return_val_if_fail(bin, false);
    return bin->ehdr.e_type == ET_REL;
}

References ET_REL, and rz_return_val_if_fail.

Referenced by convert_elf_symbol_entry(), filter_import(), fix_rva_and_offset(), init(), rz_bin_elf_get_baddr(), rz_bin_elf_p2v(), rz_bin_elf_v2p(), and set_elf_section_aux().

rz_bin_elf_is_static()

bool Elf_() rz_bin_elf_is_static

(

RZ_NONNULL ELFOBJ *

bin

)

Check if the binary is statically-linked library.

Parameters

elf

binary

Returns

is_static ?

Check the presence of PT_INTERP or PT_DYNAMIC in the program header

Definition at line 1674 of file elf_info.c.

                                                        {
    rz_return_val_if_fail(bin, false);
 
    RzBinElfSegment *segment = Elf_(rz_bin_elf_get_segment_with_type)(bin, PT_INTERP);
    if (segment && segment->is_valid) {
        return false;
    }
 
    segment = Elf_(rz_bin_elf_get_segment_with_type)(bin, PT_DYNAMIC);
    if (segment && segment->is_valid) {
        return false;
    }
 
    return true;
}

References Elf_(), PT_DYNAMIC, PT_INTERP, rz_bin_elf_get_segment_with_type(), rz_return_val_if_fail, and RzBinElfSegment.

Referenced by init(), is_playstation_hack(), and rz_bin_elf_get_bits().

rz_bin_elf_is_stripped()

bool Elf_() rz_bin_elf_is_stripped

(

RZ_NONNULL ELFOBJ *

bin

)

Check if the binary is stripped.

Parameters

elf	binary
is_stripped	?

Returns

a ptr to a new allocated RzBinSymbol

Use the shdr to check if the binary is stripped

Definition at line 1591 of file elf_info.c.

                                                          {
    rz_return_val_if_fail(bin, false);
 
    if (!Elf_(rz_bin_elf_has_sections)(bin)) {
        return false;
    }
 
    RzBinElfSection *section;
    rz_bin_elf_foreach_sections(bin, section) {
        if (section->type == SHT_SYMTAB) {
            return false;
        }
    }
 
    return true;
}

References Elf_(), rz_bin_elf_foreach_sections, rz_bin_elf_has_sections(), rz_return_val_if_fail, and SHT_SYMTAB.

rz_bin_elf_is_thumb_addr()

bool Elf_() rz_bin_elf_is_thumb_addr

(

ut64

addr

)

Definition at line 24 of file elf_arm.c.

                                               {
    return addr != UT64_MAX && addr & 1;
}

References addr, and UT64_MAX.

Referenced by get_import_addr_arm(), get_main_offset_arm_glibc(), has_thumb_symbol(), rz_bin_elf_fix_arm_thumb_addr(), rz_bin_elf_fix_arm_thumb_object(), and rz_bin_elf_get_bits().

rz_bin_elf_mul_addr()

bool Elf_() rz_bin_elf_mul_addr	(	Elf_(Addr) *	result,
		Elf_(Addr)	addr,
		Elf_(Addr)	value
	)

Definition at line 154 of file elf_misc.c.

                                                                                       {
#if RZ_BIN_ELF64
    return UT64_MUL((ut64 *)result, addr, value);
#else
    return UT32_MUL((ut32 *)result, addr, value);
#endif
}

References addr, UT32_MUL(), ut64(), UT64_MUL(), and value.

Referenced by parse_note_file().

rz_bin_elf_mul_off()

bool Elf_() rz_bin_elf_mul_off	(	Elf_(Off) *	result,
		Elf_(Off)	addr,
		Elf_(Off)	value
	)

Definition at line 162 of file elf_misc.c.

                                                                                   {
#if RZ_BIN_ELF64
    return UT64_MUL((ut64 *)result, addr, value);
#else
    return UT32_MUL((ut32 *)result, addr, value);
#endif
}

References addr, UT32_MUL(), ut64(), UT64_MUL(), and value.

Referenced by rz_bin_elf_check_array().

rz_bin_elf_new_buf()

RZ_OWN ELFOBJ* Elf_() rz_bin_elf_new_buf	(	RZ_NONNULL RzBuffer *	buf,
		RZ_NONNULL RzBinObjectLoadOptions *	options
	)

Definition at line 339 of file elf.c.

                                                                                                              {
    rz_return_val_if_fail(buf && options, NULL);
 
    ELFOBJ *bin = RZ_NEW0(ELFOBJ);
    if (!bin) {
        return NULL;
    }
 
    bin->b = rz_buf_ref(buf);
    bin->kv = sdb_new0();
 
    bin->size = rz_buf_size(buf);
 
    if (!init(bin, options)) {
        Elf_(rz_bin_elf_free)(bin);
        return NULL;
    }
 
    return bin;
}

References Elf_, ELFOBJ, init(), NULL, options, rz_bin_elf_free(), rz_buf_ref(), rz_buf_size(), RZ_NEW0, rz_return_val_if_fail, and sdb_new0().

Referenced by get_gnu_debugdata_elf_symbols().

rz_bin_elf_notes_new()

RZ_OWN RzVector* Elf_() rz_bin_elf_notes_new

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 218 of file elf_notes.c.

                                                                    {
    rz_return_val_if_fail(bin, false);
 
    RzVector *result = rz_vector_new(sizeof(RzVector), note_segment_free, NULL);
    if (!result) {
        return NULL;
    }
 
    RzBinElfSegment *segment;
    rz_bin_elf_foreach_segments(bin, segment) {
        if (!segment->is_valid || segment->data.p_type != PT_NOTE) {
            continue;
        }
 
        RzVector *notes = rz_vector_push(result, NULL);
        if (!notes) {
            rz_vector_free(result);
            return NULL;
        }
 
        rz_vector_init(notes, sizeof(RzBinElfNote), note_free, NULL);
 
        if (!set_note_segment(bin, notes, segment)) {
            rz_vector_fini(notes);
            rz_vector_free(result);
            return NULL;
        }
    }
 
    if (!rz_vector_len(result)) {
        rz_vector_free(result);
        return NULL;
    }
 
    return result;
}

References note_free(), note_segment_free(), NULL, PT_NOTE, rz_bin_elf_foreach_segments, rz_return_val_if_fail, rz_vector_fini(), rz_vector_free(), rz_vector_init(), rz_vector_len(), rz_vector_new(), rz_vector_push(), RzBinElfNote, RzBinElfSegment, and set_note_segment().

Referenced by init().

rz_bin_elf_p2v()

ut64 Elf_() rz_bin_elf_p2v	(	RZ_NONNULL ELFOBJ *	bin,
		ut64	paddr
	)

Convert a physical address to the virtual address.

Parameters

elf

binary

Returns

virtual addr

Converts a physical address to the virtual address, looking at the program headers in the binary bin

Definition at line 400 of file elf.c.

                                                              {
    rz_return_val_if_fail(bin, UT64_MAX);
 
    if (!Elf_(rz_bin_elf_has_segments)(bin)) {
        if (Elf_(rz_bin_elf_is_relocatable)(bin)) {
            return bin->baddr + paddr;
        }
 
        return UT64_MAX;
    }
 
    RzBinElfSegment *segment;
    rz_bin_elf_foreach_segments(bin, segment) {
        if (segment->data.p_type == PT_LOAD && in_physical_phdr(segment, paddr)) {
            return segment->data.p_vaddr + paddr - segment->data.p_offset;
        }
    }
 
    return UT64_MAX;
}

References Elf_, in_physical_phdr(), PT_LOAD, rz_bin_elf_foreach_segments, rz_bin_elf_has_segments(), rz_bin_elf_is_relocatable(), rz_return_val_if_fail, RzBinElfSegment, and UT64_MAX.

Referenced by convert_elf_symbol_entry(), fix_rva_and_offset_relocable_file(), get_main_offset_arm64(), get_main_offset_linux_64_pie(), get_main_offset_x86_gcc(), and get_main_offset_x86_pie().

rz_bin_elf_print_ehdr()

bool Elf_() rz_bin_elf_print_ehdr	(	ELFOBJ *	bin,
		RZ_NONNULL PrintfCallback	cb
	)

Definition at line 202 of file elf_ehdr.c.

                                                                            {
    rz_return_val_if_fail(bin && cb, false);
 
    return print_ehdr_aux(bin, cb, E_IDENT_OFFSET, "MAGIC", Elf_(rz_bin_elf_get_e_indent_as_string)) &&
        print_ehdr_aux(bin, cb, E_TYPE_OFFSET, "Type", Elf_(rz_bin_elf_get_e_type_as_string)) &&
        print_ehdr_aux(bin, cb, E_MACHINE_OFFSET, "Machine", Elf_(rz_bin_elf_get_e_machine_as_string)) &&
        print_ehdr_aux(bin, cb, E_VERSION_OFFSET, "Version", Elf_(rz_bin_elf_get_e_version_as_string)) &&
        print_ehdr_aux(bin, cb, E_ENTRYPOINT_OFFSET, "Entrypoint", Elf_(rz_bin_elf_get_e_entry_as_string)) &&
        print_ehdr_aux(bin, cb, E_PHOFF_OFFSET, "PhOff", Elf_(rz_bin_elf_get_e_phoff_as_string)) &&
        print_ehdr_aux(bin, cb, E_SHOFF_OFFSET, "ShOff", Elf_(rz_bin_elf_get_e_shoff_as_string)) &&
        print_ehdr_aux(bin, cb, E_FLAGS_OFFSET, "Flags", Elf_(rz_bin_elf_get_e_flags_as_string)) &&
        print_ehdr_aux(bin, cb, E_EHSIZE_OFFSET, "EhSize", Elf_(rz_bin_elf_get_e_ehsize_as_string)) &&
        print_ehdr_aux(bin, cb, E_PHENTSIZE_OFFSET, "PhentSize", Elf_(rz_bin_elf_get_e_phentsize_as_string)) &&
        print_ehdr_aux(bin, cb, E_PHNUM_OFFSET, "PhNum", Elf_(rz_bin_elf_get_e_phnum_as_string)) &&
        print_ehdr_aux(bin, cb, E_SHENTSIZE_OFFSET, "ShentSize", Elf_(rz_bin_elf_get_e_shentsize_as_string)) &&
        print_ehdr_aux(bin, cb, E_SHNUM_OFFSET, "ShNum", Elf_(rz_bin_elf_get_e_shnum_as_string)) &&
        print_ehdr_aux(bin, cb, E_SHSTRNDX_OFFSET, "ShStrndx", Elf_(rz_bin_elf_get_e_shstrndx_as_string));
}

References cb, E_EHSIZE_OFFSET, E_ENTRYPOINT_OFFSET, E_FLAGS_OFFSET, E_IDENT_OFFSET, E_MACHINE_OFFSET, E_PHENTSIZE_OFFSET, E_PHNUM_OFFSET, E_PHOFF_OFFSET, E_SHENTSIZE_OFFSET, E_SHNUM_OFFSET, E_SHOFF_OFFSET, E_SHSTRNDX_OFFSET, E_TYPE_OFFSET, E_VERSION_OFFSET, Elf_(), print_ehdr_aux(), rz_bin_elf_get_e_ehsize_as_string(), rz_bin_elf_get_e_entry_as_string(), rz_bin_elf_get_e_flags_as_string(), rz_bin_elf_get_e_indent_as_string(), rz_bin_elf_get_e_machine_as_string(), rz_bin_elf_get_e_phentsize_as_string(), rz_bin_elf_get_e_phnum_as_string(), rz_bin_elf_get_e_phoff_as_string(), rz_bin_elf_get_e_shentsize_as_string(), rz_bin_elf_get_e_shnum_as_string(), rz_bin_elf_get_e_shoff_as_string(), rz_bin_elf_get_e_shstrndx_as_string(), rz_bin_elf_get_e_type_as_string(), rz_bin_elf_get_e_version_as_string(), and rz_return_val_if_fail.

rz_bin_elf_read_addr()

bool Elf_() rz_bin_elf_read_addr	(	RZ_NONNULL ELFOBJ *	bin,
		RZ_NONNULL RZ_INOUT ut64 *	offset,
		RZ_NONNULL RZ_OUT Elf_(Addr) *	result
	)

Definition at line 82 of file elf_misc.c.

                                                                                                                                 {
    rz_return_val_if_fail(bin && offset && result, false);
#if RZ_BIN_ELF64
    return rz_buf_read_ble64_offset(bin->b, offset, (ut64 *)result, bin->big_endian);
#else
    return rz_buf_read_ble32_offset(bin->b, offset, (ut32 *)result, bin->big_endian);
#endif
}

References rz_return_val_if_fail, and ut64().

Referenced by get_dynamic_entry_aux(), get_got_entry(), get_note_file_aux(), get_phdr_entry(), get_shdr_entry_aux(), get_symbol_entry_aux(), parse_note_file(), read_ehdr_other_aux(), and read_reloc_entry_aux().

rz_bin_elf_read_char()

bool Elf_() rz_bin_elf_read_char	(	RZ_NONNULL ELFOBJ *	bin,
		RZ_NONNULL RZ_INOUT ut64 *	offset,
		RZ_NONNULL RZ_OUT ut8 *	result
	)

Definition at line 52 of file elf_misc.c.

                                                                                                                         {
    rz_return_val_if_fail(bin && offset && result, false);
    return rz_buf_read8_offset(bin->b, offset, result);
}

References rz_buf_read8_offset, and rz_return_val_if_fail.

Referenced by Elf_(), and get_symbol_entry_aux().

rz_bin_elf_read_half()

bool Elf_() rz_bin_elf_read_half	(	RZ_NONNULL ELFOBJ *	bin,
		RZ_NONNULL RZ_INOUT ut64 *	offset,
		RZ_NONNULL RZ_OUT Elf_(Half) *	result
	)

Definition at line 57 of file elf_misc.c.

                                                                                                                                 {
    rz_return_val_if_fail(bin && offset && result, false);
    return rz_buf_read_ble16_offset(bin->b, offset, result, bin->big_endian);
}

References rz_return_val_if_fail.

Referenced by get_verdef_entry_aux(), get_vernaux_entry_aux(), get_verneed_entry_aux(), read_ehdr_other(), read_ehdr_other_aux(), and rz_bin_elf_read_versym().

rz_bin_elf_read_off()

bool Elf_() rz_bin_elf_read_off	(	RZ_NONNULL ELFOBJ *	bin,
		RZ_NONNULL RZ_INOUT ut64 *	offset,
		RZ_NONNULL RZ_OUT Elf_(Off) *	result
	)

Definition at line 91 of file elf_misc.c.

                                                                                                                               {
    rz_return_val_if_fail(bin && offset && result, false);
#if RZ_BIN_ELF64
    return rz_buf_read_ble64_offset(bin->b, offset, (ut64 *)result, bin->big_endian);
#else
    return rz_buf_read_ble32_offset(bin->b, offset, (ut32 *)result, bin->big_endian);
#endif
}

References rz_return_val_if_fail, and ut64().

Referenced by get_note_file_aux(), get_phdr_entry(), get_shdr_entry_aux(), and read_ehdr_other_aux().

rz_bin_elf_read_section()

bool Elf_() rz_bin_elf_read_section	(	RZ_NONNULL ELFOBJ *	bin,
		RZ_NONNULL RZ_INOUT ut64 *	offset,
		RZ_NONNULL RZ_OUT Elf_(Section) *	result
	)

Definition at line 100 of file elf_misc.c.

                                                                                                                                       {
    rz_return_val_if_fail(bin && offset && result, false);
    return rz_buf_read_ble16_offset(bin->b, offset, (ut16 *)result, bin->big_endian);
}

References rz_return_val_if_fail.

Referenced by get_symbol_entry_aux().

rz_bin_elf_read_sword()

bool Elf_() rz_bin_elf_read_sword	(	RZ_NONNULL ELFOBJ *	bin,
		RZ_NONNULL RZ_INOUT ut64 *	offset,
		RZ_NONNULL RZ_OUT Elf_(Sword) *	result
	)

Definition at line 67 of file elf_misc.c.

                                                                                                                                   {
    rz_return_val_if_fail(bin && offset && result, false);
    return buffer_read_32_signed(bin, offset, result);
}

References buffer_read_32_signed(), and rz_return_val_if_fail.

Referenced by rz_bin_elf_read_sword_sxword().

rz_bin_elf_read_sword_sxword()

bool Elf_() rz_bin_elf_read_sword_sxword	(	RZ_NONNULL ELFOBJ *	bin,
		RZ_NONNULL RZ_INOUT ut64 *	offset,
		RZ_NONNULL RZ_OUT Elf_(Sword) *	result
	)

Definition at line 131 of file elf_misc.c.

                                                                                                                                          {
    rz_return_val_if_fail(bin && offset && result, false);
 
    return Elf_(rz_bin_elf_read_sword)(bin, offset, result);
}

References Elf_, rz_bin_elf_read_sword(), and rz_return_val_if_fail.

Referenced by get_dynamic_entry_aux(), and read_reloc_entry_aux().

rz_bin_elf_read_sxword()

bool Elf_() rz_bin_elf_read_sxword	(	RZ_NONNULL ELFOBJ *	bin,
		RZ_NONNULL RZ_INOUT ut64 *	offset,
		RZ_NONNULL RZ_OUT Elf_(Sxword) *	result
	)

Definition at line 77 of file elf_misc.c.

                                                                                                                                     {
    rz_return_val_if_fail(bin && offset && result, false);
    return buffer_read_64_signed(bin, offset, (st64 *)result);
}

References buffer_read_64_signed(), rz_return_val_if_fail, and st64.

rz_bin_elf_read_versym()

bool Elf_() rz_bin_elf_read_versym	(	RZ_NONNULL ELFOBJ *	bin,
		RZ_NONNULL RZ_INOUT ut64 *	offset,
		RZ_NONNULL RZ_OUT Elf_(Versym) *	result
	)

Definition at line 105 of file elf_misc.c.

                                                                                                                                     {
    rz_return_val_if_fail(bin && offset && result, false);
    return Elf_(rz_bin_elf_read_half)(bin, offset, result);
}

References Elf_, rz_bin_elf_read_half(), and rz_return_val_if_fail.

Referenced by get_gnu_versym().

rz_bin_elf_read_word()

bool Elf_() rz_bin_elf_read_word	(	RZ_NONNULL ELFOBJ *	bin,
		RZ_NONNULL RZ_INOUT ut64 *	offset,
		RZ_NONNULL RZ_OUT Elf_(Word) *	result
	)

Definition at line 62 of file elf_misc.c.

                                                                                                                                 {
    rz_return_val_if_fail(bin && offset && result, false);
    return rz_buf_read_ble32_offset(bin->b, offset, result, bin->big_endian);
}

References rz_return_val_if_fail.

Referenced by get_highest_chain_index_in_gnu_hash_table_buckets(), get_highest_symbol_index_in_gnu_hash_table_chains(), get_import_addr_x86_manual(), get_phdr_entry(), get_shdr_entry_aux(), get_symbol_entry_aux(), get_verdaux_entry_aux(), get_verdef_entry_aux(), get_vernaux_entry_aux(), get_verneed_entry_aux(), read_ehdr_other_aux(), read_gnu_hash_table(), read_hash_table(), read_note_segment_header(), and rz_bin_elf_read_word_xword().

rz_bin_elf_read_word_xword()

bool Elf_() rz_bin_elf_read_word_xword	(	RZ_NONNULL ELFOBJ *	bin,
		RZ_NONNULL RZ_INOUT ut64 *	offset,
		RZ_NONNULL RZ_OUT Elf_(Word) *	result
	)

Definition at line 117 of file elf_misc.c.

                                                                                                                                       {
    rz_return_val_if_fail(bin && offset && result, false);
 
    return Elf_(rz_bin_elf_read_word)(bin, offset, result);
}

References Elf_, rz_bin_elf_read_word(), and rz_return_val_if_fail.

Referenced by get_phdr_entry(), get_shdr_entry_aux(), and read_reloc_entry_aux().

rz_bin_elf_read_xword()

bool Elf_() rz_bin_elf_read_xword	(	RZ_NONNULL ELFOBJ *	bin,
		RZ_NONNULL RZ_INOUT ut64 *	offset,
		RZ_NONNULL RZ_OUT Elf_(Xword) *	result
	)

Definition at line 72 of file elf_misc.c.

                                                                                                                                   {
    rz_return_val_if_fail(bin && offset && result, false);
    return rz_buf_read_ble64_offset(bin->b, offset, (ut64 *)result, bin->big_endian);
}

References rz_return_val_if_fail, and ut64().

Referenced by get_symbol_entry_aux().

rz_bin_elf_relocs_new()

RZ_OWN RzVector* Elf_() rz_bin_elf_relocs_new

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 202 of file elf_relocs.c.

                                                                     {
    rz_return_val_if_fail(bin, NULL);
 
    HtUU *set = ht_uu_new0();
    if (!set) {
        return NULL;
    }
 
    RzVector *result = rz_vector_new(sizeof(RzBinElfReloc), NULL, NULL);
    if (!result) {
        ht_uu_free(set);
        return NULL;
    }
 
    if (!get_relocs_entry_from_dt_dynamic(bin, result, set)) {
        rz_vector_free(result);
        ht_uu_free(set);
        return NULL;
    }
 
    if (!get_relocs_entry_from_sections(bin, result, set)) {
        rz_vector_free(result);
        ht_uu_free(set);
        return NULL;
    }
 
    if (!rz_vector_len(result)) {
        rz_vector_free(result);
        ht_uu_free(set);
        return NULL;
    }
 
    ht_uu_free(set);
 
    return result;
}

References get_relocs_entry_from_dt_dynamic(), get_relocs_entry_from_sections(), NULL, rz_return_val_if_fail, rz_vector_free(), rz_vector_len(), and rz_vector_new().

Referenced by init().

rz_bin_elf_section_flag_to_rzlist()

RZ_OWN RzList* Elf_() rz_bin_elf_section_flag_to_rzlist

(

ut64

flag

)

Return a list of string representing flag options.

Parameters

elf

flag

Returns

RzList of string representing flag options

Compare the flag to common option such as SHF_WRITE, SHF_ALLOC, ect

Definition at line 298 of file elf_sections.c.

                                                                  {
    RzList *flag_list = rz_list_new();
    if (!flag_list) {
        return NULL;
    }
 
    for (size_t i = 0; i < RZ_ARRAY_SIZE(flag_translation_table); i++) {
        if (flag & flag_translation_table[i].flag) {
            if (!rz_list_append(flag_list, flag_translation_table[i].name)) {
                rz_list_free(flag_list);
                return NULL;
            }
        }
    }
 
    return flag_list;
}

References flag_translation::flag, flag_translation_table, i, NULL, RZ_ARRAY_SIZE, rz_list_append(), rz_list_free(), and rz_list_new().

rz_bin_elf_section_type_to_string()

RZ_OWN char* Elf_() rz_bin_elf_section_type_to_string

(

ut64

type

)

Return a string representing the elf type.

Parameters

elf

type

Returns

allocated string

Compare the type SHT_NULL, SHT_PROGBITS, etc and return the string representation

Definition at line 422 of file elf_sections.c.

                                                                {
    for (size_t i = 0; i < RZ_ARRAY_SIZE(type_translation_table); i++) {
        if (type == type_translation_table[i].type) {
            return rz_str_new(type_translation_table[i].name);
        }
    }
 
    if (type >= SHT_LOPROC && type <= SHT_HIPROC) {
        return rz_str_newf("LOPROC+0x%08" PFMT64x, type - SHT_LOPROC);
    }
 
    if (type >= SHT_LOUSER && type <= SHT_HIUSER) {
        return rz_str_newf("LOUSER+0x%08" PFMT64x, type - SHT_LOUSER);
    }
 
    return rz_str_newf("0x%" PFMT64x, type);
}

References i, PFMT64x, RZ_ARRAY_SIZE, rz_str_new(), rz_str_newf(), SHT_HIPROC, SHT_HIUSER, SHT_LOPROC, SHT_LOUSER, type, and type_translation_table.

rz_bin_elf_sections_new()

RZ_OWN RzVector* Elf_() rz_bin_elf_sections_new

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 378 of file elf_sections.c.

                                                                       {
    rz_return_val_if_fail(bin, NULL);
 
    if (!bin->ehdr.e_shnum) {
        return NULL;
    }
 
    if (!Elf_(rz_bin_elf_check_array)(bin, bin->ehdr.e_shoff, bin->ehdr.e_shnum, sizeof(Elf_(Phdr)))) {
        RZ_LOG_WARN("Invalid section header (check array failed).\n");
        return NULL;
    }
 
    RzVector *result = rz_vector_new(sizeof(Elf_(Shdr)), NULL, NULL);
    if (!result) {
        return NULL;
    }
 
    ut64 offset = bin->ehdr.e_shoff;
 
    for (size_t i = 0; i < bin->ehdr.e_shnum; i++) {
        Elf_(Shdr) *section = rz_vector_push(result, NULL);
        if (!section) {
            rz_vector_free(result);
            return NULL;
        }
 
        if (!get_shdr_entry(bin, section, offset)) {
            rz_vector_free(result);
            return NULL;
        }
 
        offset += sizeof(Elf_(Shdr));
    }
 
    return result;
}

References Elf_, get_shdr_entry(), i, NULL, rz_bin_elf_check_array(), RZ_LOG_WARN, rz_return_val_if_fail, rz_vector_free(), rz_vector_new(), rz_vector_push(), and ut64().

Referenced by init().

rz_bin_elf_segments_new()

RZ_OWN RzVector* Elf_() rz_bin_elf_segments_new	(	RZ_NONNULL ELFOBJ *	bin,
		RzVector *	sections,
		RZ_NONNULL RzBinObjectLoadOptions *	options
	)

Definition at line 133 of file elf_segments.c.

                                                                                                                                       {
    rz_return_val_if_fail(bin && options, NULL);
 
    size_t count = get_number_of_segments(bin, sections);
    if (!count) {
        return NULL;
    }
 
    if (!Elf_(rz_bin_elf_check_array)(bin, bin->ehdr.e_phoff, count, sizeof(Elf_(Phdr)))) {
        RZ_LOG_WARN("Invalid program header (check array failed).\n");
        return NULL;
    }
 
    return get_segments_from_phdr(bin, count, options);
}

References count, Elf_, get_number_of_segments(), get_segments_from_phdr(), NULL, options, rz_bin_elf_check_array(), RZ_LOG_WARN, rz_return_val_if_fail, and sections().

Referenced by init_phdr_aux().

rz_bin_elf_strtab_free()

void Elf_() rz_bin_elf_strtab_free

(

RzBinElfStrtab *

ptr

)

Definition at line 72 of file elf_strtab.c.

                                                       {
    if (!ptr) {
        return;
    }
 
    free(ptr->data);
    free(ptr);
}

References free().

Referenced by get_section_elf_symbols(), rz_bin_elf_free(), and rz_bin_elf_strtab_new().

rz_bin_elf_strtab_get()

RZ_BORROW const char* Elf_() rz_bin_elf_strtab_get	(	RZ_NONNULL RzBinElfStrtab *	strtab,
		ut64	index
	)

Definition at line 8 of file elf_strtab.c.

                                                                                                 {
    rz_return_val_if_fail(strtab, false);
 
    if (!Elf_(rz_bin_elf_strtab_has_index)(strtab, index)) {
        return NULL;
    }
 
    return strtab->data + index;
}

References Elf_, NULL, rz_bin_elf_strtab_has_index(), and rz_return_val_if_fail.

Referenced by get_vernaux_entry_sdb(), get_verneed_entry_sdb_aux(), get_versym_entry_sdb_from_verdef(), and get_versym_entry_sdb_from_verneed().

rz_bin_elf_strtab_get_dup()

RZ_OWN char* Elf_() rz_bin_elf_strtab_get_dup	(	RZ_NONNULL RzBinElfStrtab *	strtab,
		ut64	index
	)

Definition at line 52 of file elf_strtab.c.

                                                                                            {
    rz_return_val_if_fail(strtab, NULL);
 
    if (!Elf_(rz_bin_elf_strtab_has_index)(strtab, index)) {
        return NULL;
    }
 
    char *result = strdup(strtab->data + index);
    if (!result) {
        return NULL;
    }
 
    return result;
}

References Elf_, NULL, rz_bin_elf_strtab_has_index(), rz_return_val_if_fail, and strdup().

Referenced by rz_bin_elf_get_libs(), rz_bin_elf_get_rpath(), set_elf_section_name(), and set_elf_symbol_name().

rz_bin_elf_strtab_has_index()

bool Elf_() rz_bin_elf_strtab_has_index	(	RZ_NONNULL RzBinElfStrtab *	strtab,
		ut64	index
	)

Definition at line 67 of file elf_strtab.c.

                                                                                      {
    rz_return_val_if_fail(strtab, false);
    return index < strtab->size;
}

References rz_return_val_if_fail.

Referenced by rz_bin_elf_strtab_get(), rz_bin_elf_strtab_get_dup(), and set_elf_section_name().

rz_bin_elf_strtab_new()

RZ_OWN RzBinElfStrtab* Elf_() rz_bin_elf_strtab_new	(	RZ_NONNULL ELFOBJ *	bin,
		ut64	offset,
		ut64	size
	)

Definition at line 18 of file elf_strtab.c.

                                                                                                   {
    rz_return_val_if_fail(bin, NULL);
 
    if (!size || !Elf_(rz_bin_elf_check_array)(bin, offset, size, sizeof(ut8))) {
        RZ_LOG_WARN("Invalid strtab at 0x%" PFMT64x " (check array failed).\n", offset);
        return NULL;
    }
 
    RzBinElfStrtab *result = RZ_NEW(RzBinElfStrtab);
    if (!result) {
        return NULL;
    }
 
    result->size = size;
    result->data = RZ_NEWS(char, size);
    if (!result->data) {
        Elf_(rz_bin_elf_strtab_free)(result);
        return NULL;
    }
 
    if (rz_buf_read_at(bin->b, offset, (ut8 *)result->data, size) < 0) {
        Elf_(rz_bin_elf_strtab_free)(result);
        return NULL;
    }
 
    if (result->data[0] != '\0' || result->data[size - 1] != '\0') {
        RZ_LOG_WARN("String table at 0x%" PFMT64x " should start and end by a NULL byte", offset);
        Elf_(rz_bin_elf_strtab_free)(result);
        return NULL;
    }
 
    return result;
}

References rz_bin_elf_strtab::data, Elf_, NULL, PFMT64x, rz_bin_elf_check_array(), rz_bin_elf_strtab_free(), rz_buf_read_at(), RZ_LOG_WARN, RZ_NEW, RZ_NEWS, rz_return_val_if_fail, and rz_bin_elf_strtab::size.

Referenced by get_section_elf_symbols(), init_dynstr_aux(), and init_shstrtab_aux().

rz_bin_elf_symbols_new()

RZ_OWN RzVector* Elf_() rz_bin_elf_symbols_new

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 523 of file elf_symbols.c.

                                                                      {
    rz_return_val_if_fail(bin, NULL);
 
    RzVector *result = Elf_(rz_bin_elf_compute_symbols)(bin, filter_symbol);
    if (!result) {
        return NULL;
    }
 
    return result;
}

References Elf_(), filter_symbol(), NULL, rz_bin_elf_compute_symbols(), and rz_return_val_if_fail.

Referenced by init().

rz_bin_elf_v2p()

ut64 Elf_() rz_bin_elf_v2p	(	RZ_NONNULL ELFOBJ *	bin,
		ut64	vaddr
	)

Convert a virtual address to the physical address.

Parameters

elf

binary

Returns

virtual addr

Converts a virtual address to the relative physical address, looking at the program headers in the binary bin

Definition at line 429 of file elf.c.

                                                              {
    rz_return_val_if_fail(bin, UT64_MAX);
 
    if (!Elf_(rz_bin_elf_has_segments)(bin)) {
        if (Elf_(rz_bin_elf_is_relocatable)(bin) && vaddr > bin->baddr) {
            return vaddr - bin->baddr;
        }
 
        return UT64_MAX;
    }
 
    RzBinElfSegment *segment;
    rz_bin_elf_foreach_segments(bin, segment) {
        if (segment->data.p_type == PT_LOAD && in_virtual_phdr(segment, vaddr)) {
            return segment->data.p_offset + vaddr - segment->data.p_vaddr;
        }
    }
 
    return UT64_MAX;
}

References Elf_, in_virtual_phdr(), PT_LOAD, rz_bin_elf_foreach_segments, rz_bin_elf_has_segments(), rz_bin_elf_is_relocatable(), rz_return_val_if_fail, RzBinElfSegment, and UT64_MAX.

Referenced by convert_elf_symbol_entry(), convert_elf_symbol_to_elf_import(), create_section_from_phdr(), Elf_(), fix_rva_and_offset_exec_file(), get_dynamic_elf_symbols(), get_gnu_verneed(), get_gnu_versym(), get_import_addr_mips(), get_import_addr_ppc(), get_import_addr_x86_manual(), get_main_offset_arm64(), get_main_offset_arm_glibc_non_thumb(), get_main_offset_arm_glibc_thumb(), get_main_offset_linux_64_pie(), get_main_offset_mips(), get_main_offset_x86_gcc(), get_main_offset_x86_non_pie(), get_relocs_entry_from_dt_dynamic_aux(), get_versym_entry_sdb_from_verdef(), get_versym_entry_sdb_from_verneed(), init_dt_dynamic(), init_dynstr_aux(), rz_bin_elf_get_entry_offset(), rz_bin_elf_get_fini_offset(), rz_bin_elf_get_gnu_hash_table(), rz_bin_elf_get_hash_table(), and rz_bin_elf_get_init_offset().

Variable Documentation

RzBinElfNote

RzBinElfNote

Definition at line 182 of file elf.h.

Referenced by note_free(), parse_note_file(), parse_note_prstatus(), rz_bin_elf_get_sp_val(), and rz_bin_elf_notes_new().

RzBinElfNoteFile

RzBinElfNoteFile

Definition at line 165 of file elf.h.

RzBinElfSegment

RzBinElfSegment

Definition at line 131 of file elf.h.

Referenced by compute_baddr_from_phdr(), compute_boffset_from_phdr(), elf_has_gnu_relro(), get_segments_from_phdr(), get_targets_map_base_from_segments(), init_dt_dynamic(), rz_bin_elf_get_intrp(), rz_bin_elf_get_segment_with_type(), rz_bin_elf_has_nx(), rz_bin_elf_is_static(), rz_bin_elf_notes_new(), rz_bin_elf_p2v(), and rz_bin_elf_v2p().