elf_symbols.c File Reference

#include "elf.h"
#include <ht_uu.h>

Go to the source code of this file.

Classes
struct	symbols_segment
struct	symbol_bind_translation
struct	symbol_type_translation

Macros
#define	HASH_NCHAIN_OFFSET(x)   ((x) + 4)

Functions
static struct symbols_segment	symbols_segment_init (ut64 offset, ut64 number, ut64 entry_size, bool dynamic, RzBinElfStrtab *strtab)
static	Elf_ (Word)
static bool	is_special_arm_symbol (ELFOBJ *bin, Elf_(Sym) *sym, const char *name)
static bool	is_special_symbol (ELFOBJ *bin, Elf_(Sym) *sym, const char *name)
static const char *	symbol_type_to_str (ELFOBJ *bin, RzBinElfSymbol *ret, Elf_(Sym) *sym)
static const char *	symbol_bind_to_str (Elf_(Sym) *sym)
static bool	get_symbol_entry_aux (ELFOBJ *bin, ut64 offset, Elf_(Sym) *result)
static bool	get_symbol_entry (ELFOBJ *bin, ut64 offset, Elf_(Sym) *result)
static bool	is_section_local_symbol (ELFOBJ *bin, Elf_(Sym) *symbol)
static bool	set_elf_symbol_name (ELFOBJ *bin, struct symbols_segment *segment, RzBinElfSymbol *elf_symbol, Elf_(Sym) *symbol, RzBinElfSection *section)
static bool	convert_elf_symbol_entry (ELFOBJ *bin, struct symbols_segment *segment, RzBinElfSymbol *elf_symbol, Elf_(Sym) *symbol, size_t ordinal)
static bool	has_already_been_processed (ELFOBJ *bin, ut64 offset, HtUU *set)
static void	elf_symbol_fini (void *e, RZ_UNUSED void *user)
static bool	compute_symbols_from_segment (ELFOBJ *bin, RzVector *result, struct symbols_segment *segment, RzBinElfSymbolFilter filter, HtUU *set)
static bool	get_dynamic_elf_symbols (ELFOBJ *bin, RzVector *result, RzBinElfSymbolFilter filter, HtUU *set)
static bool	get_section_elf_symbols (ELFOBJ *bin, RzVector *result, RzBinElfSymbolFilter filter, HtUU *set)
static bool	get_gnu_debugdata_elf_symbols (ELFOBJ *bin, RzVector *result, RzBinElfSymbolFilter filter, HtUU *set)
static bool	filter_symbol (RZ_UNUSED ELFOBJ *bin, Elf_(Sym) *symbol, RZ_UNUSED bool is_dynamic)
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
static struct symbol_bind_translation	symbol_bind_translation_table []
static const struct symbol_type_translation	symbol_type_translation_table []

Macro Definition Documentation

HASH_NCHAIN_OFFSET

#define HASH_NCHAIN_OFFSET

(

x

)

((x) + 4)

Definition at line 10 of file elf_symbols.c.

Function Documentation

compute_symbols_from_segment()

static bool compute_symbols_from_segment ( ELFOBJ *  bin, RzVector *  result, struct symbols_segment *  segment, RzBinElfSymbolFilter  filter, HtUU *  set  )

static

Definition at line 255 of file elf_symbols.c.

                                                                                                                                                 {
    ut64 offset = segment->offset + segment->entry_size;
 
    for (size_t i = 1; i < segment->number; i++) {
        if (has_already_been_processed(bin, offset, set)) {
            offset += segment->entry_size;
            continue;
        }
 
        if (!ht_uu_insert(set, offset, offset)) {
            return false;
        }
 
        Elf_(Sym) entry;
        if (!get_symbol_entry(bin, offset, &entry)) {
            return false;
        }
 
        if (!filter(bin, &entry, segment->dynamic)) {
            offset += segment->entry_size;
            continue;
        }
 
        RzBinElfSymbol symbol = { 0 };
 
        if (!convert_elf_symbol_entry(bin, segment, &symbol, &entry, i)) {
            return false;
        }
 
        if (!rz_vector_push(result, &symbol)) {
            elf_symbol_fini(&symbol, NULL);
            return false;
        }
 
        offset += segment->entry_size;
    }
 
    return true;
}

References convert_elf_symbol_entry(), symbols_segment::dynamic, Elf_(), elf_symbol_fini(), symbols_segment::entry_size, filter(), get_symbol_entry(), has_already_been_processed(), i, NULL, symbols_segment::number, symbols_segment::offset, rz_vector_push(), and ut64().

Referenced by get_dynamic_elf_symbols(), and get_section_elf_symbols().

convert_elf_symbol_entry()

static bool convert_elf_symbol_entry ( ELFOBJ *  bin, struct symbols_segment *  segment, RzBinElfSymbol *  elf_symbol, Elf_(Sym) *  symbol, size_t  ordinal  )

static

Definition at line 215 of file elf_symbols.c.

                                                                                                                                                   {
    RzBinElfSection *section = Elf_(rz_bin_elf_get_section)(bin, symbol->st_shndx);
 
    elf_symbol->bind = symbol_bind_to_str(symbol);
    elf_symbol->ordinal = ordinal;
    elf_symbol->size = symbol->st_size;
 
    if (symbol->st_size == 0 && symbol->st_shndx == SHN_UNDEF && symbol->st_value == 0) {
        elf_symbol->paddr = elf_symbol->vaddr = UT64_MAX;
    } else {
        if (Elf_(rz_bin_elf_is_relocatable)(bin) && section) {
            elf_symbol->paddr = section->offset + symbol->st_value;
            elf_symbol->vaddr = Elf_(rz_bin_elf_p2v)(bin, elf_symbol->paddr);
        } else {
            elf_symbol->vaddr = symbol->st_value;
            elf_symbol->paddr = Elf_(rz_bin_elf_v2p)(bin, elf_symbol->vaddr);
        }
    }
 
    if (!set_elf_symbol_name(bin, segment, elf_symbol, symbol, section)) {
        return false;
    }
 
    elf_symbol->type = symbol_type_to_str(bin, elf_symbol, symbol);
 
    return true;
}

References rz_bin_elf_symbol_t::bind, Elf_(), section::offset, rz_bin_elf_symbol_t::ordinal, rz_bin_elf_symbol_t::paddr, rz_bin_elf_get_section(), rz_bin_elf_is_relocatable(), rz_bin_elf_p2v(), rz_bin_elf_v2p(), set_elf_symbol_name(), SHN_UNDEF, rz_bin_elf_symbol_t::size, symbol_bind_to_str(), symbol_type_to_str(), rz_bin_elf_symbol_t::type, UT64_MAX, and rz_bin_elf_symbol_t::vaddr.

Referenced by compute_symbols_from_segment().

Elf_()

static Elf_ ( Word  )

static

Definition at line 66 of file elf_symbols.c.

                                                                                                                {
    if (symtab_offset > strtab_offset) {
        return 0;
    }
 
    ut64 symtab_size = strtab_offset - symtab_offset;
    return symtab_size / sizeof(Elf_(Sym));
}

References ut64().

Referenced by compute_symbols_from_segment(), convert_elf_symbol_entry(), Elf_(), get_dynamic_elf_symbols(), get_gnu_debugdata_elf_symbols(), get_section_elf_symbols(), get_symbol_entry_aux(), rz_bin_elf_symbols_new(), and set_elf_symbol_name().

elf_symbol_fini()

static void elf_symbol_fini ( void *  e, RZ_UNUSED void *  user  )

static

Definition at line 250 of file elf_symbols.c.

                                                           {
    RzBinElfSymbol *ptr = e;
    free(ptr->name);
}

References e, free(), and rz_bin_elf_symbol_t::name.

Referenced by compute_symbols_from_segment(), and rz_bin_elf_compute_symbols().

filter_symbol()

static bool filter_symbol ( RZ_UNUSED ELFOBJ *  bin, Elf_(Sym) *  symbol, RZ_UNUSED bool  is_dynamic  )

static

Definition at line 439 of file elf_symbols.c.

                                                                                                {
    return symbol->st_shndx != SHT_NULL;
}

References SHT_NULL.

Referenced by rz_bin_elf_symbols_new().

get_dynamic_elf_symbols()

static bool get_dynamic_elf_symbols ( ELFOBJ *  bin, RzVector *  result, RzBinElfSymbolFilter  filter, HtUU *  set  )

static

Definition at line 295 of file elf_symbols.c.

                                                                                                           {
    if (!Elf_(rz_bin_elf_is_executable)(bin)) {
        return true;
    }
 
    ut64 addr;
    ut64 entry_size;
    if (!Elf_(rz_bin_elf_get_dt_info)(bin, DT_SYMTAB, &addr) || !Elf_(rz_bin_elf_get_dt_info)(bin, DT_SYMENT, &entry_size)) {
        return true;
    }
 
    ut64 offset = Elf_(rz_bin_elf_v2p)(bin, addr);
    if (offset == UT64_MAX) {
        return true;
    }
 
    Elf_(Word) number = Elf_(rz_bin_elf_get_number_of_dynamic_symbols)(bin);
    if (!number) {
        return true;
    }
 
    struct symbols_segment segment = symbols_segment_init(offset, number, entry_size, true, bin->dynstr);
 
    if (!compute_symbols_from_segment(bin, result, &segment, filter, set)) {
        return false;
    }
 
    return true;
}

References addr, compute_symbols_from_segment(), DT_SYMENT, DT_SYMTAB, Elf_(), symbols_segment::entry_size, symbols_segment::number, rz_bin_elf_get_dt_info(), rz_bin_elf_is_executable(), rz_bin_elf_v2p(), symbols_segment_init(), ut64(), and UT64_MAX.

Referenced by rz_bin_elf_compute_symbols().

get_gnu_debugdata_elf_symbols()

static bool get_gnu_debugdata_elf_symbols ( ELFOBJ *  bin, RzVector *  result, RzBinElfSymbolFilter  filter, HtUU *  set  )

static

Definition at line 367 of file elf_symbols.c.

                                                                                                                 {
    // Get symbols from .gnu_debugdata according to https://sourceware.org/gdb/onlinedocs/gdb/MiniDebugInfo.html
    bool res = false;
    const RzBinElfSection *gnu_debugdata = Elf_(rz_bin_elf_get_section_with_name)(bin, ".gnu_debugdata");
    if (!gnu_debugdata) {
        return false;
    }
 
    RzBuffer *data_buf = rz_buf_new_slice(bin->b, gnu_debugdata->offset, gnu_debugdata->size);
    if (!data_buf) {
        return false;
    }
 
    RzBuffer *dec_buf = rz_buf_new_empty(0);
    if (!dec_buf) {
        goto data_buf_err;
    }
 
    if (!rz_lzma_dec_buf(data_buf, dec_buf, 1 << 13, NULL)) {
        goto dec_buf_err;
    }
 
    RzBinObjectLoadOptions obj_opts = {
        .baseaddr = UT64_MAX,
        .loadaddr = 0,
        .elf_load_sections = true,
    };
    ELFOBJ *debug_data_bin = Elf_(rz_bin_elf_new_buf)(dec_buf, &obj_opts);
    if (!debug_data_bin) {
        goto dec_buf_err;
    }
 
    RzVector *debug_symbols = Elf_(rz_bin_elf_compute_symbols)(debug_data_bin, filter);
    if (!debug_symbols) {
        goto debug_data_err;
    }
 
    HtPP *name_set = ht_pp_new0();
    if (!name_set) {
        goto debug_symbols_err;
    }
 
    RzBinElfSymbol *sym;
    rz_vector_foreach(result, sym) {
        ht_pp_insert(name_set, sym->name, sym);
    }
 
    rz_vector_foreach(debug_symbols, sym) {
        bool found;
        ht_pp_find(name_set, sym->name, &found);
        if (found) {
            continue;
        }
 
        rz_vector_push(result, sym);
    }
    // The ownership has been moved to `result`, no need to free the elements.
    debug_symbols->len = 0;
    res = true;
 
    ht_pp_free(name_set);
debug_symbols_err:
    rz_vector_free(debug_symbols);
debug_data_err:
    Elf_(rz_bin_elf_free)(debug_data_bin);
dec_buf_err:
    rz_buf_free(dec_buf);
data_buf_err:
    rz_buf_free(data_buf);
    return res;
}

References rz_bin_file_load_options_t::baseaddr, Elf_(), ELFOBJ, filter(), found, rz_vector_t::len, rz_bin_elf_symbol_t::name, NULL, rz_bin_elf_section_t::offset, rz_bin_elf_compute_symbols(), rz_bin_elf_free(), rz_bin_elf_get_section_with_name(), rz_bin_elf_new_buf(), rz_buf_free(), rz_buf_new_empty(), rz_buf_new_slice(), rz_lzma_dec_buf(), rz_vector_foreach, rz_vector_free(), rz_vector_push(), rz_bin_elf_section_t::size, and UT64_MAX.

Referenced by rz_bin_elf_compute_symbols().

get_section_elf_symbols()

static bool get_section_elf_symbols ( ELFOBJ *  bin, RzVector *  result, RzBinElfSymbolFilter  filter, HtUU *  set  )

static

Definition at line 325 of file elf_symbols.c.

                                                                                                           {
    size_t i;
    RzBinElfSection *section;
    rz_bin_elf_enumerate_sections(bin, section, i) {
        if (!section->is_valid) {
            continue;
        }
 
        if (section->type != SHT_SYMTAB && section->type != SHT_DYNSYM) {
            continue;
        }
 
        if (!section->link) {
            RZ_LOG_WARN("The section %zu has a null link.\n", i);
            continue;
        }
 
        RzBinElfSection *strtab_section = Elf_(rz_bin_elf_get_section)(bin, section->link);
        if (!strtab_section) {
            continue;
        }
 
        RzBinElfStrtab *strtab = Elf_(rz_bin_elf_strtab_new)(bin, strtab_section->offset, strtab_section->size);
        if (!strtab) {
            continue;
        }
 
        ut64 number = (section->size / sizeof(Elf_(Sym)));
 
        struct symbols_segment segment = symbols_segment_init(section->offset, number, sizeof(Elf_(Sym)), false, strtab);
 
        if (!compute_symbols_from_segment(bin, result, &segment, filter, set)) {
            Elf_(rz_bin_elf_strtab_free)(strtab);
            return false;
        }
 
        Elf_(rz_bin_elf_strtab_free)(strtab);
    }
 
    return true;
}

References compute_symbols_from_segment(), Elf_(), i, symbols_segment::number, rz_bin_elf_section_t::offset, section::offset, rz_bin_elf_enumerate_sections, rz_bin_elf_get_section(), rz_bin_elf_strtab_free(), rz_bin_elf_strtab_new(), RZ_LOG_WARN, SHT_DYNSYM, SHT_SYMTAB, rz_bin_elf_section_t::size, section::size, symbols_segment::strtab, symbols_segment_init(), and ut64().

Referenced by rz_bin_elf_compute_symbols().

get_symbol_entry()

static bool get_symbol_entry ( ELFOBJ *  bin, ut64  offset, Elf_(Sym) *  result  )

static

Definition at line 171 of file elf_symbols.c.

                                                                           {
    if (!get_symbol_entry_aux(bin, offset, result)) {
        RZ_LOG_WARN("Failed to read symbol entry at 0x%" PFMT64x ".\n", offset);
        return false;
    }
 
    return true;
}

References get_symbol_entry_aux(), PFMT64x, and RZ_LOG_WARN.

Referenced by compute_symbols_from_segment().

get_symbol_entry_aux()

static bool get_symbol_entry_aux ( ELFOBJ *  bin, ut64  offset, Elf_(Sym) *  result  )

static

Definition at line 153 of file elf_symbols.c.

                                                                               {
#if RZ_BIN_ELF64
    return Elf_(rz_bin_elf_read_word)(bin, &offset, &result->st_name) &&
        Elf_(rz_bin_elf_read_char)(bin, &offset, &result->st_info) &&
        Elf_(rz_bin_elf_read_char)(bin, &offset, &result->st_other) &&
        Elf_(rz_bin_elf_read_section)(bin, &offset, &result->st_shndx) &&
        Elf_(rz_bin_elf_read_addr)(bin, &offset, &result->st_value) &&
        Elf_(rz_bin_elf_read_xword)(bin, &offset, &result->st_size);
#else
    return Elf_(rz_bin_elf_read_word)(bin, &offset, &result->st_name) &&
        Elf_(rz_bin_elf_read_addr)(bin, &offset, &result->st_value) &&
        Elf_(rz_bin_elf_read_word)(bin, &offset, &result->st_size) &&
        Elf_(rz_bin_elf_read_char)(bin, &offset, &result->st_info) &&
        Elf_(rz_bin_elf_read_char)(bin, &offset, &result->st_other) &&
        Elf_(rz_bin_elf_read_section)(bin, &offset, &result->st_shndx);
#endif
}

References Elf_(), rz_bin_elf_read_addr(), rz_bin_elf_read_char(), rz_bin_elf_read_section(), rz_bin_elf_read_word(), and rz_bin_elf_read_xword().

Referenced by get_symbol_entry().

has_already_been_processed()

static bool has_already_been_processed ( ELFOBJ *  bin, ut64  offset, HtUU *  set  )

static

Definition at line 243 of file elf_symbols.c.

                                                                            {
    bool found;
    ht_uu_find(set, offset, &found);
 
    return found;
}

References found.

Referenced by compute_symbols_from_segment().

is_section_local_symbol()

static bool is_section_local_symbol ( ELFOBJ *  bin, Elf_(Sym) *  symbol  )

static

Definition at line 180 of file elf_symbols.c.

                                                                     {
    if (symbol->st_name != 0) {
        return false;
    }
    if (ELF_ST_TYPE(symbol->st_info) != STT_SECTION) {
        return false;
    }
    if (ELF_ST_BIND(symbol->st_info) != STB_LOCAL) {
        return false;
    }
    if (symbol->st_shndx >= bin->ehdr.e_shnum) {
        return false;
    }
 
    return true;
}

References ELF_ST_BIND, ELF_ST_TYPE, STB_LOCAL, and STT_SECTION.

Referenced by set_elf_symbol_name().

is_special_arm_symbol()

static bool is_special_arm_symbol ( ELFOBJ *  bin, Elf_(Sym) *  sym, const char *  name  )

static

Definition at line 100 of file elf_symbols.c.

                                                                                  {
    if (!name) {
        return false;
    }
 
    if (name[0] != '$') {
        return false;
    }
 
    if (name[1] == 'a' || name[1] == 't' || name[1] == 'd' || name[1] == 'x') {
        return (name[2] == '\0' || name[2] == '.') &&
            ELF_ST_TYPE(sym->st_info) == STT_NOTYPE &&
            ELF_ST_BIND(sym->st_info) == STB_LOCAL &&
            ELF_ST_VISIBILITY(sym->st_info) == STV_DEFAULT;
    }
 
    return false;
}

References ELF_ST_BIND, ELF_ST_TYPE, ELF_ST_VISIBILITY, STB_LOCAL, STT_NOTYPE, and STV_DEFAULT.

Referenced by is_special_symbol().

is_special_symbol()

static bool is_special_symbol ( ELFOBJ *  bin, Elf_(Sym) *  sym, const char *  name  )

static

Definition at line 119 of file elf_symbols.c.

                                                                              {
    switch (bin->ehdr.e_machine) {
    case EM_ARM:
    case EM_AARCH64:
        return is_special_arm_symbol(bin, sym, name);
    default:
        return false;
    }
}

References EM_AARCH64, EM_ARM, and is_special_arm_symbol().

Referenced by symbol_type_to_str().

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_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_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_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().

set_elf_symbol_name()

static bool set_elf_symbol_name ( ELFOBJ *  bin, struct symbols_segment *  segment, RzBinElfSymbol *  elf_symbol, Elf_(Sym) *  symbol, RzBinElfSection *  section  )

static

Definition at line 197 of file elf_symbols.c.

                                                                                                                                                        {
    if (section && is_section_local_symbol(bin, symbol)) {
        elf_symbol->name = rz_str_new(section->name);
        return elf_symbol->name;
    }
 
    if (!segment->strtab) {
        return false;
    }
 
    elf_symbol->name = Elf_(rz_bin_elf_strtab_get_dup)(segment->strtab, symbol->st_name);
    if (!elf_symbol->name) {
        return false;
    }
 
    return true;
}

References Elf_(), is_section_local_symbol(), rz_bin_elf_symbol_t::name, rz_bin_elf_strtab_get_dup(), rz_str_new(), and symbols_segment::strtab.

Referenced by convert_elf_symbol_entry().

symbol_bind_to_str()

static const char* symbol_bind_to_str ( Elf_(Sym) *  sym )

static

Definition at line 143 of file elf_symbols.c.

                                                       {
    for (size_t i = 0; i < RZ_ARRAY_SIZE(symbol_bind_translation_table); i++) {
        if (ELF_ST_BIND(sym->st_info) == symbol_bind_translation_table[i].bind) {
            return symbol_bind_translation_table[i].name;
        }
    }
 
    return RZ_BIN_BIND_UNKNOWN_STR;
}

References symbol_bind_translation::bind, ELF_ST_BIND, i, symbol_bind_translation::name, RZ_ARRAY_SIZE, RZ_BIN_BIND_UNKNOWN_STR, and symbol_bind_translation_table.

Referenced by convert_elf_symbol_entry().

symbol_type_to_str()

static const char* symbol_type_to_str ( ELFOBJ *  bin, RzBinElfSymbol *  ret, Elf_(Sym) *  sym  )

static

Definition at line 129 of file elf_symbols.c.

                                                                                         {
    if (bin && ret && is_special_symbol(bin, sym, ret->name)) {
        return RZ_BIN_TYPE_SPECIAL_SYM_STR;
    }
 
    for (size_t i = 0; i < RZ_ARRAY_SIZE(symbol_type_translation_table); i++) {
        if (ELF_ST_TYPE(sym->st_info) == symbol_type_translation_table[i].type) {
            return symbol_type_translation_table[i].name;
        }
    }
 
    return RZ_BIN_TYPE_UNKNOWN_STR;
}

References ELF_ST_TYPE, i, is_special_symbol(), rz_bin_elf_symbol_t::name, symbol_type_translation::name, RZ_ARRAY_SIZE, RZ_BIN_TYPE_SPECIAL_SYM_STR, RZ_BIN_TYPE_UNKNOWN_STR, symbol_type_translation_table, and symbol_type_translation::type.

Referenced by convert_elf_symbol_entry().

symbols_segment_init()

static struct symbols_segment symbols_segment_init ( ut64  offset, ut64  number, ut64  entry_size, bool  dynamic, RzBinElfStrtab *  strtab  )

static

Definition at line 1 of file elf_symbols.c.

                                                                                                                                    {
    return (struct symbols_segment){
        .offset = offset,
        .number = number,
        .entry_size = entry_size,
        .dynamic = dynamic,
        .strtab = strtab
    };
}

Referenced by get_dynamic_elf_symbols(), and get_section_elf_symbols().

Variable Documentation

symbol_bind_translation_table

struct symbol_bind_translation symbol_bind_translation_table[]

static

Initial value:

= {
    { STB_LOCAL, RZ_BIN_BIND_LOCAL_STR },
    { STB_GLOBAL, RZ_BIN_BIND_GLOBAL_STR },
    { STB_WEAK, RZ_BIN_BIND_WEAK_STR },
    { STB_NUM, RZ_BIN_BIND_NUM_STR },
    { STB_LOOS, RZ_BIN_BIND_LOOS_STR },
    { STB_HIOS, RZ_BIN_BIND_HIOS_STR },
    { STB_LOPROC, RZ_BIN_BIND_LOPROC_STR },
    { STB_HIPROC, RZ_BIN_BIND_HIPROC_STR }
}

Definition at line 1 of file elf_symbols.c.

Referenced by symbol_bind_to_str().

symbol_type_translation_table

const struct symbol_type_translation symbol_type_translation_table[]

static

Initial value:

= {
    { STT_NOTYPE, RZ_BIN_TYPE_NOTYPE_STR },
    { STT_OBJECT, RZ_BIN_TYPE_OBJECT_STR },
    { STT_FUNC, RZ_BIN_TYPE_FUNC_STR },
    { STT_SECTION, RZ_BIN_TYPE_SECTION_STR },
    { STT_FILE, RZ_BIN_TYPE_FILE_STR },
    { STT_COMMON, RZ_BIN_TYPE_COMMON_STR },
    { STT_TLS, RZ_BIN_TYPE_TLS_STR },
    { STT_NUM, RZ_BIN_TYPE_NUM_STR },
    { STT_LOOS, RZ_BIN_TYPE_LOOS_STR },
    { STT_HIOS, RZ_BIN_TYPE_HIOS_STR },
    { STT_LOPROC, RZ_BIN_TYPE_LOPROC_STR },
    { STT_HIPROC, RZ_BIN_TYPE_HIPROC_STR }
}

Definition at line 1 of file elf_symbols.c.

Referenced by symbol_type_to_str().