From 23e1d515879cc13693eb25d8472a4746e7c36ba1 Mon Sep 17 00:00:00 2001 From: Wenyong Huang Date: Fri, 31 May 2024 11:32:36 +0800 Subject: [PATCH] Fix loader parse block type and calculate dynamic offset for loop args (#3482) Fix several issues in wasm loader: - Parse a block's type index with leb int32 instead leb uint32 - Correct dst dynamic offset of loop block arguments for opcode br when copying the stack operands to the arguments of loop block - Free each frame_csp's param_frame_offsets when destroy loader ctx - Fix compilation error in wasm_mini_loader.c - Add test cases of failed issues This PR fixes issue #3467 and #3468. --- core/iwasm/compilation/aot_compiler.c | 8 ++- core/iwasm/fast-jit/jit_frontend.c | 4 +- core/iwasm/interpreter/wasm_loader.c | 65 ++++++++++++++---- core/iwasm/interpreter/wasm_mini_loader.c | 62 +++++++++++++---- .../issues/issue-3467/tt_unreachable.wasm | Bin 0 -> 237 bytes .../ba-issues/issues/issue-3468/i64.add.wasm | Bin 0 -> 14593 bytes .../regression/ba-issues/running_config.json | 32 +++++++++ 7 files changed, 139 insertions(+), 32 deletions(-) create mode 100644 tests/regression/ba-issues/issues/issue-3467/tt_unreachable.wasm create mode 100644 tests/regression/ba-issues/issues/issue-3468/i64.add.wasm diff --git a/core/iwasm/compilation/aot_compiler.c b/core/iwasm/compilation/aot_compiler.c index 5c66e0fe..96ed8fac 100644 --- a/core/iwasm/compilation/aot_compiler.c +++ b/core/iwasm/compilation/aot_compiler.c @@ -1028,7 +1028,9 @@ aot_compile_func(AOTCompContext *comp_ctx, uint32 func_index) } else { frame_ip--; - read_leb_uint32(frame_ip, frame_ip_end, type_index); + read_leb_int32(frame_ip, frame_ip_end, type_index); + /* type index was checked in wasm loader */ + bh_assert(type_index < comp_ctx->comp_data->type_count); func_type = (AOTFuncType *)comp_ctx->comp_data->types[type_index]; param_count = func_type->param_count; @@ -1048,7 +1050,9 @@ aot_compile_func(AOTCompContext *comp_ctx, uint32 func_index) case EXT_OP_LOOP: case EXT_OP_IF: { - read_leb_uint32(frame_ip, frame_ip_end, type_index); + read_leb_int32(frame_ip, frame_ip_end, type_index); + /* type index was checked in wasm loader */ + bh_assert(type_index < comp_ctx->comp_data->type_count); func_type = (AOTFuncType *)comp_ctx->comp_data->types[type_index]; param_count = func_type->param_count; diff --git a/core/iwasm/fast-jit/jit_frontend.c b/core/iwasm/fast-jit/jit_frontend.c index 092f9c0c..17c33230 100644 --- a/core/iwasm/fast-jit/jit_frontend.c +++ b/core/iwasm/fast-jit/jit_frontend.c @@ -1510,7 +1510,9 @@ jit_compile_func(JitCompContext *cc) case EXT_OP_LOOP: case EXT_OP_IF: { - read_leb_uint32(frame_ip, frame_ip_end, type_idx); + read_leb_int32(frame_ip, frame_ip_end, type_idx); + /* type index was checked in wasm loader */ + bh_assert(type_idx < cc->cur_wasm_module->type_count); func_type = cc->cur_wasm_module->types[type_idx]; param_count = func_type->param_count; param_types = func_type->types; diff --git a/core/iwasm/interpreter/wasm_loader.c b/core/iwasm/interpreter/wasm_loader.c index f4911d6e..b5185b92 100644 --- a/core/iwasm/interpreter/wasm_loader.c +++ b/core/iwasm/interpreter/wasm_loader.c @@ -7086,7 +7086,8 @@ wasm_loader_find_block_addr(WASMExecEnv *exec_env, BlockAddr *block_addr_cache, } else { p--; - skip_leb_uint32(p, p_end); + /* block type */ + skip_leb_int32(p, p_end); } if (block_nested_depth < sizeof(block_stack) / sizeof(BlockAddr)) { @@ -7101,7 +7102,7 @@ wasm_loader_find_block_addr(WASMExecEnv *exec_env, BlockAddr *block_addr_cache, case EXT_OP_LOOP: case EXT_OP_IF: /* block type */ - skip_leb_uint32(p, p_end); + skip_leb_int32(p, p_end); if (block_nested_depth < sizeof(block_stack) / sizeof(BlockAddr)) { block_stack[block_nested_depth].start_addr = p; @@ -7850,7 +7851,11 @@ typedef struct BranchBlock { BranchBlockPatch *patch_list; /* This is used to save params frame_offset of of if block */ int16 *param_frame_offsets; - /* This is used to recover dynamic offset for else branch */ + /* This is used to recover the dynamic offset for else branch, + * and also to remember the start offset of dynamic space which + * stores the block arguments for loop block, so we can use it + * to copy the stack operands to the loop block's arguments in + * wasm_loader_emit_br_info for opcode br. */ uint16 start_dynamic_offset; #endif @@ -8001,13 +8006,26 @@ static void free_all_label_patch_lists(BranchBlock *frame_csp, uint32 csp_num) { BranchBlock *tmp_csp = frame_csp; + uint32 i; - for (uint32 i = 0; i < csp_num; i++) { + for (i = 0; i < csp_num; i++) { free_label_patch_list(tmp_csp); tmp_csp++; } } +static void +free_all_label_param_frame_offsets(BranchBlock *frame_csp, uint32 csp_num) +{ + BranchBlock *tmp_csp = frame_csp; + uint32 i; + + for (i = 0; i < csp_num; i++) { + if (tmp_csp->param_frame_offsets) + wasm_runtime_free(tmp_csp->param_frame_offsets); + tmp_csp++; + } +} #endif /* end of WASM_ENABLE_FAST_INTERP */ #if WASM_ENABLE_GC != 0 @@ -8126,6 +8144,8 @@ wasm_loader_ctx_destroy(WASMLoaderContext *ctx) if (ctx->frame_csp_bottom) { #if WASM_ENABLE_FAST_INTERP != 0 free_all_label_patch_lists(ctx->frame_csp_bottom, ctx->csp_num); + free_all_label_param_frame_offsets(ctx->frame_csp_bottom, + ctx->csp_num); #endif #if WASM_ENABLE_GC != 0 wasm_loader_clean_all_local_use_masks(ctx); @@ -9238,8 +9258,14 @@ wasm_loader_emit_br_info(WASMLoaderContext *ctx, BranchBlock *frame_csp, emit_operand(ctx, *(int16 *)(frame_offset)); } /* Part e */ - dynamic_offset = - frame_csp->dynamic_offset + wasm_get_cell_num(types, arity); + if (frame_csp->label_type == LABEL_TYPE_LOOP) + /* Use start_dynamic_offset which was set in + copy_params_to_dynamic_space */ + dynamic_offset = frame_csp->start_dynamic_offset + + wasm_get_cell_num(types, arity); + else + dynamic_offset = + frame_csp->dynamic_offset + wasm_get_cell_num(types, arity); if (is_br) ctx->dynamic_offset = dynamic_offset; for (i = (int32)arity - 1; i >= 0; i--) { @@ -10623,8 +10649,8 @@ fail: * Part e: each param's dst offset */ static bool -copy_params_to_dynamic_space(WASMLoaderContext *loader_ctx, bool is_if_block, - char *error_buf, uint32 error_buf_size) +copy_params_to_dynamic_space(WASMLoaderContext *loader_ctx, char *error_buf, + uint32 error_buf_size) { bool ret = false; int16 *frame_offset = NULL; @@ -10638,6 +10664,7 @@ copy_params_to_dynamic_space(WASMLoaderContext *loader_ctx, bool is_if_block, uint32 param_count = block_type->u.type->param_count; int16 condition_offset = 0; bool disable_emit = false; + bool is_if_block = (block->label_type == LABEL_TYPE_IF ? true : false); int16 operand_offset = 0; uint64 size = (uint64)param_count * (sizeof(*cells) + sizeof(*src_offsets)); @@ -10690,6 +10717,14 @@ copy_params_to_dynamic_space(WASMLoaderContext *loader_ctx, bool is_if_block, if (is_if_block) emit_operand(loader_ctx, condition_offset); + /* Since the start offset to save the block's params and + * the start offset to save the block's results may be + * different, we remember the dynamic offset for loop block + * so that we can use it to copy the stack operands to the + * loop block's params in wasm_loader_emit_br_info. */ + if (block->label_type == LABEL_TYPE_LOOP) + block->start_dynamic_offset = loader_ctx->dynamic_offset; + /* Part e) */ /* Push to dynamic space. The push will emit the dst offset. */ for (i = 0; i < param_count; i++) @@ -11062,12 +11097,12 @@ re_scan: #endif /* end of WASM_ENABLE_GC != 0 */ } else { - uint32 type_index; + int32 type_index; /* Resolve the leb128 encoded type index as block type */ p--; p_org = p - 1; - read_leb_uint32(p, p_end, type_index); - if (type_index >= module->type_count) { + read_leb_int32(p, p_end, type_index); + if ((uint32)type_index >= module->type_count) { set_error_buf(error_buf, error_buf_size, "unknown type"); goto fail; @@ -11171,8 +11206,8 @@ re_scan: if (BLOCK_HAS_PARAM(block_type)) { /* Make sure params are in dynamic space */ - if (!copy_params_to_dynamic_space( - loader_ctx, false, error_buf, error_buf_size)) + if (!copy_params_to_dynamic_space(loader_ctx, error_buf, + error_buf_size)) goto fail; } @@ -11218,8 +11253,8 @@ re_scan: /* skip the if label */ skip_label(); /* Emit a copy instruction */ - if (!copy_params_to_dynamic_space( - loader_ctx, true, error_buf, error_buf_size)) + if (!copy_params_to_dynamic_space(loader_ctx, error_buf, + error_buf_size)) goto fail; /* Emit the if instruction */ diff --git a/core/iwasm/interpreter/wasm_mini_loader.c b/core/iwasm/interpreter/wasm_mini_loader.c index b9cd91fd..15e55925 100644 --- a/core/iwasm/interpreter/wasm_mini_loader.c +++ b/core/iwasm/interpreter/wasm_mini_loader.c @@ -3451,7 +3451,7 @@ wasm_loader_find_block_addr(WASMExecEnv *exec_env, BlockAddr *block_addr_cache, case EXT_OP_LOOP: case EXT_OP_IF: /* block type */ - skip_leb_uint32(p, p_end); + skip_leb_int32(p, p_end); if (block_nested_depth < sizeof(block_stack) / sizeof(BlockAddr)) { block_stack[block_nested_depth].start_addr = p; @@ -3921,7 +3921,11 @@ typedef struct BranchBlock { /* This is used to store available param num for if/else branch, so the else * opcode can know how many parameters should be copied to the stack */ uint32 available_param_num; - /* This is used to recover dynamic offset for else branch */ + /* This is used to recover the dynamic offset for else branch, + * and also to remember the start offset of dynamic space which + * stores the block arguments for loop block, so we can use it + * to copy the stack operands to the loop block's arguments in + * wasm_loader_emit_br_info for opcode br. */ uint16 start_dynamic_offset; #endif @@ -4050,13 +4054,26 @@ static void free_all_label_patch_lists(BranchBlock *frame_csp, uint32 csp_num) { BranchBlock *tmp_csp = frame_csp; + uint32 i; - for (uint32 i = 0; i < csp_num; i++) { + for (i = 0; i < csp_num; i++) { free_label_patch_list(tmp_csp); tmp_csp++; } } +static void +free_all_label_param_frame_offsets(BranchBlock *frame_csp, uint32 csp_num) +{ + BranchBlock *tmp_csp = frame_csp; + uint32 i; + + for (i = 0; i < csp_num; i++) { + if (tmp_csp->param_frame_offsets) + wasm_runtime_free(tmp_csp->param_frame_offsets); + tmp_csp++; + } +} #endif static bool @@ -4120,6 +4137,8 @@ wasm_loader_ctx_destroy(WASMLoaderContext *ctx) if (ctx->frame_csp_bottom) { #if WASM_ENABLE_FAST_INTERP != 0 free_all_label_patch_lists(ctx->frame_csp_bottom, ctx->csp_num); + free_all_label_param_frame_offsets(ctx->frame_csp_bottom, + ctx->csp_num); #endif wasm_runtime_free(ctx->frame_csp_bottom); } @@ -4798,8 +4817,14 @@ wasm_loader_emit_br_info(WASMLoaderContext *ctx, BranchBlock *frame_csp, emit_operand(ctx, *(int16 *)(frame_offset)); } /* Part e */ - dynamic_offset = - frame_csp->dynamic_offset + wasm_get_cell_num(types, arity); + if (frame_csp->label_type == LABEL_TYPE_LOOP) + /* Use start_dynamic_offset which was set in + copy_params_to_dynamic_space */ + dynamic_offset = frame_csp->start_dynamic_offset + + wasm_get_cell_num(types, arity); + else + dynamic_offset = + frame_csp->dynamic_offset + wasm_get_cell_num(types, arity); if (is_br) ctx->dynamic_offset = dynamic_offset; for (i = (int32)arity - 1; i >= 0; i--) { @@ -5778,8 +5803,8 @@ fail: * Part e: each param's dst offset */ static bool -copy_params_to_dynamic_space(WASMLoaderContext *loader_ctx, bool is_if_block, - char *error_buf, uint32 error_buf_size) +copy_params_to_dynamic_space(WASMLoaderContext *loader_ctx, char *error_buf, + uint32 error_buf_size) { bool ret = false; int16 *frame_offset = NULL; @@ -5793,6 +5818,7 @@ copy_params_to_dynamic_space(WASMLoaderContext *loader_ctx, bool is_if_block, uint32 param_count = block_type->u.type->param_count; int16 condition_offset = 0; bool disable_emit = false; + bool is_if_block = (block->label_type == LABEL_TYPE_IF ? true : false); int16 operand_offset = 0; uint64 size = (uint64)param_count * (sizeof(*cells) + sizeof(*src_offsets)); @@ -5845,6 +5871,14 @@ copy_params_to_dynamic_space(WASMLoaderContext *loader_ctx, bool is_if_block, if (is_if_block) emit_operand(loader_ctx, condition_offset); + /* Since the start offset to save the block's params and + * the start offset to save the block's results may be + * different, we remember the dynamic offset for loop block + * so that we can use it to copy the stack operands to the + * loop block's params in wasm_loader_emit_br_info. */ + if (block->label_type == LABEL_TYPE_LOOP) + block->start_dynamic_offset = loader_ctx->dynamic_offset; + /* Part e) */ /* Push to dynamic space. The push will emit the dst offset. */ for (i = 0; i < param_count; i++) @@ -6043,11 +6077,11 @@ re_scan: block_type.u.value_type.type = value_type; } else { - uint32 type_index; + int32 type_index; /* Resolve the leb128 encoded type index as block type */ p--; - read_leb_uint32(p, p_end, type_index); - bh_assert(type_index < module->type_count); + read_leb_int32(p, p_end, type_index); + bh_assert((uint32)type_index < module->type_count); block_type.is_value_type = false; block_type.u.type = module->types[type_index]; #if WASM_ENABLE_FAST_INTERP == 0 @@ -6134,8 +6168,8 @@ re_scan: skip_label(); if (BLOCK_HAS_PARAM(block_type)) { /* Make sure params are in dynamic space */ - if (!copy_params_to_dynamic_space( - loader_ctx, false, error_buf, error_buf_size)) + if (!copy_params_to_dynamic_space(loader_ctx, error_buf, + error_buf_size)) goto fail; } if (opcode == WASM_OP_LOOP) { @@ -6175,8 +6209,8 @@ re_scan: /* skip the if label */ skip_label(); /* Emit a copy instruction */ - if (!copy_params_to_dynamic_space( - loader_ctx, true, error_buf, error_buf_size)) + if (!copy_params_to_dynamic_space(loader_ctx, error_buf, + error_buf_size)) goto fail; /* Emit the if instruction */ diff --git a/tests/regression/ba-issues/issues/issue-3467/tt_unreachable.wasm b/tests/regression/ba-issues/issues/issue-3467/tt_unreachable.wasm new file mode 100644 index 0000000000000000000000000000000000000000..9f56fb5e546cc8a7cb41ff9c032e510705ac0c4e GIT binary patch literal 237 zcmYL?F-pWx6h-gNdr8n|VVx@Qf8`#8`DWaLofr$5LUaa`M(`(C46_Lvi^0ai(n1Sc zE13<5JD3fK22||s;T*U)Zq5jRJ6X*>i?gd3r*+bG>}vcWd&a@aU~4dniZIQJwBsJE zXMp{$0o8J2-cFC&lcq(ok&}?&WV4qGIQ6S^PBPuY=39`dBV*&3;Ao>aX8T0Lu`# G4f_V?oj1Y& literal 0 HcmV?d00001 diff --git a/tests/regression/ba-issues/issues/issue-3468/i64.add.wasm b/tests/regression/ba-issues/issues/issue-3468/i64.add.wasm new file mode 100644 index 0000000000000000000000000000000000000000..ea40df17140ab7f012644f48d47bb76472d4ab02 GIT binary patch literal 14593 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 G?*9P~{yIhg literal 0 HcmV?d00001 diff --git a/tests/regression/ba-issues/running_config.json b/tests/regression/ba-issues/running_config.json index 7ec213e4..b7e35cad 100644 --- a/tests/regression/ba-issues/running_config.json +++ b/tests/regression/ba-issues/running_config.json @@ -1674,6 +1674,38 @@ "stdout content": "Hello from Kotlin via WASI\nCurrent 'realtime' timestamp is:", "description": "no 'type mismatch: expect (ref null ht) but got other1 unknown type'" } + }, + { + "deprecated": false, + "ids": [ + 3467 + ], + "runtime": "iwasm-default-wasi-disabled", + "file": "tt_unreachable.wasm", + "mode": "fast-interp", + "options": "--heap-size=0 -f to_test", + "argument": "", + "expected return": { + "ret code": 1, + "stdout content": "Exception: unreachable", + "description": "no '-1.861157e+19:f32'" + } + }, + { + "deprecated": false, + "ids": [ + 3468 + ], + "runtime": "iwasm-default-wasi-disabled", + "file": "i64.add.wasm", + "mode": "fast-interp", + "options": "--heap-size=0 -f to_test", + "argument": "", + "expected return": { + "ret code": 255, + "stdout content": "WASM module load failed: unknown type", + "description": "no '0x0:i64'" + } } ] }