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

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.

.github/workflows/codeql_buildscript.sh

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

core/iwasm/aot/aot_loader.c

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

core/iwasm/aot/aot_runtime.c

@@ -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;
 }
 

core/iwasm/common/gc/gc_type.c

@@ -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;

core/iwasm/common/wasm_c_api.c

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

core/iwasm/common/wasm_memory.c

@@ -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;
-}
+}

core/iwasm/common/wasm_runtime_common.c

@@ -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);

core/iwasm/compilation/aot_compiler.c

@@ -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");

core/iwasm/compilation/aot_emit_control.c

@@ -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;

core/iwasm/compilation/aot_llvm.c

@@ -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;

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

@@ -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[] = {

core/iwasm/fast-jit/fe/jit_emit_memory.c

@@ -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;

core/iwasm/interpreter/wasm.h

@@ -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 {

core/iwasm/interpreter/wasm_interp_fast.c

@@ -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;

core/iwasm/interpreter/wasm_loader.c

@@ -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;

core/iwasm/interpreter/wasm_mini_loader.c

@@ -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;

core/iwasm/interpreter/wasm_runtime.c

@@ -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;
-}
+}

core/iwasm/libraries/debug-engine/handler.c

@@ -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");

core/iwasm/libraries/lib-pthread/lib_pthread_wrapper.c

@@ -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;
 

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

@@ -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_ */

core/shared/mem-alloc/ems/ems_alloc.c

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

core/shared/mem-alloc/ems/ems_gc.c

@@ -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);
 

core/shared/mem-alloc/mem_alloc.c

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

core/shared/utils/runtime_timer.c

@@ -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 {

product-mini/platforms/posix/main.c

@@ -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 */

product-mini/platforms/windows/main.c

@@ -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 */