bin_coff.c File Reference

#include <rz_types.h>
#include <rz_util.h>
#include <rz_lib.h>
#include <rz_bin.h>
#include <ht_uu.h>
#include "coff/coff.h"

Go to the source code of this file.

Macros
#define	VFILE_NAME_RELOC_TARGETS   "reloc-targets"
#define	VFILE_NAME_PATCHED   "patched"
#define	DTYPE_IS_FUNCTION(type)   (COFF_SYM_GET_DTYPE(type) == COFF_SYM_DTYPE_FUNCTION)

Functions
static void	populate_symbols (RzBinFile *bf)
static Sdb *	get_sdb (RzBinFile *bf)
static bool	rz_coff_is_stripped (struct rz_bin_coff_obj *obj)
static bool	load_buffer (RzBinFile *bf, RzBinObject *obj, RzBuffer *buf, Sdb *sdb)
static void	destroy (RzBinFile *bf)
static ut64	baddr (RzBinFile *bf)
static RzBinAddr *	binsym (RzBinFile *bf, RzBinSpecialSymbol sym)
static bool	is_imported_symbol (struct coff_symbol *s)
static bool	_fill_bin_symbol (RzBin *rbin, struct rz_bin_coff_obj *bin, int idx, RzBinSymbol **sym)
static RzBinImport *	_fill_bin_import (struct rz_bin_coff_obj *bin, int idx)
static RzList *	entries (RzBinFile *bf)
static RzList *	virtual_files (RzBinFile *bf)
static RzList *	maps (RzBinFile *bf)
static RzList *	sections (RzBinFile *bf)
static void	populate_imports (struct rz_bin_coff_obj *obj)
static RzList *	symbols (RzBinFile *bf)
static RzList *	imports (RzBinFile *bf)
static RzList *	libs (RzBinFile *bf)
static RzList *	relocs (RzBinFile *bf)
static RzBinInfo *	info (RzBinFile *bf)
static RzList *	fields (RzBinFile *bf)
static ut64	size (RzBinFile *bf)
static bool	check_buffer (RzBuffer *buf)

Variables
RzBinPlugin	rz_bin_plugin_coff
RZ_API RzLibStruct	rizin_plugin

Macro Definition Documentation

DTYPE_IS_FUNCTION

#define DTYPE_IS_FUNCTION

(

type

)

(COFF_SYM_GET_DTYPE(type) == COFF_SYM_DTYPE_FUNCTION)

Definition at line 51 of file bin_coff.c.

VFILE_NAME_PATCHED

#define VFILE_NAME_PATCHED   "patched"

Definition at line 14 of file bin_coff.c.

VFILE_NAME_RELOC_TARGETS

#define VFILE_NAME_RELOC_TARGETS   "reloc-targets"

Definition at line 13 of file bin_coff.c.

Function Documentation

_fill_bin_import()

static RzBinImport* _fill_bin_import ( struct rz_bin_coff_obj *  bin, int  idx  )

static

Definition at line 146 of file bin_coff.c.

                                                                           {
    RzBinImport *ptr = RZ_NEW0(RzBinImport);
    if (!ptr || idx < 0 || idx > bin->hdr.f_nsyms) {
        free(ptr);
        return NULL;
    }
    struct coff_symbol *s = &bin->symbols[idx];
    if (!is_imported_symbol(s)) {
        free(ptr);
        return NULL;
    }
    char *coffname = rz_coff_symbol_name(bin, s);
    if (!coffname) {
        free(ptr);
        return NULL;
    }
    ptr->name = coffname;
    ptr->bind = "NONE";
    ptr->type = DTYPE_IS_FUNCTION(s->n_type)
        ? RZ_BIN_TYPE_FUNC_STR
        : RZ_BIN_TYPE_UNKNOWN_STR;
    return ptr;
}

References rz_bin_import_t::bind, DTYPE_IS_FUNCTION, free(), setup::idx, is_imported_symbol(), rz_bin_import_t::name, NULL, RZ_BIN_TYPE_FUNC_STR, RZ_BIN_TYPE_UNKNOWN_STR, rz_coff_symbol_name(), RZ_NEW0, s, and rz_bin_import_t::type.

Referenced by populate_imports().

_fill_bin_symbol()

static bool _fill_bin_symbol ( RzBin *  rbin, struct rz_bin_coff_obj *  bin, int  idx, RzBinSymbol **  sym  )

static

Definition at line 57 of file bin_coff.c.

                                                                                                   {
    RzBinSymbol *ptr = *sym;
    struct coff_symbol *s = NULL;
    struct coff_scn_hdr *sc_hdr = NULL;
    if (idx < 0 || idx > bin->hdr.f_nsyms) {
        return false;
    }
    if (!bin->symbols) {
        return false;
    }
    s = &bin->symbols[idx];
    char *coffname = rz_coff_symbol_name(bin, s);
    if (!coffname) {
        return false;
    }
    ptr->size = 4;
    ptr->ordinal = 0;
    ptr->name = coffname;
    ptr->forwarder = "NONE";
    ptr->bind = RZ_BIN_BIND_LOCAL_STR;
    ptr->is_imported = is_imported_symbol(s);
    ptr->vaddr = UT64_MAX;
    if (s->n_scnum < bin->hdr.f_nscns + 1 && s->n_scnum > 0) {
        // first index is 0 that is why -1
        sc_hdr = &bin->scn_hdrs[s->n_scnum - 1];
        ptr->paddr = sc_hdr->s_scnptr + s->n_value;
        if (bin->scn_va) {
            ptr->vaddr = bin->scn_va[s->n_scnum - 1] + s->n_value;
        }
    }
    if (ptr->is_imported) {
        // if the symbol is an import and it will be assigned an artificial target,
        // assign this target as the vaddr of the symbol.
        bool found;
        ut64 imp_idx = ht_uu_find(bin->imp_index, idx, &found);
        if (found) {
            ptr->vaddr = rz_coff_import_index_addr(bin, imp_idx);
        }
    }
 
    switch (s->n_sclass) {
    case COFF_SYM_CLASS_FUNCTION:
        ptr->type = RZ_BIN_TYPE_FUNC_STR;
        break;
    case COFF_SYM_CLASS_FILE:
        ptr->type = RZ_BIN_TYPE_FILE_STR;
        break;
    case COFF_SYM_CLASS_SECTION:
        ptr->type = RZ_BIN_TYPE_SECTION_STR;
        break;
    case COFF_SYM_CLASS_EXTERNAL:
        if (s->n_scnum == COFF_SYM_SCNUM_UNDEF) {
            ptr->paddr = UT64_MAX;
            ptr->bind = "NONE";
        } else {
            ptr->bind = RZ_BIN_BIND_GLOBAL_STR;
        }
        ptr->type = (DTYPE_IS_FUNCTION(s->n_type) || !strcmp(coffname, "main"))
            ? RZ_BIN_TYPE_FUNC_STR
            : RZ_BIN_TYPE_UNKNOWN_STR;
        break;
    case COFF_SYM_CLASS_STATIC:
        if (s->n_scnum == COFF_SYM_SCNUM_ABS) {
            ptr->type = "ABS";
            ptr->paddr = UT64_MAX;
            char *newname = rz_str_newf("%s-0x%08x", coffname, s->n_value);
            if (newname) {
                free(ptr->name);
                ptr->name = newname;
            }
        } else if (sc_hdr && !memcmp(sc_hdr->s_name, s->n_name, 8)) {
            ptr->type = RZ_BIN_TYPE_SECTION_STR;
        } else {
            ptr->type = DTYPE_IS_FUNCTION(s->n_type)
                ? RZ_BIN_TYPE_FUNC_STR
                : RZ_BIN_TYPE_UNKNOWN_STR;
        }
        break;
    case COFF_SYM_CLASS_LABEL:
        ptr->type = "LABEL";
        ptr->size = 0;
        break;
    default:
        ptr->type = rz_str_constpool_get(&rbin->constpool, sdb_fmt("%i", s->n_sclass));
        break;
    }
    return true;
}

References rz_bin_symbol_t::bind, COFF_SYM_CLASS_EXTERNAL, COFF_SYM_CLASS_FILE, COFF_SYM_CLASS_FUNCTION, COFF_SYM_CLASS_LABEL, COFF_SYM_CLASS_SECTION, COFF_SYM_CLASS_STATIC, COFF_SYM_SCNUM_ABS, COFF_SYM_SCNUM_UNDEF, rz_bin_t::constpool, DTYPE_IS_FUNCTION, rz_bin_symbol_t::forwarder, found, free(), setup::idx, rz_bin_symbol_t::is_imported, is_imported_symbol(), rz_bin_symbol_t::name, NULL, rz_bin_symbol_t::ordinal, rz_bin_symbol_t::paddr, RZ_BIN_BIND_GLOBAL_STR, RZ_BIN_BIND_LOCAL_STR, RZ_BIN_TYPE_FILE_STR, RZ_BIN_TYPE_FUNC_STR, RZ_BIN_TYPE_SECTION_STR, RZ_BIN_TYPE_UNKNOWN_STR, rz_coff_import_index_addr(), rz_coff_symbol_name(), rz_str_constpool_get(), rz_str_newf(), s, sdb_fmt(), rz_bin_symbol_t::size, rz_bin_symbol_t::type, ut64(), UT64_MAX, and rz_bin_symbol_t::vaddr.

Referenced by populate_symbols().

baddr()

static ut64 baddr ( RzBinFile *  bf )

static

Definition at line 43 of file bin_coff.c.

                                 {
    return 0;
}

binsym()

static RzBinAddr* binsym ( RzBinFile *  bf, RzBinSpecialSymbol  sym  )

static

Definition at line 47 of file bin_coff.c.

                                                                {
    return NULL;
}

References NULL.

check_buffer()

static bool check_buffer ( RzBuffer *  buf )

static

Definition at line 505 of file bin_coff.c.

                                        {
#if 0
TODO: do more checks here to avoid false positives
 
ut16 MACHINE
ut16 NSECTIONS
ut32 DATE
ut32 PTRTOSYMTABLE
ut32 NUMOFSYMS
ut16 OPTHDRSIZE
ut16 CHARACTERISTICS
#endif
 
    ut8 tmp[20];
    int r = rz_buf_read_at(buf, 0, tmp, sizeof(tmp));
    return r >= 20 && rz_coff_supported_arch(tmp);
}

References checks, r, rz_buf_read_at(), rz_coff_supported_arch(), autogen_x86imm::tmp, to, and objdump-m68k::TODO.

destroy()

static void destroy ( RzBinFile *  bf )

static

Definition at line 39 of file bin_coff.c.

                                   {
    rz_bin_coff_free((struct rz_bin_coff_obj *)bf->o->bin_obj);
}

References rz_bin_object_t::bin_obj, rz_bin_file_t::o, and rz_bin_coff_free().

entries()

static RzList* entries ( RzBinFile *  bf )

static

Definition at line 170 of file bin_coff.c.

                                      {
    struct rz_bin_coff_obj *obj = (struct rz_bin_coff_obj *)bf->o->bin_obj;
    RzList *ret;
    if (!(ret = rz_list_newf(free))) {
        return NULL;
    }
    RzBinAddr *ptr = rz_coff_get_entry(obj);
    if (ptr) {
        rz_list_append(ret, ptr);
    }
    return ret;
}

References rz_bin_object_t::bin_obj, free(), if(), NULL, rz_bin_file_t::o, rz_coff_get_entry(), rz_list_append(), and rz_list_newf().

fields()

static RzList* fields ( RzBinFile *  bf )

static

Definition at line 497 of file bin_coff.c.

                                     {
    return NULL;
}

References NULL.

get_sdb()

static Sdb* get_sdb ( RzBinFile *  bf )

static

Definition at line 18 of file bin_coff.c.

                                   {
    RzBinObject *o = bf->o;
    if (!o) {
        return NULL;
    }
    struct rz_bin_coff_obj *bin = (struct rz_bin_coff_obj *)o->bin_obj;
    if (bin->kv) {
        return bin->kv;
    }
    return NULL;
}

References rz_bin_object_t::bin_obj, if(), NULL, and rz_bin_file_t::o.

imports()

static RzList* imports ( RzBinFile *  bf )

static

Definition at line 359 of file bin_coff.c.

                                      {
    int i;
    struct rz_bin_coff_obj *obj = (struct rz_bin_coff_obj *)bf->o->bin_obj;
    RzList *ret = rz_list_newf((RzListFree)rz_bin_import_free);
    if (!ret) {
        return NULL;
    }
    if (obj->symbols) {
        populate_imports(obj);
        for (i = 0; i < obj->hdr.f_nsyms; i++) {
            RzBinImport *ptr = ht_up_find(obj->imp_ht, i, NULL);
            if (ptr) {
                rz_list_append(ret, ptr);
            }
            i += obj->symbols[i].n_numaux;
        }
    }
    return ret;
}

References rz_bin_object_t::bin_obj, rz_bin_coff_obj::hdr, i, rz_bin_coff_obj::imp_ht, NULL, rz_bin_file_t::o, populate_imports(), rz_bin_import_free(), rz_list_append(), rz_list_newf(), and rz_bin_coff_obj::symbols.

info()

static RzBinInfo* info ( RzBinFile *  bf )

static

Definition at line 388 of file bin_coff.c.

                                      {
    RzBinInfo *ret = RZ_NEW0(RzBinInfo);
    struct rz_bin_coff_obj *obj = (struct rz_bin_coff_obj *)bf->o->bin_obj;
 
    ret->file = bf->file ? strdup(bf->file) : NULL;
    ret->rclass = strdup("coff");
    ret->bclass = strdup("coff");
    ret->type = strdup("COFF (Executable file)");
    ret->os = strdup("any");
    ret->subsystem = strdup("any");
    ret->big_endian = obj->endian;
    ret->has_va = true;
    ret->dbg_info = 0;
 
    if (rz_coff_is_stripped(obj)) {
        ret->dbg_info |= RZ_BIN_DBG_STRIPPED;
    } else {
        if (!(obj->hdr.f_flags & COFF_FLAGS_TI_F_RELFLG)) {
            ret->dbg_info |= RZ_BIN_DBG_RELOCS;
        }
        if (!(obj->hdr.f_flags & COFF_FLAGS_TI_F_LNNO)) {
            ret->dbg_info |= RZ_BIN_DBG_LINENUMS;
        }
        if (!(obj->hdr.f_flags & COFF_FLAGS_TI_F_EXEC)) {
            ret->dbg_info |= RZ_BIN_DBG_SYMS;
        }
    }
 
    switch (obj->hdr.f_magic) {
    case COFF_FILE_MACHINE_R4000:
    case COFF_FILE_MACHINE_MIPS16:
    case COFF_FILE_MACHINE_MIPSFPU:
    case COFF_FILE_MACHINE_MIPSFPU16:
        ret->machine = strdup("mips");
        ret->arch = strdup("mips");
        ret->bits = 32;
        break;
    case COFF_FILE_MACHINE_I386:
        ret->machine = strdup("i386");
        ret->arch = strdup("x86");
        ret->bits = 32;
        break;
    case COFF_FILE_MACHINE_AMD64:
        ret->machine = strdup("AMD64");
        ret->arch = strdup("x86");
        ret->bits = 64;
        break;
    case COFF_FILE_MACHINE_H8300:
        ret->machine = strdup("H8300");
        ret->arch = strdup("h8300");
        ret->bits = 16;
        break;
    case COFF_FILE_MACHINE_AMD29KBE:
    case COFF_FILE_MACHINE_AMD29KLE:
        ret->cpu = strdup("29000");
        ret->machine = strdup("amd29k");
        ret->arch = strdup("amd29k");
        ret->bits = 32;
        break;
    case COFF_FILE_MACHINE_THUMB:
        ret->machine = strdup("arm");
        ret->arch = strdup("arm");
        ret->bits = 16;
        break;
    case COFF_FILE_MACHINE_ARM:
    case COFF_FILE_MACHINE_ARMNT:
        ret->machine = strdup("arm");
        ret->arch = strdup("arm");
        ret->bits = 32;
        break;
    case COFF_FILE_MACHINE_ARM64:
        ret->machine = strdup("arm");
        ret->arch = strdup("arm");
        ret->bits = 64;
        break;
    case COFF_FILE_MACHINE_SH3:
    case COFF_FILE_MACHINE_SH3DSP:
    case COFF_FILE_MACHINE_SH4:
    case COFF_FILE_MACHINE_SH5:
        ret->machine = strdup("sh");
        ret->arch = strdup("sh");
        ret->bits = 32;
        break;
    case COFF_FILE_TI_COFF:
        switch (obj->target_id) {
        case COFF_FILE_MACHINE_TMS320C54:
            ret->machine = strdup("c54x");
            ret->arch = strdup("tms320");
            ret->bits = 32;
            break;
        case COFF_FILE_MACHINE_TMS320C55:
            ret->machine = strdup("c55x");
            ret->arch = strdup("tms320");
            ret->bits = 32;
            break;
        case COFF_FILE_MACHINE_TMS320C55PLUS:
            ret->machine = strdup("c55x+");
            ret->arch = strdup("tms320");
            ret->bits = 32;
            break;
        }
        break;
    default:
        ret->machine = strdup("unknown");
    }
 
    return ret;
}

References rz_bin_info_t::arch, rz_bin_info_t::bclass, rz_bin_info_t::big_endian, rz_bin_object_t::bin_obj, rz_bin_info_t::bits, COFF_FILE_MACHINE_AMD29KBE, COFF_FILE_MACHINE_AMD29KLE, COFF_FILE_MACHINE_AMD64, COFF_FILE_MACHINE_ARM, COFF_FILE_MACHINE_ARM64, COFF_FILE_MACHINE_ARMNT, COFF_FILE_MACHINE_H8300, COFF_FILE_MACHINE_I386, COFF_FILE_MACHINE_MIPS16, COFF_FILE_MACHINE_MIPSFPU, COFF_FILE_MACHINE_MIPSFPU16, COFF_FILE_MACHINE_R4000, COFF_FILE_MACHINE_SH3, COFF_FILE_MACHINE_SH3DSP, COFF_FILE_MACHINE_SH4, COFF_FILE_MACHINE_SH5, COFF_FILE_MACHINE_THUMB, COFF_FILE_MACHINE_TMS320C54, COFF_FILE_MACHINE_TMS320C55, COFF_FILE_MACHINE_TMS320C55PLUS, COFF_FILE_TI_COFF, COFF_FLAGS_TI_F_EXEC, COFF_FLAGS_TI_F_LNNO, COFF_FLAGS_TI_F_RELFLG, rz_bin_info_t::cpu, rz_bin_info_t::dbg_info, rz_bin_coff_obj::endian, rz_bin_info_t::file, rz_bin_file_t::file, rz_bin_info_t::has_va, rz_bin_coff_obj::hdr, rz_bin_info_t::machine, NULL, rz_bin_file_t::o, rz_bin_info_t::os, rz_bin_info_t::rclass, RZ_BIN_DBG_LINENUMS, RZ_BIN_DBG_RELOCS, RZ_BIN_DBG_STRIPPED, RZ_BIN_DBG_SYMS, rz_coff_is_stripped(), RZ_NEW0, strdup(), rz_bin_info_t::subsystem, rz_bin_coff_obj::target_id, and rz_bin_info_t::type.

is_imported_symbol()

static bool is_imported_symbol ( struct coff_symbol *  s )

static

Definition at line 53 of file bin_coff.c.

                                                      {
    return s->n_scnum == COFF_SYM_SCNUM_UNDEF && s->n_sclass == COFF_SYM_CLASS_EXTERNAL;
}

References COFF_SYM_CLASS_EXTERNAL, COFF_SYM_SCNUM_UNDEF, and s.

Referenced by _fill_bin_import(), and _fill_bin_symbol().

libs()

static RzList* libs ( RzBinFile *  bf )

static

Definition at line 379 of file bin_coff.c.

                                   {
    return NULL;
}

References NULL.

Referenced by get_libs(), rz_bin_demangle(), rz_bin_pe_get_libs(), rz_core_bin_libs_print(), rz_core_bin_load(), and rz_diff_libraries_new().

load_buffer()

static bool load_buffer ( RzBinFile *  bf, RzBinObject *  obj, RzBuffer *  buf, Sdb *  sdb  )

static

Definition at line 34 of file bin_coff.c.

                                                                                  {
    obj->bin_obj = rz_bin_coff_new_buf(buf, bf->rbin->verbose);
    return obj->bin_obj != NULL;
}

References rz_bin_object_t::bin_obj, NULL, rz_bin_file_t::rbin, rz_bin_coff_new_buf(), and rz_bin_t::verbose.

maps()

static RzList* maps ( RzBinFile *  bf )

static

Definition at line 224 of file bin_coff.c.

                                   {
    RzList *ret = rz_list_newf((RzListFree)rz_bin_map_free);
    if (!ret) {
        return NULL;
    }
    RzBinObject *o = bf->o;
    struct rz_bin_coff_obj *obj = o ? o->bin_obj : NULL;
    if (!obj || !obj->scn_hdrs) {
        return ret;
    }
    populate_symbols(bf);
    for (size_t i = 0; i < obj->hdr.f_nscns; i++) {
        RzBinMap *ptr = RZ_NEW0(RzBinMap);
        if (!ptr) {
            return ret;
        }
        struct coff_scn_hdr *hdr = &obj->scn_hdrs[i];
        ptr->name = rz_coff_symbol_name(obj, hdr);
        ptr->psize = hdr->s_size;
        ptr->vsize = hdr->s_size;
        ptr->paddr = hdr->s_scnptr;
        if (obj->scn_va) {
            ptr->vaddr = obj->scn_va[i];
        }
        ptr->perm = rz_coff_perms_from_section_flags(hdr->s_flags);
        if (hdr->s_nreloc) {
            ptr->vfile_name = strdup(VFILE_NAME_PATCHED);
        }
        rz_list_append(ret, ptr);
    }
    ut64 rtmsz = rz_coff_get_reloc_targets_vfile_size(obj);
    if (rtmsz) {
        // virtual file for reloc targets (where the relocs will point into)
        RzBinMap *map = RZ_NEW0(RzBinMap);
        if (!map) {
            return ret;
        }
        map->name = strdup("reloc-targets");
        map->paddr = 0;
        map->psize = rtmsz;
        map->vaddr = rz_coff_get_reloc_targets_map_base(obj);
        map->vsize = rtmsz;
        map->perm = RZ_PERM_R;
        map->vfile_name = strdup(VFILE_NAME_RELOC_TARGETS);
        rz_list_prepend(ret, map);
    }
    return ret;
}

References rz_bin_object_t::bin_obj, rz_bin_coff_obj::hdr, i, map(), rz_bin_map_t::name, NULL, rz_bin_file_t::o, rz_bin_map_t::paddr, rz_bin_map_t::perm, populate_symbols(), rz_bin_map_t::psize, rz_bin_map_free(), rz_coff_get_reloc_targets_map_base(), rz_coff_get_reloc_targets_vfile_size(), rz_coff_perms_from_section_flags(), rz_coff_symbol_name(), rz_list_append(), rz_list_newf(), rz_list_prepend(), RZ_NEW0, RZ_PERM_R, rz_bin_coff_obj::scn_hdrs, rz_bin_coff_obj::scn_va, strdup(), ut64(), rz_bin_map_t::vaddr, rz_bin_map_t::vfile_name, VFILE_NAME_PATCHED, VFILE_NAME_RELOC_TARGETS, and rz_bin_map_t::vsize.

populate_imports()

static void populate_imports ( struct rz_bin_coff_obj *  obj )

static

Definition at line 303 of file bin_coff.c.

                                                          {
    if (obj->imp_index->count || !obj->symbols) {
        return;
    }
    int ord = 0;
    ut64 imp_idx = 0;
    for (size_t i = 0; i < obj->hdr.f_nsyms; i++) {
        RzBinImport *ptr = _fill_bin_import(obj, i);
        if (ptr) {
            ptr->ordinal = ord++;
            ht_up_insert(obj->imp_ht, (ut64)i, ptr);
            ht_uu_insert(obj->imp_index, (ut64)i, imp_idx++);
        }
        i += obj->symbols[i].n_numaux;
    }
}

References _fill_bin_import(), rz_bin_coff_obj::hdr, i, rz_bin_coff_obj::imp_ht, rz_bin_coff_obj::imp_index, rz_bin_import_t::ordinal, rz_bin_coff_obj::symbols, and ut64().

Referenced by imports(), and populate_symbols().

populate_symbols()

static void populate_symbols ( RzBinFile *  bf )

static

Definition at line 320 of file bin_coff.c.

                                            {
    struct rz_bin_coff_obj *obj = (struct rz_bin_coff_obj *)bf->o->bin_obj;
    if (obj->sym_ht->count || !obj->symbols) {
        return;
    }
    populate_imports(obj);
    for (size_t i = 0; i < obj->hdr.f_nsyms; i++) {
        RzBinSymbol *ptr = RZ_NEW0(RzBinSymbol);
        if (!ptr) {
            break;
        }
        if (_fill_bin_symbol(bf->rbin, obj, i, &ptr)) {
            ht_up_insert(obj->sym_ht, (ut64)i, ptr);
        } else {
            free(ptr);
        }
        i += obj->symbols[i].n_numaux;
    }
}

References _fill_bin_symbol(), rz_bin_object_t::bin_obj, free(), rz_bin_coff_obj::hdr, i, if(), rz_bin_file_t::o, populate_imports(), rz_bin_file_t::rbin, RZ_NEW0, rz_bin_coff_obj::sym_ht, rz_bin_coff_obj::symbols, and ut64().

Referenced by maps(), relocs(), symbols(), and virtual_files().

relocs()

static RzList* relocs ( RzBinFile *  bf )

static

Definition at line 383 of file bin_coff.c.

                                     {
    populate_symbols(bf);
    return rz_coff_get_relocs(bf->o->bin_obj);
}

References rz_bin_object_t::bin_obj, rz_bin_file_t::o, populate_symbols(), and rz_coff_get_relocs().

rz_coff_is_stripped()

static bool rz_coff_is_stripped ( struct rz_bin_coff_obj *  obj )

static

Definition at line 30 of file bin_coff.c.

                                                             {
    return !!(obj->hdr.f_flags & (COFF_FLAGS_TI_F_RELFLG | COFF_FLAGS_TI_F_LNNO | COFF_FLAGS_TI_F_LSYMS));
}

References COFF_FLAGS_TI_F_LNNO, COFF_FLAGS_TI_F_LSYMS, COFF_FLAGS_TI_F_RELFLG, and rz_bin_coff_obj::hdr.

Referenced by info().

sections()

static RzList* sections ( RzBinFile *  bf )

static

Definition at line 273 of file bin_coff.c.

                                       {
    struct rz_bin_coff_obj *obj = (struct rz_bin_coff_obj *)bf->o->bin_obj;
    RzList *ret = rz_list_newf((RzListFree)rz_bin_section_free);
    if (!ret) {
        return NULL;
    }
    if (!obj || !obj->scn_hdrs) {
        return ret;
    }
    for (size_t i = 0; i < obj->hdr.f_nscns; i++) {
        RzBinSection *ptr = RZ_NEW0(RzBinSection);
        if (!ptr) {
            return ret;
        }
        ptr->name = rz_coff_symbol_name(obj, &obj->scn_hdrs[i]);
        if (strstr(ptr->name, "data")) {
            ptr->is_data = true;
        }
        ptr->size = obj->scn_hdrs[i].s_size;
        ptr->vsize = obj->scn_hdrs[i].s_size;
        ptr->paddr = obj->scn_hdrs[i].s_scnptr;
        if (obj->scn_va) {
            ptr->vaddr = obj->scn_va[i];
        }
        ptr->perm = rz_coff_perms_from_section_flags(obj->scn_hdrs[i].s_flags);
        rz_list_append(ret, ptr);
    }
    return ret;
}

References rz_bin_object_t::bin_obj, rz_bin_coff_obj::hdr, i, rz_bin_section_t::is_data, rz_bin_section_t::name, NULL, rz_bin_file_t::o, rz_bin_section_t::paddr, rz_bin_section_t::perm, rz_bin_section_free(), rz_coff_perms_from_section_flags(), rz_coff_symbol_name(), rz_list_append(), rz_list_newf(), RZ_NEW0, rz_bin_coff_obj::scn_hdrs, rz_bin_coff_obj::scn_va, rz_bin_section_t::size, rz_bin_section_t::vaddr, and rz_bin_section_t::vsize.

size()

static ut64 size ( RzBinFile *  bf )

static

Definition at line 501 of file bin_coff.c.

                                {
    return 0;
}

symbols()

static RzList* symbols ( RzBinFile *  bf )

static

Definition at line 340 of file bin_coff.c.

                                      {
    struct rz_bin_coff_obj *obj = (struct rz_bin_coff_obj *)bf->o->bin_obj;
    RzList *ret = rz_list_newf((RzListFree)rz_bin_symbol_free);
    if (!ret) {
        return NULL;
    }
    if (obj->symbols) {
        populate_symbols(bf);
        for (size_t i = 0; i < obj->hdr.f_nsyms; i++) {
            RzBinSymbol *ptr = ht_up_find(obj->sym_ht, i, NULL);
            if (ptr) {
                rz_list_append(ret, ptr);
            }
            i += obj->symbols[i].n_numaux;
        }
    }
    return ret;
}

References rz_bin_object_t::bin_obj, rz_bin_coff_obj::hdr, i, NULL, rz_bin_file_t::o, populate_symbols(), rz_bin_symbol_free(), rz_list_append(), rz_list_newf(), rz_bin_coff_obj::sym_ht, and rz_bin_coff_obj::symbols.

virtual_files()

static RzList* virtual_files ( RzBinFile *  bf )

static

Definition at line 183 of file bin_coff.c.

                                            {
    RzList *r = rz_list_newf((RzListFree)rz_bin_virtual_file_free);
    if (!r) {
        return NULL;
    }
    RzBinObject *o = bf->o;
    struct rz_bin_coff_obj *obj = o ? o->bin_obj : NULL;
    if (!obj) {
        return r;
    }
    populate_symbols(bf); // the patching depends on symbols to be available
    // virtual file for reloc targets (where the relocs will point into)
    ut64 rtmsz = rz_coff_get_reloc_targets_vfile_size(obj);
    if (rtmsz) {
        RzBuffer *buf = rz_buf_new_empty(rtmsz);
        if (!buf) {
            return r;
        }
        RzBinVirtualFile *vf = RZ_NEW0(RzBinVirtualFile);
        if (!vf) {
            return r;
        }
        vf->buf = buf;
        vf->buf_owned = true;
        vf->name = strdup(VFILE_NAME_RELOC_TARGETS);
        rz_list_push(r, vf);
    }
    // virtual file mirroring the raw file, but with relocs patched
    RzBuffer *buf_patched = rz_coff_get_patched_buf(obj);
    if (buf_patched) {
        RzBinVirtualFile *vf = RZ_NEW0(RzBinVirtualFile);
        if (!vf) {
            return r;
        }
        vf->buf = buf_patched;
        vf->name = strdup(VFILE_NAME_PATCHED);
        rz_list_push(r, vf);
    }
    return r;
}

References rz_bin_object_t::bin_obj, rz_bin_virtual_file_t::buf, rz_bin_virtual_file_t::buf_owned, rz_bin_coff_obj::buf_patched, rz_bin_virtual_file_t::name, NULL, rz_bin_file_t::o, populate_symbols(), r, rz_bin_virtual_file_free(), rz_buf_new_empty(), rz_coff_get_patched_buf(), rz_coff_get_reloc_targets_vfile_size(), rz_list_newf(), rz_list_push(), RZ_NEW0, strdup(), ut64(), VFILE_NAME_PATCHED, and VFILE_NAME_RELOC_TARGETS.

Variable Documentation

rizin_plugin

RZ_API RzLibStruct rizin_plugin

Initial value:

= {
    .type = RZ_LIB_TYPE_BIN,
    .data = &rz_bin_plugin_coff,
    .version = RZ_VERSION
}

Definition at line 547 of file bin_coff.c.

rz_bin_plugin_coff

RzBinPlugin rz_bin_plugin_coff

Initial value:

= {
    .name = "coff",
    .desc = "COFF format rz_bin plugin",
    .license = "LGPL3",
    .get_sdb = &get_sdb,
    .load_buffer = &load_buffer,
    .destroy = &destroy,
    .check_buffer = &check_buffer,
    .baddr = &baddr,
    .binsym = &binsym,
    .entries = &entries,
    .virtual_files = &virtual_files,
    .maps = &maps,
    .sections = &sections,
    .symbols = &symbols,
    .imports = &imports,
    .info = &info,
    .fields = &fields,
    .size = &size,
    .libs = &libs,
    .relocs = &relocs
}

Definition at line 523 of file bin_coff.c.