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.
2025-02-06 06:55:07 +00:00 · 2024-04-07 11:57:31 +08:00 · 2024-04-07 11:57:31 +08:00 · 2013f1f7d7
commit 2013f1f7d7
parent 53f0941ffa
26 changed files with 202 additions and 118 deletions
--- a/.github/workflows/codeql_buildscript.sh
+++ b/.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
--- a/core/iwasm/aot/aot_loader.c
+++ b/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
--- a/core/iwasm/aot/aot_runtime.c
+++ b/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,8 +4724,8 @@ 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,
 #endif
--- a/core/iwasm/common/gc/gc_type.c
+++ b/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;
--- a/core/iwasm/common/wasm_c_api.c
+++ b/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

--- a/core/iwasm/common/wasm_memory.c
+++ b/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))) {
--- a/core/iwasm/common/wasm_runtime_common.c
+++ b/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);
--- a/core/iwasm/compilation/aot_compiler.c
+++ b/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");
--- a/core/iwasm/compilation/aot_emit_control.c
+++ b/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;
--- a/core/iwasm/compilation/aot_llvm.c
+++ b/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;
--- a/core/iwasm/fast-jit/cg/x86-64/jit_codegen_x86_64.cpp
+++ b/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[] = {
--- a/core/iwasm/fast-jit/fe/jit_emit_memory.c
+++ b/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;
--- a/core/iwasm/interpreter/wasm.h
+++ b/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 {
--- a/core/iwasm/interpreter/wasm_interp_fast.c
+++ b/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;
--- a/core/iwasm/interpreter/wasm_loader.c
+++ b/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,7 +5790,8 @@ 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, "
+                        LOG_VERBOSE(
+                            "Found aux stack top global, value: %" PRIu64 ", "
                            "global index: %d, stack size: %d",
                            aux_stack_top, global_index,
                            module->aux_stack_size);
@ -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;
--- a/core/iwasm/interpreter/wasm_mini_loader.c
+++ b/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,7 +2751,8 @@ 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, "
+                        LOG_VERBOSE(
+                            "Found aux stack top global, value: %" PRIu64 ", "
                            "global index: %d, stack size: %d",
                            aux_stack_top, global_index,
                            module->aux_stack_size);
@ -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;
--- a/core/iwasm/interpreter/wasm_runtime.c
+++ b/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;
 }

--- a/core/iwasm/libraries/debug-engine/handler.c
+++ b/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");
--- a/core/iwasm/libraries/lib-pthread/lib_pthread_wrapper.c
+++ b/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;

--- a/core/iwasm/libraries/libc-wasi/sandboxed-system-primitives/src/blocking_op.h
+++ b/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_ */
--- a/core/shared/mem-alloc/ems/ems_alloc.c
+++ b/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
--- a/core/shared/mem-alloc/ems/ems_gc.c
+++ b/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);

--- a/core/shared/mem-alloc/mem_alloc.c
+++ b/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

--- a/core/shared/utils/runtime_timer.c
+++ b/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 {
--- a/product-mini/platforms/posix/main.c
+++ b/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 */
--- a/product-mini/platforms/windows/main.c
+++ b/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 */