Sync gitbook with main (#4123)

Merge branch main(f2e3348305d16cde5a45f4dda585a0caf01a0fb4) into gitbook

.github/workflows/build_llvm_libraries.yml

@@ -65,6 +65,7 @@ jobs:
         shell: bash
         run: |
           echo "last_commit=$(GH_TOKEN=${{ secrets.GITHUB_TOKEN }} /usr/bin/env python3 ./build_llvm.py ${{ inputs.extra_build_llvm_options }} --llvm-ver)" >> $GITHUB_OUTPUT
+        working-directory: build-scripts
 
       # Bump the prefix number to evict all previous caches and
       # enforce a clean build, in the unlikely case that some

.github/workflows/check_version_h.yml

@@ -0,0 +1,29 @@
+# Copyright (C) 2019 Intel Corporation.  All rights reserved.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+name: confirm version.h stay in sync
+
+on:
+  workflow_call:
+
+permissions:
+  contents: read
+
+jobs:
+  confirm_version:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: checkout
+        uses: actions/checkout@v4
+
+      - name: cmake execute to generate version.h
+        run: cmake -B build_version -S .
+
+      - name: confirm version.h
+        run: |
+          if [ -z "$(git status --porcelain | grep version.h)" ]; then
+            echo "version.h is in sync"
+          else
+            echo "version.h is not in sync"
+            exit 1
+          fi

.github/workflows/codeql.yml

@@ -53,7 +53,7 @@ jobs:
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@v3.26.13
+      uses: github/codeql-action/init@v3.28.10
       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.26.13
+      uses: github/codeql-action/analyze@v3.28.10
       with:
         category: "/language:${{matrix.language}}"
         upload: false
@@ -99,14 +99,14 @@ jobs:
         output: ${{ steps.step1.outputs.sarif-output }}/cpp.sarif
 
     - name: Upload CodeQL results to code scanning
-      uses: github/codeql-action/upload-sarif@v3.26.13
+      uses: github/codeql-action/upload-sarif@v3.28.10
       with:
         sarif_file: ${{ steps.step1.outputs.sarif-output }}
         category: "/language:${{matrix.language}}"
 
     - name: Upload CodeQL results as an artifact
       if: success() || failure()
-      uses: actions/upload-artifact@v4.4.3
+      uses: actions/upload-artifact@v4.6.1
       with:
         name: codeql-results
         path: ${{ steps.step1.outputs.sarif-output }}

.github/workflows/compilation_on_android_ubuntu.yml

@@ -74,6 +74,12 @@ permissions:
   contents: read
 
 jobs:
+  check_version_h:
+    permissions:
+      contents: read
+      actions: write
+    uses: ./.github/workflows/check_version_h.yml
+
   build_llvm_libraries_on_ubuntu_2204:
     permissions:
       contents: read
@@ -156,6 +162,7 @@ jobs:
             "-DWAMR_DISABLE_HW_BOUND_CHECK=1",
             "-DWAMR_BUILD_MEMORY64=1",
             "-DWAMR_BUILD_MULTI_MEMORY=1",
+            "-DWAMR_BUILD_SHARED=1",
           ]
         os: [ubuntu-22.04]
         platform: [android, linux]
@@ -253,6 +260,9 @@ jobs:
             platform: android
           - make_options_run_mode: $LLVM_EAGER_JIT_BUILD_OPTIONS
             platform: android
+          # android does not support WAMR_BUILD_SHARED in its CMakeLists.txt.
+          - make_options_feature: "-DWAMR_BUILD_SHARED=1"
+            platform: android
         include:
           - os: ubuntu-22.04
             llvm_cache_key: ${{ needs.build_llvm_libraries_on_ubuntu_2204.outputs.cache_key }}
@@ -671,7 +681,7 @@ jobs:
             test_option: $MEMORY64_TEST_OPTIONS
           - running_mode: "multi-tier-jit"
             test_option: $MEMORY64_TEST_OPTIONS
-          # aot, fast-interp, fast-jit, llvm-jit, multi-tier-jit don't support Multi Memory 
+          # aot, fast-interp, fast-jit, llvm-jit, multi-tier-jit don't support Multi Memory
           - running_mode: "aot"
             test_option: $MULTI_MEMORY_TEST_OPTIONS
           - running_mode: "fast-interp"
@@ -813,7 +823,7 @@ jobs:
 
       - name: install dependencies
         run: |
-          rustup target add wasm32-wasi
+          rustup target add wasm32-wasip1
           sudo apt update && sudo apt-get install -y lld ninja-build
           npm install
         working-directory: test-tools/wamr-ide/VSCode-Extension
@@ -828,7 +838,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/nightly_run.yml

@@ -142,6 +142,7 @@ jobs:
             "-DWAMR_DISABLE_HW_BOUND_CHECK=1",
             "-DWAMR_BUILD_MEMORY64=1",
             "-DWAMR_BUILD_MULTI_MEMORY=1",
+            "-DWAMR_BUILD_SHARED=1",
           ]
         os: [ubuntu-20.04]
         platform: [android, linux]

.github/workflows/spec_test_on_nuttx.yml

@@ -127,7 +127,8 @@ jobs:
         wamr_feature_option:
           # Empty option for default
           - { option: "", mode: "" }
-          - { option: "CONFIG_INTERPRETERS_WAMR_GC CONFIG_INTERPRETERS_WAMR_AOT_STACK_FRAME", mode: "-G" }
+          # need to install menhir
+          # - { option: "CONFIG_INTERPRETERS_WAMR_GC CONFIG_INTERPRETERS_WAMR_AOT_STACK_FRAME", mode: "-G" }
 
         exclude:
           # XIP is not fully supported yet on RISCV64, some relocations can not be resolved
@@ -208,7 +209,7 @@ jobs:
         if: contains(matrix.wamr_test_option.mode, 'aot')
         working-directory: apps/interpreters/wamr/wamr/wamr-compiler
         run: |
-          cmake -Bbuild .
+          cmake -B build -DWAMR_BUILD_SHRUNK_MEMORY=0 -S .
           cmake --build build
 
       # the nuttx version we use for xtensa requires esptool.py newer than
@@ -350,7 +351,7 @@ jobs:
 
       - name: upload the log
         if: always()
-        uses: actions/upload-artifact@v4.4.3
+        uses: actions/upload-artifact@v4.6.1
         with:
           name: spec-test-log-${{ github.run_id }}-${{ strategy.job-index }}-${{ matrix.target_config.target }}
           path: log

.github/workflows/supply_chain.yml

@@ -39,7 +39,7 @@ jobs:
           persist-credentials: false
 
       - name: "Run analysis"
-        uses: ossf/scorecard-action@62b2cac7ed8198b15735ed49ab1e5cf35480ba46 # v2.4.0
+        uses: ossf/scorecard-action@f49aabe0b5af0936a0987cfb85d86b75731b0186 # v2.4.1
         with:
           results_file: results.sarif
           results_format: sarif
@@ -52,7 +52,7 @@ jobs:
       # Upload the results as artifacts (optional). Commenting out will disable uploads of run results in SARIF
       # format to the repository Actions tab.
       - name: "Upload artifact"
-        uses: actions/upload-artifact@184d73b71b93c222403b2e7f1ffebe4508014249 # v3.1.0
+        uses: actions/upload-artifact@4cec3d8aa04e39d1a68397de0c4cd6fb9dce8ec1 # v3.1.0
         with:
           name: SARIF file
           path: results.sarif
@@ -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@af56b044b5d41c317aef5d19920b3183cb4fbbec # v2.2.4
+        uses: github/codeql-action/upload-sarif@ff79de67cc25c7617163ae1e4b8aa23b902fdf15 
         with:
           sarif_file: results.sarif

CMakeLists.txt

@@ -3,12 +3,16 @@
 
 cmake_minimum_required (VERSION 3.0)
 
+option(BUILD_SHARED_LIBS "Build using shared libraries" OFF)
+
 if(ESP_PLATFORM)
   include (${COMPONENT_DIR}/build-scripts/esp-idf/wamr/CMakeLists.txt)
   return()
 endif()
 
-project (iwasm)
+project (iwasm LANGUAGES C)
+
+set(CMAKE_CXX_STANDARD 17)
 
 set (CMAKE_VERBOSE_MAKEFILE OFF)
 
@@ -16,13 +20,6 @@ if (NOT DEFINED WAMR_BUILD_PLATFORM)
   string (TOLOWER ${CMAKE_HOST_SYSTEM_NAME} WAMR_BUILD_PLATFORM)
 endif ()
 
-if (NOT DEFINED WAMR_BUILD_STATIC)
-  set (WAMR_BUILD_STATIC 1)
-endif ()
-if (NOT DEFINED WAMR_BUILD_SHARED)
-  set (WAMR_BUILD_SHARED 1)
-endif ()
-
 # Reset default linker flags
 set (CMAKE_SHARED_LIBRARY_LINK_C_FLAGS "")
 set (CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS "")
@@ -113,8 +110,8 @@ if (NOT DEFINED WAMR_BUILD_SIMD)
 endif ()
 
 if (NOT DEFINED WAMR_BUILD_REF_TYPES)
-  # Disable reference types by default
-  set (WAMR_BUILD_REF_TYPES 0)
+  # Enable reference types by default
+  set (WAMR_BUILD_REF_TYPES 1)
 endif ()
 
 set (WAMR_ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR})
@@ -154,52 +151,40 @@ if (MSVC)
   add_definitions(-DCOMPILING_WASM_RUNTIME_API=1)
 endif ()
 
-# STATIC LIBRARY
-if (WAMR_BUILD_STATIC)
-    add_library(iwasm_static STATIC ${WAMR_RUNTIME_LIB_SOURCE})
-    set_target_properties (iwasm_static PROPERTIES OUTPUT_NAME vmlib)
-    target_include_directories(iwasm_static INTERFACE ${WAMR_ROOT_DIR}/core/iwasm/include)
-    target_link_libraries (iwasm_static INTERFACE ${LLVM_AVAILABLE_LIBS} ${UV_A_LIBS} -lm -ldl ${CMAKE_THREAD_LIBS_INIT})
-    if (WAMR_BUILD_WASM_CACHE EQUAL 1)
-      target_link_libraries(iwasm_static INTERFACE boringssl_crypto)
-    endif ()
+add_library (vmlib ${WAMR_RUNTIME_LIB_SOURCE})
+set_target_properties (vmlib PROPERTIES OUTPUT_NAME iwasm)
+target_include_directories(vmlib INTERFACE
+  $<BUILD_INTERFACE:${WAMR_ROOT_DIR}/core/iwasm/include>
+  $<INSTALL_INTERFACE:include/iwasm>
+)
 
-    if (MINGW)
-      target_link_libraries (iwasm_static PRIVATE ws2_32)
-    endif ()
-
-    if (WIN32)
-      target_link_libraries(iwasm_static PRIVATE ntdll)
-    endif()
+target_link_libraries (vmlib PUBLIC ${LLVM_AVAILABLE_LIBS} ${UV_A_LIBS} -lm -ldl ${CMAKE_THREAD_LIBS_INIT})
+if (WAMR_BUILD_WASM_CACHE EQUAL 1)
+  target_link_libraries(vmlib INTERFACE boringssl_crypto)
+endif ()
 
-    install (TARGETS iwasm_static ARCHIVE DESTINATION lib)
+if (MINGW)
+  target_link_libraries(vmlib INTERFACE -lWs2_32 -lwsock32)
+  target_link_libraries(vmlib PRIVATE ws2_32)
 endif ()
 
-# SHARED LIBRARY
-if (WAMR_BUILD_SHARED)
-    add_library (iwasm_shared SHARED ${WAMR_RUNTIME_LIB_SOURCE})
-    set_target_properties (iwasm_shared PROPERTIES OUTPUT_NAME iwasm)
-    target_include_directories(iwasm_shared INTERFACE ${WAMR_ROOT_DIR}/core/iwasm/include)
-    target_link_libraries (iwasm_shared INTERFACE ${LLVM_AVAILABLE_LIBS} ${UV_A_LIBS} -lm -ldl ${CMAKE_THREAD_LIBS_INIT})
-    if (WAMR_BUILD_WASM_CACHE EQUAL 1)
-      target_link_libraries(iwasm_shared INTERFACE boringssl_crypto)
-    endif ()
+if (WIN32)
+  target_link_libraries(vmlib PRIVATE ntdll)
+endif()
 
-    if (MINGW)
-      target_link_libraries(iwasm_shared INTERFACE -lWs2_32 -lwsock32)
-      target_link_libraries(iwasm_shared PRIVATE ws2_32)
-    endif ()
+set (WAMR_PUBLIC_HEADERS
+  ${WAMR_ROOT_DIR}/core/iwasm/include/wasm_c_api.h
+  ${WAMR_ROOT_DIR}/core/iwasm/include/wasm_export.h
+  ${WAMR_ROOT_DIR}/core/iwasm/include/lib_export.h
+)
+set_target_properties (vmlib PROPERTIES PUBLIC_HEADER "${WAMR_PUBLIC_HEADERS}")
 
-    if (WIN32)
-      target_link_libraries(iwasm_shared PRIVATE ntdll)
-    endif()
+set_version_info (vmlib)
 
-    install (TARGETS iwasm_shared LIBRARY DESTINATION lib)
-endif ()
+install (TARGETS vmlib
+  EXPORT iwasmTargets
+  LIBRARY DESTINATION lib
+  PUBLIC_HEADER DESTINATION include/iwasm
+)
 
-# HEADERS
-install (FILES
-    ${WAMR_ROOT_DIR}/core/iwasm/include/wasm_c_api.h
-    ${WAMR_ROOT_DIR}/core/iwasm/include/wasm_export.h
-    ${WAMR_ROOT_DIR}/core/iwasm/include/lib_export.h
-    DESTINATION include)
+install_iwasm_package ()

CODEOWNERS

@@ -22,7 +22,7 @@
 # If none of the later patterns match, assign to anyone. This team is the
 # parent of all the other teams and automatically includes everyone on those
 # teams.
-* @loganek @lum1n0us @no1wudi @wenyongh @xujuntwt95329 @yamt
+* @loganek @lum1n0us @no1wudi @TianlongLiang @wenyongh @xujuntwt95329 @yamt
 
 # Some parts of the project require more specialized knowledge. In those areas
 # we designate smaller groups who are more likely to be aware of who's working

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)
-- [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)
+- [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(FreeRTOS)](./product-mini/README.md#esp-idf)
 
 
 ## Getting started

build-scripts/build_llvm.py

@@ -102,12 +102,21 @@ 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) + '"'
-        if backends
+        '-DLLVM_TARGETS_TO_BUILD:STRING="' + ";".join(normal_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"]
+        )
+
     LLVM_PROJECTS_TO_BUILD = [
         '-DLLVM_ENABLE_PROJECTS:STRING="' + ";".join(projects) + '"' if projects else ""
     ]
@@ -202,11 +211,11 @@ def repackage_llvm_windows(llvm_dir):
     if not packs_path:
         raise Exception("Didn't find any LLVM-* package")
         return
-    
+
     llvm_package_path = f"_CPack_Packages/win64/NSIS/{packs_path[0].name}"
     windows_package_dir = build_dir.joinpath(llvm_package_path).resolve()
 
-    # mv package dir outside of build 
+    # mv package dir outside of build
     shutil.move(str(windows_package_dir), str(llvm_dir))
     # rm -r build
     shutil.rmtree(str(build_dir))
@@ -216,7 +225,7 @@ def repackage_llvm_windows(llvm_dir):
     moved_package_dir = llvm_dir.joinpath(packs_path[0].name)
     for sub_dir in moved_package_dir.iterdir():
         shutil.move(str(sub_dir), str(build_dir))
-    moved_package_dir.rmdir()  
+    moved_package_dir.rmdir()
 
 def main():
     parser = argparse.ArgumentParser(description="build necessary LLVM libraries")
@@ -240,6 +249,7 @@ def main():
             "X86",
             "Xtensa",
         ],
+        default=[],
         help="identify LLVM supported backends, separate by space, like '--arch ARM Mips X86'",
     )
     parser.add_argument(

build-scripts/config_common.cmake

@@ -131,6 +131,12 @@ else ()
   unset (LLVM_AVAILABLE_LIBS)
 endif ()
 
+# Version
+include (${WAMR_ROOT_DIR}/build-scripts/version.cmake)
+
+# Package
+include (${WAMR_ROOT_DIR}/build-scripts/package.cmake)
+
 # Sanitizers
 
 if (NOT DEFINED WAMR_BUILD_SANITIZER)
@@ -162,16 +168,68 @@ if (WAMR_BUILD_LINUX_PERF EQUAL 1)
   endif ()
 endif ()
 
+if (NOT DEFINED WAMR_BUILD_SHRUNK_MEMORY)
+  # Enable shrunk memory by default
+  set (WAMR_BUILD_SHRUNK_MEMORY 1)
+endif ()
+
+########################################
+# Default values
+########################################
+if (NOT DEFINED WAMR_BUILD_BULK_MEMORY)
+  set (WAMR_BUILD_BULK_MEMORY 1)
+endif ()
+
+if (NOT DEFINED WAMR_BUILD_EXCE_HANDLING)
+  set (WAMR_BUILD_EXCE_HANDLING 0)
+endif ()
+
+if (NOT DEFINED WAMR_BUILD_GC)
+  set (WAMR_BUILD_GC 0)
+endif ()
+
+if (NOT DEFINED WAMR_BUILD_MEMORY64)
+  set (WAMR_BUILD_MEMORY64 0)
+endif ()
+
+if (NOT DEFINED WAMR_BUILD_MULTI_MEMORY)
+  set (WAMR_BUILD_MULTI_MEMORY 0)
+endif ()
+
+if (NOT DEFINED WAMR_BUILD_SHARED_MEMORY)
+  set(WAMR_BUILD_SHARED_MEMORY 0)
+endif ()
+
+if (NOT DEFINED WAMR_BUILD_STRINGREF)
+  set(WAMR_BUILD_STRINGREF 0)
+endif ()
+
+if (NOT DEFINED WAMR_BUILD_TAIL_CALL)
+  set (WAMR_BUILD_TAIL_CALL 0)
+endif ()
+
+########################################
+# Compilation options to marco
 ########################################
 
 message ("-- Build Configurations:")
 message ("     Build as target ${WAMR_BUILD_TARGET}")
+message ("     Build for platform ${WAMR_BUILD_PLATFORM}")
 message ("     CMAKE_BUILD_TYPE " ${CMAKE_BUILD_TYPE})
+message ("     BUILD_SHARED_LIBS " ${BUILD_SHARED_LIBS})
+################## running mode ##################
 if (WAMR_BUILD_INTERP EQUAL 1)
   message ("     WAMR Interpreter enabled")
 else ()
   message ("     WAMR Interpreter disabled")
 endif ()
+if ((WAMR_BUILD_FAST_INTERP EQUAL 1) AND (WAMR_BUILD_INTERP EQUAL 1))
+  add_definitions (-DWASM_ENABLE_FAST_INTERP=1)
+  message ("     Fast interpreter enabled")
+else ()
+  add_definitions (-DWASM_ENABLE_FAST_INTERP=0)
+  message ("     Fast interpreter disabled")
+endif ()
 if (WAMR_BUILD_AOT EQUAL 1)
   message ("     WAMR AOT enabled")
 else ()
@@ -202,6 +260,16 @@ if (WAMR_BUILD_FAST_JIT EQUAL 1 AND WAMR_BUILD_JIT EQUAL 1
     AND WAMR_BUILD_LAZY_JIT EQUAL 1)
   message ("     Multi-tier JIT enabled")
 endif ()
+################## test modes ##################
+if (WAMR_BUILD_SPEC_TEST EQUAL 1)
+  add_definitions (-DWASM_ENABLE_SPEC_TEST=1)
+  message ("     spec test compatible mode is on")
+endif ()
+if (WAMR_BUILD_WASI_TEST EQUAL 1)
+  add_definitions (-DWASM_ENABLE_WASI_TEST=1)
+  message ("     wasi test compatible mode is on")
+endif ()
+################## native ##################
 if (WAMR_BUILD_LIBC_BUILTIN EQUAL 1)
   message ("     Libc builtin enabled")
 else ()
@@ -214,13 +282,25 @@ elseif (WAMR_BUILD_LIBC_WASI EQUAL 1)
 else ()
   message ("     Libc WASI disabled")
 endif ()
-if ((WAMR_BUILD_FAST_INTERP EQUAL 1) AND (WAMR_BUILD_INTERP EQUAL 1))
-  add_definitions (-DWASM_ENABLE_FAST_INTERP=1)
-  message ("     Fast interpreter enabled")
-else ()
-  add_definitions (-DWASM_ENABLE_FAST_INTERP=0)
-  message ("     Fast interpreter disabled")
+if (WAMR_BUILD_THREAD_MGR EQUAL 1)
+  message ("     Thread manager enabled")
+endif ()
+if (WAMR_BUILD_LIB_PTHREAD EQUAL 1)
+  message ("     Lib pthread enabled")
+endif ()
+if (WAMR_BUILD_LIB_PTHREAD_SEMAPHORE EQUAL 1)
+  message ("     Lib pthread semaphore enabled")
+endif ()
+if (WAMR_BUILD_LIB_WASI_THREADS EQUAL 1)
+  message ("     Lib wasi-threads enabled")
 endif ()
+if (WAMR_BUILD_LIBC_EMCC EQUAL 1)
+  message ("     Libc emcc enabled")
+endif ()
+if (WAMR_BUILD_LIB_RATS EQUAL 1)
+  message ("     Lib rats enabled")
+endif()
+################## WAMR features ##################
 if (WAMR_BUILD_MULTI_MODULE EQUAL 1)
   add_definitions (-DWASM_ENABLE_MULTI_MODULE=1)
   message ("     Multiple modules enabled")
@@ -228,24 +308,10 @@ else ()
   add_definitions (-DWASM_ENABLE_MULTI_MODULE=0)
   message ("     Multiple modules disabled")
 endif ()
-if (WAMR_BUILD_SPEC_TEST EQUAL 1)
-  add_definitions (-DWASM_ENABLE_SPEC_TEST=1)
-  message ("     spec test compatible mode is on")
-endif ()
-if (WAMR_BUILD_WASI_TEST EQUAL 1)
-  add_definitions (-DWASM_ENABLE_WASI_TEST=1)
-  message ("     wasi test compatible mode is on")
-endif ()
-if (NOT DEFINED WAMR_BUILD_BULK_MEMORY)
-  # Enable bulk memory by default
-  set (WAMR_BUILD_BULK_MEMORY 1)
-endif ()
 if (WAMR_BUILD_BULK_MEMORY EQUAL 1)
   add_definitions (-DWASM_ENABLE_BULK_MEMORY=1)
-  message ("     Bulk memory feature enabled")
 else ()
   add_definitions (-DWASM_ENABLE_BULK_MEMORY=0)
-  message ("     Bulk memory feature disabled")
 endif ()
 if (WAMR_BUILD_SHARED_MEMORY EQUAL 1)
   add_definitions (-DWASM_ENABLE_SHARED_MEMORY=1)
@@ -265,31 +331,11 @@ if (WAMR_BUILD_MEMORY64 EQUAL 1)
   endif()
   add_definitions (-DWASM_ENABLE_MEMORY64=1)
   set (WAMR_DISABLE_HW_BOUND_CHECK 1)
-  message ("     Memory64 memory enabled")
 endif ()
 if (WAMR_BUILD_MULTI_MEMORY EQUAL 1)
   add_definitions (-DWASM_ENABLE_MULTI_MEMORY=1)
-  message ("     Multi memory enabled")
   set (WAMR_BUILD_DEBUG_INTERP 0)
 endif ()
-if (WAMR_BUILD_THREAD_MGR EQUAL 1)
-  message ("     Thread manager enabled")
-endif ()
-if (WAMR_BUILD_LIB_PTHREAD EQUAL 1)
-  message ("     Lib pthread enabled")
-endif ()
-if (WAMR_BUILD_LIB_PTHREAD_SEMAPHORE EQUAL 1)
-  message ("     Lib pthread semaphore enabled")
-endif ()
-if (WAMR_BUILD_LIB_WASI_THREADS EQUAL 1)
-  message ("     Lib wasi-threads enabled")
-endif ()
-if (WAMR_BUILD_LIBC_EMCC EQUAL 1)
-  message ("     Libc emcc enabled")
-endif ()
-if (WAMR_BUILD_LIB_RATS EQUAL 1)
-  message ("     Lib rats enabled")
-endif()
 if (WAMR_BUILD_MINI_LOADER EQUAL 1)
   add_definitions (-DWASM_ENABLE_MINI_LOADER=1)
   message ("     WASM mini loader enabled")
@@ -319,7 +365,6 @@ endif ()
 if (WAMR_BUILD_SIMD EQUAL 1)
   if (NOT WAMR_BUILD_TARGET MATCHES "RISCV64.*")
     add_definitions (-DWASM_ENABLE_SIMD=1)
-    message ("     SIMD enabled")
   else ()
     message ("     SIMD disabled due to not supported on target RISCV64")
   endif ()
@@ -349,16 +394,11 @@ if (WAMR_BUILD_DUMP_CALL_STACK EQUAL 1)
 endif ()
 if (WAMR_BUILD_TAIL_CALL EQUAL 1)
   add_definitions (-DWASM_ENABLE_TAIL_CALL=1)
-  message ("     Tail call enabled")
 endif ()
 if (WAMR_BUILD_REF_TYPES EQUAL 1)
   add_definitions (-DWASM_ENABLE_REF_TYPES=1)
-  message ("     Reference types enabled")
-else ()
-  message ("     Reference types disabled")
 endif ()
 if (WAMR_BUILD_GC EQUAL 1)
-  message ("     GC enabled")
   if (WAMR_TEST_GC EQUAL 1)
     message("      GC testing enabled")
   endif()
@@ -370,7 +410,6 @@ else ()
   message ("     GC performance profiling disabled")
 endif ()
 if (WAMR_BUILD_STRINGREF EQUAL 1)
-  message ("     Stringref enabled")
   if (NOT DEFINED WAMR_STRINGREF_IMPL_SOURCE)
     message ("       Using WAMR builtin implementation for stringref")
   else ()
@@ -599,3 +638,47 @@ endif()
 if (NOT WAMR_BUILD_SANITIZER STREQUAL "")
   message ("     Sanitizer ${WAMR_BUILD_SANITIZER} enabled")
 endif ()
+if (WAMR_BUILD_SHRUNK_MEMORY EQUAL 1)
+  add_definitions (-DWASM_ENABLE_SHRUNK_MEMORY=1)
+  message ("     Shrunk memory enabled")
+else ()
+  add_definitions (-DWASM_ENABLE_SHRUNK_MEMORY=0)
+  message ("     Shrunk memory disabled")
+endif()
+if (WAMR_BUILD_AOT_VALIDATOR EQUAL 1)
+  message ("     AOT validator enabled")
+  add_definitions (-DWASM_ENABLE_AOT_VALIDATOR=1)
+endif ()
+
+########################################
+# Show Phase4 Wasm proposals status.
+########################################
+
+message (
+"-- About Wasm Proposals:\n"
+"     Always-on:\n"
+"       \"Extended Constant Expressions\"\n"
+"       \"Multi-value\"\n"
+"       \"Non-trapping float-to-int conversions\"\n"
+"       \"Sign-extension operators\"\n"
+"       \"WebAssembly C and C++ API\"\n"
+"     Configurable. 0 is OFF. 1 is ON:\n"
+"       \"Bulk Memory Operation\" via WAMR_BUILD_BULK_MEMORY: ${WAMR_BUILD_BULK_MEMORY}\n"
+"       \"Fixed-width SIMD\" via WAMR_BUILD_SIMD: ${WAMR_BUILD_SIMD}\n"
+"       \"Garbage collection\" via WAMR_BUILD_GC: ${WAMR_BUILD_GC}\n"
+"       \"Legacy Exception handling\" via WAMR_BUILD_EXCE_HANDLING: ${WAMR_BUILD_EXCE_HANDLING}\n"
+"       \"Memory64\" via WAMR_BUILD_MEMORY64: ${WAMR_BUILD_MEMORY64}\n"
+"       \"Multiple memories\" via WAMR_BUILD_MULTI_MEMORY: ${WAMR_BUILD_MULTI_MEMORY}\n"
+"       \"Reference Types\" via WAMR_BUILD_REF_TYPES: ${WAMR_BUILD_REF_TYPES}\n"
+"       \"Reference-Typed Strings\" via WAMR_BUILD_STRINGREF: ${WAMR_BUILD_STRINGREF}\n"
+"       \"Tail call\" via WAMR_BUILD_TAIL_CALL: ${WAMR_BUILD_TAIL_CALL}\n"
+"       \"Threads\" via WAMR_BUILD_SHARED_MEMORY: ${WAMR_BUILD_SHARED_MEMORY}\n"
+"       \"Typed Function References\" via WAMR_BUILD_GC: ${WAMR_BUILD_GC}\n"
+"     Unsupported (>= Phase4):\n"
+"       \"Branch Hinting\"\n"
+"       \"Custom Annotation Syntax in the Text Format\"\n"
+"       \"Exception handling\"\n"
+"       \"Import/Export of Mutable Globals\"\n"
+"       \"JS String Builtins\"\n"
+"       \"Relaxed SIMD\"\n"
+)

build-scripts/iwasmConfig.cmake.in

@@ -0,0 +1,6 @@
+# Copyright (C) 2019 Intel Corporation.  All rights reserved.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+@PACKAGE_INIT@
+
+include("${CMAKE_CURRENT_LIST_DIR}/iwasmTargets.cmake")

build-scripts/package.cmake

@@ -0,0 +1,28 @@
+# Copyright (C) 2019 Intel Corporation.  All rights reserved.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+function(install_iwasm_package)
+    install (EXPORT iwasmTargets
+        FILE iwasmTargets.cmake
+        NAMESPACE iwasm::
+        DESTINATION lib/cmake/iwasm
+    )
+
+    include (CMakePackageConfigHelpers)
+    configure_package_config_file (${CMAKE_CURRENT_FUNCTION_LIST_DIR}/iwasmConfig.cmake.in
+        "${CMAKE_CURRENT_BINARY_DIR}/iwasmConfig.cmake"
+        INSTALL_DESTINATION lib/cmake/iwasm
+    )
+
+    write_basic_package_version_file(
+        "${CMAKE_CURRENT_BINARY_DIR}/iwasmConfigVersion.cmake"
+        VERSION ${WAMR_VERSION_MAJOR}.${WAMR_VERSION_MINOR}.${WAMR_VERSION_PATCH}
+        COMPATIBILITY SameMajorVersion
+    )
+
+    install (FILES
+        "${CMAKE_CURRENT_BINARY_DIR}/iwasmConfig.cmake"
+        "${CMAKE_CURRENT_BINARY_DIR}/iwasmConfigVersion.cmake"
+        DESTINATION lib/cmake/iwasm
+    )
+endfunction()

build-scripts/version.cmake

@@ -0,0 +1,28 @@
+# Copyright (C) 2019 Intel Corporation.  All rights reserved.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+if(NOT WAMR_ROOT_DIR)
+  # if from wamr-compiler
+  set(WAMR_ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/..)
+endif()
+
+set(WAMR_VERSION_MAJOR 2)
+set(WAMR_VERSION_MINOR 2)
+set(WAMR_VERSION_PATCH 0)
+
+message("-- WAMR version: ${WAMR_VERSION_MAJOR}.${WAMR_VERSION_MINOR}.${WAMR_VERSION_PATCH}")
+
+# Configure the version header file
+configure_file(
+  ${WAMR_ROOT_DIR}/core/version.h.in
+  ${WAMR_ROOT_DIR}/core/version.h
+)
+
+# Set the library version and SOVERSION
+function(set_version_info target)
+  set_target_properties(${target}
+    PROPERTIES
+      VERSION ${WAMR_VERSION_MAJOR}.${WAMR_VERSION_MINOR}.${WAMR_VERSION_PATCH}
+      SOVERSION ${WAMR_VERSION_MAJOR}
+)
+endfunction()

core/config.h

@@ -84,7 +84,7 @@
 #endif
 
 #define AOT_MAGIC_NUMBER 0x746f6100
-#define AOT_CURRENT_VERSION 3
+#define AOT_CURRENT_VERSION 4
 
 #ifndef WASM_ENABLE_JIT
 #define WASM_ENABLE_JIT 0
@@ -698,4 +698,12 @@
 #define WASM_ENABLE_SHARED_HEAP 0
 #endif
 
+#ifndef WASM_ENABLE_SHRUNK_MEMORY
+#define WASM_ENABLE_SHRUNK_MEMORY 1
+#endif
+
+#ifndef WASM_ENABLE_AOT_VALIDATOR
+#define WASM_ENABLE_AOT_VALIDATOR 0
+#endif
+
 #endif /* end of _CONFIG_H_ */

core/iwasm/aot/aot_loader.c

@@ -10,6 +10,9 @@
 #include "../common/wasm_native.h"
 #include "../common/wasm_loader_common.h"
 #include "../compilation/aot.h"
+#if WASM_ENABLE_AOT_VALIDATOR != 0
+#include "aot_validator.h"
+#endif
 
 #if WASM_ENABLE_DEBUG_AOT != 0
 #include "debug/elf_parser.h"
@@ -304,18 +307,22 @@ loader_mmap(uint32 size, bool prot_exec, char *error_buf, uint32 error_buf_size)
 #if defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64) \
     || defined(BUILD_TARGET_RISCV64_LP64D)                       \
     || defined(BUILD_TARGET_RISCV64_LP64)
-#ifndef __APPLE__
+#if !defined(__APPLE__) && !defined(BH_PLATFORM_LINUX_SGX)
     /* The mmapped AOT data and code in 64-bit targets had better be in
        range 0 to 2G, or aot loader may fail to apply some relocations,
        e.g., R_X86_64_32/R_X86_64_32S/R_X86_64_PC32/R_RISCV_32.
        We try to mmap with MMAP_MAP_32BIT flag first, and if fails, mmap
        again without the flag. */
+    /* sgx_tprotect_rsrv_mem() and sgx_alloc_rsrv_mem() will ignore flags */
     map_flags = MMAP_MAP_32BIT;
     if ((mem = os_mmap(NULL, size, map_prot, map_flags,
                        os_get_invalid_handle()))) {
-        /* The mmapped memory must be in the first 2 Gigabytes of the
+        /* Test whether the mmapped memory in the first 2 Gigabytes of the
            process address space */
-        bh_assert((uintptr_t)mem < INT32_MAX);
+        if ((uintptr_t)mem >= INT32_MAX)
+            LOG_WARNING(
+                "Warning: loader mmap memory address is not in the first 2 "
+                "Gigabytes of the process address space.");
         return mem;
     }
 #endif
@@ -966,13 +973,29 @@ destroy_import_memories(AOTImportMemory *import_memories)
     wasm_runtime_free(import_memories);
 }
 
+/**
+ * Free memory initialization data segments.
+ *
+ * @param module the AOT module containing the data
+ * @param data_list array of memory initialization data segments to free
+ * @param count number of segments in the data_list array
+ */
+
 static void
-destroy_mem_init_data_list(AOTMemInitData **data_list, uint32 count)
+destroy_mem_init_data_list(AOTModule *module, AOTMemInitData **data_list,
+                           uint32 count)
 {
     uint32 i;
+    /* Free each memory initialization data segment */
     for (i = 0; i < count; i++)
-        if (data_list[i])
+        if (data_list[i]) {
+            /* If the module owns the binary data, free the bytes buffer */
+            if (module->is_binary_freeable && data_list[i]->bytes)
+                wasm_runtime_free(data_list[i]->bytes);
+            /* Free the data segment structure itself */
             wasm_runtime_free(data_list[i]);
+        }
+    /* Free the array of data segment pointers */
     wasm_runtime_free(data_list);
 }
 
@@ -981,6 +1004,22 @@ load_init_expr(const uint8 **p_buf, const uint8 *buf_end, AOTModule *module,
                InitializerExpression *expr, char *error_buf,
                uint32 error_buf_size);
 
+/**
+ * Load memory initialization data segments from the AOT module.
+ *
+ * This function reads memory initialization data segments from the buffer and
+ * creates AOTMemInitData structures for each segment. The data can either be
+ * cloned into new memory or referenced directly from the buffer.
+ *
+ * @param p_buf pointer to buffer containing memory init data
+ * @param buf_end end of buffer
+ * @param module the AOT module being loaded
+ * @param error_buf buffer for error messages
+ * @param error_buf_size size of error buffer
+ *
+ * @return true if successful, false if error occurred
+ */
+
 static bool
 load_mem_init_data_list(const uint8 **p_buf, const uint8 *buf_end,
                         AOTModule *module, char *error_buf,
@@ -1012,8 +1051,8 @@ load_mem_init_data_list(const uint8 **p_buf, const uint8 *buf_end,
             return false;
         }
         read_uint32(buf, buf_end, byte_count);
-        size = offsetof(AOTMemInitData, bytes) + (uint64)byte_count;
-        if (!(data_list[i] = loader_malloc(size, error_buf, error_buf_size))) {
+        if (!(data_list[i] = loader_malloc(sizeof(AOTMemInitData), error_buf,
+                                           error_buf_size))) {
             return false;
         }
 
@@ -1025,8 +1064,22 @@ load_mem_init_data_list(const uint8 **p_buf, const uint8 *buf_end,
         data_list[i]->offset.init_expr_type = init_value.init_expr_type;
         data_list[i]->offset.u = init_value.u;
         data_list[i]->byte_count = byte_count;
-        read_byte_array(buf, buf_end, data_list[i]->bytes,
-                        data_list[i]->byte_count);
+        data_list[i]->bytes = NULL;
+        /* If the module owns the binary data, clone the bytes buffer */
+        if (module->is_binary_freeable) {
+            if (byte_count > 0) {
+                if (!(data_list[i]->bytes = loader_malloc(byte_count, error_buf,
+                                                          error_buf_size))) {
+                    return false;
+                }
+                read_byte_array(buf, buf_end, data_list[i]->bytes,
+                                data_list[i]->byte_count);
+            }
+        }
+        else {
+            data_list[i]->bytes = (uint8 *)buf;
+            buf += byte_count;
+        }
     }
 
     *p_buf = buf;
@@ -1035,6 +1088,21 @@ fail:
     return false;
 }
 
+/**
+ * Load memory information from the AOT module.
+ *
+ * This function reads memory-related data including import memory count,
+ * memory count, memory flags, page sizes, and memory initialization data.
+ *
+ * @param p_buf pointer to buffer containing memory info
+ * @param buf_end end of buffer
+ * @param module the AOT module being loaded
+ * @param error_buf buffer for error messages
+ * @param error_buf_size size of error buffer
+ *
+ * @return true if successful, false if error occurred
+ */
+
 static bool
 load_memory_info(const uint8 **p_buf, const uint8 *buf_end, AOTModule *module,
                  char *error_buf, uint32 error_buf_size)
@@ -1044,9 +1112,6 @@ load_memory_info(const uint8 **p_buf, const uint8 *buf_end, AOTModule *module,
     const uint8 *buf = *p_buf;
 
     read_uint32(buf, buf_end, module->import_memory_count);
-    /* We don't support import_memory_count > 0 currently */
-    if (module->import_memory_count > 0)
-        return false;
 
     read_uint32(buf, buf_end, module->memory_count);
     total_size = sizeof(AOTMemory) * (uint64)module->memory_count;
@@ -1189,6 +1254,7 @@ load_init_expr(const uint8 **p_buf, const uint8 *buf_end, AOTModule *module,
             }
             free_if_fail = true;
             init_values->count = field_count;
+            init_values->type_idx = type_idx;
             expr->u.data = init_values;
 
             if (type_idx >= module->type_count) {
@@ -1332,7 +1398,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
@@ -1392,7 +1463,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
@@ -1480,7 +1556,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;
         }
 
@@ -4235,6 +4311,16 @@ fail:
     return false;
 }
 
+static bool
+aot_compatible_version(uint32 version)
+{
+    /*
+     * refer to "AoT-compiled module compatibility among WAMR versions" in
+     * ./doc/biuld_wasm_app.md
+     */
+    return version == 4 || version == 3;
+}
+
 static bool
 load(const uint8 *buf, uint32 size, AOTModule *module,
      bool wasm_binary_freeable, bool no_resolve, char *error_buf,
@@ -4253,7 +4339,7 @@ load(const uint8 *buf, uint32 size, AOTModule *module,
     }
 
     read_uint32(p, p_end, version);
-    if (version != AOT_CURRENT_VERSION) {
+    if (!aot_compatible_version(version)) {
         set_error_buf(error_buf, error_buf_size, "unknown binary version");
         return false;
     }
@@ -4321,6 +4407,13 @@ aot_load_from_aot_file(const uint8 *buf, uint32 size, const LoadArgs *args,
     os_thread_jit_write_protect_np(true); /* Make memory executable */
     os_icache_flush(module->code, module->code_size);
 
+#if WASM_ENABLE_AOT_VALIDATOR != 0
+    if (!aot_module_validate(module, error_buf, error_buf_size)) {
+        aot_unload(module);
+        return NULL;
+    }
+#endif /* WASM_ENABLE_AOT_VALIDATOR != 0 */
+
     LOG_VERBOSE("Load module success.\n");
     return module;
 }
@@ -4335,7 +4428,7 @@ aot_unload(AOTModule *module)
         wasm_runtime_free(module->memories);
 
     if (module->mem_init_data_list)
-        destroy_mem_init_data_list(module->mem_init_data_list,
+        destroy_mem_init_data_list(module, module->mem_init_data_list,
                                    module->mem_init_data_count);
 
     if (module->native_symbol_list)

core/iwasm/aot/aot_perf_map.c

@@ -7,7 +7,6 @@
 #include "bh_log.h"
 #include "bh_platform.h"
 
-#if WASM_ENABLE_LINUX_PERF != 0
 struct func_info {
     uint32 idx;
     void *ptr;
@@ -117,4 +116,3 @@ quit:
 
     return ret;
 }
-#endif /* WASM_ENABLE_LINUX_PERF != 0 */

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
         }
 
@@ -1096,11 +1099,11 @@ aot_get_default_memory(AOTModuleInstance *module_inst)
 }
 
 AOTMemoryInstance *
-aot_get_memory_with_index(AOTModuleInstance *module_inst, uint32 index)
+aot_get_memory_with_idx(AOTModuleInstance *module_inst, uint32 mem_idx)
 {
-    if ((index >= module_inst->memory_count) || !module_inst->memories)
+    if ((mem_idx >= module_inst->memory_count) || !module_inst->memories)
         return NULL;
-    return module_inst->memories[index];
+    return module_inst->memories[mem_idx];
 }
 
 static bool
@@ -1282,21 +1285,78 @@ init_func_ptrs(AOTModuleInstance *module_inst, AOTModule *module,
     return true;
 }
 
+static int
+cmp_export_func_map(const void *a, const void *b)
+{
+    uint32 func_idx1 = ((const ExportFuncMap *)a)->func_idx;
+    uint32 func_idx2 = ((const ExportFuncMap *)b)->func_idx;
+    return func_idx1 < func_idx2 ? -1 : (func_idx1 > func_idx2 ? 1 : 0);
+}
+
 AOTFunctionInstance *
-aot_get_function_instance(AOTModuleInstance *module_inst, uint32 func_idx)
+aot_lookup_function_with_idx(AOTModuleInstance *module_inst, uint32 func_idx)
 {
-    AOTModule *module = (AOTModule *)module_inst->module;
     AOTModuleInstanceExtra *extra = (AOTModuleInstanceExtra *)module_inst->e;
     AOTFunctionInstance *export_funcs =
         (AOTFunctionInstance *)module_inst->export_functions;
+    AOTFunctionInstance *func_inst = NULL;
+    ExportFuncMap *export_func_maps, *export_func_map, key;
+    uint64 size;
     uint32 i;
 
-    /* export functions are pre-instantiated */
-    for (i = 0; i < module_inst->export_func_count; i++) {
-        if (export_funcs[i].func_index == func_idx)
-            return &export_funcs[i];
+    if (module_inst->export_func_count == 0)
+        return NULL;
+
+    exception_lock(module_inst);
+
+    /* create the func_idx to export_idx maps if it hasn't been created */
+    if (!extra->export_func_maps) {
+        size = sizeof(ExportFuncMap) * (uint64)module_inst->export_func_count;
+        if (!(export_func_maps = extra->export_func_maps =
+                  runtime_malloc(size, NULL, 0))) {
+            /* allocate memory failed, lookup the export function one by one */
+            for (i = 0; i < module_inst->export_func_count; i++) {
+                if (export_funcs[i].func_index == func_idx) {
+                    func_inst = &export_funcs[i];
+                    break;
+                }
+            }
+            goto unlock_and_return;
+        }
+
+        for (i = 0; i < module_inst->export_func_count; i++) {
+            export_func_maps[i].func_idx = export_funcs[i].func_index;
+            export_func_maps[i].export_idx = i;
+        }
+
+        qsort(export_func_maps, module_inst->export_func_count,
+              sizeof(ExportFuncMap), cmp_export_func_map);
     }
 
+    /* lookup the map to get the export_idx of the func_idx */
+    key.func_idx = func_idx;
+    export_func_map =
+        bsearch(&key, extra->export_func_maps, module_inst->export_func_count,
+                sizeof(ExportFuncMap), cmp_export_func_map);
+    if (export_func_map)
+        func_inst = &export_funcs[export_func_map->export_idx];
+
+unlock_and_return:
+    exception_unlock(module_inst);
+    return func_inst;
+}
+
+AOTFunctionInstance *
+aot_get_function_instance(AOTModuleInstance *module_inst, uint32 func_idx)
+{
+    AOTModule *module = (AOTModule *)module_inst->module;
+    AOTModuleInstanceExtra *extra = (AOTModuleInstanceExtra *)module_inst->e;
+    AOTFunctionInstance *func_inst;
+
+    /* lookup from export functions first */
+    if ((func_inst = aot_lookup_function_with_idx(module_inst, func_idx)))
+        return func_inst;
+
     exception_lock(module_inst);
 
     /* allocate functions array if needed */
@@ -1728,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;
@@ -1848,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);
         }
     }
@@ -1944,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) {
@@ -2168,6 +2234,9 @@ aot_deinstantiate(AOTModuleInstance *module_inst, bool is_sub_inst)
     if (module_inst->export_functions)
         wasm_runtime_free(module_inst->export_functions);
 
+    if (extra->export_func_maps)
+        wasm_runtime_free(extra->export_func_maps);
+
 #if WASM_ENABLE_MULTI_MEMORY != 0
     if (module_inst->export_memories)
         wasm_runtime_free(module_inst->export_memories);
@@ -2561,7 +2630,7 @@ aot_call_function(WASMExecEnv *exec_env, AOTFunctionInstance *function,
         ret = invoke_native_internal(exec_env, func_ptr, func_type, NULL,
                                      attachment, argv, argc, argv);
 
-        if (aot_copy_exception(module_inst, NULL)) {
+        if (!ret) {
 #ifdef AOT_STACK_FRAME_DEBUG
             if (aot_stack_frame_callback) {
                 aot_stack_frame_callback(exec_env);
@@ -2582,7 +2651,7 @@ aot_call_function(WASMExecEnv *exec_env, AOTFunctionInstance *function,
             aot_free_frame(exec_env);
 #endif
 
-        return ret && !aot_copy_exception(module_inst, NULL) ? true : false;
+        return ret;
     }
 }
 

core/iwasm/aot/aot_runtime.h

@@ -109,6 +109,13 @@ typedef struct AOTFunctionInstance {
     } u;
 } AOTFunctionInstance;
 
+/* Map of a function index to the element ith in
+   the export functions array */
+typedef struct ExportFuncMap {
+    uint32 func_idx;
+    uint32 export_idx;
+} ExportFuncMap;
+
 typedef struct AOTModuleInstanceExtra {
     DefPointer(const uint32 *, stack_sizes);
     /*
@@ -120,6 +127,13 @@ typedef struct AOTModuleInstanceExtra {
     MemBound shared_heap_start_off;
 
     WASMModuleInstanceExtraCommon common;
+
+    /**
+     * maps of func indexes to export func indexes, which
+     * is sorted by func index for a quick lookup and is
+     * created only when first time used.
+     */
+    ExportFuncMap *export_func_maps;
     AOTFunctionInstance **functions;
     uint32 function_count;
 #if WASM_ENABLE_MULTI_MODULE != 0
@@ -556,6 +570,13 @@ aot_deinstantiate(AOTModuleInstance *module_inst, bool is_sub_inst);
 AOTFunctionInstance *
 aot_lookup_function(const AOTModuleInstance *module_inst, const char *name);
 
+/**
+ * Lookup an exported function in the AOT module instance with
+ * the function index.
+ */
+AOTFunctionInstance *
+aot_lookup_function_with_idx(AOTModuleInstance *module_inst, uint32 func_idx);
+
 AOTMemoryInstance *
 aot_lookup_memory(AOTModuleInstance *module_inst, char const *name);
 
@@ -563,7 +584,7 @@ AOTMemoryInstance *
 aot_get_default_memory(AOTModuleInstance *module_inst);
 
 AOTMemoryInstance *
-aot_get_memory_with_index(AOTModuleInstance *module_inst, uint32 index);
+aot_get_memory_with_idx(AOTModuleInstance *module_inst, uint32 mem_idx);
 
 /**
  * Get a function in the AOT module instance.
@@ -574,7 +595,7 @@ aot_get_memory_with_index(AOTModuleInstance *module_inst, uint32 index);
  * @return the function instance found
  */
 AOTFunctionInstance *
-aot_get_function_instance(AOTModuleInstance *module_inst, uint32_t func_idx);
+aot_get_function_instance(AOTModuleInstance *module_inst, uint32 func_idx);
 
 /**
  * Call the given AOT function of a AOT module instance with

core/iwasm/aot/aot_validator.c

@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2025 Intel Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#include "aot_validator.h"
+
+static void
+set_error_buf(char *error_buf, uint32 error_buf_size, const char *string)
+{
+    if (error_buf != NULL) {
+        snprintf(error_buf, error_buf_size,
+                 "AOT module load failed: from validator. %s", string);
+    }
+}
+
+static bool
+aot_memory_info_validate(const AOTModule *module, char *error_buf,
+                         uint32 error_buf_size)
+{
+    if (module->import_memory_count > 0) {
+        set_error_buf(error_buf, error_buf_size,
+                      "import memory is not supported");
+        return false;
+    }
+
+    if (module->memory_count < 1) {
+        set_error_buf(error_buf, error_buf_size,
+                      "there should be >=1 memory in one aot module");
+        return false;
+    }
+
+    return true;
+}
+
+bool
+aot_module_validate(const AOTModule *module, char *error_buf,
+                    uint32 error_buf_size)
+{
+    if (!aot_memory_info_validate(module, error_buf, error_buf_size)) {
+        return false;
+    }
+
+    return true;
+}

core/iwasm/aot/aot_validator.h

@@ -0,0 +1,15 @@
+/*
+ * Copyright (C) 2025 Intel Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#ifndef _AOT_VALIDATOR_H_
+#define _AOT_VALIDATOR_H_
+
+#include "aot_runtime.h"
+
+bool
+aot_module_validate(const AOTModule *module, char *error_buf,
+                    uint32 error_buf_size);
+
+#endif /* _AOT_VALIDATOR_H_ */

core/iwasm/aot/iwasm_aot.cmake

@@ -7,7 +7,19 @@ add_definitions (-DWASM_ENABLE_AOT=1)
 
 include_directories (${IWASM_AOT_DIR})
 
-file (GLOB c_source_all ${IWASM_AOT_DIR}/*.c)
+list (APPEND c_source_all
+  ${IWASM_AOT_DIR}/aot_intrinsic.c
+  ${IWASM_AOT_DIR}/aot_loader.c
+  ${IWASM_AOT_DIR}/aot_runtime.c
+)
+
+if (WAMR_BUILD_LINUX_PERF EQUAL 1)
+  list (APPEND c_source_all ${IWASM_AOT_DIR}/aot_perf_map.c)
+endif ()
+
+if (WAMR_BUILD_AOT_VALIDATOR EQUAL 1)
+  list (APPEND c_source_all ${IWASM_AOT_DIR}/aot_validator.c)
+endif ()
 
 if (WAMR_BUILD_TARGET STREQUAL "X86_64" OR WAMR_BUILD_TARGET STREQUAL "AMD_64")
   set (arch_source ${IWASM_AOT_DIR}/arch/aot_reloc_x86_64.c)

core/iwasm/common/SConscript

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

core/iwasm/common/gc/gc_type.c

@@ -1145,6 +1145,14 @@ wasm_reftype_is_subtype_of(uint8 type1, const WASMRefType *ref_type1,
                 return true;
             else {
                 int32 heap_type = ref_type1->ref_ht_common.heap_type;
+                // We dont care whether type2 is nullable or not. So
+                // we normalize it into its related one-byte type.
+                if (type2 == REF_TYPE_HT_NULLABLE
+                    || type2 == REF_TYPE_HT_NON_NULLABLE) {
+                    bh_assert(ref_type2);
+                    type2 = (uint8)(ref_type2->ref_ht_common.heap_type
+                                    + REF_TYPE_FUNCREF - HEAP_TYPE_FUNC);
+                }
                 if (heap_type == HEAP_TYPE_ANY) {
                     /* (ref any) <: anyref */
                     return type2 == REF_TYPE_ANYREF ? true : false;
@@ -1188,19 +1196,15 @@ wasm_reftype_is_subtype_of(uint8 type1, const WASMRefType *ref_type1,
                 }
 #endif
                 else if (heap_type == HEAP_TYPE_NONE) {
-                    /* (ref none) */
-                    /* TODO */
-                    bh_assert(0);
+                    return wasm_is_reftype_supers_of_none(type2, NULL, types,
+                                                          type_count);
                 }
                 else if (heap_type == HEAP_TYPE_NOEXTERN) {
-                    /* (ref noextern) */
-                    /* TODO */
-                    bh_assert(0);
+                    return wasm_is_reftype_supers_of_noextern(type2);
                 }
                 else if (heap_type == HEAP_TYPE_NOFUNC) {
-                    /* (ref nofunc) */
-                    /* TODO */
-                    bh_assert(0);
+                    return wasm_is_reftype_supers_of_nofunc(type2, NULL, types,
+                                                            type_count);
                 }
                 else {
                     bh_assert(0);

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;
@@ -3383,21 +3384,8 @@ wasm_func_call(const wasm_func_t *func, const wasm_val_vec_t *params,
         if (!(func_comm_rt = func->func_comm_rt)) {
             AOTModuleInstance *inst_aot =
                 (AOTModuleInstance *)func->inst_comm_rt;
-            AOTModule *module_aot = (AOTModule *)inst_aot->module;
-            uint32 export_i = 0, export_func_j = 0;
-
-            for (; export_i < module_aot->export_count; ++export_i) {
-                AOTExport *export = module_aot->exports + export_i;
-                if (export->kind == EXPORT_KIND_FUNC) {
-                    if (export->index == func->func_idx_rt) {
-                        func_comm_rt =
-                            aot_lookup_function(inst_aot, export->name);
-                        ((wasm_func_t *)func)->func_comm_rt = func_comm_rt;
-                        break;
-                    }
-                    export_func_j++;
-                }
-            }
+            func_comm_rt = ((wasm_func_t *)func)->func_comm_rt =
+                aot_lookup_function_with_idx(inst_aot, func->func_idx_rt);
         }
 #endif
     }
@@ -3454,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_memory.c

@@ -420,13 +420,31 @@ is_native_addr_in_shared_heap(WASMModuleInstanceCommon *module_inst,
                               uint8 *addr, uint32 bytes)
 {
     WASMSharedHeap *heap = get_shared_heap(module_inst);
+    uintptr_t base_addr;
+    uintptr_t addr_int;
+    uintptr_t end_addr;
 
-    if (heap && addr >= heap->base_addr
-        && addr + bytes <= heap->base_addr + heap->size
-        && addr + bytes > addr) {
-        return true;
+    if (!heap) {
+        return false;
     }
-    return false;
+
+    base_addr = (uintptr_t)heap->base_addr;
+    addr_int = (uintptr_t)addr;
+    if (addr_int < base_addr) {
+        return false;
+    }
+
+    end_addr = addr_int + bytes;
+    /* Check for overflow */
+    if (end_addr <= addr_int) {
+        return false;
+    }
+
+    if (end_addr > base_addr + heap->size) {
+        return false;
+    }
+
+    return true;
 }
 
 uint64
@@ -1235,6 +1253,14 @@ wasm_mremap_linear_memory(void *mapped_mem, uint64 old_size, uint64 new_size,
     bh_assert(new_size > 0);
     bh_assert(new_size > old_size);
 
+#if UINTPTR_MAX == UINT32_MAX
+    if (new_size == 4 * (uint64)BH_GB) {
+        LOG_WARNING("On 32 bit platform, linear memory can't reach maximum "
+                    "size of 4GB\n");
+        return NULL;
+    }
+#endif
+
     if (mapped_mem) {
         new_mem = os_mremap(mapped_mem, old_size, new_size);
     }
@@ -1349,7 +1375,7 @@ wasm_enlarge_memory_internal(WASMModuleInstanceCommon *module,
     if (!(memory_data_new =
               realloc_func(Alloc_For_LinearMemory, full_size_mmaped,
 #if WASM_MEM_ALLOC_WITH_USER_DATA != 0
-                           NULL,
+                           allocator_user_data,
 #endif
                            memory_data_old, total_size_new))) {
         ret = false;
@@ -1371,7 +1397,7 @@ wasm_enlarge_memory_internal(WASMModuleInstanceCommon *module,
     if (full_size_mmaped) {
 #ifdef BH_PLATFORM_WINDOWS
         if (!os_mem_commit(memory->memory_data_end,
-                           (mem_offset_t)(total_size_new - total_size_old),
+                           total_size_new - total_size_old,
                            MMAP_PROT_READ | MMAP_PROT_WRITE)) {
             ret = false;
             goto return_func;
@@ -1379,12 +1405,12 @@ wasm_enlarge_memory_internal(WASMModuleInstanceCommon *module,
 #endif
 
         if (os_mprotect(memory->memory_data_end,
-                        (mem_offset_t)(total_size_new - total_size_old),
+                        total_size_new - total_size_old,
                         MMAP_PROT_READ | MMAP_PROT_WRITE)
             != 0) {
 #ifdef BH_PLATFORM_WINDOWS
             os_mem_decommit(memory->memory_data_end,
-                            (mem_offset_t)(total_size_new - total_size_old));
+                            total_size_new - total_size_old);
 #endif
             ret = false;
             goto return_func;
@@ -1579,8 +1605,7 @@ wasm_runtime_get_memory(WASMModuleInstanceCommon *module_inst, uint32 index)
 
 #if WASM_ENABLE_AOT != 0
     if (module_inst->module_type == Wasm_Module_AoT)
-        return aot_get_memory_with_index((AOTModuleInstance *)module_inst,
-                                         index);
+        return aot_get_memory_with_idx((AOTModuleInstance *)module_inst, index);
 #endif
 
     return NULL;
@@ -1663,7 +1688,7 @@ wasm_deallocate_linear_memory(WASMMemoryInstance *memory_inst)
     (void)map_size;
     free_func(Alloc_For_LinearMemory,
 #if WASM_MEM_ALLOC_WITH_USER_DATA != 0
-              NULL,
+              allocator_user_data,
 #endif
               memory_inst->memory_data);
 #else
@@ -1716,7 +1741,7 @@ wasm_allocate_linear_memory(uint8 **data, bool is_shared_memory,
         (void)wasm_mmap_linear_memory;
         if (!(*data = malloc_func(Alloc_For_LinearMemory,
 #if WASM_MEM_ALLOC_WITH_USER_DATA != 0
-                                  NULL,
+                                  allocator_user_data,
 #endif
                                   *memory_data_size))) {
             return BHT_ERROR;

core/iwasm/common/wasm_runtime_common.c

@@ -3014,9 +3014,9 @@ static const char *exception_msgs[] = {
     "wasm operand stack overflow",    /* EXCE_OPERAND_STACK_OVERFLOW */
     "failed to compile fast jit function", /* EXCE_FAILED_TO_COMPILE_FAST_JIT_FUNC */
     /* GC related exceptions */
-    "null function object",           /* EXCE_NULL_FUNC_OBJ */
-    "null structure object",          /* EXCE_NULL_STRUCT_OBJ */
-    "null array reference",              /* EXCE_NULL_ARRAY_OBJ */
+    "null function reference",        /* EXCE_NULL_FUNC_OBJ */
+    "null structure reference",       /* EXCE_NULL_STRUCT_OBJ */
+    "null array reference",           /* EXCE_NULL_ARRAY_OBJ */
     "null i31 reference",             /* EXCE_NULL_I31_OBJ */
     "null reference",                 /* EXCE_NULL_REFERENCE */
     "create rtt type failed",         /* EXCE_FAILED_TO_CREATE_RTT_TYPE */
@@ -3024,7 +3024,7 @@ static const char *exception_msgs[] = {
     "create array object failed",     /* EXCE_FAILED_TO_CREATE_ARRAY_OBJ */
     "create externref object failed", /* EXCE_FAILED_TO_CREATE_EXTERNREF_OBJ */
     "cast failure",                   /* EXCE_CAST_FAILURE */
-    "out of bounds array access",      /* EXCE_ARRAY_IDX_OOB */
+    "out of bounds array access",     /* EXCE_ARRAY_IDX_OOB */
     /* stringref related exceptions */
     "create string object failed",    /* EXCE_FAILED_TO_CREATE_STRING */
     "create stringref failed",        /* EXCE_FAILED_TO_CREATE_STRINGREF */
@@ -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)
@@ -4260,31 +4266,68 @@ wasm_runtime_get_export_type(WASMModuleCommon *const module, int32 export_index,
         export_type->kind = aot_export->kind;
         switch (export_type->kind) {
             case WASM_IMPORT_EXPORT_KIND_FUNC:
-                export_type->u.func_type =
-                    (AOTFuncType *)aot_module
-                        ->types[aot_module->func_type_indexes
-                                    [aot_export->index
-                                     - aot_module->import_func_count]];
+            {
+                if (aot_export->index < aot_module->import_func_count) {
+                    export_type->u.func_type =
+                        (AOTFuncType *)aot_module
+                            ->import_funcs[aot_export->index]
+                            .func_type;
+                }
+                else {
+                    export_type->u.func_type =
+                        (AOTFuncType *)aot_module
+                            ->types[aot_module->func_type_indexes
+                                        [aot_export->index
+                                         - aot_module->import_func_count]];
+                }
                 break;
+            }
             case WASM_IMPORT_EXPORT_KIND_GLOBAL:
-                export_type->u.global_type =
-                    &aot_module
-                         ->globals[aot_export->index
-                                   - aot_module->import_global_count]
-                         .type;
+            {
+                if (aot_export->index < aot_module->import_global_count) {
+                    export_type->u.global_type =
+                        &aot_module->import_globals[aot_export->index].type;
+                }
+                else {
+                    export_type->u.global_type =
+                        &aot_module
+                             ->globals[aot_export->index
+                                       - aot_module->import_global_count]
+                             .type;
+                }
                 break;
+            }
             case WASM_IMPORT_EXPORT_KIND_TABLE:
-                export_type->u.table_type =
-                    &aot_module
-                         ->tables[aot_export->index
-                                  - aot_module->import_table_count]
-                         .table_type;
+            {
+                if (aot_export->index < aot_module->import_table_count) {
+                    export_type->u.table_type =
+                        &aot_module->import_tables[aot_export->index]
+                             .table_type;
+                }
+                else {
+                    export_type->u.table_type =
+                        &aot_module
+                             ->tables[aot_export->index
+                                      - aot_module->import_table_count]
+                             .table_type;
+                }
                 break;
+            }
             case WASM_IMPORT_EXPORT_KIND_MEMORY:
-                export_type->u.memory_type =
-                    &aot_module->memories[aot_export->index
-                                          - aot_module->import_memory_count];
+            {
+                if (aot_export->index < aot_module->import_memory_count) {
+                    export_type->u.memory_type =
+                        &aot_module->import_memories[aot_export->index]
+                             .mem_type;
+                }
+                else {
+                    export_type->u.memory_type =
+                        &aot_module
+                             ->memories[aot_export->index
+                                        - aot_module->import_memory_count];
+                }
                 break;
+            }
             default:
                 bh_assert(0);
                 break;
@@ -4306,31 +4349,76 @@ wasm_runtime_get_export_type(WASMModuleCommon *const module, int32 export_index,
         export_type->kind = wasm_export->kind;
         switch (export_type->kind) {
             case WASM_IMPORT_EXPORT_KIND_FUNC:
-                export_type->u.func_type =
-                    wasm_module
-                        ->functions[wasm_export->index
-                                    - wasm_module->import_function_count]
-                        ->func_type;
+            {
+                if (wasm_export->index < wasm_module->import_function_count) {
+                    export_type->u.func_type =
+                        (WASMFuncType *)wasm_module
+                            ->import_functions[wasm_export->index]
+                            .u.function.func_type;
+                }
+                else {
+                    export_type->u.func_type =
+                        wasm_module
+                            ->functions[wasm_export->index
+                                        - wasm_module->import_function_count]
+                            ->func_type;
+                }
+
                 break;
+            }
             case WASM_IMPORT_EXPORT_KIND_GLOBAL:
-                export_type->u.global_type =
-                    &wasm_module
-                         ->globals[wasm_export->index
-                                   - wasm_module->import_global_count]
-                         .type;
+            {
+                if (wasm_export->index < wasm_module->import_global_count) {
+                    export_type->u.global_type =
+                        (WASMGlobalType *)&wasm_module
+                            ->import_globals[wasm_export->index]
+                            .u.global.type;
+                }
+                else {
+                    export_type->u.global_type =
+                        &wasm_module
+                             ->globals[wasm_export->index
+                                       - wasm_module->import_global_count]
+                             .type;
+                }
+
                 break;
+            }
             case WASM_IMPORT_EXPORT_KIND_TABLE:
-                export_type->u.table_type =
-                    &wasm_module
-                         ->tables[wasm_export->index
-                                  - wasm_module->import_table_count]
-                         .table_type;
+            {
+                if (wasm_export->index < wasm_module->import_table_count) {
+                    export_type->u.table_type =
+                        (WASMTableType *)&wasm_module
+                            ->import_tables[wasm_export->index]
+                            .u.table.table_type;
+                }
+                else {
+                    export_type->u.table_type =
+                        &wasm_module
+                             ->tables[wasm_export->index
+                                      - wasm_module->import_table_count]
+                             .table_type;
+                }
+
                 break;
+            }
             case WASM_IMPORT_EXPORT_KIND_MEMORY:
-                export_type->u.memory_type =
-                    &wasm_module->memories[wasm_export->index
-                                           - wasm_module->import_memory_count];
+            {
+                if (wasm_export->index < wasm_module->import_memory_count) {
+                    export_type->u.memory_type =
+                        (WASMMemoryType *)&wasm_module
+                            ->import_memories[wasm_export->index]
+                            .u.memory.mem_type;
+                }
+                else {
+                    export_type->u.memory_type =
+                        &wasm_module
+                             ->memories[wasm_export->index
+                                        - wasm_module->import_memory_count];
+                }
+
                 break;
+            }
             default:
                 bh_assert(0);
                 break;
@@ -4370,8 +4458,9 @@ wasm_func_type_get_param_valkind(WASMFuncType *const func_type,
             return WASM_V128;
         case VALUE_TYPE_FUNCREF:
             return WASM_FUNCREF;
-
         case VALUE_TYPE_EXTERNREF:
+            return WASM_EXTERNREF;
+
         case VALUE_TYPE_VOID:
         default:
         {

core/iwasm/compilation/aot.c

@@ -36,8 +36,11 @@ aot_destroy_mem_init_data_list(AOTMemInitData **data_list, uint32 count)
 {
     uint32 i;
     for (i = 0; i < count; i++)
-        if (data_list[i])
+        if (data_list[i]) {
+            if (data_list[i]->bytes)
+                wasm_runtime_free(data_list[i]->bytes);
             wasm_runtime_free(data_list[i]);
+        }
     wasm_runtime_free(data_list);
 }
 
@@ -60,8 +63,7 @@ aot_create_mem_init_data_list(const WASMModule *module)
 
     /* Create each memory data segment */
     for (i = 0; i < module->data_seg_count; i++) {
-        size = offsetof(AOTMemInitData, bytes)
-               + (uint64)module->data_segments[i]->data_length;
+        size = sizeof(AOTMemInitData);
         if (size >= UINT32_MAX
             || !(data_list[i] = wasm_runtime_malloc((uint32)size))) {
             aot_set_last_error("allocate memory failed.");
@@ -69,18 +71,31 @@ aot_create_mem_init_data_list(const WASMModule *module)
         }
 
 #if WASM_ENABLE_BULK_MEMORY != 0
+        /* Set bulk memory specific properties if enabled */
         data_list[i]->is_passive = module->data_segments[i]->is_passive;
         data_list[i]->memory_index = module->data_segments[i]->memory_index;
 #endif
         data_list[i]->offset = module->data_segments[i]->base_offset;
         data_list[i]->byte_count = module->data_segments[i]->data_length;
-        memcpy(data_list[i]->bytes, module->data_segments[i]->data,
-               module->data_segments[i]->data_length);
+        data_list[i]->bytes = NULL;
+        /* Allocate memory for AOT compiler is OK, because the data segment
+         * is small and the host memory is enough */
+        if (data_list[i]->byte_count > 0) {
+            data_list[i]->bytes = wasm_runtime_malloc(data_list[i]->byte_count);
+            if (!data_list[i]->bytes) {
+                aot_set_last_error("allocate memory failed.");
+                goto fail;
+            }
+            /* Copy the actual data bytes from the WASM module */
+            memcpy(data_list[i]->bytes, module->data_segments[i]->data,
+                   module->data_segments[i]->data_length);
+        }
     }
 
     return data_list;
 
 fail:
+    /* Clean up allocated memory in case of failure */
     aot_destroy_mem_init_data_list(data_list, module->data_seg_count);
     return NULL;
 }
@@ -487,60 +502,70 @@ calculate_struct_field_sizes_offsets(AOTCompData *comp_data, bool is_target_x86,
 }
 #endif
 
-AOTCompData *
-aot_create_comp_data(WASMModule *module, const char *target_arch,
-                     bool gc_enabled)
+/**
+ * Checks if target architecture is 64-bit based on target_arch string.
+ *
+ * @param target_arch The target architecture string (e.g. "x86_64", "aarch64")
+ * @return true if target is 64-bit architecture, false otherwise
+ *
+ * If target_arch is NULL, detection is based on UINTPTR_MAX.
+ * Otherwise looks for "64" in target_arch string.
+ */
+static bool
+arch_is_64bit(const char *target_arch)
 {
-    AOTCompData *comp_data;
-    uint32 import_global_data_size_64bit = 0, global_data_size_64bit = 0, i, j;
-    uint32 import_global_data_size_32bit = 0, global_data_size_32bit = 0;
-    uint64 size;
-    bool is_64bit_target = false;
-#if WASM_ENABLE_GC != 0
-    bool is_target_x86 = false;
-#endif
-
-#if WASM_ENABLE_GC != 0
     if (!target_arch) {
-#if defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64) \
-    || defined(BUILD_TARGET_X86_32)
-        is_target_x86 = true;
+#if UINTPTR_MAX == UINT64_MAX
+        return true;
+#else
+        return false;
 #endif
     }
-    else {
-        if (!strncmp(target_arch, "x86_64", 6)
-            || !strncmp(target_arch, "i386", 4))
-            is_target_x86 = true;
-    }
-#endif
+    /* All 64bit targets contains "64" string in their target name */
+    return strstr(target_arch, "64") != NULL;
+}
 
+/**
+ * Checks if target architecture is x86/x64 based on target_arch string.
+ *
+ * @param target_arch The target architecture string (e.g. "x86_64", "i386")
+ * @return true if target is x86/x64 architecture, false otherwise
+ *
+ * If target_arch is NULL, detection is based on build-time definitions.
+ * Otherwise checks for x86_64 or i386 in target_arch string.
+ */
+static bool
+arch_is_x86(const char *target_arch)
+{
     if (!target_arch) {
-#if UINTPTR_MAX == UINT64_MAX
-        is_64bit_target = true;
+#if defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64) \
+    || defined(BUILD_TARGET_X86_32)
+        return true;
+#else
+        return false;
 #endif
     }
-    else {
-        /* All 64bit targets contains "64" string in their target name */
-        if (strstr(target_arch, "64") != NULL) {
-            is_64bit_target = true;
-        }
-    }
-
-    /* Allocate memory */
-    if (!(comp_data = wasm_runtime_malloc(sizeof(AOTCompData)))) {
-        aot_set_last_error("create compile data failed.\n");
-        return NULL;
-    }
+    return !strncmp(target_arch, "x86_64", 6)
+           || !strncmp(target_arch, "i386", 4);
+}
 
-    memset(comp_data, 0, sizeof(AOTCompData));
+/**
+ * Initialize memory information in AOT compilation data from WASM module.
+ *
+ * @param comp_data the AOT compilation data structure to initialize
+ * @param module the source WASM module containing memory information
+ * @return true if initialization succeeded, false otherwise
+ */
+static bool
+aot_init_memories(AOTCompData *comp_data, WASMModule *module)
+{
+    uint32 i, j;
+    uint64 size;
 
     comp_data->memory_count =
         module->import_memory_count + module->memory_count;
 
-    /* TODO: create import memories */
-
     /* Allocate memory for memory array, reserve one AOTMemory space at least */
-    /* TODO: multi-memory */
     if (!comp_data->memory_count)
         comp_data->memory_count = 1;
 
@@ -548,7 +573,7 @@ aot_create_comp_data(WASMModule *module, const char *target_arch,
     if (size >= UINT32_MAX
         || !(comp_data->memories = wasm_runtime_malloc((uint32)size))) {
         aot_set_last_error("create memories array failed.\n");
-        goto fail;
+        return false;
     }
     memset(comp_data->memories, 0, size);
 
@@ -580,22 +605,30 @@ aot_create_comp_data(WASMModule *module, const char *target_arch,
         }
     }
 
-    /* Create memory data segments */
-    comp_data->mem_init_data_count = module->data_seg_count;
-    if (comp_data->mem_init_data_count > 0
-        && !(comp_data->mem_init_data_list =
-                 aot_create_mem_init_data_list(module)))
-        goto fail;
+    return true;
+}
+
+/**
+ * Initialize table information in AOT compilation data from WASM module.
+ *
+ * @param comp_data the AOT compilation data structure to initialize
+ * @param module the source WASM module containing table information
+ * @return true if initialization succeeded, false otherwise
+ */
+static bool
+aot_init_tables(AOTCompData *comp_data, WASMModule *module)
+{
+    uint32 i, j;
+    uint64 size;
 
-    /* Create tables */
     comp_data->table_count = module->import_table_count + module->table_count;
 
     if (comp_data->table_count > 0) {
         size = sizeof(AOTTable) * (uint64)comp_data->table_count;
         if (size >= UINT32_MAX
             || !(comp_data->tables = wasm_runtime_malloc((uint32)size))) {
-            aot_set_last_error("create memories array failed.\n");
-            goto fail;
+            aot_set_last_error("create tables array failed.\n");
+            return false;
         }
         memset(comp_data->tables, 0, size);
         for (i = 0; i < comp_data->table_count; i++) {
@@ -641,64 +674,150 @@ aot_create_comp_data(WASMModule *module, const char *target_arch,
         }
     }
 
-    /* Create table data segments */
+    return true;
+}
+
+/**
+ * Initialize memory segment information in AOT compilation data.
+ *
+ * @param comp_data the AOT compilation data structure to initialize
+ * @param module the source WASM module containing memory segments
+ * @return true if initialization succeeded, false otherwise
+ */
+static bool
+aot_init_memory_segments(AOTCompData *comp_data, WASMModule *module)
+{
+    comp_data->mem_init_data_count = module->data_seg_count;
+    if (comp_data->mem_init_data_count > 0
+        && !(comp_data->mem_init_data_list =
+                 aot_create_mem_init_data_list(module))) {
+        return false;
+    }
+    return true;
+}
+
+/**
+ * Initialize table segment information in AOT compilation data.
+ *
+ * @param comp_data the AOT compilation data structure to initialize
+ * @param module the source WASM module containing table segments
+ * @return true if initialization succeeded, false otherwise
+ */
+static bool
+aot_init_table_segments(AOTCompData *comp_data, WASMModule *module)
+{
     comp_data->table_init_data_count = module->table_seg_count;
     if (comp_data->table_init_data_count > 0
         && !(comp_data->table_init_data_list =
-                 aot_create_table_init_data_list(module)))
-        goto fail;
+                 aot_create_table_init_data_list(module))) {
+        return false;
+    }
+    return true;
+}
 
-    /* Create import globals */
+/**
+ * Initialize global variable information in AOT compilation data.
+ *
+ * @param comp_data the AOT compilation data structure to initialize
+ * @param module the source WASM module containing global information
+ * @param gc_enabled whether garbage collection is enabled
+ * @param import_global_data_size_64bit [out] size of imported global data for
+ * 64-bit
+ * @param import_global_data_size_32bit [out] size of imported global data for
+ * 32-bit
+ * @param global_data_size_64bit [out] size of global data for 64-bit
+ * @param global_data_size_32bit [out] size of global data for 32-bit
+ * @return true if initialization succeeded, false otherwise
+ */
+static bool
+aot_init_globals(AOTCompData *comp_data, WASMModule *module, bool gc_enabled,
+                 uint32 *import_global_data_size_64bit,
+                 uint32 *import_global_data_size_32bit,
+                 uint32 *global_data_size_64bit, uint32 *global_data_size_32bit)
+{
     comp_data->import_global_count = module->import_global_count;
     if (comp_data->import_global_count > 0
         && !(comp_data->import_globals = aot_create_import_globals(
-                 module, gc_enabled, &import_global_data_size_64bit,
-                 &import_global_data_size_32bit)))
-        goto fail;
+                 module, gc_enabled, import_global_data_size_64bit,
+                 import_global_data_size_32bit))) {
+        return false;
+    }
 
-    /* Create globals */
     comp_data->global_count = module->global_count;
     if (comp_data->global_count
         && !(comp_data->globals = aot_create_globals(
-                 module, gc_enabled, import_global_data_size_64bit,
-                 import_global_data_size_32bit, &global_data_size_64bit,
-                 &global_data_size_32bit)))
-        goto fail;
+                 module, gc_enabled, *import_global_data_size_64bit,
+                 *import_global_data_size_32bit, global_data_size_64bit,
+                 global_data_size_32bit))) {
+        return false;
+    }
 
     comp_data->global_data_size_64bit =
-        import_global_data_size_64bit + global_data_size_64bit;
+        *import_global_data_size_64bit + *global_data_size_64bit;
     comp_data->global_data_size_32bit =
-        import_global_data_size_32bit + global_data_size_32bit;
+        *import_global_data_size_32bit + *global_data_size_32bit;
+
+    return true;
+}
 
-    /* Create types, they are checked by wasm loader */
+/**
+ * Initialize type information in AOT compilation data.
+ *
+ * @param comp_data the AOT compilation data structure to initialize
+ * @param module the source WASM module containing type information
+ * @param is_target_x86 whether the target architecture is x86
+ * @param gc_enabled whether garbage collection is enabled
+ * @return true if initialization succeeded, false otherwise
+ */
+static bool
+aot_init_types(AOTCompData *comp_data, WASMModule *module, bool is_target_x86,
+               bool gc_enabled)
+{
     comp_data->type_count = module->type_count;
     comp_data->types = module->types;
 #if WASM_ENABLE_GC != 0
-    /* Calculate the field sizes and field offsets for 64-bit and 32-bit
-       targets since they may vary in 32-bit target and 64-bit target */
     calculate_struct_field_sizes_offsets(comp_data, is_target_x86, gc_enabled);
 #endif
+    return true;
+}
 
-    /* Create import functions */
+/**
+ * Initialize function information in AOT compilation data.
+ *
+ * @param comp_data the AOT compilation data structure to initialize
+ * @param module the source WASM module containing function information
+ * @param is_64bit_target whether the target architecture is 64-bit
+ * @return true if initialization succeeded, false otherwise
+ */
+static bool
+aot_init_functions(AOTCompData *comp_data, WASMModule *module,
+                   bool is_64bit_target)
+{
     comp_data->import_func_count = module->import_function_count;
     if (comp_data->import_func_count
-        && !(comp_data->import_funcs = aot_create_import_funcs(module)))
-        goto fail;
+        && !(comp_data->import_funcs = aot_create_import_funcs(module))) {
+        return false;
+    }
 
-    /* Create functions */
     comp_data->func_count = module->function_count;
     if (comp_data->func_count
         && !(comp_data->funcs =
-                 aot_create_funcs(module, is_64bit_target ? 8 : 4)))
-        goto fail;
+                 aot_create_funcs(module, is_64bit_target ? 8 : 4))) {
+        return false;
+    }
 
-#if WASM_ENABLE_CUSTOM_NAME_SECTION != 0
-    /* Create custom name section */
-    comp_data->name_section_buf = module->name_section_buf;
-    comp_data->name_section_buf_end = module->name_section_buf_end;
-#endif
+    return true;
+}
 
-    /* Create aux data/heap/stack information */
+/**
+ * Initialize auxiliary data in AOT compilation data.
+ *
+ * @param comp_data the AOT compilation data structure to initialize
+ * @param module the source WASM module containing auxiliary data
+ */
+static void
+aot_init_aux_data(AOTCompData *comp_data, WASMModule *module)
+{
     comp_data->aux_data_end_global_index = module->aux_data_end_global_index;
     comp_data->aux_data_end = module->aux_data_end;
     comp_data->aux_heap_base_global_index = module->aux_heap_base_global_index;
@@ -717,6 +836,43 @@ aot_create_comp_data(WASMModule *module, const char *target_arch,
     comp_data->string_literal_ptrs_wp = module->string_literal_ptrs;
     comp_data->string_literal_lengths_wp = module->string_literal_lengths;
 #endif
+}
+
+AOTCompData *
+aot_create_comp_data(WASMModule *module, const char *target_arch,
+                     bool gc_enabled)
+{
+    AOTCompData *comp_data;
+    uint32 import_global_data_size_64bit = 0, global_data_size_64bit = 0;
+    uint32 import_global_data_size_32bit = 0, global_data_size_32bit = 0;
+    bool is_64bit_target = arch_is_64bit(target_arch);
+    bool is_target_x86 = arch_is_x86(target_arch);
+
+    if (!(comp_data = wasm_runtime_malloc(sizeof(AOTCompData)))) {
+        aot_set_last_error("create compile data failed.\n");
+        return NULL;
+    }
+    memset(comp_data, 0, sizeof(AOTCompData));
+
+    if (!aot_init_memories(comp_data, module)
+        || !aot_init_memory_segments(comp_data, module)
+        || !aot_init_tables(comp_data, module)
+        || !aot_init_table_segments(comp_data, module)
+        || !aot_init_globals(comp_data, module, gc_enabled,
+                             &import_global_data_size_64bit,
+                             &import_global_data_size_32bit,
+                             &global_data_size_64bit, &global_data_size_32bit)
+        || !aot_init_types(comp_data, module, is_target_x86, gc_enabled)
+        || !aot_init_functions(comp_data, module, is_64bit_target)) {
+        goto fail;
+    }
+
+#if WASM_ENABLE_CUSTOM_NAME_SECTION != 0
+    comp_data->name_section_buf = module->name_section_buf;
+    comp_data->name_section_buf_end = module->name_section_buf_end;
+#endif
+
+    aot_init_aux_data(comp_data, module);
 
     comp_data->wasm_module = module;
 

core/iwasm/compilation/aot.h

@@ -103,7 +103,7 @@ typedef struct AOTMemInitData {
     /* Byte count */
     uint32 byte_count;
     /* Byte array */
-    uint8 bytes[1];
+    uint8 *bytes;
 } AOTMemInitData;
 
 /**

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

@@ -1790,7 +1790,9 @@ aot_emit_mem_info(uint8 *buf, uint8 *buf_end, uint32 *p_offset,
                                 &init_datas[i]->offset))
             return false;
         EMIT_U32(init_datas[i]->byte_count);
-        EMIT_BUF(init_datas[i]->bytes, init_datas[i]->byte_count);
+        if (init_datas[i]->byte_count) {
+            EMIT_BUF(init_datas[i]->bytes, init_datas[i]->byte_count);
+        }
     }
 
     if (offset - *p_offset != get_mem_info_size(comp_ctx, comp_data)) {
@@ -4292,10 +4294,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 +4321,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 +4353,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 +4380,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_control.c

@@ -1218,6 +1218,28 @@ aot_compile_op_br_table(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
         return aot_handle_next_reachable_block(comp_ctx, func_ctx, p_frame_ip);
     }
 
+    /*
+     * if (value_cmp > br_count)
+     *   value_cmp = br_count;
+     */
+    LLVMValueRef br_count_value = I32_CONST(br_count);
+    CHECK_LLVM_CONST(br_count_value);
+
+    LLVMValueRef clap_value_cmp_cond =
+        LLVMBuildICmp(comp_ctx->builder, LLVMIntUGT, value_cmp, br_count_value,
+                      "cmp_w_br_count");
+    if (!clap_value_cmp_cond) {
+        aot_set_last_error("llvm build icmp failed.");
+        return false;
+    }
+
+    value_cmp = LLVMBuildSelect(comp_ctx->builder, clap_value_cmp_cond,
+                                br_count_value, value_cmp, "clap_value_cmp");
+    if (!value_cmp) {
+        aot_set_last_error("llvm build select failed.");
+        return false;
+    }
+
     if (!LLVMIsEfficientConstInt(value_cmp)) {
         if (comp_ctx->aot_frame) {
             if (comp_ctx->enable_gc

core/iwasm/compilation/aot_emit_function.c

@@ -1832,6 +1832,7 @@ aot_compile_op_call(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
                 aot_set_last_error("llvm build load failed.");
                 goto fail;
             }
+            LLVMSetAlignment(ext_ret, 4);
             PUSH(ext_ret, ext_ret_types[i]);
         }
     }
@@ -2068,6 +2069,7 @@ call_aot_call_indirect_func(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
             aot_set_last_error("llvm build load failed.");
             return false;
         }
+        LLVMSetAlignment(value_rets[i], 4);
         cell_num += wasm_value_type_cell_num_internal(wasm_ret_types[i],
                                                       comp_ctx->pointer_size);
     }
@@ -2699,6 +2701,7 @@ aot_compile_op_call_indirect(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
                 aot_set_last_error("llvm build load failed.");
                 goto fail;
             }
+            LLVMSetAlignment(ext_ret, 4);
             LLVMAddIncoming(result_phis[i], &ext_ret, &block_curr, 1);
         }
     }
@@ -3130,6 +3133,7 @@ aot_compile_op_call_ref(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
                 aot_set_last_error("llvm build load failed.");
                 goto fail;
             }
+            LLVMSetAlignment(ext_ret, 4);
             LLVMAddIncoming(result_phis[i], &ext_ret, &block_curr, 1);
         }
     }
@@ -3205,6 +3209,7 @@ aot_compile_op_call_ref(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
                 aot_set_last_error("llvm build load failed.");
                 goto fail;
             }
+            LLVMSetAlignment(ext_ret, 4);
             LLVMAddIncoming(result_phis[i], &ext_ret, &block_curr, 1);
         }
     }

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
             }
         }
 
@@ -3344,6 +3334,11 @@ aot_destroy_comp_context(AOTCompContext *comp_ctx)
     if (comp_ctx->builder)
         LLVMDisposeBuilder(comp_ctx->builder);
 
+#if WASM_ENABLE_DEBUG_AOT != 0
+    if (comp_ctx->debug_builder)
+        LLVMDisposeDIBuilder(comp_ctx->debug_builder);
+#endif
+
     if (comp_ctx->orc_thread_safe_context)
         LLVMOrcDisposeThreadSafeContext(comp_ctx->orc_thread_safe_context);
 

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/compilation/iwasm_compl.cmake

@@ -1,6 +1,7 @@
 set (IWASM_COMPL_DIR ${CMAKE_CURRENT_LIST_DIR})
 
 include_directories(${IWASM_COMPL_DIR})
+enable_language(CXX)
 
 if (WAMR_BUILD_DEBUG_AOT EQUAL 1)
     file (GLOB_RECURSE source_all

core/iwasm/fast-jit/iwasm_fast_jit.cmake

@@ -9,6 +9,7 @@ if (WAMR_BUILD_FAST_JIT_DUMP EQUAL 1)
 endif ()
 
 include_directories (${IWASM_FAST_JIT_DIR})
+enable_language(CXX)
 
 if (WAMR_BUILD_TARGET STREQUAL "X86_64" OR WAMR_BUILD_TARGET STREQUAL "AMD_64")
     include(FetchContent)

core/iwasm/include/aot_comp_option.h

@@ -8,6 +8,10 @@
 
 #include <stdint.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef struct {
     /* Enables or disables bounds checks for stack frames. When enabled, the AOT
      * compiler generates code to check if the stack pointer is within the
@@ -88,4 +92,8 @@ typedef struct AOTCompOption {
     const char *builtin_intrinsics;
 } AOTCompOption, *aot_comp_option_t;
 
+#ifdef __cplusplus
+}
 #endif
+
+#endif /* end of __AOT_COMP_OPTION_H__ */

core/iwasm/include/wasm_c_api.h

@@ -46,7 +46,7 @@ extern "C" {
 // Auxiliaries
 
 // Machine types
-#if (__STDC_VERSION__) > 199901L
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__) > 199901L
 inline void assertions(void) {
   static_assert(sizeof(float) == sizeof(uint32_t), "incompatible float type");
   static_assert(sizeof(double) == sizeof(uint64_t), "incompatible double type");

core/iwasm/include/wasm_export.h

@@ -23,6 +23,8 @@
 #else
 #define WASM_RUNTIME_API_EXTERN __declspec(dllimport)
 #endif
+#elif defined(__GNUC__) || defined(__clang__)
+#define WASM_RUNTIME_API_EXTERN __attribute__((visibility("default")))
 #else
 #define WASM_RUNTIME_API_EXTERN
 #endif

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_TBL_ELEM_IDX() (is_table64 ? POP_I64() : POP_I32())
+#define POP_MEM_OFFSET() (is_memory64 ? POP_I64() : (uint32)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()
@@ -2649,7 +2649,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
                 read_leb_uint32(frame_ip, frame_ip_end, type_index);
                 func_obj = POP_REF();
                 if (!func_obj) {
-                    wasm_set_exception(module, "null function object");
+                    wasm_set_exception(module, "null function reference");
                     goto got_exception;
                 }
 
@@ -2666,7 +2666,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
                 read_leb_uint32(frame_ip, frame_ip_end, type_index);
                 func_obj = POP_REF();
                 if (!func_obj) {
-                    wasm_set_exception(module, "null function object");
+                    wasm_set_exception(module, "null function reference");
                     goto got_exception;
                 }
 
@@ -2813,7 +2813,8 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
                         struct_obj = POP_REF();
 
                         if (!struct_obj) {
-                            wasm_set_exception(module, "null structure object");
+                            wasm_set_exception(module,
+                                               "null structure reference");
                             goto got_exception;
                         }
 
@@ -2869,7 +2870,8 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
 
                         struct_obj = POP_REF();
                         if (!struct_obj) {
-                            wasm_set_exception(module, "null structure object");
+                            wasm_set_exception(module,
+                                               "null structure reference");
                             goto got_exception;
                         }
 

core/iwasm/interpreter/wasm_interp_fast.c

@@ -1670,7 +1670,8 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
             {
                 uint32 ret_idx;
                 WASMFuncType *func_type;
-                uint32 off, ret_offset;
+                int32 off;
+                uint32 ret_offset;
                 uint8 *ret_types;
                 if (cur_func->is_import_func)
                     func_type = cur_func->u.func_import->func_type;
@@ -1682,9 +1683,9 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
                 ret_offset = prev_frame->ret_offset;
 
                 for (ret_idx = 0,
-                    off = sizeof(int16) * (func_type->result_count - 1);
+                    off = (int32)sizeof(int16) * (func_type->result_count - 1);
                      ret_idx < func_type->result_count;
-                     ret_idx++, off -= sizeof(int16)) {
+                     ret_idx++, off -= (int32)sizeof(int16)) {
                     if (ret_types[ret_idx] == VALUE_TYPE_I64
                         || ret_types[ret_idx] == VALUE_TYPE_F64) {
                         PUT_I64_TO_ADDR(prev_frame->lp + ret_offset,
@@ -1991,7 +1992,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
 #endif
                 func_obj = POP_REF();
                 if (!func_obj) {
-                    wasm_set_exception(module, "null function object");
+                    wasm_set_exception(module, "null function reference");
                     goto got_exception;
                 }
 
@@ -2006,7 +2007,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
 #endif
                 func_obj = POP_REF();
                 if (!func_obj) {
-                    wasm_set_exception(module, "null function object");
+                    wasm_set_exception(module, "null function reference");
                     goto got_exception;
                 }
 
@@ -2147,7 +2148,8 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
                         struct_obj = POP_REF();
 
                         if (!struct_obj) {
-                            wasm_set_exception(module, "null structure object");
+                            wasm_set_exception(module,
+                                               "null structure reference");
                             goto got_exception;
                         }
 
@@ -2203,7 +2205,8 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
 
                         struct_obj = POP_REF();
                         if (!struct_obj) {
-                            wasm_set_exception(module, "null structure object");
+                            wasm_set_exception(module,
+                                               "null structure reference");
                             goto got_exception;
                         }
 

core/iwasm/interpreter/wasm_mini_loader.c

@@ -48,7 +48,9 @@ is_table_64bit(WASMModule *module, uint32 table_idx)
         return !!(module->import_tables[table_idx].u.table.table_type.flags
                   & TABLE64_FLAG);
     else
-        return !!(module->tables[table_idx].table_type.flags & TABLE64_FLAG);
+        return !!(module->tables[table_idx - module->import_table_count]
+                      .table_type.flags
+                  & TABLE64_FLAG);
 
     return false;
 }
@@ -206,9 +208,14 @@ memory_realloc(void *mem_old, uint32 size_old, uint32 size_new, char *error_buf,
 {
     uint8 *mem_new;
     bh_assert(size_new > size_old);
+
+    if ((mem_new = wasm_runtime_realloc(mem_old, size_new))) {
+        memset(mem_new + size_old, 0, size_new - size_old);
+        return mem_new;
+    }
+
     if ((mem_new = loader_malloc(size_new, error_buf, error_buf_size))) {
         bh_memcpy_s(mem_new, size_new, mem_old, size_old);
-        memset(mem_new + size_old, 0, size_new - size_old);
         wasm_runtime_free(mem_old);
     }
     return mem_new;
@@ -1183,6 +1190,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);
 
@@ -2564,7 +2573,7 @@ get_table_elem_type(const WASMModule *module, uint32 table_idx,
                 module->import_tables[table_idx].u.table.table_type.elem_type;
         else
             *p_elem_type =
-                module->tables[module->import_table_count + table_idx]
+                module->tables[table_idx - module->import_table_count]
                     .table_type.elem_type;
     }
     return true;
@@ -2725,6 +2734,11 @@ load_from_sections(WASMModule *module, WASMSection *sections,
         section = section->next;
     }
 
+#if WASM_ENABLE_BULK_MEMORY != 0
+    bh_assert(!has_datacount_section
+              || module->data_seg_count == module->data_seg_count1);
+#endif
+
     module->aux_data_end_global_index = (uint32)-1;
     module->aux_heap_base_global_index = (uint32)-1;
     module->aux_stack_top_global_index = (uint32)-1;
@@ -2734,6 +2748,12 @@ load_from_sections(WASMModule *module, WASMSection *sections,
     for (i = 0; i < module->export_count; i++, export ++) {
         if (export->kind == EXPORT_KIND_GLOBAL) {
             if (!strcmp(export->name, "__heap_base")) {
+                if (export->index < module->import_global_count) {
+                    LOG_DEBUG("Skip the process if __heap_base is imported "
+                              "instead of being a local global");
+                    continue;
+                }
+
                 global_index = export->index - module->import_global_count;
                 global = module->globals + global_index;
                 if (global->type.val_type == VALUE_TYPE_I32
@@ -2748,6 +2768,12 @@ load_from_sections(WASMModule *module, WASMSection *sections,
                 }
             }
             else if (!strcmp(export->name, "__data_end")) {
+                if (export->index < module->import_global_count) {
+                    LOG_DEBUG("Skip the process if __data_end is imported "
+                              "instead of being a local global");
+                    continue;
+                }
+
                 global_index = export->index - module->import_global_count;
                 global = module->globals + global_index;
                 if (global->type.val_type == VALUE_TYPE_I32
@@ -2942,9 +2968,7 @@ load_from_sections(WASMModule *module, WASMSection *sections,
     }
 
     if (!module->possible_memory_grow) {
-        WASMMemoryImport *memory_import;
-        WASMMemory *memory;
-
+#if WASM_ENABLE_SHRUNK_MEMORY != 0
         if (aux_data_end_global && aux_heap_base_global
             && aux_stack_top_global) {
             uint64 init_memory_size;
@@ -2954,7 +2978,8 @@ load_from_sections(WASMModule *module, WASMSection *sections,
              * valid range of uint32 */
             if (shrunk_memory_size <= UINT32_MAX) {
                 if (module->import_memory_count) {
-                    memory_import = &module->import_memories[0].u.memory;
+                    WASMMemoryImport *memory_import =
+                        &module->import_memories[0].u.memory;
                     init_memory_size =
                         (uint64)memory_import->mem_type.num_bytes_per_page
                         * memory_import->mem_type.init_page_count;
@@ -2969,7 +2994,7 @@ load_from_sections(WASMModule *module, WASMSection *sections,
                 }
 
                 if (module->memory_count) {
-                    memory = &module->memories[0];
+                    WASMMemory *memory = &module->memories[0];
                     init_memory_size = (uint64)memory->num_bytes_per_page
                                        * memory->init_page_count;
                     if (shrunk_memory_size <= init_memory_size) {
@@ -2982,9 +3007,11 @@ load_from_sections(WASMModule *module, WASMSection *sections,
                 }
             }
         }
+#endif /* WASM_ENABLE_SHRUNK_MEMORY != 0 */
 
         if (module->import_memory_count) {
-            memory_import = &module->import_memories[0].u.memory;
+            WASMMemoryImport *memory_import =
+                &module->import_memories[0].u.memory;
             if (memory_import->mem_type.init_page_count < DEFAULT_MAX_PAGES) {
                 memory_import->mem_type.num_bytes_per_page *=
                     memory_import->mem_type.init_page_count;
@@ -2998,7 +3025,7 @@ load_from_sections(WASMModule *module, WASMSection *sections,
         }
 
         if (module->memory_count) {
-            memory = &module->memories[0];
+            WASMMemory *memory = &module->memories[0];
             if (memory->init_page_count < DEFAULT_MAX_PAGES) {
                 memory->num_bytes_per_page *= memory->init_page_count;
                 if (memory->init_page_count > 0)
@@ -4030,11 +4057,16 @@ typedef struct WASMLoaderContext {
     /* preserved local offset */
     int16 preserved_local_offset;
 
-    /* const buffer */
-    uint8 *const_buf;
-    uint16 num_const;
-    uint16 const_cell_num;
-    uint32 const_buf_size;
+    /* const buffer for i64 and f64 consts, note that the raw bytes
+     * of i64 and f64 are the same, so we read an i64 value from an
+     * f64 const with its raw bytes, something like `*(int64 *)&f64 */
+    int64 *i64_consts;
+    uint32 i64_const_max_num;
+    uint32 i64_const_num;
+    /* const buffer for i32 and f32 consts */
+    int32 *i32_consts;
+    uint32 i32_const_max_num;
+    uint32 i32_const_num;
 
     /* processed code */
     uint8 *p_code_compiled;
@@ -4047,12 +4079,6 @@ typedef struct WASMLoaderContext {
 #endif
 } WASMLoaderContext;
 
-typedef struct Const {
-    WASMValue value;
-    uint16 slot_index;
-    uint8 value_type;
-} Const;
-
 #define CHECK_CSP_PUSH()                                                  \
     do {                                                                  \
         if (ctx->frame_csp >= ctx->frame_csp_boundary) {                  \
@@ -4207,8 +4233,10 @@ wasm_loader_ctx_destroy(WASMLoaderContext *ctx)
 #if WASM_ENABLE_FAST_INTERP != 0
         if (ctx->frame_offset_bottom)
             wasm_runtime_free(ctx->frame_offset_bottom);
-        if (ctx->const_buf)
-            wasm_runtime_free(ctx->const_buf);
+        if (ctx->i64_consts)
+            wasm_runtime_free(ctx->i64_consts);
+        if (ctx->i32_consts)
+            wasm_runtime_free(ctx->i32_consts);
 #endif
         wasm_runtime_free(ctx);
     }
@@ -4242,10 +4270,15 @@ wasm_loader_ctx_init(WASMFunction *func, char *error_buf, uint32 error_buf_size)
         goto fail;
     loader_ctx->frame_offset_boundary = loader_ctx->frame_offset_bottom + 32;
 
-    loader_ctx->num_const = 0;
-    loader_ctx->const_buf_size = sizeof(Const) * 8;
-    if (!(loader_ctx->const_buf = loader_malloc(loader_ctx->const_buf_size,
-                                                error_buf, error_buf_size)))
+    loader_ctx->i64_const_max_num = 8;
+    if (!(loader_ctx->i64_consts =
+              loader_malloc(sizeof(int64) * loader_ctx->i64_const_max_num,
+                            error_buf, error_buf_size)))
+        goto fail;
+    loader_ctx->i32_const_max_num = 8;
+    if (!(loader_ctx->i32_consts =
+              loader_malloc(sizeof(int32) * loader_ctx->i32_const_max_num,
+                            error_buf, error_buf_size)))
         goto fail;
 
     if (func->param_cell_num >= (int32)INT16_MAX - func->local_cell_num) {
@@ -5068,107 +5101,116 @@ wasm_loader_push_pop_frame_ref_offset(WASMLoaderContext *ctx, uint8 pop_cnt,
     return true;
 }
 
+static int
+cmp_i64_const(const void *p_i64_const1, const void *p_i64_const2)
+{
+    int64 i64_const1 = *(int64 *)p_i64_const1;
+    int64 i64_const2 = *(int64 *)p_i64_const2;
+
+    return (i64_const1 < i64_const2) ? -1 : (i64_const1 > i64_const2) ? 1 : 0;
+}
+
+static int
+cmp_i32_const(const void *p_i32_const1, const void *p_i32_const2)
+{
+    int32 i32_const1 = *(int32 *)p_i32_const1;
+    int32 i32_const2 = *(int32 *)p_i32_const2;
+
+    return (i32_const1 < i32_const2) ? -1 : (i32_const1 > i32_const2) ? 1 : 0;
+}
+
 static bool
 wasm_loader_get_const_offset(WASMLoaderContext *ctx, uint8 type, void *value,
                              int16 *offset, char *error_buf,
                              uint32 error_buf_size)
 {
-    int8 bytes_to_increase;
-    int16 operand_offset = 0;
-    Const *c;
-
-    /* Search existing constant */
-    for (c = (Const *)ctx->const_buf;
-         (uint8 *)c < ctx->const_buf + ctx->num_const * sizeof(Const); c++) {
-        if ((type == c->value_type)
-            && ((type == VALUE_TYPE_I64 && *(int64 *)value == c->value.i64)
-                || (type == VALUE_TYPE_I32 && *(int32 *)value == c->value.i32)
-#if WASM_ENABLE_REF_TYPES != 0
-                || (type == VALUE_TYPE_FUNCREF
-                    && *(int32 *)value == c->value.i32)
-                || (type == VALUE_TYPE_EXTERNREF
-                    && *(int32 *)value == c->value.i32)
-#endif
-                || (type == VALUE_TYPE_F64
-                    && (0 == memcmp(value, &(c->value.f64), sizeof(float64))))
-                || (type == VALUE_TYPE_F32
-                    && (0
-                        == memcmp(value, &(c->value.f32), sizeof(float32)))))) {
-            operand_offset = c->slot_index;
-            break;
-        }
-        if (c->value_type == VALUE_TYPE_I64 || c->value_type == VALUE_TYPE_F64)
-            operand_offset += 2;
-        else
-            operand_offset += 1;
-    }
+    if (!ctx->p_code_compiled) {
+        /* Treat i64 and f64 as the same by reading i64 value from
+           the raw bytes */
+        if (type == VALUE_TYPE_I64 || type == VALUE_TYPE_F64) {
+            /* No slot left, emit const instead */
+            if (ctx->i64_const_num * 2 + ctx->i32_const_num > INT16_MAX - 2) {
+                *offset = 0;
+                return true;
+            }
+
+            /* Traverse the list if the const num is small */
+            if (ctx->i64_const_num < 10) {
+                for (uint32 i = 0; i < ctx->i64_const_num; i++) {
+                    if (ctx->i64_consts[i] == *(int64 *)value) {
+                        *offset = -1;
+                        return true;
+                    }
+                }
+            }
 
-    if ((uint8 *)c == ctx->const_buf + ctx->num_const * sizeof(Const)) {
-        /* New constant, append to the const buffer */
-        if ((type == VALUE_TYPE_F64) || (type == VALUE_TYPE_I64)) {
-            bytes_to_increase = 2;
+            if (ctx->i64_const_num >= ctx->i64_const_max_num) {
+                MEM_REALLOC(ctx->i64_consts,
+                            sizeof(int64) * ctx->i64_const_max_num,
+                            sizeof(int64) * (ctx->i64_const_max_num * 2));
+                ctx->i64_const_max_num *= 2;
+            }
+            ctx->i64_consts[ctx->i64_const_num++] = *(int64 *)value;
         }
         else {
-            bytes_to_increase = 1;
-        }
+            /* Treat i32 and f32 as the same by reading i32 value from
+               the raw bytes */
+            bh_assert(type == VALUE_TYPE_I32 || type == VALUE_TYPE_F32);
+
+            /* No slot left, emit const instead */
+            if (ctx->i64_const_num * 2 + ctx->i32_const_num > INT16_MAX - 1) {
+                *offset = 0;
+                return true;
+            }
 
-        /* The max cell num of const buffer is 32768 since the valid index range
-         * is -32768 ~ -1. Return an invalid index 0 to indicate the buffer is
-         * full */
-        if (ctx->const_cell_num > INT16_MAX - bytes_to_increase + 1) {
-            *offset = 0;
-            return true;
+            /* Traverse the list if the const num is small */
+            if (ctx->i32_const_num < 10) {
+                for (uint32 i = 0; i < ctx->i32_const_num; i++) {
+                    if (ctx->i32_consts[i] == *(int32 *)value) {
+                        *offset = -1;
+                        return true;
+                    }
+                }
+            }
+
+            if (ctx->i32_const_num >= ctx->i32_const_max_num) {
+                MEM_REALLOC(ctx->i32_consts,
+                            sizeof(int32) * ctx->i32_const_max_num,
+                            sizeof(int32) * (ctx->i32_const_max_num * 2));
+                ctx->i32_const_max_num *= 2;
+            }
+            ctx->i32_consts[ctx->i32_const_num++] = *(int32 *)value;
         }
 
-        if ((uint8 *)c == ctx->const_buf + ctx->const_buf_size) {
-            MEM_REALLOC(ctx->const_buf, ctx->const_buf_size,
-                        ctx->const_buf_size + 4 * sizeof(Const));
-            ctx->const_buf_size += 4 * sizeof(Const);
-            c = (Const *)(ctx->const_buf + ctx->num_const * sizeof(Const));
+        *offset = -1;
+        return true;
+    }
+    else {
+        if (type == VALUE_TYPE_I64 || type == VALUE_TYPE_F64) {
+            int64 key = *(int64 *)value, *i64_const;
+            i64_const = bsearch(&key, ctx->i64_consts, ctx->i64_const_num,
+                                sizeof(int64), cmp_i64_const);
+            if (!i64_const) { /* not found, emit const instead */
+                *offset = 0;
+                return true;
+            }
+            *offset = -(uint32)(ctx->i64_const_num * 2 + ctx->i32_const_num)
+                      + (uint32)(i64_const - ctx->i64_consts) * 2;
         }
-        c->value_type = type;
-        switch (type) {
-            case VALUE_TYPE_F64:
-                bh_memcpy_s(&(c->value.f64), sizeof(WASMValue), value,
-                            sizeof(float64));
-                ctx->const_cell_num += 2;
-                /* The const buf will be reversed, we use the second cell */
-                /* of the i64/f64 const so the finnal offset is corrent */
-                operand_offset++;
-                break;
-            case VALUE_TYPE_I64:
-                c->value.i64 = *(int64 *)value;
-                ctx->const_cell_num += 2;
-                operand_offset++;
-                break;
-            case VALUE_TYPE_F32:
-                bh_memcpy_s(&(c->value.f32), sizeof(WASMValue), value,
-                            sizeof(float32));
-                ctx->const_cell_num++;
-                break;
-            case VALUE_TYPE_I32:
-                c->value.i32 = *(int32 *)value;
-                ctx->const_cell_num++;
-                break;
-#if WASM_ENABLE_REF_TYPES != 0
-            case VALUE_TYPE_EXTERNREF:
-            case VALUE_TYPE_FUNCREF:
-                c->value.i32 = *(int32 *)value;
-                ctx->const_cell_num++;
-                break;
-#endif
-            default:
-                break;
+        else {
+            int32 key = *(int32 *)value, *i32_const;
+            i32_const = bsearch(&key, ctx->i32_consts, ctx->i32_const_num,
+                                sizeof(int32), cmp_i32_const);
+            if (!i32_const) { /* not found, emit const instead */
+                *offset = 0;
+                return true;
+            }
+            *offset = -(uint32)(ctx->i32_const_num)
+                      + (uint32)(i32_const - ctx->i32_consts);
         }
-        c->slot_index = operand_offset;
-        ctx->num_const++;
-        LOG_OP("#### new const [%d]: %ld\n", ctx->num_const,
-               (int64)c->value.i64);
-    }
-    /* use negetive index for const */
-    operand_offset = -(operand_offset + 1);
-    *offset = operand_offset;
-    return true;
+
+        return true;
+    }
 fail:
     return false;
 }
@@ -5559,7 +5601,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 +5637,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, \
@@ -6033,6 +6073,86 @@ fail:
         }                                                             \
     } while (0)
 
+#if WASM_ENABLE_FAST_INTERP == 0
+
+#define pb_read_leb_uint32 read_leb_uint32
+#define pb_read_leb_int32 read_leb_int32
+#define pb_read_leb_int64 read_leb_int64
+#define pb_read_leb_memarg read_leb_memarg
+#define pb_read_leb_mem_offset read_leb_mem_offset
+#define pb_read_leb_memidx read_leb_memidx
+
+#else
+
+/* Read leb without malformed format check */
+static uint64
+read_leb_quick(uint8 **p_buf, uint32 maxbits, bool sign)
+{
+    uint8 *buf = *p_buf;
+    uint64 result = 0, byte = 0;
+    uint32 shift = 0;
+
+    do {
+        byte = *buf++;
+        result |= ((byte & 0x7f) << shift);
+        shift += 7;
+    } while (byte & 0x80);
+
+    if (sign && (shift < maxbits) && (byte & 0x40)) {
+        /* Sign extend */
+        result |= (~((uint64)0)) << shift;
+    }
+
+    *p_buf = buf;
+    return result;
+}
+
+#define pb_read_leb_uint32(p, p_end, res)                 \
+    do {                                                  \
+        if (!loader_ctx->p_code_compiled)                 \
+            /* Enable format check in the first scan */   \
+            read_leb_uint32(p, p_end, res);               \
+        else                                              \
+            /* Disable format check in the second scan */ \
+            res = (uint32)read_leb_quick(&p, 32, false);  \
+    } while (0)
+
+#define pb_read_leb_int32(p, p_end, res)                  \
+    do {                                                  \
+        if (!loader_ctx->p_code_compiled)                 \
+            /* Enable format check in the first scan */   \
+            read_leb_int32(p, p_end, res);                \
+        else                                              \
+            /* Disable format check in the second scan */ \
+            res = (int32)read_leb_quick(&p, 32, true);    \
+    } while (0)
+
+#define pb_read_leb_int64(p, p_end, res)                  \
+    do {                                                  \
+        if (!loader_ctx->p_code_compiled)                 \
+            /* Enable format check in the first scan */   \
+            read_leb_int64(p, p_end, res);                \
+        else                                              \
+            /* Disable format check in the second scan */ \
+            res = (int64)read_leb_quick(&p, 64, true);    \
+    } while (0)
+
+#if WASM_ENABLE_MULTI_MEMORY != 0
+#define pb_read_leb_memarg read_leb_memarg
+#else
+#define pb_read_leb_memarg pb_read_leb_uint32
+#endif
+
+#if WASM_ENABLE_MEMORY64 != 0
+#define pb_read_leb_mem_offset read_leb_mem_offset
+#else
+#define pb_read_leb_mem_offset pb_read_leb_uint32
+#endif
+
+#define pb_read_leb_memidx pb_read_leb_uint32
+
+#endif /* end of WASM_ENABLE_FAST_INTERP != 0 */
+
 static bool
 wasm_loader_prepare_bytecode(WASMModule *module, WASMFunction *func,
                              uint32 cur_func_idx, char *error_buf,
@@ -6056,11 +6176,9 @@ wasm_loader_prepare_bytecode(WASMModule *module, WASMFunction *func,
     uint32 segment_index;
 #endif
 #if WASM_ENABLE_FAST_INTERP != 0
-    uint8 *func_const_end, *func_const = NULL;
     int16 operand_offset = 0;
     uint8 last_op = 0;
     bool disable_emit, preserve_local = false, if_condition_available = true;
-    ;
     float32 f32_const;
     float64 f64_const;
 
@@ -6111,6 +6229,68 @@ re_scan:
         p = func->code;
         func->code_compiled = loader_ctx->p_code_compiled;
         func->code_compiled_size = loader_ctx->code_compiled_size;
+
+        if (loader_ctx->i64_const_num > 0) {
+            int64 *i64_consts_old = loader_ctx->i64_consts;
+
+            /* Sort the i64 consts */
+            qsort(i64_consts_old, loader_ctx->i64_const_num, sizeof(int64),
+                  cmp_i64_const);
+
+            /* Remove the duplicated i64 consts */
+            uint32 k = 1;
+            for (i = 1; i < loader_ctx->i64_const_num; i++) {
+                if (i64_consts_old[i] != i64_consts_old[i - 1]) {
+                    i64_consts_old[k++] = i64_consts_old[i];
+                }
+            }
+
+            if (k < loader_ctx->i64_const_num) {
+                int64 *i64_consts_new;
+                /* Try to reallocate memory with a smaller size */
+                if ((i64_consts_new =
+                         wasm_runtime_malloc((uint32)sizeof(int64) * k))) {
+                    bh_memcpy_s(i64_consts_new, (uint32)sizeof(int64) * k,
+                                i64_consts_old, (uint32)sizeof(int64) * k);
+                    /* Free the old memory */
+                    wasm_runtime_free(i64_consts_old);
+                    loader_ctx->i64_consts = i64_consts_new;
+                    loader_ctx->i64_const_max_num = k;
+                }
+                loader_ctx->i64_const_num = k;
+            }
+        }
+
+        if (loader_ctx->i32_const_num > 0) {
+            int32 *i32_consts_old = loader_ctx->i32_consts;
+
+            /* Sort the i32 consts */
+            qsort(i32_consts_old, loader_ctx->i32_const_num, sizeof(int32),
+                  cmp_i32_const);
+
+            /* Remove the duplicated i32 consts */
+            uint32 k = 1;
+            for (i = 1; i < loader_ctx->i32_const_num; i++) {
+                if (i32_consts_old[i] != i32_consts_old[i - 1]) {
+                    i32_consts_old[k++] = i32_consts_old[i];
+                }
+            }
+
+            if (k < loader_ctx->i32_const_num) {
+                int32 *i32_consts_new;
+                /* Try to reallocate memory with a smaller size */
+                if ((i32_consts_new =
+                         wasm_runtime_malloc((uint32)sizeof(int32) * k))) {
+                    bh_memcpy_s(i32_consts_new, (uint32)sizeof(int32) * k,
+                                i32_consts_old, (uint32)sizeof(int32) * k);
+                    /* Free the old memory */
+                    wasm_runtime_free(i32_consts_old);
+                    loader_ctx->i32_consts = i32_consts_new;
+                    loader_ctx->i32_const_max_num = k;
+                }
+                loader_ctx->i32_const_num = k;
+            }
+        }
     }
 #endif
 
@@ -6180,7 +6360,7 @@ re_scan:
                     int32 type_index;
                     /* Resolve the leb128 encoded type index as block type */
                     p--;
-                    read_leb_int32(p, p_end, type_index);
+                    pb_read_leb_int32(p, p_end, type_index);
                     bh_assert((uint32)type_index < module->type_count);
                     block_type.is_value_type = false;
                     block_type.u.type = module->types[type_index];
@@ -6364,7 +6544,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 +6607,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);
@@ -6486,7 +6673,7 @@ re_scan:
                 uint32 j;
 #endif
 
-                read_leb_uint32(p, p_end, count);
+                pb_read_leb_uint32(p, p_end, count);
 #if WASM_ENABLE_FAST_INTERP != 0
                 emit_uint32(loader_ctx, count);
 #endif
@@ -6495,7 +6682,7 @@ re_scan:
                 /* Get each depth and check it */
                 p_org = p;
                 for (i = 0; i <= count; i++) {
-                    read_leb_uint32(p, p_end, depth);
+                    pb_read_leb_uint32(p, p_end, depth);
                     bh_assert(loader_ctx->csp_num > 0);
                     bh_assert(loader_ctx->csp_num - 1 >= depth);
                     (void)depth;
@@ -6593,7 +6780,7 @@ re_scan:
                 uint32 func_idx;
                 int32 idx;
 
-                read_leb_uint32(p, p_end, func_idx);
+                pb_read_leb_uint32(p, p_end, func_idx);
 #if WASM_ENABLE_FAST_INTERP != 0
                 /* we need to emit func_idx before arguments */
                 emit_uint32(loader_ctx, func_idx);
@@ -6666,10 +6853,10 @@ re_scan:
 
                 bh_assert(module->import_table_count + module->table_count > 0);
 
-                read_leb_uint32(p, p_end, type_idx);
+                pb_read_leb_uint32(p, p_end, type_idx);
 
 #if WASM_ENABLE_REF_TYPES != 0
-                read_leb_uint32(p, p_end, table_idx);
+                pb_read_leb_uint32(p, p_end, table_idx);
 #else
                 CHECK_BUF(p, p_end, 1);
                 table_idx = read_uint8(p);
@@ -6679,6 +6866,15 @@ re_scan:
                     goto fail;
                 }
 
+                bh_assert(
+                    (table_idx < module->import_table_count
+                         ? module->import_tables[table_idx]
+                               .u.table.table_type.elem_type
+                         : module
+                               ->tables[table_idx - module->import_table_count]
+                               .table_type.elem_type)
+                    == VALUE_TYPE_FUNCREF);
+
 #if WASM_ENABLE_FAST_INTERP != 0
                 /* we need to emit before arguments */
                 emit_uint32(loader_ctx, type_idx);
@@ -6900,7 +7096,7 @@ re_scan:
                 uint8 *p_code_compiled_tmp = loader_ctx->p_code_compiled;
 #endif
 
-                read_leb_uint32(p, p_end, vec_len);
+                pb_read_leb_uint32(p, p_end, vec_len);
                 if (vec_len != 1) {
                     /* typed select must have exactly one result */
                     set_error_buf(error_buf, error_buf_size,
@@ -6975,7 +7171,7 @@ re_scan:
                 uint8 decl_ref_type;
                 uint32 table_idx;
 
-                read_leb_uint32(p, p_end, table_idx);
+                pb_read_leb_uint32(p, p_end, table_idx);
                 if (!get_table_elem_type(module, table_idx, &decl_ref_type,
                                          error_buf, error_buf_size))
                     goto fail;
@@ -7069,7 +7265,7 @@ re_scan:
             case WASM_OP_REF_FUNC:
             {
                 uint32 func_idx = 0;
-                read_leb_uint32(p, p_end, func_idx);
+                pb_read_leb_uint32(p, p_end, func_idx);
 
                 if (!check_function_index(module, func_idx, error_buf,
                                           error_buf_size)) {
@@ -7286,7 +7482,7 @@ re_scan:
             case WASM_OP_GET_GLOBAL:
             {
                 p_org = p - 1;
-                read_leb_uint32(p, p_end, global_idx);
+                pb_read_leb_uint32(p, p_end, global_idx);
                 bh_assert(global_idx < global_count);
 
                 global_type = global_idx < module->import_global_count
@@ -7320,7 +7516,7 @@ re_scan:
                 bool is_mutable = false;
 
                 p_org = p - 1;
-                read_leb_uint32(p, p_end, global_idx);
+                pb_read_leb_uint32(p, p_end, global_idx);
                 bh_assert(global_idx < global_count);
 
                 is_mutable = global_idx < module->import_global_count
@@ -7417,8 +7613,8 @@ re_scan:
                 }
 #endif
                 CHECK_MEMORY();
-                read_leb_memarg(p, p_end, align);          /* align */
-                read_leb_mem_offset(p, p_end, mem_offset); /* offset */
+                pb_read_leb_memarg(p, p_end, align);          /* align */
+                pb_read_leb_mem_offset(p, p_end, mem_offset); /* offset */
 #if WASM_ENABLE_FAST_INTERP != 0
                 emit_uint32(loader_ctx, mem_offset);
 #endif
@@ -7479,7 +7675,7 @@ re_scan:
 
             case WASM_OP_MEMORY_SIZE:
                 CHECK_MEMORY();
-                read_leb_memidx(p, p_end, memidx);
+                pb_read_leb_memidx(p, p_end, memidx);
                 check_memidx(module, memidx);
                 PUSH_PAGE_COUNT();
 
@@ -7491,7 +7687,7 @@ re_scan:
 
             case WASM_OP_MEMORY_GROW:
                 CHECK_MEMORY();
-                read_leb_memidx(p, p_end, memidx);
+                pb_read_leb_memidx(p, p_end, memidx);
                 check_memidx(module, memidx);
                 POP_AND_PUSH(mem_offset_type, mem_offset_type);
 
@@ -7506,7 +7702,7 @@ re_scan:
                 break;
 
             case WASM_OP_I32_CONST:
-                read_leb_int32(p, p_end, i32_const);
+                pb_read_leb_int32(p, p_end, i32_const);
 #if WASM_ENABLE_FAST_INTERP != 0
                 skip_label();
                 disable_emit = true;
@@ -7524,7 +7720,7 @@ re_scan:
                 break;
 
             case WASM_OP_I64_CONST:
-                read_leb_int64(p, p_end, i64_const);
+                pb_read_leb_int64(p, p_end, i64_const);
 #if WASM_ENABLE_FAST_INTERP != 0
                 skip_label();
                 disable_emit = true;
@@ -7806,7 +8002,7 @@ re_scan:
             {
                 uint32 opcode1;
 
-                read_leb_uint32(p, p_end, opcode1);
+                pb_read_leb_uint32(p, p_end, opcode1);
 #if WASM_ENABLE_FAST_INTERP != 0
                 emit_byte(loader_ctx, ((uint8)opcode1));
 #endif
@@ -7831,11 +8027,11 @@ re_scan:
                     case WASM_OP_MEMORY_INIT:
                     {
                         CHECK_MEMORY();
-                        read_leb_uint32(p, p_end, segment_index);
+                        pb_read_leb_uint32(p, p_end, segment_index);
 #if WASM_ENABLE_FAST_INTERP != 0
                         emit_uint32(loader_ctx, segment_index);
 #endif
-                        read_leb_memidx(p, p_end, memidx);
+                        pb_read_leb_memidx(p, p_end, memidx);
                         check_memidx(module, memidx);
 
                         bh_assert(segment_index < module->data_seg_count);
@@ -7851,7 +8047,7 @@ re_scan:
                     }
                     case WASM_OP_DATA_DROP:
                     {
-                        read_leb_uint32(p, p_end, segment_index);
+                        pb_read_leb_uint32(p, p_end, segment_index);
 #if WASM_ENABLE_FAST_INTERP != 0
                         emit_uint32(loader_ctx, segment_index);
 #endif
@@ -7867,9 +8063,9 @@ re_scan:
                         CHECK_MEMORY();
                         CHECK_BUF(p, p_end, sizeof(int16));
                         /* check both src and dst memory index */
-                        read_leb_memidx(p, p_end, memidx);
+                        pb_read_leb_memidx(p, p_end, memidx);
                         check_memidx(module, memidx);
-                        read_leb_memidx(p, p_end, memidx);
+                        pb_read_leb_memidx(p, p_end, memidx);
                         check_memidx(module, memidx);
 
                         POP_MEM_OFFSET();
@@ -7883,7 +8079,7 @@ re_scan:
                     case WASM_OP_MEMORY_FILL:
                     {
                         CHECK_MEMORY();
-                        read_leb_memidx(p, p_end, memidx);
+                        pb_read_leb_memidx(p, p_end, memidx);
                         check_memidx(module, memidx);
 
                         POP_MEM_OFFSET();
@@ -7901,8 +8097,8 @@ re_scan:
                         uint8 seg_ref_type, tbl_ref_type;
                         uint32 table_seg_idx, table_idx;
 
-                        read_leb_uint32(p, p_end, table_seg_idx);
-                        read_leb_uint32(p, p_end, table_idx);
+                        pb_read_leb_uint32(p, p_end, table_seg_idx);
+                        pb_read_leb_uint32(p, p_end, table_idx);
 
                         if (!get_table_elem_type(module, table_idx,
                                                  &tbl_ref_type, error_buf,
@@ -7937,7 +8133,7 @@ re_scan:
                     case WASM_OP_ELEM_DROP:
                     {
                         uint32 table_seg_idx;
-                        read_leb_uint32(p, p_end, table_seg_idx);
+                        pb_read_leb_uint32(p, p_end, table_seg_idx);
                         if (!get_table_seg_elem_type(module, table_seg_idx,
                                                      NULL, error_buf,
                                                      error_buf_size))
@@ -7953,13 +8149,13 @@ re_scan:
                         uint32 src_tbl_idx, dst_tbl_idx, src_tbl_idx_type,
                             dst_tbl_idx_type, min_tbl_idx_type;
 
-                        read_leb_uint32(p, p_end, src_tbl_idx);
+                        pb_read_leb_uint32(p, p_end, src_tbl_idx);
                         if (!get_table_elem_type(module, src_tbl_idx,
                                                  &src_ref_type, error_buf,
                                                  error_buf_size))
                             goto fail;
 
-                        read_leb_uint32(p, p_end, dst_tbl_idx);
+                        pb_read_leb_uint32(p, p_end, dst_tbl_idx);
                         if (!get_table_elem_type(module, dst_tbl_idx,
                                                  &dst_ref_type, error_buf,
                                                  error_buf_size))
@@ -8006,7 +8202,7 @@ re_scan:
                     {
                         uint32 table_idx;
 
-                        read_leb_uint32(p, p_end, table_idx);
+                        pb_read_leb_uint32(p, p_end, table_idx);
                         /* TODO: shall we create a new function to check
                                  table idx instead of using below function? */
                         if (!get_table_elem_type(module, table_idx, NULL,
@@ -8031,7 +8227,7 @@ re_scan:
                         uint8 decl_ref_type;
                         uint32 table_idx;
 
-                        read_leb_uint32(p, p_end, table_idx);
+                        pb_read_leb_uint32(p, p_end, table_idx);
                         if (!get_table_elem_type(module, table_idx,
                                                  &decl_ref_type, error_buf,
                                                  error_buf_size))
@@ -8083,15 +8279,15 @@ re_scan:
             {
                 uint32 opcode1;
 
-                read_leb_uint32(p, p_end, opcode1);
+                pb_read_leb_uint32(p, p_end, opcode1);
 
 #if WASM_ENABLE_FAST_INTERP != 0
                 emit_byte(loader_ctx, opcode1);
 #endif
                 if (opcode1 != WASM_OP_ATOMIC_FENCE) {
                     CHECK_MEMORY();
-                    read_leb_uint32(p, p_end, align);          /* align */
-                    read_leb_mem_offset(p, p_end, mem_offset); /* offset */
+                    pb_read_leb_uint32(p, p_end, align);          /* align */
+                    pb_read_leb_mem_offset(p, p_end, mem_offset); /* offset */
 #if WASM_ENABLE_FAST_INTERP != 0
                     emit_uint32(loader_ctx, mem_offset);
 #endif
@@ -8241,29 +8437,25 @@ re_scan:
     if (loader_ctx->p_code_compiled == NULL)
         goto re_scan;
 
-    func->const_cell_num = loader_ctx->const_cell_num;
+    func->const_cell_num =
+        loader_ctx->i64_const_num * 2 + loader_ctx->i32_const_num;
     if (func->const_cell_num > 0) {
-        int32 j;
-
-        if (!(func->consts = func_const = loader_malloc(
-                  func->const_cell_num * 4, error_buf, error_buf_size)))
+        if (!(func->consts =
+                  loader_malloc((uint64)sizeof(uint32) * func->const_cell_num,
+                                error_buf, error_buf_size)))
             goto fail;
-
-        func_const_end = func->consts + func->const_cell_num * 4;
-        /* reverse the const buf */
-        for (j = loader_ctx->num_const - 1; j >= 0; j--) {
-            Const *c = (Const *)(loader_ctx->const_buf + j * sizeof(Const));
-            if (c->value_type == VALUE_TYPE_F64
-                || c->value_type == VALUE_TYPE_I64) {
-                bh_memcpy_s(func_const, (uint32)(func_const_end - func_const),
-                            &(c->value.f64), (uint32)sizeof(int64));
-                func_const += sizeof(int64);
-            }
-            else {
-                bh_memcpy_s(func_const, (uint32)(func_const_end - func_const),
-                            &(c->value.f32), (uint32)sizeof(int32));
-                func_const += sizeof(int32);
-            }
+        if (loader_ctx->i64_const_num > 0) {
+            bh_memcpy_s(func->consts,
+                        (uint32)sizeof(int64) * loader_ctx->i64_const_num,
+                        loader_ctx->i64_consts,
+                        (uint32)sizeof(int64) * loader_ctx->i64_const_num);
+        }
+        if (loader_ctx->i32_const_num > 0) {
+            bh_memcpy_s(func->consts
+                            + sizeof(int64) * loader_ctx->i64_const_num,
+                        (uint32)sizeof(int32) * loader_ctx->i32_const_num,
+                        loader_ctx->i32_consts,
+                        (uint32)sizeof(int32) * loader_ctx->i32_const_num);
         }
     }
 

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_import->import_global_linked->init_expr),
-                        sizeof(WASMValue));
+            global->initial_value =
+                global_import->import_global_linked->init_expr.u;
         }
         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);
         }
     }
@@ -4660,7 +4660,7 @@ llvm_jit_table_init(WASMModuleInstance *module_inst, uint32 tbl_idx,
             if (!(func_obj = wasm_create_func_obj(module_inst,
                                                   init_values[i].u.ref_index,
                                                   true, NULL, 0))) {
-                wasm_set_exception(module_inst, "null function object");
+                wasm_set_exception(module_inst, "null function reference");
                 return;
             }
             table_elems[i] = func_obj;

core/iwasm/libraries/wasi-nn/cmake/wasi_nn.cmake

@@ -22,6 +22,7 @@ add_compile_definitions(
 # - tflite
 if(WAMR_BUILD_WASI_NN_TFLITE EQUAL 1)
   find_package(tensorflow_lite REQUIRED)
+  enable_language(CXX)
 
   add_library(
     wasi_nn_tflite

core/iwasm/libraries/wasi-nn/test/Dockerfile.wasi-nn-smoke

@@ -13,7 +13,7 @@ RUN apt-get update \
   && apt-get upgrade -y \
   && apt-get install -y --no-install-recommends cmake
 
-RUN rustup target add wasm32-wasi
+RUN rustup target add wasm32-wasip1
 
 #
 # Openvino
@@ -37,10 +37,10 @@ WORKDIR /workspaces/wasi-nn
 RUN git clone --depth 1 https://github.com/bytecodealliance/wasi-nn.git .
 
 WORKDIR /workspaces/wasi-nn/rust/examples/classification-example/
-RUN cargo build --target=wasm32-wasi
+RUN cargo build --target=wasm32-wasip1
 
 WORKDIR /workspaces/wasi-nn/rust/examples/classification-example/build
-RUN cp ../target/wasm32-wasi/debug/wasi-nn-example.wasm . \
+RUN cp ../target/wasm32-wasip1/debug/wasi-nn-example.wasm . \
   && wget -q --no-clobber https://github.com/intel/openvino-rs/raw/main/crates/openvino/tests/fixtures/mobilenet/mobilenet.xml \
   && wget -q --no-clobber https://github.com/intel/openvino-rs/raw/main/crates/openvino/tests/fixtures/mobilenet/mobilenet.bin
 # There are model files(mobilenet*) and wasm files(wasi-nn-example.wasm) in the directory,
@@ -67,30 +67,30 @@ RUN git apply ./bump_wasi_nn_to_0_6_0.patch
 # recompile with wasi-nn 0.6.0
 WORKDIR /workspaces/wasmedge-wasinn-examples/openvino-mobilenet-image/
 RUN pushd rust \
-  && cargo build --target=wasm32-wasi \
+  && cargo build --target=wasm32-wasip1 \
   && popd \
   && ./download_mobilenet.sh . \
   && ls -l mobilenet.xml mobilenet.bin
 
 WORKDIR /workspaces/wasmedge-wasinn-examples/openvino-mobilenet-raw/
 RUN pushd rust \
-  && cargo build --target=wasm32-wasi \
+  && cargo build --target=wasm32-wasip1 \
   && popd \
   && ./download_mobilenet.sh . \
   && ls -l mobilenet.xml mobilenet.bin tensor-1x224x224x3-f32.bgr
 
 WORKDIR /workspaces/wasmedge-wasinn-examples/openvino-road-segmentation-adas/
 RUN pushd openvino-road-seg-adas \
-  && cargo build --target=wasm32-wasi
+  && cargo build --target=wasm32-wasip1
 
 WORKDIR /workspaces/wasmedge-wasinn-examples/tflite-birds_v1-image/
 RUN pushd rust \
-  && cargo build --target=wasm32-wasi
+  && cargo build --target=wasm32-wasip1
 
 # mount models when running
 WORKDIR /workspaces/wasmedge-wasinn-examples/wasmedge-ggml/qwen
 RUN wget --progress=dot:giga https://www.modelscope.cn/models/qwen/Qwen1.5-0.5B-Chat-GGUF/resolve/master/qwen1_5-0_5b-chat-q2_k.gguf
-RUN cargo build --target=wasm32-wasi
+RUN cargo build --target=wasm32-wasip1
 
 #
 # iwasm. build from source
@@ -107,7 +107,7 @@ RUN OpenVINO_DIR=/usr/lib/openvino-2023.2.0 \
     -DWAMR_BUILD_WASI_NN_LLAMACPP=1 \
   && cmake --build build \
   && cmake --install build
- 
+
 ENV LD_LIBRARY_PATH=/usr/local/lib
 
 # add smoke test script

core/iwasm/libraries/wasi-nn/test/run_smoke_test.py

@@ -53,7 +53,7 @@ def execute_openvino_road_segmentation_adas_once(
     """
 
     wasm_file = (
-        "./openvino-road-seg-adas/target/wasm32-wasi/debug/openvino-road-seg-adas.wasm"
+        "./openvino-road-seg-adas/target/wasm32-wasip1/debug/openvino-road-seg-adas.wasm"
     )
     wasm_args = [
         "./model/road-segmentation-adas-0001.xml",
@@ -70,7 +70,7 @@ def execute_openvino_mobilenet_raw_once(
     execute openvino-mobilenet-image with iwasm and wasmedge
     """
 
-    wasm_file = "./rust/target/wasm32-wasi/debug/wasmedge-wasinn-example-mobilenet.wasm"
+    wasm_file = "./rust/target/wasm32-wasip1/debug/wasmedge-wasinn-example-mobilenet.wasm"
     wasm_args = [
         "mobilenet.xml",
         "mobilenet.bin",
@@ -87,7 +87,7 @@ def execute_openvino_mobilenet_image_once(
     """
 
     wasm_file = (
-        "./rust/target/wasm32-wasi/debug/wasmedge-wasinn-example-mobilenet-image.wasm"
+        "./rust/target/wasm32-wasip1/debug/wasmedge-wasinn-example-mobilenet-image.wasm"
     )
     wasm_args = [
         "mobilenet.xml",
@@ -105,7 +105,7 @@ def execute_tflite_birds_v1_image_once(
     """
 
     wasm_file = (
-        "rust/target/wasm32-wasi/debug/wasmedge-wasinn-example-tflite-bird-image.wasm"
+        "rust/target/wasm32-wasip1/debug/wasmedge-wasinn-example-tflite-bird-image.wasm"
     )
     wasm_args = ["lite-model_aiy_vision_classifier_birds_V1_3.tflite", "bird.jpg"]
     return execute_once(runtime_bin, runtime_args, wasm_file, wasm_args, cwd)
@@ -262,7 +262,7 @@ def execute_openvino_road_segmentation_adas(
 
 def execute_wasmedge_ggml_qwen(iwasm_bin: str, wasmedge_bin: str, cwd: Path):
     iwasm_args = ["--dir=."]
-    wasm_file = ["./target/wasm32-wasi/debug/wasmedge-ggml-qwen.wasm"]
+    wasm_file = ["./target/wasm32-wasip1/debug/wasmedge-ggml-qwen.wasm"]
     wasm_args = ["./qwen1_5-0_5b-chat-q2_k.gguf"]
 
     cmd = [iwasm_bin]

core/shared/platform/common/posix/posix_memmap.c

@@ -61,14 +61,16 @@ os_mmap(void *hint, size_t size, int prot, int flags, os_file_handle file)
         request_size += HUGE_PAGE_SIZE;
 #endif
 
-    if ((size_t)request_size < size)
-        /* integer overflow */
+    if ((size_t)request_size < size) {
+        os_printf("mmap failed: request size overflow due to paging\n");
         return NULL;
+    }
 
 #if WASM_ENABLE_MEMORY64 == 0
-    if (request_size > 16 * (uint64)UINT32_MAX)
-        /* at most 64 G is allowed */
+    if (request_size > 16 * (uint64)UINT32_MAX) {
+        os_printf("mmap failed: for memory64 at most 64G is allowed\n");
         return NULL;
+    }
 #endif
 
     if (prot & MMAP_PROT_READ)
@@ -155,7 +157,7 @@ os_mmap(void *hint, size_t size, int prot, int flags, os_file_handle file)
 
     if (addr == MAP_FAILED) {
         os_printf("mmap failed with errno: %d, hint: %p, size: %" PRIu64
-                  ", prot: %d, flags: %d",
+                  ", prot: %d, flags: %d\n",
                   errno, hint, request_size, map_prot, map_flags);
         return NULL;
     }

core/shared/platform/common/posix/posix_thread.c

@@ -712,6 +712,13 @@ os_thread_signal_init(os_signal_handler handler)
 #if WASM_DISABLE_STACK_HW_BOUND_CHECK == 0
     sigalt_stack_base_addr = map_addr;
 #endif
+
+#if defined(os_thread_local_attribute)
+    // calculate and cache the new stack boundary.
+    // see https://github.com/bytecodealliance/wasm-micro-runtime/issues/3966
+    (void)os_thread_get_stack_boundary();
+#endif
+
     signal_handler = handler;
     thread_signal_inited = true;
     return 0;

core/shared/platform/linux-sgx/sgx_platform.c

@@ -149,8 +149,10 @@ os_mmap(void *hint, size_t size, int prot, int flags, os_file_handle file)
     page_size = getpagesize();
     aligned_size = (size + page_size - 1) & ~(page_size - 1);
 
-    if (aligned_size >= UINT32_MAX)
+    if (aligned_size >= UINT32_MAX) {
+        os_printf("mmap failed: request size overflow due to paging\n");
         return NULL;
+    }
 
     ret = sgx_alloc_rsrv_mem(aligned_size);
     if (ret == NULL) {

core/shared/platform/windows/shared_platform.cmake

@@ -6,6 +6,7 @@ set (PLATFORM_SHARED_DIR ${CMAKE_CURRENT_LIST_DIR})
 add_definitions(-DBH_PLATFORM_WINDOWS)
 add_definitions(-DHAVE_STRUCT_TIMESPEC)
 add_definitions(-D_WINSOCK_DEPRECATED_NO_WARNINGS)
+enable_language(CXX)
 
 include_directories(${PLATFORM_SHARED_DIR})
 include_directories(${PLATFORM_SHARED_DIR}/../include)

core/shared/platform/windows/win_clock.c

@@ -10,9 +10,21 @@
 #define NANOSECONDS_PER_SECOND 1000000000ULL
 #define NANOSECONDS_PER_TICK 100
 
-extern NTSTATUS
-NtQueryTimerResolution(PULONG MinimumResolution, PULONG MaximumResolution,
-                       PULONG CurrentResolution);
+#if WINAPI_PARTITION_DESKTOP
+#ifndef __kernel_entry
+#define __kernel_entry
+#endif
+#ifndef NTAPI
+#define NTAPI
+#endif
+#ifndef _Out_
+#define _Out_
+#endif
+extern __kernel_entry NTSTATUS NTAPI
+NtQueryTimerResolution(_Out_ PULONG MinimumResolution,
+                       _Out_ PULONG MaximumResolution,
+                       _Out_ 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_memmap.c

@@ -39,9 +39,10 @@ os_mmap(void *hint, size_t size, int prot, int flags, os_file_handle file)
     page_size = os_getpagesize();
     request_size = (size + page_size - 1) & ~(page_size - 1);
 
-    if (request_size < size)
-        /* integer overflow */
+    if (request_size < size) {
+        printf("mmap failed: request size overflow due to paging\n");
         return NULL;
+    }
 
 #if WASM_ENABLE_JIT != 0
     /**

core/shared/platform/windows/win_thread.c

@@ -71,6 +71,63 @@ os_sem_reltimed_wait(korp_sem *sem, uint64 useconds);
 int
 os_sem_signal(korp_sem *sem);
 
+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_thread_sys_init()
 {
@@ -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->next = supervisor_thread_data.next;
-    supervisor_thread_data.next = thread_data;
-    os_mutex_unlock(&thread_data_list_lock);
+    thread_data_list_add(thread_data);
 
     /* 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;
-    bh_assert(thread_data);
+    thread_data = thread_data_list_lookup(thread);
+
+    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)
     sem_init(&node->sem, 0, 1);
     node->next = NULL;
 
-    /* Get thread data */
-    thread_data = thread_data_list_lookup(thread);
-    bh_assert(thread_data != NULL);
-
     mutex_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,23 @@ os_time_get_boot_us()
 uint64
 os_time_thread_cputime_us(void)
 {
-    /* FIXME if u know the right api */
+    /* On certain boards, enabling userspace could impact the collection of
+     * thread runtime statistics */
+#ifdef CONFIG_THREAD_RUNTIME_STATS
+    k_tid_t tid;
+    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;
+#else
     return os_time_get_boot_us();
+#endif
 }

core/shared/utils/bh_assert.h

@@ -26,7 +26,7 @@ bh_assert_internal(int64 v, const char *file_name, int line_number,
 #define __has_extension(a) 0
 #endif
 
-#if __STDC_VERSION__ >= 201112L                                          \
+#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L)           \
     || (defined(__GNUC__) && __GNUC__ * 0x100 + __GNUC_MINOR__ >= 0x406) \
     || __has_extension(c_static_assert)
 

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

core/version.h

@@ -3,9 +3,22 @@
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  */
 
+/*
+ * version.h.in is a template file.  version.h is a generated file.
+ * Please do not edit both files directly.
+ *
+ * Any changes to the version should be done in build-scripts/version.cmake.
+ *
+ * Continue to maintain the version.h for certain embedded platforms.
+ */
+
 #ifndef _WAMR_VERSION_H_
 #define _WAMR_VERSION_H_
+
+/* clang-format off */
 #define WAMR_VERSION_MAJOR 2
 #define WAMR_VERSION_MINOR 2
 #define WAMR_VERSION_PATCH 0
+/* clang-format on */
+
 #endif

core/version.h.in

@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+/*
+ * version.h.in is a template file.  version.h is a generated file.
+ * Please do not edit both files directly.
+ *
+ * Any changes to the version should be done in build-scripts/version.cmake.
+ *
+ * Continue to maintain the version.h for certain embedded platforms.
+ */
+
+#ifndef _WAMR_VERSION_H_
+#define _WAMR_VERSION_H_
+
+/* clang-format off */
+#define WAMR_VERSION_MAJOR @WAMR_VERSION_MAJOR@
+#define WAMR_VERSION_MINOR @WAMR_VERSION_MINOR@
+#define WAMR_VERSION_PATCH @WAMR_VERSION_PATCH@
+/* clang-format on */
+
+#endif

doc/build_wamr.md

@@ -20,7 +20,7 @@ add_library(vmlib ${WAMR_RUNTIME_LIB_SOURCE})
 
 The script `runtime_lib.cmake` defines a number of variables for configuring the WAMR runtime features. You can set these variables in your CMakeList.txt or pass the configurations from cmake command line.
 
-#### **Configure platform and architecture**
+### **Configure platform and architecture**
 
 - **WAMR_BUILD_PLATFORM**:  set the target platform. It can be set to any platform name (folder name) under folder [core/shared/platform](../core/shared/platform).
 
@@ -34,7 +34,7 @@ The script `runtime_lib.cmake` defines a number of variables for configuring the
 cmake -DWAMR_BUILD_PLATFORM=linux -DWAMR_BUILD_TARGET=ARM
 ```
 
-#### **Configure interpreters**
+### **Configure interpreters**
 
 - **WAMR_BUILD_INTERP**=1/0: enable or disable WASM interpreter
 
@@ -42,14 +42,14 @@ cmake -DWAMR_BUILD_PLATFORM=linux -DWAMR_BUILD_TARGET=ARM
 
   NOTE: the fast interpreter runs ~2X faster than classic interpreter, but consumes about 2X memory to hold the pre-compiled code.
 
-#### **Configure AOT and JITs**
+### **Configure AOT and JITs**
 
 - **WAMR_BUILD_AOT**=1/0, enable AOT or not, default to enable if not set
 - **WAMR_BUILD_JIT**=1/0, enable LLVM JIT or not, default to disable if not set
 - **WAMR_BUILD_FAST_JIT**=1/0, enable Fast JIT or not, default to disable if not set
 - **WAMR_BUILD_FAST_JIT**=1 and **WAMR_BUILD_JIT**=1, enable Multi-tier JIT, default to disable if not set
 
-#### **Configure LIBC**
+### **Configure LIBC**
 
 - **WAMR_BUILD_LIBC_BUILTIN**=1/0, build the built-in libc subset for WASM app, default to enable if not set
 
@@ -59,98 +59,98 @@ cmake -DWAMR_BUILD_PLATFORM=linux -DWAMR_BUILD_TARGET=ARM
 
 > Note: for platform which doesn't support **WAMR_BUILD_LIBC_WASI**, e.g. Windows, developer can try using **WAMR_BUILD_LIBC_UVWASI**.
 
-#### **Enable Multi-Module feature**
+### **Enable Multi-Module feature**
 
 - **WAMR_BUILD_MULTI_MODULE**=1/0, default to disable if not set
 > Note: See [Multiple Modules as Dependencies](./multi_module.md) for more details.
 
-#### **Enable WASM mini loader**
+### **Enable WASM mini loader**
 
 - **WAMR_BUILD_MINI_LOADER**=1/0, default to disable if not set
 
 > Note: the mini loader doesn't check the integrity of the WASM binary file, developer must ensure that the WASM file is well-formed.
 
-#### **Enable shared memory feature**
+### **Enable shared memory feature**
 - **WAMR_BUILD_SHARED_MEMORY**=1/0, default to disable if not set
 
-#### **Enable bulk memory feature**
+### **Enable bulk memory feature**
 - **WAMR_BUILD_BULK_MEMORY**=1/0, default to disable if not set
 
-#### **Enable memory64 feature**
+### **Enable memory64 feature**
 - **WAMR_BUILD_MEMORY64**=1/0, default to disable if not set
 
 > Note: Currently, the memory64 feature is only supported in classic interpreter running mode and AOT mode.
 
-#### **Enable thread manager**
+### **Enable thread manager**
 - **WAMR_BUILD_THREAD_MGR**=1/0, default to disable if not set
 
-#### **Enable lib-pthread**
+### **Enable lib-pthread**
 - **WAMR_BUILD_LIB_PTHREAD**=1/0, default to disable if not set
 > Note: The dependent feature of lib pthread such as the `shared memory` and `thread manager` will be enabled automatically.
 
 > See [WAMR pthread library](./pthread_library.md) for more details.
 
-#### **Enable lib-pthread-semaphore**
+### **Enable lib-pthread-semaphore**
 - **WAMR_BUILD_LIB_PTHREAD_SEMAPHORE**=1/0, default to disable if not set
 > Note: This feature depends on `lib-pthread`, it will be enabled automatically if this feature is enabled.
 
-#### **Enable lib wasi-threads**
+### **Enable lib wasi-threads**
 - **WAMR_BUILD_LIB_WASI_THREADS**=1/0, default to disable if not set
 > Note: The dependent feature of lib wasi-threads such as the `shared memory` and `thread manager` will be enabled automatically.
 
 > See [wasi-threads](./pthread_impls.md#wasi-threads-new) and [Introduction to WAMR WASI threads](https://bytecodealliance.github.io/wamr.dev/blog/introduction-to-wamr-wasi-threads) for more details.
 
-#### **Enable lib wasi-nn**
+### **Enable lib wasi-nn**
 - **WAMR_BUILD_WASI_NN**=1/0, default to disable if not set
 > Note: See [WASI-NN](../core/iwasm/libraries/wasi-nn) for more details.
 
-#### **Enable lib wasi-nn GPU mode**
+### **Enable lib wasi-nn GPU mode**
 - **WAMR_BUILD_WASI_NN_ENABLE_GPU**=1/0, default to disable if not set
 
-#### **Enable lib wasi-nn external delegate mode**
+### **Enable lib wasi-nn external delegate mode**
 - **WAMR_BUILD_WASI_NN_ENABLE_EXTERNAL_DELEGATE**=1/0, default to disable if not set
 
 - **WAMR_BUILD_WASI_NN_EXTERNAL_DELEGATE_PATH**=Path to the external delegate shared library (e.g. `libedgetpu.so.1.0` for Coral USB)
 
-#### **Enable lib wasi-nn with `wasi_ephemeral_nn` module support**
+### **Enable lib wasi-nn with `wasi_ephemeral_nn` module support**
 - **WAMR_BUILD_WASI_EPHEMERAL_NN**=1/0, default to disable if not set
 
-#### **Disable boundary check with hardware trap**
+### **Disable boundary check with hardware trap**
 - **WAMR_DISABLE_HW_BOUND_CHECK**=1/0, default to enable if not set and supported by platform
 > Note: by default only platform [linux/darwin/android/windows/vxworks 64-bit](https://github.com/bytecodealliance/wasm-micro-runtime/blob/5fb5119239220b0803e7045ca49b0a29fe65e70e/core/shared/platform/linux/platform_internal.h#L81) will enable the boundary check with hardware trap feature, for 32-bit platforms it's automatically disabled even when the flag is set to 0, and the wamrc tool will generate AOT code without boundary check instructions in all 64-bit targets except SGX to improve performance. The boundary check includes linear memory access boundary and native stack access boundary, if `WAMR_DISABLE_STACK_HW_BOUND_CHECK` below isn't set.
 
-#### **Disable native stack boundary check with hardware trap**
+### **Disable native stack boundary check with hardware trap**
 - **WAMR_DISABLE_STACK_HW_BOUND_CHECK**=1/0, default to enable if not set and supported by platform, same as `WAMR_DISABLE_HW_BOUND_CHECK`.
 > Note: When boundary check with hardware trap is disabled, or `WAMR_DISABLE_HW_BOUND_CHECK` is set to 1, the native stack boundary check with hardware trap will be disabled too, no matter what value is set to `WAMR_DISABLE_STACK_HW_BOUND_CHECK`. And when boundary check with hardware trap is enabled, the status of this feature is set according to the value of `WAMR_DISABLE_STACK_HW_BOUND_CHECK`.
 
-#### **Disable async wakeup of blocking operation**
+### **Disable async wakeup of blocking operation**
 - **WAMR_DISABLE_WAKEUP_BLOCKING_OP**=1/0, default to enable if supported by the platform
 > Note: The feature helps async termination of blocking threads. If you disable it, the runtime can wait for termination of blocking threads possibly forever.
 
-#### **Enable tail call feature**
+### **Enable tail call feature**
 - **WAMR_BUILD_TAIL_CALL**=1/0, default to disable if not set
 
-#### **Enable 128-bit SIMD feature**
+### **Enable 128-bit SIMD feature**
 - **WAMR_BUILD_SIMD**=1/0, default to enable if not set
 > Note: only supported in AOT mode x86-64 target.
 
-#### **Enable Exception Handling**
+### **Enable Exception Handling**
 - **WAMR_BUILD_EXCE_HANDLING**=1/0, default to disable if not set
 
 > Note: Currently, the exception handling feature is only supported in classic interpreter running mode.
 
-#### **Enable Garbage Collection**
+### **Enable Garbage Collection**
 - **WAMR_BUILD_GC**=1/0, default to disable if not set
 
-#### **Configure Debug**
+### **Configure Debug**
 
 - **WAMR_BUILD_CUSTOM_NAME_SECTION**=1/0, load the function name from custom name section, default to disable if not set
 
-#### **Enable AOT stack frame feature**
+### **Enable AOT stack frame feature**
 - **WAMR_BUILD_AOT_STACK_FRAME**=1/0, default to disable if not set
 > Note: if it is enabled, the AOT or JIT stack frames (like stack frame of classic interpreter but only necessary data is committed) will be created for AOT or JIT mode in function calls. And please add `--enable-dump-call-stack` option to wamrc during compiling AOT module.
 
-#### **Enable dump call stack feature**
+### **Enable dump call stack feature**
 - **WAMR_BUILD_DUMP_CALL_STACK**=1/0, default to disable if not set
 
 > Note: if it is enabled, the call stack will be dumped when exception occurs.
@@ -158,14 +158,14 @@ cmake -DWAMR_BUILD_PLATFORM=linux -DWAMR_BUILD_TARGET=ARM
 > - For interpreter mode, the function names are firstly extracted from *custom name section*, if this section doesn't exist or the feature is not enabled, then the name will be extracted from the import/export sections
 > - For AOT/JIT mode, the function names are extracted from import/export section, please export as many functions as possible (for `wasi-sdk` you can use `-Wl,--export-all`) when compiling wasm module, and add `--enable-dump-call-stack --emit-custom-sections=name` option to wamrc during compiling AOT module.
 
-#### **Enable memory profiling (Experiment)**
+### **Enable memory profiling (Experiment)**
 - **WAMR_BUILD_MEMORY_PROFILING**=1/0, default to disable if not set
 > Note: if it is enabled, developer can use API `void wasm_runtime_dump_mem_consumption(wasm_exec_env_t exec_env)` to dump the memory consumption info.
 Currently we only profile the memory consumption of module, module_instance and exec_env, the memory consumed by other components such as `wasi-ctx`, `multi-module` and `thread-manager` are not included.
 
 > Also refer to [Memory usage estimation for a module](./memory_usage.md).
 
-#### **Enable performance profiling (Experiment)**
+### **Enable performance profiling (Experiment)**
 - **WAMR_BUILD_PERF_PROFILING**=1/0, default to disable if not set
 > Note: if it is enabled, developer can use API `void wasm_runtime_dump_perf_profiling(wasm_module_inst_t module_inst)` to dump the performance consumption info. Currently we only profile the performance consumption of each WASM function.
 
@@ -173,24 +173,24 @@ Currently we only profile the memory consumption of module, module_instance and
 
 > Also refer to [Tune the performance of running wasm/aot file](./perf_tune.md).
 
-#### **Enable the global heap**
+### **Enable the global heap**
 - **WAMR_BUILD_GLOBAL_HEAP_POOL**=1/0, default to disable if not set for all *iwasm* applications, except for the platforms Alios and Zephyr.
 
 > **WAMR_BUILD_GLOBAL_HEAP_POOL** is used in the *iwasm* applications provided in the directory `product-mini`. When writing your own host application using WAMR, if you want to use a global heap and allocate memory from it, you must set the initialization argument `mem_alloc_type` to `Alloc_With_Pool`.
 > The global heap is defined in the documentation [Memory model and memory usage tunning](memory_tune.md).
 
-#### **Set the global heap size**
+### **Set the global heap size**
 - **WAMR_BUILD_GLOBAL_HEAP_SIZE**=n, default to 10 MB (10485760) if not set for all *iwasm* applications, except for the platforms Alios (256 kB), Riot (256 kB) and Zephyr (128 kB).
 
 > **WAMR_BUILD_GLOBAL_HEAP_SIZE** is used in the *iwasm* applications provided in the directory `product-mini`. When writing your own host application using WAMR, if you want to set the amount of memory dedicated to the global heap pool, you must set the initialization argument `mem_alloc_option.pool` with the appropriate values.
 > The global heap is defined in the documentation [Memory model and memory usage tunning](memory_tune.md).
 > Note: if `WAMR_BUILD_GLOBAL_HEAP_SIZE` is not set and the flag `WAMR_BUILD_SPEC_TEST` is set, the global heap size is equal to 300 MB (314572800), or 100 MB (104857600) when compiled for Intel SGX (Linux).
 
-#### **Set maximum app thread stack size**
+### **Set maximum app thread stack size**
 - **WAMR_APP_THREAD_STACK_SIZE_MAX**=n, default to 8 MB (8388608) if not set
 > Note: the AOT boundary check with hardware trap mechanism might consume large stack since the OS may lazily grow the stack mapping as a guard page is hit, we may use this configuration to reduce the total stack usage, e.g. -DWAMR_APP_THREAD_STACK_SIZE_MAX=131072 (128 KB).
 
-#### **Set vprintf callback**
+### **Set vprintf callback**
 - **WAMR_BH_VPRINTF**=<vprintf_callback>, default to disable if not set
 > Note: if the vprintf_callback function is provided by developer, the os_printf() and os_vprintf() in Linux, Darwin, Windows, VxWorks, Android and esp-idf platforms, besides WASI Libc output will call the callback function instead of libc vprintf() function to redirect the stdout output. For example, developer can define the callback function like below outside runtime lib:
 >
@@ -212,7 +212,7 @@ Currently we only profile the memory consumption of module, module_instance and
 >
 > and then use `cmake -DWAMR_BH_VPRINTF=my_vprintf ..` to pass the callback function, or add `BH_VPRINTF=my_vprintf` macro for the compiler, e.g. add line `add_definitions(-DBH_VPRINTF=my_vprintf)` in CMakeLists.txt. See [basic sample](../samples/basic/src/main.c) for a usage example.
 
-#### **WAMR_BH_LOG**=<log_callback>, default to disable if not set
+### **WAMR_BH_LOG**=<log_callback>, default to disable if not set
 > Note: if the log_callback function is provided by the developer, WAMR logs are redirected to such callback. For example:
 > ```C
 > void my_log(uint32 log_level, const char *file, int line, const char *fmt, ...)
@@ -222,20 +222,20 @@ 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
+### **Enable reference types feature**
+- **WAMR_BUILD_REF_TYPES**=1/0, default to enable if not set
 
-#### **Exclude WAMR application entry functions**
+### **Exclude WAMR application entry functions**
 - **WAMR_DISABLE_APP_ENTRY**=1/0, default to disable if not set
 
 > Note: The WAMR application entry (`core/iwasm/common/wasm_application.c`) encapsulate some common process to instantiate, execute the wasm functions and print the results. Some platform related APIs are used in these functions, so you can enable this flag to exclude this file if your platform doesn't support those APIs.
 > *Don't enable this flag if you are building `product-mini`*
 
-#### **Enable source debugging features**
+### **Enable source debugging features**
 - **WAMR_BUILD_DEBUG_INTERP**=1/0, default to 0 if not set
 > Note: There are some other setup required by source debugging, please refer to [source_debugging.md](./source_debugging.md) and [WAMR source debugging basic](https://bytecodealliance.github.io/wamr.dev/blog/wamr-source-debugging-basic) for more details.
 
-#### **Enable load wasm custom sections**
+### **Enable load wasm custom sections**
 - **WAMR_BUILD_LOAD_CUSTOM_SECTION**=1/0, default to disable if not set
 
 > Note: By default, the custom sections are ignored. If the embedder wants to get custom sections from `wasm_module_t`, then `WAMR_BUILD_LOAD_CUSTOM_SECTION` should be enabled, and then `wasm_runtime_get_custom_section` can be used to get a custom section by name.
@@ -244,29 +244,29 @@ Currently we only profile the memory consumption of module, module_instance and
 
 > For AoT file, must use `--emit-custom-sections` to specify which sections need to be emitted into AoT file, otherwise all custom sections will be ignored.
 
-#### **Stack guard size**
+### **Stack guard size**
 - **WAMR_BUILD_STACK_GUARD_SIZE**=n, default to N/A if not set.
 > Note: By default, the stack guard size is 1K (1024) or 24K (if uvwasi enabled).
 
-#### **Disable writing the linear memory base address to x86 GS segment register**
+### **Disable writing the linear memory base address to x86 GS segment register**
 - **WAMR_DISABLE_WRITE_GS_BASE**=1/0, default to enable if not set and supported by platform
 > Note: by default only platform [linux x86-64](https://github.com/bytecodealliance/wasm-micro-runtime/blob/5fb5119239220b0803e7045ca49b0a29fe65e70e/core/shared/platform/linux/platform_internal.h#L67) will enable this feature, for 32-bit platforms it's automatically disabled even when the flag is set to 0. In linux x86-64, writing the linear memory base address to x86 GS segment register may be used to speedup the linear memory access for LLVM AOT/JIT, when `--enable-segue=[<flags>]` option is added for `wamrc` or `iwasm`.
 
 > See [Enable segue optimization for wamrc when generating the aot file](./perf_tune.md#3-enable-segue-optimization-for-wamrc-when-generating-the-aot-file) for more details.
 
-#### **User defined linear memory allocator**
+### **User defined linear memory allocator**
 - **WAMR_BUILD_ALLOC_WITH_USAGE**=1/0, default to disable if not set
 > Notes: by default, the linear memory is allocated by system. when it's set to 1 and Alloc_With_Allocator is selected, it will be allocated by customer.
 
-#### **Enable running PGO(Profile-Guided Optimization) instrumented AOT file**
+### **Enable running PGO(Profile-Guided Optimization) instrumented AOT file**
 - **WAMR_BUILD_STATIC_PGO**=1/0, default to disable if not set
 > Note: See [Use the AOT static PGO method](./perf_tune.md#5-use-the-aot-static-pgo-method) for more details.
 
-#### **Enable linux perf support**
+### **Enable linux perf support**
 - **WAMR_BUILD_LINUX_PERF**=1/0, enable linux perf support to generate the flamegraph to analyze the performance of a wasm application, default to disable if not set
 > Note: See [Use linux-perf](./perf_tune.md#7-use-linux-perf) for more details.
 
-#### **Enable module instance context APIs**
+### **Enable module instance context APIs**
 - **WAMR_BUILD_MODULE_INST_CONTEXT**=1/0, enable module instance context APIs which can set one or more contexts created by the embedder for a wasm module instance, default to enable if not set:
 ```C
     wasm_runtime_create_context_key
@@ -277,19 +277,19 @@ Currently we only profile the memory consumption of module, module_instance and
 ```
 > Note: See [wasm_export.h](../core/iwasm/include/wasm_export.h) for more details.
 
-#### **Enable quick AOT/JTI entries**
+### **Enable quick AOT/JTI entries**
 - **WAMR_BUILD_QUICK_AOT_ENTRY**=1/0, enable registering quick call entries to speedup the aot/jit func call process, default to enable if not set
 > Note: See [Refine callings to AOT/JIT functions from host native](./perf_tune.md#83-refine-callings-to-aotjit-functions-from-host-native) for more details.
 
-#### **Enable AOT intrinsics**
+### **Enable AOT intrinsics**
 - **WAMR_BUILD_AOT_INTRINSICS**=1/0, enable the AOT intrinsic functions, default to enable if not set. These functions can be called from the AOT code when `--disable-llvm-intrinsics` flag or `--enable-builtin-intrinsics=<intr1,intr2,...>` flag is used by wamrc to generate the AOT file.
 > Note: See [Tuning the XIP intrinsic functions](./xip.md#tuning-the-xip-intrinsic-functions) for more details.
 
-#### **Configurable memory access boundary check**
+### **Configurable memory access boundary check**
 - **WAMR_CONFIGURABLE_BOUNDS_CHECKS**=1/0, default to disable if not set
 > Note: If it is enabled, allow to run `iwasm --disable-bounds-checks` to disable the memory access boundary checks for interpreter mode.
 
-#### **Module instance context APIs**
+### **Module instance context APIs**
 - **WAMR_BUILD_MODULE_INST_CONTEXT**=1/0, default to disable if not set
 > Note: If it is enabled, allow to set one or more contexts created by embedder for a module instance, the below APIs are provided:
 ```C
@@ -300,7 +300,7 @@ Currently we only profile the memory consumption of module, module_instance and
     wasm_runtime_get_context
 ```
 
-#### **Shared heap among wasm apps and host native**
+### **Shared heap among wasm apps and host native**
 - **WAMR_BUILD_SHARED_HEAP**=1/0, default to disable if not set
 > Note: If it is enabled, allow to create one or more shared heaps, and attach one to a module instance, the belows APIs ared provided:
 ```C
@@ -316,7 +316,11 @@ And the wasm app can calls below APIs to allocate/free memory from/to the shared
    void shared_heap_free(void *ptr);
 ```
 
-**Combination of configurations:**
+### **Shrunk the memory usage**
+- **WAMR_BUILD_SHRUNK_MEMORY**=1/0, default to enable if not set
+> Note: When enabled, this feature will reduce memory usage by decreasing the size of the linear memory, particularly when the `memory.grow` opcode is not used and memory usage is somewhat predictable.
+
+## **Combination of configurations:**
 
 We can combine the configurations. For example, if we want to disable interpreter, enable AOT and WASI, we can run command:
 
@@ -328,4 +332,4 @@ Or if we want to enable interpreter, disable AOT and WASI, and build as X86_32,
 
 ``` Bash
 cmake .. -DWAMR_BUILD_INTERP=1 -DWAMR_BUILD_AOT=0 -DWAMR_BUILD_LIBC_WASI=0 -DWAMR_BUILD_TARGET=X86_32
-```
+```

doc/build_wasm_app.md

@@ -16,24 +16,24 @@ For [AssemblyScript](https://github.com/AssemblyScript/assemblyscript), please r
 
 For Rust, please refer to [Install Rust and Cargo](https://doc.rust-lang.org/cargo/getting-started/installation.html) to install *cargo*, *rustc* and *rustup*. By default they are under ~/.cargo/bin.
 
-And then run such a command to install `wasm32-wasi` target.
+And then run such a command to install `wasm32-wasip1` target.
 
 ``` bash
-$ rustup target add wasm32-wasi
+$ rustup target add wasm32-wasip1
 ```
 
 To build WASM applications, run
 
 ``` bash
-$ cargo build --target wasm32-wasi
+$ cargo build --target wasm32-wasip1
 ```
 
-The output files are under `target/wasm32-wasi`.
+The output files are under `target/wasm32-wasip1`.
 
 To build a release version
 
 ``` bash
-$ cargo build --release --target wasm32-wasi
+$ cargo build --release --target wasm32-wasip1
 ```
 
 
@@ -377,15 +377,23 @@ Examples: wamrc -o test.aot test.wasm
 When making major ABI changes for AoT-compiled modules, we bump
 `AOT_CURRENT_VERSION` constant in `core/config.h` header.
 The runtime rejects to load a module AoT-compiled with wamrc with
-a different `AOT_CURRENT_VERSION`.
+a non-compatible`AOT_CURRENT_VERSION`.
 
 We try our best to maintain our runtime ABI for AoT-compiled modules
-compatible among WAMR versions with the same `AOT_CURRENT_VERSION`
+compatible among WAMR versions with compatible `AOT_CURRENT_VERSION`
 so that combinations of older wamrc and newer runtime usually work.
 However, there might be minor incompatibilities time to time.
-For productions, we recommend to use the exactly same version of
+For productions, we recommend to use compatible versions of
 wamrc and the runtime.
 
+| WAMR version | AOT_CURRENT_VERSION | Compatible AOT version |
+| ------------ | ------------------- | ---------------------- |
+| 1.x          | 3                   | 3                      |
+| 2.0.0        | 3                   | 3                      |
+| 2.1.x        | 3                   | 3                      |
+| 2.2.0        | 3                   | 3                      |
+| next         | 4                   | 3,4                    |
+
 ## AoT compilation with 3rd-party toolchains
 
 `wamrc` uses LLVM to compile wasm bytecode to AoT file, this works for most of the architectures, but there may be circumstances where you want to use 3rd-party toolchains to take over some steps of the compilation pipeline, e.g.

doc/memory_tune.md

@@ -32,3 +32,4 @@ Normally there are some methods to tune the memory usage:
 - use XIP mode, refer to [WAMR XIP (Execution In Place) feature introduction](./xip.md) for more details
 - when using the Wasm C API in fast interpreter or AOT mode, set `clone_wasm_binary=false` in `LoadArgs` and free the wasm binary buffer (with `wasm_byte_vec_delete`) after module loading; `wasm_module_is_underlying_binary_freeable` can be queried to check if the wasm binary buffer can be safely freed (see [the example](../samples/basic/src/free_buffer_early.c)); after the buffer is freed, `wasm_runtime_get_custom_section` cannot be called anymore
 - when using the wasm/AOT loader in fast interpreter or AOT mode, set `wasm_binary_freeable=true` in `LoadArgs` and free the wasm binary buffer (with `wasm_byte_vec_delete`) after module loading; `wasm_runtime_is_underlying_binary_freeable` can be queried to check if the wasm binary buffer can be safely freed; after the buffer is freed, `wasm_runtime_get_custom_section` cannot be called anymore
+- `WAMR_BUILD_SHRUNK_MEMORY` can be used to reduce the memory usage of WAMR, but it might affect the standard expected behavior of WAMR.

doc/security_need_to_know.md

@@ -0,0 +1,33 @@
+# About security issues
+
+This document aims to explain the process of identifying a security issue and the steps for managing a security issue.
+
+## identifying a security issue
+
+It is commonly stated that a security issue is an issue that:
+
+- Exposes sensitive information to unauthorized parties.
+- Allows unauthorized modification of data or system state.
+- Affects the availability of the system or its services.
+- Permits unauthorized access to the system.
+- Enables users to perform actions they should not be able to.
+- Allows users to deny actions they have performed.
+
+Given that WASI is a set of Capability-based APIs, all unauthorized actions are not supposed to happen. Most of the above security concerns can be alleviated. What remains for us is to ensure that the execution of Wasm modules is secure. In other words, do not compromise the sandbox. Unless it is explicitly disabled beforehand.
+
+Thus, we share most of the criteria for judging security issues with [the Bytecode Alliance](https://github.com/bytecodealliance/rfcs/blob/main/accepted/what-is-considered-a-security-bug.md#definition).
+
+> [!NOTE]
+> keep updating this document as the project evolves.
+
+## reporting a security issue
+
+Follow the [same guidelines](https://bytecodealliance.org/security) as other projects within the Bytecode Alliance.
+
+## managing a security issue
+
+Before reporting an issue, particularly one related to crashing, consult [the cheat sheet](https://github.com/bytecodealliance/rfcs/blob/main/accepted/what-is-considered-a-security-bug.md#cheat-sheet-is-this-bug-considered-a-security-vulnerability), _Report a security vulnerability_ if it qualifies.
+
+Upon receiving an issue, thoroughly review [the cheat sheet](https://github.com/bytecodealliance/rfcs/blob/main/accepted/what-is-considered-a-security-bug.md#cheat-sheet-is-this-bug-considered-a-security-vulnerability) to assess and _Report a security vulnerability_ if the issue is indeed a security vulnerability.
+
+Once a security issue is confirmed, please refer to [the runbook](https://github.com/bytecodealliance/rfcs/blob/main/accepted/vulnerability-response-runbook.md) for the subsequent steps to take.

doc/semantic_version.md

@@ -1,21 +0,0 @@
-# WAMR uses semantic versioning
-
-WAMR uses the _semantic versioning_ to replace the current _date versioning_ system.
-
-There are three parts in the new version string:
-
-- _major_. Any incompatible modification, on both ABI and APIs, will lead an increment
-  in the value of _major_. APIs includes: `wasm_export.h`, `wasm_c_api.h`,
-  _sections in AOT files_, and so on.
-- _minor_. It represents new features. It includes not just MVP or POST-MVP features
-  but also WASI features and WAMR private ones.
-- _patch_. It represents patches.
-
-## Legacy versions
-
-All legacy versions(tags) will keep their current status. No existing release names
-and links will be changed.
-
-## Reference
-
-- [Semantic Versioning 2.0.0](https://semver.org/)

doc/stability_release.md

@@ -0,0 +1,33 @@
+# Semantic Versioning
+
+WAMR has adopted [semantic versioning](https://semver.org/) to replace the former *date versioning system*.  The new version string consists of three parts:
+
+- *major*: Any change that is not compatible with previous versions, affecting either the ABI or APIs, will result in an increase in the major version number. APIs include: wasm_export.h, wasm_c_api.h, sections in AOT files, among others.
+- *minor*: This number increases with the addition of new features. This encompasses not only MVP (Minimum Viable Product) or POST-MVP features but also WebAssembly System Interface (WASI) features and WAMR-specific features.
+- *patch*: This number is incremented for patches.
+
+## Legacy releases
+
+All previous versions (tags) will retain their current status. There will be no changes to existing release names and links.
+
+# Release Process
+
+WAMR has been deployed across various devices. A frequent release cycle would strain customers' testing resources and add extra deployment work. Two factors can trigger a new WAMR release:
+
+- Community requests, particularly following the integration of significant and new features.
+- Security vulnerabilities and critical bug fixes that ensure correctness.
+
+Patch releases will be made only to address security vulnerabilities and critical issues related to default behavior in prior releases.
+
+Once a release decision has been made:
+
+- Create a PR that:
+  1. Modifies *build-scripts/version.cmake*.
+  2. Executes cmake configuration to update the version.
+  3. Updates *RELEASE_NOTES.md*.
+- A checklist of the PR includes
+  - [ ] *build-scripts/version.cmake*
+  - [ ] *core/version.h*
+  - [ ] *RELEASE_NOTES.md*
+- Once the PR is merged, create a new tag.
+- Initiate the release process by triggering *the binary release processes* in *Actions*.

doc/stability_wasm_proposals.md

@@ -0,0 +1,82 @@
+# Wasm Proposals
+
+This document is intended to describe the current status of WebAssembly proposals and WASI proposals in WAMR.
+
+Only track proposals that are followed in the [WebAssembly proposals](https://github.com/WebAssembly/proposals) and [WASI proposals](https://github.com/WebAssembly/WASI/blob/main/Proposals.md).
+
+Normally, the document tracks proposals that are in phase 4. However, if a proposal in an earlier phase receives support, it will be added to the list below.
+
+The _status_ represents the configuration _product-mini/platforms/linux/CMakeLists.txt_. There may be minor differences between the top-level CMakeLists and platform-specific CMakeLists.
+
+Users can turn those features on or off by using compilation options. If a relevant compilation option is not available(`N/A`), it indicates that the feature is permanently enabled.
+
+## On-by-default Wasm Proposals
+
+| Proposal                              | >= Phase 4 | Compilation Option       |
+| ------------------------------------- | ---------- | ------------------------ |
+| Bulk memory operations                | Yes        | `WAMR_BUILD_BULK_MEMORY` |
+| Extended Constant Expressions         | Yes        | N/A                      |
+| Fixed-width SIMD[^1]                  | Yes        | `WAMR_BUILD_SIMD`        |
+| Multi-value                           | Yes        | N/A                      |
+| Non-trapping float-to-int conversions | Yes        | N/A                      |
+| Reference Types                       | Yes        | `WAMR_BUILD_REF_TYPES`   |
+| Sign-extension operators              | Yes        | N/A                      |
+| WebAssembly C and C++ API             | No         | N/A                      |
+
+[^1]: llvm-jit and aot only.
+
+## Off-by-default Wasm Proposals
+
+| Proposal                      | >= Phase 4 | Compilation Option         |
+| ----------------------------- | ---------- | -------------------------- |
+| Garbage collection            | Yes        | `WAMR_BUILD_GC`            |
+| Legacy Exception handling[^2] | No         | `WAMR_BUILD_EXCE_HANDLING` |
+| Memory64                      | Yes        | `WAMR_BUILD_MEMORY64`      |
+| Multiple memories[^3]         | Yes        | `WAMR_BUILD_MULTI_MEMORY`  |
+| Reference-Typed Strings       | No         | `WAMR_BUILD_STRINGREF`     |
+| Tail call                     | Yes        | `WAMR_BUILD_TAIL_CALL`     |
+| Threads[^4]                   | Yes        | `WAMR_BUILD_SHARED_MEMORY` |
+| Typed Function References     | Yes        | `WAMR_BUILD_GC`            |
+
+[^2]:
+    interpreter only. [a legacy version](https://github.com/WebAssembly/exception-handling/blob/main/proposals/exception-handling/legacy/Exceptions.md).
+    This proposal is currently also known as the "legacy proposal" and still
+    supported in the web, but can be deprecated in future and the use of
+    this proposal is discouraged.
+
+[^3]: interpreter only
+[^4]: `WAMR_BUILD_LIB_PTHREAD` can also be used to enable
+
+## Unimplemented Wasm Proposals
+
+| Proposal                                    | >= Phase 4 |
+| ------------------------------------------- | ---------- |
+| Branch Hinting                              | Yes        |
+| Custom Annotation Syntax in the Text Format | Yes        |
+| Exception handling[^5]                      | Yes        |
+| Import/Export of Mutable Globals            | Yes        |
+| JS String Builtins                          | Yes        |
+| Relaxed SIMD                                | Yes        |
+
+[^5]: [up-to-date version](https://github.com/WebAssembly/exception-handling/blob/main/proposals/exception-handling/Exceptions.md)
+
+## On-by-default WASI Proposals
+
+| Proposal | >= Phase 4 | Compilation Option |
+| -------- | ---------- | ------------------ |
+
+## Off-by-default WASI Proposals
+
+| Proposal                   | >= Phase 4 | Compilation Option            |
+| -------------------------- | ---------- | ----------------------------- |
+| Machine Learning (wasi-nn) | No         | `WAMR_BUILD_WASI_NN`          |
+| Threads                    | No         | `WAMR_BUILD_LIB_WASI_THREADS` |
+
+## Unimplemented WASI Proposals
+
+| Proposal | >= Phase 4 |
+| -------- | ---------- |
+
+## WAMR features
+
+WAMR offers a variety of customizable features to create a highly efficient runtime. For more details, please refer to [build_wamr](./build_wamr.md).

product-mini/platforms/android/CMakeLists.txt

@@ -107,6 +107,8 @@ include (${WAMR_ROOT_DIR}/build-scripts/runtime_lib.cmake)
 
 add_library(vmlib ${WAMR_RUNTIME_LIB_SOURCE})
 
+set_version_info (vmlib)
+
 set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--gc-sections -pie -fPIE")
 
 set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Wformat -Wformat-security")
@@ -135,6 +137,7 @@ endif()
 
 set (distribution_DIR ${CMAKE_BINARY_DIR}/distribution)
 set_target_properties (iwasm PROPERTIES LIBRARY_OUTPUT_DIRECTORY "${distribution_DIR}/wasm/lib")
+set_version_info (iwasm)
 
 add_custom_command (TARGET iwasm POST_BUILD
         COMMAND "${CMAKE_COMMAND}" -E copy_directory "${WAMR_ROOT_DIR}/core/iwasm/include" "${distribution_DIR}/wasm/include/"

product-mini/platforms/common/wasm_proposal.c

@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2023 Amazon.com Inc. or its affiliates. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#include <stdio.h>
+
+void
+wasm_proposal_print_status(void)
+{
+    printf("About Wasm Proposals:\n");
+    printf("  Always-on:\n");
+    printf("    - Extended Constant Expressions\n");
+    printf("    - Multi-value\n");
+    printf("    - Non-trapping float-to-int conversions\n");
+    printf("    - Sign-extension operators\n");
+    printf("    - WebAssembly C and C++ API\n");
+    printf("  Compilation Configurable. 0 is OFF. 1 is ON:\n");
+    printf("    - Bulk Memory Operation via WASM_ENABLE_BULK_MEMORY: %u\n",
+           WASM_ENABLE_BULK_MEMORY);
+    printf("    - Fixed-Width SIMD via WASM_ENABLE_SIMD: %u\n",
+           WASM_ENABLE_SIMD);
+    printf("    - Garbage Collection via WASM_ENABLE_GC: %u\n", WASM_ENABLE_GC);
+    printf(
+        "    - Legacy Exception Handling via WASM_ENABLE_EXCE_HANDLING: %u\n",
+        WASM_ENABLE_EXCE_HANDLING);
+    printf("    - Memory64 via WASM_ENABLE_MEMORY64: %u\n",
+           WASM_ENABLE_MEMORY64);
+    printf("    - Multiple Memory via WASM_ENABLE_MULTI_MEMORY: %u\n",
+           WASM_ENABLE_MULTI_MEMORY);
+    printf("    - Reference Types via WASM_ENABLE_REF_TYPES: %u\n",
+           WASM_ENABLE_REF_TYPES);
+    printf("    - Reference-Typed Strings via WASM_ENABLE_REF_TYPES: %u\n",
+           WASM_ENABLE_REF_TYPES);
+    printf("    - Tail Call via WASM_ENABLE_TAIL_CALL: %u\n",
+           WASM_ENABLE_TAIL_CALL);
+    printf("    - Threads via WASM_ENABLE_SHARED_MEMORY: %u\n",
+           WASM_ENABLE_SHARED_MEMORY);
+    printf("    - Typed Function References via WASM_ENABLE_GC: %u\n",
+           WASM_ENABLE_GC);
+    printf("  Unsupported (>= Phase4):\n");
+    printf("    - Branch Hinting\n");
+    printf("    - Custom Annotation Syntax in the Text Format\n");
+    printf("    - Exception handling\n");
+    printf("    - Import/Export of Mutable Globals\n");
+    printf("    - JS String Builtins\n");
+    printf("    - Relaxed SIMD\n");
+}

product-mini/platforms/cosmopolitan/CMakeLists.txt

@@ -132,6 +132,7 @@ include (${WAMR_ROOT_DIR}/build-scripts/runtime_lib.cmake)
 check_pie_supported()
 add_library(vmlib ${WAMR_RUNTIME_LIB_SOURCE})
 set_target_properties (vmlib PROPERTIES POSITION_INDEPENDENT_CODE ON)
+set_version_info (vmlib)
 
 set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--gc-sections")
 
@@ -160,6 +161,8 @@ include (${SHARED_DIR}/utils/uncommon/shared_uncommon.cmake)
 
 add_executable (iwasm main.c ${UNCOMMON_SHARED_SOURCE})
 
+set_version_info (iwasm)
+
 set_target_properties (iwasm PROPERTIES POSITION_INDEPENDENT_CODE ON)
 
 install (TARGETS iwasm DESTINATION bin)
@@ -168,6 +171,8 @@ target_link_libraries (iwasm vmlib ${LLVM_AVAILABLE_LIBS} ${UV_A_LIBS} ${WASI_NN
 
 add_library (libiwasm STATIC ${WAMR_RUNTIME_LIB_SOURCE})
 
+set_version_info (libiwasm)
+
 install (TARGETS libiwasm DESTINATION lib)
 
 set_target_properties (libiwasm PROPERTIES OUTPUT_NAME iwasm)

product-mini/platforms/darwin/CMakeLists.txt

@@ -1,10 +1,12 @@
 # Copyright (C) 2019 Intel Corporation.  All rights reserved.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-cmake_minimum_required (VERSION 2.9)
+cmake_minimum_required (VERSION 3.14)
 
 project (iwasm)
 
+option(BUILD_SHARED_LIBS "Build using shared libraries" OFF)
+
 set (WAMR_BUILD_PLATFORM "darwin")
 
 # Reset default linker flags
@@ -91,6 +93,11 @@ if (NOT DEFINED WAMR_BUILD_SIMD)
   set (WAMR_BUILD_SIMD 1)
 endif ()
 
+if (NOT DEFINED WAMR_BUILD_REF_TYPES)
+  # Enable reference types by default
+  set (WAMR_BUILD_REF_TYPES 1)
+endif ()
+
 if (NOT DEFINED WAMR_BUILD_DEBUG_INTERP)
   # Disable Debug feature by default
   set (WAMR_BUILD_DEBUG_INTERP 0)
@@ -110,21 +117,41 @@ set (CMAKE_MACOSX_RPATH True)
 set (WAMR_ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../..)
 
 include (${WAMR_ROOT_DIR}/build-scripts/runtime_lib.cmake)
-add_library(vmlib ${WAMR_RUNTIME_LIB_SOURCE})
-
 include (${SHARED_DIR}/utils/uncommon/shared_uncommon.cmake)
 
 add_executable (iwasm main.c ${UNCOMMON_SHARED_SOURCE})
 
+set_version_info (iwasm)
+
 install (TARGETS iwasm DESTINATION bin)
 
-target_link_libraries (iwasm vmlib ${LLVM_AVAILABLE_LIBS} ${UV_A_LIBS} -lm -ldl -lpthread)
+target_link_libraries (iwasm vmlib)
+
+add_library (vmlib ${WAMR_RUNTIME_LIB_SOURCE})
+
+set_version_info (vmlib)
+
+target_include_directories(vmlib INTERFACE
+  $<INSTALL_INTERFACE:include/iwasm>
+)
 
-add_library (libiwasm SHARED ${WAMR_RUNTIME_LIB_SOURCE})
+set (WAMR_PUBLIC_HEADERS
+  ${WAMR_ROOT_DIR}/core/iwasm/include/wasm_c_api.h
+  ${WAMR_ROOT_DIR}/core/iwasm/include/wasm_export.h
+  ${WAMR_ROOT_DIR}/core/iwasm/include/lib_export.h
+)
 
-install (TARGETS libiwasm DESTINATION lib)
+set_target_properties (vmlib PROPERTIES
+  OUTPUT_NAME iwasm
+  PUBLIC_HEADER "${WAMR_PUBLIC_HEADERS}"
+)
 
-set_target_properties (libiwasm PROPERTIES OUTPUT_NAME iwasm)
+target_link_libraries (vmlib ${LLVM_AVAILABLE_LIBS} ${UV_A_LIBS} -lm -ldl -lpthread)
 
-target_link_libraries (libiwasm ${LLVM_AVAILABLE_LIBS} ${UV_A_LIBS} -lm -ldl -lpthread)
+install (TARGETS vmlib
+  EXPORT iwasmTargets
+  DESTINATION lib
+  PUBLIC_HEADER DESTINATION include/iwasm
+)
 
+install_iwasm_package ()

product-mini/platforms/freebsd/CMakeLists.txt

@@ -113,17 +113,22 @@ set (WAMR_ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../..)
 
 include (${WAMR_ROOT_DIR}/build-scripts/runtime_lib.cmake)
 add_library(vmlib ${WAMR_RUNTIME_LIB_SOURCE})
+set_version_info (vmlib)
 
 include (${SHARED_DIR}/utils/uncommon/shared_uncommon.cmake)
 
 add_executable (iwasm main.c ${UNCOMMON_SHARED_SOURCE})
 
+set_version_info (iwasm)
+
 install (TARGETS iwasm DESTINATION bin)
 
 target_link_libraries (iwasm vmlib ${LLVM_AVAILABLE_LIBS} ${UV_A_LIBS} -lm -ldl -lpthread)
 
 add_library (libiwasm SHARED ${WAMR_RUNTIME_LIB_SOURCE})
 
+set_version_info (libiwasm)
+
 install (TARGETS libiwasm DESTINATION lib)
 
 set_target_properties (libiwasm PROPERTIES OUTPUT_NAME iwasm)

product-mini/platforms/ios/CMakeLists.txt

@@ -3,8 +3,6 @@
 
 cmake_minimum_required (VERSION 3.21)
 
-set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mfloat-abi=hard")
-
 project (iwasm)
 
 set (WAMR_BUILD_PLATFORM "darwin")
@@ -141,6 +139,7 @@ endif()
 
 set (distribution_DIR ${CMAKE_BINARY_DIR}/distribution)
 set_target_properties (iwasm PROPERTIES LIBRARY_OUTPUT_DIRECTORY "${distribution_DIR}/wasm/lib")
+set_version_info (iwasm)
 
 add_custom_command (TARGET iwasm POST_BUILD
         COMMAND "${CMAKE_COMMAND}" -E copy_directory "${WAMR_ROOT_DIR}/core/iwasm/include" "${distribution_DIR}/wasm/include/"

product-mini/platforms/linux-sgx/CMakeLists.txt

@@ -107,6 +107,7 @@ set (WAMR_ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../..)
 
 include (${WAMR_ROOT_DIR}/build-scripts/runtime_lib.cmake)
 add_library(vmlib ${WAMR_RUNTIME_LIB_SOURCE})
+set_version_info (vmlib)
 
 add_custom_command (
              OUTPUT libvmlib_untrusted.a

product-mini/platforms/linux-sgx/CMakeLists_minimal.txt

@@ -78,6 +78,7 @@ set (WAMR_ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../..)
 
 include (${WAMR_ROOT_DIR}/build-scripts/runtime_lib.cmake)
 add_library(vmlib ${WAMR_RUNTIME_LIB_SOURCE})
+set_version_info (vmlib)
 
 add_custom_command (
              OUTPUT libvmlib_untrusted.a

product-mini/platforms/linux/CMakeLists.txt

@@ -7,6 +7,8 @@ include(CheckPIESupported)
 
 project (iwasm)
 
+option(BUILD_SHARED_LIBS "Build using shared libraries" OFF)
+
 set (CMAKE_VERBOSE_MAKEFILE OFF)
 
 set (WAMR_BUILD_PLATFORM "linux")
@@ -108,8 +110,8 @@ if (NOT DEFINED WAMR_BUILD_SIMD)
 endif ()
 
 if (NOT DEFINED WAMR_BUILD_REF_TYPES)
-  # Disable reference types by default
-  set (WAMR_BUILD_REF_TYPES 0)
+  # Enable reference types by default
+  set (WAMR_BUILD_REF_TYPES 1)
 endif ()
 
 if (NOT DEFINED WAMR_BUILD_DEBUG_INTERP)
@@ -126,13 +128,7 @@ endif ()
 # if enable wasi-nn, both wasi-nn-backends and iwasm
 # need to use same WAMR (dynamic) libraries
 if (WAMR_BUILD_WASI_NN EQUAL 1)
-  set (WAMR_BUILD_SHARED 1)
-endif ()
-
-if (NOT DEFINED WAMR_BUILD_SHARED)
-  set (WAMR_BUILD_SHARED 0)
-elseif (WAMR_BUILD_SHARED EQUAL 1)
-  message ("build WAMR as shared libraries")
+  set (BUILD_SHARED_LIBS ON)
 endif ()
 
 set (WAMR_ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../..)
@@ -140,8 +136,6 @@ set (WAMR_ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../..)
 include (${WAMR_ROOT_DIR}/build-scripts/runtime_lib.cmake)
 
 check_pie_supported()
-add_library(vmlib ${WAMR_RUNTIME_LIB_SOURCE})
-set_target_properties (vmlib PROPERTIES POSITION_INDEPENDENT_CODE ON)
 
 set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--gc-sections")
 
@@ -170,23 +164,40 @@ include (${SHARED_DIR}/utils/uncommon/shared_uncommon.cmake)
 
 add_executable (iwasm main.c ${UNCOMMON_SHARED_SOURCE})
 
+set_version_info (iwasm)
+
 set_target_properties (iwasm PROPERTIES POSITION_INDEPENDENT_CODE ON)
 
-target_link_libraries(iwasm
-  $<$<BOOL:${WAMR_BUILD_SHARED}>:libiwasm> $<$<NOT:$<BOOL:${WAMR_BUILD_SHARED}>>:vmlib>
-  ${LLVM_AVAILABLE_LIBS}
-  ${UV_A_LIBS}
-  -lm
-  -ldl
-  -lpthread
-)
+target_link_libraries(iwasm vmlib)
 
 install (TARGETS iwasm DESTINATION bin)
 
-add_library (libiwasm SHARED ${WAMR_RUNTIME_LIB_SOURCE})
+add_library (vmlib ${WAMR_RUNTIME_LIB_SOURCE})
+
+set_version_info (vmlib)
 
-install (TARGETS libiwasm DESTINATION lib)
+target_include_directories(vmlib INTERFACE
+  $<INSTALL_INTERFACE:include/iwasm>
+)
 
-set_target_properties (libiwasm PROPERTIES OUTPUT_NAME iwasm)
+set (WAMR_PUBLIC_HEADERS
+  ${WAMR_ROOT_DIR}/core/iwasm/include/wasm_c_api.h
+  ${WAMR_ROOT_DIR}/core/iwasm/include/wasm_export.h
+  ${WAMR_ROOT_DIR}/core/iwasm/include/lib_export.h
+)
+
+set_target_properties (vmlib PROPERTIES
+  OUTPUT_NAME iwasm
+  PUBLIC_HEADER "${WAMR_PUBLIC_HEADERS}"
+  POSITION_INDEPENDENT_CODE ON
+)
+
+target_link_libraries (vmlib ${LLVM_AVAILABLE_LIBS} ${UV_A_LIBS} -lm -ldl -lpthread)
+
+install (TARGETS vmlib
+  EXPORT iwasmTargets
+  DESTINATION lib
+  PUBLIC_HEADER DESTINATION include/iwasm
+)
 
-target_link_libraries (libiwasm ${LLVM_AVAILABLE_LIBS} ${UV_A_LIBS} -lm -ldl -lpthread)
+install_iwasm_package ()

product-mini/platforms/posix/main.c

@@ -18,6 +18,8 @@
 #include "../common/libc_wasi.c"
 #endif
 
+#include "../common/wasm_proposal.c"
+
 #if BH_HAS_DLFCN
 #include <dlfcn.h>
 #endif
@@ -798,6 +800,8 @@ main(int argc, char *argv[])
             wasm_runtime_get_version(&major, &minor, &patch);
             printf("iwasm %" PRIu32 ".%" PRIu32 ".%" PRIu32 "\n", major, minor,
                    patch);
+            printf("\n");
+            wasm_proposal_print_status();
             return 0;
         }
         else {

product-mini/platforms/riot/CMakeLists.txt

@@ -62,3 +62,5 @@ include_directories(SYSTEM ${RIOT_INCLUDES_LIST})
 # executable linking is done by RIOT build system
 
 add_library( wamr ${WAMR_RUNTIME_LIB_SOURCE})
+
+set_version_info (wamr)

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/vxworks/CMakeLists.txt

@@ -78,17 +78,22 @@ set (WAMR_ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../..)
 
 include (${WAMR_ROOT_DIR}/build-scripts/runtime_lib.cmake)
 add_library(vmlib ${WAMR_RUNTIME_LIB_SOURCE})
+set_version_info (vmlib)
 
 include (${SHARED_DIR}/utils/uncommon/shared_uncommon.cmake)
 
 add_executable (iwasm main.c ${UNCOMMON_SHARED_SOURCE})
 
+set_version_info (iwasm)
+
 install (TARGETS iwasm DESTINATION bin)
 
 target_link_libraries (iwasm vmlib ${LLVM_AVAILABLE_LIBS} -lm -ldl -lunix)
 
 add_library (libiwasm SHARED ${WAMR_RUNTIME_LIB_SOURCE})
 
+set_version_info (libiwasm)
+
 install (TARGETS libiwasm DESTINATION lib)
 
 set_target_properties (libiwasm PROPERTIES OUTPUT_NAME iwasm)

product-mini/platforms/windows/CMakeLists.txt

@@ -6,6 +6,8 @@ cmake_minimum_required (VERSION 2.9)
 project (iwasm C ASM CXX)
 # set (CMAKE_VERBOSE_MAKEFILE 1)
 
+option(BUILD_SHARED_LIBS "Build using shared libraries" OFF)
+
 set (WAMR_BUILD_PLATFORM "windows")
 
 # Reset default linker flags
@@ -105,7 +107,6 @@ endif()
 set (WAMR_ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../..)
 
 include (${WAMR_ROOT_DIR}/build-scripts/runtime_lib.cmake)
-add_library(vmlib ${WAMR_RUNTIME_LIB_SOURCE})
 
 #set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DWIN32_LEAN_AND_MEAN")
 if (NOT MINGW)
@@ -132,30 +133,46 @@ endif ()
 
 include (${SHARED_DIR}/utils/uncommon/shared_uncommon.cmake)
 
-add_executable (iwasm main.c ${UNCOMMON_SHARED_SOURCE})
+add_executable (iwasm main.c ${PLATFORM_SHARED_SOURCE} ${UNCOMMON_SHARED_SOURCE} ${UTILS_SHARED_SOURCE})
 
-install (TARGETS iwasm DESTINATION bin)
+set_version_info (iwasm)
 
-target_link_libraries (iwasm vmlib ${LLVM_AVAILABLE_LIBS} ${UV_A_LIBS})
+install (TARGETS iwasm DESTINATION bin)
 
-if (MINGW)
-  target_link_libraries (iwasm ws2_32)
-endif ()
+target_link_libraries (iwasm vmlib)
 
-add_library (libiwasm SHARED ${WAMR_RUNTIME_LIB_SOURCE})
+add_library (vmlib ${WAMR_RUNTIME_LIB_SOURCE})
+set_version_info (vmlib)
 
-install (TARGETS libiwasm DESTINATION lib)
+target_include_directories(vmlib INTERFACE
+  $<INSTALL_INTERFACE:include/iwasm>
+)
 
-set_target_properties (libiwasm PROPERTIES OUTPUT_NAME libiwasm)
+set (WAMR_PUBLIC_HEADERS
+  ${WAMR_ROOT_DIR}/core/iwasm/include/wasm_c_api.h
+  ${WAMR_ROOT_DIR}/core/iwasm/include/wasm_export.h
+  ${WAMR_ROOT_DIR}/core/iwasm/include/lib_export.h
+)
 
-target_link_libraries (libiwasm ${LLVM_AVAILABLE_LIBS} ${UV_A_LIBS})
+set_target_properties (vmlib PROPERTIES
+  OUTPUT_NAME libiwasm
+  PUBLIC_HEADER "${WAMR_PUBLIC_HEADERS}"
+  POSITION_INDEPENDENT_CODE ON
+)
 
+target_link_libraries (vmlib ${LLVM_AVAILABLE_LIBS} ${UV_A_LIBS})
 if (MINGW)
-  target_link_libraries (libiwasm ws2_32)
+  target_link_libraries (vmlib ws2_32)
 endif ()
 
 if (WIN32)
-  target_link_libraries(libiwasm ntdll)
-
-  target_link_libraries(iwasm ntdll)  
+  target_link_libraries(vmlib ntdll)
 endif()
+
+install (TARGETS vmlib
+  EXPORT iwasmTargets
+  DESTINATION lib
+  PUBLIC_HEADER DESTINATION include/iwasm
+)
+
+install_iwasm_package ()

product-mini/platforms/zephyr/simple/CMakeLists.txt

@@ -32,7 +32,8 @@ if (NOT DEFINED WAMR_BUILD_LIBC_BUILTIN)
 endif ()
 
 if (NOT DEFINED WAMR_BUILD_LIBC_WASI)
-  # Disable libc wasi support by default
+  # Disable libc wasi support by default, in the future, 
+  # it can be enabled if libc wasi file/socket/lock support is ready on Zephyr platform
   set (WAMR_BUILD_LIBC_WASI 0)
 endif ()
 

product-mini/platforms/zephyr/simple/build_and_run.sh

@@ -38,7 +38,7 @@ TARGET=$1
 
 case $TARGET in
         $X86_TARGET)
-                west build -b qemu_x86_nommu \
+                west build -b qemu_x86_tiny \
                            . -p always -- \
                            -DWAMR_BUILD_TARGET=X86_32
                 west build -t run

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

product-mini/platforms/zephyr/user-mode/CMakeLists.txt

@@ -0,0 +1,15 @@
+# Copyright (C) 2019 Intel Corporation.  All rights reserved.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+cmake_minimum_required(VERSION 3.13.1)
+find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
+
+project(wamr_user_mode LANGUAGES C)
+
+# Add the wamr-lib directory
+add_subdirectory(lib-wamr-zephyr)
+
+# Link the wamr library to the app target
+target_link_libraries(app PRIVATE wamr_lib)
+
+target_sources(app PRIVATE src/main.c)

product-mini/platforms/zephyr/user-mode/README.md

@@ -0,0 +1,60 @@
+# How to use WAMR with Zephyr in user mode
+
+This example demonstrates how to build and run a WebAssembly application in user mode on Zephyr.
+
+> Note: The user mode is not supported on all Zephyr boards. Please refer to the Zephyr documentation for more information.
+
+## Setup
+
+Please refer to the [previous WAMR Zephyr README.md](../simple/README.md) for general Zephyr setup instructions.
+
+And refer to [official documentation of Zephyr user mode](https://docs.zephyrproject.org/latest/kernel/usermode/index.html) for more information about Zephyr user mode.
+
+### Enable user mode
+
+To enable Zephyr user mode, set the `CONFIG_USERSPACE` option to yes in the Zephyr configuration.
+
+```conf
+CONFIG_USERSPACE=y
+```
+
+And link the WAMR runtime as a separate library in CMakelists.txt.
+
+```cmake
+...WAMR CMake set up...
+
+zephyr_library_named (wamr_lib)
+
+zephyr_library_sources (
+  ${WAMR_RUNTIME_LIB_SOURCE} 
+  wamr_lib.c
+)
+
+zephyr_library_app_memory (wamr_partition)
+```
+
+The `wamr_partition` is a memory partition that will be granted to the WAMR runtime. It is defined in the Zephyr application code.
+
+```C
+K_APPMEM_PARTITION_DEFINE(wamr_partition);
+```
+
+When creating a Zephyr thread, set the thread option to `K_USER` and the timeout to `K_FOREVER`. This can ensure that the `wamr_partition` is granted access to the thread before starting it with `k_thread_start`.
+
+### Advantage of using WAMR runtime in Zephyr user mode thread
+
+In a user-mode Zephyr thread, the application can only access a restricted partition of memory it granted to. It creates a sandbox for the WAMR runtime to run in, and the WAMR runtime can only access that memory space, meaning that all global variables in the WAMR runtime and both runtime and wasm app heap memory will be allocated from it. In this way, an extra layer of security is added to the wasm application on top of the wasm sandbox provided by WAMR.
+
+### Example Targets
+
+x86_64 QEMU (x86_64) is a 64-bit x86 target for emulating the x86_64 platform.
+
+```shell
+west build -b qemu_x86_tiny . -p always -- -DWAMR_BUILD_TARGET=X86_32
+```
+
+Use qemu to run the image.
+
+```shell
+qemu-system-i386 -m 32 -cpu qemu32,+nx,+pae -machine pc -device isa-debug-exit,iobase=0xf4,iosize=0x04 -no-reboot -nographic -net none -pidfile qemu.pid -chardev stdio,id=con,mux=on -serial chardev:con -mon chardev=con,mode=readline -icount shift=5,align=off,sleep=off -rtc clock=vm -kernel ./build/zephyr/zephyr.elf
+```

product-mini/platforms/zephyr/user-mode/lib-wamr-zephyr/CMakeLists.txt

@@ -0,0 +1,63 @@
+# Copyright (C) 2019 Intel Corporation.  All rights reserved.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+cmake_minimum_required(VERSION 3.8.2)
+
+set (WAMR_BUILD_PLATFORM "zephyr")
+
+# Build as X86_32 by default, change to "AARCH64[sub]", "ARM[sub]", "THUMB[sub]", "MIPS" or "XTENSA"
+# if we want to support arm, thumb, mips or xtensa
+if (NOT DEFINED WAMR_BUILD_TARGET)
+  set (WAMR_BUILD_TARGET "X86_32")
+endif ()
+
+if (NOT DEFINED WAMR_BUILD_INTERP)
+  # Enable Interpreter by default
+  set (WAMR_BUILD_INTERP 1)
+endif ()
+
+if (NOT DEFINED WAMR_BUILD_AOT)
+  # Enable AOT by default.
+  set (WAMR_BUILD_AOT 1)
+endif ()
+
+if (NOT DEFINED WAMR_BUILD_LIBC_BUILTIN)
+  # Enable libc builtin support by default
+  set (WAMR_BUILD_LIBC_BUILTIN 1)
+endif ()
+
+if (NOT DEFINED WAMR_BUILD_LIBC_WASI)
+  # Disable libc wasi support by default, in the future, 
+  # it can be enabled if libc wasi file/socket/lock support is ready on Zephyr platform
+  set (WAMR_BUILD_LIBC_WASI 0)
+endif ()
+
+if (WAMR_BUILD_TARGET STREQUAL "RISCV64_LP64" OR WAMR_BUILD_TARGET STREQUAL "RISCV32_ILP32")
+  set (WAMR_BUILD_FAST_INTERP 1)
+endif ()
+
+# Limited to global heap usage in Zephyr user mode
+set (WAMR_BUILD_GLOBAL_HEAP_POOL 1)
+
+# Override the global heap size for small devices
+if (NOT DEFINED WAMR_BUILD_GLOBAL_HEAP_SIZE)
+  set (WAMR_BUILD_GLOBAL_HEAP_SIZE 40960) # 40 KB
+endif ()
+
+set (WAMR_ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../../../..)
+
+include (${WAMR_ROOT_DIR}/build-scripts/runtime_lib.cmake)
+
+# Embed WAMR as a Zephyr library
+zephyr_library_named (wamr_lib)
+
+# Add source files to the library
+zephyr_library_sources (
+  ${WAMR_RUNTIME_LIB_SOURCE} 
+  wamr_lib.c
+)
+
+# Specify the memory partition where all globals(including the WAMR global heap buffer)
+# in the library should be placed. This partition will be defined in the app source code
+# and added to the use-mode thread that uses the WAMR library.
+zephyr_library_app_memory (wamr_partition)

product-mini/platforms/zephyr/user-mode/lib-wamr-zephyr/test_wasm.h

@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+/**
+ * The byte array buffer is the file content of a test wasm binary file,
+ * which is compiled by wasi-sdk toolchain from C source file of:
+ *   product-mini/app-samples/hello-world/main.c.
+ */
+unsigned char __aligned(4) wasm_test_file[] = {
+    0x00, 0x61, 0x73, 0x6D, 0x01, 0x00, 0x00, 0x00, 0x01, 0x10, 0x03, 0x60,
+    0x01, 0x7F, 0x01, 0x7F, 0x60, 0x02, 0x7F, 0x7F, 0x01, 0x7F, 0x60, 0x01,
+    0x7F, 0x00, 0x02, 0x31, 0x04, 0x03, 0x65, 0x6E, 0x76, 0x04, 0x70, 0x75,
+    0x74, 0x73, 0x00, 0x00, 0x03, 0x65, 0x6E, 0x76, 0x06, 0x6D, 0x61, 0x6C,
+    0x6C, 0x6F, 0x63, 0x00, 0x00, 0x03, 0x65, 0x6E, 0x76, 0x06, 0x70, 0x72,
+    0x69, 0x6E, 0x74, 0x66, 0x00, 0x01, 0x03, 0x65, 0x6E, 0x76, 0x04, 0x66,
+    0x72, 0x65, 0x65, 0x00, 0x02, 0x03, 0x02, 0x01, 0x01, 0x04, 0x05, 0x01,
+    0x70, 0x01, 0x01, 0x01, 0x05, 0x03, 0x01, 0x00, 0x01, 0x06, 0x13, 0x03,
+    0x7F, 0x01, 0x41, 0xC0, 0x28, 0x0B, 0x7F, 0x00, 0x41, 0xBA, 0x08, 0x0B,
+    0x7F, 0x00, 0x41, 0xC0, 0x28, 0x0B, 0x07, 0x2C, 0x04, 0x06, 0x6D, 0x65,
+    0x6D, 0x6F, 0x72, 0x79, 0x02, 0x00, 0x0A, 0x5F, 0x5F, 0x64, 0x61, 0x74,
+    0x61, 0x5F, 0x65, 0x6E, 0x64, 0x03, 0x01, 0x0B, 0x5F, 0x5F, 0x68, 0x65,
+    0x61, 0x70, 0x5F, 0x62, 0x61, 0x73, 0x65, 0x03, 0x02, 0x04, 0x6D, 0x61,
+    0x69, 0x6E, 0x00, 0x04, 0x0A, 0xB2, 0x01, 0x01, 0xAF, 0x01, 0x01, 0x03,
+    0x7F, 0x23, 0x80, 0x80, 0x80, 0x80, 0x00, 0x41, 0x20, 0x6B, 0x22, 0x02,
+    0x24, 0x80, 0x80, 0x80, 0x80, 0x00, 0x41, 0x9B, 0x88, 0x80, 0x80, 0x00,
+    0x10, 0x80, 0x80, 0x80, 0x80, 0x00, 0x1A, 0x02, 0x40, 0x02, 0x40, 0x41,
+    0x80, 0x08, 0x10, 0x81, 0x80, 0x80, 0x80, 0x00, 0x22, 0x03, 0x0D, 0x00,
+    0x41, 0xA8, 0x88, 0x80, 0x80, 0x00, 0x10, 0x80, 0x80, 0x80, 0x80, 0x00,
+    0x1A, 0x41, 0x7F, 0x21, 0x04, 0x0C, 0x01, 0x0B, 0x20, 0x02, 0x20, 0x03,
+    0x36, 0x02, 0x10, 0x41, 0x80, 0x88, 0x80, 0x80, 0x00, 0x20, 0x02, 0x41,
+    0x10, 0x6A, 0x10, 0x82, 0x80, 0x80, 0x80, 0x00, 0x1A, 0x41, 0x00, 0x21,
+    0x04, 0x20, 0x03, 0x41, 0x04, 0x6A, 0x41, 0x00, 0x2F, 0x00, 0x91, 0x88,
+    0x80, 0x80, 0x00, 0x3B, 0x00, 0x00, 0x20, 0x03, 0x41, 0x00, 0x28, 0x00,
+    0x8D, 0x88, 0x80, 0x80, 0x00, 0x36, 0x00, 0x00, 0x20, 0x02, 0x20, 0x03,
+    0x36, 0x02, 0x00, 0x41, 0x93, 0x88, 0x80, 0x80, 0x00, 0x20, 0x02, 0x10,
+    0x82, 0x80, 0x80, 0x80, 0x00, 0x1A, 0x20, 0x03, 0x10, 0x83, 0x80, 0x80,
+    0x80, 0x00, 0x0B, 0x20, 0x02, 0x41, 0x20, 0x6A, 0x24, 0x80, 0x80, 0x80,
+    0x80, 0x00, 0x20, 0x04, 0x0B, 0x0B, 0x41, 0x01, 0x00, 0x41, 0x80, 0x08,
+    0x0B, 0x3A, 0x62, 0x75, 0x66, 0x20, 0x70, 0x74, 0x72, 0x3A, 0x20, 0x25,
+    0x70, 0x0A, 0x00, 0x31, 0x32, 0x33, 0x34, 0x0A, 0x00, 0x62, 0x75, 0x66,
+    0x3A, 0x20, 0x25, 0x73, 0x00, 0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x20, 0x77,
+    0x6F, 0x72, 0x6C, 0x64, 0x21, 0x00, 0x6D, 0x61, 0x6C, 0x6C, 0x6F, 0x63,
+    0x20, 0x62, 0x75, 0x66, 0x20, 0x66, 0x61, 0x69, 0x6C, 0x65, 0x64, 0x00
+};

product-mini/platforms/zephyr/user-mode/lib-wamr-zephyr/test_wasm_riscv64.h

@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+unsigned char __aligned(4) wasm_test_file[] = {
+    0x00, 0x61, 0x73, 0x6D, 0x01, 0x00, 0x00, 0x00, 0x01, 0x10, 0x03, 0x60,
+    0x01, 0x7F, 0x01, 0x7F, 0x60, 0x02, 0x7F, 0x7F, 0x01, 0x7F, 0x60, 0x01,
+    0x7F, 0x00, 0x02, 0x31, 0x04, 0x03, 0x65, 0x6E, 0x76, 0x04, 0x70, 0x75,
+    0x74, 0x73, 0x00, 0x00, 0x03, 0x65, 0x6E, 0x76, 0x06, 0x6D, 0x61, 0x6C,
+    0x6C, 0x6F, 0x63, 0x00, 0x00, 0x03, 0x65, 0x6E, 0x76, 0x06, 0x70, 0x72,
+    0x69, 0x6E, 0x74, 0x66, 0x00, 0x01, 0x03, 0x65, 0x6E, 0x76, 0x04, 0x66,
+    0x72, 0x65, 0x65, 0x00, 0x02, 0x03, 0x02, 0x01, 0x01, 0x04, 0x05, 0x01,
+    0x70, 0x01, 0x01, 0x01, 0x05, 0x03, 0x01, 0x00, 0x01, 0x06, 0x12, 0x03,
+    0x7F, 0x01, 0x41, 0xC0, 0x01, 0x0B, 0x7F, 0x00, 0x41, 0x3A, 0x0B, 0x7F,
+    0x00, 0x41, 0xC0, 0x01, 0x0B, 0x07, 0x2C, 0x04, 0x06, 0x6D, 0x65, 0x6D,
+    0x6F, 0x72, 0x79, 0x02, 0x00, 0x04, 0x6D, 0x61, 0x69, 0x6E, 0x00, 0x04,
+    0x0A, 0x5F, 0x5F, 0x64, 0x61, 0x74, 0x61, 0x5F, 0x65, 0x6E, 0x64, 0x03,
+    0x01, 0x0B, 0x5F, 0x5F, 0x68, 0x65, 0x61, 0x70, 0x5F, 0x62, 0x61, 0x73,
+    0x65, 0x03, 0x02, 0x0A, 0xB1, 0x01, 0x01, 0xAE, 0x01, 0x01, 0x03, 0x7F,
+    0x23, 0x80, 0x80, 0x80, 0x80, 0x00, 0x41, 0x20, 0x6B, 0x22, 0x02, 0x24,
+    0x80, 0x80, 0x80, 0x80, 0x00, 0x41, 0x9B, 0x80, 0x80, 0x80, 0x00, 0x10,
+    0x80, 0x80, 0x80, 0x80, 0x00, 0x1A, 0x02, 0x40, 0x02, 0x40, 0x41, 0x10,
+    0x10, 0x81, 0x80, 0x80, 0x80, 0x00, 0x22, 0x03, 0x0D, 0x00, 0x41, 0xA8,
+    0x80, 0x80, 0x80, 0x00, 0x10, 0x80, 0x80, 0x80, 0x80, 0x00, 0x1A, 0x41,
+    0x7F, 0x21, 0x04, 0x0C, 0x01, 0x0B, 0x20, 0x02, 0x20, 0x03, 0x36, 0x02,
+    0x10, 0x41, 0x80, 0x80, 0x80, 0x80, 0x00, 0x20, 0x02, 0x41, 0x10, 0x6A,
+    0x10, 0x82, 0x80, 0x80, 0x80, 0x00, 0x1A, 0x41, 0x00, 0x21, 0x04, 0x20,
+    0x03, 0x41, 0x04, 0x6A, 0x41, 0x00, 0x2F, 0x00, 0x91, 0x80, 0x80, 0x80,
+    0x00, 0x3B, 0x00, 0x00, 0x20, 0x03, 0x41, 0x00, 0x28, 0x00, 0x8D, 0x80,
+    0x80, 0x80, 0x00, 0x36, 0x00, 0x00, 0x20, 0x02, 0x20, 0x03, 0x36, 0x02,
+    0x00, 0x41, 0x93, 0x80, 0x80, 0x80, 0x00, 0x20, 0x02, 0x10, 0x82, 0x80,
+    0x80, 0x80, 0x00, 0x1A, 0x20, 0x03, 0x10, 0x83, 0x80, 0x80, 0x80, 0x00,
+    0x0B, 0x20, 0x02, 0x41, 0x20, 0x6A, 0x24, 0x80, 0x80, 0x80, 0x80, 0x00,
+    0x20, 0x04, 0x0B, 0x0B, 0x40, 0x01, 0x00, 0x41, 0x00, 0x0B, 0x3A, 0x62,
+    0x75, 0x66, 0x20, 0x70, 0x74, 0x72, 0x3A, 0x20, 0x25, 0x70, 0x0A, 0x00,
+    0x31, 0x32, 0x33, 0x34, 0x0A, 0x00, 0x62, 0x75, 0x66, 0x3A, 0x20, 0x25,
+    0x73, 0x00, 0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x20, 0x77, 0x6F, 0x72, 0x6C,
+    0x64, 0x21, 0x00, 0x6D, 0x61, 0x6C, 0x6C, 0x6F, 0x63, 0x20, 0x62, 0x75,
+    0x66, 0x20, 0x66, 0x61, 0x69, 0x6C, 0x65, 0x64, 0x00
+};

product-mini/platforms/zephyr/user-mode/lib-wamr-zephyr/wamr_lib.c

@@ -0,0 +1,172 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include "bh_platform.h"
+#include "bh_assert.h"
+#include "bh_log.h"
+#include "bh_queue.h"
+#include "wasm_export.h"
+#if defined(BUILD_TARGET_RISCV64_LP64) || defined(BUILD_TARGET_RISCV32_ILP32)
+#include "test_wasm_riscv64.h"
+#else
+#include "test_wasm.h"
+#endif /* end of BUILD_TARGET_RISCV64_LP64 || BUILD_TARGET_RISCV32_ILP32 */
+
+#if defined(BUILD_TARGET_RISCV64_LP64) || defined(BUILD_TARGET_RISCV32_ILP32)
+#define CONFIG_GLOBAL_HEAP_BUF_SIZE 5120
+#define CONFIG_APP_STACK_SIZE 512
+#define CONFIG_APP_HEAP_SIZE 512
+#else /* else of BUILD_TARGET_RISCV64_LP64 || BUILD_TARGET_RISCV32_ILP32 */
+#define CONFIG_GLOBAL_HEAP_BUF_SIZE WASM_GLOBAL_HEAP_SIZE
+#define CONFIG_APP_STACK_SIZE 8192
+#define CONFIG_APP_HEAP_SIZE 8192
+#endif /* end of BUILD_TARGET_RISCV64_LP64 || BUILD_TARGET_RISCV32_ILP32 */
+
+static int app_argc;
+static char **app_argv;
+
+/**
+ * Find the unique main function from a WASM module instance
+ * and execute that function.
+ *
+ * @param module_inst the WASM module instance
+ * @param argc the number of arguments
+ * @param argv the arguments array
+ *
+ * @return true if the main function is called, false otherwise.
+ */
+bool
+wasm_application_execute_main(wasm_module_inst_t module_inst, int argc,
+                              char *argv[]);
+
+static void *
+app_instance_main(wasm_module_inst_t module_inst)
+{
+    const char *exception;
+    wasm_function_inst_t func;
+    wasm_exec_env_t exec_env;
+    unsigned argv[2] = { 0 };
+
+    if (wasm_runtime_lookup_function(module_inst, "main")
+        || wasm_runtime_lookup_function(module_inst, "__main_argc_argv")) {
+        LOG_VERBOSE("Calling main function\n");
+        wasm_application_execute_main(module_inst, app_argc, app_argv);
+    }
+    else if ((func = wasm_runtime_lookup_function(module_inst, "app_main"))) {
+        exec_env =
+            wasm_runtime_create_exec_env(module_inst, CONFIG_APP_HEAP_SIZE);
+        if (!exec_env) {
+            os_printf("Create exec env failed\n");
+            return NULL;
+        }
+
+        LOG_VERBOSE("Calling app_main function\n");
+        wasm_runtime_call_wasm(exec_env, func, 0, argv);
+
+        if (!wasm_runtime_get_exception(module_inst)) {
+            os_printf("result: 0x%x\n", argv[0]);
+        }
+
+        wasm_runtime_destroy_exec_env(exec_env);
+    }
+    else {
+        os_printf("Failed to lookup function main or app_main to call\n");
+        return NULL;
+    }
+
+    if ((exception = wasm_runtime_get_exception(module_inst)))
+        os_printf("%s\n", exception);
+
+    return NULL;
+}
+
+#if WASM_ENABLE_GLOBAL_HEAP_POOL != 0
+static char global_heap_buf[CONFIG_GLOBAL_HEAP_BUF_SIZE] = { 0 };
+#endif
+
+void
+iwasm_main(void *arg1, void *arg2, void *arg3)
+{
+    int start, end;
+    start = k_uptime_get_32();
+    uint8 *wasm_file_buf = NULL;
+    uint32 wasm_file_size;
+    wasm_module_t wasm_module = NULL;
+    wasm_module_inst_t wasm_module_inst = NULL;
+    RuntimeInitArgs init_args;
+    char error_buf[128];
+#if WASM_ENABLE_LOG != 0
+    int log_verbose_level = 2;
+#endif
+
+    (void)arg1;
+    (void)arg2;
+    (void)arg3;
+
+    os_printf("User mode thread: start\n");
+
+    memset(&init_args, 0, sizeof(RuntimeInitArgs));
+
+#if WASM_ENABLE_GLOBAL_HEAP_POOL != 0
+    init_args.mem_alloc_type = Alloc_With_Pool;
+    init_args.mem_alloc_option.pool.heap_buf = global_heap_buf;
+    init_args.mem_alloc_option.pool.heap_size = sizeof(global_heap_buf);
+#elif (defined(CONFIG_COMMON_LIBC_MALLOC)            \
+       && CONFIG_COMMON_LIBC_MALLOC_ARENA_SIZE != 0) \
+    || defined(CONFIG_NEWLIB_LIBC)
+    init_args.mem_alloc_type = Alloc_With_System_Allocator;
+#else
+#error "memory allocation scheme is not defined."
+#endif
+
+    /* initialize runtime environment */
+    if (!wasm_runtime_full_init(&init_args)) {
+        printf("Init runtime environment failed.\n");
+        return;
+    }
+
+#if WASM_ENABLE_LOG != 0
+    bh_log_set_verbose_level(log_verbose_level);
+#endif
+
+    /* load WASM byte buffer from byte buffer of include file */
+    wasm_file_buf = (uint8 *)wasm_test_file;
+    wasm_file_size = sizeof(wasm_test_file);
+
+    /* load WASM module */
+    if (!(wasm_module = wasm_runtime_load(wasm_file_buf, wasm_file_size,
+                                          error_buf, sizeof(error_buf)))) {
+        printf("%s\n", error_buf);
+        goto fail1;
+    }
+
+    /* instantiate the module */
+    if (!(wasm_module_inst = wasm_runtime_instantiate(
+              wasm_module, CONFIG_APP_STACK_SIZE, CONFIG_APP_HEAP_SIZE,
+              error_buf, sizeof(error_buf)))) {
+        printf("%s\n", error_buf);
+        goto fail2;
+    }
+
+    /* invoke the main function */
+    app_instance_main(wasm_module_inst);
+
+    /* destroy the module instance */
+    wasm_runtime_deinstantiate(wasm_module_inst);
+
+fail2:
+    /* unload the module */
+    wasm_runtime_unload(wasm_module);
+
+fail1:
+    /* destroy runtime environment */
+    wasm_runtime_destroy();
+
+    end = k_uptime_get_32();
+
+    os_printf("User mode thread: elapsed %d\n", (end - start));
+}

product-mini/platforms/zephyr/user-mode/prj.conf

@@ -0,0 +1,9 @@
+# Copyright (C) 2019 Intel Corporation.  All rights reserved.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+CONFIG_USERSPACE=y
+CONFIG_STACK_SENTINEL=y
+CONFIG_PRINTK=y
+CONFIG_LOG=y
+CONFIG_LOG_BUFFER_SIZE=8096
+CONFIG_THREAD_RUNTIME_STATS=y

product-mini/platforms/zephyr/user-mode/src/main.c

@@ -0,0 +1,78 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#include <stdio.h>
+
+#include <zephyr/version.h>
+#include <zephyr/app_memory/app_memdomain.h>
+
+#define MAIN_THREAD_STACK_SIZE 2048
+#define MAIN_THREAD_PRIORITY 5
+
+static struct k_thread iwasm_user_mode_thread;
+K_THREAD_STACK_DEFINE(iwasm_user_mode_thread_stack, MAIN_THREAD_STACK_SIZE);
+
+extern struct k_mem_partition z_libc_partition;
+K_APPMEM_PARTITION_DEFINE(wamr_partition);
+
+/* WAMR memory domain */
+struct k_mem_domain wamr_domain;
+
+extern void
+iwasm_main(void *arg1, void *arg2, void *arg3);
+
+bool
+iwasm_user_mode(void)
+{
+    struct k_mem_partition *wamr_domain_parts[] = { &wamr_partition,
+                                                    &z_libc_partition };
+
+    printk("wamr_partition start addr: %ld, size: %zu\n", wamr_partition.start,
+           wamr_partition.size);
+
+    /* Initialize the memory domain with single WAMR partition */
+    if (k_mem_domain_init(&wamr_domain, 2, wamr_domain_parts) != 0) {
+        printk("Failed to initialize memory domain.\n");
+        return false;
+    }
+
+    k_tid_t tid =
+        k_thread_create(&iwasm_user_mode_thread, iwasm_user_mode_thread_stack,
+                        MAIN_THREAD_STACK_SIZE, iwasm_main, NULL, NULL, NULL,
+                        MAIN_THREAD_PRIORITY, K_USER, K_FOREVER);
+
+    /* Grant WAMR memory domain access to user mode thread */
+    if (k_mem_domain_add_thread(&wamr_domain, tid) != 0) {
+        printk("Failed to add memory domain to thread.\n");
+        return false;
+    }
+
+#if KERNEL_VERSION_NUMBER < 0x040000 /* version 4.0.0 */
+    /* k_thread_start is a legacy API for compatibility. Modern Zephyr threads
+     * are initialized in the "sleeping" state and do not need special handling
+     * for "start".*/
+    k_thread_start(tid);
+#else
+    /* wakes up thread from sleeping */
+    k_wakeup(tid);
+#endif
+
+    return tid ? true : false;
+}
+
+#if KERNEL_VERSION_NUMBER < 0x030400 /* version 3.4.0 */
+void
+main(void)
+{
+    iwasm_user_mode();
+}
+#else
+int
+main(void)
+{
+    iwasm_user_mode();
+    return 0;
+}
+#endif