Merge branch main into dev/zephyr_file_socket

.github/workflows/codeql.yml

@@ -53,7 +53,7 @@ jobs:
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@v3.27.0
+      uses: github/codeql-action/init@v3.27.6
       with:
         languages: ${{ matrix.language }}
 
@@ -70,7 +70,7 @@ jobs:
     - run: |
         ./.github/scripts/codeql_buildscript.sh
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v3.27.0
+      uses: github/codeql-action/analyze@v3.27.6
       with:
         category: "/language:${{matrix.language}}"
         upload: false
@@ -99,7 +99,7 @@ jobs:
         output: ${{ steps.step1.outputs.sarif-output }}/cpp.sarif
 
     - name: Upload CodeQL results to code scanning
-      uses: github/codeql-action/upload-sarif@v3.27.0
+      uses: github/codeql-action/upload-sarif@v3.27.6
       with:
         sarif_file: ${{ steps.step1.outputs.sarif-output }}
         category: "/language:${{matrix.language}}"

.github/workflows/compilation_on_android_ubuntu.yml

@@ -828,7 +828,7 @@ jobs:
         run: |
           mkdir build
           cd build
-          cmake .. -DWAMR_BUILD_DEBUG_INTERP=1
+          cmake .. -DWAMR_BUILD_DEBUG_INTERP=1 -DWAMR_BUILD_REF_TYPES=1
           make
         working-directory: product-mini/platforms/linux
 

.github/workflows/supply_chain.yml

@@ -60,6 +60,6 @@ jobs:
 
       # Upload the results to GitHub's code scanning dashboard.
       - name: "Upload to code-scanning"
-        uses: github/codeql-action/upload-sarif@3aa71356c75a8edd8430d54dff2982203a28be45 # v2.2.4
+        uses: github/codeql-action/upload-sarif@6f9e628e6f9a18c785dd746325ba455111df1b67 # v2.2.4
         with:
           sarif_file: results.sarif

CMakeLists.txt

@@ -113,8 +113,8 @@ if (NOT DEFINED WAMR_BUILD_SIMD)
 endif ()
 
 if (NOT DEFINED WAMR_BUILD_REF_TYPES)
-  # Disable reference types by default
+  # Enable reference types by default
-  set (WAMR_BUILD_REF_TYPES 0)
+  set (WAMR_BUILD_REF_TYPES 1)
 endif ()
 
 set (WAMR_ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR})

README.md

@@ -58,8 +58,8 @@ The WAMR VMcore supports the following architectures:
 - XTENSA, MIPS, ARC
 
 The following platforms are supported, click each link below for how to build iwasm on that platform. Refer to [WAMR porting guide](./doc/port_wamr.md) for how to port WAMR to a new platform.
-- [Linux](./product-mini/README.md#linux),  [Linux SGX (Intel Software Guard Extension)](./doc/linux_sgx.md),  [MacOS](./product-mini/README.md#macos),  [Android](./product-mini/README.md#android), [Windows](./product-mini/README.md#windows), [Windows (MinGW)](./product-mini/README.md#mingw)
+- [Linux](./product-mini/README.md#linux),  [Linux SGX (Intel Software Guard Extension)](./doc/linux_sgx.md),  [MacOS](./product-mini/README.md#macos),  [Android](./product-mini/README.md#android), [Windows](./product-mini/README.md#windows), [Windows (MinGW, MSVC)](./product-mini/README.md#mingw)
-- [Zephyr](./product-mini/README.md#zephyr),  [AliOS-Things](./product-mini/README.md#alios-things),  [VxWorks](./product-mini/README.md#vxworks), [NuttX](./product-mini/README.md#nuttx), [RT-Thread](./product-mini/README.md#RT-Thread), [ESP-IDF](./product-mini/README.md#esp-idf)
+- [Zephyr](./product-mini/README.md#zephyr),  [AliOS-Things](./product-mini/README.md#alios-things),  [VxWorks](./product-mini/README.md#vxworks), [NuttX](./product-mini/README.md#nuttx), [RT-Thread](./product-mini/README.md#RT-Thread), [ESP-IDF(FreeRTOS)](./product-mini/README.md#esp-idf)
 
 
 ## Getting started

build-scripts/build_llvm.py

@@ -102,12 +102,27 @@ def build_llvm(llvm_dir, platform, backends, projects, use_clang=False, extra_fl
         "default": [],
     }
 
+    experimental_backends = ["ARC", "Xtensa"]
+    normal_backends = [s for s in backends if s not in experimental_backends]
+
     LLVM_TARGETS_TO_BUILD = [
-        '-DLLVM_TARGETS_TO_BUILD:STRING="' + ";".join(backends) + '"'
+        '-DLLVM_TARGETS_TO_BUILD:STRING="' + ";".join(normal_backends) + '"'
-        if backends
+        if normal_backends
         else '-DLLVM_TARGETS_TO_BUILD:STRING="AArch64;ARM;Mips;RISCV;X86"'
     ]
 
+    # if not on ARC platform, but want to add expeirmental backend ARC as target
+    if platform != "ARC" and "ARC" in backends: 
+        LLVM_TARGETS_TO_BUILD.extend(
+            LLVM_EXTRA_COMPILE_OPTIONS["arc"]
+        )
+
+    if platform != "Xtensa" and "Xtensa" in backends:
+        print(
+            "Currently it's not supported to build Xtensa backend on non-Xtensa platform"
+        )
+        return None
+
     LLVM_PROJECTS_TO_BUILD = [
         '-DLLVM_ENABLE_PROJECTS:STRING="' + ";".join(projects) + '"' if projects else ""
     ]
@@ -240,6 +255,7 @@ def main():
             "X86",
             "Xtensa",
         ],
+        default=[],
         help="identify LLVM supported backends, separate by space, like '--arch ARM Mips X86'",
     )
     parser.add_argument(

core/iwasm/aot/aot_loader.c

@@ -1333,7 +1333,12 @@ load_import_table_list(const uint8 **p_buf, const uint8 *buf_end,
         if (wasm_is_type_multi_byte_type(import_table->table_type.elem_type)) {
             read_uint8(buf, buf_end, ref_type.ref_ht_common.nullable);
         }
+        else
 #endif
+        {
+            /* Skip 1 byte */
+            buf += 1;
+        }
         read_uint32(buf, buf_end, import_table->table_type.init_size);
         read_uint32(buf, buf_end, import_table->table_type.max_size);
 #if WASM_ENABLE_GC != 0
@@ -1393,7 +1398,12 @@ load_table_list(const uint8 **p_buf, const uint8 *buf_end, AOTModule *module,
         if (wasm_is_type_multi_byte_type(table->table_type.elem_type)) {
             read_uint8(buf, buf_end, ref_type.ref_ht_common.nullable);
         }
+        else
 #endif
+        {
+            /* Skip 1 byte */
+            buf += 1;
+        }
         read_uint32(buf, buf_end, table->table_type.init_size);
         read_uint32(buf, buf_end, table->table_type.max_size);
 #if WASM_ENABLE_GC != 0
@@ -1481,7 +1491,7 @@ load_table_init_data_list(const uint8 **p_buf, const uint8 *buf_end,
         else
 #endif
         {
-            /* Skip 8 byte for ref type info */
+            /* Skip 8 byte(2+2+4) for ref type info */
             buf += 8;
         }
 

core/iwasm/aot/aot_runtime.c

@@ -689,20 +689,23 @@ tables_instantiate(AOTModuleInstance *module_inst, AOTModule *module,
             tbl_inst->cur_size = import_table->table_type.init_size;
             tbl_inst->max_size =
                 aot_get_imp_tbl_data_slots(import_table, false);
-            tbl_inst->elem_type = module->tables[i].table_type.elem_type;
+            tbl_inst->elem_type = import_table->table_type.elem_type;
+            tbl_inst->is_table64 =
+                import_table->table_type.flags & TABLE64_FLAG;
 #if WASM_ENABLE_GC != 0
             tbl_inst->elem_ref_type.elem_ref_type =
-                module->tables[i].table_type.elem_ref_type;
+                import_table->table_type.elem_ref_type;
 #endif
         }
         else {
             AOTTable *table = module->tables + (i - module->import_table_count);
             tbl_inst->cur_size = table->table_type.init_size;
             tbl_inst->max_size = aot_get_tbl_data_slots(table, false);
-            tbl_inst->elem_type = module->tables[i].table_type.elem_type;
+            tbl_inst->elem_type = table->table_type.elem_type;
+            tbl_inst->is_table64 = table->table_type.flags & TABLE64_FLAG;
 #if WASM_ENABLE_GC != 0
             tbl_inst->elem_ref_type.elem_ref_type =
-                module->tables[i].table_type.elem_ref_type;
+                table->table_type.elem_ref_type;
 #endif
         }
 
@@ -1785,7 +1788,7 @@ aot_instantiate(AOTModule *module, AOTModuleInstance *parent,
     bool ret = false;
 #endif
 
-    /* Check heap size */
+    /* Align and validate heap size */
     heap_size = align_uint(heap_size, 8);
     if (heap_size > APP_HEAP_SIZE_MAX)
         heap_size = APP_HEAP_SIZE_MAX;
@@ -1905,7 +1908,9 @@ aot_instantiate(AOTModule *module, AOTModuleInstance *parent,
             goto fail;
         }
         for (i = 0; i < module->table_init_data_count; i++) {
-            if (wasm_elem_is_active(module->table_init_data_list[i]->mode))
+            if (wasm_elem_is_active(module->table_init_data_list[i]->mode)
+                || wasm_elem_is_declarative(
+                    module->table_init_data_list[i]->mode))
                 bh_bitmap_set_bit(common->elem_dropped, i);
         }
     }
@@ -2001,7 +2006,11 @@ aot_instantiate(AOTModule *module, AOTModuleInstance *parent,
         AOTTableInstance *table_inst;
         table_elem_type_t *table_data;
 
-        table = &module->tables[i];
+        /* bypass imported table since AOTImportTable doesn't have init_expr */
+        if (i < module->import_table_count)
+            continue;
+
+        table = &module->tables[i - module->import_table_count];
         bh_assert(table);
 
         if (table->init_expr.init_expr_type == INIT_EXPR_NONE) {

core/iwasm/common/SConscript

@@ -13,13 +13,10 @@ cwd     = GetCurrentDir()
 
 src = Glob('*.c')
 
-if rtconfig.ARCH == 'arm':
+if rtconfig.ARCH == 'arm' and re.match('^cortex-m.*', rtconfig.CPU):
-    if re.match('^cortex-m.*', rtconfig.CPU):
+    src += ['arch/invokeNative_thumb.s']
-        src += ['arch/invokeNative_thumb.s']
+else:
-    elif re.match('^cortex-a.*', rtconfig.CPU):
+    src.append(f"arch/invokeNative_{rtconfig.ARCH}.s")
-        src += ['arch/invokeNative_arm.s']
-elif rtconfig.ARCH == 'ia32':
-    src += ['arch/invokeNative_ia32.s']
 
 CPPPATH = [cwd, cwd + '/../include']
 

core/iwasm/common/wasm_application.c

@@ -105,7 +105,8 @@ execute_main(WASMModuleInstanceCommon *module_inst, int32 argc, char *argv[])
     bool ret, is_import_func = true, is_memory64 = false;
 #if WASM_ENABLE_MEMORY64 != 0
     WASMModuleInstance *wasm_module_inst = (WASMModuleInstance *)module_inst;
-    is_memory64 = wasm_module_inst->memories[0]->is_memory64;
+    if (wasm_module_inst->memory_count > 0)
+        is_memory64 = wasm_module_inst->memories[0]->is_memory64;
 #endif
 
     exec_env = wasm_runtime_get_exec_env_singleton(module_inst);

core/iwasm/common/wasm_c_api.c

@@ -3330,6 +3330,7 @@ argv_to_results(const uint32 *argv, const wasm_valtype_vec_t *result_defs,
                 break;
 #if WASM_ENABLE_GC == 0 && WASM_ENABLE_REF_TYPES != 0
             case WASM_EXTERNREF:
+            case WASM_FUNCREF:
                 result->of.ref = (struct wasm_ref_t *)(*(uintptr_t *)argv);
                 argv += sizeof(uintptr_t) / sizeof(uint32);
                 break;
@@ -3441,6 +3442,8 @@ wasm_func_call(const wasm_func_t *func, const wasm_val_vec_t *params,
     if (result_count) {
         if (!argv_to_results(argv, wasm_functype_results(func->type),
                              results)) {
+            wasm_runtime_set_exception(func->inst_comm_rt,
+                                       "argv_to_results failed");
             goto failed;
         }
         results->num_elems = result_count;

core/iwasm/common/wasm_runtime_common.c

@@ -3631,8 +3631,14 @@ wasm_runtime_init_wasi(WASMModuleInstanceCommon *module_inst,
 
         bh_memcpy_s(mapping_copy, max_len, map_dir_list[i],
                     (uint32)(strlen(map_dir_list[i]) + 1));
-        map_mapped = strtok(mapping_copy, "::");
+
-        map_host = strtok(NULL, "::");
+        const char *delim = "::";
+        char *delim_pos = strstr(mapping_copy, delim);
+        if (delim_pos) {
+            *delim_pos = '\0';
+            map_mapped = mapping_copy;
+            map_host = delim_pos + strlen(delim);
+        }
 
         if (!map_mapped || !map_host) {
             if (error_buf)

core/iwasm/compilation/aot_compiler.c

@@ -4093,39 +4093,6 @@ aot_compile_wasm(AOTCompContext *comp_ctx)
     return true;
 }
 
-#if !(defined(_WIN32) || defined(_WIN32_))
-char *
-aot_generate_tempfile_name(const char *prefix, const char *extension,
-                           char *buffer, uint32 len)
-{
-    int fd, name_len;
-
-    name_len = snprintf(buffer, len, "%s-XXXXXX", prefix);
-
-    if ((fd = mkstemp(buffer)) <= 0) {
-        aot_set_last_error("make temp file failed.");
-        return NULL;
-    }
-
-    /* close and remove temp file */
-    close(fd);
-    unlink(buffer);
-
-    /* Check if buffer length is enough */
-    /* name_len + '.' + extension + '\0' */
-    if (name_len + 1 + strlen(extension) + 1 > len) {
-        aot_set_last_error("temp file name too long.");
-        return NULL;
-    }
-
-    snprintf(buffer + name_len, len - name_len, ".%s", extension);
-    return buffer;
-}
-#else
-
-errno_t
-_mktemp_s(char *nameTemplate, size_t sizeInChars);
-
 char *
 aot_generate_tempfile_name(const char *prefix, const char *extension,
                            char *buffer, uint32 len)
@@ -4134,7 +4101,8 @@ aot_generate_tempfile_name(const char *prefix, const char *extension,
 
     name_len = snprintf(buffer, len, "%s-XXXXXX", prefix);
 
-    if (_mktemp_s(buffer, name_len + 1) != 0) {
+    if (!bh_mkstemp(buffer, name_len + 1)) {
+        aot_set_last_error("make temp file failed.");
         return NULL;
     }
 
@@ -4148,7 +4116,6 @@ aot_generate_tempfile_name(const char *prefix, const char *extension,
     snprintf(buffer + name_len, len - name_len, ".%s", extension);
     return buffer;
 }
-#endif /* end of !(defined(_WIN32) || defined(_WIN32_)) */
 
 bool
 aot_emit_llvm_file(AOTCompContext *comp_ctx, const char *file_name)
@@ -4227,7 +4194,6 @@ aot_emit_object_file(AOTCompContext *comp_ctx, char *file_name)
 
     bh_print_time("Begin to emit object file");
 
-#if !(defined(_WIN32) || defined(_WIN32_))
     if (comp_ctx->external_llc_compiler || comp_ctx->external_asm_compiler) {
         char cmd[1024];
         int ret;
@@ -4270,7 +4236,7 @@ aot_emit_object_file(AOTCompContext *comp_ctx, char *file_name)
                      file_name, bc_file_name);
             LOG_VERBOSE("invoking external LLC compiler:\n\t%s", cmd);
 
-            ret = system(cmd);
+            ret = bh_system(cmd);
             /* remove temp bitcode file */
             unlink(bc_file_name);
 
@@ -4323,7 +4289,7 @@ aot_emit_object_file(AOTCompContext *comp_ctx, char *file_name)
                      file_name, asm_file_name);
             LOG_VERBOSE("invoking external ASM compiler:\n\t%s", cmd);
 
-            ret = system(cmd);
+            ret = bh_system(cmd);
             /* remove temp assembly file */
             unlink(asm_file_name);
 
@@ -4336,7 +4302,6 @@ aot_emit_object_file(AOTCompContext *comp_ctx, char *file_name)
 
         return true;
     }
-#endif /* end of !(defined(_WIN32) || defined(_WIN32_)) */
 
     if (!strncmp(LLVMGetTargetName(target), "arc", 3))
         /* Emit to assembly file instead for arc target

core/iwasm/compilation/aot_emit_aot_file.c

@@ -4292,10 +4292,6 @@ aot_obj_data_create(AOTCompContext *comp_ctx)
 
     bh_print_time("Begin to emit object file");
     if (comp_ctx->external_llc_compiler || comp_ctx->external_asm_compiler) {
-#if defined(_WIN32) || defined(_WIN32_)
-        aot_set_last_error("external toolchain not supported on Windows");
-        goto fail;
-#else
         /* Generate a temp file name */
         int ret;
         char obj_file_name[64];
@@ -4323,27 +4319,18 @@ aot_obj_data_create(AOTCompContext *comp_ctx)
             aot_set_last_error("create mem buffer with file failed.");
             goto fail;
         }
-#endif /* end of defined(_WIN32) || defined(_WIN32_) */
     }
     else if (!strncmp(LLVMGetTargetName(target), "arc", 3)) {
-#if defined(_WIN32) || defined(_WIN32_)
-        aot_set_last_error("emit object file on Windows is unsupported.");
-        goto fail;
-#else
         /* Emit to assembly file instead for arc target
            as it cannot emit to object file */
         char file_name[] = "wasm-XXXXXX", buf[128];
-        int fd, ret;
+        int ret;
 
-        if ((fd = mkstemp(file_name)) <= 0) {
+        if (!bh_mkstemp(file_name, sizeof(file_name))) {
             aot_set_last_error("make temp file failed.");
             goto fail;
         }
 
-        /* close and remove temp file */
-        close(fd);
-        unlink(file_name);
-
         snprintf(buf, sizeof(buf), "%s%s", file_name, ".s");
         if (LLVMTargetMachineEmitToFile(comp_ctx->target_machine,
                                         comp_ctx->module, buf, LLVMAssemblyFile,
@@ -4364,7 +4351,7 @@ aot_obj_data_create(AOTCompContext *comp_ctx)
                  "/opt/zephyr-sdk/arc-zephyr-elf/bin/arc-zephyr-elf-gcc ",
                  "-mcpu=arcem -o ", file_name, ".o -c ", file_name, ".s");
         /* TODO: use try..catch to handle possible exceptions */
-        ret = system(buf);
+        ret = bh_system(buf);
         /* remove temp assembly file */
         snprintf(buf, sizeof(buf), "%s%s", file_name, ".s");
         unlink(buf);
@@ -4391,7 +4378,6 @@ aot_obj_data_create(AOTCompContext *comp_ctx)
             aot_set_last_error("create mem buffer with file failed.");
             goto fail;
         }
-#endif /* end of defined(_WIN32) || defined(_WIN32_) */
     }
     else {
         if (LLVMTargetMachineEmitToMemoryBuffer(

core/iwasm/compilation/aot_emit_memory.c

@@ -273,10 +273,24 @@ aot_check_memory_overflow(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
     }
 
     /* offset1 = offset + addr; */
-    /* TODO: check whether integer overflow occurs when memory is 64-bit
-             and boundary check is enabled */
     BUILD_OP(Add, offset_const, addr, offset1, "offset1");
 
+    if (is_memory64 && comp_ctx->enable_bound_check) {
+        /* Check whether integer overflow occurs in offset + addr */
+        LLVMBasicBlockRef check_integer_overflow_end;
+        ADD_BASIC_BLOCK(check_integer_overflow_end,
+                        "check_integer_overflow_end");
+        LLVMMoveBasicBlockAfter(check_integer_overflow_end, block_curr);
+
+        BUILD_ICMP(LLVMIntULT, offset1, offset_const, cmp1, "cmp1");
+        if (!aot_emit_exception(comp_ctx, func_ctx,
+                                EXCE_OUT_OF_BOUNDS_MEMORY_ACCESS, true, cmp1,
+                                check_integer_overflow_end)) {
+            goto fail;
+        }
+        SET_BUILD_POS(check_integer_overflow_end);
+    }
+
     if (comp_ctx->enable_shared_heap /* TODO: && mem_idx == 0 */) {
         LLVMBasicBlockRef app_addr_in_shared_heap, app_addr_in_linear_mem;
         LLVMValueRef is_in_shared_heap, shared_heap_check_bound = NULL;
@@ -303,7 +317,7 @@ aot_check_memory_overflow(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
         LLVMPositionBuilderAtEnd(comp_ctx->builder, block_curr);
 
         if (!is_target_64bit) {
-            /* Check whether interger overflow occurs in addr + offset */
+            /* Check whether integer overflow occurs in addr + offset */
             LLVMBasicBlockRef check_integer_overflow_end;
             ADD_BASIC_BLOCK(check_integer_overflow_end,
                             "check_integer_overflow_end");
@@ -1215,10 +1229,24 @@ check_bulk_memory_overflow(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
         goto fail;
     }
 
-    /* TODO: check whether integer overflow occurs when memory is 64-bit
-             and boundary check is enabled */
     BUILD_OP(Add, offset, bytes, max_addr, "max_addr");
 
+    if (is_memory64 && comp_ctx->enable_bound_check) {
+        /* Check whether integer overflow occurs in offset + addr */
+        LLVMBasicBlockRef check_integer_overflow_end;
+        ADD_BASIC_BLOCK(check_integer_overflow_end,
+                        "check_integer_overflow_end");
+        LLVMMoveBasicBlockAfter(check_integer_overflow_end, block_curr);
+
+        BUILD_ICMP(LLVMIntULT, max_addr, offset, cmp, "cmp");
+        if (!aot_emit_exception(comp_ctx, func_ctx,
+                                EXCE_OUT_OF_BOUNDS_MEMORY_ACCESS, true, cmp,
+                                check_integer_overflow_end)) {
+            goto fail;
+        }
+        SET_BUILD_POS(check_integer_overflow_end);
+    }
+
     if (comp_ctx->enable_shared_heap /* TODO: && mem_idx == 0 */) {
         LLVMBasicBlockRef app_addr_in_shared_heap, app_addr_in_linear_mem;
         LLVMValueRef shared_heap_start_off, shared_heap_check_bound;

core/iwasm/compilation/aot_llvm.c

@@ -2746,10 +2746,6 @@ aot_create_comp_context(const AOTCompData *comp_data, aot_comp_option_t option)
         /* verify external llc compiler */
         comp_ctx->external_llc_compiler = getenv("WAMRC_LLC_COMPILER");
         if (comp_ctx->external_llc_compiler) {
-#if defined(_WIN32) || defined(_WIN32_)
-            comp_ctx->external_llc_compiler = NULL;
-            LOG_WARNING("External LLC compiler not supported on Windows.");
-#else
             if (access(comp_ctx->external_llc_compiler, X_OK) != 0) {
                 LOG_WARNING("WAMRC_LLC_COMPILER [%s] not found, fallback to "
                             "default pipeline",
@@ -2761,17 +2757,12 @@ aot_create_comp_context(const AOTCompData *comp_data, aot_comp_option_t option)
                 LOG_VERBOSE("Using external LLC compiler [%s]",
                             comp_ctx->external_llc_compiler);
             }
-#endif
         }
 
         /* verify external asm compiler */
         if (!comp_ctx->external_llc_compiler) {
             comp_ctx->external_asm_compiler = getenv("WAMRC_ASM_COMPILER");
             if (comp_ctx->external_asm_compiler) {
-#if defined(_WIN32) || defined(_WIN32_)
-                comp_ctx->external_asm_compiler = NULL;
-                LOG_WARNING("External ASM compiler not supported on Windows.");
-#else
                 if (access(comp_ctx->external_asm_compiler, X_OK) != 0) {
                     LOG_WARNING(
                         "WAMRC_ASM_COMPILER [%s] not found, fallback to "
@@ -2784,7 +2775,6 @@ aot_create_comp_context(const AOTCompData *comp_data, aot_comp_option_t option)
                     LOG_VERBOSE("Using external ASM compiler [%s]",
                                 comp_ctx->external_asm_compiler);
                 }
-#endif
             }
         }
 

core/iwasm/compilation/aot_llvm.h

@@ -37,6 +37,18 @@
 #include "aot_orc_extra.h"
 #include "aot_comp_option.h"
 
+#if defined(_WIN32) || defined(_WIN32_)
+#include <io.h>
+#define access _access
+/* On windows there is no X_OK flag to check for executablity, only check for
+ * existence */
+#ifdef X_OK
+#undef X_OK
+#endif
+#define X_OK 00
+#define unlink _unlink
+#endif
+
 #ifdef __cplusplus
 extern "C" {
 #endif

core/iwasm/compilation/aot_orc_extra.cpp

@@ -177,7 +177,7 @@ LLVMOrcLLLazyJITBuilderSetJITTargetMachineBuilder(
     LLVMOrcDisposeJITTargetMachineBuilder(JTMP);
 }
 
-static Optional<CompileOnDemandLayer::GlobalValueSet>
+static Optional<GlobalValueSet>
 PartitionFunction(GlobalValueSet Requested)
 {
     std::vector<const GlobalValue *> GVsToAdd;

core/iwasm/interpreter/wasm_interp_classic.c

@@ -593,8 +593,8 @@ wasm_interp_get_frame_ref(WASMInterpFrame *frame)
 #endif
 
 #if WASM_ENABLE_MEMORY64 != 0
-#define POP_MEM_OFFSET() (is_memory64 ? POP_I64() : POP_I32())
+#define POP_MEM_OFFSET() (is_memory64 ? POP_I64() : (uint32)POP_I32())
-#define POP_TBL_ELEM_IDX() (is_table64 ? POP_I64() : POP_I32())
+#define POP_TBL_ELEM_IDX() (is_table64 ? POP_I64() : (uint32)POP_I32())
 #else
 #define POP_MEM_OFFSET() POP_I32()
 #define POP_TBL_ELEM_IDX() POP_I32()

core/iwasm/interpreter/wasm_loader.c

@@ -3610,6 +3610,17 @@ load_function_section(const uint8 *buf, const uint8 *buf_end,
 #endif
             }
 
+            /* Code size in code entry can't be smaller than size of vec(locals)
+             * + expr(at least 1 for opcode end). And expressions are encoded by
+             * their instruction sequence terminated with an explicit 0x0B
+             * opcode for end. */
+            if (p_code_end <= p_code || *(p_code_end - 1) != WASM_OP_END) {
+                set_error_buf(
+                    error_buf, error_buf_size,
+                    "section size mismatch: function body END opcode expected");
+                return false;
+            }
+
             /* Alloc memory, layout: function structure + local types */
             code_size = (uint32)(p_code_end - p_code);
 
@@ -9844,7 +9855,12 @@ reserve_block_ret(WASMLoaderContext *loader_ctx, uint8 opcode,
             else {
                 loader_ctx->frame_offset = frame_offset;
                 loader_ctx->dynamic_offset = dynamic_offset;
-                PUSH_OFFSET_TYPE(return_types[i]);
+                if (!(wasm_loader_push_frame_offset(
+                        loader_ctx, return_types[i], disable_emit,
+                        operand_offset, error_buf, error_buf_size))) {
+                    wasm_runtime_free(emit_data);
+                    goto fail;
+                }
                 wasm_loader_emit_backspace(loader_ctx, sizeof(int16));
                 loader_ctx->frame_offset = frame_offset_org;
                 loader_ctx->dynamic_offset = dynamic_offset_org;
@@ -9874,13 +9890,6 @@ fail:
 }
 #endif /* WASM_ENABLE_FAST_INTERP */
 
-#define RESERVE_BLOCK_RET()                                                 \
-    do {                                                                    \
-        if (!reserve_block_ret(loader_ctx, opcode, disable_emit, error_buf, \
-                               error_buf_size))                             \
-            goto fail;                                                      \
-    } while (0)
-
 #define PUSH_TYPE(type)                                               \
     do {                                                              \
         if (!(wasm_loader_push_frame_ref(loader_ctx, type, error_buf, \
@@ -11601,7 +11610,10 @@ re_scan:
 #if WASM_ENABLE_FAST_INTERP != 0
                 /* if the result of if branch is in local or const area, add a
                  * copy op */
-                RESERVE_BLOCK_RET();
+                if (!reserve_block_ret(loader_ctx, opcode, disable_emit,
+                                       error_buf, error_buf_size)) {
+                    goto fail;
+                }
 
                 emit_empty_label_addr_and_frame_ip(PATCH_END);
                 apply_label_patch(loader_ctx, 1, PATCH_ELSE);
@@ -11661,7 +11673,15 @@ re_scan:
 #if WASM_ENABLE_FAST_INTERP != 0
                 skip_label();
                 /* copy the result to the block return address */
-                RESERVE_BLOCK_RET();
+                if (!reserve_block_ret(loader_ctx, opcode, disable_emit,
+                                       error_buf, error_buf_size)) {
+                    /* it could be tmp frame_csp allocated from opcode like
+                     * OP_BR and not counted in loader_ctx->csp_num, it won't
+                     * be freed in wasm_loader_ctx_destroy(loader_ctx) so need
+                     * to free the loader_ctx->frame_csp if fails */
+                    free_label_patch_list(loader_ctx->frame_csp);
+                    goto fail;
+                }
 
                 apply_label_patch(loader_ctx, 0, PATCH_END);
                 free_label_patch_list(loader_ctx->frame_csp);
@@ -15837,15 +15857,12 @@ re_scan:
     }
 
     if (loader_ctx->csp_num > 0) {
-        if (cur_func_idx < module->function_count - 1)
+        /* unmatched end opcodes result from unbalanced control flow structures,
-            /* Function with missing end marker (between two functions) */
+         * for example, br_table with inconsistent target count (1 declared, 2
-            set_error_buf(error_buf, error_buf_size, "END opcode expected");
+         * given), or simply superfluous end opcodes */
-        else
+        set_error_buf(
-            /* Function with missing end marker
+            error_buf, error_buf_size,
-               (at EOF or end of code sections) */
+            "unexpected end opcodes from unbalanced control flow structures");
-            set_error_buf(error_buf, error_buf_size,
-                          "unexpected end of section or function, "
-                          "or section size mismatch");
         goto fail;
     }
 

core/iwasm/interpreter/wasm_mini_loader.c

@@ -1183,6 +1183,8 @@ load_function_section(const uint8 *buf, const uint8 *buf_end,
                 local_count += sub_local_count;
             }
 
+            bh_assert(p_code_end > p_code && *(p_code_end - 1) == WASM_OP_END);
+
             /* Alloc memory, layout: function structure + local types */
             code_size = (uint32)(p_code_end - p_code);
 
@@ -5559,7 +5561,12 @@ reserve_block_ret(WASMLoaderContext *loader_ctx, uint8 opcode,
             else {
                 loader_ctx->frame_offset = frame_offset;
                 loader_ctx->dynamic_offset = dynamic_offset;
-                PUSH_OFFSET_TYPE(return_types[i]);
+                if (!(wasm_loader_push_frame_offset(
+                        loader_ctx, return_types[i], disable_emit,
+                        operand_offset, error_buf, error_buf_size))) {
+                    wasm_runtime_free(emit_data);
+                    goto fail;
+                }
                 wasm_loader_emit_backspace(loader_ctx, sizeof(int16));
                 loader_ctx->frame_offset = frame_offset_org;
                 loader_ctx->dynamic_offset = dynamic_offset_org;
@@ -5590,13 +5597,6 @@ fail:
 
 #endif /* WASM_ENABLE_FAST_INTERP */
 
-#define RESERVE_BLOCK_RET()                                                 \
-    do {                                                                    \
-        if (!reserve_block_ret(loader_ctx, opcode, disable_emit, error_buf, \
-                               error_buf_size))                             \
-            goto fail;                                                      \
-    } while (0)
-
 #define PUSH_TYPE(type)                                               \
     do {                                                              \
         if (!(wasm_loader_push_frame_ref(loader_ctx, type, error_buf, \
@@ -6364,7 +6364,10 @@ re_scan:
 #if WASM_ENABLE_FAST_INTERP != 0
                 /* if the result of if branch is in local or const area, add a
                  * copy op */
-                RESERVE_BLOCK_RET();
+                if (!reserve_block_ret(loader_ctx, opcode, disable_emit,
+                                       error_buf, error_buf_size)) {
+                    goto fail;
+                }
 
                 emit_empty_label_addr_and_frame_ip(PATCH_END);
                 apply_label_patch(loader_ctx, 1, PATCH_ELSE);
@@ -6424,7 +6427,11 @@ re_scan:
 #if WASM_ENABLE_FAST_INTERP != 0
                 skip_label();
                 /* copy the result to the block return address */
-                RESERVE_BLOCK_RET();
+                if (!reserve_block_ret(loader_ctx, opcode, disable_emit,
+                                       error_buf, error_buf_size)) {
+                    free_label_patch_list(loader_ctx->frame_csp);
+                    goto fail;
+                }
 
                 apply_label_patch(loader_ctx, 0, PATCH_END);
                 free_label_patch_list(loader_ctx->frame_csp);

core/iwasm/interpreter/wasm_runtime.c

@@ -1208,9 +1208,8 @@ globals_instantiate(WASMModule *module, WASMModuleInstance *module_inst,
 
             /* The linked global instance has been initialized, we
                just need to copy the value. */
-            bh_memcpy_s(&(global->initial_value), sizeof(WASMValue),
+            global->initial_value =
-                        &(global_import->import_global_linked->init_expr),
+                global_import->import_global_linked->init_expr.u;
-                        sizeof(WASMValue));
         }
         else
 #endif
@@ -2467,7 +2466,8 @@ wasm_instantiate(WASMModule *module, WASMModuleInstance *parent,
             goto fail;
         }
         for (i = 0; i < module->table_seg_count; i++) {
-            if (wasm_elem_is_active(module->table_segments[i].mode))
+            if (wasm_elem_is_active(module->table_segments[i].mode)
+                || wasm_elem_is_declarative(module->table_segments[i].mode))
                 bh_bitmap_set_bit(module_inst->e->common.elem_dropped, i);
         }
     }

core/shared/platform/windows/win_clock.c

@@ -10,9 +10,11 @@
 #define NANOSECONDS_PER_SECOND 1000000000ULL
 #define NANOSECONDS_PER_TICK 100
 
+#if WINAPI_PARTITION_DESKTOP
 extern NTSTATUS
 NtQueryTimerResolution(PULONG MinimumResolution, PULONG MaximumResolution,
                        PULONG CurrentResolution);
+#endif
 
 static __wasi_errno_t
 calculate_monotonic_clock_frequency(uint64 *out_frequency)

core/shared/platform/windows/win_file.c

@@ -1758,7 +1758,7 @@ os_closedir(os_dir_stream dir_stream)
     if (!success) {
         DWORD win_error = GetLastError();
 
-        if (win_error = ERROR_INVALID_HANDLE)
+        if (win_error == ERROR_INVALID_HANDLE)
             BH_FREE(dir_stream);
         return convert_windows_error_code(win_error);
     }

core/shared/platform/windows/win_thread.c

@@ -60,6 +60,63 @@ static DWORD thread_data_key;
 static void(WINAPI *GetCurrentThreadStackLimits_Kernel32)(PULONG_PTR,
                                                           PULONG_PTR) = NULL;
 
+static void
+thread_data_list_add(os_thread_data *thread_data)
+{
+    os_mutex_lock(&thread_data_list_lock);
+    /* If already in list, just return */
+    os_thread_data *p = &supervisor_thread_data;
+    while (p) {
+        if (p == thread_data) {
+            os_mutex_unlock(&thread_data_list_lock);
+            return;
+        }
+        p = p->next;
+    }
+    thread_data->next = supervisor_thread_data.next;
+    supervisor_thread_data.next = thread_data;
+    os_mutex_unlock(&thread_data_list_lock);
+}
+
+static void
+thread_data_list_remove(os_thread_data *thread_data)
+{
+    os_mutex_lock(&thread_data_list_lock);
+    /* Search and remove it from list */
+    os_thread_data *p = &supervisor_thread_data;
+    while (p && p->next != thread_data)
+        p = p->next;
+
+    if (p && p->next) {
+        bh_assert(p->next == thread_data);
+        p->next = p->next->next;
+        /* Release the resources in thread_data */
+        os_cond_destroy(&thread_data->wait_cond);
+        os_mutex_destroy(&thread_data->wait_lock);
+        os_sem_destroy(&thread_data->wait_node.sem);
+        BH_FREE(thread_data);
+    }
+    os_mutex_unlock(&thread_data_list_lock);
+}
+
+static os_thread_data *
+thread_data_list_lookup(korp_tid tid)
+{
+    os_thread_data *thread_data = (os_thread_data *)tid;
+    os_mutex_lock(&thread_data_list_lock);
+    os_thread_data *p = supervisor_thread_data.next;
+    while (p) {
+        if (p == thread_data) {
+            /* Found */
+            os_mutex_unlock(&thread_data_list_lock);
+            return p;
+        }
+        p = p->next;
+    }
+    os_mutex_unlock(&thread_data_list_lock);
+    return NULL;
+}
+
 int
 os_sem_init(korp_sem *sem);
 int
@@ -254,10 +311,7 @@ os_thread_create_with_prio(korp_tid *p_tid, thread_start_routine_t start,
     }
 
     /* Add thread data into thread data list */
-    os_mutex_lock(&thread_data_list_lock);
+    thread_data_list_add(thread_data);
-    thread_data->next = supervisor_thread_data.next;
-    supervisor_thread_data.next = thread_data;
-    os_mutex_unlock(&thread_data_list_lock);
 
     /* Wait for the thread routine to set thread_data's tid
        and add thread_data to thread data list */
@@ -302,8 +356,12 @@ os_thread_join(korp_tid thread, void **p_retval)
     curr_thread_data->wait_node.next = NULL;
 
     /* Get thread data of thread to join */
-    thread_data = (os_thread_data *)thread;
+    thread_data = thread_data_list_lookup(thread);
-    bh_assert(thread_data);
+
+    if (thread_data == NULL) {
+        os_printf("Can't join thread %p, it does not exist", thread);
+        return BHT_ERROR;
+    }
 
     os_mutex_lock(&thread_data->wait_lock);
 
@@ -312,6 +370,7 @@ os_thread_join(korp_tid thread, void **p_retval)
         if (p_retval)
             *p_retval = thread_data->thread_retval;
         os_mutex_unlock(&thread_data->wait_lock);
+        thread_data_list_remove(thread_data);
         return BHT_OK;
     }
 
@@ -332,6 +391,7 @@ os_thread_join(korp_tid thread, void **p_retval)
     os_sem_wait(&curr_thread_data->wait_node.sem);
     if (p_retval)
         *p_retval = curr_thread_data->wait_node.retval;
+    thread_data_list_remove(thread_data);
     return BHT_OK;
 }
 

core/shared/platform/zephyr/zephyr_thread.c

@@ -393,6 +393,16 @@ os_thread_join(korp_tid thread, void **value_ptr)
     os_thread_data *thread_data;
     os_thread_wait_node *node;
 
+    /* Get thread data */
+    thread_data = thread_data_list_lookup(thread);
+
+    if (thread_data == NULL) {
+        os_printf(
+            "Can't join thread %p, probably already exited or does not exist",
+            thread);
+        return BHT_OK;
+    }
+
     /* Create wait node and append it to wait list */
     if (!(node = BH_MALLOC(sizeof(os_thread_wait_node))))
         return BHT_ERROR;
@@ -400,10 +410,6 @@ os_thread_join(korp_tid thread, void **value_ptr)
     zsem_init(&node->sem, 0, 1);
     node->next = NULL;
 
-    /* Get thread data */
-    thread_data = thread_data_list_lookup(thread);
-    bh_assert(thread_data != NULL);
-
     zmutex_lock(&thread_data->wait_list_lock, K_FOREVER);
     if (!thread_data->thread_wait_list)
         thread_data->thread_wait_list = node;

core/shared/platform/zephyr/zephyr_time.c

@@ -14,6 +14,17 @@ os_time_get_boot_us()
 uint64
 os_time_thread_cputime_us(void)
 {
-    /* FIXME if u know the right api */
+    k_tid_t tid;
-    return os_time_get_boot_us();
+    struct k_thread_runtime_stats stats;
+    uint32 clock_freq;
+    uint64 cpu_cycles, time_in_us = 0;
+
+    tid = k_current_get();
+    if (k_thread_runtime_stats_get(tid, &stats) == 0) {
+        cpu_cycles = stats.execution_cycles;
+        clock_freq = CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC;
+        time_in_us = (cpu_cycles * 1000000) / clock_freq;
+    }
+
+    return time_in_us;
 }

core/shared/utils/bh_atomic.h

@@ -114,7 +114,8 @@ typedef uint16 bh_atomic_16_t;
 #endif
 
 /* On some 32-bit platform, disable 64-bit atomic operations, otherwise
- * undefined reference to `__atomic_load_8' */
+ * undefined reference to `__atomic_load_8', if on Zephyr, can add board related
+ * macro in autoconf.h to control */
 #ifndef WASM_UINT64_IS_ATOMIC
 #if !defined(__linux__) && !defined(__FreeBSD__) && !defined(__NetBSD__) \
     && !defined(__OpenBSD__) && (defined(__riscv) || defined(__arm__))   \

core/shared/utils/bh_common.c

@@ -165,3 +165,53 @@ wa_strdup(const char *s)
     }
     return s1;
 }
+
+#if WASM_ENABLE_WAMR_COMPILER != 0 || WASM_ENABLE_JIT != 0
+int
+bh_system(const char *cmd)
+{
+    int ret;
+
+#if !(defined(_WIN32) || defined(_WIN32_))
+    ret = system(cmd);
+#else
+    ret = _spawnlp(_P_WAIT, "cmd.exe", "/c", cmd, NULL);
+#endif
+
+    return ret;
+}
+
+#if defined(_WIN32) || defined(_WIN32_)
+errno_t
+_mktemp_s(char *nameTemplate, size_t sizeInChars);
+#endif
+
+bool
+bh_mkstemp(char *file_name, size_t name_len)
+{
+    int fd;
+
+#if !(defined(_WIN32) || defined(_WIN32_))
+    (void)name_len;
+    /* On Linux, it generates a unique temporary filename from template, creates
+     * and opens the file, and returns an open file descriptor for the file. */
+    if ((fd = mkstemp(file_name)) <= 0) {
+        goto fail;
+    }
+
+    /* close and remove temp file */
+    close(fd);
+    unlink(file_name);
+#else
+    /* On Windows, it generates a unique temporary file name but does not create
+     * or open the file */
+    if (_mktemp_s(file_name, name_len) != 0) {
+        goto fail;
+    }
+#endif
+
+    return true;
+fail:
+    return false;
+}
+#endif /* End of WASM_ENABLE_WAMR_COMPILER != 0 || WASM_ENABLE_JIT != 0 */

core/shared/utils/bh_common.h

@@ -66,6 +66,16 @@ bh_strdup(const char *s);
 char *
 wa_strdup(const char *s);
 
+#if WASM_ENABLE_WAMR_COMPILER != 0 || WASM_ENABLE_JIT != 0
+/* Executes a system command in bash/cmd.exe */
+int
+bh_system(const char *cmd);
+
+/* Tests whether can create a temporary file with the given name */
+bool
+bh_mkstemp(char *filename, size_t name_len);
+#endif
+
 #ifdef __cplusplus
 }
 #endif

doc/build_wamr.md

@@ -223,7 +223,7 @@ Currently we only profile the memory consumption of module, module_instance and
 > See [basic sample](../samples/basic/src/main.c) for a usage example.
 
 #### **Enable reference types feature**
-- **WAMR_BUILD_REF_TYPES**=1/0, default to disable if not set
+- **WAMR_BUILD_REF_TYPES**=1/0, default to enable if not set
 
 #### **Exclude WAMR application entry functions**
 - **WAMR_DISABLE_APP_ENTRY**=1/0, default to disable if not set

product-mini/platforms/linux/CMakeLists.txt

@@ -108,8 +108,8 @@ if (NOT DEFINED WAMR_BUILD_SIMD)
 endif ()
 
 if (NOT DEFINED WAMR_BUILD_REF_TYPES)
-  # Disable reference types by default
+  # Enable reference types by default
-  set (WAMR_BUILD_REF_TYPES 0)
+  set (WAMR_BUILD_REF_TYPES 1)
 endif ()
 
 if (NOT DEFINED WAMR_BUILD_DEBUG_INTERP)

product-mini/platforms/rt-thread/iwasm.c

@@ -192,6 +192,21 @@ my_read_file_to_buffer(char *filename, rt_uint32_t *size)
 {
     struct stat f_stat;
 
+    if (!filename || !size) {
+        rt_set_errno(-EINVAL);
+        return RT_NULL;
+    }
+
+    if (stat(filename, &f_stat) != 0) {
+        rt_set_errno(errno);
+        return RT_NULL;
+    }
+
+    if (f_stat.st_size <= 0) {
+        rt_set_errno(-EINVAL);
+        return RT_NULL;
+    }
+
     rt_uint8_t *buff = rt_malloc(f_stat.st_size);
     *size = 0;
     if (!buff) {

product-mini/platforms/zephyr/simple/prj.conf

@@ -5,3 +5,4 @@ CONFIG_STACK_SENTINEL=y
 CONFIG_PRINTK=y
 CONFIG_LOG=y
 CONFIG_LOG_BUFFER_SIZE=4096
+CONFIG_THREAD_RUNTIME_STATS=y

test-tools/wamr-ide/VSCode-Extension/src/test/suite/extension.test.ts

@@ -196,11 +196,14 @@ suite('Inegration Tests', function () {
         );
 
         // Vector
-        assert.equal(
+        // TODO: The vector format conversion have some problem now, can't see the actual value
-            namesToVariables['vector'].value,
+        // - (5) vec![{...}, {...}, {...}, {...}, {...}, ...]
-            ' (5) vec![1, 2, 3, 4, 12]',
+        // + (5) vec![1, 2, 3, 4, 12]
-            'The Vector summary string looks different than expected'
+        // assert.equal(
-        );
+        //     namesToVariables['vector'].value,
+        //     ' (5) vec![1, 2, 3, 4, 12]',
+        //     'The Vector summary string looks different than expected'
+        // );
 
         // Map
         assert.equal(

tests/unit/shared-heap/CMakeLists.txt

@@ -8,7 +8,7 @@ project(test-shared-heap)
 add_definitions(-DRUN_ON_LINUX)
 
 set(WAMR_BUILD_APP_FRAMEWORK 0)
-set(WAMR_BUILD_AOT 0)
+set(WAMR_BUILD_AOT 1)
 set(WAMR_BUILD_INTERP 1)
 set(WAMR_BUILD_FAST_INTERP 1)
 set(WAMR_BUILD_JIT 0)

tests/unit/shared-heap/shared_heap_test.cc

@@ -92,37 +92,28 @@ destroy_module_env(struct ret_env module_env)
     }
 }
 
-TEST_F(shared_heap_test, test_shared_heap)
+static void test_shared_heap(WASMSharedHeap *shared_heap, const char *file, const char *func_name, uint32 argc, uint32 argv[])
 {
     struct ret_env tmp_module_env;
     WASMFunctionInstanceCommon *func_test = nullptr;
     bool ret = false;
-    uint32 argv[1] = { 65535 };
     const char *exception = nullptr;
-    SharedHeapInitArgs args;
-    WASMSharedHeap *shared_heap = nullptr;
 
-    args.size = 1024;
+    tmp_module_env = load_wasm((char *)file, 0);
-    shared_heap = wasm_runtime_create_shared_heap(&args);
-    tmp_module_env = load_wasm((char *)"test.wasm", 0);
 
-    if (!shared_heap) {
-        printf("Failed to create shared heap\n");
-        goto test_failed;
-    }
     if (!wasm_runtime_attach_shared_heap(tmp_module_env.wasm_module_inst, shared_heap)) {
         printf("Failed to attach shared heap\n");
         goto test_failed;
     }
-    func_test = wasm_runtime_lookup_function(
+    func_test = wasm_runtime_lookup_function(tmp_module_env.wasm_module_inst,
-        tmp_module_env.wasm_module_inst, "test");
+                                             func_name);
     if (!func_test) {
         printf("\nFailed to wasm_runtime_lookup_function!\n");
         goto test_failed;
     }
 
     ret =
-        wasm_runtime_call_wasm(tmp_module_env.exec_env, func_test, 1, argv);
+        wasm_runtime_call_wasm(tmp_module_env.exec_env, func_test, argc, argv);
     if (!ret) {
         printf("\nFailed to wasm_runtime_call_wasm!\n");
         const char *s = wasm_runtime_get_exception(tmp_module_env.wasm_module_inst);
@@ -131,12 +122,119 @@ TEST_F(shared_heap_test, test_shared_heap)
     }
 
     wasm_runtime_detach_shared_heap(tmp_module_env.wasm_module_inst);
-
-    EXPECT_EQ(10, argv[0]);
-
     destroy_module_env(tmp_module_env);
     return;
 test_failed:
     destroy_module_env(tmp_module_env);
     EXPECT_EQ(1, 0);
 }
+
+TEST_F(shared_heap_test, test_shared_heap_basic)
+{
+    SharedHeapInitArgs args;
+    WASMSharedHeap *shared_heap = nullptr;
+    uint32 argv[1] = { 0 };
+
+    args.size = 1024;
+    shared_heap = wasm_runtime_create_shared_heap(&args);
+
+    if (!shared_heap) {
+        printf("Failed to create shared heap\n");
+        EXPECT_EQ(1, 0);
+    }
+
+    // test wasm
+    test_shared_heap(shared_heap, "test.wasm", "test", 1, argv);
+    EXPECT_EQ(10, argv[0]);
+
+    // test aot
+    test_shared_heap(shared_heap, "test.aot", "test", 1, argv);
+    EXPECT_EQ(10, argv[0]);
+
+}
+
+TEST_F(shared_heap_test, test_shared_heap_malloc_fail)
+{
+    SharedHeapInitArgs args;
+    WASMSharedHeap *shared_heap = nullptr;
+    uint32 argv[1] = { 0 };
+
+    args.size = 1024;
+    shared_heap = wasm_runtime_create_shared_heap(&args);
+
+    if (!shared_heap) {
+        printf("Failed to create shared heap\n");
+        EXPECT_EQ(1, 0);
+    }
+
+    // test wasm
+    test_shared_heap(shared_heap, "test.wasm", "test_malloc_fail", 1, argv);
+    EXPECT_EQ(1, argv[0]);
+
+    // test aot
+    test_shared_heap(shared_heap, "test.aot", "test_malloc_fail", 1, argv);
+    EXPECT_EQ(1, argv[0]);
+}
+
+#ifndef native_function
+#define native_function(func_name, signature) \
+    { #func_name, (void *)glue_##func_name, signature, NULL }
+
+#endif
+#ifndef nitems
+#define nitems(_a) (sizeof(_a) / sizeof(0 [(_a)]))
+#endif /* nitems */
+uintptr_t glue_test_addr_conv(wasm_exec_env_t env, uintptr_t addr)
+{
+  wasm_module_inst_t module_inst = get_module_inst(env);
+  uintptr_t ret;
+  void *native_addr = (void *)addr;
+  uintptr_t app_addr = addr_native_to_app(native_addr);
+
+  native_addr = addr_app_to_native(app_addr);
+  if (native_addr != (void *)addr)
+  {
+    EXPECT_EQ(1, 0);
+  }
+  return app_addr;
+}
+
+static NativeSymbol g_test_native_symbols[] =
+{
+  native_function(test_addr_conv,"(*)i"),
+};
+
+TEST_F(shared_heap_test, test_addr_conv)
+{
+    SharedHeapInitArgs args;
+    WASMSharedHeap *shared_heap = nullptr;
+    uint32 argv[1] = { 0 };
+    struct ret_env tmp_module_env;
+    WASMFunctionInstanceCommon *func_test = nullptr;
+    bool ret = false;
+    const char *exception = nullptr;
+    wasm_module_inst_t module_inst = tmp_module_env.wasm_module_inst;
+
+    ret = wasm_native_register_natives("env", g_test_native_symbols,
+                                       nitems(g_test_native_symbols));
+    if (!ret)
+    {
+        EXPECT_EQ(1, 0);
+        return;
+    }
+
+    args.size = 1024;
+    shared_heap = wasm_runtime_create_shared_heap(&args);
+    if (!shared_heap) {
+        printf("Failed to create shared heap\n");
+        EXPECT_EQ(1, 0);
+    }
+
+    // test wasm
+    test_shared_heap(shared_heap, "test_addr_conv.wasm", "test", 1, argv);
+    EXPECT_EQ(1, argv[0]);
+
+    // test aot
+    test_shared_heap(shared_heap, "test_addr_conv.aot", "test", 1, argv);
+    EXPECT_EQ(1, argv[0]);
+}

tests/unit/shared-heap/wasm-apps/CMakeLists.txt

@@ -5,6 +5,7 @@ cmake_minimum_required(VERSION 3.14)
 project(wasm-apps)
 
 set(WAMR_ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../../..)
+set(WAMRC_ROOT_DIR ${WAMR_ROOT_DIR}/wamr-compiler/build)
 
 set(CMAKE_SYSTEM_PROCESSOR wasm32)
 set(CMAKE_SYSROOT ${WAMR_ROOT_DIR}/wamr-sdk/app/libc-builtin-sysroot)
@@ -37,3 +38,35 @@ add_custom_command(TARGET test.wasm POST_BUILD
         ${CMAKE_CURRENT_BINARY_DIR}/../
         COMMENT "Copy test.wasm to the same directory of google test"
         )
+
+add_custom_command(TARGET test.wasm POST_BUILD
+        COMMAND ${WAMRC_ROOT_DIR}/wamrc --opt-level=0 --enable-shared-heap --bounds-checks=1
+        -o
+        test.aot
+        test.wasm
+        COMMAND ${CMAKE_COMMAND} -E copy
+        ${CMAKE_CURRENT_BINARY_DIR}/test.aot
+        ${CMAKE_CURRENT_BINARY_DIR}/../
+        COMMENT "Copy test.aot to the same directory of google test"
+        )
+
+add_executable(test_addr_conv.wasm test_addr_conv.c)
+target_link_libraries(test.wasm)
+
+add_custom_command(TARGET test_addr_conv.wasm POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E copy
+        ${CMAKE_CURRENT_BINARY_DIR}/test_addr_conv.wasm
+        ${CMAKE_CURRENT_BINARY_DIR}/../
+        COMMENT "Copy test_addr_conv.wasm to the same directory of google test"
+        )
+
+add_custom_command(TARGET test_addr_conv.wasm POST_BUILD
+        COMMAND ${WAMRC_ROOT_DIR}/wamrc --opt-level=0 --enable-shared-heap --bounds-checks=1
+        -o
+        test_addr_conv.aot
+        test_addr_conv.wasm
+        COMMAND ${CMAKE_COMMAND} -E copy
+        ${CMAKE_CURRENT_BINARY_DIR}/test_addr_conv.aot
+        ${CMAKE_CURRENT_BINARY_DIR}/../
+        COMMENT "Copy test_addr_conv.aot to the same directory of google test"
+        )

tests/unit/shared-heap/wasm-apps/test.c

@@ -13,10 +13,22 @@ shared_heap_free(void *offset);
 int
 test()
 {
-    int *ptr = (int *)shared_heap_malloc(10);
+    int *ptr = (int *)shared_heap_malloc(4);
 
     *ptr = 10;
     int a = *ptr;
     shared_heap_free(ptr);
     return a;
 }
+
+int
+test_malloc_fail()
+{
+    int *ptr = (int *)shared_heap_malloc(8192);
+
+    if (ptr == NULL) {
+        return 1;
+    }
+    shared_heap_free(ptr);
+    return 0;
+}

tests/unit/shared-heap/wasm-apps/test_addr_conv.c

@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2024 Xiaomi Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#include <stdio.h>
+
+extern void *
+shared_heap_malloc(int size);
+extern void
+shared_heap_free(void *offset);
+extern void *
+test_addr_conv(void *ptr);
+
+int
+test()
+{
+    int *ptr = NULL;
+    int *ptr2 = NULL;
+
+    ptr = (int *)shared_heap_malloc(4);
+
+    if (ptr == NULL) {
+        return 0;
+    }
+    ptr2 = test_addr_conv(ptr);
+    if (ptr2 != ptr) {
+        return 0;
+    }
+    shared_heap_free(ptr);
+    return 1;
+}