CloudEdge/wasm-micro-runtime
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update wasm_c_api to use vector types (#751)

Browse Source 
The WASM C API now requires the use of vector types in certain apis.
Switching WAMR to use the new call signatures improves "drop in"
compilation compatibility between WAMR and other implementations
from a C-api embedding program's perspective.

* wasm_func_callback_t type has been updated to use wasm_val_vec_t
* wasm_func_callback_with_env_t type has been updated to use wasm_val_vec_t
* wasm_func_call() has been updated to use wasm_val_vec_t
* wasm_instance_new() has been updated to use wasm_extern_vec_t*
* wasm_instance_new_with_args() has been updated to use wasm_extern_vec_t*
* wasm_runtime_invoke_c_api_native() has been updated to support vector types
  in native callbacks without modifying the contract with the interpreter code.
* All users of the modified functions (including samples/wasm-c-api/src/*.c)
  have been appropriately updated.
This commit is contained in:
Saju Pillai 2021-09-15 23:54:25 -07:00 committed by GitHub
parent ed32693fc8
commit 76d641c7ea
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
13 changed files with 186 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
core/iwasm/common/wasm_c_api.c
View File

@ -2739,8 +2739,8 @@ failed:
wasm_trap_t *
wasm_func_call(const wasm_func_t *func,
const wasm_val_t params[],
wasm_val_t results[])
const wasm_val_vec_t *params,
wasm_val_vec_t *results)
{
/* parameters count as if all are uint32 */
/* a int64 or float64 parameter means 2 */
@ -2804,7 +2804,7 @@ wasm_func_call(const wasm_func_t *func,
/* copy parametes */
if (param_count
&& !(argc = params_to_argv(func->inst_comm_rt, params,
&& !(argc = params_to_argv(func->inst_comm_rt, params->data,
wasm_functype_params(func->type),
param_count, argv))) {
goto failed;
@ -2826,9 +2826,11 @@ wasm_func_call(const wasm_func_t *func,
/* copy results */
if (result_count) {
if (!(argc = argv_to_results(argv, wasm_functype_results(func->type),
result_count, results))) {
result_count, results->data))) {
goto failed;
}
results->num_elems = result_count;
results->size = result_count;
}
if (argv != argv_buf)
@ -4261,7 +4263,7 @@ failed:
wasm_instance_t *
wasm_instance_new(wasm_store_t *store,
const wasm_module_t *module,
const wasm_extern_t *const imports[],
const wasm_extern_vec_t *imports,
own wasm_trap_t **traps)
{
return wasm_instance_new_with_args(store, module, imports, traps,
@ -4271,7 +4273,7 @@ wasm_instance_new(wasm_store_t *store,
wasm_instance_t *
wasm_instance_new_with_args(wasm_store_t *store,
const wasm_module_t *module,
const wasm_extern_t *const imports[],
const wasm_extern_vec_t *imports,
own wasm_trap_t **traps,
const uint32 stack_size,
const uint32 heap_size)
@ -4305,7 +4307,7 @@ wasm_instance_new_with_args(wasm_store_t *store,
if (import_count) {
uint32 actual_link_import_count = interp_link(
instance, MODULE_INTERP(module), (wasm_extern_t **)imports);
instance, MODULE_INTERP(module), (wasm_extern_t **)imports->data);
/* make sure a complete import list */
if ((int32)import_count < 0
|| import_count != actual_link_import_count) {
@ -4327,7 +4329,7 @@ wasm_instance_new_with_args(wasm_store_t *store,
if (import_count) {
import_count = aot_link(instance, MODULE_AOT(module),
(wasm_extern_t **)imports);
(wasm_extern_t **)imports->data);
if ((int32)import_count < 0) {
goto failed;
}
@ -4356,8 +4358,8 @@ wasm_instance_new_with_args(wasm_store_t *store,
}
/* fill with inst */
for (i = 0; imports && i < (uint32)import_count; ++i) {
wasm_extern_t *import = (wasm_extern_t *)imports[i];
for (i = 0; imports && imports->data && i < (uint32)import_count; ++i) {
wasm_extern_t *import = imports->data[i];
switch (import->kind) {
case WASM_EXTERN_FUNC:
wasm_extern_as_func(import)->inst_comm_rt =

17
core/iwasm/common/wasm_runtime_common.c
View File

@ -4104,6 +4104,7 @@ wasm_runtime_invoke_c_api_native(WASMModuleInstanceCommon *module_inst,
wasm_val_t *params = params_buf, *results = results_buf;
wasm_trap_t *trap = NULL;
bool ret = false;
wasm_val_vec_t params_vec, results_vec;
if (func_type->param_count > 16
&& !(params = wasm_runtime_malloc(sizeof(wasm_val_t)
@ -4124,14 +4125,24 @@ wasm_runtime_invoke_c_api_native(WASMModuleInstanceCommon *module_inst,
goto fail;
}
params_vec.data = params;
params_vec.num_elems = func_type->param_count;
params_vec.size = func_type->param_count;
params_vec.size_of_elem = sizeof(wasm_val_t);
results_vec.data = results;
results_vec.num_elems = 0;
results_vec.size = func_type->result_count;
results_vec.size_of_elem = sizeof(wasm_val_t);
if (!with_env) {
wasm_func_callback_t callback = (wasm_func_callback_t)func_ptr;
trap = callback(params, results);
trap = callback(&params_vec, &results_vec);
}
else {
wasm_func_callback_with_env_t callback =
(wasm_func_callback_with_env_t)func_ptr;
trap = callback(wasm_c_api_env, params, results);
trap = callback(wasm_c_api_env, &params_vec, &results_vec);
}
if (trap) {
@ -4155,7 +4166,7 @@ wasm_runtime_invoke_c_api_native(WASMModuleInstanceCommon *module_inst,
wasm_runtime_set_exception(module_inst, "unsupported result type");
goto fail;
}
results_vec.num_elems = func_type->result_count;
ret = true;
fail:

10
core/iwasm/include/wasm_c_api.h
View File

@ -467,9 +467,9 @@ WASM_API_EXTERN own wasm_module_t* wasm_module_deserialize(wasm_store_t*, const
WASM_DECLARE_REF(func)
typedef own wasm_trap_t* (*wasm_func_callback_t)(
const wasm_val_t args[], own wasm_val_t results[]);
const wasm_val_vec_t* args, own wasm_val_vec_t *results);
typedef own wasm_trap_t* (*wasm_func_callback_with_env_t)(
void* env, const wasm_val_t args[], wasm_val_t results[]);
void* env, const wasm_val_vec_t *args, wasm_val_vec_t *results);
WASM_API_EXTERN own wasm_func_t* wasm_func_new(
wasm_store_t*, const wasm_functype_t*, wasm_func_callback_t);
@ -482,7 +482,7 @@ WASM_API_EXTERN size_t wasm_func_param_arity(const wasm_func_t*);
WASM_API_EXTERN size_t wasm_func_result_arity(const wasm_func_t*);
WASM_API_EXTERN own wasm_trap_t* wasm_func_call(
const wasm_func_t*, const wasm_val_t args[], wasm_val_t results[]);
const wasm_func_t*, const wasm_val_vec_t* args, wasm_val_vec_t* results);
// Global Instances
@ -569,13 +569,13 @@ WASM_API_EXTERN const wasm_memory_t* wasm_extern_as_memory_const(const wasm_exte
WASM_DECLARE_REF(instance)
WASM_API_EXTERN own wasm_instance_t* wasm_instance_new(
wasm_store_t*, const wasm_module_t*, const wasm_extern_t *const imports[],
wasm_store_t*, const wasm_module_t*, const wasm_extern_vec_t *imports,
own wasm_trap_t**
);
// please refer to wasm_runtime_instantiate(...) in core/iwasm/include/wasm_export.h
WASM_API_EXTERN own wasm_instance_t* wasm_instance_new_with_args(
wasm_store_t*, const wasm_module_t*, const wasm_extern_t *const imports[],
wasm_store_t*, const wasm_module_t*, const wasm_extern_vec_t *imports,
own wasm_trap_t**, const uint32_t stack_size, const uint32_t heap_size
);

29
samples/wasm-c-api/src/callback.c
View File

@ -35,27 +35,27 @@ void wasm_val_print(wasm_val_t val) {
// A function to be called from Wasm code.
own wasm_trap_t* print_callback(
const wasm_val_t args[], wasm_val_t results[]
const wasm_val_vec_t *args, wasm_val_vec_t *results
) {
printf("Calling back...\n> ");
wasm_val_print(args[0]);
wasm_val_print(args->data[0]);
printf("\n");
wasm_val_copy(&results[0], &args[0]);
wasm_val_copy(&results->data[0], &args->data[0]);
return NULL;
}
// A function closure.
own wasm_trap_t* closure_callback(
void* env, const wasm_val_t args[], wasm_val_t results[]
void* env, const wasm_val_vec_t *args, wasm_val_vec_t *results
) {
int i = *(int*)env;
printf("Calling back closure...\n");
printf("> %d\n", i);
results[0].kind = WASM_I32;
results[0].of.i32 = (int32_t)i;
results->data[0].kind = WASM_I32;
results->data[0].of.i32 = (int32_t)i;
return NULL;
}
@ -113,11 +113,13 @@ int main(int argc, const char* argv[]) {
// Instantiate.
printf("Instantiating module...\n");
const wasm_extern_t* imports[] = {
wasm_extern_vec_t imports;
wasm_extern_vec_new(&imports, 2, (wasm_extern_t *[]) {
wasm_func_as_extern(print_func), wasm_func_as_extern(closure_func)
};
});
own wasm_instance_t* instance =
wasm_instance_new(store, module, imports, NULL);
wasm_instance_new(store, module, &imports, NULL);
if (!instance) {
printf("> Error instantiating module!\n");
return 1;
@ -145,9 +147,10 @@ int main(int argc, const char* argv[]) {
// Call.
printf("Calling export...\n");
wasm_val_t args[2] = { WASM_I32_VAL(3), WASM_I32_VAL(4) };
wasm_val_t results[1] = { WASM_INIT_VAL };
if (wasm_func_call(run_func, args, results)) {
wasm_val_vec_t args, results;
wasm_val_vec_new(&args, 2, (wasm_val_t[]){ WASM_I32_VAL(3), WASM_I32_VAL(4) });
wasm_val_vec_new(&results, 1, (wasm_val_t[]) { WASM_INIT_VAL });
if (wasm_func_call(run_func, &args, &results)) {
printf("> Error calling function!\n");
return 1;
}
@ -156,7 +159,7 @@ int main(int argc, const char* argv[]) {
// Print result.
printf("Printing result...\n");
printf("> %u\n", results[0].of.i32);
printf("> %u\n", results.data[0].of.i32);
// Shut down.
printf("Shutting down...\n");

29
samples/wasm-c-api/src/callback_chain.c
View File

@ -17,8 +17,8 @@ get_memory_data(uint32_t offset, uint32_t length);
static bool
call_wasm_function(uint32_t export_id,
const wasm_val_t *args,
wasm_val_t *results,
const wasm_val_vec_t *args,
wasm_val_vec_t *results,
const char *name);
/************************ IMPORTED FUNCTIONS **************************/
@ -49,7 +49,7 @@ enum EXPORT_ITEM_NAME {
};
#define DEFINE_FUNCTION(name) \
wasm_trap_t *STUB_##name(const wasm_val_t args[], wasm_val_t results[])
wasm_trap_t *STUB_##name(const wasm_val_vec_t* args, wasm_val_vec_t* results)
#define DEFINE_EMPTY_FUNCTION(name) \
DEFINE_FUNCTION(name) \
@ -61,16 +61,17 @@ enum EXPORT_ITEM_NAME {
DEFINE_FUNCTION(get_pairs)
{
wasm_val_t ret[1] = { WASM_INIT_VAL };
call_wasm_function(e_malloc, (wasm_val_t[]){ WASM_I32_VAL(24) }, ret,
"malloc");
wasm_val_vec_t arg, ret;
wasm_val_vec_new(&ret, 1, (wasm_val_t []){ WASM_INIT_VAL });
wasm_val_vec_new(&arg, 1, (wasm_val_t []){ WASM_I32_VAL(24) });
call_wasm_function(e_malloc, &arg, &ret, "malloc");
return NULL;
}
DEFINE_FUNCTION(log)
{
wasm_val_t offset = args[0];
wasm_val_t length = args[1];
wasm_val_t offset = args->data[0];
wasm_val_t length = args->data[1];
const byte_t *data = NULL;
printf("[WASM -> NATIVE] calling back %s\n", __FUNCTION__);
@ -120,8 +121,8 @@ get_memory_data(uint32_t offset, uint32_t length)
static bool
call_wasm_function(uint32_t export_id,
const wasm_val_t *args,
wasm_val_t *results,
const wasm_val_vec_t *args,
wasm_val_vec_t *results,
const char *name)
{
const wasm_func_t *function;
@ -203,7 +204,8 @@ main(int argc, const char *argv[])
IMPORT_FUNCTION_LIST(IMPORT_FUNCTION_VARIABLE_NAME)
#undef IMPORT_FUNCTION_VARIABLE_NAME
const wasm_extern_t *imports[10] = { 0 };
wasm_extern_vec_t imports;
wasm_extern_vec_new_uninitialized(&imports, 10);
#define CREATE_WASM_FUNCTION(name, index, CREATE_FUNC_TYPE) \
{ \
@ -218,13 +220,14 @@ main(int argc, const char *argv[])
#undef CREATE_WASM_FUNCTION
#define ADD_TO_FUNCTION_LIST(name, index, ...) \
imports[index] = wasm_func_as_extern(function_##name);
imports.data[index] = wasm_func_as_extern(function_##name); \
imports.num_elems += 1;
IMPORT_FUNCTION_LIST(ADD_TO_FUNCTION_LIST)
#undef CREATE_IMPORT_FUNCTION
own wasm_instance_t *instance =
wasm_instance_new(store, module, imports, NULL);
wasm_instance_new(store, module, &imports, NULL);
if (!instance) {
printf("> Error instantiating module!\n");
return 1;

40
samples/wasm-c-api/src/global.c
View File

@ -39,9 +39,10 @@ wasm_func_t* get_export_func(const wasm_extern_vec_t* exports, size_t i) {
#define check_call(func, type, expected) \
{ \
wasm_val_t results[1]; \
wasm_func_call(func, NULL, results); \
check(results[0], type, expected); \
wasm_val_vec_t results; \
wasm_val_vec_new_uninitialized(&results, 1); \
wasm_func_call(func, NULL, &results); \
check(results.data[0], type, expected); \
}
@ -115,14 +116,21 @@ int main(int argc, const char* argv[]) {
// Instantiate.
printf("Instantiating module...\n");
const wasm_extern_t* imports[] = {
/*const wasm_extern_t* imports1[] = {
wasm_global_as_extern(const_f32_import),
wasm_global_as_extern(const_i64_import),
wasm_global_as_extern(var_f32_import),
wasm_global_as_extern(var_i64_import)
};
};*/
wasm_extern_vec_t imports;
wasm_extern_vec_new(&imports, 4, (wasm_extern_t* []) {
wasm_global_as_extern(const_f32_import),
wasm_global_as_extern(const_i64_import),
wasm_global_as_extern(var_f32_import),
wasm_global_as_extern(var_i64_import)
});
own wasm_instance_t* instance =
wasm_instance_new(store, module, imports, NULL);
wasm_instance_new(store, module, &imports, NULL);
if (!instance) {
printf("> Error instantiating module!\n");
return 1;
@ -200,14 +208,18 @@ int main(int argc, const char* argv[]) {
check_call(get_var_i64_export, i64, 38);
// Modify variables through calls and check again.
wasm_val_t args73[] = { WASM_F32_VAL(73) };
wasm_func_call(set_var_f32_import, args73, NULL);
wasm_val_t args74[] = { WASM_I64_VAL(74) };
wasm_func_call(set_var_i64_import, args74, NULL);
wasm_val_t args77[] = { WASM_F32_VAL(77) };
wasm_func_call(set_var_f32_export, args77, NULL);
wasm_val_t args78[] = { WASM_I64_VAL(78) };
wasm_func_call(set_var_i64_export, args78, NULL);
wasm_val_vec_t args73;
wasm_val_vec_new(&args73, 1, (wasm_val_t []){ WASM_F32_VAL(73) });
wasm_func_call(set_var_f32_import, &args73, NULL);
wasm_val_vec_t args74;
wasm_val_vec_new(&args74, 1, (wasm_val_t []){ WASM_I64_VAL(74) });
wasm_func_call(set_var_i64_import, &args74, NULL);
wasm_val_vec_t args77;
wasm_val_vec_new(&args77, 1, (wasm_val_t []){ WASM_F32_VAL(77) });
wasm_func_call(set_var_f32_export, &args77, NULL);
wasm_val_vec_t args78;
wasm_val_vec_new(&args78, 1, (wasm_val_t []){ WASM_I64_VAL(78) });
wasm_func_call(set_var_i64_export, &args78, NULL);
check_global(var_f32_import, f32, 73);
check_global(var_i64_import, i64, 74);

17
samples/wasm-c-api/src/globalexportimport.c
View File

@ -52,9 +52,10 @@ wasm_func_t* get_export_func(const wasm_extern_vec_t* exports, size_t i) {
#define check_call(func, type, expected) \
{ \
wasm_val_t results[1]; \
wasm_func_call(func, NULL, results); \
check(results[0], type, expected); \
wasm_val_vec_t results; \
wasm_val_vec_new_uninitialized(&results, 1); \
wasm_func_call(func, NULL, &results); \
check(results.data[0], type, expected); \
}
wasm_module_t * create_module_from_file(wasm_store_t* store, const char * filename)
@ -146,16 +147,18 @@ int main(int argc, const char* argv[]) {
// Modify variables through calls and check again.
printf("Modify the variable to 77.0...\n");
wasm_val_t args77[] = { {.kind = WASM_F32, .of = {.f32 = 77.}} };
wasm_func_call(set_var_f32_export, args77, NULL); //Call to module export
wasm_val_vec_t args77;
wasm_val_vec_new(&args77, 1, (wasm_val_t []){ {.kind = WASM_F32, .of = {.f32 = 77.0}} });
wasm_func_call(set_var_f32_export, &args77, NULL); //Call to module export
check_call(get_var_f32_export, f32, 77.0); //Call to module export
check_global(var_f32_export, f32, 77.0); //Failed here, still 37
check_call(get_var_f32_import, f32, 77.0); //Call to module import Failed here, still 37
printf("Modify the variable to 78.0...\n");
wasm_val_t args78[] = { {.kind = WASM_F32, .of = {.f32 = 78.0}} };
wasm_func_call(set_var_f32_import, args78, NULL);
wasm_val_vec_t args78;
wasm_val_vec_new(&args78, 1, (wasm_val_t []){ {.kind = WASM_F32, .of = {.f32 = 78.0}} });
wasm_func_call(set_var_f32_import, &args78, NULL);
check_global(var_f32_export, f32, 78.0);
check_call(get_var_f32_export, f32, 78.0); //Call to module export Failed here, still 77
check_call(get_var_f32_import, f32, 78.0); //Call to module import

8
samples/wasm-c-api/src/hello.c
View File

@ -9,7 +9,7 @@
// A function to be called from Wasm code.
own wasm_trap_t* hello_callback(
const wasm_val_t args[], wasm_val_t results[]
const wasm_val_vec_t* args, wasm_val_vec_t* results
) {
printf("Calling back...\n");
printf("> Hello World!\n");
@ -66,9 +66,11 @@ int main(int argc, const char* argv[]) {
// Instantiate.
printf("Instantiating module...\n");
const wasm_extern_t* imports[] = { wasm_func_as_extern(hello_func) };
wasm_extern_vec_t imports;
wasm_extern_vec_new(&imports, 1, (wasm_extern_t* []) { wasm_func_as_extern(hello_func) });
own wasm_instance_t* instance =
wasm_instance_new(store, module, imports, NULL);
wasm_instance_new(store, module, &imports, NULL);
if (!instance) {
printf("> Error instantiating module!\n");
return 1;

46
samples/wasm-c-api/src/hostref.c
View File

@ -10,12 +10,12 @@
// A function to be called from Wasm code.
own wasm_trap_t* callback(
const wasm_val_t args[], wasm_val_t results[]
const wasm_val_vec_t* args, wasm_val_vec_t* results
) {
printf("Calling back...\n> ");
printf("> %p\n",
args[0].of.ref ? wasm_ref_get_host_info(args[0].of.ref) : NULL);
wasm_val_copy(&results[0], &args[0]);
args->data[0].of.ref ? wasm_ref_get_host_info(args->data[0].of.ref) : NULL);
wasm_val_copy(&results->data[0], &args->data[0]);
return NULL;
}
@ -47,19 +47,21 @@ wasm_table_t* get_export_table(const wasm_extern_vec_t* exports, size_t i) {
own wasm_ref_t* call_v_r(const wasm_func_t* func) {
printf("call_v_r... "); fflush(stdout);
wasm_val_t rs[] = { WASM_INIT_VAL };
if (wasm_func_call(func, NULL, rs)) {
wasm_val_vec_t rs;
wasm_val_vec_new_uninitialized(&rs, 1);
if (wasm_func_call(func, NULL, &rs)) {
printf("> Error calling function!\n");
exit(1);
}
printf("okay\n");
return rs[0].of.ref;
return rs.data[0].of.ref;
}
void call_r_v(const wasm_func_t* func, wasm_ref_t* ref) {
printf("call_r_v... "); fflush(stdout);
wasm_val_t vs[1] = { WASM_REF_VAL(ref) };
if (wasm_func_call(func, vs, NULL)) {
wasm_val_vec_t vs;
wasm_val_vec_new(&vs, 1, (wasm_val_t []){ WASM_REF_VAL(ref) });
if (wasm_func_call(func, &vs, NULL)) {
printf("> Error calling function!\n");
exit(1);
}
@ -68,20 +70,22 @@ void call_r_v(const wasm_func_t* func, wasm_ref_t* ref) {
own wasm_ref_t* call_r_r(const wasm_func_t* func, wasm_ref_t* ref) {
printf("call_r_r... "); fflush(stdout);
wasm_val_t vs[1] = { WASM_REF_VAL(ref) };
wasm_val_t rs[1] = { WASM_INIT_VAL };
if (wasm_func_call(func, vs, rs)) {
wasm_val_vec_t vs, rs;
wasm_val_vec_new(&vs, 1, (wasm_val_t []){ WASM_REF_VAL(ref) });
wasm_val_vec_new_uninitialized(&rs, 1);
if (wasm_func_call(func, &vs, &rs)) {
printf("> Error calling function!\n");
exit(1);
}
printf("okay\n");
return rs[0].of.ref;
return rs.data[0].of.ref;
}
void call_ir_v(const wasm_func_t* func, int32_t i, wasm_ref_t* ref) {
printf("call_ir_v... "); fflush(stdout);
wasm_val_t vs[2] = { WASM_I32_VAL(i), WASM_REF_VAL(ref) };
if (wasm_func_call(func, vs, NULL)) {
wasm_val_vec_t vs;
wasm_val_vec_new(&vs, 2, (wasm_val_t []){ WASM_I32_VAL(i), WASM_REF_VAL(ref) });
if (wasm_func_call(func, &vs, NULL)) {
printf("> Error calling function!\n");
exit(1);
}
@ -90,14 +94,15 @@ void call_ir_v(const wasm_func_t* func, int32_t i, wasm_ref_t* ref) {
own wasm_ref_t* call_i_r(const wasm_func_t* func, int32_t i) {
printf("call_i_r... "); fflush(stdout);
wasm_val_t vs[1] = { WASM_I32_VAL(i) };
wasm_val_t rs[1] = { WASM_INIT_VAL };
if (wasm_func_call(func, vs, rs)) {
wasm_val_vec_t vs, rs;
wasm_val_vec_new(&vs, 1, (wasm_val_t []){ WASM_I32_VAL(i) });
wasm_val_vec_new_uninitialized(&rs, 1);
if (wasm_func_call(func, &vs, &rs)) {
printf("> Error calling function!\n");
exit(1);
}
printf("okay\n");
return rs[0].of.ref;
return rs.data[0].of.ref;
}
void
@ -164,9 +169,10 @@ int main(int argc, const char* argv[]) {
// Instantiate.
printf("Instantiating module...\n");
const wasm_extern_t* imports[] = { wasm_func_as_extern(callback_func) };
wasm_extern_vec_t imports;
wasm_extern_vec_new(&imports, 1, (wasm_extern_t* []) { wasm_func_as_extern(callback_func) });
own wasm_instance_t* instance =
wasm_instance_new(store, module, imports, NULL);
wasm_instance_new(store, module, &imports, NULL);
if (!instance) {
printf("> Error instantiating module!\n");
return 1;

19
samples/wasm-c-api/src/memory.c
View File

@ -33,8 +33,13 @@ void check(bool success) {
}
void check_call(wasm_func_t* func, int i, wasm_val_t args[], int32_t expected) {
wasm_val_t results[1] = { WASM_INIT_VAL };
if (wasm_func_call(func, args, results) || results[0].of.i32 != expected) {
wasm_val_vec_t args_vec;
wasm_val_vec_t results_vec;
if (args)
wasm_val_vec_new(&args_vec, i, args);
wasm_val_vec_new(&results_vec, 1, (wasm_val_t []){ WASM_INIT_VAL });
if (wasm_func_call(func, args ? &args_vec : NULL, &results_vec)
|| results_vec.data[0].of.i32 != expected) {
printf("> Error on result\n");
exit(1);
}
@ -55,7 +60,9 @@ void check_call2(wasm_func_t* func, int32_t arg1, int32_t arg2, int32_t expected
}
void check_ok(wasm_func_t* func, int i, wasm_val_t args[]) {
if (wasm_func_call(func, args, NULL)) {
wasm_val_vec_t args_vec;
wasm_val_vec_new(&args_vec, i, args);
if (wasm_func_call(func, &args_vec, NULL)) {
printf("> Error on result, expected empty\n");
exit(1);
}
@ -67,8 +74,10 @@ void check_ok2(wasm_func_t* func, int32_t arg1, int32_t arg2) {
}
void check_trap(wasm_func_t* func, int i, wasm_val_t args[]) {
wasm_val_t results[1] = { WASM_INIT_VAL };
own wasm_trap_t* trap = wasm_func_call(func, args, results);
wasm_val_vec_t args_vec, results_vec;
wasm_val_vec_new(&args_vec, i, args);
wasm_val_vec_new(&results_vec, 1, (wasm_val_t []){ WASM_INIT_VAL });
own wasm_trap_t* trap = wasm_func_call(func, &args_vec, &results_vec);
if (! trap) {
printf("> Error on result, expected trap\n");
exit(1);

44
samples/wasm-c-api/src/multi.c
View File

@ -9,18 +9,18 @@
// A function to be called from Wasm code.
own wasm_trap_t* callback(
const wasm_val_t args[], wasm_val_t results[]
const wasm_val_vec_t *args, wasm_val_vec_t *results
) {
printf("Calling back...\n> ");
printf("> %"PRIu32" %"PRIu64" %"PRIu64" %"PRIu32"\n",
args[0].of.i32, args[1].of.i64,
args[2].of.i64, args[3].of.i32);
args->data[0].of.i32, args->data[1].of.i64,
args->data[2].of.i64, args->data[3].of.i32);
printf("\n");
wasm_val_copy(&results[0], &args[3]);
wasm_val_copy(&results[1], &args[1]);
wasm_val_copy(&results[2], &args[2]);
wasm_val_copy(&results[3], &args[0]);
wasm_val_copy(&results->data[0], &args->data[3]);
wasm_val_copy(&results->data[1], &args->data[1]);
wasm_val_copy(&results->data[2], &args->data[2]);
wasm_val_copy(&results->data[3], &args->data[0]);
return NULL;
}
@ -91,9 +91,10 @@ int main(int argc, const char* argv[]) {
// Instantiate.
printf("Instantiating module...\n");
const wasm_extern_t* imports[] = { wasm_func_as_extern(callback_func) };
wasm_extern_vec_t imports;
wasm_extern_vec_new(&imports, 1, (wasm_extern_t *[]) { wasm_func_as_extern(callback_func) });
own wasm_instance_t* instance =
wasm_instance_new(store, module, imports, NULL);
wasm_instance_new(store, module, &imports, NULL);
if (!instance) {
printf("> Error instantiating module!\n");
return 1;
@ -120,13 +121,14 @@ int main(int argc, const char* argv[]) {
// Call.
printf("Calling export...\n");
wasm_val_t args[4] = {
WASM_I32_VAL(1), WASM_I64_VAL(2), WASM_I64_VAL(3), WASM_I32_VAL(4)
};
wasm_val_t results[4] = {
WASM_INIT_VAL, WASM_INIT_VAL, WASM_INIT_VAL, WASM_INIT_VAL
};
if (wasm_func_call(run_func, args, results)) {
wasm_val_vec_t args, results;
wasm_val_vec_new(&args, 4, (wasm_val_t []){
WASM_I32_VAL(1), WASM_I64_VAL(2), WASM_I64_VAL(3), WASM_I32_VAL(4)
});
wasm_val_vec_new(&results, 4, (wasm_val_t []) {
WASM_INIT_VAL, WASM_INIT_VAL, WASM_INIT_VAL, WASM_INIT_VAL
});
if (wasm_func_call(run_func, &args, &results)) {
printf("> Error calling function!\n");
return 1;
}
@ -136,12 +138,12 @@ int main(int argc, const char* argv[]) {
// Print result.
printf("Printing result...\n");
printf("> %"PRIu32" %"PRIu64" %"PRIu64" %"PRIu32"\n",
results[0].of.i32, results[1].of.i64, results[2].of.i64, results[3].of.i32);
results.data[0].of.i32, results.data[1].of.i64, results.data[2].of.i64, results.data[3].of.i32);
assert(results[0].of.i32 == 1);
assert(results[1].of.i64 == 2);
assert(results[2].of.i64 == 3);
assert(results[3].of.i32 == 4);
assert(results.data[0].of.i32 == 1);
assert(results.data[1].of.i64 == 2);
assert(results.data[2].of.i64 == 3);
assert(results.data[3].of.i32 == 4);
// Shut down.
printf("Shutting down...\n");

20
samples/wasm-c-api/src/table.c
View File

@ -9,11 +9,11 @@
// A function to be called from Wasm code.
own wasm_trap_t* neg_callback(
const wasm_val_t args[], wasm_val_t results[]
const wasm_val_vec_t* args, wasm_val_vec_t* results
) {
printf("Calling back...\n");
results[0].kind = WASM_I32;
results[0].of.i32 = -args[0].of.i32;
results->data[0].kind = WASM_I32;
results->data[0].of.i32 = -args->data[0].of.i32;
return NULL;
}
@ -49,18 +49,20 @@ void check_table(wasm_table_t* table, int32_t i, bool expect_set) {
}
void check_call(wasm_func_t* func, int32_t arg1, int32_t arg2, int32_t expected) {
wasm_val_t args[2] = { WASM_I32_VAL(arg1), WASM_I32_VAL(arg2) };
wasm_val_t results[1] = { WASM_INIT_VAL };
if (wasm_func_call(func, args, results) || results[0].of.i32 != expected) {
wasm_val_vec_t args, results;
wasm_val_vec_new(&args, 2, (wasm_val_t []){ WASM_I32_VAL(arg1), WASM_I32_VAL(arg2) });
wasm_val_vec_new(&results, 1, (wasm_val_t []){ WASM_INIT_VAL });
if (wasm_func_call(func, &args, &results) || results.data[0].of.i32 != expected) {
printf("> Error on result\n");
exit(1);
}
}
void check_trap(wasm_func_t* func, int32_t arg1, int32_t arg2) {
wasm_val_t args[2] = { WASM_I32_VAL(arg1), WASM_I32_VAL(arg2) };
wasm_val_t results[1] = { WASM_INIT_VAL };
own wasm_trap_t* trap = wasm_func_call(func, args, results);
wasm_val_vec_t args, results;
wasm_val_vec_new(&args, 2, (wasm_val_t []){ WASM_I32_VAL(arg1), WASM_I32_VAL(arg2) });
wasm_val_vec_new(&results, 1, (wasm_val_t []){ WASM_INIT_VAL });
own wasm_trap_t* trap = wasm_func_call(func, &args, &results);
if (! trap) {
printf("> Error on result, expected trap\n");
exit(1);

13
samples/wasm-c-api/src/trap.c
View File

@ -9,7 +9,7 @@
// A function to be called from Wasm code.
own wasm_trap_t* fail_callback(
void* env, const wasm_val_t args[], wasm_val_t results[]
void* env, const wasm_val_vec_t* args, wasm_val_vec_t* results
) {
printf("Calling back...\n");
own wasm_name_t message;
@ -80,9 +80,10 @@ int main(int argc, const char* argv[]) {
// Instantiate.
printf("Instantiating module...\n");
const wasm_extern_t* imports[] = { wasm_func_as_extern(fail_func) };
wasm_extern_vec_t imports;
wasm_extern_vec_new(&imports, 1, (wasm_extern_t* []) { wasm_func_as_extern(fail_func) });
own wasm_instance_t* instance =
wasm_instance_new(store, module, imports, NULL);
wasm_instance_new(store, module, &imports, NULL);
if (!instance) {
printf("> Error instantiating module!\n");
return 1;
@ -111,8 +112,10 @@ int main(int argc, const char* argv[]) {
}
printf("Calling export %d...\n", i);
wasm_val_t results[1]; \
own wasm_trap_t* trap = wasm_func_call(func, NULL, results);
wasm_val_vec_t results;
wasm_val_vec_new_uninitialized(&results, 1);
own wasm_trap_t* trap = wasm_func_call(func, NULL, &results);
if (!trap) {
printf("> Error calling function, expected trap!\n");
return 1;