try func call to replace shared heap chain traverse

Author: TianlongLiang

core/iwasm/aot/aot_reloc.h

@@ -181,6 +181,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),           \
@@ -214,6 +221,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/common/wasm_runtime_common.c

@@ -7827,3 +7827,39 @@ 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) {
+            *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

@@ -1215,6 +1215,15 @@ 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

core/iwasm/compilation/aot_emit_memory.c

@@ -1527,60 +1527,87 @@ create_memory_info(const AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
                                               func_ctx->aot_inst, &offset, 1,  \
                                               #field "_p"))) {                 \
             aot_set_last_error("llvm build inbounds gep failed");              \
-            return false;                                                      \
+            goto fail;                                                         \
         }                                                                      \
         if (!(load_val =                                                       \
                   LLVMBuildLoad2(comp_ctx->builder, type, field_p, #field))) { \
             aot_set_last_error("llvm build load failed");                      \
-            return false;                                                      \
+            goto fail;                                                         \
         }                                                                      \
         if (!(func_ctx->field =                                                \
                   LLVMBuildAlloca(comp_ctx->builder, type, #field))) {         \
             aot_set_last_error("llvm build alloca failed");                    \
-            return false;                                                      \
+            goto fail;                                                         \
         }                                                                      \
         if (!LLVMBuildStore(comp_ctx->builder, load_val, func_ctx->field)) {   \
             aot_set_last_error("llvm build store failed");                     \
-            return false;                                                      \
-        }                                                                      \
-    } while (0)
-
-#define LOAD_MODULE_EXTRA_FIELD(field, type)                                   \
-    do {                                                                       \
-        get_module_extra_field_offset(field);                                  \
-        offset = I32_CONST(offset_u32);                                        \
-        CHECK_LLVM_CONST(offset);                                              \
-        if (!(field_p = LLVMBuildInBoundsGEP2(comp_ctx->builder, INT8_TYPE,    \
-                                              func_ctx->aot_inst, &offset, 1,  \
-                                              #field "_p"))) {                 \
-            aot_set_last_error("llvm build inbounds gep failed");              \
-            return false;                                                      \
-        }                                                                      \
-        if (!(func_ctx->field =                                                \
-                  LLVMBuildLoad2(comp_ctx->builder, type, field_p, #field))) { \
-            aot_set_last_error("llvm build load failed");                      \
-            return false;                                                      \
+            goto fail;                                                         \
         }                                                                      \
     } while (0)
 
 static bool
 create_shared_heap_info(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx)
 {
-    LLVMValueRef offset, field_p, load_val;
+    LLVMValueRef offset, field_p, load_val, shared_heap_head_p,
+        shared_heap_head;
+    LLVMTypeRef shared_heap_offset_type;
     uint32 offset_u32;
+#if WASM_ENABLE_MEMORY64 == 0
+    bool is_memory64 = false;
+#else
+    bool is_memory64 = IS_MEMORY64;
+#endif
 
-    /* shared_heap_base_addr_adj, shared_heap_start_off, and shared_heap_end_off
-     * can be updated later, use local variable to represent them */
+    shared_heap_offset_type =
+        comp_ctx->pointer_size == sizeof(uint64) ? I64_TYPE : I32_TYPE;
+
+    /* shared_heap_base_addr_adj, shared_heap_start_off, and
+     * shared_heap_end_off can be updated later, use local variable to
+     * represent them */
     LOAD_MODULE_EXTRA_FIELD_AND_ALLOCA(shared_heap_base_addr_adj,
                                        INT8_PTR_TYPE);
-    LOAD_MODULE_EXTRA_FIELD_AND_ALLOCA(
-        shared_heap_start_off,
-        comp_ctx->pointer_size == sizeof(uint64) ? I64_TYPE : I32_TYPE);
-    LOAD_MODULE_EXTRA_FIELD_AND_ALLOCA(
-        shared_heap_end_off,
-        comp_ctx->pointer_size == sizeof(uint64) ? I64_TYPE : I32_TYPE);
-    /* Shared Heap won't be updated, no need to alloca */
-    LOAD_MODULE_EXTRA_FIELD(shared_heap, INT8_PTR_TYPE);
+    LOAD_MODULE_EXTRA_FIELD_AND_ALLOCA(shared_heap_start_off,
+                                       shared_heap_offset_type);
+    LOAD_MODULE_EXTRA_FIELD_AND_ALLOCA(shared_heap_end_off,
+                                       shared_heap_offset_type);
+
+    /* Shared Heap head start off won't be updated, no need to alloca */
+    get_module_extra_field_offset(shared_heap);
+    offset = I32_CONST(offset_u32);
+    CHECK_LLVM_CONST(offset);
+    if (!(shared_heap_head_p = LLVMBuildInBoundsGEP2(
+              comp_ctx->builder, INT8_TYPE, func_ctx->aot_inst, &offset, 1,
+              "shared_heap_head_p"))) {
+        aot_set_last_error("llvm build inbounds gep failed");
+        goto fail;
+    }
+    if (!(shared_heap_head =
+              LLVMBuildLoad2(comp_ctx->builder, INT8_PTR_TYPE,
+                             shared_heap_head_p, "shared_heap_head"))) {
+        aot_set_last_error("llvm build load failed");
+        goto fail;
+    }
+
+    if (is_memory64) {
+        offset_u32 = offsetof(WASMSharedHeap, start_off_mem64);
+    }
+    else {
+        offset_u32 = offsetof(WASMSharedHeap, start_off_mem32);
+    }
+    offset = I32_CONST(offset_u32);
+    CHECK_LLVM_CONST(offset);
+    if (!(field_p = LLVMBuildInBoundsGEP2(comp_ctx->builder, INT8_TYPE,
+                                          shared_heap_head, &offset, 1,
+                                          "head_start_off_p"))) {
+        aot_set_last_error("llvm build inbounds gep failed");
+        goto fail;
+    }
+    if (!(func_ctx->shared_heap_head_start_off =
+              LLVMBuildLoad2(comp_ctx->builder, shared_heap_offset_type,
+                             field_p, "shared_heap_head_start_off"))) {
+        aot_set_last_error("llvm build load failed");
+        goto fail;
+    }
 
     return true;
 fail:
@@ -2439,7 +2466,7 @@ jit_stack_size_callback(void *user_data, const char *name, size_t namelen,
     stack_consumption_to_call_wrapped_func =
         musttail ? 0
                  : aot_estimate_stack_usage_for_function_call(
-                     comp_ctx, func_ctx->aot_func->func_type);
+                       comp_ctx, func_ctx->aot_func->func_type);
     LOG_VERBOSE("func %.*s stack %u + %zu + %u", (int)namelen, name,
                 stack_consumption_to_call_wrapped_func, stack_size, call_size);
 

core/iwasm/compilation/aot_llvm.c

@@ -275,8 +275,8 @@ typedef struct AOTFuncContext {
     LLVMValueRef shared_heap_base_addr_adj;
     LLVMValueRef shared_heap_start_off;
     LLVMValueRef shared_heap_end_off;
-    /* The head of shared heap chain, and its start offset */
-    LLVMValueRef shared_heap;
+    /* The start offset of the head of shared heap chain */
+    LLVMValueRef shared_heap_head_start_off;
 
     LLVMBasicBlockRef got_exception_block;
     LLVMBasicBlockRef func_return_block;

core/iwasm/compilation/aot_llvm.h

@@ -284,6 +284,7 @@ include (${IWASM_DIR}/common/gc/iwasm_gc.cmake)
 include (${IWASM_DIR}/interpreter/iwasm_interp.cmake)
 include (${IWASM_DIR}/aot/iwasm_aot.cmake)
 include (${IWASM_DIR}/compilation/iwasm_compl.cmake)
+include (${IWASM_DIR}/libraries/shared-heap/shared_heap.cmake)
 
 if (WAMR_BUILD_LIBC_BUILTIN EQUAL 1)
   include (${IWASM_DIR}/libraries/libc-builtin/libc_builtin.cmake)
@@ -365,6 +366,7 @@ add_library (vmlib
              ${LIBC_WASI_SOURCE}
              ${LIB_PTHREAD_SOURCE}
              ${LIB_WASI_THREADS_SOURCE}
+             ${LIB_SHARED_HEAP_SOURCE}
              ${IWASM_COMMON_SOURCE}
              ${IWASM_INTERP_SOURCE}
              ${IWASM_AOT_SOURCE}