Shared heap enhancement for AOT and update tests and samples (#4226)

* shared heap enhancement: modify memory check for aot_check_memory_overflow to accomodate shared heap chain
* shared heap enhancement in AOT
* use alloca for func ctx shared heap cache value
* use correct alloca for func ctx shared heap cache value
* enable shared heap chain aot test and bug fix
* Fix a missing argument on 32bits platform, still has the shared heap chain iteration problem
* Fix shared heap chain iteration problem on 32bits platform
* fix AOT bulk memory bounds checks compliation issue
* fix AOT bulk memory bounds checks on 64 bits platform
* refactor aot memory check
* refactor AOT bulk memory bounds checks
* add more unit test for shared heap
* finished organizing unit test for shared heap and enable x86_32 for shared heap unit test
* cover a corner case for bulk memory overflow check
* try func call to replace shared heap chain traverse
* fix compilation error in JIT and potentially load nullptr
* add option for wamrc to enable single shared heap/multi shared heap, and update shared heap unit tests and sample
* cr suggestions: 1. check potiential underflow 2. refactor and use separate function for bulk memory and normal memroy 3. static assert 4. add more comments 5. remove unused code

Author: TianlongLiang

core/iwasm/aot/aot_reloc.h

@@ -185,6 +185,13 @@ typedef struct {
 #define REG_STRINGREF_SYM()
 #endif
 
+#if WASM_ENABLE_SHARED_HEAP != 0
+#define REG_SHARED_HEAP_SYM()                 \
+    REG_SYM(wasm_runtime_update_last_used_shared_heap),
+#else
+#define REG_SHARED_HEAP_SYM()
+#endif
+
 #define REG_COMMON_SYMBOLS                \
     REG_SYM(aot_set_exception_with_id),   \
     REG_SYM(aot_invoke_native),           \
@@ -218,6 +225,7 @@ typedef struct {
     REG_LLVM_PGO_SYM()                    \
     REG_GC_SYM()                          \
     REG_STRINGREF_SYM()                   \
+    REG_SHARED_HEAP_SYM()                 \
 
 #define CHECK_RELOC_OFFSET(data_size) do {              \
     if (!check_reloc_offset(target_section_size,        \

core/iwasm/aot/aot_runtime.c

@@ -63,6 +63,14 @@ bh_static_assert(offsetof(AOTModuleInstanceExtra, shared_heap_start_off) == 16);
 bh_static_assert(offsetof(AOTModuleInstanceExtra, shared_heap_end_off) == 24);
 bh_static_assert(offsetof(AOTModuleInstanceExtra, shared_heap) == 32);
 
+bh_static_assert(offsetof(WASMSharedHeap, next) == 0);
+bh_static_assert(offsetof(WASMSharedHeap, chain_next) == 8);
+bh_static_assert(offsetof(WASMSharedHeap, heap_handle) == 16);
+bh_static_assert(offsetof(WASMSharedHeap, base_addr) == 24);
+bh_static_assert(offsetof(WASMSharedHeap, size) == 32);
+bh_static_assert(offsetof(WASMSharedHeap, start_off_mem64) == 40);
+bh_static_assert(offsetof(WASMSharedHeap, start_off_mem32) == 48);
+
 bh_static_assert(sizeof(CApiFuncImport) == sizeof(uintptr_t) * 3);
 
 bh_static_assert(sizeof(wasm_val_t) == 16);
@@ -1991,6 +1999,8 @@ aot_instantiate(AOTModule *module, AOTModuleInstance *parent,
 #else
     extra->shared_heap_start_off.u32[0] = UINT32_MAX;
 #endif
+    /* After shared heap chain, will early stop if shared heap is NULL */
+    extra->shared_heap = NULL;
 
 #if WASM_ENABLE_PERF_PROFILING != 0
     total_size = sizeof(AOTFuncPerfProfInfo)

core/iwasm/common/wasm_memory.c

@@ -615,7 +615,8 @@ is_app_addr_in_shared_heap(WASMModuleInstanceCommon *module_inst,
         (uint64)get_last_used_shared_heap_start_offset(module_inst);
     shared_heap_end = (uint64)get_last_used_shared_heap_end_offset(module_inst);
     if (app_offset >= shared_heap_start
-        && app_offset <= shared_heap_end - bytes + 1) {
+        && app_offset <= shared_heap_end - bytes + 1
+        && bytes - 1 <= shared_heap_end) {
         return true;
     }
 
@@ -624,7 +625,8 @@ is_app_addr_in_shared_heap(WASMModuleInstanceCommon *module_inst,
         is_memory64 ? heap->start_off_mem64 : heap->start_off_mem32;
     shared_heap_end = is_memory64 ? UINT64_MAX : UINT32_MAX;
     if (app_offset < shared_heap_start
-        || app_offset > shared_heap_end - bytes + 1) {
+        || app_offset > shared_heap_end - bytes + 1
+        || bytes - 1 > shared_heap_end) {
         goto fail;
     }
 
@@ -635,7 +637,8 @@ is_app_addr_in_shared_heap(WASMModuleInstanceCommon *module_inst,
             is_memory64 ? cur->start_off_mem64 : cur->start_off_mem32;
         shared_heap_end = shared_heap_start - 1 + cur->size;
         if (app_offset >= shared_heap_start
-            && app_offset <= shared_heap_end - bytes + 1) {
+            && app_offset <= shared_heap_end - bytes + 1
+            && bytes - 1 <= shared_heap_end) {
             update_last_used_shared_heap(module_inst, cur, is_memory64);
             return true;
         }
@@ -1227,7 +1230,9 @@ wasm_runtime_addr_native_to_app(WASMModuleInstanceCommon *module_inst_comm,
 #if WASM_ENABLE_SHARED_HEAP != 0
     if (is_native_addr_in_shared_heap(module_inst_comm,
                                       memory_inst->is_memory64, addr, 1)) {
-        return addr - get_last_used_shared_heap_base_addr_adj(module_inst_comm);
+        return (uint64)(uintptr_t)(addr
+                                   - get_last_used_shared_heap_base_addr_adj(
+                                       module_inst_comm));
     }
 #endif
 
@@ -1349,7 +1354,7 @@ wasm_check_app_addr_and_convert(WASMModuleInstance *module_inst, bool is_str,
             (WASMModuleInstanceCommon *)module_inst);
         shared_heap_end_off = get_last_used_shared_heap_end_offset(
             (WASMModuleInstanceCommon *)module_inst);
-        native_addr = shared_heap_base_addr_adj + app_buf_addr;
+        native_addr = shared_heap_base_addr_adj + (uintptr_t)app_buf_addr;
 
         /* The whole string must be in the shared heap */
         str = (const char *)native_addr;

core/iwasm/common/wasm_runtime_common.c

@@ -7883,3 +7883,40 @@ wasm_runtime_is_underlying_binary_freeable(WASMModuleCommon *const module)
 
     return true;
 }
+
+#if WASM_ENABLE_SHARED_HEAP != 0
+bool
+wasm_runtime_update_last_used_shared_heap(WASMModuleInstanceCommon *module_inst,
+                                          uintptr_t app_offset, size_t bytes,
+                                          uintptr_t *shared_heap_start_off_p,
+                                          uintptr_t *shared_heap_end_off_p,
+                                          uint8 **shared_heap_base_addr_adj_p,
+                                          bool is_memory64)
+{
+    WASMSharedHeap *heap = wasm_runtime_get_shared_heap(module_inst), *cur;
+    uint64 shared_heap_start, shared_heap_end;
+
+    if (bytes == 0) {
+        bytes = 1;
+    }
+
+    /* Find the exact shared heap that app addr is in, and update last used
+     * shared heap info in func context */
+    for (cur = heap; cur; cur = cur->chain_next) {
+        shared_heap_start =
+            is_memory64 ? cur->start_off_mem64 : cur->start_off_mem32;
+        shared_heap_end = shared_heap_start - 1 + cur->size;
+        if (app_offset >= shared_heap_start
+            && app_offset <= shared_heap_end - bytes + 1
+            && bytes - 1 <= shared_heap_end) {
+            *shared_heap_start_off_p = (uintptr_t)shared_heap_start;
+            *shared_heap_end_off_p = (uintptr_t)shared_heap_end;
+            *shared_heap_base_addr_adj_p =
+                cur->base_addr - (uintptr_t)shared_heap_start;
+            return true;
+        }
+    }
+
+    return false;
+}
+#endif

core/iwasm/common/wasm_runtime_common.h

@@ -1336,6 +1336,16 @@ void
 wasm_runtime_set_linux_perf(bool flag);
 #endif
 
+#if WASM_ENABLE_SHARED_HEAP != 0
+bool
+wasm_runtime_update_last_used_shared_heap(WASMModuleInstanceCommon *module_inst,
+                                          uintptr_t app_offset, size_t bytes,
+                                          uintptr_t *shared_heap_start_off_p,
+                                          uintptr_t *shared_heap_end_off_p,
+                                          uint8 **shared_heap_base_addr_adj_p,
+                                          bool is_memory64);
+#endif
+
 #ifdef __cplusplus
 }
 #endif