portugalfuturista/rizin
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Refactor the <entries> in RzBinPlugin from list to pvector (#4118)

Browse source
This commit is contained in:
Peiwei Hu 2024-02-25 19:42:25 +08:00 committed by GitHub
parent 8b21371b8d
commit 5d053f0448
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
66 changed files with 297 additions and 370 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
librz/bin/bin.c
View file

@ -598,13 +598,6 @@ RZ_API void rz_bin_set_baddr(RzBin *bin, ut64 baddr) {
}
}
// XXX: those accessors are redundant
RZ_DEPRECATE RZ_API RZ_BORROW RzList /*<RzBinAddr *>*/ *rz_bin_get_entries(RZ_NONNULL RzBin *bin) {
rz_return_val_if_fail(bin, NULL);
RzBinObject *o = rz_bin_cur_object(bin);
return o ? (RzList *)rz_bin_object_get_entries(o) : NULL;
}
RZ_DEPRECATE RZ_API RZ_BORROW RzBinInfo *rz_bin_get_info(RzBin *bin) {
rz_return_val_if_fail(bin, NULL);
RzBinObject *o = rz_bin_cur_object(bin);

6
librz/bin/bobj.c
View file

@ -194,7 +194,7 @@ RZ_IPI void rz_bin_object_free(RzBinObject *o) {
rz_bin_source_line_info_free(o->lines);
rz_bin_string_database_free(o->strings);
rz_pvector_free(o->classes);
rz_list_free(o->entries);
rz_pvector_free(o->entries);
rz_pvector_free(o->fields);
rz_pvector_free(o->imports);
rz_pvector_free(o->libs);
@ -657,9 +657,9 @@ RZ_API const RzBinAddr *rz_bin_object_get_special_symbol(RzBinObject *o, RzBinSp
}
/**
* \brief Get list of \p RzBinAddr representing the entry points of the binary object.
* \brief Get pvector of \p RzBinAddr representing the entry points of the binary object.
*/
RZ_API const RzList /*<RzBinAddr *>*/ *rz_bin_object_get_entries(RZ_NONNULL RzBinObject *obj) {
RZ_API RZ_BORROW const RzPVector /*<RzBinAddr *>*/ *rz_bin_object_get_entries(RZ_NONNULL RzBinObject *obj) {
rz_return_val_if_fail(obj, NULL);
return obj->entries;
}

9
librz/bin/bobj_process_entry.c
View file

@ -7,15 +7,16 @@
RZ_IPI void rz_bin_set_and_process_entries(RzBinFile *bf, RzBinObject *o) {
RzBinPlugin *plugin = o->plugin;
rz_list_free(o->entries);
rz_pvector_free(o->entries);
if (!plugin->entries || !(o->entries = plugin->entries(bf))) {
o->entries = rz_list_newf(free);
o->entries = rz_pvector_new(free);
return;
}
RzListIter *it;
void **it;
RzBinAddr *element;
rz_list_foreach (o->entries, it, element) {
rz_pvector_foreach (o->entries, it) {
element = *it;
// rebase physical address
element->paddr += o->opts.loadaddr;
}

27
librz/bin/format/dex/dex.c
View file

@ -1688,12 +1688,12 @@ RZ_API RZ_OWN RzBinAddr *rz_bin_dex_resolve_symbol(RZ_NONNULL RzBinDex *dex, RzB
return ret;
}
static RzList /*<RzBinAddr *>*/ *dex_resolve_entrypoints_in_class(RzBinDex *dex, DexClassDef *class_def) {
static RzPVector /*<RzBinAddr *>*/ *dex_resolve_entrypoints_in_class(RzBinDex *dex, DexClassDef *class_def) {
RzListIter *it;
DexEncodedMethod *encoded_method = NULL;
RzList *entrypoints = NULL;
RzPVector *entrypoints = NULL;
entrypoints = rz_list_newf((RzListFree)free);
entrypoints = rz_pvector_new((RzPVectorFree)free);
if (!entrypoints) {
return NULL;
}
@ -1732,7 +1732,7 @@ static RzList /*<RzBinAddr *>*/ *dex_resolve_entrypoints_in_class(RzBinDex *dex,
entrypoint->vaddr = encoded_method->code_offset;
entrypoint->paddr = 0;
}
if (entrypoint && !rz_list_append(entrypoints, entrypoint)) {
if (entrypoint && !rz_pvector_push(entrypoints, entrypoint)) {
free(entrypoint);
}
}
@ -1776,7 +1776,7 @@ static RzList /*<RzBinAddr *>*/ *dex_resolve_entrypoints_in_class(RzBinDex *dex,
entrypoint->vaddr = encoded_method->code_offset;
entrypoint->paddr = 0;
}
if (entrypoint && !rz_list_append(entrypoints, entrypoint)) {
if (entrypoint && !rz_pvector_push(entrypoints, entrypoint)) {
free(entrypoint);
}
}
@ -1785,27 +1785,26 @@ static RzList /*<RzBinAddr *>*/ *dex_resolve_entrypoints_in_class(RzBinDex *dex,
}
/**
* \brief Returns a RzList<RzBinAddr*> containing the dex entripoints
* \brief Returns a RzPVector<RzBinAddr*> containing the dex entripoints
*/
RZ_API RZ_OWN RzList /*<RzBinAddr *>*/ *rz_bin_dex_entrypoints(RZ_NONNULL RzBinDex *dex) {
RZ_API RZ_OWN RzPVector /*<RzBinAddr *>*/ *rz_bin_dex_entrypoints(RZ_NONNULL RzBinDex *dex) {
rz_return_val_if_fail(dex, NULL);
DexClassDef *class_def;
RzList *list = NULL;
RzList *entrypoints = NULL;
RzPVector *entrypoints = NULL, *vec = NULL;
void **it;
entrypoints = rz_list_newf((RzListFree)free);
entrypoints = rz_pvector_new((RzPVectorFree)free);
if (!entrypoints) {
return NULL;
}
rz_pvector_foreach (dex->class_defs, it) {
class_def = (DexClassDef *)*it;
list = dex_resolve_entrypoints_in_class(dex, class_def);
if (list) {
rz_list_join(entrypoints, list);
rz_list_free(list);
vec = dex_resolve_entrypoints_in_class(dex, class_def);
if (vec) {
rz_pvector_join(entrypoints, vec);
rz_pvector_free(vec);
}
}

2
librz/bin/format/dex/dex.h
View file

@ -215,7 +215,7 @@ RZ_API RZ_OWN RzPVector /*<RzBinSymbol *>*/ *rz_bin_dex_symbols(RZ_NONNULL RzBin
RZ_API RZ_OWN RzPVector /*<RzBinImport *>*/ *rz_bin_dex_imports(RZ_NONNULL RzBinDex *dex);
RZ_API RZ_OWN RzPVector /*<char *>*/ *rz_bin_dex_libraries(RZ_NONNULL RzBinDex *dex);
RZ_API RZ_OWN RzBinAddr *rz_bin_dex_resolve_symbol(RZ_NONNULL RzBinDex *dex, RzBinSpecialSymbol resolve);
RZ_API RZ_OWN RzList /*<RzBinAddr *>*/ *rz_bin_dex_entrypoints(RZ_NONNULL RzBinDex *dex);
RZ_API RZ_OWN RzPVector /*<RzBinAddr *>*/ *rz_bin_dex_entrypoints(RZ_NONNULL RzBinDex *dex);
RZ_API RZ_BORROW RzBuffer *rz_bin_dex_relocations(RZ_NONNULL RzBinDex *dex);
RZ_API RZ_OWN char *rz_bin_dex_resolve_method_by_idx(RZ_NONNULL RzBinDex *dex, ut32 method_idx);

12
librz/bin/format/java/class_bin.c
View file

@ -932,13 +932,13 @@ RZ_API RZ_OWN RzBinAddr *rz_bin_java_class_resolve_symbol(RZ_NONNULL RzBinJavaCl
}
/**
* \brief Returns a RzList<RzBinAddr*> containing the entrypoints
* \brief Returns a RzPVector<RzBinAddr*> containing the entrypoints
*/
RZ_API RZ_OWN RzList /*<RzBinAddr *>*/ *rz_bin_java_class_entrypoints(RZ_NONNULL RzBinJavaClass *bin) {
RZ_API RZ_OWN RzPVector /*<RzBinAddr *>*/ *rz_bin_java_class_entrypoints(RZ_NONNULL RzBinJavaClass *bin) {
rz_return_val_if_fail(bin, NULL);
RzList *list = rz_list_newf(free);
if (!list) {
RzPVector *vec = rz_pvector_new(free);
if (!vec) {
return NULL;
}
@ -984,10 +984,10 @@ RZ_API RZ_OWN RzList /*<RzBinAddr *>*/ *rz_bin_java_class_entrypoints(RZ_NONNULL
continue;
}
entrypoint->vaddr = entrypoint->paddr = addr;
rz_list_append(list, entrypoint);
rz_pvector_push(vec, entrypoint);
}
}
return list;
return vec;
}
/**

2
librz/bin/format/java/class_bin.h
View file

@ -83,7 +83,7 @@ RZ_API RZ_OWN char *rz_bin_java_class_const_pool_resolve_index(RZ_NONNULL RzBinJ
RZ_API void rz_bin_java_class_as_source_code(RZ_NONNULL RzBinJavaClass *bin, RZ_NONNULL RzStrBuf *sb);
RZ_API RZ_OWN RzBinAddr *rz_bin_java_class_resolve_symbol(RZ_NONNULL RzBinJavaClass *bin, RzBinSpecialSymbol resolve);
RZ_API RZ_OWN RzPVector /*<RzBinString *>*/ *rz_bin_java_class_strings(RZ_NONNULL RzBinJavaClass *bin);
RZ_API RZ_OWN RzList /*<RzBinAddr *>*/ *rz_bin_java_class_entrypoints(RZ_NONNULL RzBinJavaClass *bin);
RZ_API RZ_OWN RzPVector /*<RzBinAddr *>*/ *rz_bin_java_class_entrypoints(RZ_NONNULL RzBinJavaClass *bin);
RZ_API RZ_OWN RzList /*<RzBinSymbol *>*/ *rz_bin_java_class_methods_as_symbols(RZ_NONNULL RzBinJavaClass *bin);
RZ_API void rz_bin_java_class_methods_as_text(RZ_NONNULL RzBinJavaClass *bin, RZ_NONNULL RzStrBuf *sb);
RZ_API void rz_bin_java_class_methods_as_json(RZ_NONNULL RzBinJavaClass *bin, RZ_NONNULL PJ *j);

10
librz/bin/format/le/le.c
View file

@ -1649,14 +1649,14 @@ RZ_OWN RzPVector /*<RzBinSection *>*/ *rz_bin_le_get_sections(RzBinFile *bf) {
return sections;
}
RZ_OWN RzList /*<RzBinAddr *>*/ *rz_bin_le_get_entry_points(RzBinFile *bf) {
RZ_OWN RzPVector /*<RzBinAddr *>*/ *rz_bin_le_get_entry_points(RzBinFile *bf) {
rz_bin_le_obj_t *bin = bf->o->bin_obj;
LE_header *h = bin->header;
RzBinAddr *addr = NULL;
RzList *entries = rz_list_newf((RzListFree)free);
RzPVector *entries = rz_pvector_new((RzPVectorFree)free);
if (!entries) {
fail_cleanup:
rz_list_free(entries);
rz_pvector_free(entries);
free(addr);
return NULL;
}
@ -1667,7 +1667,7 @@ RZ_OWN RzList /*<RzBinAddr *>*/ *rz_bin_le_get_entry_points(RzBinFile *bf) {
CHECK(addr = RZ_NEW0(RzBinAddr));
addr->vaddr = bin->objects[h->startobj - 1].reloc_base_addr + h->eip;
addr->paddr = le_vaddr_to_paddr(bin, addr->vaddr);
CHECK(rz_list_append(entries, addr));
CHECK(rz_pvector_push(entries, addr));
addr = NULL;
}
@ -1678,7 +1678,7 @@ RZ_OWN RzList /*<RzBinAddr *>*/ *rz_bin_le_get_entry_points(RzBinFile *bf) {
CHECK(addr = RZ_NEW0(RzBinAddr));
addr->vaddr = e->symbol->vaddr;
addr->paddr = le_vaddr_to_paddr(bin, addr->vaddr);
CHECK(rz_list_append(entries, addr));
CHECK(rz_pvector_push(entries, addr));
addr = NULL;
}
}

2
librz/bin/format/le/le.h
View file

@ -104,7 +104,7 @@ bool rz_bin_le_check_buffer(RzBuffer *b);
bool rz_bin_le_load_buffer(RzBinFile *bf, RzBinObject *obj, RzBuffer *buf, Sdb *sdb);
void rz_bin_le_destroy(RzBinFile *bf);
RZ_OWN RzPVector /*<RzBinMap *>*/ *rz_bin_le_get_maps(RzBinFile *bf);
RZ_OWN RzList /*<RzBinAddr *>*/ *rz_bin_le_get_entry_points(RzBinFile *bf);
RZ_OWN RzPVector /*<RzBinAddr *>*/ *rz_bin_le_get_entry_points(RzBinFile *bf);
RZ_OWN RzPVector /*<RzBinSection *>*/ *rz_bin_le_get_sections(RzBinFile *bf);
RZ_OWN RzPVector /*<RzBinSymbol *>*/ *rz_bin_le_get_symbols(RzBinFile *bf);
RZ_OWN RzPVector /*<RzBinImport *>*/ *rz_bin_le_get_imports(RzBinFile *bf);

14
librz/bin/format/luac/luac_bin.c
View file

@ -44,7 +44,7 @@ void luac_add_symbol(RzList /*<RzBinSymbol *>*/ *symbol_list, char *name, ut64 o
rz_list_append(symbol_list, bin_sym);
}
void luac_add_entry(RzList /*<RzBinAddr *>*/ *entry_list, ut64 offset, int entry_type) {
void luac_add_entry(RzPVector /*<RzBinAddr *>*/ *entry_vec, ut64 offset, int entry_type) {
RzBinAddr *entry = RZ_NEW0(RzBinAddr);
if (!entry) {
return;
@ -54,7 +54,7 @@ void luac_add_entry(RzList /*<RzBinAddr *>*/ *entry_list, ut64 offset, int entry
entry->paddr = offset;
entry->type = entry_type;
rz_list_append(entry_list, entry);
rz_pvector_push(entry_vec, entry);
}
void luac_add_string(RzList /*<RzBinString *>*/ *string_list, char *string, ut64 offset, ut64 size) {
@ -112,7 +112,7 @@ void luac_build_info_free(LuacBinInfo *bin_info) {
if (!bin_info) {
return;
}
rz_list_free(bin_info->entry_list);
rz_pvector_free(bin_info->entry_vec);
rz_list_free(bin_info->symbol_list);
rz_pvector_free(bin_info->section_vec);
rz_list_free(bin_info->string_list);
@ -130,13 +130,13 @@ LuacBinInfo *luac_build_info(LuaProto *proto) {
return NULL;
}
ret->entry_list = rz_list_newf((RzListFree)free_rz_addr);
ret->entry_vec = rz_pvector_new((RzPVectorFree)free_rz_addr);
ret->symbol_list = rz_list_newf((RzListFree)rz_bin_symbol_free);
ret->section_vec = rz_pvector_new((RzPVectorFree)free_rz_section);
ret->string_list = rz_list_newf((RzListFree)free_rz_string);
if (!(ret->entry_list && ret->symbol_list && ret->section_vec && ret->string_list)) {
rz_list_free(ret->entry_list);
if (!(ret->entry_vec && ret->symbol_list && ret->section_vec && ret->string_list)) {
rz_pvector_free(ret->entry_vec);
rz_list_free(ret->symbol_list);
rz_pvector_free(ret->section_vec);
rz_list_free(ret->string_list);
@ -147,7 +147,7 @@ LuacBinInfo *luac_build_info(LuaProto *proto) {
// add entry of main
ut64 main_entry_offset;
main_entry_offset = proto->code_offset + proto->code_skipped;
luac_add_entry(ret->entry_list, main_entry_offset, RZ_BIN_ENTRY_TYPE_PROGRAM);
luac_add_entry(ret->entry_vec, main_entry_offset, RZ_BIN_ENTRY_TYPE_PROGRAM);
return ret;
}

6
librz/bin/format/luac/luac_common.h
View file

@ -161,7 +161,7 @@ typedef struct luac_bin_info {
st32 minor; ///< minor version
RzPVector /*<RzBinSection *>*/ *section_vec; ///< list of sections
RzList /*<RzBinSymbol *>*/ *symbol_list; ///< list of symbols
RzList /*<RzBinAddr *>*/ *entry_list; ///< list of entries
RzPVector /*<RzBinAddr *>*/ *entry_vec; ///< list of entries
RzList /*<RzBinString *>*/ *string_list; ///< list of strings
RzBinInfo *general_info; ///< general binary info from luac header
} LuacBinInfo;
@ -187,9 +187,9 @@ void lua_free_proto_entry(LuaProto *);
* Common Operation to RzBinInfo
* Implemented in 'bin/format/luac/luac_bin.c'
* ======================================================== */
void luac_add_section(RzPVector /*<RzBinSection *>*/ *section_list, char *name, ut64 offset, ut32 size, bool is_func);
void luac_add_section(RzPVector /*<RzBinSection *>*/ *section_vec, char *name, ut64 offset, ut32 size, bool is_func);
void luac_add_symbol(RzList /*<RzBinSymbol *>*/ *symbol_list, char *name, ut64 offset, ut64 size, const char *type);
void luac_add_entry(RzList /*<RzBinAddr *>*/ *entry_list, ut64 offset, int entry_type);
void luac_add_entry(RzPVector /*<RzBinAddr *>*/ *entry_vec, ut64 offset, int entry_type);
void luac_add_string(RzList /*<RzBinString *>*/ *string_list, char *string, ut64 offset, ut64 size);
LuacBinInfo *luac_build_info(LuaProto *proto);

12
librz/bin/format/mdmp/mdmp_pe.c
View file

@ -7,7 +7,7 @@
#include "mdmp_pe.h"
static void PE_(add_tls_callbacks)(struct PE_(rz_bin_pe_obj_t) * bin, RzList /*<RzBinAddr *>*/ *list) {
static void PE_(add_tls_callbacks)(struct PE_(rz_bin_pe_obj_t) * bin, RzPVector /*<RzBinAddr *>*/ *vec) {
char *key;
int count = 0;
PE_DWord haddr, paddr, vaddr;
@ -37,22 +37,22 @@ static void PE_(add_tls_callbacks)(struct PE_(rz_bin_pe_obj_t) * bin, RzList /*<
ptr->vaddr = vaddr;
ptr->hpaddr = haddr;
ptr->type = RZ_BIN_ENTRY_TYPE_TLS;
rz_list_append(list, ptr);
rz_pvector_push(vec, ptr);
}
count++;
} while (vaddr);
}
RzList /*<RzBinAddr *>*/ *PE_(rz_bin_mdmp_pe_get_entrypoint)(struct PE_(rz_bin_mdmp_pe_bin) * pe_bin) {
RzPVector /*<RzBinAddr *>*/ *PE_(rz_bin_mdmp_pe_get_entrypoint)(struct PE_(rz_bin_mdmp_pe_bin) * pe_bin) {
ut64 offset;
struct rz_bin_pe_addr_t *entry = NULL;
RzBinAddr *ptr = NULL;
RzList *ret;
RzPVector *ret;
if (!(entry = PE_(rz_bin_pe_get_entrypoint)(pe_bin->bin))) {
return NULL;
}
if (!(ret = rz_list_new())) {
if (!(ret = rz_pvector_new(NULL))) {
free(entry);
return NULL;
}
@ -67,7 +67,7 @@ RzList /*<RzBinAddr *>*/ *PE_(rz_bin_mdmp_pe_get_entrypoint)(struct PE_(rz_bin_m
ptr->hpaddr = pe_bin->paddr + entry->haddr;
ptr->type = RZ_BIN_ENTRY_TYPE_PROGRAM;
rz_list_append(ret, ptr);
rz_pvector_push(ret, ptr);
}
PE_(add_tls_callbacks)

2
librz/bin/format/mdmp/mdmp_pe.h
View file

@ -20,7 +20,7 @@ struct PE_(rz_bin_mdmp_pe_bin) {
struct PE_(rz_bin_pe_obj_t) * bin;
};
RzList /*<RzBinAddr *>*/ *PE_(rz_bin_mdmp_pe_get_entrypoint)(struct PE_(rz_bin_mdmp_pe_bin) * pe_bin);
RzPVector /*<RzBinAddr *>*/ *PE_(rz_bin_mdmp_pe_get_entrypoint)(struct PE_(rz_bin_mdmp_pe_bin) * pe_bin);
RzPVector /*<RzBinImport *>*/ *PE_(rz_bin_mdmp_pe_get_imports)(struct PE_(rz_bin_mdmp_pe_bin) * pe_bin);
RzPVector /*<RzBinSection *>*/ *PE_(rz_bin_mdmp_pe_get_sections)(struct PE_(rz_bin_mdmp_pe_bin) * pe_bin);
RzList /*<RzBinSymbol *>*/ *PE_(rz_bin_mdmp_pe_get_symbols)(RzBin *rbin, struct PE_(rz_bin_mdmp_pe_bin) * pe_bin);

27
librz/bin/format/ne/ne.c
View file

@ -125,7 +125,7 @@ RzPVector /*<RzBinSymbol *>*/ *rz_bin_ne_get_symbols(rz_bin_ne_obj_t *bin) {
if (!symbols) {
return NULL;
}
RzList *entries = rz_bin_ne_get_entrypoints(bin);
RzPVector *entries = rz_bin_ne_get_entrypoints(bin);
bool resident = true, first = true;
while (true) {
ut8 sz;
@ -170,7 +170,7 @@ RzPVector /*<RzBinSymbol *>*/ *rz_bin_ne_get_symbols(rz_bin_ne_obj_t *bin) {
break;
}
off += 2;
RzBinAddr *entry = rz_list_get_n(entries, entry_off);
RzBinAddr *entry = (RzBinAddr *)rz_pvector_at(entries, entry_off);
if (entry) {
sym->paddr = entry->paddr;
} else {
@ -180,10 +180,11 @@ RzPVector /*<RzBinSymbol *>*/ *rz_bin_ne_get_symbols(rz_bin_ne_obj_t *bin) {
rz_pvector_push(symbols, sym);
first = false;
}
RzListIter *it;
void **it;
RzBinAddr *en;
int i = 1;
rz_list_foreach (entries, it, en) {
rz_pvector_foreach (entries, it) {
en = *it;
if (!rz_pvector_find(symbols, &en->paddr, __find_symbol_by_paddr, NULL)) {
sym = RZ_NEW0(RzBinSymbol);
if (!sym) {
@ -390,28 +391,28 @@ RzPVector /*<RzBinImport *>*/ *rz_bin_ne_get_imports(rz_bin_ne_obj_t *bin) {
return imports;
}
RzList /*<RzBinAddr *>*/ *rz_bin_ne_get_entrypoints(rz_bin_ne_obj_t *bin) {
RzList *entries = rz_list_newf(free);
RzPVector /*<RzBinAddr *>*/ *rz_bin_ne_get_entrypoints(rz_bin_ne_obj_t *bin) {
RzPVector *entries = rz_pvector_new(free);
if (!entries) {
return NULL;
}
RzBinAddr *entry;
RzPVector *segments = rz_bin_ne_get_segments(bin);
if (!segments) {
rz_list_free(entries);
rz_pvector_free(entries);
return NULL;
}
if (bin->ne_header->csEntryPoint) {
entry = RZ_NEW0(RzBinAddr);
if (!entry) {
rz_list_free(entries);
rz_pvector_free(entries);
rz_pvector_free(segments);
return NULL;
}
entry->bits = 16;
RzBinSection *s = (RzBinSection *)rz_pvector_at(segments, bin->ne_header->csEntryPoint - 1);
entry->paddr = bin->ne_header->ipEntryPoint + (s ? s->paddr : 0);
rz_list_append(entries, entry);
rz_pvector_push(entries, entry);
}
ut32 off = 0;
while (off < bin->ne_header->EntryTableLength) {
@ -429,7 +430,7 @@ RzList /*<RzBinAddr *>*/ *rz_bin_ne_get_entrypoints(rz_bin_ne_obj_t *bin) {
for (i = 0; i < bundle_length; i++) {
entry = RZ_NEW0(RzBinAddr);
if (!entry) {
rz_list_free(entries);
rz_pvector_free(entries);
rz_pvector_free(segments);
return NULL;
}
@ -465,7 +466,7 @@ RzList /*<RzBinAddr *>*/ *rz_bin_ne_get_entrypoints(rz_bin_ne_obj_t *bin) {
entry->paddr = (ut64)bin->segment_entries[bundle_type - 1].offset * bin->alignment + rz_read_le16(p);
}
off += 2;
rz_list_append(entries, entry);
rz_pvector_push(entries, entry);
}
}
end:
@ -479,7 +480,7 @@ RzPVector /*<RzBinReloc *>*/ *rz_bin_ne_get_relocs(rz_bin_ne_obj_t *bin) {
if (!segments) {
return NULL;
}
RzList *entries = bin->entries;
RzPVector *entries = bin->entries;
if (!entries) {
return NULL;
}
@ -589,7 +590,7 @@ RzPVector /*<RzBinReloc *>*/ *rz_bin_ne_get_relocs(rz_bin_ne_obj_t *bin) {
offset = -1;
}
} else {
RzBinAddr *entry = rz_list_get_n(entries, rel.entry_ordinal - 1);
RzBinAddr *entry = (RzBinAddr *)rz_pvector_at(entries, rel.entry_ordinal - 1);
if (entry) {
offset = entry->paddr;
} else {

4
librz/bin/format/ne/ne.h
View file

@ -29,7 +29,7 @@ typedef struct {
ut8 *resident_name_table;
RzBuffer *buf;
RzPVector /*<RzBinSection *>*/ *segments;
RzList /*<RzBinAddr *>*/ *entries;
RzPVector /*<RzBinAddr *>*/ *entries;
RzList /*<rz_ne_resource *>*/ *resources;
RzPVector /*<RzBinImport *>*/ *imports;
RzPVector /*<RzBinSymbol *>*/ *symbols;
@ -42,6 +42,6 @@ RzPVector /*<RzBinReloc *>*/ *rz_bin_ne_get_relocs(rz_bin_ne_obj_t *bin);
RzPVector /*<RzBinImport *>*/ *rz_bin_ne_get_imports(rz_bin_ne_obj_t *bin);
RzPVector /*<RzBinSymbol *>*/ *rz_bin_ne_get_symbols(rz_bin_ne_obj_t *bin);
RzPVector /*<RzBinSection *>*/ *rz_bin_ne_get_segments(rz_bin_ne_obj_t *bin);
RzList /*<RzBinAddr *>*/ *rz_bin_ne_get_entrypoints(rz_bin_ne_obj_t *bin);
RzPVector /*<RzBinAddr *>*/ *rz_bin_ne_get_entrypoints(rz_bin_ne_obj_t *bin);
#endif

6
librz/bin/p/bin_art.c
View file

@ -133,13 +133,13 @@ static bool check_buffer(RzBuffer *buf) {
return r == 4 && !strncmp(tmp, "art\n", 4);
}
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzList *ret = rz_list_newf(free);
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzPVector *ret = rz_pvector_new(free);
if (ret) {
RzBinAddr *ptr = RZ_NEW0(RzBinAddr);
if (ptr) {
ptr->paddr = ptr->vaddr = 0;
rz_list_append(ret, ptr);
rz_pvector_push(ret, ptr);
}
}
return ret;

9
librz/bin/p/bin_avr.c
View file

@ -139,20 +139,19 @@ static RzBinInfo *info(RzBinFile *bf) {
return bi;
}
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzList *ret;
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzPVector *ret;
RzBinAddr *ptr = NULL;
if (tmp_entry == UT64_MAX) {
return false;
}
if (!(ret = rz_list_new())) {
if (!(ret = rz_pvector_new(free))) {
return NULL;
}
ret->free = free;
if ((ptr = RZ_NEW0(RzBinAddr))) {
ut64 addr = tmp_entry;
ptr->vaddr = ptr->paddr = addr;
rz_list_append(ret, ptr);
rz_pvector_push(ret, ptr);
}
return ret;
}

8
librz/bin/p/bin_bf.c
View file

@ -98,18 +98,18 @@ static bool check_filename(const char *filename) {
return rz_str_endswith_icase(filename, ".bf");
}
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzList *ret;
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzPVector *ret;
RzBinAddr *ptr = NULL;
if (!(ret = rz_list_newf(free))) {
if (!(ret = rz_pvector_new(free))) {
return NULL;
}
if (!(ptr = RZ_NEW0(RzBinAddr))) {
return ret;
}
ptr->paddr = ptr->vaddr = 0;
rz_list_append(ret, ptr);
rz_pvector_push(ret, ptr);
return ret;
}

10
librz/bin/p/bin_bflt.c
View file

@ -16,20 +16,20 @@ static bool load_buffer(RzBinFile *bf, RzBinObject *obj, RzBuffer *buf, Sdb *sdb
return obj->bin_obj;
}
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzBfltObj *obj = bf->o->bin_obj;
RzList *ret;
RzPVector *ret;
RzBinAddr *ptr;
if (!(ret = rz_list_newf(free))) {
if (!(ret = rz_pvector_new(free))) {
return NULL;
}
ptr = rz_bflt_get_entry(obj);
if (!ptr) {
rz_list_free(ret);
rz_pvector_free(ret);
return NULL;
}
rz_list_append(ret, ptr);
rz_pvector_push(ret, ptr);
return ret;
}

9
librz/bin/p/bin_bios.c
View file

@ -117,19 +117,18 @@ static RzPVector /*<RzBinSection *>*/ *sections(RzBinFile *bf) {
return ret;
}
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzList *ret;
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzPVector *ret;
RzBinAddr *ptr = NULL;
if (!(ret = rz_list_new())) {
if (!(ret = rz_pvector_new(free))) {
return NULL;
}
ret->free = free;
if (!(ptr = RZ_NEW0(RzBinAddr))) {
return ret;
}
ptr->paddr = 0; // 0x70000;
ptr->vaddr = 0xffff0;
rz_list_append(ret, ptr);
rz_pvector_push(ret, ptr);
return ret;
}

8
librz/bin/p/bin_bootimg.c
View file

@ -152,16 +152,16 @@ static bool check_buffer(RzBuffer *buf) {
return r > 12 && !strncmp((const char *)tmp, "ANDROID!", 8);
}
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
BootImageObj *bio = bf->o->bin_obj;
RzBinAddr *ptr = NULL;
if (!bio) {
return NULL;
}
BootImage *bi = &bio->bi;
RzList *ret;
RzPVector *ret;
if (!(ret = rz_list_newf(free))) {
if (!(ret = rz_pvector_new(free))) {
return NULL;
}
if (!(ptr = RZ_NEW0(RzBinAddr))) {
@ -169,7 +169,7 @@ static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
}
ptr->paddr = bi->page_size;
ptr->vaddr = bi->kernel_addr;
rz_list_append(ret, ptr);
rz_pvector_push(ret, ptr);
return ret;
}

8
librz/bin/p/bin_coff.c
View file

@ -167,15 +167,15 @@ static RzBinImport *_fill_bin_import(struct rz_bin_coff_obj *bin, int idx) {
return ptr;
}
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
struct rz_bin_coff_obj *obj = (struct rz_bin_coff_obj *)bf->o->bin_obj;
RzList *ret;
if (!(ret = rz_list_newf(free))) {
RzPVector *ret;
if (!(ret = rz_pvector_new(free))) {
return NULL;
}
RzBinAddr *ptr = rz_coff_get_entry(obj);
if (ptr) {
rz_list_append(ret, ptr);
rz_pvector_push(ret, ptr);
}
return ret;
}

2
librz/bin/p/bin_dex.c
View file

@ -122,7 +122,7 @@ static RzBinAddr *binsym(RzBinFile *bf, RzBinSpecialSymbol sym) {
return rz_bin_dex_resolve_symbol(dex, sym);
}
static RzList /*<RzBinAddr *>*/ *entrypoints(RzBinFile *bf) {
static RzPVector /*<RzBinAddr *>*/ *entrypoints(RzBinFile *bf) {
RzBinDex *dex = rz_bin_file_get_dex(bf);
if (!dex) {
return NULL;

6
librz/bin/p/bin_dol.c
View file

@ -134,14 +134,14 @@ static RzPVector /*<RzBinSection *>*/ *sections(RzBinFile *bf) {
return ret;
}
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
rz_return_val_if_fail(bf && bf->o && bf->o->bin_obj, NULL);
RzList *ret = rz_list_new();
RzPVector *ret = rz_pvector_new(NULL);
RzBinAddr *addr = RZ_NEW0(RzBinAddr);
DolHeader *dol = bf->o->bin_obj;
addr->vaddr = (ut64)dol->entrypoint;
addr->paddr = addr->vaddr & 0xFFFF;
rz_list_append(ret, addr);
rz_pvector_push(ret, addr);
return ret;
}

6
librz/bin/p/bin_dyldcache.c
View file

@ -81,14 +81,14 @@ static bool load_buffer(RzBinFile *bf, RzBinObject *obj, RzBuffer *buf, Sdb *sdb
return true;
}
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzBinAddr *ptr = NULL;
RzList *ret = rz_list_newf(free);
RzPVector *ret = rz_pvector_new(free);
if (!ret) {
return NULL;
}
if ((ptr = RZ_NEW0(RzBinAddr))) {
rz_list_append(ret, ptr);
rz_pvector_push(ret, ptr);
}
return ret;
}

18
librz/bin/p/bin_elf.inc
View file

@ -273,7 +273,7 @@ static RzBinAddr *binsym(RzBinFile *bf, RzBinSpecialSymbol sym) {
return rz_bin_addr_new_from_paddr(bin, paddr);
}
static void add_constructor(ELFOBJ *bin, ut64 addr, ut64 size, int type, RzList /*<RzBinAddr *>*/ *result) {
static void add_constructor(ELFOBJ *bin, ut64 addr, ut64 size, int type, RzPVector /*<RzBinAddr *>*/ *result) {
ut64 constructor_offset = Elf_(rz_bin_elf_v2p)(bin, addr);
if (constructor_offset == UT64_MAX) {
return;
@ -303,13 +303,13 @@ static void add_constructor(ELFOBJ *bin, ut64 addr, ut64 size, int type, RzList
tmp->hvaddr = addr + pos;
tmp->type = type;
rz_list_append(result, tmp);
rz_pvector_push(result, tmp);
pos += sizeof(Elf_(Addr));
}
}
static void add_constructors(ELFOBJ *bin, RzList /*<RzBinAddr *>*/ *result) {
static void add_constructors(ELFOBJ *bin, RzPVector /*<RzBinAddr *>*/ *result) {
ut64 addr, size;
if (Elf_(rz_bin_elf_get_dt_info)(bin, DT_PREINIT_ARRAY, &addr) && Elf_(rz_bin_elf_get_dt_info)(bin, DT_PREINIT_ARRAYSZ, &size)) {
@ -325,7 +325,7 @@ static void add_constructors(ELFOBJ *bin, RzList /*<RzBinAddr *>*/ *result) {
}
}
static void add_entry_offset(ELFOBJ *bin, RzList /*<RzBinAddr *>*/ *result) {
static void add_entry_offset(ELFOBJ *bin, RzPVector /*<RzBinAddr *>*/ *result) {
ut64 paddr = Elf_(rz_bin_elf_get_entry_offset)(bin);
if (paddr == UT64_MAX) {
return;
@ -343,28 +343,28 @@ static void add_entry_offset(ELFOBJ *bin, RzList /*<RzBinAddr *>*/ *result) {
RZ_LOG_ERROR("Cannot determine entrypoint, using 0x%08" PFMT64x ".\n", tmp->vaddr);
}
rz_list_append(result, tmp);
rz_pvector_push(result, tmp);
}
static void add_java_libraries(ELFOBJ *bin, RzList /*<RzBinAddr *>*/ *result) {
static void add_java_libraries(ELFOBJ *bin, RzPVector /*<RzBinAddr *>*/ *result) {
RzBinElfSymbol *symbol;
rz_bin_elf_foreach_symbols(bin, symbol) {
if (symbol->name && rz_str_startswith(symbol->name, "Java") && rz_str_endswith(symbol->name, "_init")) {
RzBinAddr *tmp = rz_bin_addr_new_from_paddr(bin, symbol->paddr);
tmp->type = RZ_BIN_ENTRY_TYPE_INIT;
rz_list_append(result, tmp);
rz_pvector_push(result, tmp);
break;
}
}
}
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
rz_return_val_if_fail(bf && bf->o, NULL);
ELFOBJ *bin = rz_bin_file_get_elf(bf);
RzList *result = rz_list_newf((RzListFree)free);
RzPVector *result = rz_pvector_new((RzPVectorFree)free);
if (!result) {
return NULL;
}

2
librz/bin/p/bin_java.c
View file

@ -149,7 +149,7 @@ static RzBinAddr *binsym(RzBinFile *bf, RzBinSpecialSymbol sym) {
return rz_bin_java_class_resolve_symbol(jclass, sym);
}
static RzList /*<RzBinAddr *>*/ *entrypoints(RzBinFile *bf) {
static RzPVector /*<RzBinAddr *>*/ *entrypoints(RzBinFile *bf) {
RzBinJavaClass *jclass = rz_bin_file_get_java_class(bf);
if (!jclass) {
return NULL;

4
librz/bin/p/bin_luac.c
View file

@ -112,7 +112,7 @@ static RzPVector /*<RzBinSymbol *>*/ *symbols(RzBinFile *bf) {
return vec;
}
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
if (!bf) {
return NULL;
}
@ -121,7 +121,7 @@ static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
return NULL;
}
return rz_list_clone(bin_info_obj->entry_list);
return rz_pvector_clone(bin_info_obj->entry_vec);
}
static RzPVector /*<RzBinString *>*/ *strings(RzBinFile *bf) {

12
librz/bin/p/bin_mach0.c
View file

@ -94,7 +94,7 @@ static RzBinAddr *newEntry(ut64 hpaddr, ut64 paddr, int type, int bits) {
return ptr;
}
static void process_constructors(RzBinFile *bf, RzList /*<RzBinAddr *>*/ *ret, int bits) {
static void process_constructors(RzBinFile *bf, RzPVector /*<RzBinAddr *>*/ *ret, int bits) {
RzPVector *secs = sections(bf);
void **iter;
RzBinSection *sec;
@ -122,7 +122,7 @@ static void process_constructors(RzBinFile *bf, RzList /*<RzBinAddr *>*/ *ret, i
ut32 addr32 = rz_read_le32(buf + i);
RzBinAddr *ba = newEntry(sec->paddr + i, (ut64)addr32, type, bits);
if (ba) {
rz_list_append(ret, ba);
rz_pvector_push(ret, ba);
}
}
} else {
@ -130,7 +130,7 @@ static void process_constructors(RzBinFile *bf, RzList /*<RzBinAddr *>*/ *ret, i
ut64 addr64 = rz_read_le64(buf + i);
RzBinAddr *ba = newEntry(sec->paddr + i, addr64, type, bits);
if (ba) {
rz_list_append(ret, ba);
rz_pvector_push(ret, ba);
}
}
}
@ -139,13 +139,13 @@ static void process_constructors(RzBinFile *bf, RzList /*<RzBinAddr *>*/ *ret, i
}
}
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
rz_return_val_if_fail(bf && bf->o, NULL);
RzBinAddr *ptr = NULL;
struct addr_t *entry = NULL;
RzList *ret = rz_list_newf(free);
RzPVector *ret = rz_pvector_new(free);
if (!ret) {
return NULL;
}
@ -166,7 +166,7 @@ static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
ptr->vaddr--;
}
}
rz_list_append(ret, ptr);
rz_pvector_push(ret, ptr);
}
process_constructors(bf, ret, bits);

6
librz/bin/p/bin_mbn.c
View file

@ -85,15 +85,15 @@ static ut64 baddr(RzBinFile *bf) {
return sb->vaddr;
}
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
SblHeader *sb = mbn_file_get_hdr(bf);
RzList *ret = rz_list_newf(free);
RzPVector *ret = rz_pvector_new(free);
if (ret) {
RzBinAddr *ptr = RZ_NEW0(RzBinAddr);
if (ptr) {
ptr->paddr = 40 + sb->code_pa;
ptr->vaddr = 40 + sb->code_pa + sb->vaddr;
rz_list_append(ret, ptr);
rz_pvector_push(ret, ptr);
}
}
return ret;

18
librz/bin/p/bin_mdmp.c
View file

@ -20,28 +20,28 @@ static void mdmp_destroy(RzBinFile *bf) {
rz_bin_mdmp_free((MiniDmpObj *)bf->o->bin_obj);
}
static RzList /*<RzBinAddr *>*/ *mdmp_entries(RzBinFile *bf) {
static RzPVector /*<RzBinAddr *>*/ *mdmp_entries(RzBinFile *bf) {
MiniDmpObj *obj;
struct Pe32_rz_bin_mdmp_pe_bin *pe32_bin;
struct Pe64_rz_bin_mdmp_pe_bin *pe64_bin;
RzListIter *it;
RzList *ret, *list;
RzPVector *ret, *vec;
if (!(ret = rz_list_newf(free))) {
if (!(ret = rz_pvector_new(free))) {
return NULL;
}
obj = (MiniDmpObj *)bf->o->bin_obj;
rz_list_foreach (obj->pe32_bins, it, pe32_bin) {
list = Pe32_rz_bin_mdmp_pe_get_entrypoint(pe32_bin);
rz_list_join(ret, list);
rz_list_free(list);
vec = Pe32_rz_bin_mdmp_pe_get_entrypoint(pe32_bin);
rz_pvector_join(ret, vec);
rz_pvector_free(vec);
}
rz_list_foreach (obj->pe64_bins, it, pe64_bin) {
list = Pe64_rz_bin_mdmp_pe_get_entrypoint(pe64_bin);
rz_list_join(ret, list);
rz_list_free(list);
vec = Pe64_rz_bin_mdmp_pe_get_entrypoint(pe64_bin);
rz_pvector_join(ret, vec);
rz_pvector_free(vec);
}
return ret;

9
librz/bin/p/bin_menuet.c
View file

@ -84,8 +84,8 @@ static ut64 menuetEntry(const ut8 *buf, int buf_size) {
return UT64_MAX;
}
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzList *ret;
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzPVector *ret;
ut8 buf[64] = { 0 };
RzBinAddr *ptr = NULL;
const int buf_size = RZ_MIN(sizeof(buf), rz_buf_size(bf->buf));
@ -95,14 +95,13 @@ static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
if (entry == UT64_MAX) {
return NULL;
}
if (!(ret = rz_list_new())) {
if (!(ret = rz_pvector_new(free))) {
return NULL;
}
ret->free = free;
if ((ptr = RZ_NEW0(RzBinAddr))) {
ptr->paddr = rz_read_ble32(buf + 12, false);
ptr->vaddr = ptr->paddr + baddr(bf);
rz_list_append(ret, ptr);
rz_pvector_push(ret, ptr);
}
return ret;
}

8
librz/bin/p/bin_mz.c
View file

@ -149,15 +149,15 @@ static RzBinAddr *binsym(RzBinFile *bf, RzBinSpecialSymbol type) {
return mzaddr;
}
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzBinAddr *ptr = NULL;
RzList *res = NULL;
if (!(res = rz_list_newf(free))) {
RzPVector *res = NULL;
if (!(res = rz_pvector_new(free))) {
return NULL;
}
ptr = rz_bin_mz_get_entrypoint(bf->o->bin_obj);
if (ptr) {
rz_list_append(res, ptr);
rz_pvector_push(res, ptr);
}
return res;
}

2
librz/bin/p/bin_ne.c
View file

@ -95,7 +95,7 @@ RzBinInfo *info(RzBinFile *bf) {
return i;
}
RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
return rz_bin_ne_get_entrypoints(bf->o->bin_obj);
}

8
librz/bin/p/bin_nes.c
View file

@ -199,10 +199,10 @@ static RzPVector /*<RzBinMem *>*/ *mem(RzBinFile *bf) {
return ret;
}
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) { // Should be 3 offsets pointed by NMI, RESET, IRQ after mapping && default = 1st CHR
RzList *ret;
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) { // Should be 3 offsets pointed by NMI, RESET, IRQ after mapping && default = 1st CHR
RzPVector *ret;
RzBinAddr *ptr = NULL;
if (!(ret = rz_list_new())) {
if (!(ret = rz_pvector_new(NULL))) {
return NULL;
}
if (!(ptr = RZ_NEW0(RzBinAddr))) {
@ -210,7 +210,7 @@ static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) { // Should be 3 offsets
}
ptr->paddr = INES_HDR_SIZE;
ptr->vaddr = ROM_START_ADDRESS;
rz_list_append(ret, ptr);
rz_pvector_push(ret, ptr);
return ret;
}

10
librz/bin/p/bin_nin3ds.c
View file

@ -161,17 +161,17 @@ static RzPVector /*<RzBinSection *>*/ *n3ds_sections(RzBinFile *bf) {
return ret;
}
static RzList /*<RzBinAddr *>*/ *n3ds_entries(RzBinFile *bf) {
static RzPVector /*<RzBinAddr *>*/ *n3ds_entries(RzBinFile *bf) {
if (!bf || !bf->o) {
return NULL;
}
RzBinAddr *ptr9 = NULL, *ptr11 = NULL;
RzList *ret = rz_list_newf(free);
RzPVector *ret = rz_pvector_new(free);
if (!ret ||
!(ptr9 = RZ_NEW0(RzBinAddr)) ||
!(ptr11 = RZ_NEW0(RzBinAddr))) {
rz_list_free(ret);
rz_pvector_free(ret);
free(ptr9);
return NULL;
}
@ -179,11 +179,11 @@ static RzList /*<RzBinAddr *>*/ *n3ds_entries(RzBinFile *bf) {
/* ARM9 entry point */
ptr9->vaddr = hdr->arm9_ep;
rz_list_append(ret, ptr9);
rz_pvector_push(ret, ptr9);
/* ARM11 entry point */
ptr11->vaddr = hdr->arm11_ep;
rz_list_append(ret, ptr11);
rz_pvector_push(ret, ptr11);
for (size_t i = 0; i < 4; i++) {
N3DSFirmSectHdr *shdr = &hdr->sections[i];

12
librz/bin/p/bin_ninds.c
View file

@ -150,17 +150,17 @@ static RzPVector /*<RzBinSection *>*/ *nds_sections(RzBinFile *bf) {
return ret;
}
static RzList /*<RzBinAddr *>*/ *nds_entries(RzBinFile *bf) {
static RzPVector /*<RzBinAddr *>*/ *nds_entries(RzBinFile *bf) {
if (!bf || !bf->buf) {
return NULL;
}
RzBinAddr *ptr9 = NULL, *ptr7 = NULL;
RzList *ret = NULL;
RzPVector *ret = NULL;
if (!(ret = rz_list_newf(free)) ||
if (!(ret = rz_pvector_new(free)) ||
!(ptr9 = RZ_NEW0(RzBinAddr)) ||
!(ptr7 = RZ_NEW0(RzBinAddr))) {
rz_list_free(ret);
rz_pvector_free(ret);
free(ptr9);
return NULL;
}
@ -169,12 +169,12 @@ static RzList /*<RzBinAddr *>*/ *nds_entries(RzBinFile *bf) {
/* ARM9 entry point */
ptr9->vaddr = hdr->arm9_entry_address;
ptr9->paddr = hdr->arm9_rom_offset + (hdr->arm9_entry_address - hdr->arm9_ram_address);
rz_list_append(ret, ptr9);
rz_pvector_push(ret, ptr9);
/* ARM7 entry point */
ptr7->vaddr = hdr->arm7_entry_address;
ptr7->paddr = hdr->arm7_rom_offset + (hdr->arm7_entry_address - hdr->arm7_ram_address);
rz_list_append(ret, ptr7);
rz_pvector_push(ret, ptr7);
return ret;
}

7
librz/bin/p/bin_ningb.c
View file

@ -110,20 +110,19 @@ static RzBinAddr *binsym(RzBinFile *bf, RzBinSpecialSymbol type) {
return NULL;
}
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzList *ret = rz_list_new();
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzPVector *ret = rz_pvector_new(free);
RzBinAddr *ptr = NULL;
if (bf && bf->buf != NULL) {
if (!ret) {
return NULL;
}
ret->free = free;
if (!(ptr = RZ_NEW0(RzBinAddr))) {
return ret;
}
ptr->paddr = ptr->vaddr = ptr->hpaddr = 0x100;
rz_list_append(ret, ptr);
rz_pvector_push(ret, ptr);
}
return ret;
}

6
librz/bin/p/bin_ningba.c
View file

@ -19,8 +19,8 @@ static bool load_buffer(RzBinFile *bf, RzBinObject *obj, RzBuffer *buf, Sdb *sdb
return check_buffer(buf);
}
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzList *ret = rz_list_newf(free);
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzPVector *ret = rz_pvector_new(free);
RzBinAddr *ptr = NULL;
if (bf && bf->buf) {
@ -31,7 +31,7 @@ static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
return ret;
}
ptr->paddr = ptr->vaddr = 0x8000000;
rz_list_append(ret, ptr);
rz_pvector_push(ret, ptr);
}
return ret;
}

9
librz/bin/p/bin_nro.c
View file

@ -73,17 +73,16 @@ static RzBinAddr *binsym(RzBinFile *bf, RzBinSpecialSymbol type) {
return NULL; // TODO
}
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzList *ret;
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzPVector *ret;
RzBinAddr *ptr = NULL;
if (!(ret = rz_list_new())) {
if (!(ret = rz_pvector_new(free))) {
return NULL;
}
ret->free = free;
if ((ptr = RZ_NEW0(RzBinAddr))) {
ptr->paddr = 0x80;
ptr->vaddr = ptr->paddr + baddr(bf);
rz_list_append(ret, ptr);
rz_pvector_push(ret, ptr);
}
return ret;
}

16
librz/bin/p/bin_nso.c
View file

@ -191,32 +191,30 @@ static RzBinAddr *binsym(RzBinFile *bf, RzBinSpecialSymbol type) {
return NULL; // TODO
}
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzList *ret;
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzPVector *ret;
RzBuffer *b = bf->buf;
if (!(ret = rz_list_new())) {
if (!(ret = rz_pvector_new(free))) {
return NULL;
}
ret->free = free;
RzBinAddr *ptr = RZ_NEW0(RzBinAddr);
if (!ptr) {
rz_list_free(ret);
rz_pvector_free(ret);
return NULL;
}
ut32 tmp;
if (!rz_buf_read_le32_at(b, NSO_OFF(text_memoffset), &tmp)) {
rz_list_free(ret);
rz_pvector_free(ret);
free(ptr);
return NULL;
}
ptr->paddr = tmp;
if (!rz_buf_read_le32_at(b, NSO_OFF(text_loc), &tmp)) {
rz_list_free(ret);
rz_pvector_free(ret);
free(ptr);
return NULL;
}
@ -224,7 +222,7 @@ static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
ptr->vaddr += baddr(bf);
rz_list_append(ret, ptr);
rz_pvector_push(ret, ptr);
return ret;
}

10
librz/bin/p/bin_omf.c
View file

@ -67,21 +67,21 @@ static ut64 baddr(RzBinFile *bf) {
return OMF_BASE_ADDR;
}
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzList *ret;
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzPVector *ret;
RzBinAddr *addr;
if (!(ret = rz_list_newf(free))) {
if (!(ret = rz_pvector_new(free))) {
return NULL;
}
if (!(addr = RZ_NEW0(RzBinAddr))) {
rz_list_free(ret);
rz_pvector_free(ret);
return NULL;
}
if (!rz_bin_omf_get_entry(bf->o->bin_obj, addr)) {
RZ_FREE(addr);
} else {
rz_list_append(ret, addr);
rz_pvector_push(ret, addr);
}
return ret;
}

9
librz/bin/p/bin_p9.c
View file

@ -28,18 +28,17 @@ static RzBinAddr *binsym(RzBinFile *bf, RzBinSpecialSymbol type) {
return NULL; // TODO
}
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzList *ret;
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzPVector *ret;
RzBinAddr *ptr = NULL;
if (!(ret = rz_list_new())) {
if (!(ret = rz_pvector_new(free))) {
return NULL;
}
ret->free = free;
if ((ptr = RZ_NEW0(RzBinAddr))) {
ptr->paddr = 8 * 4;
ptr->vaddr = 8 * 4; // + baddr (bf);
rz_list_append(ret, ptr);
rz_pvector_push(ret, ptr);
}
return ret;
}

12
librz/bin/p/bin_pe.inc
View file

@ -60,7 +60,7 @@ static RzBinAddr *binsym(RzBinFile *bf, RzBinSpecialSymbol type) {
return ret;
}
static void add_tls_callbacks(RzBinFile *bf, RzList /*<RzBinAddr *>*/ *list) {
static void add_tls_callbacks(RzBinFile *bf, RzPVector /*<RzBinAddr *>*/ *vec) {
PE_DWord paddr, vaddr, haddr;
int count = 0;
RzBinAddr *ptr = NULL;
@ -91,18 +91,18 @@ static void add_tls_callbacks(RzBinFile *bf, RzList /*<RzBinAddr *>*/ *list) {
ptr->vaddr = vaddr;
ptr->hpaddr = haddr;
ptr->type = RZ_BIN_ENTRY_TYPE_TLS;
rz_list_append(list, ptr);
rz_pvector_push(vec, ptr);
}
count++;
} while (vaddr);
}
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
struct rz_bin_pe_addr_t *entry = NULL;
RzBinAddr *ptr = NULL;
RzList *ret;
RzPVector *ret;
if (!(ret = rz_list_newf(free))) {
if (!(ret = rz_pvector_new(free))) {
return NULL;
}
if (!(entry = PE_(rz_bin_pe_get_entrypoint)(bf->o->bin_obj))) {
@ -113,7 +113,7 @@ static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
ptr->vaddr = entry->vaddr;
ptr->hpaddr = entry->haddr;
ptr->type = RZ_BIN_ENTRY_TYPE_PROGRAM;
rz_list_append(ret, ptr);
rz_pvector_push(ret, ptr);
}
free(entry);
// get TLS callback addresses

9
librz/bin/p/bin_pebble.c
View file

@ -160,24 +160,23 @@ static RzList* relocs(RzBinFile *bf) {
}
#endif
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzBinAddr *ptr = NULL;
RzList *ret;
RzPVector *ret;
PebbleAppInfo pai;
if (!rz_buf_read_at(bf->buf, 0, (ut8 *)&pai, sizeof(pai))) {
RZ_LOG_ERROR("Truncated Header\n");
return NULL;
}
if (!(ret = rz_list_new())) {
if (!(ret = rz_pvector_new(free))) {
return NULL;
}
ret->free = free;
if (!(ptr = RZ_NEW0(RzBinAddr))) {
return ret;
}
ptr->paddr = pai.offset;
ptr->vaddr = pai.offset;
rz_list_append(ret, ptr);
rz_pvector_push(ret, ptr);
return ret;
}

6
librz/bin/p/bin_prg.c
View file

@ -60,8 +60,8 @@ static RzPVector /*<RzBinSection *>*/ *sections(RzBinFile *bf) {
return ret;
}
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzList *ret = rz_list_newf(free);
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzPVector *ret = rz_pvector_new(free);
if (!ret) {
return NULL;
}
@ -71,7 +71,7 @@ static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
}
binaddr->paddr = 2;
binaddr->vaddr = baddr(bf);
rz_list_append(ret, binaddr);
rz_pvector_push(ret, binaddr);
return ret;
}

12
librz/bin/p/bin_psxexe.c
View file

@ -80,23 +80,23 @@ static RzPVector /*<RzBinSection *>*/ *sections(RzBinFile *bf) {
return ret;
}
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzList *ret = NULL;
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzPVector *ret = NULL;
RzBinAddr *addr = NULL;
psxexe_header psxheader;
if (!(ret = rz_list_new())) {
if (!(ret = rz_pvector_new(NULL))) {
return NULL;
}
if (!(addr = RZ_NEW0(RzBinAddr))) {
rz_list_free(ret);
rz_pvector_free(ret);
return NULL;
}
if (rz_buf_fread_at(bf->buf, 0, (ut8 *)&psxheader, "8c17i", 1) < sizeof(psxexe_header)) {
RZ_LOG_ERROR("Truncated Header\n");
rz_list_free(ret);
rz_pvector_free(ret);
free(addr);
return NULL;
}
@ -104,7 +104,7 @@ static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
addr->paddr = (psxheader.pc0 - psxheader.t_addr) + PSXEXE_TEXTSECTION_OFFSET;
addr->vaddr = psxheader.pc0;
rz_list_append(ret, addr);
rz_pvector_push(ret, addr);
return ret;
}

10
librz/bin/p/bin_pyc.c
View file

@ -117,26 +117,26 @@ static RzBinInfo *info(RzBinFile *arch) {
return ret;
}
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *arch) {
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *arch) {
RzBinPycObj *pyc = arch->o->bin_obj;
RzList *entries = rz_list_newf((RzListFree)free);
RzPVector *entries = rz_pvector_new((RzPVectorFree)free);
if (!entries) {
return NULL;
}
RzBinAddr *addr = RZ_NEW0(RzBinAddr);
if (!addr) {
rz_list_free(entries);
rz_pvector_free(entries);
return NULL;
}
ut64 entrypoint = get_entrypoint(arch);
addr->paddr = entrypoint;
addr->vaddr = entrypoint;
rz_buf_seek(arch->buf, entrypoint, RZ_IO_SEEK_SET);
rz_list_append(entries, addr);
rz_pvector_push(entries, addr);
if (!init_pyc_cache(pyc, arch->buf)) {
rz_list_free(entries);
rz_pvector_free(entries);
return NULL;
}
return entries;

9
librz/bin/p/bin_qnx.c
View file

@ -336,20 +336,19 @@ static ut64 baddr(RzBinFile *bf) {
* Currently both physical and virtual address are set to 0
* The memory map has different values for entry
*/
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzList *ret;
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzPVector *ret;
RzBinAddr *ptr = NULL;
QnxObj *qo = bf->o->bin_obj;
if (!(ret = rz_list_new())) {
if (!(ret = rz_pvector_new(free))) {
return NULL;
}
ret->free = free;
if (!(ptr = RZ_NEW0(RzBinAddr))) {
return ret;
}
ptr->paddr = qo->lmfh.code_offset;
ptr->vaddr = qo->lmfh.code_offset + baddr(bf);
rz_list_append(ret, ptr);
rz_pvector_push(ret, ptr);
return ret;
}

6
librz/bin/p/bin_sfc.c
View file

@ -267,9 +267,9 @@ static RzPVector /*<RzBinMem *>*/ *mem(RzBinFile *bf) {
return ret;
}
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) { // Should be 3 offsets pointed by NMI, RESET, IRQ after mapping && default = 1st CHR
RzList *ret;
if (!(ret = rz_list_new())) {
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) { // Should be 3 offsets pointed by NMI, RESET, IRQ after mapping && default = 1st CHR
RzPVector *ret;
if (!(ret = rz_pvector_new(NULL))) {
return NULL;
}
/*

10
librz/bin/p/bin_smd.c
View file

@ -293,10 +293,10 @@ static RzPVector /*<RzBinSection *>*/ *sections(RzBinFile *bf) {
return ret;
}
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) { // Should be 3 offsets pointed by NMI, RESET, IRQ after mapping && default = 1st CHR
RzList *ret;
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) { // Should be 3 offsets pointed by NMI, RESET, IRQ after mapping && default = 1st CHR
RzPVector *ret;
RzBinAddr *ptr = NULL;
if (!(ret = rz_list_new())) {
if (!(ret = rz_pvector_new(NULL))) {
return NULL;
}
if (!(ptr = RZ_NEW0(RzBinAddr))) {
@ -305,12 +305,12 @@ static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) { // Should be 3 offsets
if (bf->size < sizeof(SMD_Vectors)) {
eprintf("ERR: binfile too small!\n");
ptr->paddr = ptr->vaddr = 0x100 + sizeof(SMD_Header);
rz_list_append(ret, ptr);
rz_pvector_push(ret, ptr);
} else {
SMD_Vectors vectors;
rz_buf_read_at(bf->buf, 0, (ut8 *)&vectors, sizeof(vectors));
ptr->paddr = ptr->vaddr = rz_read_be32(&vectors.Reset);
rz_list_append(ret, ptr);
rz_pvector_push(ret, ptr);
}
return ret;
}

6
librz/bin/p/bin_spc700.c
View file

@ -66,14 +66,14 @@ static RzPVector /*<RzBinSection *>*/ *sections(RzBinFile *bf) {
return ret;
}
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzList *ret = rz_list_newf(free);
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzPVector *ret = rz_pvector_new(free);
if (ret) {
RzBinAddr *ptr = RZ_NEW0(RzBinAddr);
if (ptr) {
ptr->paddr = RAM_START_ADDRESS;
ptr->vaddr = 0;
rz_list_append(ret, ptr);
rz_pvector_push(ret, ptr);
}
}
return ret;

6
librz/bin/p/bin_te.c
View file

@ -54,8 +54,8 @@ static RzBinAddr *binsym(RzBinFile *bf, RzBinSpecialSymbol type) {
return ret;
}
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzList *ret = rz_list_newf(free);
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzPVector *ret = rz_pvector_new(free);
if (ret) {
RzBinAddr *entry = rz_bin_te_get_entrypoint(bf->o->bin_obj);
if (entry) {
@ -63,7 +63,7 @@ static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
if (ptr) {
ptr->paddr = entry->paddr;
ptr->vaddr = entry->vaddr;
rz_list_append(ret, ptr);
rz_pvector_push(ret, ptr);
}
free(entry);
}

8
librz/bin/p/bin_vsf.c
View file

@ -500,16 +500,16 @@ static void destroy(RzBinFile *bf) {
free(obj);
}
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
struct rz_bin_vsf_obj *vsf_obj = (struct rz_bin_vsf_obj *)bf->o->bin_obj;
if (!vsf_obj) {
return NULL;
}
const int m_idx = vsf_obj->machine_idx;
RzList *ret;
RzPVector *ret;
RzBinAddr *ptr = NULL;
if (!(ret = rz_list_new())) {
if (!(ret = rz_pvector_new(NULL))) {
return NULL;
}
int offset = _machines[m_idx].offset_mem;
@ -519,7 +519,7 @@ static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
}
ptr->paddr = vsf_obj->mem + offset;
ptr->vaddr = vsf_obj->maincpu ? vsf_obj->maincpu->pc : 0;
rz_list_append(ret, ptr);
rz_pvector_push(ret, ptr);
// IRQ: 0xFFFE or 0x0314 ?
// if (!(ptr = RZ_NEW0 (RzBinAddr)))

10
librz/bin/p/bin_wasm.c
View file

@ -48,14 +48,14 @@ static RzBinAddr *binsym(RzBinFile *bf, RzBinSpecialSymbol type) {
static RzPVector /*<RzBinSection *>*/ *sections(RzBinFile *bf);
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzBinWasmObj *bin = bf && bf->o ? bf->o->bin_obj : NULL;
// TODO
RzList *ret = NULL;
RzPVector *ret = NULL;
RzBinAddr *ptr = NULL;
ut64 addr = 0x0;
if (!(ret = rz_list_newf((RzListFree)free))) {
if (!(ret = rz_pvector_new((RzPVectorFree)free))) {
return NULL;
}
@ -71,14 +71,14 @@ static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
}
}
if (!addr) {
rz_list_free(ret);
rz_pvector_free(ret);
return NULL;
}
}
if ((ptr = RZ_NEW0(RzBinAddr))) {
ptr->paddr = addr;
ptr->vaddr = addr;
rz_list_append(ret, ptr);
rz_pvector_push(ret, ptr);
}
return ret;
}

9
librz/bin/p/bin_xbe.c
View file

@ -124,24 +124,23 @@ static RzBinAddr *binsym(RzBinFile *bf, RzBinSpecialSymbol type) {
return ret;
}
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
const rz_bin_xbe_obj_t *obj;
RzList *ret;
RzPVector *ret;
RzBinAddr *ptr = RZ_NEW0(RzBinAddr);
if (!bf || !bf->buf || !bf->o->bin_obj || !ptr) {
free(ptr);
return NULL;
}
ret = rz_list_new();
ret = rz_pvector_new(free);
if (!ret) {
free(ptr);
return NULL;
}
ret->free = free;
obj = bf->o->bin_obj;
ptr->vaddr = obj->header.ep ^ obj->ep_key;
ptr->paddr = ptr->vaddr - obj->header.base;
rz_list_append(ret, ptr);
rz_pvector_push(ret, ptr);
return ret;
}

74
librz/bin/p/bin_xnu_kernelcache.c
View file

@ -124,8 +124,7 @@ static RKext *rz_kext_index_vget(RKextIndex *index, ut64 vaddr);
static void process_kmod_init_term(RzXNUKernelCacheObj *obj, RKext *kext, RzPVector /*<RzBinSymbol *>*/ *ret, ut64 **inits, ut64 **terms);
static void create_initterm_syms(RKext *kext, RzPVector /*<RzBinSymbol *>*/ *ret, int type, ut64 *pointers);
static void process_constructors(RzXNUKernelCacheObj *obj, struct MACH0_(obj_t) * mach0, RzList /*<void *>*/ *ret, ut64 paddr, bool is_first, int mode, const char *prefix);
RZ_DEPRECATE static void process_constructors_vector(RzXNUKernelCacheObj *obj, struct MACH0_(obj_t) * mach0, RzPVector /*<void *>*/ *ret, ut64 paddr, bool is_first, int mode, const char *prefix);
static void process_constructors(RzXNUKernelCacheObj *obj, struct MACH0_(obj_t) * mach0, RzPVector /*<void *>*/ *ret, ut64 paddr, bool is_first, int mode, const char *prefix);
static RzBinAddr *newEntry(ut64 haddr, ut64 vaddr, int type);
static void ensure_kexts_initialized(RzXNUKernelCacheObj *obj);
@ -776,11 +775,11 @@ static struct MACH0_(obj_t) * create_kext_shared_mach0(RzXNUKernelCacheObj *obj,
return mach0;
}
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzList *ret;
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzPVector *ret;
RzBinObject *obj = bf ? bf->o : NULL;
if (!obj || !obj->bin_obj || !(ret = rz_list_newf(free))) {
if (!obj || !obj->bin_obj || !(ret = rz_pvector_new(free))) {
return NULL;
}
@ -790,7 +789,7 @@ static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
ut64 entry_paddr = entry_vaddr - kobj->pa2va_exec;
RzBinAddr *ba = newEntry(entry_paddr, entry_vaddr, 0);
if (ba) {
rz_list_append(ret, ba);
rz_pvector_push(ret, ba);
}
}
@ -904,66 +903,7 @@ static void create_initterm_syms(RKext *kext, RzPVector /*<RzBinSymbol *>*/ *ret
}
}
static void process_constructors(RzXNUKernelCacheObj *obj, struct MACH0_(obj_t) * mach0, RzList /*<void *>*/ *ret, ut64 paddr, bool is_first, int mode, const char *prefix) {
struct section_t *sections = NULL;
if (!(sections = MACH0_(get_sections)(mach0))) {
return;
}
int i, type;
for (i = 0; !sections[i].last; i++) {
if (sections[i].size == 0) {
continue;
}
if (strstr(sections[i].name, "_mod_fini_func") || strstr(sections[i].name, "_mod_term_func")) {
type = RZ_BIN_ENTRY_TYPE_FINI;
} else if (strstr(sections[i].name, "_mod_init_func")) {
type = is_first ? 0 : RZ_BIN_ENTRY_TYPE_INIT;
is_first = false;
} else {
continue;
}
ut8 *buf = calloc(sections[i].size, 1);
if (!buf) {
break;
}
if (rz_buf_read_at(obj->cache_buf, sections[i].offset + paddr, buf, sections[i].size) < sections[i].size) {
free(buf);
break;
}
int j;
int count = 0;
for (j = 0; j < sections[i].size; j += 8) {
ut64 addr64 = K_RPTR(buf + j);
ut64 paddr64 = sections[i].offset + paddr + j;
if (mode == RZ_K_CONSTRUCTOR_TO_ENTRY) {
RzBinAddr *ba = newEntry(paddr64, addr64, type);
rz_list_append(ret, ba);
} else if (mode == RZ_K_CONSTRUCTOR_TO_SYMBOL) {
RzBinSymbol *sym = RZ_NEW0(RzBinSymbol);
if (!sym) {
break;
}
sym->name = rz_str_newf("%s.%s.%d", prefix, (type == RZ_BIN_ENTRY_TYPE_INIT) ? "init" : "fini", count++);
sym->vaddr = addr64;
sym->paddr = paddr64;
sym->size = 0;
sym->forwarder = "NONE";
sym->bind = "GLOBAL";
sym->type = "FUNC";
rz_list_append(ret, sym);
}
}
free(buf);
}
free(sections);
}
// this function will be removed once the transition of entries (RzBinPlugin) from RzList to RzPVector is done
RZ_DEPRECATE static void process_constructors_vector(RzXNUKernelCacheObj *obj, struct MACH0_(obj_t) * mach0, RzPVector /*<void *>*/ *ret, ut64 paddr, bool is_first, int mode, const char *prefix) {
static void process_constructors(RzXNUKernelCacheObj *obj, struct MACH0_(obj_t) * mach0, RzPVector /*<void *>*/ *ret, ut64 paddr, bool is_first, int mode, const char *prefix) {
struct section_t *sections = NULL;
if (!(sections = MACH0_(get_sections)(mach0))) {
return;
@ -1293,7 +1233,7 @@ static RzPVector /*<RzBinSymbol *>*/ *symbols(RzBinFile *bf) {
case MH_MAGIC_64:
symbols_from_mach0(ret, kext->mach0, bf, kext->range.offset, rz_pvector_len(ret));
symbols_from_stubs(ret, kernel_syms_by_addr, obj, bf, kext, rz_pvector_len(ret));
process_constructors_vector(obj, kext->mach0, ret, kext->range.offset, false, RZ_K_CONSTRUCTOR_TO_SYMBOL, kext_short_name(kext));
process_constructors(obj, kext->mach0, ret, kext->range.offset, false, RZ_K_CONSTRUCTOR_TO_SYMBOL, kext_short_name(kext));
process_kmod_init_term(obj, kext, ret, &inits, &terms);
break;

6
librz/bin/p/bin_z64.c
View file

@ -89,8 +89,8 @@ static bool load_buffer(RzBinFile *bf, RzBinObject *obj, RzBuffer *b, Sdb *sdb)
return false;
}
static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzList /*<RzBinAddr *>*/ *ret = rz_list_newf(free);
static RzPVector /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
RzPVector /*<RzBinAddr *>*/ *ret = rz_pvector_new(free);
if (!ret) {
return NULL;
}
@ -98,7 +98,7 @@ static RzList /*<RzBinAddr *>*/ *entries(RzBinFile *bf) {
if (ptr) {
ptr->paddr = N64_ROM_START;
ptr->vaddr = baddr(bf);
rz_list_append(ret, ptr);
rz_pvector_push(ret, ptr);
}
return ret;
}

14
librz/core/canalysis.c
View file

@ -2357,7 +2357,7 @@ static bool isSkippable(RzBinSymbol *s) {
}
RZ_API int rz_core_analysis_all(RzCore *core) {
RzList *list;
RzPVector *vector;
RzListIter *iter;
RzFlagItem *item;
RzAnalysisFunction *fcni;
@ -2384,10 +2384,9 @@ RZ_API int rz_core_analysis_all(RzCore *core) {
RzBinFile *bf = core->bin->cur;
RzBinObject *o = bf ? bf->o : NULL;
/* Symbols (Imports are already analyzed by rz_bin on init) */
RzPVector *vec = NULL;
void **it;
if (o && (vec = o->symbols) != NULL) {
rz_pvector_foreach (vec, it) {
if (o && (vector = o->symbols) != NULL) {
rz_pvector_foreach (vector, it) {
symbol = *it;
if (rz_cons_is_breaked()) {
break;
@ -2411,8 +2410,11 @@ RZ_API int rz_core_analysis_all(RzCore *core) {
}
}
rz_core_task_yield(&core->tasks);
if ((list = rz_bin_get_entries(core->bin))) {
rz_list_foreach (list, iter, entry) {
RzBinObject *bin = rz_bin_cur_object(core->bin);
vector = bin ? (RzPVector *)rz_bin_object_get_entries(bin) : NULL;
if (vector) {
rz_pvector_foreach (vector, it) {
entry = *it;
if (entry->paddr == UT64_MAX) {
continue;
}

21
librz/core/cbin.c
View file

@ -737,12 +737,13 @@ RZ_API bool rz_core_bin_apply_entry(RzCore *core, RzBinFile *binfile, bool va) {
if (!o) {
return false;
}
RzList *entries = o->entries;
RzListIter *iter;
RzPVector *entries = o->entries;
void **iter;
RzBinAddr *entry = NULL;
int i = 0, init_i = 0, fini_i = 0, preinit_i = 0;
rz_flag_space_push(core->flags, RZ_FLAGS_FS_SYMBOLS);
rz_list_foreach (entries, iter, entry) {
rz_pvector_foreach (entries, iter) {
entry = *iter;
ut64 paddr = entry->paddr;
ut64 hpaddr = UT64_MAX;
ut64 hvaddr = UT64_MAX;
@ -1484,7 +1485,7 @@ RZ_API bool rz_core_bin_apply_symbols(RzCore *core, RzBinFile *binfile, bool va)
RzBinObject *obj = rz_bin_cur_object(core->bin);
RzPVector *symbols = obj ? (RzPVector *)rz_bin_object_get_symbols(obj) : NULL;
RzListIter *iter;
void **iter;
void **it;
RzBinSymbol *symbol;
rz_pvector_foreach (symbols, it) {
@ -1578,7 +1579,8 @@ RZ_API bool rz_core_bin_apply_symbols(RzCore *core, RzBinFile *binfile, bool va)
// handle thumb and arm for entry point since they are not present in symbols
if (is_arm) {
RzBinAddr *entry;
rz_list_foreach (o->entries, iter, entry) {
rz_pvector_foreach (o->entries, iter) {
entry = *iter;
handle_arm_entry(core, o, entry, va);
}
}
@ -1880,8 +1882,8 @@ static const char *bin_reloc_type_name(RzBinReloc *reloc) {
static bool entries_initfini_print(RzCore *core, RzBinFile *bf, RzCmdStateOutput *state, bool initfini) {
RzBinObject *o = bf->o;
const RzList *entries = rz_bin_object_get_entries(o);
RzListIter *iter;
const RzPVector *entries = rz_bin_object_get_entries(o);
void **iter;
RzBinAddr *entry = NULL;
ut64 baddr = rz_bin_get_baddr(core->bin);
ut64 laddr = rz_bin_get_laddr(core->bin);
@ -1890,7 +1892,8 @@ static bool entries_initfini_print(RzCore *core, RzBinFile *bf, RzCmdStateOutput
rz_cmd_state_output_array_start(state);
rz_cmd_state_output_set_columnsf(state, "XXXXs", "vaddr", "paddr", "hvaddr", "haddr", "type");
rz_list_foreach (entries, iter, entry) {
rz_pvector_foreach (entries, iter) {
entry = *iter;
ut64 paddr = entry->paddr;
ut64 hpaddr = UT64_MAX;
ut64 hvaddr = UT64_MAX;
@ -3079,7 +3082,7 @@ RZ_API bool rz_core_bin_info_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile
bool havecode;
int bits;
havecode = is_executable(obj) || rz_list_length(obj->entries) > 0;
havecode = is_executable(obj) || rz_pvector_len(obj->entries) > 0;
compiled = rz_core_bin_get_compile_time(bf);
bits = (plugin && !strcmp(plugin->name, "any")) ? rz_config_get_i(core->config, "asm.bits") : info->bits;
const char *endian = info->big_endian ? "BE" : "LE";

9
librz/core/cesil.c
View file

@ -43,14 +43,15 @@ static ut64 initializeEsil(RzCore *core) {
}
}
esil->exectrap = exectrap;
RzList *entries = rz_bin_get_entries(core->bin);
RzBinObject *obj = rz_bin_cur_object(core->bin);
RzPVector *entries = obj ? (RzPVector *)rz_bin_object_get_entries(obj) : NULL;
RzBinAddr *entry = NULL;
RzBinInfo *info = NULL;
if (entries && !rz_list_empty(entries)) {
entry = (RzBinAddr *)rz_list_pop_head(entries);
if (entries && !rz_pvector_empty(entries)) {
entry = (RzBinAddr *)rz_pvector_pop_front(entries);
info = rz_bin_get_info(core->bin);
addr = info->has_va ? entry->vaddr : entry->paddr;
rz_list_push(entries, entry);
rz_pvector_push(entries, entry);
} else {
addr = core->offset;
}

7
librz/include/rz_bin.h
View file

@ -303,7 +303,7 @@ typedef struct rz_bin_object_t {
* This associates the name of every symbol where is_imported == true to the symbol itself.
*/
HtPP /*<const char *, RzBinSymbol>*/ *import_name_symbols; // currently only used for imports, but could be extended to all symbols if needed.
RzList /*<RzBinAddr *>*/ *entries;
RzPVector /*<RzBinAddr *>*/ *entries;
RzPVector /*<RzBinField *>*/ *fields;
RzPVector /*<char *>*/ *libs;
RzBinRelocStorage *relocs;
@ -473,7 +473,7 @@ typedef struct rz_bin_plugin_t {
RzPVector /*<RzBinVirtualFile *>*/ *(*virtual_files)(RzBinFile *bf);
RzPVector /*<RzBinMap *>*/ *(*maps)(RzBinFile *bf);
RzBinAddr *(*binsym)(RzBinFile *bf, RzBinSpecialSymbol num);
RzList /*<RzBinAddr *>*/ *(*entries)(RzBinFile *bf);
RzPVector /*<RzBinAddr *>*/ *(*entries)(RzBinFile *bf);
RzPVector /*<RzBinSection *>*/ *(*sections)(RzBinFile *bf);
RZ_OWN RzBinSourceLineInfo *(*lines)(RzBinFile *bf); //< only called once on load, ownership is transferred to the caller
RzPVector /*<RzBinSymbol *>*/ *(*symbols)(RzBinFile *bf);
@ -865,11 +865,10 @@ RZ_API void rz_bin_string_search_opt_init(RZ_NONNULL RzBinStringSearchOpt *opt);
RZ_API RZ_OWN RzPVector /*<RzBinString *>*/ *rz_bin_file_strings(RZ_NONNULL RzBinFile *bf, RZ_NONNULL const RzBinStringSearchOpt *opt);
// use RzBinFile instead
RZ_DEPRECATE RZ_API RZ_BORROW RzList /*<RzBinAddr *>*/ *rz_bin_get_entries(RZ_NONNULL RzBin *bin);
RZ_DEPRECATE RZ_API int rz_bin_is_static(RZ_NONNULL RzBin *bin);
RZ_API RZ_OWN RzPVector /*<RzBinTrycatch *>*/ *rz_bin_file_get_trycatch(RZ_NONNULL RzBinFile *bf);
RZ_API const RzList /*<RzBinAddr *>*/ *rz_bin_object_get_entries(RZ_NONNULL RzBinObject *obj);
RZ_API RZ_BORROW const RzPVector /*<RzBinAddr *>*/ *rz_bin_object_get_entries(RZ_NONNULL RzBinObject *obj);
RZ_API const RzPVector /*<RzBinField *>*/ *rz_bin_object_get_fields(RZ_NONNULL RzBinObject *obj);
RZ_API const RzPVector /*<RzBinImport *>*/ *rz_bin_object_get_imports(RZ_NONNULL RzBinObject *obj);
RZ_API const RzBinInfo *rz_bin_object_get_info(RZ_NONNULL RzBinObject *obj);

5
librz/include/rz_vector.h
View file

@ -269,7 +269,10 @@ static inline size_t rz_pvector_len(const RzPVector *vec) {
}
static inline void *rz_pvector_at(const RzPVector *vec, size_t index) {
rz_return_val_if_fail(vec && index < vec->v.len, NULL);
rz_return_val_if_fail(vec, NULL);
if (index >= vec->v.len) {
return NULL;
}
return ((void **)vec->v.a)[index];
}

26
librz/main/rz-diff.c
View file

@ -727,12 +727,6 @@ static void rz_diff_file_close(DiffFile *file) {
#define rz_diff_file_get(df, n) ((df)->file->o->n)
/**************************************** rzlists ***************************************/
static const void *rz_diff_list_elem_at(const RzList /*<void *>*/ *array, ut32 index) {
return rz_list_get_n(array, index);
}
/**************************************** rzpvector ***************************************/
static const void *rz_diff_pvector_elem_at(const RzPVector /*<void *>*/ *array, ut32 index) {
@ -1073,31 +1067,31 @@ static void entry_stringify(const RzBinAddr *elem, RzStrBuf *sb) {
}
static RzDiff *rz_diff_entries_new(DiffFile *dfile_a, DiffFile *dfile_b) {
RzList *list_a = NULL;
RzList *list_b = NULL;
RzPVector *vec_a = NULL;
RzPVector *vec_b = NULL;
list_a = rz_diff_file_get(dfile_a, entries);
if (!list_a) {
vec_a = rz_diff_file_get(dfile_a, entries);
if (!vec_a) {
rz_diff_error_ret(NULL, "cannot get entries from '%s'\n", dfile_a->dio->filename);
}
list_b = rz_diff_file_get(dfile_b, entries);
if (!list_b) {
vec_b = rz_diff_file_get(dfile_b, entries);
if (!vec_b) {
rz_diff_error_ret(NULL, "cannot get entries from '%s'\n", dfile_b->dio->filename);
}
rz_list_sort(list_a, (RzListComparator)entry_compare, NULL);
rz_list_sort(list_b, (RzListComparator)entry_compare, NULL);
rz_pvector_sort(vec_a, (RzPVectorComparator)entry_compare, NULL);
rz_pvector_sort(vec_b, (RzPVectorComparator)entry_compare, NULL);
RzDiffMethods methods = {
.elem_at = (RzDiffMethodElemAt)rz_diff_list_elem_at,
.elem_at = (RzDiffMethodElemAt)rz_diff_pvector_elem_at,
.elem_hash = (RzDiffMethodElemHash)entry_hash,
.compare = (RzDiffMethodCompare)entry_compare,
.stringify = (RzDiffMethodStringify)entry_stringify,
.ignore = NULL,
};
return rz_diff_generic_new(list_a, rz_list_length(list_a), list_b, rz_list_length(list_b), &methods);
return rz_diff_generic_new(vec_a, rz_pvector_len(vec_a), vec_b, rz_pvector_len(vec_b), &methods);
}
/**************************************** libraries ***************************************/

6
librz/util/vector.c
View file

@ -458,8 +458,10 @@ RZ_API bool rz_pvector_join(RZ_NONNULL RzPVector *pvec1, RZ_NONNULL RzPVector *p
return false;
}
RzVector *vec = &pvec1->v;
RESIZE_OR_RETURN_FALSE(RZ_MAX(NEXT_VECTOR_CAPACITY, pvec1->v.len + pvec2->v.len));
if (pvec1->v.len + pvec2->v.len > pvec1->v.capacity) {
RzVector *vec = &pvec1->v;
RESIZE_OR_RETURN_NULL(RZ_MAX(NEXT_VECTOR_CAPACITY, pvec1->v.len + pvec2->v.len));
}
memmove((void **)pvec1->v.a + pvec1->v.len, pvec2->v.a, pvec2->v.elem_size * pvec2->v.len);
pvec1->v.len += pvec2->v.len;

6
test/integration/test_bin.c
View file

@ -29,9 +29,9 @@ bool test_rz_bin(void) {
mu_assert_eq(rz_pvector_len(segments), 10, "rz_bin_object_get_segments");
rz_pvector_free(segments);
const RzList *entries = rz_bin_object_get_entries(obj);
mu_assert_eq(rz_list_length(entries), 1, "rz_bin_object_get_entries");
RzBinAddr *entry = rz_list_first(entries);
const RzPVector *entries = rz_bin_object_get_entries(obj);
mu_assert_eq(rz_pvector_len(entries), 1, "rz_bin_object_get_entries");
RzBinAddr *entry = (RzBinAddr *)rz_pvector_at(entries, 0);
mu_assert_eq(entry->vaddr, 0x8048360, "entry virtual address");
mu_assert_eq(entry->paddr, 0x360, "entry file offset");