wasm.h File Reference

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

Go to the source code of this file.

Classes
struct	rz_bin_wasm_init_expr_t
struct	rz_bin_wasm_resizable_limits_t
struct	rz_bin_wasm_name_t
struct	rz_bin_wasm_section_t
struct	rz_bin_wasm_type_t
struct	rz_bin_wasm_global_type_t
struct	rz_bin_wasm_table_type_t
struct	rz_bin_wasm_memory_type_t
struct	rz_bin_wasm_import_t
struct	rz_bin_wasm_function_t
struct	rz_bin_wasm_table_t
struct	rz_bin_wasm_memory_t
struct	rz_bin_wasm_global_t
struct	rz_bin_wasm_export_t
struct	rz_bin_wasm_start_t
struct	rz_bin_wasm_local_entry_t
struct	rz_bin_wasm_element_t
struct	rz_bin_wasm_code_t
struct	rz_bin_wasm_data_t
struct	rz_bin_wasm_custom_name_function_names_t
struct	rz_bin_wasm_custom_name_local_name_t
struct	rz_bin_wasm_custom_name_local_names_t
struct	rz_bin_wasm_custom_name_entry_t
struct	rz_bin_wasm_obj_t

Macros
#define	RZ_BIN_WASM_MAGIC_BYTES
#define	RZ_BIN_WASM_VERSION   0x1
#define	RZ_BIN_WASM_STRING_LENGTH   256
#define	RZ_BIN_WASM_END_OF_CODE   0xb
#define	RZ_BIN_WASM_SECTION_CUSTOM   0x0
#define	RZ_BIN_WASM_SECTION_TYPE   0x1
#define	RZ_BIN_WASM_SECTION_IMPORT   0x2
#define	RZ_BIN_WASM_SECTION_FUNCTION   0x3
#define	RZ_BIN_WASM_SECTION_TABLE   0x4
#define	RZ_BIN_WASM_SECTION_MEMORY   0x5
#define	RZ_BIN_WASM_SECTION_GLOBAL   0x6
#define	RZ_BIN_WASM_SECTION_EXPORT   0x7
#define	RZ_BIN_WASM_SECTION_START   0x8
#define	RZ_BIN_WASM_SECTION_ELEMENT   0x9
#define	RZ_BIN_WASM_SECTION_CODE   0xa
#define	RZ_BIN_WASM_SECTION_DATA   0xb

Typedefs
typedef struct rz_bin_wasm_section_t	RzBinWasmSection
typedef struct rz_bin_wasm_type_t	RzBinWasmTypeEntry
typedef struct rz_bin_wasm_import_t	RzBinWasmImportEntry
typedef struct rz_bin_wasm_function_t	RzBinWasmFunctionEntry
typedef struct rz_bin_wasm_table_t	RzBinWasmTableEntry
typedef struct rz_bin_wasm_memory_t	RzBinWasmMemoryEntry
typedef struct rz_bin_wasm_global_t	RzBinWasmGlobalEntry
typedef struct rz_bin_wasm_export_t	RzBinWasmExportEntry
typedef struct rz_bin_wasm_start_t	RzBinWasmStartEntry
typedef struct rz_bin_wasm_element_t	RzBinWasmElementEntry
typedef struct rz_bin_wasm_code_t	RzBinWasmCodeEntry
typedef struct rz_bin_wasm_data_t	RzBinWasmDataEntry
typedef struct rz_bin_wasm_custom_name_function_names_t	RzBinWasmCustomNameFunctionNames
typedef struct rz_bin_wasm_custom_name_local_name_t	RzBinWasmCustomNameLocalName
typedef struct rz_bin_wasm_custom_name_local_names_t	RzBinWasmCustomNameLocalNames
typedef struct rz_bin_wasm_custom_name_entry_t	RzBinWasmCustomNameEntry
typedef struct rz_bin_wasm_obj_t	RzBinWasmObj

Enumerations
enum	rz_bin_wasm_value_type_t {   RZ_BIN_WASM_VALUETYPE_i32 = 0x1 , RZ_BIN_WASM_VALUETYPE_i64 = 0x2 , RZ_BIN_WASM_VALUETYPE_f32 = 0x3 , RZ_BIN_WASM_VALUETYPE_f64 = 0x4 ,   RZ_BIN_WASM_VALUETYPE_v128 = 0x5 , RZ_BIN_WASM_VALUETYPE_ANYFUNC = 0x10 , RZ_BIN_WASM_VALUETYPE_FUNC = 0x20 , RZ_BIN_WASM_VALUETYPE_EMPTY = 0x40 }
enum	rz_bin_wasm_external_kind_t { RZ_BIN_WASM_EXTERNALKIND_Function = 0x0 , RZ_BIN_WASM_EXTERNALKIND_Table = 0x1 , RZ_BIN_WASM_EXTERNALKIND_Memory = 0x2 , RZ_BIN_WASM_EXTERNALKIND_Global = 0x3 }
enum	rz_bin_wasm_custom_name_type_t { RZ_BIN_WASM_NAMETYPE_Module = 0x0 , RZ_BIN_WASM_NAMETYPE_Function = 0x1 , RZ_BIN_WASM_NAMETYPE_Local = 0x2 }

Functions
RzBinWasmObj *	rz_bin_wasm_init (RzBinFile *bf, RzBuffer *buf)
void	rz_bin_wasm_destroy (RzBinFile *bf)
RzList *	rz_bin_wasm_get_sections (RzBinWasmObj *bin)
RzList *	rz_bin_wasm_get_types (RzBinWasmObj *bin)
RzList *	rz_bin_wasm_get_imports (RzBinWasmObj *bin)
RzList *	rz_bin_wasm_get_exports (RzBinWasmObj *bin)
RzList *	rz_bin_wasm_get_tables (RzBinWasmObj *bin)
RzList *	rz_bin_wasm_get_memories (RzBinWasmObj *bin)
RzList *	rz_bin_wasm_get_globals (RzBinWasmObj *bin)
RzList *	rz_bin_wasm_get_elements (RzBinWasmObj *bin)
RzList *	rz_bin_wasm_get_codes (RzBinWasmObj *bin)
RzList *	rz_bin_wasm_get_datas (RzBinWasmObj *bin)
RzList *	rz_bin_wasm_get_custom_names (RzBinWasmObj *bin)
ut32	rz_bin_wasm_get_entrypoint (RzBinWasmObj *bin)
const char *	rz_bin_wasm_get_function_name (RzBinWasmObj *bin, ut32 idx)
const char *	rz_bin_wasm_valuetype_to_string (rz_bin_wasm_value_type_t type)

Macro Definition Documentation

RZ_BIN_WASM_END_OF_CODE

#define RZ_BIN_WASM_END_OF_CODE   0xb

Definition at line 19 of file wasm.h.

RZ_BIN_WASM_MAGIC_BYTES

#define RZ_BIN_WASM_MAGIC_BYTES

Value:

                "\x00" \
                "asm"

Definition at line 15 of file wasm.h.

RZ_BIN_WASM_SECTION_CODE

#define RZ_BIN_WASM_SECTION_CODE   0xa

Definition at line 31 of file wasm.h.

RZ_BIN_WASM_SECTION_CUSTOM

#define RZ_BIN_WASM_SECTION_CUSTOM   0x0

Definition at line 21 of file wasm.h.

RZ_BIN_WASM_SECTION_DATA

#define RZ_BIN_WASM_SECTION_DATA   0xb

Definition at line 32 of file wasm.h.

RZ_BIN_WASM_SECTION_ELEMENT

#define RZ_BIN_WASM_SECTION_ELEMENT   0x9

Definition at line 30 of file wasm.h.

RZ_BIN_WASM_SECTION_EXPORT

#define RZ_BIN_WASM_SECTION_EXPORT   0x7

Definition at line 28 of file wasm.h.

RZ_BIN_WASM_SECTION_FUNCTION

#define RZ_BIN_WASM_SECTION_FUNCTION   0x3

Definition at line 24 of file wasm.h.

RZ_BIN_WASM_SECTION_GLOBAL

#define RZ_BIN_WASM_SECTION_GLOBAL   0x6

Definition at line 27 of file wasm.h.

RZ_BIN_WASM_SECTION_IMPORT

#define RZ_BIN_WASM_SECTION_IMPORT   0x2

Definition at line 23 of file wasm.h.

RZ_BIN_WASM_SECTION_MEMORY

#define RZ_BIN_WASM_SECTION_MEMORY   0x5

Definition at line 26 of file wasm.h.

RZ_BIN_WASM_SECTION_START

#define RZ_BIN_WASM_SECTION_START   0x8

Definition at line 29 of file wasm.h.

RZ_BIN_WASM_SECTION_TABLE

#define RZ_BIN_WASM_SECTION_TABLE   0x4

Definition at line 25 of file wasm.h.

RZ_BIN_WASM_SECTION_TYPE

#define RZ_BIN_WASM_SECTION_TYPE   0x1

Definition at line 22 of file wasm.h.

RZ_BIN_WASM_STRING_LENGTH

#define RZ_BIN_WASM_STRING_LENGTH   256

Definition at line 18 of file wasm.h.

RZ_BIN_WASM_VERSION

#define RZ_BIN_WASM_VERSION   0x1

Definition at line 17 of file wasm.h.

Typedef Documentation

RzBinWasmCodeEntry

typedef struct rz_bin_wasm_code_t RzBinWasmCodeEntry

RzBinWasmCustomNameEntry

typedef struct rz_bin_wasm_custom_name_entry_t RzBinWasmCustomNameEntry

RzBinWasmCustomNameFunctionNames

typedef struct rz_bin_wasm_custom_name_function_names_t RzBinWasmCustomNameFunctionNames

RzBinWasmCustomNameLocalName

typedef struct rz_bin_wasm_custom_name_local_name_t RzBinWasmCustomNameLocalName

RzBinWasmCustomNameLocalNames

typedef struct rz_bin_wasm_custom_name_local_names_t RzBinWasmCustomNameLocalNames

RzBinWasmDataEntry

typedef struct rz_bin_wasm_data_t RzBinWasmDataEntry

RzBinWasmElementEntry

typedef struct rz_bin_wasm_element_t RzBinWasmElementEntry

RzBinWasmExportEntry

typedef struct rz_bin_wasm_export_t RzBinWasmExportEntry

RzBinWasmFunctionEntry

typedef struct rz_bin_wasm_function_t RzBinWasmFunctionEntry

RzBinWasmGlobalEntry

typedef struct rz_bin_wasm_global_t RzBinWasmGlobalEntry

RzBinWasmImportEntry

typedef struct rz_bin_wasm_import_t RzBinWasmImportEntry

RzBinWasmMemoryEntry

typedef struct rz_bin_wasm_memory_t RzBinWasmMemoryEntry

RzBinWasmObj

typedef struct rz_bin_wasm_obj_t RzBinWasmObj

RzBinWasmSection

typedef struct rz_bin_wasm_section_t RzBinWasmSection

RzBinWasmStartEntry

typedef struct rz_bin_wasm_start_t RzBinWasmStartEntry

RzBinWasmTableEntry

typedef struct rz_bin_wasm_table_t RzBinWasmTableEntry

RzBinWasmTypeEntry

typedef struct rz_bin_wasm_type_t RzBinWasmTypeEntry

Enumeration Type Documentation

rz_bin_wasm_custom_name_type_t

enum rz_bin_wasm_custom_name_type_t

Enumerator
RZ_BIN_WASM_NAMETYPE_Module
RZ_BIN_WASM_NAMETYPE_Function
RZ_BIN_WASM_NAMETYPE_Local

Definition at line 52 of file wasm.h.

             {
    RZ_BIN_WASM_NAMETYPE_Module = 0x0,
    RZ_BIN_WASM_NAMETYPE_Function = 0x1,
    RZ_BIN_WASM_NAMETYPE_Local = 0x2,
} rz_bin_wasm_custom_name_type_t;

rz_bin_wasm_external_kind_t

enum rz_bin_wasm_external_kind_t

Enumerator
RZ_BIN_WASM_EXTERNALKIND_Function
RZ_BIN_WASM_EXTERNALKIND_Table
RZ_BIN_WASM_EXTERNALKIND_Memory
RZ_BIN_WASM_EXTERNALKIND_Global

Definition at line 45 of file wasm.h.

             {
    RZ_BIN_WASM_EXTERNALKIND_Function = 0x0,
    RZ_BIN_WASM_EXTERNALKIND_Table = 0x1,
    RZ_BIN_WASM_EXTERNALKIND_Memory = 0x2,
    RZ_BIN_WASM_EXTERNALKIND_Global = 0x3,
} rz_bin_wasm_external_kind_t;

rz_bin_wasm_value_type_t

enum rz_bin_wasm_value_type_t

Enumerator
RZ_BIN_WASM_VALUETYPE_i32
RZ_BIN_WASM_VALUETYPE_i64
RZ_BIN_WASM_VALUETYPE_f32
RZ_BIN_WASM_VALUETYPE_f64
RZ_BIN_WASM_VALUETYPE_v128
RZ_BIN_WASM_VALUETYPE_ANYFUNC
RZ_BIN_WASM_VALUETYPE_FUNC
RZ_BIN_WASM_VALUETYPE_EMPTY

Definition at line 34 of file wasm.h.

             {
    RZ_BIN_WASM_VALUETYPE_i32 = 0x1,
    RZ_BIN_WASM_VALUETYPE_i64 = 0x2,
    RZ_BIN_WASM_VALUETYPE_f32 = 0x3,
    RZ_BIN_WASM_VALUETYPE_f64 = 0x4,
    RZ_BIN_WASM_VALUETYPE_v128 = 0x5,
    RZ_BIN_WASM_VALUETYPE_ANYFUNC = 0x10,
    RZ_BIN_WASM_VALUETYPE_FUNC = 0x20,
    RZ_BIN_WASM_VALUETYPE_EMPTY = 0x40,
} rz_bin_wasm_value_type_t;

Function Documentation

rz_bin_wasm_destroy()

void rz_bin_wasm_destroy

(

RzBinFile *

bf

)

Definition at line 789 of file wasm.c.

                                        {
    RzBinWasmObj *bin;
 
    if (!bf || !bf->o || !bf->o->bin_obj) {
        return;
    }
 
    bin = bf->o->bin_obj;
    rz_buf_free(bin->buf);
 
    rz_list_free(bin->g_sections);
    rz_list_free(bin->g_types);
 
    rz_list_free(bin->g_imports);
    rz_list_free(bin->g_exports);
    rz_list_free(bin->g_tables);
    rz_list_free(bin->g_memories);
    rz_list_free(bin->g_globals);
    rz_list_free(bin->g_codes);
    rz_list_free(bin->g_datas);
 
    RzListIter *iter;
    RzBinWasmCustomNameEntry *nam;
    rz_list_foreach (bin->g_names, iter, nam) {
        switch (nam->type) {
        case RZ_BIN_WASM_NAMETYPE_Module:
            if (nam->mod_name) {
                free(nam->mod_name);
            }
            break;
        case RZ_BIN_WASM_NAMETYPE_Function:
            if (nam->func) {
                rz_id_storage_free(nam->func->names);
            }
            break;
        case RZ_BIN_WASM_NAMETYPE_Local:
            if (nam->local && nam->local->locals) {
                RzListIter *iter;
                RzBinWasmCustomNameLocalName *local;
                rz_list_foreach (nam->local->locals, iter, local) {
                    if (local->names) {
                        rz_id_storage_free(local->names);
                    }
                }
 
                rz_list_free(nam->local->locals);
            }
            break;
        }
    }
    rz_list_free(bin->g_names);
 
    free(bin->g_start);
    free(bin);
    bf->o->bin_obj = NULL;
}

References rz_bin_object_t::bin_obj, bin::buf, free(), rz_bin_wasm_custom_name_entry_t::func, rz_bin_wasm_custom_name_entry_t::local, local, rz_bin_wasm_custom_name_local_names_t::locals, rz_bin_wasm_custom_name_entry_t::mod_name, rz_bin_wasm_custom_name_function_names_t::names, NULL, rz_bin_file_t::o, RZ_BIN_WASM_NAMETYPE_Function, RZ_BIN_WASM_NAMETYPE_Local, RZ_BIN_WASM_NAMETYPE_Module, rz_buf_free(), rz_id_storage_free(), rz_list_free(), and rz_bin_wasm_custom_name_entry_t::type.

Referenced by destroy().

rz_bin_wasm_get_codes()

RzList* rz_bin_wasm_get_codes

(

RzBinWasmObj *

bin

)

Definition at line 1168 of file wasm.c.

                                                 {
    RzBinWasmSection *code = NULL;
    ;
    RzList *codes = NULL;
 
    if (!bin || !bin->g_sections) {
        return NULL;
    }
    if (bin->g_codes) {
        return bin->g_codes;
    }
    if (!(codes = rz_bin_wasm_get_sections_by_id(bin->g_sections, RZ_BIN_WASM_SECTION_CODE))) {
        return rz_list_new();
    }
    // support for multiple export sections against spec
    if (!(code = (RzBinWasmSection *)rz_list_first(codes))) {
        rz_list_free(codes);
        return rz_list_new();
    }
    bin->g_codes = rz_bin_wasm_get_code_entries(bin, code);
    rz_list_free(codes);
    return bin->g_codes;
}

References codes(), NULL, rz_bin_wasm_get_code_entries(), rz_bin_wasm_get_sections_by_id(), RZ_BIN_WASM_SECTION_CODE, rz_list_first(), rz_list_free(), and rz_list_new().

Referenced by entries(), rz_bin_wasm_init(), and symbols().

rz_bin_wasm_get_custom_names()

RzList* rz_bin_wasm_get_custom_names

(

RzBinWasmObj *

bin

)

Definition at line 1215 of file wasm.c.

                                                        {
    RzBinWasmSection *cust = NULL;
    RzList *customs = NULL;
 
    rz_return_val_if_fail(bin && bin->g_sections, NULL);
 
    if (bin->g_names) {
        return bin->g_names;
    }
    if (!(customs = rz_bin_wasm_get_sections_by_id(bin->g_sections, RZ_BIN_WASM_SECTION_CUSTOM))) {
        return rz_list_new();
    }
    // support for multiple "name" sections against spec
    if (!(cust = (RzBinWasmSection *)rz_list_first(customs)) || strncmp(cust->name, "name", 5)) {
        rz_list_free(customs);
        return rz_list_new();
    }
    bin->g_names = rz_bin_wasm_get_custom_name_entries(bin, cust);
    rz_list_free(customs);
    return bin->g_names;
}

References rz_bin_wasm_section_t::name, NULL, rz_bin_wasm_get_custom_name_entries(), rz_bin_wasm_get_sections_by_id(), RZ_BIN_WASM_SECTION_CUSTOM, rz_list_first(), rz_list_free(), rz_list_new(), and rz_return_val_if_fail.

Referenced by rz_bin_wasm_init().

rz_bin_wasm_get_datas()

RzList* rz_bin_wasm_get_datas

(

RzBinWasmObj *

bin

)

Definition at line 1192 of file wasm.c.

                                                 {
    RzBinWasmSection *data = NULL;
    RzList *datas = NULL;
 
    if (!bin || !bin->g_sections) {
        return NULL;
    }
    if (bin->g_datas) {
        return bin->g_datas;
    }
    if (!(datas = rz_bin_wasm_get_sections_by_id(bin->g_sections, RZ_BIN_WASM_SECTION_DATA))) {
        return rz_list_new();
    }
    // support for multiple export sections against spec
    if (!(data = (RzBinWasmSection *)rz_list_first(datas))) {
        rz_list_free(datas);
        return rz_list_new();
    }
    bin->g_datas = rz_bin_wasm_get_data_entries(bin, data);
    rz_list_free(datas);
    return bin->g_datas;
}

References NULL, rz_bin_wasm_get_data_entries(), rz_bin_wasm_get_sections_by_id(), RZ_BIN_WASM_SECTION_DATA, rz_list_first(), rz_list_free(), and rz_list_new().

Referenced by rz_bin_wasm_init().

rz_bin_wasm_get_elements()

RzList* rz_bin_wasm_get_elements

(

RzBinWasmObj *

bin

)

Definition at line 1145 of file wasm.c.

                                                    {
    RzBinWasmSection *element = NULL;
    RzList *elements = NULL;
 
    if (!bin || !bin->g_sections) {
        return NULL;
    }
    if (bin->g_elements) {
        return bin->g_elements;
    }
    if (!(elements = rz_bin_wasm_get_sections_by_id(bin->g_sections, RZ_BIN_WASM_SECTION_ELEMENT))) {
        return rz_list_new();
    }
    // support for multiple export sections against spec
    if (!(element = (RzBinWasmSection *)rz_list_first(elements))) {
        rz_list_free(elements);
        return rz_list_new();
    }
    bin->g_elements = rz_bin_wasm_get_element_entries(bin, element);
    rz_list_free(elements);
    return bin->g_elements;
}

References NULL, rz_bin_wasm_get_element_entries(), rz_bin_wasm_get_sections_by_id(), RZ_BIN_WASM_SECTION_ELEMENT, rz_list_first(), rz_list_free(), and rz_list_new().

rz_bin_wasm_get_entrypoint()

ut32 rz_bin_wasm_get_entrypoint

(

RzBinWasmObj *

bin

)

Definition at line 966 of file wasm.c.

                                                   {
    RzList *secs = NULL;
    RzBinWasmStartEntry *start = NULL;
    RzBinWasmSection *sec = NULL;
    RzBinWasmCodeEntry *func = NULL;
 
    if (!bin || !bin->g_sections) {
        return 0;
    }
    if (bin->entrypoint) {
        return bin->entrypoint;
    }
    if (bin->g_start) {
        start = bin->g_start;
    } else if (!(secs = rz_bin_wasm_get_sections_by_id(bin->g_sections, RZ_BIN_WASM_SECTION_START))) {
        return 0;
    } else if (!(sec = (RzBinWasmSection *)rz_list_first(secs))) {
        rz_list_free(secs);
        return 0;
    } else {
        start = rz_bin_wasm_get_start(bin, sec);
        bin->g_start = start;
    }
    if (!start) {
        rz_list_free(secs);
        return 0;
    }
    // FIX: entrypoint can be also an import
    if (!bin->g_codes) {
        rz_list_free(secs);
        return 0;
    }
    func = rz_list_get_n(bin->g_codes, start->index);
    rz_list_free(secs);
    return (ut32)(func ? func->code : 0);
}

References rz_bin_wasm_code_t::code, NULL, rz_bin_wasm_get_sections_by_id(), rz_bin_wasm_get_start(), RZ_BIN_WASM_SECTION_START, rz_list_first(), rz_list_free(), rz_list_get_n(), and start.

Referenced by entries(), and rz_bin_wasm_init().

rz_bin_wasm_get_exports()

RzList* rz_bin_wasm_get_exports

(

RzBinWasmObj *

bin

)

Definition at line 1026 of file wasm.c.

                                                   {
    RzBinWasmSection *export = NULL;
    RzList *exports = NULL;
 
    if (!bin || !bin->g_sections) {
        return NULL;
    }
    if (bin->g_exports) {
        return bin->g_exports;
    }
    if (!(exports = rz_bin_wasm_get_sections_by_id(bin->g_sections, RZ_BIN_WASM_SECTION_EXPORT))) {
        return rz_list_new();
    }
    // support for multiple export sections against spec
    if (!(export = (RzBinWasmSection *)rz_list_first(exports))) {
        rz_list_free(exports);
        return rz_list_new();
    }
    bin->g_exports = rz_bin_wasm_get_export_entries(bin, export);
    rz_list_free(exports);
    return bin->g_exports;
}

References NULL, rz_bin_wasm_get_export_entries(), rz_bin_wasm_get_sections_by_id(), RZ_BIN_WASM_SECTION_EXPORT, rz_list_first(), rz_list_free(), and rz_list_new().

Referenced by rz_bin_wasm_init(), and symbols().

rz_bin_wasm_get_function_name()

const char* rz_bin_wasm_get_function_name	(	RzBinWasmObj *	bin,
		ut32	idx
	)

Definition at line 1237 of file wasm.c.

                                                                       {
    if (!(bin && bin->g_names)) {
        return NULL;
    };
 
    RzListIter *iter;
    RzBinWasmCustomNameEntry *nam;
    rz_list_foreach (bin->g_names, iter, nam) {
        if (nam->type == RZ_BIN_WASM_NAMETYPE_Function) {
            struct rz_bin_wasm_name_t *n = NULL;
 
            if ((n = rz_id_storage_get(nam->func->names, idx))) {
                return (const char *)n->name;
            }
        }
    }
 
    return NULL;
}

References rz_bin_wasm_custom_name_entry_t::func, setup::idx, n, rz_bin_wasm_custom_name_function_names_t::names, NULL, RZ_BIN_WASM_NAMETYPE_Function, rz_id_storage_get(), and rz_bin_wasm_custom_name_entry_t::type.

Referenced by symbols().

rz_bin_wasm_get_globals()

RzList* rz_bin_wasm_get_globals

(

RzBinWasmObj *

bin

)

Definition at line 1122 of file wasm.c.

                                                   {
    RzBinWasmSection *global = NULL;
    RzList *globals = NULL;
 
    if (!bin || !bin->g_sections) {
        return NULL;
    }
    if (bin->g_globals) {
        return bin->g_globals;
    }
    if (!(globals = rz_bin_wasm_get_sections_by_id(bin->g_sections, RZ_BIN_WASM_SECTION_GLOBAL))) {
        return rz_list_new();
    }
    // support for multiple export sections against spec
    if (!(global = (RzBinWasmSection *)rz_list_first(globals))) {
        rz_list_free(globals);
        return rz_list_new();
    }
    bin->g_globals = rz_bin_wasm_get_global_entries(bin, global);
    rz_list_free(globals);
    return bin->g_globals;
}

References NULL, rz_bin_wasm_get_global_entries(), rz_bin_wasm_get_sections_by_id(), RZ_BIN_WASM_SECTION_GLOBAL, rz_list_first(), rz_list_free(), and rz_list_new().

Referenced by rz_bin_wasm_init().

rz_bin_wasm_get_imports()

RzList* rz_bin_wasm_get_imports

(

RzBinWasmObj *

bin

)

Definition at line 1003 of file wasm.c.

                                                   {
    RzBinWasmSection *import = NULL;
    RzList *imports = NULL;
 
    if (!bin || !bin->g_sections) {
        return NULL;
    }
    if (bin->g_imports) {
        return bin->g_imports;
    }
    if (!(imports = rz_bin_wasm_get_sections_by_id(bin->g_sections, RZ_BIN_WASM_SECTION_IMPORT))) {
        return rz_list_new();
    }
    // support for multiple import sections against spec
    if (!(import = (RzBinWasmSection *)rz_list_first(imports))) {
        rz_list_free(imports);
        return rz_list_new();
    }
    bin->g_imports = rz_bin_wasm_get_import_entries(bin, import);
    rz_list_free(imports);
    return bin->g_imports;
}

References imports(), NULL, rz_bin_wasm_get_import_entries(), rz_bin_wasm_get_sections_by_id(), RZ_BIN_WASM_SECTION_IMPORT, rz_list_first(), rz_list_free(), and rz_list_new().

Referenced by imports(), rz_bin_wasm_init(), and symbols().

rz_bin_wasm_get_memories()

RzList* rz_bin_wasm_get_memories

(

RzBinWasmObj *

bin

)

Definition at line 1095 of file wasm.c.

                                                    {
    RzBinWasmSection *memory;
    RzList *memories;
 
    if (!bin || !bin->g_sections) {
        return NULL;
    }
 
    if (bin->g_memories) {
        return bin->g_memories;
    }
 
    if (!(memories = rz_bin_wasm_get_sections_by_id(bin->g_sections, RZ_BIN_WASM_SECTION_MEMORY))) {
        return rz_list_new();
    }
 
    // support for multiple export sections against spec
    if (!(memory = (RzBinWasmSection *)rz_list_first(memories))) {
        rz_list_free(memories);
        return rz_list_new();
    }
 
    bin->g_memories = rz_bin_wasm_get_memory_entries(bin, memory);
    rz_list_free(memories);
    return bin->g_memories;
}

References NULL, rz_bin_wasm_get_memory_entries(), rz_bin_wasm_get_sections_by_id(), RZ_BIN_WASM_SECTION_MEMORY, rz_list_first(), rz_list_free(), and rz_list_new().

Referenced by rz_bin_wasm_init().

rz_bin_wasm_get_sections()

RzList* rz_bin_wasm_get_sections

(

RzBinWasmObj *

bin

)

Definition at line 846 of file wasm.c.

                                                    {
    RzList *ret = NULL;
    RzBinWasmSection *ptr = NULL;
 
    if (!bin) {
        return NULL;
    }
    if (bin->g_sections) {
        return bin->g_sections;
    }
    if (!(ret = rz_list_newf((RzListFree)free))) {
        return NULL;
    }
    RzBuffer *b = bin->buf;
    ut64 max = rz_buf_size(b) - 1;
    rz_buf_seek(b, 8, RZ_BUF_SET);
    while (rz_buf_tell(b) <= max) {
        if (!(ptr = RZ_NEW0(RzBinWasmSection))) {
            return ret;
        }
        if (!(consume_u7_r(b, max, &ptr->id))) {
            goto beach;
        }
        if (!(consume_u32_r(b, max, &ptr->size))) {
            goto beach;
        }
        // against spec. TODO: choose criteria for parsing
        if (ptr->size < 1) {
            goto beach;
            // free (ptr);
            // continue;
        }
        if (!(rz_buf_tell(b) + (ut64)ptr->size - 1 <= max)) {
            goto beach;
        }
        ptr->count = 0;
        ptr->offset = rz_buf_tell(b);
        switch (ptr->id) {
        case RZ_BIN_WASM_SECTION_CUSTOM:
            if (!(consume_u32_r(b, max, &ptr->name_len))) {
                goto beach;
            }
            if (consume_str_r(b, max, ptr->name_len, (char *)ptr->name) < ptr->name_len) {
                goto beach;
            }
            break;
        case RZ_BIN_WASM_SECTION_TYPE:
            strcpy(ptr->name, "type");
            ptr->name_len = 4;
            break;
        case RZ_BIN_WASM_SECTION_IMPORT:
            strcpy(ptr->name, "import");
            ptr->name_len = 6;
            break;
        case RZ_BIN_WASM_SECTION_FUNCTION:
            strcpy(ptr->name, "function");
            ptr->name_len = 8;
            break;
        case RZ_BIN_WASM_SECTION_TABLE:
            strcpy(ptr->name, "table");
            ptr->name_len = 5;
            break;
        case RZ_BIN_WASM_SECTION_MEMORY:
            strcpy(ptr->name, "memory");
            ptr->name_len = 6;
            break;
        case RZ_BIN_WASM_SECTION_GLOBAL:
            strcpy(ptr->name, "global");
            ptr->name_len = 6;
            break;
        case RZ_BIN_WASM_SECTION_EXPORT:
            strcpy(ptr->name, "export");
            ptr->name_len = 6;
            break;
        case RZ_BIN_WASM_SECTION_START:
            strcpy(ptr->name, "start");
            ptr->name_len = 5;
            break;
        case RZ_BIN_WASM_SECTION_ELEMENT:
            strcpy(ptr->name, "element");
            ptr->name_len = 7;
            break;
        case RZ_BIN_WASM_SECTION_CODE:
            strcpy(ptr->name, "code");
            ptr->name_len = 4;
            break;
        case RZ_BIN_WASM_SECTION_DATA:
            strcpy(ptr->name, "data");
            ptr->name_len = 4;
            break;
        default:
            RZ_LOG_ERROR("wasm: unkown section id: %d\n", ptr->id);
            rz_buf_seek(b, ptr->size - 1, RZ_BUF_CUR);
            continue;
        }
        if (ptr->id != RZ_BIN_WASM_SECTION_START && ptr->id != RZ_BIN_WASM_SECTION_CUSTOM) {
            if (!(consume_u32_r(b, max, &ptr->count))) {
                goto beach;
            }
        }
        ptr->payload_data = rz_buf_tell(b);
        ptr->payload_len = ptr->size - (ptr->payload_data - ptr->offset);
        if (ptr->payload_len > ptr->size) {
            goto beach;
        }
        rz_buf_seek(b, ptr->payload_len, RZ_BUF_CUR);
        if (!rz_list_append(ret, ptr)) {
            free(ptr);
            // should it jump to beach?
        }
        ptr = NULL;
    }
    bin->g_sections = ret;
    return ret;
beach:
    RZ_LOG_ERROR("wasm: failed to read sections\n");
    free(ptr);
    return ret;
}

References b, bin::buf, consume_str_r(), consume_u32_r(), consume_u7_r(), rz_bin_wasm_section_t::count, free(), rz_bin_wasm_section_t::id, max, rz_bin_wasm_section_t::name, rz_bin_wasm_section_t::name_len, NULL, rz_bin_wasm_section_t::offset, rz_bin_wasm_section_t::payload_data, rz_bin_wasm_section_t::payload_len, RZ_BIN_WASM_SECTION_CODE, RZ_BIN_WASM_SECTION_CUSTOM, RZ_BIN_WASM_SECTION_DATA, RZ_BIN_WASM_SECTION_ELEMENT, RZ_BIN_WASM_SECTION_EXPORT, RZ_BIN_WASM_SECTION_FUNCTION, RZ_BIN_WASM_SECTION_GLOBAL, RZ_BIN_WASM_SECTION_IMPORT, RZ_BIN_WASM_SECTION_MEMORY, RZ_BIN_WASM_SECTION_START, RZ_BIN_WASM_SECTION_TABLE, RZ_BIN_WASM_SECTION_TYPE, RZ_BUF_CUR, rz_buf_seek(), RZ_BUF_SET, rz_buf_size(), rz_buf_tell(), rz_list_append(), rz_list_newf(), RZ_LOG_ERROR, RZ_NEW0, rz_bin_wasm_section_t::size, and ut64().

Referenced by rz_bin_wasm_init(), and sections().

rz_bin_wasm_get_tables()

RzList* rz_bin_wasm_get_tables

(

RzBinWasmObj *

bin

)

Definition at line 1072 of file wasm.c.

                                                  {
    RzBinWasmSection *table = NULL;
    RzList *tables = NULL;
 
    if (!bin || !bin->g_sections) {
        return NULL;
    }
    if (bin->g_tables) {
        return bin->g_tables;
    }
    if (!(tables = rz_bin_wasm_get_sections_by_id(bin->g_sections, RZ_BIN_WASM_SECTION_TABLE))) {
        return rz_list_new();
    }
    // support for multiple export sections against spec
    if (!(table = (RzBinWasmSection *)rz_list_first(tables))) {
        rz_list_free(tables);
        return rz_list_new();
    }
    bin->g_tables = rz_bin_wasm_get_table_entries(bin, table);
    rz_list_free(tables);
    return bin->g_tables;
}

References NULL, rz_bin_wasm_get_sections_by_id(), rz_bin_wasm_get_table_entries(), RZ_BIN_WASM_SECTION_TABLE, rz_list_first(), rz_list_free(), and rz_list_new().

Referenced by rz_bin_wasm_init().

rz_bin_wasm_get_types()

RzList* rz_bin_wasm_get_types

(

RzBinWasmObj *

bin

)

Definition at line 1049 of file wasm.c.

                                                 {
    RzBinWasmSection *type = NULL;
    RzList *types = NULL;
 
    if (!bin || !bin->g_sections) {
        return NULL;
    }
    if (bin->g_types) {
        return bin->g_types;
    }
    if (!(types = rz_bin_wasm_get_sections_by_id(bin->g_sections, RZ_BIN_WASM_SECTION_TYPE))) {
        return rz_list_new();
    }
    // support for multiple export sections against spec
    if (!(type = (RzBinWasmSection *)rz_list_first(types))) {
        rz_list_free(types);
        return rz_list_new();
    }
    bin->g_types = rz_bin_wasm_get_type_entries(bin, type);
    rz_list_free(types);
    return bin->g_types;
}

References NULL, rz_bin_wasm_get_sections_by_id(), rz_bin_wasm_get_type_entries(), RZ_BIN_WASM_SECTION_TYPE, rz_list_first(), rz_list_free(), rz_list_new(), type, and types.

Referenced by rz_bin_wasm_init().

rz_bin_wasm_init()

RzBinWasmObj* rz_bin_wasm_init	(	RzBinFile *	bf,
		RzBuffer *	buf
	)

Definition at line 761 of file wasm.c.

                                                             {
    RzBinWasmObj *bin = RZ_NEW0(RzBinWasmObj);
    if (!bin) {
        return NULL;
    }
    bin->buf = rz_buf_ref(buf);
    bin->size = (ut32)rz_buf_size(bf->buf);
    bin->g_sections = rz_bin_wasm_get_sections(bin);
    // TODO: recursive invocation more natural with streamed parsing
    // but dependency problems when sections are disordered (against spec)
 
    bin->g_types = rz_bin_wasm_get_types(bin);
    bin->g_imports = rz_bin_wasm_get_imports(bin);
    bin->g_exports = rz_bin_wasm_get_exports(bin);
    bin->g_tables = rz_bin_wasm_get_tables(bin);
    bin->g_memories = rz_bin_wasm_get_memories(bin);
    bin->g_globals = rz_bin_wasm_get_globals(bin);
    bin->g_codes = rz_bin_wasm_get_codes(bin);
    bin->g_datas = rz_bin_wasm_get_datas(bin);
 
    bin->g_names = rz_bin_wasm_get_custom_names(bin);
 
    // entrypoint from Start section
    bin->entrypoint = rz_bin_wasm_get_entrypoint(bin);
 
    return bin;
}

References rz_bin_file_t::buf, bin::buf, NULL, rz_bin_wasm_get_codes(), rz_bin_wasm_get_custom_names(), rz_bin_wasm_get_datas(), rz_bin_wasm_get_entrypoint(), rz_bin_wasm_get_exports(), rz_bin_wasm_get_globals(), rz_bin_wasm_get_imports(), rz_bin_wasm_get_memories(), rz_bin_wasm_get_sections(), rz_bin_wasm_get_tables(), rz_bin_wasm_get_types(), rz_buf_ref(), rz_buf_size(), and RZ_NEW0.

Referenced by load_buffer().

rz_bin_wasm_valuetype_to_string()

const char* rz_bin_wasm_valuetype_to_string

(

rz_bin_wasm_value_type_t

type

)