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

Cumulative fixes for release/1.3.x (#3155)

Browse Source 
Apply patches in branch main for branch `release/1.3.x`:
- Fix loader check_wasi_abi_compatibility (#3126)
- Zero the memory mapped from os_mmap in NuttX (#3132)
- Fix possible integer overflow in loader target block check (#3133)
- Fix locel.set in polymorphic stack (#3135)
- Fix threads opcodes' boundary check in classic-interp and fast-interp (#3136)
- aot_compile_op_call: Stop setting calling convention explicitly (#3140)
- aot compiler: Place precheck wrapper before the corresponding wrapped function (#3141)
- fast-interp: Fix copy_stack_top_i64 overlap issue (#3146)
- fast-interp: Fix frame_offset overflow issue (#3149)
- Fix null pointer access in fast-interp when configurable soft bound check is enabled (#3150)
This commit is contained in:
Wenyong Huang 2024-02-17 13:48:55 +08:00 committed by GitHub
parent 2eb60060d8
commit add9547324
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
8 changed files with 145 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -96,6 +96,10 @@ static inline bool
is_bounds_checks_enabled(WASMModuleInstanceCommon *module_inst) is_bounds_checks_enabled(WASMModuleInstanceCommon *module_inst)
{ {
#if WASM_CONFIGURABLE_BOUNDS_CHECKS != 0 #if WASM_CONFIGURABLE_BOUNDS_CHECKS != 0
if (!module_inst) {
return true;
}
return wasm_runtime_is_bounds_checks_enabled(module_inst); return wasm_runtime_is_bounds_checks_enabled(module_inst);
#else #else
return true; return true;

4
core/iwasm/compilation/aot_emit_function.c
View File

@ -1088,10 +1088,6 @@ aot_compile_op_call(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
goto fail; goto fail;
} }
/* Set calling convention for the call with the func's calling
convention */
LLVMSetInstructionCallConv(value_ret, LLVMGetFunctionCallConv(func));
if (tail_call) if (tail_call)
LLVMSetTailCall(value_ret, true); LLVMSetTailCall(value_ret, true);

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

@ -263,12 +263,11 @@ get_inst_extra_offset(AOTCompContext *comp_ctx)
* - update native_stack_top_min if necessary * - update native_stack_top_min if necessary
* - stack overflow check (if it does, trap) * - stack overflow check (if it does, trap)
*/ */
static LLVMValueRef static bool
aot_add_precheck_function(AOTCompContext *comp_ctx, LLVMModuleRef module, aot_build_precheck_function(AOTCompContext *comp_ctx, LLVMModuleRef module,
uint32 func_index, uint32 orig_param_count, LLVMValueRef precheck_func, uint32 func_index,
LLVMTypeRef func_type, LLVMValueRef wrapped_func) LLVMTypeRef func_type, LLVMValueRef wrapped_func)
{ {
LLVMValueRef precheck_func;
LLVMBasicBlockRef begin = NULL; LLVMBasicBlockRef begin = NULL;
LLVMBasicBlockRef check_top_block = NULL; LLVMBasicBlockRef check_top_block = NULL;
LLVMBasicBlockRef update_top_block = NULL; LLVMBasicBlockRef update_top_block = NULL;
@ -276,12 +275,6 @@ aot_add_precheck_function(AOTCompContext *comp_ctx, LLVMModuleRef module,
LLVMBasicBlockRef call_wrapped_func_block = NULL; LLVMBasicBlockRef call_wrapped_func_block = NULL;
LLVMValueRef *params = NULL; LLVMValueRef *params = NULL;
precheck_func =
aot_add_llvm_func1(comp_ctx, module, func_index, orig_param_count,
func_type, AOT_FUNC_PREFIX);
if (!precheck_func) {
goto fail;
}
begin = LLVMAppendBasicBlockInContext(comp_ctx->context, precheck_func, begin = LLVMAppendBasicBlockInContext(comp_ctx->context, precheck_func,
"begin"); "begin");
check_top_block = LLVMAppendBasicBlockInContext( check_top_block = LLVMAppendBasicBlockInContext(
@ -550,13 +543,13 @@ aot_add_precheck_function(AOTCompContext *comp_ctx, LLVMModuleRef module,
} }
} }
return precheck_func; return true;
fail: fail:
if (params != NULL) { if (params != NULL) {
wasm_runtime_free(params); wasm_runtime_free(params);
} }
aot_set_last_error("failed to build precheck wrapper function."); aot_set_last_error("failed to build precheck wrapper function.");
return NULL; return false;
} }
/** /**
@ -626,7 +619,14 @@ aot_add_llvm_func(AOTCompContext *comp_ctx, LLVMModuleRef module,
const char *prefix = AOT_FUNC_PREFIX; const char *prefix = AOT_FUNC_PREFIX;
const bool need_precheck = const bool need_precheck =
comp_ctx->enable_stack_bound_check || comp_ctx->enable_stack_estimation; comp_ctx->enable_stack_bound_check || comp_ctx->enable_stack_estimation;
LLVMValueRef precheck_func;
if (need_precheck) { if (need_precheck) {
precheck_func = aot_add_llvm_func1(comp_ctx, module, func_index,
aot_func_type->param_count,
func_type, AOT_FUNC_PREFIX);
if (!precheck_func) {
goto fail;
}
/* /*
* REVISIT: probably this breaks windows hw bound check * REVISIT: probably this breaks windows hw bound check
* (the RtlAddFunctionTable stuff) * (the RtlAddFunctionTable stuff)
@ -671,10 +671,8 @@ aot_add_llvm_func(AOTCompContext *comp_ctx, LLVMModuleRef module,
LLVMAddAttributeAtIndex(func, LLVMAttributeFunctionIndex, LLVMAddAttributeAtIndex(func, LLVMAttributeFunctionIndex,
attr_noinline); attr_noinline);
LLVMValueRef precheck_func = aot_add_precheck_function( if (!aot_build_precheck_function(comp_ctx, module, precheck_func,
comp_ctx, module, func_index, aot_func_type->param_count, func_type, func_index, func_type, func))
func);
if (!precheck_func)
goto fail; goto fail;
LLVMAddAttributeAtIndex(precheck_func, LLVMAttributeFunctionIndex, LLVMAddAttributeAtIndex(precheck_func, LLVMAttributeFunctionIndex,
attr_noinline); attr_noinline);

62
core/iwasm/interpreter/wasm_interp_classic.c
View File

@ -728,7 +728,7 @@ trunc_f64_to_int(WASMModuleInstance *module, uint32 *frame_sp, float64 src_min,
addr = POP_I32(); \ addr = POP_I32(); \
\ \
if (opcode == WASM_OP_ATOMIC_RMW_I32_##OP_NAME##8_U) { \ if (opcode == WASM_OP_ATOMIC_RMW_I32_##OP_NAME##8_U) { \
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); \ CHECK_MEMORY_OVERFLOW(1); \
CHECK_ATOMIC_MEMORY_ACCESS(); \ CHECK_ATOMIC_MEMORY_ACCESS(); \
\ \
shared_memory_lock(memory); \ shared_memory_lock(memory); \
@ -737,7 +737,7 @@ trunc_f64_to_int(WASMModuleInstance *module, uint32 *frame_sp, float64 src_min,
shared_memory_unlock(memory); \ shared_memory_unlock(memory); \
} \ } \
else if (opcode == WASM_OP_ATOMIC_RMW_I32_##OP_NAME##16_U) { \ else if (opcode == WASM_OP_ATOMIC_RMW_I32_##OP_NAME##16_U) { \
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); \ CHECK_MEMORY_OVERFLOW(2); \
CHECK_ATOMIC_MEMORY_ACCESS(); \ CHECK_ATOMIC_MEMORY_ACCESS(); \
\ \
shared_memory_lock(memory); \ shared_memory_lock(memory); \
@ -746,7 +746,7 @@ trunc_f64_to_int(WASMModuleInstance *module, uint32 *frame_sp, float64 src_min,
shared_memory_unlock(memory); \ shared_memory_unlock(memory); \
} \ } \
else { \ else { \
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); \ CHECK_MEMORY_OVERFLOW(4); \
CHECK_ATOMIC_MEMORY_ACCESS(); \ CHECK_ATOMIC_MEMORY_ACCESS(); \
\ \
shared_memory_lock(memory); \ shared_memory_lock(memory); \
@ -768,7 +768,7 @@ trunc_f64_to_int(WASMModuleInstance *module, uint32 *frame_sp, float64 src_min,
addr = POP_I32(); \ addr = POP_I32(); \
\ \
if (opcode == WASM_OP_ATOMIC_RMW_I64_##OP_NAME##8_U) { \ if (opcode == WASM_OP_ATOMIC_RMW_I64_##OP_NAME##8_U) { \
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); \ CHECK_MEMORY_OVERFLOW(1); \
CHECK_ATOMIC_MEMORY_ACCESS(); \ CHECK_ATOMIC_MEMORY_ACCESS(); \
\ \
shared_memory_lock(memory); \ shared_memory_lock(memory); \
@ -777,7 +777,7 @@ trunc_f64_to_int(WASMModuleInstance *module, uint32 *frame_sp, float64 src_min,
shared_memory_unlock(memory); \ shared_memory_unlock(memory); \
} \ } \
else if (opcode == WASM_OP_ATOMIC_RMW_I64_##OP_NAME##16_U) { \ else if (opcode == WASM_OP_ATOMIC_RMW_I64_##OP_NAME##16_U) { \
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); \ CHECK_MEMORY_OVERFLOW(2); \
CHECK_ATOMIC_MEMORY_ACCESS(); \ CHECK_ATOMIC_MEMORY_ACCESS(); \
\ \
shared_memory_lock(memory); \ shared_memory_lock(memory); \
@ -786,7 +786,7 @@ trunc_f64_to_int(WASMModuleInstance *module, uint32 *frame_sp, float64 src_min,
shared_memory_unlock(memory); \ shared_memory_unlock(memory); \
} \ } \
else if (opcode == WASM_OP_ATOMIC_RMW_I64_##OP_NAME##32_U) { \ else if (opcode == WASM_OP_ATOMIC_RMW_I64_##OP_NAME##32_U) { \
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); \ CHECK_MEMORY_OVERFLOW(4); \
CHECK_ATOMIC_MEMORY_ACCESS(); \ CHECK_ATOMIC_MEMORY_ACCESS(); \
\ \
shared_memory_lock(memory); \ shared_memory_lock(memory); \
@ -796,7 +796,7 @@ trunc_f64_to_int(WASMModuleInstance *module, uint32 *frame_sp, float64 src_min,
} \ } \
else { \ else { \
uint64 op_result; \ uint64 op_result; \
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 8, maddr); \ CHECK_MEMORY_OVERFLOW(8); \
CHECK_ATOMIC_MEMORY_ACCESS(); \ CHECK_ATOMIC_MEMORY_ACCESS(); \
\ \
shared_memory_lock(memory); \ shared_memory_lock(memory); \
@ -3864,7 +3864,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
notify_count = POP_I32(); notify_count = POP_I32();
addr = POP_I32(); addr = POP_I32();
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); CHECK_MEMORY_OVERFLOW(4);
CHECK_ATOMIC_MEMORY_ACCESS(); CHECK_ATOMIC_MEMORY_ACCESS();
ret = wasm_runtime_atomic_notify( ret = wasm_runtime_atomic_notify(
@ -3884,7 +3884,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
timeout = POP_I64(); timeout = POP_I64();
expect = POP_I32(); expect = POP_I32();
addr = POP_I32(); addr = POP_I32();
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); CHECK_MEMORY_OVERFLOW(4);
CHECK_ATOMIC_MEMORY_ACCESS(); CHECK_ATOMIC_MEMORY_ACCESS();
ret = wasm_runtime_atomic_wait( ret = wasm_runtime_atomic_wait(
@ -3908,7 +3908,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
timeout = POP_I64(); timeout = POP_I64();
expect = POP_I64(); expect = POP_I64();
addr = POP_I32(); addr = POP_I32();
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 8, maddr); CHECK_MEMORY_OVERFLOW(8);
CHECK_ATOMIC_MEMORY_ACCESS(); CHECK_ATOMIC_MEMORY_ACCESS();
ret = wasm_runtime_atomic_wait( ret = wasm_runtime_atomic_wait(
@ -3941,21 +3941,21 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
addr = POP_I32(); addr = POP_I32();
if (opcode == WASM_OP_ATOMIC_I32_LOAD8_U) { if (opcode == WASM_OP_ATOMIC_I32_LOAD8_U) {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); CHECK_MEMORY_OVERFLOW(1);
CHECK_ATOMIC_MEMORY_ACCESS(); CHECK_ATOMIC_MEMORY_ACCESS();
shared_memory_lock(memory); shared_memory_lock(memory);
readv = (uint32)(*(uint8 *)maddr); readv = (uint32)(*(uint8 *)maddr);
shared_memory_unlock(memory); shared_memory_unlock(memory);
} }
else if (opcode == WASM_OP_ATOMIC_I32_LOAD16_U) { else if (opcode == WASM_OP_ATOMIC_I32_LOAD16_U) {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); CHECK_MEMORY_OVERFLOW(2);
CHECK_ATOMIC_MEMORY_ACCESS(); CHECK_ATOMIC_MEMORY_ACCESS();
shared_memory_lock(memory); shared_memory_lock(memory);
readv = (uint32)LOAD_U16(maddr); readv = (uint32)LOAD_U16(maddr);
shared_memory_unlock(memory); shared_memory_unlock(memory);
} }
else { else {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); CHECK_MEMORY_OVERFLOW(4);
CHECK_ATOMIC_MEMORY_ACCESS(); CHECK_ATOMIC_MEMORY_ACCESS();
shared_memory_lock(memory); shared_memory_lock(memory);
readv = LOAD_I32(maddr); readv = LOAD_I32(maddr);
@ -3976,28 +3976,28 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
addr = POP_I32(); addr = POP_I32();
if (opcode == WASM_OP_ATOMIC_I64_LOAD8_U) { if (opcode == WASM_OP_ATOMIC_I64_LOAD8_U) {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); CHECK_MEMORY_OVERFLOW(1);
CHECK_ATOMIC_MEMORY_ACCESS(); CHECK_ATOMIC_MEMORY_ACCESS();
shared_memory_lock(memory); shared_memory_lock(memory);
readv = (uint64)(*(uint8 *)maddr); readv = (uint64)(*(uint8 *)maddr);
shared_memory_unlock(memory); shared_memory_unlock(memory);
} }
else if (opcode == WASM_OP_ATOMIC_I64_LOAD16_U) { else if (opcode == WASM_OP_ATOMIC_I64_LOAD16_U) {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); CHECK_MEMORY_OVERFLOW(2);
CHECK_ATOMIC_MEMORY_ACCESS(); CHECK_ATOMIC_MEMORY_ACCESS();
shared_memory_lock(memory); shared_memory_lock(memory);
readv = (uint64)LOAD_U16(maddr); readv = (uint64)LOAD_U16(maddr);
shared_memory_unlock(memory); shared_memory_unlock(memory);
} }
else if (opcode == WASM_OP_ATOMIC_I64_LOAD32_U) { else if (opcode == WASM_OP_ATOMIC_I64_LOAD32_U) {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); CHECK_MEMORY_OVERFLOW(4);
CHECK_ATOMIC_MEMORY_ACCESS(); CHECK_ATOMIC_MEMORY_ACCESS();
shared_memory_lock(memory); shared_memory_lock(memory);
readv = (uint64)LOAD_U32(maddr); readv = (uint64)LOAD_U32(maddr);
shared_memory_unlock(memory); shared_memory_unlock(memory);
} }
else { else {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 8, maddr); CHECK_MEMORY_OVERFLOW(8);
CHECK_ATOMIC_MEMORY_ACCESS(); CHECK_ATOMIC_MEMORY_ACCESS();
shared_memory_lock(memory); shared_memory_lock(memory);
readv = LOAD_I64(maddr); readv = LOAD_I64(maddr);
@ -4018,21 +4018,21 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
addr = POP_I32(); addr = POP_I32();
if (opcode == WASM_OP_ATOMIC_I32_STORE8) { if (opcode == WASM_OP_ATOMIC_I32_STORE8) {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); CHECK_MEMORY_OVERFLOW(1);
CHECK_ATOMIC_MEMORY_ACCESS(); CHECK_ATOMIC_MEMORY_ACCESS();
shared_memory_lock(memory); shared_memory_lock(memory);
*(uint8 *)maddr = (uint8)sval; *(uint8 *)maddr = (uint8)sval;
shared_memory_unlock(memory); shared_memory_unlock(memory);
} }
else if (opcode == WASM_OP_ATOMIC_I32_STORE16) { else if (opcode == WASM_OP_ATOMIC_I32_STORE16) {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); CHECK_MEMORY_OVERFLOW(2);
CHECK_ATOMIC_MEMORY_ACCESS(); CHECK_ATOMIC_MEMORY_ACCESS();
shared_memory_lock(memory); shared_memory_lock(memory);
STORE_U16(maddr, (uint16)sval); STORE_U16(maddr, (uint16)sval);
shared_memory_unlock(memory); shared_memory_unlock(memory);
} }
else { else {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); CHECK_MEMORY_OVERFLOW(4);
CHECK_ATOMIC_MEMORY_ACCESS(); CHECK_ATOMIC_MEMORY_ACCESS();
shared_memory_lock(memory); shared_memory_lock(memory);
STORE_U32(maddr, sval); STORE_U32(maddr, sval);
@ -4052,28 +4052,28 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
addr = POP_I32(); addr = POP_I32();
if (opcode == WASM_OP_ATOMIC_I64_STORE8) { if (opcode == WASM_OP_ATOMIC_I64_STORE8) {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); CHECK_MEMORY_OVERFLOW(1);
CHECK_ATOMIC_MEMORY_ACCESS(); CHECK_ATOMIC_MEMORY_ACCESS();
shared_memory_lock(memory); shared_memory_lock(memory);
*(uint8 *)maddr = (uint8)sval; *(uint8 *)maddr = (uint8)sval;
shared_memory_unlock(memory); shared_memory_unlock(memory);
} }
else if (opcode == WASM_OP_ATOMIC_I64_STORE16) { else if (opcode == WASM_OP_ATOMIC_I64_STORE16) {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); CHECK_MEMORY_OVERFLOW(2);
CHECK_ATOMIC_MEMORY_ACCESS(); CHECK_ATOMIC_MEMORY_ACCESS();
shared_memory_lock(memory); shared_memory_lock(memory);
STORE_U16(maddr, (uint16)sval); STORE_U16(maddr, (uint16)sval);
shared_memory_unlock(memory); shared_memory_unlock(memory);
} }
else if (opcode == WASM_OP_ATOMIC_I64_STORE32) { else if (opcode == WASM_OP_ATOMIC_I64_STORE32) {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); CHECK_MEMORY_OVERFLOW(4);
CHECK_ATOMIC_MEMORY_ACCESS(); CHECK_ATOMIC_MEMORY_ACCESS();
shared_memory_lock(memory); shared_memory_lock(memory);
STORE_U32(maddr, (uint32)sval); STORE_U32(maddr, (uint32)sval);
shared_memory_unlock(memory); shared_memory_unlock(memory);
} }
else { else {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 8, maddr); CHECK_MEMORY_OVERFLOW(8);
CHECK_ATOMIC_MEMORY_ACCESS(); CHECK_ATOMIC_MEMORY_ACCESS();
shared_memory_lock(memory); shared_memory_lock(memory);
PUT_I64_TO_ADDR((uint32 *)maddr, sval); PUT_I64_TO_ADDR((uint32 *)maddr, sval);
@ -4093,7 +4093,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
addr = POP_I32(); addr = POP_I32();
if (opcode == WASM_OP_ATOMIC_RMW_I32_CMPXCHG8_U) { if (opcode == WASM_OP_ATOMIC_RMW_I32_CMPXCHG8_U) {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); CHECK_MEMORY_OVERFLOW(1);
CHECK_ATOMIC_MEMORY_ACCESS(); CHECK_ATOMIC_MEMORY_ACCESS();
expect = (uint8)expect; expect = (uint8)expect;
@ -4104,7 +4104,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
shared_memory_unlock(memory); shared_memory_unlock(memory);
} }
else if (opcode == WASM_OP_ATOMIC_RMW_I32_CMPXCHG16_U) { else if (opcode == WASM_OP_ATOMIC_RMW_I32_CMPXCHG16_U) {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); CHECK_MEMORY_OVERFLOW(2);
CHECK_ATOMIC_MEMORY_ACCESS(); CHECK_ATOMIC_MEMORY_ACCESS();
expect = (uint16)expect; expect = (uint16)expect;
@ -4115,7 +4115,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
shared_memory_unlock(memory); shared_memory_unlock(memory);
} }
else { else {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); CHECK_MEMORY_OVERFLOW(4);
CHECK_ATOMIC_MEMORY_ACCESS(); CHECK_ATOMIC_MEMORY_ACCESS();
shared_memory_lock(memory); shared_memory_lock(memory);
@ -4139,7 +4139,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
addr = POP_I32(); addr = POP_I32();
if (opcode == WASM_OP_ATOMIC_RMW_I64_CMPXCHG8_U) { if (opcode == WASM_OP_ATOMIC_RMW_I64_CMPXCHG8_U) {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); CHECK_MEMORY_OVERFLOW(1);
CHECK_ATOMIC_MEMORY_ACCESS(); CHECK_ATOMIC_MEMORY_ACCESS();
expect = (uint8)expect; expect = (uint8)expect;
@ -4150,7 +4150,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
shared_memory_unlock(memory); shared_memory_unlock(memory);
} }
else if (opcode == WASM_OP_ATOMIC_RMW_I64_CMPXCHG16_U) { else if (opcode == WASM_OP_ATOMIC_RMW_I64_CMPXCHG16_U) {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); CHECK_MEMORY_OVERFLOW(2);
CHECK_ATOMIC_MEMORY_ACCESS(); CHECK_ATOMIC_MEMORY_ACCESS();
expect = (uint16)expect; expect = (uint16)expect;
@ -4161,7 +4161,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
shared_memory_unlock(memory); shared_memory_unlock(memory);
} }
else if (opcode == WASM_OP_ATOMIC_RMW_I64_CMPXCHG32_U) { else if (opcode == WASM_OP_ATOMIC_RMW_I64_CMPXCHG32_U) {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); CHECK_MEMORY_OVERFLOW(4);
CHECK_ATOMIC_MEMORY_ACCESS(); CHECK_ATOMIC_MEMORY_ACCESS();
expect = (uint32)expect; expect = (uint32)expect;
@ -4172,7 +4172,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
shared_memory_unlock(memory); shared_memory_unlock(memory);
} }
else { else {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 8, maddr); CHECK_MEMORY_OVERFLOW(8);
CHECK_ATOMIC_MEMORY_ACCESS(); CHECK_ATOMIC_MEMORY_ACCESS();
shared_memory_lock(memory); shared_memory_lock(memory);

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

@ -479,7 +479,7 @@ LOAD_PTR(void *addr)
addr = POP_I32(); \ addr = POP_I32(); \
\ \
if (opcode == WASM_OP_ATOMIC_RMW_I32_##OP_NAME##8_U) { \ if (opcode == WASM_OP_ATOMIC_RMW_I32_##OP_NAME##8_U) { \
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); \ CHECK_MEMORY_OVERFLOW(1); \
CHECK_ATOMIC_MEMORY_ACCESS(1); \ CHECK_ATOMIC_MEMORY_ACCESS(1); \
\ \
shared_memory_lock(memory); \ shared_memory_lock(memory); \
@ -488,7 +488,7 @@ LOAD_PTR(void *addr)
shared_memory_unlock(memory); \ shared_memory_unlock(memory); \
} \ } \
else if (opcode == WASM_OP_ATOMIC_RMW_I32_##OP_NAME##16_U) { \ else if (opcode == WASM_OP_ATOMIC_RMW_I32_##OP_NAME##16_U) { \
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); \ CHECK_MEMORY_OVERFLOW(2); \
CHECK_ATOMIC_MEMORY_ACCESS(2); \ CHECK_ATOMIC_MEMORY_ACCESS(2); \
\ \
shared_memory_lock(memory); \ shared_memory_lock(memory); \
@ -497,7 +497,7 @@ LOAD_PTR(void *addr)
shared_memory_unlock(memory); \ shared_memory_unlock(memory); \
} \ } \
else { \ else { \
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); \ CHECK_MEMORY_OVERFLOW(4); \
CHECK_ATOMIC_MEMORY_ACCESS(4); \ CHECK_ATOMIC_MEMORY_ACCESS(4); \
\ \
shared_memory_lock(memory); \ shared_memory_lock(memory); \
@ -519,7 +519,7 @@ LOAD_PTR(void *addr)
addr = POP_I32(); \ addr = POP_I32(); \
\ \
if (opcode == WASM_OP_ATOMIC_RMW_I64_##OP_NAME##8_U) { \ if (opcode == WASM_OP_ATOMIC_RMW_I64_##OP_NAME##8_U) { \
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); \ CHECK_MEMORY_OVERFLOW(1); \
CHECK_ATOMIC_MEMORY_ACCESS(1); \ CHECK_ATOMIC_MEMORY_ACCESS(1); \
\ \
shared_memory_lock(memory); \ shared_memory_lock(memory); \
@ -528,7 +528,7 @@ LOAD_PTR(void *addr)
shared_memory_unlock(memory); \ shared_memory_unlock(memory); \
} \ } \
else if (opcode == WASM_OP_ATOMIC_RMW_I64_##OP_NAME##16_U) { \ else if (opcode == WASM_OP_ATOMIC_RMW_I64_##OP_NAME##16_U) { \
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); \ CHECK_MEMORY_OVERFLOW(2); \
CHECK_ATOMIC_MEMORY_ACCESS(2); \ CHECK_ATOMIC_MEMORY_ACCESS(2); \
\ \
shared_memory_lock(memory); \ shared_memory_lock(memory); \
@ -537,7 +537,7 @@ LOAD_PTR(void *addr)
shared_memory_unlock(memory); \ shared_memory_unlock(memory); \
} \ } \
else if (opcode == WASM_OP_ATOMIC_RMW_I64_##OP_NAME##32_U) { \ else if (opcode == WASM_OP_ATOMIC_RMW_I64_##OP_NAME##32_U) { \
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); \ CHECK_MEMORY_OVERFLOW(4); \
CHECK_ATOMIC_MEMORY_ACCESS(4); \ CHECK_ATOMIC_MEMORY_ACCESS(4); \
\ \
shared_memory_lock(memory); \ shared_memory_lock(memory); \
@ -547,7 +547,7 @@ LOAD_PTR(void *addr)
} \ } \
else { \ else { \
uint64 op_result; \ uint64 op_result; \
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 8, maddr); \ CHECK_MEMORY_OVERFLOW(8); \
CHECK_ATOMIC_MEMORY_ACCESS(8); \ CHECK_ATOMIC_MEMORY_ACCESS(8); \
\ \
shared_memory_lock(memory); \ shared_memory_lock(memory); \
@ -2881,8 +2881,8 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
{ {
addr1 = GET_OFFSET(); addr1 = GET_OFFSET();
addr2 = GET_OFFSET(); addr2 = GET_OFFSET();
frame_lp[addr2] = frame_lp[addr1]; PUT_I64_TO_ADDR(frame_lp + addr2,
frame_lp[addr2 + 1] = frame_lp[addr1 + 1]; GET_I64_FROM_ADDR(frame_lp + addr1));
HANDLE_OP_END(); HANDLE_OP_END();
} }
@ -3017,7 +3017,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
offset = (uint64)(uint32)POP_I32(); offset = (uint64)(uint32)POP_I32();
addr = POP_I32(); addr = POP_I32();
#if WASM_ENABLE_THREAD_MGR #if WASM_ENABLE_THREAD_MGR != 0
linear_mem_size = get_linear_mem_size(); linear_mem_size = get_linear_mem_size();
#endif #endif
@ -3065,7 +3065,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
src = POP_I32(); src = POP_I32();
dst = POP_I32(); dst = POP_I32();
#if WASM_ENABLE_THREAD_MGR #if WASM_ENABLE_THREAD_MGR != 0
linear_mem_size = get_linear_mem_size(); linear_mem_size = get_linear_mem_size();
#endif #endif
@ -3095,7 +3095,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
fill_val = POP_I32(); fill_val = POP_I32();
dst = POP_I32(); dst = POP_I32();
#if WASM_ENABLE_THREAD_MGR #if WASM_ENABLE_THREAD_MGR != 0
linear_mem_size = get_linear_mem_size(); linear_mem_size = get_linear_mem_size();
#endif #endif
@ -3303,7 +3303,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
notify_count = POP_I32(); notify_count = POP_I32();
addr = POP_I32(); addr = POP_I32();
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); CHECK_MEMORY_OVERFLOW(4);
CHECK_ATOMIC_MEMORY_ACCESS(4); CHECK_ATOMIC_MEMORY_ACCESS(4);
ret = wasm_runtime_atomic_notify( ret = wasm_runtime_atomic_notify(
@ -3323,7 +3323,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
timeout = POP_I64(); timeout = POP_I64();
expect = POP_I32(); expect = POP_I32();
addr = POP_I32(); addr = POP_I32();
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); CHECK_MEMORY_OVERFLOW(4);
CHECK_ATOMIC_MEMORY_ACCESS(4); CHECK_ATOMIC_MEMORY_ACCESS(4);
ret = wasm_runtime_atomic_wait( ret = wasm_runtime_atomic_wait(
@ -3347,7 +3347,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
timeout = POP_I64(); timeout = POP_I64();
expect = POP_I64(); expect = POP_I64();
addr = POP_I32(); addr = POP_I32();
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 8, maddr); CHECK_MEMORY_OVERFLOW(8);
CHECK_ATOMIC_MEMORY_ACCESS(8); CHECK_ATOMIC_MEMORY_ACCESS(8);
ret = wasm_runtime_atomic_wait( ret = wasm_runtime_atomic_wait(
@ -3378,21 +3378,21 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
addr = POP_I32(); addr = POP_I32();
if (opcode == WASM_OP_ATOMIC_I32_LOAD8_U) { if (opcode == WASM_OP_ATOMIC_I32_LOAD8_U) {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); CHECK_MEMORY_OVERFLOW(1);
CHECK_ATOMIC_MEMORY_ACCESS(1); CHECK_ATOMIC_MEMORY_ACCESS(1);
shared_memory_lock(memory); shared_memory_lock(memory);
readv = (uint32)(*(uint8 *)maddr); readv = (uint32)(*(uint8 *)maddr);
shared_memory_unlock(memory); shared_memory_unlock(memory);
} }
else if (opcode == WASM_OP_ATOMIC_I32_LOAD16_U) { else if (opcode == WASM_OP_ATOMIC_I32_LOAD16_U) {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); CHECK_MEMORY_OVERFLOW(2);
CHECK_ATOMIC_MEMORY_ACCESS(2); CHECK_ATOMIC_MEMORY_ACCESS(2);
shared_memory_lock(memory); shared_memory_lock(memory);
readv = (uint32)LOAD_U16(maddr); readv = (uint32)LOAD_U16(maddr);
shared_memory_unlock(memory); shared_memory_unlock(memory);
} }
else { else {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); CHECK_MEMORY_OVERFLOW(4);
CHECK_ATOMIC_MEMORY_ACCESS(4); CHECK_ATOMIC_MEMORY_ACCESS(4);
shared_memory_lock(memory); shared_memory_lock(memory);
readv = LOAD_I32(maddr); readv = LOAD_I32(maddr);
@ -3413,28 +3413,28 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
addr = POP_I32(); addr = POP_I32();
if (opcode == WASM_OP_ATOMIC_I64_LOAD8_U) { if (opcode == WASM_OP_ATOMIC_I64_LOAD8_U) {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); CHECK_MEMORY_OVERFLOW(1);
CHECK_ATOMIC_MEMORY_ACCESS(1); CHECK_ATOMIC_MEMORY_ACCESS(1);
shared_memory_lock(memory); shared_memory_lock(memory);
readv = (uint64)(*(uint8 *)maddr); readv = (uint64)(*(uint8 *)maddr);
shared_memory_unlock(memory); shared_memory_unlock(memory);
} }
else if (opcode == WASM_OP_ATOMIC_I64_LOAD16_U) { else if (opcode == WASM_OP_ATOMIC_I64_LOAD16_U) {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); CHECK_MEMORY_OVERFLOW(2);
CHECK_ATOMIC_MEMORY_ACCESS(2); CHECK_ATOMIC_MEMORY_ACCESS(2);
shared_memory_lock(memory); shared_memory_lock(memory);
readv = (uint64)LOAD_U16(maddr); readv = (uint64)LOAD_U16(maddr);
shared_memory_unlock(memory); shared_memory_unlock(memory);
} }
else if (opcode == WASM_OP_ATOMIC_I64_LOAD32_U) { else if (opcode == WASM_OP_ATOMIC_I64_LOAD32_U) {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); CHECK_MEMORY_OVERFLOW(4);
CHECK_ATOMIC_MEMORY_ACCESS(4); CHECK_ATOMIC_MEMORY_ACCESS(4);
shared_memory_lock(memory); shared_memory_lock(memory);
readv = (uint64)LOAD_U32(maddr); readv = (uint64)LOAD_U32(maddr);
shared_memory_unlock(memory); shared_memory_unlock(memory);
} }
else { else {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 8, maddr); CHECK_MEMORY_OVERFLOW(8);
CHECK_ATOMIC_MEMORY_ACCESS(8); CHECK_ATOMIC_MEMORY_ACCESS(8);
shared_memory_lock(memory); shared_memory_lock(memory);
readv = LOAD_I64(maddr); readv = LOAD_I64(maddr);
@ -3454,21 +3454,21 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
addr = POP_I32(); addr = POP_I32();
if (opcode == WASM_OP_ATOMIC_I32_STORE8) { if (opcode == WASM_OP_ATOMIC_I32_STORE8) {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); CHECK_MEMORY_OVERFLOW(1);
CHECK_ATOMIC_MEMORY_ACCESS(1); CHECK_ATOMIC_MEMORY_ACCESS(1);
shared_memory_lock(memory); shared_memory_lock(memory);
*(uint8 *)maddr = (uint8)sval; *(uint8 *)maddr = (uint8)sval;
shared_memory_unlock(memory); shared_memory_unlock(memory);
} }
else if (opcode == WASM_OP_ATOMIC_I32_STORE16) { else if (opcode == WASM_OP_ATOMIC_I32_STORE16) {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); CHECK_MEMORY_OVERFLOW(2);
CHECK_ATOMIC_MEMORY_ACCESS(2); CHECK_ATOMIC_MEMORY_ACCESS(2);
shared_memory_lock(memory); shared_memory_lock(memory);
STORE_U16(maddr, (uint16)sval); STORE_U16(maddr, (uint16)sval);
shared_memory_unlock(memory); shared_memory_unlock(memory);
} }
else { else {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); CHECK_MEMORY_OVERFLOW(4);
CHECK_ATOMIC_MEMORY_ACCESS(4); CHECK_ATOMIC_MEMORY_ACCESS(4);
shared_memory_lock(memory); shared_memory_lock(memory);
STORE_U32(maddr, sval); STORE_U32(maddr, sval);
@ -3488,28 +3488,28 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
addr = POP_I32(); addr = POP_I32();
if (opcode == WASM_OP_ATOMIC_I64_STORE8) { if (opcode == WASM_OP_ATOMIC_I64_STORE8) {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); CHECK_MEMORY_OVERFLOW(1);
CHECK_ATOMIC_MEMORY_ACCESS(1); CHECK_ATOMIC_MEMORY_ACCESS(1);
shared_memory_lock(memory); shared_memory_lock(memory);
*(uint8 *)maddr = (uint8)sval; *(uint8 *)maddr = (uint8)sval;
shared_memory_unlock(memory); shared_memory_unlock(memory);
} }
else if (opcode == WASM_OP_ATOMIC_I64_STORE16) { else if (opcode == WASM_OP_ATOMIC_I64_STORE16) {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); CHECK_MEMORY_OVERFLOW(2);
CHECK_ATOMIC_MEMORY_ACCESS(2); CHECK_ATOMIC_MEMORY_ACCESS(2);
shared_memory_lock(memory); shared_memory_lock(memory);
STORE_U16(maddr, (uint16)sval); STORE_U16(maddr, (uint16)sval);
shared_memory_unlock(memory); shared_memory_unlock(memory);
} }
else if (opcode == WASM_OP_ATOMIC_I64_STORE32) { else if (opcode == WASM_OP_ATOMIC_I64_STORE32) {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); CHECK_MEMORY_OVERFLOW(4);
CHECK_ATOMIC_MEMORY_ACCESS(4); CHECK_ATOMIC_MEMORY_ACCESS(4);
shared_memory_lock(memory); shared_memory_lock(memory);
STORE_U32(maddr, (uint32)sval); STORE_U32(maddr, (uint32)sval);
shared_memory_unlock(memory); shared_memory_unlock(memory);
} }
else { else {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 8, maddr); CHECK_MEMORY_OVERFLOW(8);
CHECK_ATOMIC_MEMORY_ACCESS(8); CHECK_ATOMIC_MEMORY_ACCESS(8);
shared_memory_lock(memory); shared_memory_lock(memory);
STORE_I64(maddr, sval); STORE_I64(maddr, sval);
@ -3529,7 +3529,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
addr = POP_I32(); addr = POP_I32();
if (opcode == WASM_OP_ATOMIC_RMW_I32_CMPXCHG8_U) { if (opcode == WASM_OP_ATOMIC_RMW_I32_CMPXCHG8_U) {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); CHECK_MEMORY_OVERFLOW(1);
CHECK_ATOMIC_MEMORY_ACCESS(1); CHECK_ATOMIC_MEMORY_ACCESS(1);
expect = (uint8)expect; expect = (uint8)expect;
@ -3540,7 +3540,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
shared_memory_unlock(memory); shared_memory_unlock(memory);
} }
else if (opcode == WASM_OP_ATOMIC_RMW_I32_CMPXCHG16_U) { else if (opcode == WASM_OP_ATOMIC_RMW_I32_CMPXCHG16_U) {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); CHECK_MEMORY_OVERFLOW(2);
CHECK_ATOMIC_MEMORY_ACCESS(2); CHECK_ATOMIC_MEMORY_ACCESS(2);
expect = (uint16)expect; expect = (uint16)expect;
@ -3551,7 +3551,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
shared_memory_unlock(memory); shared_memory_unlock(memory);
} }
else { else {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); CHECK_MEMORY_OVERFLOW(4);
CHECK_ATOMIC_MEMORY_ACCESS(4); CHECK_ATOMIC_MEMORY_ACCESS(4);
shared_memory_lock(memory); shared_memory_lock(memory);
@ -3575,7 +3575,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
addr = POP_I32(); addr = POP_I32();
if (opcode == WASM_OP_ATOMIC_RMW_I64_CMPXCHG8_U) { if (opcode == WASM_OP_ATOMIC_RMW_I64_CMPXCHG8_U) {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); CHECK_MEMORY_OVERFLOW(1);
CHECK_ATOMIC_MEMORY_ACCESS(1); CHECK_ATOMIC_MEMORY_ACCESS(1);
expect = (uint8)expect; expect = (uint8)expect;
@ -3586,7 +3586,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
shared_memory_unlock(memory); shared_memory_unlock(memory);
} }
else if (opcode == WASM_OP_ATOMIC_RMW_I64_CMPXCHG16_U) { else if (opcode == WASM_OP_ATOMIC_RMW_I64_CMPXCHG16_U) {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); CHECK_MEMORY_OVERFLOW(2);
CHECK_ATOMIC_MEMORY_ACCESS(2); CHECK_ATOMIC_MEMORY_ACCESS(2);
expect = (uint16)expect; expect = (uint16)expect;
@ -3597,7 +3597,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
shared_memory_unlock(memory); shared_memory_unlock(memory);
} }
else if (opcode == WASM_OP_ATOMIC_RMW_I64_CMPXCHG32_U) { else if (opcode == WASM_OP_ATOMIC_RMW_I64_CMPXCHG32_U) {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); CHECK_MEMORY_OVERFLOW(4);
CHECK_ATOMIC_MEMORY_ACCESS(4); CHECK_ATOMIC_MEMORY_ACCESS(4);
expect = (uint32)expect; expect = (uint32)expect;
@ -3608,7 +3608,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
shared_memory_unlock(memory); shared_memory_unlock(memory);
} }
else { else {
CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 8, maddr); CHECK_MEMORY_OVERFLOW(8);
CHECK_ATOMIC_MEMORY_ACCESS(8); CHECK_ATOMIC_MEMORY_ACCESS(8);
shared_memory_lock(memory); shared_memory_lock(memory);

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

@ -4267,14 +4267,22 @@ check_wasi_abi_compatibility(const WASMModule *module,
/* clang-format on */ /* clang-format on */
WASMExport *initialize = NULL, *memory = NULL, *start = NULL; WASMExport *initialize = NULL, *memory = NULL, *start = NULL;
uint32 import_function_count = module->import_function_count;
WASMType *func_type;
/* (func (export "_start") (...) */ /* (func (export "_start") (...) */
start = wasm_loader_find_export(module, "", "_start", EXPORT_KIND_FUNC, start = wasm_loader_find_export(module, "", "_start", EXPORT_KIND_FUNC,
error_buf, error_buf_size); error_buf, error_buf_size);
if (start) { if (start) {
WASMType *func_type = if (start->index < import_function_count) {
module->functions[start->index - module->import_function_count] set_error_buf(
->func_type; error_buf, error_buf_size,
"the builtin _start function can not be an import function");
return false;
}
func_type =
module->functions[start->index - import_function_count]->func_type;
if (func_type->param_count || func_type->result_count) { if (func_type->param_count || func_type->result_count) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"the signature of builtin _start function is wrong"); "the signature of builtin _start function is wrong");
@ -4286,11 +4294,17 @@ check_wasi_abi_compatibility(const WASMModule *module,
initialize = initialize =
wasm_loader_find_export(module, "", "_initialize", EXPORT_KIND_FUNC, wasm_loader_find_export(module, "", "_initialize", EXPORT_KIND_FUNC,
error_buf, error_buf_size); error_buf, error_buf_size);
if (initialize) { if (initialize) {
WASMType *func_type = if (initialize->index < import_function_count) {
module set_error_buf(error_buf, error_buf_size,
->functions[initialize->index "the builtin _initialize function can not be an "
- module->import_function_count] "import function");
return false;
}
func_type =
module->functions[initialize->index - import_function_count]
->func_type; ->func_type;
if (func_type->param_count || func_type->result_count) { if (func_type->param_count || func_type->result_count) {
set_error_buf( set_error_buf(
@ -7057,7 +7071,8 @@ wasm_loader_check_br(WASMLoaderContext *loader_ctx, uint32 depth,
int32 i, available_stack_cell; int32 i, available_stack_cell;
uint16 cell_num; uint16 cell_num;
if (loader_ctx->csp_num < depth + 1) { bh_assert(loader_ctx->csp_num > 0);
if (loader_ctx->csp_num - 1 < depth) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"unknown label, " "unknown label, "
"unexpected end of section or function"); "unexpected end of section or function");
@ -7680,8 +7695,15 @@ re_scan:
* Since the stack is already in polymorphic state, * Since the stack is already in polymorphic state,
* the opcode will not be executed, so the dummy * the opcode will not be executed, so the dummy
* offset won't cause any error */ * offset won't cause any error */
*loader_ctx->frame_offset++ = 0; uint32 n;
if (cell_num > 1) {
for (n = 0; n < cell_num; n++) {
if (loader_ctx->p_code_compiled == NULL) {
if (!check_offset_push(loader_ctx,
error_buf,
error_buf_size))
goto fail;
}
*loader_ctx->frame_offset++ = 0; *loader_ctx->frame_offset++ = 0;
} }
} }
@ -8891,7 +8913,6 @@ re_scan:
{ {
p_org = p - 1; p_org = p - 1;
GET_LOCAL_INDEX_TYPE_AND_OFFSET(); GET_LOCAL_INDEX_TYPE_AND_OFFSET();
POP_TYPE(local_type);
#if WASM_ENABLE_FAST_INTERP != 0 #if WASM_ENABLE_FAST_INTERP != 0
if (!(preserve_referenced_local( if (!(preserve_referenced_local(
@ -8948,6 +8969,7 @@ re_scan:
} }
#endif #endif
#endif /* end of WASM_ENABLE_FAST_INTERP != 0 */ #endif /* end of WASM_ENABLE_FAST_INTERP != 0 */
POP_TYPE(local_type);
break; break;
} }

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

@ -5226,7 +5226,8 @@ wasm_loader_check_br(WASMLoaderContext *loader_ctx, uint32 depth,
int32 i, available_stack_cell; int32 i, available_stack_cell;
uint16 cell_num; uint16 cell_num;
if (loader_ctx->csp_num < depth + 1) { bh_assert(loader_ctx->csp_num > 0);
if (loader_ctx->csp_num - 1 < depth) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"unknown label, " "unknown label, "
"unexpected end of section or function"); "unexpected end of section or function");
@ -5705,8 +5706,15 @@ re_scan:
* Since the stack is already in polymorphic state, * Since the stack is already in polymorphic state,
* the opcode will not be executed, so the dummy * the opcode will not be executed, so the dummy
* offset won't cause any error */ * offset won't cause any error */
*loader_ctx->frame_offset++ = 0; uint32 n;
if (cell_num > 1) {
for (n = 0; n < cell_num; n++) {
if (loader_ctx->p_code_compiled == NULL) {
if (!check_offset_push(loader_ctx,
error_buf,
error_buf_size))
goto fail;
}
*loader_ctx->frame_offset++ = 0; *loader_ctx->frame_offset++ = 0;
} }
} }
@ -6593,7 +6601,6 @@ re_scan:
{ {
p_org = p - 1; p_org = p - 1;
GET_LOCAL_INDEX_TYPE_AND_OFFSET(); GET_LOCAL_INDEX_TYPE_AND_OFFSET();
POP_TYPE(local_type);
#if WASM_ENABLE_FAST_INTERP != 0 #if WASM_ENABLE_FAST_INTERP != 0
if (!(preserve_referenced_local( if (!(preserve_referenced_local(
@ -6647,6 +6654,7 @@ re_scan:
} }
#endif #endif
#endif #endif
POP_TYPE(local_type);
break; break;
} }

16
core/shared/platform/nuttx/nuttx_platform.c
View File

@ -94,7 +94,11 @@ os_mmap(void *hint, size_t size, int prot, int flags, os_file_handle file)
#if defined(CONFIG_ARCH_USE_TEXT_HEAP) #if defined(CONFIG_ARCH_USE_TEXT_HEAP)
if ((prot & MMAP_PROT_EXEC) != 0) { if ((prot & MMAP_PROT_EXEC) != 0) {
return up_textheap_memalign(sizeof(void *), size); p = up_textheap_memalign(sizeof(void *), size);
if (p) {
memset(p, 0, size);
}
return p;
} }
#endif #endif
@ -108,7 +112,11 @@ os_mmap(void *hint, size_t size, int prot, int flags, os_file_handle file)
return NULL; return NULL;
} }
i_addr = (void *)((uint8 *)d_addr + MEM_DUAL_BUS_OFFSET); i_addr = (void *)((uint8 *)d_addr + MEM_DUAL_BUS_OFFSET);
return in_ibus_ext(i_addr) ? i_addr : d_addr; p = in_ibus_ext(i_addr) ? i_addr : d_addr;
if (p) {
memset(p, 0, size);
}
return p;
} }
#endif #endif
/* Note: aot_loader.c assumes that os_mmap provides large enough /* Note: aot_loader.c assumes that os_mmap provides large enough
@ -125,6 +133,10 @@ os_mmap(void *hint, size_t size, int prot, int flags, os_file_handle file)
if (posix_memalign(&p, 32, size)) { if (posix_memalign(&p, 32, size)) {
return NULL; return NULL;
} }
/* Zero the memory which is required by os_mmap */
memset(p, 0, size);
return p; return p;
} }