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

Fix warnings/issues reported in Windows and by CodeQL/Coverity (#3275)

Browse Source 
Fix the warnings and issues reported:
- in Windows platform
- by CodeQL static code analyzing
- by Coverity static code analyzing

And update CodeQL script to build exception handling and memory features.
This commit is contained in:
Wenyong Huang 2024-04-07 11:57:31 +08:00 committed by GitHub
parent 53f0941ffa
commit 2013f1f7d7
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
26 changed files with 202 additions and 118 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
.github/workflows/codeql_buildscript.sh vendored
View File

@ -101,6 +101,26 @@ if [[ $? != 0 ]]; then
exit 1; exit 1;
fi fi
# build iwasm with exception handling enabled
cd ${WAMR_DIR}/product-mini/platforms/linux
rm -rf build && mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Debug -DWAMR_BUILD_EXCE_HANDLING=1
make -j
if [[ $? != 0 ]]; then
echo "Failed to build iwasm with exception handling enabled!"
exit 1;
fi
# build iwasm with memory64 enabled
cd ${WAMR_DIR}/product-mini/platforms/linux
rm -rf build && mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Debug -DWAMR_BUILD_MEMORY64=1
make -j
if [[ $? != 0 ]]; then
echo "Failed to build iwasm with memory64 enabled!"
exit 1;
fi
# build iwasm with hardware boundary check disabled # build iwasm with hardware boundary check disabled
cd ${WAMR_DIR}/product-mini/platforms/linux cd ${WAMR_DIR}/product-mini/platforms/linux
rm -rf build && mkdir build && cd build rm -rf build && mkdir build && cd build

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

@ -1430,9 +1430,20 @@ load_table_init_data_list(const uint8 **p_buf, const uint8 *buf_end,
read_uint64(buf, buf_end, init_expr_value); read_uint64(buf, buf_end, init_expr_value);
#if WASM_ENABLE_GC != 0 #if WASM_ENABLE_GC != 0
if (wasm_is_type_multi_byte_type(elem_type)) { if (wasm_is_type_multi_byte_type(elem_type)) {
/* TODO: check ref_type */ uint16 ref_type, nullable;
read_uint16(buf, buf_end, reftype.ref_ht_common.ref_type); read_uint16(buf, buf_end, ref_type);
read_uint16(buf, buf_end, reftype.ref_ht_common.nullable); if (elem_type != ref_type) {
set_error_buf(error_buf, error_buf_size, "invalid elem type");
return false;
}
reftype.ref_ht_common.ref_type = (uint8)ref_type;
read_uint16(buf, buf_end, nullable);
if (nullable != 0 && nullable != 1) {
set_error_buf(error_buf, error_buf_size,
"invalid nullable value");
return false;
}
reftype.ref_ht_common.nullable = (uint8)nullable;
read_uint32(buf, buf_end, reftype.ref_ht_common.heap_type); read_uint32(buf, buf_end, reftype.ref_ht_common.heap_type);
} }
else else
@ -4379,7 +4390,7 @@ aot_unload(AOTModule *module)
} }
if (module->string_literal_ptrs) { if (module->string_literal_ptrs) {
wasm_runtime_free(module->string_literal_ptrs); wasm_runtime_free((void *)module->string_literal_ptrs);
} }
} }
#endif #endif

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

@ -880,7 +880,7 @@ memory_instantiate(AOTModuleInstance *module_inst, AOTModuleInstance *parent,
global_addr = module_inst->global_data global_addr = module_inst->global_data
+ module->globals[global_idx].data_offset; + module->globals[global_idx].data_offset;
*(uint32 *)global_addr = (uint32)aux_heap_base; *(uint32 *)global_addr = (uint32)aux_heap_base;
LOG_VERBOSE("Reset __heap_base global to %u", aux_heap_base); LOG_VERBOSE("Reset __heap_base global to %" PRIu64, aux_heap_base);
} }
else { else {
/* Insert app heap before new page */ /* Insert app heap before new page */
@ -906,9 +906,10 @@ memory_instantiate(AOTModuleInstance *module_inst, AOTModuleInstance *parent,
LOG_VERBOSE("Memory instantiate:"); LOG_VERBOSE("Memory instantiate:");
LOG_VERBOSE(" page bytes: %u, init pages: %u, max pages: %u", LOG_VERBOSE(" page bytes: %u, init pages: %u, max pages: %u",
num_bytes_per_page, init_page_count, max_page_count); num_bytes_per_page, init_page_count, max_page_count);
LOG_VERBOSE(" data offset: %u, stack size: %d", module->aux_data_end, LOG_VERBOSE(" data offset: %" PRIu64 ", stack size: %d",
module->aux_stack_size); module->aux_data_end, module->aux_stack_size);
LOG_VERBOSE(" heap offset: %u, heap size: %d\n", heap_offset, heap_size); LOG_VERBOSE(" heap offset: %" PRIu64 ", heap size: %d\n", heap_offset,
heap_size);
max_memory_data_size = (uint64)num_bytes_per_page * max_page_count; max_memory_data_size = (uint64)num_bytes_per_page * max_page_count;
bh_assert(max_memory_data_size <= MAX_LINEAR_MEMORY_SIZE); bh_assert(max_memory_data_size <= MAX_LINEAR_MEMORY_SIZE);
@ -1070,8 +1071,8 @@ memories_instantiate(AOTModuleInstance *module_inst, AOTModuleInstance *parent,
/* Check memory data */ /* Check memory data */
/* check offset since length might negative */ /* check offset since length might negative */
if (base_offset > memory_inst->memory_data_size) { if (base_offset > memory_inst->memory_data_size) {
LOG_DEBUG("base_offset(%d) > memory_data_size(%d)", base_offset, LOG_DEBUG("base_offset(%d) > memory_data_size(%" PRIu64 ")",
memory_inst->memory_data_size); base_offset, memory_inst->memory_data_size);
#if WASM_ENABLE_REF_TYPES != 0 #if WASM_ENABLE_REF_TYPES != 0
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"out of bounds memory access"); "out of bounds memory access");
@ -1085,7 +1086,8 @@ memories_instantiate(AOTModuleInstance *module_inst, AOTModuleInstance *parent,
/* check offset + length(could be zero) */ /* check offset + length(could be zero) */
length = data_seg->byte_count; length = data_seg->byte_count;
if (base_offset + length > memory_inst->memory_data_size) { if (base_offset + length > memory_inst->memory_data_size) {
LOG_DEBUG("base_offset(%d) + length(%d) > memory_data_size(%d)", LOG_DEBUG("base_offset(%d) + length(%d) > memory_data_size(%" PRIu64
")",
base_offset, length, memory_inst->memory_data_size); base_offset, length, memory_inst->memory_data_size);
#if WASM_ENABLE_REF_TYPES != 0 #if WASM_ENABLE_REF_TYPES != 0
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
@ -2523,7 +2525,8 @@ aot_module_malloc_internal(AOTModuleInstance *module_inst,
aot_set_exception(module_inst, "app heap corrupted"); aot_set_exception(module_inst, "app heap corrupted");
} }
else { else {
LOG_WARNING("warning: allocate %u bytes memory failed", size); LOG_WARNING("warning: allocate %" PRIu64 " bytes memory failed",
size);
} }
return 0; return 0;
} }
@ -2806,7 +2809,7 @@ aot_call_indirect(WASMExecEnv *exec_env, uint32 tbl_idx, uint32 table_elem_idx,
} }
#if WASM_ENABLE_GC == 0 #if WASM_ENABLE_GC == 0
func_idx = tbl_elem_val; func_idx = (uint32)tbl_elem_val;
#else #else
func_idx = func_idx =
wasm_func_obj_get_func_idx_bound((WASMFuncObjectRef)tbl_elem_val); wasm_func_obj_get_func_idx_bound((WASMFuncObjectRef)tbl_elem_val);
@ -3697,14 +3700,14 @@ aot_create_call_stack(struct WASMExecEnv *exec_env)
frame.instance = module_inst; frame.instance = module_inst;
frame.module_offset = 0; frame.module_offset = 0;
frame.func_index = cur_frame->func_index; frame.func_index = (uint32)cur_frame->func_index;
frame.func_offset = cur_frame->ip_offset; frame.func_offset = (uint32)cur_frame->ip_offset;
frame.func_name_wp = frame.func_name_wp = get_func_name_from_index(
get_func_name_from_index(module_inst, cur_frame->func_index); module_inst, (uint32)cur_frame->func_index);
if (cur_frame->func_index >= module->import_func_count) { if (cur_frame->func_index >= module->import_func_count) {
uint32 aot_func_idx = uint32 aot_func_idx =
cur_frame->func_index - module->import_func_count; (uint32)(cur_frame->func_index - module->import_func_count);
max_local_cell_num = module->max_local_cell_nums[aot_func_idx]; max_local_cell_num = module->max_local_cell_nums[aot_func_idx];
max_stack_cell_num = module->max_stack_cell_nums[aot_func_idx]; max_stack_cell_num = module->max_stack_cell_nums[aot_func_idx];
} }
@ -4721,12 +4724,12 @@ aot_set_module_name(AOTModule *module, const char *name, char *error_buf,
if (!name) if (!name)
return false; return false;
module->name = module->name = aot_const_str_set_insert((const uint8 *)name,
aot_const_str_set_insert((const uint8 *)name, strlen(name) + 1, module, (uint32)(strlen(name) + 1), module,
#if (WASM_ENABLE_WORD_ALIGN_READ != 0) #if (WASM_ENABLE_WORD_ALIGN_READ != 0)
false, false,
#endif #endif
error_buf, error_buf_size); error_buf, error_buf_size);
return module->name != NULL; return module->name != NULL;
} }

6
core/iwasm/common/gc/gc_type.c
View File

@ -148,7 +148,7 @@ wasm_dump_func_type(const WASMFuncType *type)
os_printf("] -> ["); os_printf("] -> [");
for (; i < type->param_count + type->result_count; i++) { for (; i < (uint32)(type->param_count + type->result_count); i++) {
if (wasm_is_type_multi_byte_type(type->types[i])) { if (wasm_is_type_multi_byte_type(type->types[i])) {
bh_assert(j < type->ref_type_map_count); bh_assert(j < type->ref_type_map_count);
bh_assert(i == type->ref_type_maps[j].index); bh_assert(i == type->ref_type_maps[j].index);
@ -264,7 +264,7 @@ wasm_func_type_equal(const WASMFuncType *type1, const WASMFuncType *type2,
|| type1->ref_type_map_count != type2->ref_type_map_count) || type1->ref_type_map_count != type2->ref_type_map_count)
return false; return false;
for (i = 0; i < type1->param_count + type1->result_count; i++) { for (i = 0; i < (uint32)(type1->param_count + type1->result_count); i++) {
if (type1->types[i] != type2->types[i]) if (type1->types[i] != type2->types[i])
return false; return false;
@ -399,7 +399,7 @@ wasm_func_type_is_subtype_of(const WASMFuncType *type1,
} }
} }
for (; i < type1->param_count + type1->result_count; i++) { for (; i < (uint32)(type1->param_count + type1->result_count); i++) {
if (wasm_is_type_multi_byte_type(type1->types[i])) { if (wasm_is_type_multi_byte_type(type1->types[i])) {
bh_assert(j1 < type1->ref_type_map_count); bh_assert(j1 < type1->ref_type_map_count);
ref_type1 = type1->ref_type_maps[j1++].ref_type; ref_type1 = type1->ref_type_maps[j1++].ref_type;

4
core/iwasm/common/wasm_c_api.c
View File

@ -3987,7 +3987,7 @@ wasm_table_get(const wasm_table_t *table, wasm_table_size_t index)
if (index >= table_interp->cur_size) { if (index >= table_interp->cur_size) {
return NULL; return NULL;
} }
ref_idx = table_interp->elems[index]; ref_idx = (uint32)table_interp->elems[index];
} }
#endif #endif
@ -3998,7 +3998,7 @@ wasm_table_get(const wasm_table_t *table, wasm_table_size_t index)
if (index >= table_aot->cur_size) { if (index >= table_aot->cur_size) {
return NULL; return NULL;
} }
ref_idx = table_aot->elems[index]; ref_idx = (uint32)table_aot->elems[index];
} }
#endif #endif

6
core/iwasm/common/wasm_memory.c
View File

@ -41,12 +41,12 @@ static void (*free_func)(void *ptr) = NULL;
static unsigned int global_pool_size; static unsigned int global_pool_size;
static uint32 static uint64
align_as_and_cast(uint64 size, uint64 alignment) align_as_and_cast(uint64 size, uint64 alignment)
{ {
uint64 aligned_size = (size + alignment - 1) & ~(alignment - 1); uint64 aligned_size = (size + alignment - 1) & ~(alignment - 1);
return aligned_size > UINT32_MAX ? UINT32_MAX : (uint32)aligned_size; return aligned_size;
} }
static bool static bool
@ -951,7 +951,7 @@ wasm_allocate_linear_memory(uint8 **data, bool is_shared_memory,
{ {
bh_assert(*memory_data_size <= MAX_LINEAR_MEMORY_SIZE); bh_assert(*memory_data_size <= MAX_LINEAR_MEMORY_SIZE);
} }
align_as_and_cast(*memory_data_size, page_size); *memory_data_size = align_as_and_cast(*memory_data_size, page_size);
if (map_size > 0) { if (map_size > 0) {
if (!(*data = wasm_mmap_linear_memory(map_size, *memory_data_size))) { if (!(*data = wasm_mmap_linear_memory(map_size, *memory_data_size))) {

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

@ -275,11 +275,11 @@ decode_insn(uint8 *insn)
buffer, sizeof(buffer), buffer, sizeof(buffer),
runtime_address); runtime_address);
#if 0
/* Print current instruction */ /* Print current instruction */
/*
os_printf("%012" PRIX64 " ", runtime_address); os_printf("%012" PRIX64 " ", runtime_address);
puts(buffer); puts(buffer);
*/ #endif
return instruction.length; return instruction.length;
} }
@ -1043,7 +1043,7 @@ wasm_runtime_register_module_internal(const char *module_name,
/* module hasn't been registered */ /* module hasn't been registered */
node = runtime_malloc(sizeof(WASMRegisteredModule), NULL, NULL, 0); node = runtime_malloc(sizeof(WASMRegisteredModule), NULL, NULL, 0);
if (!node) { if (!node) {
LOG_DEBUG("malloc WASMRegisteredModule failed. SZ=%d", LOG_DEBUG("malloc WASMRegisteredModule failed. SZ=%zu",
sizeof(WASMRegisteredModule)); sizeof(WASMRegisteredModule));
return false; return false;
} }
@ -1780,7 +1780,7 @@ wasm_runtime_dump_mem_consumption(WASMExecEnv *exec_env)
wasm_runtime_dump_module_inst_mem_consumption(module_inst_common); wasm_runtime_dump_module_inst_mem_consumption(module_inst_common);
wasm_runtime_dump_exec_env_mem_consumption(exec_env); wasm_runtime_dump_exec_env_mem_consumption(exec_env);
os_printf("\nTotal memory consumption of module, module inst and " os_printf("\nTotal memory consumption of module, module inst and "
"exec env: %u\n", "exec env: %" PRIu64 "\n",
total_size); total_size);
os_printf("Total interpreter stack used: %u\n", os_printf("Total interpreter stack used: %u\n",
exec_env->max_wasm_stack_used); exec_env->max_wasm_stack_used);
@ -5488,6 +5488,7 @@ wasm_externref_set_cleanup(WASMModuleInstanceCommon *module_inst,
if (lookup_user_data.found) { if (lookup_user_data.found) {
void *key = (void *)(uintptr_t)lookup_user_data.externref_idx; void *key = (void *)(uintptr_t)lookup_user_data.externref_idx;
ExternRefMapNode *node = bh_hash_map_find(externref_map, key); ExternRefMapNode *node = bh_hash_map_find(externref_map, key);
bh_assert(node);
node->cleanup = extern_obj_cleanup; node->cleanup = extern_obj_cleanup;
ok = true; ok = true;
} }
@ -6539,12 +6540,12 @@ wasm_runtime_load_depended_module(const WASMModuleCommon *parent_module,
if (!ret) { if (!ret) {
LOG_DEBUG("read the file of %s failed", sub_module_name); LOG_DEBUG("read the file of %s failed", sub_module_name);
set_error_buf_v(parent_module, error_buf, error_buf_size, set_error_buf_v(parent_module, error_buf, error_buf_size,
"unknown import", sub_module_name); "unknown import %s", sub_module_name);
goto delete_loading_module; goto delete_loading_module;
} }
if (get_package_type(buffer, buffer_size) != parent_module->module_type) { if (get_package_type(buffer, buffer_size) != parent_module->module_type) {
LOG_DEBUG("moudle %s type error", sub_module_name); LOG_DEBUG("moudle %s type error", sub_module_name);
goto delete_loading_module; goto destroy_file_buffer;
} }
if (get_package_type(buffer, buffer_size) == Wasm_Module_Bytecode) { if (get_package_type(buffer, buffer_size) == Wasm_Module_Bytecode) {
#if WASM_ENABLE_INTERP != 0 #if WASM_ENABLE_INTERP != 0
@ -6650,7 +6651,7 @@ wasm_runtime_sub_module_instantiate(WASMModuleCommon *module,
sub_module_inst_list_node = loader_malloc(sizeof(WASMSubModInstNode), sub_module_inst_list_node = loader_malloc(sizeof(WASMSubModInstNode),
error_buf, error_buf_size); error_buf, error_buf_size);
if (!sub_module_inst_list_node) { if (!sub_module_inst_list_node) {
LOG_DEBUG("Malloc WASMSubModInstNode failed, SZ:%d", LOG_DEBUG("Malloc WASMSubModInstNode failed, SZ: %zu",
sizeof(WASMSubModInstNode)); sizeof(WASMSubModInstNode));
if (sub_module_inst) if (sub_module_inst)
wasm_runtime_deinstantiate_internal(sub_module_inst, false); wasm_runtime_deinstantiate_internal(sub_module_inst, false);

8
core/iwasm/compilation/aot_compiler.c
View File

@ -330,7 +330,7 @@ aot_gen_commit_values(AOTCompFrame *frame)
if (!p->dirty) if (!p->dirty)
continue; continue;
n = p - frame->lp; n = (uint32)(p - frame->lp);
/* Commit reference flag */ /* Commit reference flag */
if (comp_ctx->enable_gc) { if (comp_ctx->enable_gc) {
@ -432,7 +432,7 @@ aot_gen_commit_values(AOTCompFrame *frame)
continue; continue;
p->dirty = 0; p->dirty = 0;
n = p - frame->lp; n = (uint32)(p - frame->lp);
/* Commit values */ /* Commit values */
switch (p->type) { switch (p->type) {
@ -538,7 +538,7 @@ aot_gen_commit_values(AOTCompFrame *frame)
/* Clear reference flags for unused stack slots. */ /* Clear reference flags for unused stack slots. */
for (p = frame->sp; p < end; p++) { for (p = frame->sp; p < end; p++) {
bh_assert(!p->ref); bh_assert(!p->ref);
n = p - frame->lp; n = (uint32)(p - frame->lp);
/* Commit reference flag. */ /* Commit reference flag. */
if (p->ref != p->committed_ref - 1) { if (p->ref != p->committed_ref - 1) {
@ -621,7 +621,7 @@ aot_gen_commit_sp_ip(AOTCompFrame *frame, bool commit_sp, bool commit_ip)
} }
if (commit_sp) { if (commit_sp) {
n = sp - frame->lp; n = (uint32)(sp - frame->lp);
value = I32_CONST(offset_of_local(comp_ctx, n)); value = I32_CONST(offset_of_local(comp_ctx, n));
if (!value) { if (!value) {
aot_set_last_error("llvm build const failed"); aot_set_last_error("llvm build const failed");

2
core/iwasm/compilation/aot_emit_control.c
View File

@ -1269,6 +1269,7 @@ aot_compile_op_br_table(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
PUSH(values[j], target_block->result_types[j]); PUSH(values[j], target_block->result_types[j]);
} }
wasm_runtime_free(values); wasm_runtime_free(values);
values = NULL;
} }
target_block->is_reachable = true; target_block->is_reachable = true;
if (i == br_count) if (i == br_count)
@ -1294,6 +1295,7 @@ aot_compile_op_br_table(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
PUSH(values[j], target_block->param_types[j]); PUSH(values[j], target_block->param_types[j]);
} }
wasm_runtime_free(values); wasm_runtime_free(values);
values = NULL;
} }
if (i == br_count) if (i == br_count)
default_llvm_block = target_block->llvm_entry_block; default_llvm_block = target_block->llvm_entry_block;

3
core/iwasm/compilation/aot_llvm.c
View File

@ -674,7 +674,8 @@ aot_add_llvm_func(AOTCompContext *comp_ctx, LLVMModuleRef module,
uint32 backend_thread_num, compile_thread_num; uint32 backend_thread_num, compile_thread_num;
/* Check function parameter types and result types */ /* Check function parameter types and result types */
for (i = 0; i < aot_func_type->param_count + aot_func_type->result_count; for (i = 0;
i < (uint32)(aot_func_type->param_count + aot_func_type->result_count);
i++) { i++) {
if (!check_wasm_type(comp_ctx, aot_func_type->types[i])) if (!check_wasm_type(comp_ctx, aot_func_type->types[i]))
return NULL; return NULL;

6
core/iwasm/fast-jit/cg/x86-64/jit_codegen_x86_64.cpp
View File

@ -7511,7 +7511,7 @@ at_rmw_xor_r_base_r_offset_r(x86::Assembler &a, uint32 bytes_dst,
CHECK_KIND(r3, JIT_REG_KIND_I64); \ CHECK_KIND(r3, JIT_REG_KIND_I64); \
} \ } \
/* r0: read/return value r2: memory base addr can't be const */ \ /* r0: read/return value r2: memory base addr can't be const */ \
/* already check it's not const in LOAD_4ARGS(); */ \ /* already check it's not const in LOAD_4ARGS() */ \
reg_no_dst = jit_reg_no(r0); \ reg_no_dst = jit_reg_no(r0); \
CHECK_REG_NO(reg_no_dst, jit_reg_kind(r0)); \ CHECK_REG_NO(reg_no_dst, jit_reg_kind(r0)); \
/* mem_data base address has to be non-const */ \ /* mem_data base address has to be non-const */ \
@ -9419,7 +9419,7 @@ static uint8 hreg_info_F64[3][16] = {
1, 1, 1, 1, 1, 1, 1, 0 }, /* caller_saved_jitted */ 1, 1, 1, 1, 1, 1, 1, 0 }, /* caller_saved_jitted */
}; };
static const JitHardRegInfo hreg_info = { static const JitHardRegInfo g_hreg_info = {
{ {
{ 0, NULL, NULL, NULL }, /* VOID */ { 0, NULL, NULL, NULL }, /* VOID */
@ -9459,7 +9459,7 @@ static const JitHardRegInfo hreg_info = {
const JitHardRegInfo * const JitHardRegInfo *
jit_codegen_get_hreg_info() jit_codegen_get_hreg_info()
{ {
return &hreg_info; return &g_hreg_info;
} }
static const char *reg_names_i32[] = { static const char *reg_names_i32[] = {

10
core/iwasm/fast-jit/fe/jit_emit_memory.c
View File

@ -636,7 +636,7 @@ wasm_init_memory(WASMModuleInstance *inst, uint32 mem_idx, uint32 seg_idx,
/* if d + n > the length of mem.data */ /* if d + n > the length of mem.data */
mem_inst = inst->memories[mem_idx]; mem_inst = inst->memories[mem_idx];
mem_size = mem_inst->cur_page_count * mem_inst->num_bytes_per_page; mem_size = mem_inst->cur_page_count * (uint64)mem_inst->num_bytes_per_page;
if (mem_size < mem_offset || mem_size - mem_offset < len) if (mem_size < mem_offset || mem_size - mem_offset < len)
goto out_of_bounds; goto out_of_bounds;
@ -724,8 +724,10 @@ wasm_copy_memory(WASMModuleInstance *inst, uint32 src_mem_idx,
src_mem = inst->memories[src_mem_idx]; src_mem = inst->memories[src_mem_idx];
dst_mem = inst->memories[dst_mem_idx]; dst_mem = inst->memories[dst_mem_idx];
src_mem_size = src_mem->cur_page_count * src_mem->num_bytes_per_page; src_mem_size =
dst_mem_size = dst_mem->cur_page_count * dst_mem->num_bytes_per_page; src_mem->cur_page_count * (uint64)src_mem->num_bytes_per_page;
dst_mem_size =
dst_mem->cur_page_count * (uint64)dst_mem->num_bytes_per_page;
/* if s + n > the length of mem.data */ /* if s + n > the length of mem.data */
if (src_mem_size < src_offset || src_mem_size - src_offset < len) if (src_mem_size < src_offset || src_mem_size - src_offset < len)
@ -788,7 +790,7 @@ wasm_fill_memory(WASMModuleInstance *inst, uint32 mem_idx, uint32 len,
uint8 *dst_addr; uint8 *dst_addr;
mem_inst = inst->memories[mem_idx]; mem_inst = inst->memories[mem_idx];
mem_size = mem_inst->cur_page_count * mem_inst->num_bytes_per_page; mem_size = mem_inst->cur_page_count * (uint64)mem_inst->num_bytes_per_page;
if (mem_size < dst || mem_size - dst < len) if (mem_size < dst || mem_size - dst < len)
goto out_of_bounds; goto out_of_bounds;

4
core/iwasm/interpreter/wasm.h
View File

@ -1329,8 +1329,8 @@ block_type_get_param_types(BlockType *block_type, uint8 **p_param_types,
param_count = func_type->param_count; param_count = func_type->param_count;
#if WASM_ENABLE_GC != 0 #if WASM_ENABLE_GC != 0
*p_param_reftype_maps = func_type->ref_type_maps; *p_param_reftype_maps = func_type->ref_type_maps;
*p_param_reftype_map_count = *p_param_reftype_map_count = (uint32)(func_type->result_ref_type_maps
func_type->result_ref_type_maps - func_type->ref_type_maps; - func_type->ref_type_maps);
#endif #endif
} }
else { else {

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

@ -1693,7 +1693,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
/* clang-format off */ /* clang-format off */
#if WASM_ENABLE_GC == 0 #if WASM_ENABLE_GC == 0
fidx = tbl_inst->elems[val]; fidx = (uint32)tbl_inst->elems[val];
if (fidx == (uint32)-1) { if (fidx == (uint32)-1) {
wasm_set_exception(module, "uninitialized element"); wasm_set_exception(module, "uninitialized element");
goto got_exception; goto got_exception;

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

@ -1521,7 +1521,7 @@ resolve_func_type(const uint8 **p_buf, const uint8 *buf_end, WASMModule *module,
#endif #endif
#if WASM_ENABLE_WAMR_COMPILER != 0 #if WASM_ENABLE_WAMR_COMPILER != 0
for (i = 0; i < type->param_count + type->result_count; i++) { for (i = 0; i < (uint32)(type->param_count + type->result_count); i++) {
if (type->types[i] == VALUE_TYPE_V128) if (type->types[i] == VALUE_TYPE_V128)
module->is_simd_used = true; module->is_simd_used = true;
} }
@ -1929,8 +1929,8 @@ load_type_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
} }
#else /* else of WASM_ENABLE_GC == 0 */ #else /* else of WASM_ENABLE_GC == 0 */
for (i = 0; i < type_count; i++) { for (i = 0; i < type_count; i++) {
uint32 super_type_count = 0, parent_type_idx = (uint32)-1, uint32 super_type_count = 0, parent_type_idx = (uint32)-1;
rec_count = 1, j; uint32 rec_count = 1, j;
bool is_sub_final = true; bool is_sub_final = true;
CHECK_BUF(p, p_end, 1); CHECK_BUF(p, p_end, 1);
@ -1942,10 +1942,22 @@ load_type_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
if (rec_count > 1) { if (rec_count > 1) {
uint64 new_total_size; uint64 new_total_size;
/* integer overflow */
if (rec_count - 1 > UINT32_MAX - module->type_count) {
set_error_buf(error_buf, error_buf_size,
"recursive type count too large");
return false;
}
module->type_count += rec_count - 1; module->type_count += rec_count - 1;
new_total_size = new_total_size =
sizeof(WASMFuncType *) * (uint64)module->type_count; sizeof(WASMFuncType *) * (uint64)module->type_count;
MEM_REALLOC(module->types, total_size, new_total_size); if (new_total_size > UINT32_MAX) {
set_error_buf(error_buf, error_buf_size,
"allocate memory failed");
return false;
}
MEM_REALLOC(module->types, (uint32)total_size,
(uint32)new_total_size);
total_size = new_total_size; total_size = new_total_size;
} }
@ -5574,8 +5586,8 @@ load_from_sections(WASMModule *module, WASMSection *sections,
*buf_func = NULL, *buf_func_end = NULL; *buf_func = NULL, *buf_func_end = NULL;
WASMGlobal *aux_data_end_global = NULL, *aux_heap_base_global = NULL; WASMGlobal *aux_data_end_global = NULL, *aux_heap_base_global = NULL;
WASMGlobal *aux_stack_top_global = NULL, *global; WASMGlobal *aux_stack_top_global = NULL, *global;
uint64 aux_data_end = (uint64)-1, aux_heap_base = (uint64)-1, uint64 aux_data_end = (uint64)-1LL, aux_heap_base = (uint64)-1LL,
aux_stack_top = (uint64)-1; aux_stack_top = (uint64)-1LL;
uint32 global_index, func_index, i; uint32 global_index, func_index, i;
uint32 aux_data_end_global_index = (uint32)-1; uint32 aux_data_end_global_index = (uint32)-1;
uint32 aux_heap_base_global_index = (uint32)-1; uint32 aux_heap_base_global_index = (uint32)-1;
@ -5715,7 +5727,7 @@ load_from_sections(WASMModule *module, WASMSection *sections,
aux_heap_base_global = global; aux_heap_base_global = global;
aux_heap_base = (uint64)(uint32)global->init_expr.u.i32; aux_heap_base = (uint64)(uint32)global->init_expr.u.i32;
aux_heap_base_global_index = export->index; aux_heap_base_global_index = export->index;
LOG_VERBOSE("Found aux __heap_base global, value: %d", LOG_VERBOSE("Found aux __heap_base global, value: %" PRIu64,
aux_heap_base); aux_heap_base);
} }
} }
@ -5728,7 +5740,7 @@ load_from_sections(WASMModule *module, WASMSection *sections,
aux_data_end_global = global; aux_data_end_global = global;
aux_data_end = (uint64)(uint32)global->init_expr.u.i32; aux_data_end = (uint64)(uint32)global->init_expr.u.i32;
aux_data_end_global_index = export->index; aux_data_end_global_index = export->index;
LOG_VERBOSE("Found aux __data_end global, value: %d", LOG_VERBOSE("Found aux __data_end global, value: %" PRIu64,
aux_data_end); aux_data_end);
aux_data_end = align_uint64(aux_data_end, 16); aux_data_end = align_uint64(aux_data_end, 16);
@ -5778,10 +5790,11 @@ load_from_sections(WASMModule *module, WASMSection *sections,
aux_stack_top > aux_data_end aux_stack_top > aux_data_end
? (uint32)(aux_stack_top - aux_data_end) ? (uint32)(aux_stack_top - aux_data_end)
: (uint32)aux_stack_top; : (uint32)aux_stack_top;
LOG_VERBOSE("Found aux stack top global, value: %d, " LOG_VERBOSE(
"global index: %d, stack size: %d", "Found aux stack top global, value: %" PRIu64 ", "
aux_stack_top, global_index, "global index: %d, stack size: %d",
module->aux_stack_size); aux_stack_top, global_index,
module->aux_stack_size);
break; break;
} }
} }
@ -5929,9 +5942,10 @@ load_from_sections(WASMModule *module, WASMSection *sections,
* memory_import->init_page_count; * memory_import->init_page_count;
if (shrunk_memory_size <= init_memory_size) { if (shrunk_memory_size <= init_memory_size) {
/* Reset memory info to decrease memory usage */ /* Reset memory info to decrease memory usage */
memory_import->num_bytes_per_page = shrunk_memory_size; memory_import->num_bytes_per_page =
(uint32)shrunk_memory_size;
memory_import->init_page_count = 1; memory_import->init_page_count = 1;
LOG_VERBOSE("Shrink import memory size to %d", LOG_VERBOSE("Shrink import memory size to %" PRIu64,
shrunk_memory_size); shrunk_memory_size);
} }
} }
@ -5942,9 +5956,9 @@ load_from_sections(WASMModule *module, WASMSection *sections,
* memory->init_page_count; * memory->init_page_count;
if (shrunk_memory_size <= init_memory_size) { if (shrunk_memory_size <= init_memory_size) {
/* Reset memory info to decrease memory usage */ /* Reset memory info to decrease memory usage */
memory->num_bytes_per_page = shrunk_memory_size; memory->num_bytes_per_page = (uint32)shrunk_memory_size;
memory->init_page_count = 1; memory->init_page_count = 1;
LOG_VERBOSE("Shrink memory size to %d", LOG_VERBOSE("Shrink memory size to %" PRIu64,
shrunk_memory_size); shrunk_memory_size);
} }
} }
@ -6654,7 +6668,7 @@ wasm_loader_unload(WASMModule *module)
#if WASM_ENABLE_STRINGREF != 0 #if WASM_ENABLE_STRINGREF != 0
if (module->string_literal_ptrs) { if (module->string_literal_ptrs) {
wasm_runtime_free(module->string_literal_ptrs); wasm_runtime_free((void *)module->string_literal_ptrs);
} }
if (module->string_literal_lengths) { if (module->string_literal_lengths) {
wasm_runtime_free(module->string_literal_lengths); wasm_runtime_free(module->string_literal_lengths);
@ -8356,12 +8370,12 @@ wasm_loader_pop_nullable_ht(WASMLoaderContext *ctx, uint8 *p_type,
} }
/* Convert to related (ref ht) and return */ /* Convert to related (ref ht) and return */
if ((type >= REF_TYPE_EQREF && type <= REF_TYPE_FUNCREF) if (type >= REF_TYPE_ARRAYREF && type <= REF_TYPE_NULLFUNCREF) {
|| (type >= REF_TYPE_NULLREF && type <= REF_TYPE_I31REF)) { /* Return (ref array/struct/i31/eq/any/extern/func/none/noextern/nofunc)
/* Return (ref func/extern/any/eq/i31/nofunc/noextern/struct/array/none)
*/ */
wasm_set_refheaptype_common(&ref_ht_ret->ref_ht_common, false, wasm_set_refheaptype_common(&ref_ht_ret->ref_ht_common, false,
HEAP_TYPE_FUNC + (type - REF_TYPE_FUNCREF)); HEAP_TYPE_ARRAY
+ (type - REF_TYPE_ARRAYREF));
type = ref_ht_ret->ref_type; type = ref_ht_ret->ref_type;
} }
else if (wasm_is_reftype_htref_nullable(type) else if (wasm_is_reftype_htref_nullable(type)
@ -10067,8 +10081,8 @@ wasm_loader_check_br(WASMLoaderContext *loader_ctx, uint32 depth, uint8 opcode,
loader_ctx->stack_cell_num = stack_cell_num_old; loader_ctx->stack_cell_num = stack_cell_num_old;
loader_ctx->frame_ref = loader_ctx->frame_ref =
loader_ctx->frame_ref_bottom + stack_cell_num_old; loader_ctx->frame_ref_bottom + stack_cell_num_old;
total_size = (uint32)sizeof(uint8) total_size = (uint32)(sizeof(uint8)
* (frame_ref_old - frame_ref_after_popped); * (frame_ref_old - frame_ref_after_popped));
bh_memcpy_s((uint8 *)loader_ctx->frame_ref - total_size, total_size, bh_memcpy_s((uint8 *)loader_ctx->frame_ref - total_size, total_size,
frame_ref_buf, total_size); frame_ref_buf, total_size);
@ -10079,9 +10093,9 @@ wasm_loader_check_br(WASMLoaderContext *loader_ctx, uint32 depth, uint8 opcode,
loader_ctx->reftype_map_num = reftype_map_num_old; loader_ctx->reftype_map_num = reftype_map_num_old;
loader_ctx->frame_reftype_map = loader_ctx->frame_reftype_map =
loader_ctx->frame_reftype_map_bottom + reftype_map_num_old; loader_ctx->frame_reftype_map_bottom + reftype_map_num_old;
total_size = total_size = (uint32)(sizeof(WASMRefTypeMap)
(uint32)sizeof(WASMRefTypeMap) * (frame_reftype_map_old
* (frame_reftype_map_old - frame_reftype_map_after_popped); - frame_reftype_map_after_popped));
bh_memcpy_s((uint8 *)loader_ctx->frame_reftype_map - total_size, bh_memcpy_s((uint8 *)loader_ctx->frame_reftype_map - total_size,
total_size, frame_reftype_map_buf, total_size); total_size, frame_reftype_map_buf, total_size);
#endif #endif
@ -10089,8 +10103,9 @@ wasm_loader_check_br(WASMLoaderContext *loader_ctx, uint32 depth, uint8 opcode,
#if WASM_ENABLE_FAST_INTERP != 0 #if WASM_ENABLE_FAST_INTERP != 0
loader_ctx->frame_offset = loader_ctx->frame_offset =
loader_ctx->frame_offset_bottom + stack_cell_num_old; loader_ctx->frame_offset_bottom + stack_cell_num_old;
total_size = (uint32)sizeof(int16) total_size =
* (frame_offset_old - frame_offset_after_popped); (uint32)(sizeof(int16)
* (frame_offset_old - frame_offset_after_popped));
bh_memcpy_s((uint8 *)loader_ctx->frame_offset - total_size, bh_memcpy_s((uint8 *)loader_ctx->frame_offset - total_size,
total_size, frame_offset_buf, total_size); total_size, frame_offset_buf, total_size);
(loader_ctx->frame_csp - 1)->dynamic_offset = dynamic_offset_old; (loader_ctx->frame_csp - 1)->dynamic_offset = dynamic_offset_old;
@ -10164,7 +10179,7 @@ fail:
#endif #endif
#if WASM_ENABLE_FAST_INTERP != 0 #if WASM_ENABLE_FAST_INTERP != 0
if (frame_offset_buf && frame_offset_buf != frame_offset_tmp) if (frame_offset_buf && frame_offset_buf != frame_offset_tmp)
wasm_runtime_free(frame_offset_tmp); wasm_runtime_free(frame_offset_buf);
#endif #endif
return ret; return ret;
@ -10220,7 +10235,7 @@ check_branch_block_for_delegate(WASMLoaderContext *loader_ctx, uint8 **p_buf,
} }
frame_csp_tmp = loader_ctx->frame_csp - depth - 2; frame_csp_tmp = loader_ctx->frame_csp - depth - 2;
#if WASM_ENABLE_FAST_INTERP != 0 #if WASM_ENABLE_FAST_INTERP != 0
emit_br_info(frame_csp_tmp); emit_br_info(frame_csp_tmp, false);
#endif #endif
*p_buf = p; *p_buf = p;

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

@ -2567,8 +2567,8 @@ load_from_sections(WASMModule *module, WASMSection *sections,
*buf_func = NULL, *buf_func_end = NULL; *buf_func = NULL, *buf_func_end = NULL;
WASMGlobal *aux_data_end_global = NULL, *aux_heap_base_global = NULL; WASMGlobal *aux_data_end_global = NULL, *aux_heap_base_global = NULL;
WASMGlobal *aux_stack_top_global = NULL, *global; WASMGlobal *aux_stack_top_global = NULL, *global;
uint64 aux_data_end = (uint64)-1, aux_heap_base = (uint64)-1, uint64 aux_data_end = (uint64)-1LL, aux_heap_base = (uint64)-1LL,
aux_stack_top = (uint64)-1; aux_stack_top = (uint64)-1LL;
uint32 global_index, func_index, i; uint32 global_index, func_index, i;
uint32 aux_data_end_global_index = (uint32)-1; uint32 aux_data_end_global_index = (uint32)-1;
uint32 aux_heap_base_global_index = (uint32)-1; uint32 aux_heap_base_global_index = (uint32)-1;
@ -2689,7 +2689,7 @@ load_from_sections(WASMModule *module, WASMSection *sections,
aux_heap_base_global = global; aux_heap_base_global = global;
aux_heap_base = (uint64)(uint32)global->init_expr.u.i32; aux_heap_base = (uint64)(uint32)global->init_expr.u.i32;
aux_heap_base_global_index = export->index; aux_heap_base_global_index = export->index;
LOG_VERBOSE("Found aux __heap_base global, value: %d", LOG_VERBOSE("Found aux __heap_base global, value: %" PRIu64,
aux_heap_base); aux_heap_base);
} }
} }
@ -2702,7 +2702,7 @@ load_from_sections(WASMModule *module, WASMSection *sections,
aux_data_end_global = global; aux_data_end_global = global;
aux_data_end = (uint64)(uint32)global->init_expr.u.i32; aux_data_end = (uint64)(uint32)global->init_expr.u.i32;
aux_data_end_global_index = export->index; aux_data_end_global_index = export->index;
LOG_VERBOSE("Found aux __data_end global, value: %d", LOG_VERBOSE("Found aux __data_end global, value: %" PRIu64,
aux_data_end); aux_data_end);
aux_data_end = align_uint64(aux_data_end, 16); aux_data_end = align_uint64(aux_data_end, 16);
} }
@ -2751,10 +2751,11 @@ load_from_sections(WASMModule *module, WASMSection *sections,
aux_stack_top > aux_data_end aux_stack_top > aux_data_end
? (uint32)(aux_stack_top - aux_data_end) ? (uint32)(aux_stack_top - aux_data_end)
: (uint32)aux_stack_top; : (uint32)aux_stack_top;
LOG_VERBOSE("Found aux stack top global, value: %d, " LOG_VERBOSE(
"global index: %d, stack size: %d", "Found aux stack top global, value: %" PRIu64 ", "
aux_stack_top, global_index, "global index: %d, stack size: %d",
module->aux_stack_size); aux_stack_top, global_index,
module->aux_stack_size);
break; break;
} }
} }
@ -2901,7 +2902,7 @@ load_from_sections(WASMModule *module, WASMSection *sections,
/* Reset memory info to decrease memory usage */ /* Reset memory info to decrease memory usage */
memory_import->num_bytes_per_page = shrunk_memory_size; memory_import->num_bytes_per_page = shrunk_memory_size;
memory_import->init_page_count = 1; memory_import->init_page_count = 1;
LOG_VERBOSE("Shrink import memory size to %d", LOG_VERBOSE("Shrink import memory size to %" PRIu64,
shrunk_memory_size); shrunk_memory_size);
} }
} }
@ -2914,7 +2915,7 @@ load_from_sections(WASMModule *module, WASMSection *sections,
/* Reset memory info to decrease memory usage */ /* Reset memory info to decrease memory usage */
memory->num_bytes_per_page = shrunk_memory_size; memory->num_bytes_per_page = shrunk_memory_size;
memory->init_page_count = 1; memory->init_page_count = 1;
LOG_VERBOSE("Shrink memory size to %d", LOG_VERBOSE("Shrink memory size to %" PRIu64,
shrunk_memory_size); shrunk_memory_size);
} }
} }
@ -5646,7 +5647,7 @@ fail:
wasm_runtime_free(frame_ref_buf); wasm_runtime_free(frame_ref_buf);
#if WASM_ENABLE_FAST_INTERP != 0 #if WASM_ENABLE_FAST_INTERP != 0
if (frame_offset_buf && frame_offset_buf != frame_offset_tmp) if (frame_offset_buf && frame_offset_buf != frame_offset_tmp)
wasm_runtime_free(frame_offset_tmp); wasm_runtime_free(frame_offset_buf);
#endif #endif
return ret; return ret;

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

@ -273,7 +273,7 @@ memory_instantiate(WASMModuleInstance *module_inst, WASMModuleInstance *parent,
/* For memory32, the global value should be i32 */ /* For memory32, the global value should be i32 */
*(uint32 *)global_addr = (uint32)aux_heap_base; *(uint32 *)global_addr = (uint32)aux_heap_base;
} }
LOG_VERBOSE("Reset __heap_base global to %lu", aux_heap_base); LOG_VERBOSE("Reset __heap_base global to %" PRIu64, aux_heap_base);
} }
else { else {
/* Insert app heap before new page */ /* Insert app heap before new page */
@ -300,7 +300,8 @@ memory_instantiate(WASMModuleInstance *module_inst, WASMModuleInstance *parent,
LOG_VERBOSE("Memory instantiate:"); LOG_VERBOSE("Memory instantiate:");
LOG_VERBOSE(" page bytes: %u, init pages: %u, max pages: %u", LOG_VERBOSE(" page bytes: %u, init pages: %u, max pages: %u",
num_bytes_per_page, init_page_count, max_page_count); num_bytes_per_page, init_page_count, max_page_count);
LOG_VERBOSE(" heap offset: %u, heap size: %d\n", heap_offset, heap_size); LOG_VERBOSE(" heap offset: %" PRIu64 ", heap size: %u\n", heap_offset,
heap_size);
max_memory_data_size = (uint64)num_bytes_per_page * max_page_count; max_memory_data_size = (uint64)num_bytes_per_page * max_page_count;
bh_assert(max_memory_data_size bh_assert(max_memory_data_size
@ -2379,8 +2380,13 @@ wasm_instantiate(WASMModule *module, WASMModuleInstance *parent,
/* check offset */ /* check offset */
if (base_offset > memory_size) { if (base_offset > memory_size) {
LOG_DEBUG("base_offset(%d) > memory_size(%d)", base_offset, #if WASM_ENABLE_MEMORY64 != 0
LOG_DEBUG("base_offset(%" PRIu64 ") > memory_size(%" PRIu64 ")",
base_offset, memory_size);
#else
LOG_DEBUG("base_offset(%u) > memory_size(%" PRIu64 ")", base_offset,
memory_size); memory_size);
#endif
#if WASM_ENABLE_REF_TYPES != 0 || WASM_ENABLE_GC != 0 #if WASM_ENABLE_REF_TYPES != 0 || WASM_ENABLE_GC != 0
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"out of bounds memory access"); "out of bounds memory access");
@ -2394,8 +2400,14 @@ wasm_instantiate(WASMModule *module, WASMModuleInstance *parent,
/* check offset + length(could be zero) */ /* check offset + length(could be zero) */
length = data_seg->data_length; length = data_seg->data_length;
if ((uint64)base_offset + length > memory_size) { if ((uint64)base_offset + length > memory_size) {
LOG_DEBUG("base_offset(%d) + length(%d) > memory_size(%d)", #if WASM_ENABLE_MEMORY64 != 0
LOG_DEBUG("base_offset(%" PRIu64
") + length(%d) > memory_size(%" PRIu64 ")",
base_offset, length, memory_size); base_offset, length, memory_size);
#else
LOG_DEBUG("base_offset(%u) + length(%d) > memory_size(%" PRIu64 ")",
base_offset, length, memory_size);
#endif
#if WASM_ENABLE_REF_TYPES != 0 || WASM_ENABLE_GC != 0 #if WASM_ENABLE_REF_TYPES != 0 || WASM_ENABLE_GC != 0
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"out of bounds memory access"); "out of bounds memory access");
@ -3356,7 +3368,8 @@ wasm_module_malloc_internal(WASMModuleInstance *module_inst,
wasm_set_exception(module_inst, "app heap corrupted"); wasm_set_exception(module_inst, "app heap corrupted");
} }
else { else {
LOG_WARNING("warning: allocate %u bytes memory failed", size); LOG_WARNING("warning: allocate %" PRIu64 " bytes memory failed",
size);
} }
return 0; return 0;
} }
@ -3555,7 +3568,7 @@ call_indirect(WASMExecEnv *exec_env, uint32 tbl_idx, uint32 tbl_elem_idx,
} }
#if WASM_ENABLE_GC == 0 #if WASM_ENABLE_GC == 0
func_idx = tbl_elem_val; func_idx = (uint32)tbl_elem_val;
#else #else
func_idx = func_idx =
wasm_func_obj_get_func_idx_bound((WASMFuncObjectRef)tbl_elem_val); wasm_func_obj_get_func_idx_bound((WASMFuncObjectRef)tbl_elem_val);
@ -4586,8 +4599,8 @@ wasm_set_module_name(WASMModule *module, const char *name, char *error_buf,
return false; return false;
module->name = module->name =
wasm_const_str_list_insert((const uint8 *)name, strlen(name), module, wasm_const_str_list_insert((const uint8 *)name, (uint32)strlen(name),
false, error_buf, error_buf_size); module, false, error_buf, error_buf_size);
return module->name != NULL; return module->name != NULL;
} }

4
core/iwasm/libraries/debug-engine/handler.c
View File

@ -309,9 +309,11 @@ handle_general_query(WASMGDBServer *server, char *payload)
} }
if (!strcmp(name, "WasmData")) { if (!strcmp(name, "WasmData")) {
write_packet(server, "");
} }
if (!strcmp(name, "WasmMem")) { if (!strcmp(name, "WasmMem")) {
write_packet(server, "");
} }
if (!strcmp(name, "Symbol")) { if (!strcmp(name, "Symbol")) {
@ -447,7 +449,7 @@ send_thread_stop_status(WASMGDBServer *server, uint32 status, korp_tid tid)
"thread-pcs:%" PRIx64 ";00:%s;reason:%s;", pc, "thread-pcs:%" PRIx64 ";00:%s;reason:%s;", pc,
pc_string, "trace"); pc_string, "trace");
} }
else if (status > 0) { else { /* status > 0 (== 0 is checked at the function beginning) */
len += snprintf(tmpbuf + len, MAX_PACKET_SIZE - len, len += snprintf(tmpbuf + len, MAX_PACKET_SIZE - len,
"thread-pcs:%" PRIx64 ";00:%s;reason:%s;", pc, "thread-pcs:%" PRIx64 ";00:%s;reason:%s;", pc,
pc_string, "signal"); pc_string, "signal");

3
core/iwasm/libraries/lib-pthread/lib_pthread_wrapper.c
View File

@ -1123,7 +1123,8 @@ posix_memalign_wrapper(wasm_exec_env_t exec_env, void **memptr, int32 align,
wasm_module_inst_t module_inst = get_module_inst(exec_env); wasm_module_inst_t module_inst = get_module_inst(exec_env);
void *p = NULL; void *p = NULL;
*((int32 *)memptr) = module_malloc(size, (void **)&p); /* TODO: for memory 64, module_malloc may return uint64 offset */
*((uint32 *)memptr) = (uint32)module_malloc(size, (void **)&p);
if (!p) if (!p)
return -1; return -1;

5
core/iwasm/libraries/libc-wasi/sandboxed-system-primitives/src/blocking_op.h
View File

@ -3,6 +3,9 @@
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/ */
#ifndef _BLOCKING_OP_H_
#define _BLOCKING_OP_H_
#include "bh_platform.h" #include "bh_platform.h"
#include "wasm_export.h" #include "wasm_export.h"
@ -57,3 +60,5 @@ __wasi_errno_t
blocking_op_poll(wasm_exec_env_t exec_env, struct pollfd *pfds, nfds_t nfds, blocking_op_poll(wasm_exec_env_t exec_env, struct pollfd *pfds, nfds_t nfds,
int timeout, int *retp); int timeout, int *retp);
#endif #endif
#endif /* end of _BLOCKING_OP_H_ */

4
core/shared/mem-alloc/ems/ems_alloc.c
View File

@ -785,8 +785,8 @@ gc_alloc_wo_internal(void *vheap, gc_size_t size, const char *file, int line)
if (!hmu) if (!hmu)
goto finish; goto finish;
/* Do we need to memset the memory to 0? */ /* Don't memset the memory to improve performance, the caller should
/* memset((char *)hmu + sizeof(*hmu), 0, tot_size - sizeof(*hmu)); */ decide whether to memset it or not */
bh_assert(hmu_get_size(hmu) >= tot_size); bh_assert(hmu_get_size(hmu) >= tot_size);
/* the total size allocated may be larger than /* the total size allocated may be larger than

16
core/shared/mem-alloc/ems/ems_gc.c
View File

@ -114,8 +114,8 @@ sweep_instance_heap(gc_heap_t *heap)
else { else {
/* current block is still live */ /* current block is still live */
if (last) { if (last) {
tot_free += (char *)cur - (char *)last; tot_free += (gc_size_t)((char *)cur - (char *)last);
gci_add_fc(heap, last, (char *)cur - (char *)last); gci_add_fc(heap, last, (gc_size_t)((char *)cur - (char *)last));
hmu_mark_pinuse(last); hmu_mark_pinuse(last);
last = NULL; last = NULL;
} }
@ -132,8 +132,8 @@ sweep_instance_heap(gc_heap_t *heap)
bh_assert(cur == end); bh_assert(cur == end);
if (last) { if (last) {
tot_free += (char *)cur - (char *)last; tot_free += (gc_size_t)((char *)cur - (char *)last);
gci_add_fc(heap, last, (char *)cur - (char *)last); gci_add_fc(heap, last, (gc_size_t)((char *)cur - (char *)last));
hmu_mark_pinuse(last); hmu_mark_pinuse(last);
} }
@ -449,7 +449,9 @@ gci_gc_heap(void *h)
LOG_VERBOSE("#reclaim instance heap %p", heap); LOG_VERBOSE("#reclaim instance heap %p", heap);
gct_vm_gc_prepare(); /* TODO: get exec_env of current thread when GC multi-threading
is enabled, and pass it to runtime */
gct_vm_gc_prepare(NULL);
gct_vm_mutex_lock(&heap->lock); gct_vm_mutex_lock(&heap->lock);
heap->is_doing_reclaim = 1; heap->is_doing_reclaim = 1;
@ -459,7 +461,9 @@ gci_gc_heap(void *h)
heap->is_doing_reclaim = 0; heap->is_doing_reclaim = 0;
gct_vm_mutex_unlock(&heap->lock); gct_vm_mutex_unlock(&heap->lock);
gct_vm_gc_finished(); /* TODO: get exec_env of current thread when GC multi-threading
is enabled, and pass it to runtime */
gct_vm_gc_finished(NULL);
LOG_VERBOSE("#reclaim instance heap %p done", heap); LOG_VERBOSE("#reclaim instance heap %p done", heap);

4
core/shared/mem-alloc/mem_alloc.c
View File

@ -77,13 +77,13 @@ mem_allocator_free_with_gc(mem_allocator_t allocator, void *ptr)
void void
mem_allocator_enable_gc_reclaim(mem_allocator_t allocator, void *exec_env) mem_allocator_enable_gc_reclaim(mem_allocator_t allocator, void *exec_env)
{ {
return gc_enable_gc_reclaim((gc_handle_t)allocator, exec_env); gc_enable_gc_reclaim((gc_handle_t)allocator, exec_env);
} }
#else #else
void void
mem_allocator_enable_gc_reclaim(mem_allocator_t allocator, void *cluster) mem_allocator_enable_gc_reclaim(mem_allocator_t allocator, void *cluster)
{ {
return gc_enable_gc_reclaim((gc_handle_t)allocator, cluster); gc_enable_gc_reclaim((gc_handle_t)allocator, cluster);
} }
#endif #endif

2
core/shared/utils/runtime_timer.c
View File

@ -394,7 +394,7 @@ handle_expired_timers(timer_ctx_t ctx, app_timer_t *expired)
operation may change expired->next */ operation may change expired->next */
expired = expired->next; expired = expired->next;
if (t->is_periodic) { if (t->is_periodic) {
/* if it is repeating, then reschedule it; */ /* if it is repeating, then reschedule it */
reschedule_timer(ctx, t); reschedule_timer(ctx, t);
} }
else { else {

3
product-mini/platforms/posix/main.c
View File

@ -851,7 +851,8 @@ main(int argc, char *argv[])
#if WASM_ENABLE_DEBUG_INTERP != 0 #if WASM_ENABLE_DEBUG_INTERP != 0
init_args.instance_port = instance_port; init_args.instance_port = instance_port;
if (ip_addr) if (ip_addr)
strcpy(init_args.ip_addr, ip_addr); /* ensure that init_args.ip_addr is null terminated */
strncpy(init_args.ip_addr, ip_addr, sizeof(init_args.ip_addr) - 1);
#endif #endif
/* initialize runtime environment */ /* initialize runtime environment */

4
product-mini/platforms/windows/main.c
View File

@ -464,7 +464,9 @@ main(int argc, char *argv[])
#if WASM_ENABLE_DEBUG_INTERP != 0 #if WASM_ENABLE_DEBUG_INTERP != 0
init_args.instance_port = instance_port; init_args.instance_port = instance_port;
if (ip_addr) if (ip_addr)
strcpy(init_args.ip_addr, ip_addr); /* ensure that init_args.ip_addr is null terminated */
strncpy_s(init_args.ip_addr, sizeof(init_args.ip_addr) - 1, ip_addr,
strlen(ip_addr));
#endif #endif
/* initialize runtime environment */ /* initialize runtime environment */