diff --git a/core/iwasm/common/wasm_memory.c b/core/iwasm/common/wasm_memory.c index 10c651bc9..f404b4a4a 100644 --- a/core/iwasm/common/wasm_memory.c +++ b/core/iwasm/common/wasm_memory.c @@ -148,6 +148,25 @@ static void wasm_munmap_linear_memory(void *mapped_mem, uint64 commit_size, uint64 map_size); +static void +destroy_shared_heap_node(WASMSharedHeap *heap) +{ + uint64 map_size; + + if (heap->heap_handle) { + mem_allocator_destroy(heap->heap_handle); + wasm_runtime_free(heap->heap_handle); +#ifndef OS_ENABLE_HW_BOUND_CHECK + map_size = heap->size; +#else + map_size = 8 * (uint64)BH_GB; +#endif + wasm_munmap_linear_memory(heap->base_addr, heap->size, map_size); + } + + wasm_runtime_free(heap); +} + static void * runtime_malloc(uint64 size) { @@ -339,6 +358,81 @@ wasm_runtime_unchain_shared_heaps(WASMSharedHeap *head, bool entire_chain) return cur; } +/* Destroy and recycle a shared heap(or head of shared heap chain), return next + * node in the shared heap chain */ +static WASMSharedHeap * +wasm_runtime_destroy_shared_heap_head(WASMSharedHeap *head) +{ + WASMSharedHeap *cur = NULL, *prev = NULL, *new_head = NULL; + bool head_found = false, is_chain_head = true; + + if (!head) { + LOG_WARNING("Invalid shared heap to destroy."); + return NULL; + } + + os_mutex_lock(&shared_heap_list_lock); + if (head->attached_count != 0) { + LOG_WARNING("To destroy shared heap, it needs to be detached first."); + os_mutex_unlock(&shared_heap_list_lock); + return NULL; + } + + for (cur = shared_heap_list; cur; cur = cur->next) { + if (cur == head) + head_found = true; + if (cur->chain_next == head) + is_chain_head = false; + } + if (!head_found) { + LOG_WARNING("Shared heap %p isn't tracked by runtime.", head); + os_mutex_unlock(&shared_heap_list_lock); + return NULL; + } + if (!is_chain_head) { + LOG_WARNING("Shared heap %p isn't the head of a shared heap chain.", + head); + os_mutex_unlock(&shared_heap_list_lock); + return NULL; + } + + new_head = head->chain_next; + if (head == shared_heap_list) { + shared_heap_list = head->next; + destroy_shared_heap_node(head); + } + else { + prev = shared_heap_list; + cur = shared_heap_list->next; + while (prev) { + if (head == cur) { + prev->next = head->next; + destroy_shared_heap_node(cur); + break; + } + prev = prev->next; + cur = cur->next; + } + } + + os_mutex_unlock(&shared_heap_list_lock); + + LOG_VERBOSE("Destroyed shared heap %p", head); + + return new_head; +} + +WASMSharedHeap * +wasm_runtime_destroy_shared_heap(WASMSharedHeap *head, bool entire_chain) +{ + WASMSharedHeap *new_head = NULL; + do { + new_head = wasm_runtime_destroy_shared_heap_head(head); + } while (entire_chain && new_head); + + return new_head; +} + static uint8 * get_last_used_shared_heap_base_addr_adj(WASMModuleInstanceCommon *module_inst) { @@ -819,7 +913,6 @@ destroy_shared_heaps() { WASMSharedHeap *heap; WASMSharedHeap *cur; - uint64 map_size; os_mutex_lock(&shared_heap_list_lock); heap = shared_heap_list; @@ -829,17 +922,7 @@ destroy_shared_heaps() while (heap) { cur = heap; heap = heap->next; - if (cur->heap_handle) { - mem_allocator_destroy(cur->heap_handle); - wasm_runtime_free(cur->heap_handle); -#ifndef OS_ENABLE_HW_BOUND_CHECK - map_size = cur->size; -#else - map_size = 8 * (uint64)BH_GB; -#endif - wasm_munmap_linear_memory(cur->base_addr, cur->size, map_size); - } - wasm_runtime_free(cur); + destroy_shared_heap_node(cur); } os_mutex_destroy(&shared_heap_list_lock); } diff --git a/core/iwasm/common/wasm_memory.h b/core/iwasm/common/wasm_memory.h index b79ed4a6c..7a52b2b03 100644 --- a/core/iwasm/common/wasm_memory.h +++ b/core/iwasm/common/wasm_memory.h @@ -95,6 +95,9 @@ wasm_runtime_chain_shared_heaps(WASMSharedHeap *head, WASMSharedHeap *body); WASMSharedHeap * wasm_runtime_unchain_shared_heaps(WASMSharedHeap *head, bool entire_chain); +WASMSharedHeap * +wasm_runtime_destroy_shared_heap(WASMSharedHeap *head, bool entire_chain); + bool wasm_runtime_attach_shared_heap(WASMModuleInstanceCommon *module_inst, WASMSharedHeap *shared_heap); diff --git a/core/iwasm/include/wasm_export.h b/core/iwasm/include/wasm_export.h index fc46825c8..09a650ad4 100644 --- a/core/iwasm/include/wasm_export.h +++ b/core/iwasm/include/wasm_export.h @@ -2405,6 +2405,21 @@ wasm_runtime_chain_shared_heaps(wasm_shared_heap_t head, wasm_shared_heap_t wasm_runtime_unchain_shared_heaps(wasm_shared_heap_t head, bool entire_chain); +/** + * Destroy a shared heap or shared heap chain starting from the given head. + * If `entire_chain` is true, destroy the whole chain; otherwise, destroy only + * the head and return the new head of the chain. The shared heap chain must be + * detached before destruction, and only the chain head registered with the + * runtime can be destroyed. + * + * @param head The head of the shared heap chain to be destroyed. + * @param entire_chain Whether to destroy the entire chain. + * @return The new head of the shared heap chain when `entire_chain` is false; + * NULL otherwise. + */ +WASM_RUNTIME_API_EXTERN wasm_shared_heap_t +wasm_runtime_destroy_shared_heap(wasm_shared_heap_t head, bool entire_chain); + /** * Attach a shared heap, it can be the head of shared heap chain, in that case, * attach the shared heap chain, to a module instance diff --git a/tests/unit/shared-heap/shared_heap_test.cc b/tests/unit/shared-heap/shared_heap_test.cc index 434b4c389..9dfb8498f 100644 --- a/tests/unit/shared-heap/shared_heap_test.cc +++ b/tests/unit/shared-heap/shared_heap_test.cc @@ -7,7 +7,7 @@ #include "gtest/gtest.h" #include "bh_read_file.h" -#include "wasm_runtime_common.h" +#include "wasm_runtime.h" #include @@ -32,13 +32,13 @@ static void destroy_module_env(struct ret_env module_env); static bool -load_wasm(char *wasm_file_tested, unsigned int app_heap_size, +load_wasm(const char *wasm_file_tested, unsigned int app_heap_size, ret_env &ret_module_env) { char *wasm_file = strdup(wasm_file_tested); unsigned int wasm_file_size = 0; unsigned int stack_size = 16 * 1024, heap_size = app_heap_size; - char error_buf[128] = { 0 }; + char error_buf[128] = {}; ret_module_env.wasm_file_buf = (unsigned char *)bh_read_file_to_buffer(wasm_file, &wasm_file_size); @@ -141,9 +141,9 @@ fail0: TEST_F(shared_heap_test, test_shared_heap_basic) { - SharedHeapInitArgs args = { 0 }; + SharedHeapInitArgs args = {}; WASMSharedHeap *shared_heap = nullptr; - uint32 argv[1] = { 0 }; + uint32 argv[1] = {}; args.size = 1024; shared_heap = wasm_runtime_create_shared_heap(&args); @@ -164,9 +164,9 @@ TEST_F(shared_heap_test, test_shared_heap_basic) TEST_F(shared_heap_test, test_shared_heap_malloc_fail) { - SharedHeapInitArgs args = { 0 }; + SharedHeapInitArgs args = {}; WASMSharedHeap *shared_heap = nullptr; - uint32 argv[1] = { 0 }; + uint32 argv[1] = {}; args.size = 1024; shared_heap = wasm_runtime_create_shared_heap(&args); @@ -188,10 +188,10 @@ TEST_F(shared_heap_test, test_shared_heap_malloc_fail) TEST_F(shared_heap_test, test_preallocated_shared_heap_malloc_fail) { - SharedHeapInitArgs args = { 0 }; + SharedHeapInitArgs args = {}; WASMSharedHeap *shared_heap = nullptr; - uint32 argv[1] = { 0 }, BUF_SIZE = os_getpagesize(); - uint8 preallocated_buf[BUF_SIZE]; + uint32 argv[1] = {}, BUF_SIZE = os_getpagesize(); + uint8 preallocated_buf[BUF_SIZE] = {}; /* create a preallocated shared heap */ args.pre_allocated_addr = preallocated_buf; @@ -220,9 +220,9 @@ TEST_F(shared_heap_test, test_preallocated_shared_heap_malloc_fail) TEST_F(shared_heap_test, test_preallocated_shared_runtime_api) { struct ret_env tmp_module_env; - SharedHeapInitArgs args = { 0 }; + SharedHeapInitArgs args = {}; WASMSharedHeap *shared_heap = nullptr; - uint32 argv[1] = { 0 }; + uint32 argv[1] = {}; void *native_ptr; uint64 offset, size; bool ret; @@ -263,7 +263,7 @@ TEST_F(shared_heap_test, test_preallocated_shared_runtime_api) ASSERT_EQ(true, wasm_runtime_validate_app_addr( tmp_module_env.wasm_module_inst, offset, size)); - ASSERT_EQ(native_ptr + size, + ASSERT_EQ((char *)native_ptr + size, wasm_runtime_addr_app_to_native(tmp_module_env.wasm_module_inst, offset + size)); @@ -277,7 +277,7 @@ static void create_test_shared_heap(uint8 *preallocated_buf, size_t size, WASMSharedHeap **shared_heap_res) { - SharedHeapInitArgs args = { 0 }; + SharedHeapInitArgs args = {}; WASMSharedHeap *shared_heap = nullptr; args.pre_allocated_addr = preallocated_buf; args.size = size; @@ -297,7 +297,7 @@ create_test_shared_heap_chain(uint8 *preallocated_buf, size_t size, uint8 *preallocated_buf2, size_t size2, WASMSharedHeap **shared_heap_chain) { - SharedHeapInitArgs args = { 0 }; + SharedHeapInitArgs args = {}; WASMSharedHeap *shared_heap = nullptr, *shared_heap2 = nullptr; args.pre_allocated_addr = preallocated_buf; args.size = size; @@ -321,11 +321,144 @@ create_test_shared_heap_chain(uint8 *preallocated_buf, size_t size, } } +TEST_F(shared_heap_test, test_destroy_shared_heap_head_only) +{ + WASMSharedHeap *shared_heap_chain = nullptr; + WASMSharedHeap *second = nullptr; + uint32 argv[1] = {}, BUF_SIZE = os_getpagesize(); + uint8 preallocated_buf[BUF_SIZE] = {}; + + create_test_shared_heap_chain(preallocated_buf, BUF_SIZE, NULL, BUF_SIZE, + &shared_heap_chain); + second = shared_heap_chain->chain_next; + + ASSERT_NE(nullptr, second); + + WASMSharedHeap *new_head = + wasm_runtime_destroy_shared_heap(shared_heap_chain, false); + + ASSERT_EQ(second, new_head); + ASSERT_EQ(nullptr, new_head->chain_next); + + test_shared_heap(new_head, "test.wasm", "test", 0, argv); + EXPECT_EQ(10, argv[0]); +} + +TEST_F(shared_heap_test, test_destroy_shared_heap_entire_chain) +{ + SharedHeapInitArgs args = {}; + WASMSharedHeap *shared_heap_chain = nullptr; + + args.size = 1024; + shared_heap_chain = wasm_runtime_create_shared_heap(&args); + if (!shared_heap_chain) { + FAIL() << "Failed to create shared heap"; + } + + EXPECT_EQ(nullptr, + wasm_runtime_destroy_shared_heap(shared_heap_chain, true)); +} + +TEST_F(shared_heap_test, test_destroy_shared_heap_not_chain_head) +{ + WASMSharedHeap *shared_heap_chain = nullptr; + WASMSharedHeap *body = nullptr; + uint32 argv[1] = {}, BUF_SIZE = os_getpagesize(); + uint8 preallocated_buf[BUF_SIZE] = {}, preallocated_buf2[BUF_SIZE] = {}; + + create_test_shared_heap_chain(preallocated_buf, BUF_SIZE, preallocated_buf2, + BUF_SIZE, &shared_heap_chain); + body = shared_heap_chain->chain_next; + + ASSERT_NE(nullptr, body); + + EXPECT_EQ(nullptr, wasm_runtime_destroy_shared_heap(body, true)); + EXPECT_EQ(body, shared_heap_chain->chain_next); + + test_shared_heap(shared_heap_chain, "test.wasm", "test", 0, argv); + EXPECT_EQ(10, argv[0]); + + EXPECT_EQ(nullptr, + wasm_runtime_destroy_shared_heap(shared_heap_chain, true)); +} + +TEST_F(shared_heap_test, test_destroy_shared_heap_when_attached) +{ + WASMSharedHeap *shared_heap = nullptr; + uint32 argv[1] = {}, BUF_SIZE = os_getpagesize(); + uint8 preallocated_buf[BUF_SIZE] = {}; + struct ret_env module_env = {}; + + create_test_shared_heap(preallocated_buf, BUF_SIZE, &shared_heap); + + ASSERT_TRUE(load_wasm((char *)"test.wasm", 0, module_env)); + ASSERT_TRUE(wasm_runtime_attach_shared_heap(module_env.wasm_module_inst, + shared_heap)); + + EXPECT_EQ(nullptr, wasm_runtime_destroy_shared_heap(shared_heap, true)); + + wasm_runtime_detach_shared_heap(module_env.wasm_module_inst); + destroy_module_env(module_env); + + EXPECT_EQ(nullptr, wasm_runtime_destroy_shared_heap(shared_heap, true)); +} + +TEST_F(shared_heap_test, test_destroy_invalid_shared_heap) +{ + WASMSharedHeap fake_shared_heap = {}; + + EXPECT_EQ(nullptr, + wasm_runtime_destroy_shared_heap(&fake_shared_heap, true)); +} + +TEST_F(shared_heap_test, test_destroy_shared_heap_untracked_next_head_only) +{ + WASMSharedHeap *shared_heap_chain = nullptr; + WASMSharedHeap *body = nullptr; + WASMSharedHeap fake_shared_heap = {}; + uint32 BUF_SIZE = os_getpagesize(); + + create_test_shared_heap_chain(preallocated_buf, BUF_SIZE, preallocated_buf2, + BUF_SIZE, &shared_heap_chain); + body = shared_heap_chain->chain_next; + + ASSERT_NE(nullptr, body); + + shared_heap_chain->chain_next = &fake_shared_heap; + EXPECT_EQ(NULL, wasm_runtime_destroy_shared_heap(shared_heap_chain, false)); + shared_heap_chain->chain_next = body; + + EXPECT_EQ(body, wasm_runtime_destroy_shared_heap(shared_heap_chain, false)); + EXPECT_EQ(nullptr, wasm_runtime_destroy_shared_heap(body, true)); +} + +TEST_F(shared_heap_test, test_destroy_shared_heap_untracked_next_entire_chain) +{ + WASMSharedHeap *shared_heap_chain = nullptr; + WASMSharedHeap *body = nullptr; + WASMSharedHeap fake_shared_heap = {}; + uint32 BUF_SIZE = os_getpagesize(); + + create_test_shared_heap_chain(NULL, BUF_SIZE, NULL, BUF_SIZE, + &shared_heap_chain); + body = shared_heap_chain->chain_next; + + ASSERT_NE(nullptr, body); + + shared_heap_chain->chain_next = &fake_shared_heap; + EXPECT_EQ(nullptr, + wasm_runtime_destroy_shared_heap(shared_heap_chain, true)); + + shared_heap_chain->chain_next = body; + EXPECT_EQ(nullptr, + wasm_runtime_destroy_shared_heap(shared_heap_chain, true)); +} + TEST_F(shared_heap_test, test_shared_heap_rmw) { WASMSharedHeap *shared_heap = nullptr; - uint32 argv[2] = { 0 }, BUF_SIZE = os_getpagesize(); - uint8 preallocated_buf[BUF_SIZE] = { 0 }; + uint32 argv[2] = {}, BUF_SIZE = os_getpagesize(); + uint8 preallocated_buf[BUF_SIZE] = {}; uint32 start1, end1; create_test_shared_heap(preallocated_buf, BUF_SIZE, &shared_heap); @@ -361,11 +494,10 @@ TEST_F(shared_heap_test, test_shared_heap_rmw) TEST_F(shared_heap_test, test_shared_heap_chain_rmw) { - SharedHeapInitArgs args = { 0 }; + SharedHeapInitArgs args = {}; WASMSharedHeap *shared_heap_chain = nullptr; - uint32 argv[2] = { 0 }, BUF_SIZE = os_getpagesize(); - uint8 preallocated_buf[BUF_SIZE] = { 0 }, - preallocated_buf2[BUF_SIZE] = { 0 }; + uint32 argv[2] = {}, BUF_SIZE = os_getpagesize(); + uint8 preallocated_buf[BUF_SIZE] = {}, preallocated_buf2[BUF_SIZE] = {}; uint32 start1, end1, start2, end2; create_test_shared_heap_chain(preallocated_buf, BUF_SIZE, preallocated_buf2, @@ -410,11 +542,10 @@ TEST_F(shared_heap_test, test_shared_heap_chain_rmw) TEST_F(shared_heap_test, test_shared_heap_chain_rmw_bulk_memory) { - SharedHeapInitArgs args = { 0 }; + SharedHeapInitArgs args = {}; WASMSharedHeap *shared_heap_chain = nullptr; - uint32 argv[3] = { 0 }, BUF_SIZE = os_getpagesize(); - uint8 preallocated_buf[BUF_SIZE] = { 0 }, - preallocated_buf2[BUF_SIZE] = { 0 }; + uint32 argv[3] = {}, BUF_SIZE = os_getpagesize(); + uint8 preallocated_buf[BUF_SIZE] = {}, preallocated_buf2[BUF_SIZE] = {}; uint32 start1, end1, start2, end2; create_test_shared_heap_chain(preallocated_buf, BUF_SIZE, preallocated_buf2, @@ -466,11 +597,10 @@ TEST_F(shared_heap_test, test_shared_heap_chain_rmw_bulk_memory) TEST_F(shared_heap_test, test_shared_heap_chain_rmw_bulk_memory_oob) { - SharedHeapInitArgs args = { 0 }; + SharedHeapInitArgs args = {}; WASMSharedHeap *shared_heap_chain = nullptr; - uint32 argv[3] = { 0 }, BUF_SIZE = os_getpagesize(); - uint8 preallocated_buf[BUF_SIZE] = { 0 }, - preallocated_buf2[BUF_SIZE] = { 0 }; + uint32 argv[3] = {}, BUF_SIZE = os_getpagesize(); + uint8 preallocated_buf[BUF_SIZE] = {}, preallocated_buf2[BUF_SIZE] = {}; uint32 start1, end1, start2, end2; create_test_shared_heap_chain(preallocated_buf, BUF_SIZE, preallocated_buf2, @@ -551,7 +681,7 @@ TEST_F(shared_heap_test, test_shared_heap_chain_rmw_bulk_memory_oob) TEST_F(shared_heap_test, test_shared_heap_rmw_oob) { WASMSharedHeap *shared_heap = nullptr; - uint32 argv[2] = { 0 }, BUF_SIZE = os_getpagesize(); + uint32 argv[2] = {}, BUF_SIZE = os_getpagesize(); uint8 preallocated_buf[BUF_SIZE], preallocated_buf2[BUF_SIZE]; uint32 start1, end1, start2, end2; @@ -585,8 +715,8 @@ TEST_F(shared_heap_test, test_shared_heap_rmw_oob) TEST_F(shared_heap_test, test_shared_heap_chain_rmw_oob) { WASMSharedHeap *shared_heap_chain = nullptr; - uint32 argv[2] = { 0 }, BUF_SIZE = os_getpagesize(); - uint8 preallocated_buf[BUF_SIZE], preallocated_buf2[BUF_SIZE]; + uint32 argv[2] = {}, BUF_SIZE = os_getpagesize(); + uint8 preallocated_buf[BUF_SIZE] = {}, preallocated_buf2[BUF_SIZE] = {}; uint32 start1, end1, start2, end2; create_test_shared_heap_chain(preallocated_buf, BUF_SIZE, preallocated_buf2, @@ -618,9 +748,8 @@ TEST_F(shared_heap_test, test_shared_heap_chain_rmw_oob) TEST_F(shared_heap_test, test_shared_heap_chain_memory64_rmw) { WASMSharedHeap *shared_heap_chain = nullptr; - uint32 argv[3] = { 0 }, BUF_SIZE = os_getpagesize(); - uint8 preallocated_buf[BUF_SIZE] = { 0 }, - preallocated_buf2[BUF_SIZE] = { 0 }; + uint32 argv[3] = {}, BUF_SIZE = os_getpagesize(); + uint8 preallocated_buf[BUF_SIZE] = {}, preallocated_buf2[BUF_SIZE] = {}; uint64 start1, end1, start2, end2; create_test_shared_heap_chain(preallocated_buf, BUF_SIZE, preallocated_buf2, @@ -666,7 +795,7 @@ TEST_F(shared_heap_test, test_shared_heap_chain_memory64_rmw) TEST_F(shared_heap_test, test_shared_heap_chain_memory64_rmw_oob) { WASMSharedHeap *shared_heap_chain = nullptr; - uint32 argv[3] = { 0 }, BUF_SIZE = os_getpagesize(); + uint32 argv[3] = {}, BUF_SIZE = os_getpagesize(); uint8 preallocated_buf[BUF_SIZE], preallocated_buf2[BUF_SIZE]; uint64 start1, end1, start2, end2; @@ -726,9 +855,9 @@ static NativeSymbol g_test_native_symbols[] = { TEST_F(shared_heap_test, test_addr_conv) { - SharedHeapInitArgs args = { 0 }; + SharedHeapInitArgs args = {}; WASMSharedHeap *shared_heap = nullptr; - uint32 argv[1] = { 0 }; + uint32 argv[1] = {}; bool ret = false; ret = wasm_native_register_natives("env", g_test_native_symbols, @@ -755,9 +884,9 @@ TEST_F(shared_heap_test, test_addr_conv) TEST_F(shared_heap_test, test_addr_conv_pre_allocated_oob) { - SharedHeapInitArgs args = { 0 }; + SharedHeapInitArgs args = {}; WASMSharedHeap *shared_heap = nullptr; - uint32 argv[1] = { 0 }, BUF_SIZE = os_getpagesize(), + uint32 argv[1] = {}, BUF_SIZE = os_getpagesize(), app_addr = 0xFFFFFFFF - BUF_SIZE; uint8 preallocated_buf[BUF_SIZE]; bool ret = false; @@ -795,10 +924,10 @@ TEST_F(shared_heap_test, test_addr_conv_pre_allocated_oob) TEST_F(shared_heap_test, test_shared_heap_chain) { - SharedHeapInitArgs args = { 0 }; + SharedHeapInitArgs args = {}; WASMSharedHeap *shared_heap = nullptr, *shared_heap2 = nullptr, *shared_heap_chain = nullptr; - uint32 argv[1] = { 0 }, BUF_SIZE = os_getpagesize(); + uint32 argv[1] = {}, BUF_SIZE = os_getpagesize(); uint8 preallocated_buf[BUF_SIZE]; bool ret = false; @@ -838,7 +967,7 @@ TEST_F(shared_heap_test, test_shared_heap_chain) TEST_F(shared_heap_test, test_shared_heap_chain_create_fail) { - SharedHeapInitArgs args = { 0 }; + SharedHeapInitArgs args = {}; WASMSharedHeap *shared_heap = nullptr, *shared_heap2 = nullptr, *shared_heap_chain = nullptr; @@ -861,10 +990,10 @@ TEST_F(shared_heap_test, test_shared_heap_chain_create_fail) TEST_F(shared_heap_test, test_shared_heap_chain_create_fail2) { - SharedHeapInitArgs args = { 0 }; + SharedHeapInitArgs args = {}; WASMSharedHeap *shared_heap = nullptr, *shared_heap2 = nullptr, *shared_heap_chain = nullptr; - uint32 argv[1] = { 0 }, BUF_SIZE = os_getpagesize(); + uint32 argv[1] = {}, BUF_SIZE = os_getpagesize(); uint8 preallocated_buf[BUF_SIZE]; struct ret_env tmp_module_env; @@ -903,10 +1032,10 @@ TEST_F(shared_heap_test, test_shared_heap_chain_create_fail2) TEST_F(shared_heap_test, test_shared_heap_chain_create_fail3) { - SharedHeapInitArgs args = { 0 }; + SharedHeapInitArgs args = {}; WASMSharedHeap *shared_heap = nullptr, *shared_heap2 = nullptr, *shared_heap3 = nullptr, *shared_heap_chain = nullptr; - uint32 argv[1] = { 0 }, BUF_SIZE = os_getpagesize(); + uint32 argv[1] = {}, BUF_SIZE = os_getpagesize(); uint8 preallocated_buf[BUF_SIZE], preallocated_buf2[BUF_SIZE]; args.size = 1024; @@ -948,10 +1077,10 @@ TEST_F(shared_heap_test, test_shared_heap_chain_create_fail3) TEST_F(shared_heap_test, test_shared_heap_chain_unchain) { - SharedHeapInitArgs args = { 0 }; + SharedHeapInitArgs args = {}; WASMSharedHeap *shared_heap = nullptr, *shared_heap2 = nullptr, *shared_heap3 = nullptr, *shared_heap_chain = nullptr; - uint32 argv[1] = { 0 }, BUF_SIZE = os_getpagesize(); + uint32 argv[1] = {}, BUF_SIZE = os_getpagesize(); uint8 preallocated_buf[BUF_SIZE], preallocated_buf2[BUF_SIZE]; args.size = 1024; @@ -1000,10 +1129,10 @@ TEST_F(shared_heap_test, test_shared_heap_chain_unchain) TEST_F(shared_heap_test, test_shared_heap_chain_addr_conv) { - SharedHeapInitArgs args = { 0 }; + SharedHeapInitArgs args = {}; WASMSharedHeap *shared_heap = nullptr, *shared_heap2 = nullptr, *shared_heap_chain = nullptr; - uint32 argv[1] = { 0 }, BUF_SIZE = os_getpagesize(); + uint32 argv[1] = {}, BUF_SIZE = os_getpagesize(); uint8 preallocated_buf[BUF_SIZE]; bool ret = false; @@ -1057,10 +1186,10 @@ TEST_F(shared_heap_test, test_shared_heap_chain_addr_conv) TEST_F(shared_heap_test, test_shared_heap_chain_addr_conv_oob) { - SharedHeapInitArgs args = { 0 }; + SharedHeapInitArgs args = {}; WASMSharedHeap *shared_heap = nullptr, *shared_heap2 = nullptr, *shared_heap_chain = nullptr; - uint32 argv[1] = { 0 }, BUF_SIZE = os_getpagesize(); + uint32 argv[1] = {}, BUF_SIZE = os_getpagesize(); uint8 preallocated_buf[BUF_SIZE]; bool ret = false;