/* * 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_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" #endif #if WASM_ENABLE_MULTI_MODULE != 0 /* * a safety insurance to prevent * circular depencies leading a stack overflow * try 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 about 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 = ®istered_module_list_head; static korp_mutex registered_module_list_lock; static void wasm_runtime_destroy_registered_module_list(); #endif /* WASM_ENABLE_MULTI_MODULE */ void set_error_buf_v(char *error_buf, uint32 error_buf_size, const char *format, ...) { va_list args; va_start(args, format); vsnprintf(error_buf, error_buf_size, format, args); va_end(args); } 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 bool wasm_runtime_env_init() { if (bh_platform_init() != 0) return false; if (wasm_native_init() == false) { bh_platform_destroy(); return false; } #if WASM_ENABLE_MULTI_MODULE if (BHT_OK != os_mutex_init(®istered_module_list_lock)) { wasm_native_destroy(); bh_platform_destroy(); return false; } if (BHT_OK != os_mutex_init(&loading_module_list_lock)) { os_mutex_destroy(®istered_module_list_lock); wasm_native_destroy(); bh_platform_destroy(); return false; } #endif return true; } 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() { /* 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(®istered_module_list_lock); #endif wasm_native_destroy(); bh_platform_destroy(); wasm_runtime_memory_destroy(); } 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_env_init()) { wasm_runtime_memory_destroy(); return false; } 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; } return true; } PackageType get_package_type(const uint8 *buf, uint32 size) { 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_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(®istered_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(®istered_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_t 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 (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_v(error_buf, error_buf_size, "can not 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 = wasm_runtime_malloc(sizeof(WASMRegisteredModule)); if (!node) { LOG_DEBUG("malloc WASMRegisteredModule failed. SZ=%d", sizeof(WASMRegisteredModule)); set_error_buf_v(error_buf, error_buf_size, "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(®istered_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(®istered_module_list_lock); return true; } bool wasm_runtime_register_module(const char *module_name, WASMModuleCommon *module, char *error_buf, uint32_t 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_v(error_buf, error_buf_size, "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, "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(®istered_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(®istered_module_list_lock); } WASMModuleCommon * wasm_runtime_find_module_registered(const char *module_name) { WASMRegisteredModule *module = NULL, *module_next; os_mutex_lock(®istered_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(®istered_module_list_lock); return module ? module->module : NULL; } bool wasm_runtime_is_module_registered(const char *module_name) { return NULL != wasm_runtime_find_module_registered(module_name); } /* * simply destroy all */ static void wasm_runtime_destroy_registered_module_list() { WASMRegisteredModule *reg_module = NULL; os_mutex_lock(®istered_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 WASM_ENABLE_INTERP != 0 if (reg_module->module->module_type == Wasm_Module_Bytecode) wasm_unload((WASMModule *)reg_module->module); #endif #if WASM_ENABLE_AOT != 0 if (reg_module->module->module_type == Wasm_Module_AoT) 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(®istered_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 = wasm_runtime_malloc(sizeof(LoadingModule)); if (!loadingModule) { set_error_buf_v(error_buf, error_buf_size, "malloc LoadingModule failed. SZ=%d", sizeof(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) || !strcmp("spectest", module_name) ); } 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(const 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_AOT != 0 && WASM_ENABLE_JIT != 0 AOTModule *aot_module; WASMModule *module = wasm_load(buf, size, error_buf, error_buf_size); if (!module) return NULL; if (!(aot_module = aot_convert_wasm_module(module, error_buf, error_buf_size))) { wasm_unload(module); return NULL; } module_common = (WASMModuleCommon*)aot_module; return register_module_with_null_name(module_common, error_buf, error_buf_size); #elif 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_t error_buf_size) { WASMModuleCommon *module_common; #if WASM_ENABLE_INTERP != 0 if (!is_aot) { 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 #if WASM_ENABLE_AOT != 0 if (is_aot) { 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 set_error_buf(error_buf, error_buf_size, "WASM module load failed: invalid section list type"); return NULL; } 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(WASMModuleCommon *module, 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, 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, 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; } void wasm_runtime_deinstantiate(WASMModuleInstanceCommon *module_inst) { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) { wasm_deinstantiate((WASMModuleInstance*)module_inst); return; } #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) { aot_deinstantiate((AOTModuleInstance*)module_inst); return; } #endif } 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); } WASMModuleInstanceCommon * wasm_runtime_get_module_inst(WASMExecEnv *exec_env) { return wasm_exec_env_get_module_inst(exec_env); } 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; } 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; } bool wasm_runtime_call_wasm(WASMExecEnv *exec_env, WASMFunctionInstanceCommon *function, uint32 argc, uint32 argv[]) { if (!wasm_runtime_exec_env_check(exec_env)) { LOG_ERROR("Invalid exec env stack info."); return false; } /* set thread handle and stack boundary */ wasm_exec_env_set_thread_info(exec_env); #if WASM_ENABLE_INTERP != 0 if (exec_env->module_inst->module_type == Wasm_Module_Bytecode) return wasm_call_function(exec_env, (WASMFunctionInstance*)function, argc, argv); #endif #if WASM_ENABLE_AOT != 0 if (exec_env->module_inst->module_type == Wasm_Module_AoT) return aot_call_function(exec_env, (AOTFunctionInstance*)function, argc, argv); #endif return false; } bool wasm_runtime_create_exec_env_and_call_wasm(WASMModuleInstanceCommon *module_inst, WASMFunctionInstanceCommon *function, uint32 argc, uint32 argv[]) { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) return wasm_create_exec_env_and_call_function( (WASMModuleInstance*)module_inst, (WASMFunctionInstance*)function, argc, argv); #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) return aot_create_exec_env_and_call_function( (AOTModuleInstance*)module_inst, (AOTFunctionInstance*)function, argc, argv); #endif return false; } void wasm_runtime_set_exception(WASMModuleInstanceCommon *module_inst, const char *exception) { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) { wasm_set_exception((WASMModuleInstance*)module_inst, exception); return; } #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) { aot_set_exception((AOTModuleInstance*)module_inst, exception); return; } #endif } const char* wasm_runtime_get_exception(WASMModuleInstanceCommon *module_inst) { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) { return wasm_get_exception((WASMModuleInstance*)module_inst); } #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) { return aot_get_exception((AOTModuleInstance*)module_inst); } #endif return NULL; } void wasm_runtime_clear_exception(WASMModuleInstanceCommon *module_inst) { wasm_runtime_set_exception(module_inst, NULL); } void wasm_runtime_set_custom_data(WASMModuleInstanceCommon *module_inst, void *custom_data) { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) { ((WASMModuleInstance*)module_inst)->custom_data = custom_data; return; } #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) { ((AOTModuleInstance*)module_inst)->custom_data.ptr = custom_data; return; } #endif } void* wasm_runtime_get_custom_data(WASMModuleInstanceCommon *module_inst) { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) return ((WASMModuleInstance*)module_inst)->custom_data; #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) return ((AOTModuleInstance*)module_inst)->custom_data.ptr; #endif return NULL; } int32 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; } void wasm_runtime_module_free(WASMModuleInstanceCommon *module_inst, int32 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 } int32 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; } bool wasm_runtime_validate_app_addr(WASMModuleInstanceCommon *module_inst, int32 app_offset, uint32 size) { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) return wasm_validate_app_addr((WASMModuleInstance*)module_inst, app_offset, size); #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) return aot_validate_app_addr((AOTModuleInstance*)module_inst, app_offset, size); #endif return false; } bool wasm_runtime_validate_app_str_addr(WASMModuleInstanceCommon *module_inst, int32 app_str_offset) { int32 app_end_offset; char *str, *str_end; if (!wasm_runtime_get_app_addr_range(module_inst, app_str_offset, NULL, &app_end_offset)) goto fail; str = wasm_runtime_addr_app_to_native(module_inst, app_str_offset); str_end = str + (app_end_offset - app_str_offset); while (str < str_end && *str != '\0') str++; if (str == str_end) goto fail; return true; fail: wasm_runtime_set_exception(module_inst, "out of bounds memory access"); return false; } bool wasm_runtime_validate_native_addr(WASMModuleInstanceCommon *module_inst, void *native_ptr, uint32 size) { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) return wasm_validate_native_addr((WASMModuleInstance*)module_inst, native_ptr, size); #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) return aot_validate_native_addr((AOTModuleInstance*)module_inst, native_ptr, size); #endif return false; } void * wasm_runtime_addr_app_to_native(WASMModuleInstanceCommon *module_inst, int32 app_offset) { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) return wasm_addr_app_to_native((WASMModuleInstance*)module_inst, app_offset); #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) return aot_addr_app_to_native((AOTModuleInstance*)module_inst, app_offset); #endif return NULL; } int32 wasm_runtime_addr_native_to_app(WASMModuleInstanceCommon *module_inst, void *native_ptr) { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) return wasm_addr_native_to_app((WASMModuleInstance*)module_inst, native_ptr); #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) return aot_addr_native_to_app((AOTModuleInstance*)module_inst, native_ptr); #endif return 0; } bool wasm_runtime_get_app_addr_range(WASMModuleInstanceCommon *module_inst, int32 app_offset, int32 *p_app_start_offset, int32 *p_app_end_offset) { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) return wasm_get_app_addr_range((WASMModuleInstance*)module_inst, app_offset, p_app_start_offset, p_app_end_offset); #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) return aot_get_app_addr_range((AOTModuleInstance*)module_inst, app_offset, p_app_start_offset, p_app_end_offset); #endif return false; } bool wasm_runtime_get_native_addr_range(WASMModuleInstanceCommon *module_inst, uint8_t *native_ptr, uint8_t **p_native_start_addr, uint8_t **p_native_end_addr) { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) return wasm_get_native_addr_range((WASMModuleInstance*)module_inst, native_ptr, p_native_start_addr, p_native_end_addr); #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) return aot_get_native_addr_range((AOTModuleInstance*)module_inst, native_ptr, p_native_start_addr, p_native_end_addr); #endif return false; } uint32 wasm_runtime_get_temp_ret(WASMModuleInstanceCommon *module_inst) { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) return ((WASMModuleInstance*)module_inst)->temp_ret; #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) return ((AOTModuleInstance*)module_inst)->temp_ret; #endif return 0; } void wasm_runtime_set_temp_ret(WASMModuleInstanceCommon *module_inst, uint32 temp_ret) { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) { ((WASMModuleInstance*)module_inst)->temp_ret = temp_ret; return; } #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) { ((AOTModuleInstance*)module_inst)->temp_ret = temp_ret; return; } #endif } uint32 wasm_runtime_get_llvm_stack(WASMModuleInstanceCommon *module_inst) { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) return ((WASMModuleInstance*)module_inst)->llvm_stack; #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) return ((AOTModuleInstance*)module_inst)->llvm_stack; #endif return 0; } void wasm_runtime_set_llvm_stack(WASMModuleInstanceCommon *module_inst, uint32 llvm_stack) { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) { ((WASMModuleInstance*)module_inst)->llvm_stack = llvm_stack; return; } #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) { ((AOTModuleInstance*)module_inst)->llvm_stack = llvm_stack; return; } #endif } bool wasm_runtime_enlarge_memory(WASMModuleInstanceCommon *module, uint32 inc_page_count) { #if WASM_ENABLE_INTERP != 0 if (module->module_type == Wasm_Module_Bytecode) return wasm_enlarge_memory((WASMModuleInstance*)module, inc_page_count); #endif #if WASM_ENABLE_AOT != 0 if (module->module_type == Wasm_Module_AoT) return aot_enlarge_memory((AOTModuleInstance*)module, inc_page_count); #endif return false; } #if WASM_ENABLE_LIBC_WASI != 0 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) { 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 if (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 = argc; } } 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, char *argv[], uint32 argc, char *error_buf, uint32 error_buf_size) { WASIContext *wasi_ctx; size_t *argv_offsets = NULL; char *argv_buf = NULL; size_t *env_offsets = NULL; char *env_buf = NULL; uint64 argv_buf_len = 0, env_buf_len = 0; uint32 argv_buf_offset = 0, env_buf_offset = 0; struct fd_table *curfds; struct fd_prestats *prestats; struct argv_environ_values *argv_environ; int32 offset_argv_offsets = 0, offset_env_offsets = 0; int32 offset_argv_buf = 0, offset_env_buf = 0; int32 offset_curfds = 0; int32 offset_prestats = 0; int32 offset_argv_environ = 0; __wasi_fd_t wasm_fd = 3; int32 raw_fd; char *path, resolved_path[PATH_MAX]; uint64 total_size; uint32 i; if (!(wasi_ctx = wasm_runtime_malloc(sizeof(WASIContext)))) { set_error_buf(error_buf, error_buf_size, "Init wasi environment failed: allocate memory failed."); return false; } memset(wasi_ctx, 0, sizeof(WASIContext)); wasm_runtime_set_wasi_ctx(module_inst, wasi_ctx); #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode && !((WASMModuleInstance*)module_inst)->default_memory) return true; #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT && !((AOTModuleInstance*)module_inst)->memory_data.ptr) return true; #endif /* process argv[0], trip the path and suffix, only keep the program name */ for (i = 0; i < argc; i++) argv_buf_len += strlen(argv[i]) + 1; total_size = sizeof(size_t) * (uint64)argc; if (total_size >= UINT32_MAX || !(offset_argv_offsets = wasm_runtime_module_malloc (module_inst, (uint32)total_size, (void**)&argv_offsets)) || argv_buf_len >= UINT32_MAX || !(offset_argv_buf = wasm_runtime_module_malloc (module_inst, (uint32)argv_buf_len, (void**)&argv_buf))) { set_error_buf(error_buf, error_buf_size, "Init wasi environment failed: allocate memory failed."); goto fail; } for (i = 0; i < argc; i++) { argv_offsets[i] = argv_buf_offset; bh_strcpy_s(argv_buf + argv_buf_offset, (uint32)argv_buf_len - argv_buf_offset, argv[i]); argv_buf_offset += (uint32)(strlen(argv[i]) + 1); } for (i = 0; i < env_count; i++) env_buf_len += strlen(env[i]) + 1; total_size = sizeof(size_t) * (uint64)argc; if (total_size >= UINT32_MAX || !(offset_env_offsets = wasm_runtime_module_malloc (module_inst, (uint32)total_size, (void**)&env_offsets)) || env_buf_len >= UINT32_MAX || !(offset_env_buf = wasm_runtime_module_malloc (module_inst, (uint32)env_buf_len, (void**)&env_buf))) { set_error_buf(error_buf, error_buf_size, "Init wasi environment failed: allocate memory failed."); goto fail; } for (i = 0; i < env_count; i++) { env_offsets[i] = env_buf_offset; bh_strcpy_s(env_buf + env_buf_offset, (uint32)env_buf_len - env_buf_offset, env[i]); env_buf_offset += (uint32)(strlen(env[i]) + 1); } if (!(offset_curfds = wasm_runtime_module_malloc (module_inst, sizeof(struct fd_table), (void**)&curfds)) || !(offset_prestats = wasm_runtime_module_malloc (module_inst, sizeof(struct fd_prestats), (void**)&prestats)) || !(offset_argv_environ = wasm_runtime_module_malloc (module_inst, sizeof(struct argv_environ_values), (void**)&argv_environ))) { set_error_buf(error_buf, error_buf_size, "Init wasi environment failed: allocate memory failed."); goto fail; } wasi_ctx->curfds_offset = offset_curfds; wasi_ctx->prestats_offset = offset_prestats; wasi_ctx->argv_environ_offset = offset_argv_environ; fd_table_init(curfds); fd_prestats_init(prestats); if (!argv_environ_init(argv_environ, argv_offsets, argc, argv_buf, argv_buf_len, env_offsets, env_count, env_buf, env_buf_len)) { set_error_buf(error_buf, error_buf_size, "Init wasi environment failed: " "init argument environment failed."); goto fail; } /* Prepopulate curfds with stdin, stdout, and stderr file descriptors. */ if (!fd_table_insert_existing(curfds, 0, 0) || !fd_table_insert_existing(curfds, 1, 1) || !fd_table_insert_existing(curfds, 2, 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); } return true; fail: if (offset_curfds != 0) wasm_runtime_module_free(module_inst, offset_curfds); if (offset_prestats != 0) wasm_runtime_module_free(module_inst, offset_prestats); if (offset_argv_environ != 0) wasm_runtime_module_free(module_inst, offset_argv_environ); if (offset_argv_buf) wasm_runtime_module_free(module_inst, offset_argv_buf); if (offset_argv_offsets) wasm_runtime_module_free(module_inst, offset_argv_offsets); if (offset_env_buf) wasm_runtime_module_free(module_inst, offset_env_buf); if (offset_env_offsets) wasm_runtime_module_free(module_inst, offset_env_offsets); return false; } 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->is_wasi_module) return true; #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT && ((AOTModule*)((AOTModuleInstance*)module_inst)->aot_module.ptr) ->is_wasi_module) 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; AOTModule *module = (AOTModule*)aot_inst->aot_module.ptr; for (i = 0; i < module->export_func_count; i++) { if (!strcmp(module->export_funcs[i].func_name, "_start")) { AOTFuncType *func_type = module->export_funcs[i].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*)&module->export_funcs[i]; } } return NULL; } #endif /* end of WASM_ENABLE_AOT */ return NULL; } void wasm_runtime_destroy_wasi(WASMModuleInstanceCommon *module_inst) { WASIContext *wasi_ctx = wasm_runtime_get_wasi_ctx(module_inst); struct argv_environ_values *argv_environ; struct fd_table *curfds; struct fd_prestats *prestats; if (wasi_ctx) { if (wasi_ctx->argv_environ_offset) { argv_environ = (struct argv_environ_values *) wasm_runtime_addr_app_to_native(module_inst, wasi_ctx->argv_environ_offset); argv_environ_destroy(argv_environ); wasm_runtime_module_free(module_inst, wasi_ctx->argv_environ_offset); } if (wasi_ctx->curfds_offset) { curfds = (struct fd_table *) wasm_runtime_addr_app_to_native(module_inst, wasi_ctx->curfds_offset); fd_table_destroy(curfds); wasm_runtime_module_free(module_inst, wasi_ctx->curfds_offset); } if (wasi_ctx->prestats_offset) { prestats = (struct fd_prestats *) wasm_runtime_addr_app_to_native(module_inst, wasi_ctx->prestats_offset); fd_prestats_destroy(prestats); wasm_runtime_module_free(module_inst, wasi_ctx->prestats_offset); } wasm_runtime_free(wasi_ctx); } } WASIContext * wasm_runtime_get_wasi_ctx(WASMModuleInstanceCommon *module_inst) { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) return ((WASMModuleInstance*)module_inst)->wasi_ctx; #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) return ((AOTModuleInstance*)module_inst)->wasi_ctx.ptr; #endif return NULL; } void wasm_runtime_set_wasi_ctx(WASMModuleInstanceCommon *module_inst, WASIContext *wasi_ctx) { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) ((WASMModuleInstance*)module_inst)->wasi_ctx = wasi_ctx; #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) ((AOTModuleInstance*)module_inst)->wasi_ctx.ptr = wasi_ctx; #endif } #endif /* end of WASM_ENABLE_LIBC_WASI */ /** * Implementation of wasm_application_execute_main() */ static WASMFunctionInstanceCommon * resolve_main_function(const WASMModuleInstanceCommon *module_inst) { uint32 i; #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) { WASMModuleInstance *wasm_inst = (WASMModuleInstance*)module_inst; for (i = 0; i < wasm_inst->export_func_count; i++) { if (!strcmp(wasm_inst->export_functions[i].name, "_main") || !strcmp(wasm_inst->export_functions[i].name, "main")) return (WASMFunctionInstanceCommon*) wasm_inst->export_functions[i].function; } LOG_ERROR("WASM execute application failed: main function not found.\n"); return NULL; } #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) { AOTModuleInstance *aot_inst = (AOTModuleInstance*)module_inst; AOTModule *module = (AOTModule*)aot_inst->aot_module.ptr; for (i = 0; i < module->export_func_count; i++) { if (!strcmp(module->export_funcs[i].func_name, "_main") || !strcmp(module->export_funcs[i].func_name, "main")) return (WASMFunctionInstanceCommon*)&module->export_funcs[i]; } LOG_ERROR("WASM execute application failed: main function not found.\n"); return NULL; } #endif return NULL; } static bool check_main_func_type(const WASMType *type) { if (!(type->param_count == 0 || type->param_count == 2) ||type->result_count > 1) { LOG_ERROR("WASM execute application failed: invalid main function type.\n"); return false; } if (type->param_count == 2 && !(type->types[0] == VALUE_TYPE_I32 && type->types[1] == VALUE_TYPE_I32)) { LOG_ERROR("WASM execute application failed: invalid main function type.\n"); return false; } if (type->result_count && type->types[type->param_count] != VALUE_TYPE_I32) { LOG_ERROR("WASM execute application failed: invalid main function type.\n"); return false; } return true; } bool wasm_application_execute_main(WASMModuleInstanceCommon *module_inst, int32 argc, char *argv[]) { WASMFunctionInstanceCommon *func; WASMType *func_type = NULL; uint32 argc1 = 0, argv1[2] = { 0 }; uint32 total_argv_size = 0; uint64 total_size; int32 argv_buf_offset, i; char *argv_buf, *p, *p_end; int32 *argv_offsets; #if WASM_ENABLE_LIBC_WASI != 0 if (wasm_runtime_is_wasi_mode(module_inst)) { /* In wasi mode, we should call function named "_start" which initializes the wasi envrionment and then calls the actual main function. Directly call main function may cause exception thrown. */ if ((func = wasm_runtime_lookup_wasi_start_function(module_inst))) return wasm_runtime_create_exec_env_and_call_wasm( module_inst, func, 0, NULL); /* if no start function is found, we execute the main function as normal */ } #endif /* end of WASM_ENABLE_LIBC_WASI */ func = resolve_main_function(module_inst); if (!func) { wasm_runtime_set_exception(module_inst, "lookup main function failed."); return false; } #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) { if (((WASMFunctionInstance*)func)->is_import_func) { wasm_runtime_set_exception(module_inst, "lookup main function failed."); return false; } func_type = ((WASMFunctionInstance*)func)->u.func->func_type; } #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) func_type = ((AOTFunctionInstance*)func)->func_type; #endif if (!check_main_func_type(func_type)) { wasm_runtime_set_exception(module_inst, "invalid function type of main function."); return false; } if (func_type->param_count) { for (i = 0; i < argc; i++) total_argv_size += (uint32)(strlen(argv[i]) + 1); total_argv_size = align_uint(total_argv_size, 4); total_size = (uint64)total_argv_size + sizeof(int32) * (uint64)argc; if (total_size >= UINT32_MAX || !(argv_buf_offset = wasm_runtime_module_malloc(module_inst, (uint32)total_size, (void**)&argv_buf))) { wasm_runtime_set_exception(module_inst, "allocate memory failed."); return false; } p = argv_buf; argv_offsets = (int32*)(p + total_argv_size); p_end = p + total_size; for (i = 0; i < argc; i++) { bh_memcpy_s(p, (uint32)(p_end - p), argv[i], (uint32)(strlen(argv[i]) + 1)); argv_offsets[i] = argv_buf_offset + (int32)(p - argv_buf); p += strlen(argv[i]) + 1; } argc1 = 2; argv1[0] = (uint32)argc; argv1[1] = (uint32)wasm_runtime_addr_native_to_app(module_inst, argv_offsets); } return wasm_runtime_create_exec_env_and_call_wasm(module_inst, func, argc1, argv1); } #if WASM_ENABLE_MULTI_MODULE != 0 static WASMModuleInstance * get_sub_module_inst(const WASMModuleInstance *parent_module_inst, const char *sub_module_name) { WASMSubModInstNode *node = bh_list_first_elem(parent_module_inst->sub_module_inst_list); while (node && strcmp(node->module_name, sub_module_name)) { node = bh_list_elem_next(node); } return node ? node->module_inst : NULL; } static bool parse_function_name(char *orig_function_name, char **p_module_name, char **p_function_name) { if (orig_function_name[0] != '$') { *p_module_name = NULL; *p_function_name = orig_function_name; return true; } /** * $module_name$function_name\0 * ===> * module_name\0function_name\0 * ===> * module_name * function_name */ char *p1 = orig_function_name; char *p2 = strchr(p1 + 1, '$'); if (!p2) { LOG_DEBUG("can not parse the incoming function name"); return false; } *p_module_name = p1 + 1; *p2 = '\0'; *p_function_name = p2 + 1; return strlen(*p_module_name) && strlen(*p_function_name); } #endif /** * Implementation of wasm_application_execute_func() */ static WASMFunctionInstanceCommon* resolve_function(const WASMModuleInstanceCommon *module_inst, const char *name) { uint32 i = 0; WASMFunctionInstanceCommon *ret = NULL; #if WASM_ENABLE_MULTI_MODULE != 0 WASMModuleInstance *sub_module_inst = NULL; char *orig_name = NULL; char *sub_module_name = NULL; char *function_name = NULL; uint32 length = strlen(name) + 1; orig_name = wasm_runtime_malloc(sizeof(char) * length); if (!orig_name) { return NULL; } memset(orig_name, 0, sizeof(char) * length); strncpy(orig_name, name, length); if (!parse_function_name(orig_name, &sub_module_name, &function_name)) { goto LEAVE; } LOG_DEBUG("%s -> %s and %s", name, sub_module_name, function_name); if (sub_module_name) { sub_module_inst = get_sub_module_inst( (WASMModuleInstance *)module_inst, sub_module_name); if (!sub_module_inst) { LOG_DEBUG("can not find a sub module named %s", sub_module_name); goto LEAVE; } } #else const char *function_name = name; #endif #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) { WASMModuleInstance *wasm_inst = (WASMModuleInstance*)module_inst; #if WASM_ENABLE_MULTI_MODULE != 0 wasm_inst = sub_module_inst ? sub_module_inst : wasm_inst; #endif /* WASM_ENABLE_MULTI_MODULE */ for (i = 0; i < wasm_inst->export_func_count; i++) { if (!strcmp(wasm_inst->export_functions[i].name, function_name)) { ret = wasm_inst->export_functions[i].function; break; } } } #endif /* WASM_ENABLE_INTERP */ #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) { AOTModuleInstance *aot_inst = (AOTModuleInstance*)module_inst; AOTModule *module = (AOTModule*)aot_inst->aot_module.ptr; for (i = 0; i < module->export_func_count; i++) { if (!strcmp(module->export_funcs[i].func_name, function_name)) { ret = (WASMFunctionInstance*)&module->export_funcs[i]; break; } } } #endif #if WASM_ENABLE_MULTI_MODULE != 0 LEAVE: wasm_runtime_free(orig_name); #endif return ret; } union ieee754_float { float f; /* This is the IEEE 754 single-precision format. */ union { struct { unsigned int negative:1; unsigned int exponent:8; unsigned int mantissa:23; } ieee_big_endian; struct { unsigned int mantissa:23; unsigned int exponent:8; unsigned int negative:1; } ieee_little_endian; } ieee; }; union ieee754_double { double d; /* This is the IEEE 754 double-precision format. */ union { struct { unsigned int negative:1; unsigned int exponent:11; /* Together these comprise the mantissa. */ unsigned int mantissa0:20; unsigned int mantissa1:32; } ieee_big_endian; struct { /* Together these comprise the mantissa. */ unsigned int mantissa1:32; unsigned int mantissa0:20; unsigned int exponent:11; unsigned int negative:1; } ieee_little_endian; } ieee; }; static union { int a; char b; } __ue = { .a = 1 }; #define is_little_endian() (__ue.b == 1) bool wasm_application_execute_func(WASMModuleInstanceCommon *module_inst, const char *name, int32 argc, char *argv[]) { WASMFunctionInstanceCommon *func; WASMType *type = NULL; uint32 argc1, *argv1 = NULL; int32 i, p; uint64 total_size; const char *exception; char buf[128]; bh_assert(argc >= 0); LOG_DEBUG("call a function \"%s\" with %d arguments", name, argc); func = resolve_function(module_inst, name); if (!func) { snprintf(buf, sizeof(buf), "lookup function %s failed.", name); wasm_runtime_set_exception(module_inst, buf); goto fail; } #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) { WASMFunctionInstance *wasm_func = (WASMFunctionInstance*)func; if (wasm_func->is_import_func #if WASM_ENABLE_MULTI_MODULE != 0 && !wasm_func->import_func_inst #endif ) { snprintf(buf, sizeof(buf), "lookup function %s failed.", name); wasm_runtime_set_exception(module_inst, buf); goto fail; } type = wasm_func->u.func->func_type; argc1 = wasm_func->param_cell_num; } #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) { type = ((AOTFunctionInstance*)func)->func_type; argc1 = wasm_type_param_cell_num(type); } #endif if (type->param_count != (uint32)argc) { wasm_runtime_set_exception(module_inst, "invalid input argument count."); goto fail; } total_size = sizeof(uint32) * (uint64)(argc1 > 2 ? argc1 : 2); if (total_size >= UINT32_MAX || (!(argv1 = wasm_runtime_malloc((uint32)total_size)))) { wasm_runtime_set_exception(module_inst, "allocate memory failed."); goto fail; } /* Clear errno before parsing arguments */ errno = 0; /* Parse arguments */ for (i = 0, p = 0; i < argc; i++) { char *endptr = NULL; bh_assert(argv[i] != NULL); if (argv[i][0] == '\0') { snprintf(buf, sizeof(buf), "invalid input argument %d.", i); wasm_runtime_set_exception(module_inst, buf); goto fail; } switch (type->types[i]) { case VALUE_TYPE_I32: argv1[p++] = (uint32)strtoul(argv[i], &endptr, 0); break; case VALUE_TYPE_I64: { union { uint64 val; uint32 parts[2]; } u; u.val = strtoull(argv[i], &endptr, 0); argv1[p++] = u.parts[0]; argv1[p++] = u.parts[1]; break; } case VALUE_TYPE_F32: { float32 f32 = strtof(argv[i], &endptr); if (isnan(f32)) { if (argv[i][0] == '-') { union ieee754_float u; u.f = f32; if (is_little_endian()) u.ieee.ieee_little_endian.negative = 1; else u.ieee.ieee_big_endian.negative = 1; memcpy(&f32, &u.f, sizeof(float)); } if (endptr[0] == ':') { uint32 sig; union ieee754_float u; sig = (uint32)strtoul(endptr + 1, &endptr, 0); u.f = f32; if (is_little_endian()) u.ieee.ieee_little_endian.mantissa = sig; else u.ieee.ieee_big_endian.mantissa = sig; memcpy(&f32, &u.f, sizeof(float)); } } memcpy(&argv1[p++], &f32, sizeof(float)); break; } case VALUE_TYPE_F64: { union { float64 val; uint32 parts[2]; } u; u.val = strtod(argv[i], &endptr); if (isnan(u.val)) { if (argv[i][0] == '-') { union ieee754_double ud; ud.d = u.val; if (is_little_endian()) ud.ieee.ieee_little_endian.negative = 1; else ud.ieee.ieee_big_endian.negative = 1; memcpy(&u.val, &ud.d, sizeof(double)); } if (endptr[0] == ':') { uint64 sig; union ieee754_double ud; sig = strtoull(endptr + 1, &endptr, 0); ud.d = u.val; if (is_little_endian()) { ud.ieee.ieee_little_endian.mantissa0 = sig >> 32; ud.ieee.ieee_little_endian.mantissa1 = (uint32)sig; } else { ud.ieee.ieee_big_endian.mantissa0 = sig >> 32; ud.ieee.ieee_big_endian.mantissa1 = (uint32)sig; } memcpy(&u.val, &ud.d, sizeof(double)); } } argv1[p++] = u.parts[0]; argv1[p++] = u.parts[1]; break; } } if (endptr && *endptr != '\0' && *endptr != '_') { snprintf(buf, sizeof(buf), "invalid input argument %d: %s.", i, argv[i]); wasm_runtime_set_exception(module_inst, buf); goto fail; } if (errno != 0) { snprintf(buf, sizeof(buf), "prepare function argument error, errno: %d.", errno); wasm_runtime_set_exception(module_inst, buf); goto fail; } } bh_assert(p == (int32)argc1); wasm_runtime_set_exception(module_inst, NULL); if (!wasm_runtime_create_exec_env_and_call_wasm(module_inst, func, argc1, argv1)) { goto fail; } /* print return value */ if (type->result_count > 0) { switch (type->types[type->param_count]) { case VALUE_TYPE_I32: os_printf("0x%x:i32", argv1[0]); break; case VALUE_TYPE_I64: { union { uint64 val; uint32 parts[2]; } u; u.parts[0] = argv1[0]; u.parts[1] = argv1[1]; #ifdef PRIx64 os_printf("0x%"PRIx64":i64", u.val); #else char buf[16]; if (sizeof(long) == 4) snprintf(buf, sizeof(buf), "%s", "0x%llx:i64"); else snprintf(buf, sizeof(buf), "%s", "0x%lx:i64"); os_printf(buf, u.val); #endif break; } case VALUE_TYPE_F32: os_printf("%.7g:f32", *(float32*)argv1); break; case VALUE_TYPE_F64: { union { float64 val; uint32 parts[2]; } u; u.parts[0] = argv1[0]; u.parts[1] = argv1[1]; os_printf("%.7g:f64", u.val); break; } } } os_printf("\n"); wasm_runtime_free(argv1); return true; fail: if (argv1) wasm_runtime_free(argv1); exception = wasm_runtime_get_exception(module_inst); bh_assert(exception); os_printf("%s\n", exception); return false; } 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_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; int32 arg_i32; bool ret = false; argc1 = func_type->param_count; if (argc1 > sizeof(argv_buf) / sizeof(uint64)) { size = sizeof(uint64) * (uint64)argc1; if (size >= UINT32_MAX || !(argv1 = wasm_runtime_malloc((uint32)size))) { wasm_runtime_set_exception(exec_env->module_inst, "allocate memory failed."); return false; } memset(argv1, 0, (uint32)size); } 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: { *(int32*)argv_dst = arg_i32 = (int32)*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; 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: 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; default: bh_assert(0); break; } } ret = true; fail: if (argv1 != argv_buf) wasm_runtime_free(argv1); return ret; } /** * Implementation of wasm_runtime_invoke_native() */ static inline void word_copy(uint32 *dest, uint32 *src, unsigned num) { for (; num > 0; num--) *dest++ = *src++; } #define PUT_I64_TO_ADDR(addr, value) do { \ union { int64 val; uint32 parts[2]; } u; \ u.val = (value); \ (addr)[0] = u.parts[0]; \ (addr)[1] = u.parts[1]; \ } while (0) #define PUT_F64_TO_ADDR(addr, value) do { \ union { float64 val; uint32 parts[2]; } u; \ u.val = (value); \ (addr)[0] = u.parts[0]; \ (addr)[1] = u.parts[1]; \ } while (0) /* The invoke native implementation on ARM platform with VFP co-processor */ #if defined(BUILD_TARGET_ARM_VFP) || defined(BUILD_TARGET_THUMB_VFP) typedef void (*GenericFunctionPointer)(); int64 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 Float64FuncPtr invokeNative_Float64 = (Float64FuncPtr)invokeNative; static Float32FuncPtr invokeNative_Float32 = (Float32FuncPtr)invokeNative; static Int64FuncPtr invokeNative_Int64 = (Int64FuncPtr)invokeNative; static Int32FuncPtr invokeNative_Int32 = (Int32FuncPtr)invokeNative; static VoidFuncPtr invokeNative_Void = (VoidFuncPtr)invokeNative; #define MAX_REG_INTS 4 #define MAX_REG_FLOATS 16 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, *fps, *ints, *stacks, size; uint32 *argv_src = argv, i, argc1, n_ints = 0, n_fps = 0, n_stacks = 0; uint32 arg_i32, ptr_len; bool ret = false; 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 (n_ints < MAX_REG_INTS) n_ints++; else n_stacks++; break; case VALUE_TYPE_I64: if (n_ints < MAX_REG_INTS - 1) { /* 64-bit data must be 8 bytes aligned in arm */ if (n_ints & 1) n_ints++; n_ints += 2; } else { /* 64-bit data must be 8 bytes aligned in arm */ if (n_stacks & 1) n_stacks++; n_stacks += 2; } break; 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) { /* 64-bit data must be 8 bytes aligned in arm */ if (n_fps & 1) n_fps++; n_fps += 2; } else { /* 64-bit data must be 8 bytes aligned in arm */ if (n_stacks & 1) n_stacks++; n_stacks += 2; } break; default: bh_assert(0); break; } } argc1 = MAX_REG_INTS + MAX_REG_FLOATS + n_stacks; if (argc1 > sizeof(argv_buf) / sizeof(uint32)) { size = sizeof(uint32) * (uint32)argc1; if (size >= UINT32_MAX || !(argv1 = wasm_runtime_malloc((uint32)size))) { wasm_runtime_set_exception(exec_env->module_inst, "allocate memory failed."); return false; } } ints = argv1; fps = ints + MAX_REG_INTS; stacks = fps + MAX_REG_FLOATS; 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: { 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) { /* 64-bit data must be 8 bytes aligned in arm */ if (n_ints & 1) n_ints++; *(uint64*)&ints[n_ints] = *(uint64*)argv_src; n_ints += 2; } else { /* 64-bit data must be 8 bytes aligned in arm */ if (n_stacks & 1) n_stacks++; *(uint64*)&stacks[n_stacks] = *(uint64*)argv_src; n_stacks += 2; } 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 - 1) { /* 64-bit data must be 8 bytes aligned in arm */ if (n_fps & 1) n_fps++; *(float64*)&fps[n_fps] = *(float64*)argv_src; n_fps += 2; } else { /* 64-bit data must be 8 bytes aligned in arm */ if (n_stacks & 1) n_stacks++; *(float64*)&stacks[n_stacks] = *(float64*)argv_src; n_stacks += 2; } argv_src += 2; break; default: bh_assert(0); break; } } 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: 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; default: bh_assert(0); break; } } exec_env->attachment = NULL; ret = true; fail: if (argv1 != argv_buf) wasm_runtime_free(argv1); return ret; } #endif /* end of defined(BUILD_TARGET_ARM_VFP) || defined(BUILD_TARGET_THUMB_VFP) */ #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)(); int64 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 Int64FuncPtr invokeNative_Int64 = (Int64FuncPtr)invokeNative; static Int32FuncPtr invokeNative_Int32 = (Int32FuncPtr)invokeNative; static Float64FuncPtr invokeNative_Float64 = (Float64FuncPtr)invokeNative; static Float32FuncPtr invokeNative_Float32 = (Float32FuncPtr)invokeNative; static VoidFuncPtr invokeNative_Void = (VoidFuncPtr)invokeNative; 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; uint64 size; bool ret = false; #if defined(BUILD_TARGET_X86_32) argc1 = argc + 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 + 2; #endif if (argc1 > sizeof(argv_buf) / sizeof(uint32)) { size = sizeof(uint32) * (uint64)argc1; if (size >= UINT_MAX || !(argv1 = wasm_runtime_malloc((uint32)size))) { wasm_runtime_set_exception(exec_env->module_inst, "allocate memory failed."); 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: { 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; default: bh_assert(0); break; } } argc1 = j; 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: 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; default: bh_assert(0); break; } } exec_env->attachment = NULL; ret = true; 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) typedef void (*GenericFunctionPointer)(); int64 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 Float64FuncPtr invokeNative_Float64 = (Float64FuncPtr)(uintptr_t)invokeNative; static Float32FuncPtr invokeNative_Float32 = (Float32FuncPtr)(uintptr_t)invokeNative; static Int64FuncPtr invokeNative_Int64 = (Int64FuncPtr)(uintptr_t)invokeNative; static Int32FuncPtr invokeNative_Int32 = (Int32FuncPtr)(uintptr_t)invokeNative; static VoidFuncPtr invokeNative_Void = (VoidFuncPtr)(uintptr_t)invokeNative; #if defined(_WIN32) || defined(_WIN32_) #define MAX_REG_FLOATS 4 #define MAX_REG_INTS 4 #else #define MAX_REG_FLOATS 8 #if defined(BUILD_TARGET_AARCH64) #define MAX_REG_INTS 8 #else #define MAX_REG_INTS 6 #endif /* end of defined(BUILD_TARGET_AARCH64 */ #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], *argv1 = argv_buf, *fps, *ints, *stacks, size, arg_i64; uint32 *argv_src = argv, i, argc1, n_ints = 0, n_stacks = 0; uint32 arg_i32, ptr_len; bool ret = false; #if defined(_WIN32) || defined(_WIN32_) /* important difference in calling conventions */ #define n_fps n_ints #else int n_fps = 0; #endif argc1 = 1 + MAX_REG_FLOATS + func_type->param_count + 2; if (argc1 > sizeof(argv_buf) / sizeof(uint64)) { size = sizeof(uint64) * (uint64)argc1; if (size >= UINT32_MAX || !(argv1 = wasm_runtime_malloc((uint32)size))) { wasm_runtime_set_exception(exec_env->module_inst, "allocate memory failed."); return false; } } fps = argv1; ints = fps + MAX_REG_FLOATS; 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: { 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; default: bh_assert(0); break; } } 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: 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; default: bh_assert(0); break; } } exec_env->attachment = NULL; ret = true; fail: if (argv1 != argv_buf) wasm_runtime_free(argv1); return ret; } bool wasm_runtime_call_indirect(WASMExecEnv *exec_env, uint32_t element_indices, uint32_t argc, uint32_t argv[]) { 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) return wasm_call_indirect(exec_env, element_indices, argc, argv); #endif #if WASM_ENABLE_AOT != 0 if (exec_env->module_inst->module_type == Wasm_Module_AoT) return aot_call_indirect(exec_env, false, 0, element_indices, argc, argv); #endif return false; } #endif /* end of defined(BUILD_TARGET_X86_64) \ || defined(BUILD_TARGET_AMD_64) \ || defined(BUILD_TARGET_AARCH64) */