summaryrefslogtreecommitdiffstats
path: root/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/iwasm/common/wasm_runtime_common.c
diff options
context:
space:
mode:
Diffstat (limited to 'fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/iwasm/common/wasm_runtime_common.c')
-rw-r--r--fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/iwasm/common/wasm_runtime_common.c5475
1 files changed, 5475 insertions, 0 deletions
diff --git a/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/iwasm/common/wasm_runtime_common.c b/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/iwasm/common/wasm_runtime_common.c
new file mode 100644
index 000000000..452a2661b
--- /dev/null
+++ b/fluent-bit/lib/wasm-micro-runtime-WAMR-1.2.2/core/iwasm/common/wasm_runtime_common.c
@@ -0,0 +1,5475 @@
+/*
+ * Copyright (C) 2019 Intel Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#include "bh_platform.h"
+#include "bh_common.h"
+#include "bh_assert.h"
+#include "bh_log.h"
+#include "wasm_native.h"
+#include "wasm_runtime_common.h"
+#include "wasm_memory.h"
+#if WASM_ENABLE_INTERP != 0
+#include "../interpreter/wasm_runtime.h"
+#endif
+#if WASM_ENABLE_AOT != 0
+#include "../aot/aot_runtime.h"
+#if WASM_ENABLE_DEBUG_AOT != 0
+#include "../aot/debug/jit_debug.h"
+#endif
+#endif
+#if WASM_ENABLE_THREAD_MGR != 0
+#include "../libraries/thread-mgr/thread_manager.h"
+#if WASM_ENABLE_DEBUG_INTERP != 0
+#include "../libraries/debug-engine/debug_engine.h"
+#endif
+#endif
+#if WASM_ENABLE_SHARED_MEMORY != 0
+#include "wasm_shared_memory.h"
+#endif
+#if WASM_ENABLE_FAST_JIT != 0
+#include "../fast-jit/jit_compiler.h"
+#endif
+#if WASM_ENABLE_JIT != 0 || WASM_ENABLE_WAMR_COMPILER != 0
+#include "../compilation/aot_llvm.h"
+#endif
+#include "../common/wasm_c_api_internal.h"
+#include "../../version.h"
+
+/**
+ * For runtime build, BH_MALLOC/BH_FREE should be defined as
+ * wasm_runtime_malloc/wasm_runtime_free.
+ */
+#define CHECK(a) CHECK1(a)
+#define CHECK1(a) SHOULD_BE_##a
+
+#define SHOULD_BE_wasm_runtime_malloc 1
+#if !CHECK(BH_MALLOC)
+#error unexpected BH_MALLOC
+#endif
+#undef SHOULD_BE_wasm_runtime_malloc
+
+#define SHOULD_BE_wasm_runtime_free 1
+#if !CHECK(BH_FREE)
+#error unexpected BH_FREE
+#endif
+#undef SHOULD_BE_wasm_runtime_free
+
+#undef CHECK
+#undef CHECK1
+
+#if WASM_ENABLE_MULTI_MODULE != 0
+/**
+ * A safety insurance to prevent
+ * circular depencies which leads stack overflow
+ * try to break early
+ */
+typedef struct LoadingModule {
+ bh_list_link l;
+ /* point to a string pool */
+ const char *module_name;
+} LoadingModule;
+
+static bh_list loading_module_list_head;
+static bh_list *const loading_module_list = &loading_module_list_head;
+static korp_mutex loading_module_list_lock;
+
+/**
+ * A list to store all exported functions/globals/memories/tables
+ * of every fully loaded module
+ */
+static bh_list registered_module_list_head;
+static bh_list *const registered_module_list = &registered_module_list_head;
+static korp_mutex registered_module_list_lock;
+static void
+wasm_runtime_destroy_registered_module_list();
+#endif /* WASM_ENABLE_MULTI_MODULE */
+
+#define E_TYPE_XIP 4
+
+#if WASM_ENABLE_REF_TYPES != 0
+/* Initialize externref hashmap */
+static bool
+wasm_externref_map_init();
+
+/* Destroy externref hashmap */
+static void
+wasm_externref_map_destroy();
+#endif /* WASM_ENABLE_REF_TYPES */
+
+static void
+set_error_buf(char *error_buf, uint32 error_buf_size, const char *string)
+{
+ if (error_buf != NULL)
+ snprintf(error_buf, error_buf_size, "%s", string);
+}
+
+static void *
+runtime_malloc(uint64 size, WASMModuleInstanceCommon *module_inst,
+ char *error_buf, uint32 error_buf_size)
+{
+ void *mem;
+
+ if (size >= UINT32_MAX || !(mem = wasm_runtime_malloc((uint32)size))) {
+ if (module_inst != NULL) {
+ wasm_runtime_set_exception(module_inst, "allocate memory failed");
+ }
+ else if (error_buf != NULL) {
+ set_error_buf(error_buf, error_buf_size, "allocate memory failed");
+ }
+ return NULL;
+ }
+
+ memset(mem, 0, (uint32)size);
+ return mem;
+}
+
+#if WASM_ENABLE_FAST_JIT != 0
+static JitCompOptions jit_options = { 0 };
+#endif
+
+#if WASM_ENABLE_JIT != 0
+static LLVMJITOptions llvm_jit_options = { 3, 3 };
+#endif
+
+static RunningMode runtime_running_mode = Mode_Default;
+
+#ifdef OS_ENABLE_HW_BOUND_CHECK
+/* The exec_env of thread local storage, set before calling function
+ and used in signal handler, as we cannot get it from the argument
+ of signal handler */
+static os_thread_local_attribute WASMExecEnv *exec_env_tls = NULL;
+
+#ifndef BH_PLATFORM_WINDOWS
+static void
+runtime_signal_handler(void *sig_addr)
+{
+ WASMModuleInstance *module_inst;
+ WASMMemoryInstance *memory_inst;
+ WASMJmpBuf *jmpbuf_node;
+ uint8 *mapped_mem_start_addr = NULL;
+ uint8 *mapped_mem_end_addr = NULL;
+ uint32 page_size = os_getpagesize();
+#if WASM_DISABLE_STACK_HW_BOUND_CHECK == 0
+ uint8 *stack_min_addr;
+ uint32 guard_page_count = STACK_OVERFLOW_CHECK_GUARD_PAGE_COUNT;
+#endif
+
+ /* Check whether current thread is running wasm function */
+ if (exec_env_tls && exec_env_tls->handle == os_self_thread()
+ && (jmpbuf_node = exec_env_tls->jmpbuf_stack_top)) {
+ /* Get mapped mem info of current instance */
+ module_inst = (WASMModuleInstance *)exec_env_tls->module_inst;
+ /* Get the default memory instance */
+ memory_inst = wasm_get_default_memory(module_inst);
+ if (memory_inst) {
+ mapped_mem_start_addr = memory_inst->memory_data;
+ mapped_mem_end_addr = memory_inst->memory_data + 8 * (uint64)BH_GB;
+ }
+
+#if WASM_DISABLE_STACK_HW_BOUND_CHECK == 0
+ /* Get stack info of current thread */
+ stack_min_addr = os_thread_get_stack_boundary();
+#endif
+
+ if (memory_inst
+ && (mapped_mem_start_addr <= (uint8 *)sig_addr
+ && (uint8 *)sig_addr < mapped_mem_end_addr)) {
+ /* The address which causes segmentation fault is inside
+ the memory instance's guard regions */
+ wasm_set_exception(module_inst, "out of bounds memory access");
+ os_longjmp(jmpbuf_node->jmpbuf, 1);
+ }
+#if WASM_DISABLE_STACK_HW_BOUND_CHECK == 0
+ else if (stack_min_addr - page_size <= (uint8 *)sig_addr
+ && (uint8 *)sig_addr
+ < stack_min_addr + page_size * guard_page_count) {
+ /* The address which causes segmentation fault is inside
+ native thread's guard page */
+ wasm_set_exception(module_inst, "native stack overflow");
+ os_longjmp(jmpbuf_node->jmpbuf, 1);
+ }
+#endif
+ else if (exec_env_tls->exce_check_guard_page <= (uint8 *)sig_addr
+ && (uint8 *)sig_addr
+ < exec_env_tls->exce_check_guard_page + page_size) {
+ bh_assert(wasm_copy_exception(module_inst, NULL));
+ os_longjmp(jmpbuf_node->jmpbuf, 1);
+ }
+ }
+}
+#else
+static LONG
+runtime_exception_handler(EXCEPTION_POINTERS *exce_info)
+{
+ PEXCEPTION_RECORD ExceptionRecord = exce_info->ExceptionRecord;
+ uint8 *sig_addr = (uint8 *)ExceptionRecord->ExceptionInformation[1];
+ WASMModuleInstance *module_inst;
+ WASMMemoryInstance *memory_inst;
+ WASMJmpBuf *jmpbuf_node;
+ uint8 *mapped_mem_start_addr = NULL;
+ uint8 *mapped_mem_end_addr = NULL;
+ uint32 page_size = os_getpagesize();
+
+ if (exec_env_tls && exec_env_tls->handle == os_self_thread()
+ && (jmpbuf_node = exec_env_tls->jmpbuf_stack_top)) {
+ module_inst = (WASMModuleInstance *)exec_env_tls->module_inst;
+ if (ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION) {
+ /* Get the default memory instance */
+ memory_inst = wasm_get_default_memory(module_inst);
+ if (memory_inst) {
+ mapped_mem_start_addr = memory_inst->memory_data;
+ mapped_mem_end_addr =
+ memory_inst->memory_data + 8 * (uint64)BH_GB;
+ }
+
+ if (memory_inst && mapped_mem_start_addr <= (uint8 *)sig_addr
+ && (uint8 *)sig_addr < mapped_mem_end_addr) {
+ /* The address which causes segmentation fault is inside
+ the memory instance's guard regions.
+ Set exception and let the wasm func continue to run, when
+ the wasm func returns, the caller will check whether the
+ exception is thrown and return to runtime. */
+ wasm_set_exception(module_inst, "out of bounds memory access");
+ if (module_inst->module_type == Wasm_Module_Bytecode) {
+ /* Continue to search next exception handler for
+ interpreter mode as it can be caught by
+ `__try { .. } __except { .. }` sentences in
+ wasm_runtime.c */
+ return EXCEPTION_CONTINUE_SEARCH;
+ }
+ else {
+ /* Skip current instruction and continue to run for
+ AOT mode. TODO: implement unwind support for AOT
+ code in Windows platform */
+ exce_info->ContextRecord->Rip++;
+ return EXCEPTION_CONTINUE_EXECUTION;
+ }
+ }
+ else if (exec_env_tls->exce_check_guard_page <= (uint8 *)sig_addr
+ && (uint8 *)sig_addr
+ < exec_env_tls->exce_check_guard_page + page_size) {
+ bh_assert(wasm_copy_exception(module_inst, NULL));
+ if (module_inst->module_type == Wasm_Module_Bytecode) {
+ return EXCEPTION_CONTINUE_SEARCH;
+ }
+ else {
+ exce_info->ContextRecord->Rip++;
+ return EXCEPTION_CONTINUE_EXECUTION;
+ }
+ }
+ }
+#if WASM_DISABLE_STACK_HW_BOUND_CHECK == 0
+ else if (ExceptionRecord->ExceptionCode == EXCEPTION_STACK_OVERFLOW) {
+ /* Set stack overflow exception and let the wasm func continue
+ to run, when the wasm func returns, the caller will check
+ whether the exception is thrown and return to runtime, and
+ the damaged stack will be recovered by _resetstkoflw(). */
+ wasm_set_exception(module_inst, "native stack overflow");
+ if (module_inst->module_type == Wasm_Module_Bytecode) {
+ return EXCEPTION_CONTINUE_SEARCH;
+ }
+ else {
+ return EXCEPTION_CONTINUE_EXECUTION;
+ }
+ }
+#endif
+ }
+
+ os_printf("Unhandled exception thrown: exception code: 0x%lx, "
+ "exception address: %p, exception information: %p\n",
+ ExceptionRecord->ExceptionCode, ExceptionRecord->ExceptionAddress,
+ sig_addr);
+ return EXCEPTION_CONTINUE_SEARCH;
+}
+#endif /* end of BH_PLATFORM_WINDOWS */
+
+static bool
+runtime_signal_init()
+{
+#ifndef BH_PLATFORM_WINDOWS
+ return os_thread_signal_init(runtime_signal_handler) == 0 ? true : false;
+#else
+ if (os_thread_signal_init() != 0)
+ return false;
+
+ if (!AddVectoredExceptionHandler(1, runtime_exception_handler)) {
+ os_thread_signal_destroy();
+ return false;
+ }
+#endif
+ return true;
+}
+
+static void
+runtime_signal_destroy()
+{
+#ifdef BH_PLATFORM_WINDOWS
+ RemoveVectoredExceptionHandler(runtime_exception_handler);
+#endif
+ os_thread_signal_destroy();
+}
+
+void
+wasm_runtime_set_exec_env_tls(WASMExecEnv *exec_env)
+{
+ exec_env_tls = exec_env;
+}
+
+WASMExecEnv *
+wasm_runtime_get_exec_env_tls()
+{
+ return exec_env_tls;
+}
+#endif /* end of OS_ENABLE_HW_BOUND_CHECK */
+
+static bool
+wasm_runtime_env_init()
+{
+ if (bh_platform_init() != 0)
+ return false;
+
+ if (wasm_native_init() == false) {
+ goto fail1;
+ }
+
+#if WASM_ENABLE_MULTI_MODULE
+ if (BHT_OK != os_mutex_init(&registered_module_list_lock)) {
+ goto fail2;
+ }
+
+ if (BHT_OK != os_mutex_init(&loading_module_list_lock)) {
+ goto fail3;
+ }
+#endif
+
+#if WASM_ENABLE_SHARED_MEMORY
+ if (!wasm_shared_memory_init()) {
+ goto fail4;
+ }
+#endif
+
+#if (WASM_ENABLE_WAMR_COMPILER == 0) && (WASM_ENABLE_THREAD_MGR != 0)
+ if (!thread_manager_init()) {
+ goto fail5;
+ }
+#endif
+
+#ifdef OS_ENABLE_HW_BOUND_CHECK
+ if (!runtime_signal_init()) {
+ goto fail6;
+ }
+#endif
+
+#if WASM_ENABLE_AOT != 0
+#if WASM_ENABLE_DEBUG_AOT != 0
+ if (!jit_debug_engine_init()) {
+ goto fail7;
+ }
+#endif
+#endif
+
+#if WASM_ENABLE_REF_TYPES != 0
+ if (!wasm_externref_map_init()) {
+ goto fail8;
+ }
+#endif
+
+#if WASM_ENABLE_FAST_JIT != 0
+ if (!jit_compiler_init(&jit_options)) {
+ goto fail9;
+ }
+#endif
+
+#if WASM_ENABLE_JIT != 0 || WASM_ENABLE_WAMR_COMPILER != 0
+ if (!aot_compiler_init()) {
+ goto fail10;
+ }
+#endif
+
+ return true;
+
+#if WASM_ENABLE_JIT != 0 || WASM_ENABLE_WAMR_COMPILER != 0
+fail10:
+#if WASM_ENABLE_FAST_JIT != 0
+ jit_compiler_destroy();
+#endif
+#endif
+#if WASM_ENABLE_FAST_JIT != 0
+fail9:
+#if WASM_ENABLE_REF_TYPES != 0
+ wasm_externref_map_destroy();
+#endif
+#endif
+#if WASM_ENABLE_REF_TYPES != 0
+fail8:
+#endif
+#if WASM_ENABLE_AOT != 0
+#if WASM_ENABLE_DEBUG_AOT != 0
+ jit_debug_engine_destroy();
+fail7:
+#endif
+#endif
+#ifdef OS_ENABLE_HW_BOUND_CHECK
+ runtime_signal_destroy();
+fail6:
+#endif
+#if (WASM_ENABLE_WAMR_COMPILER == 0) && (WASM_ENABLE_THREAD_MGR != 0)
+ thread_manager_destroy();
+fail5:
+#endif
+#if WASM_ENABLE_SHARED_MEMORY
+ wasm_shared_memory_destroy();
+fail4:
+#endif
+#if WASM_ENABLE_MULTI_MODULE
+ os_mutex_destroy(&loading_module_list_lock);
+fail3:
+ os_mutex_destroy(&registered_module_list_lock);
+fail2:
+#endif
+ wasm_native_destroy();
+fail1:
+ bh_platform_destroy();
+
+ return false;
+}
+
+static bool
+wasm_runtime_exec_env_check(WASMExecEnv *exec_env)
+{
+ return exec_env && exec_env->module_inst && exec_env->wasm_stack_size > 0
+ && exec_env->wasm_stack.s.top_boundary
+ == exec_env->wasm_stack.s.bottom + exec_env->wasm_stack_size
+ && exec_env->wasm_stack.s.top <= exec_env->wasm_stack.s.top_boundary;
+}
+
+bool
+wasm_runtime_init()
+{
+ if (!wasm_runtime_memory_init(Alloc_With_System_Allocator, NULL))
+ return false;
+
+ if (!wasm_runtime_env_init()) {
+ wasm_runtime_memory_destroy();
+ return false;
+ }
+
+ return true;
+}
+
+void
+wasm_runtime_destroy()
+{
+#if WASM_ENABLE_REF_TYPES != 0
+ wasm_externref_map_destroy();
+#endif
+
+#if WASM_ENABLE_AOT != 0
+#if WASM_ENABLE_DEBUG_AOT != 0
+ jit_debug_engine_destroy();
+#endif
+#endif
+
+#ifdef OS_ENABLE_HW_BOUND_CHECK
+ runtime_signal_destroy();
+#endif
+
+ /* runtime env destroy */
+#if WASM_ENABLE_MULTI_MODULE
+ wasm_runtime_destroy_loading_module_list();
+ os_mutex_destroy(&loading_module_list_lock);
+
+ wasm_runtime_destroy_registered_module_list();
+ os_mutex_destroy(&registered_module_list_lock);
+#endif
+
+#if WASM_ENABLE_JIT != 0 || WASM_ENABLE_WAMR_COMPILER != 0
+ /* Destroy LLVM-JIT compiler after destroying the modules
+ * loaded by multi-module feature, since these modules may
+ * create backend threads to compile the wasm functions,
+ * which may access the LLVM resources. We wait until they
+ * finish the compilation to avoid accessing the destroyed
+ * resources in the compilation threads.
+ */
+ aot_compiler_destroy();
+#endif
+
+#if WASM_ENABLE_FAST_JIT != 0
+ /* Destroy Fast-JIT compiler after destroying the modules
+ * loaded by multi-module feature, since the Fast JIT's
+ * code cache allocator may be used by these modules.
+ */
+ jit_compiler_destroy();
+#endif
+
+#if WASM_ENABLE_SHARED_MEMORY
+ wasm_shared_memory_destroy();
+#endif
+
+#if (WASM_ENABLE_WAMR_COMPILER == 0) && (WASM_ENABLE_THREAD_MGR != 0)
+#if WASM_ENABLE_DEBUG_INTERP != 0
+ wasm_debug_engine_destroy();
+#endif
+ thread_manager_destroy();
+#endif
+
+ wasm_native_destroy();
+ bh_platform_destroy();
+
+ wasm_runtime_memory_destroy();
+}
+
+RunningMode
+wasm_runtime_get_default_running_mode(void)
+{
+ return runtime_running_mode;
+}
+
+#if WASM_ENABLE_JIT != 0
+LLVMJITOptions
+wasm_runtime_get_llvm_jit_options(void)
+{
+ return llvm_jit_options;
+}
+#endif
+
+bool
+wasm_runtime_full_init(RuntimeInitArgs *init_args)
+{
+ if (!wasm_runtime_memory_init(init_args->mem_alloc_type,
+ &init_args->mem_alloc_option))
+ return false;
+
+ if (!wasm_runtime_set_default_running_mode(init_args->running_mode)) {
+ wasm_runtime_memory_destroy();
+ return false;
+ }
+
+#if WASM_ENABLE_FAST_JIT != 0
+ jit_options.code_cache_size = init_args->fast_jit_code_cache_size;
+#endif
+
+#if WASM_ENABLE_JIT != 0
+ llvm_jit_options.size_level = init_args->llvm_jit_size_level;
+ llvm_jit_options.opt_level = init_args->llvm_jit_opt_level;
+#endif
+
+ if (!wasm_runtime_env_init()) {
+ wasm_runtime_memory_destroy();
+ return false;
+ }
+
+#if WASM_ENABLE_DEBUG_INTERP != 0
+ if (strlen(init_args->ip_addr))
+ if (!wasm_debug_engine_init(init_args->ip_addr,
+ init_args->instance_port)) {
+ wasm_runtime_destroy();
+ return false;
+ }
+#endif
+
+ if (init_args->n_native_symbols > 0
+ && !wasm_runtime_register_natives(init_args->native_module_name,
+ init_args->native_symbols,
+ init_args->n_native_symbols)) {
+ wasm_runtime_destroy();
+ return false;
+ }
+
+#if WASM_ENABLE_THREAD_MGR != 0
+ wasm_cluster_set_max_thread_num(init_args->max_thread_num);
+#endif
+
+ return true;
+}
+
+bool
+wasm_runtime_is_running_mode_supported(RunningMode running_mode)
+{
+ if (running_mode == Mode_Default) {
+ return true;
+ }
+ else if (running_mode == Mode_Interp) {
+#if WASM_ENABLE_INTERP != 0
+ return true;
+#endif
+ }
+ else if (running_mode == Mode_Fast_JIT) {
+#if WASM_ENABLE_FAST_JIT != 0
+ return true;
+#endif
+ }
+ else if (running_mode == Mode_LLVM_JIT) {
+#if WASM_ENABLE_JIT != 0
+ return true;
+#endif
+ }
+ else if (running_mode == Mode_Multi_Tier_JIT) {
+#if WASM_ENABLE_FAST_JIT != 0 && WASM_ENABLE_JIT != 0 \
+ && WASM_ENABLE_LAZY_JIT != 0
+ return true;
+#endif
+ }
+
+ return false;
+}
+
+bool
+wasm_runtime_set_default_running_mode(RunningMode running_mode)
+{
+ if (wasm_runtime_is_running_mode_supported(running_mode)) {
+ runtime_running_mode = running_mode;
+ return true;
+ }
+ return false;
+}
+
+PackageType
+get_package_type(const uint8 *buf, uint32 size)
+{
+#if (WASM_ENABLE_WORD_ALIGN_READ != 0)
+ uint32 buf32 = *(uint32 *)buf;
+ buf = (const uint8 *)&buf32;
+#endif
+ if (buf && size >= 4) {
+ if (buf[0] == '\0' && buf[1] == 'a' && buf[2] == 's' && buf[3] == 'm')
+ return Wasm_Module_Bytecode;
+ if (buf[0] == '\0' && buf[1] == 'a' && buf[2] == 'o' && buf[3] == 't')
+ return Wasm_Module_AoT;
+ }
+ return Package_Type_Unknown;
+}
+
+#if WASM_ENABLE_AOT != 0
+static uint8 *
+align_ptr(const uint8 *p, uint32 b)
+{
+ uintptr_t v = (uintptr_t)p;
+ uintptr_t m = b - 1;
+ return (uint8 *)((v + m) & ~m);
+}
+
+#define CHECK_BUF(buf, buf_end, length) \
+ do { \
+ if ((uintptr_t)buf + length < (uintptr_t)buf \
+ || (uintptr_t)buf + length > (uintptr_t)buf_end) \
+ return false; \
+ } while (0)
+
+#define read_uint16(p, p_end, res) \
+ do { \
+ p = (uint8 *)align_ptr(p, sizeof(uint16)); \
+ CHECK_BUF(p, p_end, sizeof(uint16)); \
+ res = *(uint16 *)p; \
+ p += sizeof(uint16); \
+ } while (0)
+
+#define read_uint32(p, p_end, res) \
+ do { \
+ p = (uint8 *)align_ptr(p, sizeof(uint32)); \
+ CHECK_BUF(p, p_end, sizeof(uint32)); \
+ res = *(uint32 *)p; \
+ p += sizeof(uint32); \
+ } while (0)
+
+bool
+wasm_runtime_is_xip_file(const uint8 *buf, uint32 size)
+{
+ const uint8 *p = buf, *p_end = buf + size;
+ uint32 section_type, section_size;
+ uint16 e_type;
+
+ if (get_package_type(buf, size) != Wasm_Module_AoT)
+ return false;
+
+ CHECK_BUF(p, p_end, 8);
+ p += 8;
+ while (p < p_end) {
+ read_uint32(p, p_end, section_type);
+ read_uint32(p, p_end, section_size);
+ CHECK_BUF(p, p_end, section_size);
+
+ if (section_type == AOT_SECTION_TYPE_TARGET_INFO) {
+ p += 4;
+ read_uint16(p, p_end, e_type);
+ return (e_type == E_TYPE_XIP) ? true : false;
+ }
+ else if (section_type >= AOT_SECTION_TYPE_SIGANATURE) {
+ return false;
+ }
+ p += section_size;
+ }
+
+ return false;
+}
+#endif /* end of WASM_ENABLE_AOT */
+
+#if (WASM_ENABLE_THREAD_MGR != 0) && (WASM_ENABLE_DEBUG_INTERP != 0)
+uint32
+wasm_runtime_start_debug_instance_with_port(WASMExecEnv *exec_env, int32_t port)
+{
+ WASMModuleInstanceCommon *module_inst =
+ wasm_runtime_get_module_inst(exec_env);
+ WASMCluster *cluster = wasm_exec_env_get_cluster(exec_env);
+ bh_assert(module_inst);
+ bh_assert(cluster);
+
+ if (module_inst->module_type != Wasm_Module_Bytecode) {
+ LOG_WARNING("Attempt to create a debug instance for an AOT module");
+ return 0;
+ }
+
+ if (cluster->debug_inst) {
+ LOG_WARNING("Cluster already bind to a debug instance");
+ return cluster->debug_inst->control_thread->port;
+ }
+
+ if (wasm_debug_instance_create(cluster, port)) {
+ return cluster->debug_inst->control_thread->port;
+ }
+
+ return 0;
+}
+
+uint32
+wasm_runtime_start_debug_instance(WASMExecEnv *exec_env)
+{
+ return wasm_runtime_start_debug_instance_with_port(exec_env, -1);
+}
+#endif
+
+#if WASM_ENABLE_MULTI_MODULE != 0
+static module_reader reader;
+static module_destroyer destroyer;
+void
+wasm_runtime_set_module_reader(const module_reader reader_cb,
+ const module_destroyer destroyer_cb)
+{
+ reader = reader_cb;
+ destroyer = destroyer_cb;
+}
+
+module_reader
+wasm_runtime_get_module_reader()
+{
+ return reader;
+}
+
+module_destroyer
+wasm_runtime_get_module_destroyer()
+{
+ return destroyer;
+}
+
+static WASMRegisteredModule *
+wasm_runtime_find_module_registered_by_reference(WASMModuleCommon *module)
+{
+ WASMRegisteredModule *reg_module = NULL;
+
+ os_mutex_lock(&registered_module_list_lock);
+ reg_module = bh_list_first_elem(registered_module_list);
+ while (reg_module && module != reg_module->module) {
+ reg_module = bh_list_elem_next(reg_module);
+ }
+ os_mutex_unlock(&registered_module_list_lock);
+
+ return reg_module;
+}
+
+bool
+wasm_runtime_register_module_internal(const char *module_name,
+ WASMModuleCommon *module,
+ uint8 *orig_file_buf,
+ uint32 orig_file_buf_size,
+ char *error_buf, uint32 error_buf_size)
+{
+ WASMRegisteredModule *node = NULL;
+
+ node = wasm_runtime_find_module_registered_by_reference(module);
+ if (node) { /* module has been registered */
+ if (node->module_name) { /* module has name */
+ if (!module_name || strcmp(node->module_name, module_name)) {
+ /* module has different name */
+ LOG_DEBUG("module(%p) has been registered with name %s", module,
+ node->module_name);
+ set_error_buf(error_buf, error_buf_size,
+ "Register module failed: "
+ "failed to rename the module");
+ return false;
+ }
+ else {
+ /* module has the same name */
+ LOG_DEBUG(
+ "module(%p) has been registered with the same name %s",
+ module, node->module_name);
+ return true;
+ }
+ }
+ else {
+ /* module has empyt name, reset it */
+ node->module_name = module_name;
+ return true;
+ }
+ }
+
+ /* module hasn't been registered */
+ node = runtime_malloc(sizeof(WASMRegisteredModule), NULL, NULL, 0);
+ if (!node) {
+ LOG_DEBUG("malloc WASMRegisteredModule failed. SZ=%d",
+ sizeof(WASMRegisteredModule));
+ return false;
+ }
+
+ /* share the string and the module */
+ node->module_name = module_name;
+ node->module = module;
+ node->orig_file_buf = orig_file_buf;
+ node->orig_file_buf_size = orig_file_buf_size;
+
+ os_mutex_lock(&registered_module_list_lock);
+ bh_list_status ret = bh_list_insert(registered_module_list, node);
+ bh_assert(BH_LIST_SUCCESS == ret);
+ (void)ret;
+ os_mutex_unlock(&registered_module_list_lock);
+ return true;
+}
+
+bool
+wasm_runtime_register_module(const char *module_name, WASMModuleCommon *module,
+ char *error_buf, uint32 error_buf_size)
+{
+ if (!error_buf || !error_buf_size) {
+ LOG_ERROR("error buffer is required");
+ return false;
+ }
+
+ if (!module_name || !module) {
+ LOG_DEBUG("module_name and module are required");
+ set_error_buf(error_buf, error_buf_size,
+ "Register module failed: "
+ "module_name and module are required");
+ return false;
+ }
+
+ if (wasm_runtime_is_built_in_module(module_name)) {
+ LOG_DEBUG("%s is a built-in module name", module_name);
+ set_error_buf(error_buf, error_buf_size,
+ "Register module failed: "
+ "can not register as a built-in module");
+ return false;
+ }
+
+ return wasm_runtime_register_module_internal(module_name, module, NULL, 0,
+ error_buf, error_buf_size);
+}
+
+void
+wasm_runtime_unregister_module(const WASMModuleCommon *module)
+{
+ WASMRegisteredModule *registered_module = NULL;
+
+ os_mutex_lock(&registered_module_list_lock);
+ registered_module = bh_list_first_elem(registered_module_list);
+ while (registered_module && module != registered_module->module) {
+ registered_module = bh_list_elem_next(registered_module);
+ }
+
+ /* it does not matter if it is not exist. after all, it is gone */
+ if (registered_module) {
+ bh_list_remove(registered_module_list, registered_module);
+ wasm_runtime_free(registered_module);
+ }
+ os_mutex_unlock(&registered_module_list_lock);
+}
+
+WASMModuleCommon *
+wasm_runtime_find_module_registered(const char *module_name)
+{
+ WASMRegisteredModule *module = NULL, *module_next;
+
+ os_mutex_lock(&registered_module_list_lock);
+ module = bh_list_first_elem(registered_module_list);
+ while (module) {
+ module_next = bh_list_elem_next(module);
+ if (module->module_name && !strcmp(module_name, module->module_name)) {
+ break;
+ }
+ module = module_next;
+ }
+ os_mutex_unlock(&registered_module_list_lock);
+
+ return module ? module->module : NULL;
+}
+
+/*
+ * simply destroy all
+ */
+static void
+wasm_runtime_destroy_registered_module_list()
+{
+ WASMRegisteredModule *reg_module = NULL;
+
+ os_mutex_lock(&registered_module_list_lock);
+ reg_module = bh_list_first_elem(registered_module_list);
+ while (reg_module) {
+ WASMRegisteredModule *next_reg_module = bh_list_elem_next(reg_module);
+
+ bh_list_remove(registered_module_list, reg_module);
+
+ /* now, it is time to release every module in the runtime */
+ if (reg_module->module->module_type == Wasm_Module_Bytecode) {
+#if WASM_ENABLE_INTERP != 0
+ wasm_unload((WASMModule *)reg_module->module);
+#endif
+ }
+ else {
+#if WASM_ENABLE_AOT != 0
+ aot_unload((AOTModule *)reg_module->module);
+#endif
+ }
+
+ /* destroy the file buffer */
+ if (destroyer && reg_module->orig_file_buf) {
+ destroyer(reg_module->orig_file_buf,
+ reg_module->orig_file_buf_size);
+ reg_module->orig_file_buf = NULL;
+ reg_module->orig_file_buf_size = 0;
+ }
+
+ wasm_runtime_free(reg_module);
+ reg_module = next_reg_module;
+ }
+ os_mutex_unlock(&registered_module_list_lock);
+}
+
+bool
+wasm_runtime_add_loading_module(const char *module_name, char *error_buf,
+ uint32 error_buf_size)
+{
+ LOG_DEBUG("add %s into a loading list", module_name);
+ LoadingModule *loadingModule =
+ runtime_malloc(sizeof(LoadingModule), NULL, error_buf, error_buf_size);
+
+ if (!loadingModule) {
+ return false;
+ }
+
+ /* share the incoming string */
+ loadingModule->module_name = module_name;
+
+ os_mutex_lock(&loading_module_list_lock);
+ bh_list_status ret = bh_list_insert(loading_module_list, loadingModule);
+ bh_assert(BH_LIST_SUCCESS == ret);
+ (void)ret;
+ os_mutex_unlock(&loading_module_list_lock);
+ return true;
+}
+
+void
+wasm_runtime_delete_loading_module(const char *module_name)
+{
+ LOG_DEBUG("delete %s from a loading list", module_name);
+
+ LoadingModule *module = NULL;
+
+ os_mutex_lock(&loading_module_list_lock);
+ module = bh_list_first_elem(loading_module_list);
+ while (module && strcmp(module->module_name, module_name)) {
+ module = bh_list_elem_next(module);
+ }
+
+ /* it does not matter if it is not exist. after all, it is gone */
+ if (module) {
+ bh_list_remove(loading_module_list, module);
+ wasm_runtime_free(module);
+ }
+ os_mutex_unlock(&loading_module_list_lock);
+}
+
+bool
+wasm_runtime_is_loading_module(const char *module_name)
+{
+ LOG_DEBUG("find %s in a loading list", module_name);
+
+ LoadingModule *module = NULL;
+
+ os_mutex_lock(&loading_module_list_lock);
+ module = bh_list_first_elem(loading_module_list);
+ while (module && strcmp(module_name, module->module_name)) {
+ module = bh_list_elem_next(module);
+ }
+ os_mutex_unlock(&loading_module_list_lock);
+
+ return module != NULL;
+}
+
+void
+wasm_runtime_destroy_loading_module_list()
+{
+ LoadingModule *module = NULL;
+
+ os_mutex_lock(&loading_module_list_lock);
+ module = bh_list_first_elem(loading_module_list);
+ while (module) {
+ LoadingModule *next_module = bh_list_elem_next(module);
+
+ bh_list_remove(loading_module_list, module);
+ /*
+ * will not free the module_name since it is
+ * shared one of the const string pool
+ */
+ wasm_runtime_free(module);
+
+ module = next_module;
+ }
+
+ os_mutex_unlock(&loading_module_list_lock);
+}
+#endif /* WASM_ENABLE_MULTI_MODULE */
+
+bool
+wasm_runtime_is_built_in_module(const char *module_name)
+{
+ return (!strcmp("env", module_name) || !strcmp("wasi_unstable", module_name)
+ || !strcmp("wasi_snapshot_preview1", module_name)
+#if WASM_ENABLE_SPEC_TEST != 0
+ || !strcmp("spectest", module_name)
+#endif
+ || !strcmp("", module_name));
+}
+
+#if WASM_ENABLE_THREAD_MGR != 0
+bool
+wasm_exec_env_set_aux_stack(WASMExecEnv *exec_env, uint32 start_offset,
+ uint32 size)
+{
+ WASMModuleInstanceCommon *module_inst =
+ wasm_exec_env_get_module_inst(exec_env);
+#if WASM_ENABLE_INTERP != 0
+ if (module_inst->module_type == Wasm_Module_Bytecode) {
+ return wasm_set_aux_stack(exec_env, start_offset, size);
+ }
+#endif
+#if WASM_ENABLE_AOT != 0
+ if (module_inst->module_type == Wasm_Module_AoT) {
+ return aot_set_aux_stack(exec_env, start_offset, size);
+ }
+#endif
+ return false;
+}
+
+bool
+wasm_exec_env_get_aux_stack(WASMExecEnv *exec_env, uint32 *start_offset,
+ uint32 *size)
+{
+ WASMModuleInstanceCommon *module_inst =
+ wasm_exec_env_get_module_inst(exec_env);
+#if WASM_ENABLE_INTERP != 0
+ if (module_inst->module_type == Wasm_Module_Bytecode) {
+ return wasm_get_aux_stack(exec_env, start_offset, size);
+ }
+#endif
+#if WASM_ENABLE_AOT != 0
+ if (module_inst->module_type == Wasm_Module_AoT) {
+ return aot_get_aux_stack(exec_env, start_offset, size);
+ }
+#endif
+ return false;
+}
+
+void
+wasm_runtime_set_max_thread_num(uint32 num)
+{
+ wasm_cluster_set_max_thread_num(num);
+}
+#endif /* end of WASM_ENABLE_THREAD_MGR */
+
+static WASMModuleCommon *
+register_module_with_null_name(WASMModuleCommon *module_common, char *error_buf,
+ uint32 error_buf_size)
+{
+#if WASM_ENABLE_MULTI_MODULE != 0
+ if (module_common) {
+ if (!wasm_runtime_register_module_internal(NULL, module_common, NULL, 0,
+ error_buf, error_buf_size)) {
+ wasm_runtime_unload(module_common);
+ return NULL;
+ }
+ return module_common;
+ }
+ else
+ return NULL;
+#else
+ return module_common;
+#endif
+}
+
+WASMModuleCommon *
+wasm_runtime_load(uint8 *buf, uint32 size, char *error_buf,
+ uint32 error_buf_size)
+{
+ WASMModuleCommon *module_common = NULL;
+
+ if (get_package_type(buf, size) == Wasm_Module_Bytecode) {
+#if WASM_ENABLE_INTERP != 0
+ module_common =
+ (WASMModuleCommon *)wasm_load(buf, size, error_buf, error_buf_size);
+ return register_module_with_null_name(module_common, error_buf,
+ error_buf_size);
+#endif
+ }
+ else if (get_package_type(buf, size) == Wasm_Module_AoT) {
+#if WASM_ENABLE_AOT != 0
+ module_common = (WASMModuleCommon *)aot_load_from_aot_file(
+ buf, size, error_buf, error_buf_size);
+ return register_module_with_null_name(module_common, error_buf,
+ error_buf_size);
+#endif
+ }
+
+ if (size < 4)
+ set_error_buf(error_buf, error_buf_size,
+ "WASM module load failed: unexpected end");
+ else
+ set_error_buf(error_buf, error_buf_size,
+ "WASM module load failed: magic header not detected");
+ return NULL;
+}
+
+WASMModuleCommon *
+wasm_runtime_load_from_sections(WASMSection *section_list, bool is_aot,
+ char *error_buf, uint32 error_buf_size)
+{
+ WASMModuleCommon *module_common;
+
+ if (!is_aot) {
+#if WASM_ENABLE_INTERP != 0
+ module_common = (WASMModuleCommon *)wasm_load_from_sections(
+ section_list, error_buf, error_buf_size);
+ return register_module_with_null_name(module_common, error_buf,
+ error_buf_size);
+#endif
+ }
+ else {
+#if WASM_ENABLE_AOT != 0
+ module_common = (WASMModuleCommon *)aot_load_from_sections(
+ section_list, error_buf, error_buf_size);
+ return register_module_with_null_name(module_common, error_buf,
+ error_buf_size);
+#endif
+ }
+
+#if WASM_ENABLE_INTERP == 0 || WASM_ENABLE_AOT == 0
+ set_error_buf(error_buf, error_buf_size,
+ "WASM module load failed: invalid section list type");
+ return NULL;
+#endif
+}
+
+void
+wasm_runtime_unload(WASMModuleCommon *module)
+{
+#if WASM_ENABLE_MULTI_MODULE != 0
+ /**
+ * since we will unload and free all module when runtime_destroy()
+ * we don't want users to unwillingly disrupt it
+ */
+ return;
+#endif
+
+#if WASM_ENABLE_INTERP != 0
+ if (module->module_type == Wasm_Module_Bytecode) {
+ wasm_unload((WASMModule *)module);
+ return;
+ }
+#endif
+
+#if WASM_ENABLE_AOT != 0
+ if (module->module_type == Wasm_Module_AoT) {
+ aot_unload((AOTModule *)module);
+ return;
+ }
+#endif
+}
+
+WASMModuleInstanceCommon *
+wasm_runtime_instantiate_internal(WASMModuleCommon *module, bool is_sub_inst,
+ WASMExecEnv *exec_env_main, uint32 stack_size,
+ uint32 heap_size, char *error_buf,
+ uint32 error_buf_size)
+{
+#if WASM_ENABLE_INTERP != 0
+ if (module->module_type == Wasm_Module_Bytecode)
+ return (WASMModuleInstanceCommon *)wasm_instantiate(
+ (WASMModule *)module, is_sub_inst, exec_env_main, stack_size,
+ heap_size, error_buf, error_buf_size);
+#endif
+#if WASM_ENABLE_AOT != 0
+ if (module->module_type == Wasm_Module_AoT)
+ return (WASMModuleInstanceCommon *)aot_instantiate(
+ (AOTModule *)module, is_sub_inst, exec_env_main, stack_size,
+ heap_size, error_buf, error_buf_size);
+#endif
+ set_error_buf(error_buf, error_buf_size,
+ "Instantiate module failed, invalid module type");
+ return NULL;
+}
+
+WASMModuleInstanceCommon *
+wasm_runtime_instantiate(WASMModuleCommon *module, uint32 stack_size,
+ uint32 heap_size, char *error_buf,
+ uint32 error_buf_size)
+{
+ return wasm_runtime_instantiate_internal(
+ module, false, NULL, stack_size, heap_size, error_buf, error_buf_size);
+}
+
+void
+wasm_runtime_deinstantiate_internal(WASMModuleInstanceCommon *module_inst,
+ bool is_sub_inst)
+{
+#if WASM_ENABLE_INTERP != 0
+ if (module_inst->module_type == Wasm_Module_Bytecode) {
+ wasm_deinstantiate((WASMModuleInstance *)module_inst, is_sub_inst);
+ return;
+ }
+#endif
+#if WASM_ENABLE_AOT != 0
+ if (module_inst->module_type == Wasm_Module_AoT) {
+ aot_deinstantiate((AOTModuleInstance *)module_inst, is_sub_inst);
+ return;
+ }
+#endif
+}
+
+bool
+wasm_runtime_set_running_mode(wasm_module_inst_t module_inst,
+ RunningMode running_mode)
+{
+#if WASM_ENABLE_AOT != 0
+ if (module_inst->module_type == Wasm_Module_AoT)
+ return true;
+#endif
+
+#if WASM_ENABLE_INTERP != 0
+ if (module_inst->module_type == Wasm_Module_Bytecode) {
+ WASMModuleInstance *module_inst_interp =
+ (WASMModuleInstance *)module_inst;
+
+ return wasm_set_running_mode(module_inst_interp, running_mode);
+ }
+#endif
+
+ return false;
+}
+
+RunningMode
+wasm_runtime_get_running_mode(wasm_module_inst_t module_inst)
+{
+#if WASM_ENABLE_INTERP != 0
+ if (module_inst->module_type == Wasm_Module_Bytecode) {
+ WASMModuleInstance *module_inst_interp =
+ (WASMModuleInstance *)module_inst;
+ return module_inst_interp->e->running_mode;
+ }
+#endif
+
+ return Mode_Default;
+}
+
+void
+wasm_runtime_deinstantiate(WASMModuleInstanceCommon *module_inst)
+{
+ wasm_runtime_deinstantiate_internal(module_inst, false);
+}
+
+WASMModuleCommon *
+wasm_runtime_get_module(WASMModuleInstanceCommon *module_inst)
+{
+ return (WASMModuleCommon *)((WASMModuleInstance *)module_inst)->module;
+}
+
+WASMExecEnv *
+wasm_runtime_create_exec_env(WASMModuleInstanceCommon *module_inst,
+ uint32 stack_size)
+{
+ return wasm_exec_env_create(module_inst, stack_size);
+}
+
+void
+wasm_runtime_destroy_exec_env(WASMExecEnv *exec_env)
+{
+ wasm_exec_env_destroy(exec_env);
+}
+
+bool
+wasm_runtime_init_thread_env(void)
+{
+#ifdef BH_PLATFORM_WINDOWS
+ if (os_thread_env_init() != 0)
+ return false;
+#endif
+
+#ifdef OS_ENABLE_HW_BOUND_CHECK
+ if (!runtime_signal_init()) {
+#ifdef BH_PLATFORM_WINDOWS
+ os_thread_env_destroy();
+#endif
+ return false;
+ }
+#endif
+
+ return true;
+}
+
+void
+wasm_runtime_destroy_thread_env(void)
+{
+#ifdef OS_ENABLE_HW_BOUND_CHECK
+ runtime_signal_destroy();
+#endif
+
+#ifdef BH_PLATFORM_WINDOWS
+ os_thread_env_destroy();
+#endif
+}
+
+bool
+wasm_runtime_thread_env_inited(void)
+{
+#ifdef BH_PLATFORM_WINDOWS
+ if (!os_thread_env_inited())
+ return false;
+#endif
+
+#if WASM_ENABLE_AOT != 0
+#ifdef OS_ENABLE_HW_BOUND_CHECK
+ if (!os_thread_signal_inited())
+ return false;
+#endif
+#endif
+ return true;
+}
+
+#if (WASM_ENABLE_MEMORY_PROFILING != 0) || (WASM_ENABLE_MEMORY_TRACING != 0)
+void
+wasm_runtime_dump_module_mem_consumption(const WASMModuleCommon *module)
+{
+ WASMModuleMemConsumption mem_conspn = { 0 };
+
+#if WASM_ENABLE_INTERP != 0
+ if (module->module_type == Wasm_Module_Bytecode) {
+ wasm_get_module_mem_consumption((WASMModule *)module, &mem_conspn);
+ }
+#endif
+#if WASM_ENABLE_AOT != 0
+ if (module->module_type == Wasm_Module_AoT) {
+ aot_get_module_mem_consumption((AOTModule *)module, &mem_conspn);
+ }
+#endif
+
+ os_printf("WASM module memory consumption, total size: %u\n",
+ mem_conspn.total_size);
+ os_printf(" module struct size: %u\n", mem_conspn.module_struct_size);
+ os_printf(" types size: %u\n", mem_conspn.types_size);
+ os_printf(" imports size: %u\n", mem_conspn.imports_size);
+ os_printf(" funcs size: %u\n", mem_conspn.functions_size);
+ os_printf(" tables size: %u\n", mem_conspn.tables_size);
+ os_printf(" memories size: %u\n", mem_conspn.memories_size);
+ os_printf(" globals size: %u\n", mem_conspn.globals_size);
+ os_printf(" exports size: %u\n", mem_conspn.exports_size);
+ os_printf(" table segs size: %u\n", mem_conspn.table_segs_size);
+ os_printf(" data segs size: %u\n", mem_conspn.data_segs_size);
+ os_printf(" const strings size: %u\n", mem_conspn.const_strs_size);
+#if WASM_ENABLE_AOT != 0
+ os_printf(" aot code size: %u\n", mem_conspn.aot_code_size);
+#endif
+}
+
+void
+wasm_runtime_dump_module_inst_mem_consumption(
+ const WASMModuleInstanceCommon *module_inst)
+{
+ WASMModuleInstMemConsumption mem_conspn = { 0 };
+
+#if WASM_ENABLE_INTERP != 0
+ if (module_inst->module_type == Wasm_Module_Bytecode) {
+ wasm_get_module_inst_mem_consumption((WASMModuleInstance *)module_inst,
+ &mem_conspn);
+ }
+#endif
+#if WASM_ENABLE_AOT != 0
+ if (module_inst->module_type == Wasm_Module_AoT) {
+ aot_get_module_inst_mem_consumption((AOTModuleInstance *)module_inst,
+ &mem_conspn);
+ }
+#endif
+
+ os_printf("WASM module inst memory consumption, total size: %u\n",
+ mem_conspn.total_size);
+ os_printf(" module inst struct size: %u\n",
+ mem_conspn.module_inst_struct_size);
+ os_printf(" memories size: %u\n", mem_conspn.memories_size);
+ os_printf(" app heap size: %u\n", mem_conspn.app_heap_size);
+ os_printf(" tables size: %u\n", mem_conspn.tables_size);
+ os_printf(" functions size: %u\n", mem_conspn.functions_size);
+ os_printf(" globals size: %u\n", mem_conspn.globals_size);
+ os_printf(" exports size: %u\n", mem_conspn.exports_size);
+}
+
+void
+wasm_runtime_dump_exec_env_mem_consumption(const WASMExecEnv *exec_env)
+{
+ uint32 total_size =
+ offsetof(WASMExecEnv, wasm_stack.s.bottom) + exec_env->wasm_stack_size;
+
+ os_printf("Exec env memory consumption, total size: %u\n", total_size);
+ os_printf(" exec env struct size: %u\n",
+ offsetof(WASMExecEnv, wasm_stack.s.bottom));
+#if WASM_ENABLE_INTERP != 0 && WASM_ENABLE_FAST_INTERP == 0
+ os_printf(" block addr cache size: %u\n",
+ sizeof(exec_env->block_addr_cache));
+#endif
+ os_printf(" stack size: %u\n", exec_env->wasm_stack_size);
+}
+
+uint32
+gc_get_heap_highmark_size(void *heap);
+
+void
+wasm_runtime_dump_mem_consumption(WASMExecEnv *exec_env)
+{
+ WASMModuleInstMemConsumption module_inst_mem_consps;
+ WASMModuleMemConsumption module_mem_consps;
+ WASMModuleInstanceCommon *module_inst_common;
+ WASMModuleCommon *module_common = NULL;
+ void *heap_handle = NULL;
+ uint32 total_size = 0, app_heap_peak_size = 0;
+ uint32 max_aux_stack_used = -1;
+
+ module_inst_common = exec_env->module_inst;
+#if WASM_ENABLE_INTERP != 0
+ if (module_inst_common->module_type == Wasm_Module_Bytecode) {
+ WASMModuleInstance *wasm_module_inst =
+ (WASMModuleInstance *)module_inst_common;
+ WASMModule *wasm_module = wasm_module_inst->module;
+ module_common = (WASMModuleCommon *)wasm_module;
+ if (wasm_module_inst->memories) {
+ heap_handle = wasm_module_inst->memories[0]->heap_handle;
+ }
+ wasm_get_module_inst_mem_consumption(wasm_module_inst,
+ &module_inst_mem_consps);
+ wasm_get_module_mem_consumption(wasm_module, &module_mem_consps);
+ if (wasm_module_inst->module->aux_stack_top_global_index != (uint32)-1)
+ max_aux_stack_used = wasm_module_inst->e->max_aux_stack_used;
+ }
+#endif
+#if WASM_ENABLE_AOT != 0
+ if (module_inst_common->module_type == Wasm_Module_AoT) {
+ AOTModuleInstance *aot_module_inst =
+ (AOTModuleInstance *)module_inst_common;
+ AOTModule *aot_module = (AOTModule *)aot_module_inst->module;
+ module_common = (WASMModuleCommon *)aot_module;
+ if (aot_module_inst->memories) {
+ AOTMemoryInstance **memories = aot_module_inst->memories;
+ heap_handle = memories[0]->heap_handle;
+ }
+ aot_get_module_inst_mem_consumption(aot_module_inst,
+ &module_inst_mem_consps);
+ aot_get_module_mem_consumption(aot_module, &module_mem_consps);
+ }
+#endif
+
+ bh_assert(module_common != NULL);
+
+ if (heap_handle) {
+ app_heap_peak_size = gc_get_heap_highmark_size(heap_handle);
+ }
+
+ total_size = offsetof(WASMExecEnv, wasm_stack.s.bottom)
+ + exec_env->wasm_stack_size + module_mem_consps.total_size
+ + module_inst_mem_consps.total_size;
+
+ os_printf("\nMemory consumption summary (bytes):\n");
+ wasm_runtime_dump_module_mem_consumption(module_common);
+ wasm_runtime_dump_module_inst_mem_consumption(module_inst_common);
+ wasm_runtime_dump_exec_env_mem_consumption(exec_env);
+ os_printf("\nTotal memory consumption of module, module inst and "
+ "exec env: %u\n",
+ total_size);
+ os_printf("Total interpreter stack used: %u\n",
+ exec_env->max_wasm_stack_used);
+
+ if (max_aux_stack_used != (uint32)-1)
+ os_printf("Total auxiliary stack used: %u\n", max_aux_stack_used);
+ else
+ os_printf("Total aux stack used: no enough info to profile\n");
+
+ /*
+ * Report the native stack usage estimation.
+ *
+ * Unlike the aux stack above, we report the amount unused
+ * because we don't know the stack "bottom".
+ *
+ * Note that this is just about what the runtime itself observed.
+ * It doesn't cover host func implementations, signal handlers, etc.
+ */
+ if (exec_env->native_stack_top_min != (void *)UINTPTR_MAX)
+ os_printf("Native stack left: %zd\n",
+ exec_env->native_stack_top_min
+ - exec_env->native_stack_boundary);
+ else
+ os_printf("Native stack left: no enough info to profile\n");
+
+ os_printf("Total app heap used: %u\n", app_heap_peak_size);
+}
+#endif /* end of (WASM_ENABLE_MEMORY_PROFILING != 0) \
+ || (WASM_ENABLE_MEMORY_TRACING != 0) */
+
+#if WASM_ENABLE_PERF_PROFILING != 0
+void
+wasm_runtime_dump_perf_profiling(WASMModuleInstanceCommon *module_inst)
+{
+#if WASM_ENABLE_INTERP != 0
+ if (module_inst->module_type == Wasm_Module_Bytecode) {
+ wasm_dump_perf_profiling((WASMModuleInstance *)module_inst);
+ }
+#endif
+#if WASM_ENABLE_AOT != 0
+ if (module_inst->module_type == Wasm_Module_AoT) {
+ aot_dump_perf_profiling((AOTModuleInstance *)module_inst);
+ }
+#endif
+}
+#endif
+
+WASMModuleInstanceCommon *
+wasm_runtime_get_module_inst(WASMExecEnv *exec_env)
+{
+ return wasm_exec_env_get_module_inst(exec_env);
+}
+
+void
+wasm_runtime_set_module_inst(WASMExecEnv *exec_env,
+ WASMModuleInstanceCommon *const module_inst)
+{
+ wasm_exec_env_set_module_inst(exec_env, module_inst);
+}
+
+void *
+wasm_runtime_get_function_attachment(WASMExecEnv *exec_env)
+{
+ return exec_env->attachment;
+}
+
+void
+wasm_runtime_set_user_data(WASMExecEnv *exec_env, void *user_data)
+{
+ exec_env->user_data = user_data;
+}
+
+void *
+wasm_runtime_get_user_data(WASMExecEnv *exec_env)
+{
+ return exec_env->user_data;
+}
+
+#ifdef OS_ENABLE_HW_BOUND_CHECK
+void
+wasm_runtime_access_exce_check_guard_page()
+{
+ if (exec_env_tls && exec_env_tls->handle == os_self_thread()) {
+ uint32 page_size = os_getpagesize();
+ memset(exec_env_tls->exce_check_guard_page, 0, page_size);
+ }
+}
+#endif
+
+WASMType *
+wasm_runtime_get_function_type(const WASMFunctionInstanceCommon *function,
+ uint32 module_type)
+{
+ WASMType *type = NULL;
+
+#if WASM_ENABLE_INTERP != 0
+ if (module_type == Wasm_Module_Bytecode) {
+ WASMFunctionInstance *wasm_func = (WASMFunctionInstance *)function;
+ type = wasm_func->is_import_func ? wasm_func->u.func_import->func_type
+ : wasm_func->u.func->func_type;
+ }
+#endif
+#if WASM_ENABLE_AOT != 0
+ if (module_type == Wasm_Module_AoT) {
+ AOTFunctionInstance *aot_func = (AOTFunctionInstance *)function;
+ type = aot_func->is_import_func ? aot_func->u.func_import->func_type
+ : aot_func->u.func.func_type;
+ }
+#endif
+
+ return type;
+}
+
+WASMFunctionInstanceCommon *
+wasm_runtime_lookup_function(WASMModuleInstanceCommon *const module_inst,
+ const char *name, const char *signature)
+{
+#if WASM_ENABLE_INTERP != 0
+ if (module_inst->module_type == Wasm_Module_Bytecode)
+ return (WASMFunctionInstanceCommon *)wasm_lookup_function(
+ (const WASMModuleInstance *)module_inst, name, signature);
+#endif
+#if WASM_ENABLE_AOT != 0
+ if (module_inst->module_type == Wasm_Module_AoT)
+ return (WASMFunctionInstanceCommon *)aot_lookup_function(
+ (const AOTModuleInstance *)module_inst, name, signature);
+#endif
+ return NULL;
+}
+
+uint32
+wasm_func_get_param_count(WASMFunctionInstanceCommon *const func_inst,
+ WASMModuleInstanceCommon *const module_inst)
+{
+ WASMType *type =
+ wasm_runtime_get_function_type(func_inst, module_inst->module_type);
+ bh_assert(type);
+
+ return type->param_count;
+}
+
+uint32
+wasm_func_get_result_count(WASMFunctionInstanceCommon *const func_inst,
+ WASMModuleInstanceCommon *const module_inst)
+{
+ WASMType *type =
+ wasm_runtime_get_function_type(func_inst, module_inst->module_type);
+ bh_assert(type);
+
+ return type->result_count;
+}
+
+static uint8
+val_type_to_val_kind(uint8 value_type)
+{
+ switch (value_type) {
+ case VALUE_TYPE_I32:
+ return WASM_I32;
+ case VALUE_TYPE_I64:
+ return WASM_I64;
+ case VALUE_TYPE_F32:
+ return WASM_F32;
+ case VALUE_TYPE_F64:
+ return WASM_F64;
+ case VALUE_TYPE_FUNCREF:
+ return WASM_FUNCREF;
+ case VALUE_TYPE_EXTERNREF:
+ return WASM_ANYREF;
+ default:
+ bh_assert(0);
+ return 0;
+ }
+}
+
+void
+wasm_func_get_param_types(WASMFunctionInstanceCommon *const func_inst,
+ WASMModuleInstanceCommon *const module_inst,
+ wasm_valkind_t *param_types)
+{
+ WASMType *type =
+ wasm_runtime_get_function_type(func_inst, module_inst->module_type);
+ uint32 i;
+
+ bh_assert(type);
+
+ for (i = 0; i < type->param_count; i++) {
+ param_types[i] = val_type_to_val_kind(type->types[i]);
+ }
+}
+
+void
+wasm_func_get_result_types(WASMFunctionInstanceCommon *const func_inst,
+ WASMModuleInstanceCommon *const module_inst,
+ wasm_valkind_t *result_types)
+{
+ WASMType *type =
+ wasm_runtime_get_function_type(func_inst, module_inst->module_type);
+ uint32 i;
+
+ bh_assert(type);
+
+ for (i = 0; i < type->result_count; i++) {
+ result_types[i] =
+ val_type_to_val_kind(type->types[type->param_count + i]);
+ }
+}
+
+#if WASM_ENABLE_REF_TYPES != 0
+/* (uintptr_t)externref -> (uint32)index */
+/* argv -> *ret_argv */
+static bool
+wasm_runtime_prepare_call_function(WASMExecEnv *exec_env,
+ WASMFunctionInstanceCommon *function,
+ uint32 *argv, uint32 argc, uint32 **ret_argv,
+ uint32 *ret_argc_param,
+ uint32 *ret_argc_result)
+{
+ uint32 *new_argv = NULL, argv_i = 0, new_argv_i = 0, param_i = 0,
+ result_i = 0;
+ bool need_param_transform = false, need_result_transform = false;
+ uint64 size = 0;
+ WASMType *func_type = wasm_runtime_get_function_type(
+ function, exec_env->module_inst->module_type);
+
+ bh_assert(func_type);
+
+ *ret_argc_param = func_type->param_cell_num;
+ *ret_argc_result = func_type->ret_cell_num;
+ for (param_i = 0; param_i < func_type->param_count; param_i++) {
+ if (VALUE_TYPE_EXTERNREF == func_type->types[param_i]) {
+ need_param_transform = true;
+ }
+ }
+
+ for (result_i = 0; result_i < func_type->result_count; result_i++) {
+ if (VALUE_TYPE_EXTERNREF
+ == func_type->types[func_type->param_count + result_i]) {
+ need_result_transform = true;
+ }
+ }
+
+ if (!need_param_transform && !need_result_transform) {
+ *ret_argv = argv;
+ return true;
+ }
+
+ if (func_type->param_cell_num >= func_type->ret_cell_num) {
+ size = sizeof(uint32) * func_type->param_cell_num;
+ }
+ else {
+ size = sizeof(uint32) * func_type->ret_cell_num;
+ }
+
+ if (!(new_argv = runtime_malloc(size, exec_env->module_inst, NULL, 0))) {
+ return false;
+ }
+
+ if (!need_param_transform) {
+ bh_memcpy_s(new_argv, (uint32)size, argv, (uint32)size);
+ }
+ else {
+ for (param_i = 0; param_i < func_type->param_count && argv_i < argc
+ && new_argv_i < func_type->param_cell_num;
+ param_i++) {
+ uint8 param_type = func_type->types[param_i];
+ if (VALUE_TYPE_EXTERNREF == param_type) {
+ void *externref_obj;
+ uint32 externref_index;
+
+#if UINTPTR_MAX == UINT32_MAX
+ externref_obj = (void *)argv[argv_i];
+#else
+ union {
+ uintptr_t val;
+ uint32 parts[2];
+ } u;
+
+ u.parts[0] = argv[argv_i];
+ u.parts[1] = argv[argv_i + 1];
+ externref_obj = (void *)u.val;
+#endif
+ if (!wasm_externref_obj2ref(exec_env->module_inst,
+ externref_obj, &externref_index)) {
+ wasm_runtime_free(new_argv);
+ return false;
+ }
+
+ new_argv[new_argv_i] = externref_index;
+ argv_i += sizeof(uintptr_t) / sizeof(uint32);
+ new_argv_i++;
+ }
+ else {
+ uint16 param_cell_num = wasm_value_type_cell_num(param_type);
+ uint32 param_size = sizeof(uint32) * param_cell_num;
+ bh_memcpy_s(new_argv + new_argv_i, param_size, argv + argv_i,
+ param_size);
+ argv_i += param_cell_num;
+ new_argv_i += param_cell_num;
+ }
+ }
+ }
+
+ *ret_argv = new_argv;
+ return true;
+}
+
+/* (uintptr_t)externref <- (uint32)index */
+/* argv <- new_argv */
+static bool
+wasm_runtime_finalize_call_function(WASMExecEnv *exec_env,
+ WASMFunctionInstanceCommon *function,
+ uint32 *argv, uint32 argc, uint32 *ret_argv)
+{
+ uint32 argv_i = 0, result_i = 0, ret_argv_i = 0;
+ WASMType *func_type;
+
+ bh_assert((argv && ret_argv) || (argc == 0));
+
+ if (argv == ret_argv) {
+ /* no need to transfrom externref results */
+ return true;
+ }
+
+ func_type = wasm_runtime_get_function_type(
+ function, exec_env->module_inst->module_type);
+ bh_assert(func_type);
+
+ for (result_i = 0; result_i < func_type->result_count && argv_i < argc;
+ result_i++) {
+ uint8 result_type = func_type->types[func_type->param_count + result_i];
+ if (result_type == VALUE_TYPE_EXTERNREF) {
+ void *externref_obj;
+#if UINTPTR_MAX != UINT32_MAX
+ union {
+ uintptr_t val;
+ uint32 parts[2];
+ } u;
+#endif
+
+ if (!wasm_externref_ref2obj(argv[argv_i], &externref_obj)) {
+ wasm_runtime_free(argv);
+ return false;
+ }
+
+#if UINTPTR_MAX == UINT32_MAX
+ ret_argv[ret_argv_i] = (uintptr_t)externref_obj;
+#else
+ u.val = (uintptr_t)externref_obj;
+ ret_argv[ret_argv_i] = u.parts[0];
+ ret_argv[ret_argv_i + 1] = u.parts[1];
+#endif
+ argv_i += 1;
+ ret_argv_i += sizeof(uintptr_t) / sizeof(uint32);
+ }
+ else {
+ uint16 result_cell_num = wasm_value_type_cell_num(result_type);
+ uint32 result_size = sizeof(uint32) * result_cell_num;
+ bh_memcpy_s(ret_argv + ret_argv_i, result_size, argv + argv_i,
+ result_size);
+ argv_i += result_cell_num;
+ ret_argv_i += result_cell_num;
+ }
+ }
+
+ wasm_runtime_free(argv);
+ return true;
+}
+#endif
+
+static bool
+clear_wasi_proc_exit_exception(WASMModuleInstanceCommon *module_inst_comm)
+{
+#if WASM_ENABLE_LIBC_WASI != 0
+ bool has_exception;
+ char exception[EXCEPTION_BUF_LEN];
+ WASMModuleInstance *module_inst = (WASMModuleInstance *)module_inst_comm;
+
+ bh_assert(module_inst_comm->module_type == Wasm_Module_Bytecode
+ || module_inst_comm->module_type == Wasm_Module_AoT);
+
+ has_exception = wasm_copy_exception(module_inst, exception);
+ if (has_exception && !strcmp(exception, "Exception: wasi proc exit")) {
+ /* The "wasi proc exit" exception is thrown by native lib to
+ let wasm app exit, which is a normal behavior, we clear
+ the exception here. And just clear the exception of current
+ thread, don't call `wasm_set_exception(module_inst, NULL)`
+ which will clear the exception of all threads. */
+ module_inst->cur_exception[0] = '\0';
+ return true;
+ }
+ return false;
+#else
+ return false;
+#endif
+}
+
+bool
+wasm_runtime_call_wasm(WASMExecEnv *exec_env,
+ WASMFunctionInstanceCommon *function, uint32 argc,
+ uint32 argv[])
+{
+ bool ret = false;
+ uint32 *new_argv = NULL, param_argc;
+#if WASM_ENABLE_REF_TYPES != 0
+ uint32 result_argc = 0;
+#endif
+
+ if (!wasm_runtime_exec_env_check(exec_env)) {
+ LOG_ERROR("Invalid exec env stack info.");
+ return false;
+ }
+
+#if WASM_ENABLE_REF_TYPES != 0
+ if (!wasm_runtime_prepare_call_function(exec_env, function, argv, argc,
+ &new_argv, &param_argc,
+ &result_argc)) {
+ wasm_runtime_set_exception(exec_env->module_inst,
+ "the arguments conversion is failed");
+ return false;
+ }
+#else
+ new_argv = argv;
+ param_argc = argc;
+#endif
+
+#if WASM_ENABLE_INTERP != 0
+ if (exec_env->module_inst->module_type == Wasm_Module_Bytecode)
+ ret = wasm_call_function(exec_env, (WASMFunctionInstance *)function,
+ param_argc, new_argv);
+#endif
+#if WASM_ENABLE_AOT != 0
+ if (exec_env->module_inst->module_type == Wasm_Module_AoT)
+ ret = aot_call_function(exec_env, (AOTFunctionInstance *)function,
+ param_argc, new_argv);
+#endif
+ if (!ret) {
+ if (clear_wasi_proc_exit_exception(exec_env->module_inst)) {
+ ret = true;
+ }
+ else {
+ if (new_argv != argv) {
+ wasm_runtime_free(new_argv);
+ }
+ return false;
+ }
+ }
+
+#if WASM_ENABLE_REF_TYPES != 0
+ if (!wasm_runtime_finalize_call_function(exec_env, function, new_argv,
+ result_argc, argv)) {
+ wasm_runtime_set_exception(exec_env->module_inst,
+ "the result conversion is failed");
+ return false;
+ }
+#endif
+
+ return ret;
+}
+
+static void
+parse_args_to_uint32_array(WASMType *type, wasm_val_t *args, uint32 *out_argv)
+{
+ uint32 i, p;
+
+ for (i = 0, p = 0; i < type->param_count; i++) {
+ switch (args[i].kind) {
+ case WASM_I32:
+ out_argv[p++] = args[i].of.i32;
+ break;
+ case WASM_I64:
+ {
+ union {
+ uint64 val;
+ uint32 parts[2];
+ } u;
+ u.val = args[i].of.i64;
+ out_argv[p++] = u.parts[0];
+ out_argv[p++] = u.parts[1];
+ break;
+ }
+ case WASM_F32:
+ {
+ union {
+ float32 val;
+ uint32 part;
+ } u;
+ u.val = args[i].of.f32;
+ out_argv[p++] = u.part;
+ break;
+ }
+ case WASM_F64:
+ {
+ union {
+ float64 val;
+ uint32 parts[2];
+ } u;
+ u.val = args[i].of.f64;
+ out_argv[p++] = u.parts[0];
+ out_argv[p++] = u.parts[1];
+ break;
+ }
+#if WASM_ENABLE_REF_TYPES != 0
+ case WASM_FUNCREF:
+ {
+ out_argv[p++] = args[i].of.i32;
+ break;
+ }
+ case WASM_ANYREF:
+ {
+#if UINTPTR_MAX == UINT32_MAX
+ out_argv[p++] = args[i].of.foreign;
+#else
+ union {
+ uintptr_t val;
+ uint32 parts[2];
+ } u;
+
+ u.val = (uintptr_t)args[i].of.foreign;
+ out_argv[p++] = u.parts[0];
+ out_argv[p++] = u.parts[1];
+#endif
+ break;
+ }
+#endif
+ default:
+ bh_assert(0);
+ break;
+ }
+ }
+}
+
+static void
+parse_uint32_array_to_results(WASMType *type, uint32 *argv,
+ wasm_val_t *out_results)
+{
+ uint32 i, p;
+
+ for (i = 0, p = 0; i < type->result_count; i++) {
+ switch (type->types[type->param_count + i]) {
+ case VALUE_TYPE_I32:
+ out_results[i].kind = WASM_I32;
+ out_results[i].of.i32 = (int32)argv[p++];
+ break;
+ case VALUE_TYPE_I64:
+ {
+ union {
+ uint64 val;
+ uint32 parts[2];
+ } u;
+ u.parts[0] = argv[p++];
+ u.parts[1] = argv[p++];
+ out_results[i].kind = WASM_I64;
+ out_results[i].of.i64 = u.val;
+ break;
+ }
+ case VALUE_TYPE_F32:
+ {
+ union {
+ float32 val;
+ uint32 part;
+ } u;
+ u.part = argv[p++];
+ out_results[i].kind = WASM_F32;
+ out_results[i].of.f32 = u.val;
+ break;
+ }
+ case VALUE_TYPE_F64:
+ {
+ union {
+ float64 val;
+ uint32 parts[2];
+ } u;
+ u.parts[0] = argv[p++];
+ u.parts[1] = argv[p++];
+ out_results[i].kind = WASM_F64;
+ out_results[i].of.f64 = u.val;
+ break;
+ }
+#if WASM_ENABLE_REF_TYPES != 0
+ case VALUE_TYPE_FUNCREF:
+ {
+ out_results[i].kind = WASM_I32;
+ out_results[i].of.i32 = (int32)argv[p++];
+ break;
+ }
+ case VALUE_TYPE_EXTERNREF:
+ {
+#if UINTPTR_MAX == UINT32_MAX
+ out_results[i].kind = WASM_ANYREF;
+ out_results[i].of.foreign = (uintptr_t)argv[p++];
+#else
+ union {
+ uintptr_t val;
+ uint32 parts[2];
+ } u;
+ u.parts[0] = argv[p++];
+ u.parts[1] = argv[p++];
+ out_results[i].kind = WASM_ANYREF;
+ out_results[i].of.foreign = u.val;
+#endif
+ break;
+ }
+#endif
+ default:
+ bh_assert(0);
+ break;
+ }
+ }
+}
+
+bool
+wasm_runtime_call_wasm_a(WASMExecEnv *exec_env,
+ WASMFunctionInstanceCommon *function,
+ uint32 num_results, wasm_val_t results[],
+ uint32 num_args, wasm_val_t args[])
+{
+ uint32 argc, argv_buf[16] = { 0 }, *argv = argv_buf, cell_num, module_type;
+#if WASM_ENABLE_REF_TYPES != 0
+ uint32 i, param_size_in_double_world = 0, result_size_in_double_world = 0;
+#endif
+ uint64 total_size;
+ WASMType *type;
+ bool ret = false;
+
+ module_type = exec_env->module_inst->module_type;
+ type = wasm_runtime_get_function_type(function, module_type);
+
+ if (!type) {
+ LOG_ERROR("Function type get failed, WAMR Interpreter and AOT must be "
+ "enabled at least one.");
+ goto fail1;
+ }
+
+#if WASM_ENABLE_REF_TYPES != 0
+ for (i = 0; i < type->param_count; i++) {
+ param_size_in_double_world +=
+ wasm_value_type_cell_num_outside(type->types[i]);
+ }
+ for (i = 0; i < type->result_count; i++) {
+ result_size_in_double_world += wasm_value_type_cell_num_outside(
+ type->types[type->param_count + i]);
+ }
+ argc = param_size_in_double_world;
+ cell_num = (argc >= result_size_in_double_world)
+ ? argc
+ : result_size_in_double_world;
+#else
+ argc = type->param_cell_num;
+ cell_num = (argc > type->ret_cell_num) ? argc : type->ret_cell_num;
+#endif
+
+ if (num_results != type->result_count) {
+ LOG_ERROR(
+ "The result value number does not match the function declaration.");
+ goto fail1;
+ }
+
+ if (num_args != type->param_count) {
+ LOG_ERROR("The argument value number does not match the function "
+ "declaration.");
+ goto fail1;
+ }
+
+ total_size = sizeof(uint32) * (uint64)(cell_num > 2 ? cell_num : 2);
+ if (total_size > sizeof(argv_buf)) {
+ if (!(argv =
+ runtime_malloc(total_size, exec_env->module_inst, NULL, 0))) {
+ goto fail1;
+ }
+ }
+
+ parse_args_to_uint32_array(type, args, argv);
+ if (!(ret = wasm_runtime_call_wasm(exec_env, function, argc, argv)))
+ goto fail2;
+
+ parse_uint32_array_to_results(type, argv, results);
+
+fail2:
+ if (argv != argv_buf)
+ wasm_runtime_free(argv);
+fail1:
+ return ret;
+}
+
+bool
+wasm_runtime_call_wasm_v(WASMExecEnv *exec_env,
+ WASMFunctionInstanceCommon *function,
+ uint32 num_results, wasm_val_t results[],
+ uint32 num_args, ...)
+{
+ wasm_val_t args_buf[8] = { 0 }, *args = args_buf;
+ WASMType *type = NULL;
+ bool ret = false;
+ uint64 total_size;
+ uint32 i = 0, module_type;
+ va_list vargs;
+
+ module_type = exec_env->module_inst->module_type;
+ type = wasm_runtime_get_function_type(function, module_type);
+
+ if (!type) {
+ LOG_ERROR("Function type get failed, WAMR Interpreter and AOT "
+ "must be enabled at least one.");
+ goto fail1;
+ }
+
+ if (num_args != type->param_count) {
+ LOG_ERROR("The argument value number does not match the "
+ "function declaration.");
+ goto fail1;
+ }
+
+ total_size = sizeof(wasm_val_t) * (uint64)num_args;
+ if (total_size > sizeof(args_buf)) {
+ if (!(args =
+ runtime_malloc(total_size, exec_env->module_inst, NULL, 0))) {
+ goto fail1;
+ }
+ }
+
+ va_start(vargs, num_args);
+ for (i = 0; i < num_args; i++) {
+ switch (type->types[i]) {
+ case VALUE_TYPE_I32:
+ args[i].kind = WASM_I32;
+ args[i].of.i32 = va_arg(vargs, uint32);
+ break;
+ case VALUE_TYPE_I64:
+ args[i].kind = WASM_I64;
+ args[i].of.i64 = va_arg(vargs, uint64);
+ break;
+ case VALUE_TYPE_F32:
+ args[i].kind = WASM_F32;
+ args[i].of.f32 = (float32)va_arg(vargs, float64);
+ break;
+ case VALUE_TYPE_F64:
+ args[i].kind = WASM_F64;
+ args[i].of.f64 = va_arg(vargs, float64);
+ break;
+#if WASM_ENABLE_REF_TYPES != 0
+ case VALUE_TYPE_FUNCREF:
+ {
+ args[i].kind = WASM_FUNCREF;
+ args[i].of.i32 = va_arg(vargs, uint32);
+ break;
+ }
+ case VALUE_TYPE_EXTERNREF:
+ {
+ args[i].kind = WASM_ANYREF;
+ args[i].of.foreign = va_arg(vargs, uintptr_t);
+ break;
+ }
+#endif
+ default:
+ bh_assert(0);
+ break;
+ }
+ }
+ va_end(vargs);
+
+ ret = wasm_runtime_call_wasm_a(exec_env, function, num_results, results,
+ num_args, args);
+ if (args != args_buf)
+ wasm_runtime_free(args);
+
+fail1:
+ return ret;
+}
+
+bool
+wasm_runtime_create_exec_env_singleton(
+ WASMModuleInstanceCommon *module_inst_comm)
+{
+ WASMModuleInstance *module_inst = (WASMModuleInstance *)module_inst_comm;
+ WASMExecEnv *exec_env = NULL;
+
+ bh_assert(module_inst_comm->module_type == Wasm_Module_Bytecode
+ || module_inst_comm->module_type == Wasm_Module_AoT);
+
+ if (module_inst->exec_env_singleton) {
+ return true;
+ }
+
+ exec_env = wasm_exec_env_create(module_inst_comm,
+ module_inst->default_wasm_stack_size);
+ if (exec_env)
+ module_inst->exec_env_singleton = exec_env;
+
+ return exec_env ? true : false;
+}
+
+WASMExecEnv *
+wasm_runtime_get_exec_env_singleton(WASMModuleInstanceCommon *module_inst_comm)
+{
+ WASMModuleInstance *module_inst = (WASMModuleInstance *)module_inst_comm;
+
+ bh_assert(module_inst_comm->module_type == Wasm_Module_Bytecode
+ || module_inst_comm->module_type == Wasm_Module_AoT);
+
+ if (!module_inst->exec_env_singleton) {
+ wasm_runtime_create_exec_env_singleton(module_inst_comm);
+ }
+ return module_inst->exec_env_singleton;
+}
+
+void
+wasm_set_exception(WASMModuleInstance *module_inst, const char *exception)
+{
+ WASMExecEnv *exec_env = NULL;
+
+#if WASM_ENABLE_SHARED_MEMORY != 0
+ WASMSharedMemNode *node =
+ wasm_module_get_shared_memory((WASMModuleCommon *)module_inst->module);
+ if (node)
+ os_mutex_lock(&node->shared_mem_lock);
+#endif
+ if (exception) {
+ snprintf(module_inst->cur_exception, sizeof(module_inst->cur_exception),
+ "Exception: %s", exception);
+ }
+ else {
+ module_inst->cur_exception[0] = '\0';
+ }
+#if WASM_ENABLE_SHARED_MEMORY != 0
+ if (node)
+ os_mutex_unlock(&node->shared_mem_lock);
+#endif
+
+#if WASM_ENABLE_THREAD_MGR != 0
+ exec_env =
+ wasm_clusters_search_exec_env((WASMModuleInstanceCommon *)module_inst);
+ if (exec_env) {
+ wasm_cluster_spread_exception(exec_env, exception ? false : true);
+ }
+#else
+ (void)exec_env;
+#endif
+}
+
+/* clang-format off */
+static const char *exception_msgs[] = {
+ "unreachable", /* EXCE_UNREACHABLE */
+ "allocate memory failed", /* EXCE_OUT_OF_MEMORY */
+ "out of bounds memory access", /* EXCE_OUT_OF_BOUNDS_MEMORY_ACCESS */
+ "integer overflow", /* EXCE_INTEGER_OVERFLOW */
+ "integer divide by zero", /* EXCE_INTEGER_DIVIDE_BY_ZERO */
+ "invalid conversion to integer", /* EXCE_INVALID_CONVERSION_TO_INTEGER */
+ "indirect call type mismatch", /* EXCE_INVALID_FUNCTION_TYPE_INDEX */
+ "invalid function index", /* EXCE_INVALID_FUNCTION_INDEX */
+ "undefined element", /* EXCE_UNDEFINED_ELEMENT */
+ "uninitialized element", /* EXCE_UNINITIALIZED_ELEMENT */
+ "failed to call unlinked import function", /* EXCE_CALL_UNLINKED_IMPORT_FUNC */
+ "native stack overflow", /* EXCE_NATIVE_STACK_OVERFLOW */
+ "unaligned atomic", /* EXCE_UNALIGNED_ATOMIC */
+ "wasm auxiliary stack overflow", /* EXCE_AUX_STACK_OVERFLOW */
+ "wasm auxiliary stack underflow", /* EXCE_AUX_STACK_UNDERFLOW */
+ "out of bounds table access", /* EXCE_OUT_OF_BOUNDS_TABLE_ACCESS */
+ "wasm operand stack overflow", /* EXCE_OPERAND_STACK_OVERFLOW */
+ "failed to compile fast jit function", /* EXCE_FAILED_TO_COMPILE_FAST_JIT_FUNC */
+ "", /* EXCE_ALREADY_THROWN */
+};
+/* clang-format on */
+
+void
+wasm_set_exception_with_id(WASMModuleInstance *module_inst, uint32 id)
+{
+ if (id < EXCE_NUM)
+ wasm_set_exception(module_inst, exception_msgs[id]);
+ else
+ wasm_set_exception(module_inst, "unknown exception");
+}
+
+const char *
+wasm_get_exception(WASMModuleInstance *module_inst)
+{
+ if (module_inst->cur_exception[0] == '\0')
+ return NULL;
+ else
+ return module_inst->cur_exception;
+}
+
+bool
+wasm_copy_exception(WASMModuleInstance *module_inst, char *exception_buf)
+{
+ bool has_exception = false;
+
+#if WASM_ENABLE_SHARED_MEMORY != 0
+ WASMSharedMemNode *node =
+ wasm_module_get_shared_memory((WASMModuleCommon *)module_inst->module);
+ if (node)
+ os_mutex_lock(&node->shared_mem_lock);
+#endif
+ if (module_inst->cur_exception[0] != '\0') {
+ /* NULL is passed if the caller is not interested in getting the
+ * exception content, but only in knowing if an exception has been
+ * raised
+ */
+ if (exception_buf != NULL)
+ bh_memcpy_s(exception_buf, sizeof(module_inst->cur_exception),
+ module_inst->cur_exception,
+ sizeof(module_inst->cur_exception));
+ has_exception = true;
+ }
+#if WASM_ENABLE_SHARED_MEMORY != 0
+ if (node)
+ os_mutex_unlock(&node->shared_mem_lock);
+#endif
+
+ return has_exception;
+}
+
+void
+wasm_runtime_set_exception(WASMModuleInstanceCommon *module_inst_comm,
+ const char *exception)
+{
+ WASMModuleInstance *module_inst = (WASMModuleInstance *)module_inst_comm;
+
+ bh_assert(module_inst_comm->module_type == Wasm_Module_Bytecode
+ || module_inst_comm->module_type == Wasm_Module_AoT);
+ wasm_set_exception(module_inst, exception);
+}
+
+const char *
+wasm_runtime_get_exception(WASMModuleInstanceCommon *module_inst_comm)
+{
+ WASMModuleInstance *module_inst = (WASMModuleInstance *)module_inst_comm;
+
+ bh_assert(module_inst_comm->module_type == Wasm_Module_Bytecode
+ || module_inst_comm->module_type == Wasm_Module_AoT);
+ return wasm_get_exception(module_inst);
+}
+
+bool
+wasm_runtime_copy_exception(WASMModuleInstanceCommon *module_inst_comm,
+ char *exception_buf)
+{
+ WASMModuleInstance *module_inst = (WASMModuleInstance *)module_inst_comm;
+
+ bh_assert(module_inst_comm->module_type == Wasm_Module_Bytecode
+ || module_inst_comm->module_type == Wasm_Module_AoT);
+ return wasm_copy_exception(module_inst, exception_buf);
+}
+
+void
+wasm_runtime_clear_exception(WASMModuleInstanceCommon *module_inst_comm)
+{
+ bh_assert(module_inst_comm->module_type == Wasm_Module_Bytecode
+ || module_inst_comm->module_type == Wasm_Module_AoT);
+ wasm_runtime_set_exception(module_inst_comm, NULL);
+}
+
+void
+wasm_runtime_set_custom_data_internal(
+ WASMModuleInstanceCommon *module_inst_comm, void *custom_data)
+{
+ WASMModuleInstance *module_inst = (WASMModuleInstance *)module_inst_comm;
+
+ bh_assert(module_inst_comm->module_type == Wasm_Module_Bytecode
+ || module_inst_comm->module_type == Wasm_Module_AoT);
+ module_inst->custom_data = custom_data;
+}
+
+void
+wasm_runtime_set_custom_data(WASMModuleInstanceCommon *module_inst,
+ void *custom_data)
+{
+#if WASM_ENABLE_THREAD_MGR != 0
+ wasm_cluster_spread_custom_data(module_inst, custom_data);
+#else
+ wasm_runtime_set_custom_data_internal(module_inst, custom_data);
+#endif
+}
+
+void *
+wasm_runtime_get_custom_data(WASMModuleInstanceCommon *module_inst_comm)
+{
+ WASMModuleInstance *module_inst = (WASMModuleInstance *)module_inst_comm;
+
+ bh_assert(module_inst_comm->module_type == Wasm_Module_Bytecode
+ || module_inst_comm->module_type == Wasm_Module_AoT);
+ return module_inst->custom_data;
+}
+
+uint32
+wasm_runtime_module_malloc_internal(WASMModuleInstanceCommon *module_inst,
+ WASMExecEnv *exec_env, uint32 size,
+ void **p_native_addr)
+{
+#if WASM_ENABLE_INTERP != 0
+ if (module_inst->module_type == Wasm_Module_Bytecode)
+ return wasm_module_malloc_internal((WASMModuleInstance *)module_inst,
+ exec_env, size, p_native_addr);
+#endif
+#if WASM_ENABLE_AOT != 0
+ if (module_inst->module_type == Wasm_Module_AoT)
+ return aot_module_malloc_internal((AOTModuleInstance *)module_inst,
+ exec_env, size, p_native_addr);
+#endif
+ return 0;
+}
+
+uint32
+wasm_runtime_module_realloc_internal(WASMModuleInstanceCommon *module_inst,
+ WASMExecEnv *exec_env, uint32 ptr,
+ uint32 size, void **p_native_addr)
+{
+#if WASM_ENABLE_INTERP != 0
+ if (module_inst->module_type == Wasm_Module_Bytecode)
+ return wasm_module_realloc_internal((WASMModuleInstance *)module_inst,
+ exec_env, ptr, size, p_native_addr);
+#endif
+#if WASM_ENABLE_AOT != 0
+ if (module_inst->module_type == Wasm_Module_AoT)
+ return aot_module_realloc_internal((AOTModuleInstance *)module_inst,
+ exec_env, ptr, size, p_native_addr);
+#endif
+ return 0;
+}
+
+void
+wasm_runtime_module_free_internal(WASMModuleInstanceCommon *module_inst,
+ WASMExecEnv *exec_env, uint32 ptr)
+{
+#if WASM_ENABLE_INTERP != 0
+ if (module_inst->module_type == Wasm_Module_Bytecode) {
+ wasm_module_free_internal((WASMModuleInstance *)module_inst, exec_env,
+ ptr);
+ return;
+ }
+#endif
+#if WASM_ENABLE_AOT != 0
+ if (module_inst->module_type == Wasm_Module_AoT) {
+ aot_module_free_internal((AOTModuleInstance *)module_inst, exec_env,
+ ptr);
+ return;
+ }
+#endif
+}
+
+uint32
+wasm_runtime_module_malloc(WASMModuleInstanceCommon *module_inst, uint32 size,
+ void **p_native_addr)
+{
+#if WASM_ENABLE_INTERP != 0
+ if (module_inst->module_type == Wasm_Module_Bytecode)
+ return wasm_module_malloc((WASMModuleInstance *)module_inst, size,
+ p_native_addr);
+#endif
+#if WASM_ENABLE_AOT != 0
+ if (module_inst->module_type == Wasm_Module_AoT)
+ return aot_module_malloc((AOTModuleInstance *)module_inst, size,
+ p_native_addr);
+#endif
+ return 0;
+}
+
+uint32
+wasm_runtime_module_realloc(WASMModuleInstanceCommon *module_inst, uint32 ptr,
+ uint32 size, void **p_native_addr)
+{
+#if WASM_ENABLE_INTERP != 0
+ if (module_inst->module_type == Wasm_Module_Bytecode)
+ return wasm_module_realloc((WASMModuleInstance *)module_inst, ptr, size,
+ p_native_addr);
+#endif
+#if WASM_ENABLE_AOT != 0
+ if (module_inst->module_type == Wasm_Module_AoT)
+ return aot_module_realloc((AOTModuleInstance *)module_inst, ptr, size,
+ p_native_addr);
+#endif
+ return 0;
+}
+
+void
+wasm_runtime_module_free(WASMModuleInstanceCommon *module_inst, uint32 ptr)
+{
+#if WASM_ENABLE_INTERP != 0
+ if (module_inst->module_type == Wasm_Module_Bytecode) {
+ wasm_module_free((WASMModuleInstance *)module_inst, ptr);
+ return;
+ }
+#endif
+#if WASM_ENABLE_AOT != 0
+ if (module_inst->module_type == Wasm_Module_AoT) {
+ aot_module_free((AOTModuleInstance *)module_inst, ptr);
+ return;
+ }
+#endif
+}
+
+uint32
+wasm_runtime_module_dup_data(WASMModuleInstanceCommon *module_inst,
+ const char *src, uint32 size)
+{
+#if WASM_ENABLE_INTERP != 0
+ if (module_inst->module_type == Wasm_Module_Bytecode) {
+ return wasm_module_dup_data((WASMModuleInstance *)module_inst, src,
+ size);
+ }
+#endif
+#if WASM_ENABLE_AOT != 0
+ if (module_inst->module_type == Wasm_Module_AoT) {
+ return aot_module_dup_data((AOTModuleInstance *)module_inst, src, size);
+ }
+#endif
+ return 0;
+}
+
+#if WASM_ENABLE_LIBC_WASI != 0
+
+static WASIArguments *
+get_wasi_args_from_module(wasm_module_t module)
+{
+ WASIArguments *wasi_args = NULL;
+
+#if WASM_ENABLE_INTERP != 0 || WASM_ENABLE_JIT != 0
+ if (module->module_type == Wasm_Module_Bytecode)
+ wasi_args = &((WASMModule *)module)->wasi_args;
+#endif
+#if WASM_ENABLE_AOT != 0
+ if (module->module_type == Wasm_Module_AoT)
+ wasi_args = &((AOTModule *)module)->wasi_args;
+#endif
+
+ return wasi_args;
+}
+
+void
+wasm_runtime_set_wasi_args_ex(WASMModuleCommon *module, const char *dir_list[],
+ uint32 dir_count, const char *map_dir_list[],
+ uint32 map_dir_count, const char *env_list[],
+ uint32 env_count, char *argv[], int argc,
+ int stdinfd, int stdoutfd, int stderrfd)
+{
+ WASIArguments *wasi_args = get_wasi_args_from_module(module);
+
+ bh_assert(wasi_args);
+
+ wasi_args->dir_list = dir_list;
+ wasi_args->dir_count = dir_count;
+ wasi_args->map_dir_list = map_dir_list;
+ wasi_args->map_dir_count = map_dir_count;
+ wasi_args->env = env_list;
+ wasi_args->env_count = env_count;
+ wasi_args->argv = argv;
+ wasi_args->argc = (uint32)argc;
+ wasi_args->stdio[0] = stdinfd;
+ wasi_args->stdio[1] = stdoutfd;
+ wasi_args->stdio[2] = stderrfd;
+
+#if WASM_ENABLE_MULTI_MODULE != 0
+#if WASM_ENABLE_INTERP != 0
+ if (module->module_type == Wasm_Module_Bytecode) {
+ wasm_propagate_wasi_args((WASMModule *)module);
+ }
+#endif
+#endif
+}
+
+void
+wasm_runtime_set_wasi_args(WASMModuleCommon *module, const char *dir_list[],
+ uint32 dir_count, const char *map_dir_list[],
+ uint32 map_dir_count, const char *env_list[],
+ uint32 env_count, char *argv[], int argc)
+{
+ wasm_runtime_set_wasi_args_ex(module, dir_list, dir_count, map_dir_list,
+ map_dir_count, env_list, env_count, argv,
+ argc, -1, -1, -1);
+}
+
+void
+wasm_runtime_set_wasi_addr_pool(wasm_module_t module, const char *addr_pool[],
+ uint32 addr_pool_size)
+{
+ WASIArguments *wasi_args = get_wasi_args_from_module(module);
+
+ if (wasi_args) {
+ wasi_args->addr_pool = addr_pool;
+ wasi_args->addr_count = addr_pool_size;
+ }
+}
+
+void
+wasm_runtime_set_wasi_ns_lookup_pool(wasm_module_t module,
+ const char *ns_lookup_pool[],
+ uint32 ns_lookup_pool_size)
+{
+ WASIArguments *wasi_args = get_wasi_args_from_module(module);
+
+ if (wasi_args) {
+ wasi_args->ns_lookup_pool = ns_lookup_pool;
+ wasi_args->ns_lookup_count = ns_lookup_pool_size;
+ }
+}
+
+#if WASM_ENABLE_UVWASI == 0
+static bool
+copy_string_array(const char *array[], uint32 array_size, char **buf_ptr,
+ char ***list_ptr, uint64 *out_buf_size)
+{
+ uint64 buf_size = 0, total_size;
+ uint32 buf_offset = 0, i;
+ char *buf = NULL, **list = NULL;
+
+ for (i = 0; i < array_size; i++)
+ buf_size += strlen(array[i]) + 1;
+
+ /* 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)))
+ || buf_size >= UINT32_MAX
+ || (buf_size > 0 && !(buf = wasm_runtime_malloc((uint32)buf_size)))) {
+
+ if (buf)
+ wasm_runtime_free(buf);
+ if (list)
+ wasm_runtime_free(list);
+ return false;
+ }
+
+ for (i = 0; i < array_size; i++) {
+ list[i] = buf + buf_offset;
+ bh_strcpy_s(buf + buf_offset, (uint32)buf_size - buf_offset, array[i]);
+ buf_offset += (uint32)(strlen(array[i]) + 1);
+ }
+ list[array_size] = NULL;
+
+ *list_ptr = list;
+ *buf_ptr = buf;
+ if (out_buf_size)
+ *out_buf_size = buf_size;
+
+ return true;
+}
+
+bool
+wasm_runtime_init_wasi(WASMModuleInstanceCommon *module_inst,
+ const char *dir_list[], uint32 dir_count,
+ const char *map_dir_list[], uint32 map_dir_count,
+ const char *env[], uint32 env_count,
+ const char *addr_pool[], uint32 addr_pool_size,
+ const char *ns_lookup_pool[], uint32 ns_lookup_pool_size,
+ char *argv[], uint32 argc, int stdinfd, int stdoutfd,
+ int stderrfd, char *error_buf, uint32 error_buf_size)
+{
+ WASIContext *wasi_ctx;
+ char *argv_buf = NULL;
+ char **argv_list = NULL;
+ char *env_buf = NULL;
+ char **env_list = NULL;
+ char *ns_lookup_buf = NULL;
+ char **ns_lookup_list = NULL;
+ uint64 argv_buf_size = 0, env_buf_size = 0;
+ struct fd_table *curfds = NULL;
+ struct fd_prestats *prestats = NULL;
+ struct argv_environ_values *argv_environ = NULL;
+ struct addr_pool *apool = NULL;
+ bool fd_table_inited = false, fd_prestats_inited = false;
+ bool argv_environ_inited = false;
+ bool addr_pool_inited = false;
+ __wasi_fd_t wasm_fd = 3;
+ int32 raw_fd;
+ char *path, resolved_path[PATH_MAX];
+ uint32 i;
+
+ if (!(wasi_ctx = runtime_malloc(sizeof(WASIContext), NULL, error_buf,
+ error_buf_size))) {
+ return false;
+ }
+
+ wasm_runtime_set_wasi_ctx(module_inst, wasi_ctx);
+
+ /* process argv[0], trip the path and suffix, only keep the program name
+ */
+ if (!copy_string_array((const char **)argv, argc, &argv_buf, &argv_list,
+ &argv_buf_size)) {
+ set_error_buf(error_buf, error_buf_size,
+ "Init wasi environment failed: allocate memory failed");
+ goto fail;
+ }
+
+ if (!copy_string_array(env, env_count, &env_buf, &env_list,
+ &env_buf_size)) {
+ set_error_buf(error_buf, error_buf_size,
+ "Init wasi environment failed: allocate memory failed");
+ goto fail;
+ }
+
+ if (!(curfds = wasm_runtime_malloc(sizeof(struct fd_table)))
+ || !(prestats = wasm_runtime_malloc(sizeof(struct fd_prestats)))
+ || !(argv_environ =
+ wasm_runtime_malloc(sizeof(struct argv_environ_values)))
+ || !(apool = wasm_runtime_malloc(sizeof(struct addr_pool)))) {
+ set_error_buf(error_buf, error_buf_size,
+ "Init wasi environment failed: allocate memory failed");
+ goto fail;
+ }
+
+ if (!fd_table_init(curfds)) {
+ set_error_buf(error_buf, error_buf_size,
+ "Init wasi environment failed: "
+ "init fd table failed");
+ goto fail;
+ }
+ fd_table_inited = true;
+
+ if (!fd_prestats_init(prestats)) {
+ set_error_buf(error_buf, error_buf_size,
+ "Init wasi environment failed: "
+ "init fd prestats failed");
+ goto fail;
+ }
+ fd_prestats_inited = true;
+
+ if (!argv_environ_init(argv_environ, argv_buf, argv_buf_size, argv_list,
+ argc, env_buf, env_buf_size, env_list, env_count)) {
+ set_error_buf(error_buf, error_buf_size,
+ "Init wasi environment failed: "
+ "init argument environment failed");
+ goto fail;
+ }
+ argv_environ_inited = true;
+
+ if (!addr_pool_init(apool)) {
+ set_error_buf(error_buf, error_buf_size,
+ "Init wasi environment failed: "
+ "init the address pool failed");
+ goto fail;
+ }
+ addr_pool_inited = true;
+
+ /* Prepopulate curfds with stdin, stdout, and stderr file descriptors.
+ *
+ * If -1 is given, use STDIN_FILENO (0), STDOUT_FILENO (1),
+ * STDERR_FILENO (2) respectively.
+ */
+ if (!fd_table_insert_existing(curfds, 0, (stdinfd != -1) ? stdinfd : 0)
+ || !fd_table_insert_existing(curfds, 1, (stdoutfd != -1) ? stdoutfd : 1)
+ || !fd_table_insert_existing(curfds, 2,
+ (stderrfd != -1) ? stderrfd : 2)) {
+ set_error_buf(error_buf, error_buf_size,
+ "Init wasi environment failed: init fd table failed");
+ goto fail;
+ }
+
+ wasm_fd = 3;
+ for (i = 0; i < dir_count; i++, wasm_fd++) {
+ path = realpath(dir_list[i], resolved_path);
+ if (!path) {
+ if (error_buf)
+ snprintf(error_buf, error_buf_size,
+ "error while pre-opening directory %s: %d\n",
+ dir_list[i], errno);
+ goto fail;
+ }
+
+ raw_fd = open(path, O_RDONLY | O_DIRECTORY, 0);
+ if (raw_fd == -1) {
+ if (error_buf)
+ snprintf(error_buf, error_buf_size,
+ "error while pre-opening directory %s: %d\n",
+ dir_list[i], errno);
+ goto fail;
+ }
+
+ fd_table_insert_existing(curfds, wasm_fd, raw_fd);
+ fd_prestats_insert(prestats, dir_list[i], wasm_fd);
+ }
+
+ /* addr_pool(textual) -> apool */
+ for (i = 0; i < addr_pool_size; i++) {
+ char *cp, *address, *mask;
+ bool ret = false;
+
+ cp = bh_strdup(addr_pool[i]);
+ if (!cp) {
+ set_error_buf(error_buf, error_buf_size,
+ "Init wasi environment failed: copy address failed");
+ goto fail;
+ }
+
+ address = strtok(cp, "/");
+ mask = strtok(NULL, "/");
+
+ ret = addr_pool_insert(apool, address, (uint8)(mask ? atoi(mask) : 0));
+ wasm_runtime_free(cp);
+ if (!ret) {
+ set_error_buf(error_buf, error_buf_size,
+ "Init wasi environment failed: store address failed");
+ goto fail;
+ }
+ }
+
+ if (!copy_string_array(ns_lookup_pool, ns_lookup_pool_size, &ns_lookup_buf,
+ &ns_lookup_list, NULL)) {
+ set_error_buf(error_buf, error_buf_size,
+ "Init wasi environment failed: allocate memory failed");
+ goto fail;
+ }
+
+ wasi_ctx->curfds = curfds;
+ wasi_ctx->prestats = prestats;
+ wasi_ctx->argv_environ = argv_environ;
+ wasi_ctx->addr_pool = apool;
+ wasi_ctx->argv_buf = argv_buf;
+ wasi_ctx->argv_list = argv_list;
+ wasi_ctx->env_buf = env_buf;
+ wasi_ctx->env_list = env_list;
+ wasi_ctx->ns_lookup_buf = ns_lookup_buf;
+ wasi_ctx->ns_lookup_list = ns_lookup_list;
+
+ return true;
+
+fail:
+ if (argv_environ_inited)
+ argv_environ_destroy(argv_environ);
+ if (fd_prestats_inited)
+ fd_prestats_destroy(prestats);
+ if (fd_table_inited)
+ fd_table_destroy(curfds);
+ if (addr_pool_inited)
+ addr_pool_destroy(apool);
+ if (curfds)
+ wasm_runtime_free(curfds);
+ if (prestats)
+ wasm_runtime_free(prestats);
+ if (argv_environ)
+ wasm_runtime_free(argv_environ);
+ if (apool)
+ wasm_runtime_free(apool);
+ if (argv_buf)
+ wasm_runtime_free(argv_buf);
+ if (argv_list)
+ wasm_runtime_free(argv_list);
+ if (env_buf)
+ wasm_runtime_free(env_buf);
+ if (env_list)
+ wasm_runtime_free(env_list);
+ if (ns_lookup_buf)
+ wasm_runtime_free(ns_lookup_buf);
+ if (ns_lookup_list)
+ wasm_runtime_free(ns_lookup_list);
+ return false;
+}
+#else /* else of WASM_ENABLE_UVWASI == 0 */
+static void *
+wasm_uvwasi_malloc(size_t size, void *mem_user_data)
+{
+ return runtime_malloc(size, NULL, NULL, 0);
+ (void)mem_user_data;
+}
+
+static void
+wasm_uvwasi_free(void *ptr, void *mem_user_data)
+{
+ if (ptr)
+ wasm_runtime_free(ptr);
+ (void)mem_user_data;
+}
+
+static void *
+wasm_uvwasi_calloc(size_t nmemb, size_t size, void *mem_user_data)
+{
+ uint64 total_size = (uint64)nmemb * size;
+ return runtime_malloc(total_size, NULL, NULL, 0);
+ (void)mem_user_data;
+}
+
+static void *
+wasm_uvwasi_realloc(void *ptr, size_t size, void *mem_user_data)
+{
+ if (size >= UINT32_MAX) {
+ return NULL;
+ }
+ return wasm_runtime_realloc(ptr, (uint32)size);
+}
+
+/* clang-format off */
+static uvwasi_mem_t uvwasi_allocator = {
+ .mem_user_data = 0,
+ .malloc = wasm_uvwasi_malloc,
+ .free = wasm_uvwasi_free,
+ .calloc = wasm_uvwasi_calloc,
+ .realloc = wasm_uvwasi_realloc
+};
+/* clang-format on */
+
+bool
+wasm_runtime_init_wasi(WASMModuleInstanceCommon *module_inst,
+ const char *dir_list[], uint32 dir_count,
+ const char *map_dir_list[], uint32 map_dir_count,
+ const char *env[], uint32 env_count,
+ const char *addr_pool[], uint32 addr_pool_size,
+ const char *ns_lookup_pool[], uint32 ns_lookup_pool_size,
+ char *argv[], uint32 argc, int stdinfd, int stdoutfd,
+ int stderrfd, char *error_buf, uint32 error_buf_size)
+{
+ WASIContext *ctx;
+ uvwasi_t *uvwasi;
+ uvwasi_options_t init_options;
+ const char **envp = NULL;
+ uint64 total_size;
+ uint32 i;
+ bool ret = false;
+
+ ctx = runtime_malloc(sizeof(*ctx), module_inst, error_buf, error_buf_size);
+ if (!ctx)
+ return false;
+ uvwasi = &ctx->uvwasi;
+
+ /* Setup the initialization options */
+ uvwasi_options_init(&init_options);
+ init_options.allocator = &uvwasi_allocator;
+ init_options.argc = argc;
+ init_options.argv = (const char **)argv;
+ init_options.in = (stdinfd != -1) ? (uvwasi_fd_t)stdinfd : init_options.in;
+ init_options.out =
+ (stdoutfd != -1) ? (uvwasi_fd_t)stdoutfd : init_options.out;
+ init_options.err =
+ (stderrfd != -1) ? (uvwasi_fd_t)stderrfd : init_options.err;
+
+ if (dir_count > 0) {
+ init_options.preopenc = dir_count;
+
+ total_size = sizeof(uvwasi_preopen_t) * (uint64)init_options.preopenc;
+ init_options.preopens = (uvwasi_preopen_t *)runtime_malloc(
+ total_size, module_inst, error_buf, error_buf_size);
+ if (init_options.preopens == NULL)
+ goto fail;
+
+ for (i = 0; i < init_options.preopenc; i++) {
+ init_options.preopens[i].real_path = dir_list[i];
+ init_options.preopens[i].mapped_path =
+ (i < map_dir_count) ? map_dir_list[i] : dir_list[i];
+ }
+ }
+
+ if (env_count > 0) {
+ total_size = sizeof(char *) * (uint64)(env_count + 1);
+ envp =
+ runtime_malloc(total_size, module_inst, error_buf, error_buf_size);
+ if (envp == NULL)
+ goto fail;
+
+ for (i = 0; i < env_count; i++) {
+ envp[i] = env[i];
+ }
+ envp[env_count] = NULL;
+ init_options.envp = envp;
+ }
+
+ if (UVWASI_ESUCCESS != uvwasi_init(uvwasi, &init_options)) {
+ set_error_buf(error_buf, error_buf_size, "uvwasi init failed");
+ goto fail;
+ }
+
+ wasm_runtime_set_wasi_ctx(module_inst, ctx);
+
+ ret = true;
+
+fail:
+ if (envp)
+ wasm_runtime_free((void *)envp);
+
+ if (init_options.preopens)
+ wasm_runtime_free(init_options.preopens);
+
+ if (!ret && uvwasi)
+ wasm_runtime_free(uvwasi);
+
+ return ret;
+}
+#endif /* end of WASM_ENABLE_UVWASI */
+
+bool
+wasm_runtime_is_wasi_mode(WASMModuleInstanceCommon *module_inst)
+{
+#if WASM_ENABLE_INTERP != 0
+ if (module_inst->module_type == Wasm_Module_Bytecode
+ && ((WASMModuleInstance *)module_inst)->module->import_wasi_api)
+ return true;
+#endif
+#if WASM_ENABLE_AOT != 0
+ if (module_inst->module_type == Wasm_Module_AoT
+ && ((AOTModule *)((AOTModuleInstance *)module_inst)->module)
+ ->import_wasi_api)
+ return true;
+#endif
+ return false;
+}
+
+WASMFunctionInstanceCommon *
+wasm_runtime_lookup_wasi_start_function(WASMModuleInstanceCommon *module_inst)
+{
+ uint32 i;
+
+#if WASM_ENABLE_INTERP != 0
+ if (module_inst->module_type == Wasm_Module_Bytecode) {
+ WASMModuleInstance *wasm_inst = (WASMModuleInstance *)module_inst;
+ WASMFunctionInstance *func;
+ for (i = 0; i < wasm_inst->export_func_count; i++) {
+ if (!strcmp(wasm_inst->export_functions[i].name, "_start")) {
+ func = wasm_inst->export_functions[i].function;
+ if (func->u.func->func_type->param_count != 0
+ || func->u.func->func_type->result_count != 0) {
+ LOG_ERROR("Lookup wasi _start function failed: "
+ "invalid function type.\n");
+ return NULL;
+ }
+ return (WASMFunctionInstanceCommon *)func;
+ }
+ }
+ return NULL;
+ }
+#endif
+
+#if WASM_ENABLE_AOT != 0
+ if (module_inst->module_type == Wasm_Module_AoT) {
+ AOTModuleInstance *aot_inst = (AOTModuleInstance *)module_inst;
+ AOTFunctionInstance *export_funcs =
+ (AOTFunctionInstance *)aot_inst->export_functions;
+ for (i = 0; i < aot_inst->export_func_count; i++) {
+ if (!strcmp(export_funcs[i].func_name, "_start")) {
+ AOTFuncType *func_type = export_funcs[i].u.func.func_type;
+ if (func_type->param_count != 0
+ || func_type->result_count != 0) {
+ LOG_ERROR("Lookup wasi _start function failed: "
+ "invalid function type.\n");
+ return NULL;
+ }
+ return (WASMFunctionInstanceCommon *)&export_funcs[i];
+ }
+ }
+ return NULL;
+ }
+#endif /* end of WASM_ENABLE_AOT */
+
+ return NULL;
+}
+
+#if WASM_ENABLE_UVWASI == 0
+void
+wasm_runtime_destroy_wasi(WASMModuleInstanceCommon *module_inst)
+{
+ WASIContext *wasi_ctx = wasm_runtime_get_wasi_ctx(module_inst);
+
+ if (wasi_ctx) {
+ if (wasi_ctx->argv_environ) {
+ argv_environ_destroy(wasi_ctx->argv_environ);
+ wasm_runtime_free(wasi_ctx->argv_environ);
+ }
+ if (wasi_ctx->curfds) {
+ fd_table_destroy(wasi_ctx->curfds);
+ wasm_runtime_free(wasi_ctx->curfds);
+ }
+ if (wasi_ctx->prestats) {
+ fd_prestats_destroy(wasi_ctx->prestats);
+ wasm_runtime_free(wasi_ctx->prestats);
+ }
+ if (wasi_ctx->addr_pool) {
+ addr_pool_destroy(wasi_ctx->addr_pool);
+ wasm_runtime_free(wasi_ctx->addr_pool);
+ }
+ if (wasi_ctx->argv_buf)
+ wasm_runtime_free(wasi_ctx->argv_buf);
+ if (wasi_ctx->argv_list)
+ wasm_runtime_free(wasi_ctx->argv_list);
+ if (wasi_ctx->env_buf)
+ wasm_runtime_free(wasi_ctx->env_buf);
+ if (wasi_ctx->env_list)
+ wasm_runtime_free(wasi_ctx->env_list);
+ if (wasi_ctx->ns_lookup_buf)
+ wasm_runtime_free(wasi_ctx->ns_lookup_buf);
+ if (wasi_ctx->ns_lookup_list)
+ wasm_runtime_free(wasi_ctx->ns_lookup_list);
+
+ wasm_runtime_free(wasi_ctx);
+ }
+}
+#else
+void
+wasm_runtime_destroy_wasi(WASMModuleInstanceCommon *module_inst)
+{
+ WASIContext *wasi_ctx = wasm_runtime_get_wasi_ctx(module_inst);
+
+ if (wasi_ctx) {
+ uvwasi_destroy(&wasi_ctx->uvwasi);
+ wasm_runtime_free(wasi_ctx);
+ }
+}
+#endif
+
+uint32_t
+wasm_runtime_get_wasi_exit_code(WASMModuleInstanceCommon *module_inst)
+{
+ WASIContext *wasi_ctx = wasm_runtime_get_wasi_ctx(module_inst);
+#if WASM_ENABLE_THREAD_MGR != 0
+ WASMCluster *cluster;
+ WASMExecEnv *exec_env;
+
+ exec_env = wasm_runtime_get_exec_env_singleton(module_inst);
+ if (exec_env && (cluster = wasm_exec_env_get_cluster(exec_env))) {
+ /**
+ * The main thread may exit earlier than other threads, and
+ * the exit_code of wasi_ctx may be changed by other thread
+ * when it runs into wasi_proc_exit, here we wait until all
+ * other threads exit to avoid getting invalid exit_code.
+ */
+ wasm_cluster_wait_for_all_except_self(cluster, exec_env);
+ }
+#endif
+ return wasi_ctx->exit_code;
+}
+
+WASIContext *
+wasm_runtime_get_wasi_ctx(WASMModuleInstanceCommon *module_inst_comm)
+{
+ WASMModuleInstance *module_inst = (WASMModuleInstance *)module_inst_comm;
+
+ bh_assert(module_inst_comm->module_type == Wasm_Module_Bytecode
+ || module_inst_comm->module_type == Wasm_Module_AoT);
+ return module_inst->wasi_ctx;
+}
+
+void
+wasm_runtime_set_wasi_ctx(WASMModuleInstanceCommon *module_inst_comm,
+ WASIContext *wasi_ctx)
+{
+ WASMModuleInstance *module_inst = (WASMModuleInstance *)module_inst_comm;
+
+ bh_assert(module_inst_comm->module_type == Wasm_Module_Bytecode
+ || module_inst_comm->module_type == Wasm_Module_AoT);
+ module_inst->wasi_ctx = wasi_ctx;
+}
+#endif /* end of WASM_ENABLE_LIBC_WASI */
+
+WASMModuleCommon *
+wasm_exec_env_get_module(WASMExecEnv *exec_env)
+{
+ WASMModuleInstanceCommon *module_inst_comm =
+ wasm_runtime_get_module_inst(exec_env);
+ WASMModuleInstance *module_inst = (WASMModuleInstance *)module_inst_comm;
+
+ bh_assert(module_inst_comm->module_type == Wasm_Module_Bytecode
+ || module_inst_comm->module_type == Wasm_Module_AoT);
+ return (WASMModuleCommon *)module_inst->module;
+}
+
+#if WASM_ENABLE_LOAD_CUSTOM_SECTION != 0
+const uint8 *
+wasm_runtime_get_custom_section(WASMModuleCommon *const module_comm,
+ const char *name, uint32 *len)
+{
+#if WASM_ENABLE_INTERP != 0
+ if (module_comm->module_type == Wasm_Module_Bytecode)
+ return wasm_loader_get_custom_section((WASMModule *)module_comm, name,
+ len);
+#endif
+#if WASM_ENABLE_AOT != 0
+ if (module_comm->module_type == Wasm_Module_AoT)
+ return aot_get_custom_section((AOTModule *)module_comm, name, len);
+#endif
+ return NULL;
+}
+#endif /* end of WASM_ENABLE_LOAD_CUSTOM_SECTION != 0 */
+
+static union {
+ int a;
+ char b;
+} __ue = { .a = 1 };
+
+#define is_little_endian() (__ue.b == 1)
+
+bool
+wasm_runtime_register_natives(const char *module_name,
+ NativeSymbol *native_symbols,
+ uint32 n_native_symbols)
+{
+ return wasm_native_register_natives(module_name, native_symbols,
+ n_native_symbols);
+}
+
+bool
+wasm_runtime_register_natives_raw(const char *module_name,
+ NativeSymbol *native_symbols,
+ uint32 n_native_symbols)
+{
+ return wasm_native_register_natives_raw(module_name, native_symbols,
+ n_native_symbols);
+}
+
+bool
+wasm_runtime_unregister_natives(const char *module_name,
+ NativeSymbol *native_symbols)
+{
+ return wasm_native_unregister_natives(module_name, native_symbols);
+}
+
+bool
+wasm_runtime_invoke_native_raw(WASMExecEnv *exec_env, void *func_ptr,
+ const WASMType *func_type, const char *signature,
+ void *attachment, uint32 *argv, uint32 argc,
+ uint32 *argv_ret)
+{
+ WASMModuleInstanceCommon *module = wasm_runtime_get_module_inst(exec_env);
+ typedef void (*NativeRawFuncPtr)(WASMExecEnv *, uint64 *);
+ NativeRawFuncPtr invokeNativeRaw = (NativeRawFuncPtr)func_ptr;
+ uint64 argv_buf[16] = { 0 }, *argv1 = argv_buf, *argv_dst, size;
+ uint32 *argv_src = argv, i, argc1, ptr_len;
+ uint32 arg_i32;
+ bool ret = false;
+
+ argc1 = func_type->param_count;
+ if (argc1 > sizeof(argv_buf) / sizeof(uint64)) {
+ size = sizeof(uint64) * (uint64)argc1;
+ if (!(argv1 = runtime_malloc((uint32)size, exec_env->module_inst, NULL,
+ 0))) {
+ return false;
+ }
+ }
+
+ argv_dst = argv1;
+
+ /* Traverse secondly to fill in each argument */
+ for (i = 0; i < func_type->param_count; i++, argv_dst++) {
+ switch (func_type->types[i]) {
+ case VALUE_TYPE_I32:
+#if WASM_ENABLE_REF_TYPES != 0
+ case VALUE_TYPE_FUNCREF:
+#endif
+ {
+ *(uint32 *)argv_dst = arg_i32 = *argv_src++;
+ if (signature) {
+ if (signature[i + 1] == '*') {
+ /* param is a pointer */
+ if (signature[i + 2] == '~')
+ /* pointer with length followed */
+ ptr_len = *argv_src;
+ else
+ /* pointer without length followed */
+ ptr_len = 1;
+
+ if (!wasm_runtime_validate_app_addr(module, arg_i32,
+ ptr_len))
+ goto fail;
+
+ *(uintptr_t *)argv_dst =
+ (uintptr_t)wasm_runtime_addr_app_to_native(module,
+ arg_i32);
+ }
+ else if (signature[i + 1] == '$') {
+ /* param is a string */
+ if (!wasm_runtime_validate_app_str_addr(module,
+ arg_i32))
+ goto fail;
+
+ *(uintptr_t *)argv_dst =
+ (uintptr_t)wasm_runtime_addr_app_to_native(module,
+ arg_i32);
+ }
+ }
+ break;
+ }
+ case VALUE_TYPE_I64:
+ case VALUE_TYPE_F64:
+ bh_memcpy_s(argv_dst, sizeof(uint64), argv_src,
+ sizeof(uint32) * 2);
+ argv_src += 2;
+ break;
+ case VALUE_TYPE_F32:
+ *(float32 *)argv_dst = *(float32 *)argv_src++;
+ break;
+#if WASM_ENABLE_REF_TYPES != 0
+ case VALUE_TYPE_EXTERNREF:
+ {
+ uint32 externref_idx = *argv_src++;
+
+ void *externref_obj;
+
+ if (!wasm_externref_ref2obj(externref_idx, &externref_obj))
+ goto fail;
+
+ bh_memcpy_s(argv_dst, sizeof(uintptr_t), argv_src,
+ sizeof(uintptr_t));
+ break;
+ }
+#endif
+ default:
+ bh_assert(0);
+ break;
+ }
+ }
+
+ exec_env->attachment = attachment;
+ invokeNativeRaw(exec_env, argv1);
+ exec_env->attachment = NULL;
+
+ if (func_type->result_count > 0) {
+ switch (func_type->types[func_type->param_count]) {
+ case VALUE_TYPE_I32:
+#if WASM_ENABLE_REF_TYPES != 0
+ case VALUE_TYPE_FUNCREF:
+#endif
+ argv_ret[0] = *(uint32 *)argv1;
+ break;
+ case VALUE_TYPE_F32:
+ *(float32 *)argv_ret = *(float32 *)argv1;
+ break;
+ case VALUE_TYPE_I64:
+ case VALUE_TYPE_F64:
+ bh_memcpy_s(argv_ret, sizeof(uint32) * 2, argv1,
+ sizeof(uint64));
+ break;
+#if WASM_ENABLE_REF_TYPES != 0
+ case VALUE_TYPE_EXTERNREF:
+ {
+ uint32 externref_idx;
+ uint64 externref_obj;
+
+ bh_memcpy_s(&externref_obj, sizeof(uint64), argv1,
+ sizeof(uint64));
+
+ if (!wasm_externref_obj2ref(exec_env->module_inst,
+ (void *)(uintptr_t)externref_obj,
+ &externref_idx))
+ goto fail;
+ argv_ret[0] = externref_idx;
+ break;
+ }
+#endif
+ default:
+ bh_assert(0);
+ break;
+ }
+ }
+
+ ret = !wasm_runtime_copy_exception(module, NULL);
+
+fail:
+ if (argv1 != argv_buf)
+ wasm_runtime_free(argv1);
+ return ret;
+}
+
+/**
+ * Implementation of wasm_runtime_invoke_native()
+ */
+
+/* The invoke native implementation on ARM platform with VFP co-processor */
+#if defined(BUILD_TARGET_ARM_VFP) || defined(BUILD_TARGET_THUMB_VFP) \
+ || defined(BUILD_TARGET_RISCV32_ILP32D) \
+ || defined(BUILD_TARGET_RISCV32_ILP32) || defined(BUILD_TARGET_ARC)
+typedef void (*GenericFunctionPointer)();
+void
+invokeNative(GenericFunctionPointer f, uint32 *args, uint32 n_stacks);
+
+typedef float64 (*Float64FuncPtr)(GenericFunctionPointer, uint32 *, uint32);
+typedef float32 (*Float32FuncPtr)(GenericFunctionPointer, uint32 *, uint32);
+typedef int64 (*Int64FuncPtr)(GenericFunctionPointer, uint32 *, uint32);
+typedef int32 (*Int32FuncPtr)(GenericFunctionPointer, uint32 *, uint32);
+typedef void (*VoidFuncPtr)(GenericFunctionPointer, uint32 *, uint32);
+
+static volatile Float64FuncPtr invokeNative_Float64 =
+ (Float64FuncPtr)(uintptr_t)invokeNative;
+static volatile Float32FuncPtr invokeNative_Float32 =
+ (Float32FuncPtr)(uintptr_t)invokeNative;
+static volatile Int64FuncPtr invokeNative_Int64 =
+ (Int64FuncPtr)(uintptr_t)invokeNative;
+static volatile Int32FuncPtr invokeNative_Int32 =
+ (Int32FuncPtr)(uintptr_t)invokeNative;
+static volatile VoidFuncPtr invokeNative_Void =
+ (VoidFuncPtr)(uintptr_t)invokeNative;
+
+#if defined(BUILD_TARGET_ARM_VFP) || defined(BUILD_TARGET_THUMB_VFP)
+#define MAX_REG_INTS 4
+#define MAX_REG_FLOATS 16
+#else
+#define MAX_REG_INTS 8
+#define MAX_REG_FLOATS 8
+#endif
+
+bool
+wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr,
+ const WASMType *func_type, const char *signature,
+ void *attachment, uint32 *argv, uint32 argc,
+ uint32 *argv_ret)
+{
+ WASMModuleInstanceCommon *module = wasm_runtime_get_module_inst(exec_env);
+ /* argv buf layout: int args(fix cnt) + float args(fix cnt) + stack args
+ */
+ uint32 argv_buf[32], *argv1 = argv_buf, *ints, *stacks, size;
+ uint32 *argv_src = argv, i, argc1, n_ints = 0, n_stacks = 0;
+ uint32 arg_i32, ptr_len;
+ uint32 result_count = func_type->result_count;
+ uint32 ext_ret_count = result_count > 1 ? result_count - 1 : 0;
+ bool ret = false;
+#if WASM_ENABLE_REF_TYPES != 0
+ bool is_aot_func = (NULL == signature);
+#endif
+#if !defined(BUILD_TARGET_RISCV32_ILP32) && !defined(BUILD_TARGET_ARC)
+ uint32 *fps;
+ int n_fps = 0;
+#else
+#define fps ints
+#define n_fps n_ints
+#endif
+
+ n_ints++; /* exec env */
+
+ /* Traverse firstly to calculate stack args count */
+ for (i = 0; i < func_type->param_count; i++) {
+ switch (func_type->types[i]) {
+ case VALUE_TYPE_I32:
+#if WASM_ENABLE_REF_TYPES != 0
+ case VALUE_TYPE_FUNCREF:
+ case VALUE_TYPE_EXTERNREF:
+#endif
+ if (n_ints < MAX_REG_INTS)
+ n_ints++;
+ else
+ n_stacks++;
+ break;
+ case VALUE_TYPE_I64:
+ if (n_ints < MAX_REG_INTS - 1) {
+#if defined(BUILD_TARGET_ARM_VFP) || defined(BUILD_TARGET_THUMB_VFP)
+ /* 64-bit data must be 8 bytes aligned in arm */
+ if (n_ints & 1)
+ n_ints++;
+#endif
+ n_ints += 2;
+ }
+#if defined(BUILD_TARGET_RISCV32_ILP32) \
+ || defined(BUILD_TARGET_RISCV32_ILP32D) || defined(BUILD_TARGET_ARC)
+ /* part in register, part in stack */
+ else if (n_ints == MAX_REG_INTS - 1) {
+ n_ints++;
+ n_stacks++;
+ }
+#endif
+ else {
+ /* 64-bit data in stack must be 8 bytes aligned
+ in arm and riscv32 */
+#if !defined(BUILD_TARGET_ARC)
+ if (n_stacks & 1)
+ n_stacks++;
+#endif
+ n_stacks += 2;
+ }
+ break;
+#if !defined(BUILD_TARGET_RISCV32_ILP32D)
+ case VALUE_TYPE_F32:
+ if (n_fps < MAX_REG_FLOATS)
+ n_fps++;
+ else
+ n_stacks++;
+ break;
+ case VALUE_TYPE_F64:
+ if (n_fps < MAX_REG_FLOATS - 1) {
+#if !defined(BUILD_TARGET_RISCV32_ILP32) && !defined(BUILD_TARGET_ARC)
+ /* 64-bit data must be 8 bytes aligned in arm */
+ if (n_fps & 1)
+ n_fps++;
+#endif
+ n_fps += 2;
+ }
+#if defined(BUILD_TARGET_RISCV32_ILP32) || defined(BUILD_TARGET_ARC)
+ else if (n_fps == MAX_REG_FLOATS - 1) {
+ n_fps++;
+ n_stacks++;
+ }
+#endif
+ else {
+ /* 64-bit data in stack must be 8 bytes aligned
+ in arm and riscv32 */
+#if !defined(BUILD_TARGET_ARC)
+ if (n_stacks & 1)
+ n_stacks++;
+#endif
+ n_stacks += 2;
+ }
+ break;
+#else /* BUILD_TARGET_RISCV32_ILP32D */
+ case VALUE_TYPE_F32:
+ case VALUE_TYPE_F64:
+ if (n_fps < MAX_REG_FLOATS) {
+ n_fps++;
+ }
+ else if (func_type->types[i] == VALUE_TYPE_F32
+ && n_ints < MAX_REG_INTS) {
+ /* use int reg firstly if available */
+ n_ints++;
+ }
+ else if (func_type->types[i] == VALUE_TYPE_F64
+ && n_ints < MAX_REG_INTS - 1) {
+ /* use int regs firstly if available */
+ if (n_ints & 1)
+ n_ints++;
+ ints += 2;
+ }
+ else {
+ /* 64-bit data in stack must be 8 bytes aligned in riscv32
+ */
+ if (n_stacks & 1)
+ n_stacks++;
+ n_stacks += 2;
+ }
+ break;
+#endif /* BUILD_TARGET_RISCV32_ILP32D */
+ default:
+ bh_assert(0);
+ break;
+ }
+ }
+
+ for (i = 0; i < ext_ret_count; i++) {
+ if (n_ints < MAX_REG_INTS)
+ n_ints++;
+ else
+ n_stacks++;
+ }
+
+#if defined(BUILD_TARGET_ARM_VFP) || defined(BUILD_TARGET_THUMB_VFP)
+ argc1 = MAX_REG_INTS + MAX_REG_FLOATS + n_stacks;
+#elif defined(BUILD_TARGET_RISCV32_ILP32) || defined(BUILD_TARGET_ARC)
+ argc1 = MAX_REG_INTS + n_stacks;
+#else /* for BUILD_TARGET_RISCV32_ILP32D */
+ argc1 = MAX_REG_INTS + MAX_REG_FLOATS * 2 + n_stacks;
+#endif
+
+ if (argc1 > sizeof(argv_buf) / sizeof(uint32)) {
+ size = sizeof(uint32) * (uint32)argc1;
+ if (!(argv1 = runtime_malloc((uint32)size, exec_env->module_inst, NULL,
+ 0))) {
+ return false;
+ }
+ }
+
+ ints = argv1;
+#if defined(BUILD_TARGET_ARM_VFP) || defined(BUILD_TARGET_THUMB_VFP)
+ fps = ints + MAX_REG_INTS;
+ stacks = fps + MAX_REG_FLOATS;
+#elif defined(BUILD_TARGET_RISCV32_ILP32) || defined(BUILD_TARGET_ARC)
+ stacks = ints + MAX_REG_INTS;
+#else /* for BUILD_TARGET_RISCV32_ILP32D */
+ fps = ints + MAX_REG_INTS;
+ stacks = fps + MAX_REG_FLOATS * 2;
+#endif
+
+ n_ints = 0;
+ n_fps = 0;
+ n_stacks = 0;
+ ints[n_ints++] = (uint32)(uintptr_t)exec_env;
+
+ /* Traverse secondly to fill in each argument */
+ for (i = 0; i < func_type->param_count; i++) {
+ switch (func_type->types[i]) {
+ case VALUE_TYPE_I32:
+#if WASM_ENABLE_REF_TYPES != 0
+ case VALUE_TYPE_FUNCREF:
+#endif
+ {
+ arg_i32 = *argv_src++;
+
+ if (signature) {
+ if (signature[i + 1] == '*') {
+ /* param is a pointer */
+ if (signature[i + 2] == '~')
+ /* pointer with length followed */
+ ptr_len = *argv_src;
+ else
+ /* pointer without length followed */
+ ptr_len = 1;
+
+ if (!wasm_runtime_validate_app_addr(module, arg_i32,
+ ptr_len))
+ goto fail;
+
+ arg_i32 = (uintptr_t)wasm_runtime_addr_app_to_native(
+ module, arg_i32);
+ }
+ else if (signature[i + 1] == '$') {
+ /* param is a string */
+ if (!wasm_runtime_validate_app_str_addr(module,
+ arg_i32))
+ goto fail;
+
+ arg_i32 = (uintptr_t)wasm_runtime_addr_app_to_native(
+ module, arg_i32);
+ }
+ }
+
+ if (n_ints < MAX_REG_INTS)
+ ints[n_ints++] = arg_i32;
+ else
+ stacks[n_stacks++] = arg_i32;
+ break;
+ }
+ case VALUE_TYPE_I64:
+ {
+ if (n_ints < MAX_REG_INTS - 1) {
+#if defined(BUILD_TARGET_ARM_VFP) || defined(BUILD_TARGET_THUMB_VFP)
+ /* 64-bit data must be 8 bytes aligned in arm */
+ if (n_ints & 1)
+ n_ints++;
+#endif
+ ints[n_ints++] = *argv_src++;
+ ints[n_ints++] = *argv_src++;
+ }
+#if defined(BUILD_TARGET_RISCV32_ILP32) \
+ || defined(BUILD_TARGET_RISCV32_ILP32D) || defined(BUILD_TARGET_ARC)
+ else if (n_ints == MAX_REG_INTS - 1) {
+ ints[n_ints++] = *argv_src++;
+ stacks[n_stacks++] = *argv_src++;
+ }
+#endif
+ else {
+ /* 64-bit data in stack must be 8 bytes aligned
+ in arm and riscv32 */
+#if !defined(BUILD_TARGET_ARC)
+ if (n_stacks & 1)
+ n_stacks++;
+#endif
+ stacks[n_stacks++] = *argv_src++;
+ stacks[n_stacks++] = *argv_src++;
+ }
+ break;
+ }
+#if !defined(BUILD_TARGET_RISCV32_ILP32D)
+ case VALUE_TYPE_F32:
+ {
+ if (n_fps < MAX_REG_FLOATS)
+ *(float32 *)&fps[n_fps++] = *(float32 *)argv_src++;
+ else
+ *(float32 *)&stacks[n_stacks++] = *(float32 *)argv_src++;
+ break;
+ }
+ case VALUE_TYPE_F64:
+ {
+ if (n_fps < MAX_REG_FLOATS - 1) {
+#if !defined(BUILD_TARGET_RISCV32_ILP32) && !defined(BUILD_TARGET_ARC)
+ /* 64-bit data must be 8 bytes aligned in arm */
+ if (n_fps & 1)
+ n_fps++;
+#endif
+ fps[n_fps++] = *argv_src++;
+ fps[n_fps++] = *argv_src++;
+ }
+#if defined(BUILD_TARGET_RISCV32_ILP32) || defined(BUILD_TARGET_ARC)
+ else if (n_fps == MAX_REG_FLOATS - 1) {
+ fps[n_fps++] = *argv_src++;
+ stacks[n_stacks++] = *argv_src++;
+ }
+#endif
+ else {
+ /* 64-bit data in stack must be 8 bytes aligned
+ in arm and riscv32 */
+#if !defined(BUILD_TARGET_ARC)
+ if (n_stacks & 1)
+ n_stacks++;
+#endif
+ stacks[n_stacks++] = *argv_src++;
+ stacks[n_stacks++] = *argv_src++;
+ }
+ break;
+ }
+#else /* BUILD_TARGET_RISCV32_ILP32D */
+ case VALUE_TYPE_F32:
+ case VALUE_TYPE_F64:
+ {
+ if (n_fps < MAX_REG_FLOATS) {
+ if (func_type->types[i] == VALUE_TYPE_F32) {
+ *(float32 *)&fps[n_fps * 2] = *(float32 *)argv_src++;
+ /* NaN boxing, the upper bits of a valid NaN-boxed
+ value must be all 1s. */
+ fps[n_fps * 2 + 1] = 0xFFFFFFFF;
+ }
+ else {
+ *(float64 *)&fps[n_fps * 2] = *(float64 *)argv_src;
+ argv_src += 2;
+ }
+ n_fps++;
+ }
+ else if (func_type->types[i] == VALUE_TYPE_F32
+ && n_ints < MAX_REG_INTS) {
+ /* use int reg firstly if available */
+ *(float32 *)&ints[n_ints++] = *(float32 *)argv_src++;
+ }
+ else if (func_type->types[i] == VALUE_TYPE_F64
+ && n_ints < MAX_REG_INTS - 1) {
+ /* use int regs firstly if available */
+ if (n_ints & 1)
+ n_ints++;
+ *(float64 *)&ints[n_ints] = *(float64 *)argv_src;
+ n_ints += 2;
+ argv_src += 2;
+ }
+ else {
+ /* 64-bit data in stack must be 8 bytes aligned in riscv32
+ */
+ if (n_stacks & 1)
+ n_stacks++;
+ if (func_type->types[i] == VALUE_TYPE_F32) {
+ *(float32 *)&stacks[n_stacks] = *(float32 *)argv_src++;
+ /* NaN boxing, the upper bits of a valid NaN-boxed
+ value must be all 1s. */
+ stacks[n_stacks + 1] = 0xFFFFFFFF;
+ }
+ else {
+ *(float64 *)&stacks[n_stacks] = *(float64 *)argv_src;
+ argv_src += 2;
+ }
+ n_stacks += 2;
+ }
+ break;
+ }
+#endif /* BUILD_TARGET_RISCV32_ILP32D */
+#if WASM_ENABLE_REF_TYPES != 0
+ case VALUE_TYPE_EXTERNREF:
+ {
+ uint32 externref_idx = *argv_src++;
+
+ if (is_aot_func) {
+ if (n_ints < MAX_REG_INTS)
+ ints[n_ints++] = externref_idx;
+ else
+ stacks[n_stacks++] = externref_idx;
+ }
+ else {
+ void *externref_obj;
+
+ if (!wasm_externref_ref2obj(externref_idx, &externref_obj))
+ goto fail;
+
+ if (n_ints < MAX_REG_INTS)
+ ints[n_ints++] = (uintptr_t)externref_obj;
+ else
+ stacks[n_stacks++] = (uintptr_t)externref_obj;
+ }
+ break;
+ }
+#endif
+ default:
+ bh_assert(0);
+ break;
+ }
+ }
+
+ /* Save extra result values' address to argv1 */
+ for (i = 0; i < ext_ret_count; i++) {
+ if (n_ints < MAX_REG_INTS)
+ ints[n_ints++] = *(uint32 *)argv_src++;
+ else
+ stacks[n_stacks++] = *(uint32 *)argv_src++;
+ }
+
+ exec_env->attachment = attachment;
+ if (func_type->result_count == 0) {
+ invokeNative_Void(func_ptr, argv1, n_stacks);
+ }
+ else {
+ switch (func_type->types[func_type->param_count]) {
+ case VALUE_TYPE_I32:
+#if WASM_ENABLE_REF_TYPES != 0
+ case VALUE_TYPE_FUNCREF:
+#endif
+ argv_ret[0] =
+ (uint32)invokeNative_Int32(func_ptr, argv1, n_stacks);
+ break;
+ case VALUE_TYPE_I64:
+ PUT_I64_TO_ADDR(argv_ret,
+ invokeNative_Int64(func_ptr, argv1, n_stacks));
+ break;
+ case VALUE_TYPE_F32:
+ *(float32 *)argv_ret =
+ invokeNative_Float32(func_ptr, argv1, n_stacks);
+ break;
+ case VALUE_TYPE_F64:
+ PUT_F64_TO_ADDR(
+ argv_ret, invokeNative_Float64(func_ptr, argv1, n_stacks));
+ break;
+#if WASM_ENABLE_REF_TYPES != 0
+ case VALUE_TYPE_EXTERNREF:
+ {
+ if (is_aot_func) {
+ uint32 externref_idx =
+ (uint32)invokeNative_Int32(func_ptr, argv1, argc1);
+ argv_ret[0] = externref_idx;
+ }
+ else {
+ uint32 externref_idx;
+ void *externref_obj;
+
+ externref_obj = (void *)(uintptr_t)invokeNative_Int32(
+ func_ptr, argv1, argc1);
+
+ if (!wasm_externref_obj2ref(exec_env->module_inst,
+ externref_obj, &externref_idx))
+ goto fail;
+
+ argv_ret[0] = externref_idx;
+ }
+ break;
+ }
+#endif
+ default:
+ bh_assert(0);
+ break;
+ }
+ }
+ exec_env->attachment = NULL;
+
+ ret = !wasm_runtime_copy_exception(module, NULL);
+
+fail:
+ if (argv1 != argv_buf)
+ wasm_runtime_free(argv1);
+ return ret;
+}
+#endif /* end of defined(BUILD_TARGET_ARM_VFP) \
+ || defined(BUILD_TARGET_THUMB_VFP) \
+ || defined(BUILD_TARGET_RISCV32_ILP32D) \
+ || defined(BUILD_TARGET_RISCV32_ILP32) \
+ || defined(BUILD_TARGET_ARC) */
+
+#if defined(BUILD_TARGET_X86_32) || defined(BUILD_TARGET_ARM) \
+ || defined(BUILD_TARGET_THUMB) || defined(BUILD_TARGET_MIPS) \
+ || defined(BUILD_TARGET_XTENSA)
+typedef void (*GenericFunctionPointer)();
+void
+invokeNative(GenericFunctionPointer f, uint32 *args, uint32 sz);
+
+typedef float64 (*Float64FuncPtr)(GenericFunctionPointer f, uint32 *, uint32);
+typedef float32 (*Float32FuncPtr)(GenericFunctionPointer f, uint32 *, uint32);
+typedef int64 (*Int64FuncPtr)(GenericFunctionPointer f, uint32 *, uint32);
+typedef int32 (*Int32FuncPtr)(GenericFunctionPointer f, uint32 *, uint32);
+typedef void (*VoidFuncPtr)(GenericFunctionPointer f, uint32 *, uint32);
+
+static volatile Int64FuncPtr invokeNative_Int64 =
+ (Int64FuncPtr)(uintptr_t)invokeNative;
+static volatile Int32FuncPtr invokeNative_Int32 =
+ (Int32FuncPtr)(uintptr_t)invokeNative;
+static volatile Float64FuncPtr invokeNative_Float64 =
+ (Float64FuncPtr)(uintptr_t)invokeNative;
+static volatile Float32FuncPtr invokeNative_Float32 =
+ (Float32FuncPtr)(uintptr_t)invokeNative;
+static volatile VoidFuncPtr invokeNative_Void =
+ (VoidFuncPtr)(uintptr_t)invokeNative;
+
+static inline void
+word_copy(uint32 *dest, uint32 *src, unsigned num)
+{
+ for (; num > 0; num--)
+ *dest++ = *src++;
+}
+
+bool
+wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr,
+ const WASMType *func_type, const char *signature,
+ void *attachment, uint32 *argv, uint32 argc,
+ uint32 *argv_ret)
+{
+ WASMModuleInstanceCommon *module = wasm_runtime_get_module_inst(exec_env);
+ uint32 argv_buf[32], *argv1 = argv_buf, argc1, i, j = 0;
+ uint32 arg_i32, ptr_len;
+ uint32 result_count = func_type->result_count;
+ uint32 ext_ret_count = result_count > 1 ? result_count - 1 : 0;
+ uint64 size;
+ bool ret = false;
+#if WASM_ENABLE_REF_TYPES != 0
+ bool is_aot_func = (NULL == signature);
+#endif
+
+#if defined(BUILD_TARGET_X86_32)
+ argc1 = argc + ext_ret_count + 2;
+#else
+ /* arm/thumb/mips/xtensa, 64-bit data must be 8 bytes aligned,
+ so we need to allocate more memory. */
+ argc1 = func_type->param_count * 2 + ext_ret_count + 2;
+#endif
+
+ if (argc1 > sizeof(argv_buf) / sizeof(uint32)) {
+ size = sizeof(uint32) * (uint64)argc1;
+ if (!(argv1 = runtime_malloc((uint32)size, exec_env->module_inst, NULL,
+ 0))) {
+ return false;
+ }
+ }
+
+ for (i = 0; i < sizeof(WASMExecEnv *) / sizeof(uint32); i++)
+ argv1[j++] = ((uint32 *)&exec_env)[i];
+
+ for (i = 0; i < func_type->param_count; i++) {
+ switch (func_type->types[i]) {
+ case VALUE_TYPE_I32:
+#if WASM_ENABLE_REF_TYPES != 0
+ case VALUE_TYPE_FUNCREF:
+#endif
+ {
+ arg_i32 = *argv++;
+
+ if (signature) {
+ if (signature[i + 1] == '*') {
+ /* param is a pointer */
+ if (signature[i + 2] == '~')
+ /* pointer with length followed */
+ ptr_len = *argv;
+ else
+ /* pointer without length followed */
+ ptr_len = 1;
+
+ if (!wasm_runtime_validate_app_addr(module, arg_i32,
+ ptr_len))
+ goto fail;
+
+ arg_i32 = (uintptr_t)wasm_runtime_addr_app_to_native(
+ module, arg_i32);
+ }
+ else if (signature[i + 1] == '$') {
+ /* param is a string */
+ if (!wasm_runtime_validate_app_str_addr(module,
+ arg_i32))
+ goto fail;
+
+ arg_i32 = (uintptr_t)wasm_runtime_addr_app_to_native(
+ module, arg_i32);
+ }
+ }
+
+ argv1[j++] = arg_i32;
+ break;
+ }
+ case VALUE_TYPE_I64:
+ case VALUE_TYPE_F64:
+#if !defined(BUILD_TARGET_X86_32)
+ /* 64-bit data must be 8 bytes aligned in arm, thumb, mips
+ and xtensa */
+ if (j & 1)
+ j++;
+#endif
+ argv1[j++] = *argv++;
+ argv1[j++] = *argv++;
+ break;
+ case VALUE_TYPE_F32:
+ argv1[j++] = *argv++;
+ break;
+#if WASM_ENABLE_REF_TYPES != 0
+ case VALUE_TYPE_EXTERNREF:
+ {
+ uint32 externref_idx = *argv++;
+ if (is_aot_func) {
+ argv1[j++] = externref_idx;
+ }
+ else {
+ void *externref_obj;
+
+ if (!wasm_externref_ref2obj(externref_idx, &externref_obj))
+ goto fail;
+
+ argv1[j++] = (uintptr_t)externref_obj;
+ }
+ break;
+ }
+#endif
+ default:
+ bh_assert(0);
+ break;
+ }
+ }
+
+ /* Save extra result values' address to argv1 */
+ word_copy(argv1 + j, argv, ext_ret_count);
+
+ argc1 = j + ext_ret_count;
+ exec_env->attachment = attachment;
+ if (func_type->result_count == 0) {
+ invokeNative_Void(func_ptr, argv1, argc1);
+ }
+ else {
+ switch (func_type->types[func_type->param_count]) {
+ case VALUE_TYPE_I32:
+#if WASM_ENABLE_REF_TYPES != 0
+ case VALUE_TYPE_FUNCREF:
+#endif
+ argv_ret[0] =
+ (uint32)invokeNative_Int32(func_ptr, argv1, argc1);
+ break;
+ case VALUE_TYPE_I64:
+ PUT_I64_TO_ADDR(argv_ret,
+ invokeNative_Int64(func_ptr, argv1, argc1));
+ break;
+ case VALUE_TYPE_F32:
+ *(float32 *)argv_ret =
+ invokeNative_Float32(func_ptr, argv1, argc1);
+ break;
+ case VALUE_TYPE_F64:
+ PUT_F64_TO_ADDR(argv_ret,
+ invokeNative_Float64(func_ptr, argv1, argc1));
+ break;
+#if WASM_ENABLE_REF_TYPES != 0
+ case VALUE_TYPE_EXTERNREF:
+ {
+ if (is_aot_func) {
+ uint32 externref_idx =
+ (uint32)invokeNative_Int32(func_ptr, argv1, argc1);
+ argv_ret[0] = externref_idx;
+ }
+ else {
+ void *externref_obj = (void *)(uintptr_t)invokeNative_Int32(
+ func_ptr, argv1, argc1);
+ uint32 externref_idx;
+ if (!wasm_externref_obj2ref(exec_env->module_inst,
+ externref_obj, &externref_idx))
+ goto fail;
+ argv_ret[0] = externref_idx;
+ }
+ break;
+ }
+#endif
+ default:
+ bh_assert(0);
+ break;
+ }
+ }
+ exec_env->attachment = NULL;
+
+ ret = !wasm_runtime_copy_exception(module, NULL);
+
+fail:
+ if (argv1 != argv_buf)
+ wasm_runtime_free(argv1);
+ return ret;
+}
+
+#endif /* end of defined(BUILD_TARGET_X86_32) \
+ || defined(BUILD_TARGET_ARM) \
+ || defined(BUILD_TARGET_THUMB) \
+ || defined(BUILD_TARGET_MIPS) \
+ || defined(BUILD_TARGET_XTENSA) */
+
+#if defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64) \
+ || defined(BUILD_TARGET_AARCH64) || defined(BUILD_TARGET_RISCV64_LP64D) \
+ || defined(BUILD_TARGET_RISCV64_LP64)
+
+#if WASM_ENABLE_SIMD != 0
+#ifdef v128
+#undef v128
+#endif
+
+#if defined(_WIN32) || defined(_WIN32_)
+typedef union __declspec(intrin_type) __declspec(align(8)) v128 {
+ __int8 m128i_i8[16];
+ __int16 m128i_i16[8];
+ __int32 m128i_i32[4];
+ __int64 m128i_i64[2];
+ unsigned __int8 m128i_u8[16];
+ unsigned __int16 m128i_u16[8];
+ unsigned __int32 m128i_u32[4];
+ unsigned __int64 m128i_u64[2];
+} v128;
+#elif defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64) \
+ || defined(BUILD_TARGET_RISCV64_LP64D) \
+ || defined(BUILD_TARGET_RISCV64_LP64)
+typedef long long v128
+ __attribute__((__vector_size__(16), __may_alias__, __aligned__(1)));
+#elif defined(BUILD_TARGET_AARCH64)
+#include <arm_neon.h>
+typedef uint32x4_t __m128i;
+#define v128 __m128i
+#endif
+
+#endif /* end of WASM_ENABLE_SIMD != 0 */
+
+typedef void (*GenericFunctionPointer)();
+void
+invokeNative(GenericFunctionPointer f, uint64 *args, uint64 n_stacks);
+
+typedef float64 (*Float64FuncPtr)(GenericFunctionPointer, uint64 *, uint64);
+typedef float32 (*Float32FuncPtr)(GenericFunctionPointer, uint64 *, uint64);
+typedef int64 (*Int64FuncPtr)(GenericFunctionPointer, uint64 *, uint64);
+typedef int32 (*Int32FuncPtr)(GenericFunctionPointer, uint64 *, uint64);
+typedef void (*VoidFuncPtr)(GenericFunctionPointer, uint64 *, uint64);
+
+static volatile Float64FuncPtr invokeNative_Float64 =
+ (Float64FuncPtr)(uintptr_t)invokeNative;
+static volatile Float32FuncPtr invokeNative_Float32 =
+ (Float32FuncPtr)(uintptr_t)invokeNative;
+static volatile Int64FuncPtr invokeNative_Int64 =
+ (Int64FuncPtr)(uintptr_t)invokeNative;
+static volatile Int32FuncPtr invokeNative_Int32 =
+ (Int32FuncPtr)(uintptr_t)invokeNative;
+static volatile VoidFuncPtr invokeNative_Void =
+ (VoidFuncPtr)(uintptr_t)invokeNative;
+
+#if WASM_ENABLE_SIMD != 0
+typedef v128 (*V128FuncPtr)(GenericFunctionPointer, uint64 *, uint64);
+static V128FuncPtr invokeNative_V128 = (V128FuncPtr)(uintptr_t)invokeNative;
+#endif
+
+#if defined(_WIN32) || defined(_WIN32_)
+#define MAX_REG_FLOATS 4
+#define MAX_REG_INTS 4
+#else /* else of defined(_WIN32) || defined(_WIN32_) */
+#define MAX_REG_FLOATS 8
+#if defined(BUILD_TARGET_AARCH64) || defined(BUILD_TARGET_RISCV64_LP64D) \
+ || defined(BUILD_TARGET_RISCV64_LP64)
+#define MAX_REG_INTS 8
+#else
+#define MAX_REG_INTS 6
+#endif /* end of defined(BUILD_TARGET_AARCH64) \
+ || defined(BUILD_TARGET_RISCV64_LP64D) \
+ || defined(BUILD_TARGET_RISCV64_LP64) */
+#endif /* end of defined(_WIN32) || defined(_WIN32_) */
+
+bool
+wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr,
+ const WASMType *func_type, const char *signature,
+ void *attachment, uint32 *argv, uint32 argc,
+ uint32 *argv_ret)
+{
+ WASMModuleInstanceCommon *module = wasm_runtime_get_module_inst(exec_env);
+ uint64 argv_buf[32] = { 0 }, *argv1 = argv_buf, *ints, *stacks, size,
+ arg_i64;
+ uint32 *argv_src = argv, i, argc1, n_ints = 0, n_stacks = 0;
+ uint32 arg_i32, ptr_len;
+ uint32 result_count = func_type->result_count;
+ uint32 ext_ret_count = result_count > 1 ? result_count - 1 : 0;
+ bool ret = false;
+#if WASM_ENABLE_REF_TYPES != 0
+ bool is_aot_func = (NULL == signature);
+#endif
+#ifndef BUILD_TARGET_RISCV64_LP64
+#if WASM_ENABLE_SIMD == 0
+ uint64 *fps;
+#else
+ v128 *fps;
+#endif
+#else /* else of BUILD_TARGET_RISCV64_LP64 */
+#define fps ints
+#endif /* end of BUILD_TARGET_RISCV64_LP64 */
+
+#if defined(_WIN32) || defined(_WIN32_) || defined(BUILD_TARGET_RISCV64_LP64)
+ /* important difference in calling conventions */
+#define n_fps n_ints
+#else
+ int n_fps = 0;
+#endif
+
+#if WASM_ENABLE_SIMD == 0
+ argc1 = 1 + MAX_REG_FLOATS + (uint32)func_type->param_count + ext_ret_count;
+#else
+ argc1 = 1 + MAX_REG_FLOATS * 2 + (uint32)func_type->param_count * 2
+ + ext_ret_count;
+#endif
+ if (argc1 > sizeof(argv_buf) / sizeof(uint64)) {
+ size = sizeof(uint64) * (uint64)argc1;
+ if (!(argv1 = runtime_malloc((uint32)size, exec_env->module_inst, NULL,
+ 0))) {
+ return false;
+ }
+ }
+
+#ifndef BUILD_TARGET_RISCV64_LP64
+#if WASM_ENABLE_SIMD == 0
+ fps = argv1;
+ ints = fps + MAX_REG_FLOATS;
+#else
+ fps = (v128 *)argv1;
+ ints = (uint64 *)(fps + MAX_REG_FLOATS);
+#endif
+#else /* else of BUILD_TARGET_RISCV64_LP64 */
+ ints = argv1;
+#endif /* end of BUILD_TARGET_RISCV64_LP64 */
+ stacks = ints + MAX_REG_INTS;
+
+ ints[n_ints++] = (uint64)(uintptr_t)exec_env;
+
+ for (i = 0; i < func_type->param_count; i++) {
+ switch (func_type->types[i]) {
+ case VALUE_TYPE_I32:
+#if WASM_ENABLE_REF_TYPES != 0
+ case VALUE_TYPE_FUNCREF:
+#endif
+ {
+ arg_i32 = *argv_src++;
+ arg_i64 = arg_i32;
+ if (signature) {
+ if (signature[i + 1] == '*') {
+ /* param is a pointer */
+ if (signature[i + 2] == '~')
+ /* pointer with length followed */
+ ptr_len = *argv_src;
+ else
+ /* pointer without length followed */
+ ptr_len = 1;
+
+ if (!wasm_runtime_validate_app_addr(module, arg_i32,
+ ptr_len))
+ goto fail;
+
+ arg_i64 = (uintptr_t)wasm_runtime_addr_app_to_native(
+ module, arg_i32);
+ }
+ else if (signature[i + 1] == '$') {
+ /* param is a string */
+ if (!wasm_runtime_validate_app_str_addr(module,
+ arg_i32))
+ goto fail;
+
+ arg_i64 = (uintptr_t)wasm_runtime_addr_app_to_native(
+ module, arg_i32);
+ }
+ }
+ if (n_ints < MAX_REG_INTS)
+ ints[n_ints++] = arg_i64;
+ else
+ stacks[n_stacks++] = arg_i64;
+ break;
+ }
+ case VALUE_TYPE_I64:
+ if (n_ints < MAX_REG_INTS)
+ ints[n_ints++] = *(uint64 *)argv_src;
+ else
+ stacks[n_stacks++] = *(uint64 *)argv_src;
+ argv_src += 2;
+ break;
+ case VALUE_TYPE_F32:
+ if (n_fps < MAX_REG_FLOATS) {
+ *(float32 *)&fps[n_fps++] = *(float32 *)argv_src++;
+ }
+ else {
+ *(float32 *)&stacks[n_stacks++] = *(float32 *)argv_src++;
+ }
+ break;
+ case VALUE_TYPE_F64:
+ if (n_fps < MAX_REG_FLOATS) {
+ *(float64 *)&fps[n_fps++] = *(float64 *)argv_src;
+ }
+ else {
+ *(float64 *)&stacks[n_stacks++] = *(float64 *)argv_src;
+ }
+ argv_src += 2;
+ break;
+#if WASM_ENABLE_REF_TYPES != 0
+ case VALUE_TYPE_EXTERNREF:
+ {
+ uint32 externref_idx = *argv_src++;
+ if (is_aot_func) {
+ if (n_ints < MAX_REG_INTS)
+ ints[n_ints++] = externref_idx;
+ else
+ stacks[n_stacks++] = externref_idx;
+ }
+ else {
+ void *externref_obj;
+
+ if (!wasm_externref_ref2obj(externref_idx, &externref_obj))
+ goto fail;
+
+ if (n_ints < MAX_REG_INTS)
+ ints[n_ints++] = (uintptr_t)externref_obj;
+ else
+ stacks[n_stacks++] = (uintptr_t)externref_obj;
+ }
+ break;
+ }
+#endif
+#if WASM_ENABLE_SIMD != 0
+ case VALUE_TYPE_V128:
+ if (n_fps < MAX_REG_FLOATS) {
+ *(v128 *)&fps[n_fps++] = *(v128 *)argv_src;
+ }
+ else {
+ *(v128 *)&stacks[n_stacks++] = *(v128 *)argv_src;
+ n_stacks++;
+ }
+ argv_src += 4;
+ break;
+#endif
+ default:
+ bh_assert(0);
+ break;
+ }
+ }
+
+ /* Save extra result values' address to argv1 */
+ for (i = 0; i < ext_ret_count; i++) {
+ if (n_ints < MAX_REG_INTS)
+ ints[n_ints++] = *(uint64 *)argv_src;
+ else
+ stacks[n_stacks++] = *(uint64 *)argv_src;
+ argv_src += 2;
+ }
+
+ exec_env->attachment = attachment;
+ if (result_count == 0) {
+ invokeNative_Void(func_ptr, argv1, n_stacks);
+ }
+ else {
+ /* Invoke the native function and get the first result value */
+ switch (func_type->types[func_type->param_count]) {
+ case VALUE_TYPE_I32:
+#if WASM_ENABLE_REF_TYPES != 0
+ case VALUE_TYPE_FUNCREF:
+#endif
+ argv_ret[0] =
+ (uint32)invokeNative_Int32(func_ptr, argv1, n_stacks);
+ break;
+ case VALUE_TYPE_I64:
+ PUT_I64_TO_ADDR(argv_ret,
+ invokeNative_Int64(func_ptr, argv1, n_stacks));
+ break;
+ case VALUE_TYPE_F32:
+ *(float32 *)argv_ret =
+ invokeNative_Float32(func_ptr, argv1, n_stacks);
+ break;
+ case VALUE_TYPE_F64:
+ PUT_F64_TO_ADDR(
+ argv_ret, invokeNative_Float64(func_ptr, argv1, n_stacks));
+ break;
+#if WASM_ENABLE_REF_TYPES != 0
+ case VALUE_TYPE_EXTERNREF:
+ {
+ if (is_aot_func) {
+ argv_ret[0] = invokeNative_Int32(func_ptr, argv1, n_stacks);
+ }
+ else {
+ uint32 externref_idx;
+ void *externref_obj = (void *)(uintptr_t)invokeNative_Int64(
+ func_ptr, argv1, n_stacks);
+
+ if (!wasm_externref_obj2ref(exec_env->module_inst,
+ externref_obj, &externref_idx))
+ goto fail;
+
+ argv_ret[0] = externref_idx;
+ }
+ break;
+ }
+#endif
+#if WASM_ENABLE_SIMD != 0
+ case VALUE_TYPE_V128:
+ *(v128 *)argv_ret =
+ invokeNative_V128(func_ptr, argv1, n_stacks);
+ break;
+#endif
+ default:
+ bh_assert(0);
+ break;
+ }
+ }
+ exec_env->attachment = NULL;
+
+ ret = !wasm_runtime_copy_exception(module, NULL);
+fail:
+ if (argv1 != argv_buf)
+ wasm_runtime_free(argv1);
+
+ return ret;
+}
+
+#endif /* end of defined(BUILD_TARGET_X86_64) \
+ || defined(BUILD_TARGET_AMD_64) \
+ || defined(BUILD_TARGET_AARCH64) \
+ || defined(BUILD_TARGET_RISCV64_LP64D) \
+ || defined(BUILD_TARGET_RISCV64_LP64) */
+
+bool
+wasm_runtime_call_indirect(WASMExecEnv *exec_env, uint32 element_index,
+ uint32 argc, uint32 argv[])
+{
+ bool ret = false;
+
+ if (!wasm_runtime_exec_env_check(exec_env)) {
+ LOG_ERROR("Invalid exec env stack info.");
+ return false;
+ }
+
+ /* this function is called from native code, so exec_env->handle and
+ exec_env->native_stack_boundary must have been set, we don't set
+ it again */
+
+#if WASM_ENABLE_INTERP != 0
+ if (exec_env->module_inst->module_type == Wasm_Module_Bytecode)
+ ret = wasm_call_indirect(exec_env, 0, element_index, argc, argv);
+#endif
+#if WASM_ENABLE_AOT != 0
+ if (exec_env->module_inst->module_type == Wasm_Module_AoT)
+ ret = aot_call_indirect(exec_env, 0, element_index, argc, argv);
+#endif
+
+ if (!ret && clear_wasi_proc_exit_exception(exec_env->module_inst)) {
+ ret = true;
+ }
+
+ return ret;
+}
+
+static void
+exchange_uint32(uint8 *p_data)
+{
+ uint8 value = *p_data;
+ *p_data = *(p_data + 3);
+ *(p_data + 3) = value;
+
+ value = *(p_data + 1);
+ *(p_data + 1) = *(p_data + 2);
+ *(p_data + 2) = value;
+}
+
+static void
+exchange_uint64(uint8 *p_data)
+{
+ uint32 value;
+
+ value = *(uint32 *)p_data;
+ *(uint32 *)p_data = *(uint32 *)(p_data + 4);
+ *(uint32 *)(p_data + 4) = value;
+ exchange_uint32(p_data);
+ exchange_uint32(p_data + 4);
+}
+
+void
+wasm_runtime_read_v128(const uint8 *bytes, uint64 *ret1, uint64 *ret2)
+{
+ uint64 u1, u2;
+
+ bh_memcpy_s(&u1, 8, bytes, 8);
+ bh_memcpy_s(&u2, 8, bytes + 8, 8);
+
+ if (!is_little_endian()) {
+ exchange_uint64((uint8 *)&u1);
+ exchange_uint64((uint8 *)&u2);
+ *ret1 = u2;
+ *ret2 = u1;
+ }
+ else {
+ *ret1 = u1;
+ *ret2 = u2;
+ }
+}
+
+#if WASM_ENABLE_THREAD_MGR != 0
+typedef struct WASMThreadArg {
+ WASMExecEnv *new_exec_env;
+ wasm_thread_callback_t callback;
+ void *arg;
+} WASMThreadArg;
+
+WASMExecEnv *
+wasm_runtime_spawn_exec_env(WASMExecEnv *exec_env)
+{
+ return wasm_cluster_spawn_exec_env(exec_env);
+}
+
+void
+wasm_runtime_destroy_spawned_exec_env(WASMExecEnv *exec_env)
+{
+ wasm_cluster_destroy_spawned_exec_env(exec_env);
+}
+
+static void *
+wasm_runtime_thread_routine(void *arg)
+{
+ WASMThreadArg *thread_arg = (WASMThreadArg *)arg;
+ void *ret;
+
+ bh_assert(thread_arg->new_exec_env);
+ ret = thread_arg->callback(thread_arg->new_exec_env, thread_arg->arg);
+
+ wasm_runtime_destroy_spawned_exec_env(thread_arg->new_exec_env);
+ wasm_runtime_free(thread_arg);
+
+ os_thread_exit(ret);
+ return ret;
+}
+
+int32
+wasm_runtime_spawn_thread(WASMExecEnv *exec_env, wasm_thread_t *tid,
+ wasm_thread_callback_t callback, void *arg)
+{
+ WASMExecEnv *new_exec_env = wasm_runtime_spawn_exec_env(exec_env);
+ WASMThreadArg *thread_arg;
+ int32 ret;
+
+ if (!new_exec_env)
+ return -1;
+
+ if (!(thread_arg = wasm_runtime_malloc(sizeof(WASMThreadArg)))) {
+ wasm_runtime_destroy_spawned_exec_env(new_exec_env);
+ return -1;
+ }
+
+ thread_arg->new_exec_env = new_exec_env;
+ thread_arg->callback = callback;
+ thread_arg->arg = arg;
+
+ ret = os_thread_create((korp_tid *)tid, wasm_runtime_thread_routine,
+ thread_arg, APP_THREAD_STACK_SIZE_DEFAULT);
+
+ if (ret != 0) {
+ wasm_runtime_destroy_spawned_exec_env(new_exec_env);
+ wasm_runtime_free(thread_arg);
+ }
+
+ return ret;
+}
+
+int32
+wasm_runtime_join_thread(wasm_thread_t tid, void **retval)
+{
+ return os_thread_join((korp_tid)tid, retval);
+}
+
+#endif /* end of WASM_ENABLE_THREAD_MGR */
+
+#if WASM_ENABLE_REF_TYPES != 0
+
+static korp_mutex externref_lock;
+static uint32 externref_global_id = 1;
+static HashMap *externref_map;
+
+typedef struct ExternRefMapNode {
+ /* The extern object from runtime embedder */
+ void *extern_obj;
+ /* The module instance it belongs to */
+ WASMModuleInstanceCommon *module_inst;
+ /* Whether it is retained */
+ bool retained;
+ /* Whether it is marked by runtime */
+ bool marked;
+} ExternRefMapNode;
+
+static uint32
+wasm_externref_hash(const void *key)
+{
+ uint32 externref_idx = (uint32)(uintptr_t)key;
+ return externref_idx;
+}
+
+static bool
+wasm_externref_equal(void *key1, void *key2)
+{
+ uint32 externref_idx1 = (uint32)(uintptr_t)key1;
+ uint32 externref_idx2 = (uint32)(uintptr_t)key2;
+ return externref_idx1 == externref_idx2 ? true : false;
+}
+
+static bool
+wasm_externref_map_init()
+{
+ if (os_mutex_init(&externref_lock) != 0)
+ return false;
+
+ if (!(externref_map = bh_hash_map_create(32, false, wasm_externref_hash,
+ wasm_externref_equal, NULL,
+ wasm_runtime_free))) {
+ os_mutex_destroy(&externref_lock);
+ return false;
+ }
+
+ externref_global_id = 1;
+ return true;
+}
+
+static void
+wasm_externref_map_destroy()
+{
+ bh_hash_map_destroy(externref_map);
+ os_mutex_destroy(&externref_lock);
+}
+
+typedef struct LookupExtObj_UserData {
+ ExternRefMapNode node;
+ bool found;
+ uint32 externref_idx;
+} LookupExtObj_UserData;
+
+static void
+lookup_extobj_callback(void *key, void *value, void *user_data)
+{
+ uint32 externref_idx = (uint32)(uintptr_t)key;
+ ExternRefMapNode *node = (ExternRefMapNode *)value;
+ LookupExtObj_UserData *user_data_lookup =
+ (LookupExtObj_UserData *)user_data;
+
+ if (node->extern_obj == user_data_lookup->node.extern_obj
+ && node->module_inst == user_data_lookup->node.module_inst) {
+ user_data_lookup->found = true;
+ user_data_lookup->externref_idx = externref_idx;
+ }
+}
+
+bool
+wasm_externref_obj2ref(WASMModuleInstanceCommon *module_inst, void *extern_obj,
+ uint32 *p_externref_idx)
+{
+ LookupExtObj_UserData lookup_user_data = { 0 };
+ ExternRefMapNode *node;
+ uint32 externref_idx;
+
+ /*
+ * to catch a parameter from `wasm_application_execute_func`,
+ * which represents a string 'null'
+ */
+#if UINTPTR_MAX == UINT32_MAX
+ if ((uint32)-1 == (uintptr_t)extern_obj) {
+#else
+ if ((uint64)-1LL == (uintptr_t)extern_obj) {
+#endif
+ *p_externref_idx = NULL_REF;
+ return true;
+ }
+
+ /* in a wrapper, extern_obj could be any value */
+ lookup_user_data.node.extern_obj = extern_obj;
+ lookup_user_data.node.module_inst = module_inst;
+ lookup_user_data.found = false;
+
+ os_mutex_lock(&externref_lock);
+
+ /* Lookup hashmap firstly */
+ bh_hash_map_traverse(externref_map, lookup_extobj_callback,
+ (void *)&lookup_user_data);
+ if (lookup_user_data.found) {
+ *p_externref_idx = lookup_user_data.externref_idx;
+ os_mutex_unlock(&externref_lock);
+ return true;
+ }
+
+ /* Not found in hashmap */
+ if (externref_global_id == NULL_REF || externref_global_id == 0) {
+ goto fail1;
+ }
+
+ if (!(node = wasm_runtime_malloc(sizeof(ExternRefMapNode)))) {
+ goto fail1;
+ }
+
+ memset(node, 0, sizeof(ExternRefMapNode));
+ node->extern_obj = extern_obj;
+ node->module_inst = module_inst;
+
+ externref_idx = externref_global_id;
+
+ if (!bh_hash_map_insert(externref_map, (void *)(uintptr_t)externref_idx,
+ (void *)node)) {
+ goto fail2;
+ }
+
+ externref_global_id++;
+ *p_externref_idx = externref_idx;
+ os_mutex_unlock(&externref_lock);
+ return true;
+fail2:
+ wasm_runtime_free(node);
+fail1:
+ os_mutex_unlock(&externref_lock);
+ return false;
+}
+
+bool
+wasm_externref_ref2obj(uint32 externref_idx, void **p_extern_obj)
+{
+ ExternRefMapNode *node;
+
+ /* catch a `ref.null` vairable */
+ if (externref_idx == NULL_REF) {
+ *p_extern_obj = NULL;
+ return true;
+ }
+
+ os_mutex_lock(&externref_lock);
+ node = bh_hash_map_find(externref_map, (void *)(uintptr_t)externref_idx);
+ os_mutex_unlock(&externref_lock);
+
+ if (!node)
+ return false;
+
+ *p_extern_obj = node->extern_obj;
+ return true;
+}
+
+static void
+reclaim_extobj_callback(void *key, void *value, void *user_data)
+{
+ ExternRefMapNode *node = (ExternRefMapNode *)value;
+ WASMModuleInstanceCommon *module_inst =
+ (WASMModuleInstanceCommon *)user_data;
+
+ if (node->module_inst == module_inst) {
+ if (!node->marked && !node->retained) {
+ bh_hash_map_remove(externref_map, key, NULL, NULL);
+ wasm_runtime_free(value);
+ }
+ else {
+ node->marked = false;
+ }
+ }
+}
+
+static void
+mark_externref(uint32 externref_idx)
+{
+ ExternRefMapNode *node;
+
+ if (externref_idx != NULL_REF) {
+ node =
+ bh_hash_map_find(externref_map, (void *)(uintptr_t)externref_idx);
+ if (node) {
+ node->marked = true;
+ }
+ }
+}
+
+#if WASM_ENABLE_INTERP != 0
+static void
+interp_mark_all_externrefs(WASMModuleInstance *module_inst)
+{
+ uint32 i, j, externref_idx, *table_data;
+ uint8 *global_data = module_inst->global_data;
+ WASMGlobalInstance *global;
+ WASMTableInstance *table;
+
+ global = module_inst->e->globals;
+ for (i = 0; i < module_inst->e->global_count; i++, global++) {
+ if (global->type == VALUE_TYPE_EXTERNREF) {
+ externref_idx = *(uint32 *)(global_data + global->data_offset);
+ mark_externref(externref_idx);
+ }
+ }
+
+ for (i = 0; i < module_inst->table_count; i++) {
+ uint8 elem_type = 0;
+ uint32 init_size, max_size;
+
+ table = wasm_get_table_inst(module_inst, i);
+ (void)wasm_runtime_get_table_inst_elem_type(
+ (WASMModuleInstanceCommon *)module_inst, i, &elem_type, &init_size,
+ &max_size);
+
+ if (elem_type == VALUE_TYPE_EXTERNREF) {
+ table_data = table->elems;
+ for (j = 0; j < table->cur_size; j++) {
+ externref_idx = table_data[j];
+ mark_externref(externref_idx);
+ }
+ }
+ (void)init_size;
+ (void)max_size;
+ }
+}
+#endif
+
+#if WASM_ENABLE_AOT != 0
+static void
+aot_mark_all_externrefs(AOTModuleInstance *module_inst)
+{
+ uint32 i = 0, j = 0;
+ const AOTModule *module = (AOTModule *)module_inst->module;
+ const AOTTable *table = module->tables;
+ const AOTGlobal *global = module->globals;
+ const AOTTableInstance *table_inst;
+
+ for (i = 0; i < module->global_count; i++, global++) {
+ if (global->type == VALUE_TYPE_EXTERNREF) {
+ mark_externref(
+ *(uint32 *)(module_inst->global_data + global->data_offset));
+ }
+ }
+
+ for (i = 0; i < module->table_count; i++) {
+ table_inst = module_inst->tables[i];
+ if ((table + i)->elem_type == VALUE_TYPE_EXTERNREF) {
+ while (j < table_inst->cur_size) {
+ mark_externref(table_inst->elems[j++]);
+ }
+ }
+ }
+}
+#endif
+
+void
+wasm_externref_reclaim(WASMModuleInstanceCommon *module_inst)
+{
+ os_mutex_lock(&externref_lock);
+#if WASM_ENABLE_INTERP != 0
+ if (module_inst->module_type == Wasm_Module_Bytecode)
+ interp_mark_all_externrefs((WASMModuleInstance *)module_inst);
+#endif
+#if WASM_ENABLE_AOT != 0
+ if (module_inst->module_type == Wasm_Module_AoT)
+ aot_mark_all_externrefs((AOTModuleInstance *)module_inst);
+#endif
+
+ bh_hash_map_traverse(externref_map, reclaim_extobj_callback,
+ (void *)module_inst);
+ os_mutex_unlock(&externref_lock);
+}
+
+static void
+cleanup_extobj_callback(void *key, void *value, void *user_data)
+{
+ ExternRefMapNode *node = (ExternRefMapNode *)value;
+ WASMModuleInstanceCommon *module_inst =
+ (WASMModuleInstanceCommon *)user_data;
+
+ if (node->module_inst == module_inst) {
+ bh_hash_map_remove(externref_map, key, NULL, NULL);
+ wasm_runtime_free(value);
+ }
+}
+
+void
+wasm_externref_cleanup(WASMModuleInstanceCommon *module_inst)
+{
+ os_mutex_lock(&externref_lock);
+ bh_hash_map_traverse(externref_map, cleanup_extobj_callback,
+ (void *)module_inst);
+ os_mutex_unlock(&externref_lock);
+}
+
+bool
+wasm_externref_retain(uint32 externref_idx)
+{
+ ExternRefMapNode *node;
+
+ os_mutex_lock(&externref_lock);
+
+ if (externref_idx != NULL_REF) {
+ node =
+ bh_hash_map_find(externref_map, (void *)(uintptr_t)externref_idx);
+ if (node) {
+ node->retained = true;
+ os_mutex_unlock(&externref_lock);
+ return true;
+ }
+ }
+
+ os_mutex_unlock(&externref_lock);
+ return false;
+}
+#endif /* end of WASM_ENABLE_REF_TYPES */
+
+#if WASM_ENABLE_DUMP_CALL_STACK != 0
+uint32
+wasm_runtime_dump_line_buf_impl(const char *line_buf, bool dump_or_print,
+ char **buf, uint32 *len)
+{
+ if (dump_or_print) {
+ return (uint32)os_printf("%s", line_buf);
+ }
+ else if (*buf) {
+ uint32 dump_len;
+
+ dump_len = snprintf(*buf, *len, "%s", line_buf);
+ if (dump_len >= *len) {
+ dump_len = *len;
+ }
+
+ *len = *len - dump_len;
+ *buf = *buf + dump_len;
+ return dump_len;
+ }
+ else {
+ return (uint32)strlen(line_buf);
+ }
+}
+
+void
+wasm_runtime_dump_call_stack(WASMExecEnv *exec_env)
+{
+ WASMModuleInstanceCommon *module_inst =
+ wasm_exec_env_get_module_inst(exec_env);
+#if WASM_ENABLE_INTERP != 0
+ if (module_inst->module_type == Wasm_Module_Bytecode) {
+ wasm_interp_dump_call_stack(exec_env, true, NULL, 0);
+ }
+#endif
+#if WASM_ENABLE_AOT != 0
+ if (module_inst->module_type == Wasm_Module_AoT) {
+ aot_dump_call_stack(exec_env, true, NULL, 0);
+ }
+#endif
+}
+
+uint32
+wasm_runtime_get_call_stack_buf_size(wasm_exec_env_t exec_env)
+{
+ WASMModuleInstanceCommon *module_inst =
+ wasm_exec_env_get_module_inst(exec_env);
+
+#if WASM_ENABLE_INTERP != 0
+ if (module_inst->module_type == Wasm_Module_Bytecode) {
+ return wasm_interp_dump_call_stack(exec_env, false, NULL, 0);
+ }
+#endif
+#if WASM_ENABLE_AOT != 0
+ if (module_inst->module_type == Wasm_Module_AoT) {
+ return aot_dump_call_stack(exec_env, false, NULL, 0);
+ }
+#endif
+
+ return 0;
+}
+
+uint32
+wasm_runtime_dump_call_stack_to_buf(wasm_exec_env_t exec_env, char *buf,
+ uint32 len)
+{
+ WASMModuleInstanceCommon *module_inst =
+ wasm_exec_env_get_module_inst(exec_env);
+
+#if WASM_ENABLE_INTERP != 0
+ if (module_inst->module_type == Wasm_Module_Bytecode) {
+ return wasm_interp_dump_call_stack(exec_env, false, buf, len);
+ }
+#endif
+#if WASM_ENABLE_AOT != 0
+ if (module_inst->module_type == Wasm_Module_AoT) {
+ return aot_dump_call_stack(exec_env, false, buf, len);
+ }
+#endif
+
+ return 0;
+}
+#endif /* end of WASM_ENABLE_DUMP_CALL_STACK */
+
+bool
+wasm_runtime_get_table_elem_type(const WASMModuleCommon *module_comm,
+ uint32 table_idx, uint8 *out_elem_type,
+ uint32 *out_min_size, uint32 *out_max_size)
+{
+#if WASM_ENABLE_INTERP != 0
+ if (module_comm->module_type == Wasm_Module_Bytecode) {
+ WASMModule *module = (WASMModule *)module_comm;
+
+ if (table_idx < module->import_table_count) {
+ WASMTableImport *import_table =
+ &((module->import_tables + table_idx)->u.table);
+ *out_elem_type = import_table->elem_type;
+ *out_min_size = import_table->init_size;
+ *out_max_size = import_table->max_size;
+ }
+ else {
+ WASMTable *table =
+ module->tables + (table_idx - module->import_table_count);
+ *out_elem_type = table->elem_type;
+ *out_min_size = table->init_size;
+ *out_max_size = table->max_size;
+ }
+ return true;
+ }
+#endif
+
+#if WASM_ENABLE_AOT != 0
+ if (module_comm->module_type == Wasm_Module_AoT) {
+ AOTModule *module = (AOTModule *)module_comm;
+
+ if (table_idx < module->import_table_count) {
+ AOTImportTable *import_table = module->import_tables + table_idx;
+ *out_elem_type = VALUE_TYPE_FUNCREF;
+ *out_min_size = import_table->table_init_size;
+ *out_max_size = import_table->table_max_size;
+ }
+ else {
+ AOTTable *table =
+ module->tables + (table_idx - module->import_table_count);
+ *out_elem_type = table->elem_type;
+ *out_min_size = table->table_init_size;
+ *out_max_size = table->table_max_size;
+ }
+ return true;
+ }
+#endif
+
+ return false;
+}
+
+bool
+wasm_runtime_get_table_inst_elem_type(
+ const WASMModuleInstanceCommon *module_inst_comm, uint32 table_idx,
+ uint8 *out_elem_type, uint32 *out_min_size, uint32 *out_max_size)
+{
+#if WASM_ENABLE_INTERP != 0
+ if (module_inst_comm->module_type == Wasm_Module_Bytecode) {
+ WASMModuleInstance *module_inst =
+ (WASMModuleInstance *)module_inst_comm;
+ return wasm_runtime_get_table_elem_type(
+ (WASMModuleCommon *)module_inst->module, table_idx, out_elem_type,
+ out_min_size, out_max_size);
+ }
+#endif
+#if WASM_ENABLE_AOT != 0
+ if (module_inst_comm->module_type == Wasm_Module_AoT) {
+ AOTModuleInstance *module_inst = (AOTModuleInstance *)module_inst_comm;
+ return wasm_runtime_get_table_elem_type(
+ (WASMModuleCommon *)module_inst->module, table_idx, out_elem_type,
+ out_min_size, out_max_size);
+ }
+#endif
+ return false;
+}
+
+bool
+wasm_runtime_get_export_func_type(const WASMModuleCommon *module_comm,
+ const WASMExport *export, WASMType **out)
+{
+#if WASM_ENABLE_INTERP != 0
+ if (module_comm->module_type == Wasm_Module_Bytecode) {
+ WASMModule *module = (WASMModule *)module_comm;
+
+ if (export->index < module->import_function_count) {
+ *out = module->import_functions[export->index].u.function.func_type;
+ }
+ else {
+ *out =
+ module->functions[export->index - module->import_function_count]
+ ->func_type;
+ }
+ return true;
+ }
+#endif
+
+#if WASM_ENABLE_AOT != 0
+ if (module_comm->module_type == Wasm_Module_AoT) {
+ AOTModule *module = (AOTModule *)module_comm;
+
+ if (export->index < module->import_func_count) {
+ *out = module->func_types[module->import_funcs[export->index]
+ .func_type_index];
+ }
+ else {
+ *out = module->func_types
+ [module->func_type_indexes[export->index
+ - module->import_func_count]];
+ }
+ return true;
+ }
+#endif
+ return false;
+}
+
+bool
+wasm_runtime_get_export_global_type(const WASMModuleCommon *module_comm,
+ const WASMExport *export,
+ uint8 *out_val_type, bool *out_mutability)
+{
+#if WASM_ENABLE_INTERP != 0
+ if (module_comm->module_type == Wasm_Module_Bytecode) {
+ WASMModule *module = (WASMModule *)module_comm;
+
+ if (export->index < module->import_global_count) {
+ WASMGlobalImport *import_global =
+ &((module->import_globals + export->index)->u.global);
+ *out_val_type = import_global->type;
+ *out_mutability = import_global->is_mutable;
+ }
+ else {
+ WASMGlobal *global =
+ module->globals + (export->index - module->import_global_count);
+ *out_val_type = global->type;
+ *out_mutability = global->is_mutable;
+ }
+ return true;
+ }
+#endif
+
+#if WASM_ENABLE_AOT != 0
+ if (module_comm->module_type == Wasm_Module_AoT) {
+ AOTModule *module = (AOTModule *)module_comm;
+
+ if (export->index < module->import_global_count) {
+ AOTImportGlobal *import_global =
+ module->import_globals + export->index;
+ *out_val_type = import_global->type;
+ *out_mutability = import_global->is_mutable;
+ }
+ else {
+ AOTGlobal *global =
+ module->globals + (export->index - module->import_global_count);
+ *out_val_type = global->type;
+ *out_mutability = global->is_mutable;
+ }
+ return true;
+ }
+#endif
+ return false;
+}
+
+bool
+wasm_runtime_get_export_memory_type(const WASMModuleCommon *module_comm,
+ const WASMExport *export,
+ uint32 *out_min_page, uint32 *out_max_page)
+{
+#if WASM_ENABLE_INTERP != 0
+ if (module_comm->module_type == Wasm_Module_Bytecode) {
+ WASMModule *module = (WASMModule *)module_comm;
+
+ if (export->index < module->import_memory_count) {
+ WASMMemoryImport *import_memory =
+ &((module->import_memories + export->index)->u.memory);
+ *out_min_page = import_memory->init_page_count;
+ *out_max_page = import_memory->max_page_count;
+ }
+ else {
+ WASMMemory *memory =
+ module->memories
+ + (export->index - module->import_memory_count);
+ *out_min_page = memory->init_page_count;
+ *out_max_page = memory->max_page_count;
+ }
+ return true;
+ }
+#endif
+
+#if WASM_ENABLE_AOT != 0
+ if (module_comm->module_type == Wasm_Module_AoT) {
+ AOTModule *module = (AOTModule *)module_comm;
+
+ if (export->index < module->import_memory_count) {
+ AOTImportMemory *import_memory =
+ module->import_memories + export->index;
+ *out_min_page = import_memory->mem_init_page_count;
+ *out_max_page = import_memory->mem_max_page_count;
+ }
+ else {
+ AOTMemory *memory = module->memories
+ + (export->index - module->import_memory_count);
+ *out_min_page = memory->mem_init_page_count;
+ *out_max_page = memory->mem_max_page_count;
+ }
+ return true;
+ }
+#endif
+ return false;
+}
+
+bool
+wasm_runtime_get_export_table_type(const WASMModuleCommon *module_comm,
+ const WASMExport *export,
+ uint8 *out_elem_type, uint32 *out_min_size,
+ uint32 *out_max_size)
+{
+ return wasm_runtime_get_table_elem_type(
+ module_comm, export->index, out_elem_type, out_min_size, out_max_size);
+}
+
+static inline bool
+argv_to_params(wasm_val_t *out_params, const uint32 *argv, WASMType *func_type)
+{
+ wasm_val_t *param = out_params;
+ uint32 i = 0, *u32;
+
+ for (i = 0; i < func_type->param_count; i++, param++) {
+ switch (func_type->types[i]) {
+ case VALUE_TYPE_I32:
+ param->kind = WASM_I32;
+ param->of.i32 = *argv++;
+ break;
+ case VALUE_TYPE_I64:
+ param->kind = WASM_I64;
+ u32 = (uint32 *)&param->of.i64;
+ u32[0] = *argv++;
+ u32[1] = *argv++;
+ break;
+ case VALUE_TYPE_F32:
+ param->kind = WASM_F32;
+ param->of.f32 = *(float32 *)argv++;
+ break;
+ case VALUE_TYPE_F64:
+ param->kind = WASM_F64;
+ u32 = (uint32 *)&param->of.i64;
+ u32[0] = *argv++;
+ u32[1] = *argv++;
+ break;
+#if WASM_ENABLE_REF_TYPES != 0
+ case VALUE_TYPE_EXTERNREF:
+ param->kind = WASM_ANYREF;
+
+ if (!wasm_externref_ref2obj(*argv,
+ (void **)&param->of.foreign)) {
+ return false;
+ }
+
+ argv++;
+ break;
+#endif
+ default:
+ return false;
+ }
+ }
+
+ return true;
+}
+
+static inline bool
+results_to_argv(WASMModuleInstanceCommon *module_inst, uint32 *out_argv,
+ const wasm_val_t *results, WASMType *func_type)
+{
+ const wasm_val_t *result = results;
+ uint32 *argv = out_argv, *u32, i;
+ uint8 *result_types = func_type->types + func_type->param_count;
+
+ for (i = 0; i < func_type->result_count; i++, result++) {
+ switch (result_types[i]) {
+ case VALUE_TYPE_I32:
+ case VALUE_TYPE_F32:
+ *(int32 *)argv++ = result->of.i32;
+ break;
+ case VALUE_TYPE_I64:
+ case VALUE_TYPE_F64:
+ u32 = (uint32 *)&result->of.i64;
+ *argv++ = u32[0];
+ *argv++ = u32[1];
+ break;
+#if WASM_ENABLE_REF_TYPES != 0
+ case VALUE_TYPE_EXTERNREF:
+ if (!wasm_externref_obj2ref(module_inst,
+ (void *)result->of.foreign, argv)) {
+ return false;
+ }
+ argv++;
+ break;
+#endif
+ default:
+ return false;
+ }
+ }
+
+ return true;
+}
+
+bool
+wasm_runtime_invoke_c_api_native(WASMModuleInstanceCommon *module_inst,
+ void *func_ptr, WASMType *func_type,
+ uint32 argc, uint32 *argv, bool with_env,
+ void *wasm_c_api_env)
+{
+ wasm_val_t params_buf[16] = { 0 }, results_buf[4] = { 0 };
+ wasm_val_t *params = params_buf, *results = results_buf;
+ wasm_trap_t *trap = NULL;
+ bool ret = false;
+ wasm_val_vec_t params_vec, results_vec;
+
+ if (func_type->param_count > 16) {
+ if (!(params =
+ runtime_malloc(sizeof(wasm_val_t) * func_type->param_count,
+ module_inst, NULL, 0))) {
+ wasm_runtime_set_exception(module_inst, "allocate memory failed");
+ return false;
+ }
+ }
+
+ if (!argv_to_params(params, argv, func_type)) {
+ wasm_runtime_set_exception(module_inst, "unsupported param type");
+ goto fail;
+ }
+
+ if (func_type->result_count > 4) {
+ if (!(results =
+ runtime_malloc(sizeof(wasm_val_t) * func_type->result_count,
+ module_inst, NULL, 0))) {
+ wasm_runtime_set_exception(module_inst, "allocate memory failed");
+ goto fail;
+ }
+ }
+
+ params_vec.data = params;
+ params_vec.num_elems = func_type->param_count;
+ params_vec.size = func_type->param_count;
+ params_vec.size_of_elem = sizeof(wasm_val_t);
+
+ results_vec.data = results;
+ results_vec.num_elems = 0;
+ results_vec.size = func_type->result_count;
+ results_vec.size_of_elem = sizeof(wasm_val_t);
+
+ if (!with_env) {
+ wasm_func_callback_t callback = (wasm_func_callback_t)func_ptr;
+ trap = callback(&params_vec, &results_vec);
+ }
+ else {
+ wasm_func_callback_with_env_t callback =
+ (wasm_func_callback_with_env_t)func_ptr;
+ trap = callback(wasm_c_api_env, &params_vec, &results_vec);
+ }
+
+ if (trap) {
+ if (trap->message->data) {
+ /* since trap->message->data does not end with '\0' */
+ char trap_message[108] = { 0 };
+ uint32 max_size_to_copy = (uint32)sizeof(trap_message) - 1;
+ uint32 size_to_copy = (trap->message->size < max_size_to_copy)
+ ? (uint32)trap->message->size
+ : max_size_to_copy;
+ bh_memcpy_s(trap_message, (uint32)sizeof(trap_message),
+ trap->message->data, size_to_copy);
+ wasm_runtime_set_exception(module_inst, trap_message);
+ }
+ else {
+ wasm_runtime_set_exception(
+ module_inst, "native function throw unknown exception");
+ }
+ wasm_trap_delete(trap);
+ goto fail;
+ }
+
+ if (!results_to_argv(module_inst, argv, results, func_type)) {
+ wasm_runtime_set_exception(module_inst, "unsupported result type");
+ goto fail;
+ }
+ results_vec.num_elems = func_type->result_count;
+ ret = true;
+
+fail:
+ if (params != params_buf)
+ wasm_runtime_free(params);
+ if (results != results_buf)
+ wasm_runtime_free(results);
+ return ret;
+}
+
+void
+wasm_runtime_show_app_heap_corrupted_prompt()
+{
+ LOG_ERROR("Error: app heap is corrupted, if the wasm file "
+ "is compiled by wasi-sdk-12.0 or higher version, "
+ "please add -Wl,--export=malloc -Wl,--export=free "
+ "to export malloc and free functions. If it is "
+ "compiled by asc, please add --exportRuntime to "
+ "export the runtime helpers.");
+}
+
+#if WASM_ENABLE_LOAD_CUSTOM_SECTION != 0
+void
+wasm_runtime_destroy_custom_sections(WASMCustomSection *section_list)
+{
+ WASMCustomSection *section = section_list, *next;
+ while (section) {
+ next = section->next;
+ wasm_runtime_free(section);
+ section = next;
+ }
+}
+#endif /* end of WASM_ENABLE_LOAD_CUSTOM_SECTION */
+
+void
+wasm_runtime_get_version(uint32_t *major, uint32_t *minor, uint32_t *patch)
+{
+ *major = WAMR_VERSION_MAJOR;
+ *minor = WAMR_VERSION_MINOR;
+ *patch = WAMR_VERSION_PATCH;
+}
+
+bool
+wasm_runtime_is_import_func_linked(const char *module_name,
+ const char *func_name)
+{
+ return wasm_native_resolve_symbol(module_name, func_name, NULL, NULL, NULL,
+ NULL);
+}
+
+bool
+wasm_runtime_is_import_global_linked(const char *module_name,
+ const char *global_name)
+{
+#if WASM_ENABLE_LIBC_BUILTIN != 0
+ WASMGlobalImport global = { 0 };
+ return wasm_native_lookup_libc_builtin_global(module_name, global_name,
+ &global);
+#else
+ return false;
+#endif
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-31 01:20:26 +0000