From fc8f70cfa42919070c6ccc7be0998f70506d2b9e Mon Sep 17 00:00:00 2001 From: "liang.he" Date: Thu, 1 Dec 2022 22:03:09 +0800 Subject: [PATCH] Fix issues detected by Coverity (#1776) - wasm_func_call always return trap if failed - in Debug, always run LEAK_TEST in samples/wasm-c-api --- core/iwasm/common/wasm_c_api.c | 1 + samples/wasm-c-api/CMakeLists.txt | 13 ++++--- samples/wasm-c-api/src/callback.c | 8 +++-- samples/wasm-c-api/src/clone.c | 8 +++-- samples/wasm-c-api/src/empty_imports.c | 14 +++++--- samples/wasm-c-api/src/global.c | 38 +++++++++++++------- samples/wasm-c-api/src/globalexportimport.c | 29 ++++++++++----- samples/wasm-c-api/src/hello.c | 8 +++-- samples/wasm-c-api/src/hostref.c | 40 +++++++++++++-------- samples/wasm-c-api/src/memory.c | 21 +++++++---- samples/wasm-c-api/src/multi.c | 8 +++-- samples/wasm-c-api/src/serialize.c | 4 ++- samples/wasm-c-api/src/table.c | 13 +++++-- samples/wasm-c-api/src/threads.c | 4 ++- 14 files changed, 143 insertions(+), 66 deletions(-) diff --git a/core/iwasm/common/wasm_c_api.c b/core/iwasm/common/wasm_c_api.c index 212a7780..6908fbf4 100644 --- a/core/iwasm/common/wasm_c_api.c +++ b/core/iwasm/common/wasm_c_api.c @@ -2112,6 +2112,7 @@ wasm_module_imports(const wasm_module_t *module, own wasm_importtype_vec_t *out) memset(&module_name, 0, sizeof(wasm_val_vec_t)); memset(&name, 0, sizeof(wasm_val_vec_t)); extern_type = NULL; + import_type = NULL; if (i < import_func_count) { wasm_functype_t *type = NULL; diff --git a/samples/wasm-c-api/CMakeLists.txt b/samples/wasm-c-api/CMakeLists.txt index 2b3a02db..3fce87c0 100644 --- a/samples/wasm-c-api/CMakeLists.txt +++ b/samples/wasm-c-api/CMakeLists.txt @@ -199,11 +199,16 @@ if (CMAKE_BUILD_TYPE STREQUAL "Debug") if(VALGRIND) foreach(EX ${EXAMPLES}) - add_custom_target(${EX}_LEAK_TEST - COMMAND ${VALGRIND} --tool=memcheck --leak-check=yes ./${EX} + add_custom_command( + OUTPUT ${EX}_leak_check.report DEPENDS ${EX} ${EX}_WASM - VERBATIM - COMMENT "run a leak check on ${EX}" + COMMAND ${VALGRIND} --tool=memcheck --leak-check=summary -- ./${EX} > ${EX}_leak_check.report 2>&1 + WORKING_DIRECTORY ${CMAKE_BINARY_DIR} + ) + add_custom_target(${EX}_LEAK_TEST ALL + DEPENDS ${EX}_leak_check.report + COMMAND grep "All heap blocks were freed -- no leaks are possible" ${EX}_leak_check.report + COMMENT "Please read ${EX}_leak_check.report when meeting Error" ) endforeach() endif (VALGRIND) diff --git a/samples/wasm-c-api/src/callback.c b/samples/wasm-c-api/src/callback.c index b1294670..ccb9ec06 100644 --- a/samples/wasm-c-api/src/callback.c +++ b/samples/wasm-c-api/src/callback.c @@ -169,9 +169,11 @@ int main(int argc, const char* argv[]) { wasm_val_t rs[1] = { WASM_INIT_VAL }; wasm_val_vec_t args = WASM_ARRAY_VEC(as); wasm_val_vec_t results = WASM_ARRAY_VEC(rs); - if (wasm_func_call(run_func, &args, &results)) { - printf("> Error calling function!\n"); - return 1; + wasm_trap_t *trap = wasm_func_call(run_func, &args, &results); + if (trap) { + printf("> Error calling function!\n"); + wasm_trap_delete(trap); + return 1; } wasm_extern_vec_delete(&exports); diff --git a/samples/wasm-c-api/src/clone.c b/samples/wasm-c-api/src/clone.c index bfe62175..ce8ebd8b 100644 --- a/samples/wasm-c-api/src/clone.c +++ b/samples/wasm-c-api/src/clone.c @@ -231,10 +231,13 @@ vm_function_set_byte(const wasm_vm_t *vm, uint32_t offset, uint8_t byte) wasm_val_vec_t args = WASM_ARRAY_VEC(a_v); wasm_val_vec_t results = WASM_EMPTY_VEC; wasm_trap_t *trap = wasm_func_call(vm->function_list[0], &args, &results); - if (trap) + if (trap) { printf("call wasm_set_byte failed"); + wasm_trap_delete(trap); + return false; + } - return trap != NULL; + return true; } bool @@ -247,6 +250,7 @@ vm_function_get_byte(const wasm_vm_t *vm, uint32_t offset, uint8_t *byte) wasm_trap_t *trap = wasm_func_call(vm->function_list[1], &args, &results); if (trap) { printf("call wasm_get_byte failed"); + wasm_trap_delete(trap); return false; } diff --git a/samples/wasm-c-api/src/empty_imports.c b/samples/wasm-c-api/src/empty_imports.c index 5858ed6b..c8788b51 100644 --- a/samples/wasm-c-api/src/empty_imports.c +++ b/samples/wasm-c-api/src/empty_imports.c @@ -97,10 +97,16 @@ int main(int argc, const char* argv[]) { wasm_val_t results[1] = { WASM_INIT_VAL }; wasm_val_vec_t results_vec = WASM_ARRAY_VEC(results); - if (wasm_func_call(add_func, &args_vec, &results_vec) - || results_vec.data[0].of.i32 != 7) { - printf("> Error calling function!\n"); - return 1; + wasm_trap_t *trap = wasm_func_call(add_func, &args_vec, &results_vec); + if (trap) { + printf("> Error calling function!\n"); + wasm_trap_delete(trap); + return 1; + } + + if (results_vec.data[0].of.i32 != 7) { + printf("> Error calling function!\n"); + return 1; } wasm_extern_vec_delete(&exports); diff --git a/samples/wasm-c-api/src/global.c b/samples/wasm-c-api/src/global.c index bc4671d2..91c8cb65 100644 --- a/samples/wasm-c-api/src/global.c +++ b/samples/wasm-c-api/src/global.c @@ -37,15 +37,22 @@ wasm_func_t* get_export_func(const wasm_extern_vec_t* exports, size_t i) { check(val, type, expected); \ } -#define check_call(func, type, expected) \ - { \ - wasm_val_t vs[1]; \ - wasm_val_vec_t args = WASM_EMPTY_VEC; \ - wasm_val_vec_t results = WASM_ARRAY_VEC(vs); \ - wasm_func_call(func, &args, &results); \ - check(vs[0], type, expected); \ - } +#define check_trap(trap) \ + if (trap) { \ + printf("> Error calling function\n"); \ + wasm_trap_delete(trap); \ + exit(1); \ + } +#define check_call(func, type, expected) \ + { \ + wasm_val_t vs[1]; \ + wasm_val_vec_t args = WASM_EMPTY_VEC; \ + wasm_val_vec_t results = WASM_ARRAY_VEC(vs); \ + wasm_trap_t *trap = wasm_func_call(func, &args, &results); \ + check_trap(trap); \ + check(vs[0], type, expected); \ + } int main(int argc, const char* argv[]) { // Initialize. @@ -225,16 +232,23 @@ int main(int argc, const char* argv[]) { wasm_val_vec_t res = WASM_EMPTY_VEC; wasm_val_t vs73[] = { WASM_F32_VAL(73) }; wasm_val_vec_t args73 = WASM_ARRAY_VEC(vs73); - wasm_func_call(set_var_f32_import, &args73, &res); + wasm_trap_t *trap = wasm_func_call(set_var_f32_import, &args73, &res); + check_trap(trap); + wasm_val_t vs74[] = { WASM_I64_VAL(74) }; wasm_val_vec_t args74 = WASM_ARRAY_VEC(vs74); - wasm_func_call(set_var_i64_import, &args74, &res); + trap = wasm_func_call(set_var_i64_import, &args74, &res); + check_trap(trap); + wasm_val_t vs77[] = { WASM_F32_VAL(77) }; wasm_val_vec_t args77 = WASM_ARRAY_VEC(vs77); - wasm_func_call(set_var_f32_export, &args77, &res); + trap = wasm_func_call(set_var_f32_export, &args77, &res); + check_trap(trap); + wasm_val_t vs78[] = { WASM_I64_VAL(78) }; wasm_val_vec_t args78 = WASM_ARRAY_VEC(vs78); - wasm_func_call(set_var_i64_export, &args78, &res); + trap = wasm_func_call(set_var_i64_export, &args78, &res); + check_trap(trap); check_global(var_f32_import, f32, 73); check_global(var_i64_import, i64, 74); diff --git a/samples/wasm-c-api/src/globalexportimport.c b/samples/wasm-c-api/src/globalexportimport.c index 92420a1b..1c1715f2 100644 --- a/samples/wasm-c-api/src/globalexportimport.c +++ b/samples/wasm-c-api/src/globalexportimport.c @@ -50,13 +50,21 @@ wasm_func_t* get_export_func(const wasm_extern_vec_t* exports, size_t i) { check(val, type, expected); \ } -#define check_call(func, 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); \ - } +#define check_trap(trap) \ + if (trap) { \ + printf("> Error calling function\n"); \ + wasm_trap_delete(trap); \ + exit(1); \ + } + +#define check_call(func, type, expected) \ + { \ + wasm_val_vec_t results; \ + wasm_val_vec_new_uninitialized(&results, 1); \ + wasm_trap_t *trap = wasm_func_call(func, NULL, &results); \ + check_trap(trap); \ + check(results.data[0], type, expected); \ + } wasm_module_t * create_module_from_file(wasm_store_t* store, const char * filename) { @@ -149,7 +157,9 @@ int main(int argc, const char* argv[]) { printf("Modify the variable to 77.0...\n"); 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 + wasm_trap_t *trap = wasm_func_call(set_var_f32_export, &args77, + NULL); // Call to module export + check_trap(trap); 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 @@ -158,7 +168,8 @@ int main(int argc, const char* argv[]) { printf("Modify the variable to 78.0...\n"); 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); + trap = wasm_func_call(set_var_f32_import, &args78, NULL); + check_trap(trap); 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 diff --git a/samples/wasm-c-api/src/hello.c b/samples/wasm-c-api/src/hello.c index 5a2b9843..3ebea87b 100644 --- a/samples/wasm-c-api/src/hello.c +++ b/samples/wasm-c-api/src/hello.c @@ -118,9 +118,11 @@ int main(int argc, const char* argv[]) { printf("Calling export...\n"); wasm_val_vec_t args = WASM_EMPTY_VEC; wasm_val_vec_t results = WASM_EMPTY_VEC; - if (wasm_func_call(run_func, &args, &results)) { - printf("> Error calling function!\n"); - return 1; + wasm_trap_t *trap = wasm_func_call(run_func, &args, &results); + if (trap) { + printf("> Error calling function!\n"); + wasm_trap_delete(trap); + return 1; } wasm_extern_vec_delete(&exports); diff --git a/samples/wasm-c-api/src/hostref.c b/samples/wasm-c-api/src/hostref.c index a411ddd9..219c862d 100644 --- a/samples/wasm-c-api/src/hostref.c +++ b/samples/wasm-c-api/src/hostref.c @@ -50,9 +50,11 @@ own wasm_ref_t* call_v_r(const wasm_func_t* func) { wasm_val_t rs[] = { WASM_INIT_VAL }; wasm_val_vec_t args = WASM_EMPTY_VEC; wasm_val_vec_t results = WASM_ARRAY_VEC(rs); - if (wasm_func_call(func, &args, &results)) { - printf("> Error calling function!\n"); - exit(1); + wasm_trap_t *trap = wasm_func_call(func, &args, &results); + if (trap) { + printf("> Error calling function!\n"); + wasm_trap_delete(trap); + exit(1); } printf("okay\n"); return rs[0].of.ref; @@ -63,9 +65,11 @@ void call_r_v(const wasm_func_t* func, wasm_ref_t* ref) { wasm_val_t vs[1] = { WASM_REF_VAL(ref) }; wasm_val_vec_t args = WASM_ARRAY_VEC(vs); wasm_val_vec_t results = WASM_EMPTY_VEC; - if (wasm_func_call(func, &args, &results)) { - printf("> Error calling function!\n"); - exit(1); + wasm_trap_t *trap = wasm_func_call(func, &args, &results); + if (trap) { + printf("> Error calling function!\n"); + wasm_trap_delete(trap); + exit(1); } printf("okay\n"); } @@ -76,9 +80,11 @@ own wasm_ref_t* call_r_r(const wasm_func_t* func, wasm_ref_t* ref) { wasm_val_t rs[1] = { WASM_INIT_VAL }; wasm_val_vec_t args = WASM_ARRAY_VEC(vs); wasm_val_vec_t results = WASM_ARRAY_VEC(rs); - if (wasm_func_call(func, &args, &results)) { - printf("> Error calling function!\n"); - exit(1); + wasm_trap_t *trap = wasm_func_call(func, &args, &results); + if (trap) { + printf("> Error calling function!\n"); + wasm_trap_delete(trap); + exit(1); } printf("okay\n"); return rs[0].of.ref; @@ -89,9 +95,11 @@ void call_ir_v(const wasm_func_t* func, int32_t i, wasm_ref_t* ref) { wasm_val_t vs[2] = { WASM_I32_VAL(i), WASM_REF_VAL(ref) }; wasm_val_vec_t args = WASM_ARRAY_VEC(vs); wasm_val_vec_t results = WASM_EMPTY_VEC; - if (wasm_func_call(func, &args, &results)) { - printf("> Error calling function!\n"); - exit(1); + wasm_trap_t *trap = wasm_func_call(func, &args, &results); + if (trap) { + printf("> Error calling function!\n"); + wasm_trap_delete(trap); + exit(1); } printf("okay\n"); } @@ -102,9 +110,11 @@ own wasm_ref_t* call_i_r(const wasm_func_t* func, int32_t i) { wasm_val_t rs[1] = { WASM_INIT_VAL }; wasm_val_vec_t args = WASM_ARRAY_VEC(vs); wasm_val_vec_t results = WASM_ARRAY_VEC(rs); - if (wasm_func_call(func, &args, &results)) { - printf("> Error calling function!\n"); - exit(1); + wasm_trap_t *trap = wasm_func_call(func, &args, &results); + if (trap) { + printf("> Error calling function!\n"); + wasm_trap_delete(trap); + exit(1); } printf("okay\n"); return rs[0].of.ref; diff --git a/samples/wasm-c-api/src/memory.c b/samples/wasm-c-api/src/memory.c index 64d1c077..737dd850 100644 --- a/samples/wasm-c-api/src/memory.c +++ b/samples/wasm-c-api/src/memory.c @@ -36,9 +36,16 @@ void check_call(wasm_func_t* func, int i, wasm_val_t args[], int32_t expected) { wasm_val_t r[] = {WASM_INIT_VAL}; wasm_val_vec_t args_ = {i, args, i, sizeof(wasm_val_t), NULL}; wasm_val_vec_t results = WASM_ARRAY_VEC(r); - if (wasm_func_call(func, &args_, &results) || r[0].of.i32 != expected) { - printf("> Error on result\n"); - exit(1); + wasm_trap_t *trap = wasm_func_call(func, &args_, &results); + if (trap) { + printf("> Error on result\n"); + wasm_trap_delete(trap); + exit(1); + } + + if (r[0].of.i32 != expected) { + printf("> Error on result\n"); + exit(1); } } @@ -59,9 +66,11 @@ 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[]) { wasm_val_vec_t args_ = {i, args, i, sizeof(wasm_val_t), NULL}; wasm_val_vec_t results = WASM_EMPTY_VEC; - if (wasm_func_call(func, &args_, &results)) { - printf("> Error on result, expected empty\n"); - exit(1); + wasm_trap_t *trap = wasm_func_call(func, &args_, &results); + if (trap) { + printf("> Error on result, expected empty\n"); + wasm_trap_delete(trap); + exit(1); } } diff --git a/samples/wasm-c-api/src/multi.c b/samples/wasm-c-api/src/multi.c index 92ef0eea..a1c8fa9f 100644 --- a/samples/wasm-c-api/src/multi.c +++ b/samples/wasm-c-api/src/multi.c @@ -133,9 +133,11 @@ int main(int argc, const char* argv[]) { }; wasm_val_vec_t args = WASM_ARRAY_VEC(vals); wasm_val_vec_t results = WASM_ARRAY_VEC(res); - if (wasm_func_call(run_func, &args, &results)) { - printf("> Error calling function!\n"); - return 1; + wasm_trap_t *trap = wasm_func_call(run_func, &args, &results); + if (trap) { + printf("> Error calling function!\n"); + wasm_trap_delete(trap); + return 1; } wasm_extern_vec_delete(&exports); diff --git a/samples/wasm-c-api/src/serialize.c b/samples/wasm-c-api/src/serialize.c index d6570691..83436817 100644 --- a/samples/wasm-c-api/src/serialize.c +++ b/samples/wasm-c-api/src/serialize.c @@ -111,8 +111,10 @@ main(int argc, const char *argv[]) // Call. printf("Calling export...\n"); wasm_val_vec_t empty = WASM_EMPTY_VEC; - if (wasm_func_call(run_func, &empty, &empty)) { + wasm_trap_t *trap = wasm_func_call(run_func, &empty, &empty); + if (trap) { printf("> Error calling function!\n"); + wasm_trap_delete(trap); return 1; } diff --git a/samples/wasm-c-api/src/table.c b/samples/wasm-c-api/src/table.c index 0bf68e05..c4a7da8b 100644 --- a/samples/wasm-c-api/src/table.c +++ b/samples/wasm-c-api/src/table.c @@ -53,9 +53,16 @@ void check_call(wasm_func_t* func, int32_t arg1, int32_t arg2, int32_t expected) wasm_val_t r[1] = { WASM_INIT_VAL }; wasm_val_vec_t args = WASM_ARRAY_VEC(vs); wasm_val_vec_t results = WASM_ARRAY_VEC(r); - if (wasm_func_call(func, &args, &results) || r[0].of.i32 != expected) { - printf("> Error on result\n"); - exit(1); + wasm_trap_t *trap = wasm_func_call(func, &args, &results); + if (trap) { + printf("> Error on calling\n"); + wasm_trap_delete(trap); + exit(1); + } + + if (r[0].of.i32 != expected) { + printf("> Error on result\n"); + exit(1); } } diff --git a/samples/wasm-c-api/src/threads.c b/samples/wasm-c-api/src/threads.c index d7ae4893..cbe4aaf4 100644 --- a/samples/wasm-c-api/src/threads.c +++ b/samples/wasm-c-api/src/threads.c @@ -85,8 +85,10 @@ run(void *args_abs) // Call. wasm_val_vec_t empty = WASM_EMPTY_VEC; - if (wasm_func_call(run_func, &empty, &empty)) { + wasm_trap_t *trap = wasm_func_call(run_func, &empty, &empty); + if (trap) { printf("> Error calling function!\n"); + wasm_trap_delete(trap); return NULL; }