gnh1201/wasm-micro-runtime
1
0
Fork 0
mirror of https://github.com/bytecodealliance/wasm-micro-runtime.git synced 2025-05-08 20:56:13 +00:00
Code Issues Actions 9 Packages Projects Releases Wiki Activity

Refactor error/exception strings to reduce binary size (#359)

Browse Source
This commit is contained in:
Wenyong Huang 2020-08-21 15:11:31 +08:00 committed by GitHub
parent 89d2937cde
commit 0103f6429c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 321 additions and 505 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

166
core/iwasm/aot/aot_loader.c
View File

@ -19,8 +19,26 @@
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);
if (error_buf != NULL) {
snprintf(error_buf, error_buf_size,
"AOT module load failed: %s", string);
}
}
static void
set_error_buf_v(char *error_buf, uint32 error_buf_size,
const char *format, ...)
{
va_list args;
char buf[128];
if (error_buf != NULL) {
va_start(args, format);
vsnprintf(buf, sizeof(buf), format, args);
va_end(args);
snprintf(error_buf, error_buf_size,
"AOT module load failed: %s", buf);
}
}
#define exchange_uint8(p_data) (void)0
@ -64,8 +82,7 @@ check_buf(const uint8 *buf, const uint8 *buf_end, uint32 length,
char *error_buf, uint32 error_buf_size)
{
if (buf + length > buf_end) {
set_error_buf(error_buf, error_buf_size,
"AOT module load failed: unexpect end.");
set_error_buf(error_buf, error_buf_size, "unexpect end");
return false;
}
return true;
@ -169,8 +186,7 @@ loader_malloc(uint64 size, char *error_buf, uint32 error_buf_size)
if (size >= UINT32_MAX
|| !(mem = wasm_runtime_malloc((uint32)size))) {
set_error_buf(error_buf, error_buf_size,
"AOT module load failed: "
"allocate memory failed.");
"allocate memory failed");
return NULL;
}
@ -200,8 +216,7 @@ const_str_set_insert(const uint8 *str, int32 len, AOTModule *module,
if (!bh_hash_map_insert(set, c_str, c_str)) {
set_error_buf(error_buf, error_buf_size,
"AOT module load failed: "
"insert string to hash map failed.");
"insert string to hash map failed");
wasm_runtime_free(c_str);
return NULL;
}
@ -233,18 +248,15 @@ get_aot_file_target(AOTTargetInfo *target_info,
machine_type = "xtensa";
break;
default:
if (error_buf)
snprintf(error_buf, error_buf_size,
"AOT module load failed: unknown machine type %d.",
target_info->e_machine);
set_error_buf_v(error_buf, error_buf_size,
"unknown machine type %d",
target_info->e_machine);
return false;
}
if (strncmp(target_info->arch, machine_type, strlen(machine_type))) {
if (error_buf)
snprintf(error_buf, error_buf_size,
"AOT module load failed: "
"machine type (%s) isn't consistent with target type (%s).",
machine_type, target_info->arch);
set_error_buf_v(error_buf, error_buf_size,
"machine type (%s) isn't consistent with target type (%s)",
machine_type, target_info->arch);
return false;
}
snprintf(target_buf, target_buf_size, "%s", target_info->arch);
@ -264,12 +276,9 @@ check_machine_info(AOTTargetInfo *target_info,
return false;
if (strcmp(target_expected, target_got)) {
if (error_buf) {
snprintf(error_buf, error_buf_size,
"AOT module load failed: invalid target type, "
"expected %s but got %s.",
target_expected, target_got);
}
set_error_buf_v(error_buf, error_buf_size,
"invalid target type, expected %s but got %s",
target_expected, target_got);
return false;
}
@ -297,39 +306,35 @@ load_target_info_section(const uint8 *buf, const uint8 *buf_end,
if (p != buf_end) {
set_error_buf(error_buf, error_buf_size,
"AOT module load failed: invalid section size.");
"invalid section size");
return false;
}
/* Check target endian type */
is_target_little_endian = target_info.bin_type & 1 ? false : true;
if (is_little_endian() != is_target_little_endian) {
if (error_buf)
snprintf(error_buf, error_buf_size,
"AOT module load failed: "
"invalid target endian type, expected %s but got %s.",
is_little_endian() ? "little endian" : "big endian",
is_target_little_endian ? "little endian" : "big endian");
set_error_buf_v(error_buf, error_buf_size,
"invalid target endian type, expected %s but got %s",
is_little_endian() ? "little endian" : "big endian",
is_target_little_endian ? "little endian" : "big endian");
return false;
}
/* Check target bit width */
is_target_64_bit = target_info.bin_type & 2 ? true : false;
if ((sizeof(void*) == 8 ? true : false) != is_target_64_bit) {
if (error_buf)
snprintf(error_buf, error_buf_size,
"AOT module load failed: "
"invalid target bit width, expected %s but got %s.",
sizeof(void*) == 8 ? "64-bit" : "32-bit",
is_target_64_bit ? "64-bit" : "32-bit");
set_error_buf_v(error_buf, error_buf_size,
"invalid target bit width, expected %s but got %s",
sizeof(void*) == 8 ? "64-bit" : "32-bit",
is_target_64_bit ? "64-bit" : "32-bit");
return false;
}
/* Check target elf file type */
if (target_info.e_type != E_TYPE_REL) {
set_error_buf(error_buf, error_buf_size,
"AOT module load failed: invalid object file type, "
"expected relocatable file type but got others.");
"invalid object file type, "
"expected relocatable file type but got others");
return false;
}
@ -340,7 +345,7 @@ load_target_info_section(const uint8 *buf, const uint8 *buf_end,
if (target_info.e_version != E_VERSION_CURRENT) {
set_error_buf(error_buf, error_buf_size,
"AOT module load failed: invalid elf file version.");
"invalid elf file version");
return false;
}
@ -639,7 +644,6 @@ load_func_types(const uint8 **p_buf, const uint8 *buf_end,
if (param_count > UINT16_MAX || result_count > UINT16_MAX) {
set_error_buf(error_buf, error_buf_size,
"AOT module load failed: "
"param count or result count too large");
return false;
}
@ -660,7 +664,6 @@ load_func_types(const uint8 **p_buf, const uint8 *buf_end,
result_count);
if (param_cell_num > UINT16_MAX || ret_cell_num > UINT16_MAX) {
set_error_buf(error_buf, error_buf_size,
"AOT module load failed: "
"param count or result count too large");
return false;
}
@ -866,8 +869,7 @@ load_import_funcs(const uint8 **p_buf, const uint8 *buf_end,
for (i = 0; i < module->import_func_count; i++) {
read_uint16(buf, buf_end, import_funcs[i].func_type_index);
if (import_funcs[i].func_type_index >= module->func_type_count) {
set_error_buf(error_buf, error_buf_size,
"AOT module load failed: unknown type.");
set_error_buf(error_buf, error_buf_size, "unknown type");
return false;
}
import_funcs[i].func_type = module->func_types[import_funcs[i].func_type_index];
@ -967,8 +969,7 @@ load_object_data_sections(const uint8 **p_buf, const uint8 *buf_end,
if (!(data_sections[i].data =
os_mmap(NULL, data_sections[i].size, map_prot, map_flags))) {
set_error_buf(error_buf, error_buf_size,
"AOT module load failed: "
"allocate memory failed.");
"allocate memory failed");
return false;
}
#if defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64)
@ -1034,7 +1035,6 @@ load_init_data_section(const uint8 *buf, const uint8 *buf_end,
&& (module->start_func_index >= module->import_func_count
+ module->func_count)) {
set_error_buf(error_buf, error_buf_size,
"AOT module load failed: "
"invalid start function index");
return false;
}
@ -1053,7 +1053,6 @@ load_init_data_section(const uint8 *buf, const uint8 *buf_end,
if (p != p_end) {
set_error_buf(error_buf, error_buf_size,
"AOT module load failed: "
"invalid init data section size");
return false;
}
@ -1073,7 +1072,7 @@ load_text_section(const uint8 *buf, const uint8 *buf_end,
if (module->func_count > 0 && buf_end == buf) {
set_error_buf(error_buf, error_buf_size,
"AOT module load failed: invalid code size.");
"invalid code size");
return false;
}
@ -1120,8 +1119,7 @@ load_function_section(const uint8 *buf, const uint8 *buf_end,
}
if (text_offset >= module->code_size) {
set_error_buf(error_buf, error_buf_size,
"AOT module load failed: "
"invalid function code offset.");
"invalid function code offset");
return false;
}
module->func_ptrs[i] = (uint8*)module->code + text_offset;
@ -1154,15 +1152,13 @@ load_function_section(const uint8 *buf, const uint8 *buf_end,
for (i = 0; i < module->func_count; i++) {
read_uint32(p, p_end, module->func_type_indexes[i]);
if (module->func_type_indexes[i] >= module->func_type_count) {
set_error_buf(error_buf, error_buf_size,
"AOT module load failed: unknown type.");
set_error_buf(error_buf, error_buf_size, "unknown type");
return false;
}
}
if (p != buf_end) {
set_error_buf(error_buf, error_buf_size,
"AOT module load failed: "
"invalid function section size");
return false;
}
@ -1204,8 +1200,7 @@ load_exports(const uint8 **p_buf, const uint8 *buf_end,
if (export_funcs[i].index >=
module->func_count + module->import_func_count) {
set_error_buf(error_buf, error_buf_size,
"AOT module load failed: "
"function index is out of range.");
"function index is out of range");
return false;
}
#endif
@ -1232,7 +1227,6 @@ load_export_section(const uint8 *buf, const uint8 *buf_end,
if (p != p_end) {
set_error_buf(error_buf, error_buf_size,
"AOT module load failed: "
"invalid export section size");
return false;
}
@ -1299,7 +1293,7 @@ do_text_relocation(AOTModule *module,
if (group->relocation_count > 0 && !aot_text) {
set_error_buf(error_buf, error_buf_size,
"AOT module load failed: invalid text relocation count.");
"invalid text relocation count");
return false;
}
@ -1321,11 +1315,8 @@ do_text_relocation(AOTModule *module,
p = symbol + strlen(AOT_FUNC_PREFIX);
if (*p == '\0'
|| (func_index = (uint32)atoi(p)) > module->func_count) {
if (error_buf != NULL)
snprintf(error_buf, error_buf_size,
"AOT module load failed: "
"invalid import symbol %s.",
symbol);
set_error_buf_v(error_buf, error_buf_size,
"invalid import symbol %s", symbol);
goto check_symbol_fail;
}
symbol_addr = module->func_ptrs[func_index];
@ -1339,11 +1330,8 @@ do_text_relocation(AOTModule *module,
|| !strncmp(symbol, ".rodata.cst", strlen(".rodata.cst"))) {
symbol_addr = get_data_section_addr(module, symbol, NULL);
if (!symbol_addr) {
if (error_buf != NULL)
snprintf(error_buf, error_buf_size,
"AOT module load failed: "
"invalid data section (%s).",
symbol);
set_error_buf_v(error_buf, error_buf_size,
"invalid data section (%s)", symbol);
goto check_symbol_fail;
}
}
@ -1351,11 +1339,8 @@ do_text_relocation(AOTModule *module,
symbol_addr = module->literal;
}
else if (!(symbol_addr = resolve_target_sym(symbol, &symbol_index))) {
if (error_buf != NULL)
snprintf(error_buf, error_buf_size,
"AOT module load failed: "
"resolve symbol %s failed.",
symbol);
set_error_buf_v(error_buf, error_buf_size,
"resolve symbol %s failed", symbol);
goto check_symbol_fail;
}
@ -1400,8 +1385,7 @@ do_data_relocation(AOTModule *module,
}
else {
set_error_buf(error_buf, error_buf_size,
"AOT module load failed: "
"invalid data relocation section name.");
"invalid data relocation section name");
return false;
}
@ -1409,7 +1393,7 @@ do_data_relocation(AOTModule *module,
&data_size);
if (group->relocation_count > 0 && !data_addr) {
set_error_buf(error_buf, error_buf_size,
"AOT module load failed: invalid data relocation count.");
"invalid data relocation count");
return false;
}
@ -1419,11 +1403,8 @@ do_data_relocation(AOTModule *module,
symbol_addr = module->code;
}
else {
if (error_buf != NULL)
snprintf(error_buf, error_buf_size,
"AOT module load failed: "
"invalid relocation symbol %s.",
symbol);
set_error_buf_v(error_buf, error_buf_size,
"invalid relocation symbol %s", symbol);
return false;
}
@ -1494,8 +1475,7 @@ load_relocation_section(const uint8 *buf, const uint8 *buf_end,
symbol_offsets, symbol_count,
error_buf, error_buf_size)) {
set_error_buf(error_buf, error_buf_size,
"AOT module load failed: "
"validate symbol table failed.");
"validate symbol table failed");
goto fail;
}
@ -1521,8 +1501,7 @@ load_relocation_section(const uint8 *buf, const uint8 *buf_end,
if (name_index >= symbol_count) {
set_error_buf(error_buf, error_buf_size,
"AOT module load failed: "
"symbol index out of range.");
"symbol index out of range");
goto fail;
}
@ -1568,8 +1547,7 @@ load_relocation_section(const uint8 *buf, const uint8 *buf_end,
if (symbol_index >= symbol_count) {
set_error_buf(error_buf, error_buf_size,
"AOT module load failed: "
"symbol index out of range.");
"symbol index out of range");
goto fail;
}
@ -1630,7 +1608,7 @@ load_from_sections(AOTModule *module, AOTSection *sections,
|| (last_section_type != (uint32)-1
&& section_type != last_section_type + 1)) {
set_error_buf(error_buf, error_buf_size,
"AOT module load failed: invalid section order.");
"invalid section order");
return false;
}
last_section_type = section_type;
@ -1672,7 +1650,7 @@ load_from_sections(AOTModule *module, AOTSection *sections,
if (last_section_type != AOT_SECTION_TYPE_RELOCATION) {
set_error_buf(error_buf, error_buf_size,
"AOT module load failed: section missing.");
"section missing");
return false;
}
@ -1747,8 +1725,7 @@ create_module(char *error_buf, uint32 error_buf_size)
NULL,
aot_free))) {
set_error_buf(error_buf, error_buf_size,
"AOT module load failed: "
"create const string set failed.");
"create const string set failed");
wasm_runtime_free(module);
return NULL;
}
@ -1838,8 +1815,7 @@ create_sections(const uint8 *buf, uint32 size,
map_prot, map_flags))) {
wasm_runtime_free(section);
set_error_buf(error_buf, error_buf_size,
"AOT module load failed: "
"mmap memory failed.");
"mmap memory failed");
goto fail;
}
#if defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64)
@ -1874,14 +1850,14 @@ create_sections(const uint8 *buf, uint32 size,
}
else {
set_error_buf(error_buf, error_buf_size,
"AOT module load failed: invalid section id.");
"invalid section id");
goto fail;
}
}
if (!section_list) {
set_error_buf(error_buf, error_buf_size,
"AOT module load failed: create section list failed.");
"create section list failed");
return false;
}
@ -2032,7 +2008,7 @@ aot_load_from_comp_data(AOTCompData *comp_data, AOTCompContext *comp_ctx,
(void *)LLVMGetFunctionAddress(comp_ctx->exec_engine,
func_name))) {
set_error_buf(error_buf, error_buf_size,
"Get function address fail.");
"get function address failed");
goto fail3;
}
}

38
core/iwasm/aot/aot_runtime.c
View File

@ -13,8 +13,10 @@
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);
if (error_buf != NULL) {
snprintf(error_buf, error_buf_size,
"AOT module instantiate failed: %s", string);
}
}
static void *
@ -25,8 +27,7 @@ runtime_malloc(uint64 size, char *error_buf, uint32 error_buf_size)
if (size >= UINT32_MAX
|| !(mem = wasm_runtime_malloc((uint32)size))) {
set_error_buf(error_buf, error_buf_size,
"AOT module instantiate failed: "
"allocate memory failed.");
"allocate memory failed");
return NULL;
}
@ -60,8 +61,7 @@ global_instantiate(AOTModuleInstance *module_inst, AOTModule *module,
switch (init_expr->init_expr_type) {
case INIT_EXPR_TYPE_GET_GLOBAL:
if (init_expr->u.global_index >= module->import_global_count + i) {
set_error_buf(error_buf, error_buf_size,
"Instantiate global failed: unknown global.");
set_error_buf(error_buf, error_buf_size, "unknown global");
return false;
}
memcpy(p,
@ -333,14 +333,12 @@ memory_instantiate(AOTModuleInstance *module_inst, AOTModule *module,
if (total_size >= UINT32_MAX
|| !(p = mapped_mem = os_mmap(NULL, map_size,
MMAP_PROT_NONE, MMAP_MAP_NONE))) {
set_error_buf(error_buf, error_buf_size,
"AOT module instantiate failed: mmap memory failed.");
set_error_buf(error_buf, error_buf_size, "mmap memory failed");
return NULL;
}
if (os_mprotect(p, total_size, MMAP_PROT_READ | MMAP_PROT_WRITE) != 0) {
set_error_buf(error_buf, error_buf_size,
"AOT module instantiate failed: mprotec memory failed.");
set_error_buf(error_buf, error_buf_size, "mprotec memory failed");
os_munmap(mapped_mem, map_size);
return NULL;
}
@ -364,8 +362,7 @@ memory_instantiate(AOTModuleInstance *module_inst, AOTModule *module,
if (!(heap_handle = mem_allocator_create(memory_inst->heap_data.ptr,
heap_size))) {
set_error_buf(error_buf, error_buf_size,
"AOT module instantiate failed:"
"init app heap failed.");
"init app heap failed");
goto fail1;
}
memory_inst->heap_handle.ptr = heap_handle;
@ -392,8 +389,7 @@ memory_instantiate(AOTModuleInstance *module_inst, AOTModule *module,
if (!shared_memory_set_memory_inst((WASMModuleCommon *)module,
(WASMMemoryInstanceCommon *)memory_inst)) {
set_error_buf(error_buf, error_buf_size,
"Instantiate memory failed:"
"allocate memory failed.");
"allocate memory failed");
goto fail2;
}
}
@ -659,7 +655,7 @@ execute_start_function(AOTModuleInstance *module_inst)
if (!(exec_env = wasm_exec_env_create((WASMModuleInstanceCommon*)module_inst,
module_inst->default_wasm_stack_size))) {
aot_set_exception(module_inst, "allocate memory failed.");
aot_set_exception(module_inst, "allocate memory failed");
return false;
}
@ -988,7 +984,7 @@ invoke_native_with_hw_bound_check(WASMExecEnv *exec_env, void *func_ptr,
if (aot_exec_env
&& (aot_exec_env != exec_env)) {
aot_set_exception(module_inst, "Invalid exec env.");
aot_set_exception(module_inst, "invalid exec env");
return false;
}
@ -999,7 +995,7 @@ invoke_native_with_hw_bound_check(WASMExecEnv *exec_env, void *func_ptr,
/* First time to call aot function, protect one page */
if (os_mprotect(stack_min_addr, page_size * guard_page_count,
MMAP_PROT_NONE) != 0) {
aot_set_exception(module_inst, "Set protected page failed.");
aot_set_exception(module_inst, "set protected page failed");
return false;
}
}
@ -1132,7 +1128,7 @@ aot_create_exec_env_and_call_function(AOTModuleInstance *module_inst,
if (!(exec_env = wasm_exec_env_create((WASMModuleInstanceCommon*)module_inst,
module_inst->default_wasm_stack_size))) {
aot_set_exception(module_inst, "allocate memory failed.");
aot_set_exception(module_inst, "allocate memory failed");
return false;
}
@ -1471,12 +1467,10 @@ aot_enlarge_memory(AOTModuleInstance *module_inst, uint32 inc_page_count)
if (total_page_count < cur_page_count /* integer overflow */
|| total_page_count > max_page_count) {
aot_set_exception(module_inst, "fail to enlarge memory.");
return false;
}
if (total_size >= UINT32_MAX) {
aot_set_exception(module_inst, "fail to enlarge memory.");
return false;
}
@ -1501,7 +1495,6 @@ aot_enlarge_memory(AOTModuleInstance *module_inst, uint32 inc_page_count)
/* Restore heap's lock if memory re-alloc failed */
mem_allocator_reinit_lock(memory_inst->heap_handle.ptr);
}
aot_set_exception(module_inst, "fail to enlarge memory.");
return false;
}
bh_memcpy_s(memory_data, (uint32)total_size,
@ -1522,7 +1515,6 @@ aot_enlarge_memory(AOTModuleInstance *module_inst, uint32 inc_page_count)
+ (memory_data - memory_data_old);
if (mem_allocator_migrate(memory_inst->heap_handle.ptr,
heap_handle_old) != 0) {
aot_set_exception(module_inst, "fail to enlarge memory.");
return false;
}
}
@ -1562,14 +1554,12 @@ aot_enlarge_memory(AOTModuleInstance *module_inst, uint32 inc_page_count)
if (total_page_count < cur_page_count /* integer overflow */
|| total_page_count > max_page_count) {
aot_set_exception(module_inst, "fail to enlarge memory.");
return false;
}
if (os_mprotect(memory_inst->memory_data_end.ptr,
num_bytes_per_page * inc_page_count,
MMAP_PROT_READ | MMAP_PROT_WRITE) != 0) {
aot_set_exception(module_inst, "fail to enlarge memory.");
return false;
}

59
core/iwasm/common/wasm_runtime_common.c
View File

@ -49,16 +49,6 @@ 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)
{
@ -76,11 +66,11 @@ runtime_malloc(uint64 size, WASMModuleInstanceCommon *module_inst,
|| !(mem = wasm_runtime_malloc((uint32)size))) {
if (module_inst != NULL) {
wasm_runtime_set_exception(module_inst,
"allocate memory failed.");
"allocate memory failed");
}
else if (error_buf != NULL) {
set_error_buf(error_buf, error_buf_size,
"allocate memory failed.");
"allocate memory failed");
}
return NULL;
}
@ -308,8 +298,9 @@ wasm_runtime_register_module_internal(const char *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");
set_error_buf(error_buf, error_buf_size,
"Register module failed: "
"failed to rename the module");
return false;
}
else {
@ -359,14 +350,16 @@ wasm_runtime_register_module(const char *module_name, WASMModuleCommon *module,
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");
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;
}
@ -1325,7 +1318,7 @@ wasm_runtime_init_wasi(WASMModuleInstanceCommon *module_inst,
(module_inst, (uint32)argv_buf_len,
(void**)&argv_buf))) {
set_error_buf(error_buf, error_buf_size,
"Init wasi environment failed: allocate memory failed.");
"Init wasi environment failed: allocate memory failed");
goto fail;
}
@ -1349,7 +1342,7 @@ wasm_runtime_init_wasi(WASMModuleInstanceCommon *module_inst,
(module_inst, (uint32)env_buf_len,
(void**)&env_buf))) {
set_error_buf(error_buf, error_buf_size,
"Init wasi environment failed: allocate memory failed.");
"Init wasi environment failed: allocate memory failed");
goto fail;
}
@ -1368,7 +1361,7 @@ wasm_runtime_init_wasi(WASMModuleInstanceCommon *module_inst,
(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.");
"Init wasi environment failed: allocate memory failed");
goto fail;
}
@ -1383,7 +1376,7 @@ wasm_runtime_init_wasi(WASMModuleInstanceCommon *module_inst,
if (!fd_table_init(curfds)) {
set_error_buf(error_buf, error_buf_size,
"Init wasi environment failed: "
"init fd table failed.");
"init fd table failed");
goto fail;
}
fd_table_inited = true;
@ -1391,7 +1384,7 @@ wasm_runtime_init_wasi(WASMModuleInstanceCommon *module_inst,
if (!fd_prestats_init(prestats)) {
set_error_buf(error_buf, error_buf_size,
"Init wasi environment failed: "
"init fd prestats failed.");
"init fd prestats failed");
goto fail;
}
fd_prestats_inited = true;
@ -1403,7 +1396,7 @@ wasm_runtime_init_wasi(WASMModuleInstanceCommon *module_inst,
env_buf, env_buf_len)) {
set_error_buf(error_buf, error_buf_size,
"Init wasi environment failed: "
"init argument environment failed.");
"init argument environment failed");
goto fail;
}
argv_environ_inited = true;
@ -1413,7 +1406,7 @@ wasm_runtime_init_wasi(WASMModuleInstanceCommon *module_inst,
|| !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.");
"Init wasi environment failed: init fd table failed");
goto fail;
}
@ -1689,7 +1682,7 @@ wasm_application_execute_main(WASMModuleInstanceCommon *module_inst,
if (!func) {
wasm_runtime_set_exception(module_inst,
"lookup main function failed.");
"lookup main function failed");
return false;
}
@ -1697,7 +1690,7 @@ wasm_application_execute_main(WASMModuleInstanceCommon *module_inst,
if (module_inst->module_type == Wasm_Module_Bytecode) {
if (((WASMFunctionInstance*)func)->is_import_func) {
wasm_runtime_set_exception(module_inst,
"lookup main function failed.");
"lookup main function failed");
return false;
}
func_type = ((WASMFunctionInstance*)func)->u.func->func_type;
@ -1710,7 +1703,7 @@ wasm_application_execute_main(WASMModuleInstanceCommon *module_inst,
if (!check_main_func_type(func_type)) {
wasm_runtime_set_exception(module_inst,
"invalid function type of main function.");
"invalid function type of main function");
return false;
}
@ -1726,7 +1719,7 @@ wasm_application_execute_main(WASMModuleInstanceCommon *module_inst,
wasm_runtime_module_malloc(module_inst, (uint32)total_size,
(void**)&argv_buf))) {
wasm_runtime_set_exception(module_inst,
"allocate memory failed.");
"allocate memory failed");
return false;
}
@ -1942,7 +1935,7 @@ wasm_application_execute_func(WASMModuleInstanceCommon *module_inst,
func = resolve_function(module_inst, name);
if (!func) {
snprintf(buf, sizeof(buf), "lookup function %s failed.", name);
snprintf(buf, sizeof(buf), "lookup function %s failed", name);
wasm_runtime_set_exception(module_inst, buf);
goto fail;
}
@ -1955,7 +1948,7 @@ wasm_application_execute_func(WASMModuleInstanceCommon *module_inst,
&& !wasm_func->import_func_inst
#endif
) {
snprintf(buf, sizeof(buf), "lookup function %s failed.", name);
snprintf(buf, sizeof(buf), "lookup function %s failed", name);
wasm_runtime_set_exception(module_inst, buf);
goto fail;
}
@ -1976,7 +1969,7 @@ wasm_application_execute_func(WASMModuleInstanceCommon *module_inst,
if (type->param_count != (uint32)argc) {
wasm_runtime_set_exception(module_inst,
"invalid input argument count.");
"invalid input argument count");
goto fail;
}
@ -1994,7 +1987,7 @@ wasm_application_execute_func(WASMModuleInstanceCommon *module_inst,
char *endptr = NULL;
bh_assert(argv[i] != NULL);
if (argv[i][0] == '\0') {
snprintf(buf, sizeof(buf), "invalid input argument %d.", i);
snprintf(buf, sizeof(buf), "invalid input argument %d", i);
wasm_runtime_set_exception(module_inst, buf);
goto fail;
}
@ -2074,14 +2067,14 @@ wasm_application_execute_func(WASMModuleInstanceCommon *module_inst,
}
}
if (endptr && *endptr != '\0' && *endptr != '_') {
snprintf(buf, sizeof(buf), "invalid input argument %d: %s.",
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);
"prepare function argument error, errno: %d", errno);
wasm_runtime_set_exception(module_inst, buf);
goto fail;
}

4
core/iwasm/common/wasm_runtime_common.h
View File

@ -79,10 +79,6 @@ typedef struct WASMMemoryInstanceCommon {
typedef package_type_t PackageType;
typedef wasm_section_t WASMSection, AOTSection;
void
set_error_buf_v(char *error_buf, uint32 error_buf_size, const char *format,
...);
/* See wasm_export.h for description */
bool
wasm_runtime_init(void);

41
core/iwasm/compilation/aot_emit_memory.c
View File

@ -700,47 +700,6 @@ aot_compile_op_memory_grow(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx)
}
PUSH_I32(ret_value);
/* To be simple, call wasm_runtime_set_exception() no matter
enlarge success or not */
param_types[1] = INT8_PTR_TYPE;
ret_type = VOID_TYPE;
if (!(func_type = LLVMFunctionType(ret_type, param_types, 2, false))) {
aot_set_last_error("llvm add function type failed.");
return false;
}
if (comp_ctx->is_jit_mode) {
/* JIT mode, call the function directly */
if (!(func_ptr_type = LLVMPointerType(func_type, 0))) {
aot_set_last_error("llvm add pointer type failed.");
return false;
}
if (!(value = I64_CONST((uint64)(uintptr_t)wasm_runtime_set_exception))
|| !(func = LLVMConstIntToPtr(value, func_ptr_type))) {
aot_set_last_error("create LLVM value failed.");
return false;
}
}
else {
char *func_name = "wasm_runtime_set_exception";
/* AOT mode, delcare the function */
if (!(func = LLVMGetNamedFunction(comp_ctx->module, func_name))
&& !(func = LLVMAddFunction(comp_ctx->module,
func_name, func_type))) {
aot_set_last_error("llvm add function failed.");
return false;
}
}
/* Call function wasm_runtime_set_exception(aot_inst, NULL) */
param_values[1] = LLVMConstNull(INT8_PTR_TYPE);
CHECK_LLVM_CONST(param_values[1]);
if (!(LLVMBuildCall(comp_ctx->builder, func, param_values, 2, ""))) {
aot_set_last_error("llvm build call failed.");
return false;
}
return true;
fail:
return false;

39
core/iwasm/interpreter/wasm_interp_classic.c
View File

@ -903,7 +903,7 @@ ALLOC_FRAME(WASMExecEnv *exec_env, uint32 size, WASMInterpFrame *prev_frame)
frame->prev_frame = prev_frame;
else {
wasm_set_exception((WASMModuleInstance*)exec_env->module_inst,
"WASM interp failed: stack overflow.");
"stack overflow");
}
return frame;
@ -1244,8 +1244,7 @@ label_pop_csp_n:
uint64 total_size = sizeof(uint32) * (uint64)count;
if (total_size >= UINT32_MAX
|| !(depths = wasm_runtime_malloc((uint32)total_size))) {
wasm_set_exception(module,
"WASM interp failed: allocate memory failed.");
wasm_set_exception(module, "allocate memory failed");
goto got_exception;
}
}
@ -1303,7 +1302,7 @@ label_pop_csp_n:
*/
read_leb_uint32(frame_ip, frame_ip_end, tidx);
if (tidx >= module->module->type_count) {
wasm_set_exception(module, "type index is overflow");
wasm_set_exception(module, "unknown type");
goto got_exception;
}
cur_type = wasm_types[tidx];
@ -1839,10 +1838,6 @@ label_pop_csp_n:
if (!wasm_enlarge_memory(module, delta)) {
/* fail to memory.grow, return -1 */
PUSH_I32(-1);
if (wasm_get_exception(module)) {
os_printf("%s\n", wasm_get_exception(module));
wasm_set_exception(module, NULL);
}
}
else {
/* success, return previous page count */
@ -2762,7 +2757,7 @@ label_pop_csp_n:
}
#endif /* WASM_ENABLE_BULK_MEMORY */
default:
wasm_set_exception(module, "WASM interp failed: unsupported opcode.");
wasm_set_exception(module, "unsupported opcode");
goto got_exception;
break;
}
@ -3107,7 +3102,7 @@ label_pop_csp_n:
#if WASM_ENABLE_LABELS_AS_VALUES == 0
default:
wasm_set_exception(module, "WASM interp failed: unsupported opcode.");
wasm_set_exception(module, "unsupported opcode");
goto got_exception;
}
#endif
@ -3137,7 +3132,7 @@ label_pop_csp_n:
HANDLE_OP (EXT_OP_COPY_STACK_TOP_I64):
HANDLE_OP (EXT_OP_COPY_STACK_VALUES):
{
wasm_set_exception(module, "WASM interp failed: unsupported opcode.");
wasm_set_exception(module, "unsupported opcode");
goto got_exception;
}
#endif
@ -3192,7 +3187,7 @@ label_pop_csp_n:
+ (uint64)cur_wasm_func->max_stack_cell_num
+ ((uint64)cur_wasm_func->max_block_num) * sizeof(WASMBranchBlock) / 4;
if (all_cell_num >= UINT32_MAX) {
wasm_set_exception(module, "WASM interp failed: stack overflow.");
wasm_set_exception(module, "stack overflow");
goto got_exception;
}
@ -3288,7 +3283,7 @@ wasm_interp_call_wasm(WASMModuleInstance *module_inst,
if ((uint8*)&prev_frame < exec_env->native_stack_boundary) {
wasm_set_exception((WASMModuleInstance*)exec_env->module_inst,
"WASM interp failed: native stack overflow.");
"native stack overflow");
return;
}
@ -3310,20 +3305,16 @@ wasm_interp_call_wasm(WASMModuleInstance *module_inst,
#if WASM_ENABLE_MULTI_MODULE != 0
if (function->import_module_inst) {
LOG_DEBUG("it is a function of a sub module");
wasm_interp_call_func_import(module_inst,
exec_env,
function,
frame);
wasm_interp_call_func_import(module_inst, exec_env,
function, frame);
}
else
#endif
{
LOG_DEBUG("it is an native function");
/* it is a native function */
wasm_interp_call_func_native(module_inst,
exec_env,
function,
frame);
wasm_interp_call_func_native(module_inst, exec_env,
function, frame);
}
}
else {
@ -3339,10 +3330,12 @@ wasm_interp_call_wasm(WASMModuleInstance *module_inst,
if (function->ret_cell_num) {
LOG_DEBUG("first return value argv[0]=%d", argv[0]);
} else {
}
else {
LOG_DEBUG("no return value");
}
} else {
}
else {
LOG_DEBUG("meet an exception %s", wasm_get_exception(module_inst));
}

31
core/iwasm/interpreter/wasm_interp_fast.c
View File

@ -802,8 +802,7 @@ copy_stack_values(WASMModuleInstance *module,
uint64 total_size = sizeof(uint32) * (uint64)total_cell_num;
if (total_size >= UINT32_MAX
|| !(tmp_buf = wasm_runtime_malloc((uint32)total_size))) {
wasm_set_exception(module,
"WASM interp failed: allocate memory failed.");
wasm_set_exception(module, "allocate memory failed");
return false;
}
}
@ -951,7 +950,7 @@ ALLOC_FRAME(WASMExecEnv *exec_env, uint32 size, WASMInterpFrame *prev_frame)
frame->prev_frame = prev_frame;
else {
wasm_set_exception((WASMModuleInstance*)exec_env->module_inst,
"WASM interp failed: stack overflow.");
"stack overflow");
}
return frame;
@ -1789,10 +1788,6 @@ recover_br_info:
if (!wasm_enlarge_memory(module, delta)) {
/* fail to memory.grow, return -1 */
frame_lp[addr_ret] = -1;
if (wasm_get_exception(module)) {
os_printf("%s\n", wasm_get_exception(module));
wasm_set_exception(module, NULL);
}
}
else {
/* success, return previous page count */
@ -2756,7 +2751,7 @@ recover_br_info:
}
#endif /* WASM_ENABLE_BULK_MEMORY */
default:
wasm_set_exception(module, "WASM interp failed: unsupported opcode.");
wasm_set_exception(module, "unsupported opcode");
goto got_exception;
break;
}
@ -3111,7 +3106,7 @@ recover_br_info:
#if WASM_ENABLE_LABELS_AS_VALUES == 0
default:
wasm_set_exception(module, "WASM interp failed: unsupported opcode.");
wasm_set_exception(module, "unsupported opcode");
goto got_exception;
}
#endif
@ -3155,7 +3150,7 @@ recover_br_info:
HANDLE_OP (EXT_OP_LOOP):
HANDLE_OP (EXT_OP_IF):
{
wasm_set_exception(module, "WASM interp failed: unsupported opcode.");
wasm_set_exception(module, "unsupported opcode");
goto got_exception;
}
#endif
@ -3234,7 +3229,7 @@ recover_br_info:
+ (uint64)cur_func->const_cell_num
+ (uint64)cur_wasm_func->max_stack_cell_num;
if (all_cell_num >= UINT32_MAX) {
wasm_set_exception(module, "WASM interp failed: stack overflow.");
wasm_set_exception(module, "stack overflow");
goto got_exception;
}
@ -3336,7 +3331,7 @@ wasm_interp_call_wasm(WASMModuleInstance *module_inst,
if ((uint8*)&prev_frame < exec_env->native_stack_boundary) {
wasm_set_exception((WASMModuleInstance*)exec_env->module_inst,
"WASM interp failed: native stack overflow.");
"native stack overflow");
return;
}
@ -3359,19 +3354,15 @@ wasm_interp_call_wasm(WASMModuleInstance *module_inst,
#if WASM_ENABLE_MULTI_MODULE != 0
if (function->import_module_inst) {
LOG_DEBUG("it is a function of a sub module");
wasm_interp_call_func_import(module_inst,
exec_env,
function,
frame);
wasm_interp_call_func_import(module_inst, exec_env,
function, frame);
}
else
#endif
{
LOG_DEBUG("it is an native function");
wasm_interp_call_func_native(module_inst,
exec_env,
function,
frame);
wasm_interp_call_func_native(module_inst, exec_env,
function, frame);
}
}
else {

358
core/iwasm/interpreter/wasm_loader.c
View File

File diff suppressed because it is too large Load Diff

37
core/iwasm/interpreter/wasm_mini_loader.c
View File

@ -21,7 +21,8 @@ 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);
snprintf(error_buf, error_buf_size,
"WASM module load failed: %s", string);
}
#define CHECK_BUF(buf, buf_end, length) do { \
@ -168,8 +169,7 @@ loader_malloc(uint64 size, char *error_buf, uint32 error_buf_size)
if (size >= UINT32_MAX
|| !(mem = wasm_runtime_malloc((uint32)size))) {
set_error_buf(error_buf, error_buf_size,
"WASM module load failed: "
"allocate memory failed.");
"allocate memory failed");
return NULL;
}
@ -378,8 +378,7 @@ load_function_import(const WASMModule *parent_module, WASMModule *sub_module,
is_built_in_module = wasm_runtime_is_built_in_module(sub_module_name);
if (is_built_in_module) {
LOG_DEBUG("%s is a function of a built-in module %s",
function_name,
sub_module_name);
function_name, sub_module_name);
/* check built-in modules */
linked_func = wasm_native_resolve_symbol(sub_module_name,
function_name,
@ -391,15 +390,13 @@ load_function_import(const WASMModule *parent_module, WASMModule *sub_module,
if (!linked_func) {
#if WASM_ENABLE_SPEC_TEST != 0
set_error_buf(error_buf,
error_buf_size,
set_error_buf(error_buf, error_buf_size,
"unknown import or incompatible import type");
return false;
#else
#if WASM_ENABLE_WAMR_COMPILER == 0
LOG_WARNING(
"warning: fail to link import function (%s, %s)",
sub_module_name, function_name);
LOG_WARNING("warning: fail to link import function (%s, %s)",
sub_module_name, function_name);
#endif
#endif
}
@ -538,8 +535,8 @@ load_global_import(const WASMModule *parent_module,
#endif /* WASM_ENABLE_LIBC_BUILTIN */
if (!ret) {
set_error_buf_v(error_buf, error_buf_size,
"unknown import or incompatible import type");
set_error_buf(error_buf, error_buf_size,
"unknown import or incompatible import type");
return false;
}
@ -597,6 +594,7 @@ load_memory(const uint8 **p_buf, const uint8 *buf_end, WASMMemory *memory,
p_org = p;
read_leb_uint32(p, p_end, memory->flags);
bh_assert(p - p_org <= 1);
(void)p_org;
#if WASM_ENABLE_SHARED_MEMORY == 0
bh_assert(memory->flags <= 1);
#else
@ -1536,7 +1534,7 @@ load_from_sections(WASMModule *module, WASMSection *sections,
#endif
default:
set_error_buf(error_buf, error_buf_size,
"WASM module load failed: invalid section id");
"invalid section id");
return false;
}
@ -1934,8 +1932,7 @@ load(const uint8 *buf, uint32 size, WASMModule *module,
exchange32((uint8*)&version);
if (version != WASM_CURRENT_VERSION) {
set_error_buf(error_buf, error_buf_size,
"WASM module load failed: unknown binary version");
set_error_buf(error_buf, error_buf_size, "unknown binary version");
return false;
}
@ -1959,7 +1956,6 @@ wasm_loader_load(const uint8 *buf, uint32 size, char *error_buf, uint32 error_bu
}
if (!load(buf, size, module, error_buf, error_buf_size)) {
LOG_VERBOSE("Load module failed, %s", error_buf);
goto fail;
}
@ -2459,7 +2455,7 @@ wasm_loader_find_block_addr(BlockAddr *block_addr_cache,
#if WASM_DEBUG_PREPROCESSOR != 0
#define LOG_OP(...) os_printf(__VA_ARGS__)
#else
#define LOG_OP(...)
#define LOG_OP(...) (void)0
#endif
#define PATCH_ELSE 0
@ -3878,7 +3874,7 @@ wasm_loader_check_br(WASMLoaderContext *loader_ctx, uint32 depth,
if (loader_ctx->csp_num < depth + 1) {
set_error_buf(error_buf, error_buf_size,
"WASM module load failed: unknown label, "
"unknown label, "
"unexpected end of section or function");
return false;
}
@ -4196,7 +4192,6 @@ wasm_loader_prepare_bytecode(WASMModule *module, WASMFunction *func,
if (!(loader_ctx = wasm_loader_ctx_init(func))) {
set_error_buf(error_buf, error_buf_size,
"WASM loader prepare bytecode failed: "
"allocate memory failed");
goto fail;
}
@ -4206,7 +4201,6 @@ re_scan:
if (loader_ctx->code_compiled_size > 0) {
if (!wasm_loader_ctx_reinit(loader_ctx)) {
set_error_buf(error_buf, error_buf_size,
"WASM loader prepare bytecode failed: "
"allocate memory failed");
goto fail;
}
@ -5604,8 +5598,7 @@ handle_op_block_and_loop:
if (loader_ctx->csp_num > 0) {
set_error_buf(error_buf, error_buf_size,
"WASM module load failed: "
"function body must end with END opcode.");
"function body must end with END opcode");
goto fail;
}

53
core/iwasm/interpreter/wasm_runtime.c
View File

@ -17,8 +17,10 @@
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);
if (error_buf != NULL) {
snprintf(error_buf, error_buf_size,
"WASM module instantiate failed: %s", string);
}
}
WASMModule*
@ -50,8 +52,7 @@ runtime_malloc(uint64 size, char *error_buf, uint32 error_buf_size)
if (size >= UINT32_MAX
|| !(mem = wasm_runtime_malloc((uint32)size))) {
set_error_buf(error_buf, error_buf_size,
"WASM module instantiate failed: "
"allocate memory failed.");
"allocate memory failed");
return NULL;
}
@ -262,17 +263,13 @@ memory_instantiate(WASMModuleInstance *module_inst,
if (heap_size > 0
&& !(memory->heap_handle =
mem_allocator_create(memory->heap_data, heap_size))) {
set_error_buf(error_buf, error_buf_size,
"Instantiate memory failed: "
"init app heap failed.");
set_error_buf(error_buf, error_buf_size, "init app heap failed");
goto fail1;
}
#if WASM_ENABLE_SHARED_MEMORY != 0
if (0 != os_mutex_init(&memory->mem_lock)) {
set_error_buf(error_buf, error_buf_size,
"Instantiate memory failed: "
"init mutex failed.");
set_error_buf(error_buf, error_buf_size, "init mutex failed");
goto fail2;
}
if (is_shared_memory) {
@ -281,8 +278,7 @@ memory_instantiate(WASMModuleInstance *module_inst,
(WASMModuleCommon *)module_inst->module,
(WASMMemoryInstanceCommon *)memory)) {
set_error_buf(error_buf, error_buf_size,
"Instantiate memory failed: "
"allocate memory failed.");
"allocate memory failed");
goto fail3;
}
}
@ -735,8 +731,7 @@ globals_instantiate(const WASMModule *module,
sub_module_inst->globals,
sub_module_inst->global_count, &(global->initial_value));
if (!ret) {
set_error_buf(error_buf, error_buf_size,
"Instantiate global failed: unknown global.");
set_error_buf(error_buf, error_buf_size, "unknown global");
return NULL;
}
}
@ -774,8 +769,7 @@ globals_instantiate(const WASMModule *module,
parse_init_expr(init_expr, globals, global_count,
&(global->initial_value));
if (!ret) {
set_error_buf(error_buf, error_buf_size,
"Instantiate global failed: unknown global.");
set_error_buf(error_buf, error_buf_size, "unknown global");
return NULL;
}
}
@ -811,8 +805,7 @@ globals_instantiate_fix(WASMGlobalInstance *globals,
ret = parse_init_expr(init_expr, globals, global_count,
&global->initial_value);
if (!ret) {
set_error_buf(error_buf, error_buf_size,
"Instantiate global failed: unknown global.");
set_error_buf(error_buf, error_buf_size, "unknown global");
return false;
}
}
@ -1024,18 +1017,18 @@ sub_module_instantiate(WASMModule *module, WASMModuleInstance *module_inst,
bh_list_first_elem(module->import_module_list);
while (sub_module_list_node) {
WASMSubModInstNode *sub_module_inst_list_node;
WASMModule *sub_module = (WASMModule*)sub_module_list_node->module;
WASMModuleInstance *sub_module_inst = wasm_instantiate(
sub_module, false, stack_size, heap_size, error_buf, error_buf_size);
WASMModuleInstance *sub_module_inst =
wasm_instantiate(sub_module, false, stack_size, heap_size,
error_buf, error_buf_size);
if (!sub_module_inst) {
LOG_DEBUG("instantiate %s failed",
sub_module_list_node->module_name);
set_error_buf_v(error_buf, error_buf_size, "instantiate %s failed",
sub_module_list_node->module_name);
return false;
}
WASMSubModInstNode *sub_module_inst_list_node = runtime_malloc
sub_module_inst_list_node = runtime_malloc
(sizeof(WASMSubModInstNode), error_buf, error_buf_size);
if (!sub_module_inst_list_node) {
LOG_DEBUG("Malloc WASMSubModInstNode failed, SZ:%d",
@ -1102,7 +1095,6 @@ wasm_instantiate(WASMModule *module, bool is_sub_inst,
error_buf, error_buf_size))) {
return NULL;
}
memset(module_inst, 0, (uint32)sizeof(WASMModuleInstance));
module_inst->module = module;
@ -1264,7 +1256,7 @@ wasm_instantiate(WASMModule *module, bool is_sub_inst,
LOG_DEBUG("base_offset(%d) > memory_size(%d)", base_offset,
memory_size);
set_error_buf(error_buf, error_buf_size,
"data segment does not fit.");
"data segment does not fit");
wasm_deinstantiate(module_inst, false);
return NULL;
}
@ -1274,9 +1266,8 @@ wasm_instantiate(WASMModule *module, bool is_sub_inst,
if (base_offset + length > memory_size) {
LOG_DEBUG("base_offset(%d) + length(%d) > memory_size(%d)",
base_offset, length, memory_size);
set_error_buf(
error_buf, error_buf_size,
"Instantiate module failed: data segment does not fit.");
set_error_buf(error_buf, error_buf_size,
"data segment does not fit");
wasm_deinstantiate(module_inst, false);
return NULL;
}
@ -1538,7 +1529,7 @@ wasm_create_exec_env_and_call_function(WASMModuleInstance *module_inst,
if (!(exec_env = wasm_exec_env_create(
(WASMModuleInstanceCommon*)module_inst,
module_inst->default_wasm_stack_size))) {
wasm_set_exception(module_inst, "allocate memory failed.");
wasm_set_exception(module_inst, "allocate memory failed");
return false;
}
@ -1764,12 +1755,10 @@ wasm_enlarge_memory(WASMModuleInstance *module, uint32 inc_page_count)
if (total_page_count < memory->cur_page_count /* integer overflow */
|| total_page_count > memory->max_page_count) {
wasm_set_exception(module, "fail to enlarge memory.");
return false;
}
if (total_size >= UINT32_MAX) {
wasm_set_exception(module, "fail to enlarge memory.");
return false;
}
@ -1793,7 +1782,6 @@ wasm_enlarge_memory(WASMModuleInstance *module, uint32 inc_page_count)
/* Restore heap's lock if memory re-alloc failed */
mem_allocator_reinit_lock(memory->heap_handle);
}
wasm_set_exception(module, "fail to enlarge memory.");
return false;
}
bh_memcpy_s((uint8 *)new_memory, (uint32)total_size,
@ -1809,7 +1797,6 @@ wasm_enlarge_memory(WASMModuleInstance *module, uint32 inc_page_count)
((uint8 *)new_memory - (uint8 *)memory);
if (mem_allocator_migrate(new_memory->heap_handle,
heap_handle_old) != 0) {
wasm_set_exception(module, "fail to enlarge memory.");
return false;
}
}