gnh1201/wasm-micro-runtime
1
0
Fork 0
mirror of https://github.com/bytecodealliance/wasm-micro-runtime.git synced 2025-02-06 06:55:07 +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;
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
cd ${WAMR_DIR}/product-mini/platforms/linux
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);
#if WASM_ENABLE_GC != 0
if (wasm_is_type_multi_byte_type(elem_type)) {
/* TODO: check ref_type */
read_uint16(buf, buf_end, reftype.ref_ht_common.ref_type);
read_uint16(buf, buf_end, reftype.ref_ht_common.nullable);
uint16 ref_type, nullable;
read_uint16(buf, buf_end, ref_type);
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);
}
else
@ -4379,7 +4390,7 @@ aot_unload(AOTModule *module)
}
if (module->string_literal_ptrs) {
wasm_runtime_free(module->string_literal_ptrs);
wasm_runtime_free((void *)module->string_literal_ptrs);
}
}
#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
+ module->globals[global_idx].data_offset;
*(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 {
/* Insert app heap before new page */
@ -906,9 +906,10 @@ memory_instantiate(AOTModuleInstance *module_inst, AOTModuleInstance *parent,
LOG_VERBOSE("Memory instantiate:");
LOG_VERBOSE(" page bytes: %u, init pages: %u, max pages: %u",
num_bytes_per_page, init_page_count, max_page_count);
LOG_VERBOSE(" data offset: %u, stack size: %d", module->aux_data_end,
module->aux_stack_size);
LOG_VERBOSE(" heap offset: %u, heap size: %d\n", heap_offset, heap_size);
LOG_VERBOSE(" data offset: %" PRIu64 ", stack size: %d",
module->aux_data_end, module->aux_stack_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;
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 offset since length might negative */
if (base_offset > memory_inst->memory_data_size) {
LOG_DEBUG("base_offset(%d) > memory_data_size(%d)", base_offset,
memory_inst->memory_data_size);
LOG_DEBUG("base_offset(%d) > memory_data_size(%" PRIu64 ")",
base_offset, memory_inst->memory_data_size);
#if WASM_ENABLE_REF_TYPES != 0
set_error_buf(error_buf, error_buf_size,
"out of bounds memory access");
@ -1085,7 +1086,8 @@ memories_instantiate(AOTModuleInstance *module_inst, AOTModuleInstance *parent,
/* check offset + length(could be zero) */
length = data_seg->byte_count;
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);
#if WASM_ENABLE_REF_TYPES != 0
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");
}
else {
LOG_WARNING("warning: allocate %u bytes memory failed", size);
LOG_WARNING("warning: allocate %" PRIu64 " bytes memory failed",
size);
}
return 0;
}
@ -2806,7 +2809,7 @@ aot_call_indirect(WASMExecEnv *exec_env, uint32 tbl_idx, uint32 table_elem_idx,
}
#if WASM_ENABLE_GC == 0
func_idx = tbl_elem_val;
func_idx = (uint32)tbl_elem_val;
#else
func_idx =
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.module_offset = 0;
frame.func_index = cur_frame->func_index;
frame.func_offset = cur_frame->ip_offset;
frame.func_name_wp =
get_func_name_from_index(module_inst, cur_frame->func_index);
frame.func_index = (uint32)cur_frame->func_index;
frame.func_offset = (uint32)cur_frame->ip_offset;
frame.func_name_wp = get_func_name_from_index(
module_inst, (uint32)cur_frame->func_index);
if (cur_frame->func_index >= module->import_func_count) {
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_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)
return false;
module->name =
aot_const_str_set_insert((const uint8 *)name, strlen(name) + 1, module,
module->name = aot_const_str_set_insert((const uint8 *)name,
(uint32)(strlen(name) + 1), module,
#if (WASM_ENABLE_WORD_ALIGN_READ != 0)
false,
false,
#endif
error_buf, error_buf_size);
error_buf, error_buf_size);
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("] -> [");
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])) {
bh_assert(j < type->ref_type_map_count);
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)
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])
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])) {
bh_assert(j1 < type1->ref_type_map_count);
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) {
return NULL;
}
ref_idx = table_interp->elems[index];
ref_idx = (uint32)table_interp->elems[index];
}
#endif
@ -3998,7 +3998,7 @@ wasm_table_get(const wasm_table_t *table, wasm_table_size_t index)
if (index >= table_aot->cur_size) {
return NULL;
}
ref_idx = table_aot->elems[index];
ref_idx = (uint32)table_aot->elems[index];
}
#endif

8
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 uint32
static uint64
align_as_and_cast(uint64 size, uint64 alignment)
{
uint64 aligned_size = (size + alignment - 1) & ~(alignment - 1);
return aligned_size > UINT32_MAX ? UINT32_MAX : (uint32)aligned_size;
return aligned_size;
}
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);
}
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 (!(*data = wasm_mmap_linear_memory(map_size, *memory_data_size))) {
@ -960,4 +960,4 @@ wasm_allocate_linear_memory(uint8 **data, bool is_shared_memory,
}
return BHT_OK;
}
}

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

@ -275,11 +275,11 @@ decode_insn(uint8 *insn)
buffer, sizeof(buffer),
runtime_address);
#if 0
/* Print current instruction */
/*
os_printf("%012" PRIX64 " ", runtime_address);
puts(buffer);
*/
#endif
return instruction.length;
}
@ -1043,7 +1043,7 @@ wasm_runtime_register_module_internal(const char *module_name,
/* module hasn't been registered */
node = runtime_malloc(sizeof(WASMRegisteredModule), NULL, NULL, 0);
if (!node) {
LOG_DEBUG("malloc WASMRegisteredModule failed. SZ=%d",
LOG_DEBUG("malloc WASMRegisteredModule failed. SZ=%zu",
sizeof(WASMRegisteredModule));
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_exec_env_mem_consumption(exec_env);
os_printf("\nTotal memory consumption of module, module inst and "
"exec env: %u\n",
"exec env: %" PRIu64 "\n",
total_size);
os_printf("Total interpreter stack used: %u\n",
exec_env->max_wasm_stack_used);
@ -5488,6 +5488,7 @@ wasm_externref_set_cleanup(WASMModuleInstanceCommon *module_inst,
if (lookup_user_data.found) {
void *key = (void *)(uintptr_t)lookup_user_data.externref_idx;
ExternRefMapNode *node = bh_hash_map_find(externref_map, key);
bh_assert(node);
node->cleanup = extern_obj_cleanup;
ok = true;
}
@ -6539,12 +6540,12 @@ wasm_runtime_load_depended_module(const WASMModuleCommon *parent_module,
if (!ret) {
LOG_DEBUG("read the file of %s failed", sub_module_name);
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;
}
if (get_package_type(buffer, buffer_size) != parent_module->module_type) {
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 WASM_ENABLE_INTERP != 0
@ -6650,7 +6651,7 @@ wasm_runtime_sub_module_instantiate(WASMModuleCommon *module,
sub_module_inst_list_node = loader_malloc(sizeof(WASMSubModInstNode),
error_buf, error_buf_size);
if (!sub_module_inst_list_node) {
LOG_DEBUG("Malloc WASMSubModInstNode failed, SZ:%d",
LOG_DEBUG("Malloc WASMSubModInstNode failed, SZ: %zu",
sizeof(WASMSubModInstNode));
if (sub_module_inst)
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)
continue;
n = p - frame->lp;
n = (uint32)(p - frame->lp);
/* Commit reference flag */
if (comp_ctx->enable_gc) {
@ -432,7 +432,7 @@ aot_gen_commit_values(AOTCompFrame *frame)
continue;
p->dirty = 0;
n = p - frame->lp;
n = (uint32)(p - frame->lp);
/* Commit values */
switch (p->type) {
@ -538,7 +538,7 @@ aot_gen_commit_values(AOTCompFrame *frame)
/* Clear reference flags for unused stack slots. */
for (p = frame->sp; p < end; p++) {
bh_assert(!p->ref);
n = p - frame->lp;
n = (uint32)(p - frame->lp);
/* Commit reference flag. */
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) {
n = sp - frame->lp;
n = (uint32)(sp - frame->lp);
value = I32_CONST(offset_of_local(comp_ctx, n));
if (!value) {
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]);
}
wasm_runtime_free(values);
values = NULL;
}
target_block->is_reachable = true;
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]);
}
wasm_runtime_free(values);
values = NULL;
}
if (i == br_count)
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;
/* 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++) {
if (!check_wasm_type(comp_ctx, aot_func_type->types[i]))
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); \
} \
/* 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); \
CHECK_REG_NO(reg_no_dst, jit_reg_kind(r0)); \
/* 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 */
};
static const JitHardRegInfo hreg_info = {
static const JitHardRegInfo g_hreg_info = {
{
{ 0, NULL, NULL, NULL }, /* VOID */
@ -9459,7 +9459,7 @@ static const JitHardRegInfo hreg_info = {
const JitHardRegInfo *
jit_codegen_get_hreg_info()
{
return &hreg_info;
return &g_hreg_info;
}
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 */
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)
goto out_of_bounds;
@ -724,8 +724,10 @@ wasm_copy_memory(WASMModuleInstance *inst, uint32 src_mem_idx,
src_mem = inst->memories[src_mem_idx];
dst_mem = inst->memories[dst_mem_idx];
src_mem_size = src_mem->cur_page_count * src_mem->num_bytes_per_page;
dst_mem_size = dst_mem->cur_page_count * dst_mem->num_bytes_per_page;
src_mem_size =
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 (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;
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)
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;
#if WASM_ENABLE_GC != 0
*p_param_reftype_maps = func_type->ref_type_maps;
*p_param_reftype_map_count =
func_type->result_ref_type_maps - func_type->ref_type_maps;
*p_param_reftype_map_count = (uint32)(func_type->result_ref_type_maps
- func_type->ref_type_maps);
#endif
}
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 */
#if WASM_ENABLE_GC == 0
fidx = tbl_inst->elems[val];
fidx = (uint32)tbl_inst->elems[val];
if (fidx == (uint32)-1) {
wasm_set_exception(module, "uninitialized element");
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
#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)
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 */
for (i = 0; i < type_count; i++) {
uint32 super_type_count = 0, parent_type_idx = (uint32)-1,
rec_count = 1, j;
uint32 super_type_count = 0, parent_type_idx = (uint32)-1;
uint32 rec_count = 1, j;
bool is_sub_final = true;
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) {
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;
new_total_size =
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;
}
@ -5574,8 +5586,8 @@ load_from_sections(WASMModule *module, WASMSection *sections,
*buf_func = NULL, *buf_func_end = NULL;
WASMGlobal *aux_data_end_global = NULL, *aux_heap_base_global = NULL;
WASMGlobal *aux_stack_top_global = NULL, *global;
uint64 aux_data_end = (uint64)-1, aux_heap_base = (uint64)-1,
aux_stack_top = (uint64)-1;
uint64 aux_data_end = (uint64)-1LL, aux_heap_base = (uint64)-1LL,
aux_stack_top = (uint64)-1LL;
uint32 global_index, func_index, i;
uint32 aux_data_end_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 = (uint64)(uint32)global->init_expr.u.i32;
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);
}
}
@ -5728,7 +5740,7 @@ load_from_sections(WASMModule *module, WASMSection *sections,
aux_data_end_global = global;
aux_data_end = (uint64)(uint32)global->init_expr.u.i32;
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 = align_uint64(aux_data_end, 16);
@ -5778,10 +5790,11 @@ load_from_sections(WASMModule *module, WASMSection *sections,
aux_stack_top > aux_data_end
? (uint32)(aux_stack_top - aux_data_end)
: (uint32)aux_stack_top;
LOG_VERBOSE("Found aux stack top global, value: %d, "
"global index: %d, stack size: %d",
aux_stack_top, global_index,
module->aux_stack_size);
LOG_VERBOSE(
"Found aux stack top global, value: %" PRIu64 ", "
"global index: %d, stack size: %d",
aux_stack_top, global_index,
module->aux_stack_size);
break;
}
}
@ -5929,9 +5942,10 @@ load_from_sections(WASMModule *module, WASMSection *sections,
* memory_import->init_page_count;
if (shrunk_memory_size <= init_memory_size) {
/* 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;
LOG_VERBOSE("Shrink import memory size to %d",
LOG_VERBOSE("Shrink import memory size to %" PRIu64,
shrunk_memory_size);
}
}
@ -5942,9 +5956,9 @@ load_from_sections(WASMModule *module, WASMSection *sections,
* memory->init_page_count;
if (shrunk_memory_size <= init_memory_size) {
/* 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;
LOG_VERBOSE("Shrink memory size to %d",
LOG_VERBOSE("Shrink memory size to %" PRIu64,
shrunk_memory_size);
}
}
@ -6654,7 +6668,7 @@ wasm_loader_unload(WASMModule *module)
#if WASM_ENABLE_STRINGREF != 0
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) {
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 */
if ((type >= REF_TYPE_EQREF && type <= REF_TYPE_FUNCREF)
|| (type >= REF_TYPE_NULLREF && type <= REF_TYPE_I31REF)) {
/* Return (ref func/extern/any/eq/i31/nofunc/noextern/struct/array/none)
if (type >= REF_TYPE_ARRAYREF && type <= REF_TYPE_NULLFUNCREF) {
/* Return (ref array/struct/i31/eq/any/extern/func/none/noextern/nofunc)
*/
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;
}
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->frame_ref =
loader_ctx->frame_ref_bottom + stack_cell_num_old;
total_size = (uint32)sizeof(uint8)
* (frame_ref_old - frame_ref_after_popped);
total_size = (uint32)(sizeof(uint8)
* (frame_ref_old - frame_ref_after_popped));
bh_memcpy_s((uint8 *)loader_ctx->frame_ref - total_size, 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->frame_reftype_map =
loader_ctx->frame_reftype_map_bottom + reftype_map_num_old;
total_size =
(uint32)sizeof(WASMRefTypeMap)
* (frame_reftype_map_old - frame_reftype_map_after_popped);
total_size = (uint32)(sizeof(WASMRefTypeMap)
* (frame_reftype_map_old
- frame_reftype_map_after_popped));
bh_memcpy_s((uint8 *)loader_ctx->frame_reftype_map - total_size,
total_size, frame_reftype_map_buf, total_size);
#endif
@ -10089,8 +10103,9 @@ wasm_loader_check_br(WASMLoaderContext *loader_ctx, uint32 depth, uint8 opcode,
#if WASM_ENABLE_FAST_INTERP != 0
loader_ctx->frame_offset =
loader_ctx->frame_offset_bottom + stack_cell_num_old;
total_size = (uint32)sizeof(int16)
* (frame_offset_old - frame_offset_after_popped);
total_size =
(uint32)(sizeof(int16)
* (frame_offset_old - frame_offset_after_popped));
bh_memcpy_s((uint8 *)loader_ctx->frame_offset - total_size,
total_size, frame_offset_buf, total_size);
(loader_ctx->frame_csp - 1)->dynamic_offset = dynamic_offset_old;
@ -10164,7 +10179,7 @@ fail:
#endif
#if WASM_ENABLE_FAST_INTERP != 0
if (frame_offset_buf && frame_offset_buf != frame_offset_tmp)
wasm_runtime_free(frame_offset_tmp);
wasm_runtime_free(frame_offset_buf);
#endif
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;
#if WASM_ENABLE_FAST_INTERP != 0
emit_br_info(frame_csp_tmp);
emit_br_info(frame_csp_tmp, false);
#endif
*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;
WASMGlobal *aux_data_end_global = NULL, *aux_heap_base_global = NULL;
WASMGlobal *aux_stack_top_global = NULL, *global;
uint64 aux_data_end = (uint64)-1, aux_heap_base = (uint64)-1,
aux_stack_top = (uint64)-1;
uint64 aux_data_end = (uint64)-1LL, aux_heap_base = (uint64)-1LL,
aux_stack_top = (uint64)-1LL;
uint32 global_index, func_index, i;
uint32 aux_data_end_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 = (uint64)(uint32)global->init_expr.u.i32;
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);
}
}
@ -2702,7 +2702,7 @@ load_from_sections(WASMModule *module, WASMSection *sections,
aux_data_end_global = global;
aux_data_end = (uint64)(uint32)global->init_expr.u.i32;
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 = align_uint64(aux_data_end, 16);
}
@ -2751,10 +2751,11 @@ load_from_sections(WASMModule *module, WASMSection *sections,
aux_stack_top > aux_data_end
? (uint32)(aux_stack_top - aux_data_end)
: (uint32)aux_stack_top;
LOG_VERBOSE("Found aux stack top global, value: %d, "
"global index: %d, stack size: %d",
aux_stack_top, global_index,
module->aux_stack_size);
LOG_VERBOSE(
"Found aux stack top global, value: %" PRIu64 ", "
"global index: %d, stack size: %d",
aux_stack_top, global_index,
module->aux_stack_size);
break;
}
}
@ -2901,7 +2902,7 @@ load_from_sections(WASMModule *module, WASMSection *sections,
/* Reset memory info to decrease memory usage */
memory_import->num_bytes_per_page = shrunk_memory_size;
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);
}
}
@ -2914,7 +2915,7 @@ load_from_sections(WASMModule *module, WASMSection *sections,
/* Reset memory info to decrease memory usage */
memory->num_bytes_per_page = shrunk_memory_size;
memory->init_page_count = 1;
LOG_VERBOSE("Shrink memory size to %d",
LOG_VERBOSE("Shrink memory size to %" PRIu64,
shrunk_memory_size);
}
}
@ -5646,7 +5647,7 @@ fail:
wasm_runtime_free(frame_ref_buf);
#if WASM_ENABLE_FAST_INTERP != 0
if (frame_offset_buf && frame_offset_buf != frame_offset_tmp)
wasm_runtime_free(frame_offset_tmp);
wasm_runtime_free(frame_offset_buf);
#endif
return ret;

31
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 */
*(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 {
/* Insert app heap before new page */
@ -300,7 +300,8 @@ memory_instantiate(WASMModuleInstance *module_inst, WASMModuleInstance *parent,
LOG_VERBOSE("Memory instantiate:");
LOG_VERBOSE(" page bytes: %u, init pages: %u, max pages: %u",
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;
bh_assert(max_memory_data_size
@ -2379,8 +2380,13 @@ wasm_instantiate(WASMModule *module, WASMModuleInstance *parent,
/* check offset */
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);
#endif
#if WASM_ENABLE_REF_TYPES != 0 || WASM_ENABLE_GC != 0
set_error_buf(error_buf, error_buf_size,
"out of bounds memory access");
@ -2394,8 +2400,14 @@ wasm_instantiate(WASMModule *module, WASMModuleInstance *parent,
/* check offset + length(could be zero) */
length = data_seg->data_length;
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);
#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
set_error_buf(error_buf, error_buf_size,
"out of bounds memory access");
@ -3356,7 +3368,8 @@ wasm_module_malloc_internal(WASMModuleInstance *module_inst,
wasm_set_exception(module_inst, "app heap corrupted");
}
else {
LOG_WARNING("warning: allocate %u bytes memory failed", size);
LOG_WARNING("warning: allocate %" PRIu64 " bytes memory failed",
size);
}
return 0;
}
@ -3555,7 +3568,7 @@ call_indirect(WASMExecEnv *exec_env, uint32 tbl_idx, uint32 tbl_elem_idx,
}
#if WASM_ENABLE_GC == 0
func_idx = tbl_elem_val;
func_idx = (uint32)tbl_elem_val;
#else
func_idx =
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;
module->name =
wasm_const_str_list_insert((const uint8 *)name, strlen(name), module,
false, error_buf, error_buf_size);
wasm_const_str_list_insert((const uint8 *)name, (uint32)strlen(name),
module, false, error_buf, error_buf_size);
return module->name != NULL;
}
@ -4595,4 +4608,4 @@ const char *
wasm_get_module_name(WASMModule *module)
{
return module->name;
}
}

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")) {
write_packet(server, "");
}
if (!strcmp(name, "WasmMem")) {
write_packet(server, "");
}
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,
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,
"thread-pcs:%" PRIx64 ";00:%s;reason:%s;", pc,
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);
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)
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
*/
#ifndef _BLOCKING_OP_H_
#define _BLOCKING_OP_H_
#include "bh_platform.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,
int timeout, int *retp);
#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)
goto finish;
/* Do we need to memset the memory to 0? */
/* memset((char *)hmu + sizeof(*hmu), 0, tot_size - sizeof(*hmu)); */
/* Don't memset the memory to improve performance, the caller should
decide whether to memset it or not */
bh_assert(hmu_get_size(hmu) >= tot_size);
/* 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 {
/* current block is still live */
if (last) {
tot_free += (char *)cur - (char *)last;
gci_add_fc(heap, last, (char *)cur - (char *)last);
tot_free += (gc_size_t)((char *)cur - (char *)last);
gci_add_fc(heap, last, (gc_size_t)((char *)cur - (char *)last));
hmu_mark_pinuse(last);
last = NULL;
}
@ -132,8 +132,8 @@ sweep_instance_heap(gc_heap_t *heap)
bh_assert(cur == end);
if (last) {
tot_free += (char *)cur - (char *)last;
gci_add_fc(heap, last, (char *)cur - (char *)last);
tot_free += (gc_size_t)((char *)cur - (char *)last);
gci_add_fc(heap, last, (gc_size_t)((char *)cur - (char *)last));
hmu_mark_pinuse(last);
}
@ -449,7 +449,9 @@ gci_gc_heap(void *h)
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);
heap->is_doing_reclaim = 1;
@ -459,7 +461,9 @@ gci_gc_heap(void *h)
heap->is_doing_reclaim = 0;
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);

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
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
void
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

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 */
expired = expired->next;
if (t->is_periodic) {
/* if it is repeating, then reschedule it; */
/* if it is repeating, then reschedule it */
reschedule_timer(ctx, t);
}
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
init_args.instance_port = instance_port;
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
/* 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
init_args.instance_port = instance_port;
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
/* initialize runtime environment */