From 627debcefb1324a13d4f360a4346964fcde62dc5 Mon Sep 17 00:00:00 2001
From: Marcin Kolny <marcin.kolny@gmail.com>
Date: Sun, 21 Jan 2024 23:33:26 +0000
Subject: [PATCH 01/14] Add flag to control Winsocket initialization (#3060)

When WAMR is embedded to other application, the lifecycle of the socket
might conflict with other usecases. E.g. if WAMR is deinitialized before any
other use of sockets, the application goes into the invalid state. The new
flag allows host application to take control over the socket initialization.
---
 core/config.h                             | 11 +++++++++++
 core/shared/platform/windows/win_socket.c |  4 ++++
 2 files changed, 15 insertions(+)

diff --git a/core/config.h b/core/config.h
index ed8af92f23..ef322647fd 100644
--- a/core/config.h
+++ b/core/config.h
@@ -231,6 +231,17 @@
 #define WASM_ENABLE_LOG 1
 #endif
 
+/* When this flag is set, WAMR will not automatically
+ * initialize sockets on Windows platforms. The host
+ * application is responsible for calling WSAStartup()
+ * before executing WAMR code that uses sockets, and
+ * calling WSACleanup() after.
+ * This flag passes control of socket initialization from
+ * WAMR to the host application. */
+#ifndef WASM_ENABLE_HOST_SOCKET_INIT
+#define WASM_ENABLE_HOST_SOCKET_INIT 0
+#endif
+
 #ifndef WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS
 #if defined(BUILD_TARGET_X86_32) || defined(BUILD_TARGET_X86_64) \
     || defined(BUILD_TARGET_AARCH64)
diff --git a/core/shared/platform/windows/win_socket.c b/core/shared/platform/windows/win_socket.c
index 91d38fd8b6..b19e5b0976 100644
--- a/core/shared/platform/windows/win_socket.c
+++ b/core/shared/platform/windows/win_socket.c
@@ -32,6 +32,7 @@ static bool is_winsock_inited = false;
 int
 init_winsock()
 {
+#if WASM_ENABLE_HOST_SOCKET_INIT == 0
     WSADATA wsaData;
 
     if (!is_winsock_inited) {
@@ -42,6 +43,7 @@ init_winsock()
 
         is_winsock_inited = true;
     }
+#endif
 
     return BHT_OK;
 }
@@ -49,9 +51,11 @@ init_winsock()
 void
 deinit_winsock()
 {
+#if WASM_ENABLE_HOST_SOCKET_INIT == 0
     if (is_winsock_inited) {
         WSACleanup();
     }
+#endif
 }
 
 int

From 4bafa40052b3420e99eaef6f5bfd8bde0cfc4b15 Mon Sep 17 00:00:00 2001
From: YAMAMOTO Takashi <yamamoto@midokura.com>
Date: Tue, 23 Jan 2024 12:52:25 +0900
Subject: [PATCH 02/14] nuttx: If STACK_GUARD_SIZE is not set, leave it to
 config.h (#2927)

cf. https://github.com/apache/nuttx-apps/pull/2241
---
 product-mini/platforms/nuttx/wamr.mk | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/product-mini/platforms/nuttx/wamr.mk b/product-mini/platforms/nuttx/wamr.mk
index 37b633131a..341034e512 100644
--- a/product-mini/platforms/nuttx/wamr.mk
+++ b/product-mini/platforms/nuttx/wamr.mk
@@ -198,9 +198,7 @@ CSRCS += utils.c
 VPATH += $(IWASM_ROOT)/libraries/debug-engine
 endif
 
-ifeq ($(CONFIG_INTERPRETERS_WAMR_STACK_GUARD_SIZE),)
-CFLAGS += -DWASM_STACK_GUARD_SIZE=0
-else
+ifneq ($(CONFIG_INTERPRETERS_WAMR_STACK_GUARD_SIZE),)
 CFLAGS += -DWASM_STACK_GUARD_SIZE=CONFIG_INTERPRETERS_WAMR_STACK_GUARD_SIZE
 endif
 

From 7f035d4206217d0bcbc913a35d9de9837ed8120b Mon Sep 17 00:00:00 2001
From: Wenyong Huang <wenyong.huang@intel.com>
Date: Tue, 23 Jan 2024 12:20:28 +0800
Subject: [PATCH 03/14] perf_tune.md: Add refine the calling processes between
 host and wasm (#3065)

---
 doc/perf_tune.md | 109 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 109 insertions(+)

diff --git a/doc/perf_tune.md b/doc/perf_tune.md
index 5cd631a19b..b366f09c0c 100644
--- a/doc/perf_tune.md
+++ b/doc/perf_tune.md
@@ -190,3 +190,112 @@ $ ./FlameGraph/flamegraph.pl out.folded > perf.foo.wasm.svg
 >
 > Then you will see a new file named _out.folded.translated_ which contains the translated folded stacks.
 > All wasm functions are translated to its original names with a prefix like "[Wasm]"
+
+## 8. Refine the calling processes between host native and wasm application
+
+In some scenarios, there may be lots of callings between host native and wasm application, e.g. frequent callings to AOT/JIT functions from host native or frequent callings to host native from AOT/JIT functions. It is important to refine these calling processes to speedup them, WAMR provides several methods:
+
+### 8.1 Refine callings to native APIs registered by `wasm_runtime_register_natives` from AOT code
+
+When wamrc compiles the wasm file to AOT code, it may generate LLVM IR to call the native API from an AOT function, and if it doesn't know the native API's signature, the generated LLVM IR has to call the runtime API `aot_invoke_native` to invoke the native API, which is a relatively slow way. If developer registers native APIs during execution by calling `wasm_runtime_register_natives` or by `iwasm --native-lib=<lib>`, then developer can also register native APIs with the same signatures to the AOT compiler by `wamrc --native-lib=<lib>`, so as to let the AOT compiler pre-know the native API's signature, and generate optimized LLVM IR to quickly call to the native API.
+
+The below sample registers an API `int test_add(int, int)` to the AOT compiler:
+
+```C
+/* test_add.c */
+
+#include "wasm_export.h"
+
+static int
+test_add_wrapper(wasm_exec_env_t exec_env, int x, int y) {
+    return 0; /* empty function is enough */
+}
+
+#define REG_NATIVE_FUNC(func_name, signature) \
+    { #func_name, func_name##_wrapper, signature, NULL }
+
+static NativeSymbol native_symbols[] = {
+    REG_NATIVE_FUNC(test_add, "(ii)i")
+};
+
+uint32_t
+get_native_lib(char **p_module_name, NativeSymbol **p_native_symbols)
+{
+    *p_module_name = "env";
+    *p_native_symbols = native_symbols;
+    return sizeof(native_symbols) / sizeof(NativeSymbol);
+}
+```
+```bash
+# build native lib
+gcc -O3 -fPIC -shared -I <wamr_root>/core/iwasm/include -o libtest_add.so test_add.c
+# register native lib to aot compiler
+wamrc --native-lib=./libtest_add.so -o <aot_file> <wasm_file>
+```
+
+> Note: no need to do anything for LLVM JIT since the native APIs must have been registered before execution and JIT compiler already knows the native APIs' signatures.
+
+### 8.2 Refine callings to native APIs registered by wasm-c-api `wasm_instance_new` from AOT code
+
+In wasm-c-api mode, when the native APIs are registered by `wasm_instance_new(..., imports, ...)`, developer can use `wamrc --invoke-c-api-import` option to generate the AOT file, which treats the unknown import function as wasm-c-api import function and generates optimized LLVM IR to speedup the calling process.
+
+> Note: no need to do anything for LLVM JIT since the similar flag has been set to JIT compiler in wasm-c-api `wasm_engine_new` when LLVM JIT is enabled.
+
+### 8.3 Refine callings to AOT/JIT functions from host native
+
+Currently by default WAMR runtime has registered many quick AOT/JIT entries to speedup the calling processes to call AOT/JIT functions from host native, as long as developer doesn't disable it by using `cmake -DWAMR_BUILD_QUICK_AOT_ENTRY=0` or setting the compiler macro `WASM_ENABLE_QUICK_AOT_ENTRY` to 0 in the makefile. These quick AOT/JIT entries include:
+
+1. wasm function contains 0 to 4 arguments and 0 to 1 results, with the type of each argument is i32 or i64 and the type of result is i32, i64 or void. These functions are like:
+
+```C
+// no argument
+i32 foo(), i64 foo(), void foo()
+// one argument, each argument is i32 or i64
+i32 foo(i32/i64), i64 foo(i32/i64), void(i32/i64)
+// two arguments, each argument is i32 or i64
+i32 foo(i32/i64, i32/i64), i64 foo(i32/i64, i32/i64), void(i32/i64, i32/i64)
+// three arguments, each argument is i32 or i64
+i32 foo(i32/i64, i32/i64, i32/i64), i64 foo(i32/i64, i32/i64, i32/i64), void(i32/i64, i32/i64, i32/i64)
+// four arguments, each argument is i32 or i64
+i32 foo(i32/i64, i32/i64, i32/i64, i32/i64)
+i64 foo(i32/i64, i32/i64, i32/i64, i32/i64)
+void(i32/i64, i32/i64, i32/i64, i32/i64)
+```
+
+2. wasm function contains 5 arguments and 0 to 1 results, with the type of each argument is i32 and the type of result is i32, i64 or void. These functions are like:
+
+```C
+i32 foo(i32, i32, i32, i32, i32)
+i64 foo(i32, i32, i32, i32, i32)
+void foo(i32, i32, i32, i32, i32)
+```
+
+To speedup the calling processes, developer had better ensure that the signatures of the wasm functions to expose are like above, or add some conversions to achieve it. For example, if a wasm function to call is `f32 foo(f32)`, developer can define a new function `i32 foo1(i32)` like below and export it:
+```C
+int32 foo1(int32 arg_i32)
+{
+    float arg_f32 = *(float *)&arg_i32;
+    float res_f32 = foo(f32);
+    int32 res_i32 = *(int32 *)&res_i32;
+    return res_i32;
+}
+```
+And in the host embedder:
+```
+    uint32 argv[2];
+    float arg_f32 = ...; /* argument to foo */
+    float res_f32;
+    bool ret;
+
+    argv[0] = *(uint32 *)&arg_f32;
+    func = wasm_runtime_lookup_function(module_inst, "foo1", NULL);
+    ret = wasm_runtime_call_wasm(exec_env, func, 1, argv);
+    if (!ret) {
+        /* handle exception */
+        printf("%s\n", wasm_runtime_get_exception(module_inst));
+    }
+    else {
+        /* the return value is stored in argv[0] */
+        res_f32 = *(float *)&argv[0];
+    }
+```

From c8b59588a758c8f969203c1828981d96a3647ce5 Mon Sep 17 00:00:00 2001
From: Wenyong Huang <wenyong.huang@intel.com>
Date: Tue, 23 Jan 2024 12:21:20 +0800
Subject: [PATCH 04/14] Enhance setting write gs base with cmake variable
 (#3066)

In linux x86-64, developer can use cmake variable to configure whether
to enable writing linear memory base address to x86 GS register or not:
- `cmake -DWAMR_DISABLE_WRITE_GS_BASE=1`: disabled it
- `cmake -DWAMR_DISABLE_WRITE_GS_BASE=0`: enabled it
- `cmake` without `-DWAMR_DISABLE_WRITE_GS_BASE=1/0`:
        auto-detected by the compiler
---
 build-scripts/config_common.cmake | 65 +++++++++++++++++++------------
 1 file changed, 41 insertions(+), 24 deletions(-)

diff --git a/build-scripts/config_common.cmake b/build-scripts/config_common.cmake
index 76ebcb0b7c..6e13d0ffe5 100644
--- a/build-scripts/config_common.cmake
+++ b/build-scripts/config_common.cmake
@@ -421,32 +421,49 @@ if (WAMR_BUILD_STATIC_PGO EQUAL 1)
   add_definitions (-DWASM_ENABLE_STATIC_PGO=1)
   message ("     AOT static PGO enabled")
 endif ()
-if (WAMR_DISABLE_WRITE_GS_BASE EQUAL 1)
-  add_definitions (-DWASM_DISABLE_WRITE_GS_BASE=1)
-  message ("     Write linear memory base addr to x86 GS register disabled")
-elseif (WAMR_BUILD_TARGET STREQUAL "X86_64"
-        AND WAMR_BUILD_PLATFORM STREQUAL "linux")
-  set (TEST_WRGSBASE_SOURCE "${CMAKE_BINARY_DIR}/test_wrgsbase.c")
-  file (WRITE "${TEST_WRGSBASE_SOURCE}" "
-  #include <stdio.h>
-  #include <stdint.h>
-  int main() {
-      uint64_t value;
-      asm volatile (\"wrgsbase %0\" : : \"r\"(value));
-      printf(\"WRGSBASE instruction is available.\\n\");
-      return 0;
-  }")
-  # Try to compile and run the test program
-  try_run (TEST_WRGSBASE_RESULT
-    TEST_WRGSBASE_COMPILED
-    ${CMAKE_BINARY_DIR}/test_wrgsbase
-    SOURCES ${TEST_WRGSBASE_SOURCE}
-    CMAKE_FLAGS -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
-  )
-  #message("${TEST_WRGSBASE_COMPILED}, ${TEST_WRGSBASE_RESULT}")
-  if (NOT TEST_WRGSBASE_RESULT EQUAL 0)
+if (WAMR_BUILD_TARGET STREQUAL "X86_64"
+    AND WAMR_BUILD_PLATFORM STREQUAL "linux")
+  if (WAMR_DISABLE_WRITE_GS_BASE EQUAL 1)
+    # disabled by user
+    set (DISABLE_WRITE_GS_BASE 1)
+  elseif (WAMR_DISABLE_WRITE_GS_BASE EQUAL 0)
+    # enabled by user
+    set (DISABLE_WRITE_GS_BASE 0)
+  elseif (CMAKE_CROSSCOMPILING)
+    # disabled in cross compilation environment
+    set (DISABLE_WRITE_GS_BASE 1)
+  else ()
+    # auto-detected by the compiler
+    set (TEST_WRGSBASE_SOURCE "${CMAKE_BINARY_DIR}/test_wrgsbase.c")
+    file (WRITE "${TEST_WRGSBASE_SOURCE}" "
+    #include <stdio.h>
+    #include <stdint.h>
+    int main() {
+        uint64_t value;
+        asm volatile (\"wrgsbase %0\" : : \"r\"(value));
+        printf(\"WRGSBASE instruction is available.\\n\");
+        return 0;
+    }")
+    # Try to compile and run the test program
+    try_run (TEST_WRGSBASE_RESULT
+      TEST_WRGSBASE_COMPILED
+      ${CMAKE_BINARY_DIR}/test_wrgsbase
+      SOURCES ${TEST_WRGSBASE_SOURCE}
+      CMAKE_FLAGS -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+    )
+    #message("${TEST_WRGSBASE_COMPILED}, ${TEST_WRGSBASE_RESULT}")
+    if (TEST_WRGSBASE_RESULT EQUAL 0)
+      set (DISABLE_WRITE_GS_BASE 0)
+    else ()
+      set (DISABLE_WRITE_GS_BASE 1)
+    endif ()
+  endif ()
+  if (DISABLE_WRITE_GS_BASE EQUAL 1)
     add_definitions (-DWASM_DISABLE_WRITE_GS_BASE=1)
     message ("     Write linear memory base addr to x86 GS register disabled")
+  else ()
+    add_definitions (-DWASM_DISABLE_WRITE_GS_BASE=0)
+    message ("     Write linear memory base addr to x86 GS register enabled")
   endif ()
 endif ()
 if (WAMR_CONFIGUABLE_BOUNDS_CHECKS EQUAL 1)

From b44aa654b8f41112dd02a84c2e3246e669e818b6 Mon Sep 17 00:00:00 2001
From: YAMAMOTO Takashi <yamamoto@midokura.com>
Date: Tue, 23 Jan 2024 14:00:19 +0900
Subject: [PATCH 05/14] aot_reloc_x86_64.c: Suggest to try --size-level=0 as
 well (#3067)

cf. https://github.com/bytecodealliance/wasm-micro-runtime/issues/3035
---
 core/iwasm/aot/arch/aot_reloc_x86_64.c | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/core/iwasm/aot/arch/aot_reloc_x86_64.c b/core/iwasm/aot/arch/aot_reloc_x86_64.c
index b5be245932..d1f5cb5acc 100644
--- a/core/iwasm/aot/arch/aot_reloc_x86_64.c
+++ b/core/iwasm/aot/arch/aot_reloc_x86_64.c
@@ -163,7 +163,7 @@ apply_relocation(AOTModule *module, uint8 *target_section_addr,
                     error_buf, error_buf_size,
                     "AOT module load failed: "
                     "relocation truncated to fit R_X86_64_PC32 failed. "
-                    "Try using wamrc with --size-level=1 option.");
+                    "Try using wamrc with --size-level=1 or 0 option.");
                 return false;
             }
 
@@ -196,7 +196,7 @@ apply_relocation(AOTModule *module, uint8 *target_section_addr,
                 snprintf(buf, sizeof(buf),
                          "AOT module load failed: "
                          "relocation truncated to fit %s failed. "
-                         "Try using wamrc with --size-level=1 option.",
+                         "Try using wamrc with --size-level=1 or 0 option.",
                          reloc_type == R_X86_64_32 ? "R_X86_64_32"
                                                    : "R_X86_64_32S");
                 set_error_buf(error_buf, error_buf_size, buf);
@@ -236,15 +236,16 @@ apply_relocation(AOTModule *module, uint8 *target_section_addr,
             target_addr -= sizeof(int32);
 #endif
             if ((int32)target_addr != target_addr) {
-                set_error_buf(error_buf, error_buf_size,
-                              "AOT module load failed: "
-                              "relocation truncated to fit "
+                set_error_buf(
+                    error_buf, error_buf_size,
+                    "AOT module load failed: "
+                    "relocation truncated to fit "
 #if !defined(BH_PLATFORM_WINDOWS)
-                              "R_X86_64_PLT32 failed. "
+                    "R_X86_64_PLT32 failed. "
 #else
-                              "IMAGE_REL_AMD64_32 failed."
+                    "IMAGE_REL_AMD64_32 failed."
 #endif
-                              "Try using wamrc with --size-level=1 option.");
+                    "Try using wamrc with --size-level=1 or 0 option.");
                 return false;
             }
             *(int32 *)(target_section_addr + reloc_offset) = (int32)target_addr;

From ab97d543e0f7c93a2ff4c4bfef351176c751f1ca Mon Sep 17 00:00:00 2001
From: YAMAMOTO Takashi <yamamoto@midokura.com>
Date: Tue, 23 Jan 2024 16:20:01 +0900
Subject: [PATCH 06/14] wasm_cluster_destroy_spawned_exec_env: Avoid "invalid
 exec env" trap (#3068)

Possible alternatives:

* Make wasm_cluster_destroy_spawned_exec_env take two exec_env.
  One for wasm execution and another to specify the target to destroy.

* Make execute functions to switch exec_env as briefly discussed in
  https://github.com/bytecodealliance/wasm-micro-runtime/pull/2047
---
 core/iwasm/libraries/thread-mgr/thread_manager.c | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/core/iwasm/libraries/thread-mgr/thread_manager.c b/core/iwasm/libraries/thread-mgr/thread_manager.c
index 377983a69a..75c66a7c34 100644
--- a/core/iwasm/libraries/thread-mgr/thread_manager.c
+++ b/core/iwasm/libraries/thread-mgr/thread_manager.c
@@ -604,11 +604,24 @@ wasm_cluster_destroy_spawned_exec_env(WASMExecEnv *exec_env)
     WASMCluster *cluster = wasm_exec_env_get_cluster(exec_env);
     wasm_module_inst_t module_inst = wasm_runtime_get_module_inst(exec_env);
     bh_assert(cluster != NULL);
+    WASMExecEnv *exec_env_tls = NULL;
+
+#ifdef OS_ENABLE_HW_BOUND_CHECK
+    /* Note: free_aux_stack can execute the module's "free" function
+     * using the specified exec_env. In case of OS_ENABLE_HW_BOUND_CHECK,
+     * it needs to match the TLS exec_env if available. (Consider a native
+     * function which calls wasm_cluster_destroy_spawned_exec_env.)
+     */
+    exec_env_tls = wasm_runtime_get_exec_env_tls();
+#endif
+    if (exec_env_tls == NULL) {
+        exec_env_tls = exec_env;
+    }
 
     os_mutex_lock(&cluster->lock);
 
     /* Free aux stack space */
-    free_aux_stack(exec_env, exec_env->aux_stack_bottom.bottom);
+    free_aux_stack(exec_env_tls, exec_env->aux_stack_bottom.bottom);
     /* Remove exec_env */
     wasm_cluster_del_exec_env_internal(cluster, exec_env, false);
     /* Destroy exec_env */

From 9f643405295997b214e908d7b9a9325a9a4761ef Mon Sep 17 00:00:00 2001
From: Wenyong Huang <wenyong.huang@intel.com>
Date: Tue, 23 Jan 2024 21:38:30 +0800
Subject: [PATCH 07/14] Fix some issues reported by CodeQL (#3064)

Refer to https://github.com/bytecodealliance/wasm-micro-runtime/pull/2812
and https://github.com/bytecodealliance/wasm-micro-runtime/security/code-scanning?query=pr%3A2812+is%3Aopen
---
 core/iwasm/aot/aot_loader.c                        | 5 ++---
 core/iwasm/common/wasm_c_api.c                     | 8 ++++----
 core/iwasm/common/wasm_native.c                    | 2 +-
 core/iwasm/common/wasm_runtime_common.c            | 3 ++-
 core/iwasm/interpreter/wasm_loader.c               | 6 +++---
 core/iwasm/libraries/libc-wasi/libc_wasi_wrapper.c | 3 ++-
 core/iwasm/libraries/thread-mgr/thread_manager.c   | 2 +-
 core/shared/platform/common/posix/posix_socket.c   | 4 ++--
 core/shared/utils/bh_hashmap.c                     | 4 +++-
 9 files changed, 20 insertions(+), 17 deletions(-)

diff --git a/core/iwasm/aot/aot_loader.c b/core/iwasm/aot/aot_loader.c
index d57f009300..948ac4dfd2 100644
--- a/core/iwasm/aot/aot_loader.c
+++ b/core/iwasm/aot/aot_loader.c
@@ -3134,8 +3134,7 @@ resolve_execute_mode(const uint8 *buf, uint32 size, bool *p_mode,
     p += 8;
     while (p < p_end) {
         read_uint32(p, p_end, section_type);
-        if (section_type <= AOT_SECTION_TYPE_SIGANATURE
-            || section_type == AOT_SECTION_TYPE_TARGET_INFO) {
+        if (section_type <= AOT_SECTION_TYPE_SIGANATURE) {
             read_uint32(p, p_end, section_size);
             CHECK_BUF(p, p_end, section_size);
             if (section_type == AOT_SECTION_TYPE_TARGET_INFO) {
@@ -3150,7 +3149,7 @@ resolve_execute_mode(const uint8 *buf, uint32 size, bool *p_mode,
                 break;
             }
         }
-        else if (section_type > AOT_SECTION_TYPE_SIGANATURE) {
+        else { /* section_type > AOT_SECTION_TYPE_SIGANATURE */
             set_error_buf(error_buf, error_buf_size,
                           "resolve execute mode failed");
             break;
diff --git a/core/iwasm/common/wasm_c_api.c b/core/iwasm/common/wasm_c_api.c
index bdc5315eb8..873dc3b3fc 100644
--- a/core/iwasm/common/wasm_c_api.c
+++ b/core/iwasm/common/wasm_c_api.c
@@ -2294,7 +2294,7 @@ wasm_module_new(wasm_store_t *store, const wasm_byte_vec_t *binary)
         (uint8 *)module_ex->binary->data, (uint32)module_ex->binary->size,
         error_buf, (uint32)sizeof(error_buf));
     if (!(module_ex->module_comm_rt)) {
-        LOG_ERROR(error_buf);
+        LOG_ERROR("%s", error_buf);
         goto free_vec;
     }
 
@@ -2367,7 +2367,7 @@ wasm_module_validate(wasm_store_t *store, const wasm_byte_vec_t *binary)
     }
     else {
         ret = false;
-        LOG_VERBOSE(error_buf);
+        LOG_VERBOSE("%s", error_buf);
     }
 
     return ret;
@@ -3359,7 +3359,7 @@ wasm_func_call(const wasm_func_t *func, const wasm_val_vec_t *params,
     wasm_runtime_set_exception(func->inst_comm_rt, NULL);
     if (!wasm_runtime_call_wasm(exec_env, func_comm_rt, argc, argv)) {
         if (wasm_runtime_get_exception(func->inst_comm_rt)) {
-            LOG_DEBUG(wasm_runtime_get_exception(func->inst_comm_rt));
+            LOG_DEBUG("%s", wasm_runtime_get_exception(func->inst_comm_rt));
             goto failed;
         }
     }
@@ -5044,7 +5044,7 @@ wasm_instance_new_with_args(wasm_store_t *store, const wasm_module_t *module,
         *trap = wasm_trap_new(store, &message);
         wasm_byte_vec_delete(&message);
     }
-    LOG_DEBUG(error_buf);
+    LOG_DEBUG("%s", error_buf);
     wasm_instance_delete_internal(instance);
     return NULL;
 }
diff --git a/core/iwasm/common/wasm_native.c b/core/iwasm/common/wasm_native.c
index e565217819..d2492bc49f 100644
--- a/core/iwasm/common/wasm_native.c
+++ b/core/iwasm/common/wasm_native.c
@@ -194,7 +194,7 @@ wasm_native_resolve_symbol(const char *module_name, const char *field_name,
 {
     NativeSymbolsNode *node, *node_next;
     const char *signature = NULL;
-    void *func_ptr = NULL, *attachment;
+    void *func_ptr = NULL, *attachment = NULL;
 
     node = g_native_symbols_list;
     while (node) {
diff --git a/core/iwasm/common/wasm_runtime_common.c b/core/iwasm/common/wasm_runtime_common.c
index 2bd29205e1..4434a2a0fa 100644
--- a/core/iwasm/common/wasm_runtime_common.c
+++ b/core/iwasm/common/wasm_runtime_common.c
@@ -2905,7 +2905,8 @@ copy_string_array(const char *array[], uint32 array_size, char **buf_ptr,
     /* We add +1 to generate null-terminated array of strings */
     total_size = sizeof(char *) * ((uint64)array_size + 1);
     if (total_size >= UINT32_MAX
-        || (total_size > 0 && !(list = wasm_runtime_malloc((uint32)total_size)))
+        /* total_size must be larger than 0, don' check it again */
+        || !(list = wasm_runtime_malloc((uint32)total_size))
         || buf_size >= UINT32_MAX
         || (buf_size > 0 && !(buf = wasm_runtime_malloc((uint32)buf_size)))) {
 
diff --git a/core/iwasm/interpreter/wasm_loader.c b/core/iwasm/interpreter/wasm_loader.c
index 2f98d02779..db82ab4949 100644
--- a/core/iwasm/interpreter/wasm_loader.c
+++ b/core/iwasm/interpreter/wasm_loader.c
@@ -327,7 +327,7 @@ check_utf8_str(const uint8 *str, uint32 len)
                     return false;
                 }
             }
-            else if (chr >= 0xE1 && chr <= 0xEF) {
+            else { /* chr >= 0xE1 && chr <= 0xEF */
                 if (p[1] < 0x80 || p[1] > 0xBF || p[2] < 0x80 || p[2] > 0xBF) {
                     return false;
                 }
@@ -341,13 +341,13 @@ check_utf8_str(const uint8 *str, uint32 len)
                     return false;
                 }
             }
-            else if (chr >= 0xF1 && chr <= 0xF3) {
+            else if (chr <= 0xF3) { /* and also chr >= 0xF1 */
                 if (p[1] < 0x80 || p[1] > 0xBF || p[2] < 0x80 || p[2] > 0xBF
                     || p[3] < 0x80 || p[3] > 0xBF) {
                     return false;
                 }
             }
-            else if (chr == 0xF4) {
+            else { /* chr == 0xF4 */
                 if (p[1] < 0x80 || p[1] > 0x8F || p[2] < 0x80 || p[2] > 0xBF
                     || p[3] < 0x80 || p[3] > 0xBF) {
                     return false;
diff --git a/core/iwasm/libraries/libc-wasi/libc_wasi_wrapper.c b/core/iwasm/libraries/libc-wasi/libc_wasi_wrapper.c
index d2545f7bd4..0a7419baaf 100644
--- a/core/iwasm/libraries/libc-wasi/libc_wasi_wrapper.c
+++ b/core/iwasm/libraries/libc-wasi/libc_wasi_wrapper.c
@@ -2013,7 +2013,8 @@ copy_buffer_to_iovec_app(wasm_module_inst_t module_inst, uint8 *buf_begin,
         }
 
         if (buf >= buf_begin + buf_size
-            || buf + data->buf_len < buf /* integer overflow */
+            /* integer overflow */
+            || data->buf_len > UINTPTR_MAX - (uintptr_t)buf
             || buf + data->buf_len > buf_begin + buf_size
             || size_to_copy == 0) {
             break;
diff --git a/core/iwasm/libraries/thread-mgr/thread_manager.c b/core/iwasm/libraries/thread-mgr/thread_manager.c
index 75c66a7c34..76638c694e 100644
--- a/core/iwasm/libraries/thread-mgr/thread_manager.c
+++ b/core/iwasm/libraries/thread-mgr/thread_manager.c
@@ -787,7 +787,7 @@ wasm_cluster_dup_c_api_imports(WASMModuleInstanceCommon *module_inst_dst,
 {
     /* workaround about passing instantiate-linking information */
     CApiFuncImport **new_c_api_func_imports = NULL;
-    CApiFuncImport *c_api_func_imports;
+    CApiFuncImport *c_api_func_imports = NULL;
     uint32 import_func_count = 0;
     uint32 size_in_bytes = 0;
 
diff --git a/core/shared/platform/common/posix/posix_socket.c b/core/shared/platform/common/posix/posix_socket.c
index 7bdcb529e6..0293b08d86 100644
--- a/core/shared/platform/common/posix/posix_socket.c
+++ b/core/shared/platform/common/posix/posix_socket.c
@@ -884,7 +884,7 @@ os_socket_set_ip_ttl(bh_socket_t socket, uint8_t ttl_s)
 int
 os_socket_get_ip_ttl(bh_socket_t socket, uint8_t *ttl_s)
 {
-    socklen_t opt_len = sizeof(ttl_s);
+    socklen_t opt_len = sizeof(*ttl_s);
     if (getsockopt(socket, IPPROTO_IP, IP_TTL, ttl_s, &opt_len) != 0) {
         return BHT_ERROR;
     }
@@ -906,7 +906,7 @@ os_socket_set_ip_multicast_ttl(bh_socket_t socket, uint8_t ttl_s)
 int
 os_socket_get_ip_multicast_ttl(bh_socket_t socket, uint8_t *ttl_s)
 {
-    socklen_t opt_len = sizeof(ttl_s);
+    socklen_t opt_len = sizeof(*ttl_s);
     if (getsockopt(socket, IPPROTO_IP, IP_MULTICAST_TTL, ttl_s, &opt_len)
         != 0) {
         return BHT_ERROR;
diff --git a/core/shared/utils/bh_hashmap.c b/core/shared/utils/bh_hashmap.c
index 3502239ad8..794b7a746e 100644
--- a/core/shared/utils/bh_hashmap.c
+++ b/core/shared/utils/bh_hashmap.c
@@ -51,7 +51,9 @@ bh_hash_map_create(uint32 size, bool use_lock, HashFunc hash_func,
                  + sizeof(HashMapElem *) * (uint64)size
                  + (use_lock ? sizeof(korp_mutex) : 0);
 
-    if (total_size >= UINT32_MAX || !(map = BH_MALLOC((uint32)total_size))) {
+    /* size <= HASH_MAP_MAX_SIZE, so total_size won't be larger than
+       UINT32_MAX, no need to check integer overflow */
+    if (!(map = BH_MALLOC((uint32)total_size))) {
         LOG_ERROR("HashMap create failed: alloc memory failed.\n");
         return NULL;
     }

From 0eb788d71159bf6cb7f0ea46fd504b83888d9e97 Mon Sep 17 00:00:00 2001
From: Wenyong Huang <wenyong.huang@intel.com>
Date: Wed, 24 Jan 2024 09:45:57 +0800
Subject: [PATCH 08/14] build_wamr.md: Update the document (#3074)

Add description for `WAMR_BUILD_LINUX_PERF`, `WAMR_BUILD_QUICK_AOT_ENTRY`
and `WAMR_BUILD_MODULE_INST_CONTEXT`.
And add some reference links.
---
 doc/build_wamr.md | 37 +++++++++++++++++++++++++++++++++++--
 1 file changed, 35 insertions(+), 2 deletions(-)

diff --git a/doc/build_wamr.md b/doc/build_wamr.md
index 1ac62409cc..a239a4050b 100644
--- a/doc/build_wamr.md
+++ b/doc/build_wamr.md
@@ -62,6 +62,7 @@ cmake -DWAMR_BUILD_PLATFORM=linux -DWAMR_BUILD_TARGET=ARM
 #### **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**
 
@@ -82,6 +83,8 @@ cmake -DWAMR_BUILD_PLATFORM=linux -DWAMR_BUILD_TARGET=ARM
 - **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**
 - **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.
@@ -90,8 +93,11 @@ cmake -DWAMR_BUILD_PLATFORM=linux -DWAMR_BUILD_TARGET=ARM
 - **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**
 - **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**
 - **WAMR_BUILD_WASI_NN_ENABLE_GPU**=1/0, default to disable if not set
@@ -137,12 +143,17 @@ cmake -DWAMR_BUILD_PLATFORM=linux -DWAMR_BUILD_TARGET=ARM
 > 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)**
 - **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.
 
 > The function name searching sequence is the same with dump call stack feature.
 
+> Also refer to [Tune the performance of running wasm/aot file](./perf_tune.md).
+
+
 #### **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.
 
@@ -192,7 +203,7 @@ Currently we only profile the memory consumption of module, module_instance and
 
 #### **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) for more details.
+> 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**
 - **WAMR_BUILD_LOAD_CUSTOM_SECTION**=1/0, default to disable if not set
@@ -207,12 +218,34 @@ Currently we only profile the memory consumption of module, module_instance and
 - **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 the writing linear memory base address to x86 GS segment register
+### **Disable the writing 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.
+
 ### **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**
+- **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**
+- **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
+    wasm_runtime_destroy_context_key
+    wasm_runtime_set_context
+    wasm_runtime_set_context_spread
+    wasm_runtime_get_context
+```
+> Note: See [wasm_export.h](../core/iwasm/include/wasm_export.h) for more details.
+
+### **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.
 
 **Combination of configurations:**
 

From f56154ed80459c2d39c0dc4bb07473ac02659d92 Mon Sep 17 00:00:00 2001
From: YAMAMOTO Takashi <yamamoto@midokura.com>
Date: Wed, 24 Jan 2024 10:46:53 +0900
Subject: [PATCH 09/14] thread-mgr: Fix locking problems around aux stack
 allocation (#3073)

Fixes: https://github.com/bytecodealliance/wasm-micro-runtime/issues/3069
---
 .../libraries/thread-mgr/thread_manager.c     | 101 ++++++++----------
 1 file changed, 44 insertions(+), 57 deletions(-)

diff --git a/core/iwasm/libraries/thread-mgr/thread_manager.c b/core/iwasm/libraries/thread-mgr/thread_manager.c
index 76638c694e..bdfc38dded 100644
--- a/core/iwasm/libraries/thread-mgr/thread_manager.c
+++ b/core/iwasm/libraries/thread-mgr/thread_manager.c
@@ -137,9 +137,10 @@ safe_traverse_exec_env_list(WASMCluster *cluster, list_visitor visitor,
     return ret;
 }
 
-/* The caller must lock cluster->lock */
-static bool
-allocate_aux_stack(WASMExecEnv *exec_env, uint32 *start, uint32 *size)
+/* The caller must not have any locks */
+bool
+wasm_cluster_allocate_aux_stack(WASMExecEnv *exec_env, uint32 *p_start,
+                                uint32 *p_size)
 {
     WASMCluster *cluster = wasm_exec_env_get_cluster(exec_env);
 #if WASM_ENABLE_HEAP_AUX_STACK_ALLOCATION != 0
@@ -149,8 +150,8 @@ allocate_aux_stack(WASMExecEnv *exec_env, uint32 *start, uint32 *size)
 
     stack_end = wasm_runtime_module_malloc_internal(module_inst, exec_env,
                                                     cluster->stack_size, NULL);
-    *start = stack_end + cluster->stack_size;
-    *size = cluster->stack_size;
+    *p_start = stack_end + cluster->stack_size;
+    *p_size = cluster->stack_size;
 
     return stack_end != 0;
 #else
@@ -158,27 +159,33 @@ allocate_aux_stack(WASMExecEnv *exec_env, uint32 *start, uint32 *size)
 
     /* If the module doesn't have aux stack info,
         it can't create any threads */
-    if (!cluster->stack_segment_occupied)
+
+    os_mutex_lock(&cluster->lock);
+    if (!cluster->stack_segment_occupied) {
+        os_mutex_unlock(&cluster->lock);
         return false;
+    }
 
     for (i = 0; i < cluster_max_thread_num; i++) {
         if (!cluster->stack_segment_occupied[i]) {
-            if (start)
-                *start = cluster->stack_tops[i];
-            if (size)
-                *size = cluster->stack_size;
+            if (p_start)
+                *p_start = cluster->stack_tops[i];
+            if (p_size)
+                *p_size = cluster->stack_size;
             cluster->stack_segment_occupied[i] = true;
+            os_mutex_unlock(&cluster->lock);
             return true;
         }
     }
+    os_mutex_unlock(&cluster->lock);
 
     return false;
 #endif
 }
 
-/* The caller must lock cluster->lock */
-static bool
-free_aux_stack(WASMExecEnv *exec_env, uint32 start)
+/* The caller must not have any locks */
+bool
+wasm_cluster_free_aux_stack(WASMExecEnv *exec_env, uint32 start)
 {
     WASMCluster *cluster = wasm_exec_env_get_cluster(exec_env);
 
@@ -199,43 +206,19 @@ free_aux_stack(WASMExecEnv *exec_env, uint32 start)
 #else
     uint32 i;
 
+    os_mutex_lock(&cluster->lock);
     for (i = 0; i < cluster_max_thread_num; i++) {
         if (start == cluster->stack_tops[i]) {
             cluster->stack_segment_occupied[i] = false;
+            os_mutex_unlock(&cluster->lock);
             return true;
         }
     }
+    os_mutex_unlock(&cluster->lock);
     return false;
 #endif
 }
 
-bool
-wasm_cluster_allocate_aux_stack(WASMExecEnv *exec_env, uint32 *p_start,
-                                uint32 *p_size)
-{
-    WASMCluster *cluster = wasm_exec_env_get_cluster(exec_env);
-    bool ret;
-
-    os_mutex_lock(&cluster->lock);
-    ret = allocate_aux_stack(exec_env, p_start, p_size);
-    os_mutex_unlock(&cluster->lock);
-
-    return ret;
-}
-
-bool
-wasm_cluster_free_aux_stack(WASMExecEnv *exec_env, uint32 start)
-{
-    WASMCluster *cluster = wasm_exec_env_get_cluster(exec_env);
-    bool ret;
-
-    os_mutex_lock(&cluster->lock);
-    ret = free_aux_stack(exec_env, start);
-    os_mutex_unlock(&cluster->lock);
-
-    return ret;
-}
-
 WASMCluster *
 wasm_cluster_create(WASMExecEnv *exec_env)
 {
@@ -535,6 +518,13 @@ wasm_cluster_spawn_exec_env(WASMExecEnv *exec_env)
         goto fail1;
     }
 
+    if (!wasm_cluster_allocate_aux_stack(exec_env, &aux_stack_start,
+                                         &aux_stack_size)) {
+        LOG_ERROR("thread manager error: "
+                  "failed to allocate aux stack space for new thread");
+        goto fail1;
+    }
+
     os_mutex_lock(&cluster->lock);
 
     if (cluster->has_exception || cluster->processing) {
@@ -561,16 +551,10 @@ wasm_cluster_spawn_exec_env(WASMExecEnv *exec_env)
         goto fail2;
     }
 
-    if (!allocate_aux_stack(exec_env, &aux_stack_start, &aux_stack_size)) {
-        LOG_ERROR("thread manager error: "
-                  "failed to allocate aux stack space for new thread");
-        goto fail3;
-    }
-
     /* Set aux stack for current thread */
     if (!wasm_exec_env_set_aux_stack(new_exec_env, aux_stack_start,
                                      aux_stack_size)) {
-        goto fail4;
+        goto fail3;
     }
 
     /* Inherit suspend_flags of parent thread */
@@ -578,20 +562,19 @@ wasm_cluster_spawn_exec_env(WASMExecEnv *exec_env)
         (exec_env->suspend_flags.flags & WASM_SUSPEND_FLAG_INHERIT_MASK);
 
     if (!wasm_cluster_add_exec_env(cluster, new_exec_env)) {
-        goto fail4;
+        goto fail3;
     }
 
     os_mutex_unlock(&cluster->lock);
 
     return new_exec_env;
 
-fail4:
-    /* free the allocated aux stack space */
-    free_aux_stack(exec_env, aux_stack_start);
 fail3:
     wasm_exec_env_destroy_internal(new_exec_env);
 fail2:
     os_mutex_unlock(&cluster->lock);
+    /* free the allocated aux stack space */
+    wasm_cluster_free_aux_stack(exec_env, aux_stack_start);
 fail1:
     wasm_runtime_deinstantiate_internal(new_module_inst, true);
 
@@ -618,10 +601,12 @@ wasm_cluster_destroy_spawned_exec_env(WASMExecEnv *exec_env)
         exec_env_tls = exec_env;
     }
 
+    /* Free aux stack space */
+    wasm_cluster_free_aux_stack(exec_env_tls,
+                                exec_env->aux_stack_bottom.bottom);
+
     os_mutex_lock(&cluster->lock);
 
-    /* Free aux stack space */
-    free_aux_stack(exec_env_tls, exec_env->aux_stack_bottom.bottom);
     /* Remove exec_env */
     wasm_cluster_del_exec_env_internal(cluster, exec_env, false);
     /* Destroy exec_env */
@@ -667,6 +652,9 @@ thread_manager_start_routine(void *arg)
     wasm_cluster_thread_exited(exec_env);
 #endif
 
+    /* Free aux stack space */
+    wasm_cluster_free_aux_stack(exec_env, exec_env->aux_stack_bottom.bottom);
+
     os_mutex_lock(&cluster_list_lock);
 
     os_mutex_lock(&cluster->lock);
@@ -687,8 +675,6 @@ thread_manager_start_routine(void *arg)
     os_printf("========================================\n");
 #endif
 
-    /* Free aux stack space */
-    free_aux_stack(exec_env, exec_env->aux_stack_bottom.bottom);
     /* Remove exec_env */
     wasm_cluster_del_exec_env_internal(cluster, exec_env, false);
     /* Destroy exec_env */
@@ -1063,6 +1049,9 @@ wasm_cluster_exit_thread(WASMExecEnv *exec_env, void *retval)
     wasm_cluster_thread_exited(exec_env);
 #endif
 
+    /* Free aux stack space */
+    wasm_cluster_free_aux_stack(exec_env, exec_env->aux_stack_bottom.bottom);
+
     /* App exit the thread, free the resources before exit native thread */
 
     os_mutex_lock(&cluster_list_lock);
@@ -1081,8 +1070,6 @@ wasm_cluster_exit_thread(WASMExecEnv *exec_env, void *retval)
 
     module_inst = exec_env->module_inst;
 
-    /* Free aux stack space */
-    free_aux_stack(exec_env, exec_env->aux_stack_bottom.bottom);
     /* Remove exec_env */
     wasm_cluster_del_exec_env_internal(cluster, exec_env, false);
     /* Destroy exec_env */

From 1505e6170486acf72d2c3c2593665d1d0c91438c Mon Sep 17 00:00:00 2001
From: Marcin Kolny <marcin.kolny@gmail.com>
Date: Wed, 24 Jan 2024 03:21:13 +0000
Subject: [PATCH 10/14] Remove a lot of "unused parameter" warnings (#3075)

They might shadow some of the real issues, so better to keep the number
of warnings as low as possible.
---
 .../libc-builtin/libc_builtin_wrapper.c       |  48 ++++-
 .../libraries/libc-wasi/libc_wasi_wrapper.c   | 191 +++++++++---------
 .../sandboxed-system-primitives/src/posix.c   |  20 +-
 .../platform/common/posix/posix_blocking_op.c |   1 +
 .../platform/common/posix/posix_clock.c       |   2 +
 .../platform/common/posix/posix_memmap.c      |   3 +
 6 files changed, 167 insertions(+), 98 deletions(-)

diff --git a/core/iwasm/libraries/libc-builtin/libc_builtin_wrapper.c b/core/iwasm/libraries/libc-builtin/libc_builtin_wrapper.c
index fec8fcc971..8e6a65a4aa 100644
--- a/core/iwasm/libraries/libc-builtin/libc_builtin_wrapper.c
+++ b/core/iwasm/libraries/libc-builtin/libc_builtin_wrapper.c
@@ -473,12 +473,16 @@ snprintf_wrapper(wasm_exec_env_t exec_env, char *str, uint32 size,
 static int
 puts_wrapper(wasm_exec_env_t exec_env, const char *str)
 {
+    (void)exec_env;
+
     return os_printf("%s\n", str);
 }
 
 static int
 putchar_wrapper(wasm_exec_env_t exec_env, int c)
 {
+    (void)exec_env;
+
     os_printf("%c", c);
     return 1;
 }
@@ -585,6 +589,8 @@ strchr_wrapper(wasm_exec_env_t exec_env, const char *s, int32 c)
 static int32
 strcmp_wrapper(wasm_exec_env_t exec_env, const char *s1, const char *s2)
 {
+    (void)exec_env;
+
     /* s1 and s2 have been checked by runtime */
     return strcmp(s1, s2);
 }
@@ -641,6 +647,8 @@ strncpy_wrapper(wasm_exec_env_t exec_env, char *dst, const char *src,
 static uint32
 strlen_wrapper(wasm_exec_env_t exec_env, const char *s)
 {
+    (void)exec_env;
+
     /* s has been checked by runtime */
     return (uint32)strlen(s);
 }
@@ -693,6 +701,7 @@ free_wrapper(wasm_exec_env_t exec_env, void *ptr)
 static int32
 atoi_wrapper(wasm_exec_env_t exec_env, const char *s)
 {
+    (void)exec_env;
     /* s has been checked by runtime */
     return atoi(s);
 }
@@ -757,6 +766,8 @@ static int32
 strncasecmp_wrapper(wasm_exec_env_t exec_env, const char *s1, const char *s2,
                     uint32 n)
 {
+    (void)exec_env;
+
     /* s1 and s2 have been checked by runtime */
     return strncasecmp(s1, s2, n);
 }
@@ -764,6 +775,8 @@ strncasecmp_wrapper(wasm_exec_env_t exec_env, const char *s1, const char *s2,
 static uint32
 strspn_wrapper(wasm_exec_env_t exec_env, const char *s, const char *accept)
 {
+    (void)exec_env;
+
     /* s and accept have been checked by runtime */
     return (uint32)strspn(s, accept);
 }
@@ -771,6 +784,8 @@ strspn_wrapper(wasm_exec_env_t exec_env, const char *s, const char *accept)
 static uint32
 strcspn_wrapper(wasm_exec_env_t exec_env, const char *s, const char *reject)
 {
+    (void)exec_env;
+
     /* s and reject have been checked by runtime */
     return (uint32)strcspn(s, reject);
 }
@@ -787,60 +802,80 @@ strstr_wrapper(wasm_exec_env_t exec_env, const char *s, const char *find)
 static int32
 isupper_wrapper(wasm_exec_env_t exec_env, int32 c)
 {
+    (void)exec_env;
+
     return isupper(c);
 }
 
 static int32
 isalpha_wrapper(wasm_exec_env_t exec_env, int32 c)
 {
+    (void)exec_env;
+
     return isalpha(c);
 }
 
 static int32
 isspace_wrapper(wasm_exec_env_t exec_env, int32 c)
 {
+    (void)exec_env;
+
     return isspace(c);
 }
 
 static int32
 isgraph_wrapper(wasm_exec_env_t exec_env, int32 c)
 {
+    (void)exec_env;
+
     return isgraph(c);
 }
 
 static int32
 isprint_wrapper(wasm_exec_env_t exec_env, int32 c)
 {
+    (void)exec_env;
+
     return isprint(c);
 }
 
 static int32
 isdigit_wrapper(wasm_exec_env_t exec_env, int32 c)
 {
+    (void)exec_env;
+
     return isdigit(c);
 }
 
 static int32
 isxdigit_wrapper(wasm_exec_env_t exec_env, int32 c)
 {
+    (void)exec_env;
+
     return isxdigit(c);
 }
 
 static int32
 tolower_wrapper(wasm_exec_env_t exec_env, int32 c)
 {
+    (void)exec_env;
+
     return tolower(c);
 }
 
 static int32
 toupper_wrapper(wasm_exec_env_t exec_env, int32 c)
 {
+    (void)exec_env;
+
     return toupper(c);
 }
 
 static int32
 isalnum_wrapper(wasm_exec_env_t exec_env, int32 c)
 {
+    (void)exec_env;
+
     return isalnum(c);
 }
 
@@ -899,7 +934,10 @@ __cxa_allocate_exception_wrapper(wasm_exec_env_t exec_env, uint32 thrown_size)
 
 static void
 __cxa_begin_catch_wrapper(wasm_exec_env_t exec_env, void *exception_object)
-{}
+{
+    (void)exec_env;
+    (void)exception_object;
+}
 
 static void
 __cxa_throw_wrapper(wasm_exec_env_t exec_env, void *thrown_exception,
@@ -908,6 +946,10 @@ __cxa_throw_wrapper(wasm_exec_env_t exec_env, void *thrown_exception,
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     char buf[32];
 
+    (void)thrown_exception;
+    (void)tinfo;
+    (void)table_elem_idx;
+
     snprintf(buf, sizeof(buf), "%s", "exception thrown by stdc++");
     wasm_runtime_set_exception(module_inst, buf);
 }
@@ -924,6 +966,8 @@ clock_gettime_wrapper(wasm_exec_env_t exec_env, uint32 clk_id,
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     uint64 time;
 
+    (void)clk_id;
+
     if (!validate_native_addr(ts_app, sizeof(struct timespec_app)))
         return (uint32)-1;
 
@@ -937,6 +981,8 @@ clock_gettime_wrapper(wasm_exec_env_t exec_env, uint32 clk_id,
 static uint64
 clock_wrapper(wasm_exec_env_t exec_env)
 {
+    (void)exec_env;
+
     /* Convert to nano seconds as CLOCKS_PER_SEC in wasi-sdk */
 
     return os_time_get_boot_us() * 1000;
diff --git a/core/iwasm/libraries/libc-wasi/libc_wasi_wrapper.c b/core/iwasm/libraries/libc-wasi/libc_wasi_wrapper.c
index 0a7419baaf..0b69de6b92 100644
--- a/core/iwasm/libraries/libc-wasi/libc_wasi_wrapper.c
+++ b/core/iwasm/libraries/libc-wasi/libc_wasi_wrapper.c
@@ -72,7 +72,7 @@ min_uint32(uint32_t a, uint32_t b)
 }
 
 static inline struct fd_table *
-wasi_ctx_get_curfds(wasm_module_inst_t module_inst, wasi_ctx_t wasi_ctx)
+wasi_ctx_get_curfds(wasi_ctx_t wasi_ctx)
 {
     if (!wasi_ctx)
         return NULL;
@@ -88,7 +88,7 @@ wasi_ctx_get_argv_environ(wasm_module_inst_t module_inst, wasi_ctx_t wasi_ctx)
 }
 
 static inline struct fd_prestats *
-wasi_ctx_get_prestats(wasm_module_inst_t module_inst, wasi_ctx_t wasi_ctx)
+wasi_ctx_get_prestats(wasi_ctx_t wasi_ctx)
 {
     if (!wasi_ctx)
         return NULL;
@@ -96,7 +96,7 @@ wasi_ctx_get_prestats(wasm_module_inst_t module_inst, wasi_ctx_t wasi_ctx)
 }
 
 static inline struct addr_pool *
-wasi_ctx_get_addr_pool(wasm_module_inst_t module_inst, wasi_ctx_t wasi_ctx)
+wasi_ctx_get_addr_pool(wasi_ctx_t wasi_ctx)
 {
     if (!wasi_ctx)
         return NULL;
@@ -292,7 +292,7 @@ wasi_fd_prestat_get(wasm_exec_env_t exec_env, wasi_fd_t fd,
 {
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     wasi_ctx_t wasi_ctx = get_wasi_ctx(module_inst);
-    struct fd_prestats *prestats = wasi_ctx_get_prestats(module_inst, wasi_ctx);
+    struct fd_prestats *prestats = wasi_ctx_get_prestats(wasi_ctx);
     wasi_prestat_t prestat;
     wasi_errno_t err;
 
@@ -317,7 +317,7 @@ wasi_fd_prestat_dir_name(wasm_exec_env_t exec_env, wasi_fd_t fd, char *path,
 {
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     wasi_ctx_t wasi_ctx = get_wasi_ctx(module_inst);
-    struct fd_prestats *prestats = wasi_ctx_get_prestats(module_inst, wasi_ctx);
+    struct fd_prestats *prestats = wasi_ctx_get_prestats(wasi_ctx);
 
     if (!wasi_ctx)
         return (wasi_errno_t)-1;
@@ -330,8 +330,8 @@ wasi_fd_close(wasm_exec_env_t exec_env, wasi_fd_t fd)
 {
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     wasi_ctx_t wasi_ctx = get_wasi_ctx(module_inst);
-    struct fd_table *curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
-    struct fd_prestats *prestats = wasi_ctx_get_prestats(module_inst, wasi_ctx);
+    struct fd_table *curfds = wasi_ctx_get_curfds(wasi_ctx);
+    struct fd_prestats *prestats = wasi_ctx_get_prestats(wasi_ctx);
 
     if (!wasi_ctx)
         return (wasi_errno_t)-1;
@@ -344,7 +344,7 @@ wasi_fd_datasync(wasm_exec_env_t exec_env, wasi_fd_t fd)
 {
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     wasi_ctx_t wasi_ctx = get_wasi_ctx(module_inst);
-    struct fd_table *curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    struct fd_table *curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     if (!wasi_ctx)
         return (wasi_errno_t)-1;
@@ -358,7 +358,7 @@ wasi_fd_pread(wasm_exec_env_t exec_env, wasi_fd_t fd, iovec_app_t *iovec_app,
 {
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     wasi_ctx_t wasi_ctx = get_wasi_ctx(module_inst);
-    struct fd_table *curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    struct fd_table *curfds = wasi_ctx_get_curfds(wasi_ctx);
     wasi_iovec_t *iovec, *iovec_begin;
     uint64 total_size;
     size_t nread;
@@ -412,7 +412,7 @@ wasi_fd_pwrite(wasm_exec_env_t exec_env, wasi_fd_t fd,
 {
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     wasi_ctx_t wasi_ctx = get_wasi_ctx(module_inst);
-    struct fd_table *curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    struct fd_table *curfds = wasi_ctx_get_curfds(wasi_ctx);
     wasi_ciovec_t *ciovec, *ciovec_begin;
     uint64 total_size;
     size_t nwritten;
@@ -465,7 +465,7 @@ wasi_fd_read(wasm_exec_env_t exec_env, wasi_fd_t fd,
 {
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     wasi_ctx_t wasi_ctx = get_wasi_ctx(module_inst);
-    struct fd_table *curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    struct fd_table *curfds = wasi_ctx_get_curfds(wasi_ctx);
     wasi_iovec_t *iovec, *iovec_begin;
     uint64 total_size;
     size_t nread;
@@ -517,8 +517,8 @@ wasi_fd_renumber(wasm_exec_env_t exec_env, wasi_fd_t from, wasi_fd_t to)
 {
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     wasi_ctx_t wasi_ctx = get_wasi_ctx(module_inst);
-    struct fd_table *curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
-    struct fd_prestats *prestats = wasi_ctx_get_prestats(module_inst, wasi_ctx);
+    struct fd_table *curfds = wasi_ctx_get_curfds(wasi_ctx);
+    struct fd_prestats *prestats = wasi_ctx_get_prestats(wasi_ctx);
 
     if (!wasi_ctx)
         return (wasi_errno_t)-1;
@@ -532,7 +532,7 @@ wasi_fd_seek(wasm_exec_env_t exec_env, wasi_fd_t fd, wasi_filedelta_t offset,
 {
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     wasi_ctx_t wasi_ctx = get_wasi_ctx(module_inst);
-    struct fd_table *curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    struct fd_table *curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     if (!wasi_ctx)
         return (wasi_errno_t)-1;
@@ -549,7 +549,7 @@ wasi_fd_tell(wasm_exec_env_t exec_env, wasi_fd_t fd, wasi_filesize_t *newoffset)
 {
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     wasi_ctx_t wasi_ctx = get_wasi_ctx(module_inst);
-    struct fd_table *curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    struct fd_table *curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     if (!wasi_ctx)
         return (wasi_errno_t)-1;
@@ -566,7 +566,7 @@ wasi_fd_fdstat_get(wasm_exec_env_t exec_env, wasi_fd_t fd,
 {
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     wasi_ctx_t wasi_ctx = get_wasi_ctx(module_inst);
-    struct fd_table *curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    struct fd_table *curfds = wasi_ctx_get_curfds(wasi_ctx);
     wasi_fdstat_t fdstat;
     wasi_errno_t err;
 
@@ -590,7 +590,7 @@ wasi_fd_fdstat_set_flags(wasm_exec_env_t exec_env, wasi_fd_t fd,
 {
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     wasi_ctx_t wasi_ctx = get_wasi_ctx(module_inst);
-    struct fd_table *curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    struct fd_table *curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     if (!wasi_ctx)
         return (wasi_errno_t)-1;
@@ -605,7 +605,7 @@ wasi_fd_fdstat_set_rights(wasm_exec_env_t exec_env, wasi_fd_t fd,
 {
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     wasi_ctx_t wasi_ctx = get_wasi_ctx(module_inst);
-    struct fd_table *curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    struct fd_table *curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     if (!wasi_ctx)
         return (wasi_errno_t)-1;
@@ -619,7 +619,7 @@ wasi_fd_sync(wasm_exec_env_t exec_env, wasi_fd_t fd)
 {
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     wasi_ctx_t wasi_ctx = get_wasi_ctx(module_inst);
-    struct fd_table *curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    struct fd_table *curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     if (!wasi_ctx)
         return (wasi_errno_t)-1;
@@ -634,7 +634,7 @@ wasi_fd_write(wasm_exec_env_t exec_env, wasi_fd_t fd,
 {
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     wasi_ctx_t wasi_ctx = get_wasi_ctx(module_inst);
-    struct fd_table *curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    struct fd_table *curfds = wasi_ctx_get_curfds(wasi_ctx);
     wasi_ciovec_t *ciovec, *ciovec_begin;
     uint64 total_size;
     size_t nwritten;
@@ -687,7 +687,7 @@ wasi_fd_advise(wasm_exec_env_t exec_env, wasi_fd_t fd, wasi_filesize_t offset,
 {
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     wasi_ctx_t wasi_ctx = get_wasi_ctx(module_inst);
-    struct fd_table *curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    struct fd_table *curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     if (!wasi_ctx)
         return (wasi_errno_t)-1;
@@ -701,7 +701,7 @@ wasi_fd_allocate(wasm_exec_env_t exec_env, wasi_fd_t fd, wasi_filesize_t offset,
 {
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     wasi_ctx_t wasi_ctx = get_wasi_ctx(module_inst);
-    struct fd_table *curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    struct fd_table *curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     if (!wasi_ctx)
         return (wasi_errno_t)-1;
@@ -715,7 +715,7 @@ wasi_path_create_directory(wasm_exec_env_t exec_env, wasi_fd_t fd,
 {
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     wasi_ctx_t wasi_ctx = get_wasi_ctx(module_inst);
-    struct fd_table *curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    struct fd_table *curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     if (!wasi_ctx)
         return (wasi_errno_t)-1;
@@ -732,8 +732,8 @@ wasi_path_link(wasm_exec_env_t exec_env, wasi_fd_t old_fd,
 {
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     wasi_ctx_t wasi_ctx = get_wasi_ctx(module_inst);
-    struct fd_table *curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
-    struct fd_prestats *prestats = wasi_ctx_get_prestats(module_inst, wasi_ctx);
+    struct fd_table *curfds = wasi_ctx_get_curfds(wasi_ctx);
+    struct fd_prestats *prestats = wasi_ctx_get_prestats(wasi_ctx);
 
     if (!wasi_ctx)
         return (wasi_errno_t)-1;
@@ -752,7 +752,7 @@ wasi_path_open(wasm_exec_env_t exec_env, wasi_fd_t dirfd,
 {
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     wasi_ctx_t wasi_ctx = get_wasi_ctx(module_inst);
-    struct fd_table *curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    struct fd_table *curfds = wasi_ctx_get_curfds(wasi_ctx);
     wasi_fd_t fd = (wasi_fd_t)-1; /* set fd_app -1 if path open failed */
     wasi_errno_t err;
 
@@ -776,7 +776,7 @@ wasi_fd_readdir(wasm_exec_env_t exec_env, wasi_fd_t fd, void *buf,
 {
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     wasi_ctx_t wasi_ctx = get_wasi_ctx(module_inst);
-    struct fd_table *curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    struct fd_table *curfds = wasi_ctx_get_curfds(wasi_ctx);
     size_t bufused;
     wasi_errno_t err;
 
@@ -802,7 +802,7 @@ wasi_path_readlink(wasm_exec_env_t exec_env, wasi_fd_t fd, const char *path,
 {
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     wasi_ctx_t wasi_ctx = get_wasi_ctx(module_inst);
-    struct fd_table *curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    struct fd_table *curfds = wasi_ctx_get_curfds(wasi_ctx);
     size_t bufused;
     wasi_errno_t err;
 
@@ -828,7 +828,7 @@ wasi_path_rename(wasm_exec_env_t exec_env, wasi_fd_t old_fd,
 {
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     wasi_ctx_t wasi_ctx = get_wasi_ctx(module_inst);
-    struct fd_table *curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    struct fd_table *curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     if (!wasi_ctx)
         return (wasi_errno_t)-1;
@@ -844,7 +844,7 @@ wasi_fd_filestat_get(wasm_exec_env_t exec_env, wasi_fd_t fd,
 {
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     wasi_ctx_t wasi_ctx = get_wasi_ctx(module_inst);
-    struct fd_table *curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    struct fd_table *curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     if (!wasi_ctx)
         return (wasi_errno_t)-1;
@@ -862,7 +862,7 @@ wasi_fd_filestat_set_times(wasm_exec_env_t exec_env, wasi_fd_t fd,
 {
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     wasi_ctx_t wasi_ctx = get_wasi_ctx(module_inst);
-    struct fd_table *curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    struct fd_table *curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     if (!wasi_ctx)
         return (wasi_errno_t)-1;
@@ -877,7 +877,7 @@ wasi_fd_filestat_set_size(wasm_exec_env_t exec_env, wasi_fd_t fd,
 {
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     wasi_ctx_t wasi_ctx = get_wasi_ctx(module_inst);
-    struct fd_table *curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    struct fd_table *curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     if (!wasi_ctx)
         return (wasi_errno_t)-1;
@@ -892,7 +892,7 @@ wasi_path_filestat_get(wasm_exec_env_t exec_env, wasi_fd_t fd,
 {
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     wasi_ctx_t wasi_ctx = get_wasi_ctx(module_inst);
-    struct fd_table *curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    struct fd_table *curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     if (!wasi_ctx)
         return (wasi_errno_t)-1;
@@ -912,7 +912,7 @@ wasi_path_filestat_set_times(wasm_exec_env_t exec_env, wasi_fd_t fd,
 {
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     wasi_ctx_t wasi_ctx = get_wasi_ctx(module_inst);
-    struct fd_table *curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    struct fd_table *curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     if (!wasi_ctx)
         return (wasi_errno_t)-1;
@@ -929,8 +929,8 @@ wasi_path_symlink(wasm_exec_env_t exec_env, const char *old_path,
 {
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     wasi_ctx_t wasi_ctx = get_wasi_ctx(module_inst);
-    struct fd_table *curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
-    struct fd_prestats *prestats = wasi_ctx_get_prestats(module_inst, wasi_ctx);
+    struct fd_table *curfds = wasi_ctx_get_curfds(wasi_ctx);
+    struct fd_prestats *prestats = wasi_ctx_get_prestats(wasi_ctx);
 
     if (!wasi_ctx)
         return (wasi_errno_t)-1;
@@ -945,7 +945,7 @@ wasi_path_unlink_file(wasm_exec_env_t exec_env, wasi_fd_t fd, const char *path,
 {
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     wasi_ctx_t wasi_ctx = get_wasi_ctx(module_inst);
-    struct fd_table *curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    struct fd_table *curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     if (!wasi_ctx)
         return (wasi_errno_t)-1;
@@ -959,7 +959,7 @@ wasi_path_remove_directory(wasm_exec_env_t exec_env, wasi_fd_t fd,
 {
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     wasi_ctx_t wasi_ctx = get_wasi_ctx(module_inst);
-    struct fd_table *curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    struct fd_table *curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     if (!wasi_ctx)
         return (wasi_errno_t)-1;
@@ -1076,7 +1076,7 @@ wasi_poll_oneoff(wasm_exec_env_t exec_env, const wasi_subscription_t *in,
 {
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     wasi_ctx_t wasi_ctx = get_wasi_ctx(module_inst);
-    struct fd_table *curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    struct fd_table *curfds = wasi_ctx_get_curfds(wasi_ctx);
     size_t nevents = 0;
     wasi_errno_t err;
 
@@ -1128,6 +1128,8 @@ wasi_proc_raise(wasm_exec_env_t exec_env, wasi_signal_t sig)
 static wasi_errno_t
 wasi_random_get(wasm_exec_env_t exec_env, void *buf, uint32 buf_len)
 {
+    (void)exec_env;
+
     return wasmtime_ssp_random_get(buf, buf_len);
 }
 
@@ -1142,7 +1144,7 @@ wasi_sock_accept(wasm_exec_env_t exec_env, wasi_fd_t fd, wasi_fdflags_t flags,
     if (!wasi_ctx)
         return __WASI_EACCES;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasi_ssp_sock_accept(exec_env, curfds, fd, flags, fd_new);
 }
@@ -1161,7 +1163,7 @@ wasi_sock_addr_local(wasm_exec_env_t exec_env, wasi_fd_t fd,
     if (!validate_native_addr(addr, sizeof(__wasi_addr_t)))
         return __WASI_EINVAL;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasi_ssp_sock_addr_local(exec_env, curfds, fd, addr);
 }
@@ -1180,7 +1182,7 @@ wasi_sock_addr_remote(wasm_exec_env_t exec_env, wasi_fd_t fd,
     if (!validate_native_addr(addr, sizeof(__wasi_addr_t)))
         return __WASI_EINVAL;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasi_ssp_sock_addr_remote(exec_env, curfds, fd, addr);
 }
@@ -1200,7 +1202,7 @@ wasi_sock_addr_resolve(wasm_exec_env_t exec_env, const char *host,
     if (!wasi_ctx)
         return __WASI_EACCES;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
     ns_lookup_list = wasi_ctx_get_ns_lookup_list(wasi_ctx);
 
     return wasi_ssp_sock_addr_resolve(exec_env, curfds, ns_lookup_list, host,
@@ -1219,8 +1221,8 @@ wasi_sock_bind(wasm_exec_env_t exec_env, wasi_fd_t fd, wasi_addr_t *addr)
     if (!wasi_ctx)
         return __WASI_EACCES;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
-    addr_pool = wasi_ctx_get_addr_pool(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
+    addr_pool = wasi_ctx_get_addr_pool(wasi_ctx);
 
     return wasi_ssp_sock_bind(exec_env, curfds, addr_pool, fd, addr);
 }
@@ -1228,6 +1230,9 @@ wasi_sock_bind(wasm_exec_env_t exec_env, wasi_fd_t fd, wasi_addr_t *addr)
 static wasi_errno_t
 wasi_sock_close(wasm_exec_env_t exec_env, wasi_fd_t fd)
 {
+    (void)exec_env;
+    (void)fd;
+
     return __WASI_ENOSYS;
 }
 
@@ -1242,8 +1247,8 @@ wasi_sock_connect(wasm_exec_env_t exec_env, wasi_fd_t fd, wasi_addr_t *addr)
     if (!wasi_ctx)
         return __WASI_EACCES;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
-    addr_pool = wasi_ctx_get_addr_pool(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
+    addr_pool = wasi_ctx_get_addr_pool(wasi_ctx);
 
     return wasi_ssp_sock_connect(exec_env, curfds, addr_pool, fd, addr);
 }
@@ -1262,7 +1267,7 @@ wasi_sock_get_broadcast(wasm_exec_env_t exec_env, wasi_fd_t fd,
     if (!validate_native_addr(is_enabled, sizeof(bool)))
         return __WASI_EINVAL;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_get_broadcast(exec_env, curfds, fd, is_enabled);
 }
@@ -1281,7 +1286,7 @@ wasi_sock_get_keep_alive(wasm_exec_env_t exec_env, wasi_fd_t fd,
     if (!validate_native_addr(is_enabled, sizeof(bool)))
         return __WASI_EINVAL;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_get_keep_alive(exec_env, curfds, fd, is_enabled);
 }
@@ -1301,7 +1306,7 @@ wasi_sock_get_linger(wasm_exec_env_t exec_env, wasi_fd_t fd, bool *is_enabled,
         || !validate_native_addr(linger_s, sizeof(int)))
         return __WASI_EINVAL;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_get_linger(exec_env, curfds, fd, is_enabled,
                                         linger_s);
@@ -1321,7 +1326,7 @@ wasi_sock_get_recv_buf_size(wasm_exec_env_t exec_env, wasi_fd_t fd,
     if (!validate_native_addr(size, sizeof(wasi_size_t)))
         return __WASI_EINVAL;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_get_recv_buf_size(exec_env, curfds, fd, size);
 }
@@ -1340,7 +1345,7 @@ wasi_sock_get_recv_timeout(wasm_exec_env_t exec_env, wasi_fd_t fd,
     if (!validate_native_addr(timeout_us, sizeof(uint64_t)))
         return __WASI_EINVAL;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_get_recv_timeout(exec_env, curfds, fd, timeout_us);
 }
@@ -1359,7 +1364,7 @@ wasi_sock_get_reuse_addr(wasm_exec_env_t exec_env, wasi_fd_t fd,
     if (!validate_native_addr(is_enabled, sizeof(bool)))
         return __WASI_EINVAL;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_get_reuse_addr(exec_env, curfds, fd, is_enabled);
 }
@@ -1378,7 +1383,7 @@ wasi_sock_get_reuse_port(wasm_exec_env_t exec_env, wasi_fd_t fd,
     if (!validate_native_addr(is_enabled, sizeof(bool)))
         return __WASI_EINVAL;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_get_reuse_port(exec_env, curfds, fd, is_enabled);
 }
@@ -1397,7 +1402,7 @@ wasi_sock_get_send_buf_size(wasm_exec_env_t exec_env, wasi_fd_t fd,
     if (!validate_native_addr(size, sizeof(__wasi_size_t)))
         return __WASI_EINVAL;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_get_send_buf_size(exec_env, curfds, fd, size);
 }
@@ -1416,7 +1421,7 @@ wasi_sock_get_send_timeout(wasm_exec_env_t exec_env, wasi_fd_t fd,
     if (!validate_native_addr(timeout_us, sizeof(uint64_t)))
         return __WASI_EINVAL;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_get_send_timeout(exec_env, curfds, fd, timeout_us);
 }
@@ -1435,7 +1440,7 @@ wasi_sock_get_tcp_fastopen_connect(wasm_exec_env_t exec_env, wasi_fd_t fd,
     if (!validate_native_addr(is_enabled, sizeof(bool)))
         return __WASI_EINVAL;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_get_tcp_fastopen_connect(exec_env, curfds, fd,
                                                       is_enabled);
@@ -1455,7 +1460,7 @@ wasi_sock_get_tcp_no_delay(wasm_exec_env_t exec_env, wasi_fd_t fd,
     if (!validate_native_addr(is_enabled, sizeof(bool)))
         return __WASI_EINVAL;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_get_tcp_no_delay(exec_env, curfds, fd, is_enabled);
 }
@@ -1474,7 +1479,7 @@ wasi_sock_get_tcp_quick_ack(wasm_exec_env_t exec_env, wasi_fd_t fd,
     if (!validate_native_addr(is_enabled, sizeof(bool)))
         return __WASI_EINVAL;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_get_tcp_quick_ack(exec_env, curfds, fd,
                                                is_enabled);
@@ -1494,7 +1499,7 @@ wasi_sock_get_tcp_keep_idle(wasm_exec_env_t exec_env, wasi_fd_t fd,
     if (!validate_native_addr(time_s, sizeof(uint32_t)))
         return __WASI_EINVAL;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_get_tcp_keep_idle(exec_env, curfds, fd, time_s);
 }
@@ -1513,7 +1518,7 @@ wasi_sock_get_tcp_keep_intvl(wasm_exec_env_t exec_env, wasi_fd_t fd,
     if (!validate_native_addr(time_s, sizeof(uint32_t)))
         return __WASI_EINVAL;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_get_tcp_keep_intvl(exec_env, curfds, fd, time_s);
 }
@@ -1532,7 +1537,7 @@ wasi_sock_get_ip_multicast_loop(wasm_exec_env_t exec_env, wasi_fd_t fd,
     if (!validate_native_addr(is_enabled, sizeof(bool)))
         return __WASI_EINVAL;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_get_ip_multicast_loop(exec_env, curfds, fd, ipv6,
                                                    is_enabled);
@@ -1551,7 +1556,7 @@ wasi_sock_get_ip_ttl(wasm_exec_env_t exec_env, wasi_fd_t fd, uint8_t *ttl_s)
     if (!validate_native_addr(ttl_s, sizeof(uint8_t)))
         return __WASI_EINVAL;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_get_ip_ttl(exec_env, curfds, fd, ttl_s);
 }
@@ -1570,7 +1575,7 @@ wasi_sock_get_ip_multicast_ttl(wasm_exec_env_t exec_env, wasi_fd_t fd,
     if (!validate_native_addr(ttl_s, sizeof(uint8_t)))
         return __WASI_EINVAL;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_get_ip_multicast_ttl(exec_env, curfds, fd, ttl_s);
 }
@@ -1589,7 +1594,7 @@ wasi_sock_get_ipv6_only(wasm_exec_env_t exec_env, wasi_fd_t fd,
     if (!validate_native_addr(is_enabled, sizeof(bool)))
         return __WASI_EINVAL;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_get_ipv6_only(exec_env, curfds, fd, is_enabled);
 }
@@ -1604,7 +1609,7 @@ wasi_sock_listen(wasm_exec_env_t exec_env, wasi_fd_t fd, uint32 backlog)
     if (!wasi_ctx)
         return __WASI_EACCES;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasi_ssp_sock_listen(exec_env, curfds, fd, backlog);
 }
@@ -1621,7 +1626,7 @@ wasi_sock_open(wasm_exec_env_t exec_env, wasi_fd_t poolfd,
     if (!wasi_ctx)
         return __WASI_EACCES;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasi_ssp_sock_open(exec_env, curfds, poolfd, af, socktype, sockfd);
 }
@@ -1636,7 +1641,7 @@ wasi_sock_set_broadcast(wasm_exec_env_t exec_env, wasi_fd_t fd, bool is_enabled)
     if (!wasi_ctx)
         return __WASI_EACCES;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_set_broadcast(exec_env, curfds, fd, is_enabled);
 }
@@ -1652,7 +1657,7 @@ wasi_sock_set_keep_alive(wasm_exec_env_t exec_env, wasi_fd_t fd,
     if (!wasi_ctx)
         return __WASI_EACCES;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_set_keep_alive(exec_env, curfds, fd, is_enabled);
 }
@@ -1668,7 +1673,7 @@ wasi_sock_set_linger(wasm_exec_env_t exec_env, wasi_fd_t fd, bool is_enabled,
     if (!wasi_ctx)
         return __WASI_EACCES;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_set_linger(exec_env, curfds, fd, is_enabled,
                                         linger_s);
@@ -1684,7 +1689,7 @@ wasi_sock_set_recv_buf_size(wasm_exec_env_t exec_env, wasi_fd_t fd, size_t size)
     if (!wasi_ctx)
         return __WASI_EACCES;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_set_recv_buf_size(exec_env, curfds, fd, size);
 }
@@ -1700,7 +1705,7 @@ wasi_sock_set_recv_timeout(wasm_exec_env_t exec_env, wasi_fd_t fd,
     if (!wasi_ctx)
         return __WASI_EACCES;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_set_recv_timeout(exec_env, curfds, fd, timeout_us);
 }
@@ -1716,7 +1721,7 @@ wasi_sock_set_reuse_addr(wasm_exec_env_t exec_env, wasi_fd_t fd,
     if (!wasi_ctx)
         return __WASI_EACCES;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_set_reuse_addr(exec_env, curfds, fd, is_enabled);
 }
@@ -1732,7 +1737,7 @@ wasi_sock_set_reuse_port(wasm_exec_env_t exec_env, wasi_fd_t fd,
     if (!wasi_ctx)
         return __WASI_EACCES;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_set_reuse_port(exec_env, curfds, fd, is_enabled);
 }
@@ -1747,7 +1752,7 @@ wasi_sock_set_send_buf_size(wasm_exec_env_t exec_env, wasi_fd_t fd, size_t size)
     if (!wasi_ctx)
         return __WASI_EACCES;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_set_send_buf_size(exec_env, curfds, fd, size);
 }
@@ -1763,7 +1768,7 @@ wasi_sock_set_send_timeout(wasm_exec_env_t exec_env, wasi_fd_t fd,
     if (!wasi_ctx)
         return __WASI_EACCES;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_set_send_timeout(exec_env, curfds, fd, timeout_us);
 }
@@ -1779,7 +1784,7 @@ wasi_sock_set_tcp_fastopen_connect(wasm_exec_env_t exec_env, wasi_fd_t fd,
     if (!wasi_ctx)
         return __WASI_EACCES;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_set_tcp_fastopen_connect(exec_env, curfds, fd,
                                                       is_enabled);
@@ -1796,7 +1801,7 @@ wasi_sock_set_tcp_no_delay(wasm_exec_env_t exec_env, wasi_fd_t fd,
     if (!wasi_ctx)
         return __WASI_EACCES;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_set_tcp_no_delay(exec_env, curfds, fd, is_enabled);
 }
@@ -1812,7 +1817,7 @@ wasi_sock_set_tcp_quick_ack(wasm_exec_env_t exec_env, wasi_fd_t fd,
     if (!wasi_ctx)
         return __WASI_EACCES;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_set_tcp_quick_ack(exec_env, curfds, fd,
                                                is_enabled);
@@ -1829,7 +1834,7 @@ wasi_sock_set_tcp_keep_idle(wasm_exec_env_t exec_env, wasi_fd_t fd,
     if (!wasi_ctx)
         return __WASI_EACCES;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_set_tcp_keep_idle(exec_env, curfds, fd, time_s);
 }
@@ -1845,7 +1850,7 @@ wasi_sock_set_tcp_keep_intvl(wasm_exec_env_t exec_env, wasi_fd_t fd,
     if (!wasi_ctx)
         return __WASI_EACCES;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_set_tcp_keep_intvl(exec_env, curfds, fd, time_s);
 }
@@ -1861,7 +1866,7 @@ wasi_sock_set_ip_multicast_loop(wasm_exec_env_t exec_env, wasi_fd_t fd,
     if (!wasi_ctx)
         return __WASI_EACCES;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_set_ip_multicast_loop(exec_env, curfds, fd, ipv6,
                                                    is_enabled);
@@ -1882,7 +1887,7 @@ wasi_sock_set_ip_add_membership(wasm_exec_env_t exec_env, wasi_fd_t fd,
     if (!validate_native_addr(imr_multiaddr, sizeof(__wasi_addr_ip_t)))
         return __WASI_EINVAL;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_set_ip_add_membership(
         exec_env, curfds, fd, imr_multiaddr, imr_interface);
@@ -1903,7 +1908,7 @@ wasi_sock_set_ip_drop_membership(wasm_exec_env_t exec_env, wasi_fd_t fd,
     if (!validate_native_addr(imr_multiaddr, sizeof(__wasi_addr_ip_t)))
         return __WASI_EINVAL;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_set_ip_drop_membership(
         exec_env, curfds, fd, imr_multiaddr, imr_interface);
@@ -1919,7 +1924,7 @@ wasi_sock_set_ip_ttl(wasm_exec_env_t exec_env, wasi_fd_t fd, uint8_t ttl_s)
     if (!wasi_ctx)
         return __WASI_EACCES;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_set_ip_ttl(exec_env, curfds, fd, ttl_s);
 }
@@ -1935,7 +1940,7 @@ wasi_sock_set_ip_multicast_ttl(wasm_exec_env_t exec_env, wasi_fd_t fd,
     if (!wasi_ctx)
         return __WASI_EACCES;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_set_ip_multicast_ttl(exec_env, curfds, fd, ttl_s);
 }
@@ -1950,7 +1955,7 @@ wasi_sock_set_ipv6_only(wasm_exec_env_t exec_env, wasi_fd_t fd, bool is_enabled)
     if (!wasi_ctx)
         return __WASI_EACCES;
 
-    curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     return wasmtime_ssp_sock_set_ipv6_only(exec_env, curfds, fd, is_enabled);
 }
@@ -2049,7 +2054,7 @@ wasi_sock_recv_from(wasm_exec_env_t exec_env, wasi_fd_t sock,
      **/
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     wasi_ctx_t wasi_ctx = get_wasi_ctx(module_inst);
-    struct fd_table *curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    struct fd_table *curfds = wasi_ctx_get_curfds(wasi_ctx);
     uint64 total_size;
     uint8 *buf_begin = NULL;
     wasi_errno_t err;
@@ -2153,7 +2158,7 @@ wasi_sock_send(wasm_exec_env_t exec_env, wasi_fd_t sock,
      **/
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     wasi_ctx_t wasi_ctx = get_wasi_ctx(module_inst);
-    struct fd_table *curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    struct fd_table *curfds = wasi_ctx_get_curfds(wasi_ctx);
     uint64 buf_size = 0;
     uint8 *buf = NULL;
     wasi_errno_t err;
@@ -2193,12 +2198,12 @@ wasi_sock_send_to(wasm_exec_env_t exec_env, wasi_fd_t sock,
      **/
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     wasi_ctx_t wasi_ctx = get_wasi_ctx(module_inst);
-    struct fd_table *curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    struct fd_table *curfds = wasi_ctx_get_curfds(wasi_ctx);
     uint64 buf_size = 0;
     uint8 *buf = NULL;
     wasi_errno_t err;
     size_t send_bytes = 0;
-    struct addr_pool *addr_pool = wasi_ctx_get_addr_pool(module_inst, wasi_ctx);
+    struct addr_pool *addr_pool = wasi_ctx_get_addr_pool(wasi_ctx);
 
     if (!wasi_ctx) {
         return __WASI_EINVAL;
@@ -2227,7 +2232,7 @@ wasi_sock_shutdown(wasm_exec_env_t exec_env, wasi_fd_t sock, wasi_sdflags_t how)
 {
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
     wasi_ctx_t wasi_ctx = get_wasi_ctx(module_inst);
-    struct fd_table *curfds = wasi_ctx_get_curfds(module_inst, wasi_ctx);
+    struct fd_table *curfds = wasi_ctx_get_curfds(wasi_ctx);
 
     if (!wasi_ctx)
         return __WASI_EINVAL;
@@ -2238,6 +2243,8 @@ wasi_sock_shutdown(wasm_exec_env_t exec_env, wasi_fd_t sock, wasi_sdflags_t how)
 static wasi_errno_t
 wasi_sched_yield(wasm_exec_env_t exec_env)
 {
+    (void)exec_env;
+
     return wasmtime_ssp_sched_yield();
 }
 
diff --git a/core/iwasm/libraries/libc-wasi/sandboxed-system-primitives/src/posix.c b/core/iwasm/libraries/libc-wasi/sandboxed-system-primitives/src/posix.c
index d24d493938..2363c73d2a 100644
--- a/core/iwasm/libraries/libc-wasi/sandboxed-system-primitives/src/posix.c
+++ b/core/iwasm/libraries/libc-wasi/sandboxed-system-primitives/src/posix.c
@@ -1017,9 +1017,13 @@ wasmtime_ssp_fd_fdstat_get(wasm_exec_env_t exec_env, struct fd_table *curfds,
                            __wasi_fd_t fd, __wasi_fdstat_t *buf)
 {
     struct fd_table *ft = curfds;
-    rwlock_rdlock(&ft->lock);
     struct fd_entry *fe;
-    __wasi_errno_t error = fd_table_get_entry(ft, fd, 0, 0, &fe);
+    __wasi_errno_t error;
+
+    (void)exec_env;
+
+    rwlock_rdlock(&ft->lock);
+    error = fd_table_get_entry(ft, fd, 0, 0, &fe);
     if (error != __WASI_ESUCCESS) {
         rwlock_unlock(&ft->lock);
         return error;
@@ -1071,9 +1075,13 @@ wasmtime_ssp_fd_fdstat_set_rights(wasm_exec_env_t exec_env,
                                   __wasi_rights_t fs_rights_inheriting)
 {
     struct fd_table *ft = curfds;
-    rwlock_wrlock(&ft->lock);
     struct fd_entry *fe;
-    __wasi_errno_t error =
+    __wasi_errno_t error;
+
+    (void)exec_env;
+
+    rwlock_wrlock(&ft->lock);
+    error =
         fd_table_get_entry(ft, fd, fs_rights_base, fs_rights_inheriting, &fe);
     if (error != 0) {
         rwlock_unlock(&ft->lock);
@@ -2980,7 +2988,9 @@ argv_environ_init(struct argv_environ_values *argv_environ, char *argv_buf,
 
 void
 argv_environ_destroy(struct argv_environ_values *argv_environ)
-{}
+{
+    (void)argv_environ;
+}
 
 void
 fd_table_destroy(struct fd_table *ft)
diff --git a/core/shared/platform/common/posix/posix_blocking_op.c b/core/shared/platform/common/posix/posix_blocking_op.c
index 560828a06e..e56f84cf1d 100644
--- a/core/shared/platform/common/posix/posix_blocking_op.c
+++ b/core/shared/platform/common/posix/posix_blocking_op.c
@@ -15,6 +15,7 @@ static void
 blocking_op_sighandler(int signo)
 {
     /* nothing */
+    (void)signo;
 }
 
 void
diff --git a/core/shared/platform/common/posix/posix_clock.c b/core/shared/platform/common/posix/posix_clock.c
index 280306c422..41413211cb 100644
--- a/core/shared/platform/common/posix/posix_clock.c
+++ b/core/shared/platform/common/posix/posix_clock.c
@@ -73,6 +73,8 @@ os_clock_time_get(__wasi_clockid_t clock_id, __wasi_timestamp_t precision,
     clockid_t nclock_id;
     __wasi_errno_t error = wasi_clockid_to_clockid(clock_id, &nclock_id);
 
+    (void)precision;
+
     if (error != __WASI_ESUCCESS)
         return error;
 
diff --git a/core/shared/platform/common/posix/posix_memmap.c b/core/shared/platform/common/posix/posix_memmap.c
index 1ab99fd918..aeb4530ab8 100644
--- a/core/shared/platform/common/posix/posix_memmap.c
+++ b/core/shared/platform/common/posix/posix_memmap.c
@@ -266,5 +266,8 @@ os_icache_flush(void *start, size_t len)
 {
 #if defined(__APPLE__) || defined(__MACH__)
     sys_icache_invalidate(start, len);
+#else
+    (void)start;
+    (void)len;
 #endif
 }

From 3fcd79867d8e3d0efd1499f0c2a7a8b2d0ac1a47 Mon Sep 17 00:00:00 2001
From: Enrico Loparco <eloparco@amazon.com>
Date: Wed, 24 Jan 2024 06:05:07 +0100
Subject: [PATCH 11/14] Forward log and log level to custom bh_log callback
 (#3070)

Follow-up on #2907. The log level is needed in the host embedder to
better integrate with the embedder's logger.

Allow the developer to customize his bh_log callback with
`cmake -DWAMR_BH_LOG=<log_callback>`,
and update sample/basic to show the usage.
---
 build-scripts/config_common.cmake |  3 +++
 core/shared/utils/bh_log.c        |  2 ++
 core/shared/utils/bh_log.h        |  6 ++++++
 doc/build_wamr.md                 | 12 +++++++++++-
 samples/basic/build.sh            |  2 +-
 samples/basic/src/main.c          | 28 +++++++++++++++++++++++++++-
 6 files changed, 50 insertions(+), 3 deletions(-)

diff --git a/build-scripts/config_common.cmake b/build-scripts/config_common.cmake
index 6e13d0ffe5..cb0b7210b4 100644
--- a/build-scripts/config_common.cmake
+++ b/build-scripts/config_common.cmake
@@ -338,6 +338,9 @@ endif ()
 if (DEFINED WAMR_BH_VPRINTF)
   add_definitions (-DBH_VPRINTF=${WAMR_BH_VPRINTF})
 endif ()
+if (DEFINED WAMR_BH_LOG)
+  add_definitions (-DBH_LOG=${WAMR_BH_LOG})
+endif ()
 if (WAMR_DISABLE_APP_ENTRY EQUAL 1)
   message ("     WAMR application entry functions excluded")
 endif ()
diff --git a/core/shared/utils/bh_log.c b/core/shared/utils/bh_log.c
index 7a9465e0ce..1ffd9b7641 100644
--- a/core/shared/utils/bh_log.c
+++ b/core/shared/utils/bh_log.c
@@ -17,6 +17,7 @@ bh_log_set_verbose_level(uint32 level)
     log_verbose_level = level;
 }
 
+#ifndef BH_LOG
 void
 bh_log(LogLevel log_level, const char *file, int line, const char *fmt, ...)
 {
@@ -56,6 +57,7 @@ bh_log(LogLevel log_level, const char *file, int line, const char *fmt, ...)
 
     os_printf("\n");
 }
+#endif
 
 static uint32 last_time_ms = 0;
 static uint32 total_time_ms = 0;
diff --git a/core/shared/utils/bh_log.h b/core/shared/utils/bh_log.h
index e0bc61da26..53921b250e 100644
--- a/core/shared/utils/bh_log.h
+++ b/core/shared/utils/bh_log.h
@@ -38,8 +38,14 @@ typedef enum {
 void
 bh_log_set_verbose_level(uint32 level);
 
+#ifndef BH_LOG
 void
 bh_log(LogLevel log_level, const char *file, int line, const char *fmt, ...);
+#else
+void
+BH_LOG(uint32 log_level, const char *file, int line, const char *fmt, ...);
+#define bh_log BH_LOG
+#endif
 
 #ifdef BH_PLATFORM_NUTTX
 
diff --git a/doc/build_wamr.md b/doc/build_wamr.md
index a239a4050b..6857478a9c 100644
--- a/doc/build_wamr.md
+++ b/doc/build_wamr.md
@@ -190,7 +190,17 @@ 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_defintions(-DBH_VPRINTF=my_vprintf)` in CMakeListst.txt.
+> 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_defintions(-DBH_VPRINTF=my_vprintf)` in CMakeListst.txt. See [basic sample](../samples/basic/src/main.c) for a usage example.
+
+#### **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, ...)
+> {
+>     /* Usage of custom logger */
+> }
+> ```
+> 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
diff --git a/samples/basic/build.sh b/samples/basic/build.sh
index bc75ac7830..c1d598a8c9 100755
--- a/samples/basic/build.sh
+++ b/samples/basic/build.sh
@@ -21,7 +21,7 @@ echo "#####################build basic project"
 cd ${CURR_DIR}
 mkdir -p cmake_build
 cd cmake_build
-cmake .. -DCMAKE_BUILD_TYPE=Debug
+cmake .. -DCMAKE_BUILD_TYPE=Debug -DWAMR_BH_VPRINTF=my_vprintf -DWAMR_BH_LOG=my_log
 make -j ${nproc}
 if [ $? != 0 ];then
     echo "BUILD_FAIL basic exit as $?\n"
diff --git a/samples/basic/src/main.c b/samples/basic/src/main.c
index c35da31793..ca580af330 100644
--- a/samples/basic/src/main.c
+++ b/samples/basic/src/main.c
@@ -15,6 +15,30 @@ get_pow(int x, int y);
 int32_t
 calculate_native(int32_t n, int32_t func1, int32_t func2);
 
+void
+my_log(uint32 log_level, const char *file, int line, const char *fmt, ...)
+{
+    char buf[200];
+    snprintf(buf, 200,
+             log_level == WASM_LOG_LEVEL_VERBOSE ? "[WamrLogger - VERBOSE] %s"
+                                                 : "[WamrLogger] %s",
+             fmt);
+
+    va_list ap;
+    va_start(ap, fmt);
+    vprintf(buf, ap);
+    va_end(ap);
+}
+
+int
+my_vprintf(const char *format, va_list ap)
+{
+    /* Print in blue */
+    char buf[200];
+    snprintf(buf, 200, "\x1b[34m%s\x1b[0m", format);
+    return vprintf(buf, ap);
+}
+
 void
 print_usage(void)
 {
@@ -95,6 +119,7 @@ main(int argc, char *argv_main[])
         printf("Init runtime environment failed.\n");
         return -1;
     }
+    wasm_runtime_set_log_level(WASM_LOG_LEVEL_VERBOSE);
 
     buffer = bh_read_file_to_buffer(wasm_path, &buf_size);
 
@@ -103,7 +128,8 @@ main(int argc, char *argv_main[])
         goto fail;
     }
 
-    module = wasm_runtime_load(buffer, buf_size, error_buf, sizeof(error_buf));
+    module = wasm_runtime_load((uint8 *)buffer, buf_size, error_buf,
+                               sizeof(error_buf));
     if (!module) {
         printf("Load wasm module failed. error: %s\n", error_buf);
         goto fail;

From 61fe78c9ff44aef9f173a1687604ceb24c9b5c46 Mon Sep 17 00:00:00 2001
From: Bruce Mitchener <bruce.mitchener@gmail.com>
Date: Wed, 24 Jan 2024 12:42:45 +0700
Subject: [PATCH 12/14] Fix download link for wasi-sdk (#3077)

The wasi-sdk repo moved from CraneStation to the WebAssembly org
on GitHub.
---
 doc/build_wasm_app.md                 | 2 +-
 samples/file/README.md                | 2 +-
 samples/native-lib/README.md          | 2 +-
 samples/socket-api/README.md          | 2 +-
 tests/benchmarks/coremark/README.md   | 2 +-
 tests/benchmarks/polybench/README.md  | 2 +-
 tests/benchmarks/sightglass/README.md | 2 +-
 wamr-sdk/README.md                    | 2 +-
 8 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/doc/build_wasm_app.md b/doc/build_wasm_app.md
index 23119456e7..7747d9ac39 100644
--- a/doc/build_wasm_app.md
+++ b/doc/build_wasm_app.md
@@ -5,7 +5,7 @@ Prepare WASM building environments
 
 For C and C++, WASI-SDK version 19.0+ is the major tool supported by WAMR to build WASM applications. Also, we can use [Emscripten SDK (EMSDK)](https://github.com/emscripten-core/emsdk), but it is not recommended. And there are some other compilers such as the standard clang compiler, which might also work [here](./other_wasm_compilers.md).
 
-To install WASI SDK, please download the [wasi-sdk release](https://github.com/CraneStation/wasi-sdk/releases) and extract the archive to default path `/opt/wasi-sdk`.
+To install WASI SDK, please download the [wasi-sdk release](https://github.com/WebAssembly/wasi-sdk/releases) and extract the archive to default path `/opt/wasi-sdk`.
 
 The official *wasi-sdk release* doesn't fully support *latest 128-bit SIMD spec* yet. WAMR provides a script in [build-wasi-sdk](../test-tools/build-wasi-sdk/) to generate
 another wasi-sdk with *llvm-15* from source code and installs it at *../test-tools/wasi-sdk*. If you plan to build WASM applications with *latest 128-bit SIMD*, please use it instead of the official release.
diff --git a/samples/file/README.md b/samples/file/README.md
index 8b34719ef1..98f0cc3a71 100644
--- a/samples/file/README.md
+++ b/samples/file/README.md
@@ -5,7 +5,7 @@ This sample can also demonstrate the SGX IPFS (Intel Protected File System), ena
 
 ## Preparation
 
-Please install WASI SDK, download the [wasi-sdk release](https://github.com/CraneStation/wasi-sdk/releases) and extract the archive to default path `/opt/wasi-sdk`.
+Please install WASI SDK, download the [wasi-sdk release](https://github.com/WebAssembly/wasi-sdk/releases) and extract the archive to default path `/opt/wasi-sdk`.
 For testing with SGX IPFS, follow the instructions in [the documentation of SGX for WAMR](../../doc/linux_sgx.md#sgx-intel-protected-file-system).
 
 ## Build the sample
diff --git a/samples/native-lib/README.md b/samples/native-lib/README.md
index 80500ade0f..be1cc6e74c 100644
--- a/samples/native-lib/README.md
+++ b/samples/native-lib/README.md
@@ -29,7 +29,7 @@ get_native_lib(char **p_module_name, NativeSymbol **p_native_symbols)
 
 ## Preparation
 
-Please install WASI SDK, download the [wasi-sdk release](https://github.com/CraneStation/wasi-sdk/releases) and extract the archive to default path `/opt/wasi-sdk`.
+Please install WASI SDK, download the [wasi-sdk release](https://github.com/WebAssembly/wasi-sdk/releases) and extract the archive to default path `/opt/wasi-sdk`.
 
 ## Build the sample
 
diff --git a/samples/socket-api/README.md b/samples/socket-api/README.md
index a3bc5ac152..911dfb7ab3 100644
--- a/samples/socket-api/README.md
+++ b/samples/socket-api/README.md
@@ -6,7 +6,7 @@ how they communicate with each other.
 
 ## Preparation
 
-Please install WASI SDK, download the [wasi-sdk release](https://github.com/CraneStation/wasi-sdk/releases) and extract the archive to default path `/opt/wasi-sdk`.
+Please install WASI SDK, download the [wasi-sdk release](https://github.com/WebAssembly/wasi-sdk/releases) and extract the archive to default path `/opt/wasi-sdk`.
 And install wabt, download the [wabt release](https://github.com/WebAssembly/wabt/releases) and extract the archive to default path `/opt/wabt`
 
 ## Build the sample
diff --git a/tests/benchmarks/coremark/README.md b/tests/benchmarks/coremark/README.md
index 4e88069f85..5b874e9889 100644
--- a/tests/benchmarks/coremark/README.md
+++ b/tests/benchmarks/coremark/README.md
@@ -10,7 +10,7 @@ Please build iwasm and wamrc, refer to:
 - [Build iwasm on Linux](../../../doc/build_wamr.md#linux), or [Build iwasm on MacOS](../../../doc/build_wamr.md#macos)
 - [Build wamrc AOT compiler](../../../README.md#build-wamrc-aot-compiler)
 
-And install WASI SDK, please download the [wasi-sdk release](https://github.com/CraneStation/wasi-sdk/releases) and extract the archive to default path `/opt/wasi-sdk`.
+And install WASI SDK, please download the [wasi-sdk release](https://github.com/WebAssembly/wasi-sdk/releases) and extract the archive to default path `/opt/wasi-sdk`.
 
 And then run `./build.sh` to build the source code, file `coremark.exe`, `coremark.wasm` and `coremark.aot` will be generated.
 
diff --git a/tests/benchmarks/polybench/README.md b/tests/benchmarks/polybench/README.md
index d8b3db9619..7b6623f221 100644
--- a/tests/benchmarks/polybench/README.md
+++ b/tests/benchmarks/polybench/README.md
@@ -10,7 +10,7 @@ Please build iwasm and wamrc, refer to:
 - [Build iwasm on Linux](../../../doc/build_wamr.md#linux), or [Build iwasm on MacOS](../../../doc/build_wamr.md#macos)
 - [Build wamrc AOT compiler](../../../README.md#build-wamrc-aot-compiler)
 
-And install WASI SDK, please download the [wasi-sdk release](https://github.com/CraneStation/wasi-sdk/releases) and extract the archive to default path `/opt/wasi-sdk`.
+And install WASI SDK, please download the [wasi-sdk release](https://github.com/WebAssembly/wasi-sdk/releases) and extract the archive to default path `/opt/wasi-sdk`.
 
 And then run `./build.sh` to build the source code, the folder `out` will be created and files will be generated under it.
 
diff --git a/tests/benchmarks/sightglass/README.md b/tests/benchmarks/sightglass/README.md
index ff34c7d700..3f54fda1bc 100644
--- a/tests/benchmarks/sightglass/README.md
+++ b/tests/benchmarks/sightglass/README.md
@@ -10,7 +10,7 @@ Please build iwasm and wamrc, refer to:
 - [Build iwasm on Linux](../../../doc/build_wamr.md#linux), or [Build iwasm on MacOS](../../../doc/build_wamr.md#macos)
 - [Build wamrc AOT compiler](../../../README.md#build-wamrc-aot-compiler)
 
-And install WASI SDK, please download the [wasi-sdk release](https://github.com/CraneStation/wasi-sdk/releases) and extract the archive to default path `/opt/wasi-sdk`.
+And install WASI SDK, please download the [wasi-sdk release](https://github.com/WebAssembly/wasi-sdk/releases) and extract the archive to default path `/opt/wasi-sdk`.
 
 And then run `./build.sh` to build the source code, the folder `out` will be created and files will be generated under it.
 
diff --git a/wamr-sdk/README.md b/wamr-sdk/README.md
index 14b172e028..fd926af862 100644
--- a/wamr-sdk/README.md
+++ b/wamr-sdk/README.md
@@ -8,7 +8,7 @@ Usually there are two tasks for integrating the WAMR into a particular project:
 The **[WAMR SDK](./wamr-sdk)** tools is helpful to finish the two tasks quickly. It supports menu configuration for selecting WAMR components and builds the WAMR to a SDK package that includes **runtime SDK** and **APP SDK**. The runtime SDK is used for building the native application and the APP SDK should be shipped to WASM application developers.
 
 
-**Note**: [WASI-SDK](https://github.com/CraneStation/wasi-sdk/releases) version 7 and above should be installed before building the WAMR SDK. 
+**Note**: [WASI-SDK](https://github.com/WebAssembly/wasi-sdk/releases) version 7 and above should be installed before building the WAMR SDK.
 
 
 

From d815bbc3dbd455bd4afa59a3339d9881e0f294a0 Mon Sep 17 00:00:00 2001
From: Bruce Mitchener <bruce.mitchener@gmail.com>
Date: Wed, 24 Jan 2024 14:35:45 +0700
Subject: [PATCH 13/14] README.md: Fix typo `tunning` to `tuning` (#3078)

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index dfdae2da89..31156b9cc3 100644
--- a/README.md
+++ b/README.md
@@ -75,9 +75,9 @@ The following platforms are supported, click each link below for how to build iw
 - [Blog: The WAMR memory model](https://bytecodealliance.github.io/wamr.dev/blog/the-wamr-memory-model/)
 - [Blog: Understand WAMR heaps](https://bytecodealliance.github.io/wamr.dev/blog/understand-the-wamr-heaps/) and [stacks](https://bytecodealliance.github.io/wamr.dev/blog/understand-the-wamr-stacks/)
 - [Blog: Introduction to WAMR running modes](https://bytecodealliance.github.io/wamr.dev/blog/introduction-to-wamr-running-modes/)
-- [Memory usage tunning](./doc/memory_tune.md): the memory model and how to tune the memory usage
+- [Memory usage tuning](./doc/memory_tune.md): the memory model and how to tune the memory usage
 - [Memory usage profiling](./doc/build_wamr.md#enable-memory-profiling-experiment): how to profile the memory usage
-- [Performance tunning](./doc/perf_tune.md): how to tune the performance
+- [Performance tuning](./doc/perf_tune.md): how to tune the performance
 - [Benchmarks](./tests/benchmarks): checkout these links for how to run the benchmarks: [PolyBench](./tests/benchmarks/polybench), [CoreMark](./tests/benchmarks/coremark), [Sightglass](./tests/benchmarks/sightglass), [JetStream2](./tests/benchmarks/jetstream)
 - [Performance and footprint data](https://github.com/bytecodealliance/wasm-micro-runtime/wiki/Performance): the performance and footprint data
 

From bf9fb2e680892f2c298104c37d608cf182c8d345 Mon Sep 17 00:00:00 2001
From: Gavin Hayes <gavin@dylibso.com>
Date: Wed, 24 Jan 2024 03:04:48 -0500
Subject: [PATCH 14/14] cosmopolitan: Update compiler and update
 platform_internal.h (#3079)

This fixes the cosmopolitan platform.
- Switch `build_cosmocc.sh` and platform documentation to
  explicitly use the x86_64 cosmocc compiler as multi-arch
  cosmocc won't work here. Older version `cosmocc` just did
  a x86_64 build.
- Add missing items from `platform_internal.h` to fix build.
---
 core/shared/platform/cosmopolitan/platform_internal.h | 7 +++++++
 product-mini/README.md                                | 6 +++---
 product-mini/platforms/cosmopolitan/build_cosmocc.sh  | 4 ++--
 3 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/core/shared/platform/cosmopolitan/platform_internal.h b/core/shared/platform/cosmopolitan/platform_internal.h
index 66515e3059..7260211606 100644
--- a/core/shared/platform/cosmopolitan/platform_internal.h
+++ b/core/shared/platform/cosmopolitan/platform_internal.h
@@ -55,6 +55,7 @@ typedef pthread_t korp_tid;
 typedef pthread_mutex_t korp_mutex;
 typedef pthread_cond_t korp_cond;
 typedef pthread_t korp_thread;
+typedef pthread_rwlock_t korp_rwlock;
 typedef sem_t korp_sem;
 
 #define OS_THREAD_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
@@ -67,6 +68,12 @@ typedef int os_file_handle;
 typedef DIR *os_dir_stream;
 typedef int os_raw_file_handle;
 
+static inline os_file_handle
+os_get_invalid_handle()
+{
+    return -1;
+}
+
 #if WASM_DISABLE_WRITE_GS_BASE == 0
 #if defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64)
 #define os_writegsbase(base_addr)                                 \
diff --git a/product-mini/README.md b/product-mini/README.md
index 22acfeaf46..4a82756188 100644
--- a/product-mini/README.md
+++ b/product-mini/README.md
@@ -447,12 +447,12 @@ make
 ## Cosmopolitan Libc
 Currently, only x86_64 architecture with interpreter modes is supported.
 
-Clone the Cosmopolitan Libc. Setup `cosmocc` as described in [Getting Started](https://github.com/jart/cosmopolitan/#getting-started) being sure to get it into `PATH`.
+Setup `cosmocc` as described in [Getting Started](https://github.com/jart/cosmopolitan/#getting-started) being sure to get its `bin` directory into `PATH`.
 
 Build iwasm
 ``` Bash
-export CC=cosmocc
-export CXX=cosmoc++
+export CC=x86_64-unknown-cosmo-cc
+export CXX=x86_64-unknown-cosmo-c++
 rm -rf build
 mkdir build
 cmake -DWAMR_BUILD_INTERP=1 -DWAMR_BUILD_FAST_INTERP=1 -B build
diff --git a/product-mini/platforms/cosmopolitan/build_cosmocc.sh b/product-mini/platforms/cosmopolitan/build_cosmocc.sh
index b2ce15d33a..8d96027e1d 100755
--- a/product-mini/platforms/cosmopolitan/build_cosmocc.sh
+++ b/product-mini/platforms/cosmopolitan/build_cosmocc.sh
@@ -2,8 +2,8 @@
 
 # Copyright (C) 2023 Dylibso.  All rights reserved.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-export CC=cosmocc
-export CXX=cosmoc++
+export CC=x86_64-unknown-cosmo-cc
+export CXX=x86_64-unknown-cosmo-c++
 rm -rf build
 mkdir build
 cmake -DWAMR_BUILD_INTERP=1 -DWAMR_BUILD_FAST_INTERP=1 -B build