static RList *imports(RBinFile *bf) {
RBinWasmObj *bin = NULL;
RList *imports = NULL;
RBinImport *ptr = NULL;
RList *ret = NULL;
if (!bf || !bf->o || !bf->o->bin_obj) {
return NULL;
}
bin = bf->o->bin_obj;
if (!(ret = r_list_newf (r_bin_import_free))) {
return NULL;
}
if (!(imports = r_bin_wasm_get_imports (bin))) {
goto bad_alloc;
}
RBinWasmImportEntry *import = NULL;
ut32 i = 0;
RListIter *iter;
r_list_foreach (imports, iter, import) {
if (!(ptr = R_NEW0 (RBinImport))) {
goto bad_alloc;
}
ptr->name = strdup (import->field_str);
ptr->classname = strdup (import->module_str);
ptr->ordinal = i;
ptr->bind = r_str_const ("NONE");
switch(import->kind) {
case R_BIN_WASM_EXTERNALKIND_Function:
ptr->type = r_str_const ("FUNC");
break;
case R_BIN_WASM_EXTERNALKIND_Table:
ptr->type = r_str_const ("TABLE");
break;
case R_BIN_WASM_EXTERNALKIND_Memory:
ptr->type = r_str_const ("MEM");
break;
case R_BIN_WASM_EXTERNALKIND_Global:
ptr->type = r_str_const ("GLOBAL");
break;
}
r_list_append (ret, ptr);
}
return ret;
bad_alloc:
r_list_free (imports);
r_list_free (ret);
return NULL;
}
static RList *symbols(RBinFile *arch) {
RList *ret;
RBinSymbol *sym;
OMF_symbol *sym_omf;
int ct_sym = 0;
if (!(ret = r_list_new()))
return NULL;
ret->free = free;
while (ct_sym < ((r_bin_omf_obj *)arch->o->bin_obj)->nb_symbol) {
if (!(sym = R_NEW0 (RBinSymbol)))
return ret;
sym_omf = ((r_bin_omf_obj *)arch->o->bin_obj)->symbols[ct_sym++];
sym->name = strdup (sym_omf->name);
sym->forwarder = r_str_const ("NONE");
sym->paddr = r_bin_omf_get_paddr_sym(arch->o->bin_obj, sym_omf);
sym->vaddr = r_bin_omf_get_vaddr_sym(arch->o->bin_obj, sym_omf);
sym->ordinal = ct_sym;
sym->size = 0;
r_list_append (ret, sym);
}
return ret;
}
static bool _fill_bin_symbol(struct r_bin_coff_obj *bin, int idx, RBinSymbol **sym) {
RBinSymbol *ptr = *sym;
char * coffname = NULL;
struct coff_symbol *s = NULL;
if (idx < 0 || idx > bin->hdr.f_nsyms) {
return false;
}
if (!bin->symbols) {
return false;
}
s = &bin->symbols[idx];
coffname = r_coff_symbol_name (bin, s);
if (!coffname) {
return false;
}
ptr->name = strdup (coffname);
free (coffname);
ptr->forwarder = r_str_const ("NONE");
switch (s->n_sclass) {
case COFF_SYM_CLASS_FUNCTION:
ptr->type = r_str_const ("FUNC");
break;
case COFF_SYM_CLASS_FILE:
ptr->type = r_str_const ("FILE");
break;
case COFF_SYM_CLASS_SECTION:
ptr->type = r_str_const ("SECTION");
break;
case COFF_SYM_CLASS_EXTERNAL:
ptr->type = r_str_const ("EXTERNAL");
break;
case COFF_SYM_CLASS_STATIC:
ptr->type = r_str_const ("STATIC");
break;
default:
ptr->type = r_str_const (sdb_fmt (0, "%i", s->n_sclass));
break;
}
if (bin->symbols[idx].n_scnum < bin->hdr.f_nscns &&
bin->symbols[idx].n_scnum > 0) {
//first index is 0 that is why -1
ptr->paddr = bin->scn_hdrs[s->n_scnum - 1].s_scnptr + s->n_value;
}
ptr->size = 4;
ptr->ordinal = 0;
return true;
}
static void walkSymbols (RBinFile *bf, RBinNROObj *bin, ut64 symtab, ut64 strtab, ut64 strtab_size, ut64 relplt, ut64 baddr) {
int i, import = 0;
RBinSymbol *sym;
RBinImport *imp;
for (i = 8; i < 99999; i++) {
ut64 addr = readLE64 (bf->buf, symtab + i);
ut64 size = readLE64 (bf->buf, symtab + i + 8);
i += 16; // NULL, NULL
ut64 name = readLE32 (bf->buf, symtab + i);
//ut64 type = readLE32 (bf->buf, symtab + i + 4);
const char *symName = readString (bf->buf, strtab + name);
if (!symName) {
break;
}
sym = R_NEW0 (RBinSymbol);
if (!sym) {
break;
}
sym->type = r_str_const ("FUNC");
sym->bind = r_str_const ("NONE");
sym->size = size;
if (addr == 0) {
import ++;
ut64 pltSym = readLE64 (bf->buf, relplt + (import * 24));
imp = R_NEW0 (RBinImport);
if (!imp) {
R_FREE (sym);
break;
}
imp->name = strdup (symName);
if (!imp->name) {
goto out_walk_symbol;
}
imp->type = r_str_const ("FUNC");
if (!imp->type) {
goto out_walk_symbol;
}
imp->bind = r_str_const ("NONE");
if (!imp->bind) {
goto out_walk_symbol;
}
imp->ordinal = bin->imports_list->length;
r_list_append (bin->imports_list, imp);
sym->name = r_str_newf ("imp.%s", symName);
if (!sym->name) {
goto out_walk_symbol;
}
sym->paddr = pltSym - 8;
sym->vaddr = sym->paddr + baddr;
//eprintf ("f sym.imp.%s = 0x%"PFMT64x"\n", symName, pltSym - 8);
} else {
sym->name = strdup (symName);
if (!sym->name) {
R_FREE (sym);
break;
}
sym->paddr = addr;
sym->vaddr = sym->paddr + baddr;
//eprintf ("f sym.%s %"PFMT64u "0x%"PFMT64x"\n", symName, size, addr);
}
r_list_append (bin->methods_list, sym);
i += 8 - 1;
}
return;
out_walk_symbol:
R_FREE (sym);
R_FREE (imp);
return;
}
static RList *symbols(RBinFile *bf) {
RBinWasmObj *bin = NULL;
RList *ret = NULL, *codes = NULL, *imports = NULL;
RBinSymbol *ptr = NULL;
if (!bf || !bf->o || !bf->o->bin_obj) {
return NULL;
}
bin = bf->o->bin_obj;
if (!(ret = r_list_newf ((RListFree)free))) {
return NULL;
}
if (!(codes = r_bin_wasm_get_codes (bin))) {
goto bad_alloc;
}
if (!(imports = r_bin_wasm_get_imports (bin))) {
goto bad_alloc;
}
ut32 i = 0;
RBinWasmImportEntry *imp;
RListIter *iter;
r_list_foreach (imports, iter, imp) {
if (!(ptr = R_NEW0 (RBinSymbol))) {
goto bad_alloc;
}
ptr->name = r_str_newf ("imp.%s.%s", imp->module_str, imp->field_str);
ptr->forwarder = r_str_const ("NONE");
ptr->bind = r_str_const ("NONE");
switch (imp->kind) {
case 0: ptr->type = r_str_const ("FUNC"); break;
case 1: ptr->type = r_str_const ("TABLE"); break;
case 2: ptr->type = r_str_const ("MEMORY"); break;
case 3: ptr->type = r_str_const ("GLOBAL"); break;
}
ptr->size = 0;
ptr->vaddr = -1;
ptr->paddr = -1;
ptr->ordinal = i;
i += 1;
r_list_append (ret, ptr);
}
RBinWasmCodeEntry *func;
r_list_foreach (codes, iter, func) {
if (!(ptr = R_NEW0 (RBinSymbol))) {
goto bad_alloc;
}
char tmp[R_BIN_SIZEOF_STRINGS];
snprintf (tmp, R_BIN_SIZEOF_STRINGS, "fnc.%d", i);
ptr->name = strdup(tmp);
ptr->forwarder = r_str_const ("NONE");
ptr->bind = r_str_const ("NONE");
ptr->type = r_str_const ("FUNC");
ptr->size = func->len;
ptr->vaddr = (ut64)func->code;
ptr->paddr = (ut64)func->code;
ptr->ordinal = i;
i++;
r_list_append (ret, ptr);
}
// TODO: use custom section "name" if present
// TODO: exports, globals, tables and memories
return ret;
bad_alloc:
// not so sure if imports should be freed.
r_list_free (codes);
r_list_free (ret);
return NULL;
}
static RList *symbols(RBinFile *arch) {
const char *coffname;
size_t i;
RList *ret = NULL;
RBinSymbol *ptr = NULL;
struct r_bin_coff_obj *obj = (struct r_bin_coff_obj*)arch->o->bin_obj;
if (!(ret = r_list_new()))
return ret;
ret->free = free;
if (obj->symbols)
for (i = 0; i < obj->hdr.f_nsyms; i++) {
if (!(ptr = R_NEW0 (RBinSymbol)))
break;
coffname = r_coff_symbol_name (obj, &obj->symbols[i]);
if (!coffname) {
free (ptr);
break;
}
ptr->name = strdup (coffname);
ptr->forwarder = r_str_const ("NONE");
switch (obj->symbols[i].n_sclass) {
case COFF_SYM_CLASS_FUNCTION:
ptr->type = r_str_const ("FUNC");
break;
case COFF_SYM_CLASS_FILE:
ptr->type = r_str_const ("FILE");
break;
case COFF_SYM_CLASS_SECTION:
ptr->type = r_str_const ("SECTION");
break;
case COFF_SYM_CLASS_EXTERNAL:
ptr->type = r_str_const ("EXTERNAL");
break;
case COFF_SYM_CLASS_STATIC:
ptr->type = r_str_const ("STATIC");
break;
default:
ptr->type = r_str_const (sdb_fmt(0, "%i", obj->symbols[i].n_sclass));
break;
}
if (obj->symbols[i].n_scnum < obj->hdr.f_nscns) {
ptr->paddr = obj->scn_hdrs[obj->symbols[i].n_scnum].s_scnptr +
obj->symbols[i].n_value;
}
ptr->size = 4;
ptr->ordinal = 0;
r_list_append (ret, ptr);
i += obj->symbols[i].n_numaux;
free (ptr);
}
return ret;
}
