From 6415e1b0063010acb8bc6d3e8f36e5e2ccc71249 Mon Sep 17 00:00:00 2001 From: Wenyong Huang Date: Fri, 8 Oct 2021 11:44:39 +0800 Subject: [PATCH] Apply clang-format for interpreter source files (#772) And update source debugging document. --- core/iwasm/common/wasm_runtime_common.h | 1 - core/iwasm/interpreter/wasm.h | 25 +- core/iwasm/interpreter/wasm_interp.h | 62 +- core/iwasm/interpreter/wasm_interp_classic.c | 5658 ++++++++--------- core/iwasm/interpreter/wasm_interp_fast.c | 5718 +++++++++--------- core/iwasm/interpreter/wasm_loader.c | 2788 +++++---- core/iwasm/interpreter/wasm_loader.h | 20 +- core/iwasm/interpreter/wasm_mini_loader.c | 2439 ++++---- core/iwasm/interpreter/wasm_opcode.h | 1463 +++-- core/iwasm/interpreter/wasm_runtime.c | 699 +-- core/iwasm/interpreter/wasm_runtime.h | 83 +- doc/source_debugging.md | 18 +- 12 files changed, 9750 insertions(+), 9224 deletions(-) diff --git a/core/iwasm/common/wasm_runtime_common.h b/core/iwasm/common/wasm_runtime_common.h index baaf3b9d..cd13a2a0 100644 --- a/core/iwasm/common/wasm_runtime_common.h +++ b/core/iwasm/common/wasm_runtime_common.h @@ -57,7 +57,6 @@ extern "C" { #define STORE_PTR(addr, ptr) do { \ *(void**)addr = (void*)ptr; \ } while (0) -#define LOAD_PTR(addr) (*(void**)(addr)) #else /* WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS != 0 */ diff --git a/core/iwasm/interpreter/wasm.h b/core/iwasm/interpreter/wasm.h index 5bdf65c6..4402b92e 100644 --- a/core/iwasm/interpreter/wasm.h +++ b/core/iwasm/interpreter/wasm.h @@ -24,7 +24,7 @@ extern "C" { #define VALUE_TYPE_EXTERNREF 0x6F #define VALUE_TYPE_VOID 0x40 /* Used by AOT */ -#define VALUE_TYPE_I1 0x41 +#define VALUE_TYPE_I1 0x41 /* Used by loader to represent any type of i32/i64/f32/f64 */ #define VALUE_TYPE_ANY 0x42 @@ -66,8 +66,8 @@ extern "C" { #endif #define SUB_SECTION_TYPE_MODULE 0 -#define SUB_SECTION_TYPE_FUNC 1 -#define SUB_SECTION_TYPE_LOCAL 2 +#define SUB_SECTION_TYPE_FUNC 1 +#define SUB_SECTION_TYPE_LOCAL 2 #define IMPORT_KIND_FUNC 0 #define IMPORT_KIND_TABLE 1 @@ -449,7 +449,7 @@ typedef struct WASMBranchBlock { * @return the aligned value */ inline static unsigned -align_uint (unsigned v, unsigned b) +align_uint(unsigned v, unsigned b) { unsigned m = b - 1; return (v + m) & ~m; @@ -462,7 +462,7 @@ inline static uint32 wasm_string_hash(const char *str) { unsigned h = (unsigned)strlen(str); - const uint8 *p = (uint8*)str; + const uint8 *p = (uint8 *)str; const uint8 *end = p + h; while (p != end) @@ -547,9 +547,10 @@ wasm_type_equal(const WASMType *type1, const WASMType *type2) return (type1->param_count == type2->param_count && type1->result_count == type2->result_count && memcmp(type1->types, type2->types, - (uint32)(type1->param_count - + type1->result_count)) == 0) - ? true : false; + (uint32)(type1->param_count + type1->result_count)) + == 0) + ? true + : false; } inline static uint32 @@ -566,8 +567,7 @@ wasm_get_smallest_type_idx(WASMType **types, uint32 type_count, } static inline uint32 -block_type_get_param_types(BlockType *block_type, - uint8 **p_param_types) +block_type_get_param_types(BlockType *block_type, uint8 **p_param_types) { uint32 param_count = 0; if (!block_type->is_value_type) { @@ -577,15 +577,14 @@ block_type_get_param_types(BlockType *block_type, } else { *p_param_types = NULL; - param_count = 0; + param_count = 0; } return param_count; } static inline uint32 -block_type_get_result_types(BlockType *block_type, - uint8 **p_result_types) +block_type_get_result_types(BlockType *block_type, uint8 **p_result_types) { uint32 result_count = 0; if (block_type->is_value_type) { diff --git a/core/iwasm/interpreter/wasm_interp.h b/core/iwasm/interpreter/wasm_interp.h index a0d56f32..4ac36eda 100644 --- a/core/iwasm/interpreter/wasm_interp.h +++ b/core/iwasm/interpreter/wasm_interp.h @@ -17,43 +17,43 @@ struct WASMFunctionInstance; struct WASMExecEnv; typedef struct WASMInterpFrame { - /* The frame of the caller that are calling the current function. */ - struct WASMInterpFrame *prev_frame; + /* The frame of the caller that are calling the current function. */ + struct WASMInterpFrame *prev_frame; - /* The current WASM function. */ - struct WASMFunctionInstance *function; + /* The current WASM function. */ + struct WASMFunctionInstance *function; - /* Instruction pointer of the bytecode array. */ - uint8 *ip; + /* Instruction pointer of the bytecode array. */ + uint8 *ip; #if WASM_ENABLE_PERF_PROFILING != 0 - uint64 time_started; + uint64 time_started; #endif #if WASM_ENABLE_FAST_INTERP != 0 - /* return offset of the first return value of current frame. - the callee will put return values here continuously */ - uint32 ret_offset; - uint32 *lp; - uint32 operand[1]; + /* Return offset of the first return value of current frame, + the callee will put return values here continuously */ + uint32 ret_offset; + uint32 *lp; + uint32 operand[1]; #else - /* Operand stack top pointer of the current frame. The bottom of - the stack is the next cell after the last local variable. */ - uint32 *sp_bottom; - uint32 *sp_boundary; - uint32 *sp; + /* Operand stack top pointer of the current frame. The bottom of + the stack is the next cell after the last local variable. */ + uint32 *sp_bottom; + uint32 *sp_boundary; + uint32 *sp; - WASMBranchBlock *csp_bottom; - WASMBranchBlock *csp_boundary; - WASMBranchBlock *csp; + WASMBranchBlock *csp_bottom; + WASMBranchBlock *csp_boundary; + WASMBranchBlock *csp; - /* Frame data, the layout is: - lp: param_cell_count + local_cell_count - sp_bottom to sp_boundary: stack of data - csp_bottom to csp_boundary: stack of block - ref to frame end: data types of local vairables and stack data - */ - uint32 lp[1]; + /* Frame data, the layout is: + lp: param_cell_count + local_cell_count + sp_bottom to sp_boundary: stack of data + csp_bottom to csp_boundary: stack of block + ref to frame end: data types of local vairables and stack data + */ + uint32 lp[1]; #endif } WASMInterpFrame; @@ -68,15 +68,15 @@ typedef struct WASMInterpFrame { static inline unsigned wasm_interp_interp_frame_size(unsigned all_cell_num) { - return align_uint((uint32)offsetof(WASMInterpFrame, lp) - + all_cell_num * 5, 4); + return align_uint((uint32)offsetof(WASMInterpFrame, lp) + all_cell_num * 5, + 4); } void wasm_interp_call_wasm(struct WASMModuleInstance *module_inst, struct WASMExecEnv *exec_env, - struct WASMFunctionInstance *function, - uint32 argc, uint32 argv[]); + struct WASMFunctionInstance *function, uint32 argc, + uint32 argv[]); #ifdef __cplusplus } diff --git a/core/iwasm/interpreter/wasm_interp_classic.c b/core/iwasm/interpreter/wasm_interp_classic.c index 1f9ddf3f..a4e48510 100644 --- a/core/iwasm/interpreter/wasm_interp_classic.c +++ b/core/iwasm/interpreter/wasm_interp_classic.c @@ -23,29 +23,33 @@ typedef float64 CellType_F64; #define BR_TABLE_TMP_BUF_LEN 32 -#define CHECK_MEMORY_OVERFLOW(bytes) do { \ - uint64 offset1 = (uint64)offset + (uint64)addr; \ - if (offset1 + bytes <= (uint64)linear_mem_size) \ - /* If offset1 is in valid range, maddr must also be in valid range, \ - no need to check it again. */ \ - maddr = memory->memory_data + offset1; \ - else \ - goto out_of_bounds; \ - } while (0) +#define CHECK_MEMORY_OVERFLOW(bytes) \ + do { \ + uint64 offset1 = (uint64)offset + (uint64)addr; \ + if (offset1 + bytes <= (uint64)linear_mem_size) \ + /* If offset1 is in valid range, maddr must also \ + be in valid range, no need to check it again. */ \ + maddr = memory->memory_data + offset1; \ + else \ + goto out_of_bounds; \ + } while (0) -#define CHECK_BULK_MEMORY_OVERFLOW(start, bytes, maddr) do { \ - uint64 offset1 = (uint32)(start); \ - if (offset1 + bytes <= (uint64)linear_mem_size) \ - /* App heap space is not valid space for bulk memory operation */ \ - maddr = memory->memory_data + offset1; \ - else \ - goto out_of_bounds; \ - } while (0) +#define CHECK_BULK_MEMORY_OVERFLOW(start, bytes, maddr) \ + do { \ + uint64 offset1 = (uint32)(start); \ + if (offset1 + bytes <= (uint64)linear_mem_size) \ + /* App heap space is not valid space for \ + bulk memory operation */ \ + maddr = memory->memory_data + offset1; \ + else \ + goto out_of_bounds; \ + } while (0) -#define CHECK_ATOMIC_MEMORY_ACCESS() do { \ - if (((uintptr_t)maddr & (((uintptr_t)1 << align) - 1)) != 0)\ - goto unaligned_atomic; \ - } while (0) +#define CHECK_ATOMIC_MEMORY_ACCESS() \ + do { \ + if (((uintptr_t)maddr & (((uintptr_t)1 << align) - 1)) != 0) \ + goto unaligned_atomic; \ + } while (0) static inline uint32 rotl32(uint32 n, uint32 c) @@ -87,7 +91,7 @@ static inline double wa_fmax(double a, double b) { double c = fmax(a, b); - if (c==0 && a==b) + if (c == 0 && a == b) return signbit(a) ? b : a; return c; } @@ -96,7 +100,7 @@ static inline double wa_fmin(double a, double b) { double c = fmin(a, b); - if (c==0 && a==b) + if (c == 0 && a == b) return signbit(a) ? a : b; return c; } @@ -200,141 +204,155 @@ read_leb(const uint8 *buf, uint32 *p_offset, uint32 maxbits, bool sign) #define skip_leb(p) while (*p++ & 0x80) -#define PUSH_I32(value) do { \ - *(int32*)frame_sp++ = (int32)(value); \ - } while (0) +#define PUSH_I32(value) \ + do { \ + *(int32 *)frame_sp++ = (int32)(value); \ + } while (0) -#define PUSH_F32(value) do { \ - *(float32*)frame_sp++ = (float32)(value); \ - } while (0) +#define PUSH_F32(value) \ + do { \ + *(float32 *)frame_sp++ = (float32)(value); \ + } while (0) -#define PUSH_I64(value) do { \ - PUT_I64_TO_ADDR(frame_sp, value); \ - frame_sp += 2; \ - } while (0) +#define PUSH_I64(value) \ + do { \ + PUT_I64_TO_ADDR(frame_sp, value); \ + frame_sp += 2; \ + } while (0) -#define PUSH_F64(value) do { \ - PUT_F64_TO_ADDR(frame_sp, value); \ - frame_sp += 2; \ - } while (0) +#define PUSH_F64(value) \ + do { \ + PUT_F64_TO_ADDR(frame_sp, value); \ + frame_sp += 2; \ + } while (0) -#define PUSH_CSP(_label_type, cell_num, _target_addr) do { \ - bh_assert(frame_csp < frame->csp_boundary); \ - /* frame_csp->label_type = _label_type; */ \ - frame_csp->cell_num = cell_num; \ - frame_csp->begin_addr = frame_ip; \ - frame_csp->target_addr = _target_addr; \ - frame_csp->frame_sp = frame_sp; \ - frame_csp++; \ - } while (0) +#define PUSH_CSP(_label_type, cell_num, _target_addr) \ + do { \ + bh_assert(frame_csp < frame->csp_boundary); \ + /* frame_csp->label_type = _label_type; */ \ + frame_csp->cell_num = cell_num; \ + frame_csp->begin_addr = frame_ip; \ + frame_csp->target_addr = _target_addr; \ + frame_csp->frame_sp = frame_sp; \ + frame_csp++; \ + } while (0) -#define POP_I32() (--frame_sp, *(int32*)frame_sp) +#define POP_I32() (--frame_sp, *(int32 *)frame_sp) -#define POP_F32() (--frame_sp, *(float32*)frame_sp) +#define POP_F32() (--frame_sp, *(float32 *)frame_sp) #define POP_I64() (frame_sp -= 2, GET_I64_FROM_ADDR(frame_sp)) #define POP_F64() (frame_sp -= 2, GET_F64_FROM_ADDR(frame_sp)) -#define POP_CSP_CHECK_OVERFLOW(n) do { \ - bh_assert(frame_csp - n >= frame->csp_bottom); \ - } while (0) +#define POP_CSP_CHECK_OVERFLOW(n) \ + do { \ + bh_assert(frame_csp - n >= frame->csp_bottom); \ + } while (0) -#define POP_CSP() do { \ - POP_CSP_CHECK_OVERFLOW(1); \ - --frame_csp; \ - } while (0) +#define POP_CSP() \ + do { \ + POP_CSP_CHECK_OVERFLOW(1); \ + --frame_csp; \ + } while (0) -#define POP_CSP_N(n) do { \ - uint32 *frame_sp_old = frame_sp; \ - uint32 cell_num = 0; \ - POP_CSP_CHECK_OVERFLOW(n + 1); \ - frame_csp -= n; \ - frame_ip = (frame_csp - 1)->target_addr; \ - /* copy arity values of block */ \ - frame_sp = (frame_csp - 1)->frame_sp; \ - cell_num = (frame_csp - 1)->cell_num; \ - word_copy(frame_sp, frame_sp_old - cell_num, cell_num); \ - frame_sp += cell_num; \ - } while (0) +#define POP_CSP_N(n) \ + do { \ + uint32 *frame_sp_old = frame_sp; \ + uint32 cell_num = 0; \ + POP_CSP_CHECK_OVERFLOW(n + 1); \ + frame_csp -= n; \ + frame_ip = (frame_csp - 1)->target_addr; \ + /* copy arity values of block */ \ + frame_sp = (frame_csp - 1)->frame_sp; \ + cell_num = (frame_csp - 1)->cell_num; \ + word_copy(frame_sp, frame_sp_old - cell_num, cell_num); \ + frame_sp += cell_num; \ + } while (0) /* Pop the given number of elements from the given frame's stack. */ -#define POP(N) do { \ - int n = (N); \ - frame_sp -= n; \ - } while (0) +#define POP(N) \ + do { \ + int n = (N); \ + frame_sp -= n; \ + } while (0) -#define SYNC_ALL_TO_FRAME() do { \ - frame->sp = frame_sp; \ - frame->ip = frame_ip; \ - frame->csp = frame_csp; \ - } while (0) +#define SYNC_ALL_TO_FRAME() \ + do { \ + frame->sp = frame_sp; \ + frame->ip = frame_ip; \ + frame->csp = frame_csp; \ + } while (0) -#define UPDATE_ALL_FROM_FRAME() do { \ - frame_sp = frame->sp; \ - frame_ip = frame->ip; \ - frame_csp = frame->csp; \ - } while (0) +#define UPDATE_ALL_FROM_FRAME() \ + do { \ + frame_sp = frame->sp; \ + frame_ip = frame->ip; \ + frame_csp = frame->csp; \ + } while (0) -#define read_leb_int64(p, p_end, res) do { \ - uint8 _val = *p; \ - if (!(_val & 0x80)) { \ - res = (int64)_val; \ - if (_val & 0x40) \ - /* sign extend */ \ - res |= 0xFFFFFFFFFFFFFF80LL; \ - p++; \ - break; \ - } \ - uint32 _off = 0; \ - res = (int64)read_leb(p, &_off, 64, true); \ - p += _off; \ -} while (0) +#define read_leb_int64(p, p_end, res) \ + do { \ + uint8 _val = *p; \ + if (!(_val & 0x80)) { \ + res = (int64)_val; \ + if (_val & 0x40) \ + /* sign extend */ \ + res |= 0xFFFFFFFFFFFFFF80LL; \ + p++; \ + break; \ + } \ + uint32 _off = 0; \ + res = (int64)read_leb(p, &_off, 64, true); \ + p += _off; \ + } while (0) -#define read_leb_uint32(p, p_end, res) do { \ - uint8 _val = *p; \ - if (!(_val & 0x80)) { \ - res = _val; \ - p++; \ - break; \ - } \ - uint32 _off = 0; \ - res = (uint32)read_leb(p, &_off, 32, false); \ - p += _off; \ -} while (0) +#define read_leb_uint32(p, p_end, res) \ + do { \ + uint8 _val = *p; \ + if (!(_val & 0x80)) { \ + res = _val; \ + p++; \ + break; \ + } \ + uint32 _off = 0; \ + res = (uint32)read_leb(p, &_off, 32, false); \ + p += _off; \ + } while (0) -#define read_leb_int32(p, p_end, res) do { \ - uint8 _val = *p; \ - if (!(_val & 0x80)) { \ - res = (int32)_val; \ - if (_val & 0x40) \ - /* sign extend */ \ - res |= 0xFFFFFF80; \ - p++; \ - break; \ - } \ - uint32 _off = 0; \ - res = (int32)read_leb(p, &_off, 32, true); \ - p += _off; \ -} while (0) +#define read_leb_int32(p, p_end, res) \ + do { \ + uint8 _val = *p; \ + if (!(_val & 0x80)) { \ + res = (int32)_val; \ + if (_val & 0x40) \ + /* sign extend */ \ + res |= 0xFFFFFF80; \ + p++; \ + break; \ + } \ + uint32 _off = 0; \ + res = (int32)read_leb(p, &_off, 32, true); \ + p += _off; \ + } while (0) #if WASM_ENABLE_LABELS_AS_VALUES == 0 -#define RECOVER_FRAME_IP_END() \ - frame_ip_end = wasm_get_func_code_end(cur_func) +#define RECOVER_FRAME_IP_END() frame_ip_end = wasm_get_func_code_end(cur_func) #else #define RECOVER_FRAME_IP_END() (void)0 #endif -#define RECOVER_CONTEXT(new_frame) do { \ - frame = (new_frame); \ - cur_func = frame->function; \ - prev_frame = frame->prev_frame; \ - frame_ip = frame->ip; \ - RECOVER_FRAME_IP_END(); \ - frame_lp = frame->lp; \ - frame_sp = frame->sp; \ - frame_csp = frame->csp; \ - } while (0) +#define RECOVER_CONTEXT(new_frame) \ + do { \ + frame = (new_frame); \ + cur_func = frame->function; \ + prev_frame = frame->prev_frame; \ + frame_ip = frame->ip; \ + RECOVER_FRAME_IP_END(); \ + frame_lp = frame->lp; \ + frame_sp = frame->sp; \ + frame_csp = frame->csp; \ + } while (0) #if WASM_ENABLE_LABELS_AS_VALUES != 0 #define GET_OPCODE() opcode = *(frame_ip - 1); @@ -342,96 +360,105 @@ read_leb(const uint8 *buf, uint32 *p_offset, uint32 maxbits, bool sign) #define GET_OPCODE() (void)0 #endif -#define DEF_OP_I_CONST(ctype, src_op_type) do { \ - ctype cval; \ - read_leb_##ctype(frame_ip, frame_ip_end, cval); \ - PUSH_##src_op_type(cval); \ - } while (0) +#define DEF_OP_I_CONST(ctype, src_op_type) \ + do { \ + ctype cval; \ + read_leb_##ctype(frame_ip, frame_ip_end, cval); \ + PUSH_##src_op_type(cval); \ + } while (0) -#define DEF_OP_EQZ(src_op_type) do { \ - int32 val; \ - val = POP_##src_op_type() == 0; \ - PUSH_I32(val); \ - } while (0) +#define DEF_OP_EQZ(src_op_type) \ + do { \ + int32 val; \ + val = POP_##src_op_type() == 0; \ + PUSH_I32(val); \ + } while (0) -#define DEF_OP_CMP(src_type, src_op_type, cond) do { \ - uint32 res; \ - src_type val1, val2; \ - val2 = (src_type)POP_##src_op_type(); \ - val1 = (src_type)POP_##src_op_type(); \ - res = val1 cond val2; \ - PUSH_I32(res); \ - } while (0) +#define DEF_OP_CMP(src_type, src_op_type, cond) \ + do { \ + uint32 res; \ + src_type val1, val2; \ + val2 = (src_type)POP_##src_op_type(); \ + val1 = (src_type)POP_##src_op_type(); \ + res = val1 cond val2; \ + PUSH_I32(res); \ + } while (0) -#define DEF_OP_BIT_COUNT(src_type, src_op_type, operation) do { \ - src_type val1, val2; \ - val1 = (src_type)POP_##src_op_type(); \ - val2 = (src_type)operation(val1); \ - PUSH_##src_op_type(val2); \ - } while (0) +#define DEF_OP_BIT_COUNT(src_type, src_op_type, operation) \ + do { \ + src_type val1, val2; \ + val1 = (src_type)POP_##src_op_type(); \ + val2 = (src_type)operation(val1); \ + PUSH_##src_op_type(val2); \ + } while (0) -#define DEF_OP_NUMERIC(src_type1, src_type2, src_op_type, operation) do { \ - frame_sp -= sizeof(src_type2)/sizeof(uint32); \ - *(src_type1*)(frame_sp - sizeof(src_type1)/sizeof(uint32)) operation##= \ - *(src_type2*)(frame_sp); \ - } while (0) +#define DEF_OP_NUMERIC(src_type1, src_type2, src_op_type, operation) \ + do { \ + frame_sp -= sizeof(src_type2) / sizeof(uint32); \ + *(src_type1 *)(frame_sp - sizeof(src_type1) / sizeof(uint32)) \ + operation## = *(src_type2 *)(frame_sp); \ + } while (0) #if WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS != 0 #define DEF_OP_NUMERIC_64 DEF_OP_NUMERIC #else -#define DEF_OP_NUMERIC_64(src_type1, src_type2, src_op_type, operation) do {\ - src_type1 val1; \ - src_type2 val2; \ - frame_sp -= 2; \ - val1 = (src_type1)GET_##src_op_type##_FROM_ADDR(frame_sp - 2); \ - val2 = (src_type2)GET_##src_op_type##_FROM_ADDR(frame_sp); \ - val1 operation##= val2; \ - PUT_##src_op_type##_TO_ADDR(frame_sp - 2, val1); \ - } while (0) +#define DEF_OP_NUMERIC_64(src_type1, src_type2, src_op_type, operation) \ + do { \ + src_type1 val1; \ + src_type2 val2; \ + frame_sp -= 2; \ + val1 = (src_type1)GET_##src_op_type##_FROM_ADDR(frame_sp - 2); \ + val2 = (src_type2)GET_##src_op_type##_FROM_ADDR(frame_sp); \ + val1 operation## = val2; \ + PUT_##src_op_type##_TO_ADDR(frame_sp - 2, val1); \ + } while (0) #endif -#define DEF_OP_NUMERIC2(src_type1, src_type2, src_op_type, operation) do { \ - frame_sp -= sizeof(src_type2)/sizeof(uint32); \ - *(src_type1*)(frame_sp - sizeof(src_type1)/sizeof(uint32)) operation##= \ - (*(src_type2*)(frame_sp) % 32); \ - } while (0) +#define DEF_OP_NUMERIC2(src_type1, src_type2, src_op_type, operation) \ + do { \ + frame_sp -= sizeof(src_type2) / sizeof(uint32); \ + *(src_type1 *)(frame_sp - sizeof(src_type1) / sizeof(uint32)) \ + operation## = (*(src_type2 *)(frame_sp) % 32); \ + } while (0) -#define DEF_OP_NUMERIC2_64(src_type1, src_type2, src_op_type, operation) do { \ - src_type1 val1; \ - src_type2 val2; \ - frame_sp -= 2; \ - val1 = (src_type1)GET_##src_op_type##_FROM_ADDR(frame_sp - 2); \ - val2 = (src_type2)GET_##src_op_type##_FROM_ADDR(frame_sp); \ - val1 operation##= (val2 % 64); \ - PUT_##src_op_type##_TO_ADDR(frame_sp - 2, val1); \ - } while (0) +#define DEF_OP_NUMERIC2_64(src_type1, src_type2, src_op_type, operation) \ + do { \ + src_type1 val1; \ + src_type2 val2; \ + frame_sp -= 2; \ + val1 = (src_type1)GET_##src_op_type##_FROM_ADDR(frame_sp - 2); \ + val2 = (src_type2)GET_##src_op_type##_FROM_ADDR(frame_sp); \ + val1 operation## = (val2 % 64); \ + PUT_##src_op_type##_TO_ADDR(frame_sp - 2, val1); \ + } while (0) -#define DEF_OP_MATH(src_type, src_op_type, method) do { \ - src_type val; \ - val = POP_##src_op_type(); \ - PUSH_##src_op_type(method(val)); \ - } while (0) +#define DEF_OP_MATH(src_type, src_op_type, method) \ + do { \ + src_type val; \ + val = POP_##src_op_type(); \ + PUSH_##src_op_type(method(val)); \ + } while (0) #define TRUNC_FUNCTION(func_name, src_type, dst_type, signed_type) \ -static dst_type \ -func_name(src_type src_value, src_type src_min, src_type src_max, \ - dst_type dst_min, dst_type dst_max, bool is_sign) \ -{ \ - dst_type dst_value = 0; \ - if (!isnan(src_value)) { \ - if (src_value <= src_min) \ - dst_value = dst_min; \ - else if (src_value >= src_max) \ - dst_value = dst_max; \ - else { \ - if (is_sign) \ - dst_value = (dst_type)(signed_type)src_value; \ - else \ - dst_value = (dst_type)src_value; \ - } \ - } \ - return dst_value; \ -} + static dst_type func_name(src_type src_value, src_type src_min, \ + src_type src_max, dst_type dst_min, \ + dst_type dst_max, bool is_sign) \ + { \ + dst_type dst_value = 0; \ + if (!isnan(src_value)) { \ + if (src_value <= src_min) \ + dst_value = dst_min; \ + else if (src_value >= src_max) \ + dst_value = dst_max; \ + else { \ + if (is_sign) \ + dst_value = (dst_type)(signed_type)src_value; \ + else \ + dst_value = (dst_type)src_value; \ + } \ + } \ + return dst_value; \ + } TRUNC_FUNCTION(trunc_f32_to_i32, float32, uint32, int32) TRUNC_FUNCTION(trunc_f32_to_i64, float32, uint64, int64) @@ -439,10 +466,8 @@ TRUNC_FUNCTION(trunc_f64_to_i32, float64, uint32, int32) TRUNC_FUNCTION(trunc_f64_to_i64, float64, uint64, int64) static bool -trunc_f32_to_int(WASMModuleInstance *module, - uint32 *frame_sp, - float32 src_min, float32 src_max, - bool saturating, bool is_i32, bool is_sign) +trunc_f32_to_int(WASMModuleInstance *module, uint32 *frame_sp, float32 src_min, + float32 src_max, bool saturating, bool is_i32, bool is_sign) { float32 src_value = POP_F32(); uint64 dst_value_i64; @@ -462,25 +487,23 @@ trunc_f32_to_int(WASMModuleInstance *module, if (is_i32) { uint32 dst_min = is_sign ? INT32_MIN : 0; uint32 dst_max = is_sign ? INT32_MAX : UINT32_MAX; - dst_value_i32 = trunc_f32_to_i32(src_value, src_min, src_max, - dst_min, dst_max, is_sign); + dst_value_i32 = trunc_f32_to_i32(src_value, src_min, src_max, dst_min, + dst_max, is_sign); PUSH_I32(dst_value_i32); } else { uint64 dst_min = is_sign ? INT64_MIN : 0; uint64 dst_max = is_sign ? INT64_MAX : UINT64_MAX; - dst_value_i64 = trunc_f32_to_i64(src_value, src_min, src_max, - dst_min, dst_max, is_sign); + dst_value_i64 = trunc_f32_to_i64(src_value, src_min, src_max, dst_min, + dst_max, is_sign); PUSH_I64(dst_value_i64); } return false; } static bool -trunc_f64_to_int(WASMModuleInstance *module, - uint32 *frame_sp, - float64 src_min, float64 src_max, - bool saturating, bool is_i32, bool is_sign) +trunc_f64_to_int(WASMModuleInstance *module, uint32 *frame_sp, float64 src_min, + float64 src_max, bool saturating, bool is_i32, bool is_sign) { float64 src_value = POP_F64(); uint64 dst_value_i64; @@ -500,150 +523,155 @@ trunc_f64_to_int(WASMModuleInstance *module, if (is_i32) { uint32 dst_min = is_sign ? INT32_MIN : 0; uint32 dst_max = is_sign ? INT32_MAX : UINT32_MAX; - dst_value_i32 = trunc_f64_to_i32(src_value, src_min, src_max, - dst_min, dst_max, is_sign); + dst_value_i32 = trunc_f64_to_i32(src_value, src_min, src_max, dst_min, + dst_max, is_sign); PUSH_I32(dst_value_i32); } else { uint64 dst_min = is_sign ? INT64_MIN : 0; uint64 dst_max = is_sign ? INT64_MAX : UINT64_MAX; - dst_value_i64 = trunc_f64_to_i64(src_value, src_min, src_max, - dst_min, dst_max, is_sign); + dst_value_i64 = trunc_f64_to_i64(src_value, src_min, src_max, dst_min, + dst_max, is_sign); PUSH_I64(dst_value_i64); } return false; } -#define DEF_OP_TRUNC_F32(min, max, is_i32, is_sign) do { \ - if (trunc_f32_to_int(module, frame_sp, min, max, \ - false, is_i32, is_sign)) \ - goto got_exception; \ - } while (0) +#define DEF_OP_TRUNC_F32(min, max, is_i32, is_sign) \ + do { \ + if (trunc_f32_to_int(module, frame_sp, min, max, false, is_i32, \ + is_sign)) \ + goto got_exception; \ + } while (0) -#define DEF_OP_TRUNC_F64(min, max, is_i32, is_sign) do { \ - if (trunc_f64_to_int(module, frame_sp, min, max, \ - false, is_i32, is_sign)) \ - goto got_exception; \ - } while (0) +#define DEF_OP_TRUNC_F64(min, max, is_i32, is_sign) \ + do { \ + if (trunc_f64_to_int(module, frame_sp, min, max, false, is_i32, \ + is_sign)) \ + goto got_exception; \ + } while (0) -#define DEF_OP_TRUNC_SAT_F32(min, max, is_i32, is_sign) do { \ - (void)trunc_f32_to_int(module, frame_sp, min, max, \ - true, is_i32, is_sign); \ - } while (0) +#define DEF_OP_TRUNC_SAT_F32(min, max, is_i32, is_sign) \ + do { \ + (void)trunc_f32_to_int(module, frame_sp, min, max, true, is_i32, \ + is_sign); \ + } while (0) -#define DEF_OP_TRUNC_SAT_F64(min, max, is_i32, is_sign) do { \ - (void)trunc_f64_to_int(module, frame_sp, min, max, \ - true, is_i32, is_sign); \ - } while (0) +#define DEF_OP_TRUNC_SAT_F64(min, max, is_i32, is_sign) \ + do { \ + (void)trunc_f64_to_int(module, frame_sp, min, max, true, is_i32, \ + is_sign); \ + } while (0) -#define DEF_OP_CONVERT(dst_type, dst_op_type, \ - src_type, src_op_type) do { \ - dst_type value = (dst_type)(src_type)POP_##src_op_type(); \ - PUSH_##dst_op_type(value); \ - } while (0) +#define DEF_OP_CONVERT(dst_type, dst_op_type, src_type, src_op_type) \ + do { \ + dst_type value = (dst_type)(src_type)POP_##src_op_type(); \ + PUSH_##dst_op_type(value); \ + } while (0) -#define GET_LOCAL_INDEX_TYPE_AND_OFFSET() do { \ - uint32 param_count = cur_func->param_count; \ - read_leb_uint32(frame_ip, frame_ip_end, local_idx); \ - bh_assert(local_idx < param_count + cur_func->local_count); \ - local_offset = cur_func->local_offsets[local_idx]; \ - if (local_idx < param_count) \ - local_type = cur_func->param_types[local_idx]; \ - else \ - local_type = cur_func->local_types[local_idx - param_count]; \ - } while (0) +#define GET_LOCAL_INDEX_TYPE_AND_OFFSET() \ + do { \ + uint32 param_count = cur_func->param_count; \ + read_leb_uint32(frame_ip, frame_ip_end, local_idx); \ + bh_assert(local_idx < param_count + cur_func->local_count); \ + local_offset = cur_func->local_offsets[local_idx]; \ + if (local_idx < param_count) \ + local_type = cur_func->param_types[local_idx]; \ + else \ + local_type = cur_func->local_types[local_idx - param_count]; \ + } while (0) -#define DEF_ATOMIC_RMW_OPCODE(OP_NAME, op) \ - case WASM_OP_ATOMIC_RMW_I32_##OP_NAME: \ - case WASM_OP_ATOMIC_RMW_I32_##OP_NAME##8_U: \ - case WASM_OP_ATOMIC_RMW_I32_##OP_NAME##16_U: \ - { \ - uint32 readv, sval; \ - \ - sval = POP_I32(); \ - addr = POP_I32(); \ - \ - if (opcode == WASM_OP_ATOMIC_RMW_I32_##OP_NAME##8_U) { \ - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); \ - CHECK_ATOMIC_MEMORY_ACCESS(); \ - \ - os_mutex_lock(&memory->mem_lock); \ - readv = (uint32)(*(uint8*)maddr); \ - *(uint8*)maddr = (uint8)(readv op sval); \ - os_mutex_unlock(&memory->mem_lock); \ - } \ - else if (opcode == WASM_OP_ATOMIC_RMW_I32_##OP_NAME##16_U) { \ - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); \ - CHECK_ATOMIC_MEMORY_ACCESS(); \ - \ - os_mutex_lock(&memory->mem_lock); \ - readv = (uint32)LOAD_U16(maddr); \ - STORE_U16(maddr, (uint16)(readv op sval)); \ - os_mutex_unlock(&memory->mem_lock); \ - } \ - else { \ - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); \ - CHECK_ATOMIC_MEMORY_ACCESS(); \ - \ - os_mutex_lock(&memory->mem_lock); \ - readv = LOAD_I32(maddr); \ - STORE_U32(maddr, readv op sval); \ - os_mutex_unlock(&memory->mem_lock); \ - } \ - PUSH_I32(readv); \ - break; \ - } \ - case WASM_OP_ATOMIC_RMW_I64_##OP_NAME: \ - case WASM_OP_ATOMIC_RMW_I64_##OP_NAME##8_U: \ - case WASM_OP_ATOMIC_RMW_I64_##OP_NAME##16_U: \ - case WASM_OP_ATOMIC_RMW_I64_##OP_NAME##32_U: \ - { \ - uint64 readv, sval; \ - \ - sval = (uint64)POP_I64(); \ - addr = POP_I32(); \ - \ - if (opcode == WASM_OP_ATOMIC_RMW_I64_##OP_NAME##8_U) { \ - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); \ - CHECK_ATOMIC_MEMORY_ACCESS(); \ - \ - os_mutex_lock(&memory->mem_lock); \ - readv = (uint64)(*(uint8*)maddr); \ - *(uint8*)maddr = (uint8)(readv op sval); \ - os_mutex_unlock(&memory->mem_lock); \ - } \ - else if (opcode == WASM_OP_ATOMIC_RMW_I64_##OP_NAME##16_U) { \ - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); \ - CHECK_ATOMIC_MEMORY_ACCESS(); \ - \ - os_mutex_lock(&memory->mem_lock); \ - readv = (uint64)LOAD_U16(maddr); \ - STORE_U16(maddr, (uint16)(readv op sval)); \ - os_mutex_unlock(&memory->mem_lock); \ - } \ - else if (opcode == WASM_OP_ATOMIC_RMW_I64_##OP_NAME##32_U) { \ - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); \ - CHECK_ATOMIC_MEMORY_ACCESS(); \ - \ - os_mutex_lock(&memory->mem_lock); \ - readv = (uint64)LOAD_U32(maddr); \ - STORE_U32(maddr, (uint32)(readv op sval)); \ - os_mutex_unlock(&memory->mem_lock); \ - } \ - else { \ - uint64 op_result; \ - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 8, maddr); \ - CHECK_ATOMIC_MEMORY_ACCESS(); \ - \ - os_mutex_lock(&memory->mem_lock); \ - readv = (uint64)LOAD_I64(maddr); \ - op_result = readv op sval; \ - STORE_I64(maddr, op_result); \ - os_mutex_unlock(&memory->mem_lock); \ - } \ - PUSH_I64(readv); \ - break; \ - } +#define DEF_ATOMIC_RMW_OPCODE(OP_NAME, op) \ + case WASM_OP_ATOMIC_RMW_I32_##OP_NAME: \ + case WASM_OP_ATOMIC_RMW_I32_##OP_NAME##8_U: \ + case WASM_OP_ATOMIC_RMW_I32_##OP_NAME##16_U: \ + { \ + uint32 readv, sval; \ + \ + sval = POP_I32(); \ + addr = POP_I32(); \ + \ + if (opcode == WASM_OP_ATOMIC_RMW_I32_##OP_NAME##8_U) { \ + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); \ + CHECK_ATOMIC_MEMORY_ACCESS(); \ + \ + os_mutex_lock(&memory->mem_lock); \ + readv = (uint32)(*(uint8 *)maddr); \ + *(uint8 *)maddr = (uint8)(readv op sval); \ + os_mutex_unlock(&memory->mem_lock); \ + } \ + else if (opcode == WASM_OP_ATOMIC_RMW_I32_##OP_NAME##16_U) { \ + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); \ + CHECK_ATOMIC_MEMORY_ACCESS(); \ + \ + os_mutex_lock(&memory->mem_lock); \ + readv = (uint32)LOAD_U16(maddr); \ + STORE_U16(maddr, (uint16)(readv op sval)); \ + os_mutex_unlock(&memory->mem_lock); \ + } \ + else { \ + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); \ + CHECK_ATOMIC_MEMORY_ACCESS(); \ + \ + os_mutex_lock(&memory->mem_lock); \ + readv = LOAD_I32(maddr); \ + STORE_U32(maddr, readv op sval); \ + os_mutex_unlock(&memory->mem_lock); \ + } \ + PUSH_I32(readv); \ + break; \ + } \ + case WASM_OP_ATOMIC_RMW_I64_##OP_NAME: \ + case WASM_OP_ATOMIC_RMW_I64_##OP_NAME##8_U: \ + case WASM_OP_ATOMIC_RMW_I64_##OP_NAME##16_U: \ + case WASM_OP_ATOMIC_RMW_I64_##OP_NAME##32_U: \ + { \ + uint64 readv, sval; \ + \ + sval = (uint64)POP_I64(); \ + addr = POP_I32(); \ + \ + if (opcode == WASM_OP_ATOMIC_RMW_I64_##OP_NAME##8_U) { \ + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); \ + CHECK_ATOMIC_MEMORY_ACCESS(); \ + \ + os_mutex_lock(&memory->mem_lock); \ + readv = (uint64)(*(uint8 *)maddr); \ + *(uint8 *)maddr = (uint8)(readv op sval); \ + os_mutex_unlock(&memory->mem_lock); \ + } \ + else if (opcode == WASM_OP_ATOMIC_RMW_I64_##OP_NAME##16_U) { \ + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); \ + CHECK_ATOMIC_MEMORY_ACCESS(); \ + \ + os_mutex_lock(&memory->mem_lock); \ + readv = (uint64)LOAD_U16(maddr); \ + STORE_U16(maddr, (uint16)(readv op sval)); \ + os_mutex_unlock(&memory->mem_lock); \ + } \ + else if (opcode == WASM_OP_ATOMIC_RMW_I64_##OP_NAME##32_U) { \ + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); \ + CHECK_ATOMIC_MEMORY_ACCESS(); \ + \ + os_mutex_lock(&memory->mem_lock); \ + readv = (uint64)LOAD_U32(maddr); \ + STORE_U32(maddr, (uint32)(readv op sval)); \ + os_mutex_unlock(&memory->mem_lock); \ + } \ + else { \ + uint64 op_result; \ + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 8, maddr); \ + CHECK_ATOMIC_MEMORY_ACCESS(); \ + \ + os_mutex_lock(&memory->mem_lock); \ + readv = (uint64)LOAD_I64(maddr); \ + op_result = readv op sval; \ + STORE_I64(maddr, op_result); \ + os_mutex_unlock(&memory->mem_lock); \ + } \ + PUSH_I64(readv); \ + break; \ + } static inline int32 sign_ext_8_32(int8 val) @@ -692,7 +720,7 @@ word_copy(uint32 *dest, uint32 *src, unsigned num) *dest++ = *src++; } -static inline WASMInterpFrame* +static inline WASMInterpFrame * ALLOC_FRAME(WASMExecEnv *exec_env, uint32 size, WASMInterpFrame *prev_frame) { WASMInterpFrame *frame = wasm_exec_env_alloc_wasm_frame(exec_env, size); @@ -704,7 +732,7 @@ ALLOC_FRAME(WASMExecEnv *exec_env, uint32 size, WASMInterpFrame *prev_frame) #endif } else { - wasm_set_exception((WASMModuleInstance*)exec_env->module_inst, + wasm_set_exception((WASMModuleInstance *)exec_env->module_inst, "wasm operand stack overflow"); } @@ -716,8 +744,8 @@ FREE_FRAME(WASMExecEnv *exec_env, WASMInterpFrame *frame) { #if WASM_ENABLE_PERF_PROFILING != 0 if (frame->function) { - frame->function->total_exec_time += os_time_get_boot_microsecond() - - frame->time_started; + frame->function->total_exec_time += + os_time_get_boot_microsecond() - frame->time_started; frame->function->total_exec_cnt++; } #endif @@ -758,26 +786,26 @@ wasm_interp_call_func_native(WASMModuleInstance *module_inst, if (func_import->call_conv_wasm_c_api) { ret = wasm_runtime_invoke_c_api_native( - (WASMModuleInstanceCommon *)module_inst, - func_import->func_ptr_linked, func_import->func_type, - cur_func->param_cell_num, frame->lp, - func_import->wasm_c_api_with_env, func_import->attachment); + (WASMModuleInstanceCommon *)module_inst, + func_import->func_ptr_linked, func_import->func_type, + cur_func->param_cell_num, frame->lp, + func_import->wasm_c_api_with_env, func_import->attachment); if (ret) { argv_ret[0] = frame->lp[0]; argv_ret[1] = frame->lp[1]; } } else if (!func_import->call_conv_raw) { - ret = wasm_runtime_invoke_native(exec_env, func_import->func_ptr_linked, - func_import->func_type, func_import->signature, - func_import->attachment, - frame->lp, cur_func->param_cell_num, argv_ret); + ret = wasm_runtime_invoke_native( + exec_env, func_import->func_ptr_linked, func_import->func_type, + func_import->signature, func_import->attachment, frame->lp, + cur_func->param_cell_num, argv_ret); } else { - ret = wasm_runtime_invoke_native_raw(exec_env, func_import->func_ptr_linked, - func_import->func_type, func_import->signature, - func_import->attachment, - frame->lp, cur_func->param_cell_num, argv_ret); + ret = wasm_runtime_invoke_native_raw( + exec_env, func_import->func_ptr_linked, func_import->func_type, + func_import->signature, func_import->attachment, frame->lp, + cur_func->param_cell_num, argv_ret); } if (!ret) @@ -833,8 +861,8 @@ wasm_interp_call_func_import(WASMModuleInstance *module_inst, exec_env->module_inst = (WASMModuleInstanceCommon *)sub_module_inst; /* call function of sub-module*/ - wasm_interp_call_func_bytecode(sub_module_inst, exec_env, - sub_func_inst, prev_frame); + wasm_interp_call_func_bytecode(sub_module_inst, exec_env, sub_func_inst, + prev_frame); /* restore ip and module_inst */ prev_frame->ip = ip; @@ -852,71 +880,85 @@ wasm_interp_call_func_import(WASMModuleInstance *module_inst, #if WASM_ENABLE_THREAD_MGR != 0 #if WASM_ENABLE_DEBUG_INTERP != 0 -#define CHECK_SUSPEND_FLAGS() do { \ - if (IS_WAMR_TERM_SIG(exec_env->current_status->signal_flag)) { \ - return; \ - } \ - if (IS_WAMR_STOP_SIG(exec_env->current_status->signal_flag)) { \ - SYNC_ALL_TO_FRAME(); \ - wasm_cluster_thread_stopped(exec_env); \ - wasm_cluster_thread_waiting_run(exec_env); \ - } \ - } while (0) +#define CHECK_SUSPEND_FLAGS() \ + do { \ + if (IS_WAMR_TERM_SIG(exec_env->current_status->signal_flag)) { \ + return; \ + } \ + if (IS_WAMR_STOP_SIG(exec_env->current_status->signal_flag)) { \ + SYNC_ALL_TO_FRAME(); \ + wasm_cluster_thread_stopped(exec_env); \ + wasm_cluster_thread_waiting_run(exec_env); \ + } \ + } while (0) #else -#define CHECK_SUSPEND_FLAGS() do { \ - if (exec_env->suspend_flags.flags != 0) { \ - if (exec_env->suspend_flags.flags & 0x01) { \ - /* terminate current thread */ \ - return; \ - } \ - while (exec_env->suspend_flags.flags & 0x02){ \ - /* suspend current thread */ \ - os_cond_wait(&exec_env->wait_cond, \ - &exec_env->wait_lock); \ - } \ - } \ - } while (0) -#endif -#endif +#define CHECK_SUSPEND_FLAGS() \ + do { \ + if (exec_env->suspend_flags.flags != 0) { \ + if (exec_env->suspend_flags.flags & 0x01) { \ + /* terminate current thread */ \ + return; \ + } \ + while (exec_env->suspend_flags.flags & 0x02) { \ + /* suspend current thread */ \ + os_cond_wait(&exec_env->wait_cond, &exec_env->wait_lock); \ + } \ + } \ + } while (0) +#endif /* WASM_ENABLE_DEBUG_INTERP */ +#endif /* WASM_ENABLE_THREAD_MGR */ #if WASM_ENABLE_LABELS_AS_VALUES != 0 -#define HANDLE_OP(opcode) HANDLE_##opcode +#define HANDLE_OP(opcode) HANDLE_##opcode: #define FETCH_OPCODE_AND_DISPATCH() goto *handle_table[*frame_ip++] #if WASM_ENABLE_THREAD_MGR != 0 && WASM_ENABLE_DEBUG_INTERP != 0 -#define HANDLE_OP_END() \ - do { \ - while (exec_env->current_status->signal_flag == WAMR_SIG_SINGSTEP \ - && exec_env->current_status->step_count++ == 1) { \ - exec_env->current_status->step_count = 0; \ - SYNC_ALL_TO_FRAME(); \ - wasm_cluster_thread_stopped(exec_env); \ - wasm_cluster_thread_waiting_run(exec_env); \ - } \ - goto *handle_table[*frame_ip++]; \ +#define HANDLE_OP_END() \ + do { \ + while (exec_env->current_status->signal_flag == WAMR_SIG_SINGSTEP \ + && exec_env->current_status->step_count++ == 1) { \ + exec_env->current_status->step_count = 0; \ + SYNC_ALL_TO_FRAME(); \ + wasm_cluster_thread_stopped(exec_env); \ + wasm_cluster_thread_waiting_run(exec_env); \ + } \ + goto *handle_table[*frame_ip++]; \ } while (0) #else #define HANDLE_OP_END() FETCH_OPCODE_AND_DISPATCH() #endif -#else /* else of WASM_ENABLE_LABELS_AS_VALUES */ -#define HANDLE_OP(opcode) case opcode +#else /* else of WASM_ENABLE_LABELS_AS_VALUES */ +#define HANDLE_OP(opcode) case opcode: #if WASM_ENABLE_THREAD_MGR != 0 && WASM_ENABLE_DEBUG_INTERP != 0 -#define HANDLE_OP_END() \ - if (exec_env->current_status->signal_flag == WAMR_SIG_SINGSTEP \ - && exec_env->current_status->step_count++ == 2) { \ - exec_env->current_status->step_count = 0; \ - SYNC_ALL_TO_FRAME(); \ - wasm_cluster_thread_stopped(exec_env); \ - wasm_cluster_thread_waiting_run(exec_env); \ - } \ +#define HANDLE_OP_END() \ + if (exec_env->current_status->signal_flag == WAMR_SIG_SINGSTEP \ + && exec_env->current_status->step_count++ == 2) { \ + exec_env->current_status->step_count = 0; \ + SYNC_ALL_TO_FRAME(); \ + wasm_cluster_thread_stopped(exec_env); \ + wasm_cluster_thread_waiting_run(exec_env); \ + } \ continue #else #define HANDLE_OP_END() continue #endif -#endif /* end of WASM_ENABLE_LABELS_AS_VALUES */ +#endif /* end of WASM_ENABLE_LABELS_AS_VALUES */ + +static inline uint8 * +get_global_addr(uint8 *global_data, WASMGlobalInstance *global) +{ +#if WASM_ENABLE_MULTI_MODULE == 0 + return global_data + global->data_offset; +#else + return global->import_global_inst + ? global->import_module_inst->global_data + + global->import_global_inst->data_offset + : global_data + global->data_offset; +#endif +} static void wasm_interp_call_func_bytecode(WASMModuleInstance *module, @@ -924,2542 +966,2764 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module, WASMFunctionInstance *cur_func, WASMInterpFrame *prev_frame) { - WASMMemoryInstance *memory = module->default_memory; - uint32 num_bytes_per_page = memory ? memory->num_bytes_per_page : 0; - uint8 *global_data = module->global_data; - uint32 linear_mem_size = memory ? num_bytes_per_page * memory->cur_page_count : 0; - WASMType **wasm_types = module->module->types; - WASMGlobalInstance *globals = module->globals, *global; - uint8 opcode_IMPDEP = WASM_OP_IMPDEP; - WASMInterpFrame *frame = NULL; - /* Points to this special opcode so as to jump to the call_method_from_entry. */ - register uint8 *frame_ip = &opcode_IMPDEP; /* cache of frame->ip */ - register uint32 *frame_lp = NULL; /* cache of frame->lp */ - register uint32 *frame_sp = NULL; /* cache of frame->sp */ - WASMBranchBlock *frame_csp = NULL; - BlockAddr *cache_items; - uint8 *frame_ip_end = frame_ip + 1; - uint8 opcode; - uint32 i, depth, cond, count, fidx, tidx, lidx, frame_size = 0; - uint64 all_cell_num = 0; - int32 val; - uint8 *else_addr, *end_addr, *maddr = NULL; - uint32 local_idx, local_offset, global_idx; - uint8 local_type, *global_addr; - uint32 cache_index, type_index, cell_num; - uint8 value_type; + WASMMemoryInstance *memory = module->default_memory; + uint32 num_bytes_per_page = memory ? memory->num_bytes_per_page : 0; + uint8 *global_data = module->global_data; + uint32 linear_mem_size = + memory ? num_bytes_per_page * memory->cur_page_count : 0; + WASMType **wasm_types = module->module->types; + WASMGlobalInstance *globals = module->globals, *global; + uint8 opcode_IMPDEP = WASM_OP_IMPDEP; + WASMInterpFrame *frame = NULL; + /* Points to this special opcode so as to jump to the + * call_method_from_entry. */ + register uint8 *frame_ip = &opcode_IMPDEP; /* cache of frame->ip */ + register uint32 *frame_lp = NULL; /* cache of frame->lp */ + register uint32 *frame_sp = NULL; /* cache of frame->sp */ + WASMBranchBlock *frame_csp = NULL; + BlockAddr *cache_items; + uint8 *frame_ip_end = frame_ip + 1; + uint8 opcode; + uint32 i, depth, cond, count, fidx, tidx, lidx, frame_size = 0; + uint64 all_cell_num = 0; + int32 val; + uint8 *else_addr, *end_addr, *maddr = NULL; + uint32 local_idx, local_offset, global_idx; + uint8 local_type, *global_addr; + uint32 cache_index, type_index, cell_num; + uint8 value_type; #if WASM_ENABLE_LABELS_AS_VALUES != 0 - #define HANDLE_OPCODE(op) &&HANDLE_##op - DEFINE_GOTO_TABLE (const void *, handle_table); - #undef HANDLE_OPCODE +#define HANDLE_OPCODE(op) &&HANDLE_##op + DEFINE_GOTO_TABLE(const void *, handle_table); +#undef HANDLE_OPCODE #endif #if WASM_ENABLE_LABELS_AS_VALUES == 0 - while (frame_ip < frame_ip_end) { - opcode = *frame_ip++; - switch (opcode) { + while (frame_ip < frame_ip_end) { + opcode = *frame_ip++; + switch (opcode) { #else - FETCH_OPCODE_AND_DISPATCH (); + FETCH_OPCODE_AND_DISPATCH(); #endif - /* control instructions */ - HANDLE_OP (WASM_OP_UNREACHABLE): - wasm_set_exception(module, "unreachable"); - goto got_exception; + /* control instructions */ + HANDLE_OP(WASM_OP_UNREACHABLE) + { + wasm_set_exception(module, "unreachable"); + goto got_exception; + } - HANDLE_OP (WASM_OP_NOP): - HANDLE_OP_END (); + HANDLE_OP(WASM_OP_NOP) { HANDLE_OP_END(); } - HANDLE_OP (EXT_OP_BLOCK): - read_leb_uint32(frame_ip, frame_ip_end, type_index); - cell_num = wasm_types[type_index]->ret_cell_num; - goto handle_op_block; + HANDLE_OP(EXT_OP_BLOCK) + { + read_leb_uint32(frame_ip, frame_ip_end, type_index); + cell_num = wasm_types[type_index]->ret_cell_num; + goto handle_op_block; + } - HANDLE_OP (WASM_OP_BLOCK): - value_type = *frame_ip++; - cell_num = wasm_value_type_cell_num(value_type); -handle_op_block: - cache_index = ((uintptr_t)frame_ip) & (uintptr_t)(BLOCK_ADDR_CACHE_SIZE - 1); - cache_items = exec_env->block_addr_cache[cache_index]; - if (cache_items[0].start_addr == frame_ip) { - end_addr = cache_items[0].end_addr; - } - else if (cache_items[1].start_addr == frame_ip) { - end_addr = cache_items[1].end_addr; - } + HANDLE_OP(WASM_OP_BLOCK) + { + value_type = *frame_ip++; + cell_num = wasm_value_type_cell_num(value_type); + handle_op_block: + cache_index = ((uintptr_t)frame_ip) + & (uintptr_t)(BLOCK_ADDR_CACHE_SIZE - 1); + cache_items = exec_env->block_addr_cache[cache_index]; + if (cache_items[0].start_addr == frame_ip) { + end_addr = cache_items[0].end_addr; + } + else if (cache_items[1].start_addr == frame_ip) { + end_addr = cache_items[1].end_addr; + } #if WASM_ENABLE_DEBUG_INTERP != 0 - else if (!wasm_loader_find_block_addr(exec_env, - (BlockAddr*)exec_env->block_addr_cache, - frame_ip, (uint8*)-1, - LABEL_TYPE_BLOCK, - &else_addr, &end_addr)) { - wasm_set_exception(module, "find block address failed"); - goto got_exception; - } + else if (!wasm_loader_find_block_addr( + exec_env, (BlockAddr *)exec_env->block_addr_cache, + frame_ip, (uint8 *)-1, LABEL_TYPE_BLOCK, + &else_addr, &end_addr)) { + wasm_set_exception(module, "find block address failed"); + goto got_exception; + } #endif - else { - end_addr = NULL; - } - PUSH_CSP(LABEL_TYPE_BLOCK, cell_num, end_addr); - HANDLE_OP_END (); + else { + end_addr = NULL; + } + PUSH_CSP(LABEL_TYPE_BLOCK, cell_num, end_addr); + HANDLE_OP_END(); + } - HANDLE_OP (EXT_OP_LOOP): - read_leb_uint32(frame_ip, frame_ip_end, type_index); - cell_num = wasm_types[type_index]->param_cell_num; - goto handle_op_loop; + HANDLE_OP(EXT_OP_LOOP) + { + read_leb_uint32(frame_ip, frame_ip_end, type_index); + cell_num = wasm_types[type_index]->param_cell_num; + goto handle_op_loop; + } - HANDLE_OP (WASM_OP_LOOP): - value_type = *frame_ip++; - cell_num = wasm_value_type_cell_num(value_type); -handle_op_loop: - PUSH_CSP(LABEL_TYPE_LOOP, cell_num, frame_ip); - HANDLE_OP_END (); + HANDLE_OP(WASM_OP_LOOP) + { + value_type = *frame_ip++; + cell_num = wasm_value_type_cell_num(value_type); + handle_op_loop: + PUSH_CSP(LABEL_TYPE_LOOP, cell_num, frame_ip); + HANDLE_OP_END(); + } - HANDLE_OP (EXT_OP_IF): - read_leb_uint32(frame_ip, frame_ip_end, type_index); - cell_num = wasm_types[type_index]->ret_cell_num; - goto handle_op_if; + HANDLE_OP(EXT_OP_IF) + { + read_leb_uint32(frame_ip, frame_ip_end, type_index); + cell_num = wasm_types[type_index]->ret_cell_num; + goto handle_op_if; + } - HANDLE_OP (WASM_OP_IF): - value_type = *frame_ip++; - cell_num = wasm_value_type_cell_num(value_type); -handle_op_if: - cache_index = ((uintptr_t)frame_ip) & (uintptr_t)(BLOCK_ADDR_CACHE_SIZE - 1); - cache_items = exec_env->block_addr_cache[cache_index]; - if (cache_items[0].start_addr == frame_ip) { - else_addr = cache_items[0].else_addr; - end_addr = cache_items[0].end_addr; - } - else if (cache_items[1].start_addr == frame_ip) { - else_addr = cache_items[1].else_addr; - end_addr = cache_items[1].end_addr; - } - else if (!wasm_loader_find_block_addr(exec_env, - (BlockAddr*)exec_env->block_addr_cache, - frame_ip, (uint8*)-1, - LABEL_TYPE_IF, - &else_addr, &end_addr)) { - wasm_set_exception(module, "find block address failed"); - goto got_exception; - } + HANDLE_OP(WASM_OP_IF) + { + value_type = *frame_ip++; + cell_num = wasm_value_type_cell_num(value_type); + handle_op_if: + cache_index = ((uintptr_t)frame_ip) + & (uintptr_t)(BLOCK_ADDR_CACHE_SIZE - 1); + cache_items = exec_env->block_addr_cache[cache_index]; + if (cache_items[0].start_addr == frame_ip) { + else_addr = cache_items[0].else_addr; + end_addr = cache_items[0].end_addr; + } + else if (cache_items[1].start_addr == frame_ip) { + else_addr = cache_items[1].else_addr; + end_addr = cache_items[1].end_addr; + } + else if (!wasm_loader_find_block_addr( + exec_env, (BlockAddr *)exec_env->block_addr_cache, + frame_ip, (uint8 *)-1, LABEL_TYPE_IF, &else_addr, + &end_addr)) { + wasm_set_exception(module, "find block address failed"); + goto got_exception; + } - cond = (uint32)POP_I32(); + cond = (uint32)POP_I32(); - if (cond) { /* if branch is met */ - PUSH_CSP(LABEL_TYPE_IF, cell_num, end_addr); - } - else { /* if branch is not met */ - /* if there is no else branch, go to the end addr */ - if (else_addr == NULL) { - frame_ip = end_addr + 1; - } - /* if there is an else branch, go to the else addr */ - else { - PUSH_CSP(LABEL_TYPE_IF, cell_num, end_addr); - frame_ip = else_addr + 1; - } - } - HANDLE_OP_END (); + if (cond) { /* if branch is met */ + PUSH_CSP(LABEL_TYPE_IF, cell_num, end_addr); + } + else { /* if branch is not met */ + /* if there is no else branch, go to the end addr */ + if (else_addr == NULL) { + frame_ip = end_addr + 1; + } + /* if there is an else branch, go to the else addr */ + else { + PUSH_CSP(LABEL_TYPE_IF, cell_num, end_addr); + frame_ip = else_addr + 1; + } + } + HANDLE_OP_END(); + } - HANDLE_OP (WASM_OP_ELSE): - /* comes from the if branch in WASM_OP_IF */ - frame_ip = (frame_csp - 1)->target_addr; - HANDLE_OP_END (); + HANDLE_OP(WASM_OP_ELSE) + { + /* comes from the if branch in WASM_OP_IF */ + frame_ip = (frame_csp - 1)->target_addr; + HANDLE_OP_END(); + } - HANDLE_OP (WASM_OP_END): - if (frame_csp > frame->csp_bottom + 1) { - POP_CSP(); - } - else { /* end of function, treat as WASM_OP_RETURN */ - frame_sp -= cur_func->ret_cell_num; - for (i = 0; i < cur_func->ret_cell_num; i++) { - *prev_frame->sp++ = frame_sp[i]; - } - goto return_func; - } - HANDLE_OP_END (); + HANDLE_OP(WASM_OP_END) + { + if (frame_csp > frame->csp_bottom + 1) { + POP_CSP(); + } + else { /* end of function, treat as WASM_OP_RETURN */ + frame_sp -= cur_func->ret_cell_num; + for (i = 0; i < cur_func->ret_cell_num; i++) { + *prev_frame->sp++ = frame_sp[i]; + } + goto return_func; + } + HANDLE_OP_END(); + } - HANDLE_OP (WASM_OP_BR): + HANDLE_OP(WASM_OP_BR) + { #if WASM_ENABLE_THREAD_MGR != 0 - CHECK_SUSPEND_FLAGS(); + CHECK_SUSPEND_FLAGS(); #endif - read_leb_uint32(frame_ip, frame_ip_end, depth); -label_pop_csp_n: - POP_CSP_N(depth); - if (!frame_ip) { /* must be label pushed by WASM_OP_BLOCK */ - if (!wasm_loader_find_block_addr(exec_env, - (BlockAddr*)exec_env->block_addr_cache, - (frame_csp - 1)->begin_addr, (uint8*)-1, - LABEL_TYPE_BLOCK, - &else_addr, &end_addr)) { - wasm_set_exception(module, "find block address failed"); - goto got_exception; - } - frame_ip = end_addr; - } - HANDLE_OP_END (); + read_leb_uint32(frame_ip, frame_ip_end, depth); + label_pop_csp_n: + POP_CSP_N(depth); + if (!frame_ip) { /* must be label pushed by WASM_OP_BLOCK */ + if (!wasm_loader_find_block_addr( + exec_env, (BlockAddr *)exec_env->block_addr_cache, + (frame_csp - 1)->begin_addr, (uint8 *)-1, + LABEL_TYPE_BLOCK, &else_addr, &end_addr)) { + wasm_set_exception(module, "find block address failed"); + goto got_exception; + } + frame_ip = end_addr; + } + HANDLE_OP_END(); + } - HANDLE_OP (WASM_OP_BR_IF): + HANDLE_OP(WASM_OP_BR_IF) + { #if WASM_ENABLE_THREAD_MGR != 0 - CHECK_SUSPEND_FLAGS(); + CHECK_SUSPEND_FLAGS(); #endif - read_leb_uint32(frame_ip, frame_ip_end, depth); - cond = (uint32)POP_I32(); - if (cond) - goto label_pop_csp_n; - HANDLE_OP_END (); + read_leb_uint32(frame_ip, frame_ip_end, depth); + cond = (uint32)POP_I32(); + if (cond) + goto label_pop_csp_n; + HANDLE_OP_END(); + } - HANDLE_OP (WASM_OP_BR_TABLE): + HANDLE_OP(WASM_OP_BR_TABLE) + { #if WASM_ENABLE_THREAD_MGR != 0 - CHECK_SUSPEND_FLAGS(); + CHECK_SUSPEND_FLAGS(); #endif - read_leb_uint32(frame_ip, frame_ip_end, count); - lidx = POP_I32(); - if (lidx > count) - lidx = count; - for (i = 0; i < lidx; i++) - skip_leb(frame_ip); - read_leb_uint32(frame_ip, frame_ip_end, depth); - goto label_pop_csp_n; + read_leb_uint32(frame_ip, frame_ip_end, count); + lidx = POP_I32(); + if (lidx > count) + lidx = count; + for (i = 0; i < lidx; i++) + skip_leb(frame_ip); + read_leb_uint32(frame_ip, frame_ip_end, depth); + goto label_pop_csp_n; + } - HANDLE_OP (WASM_OP_RETURN): - frame_sp -= cur_func->ret_cell_num; - for (i = 0; i < cur_func->ret_cell_num; i++) { - *prev_frame->sp++ = frame_sp[i]; - } - goto return_func; + HANDLE_OP(WASM_OP_RETURN) + { + frame_sp -= cur_func->ret_cell_num; + for (i = 0; i < cur_func->ret_cell_num; i++) { + *prev_frame->sp++ = frame_sp[i]; + } + goto return_func; + } - HANDLE_OP (WASM_OP_CALL): + HANDLE_OP(WASM_OP_CALL) + { #if WASM_ENABLE_THREAD_MGR != 0 - CHECK_SUSPEND_FLAGS(); + CHECK_SUSPEND_FLAGS(); #endif - read_leb_uint32(frame_ip, frame_ip_end, fidx); + read_leb_uint32(frame_ip, frame_ip_end, fidx); #if WASM_ENABLE_MULTI_MODULE != 0 - if (fidx >= module->function_count) { - wasm_set_exception(module, "unknown function"); - goto got_exception; - } + if (fidx >= module->function_count) { + wasm_set_exception(module, "unknown function"); + goto got_exception; + } #endif - cur_func = module->functions + fidx; - goto call_func_from_interp; + cur_func = module->functions + fidx; + goto call_func_from_interp; + } #if WASM_ENABLE_TAIL_CALL != 0 - HANDLE_OP (WASM_OP_RETURN_CALL): + HANDLE_OP(WASM_OP_RETURN_CALL) + { #if WASM_ENABLE_THREAD_MGR != 0 - CHECK_SUSPEND_FLAGS(); + CHECK_SUSPEND_FLAGS(); #endif - read_leb_uint32(frame_ip, frame_ip_end, fidx); + read_leb_uint32(frame_ip, frame_ip_end, fidx); #if WASM_ENABLE_MULTI_MODULE != 0 - if (fidx >= module->function_count) { - wasm_set_exception(module, "unknown function"); - goto got_exception; - } + if (fidx >= module->function_count) { + wasm_set_exception(module, "unknown function"); + goto got_exception; + } #endif - cur_func = module->functions + fidx; + cur_func = module->functions + fidx; - goto call_func_from_return_call; + goto call_func_from_return_call; + } #endif /* WASM_ENABLE_TAIL_CALL */ - HANDLE_OP (WASM_OP_CALL_INDIRECT): + HANDLE_OP(WASM_OP_CALL_INDIRECT) #if WASM_ENABLE_TAIL_CALL != 0 - HANDLE_OP (WASM_OP_RETURN_CALL_INDIRECT): + HANDLE_OP(WASM_OP_RETURN_CALL_INDIRECT) #endif - { - WASMType *cur_type, *cur_func_type; - WASMTableInstance *tbl_inst; - uint32 tbl_idx; + { + WASMType *cur_type, *cur_func_type; + WASMTableInstance *tbl_inst; + uint32 tbl_idx; #if WASM_ENABLE_TAIL_CALL != 0 - opcode = *(frame_ip - 1); + opcode = *(frame_ip - 1); #endif #if WASM_ENABLE_THREAD_MGR != 0 - CHECK_SUSPEND_FLAGS(); + CHECK_SUSPEND_FLAGS(); #endif - /** - * type check. compiler will make sure all like - * (call_indirect (type $x) (i32.const 1)) - * the function type has to be defined in the module also - * no matter it is used or not - */ - read_leb_uint32(frame_ip, frame_ip_end, tidx); - bh_assert(tidx < module->module->type_count); - cur_type = wasm_types[tidx]; + /** + * type check. compiler will make sure all like + * (call_indirect (type $x) (i32.const 1)) + * the function type has to be defined in the module also + * no matter it is used or not + */ + read_leb_uint32(frame_ip, frame_ip_end, tidx); + bh_assert(tidx < module->module->type_count); + cur_type = wasm_types[tidx]; - read_leb_uint32(frame_ip, frame_ip_end, tbl_idx); - bh_assert(tbl_idx < module->table_count); + read_leb_uint32(frame_ip, frame_ip_end, tbl_idx); + bh_assert(tbl_idx < module->table_count); - tbl_inst = wasm_get_table_inst(module, tbl_idx); + tbl_inst = wasm_get_table_inst(module, tbl_idx); - val = POP_I32(); - if (val < 0 || val >= (int32)tbl_inst->cur_size) { - wasm_set_exception(module, "undefined element"); - goto got_exception; - } + val = POP_I32(); + if (val < 0 || val >= (int32)tbl_inst->cur_size) { + wasm_set_exception(module, "undefined element"); + goto got_exception; + } - fidx = ((uint32*)tbl_inst->base_addr)[val]; - if (fidx == (uint32)-1) { - wasm_set_exception(module, "uninitialized element"); - goto got_exception; - } + fidx = ((uint32 *)tbl_inst->base_addr)[val]; + if (fidx == (uint32)-1) { + wasm_set_exception(module, "uninitialized element"); + goto got_exception; + } - /* - * we might be using a table injected by host or - * another module. In that case, we don't validate - * the elem value while loading - */ - if (fidx >= module->function_count) { - wasm_set_exception(module, "unknown function"); - goto got_exception; - } + /* + * we might be using a table injected by host or + * another module. In that case, we don't validate + * the elem value while loading + */ + if (fidx >= module->function_count) { + wasm_set_exception(module, "unknown function"); + goto got_exception; + } - /* always call module own functions */ - cur_func = module->functions + fidx; + /* always call module own functions */ + cur_func = module->functions + fidx; - if (cur_func->is_import_func) - cur_func_type = cur_func->u.func_import->func_type; - else - cur_func_type = cur_func->u.func->func_type; - if (!wasm_type_equal(cur_type, cur_func_type)) { - wasm_set_exception(module, "indirect call type mismatch"); - goto got_exception; - } + if (cur_func->is_import_func) + cur_func_type = cur_func->u.func_import->func_type; + else + cur_func_type = cur_func->u.func->func_type; + if (!wasm_type_equal(cur_type, cur_func_type)) { + wasm_set_exception(module, "indirect call type mismatch"); + goto got_exception; + } #if WASM_ENABLE_TAIL_CALL != 0 - if (opcode == WASM_OP_RETURN_CALL_INDIRECT) - goto call_func_from_return_call; + if (opcode == WASM_OP_RETURN_CALL_INDIRECT) + goto call_func_from_return_call; #endif - goto call_func_from_interp; - } + goto call_func_from_interp; + } - /* parametric instructions */ - HANDLE_OP (WASM_OP_DROP): - { - frame_sp--; - HANDLE_OP_END (); - } + /* parametric instructions */ + HANDLE_OP(WASM_OP_DROP) + { + frame_sp--; + HANDLE_OP_END(); + } - HANDLE_OP (WASM_OP_DROP_64): - { - frame_sp -= 2; - HANDLE_OP_END (); - } + HANDLE_OP(WASM_OP_DROP_64) + { + frame_sp -= 2; + HANDLE_OP_END(); + } - HANDLE_OP (WASM_OP_SELECT): - { - cond = (uint32)POP_I32(); - frame_sp--; - if (!cond) - *(frame_sp - 1) = *frame_sp; - HANDLE_OP_END (); - } + HANDLE_OP(WASM_OP_SELECT) + { + cond = (uint32)POP_I32(); + frame_sp--; + if (!cond) + *(frame_sp - 1) = *frame_sp; + HANDLE_OP_END(); + } - HANDLE_OP (WASM_OP_SELECT_64): - { - cond = (uint32)POP_I32(); - frame_sp -= 2; - if (!cond) { - *(frame_sp - 2) = *frame_sp; - *(frame_sp - 1) = *(frame_sp + 1); - } - HANDLE_OP_END (); - } + HANDLE_OP(WASM_OP_SELECT_64) + { + cond = (uint32)POP_I32(); + frame_sp -= 2; + if (!cond) { + *(frame_sp - 2) = *frame_sp; + *(frame_sp - 1) = *(frame_sp + 1); + } + HANDLE_OP_END(); + } #if WASM_ENABLE_REF_TYPES != 0 - HANDLE_OP (WASM_OP_SELECT_T): - { - uint32 vec_len; - uint8 type; + HANDLE_OP(WASM_OP_SELECT_T) + { + uint32 vec_len; + uint8 type; - read_leb_uint32(frame_ip, frame_ip_end, vec_len); - type = *frame_ip++; + read_leb_uint32(frame_ip, frame_ip_end, vec_len); + type = *frame_ip++; - cond = (uint32)POP_I32(); - if (type == VALUE_TYPE_I64 || type == VALUE_TYPE_F64) { - frame_sp -= 2; - if (!cond) { - *(frame_sp - 2) = *frame_sp; - *(frame_sp - 1) = *(frame_sp + 1); + cond = (uint32)POP_I32(); + if (type == VALUE_TYPE_I64 || type == VALUE_TYPE_F64) { + frame_sp -= 2; + if (!cond) { + *(frame_sp - 2) = *frame_sp; + *(frame_sp - 1) = *(frame_sp + 1); + } + } + else { + frame_sp--; + if (!cond) + *(frame_sp - 1) = *frame_sp; + } + + (void)vec_len; + HANDLE_OP_END(); } - } - else { - frame_sp--; - if (!cond) - *(frame_sp - 1) = *frame_sp; - } + HANDLE_OP(WASM_OP_TABLE_GET) + { + uint32 tbl_idx, elem_idx; + WASMTableInstance *tbl_inst; - (void)vec_len; - HANDLE_OP_END (); - } - HANDLE_OP (WASM_OP_TABLE_GET): - { - uint32 tbl_idx, elem_idx; - WASMTableInstance *tbl_inst; + read_leb_uint32(frame_ip, frame_ip_end, tbl_idx); + bh_assert(tbl_idx < module->table_count); - read_leb_uint32(frame_ip, frame_ip_end, tbl_idx); - bh_assert(tbl_idx < module->table_count); + tbl_inst = wasm_get_table_inst(module, tbl_idx); - tbl_inst = wasm_get_table_inst(module, tbl_idx); + elem_idx = POP_I32(); + if (elem_idx >= tbl_inst->cur_size) { + wasm_set_exception(module, "out of bounds table access"); + goto got_exception; + } - elem_idx = POP_I32(); - if (elem_idx >= tbl_inst->cur_size) { - wasm_set_exception(module, "out of bounds table access"); - goto got_exception; - } + PUSH_I32(((uint32 *)tbl_inst->base_addr)[elem_idx]); + HANDLE_OP_END(); + } - PUSH_I32(((uint32 *)tbl_inst->base_addr)[elem_idx]); - HANDLE_OP_END (); - } + HANDLE_OP(WASM_OP_TABLE_SET) + { + uint32 tbl_idx, elem_idx, val; + WASMTableInstance *tbl_inst; - HANDLE_OP (WASM_OP_TABLE_SET): - { - uint32 tbl_idx, elem_idx, val; - WASMTableInstance *tbl_inst; + read_leb_uint32(frame_ip, frame_ip_end, tbl_idx); + bh_assert(tbl_idx < module->table_count); - read_leb_uint32(frame_ip, frame_ip_end, tbl_idx); - bh_assert(tbl_idx < module->table_count); + tbl_inst = wasm_get_table_inst(module, tbl_idx); - tbl_inst = wasm_get_table_inst(module, tbl_idx); + val = POP_I32(); + elem_idx = POP_I32(); + if (elem_idx >= tbl_inst->cur_size) { + wasm_set_exception(module, "out of bounds table access"); + goto got_exception; + } - val = POP_I32(); - elem_idx = POP_I32(); - if (elem_idx >= tbl_inst->cur_size) { - wasm_set_exception(module, "out of bounds table access"); - goto got_exception; - } + ((uint32 *)(tbl_inst->base_addr))[elem_idx] = val; + HANDLE_OP_END(); + } - ((uint32 *)(tbl_inst->base_addr))[elem_idx] = val; - HANDLE_OP_END(); - } + HANDLE_OP(WASM_OP_REF_NULL) + { + uint32 ref_type; + read_leb_uint32(frame_ip, frame_ip_end, ref_type); + PUSH_I32(NULL_REF); + (void)ref_type; + HANDLE_OP_END(); + } - HANDLE_OP (WASM_OP_REF_NULL): - { - uint32 ref_type; - read_leb_uint32(frame_ip, frame_ip_end, ref_type); - PUSH_I32(NULL_REF); - (void)ref_type; - HANDLE_OP_END(); - } + HANDLE_OP(WASM_OP_REF_IS_NULL) + { + uint32 val; + val = POP_I32(); + PUSH_I32(val == NULL_REF ? 1 : 0); + HANDLE_OP_END(); + } - HANDLE_OP (WASM_OP_REF_IS_NULL): - { - uint32 val; - val = POP_I32(); - PUSH_I32(val == NULL_REF ? 1 : 0); - HANDLE_OP_END(); - } - - HANDLE_OP (WASM_OP_REF_FUNC): - { - uint32 func_idx; - read_leb_uint32(frame_ip, frame_ip_end, func_idx); - PUSH_I32(func_idx); - HANDLE_OP_END(); - } + HANDLE_OP(WASM_OP_REF_FUNC) + { + uint32 func_idx; + read_leb_uint32(frame_ip, frame_ip_end, func_idx); + PUSH_I32(func_idx); + HANDLE_OP_END(); + } #endif /* WASM_ENABLE_REF_TYPES */ - /* variable instructions */ - HANDLE_OP (WASM_OP_GET_LOCAL): - { - GET_LOCAL_INDEX_TYPE_AND_OFFSET(); + /* variable instructions */ + HANDLE_OP(WASM_OP_GET_LOCAL) + { + GET_LOCAL_INDEX_TYPE_AND_OFFSET(); - switch (local_type) { - case VALUE_TYPE_I32: - case VALUE_TYPE_F32: + switch (local_type) { + case VALUE_TYPE_I32: + case VALUE_TYPE_F32: #if WASM_ENABLE_REF_TYPES != 0 - case VALUE_TYPE_FUNCREF: - case VALUE_TYPE_EXTERNREF: + case VALUE_TYPE_FUNCREF: + case VALUE_TYPE_EXTERNREF: #endif - PUSH_I32(*(int32*)(frame_lp + local_offset)); - break; - case VALUE_TYPE_I64: - case VALUE_TYPE_F64: - PUSH_I64(GET_I64_FROM_ADDR(frame_lp + local_offset)); - break; - default: - wasm_set_exception(module, "invalid local type"); - goto got_exception; - } + PUSH_I32(*(int32 *)(frame_lp + local_offset)); + break; + case VALUE_TYPE_I64: + case VALUE_TYPE_F64: + PUSH_I64(GET_I64_FROM_ADDR(frame_lp + local_offset)); + break; + default: + wasm_set_exception(module, "invalid local type"); + goto got_exception; + } - HANDLE_OP_END (); - } + HANDLE_OP_END(); + } - HANDLE_OP (EXT_OP_GET_LOCAL_FAST): - { - local_offset = *frame_ip++; - if (local_offset & 0x80) - PUSH_I64(GET_I64_FROM_ADDR(frame_lp + (local_offset & 0x7F))); - else - PUSH_I32(*(int32*)(frame_lp + local_offset)); - HANDLE_OP_END (); - } + HANDLE_OP(EXT_OP_GET_LOCAL_FAST) + { + local_offset = *frame_ip++; + if (local_offset & 0x80) + PUSH_I64( + GET_I64_FROM_ADDR(frame_lp + (local_offset & 0x7F))); + else + PUSH_I32(*(int32 *)(frame_lp + local_offset)); + HANDLE_OP_END(); + } - HANDLE_OP (WASM_OP_SET_LOCAL): - { - GET_LOCAL_INDEX_TYPE_AND_OFFSET(); + HANDLE_OP(WASM_OP_SET_LOCAL) + { + GET_LOCAL_INDEX_TYPE_AND_OFFSET(); - switch (local_type) { - case VALUE_TYPE_I32: - case VALUE_TYPE_F32: + switch (local_type) { + case VALUE_TYPE_I32: + case VALUE_TYPE_F32: #if WASM_ENABLE_REF_TYPES != 0 - case VALUE_TYPE_FUNCREF: - case VALUE_TYPE_EXTERNREF: + case VALUE_TYPE_FUNCREF: + case VALUE_TYPE_EXTERNREF: #endif - *(int32*)(frame_lp + local_offset) = POP_I32(); - break; - case VALUE_TYPE_I64: - case VALUE_TYPE_F64: - PUT_I64_TO_ADDR((uint32*)(frame_lp + local_offset), POP_I64()); - break; - default: - wasm_set_exception(module, "invalid local type"); - goto got_exception; - } + *(int32 *)(frame_lp + local_offset) = POP_I32(); + break; + case VALUE_TYPE_I64: + case VALUE_TYPE_F64: + PUT_I64_TO_ADDR((uint32 *)(frame_lp + local_offset), + POP_I64()); + break; + default: + wasm_set_exception(module, "invalid local type"); + goto got_exception; + } - HANDLE_OP_END (); - } + HANDLE_OP_END(); + } - HANDLE_OP (EXT_OP_SET_LOCAL_FAST): - { - local_offset = *frame_ip++; - if (local_offset & 0x80) - PUT_I64_TO_ADDR((uint32*)(frame_lp + (local_offset & 0x7F)), POP_I64()); - else - *(int32*)(frame_lp + local_offset) = POP_I32(); - HANDLE_OP_END (); - } + HANDLE_OP(EXT_OP_SET_LOCAL_FAST) + { + local_offset = *frame_ip++; + if (local_offset & 0x80) + PUT_I64_TO_ADDR( + (uint32 *)(frame_lp + (local_offset & 0x7F)), + POP_I64()); + else + *(int32 *)(frame_lp + local_offset) = POP_I32(); + HANDLE_OP_END(); + } - HANDLE_OP (WASM_OP_TEE_LOCAL): - { - GET_LOCAL_INDEX_TYPE_AND_OFFSET(); + HANDLE_OP(WASM_OP_TEE_LOCAL) + { + GET_LOCAL_INDEX_TYPE_AND_OFFSET(); - switch (local_type) { - case VALUE_TYPE_I32: - case VALUE_TYPE_F32: + switch (local_type) { + case VALUE_TYPE_I32: + case VALUE_TYPE_F32: #if WASM_ENABLE_REF_TYPES != 0 - case VALUE_TYPE_FUNCREF: - case VALUE_TYPE_EXTERNREF: + case VALUE_TYPE_FUNCREF: + case VALUE_TYPE_EXTERNREF: #endif - *(int32*)(frame_lp + local_offset) = *(int32*)(frame_sp - 1); - break; - case VALUE_TYPE_I64: - case VALUE_TYPE_F64: - PUT_I64_TO_ADDR((uint32*)(frame_lp + local_offset), - GET_I64_FROM_ADDR(frame_sp - 2)); - break; - default: - wasm_set_exception(module, "invalid local type"); - goto got_exception; - } + *(int32 *)(frame_lp + local_offset) = + *(int32 *)(frame_sp - 1); + break; + case VALUE_TYPE_I64: + case VALUE_TYPE_F64: + PUT_I64_TO_ADDR((uint32 *)(frame_lp + local_offset), + GET_I64_FROM_ADDR(frame_sp - 2)); + break; + default: + wasm_set_exception(module, "invalid local type"); + goto got_exception; + } - HANDLE_OP_END (); - } + HANDLE_OP_END(); + } - HANDLE_OP (EXT_OP_TEE_LOCAL_FAST): - { - local_offset = *frame_ip++; - if (local_offset & 0x80) - PUT_I64_TO_ADDR((uint32*)(frame_lp + (local_offset & 0x7F)), - GET_I64_FROM_ADDR(frame_sp - 2)); - else - *(int32*)(frame_lp + local_offset) = *(int32*)(frame_sp - 1); - HANDLE_OP_END (); - } + HANDLE_OP(EXT_OP_TEE_LOCAL_FAST) + { + local_offset = *frame_ip++; + if (local_offset & 0x80) + PUT_I64_TO_ADDR( + (uint32 *)(frame_lp + (local_offset & 0x7F)), + GET_I64_FROM_ADDR(frame_sp - 2)); + else + *(int32 *)(frame_lp + local_offset) = + *(int32 *)(frame_sp - 1); + HANDLE_OP_END(); + } - HANDLE_OP (WASM_OP_GET_GLOBAL): - { - read_leb_uint32(frame_ip, frame_ip_end, global_idx); - bh_assert(global_idx < module->global_count); - global = globals + global_idx; -#if WASM_ENABLE_MULTI_MODULE == 0 - global_addr = global_data + global->data_offset; -#else - global_addr = global->import_global_inst - ? global->import_module_inst->global_data - + global->import_global_inst->data_offset - : global_data + global->data_offset; -#endif - PUSH_I32(*(uint32*)global_addr); - HANDLE_OP_END (); - } + HANDLE_OP(WASM_OP_GET_GLOBAL) + { + read_leb_uint32(frame_ip, frame_ip_end, global_idx); + bh_assert(global_idx < module->global_count); + global = globals + global_idx; + global_addr = get_global_addr(global_data, global); + PUSH_I32(*(uint32 *)global_addr); + HANDLE_OP_END(); + } - HANDLE_OP (WASM_OP_GET_GLOBAL_64): - { - read_leb_uint32(frame_ip, frame_ip_end, global_idx); - bh_assert(global_idx < module->global_count); - global = globals + global_idx; -#if WASM_ENABLE_MULTI_MODULE == 0 - global_addr = global_data + global->data_offset; -#else - global_addr = global->import_global_inst - ? global->import_module_inst->global_data - + global->import_global_inst->data_offset - : global_data + global->data_offset; -#endif - PUSH_I64(GET_I64_FROM_ADDR((uint32*)global_addr)); - HANDLE_OP_END (); - } + HANDLE_OP(WASM_OP_GET_GLOBAL_64) + { + read_leb_uint32(frame_ip, frame_ip_end, global_idx); + bh_assert(global_idx < module->global_count); + global = globals + global_idx; + global_addr = get_global_addr(global_data, global); + PUSH_I64(GET_I64_FROM_ADDR((uint32 *)global_addr)); + HANDLE_OP_END(); + } - HANDLE_OP (WASM_OP_SET_GLOBAL): - { - read_leb_uint32(frame_ip, frame_ip_end, global_idx); - bh_assert(global_idx < module->global_count); - global = globals + global_idx; -#if WASM_ENABLE_MULTI_MODULE == 0 - global_addr = global_data + global->data_offset; -#else - global_addr = global->import_global_inst - ? global->import_module_inst->global_data - + global->import_global_inst->data_offset - : global_data + global->data_offset; -#endif - *(int32*)global_addr = POP_I32(); - HANDLE_OP_END (); - } + HANDLE_OP(WASM_OP_SET_GLOBAL) + { + read_leb_uint32(frame_ip, frame_ip_end, global_idx); + bh_assert(global_idx < module->global_count); + global = globals + global_idx; + global_addr = get_global_addr(global_data, global); + *(int32 *)global_addr = POP_I32(); + HANDLE_OP_END(); + } - HANDLE_OP (WASM_OP_SET_GLOBAL_AUX_STACK): - { - uint32 aux_stack_top; + HANDLE_OP(WASM_OP_SET_GLOBAL_AUX_STACK) + { + uint32 aux_stack_top; - read_leb_uint32(frame_ip, frame_ip_end, global_idx); - bh_assert(global_idx < module->global_count); - global = globals + global_idx; -#if WASM_ENABLE_MULTI_MODULE == 0 - global_addr = global_data + global->data_offset; -#else - global_addr = global->import_global_inst - ? global->import_module_inst->global_data - + global->import_global_inst->data_offset - : global_data + global->data_offset; -#endif - aux_stack_top = *(uint32*)(frame_sp - 1); - if (aux_stack_top <= exec_env->aux_stack_boundary.boundary) { - wasm_set_exception(module, "wasm auxiliary stack overflow"); - goto got_exception; - } - if (aux_stack_top > exec_env->aux_stack_bottom.bottom) { - wasm_set_exception(module, "wasm auxiliary stack underflow"); - goto got_exception; - } - *(int32*)global_addr = aux_stack_top; - frame_sp--; + read_leb_uint32(frame_ip, frame_ip_end, global_idx); + bh_assert(global_idx < module->global_count); + global = globals + global_idx; + global_addr = get_global_addr(global_data, global); + aux_stack_top = *(uint32 *)(frame_sp - 1); + if (aux_stack_top <= exec_env->aux_stack_boundary.boundary) { + wasm_set_exception(module, "wasm auxiliary stack overflow"); + goto got_exception; + } + if (aux_stack_top > exec_env->aux_stack_bottom.bottom) { + wasm_set_exception(module, + "wasm auxiliary stack underflow"); + goto got_exception; + } + *(int32 *)global_addr = aux_stack_top; + frame_sp--; #if WASM_ENABLE_MEMORY_PROFILING != 0 - if (module->module->aux_stack_top_global_index != (uint32)-1) { - uint32 aux_stack_used = - module->module->aux_stack_bottom - *(uint32*)global_addr; - if (aux_stack_used > module->max_aux_stack_used) - module->max_aux_stack_used = aux_stack_used; - } + if (module->module->aux_stack_top_global_index != (uint32)-1) { + uint32 aux_stack_used = module->module->aux_stack_bottom + - *(uint32 *)global_addr; + if (aux_stack_used > module->max_aux_stack_used) + module->max_aux_stack_used = aux_stack_used; + } #endif - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_SET_GLOBAL_64): - { - read_leb_uint32(frame_ip, frame_ip_end, global_idx); - bh_assert(global_idx < module->global_count); - global = globals + global_idx; -#if WASM_ENABLE_MULTI_MODULE == 0 - global_addr = global_data + global->data_offset; -#else - global_addr = global->import_global_inst - ? global->import_module_inst->global_data - + global->import_global_inst->data_offset - : global_data + global->data_offset; -#endif - PUT_I64_TO_ADDR((uint32*)global_addr, POP_I64()); - HANDLE_OP_END (); - } - - /* memory load instructions */ - HANDLE_OP (WASM_OP_I32_LOAD): - HANDLE_OP (WASM_OP_F32_LOAD): - { - uint32 offset, flags, addr; - - read_leb_uint32(frame_ip, frame_ip_end, flags); - read_leb_uint32(frame_ip, frame_ip_end, offset); - addr = POP_I32(); - CHECK_MEMORY_OVERFLOW(4); - PUSH_I32(LOAD_I32(maddr)); - (void)flags; - HANDLE_OP_END(); - } - - HANDLE_OP (WASM_OP_I64_LOAD): - HANDLE_OP (WASM_OP_F64_LOAD): - { - uint32 offset, flags, addr; - - read_leb_uint32(frame_ip, frame_ip_end, flags); - read_leb_uint32(frame_ip, frame_ip_end, offset); - addr = POP_I32(); - CHECK_MEMORY_OVERFLOW(8); - PUSH_I64(LOAD_I64(maddr)); - (void)flags; - HANDLE_OP_END(); - } - - HANDLE_OP (WASM_OP_I32_LOAD8_S): - { - uint32 offset, flags, addr; - - read_leb_uint32(frame_ip, frame_ip_end, flags); - read_leb_uint32(frame_ip, frame_ip_end, offset); - addr = POP_I32(); - CHECK_MEMORY_OVERFLOW(1); - PUSH_I32(sign_ext_8_32(*(int8*)maddr)); - (void)flags; - HANDLE_OP_END(); - } - - HANDLE_OP (WASM_OP_I32_LOAD8_U): - { - uint32 offset, flags, addr; - - read_leb_uint32(frame_ip, frame_ip_end, flags); - read_leb_uint32(frame_ip, frame_ip_end, offset); - addr = POP_I32(); - CHECK_MEMORY_OVERFLOW(1); - PUSH_I32((uint32)(*(uint8*)maddr)); - (void)flags; - HANDLE_OP_END(); - } - - HANDLE_OP (WASM_OP_I32_LOAD16_S): - { - uint32 offset, flags, addr; - - read_leb_uint32(frame_ip, frame_ip_end, flags); - read_leb_uint32(frame_ip, frame_ip_end, offset); - addr = POP_I32(); - CHECK_MEMORY_OVERFLOW(2); - PUSH_I32(sign_ext_16_32(LOAD_I16(maddr))); - (void)flags; - HANDLE_OP_END(); - } - - HANDLE_OP (WASM_OP_I32_LOAD16_U): - { - uint32 offset, flags, addr; - - read_leb_uint32(frame_ip, frame_ip_end, flags); - read_leb_uint32(frame_ip, frame_ip_end, offset); - addr = POP_I32(); - CHECK_MEMORY_OVERFLOW(2); - PUSH_I32((uint32)(LOAD_U16(maddr))); - (void)flags; - HANDLE_OP_END(); - } - - HANDLE_OP (WASM_OP_I64_LOAD8_S): - { - uint32 offset, flags, addr; - - read_leb_uint32(frame_ip, frame_ip_end, flags); - read_leb_uint32(frame_ip, frame_ip_end, offset); - addr = POP_I32(); - CHECK_MEMORY_OVERFLOW(1); - PUSH_I64(sign_ext_8_64(*(int8*)maddr)); - (void)flags; - HANDLE_OP_END(); - } - - HANDLE_OP (WASM_OP_I64_LOAD8_U): - { - uint32 offset, flags, addr; - - read_leb_uint32(frame_ip, frame_ip_end, flags); - read_leb_uint32(frame_ip, frame_ip_end, offset); - addr = POP_I32(); - CHECK_MEMORY_OVERFLOW(1); - PUSH_I64((uint64)(*(uint8*)maddr)); - (void)flags; - HANDLE_OP_END(); - } - - HANDLE_OP (WASM_OP_I64_LOAD16_S): - { - uint32 offset, flags, addr; - - read_leb_uint32(frame_ip, frame_ip_end, flags); - read_leb_uint32(frame_ip, frame_ip_end, offset); - addr = POP_I32(); - CHECK_MEMORY_OVERFLOW(2); - PUSH_I64(sign_ext_16_64(LOAD_I16(maddr))); - (void)flags; - HANDLE_OP_END(); - } - - HANDLE_OP (WASM_OP_I64_LOAD16_U): - { - uint32 offset, flags, addr; - - read_leb_uint32(frame_ip, frame_ip_end, flags); - read_leb_uint32(frame_ip, frame_ip_end, offset); - addr = POP_I32(); - CHECK_MEMORY_OVERFLOW(2); - PUSH_I64((uint64)(LOAD_U16(maddr))); - (void)flags; - HANDLE_OP_END(); - } - - HANDLE_OP (WASM_OP_I64_LOAD32_S): - { - uint32 offset, flags, addr; - - opcode = *(frame_ip - 1); - read_leb_uint32(frame_ip, frame_ip_end, flags); - read_leb_uint32(frame_ip, frame_ip_end, offset); - addr = POP_I32(); - CHECK_MEMORY_OVERFLOW(4); - PUSH_I64(sign_ext_32_64(LOAD_I32(maddr))); - (void)flags; - HANDLE_OP_END(); - } - - HANDLE_OP (WASM_OP_I64_LOAD32_U): - { - uint32 offset, flags, addr; - - read_leb_uint32(frame_ip, frame_ip_end, flags); - read_leb_uint32(frame_ip, frame_ip_end, offset); - addr = POP_I32(); - CHECK_MEMORY_OVERFLOW(4); - PUSH_I64((uint64)(LOAD_U32(maddr))); - (void)flags; - HANDLE_OP_END(); - } - - /* memory store instructions */ - HANDLE_OP (WASM_OP_I32_STORE): - HANDLE_OP (WASM_OP_F32_STORE): - { - uint32 offset, flags, addr; - - read_leb_uint32(frame_ip, frame_ip_end, flags); - read_leb_uint32(frame_ip, frame_ip_end, offset); - frame_sp--; - addr = POP_I32(); - CHECK_MEMORY_OVERFLOW(4); - STORE_U32(maddr, frame_sp[1]); - (void)flags; - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I64_STORE): - HANDLE_OP (WASM_OP_F64_STORE): - { - uint32 offset, flags, addr; - - read_leb_uint32(frame_ip, frame_ip_end, flags); - read_leb_uint32(frame_ip, frame_ip_end, offset); - frame_sp -= 2; - addr = POP_I32(); - CHECK_MEMORY_OVERFLOW(8); - STORE_U32(maddr, frame_sp[1]); - STORE_U32(maddr + 4, frame_sp[2]); - (void)flags; - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I32_STORE8): - HANDLE_OP (WASM_OP_I32_STORE16): - { - uint32 offset, flags, addr; - uint32 sval; - - opcode = *(frame_ip - 1); - read_leb_uint32(frame_ip, frame_ip_end, flags); - read_leb_uint32(frame_ip, frame_ip_end, offset); - sval = (uint32)POP_I32(); - addr = POP_I32(); - - if (opcode == WASM_OP_I32_STORE8) { - CHECK_MEMORY_OVERFLOW(1); - *(uint8*)maddr = (uint8)sval; - } - else { - CHECK_MEMORY_OVERFLOW(2); - STORE_U16(maddr, (uint16)sval); - } - - (void)flags; - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I64_STORE8): - HANDLE_OP (WASM_OP_I64_STORE16): - HANDLE_OP (WASM_OP_I64_STORE32): - { - uint32 offset, flags, addr; - uint64 sval; - - opcode = *(frame_ip - 1); - read_leb_uint32(frame_ip, frame_ip_end, flags); - read_leb_uint32(frame_ip, frame_ip_end, offset); - sval = (uint64)POP_I64(); - addr = POP_I32(); - - if (opcode == WASM_OP_I64_STORE8) { - CHECK_MEMORY_OVERFLOW(1); - *(uint8*)maddr = (uint8)sval; - } - else if(opcode == WASM_OP_I64_STORE16) { - CHECK_MEMORY_OVERFLOW(2); - STORE_U16(maddr, (uint16)sval); - } - else { - CHECK_MEMORY_OVERFLOW(4); - STORE_U32(maddr, (uint32)sval); - } - (void)flags; - HANDLE_OP_END (); - } - - /* memory size and memory grow instructions */ - HANDLE_OP (WASM_OP_MEMORY_SIZE): - { - uint32 reserved; - read_leb_uint32(frame_ip, frame_ip_end, reserved); - PUSH_I32(memory->cur_page_count); - (void)reserved; - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_MEMORY_GROW): - { - uint32 reserved, delta, prev_page_count = memory->cur_page_count; - - read_leb_uint32(frame_ip, frame_ip_end, reserved); - delta = (uint32)POP_I32(); - - if (!wasm_enlarge_memory(module, delta)) { - /* failed to memory.grow, return -1 */ - PUSH_I32(-1); - } - else { - /* success, return previous page count */ - PUSH_I32(prev_page_count); - /* update memory instance ptr and memory size */ - memory = module->default_memory; - linear_mem_size = num_bytes_per_page * memory->cur_page_count; - } - - (void)reserved; - HANDLE_OP_END (); - } - - /* constant instructions */ - HANDLE_OP (WASM_OP_I32_CONST): - DEF_OP_I_CONST(int32, I32); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_CONST): - DEF_OP_I_CONST(int64, I64); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_CONST): - { - uint8 *p_float = (uint8*)frame_sp++; - for (i = 0; i < sizeof(float32); i++) - *p_float++ = *frame_ip++; - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_F64_CONST): - { - uint8 *p_float = (uint8*)frame_sp++; - frame_sp++; - for (i = 0; i < sizeof(float64); i++) - *p_float++ = *frame_ip++; - HANDLE_OP_END (); - } - - /* comparison instructions of i32 */ - HANDLE_OP (WASM_OP_I32_EQZ): - DEF_OP_EQZ(I32); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_EQ): - DEF_OP_CMP(uint32, I32, ==); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_NE): - DEF_OP_CMP(uint32, I32, !=); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_LT_S): - DEF_OP_CMP(int32, I32, <); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_LT_U): - DEF_OP_CMP(uint32, I32, <); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_GT_S): - DEF_OP_CMP(int32, I32, >); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_GT_U): - DEF_OP_CMP(uint32, I32, >); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_LE_S): - DEF_OP_CMP(int32, I32, <=); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_LE_U): - DEF_OP_CMP(uint32, I32, <=); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_GE_S): - DEF_OP_CMP(int32, I32, >=); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_GE_U): - DEF_OP_CMP(uint32, I32, >=); - HANDLE_OP_END (); - - /* comparison instructions of i64 */ - HANDLE_OP (WASM_OP_I64_EQZ): - DEF_OP_EQZ(I64); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_EQ): - DEF_OP_CMP(uint64, I64, ==); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_NE): - DEF_OP_CMP(uint64, I64, !=); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_LT_S): - DEF_OP_CMP(int64, I64, <); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_LT_U): - DEF_OP_CMP(uint64, I64, <); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_GT_S): - DEF_OP_CMP(int64, I64, >); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_GT_U): - DEF_OP_CMP(uint64, I64, >); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_LE_S): - DEF_OP_CMP(int64, I64, <=); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_LE_U): - DEF_OP_CMP(uint64, I64, <=); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_GE_S): - DEF_OP_CMP(int64, I64, >=); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_GE_U): - DEF_OP_CMP(uint64, I64, >=); - HANDLE_OP_END (); - - /* comparison instructions of f32 */ - HANDLE_OP (WASM_OP_F32_EQ): - DEF_OP_CMP(float32, F32, ==); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_NE): - DEF_OP_CMP(float32, F32, !=); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_LT): - DEF_OP_CMP(float32, F32, <); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_GT): - DEF_OP_CMP(float32, F32, >); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_LE): - DEF_OP_CMP(float32, F32, <=); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_GE): - DEF_OP_CMP(float32, F32, >=); - HANDLE_OP_END (); - - /* comparison instructions of f64 */ - HANDLE_OP (WASM_OP_F64_EQ): - DEF_OP_CMP(float64, F64, ==); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_NE): - DEF_OP_CMP(float64, F64, !=); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_LT): - DEF_OP_CMP(float64, F64, <); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_GT): - DEF_OP_CMP(float64, F64, >); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_LE): - DEF_OP_CMP(float64, F64, <=); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_GE): - DEF_OP_CMP(float64, F64, >=); - HANDLE_OP_END (); - - /* numberic instructions of i32 */ - HANDLE_OP (WASM_OP_I32_CLZ): - DEF_OP_BIT_COUNT(uint32, I32, clz32); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_CTZ): - DEF_OP_BIT_COUNT(uint32, I32, ctz32); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_POPCNT): - DEF_OP_BIT_COUNT(uint32, I32, popcount32); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_ADD): - DEF_OP_NUMERIC(uint32, uint32, I32, +); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_SUB): - DEF_OP_NUMERIC(uint32, uint32, I32, -); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_MUL): - DEF_OP_NUMERIC(uint32, uint32, I32, *); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_DIV_S): - { - int32 a, b; - - b = POP_I32(); - a = POP_I32(); - if (a == (int32)0x80000000 && b == -1) { - wasm_set_exception(module, "integer overflow"); - goto got_exception; - } - if (b == 0) { - wasm_set_exception(module, "integer divide by zero"); - goto got_exception; - } - PUSH_I32(a / b); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I32_DIV_U): - { - uint32 a, b; - - b = (uint32)POP_I32(); - a = (uint32)POP_I32(); - if (b == 0) { - wasm_set_exception(module, "integer divide by zero"); - goto got_exception; - } - PUSH_I32(a / b); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I32_REM_S): - { - int32 a, b; - - b = POP_I32(); - a = POP_I32(); - if (a == (int32)0x80000000 && b == -1) { - PUSH_I32(0); - HANDLE_OP_END (); - } - if (b == 0) { - wasm_set_exception(module, "integer divide by zero"); - goto got_exception; - } - PUSH_I32(a % b); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I32_REM_U): - { - uint32 a, b; - - b = (uint32)POP_I32(); - a = (uint32)POP_I32(); - if (b == 0) { - wasm_set_exception(module, "integer divide by zero"); - goto got_exception; - } - PUSH_I32(a % b); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I32_AND): - DEF_OP_NUMERIC(uint32, uint32, I32, &); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_OR): - DEF_OP_NUMERIC(uint32, uint32, I32, |); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_XOR): - DEF_OP_NUMERIC(uint32, uint32, I32, ^); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_SHL): - { - DEF_OP_NUMERIC2(uint32, uint32, I32, <<); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I32_SHR_S): - { - DEF_OP_NUMERIC2(int32, uint32, I32, >>); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I32_SHR_U): - { - DEF_OP_NUMERIC2(uint32, uint32, I32, >>); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I32_ROTL): - { - uint32 a, b; - - b = (uint32)POP_I32(); - a = (uint32)POP_I32(); - PUSH_I32(rotl32(a, b)); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I32_ROTR): - { - uint32 a, b; - - b = (uint32)POP_I32(); - a = (uint32)POP_I32(); - PUSH_I32(rotr32(a, b)); - HANDLE_OP_END (); - } - - /* numberic instructions of i64 */ - HANDLE_OP (WASM_OP_I64_CLZ): - DEF_OP_BIT_COUNT(uint64, I64, clz64); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_CTZ): - DEF_OP_BIT_COUNT(uint64, I64, ctz64); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_POPCNT): - DEF_OP_BIT_COUNT(uint64, I64, popcount64); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_ADD): - DEF_OP_NUMERIC_64(uint64, uint64, I64, +); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_SUB): - DEF_OP_NUMERIC_64(uint64, uint64, I64, -); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_MUL): - DEF_OP_NUMERIC_64(uint64, uint64, I64, *); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_DIV_S): - { - int64 a, b; - - b = POP_I64(); - a = POP_I64(); - if (a == (int64)0x8000000000000000LL && b == -1) { - wasm_set_exception(module, "integer overflow"); - goto got_exception; - } - if (b == 0) { - wasm_set_exception(module, "integer divide by zero"); - goto got_exception; - } - PUSH_I64(a / b); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I64_DIV_U): - { - uint64 a, b; - - b = (uint64)POP_I64(); - a = (uint64)POP_I64(); - if (b == 0) { - wasm_set_exception(module, "integer divide by zero"); - goto got_exception; - } - PUSH_I64(a / b); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I64_REM_S): - { - int64 a, b; - - b = POP_I64(); - a = POP_I64(); - if (a == (int64)0x8000000000000000LL && b == -1) { - PUSH_I64(0); - HANDLE_OP_END (); - } - if (b == 0) { - wasm_set_exception(module, "integer divide by zero"); - goto got_exception; - } - PUSH_I64(a % b); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I64_REM_U): - { - uint64 a, b; - - b = (uint64)POP_I64(); - a = (uint64)POP_I64(); - if (b == 0) { - wasm_set_exception(module, "integer divide by zero"); - goto got_exception; - } - PUSH_I64(a % b); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I64_AND): - DEF_OP_NUMERIC_64(uint64, uint64, I64, &); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_OR): - DEF_OP_NUMERIC_64(uint64, uint64, I64, |); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_XOR): - DEF_OP_NUMERIC_64(uint64, uint64, I64, ^); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_SHL): - { - DEF_OP_NUMERIC2_64(uint64, uint64, I64, <<); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I64_SHR_S): - { - DEF_OP_NUMERIC2_64(int64, uint64, I64, >>); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I64_SHR_U): - { - DEF_OP_NUMERIC2_64(uint64, uint64, I64, >>); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I64_ROTL): - { - uint64 a, b; - - b = (uint64)POP_I64(); - a = (uint64)POP_I64(); - PUSH_I64(rotl64(a, b)); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I64_ROTR): - { - uint64 a, b; - - b = (uint64)POP_I64(); - a = (uint64)POP_I64(); - PUSH_I64(rotr64(a, b)); - HANDLE_OP_END (); - } - - /* numberic instructions of f32 */ - HANDLE_OP (WASM_OP_F32_ABS): - DEF_OP_MATH(float32, F32, fabs); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_NEG): - { - uint32 u32 = frame_sp[-1]; - uint32 sign_bit = u32 & ((uint32)1 << 31); - if (sign_bit) - frame_sp[-1] = u32 & ~((uint32)1 << 31); - else - frame_sp[-1] = u32 | ((uint32)1 << 31); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_F32_CEIL): - DEF_OP_MATH(float32, F32, ceil); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_FLOOR): - DEF_OP_MATH(float32, F32, floor); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_TRUNC): - DEF_OP_MATH(float32, F32, trunc); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_NEAREST): - DEF_OP_MATH(float32, F32, rint); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_SQRT): - DEF_OP_MATH(float32, F32, sqrt); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_ADD): - DEF_OP_NUMERIC(float32, float32, F32, +); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_SUB): - DEF_OP_NUMERIC(float32, float32, F32, -); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_MUL): - DEF_OP_NUMERIC(float32, float32, F32, *); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_DIV): - DEF_OP_NUMERIC(float32, float32, F32, /); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_MIN): - { - float32 a, b; - - b = POP_F32(); - a = POP_F32(); - - if (isnan(a)) - PUSH_F32(a); - else if (isnan(b)) - PUSH_F32(b); - else - PUSH_F32(wa_fmin(a, b)); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_F32_MAX): - { - float32 a, b; - - b = POP_F32(); - a = POP_F32(); - - if (isnan(a)) - PUSH_F32(a); - else if (isnan(b)) - PUSH_F32(b); - else - PUSH_F32(wa_fmax(a, b)); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_F32_COPYSIGN): - { - float32 a, b; - - b = POP_F32(); - a = POP_F32(); - PUSH_F32(signbit(b) ? -fabs(a) : fabs(a)); - HANDLE_OP_END (); - } - - /* numberic instructions of f64 */ - HANDLE_OP (WASM_OP_F64_ABS): - DEF_OP_MATH(float64, F64, fabs); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_NEG): - { - uint64 u64 = GET_I64_FROM_ADDR(frame_sp - 2); - uint64 sign_bit = u64 & (((uint64)1) << 63); - if (sign_bit) - PUT_I64_TO_ADDR(frame_sp - 2, (u64 & ~(((uint64)1) << 63))); - else - PUT_I64_TO_ADDR(frame_sp - 2, (u64 | (((uint64)1) << 63))); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_F64_CEIL): - DEF_OP_MATH(float64, F64, ceil); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_FLOOR): - DEF_OP_MATH(float64, F64, floor); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_TRUNC): - DEF_OP_MATH(float64, F64, trunc); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_NEAREST): - DEF_OP_MATH(float64, F64, rint); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_SQRT): - DEF_OP_MATH(float64, F64, sqrt); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_ADD): - DEF_OP_NUMERIC_64(float64, float64, F64, +); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_SUB): - DEF_OP_NUMERIC_64(float64, float64, F64, -); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_MUL): - DEF_OP_NUMERIC_64(float64, float64, F64, *); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_DIV): - DEF_OP_NUMERIC_64(float64, float64, F64, /); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_MIN): - { - float64 a, b; - - b = POP_F64(); - a = POP_F64(); - - if (isnan(a)) - PUSH_F64(a); - else if (isnan(b)) - PUSH_F64(b); - else - PUSH_F64(wa_fmin(a, b)); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_F64_MAX): - { - float64 a, b; - - b = POP_F64(); - a = POP_F64(); - - if (isnan(a)) - PUSH_F64(a); - else if (isnan(b)) - PUSH_F64(b); - else - PUSH_F64(wa_fmax(a, b)); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_F64_COPYSIGN): - { - float64 a, b; - - b = POP_F64(); - a = POP_F64(); - PUSH_F64(signbit(b) ? -fabs(a) : fabs(a)); - HANDLE_OP_END (); - } - - /* conversions of i32 */ - HANDLE_OP (WASM_OP_I32_WRAP_I64): - { - int32 value = (int32)(POP_I64() & 0xFFFFFFFFLL); - PUSH_I32(value); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I32_TRUNC_S_F32): - /* We don't use INT32_MIN/INT32_MAX/UINT32_MIN/UINT32_MAX, - since float/double values of ieee754 cannot precisely represent - all int32/uint32/int64/uint64 values, e.g.: - UINT32_MAX is 4294967295, but (float32)4294967295 is 4294967296.0f, - but not 4294967295.0f. */ - DEF_OP_TRUNC_F32(-2147483904.0f, 2147483648.0f, true, true); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_TRUNC_U_F32): - DEF_OP_TRUNC_F32(-1.0f, 4294967296.0f, true, false); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_TRUNC_S_F64): - DEF_OP_TRUNC_F64(-2147483649.0, 2147483648.0, true, true); - /* frame_sp can't be moved in trunc function, we need to manually adjust - it if src and dst op's cell num is different */ - frame_sp--; - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_TRUNC_U_F64): - DEF_OP_TRUNC_F64(-1.0, 4294967296.0, true, false); - frame_sp--; - HANDLE_OP_END (); - - /* conversions of i64 */ - HANDLE_OP (WASM_OP_I64_EXTEND_S_I32): - DEF_OP_CONVERT(int64, I64, int32, I32); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_EXTEND_U_I32): - DEF_OP_CONVERT(int64, I64, uint32, I32); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_TRUNC_S_F32): - DEF_OP_TRUNC_F32(-9223373136366403584.0f, 9223372036854775808.0f, - false, true); - frame_sp++; - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_TRUNC_U_F32): - DEF_OP_TRUNC_F32(-1.0f, 18446744073709551616.0f, - false, false); - frame_sp++; - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_TRUNC_S_F64): - DEF_OP_TRUNC_F64(-9223372036854777856.0, 9223372036854775808.0, - false, true); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_TRUNC_U_F64): - DEF_OP_TRUNC_F64(-1.0, 18446744073709551616.0, - false, false); - HANDLE_OP_END (); - - /* conversions of f32 */ - HANDLE_OP (WASM_OP_F32_CONVERT_S_I32): - DEF_OP_CONVERT(float32, F32, int32, I32); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_CONVERT_U_I32): - DEF_OP_CONVERT(float32, F32, uint32, I32); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_CONVERT_S_I64): - DEF_OP_CONVERT(float32, F32, int64, I64); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_CONVERT_U_I64): - DEF_OP_CONVERT(float32, F32, uint64, I64); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_DEMOTE_F64): - DEF_OP_CONVERT(float32, F32, float64, F64); - HANDLE_OP_END (); - - /* conversions of f64 */ - HANDLE_OP (WASM_OP_F64_CONVERT_S_I32): - DEF_OP_CONVERT(float64, F64, int32, I32); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_CONVERT_U_I32): - DEF_OP_CONVERT(float64, F64, uint32, I32); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_CONVERT_S_I64): - DEF_OP_CONVERT(float64, F64, int64, I64); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_CONVERT_U_I64): - DEF_OP_CONVERT(float64, F64, uint64, I64); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_PROMOTE_F32): - DEF_OP_CONVERT(float64, F64, float32, F32); - HANDLE_OP_END (); - - /* reinterpretations */ - HANDLE_OP (WASM_OP_I32_REINTERPRET_F32): - HANDLE_OP (WASM_OP_I64_REINTERPRET_F64): - HANDLE_OP (WASM_OP_F32_REINTERPRET_I32): - HANDLE_OP (WASM_OP_F64_REINTERPRET_I64): - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_EXTEND8_S): - DEF_OP_CONVERT(int32, I32, int8, I32); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_EXTEND16_S): - DEF_OP_CONVERT(int32, I32, int16, I32); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_EXTEND8_S): - DEF_OP_CONVERT(int64, I64, int8, I64); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_EXTEND16_S): - DEF_OP_CONVERT(int64, I64, int16, I64); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_EXTEND32_S): - DEF_OP_CONVERT(int64, I64, int32, I64); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_MISC_PREFIX): - { - uint32 opcode1; - - read_leb_uint32(frame_ip, frame_ip_end, opcode1); - opcode = (uint8)opcode1; - - switch (opcode) { - case WASM_OP_I32_TRUNC_SAT_S_F32: - DEF_OP_TRUNC_SAT_F32(-2147483904.0f, 2147483648.0f, - true, true); - break; - case WASM_OP_I32_TRUNC_SAT_U_F32: - DEF_OP_TRUNC_SAT_F32(-1.0f, 4294967296.0f, - true, false); - break; - case WASM_OP_I32_TRUNC_SAT_S_F64: - DEF_OP_TRUNC_SAT_F64(-2147483649.0, 2147483648.0, - true, true); - frame_sp--; - break; - case WASM_OP_I32_TRUNC_SAT_U_F64: - DEF_OP_TRUNC_SAT_F64(-1.0, 4294967296.0, - true, false); - frame_sp--; - break; - case WASM_OP_I64_TRUNC_SAT_S_F32: - DEF_OP_TRUNC_SAT_F32(-9223373136366403584.0f, 9223372036854775808.0f, - false, true); - frame_sp++; - break; - case WASM_OP_I64_TRUNC_SAT_U_F32: - DEF_OP_TRUNC_SAT_F32(-1.0f, 18446744073709551616.0f, - false, false); - frame_sp++; - break; - case WASM_OP_I64_TRUNC_SAT_S_F64: - DEF_OP_TRUNC_SAT_F64(-9223372036854777856.0, 9223372036854775808.0, - false, true); - break; - case WASM_OP_I64_TRUNC_SAT_U_F64: - DEF_OP_TRUNC_SAT_F64(-1.0f, 18446744073709551616.0, - false, false); - break; + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_SET_GLOBAL_64) + { + read_leb_uint32(frame_ip, frame_ip_end, global_idx); + bh_assert(global_idx < module->global_count); + global = globals + global_idx; + global_addr = get_global_addr(global_data, global); + PUT_I64_TO_ADDR((uint32 *)global_addr, POP_I64()); + HANDLE_OP_END(); + } + + /* memory load instructions */ + HANDLE_OP(WASM_OP_I32_LOAD) + HANDLE_OP(WASM_OP_F32_LOAD) + { + uint32 offset, flags, addr; + + read_leb_uint32(frame_ip, frame_ip_end, flags); + read_leb_uint32(frame_ip, frame_ip_end, offset); + addr = POP_I32(); + CHECK_MEMORY_OVERFLOW(4); + PUSH_I32(LOAD_I32(maddr)); + (void)flags; + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_LOAD) + HANDLE_OP(WASM_OP_F64_LOAD) + { + uint32 offset, flags, addr; + + read_leb_uint32(frame_ip, frame_ip_end, flags); + read_leb_uint32(frame_ip, frame_ip_end, offset); + addr = POP_I32(); + CHECK_MEMORY_OVERFLOW(8); + PUSH_I64(LOAD_I64(maddr)); + (void)flags; + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_LOAD8_S) + { + uint32 offset, flags, addr; + + read_leb_uint32(frame_ip, frame_ip_end, flags); + read_leb_uint32(frame_ip, frame_ip_end, offset); + addr = POP_I32(); + CHECK_MEMORY_OVERFLOW(1); + PUSH_I32(sign_ext_8_32(*(int8 *)maddr)); + (void)flags; + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_LOAD8_U) + { + uint32 offset, flags, addr; + + read_leb_uint32(frame_ip, frame_ip_end, flags); + read_leb_uint32(frame_ip, frame_ip_end, offset); + addr = POP_I32(); + CHECK_MEMORY_OVERFLOW(1); + PUSH_I32((uint32)(*(uint8 *)maddr)); + (void)flags; + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_LOAD16_S) + { + uint32 offset, flags, addr; + + read_leb_uint32(frame_ip, frame_ip_end, flags); + read_leb_uint32(frame_ip, frame_ip_end, offset); + addr = POP_I32(); + CHECK_MEMORY_OVERFLOW(2); + PUSH_I32(sign_ext_16_32(LOAD_I16(maddr))); + (void)flags; + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_LOAD16_U) + { + uint32 offset, flags, addr; + + read_leb_uint32(frame_ip, frame_ip_end, flags); + read_leb_uint32(frame_ip, frame_ip_end, offset); + addr = POP_I32(); + CHECK_MEMORY_OVERFLOW(2); + PUSH_I32((uint32)(LOAD_U16(maddr))); + (void)flags; + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_LOAD8_S) + { + uint32 offset, flags, addr; + + read_leb_uint32(frame_ip, frame_ip_end, flags); + read_leb_uint32(frame_ip, frame_ip_end, offset); + addr = POP_I32(); + CHECK_MEMORY_OVERFLOW(1); + PUSH_I64(sign_ext_8_64(*(int8 *)maddr)); + (void)flags; + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_LOAD8_U) + { + uint32 offset, flags, addr; + + read_leb_uint32(frame_ip, frame_ip_end, flags); + read_leb_uint32(frame_ip, frame_ip_end, offset); + addr = POP_I32(); + CHECK_MEMORY_OVERFLOW(1); + PUSH_I64((uint64)(*(uint8 *)maddr)); + (void)flags; + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_LOAD16_S) + { + uint32 offset, flags, addr; + + read_leb_uint32(frame_ip, frame_ip_end, flags); + read_leb_uint32(frame_ip, frame_ip_end, offset); + addr = POP_I32(); + CHECK_MEMORY_OVERFLOW(2); + PUSH_I64(sign_ext_16_64(LOAD_I16(maddr))); + (void)flags; + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_LOAD16_U) + { + uint32 offset, flags, addr; + + read_leb_uint32(frame_ip, frame_ip_end, flags); + read_leb_uint32(frame_ip, frame_ip_end, offset); + addr = POP_I32(); + CHECK_MEMORY_OVERFLOW(2); + PUSH_I64((uint64)(LOAD_U16(maddr))); + (void)flags; + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_LOAD32_S) + { + uint32 offset, flags, addr; + + opcode = *(frame_ip - 1); + read_leb_uint32(frame_ip, frame_ip_end, flags); + read_leb_uint32(frame_ip, frame_ip_end, offset); + addr = POP_I32(); + CHECK_MEMORY_OVERFLOW(4); + PUSH_I64(sign_ext_32_64(LOAD_I32(maddr))); + (void)flags; + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_LOAD32_U) + { + uint32 offset, flags, addr; + + read_leb_uint32(frame_ip, frame_ip_end, flags); + read_leb_uint32(frame_ip, frame_ip_end, offset); + addr = POP_I32(); + CHECK_MEMORY_OVERFLOW(4); + PUSH_I64((uint64)(LOAD_U32(maddr))); + (void)flags; + HANDLE_OP_END(); + } + + /* memory store instructions */ + HANDLE_OP(WASM_OP_I32_STORE) + HANDLE_OP(WASM_OP_F32_STORE) + { + uint32 offset, flags, addr; + + read_leb_uint32(frame_ip, frame_ip_end, flags); + read_leb_uint32(frame_ip, frame_ip_end, offset); + frame_sp--; + addr = POP_I32(); + CHECK_MEMORY_OVERFLOW(4); + STORE_U32(maddr, frame_sp[1]); + (void)flags; + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_STORE) + HANDLE_OP(WASM_OP_F64_STORE) + { + uint32 offset, flags, addr; + + read_leb_uint32(frame_ip, frame_ip_end, flags); + read_leb_uint32(frame_ip, frame_ip_end, offset); + frame_sp -= 2; + addr = POP_I32(); + CHECK_MEMORY_OVERFLOW(8); + STORE_U32(maddr, frame_sp[1]); + STORE_U32(maddr + 4, frame_sp[2]); + (void)flags; + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_STORE8) + HANDLE_OP(WASM_OP_I32_STORE16) + { + uint32 offset, flags, addr; + uint32 sval; + + opcode = *(frame_ip - 1); + read_leb_uint32(frame_ip, frame_ip_end, flags); + read_leb_uint32(frame_ip, frame_ip_end, offset); + sval = (uint32)POP_I32(); + addr = POP_I32(); + + if (opcode == WASM_OP_I32_STORE8) { + CHECK_MEMORY_OVERFLOW(1); + *(uint8 *)maddr = (uint8)sval; + } + else { + CHECK_MEMORY_OVERFLOW(2); + STORE_U16(maddr, (uint16)sval); + } + + (void)flags; + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_STORE8) + HANDLE_OP(WASM_OP_I64_STORE16) + HANDLE_OP(WASM_OP_I64_STORE32) + { + uint32 offset, flags, addr; + uint64 sval; + + opcode = *(frame_ip - 1); + read_leb_uint32(frame_ip, frame_ip_end, flags); + read_leb_uint32(frame_ip, frame_ip_end, offset); + sval = (uint64)POP_I64(); + addr = POP_I32(); + + if (opcode == WASM_OP_I64_STORE8) { + CHECK_MEMORY_OVERFLOW(1); + *(uint8 *)maddr = (uint8)sval; + } + else if (opcode == WASM_OP_I64_STORE16) { + CHECK_MEMORY_OVERFLOW(2); + STORE_U16(maddr, (uint16)sval); + } + else { + CHECK_MEMORY_OVERFLOW(4); + STORE_U32(maddr, (uint32)sval); + } + (void)flags; + HANDLE_OP_END(); + } + + /* memory size and memory grow instructions */ + HANDLE_OP(WASM_OP_MEMORY_SIZE) + { + uint32 reserved; + read_leb_uint32(frame_ip, frame_ip_end, reserved); + PUSH_I32(memory->cur_page_count); + (void)reserved; + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_MEMORY_GROW) + { + uint32 reserved, delta, + prev_page_count = memory->cur_page_count; + + read_leb_uint32(frame_ip, frame_ip_end, reserved); + delta = (uint32)POP_I32(); + + if (!wasm_enlarge_memory(module, delta)) { + /* failed to memory.grow, return -1 */ + PUSH_I32(-1); + } + else { + /* success, return previous page count */ + PUSH_I32(prev_page_count); + /* update memory instance ptr and memory size */ + memory = module->default_memory; + linear_mem_size = + num_bytes_per_page * memory->cur_page_count; + } + + (void)reserved; + HANDLE_OP_END(); + } + + /* constant instructions */ + HANDLE_OP(WASM_OP_I32_CONST) + DEF_OP_I_CONST(int32, I32); + HANDLE_OP_END(); + + HANDLE_OP(WASM_OP_I64_CONST) + DEF_OP_I_CONST(int64, I64); + HANDLE_OP_END(); + + HANDLE_OP(WASM_OP_F32_CONST) + { + uint8 *p_float = (uint8 *)frame_sp++; + for (i = 0; i < sizeof(float32); i++) + *p_float++ = *frame_ip++; + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_CONST) + { + uint8 *p_float = (uint8 *)frame_sp++; + frame_sp++; + for (i = 0; i < sizeof(float64); i++) + *p_float++ = *frame_ip++; + HANDLE_OP_END(); + } + + /* comparison instructions of i32 */ + HANDLE_OP(WASM_OP_I32_EQZ) + { + DEF_OP_EQZ(I32); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_EQ) + { + DEF_OP_CMP(uint32, I32, ==); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_NE) + { + DEF_OP_CMP(uint32, I32, !=); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_LT_S) + { + DEF_OP_CMP(int32, I32, <); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_LT_U) + { + DEF_OP_CMP(uint32, I32, <); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_GT_S) + { + DEF_OP_CMP(int32, I32, >); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_GT_U) + { + DEF_OP_CMP(uint32, I32, >); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_LE_S) + { + DEF_OP_CMP(int32, I32, <=); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_LE_U) + { + DEF_OP_CMP(uint32, I32, <=); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_GE_S) + { + DEF_OP_CMP(int32, I32, >=); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_GE_U) + { + DEF_OP_CMP(uint32, I32, >=); + HANDLE_OP_END(); + } + + /* comparison instructions of i64 */ + HANDLE_OP(WASM_OP_I64_EQZ) + { + DEF_OP_EQZ(I64); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_EQ) + { + DEF_OP_CMP(uint64, I64, ==); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_NE) + { + DEF_OP_CMP(uint64, I64, !=); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_LT_S) + { + DEF_OP_CMP(int64, I64, <); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_LT_U) + { + DEF_OP_CMP(uint64, I64, <); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_GT_S) + { + DEF_OP_CMP(int64, I64, >); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_GT_U) + { + DEF_OP_CMP(uint64, I64, >); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_LE_S) + { + DEF_OP_CMP(int64, I64, <=); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_LE_U) + { + DEF_OP_CMP(uint64, I64, <=); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_GE_S) + { + DEF_OP_CMP(int64, I64, >=); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_GE_U) + { + DEF_OP_CMP(uint64, I64, >=); + HANDLE_OP_END(); + } + + /* comparison instructions of f32 */ + HANDLE_OP(WASM_OP_F32_EQ) + { + DEF_OP_CMP(float32, F32, ==); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_NE) + { + DEF_OP_CMP(float32, F32, !=); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_LT) + { + DEF_OP_CMP(float32, F32, <); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_GT) + { + DEF_OP_CMP(float32, F32, >); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_LE) + { + DEF_OP_CMP(float32, F32, <=); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_GE) + { + DEF_OP_CMP(float32, F32, >=); + HANDLE_OP_END(); + } + + /* comparison instructions of f64 */ + HANDLE_OP(WASM_OP_F64_EQ) + { + DEF_OP_CMP(float64, F64, ==); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_NE) + { + DEF_OP_CMP(float64, F64, !=); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_LT) + { + DEF_OP_CMP(float64, F64, <); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_GT) + { + DEF_OP_CMP(float64, F64, >); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_LE) + { + DEF_OP_CMP(float64, F64, <=); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_GE) + { + DEF_OP_CMP(float64, F64, >=); + HANDLE_OP_END(); + } + + /* numberic instructions of i32 */ + HANDLE_OP(WASM_OP_I32_CLZ) + { + DEF_OP_BIT_COUNT(uint32, I32, clz32); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_CTZ) + { + DEF_OP_BIT_COUNT(uint32, I32, ctz32); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_POPCNT) + { + DEF_OP_BIT_COUNT(uint32, I32, popcount32); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_ADD) + { + DEF_OP_NUMERIC(uint32, uint32, I32, +); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_SUB) + { + DEF_OP_NUMERIC(uint32, uint32, I32, -); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_MUL) + { + DEF_OP_NUMERIC(uint32, uint32, I32, *); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_DIV_S) + { + int32 a, b; + + b = POP_I32(); + a = POP_I32(); + if (a == (int32)0x80000000 && b == -1) { + wasm_set_exception(module, "integer overflow"); + goto got_exception; + } + if (b == 0) { + wasm_set_exception(module, "integer divide by zero"); + goto got_exception; + } + PUSH_I32(a / b); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_DIV_U) + { + uint32 a, b; + + b = (uint32)POP_I32(); + a = (uint32)POP_I32(); + if (b == 0) { + wasm_set_exception(module, "integer divide by zero"); + goto got_exception; + } + PUSH_I32(a / b); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_REM_S) + { + int32 a, b; + + b = POP_I32(); + a = POP_I32(); + if (a == (int32)0x80000000 && b == -1) { + PUSH_I32(0); + HANDLE_OP_END(); + } + if (b == 0) { + wasm_set_exception(module, "integer divide by zero"); + goto got_exception; + } + PUSH_I32(a % b); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_REM_U) + { + uint32 a, b; + + b = (uint32)POP_I32(); + a = (uint32)POP_I32(); + if (b == 0) { + wasm_set_exception(module, "integer divide by zero"); + goto got_exception; + } + PUSH_I32(a % b); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_AND) + { + DEF_OP_NUMERIC(uint32, uint32, I32, &); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_OR) + { + DEF_OP_NUMERIC(uint32, uint32, I32, |); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_XOR) + { + DEF_OP_NUMERIC(uint32, uint32, I32, ^); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_SHL) + { + DEF_OP_NUMERIC2(uint32, uint32, I32, <<); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_SHR_S) + { + DEF_OP_NUMERIC2(int32, uint32, I32, >>); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_SHR_U) + { + DEF_OP_NUMERIC2(uint32, uint32, I32, >>); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_ROTL) + { + uint32 a, b; + + b = (uint32)POP_I32(); + a = (uint32)POP_I32(); + PUSH_I32(rotl32(a, b)); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_ROTR) + { + uint32 a, b; + + b = (uint32)POP_I32(); + a = (uint32)POP_I32(); + PUSH_I32(rotr32(a, b)); + HANDLE_OP_END(); + } + + /* numberic instructions of i64 */ + HANDLE_OP(WASM_OP_I64_CLZ) + { + DEF_OP_BIT_COUNT(uint64, I64, clz64); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_CTZ) + { + DEF_OP_BIT_COUNT(uint64, I64, ctz64); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_POPCNT) + { + DEF_OP_BIT_COUNT(uint64, I64, popcount64); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_ADD) + { + DEF_OP_NUMERIC_64(uint64, uint64, I64, +); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_SUB) + { + DEF_OP_NUMERIC_64(uint64, uint64, I64, -); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_MUL) + { + DEF_OP_NUMERIC_64(uint64, uint64, I64, *); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_DIV_S) + { + int64 a, b; + + b = POP_I64(); + a = POP_I64(); + if (a == (int64)0x8000000000000000LL && b == -1) { + wasm_set_exception(module, "integer overflow"); + goto got_exception; + } + if (b == 0) { + wasm_set_exception(module, "integer divide by zero"); + goto got_exception; + } + PUSH_I64(a / b); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_DIV_U) + { + uint64 a, b; + + b = (uint64)POP_I64(); + a = (uint64)POP_I64(); + if (b == 0) { + wasm_set_exception(module, "integer divide by zero"); + goto got_exception; + } + PUSH_I64(a / b); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_REM_S) + { + int64 a, b; + + b = POP_I64(); + a = POP_I64(); + if (a == (int64)0x8000000000000000LL && b == -1) { + PUSH_I64(0); + HANDLE_OP_END(); + } + if (b == 0) { + wasm_set_exception(module, "integer divide by zero"); + goto got_exception; + } + PUSH_I64(a % b); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_REM_U) + { + uint64 a, b; + + b = (uint64)POP_I64(); + a = (uint64)POP_I64(); + if (b == 0) { + wasm_set_exception(module, "integer divide by zero"); + goto got_exception; + } + PUSH_I64(a % b); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_AND) + { + DEF_OP_NUMERIC_64(uint64, uint64, I64, &); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_OR) + { + DEF_OP_NUMERIC_64(uint64, uint64, I64, |); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_XOR) + { + DEF_OP_NUMERIC_64(uint64, uint64, I64, ^); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_SHL) + { + DEF_OP_NUMERIC2_64(uint64, uint64, I64, <<); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_SHR_S) + { + DEF_OP_NUMERIC2_64(int64, uint64, I64, >>); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_SHR_U) + { + DEF_OP_NUMERIC2_64(uint64, uint64, I64, >>); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_ROTL) + { + uint64 a, b; + + b = (uint64)POP_I64(); + a = (uint64)POP_I64(); + PUSH_I64(rotl64(a, b)); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_ROTR) + { + uint64 a, b; + + b = (uint64)POP_I64(); + a = (uint64)POP_I64(); + PUSH_I64(rotr64(a, b)); + HANDLE_OP_END(); + } + + /* numberic instructions of f32 */ + HANDLE_OP(WASM_OP_F32_ABS) + { + DEF_OP_MATH(float32, F32, fabs); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_NEG) + { + uint32 u32 = frame_sp[-1]; + uint32 sign_bit = u32 & ((uint32)1 << 31); + if (sign_bit) + frame_sp[-1] = u32 & ~((uint32)1 << 31); + else + frame_sp[-1] = u32 | ((uint32)1 << 31); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_CEIL) + { + DEF_OP_MATH(float32, F32, ceil); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_FLOOR) + { + DEF_OP_MATH(float32, F32, floor); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_TRUNC) + { + DEF_OP_MATH(float32, F32, trunc); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_NEAREST) + { + DEF_OP_MATH(float32, F32, rint); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_SQRT) + { + DEF_OP_MATH(float32, F32, sqrt); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_ADD) + { + DEF_OP_NUMERIC(float32, float32, F32, +); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_SUB) + { + DEF_OP_NUMERIC(float32, float32, F32, -); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_MUL) + { + DEF_OP_NUMERIC(float32, float32, F32, *); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_DIV) + { + DEF_OP_NUMERIC(float32, float32, F32, /); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_MIN) + { + float32 a, b; + + b = POP_F32(); + a = POP_F32(); + + if (isnan(a)) + PUSH_F32(a); + else if (isnan(b)) + PUSH_F32(b); + else + PUSH_F32(wa_fmin(a, b)); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_MAX) + { + float32 a, b; + + b = POP_F32(); + a = POP_F32(); + + if (isnan(a)) + PUSH_F32(a); + else if (isnan(b)) + PUSH_F32(b); + else + PUSH_F32(wa_fmax(a, b)); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_COPYSIGN) + { + float32 a, b; + + b = POP_F32(); + a = POP_F32(); + PUSH_F32(signbit(b) ? -fabs(a) : fabs(a)); + HANDLE_OP_END(); + } + + /* numberic instructions of f64 */ + HANDLE_OP(WASM_OP_F64_ABS) + { + DEF_OP_MATH(float64, F64, fabs); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_NEG) + { + uint64 u64 = GET_I64_FROM_ADDR(frame_sp - 2); + uint64 sign_bit = u64 & (((uint64)1) << 63); + if (sign_bit) + PUT_I64_TO_ADDR(frame_sp - 2, (u64 & ~(((uint64)1) << 63))); + else + PUT_I64_TO_ADDR(frame_sp - 2, (u64 | (((uint64)1) << 63))); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_CEIL) + { + DEF_OP_MATH(float64, F64, ceil); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_FLOOR) + { + DEF_OP_MATH(float64, F64, floor); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_TRUNC) + { + DEF_OP_MATH(float64, F64, trunc); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_NEAREST) + { + DEF_OP_MATH(float64, F64, rint); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_SQRT) + { + DEF_OP_MATH(float64, F64, sqrt); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_ADD) + { + DEF_OP_NUMERIC_64(float64, float64, F64, +); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_SUB) + { + DEF_OP_NUMERIC_64(float64, float64, F64, -); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_MUL) + { + DEF_OP_NUMERIC_64(float64, float64, F64, *); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_DIV) + { + DEF_OP_NUMERIC_64(float64, float64, F64, /); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_MIN) + { + float64 a, b; + + b = POP_F64(); + a = POP_F64(); + + if (isnan(a)) + PUSH_F64(a); + else if (isnan(b)) + PUSH_F64(b); + else + PUSH_F64(wa_fmin(a, b)); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_MAX) + { + float64 a, b; + + b = POP_F64(); + a = POP_F64(); + + if (isnan(a)) + PUSH_F64(a); + else if (isnan(b)) + PUSH_F64(b); + else + PUSH_F64(wa_fmax(a, b)); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_COPYSIGN) + { + float64 a, b; + + b = POP_F64(); + a = POP_F64(); + PUSH_F64(signbit(b) ? -fabs(a) : fabs(a)); + HANDLE_OP_END(); + } + + /* conversions of i32 */ + HANDLE_OP(WASM_OP_I32_WRAP_I64) + { + int32 value = (int32)(POP_I64() & 0xFFFFFFFFLL); + PUSH_I32(value); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_TRUNC_S_F32) + { + /* We don't use INT32_MIN/INT32_MAX/UINT32_MIN/UINT32_MAX, + since float/double values of ieee754 cannot precisely + represent all int32/uint32/int64/uint64 values, e.g. + UINT32_MAX is 4294967295, but (float32)4294967295 is + 4294967296.0f, but not 4294967295.0f. */ + DEF_OP_TRUNC_F32(-2147483904.0f, 2147483648.0f, true, true); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_TRUNC_U_F32) + { + DEF_OP_TRUNC_F32(-1.0f, 4294967296.0f, true, false); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_TRUNC_S_F64) + { + DEF_OP_TRUNC_F64(-2147483649.0, 2147483648.0, true, true); + /* frame_sp can't be moved in trunc function, we need to + manually adjust it if src and dst op's cell num is + different */ + frame_sp--; + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_TRUNC_U_F64) + { + DEF_OP_TRUNC_F64(-1.0, 4294967296.0, true, false); + frame_sp--; + HANDLE_OP_END(); + } + + /* conversions of i64 */ + HANDLE_OP(WASM_OP_I64_EXTEND_S_I32) + { + DEF_OP_CONVERT(int64, I64, int32, I32); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_EXTEND_U_I32) + { + DEF_OP_CONVERT(int64, I64, uint32, I32); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_TRUNC_S_F32) + { + DEF_OP_TRUNC_F32(-9223373136366403584.0f, + 9223372036854775808.0f, false, true); + frame_sp++; + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_TRUNC_U_F32) + { + DEF_OP_TRUNC_F32(-1.0f, 18446744073709551616.0f, false, false); + frame_sp++; + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_TRUNC_S_F64) + { + DEF_OP_TRUNC_F64(-9223372036854777856.0, 9223372036854775808.0, + false, true); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_TRUNC_U_F64) + { + DEF_OP_TRUNC_F64(-1.0, 18446744073709551616.0, false, false); + HANDLE_OP_END(); + } + + /* conversions of f32 */ + HANDLE_OP(WASM_OP_F32_CONVERT_S_I32) + { + DEF_OP_CONVERT(float32, F32, int32, I32); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_CONVERT_U_I32) + { + DEF_OP_CONVERT(float32, F32, uint32, I32); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_CONVERT_S_I64) + { + DEF_OP_CONVERT(float32, F32, int64, I64); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_CONVERT_U_I64) + { + DEF_OP_CONVERT(float32, F32, uint64, I64); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_DEMOTE_F64) + { + DEF_OP_CONVERT(float32, F32, float64, F64); + HANDLE_OP_END(); + } + + /* conversions of f64 */ + HANDLE_OP(WASM_OP_F64_CONVERT_S_I32) + { + DEF_OP_CONVERT(float64, F64, int32, I32); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_CONVERT_U_I32) + { + DEF_OP_CONVERT(float64, F64, uint32, I32); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_CONVERT_S_I64) + { + DEF_OP_CONVERT(float64, F64, int64, I64); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_CONVERT_U_I64) + { + DEF_OP_CONVERT(float64, F64, uint64, I64); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_PROMOTE_F32) + { + DEF_OP_CONVERT(float64, F64, float32, F32); + HANDLE_OP_END(); + } + + /* reinterpretations */ + HANDLE_OP(WASM_OP_I32_REINTERPRET_F32) + HANDLE_OP(WASM_OP_I64_REINTERPRET_F64) + HANDLE_OP(WASM_OP_F32_REINTERPRET_I32) + HANDLE_OP(WASM_OP_F64_REINTERPRET_I64) { HANDLE_OP_END(); } + + HANDLE_OP(WASM_OP_I32_EXTEND8_S) + { + DEF_OP_CONVERT(int32, I32, int8, I32); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_EXTEND16_S) + { + DEF_OP_CONVERT(int32, I32, int16, I32); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_EXTEND8_S) + { + DEF_OP_CONVERT(int64, I64, int8, I64); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_EXTEND16_S) + { + DEF_OP_CONVERT(int64, I64, int16, I64); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_EXTEND32_S) + { + DEF_OP_CONVERT(int64, I64, int32, I64); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_MISC_PREFIX) + { + uint32 opcode1; + + read_leb_uint32(frame_ip, frame_ip_end, opcode1); + opcode = (uint8)opcode1; + + switch (opcode) { + case WASM_OP_I32_TRUNC_SAT_S_F32: + DEF_OP_TRUNC_SAT_F32(-2147483904.0f, 2147483648.0f, + true, true); + break; + case WASM_OP_I32_TRUNC_SAT_U_F32: + DEF_OP_TRUNC_SAT_F32(-1.0f, 4294967296.0f, true, false); + break; + case WASM_OP_I32_TRUNC_SAT_S_F64: + DEF_OP_TRUNC_SAT_F64(-2147483649.0, 2147483648.0, true, + true); + frame_sp--; + break; + case WASM_OP_I32_TRUNC_SAT_U_F64: + DEF_OP_TRUNC_SAT_F64(-1.0, 4294967296.0, true, false); + frame_sp--; + break; + case WASM_OP_I64_TRUNC_SAT_S_F32: + DEF_OP_TRUNC_SAT_F32(-9223373136366403584.0f, + 9223372036854775808.0f, false, + true); + frame_sp++; + break; + case WASM_OP_I64_TRUNC_SAT_U_F32: + DEF_OP_TRUNC_SAT_F32(-1.0f, 18446744073709551616.0f, + false, false); + frame_sp++; + break; + case WASM_OP_I64_TRUNC_SAT_S_F64: + DEF_OP_TRUNC_SAT_F64(-9223372036854777856.0, + 9223372036854775808.0, false, + true); + break; + case WASM_OP_I64_TRUNC_SAT_U_F64: + DEF_OP_TRUNC_SAT_F64(-1.0f, 18446744073709551616.0, + false, false); + break; #if WASM_ENABLE_BULK_MEMORY != 0 - case WASM_OP_MEMORY_INIT: - { - uint32 addr, segment; - uint64 bytes, offset, seg_len; - uint8* data; + case WASM_OP_MEMORY_INIT: + { + uint32 addr, segment; + uint64 bytes, offset, seg_len; + uint8 *data; - read_leb_uint32(frame_ip, frame_ip_end, segment); - /* skip memory index */ - frame_ip++; + read_leb_uint32(frame_ip, frame_ip_end, segment); + /* skip memory index */ + frame_ip++; - bytes = (uint64)(uint32)POP_I32(); - offset = (uint64)(uint32)POP_I32(); - addr = (uint32)POP_I32(); + bytes = (uint64)(uint32)POP_I32(); + offset = (uint64)(uint32)POP_I32(); + addr = (uint32)POP_I32(); - CHECK_BULK_MEMORY_OVERFLOW(addr, bytes, maddr); + CHECK_BULK_MEMORY_OVERFLOW(addr, bytes, maddr); - seg_len = (uint64)module->module->data_segments[segment]->data_length; - data = module->module->data_segments[segment]->data; - if (offset + bytes > seg_len) - goto out_of_bounds; + seg_len = (uint64)module->module->data_segments[segment] + ->data_length; + data = module->module->data_segments[segment]->data; + if (offset + bytes > seg_len) + goto out_of_bounds; - bh_memcpy_s(maddr, linear_mem_size - addr, - data + offset, (uint32)bytes); - break; - } - case WASM_OP_DATA_DROP: - { - uint32 segment; + bh_memcpy_s(maddr, linear_mem_size - addr, + data + offset, (uint32)bytes); + break; + } + case WASM_OP_DATA_DROP: + { + uint32 segment; - read_leb_uint32(frame_ip, frame_ip_end, segment); - module->module->data_segments[segment]->data_length = 0; + read_leb_uint32(frame_ip, frame_ip_end, segment); + module->module->data_segments[segment]->data_length = 0; - break; - } - case WASM_OP_MEMORY_COPY: - { - uint32 dst, src, len; - uint8 *mdst, *msrc; + break; + } + case WASM_OP_MEMORY_COPY: + { + uint32 dst, src, len; + uint8 *mdst, *msrc; - frame_ip += 2; + frame_ip += 2; - len = POP_I32(); - src = POP_I32(); - dst = POP_I32(); + len = POP_I32(); + src = POP_I32(); + dst = POP_I32(); - CHECK_BULK_MEMORY_OVERFLOW(src, len, msrc); - CHECK_BULK_MEMORY_OVERFLOW(dst, len, mdst); + CHECK_BULK_MEMORY_OVERFLOW(src, len, msrc); + CHECK_BULK_MEMORY_OVERFLOW(dst, len, mdst); - /* allowing the destination and source to overlap */ - bh_memmove_s(mdst, linear_mem_size - dst, - msrc, len); + /* allowing the destination and source to overlap */ + bh_memmove_s(mdst, linear_mem_size - dst, msrc, len); - break; - } - case WASM_OP_MEMORY_FILL: - { - uint32 dst, len; - uint8 val, *mdst; - frame_ip++; + break; + } + case WASM_OP_MEMORY_FILL: + { + uint32 dst, len; + uint8 val, *mdst; + frame_ip++; - len = POP_I32(); - val = POP_I32(); - dst = POP_I32(); + len = POP_I32(); + val = POP_I32(); + dst = POP_I32(); - CHECK_BULK_MEMORY_OVERFLOW(dst, len, mdst); + CHECK_BULK_MEMORY_OVERFLOW(dst, len, mdst); - memset(mdst, val, len); + memset(mdst, val, len); - break; - } + break; + } #endif /* WASM_ENABLE_BULK_MEMORY */ #if WASM_ENABLE_REF_TYPES != 0 - case WASM_OP_TABLE_INIT: - { - uint32 tbl_idx, elem_idx; - uint64 n, s, d; - WASMTableInstance *tbl_inst; + case WASM_OP_TABLE_INIT: + { + uint32 tbl_idx, elem_idx; + uint64 n, s, d; + WASMTableInstance *tbl_inst; - read_leb_uint32(frame_ip, frame_ip_end, elem_idx); - bh_assert(elem_idx < module->module->table_seg_count); + read_leb_uint32(frame_ip, frame_ip_end, elem_idx); + bh_assert(elem_idx < module->module->table_seg_count); - read_leb_uint32(frame_ip, frame_ip_end, tbl_idx); - bh_assert(tbl_idx < module->module->table_count); + read_leb_uint32(frame_ip, frame_ip_end, tbl_idx); + bh_assert(tbl_idx < module->module->table_count); - tbl_inst = wasm_get_table_inst(module, tbl_idx); + tbl_inst = wasm_get_table_inst(module, tbl_idx); - n = (uint32)POP_I32(); - s = (uint32)POP_I32(); - d = (uint32)POP_I32(); + n = (uint32)POP_I32(); + s = (uint32)POP_I32(); + d = (uint32)POP_I32(); - /* TODO: what if the element is not passive? */ + /* TODO: what if the element is not passive? */ - if (!n) { - break; - } + if (!n) { + break; + } - if (n + s > module->module->table_segments[elem_idx].function_count - || d + n > tbl_inst->cur_size) { - wasm_set_exception(module, "out of bounds table access"); - goto got_exception; - } + if (n + s > module->module->table_segments[elem_idx] + .function_count + || d + n > tbl_inst->cur_size) { + wasm_set_exception(module, + "out of bounds table access"); + goto got_exception; + } - if (module->module->table_segments[elem_idx].is_dropped) { - wasm_set_exception(module, "out of bounds table access"); - goto got_exception; - } + if (module->module->table_segments[elem_idx] + .is_dropped) { + wasm_set_exception(module, + "out of bounds table access"); + goto got_exception; + } - if (!wasm_elem_is_passive( - module->module->table_segments[elem_idx].mode)) { - wasm_set_exception(module, "out of bounds table access"); - goto got_exception; - } + if (!wasm_elem_is_passive( + module->module->table_segments[elem_idx] + .mode)) { + wasm_set_exception(module, + "out of bounds table access"); + goto got_exception; + } - bh_memcpy_s( - (uint8 *)(tbl_inst) - + offsetof(WASMTableInstance, base_addr) + d * sizeof(uint32), - (uint32)((tbl_inst->cur_size - d) * sizeof(uint32)), - module->module->table_segments[elem_idx].func_indexes + s, - (uint32)(n * sizeof(uint32))); + bh_memcpy_s( + (uint8 *)(tbl_inst) + + offsetof(WASMTableInstance, base_addr) + + d * sizeof(uint32), + (uint32)((tbl_inst->cur_size - d) * sizeof(uint32)), + module->module->table_segments[elem_idx] + .func_indexes + + s, + (uint32)(n * sizeof(uint32))); - break; - } - case WASM_OP_ELEM_DROP: - { - uint32 elem_idx; - read_leb_uint32(frame_ip, frame_ip_end, elem_idx); - bh_assert(elem_idx < module->module->table_seg_count); + break; + } + case WASM_OP_ELEM_DROP: + { + uint32 elem_idx; + read_leb_uint32(frame_ip, frame_ip_end, elem_idx); + bh_assert(elem_idx < module->module->table_seg_count); - module->module->table_segments[elem_idx].is_dropped = true; - break; - } - case WASM_OP_TABLE_COPY: - { - uint32 src_tbl_idx, dst_tbl_idx; - uint64 n, s, d; - WASMTableInstance *src_tbl_inst, *dst_tbl_inst; + module->module->table_segments[elem_idx].is_dropped = + true; + break; + } + case WASM_OP_TABLE_COPY: + { + uint32 src_tbl_idx, dst_tbl_idx; + uint64 n, s, d; + WASMTableInstance *src_tbl_inst, *dst_tbl_inst; - read_leb_uint32(frame_ip, frame_ip_end, dst_tbl_idx); - bh_assert(dst_tbl_idx < module->table_count); + read_leb_uint32(frame_ip, frame_ip_end, dst_tbl_idx); + bh_assert(dst_tbl_idx < module->table_count); - dst_tbl_inst = wasm_get_table_inst(module, dst_tbl_idx); + dst_tbl_inst = wasm_get_table_inst(module, dst_tbl_idx); - read_leb_uint32(frame_ip, frame_ip_end, src_tbl_idx); - bh_assert(src_tbl_idx < module->table_count); + read_leb_uint32(frame_ip, frame_ip_end, src_tbl_idx); + bh_assert(src_tbl_idx < module->table_count); - src_tbl_inst = wasm_get_table_inst(module, src_tbl_idx); + src_tbl_inst = wasm_get_table_inst(module, src_tbl_idx); - n = (uint32)POP_I32(); - s = (uint32)POP_I32(); - d = (uint32)POP_I32(); + n = (uint32)POP_I32(); + s = (uint32)POP_I32(); + d = (uint32)POP_I32(); - if (s + n > dst_tbl_inst->cur_size - || d + n > src_tbl_inst->cur_size) { - wasm_set_exception(module, "out of bounds table access"); - goto got_exception; - } + if (s + n > dst_tbl_inst->cur_size + || d + n > src_tbl_inst->cur_size) { + wasm_set_exception(module, + "out of bounds table access"); + goto got_exception; + } - /* if s >= d, copy from front to back */ - /* if s < d, copy from back to front */ - /* merge all together */ - bh_memmove_s( - (uint8 *)(dst_tbl_inst) + offsetof(WASMTableInstance, base_addr) - + d * sizeof(uint32), - (uint32)((dst_tbl_inst->cur_size - d) * sizeof(uint32)), - (uint8 *)(src_tbl_inst) + offsetof(WASMTableInstance, base_addr) - + s * sizeof(uint32), - (uint32)(n * sizeof(uint32))); - break; - } - case WASM_OP_TABLE_GROW: - { - uint32 tbl_idx, n, init_val, orig_tbl_sz; - WASMTableInstance *tbl_inst; + /* if s >= d, copy from front to back */ + /* if s < d, copy from back to front */ + /* merge all together */ + bh_memmove_s( + (uint8 *)(dst_tbl_inst) + + offsetof(WASMTableInstance, base_addr) + + d * sizeof(uint32), + (uint32)((dst_tbl_inst->cur_size - d) + * sizeof(uint32)), + (uint8 *)(src_tbl_inst) + + offsetof(WASMTableInstance, base_addr) + + s * sizeof(uint32), + (uint32)(n * sizeof(uint32))); + break; + } + case WASM_OP_TABLE_GROW: + { + uint32 tbl_idx, n, init_val, orig_tbl_sz; + WASMTableInstance *tbl_inst; - read_leb_uint32(frame_ip, frame_ip_end, tbl_idx); - bh_assert(tbl_idx < module->table_count); + read_leb_uint32(frame_ip, frame_ip_end, tbl_idx); + bh_assert(tbl_idx < module->table_count); - tbl_inst = wasm_get_table_inst(module, tbl_idx); + tbl_inst = wasm_get_table_inst(module, tbl_idx); - orig_tbl_sz = tbl_inst->cur_size; + orig_tbl_sz = tbl_inst->cur_size; - n = POP_I32(); - init_val = POP_I32(); + n = POP_I32(); + init_val = POP_I32(); - if (!wasm_enlarge_table(module, tbl_idx, n, init_val)) { - PUSH_I32(-1); - } - else { - PUSH_I32(orig_tbl_sz); - } - break; - } - case WASM_OP_TABLE_SIZE: - { - uint32 tbl_idx; - WASMTableInstance *tbl_inst; + if (!wasm_enlarge_table(module, tbl_idx, n, init_val)) { + PUSH_I32(-1); + } + else { + PUSH_I32(orig_tbl_sz); + } + break; + } + case WASM_OP_TABLE_SIZE: + { + uint32 tbl_idx; + WASMTableInstance *tbl_inst; - read_leb_uint32(frame_ip, frame_ip_end, tbl_idx); - bh_assert(tbl_idx < module->table_count); + read_leb_uint32(frame_ip, frame_ip_end, tbl_idx); + bh_assert(tbl_idx < module->table_count); - tbl_inst = wasm_get_table_inst(module, tbl_idx); + tbl_inst = wasm_get_table_inst(module, tbl_idx); - PUSH_I32(tbl_inst->cur_size); - break; - } - case WASM_OP_TABLE_FILL: - { - uint32 tbl_idx, n, val, i; - WASMTableInstance *tbl_inst; + PUSH_I32(tbl_inst->cur_size); + break; + } + case WASM_OP_TABLE_FILL: + { + uint32 tbl_idx, n, val, i; + WASMTableInstance *tbl_inst; - read_leb_uint32(frame_ip, frame_ip_end, tbl_idx); - bh_assert(tbl_idx < module->table_count); + read_leb_uint32(frame_ip, frame_ip_end, tbl_idx); + bh_assert(tbl_idx < module->table_count); - tbl_inst = wasm_get_table_inst(module, tbl_idx); + tbl_inst = wasm_get_table_inst(module, tbl_idx); - n = POP_I32(); - val = POP_I32(); - i = POP_I32(); + n = POP_I32(); + val = POP_I32(); + i = POP_I32(); - /* TODO: what if the element is not passive? */ - /* TODO: what if the element is dropped? */ + /* TODO: what if the element is not passive? */ + /* TODO: what if the element is dropped? */ - if (i + n > tbl_inst->cur_size) { - /* TODO: verify warning content */ - wasm_set_exception(module, "out of bounds table access"); - goto got_exception; - } + if (i + n > tbl_inst->cur_size) { + /* TODO: verify warning content */ + wasm_set_exception(module, + "out of bounds table access"); + goto got_exception; + } - for (; n != 0; i++, n--) { - ((uint32 *)(tbl_inst->base_addr))[i] = val; - } + for (; n != 0; i++, n--) { + ((uint32 *)(tbl_inst->base_addr))[i] = val; + } - break; - } + break; + } #endif /* WASM_ENABLE_REF_TYPES */ - default: - wasm_set_exception(module, "unsupported opcode"); - goto got_exception; - } - HANDLE_OP_END (); - } + default: + wasm_set_exception(module, "unsupported opcode"); + goto got_exception; + } + HANDLE_OP_END(); + } #if WASM_ENABLE_SHARED_MEMORY != 0 - HANDLE_OP (WASM_OP_ATOMIC_PREFIX): - { - uint32 offset, align, addr; + HANDLE_OP(WASM_OP_ATOMIC_PREFIX) + { + uint32 offset, align, addr; - opcode = *frame_ip++; + opcode = *frame_ip++; - read_leb_uint32(frame_ip, frame_ip_end, align); - read_leb_uint32(frame_ip, frame_ip_end, offset); - switch (opcode) { - case WASM_OP_ATOMIC_NOTIFY: - { - uint32 count, ret; + read_leb_uint32(frame_ip, frame_ip_end, align); + read_leb_uint32(frame_ip, frame_ip_end, offset); + switch (opcode) { + case WASM_OP_ATOMIC_NOTIFY: + { + uint32 count, ret; - count = POP_I32(); - addr = POP_I32(); - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(); + count = POP_I32(); + addr = POP_I32(); + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(); - ret = wasm_runtime_atomic_notify((WASMModuleInstanceCommon*)module, - maddr, count); - bh_assert((int32)ret >= 0); + ret = wasm_runtime_atomic_notify( + (WASMModuleInstanceCommon *)module, maddr, count); + bh_assert((int32)ret >= 0); - PUSH_I32(ret); - break; - } - case WASM_OP_ATOMIC_WAIT32: - { - uint64 timeout; - uint32 expect, addr, ret; + PUSH_I32(ret); + break; + } + case WASM_OP_ATOMIC_WAIT32: + { + uint64 timeout; + uint32 expect, addr, ret; - timeout = POP_I64(); - expect = POP_I32(); - addr = POP_I32(); - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(); + timeout = POP_I64(); + expect = POP_I32(); + addr = POP_I32(); + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(); - ret = wasm_runtime_atomic_wait((WASMModuleInstanceCommon*)module, maddr, - (uint64)expect, timeout, false); - if (ret == (uint32)-1) - goto got_exception; + ret = wasm_runtime_atomic_wait( + (WASMModuleInstanceCommon *)module, maddr, + (uint64)expect, timeout, false); + if (ret == (uint32)-1) + goto got_exception; - PUSH_I32(ret); - break; - } - case WASM_OP_ATOMIC_WAIT64: - { - uint64 timeout, expect; - uint32 ret; + PUSH_I32(ret); + break; + } + case WASM_OP_ATOMIC_WAIT64: + { + uint64 timeout, expect; + uint32 ret; - timeout = POP_I64(); - expect = POP_I64(); - addr = POP_I32(); - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 8, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(); + timeout = POP_I64(); + expect = POP_I64(); + addr = POP_I32(); + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 8, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(); - ret = wasm_runtime_atomic_wait((WASMModuleInstanceCommon*)module, - maddr, expect, timeout, true); - if (ret == (uint32)-1) - goto got_exception; + ret = wasm_runtime_atomic_wait( + (WASMModuleInstanceCommon *)module, maddr, expect, + timeout, true); + if (ret == (uint32)-1) + goto got_exception; - PUSH_I32(ret); - break; - } + PUSH_I32(ret); + break; + } - case WASM_OP_ATOMIC_I32_LOAD: - case WASM_OP_ATOMIC_I32_LOAD8_U: - case WASM_OP_ATOMIC_I32_LOAD16_U: - { - uint32 readv; + case WASM_OP_ATOMIC_I32_LOAD: + case WASM_OP_ATOMIC_I32_LOAD8_U: + case WASM_OP_ATOMIC_I32_LOAD16_U: + { + uint32 readv; - addr = POP_I32(); + addr = POP_I32(); - if (opcode == WASM_OP_ATOMIC_I32_LOAD8_U) { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(); - os_mutex_lock(&memory->mem_lock); - readv = (uint32)(*(uint8*)maddr); - os_mutex_unlock(&memory->mem_lock); + if (opcode == WASM_OP_ATOMIC_I32_LOAD8_U) { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(); + os_mutex_lock(&memory->mem_lock); + readv = (uint32)(*(uint8 *)maddr); + os_mutex_unlock(&memory->mem_lock); + } + else if (opcode == WASM_OP_ATOMIC_I32_LOAD16_U) { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(); + os_mutex_lock(&memory->mem_lock); + readv = (uint32)LOAD_U16(maddr); + os_mutex_unlock(&memory->mem_lock); + } + else { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(); + os_mutex_lock(&memory->mem_lock); + readv = LOAD_I32(maddr); + os_mutex_unlock(&memory->mem_lock); + } + + PUSH_I32(readv); + break; + } + + case WASM_OP_ATOMIC_I64_LOAD: + case WASM_OP_ATOMIC_I64_LOAD8_U: + case WASM_OP_ATOMIC_I64_LOAD16_U: + case WASM_OP_ATOMIC_I64_LOAD32_U: + { + uint64 readv; + + addr = POP_I32(); + + if (opcode == WASM_OP_ATOMIC_I64_LOAD8_U) { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(); + os_mutex_lock(&memory->mem_lock); + readv = (uint64)(*(uint8 *)maddr); + os_mutex_unlock(&memory->mem_lock); + } + else if (opcode == WASM_OP_ATOMIC_I64_LOAD16_U) { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(); + os_mutex_lock(&memory->mem_lock); + readv = (uint64)LOAD_U16(maddr); + os_mutex_unlock(&memory->mem_lock); + } + else if (opcode == WASM_OP_ATOMIC_I64_LOAD32_U) { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(); + os_mutex_lock(&memory->mem_lock); + readv = (uint64)LOAD_U32(maddr); + os_mutex_unlock(&memory->mem_lock); + } + else { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 8, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(); + os_mutex_lock(&memory->mem_lock); + readv = LOAD_I64(maddr); + os_mutex_unlock(&memory->mem_lock); + } + + PUSH_I64(readv); + break; + } + + case WASM_OP_ATOMIC_I32_STORE: + case WASM_OP_ATOMIC_I32_STORE8: + case WASM_OP_ATOMIC_I32_STORE16: + { + uint32 sval; + + sval = (uint32)POP_I32(); + addr = POP_I32(); + + if (opcode == WASM_OP_ATOMIC_I32_STORE8) { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(); + os_mutex_lock(&memory->mem_lock); + *(uint8 *)maddr = (uint8)sval; + os_mutex_unlock(&memory->mem_lock); + } + else if (opcode == WASM_OP_ATOMIC_I32_STORE16) { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(); + os_mutex_lock(&memory->mem_lock); + STORE_U16(maddr, (uint16)sval); + os_mutex_unlock(&memory->mem_lock); + } + else { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(); + os_mutex_lock(&memory->mem_lock); + STORE_U32(maddr, frame_sp[1]); + os_mutex_unlock(&memory->mem_lock); + } + break; + } + + case WASM_OP_ATOMIC_I64_STORE: + case WASM_OP_ATOMIC_I64_STORE8: + case WASM_OP_ATOMIC_I64_STORE16: + case WASM_OP_ATOMIC_I64_STORE32: + { + uint64 sval; + + sval = (uint64)POP_I64(); + addr = POP_I32(); + + if (opcode == WASM_OP_ATOMIC_I64_STORE8) { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(); + os_mutex_lock(&memory->mem_lock); + *(uint8 *)maddr = (uint8)sval; + os_mutex_unlock(&memory->mem_lock); + } + else if (opcode == WASM_OP_ATOMIC_I64_STORE16) { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(); + os_mutex_lock(&memory->mem_lock); + STORE_U16(maddr, (uint16)sval); + os_mutex_unlock(&memory->mem_lock); + } + else if (opcode == WASM_OP_ATOMIC_I64_STORE32) { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(); + os_mutex_lock(&memory->mem_lock); + STORE_U32(maddr, (uint32)sval); + os_mutex_unlock(&memory->mem_lock); + } + else { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 8, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(); + os_mutex_lock(&memory->mem_lock); + STORE_U32(maddr, frame_sp[1]); + STORE_U32(maddr + 4, frame_sp[2]); + os_mutex_unlock(&memory->mem_lock); + } + break; + } + + case WASM_OP_ATOMIC_RMW_I32_CMPXCHG: + case WASM_OP_ATOMIC_RMW_I32_CMPXCHG8_U: + case WASM_OP_ATOMIC_RMW_I32_CMPXCHG16_U: + { + uint32 readv, sval, expect; + + sval = POP_I32(); + expect = POP_I32(); + addr = POP_I32(); + + if (opcode == WASM_OP_ATOMIC_RMW_I32_CMPXCHG8_U) { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(); + + os_mutex_lock(&memory->mem_lock); + readv = (uint32)(*(uint8 *)maddr); + if (readv == expect) + *(uint8 *)maddr = (uint8)(sval); + os_mutex_unlock(&memory->mem_lock); + } + else if (opcode == WASM_OP_ATOMIC_RMW_I32_CMPXCHG16_U) { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(); + + os_mutex_lock(&memory->mem_lock); + readv = (uint32)LOAD_U16(maddr); + if (readv == expect) + STORE_U16(maddr, (uint16)(sval)); + os_mutex_unlock(&memory->mem_lock); + } + else { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(); + + os_mutex_lock(&memory->mem_lock); + readv = LOAD_I32(maddr); + if (readv == expect) + STORE_U32(maddr, sval); + os_mutex_unlock(&memory->mem_lock); + } + PUSH_I32(readv); + break; + } + case WASM_OP_ATOMIC_RMW_I64_CMPXCHG: + case WASM_OP_ATOMIC_RMW_I64_CMPXCHG8_U: + case WASM_OP_ATOMIC_RMW_I64_CMPXCHG16_U: + case WASM_OP_ATOMIC_RMW_I64_CMPXCHG32_U: + { + uint64 readv, sval, expect; + + sval = (uint64)POP_I64(); + expect = (uint64)POP_I64(); + addr = POP_I32(); + + if (opcode == WASM_OP_ATOMIC_RMW_I64_CMPXCHG8_U) { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(); + + os_mutex_lock(&memory->mem_lock); + readv = (uint64)(*(uint8 *)maddr); + if (readv == expect) + *(uint8 *)maddr = (uint8)(sval); + os_mutex_unlock(&memory->mem_lock); + } + else if (opcode == WASM_OP_ATOMIC_RMW_I64_CMPXCHG16_U) { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(); + + os_mutex_lock(&memory->mem_lock); + readv = (uint64)LOAD_U16(maddr); + if (readv == expect) + STORE_U16(maddr, (uint16)(sval)); + os_mutex_unlock(&memory->mem_lock); + } + else if (opcode == WASM_OP_ATOMIC_RMW_I64_CMPXCHG32_U) { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(); + + os_mutex_lock(&memory->mem_lock); + readv = (uint64)LOAD_U32(maddr); + if (readv == expect) + STORE_U32(maddr, (uint32)(sval)); + os_mutex_unlock(&memory->mem_lock); + } + else { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 8, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(); + + os_mutex_lock(&memory->mem_lock); + readv = (uint64)LOAD_I64(maddr); + if (readv == expect) { + STORE_I64(maddr, sval); + } + os_mutex_unlock(&memory->mem_lock); + } + PUSH_I64(readv); + break; + } + + DEF_ATOMIC_RMW_OPCODE(ADD, +); + DEF_ATOMIC_RMW_OPCODE(SUB, -); + DEF_ATOMIC_RMW_OPCODE(AND, &); + DEF_ATOMIC_RMW_OPCODE(OR, |); + DEF_ATOMIC_RMW_OPCODE(XOR, ^); + /* xchg, ignore the read value, and store the given + value: readv * 0 + sval */ + DEF_ATOMIC_RMW_OPCODE(XCHG, *0 +); + } + + HANDLE_OP_END(); } - else if (opcode == WASM_OP_ATOMIC_I32_LOAD16_U) { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(); - os_mutex_lock(&memory->mem_lock); - readv = (uint32)LOAD_U16(maddr); - os_mutex_unlock(&memory->mem_lock); - } - else { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(); - os_mutex_lock(&memory->mem_lock); - readv = LOAD_I32(maddr); - os_mutex_unlock(&memory->mem_lock); - } - - PUSH_I32(readv); - break; - } - - case WASM_OP_ATOMIC_I64_LOAD: - case WASM_OP_ATOMIC_I64_LOAD8_U: - case WASM_OP_ATOMIC_I64_LOAD16_U: - case WASM_OP_ATOMIC_I64_LOAD32_U: - { - uint64 readv; - - addr = POP_I32(); - - if (opcode == WASM_OP_ATOMIC_I64_LOAD8_U) { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(); - os_mutex_lock(&memory->mem_lock); - readv = (uint64)(*(uint8*)maddr); - os_mutex_unlock(&memory->mem_lock); - } - else if (opcode == WASM_OP_ATOMIC_I64_LOAD16_U) { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(); - os_mutex_lock(&memory->mem_lock); - readv = (uint64)LOAD_U16(maddr); - os_mutex_unlock(&memory->mem_lock); - } - else if (opcode == WASM_OP_ATOMIC_I64_LOAD32_U) { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(); - os_mutex_lock(&memory->mem_lock); - readv = (uint64)LOAD_U32(maddr); - os_mutex_unlock(&memory->mem_lock); - } - else { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 8, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(); - os_mutex_lock(&memory->mem_lock); - readv = LOAD_I64(maddr); - os_mutex_unlock(&memory->mem_lock); - } - - PUSH_I64(readv); - break; - } - - case WASM_OP_ATOMIC_I32_STORE: - case WASM_OP_ATOMIC_I32_STORE8: - case WASM_OP_ATOMIC_I32_STORE16: - { - uint32 sval; - - sval = (uint32)POP_I32(); - addr = POP_I32(); - - if (opcode == WASM_OP_ATOMIC_I32_STORE8) { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(); - os_mutex_lock(&memory->mem_lock); - *(uint8*)maddr = (uint8)sval; - os_mutex_unlock(&memory->mem_lock); - } - else if (opcode == WASM_OP_ATOMIC_I32_STORE16) { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(); - os_mutex_lock(&memory->mem_lock); - STORE_U16(maddr, (uint16)sval); - os_mutex_unlock(&memory->mem_lock); - } - else { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(); - os_mutex_lock(&memory->mem_lock); - STORE_U32(maddr, frame_sp[1]); - os_mutex_unlock(&memory->mem_lock); - } - break; - } - - case WASM_OP_ATOMIC_I64_STORE: - case WASM_OP_ATOMIC_I64_STORE8: - case WASM_OP_ATOMIC_I64_STORE16: - case WASM_OP_ATOMIC_I64_STORE32: - { - uint64 sval; - - sval = (uint64)POP_I64(); - addr = POP_I32(); - - if (opcode == WASM_OP_ATOMIC_I64_STORE8) { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(); - os_mutex_lock(&memory->mem_lock); - *(uint8*)maddr = (uint8)sval; - os_mutex_unlock(&memory->mem_lock); - } - else if(opcode == WASM_OP_ATOMIC_I64_STORE16) { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(); - os_mutex_lock(&memory->mem_lock); - STORE_U16(maddr, (uint16)sval); - os_mutex_unlock(&memory->mem_lock); - } - else if (opcode == WASM_OP_ATOMIC_I64_STORE32) { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(); - os_mutex_lock(&memory->mem_lock); - STORE_U32(maddr, (uint32)sval); - os_mutex_unlock(&memory->mem_lock); - } - else { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 8, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(); - os_mutex_lock(&memory->mem_lock); - STORE_U32(maddr, frame_sp[1]); - STORE_U32(maddr + 4, frame_sp[2]); - os_mutex_unlock(&memory->mem_lock); - } - break; - } - - case WASM_OP_ATOMIC_RMW_I32_CMPXCHG: - case WASM_OP_ATOMIC_RMW_I32_CMPXCHG8_U: - case WASM_OP_ATOMIC_RMW_I32_CMPXCHG16_U: - { - uint32 readv, sval, expect; - - sval = POP_I32(); - expect = POP_I32(); - addr = POP_I32(); - - if (opcode == WASM_OP_ATOMIC_RMW_I32_CMPXCHG8_U) { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(); - - os_mutex_lock(&memory->mem_lock); - readv = (uint32)(*(uint8*)maddr); - if (readv == expect) - *(uint8*)maddr = (uint8)(sval); - os_mutex_unlock(&memory->mem_lock); - } - else if (opcode == WASM_OP_ATOMIC_RMW_I32_CMPXCHG16_U) { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(); - - os_mutex_lock(&memory->mem_lock); - readv = (uint32)LOAD_U16(maddr); - if (readv == expect) - STORE_U16(maddr, (uint16)(sval)); - os_mutex_unlock(&memory->mem_lock); - } - else { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(); - - os_mutex_lock(&memory->mem_lock); - readv = LOAD_I32(maddr); - if (readv == expect) - STORE_U32(maddr, sval); - os_mutex_unlock(&memory->mem_lock); - } - PUSH_I32(readv); - break; - } - case WASM_OP_ATOMIC_RMW_I64_CMPXCHG: - case WASM_OP_ATOMIC_RMW_I64_CMPXCHG8_U: - case WASM_OP_ATOMIC_RMW_I64_CMPXCHG16_U: - case WASM_OP_ATOMIC_RMW_I64_CMPXCHG32_U: - { - uint64 readv, sval, expect; - - sval = (uint64)POP_I64(); - expect = (uint64)POP_I64(); - addr = POP_I32(); - - if (opcode == WASM_OP_ATOMIC_RMW_I64_CMPXCHG8_U) { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(); - - os_mutex_lock(&memory->mem_lock); - readv = (uint64)(*(uint8*)maddr); - if (readv == expect) - *(uint8*)maddr = (uint8)(sval); - os_mutex_unlock(&memory->mem_lock); - } - else if (opcode == WASM_OP_ATOMIC_RMW_I64_CMPXCHG16_U) { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(); - - os_mutex_lock(&memory->mem_lock); - readv = (uint64)LOAD_U16(maddr); - if (readv == expect) - STORE_U16(maddr, (uint16)(sval)); - os_mutex_unlock(&memory->mem_lock); - } - else if (opcode == WASM_OP_ATOMIC_RMW_I64_CMPXCHG32_U) { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(); - - os_mutex_lock(&memory->mem_lock); - readv = (uint64)LOAD_U32(maddr); - if (readv == expect) - STORE_U32(maddr, (uint32)(sval)); - os_mutex_unlock(&memory->mem_lock); - } - else { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 8, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(); - - os_mutex_lock(&memory->mem_lock); - readv = (uint64)LOAD_I64(maddr); - if (readv == expect) { - STORE_I64(maddr, sval); - } - os_mutex_unlock(&memory->mem_lock); - } - PUSH_I64(readv); - break; - } - - DEF_ATOMIC_RMW_OPCODE(ADD, +); - DEF_ATOMIC_RMW_OPCODE(SUB, -); - DEF_ATOMIC_RMW_OPCODE(AND, &); - DEF_ATOMIC_RMW_OPCODE(OR, |); - DEF_ATOMIC_RMW_OPCODE(XOR, ^); - /* xchg, ignore the read value, and store the given value: - readv * 0 + sval */ - DEF_ATOMIC_RMW_OPCODE(XCHG, *0 +); - } - - HANDLE_OP_END (); - } #endif - HANDLE_OP (WASM_OP_IMPDEP): - frame = prev_frame; - frame_ip = frame->ip; - frame_sp = frame->sp; - frame_csp = frame->csp; - goto call_func_from_entry; + HANDLE_OP(WASM_OP_IMPDEP) + { + frame = prev_frame; + frame_ip = frame->ip; + frame_sp = frame->sp; + frame_csp = frame->csp; + goto call_func_from_entry; + } + #if WASM_ENABLE_DEBUG_INTERP != 0 - HANDLE_OP (DEBUG_OP_BREAK): - { - wasm_cluster_thread_send_signal(exec_env, WAMR_SIG_TRAP); - exec_env->suspend_flags.flags |= 2; - frame_ip--; - SYNC_ALL_TO_FRAME(); - CHECK_SUSPEND_FLAGS(); - HANDLE_OP_END (); - } + HANDLE_OP(DEBUG_OP_BREAK) + { + wasm_cluster_thread_send_signal(exec_env, WAMR_SIG_TRAP); + exec_env->suspend_flags.flags |= 2; + frame_ip--; + SYNC_ALL_TO_FRAME(); + CHECK_SUSPEND_FLAGS(); + HANDLE_OP_END(); + } #endif #if WASM_ENABLE_LABELS_AS_VALUES == 0 - default: - wasm_set_exception(module, "unsupported opcode"); - goto got_exception; - } + default: + wasm_set_exception(module, "unsupported opcode"); + goto got_exception; + } #endif #if WASM_ENABLE_LABELS_AS_VALUES != 0 - HANDLE_OP (WASM_OP_UNUSED_0x06): - HANDLE_OP (WASM_OP_UNUSED_0x07): - HANDLE_OP (WASM_OP_UNUSED_0x08): - HANDLE_OP (WASM_OP_UNUSED_0x09): - HANDLE_OP (WASM_OP_UNUSED_0x0a): + HANDLE_OP(WASM_OP_UNUSED_0x06) + HANDLE_OP(WASM_OP_UNUSED_0x07) + HANDLE_OP(WASM_OP_UNUSED_0x08) + HANDLE_OP(WASM_OP_UNUSED_0x09) + HANDLE_OP(WASM_OP_UNUSED_0x0a) #if WASM_ENABLE_TAIL_CALL == 0 - HANDLE_OP (WASM_OP_RETURN_CALL): - HANDLE_OP (WASM_OP_RETURN_CALL_INDIRECT): + HANDLE_OP(WASM_OP_RETURN_CALL) + HANDLE_OP(WASM_OP_RETURN_CALL_INDIRECT) #endif #if WASM_ENABLE_SHARED_MEMORY == 0 - HANDLE_OP (WASM_OP_ATOMIC_PREFIX): + HANDLE_OP(WASM_OP_ATOMIC_PREFIX) #endif #if WASM_ENABLE_REF_TYPES == 0 - HANDLE_OP (WASM_OP_SELECT_T): - HANDLE_OP (WASM_OP_TABLE_GET): - HANDLE_OP (WASM_OP_TABLE_SET): - HANDLE_OP (WASM_OP_REF_NULL): - HANDLE_OP (WASM_OP_REF_IS_NULL): - HANDLE_OP (WASM_OP_REF_FUNC): + HANDLE_OP(WASM_OP_SELECT_T) + HANDLE_OP(WASM_OP_TABLE_GET) + HANDLE_OP(WASM_OP_TABLE_SET) + HANDLE_OP(WASM_OP_REF_NULL) + HANDLE_OP(WASM_OP_REF_IS_NULL) + HANDLE_OP(WASM_OP_REF_FUNC) #endif - HANDLE_OP (WASM_OP_UNUSED_0x14): - HANDLE_OP (WASM_OP_UNUSED_0x15): - HANDLE_OP (WASM_OP_UNUSED_0x16): - HANDLE_OP (WASM_OP_UNUSED_0x17): - HANDLE_OP (WASM_OP_UNUSED_0x18): - HANDLE_OP (WASM_OP_UNUSED_0x19): - HANDLE_OP (WASM_OP_UNUSED_0x27): - /* Used by fast interpreter */ - HANDLE_OP (EXT_OP_SET_LOCAL_FAST_I64): - HANDLE_OP (EXT_OP_TEE_LOCAL_FAST_I64): - HANDLE_OP (EXT_OP_COPY_STACK_TOP): - HANDLE_OP (EXT_OP_COPY_STACK_TOP_I64): - HANDLE_OP (EXT_OP_COPY_STACK_VALUES): - { - wasm_set_exception(module, "unsupported opcode"); - goto got_exception; - } + HANDLE_OP(WASM_OP_UNUSED_0x14) + HANDLE_OP(WASM_OP_UNUSED_0x15) + HANDLE_OP(WASM_OP_UNUSED_0x16) + HANDLE_OP(WASM_OP_UNUSED_0x17) + HANDLE_OP(WASM_OP_UNUSED_0x18) + HANDLE_OP(WASM_OP_UNUSED_0x19) + HANDLE_OP(WASM_OP_UNUSED_0x27) + /* Used by fast interpreter */ + HANDLE_OP(EXT_OP_SET_LOCAL_FAST_I64) + HANDLE_OP(EXT_OP_TEE_LOCAL_FAST_I64) + HANDLE_OP(EXT_OP_COPY_STACK_TOP) + HANDLE_OP(EXT_OP_COPY_STACK_TOP_I64) + HANDLE_OP(EXT_OP_COPY_STACK_VALUES) + { + wasm_set_exception(module, "unsupported opcode"); + goto got_exception; + } #endif #if WASM_ENABLE_LABELS_AS_VALUES == 0 - continue; + continue; #else - FETCH_OPCODE_AND_DISPATCH (); + FETCH_OPCODE_AND_DISPATCH(); #endif #if WASM_ENABLE_TAIL_CALL != 0 - call_func_from_return_call: - POP(cur_func->param_cell_num); - word_copy(frame->lp, frame_sp, cur_func->param_cell_num); - FREE_FRAME(exec_env, frame); - wasm_exec_env_set_cur_frame(exec_env, - (WASMRuntimeFrame *)prev_frame); - goto call_func_from_entry; -#endif - call_func_from_interp: - /* Only do the copy when it's called from interpreter. */ + call_func_from_return_call: { - WASMInterpFrame *outs_area = wasm_exec_env_wasm_stack_top(exec_env); - POP(cur_func->param_cell_num); - SYNC_ALL_TO_FRAME(); - word_copy(outs_area->lp, frame_sp, cur_func->param_cell_num); - prev_frame = frame; + POP(cur_func->param_cell_num); + word_copy(frame->lp, frame_sp, cur_func->param_cell_num); + FREE_FRAME(exec_env, frame); + wasm_exec_env_set_cur_frame(exec_env, (WASMRuntimeFrame *)prev_frame); + goto call_func_from_entry; + } +#endif + call_func_from_interp: + { + /* Only do the copy when it's called from interpreter. */ + WASMInterpFrame *outs_area = wasm_exec_env_wasm_stack_top(exec_env); + POP(cur_func->param_cell_num); + SYNC_ALL_TO_FRAME(); + word_copy(outs_area->lp, frame_sp, cur_func->param_cell_num); + prev_frame = frame; } - call_func_from_entry: + call_func_from_entry: { - if (cur_func->is_import_func) { + if (cur_func->is_import_func) { #if WASM_ENABLE_MULTI_MODULE != 0 - if (cur_func->import_func_inst) { - wasm_interp_call_func_import(module, exec_env, cur_func, - prev_frame); - } - else + if (cur_func->import_func_inst) { + wasm_interp_call_func_import(module, exec_env, cur_func, + prev_frame); + } + else #endif - { - wasm_interp_call_func_native(module, exec_env, cur_func, - prev_frame); - } + { + wasm_interp_call_func_native(module, exec_env, cur_func, + prev_frame); + } - prev_frame = frame->prev_frame; - cur_func = frame->function; - UPDATE_ALL_FROM_FRAME(); + prev_frame = frame->prev_frame; + cur_func = frame->function; + UPDATE_ALL_FROM_FRAME(); - /* update memory instance ptr and memory size */ - memory = module->default_memory; - if (memory) - linear_mem_size = num_bytes_per_page * memory->cur_page_count; - if (wasm_get_exception(module)) - goto got_exception; - } - else { - WASMFunction *cur_wasm_func = cur_func->u.func; - WASMType *func_type; - - func_type = cur_wasm_func->func_type; - - all_cell_num = (uint64)cur_func->param_cell_num - + (uint64)cur_func->local_cell_num - + (uint64)cur_wasm_func->max_stack_cell_num - + ((uint64)cur_wasm_func->max_block_num) * sizeof(WASMBranchBlock) / 4; - if (all_cell_num >= UINT32_MAX) { - wasm_set_exception(module, "wasm operand stack overflow"); - goto got_exception; + /* update memory instance ptr and memory size */ + memory = module->default_memory; + if (memory) + linear_mem_size = num_bytes_per_page * memory->cur_page_count; + if (wasm_get_exception(module)) + goto got_exception; } + else { + WASMFunction *cur_wasm_func = cur_func->u.func; + WASMType *func_type; - frame_size = wasm_interp_interp_frame_size((uint32)all_cell_num); - if (!(frame = ALLOC_FRAME(exec_env, frame_size, prev_frame))) { - frame = prev_frame; - goto got_exception; - } + func_type = cur_wasm_func->func_type; - /* Initialize the interpreter context. */ - frame->function = cur_func; - frame_ip = wasm_get_func_code(cur_func); - frame_ip_end = wasm_get_func_code_end(cur_func); - frame_lp = frame->lp; + all_cell_num = (uint64)cur_func->param_cell_num + + (uint64)cur_func->local_cell_num + + (uint64)cur_wasm_func->max_stack_cell_num + + ((uint64)cur_wasm_func->max_block_num) + * sizeof(WASMBranchBlock) / 4; + if (all_cell_num >= UINT32_MAX) { + wasm_set_exception(module, "wasm operand stack overflow"); + goto got_exception; + } - frame_sp = frame->sp_bottom = frame_lp + cur_func->param_cell_num - + cur_func->local_cell_num; - frame->sp_boundary = frame->sp_bottom + cur_wasm_func->max_stack_cell_num; + frame_size = wasm_interp_interp_frame_size((uint32)all_cell_num); + if (!(frame = ALLOC_FRAME(exec_env, frame_size, prev_frame))) { + frame = prev_frame; + goto got_exception; + } - frame_csp = frame->csp_bottom = (WASMBranchBlock*)frame->sp_boundary; - frame->csp_boundary = frame->csp_bottom + cur_wasm_func->max_block_num; + /* Initialize the interpreter context. */ + frame->function = cur_func; + frame_ip = wasm_get_func_code(cur_func); + frame_ip_end = wasm_get_func_code_end(cur_func); + frame_lp = frame->lp; - /* Initialize the local varialbes */ - memset(frame_lp + cur_func->param_cell_num, 0, - (uint32)(cur_func->local_cell_num * 4)); + frame_sp = frame->sp_bottom = + frame_lp + cur_func->param_cell_num + cur_func->local_cell_num; + frame->sp_boundary = + frame->sp_bottom + cur_wasm_func->max_stack_cell_num; - /* Push function block as first block */ - cell_num = func_type->ret_cell_num; - PUSH_CSP(LABEL_TYPE_FUNCTION, cell_num, frame_ip_end - 1); + frame_csp = frame->csp_bottom = + (WASMBranchBlock *)frame->sp_boundary; + frame->csp_boundary = + frame->csp_bottom + cur_wasm_func->max_block_num; - wasm_exec_env_set_cur_frame(exec_env, (WASMRuntimeFrame*)frame); + /* Initialize the local varialbes */ + memset(frame_lp + cur_func->param_cell_num, 0, + (uint32)(cur_func->local_cell_num * 4)); + + /* Push function block as first block */ + cell_num = func_type->ret_cell_num; + PUSH_CSP(LABEL_TYPE_FUNCTION, cell_num, frame_ip_end - 1); + + wasm_exec_env_set_cur_frame(exec_env, (WASMRuntimeFrame *)frame); #if WASM_ENABLE_THREAD_MGR != 0 - CHECK_SUSPEND_FLAGS(); + CHECK_SUSPEND_FLAGS(); #endif - } - HANDLE_OP_END (); + } + HANDLE_OP_END(); } - return_func: + return_func: { - FREE_FRAME(exec_env, frame); - wasm_exec_env_set_cur_frame(exec_env, (WASMRuntimeFrame*)prev_frame); + FREE_FRAME(exec_env, frame); + wasm_exec_env_set_cur_frame(exec_env, (WASMRuntimeFrame *)prev_frame); - if (!prev_frame->ip) - /* Called from native. */ - return; + if (!prev_frame->ip) + /* Called from native. */ + return; - RECOVER_CONTEXT(prev_frame); - HANDLE_OP_END (); + RECOVER_CONTEXT(prev_frame); + HANDLE_OP_END(); } #if WASM_ENABLE_SHARED_MEMORY != 0 - unaligned_atomic: - wasm_set_exception(module, "unaligned atomic"); - goto got_exception; + unaligned_atomic: + wasm_set_exception(module, "unaligned atomic"); + goto got_exception; #endif - out_of_bounds: - wasm_set_exception(module, "out of bounds memory access"); + out_of_bounds: + wasm_set_exception(module, "out of bounds memory access"); - got_exception: - SYNC_ALL_TO_FRAME(); - return; + got_exception: + SYNC_ALL_TO_FRAME(); + return; #if WASM_ENABLE_LABELS_AS_VALUES == 0 - } + } #else - FETCH_OPCODE_AND_DISPATCH (); + FETCH_OPCODE_AND_DISPATCH(); #endif } void -wasm_interp_call_wasm(WASMModuleInstance *module_inst, - WASMExecEnv *exec_env, - WASMFunctionInstance *function, - uint32 argc, uint32 argv[]) +wasm_interp_call_wasm(WASMModuleInstance *module_inst, WASMExecEnv *exec_env, + WASMFunctionInstance *function, uint32 argc, + uint32 argv[]) { WASMRuntimeFrame *prev_frame = wasm_exec_env_get_cur_frame(exec_env); WASMInterpFrame *frame, *outs_area; /* Allocate sufficient cells for all kinds of return values. */ - unsigned all_cell_num = function->ret_cell_num > 2 ? - function->ret_cell_num : 2, i; + unsigned all_cell_num = + function->ret_cell_num > 2 ? function->ret_cell_num : 2, + i; /* This frame won't be used by JITed code, so only allocate interp frame here. */ unsigned frame_size = wasm_interp_interp_frame_size(all_cell_num); if (argc != function->param_cell_num) { char buf[128]; - snprintf(buf, sizeof(buf), - "invalid argument count %d, expected %d", + snprintf(buf, sizeof(buf), "invalid argument count %d, expected %d", argc, function->param_cell_num); wasm_set_exception(module_inst, buf); return; } - if ((uint8*)&prev_frame < exec_env->native_stack_boundary) { - wasm_set_exception((WASMModuleInstance*)exec_env->module_inst, + if ((uint8 *)&prev_frame < exec_env->native_stack_boundary) { + wasm_set_exception((WASMModuleInstance *)exec_env->module_inst, "native stack overflow"); return; } - if (!(frame = ALLOC_FRAME(exec_env, frame_size, (WASMInterpFrame*)prev_frame))) + if (!(frame = + ALLOC_FRAME(exec_env, frame_size, (WASMInterpFrame *)prev_frame))) return; outs_area = wasm_exec_env_wasm_stack_top(exec_env); @@ -3476,15 +3740,15 @@ wasm_interp_call_wasm(WASMModuleInstance *module_inst, if (function->is_import_func) { #if WASM_ENABLE_MULTI_MODULE != 0 if (function->import_module_inst) { - wasm_interp_call_func_import(module_inst, exec_env, - function, frame); + wasm_interp_call_func_import(module_inst, exec_env, function, + frame); } else #endif { /* it is a native function */ - wasm_interp_call_func_native(module_inst, exec_env, - function, frame); + wasm_interp_call_func_native(module_inst, exec_env, function, + frame); } } else { diff --git a/core/iwasm/interpreter/wasm_interp_fast.c b/core/iwasm/interpreter/wasm_interp_fast.c index ca32b8d3..b0e29e45 100644 --- a/core/iwasm/interpreter/wasm_interp_fast.c +++ b/core/iwasm/interpreter/wasm_interp_fast.c @@ -18,29 +18,33 @@ typedef int64 CellType_I64; typedef float32 CellType_F32; typedef float64 CellType_F64; -#define CHECK_MEMORY_OVERFLOW(bytes) do { \ - uint64 offset1 = (uint64)offset + (uint64)addr; \ - if (offset1 + bytes <= (uint64)linear_mem_size) \ - /* If offset1 is in valid range, maddr must also be in valid range,\ - no need to check it again. */ \ - maddr = memory->memory_data + offset1; \ - else \ - goto out_of_bounds; \ - } while (0) +#define CHECK_MEMORY_OVERFLOW(bytes) \ + do { \ + uint64 offset1 = (uint64)offset + (uint64)addr; \ + if (offset1 + bytes <= (uint64)linear_mem_size) \ + /* If offset1 is in valid range, maddr must also \ + be in valid range, no need to check it again. */ \ + maddr = memory->memory_data + offset1; \ + else \ + goto out_of_bounds; \ + } while (0) -#define CHECK_BULK_MEMORY_OVERFLOW(start, bytes, maddr) do { \ - uint64 offset1 = (uint32)(start); \ - if (offset1 + bytes <= linear_mem_size) \ - /* App heap space is not valid space for bulk memory operation */ \ - maddr = memory->memory_data + offset1; \ - else \ - goto out_of_bounds; \ - } while (0) +#define CHECK_BULK_MEMORY_OVERFLOW(start, bytes, maddr) \ + do { \ + uint64 offset1 = (uint32)(start); \ + if (offset1 + bytes <= linear_mem_size) \ + /* App heap space is not valid space for \ + bulk memory operation */ \ + maddr = memory->memory_data + offset1; \ + else \ + goto out_of_bounds; \ + } while (0) -#define CHECK_ATOMIC_MEMORY_ACCESS(align) do { \ - if (((uintptr_t)maddr & (align - 1)) != 0) \ - goto unaligned_atomic; \ - } while (0) +#define CHECK_ATOMIC_MEMORY_ACCESS(align) \ + do { \ + if (((uintptr_t)maddr & (align - 1)) != 0) \ + goto unaligned_atomic; \ + } while (0) static inline uint32 rotl32(uint32 n, uint32 c) @@ -82,7 +86,7 @@ static inline double wa_fmax(double a, double b) { double c = fmax(a, b); - if (c==0 && a==b) + if (c == 0 && a == b) return signbit(a) ? b : a; return c; } @@ -91,7 +95,7 @@ static inline double wa_fmin(double a, double b) { double c = fmin(a, b); - if (c==0 && a==b) + if (c == 0 && a == b) return signbit(a) ? a : b; return c; } @@ -171,41 +175,48 @@ popcount64(uint64 u) } #if WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS != 0 -#define LOAD_U32_WITH_2U16S(addr) (*(uint32*)(addr)) -#define LOAD_PTR(addr) (*(void**)(addr)) +#define LOAD_U32_WITH_2U16S(addr) (*(uint32 *)(addr)) +#define LOAD_PTR(addr) (*(void **)(addr)) #else /* else of WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS */ static inline uint32 LOAD_U32_WITH_2U16S(void *addr) { - union { uint32 val; uint16 u16[2]; } u; + union { + uint32 val; + uint16 u16[2]; + } u; bh_assert(((uintptr_t)addr & 1) == 0); - u.u16[0] = ((uint16*)addr)[0]; - u.u16[1] = ((uint16*)addr)[1]; + u.u16[0] = ((uint16 *)addr)[0]; + u.u16[1] = ((uint16 *)addr)[1]; return u.val; } #if UINTPTR_MAX == UINT32_MAX -#define LOAD_PTR(addr) ((void*)LOAD_U32_WITH_2U16S(addr)) +#define LOAD_PTR(addr) ((void *)LOAD_U32_WITH_2U16S(addr)) #elif UINTPTR_MAX == UINT64_MAX static inline void * LOAD_PTR(void *addr) { uintptr_t addr1 = (uintptr_t)addr; - union { void *val; uint32 u32[2]; uint16 u16[4]; } u; + union { + void *val; + uint32 u32[2]; + uint16 u16[4]; + } u; bh_assert(((uintptr_t)addr & 1) == 0); if ((addr1 & (uintptr_t)7) == 0) - return *(void**)addr; + return *(void **)addr; if ((addr1 & (uintptr_t)3) == 0) { - u.u32[0] = ((uint32*)addr)[0]; - u.u32[1] = ((uint32*)addr)[1]; + u.u32[0] = ((uint32 *)addr)[0]; + u.u32[1] = ((uint32 *)addr)[1]; } else { - u.u16[0] = ((uint16*)addr)[0]; - u.u16[1] = ((uint16*)addr)[1]; - u.u16[2] = ((uint16*)addr)[2]; - u.u16[3] = ((uint16*)addr)[3]; + u.u16[0] = ((uint16 *)addr)[0]; + u.u16[1] = ((uint16 *)addr)[1]; + u.u16[2] = ((uint16 *)addr)[2]; + u.u16[3] = ((uint16 *)addr)[3]; } return u.val; } @@ -215,271 +226,289 @@ LOAD_PTR(void *addr) #define read_uint32(p) \ (p += sizeof(uint32), LOAD_U32_WITH_2U16S(p - sizeof(uint32))) -#define GET_LOCAL_INDEX_TYPE_AND_OFFSET() do { \ - uint32 param_count = cur_func->param_count; \ - local_idx = read_uint32(frame_ip); \ - bh_assert(local_idx < param_count + cur_func->local_count); \ - local_offset = cur_func->local_offsets[local_idx]; \ - if (local_idx < param_count) \ - local_type = cur_func->param_types[local_idx]; \ - else \ - local_type = cur_func->local_types[local_idx - param_count]; \ - } while (0) +#define GET_LOCAL_INDEX_TYPE_AND_OFFSET() \ + do { \ + uint32 param_count = cur_func->param_count; \ + local_idx = read_uint32(frame_ip); \ + bh_assert(local_idx < param_count + cur_func->local_count); \ + local_offset = cur_func->local_offsets[local_idx]; \ + if (local_idx < param_count) \ + local_type = cur_func->param_types[local_idx]; \ + else \ + local_type = cur_func->local_types[local_idx - param_count]; \ + } while (0) -#define GET_OFFSET() (frame_ip += 2, *(int16*)(frame_ip - 2)) +#define GET_OFFSET() (frame_ip += 2, *(int16 *)(frame_ip - 2)) -#define SET_OPERAND_I32(off, value) do { \ - *(uint32*)(frame_lp + *(int16*)(frame_ip + off)) = value; \ - } while (0) -#define SET_OPERAND_F32(off, value) do { \ - *(float32*)(frame_lp + *(int16*)(frame_ip + off)) = value; \ - } while (0) -#define SET_OPERAND_I64(off, value) do { \ - uint32 *addr_tmp = frame_lp + *(int16*)(frame_ip + off); \ - PUT_I64_TO_ADDR(addr_tmp, value); \ - } while (0) -#define SET_OPERAND_F64(off, value) do { \ - uint32 *addr_tmp = frame_lp + *(int16*)(frame_ip + off); \ - PUT_F64_TO_ADDR(addr_tmp, value); \ - } while (0) +#define SET_OPERAND_I32(off, value) \ + do { \ + *(uint32 *)(frame_lp + *(int16 *)(frame_ip + off)) = value; \ + } while (0) +#define SET_OPERAND_F32(off, value) \ + do { \ + *(float32 *)(frame_lp + *(int16 *)(frame_ip + off)) = value; \ + } while (0) +#define SET_OPERAND_I64(off, value) \ + do { \ + uint32 *addr_tmp = frame_lp + *(int16 *)(frame_ip + off); \ + PUT_I64_TO_ADDR(addr_tmp, value); \ + } while (0) +#define SET_OPERAND_F64(off, value) \ + do { \ + uint32 *addr_tmp = frame_lp + *(int16 *)(frame_ip + off); \ + PUT_F64_TO_ADDR(addr_tmp, value); \ + } while (0) #define SET_OPERAND(op_type, off, value) SET_OPERAND_##op_type(off, value) -#define GET_OPERAND_I32(type, off) \ - *(type*)(frame_lp + *(int16*)(frame_ip + off)) -#define GET_OPERAND_F32(type, off) \ - *(type*)(frame_lp + *(int16*)(frame_ip + off)) -#define GET_OPERAND_I64(type, off) \ - (type)GET_I64_FROM_ADDR(frame_lp + *(int16*)(frame_ip + off)) -#define GET_OPERAND_F64(type, off) \ - (type)GET_F64_FROM_ADDR(frame_lp + *(int16*)(frame_ip + off)) +#define GET_OPERAND_I32(type, off) \ + *(type *)(frame_lp + *(int16 *)(frame_ip + off)) +#define GET_OPERAND_F32(type, off) \ + *(type *)(frame_lp + *(int16 *)(frame_ip + off)) +#define GET_OPERAND_I64(type, off) \ + (type) GET_I64_FROM_ADDR(frame_lp + *(int16 *)(frame_ip + off)) +#define GET_OPERAND_F64(type, off) \ + (type) GET_F64_FROM_ADDR(frame_lp + *(int16 *)(frame_ip + off)) #define GET_OPERAND(type, op_type, off) GET_OPERAND_##op_type(type, off) -#define PUSH_I32(value) do { \ - *(int32*)(frame_lp + GET_OFFSET()) = value; \ - } while (0) +#define PUSH_I32(value) \ + do { \ + *(int32 *)(frame_lp + GET_OFFSET()) = value; \ + } while (0) -#define PUSH_F32(value) do { \ - *(float32*)(frame_lp + GET_OFFSET()) = value; \ - } while (0) +#define PUSH_F32(value) \ + do { \ + *(float32 *)(frame_lp + GET_OFFSET()) = value; \ + } while (0) -#define PUSH_I64(value) do { \ - uint32 *addr_tmp = frame_lp + GET_OFFSET(); \ - PUT_I64_TO_ADDR(addr_tmp, value); \ - } while (0) +#define PUSH_I64(value) \ + do { \ + uint32 *addr_tmp = frame_lp + GET_OFFSET(); \ + PUT_I64_TO_ADDR(addr_tmp, value); \ + } while (0) -#define PUSH_F64(value) do { \ - uint32 *addr_tmp = frame_lp + GET_OFFSET(); \ - PUT_F64_TO_ADDR(addr_tmp, value); \ - } while (0) +#define PUSH_F64(value) \ + do { \ + uint32 *addr_tmp = frame_lp + GET_OFFSET(); \ + PUT_F64_TO_ADDR(addr_tmp, value); \ + } while (0) -#define POP_I32() (*(int32*)(frame_lp + GET_OFFSET())) +#define POP_I32() (*(int32 *)(frame_lp + GET_OFFSET())) -#define POP_F32() (*(float32*)(frame_lp + GET_OFFSET())) +#define POP_F32() (*(float32 *)(frame_lp + GET_OFFSET())) #define POP_I64() (GET_I64_FROM_ADDR(frame_lp + GET_OFFSET())) #define POP_F64() (GET_F64_FROM_ADDR(frame_lp + GET_OFFSET())) -#define SYNC_ALL_TO_FRAME() do { \ - frame->ip = frame_ip; \ - } while (0) +#define SYNC_ALL_TO_FRAME() \ + do { \ + frame->ip = frame_ip; \ + } while (0) -#define UPDATE_ALL_FROM_FRAME() do { \ - frame_ip = frame->ip; \ - } while (0) +#define UPDATE_ALL_FROM_FRAME() \ + do { \ + frame_ip = frame->ip; \ + } while (0) #if WASM_ENABLE_LABELS_AS_VALUES != 0 #define UPDATE_FRAME_IP_END() (void)0 #else -#define UPDATE_FRAME_IP_END() \ - frame_ip_end = wasm_get_func_code_end(cur_func) +#define UPDATE_FRAME_IP_END() frame_ip_end = wasm_get_func_code_end(cur_func) #endif -#define RECOVER_CONTEXT(new_frame) do { \ - frame = (new_frame); \ - cur_func = frame->function; \ - prev_frame = frame->prev_frame; \ - frame_ip = frame->ip; \ - UPDATE_FRAME_IP_END(); \ - frame_lp = frame->lp; \ - } while (0) +#define RECOVER_CONTEXT(new_frame) \ + do { \ + frame = (new_frame); \ + cur_func = frame->function; \ + prev_frame = frame->prev_frame; \ + frame_ip = frame->ip; \ + UPDATE_FRAME_IP_END(); \ + frame_lp = frame->lp; \ + } while (0) #if WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS != 0 #define GET_OPCODE() opcode = *frame_ip++; #else -#define GET_OPCODE() opcode = *frame_ip; frame_ip += 2; +#define GET_OPCODE() \ + opcode = *frame_ip; \ + frame_ip += 2; #endif -#define DEF_OP_EQZ(ctype, src_op_type) do { \ - SET_OPERAND(I32, 2, (GET_OPERAND(ctype, src_op_type, 0) == 0)); \ - frame_ip += 4; \ - } while (0) +#define DEF_OP_EQZ(ctype, src_op_type) \ + do { \ + SET_OPERAND(I32, 2, (GET_OPERAND(ctype, src_op_type, 0) == 0)); \ + frame_ip += 4; \ + } while (0) -#define DEF_OP_CMP(src_type, src_op_type, cond) do { \ - SET_OPERAND(I32, 4, GET_OPERAND(src_type, src_op_type, 2) cond \ - GET_OPERAND(src_type, src_op_type, 0)); \ - frame_ip += 6; \ - } while (0) +#define DEF_OP_CMP(src_type, src_op_type, cond) \ + do { \ + SET_OPERAND(I32, 4, \ + GET_OPERAND(src_type, src_op_type, 2) \ + cond GET_OPERAND(src_type, src_op_type, 0)); \ + frame_ip += 6; \ + } while (0) -#define DEF_OP_BIT_COUNT(src_type, src_op_type, operation) do { \ - SET_OPERAND(src_op_type, 2, (src_type)operation( \ - GET_OPERAND(src_type, src_op_type, 0))); \ - frame_ip += 4; \ - } while (0) +#define DEF_OP_BIT_COUNT(src_type, src_op_type, operation) \ + do { \ + SET_OPERAND( \ + src_op_type, 2, \ + (src_type)operation(GET_OPERAND(src_type, src_op_type, 0))); \ + frame_ip += 4; \ + } while (0) -#define DEF_OP_NUMERIC(src_type1, src_type2, \ - src_op_type, operation) do { \ - SET_OPERAND(src_op_type, 4, \ - GET_OPERAND(src_type1, src_op_type, 2) operation \ - GET_OPERAND(src_type2, src_op_type, 0)); \ - frame_ip += 6; \ - } while (0) +#define DEF_OP_NUMERIC(src_type1, src_type2, src_op_type, operation) \ + do { \ + SET_OPERAND(src_op_type, 4, \ + GET_OPERAND(src_type1, src_op_type, 2) \ + operation GET_OPERAND(src_type2, src_op_type, 0)); \ + frame_ip += 6; \ + } while (0) -#define DEF_OP_REINTERPRET(src_type, src_op_type) do { \ - SET_OPERAND(src_op_type, 2, \ - GET_OPERAND(src_type, src_op_type, 0)); \ - frame_ip += 4; \ - } while (0) +#define DEF_OP_REINTERPRET(src_type, src_op_type) \ + do { \ + SET_OPERAND(src_op_type, 2, GET_OPERAND(src_type, src_op_type, 0)); \ + frame_ip += 4; \ + } while (0) #define DEF_OP_NUMERIC_64 DEF_OP_NUMERIC -#define DEF_OP_NUMERIC2(src_type1, src_type2, \ - src_op_type, operation) do { \ - SET_OPERAND(src_op_type, 4, \ - GET_OPERAND(src_type1, src_op_type, 2) operation \ - (GET_OPERAND(src_type2, src_op_type, 0) % 32)); \ - frame_ip += 6; \ - } while (0) +#define DEF_OP_NUMERIC2(src_type1, src_type2, src_op_type, operation) \ + do { \ + SET_OPERAND(src_op_type, 4, \ + GET_OPERAND(src_type1, src_op_type, 2) operation( \ + GET_OPERAND(src_type2, src_op_type, 0) % 32)); \ + frame_ip += 6; \ + } while (0) -#define DEF_OP_NUMERIC2_64(src_type1, src_type2, \ - src_op_type, operation) do { \ - SET_OPERAND(src_op_type, 4, \ - GET_OPERAND(src_type1, src_op_type, 2) operation \ - (GET_OPERAND(src_type2, src_op_type, 0) % 64)); \ - frame_ip += 6; \ - } while (0) +#define DEF_OP_NUMERIC2_64(src_type1, src_type2, src_op_type, operation) \ + do { \ + SET_OPERAND(src_op_type, 4, \ + GET_OPERAND(src_type1, src_op_type, 2) operation( \ + GET_OPERAND(src_type2, src_op_type, 0) % 64)); \ + frame_ip += 6; \ + } while (0) -#define DEF_ATOMIC_RMW_OPCODE(OP_NAME, op) \ - case WASM_OP_ATOMIC_RMW_I32_##OP_NAME: \ - case WASM_OP_ATOMIC_RMW_I32_##OP_NAME##8_U: \ - case WASM_OP_ATOMIC_RMW_I32_##OP_NAME##16_U: \ - { \ - uint32 readv, sval; \ - \ - sval = POP_I32(); \ - addr = POP_I32(); \ - \ - if (opcode == WASM_OP_ATOMIC_RMW_I32_##OP_NAME##8_U) { \ - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); \ - CHECK_ATOMIC_MEMORY_ACCESS(1); \ - \ - os_mutex_lock(&memory->mem_lock); \ - readv = (uint32)(*(uint8*)maddr); \ - *(uint8*)maddr = (uint8)(readv op sval); \ - os_mutex_unlock(&memory->mem_lock); \ - } \ - else if (opcode == WASM_OP_ATOMIC_RMW_I32_##OP_NAME##16_U) { \ - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); \ - CHECK_ATOMIC_MEMORY_ACCESS(2); \ - \ - os_mutex_lock(&memory->mem_lock); \ - readv = (uint32)LOAD_U16(maddr); \ - STORE_U16(maddr, (uint16)(readv op sval)); \ - os_mutex_unlock(&memory->mem_lock); \ - } \ - else { \ - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); \ - CHECK_ATOMIC_MEMORY_ACCESS(4); \ - \ - os_mutex_lock(&memory->mem_lock); \ - readv = LOAD_I32(maddr); \ - STORE_U32(maddr, readv op sval); \ - os_mutex_unlock(&memory->mem_lock); \ - } \ - PUSH_I32(readv); \ - break; \ - } \ - case WASM_OP_ATOMIC_RMW_I64_##OP_NAME: \ - case WASM_OP_ATOMIC_RMW_I64_##OP_NAME##8_U: \ - case WASM_OP_ATOMIC_RMW_I64_##OP_NAME##16_U: \ - case WASM_OP_ATOMIC_RMW_I64_##OP_NAME##32_U: \ - { \ - uint64 readv, sval; \ - \ - sval = (uint64)POP_I64(); \ - addr = POP_I32(); \ - \ - if (opcode == WASM_OP_ATOMIC_RMW_I64_##OP_NAME##8_U) { \ - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); \ - CHECK_ATOMIC_MEMORY_ACCESS(1); \ - \ - os_mutex_lock(&memory->mem_lock); \ - readv = (uint64)(*(uint8*)maddr); \ - *(uint8*)maddr = (uint8)(readv op sval); \ - os_mutex_unlock(&memory->mem_lock); \ - } \ - else if (opcode == WASM_OP_ATOMIC_RMW_I64_##OP_NAME##16_U) { \ - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); \ - CHECK_ATOMIC_MEMORY_ACCESS(2); \ - \ - os_mutex_lock(&memory->mem_lock); \ - readv = (uint64)LOAD_U16(maddr); \ - STORE_U16(maddr, (uint16)(readv op sval)); \ - os_mutex_unlock(&memory->mem_lock); \ - } \ - else if (opcode == WASM_OP_ATOMIC_RMW_I64_##OP_NAME##32_U) { \ - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); \ - CHECK_ATOMIC_MEMORY_ACCESS(4); \ - \ - os_mutex_lock(&memory->mem_lock); \ - readv = (uint64)LOAD_U32(maddr); \ - STORE_U32(maddr, (uint32)(readv op sval)); \ - os_mutex_unlock(&memory->mem_lock); \ - } \ - else { \ - uint64 op_result; \ - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 8, maddr); \ - CHECK_ATOMIC_MEMORY_ACCESS(8); \ - \ - os_mutex_lock(&memory->mem_lock); \ - readv = (uint64)LOAD_I64(maddr); \ - op_result = readv op sval; \ - STORE_I64(maddr, op_result); \ - os_mutex_unlock(&memory->mem_lock); \ - } \ - PUSH_I64(readv); \ - break; \ - } +#define DEF_ATOMIC_RMW_OPCODE(OP_NAME, op) \ + case WASM_OP_ATOMIC_RMW_I32_##OP_NAME: \ + case WASM_OP_ATOMIC_RMW_I32_##OP_NAME##8_U: \ + case WASM_OP_ATOMIC_RMW_I32_##OP_NAME##16_U: \ + { \ + uint32 readv, sval; \ + \ + sval = POP_I32(); \ + addr = POP_I32(); \ + \ + if (opcode == WASM_OP_ATOMIC_RMW_I32_##OP_NAME##8_U) { \ + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); \ + CHECK_ATOMIC_MEMORY_ACCESS(1); \ + \ + os_mutex_lock(&memory->mem_lock); \ + readv = (uint32)(*(uint8 *)maddr); \ + *(uint8 *)maddr = (uint8)(readv op sval); \ + os_mutex_unlock(&memory->mem_lock); \ + } \ + else if (opcode == WASM_OP_ATOMIC_RMW_I32_##OP_NAME##16_U) { \ + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); \ + CHECK_ATOMIC_MEMORY_ACCESS(2); \ + \ + os_mutex_lock(&memory->mem_lock); \ + readv = (uint32)LOAD_U16(maddr); \ + STORE_U16(maddr, (uint16)(readv op sval)); \ + os_mutex_unlock(&memory->mem_lock); \ + } \ + else { \ + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); \ + CHECK_ATOMIC_MEMORY_ACCESS(4); \ + \ + os_mutex_lock(&memory->mem_lock); \ + readv = LOAD_I32(maddr); \ + STORE_U32(maddr, readv op sval); \ + os_mutex_unlock(&memory->mem_lock); \ + } \ + PUSH_I32(readv); \ + break; \ + } \ + case WASM_OP_ATOMIC_RMW_I64_##OP_NAME: \ + case WASM_OP_ATOMIC_RMW_I64_##OP_NAME##8_U: \ + case WASM_OP_ATOMIC_RMW_I64_##OP_NAME##16_U: \ + case WASM_OP_ATOMIC_RMW_I64_##OP_NAME##32_U: \ + { \ + uint64 readv, sval; \ + \ + sval = (uint64)POP_I64(); \ + addr = POP_I32(); \ + \ + if (opcode == WASM_OP_ATOMIC_RMW_I64_##OP_NAME##8_U) { \ + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); \ + CHECK_ATOMIC_MEMORY_ACCESS(1); \ + \ + os_mutex_lock(&memory->mem_lock); \ + readv = (uint64)(*(uint8 *)maddr); \ + *(uint8 *)maddr = (uint8)(readv op sval); \ + os_mutex_unlock(&memory->mem_lock); \ + } \ + else if (opcode == WASM_OP_ATOMIC_RMW_I64_##OP_NAME##16_U) { \ + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); \ + CHECK_ATOMIC_MEMORY_ACCESS(2); \ + \ + os_mutex_lock(&memory->mem_lock); \ + readv = (uint64)LOAD_U16(maddr); \ + STORE_U16(maddr, (uint16)(readv op sval)); \ + os_mutex_unlock(&memory->mem_lock); \ + } \ + else if (opcode == WASM_OP_ATOMIC_RMW_I64_##OP_NAME##32_U) { \ + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); \ + CHECK_ATOMIC_MEMORY_ACCESS(4); \ + \ + os_mutex_lock(&memory->mem_lock); \ + readv = (uint64)LOAD_U32(maddr); \ + STORE_U32(maddr, (uint32)(readv op sval)); \ + os_mutex_unlock(&memory->mem_lock); \ + } \ + else { \ + uint64 op_result; \ + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 8, maddr); \ + CHECK_ATOMIC_MEMORY_ACCESS(8); \ + \ + os_mutex_lock(&memory->mem_lock); \ + readv = (uint64)LOAD_I64(maddr); \ + op_result = readv op sval; \ + STORE_I64(maddr, op_result); \ + os_mutex_unlock(&memory->mem_lock); \ + } \ + PUSH_I64(readv); \ + break; \ + } -#define DEF_OP_MATH(src_type, src_op_type, method) do { \ - SET_OPERAND(src_op_type, 2, \ - (src_type)method(GET_OPERAND(src_type, \ - src_op_type, 0))); \ - frame_ip += 4; \ - } while (0) +#define DEF_OP_MATH(src_type, src_op_type, method) \ + do { \ + SET_OPERAND(src_op_type, 2, \ + (src_type)method(GET_OPERAND(src_type, src_op_type, 0))); \ + frame_ip += 4; \ + } while (0) #define TRUNC_FUNCTION(func_name, src_type, dst_type, signed_type) \ -static dst_type \ -func_name(src_type src_value, src_type src_min, src_type src_max, \ - dst_type dst_min, dst_type dst_max, bool is_sign) \ -{ \ - dst_type dst_value = 0; \ - if (!isnan(src_value)) { \ - if (src_value <= src_min) \ - dst_value = dst_min; \ - else if (src_value >= src_max) \ - dst_value = dst_max; \ - else { \ - if (is_sign) \ - dst_value = (dst_type)(signed_type)src_value; \ - else \ - dst_value = (dst_type)src_value; \ - } \ - } \ - return dst_value; \ -} + static dst_type func_name(src_type src_value, src_type src_min, \ + src_type src_max, dst_type dst_min, \ + dst_type dst_max, bool is_sign) \ + { \ + dst_type dst_value = 0; \ + if (!isnan(src_value)) { \ + if (src_value <= src_min) \ + dst_value = dst_min; \ + else if (src_value >= src_max) \ + dst_value = dst_max; \ + else { \ + if (is_sign) \ + dst_value = (dst_type)(signed_type)src_value; \ + else \ + dst_value = (dst_type)src_value; \ + } \ + } \ + return dst_value; \ + } TRUNC_FUNCTION(trunc_f32_to_i32, float32, uint32, int32) TRUNC_FUNCTION(trunc_f32_to_i64, float32, uint64, int64) @@ -487,10 +516,9 @@ TRUNC_FUNCTION(trunc_f64_to_i32, float64, uint32, int32) TRUNC_FUNCTION(trunc_f64_to_i64, float64, uint64, int64) static bool -trunc_f32_to_int(WASMModuleInstance *module, - uint8 *frame_ip, uint32 *frame_lp, - float32 src_min, float32 src_max, - bool saturating, bool is_i32, bool is_sign) +trunc_f32_to_int(WASMModuleInstance *module, uint8 *frame_ip, uint32 *frame_lp, + float32 src_min, float32 src_max, bool saturating, bool is_i32, + bool is_sign) { float32 src_value = GET_OPERAND(float32, F32, 0); uint64 dst_value_i64; @@ -510,25 +538,24 @@ trunc_f32_to_int(WASMModuleInstance *module, if (is_i32) { uint32 dst_min = is_sign ? INT32_MIN : 0; uint32 dst_max = is_sign ? INT32_MAX : UINT32_MAX; - dst_value_i32 = trunc_f32_to_i32(src_value, src_min, src_max, - dst_min, dst_max, is_sign); + dst_value_i32 = trunc_f32_to_i32(src_value, src_min, src_max, dst_min, + dst_max, is_sign); SET_OPERAND(I32, 2, dst_value_i32); } else { uint64 dst_min = is_sign ? INT64_MIN : 0; uint64 dst_max = is_sign ? INT64_MAX : UINT64_MAX; - dst_value_i64 = trunc_f32_to_i64(src_value, src_min, src_max, - dst_min, dst_max, is_sign); + dst_value_i64 = trunc_f32_to_i64(src_value, src_min, src_max, dst_min, + dst_max, is_sign); SET_OPERAND(I64, 2, dst_value_i64); } return false; } static bool -trunc_f64_to_int(WASMModuleInstance *module, - uint8 *frame_ip, uint32 *frame_lp, - float64 src_min, float64 src_max, - bool saturating, bool is_i32, bool is_sign) +trunc_f64_to_int(WASMModuleInstance *module, uint8 *frame_ip, uint32 *frame_lp, + float64 src_min, float64 src_max, bool saturating, bool is_i32, + bool is_sign) { float64 src_value = GET_OPERAND(float64, F64, 0); uint64 dst_value_i64; @@ -548,51 +575,55 @@ trunc_f64_to_int(WASMModuleInstance *module, if (is_i32) { uint32 dst_min = is_sign ? INT32_MIN : 0; uint32 dst_max = is_sign ? INT32_MAX : UINT32_MAX; - dst_value_i32 = trunc_f64_to_i32(src_value, src_min, src_max, - dst_min, dst_max, is_sign); + dst_value_i32 = trunc_f64_to_i32(src_value, src_min, src_max, dst_min, + dst_max, is_sign); SET_OPERAND(I32, 2, dst_value_i32); } else { uint64 dst_min = is_sign ? INT64_MIN : 0; uint64 dst_max = is_sign ? INT64_MAX : UINT64_MAX; - dst_value_i64 = trunc_f64_to_i64(src_value, src_min, src_max, - dst_min, dst_max, is_sign); + dst_value_i64 = trunc_f64_to_i64(src_value, src_min, src_max, dst_min, + dst_max, is_sign); SET_OPERAND(I64, 2, dst_value_i64); } return false; } -#define DEF_OP_TRUNC_F32(min, max, is_i32, is_sign) do { \ - if (trunc_f32_to_int(module, frame_ip, frame_lp, min, max, \ - false, is_i32, is_sign)) \ - goto got_exception; \ - frame_ip += 4; \ - } while (0) +#define DEF_OP_TRUNC_F32(min, max, is_i32, is_sign) \ + do { \ + if (trunc_f32_to_int(module, frame_ip, frame_lp, min, max, false, \ + is_i32, is_sign)) \ + goto got_exception; \ + frame_ip += 4; \ + } while (0) -#define DEF_OP_TRUNC_F64(min, max, is_i32, is_sign) do { \ - if (trunc_f64_to_int(module, frame_ip, frame_lp, min, max, \ - false, is_i32, is_sign)) \ - goto got_exception; \ - frame_ip += 4; \ - } while (0) +#define DEF_OP_TRUNC_F64(min, max, is_i32, is_sign) \ + do { \ + if (trunc_f64_to_int(module, frame_ip, frame_lp, min, max, false, \ + is_i32, is_sign)) \ + goto got_exception; \ + frame_ip += 4; \ + } while (0) -#define DEF_OP_TRUNC_SAT_F32(min, max, is_i32, is_sign) do { \ - (void)trunc_f32_to_int(module, frame_ip, frame_lp, min, max, \ - true, is_i32, is_sign); \ - frame_ip += 4; \ - } while (0) +#define DEF_OP_TRUNC_SAT_F32(min, max, is_i32, is_sign) \ + do { \ + (void)trunc_f32_to_int(module, frame_ip, frame_lp, min, max, true, \ + is_i32, is_sign); \ + frame_ip += 4; \ + } while (0) -#define DEF_OP_TRUNC_SAT_F64(min, max, is_i32, is_sign) do { \ - (void)trunc_f64_to_int(module, frame_ip, frame_lp, min, max, \ - true, is_i32, is_sign); \ - frame_ip += 4; \ - } while (0) +#define DEF_OP_TRUNC_SAT_F64(min, max, is_i32, is_sign) \ + do { \ + (void)trunc_f64_to_int(module, frame_ip, frame_lp, min, max, true, \ + is_i32, is_sign); \ + frame_ip += 4; \ + } while (0) -#define DEF_OP_CONVERT(dst_type, dst_op_type, \ - src_type, src_op_type) do { \ - dst_type value = (dst_type)(src_type)POP_##src_op_type(); \ - PUSH_##dst_op_type(value); \ - } while (0) +#define DEF_OP_CONVERT(dst_type, dst_op_type, src_type, src_op_type) \ + do { \ + dst_type value = (dst_type)(src_type)POP_##src_op_type(); \ + PUSH_##dst_op_type(value); \ + } while (0) #if WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS != 0 #define CELL_SIZE sizeof(uint8) @@ -601,120 +632,117 @@ trunc_f64_to_int(WASMModuleInstance *module, #endif static bool -copy_stack_values(WASMModuleInstance *module, uint32 *frame_lp, - uint32 arity, uint32 total_cell_num, const uint8 *cells, +copy_stack_values(WASMModuleInstance *module, uint32 *frame_lp, uint32 arity, + uint32 total_cell_num, const uint8 *cells, const int16 *src_offsets, const uint16 *dst_offsets) { - /* To avoid the overlap issue between src offsets and dst offset, - * we use 2 steps to do the copy. First step, copy the src values - * to a tmp buf. Second step, copy the values from tmp buf to dst. - */ - uint32 buf[16] = {0}, i; - uint32 *tmp_buf = buf; - uint8 cell; - int16 src, buf_index = 0; - uint16 dst; + /* To avoid the overlap issue between src offsets and dst offset, + * we use 2 steps to do the copy. First step, copy the src values + * to a tmp buf. Second step, copy the values from tmp buf to dst. + */ + uint32 buf[16] = { 0 }, i; + uint32 *tmp_buf = buf; + uint8 cell; + int16 src, buf_index = 0; + uint16 dst; - /* Allocate memory if the buf is not large enough */ - if (total_cell_num > sizeof(buf)/sizeof(uint32)) { - uint64 total_size = sizeof(uint32) * (uint64)total_cell_num; - if (total_size >= UINT32_MAX - || !(tmp_buf = wasm_runtime_malloc((uint32)total_size))) { - wasm_set_exception(module, "allocate memory failed"); - return false; + /* Allocate memory if the buf is not large enough */ + if (total_cell_num > sizeof(buf) / sizeof(uint32)) { + uint64 total_size = sizeof(uint32) * (uint64)total_cell_num; + if (total_size >= UINT32_MAX + || !(tmp_buf = wasm_runtime_malloc((uint32)total_size))) { + wasm_set_exception(module, "allocate memory failed"); + return false; + } } - } - /* 1) Copy values from src to tmp buf */ - for (i = 0; i < arity; i++) { - cell = cells[i * CELL_SIZE]; - src = src_offsets[i]; - if (cell == 1) - tmp_buf[buf_index] = frame_lp[src]; - else { - tmp_buf[buf_index] = frame_lp[src]; - tmp_buf[buf_index + 1] = frame_lp[src + 1]; + /* 1) Copy values from src to tmp buf */ + for (i = 0; i < arity; i++) { + cell = cells[i * CELL_SIZE]; + src = src_offsets[i]; + if (cell == 1) + tmp_buf[buf_index] = frame_lp[src]; + else { + tmp_buf[buf_index] = frame_lp[src]; + tmp_buf[buf_index + 1] = frame_lp[src + 1]; + } + buf_index += cell; } - buf_index += cell; - } - /* 2) Copy values from tmp buf to dest */ - buf_index = 0; - for (i = 0; i < arity; i++) { - cell = cells[i * CELL_SIZE]; - dst = dst_offsets[i]; - if (cell == 1) - frame_lp[dst] = tmp_buf[buf_index]; - else { - frame_lp[dst] = tmp_buf[buf_index]; - frame_lp[dst + 1] = tmp_buf[buf_index + 1]; + /* 2) Copy values from tmp buf to dest */ + buf_index = 0; + for (i = 0; i < arity; i++) { + cell = cells[i * CELL_SIZE]; + dst = dst_offsets[i]; + if (cell == 1) + frame_lp[dst] = tmp_buf[buf_index]; + else { + frame_lp[dst] = tmp_buf[buf_index]; + frame_lp[dst + 1] = tmp_buf[buf_index + 1]; + } + buf_index += cell; } - buf_index += cell; - } - if (tmp_buf != buf) { - wasm_runtime_free(tmp_buf); - } + if (tmp_buf != buf) { + wasm_runtime_free(tmp_buf); + } - return true; + return true; } -#define RECOVER_BR_INFO() do { \ - uint32 arity; \ - /* read arity */ \ - arity = read_uint32(frame_ip); \ - if (arity) { \ - uint32 total_cell; \ - uint16 *dst_offsets = NULL; \ - uint8 *cells; \ - int16 *src_offsets = NULL; \ - /* read total cell num */ \ - total_cell = read_uint32(frame_ip); \ - /* cells */ \ - cells = (uint8 *)frame_ip; \ - frame_ip += arity * CELL_SIZE; \ - /* src offsets */ \ - src_offsets = (int16 *)frame_ip; \ - frame_ip += arity * sizeof(int16); \ - /* dst offsets */ \ - dst_offsets = (uint16*)frame_ip; \ - frame_ip += arity * sizeof(uint16); \ - if (arity == 1) { \ - if (cells[0] == 1) \ - frame_lp[dst_offsets[0]] = \ - frame_lp[src_offsets[0]]; \ - else if (cells[0] == 2) { \ - frame_lp[dst_offsets[0]] = \ - frame_lp[src_offsets[0]]; \ - frame_lp[dst_offsets[0] + 1] = \ - frame_lp[src_offsets[0] + 1]; \ - } \ - } \ - else { \ - if (!copy_stack_values(module, frame_lp, \ - arity, total_cell, \ - cells, src_offsets, \ - dst_offsets)) \ - goto got_exception; \ - } \ - } \ - frame_ip = (uint8*)LOAD_PTR(frame_ip); \ - } while (0) +#define RECOVER_BR_INFO() \ + do { \ + uint32 arity; \ + /* read arity */ \ + arity = read_uint32(frame_ip); \ + if (arity) { \ + uint32 total_cell; \ + uint16 *dst_offsets = NULL; \ + uint8 *cells; \ + int16 *src_offsets = NULL; \ + /* read total cell num */ \ + total_cell = read_uint32(frame_ip); \ + /* cells */ \ + cells = (uint8 *)frame_ip; \ + frame_ip += arity * CELL_SIZE; \ + /* src offsets */ \ + src_offsets = (int16 *)frame_ip; \ + frame_ip += arity * sizeof(int16); \ + /* dst offsets */ \ + dst_offsets = (uint16 *)frame_ip; \ + frame_ip += arity * sizeof(uint16); \ + if (arity == 1) { \ + if (cells[0] == 1) \ + frame_lp[dst_offsets[0]] = frame_lp[src_offsets[0]]; \ + else if (cells[0] == 2) { \ + frame_lp[dst_offsets[0]] = frame_lp[src_offsets[0]]; \ + frame_lp[dst_offsets[0] + 1] = \ + frame_lp[src_offsets[0] + 1]; \ + } \ + } \ + else { \ + if (!copy_stack_values(module, frame_lp, arity, total_cell, \ + cells, src_offsets, dst_offsets)) \ + goto got_exception; \ + } \ + } \ + frame_ip = (uint8 *)LOAD_PTR(frame_ip); \ + } while (0) -#define SKIP_BR_INFO() do { \ - uint32 arity; \ - /* read and skip arity */ \ - arity = read_uint32(frame_ip); \ - if (arity) { \ - /* skip total cell num */ \ - frame_ip += sizeof(uint32); \ - /* skip cells, src offsets and dst offsets */ \ - frame_ip += (CELL_SIZE + sizeof(int16) \ - + sizeof(uint16)) * arity; \ - } \ - /* skip target address */ \ - frame_ip += sizeof(uint8*); \ - } while (0) +#define SKIP_BR_INFO() \ + do { \ + uint32 arity; \ + /* read and skip arity */ \ + arity = read_uint32(frame_ip); \ + if (arity) { \ + /* skip total cell num */ \ + frame_ip += sizeof(uint32); \ + /* skip cells, src offsets and dst offsets */ \ + frame_ip += (CELL_SIZE + sizeof(int16) + sizeof(uint16)) * arity; \ + } \ + /* skip target address */ \ + frame_ip += sizeof(uint8 *); \ + } while (0) static inline int32 sign_ext_8_32(int8 val) @@ -763,7 +791,7 @@ word_copy(uint32 *dest, uint32 *src, unsigned num) *dest++ = *src++; } -static inline WASMInterpFrame* +static inline WASMInterpFrame * ALLOC_FRAME(WASMExecEnv *exec_env, uint32 size, WASMInterpFrame *prev_frame) { WASMInterpFrame *frame = wasm_exec_env_alloc_wasm_frame(exec_env, size); @@ -775,7 +803,7 @@ ALLOC_FRAME(WASMExecEnv *exec_env, uint32 size, WASMInterpFrame *prev_frame) #endif } else { - wasm_set_exception((WASMModuleInstance*)exec_env->module_inst, + wasm_set_exception((WASMModuleInstance *)exec_env->module_inst, "wasm operand stack overflow"); } @@ -787,8 +815,8 @@ FREE_FRAME(WASMExecEnv *exec_env, WASMInterpFrame *frame) { #if WASM_ENABLE_PERF_PROFILING != 0 if (frame->function) { - frame->function->total_exec_time += os_time_get_boot_microsecond() - - frame->time_started; + frame->function->total_exec_time += + os_time_get_boot_microsecond() - frame->time_started; frame->function->total_exec_cnt++; } #endif @@ -823,32 +851,32 @@ wasm_interp_call_func_native(WASMModuleInstance *module_inst, snprintf(buf, sizeof(buf), "failed to call unlinked import function (%s, %s)", func_import->module_name, func_import->field_name); - wasm_set_exception((WASMModuleInstance*)module_inst, buf); + wasm_set_exception((WASMModuleInstance *)module_inst, buf); return; } if (func_import->call_conv_wasm_c_api) { ret = wasm_runtime_invoke_c_api_native( - (WASMModuleInstanceCommon *)module_inst, - func_import->func_ptr_linked, func_import->func_type, - cur_func->param_cell_num, frame->lp, - func_import->wasm_c_api_with_env, func_import->attachment); + (WASMModuleInstanceCommon *)module_inst, + func_import->func_ptr_linked, func_import->func_type, + cur_func->param_cell_num, frame->lp, + func_import->wasm_c_api_with_env, func_import->attachment); if (ret) { argv_ret[0] = frame->lp[0]; argv_ret[1] = frame->lp[1]; } } else if (!func_import->call_conv_raw) { - ret = wasm_runtime_invoke_native(exec_env, func_import->func_ptr_linked, - func_import->func_type, func_import->signature, - func_import->attachment, - frame->lp, cur_func->param_cell_num, argv_ret); + ret = wasm_runtime_invoke_native( + exec_env, func_import->func_ptr_linked, func_import->func_type, + func_import->signature, func_import->attachment, frame->lp, + cur_func->param_cell_num, argv_ret); } else { - ret = wasm_runtime_invoke_native_raw(exec_env, func_import->func_ptr_linked, - func_import->func_type, func_import->signature, - func_import->attachment, - frame->lp, cur_func->param_cell_num, argv_ret); + ret = wasm_runtime_invoke_native_raw( + exec_env, func_import->func_ptr_linked, func_import->func_type, + func_import->signature, func_import->attachment, frame->lp, + cur_func->param_cell_num, argv_ret); } if (!ret) @@ -902,8 +930,8 @@ wasm_interp_call_func_import(WASMModuleInstance *module_inst, exec_env->module_inst = (WASMModuleInstanceCommon *)sub_module_inst; /* call function of sub-module*/ - wasm_interp_call_func_bytecode(sub_module_inst, exec_env, - sub_func_inst, prev_frame); + wasm_interp_call_func_bytecode(sub_module_inst, exec_env, sub_func_inst, + prev_frame); /* restore ip and module_inst */ prev_frame->ip = ip; @@ -920,15 +948,16 @@ wasm_interp_call_func_import(WASMModuleInstance *module_inst, #endif #if WASM_ENABLE_THREAD_MGR != 0 -#define CHECK_SUSPEND_FLAGS() do { \ - if (exec_env->suspend_flags.flags != 0) { \ - if (exec_env->suspend_flags.flags & 0x01) { \ - /* terminate current thread */ \ - return; \ +#define CHECK_SUSPEND_FLAGS() \ + do { \ + if (exec_env->suspend_flags.flags != 0) { \ + if (exec_env->suspend_flags.flags & 0x01) { \ + /* terminate current thread */ \ + return; \ + } \ + /* TODO: support suspend and breakpoint */ \ } \ - /* TODO: support suspend and breakpoint */ \ - } \ - } while (0) + } while (0) #endif #if WASM_ENABLE_OPCODE_COUNTER != 0 @@ -937,9 +966,14 @@ typedef struct OpcodeInfo { uint64 count; } OpcodeInfo; -#define HANDLE_OPCODE(op) { #op, 0 } -DEFINE_GOTO_TABLE (OpcodeInfo, opcode_table); +/* clang-format off */ +#define HANDLE_OPCODE(op) \ + { \ + #op, 0 \ + } +DEFINE_GOTO_TABLE(OpcodeInfo, opcode_table); #undef HANDLE_OPCODE +/* clang-format on */ static void wasm_interp_dump_op_count() @@ -952,2481 +986,2719 @@ wasm_interp_dump_op_count() printf("total opcode count: %ld\n", total_count); for (i = 0; i < WASM_OP_IMPDEP; i++) if (opcode_table[i].count > 0) - printf("\t\t%s count:\t\t%ld,\t\t%.2f%%\n", - opcode_table[i].name, opcode_table[i].count, + printf("\t\t%s count:\t\t%ld,\t\t%.2f%%\n", opcode_table[i].name, + opcode_table[i].count, opcode_table[i].count * 100.0f / total_count); } #endif #if WASM_ENABLE_LABELS_AS_VALUES != 0 -/* #define HANDLE_OP(opcode) HANDLE_##opcode:printf(#opcode"\n");h_##opcode */ +/* #define HANDLE_OP(opcode) HANDLE_##opcode:printf(#opcode"\n"); */ #if WASM_ENABLE_OPCODE_COUNTER != 0 -#define HANDLE_OP(opcode) HANDLE_##opcode:opcode_table[opcode].count++;h_##opcode +#define HANDLE_OP(opcode) HANDLE_##opcode : opcode_table[opcode].count++; #else -#define HANDLE_OP(opcode) HANDLE_##opcode +#define HANDLE_OP(opcode) HANDLE_##opcode: #endif #if WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS != 0 -#define FETCH_OPCODE_AND_DISPATCH() do { \ - const void *p_label_addr = *(void**)frame_ip; \ - frame_ip += sizeof(void*); \ - goto *p_label_addr; \ - } while (0) +#define FETCH_OPCODE_AND_DISPATCH() \ + do { \ + const void *p_label_addr = *(void **)frame_ip; \ + frame_ip += sizeof(void *); \ + goto *p_label_addr; \ + } while (0) #else -#define FETCH_OPCODE_AND_DISPATCH() do { \ - const void *p_label_addr = label_base \ - + *(int16*)frame_ip; \ - frame_ip += sizeof(int16); \ - goto *p_label_addr; \ - } while (0) +#define FETCH_OPCODE_AND_DISPATCH() \ + do { \ + const void *p_label_addr = label_base + *(int16 *)frame_ip; \ + frame_ip += sizeof(int16); \ + goto *p_label_addr; \ + } while (0) #endif /* end of WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS */ #define HANDLE_OP_END() FETCH_OPCODE_AND_DISPATCH() -#else /* else of WASM_ENABLE_LABELS_AS_VALUES */ +#else /* else of WASM_ENABLE_LABELS_AS_VALUES */ -#define HANDLE_OP(opcode) case opcode +#define HANDLE_OP(opcode) case opcode: #define HANDLE_OP_END() continue -#endif /* end of WASM_ENABLE_LABELS_AS_VALUES */ +#endif /* end of WASM_ENABLE_LABELS_AS_VALUES */ #if WASM_ENABLE_LABELS_AS_VALUES != 0 static void **global_handle_table; #endif +static inline uint8 * +get_global_addr(uint8 *global_data, WASMGlobalInstance *global) +{ +#if WASM_ENABLE_MULTI_MODULE == 0 + return global_data + global->data_offset; +#else + return global->import_global_inst + ? global->import_module_inst->global_data + + global->import_global_inst->data_offset + : global_data + global->data_offset; +#endif +} + static void wasm_interp_call_func_bytecode(WASMModuleInstance *module, WASMExecEnv *exec_env, WASMFunctionInstance *cur_func, WASMInterpFrame *prev_frame) { - WASMMemoryInstance *memory = module->default_memory; - uint32 num_bytes_per_page = memory ? memory->num_bytes_per_page : 0; - uint8 *global_data = module->global_data; - uint32 linear_mem_size = memory ? num_bytes_per_page * memory->cur_page_count : 0; - WASMGlobalInstance *globals = module->globals, *global; - uint8 opcode_IMPDEP = WASM_OP_IMPDEP; - WASMInterpFrame *frame = NULL; - /* Points to this special opcode so as to jump to the call_method_from_entry. */ - register uint8 *frame_ip = &opcode_IMPDEP; /* cache of frame->ip */ - register uint32 *frame_lp = NULL; /* cache of frame->lp */ + WASMMemoryInstance *memory = module->default_memory; + uint32 num_bytes_per_page = memory ? memory->num_bytes_per_page : 0; + uint8 *global_data = module->global_data; + uint32 linear_mem_size = + memory ? num_bytes_per_page * memory->cur_page_count : 0; + WASMGlobalInstance *globals = module->globals, *global; + uint8 opcode_IMPDEP = WASM_OP_IMPDEP; + WASMInterpFrame *frame = NULL; + /* Points to this special opcode so as to jump to the + * call_method_from_entry. */ + register uint8 *frame_ip = &opcode_IMPDEP; /* cache of frame->ip */ + register uint32 *frame_lp = NULL; /* cache of frame->lp */ #if WASM_ENABLE_LABELS_AS_VALUES != 0 #if WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS == 0 - /* cache of label base addr */ - register uint8 *label_base = &&HANDLE_WASM_OP_UNREACHABLE; + /* cache of label base addr */ + register uint8 *label_base = &&HANDLE_WASM_OP_UNREACHABLE; #endif #endif - uint8 *frame_ip_end = frame_ip + 1; - uint32 cond, count, fidx, tidx, frame_size = 0; - uint64 all_cell_num = 0; - int16 addr1, addr2, addr_ret = 0; - int32 didx, val; - uint8 *maddr = NULL; - uint32 local_idx, local_offset, global_idx; - uint8 opcode, local_type, *global_addr; + uint8 *frame_ip_end = frame_ip + 1; + uint32 cond, count, fidx, tidx, frame_size = 0; + uint64 all_cell_num = 0; + int16 addr1, addr2, addr_ret = 0; + int32 didx, val; + uint8 *maddr = NULL; + uint32 local_idx, local_offset, global_idx; + uint8 opcode, local_type, *global_addr; #if WASM_ENABLE_LABELS_AS_VALUES != 0 - #define HANDLE_OPCODE(op) &&HANDLE_##op - DEFINE_GOTO_TABLE (const void*, handle_table); - #undef HANDLE_OPCODE - if (exec_env == NULL) { - global_handle_table = (void **)handle_table; - return; - } +#define HANDLE_OPCODE(op) &&HANDLE_##op + DEFINE_GOTO_TABLE(const void *, handle_table); +#undef HANDLE_OPCODE + if (exec_env == NULL) { + global_handle_table = (void **)handle_table; + return; + } #endif #if WASM_ENABLE_LABELS_AS_VALUES == 0 - while (frame_ip < frame_ip_end) { - opcode = *frame_ip++; + while (frame_ip < frame_ip_end) { + opcode = *frame_ip++; #if WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS == 0 - frame_ip++; + frame_ip++; #endif - switch (opcode) { + switch (opcode) { #else - goto *handle_table[WASM_OP_IMPDEP]; + goto *handle_table[WASM_OP_IMPDEP]; #endif - /* control instructions */ - HANDLE_OP (WASM_OP_UNREACHABLE): - wasm_set_exception(module, "unreachable"); - goto got_exception; - - HANDLE_OP (WASM_OP_IF): - cond = (uint32)POP_I32(); - - if (cond == 0) { - uint8 *else_addr = (uint8*)LOAD_PTR(frame_ip); - if (else_addr == NULL) { - frame_ip = (uint8*)LOAD_PTR(frame_ip + sizeof(uint8*)); - } - else { - frame_ip = else_addr; - } - } - else { - frame_ip += sizeof(uint8*) * 2; - } - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_ELSE): - frame_ip = (uint8*)LOAD_PTR(frame_ip); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_BR): -#if WASM_ENABLE_THREAD_MGR != 0 - CHECK_SUSPEND_FLAGS(); -#endif -recover_br_info: - RECOVER_BR_INFO(); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_BR_IF): -#if WASM_ENABLE_THREAD_MGR != 0 - CHECK_SUSPEND_FLAGS(); -#endif - cond = frame_lp[GET_OFFSET()]; - - if (cond) - goto recover_br_info; - else - SKIP_BR_INFO(); - - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_BR_TABLE): - { - uint32 arity, br_item_size; - -#if WASM_ENABLE_THREAD_MGR != 0 - CHECK_SUSPEND_FLAGS(); -#endif - count = read_uint32(frame_ip); - didx = GET_OPERAND(uint32, I32, 0); - frame_ip += 2; - - if (!(didx >= 0 && (uint32)didx < count)) - didx = count; - - /* all br items must have the same arity and item size, - so we only calculate the first item size */ - arity = LOAD_U32_WITH_2U16S(frame_ip); - br_item_size = sizeof(uint32); /* arity */ - if (arity) { - /* total cell num */ - br_item_size += sizeof(uint32); - /* cells, src offsets and dst offsets */ - br_item_size += (CELL_SIZE + sizeof(int16) + sizeof(uint16)) - * arity; - } - /* target address */ - br_item_size += sizeof(uint8*); - - frame_ip += br_item_size * didx; - goto recover_br_info; - } - - HANDLE_OP (WASM_OP_RETURN): - { - uint32 ret_idx; - WASMType *func_type; - uint32 off, ret_offset; - uint8 *ret_types; - if (cur_func->is_import_func) - func_type = cur_func->u.func_import->func_type; - else - func_type = cur_func->u.func->func_type; - - /* types of each return value */ - ret_types = func_type->types + func_type->param_count; - ret_offset = prev_frame->ret_offset; - - for (ret_idx = 0, off = sizeof(int16) * (func_type->result_count - 1); - ret_idx < func_type->result_count; - ret_idx++, off -= sizeof(int16)) { - if (ret_types[ret_idx] == VALUE_TYPE_I64 - || ret_types[ret_idx] == VALUE_TYPE_F64) { - PUT_I64_TO_ADDR(prev_frame->lp + ret_offset, - GET_OPERAND(uint64, I64, off)); - ret_offset += 2; + /* control instructions */ + HANDLE_OP(WASM_OP_UNREACHABLE) + { + wasm_set_exception(module, "unreachable"); + goto got_exception; } - else { - prev_frame->lp[ret_offset] = GET_OPERAND(uint32, I32, off); - ret_offset++; + + HANDLE_OP(WASM_OP_IF) + { + cond = (uint32)POP_I32(); + + if (cond == 0) { + uint8 *else_addr = (uint8 *)LOAD_PTR(frame_ip); + if (else_addr == NULL) { + frame_ip = + (uint8 *)LOAD_PTR(frame_ip + sizeof(uint8 *)); + } + else { + frame_ip = else_addr; + } + } + else { + frame_ip += sizeof(uint8 *) * 2; + } + HANDLE_OP_END(); } - } - } - goto return_func; - HANDLE_OP (WASM_OP_CALL_INDIRECT): -#if WASM_ENABLE_TAIL_CALL != 0 - HANDLE_OP (WASM_OP_RETURN_CALL_INDIRECT): + HANDLE_OP(WASM_OP_ELSE) + { + frame_ip = (uint8 *)LOAD_PTR(frame_ip); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_BR) + { +#if WASM_ENABLE_THREAD_MGR != 0 + CHECK_SUSPEND_FLAGS(); #endif - { - WASMType *cur_type, *cur_func_type; - WASMTableInstance *tbl_inst; - uint32 tbl_idx; + recover_br_info: + RECOVER_BR_INFO(); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_BR_IF) + { +#if WASM_ENABLE_THREAD_MGR != 0 + CHECK_SUSPEND_FLAGS(); +#endif + cond = frame_lp[GET_OFFSET()]; + + if (cond) + goto recover_br_info; + else + SKIP_BR_INFO(); + + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_BR_TABLE) + { + uint32 arity, br_item_size; + +#if WASM_ENABLE_THREAD_MGR != 0 + CHECK_SUSPEND_FLAGS(); +#endif + count = read_uint32(frame_ip); + didx = GET_OPERAND(uint32, I32, 0); + frame_ip += 2; + + if (!(didx >= 0 && (uint32)didx < count)) + didx = count; + + /* all br items must have the same arity and item size, + so we only calculate the first item size */ + arity = LOAD_U32_WITH_2U16S(frame_ip); + br_item_size = sizeof(uint32); /* arity */ + if (arity) { + /* total cell num */ + br_item_size += sizeof(uint32); + /* cells, src offsets and dst offsets */ + br_item_size += + (CELL_SIZE + sizeof(int16) + sizeof(uint16)) * arity; + } + /* target address */ + br_item_size += sizeof(uint8 *); + + frame_ip += br_item_size * didx; + goto recover_br_info; + } + + HANDLE_OP(WASM_OP_RETURN) + { + uint32 ret_idx; + WASMType *func_type; + uint32 off, ret_offset; + uint8 *ret_types; + if (cur_func->is_import_func) + func_type = cur_func->u.func_import->func_type; + else + func_type = cur_func->u.func->func_type; + + /* types of each return value */ + ret_types = func_type->types + func_type->param_count; + ret_offset = prev_frame->ret_offset; + + for (ret_idx = 0, + off = sizeof(int16) * (func_type->result_count - 1); + ret_idx < func_type->result_count; + ret_idx++, off -= sizeof(int16)) { + if (ret_types[ret_idx] == VALUE_TYPE_I64 + || ret_types[ret_idx] == VALUE_TYPE_F64) { + PUT_I64_TO_ADDR(prev_frame->lp + ret_offset, + GET_OPERAND(uint64, I64, off)); + ret_offset += 2; + } + else { + prev_frame->lp[ret_offset] = + GET_OPERAND(uint32, I32, off); + ret_offset++; + } + } + goto return_func; + } + + HANDLE_OP(WASM_OP_CALL_INDIRECT) +#if WASM_ENABLE_TAIL_CALL != 0 + HANDLE_OP(WASM_OP_RETURN_CALL_INDIRECT) +#endif + { + WASMType *cur_type, *cur_func_type; + WASMTableInstance *tbl_inst; + uint32 tbl_idx; #if WASM_ENABLE_TAIL_CALL != 0 - GET_OPCODE(); + GET_OPCODE(); #endif #if WASM_ENABLE_THREAD_MGR != 0 - CHECK_SUSPEND_FLAGS(); + CHECK_SUSPEND_FLAGS(); #endif - tidx = read_uint32(frame_ip); - cur_type = module->module->types[tidx]; + tidx = read_uint32(frame_ip); + cur_type = module->module->types[tidx]; - tbl_idx = read_uint32(frame_ip); - bh_assert(tbl_idx < module->table_count); + tbl_idx = read_uint32(frame_ip); + bh_assert(tbl_idx < module->table_count); - tbl_inst = wasm_get_table_inst(module, tbl_idx); + tbl_inst = wasm_get_table_inst(module, tbl_idx); - val = GET_OPERAND(uint32, I32, 0); - frame_ip += 2; + val = GET_OPERAND(uint32, I32, 0); + frame_ip += 2; - if (val < 0 || val >= (int32)tbl_inst->cur_size) { - wasm_set_exception(module, "undefined element"); - goto got_exception; - } + if (val < 0 || val >= (int32)tbl_inst->cur_size) { + wasm_set_exception(module, "undefined element"); + goto got_exception; + } - fidx = ((uint32*)tbl_inst->base_addr)[val]; - if (fidx == (uint32)-1) { - wasm_set_exception(module, "uninitialized element"); - goto got_exception; - } + fidx = ((uint32 *)tbl_inst->base_addr)[val]; + if (fidx == (uint32)-1) { + wasm_set_exception(module, "uninitialized element"); + goto got_exception; + } - /* - * we might be using a table injected by host or - * another module. in that case, we don't validate - * the elem value while loading - */ - if (fidx >= module->function_count) { - wasm_set_exception(module, "unknown function"); - goto got_exception; - } + /* + * we might be using a table injected by host or + * another module. in that case, we don't validate + * the elem value while loading + */ + if (fidx >= module->function_count) { + wasm_set_exception(module, "unknown function"); + goto got_exception; + } - /* always call module own functions */ - cur_func = module->functions + fidx; + /* always call module own functions */ + cur_func = module->functions + fidx; - if (cur_func->is_import_func) - cur_func_type = cur_func->u.func_import->func_type; - else - cur_func_type = cur_func->u.func->func_type; - if (!wasm_type_equal(cur_type, cur_func_type)) { - wasm_set_exception(module, "indirect call type mismatch"); - goto got_exception; - } + if (cur_func->is_import_func) + cur_func_type = cur_func->u.func_import->func_type; + else + cur_func_type = cur_func->u.func->func_type; + if (!wasm_type_equal(cur_type, cur_func_type)) { + wasm_set_exception(module, "indirect call type mismatch"); + goto got_exception; + } #if WASM_ENABLE_TAIL_CALL != 0 - if (opcode == WASM_OP_RETURN_CALL_INDIRECT) - goto call_func_from_return_call; + if (opcode == WASM_OP_RETURN_CALL_INDIRECT) + goto call_func_from_return_call; #endif - goto call_func_from_interp; - } + goto call_func_from_interp; + } - /* parametric instructions */ - HANDLE_OP (WASM_OP_SELECT): - { - cond = frame_lp[GET_OFFSET()]; - addr1 = GET_OFFSET(); - addr2 = GET_OFFSET(); - addr_ret = GET_OFFSET(); + /* parametric instructions */ + HANDLE_OP(WASM_OP_SELECT) + { + cond = frame_lp[GET_OFFSET()]; + addr1 = GET_OFFSET(); + addr2 = GET_OFFSET(); + addr_ret = GET_OFFSET(); - if (!cond) { - if (addr_ret != addr1) - frame_lp[addr_ret] = frame_lp[addr1]; - } - else { - if (addr_ret != addr2) - frame_lp[addr_ret] = frame_lp[addr2]; - } - HANDLE_OP_END (); - } + if (!cond) { + if (addr_ret != addr1) + frame_lp[addr_ret] = frame_lp[addr1]; + } + else { + if (addr_ret != addr2) + frame_lp[addr_ret] = frame_lp[addr2]; + } + HANDLE_OP_END(); + } - HANDLE_OP (WASM_OP_SELECT_64): - { - cond = frame_lp[GET_OFFSET()]; - addr1 = GET_OFFSET(); - addr2 = GET_OFFSET(); - addr_ret = GET_OFFSET(); + HANDLE_OP(WASM_OP_SELECT_64) + { + cond = frame_lp[GET_OFFSET()]; + addr1 = GET_OFFSET(); + addr2 = GET_OFFSET(); + addr_ret = GET_OFFSET(); - if (!cond) { - if (addr_ret != addr1) - PUT_I64_TO_ADDR(frame_lp + addr_ret, - GET_I64_FROM_ADDR(frame_lp + addr1)); - } - else { - if (addr_ret != addr2) - PUT_I64_TO_ADDR(frame_lp + addr_ret, - GET_I64_FROM_ADDR(frame_lp + addr2)); - } - HANDLE_OP_END (); - } + if (!cond) { + if (addr_ret != addr1) + PUT_I64_TO_ADDR(frame_lp + addr_ret, + GET_I64_FROM_ADDR(frame_lp + addr1)); + } + else { + if (addr_ret != addr2) + PUT_I64_TO_ADDR(frame_lp + addr_ret, + GET_I64_FROM_ADDR(frame_lp + addr2)); + } + HANDLE_OP_END(); + } #if WASM_ENABLE_REF_TYPES != 0 - HANDLE_OP (WASM_OP_TABLE_GET): - { - uint32 tbl_idx, elem_idx; - WASMTableInstance *tbl_inst; + HANDLE_OP(WASM_OP_TABLE_GET) + { + uint32 tbl_idx, elem_idx; + WASMTableInstance *tbl_inst; - tbl_idx = read_uint32(frame_ip); - bh_assert(tbl_idx < module->table_count); + tbl_idx = read_uint32(frame_ip); + bh_assert(tbl_idx < module->table_count); - tbl_inst = wasm_get_table_inst(module, tbl_idx); + tbl_inst = wasm_get_table_inst(module, tbl_idx); - elem_idx = POP_I32(); - if (elem_idx >= tbl_inst->cur_size) { - wasm_set_exception(module, "out of bounds table access"); - goto got_exception; + elem_idx = POP_I32(); + if (elem_idx >= tbl_inst->cur_size) { + wasm_set_exception(module, "out of bounds table access"); + goto got_exception; + } + + PUSH_I32(((uint32 *)tbl_inst->base_addr)[elem_idx]); + HANDLE_OP_END(); } - PUSH_I32(((uint32 *)tbl_inst->base_addr)[elem_idx]); - HANDLE_OP_END(); - } + HANDLE_OP(WASM_OP_TABLE_SET) + { + uint32 tbl_idx, elem_idx, val; + WASMTableInstance *tbl_inst; - HANDLE_OP (WASM_OP_TABLE_SET): - { - uint32 tbl_idx, elem_idx, val; - WASMTableInstance *tbl_inst; + tbl_idx = read_uint32(frame_ip); + bh_assert(tbl_idx < module->table_count); - tbl_idx = read_uint32(frame_ip); - bh_assert(tbl_idx < module->table_count); + tbl_inst = wasm_get_table_inst(module, tbl_idx); - tbl_inst = wasm_get_table_inst(module, tbl_idx); + val = POP_I32(); + elem_idx = POP_I32(); + if (elem_idx >= tbl_inst->cur_size) { + wasm_set_exception(module, "out of bounds table access"); + goto got_exception; + } - val = POP_I32(); - elem_idx = POP_I32(); - if (elem_idx >= tbl_inst->cur_size) { - wasm_set_exception(module, "out of bounds table access"); - goto got_exception; + ((uint32 *)tbl_inst->base_addr)[elem_idx] = val; + HANDLE_OP_END(); } - ((uint32 *)tbl_inst->base_addr)[elem_idx] = val; - HANDLE_OP_END (); - } + HANDLE_OP(WASM_OP_REF_NULL) + { + PUSH_I32(NULL_REF); + HANDLE_OP_END(); + } - HANDLE_OP (WASM_OP_REF_NULL): - { - PUSH_I32(NULL_REF); - HANDLE_OP_END(); - } + HANDLE_OP(WASM_OP_REF_IS_NULL) + { + uint32 val; + val = POP_I32(); + PUSH_I32(val == NULL_REF ? 1 : 0); + HANDLE_OP_END(); + } - HANDLE_OP (WASM_OP_REF_IS_NULL): - { - uint32 val; - val = POP_I32(); - PUSH_I32(val == NULL_REF ? 1 : 0); - HANDLE_OP_END(); - } - - HANDLE_OP (WASM_OP_REF_FUNC): - { - uint32 func_idx = read_uint32(frame_ip); - PUSH_I32(func_idx); - HANDLE_OP_END(); - } + HANDLE_OP(WASM_OP_REF_FUNC) + { + uint32 func_idx = read_uint32(frame_ip); + PUSH_I32(func_idx); + HANDLE_OP_END(); + } #endif /* WASM_ENABLE_REF_TYPES */ - /* variable instructions */ - HANDLE_OP (EXT_OP_SET_LOCAL_FAST): - HANDLE_OP (EXT_OP_TEE_LOCAL_FAST): - { + /* variable instructions */ + HANDLE_OP(EXT_OP_SET_LOCAL_FAST) + HANDLE_OP(EXT_OP_TEE_LOCAL_FAST) + { #if WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS != 0 - local_offset = *frame_ip++; + local_offset = *frame_ip++; #else - local_offset = *frame_ip; - frame_ip += 2; + /* clang-format off */ + local_offset = *frame_ip; + frame_ip += 2; + /* clang-format on */ #endif - *(uint32*)(frame_lp + local_offset) = GET_OPERAND(uint32, I32, 0); - frame_ip += 2; - HANDLE_OP_END (); - } + *(uint32 *)(frame_lp + local_offset) = + GET_OPERAND(uint32, I32, 0); + frame_ip += 2; + HANDLE_OP_END(); + } - HANDLE_OP (EXT_OP_SET_LOCAL_FAST_I64): - HANDLE_OP (EXT_OP_TEE_LOCAL_FAST_I64): - { + HANDLE_OP(EXT_OP_SET_LOCAL_FAST_I64) + HANDLE_OP(EXT_OP_TEE_LOCAL_FAST_I64) + { #if WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS != 0 - local_offset = *frame_ip++; + local_offset = *frame_ip++; #else - local_offset = *frame_ip; - frame_ip += 2; + /* clang-format off */ + local_offset = *frame_ip; + frame_ip += 2; + /* clang-format on */ #endif - PUT_I64_TO_ADDR((uint32*)(frame_lp + local_offset), - GET_OPERAND(uint64, I64, 0)); - frame_ip += 2; - HANDLE_OP_END (); - } + PUT_I64_TO_ADDR((uint32 *)(frame_lp + local_offset), + GET_OPERAND(uint64, I64, 0)); + frame_ip += 2; + HANDLE_OP_END(); + } - HANDLE_OP (WASM_OP_GET_GLOBAL): - { - global_idx = read_uint32(frame_ip); - bh_assert(global_idx < module->global_count); - global = globals + global_idx; -#if WASM_ENABLE_MULTI_MODULE == 0 - global_addr = global_data + global->data_offset; -#else - global_addr = global->import_global_inst - ? global->import_module_inst->global_data - + global->import_global_inst->data_offset - : global_data + global->data_offset; -#endif - addr_ret = GET_OFFSET(); - frame_lp[addr_ret] = *(uint32*)global_addr; - HANDLE_OP_END (); - } + HANDLE_OP(WASM_OP_GET_GLOBAL) + { + global_idx = read_uint32(frame_ip); + bh_assert(global_idx < module->global_count); + global = globals + global_idx; + global_addr = get_global_addr(global_data, global); + addr_ret = GET_OFFSET(); + frame_lp[addr_ret] = *(uint32 *)global_addr; + HANDLE_OP_END(); + } - HANDLE_OP (WASM_OP_GET_GLOBAL_64): - { - global_idx = read_uint32(frame_ip); - bh_assert(global_idx < module->global_count); - global = globals + global_idx; -#if WASM_ENABLE_MULTI_MODULE == 0 - global_addr = global_data + global->data_offset; -#else - global_addr = global->import_global_inst - ? global->import_module_inst->global_data - + global->import_global_inst->data_offset - : global_data + global->data_offset; -#endif - addr_ret = GET_OFFSET(); - PUT_I64_TO_ADDR(frame_lp + addr_ret, - GET_I64_FROM_ADDR((uint32*)global_addr)); - HANDLE_OP_END (); - } + HANDLE_OP(WASM_OP_GET_GLOBAL_64) + { + global_idx = read_uint32(frame_ip); + bh_assert(global_idx < module->global_count); + global = globals + global_idx; + global_addr = get_global_addr(global_data, global); + addr_ret = GET_OFFSET(); + PUT_I64_TO_ADDR(frame_lp + addr_ret, + GET_I64_FROM_ADDR((uint32 *)global_addr)); + HANDLE_OP_END(); + } - HANDLE_OP (WASM_OP_SET_GLOBAL): - { - global_idx = read_uint32(frame_ip); - bh_assert(global_idx < module->global_count); - global = globals + global_idx; -#if WASM_ENABLE_MULTI_MODULE == 0 - global_addr = global_data + global->data_offset; -#else - global_addr = global->import_global_inst - ? global->import_module_inst->global_data - + global->import_global_inst->data_offset - : global_data + global->data_offset; -#endif - addr1 = GET_OFFSET(); - *(int32*)global_addr = frame_lp[addr1]; - HANDLE_OP_END (); - } + HANDLE_OP(WASM_OP_SET_GLOBAL) + { + global_idx = read_uint32(frame_ip); + bh_assert(global_idx < module->global_count); + global = globals + global_idx; + global_addr = get_global_addr(global_data, global); + addr1 = GET_OFFSET(); + *(int32 *)global_addr = frame_lp[addr1]; + HANDLE_OP_END(); + } - HANDLE_OP (WASM_OP_SET_GLOBAL_AUX_STACK): - { - uint32 aux_stack_top; + HANDLE_OP(WASM_OP_SET_GLOBAL_AUX_STACK) + { + uint32 aux_stack_top; - global_idx = read_uint32(frame_ip); - bh_assert(global_idx < module->global_count); - global = globals + global_idx; -#if WASM_ENABLE_MULTI_MODULE == 0 - global_addr = global_data + global->data_offset; -#else - global_addr = global->import_global_inst - ? global->import_module_inst->global_data - + global->import_global_inst->data_offset - : global_data + global->data_offset; -#endif - aux_stack_top = frame_lp[GET_OFFSET()]; - if (aux_stack_top <= exec_env->aux_stack_boundary.boundary) { - wasm_set_exception(module, "wasm auxiliary stack overflow"); - goto got_exception; - } - if (aux_stack_top > exec_env->aux_stack_bottom.bottom) { - wasm_set_exception(module, "wasm auxiliary stack underflow"); - goto got_exception; - } - *(int32*)global_addr = aux_stack_top; + global_idx = read_uint32(frame_ip); + bh_assert(global_idx < module->global_count); + global = globals + global_idx; + global_addr = get_global_addr(global_data, global); + aux_stack_top = frame_lp[GET_OFFSET()]; + if (aux_stack_top <= exec_env->aux_stack_boundary.boundary) { + wasm_set_exception(module, "wasm auxiliary stack overflow"); + goto got_exception; + } + if (aux_stack_top > exec_env->aux_stack_bottom.bottom) { + wasm_set_exception(module, + "wasm auxiliary stack underflow"); + goto got_exception; + } + *(int32 *)global_addr = aux_stack_top; #if WASM_ENABLE_MEMORY_PROFILING != 0 - if (module->module->aux_stack_top_global_index != (uint32)-1) { - uint32 aux_stack_used = - module->module->aux_stack_bottom - *(uint32*)global_addr; - if (aux_stack_used > module->max_aux_stack_used) - module->max_aux_stack_used = aux_stack_used; - } + if (module->module->aux_stack_top_global_index != (uint32)-1) { + uint32 aux_stack_used = module->module->aux_stack_bottom + - *(uint32 *)global_addr; + if (aux_stack_used > module->max_aux_stack_used) + module->max_aux_stack_used = aux_stack_used; + } #endif - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_SET_GLOBAL_64): - { - global_idx = read_uint32(frame_ip); - bh_assert(global_idx < module->global_count); - global = globals + global_idx; -#if WASM_ENABLE_MULTI_MODULE == 0 - global_addr = global_data + global->data_offset; -#else - global_addr = global->import_global_inst - ? global->import_module_inst->global_data - + global->import_global_inst->data_offset - : global_data + global->data_offset; -#endif - addr1 = GET_OFFSET(); - PUT_I64_TO_ADDR((uint32*)global_addr, - GET_I64_FROM_ADDR(frame_lp + addr1)); - HANDLE_OP_END (); - } - - /* memory load instructions */ - HANDLE_OP (WASM_OP_I32_LOAD): - { - uint32 offset, addr; - offset = read_uint32(frame_ip); - addr = GET_OPERAND(uint32, I32, 0); - frame_ip += 2; - addr_ret = GET_OFFSET(); - CHECK_MEMORY_OVERFLOW(4); - frame_lp[addr_ret] = LOAD_I32(maddr); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I64_LOAD): - { - uint32 offset, addr; - offset = read_uint32(frame_ip); - addr = GET_OPERAND(uint32, I32, 0); - frame_ip += 2; - addr_ret = GET_OFFSET(); - CHECK_MEMORY_OVERFLOW(8); - PUT_I64_TO_ADDR(frame_lp + addr_ret, LOAD_I64(maddr)); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I32_LOAD8_S): - { - uint32 offset, addr; - offset = read_uint32(frame_ip); - addr = GET_OPERAND(uint32, I32, 0); - frame_ip += 2; - addr_ret = GET_OFFSET(); - CHECK_MEMORY_OVERFLOW(1); - frame_lp[addr_ret] = sign_ext_8_32(*(int8*)maddr); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I32_LOAD8_U): - { - uint32 offset, addr; - offset = read_uint32(frame_ip); - addr = GET_OPERAND(uint32, I32, 0); - frame_ip += 2; - addr_ret = GET_OFFSET(); - CHECK_MEMORY_OVERFLOW(1); - frame_lp[addr_ret] = (uint32)(*(uint8*)maddr); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I32_LOAD16_S): - { - uint32 offset, addr; - offset = read_uint32(frame_ip); - addr = GET_OPERAND(uint32, I32, 0); - frame_ip += 2; - addr_ret = GET_OFFSET(); - CHECK_MEMORY_OVERFLOW(2); - frame_lp[addr_ret] = sign_ext_16_32(LOAD_I16(maddr)); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I32_LOAD16_U): - { - uint32 offset, addr; - offset = read_uint32(frame_ip); - addr = GET_OPERAND(uint32, I32, 0); - frame_ip += 2; - addr_ret = GET_OFFSET(); - CHECK_MEMORY_OVERFLOW(2); - frame_lp[addr_ret] = (uint32)(LOAD_U16(maddr)); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I64_LOAD8_S): - { - uint32 offset, addr; - offset = read_uint32(frame_ip); - addr = GET_OPERAND(uint32, I32, 0); - frame_ip += 2; - addr_ret = GET_OFFSET(); - CHECK_MEMORY_OVERFLOW(1); - PUT_I64_TO_ADDR(frame_lp + addr_ret, sign_ext_8_64(*(int8*)maddr)); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I64_LOAD8_U): - { - uint32 offset, addr; - offset = read_uint32(frame_ip); - addr = GET_OPERAND(uint32, I32, 0); - frame_ip += 2; - addr_ret = GET_OFFSET(); - CHECK_MEMORY_OVERFLOW(1); - PUT_I64_TO_ADDR(frame_lp + addr_ret, (uint64)(*(uint8*)maddr)); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I64_LOAD16_S): - { - uint32 offset, addr; - offset = read_uint32(frame_ip); - addr = GET_OPERAND(uint32, I32, 0); - frame_ip += 2; - addr_ret = GET_OFFSET(); - CHECK_MEMORY_OVERFLOW(2); - PUT_I64_TO_ADDR(frame_lp + addr_ret, sign_ext_16_64(LOAD_I16(maddr))); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I64_LOAD16_U): - { - uint32 offset, addr; - offset = read_uint32(frame_ip); - addr = GET_OPERAND(uint32, I32, 0); - frame_ip += 2; - addr_ret = GET_OFFSET(); - CHECK_MEMORY_OVERFLOW(2); - PUT_I64_TO_ADDR(frame_lp + addr_ret, (uint64)(LOAD_U16(maddr))); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I64_LOAD32_S): - { - uint32 offset, addr; - offset = read_uint32(frame_ip); - addr = GET_OPERAND(uint32, I32, 0); - frame_ip += 2; - addr_ret = GET_OFFSET(); - CHECK_MEMORY_OVERFLOW(4); - PUT_I64_TO_ADDR(frame_lp + addr_ret, sign_ext_32_64(LOAD_I32(maddr))); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I64_LOAD32_U): - { - uint32 offset, addr; - offset = read_uint32(frame_ip); - addr = GET_OPERAND(uint32, I32, 0); - frame_ip += 2; - addr_ret = GET_OFFSET(); - CHECK_MEMORY_OVERFLOW(4); - PUT_I64_TO_ADDR(frame_lp + addr_ret, (uint64)(LOAD_U32(maddr))); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I32_STORE): - { - uint32 offset, addr; - uint32 sval; - offset = read_uint32(frame_ip); - sval = GET_OPERAND(uint32, I32, 0); - addr = GET_OPERAND(uint32, I32, 2); - frame_ip += 4; - CHECK_MEMORY_OVERFLOW(4); - STORE_U32(maddr, sval); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I32_STORE8): - { - uint32 offset, addr; - uint32 sval; - offset = read_uint32(frame_ip); - sval = GET_OPERAND(uint32, I32, 0); - addr = GET_OPERAND(uint32, I32, 2); - frame_ip += 4; - CHECK_MEMORY_OVERFLOW(1); - *(uint8*)maddr = (uint8)sval; - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I32_STORE16): - { - uint32 offset, addr; - uint32 sval; - offset = read_uint32(frame_ip); - sval = GET_OPERAND(uint32, I32, 0); - addr = GET_OPERAND(uint32, I32, 2); - frame_ip += 4; - CHECK_MEMORY_OVERFLOW(2); - STORE_U16(maddr, (uint16)sval); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I64_STORE): - { - uint32 offset, addr; - uint64 sval; - offset = read_uint32(frame_ip); - sval = GET_OPERAND(uint64, I64, 0); - addr = GET_OPERAND(uint32, I32, 2); - frame_ip += 4; - CHECK_MEMORY_OVERFLOW(8); - STORE_I64(maddr, sval); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I64_STORE8): - { - uint32 offset, addr; - uint64 sval; - offset = read_uint32(frame_ip); - sval = GET_OPERAND(uint64, I64, 0); - addr = GET_OPERAND(uint32, I32, 2); - frame_ip += 4; - CHECK_MEMORY_OVERFLOW(1); - *(uint8*)maddr = (uint8)sval; - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I64_STORE16): - { - uint32 offset, addr; - uint64 sval; - offset = read_uint32(frame_ip); - sval = GET_OPERAND(uint64, I64, 0); - addr = GET_OPERAND(uint32, I32, 2); - frame_ip += 4; - CHECK_MEMORY_OVERFLOW(2); - STORE_U16(maddr, (uint16)sval); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I64_STORE32): - { - uint32 offset, addr; - uint64 sval; - offset = read_uint32(frame_ip); - sval = GET_OPERAND(uint64, I64, 0); - addr = GET_OPERAND(uint32, I32, 2); - frame_ip += 4; - CHECK_MEMORY_OVERFLOW(4); - STORE_U32(maddr, (uint32)sval); - HANDLE_OP_END (); - } - - /* memory size and memory grow instructions */ - HANDLE_OP (WASM_OP_MEMORY_SIZE): - { - uint32 reserved; - addr_ret = GET_OFFSET(); - frame_lp[addr_ret] = memory->cur_page_count; - (void)reserved; - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_MEMORY_GROW): - { - uint32 reserved, delta, prev_page_count = memory->cur_page_count; - - addr1 = GET_OFFSET(); - addr_ret = GET_OFFSET(); - delta = (uint32)frame_lp[addr1]; - - if (!wasm_enlarge_memory(module, delta)) { - /* failed to memory.grow, return -1 */ - frame_lp[addr_ret] = -1; - } - else { - /* success, return previous page count */ - frame_lp[addr_ret] = prev_page_count; - /* update memory instance ptr and memory size */ - memory = module->default_memory; - linear_mem_size = num_bytes_per_page * memory->cur_page_count; - } - - (void)reserved; - HANDLE_OP_END (); - } - - /* comparison instructions of i32 */ - HANDLE_OP (WASM_OP_I32_EQZ): - DEF_OP_EQZ(int32, I32); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_EQ): - DEF_OP_CMP(uint32, I32, ==); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_NE): - DEF_OP_CMP(uint32, I32, !=); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_LT_S): - DEF_OP_CMP(int32, I32, <); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_LT_U): - DEF_OP_CMP(uint32, I32, <); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_GT_S): - DEF_OP_CMP(int32, I32, >); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_GT_U): - DEF_OP_CMP(uint32, I32, >); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_LE_S): - DEF_OP_CMP(int32, I32, <=); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_LE_U): - DEF_OP_CMP(uint32, I32, <=); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_GE_S): - DEF_OP_CMP(int32, I32, >=); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_GE_U): - DEF_OP_CMP(uint32, I32, >=); - HANDLE_OP_END (); - - /* comparison instructions of i64 */ - HANDLE_OP (WASM_OP_I64_EQZ): - DEF_OP_EQZ(int64, I64); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_EQ): - DEF_OP_CMP(uint64, I64, ==); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_NE): - DEF_OP_CMP(uint64, I64, !=); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_LT_S): - DEF_OP_CMP(int64, I64, <); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_LT_U): - DEF_OP_CMP(uint64, I64, <); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_GT_S): - DEF_OP_CMP(int64, I64, >); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_GT_U): - DEF_OP_CMP(uint64, I64, >); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_LE_S): - DEF_OP_CMP(int64, I64, <=); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_LE_U): - DEF_OP_CMP(uint64, I64, <=); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_GE_S): - DEF_OP_CMP(int64, I64, >=); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_GE_U): - DEF_OP_CMP(uint64, I64, >=); - HANDLE_OP_END (); - - /* comparison instructions of f32 */ - HANDLE_OP (WASM_OP_F32_EQ): - DEF_OP_CMP(float32, F32, ==); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_NE): - DEF_OP_CMP(float32, F32, !=); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_LT): - DEF_OP_CMP(float32, F32, <); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_GT): - DEF_OP_CMP(float32, F32, >); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_LE): - DEF_OP_CMP(float32, F32, <=); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_GE): - DEF_OP_CMP(float32, F32, >=); - HANDLE_OP_END (); - - /* comparison instructions of f64 */ - HANDLE_OP (WASM_OP_F64_EQ): - DEF_OP_CMP(float64, F64, ==); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_NE): - DEF_OP_CMP(float64, F64, !=); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_LT): - DEF_OP_CMP(float64, F64, <); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_GT): - DEF_OP_CMP(float64, F64, >); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_LE): - DEF_OP_CMP(float64, F64, <=); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_GE): - DEF_OP_CMP(float64, F64, >=); - HANDLE_OP_END (); - - /* numberic instructions of i32 */ - HANDLE_OP (WASM_OP_I32_CLZ): - DEF_OP_BIT_COUNT(uint32, I32, clz32); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_CTZ): - DEF_OP_BIT_COUNT(uint32, I32, ctz32); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_POPCNT): - DEF_OP_BIT_COUNT(uint32, I32, popcount32); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_ADD): - DEF_OP_NUMERIC(uint32, uint32, I32, +); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_SUB): - DEF_OP_NUMERIC(uint32, uint32, I32, -); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_MUL): - DEF_OP_NUMERIC(uint32, uint32, I32, *); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_DIV_S): - { - int32 a, b; - - b = frame_lp[GET_OFFSET()]; - a = frame_lp[GET_OFFSET()]; - addr_ret = GET_OFFSET(); - if (a == (int32)0x80000000 && b == -1) { - wasm_set_exception(module, "integer overflow"); - goto got_exception; - } - if (b == 0) { - wasm_set_exception(module, "integer divide by zero"); - goto got_exception; - } - frame_lp[addr_ret] = (a / b); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I32_DIV_U): - { - uint32 a, b; - - addr1 = GET_OFFSET(); - addr2 = GET_OFFSET(); - addr_ret = GET_OFFSET(); - - b = (uint32)frame_lp[addr1]; - a = (uint32)frame_lp[addr2]; - if (b == 0) { - wasm_set_exception(module, "integer divide by zero"); - goto got_exception; - } - frame_lp[addr_ret] = (a / b); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I32_REM_S): - { - int32 a, b; - - addr1 = GET_OFFSET(); - addr2 = GET_OFFSET(); - addr_ret = GET_OFFSET(); - - b = frame_lp[addr1]; - a = frame_lp[addr2]; - if (a == (int32)0x80000000 && b == -1) { - frame_lp[addr_ret] = 0; - HANDLE_OP_END (); - } - if (b == 0) { - wasm_set_exception(module, "integer divide by zero"); - goto got_exception; - } - frame_lp[addr_ret] = (a % b); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I32_REM_U): - { - uint32 a, b; - - addr1 = GET_OFFSET(); - addr2 = GET_OFFSET(); - addr_ret = GET_OFFSET(); - - b = (uint32)frame_lp[addr1]; - a = (uint32)frame_lp[addr2]; - if (b == 0) { - wasm_set_exception(module, "integer divide by zero"); - goto got_exception; - } - frame_lp[addr_ret] = (a % b); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I32_AND): - DEF_OP_NUMERIC(uint32, uint32, I32, &); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_OR): - DEF_OP_NUMERIC(uint32, uint32, I32, |); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_XOR): - DEF_OP_NUMERIC(uint32, uint32, I32, ^); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_SHL): - { - DEF_OP_NUMERIC2(uint32, uint32, I32, <<); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I32_SHR_S): - { - DEF_OP_NUMERIC2(int32, uint32, I32, >>); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I32_SHR_U): - { - DEF_OP_NUMERIC2(uint32, uint32, I32, >>); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I32_ROTL): - { - uint32 a, b; - - b = (uint32)frame_lp[GET_OFFSET()]; - a = (uint32)frame_lp[GET_OFFSET()]; - frame_lp[GET_OFFSET()] = rotl32(a, b); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I32_ROTR): - { - uint32 a, b; - - b = (uint32)frame_lp[GET_OFFSET()]; - a = (uint32)frame_lp[GET_OFFSET()]; - frame_lp[GET_OFFSET()] = rotr32(a, b); - HANDLE_OP_END (); - } - - /* numberic instructions of i64 */ - HANDLE_OP (WASM_OP_I64_CLZ): - DEF_OP_BIT_COUNT(uint64, I64, clz64); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_CTZ): - DEF_OP_BIT_COUNT(uint64, I64, ctz64); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_POPCNT): - DEF_OP_BIT_COUNT(uint64, I64, popcount64); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_ADD): - DEF_OP_NUMERIC_64(uint64, uint64, I64, +); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_SUB): - DEF_OP_NUMERIC_64(uint64, uint64, I64, -); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_MUL): - DEF_OP_NUMERIC_64(uint64, uint64, I64, *); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_DIV_S): - { - int64 a, b; - - b = GET_I64_FROM_ADDR(frame_lp + GET_OFFSET()); - a = GET_I64_FROM_ADDR(frame_lp + GET_OFFSET()); - if (a == (int64)0x8000000000000000LL && b == -1) { - wasm_set_exception(module, "integer overflow"); - goto got_exception; - } - if (b == 0) { - wasm_set_exception(module, "integer divide by zero"); - goto got_exception; - } - PUT_I64_TO_ADDR(frame_lp + GET_OFFSET(), a / b); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I64_DIV_U): - { - uint64 a, b; - - b = GET_I64_FROM_ADDR(frame_lp + GET_OFFSET()); - a = GET_I64_FROM_ADDR(frame_lp + GET_OFFSET()); - if (b == 0) { - wasm_set_exception(module, "integer divide by zero"); - goto got_exception; - } - PUT_I64_TO_ADDR(frame_lp + GET_OFFSET(), a / b); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I64_REM_S): - { - int64 a, b; - - b = GET_I64_FROM_ADDR(frame_lp + GET_OFFSET()); - a = GET_I64_FROM_ADDR(frame_lp + GET_OFFSET()); - if (a == (int64)0x8000000000000000LL && b == -1) { - *(int64*)(frame_lp + GET_OFFSET()) = 0; - HANDLE_OP_END (); - } - if (b == 0) { - wasm_set_exception(module, "integer divide by zero"); - goto got_exception; - } - PUT_I64_TO_ADDR(frame_lp + GET_OFFSET(), a % b); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I64_REM_U): - { - uint64 a, b; - - b = GET_I64_FROM_ADDR(frame_lp + GET_OFFSET()); - a = GET_I64_FROM_ADDR(frame_lp + GET_OFFSET()); - if (b == 0) { - wasm_set_exception(module, "integer divide by zero"); - goto got_exception; - } - PUT_I64_TO_ADDR(frame_lp + GET_OFFSET(), a % b); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I64_AND): - DEF_OP_NUMERIC_64(uint64, uint64, I64, &); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_OR): - DEF_OP_NUMERIC_64(uint64, uint64, I64, |); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_XOR): - DEF_OP_NUMERIC_64(uint64, uint64, I64, ^); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_SHL): - { - DEF_OP_NUMERIC2_64(uint64, uint64, I64, <<); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I64_SHR_S): - { - DEF_OP_NUMERIC2_64(int64, uint64, I64, >>); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I64_SHR_U): - { - DEF_OP_NUMERIC2_64(uint64, uint64, I64, >>); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I64_ROTL): - { - uint64 a, b; - - b = GET_I64_FROM_ADDR(frame_lp + GET_OFFSET()); - a = GET_I64_FROM_ADDR(frame_lp + GET_OFFSET()); - PUT_I64_TO_ADDR(frame_lp + GET_OFFSET(), rotl64(a, b)); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I64_ROTR): - { - uint64 a, b; - - b = GET_I64_FROM_ADDR(frame_lp + GET_OFFSET()); - a = GET_I64_FROM_ADDR(frame_lp + GET_OFFSET()); - PUT_I64_TO_ADDR(frame_lp + GET_OFFSET(), rotr64(a, b)); - HANDLE_OP_END (); - } - - /* numberic instructions of f32 */ - HANDLE_OP (WASM_OP_F32_ABS): - DEF_OP_MATH(float32, F32, fabs); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_NEG): - { - uint32 u32 = frame_lp[GET_OFFSET()]; - uint32 sign_bit = u32 & ((uint32)1 << 31); - addr_ret = GET_OFFSET(); - if (sign_bit) - frame_lp[addr_ret] = u32 & ~((uint32)1 << 31); - else - frame_lp[addr_ret] = u32 | ((uint32)1 << 31); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_F32_CEIL): - DEF_OP_MATH(float32, F32, ceil); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_FLOOR): - DEF_OP_MATH(float32, F32, floor); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_TRUNC): - DEF_OP_MATH(float32, F32, trunc); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_NEAREST): - DEF_OP_MATH(float32, F32, rint); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_SQRT): - DEF_OP_MATH(float32, F32, sqrt); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_ADD): - DEF_OP_NUMERIC(float32, float32, F32, +); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_SUB): - DEF_OP_NUMERIC(float32, float32, F32, -); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_MUL): - DEF_OP_NUMERIC(float32, float32, F32, *); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_DIV): - DEF_OP_NUMERIC(float32, float32, F32, /); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_MIN): - { - float32 a, b; - - b = *(float32*)(frame_lp + GET_OFFSET()); - a = *(float32*)(frame_lp + GET_OFFSET()); - - if (isnan(a)) - *(float32*)(frame_lp + GET_OFFSET()) = a; - else if (isnan(b)) - *(float32*)(frame_lp + GET_OFFSET()) = b; - else - *(float32*)(frame_lp + GET_OFFSET()) = (float32)wa_fmin(a, b); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_F32_MAX): - { - float32 a, b; - - b = *(float32*)(frame_lp + GET_OFFSET()); - a = *(float32*)(frame_lp + GET_OFFSET()); - - if (isnan(a)) - *(float32*)(frame_lp + GET_OFFSET()) = a; - else if (isnan(b)) - *(float32*)(frame_lp + GET_OFFSET()) = b; - else - *(float32*)(frame_lp + GET_OFFSET()) = (float32)wa_fmax(a, b); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_F32_COPYSIGN): - { - float32 a, b; - - b = *(float32*)(frame_lp + GET_OFFSET()); - a = *(float32*)(frame_lp + GET_OFFSET()); - *(float32*)(frame_lp + GET_OFFSET()) = - (float32)(signbit(b) ? -fabs(a) : fabs(a)); - HANDLE_OP_END (); - } - - /* numberic instructions of f64 */ - HANDLE_OP (WASM_OP_F64_ABS): - DEF_OP_MATH(float64, F64, fabs); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_NEG): - { - uint64 u64 = GET_I64_FROM_ADDR(frame_lp + GET_OFFSET()); - uint64 sign_bit = u64 & (((uint64)1) << 63); - if (sign_bit) - PUT_I64_TO_ADDR(frame_lp + GET_OFFSET(), - (u64 & ~(((uint64)1) << 63))); - else - PUT_I64_TO_ADDR(frame_lp + GET_OFFSET(), - (u64 | (((uint64)1) << 63))); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_F64_CEIL): - DEF_OP_MATH(float64, F64, ceil); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_FLOOR): - DEF_OP_MATH(float64, F64, floor); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_TRUNC): - DEF_OP_MATH(float64, F64, trunc); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_NEAREST): - DEF_OP_MATH(float64, F64, rint); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_SQRT): - DEF_OP_MATH(float64, F64, sqrt); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_ADD): - DEF_OP_NUMERIC_64(float64, float64, F64, +); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_SUB): - DEF_OP_NUMERIC_64(float64, float64, F64, -); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_MUL): - DEF_OP_NUMERIC_64(float64, float64, F64, *); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_DIV): - DEF_OP_NUMERIC_64(float64, float64, F64, /); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_MIN): - { - float64 a, b; - - b = POP_F64(); - a = POP_F64(); - - if (isnan(a)) - PUSH_F64(a); - else if (isnan(b)) - PUSH_F64(b); - else - PUSH_F64(wa_fmin(a, b)); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_F64_MAX): - { - float64 a, b; - - b = POP_F64(); - a = POP_F64(); - - if (isnan(a)) - PUSH_F64(a); - else if (isnan(b)) - PUSH_F64(b); - else - PUSH_F64(wa_fmax(a, b)); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_F64_COPYSIGN): - { - float64 a, b; - - b = POP_F64(); - a = POP_F64(); - PUSH_F64(signbit(b) ? -fabs(a) : fabs(a)); - HANDLE_OP_END (); - } - - /* conversions of i32 */ - HANDLE_OP (WASM_OP_I32_WRAP_I64): - { - int32 value = (int32)(POP_I64() & 0xFFFFFFFFLL); - PUSH_I32(value); - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I32_TRUNC_S_F32): - /* We don't use INT32_MIN/INT32_MAX/UINT32_MIN/UINT32_MAX, - since float/double values of ieee754 cannot precisely represent - all int32/uint32/int64/uint64 values, e.g.: - UINT32_MAX is 4294967295, but (float32)4294967295 is 4294967296.0f, - but not 4294967295.0f. */ - DEF_OP_TRUNC_F32(-2147483904.0f, 2147483648.0f, true, true); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_TRUNC_U_F32): - DEF_OP_TRUNC_F32(-1.0f, 4294967296.0f, true, false); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_TRUNC_S_F64): - DEF_OP_TRUNC_F64(-2147483649.0, 2147483648.0, true, true); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_TRUNC_U_F64): - DEF_OP_TRUNC_F64(-1.0, 4294967296.0, true, false); - HANDLE_OP_END (); - - /* conversions of i64 */ - HANDLE_OP (WASM_OP_I64_EXTEND_S_I32): - DEF_OP_CONVERT(int64, I64, int32, I32); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_EXTEND_U_I32): - DEF_OP_CONVERT(int64, I64, uint32, I32); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_TRUNC_S_F32): - DEF_OP_TRUNC_F32(-9223373136366403584.0f, - 9223372036854775808.0f, false, true); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_TRUNC_U_F32): - DEF_OP_TRUNC_F32(-1.0f, 18446744073709551616.0f, - false, false); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_TRUNC_S_F64): - DEF_OP_TRUNC_F64(-9223372036854777856.0, - 9223372036854775808.0, false, true); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_TRUNC_U_F64): - DEF_OP_TRUNC_F64(-1.0, 18446744073709551616.0, - false, false); - HANDLE_OP_END (); - - /* conversions of f32 */ - HANDLE_OP (WASM_OP_F32_CONVERT_S_I32): - DEF_OP_CONVERT(float32, F32, int32, I32); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_CONVERT_U_I32): - DEF_OP_CONVERT(float32, F32, uint32, I32); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_CONVERT_S_I64): - DEF_OP_CONVERT(float32, F32, int64, I64); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_CONVERT_U_I64): - DEF_OP_CONVERT(float32, F32, uint64, I64); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F32_DEMOTE_F64): - DEF_OP_CONVERT(float32, F32, float64, F64); - HANDLE_OP_END (); - - /* conversions of f64 */ - HANDLE_OP (WASM_OP_F64_CONVERT_S_I32): - DEF_OP_CONVERT(float64, F64, int32, I32); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_CONVERT_U_I32): - DEF_OP_CONVERT(float64, F64, uint32, I32); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_CONVERT_S_I64): - DEF_OP_CONVERT(float64, F64, int64, I64); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_CONVERT_U_I64): - DEF_OP_CONVERT(float64, F64, uint64, I64); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_F64_PROMOTE_F32): - DEF_OP_CONVERT(float64, F64, float32, F32); - HANDLE_OP_END (); - - /* reinterpretations */ - HANDLE_OP (WASM_OP_I32_REINTERPRET_F32): - HANDLE_OP (WASM_OP_F32_REINTERPRET_I32): - DEF_OP_REINTERPRET(uint32, I32); - HANDLE_OP_END (); - HANDLE_OP (WASM_OP_I64_REINTERPRET_F64): - HANDLE_OP (WASM_OP_F64_REINTERPRET_I64): - DEF_OP_REINTERPRET(int64, I64); - HANDLE_OP_END (); - - HANDLE_OP (EXT_OP_COPY_STACK_TOP): - addr1 = GET_OFFSET(); - addr2 = GET_OFFSET(); - frame_lp[addr2] = frame_lp[addr1]; - HANDLE_OP_END (); - - HANDLE_OP (EXT_OP_COPY_STACK_TOP_I64): - addr1 = GET_OFFSET(); - addr2 = GET_OFFSET(); - frame_lp[addr2] = frame_lp[addr1]; - frame_lp[addr2 + 1] = frame_lp[addr1 + 1]; - HANDLE_OP_END (); - - HANDLE_OP (EXT_OP_COPY_STACK_VALUES): - { - uint32 values_count, total_cell; - uint8 *cells; - int16 *src_offsets = NULL; - uint16 *dst_offsets = NULL; - - /* read values_count */ - values_count = read_uint32(frame_ip); - /* read total cell num */ - total_cell = read_uint32(frame_ip); - /* cells */ - cells = (uint8 *)frame_ip; - frame_ip += values_count * CELL_SIZE; - /* src offsets */ - src_offsets = (int16 *)frame_ip; - frame_ip += values_count * sizeof(int16); - /* dst offsets */ - dst_offsets = (uint16*)frame_ip; - frame_ip += values_count * sizeof(uint16); - - if (!copy_stack_values(module, frame_lp, values_count, - total_cell, cells, - src_offsets, dst_offsets)) - goto got_exception; - - HANDLE_OP_END (); - } - HANDLE_OP (WASM_OP_SET_LOCAL): - HANDLE_OP (WASM_OP_TEE_LOCAL): - { - GET_LOCAL_INDEX_TYPE_AND_OFFSET(); - addr1 = GET_OFFSET(); - - if (local_type == VALUE_TYPE_I32 - || local_type == VALUE_TYPE_F32) { - *(int32*)(frame_lp + local_offset) = frame_lp[addr1]; - } - else if (local_type == VALUE_TYPE_I64 - || local_type == VALUE_TYPE_F64) { - PUT_I64_TO_ADDR((uint32*)(frame_lp + local_offset), - GET_I64_FROM_ADDR(frame_lp + addr1)); - } - else { - wasm_set_exception(module, "invalid local type"); - goto got_exception; - } - - HANDLE_OP_END (); - } - - HANDLE_OP (WASM_OP_I32_EXTEND8_S): - DEF_OP_CONVERT(int32, I32, int8, I32); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I32_EXTEND16_S): - DEF_OP_CONVERT(int32, I32, int16, I32); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_EXTEND8_S): - DEF_OP_CONVERT(int64, I64, int8, I64); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_EXTEND16_S): - DEF_OP_CONVERT(int64, I64, int16, I64); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_I64_EXTEND32_S): - DEF_OP_CONVERT(int64, I64, int32, I64); - HANDLE_OP_END (); - - HANDLE_OP (WASM_OP_MISC_PREFIX): - { - GET_OPCODE(); - switch (opcode) - { - case WASM_OP_I32_TRUNC_SAT_S_F32: - DEF_OP_TRUNC_SAT_F32(-2147483904.0f, 2147483648.0f, - true, true); - break; - case WASM_OP_I32_TRUNC_SAT_U_F32: - DEF_OP_TRUNC_SAT_F32(-1.0f, 4294967296.0f, - true, false); - break; - case WASM_OP_I32_TRUNC_SAT_S_F64: - DEF_OP_TRUNC_SAT_F64(-2147483649.0, 2147483648.0, - true, true); - break; - case WASM_OP_I32_TRUNC_SAT_U_F64: - DEF_OP_TRUNC_SAT_F64(-1.0, 4294967296.0, - true, false); - break; - case WASM_OP_I64_TRUNC_SAT_S_F32: - DEF_OP_TRUNC_SAT_F32(-9223373136366403584.0f, 9223372036854775808.0f, - false, true); - break; - case WASM_OP_I64_TRUNC_SAT_U_F32: - DEF_OP_TRUNC_SAT_F32(-1.0f, 18446744073709551616.0f, - false, false); - break; - case WASM_OP_I64_TRUNC_SAT_S_F64: - DEF_OP_TRUNC_SAT_F64(-9223372036854777856.0, 9223372036854775808.0, - false, true); - break; - case WASM_OP_I64_TRUNC_SAT_U_F64: - DEF_OP_TRUNC_SAT_F64(-1.0, 18446744073709551616.0, - false, false); - break; + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_SET_GLOBAL_64) + { + global_idx = read_uint32(frame_ip); + bh_assert(global_idx < module->global_count); + global = globals + global_idx; + global_addr = get_global_addr(global_data, global); + addr1 = GET_OFFSET(); + PUT_I64_TO_ADDR((uint32 *)global_addr, + GET_I64_FROM_ADDR(frame_lp + addr1)); + HANDLE_OP_END(); + } + + /* memory load instructions */ + HANDLE_OP(WASM_OP_I32_LOAD) + { + uint32 offset, addr; + offset = read_uint32(frame_ip); + addr = GET_OPERAND(uint32, I32, 0); + frame_ip += 2; + addr_ret = GET_OFFSET(); + CHECK_MEMORY_OVERFLOW(4); + frame_lp[addr_ret] = LOAD_I32(maddr); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_LOAD) + { + uint32 offset, addr; + offset = read_uint32(frame_ip); + addr = GET_OPERAND(uint32, I32, 0); + frame_ip += 2; + addr_ret = GET_OFFSET(); + CHECK_MEMORY_OVERFLOW(8); + PUT_I64_TO_ADDR(frame_lp + addr_ret, LOAD_I64(maddr)); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_LOAD8_S) + { + uint32 offset, addr; + offset = read_uint32(frame_ip); + addr = GET_OPERAND(uint32, I32, 0); + frame_ip += 2; + addr_ret = GET_OFFSET(); + CHECK_MEMORY_OVERFLOW(1); + frame_lp[addr_ret] = sign_ext_8_32(*(int8 *)maddr); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_LOAD8_U) + { + uint32 offset, addr; + offset = read_uint32(frame_ip); + addr = GET_OPERAND(uint32, I32, 0); + frame_ip += 2; + addr_ret = GET_OFFSET(); + CHECK_MEMORY_OVERFLOW(1); + frame_lp[addr_ret] = (uint32)(*(uint8 *)maddr); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_LOAD16_S) + { + uint32 offset, addr; + offset = read_uint32(frame_ip); + addr = GET_OPERAND(uint32, I32, 0); + frame_ip += 2; + addr_ret = GET_OFFSET(); + CHECK_MEMORY_OVERFLOW(2); + frame_lp[addr_ret] = sign_ext_16_32(LOAD_I16(maddr)); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_LOAD16_U) + { + uint32 offset, addr; + offset = read_uint32(frame_ip); + addr = GET_OPERAND(uint32, I32, 0); + frame_ip += 2; + addr_ret = GET_OFFSET(); + CHECK_MEMORY_OVERFLOW(2); + frame_lp[addr_ret] = (uint32)(LOAD_U16(maddr)); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_LOAD8_S) + { + uint32 offset, addr; + offset = read_uint32(frame_ip); + addr = GET_OPERAND(uint32, I32, 0); + frame_ip += 2; + addr_ret = GET_OFFSET(); + CHECK_MEMORY_OVERFLOW(1); + PUT_I64_TO_ADDR(frame_lp + addr_ret, + sign_ext_8_64(*(int8 *)maddr)); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_LOAD8_U) + { + uint32 offset, addr; + offset = read_uint32(frame_ip); + addr = GET_OPERAND(uint32, I32, 0); + frame_ip += 2; + addr_ret = GET_OFFSET(); + CHECK_MEMORY_OVERFLOW(1); + PUT_I64_TO_ADDR(frame_lp + addr_ret, (uint64)(*(uint8 *)maddr)); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_LOAD16_S) + { + uint32 offset, addr; + offset = read_uint32(frame_ip); + addr = GET_OPERAND(uint32, I32, 0); + frame_ip += 2; + addr_ret = GET_OFFSET(); + CHECK_MEMORY_OVERFLOW(2); + PUT_I64_TO_ADDR(frame_lp + addr_ret, + sign_ext_16_64(LOAD_I16(maddr))); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_LOAD16_U) + { + uint32 offset, addr; + offset = read_uint32(frame_ip); + addr = GET_OPERAND(uint32, I32, 0); + frame_ip += 2; + addr_ret = GET_OFFSET(); + CHECK_MEMORY_OVERFLOW(2); + PUT_I64_TO_ADDR(frame_lp + addr_ret, (uint64)(LOAD_U16(maddr))); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_LOAD32_S) + { + uint32 offset, addr; + offset = read_uint32(frame_ip); + addr = GET_OPERAND(uint32, I32, 0); + frame_ip += 2; + addr_ret = GET_OFFSET(); + CHECK_MEMORY_OVERFLOW(4); + PUT_I64_TO_ADDR(frame_lp + addr_ret, + sign_ext_32_64(LOAD_I32(maddr))); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_LOAD32_U) + { + uint32 offset, addr; + offset = read_uint32(frame_ip); + addr = GET_OPERAND(uint32, I32, 0); + frame_ip += 2; + addr_ret = GET_OFFSET(); + CHECK_MEMORY_OVERFLOW(4); + PUT_I64_TO_ADDR(frame_lp + addr_ret, (uint64)(LOAD_U32(maddr))); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_STORE) + { + uint32 offset, addr; + uint32 sval; + offset = read_uint32(frame_ip); + sval = GET_OPERAND(uint32, I32, 0); + addr = GET_OPERAND(uint32, I32, 2); + frame_ip += 4; + CHECK_MEMORY_OVERFLOW(4); + STORE_U32(maddr, sval); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_STORE8) + { + uint32 offset, addr; + uint32 sval; + offset = read_uint32(frame_ip); + sval = GET_OPERAND(uint32, I32, 0); + addr = GET_OPERAND(uint32, I32, 2); + frame_ip += 4; + CHECK_MEMORY_OVERFLOW(1); + *(uint8 *)maddr = (uint8)sval; + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_STORE16) + { + uint32 offset, addr; + uint32 sval; + offset = read_uint32(frame_ip); + sval = GET_OPERAND(uint32, I32, 0); + addr = GET_OPERAND(uint32, I32, 2); + frame_ip += 4; + CHECK_MEMORY_OVERFLOW(2); + STORE_U16(maddr, (uint16)sval); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_STORE) + { + uint32 offset, addr; + uint64 sval; + offset = read_uint32(frame_ip); + sval = GET_OPERAND(uint64, I64, 0); + addr = GET_OPERAND(uint32, I32, 2); + frame_ip += 4; + CHECK_MEMORY_OVERFLOW(8); + STORE_I64(maddr, sval); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_STORE8) + { + uint32 offset, addr; + uint64 sval; + offset = read_uint32(frame_ip); + sval = GET_OPERAND(uint64, I64, 0); + addr = GET_OPERAND(uint32, I32, 2); + frame_ip += 4; + CHECK_MEMORY_OVERFLOW(1); + *(uint8 *)maddr = (uint8)sval; + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_STORE16) + { + uint32 offset, addr; + uint64 sval; + offset = read_uint32(frame_ip); + sval = GET_OPERAND(uint64, I64, 0); + addr = GET_OPERAND(uint32, I32, 2); + frame_ip += 4; + CHECK_MEMORY_OVERFLOW(2); + STORE_U16(maddr, (uint16)sval); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_STORE32) + { + uint32 offset, addr; + uint64 sval; + offset = read_uint32(frame_ip); + sval = GET_OPERAND(uint64, I64, 0); + addr = GET_OPERAND(uint32, I32, 2); + frame_ip += 4; + CHECK_MEMORY_OVERFLOW(4); + STORE_U32(maddr, (uint32)sval); + HANDLE_OP_END(); + } + + /* memory size and memory grow instructions */ + HANDLE_OP(WASM_OP_MEMORY_SIZE) + { + uint32 reserved; + addr_ret = GET_OFFSET(); + frame_lp[addr_ret] = memory->cur_page_count; + (void)reserved; + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_MEMORY_GROW) + { + uint32 reserved, delta, + prev_page_count = memory->cur_page_count; + + addr1 = GET_OFFSET(); + addr_ret = GET_OFFSET(); + delta = (uint32)frame_lp[addr1]; + + if (!wasm_enlarge_memory(module, delta)) { + /* failed to memory.grow, return -1 */ + frame_lp[addr_ret] = -1; + } + else { + /* success, return previous page count */ + frame_lp[addr_ret] = prev_page_count; + /* update memory instance ptr and memory size */ + memory = module->default_memory; + linear_mem_size = + num_bytes_per_page * memory->cur_page_count; + } + + (void)reserved; + HANDLE_OP_END(); + } + + /* comparison instructions of i32 */ + HANDLE_OP(WASM_OP_I32_EQZ) + { + DEF_OP_EQZ(int32, I32); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_EQ) + { + DEF_OP_CMP(uint32, I32, ==); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_NE) + { + DEF_OP_CMP(uint32, I32, !=); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_LT_S) + { + DEF_OP_CMP(int32, I32, <); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_LT_U) + { + DEF_OP_CMP(uint32, I32, <); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_GT_S) + { + DEF_OP_CMP(int32, I32, >); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_GT_U) + { + DEF_OP_CMP(uint32, I32, >); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_LE_S) + { + DEF_OP_CMP(int32, I32, <=); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_LE_U) + { + DEF_OP_CMP(uint32, I32, <=); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_GE_S) + { + DEF_OP_CMP(int32, I32, >=); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_GE_U) + { + DEF_OP_CMP(uint32, I32, >=); + HANDLE_OP_END(); + } + + /* comparison instructions of i64 */ + HANDLE_OP(WASM_OP_I64_EQZ) + { + DEF_OP_EQZ(int64, I64); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_EQ) + { + DEF_OP_CMP(uint64, I64, ==); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_NE) + { + DEF_OP_CMP(uint64, I64, !=); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_LT_S) + { + DEF_OP_CMP(int64, I64, <); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_LT_U) + { + DEF_OP_CMP(uint64, I64, <); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_GT_S) + { + DEF_OP_CMP(int64, I64, >); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_GT_U) + { + DEF_OP_CMP(uint64, I64, >); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_LE_S) + { + DEF_OP_CMP(int64, I64, <=); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_LE_U) + { + DEF_OP_CMP(uint64, I64, <=); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_GE_S) + { + DEF_OP_CMP(int64, I64, >=); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_GE_U) + { + DEF_OP_CMP(uint64, I64, >=); + HANDLE_OP_END(); + } + + /* comparison instructions of f32 */ + HANDLE_OP(WASM_OP_F32_EQ) + { + DEF_OP_CMP(float32, F32, ==); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_NE) + { + DEF_OP_CMP(float32, F32, !=); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_LT) + { + DEF_OP_CMP(float32, F32, <); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_GT) + { + DEF_OP_CMP(float32, F32, >); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_LE) + { + DEF_OP_CMP(float32, F32, <=); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_GE) + { + DEF_OP_CMP(float32, F32, >=); + HANDLE_OP_END(); + } + + /* comparison instructions of f64 */ + HANDLE_OP(WASM_OP_F64_EQ) + { + DEF_OP_CMP(float64, F64, ==); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_NE) + { + DEF_OP_CMP(float64, F64, !=); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_LT) + { + DEF_OP_CMP(float64, F64, <); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_GT) + { + DEF_OP_CMP(float64, F64, >); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_LE) + { + DEF_OP_CMP(float64, F64, <=); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_GE) + { + DEF_OP_CMP(float64, F64, >=); + HANDLE_OP_END(); + } + + /* numberic instructions of i32 */ + HANDLE_OP(WASM_OP_I32_CLZ) + { + DEF_OP_BIT_COUNT(uint32, I32, clz32); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_CTZ) + { + DEF_OP_BIT_COUNT(uint32, I32, ctz32); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_POPCNT) + { + DEF_OP_BIT_COUNT(uint32, I32, popcount32); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_ADD) + { + DEF_OP_NUMERIC(uint32, uint32, I32, +); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_SUB) + { + DEF_OP_NUMERIC(uint32, uint32, I32, -); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_MUL) + { + DEF_OP_NUMERIC(uint32, uint32, I32, *); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_DIV_S) + { + int32 a, b; + + b = frame_lp[GET_OFFSET()]; + a = frame_lp[GET_OFFSET()]; + addr_ret = GET_OFFSET(); + if (a == (int32)0x80000000 && b == -1) { + wasm_set_exception(module, "integer overflow"); + goto got_exception; + } + if (b == 0) { + wasm_set_exception(module, "integer divide by zero"); + goto got_exception; + } + frame_lp[addr_ret] = (a / b); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_DIV_U) + { + uint32 a, b; + + addr1 = GET_OFFSET(); + addr2 = GET_OFFSET(); + addr_ret = GET_OFFSET(); + + b = (uint32)frame_lp[addr1]; + a = (uint32)frame_lp[addr2]; + if (b == 0) { + wasm_set_exception(module, "integer divide by zero"); + goto got_exception; + } + frame_lp[addr_ret] = (a / b); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_REM_S) + { + int32 a, b; + + addr1 = GET_OFFSET(); + addr2 = GET_OFFSET(); + addr_ret = GET_OFFSET(); + + b = frame_lp[addr1]; + a = frame_lp[addr2]; + if (a == (int32)0x80000000 && b == -1) { + frame_lp[addr_ret] = 0; + HANDLE_OP_END(); + } + if (b == 0) { + wasm_set_exception(module, "integer divide by zero"); + goto got_exception; + } + frame_lp[addr_ret] = (a % b); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_REM_U) + { + uint32 a, b; + + addr1 = GET_OFFSET(); + addr2 = GET_OFFSET(); + addr_ret = GET_OFFSET(); + + b = (uint32)frame_lp[addr1]; + a = (uint32)frame_lp[addr2]; + if (b == 0) { + wasm_set_exception(module, "integer divide by zero"); + goto got_exception; + } + frame_lp[addr_ret] = (a % b); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_AND) + { + DEF_OP_NUMERIC(uint32, uint32, I32, &); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_OR) + { + DEF_OP_NUMERIC(uint32, uint32, I32, |); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_XOR) + { + DEF_OP_NUMERIC(uint32, uint32, I32, ^); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_SHL) + { + DEF_OP_NUMERIC2(uint32, uint32, I32, <<); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_SHR_S) + { + DEF_OP_NUMERIC2(int32, uint32, I32, >>); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_SHR_U) + { + DEF_OP_NUMERIC2(uint32, uint32, I32, >>); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_ROTL) + { + uint32 a, b; + + b = (uint32)frame_lp[GET_OFFSET()]; + a = (uint32)frame_lp[GET_OFFSET()]; + frame_lp[GET_OFFSET()] = rotl32(a, b); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_ROTR) + { + uint32 a, b; + + b = (uint32)frame_lp[GET_OFFSET()]; + a = (uint32)frame_lp[GET_OFFSET()]; + frame_lp[GET_OFFSET()] = rotr32(a, b); + HANDLE_OP_END(); + } + + /* numberic instructions of i64 */ + HANDLE_OP(WASM_OP_I64_CLZ) + { + DEF_OP_BIT_COUNT(uint64, I64, clz64); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_CTZ) + { + DEF_OP_BIT_COUNT(uint64, I64, ctz64); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_POPCNT) + { + DEF_OP_BIT_COUNT(uint64, I64, popcount64); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_ADD) + { + DEF_OP_NUMERIC_64(uint64, uint64, I64, +); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_SUB) + { + DEF_OP_NUMERIC_64(uint64, uint64, I64, -); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_MUL) + { + DEF_OP_NUMERIC_64(uint64, uint64, I64, *); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_DIV_S) + { + int64 a, b; + + b = GET_I64_FROM_ADDR(frame_lp + GET_OFFSET()); + a = GET_I64_FROM_ADDR(frame_lp + GET_OFFSET()); + if (a == (int64)0x8000000000000000LL && b == -1) { + wasm_set_exception(module, "integer overflow"); + goto got_exception; + } + if (b == 0) { + wasm_set_exception(module, "integer divide by zero"); + goto got_exception; + } + PUT_I64_TO_ADDR(frame_lp + GET_OFFSET(), a / b); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_DIV_U) + { + uint64 a, b; + + b = GET_I64_FROM_ADDR(frame_lp + GET_OFFSET()); + a = GET_I64_FROM_ADDR(frame_lp + GET_OFFSET()); + if (b == 0) { + wasm_set_exception(module, "integer divide by zero"); + goto got_exception; + } + PUT_I64_TO_ADDR(frame_lp + GET_OFFSET(), a / b); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_REM_S) + { + int64 a, b; + + b = GET_I64_FROM_ADDR(frame_lp + GET_OFFSET()); + a = GET_I64_FROM_ADDR(frame_lp + GET_OFFSET()); + if (a == (int64)0x8000000000000000LL && b == -1) { + *(int64 *)(frame_lp + GET_OFFSET()) = 0; + HANDLE_OP_END(); + } + if (b == 0) { + wasm_set_exception(module, "integer divide by zero"); + goto got_exception; + } + PUT_I64_TO_ADDR(frame_lp + GET_OFFSET(), a % b); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_REM_U) + { + uint64 a, b; + + b = GET_I64_FROM_ADDR(frame_lp + GET_OFFSET()); + a = GET_I64_FROM_ADDR(frame_lp + GET_OFFSET()); + if (b == 0) { + wasm_set_exception(module, "integer divide by zero"); + goto got_exception; + } + PUT_I64_TO_ADDR(frame_lp + GET_OFFSET(), a % b); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_AND) + { + DEF_OP_NUMERIC_64(uint64, uint64, I64, &); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_OR) + { + DEF_OP_NUMERIC_64(uint64, uint64, I64, |); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_XOR) + { + DEF_OP_NUMERIC_64(uint64, uint64, I64, ^); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_SHL) + { + DEF_OP_NUMERIC2_64(uint64, uint64, I64, <<); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_SHR_S) + { + DEF_OP_NUMERIC2_64(int64, uint64, I64, >>); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_SHR_U) + { + DEF_OP_NUMERIC2_64(uint64, uint64, I64, >>); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_ROTL) + { + uint64 a, b; + + b = GET_I64_FROM_ADDR(frame_lp + GET_OFFSET()); + a = GET_I64_FROM_ADDR(frame_lp + GET_OFFSET()); + PUT_I64_TO_ADDR(frame_lp + GET_OFFSET(), rotl64(a, b)); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_ROTR) + { + uint64 a, b; + + b = GET_I64_FROM_ADDR(frame_lp + GET_OFFSET()); + a = GET_I64_FROM_ADDR(frame_lp + GET_OFFSET()); + PUT_I64_TO_ADDR(frame_lp + GET_OFFSET(), rotr64(a, b)); + HANDLE_OP_END(); + } + + /* numberic instructions of f32 */ + HANDLE_OP(WASM_OP_F32_ABS) + { + DEF_OP_MATH(float32, F32, fabs); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_NEG) + { + uint32 u32 = frame_lp[GET_OFFSET()]; + uint32 sign_bit = u32 & ((uint32)1 << 31); + addr_ret = GET_OFFSET(); + if (sign_bit) + frame_lp[addr_ret] = u32 & ~((uint32)1 << 31); + else + frame_lp[addr_ret] = u32 | ((uint32)1 << 31); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_CEIL) + { + DEF_OP_MATH(float32, F32, ceil); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_FLOOR) + { + DEF_OP_MATH(float32, F32, floor); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_TRUNC) + { + DEF_OP_MATH(float32, F32, trunc); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_NEAREST) + { + DEF_OP_MATH(float32, F32, rint); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_SQRT) + { + DEF_OP_MATH(float32, F32, sqrt); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_ADD) + { + DEF_OP_NUMERIC(float32, float32, F32, +); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_SUB) + { + DEF_OP_NUMERIC(float32, float32, F32, -); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_MUL) + { + DEF_OP_NUMERIC(float32, float32, F32, *); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_DIV) + { + DEF_OP_NUMERIC(float32, float32, F32, /); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_MIN) + { + float32 a, b; + + b = *(float32 *)(frame_lp + GET_OFFSET()); + a = *(float32 *)(frame_lp + GET_OFFSET()); + + if (isnan(a)) + *(float32 *)(frame_lp + GET_OFFSET()) = a; + else if (isnan(b)) + *(float32 *)(frame_lp + GET_OFFSET()) = b; + else + *(float32 *)(frame_lp + GET_OFFSET()) = + (float32)wa_fmin(a, b); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_MAX) + { + float32 a, b; + + b = *(float32 *)(frame_lp + GET_OFFSET()); + a = *(float32 *)(frame_lp + GET_OFFSET()); + + if (isnan(a)) + *(float32 *)(frame_lp + GET_OFFSET()) = a; + else if (isnan(b)) + *(float32 *)(frame_lp + GET_OFFSET()) = b; + else + *(float32 *)(frame_lp + GET_OFFSET()) = + (float32)wa_fmax(a, b); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_COPYSIGN) + { + float32 a, b; + + b = *(float32 *)(frame_lp + GET_OFFSET()); + a = *(float32 *)(frame_lp + GET_OFFSET()); + *(float32 *)(frame_lp + GET_OFFSET()) = + (float32)(signbit(b) ? -fabs(a) : fabs(a)); + HANDLE_OP_END(); + } + + /* numberic instructions of f64 */ + HANDLE_OP(WASM_OP_F64_ABS) + { + DEF_OP_MATH(float64, F64, fabs); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_NEG) + { + uint64 u64 = GET_I64_FROM_ADDR(frame_lp + GET_OFFSET()); + uint64 sign_bit = u64 & (((uint64)1) << 63); + if (sign_bit) + PUT_I64_TO_ADDR(frame_lp + GET_OFFSET(), + (u64 & ~(((uint64)1) << 63))); + else + PUT_I64_TO_ADDR(frame_lp + GET_OFFSET(), + (u64 | (((uint64)1) << 63))); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_CEIL) + { + DEF_OP_MATH(float64, F64, ceil); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_FLOOR) + { + DEF_OP_MATH(float64, F64, floor); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_TRUNC) + { + DEF_OP_MATH(float64, F64, trunc); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_NEAREST) + { + DEF_OP_MATH(float64, F64, rint); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_SQRT) + { + DEF_OP_MATH(float64, F64, sqrt); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_ADD) + { + DEF_OP_NUMERIC_64(float64, float64, F64, +); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_SUB) + { + DEF_OP_NUMERIC_64(float64, float64, F64, -); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_MUL) + { + DEF_OP_NUMERIC_64(float64, float64, F64, *); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_DIV) + { + DEF_OP_NUMERIC_64(float64, float64, F64, /); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_MIN) + { + float64 a, b; + + b = POP_F64(); + a = POP_F64(); + + if (isnan(a)) + PUSH_F64(a); + else if (isnan(b)) + PUSH_F64(b); + else + PUSH_F64(wa_fmin(a, b)); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_MAX) + { + float64 a, b; + + b = POP_F64(); + a = POP_F64(); + + if (isnan(a)) + PUSH_F64(a); + else if (isnan(b)) + PUSH_F64(b); + else + PUSH_F64(wa_fmax(a, b)); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_COPYSIGN) + { + float64 a, b; + + b = POP_F64(); + a = POP_F64(); + PUSH_F64(signbit(b) ? -fabs(a) : fabs(a)); + HANDLE_OP_END(); + } + + /* conversions of i32 */ + HANDLE_OP(WASM_OP_I32_WRAP_I64) + { + int32 value = (int32)(POP_I64() & 0xFFFFFFFFLL); + PUSH_I32(value); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_TRUNC_S_F32) + { + /* We don't use INT32_MIN/INT32_MAX/UINT32_MIN/UINT32_MAX, + since float/double values of ieee754 cannot precisely + represent all int32/uint32/int64/uint64 values, e.g.: + UINT32_MAX is 4294967295, but (float32)4294967295 is + 4294967296.0f, but not 4294967295.0f. */ + DEF_OP_TRUNC_F32(-2147483904.0f, 2147483648.0f, true, true); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_TRUNC_U_F32) + { + DEF_OP_TRUNC_F32(-1.0f, 4294967296.0f, true, false); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_TRUNC_S_F64) + { + DEF_OP_TRUNC_F64(-2147483649.0, 2147483648.0, true, true); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_TRUNC_U_F64) + { + DEF_OP_TRUNC_F64(-1.0, 4294967296.0, true, false); + HANDLE_OP_END(); + } + + /* conversions of i64 */ + HANDLE_OP(WASM_OP_I64_EXTEND_S_I32) + { + DEF_OP_CONVERT(int64, I64, int32, I32); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_EXTEND_U_I32) + { + DEF_OP_CONVERT(int64, I64, uint32, I32); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_TRUNC_S_F32) + { + DEF_OP_TRUNC_F32(-9223373136366403584.0f, + 9223372036854775808.0f, false, true); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_TRUNC_U_F32) + { + DEF_OP_TRUNC_F32(-1.0f, 18446744073709551616.0f, false, false); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_TRUNC_S_F64) + { + DEF_OP_TRUNC_F64(-9223372036854777856.0, 9223372036854775808.0, + false, true); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_TRUNC_U_F64) + { + DEF_OP_TRUNC_F64(-1.0, 18446744073709551616.0, false, false); + HANDLE_OP_END(); + } + + /* conversions of f32 */ + HANDLE_OP(WASM_OP_F32_CONVERT_S_I32) + { + DEF_OP_CONVERT(float32, F32, int32, I32); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_CONVERT_U_I32) + { + DEF_OP_CONVERT(float32, F32, uint32, I32); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_CONVERT_S_I64) + { + DEF_OP_CONVERT(float32, F32, int64, I64); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_CONVERT_U_I64) + { + DEF_OP_CONVERT(float32, F32, uint64, I64); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F32_DEMOTE_F64) + { + DEF_OP_CONVERT(float32, F32, float64, F64); + HANDLE_OP_END(); + } + + /* conversions of f64 */ + HANDLE_OP(WASM_OP_F64_CONVERT_S_I32) + { + DEF_OP_CONVERT(float64, F64, int32, I32); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_CONVERT_U_I32) + { + DEF_OP_CONVERT(float64, F64, uint32, I32); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_CONVERT_S_I64) + { + DEF_OP_CONVERT(float64, F64, int64, I64); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_CONVERT_U_I64) + { + DEF_OP_CONVERT(float64, F64, uint64, I64); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_F64_PROMOTE_F32) + { + DEF_OP_CONVERT(float64, F64, float32, F32); + HANDLE_OP_END(); + } + + /* reinterpretations */ + HANDLE_OP(WASM_OP_I32_REINTERPRET_F32) + HANDLE_OP(WASM_OP_F32_REINTERPRET_I32) + { + DEF_OP_REINTERPRET(uint32, I32); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_REINTERPRET_F64) + HANDLE_OP(WASM_OP_F64_REINTERPRET_I64) + { + DEF_OP_REINTERPRET(int64, I64); + HANDLE_OP_END(); + } + + HANDLE_OP(EXT_OP_COPY_STACK_TOP) + { + addr1 = GET_OFFSET(); + addr2 = GET_OFFSET(); + frame_lp[addr2] = frame_lp[addr1]; + HANDLE_OP_END(); + } + + HANDLE_OP(EXT_OP_COPY_STACK_TOP_I64) + { + addr1 = GET_OFFSET(); + addr2 = GET_OFFSET(); + frame_lp[addr2] = frame_lp[addr1]; + frame_lp[addr2 + 1] = frame_lp[addr1 + 1]; + HANDLE_OP_END(); + } + + HANDLE_OP(EXT_OP_COPY_STACK_VALUES) + { + uint32 values_count, total_cell; + uint8 *cells; + int16 *src_offsets = NULL; + uint16 *dst_offsets = NULL; + + /* read values_count */ + values_count = read_uint32(frame_ip); + /* read total cell num */ + total_cell = read_uint32(frame_ip); + /* cells */ + cells = (uint8 *)frame_ip; + frame_ip += values_count * CELL_SIZE; + /* src offsets */ + src_offsets = (int16 *)frame_ip; + frame_ip += values_count * sizeof(int16); + /* dst offsets */ + dst_offsets = (uint16 *)frame_ip; + frame_ip += values_count * sizeof(uint16); + + if (!copy_stack_values(module, frame_lp, values_count, + total_cell, cells, src_offsets, + dst_offsets)) + goto got_exception; + + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_SET_LOCAL) + HANDLE_OP(WASM_OP_TEE_LOCAL) + { + GET_LOCAL_INDEX_TYPE_AND_OFFSET(); + addr1 = GET_OFFSET(); + + if (local_type == VALUE_TYPE_I32 + || local_type == VALUE_TYPE_F32) { + *(int32 *)(frame_lp + local_offset) = frame_lp[addr1]; + } + else if (local_type == VALUE_TYPE_I64 + || local_type == VALUE_TYPE_F64) { + PUT_I64_TO_ADDR((uint32 *)(frame_lp + local_offset), + GET_I64_FROM_ADDR(frame_lp + addr1)); + } + else { + wasm_set_exception(module, "invalid local type"); + goto got_exception; + } + + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_EXTEND8_S) + { + DEF_OP_CONVERT(int32, I32, int8, I32); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I32_EXTEND16_S) + { + DEF_OP_CONVERT(int32, I32, int16, I32); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_EXTEND8_S) + { + DEF_OP_CONVERT(int64, I64, int8, I64); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_EXTEND16_S) + { + DEF_OP_CONVERT(int64, I64, int16, I64); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_I64_EXTEND32_S) + { + DEF_OP_CONVERT(int64, I64, int32, I64); + HANDLE_OP_END(); + } + + HANDLE_OP(WASM_OP_MISC_PREFIX) + { + GET_OPCODE(); + switch (opcode) { + case WASM_OP_I32_TRUNC_SAT_S_F32: + DEF_OP_TRUNC_SAT_F32(-2147483904.0f, 2147483648.0f, + true, true); + break; + case WASM_OP_I32_TRUNC_SAT_U_F32: + DEF_OP_TRUNC_SAT_F32(-1.0f, 4294967296.0f, true, false); + break; + case WASM_OP_I32_TRUNC_SAT_S_F64: + DEF_OP_TRUNC_SAT_F64(-2147483649.0, 2147483648.0, true, + true); + break; + case WASM_OP_I32_TRUNC_SAT_U_F64: + DEF_OP_TRUNC_SAT_F64(-1.0, 4294967296.0, true, false); + break; + case WASM_OP_I64_TRUNC_SAT_S_F32: + DEF_OP_TRUNC_SAT_F32(-9223373136366403584.0f, + 9223372036854775808.0f, false, + true); + break; + case WASM_OP_I64_TRUNC_SAT_U_F32: + DEF_OP_TRUNC_SAT_F32(-1.0f, 18446744073709551616.0f, + false, false); + break; + case WASM_OP_I64_TRUNC_SAT_S_F64: + DEF_OP_TRUNC_SAT_F64(-9223372036854777856.0, + 9223372036854775808.0, false, + true); + break; + case WASM_OP_I64_TRUNC_SAT_U_F64: + DEF_OP_TRUNC_SAT_F64(-1.0, 18446744073709551616.0, + false, false); + break; #if WASM_ENABLE_BULK_MEMORY != 0 - case WASM_OP_MEMORY_INIT: - { - uint32 addr, segment; - uint64 bytes, offset, seg_len; - uint8* data; + case WASM_OP_MEMORY_INIT: + { + uint32 addr, segment; + uint64 bytes, offset, seg_len; + uint8 *data; - segment = read_uint32(frame_ip); + segment = read_uint32(frame_ip); - bytes = (uint64)POP_I32(); - offset = (uint64)POP_I32(); - addr = POP_I32(); + bytes = (uint64)POP_I32(); + offset = (uint64)POP_I32(); + addr = POP_I32(); - CHECK_BULK_MEMORY_OVERFLOW(addr, bytes, maddr); + CHECK_BULK_MEMORY_OVERFLOW(addr, bytes, maddr); - seg_len = (uint64)module->module->data_segments[segment]->data_length; - data = module->module->data_segments[segment]->data; - if (offset + bytes > seg_len) - goto out_of_bounds; + seg_len = (uint64)module->module->data_segments[segment] + ->data_length; + data = module->module->data_segments[segment]->data; + if (offset + bytes > seg_len) + goto out_of_bounds; - bh_memcpy_s(maddr, linear_mem_size - addr, - data + offset, (uint32)bytes); - break; - } - case WASM_OP_DATA_DROP: - { - uint32 segment; + bh_memcpy_s(maddr, linear_mem_size - addr, + data + offset, (uint32)bytes); + break; + } + case WASM_OP_DATA_DROP: + { + uint32 segment; - segment = read_uint32(frame_ip); + segment = read_uint32(frame_ip); - module->module->data_segments[segment]->data_length = 0; + module->module->data_segments[segment]->data_length = 0; - break; - } - case WASM_OP_MEMORY_COPY: - { - uint32 dst, src, len; - uint8 *mdst, *msrc; + break; + } + case WASM_OP_MEMORY_COPY: + { + uint32 dst, src, len; + uint8 *mdst, *msrc; - len = POP_I32(); - src = POP_I32(); - dst = POP_I32(); + len = POP_I32(); + src = POP_I32(); + dst = POP_I32(); - CHECK_BULK_MEMORY_OVERFLOW(src, len, msrc); - CHECK_BULK_MEMORY_OVERFLOW(dst, len, mdst); + CHECK_BULK_MEMORY_OVERFLOW(src, len, msrc); + CHECK_BULK_MEMORY_OVERFLOW(dst, len, mdst); - /* allowing the destination and source to overlap */ - bh_memmove_s(mdst, linear_mem_size - dst, msrc, len); + /* allowing the destination and source to overlap */ + bh_memmove_s(mdst, linear_mem_size - dst, msrc, len); - break; - } - case WASM_OP_MEMORY_FILL: - { - uint32 dst, len; - uint8 val, *mdst; + break; + } + case WASM_OP_MEMORY_FILL: + { + uint32 dst, len; + uint8 val, *mdst; - len = POP_I32(); - val = POP_I32(); - dst = POP_I32(); + len = POP_I32(); + val = POP_I32(); + dst = POP_I32(); - CHECK_BULK_MEMORY_OVERFLOW(dst, len, mdst); + CHECK_BULK_MEMORY_OVERFLOW(dst, len, mdst); - memset(mdst, val, len); + memset(mdst, val, len); - break; - } + break; + } #endif /* WASM_ENABLE_BULK_MEMORY */ #if WASM_ENABLE_REF_TYPES != 0 - case WASM_OP_TABLE_INIT: - { - uint32 tbl_idx, elem_idx; - uint64 n, s, d; - WASMTableInstance *tbl_inst; + case WASM_OP_TABLE_INIT: + { + uint32 tbl_idx, elem_idx; + uint64 n, s, d; + WASMTableInstance *tbl_inst; - elem_idx = read_uint32(frame_ip); - bh_assert(elem_idx < module->module->table_seg_count); + elem_idx = read_uint32(frame_ip); + bh_assert(elem_idx < module->module->table_seg_count); - tbl_idx = read_uint32(frame_ip); - bh_assert(tbl_idx < module->module->table_count); + tbl_idx = read_uint32(frame_ip); + bh_assert(tbl_idx < module->module->table_count); - tbl_inst = wasm_get_table_inst(module, tbl_idx); + tbl_inst = wasm_get_table_inst(module, tbl_idx); - n = (uint32)POP_I32(); - s = (uint32)POP_I32(); - d = (uint32)POP_I32(); + n = (uint32)POP_I32(); + s = (uint32)POP_I32(); + d = (uint32)POP_I32(); - if (!n) { - break; - } + if (!n) { + break; + } - if (n + s > module->module->table_segments[elem_idx].function_count - || d + n > tbl_inst->cur_size) { - wasm_set_exception(module, "out of bounds table access"); - goto got_exception; - } + if (n + s > module->module->table_segments[elem_idx] + .function_count + || d + n > tbl_inst->cur_size) { + wasm_set_exception(module, + "out of bounds table access"); + goto got_exception; + } - if (module->module->table_segments[elem_idx].is_dropped) { - wasm_set_exception(module, "out of bounds table access"); - goto got_exception; - } + if (module->module->table_segments[elem_idx] + .is_dropped) { + wasm_set_exception(module, + "out of bounds table access"); + goto got_exception; + } - if (!wasm_elem_is_passive( - module->module->table_segments[elem_idx].mode)) { - wasm_set_exception(module, "out of bounds table access"); - goto got_exception; - } + if (!wasm_elem_is_passive( + module->module->table_segments[elem_idx] + .mode)) { + wasm_set_exception(module, + "out of bounds table access"); + goto got_exception; + } - bh_memcpy_s( - (uint8 *)tbl_inst + offsetof(WASMTableInstance, base_addr) - + d * sizeof(uint32), - (uint32)((tbl_inst->cur_size - d) * sizeof(uint32)), - module->module->table_segments[elem_idx].func_indexes + s, - (uint32)(n * sizeof(uint32))); - break; - } - case WASM_OP_ELEM_DROP: - { - uint32 elem_idx = read_uint32(frame_ip); - bh_assert(elem_idx < module->module->table_seg_count); + bh_memcpy_s( + (uint8 *)tbl_inst + + offsetof(WASMTableInstance, base_addr) + + d * sizeof(uint32), + (uint32)((tbl_inst->cur_size - d) * sizeof(uint32)), + module->module->table_segments[elem_idx] + .func_indexes + + s, + (uint32)(n * sizeof(uint32))); + break; + } + case WASM_OP_ELEM_DROP: + { + uint32 elem_idx = read_uint32(frame_ip); + bh_assert(elem_idx < module->module->table_seg_count); - module->module->table_segments[elem_idx].is_dropped = true; - break; - } - case WASM_OP_TABLE_COPY: - { - uint32 src_tbl_idx, dst_tbl_idx; - uint64 n, s, d; - WASMTableInstance *src_tbl_inst, *dst_tbl_inst; + module->module->table_segments[elem_idx].is_dropped = + true; + break; + } + case WASM_OP_TABLE_COPY: + { + uint32 src_tbl_idx, dst_tbl_idx; + uint64 n, s, d; + WASMTableInstance *src_tbl_inst, *dst_tbl_inst; - dst_tbl_idx = read_uint32(frame_ip); - bh_assert(dst_tbl_idx < module->table_count); + dst_tbl_idx = read_uint32(frame_ip); + bh_assert(dst_tbl_idx < module->table_count); - dst_tbl_inst = wasm_get_table_inst(module, dst_tbl_idx); + dst_tbl_inst = wasm_get_table_inst(module, dst_tbl_idx); - src_tbl_idx = read_uint32(frame_ip); - bh_assert(src_tbl_idx < module->table_count); + src_tbl_idx = read_uint32(frame_ip); + bh_assert(src_tbl_idx < module->table_count); - src_tbl_inst = wasm_get_table_inst(module, src_tbl_idx); + src_tbl_inst = wasm_get_table_inst(module, src_tbl_idx); - n = (uint32)POP_I32(); - s = (uint32)POP_I32(); - d = (uint32)POP_I32(); + n = (uint32)POP_I32(); + s = (uint32)POP_I32(); + d = (uint32)POP_I32(); - if (s + n > dst_tbl_inst->cur_size - || d + n > src_tbl_inst->cur_size) { - wasm_set_exception(module, "out of bounds table access"); - goto got_exception; - } + if (s + n > dst_tbl_inst->cur_size + || d + n > src_tbl_inst->cur_size) { + wasm_set_exception(module, + "out of bounds table access"); + goto got_exception; + } - /* if s >= d, copy from front to back */ - /* if s < d, copy from back to front */ - /* merge all together */ - bh_memmove_s( - (uint8 *)dst_tbl_inst + offsetof(WASMTableInstance, base_addr) - + d * sizeof(uint32), - (uint32)((dst_tbl_inst->cur_size - d) * sizeof(uint32)), - (uint8 *)src_tbl_inst - + offsetof(WASMTableInstance, base_addr) + s * sizeof(uint32), - (uint32)(n * sizeof(uint32))); - break; - } - case WASM_OP_TABLE_GROW: - { - uint32 tbl_idx, n, init_val, orig_tbl_sz; - WASMTableInstance *tbl_inst; + /* if s >= d, copy from front to back */ + /* if s < d, copy from back to front */ + /* merge all together */ + bh_memmove_s( + (uint8 *)dst_tbl_inst + + offsetof(WASMTableInstance, base_addr) + + d * sizeof(uint32), + (uint32)((dst_tbl_inst->cur_size - d) + * sizeof(uint32)), + (uint8 *)src_tbl_inst + + offsetof(WASMTableInstance, base_addr) + + s * sizeof(uint32), + (uint32)(n * sizeof(uint32))); + break; + } + case WASM_OP_TABLE_GROW: + { + uint32 tbl_idx, n, init_val, orig_tbl_sz; + WASMTableInstance *tbl_inst; - tbl_idx = read_uint32(frame_ip); - bh_assert(tbl_idx < module->table_count); + tbl_idx = read_uint32(frame_ip); + bh_assert(tbl_idx < module->table_count); - tbl_inst = wasm_get_table_inst(module, tbl_idx); + tbl_inst = wasm_get_table_inst(module, tbl_idx); - orig_tbl_sz = tbl_inst->cur_size; + orig_tbl_sz = tbl_inst->cur_size; - n = POP_I32(); - init_val = POP_I32(); + n = POP_I32(); + init_val = POP_I32(); - if (!wasm_enlarge_table(module, tbl_idx, n, init_val)) { - PUSH_I32(-1); - } else { - PUSH_I32(orig_tbl_sz); - } + if (!wasm_enlarge_table(module, tbl_idx, n, init_val)) { + PUSH_I32(-1); + } + else { + PUSH_I32(orig_tbl_sz); + } - break; - } - case WASM_OP_TABLE_SIZE: - { - uint32 tbl_idx; - WASMTableInstance *tbl_inst; + break; + } + case WASM_OP_TABLE_SIZE: + { + uint32 tbl_idx; + WASMTableInstance *tbl_inst; - tbl_idx = read_uint32(frame_ip); - bh_assert(tbl_idx < module->table_count); + tbl_idx = read_uint32(frame_ip); + bh_assert(tbl_idx < module->table_count); - tbl_inst = wasm_get_table_inst(module, tbl_idx); + tbl_inst = wasm_get_table_inst(module, tbl_idx); - PUSH_I32(tbl_inst->cur_size); - break; - } - case WASM_OP_TABLE_FILL: - { - uint32 tbl_idx, n, val, i; - WASMTableInstance *tbl_inst; + PUSH_I32(tbl_inst->cur_size); + break; + } + case WASM_OP_TABLE_FILL: + { + uint32 tbl_idx, n, val, i; + WASMTableInstance *tbl_inst; - tbl_idx = read_uint32(frame_ip); - bh_assert(tbl_idx < module->table_count); + tbl_idx = read_uint32(frame_ip); + bh_assert(tbl_idx < module->table_count); - tbl_inst = wasm_get_table_inst(module, tbl_idx); + tbl_inst = wasm_get_table_inst(module, tbl_idx); - n = POP_I32(); - val = POP_I32(); - i = POP_I32(); + n = POP_I32(); + val = POP_I32(); + i = POP_I32(); - if (i + n > tbl_inst->cur_size) { - wasm_set_exception(module, "out of bounds table access"); - goto got_exception; - } + if (i + n > tbl_inst->cur_size) { + wasm_set_exception(module, + "out of bounds table access"); + goto got_exception; + } - for (; n != 0; i++, n--) { - ((uint32 *)(tbl_inst->base_addr))[i] = val; - } + for (; n != 0; i++, n--) { + ((uint32 *)(tbl_inst->base_addr))[i] = val; + } - break; - } + break; + } #endif /* WASM_ENABLE_REF_TYPES */ - default: - wasm_set_exception(module, "unsupported opcode"); - goto got_exception; - } - HANDLE_OP_END (); - } + default: + wasm_set_exception(module, "unsupported opcode"); + goto got_exception; + } + HANDLE_OP_END(); + } #if WASM_ENABLE_SHARED_MEMORY != 0 - HANDLE_OP (WASM_OP_ATOMIC_PREFIX): - { - uint32 offset, addr; + HANDLE_OP(WASM_OP_ATOMIC_PREFIX) + { + uint32 offset, addr; - GET_OPCODE(); + GET_OPCODE(); - offset = read_uint32(frame_ip); + offset = read_uint32(frame_ip); - switch (opcode) { - case WASM_OP_ATOMIC_NOTIFY: - { - uint32 count, ret; + switch (opcode) { + case WASM_OP_ATOMIC_NOTIFY: + { + uint32 count, ret; - count = POP_I32(); - addr = POP_I32(); - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(4); + count = POP_I32(); + addr = POP_I32(); + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(4); - ret = wasm_runtime_atomic_notify((WASMModuleInstanceCommon*)module, - maddr, count); - bh_assert((int32)ret >= 0); + ret = wasm_runtime_atomic_notify( + (WASMModuleInstanceCommon *)module, maddr, count); + bh_assert((int32)ret >= 0); - PUSH_I32(ret); - break; - } - case WASM_OP_ATOMIC_WAIT32: - { - uint64 timeout; - uint32 expect, addr, ret; + PUSH_I32(ret); + break; + } + case WASM_OP_ATOMIC_WAIT32: + { + uint64 timeout; + uint32 expect, addr, ret; - timeout = POP_I64(); - expect = POP_I32(); - addr = POP_I32(); - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(4); + timeout = POP_I64(); + expect = POP_I32(); + addr = POP_I32(); + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(4); - ret = wasm_runtime_atomic_wait((WASMModuleInstanceCommon*)module, maddr, - (uint64)expect, timeout, false); - if (ret == (uint32)-1) - goto got_exception; + ret = wasm_runtime_atomic_wait( + (WASMModuleInstanceCommon *)module, maddr, + (uint64)expect, timeout, false); + if (ret == (uint32)-1) + goto got_exception; - PUSH_I32(ret); - break; - } - case WASM_OP_ATOMIC_WAIT64: - { - uint64 timeout, expect; - uint32 ret; + PUSH_I32(ret); + break; + } + case WASM_OP_ATOMIC_WAIT64: + { + uint64 timeout, expect; + uint32 ret; - timeout = POP_I64(); - expect = POP_I64(); - addr = POP_I32(); - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 8, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(8); + timeout = POP_I64(); + expect = POP_I64(); + addr = POP_I32(); + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 8, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(8); - ret = wasm_runtime_atomic_wait((WASMModuleInstanceCommon*)module, - maddr, expect, timeout, true); - if (ret == (uint32)-1) - goto got_exception; + ret = wasm_runtime_atomic_wait( + (WASMModuleInstanceCommon *)module, maddr, expect, + timeout, true); + if (ret == (uint32)-1) + goto got_exception; - PUSH_I32(ret); - break; - } + PUSH_I32(ret); + break; + } - case WASM_OP_ATOMIC_I32_LOAD: - case WASM_OP_ATOMIC_I32_LOAD8_U: - case WASM_OP_ATOMIC_I32_LOAD16_U: - { - uint32 readv; + case WASM_OP_ATOMIC_I32_LOAD: + case WASM_OP_ATOMIC_I32_LOAD8_U: + case WASM_OP_ATOMIC_I32_LOAD16_U: + { + uint32 readv; - addr = POP_I32(); + addr = POP_I32(); - if (opcode == WASM_OP_ATOMIC_I32_LOAD8_U) { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(1); - os_mutex_lock(&memory->mem_lock); - readv = (uint32)(*(uint8*)maddr); - os_mutex_unlock(&memory->mem_lock); + if (opcode == WASM_OP_ATOMIC_I32_LOAD8_U) { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(1); + os_mutex_lock(&memory->mem_lock); + readv = (uint32)(*(uint8 *)maddr); + os_mutex_unlock(&memory->mem_lock); + } + else if (opcode == WASM_OP_ATOMIC_I32_LOAD16_U) { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(2); + os_mutex_lock(&memory->mem_lock); + readv = (uint32)LOAD_U16(maddr); + os_mutex_unlock(&memory->mem_lock); + } + else { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(4); + os_mutex_lock(&memory->mem_lock); + readv = LOAD_I32(maddr); + os_mutex_unlock(&memory->mem_lock); + } + + PUSH_I32(readv); + break; + } + + case WASM_OP_ATOMIC_I64_LOAD: + case WASM_OP_ATOMIC_I64_LOAD8_U: + case WASM_OP_ATOMIC_I64_LOAD16_U: + case WASM_OP_ATOMIC_I64_LOAD32_U: + { + uint64 readv; + + addr = POP_I32(); + + if (opcode == WASM_OP_ATOMIC_I64_LOAD8_U) { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(1); + os_mutex_lock(&memory->mem_lock); + readv = (uint64)(*(uint8 *)maddr); + os_mutex_unlock(&memory->mem_lock); + } + else if (opcode == WASM_OP_ATOMIC_I64_LOAD16_U) { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(2); + os_mutex_lock(&memory->mem_lock); + readv = (uint64)LOAD_U16(maddr); + os_mutex_unlock(&memory->mem_lock); + } + else if (opcode == WASM_OP_ATOMIC_I64_LOAD32_U) { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(4); + os_mutex_lock(&memory->mem_lock); + readv = (uint64)LOAD_U32(maddr); + os_mutex_unlock(&memory->mem_lock); + } + else { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 8, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(8); + os_mutex_lock(&memory->mem_lock); + readv = LOAD_I64(maddr); + os_mutex_unlock(&memory->mem_lock); + } + + PUSH_I64(readv); + break; + } + case WASM_OP_ATOMIC_I32_STORE: + case WASM_OP_ATOMIC_I32_STORE8: + case WASM_OP_ATOMIC_I32_STORE16: + { + uint32 sval; + + sval = (uint32)POP_I32(); + addr = POP_I32(); + + if (opcode == WASM_OP_ATOMIC_I32_STORE8) { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(1); + os_mutex_lock(&memory->mem_lock); + *(uint8 *)maddr = (uint8)sval; + os_mutex_unlock(&memory->mem_lock); + } + else if (opcode == WASM_OP_ATOMIC_I32_STORE16) { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(2); + os_mutex_lock(&memory->mem_lock); + STORE_U16(maddr, (uint16)sval); + os_mutex_unlock(&memory->mem_lock); + } + else { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(4); + os_mutex_lock(&memory->mem_lock); + STORE_U32(maddr, sval); + os_mutex_unlock(&memory->mem_lock); + } + break; + } + + case WASM_OP_ATOMIC_I64_STORE: + case WASM_OP_ATOMIC_I64_STORE8: + case WASM_OP_ATOMIC_I64_STORE16: + case WASM_OP_ATOMIC_I64_STORE32: + { + uint64 sval; + + sval = (uint64)POP_I64(); + addr = POP_I32(); + + if (opcode == WASM_OP_ATOMIC_I64_STORE8) { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(1); + os_mutex_lock(&memory->mem_lock); + *(uint8 *)maddr = (uint8)sval; + os_mutex_unlock(&memory->mem_lock); + } + else if (opcode == WASM_OP_ATOMIC_I64_STORE16) { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(2); + os_mutex_lock(&memory->mem_lock); + STORE_U16(maddr, (uint16)sval); + os_mutex_unlock(&memory->mem_lock); + } + else if (opcode == WASM_OP_ATOMIC_I64_STORE32) { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(4); + os_mutex_lock(&memory->mem_lock); + STORE_U32(maddr, (uint32)sval); + os_mutex_unlock(&memory->mem_lock); + } + else { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 8, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(8); + os_mutex_lock(&memory->mem_lock); + STORE_I64(maddr, sval); + os_mutex_unlock(&memory->mem_lock); + } + break; + } + + case WASM_OP_ATOMIC_RMW_I32_CMPXCHG: + case WASM_OP_ATOMIC_RMW_I32_CMPXCHG8_U: + case WASM_OP_ATOMIC_RMW_I32_CMPXCHG16_U: + { + uint32 readv, sval, expect; + + sval = POP_I32(); + expect = POP_I32(); + addr = POP_I32(); + + if (opcode == WASM_OP_ATOMIC_RMW_I32_CMPXCHG8_U) { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(1); + + os_mutex_lock(&memory->mem_lock); + readv = (uint32)(*(uint8 *)maddr); + if (readv == expect) + *(uint8 *)maddr = (uint8)(sval); + os_mutex_unlock(&memory->mem_lock); + } + else if (opcode == WASM_OP_ATOMIC_RMW_I32_CMPXCHG16_U) { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(2); + + os_mutex_lock(&memory->mem_lock); + readv = (uint32)LOAD_U16(maddr); + if (readv == expect) + STORE_U16(maddr, (uint16)(sval)); + os_mutex_unlock(&memory->mem_lock); + } + else { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(4); + + os_mutex_lock(&memory->mem_lock); + readv = LOAD_I32(maddr); + if (readv == expect) + STORE_U32(maddr, sval); + os_mutex_unlock(&memory->mem_lock); + } + PUSH_I32(readv); + break; + } + case WASM_OP_ATOMIC_RMW_I64_CMPXCHG: + case WASM_OP_ATOMIC_RMW_I64_CMPXCHG8_U: + case WASM_OP_ATOMIC_RMW_I64_CMPXCHG16_U: + case WASM_OP_ATOMIC_RMW_I64_CMPXCHG32_U: + { + uint64 readv, sval, expect; + + sval = (uint64)POP_I64(); + expect = (uint64)POP_I64(); + addr = POP_I32(); + + if (opcode == WASM_OP_ATOMIC_RMW_I64_CMPXCHG8_U) { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(1); + + os_mutex_lock(&memory->mem_lock); + readv = (uint64)(*(uint8 *)maddr); + if (readv == expect) + *(uint8 *)maddr = (uint8)(sval); + os_mutex_unlock(&memory->mem_lock); + } + else if (opcode == WASM_OP_ATOMIC_RMW_I64_CMPXCHG16_U) { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(2); + + os_mutex_lock(&memory->mem_lock); + readv = (uint64)LOAD_U16(maddr); + if (readv == expect) + STORE_U16(maddr, (uint16)(sval)); + os_mutex_unlock(&memory->mem_lock); + } + else if (opcode == WASM_OP_ATOMIC_RMW_I64_CMPXCHG32_U) { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(4); + + os_mutex_lock(&memory->mem_lock); + readv = (uint64)LOAD_U32(maddr); + if (readv == expect) + STORE_U32(maddr, (uint32)(sval)); + os_mutex_unlock(&memory->mem_lock); + } + else { + CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 8, maddr); + CHECK_ATOMIC_MEMORY_ACCESS(8); + + os_mutex_lock(&memory->mem_lock); + readv = (uint64)LOAD_I64(maddr); + if (readv == expect) { + STORE_I64(maddr, sval); + } + os_mutex_unlock(&memory->mem_lock); + } + PUSH_I64(readv); + break; + } + + DEF_ATOMIC_RMW_OPCODE(ADD, +); + DEF_ATOMIC_RMW_OPCODE(SUB, -); + DEF_ATOMIC_RMW_OPCODE(AND, &); + DEF_ATOMIC_RMW_OPCODE(OR, |); + DEF_ATOMIC_RMW_OPCODE(XOR, ^); + /* xchg, ignore the read value, and store the given + value: readv * 0 + sval */ + DEF_ATOMIC_RMW_OPCODE(XCHG, *0 +); + } + + HANDLE_OP_END(); } - else if (opcode == WASM_OP_ATOMIC_I32_LOAD16_U) { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(2); - os_mutex_lock(&memory->mem_lock); - readv = (uint32)LOAD_U16(maddr); - os_mutex_unlock(&memory->mem_lock); - } - else { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(4); - os_mutex_lock(&memory->mem_lock); - readv = LOAD_I32(maddr); - os_mutex_unlock(&memory->mem_lock); - } - - PUSH_I32(readv); - break; - } - - case WASM_OP_ATOMIC_I64_LOAD: - case WASM_OP_ATOMIC_I64_LOAD8_U: - case WASM_OP_ATOMIC_I64_LOAD16_U: - case WASM_OP_ATOMIC_I64_LOAD32_U: - { - uint64 readv; - - addr = POP_I32(); - - if (opcode == WASM_OP_ATOMIC_I64_LOAD8_U) { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(1); - os_mutex_lock(&memory->mem_lock); - readv = (uint64)(*(uint8*)maddr); - os_mutex_unlock(&memory->mem_lock); - } - else if (opcode == WASM_OP_ATOMIC_I64_LOAD16_U) { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(2); - os_mutex_lock(&memory->mem_lock); - readv = (uint64)LOAD_U16(maddr); - os_mutex_unlock(&memory->mem_lock); - } - else if (opcode == WASM_OP_ATOMIC_I64_LOAD32_U) { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(4); - os_mutex_lock(&memory->mem_lock); - readv = (uint64)LOAD_U32(maddr); - os_mutex_unlock(&memory->mem_lock); - } - else { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 8, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(8); - os_mutex_lock(&memory->mem_lock); - readv = LOAD_I64(maddr); - os_mutex_unlock(&memory->mem_lock); - } - - PUSH_I64(readv); - break; - } - case WASM_OP_ATOMIC_I32_STORE: - case WASM_OP_ATOMIC_I32_STORE8: - case WASM_OP_ATOMIC_I32_STORE16: - { - uint32 sval; - - sval = (uint32)POP_I32(); - addr = POP_I32(); - - if (opcode == WASM_OP_ATOMIC_I32_STORE8) { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(1); - os_mutex_lock(&memory->mem_lock); - *(uint8*)maddr = (uint8)sval; - os_mutex_unlock(&memory->mem_lock); - } - else if (opcode == WASM_OP_ATOMIC_I32_STORE16) { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(2); - os_mutex_lock(&memory->mem_lock); - STORE_U16(maddr, (uint16)sval); - os_mutex_unlock(&memory->mem_lock); - } - else { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(4); - os_mutex_lock(&memory->mem_lock); - STORE_U32(maddr, sval); - os_mutex_unlock(&memory->mem_lock); - } - break; - } - - case WASM_OP_ATOMIC_I64_STORE: - case WASM_OP_ATOMIC_I64_STORE8: - case WASM_OP_ATOMIC_I64_STORE16: - case WASM_OP_ATOMIC_I64_STORE32: - { - uint64 sval; - - sval = (uint64)POP_I64(); - addr = POP_I32(); - - if (opcode == WASM_OP_ATOMIC_I64_STORE8) { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(1); - os_mutex_lock(&memory->mem_lock); - *(uint8*)maddr = (uint8)sval; - os_mutex_unlock(&memory->mem_lock); - } - else if(opcode == WASM_OP_ATOMIC_I64_STORE16) { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(2); - os_mutex_lock(&memory->mem_lock); - STORE_U16(maddr, (uint16)sval); - os_mutex_unlock(&memory->mem_lock); - } - else if (opcode == WASM_OP_ATOMIC_I64_STORE32) { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(4); - os_mutex_lock(&memory->mem_lock); - STORE_U32(maddr, (uint32)sval); - os_mutex_unlock(&memory->mem_lock); - } - else { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 8, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(8); - os_mutex_lock(&memory->mem_lock); - STORE_I64(maddr, sval); - os_mutex_unlock(&memory->mem_lock); - } - break; - } - - case WASM_OP_ATOMIC_RMW_I32_CMPXCHG: - case WASM_OP_ATOMIC_RMW_I32_CMPXCHG8_U: - case WASM_OP_ATOMIC_RMW_I32_CMPXCHG16_U: - { - uint32 readv, sval, expect; - - sval = POP_I32(); - expect = POP_I32(); - addr = POP_I32(); - - if (opcode == WASM_OP_ATOMIC_RMW_I32_CMPXCHG8_U) { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(1); - - os_mutex_lock(&memory->mem_lock); - readv = (uint32)(*(uint8*)maddr); - if (readv == expect) - *(uint8*)maddr = (uint8)(sval); - os_mutex_unlock(&memory->mem_lock); - } - else if (opcode == WASM_OP_ATOMIC_RMW_I32_CMPXCHG16_U) { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(2); - - os_mutex_lock(&memory->mem_lock); - readv = (uint32)LOAD_U16(maddr); - if (readv == expect) - STORE_U16(maddr, (uint16)(sval)); - os_mutex_unlock(&memory->mem_lock); - } - else { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(4); - - os_mutex_lock(&memory->mem_lock); - readv = LOAD_I32(maddr); - if (readv == expect) - STORE_U32(maddr, sval); - os_mutex_unlock(&memory->mem_lock); - } - PUSH_I32(readv); - break; - } - case WASM_OP_ATOMIC_RMW_I64_CMPXCHG: - case WASM_OP_ATOMIC_RMW_I64_CMPXCHG8_U: - case WASM_OP_ATOMIC_RMW_I64_CMPXCHG16_U: - case WASM_OP_ATOMIC_RMW_I64_CMPXCHG32_U: - { - uint64 readv, sval, expect; - - sval = (uint64)POP_I64(); - expect = (uint64)POP_I64(); - addr = POP_I32(); - - if (opcode == WASM_OP_ATOMIC_RMW_I64_CMPXCHG8_U) { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 1, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(1); - - os_mutex_lock(&memory->mem_lock); - readv = (uint64)(*(uint8*)maddr); - if (readv == expect) - *(uint8*)maddr = (uint8)(sval); - os_mutex_unlock(&memory->mem_lock); - } - else if (opcode == WASM_OP_ATOMIC_RMW_I64_CMPXCHG16_U) { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 2, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(2); - - os_mutex_lock(&memory->mem_lock); - readv = (uint64)LOAD_U16(maddr); - if (readv == expect) - STORE_U16(maddr, (uint16)(sval)); - os_mutex_unlock(&memory->mem_lock); - } - else if (opcode == WASM_OP_ATOMIC_RMW_I64_CMPXCHG32_U) { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 4, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(4); - - os_mutex_lock(&memory->mem_lock); - readv = (uint64)LOAD_U32(maddr); - if (readv == expect) - STORE_U32(maddr, (uint32)(sval)); - os_mutex_unlock(&memory->mem_lock); - } - else { - CHECK_BULK_MEMORY_OVERFLOW(addr + offset, 8, maddr); - CHECK_ATOMIC_MEMORY_ACCESS(8); - - os_mutex_lock(&memory->mem_lock); - readv = (uint64)LOAD_I64(maddr); - if (readv == expect) { - STORE_I64(maddr, sval); - } - os_mutex_unlock(&memory->mem_lock); - } - PUSH_I64(readv); - break; - } - - DEF_ATOMIC_RMW_OPCODE(ADD, +); - DEF_ATOMIC_RMW_OPCODE(SUB, -); - DEF_ATOMIC_RMW_OPCODE(AND, &); - DEF_ATOMIC_RMW_OPCODE(OR, |); - DEF_ATOMIC_RMW_OPCODE(XOR, ^); - /* xchg, ignore the read value, and store the given value: - readv * 0 + sval */ - DEF_ATOMIC_RMW_OPCODE(XCHG, *0 +); - } - - HANDLE_OP_END (); - } #endif - HANDLE_OP (WASM_OP_IMPDEP): - frame = prev_frame; - frame_ip = frame->ip; - goto call_func_from_entry; + HANDLE_OP(WASM_OP_IMPDEP) + { + frame = prev_frame; + frame_ip = frame->ip; + goto call_func_from_entry; + } - HANDLE_OP (WASM_OP_CALL): + HANDLE_OP(WASM_OP_CALL) + { #if WASM_ENABLE_THREAD_MGR != 0 - CHECK_SUSPEND_FLAGS(); + CHECK_SUSPEND_FLAGS(); #endif - fidx = read_uint32(frame_ip); + fidx = read_uint32(frame_ip); #if WASM_ENABLE_MULTI_MODULE != 0 - if (fidx >= module->function_count) { - wasm_set_exception(module, "unknown function"); - goto got_exception; - } + if (fidx >= module->function_count) { + wasm_set_exception(module, "unknown function"); + goto got_exception; + } #endif - cur_func = module->functions + fidx; - goto call_func_from_interp; + cur_func = module->functions + fidx; + goto call_func_from_interp; + } #if WASM_ENABLE_TAIL_CALL != 0 - HANDLE_OP (WASM_OP_RETURN_CALL): + HANDLE_OP(WASM_OP_RETURN_CALL) + { #if WASM_ENABLE_THREAD_MGR != 0 - CHECK_SUSPEND_FLAGS(); + CHECK_SUSPEND_FLAGS(); #endif - fidx = read_uint32(frame_ip); + fidx = read_uint32(frame_ip); #if WASM_ENABLE_MULTI_MODULE != 0 - if (fidx >= module->function_count) { - wasm_set_exception(module, "unknown function"); - goto got_exception; - } + if (fidx >= module->function_count) { + wasm_set_exception(module, "unknown function"); + goto got_exception; + } #endif - cur_func = module->functions + fidx; - goto call_func_from_return_call; + cur_func = module->functions + fidx; + goto call_func_from_return_call; + } #endif /* WASM_ENABLE_TAIL_CALL */ #if WASM_ENABLE_LABELS_AS_VALUES == 0 - default: - wasm_set_exception(module, "unsupported opcode"); - goto got_exception; - } + default: + wasm_set_exception(module, "unsupported opcode"); + goto got_exception; + } #endif #if WASM_ENABLE_LABELS_AS_VALUES != 0 - HANDLE_OP (WASM_OP_UNUSED_0x06): - HANDLE_OP (WASM_OP_UNUSED_0x07): - HANDLE_OP (WASM_OP_UNUSED_0x08): - HANDLE_OP (WASM_OP_UNUSED_0x09): - HANDLE_OP (WASM_OP_UNUSED_0x0a): + HANDLE_OP(WASM_OP_UNUSED_0x06) + HANDLE_OP(WASM_OP_UNUSED_0x07) + HANDLE_OP(WASM_OP_UNUSED_0x08) + HANDLE_OP(WASM_OP_UNUSED_0x09) + HANDLE_OP(WASM_OP_UNUSED_0x0a) #if WASM_ENABLE_TAIL_CALL == 0 - HANDLE_OP (WASM_OP_RETURN_CALL): - HANDLE_OP (WASM_OP_RETURN_CALL_INDIRECT): + HANDLE_OP(WASM_OP_RETURN_CALL) + HANDLE_OP(WASM_OP_RETURN_CALL_INDIRECT) #endif #if WASM_ENABLE_SHARED_MEMORY == 0 - HANDLE_OP (WASM_OP_ATOMIC_PREFIX): + HANDLE_OP(WASM_OP_ATOMIC_PREFIX) #endif #if WASM_ENABLE_REF_TYPES == 0 - HANDLE_OP (WASM_OP_TABLE_GET): - HANDLE_OP (WASM_OP_TABLE_SET): - HANDLE_OP (WASM_OP_REF_NULL): - HANDLE_OP (WASM_OP_REF_IS_NULL): - HANDLE_OP (WASM_OP_REF_FUNC): + HANDLE_OP(WASM_OP_TABLE_GET) + HANDLE_OP(WASM_OP_TABLE_SET) + HANDLE_OP(WASM_OP_REF_NULL) + HANDLE_OP(WASM_OP_REF_IS_NULL) + HANDLE_OP(WASM_OP_REF_FUNC) #endif - /* SELECT_T is converted to SELECT or SELECT_64 */ - HANDLE_OP (WASM_OP_SELECT_T): - HANDLE_OP (WASM_OP_UNUSED_0x14): - HANDLE_OP (WASM_OP_UNUSED_0x15): - HANDLE_OP (WASM_OP_UNUSED_0x16): - HANDLE_OP (WASM_OP_UNUSED_0x17): - HANDLE_OP (WASM_OP_UNUSED_0x18): - HANDLE_OP (WASM_OP_UNUSED_0x19): - HANDLE_OP (WASM_OP_UNUSED_0x27): - /* optimized op code */ - HANDLE_OP (WASM_OP_F32_STORE): - HANDLE_OP (WASM_OP_F64_STORE): - HANDLE_OP (WASM_OP_F32_LOAD): - HANDLE_OP (WASM_OP_F64_LOAD): - HANDLE_OP (EXT_OP_GET_LOCAL_FAST): - HANDLE_OP (WASM_OP_GET_LOCAL): - HANDLE_OP (WASM_OP_F64_CONST): - HANDLE_OP (WASM_OP_I64_CONST): - HANDLE_OP (WASM_OP_F32_CONST): - HANDLE_OP (WASM_OP_I32_CONST): - HANDLE_OP (WASM_OP_DROP): - HANDLE_OP (WASM_OP_DROP_64): - HANDLE_OP (WASM_OP_BLOCK): - HANDLE_OP (WASM_OP_LOOP): - HANDLE_OP (WASM_OP_END): - HANDLE_OP (WASM_OP_NOP): - HANDLE_OP (EXT_OP_BLOCK): - HANDLE_OP (EXT_OP_LOOP): - HANDLE_OP (EXT_OP_IF): - { - wasm_set_exception(module, "unsupported opcode"); - goto got_exception; - } -#endif - -#if WASM_ENABLE_LABELS_AS_VALUES == 0 - continue; -#else - FETCH_OPCODE_AND_DISPATCH (); -#endif - -#if WASM_ENABLE_TAIL_CALL !=0 - call_func_from_return_call: - { - uint32 *lp_base; - uint32 *lp; - int i; - - if (!(lp_base = lp = - wasm_runtime_malloc(cur_func->param_cell_num * sizeof(uint32)))) { - wasm_set_exception(module, "allocate memory failed"); - goto got_exception; - } - for (i = 0; i < cur_func->param_count; i++) { - if (cur_func->param_types[i] == VALUE_TYPE_I64 - || cur_func->param_types[i] == VALUE_TYPE_F64) { - PUT_I64_TO_ADDR(lp, GET_OPERAND(uint64, I64, - 2 * (cur_func->param_count - i - 1))); - lp += 2; - } - else { - *lp = GET_OPERAND(uint32, I32, (2 * (cur_func->param_count - i - 1))); - lp ++; - } - } - frame->lp = frame->operand + cur_func->const_cell_num; - word_copy(frame->lp, lp_base, lp - lp_base); - wasm_runtime_free(lp_base); - FREE_FRAME(exec_env, frame); - frame_ip += cur_func->param_count * sizeof(int16); - wasm_exec_env_set_cur_frame(exec_env, - (WASMRuntimeFrame *)prev_frame); - goto call_func_from_entry; - } -#endif /* WASM_ENABLE_TAIL_CALL */ - call_func_from_interp: - /* Only do the copy when it's called from interpreter. */ - { - WASMInterpFrame *outs_area = wasm_exec_env_wasm_stack_top(exec_env); - int i; - -#if WASM_ENABLE_MULTI_MODULE != 0 - if (cur_func->is_import_func) { - outs_area->lp = outs_area->operand - + (cur_func->import_func_inst - ? cur_func->import_func_inst->const_cell_num - : 0); - } - else -#endif - { - outs_area->lp = outs_area->operand + cur_func->const_cell_num; - } - for (i = 0; i < cur_func->param_count; i++) { - if (cur_func->param_types[i] == VALUE_TYPE_I64 - || cur_func->param_types[i] == VALUE_TYPE_F64) { - PUT_I64_TO_ADDR(outs_area->lp, - GET_OPERAND(uint64, I64, - 2 * (cur_func->param_count - i - 1))); - outs_area->lp += 2; - } - else { - *outs_area->lp = GET_OPERAND(uint32, I32, - (2 * (cur_func->param_count - i - 1))); - outs_area->lp ++; - } - } - frame_ip += cur_func->param_count * sizeof(int16); - if (cur_func->ret_cell_num != 0) { - /* Get the first return value's offset. Since loader emit all return - * values' offset so we must skip remain return values' offsets. - */ - WASMType *func_type; - if (cur_func->is_import_func) - func_type = cur_func->u.func_import->func_type; - else - func_type = cur_func->u.func->func_type; - frame->ret_offset = GET_OFFSET(); - frame_ip += 2 * (func_type->result_count - 1); - } - SYNC_ALL_TO_FRAME(); - prev_frame = frame; - } - - call_func_from_entry: - { - if (cur_func->is_import_func) { -#if WASM_ENABLE_MULTI_MODULE != 0 - if (cur_func->import_func_inst) { - wasm_interp_call_func_import(module, exec_env, cur_func, - prev_frame); - } - else -#endif - { - wasm_interp_call_func_native(module, exec_env, cur_func, - prev_frame); - } - - prev_frame = frame->prev_frame; - cur_func = frame->function; - UPDATE_ALL_FROM_FRAME(); - - /* update memory instance ptr and memory size */ - memory = module->default_memory; - if (memory) - linear_mem_size = num_bytes_per_page * memory->cur_page_count; - if (wasm_get_exception(module)) - goto got_exception; - } - else { - WASMFunction *cur_wasm_func = cur_func->u.func; - - all_cell_num = (uint64)cur_func->param_cell_num - + (uint64)cur_func->local_cell_num - + (uint64)cur_func->const_cell_num - + (uint64)cur_wasm_func->max_stack_cell_num; - if (all_cell_num >= UINT32_MAX) { - wasm_set_exception(module, "wasm operand stack overflow"); + /* SELECT_T is converted to SELECT or SELECT_64 */ + HANDLE_OP(WASM_OP_SELECT_T) + HANDLE_OP(WASM_OP_UNUSED_0x14) + HANDLE_OP(WASM_OP_UNUSED_0x15) + HANDLE_OP(WASM_OP_UNUSED_0x16) + HANDLE_OP(WASM_OP_UNUSED_0x17) + HANDLE_OP(WASM_OP_UNUSED_0x18) + HANDLE_OP(WASM_OP_UNUSED_0x19) + HANDLE_OP(WASM_OP_UNUSED_0x27) + /* optimized op code */ + HANDLE_OP(WASM_OP_F32_STORE) + HANDLE_OP(WASM_OP_F64_STORE) + HANDLE_OP(WASM_OP_F32_LOAD) + HANDLE_OP(WASM_OP_F64_LOAD) + HANDLE_OP(EXT_OP_GET_LOCAL_FAST) + HANDLE_OP(WASM_OP_GET_LOCAL) + HANDLE_OP(WASM_OP_F64_CONST) + HANDLE_OP(WASM_OP_I64_CONST) + HANDLE_OP(WASM_OP_F32_CONST) + HANDLE_OP(WASM_OP_I32_CONST) + HANDLE_OP(WASM_OP_DROP) + HANDLE_OP(WASM_OP_DROP_64) + HANDLE_OP(WASM_OP_BLOCK) + HANDLE_OP(WASM_OP_LOOP) + HANDLE_OP(WASM_OP_END) + HANDLE_OP(WASM_OP_NOP) + HANDLE_OP(EXT_OP_BLOCK) + HANDLE_OP(EXT_OP_LOOP) + HANDLE_OP(EXT_OP_IF) + { + wasm_set_exception(module, "unsupported opcode"); goto got_exception; } - - frame_size = wasm_interp_interp_frame_size((uint32)all_cell_num); - if (!(frame = ALLOC_FRAME(exec_env, frame_size, prev_frame))) { - frame = prev_frame; - goto got_exception; - } - - /* Initialize the interpreter context. */ - frame->function = cur_func; - frame_ip = wasm_get_func_code(cur_func); - frame_ip_end = wasm_get_func_code_end(cur_func); - - frame_lp = frame->lp = frame->operand + cur_wasm_func->const_cell_num; - - /* Initialize the consts */ - word_copy(frame->operand, (uint32*)cur_wasm_func->consts, - cur_wasm_func->const_cell_num); - - /* Initialize the local varialbes */ - memset(frame_lp + cur_func->param_cell_num, 0, - (uint32)(cur_func->local_cell_num * 4)); - - wasm_exec_env_set_cur_frame(exec_env, (WASMRuntimeFrame*)frame); - } - HANDLE_OP_END (); - } - - return_func: - { - FREE_FRAME(exec_env, frame); - wasm_exec_env_set_cur_frame(exec_env, (WASMRuntimeFrame*)prev_frame); - - if (!prev_frame->ip) - /* Called from native. */ - return; - - RECOVER_CONTEXT(prev_frame); - HANDLE_OP_END (); - } - - (void)frame_ip_end; - -#if WASM_ENABLE_SHARED_MEMORY != 0 - unaligned_atomic: - wasm_set_exception(module, "unaligned atomic"); - goto got_exception; #endif - out_of_bounds: - wasm_set_exception(module, "out of bounds memory access"); +#if WASM_ENABLE_LABELS_AS_VALUES == 0 + continue; +#else + FETCH_OPCODE_AND_DISPATCH(); +#endif - got_exception: - SYNC_ALL_TO_FRAME(); - return; +#if WASM_ENABLE_TAIL_CALL != 0 + call_func_from_return_call: + { + uint32 *lp_base; + uint32 *lp; + int i; + + if (!(lp_base = lp = wasm_runtime_malloc(cur_func->param_cell_num + * sizeof(uint32)))) { + wasm_set_exception(module, "allocate memory failed"); + goto got_exception; + } + for (i = 0; i < cur_func->param_count; i++) { + if (cur_func->param_types[i] == VALUE_TYPE_I64 + || cur_func->param_types[i] == VALUE_TYPE_F64) { + PUT_I64_TO_ADDR( + lp, GET_OPERAND(uint64, I64, + 2 * (cur_func->param_count - i - 1))); + lp += 2; + } + else { + *lp = GET_OPERAND(uint32, I32, + (2 * (cur_func->param_count - i - 1))); + lp++; + } + } + frame->lp = frame->operand + cur_func->const_cell_num; + word_copy(frame->lp, lp_base, lp - lp_base); + wasm_runtime_free(lp_base); + FREE_FRAME(exec_env, frame); + frame_ip += cur_func->param_count * sizeof(int16); + wasm_exec_env_set_cur_frame(exec_env, (WASMRuntimeFrame *)prev_frame); + goto call_func_from_entry; + } +#endif /* WASM_ENABLE_TAIL_CALL */ + + call_func_from_interp: + { + /* Only do the copy when it's called from interpreter. */ + WASMInterpFrame *outs_area = wasm_exec_env_wasm_stack_top(exec_env); + int i; + +#if WASM_ENABLE_MULTI_MODULE != 0 + if (cur_func->is_import_func) { + outs_area->lp = outs_area->operand + + (cur_func->import_func_inst + ? cur_func->import_func_inst->const_cell_num + : 0); + } + else +#endif + { + outs_area->lp = outs_area->operand + cur_func->const_cell_num; + } + for (i = 0; i < cur_func->param_count; i++) { + if (cur_func->param_types[i] == VALUE_TYPE_I64 + || cur_func->param_types[i] == VALUE_TYPE_F64) { + PUT_I64_TO_ADDR( + outs_area->lp, + GET_OPERAND(uint64, I64, + 2 * (cur_func->param_count - i - 1))); + outs_area->lp += 2; + } + else { + *outs_area->lp = GET_OPERAND( + uint32, I32, (2 * (cur_func->param_count - i - 1))); + outs_area->lp++; + } + } + frame_ip += cur_func->param_count * sizeof(int16); + if (cur_func->ret_cell_num != 0) { + /* Get the first return value's offset. Since loader emit + * all return values' offset so we must skip remain return + * values' offsets. + */ + WASMType *func_type; + if (cur_func->is_import_func) + func_type = cur_func->u.func_import->func_type; + else + func_type = cur_func->u.func->func_type; + frame->ret_offset = GET_OFFSET(); + frame_ip += 2 * (func_type->result_count - 1); + } + SYNC_ALL_TO_FRAME(); + prev_frame = frame; + } + + call_func_from_entry: + { + if (cur_func->is_import_func) { +#if WASM_ENABLE_MULTI_MODULE != 0 + if (cur_func->import_func_inst) { + wasm_interp_call_func_import(module, exec_env, cur_func, + prev_frame); + } + else +#endif + { + wasm_interp_call_func_native(module, exec_env, cur_func, + prev_frame); + } + + prev_frame = frame->prev_frame; + cur_func = frame->function; + UPDATE_ALL_FROM_FRAME(); + + /* update memory instance ptr and memory size */ + memory = module->default_memory; + if (memory) + linear_mem_size = num_bytes_per_page * memory->cur_page_count; + if (wasm_get_exception(module)) + goto got_exception; + } + else { + WASMFunction *cur_wasm_func = cur_func->u.func; + + all_cell_num = (uint64)cur_func->param_cell_num + + (uint64)cur_func->local_cell_num + + (uint64)cur_func->const_cell_num + + (uint64)cur_wasm_func->max_stack_cell_num; + if (all_cell_num >= UINT32_MAX) { + wasm_set_exception(module, "wasm operand stack overflow"); + goto got_exception; + } + + frame_size = wasm_interp_interp_frame_size((uint32)all_cell_num); + if (!(frame = ALLOC_FRAME(exec_env, frame_size, prev_frame))) { + frame = prev_frame; + goto got_exception; + } + + /* Initialize the interpreter context. */ + frame->function = cur_func; + frame_ip = wasm_get_func_code(cur_func); + frame_ip_end = wasm_get_func_code_end(cur_func); + + frame_lp = frame->lp = + frame->operand + cur_wasm_func->const_cell_num; + + /* Initialize the consts */ + word_copy(frame->operand, (uint32 *)cur_wasm_func->consts, + cur_wasm_func->const_cell_num); + + /* Initialize the local varialbes */ + memset(frame_lp + cur_func->param_cell_num, 0, + (uint32)(cur_func->local_cell_num * 4)); + + wasm_exec_env_set_cur_frame(exec_env, (WASMRuntimeFrame *)frame); + } + HANDLE_OP_END(); + } + + return_func: + { + FREE_FRAME(exec_env, frame); + wasm_exec_env_set_cur_frame(exec_env, (WASMRuntimeFrame *)prev_frame); + + if (!prev_frame->ip) + /* Called from native. */ + return; + + RECOVER_CONTEXT(prev_frame); + HANDLE_OP_END(); + } + + (void)frame_ip_end; + +#if WASM_ENABLE_SHARED_MEMORY != 0 + unaligned_atomic: + wasm_set_exception(module, "unaligned atomic"); + goto got_exception; +#endif + + out_of_bounds: + wasm_set_exception(module, "out of bounds memory access"); + + got_exception: + SYNC_ALL_TO_FRAME(); + return; #if WASM_ENABLE_LABELS_AS_VALUES == 0 - } + } #else - FETCH_OPCODE_AND_DISPATCH (); + FETCH_OPCODE_AND_DISPATCH(); #endif } @@ -3442,37 +3714,37 @@ wasm_interp_get_handle_table() #endif void -wasm_interp_call_wasm(WASMModuleInstance *module_inst, - WASMExecEnv *exec_env, - WASMFunctionInstance *function, - uint32 argc, uint32 argv[]) +wasm_interp_call_wasm(WASMModuleInstance *module_inst, WASMExecEnv *exec_env, + WASMFunctionInstance *function, uint32 argc, + uint32 argv[]) { WASMRuntimeFrame *prev_frame = wasm_exec_env_get_cur_frame(exec_env); WASMInterpFrame *frame, *outs_area; /* Allocate sufficient cells for all kinds of return values. */ - unsigned all_cell_num = function->ret_cell_num > 2 ? - function->ret_cell_num : 2, i; + unsigned all_cell_num = + function->ret_cell_num > 2 ? function->ret_cell_num : 2, + i; /* This frame won't be used by JITed code, so only allocate interp frame here. */ unsigned frame_size = wasm_interp_interp_frame_size(all_cell_num); if (argc != function->param_cell_num) { char buf[128]; - snprintf(buf, sizeof(buf), - "invalid argument count %d, expected %d", + snprintf(buf, sizeof(buf), "invalid argument count %d, expected %d", argc, function->param_cell_num); wasm_set_exception(module_inst, buf); return; } - if ((uint8*)&prev_frame < exec_env->native_stack_boundary) { - wasm_set_exception((WASMModuleInstance*)exec_env->module_inst, + if ((uint8 *)&prev_frame < exec_env->native_stack_boundary) { + wasm_set_exception((WASMModuleInstance *)exec_env->module_inst, "native stack overflow"); return; } - if (!(frame = ALLOC_FRAME(exec_env, frame_size, (WASMInterpFrame*)prev_frame))) + if (!(frame = + ALLOC_FRAME(exec_env, frame_size, (WASMInterpFrame *)prev_frame))) return; outs_area = wasm_exec_env_wasm_stack_top(exec_env); @@ -3491,15 +3763,15 @@ wasm_interp_call_wasm(WASMModuleInstance *module_inst, #if WASM_ENABLE_MULTI_MODULE != 0 if (function->import_module_inst) { LOG_DEBUG("it is a function of a sub module"); - wasm_interp_call_func_import(module_inst, exec_env, - function, frame); + wasm_interp_call_func_import(module_inst, exec_env, function, + frame); } else #endif { LOG_DEBUG("it is an native function"); - wasm_interp_call_func_native(module_inst, exec_env, - function, frame); + wasm_interp_call_func_native(module_inst, exec_env, function, + frame); } } else { diff --git a/core/iwasm/interpreter/wasm_loader.c b/core/iwasm/interpreter/wasm_loader.c index ea0d9cfe..979ab0be 100644 --- a/core/iwasm/interpreter/wasm_loader.c +++ b/core/iwasm/interpreter/wasm_loader.c @@ -17,21 +17,20 @@ /* Read a value of given type from the address pointed to by the given pointer and increase the pointer to the position just after the value being read. */ -#define TEMPLATE_READ_VALUE(Type, p) \ +#define TEMPLATE_READ_VALUE(Type, p) \ (p += sizeof(Type), *(Type *)(p - sizeof(Type))) static void set_error_buf(char *error_buf, uint32 error_buf_size, const char *string) { if (error_buf != NULL) { - snprintf(error_buf, error_buf_size, - "WASM module load failed: %s", string); + snprintf(error_buf, error_buf_size, "WASM module load failed: %s", + string); } } static void -set_error_buf_v(char *error_buf, uint32 error_buf_size, - const char *format, ...) +set_error_buf_v(char *error_buf, uint32 error_buf_size, const char *format, ...) { va_list args; char buf[128]; @@ -40,8 +39,7 @@ set_error_buf_v(char *error_buf, uint32 error_buf_size, va_start(args, format); vsnprintf(buf, sizeof(buf), format, args); va_end(args); - snprintf(error_buf, error_buf_size, - "WASM module load failed: %s", buf); + snprintf(error_buf, error_buf_size, "WASM module load failed: %s", buf); } } @@ -68,19 +66,19 @@ check_buf1(const uint8 *buf, const uint8 *buf_end, uint32 length, return true; } -#define CHECK_BUF(buf, buf_end, length) do { \ - if (!check_buf(buf, buf_end, length, \ - error_buf, error_buf_size)) { \ - goto fail; \ - } \ -} while (0) +#define CHECK_BUF(buf, buf_end, length) \ + do { \ + if (!check_buf(buf, buf_end, length, error_buf, error_buf_size)) { \ + goto fail; \ + } \ + } while (0) -#define CHECK_BUF1(buf, buf_end, length) do { \ - if (!check_buf1(buf, buf_end, length, \ - error_buf, error_buf_size)) { \ - goto fail; \ - } \ -} while (0) +#define CHECK_BUF1(buf, buf_end, length) \ + do { \ + if (!check_buf1(buf, buf_end, length, error_buf, error_buf_size)) { \ + goto fail; \ + } \ + } while (0) #define skip_leb(p) while (*p++ & 0x80) #define skip_leb_int64(p, p_end) skip_leb(p) @@ -88,9 +86,8 @@ check_buf1(const uint8 *buf, const uint8 *buf_end, uint32 length, #define skip_leb_int32(p, p_end) skip_leb(p) static bool -read_leb(uint8 **p_buf, const uint8 *buf_end, - uint32 maxbits, bool sign, uint64 *p_result, - char* error_buf, uint32 error_buf_size) +read_leb(uint8 **p_buf, const uint8 *buf_end, uint32 maxbits, bool sign, + uint64 *p_result, char *error_buf, uint32 error_buf_size) { const uint8 *buf = *p_buf; uint64 result = 0; @@ -164,33 +161,36 @@ fail: return false; } -#define read_uint8(p) TEMPLATE_READ_VALUE(uint8, p) +#define read_uint8(p) TEMPLATE_READ_VALUE(uint8, p) #define read_uint32(p) TEMPLATE_READ_VALUE(uint32, p) -#define read_bool(p) TEMPLATE_READ_VALUE(bool, p) +#define read_bool(p) TEMPLATE_READ_VALUE(bool, p) -#define read_leb_int64(p, p_end, res) do { \ - uint64 res64; \ - if (!read_leb((uint8**)&p, p_end, 64, true, &res64,\ - error_buf, error_buf_size)) \ - goto fail; \ - res = (int64)res64; \ -} while (0) +#define read_leb_int64(p, p_end, res) \ + do { \ + uint64 res64; \ + if (!read_leb((uint8 **)&p, p_end, 64, true, &res64, error_buf, \ + error_buf_size)) \ + goto fail; \ + res = (int64)res64; \ + } while (0) -#define read_leb_uint32(p, p_end, res) do { \ - uint64 res64; \ - if (!read_leb((uint8**)&p, p_end, 32, false, &res64,\ - error_buf, error_buf_size)) \ - goto fail; \ - res = (uint32)res64; \ -} while (0) +#define read_leb_uint32(p, p_end, res) \ + do { \ + uint64 res64; \ + if (!read_leb((uint8 **)&p, p_end, 32, false, &res64, error_buf, \ + error_buf_size)) \ + goto fail; \ + res = (uint32)res64; \ + } while (0) -#define read_leb_int32(p, p_end, res) do { \ - uint64 res64; \ - if (!read_leb((uint8**)&p, p_end, 32, true, &res64,\ - error_buf, error_buf_size)) \ - goto fail; \ - res = (int32)res64; \ -} while (0) +#define read_leb_int32(p, p_end, res) \ + do { \ + uint64 res64; \ + if (!read_leb((uint8 **)&p, p_end, 32, true, &res64, error_buf, \ + error_buf_size)) \ + goto fail; \ + res = (int32)res64; \ + } while (0) static char * type2str(uint8 type) @@ -242,7 +242,7 @@ is_value_type(uint8 type) || type == VALUE_TYPE_V128 #endif #endif - ) + ) return true; return false; } @@ -256,7 +256,7 @@ is_byte_a_type(uint8 type) #if WASM_ENABLE_SIMD != 0 #if (WASM_ENABLE_WAMR_COMPILER != 0) || (WASM_ENABLE_JIT != 0) static V128 -read_i8x16(uint8 *p_buf, char* error_buf, uint32 error_buf_size) +read_i8x16(uint8 *p_buf, char *error_buf, uint32 error_buf_size) { V128 result; uint8 i; @@ -275,10 +275,8 @@ loader_malloc(uint64 size, char *error_buf, uint32 error_buf_size) { void *mem; - if (size >= UINT32_MAX - || !(mem = wasm_runtime_malloc((uint32)size))) { - set_error_buf(error_buf, error_buf_size, - "allocate memory failed"); + if (size >= UINT32_MAX || !(mem = wasm_runtime_malloc((uint32)size))) { + set_error_buf(error_buf, error_buf_size, "allocate memory failed"); return NULL; } @@ -287,7 +285,7 @@ loader_malloc(uint64 size, char *error_buf, uint32 error_buf_size) } static bool -check_utf8_str(const uint8* str, uint32 len) +check_utf8_str(const uint8 *str, uint32 len) { /* The valid ranges are taken from page 125, below link https://www.unicode.org/versions/Unicode9.0.0/ch03.pdf */ @@ -307,20 +305,17 @@ check_utf8_str(const uint8* str, uint32 len) } else if (chr >= 0xE0 && chr <= 0xEF && p + 2 < p_end) { if (chr == 0xE0) { - if (p[1] < 0xA0 || p[1] > 0xBF - || p[2] < 0x80 || p[2] > 0xBF) { + if (p[1] < 0xA0 || p[1] > 0xBF || p[2] < 0x80 || p[2] > 0xBF) { return false; } } else if (chr == 0xED) { - if (p[1] < 0x80 || p[1] > 0x9F - || p[2] < 0x80 || p[2] > 0xBF) { + if (p[1] < 0x80 || p[1] > 0x9F || p[2] < 0x80 || p[2] > 0xBF) { return false; } } else if (chr >= 0xE1 && chr <= 0xEF) { - if (p[1] < 0x80 || p[1] > 0xBF - || p[2] < 0x80 || p[2] > 0xBF) { + if (p[1] < 0x80 || p[1] > 0xBF || p[2] < 0x80 || p[2] > 0xBF) { return false; } } @@ -328,22 +323,19 @@ check_utf8_str(const uint8* str, uint32 len) } else if (chr >= 0xF0 && chr <= 0xF4 && p + 3 < p_end) { if (chr == 0xF0) { - if (p[1] < 0x90 || p[1] > 0xBF - || p[2] < 0x80 || p[2] > 0xBF + if (p[1] < 0x90 || p[1] > 0xBF || p[2] < 0x80 || p[2] > 0xBF || p[3] < 0x80 || p[3] > 0xBF) { return false; } } else if (chr >= 0xF1 && chr <= 0xF3) { - if (p[1] < 0x80 || p[1] > 0xBF - || p[2] < 0x80 || p[2] > 0xBF + if (p[1] < 0x80 || p[1] > 0xBF || p[2] < 0x80 || p[2] > 0xBF || p[3] < 0x80 || p[3] > 0xBF) { return false; } } else if (chr == 0xF4) { - if (p[1] < 0x80 || p[1] > 0x8F - || p[2] < 0x80 || p[2] > 0xBF + if (p[1] < 0x80 || p[1] > 0x8F || p[2] < 0x80 || p[2] > 0xBF || p[3] < 0x80 || p[3] > 0xBF) { return false; } @@ -357,15 +349,14 @@ check_utf8_str(const uint8* str, uint32 len) return (p == p_end); } -static char* +static char * const_str_list_insert(const uint8 *str, uint32 len, WASMModule *module, - char* error_buf, uint32 error_buf_size) + char *error_buf, uint32 error_buf_size) { StringNode *node, *node_next; if (!check_utf8_str(str, len)) { - set_error_buf(error_buf, error_buf_size, - "invalid UTF-8 encoding"); + set_error_buf(error_buf, error_buf_size, "invalid UTF-8 encoding"); return NULL; } @@ -373,8 +364,7 @@ const_str_list_insert(const uint8 *str, uint32 len, WASMModule *module, node = module->const_str_list; while (node) { node_next = node->next; - if (strlen(node->str) == len - && !memcmp(node->str, str, len)) + if (strlen(node->str) == len && !memcmp(node->str, str, len)) break; node = node_next; } @@ -383,12 +373,12 @@ const_str_list_insert(const uint8 *str, uint32 len, WASMModule *module, return node->str; } - if (!(node = loader_malloc(sizeof(StringNode) + len + 1, - error_buf, error_buf_size))) { + if (!(node = loader_malloc(sizeof(StringNode) + len + 1, error_buf, + error_buf_size))) { return NULL; } - node->str = ((char*)node) + sizeof(StringNode); + node->str = ((char *)node) + sizeof(StringNode); bh_memcpy_s(node->str, len + 1, str, len); node->str[len] = '\0'; @@ -408,8 +398,8 @@ const_str_list_insert(const uint8 *str, uint32 len, WASMModule *module, static bool load_init_expr(const uint8 **p_buf, const uint8 *buf_end, - InitializerExpression *init_expr, uint8 type, - char *error_buf, uint32 error_buf_size) + InitializerExpression *init_expr, uint8 type, char *error_buf, + uint32 error_buf_size) { const uint8 *p = *p_buf, *p_end = buf_end; uint8 flag, end_byte, *p_float; @@ -437,7 +427,7 @@ load_init_expr(const uint8 **p_buf, const uint8 *buf_end, if (type != VALUE_TYPE_F32) goto fail_type_mismatch; CHECK_BUF(p, p_end, 4); - p_float = (uint8*)&init_expr->u.f32; + p_float = (uint8 *)&init_expr->u.f32; for (i = 0; i < sizeof(float32); i++) *p_float++ = *p++; break; @@ -446,7 +436,7 @@ load_init_expr(const uint8 **p_buf, const uint8 *buf_end, if (type != VALUE_TYPE_F64) goto fail_type_mismatch; CHECK_BUF(p, p_end, 8); - p_float = (uint8*)&init_expr->u.f64; + p_float = (uint8 *)&init_expr->u.f64; for (i = 0; i < sizeof(float64); i++) *p_float++ = *p++; break; @@ -464,7 +454,7 @@ load_init_expr(const uint8 **p_buf, const uint8 *buf_end, (void)flag; CHECK_BUF(p, p_end, 16); - wasm_runtime_read_v128(p, &high, &low); + wasm_runtime_read_v128(p, &high, &low); p += 16; init_expr->u.v128.i64x2[0] = high; @@ -506,9 +496,10 @@ load_init_expr(const uint8 **p_buf, const uint8 *buf_end, case INIT_EXPR_TYPE_GET_GLOBAL: read_leb_uint32(p, p_end, init_expr->u.global_index); break; - default: { + default: + { #if WASM_ENABLE_REF_TYPES != 0 -illegal_opcode: + illegal_opcode: #endif set_error_buf(error_buf, error_buf_size, "illegal opcode " @@ -546,9 +537,9 @@ load_type_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, if (type_count) { module->type_count = type_count; - total_size = sizeof(WASMType*) * (uint64)type_count; - if (!(module->types = loader_malloc - (total_size, error_buf, error_buf_size))) { + total_size = sizeof(WASMType *) * (uint64)type_count; + if (!(module->types = + loader_malloc(total_size, error_buf, error_buf_size))) { return false; } @@ -556,8 +547,7 @@ load_type_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, CHECK_BUF(p, p_end, 1); flag = read_uint8(p); if (flag != 0x60) { - set_error_buf(error_buf, error_buf_size, - "invalid type flag"); + set_error_buf(error_buf, error_buf_size, "invalid type flag"); return false; } @@ -577,10 +567,10 @@ load_type_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, return false; } - total_size = offsetof(WASMType, types) + - sizeof(uint8) * (uint64)(param_count + result_count); + total_size = offsetof(WASMType, types) + + sizeof(uint8) * (uint64)(param_count + result_count); if (!(type = module->types[i] = - loader_malloc(total_size, error_buf, error_buf_size))) { + loader_malloc(total_size, error_buf, error_buf_size))) { return false; } @@ -598,8 +588,8 @@ load_type_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, } param_cell_num = wasm_get_cell_num(type->types, param_count); - ret_cell_num = wasm_get_cell_num(type->types + param_count, - result_count); + ret_cell_num = + wasm_get_cell_num(type->types + param_count, result_count); if (param_cell_num > UINT16_MAX || ret_cell_num > UINT16_MAX) { set_error_buf(error_buf, error_buf_size, "param count or result count too large"); @@ -625,7 +615,7 @@ static void adjust_table_max_size(uint32 init_size, uint32 max_size_flag, uint32 *max_size) { uint32 default_max_size = - init_size * 2 > TABLE_MAX_SIZE ? init_size * 2 : TABLE_MAX_SIZE; + init_size * 2 > TABLE_MAX_SIZE ? init_size * 2 : TABLE_MAX_SIZE; if (max_size_flag) { /* module defines the table limitation */ @@ -633,7 +623,7 @@ adjust_table_max_size(uint32 init_size, uint32 max_size_flag, uint32 *max_size) if (init_size < *max_size) { *max_size = - *max_size < default_max_size ? *max_size : default_max_size; + *max_size < default_max_size ? *max_size : default_max_size; } } else { @@ -648,12 +638,10 @@ adjust_table_max_size(uint32 init_size, uint32 max_size_flag, uint32 *max_size) * module name, field name and export kind */ static WASMExport * -wasm_loader_find_export(const WASMModule *module, - const char *module_name, - const char *field_name, - uint8 export_kind, - uint32 export_index_boundary, - char *error_buf, uint32 error_buf_size) +wasm_loader_find_export(const WASMModule *module, const char *module_name, + const char *field_name, uint8 export_kind, + uint32 export_index_boundary, char *error_buf, + uint32 error_buf_size) { WASMExport *export; uint32 i; @@ -680,9 +668,8 @@ wasm_loader_find_export(const WASMModule *module, } if (export->index >= export_index_boundary) { - LOG_DEBUG("%s in the module %s is out of index (%d >= %d )", - field_name, module_name, - export->index, export_index_boundary); + LOG_DEBUG("%s in the module %s is out of index (%d >= %d )", field_name, + module_name, export->index, export_index_boundary); set_error_buf(error_buf, error_buf_size, "incompatible import type"); return NULL; } @@ -691,8 +678,7 @@ wasm_loader_find_export(const WASMModule *module, } static WASMFunction * -wasm_loader_resolve_function(const char *module_name, - const char *function_name, +wasm_loader_resolve_function(const char *module_name, const char *function_name, const WASMType *expected_function_type, char *error_buf, uint32 error_buf_size) { @@ -703,20 +689,18 @@ wasm_loader_resolve_function(const char *module_name, WASMType *target_function_type = NULL; module_reg = wasm_runtime_find_module_registered(module_name); - if (!module_reg - || module_reg->module_type != Wasm_Module_Bytecode) { - LOG_DEBUG("can not find a module named %s for function %s", - module_name, function_name); + if (!module_reg || module_reg->module_type != Wasm_Module_Bytecode) { + LOG_DEBUG("can not find a module named %s for function %s", module_name, + function_name); set_error_buf(error_buf, error_buf_size, "unknown import"); return NULL; } module = (WASMModule *)module_reg; - export = wasm_loader_find_export(module, module_name, function_name, - EXPORT_KIND_FUNC, - module->import_function_count - + module->function_count, - error_buf, error_buf_size); + export = wasm_loader_find_export( + module, module_name, function_name, EXPORT_KIND_FUNC, + module->import_function_count + module->function_count, error_buf, + error_buf_size); if (!export) { return NULL; } @@ -724,16 +708,16 @@ wasm_loader_resolve_function(const char *module_name, /* resolve function type and function */ if (export->index < module->import_function_count) { target_function_type = - module->import_functions[export->index].u.function.func_type; + module->import_functions[export->index].u.function.func_type; function = module->import_functions[export->index] - .u.function.import_func_linked; + .u.function.import_func_linked; } else { target_function_type = - module->functions[export->index - module->import_function_count] - ->func_type; + module->functions[export->index - module->import_function_count] + ->func_type; function = - module->functions[export->index - module->import_function_count]; + module->functions[export->index - module->import_function_count]; } /* check function type */ @@ -748,8 +732,8 @@ wasm_loader_resolve_function(const char *module_name, static WASMTable * wasm_loader_resolve_table(const char *module_name, const char *table_name, - uint32 init_size, uint32 max_size, - char *error_buf, uint32 error_buf_size) + uint32 init_size, uint32 max_size, char *error_buf, + uint32 error_buf_size) { WASMModuleCommon *module_reg; WASMTable *table = NULL; @@ -757,19 +741,17 @@ wasm_loader_resolve_table(const char *module_name, const char *table_name, WASMModule *module = NULL; module_reg = wasm_runtime_find_module_registered(module_name); - if (!module_reg - || module_reg->module_type != Wasm_Module_Bytecode) { + if (!module_reg || module_reg->module_type != Wasm_Module_Bytecode) { LOG_DEBUG("can not find a module named %s for table", module_name); set_error_buf(error_buf, error_buf_size, "unknown import"); return NULL; } module = (WASMModule *)module_reg; - export = wasm_loader_find_export(module, module_name, table_name, - EXPORT_KIND_TABLE, - module->table_count - + module->import_table_count, - error_buf, error_buf_size); + export = wasm_loader_find_export( + module, module_name, table_name, EXPORT_KIND_TABLE, + module->table_count + module->import_table_count, error_buf, + error_buf_size); if (!export) { return NULL; } @@ -777,7 +759,7 @@ wasm_loader_resolve_table(const char *module_name, const char *table_name, /* resolve table and check the init/max size */ if (export->index < module->import_table_count) { table = - module->import_tables[export->index].u.table.import_table_linked; + module->import_tables[export->index].u.table.import_table_linked; } else { table = &(module->tables[export->index - module->import_table_count]); @@ -804,35 +786,32 @@ wasm_loader_resolve_memory(const char *module_name, const char *memory_name, WASMModule *module = NULL; module_reg = wasm_runtime_find_module_registered(module_name); - if (!module_reg - || module_reg->module_type != Wasm_Module_Bytecode) { + if (!module_reg || module_reg->module_type != Wasm_Module_Bytecode) { LOG_DEBUG("can not find a module named %s for memory", module_name); set_error_buf(error_buf, error_buf_size, "unknown import"); return NULL; } module = (WASMModule *)module_reg; - export = wasm_loader_find_export(module, module_name, memory_name, - EXPORT_KIND_MEMORY, - module->import_memory_count - + module->memory_count, - error_buf, error_buf_size); + export = wasm_loader_find_export( + module, module_name, memory_name, EXPORT_KIND_MEMORY, + module->import_memory_count + module->memory_count, error_buf, + error_buf_size); if (!export) { return NULL; } - /* resolve memory and check the init/max page count */ if (export->index < module->import_memory_count) { - memory = - module->import_memories[export->index].u.memory.import_memory_linked; + memory = module->import_memories[export->index] + .u.memory.import_memory_linked; } else { memory = - &(module->memories[export->index - module->import_memory_count]); + &(module->memories[export->index - module->import_memory_count]); } - if (memory->init_page_count < init_page_count || - memory->max_page_count > max_page_count) { + if (memory->init_page_count < init_page_count + || memory->max_page_count > max_page_count) { LOG_DEBUG("%s,%s failed type check(%d-%d), expected(%d-%d)", module_name, memory_name, memory->init_page_count, memory->max_page_count, init_page_count, max_page_count); @@ -843,10 +822,9 @@ wasm_loader_resolve_memory(const char *module_name, const char *memory_name, } static WASMGlobal * -wasm_loader_resolve_global(const char *module_name, - const char *global_name, - uint8 type, bool is_mutable, - char *error_buf, uint32 error_buf_size) +wasm_loader_resolve_global(const char *module_name, const char *global_name, + uint8 type, bool is_mutable, char *error_buf, + uint32 error_buf_size) { WASMModuleCommon *module_reg; WASMGlobal *global = NULL; @@ -854,19 +832,17 @@ wasm_loader_resolve_global(const char *module_name, WASMModule *module = NULL; module_reg = wasm_runtime_find_module_registered(module_name); - if (!module_reg - || module_reg->module_type != Wasm_Module_Bytecode) { + if (!module_reg || module_reg->module_type != Wasm_Module_Bytecode) { LOG_DEBUG("can not find a module named %s for global", module_name); set_error_buf(error_buf, error_buf_size, "unknown import"); return NULL; } module = (WASMModule *)module_reg; - export = wasm_loader_find_export(module, module_name, global_name, - EXPORT_KIND_GLOBAL, - module->import_global_count - + module->global_count, - error_buf, error_buf_size); + export = wasm_loader_find_export( + module, module_name, global_name, EXPORT_KIND_GLOBAL, + module->import_global_count + module->global_count, error_buf, + error_buf_size); if (!export) { return NULL; } @@ -874,11 +850,11 @@ wasm_loader_resolve_global(const char *module_name, /* resolve and check the global */ if (export->index < module->import_global_count) { global = - module->import_globals[export->index].u.global.import_global_linked; + module->import_globals[export->index].u.global.import_global_linked; } else { global = - &(module->globals[export->index - module->import_global_count]); + &(module->globals[export->index - module->import_global_count]); } if (global->type != type || global->is_mutable != is_mutable) { LOG_DEBUG("%s,%s failed type check(%d, %d), expected(%d, %d)", @@ -894,11 +870,11 @@ static WASMModule * search_sub_module(const WASMModule *parent_module, const char *sub_module_name) { WASMRegisteredModule *node = - bh_list_first_elem(parent_module->import_module_list); + bh_list_first_elem(parent_module->import_module_list); while (node && strcmp(sub_module_name, node->module_name)) { node = bh_list_elem_next(node); } - return node ? (WASMModule*)node->module : NULL; + return node ? (WASMModule *)node->module : NULL; } static bool @@ -920,7 +896,7 @@ register_sub_module(const WASMModule *parent_module, } node->module_name = sub_module_name; - node->module = (WASMModuleCommon*)sub_module; + node->module = (WASMModuleCommon *)sub_module; ret = bh_list_insert(parent_module->import_module_list, node); bh_assert(BH_LIST_SUCCESS == ret); (void)ret; @@ -948,7 +924,7 @@ load_depended_module(const WASMModule *parent_module, /* check the global registered module list */ sub_module = - (WASMModule *)wasm_runtime_find_module_registered(sub_module_name); + (WASMModule *)wasm_runtime_find_module_registered(sub_module_name); if (sub_module) { LOG_DEBUG("%s has been loaded", sub_module_name); goto register_sub_module; @@ -958,8 +934,7 @@ load_depended_module(const WASMModule *parent_module, if (!reader) { set_error_buf_v(error_buf, error_buf_size, - "no sub module reader to load %s", - sub_module_name); + "no sub module reader to load %s", sub_module_name); return NULL; } @@ -967,16 +942,14 @@ load_depended_module(const WASMModule *parent_module, ret = wasm_runtime_is_loading_module(sub_module_name); if (ret) { set_error_buf_v(error_buf, error_buf_size, - "found circular dependency on %s", - sub_module_name); + "found circular dependency on %s", sub_module_name); return NULL; } ret = wasm_runtime_add_loading_module(sub_module_name, error_buf, error_buf_size); if (!ret) { - LOG_DEBUG("can not add %s into loading module list\n", - sub_module_name); + LOG_DEBUG("can not add %s into loading module list\n", sub_module_name); return NULL; } @@ -989,7 +962,7 @@ load_depended_module(const WASMModule *parent_module, } sub_module = - wasm_loader_load(buffer, buffer_size, error_buf, error_buf_size); + wasm_loader_load(buffer, buffer_size, error_buf, error_buf_size); if (!sub_module) { LOG_DEBUG("error: can not load the sub_module %s", sub_module_name); /* others will be destroyed in runtime_destroy() */ @@ -999,12 +972,12 @@ load_depended_module(const WASMModule *parent_module, wasm_runtime_delete_loading_module(sub_module_name); /* register on a global list */ - ret = wasm_runtime_register_module_internal(sub_module_name, - (WASMModuleCommon*)sub_module, - buffer, buffer_size, error_buf, - error_buf_size); + ret = wasm_runtime_register_module_internal( + sub_module_name, (WASMModuleCommon *)sub_module, buffer, buffer_size, + error_buf, error_buf_size); if (!ret) { - LOG_DEBUG("error: can not register module %s globally\n", sub_module_name); + LOG_DEBUG("error: can not register module %s globally\n", + sub_module_name); /* others will be unloaded in runtime_destroy() */ goto unload_module; } @@ -1014,8 +987,7 @@ register_sub_module: ret = register_sub_module(parent_module, sub_module_name, sub_module); if (!ret) { set_error_buf_v(error_buf, error_buf_size, - "failed to register sub module %s", - sub_module_name); + "failed to register sub module %s", sub_module_name); /* since it is in the global module list, no need to * unload the module. the runtime_destroy() will do it */ @@ -1045,10 +1017,9 @@ delete_loading_module: static bool load_function_import(const uint8 **p_buf, const uint8 *buf_end, const WASMModule *parent_module, - const char *sub_module_name, - const char *function_name, - WASMFunctionImport *function, - char *error_buf, uint32 error_buf_size) + const char *sub_module_name, const char *function_name, + WASMFunctionImport *function, char *error_buf, + uint32 error_buf_size) { const uint8 *p = *p_buf, *p_end = buf_end; uint32 declare_type_index = 0; @@ -1062,7 +1033,6 @@ load_function_import(const uint8 **p_buf, const uint8 *buf_end, bool linked_call_conv_raw = false; bool is_native_symbol = false; - CHECK_BUF(p, p_end, 1); read_leb_uint32(p, p_end, declare_type_index); *p_buf = p; @@ -1074,19 +1044,15 @@ load_function_import(const uint8 **p_buf, const uint8 *buf_end, #if (WASM_ENABLE_WAMR_COMPILER != 0) || (WASM_ENABLE_JIT != 0) declare_type_index = wasm_get_smallest_type_idx( - parent_module->types, parent_module->type_count, - declare_type_index); + parent_module->types, parent_module->type_count, declare_type_index); #endif declare_func_type = parent_module->types[declare_type_index]; /* lookup registered native symbols first */ - linked_func = wasm_native_resolve_symbol(sub_module_name, - function_name, - declare_func_type, - &linked_signature, - &linked_attachment, - &linked_call_conv_raw); + linked_func = wasm_native_resolve_symbol( + sub_module_name, function_name, declare_func_type, &linked_signature, + &linked_attachment, &linked_call_conv_raw); if (linked_func) { is_native_symbol = true; } @@ -1099,11 +1065,9 @@ load_function_import(const uint8 **p_buf, const uint8 *buf_end, return false; } } - linked_func = wasm_loader_resolve_function(sub_module_name, - function_name, - declare_func_type, - error_buf, - error_buf_size); + linked_func = wasm_loader_resolve_function( + sub_module_name, function_name, declare_func_type, error_buf, + error_buf_size); } #endif @@ -1125,8 +1089,8 @@ fail: } static bool -check_table_max_size(uint32 init_size, uint32 max_size, - char *error_buf, uint32 error_buf_size) +check_table_max_size(uint32 init_size, uint32 max_size, char *error_buf, + uint32 error_buf_size) { if (max_size < init_size) { set_error_buf(error_buf, error_buf_size, @@ -1138,10 +1102,8 @@ check_table_max_size(uint32 init_size, uint32 max_size, static bool load_table_import(const uint8 **p_buf, const uint8 *buf_end, - WASMModule *parent_module, - const char *sub_module_name, - const char *table_name, - WASMTableImport *table, + WASMModule *parent_module, const char *sub_module_name, + const char *table_name, WASMTableImport *table, char *error_buf, uint32 error_buf_size) { const uint8 *p = *p_buf, *p_end = buf_end; @@ -1194,9 +1156,8 @@ load_table_import(const uint8 **p_buf, const uint8 *buf_end, } linked_table = wasm_loader_resolve_table( - sub_module_name, table_name, - declare_init_size, declare_max_size, - error_buf, error_buf_size); + sub_module_name, table_name, declare_init_size, declare_max_size, + error_buf, error_buf_size); if (!linked_table) { return false; } @@ -1248,8 +1209,7 @@ unsigned wasm_runtime_memory_pool_size(); static bool -check_memory_init_size(uint32 init_size, - char *error_buf, uint32 error_buf_size) +check_memory_init_size(uint32 init_size, char *error_buf, uint32 error_buf_size) { if (init_size > 65536) { set_error_buf(error_buf, error_buf_size, @@ -1260,8 +1220,8 @@ check_memory_init_size(uint32 init_size, } static bool -check_memory_max_size(uint32 init_size, uint32 max_size, - char *error_buf, uint32 error_buf_size) +check_memory_max_size(uint32 init_size, uint32 max_size, char *error_buf, + uint32 error_buf_size) { if (max_size < init_size) { set_error_buf(error_buf, error_buf_size, @@ -1279,10 +1239,8 @@ check_memory_max_size(uint32 init_size, uint32 max_size, static bool load_memory_import(const uint8 **p_buf, const uint8 *buf_end, - WASMModule *parent_module, - const char *sub_module_name, - const char *memory_name, - WASMMemoryImport *memory, + WASMModule *parent_module, const char *sub_module_name, + const char *memory_name, WASMMemoryImport *memory, char *error_buf, uint32 error_buf_size) { const uint8 *p = *p_buf, *p_end = buf_end; @@ -1333,9 +1291,8 @@ load_memory_import(const uint8 **p_buf, const uint8 *buf_end, } linked_memory = wasm_loader_resolve_memory( - sub_module_name, memory_name, - declare_init_page_count, declare_max_page_count, - error_buf, error_buf_size); + sub_module_name, memory_name, declare_init_page_count, + declare_max_page_count, error_buf, error_buf_size); if (!linked_memory) { return false; } @@ -1386,10 +1343,9 @@ fail: static bool load_global_import(const uint8 **p_buf, const uint8 *buf_end, - const WASMModule *parent_module, - char *sub_module_name, char *global_name, - WASMGlobalImport *global, - char *error_buf, uint32 error_buf_size) + const WASMModule *parent_module, char *sub_module_name, + char *global_name, WASMGlobalImport *global, char *error_buf, + uint32 error_buf_size) { const uint8 *p = *p_buf, *p_end = buf_end; uint8 declare_type = 0; @@ -1411,7 +1367,7 @@ load_global_import(const uint8 **p_buf, const uint8 *buf_end, #if WASM_ENABLE_LIBC_BUILTIN != 0 global->is_linked = wasm_native_lookup_libc_builtin_global( - sub_module_name, global_name, global); + sub_module_name, global_name, global); if (global->is_linked) { if (global->type != declare_type || global->is_mutable != declare_mutable) { @@ -1431,10 +1387,9 @@ load_global_import(const uint8 **p_buf, const uint8 *buf_end, } /* check sub modules */ - linked_global = - wasm_loader_resolve_global(sub_module_name, global_name, - declare_type, declare_mutable, - error_buf, error_buf_size); + linked_global = wasm_loader_resolve_global( + sub_module_name, global_name, declare_type, declare_mutable, + error_buf, error_buf_size); if (linked_global) { global->import_module = sub_module; global->import_global_linked = linked_global; @@ -1550,22 +1505,23 @@ load_memory(const uint8 **p_buf, const uint8 *buf_end, WASMMemory *memory, return false; } else if (memory->flags == 2) { - set_error_buf(error_buf, error_buf_size, "shared memory must have maximum"); + set_error_buf(error_buf, error_buf_size, + "shared memory must have maximum"); return false; } #endif read_leb_uint32(p, p_end, memory->init_page_count); - if (!check_memory_init_size(memory->init_page_count, - error_buf, error_buf_size)) + if (!check_memory_init_size(memory->init_page_count, error_buf, + error_buf_size)) return false; if (memory->flags & 1) { read_leb_uint32(p, p_end, memory->max_page_count); if (!check_memory_max_size(memory->init_page_count, - memory->max_page_count, - error_buf, error_buf_size)) - return false; + memory->max_page_count, error_buf, + error_buf_size)) + return false; if (memory->max_page_count > max_page_count) memory->max_page_count = max_page_count; } @@ -1596,10 +1552,11 @@ load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, uint8 u8, kind; /* insert builtin module names into const str list */ - if (!const_str_list_insert((uint8*)"env", 3, module, error_buf, error_buf_size) - || !const_str_list_insert((uint8*)"wasi_unstable", 13, module, + if (!const_str_list_insert((uint8 *)"env", 3, module, error_buf, + error_buf_size) + || !const_str_list_insert((uint8 *)"wasi_unstable", 13, module, error_buf, error_buf_size) - || !const_str_list_insert((uint8*)"wasi_snapshot_preview1", 22, module, + || !const_str_list_insert((uint8 *)"wasi_snapshot_preview1", 22, module, error_buf, error_buf_size)) { return false; } @@ -1609,8 +1566,8 @@ load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, if (import_count) { module->import_count = import_count; total_size = sizeof(WASMImport) * (uint64)import_count; - if (!(module->imports = loader_malloc - (total_size, error_buf, error_buf_size))) { + if (!(module->imports = + loader_malloc(total_size, error_buf, error_buf_size))) { return false; } @@ -1650,10 +1607,10 @@ load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, if ( #if WASM_ENABLE_REF_TYPES != 0 - !wasm_get_ref_types_flag() && + !wasm_get_ref_types_flag() && #endif - module->import_table_count > 1) { + module->import_table_count > 1) { set_error_buf(error_buf, error_buf_size, "multiple tables"); return false; @@ -1693,11 +1650,12 @@ load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, module->imports + module->import_function_count; if (module->import_memory_count) import_memories = module->import_memories = - module->imports + module->import_function_count + module->import_table_count; + module->imports + module->import_function_count + + module->import_table_count; if (module->import_global_count) import_globals = module->import_globals = - module->imports + module->import_function_count + module->import_table_count - + module->import_memory_count; + module->imports + module->import_function_count + + module->import_table_count + module->import_memory_count; p = p_old; @@ -1707,7 +1665,7 @@ load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, read_leb_uint32(p, p_end, name_len); CHECK_BUF(p, p_end, name_len); if (!(sub_module_name = const_str_list_insert( - p, name_len, module, error_buf, error_buf_size))) { + p, name_len, module, error_buf, error_buf_size))) { return false; } p += name_len; @@ -1716,7 +1674,7 @@ load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, read_leb_uint32(p, p_end, name_len); CHECK_BUF(p, p_end, name_len); if (!(field_name = const_str_list_insert( - p, name_len, module, error_buf, error_buf_size))) { + p, name_len, module, error_buf, error_buf_size))) { return false; } p += name_len; @@ -1729,10 +1687,9 @@ load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, case IMPORT_KIND_FUNC: /* import function */ bh_assert(import_functions); import = import_functions++; - if (!load_function_import(&p, p_end, module, - sub_module_name, field_name, - &import->u.function, - error_buf, error_buf_size)) { + if (!load_function_import( + &p, p_end, module, sub_module_name, field_name, + &import->u.function, error_buf, error_buf_size)) { return false; } break; @@ -1740,9 +1697,8 @@ load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, case IMPORT_KIND_TABLE: /* import table */ bh_assert(import_tables); import = import_tables++; - if (!load_table_import(&p, p_end, module, - sub_module_name, field_name, - &import->u.table, + if (!load_table_import(&p, p_end, module, sub_module_name, + field_name, &import->u.table, error_buf, error_buf_size)) { LOG_DEBUG("can not import such a table (%s,%s)", sub_module_name, field_name); @@ -1753,9 +1709,8 @@ load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, case IMPORT_KIND_MEMORY: /* import memory */ bh_assert(import_memories); import = import_memories++; - if (!load_memory_import(&p, p_end, module, - sub_module_name, field_name, - &import->u.memory, + if (!load_memory_import(&p, p_end, module, sub_module_name, + field_name, &import->u.memory, error_buf, error_buf_size)) { return false; } @@ -1764,9 +1719,8 @@ load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, case IMPORT_KIND_GLOBAL: /* import global */ bh_assert(import_globals); import = import_globals++; - if (!load_global_import(&p, p_end, module, - sub_module_name, field_name, - &import->u.global, + if (!load_global_import(&p, p_end, module, sub_module_name, + field_name, &import->u.global, error_buf, error_buf_size)) { return false; } @@ -1786,7 +1740,8 @@ load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, import = module->import_functions; for (i = 0; i < module->import_function_count; i++, import++) { if (!strcmp(import->u.names.module_name, "wasi_unstable") - || !strcmp(import->u.names.module_name, "wasi_snapshot_preview1")) { + || !strcmp(import->u.names.module_name, + "wasi_snapshot_preview1")) { module->is_wasi_module = true; break; } @@ -1809,8 +1764,8 @@ fail: } static bool -init_function_local_offsets(WASMFunction *func, - char *error_buf, uint32 error_buf_size) +init_function_local_offsets(WASMFunction *func, char *error_buf, + uint32 error_buf_size) { WASMType *param_type = func->func_type; uint32 param_count = param_type->param_count; @@ -1827,7 +1782,7 @@ init_function_local_offsets(WASMFunction *func, */ if (total_size > 0 && !(func->local_offsets = - loader_malloc(total_size, error_buf, error_buf_size))) { + loader_malloc(total_size, error_buf, error_buf_size))) { return false; } @@ -1848,8 +1803,8 @@ init_function_local_offsets(WASMFunction *func, static bool load_function_section(const uint8 *buf, const uint8 *buf_end, const uint8 *buf_code, const uint8 *buf_code_end, - WASMModule *module, - char *error_buf, uint32 error_buf_size) + WASMModule *module, char *error_buf, + uint32 error_buf_size) { const uint8 *p = buf, *p_end = buf_end; const uint8 *p_code = buf_code, *p_code_end, *p_code_save; @@ -1874,9 +1829,9 @@ load_function_section(const uint8 *buf, const uint8 *buf_end, if (func_count) { module->function_count = func_count; - total_size = sizeof(WASMFunction*) * (uint64)func_count; + total_size = sizeof(WASMFunction *) * (uint64)func_count; if (!(module->functions = - loader_malloc(total_size, error_buf, error_buf_size))) { + loader_malloc(total_size, error_buf, error_buf_size))) { return false; } @@ -1890,12 +1845,11 @@ load_function_section(const uint8 *buf, const uint8 *buf_end, #if (WASM_ENABLE_WAMR_COMPILER != 0) || (WASM_ENABLE_JIT != 0) type_index = wasm_get_smallest_type_idx( - module->types, module->type_count, type_index); + module->types, module->type_count, type_index); #endif read_leb_uint32(p_code, buf_code_end, code_size); - if (code_size == 0 - || p_code + code_size > buf_code_end) { + if (code_size == 0 || p_code + code_size > buf_code_end) { set_error_buf(error_buf, error_buf_size, "invalid function code size"); return false; @@ -1911,8 +1865,7 @@ load_function_section(const uint8 *buf, const uint8 *buf_end, for (j = 0; j < local_set_count; j++) { read_leb_uint32(p_code, buf_code_end, sub_local_count); if (sub_local_count > UINT32_MAX - local_count) { - set_error_buf(error_buf, error_buf_size, - "too many locals"); + set_error_buf(error_buf, error_buf_size, "too many locals"); return false; } CHECK_BUF(p_code, buf_code_end, 1); @@ -1926,7 +1879,7 @@ load_function_section(const uint8 *buf, const uint8 *buf_end, total_size = sizeof(WASMFunction) + (uint64)local_count; if (!(func = module->functions[i] = - loader_malloc(total_size, error_buf, error_buf_size))) { + loader_malloc(total_size, error_buf, error_buf_size))) { return false; } @@ -1934,7 +1887,7 @@ load_function_section(const uint8 *buf, const uint8 *buf_end, func->func_type = module->types[type_index]; func->local_count = local_count; if (local_count > 0) - func->local_types = (uint8*)func + sizeof(WASMFunction); + func->local_types = (uint8 *)func + sizeof(WASMFunction); func->code_size = code_size; /* * we shall make a copy of code body [p_code, p_code + code_size] @@ -1946,7 +1899,7 @@ load_function_section(const uint8 *buf, const uint8 *buf_end, * memcpy(code_body_cp, p_code, code_size); * func->code = code_body_cp; */ - func->code = (uint8*)p_code; + func->code = (uint8 *)p_code; /* Load each local type */ p_code = p_code_save; @@ -2016,10 +1969,8 @@ fail: } static bool -check_function_index(const WASMModule *module, - uint32 function_index, - char *error_buf, - uint32 error_buf_size) +check_function_index(const WASMModule *module, uint32 function_index, + char *error_buf, uint32 error_buf_size) { if (function_index >= module->import_function_count + module->function_count) { @@ -2042,9 +1993,9 @@ load_table_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, read_leb_uint32(p, p_end, table_count); if ( #if WASM_ENABLE_REF_TYPES != 0 - !wasm_get_ref_types_flag() && + !wasm_get_ref_types_flag() && #endif - module->import_table_count + table_count > 1) { + module->import_table_count + table_count > 1) { /* a total of one table is allowed */ set_error_buf(error_buf, error_buf_size, "multiple tables"); return false; @@ -2053,8 +2004,8 @@ load_table_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, if (table_count) { module->table_count = table_count; total_size = sizeof(WASMTable) * (uint64)table_count; - if (!(module->tables = loader_malloc - (total_size, error_buf, error_buf_size))) { + if (!(module->tables = + loader_malloc(total_size, error_buf, error_buf_size))) { return false; } @@ -2095,8 +2046,8 @@ load_memory_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, if (memory_count) { module->memory_count = memory_count; total_size = sizeof(WASMMemory) * (uint64)memory_count; - if (!(module->memories = loader_malloc - (total_size, error_buf, error_buf_size))) { + if (!(module->memories = + loader_malloc(total_size, error_buf, error_buf_size))) { return false; } @@ -2133,14 +2084,14 @@ load_global_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, if (global_count) { module->global_count = global_count; total_size = sizeof(WASMGlobal) * (uint64)global_count; - if (!(module->globals = loader_malloc - (total_size, error_buf, error_buf_size))) { + if (!(module->globals = + loader_malloc(total_size, error_buf, error_buf_size))) { return false; } global = module->globals; - for(i = 0; i < global_count; i++, global++) { + for (i = 0; i < global_count; i++, global++) { CHECK_BUF(p, p_end, 2); global->type = read_uint8(p); mutable = read_uint8(p); @@ -2151,8 +2102,8 @@ load_global_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, global->is_mutable = mutable ? true : false; /* initialize expression */ - if (!load_init_expr(&p, p_end, &(global->init_expr), - global->type, error_buf, error_buf_size)) + if (!load_init_expr(&p, p_end, &(global->init_expr), global->type, + error_buf, error_buf_size)) return false; if (INIT_EXPR_TYPE_GET_GLOBAL == global->init_expr.init_expr_type) { @@ -2168,9 +2119,9 @@ load_global_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, return false; } } - else if (INIT_EXPR_TYPE_FUNCREF_CONST == global->init_expr.init_expr_type) { - if (!check_function_index(module, - global->init_expr.u.ref_index, + else if (INIT_EXPR_TYPE_FUNCREF_CONST + == global->init_expr.init_expr_type) { + if (!check_function_index(module, global->init_expr.u.ref_index, error_buf, error_buf_size)) { return false; } @@ -2205,28 +2156,27 @@ load_export_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, if (export_count) { module->export_count = export_count; total_size = sizeof(WASMExport) * (uint64)export_count; - if (!(module->exports = loader_malloc - (total_size, error_buf, error_buf_size))) { + if (!(module->exports = + loader_malloc(total_size, error_buf, error_buf_size))) { return false; } export = module->exports; - for (i = 0; i < export_count; i++, export++) { + for (i = 0; i < export_count; i++, export ++) { read_leb_uint32(p, p_end, str_len); CHECK_BUF(p, p_end, str_len); for (j = 0; j < i; j++) { name = module->exports[j].name; - if (strlen(name) == str_len - && memcmp(name, p, str_len) == 0) { - set_error_buf(error_buf, error_buf_size, - "duplicate export name"); - return false; + if (strlen(name) == str_len && memcmp(name, p, str_len) == 0) { + set_error_buf(error_buf, error_buf_size, + "duplicate export name"); + return false; } } - if (!(export->name = const_str_list_insert(p, str_len, module, - error_buf, error_buf_size))) { + if (!(export->name = const_str_list_insert( + p, str_len, module, error_buf, error_buf_size))) { return false; } @@ -2236,11 +2186,11 @@ load_export_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, read_leb_uint32(p, p_end, index); export->index = index; - switch(export->kind) { + switch (export->kind) { /* function index */ case EXPORT_KIND_FUNC: if (index >= module->function_count - + module->import_function_count) { + + module->import_function_count) { set_error_buf(error_buf, error_buf_size, "unknown function"); return false; @@ -2254,8 +2204,8 @@ load_export_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, break; /* table index */ case EXPORT_KIND_TABLE: - if (index >= module->table_count - + module->import_table_count) { + if (index + >= module->table_count + module->import_table_count) { set_error_buf(error_buf, error_buf_size, "unknown table"); return false; @@ -2263,8 +2213,8 @@ load_export_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, break; /* memory index */ case EXPORT_KIND_MEMORY: - if (index >= module->memory_count - + module->import_memory_count) { + if (index + >= module->memory_count + module->import_memory_count) { set_error_buf(error_buf, error_buf_size, "unknown memory"); return false; @@ -2272,8 +2222,8 @@ load_export_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, break; /* global index */ case EXPORT_KIND_GLOBAL: - if (index >= module->global_count - + module->import_global_count) { + if (index + >= module->global_count + module->import_global_count) { set_error_buf(error_buf, error_buf_size, "unknown global"); return false; @@ -2288,8 +2238,7 @@ load_export_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, } if (p != p_end) { - set_error_buf(error_buf, error_buf_size, - "section size mismatch"); + set_error_buf(error_buf, error_buf_size, "section size mismatch"); return false; } @@ -2300,14 +2249,14 @@ fail: } static bool -check_table_index(const WASMModule *module, uint32 table_index, - char *error_buf, uint32 error_buf_size) +check_table_index(const WASMModule *module, uint32 table_index, char *error_buf, + uint32 error_buf_size) { if ( #if WASM_ENABLE_REF_TYPES != 0 - !wasm_get_ref_types_flag() && + !wasm_get_ref_types_flag() && #endif - table_index != 0) { + table_index != 0) { set_error_buf(error_buf, error_buf_size, "zero byte expected"); return false; } @@ -2321,9 +2270,8 @@ check_table_index(const WASMModule *module, uint32 table_index, } static bool -load_table_index(const uint8 **p_buf, const uint8 *buf_end, - WASMModule *module, uint32 *p_table_index, - char *error_buf, uint32 error_buf_size) +load_table_index(const uint8 **p_buf, const uint8 *buf_end, WASMModule *module, + uint32 *p_table_index, char *error_buf, uint32 error_buf_size) { const uint8 *p = *p_buf, *p_end = buf_end; uint32 table_index; @@ -2342,9 +2290,8 @@ fail: #if WASM_ENABLE_REF_TYPES != 0 static bool -load_elem_type(const uint8 **p_buf, const uint8 *buf_end, - uint32 *p_elem_type, bool elemkind_zero, - char *error_buf, uint32 error_buf_size) +load_elem_type(const uint8 **p_buf, const uint8 *buf_end, uint32 *p_elem_type, + bool elemkind_zero, char *error_buf, uint32 error_buf_size) { const uint8 *p = *p_buf, *p_end = buf_end; uint8 elem_type; @@ -2372,8 +2319,7 @@ fail: static bool load_func_index_vec(const uint8 **p_buf, const uint8 *buf_end, WASMModule *module, WASMTableSeg *table_segment, - bool use_init_expr, - char *error_buf, uint32 error_buf_size) + bool use_init_expr, char *error_buf, uint32 error_buf_size) { const uint8 *p = *p_buf, *p_end = buf_end; uint32 function_count, function_index = 0, i; @@ -2383,8 +2329,8 @@ load_func_index_vec(const uint8 **p_buf, const uint8 *buf_end, table_segment->function_count = function_count; total_size = sizeof(uint32) * (uint64)function_count; if (total_size > 0 - && !(table_segment->func_indexes = (uint32 *) - loader_malloc(total_size, error_buf, error_buf_size))) { + && !(table_segment->func_indexes = (uint32 *)loader_malloc( + total_size, error_buf, error_buf_size))) { return false; } @@ -2428,8 +2374,9 @@ fail: } static bool -load_table_segment_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, - char *error_buf, uint32 error_buf_size) +load_table_segment_section(const uint8 *buf, const uint8 *buf_end, + WASMModule *module, char *error_buf, + uint32 error_buf_size) { const uint8 *p = buf, *p_end = buf_end; uint32 table_segment_count, i; @@ -2441,8 +2388,8 @@ load_table_segment_section(const uint8 *buf, const uint8 *buf_end, WASMModule *m if (table_segment_count) { module->table_seg_count = table_segment_count; total_size = sizeof(WASMTableSeg) * (uint64)table_segment_count; - if (!(module->table_segments = loader_malloc - (total_size, error_buf, error_buf_size))) { + if (!(module->table_segments = + loader_malloc(total_size, error_buf, error_buf_size))) { return false; } @@ -2472,13 +2419,13 @@ load_table_segment_section(const uint8 *buf, const uint8 *buf_end, WASMModule *m error_buf, error_buf_size)) return false; if (!load_init_expr( - &p, p_end, &table_segment->base_offset, - VALUE_TYPE_I32, error_buf, error_buf_size)) + &p, p_end, &table_segment->base_offset, + VALUE_TYPE_I32, error_buf, error_buf_size)) return false; if (!load_func_index_vec( - &p, p_end, module, table_segment, - table_segment->mode == 0 ? false : true, - error_buf, error_buf_size)) + &p, p_end, module, table_segment, + table_segment->mode == 0 ? false : true, + error_buf, error_buf_size)) return false; break; /* elemkind + passive/declarative */ @@ -2501,18 +2448,18 @@ load_table_segment_section(const uint8 *buf, const uint8 *buf_end, WASMModule *m error_buf, error_buf_size)) return false; if (!load_init_expr( - &p, p_end, &table_segment->base_offset, - VALUE_TYPE_I32, error_buf, error_buf_size)) + &p, p_end, &table_segment->base_offset, + VALUE_TYPE_I32, error_buf, error_buf_size)) return false; if (!load_elem_type( - &p, p_end, &table_segment->elem_type, - table_segment->mode == 2 ? true : false, - error_buf, error_buf_size)) + &p, p_end, &table_segment->elem_type, + table_segment->mode == 2 ? true : false, + error_buf, error_buf_size)) return false; if (!load_func_index_vec( - &p, p_end, module, table_segment, - table_segment->mode == 2 ? false : true, - error_buf, error_buf_size)) + &p, p_end, module, table_segment, + table_segment->mode == 2 ? false : true, + error_buf, error_buf_size)) return false; break; case 5: @@ -2522,8 +2469,8 @@ load_table_segment_section(const uint8 *buf, const uint8 *buf_end, WASMModule *m error_buf, error_buf_size)) return false; if (!load_func_index_vec(&p, p_end, module, - table_segment, true, - error_buf, error_buf_size)) + table_segment, true, error_buf, + error_buf_size)) return false; break; default: @@ -2566,8 +2513,8 @@ fail: static bool load_data_segment_section(const uint8 *buf, const uint8 *buf_end, - WASMModule *module, - char *error_buf, uint32 error_buf_size) + WASMModule *module, char *error_buf, + uint32 error_buf_size) { const uint8 *p = buf, *p_end = buf_end; uint32 data_seg_count, i, mem_index, data_seg_len; @@ -2592,9 +2539,9 @@ load_data_segment_section(const uint8 *buf, const uint8 *buf_end, if (data_seg_count) { module->data_seg_count = data_seg_count; - total_size = sizeof(WASMDataSeg*) * (uint64)data_seg_count; - if (!(module->data_segments = loader_malloc - (total_size, error_buf, error_buf_size))) { + total_size = sizeof(WASMDataSeg *) * (uint64)data_seg_count; + if (!(module->data_segments = + loader_malloc(total_size, error_buf, error_buf_size))) { return false; } @@ -2614,7 +2561,7 @@ load_data_segment_section(const uint8 *buf, const uint8 *buf_end, case 0x02: /* read following memory index */ read_leb_uint32(p, p_end, mem_index); -check_mem_index: + check_mem_index: if (mem_index >= module->import_memory_count + module->memory_count) { set_error_buf_v(error_buf, error_buf_size, @@ -2625,7 +2572,7 @@ check_mem_index: case 0x03: default: set_error_buf(error_buf, error_buf_size, "unknown memory"); - return false; + return false; break; } #else @@ -2646,8 +2593,8 @@ check_mem_index: read_leb_uint32(p, p_end, data_seg_len); - if (!(dataseg = module->data_segments[i] = loader_malloc - (sizeof(WASMDataSeg), error_buf, error_buf_size))) { + if (!(dataseg = module->data_segments[i] = loader_malloc( + sizeof(WASMDataSeg), error_buf, error_buf_size))) { return false; } @@ -2656,15 +2603,16 @@ check_mem_index: if (!is_passive) #endif { - bh_memcpy_s(&dataseg->base_offset, sizeof(InitializerExpression), - &init_expr, sizeof(InitializerExpression)); + bh_memcpy_s(&dataseg->base_offset, + sizeof(InitializerExpression), &init_expr, + sizeof(InitializerExpression)); dataseg->memory_index = mem_index; } dataseg->data_length = data_seg_len; CHECK_BUF(p, p_end, data_seg_len); - dataseg->data = (uint8*)p; + dataseg->data = (uint8 *)p; p += data_seg_len; } } @@ -2682,8 +2630,9 @@ fail: #if WASM_ENABLE_BULK_MEMORY != 0 static bool -load_datacount_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, - char *error_buf, uint32 error_buf_size) +load_datacount_section(const uint8 *buf, const uint8 *buf_end, + WASMModule *module, char *error_buf, + uint32 error_buf_size) { const uint8 *p = buf, *p_end = buf_end; uint32 data_seg_count1 = 0; @@ -2704,10 +2653,8 @@ fail: #endif static bool -load_code_section(const uint8 *buf, const uint8 *buf_end, - const uint8 *buf_func, - const uint8 *buf_func_end, - WASMModule *module, +load_code_section(const uint8 *buf, const uint8 *buf_end, const uint8 *buf_func, + const uint8 *buf_func_end, WASMModule *module, char *error_buf, uint32 error_buf_size) { const uint8 *p = buf, *p_end = buf_end; @@ -2752,9 +2699,8 @@ load_start_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, if (start_function < module->import_function_count) type = module->import_functions[start_function].u.function.func_type; else - type = - module->functions[start_function - module->import_function_count] - ->func_type; + type = module->functions[start_function - module->import_function_count] + ->func_type; if (type->param_count != 0 || type->result_count != 0) { set_error_buf(error_buf, error_buf_size, "invalid start function"); return false; @@ -2775,8 +2721,7 @@ fail: #if WASM_ENABLE_CUSTOM_NAME_SECTION != 0 static bool -handle_name_section(const uint8 *buf, const uint8 *buf_end, - WASMModule *module, +handle_name_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, char *error_buf, uint32 error_buf_size) { const uint8 *p = buf, *p_end = buf_end; @@ -2841,9 +2786,9 @@ handle_name_section(const uint8 *buf, const uint8 *buf_end, return false; } if (!(module->functions[func_index]->field_name = - const_str_list_insert(p, func_name_len, - module, error_buf, - error_buf_size))) { + const_str_list_insert(p, func_name_len, + module, error_buf, + error_buf_size))) { return false; } } @@ -2851,8 +2796,9 @@ handle_name_section(const uint8 *buf, const uint8 *buf_end, } } break; - case SUB_SECTION_TYPE_MODULE: /* TODO: Parse for module subsection */ - case SUB_SECTION_TYPE_LOCAL: /* TODO: Parse for local subsection */ + case SUB_SECTION_TYPE_MODULE: /* TODO: Parse for module subsection + */ + case SUB_SECTION_TYPE_LOCAL: /* TODO: Parse for local subsection */ default: p = p + subsection_size; break; @@ -2880,15 +2826,13 @@ load_user_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, read_leb_uint32(p, p_end, name_len); - if (name_len == 0 - || p + name_len > p_end) { + if (name_len == 0 || p + name_len > p_end) { set_error_buf(error_buf, error_buf_size, "unexpected end"); return false; } if (!check_utf8_str(p, name_len)) { - set_error_buf(error_buf, error_buf_size, - "invalid UTF-8 encoding"); + set_error_buf(error_buf, error_buf_size, "invalid UTF-8 encoding"); return false; } @@ -2905,9 +2849,9 @@ fail: } static bool -wasm_loader_prepare_bytecode(WASMModule *module, - WASMFunction *func, uint32 cur_func_idx, - char *error_buf, uint32 error_buf_size); +wasm_loader_prepare_bytecode(WASMModule *module, WASMFunction *func, + uint32 cur_func_idx, char *error_buf, + uint32 error_buf_size); #if WASM_ENABLE_FAST_INTERP != 0 && WASM_ENABLE_LABELS_AS_VALUES != 0 void ** @@ -2917,13 +2861,13 @@ static void **handle_table; #endif static bool -load_from_sections(WASMModule *module, WASMSection *sections, - char *error_buf, uint32 error_buf_size) +load_from_sections(WASMModule *module, WASMSection *sections, char *error_buf, + uint32 error_buf_size) { WASMExport *export; WASMSection *section = sections; const uint8 *buf, *buf_end, *buf_code = NULL, *buf_code_end = NULL, - *buf_func = NULL, *buf_func_end = NULL; + *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; uint32 aux_data_end = (uint32)-1, aux_heap_base = (uint32)-1; @@ -2956,18 +2900,18 @@ load_from_sections(WASMModule *module, WASMSection *sections, switch (section->section_type) { case SECTION_TYPE_USER: /* unsupported user section, ignore it. */ - if (!load_user_section(buf, buf_end, module, - error_buf, error_buf_size)) + if (!load_user_section(buf, buf_end, module, error_buf, + error_buf_size)) return false; break; case SECTION_TYPE_TYPE: - if (!load_type_section(buf, buf_end, module, - error_buf, error_buf_size)) + if (!load_type_section(buf, buf_end, module, error_buf, + error_buf_size)) return false; break; case SECTION_TYPE_IMPORT: - if (!load_import_section(buf, buf_end, module, - error_buf, error_buf_size)) + if (!load_import_section(buf, buf_end, module, error_buf, + error_buf_size)) return false; break; case SECTION_TYPE_FUNC: @@ -2976,33 +2920,33 @@ load_from_sections(WASMModule *module, WASMSection *sections, return false; break; case SECTION_TYPE_TABLE: - if (!load_table_section(buf, buf_end, module, - error_buf, error_buf_size)) + if (!load_table_section(buf, buf_end, module, error_buf, + error_buf_size)) return false; break; case SECTION_TYPE_MEMORY: - if (!load_memory_section(buf, buf_end, module, - error_buf, error_buf_size)) + if (!load_memory_section(buf, buf_end, module, error_buf, + error_buf_size)) return false; break; case SECTION_TYPE_GLOBAL: - if (!load_global_section(buf, buf_end, module, - error_buf, error_buf_size)) + if (!load_global_section(buf, buf_end, module, error_buf, + error_buf_size)) return false; break; case SECTION_TYPE_EXPORT: - if (!load_export_section(buf, buf_end, module, - error_buf, error_buf_size)) + if (!load_export_section(buf, buf_end, module, error_buf, + error_buf_size)) return false; break; case SECTION_TYPE_START: - if (!load_start_section(buf, buf_end, module, - error_buf, error_buf_size)) + if (!load_start_section(buf, buf_end, module, error_buf, + error_buf_size)) return false; break; case SECTION_TYPE_ELEM: - if (!load_table_segment_section(buf, buf_end, module, - error_buf, error_buf_size)) + if (!load_table_segment_section(buf, buf_end, module, error_buf, + error_buf_size)) return false; break; case SECTION_TYPE_CODE: @@ -3011,20 +2955,19 @@ load_from_sections(WASMModule *module, WASMSection *sections, return false; break; case SECTION_TYPE_DATA: - if (!load_data_segment_section(buf, buf_end, module, - error_buf, error_buf_size)) + if (!load_data_segment_section(buf, buf_end, module, error_buf, + error_buf_size)) return false; break; #if WASM_ENABLE_BULK_MEMORY != 0 case SECTION_TYPE_DATACOUNT: - if (!load_datacount_section(buf, buf_end, module, - error_buf, error_buf_size)) + if (!load_datacount_section(buf, buf_end, module, error_buf, + error_buf_size)) return false; break; #endif default: - set_error_buf(error_buf, error_buf_size, - "invalid section id"); + set_error_buf(error_buf, error_buf_size, "invalid section id"); return false; } @@ -3037,15 +2980,14 @@ load_from_sections(WASMModule *module, WASMSection *sections, /* Resolve auxiliary data/stack/heap info and reset memory info */ export = module->exports; - for (i = 0; i < module->export_count; i++, export++) { + for (i = 0; i < module->export_count; i++, export ++) { if (export->kind == EXPORT_KIND_GLOBAL) { if (!strcmp(export->name, "__heap_base")) { global_index = export->index - module->import_global_count; global = module->globals + global_index; - if (global->type == VALUE_TYPE_I32 - && !global->is_mutable - && global->init_expr.init_expr_type == - INIT_EXPR_TYPE_I32_CONST) { + if (global->type == VALUE_TYPE_I32 && !global->is_mutable + && global->init_expr.init_expr_type + == INIT_EXPR_TYPE_I32_CONST) { aux_heap_base_global = global; aux_heap_base = global->init_expr.u.i32; aux_heap_base_global_index = export->index; @@ -3056,10 +2998,9 @@ load_from_sections(WASMModule *module, WASMSection *sections, else if (!strcmp(export->name, "__data_end")) { global_index = export->index - module->import_global_count; global = module->globals + global_index; - if (global->type == VALUE_TYPE_I32 - && !global->is_mutable - && global->init_expr.init_expr_type == - INIT_EXPR_TYPE_I32_CONST) { + if (global->type == VALUE_TYPE_I32 && !global->is_mutable + && global->init_expr.init_expr_type + == INIT_EXPR_TYPE_I32_CONST) { aux_data_end_global = global; aux_data_end = global->init_expr.u.i32; aux_data_end_global_index = export->index; @@ -3100,17 +3041,18 @@ load_from_sections(WASMModule *module, WASMSection *sections, if (global->is_mutable /* heap_base and data_end is not mutable */ && global->type == VALUE_TYPE_I32 - && global->init_expr.init_expr_type == - INIT_EXPR_TYPE_I32_CONST + && global->init_expr.init_expr_type + == INIT_EXPR_TYPE_I32_CONST && (uint32)global->init_expr.u.i32 <= aux_heap_base) { aux_stack_top_global = global; aux_stack_top = (uint32)global->init_expr.u.i32; module->aux_stack_top_global_index = - module->import_global_count + global_index; + module->import_global_count + global_index; module->aux_stack_bottom = aux_stack_top; - module->aux_stack_size = aux_stack_top > aux_data_end - ? aux_stack_top - aux_data_end - : aux_stack_top; + module->aux_stack_size = + aux_stack_top > aux_data_end + ? aux_stack_top - aux_data_end + : aux_stack_top; LOG_VERBOSE("Found aux stack top global, value: %d, " "global index: %d, stack size: %d", aux_stack_top, global_index, @@ -3129,14 +3071,13 @@ load_from_sections(WASMModule *module, WASMSection *sections, /* Resolve malloc/free function exported by wasm module */ export = module->exports; - for (i = 0; i < module->export_count; i++, export++) { + for (i = 0; i < module->export_count; i++, export ++) { if (export->kind == EXPORT_KIND_FUNC) { if (!strcmp(export->name, "malloc") && export->index >= module->import_function_count) { func_index = export->index - module->import_function_count; func_type = module->functions[func_index]->func_type; - if (func_type->param_count == 1 - && func_type->result_count == 1 + if (func_type->param_count == 1 && func_type->result_count == 1 && func_type->types[0] == VALUE_TYPE_I32 && func_type->types[1] == VALUE_TYPE_I32) { bh_assert(module->malloc_function == (uint32)-1); @@ -3150,8 +3091,7 @@ load_from_sections(WASMModule *module, WASMSection *sections, /* __new && __pin for AssemblyScript */ func_index = export->index - module->import_function_count; func_type = module->functions[func_index]->func_type; - if (func_type->param_count == 2 - && func_type->result_count == 1 + if (func_type->param_count == 2 && func_type->result_count == 1 && func_type->types[0] == VALUE_TYPE_I32 && func_type->types[1] == VALUE_TYPE_I32 && func_type->types[2] == VALUE_TYPE_I32) { @@ -3173,19 +3113,20 @@ load_from_sections(WASMModule *module, WASMSection *sections, && (export_tmp->index >= module->import_function_count)) { func_index = export_tmp->index - - module->import_function_count; + - module->import_function_count; func_type = - module->functions[func_index]->func_type; + module->functions[func_index]->func_type; if (func_type->param_count == 1 && func_type->result_count == 1 && func_type->types[0] == VALUE_TYPE_I32 && func_type->types[1] == VALUE_TYPE_I32) { - bh_assert( - module->retain_function == (uint32)-1); + bh_assert(module->retain_function + == (uint32)-1); module->retain_function = export_tmp->index; - LOG_VERBOSE( - "Found retain function, name: %s, index: %u", - export_tmp->name, export_tmp->index); + LOG_VERBOSE("Found retain function, name: %s, " + "index: %u", + export_tmp->name, + export_tmp->index); break; } } @@ -3203,8 +3144,7 @@ load_from_sections(WASMModule *module, WASMSection *sections, && export->index >= module->import_function_count) { func_index = export->index - module->import_function_count; func_type = module->functions[func_index]->func_type; - if (func_type->param_count == 1 - && func_type->result_count == 0 + if (func_type->param_count == 1 && func_type->result_count == 0 && func_type->types[0] == VALUE_TYPE_I32) { bh_assert(module->free_function == (uint32)-1); module->free_function = export->index; @@ -3221,8 +3161,8 @@ load_from_sections(WASMModule *module, WASMSection *sections, for (i = 0; i < module->function_count; i++) { WASMFunction *func = module->functions[i]; - if (!wasm_loader_prepare_bytecode(module, func, i, - error_buf, error_buf_size)) { + if (!wasm_loader_prepare_bytecode(module, func, i, error_buf, + error_buf_size)) { return false; } } @@ -3231,16 +3171,15 @@ load_from_sections(WASMModule *module, WASMSection *sections, WASMMemoryImport *memory_import; WASMMemory *memory; - if (aux_data_end_global - && aux_heap_base_global + if (aux_data_end_global && aux_heap_base_global && aux_stack_top_global) { uint64 init_memory_size; uint32 shrunk_memory_size = align_uint(aux_heap_base, 8); if (module->import_memory_count) { memory_import = &module->import_memories[0].u.memory; - init_memory_size = (uint64)memory_import->num_bytes_per_page * - memory_import->init_page_count; + init_memory_size = (uint64)memory_import->num_bytes_per_page + * 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; @@ -3251,8 +3190,8 @@ load_from_sections(WASMModule *module, WASMSection *sections, } if (module->memory_count) { memory = &module->memories[0]; - init_memory_size = (uint64)memory->num_bytes_per_page * - memory->init_page_count; + init_memory_size = (uint64)memory->num_bytes_per_page + * 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; @@ -3281,16 +3220,16 @@ load_from_sections(WASMModule *module, WASMSection *sections, } #if WASM_ENABLE_MEMORY_TRACING != 0 - wasm_runtime_dump_module_mem_consumption((WASMModuleCommon*)module); + wasm_runtime_dump_module_mem_consumption((WASMModuleCommon *)module); #endif return true; } -static WASMModule* +static WASMModule * create_module(char *error_buf, uint32 error_buf_size) { - WASMModule *module = loader_malloc(sizeof(WASMModule), - error_buf, error_buf_size); + WASMModule *module = + loader_malloc(sizeof(WASMModule), error_buf, error_buf_size); if (!module) { return NULL; @@ -3312,9 +3251,10 @@ create_module(char *error_buf, uint32 error_buf_size) #if WASM_ENABLE_DEBUG_INTERP != 0 static void -record_fast_op(WASMModule *module, uint8 * pos, uint8 orig_op) +record_fast_op(WASMModule *module, uint8 *pos, uint8 orig_op) { - WASMFastOPCodeNode *fast_op = wasm_runtime_malloc(sizeof(WASMFastOPCodeNode)); + WASMFastOPCodeNode *fast_op = + wasm_runtime_malloc(sizeof(WASMFastOPCodeNode)); if (fast_op) { fast_op->offset = pos - module->load_addr; fast_op->orig_op = orig_op; @@ -3324,8 +3264,8 @@ record_fast_op(WASMModule *module, uint8 * pos, uint8 orig_op) #endif WASMModule * -wasm_loader_load_from_sections(WASMSection *section_list, - char *error_buf, uint32 error_buf_size) +wasm_loader_load_from_sections(WASMSection *section_list, char *error_buf, + uint32 error_buf_size) { WASMModule *module = create_module(error_buf, error_buf_size); if (!module) @@ -3351,6 +3291,7 @@ destroy_sections(WASMSection *section_list) } } +/* clang-format off */ static uint8 section_ids[] = { SECTION_TYPE_USER, SECTION_TYPE_TYPE, @@ -3368,6 +3309,7 @@ static uint8 section_ids[] = { SECTION_TYPE_CODE, SECTION_TYPE_DATA }; +/* clang-format on */ static uint8 get_section_index(uint8 section_type) @@ -3383,12 +3325,11 @@ get_section_index(uint8 section_type) } static bool -create_sections(const uint8 *buf, uint32 size, - WASMSection **p_section_list, +create_sections(const uint8 *buf, uint32 size, WASMSection **p_section_list, char *error_buf, uint32 error_buf_size) { WASMSection *section_list_end = NULL, *section; - const uint8 *p = buf, *p_end = buf + size/*, *section_body*/; + const uint8 *p = buf, *p_end = buf + size /*, *section_body*/; uint8 section_type, section_index, last_section_index = (uint8)-1; uint32 section_size; @@ -3416,13 +3357,13 @@ create_sections(const uint8 *buf, uint32 size, read_leb_uint32(p, p_end, section_size); CHECK_BUF1(p, p_end, section_size); - if (!(section = loader_malloc(sizeof(WASMSection), - error_buf, error_buf_size))) { + if (!(section = loader_malloc(sizeof(WASMSection), error_buf, + error_buf_size))) { return false; } section->section_type = section_type; - section->section_body = (uint8*)p; + section->section_body = (uint8 *)p; section->section_body_size = section_size; if (!section_list_end) @@ -3435,8 +3376,7 @@ create_sections(const uint8 *buf, uint32 size, p += section_size; } else { - set_error_buf(error_buf, error_buf_size, - "invalid section id"); + set_error_buf(error_buf, error_buf_size, "invalid section id"); return false; } } @@ -3447,7 +3387,7 @@ fail: } static void -exchange32(uint8* p_data) +exchange32(uint8 *p_data) { uint8 value = *p_data; *p_data = *(p_data + 3); @@ -3466,8 +3406,8 @@ static union { #define is_little_endian() (__ue.b == 1) static bool -load(const uint8 *buf, uint32 size, WASMModule *module, - char *error_buf, uint32 error_buf_size) +load(const uint8 *buf, uint32 size, WASMModule *module, char *error_buf, + uint32 error_buf_size) { const uint8 *buf_end = buf + size; const uint8 *p = buf, *p_end = buf_end; @@ -3477,27 +3417,26 @@ load(const uint8 *buf, uint32 size, WASMModule *module, CHECK_BUF1(p, p_end, sizeof(uint32)); magic_number = read_uint32(p); if (!is_little_endian()) - exchange32((uint8*)&magic_number); + exchange32((uint8 *)&magic_number); if (magic_number != WASM_MAGIC_NUMBER) { - set_error_buf(error_buf, error_buf_size, - "magic header not detected"); + set_error_buf(error_buf, error_buf_size, "magic header not detected"); return false; } CHECK_BUF1(p, p_end, sizeof(uint32)); version = read_uint32(p); if (!is_little_endian()) - exchange32((uint8*)&version); + exchange32((uint8 *)&version); if (version != WASM_CURRENT_VERSION) { - set_error_buf(error_buf, error_buf_size, - "unknown binary version"); + set_error_buf(error_buf, error_buf_size, "unknown binary version"); return false; } if (!create_sections(buf, size, §ion_list, error_buf, error_buf_size) - || !load_from_sections(module, section_list, error_buf, error_buf_size)) { + || !load_from_sections(module, section_list, error_buf, + error_buf_size)) { destroy_sections(section_list); return false; } @@ -3508,8 +3447,9 @@ fail: return false; } -WASMModule* -wasm_loader_load(const uint8 *buf, uint32 size, char *error_buf, uint32 error_buf_size) +WASMModule * +wasm_loader_load(const uint8 *buf, uint32 size, char *error_buf, + uint32 error_buf_size) { WASMModule *module = create_module(error_buf, error_buf_size); if (!module) { @@ -3610,7 +3550,7 @@ wasm_loader_unload(WASMModule *module) /* just release the sub module list */ if (module->import_module_list) { WASMRegisteredModule *node = - bh_list_first_elem(module->import_module_list); + bh_list_first_elem(module->import_module_list); while (node) { WASMRegisteredModule *next = bh_list_elem_next(node); bh_list_remove(module->import_module_list, node); @@ -3631,8 +3571,8 @@ wasm_loader_unload(WASMModule *module) #if WASM_ENABLE_DEBUG_INTERP != 0 WASMFastOPCodeNode *fast_opcode = bh_list_first_elem(&module->fast_opcode_list); - while(fast_opcode) { - WASMFastOPCodeNode * next = bh_list_elem_next(fast_opcode); + while (fast_opcode) { + WASMFastOPCodeNode *next = bh_list_elem_next(fast_opcode); wasm_runtime_free(fast_opcode); fast_opcode = next; } @@ -3641,12 +3581,9 @@ wasm_loader_unload(WASMModule *module) } bool -wasm_loader_find_block_addr(WASMExecEnv *exec_env, - BlockAddr *block_addr_cache, - const uint8 *start_addr, - const uint8 *code_end_addr, - uint8 label_type, - uint8 **p_else_addr, +wasm_loader_find_block_addr(WASMExecEnv *exec_env, BlockAddr *block_addr_cache, + const uint8 *start_addr, const uint8 *code_end_addr, + uint8 label_type, uint8 **p_else_addr, uint8 **p_end_addr) { const uint8 *p = start_addr, *p_end = code_end_addr; @@ -3655,7 +3592,7 @@ wasm_loader_find_block_addr(WASMExecEnv *exec_env, uint32 block_nested_depth = 1, count, i, j, t; uint32 error_buf_size = sizeof(error_buf); uint8 opcode, u8; - BlockAddr block_stack[16] = {{0}}, *block; + BlockAddr block_stack[16] = { { 0 } }, *block; i = ((uintptr_t)start_addr) & (uintptr_t)(BLOCK_ADDR_CACHE_SIZE - 1); block = block_addr_cache + BLOCK_ADDR_CONFLICT_SIZE * i; @@ -3675,7 +3612,7 @@ wasm_loader_find_block_addr(WASMExecEnv *exec_env, while (p < code_end_addr) { opcode = *p++; #if WASM_ENABLE_DEBUG_INTERP != 0 -op_break_retry: + op_break_retry: #endif switch (opcode) { case WASM_OP_UNREACHABLE: @@ -3687,7 +3624,8 @@ op_break_retry: case WASM_OP_IF: /* block result type: 0x40/0x7F/0x7E/0x7D/0x7C */ u8 = read_uint8(p); - if (block_nested_depth < sizeof(block_stack)/sizeof(BlockAddr)) { + if (block_nested_depth + < sizeof(block_stack) / sizeof(BlockAddr)) { block_stack[block_nested_depth].start_addr = p; block_stack[block_nested_depth].else_addr = NULL; } @@ -3699,7 +3637,8 @@ op_break_retry: case EXT_OP_IF: /* block type */ skip_leb_uint32(p, p_end); - if (block_nested_depth < sizeof(block_stack)/sizeof(BlockAddr)) { + if (block_nested_depth + < sizeof(block_stack) / sizeof(BlockAddr)) { block_stack[block_nested_depth].start_addr = p; block_stack[block_nested_depth].else_addr = NULL; } @@ -3708,33 +3647,37 @@ op_break_retry: case WASM_OP_ELSE: if (label_type == LABEL_TYPE_IF && block_nested_depth == 1) - else_addr = (uint8*)(p - 1); - if (block_nested_depth - 1 < sizeof(block_stack)/sizeof(BlockAddr)) - block_stack[block_nested_depth - 1].else_addr = (uint8*)(p - 1); + else_addr = (uint8 *)(p - 1); + if (block_nested_depth - 1 + < sizeof(block_stack) / sizeof(BlockAddr)) + block_stack[block_nested_depth - 1].else_addr = + (uint8 *)(p - 1); break; case WASM_OP_END: if (block_nested_depth == 1) { if (label_type == LABEL_TYPE_IF) *p_else_addr = else_addr; - *p_end_addr = (uint8*)(p - 1); + *p_end_addr = (uint8 *)(p - 1); - block_stack[0].end_addr = (uint8*)(p - 1); - for (t = 0; t < sizeof(block_stack)/sizeof(BlockAddr); t++) { + block_stack[0].end_addr = (uint8 *)(p - 1); + for (t = 0; t < sizeof(block_stack) / sizeof(BlockAddr); + t++) { start_addr = block_stack[t].start_addr; if (start_addr) { i = ((uintptr_t)start_addr) & (uintptr_t)(BLOCK_ADDR_CACHE_SIZE - 1); - block = block_addr_cache + BLOCK_ADDR_CONFLICT_SIZE * i; + block = + block_addr_cache + BLOCK_ADDR_CONFLICT_SIZE * i; for (j = 0; j < BLOCK_ADDR_CONFLICT_SIZE; j++) if (!block[j].start_addr) break; if (j == BLOCK_ADDR_CONFLICT_SIZE) { - memmove(block + 1, block, (BLOCK_ADDR_CONFLICT_SIZE - 1) * - sizeof(BlockAddr)); + memmove(block + 1, block, + (BLOCK_ADDR_CONFLICT_SIZE - 1) + * sizeof(BlockAddr)); j = 0; - } block[j].start_addr = block_stack[t].start_addr; block[j].else_addr = block_stack[t].else_addr; @@ -3747,8 +3690,10 @@ op_break_retry: } else { block_nested_depth--; - if (block_nested_depth < sizeof(block_stack)/sizeof(BlockAddr)) - block_stack[block_nested_depth].end_addr = (uint8*)(p - 1); + if (block_nested_depth + < sizeof(block_stack) / sizeof(BlockAddr)) + block_stack[block_nested_depth].end_addr = + (uint8 *)(p - 1); } break; @@ -3759,7 +3704,7 @@ op_break_retry: case WASM_OP_BR_TABLE: read_leb_uint32(p, p_end, count); /* lable num */ - for (i = 0; i <= count; i++) /* lableidxs */ + for (i = 0; i <= count; i++) /* lableidxs */ skip_leb_uint32(p, p_end); break; @@ -4091,9 +4036,11 @@ op_break_retry: #if (WASM_ENABLE_WAMR_COMPILER != 0) || (WASM_ENABLE_JIT != 0) case WASM_OP_SIMD_PREFIX: { - /* TODO: shall we ceate a table to be friendly to branch prediction */ + /* TODO: shall we ceate a table to be friendly to branch + * prediction */ opcode = read_uint8(p); - /* follow the order of enum WASMSimdEXTOpcode in wasm_opcode.h */ + /* follow the order of enum WASMSimdEXTOpcode in wasm_opcode.h + */ switch (opcode) { case SIMD_v128_load: case SIMD_v128_load8x8_s: @@ -4167,8 +4114,8 @@ op_break_retry: default: /* * since latest SIMD specific used almost every value - * from 0x00 to 0xff, the default branch will present all - * opcodes without imm + * from 0x00 to 0xff, the default branch will present + * all opcodes without imm * https://github.com/WebAssembly/simd/blob/main/proposals/simd/NewOpcodes.md */ break; @@ -4195,19 +4142,20 @@ op_break_retry: } #endif #if WASM_ENABLE_DEBUG_INTERP != 0 - case DEBUG_OP_BREAK: { + case DEBUG_OP_BREAK: + { WASMDebugInstance *debug_instance = - wasm_exec_env_get_instance(exec_env); + wasm_exec_env_get_instance(exec_env); char orignal_opcode[1]; uint64 size = 1; WASMModuleInstance *module_inst = - (WASMModuleInstance *)exec_env->module_inst; + (WASMModuleInstance *)exec_env->module_inst; uint64 offset = (p - 1) >= module_inst->module->load_addr - ? (p - 1) - module_inst->module->load_addr - : ~0; + ? (p - 1) - module_inst->module->load_addr + : ~0; if (debug_instance) { - if (wasm_debug_instance_get_obj_mem( - debug_instance, offset, orignal_opcode, &size) + if (wasm_debug_instance_get_obj_mem(debug_instance, offset, + orignal_opcode, &size) && size == 1) { LOG_VERBOSE("WASM loader find OP_BREAK , recover it " "with %02x: ", @@ -4231,9 +4179,9 @@ fail: return false; } -#define REF_ANY VALUE_TYPE_ANY -#define REF_I32 VALUE_TYPE_I32 -#define REF_F32 VALUE_TYPE_F32 +#define REF_ANY VALUE_TYPE_ANY +#define REF_I32 VALUE_TYPE_I32 +#define REF_F32 VALUE_TYPE_F32 #define REF_I64_1 VALUE_TYPE_I64 #define REF_I64_2 VALUE_TYPE_I64 #define REF_F64_1 VALUE_TYPE_F64 @@ -4242,19 +4190,19 @@ fail: #define REF_V128_2 VALUE_TYPE_V128 #define REF_V128_3 VALUE_TYPE_V128 #define REF_V128_4 VALUE_TYPE_V128 -#define REF_FUNCREF VALUE_TYPE_FUNCREF +#define REF_FUNCREF VALUE_TYPE_FUNCREF #define REF_EXTERNREF VALUE_TYPE_EXTERNREF #if WASM_ENABLE_FAST_INTERP != 0 #if WASM_DEBUG_PREPROCESSOR != 0 -#define LOG_OP(...) os_printf(__VA_ARGS__) +#define LOG_OP(...) os_printf(__VA_ARGS__) #else -#define LOG_OP(...) (void)0 +#define LOG_OP(...) (void)0 #endif #define PATCH_ELSE 0 -#define PATCH_END 1 +#define PATCH_END 1 typedef struct BranchBlockPatch { struct BranchBlockPatch *next; uint8 patch_type; @@ -4335,14 +4283,13 @@ typedef struct Const { uint8 value_type; } Const; -static void* -memory_realloc(void *mem_old, uint32 size_old, uint32 size_new, - char *error_buf, uint32 error_buf_size) +static void * +memory_realloc(void *mem_old, uint32 size_old, uint32 size_new, char *error_buf, + uint32 error_buf_size) { uint8 *mem_new; bh_assert(size_new > size_old); - if ((mem_new = loader_malloc - (size_new, error_buf, error_buf_size))) { + if ((mem_new = loader_malloc(size_new, error_buf, error_buf_size))) { bh_memcpy_s(mem_new, size_new, mem_old, size_old); memset(mem_new + size_old, 0, size_new - size_old); wasm_runtime_free(mem_old); @@ -4350,47 +4297,51 @@ memory_realloc(void *mem_old, uint32 size_old, uint32 size_new, return mem_new; } -#define MEM_REALLOC(mem, size_old, size_new) do { \ - void *mem_new = memory_realloc(mem, size_old, size_new, \ - error_buf, error_buf_size); \ - if (!mem_new) \ - goto fail; \ - mem = mem_new; \ - } while (0) +#define MEM_REALLOC(mem, size_old, size_new) \ + do { \ + void *mem_new = memory_realloc(mem, size_old, size_new, error_buf, \ + error_buf_size); \ + if (!mem_new) \ + goto fail; \ + mem = mem_new; \ + } while (0) -#define CHECK_CSP_PUSH() do { \ - if (ctx->frame_csp >= ctx->frame_csp_boundary) { \ - MEM_REALLOC(ctx->frame_csp_bottom, ctx->frame_csp_size, \ - (uint32)(ctx->frame_csp_size \ - + 8 * sizeof(BranchBlock))); \ - ctx->frame_csp_size += (uint32)(8 * sizeof(BranchBlock)); \ - ctx->frame_csp_boundary = ctx->frame_csp_bottom + \ - ctx->frame_csp_size / sizeof(BranchBlock); \ - ctx->frame_csp = ctx->frame_csp_bottom + ctx->csp_num; \ - } \ - } while (0) +#define CHECK_CSP_PUSH() \ + do { \ + if (ctx->frame_csp >= ctx->frame_csp_boundary) { \ + MEM_REALLOC( \ + ctx->frame_csp_bottom, ctx->frame_csp_size, \ + (uint32)(ctx->frame_csp_size + 8 * sizeof(BranchBlock))); \ + ctx->frame_csp_size += (uint32)(8 * sizeof(BranchBlock)); \ + ctx->frame_csp_boundary = \ + ctx->frame_csp_bottom \ + + ctx->frame_csp_size / sizeof(BranchBlock); \ + ctx->frame_csp = ctx->frame_csp_bottom + ctx->csp_num; \ + } \ + } while (0) -#define CHECK_CSP_POP() do { \ - if (ctx->csp_num < 1) { \ - set_error_buf(error_buf, error_buf_size, \ - "type mismatch: " \ - "expect data but block stack was empty"); \ - goto fail; \ - } \ - } while (0) +#define CHECK_CSP_POP() \ + do { \ + if (ctx->csp_num < 1) { \ + set_error_buf(error_buf, error_buf_size, \ + "type mismatch: " \ + "expect data but block stack was empty"); \ + goto fail; \ + } \ + } while (0) #if WASM_ENABLE_FAST_INTERP != 0 static bool -check_offset_push(WASMLoaderContext *ctx, - char *error_buf, uint32 error_buf_size) +check_offset_push(WASMLoaderContext *ctx, char *error_buf, + uint32 error_buf_size) { uint32 cell_num = (uint32)(ctx->frame_offset - ctx->frame_offset_bottom); if (ctx->frame_offset >= ctx->frame_offset_boundary) { MEM_REALLOC(ctx->frame_offset_bottom, ctx->frame_offset_size, ctx->frame_offset_size + 16); ctx->frame_offset_size += 16; - ctx->frame_offset_boundary = ctx->frame_offset_bottom + - ctx->frame_offset_size / sizeof(int16); + ctx->frame_offset_boundary = + ctx->frame_offset_bottom + ctx->frame_offset_size / sizeof(int16); ctx->frame_offset = ctx->frame_offset_bottom + cell_num; } return true; @@ -4426,15 +4377,14 @@ free_all_label_patch_lists(BranchBlock *frame_csp, uint32 csp_num) for (uint32 i = 0; i < csp_num; i++) { free_label_patch_list(tmp_csp); - tmp_csp ++; + tmp_csp++; } } #endif /* end of WASM_ENABLE_FAST_INTERP */ static bool -check_stack_push(WASMLoaderContext *ctx, - char *error_buf, uint32 error_buf_size) +check_stack_push(WASMLoaderContext *ctx, char *error_buf, uint32 error_buf_size) { if (ctx->frame_ref >= ctx->frame_ref_boundary) { MEM_REALLOC(ctx->frame_ref_bottom, ctx->frame_ref_size, @@ -4448,7 +4398,6 @@ fail: return false; } - static bool check_stack_top_values(uint8 *frame_ref, int32 stack_cell_num, uint8 type, char *error_buf, uint32 error_buf_size) @@ -4460,7 +4409,7 @@ check_stack_top_values(uint8 *frame_ref, int32 stack_cell_num, uint8 type, || (type == VALUE_TYPE_V128 && stack_cell_num < 4) #endif #endif - ) { + ) { set_error_buf(error_buf, error_buf_size, "type mismatch: expect data but stack was empty"); return false; @@ -4472,16 +4421,14 @@ check_stack_top_values(uint8 *frame_ref, int32 stack_cell_num, uint8 type, #if WASM_ENABLE_SIMD != 0 #if (WASM_ENABLE_WAMR_COMPILER != 0) || (WASM_ENABLE_JIT != 0) || (type == VALUE_TYPE_V128 - && (*(frame_ref - 4) != REF_V128_1 - || *(frame_ref - 3) != REF_V128_2 + && (*(frame_ref - 4) != REF_V128_1 || *(frame_ref - 3) != REF_V128_2 || *(frame_ref - 2) != REF_V128_3 || *(frame_ref - 1) != REF_V128_4)) #endif #endif - ) { + ) { set_error_buf_v(error_buf, error_buf_size, "%s%s%s", - "type mismatch: expect ", - type2str(type), + "type mismatch: expect ", type2str(type), " but got other"); return false; } @@ -4490,20 +4437,19 @@ check_stack_top_values(uint8 *frame_ref, int32 stack_cell_num, uint8 type, } static bool -check_stack_pop(WASMLoaderContext *ctx, uint8 type, - char *error_buf, uint32 error_buf_size) +check_stack_pop(WASMLoaderContext *ctx, uint8 type, char *error_buf, + uint32 error_buf_size) { - int32 block_stack_cell_num = (int32) - (ctx->stack_cell_num - (ctx->frame_csp - 1)->stack_cell_num); + int32 block_stack_cell_num = + (int32)(ctx->stack_cell_num - (ctx->frame_csp - 1)->stack_cell_num); - if (block_stack_cell_num > 0 - && *(ctx->frame_ref - 1) == VALUE_TYPE_ANY) { + if (block_stack_cell_num > 0 && *(ctx->frame_ref - 1) == VALUE_TYPE_ANY) { /* the stack top is a value of any type, return success */ return true; } - if (!check_stack_top_values(ctx->frame_ref, block_stack_cell_num, - type, error_buf, error_buf_size)) + if (!check_stack_top_values(ctx->frame_ref, block_stack_cell_num, type, + error_buf, error_buf_size)) return false; return true; @@ -4531,7 +4477,7 @@ wasm_loader_ctx_destroy(WASMLoaderContext *ctx) } } -static WASMLoaderContext* +static WASMLoaderContext * wasm_loader_ctx_init(WASMFunction *func) { WASMLoaderContext *loader_ctx = @@ -4542,15 +4488,15 @@ wasm_loader_ctx_init(WASMFunction *func) loader_ctx->frame_ref_size = 32; if (!(loader_ctx->frame_ref_bottom = loader_ctx->frame_ref = - wasm_runtime_malloc(loader_ctx->frame_ref_size))) + wasm_runtime_malloc(loader_ctx->frame_ref_size))) goto fail; memset(loader_ctx->frame_ref_bottom, 0, loader_ctx->frame_ref_size); - loader_ctx->frame_ref_boundary = loader_ctx->frame_ref_bottom + - loader_ctx->frame_ref_size; + loader_ctx->frame_ref_boundary = + loader_ctx->frame_ref_bottom + loader_ctx->frame_ref_size; loader_ctx->frame_csp_size = sizeof(BranchBlock) * 8; if (!(loader_ctx->frame_csp_bottom = loader_ctx->frame_csp = - wasm_runtime_malloc(loader_ctx->frame_csp_size))) + wasm_runtime_malloc(loader_ctx->frame_csp_size))) goto fail; memset(loader_ctx->frame_csp_bottom, 0, loader_ctx->frame_csp_size); loader_ctx->frame_csp_boundary = loader_ctx->frame_csp_bottom + 8; @@ -4558,21 +4504,21 @@ wasm_loader_ctx_init(WASMFunction *func) #if WASM_ENABLE_FAST_INTERP != 0 loader_ctx->frame_offset_size = sizeof(int16) * 32; if (!(loader_ctx->frame_offset_bottom = loader_ctx->frame_offset = - wasm_runtime_malloc(loader_ctx->frame_offset_size))) + wasm_runtime_malloc(loader_ctx->frame_offset_size))) goto fail; - memset(loader_ctx->frame_offset_bottom, 0, - loader_ctx->frame_offset_size); + memset(loader_ctx->frame_offset_bottom, 0, loader_ctx->frame_offset_size); loader_ctx->frame_offset_boundary = loader_ctx->frame_offset_bottom + 32; loader_ctx->num_const = 0; loader_ctx->const_buf_size = sizeof(Const) * 8; - if (!(loader_ctx->const_buf = wasm_runtime_malloc(loader_ctx->const_buf_size))) + if (!(loader_ctx->const_buf = + wasm_runtime_malloc(loader_ctx->const_buf_size))) goto fail; memset(loader_ctx->const_buf, 0, loader_ctx->const_buf_size); loader_ctx->start_dynamic_offset = loader_ctx->dynamic_offset = - loader_ctx->max_dynamic_offset = func->param_cell_num + - func->local_cell_num; + loader_ctx->max_dynamic_offset = + func->param_cell_num + func->local_cell_num; #endif return loader_ctx; @@ -4582,8 +4528,8 @@ fail: } static bool -wasm_loader_push_frame_ref(WASMLoaderContext *ctx, uint8 type, - char *error_buf, uint32 error_buf_size) +wasm_loader_push_frame_ref(WASMLoaderContext *ctx, uint8 type, char *error_buf, + uint32 error_buf_size) { if (type == VALUE_TYPE_VOID) return true; @@ -4624,12 +4570,12 @@ check_stack_and_return: } static bool -wasm_loader_pop_frame_ref(WASMLoaderContext *ctx, uint8 type, - char *error_buf, uint32 error_buf_size) +wasm_loader_pop_frame_ref(WASMLoaderContext *ctx, uint8 type, char *error_buf, + uint32 error_buf_size) { BranchBlock *cur_block = ctx->frame_csp - 1; - int32 available_stack_cell = (int32) - (ctx->stack_cell_num - cur_block->stack_cell_num); + int32 available_stack_cell = + (int32)(ctx->stack_cell_num - cur_block->stack_cell_num); /* Directly return success if current block is in stack * polymorphic state while stack is empty. */ @@ -4664,11 +4610,12 @@ wasm_loader_pop_frame_ref(WASMLoaderContext *ctx, uint8 type, static bool wasm_loader_push_pop_frame_ref(WASMLoaderContext *ctx, uint8 pop_cnt, - uint8 type_push, uint8 type_pop, - char *error_buf, uint32 error_buf_size) + uint8 type_push, uint8 type_pop, char *error_buf, + uint32 error_buf_size) { for (int i = 0; i < pop_cnt; i++) { - if (!wasm_loader_pop_frame_ref(ctx, type_pop, error_buf, error_buf_size)) + if (!wasm_loader_pop_frame_ref(ctx, type_pop, error_buf, + error_buf_size)) return false; } if (!wasm_loader_push_frame_ref(ctx, type_push, error_buf, error_buf_size)) @@ -4678,7 +4625,7 @@ wasm_loader_push_pop_frame_ref(WASMLoaderContext *ctx, uint8 pop_cnt, static bool wasm_loader_push_frame_csp(WASMLoaderContext *ctx, uint8 label_type, - BlockType block_type, uint8* start_addr, + BlockType block_type, uint8 *start_addr, char *error_buf, uint32 error_buf_size) { CHECK_CSP_PUSH(); @@ -4701,8 +4648,8 @@ fail: } static bool -wasm_loader_pop_frame_csp(WASMLoaderContext *ctx, - char *error_buf, uint32 error_buf_size) +wasm_loader_pop_frame_csp(WASMLoaderContext *ctx, char *error_buf, + uint32 error_buf_size) { CHECK_CSP_POP(); #if WASM_ENABLE_FAST_INTERP != 0 @@ -4721,124 +4668,132 @@ fail: #if WASM_ENABLE_LABELS_AS_VALUES != 0 #if WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS != 0 -#define emit_label(opcode) do { \ - wasm_loader_emit_ptr(loader_ctx, handle_table[opcode]); \ - LOG_OP("\nemit_op [%02x]\t", opcode); \ - } while (0) -#define skip_label() do { \ - wasm_loader_emit_backspace(loader_ctx, sizeof(void *)); \ - LOG_OP("\ndelete last op\n"); \ - } while (0) +#define emit_label(opcode) \ + do { \ + wasm_loader_emit_ptr(loader_ctx, handle_table[opcode]); \ + LOG_OP("\nemit_op [%02x]\t", opcode); \ + } while (0) +#define skip_label() \ + do { \ + wasm_loader_emit_backspace(loader_ctx, sizeof(void *)); \ + LOG_OP("\ndelete last op\n"); \ + } while (0) #else /* else of WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS */ -#define emit_label(opcode) do { \ - int32 offset = (int32)((uint8*)handle_table[opcode] \ - - (uint8*)handle_table[0]); \ - if (!(offset >= INT16_MIN && offset < INT16_MAX)) { \ - set_error_buf(error_buf, error_buf_size, \ - "pre-compiled label offset out of range"); \ - goto fail; \ - } \ - wasm_loader_emit_int16(loader_ctx, offset); \ - LOG_OP("\nemit_op [%02x]\t", opcode); \ - } while (0) -#define skip_label() do { \ - wasm_loader_emit_backspace(loader_ctx, sizeof(int16)); \ - LOG_OP("\ndelete last op\n"); \ - } while (0) +#define emit_label(opcode) \ + do { \ + int32 offset = \ + (int32)((uint8 *)handle_table[opcode] - (uint8 *)handle_table[0]); \ + if (!(offset >= INT16_MIN && offset < INT16_MAX)) { \ + set_error_buf(error_buf, error_buf_size, \ + "pre-compiled label offset out of range"); \ + goto fail; \ + } \ + wasm_loader_emit_int16(loader_ctx, offset); \ + LOG_OP("\nemit_op [%02x]\t", opcode); \ + } while (0) +#define skip_label() \ + do { \ + wasm_loader_emit_backspace(loader_ctx, sizeof(int16)); \ + LOG_OP("\ndelete last op\n"); \ + } while (0) #endif /* end of WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS */ -#else /* else of WASM_ENABLE_LABELS_AS_VALUES */ -#define emit_label(opcode) do { \ - wasm_loader_emit_uint8(loader_ctx, opcode); \ - LOG_OP("\nemit_op [%02x]\t", opcode); \ - } while (0) -#define skip_label() do { \ - wasm_loader_emit_backspace(loader_ctx, sizeof(uint8)); \ - LOG_OP("\ndelete last op\n"); \ - } while (0) +#else /* else of WASM_ENABLE_LABELS_AS_VALUES */ +#define emit_label(opcode) \ + do { \ + wasm_loader_emit_uint8(loader_ctx, opcode); \ + LOG_OP("\nemit_op [%02x]\t", opcode); \ + } while (0) +#define skip_label() \ + do { \ + wasm_loader_emit_backspace(loader_ctx, sizeof(uint8)); \ + LOG_OP("\ndelete last op\n"); \ + } while (0) #endif /* end of WASM_ENABLE_LABELS_AS_VALUES */ -#define emit_empty_label_addr_and_frame_ip(type) do { \ - if (!add_label_patch_to_list(loader_ctx->frame_csp - 1, type, \ - loader_ctx->p_code_compiled, \ - error_buf, error_buf_size)) \ - goto fail; \ - /* label address, to be patched */ \ - wasm_loader_emit_ptr(loader_ctx, NULL); \ - } while (0) +#define emit_empty_label_addr_and_frame_ip(type) \ + do { \ + if (!add_label_patch_to_list(loader_ctx->frame_csp - 1, type, \ + loader_ctx->p_code_compiled, error_buf, \ + error_buf_size)) \ + goto fail; \ + /* label address, to be patched */ \ + wasm_loader_emit_ptr(loader_ctx, NULL); \ + } while (0) -#define emit_br_info(frame_csp) do { \ - if (!wasm_loader_emit_br_info(loader_ctx, frame_csp, \ - error_buf, error_buf_size)) \ - goto fail; \ - } while (0) +#define emit_br_info(frame_csp) \ + do { \ + if (!wasm_loader_emit_br_info(loader_ctx, frame_csp, error_buf, \ + error_buf_size)) \ + goto fail; \ + } while (0) -#define LAST_OP_OUTPUT_I32() (last_op >= WASM_OP_I32_EQZ \ - && last_op <= WASM_OP_I32_ROTR) \ - || (last_op == WASM_OP_I32_LOAD \ - || last_op == WASM_OP_F32_LOAD) \ - || (last_op >= WASM_OP_I32_LOAD8_S \ - && last_op <= WASM_OP_I32_LOAD16_U) \ - || (last_op >= WASM_OP_F32_ABS \ - && last_op <= WASM_OP_F32_COPYSIGN) \ - || (last_op >= WASM_OP_I32_WRAP_I64 \ - && last_op <= WASM_OP_I32_TRUNC_U_F64) \ - || (last_op >= WASM_OP_F32_CONVERT_S_I32 \ - && last_op <= WASM_OP_F32_DEMOTE_F64) \ - || (last_op == WASM_OP_I32_REINTERPRET_F32) \ - || (last_op == WASM_OP_F32_REINTERPRET_I32) \ - || (last_op == EXT_OP_COPY_STACK_TOP) +#define LAST_OP_OUTPUT_I32() \ + (last_op >= WASM_OP_I32_EQZ && last_op <= WASM_OP_I32_ROTR) \ + || (last_op == WASM_OP_I32_LOAD || last_op == WASM_OP_F32_LOAD) \ + || (last_op >= WASM_OP_I32_LOAD8_S && last_op <= WASM_OP_I32_LOAD16_U) \ + || (last_op >= WASM_OP_F32_ABS && last_op <= WASM_OP_F32_COPYSIGN) \ + || (last_op >= WASM_OP_I32_WRAP_I64 \ + && last_op <= WASM_OP_I32_TRUNC_U_F64) \ + || (last_op >= WASM_OP_F32_CONVERT_S_I32 \ + && last_op <= WASM_OP_F32_DEMOTE_F64) \ + || (last_op == WASM_OP_I32_REINTERPRET_F32) \ + || (last_op == WASM_OP_F32_REINTERPRET_I32) \ + || (last_op == EXT_OP_COPY_STACK_TOP) -#define LAST_OP_OUTPUT_I64() (last_op >= WASM_OP_I64_CLZ \ - && last_op <= WASM_OP_I64_ROTR) \ - || (last_op >= WASM_OP_F64_ABS \ - && last_op <= WASM_OP_F64_COPYSIGN) \ - || (last_op == WASM_OP_I64_LOAD \ - || last_op == WASM_OP_F64_LOAD) \ - || (last_op >= WASM_OP_I64_LOAD8_S \ - && last_op <= WASM_OP_I64_LOAD32_U) \ - || (last_op >= WASM_OP_I64_EXTEND_S_I32 \ - && last_op <= WASM_OP_I64_TRUNC_U_F64) \ - || (last_op >= WASM_OP_F64_CONVERT_S_I32 \ - && last_op <= WASM_OP_F64_PROMOTE_F32) \ - || (last_op == WASM_OP_I64_REINTERPRET_F64) \ - || (last_op == WASM_OP_F64_REINTERPRET_I64) \ - || (last_op == EXT_OP_COPY_STACK_TOP_I64) +#define LAST_OP_OUTPUT_I64() \ + (last_op >= WASM_OP_I64_CLZ && last_op <= WASM_OP_I64_ROTR) \ + || (last_op >= WASM_OP_F64_ABS && last_op <= WASM_OP_F64_COPYSIGN) \ + || (last_op == WASM_OP_I64_LOAD || last_op == WASM_OP_F64_LOAD) \ + || (last_op >= WASM_OP_I64_LOAD8_S && last_op <= WASM_OP_I64_LOAD32_U) \ + || (last_op >= WASM_OP_I64_EXTEND_S_I32 \ + && last_op <= WASM_OP_I64_TRUNC_U_F64) \ + || (last_op >= WASM_OP_F64_CONVERT_S_I32 \ + && last_op <= WASM_OP_F64_PROMOTE_F32) \ + || (last_op == WASM_OP_I64_REINTERPRET_F64) \ + || (last_op == WASM_OP_F64_REINTERPRET_I64) \ + || (last_op == EXT_OP_COPY_STACK_TOP_I64) -#define GET_CONST_OFFSET(type, val) do { \ - if (!(wasm_loader_get_const_offset(loader_ctx, type, \ - &val, &operand_offset, \ - error_buf, error_buf_size))) \ - goto fail; \ - } while (0) +#define GET_CONST_OFFSET(type, val) \ + do { \ + if (!(wasm_loader_get_const_offset(loader_ctx, type, &val, \ + &operand_offset, error_buf, \ + error_buf_size))) \ + goto fail; \ + } while (0) -#define GET_CONST_F32_OFFSET(type, fval) do { \ - if (!(wasm_loader_get_const_offset(loader_ctx, type, \ - &fval, &operand_offset, \ - error_buf, error_buf_size))) \ - goto fail; \ - } while (0) +#define GET_CONST_F32_OFFSET(type, fval) \ + do { \ + if (!(wasm_loader_get_const_offset(loader_ctx, type, &fval, \ + &operand_offset, error_buf, \ + error_buf_size))) \ + goto fail; \ + } while (0) -#define GET_CONST_F64_OFFSET(type, fval) do { \ - if (!(wasm_loader_get_const_offset(loader_ctx, type, \ - &fval, &operand_offset, \ - error_buf, error_buf_size))) \ - goto fail; \ - } while (0) +#define GET_CONST_F64_OFFSET(type, fval) \ + do { \ + if (!(wasm_loader_get_const_offset(loader_ctx, type, &fval, \ + &operand_offset, error_buf, \ + error_buf_size))) \ + goto fail; \ + } while (0) -#define emit_operand(ctx, offset) do { \ - wasm_loader_emit_int16(ctx, offset); \ - LOG_OP("%d\t", offset); \ - } while (0) +#define emit_operand(ctx, offset) \ + do { \ + wasm_loader_emit_int16(ctx, offset); \ + LOG_OP("%d\t", offset); \ + } while (0) -#define emit_byte(ctx, byte) do { \ - wasm_loader_emit_uint8(ctx, byte); \ - LOG_OP("%d\t", byte); \ - } while (0) +#define emit_byte(ctx, byte) \ + do { \ + wasm_loader_emit_uint8(ctx, byte); \ + LOG_OP("%d\t", byte); \ + } while (0) -#define emit_uint32(ctx, value) do { \ - wasm_loader_emit_uint32(ctx, value); \ - LOG_OP("%d\t", value); \ - } while (0) +#define emit_uint32(ctx, value) \ + do { \ + wasm_loader_emit_uint32(ctx, value); \ + LOG_OP("%d\t", value); \ + } while (0) static bool wasm_loader_ctx_reinit(WASMLoaderContext *ctx) @@ -4846,8 +4801,7 @@ wasm_loader_ctx_reinit(WASMLoaderContext *ctx) if (!(ctx->p_code_compiled = wasm_runtime_malloc(ctx->code_compiled_size))) return false; memset(ctx->p_code_compiled, 0, ctx->code_compiled_size); - ctx->p_code_compiled_end = ctx->p_code_compiled + - ctx->code_compiled_size; + ctx->p_code_compiled_end = ctx->p_code_compiled + ctx->code_compiled_size; /* clean up frame ref */ memset(ctx->frame_ref_bottom, 0, ctx->frame_ref_size); @@ -4971,8 +4925,9 @@ wasm_loader_emit_backspace(WASMLoaderContext *ctx, uint32 size) static bool preserve_referenced_local(WASMLoaderContext *loader_ctx, uint8 opcode, - uint32 local_index, uint32 local_type, bool *preserved, - char *error_buf, uint32 error_buf_size) + uint32 local_index, uint32 local_type, + bool *preserved, char *error_buf, + uint32 error_buf_size) { uint32 i = 0; int16 preserved_offset = (int16)local_index; @@ -4981,7 +4936,8 @@ preserve_referenced_local(WASMLoaderContext *loader_ctx, uint8 opcode, while (i < loader_ctx->stack_cell_num) { uint8 cur_type = loader_ctx->frame_ref_bottom[i]; - /* move previous local into dynamic space before a set/tee_local opcode */ + /* move previous local into dynamic space before a set/tee_local opcode + */ if (loader_ctx->frame_offset_bottom[i] == (int16)local_index) { if (!(*preserved)) { *preserved = true; @@ -5056,12 +5012,12 @@ preserve_local_for_block(WASMLoaderContext *loader_ctx, uint8 opcode, } static bool -add_label_patch_to_list(BranchBlock *frame_csp, - uint8 patch_type, uint8 *p_code_compiled, - char *error_buf, uint32 error_buf_size) +add_label_patch_to_list(BranchBlock *frame_csp, uint8 patch_type, + uint8 *p_code_compiled, char *error_buf, + uint32 error_buf_size) { - BranchBlockPatch *patch = loader_malloc - (sizeof(BranchBlockPatch), error_buf, error_buf_size); + BranchBlockPatch *patch = + loader_malloc(sizeof(BranchBlockPatch), error_buf, error_buf_size); if (!patch) { return false; } @@ -5079,8 +5035,7 @@ add_label_patch_to_list(BranchBlock *frame_csp, } static void -apply_label_patch(WASMLoaderContext *ctx, uint8 depth, - uint8 patch_type) +apply_label_patch(WASMLoaderContext *ctx, uint8 depth, uint8 patch_type) { BranchBlock *frame_csp = ctx->frame_csp - depth; BranchBlockPatch *node = frame_csp->patch_list; @@ -5153,11 +5108,11 @@ wasm_loader_emit_br_info(WASMLoaderContext *ctx, BranchBlock *frame_csp, for (i = (int32)arity - 1; i >= 0; i--) { cell = (uint8)wasm_value_type_cell_num(types[i]); frame_offset -= cell; - emit_operand(ctx, *(int16*)(frame_offset)); + emit_operand(ctx, *(int16 *)(frame_offset)); } /* Part e */ - dynamic_offset = frame_csp->dynamic_offset - + wasm_get_cell_num(types, arity); + dynamic_offset = + frame_csp->dynamic_offset + wasm_get_cell_num(types, arity); for (i = (int32)arity - 1; i >= 0; i--) { cell = (uint8)wasm_value_type_cell_num(types[i]); dynamic_offset -= cell; @@ -5170,8 +5125,7 @@ wasm_loader_emit_br_info(WASMLoaderContext *ctx, BranchBlock *frame_csp, wasm_loader_emit_ptr(ctx, frame_csp->code_compiled); } else { - if (!add_label_patch_to_list(frame_csp, PATCH_END, - ctx->p_code_compiled, + if (!add_label_patch_to_list(frame_csp, PATCH_END, ctx->p_code_compiled, error_buf, error_buf_size)) return false; /* label address, to be patched */ @@ -5233,8 +5187,8 @@ wasm_loader_pop_frame_offset(WASMLoaderContext *ctx, uint8 type, then current block is the function block */ uint32 depth = ctx->frame_csp > ctx->frame_csp_bottom ? 1 : 0; BranchBlock *cur_block = ctx->frame_csp - depth; - int32 available_stack_cell = (int32) - (ctx->stack_cell_num - cur_block->stack_cell_num); + int32 available_stack_cell = + (int32)(ctx->stack_cell_num - cur_block->stack_cell_num); /* Directly return success if current block is in stack * polymorphic state while stack is empty. */ @@ -5279,12 +5233,13 @@ wasm_loader_push_pop_frame_offset(WASMLoaderContext *ctx, uint8 pop_cnt, uint8 i; for (i = 0; i < pop_cnt; i++) { - if (!wasm_loader_pop_frame_offset(ctx, type_pop, error_buf, error_buf_size)) + if (!wasm_loader_pop_frame_offset(ctx, type_pop, error_buf, + error_buf_size)) return false; } - if (!wasm_loader_push_frame_offset(ctx, type_push, - disable_emit, operand_offset, - error_buf, error_buf_size)) + if (!wasm_loader_push_frame_offset(ctx, type_push, disable_emit, + operand_offset, error_buf, + error_buf_size)) return false; return true; @@ -5335,26 +5290,29 @@ wasm_loader_push_pop_frame_ref_offset(WASMLoaderContext *ctx, uint8 pop_cnt, } static bool -wasm_loader_get_const_offset(WASMLoaderContext *ctx, uint8 type, - void *value, int16 *offset, - char *error_buf, uint32 error_buf_size) +wasm_loader_get_const_offset(WASMLoaderContext *ctx, uint8 type, void *value, + int16 *offset, char *error_buf, + uint32 error_buf_size) { int16 operand_offset = 0; Const *c; for (c = (Const *)ctx->const_buf; - (uint8*)c < ctx->const_buf + ctx->num_const * sizeof(Const); c ++) { + (uint8 *)c < ctx->const_buf + ctx->num_const * sizeof(Const); c++) { /* TODO: handle v128 type? */ if ((type == c->value_type) - && ((type == VALUE_TYPE_I64 && *(int64*)value == c->value.i64) - || (type == VALUE_TYPE_I32 && *(int32*)value == c->value.i32) + && ((type == VALUE_TYPE_I64 && *(int64 *)value == c->value.i64) + || (type == VALUE_TYPE_I32 && *(int32 *)value == c->value.i32) #if WASM_ENABLE_REF_TYPES != 0 - || (type == VALUE_TYPE_FUNCREF && *(int32*)value == c->value.i32) - || (type == VALUE_TYPE_EXTERNREF && *(int32*)value == c->value.i32) + || (type == VALUE_TYPE_FUNCREF + && *(int32 *)value == c->value.i32) + || (type == VALUE_TYPE_EXTERNREF + && *(int32 *)value == c->value.i32) #endif || (type == VALUE_TYPE_F64 && (0 == memcmp(value, &(c->value.f64), sizeof(float64)))) || (type == VALUE_TYPE_F32 - && (0 == memcmp(value, &(c->value.f32), sizeof(float32)))))) { + && (0 + == memcmp(value, &(c->value.f32), sizeof(float32)))))) { operand_offset = c->slot_index; break; } @@ -5365,48 +5323,49 @@ wasm_loader_get_const_offset(WASMLoaderContext *ctx, uint8 type, } if ((uint8 *)c == ctx->const_buf + ctx->num_const * sizeof(Const)) { if ((uint8 *)c == ctx->const_buf + ctx->const_buf_size) { - MEM_REALLOC(ctx->const_buf, - ctx->const_buf_size, + MEM_REALLOC(ctx->const_buf, ctx->const_buf_size, ctx->const_buf_size + 4 * sizeof(Const)); ctx->const_buf_size += 4 * sizeof(Const); c = (Const *)(ctx->const_buf + ctx->num_const * sizeof(Const)); } c->value_type = type; switch (type) { - case VALUE_TYPE_F64: - bh_memcpy_s(&(c->value.f64), sizeof(WASMValue), value, sizeof(float64)); - ctx->const_cell_num += 2; - /* The const buf will be reversed, we use the second cell */ - /* of the i64/f64 const so the finnal offset is corrent */ - operand_offset ++; - break; - case VALUE_TYPE_I64: - c->value.i64 = *(int64*)value; - ctx->const_cell_num += 2; - operand_offset ++; - break; - case VALUE_TYPE_F32: - bh_memcpy_s(&(c->value.f32), sizeof(WASMValue), value, sizeof(float32)); - ctx->const_cell_num ++; - break; - case VALUE_TYPE_I32: - c->value.i32 = *(int32*)value; - ctx->const_cell_num ++; - break; + case VALUE_TYPE_F64: + bh_memcpy_s(&(c->value.f64), sizeof(WASMValue), value, + sizeof(float64)); + ctx->const_cell_num += 2; + /* The const buf will be reversed, we use the second cell */ + /* of the i64/f64 const so the finnal offset is corrent */ + operand_offset++; + break; + case VALUE_TYPE_I64: + c->value.i64 = *(int64 *)value; + ctx->const_cell_num += 2; + operand_offset++; + break; + case VALUE_TYPE_F32: + bh_memcpy_s(&(c->value.f32), sizeof(WASMValue), value, + sizeof(float32)); + ctx->const_cell_num++; + break; + case VALUE_TYPE_I32: + c->value.i32 = *(int32 *)value; + ctx->const_cell_num++; + break; #if WASM_ENABLE_REF_TYPES != 0 - case VALUE_TYPE_EXTERNREF: - case VALUE_TYPE_FUNCREF: - c->value.i32 = *(int32*)value; - ctx->const_cell_num ++; - break; + case VALUE_TYPE_EXTERNREF: + case VALUE_TYPE_FUNCREF: + c->value.i32 = *(int32 *)value; + ctx->const_cell_num++; + break; #endif - default: - break; + default: + break; } c->slot_index = operand_offset; - ctx->num_const ++; - LOG_OP("#### new const [%d]: %ld\n", - ctx->num_const, (int64)c->value.i64); + ctx->num_const++; + LOG_OP("#### new const [%d]: %ld\n", ctx->num_const, + (int64)c->value.i64); } /* use negetive index for const */ operand_offset = -(operand_offset + 1); @@ -5433,77 +5392,85 @@ fail: only push the frame_offset stack, no emit */ -#define TEMPLATE_PUSH(Type) do { \ - if (!wasm_loader_push_frame_ref_offset(loader_ctx, VALUE_TYPE_##Type,\ - disable_emit, operand_offset,\ - error_buf, error_buf_size)) \ - goto fail; \ - } while (0) +#define TEMPLATE_PUSH(Type) \ + do { \ + if (!wasm_loader_push_frame_ref_offset(loader_ctx, VALUE_TYPE_##Type, \ + disable_emit, operand_offset, \ + error_buf, error_buf_size)) \ + goto fail; \ + } while (0) -#define TEMPLATE_POP(Type) do { \ - if (!wasm_loader_pop_frame_ref_offset(loader_ctx, VALUE_TYPE_##Type,\ - error_buf, error_buf_size)) \ - goto fail; \ - } while (0) +#define TEMPLATE_POP(Type) \ + do { \ + if (!wasm_loader_pop_frame_ref_offset(loader_ctx, VALUE_TYPE_##Type, \ + error_buf, error_buf_size)) \ + goto fail; \ + } while (0) -#define PUSH_OFFSET_TYPE(type) do { \ - if (!(wasm_loader_push_frame_offset(loader_ctx, type, \ - disable_emit, operand_offset, \ - error_buf, error_buf_size))) \ - goto fail; \ - } while (0) +#define PUSH_OFFSET_TYPE(type) \ + do { \ + if (!(wasm_loader_push_frame_offset(loader_ctx, type, disable_emit, \ + operand_offset, error_buf, \ + error_buf_size))) \ + goto fail; \ + } while (0) -#define POP_OFFSET_TYPE(type) do { \ - if (!(wasm_loader_pop_frame_offset(loader_ctx, type, \ - error_buf, error_buf_size))) \ - goto fail; \ - } while (0) +#define POP_OFFSET_TYPE(type) \ + do { \ + if (!(wasm_loader_pop_frame_offset(loader_ctx, type, error_buf, \ + error_buf_size))) \ + goto fail; \ + } while (0) -#define POP_AND_PUSH(type_pop, type_push) do { \ - if (!(wasm_loader_push_pop_frame_ref_offset(loader_ctx, 1, \ - type_push, type_pop, \ - disable_emit, operand_offset, \ - error_buf, error_buf_size))) \ - goto fail; \ - } while (0) +#define POP_AND_PUSH(type_pop, type_push) \ + do { \ + if (!(wasm_loader_push_pop_frame_ref_offset( \ + loader_ctx, 1, type_push, type_pop, disable_emit, \ + operand_offset, error_buf, error_buf_size))) \ + goto fail; \ + } while (0) /* type of POPs should be the same */ -#define POP2_AND_PUSH(type_pop, type_push) do { \ - if (!(wasm_loader_push_pop_frame_ref_offset(loader_ctx, 2, \ - type_push, type_pop, \ - disable_emit, operand_offset, \ - error_buf, error_buf_size))) \ - goto fail; \ - } while (0) +#define POP2_AND_PUSH(type_pop, type_push) \ + do { \ + if (!(wasm_loader_push_pop_frame_ref_offset( \ + loader_ctx, 2, type_push, type_pop, disable_emit, \ + operand_offset, error_buf, error_buf_size))) \ + goto fail; \ + } while (0) #else /* WASM_ENABLE_FAST_INTERP */ -#define TEMPLATE_PUSH(Type) do { \ - if (!(wasm_loader_push_frame_ref(loader_ctx, VALUE_TYPE_##Type, \ - error_buf, error_buf_size))) \ - goto fail; \ - } while (0) +#define TEMPLATE_PUSH(Type) \ + do { \ + if (!(wasm_loader_push_frame_ref(loader_ctx, VALUE_TYPE_##Type, \ + error_buf, error_buf_size))) \ + goto fail; \ + } while (0) -#define TEMPLATE_POP(Type) do { \ - if (!(wasm_loader_pop_frame_ref(loader_ctx, VALUE_TYPE_##Type, \ - error_buf, error_buf_size))) \ - goto fail; \ - } while (0) +#define TEMPLATE_POP(Type) \ + do { \ + if (!(wasm_loader_pop_frame_ref(loader_ctx, VALUE_TYPE_##Type, \ + error_buf, error_buf_size))) \ + goto fail; \ + } while (0) -#define POP_AND_PUSH(type_pop, type_push) do { \ - if (!(wasm_loader_push_pop_frame_ref(loader_ctx, 1, \ - type_push, type_pop, \ - error_buf, error_buf_size))) \ - goto fail; \ - } while (0) +#define POP_AND_PUSH(type_pop, type_push) \ + do { \ + if (!(wasm_loader_push_pop_frame_ref(loader_ctx, 1, type_push, \ + type_pop, error_buf, \ + error_buf_size))) \ + goto fail; \ + } while (0) /* type of POPs should be the same */ -#define POP2_AND_PUSH(type_pop, type_push) do { \ - if (!(wasm_loader_push_pop_frame_ref(loader_ctx, 2, \ - type_push, type_pop, \ - error_buf, error_buf_size))) \ - goto fail; \ - } while (0) +#define POP2_AND_PUSH(type_pop, type_push) \ + do { \ + if (!(wasm_loader_push_pop_frame_ref(loader_ctx, 2, type_push, \ + type_pop, error_buf, \ + error_buf_size))) \ + goto fail; \ + } while (0) #endif /* WASM_ENABLE_FAST_INTERP */ #define PUSH_I32() TEMPLATE_PUSH(I32) @@ -5525,19 +5492,18 @@ fail: #if WASM_ENABLE_FAST_INTERP != 0 static bool -reserve_block_ret(WASMLoaderContext *loader_ctx, - uint8 opcode, bool disable_emit, - char *error_buf, uint32 error_buf_size) +reserve_block_ret(WASMLoaderContext *loader_ctx, uint8 opcode, + bool disable_emit, char *error_buf, uint32 error_buf_size) { int16 operand_offset = 0; - BranchBlock *block = (opcode == WASM_OP_ELSE) ? - loader_ctx->frame_csp - 1 : loader_ctx->frame_csp; + BranchBlock *block = (opcode == WASM_OP_ELSE) ? loader_ctx->frame_csp - 1 + : loader_ctx->frame_csp; BlockType *block_type = &block->block_type; uint8 *return_types = NULL; uint32 return_count = 0, value_count = 0, total_cel_num = 0; int32 i = 0; - int16 dynamic_offset, dynamic_offset_org, - *frame_offset = NULL, *frame_offset_org = NULL; + int16 dynamic_offset, dynamic_offset_org, *frame_offset = NULL, + *frame_offset_org = NULL; return_count = block_type_get_result_types(block_type, &return_types); @@ -5549,7 +5515,8 @@ reserve_block_ret(WASMLoaderContext *loader_ctx, /* insert op_copy before else opcode */ if (opcode == WASM_OP_ELSE) skip_label(); - emit_label(cell == 1 ? EXT_OP_COPY_STACK_TOP : EXT_OP_COPY_STACK_TOP_I64); + emit_label(cell == 1 ? EXT_OP_COPY_STACK_TOP + : EXT_OP_COPY_STACK_TOP_I64); emit_operand(loader_ctx, *(loader_ctx->frame_offset - cell)); emit_operand(loader_ctx, block->dynamic_offset); @@ -5578,8 +5545,7 @@ reserve_block_ret(WASMLoaderContext *loader_ctx, */ frame_offset = frame_offset_org = loader_ctx->frame_offset; dynamic_offset = dynamic_offset_org = - block->dynamic_offset - + wasm_get_cell_num(return_types, return_count); + block->dynamic_offset + wasm_get_cell_num(return_types, return_count); /* First traversal to get the count of values needed to be copied. */ for (i = (int32)return_count - 1; i >= 0; i--) { @@ -5598,9 +5564,9 @@ reserve_block_ret(WASMLoaderContext *loader_ctx, uint8 *emit_data = NULL, *cells = NULL; int16 *src_offsets = NULL; uint16 *dst_offsets = NULL; - uint64 size = (uint64)value_count * (sizeof(*cells) - + sizeof(*src_offsets) - + sizeof(*dst_offsets)); + uint64 size = + (uint64)value_count + * (sizeof(*cells) + sizeof(*src_offsets) + sizeof(*dst_offsets)); /* Allocate memory for the emit data */ if (!(emit_data = loader_malloc(size, error_buf, error_buf_size))) @@ -5619,7 +5585,8 @@ reserve_block_ret(WASMLoaderContext *loader_ctx, /* Part b) */ emit_uint32(loader_ctx, total_cel_num); - /* Second traversal to get each value's cell num, src offset and dst offset. */ + /* Second traversal to get each value's cell num, src offset and dst + * offset. */ frame_offset = frame_offset_org; dynamic_offset = dynamic_offset_org; for (i = (int32)return_count - 1, j = 0; i >= 0; i--) { @@ -5671,83 +5638,86 @@ fail: } #endif /* WASM_ENABLE_FAST_INTERP */ -#define RESERVE_BLOCK_RET() do { \ - if (!reserve_block_ret(loader_ctx, opcode, disable_emit, \ - error_buf, error_buf_size)) \ - goto fail; \ - } while (0) +#define RESERVE_BLOCK_RET() \ + do { \ + if (!reserve_block_ret(loader_ctx, opcode, disable_emit, error_buf, \ + error_buf_size)) \ + goto fail; \ + } while (0) -#define PUSH_TYPE(type) do { \ - if (!(wasm_loader_push_frame_ref(loader_ctx, type, \ - error_buf, error_buf_size))) \ - goto fail; \ - } while (0) +#define PUSH_TYPE(type) \ + do { \ + if (!(wasm_loader_push_frame_ref(loader_ctx, type, error_buf, \ + error_buf_size))) \ + goto fail; \ + } while (0) -#define POP_TYPE(type) do { \ - if (!(wasm_loader_pop_frame_ref(loader_ctx, type, \ - error_buf, error_buf_size))) \ - goto fail; \ - } while (0) +#define POP_TYPE(type) \ + do { \ + if (!(wasm_loader_pop_frame_ref(loader_ctx, type, error_buf, \ + error_buf_size))) \ + goto fail; \ + } while (0) -#define PUSH_CSP(label_type, block_type, _start_addr) do { \ - if (!wasm_loader_push_frame_csp(loader_ctx, label_type, block_type, \ - _start_addr, error_buf, \ - error_buf_size)) \ - goto fail; \ - } while (0) +#define PUSH_CSP(label_type, block_type, _start_addr) \ + do { \ + if (!wasm_loader_push_frame_csp(loader_ctx, label_type, block_type, \ + _start_addr, error_buf, \ + error_buf_size)) \ + goto fail; \ + } while (0) -#define POP_CSP() do { \ - if (!wasm_loader_pop_frame_csp(loader_ctx, \ - error_buf, error_buf_size)) \ - goto fail; \ - } while (0) +#define POP_CSP() \ + do { \ + if (!wasm_loader_pop_frame_csp(loader_ctx, error_buf, error_buf_size)) \ + goto fail; \ + } while (0) -#define GET_LOCAL_INDEX_TYPE_AND_OFFSET() do { \ - read_leb_uint32(p, p_end, local_idx); \ - if (local_idx >= param_count + local_count) { \ - set_error_buf(error_buf, error_buf_size, \ - "unknown local"); \ - goto fail; \ - } \ - local_type = local_idx < param_count \ - ? param_types[local_idx] \ - : local_types[local_idx - param_count]; \ - local_offset = local_offsets[local_idx]; \ - } while (0) +#define GET_LOCAL_INDEX_TYPE_AND_OFFSET() \ + do { \ + read_leb_uint32(p, p_end, local_idx); \ + if (local_idx >= param_count + local_count) { \ + set_error_buf(error_buf, error_buf_size, "unknown local"); \ + goto fail; \ + } \ + local_type = local_idx < param_count \ + ? param_types[local_idx] \ + : local_types[local_idx - param_count]; \ + local_offset = local_offsets[local_idx]; \ + } while (0) -#define CHECK_BR(depth) do { \ - if (!wasm_loader_check_br(loader_ctx, depth, \ - error_buf, error_buf_size)) \ - goto fail; \ - } while (0) +#define CHECK_BR(depth) \ + do { \ + if (!wasm_loader_check_br(loader_ctx, depth, error_buf, \ + error_buf_size)) \ + goto fail; \ + } while (0) static bool -check_memory(WASMModule *module, - char *error_buf, uint32 error_buf_size) +check_memory(WASMModule *module, char *error_buf, uint32 error_buf_size) { - if (module->memory_count == 0 - && module->import_memory_count == 0) { + if (module->memory_count == 0 && module->import_memory_count == 0) { set_error_buf(error_buf, error_buf_size, "unknown memory"); return false; } return true; } -#define CHECK_MEMORY() do { \ - if (!check_memory(module, error_buf, error_buf_size)) \ - goto fail; \ - } while (0) +#define CHECK_MEMORY() \ + do { \ + if (!check_memory(module, error_buf, error_buf_size)) \ + goto fail; \ + } while (0) static bool -check_memory_access_align(uint8 opcode, uint32 align, - char *error_buf, uint32 error_buf_size) +check_memory_access_align(uint8 opcode, uint32 align, char *error_buf, + uint32 error_buf_size) { uint8 mem_access_aligns[] = { 2, 3, 2, 3, 0, 0, 1, 1, 0, 0, 1, 1, 2, 2, /* loads */ 2, 3, 2, 3, 0, 1, 0, 1, 2 /* stores */ }; - bh_assert(opcode >= WASM_OP_I32_LOAD - && opcode <= WASM_OP_I64_STORE32); + bh_assert(opcode >= WASM_OP_I32_LOAD && opcode <= WASM_OP_I64_STORE32); if (align > mem_access_aligns[opcode - WASM_OP_I32_LOAD]) { set_error_buf(error_buf, error_buf_size, "alignment must not be larger than natural"); @@ -5759,20 +5729,20 @@ check_memory_access_align(uint8 opcode, uint32 align, #if WASM_ENABLE_SIMD != 0 #if (WASM_ENABLE_WAMR_COMPILER != 0) || (WASM_ENABLE_JIT != 0) static bool -check_simd_memory_access_align(uint8 opcode, uint32 align, - char *error_buf, uint32 error_buf_size) +check_simd_memory_access_align(uint8 opcode, uint32 align, char *error_buf, + uint32 error_buf_size) { uint8 mem_access_aligns[] = { - 4, /* load */ - 3, 3, 3, 3, 3, 3, /* load and extend */ - 0, 1, 2, 3, /* load and splat */ - 4, /* store */ + 4, /* load */ + 3, 3, 3, 3, 3, 3, /* load and extend */ + 0, 1, 2, 3, /* load and splat */ + 4, /* store */ }; uint8 mem_access_aligns_load_lane[] = { 0, 1, 2, 3, /* load lane */ 0, 1, 2, 3, /* store lane */ - 2, 3 /* store zero */ + 2, 3 /* store zero */ }; if (!((opcode <= SIMD_v128_store) @@ -5797,8 +5767,8 @@ check_simd_memory_access_align(uint8 opcode, uint32 align, } static bool -check_simd_access_lane(uint8 opcode, uint8 lane, - char *error_buf, uint32 error_buf_size) +check_simd_access_lane(uint8 opcode, uint8 lane, char *error_buf, + uint32 error_buf_size) { switch (opcode) { case SIMD_i8x16_extract_lane_s: @@ -5860,9 +5830,7 @@ fail: } static bool -check_simd_shuffle_mask(V128 mask, - char *error_buf, - uint32 error_buf_size) +check_simd_shuffle_mask(V128 mask, char *error_buf, uint32 error_buf_size) { uint8 i; for (i = 0; i != 16; ++i) { @@ -5878,10 +5846,10 @@ check_simd_shuffle_mask(V128 mask, #if WASM_ENABLE_SHARED_MEMORY != 0 static bool -check_memory_align_equal(uint8 opcode, uint32 align, - char *error_buf, uint32 error_buf_size) +check_memory_align_equal(uint8 opcode, uint32 align, char *error_buf, + uint32 error_buf_size) { - uint8 wait_notify_aligns[] = {2, 2, 3}; + uint8 wait_notify_aligns[] = { 2, 2, 3 }; uint8 mem_access_aligns[] = { 2, 3, 0, 1, 0, 1, 2, }; @@ -5918,10 +5886,10 @@ wasm_loader_check_br(WASMLoaderContext *loader_ctx, uint32 depth, uint16 cell_num; if (loader_ctx->csp_num < depth + 1) { - set_error_buf(error_buf, error_buf_size, - "unknown label, " - "unexpected end of section or function"); - return false; + set_error_buf(error_buf, error_buf_size, + "unknown label, " + "unexpected end of section or function"); + return false; } cur_block = loader_ctx->frame_csp - 1; @@ -5941,7 +5909,7 @@ wasm_loader_check_br(WASMLoaderContext *loader_ctx, uint32 depth, * and then re-push the values to make the stack top values * match block type. */ if (cur_block->is_stack_polymorphic) { - for (i = (int32)arity -1; i >= 0; i--) { + for (i = (int32)arity - 1; i >= 0; i--) { #if WASM_ENABLE_FAST_INTERP != 0 POP_OFFSET_TYPE(types[i]); #endif @@ -5958,13 +5926,12 @@ wasm_loader_check_br(WASMLoaderContext *loader_ctx, uint32 depth, return true; } - available_stack_cell = (int32) - (loader_ctx->stack_cell_num - cur_block->stack_cell_num); + available_stack_cell = + (int32)(loader_ctx->stack_cell_num - cur_block->stack_cell_num); /* Check stack top values match target block type */ - for (i = (int32)arity -1; i >= 0; i--) { - if (!check_stack_top_values(frame_ref, available_stack_cell, - types[i], + for (i = (int32)arity - 1; i >= 0; i--) { + if (!check_stack_top_values(frame_ref, available_stack_cell, types[i], error_buf, error_buf_size)) return false; cell_num = wasm_value_type_cell_num(types[i]); @@ -5979,8 +5946,7 @@ fail: } static BranchBlock * -check_branch_block(WASMLoaderContext *loader_ctx, - uint8 **p_buf, uint8 *buf_end, +check_branch_block(WASMLoaderContext *loader_ctx, uint8 **p_buf, uint8 *buf_end, char *error_buf, uint32 error_buf_size) { uint8 *p = *p_buf, *p_end = buf_end; @@ -6010,19 +5976,18 @@ check_block_stack(WASMLoaderContext *loader_ctx, BranchBlock *block, int32 available_stack_cell, return_cell_num, i; uint8 *frame_ref = NULL; - available_stack_cell = (int32) - (loader_ctx->stack_cell_num - - block->stack_cell_num); + available_stack_cell = + (int32)(loader_ctx->stack_cell_num - block->stack_cell_num); return_count = block_type_get_result_types(block_type, &return_types); - return_cell_num = return_count > 0 ? - wasm_get_cell_num(return_types, return_count) : 0; + return_cell_num = + return_count > 0 ? wasm_get_cell_num(return_types, return_count) : 0; /* If the stack is in polymorphic state, just clear the stack * and then re-push the values to make the stack top values * match block type. */ if (block->is_stack_polymorphic) { - for (i = (int32)return_count -1; i >= 0; i--) { + for (i = (int32)return_count - 1; i >= 0; i--) { #if WASM_ENABLE_FAST_INTERP != 0 POP_OFFSET_TYPE(return_types[i]); #endif @@ -6031,8 +5996,9 @@ check_block_stack(WASMLoaderContext *loader_ctx, BranchBlock *block, /* Check stack is empty */ if (loader_ctx->stack_cell_num != block->stack_cell_num) { - set_error_buf(error_buf, error_buf_size, - "type mismatch: stack size does not match block type"); + set_error_buf( + error_buf, error_buf_size, + "type mismatch: stack size does not match block type"); goto fail; } @@ -6056,10 +6022,9 @@ check_block_stack(WASMLoaderContext *loader_ctx, BranchBlock *block, /* Check stack values match return types */ frame_ref = loader_ctx->frame_ref; - for (i = (int32)return_count -1; i >= 0; i--) { + for (i = (int32)return_count - 1; i >= 0; i--) { if (!check_stack_top_values(frame_ref, available_stack_cell, - return_types[i], - error_buf, error_buf_size)) + return_types[i], error_buf, error_buf_size)) return false; frame_ref -= wasm_value_type_cell_num(return_types[i]); available_stack_cell -= wasm_value_type_cell_num(return_types[i]); @@ -6084,7 +6049,7 @@ fail: */ static bool copy_params_to_dynamic_space(WASMLoaderContext *loader_ctx, bool is_if_block, - char* error_buf, uint32 error_buf_size) + char *error_buf, uint32 error_buf_size) { int16 *frame_offset = NULL; uint8 *cells = NULL, cell; @@ -6099,8 +6064,7 @@ copy_params_to_dynamic_space(WASMLoaderContext *loader_ctx, bool is_if_block, bool disable_emit = false; int16 operand_offset = 0; - uint64 size = (uint64)param_count * (sizeof(*cells) - + sizeof(*src_offsets)); + uint64 size = (uint64)param_count * (sizeof(*cells) + sizeof(*src_offsets)); /* For if block, we also need copy the condition operand offset. */ if (is_if_block) @@ -6136,9 +6100,8 @@ copy_params_to_dynamic_space(WASMLoaderContext *loader_ctx, bool is_if_block, /* Part a) */ emit_uint32(loader_ctx, is_if_block ? param_count + 1 : param_count); /* Part b) */ - emit_uint32(loader_ctx, is_if_block ? - wasm_type->param_cell_num + 1 : - wasm_type->param_cell_num); + emit_uint32(loader_ctx, is_if_block ? wasm_type->param_cell_num + 1 + : wasm_type->param_cell_num); /* Part c) */ for (i = 0; i < param_count; i++) emit_byte(loader_ctx, cells[i]); @@ -6170,44 +6133,47 @@ fail: /* reset the stack to the state of before entering the last block */ #if WASM_ENABLE_FAST_INTERP != 0 -#define RESET_STACK() do { \ - loader_ctx->stack_cell_num = \ - (loader_ctx->frame_csp - 1)->stack_cell_num; \ - loader_ctx->frame_ref = \ - loader_ctx->frame_ref_bottom + loader_ctx->stack_cell_num; \ - loader_ctx->frame_offset = \ - loader_ctx->frame_offset_bottom + loader_ctx->stack_cell_num; \ -} while (0) +#define RESET_STACK() \ + do { \ + loader_ctx->stack_cell_num = \ + (loader_ctx->frame_csp - 1)->stack_cell_num; \ + loader_ctx->frame_ref = \ + loader_ctx->frame_ref_bottom + loader_ctx->stack_cell_num; \ + loader_ctx->frame_offset = \ + loader_ctx->frame_offset_bottom + loader_ctx->stack_cell_num; \ + } while (0) #else -#define RESET_STACK() do { \ - loader_ctx->stack_cell_num = \ - (loader_ctx->frame_csp - 1)->stack_cell_num; \ - loader_ctx->frame_ref = \ - loader_ctx->frame_ref_bottom + loader_ctx->stack_cell_num; \ -} while (0) +#define RESET_STACK() \ + do { \ + loader_ctx->stack_cell_num = \ + (loader_ctx->frame_csp - 1)->stack_cell_num; \ + loader_ctx->frame_ref = \ + loader_ctx->frame_ref_bottom + loader_ctx->stack_cell_num; \ + } while (0) #endif /* set current block's stack polymorphic state */ -#define SET_CUR_BLOCK_STACK_POLYMORPHIC_STATE(flag) do { \ - BranchBlock *cur_block = loader_ctx->frame_csp - 1; \ - cur_block->is_stack_polymorphic = flag; \ -} while (0) +#define SET_CUR_BLOCK_STACK_POLYMORPHIC_STATE(flag) \ + do { \ + BranchBlock *cur_block = loader_ctx->frame_csp - 1; \ + cur_block->is_stack_polymorphic = flag; \ + } while (0) #define BLOCK_HAS_PARAM(block_type) \ (!block_type.is_value_type && block_type.u.type->param_count > 0) -#define PRESERVE_LOCAL_FOR_BLOCK() do { \ - if (!(preserve_local_for_block(loader_ctx, opcode, \ - error_buf, error_buf_size))) { \ - goto fail; \ - } \ -} while (0) +#define PRESERVE_LOCAL_FOR_BLOCK() \ + do { \ + if (!(preserve_local_for_block(loader_ctx, opcode, error_buf, \ + error_buf_size))) { \ + goto fail; \ + } \ + } while (0) #if WASM_ENABLE_REF_TYPES != 0 static bool -get_table_elem_type(const WASMModule *module, - uint32 table_idx, uint8 *p_elem_type, - char *error_buf, uint32 error_buf_size) +get_table_elem_type(const WASMModule *module, uint32 table_idx, + uint8 *p_elem_type, char *error_buf, uint32 error_buf_size) { if (!check_table_index(module, table_idx, error_buf, error_buf_size)) { return false; @@ -6217,16 +6183,17 @@ get_table_elem_type(const WASMModule *module, if (table_idx < module->import_table_count) *p_elem_type = module->import_tables[table_idx].u.table.elem_type; else - *p_elem_type = module->tables[module->import_table_count - + table_idx].elem_type; + *p_elem_type = + module->tables[module->import_table_count + table_idx] + .elem_type; } return true; } static bool -get_table_seg_elem_type(const WASMModule *module, - uint32 table_seg_idx, uint8 *p_elem_type, - char *error_buf, uint32 error_buf_size) +get_table_seg_elem_type(const WASMModule *module, uint32 table_seg_idx, + uint8 *p_elem_type, char *error_buf, + uint32 error_buf_size) { if (table_seg_idx >= module->table_seg_count) { #if WASM_ENABLE_REF_TYPES != 0 @@ -6238,8 +6205,7 @@ get_table_seg_elem_type(const WASMModule *module, "unknown elem segment %u", table_seg_idx); } #else - set_error_buf(error_buf, error_buf_size, - "unknown table segment"); + set_error_buf(error_buf, error_buf_size, "unknown table segment"); #endif return false; } @@ -6252,9 +6218,9 @@ get_table_seg_elem_type(const WASMModule *module, #endif static bool -wasm_loader_prepare_bytecode(WASMModule *module, - WASMFunction *func, uint32 cur_func_idx, - char *error_buf, uint32 error_buf_size) +wasm_loader_prepare_bytecode(WASMModule *module, WASMFunction *func, + uint32 cur_func_idx, char *error_buf, + uint32 error_buf_size) { uint8 *p = func->code, *p_end = func->code + func->code_size, *p_org; uint32 param_count, local_count, global_count; @@ -6278,9 +6244,7 @@ wasm_loader_prepare_bytecode(WASMModule *module, float64 f64; LOG_OP("\nProcessing func | [%d] params | [%d] locals | [%d] return\n", - func->param_cell_num, - func->local_cell_num, - func->ret_cell_num); + func->param_cell_num, func->local_cell_num, func->ret_cell_num); #endif global_count = module->import_global_count + module->global_count; @@ -6296,8 +6260,7 @@ wasm_loader_prepare_bytecode(WASMModule *module, local_offsets = func->local_offsets; if (!(loader_ctx = wasm_loader_ctx_init(func))) { - set_error_buf(error_buf, error_buf_size, - "allocate memory failed"); + set_error_buf(error_buf, error_buf_size, "allocate memory failed"); goto fail; } @@ -6305,8 +6268,7 @@ wasm_loader_prepare_bytecode(WASMModule *module, re_scan: if (loader_ctx->code_compiled_size > 0) { if (!wasm_loader_ctx_reinit(loader_ctx)) { - set_error_buf(error_buf, error_buf_size, - "allocate memory failed"); + set_error_buf(error_buf, error_buf_size, "allocate memory failed"); goto fail; } p = func->code; @@ -6348,7 +6310,7 @@ re_scan: #if WASM_ENABLE_FAST_INTERP != 0 PRESERVE_LOCAL_FOR_BLOCK(); #endif -handle_op_block_and_loop: + handle_op_block_and_loop: { uint8 value_type; BlockType block_type; @@ -6373,12 +6335,11 @@ handle_op_block_and_loop: } block_type.is_value_type = false; block_type.u.type = module->types[type_index]; -#if WASM_ENABLE_FAST_INTERP == 0 \ - && WASM_ENABLE_WAMR_COMPILER == 0 \ +#if WASM_ENABLE_FAST_INTERP == 0 && WASM_ENABLE_WAMR_COMPILER == 0 \ && WASM_ENABLE_JIT == 0 /* If block use type index as block type, change the opcode - * to new extended opcode so that interpreter can resolve the - * block quickly. + * to new extended opcode so that interpreter can resolve + * the block quickly. */ #if WASM_ENABLE_DEBUG_INTERP != 0 record_fast_op(module, p - 2, *(p - 2)); @@ -6391,10 +6352,12 @@ handle_op_block_and_loop: if (BLOCK_HAS_PARAM(block_type)) { WASMType *wasm_type = block_type.u.type; for (i = 0; i < block_type.u.type->param_count; i++) - POP_TYPE(wasm_type->types[wasm_type->param_count - i - 1]); + POP_TYPE( + wasm_type->types[wasm_type->param_count - i - 1]); } - PUSH_CSP(LABEL_TYPE_BLOCK + (opcode - WASM_OP_BLOCK), block_type, p); + PUSH_CSP(LABEL_TYPE_BLOCK + (opcode - WASM_OP_BLOCK), + block_type, p); /* Pass parameters to block */ if (BLOCK_HAS_PARAM(block_type)) { @@ -6410,14 +6373,12 @@ handle_op_block_and_loop: 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, false, error_buf, error_buf_size)) goto fail; } (loader_ctx->frame_csp - 1)->code_compiled = - loader_ctx->p_code_compiled; + loader_ctx->p_code_compiled; } else if (opcode == WASM_OP_IF) { /* If block has parameters, we should make sure they are in @@ -6427,8 +6388,8 @@ handle_op_block_and_loop: * (func (export "params-id") (param i32) (result i32) * (i32.const 1) * (i32.const 2) - * (if (param i32 i32) (result i32 i32) (local.get 0) (then)) - * (i32.add) + * (if (param i32 i32) (result i32 i32) (local.get 0) + * (then)) (i32.add) * ) * * So we should emit a copy instruction before the if. @@ -6446,10 +6407,8 @@ handle_op_block_and_loop: /* 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, true, error_buf, error_buf_size)) goto fail; /* Emit the if instruction */ @@ -6457,16 +6416,17 @@ handle_op_block_and_loop: /* Emit the new condition operand offset */ POP_OFFSET_TYPE(VALUE_TYPE_I32); - /* Save top param_count values of frame_offset stack, so that - * we can recover it before executing else branch */ - size = sizeof(int16) * - (uint64)block_type.u.type->param_cell_num; - if (!(block->param_frame_offsets = - loader_malloc(size, error_buf, error_buf_size))) + /* Save top param_count values of frame_offset stack, so + * that we can recover it before executing else branch + */ + size = sizeof(int16) + * (uint64)block_type.u.type->param_cell_num; + if (!(block->param_frame_offsets = loader_malloc( + size, error_buf, error_buf_size))) goto fail; - bh_memcpy_s(block->param_frame_offsets, - (uint32)size, - loader_ctx->frame_offset - size/sizeof(int16), + bh_memcpy_s(block->param_frame_offsets, (uint32)size, + loader_ctx->frame_offset + - size / sizeof(int16), (uint32)size); } @@ -6482,9 +6442,11 @@ handle_op_block_and_loop: BlockType block_type = (loader_ctx->frame_csp - 1)->block_type; if (loader_ctx->csp_num < 2 - || (loader_ctx->frame_csp - 1)->label_type != LABEL_TYPE_IF) { - set_error_buf(error_buf, error_buf_size, - "opcode else found without matched opcode if"); + || (loader_ctx->frame_csp - 1)->label_type + != LABEL_TYPE_IF) { + set_error_buf( + error_buf, error_buf_size, + "opcode else found without matched opcode if"); goto fail; } @@ -6496,7 +6458,8 @@ handle_op_block_and_loop: (loader_ctx->frame_csp - 1)->else_addr = p - 1; #if WASM_ENABLE_FAST_INTERP != 0 - /* if the result of if branch is in local or const area, add a copy op */ + /* if the result of if branch is in local or const area, add a + * copy op */ RESERVE_BLOCK_RET(); emit_empty_label_addr_and_frame_ip(PATCH_END); @@ -6516,11 +6479,10 @@ handle_op_block_and_loop: if (BLOCK_HAS_PARAM((block_type))) { uint32 size; BranchBlock *block = loader_ctx->frame_csp - 1; - size = sizeof(int16) * - block_type.u.type->param_cell_num; + size = sizeof(int16) * block_type.u.type->param_cell_num; bh_memcpy_s(loader_ctx->frame_offset, size, block->param_frame_offsets, size); - loader_ctx->frame_offset += (size/sizeof(int16)); + loader_ctx->frame_offset += (size / sizeof(int16)); } #endif @@ -6532,11 +6494,12 @@ handle_op_block_and_loop: BranchBlock *cur_block = loader_ctx->frame_csp - 1; /* check whether block stack matches its result type */ - if (!check_block_stack(loader_ctx, cur_block, - error_buf, error_buf_size)) + if (!check_block_stack(loader_ctx, cur_block, error_buf, + error_buf_size)) goto fail; - /* if no else branch, and return types do not match param types, fail */ + /* if no else branch, and return types do not match param types, + * fail */ if (cur_block->label_type == LABEL_TYPE_IF && !cur_block->else_addr) { uint32 param_count = 0, ret_count = 0; @@ -6555,7 +6518,8 @@ handle_op_block_and_loop: ret_types = block_type->u.type->types + param_count; } if (param_count != ret_count - || (param_count && memcmp(param_types, ret_types, param_count))) { + || (param_count + && memcmp(param_types, ret_types, param_count))) { set_error_buf(error_buf, error_buf_size, "type mismatch: else branch missing"); goto fail; @@ -6601,8 +6565,8 @@ handle_op_block_and_loop: case WASM_OP_BR: { - if (!(frame_csp_tmp = check_branch_block(loader_ctx, &p, p_end, - error_buf, error_buf_size))) + if (!(frame_csp_tmp = check_branch_block( + loader_ctx, &p, p_end, error_buf, error_buf_size))) goto fail; RESET_STACK(); @@ -6614,8 +6578,8 @@ handle_op_block_and_loop: { POP_I32(); - if (!(frame_csp_tmp = check_branch_block(loader_ctx, &p, p_end, - error_buf, error_buf_size))) + if (!(frame_csp_tmp = check_branch_block( + loader_ctx, &p, p_end, error_buf, error_buf_size))) goto fail; break; @@ -6634,32 +6598,34 @@ handle_op_block_and_loop: for (i = 0; i <= count; i++) { if (!(frame_csp_tmp = - check_branch_block(loader_ctx, &p, p_end, - error_buf, error_buf_size))) + check_branch_block(loader_ctx, &p, p_end, + error_buf, error_buf_size))) goto fail; if (i == 0) { if (frame_csp_tmp->label_type != LABEL_TYPE_LOOP) - ret_count = - block_type_get_result_types(&frame_csp_tmp->block_type, - &ret_types); + ret_count = block_type_get_result_types( + &frame_csp_tmp->block_type, &ret_types); } else { uint8 *tmp_ret_types = NULL; uint32 tmp_ret_count = 0; - /* Check whether all table items have the same return type */ + /* Check whether all table items have the same return + * type */ if (frame_csp_tmp->label_type != LABEL_TYPE_LOOP) - tmp_ret_count = - block_type_get_result_types(&frame_csp_tmp->block_type, - &tmp_ret_types); + tmp_ret_count = block_type_get_result_types( + &frame_csp_tmp->block_type, &tmp_ret_types); if (ret_count != tmp_ret_count || (ret_count - && 0 != memcmp(ret_types, tmp_ret_types, ret_count))) { - set_error_buf(error_buf, error_buf_size, - "type mismatch: br_table targets must " - "all use same result type"); + && 0 + != memcmp(ret_types, tmp_ret_types, + ret_count))) { + set_error_buf( + error_buf, error_buf_size, + "type mismatch: br_table targets must " + "all use same result type"); goto fail; } } @@ -6674,7 +6640,8 @@ handle_op_block_and_loop: { int32 idx; uint8 ret_type; - for (idx = (int32)func->func_type->result_count - 1; idx >= 0; idx--) { + for (idx = (int32)func->func_type->result_count - 1; idx >= 0; + idx--) { ret_type = *(func->func_type->types + func->func_type->param_count + idx); POP_TYPE(ret_type); @@ -6710,13 +6677,17 @@ handle_op_block_and_loop: } if (func_idx < module->import_function_count) - func_type = module->import_functions[func_idx].u.function.func_type; - else func_type = - module->functions[func_idx - module->import_function_count]->func_type; + module->import_functions[func_idx].u.function.func_type; + else + func_type = module + ->functions[func_idx + - module->import_function_count] + ->func_type; if (func_type->param_count > 0) { - for (idx = (int32)(func_type->param_count - 1); idx >= 0; idx--) { + for (idx = (int32)(func_type->param_count - 1); idx >= 0; + idx--) { POP_TYPE(func_type->types[idx]); #if WASM_ENABLE_FAST_INTERP != 0 POP_OFFSET_TYPE(func_type->types[idx]); @@ -6730,31 +6701,34 @@ handle_op_block_and_loop: for (i = 0; i < func_type->result_count; i++) { PUSH_TYPE(func_type->types[func_type->param_count + i]); #if WASM_ENABLE_FAST_INTERP != 0 - /* Here we emit each return value's dynamic_offset. But in fact - * these offsets are continuous, so interpreter only need to get - * the first return value's offset. + /* Here we emit each return value's dynamic_offset. But + * in fact these offsets are continuous, so interpreter + * only need to get the first return value's offset. */ - PUSH_OFFSET_TYPE(func_type->types[func_type->param_count + i]); + PUSH_OFFSET_TYPE( + func_type->types[func_type->param_count + i]); #endif } #if WASM_ENABLE_TAIL_CALL != 0 } else { uint8 type; - if (func_type->result_count != func->func_type->result_count) { - set_error_buf_v(error_buf, error_buf_size, - "%s%u%s", "type mismatch: expect ", + if (func_type->result_count + != func->func_type->result_count) { + set_error_buf_v(error_buf, error_buf_size, "%s%u%s", + "type mismatch: expect ", func->func_type->result_count, " return values but got other"); goto fail; } for (i = 0; i < func_type->result_count; i++) { - type = func->func_type->types[func->func_type->param_count + i]; - if (func_type->types[func_type->param_count + i] != type) { - set_error_buf_v(error_buf, error_buf_size, - "%s%s%s", "type mismatch: expect ", - type2str(type), - " but got other"); + type = func->func_type + ->types[func->func_type->param_count + i]; + if (func_type->types[func_type->param_count + i] + != type) { + set_error_buf_v(error_buf, error_buf_size, "%s%s%s", + "type mismatch: expect ", + type2str(type), " but got other"); goto fail; } } @@ -6810,15 +6784,15 @@ handle_op_block_and_loop: POP_I32(); if (type_idx >= module->type_count) { - set_error_buf(error_buf, error_buf_size, - "unknown type"); + set_error_buf(error_buf, error_buf_size, "unknown type"); goto fail; } func_type = module->types[type_idx]; if (func_type->param_count > 0) { - for (idx = (int32)(func_type->param_count - 1); idx >= 0; idx--) { + for (idx = (int32)(func_type->param_count - 1); idx >= 0; + idx--) { POP_TYPE(func_type->types[idx]); #if WASM_ENABLE_FAST_INTERP != 0 POP_OFFSET_TYPE(func_type->types[idx]); @@ -6832,27 +6806,30 @@ handle_op_block_and_loop: for (i = 0; i < func_type->result_count; i++) { PUSH_TYPE(func_type->types[func_type->param_count + i]); #if WASM_ENABLE_FAST_INTERP != 0 - PUSH_OFFSET_TYPE(func_type->types[func_type->param_count + i]); + PUSH_OFFSET_TYPE( + func_type->types[func_type->param_count + i]); #endif } #if WASM_ENABLE_TAIL_CALL != 0 } else { uint8 type; - if (func_type->result_count != func->func_type->result_count) { - set_error_buf_v(error_buf, error_buf_size, - "%s%u%s", "type mismatch: expect ", + if (func_type->result_count + != func->func_type->result_count) { + set_error_buf_v(error_buf, error_buf_size, "%s%u%s", + "type mismatch: expect ", func->func_type->result_count, " return values but got other"); goto fail; } for (i = 0; i < func_type->result_count; i++) { - type = func->func_type->types[func->func_type->param_count + i]; - if (func_type->types[func_type->param_count + i] != type) { - set_error_buf_v(error_buf, error_buf_size, - "%s%s%s", "type mismatch: expect ", - type2str(type), - " but got other"); + type = func->func_type + ->types[func->func_type->param_count + i]; + if (func_type->types[func_type->param_count + i] + != type) { + set_error_buf_v(error_buf, error_buf_size, "%s%s%s", + "type mismatch: expect ", + type2str(type), " but got other"); goto fail; } } @@ -6868,8 +6845,9 @@ handle_op_block_and_loop: case WASM_OP_DROP_64: { BranchBlock *cur_block = loader_ctx->frame_csp - 1; - int32 available_stack_cell = (int32) - (loader_ctx->stack_cell_num - cur_block->stack_cell_num); + int32 available_stack_cell = + (int32)(loader_ctx->stack_cell_num + - cur_block->stack_cell_num); if (available_stack_cell <= 0 && !cur_block->is_stack_polymorphic) { @@ -6886,15 +6864,15 @@ handle_op_block_and_loop: || *(loader_ctx->frame_ref - 1) == REF_FUNCREF || *(loader_ctx->frame_ref - 1) == REF_EXTERNREF #endif - ) { + ) { loader_ctx->frame_ref--; loader_ctx->stack_cell_num--; #if WASM_ENABLE_FAST_INTERP != 0 skip_label(); loader_ctx->frame_offset--; - if (*(loader_ctx->frame_offset) > - loader_ctx->start_dynamic_offset) - loader_ctx->dynamic_offset --; + if (*(loader_ctx->frame_offset) + > loader_ctx->start_dynamic_offset) + loader_ctx->dynamic_offset--; #endif } else if (*(loader_ctx->frame_ref - 1) == REF_I64_1 @@ -6907,8 +6885,8 @@ handle_op_block_and_loop: #if WASM_ENABLE_FAST_INTERP != 0 skip_label(); loader_ctx->frame_offset -= 2; - if (*(loader_ctx->frame_offset) > - loader_ctx->start_dynamic_offset) + if (*(loader_ctx->frame_offset) + > loader_ctx->start_dynamic_offset) loader_ctx->dynamic_offset -= 2; #endif } @@ -6943,8 +6921,8 @@ handle_op_block_and_loop: POP_I32(); - available_stack_cell = (int32) - (loader_ctx->stack_cell_num - cur_block->stack_cell_num); + available_stack_cell = (int32)(loader_ctx->stack_cell_num + - cur_block->stack_cell_num); if (available_stack_cell <= 0 && !cur_block->is_stack_polymorphic) { @@ -6972,21 +6950,24 @@ handle_op_block_and_loop: loader_ctx->p_code_compiled - 2; #if WASM_ENABLE_LABELS_AS_VALUES != 0 #if WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS != 0 - *(void**)(p_code_compiled_tmp - sizeof(void*)) = - handle_table[opcode_tmp]; + *(void **)(p_code_compiled_tmp + - sizeof(void *)) = + handle_table[opcode_tmp]; #else - int32 offset = (int32) - ((uint8*)handle_table[opcode_tmp] - - (uint8*)handle_table[0]); - if (!(offset >= INT16_MIN && offset < INT16_MAX)) { + int32 offset = + (int32)((uint8 *)handle_table[opcode_tmp] + - (uint8 *)handle_table[0]); + if (!(offset >= INT16_MIN + && offset < INT16_MAX)) { set_error_buf(error_buf, error_buf_size, - "pre-compiled label offset out of range"); + "pre-compiled label offset " + "out of range"); goto fail; } - *(int16*)(p_code_compiled_tmp - sizeof(int16)) = - (int16)offset; + *(int16 *)(p_code_compiled_tmp + - sizeof(int16)) = (int16)offset; #endif /* end of WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS */ -#else /* else of WASM_ENABLE_LABELS_AS_VALUES */ +#else /* else of WASM_ENABLE_LABELS_AS_VALUES */ #if WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS != 0 *(p_code_compiled_tmp - 1) = opcode_tmp; #else @@ -7002,7 +6983,8 @@ handle_op_block_and_loop: break; #endif /* (WASM_ENABLE_WAMR_COMPILER != 0) || (WASM_ENABLE_JIT != 0) */ #endif /* WASM_ENABLE_SIMD != 0 */ - default: { + default: + { set_error_buf(error_buf, error_buf_size, "type mismatch"); goto fail; @@ -7072,25 +7054,25 @@ handle_op_block_and_loop: } else { if (ref_type == VALUE_TYPE_F64 - || ref_type == VALUE_TYPE_I64) + || ref_type == VALUE_TYPE_I64) opcode_tmp = WASM_OP_SELECT_64; #if WASM_ENABLE_LABELS_AS_VALUES != 0 #if WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS != 0 - *(void**)(p_code_compiled_tmp - sizeof(void*)) = - handle_table[opcode_tmp]; + *(void **)(p_code_compiled_tmp - sizeof(void *)) = + handle_table[opcode_tmp]; #else - int32 offset = (int32) - ((uint8*)handle_table[opcode_tmp] - - (uint8*)handle_table[0]); + int32 offset = (int32)((uint8 *)handle_table[opcode_tmp] + - (uint8 *)handle_table[0]); if (!(offset >= INT16_MIN && offset < INT16_MAX)) { - set_error_buf(error_buf, error_buf_size, - "pre-compiled label offset out of range"); + set_error_buf( + error_buf, error_buf_size, + "pre-compiled label offset out of range"); goto fail; } - *(int16*)(p_code_compiled_tmp - sizeof(int16)) = - (int16)offset; + *(int16 *)(p_code_compiled_tmp - sizeof(int16)) = + (int16)offset; #endif /* end of WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS */ -#else /* else of WASM_ENABLE_LABELS_AS_VALUES */ +#else /* else of WASM_ENABLE_LABELS_AS_VALUES */ #if WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS != 0 *(p_code_compiled_tmp - 1) = opcode_tmp; #else @@ -7181,21 +7163,20 @@ handle_op_block_and_loop: } #if WASM_ENABLE_FAST_INTERP != 0 - if (!wasm_loader_pop_frame_ref_offset( - loader_ctx, VALUE_TYPE_FUNCREF, - error_buf, error_buf_size) + if (!wasm_loader_pop_frame_ref_offset(loader_ctx, + VALUE_TYPE_FUNCREF, + error_buf, error_buf_size) && !wasm_loader_pop_frame_ref_offset( - loader_ctx, VALUE_TYPE_EXTERNREF, - error_buf, error_buf_size)) { + loader_ctx, VALUE_TYPE_EXTERNREF, error_buf, + error_buf_size)) { goto fail; } #else - if (!wasm_loader_pop_frame_ref( - loader_ctx, VALUE_TYPE_FUNCREF, - error_buf, error_buf_size) - && !wasm_loader_pop_frame_ref( - loader_ctx, VALUE_TYPE_EXTERNREF, - error_buf, error_buf_size)) { + if (!wasm_loader_pop_frame_ref(loader_ctx, VALUE_TYPE_FUNCREF, + error_buf, error_buf_size) + && !wasm_loader_pop_frame_ref(loader_ctx, + VALUE_TYPE_EXTERNREF, + error_buf, error_buf_size)) { goto fail; } #endif @@ -7224,8 +7205,9 @@ handle_op_block_and_loop: for (i = 0; i < module->table_seg_count; i++, table_seg++) { if (table_seg->elem_type == VALUE_TYPE_FUNCREF && wasm_elem_is_declarative(table_seg->mode)) { - for (j =0; j < table_seg->function_count; j++) { - if (table_seg->func_indexes[j] == cur_func_idx) { + for (j = 0; j < table_seg->function_count; j++) { + if (table_seg->func_indexes[j] + == cur_func_idx) { func_declared = true; break; } @@ -7297,22 +7279,24 @@ handle_op_block_and_loop: POP_TYPE(local_type); #if WASM_ENABLE_FAST_INTERP != 0 - if (!(preserve_referenced_local(loader_ctx, opcode, local_offset, - local_type, &preserve_local, - error_buf, error_buf_size))) + if (!(preserve_referenced_local( + loader_ctx, opcode, local_offset, local_type, + &preserve_local, error_buf, error_buf_size))) goto fail; if (local_offset < 256) { skip_label(); if ((!preserve_local) && (LAST_OP_OUTPUT_I32())) { if (loader_ctx->p_code_compiled) - STORE_U16(loader_ctx->p_code_compiled - 2, local_offset); - loader_ctx->frame_offset --; - loader_ctx->dynamic_offset --; + STORE_U16(loader_ctx->p_code_compiled - 2, + local_offset); + loader_ctx->frame_offset--; + loader_ctx->dynamic_offset--; } else if ((!preserve_local) && (LAST_OP_OUTPUT_I64())) { if (loader_ctx->p_code_compiled) - STORE_U16(loader_ctx->p_code_compiled - 2, local_offset); + STORE_U16(loader_ctx->p_code_compiled - 2, + local_offset); loader_ctx->frame_offset -= 2; loader_ctx->dynamic_offset -= 2; } @@ -7328,7 +7312,7 @@ handle_op_block_and_loop: POP_OFFSET_TYPE(local_type); } } - else { /* local index larger than 255, reserve leb */ + else { /* local index larger than 255, reserve leb */ emit_uint32(loader_ctx, local_idx); POP_OFFSET_TYPE(local_type); } @@ -7369,8 +7353,8 @@ handle_op_block_and_loop: GET_LOCAL_INDEX_TYPE_AND_OFFSET(); #if WASM_ENABLE_FAST_INTERP != 0 /* If the stack is in polymorphic state, do fake pop and push on - offset stack to keep the depth of offset stack to be the same - with ref stack */ + offset stack to keep the depth of offset stack to be the + same with ref stack */ BranchBlock *cur_block = loader_ctx->frame_csp - 1; if (cur_block->is_stack_polymorphic) { POP_OFFSET_TYPE(local_type); @@ -7381,9 +7365,9 @@ handle_op_block_and_loop: PUSH_TYPE(local_type); #if WASM_ENABLE_FAST_INTERP != 0 - if (!(preserve_referenced_local(loader_ctx, opcode, local_offset, - local_type, &preserve_local, - error_buf, error_buf_size))) + if (!(preserve_referenced_local( + loader_ctx, opcode, local_offset, local_type, + &preserve_local, error_buf, error_buf_size))) goto fail; if (local_offset < 256) { @@ -7397,11 +7381,12 @@ handle_op_block_and_loop: emit_byte(loader_ctx, (uint8)local_offset); } } - else { /* local index larger than 255, reserve leb */ + else { /* local index larger than 255, reserve leb */ emit_uint32(loader_ctx, local_idx); } - emit_operand(loader_ctx, *(loader_ctx->frame_offset - - wasm_value_type_cell_num(local_type))); + emit_operand(loader_ctx, + *(loader_ctx->frame_offset + - wasm_value_type_cell_num(local_type))); #else #if (WASM_ENABLE_WAMR_COMPILER == 0) && (WASM_ENABLE_JIT == 0) if (local_offset < 0x80) { @@ -7438,16 +7423,17 @@ handle_op_block_and_loop: p_org = p - 1; read_leb_uint32(p, p_end, global_idx); if (global_idx >= global_count) { - set_error_buf(error_buf, error_buf_size, - "unknown global"); + set_error_buf(error_buf, error_buf_size, "unknown global"); goto fail; } global_type = - global_idx < module->import_global_count - ? module->import_globals[global_idx].u.global.type - : module->globals[global_idx - module->import_global_count] - .type; + global_idx < module->import_global_count + ? module->import_globals[global_idx].u.global.type + : module + ->globals[global_idx + - module->import_global_count] + .type; PUSH_TYPE(global_type); @@ -7461,7 +7447,7 @@ handle_op_block_and_loop: *p_org = WASM_OP_GET_GLOBAL_64; } #endif -#else /* else of WASM_ENABLE_FAST_INTERP */ +#else /* else of WASM_ENABLE_FAST_INTERP */ if (global_type == VALUE_TYPE_I64 || global_type == VALUE_TYPE_F64) { skip_label(); @@ -7480,16 +7466,17 @@ handle_op_block_and_loop: p_org = p - 1; read_leb_uint32(p, p_end, global_idx); if (global_idx >= global_count) { - set_error_buf(error_buf, error_buf_size, - "unknown global"); + set_error_buf(error_buf, error_buf_size, "unknown global"); goto fail; } is_mutable = - global_idx < module->import_global_count - ? module->import_globals[global_idx].u.global.is_mutable - : module->globals[global_idx - module->import_global_count] - .is_mutable; + global_idx < module->import_global_count + ? module->import_globals[global_idx].u.global.is_mutable + : module + ->globals[global_idx + - module->import_global_count] + .is_mutable; if (!is_mutable) { set_error_buf(error_buf, error_buf_size, "global is immutable"); @@ -7497,10 +7484,12 @@ handle_op_block_and_loop: } global_type = - global_idx < module->import_global_count - ? module->import_globals[global_idx].u.global.type - : module->globals[global_idx - module->import_global_count] - .type; + global_idx < module->import_global_count + ? module->import_globals[global_idx].u.global.type + : module + ->globals[global_idx + - module->import_global_count] + .type; POP_TYPE(global_type); @@ -7519,7 +7508,7 @@ handle_op_block_and_loop: #endif *p_org = WASM_OP_SET_GLOBAL_AUX_STACK; } -#else /* else of WASM_ENABLE_FAST_INTERP */ +#else /* else of WASM_ENABLE_FAST_INTERP */ if (global_type == VALUE_TYPE_I64 || global_type == VALUE_TYPE_F64) { skip_label(); @@ -7582,17 +7571,16 @@ handle_op_block_and_loop: } #endif CHECK_MEMORY(); - read_leb_uint32(p, p_end, align); /* align */ + read_leb_uint32(p, p_end, align); /* align */ read_leb_uint32(p, p_end, mem_offset); /* offset */ - if (!check_memory_access_align(opcode, align, - error_buf, error_buf_size)) { + if (!check_memory_access_align(opcode, align, error_buf, + error_buf_size)) { goto fail; } #if WASM_ENABLE_FAST_INTERP != 0 emit_uint32(loader_ctx, mem_offset); #endif - switch (opcode) - { + switch (opcode) { /* load */ case WASM_OP_I32_LOAD: case WASM_OP_I32_LOAD8_S: @@ -7698,7 +7686,8 @@ handle_op_block_and_loop: #if WASM_ENABLE_FAST_INTERP != 0 skip_label(); disable_emit = true; - bh_memcpy_s((uint8*)&f32, sizeof(float32), p_org, sizeof(float32)); + bh_memcpy_s((uint8 *)&f32, sizeof(float32), p_org, + sizeof(float32)); GET_CONST_F32_OFFSET(VALUE_TYPE_F32, f32); #endif PUSH_F32(); @@ -7710,7 +7699,8 @@ handle_op_block_and_loop: skip_label(); disable_emit = true; /* Some MCU may require 8-byte align */ - bh_memcpy_s((uint8*)&f64, sizeof(float64), p_org, sizeof(float64)); + bh_memcpy_s((uint8 *)&f64, sizeof(float64), p_org, + sizeof(float64)); GET_CONST_F64_OFFSET(VALUE_TYPE_F64, f64); #endif PUSH_F64(); @@ -7948,263 +7938,272 @@ handle_op_block_and_loop: #if WASM_ENABLE_FAST_INTERP != 0 emit_byte(loader_ctx, ((uint8)opcode1)); #endif - switch (opcode1) - { - case WASM_OP_I32_TRUNC_SAT_S_F32: - case WASM_OP_I32_TRUNC_SAT_U_F32: - POP_AND_PUSH(VALUE_TYPE_F32, VALUE_TYPE_I32); - break; - case WASM_OP_I32_TRUNC_SAT_S_F64: - case WASM_OP_I32_TRUNC_SAT_U_F64: - POP_AND_PUSH(VALUE_TYPE_F64, VALUE_TYPE_I32); - break; - case WASM_OP_I64_TRUNC_SAT_S_F32: - case WASM_OP_I64_TRUNC_SAT_U_F32: - POP_AND_PUSH(VALUE_TYPE_F32, VALUE_TYPE_I64); - break; - case WASM_OP_I64_TRUNC_SAT_S_F64: - case WASM_OP_I64_TRUNC_SAT_U_F64: - POP_AND_PUSH(VALUE_TYPE_F64, VALUE_TYPE_I64); - break; + switch (opcode1) { + case WASM_OP_I32_TRUNC_SAT_S_F32: + case WASM_OP_I32_TRUNC_SAT_U_F32: + POP_AND_PUSH(VALUE_TYPE_F32, VALUE_TYPE_I32); + break; + case WASM_OP_I32_TRUNC_SAT_S_F64: + case WASM_OP_I32_TRUNC_SAT_U_F64: + POP_AND_PUSH(VALUE_TYPE_F64, VALUE_TYPE_I32); + break; + case WASM_OP_I64_TRUNC_SAT_S_F32: + case WASM_OP_I64_TRUNC_SAT_U_F32: + POP_AND_PUSH(VALUE_TYPE_F32, VALUE_TYPE_I64); + break; + case WASM_OP_I64_TRUNC_SAT_S_F64: + case WASM_OP_I64_TRUNC_SAT_U_F64: + POP_AND_PUSH(VALUE_TYPE_F64, VALUE_TYPE_I64); + break; #if WASM_ENABLE_BULK_MEMORY != 0 - case WASM_OP_MEMORY_INIT: - { - read_leb_uint32(p, p_end, data_seg_idx); + case WASM_OP_MEMORY_INIT: + { + read_leb_uint32(p, p_end, data_seg_idx); #if WASM_ENABLE_FAST_INTERP != 0 - emit_uint32(loader_ctx, data_seg_idx); + emit_uint32(loader_ctx, data_seg_idx); #endif - if (module->import_memory_count == 0 && module->memory_count == 0) - goto fail_unknown_memory; + if (module->import_memory_count == 0 + && module->memory_count == 0) + goto fail_unknown_memory; - if (*p++ != 0x00) - goto fail_zero_byte_expected; + if (*p++ != 0x00) + goto fail_zero_byte_expected; - if (data_seg_idx >= module->data_seg_count) { - set_error_buf_v(error_buf, error_buf_size, - "unknown data segment %d", data_seg_idx); - goto fail; + if (data_seg_idx >= module->data_seg_count) { + set_error_buf_v(error_buf, error_buf_size, + "unknown data segment %d", + data_seg_idx); + goto fail; + } + + if (module->data_seg_count1 == 0) + goto fail_data_cnt_sec_require; + + POP_I32(); + POP_I32(); + POP_I32(); + break; } - - if (module->data_seg_count1 == 0) - goto fail_data_cnt_sec_require; - - POP_I32(); - POP_I32(); - POP_I32(); - break; - } - case WASM_OP_DATA_DROP: - { - read_leb_uint32(p, p_end, data_seg_idx); + case WASM_OP_DATA_DROP: + { + read_leb_uint32(p, p_end, data_seg_idx); #if WASM_ENABLE_FAST_INTERP != 0 - emit_uint32(loader_ctx, data_seg_idx); + emit_uint32(loader_ctx, data_seg_idx); #endif - if (data_seg_idx >= module->data_seg_count) { + if (data_seg_idx >= module->data_seg_count) { + set_error_buf(error_buf, error_buf_size, + "unknown data segment"); + goto fail; + } + + if (module->data_seg_count1 == 0) + goto fail_data_cnt_sec_require; + + break; + } + case WASM_OP_MEMORY_COPY: + { + /* both src and dst memory index should be 0 */ + if (*(int16 *)p != 0x0000) + goto fail_zero_byte_expected; + p += 2; + + if (module->import_memory_count == 0 + && module->memory_count == 0) + goto fail_unknown_memory; + + POP_I32(); + POP_I32(); + POP_I32(); + break; + } + case WASM_OP_MEMORY_FILL: + { + if (*p++ != 0x00) { + goto fail_zero_byte_expected; + } + if (module->import_memory_count == 0 + && module->memory_count == 0) { + goto fail_unknown_memory; + } + + POP_I32(); + POP_I32(); + POP_I32(); + break; + fail_zero_byte_expected: set_error_buf(error_buf, error_buf_size, - "unknown data segment"); + "zero byte expected"); + goto fail; + + fail_unknown_memory: + set_error_buf(error_buf, error_buf_size, + "unknown memory 0"); + goto fail; + fail_data_cnt_sec_require: + set_error_buf(error_buf, error_buf_size, + "data count section required"); goto fail; } - - if (module->data_seg_count1 == 0) - goto fail_data_cnt_sec_require; - - break; - } - case WASM_OP_MEMORY_COPY: - { - /* both src and dst memory index should be 0 */ - if (*(int16*)p != 0x0000) - goto fail_zero_byte_expected; - p += 2; - - if (module->import_memory_count == 0 && module->memory_count == 0) - goto fail_unknown_memory; - - POP_I32(); - POP_I32(); - POP_I32(); - break; - } - case WASM_OP_MEMORY_FILL: - { - if (*p++ != 0x00) { - goto fail_zero_byte_expected; - } - if (module->import_memory_count == 0 && module->memory_count == 0) { - goto fail_unknown_memory; - } - - POP_I32(); - POP_I32(); - POP_I32(); - break; -fail_zero_byte_expected: - set_error_buf(error_buf, error_buf_size, - "zero byte expected"); - goto fail; - -fail_unknown_memory: - set_error_buf(error_buf, error_buf_size, - "unknown memory 0"); - goto fail; -fail_data_cnt_sec_require: - set_error_buf(error_buf, error_buf_size, - "data count section required"); - goto fail; - } #endif /* WASM_ENABLE_BULK_MEMORY */ #if WASM_ENABLE_REF_TYPES != 0 - case WASM_OP_TABLE_INIT: - { - uint8 seg_ref_type = 0, tbl_ref_type = 0; + case WASM_OP_TABLE_INIT: + { + uint8 seg_ref_type = 0, tbl_ref_type = 0; - if (!wasm_get_ref_types_flag()) { - goto unsupported_opcode; - } + if (!wasm_get_ref_types_flag()) { + goto unsupported_opcode; + } - read_leb_uint32(p, p_end, table_seg_idx); - read_leb_uint32(p, p_end, table_idx); + read_leb_uint32(p, p_end, table_seg_idx); + read_leb_uint32(p, p_end, table_idx); - if (!get_table_elem_type(module, table_idx, &tbl_ref_type, - error_buf, error_buf_size)) - goto fail; - - if (!get_table_seg_elem_type(module, table_seg_idx, - &seg_ref_type, error_buf, + if (!get_table_elem_type(module, table_idx, + &tbl_ref_type, error_buf, error_buf_size)) - goto fail; + goto fail; - if (seg_ref_type != tbl_ref_type) { - set_error_buf(error_buf, error_buf_size, - "type mismatch"); - goto fail; - } + if (!get_table_seg_elem_type(module, table_seg_idx, + &seg_ref_type, error_buf, + error_buf_size)) + goto fail; -#if WASM_ENABLE_FAST_INTERP != 0 - emit_uint32(loader_ctx, table_seg_idx); - emit_uint32(loader_ctx, table_idx); -#endif - POP_I32(); - POP_I32(); - POP_I32(); - break; - } - case WASM_OP_ELEM_DROP: - { - if (!wasm_get_ref_types_flag()) { - goto unsupported_opcode; - } - - read_leb_uint32(p, p_end, table_seg_idx); - if (!get_table_seg_elem_type(module, table_seg_idx, NULL, - error_buf, error_buf_size)) - goto fail; -#if WASM_ENABLE_FAST_INTERP != 0 - emit_uint32(loader_ctx, table_seg_idx); -#endif - break; - } - case WASM_OP_TABLE_COPY: - { - uint8 src_ref_type, dst_ref_type; - uint32 src_tbl_idx, dst_tbl_idx; - - if (!wasm_get_ref_types_flag()) { - goto unsupported_opcode; - } - - read_leb_uint32(p, p_end, src_tbl_idx); - if (!get_table_elem_type(module, src_tbl_idx, &src_ref_type, - error_buf, error_buf_size)) - goto fail; - - read_leb_uint32(p, p_end, dst_tbl_idx); - if (!get_table_elem_type(module, dst_tbl_idx, &dst_ref_type, - error_buf, error_buf_size)) - goto fail; - - if (src_ref_type != dst_ref_type) { - set_error_buf(error_buf, error_buf_size, - "type mismatch"); - goto fail; - } - -#if WASM_ENABLE_FAST_INTERP != 0 - emit_uint32(loader_ctx, src_tbl_idx); - emit_uint32(loader_ctx, dst_tbl_idx); -#endif - POP_I32(); - POP_I32(); - POP_I32(); - break; - } - case WASM_OP_TABLE_SIZE: - { - if (!wasm_get_ref_types_flag()) { - goto unsupported_opcode; - } - - read_leb_uint32(p, p_end, table_idx); - /* TODO: shall we create a new function to check - table idx instead of using below function? */ - if (!get_table_elem_type(module, table_idx, NULL, - error_buf, error_buf_size)) - goto fail; - -#if WASM_ENABLE_FAST_INTERP != 0 - emit_uint32(loader_ctx, table_idx); -#endif - - PUSH_I32(); - break; - } - case WASM_OP_TABLE_GROW: - case WASM_OP_TABLE_FILL: - { - uint8 decl_ref_type; - - if (!wasm_get_ref_types_flag()) { - goto unsupported_opcode; - } - - read_leb_uint32(p, p_end, table_idx); - if (!get_table_elem_type(module, table_idx, - &decl_ref_type, error_buf, - error_buf_size)) - goto fail; - - if (opcode1 == WASM_OP_TABLE_GROW) { - if (table_idx < module->import_table_count) { - module->import_tables[table_idx] - .u.table.possible_grow = true; + if (seg_ref_type != tbl_ref_type) { + set_error_buf(error_buf, error_buf_size, + "type mismatch"); + goto fail; } - else { - module->tables[table_idx - module->import_table_count] - .possible_grow = true; - } - } #if WASM_ENABLE_FAST_INTERP != 0 - emit_uint32(loader_ctx, table_idx); + emit_uint32(loader_ctx, table_seg_idx); + emit_uint32(loader_ctx, table_idx); #endif - - POP_I32(); -#if WASM_ENABLE_FAST_INTERP != 0 - POP_OFFSET_TYPE(decl_ref_type); -#endif - POP_TYPE(decl_ref_type); - if (opcode1 == WASM_OP_TABLE_GROW) - PUSH_I32(); - else POP_I32(); - break; - } + POP_I32(); + POP_I32(); + break; + } + case WASM_OP_ELEM_DROP: + { + if (!wasm_get_ref_types_flag()) { + goto unsupported_opcode; + } + + read_leb_uint32(p, p_end, table_seg_idx); + if (!get_table_seg_elem_type(module, table_seg_idx, + NULL, error_buf, + error_buf_size)) + goto fail; +#if WASM_ENABLE_FAST_INTERP != 0 + emit_uint32(loader_ctx, table_seg_idx); +#endif + break; + } + case WASM_OP_TABLE_COPY: + { + uint8 src_ref_type, dst_ref_type; + uint32 src_tbl_idx, dst_tbl_idx; + + if (!wasm_get_ref_types_flag()) { + goto unsupported_opcode; + } + + read_leb_uint32(p, p_end, src_tbl_idx); + if (!get_table_elem_type(module, src_tbl_idx, + &src_ref_type, error_buf, + error_buf_size)) + goto fail; + + read_leb_uint32(p, p_end, dst_tbl_idx); + if (!get_table_elem_type(module, dst_tbl_idx, + &dst_ref_type, error_buf, + error_buf_size)) + goto fail; + + if (src_ref_type != dst_ref_type) { + set_error_buf(error_buf, error_buf_size, + "type mismatch"); + goto fail; + } + +#if WASM_ENABLE_FAST_INTERP != 0 + emit_uint32(loader_ctx, src_tbl_idx); + emit_uint32(loader_ctx, dst_tbl_idx); +#endif + POP_I32(); + POP_I32(); + POP_I32(); + break; + } + case WASM_OP_TABLE_SIZE: + { + if (!wasm_get_ref_types_flag()) { + goto unsupported_opcode; + } + + read_leb_uint32(p, p_end, table_idx); + /* TODO: shall we create a new function to check + table idx instead of using below function? */ + if (!get_table_elem_type(module, table_idx, NULL, + error_buf, error_buf_size)) + goto fail; + +#if WASM_ENABLE_FAST_INTERP != 0 + emit_uint32(loader_ctx, table_idx); +#endif + + PUSH_I32(); + break; + } + case WASM_OP_TABLE_GROW: + case WASM_OP_TABLE_FILL: + { + uint8 decl_ref_type; + + if (!wasm_get_ref_types_flag()) { + goto unsupported_opcode; + } + + read_leb_uint32(p, p_end, table_idx); + if (!get_table_elem_type(module, table_idx, + &decl_ref_type, error_buf, + error_buf_size)) + goto fail; + + if (opcode1 == WASM_OP_TABLE_GROW) { + if (table_idx < module->import_table_count) { + module->import_tables[table_idx] + .u.table.possible_grow = true; + } + else { + module + ->tables[table_idx + - module->import_table_count] + .possible_grow = true; + } + } + +#if WASM_ENABLE_FAST_INTERP != 0 + emit_uint32(loader_ctx, table_idx); +#endif + + POP_I32(); +#if WASM_ENABLE_FAST_INTERP != 0 + POP_OFFSET_TYPE(decl_ref_type); +#endif + POP_TYPE(decl_ref_type); + if (opcode1 == WASM_OP_TABLE_GROW) + PUSH_I32(); + else + POP_I32(); + break; + } #endif /* WASM_ENABLE_REF_TYPES */ - default: - set_error_buf_v(error_buf, error_buf_size, - "%s %02x %02x", - "unsupported opcode", 0xfc, opcode1); - goto fail; + default: + set_error_buf_v(error_buf, error_buf_size, + "%s %02x %02x", "unsupported opcode", + 0xfc, opcode1); + goto fail; } break; } @@ -8214,7 +8213,8 @@ fail_data_cnt_sec_require: case WASM_OP_SIMD_PREFIX: { opcode = read_uint8(p); - /* follow the order of enum WASMSimdEXTOpcode in wasm_opcode.h */ + /* follow the order of enum WASMSimdEXTOpcode in wasm_opcode.h + */ switch (opcode) { /* memory instruction */ case SIMD_v128_load: @@ -8233,7 +8233,7 @@ fail_data_cnt_sec_require: read_leb_uint32(p, p_end, align); /* align */ if (!check_simd_memory_access_align( - opcode, align, error_buf, error_buf_size)) { + opcode, align, error_buf, error_buf_size)) { goto fail; } @@ -8249,7 +8249,7 @@ fail_data_cnt_sec_require: read_leb_uint32(p, p_end, align); /* align */ if (!check_simd_memory_access_align( - opcode, align, error_buf, error_buf_size)) { + opcode, align, error_buf, error_buf_size)) { goto fail; } @@ -8354,15 +8354,15 @@ fail_data_cnt_sec_require: if (replace[opcode - SIMD_i8x16_extract_lane_s]) { if (!(wasm_loader_pop_frame_ref( - loader_ctx, - replace[opcode - SIMD_i8x16_extract_lane_s], - error_buf, error_buf_size))) + loader_ctx, + replace[opcode - SIMD_i8x16_extract_lane_s], + error_buf, error_buf_size))) goto fail; } POP_AND_PUSH( - VALUE_TYPE_V128, - push_type[opcode - SIMD_i8x16_extract_lane_s]); + VALUE_TYPE_V128, + push_type[opcode - SIMD_i8x16_extract_lane_s]); break; } @@ -8463,7 +8463,7 @@ fail_data_cnt_sec_require: read_leb_uint32(p, p_end, align); /* align */ if (!check_simd_memory_access_align( - opcode, align, error_buf, error_buf_size)) { + opcode, align, error_buf, error_buf_size)) { goto fail; } @@ -8491,7 +8491,7 @@ fail_data_cnt_sec_require: read_leb_uint32(p, p_end, align); /* align */ if (!check_simd_memory_access_align( - opcode, align, error_buf, error_buf_size)) { + opcode, align, error_buf, error_buf_size)) { goto fail; } @@ -8864,10 +8864,9 @@ fail_data_cnt_sec_require: #endif if (opcode != WASM_OP_ATOMIC_FENCE) { CHECK_MEMORY(); - read_leb_uint32(p, p_end, align); /* align */ + read_leb_uint32(p, p_end, align); /* align */ read_leb_uint32(p, p_end, mem_offset); /* offset */ - if (!check_memory_align_equal(opcode, align, - error_buf, + if (!check_memory_align_equal(opcode, align, error_buf, error_buf_size)) { goto fail; } @@ -8990,8 +8989,8 @@ fail_data_cnt_sec_require: break; default: set_error_buf_v(error_buf, error_buf_size, - "%s %02x %02x", - "unsupported opcode", 0xfe, opcode); + "%s %02x %02x", "unsupported opcode", + 0xfe, opcode); goto fail; } break; @@ -9000,10 +8999,9 @@ fail_data_cnt_sec_require: default: #if WASM_ENABLE_REF_TYPES != 0 -unsupported_opcode: + unsupported_opcode: #endif - set_error_buf_v(error_buf, error_buf_size, - "%s %02x", + set_error_buf_v(error_buf, error_buf_size, "%s %02x", "unsupported opcode", opcode); goto fail; } @@ -9025,15 +9023,14 @@ unsupported_opcode: func->const_cell_num = loader_ctx->const_cell_num; if (func->const_cell_num > 0) { - if (!(func->consts = func_const = - loader_malloc(func->const_cell_num * 4, - error_buf, error_buf_size))) + if (!(func->consts = func_const = loader_malloc( + func->const_cell_num * 4, error_buf, error_buf_size))) goto fail; func_const_end = func->consts + func->const_cell_num * 4; /* reverse the const buf */ for (int i = loader_ctx->num_const - 1; i >= 0; i--) { - Const *c = (Const*)(loader_ctx->const_buf + i * sizeof(Const)); + Const *c = (Const *)(loader_ctx->const_buf + i * sizeof(Const)); if (c->value_type == VALUE_TYPE_F64 || c->value_type == VALUE_TYPE_I64) { bh_memcpy_s(func_const, (uint32)(func_const_end - func_const), @@ -9048,8 +9045,8 @@ unsupported_opcode: } } - func->max_stack_cell_num = loader_ctx->preserved_local_offset - - loader_ctx->start_dynamic_offset + 1; + func->max_stack_cell_num = loader_ctx->preserved_local_offset + - loader_ctx->start_dynamic_offset + 1; #else func->max_stack_cell_num = loader_ctx->max_stack_cell_num; #endif @@ -9085,4 +9082,3 @@ wasm_get_ref_types_flag() return ref_types_flag; } #endif - diff --git a/core/iwasm/interpreter/wasm_loader.h b/core/iwasm/interpreter/wasm_loader.h index 03b3b8bd..403df27f 100644 --- a/core/iwasm/interpreter/wasm_loader.h +++ b/core/iwasm/interpreter/wasm_loader.h @@ -23,8 +23,9 @@ extern "C" { * * @return return module loaded, NULL if failed */ -WASMModule* -wasm_loader_load(const uint8 *buf, uint32 size, char *error_buf, uint32 error_buf_size); +WASMModule * +wasm_loader_load(const uint8 *buf, uint32 size, char *error_buf, + uint32 error_buf_size); /** * Load a WASM module from a specified WASM section list. @@ -35,9 +36,9 @@ wasm_loader_load(const uint8 *buf, uint32 size, char *error_buf, uint32 error_bu * * @return return WASM module loaded, NULL if failed */ -WASMModule* -wasm_loader_load_from_sections(WASMSection *section_list, - char *error_buf, uint32 error_buf_size); +WASMModule * +wasm_loader_load_from_sections(WASMSection *section_list, char *error_buf, + uint32 error_buf_size); /** * Unload a WASM module. @@ -64,12 +65,9 @@ wasm_loader_unload(WASMModule *module); */ bool -wasm_loader_find_block_addr(WASMExecEnv *exec_env, - BlockAddr *block_addr_cache, - const uint8 *start_addr, - const uint8 *code_end_addr, - uint8 block_type, - uint8 **p_else_addr, +wasm_loader_find_block_addr(WASMExecEnv *exec_env, BlockAddr *block_addr_cache, + const uint8 *start_addr, const uint8 *code_end_addr, + uint8 block_type, uint8 **p_else_addr, uint8 **p_end_addr); #if WASM_ENABLE_REF_TYPES != 0 diff --git a/core/iwasm/interpreter/wasm_mini_loader.c b/core/iwasm/interpreter/wasm_mini_loader.c index c4bcb505..ac299f14 100644 --- a/core/iwasm/interpreter/wasm_mini_loader.c +++ b/core/iwasm/interpreter/wasm_mini_loader.c @@ -14,24 +14,26 @@ /* Read a value of given type from the address pointed to by the given pointer and increase the pointer to the position just after the value being read. */ -#define TEMPLATE_READ_VALUE(Type, p) \ +#define TEMPLATE_READ_VALUE(Type, p) \ (p += sizeof(Type), *(Type *)(p - sizeof(Type))) static void set_error_buf(char *error_buf, uint32 error_buf_size, const char *string) { if (error_buf != NULL) - snprintf(error_buf, error_buf_size, - "WASM module load failed: %s", string); + snprintf(error_buf, error_buf_size, "WASM module load failed: %s", + string); } -#define CHECK_BUF(buf, buf_end, length) do { \ - bh_assert(buf + length <= buf_end); \ - } while (0) +#define CHECK_BUF(buf, buf_end, length) \ + do { \ + bh_assert(buf + length <= buf_end); \ + } while (0) -#define CHECK_BUF1(buf, buf_end, length) do { \ - bh_assert(buf + length <= buf_end); \ - } while (0) +#define CHECK_BUF1(buf, buf_end, length) \ + do { \ + bh_assert(buf + length <= buf_end); \ + } while (0) #define skip_leb(p) while (*p++ & 0x80) #define skip_leb_int64(p, p_end) skip_leb(p) @@ -60,9 +62,8 @@ is_64bit_type(uint8 type) } static void -read_leb(uint8 **p_buf, const uint8 *buf_end, - uint32 maxbits, bool sign, uint64 *p_result, - char* error_buf, uint32 error_buf_size) +read_leb(uint8 **p_buf, const uint8 *buf_end, uint32 maxbits, bool sign, + uint64 *p_result, char *error_buf, uint32 error_buf_size) { const uint8 *buf = *p_buf; uint64 result = 0; @@ -125,40 +126,41 @@ read_leb(uint8 **p_buf, const uint8 *buf_end, *p_result = result; } -#define read_uint8(p) TEMPLATE_READ_VALUE(uint8, p) +#define read_uint8(p) TEMPLATE_READ_VALUE(uint8, p) #define read_uint32(p) TEMPLATE_READ_VALUE(uint32, p) -#define read_bool(p) TEMPLATE_READ_VALUE(bool, p) +#define read_bool(p) TEMPLATE_READ_VALUE(bool, p) -#define read_leb_int64(p, p_end, res) do { \ - uint64 res64; \ - read_leb((uint8**)&p, p_end, 64, true, &res64, \ - error_buf, error_buf_size); \ - res = (int64)res64; \ -} while (0) +#define read_leb_int64(p, p_end, res) \ + do { \ + uint64 res64; \ + read_leb((uint8 **)&p, p_end, 64, true, &res64, error_buf, \ + error_buf_size); \ + res = (int64)res64; \ + } while (0) -#define read_leb_uint32(p, p_end, res) do { \ - uint64 res64; \ - read_leb((uint8**)&p, p_end, 32, false, &res64, \ - error_buf, error_buf_size); \ - res = (uint32)res64; \ -} while (0) +#define read_leb_uint32(p, p_end, res) \ + do { \ + uint64 res64; \ + read_leb((uint8 **)&p, p_end, 32, false, &res64, error_buf, \ + error_buf_size); \ + res = (uint32)res64; \ + } while (0) -#define read_leb_int32(p, p_end, res) do { \ - uint64 res64; \ - read_leb((uint8**)&p, p_end, 32, true, &res64, \ - error_buf, error_buf_size); \ - res = (int32)res64; \ -} while (0) +#define read_leb_int32(p, p_end, res) \ + do { \ + uint64 res64; \ + read_leb((uint8 **)&p, p_end, 32, true, &res64, error_buf, \ + error_buf_size); \ + res = (int32)res64; \ + } while (0) static void * loader_malloc(uint64 size, char *error_buf, uint32 error_buf_size) { void *mem; - if (size >= UINT32_MAX - || !(mem = wasm_runtime_malloc((uint32)size))) { - set_error_buf(error_buf, error_buf_size, - "allocate memory failed"); + if (size >= UINT32_MAX || !(mem = wasm_runtime_malloc((uint32)size))) { + set_error_buf(error_buf, error_buf_size, "allocate memory failed"); return NULL; } @@ -168,7 +170,7 @@ loader_malloc(uint64 size, char *error_buf, uint32 error_buf_size) static char * const_str_list_insert(const uint8 *str, uint32 len, WASMModule *module, - char *error_buf, uint32 error_buf_size) + char *error_buf, uint32 error_buf_size) { StringNode *node, *node_next; @@ -176,8 +178,7 @@ const_str_list_insert(const uint8 *str, uint32 len, WASMModule *module, node = module->const_str_list; while (node) { node_next = node->next; - if (strlen(node->str) == len - && !memcmp(node->str, str, len)) + if (strlen(node->str) == len && !memcmp(node->str, str, len)) break; node = node_next; } @@ -187,12 +188,12 @@ const_str_list_insert(const uint8 *str, uint32 len, WASMModule *module, return node->str; } - if (!(node = loader_malloc(sizeof(StringNode) + len + 1, - error_buf, error_buf_size))) { + if (!(node = loader_malloc(sizeof(StringNode) + len + 1, error_buf, + error_buf_size))) { return NULL; } - node->str = ((char*)node) + sizeof(StringNode); + node->str = ((char *)node) + sizeof(StringNode); bh_memcpy_s(node->str, len + 1, str, len); node->str[len] = '\0'; @@ -212,8 +213,8 @@ const_str_list_insert(const uint8 *str, uint32 len, WASMModule *module, static bool load_init_expr(const uint8 **p_buf, const uint8 *buf_end, - InitializerExpression *init_expr, uint8 type, - char *error_buf, uint32 error_buf_size) + InitializerExpression *init_expr, uint8 type, char *error_buf, + uint32 error_buf_size) { const uint8 *p = *p_buf, *p_end = buf_end; uint8 flag, end_byte, *p_float; @@ -238,7 +239,7 @@ load_init_expr(const uint8 **p_buf, const uint8 *buf_end, case INIT_EXPR_TYPE_F32_CONST: bh_assert(type == VALUE_TYPE_F32); CHECK_BUF(p, p_end, 4); - p_float = (uint8*)&init_expr->u.f32; + p_float = (uint8 *)&init_expr->u.f32; for (i = 0; i < sizeof(float32); i++) *p_float++ = *p++; break; @@ -246,7 +247,7 @@ load_init_expr(const uint8 **p_buf, const uint8 *buf_end, case INIT_EXPR_TYPE_F64_CONST: bh_assert(type == VALUE_TYPE_F64); CHECK_BUF(p, p_end, 8); - p_float = (uint8*)&init_expr->u.f64; + p_float = (uint8 *)&init_expr->u.f64; for (i = 0; i < sizeof(float64); i++) *p_float++ = *p++; break; @@ -311,9 +312,9 @@ load_type_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, if (type_count) { module->type_count = type_count; - total_size = sizeof(WASMType*) * (uint64)type_count; - if (!(module->types = loader_malloc - (total_size, error_buf, error_buf_size))) { + total_size = sizeof(WASMType *) * (uint64)type_count; + if (!(module->types = + loader_malloc(total_size, error_buf, error_buf_size))) { return false; } @@ -334,10 +335,10 @@ load_type_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, bh_assert(param_count <= UINT16_MAX && result_count <= UINT16_MAX); - total_size = offsetof(WASMType, types) + - sizeof(uint8) * (uint64)(param_count + result_count); + total_size = offsetof(WASMType, types) + + sizeof(uint8) * (uint64)(param_count + result_count); if (!(type = module->types[i] = - loader_malloc(total_size, error_buf, error_buf_size))) { + loader_malloc(total_size, error_buf, error_buf_size))) { return false; } @@ -355,9 +356,10 @@ load_type_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, } param_cell_num = wasm_get_cell_num(type->types, param_count); - ret_cell_num = wasm_get_cell_num(type->types + param_count, - result_count); - bh_assert(param_cell_num <= UINT16_MAX && ret_cell_num <= UINT16_MAX); + ret_cell_num = + wasm_get_cell_num(type->types + param_count, result_count); + bh_assert(param_cell_num <= UINT16_MAX + && ret_cell_num <= UINT16_MAX); type->param_cell_num = (uint16)param_cell_num; type->ret_cell_num = (uint16)ret_cell_num; } @@ -373,7 +375,7 @@ static void adjust_table_max_size(uint32 init_size, uint32 max_size_flag, uint32 *max_size) { uint32 default_max_size = - init_size * 2 > TABLE_MAX_SIZE ? init_size * 2 : TABLE_MAX_SIZE; + init_size * 2 > TABLE_MAX_SIZE ? init_size * 2 : TABLE_MAX_SIZE; if (max_size_flag) { /* module defines the table limitation */ @@ -381,7 +383,7 @@ adjust_table_max_size(uint32 init_size, uint32 max_size_flag, uint32 *max_size) if (init_size < *max_size) { *max_size = - *max_size < default_max_size ? *max_size : default_max_size; + *max_size < default_max_size ? *max_size : default_max_size; } } else { @@ -393,10 +395,9 @@ adjust_table_max_size(uint32 init_size, uint32 max_size_flag, uint32 *max_size) static bool load_function_import(const uint8 **p_buf, const uint8 *buf_end, const WASMModule *parent_module, - const char *sub_module_name, - const char *function_name, - WASMFunctionImport *function, - char *error_buf, uint32 error_buf_size) + const char *sub_module_name, const char *function_name, + WASMFunctionImport *function, char *error_buf, + uint32 error_buf_size) { const uint8 *p = *p_buf, *p_end = buf_end; uint32 declare_type_index = 0; @@ -415,12 +416,9 @@ load_function_import(const uint8 **p_buf, const uint8 *buf_end, declare_func_type = parent_module->types[declare_type_index]; /* check built-in modules */ - linked_func = wasm_native_resolve_symbol(sub_module_name, - function_name, - declare_func_type, - &linked_signature, - &linked_attachment, - &linked_call_conv_raw); + linked_func = wasm_native_resolve_symbol( + sub_module_name, function_name, declare_func_type, &linked_signature, + &linked_attachment, &linked_call_conv_raw); function->module_name = (char *)sub_module_name; function->field_name = (char *)function_name; @@ -434,10 +432,8 @@ load_function_import(const uint8 **p_buf, const uint8 *buf_end, static bool load_table_import(const uint8 **p_buf, const uint8 *buf_end, - WASMModule *parent_module, - const char *sub_module_name, - const char *table_name, - WASMTableImport *table, + WASMModule *parent_module, const char *sub_module_name, + const char *table_name, WASMTableImport *table, char *error_buf, uint32 error_buf_size) { const uint8 *p = *p_buf, *p_end = buf_end; @@ -449,8 +445,8 @@ load_table_import(const uint8 **p_buf, const uint8 *buf_end, declare_elem_type = read_uint8(p); bh_assert(VALUE_TYPE_FUNCREF == declare_elem_type #if WASM_ENABLE_REF_TYPES != 0 - || (wasm_get_ref_types_flag() && - VALUE_TYPE_EXTERNREF == declare_elem_type) + || (wasm_get_ref_types_flag() + && VALUE_TYPE_EXTERNREF == declare_elem_type) #endif ); @@ -465,8 +461,8 @@ load_table_import(const uint8 **p_buf, const uint8 *buf_end, &declare_max_size); *p_buf = p; - bh_assert(!((declare_max_size_flag & 1) - && declare_init_size > declare_max_size)); + bh_assert( + !((declare_max_size_flag & 1) && declare_init_size > declare_max_size)); /* now we believe all declaration are ok */ table->elem_type = declare_elem_type; @@ -481,10 +477,8 @@ wasm_runtime_memory_pool_size(); static bool load_memory_import(const uint8 **p_buf, const uint8 *buf_end, - WASMModule *parent_module, - const char *sub_module_name, - const char *memory_name, - WASMMemoryImport *memory, + WASMModule *parent_module, const char *sub_module_name, + const char *memory_name, WASMMemoryImport *memory, char *error_buf, uint32 error_buf_size) { const uint8 *p = *p_buf, *p_end = buf_end; @@ -528,10 +522,9 @@ load_memory_import(const uint8 **p_buf, const uint8 *buf_end, static bool load_global_import(const uint8 **p_buf, const uint8 *buf_end, - const WASMModule *parent_module, - char *sub_module_name, char *global_name, - WASMGlobalImport *global, - char *error_buf, uint32 error_buf_size) + const WASMModule *parent_module, char *sub_module_name, + char *global_name, WASMGlobalImport *global, char *error_buf, + uint32 error_buf_size) { const uint8 *p = *p_buf, *p_end = buf_end; uint8 declare_type = 0; @@ -550,8 +543,8 @@ load_global_import(const uint8 **p_buf, const uint8 *buf_end, #if WASM_ENABLE_LIBC_BUILTIN != 0 /* check built-in modules */ - ret = wasm_native_lookup_libc_builtin_global(sub_module_name, - global_name, global); + ret = wasm_native_lookup_libc_builtin_global(sub_module_name, global_name, + global); if (ret) { bh_assert(global->type == declare_type && global->is_mutable != declare_mutable); @@ -578,8 +571,8 @@ load_table(const uint8 **p_buf, const uint8 *buf_end, WASMTable *table, table->elem_type = read_uint8(p); bh_assert((VALUE_TYPE_FUNCREF == table->elem_type) #if WASM_ENABLE_REF_TYPES != 0 - || (wasm_get_ref_types_flag() && - VALUE_TYPE_EXTERNREF == table->elem_type) + || (wasm_get_ref_types_flag() + && VALUE_TYPE_EXTERNREF == table->elem_type) #endif ); @@ -659,10 +652,11 @@ load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, uint8 u8, kind; /* insert builtin module names into const str list */ - if (!const_str_list_insert((uint8*)"env", 3, module, error_buf, error_buf_size) - || !const_str_list_insert((uint8*)"wasi_unstable", 13, module, + if (!const_str_list_insert((uint8 *)"env", 3, module, error_buf, + error_buf_size) + || !const_str_list_insert((uint8 *)"wasi_unstable", 13, module, error_buf, error_buf_size) - || !const_str_list_insert((uint8*)"wasi_snapshot_preview1", 22, module, + || !const_str_list_insert((uint8 *)"wasi_snapshot_preview1", 22, module, error_buf, error_buf_size)) { return false; } @@ -672,8 +666,8 @@ load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, if (import_count) { module->import_count = import_count; total_size = sizeof(WASMImport) * (uint64)import_count; - if (!(module->imports = loader_malloc - (total_size, error_buf, error_buf_size))) { + if (!(module->imports = + loader_malloc(total_size, error_buf, error_buf_size))) { return false; } @@ -712,9 +706,9 @@ load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, module->import_table_count++; bh_assert( #if WASM_ENABLE_REF_TYPES != 0 - wasm_get_ref_types_flag() || + wasm_get_ref_types_flag() || #endif - module->import_table_count <= 1); + module->import_table_count <= 1); break; @@ -746,11 +740,12 @@ load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, module->imports + module->import_function_count; if (module->import_memory_count) import_memories = module->import_memories = - module->imports + module->import_function_count + module->import_table_count; + module->imports + module->import_function_count + + module->import_table_count; if (module->import_global_count) import_globals = module->import_globals = - module->imports + module->import_function_count + module->import_table_count - + module->import_memory_count; + module->imports + module->import_function_count + + module->import_table_count + module->import_memory_count; p = p_old; @@ -762,7 +757,7 @@ load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, read_leb_uint32(p, p_end, name_len); CHECK_BUF(p, p_end, name_len); if (!(sub_module_name = const_str_list_insert( - p, name_len, module, error_buf, error_buf_size))) { + p, name_len, module, error_buf, error_buf_size))) { return false; } p += name_len; @@ -771,7 +766,7 @@ load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, read_leb_uint32(p, p_end, name_len); CHECK_BUF(p, p_end, name_len); if (!(field_name = const_str_list_insert( - p, name_len, module, error_buf, error_buf_size))) { + p, name_len, module, error_buf, error_buf_size))) { return false; } p += name_len; @@ -780,16 +775,15 @@ load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, /* 0x00/0x01/0x02/0x03 */ kind = read_uint8(p); - LOG_DEBUG("import #%d: (%s, %s), kind: %d", - i, sub_module_name, field_name, kind); + LOG_DEBUG("import #%d: (%s, %s), kind: %d", i, sub_module_name, + field_name, kind); switch (kind) { case IMPORT_KIND_FUNC: /* import function */ bh_assert(import_functions); import = import_functions++; - if (!load_function_import(&p, p_end, module, - sub_module_name, field_name, - &import->u.function, - error_buf, error_buf_size)) { + if (!load_function_import( + &p, p_end, module, sub_module_name, field_name, + &import->u.function, error_buf, error_buf_size)) { return false; } break; @@ -797,9 +791,8 @@ load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, case IMPORT_KIND_TABLE: /* import table */ bh_assert(import_tables); import = import_tables++; - if (!load_table_import(&p, p_end, module, - sub_module_name, field_name, - &import->u.table, + if (!load_table_import(&p, p_end, module, sub_module_name, + field_name, &import->u.table, error_buf, error_buf_size)) { LOG_DEBUG("can not import such a table (%s,%s)", sub_module_name, field_name); @@ -810,9 +803,8 @@ load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, case IMPORT_KIND_MEMORY: /* import memory */ bh_assert(import_memories); import = import_memories++; - if (!load_memory_import(&p, p_end, module, - sub_module_name, field_name, - &import->u.memory, + if (!load_memory_import(&p, p_end, module, sub_module_name, + field_name, &import->u.memory, error_buf, error_buf_size)) { return false; } @@ -821,9 +813,8 @@ load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, case IMPORT_KIND_GLOBAL: /* import global */ bh_assert(import_globals); import = import_globals++; - if (!load_global_import(&p, p_end, module, - sub_module_name, field_name, - &import->u.global, + if (!load_global_import(&p, p_end, module, sub_module_name, + field_name, &import->u.global, error_buf, error_buf_size)) { return false; } @@ -844,7 +835,8 @@ load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, import = module->import_functions; for (i = 0; i < module->import_function_count; i++, import++) { if (!strcmp(import->u.names.module_name, "wasi_unstable") - || !strcmp(import->u.names.module_name, "wasi_snapshot_preview1")) { + || !strcmp(import->u.names.module_name, + "wasi_snapshot_preview1")) { module->is_wasi_module = true; break; } @@ -862,8 +854,8 @@ load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, } static bool -init_function_local_offsets(WASMFunction *func, - char *error_buf, uint32 error_buf_size) +init_function_local_offsets(WASMFunction *func, char *error_buf, + uint32 error_buf_size) { WASMType *param_type = func->func_type; uint32 param_count = param_type->param_count; @@ -875,7 +867,7 @@ init_function_local_offsets(WASMFunction *func, if (total_size > 0 && !(func->local_offsets = - loader_malloc(total_size, error_buf, error_buf_size))) { + loader_malloc(total_size, error_buf, error_buf_size))) { return false; } @@ -896,8 +888,8 @@ init_function_local_offsets(WASMFunction *func, static bool load_function_section(const uint8 *buf, const uint8 *buf_end, const uint8 *buf_code, const uint8 *buf_code_end, - WASMModule *module, - char *error_buf, uint32 error_buf_size) + WASMModule *module, char *error_buf, + uint32 error_buf_size) { const uint8 *p = buf, *p_end = buf_end; const uint8 *p_code = buf_code, *p_code_end, *p_code_save; @@ -917,9 +909,9 @@ load_function_section(const uint8 *buf, const uint8 *buf_end, if (func_count) { module->function_count = func_count; - total_size = sizeof(WASMFunction*) * (uint64)func_count; + total_size = sizeof(WASMFunction *) * (uint64)func_count; if (!(module->functions = - loader_malloc(total_size, error_buf, error_buf_size))) { + loader_malloc(total_size, error_buf, error_buf_size))) { return false; } @@ -929,8 +921,7 @@ load_function_section(const uint8 *buf, const uint8 *buf_end, bh_assert(type_index < module->type_count); read_leb_uint32(p_code, buf_code_end, code_size); - bh_assert(code_size > 0 - && p_code + code_size <= buf_code_end); + bh_assert(code_size > 0 && p_code + code_size <= buf_code_end); /* Resolve local set count */ p_code_end = p_code + code_size; @@ -954,7 +945,7 @@ load_function_section(const uint8 *buf, const uint8 *buf_end, total_size = sizeof(WASMFunction) + (uint64)local_count; if (!(func = module->functions[i] = - loader_malloc(total_size, error_buf, error_buf_size))) { + loader_malloc(total_size, error_buf, error_buf_size))) { return false; } @@ -962,7 +953,7 @@ load_function_section(const uint8 *buf, const uint8 *buf_end, func->func_type = module->types[type_index]; func->local_count = local_count; if (local_count > 0) - func->local_types = (uint8*)func + sizeof(WASMFunction); + func->local_types = (uint8 *)func + sizeof(WASMFunction); func->code_size = code_size; /* * we shall make a copy of code body [p_code, p_code + code_size] @@ -974,7 +965,7 @@ load_function_section(const uint8 *buf, const uint8 *buf_end, * memcpy(code_body_cp, p_code, code_size); * func->code = code_body_cp; */ - func->code = (uint8*)p_code; + func->code = (uint8 *)p_code; /* Load each local type */ p_code = p_code_save; @@ -983,8 +974,7 @@ load_function_section(const uint8 *buf, const uint8 *buf_end, read_leb_uint32(p_code, buf_code_end, sub_local_count); bh_assert(sub_local_count && local_type_index <= UINT32_MAX - sub_local_count - && local_type_index + sub_local_count - <= local_count); + && local_type_index + sub_local_count <= local_count); CHECK_BUF(p_code, buf_code_end, 1); /* 0x7F/0x7E/0x7D/0x7C */ @@ -1020,10 +1010,8 @@ load_function_section(const uint8 *buf, const uint8 *buf_end, } static bool -check_function_index(const WASMModule *module, - uint32 function_index, - char *error_buf, - uint32 error_buf_size) +check_function_index(const WASMModule *module, uint32 function_index, + char *error_buf, uint32 error_buf_size) { return (function_index < module->import_function_count + module->function_count); @@ -1041,15 +1029,15 @@ load_table_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, read_leb_uint32(p, p_end, table_count); bh_assert( #if WASM_ENABLE_REF_TYPES != 0 - wasm_get_ref_types_flag() || + wasm_get_ref_types_flag() || #endif - module->import_table_count + table_count <= 1); + module->import_table_count + table_count <= 1); if (table_count) { module->table_count = table_count; total_size = sizeof(WASMTable) * (uint64)table_count; - if (!(module->tables = loader_malloc - (total_size, error_buf, error_buf_size))) { + if (!(module->tables = + loader_malloc(total_size, error_buf, error_buf_size))) { return false; } @@ -1080,8 +1068,8 @@ load_memory_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, if (memory_count) { module->memory_count = memory_count; total_size = sizeof(WASMMemory) * (uint64)memory_count; - if (!(module->memories = loader_malloc - (total_size, error_buf, error_buf_size))) { + if (!(module->memories = + loader_malloc(total_size, error_buf, error_buf_size))) { return false; } @@ -1112,14 +1100,14 @@ load_global_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, if (global_count) { module->global_count = global_count; total_size = sizeof(WASMGlobal) * (uint64)global_count; - if (!(module->globals = loader_malloc - (total_size, error_buf, error_buf_size))) { + if (!(module->globals = + loader_malloc(total_size, error_buf, error_buf_size))) { return false; } global = module->globals; - for(i = 0; i < global_count; i++, global++) { + for (i = 0; i < global_count; i++, global++) { CHECK_BUF(p, p_end, 2); global->type = read_uint8(p); mutable = read_uint8(p); @@ -1127,8 +1115,8 @@ load_global_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, global->is_mutable = mutable ? true : false; /* initialize expression */ - if (!load_init_expr(&p, p_end, &(global->init_expr), - global->type, error_buf, error_buf_size)) + if (!load_init_expr(&p, p_end, &(global->init_expr), global->type, + error_buf, error_buf_size)) return false; if (INIT_EXPR_TYPE_GET_GLOBAL == global->init_expr.init_expr_type) { @@ -1146,7 +1134,7 @@ load_global_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, == global->init_expr.init_expr_type) { bh_assert(global->init_expr.u.ref_index < module->import_function_count - + module->function_count); + + module->function_count); } } } @@ -1172,13 +1160,13 @@ load_export_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, if (export_count) { module->export_count = export_count; total_size = sizeof(WASMExport) * (uint64)export_count; - if (!(module->exports = loader_malloc - (total_size, error_buf, error_buf_size))) { + if (!(module->exports = + loader_malloc(total_size, error_buf, error_buf_size))) { return false; } export = module->exports; - for (i = 0; i < export_count; i++, export++) { + for (i = 0; i < export_count; i++, export ++) { read_leb_uint32(p, p_end, str_len); CHECK_BUF(p, p_end, str_len); @@ -1188,8 +1176,8 @@ load_export_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, && memcmp(name, p, str_len) == 0)); } - if (!(export->name = const_str_list_insert(p, str_len, module, - error_buf, error_buf_size))) { + if (!(export->name = const_str_list_insert( + p, str_len, module, error_buf, error_buf_size))) { return false; } @@ -1199,26 +1187,26 @@ load_export_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, read_leb_uint32(p, p_end, index); export->index = index; - switch(export->kind) { + switch (export->kind) { /* function index */ case EXPORT_KIND_FUNC: bh_assert(index < module->function_count - + module->import_function_count); + + module->import_function_count); break; /* table index */ case EXPORT_KIND_TABLE: bh_assert(index < module->table_count - + module->import_table_count); + + module->import_table_count); break; /* memory index */ case EXPORT_KIND_MEMORY: bh_assert(index < module->memory_count - + module->import_memory_count); + + module->import_memory_count); break; /* global index */ case EXPORT_KIND_GLOBAL: bh_assert(index < module->global_count - + module->import_global_count); + + module->import_global_count); break; default: bh_assert(0); @@ -1234,14 +1222,14 @@ load_export_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, } static bool -check_table_index(const WASMModule *module, uint32 table_index, - char *error_buf, uint32 error_buf_size) +check_table_index(const WASMModule *module, uint32 table_index, char *error_buf, + uint32 error_buf_size) { if ( #if WASM_ENABLE_REF_TYPES != 0 - !wasm_get_ref_types_flag() && + !wasm_get_ref_types_flag() && #endif - table_index != 0) { + table_index != 0) { return false; } @@ -1253,9 +1241,8 @@ check_table_index(const WASMModule *module, uint32 table_index, #if WASM_ENABLE_REF_TYPES != 0 static bool -load_table_index(const uint8 **p_buf, const uint8 *buf_end, - WASMModule *module, uint32 *p_table_index, - char *error_buf, uint32 error_buf_size) +load_table_index(const uint8 **p_buf, const uint8 *buf_end, WASMModule *module, + uint32 *p_table_index, char *error_buf, uint32 error_buf_size) { const uint8 *p = *p_buf, *p_end = buf_end; uint32 table_index; @@ -1271,9 +1258,8 @@ load_table_index(const uint8 **p_buf, const uint8 *buf_end, } static bool -load_elem_type(const uint8 **p_buf, const uint8 *buf_end, - uint32 *p_elem_type, bool elemkind_zero, - char *error_buf, uint32 error_buf_size) +load_elem_type(const uint8 **p_buf, const uint8 *buf_end, uint32 *p_elem_type, + bool elemkind_zero, char *error_buf, uint32 error_buf_size) { const uint8 *p = *p_buf, *p_end = buf_end; uint8 elem_type; @@ -1301,8 +1287,7 @@ load_elem_type(const uint8 **p_buf, const uint8 *buf_end, static bool load_func_index_vec(const uint8 **p_buf, const uint8 *buf_end, WASMModule *module, WASMTableSeg *table_segment, - bool use_init_expr, - char *error_buf, uint32 error_buf_size) + bool use_init_expr, char *error_buf, uint32 error_buf_size) { const uint8 *p = *p_buf, *p_end = buf_end; uint32 function_count, function_index = 0, i; @@ -1312,8 +1297,8 @@ load_func_index_vec(const uint8 **p_buf, const uint8 *buf_end, table_segment->function_count = function_count; total_size = sizeof(uint32) * (uint64)function_count; if (total_size > 0 - && !(table_segment->func_indexes = (uint32 *) - loader_malloc(total_size, error_buf, error_buf_size))) { + && !(table_segment->func_indexes = (uint32 *)loader_malloc( + total_size, error_buf, error_buf_size))) { return false; } @@ -1355,8 +1340,9 @@ load_func_index_vec(const uint8 **p_buf, const uint8 *buf_end, } static bool -load_table_segment_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, - char *error_buf, uint32 error_buf_size) +load_table_segment_section(const uint8 *buf, const uint8 *buf_end, + WASMModule *module, char *error_buf, + uint32 error_buf_size) { const uint8 *p = buf, *p_end = buf_end; uint32 table_segment_count, i, table_index, function_count; @@ -1368,8 +1354,8 @@ load_table_segment_section(const uint8 *buf, const uint8 *buf_end, WASMModule *m if (table_segment_count) { module->table_seg_count = table_segment_count; total_size = sizeof(WASMTableSeg) * (uint64)table_segment_count; - if (!(module->table_segments = loader_malloc - (total_size, error_buf, error_buf_size))) { + if (!(module->table_segments = + loader_malloc(total_size, error_buf, error_buf_size))) { return false; } @@ -1395,14 +1381,14 @@ load_table_segment_section(const uint8 *buf, const uint8 *buf_end, WASMModule *m return false; if (!load_init_expr( - &p, p_end, &table_segment->base_offset, - VALUE_TYPE_I32, error_buf, error_buf_size)) + &p, p_end, &table_segment->base_offset, + VALUE_TYPE_I32, error_buf, error_buf_size)) return false; if (!load_func_index_vec( - &p, p_end, module, table_segment, - table_segment->mode == 0 ? false : true, - error_buf, error_buf_size)) + &p, p_end, module, table_segment, + table_segment->mode == 0 ? false : true, + error_buf, error_buf_size)) return false; break; /* elemkind + passive/declarative */ @@ -1425,18 +1411,18 @@ load_table_segment_section(const uint8 *buf, const uint8 *buf_end, WASMModule *m error_buf, error_buf_size)) return false; if (!load_init_expr( - &p, p_end, &table_segment->base_offset, - VALUE_TYPE_I32, error_buf, error_buf_size)) + &p, p_end, &table_segment->base_offset, + VALUE_TYPE_I32, error_buf, error_buf_size)) return false; if (!load_elem_type( - &p, p_end, &table_segment->elem_type, - table_segment->mode == 2 ? true : false, - error_buf, error_buf_size)) + &p, p_end, &table_segment->elem_type, + table_segment->mode == 2 ? true : false, + error_buf, error_buf_size)) return false; if (!load_func_index_vec( - &p, p_end, module, table_segment, - table_segment->mode == 2 ? false : true, - error_buf, error_buf_size)) + &p, p_end, module, table_segment, + table_segment->mode == 2 ? false : true, + error_buf, error_buf_size)) return false; break; case 5: @@ -1446,8 +1432,8 @@ load_table_segment_section(const uint8 *buf, const uint8 *buf_end, WASMModule *m error_buf, error_buf_size)) return false; if (!load_func_index_vec(&p, p_end, module, - table_segment, true, - error_buf, error_buf_size)) + table_segment, true, error_buf, + error_buf_size)) return false; break; default: @@ -1473,7 +1459,7 @@ load_table_segment_section(const uint8 *buf, const uint8 *buf_end, WASMModule *m total_size = sizeof(uint32) * (uint64)function_count; if (total_size > 0 && !(table_segment->func_indexes = (uint32 *)loader_malloc( - total_size, error_buf, error_buf_size))) { + total_size, error_buf, error_buf_size))) { return false; } @@ -1493,8 +1479,8 @@ load_table_segment_section(const uint8 *buf, const uint8 *buf_end, WASMModule *m static bool load_data_segment_section(const uint8 *buf, const uint8 *buf_end, - WASMModule *module, - char *error_buf, uint32 error_buf_size) + WASMModule *module, char *error_buf, + uint32 error_buf_size) { const uint8 *p = buf, *p_end = buf_end; uint32 data_seg_count, i, mem_index, data_seg_len; @@ -1515,9 +1501,9 @@ load_data_segment_section(const uint8 *buf, const uint8 *buf_end, if (data_seg_count) { module->data_seg_count = data_seg_count; - total_size = sizeof(WASMDataSeg*) * (uint64)data_seg_count; - if (!(module->data_segments = loader_malloc - (total_size, error_buf, error_buf_size))) { + total_size = sizeof(WASMDataSeg *) * (uint64)data_seg_count; + if (!(module->data_segments = + loader_malloc(total_size, error_buf, error_buf_size))) { return false; } @@ -1537,9 +1523,9 @@ load_data_segment_section(const uint8 *buf, const uint8 *buf_end, case 0x02: /* read following memory index */ read_leb_uint32(p, p_end, mem_index); -check_mem_index: + check_mem_index: bh_assert(mem_index < module->import_memory_count - + module->memory_count); + + module->memory_count); break; case 0x03: default: @@ -1547,8 +1533,8 @@ check_mem_index: break; } #else - bh_assert(mem_index < module->import_memory_count - + module->memory_count); + bh_assert(mem_index + < module->import_memory_count + module->memory_count); #endif /* WASM_ENABLE_BULK_MEMORY */ #if WASM_ENABLE_BULK_MEMORY != 0 @@ -1560,8 +1546,8 @@ check_mem_index: read_leb_uint32(p, p_end, data_seg_len); - if (!(dataseg = module->data_segments[i] = loader_malloc - (sizeof(WASMDataSeg), error_buf, error_buf_size))) { + if (!(dataseg = module->data_segments[i] = loader_malloc( + sizeof(WASMDataSeg), error_buf, error_buf_size))) { return false; } @@ -1570,15 +1556,16 @@ check_mem_index: if (!is_passive) #endif { - bh_memcpy_s(&dataseg->base_offset, sizeof(InitializerExpression), - &init_expr, sizeof(InitializerExpression)); + bh_memcpy_s(&dataseg->base_offset, + sizeof(InitializerExpression), &init_expr, + sizeof(InitializerExpression)); dataseg->memory_index = mem_index; } dataseg->data_length = data_seg_len; CHECK_BUF(p, p_end, data_seg_len); - dataseg->data = (uint8*)p; + dataseg->data = (uint8 *)p; p += data_seg_len; } } @@ -1590,8 +1577,9 @@ check_mem_index: #if WASM_ENABLE_BULK_MEMORY != 0 static bool -load_datacount_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, - char *error_buf, uint32 error_buf_size) +load_datacount_section(const uint8 *buf, const uint8 *buf_end, + WASMModule *module, char *error_buf, + uint32 error_buf_size) { const uint8 *p = buf, *p_end = buf_end; uint32 data_seg_count1 = 0; @@ -1606,10 +1594,8 @@ load_datacount_section(const uint8 *buf, const uint8 *buf_end, WASMModule *modul #endif static bool -load_code_section(const uint8 *buf, const uint8 *buf_end, - const uint8 *buf_func, - const uint8 *buf_func_end, - WASMModule *module, +load_code_section(const uint8 *buf, const uint8 *buf_end, const uint8 *buf_func, + const uint8 *buf_func_end, WASMModule *module, char *error_buf, uint32 error_buf_size) { const uint8 *p = buf, *p_end = buf_end; @@ -1640,14 +1626,14 @@ load_start_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, read_leb_uint32(p, p_end, start_function); - bh_assert(start_function < module->function_count - + module->import_function_count); + bh_assert(start_function + < module->function_count + module->import_function_count); if (start_function < module->import_function_count) type = module->import_functions[start_function].u.function.func_type; else type = module->functions[start_function - module->import_function_count] - ->func_type; + ->func_type; bh_assert(type->param_count == 0 && type->result_count == 0); @@ -1661,8 +1647,7 @@ load_start_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, #if WASM_ENABLE_CUSTOM_NAME_SECTION != 0 static bool -handle_name_section(const uint8 *buf, const uint8 *buf_end, - WASMModule *module, +handle_name_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, char *error_buf, uint32 error_buf_size) { const uint8 *p = buf, *p_end = buf_end; @@ -1701,9 +1686,9 @@ handle_name_section(const uint8 *buf, const uint8 *buf_end, func_index -= module->import_count; bh_assert(func_index < module->function_count); if (!(module->functions[func_index]->field_name = - const_str_list_insert(p, func_name_len, - module, error_buf, - error_buf_size))) { + const_str_list_insert(p, func_name_len, + module, error_buf, + error_buf_size))) { return false; } } @@ -1711,8 +1696,9 @@ handle_name_section(const uint8 *buf, const uint8 *buf_end, } } break; - case SUB_SECTION_TYPE_MODULE: /* TODO: Parse for module subsection */ - case SUB_SECTION_TYPE_LOCAL: /* TODO: Parse for local subsection */ + case SUB_SECTION_TYPE_MODULE: /* TODO: Parse for module subsection + */ + case SUB_SECTION_TYPE_LOCAL: /* TODO: Parse for local subsection */ default: p = p + subsection_size; break; @@ -1737,8 +1723,7 @@ load_user_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, read_leb_uint32(p, p_end, name_len); - bh_assert(name_len > 0 - && p + name_len <= p_end); + bh_assert(name_len > 0 && p + name_len <= p_end); #if WASM_ENABLE_CUSTOM_NAME_SECTION != 0 if (memcmp(p, "name", 4) == 0) { @@ -1753,9 +1738,8 @@ load_user_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, #if WASM_ENABLE_REF_TYPES != 0 static bool -get_table_elem_type(const WASMModule *module, - uint32 table_idx, uint8 *p_elem_type, - char *error_buf, uint32 error_buf_size) +get_table_elem_type(const WASMModule *module, uint32 table_idx, + uint8 *p_elem_type, char *error_buf, uint32 error_buf_size) { if (!check_table_index(module, table_idx, error_buf, error_buf_size)) { return false; @@ -1765,16 +1749,17 @@ get_table_elem_type(const WASMModule *module, if (table_idx < module->import_table_count) *p_elem_type = module->import_tables[table_idx].u.table.elem_type; else - *p_elem_type = module->tables[module->import_table_count - + table_idx].elem_type; + *p_elem_type = + module->tables[module->import_table_count + table_idx] + .elem_type; } return true; } static bool -get_table_seg_elem_type(const WASMModule *module, - uint32 table_seg_idx, uint8 *p_elem_type, - char *error_buf, uint32 error_buf_size) +get_table_seg_elem_type(const WASMModule *module, uint32 table_seg_idx, + uint8 *p_elem_type, char *error_buf, + uint32 error_buf_size) { if (table_seg_idx >= module->table_seg_count) { return false; @@ -1788,10 +1773,8 @@ get_table_seg_elem_type(const WASMModule *module, #endif static bool -wasm_loader_prepare_bytecode(WASMModule *module, - WASMFunction *func, - uint32 cur_func_idx, - char *error_buf, +wasm_loader_prepare_bytecode(WASMModule *module, WASMFunction *func, + uint32 cur_func_idx, char *error_buf, uint32 error_buf_size); #if WASM_ENABLE_FAST_INTERP != 0 && WASM_ENABLE_LABELS_AS_VALUES != 0 @@ -1802,13 +1785,13 @@ static void **handle_table; #endif static bool -load_from_sections(WASMModule *module, WASMSection *sections, - char *error_buf, uint32 error_buf_size) +load_from_sections(WASMModule *module, WASMSection *sections, char *error_buf, + uint32 error_buf_size) { WASMExport *export; WASMSection *section = sections; const uint8 *buf, *buf_end, *buf_code = NULL, *buf_code_end = NULL, - *buf_func = NULL, *buf_func_end = NULL; + *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; uint32 aux_data_end = (uint32)-1, aux_heap_base = (uint32)-1; @@ -1838,44 +1821,53 @@ load_from_sections(WASMModule *module, WASMSection *sections, switch (section->section_type) { case SECTION_TYPE_USER: /* unsupported user section, ignore it. */ - if (!load_user_section(buf, buf_end, module, error_buf, error_buf_size)) + if (!load_user_section(buf, buf_end, module, error_buf, + error_buf_size)) return false; break; case SECTION_TYPE_TYPE: - if (!load_type_section(buf, buf_end, module, error_buf, error_buf_size)) + if (!load_type_section(buf, buf_end, module, error_buf, + error_buf_size)) return false; break; case SECTION_TYPE_IMPORT: - if (!load_import_section(buf, buf_end, module, error_buf, error_buf_size)) + if (!load_import_section(buf, buf_end, module, error_buf, + error_buf_size)) return false; break; case SECTION_TYPE_FUNC: if (!load_function_section(buf, buf_end, buf_code, buf_code_end, - module, error_buf, error_buf_size)) + module, error_buf, error_buf_size)) return false; break; case SECTION_TYPE_TABLE: - if (!load_table_section(buf, buf_end, module, error_buf, error_buf_size)) + if (!load_table_section(buf, buf_end, module, error_buf, + error_buf_size)) return false; break; case SECTION_TYPE_MEMORY: - if (!load_memory_section(buf, buf_end, module, error_buf, error_buf_size)) + if (!load_memory_section(buf, buf_end, module, error_buf, + error_buf_size)) return false; break; case SECTION_TYPE_GLOBAL: - if (!load_global_section(buf, buf_end, module, error_buf, error_buf_size)) + if (!load_global_section(buf, buf_end, module, error_buf, + error_buf_size)) return false; break; case SECTION_TYPE_EXPORT: - if (!load_export_section(buf, buf_end, module, error_buf, error_buf_size)) + if (!load_export_section(buf, buf_end, module, error_buf, + error_buf_size)) return false; break; case SECTION_TYPE_START: - if (!load_start_section(buf, buf_end, module, error_buf, error_buf_size)) + if (!load_start_section(buf, buf_end, module, error_buf, + error_buf_size)) return false; break; case SECTION_TYPE_ELEM: - if (!load_table_segment_section(buf, buf_end, module, error_buf, error_buf_size)) + if (!load_table_segment_section(buf, buf_end, module, error_buf, + error_buf_size)) return false; break; case SECTION_TYPE_CODE: @@ -1884,18 +1876,19 @@ load_from_sections(WASMModule *module, WASMSection *sections, return false; break; case SECTION_TYPE_DATA: - if (!load_data_segment_section(buf, buf_end, module, error_buf, error_buf_size)) + if (!load_data_segment_section(buf, buf_end, module, error_buf, + error_buf_size)) return false; break; #if WASM_ENABLE_BULK_MEMORY != 0 case SECTION_TYPE_DATACOUNT: - if (!load_datacount_section(buf, buf_end, module, error_buf, error_buf_size)) + if (!load_datacount_section(buf, buf_end, module, error_buf, + error_buf_size)) return false; break; #endif default: - set_error_buf(error_buf, error_buf_size, - "invalid section id"); + set_error_buf(error_buf, error_buf_size, "invalid section id"); return false; } @@ -1908,15 +1901,14 @@ load_from_sections(WASMModule *module, WASMSection *sections, /* Resolve auxiliary data/stack/heap info and reset memory info */ export = module->exports; - for (i = 0; i < module->export_count; i++, export++) { + for (i = 0; i < module->export_count; i++, export ++) { if (export->kind == EXPORT_KIND_GLOBAL) { if (!strcmp(export->name, "__heap_base")) { global_index = export->index - module->import_global_count; global = module->globals + global_index; - if (global->type == VALUE_TYPE_I32 - && !global->is_mutable - && global->init_expr.init_expr_type == - INIT_EXPR_TYPE_I32_CONST) { + if (global->type == VALUE_TYPE_I32 && !global->is_mutable + && global->init_expr.init_expr_type + == INIT_EXPR_TYPE_I32_CONST) { aux_heap_base_global = global; aux_heap_base = global->init_expr.u.i32; aux_heap_base_global_index = export->index; @@ -1927,10 +1919,9 @@ load_from_sections(WASMModule *module, WASMSection *sections, else if (!strcmp(export->name, "__data_end")) { global_index = export->index - module->import_global_count; global = module->globals + global_index; - if (global->type == VALUE_TYPE_I32 - && !global->is_mutable - && global->init_expr.init_expr_type == - INIT_EXPR_TYPE_I32_CONST) { + if (global->type == VALUE_TYPE_I32 && !global->is_mutable + && global->init_expr.init_expr_type + == INIT_EXPR_TYPE_I32_CONST) { aux_data_end_global = global; aux_data_end = global->init_expr.u.i32; aux_data_end_global_index = export->index; @@ -1971,17 +1962,18 @@ load_from_sections(WASMModule *module, WASMSection *sections, if (global->is_mutable /* heap_base and data_end is not mutable */ && global->type == VALUE_TYPE_I32 - && global->init_expr.init_expr_type == - INIT_EXPR_TYPE_I32_CONST + && global->init_expr.init_expr_type + == INIT_EXPR_TYPE_I32_CONST && (uint32)global->init_expr.u.i32 <= aux_heap_base) { aux_stack_top_global = global; aux_stack_top = (uint32)global->init_expr.u.i32; module->aux_stack_top_global_index = - module->import_global_count + global_index; + module->import_global_count + global_index; module->aux_stack_bottom = aux_stack_top; - module->aux_stack_size = aux_stack_top > aux_data_end - ? aux_stack_top - aux_data_end - : aux_stack_top; + module->aux_stack_size = + aux_stack_top > aux_data_end + ? aux_stack_top - aux_data_end + : aux_stack_top; LOG_VERBOSE("Found aux stack top global, value: %d, " "global index: %d, stack size: %d", aux_stack_top, global_index, @@ -1999,14 +1991,13 @@ load_from_sections(WASMModule *module, WASMSection *sections, /* Resolve malloc/free function exported by wasm module */ export = module->exports; - for (i = 0; i < module->export_count; i++, export++) { + for (i = 0; i < module->export_count; i++, export ++) { if (export->kind == EXPORT_KIND_FUNC) { if (!strcmp(export->name, "malloc") && export->index >= module->import_function_count) { func_index = export->index - module->import_function_count; func_type = module->functions[func_index]->func_type; - if (func_type->param_count == 1 - && func_type->result_count == 1 + if (func_type->param_count == 1 && func_type->result_count == 1 && func_type->types[0] == VALUE_TYPE_I32 && func_type->types[1] == VALUE_TYPE_I32) { bh_assert(module->malloc_function == (uint32)-1); @@ -2020,8 +2011,7 @@ load_from_sections(WASMModule *module, WASMSection *sections, /* __new && __pin for AssemblyScript */ func_index = export->index - module->import_function_count; func_type = module->functions[func_index]->func_type; - if (func_type->param_count == 2 - && func_type->result_count == 1 + if (func_type->param_count == 2 && func_type->result_count == 1 && func_type->types[0] == VALUE_TYPE_I32 && func_type->types[1] == VALUE_TYPE_I32 && func_type->types[2] == VALUE_TYPE_I32) { @@ -2043,19 +2033,20 @@ load_from_sections(WASMModule *module, WASMSection *sections, && (export_tmp->index >= module->import_function_count)) { func_index = export_tmp->index - - module->import_function_count; + - module->import_function_count; func_type = - module->functions[func_index]->func_type; + module->functions[func_index]->func_type; if (func_type->param_count == 1 && func_type->result_count == 1 && func_type->types[0] == VALUE_TYPE_I32 && func_type->types[1] == VALUE_TYPE_I32) { - bh_assert( - module->retain_function == (uint32)-1); + bh_assert(module->retain_function + == (uint32)-1); module->retain_function = export_tmp->index; - LOG_VERBOSE( - "Found retain function, name: %s, index: %u", - export_tmp->name, export_tmp->index); + LOG_VERBOSE("Found retain function, name: %s, " + "index: %u", + export_tmp->name, + export_tmp->index); break; } } @@ -2073,8 +2064,7 @@ load_from_sections(WASMModule *module, WASMSection *sections, && export->index >= module->import_function_count) { func_index = export->index - module->import_function_count; func_type = module->functions[func_index]->func_type; - if (func_type->param_count == 1 - && func_type->result_count == 0 + if (func_type->param_count == 1 && func_type->result_count == 0 && func_type->types[0] == VALUE_TYPE_I32) { bh_assert(module->free_function == (uint32)-1); module->free_function = export->index; @@ -2091,8 +2081,8 @@ load_from_sections(WASMModule *module, WASMSection *sections, for (i = 0; i < module->function_count; i++) { WASMFunction *func = module->functions[i]; - if (!wasm_loader_prepare_bytecode(module, func, i, - error_buf, error_buf_size)) { + if (!wasm_loader_prepare_bytecode(module, func, i, error_buf, + error_buf_size)) { return false; } } @@ -2101,16 +2091,15 @@ load_from_sections(WASMModule *module, WASMSection *sections, WASMMemoryImport *memory_import; WASMMemory *memory; - if (aux_data_end_global - && aux_heap_base_global + if (aux_data_end_global && aux_heap_base_global && aux_stack_top_global) { uint64 init_memory_size; uint32 shrunk_memory_size = align_uint(aux_heap_base, 8); if (module->import_memory_count) { memory_import = &module->import_memories[0].u.memory; - init_memory_size = (uint64)memory_import->num_bytes_per_page * - memory_import->init_page_count; + init_memory_size = (uint64)memory_import->num_bytes_per_page + * 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; @@ -2121,8 +2110,8 @@ load_from_sections(WASMModule *module, WASMSection *sections, } if (module->memory_count) { memory = &module->memories[0]; - init_memory_size = (uint64)memory->num_bytes_per_page * - memory->init_page_count; + init_memory_size = (uint64)memory->num_bytes_per_page + * 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; @@ -2156,11 +2145,11 @@ load_from_sections(WASMModule *module, WASMSection *sections, return true; } -static WASMModule* +static WASMModule * create_module(char *error_buf, uint32 error_buf_size) { - WASMModule *module = loader_malloc(sizeof(WASMModule), - error_buf, error_buf_size); + WASMModule *module = + loader_malloc(sizeof(WASMModule), error_buf, error_buf_size); if (!module) { return NULL; @@ -2178,8 +2167,8 @@ create_module(char *error_buf, uint32 error_buf_size) } WASMModule * -wasm_loader_load_from_sections(WASMSection *section_list, - char *error_buf, uint32 error_buf_size) +wasm_loader_load_from_sections(WASMSection *section_list, char *error_buf, + uint32 error_buf_size) { WASMModule *module = create_module(error_buf, error_buf_size); if (!module) @@ -2205,6 +2194,7 @@ destroy_sections(WASMSection *section_list) } } +/* clang-format off */ static uint8 section_ids[] = { SECTION_TYPE_USER, SECTION_TYPE_TYPE, @@ -2222,6 +2212,7 @@ static uint8 section_ids[] = { SECTION_TYPE_CODE, SECTION_TYPE_DATA }; +/* clang-format on */ static uint8 get_section_index(uint8 section_type) @@ -2237,12 +2228,11 @@ get_section_index(uint8 section_type) } static bool -create_sections(const uint8 *buf, uint32 size, - WASMSection **p_section_list, +create_sections(const uint8 *buf, uint32 size, WASMSection **p_section_list, char *error_buf, uint32 error_buf_size) { WASMSection *section_list_end = NULL, *section; - const uint8 *p = buf, *p_end = buf + size/*, *section_body*/; + const uint8 *p = buf, *p_end = buf + size /*, *section_body*/; uint8 section_type, section_index, last_section_index = (uint8)-1; uint32 section_size; @@ -2266,13 +2256,13 @@ create_sections(const uint8 *buf, uint32 size, read_leb_uint32(p, p_end, section_size); CHECK_BUF1(p, p_end, section_size); - if (!(section = loader_malloc(sizeof(WASMSection), - error_buf, error_buf_size))) { + if (!(section = loader_malloc(sizeof(WASMSection), error_buf, + error_buf_size))) { return false; } section->section_type = section_type; - section->section_body = (uint8*)p; + section->section_body = (uint8 *)p; section->section_body_size = section_size; if (!*p_section_list) @@ -2294,7 +2284,7 @@ create_sections(const uint8 *buf, uint32 size, } static void -exchange32(uint8* p_data) +exchange32(uint8 *p_data) { uint8 value = *p_data; *p_data = *(p_data + 3); @@ -2313,8 +2303,8 @@ static union { #define is_little_endian() (__ue.b == 1) static bool -load(const uint8 *buf, uint32 size, WASMModule *module, - char *error_buf, uint32 error_buf_size) +load(const uint8 *buf, uint32 size, WASMModule *module, char *error_buf, + uint32 error_buf_size) { const uint8 *buf_end = buf + size; const uint8 *p = buf, *p_end = buf_end; @@ -2324,14 +2314,14 @@ load(const uint8 *buf, uint32 size, WASMModule *module, CHECK_BUF1(p, p_end, sizeof(uint32)); magic_number = read_uint32(p); if (!is_little_endian()) - exchange32((uint8*)&magic_number); + exchange32((uint8 *)&magic_number); bh_assert(magic_number == WASM_MAGIC_NUMBER); CHECK_BUF1(p, p_end, sizeof(uint32)); version = read_uint32(p); if (!is_little_endian()) - exchange32((uint8*)&version); + exchange32((uint8 *)&version); if (version != WASM_CURRENT_VERSION) { set_error_buf(error_buf, error_buf_size, "unknown binary version"); @@ -2339,7 +2329,8 @@ load(const uint8 *buf, uint32 size, WASMModule *module, } if (!create_sections(buf, size, §ion_list, error_buf, error_buf_size) - || !load_from_sections(module, section_list, error_buf, error_buf_size)) { + || !load_from_sections(module, section_list, error_buf, + error_buf_size)) { destroy_sections(section_list); return false; } @@ -2349,8 +2340,9 @@ load(const uint8 *buf, uint32 size, WASMModule *module, return true; } -WASMModule* -wasm_loader_load(const uint8 *buf, uint32 size, char *error_buf, uint32 error_buf_size) +WASMModule * +wasm_loader_load(const uint8 *buf, uint32 size, char *error_buf, + uint32 error_buf_size) { WASMModule *module = create_module(error_buf, error_buf_size); if (!module) { @@ -2447,10 +2439,8 @@ wasm_loader_unload(WASMModule *module) bool wasm_loader_find_block_addr(BlockAddr *block_addr_cache, - const uint8 *start_addr, - const uint8 *code_end_addr, - uint8 label_type, - uint8 **p_else_addr, + const uint8 *start_addr, const uint8 *code_end_addr, + uint8 label_type, uint8 **p_else_addr, uint8 **p_end_addr) { const uint8 *p = start_addr, *p_end = code_end_addr; @@ -2489,7 +2479,8 @@ wasm_loader_find_block_addr(BlockAddr *block_addr_cache, case WASM_OP_IF: /* block result type: 0x40/0x7F/0x7E/0x7D/0x7C */ u8 = read_uint8(p); - if (block_nested_depth < sizeof(block_stack)/sizeof(BlockAddr)) { + if (block_nested_depth + < sizeof(block_stack) / sizeof(BlockAddr)) { block_stack[block_nested_depth].start_addr = p; block_stack[block_nested_depth].else_addr = NULL; } @@ -2501,7 +2492,8 @@ wasm_loader_find_block_addr(BlockAddr *block_addr_cache, case EXT_OP_IF: /* block type */ skip_leb_uint32(p, p_end); - if (block_nested_depth < sizeof(block_stack)/sizeof(BlockAddr)) { + if (block_nested_depth + < sizeof(block_stack) / sizeof(BlockAddr)) { block_stack[block_nested_depth].start_addr = p; block_stack[block_nested_depth].else_addr = NULL; } @@ -2510,33 +2502,37 @@ wasm_loader_find_block_addr(BlockAddr *block_addr_cache, case WASM_OP_ELSE: if (label_type == LABEL_TYPE_IF && block_nested_depth == 1) - else_addr = (uint8*)(p - 1); - if (block_nested_depth - 1 < sizeof(block_stack)/sizeof(BlockAddr)) - block_stack[block_nested_depth - 1].else_addr = (uint8*)(p - 1); + else_addr = (uint8 *)(p - 1); + if (block_nested_depth - 1 + < sizeof(block_stack) / sizeof(BlockAddr)) + block_stack[block_nested_depth - 1].else_addr = + (uint8 *)(p - 1); break; case WASM_OP_END: if (block_nested_depth == 1) { if (label_type == LABEL_TYPE_IF) *p_else_addr = else_addr; - *p_end_addr = (uint8*)(p - 1); + *p_end_addr = (uint8 *)(p - 1); - block_stack[0].end_addr = (uint8*)(p - 1); - for (t = 0; t < sizeof(block_stack)/sizeof(BlockAddr); t++) { + block_stack[0].end_addr = (uint8 *)(p - 1); + for (t = 0; t < sizeof(block_stack) / sizeof(BlockAddr); + t++) { start_addr = block_stack[t].start_addr; if (start_addr) { i = ((uintptr_t)start_addr) & (uintptr_t)(BLOCK_ADDR_CACHE_SIZE - 1); - block = block_addr_cache + BLOCK_ADDR_CONFLICT_SIZE * i; + block = + block_addr_cache + BLOCK_ADDR_CONFLICT_SIZE * i; for (j = 0; j < BLOCK_ADDR_CONFLICT_SIZE; j++) if (!block[j].start_addr) break; if (j == BLOCK_ADDR_CONFLICT_SIZE) { - memmove(block + 1, block, (BLOCK_ADDR_CONFLICT_SIZE - 1) * - sizeof(BlockAddr)); + memmove(block + 1, block, + (BLOCK_ADDR_CONFLICT_SIZE - 1) + * sizeof(BlockAddr)); j = 0; - } block[j].start_addr = block_stack[t].start_addr; block[j].else_addr = block_stack[t].else_addr; @@ -2549,8 +2545,10 @@ wasm_loader_find_block_addr(BlockAddr *block_addr_cache, } else { block_nested_depth--; - if (block_nested_depth < sizeof(block_stack)/sizeof(BlockAddr)) - block_stack[block_nested_depth].end_addr = (uint8*)(p - 1); + if (block_nested_depth + < sizeof(block_stack) / sizeof(BlockAddr)) + block_stack[block_nested_depth].end_addr = + (uint8 *)(p - 1); } break; @@ -2561,7 +2559,7 @@ wasm_loader_find_block_addr(BlockAddr *block_addr_cache, case WASM_OP_BR_TABLE: read_leb_uint32(p, p_end, count); /* lable num */ - for (i = 0; i <= count; i++) /* lableidxs */ + for (i = 0; i <= count; i++) /* lableidxs */ skip_leb_uint32(p, p_end); break; @@ -2916,24 +2914,24 @@ wasm_loader_find_block_addr(BlockAddr *block_addr_cache, return false; } -#define REF_I32 VALUE_TYPE_I32 -#define REF_F32 VALUE_TYPE_F32 +#define REF_I32 VALUE_TYPE_I32 +#define REF_F32 VALUE_TYPE_F32 #define REF_I64_1 VALUE_TYPE_I64 #define REF_I64_2 VALUE_TYPE_I64 #define REF_F64_1 VALUE_TYPE_F64 #define REF_F64_2 VALUE_TYPE_F64 -#define REF_ANY VALUE_TYPE_ANY +#define REF_ANY VALUE_TYPE_ANY #if WASM_ENABLE_FAST_INTERP != 0 #if WASM_DEBUG_PREPROCESSOR != 0 -#define LOG_OP(...) os_printf(__VA_ARGS__) +#define LOG_OP(...) os_printf(__VA_ARGS__) #else -#define LOG_OP(...) (void)0 +#define LOG_OP(...) (void)0 #endif #define PATCH_ELSE 0 -#define PATCH_END 1 +#define PATCH_END 1 typedef struct BranchBlockPatch { struct BranchBlockPatch *next; uint8 patch_type; @@ -3014,14 +3012,13 @@ typedef struct Const { uint8 value_type; } Const; -static void* -memory_realloc(void *mem_old, uint32 size_old, uint32 size_new, - char *error_buf, uint32 error_buf_size) +static void * +memory_realloc(void *mem_old, uint32 size_old, uint32 size_new, char *error_buf, + uint32 error_buf_size) { uint8 *mem_new; bh_assert(size_new > size_old); - if ((mem_new = loader_malloc - (size_new, error_buf, error_buf_size))) { + if ((mem_new = loader_malloc(size_new, error_buf, error_buf_size))) { bh_memcpy_s(mem_new, size_new, mem_old, size_old); memset(mem_new + size_old, 0, size_new - size_old); wasm_runtime_free(mem_old); @@ -3029,42 +3026,46 @@ memory_realloc(void *mem_old, uint32 size_old, uint32 size_new, return mem_new; } -#define MEM_REALLOC(mem, size_old, size_new) do { \ - void *mem_new = memory_realloc(mem, size_old, size_new, \ - error_buf, error_buf_size); \ - if (!mem_new) \ - goto fail; \ - mem = mem_new; \ - } while (0) +#define MEM_REALLOC(mem, size_old, size_new) \ + do { \ + void *mem_new = memory_realloc(mem, size_old, size_new, error_buf, \ + error_buf_size); \ + if (!mem_new) \ + goto fail; \ + mem = mem_new; \ + } while (0) -#define CHECK_CSP_PUSH() do { \ - if (ctx->frame_csp >= ctx->frame_csp_boundary) { \ - MEM_REALLOC(ctx->frame_csp_bottom, ctx->frame_csp_size, \ - (uint32)(ctx->frame_csp_size \ - + 8 * sizeof(BranchBlock))); \ - ctx->frame_csp_size += (uint32)(8 * sizeof(BranchBlock)); \ - ctx->frame_csp_boundary = ctx->frame_csp_bottom + \ - ctx->frame_csp_size / sizeof(BranchBlock); \ - ctx->frame_csp = ctx->frame_csp_bottom + ctx->csp_num; \ - } \ - } while (0) +#define CHECK_CSP_PUSH() \ + do { \ + if (ctx->frame_csp >= ctx->frame_csp_boundary) { \ + MEM_REALLOC( \ + ctx->frame_csp_bottom, ctx->frame_csp_size, \ + (uint32)(ctx->frame_csp_size + 8 * sizeof(BranchBlock))); \ + ctx->frame_csp_size += (uint32)(8 * sizeof(BranchBlock)); \ + ctx->frame_csp_boundary = \ + ctx->frame_csp_bottom \ + + ctx->frame_csp_size / sizeof(BranchBlock); \ + ctx->frame_csp = ctx->frame_csp_bottom + ctx->csp_num; \ + } \ + } while (0) -#define CHECK_CSP_POP() do { \ - bh_assert(ctx->csp_num >= 1); \ - } while (0) +#define CHECK_CSP_POP() \ + do { \ + bh_assert(ctx->csp_num >= 1); \ + } while (0) #if WASM_ENABLE_FAST_INTERP != 0 static bool -check_offset_push(WASMLoaderContext *ctx, - char *error_buf, uint32 error_buf_size) +check_offset_push(WASMLoaderContext *ctx, char *error_buf, + uint32 error_buf_size) { uint32 cell_num = (uint32)(ctx->frame_offset - ctx->frame_offset_bottom); if (ctx->frame_offset >= ctx->frame_offset_boundary) { MEM_REALLOC(ctx->frame_offset_bottom, ctx->frame_offset_size, ctx->frame_offset_size + 16); ctx->frame_offset_size += 16; - ctx->frame_offset_boundary = ctx->frame_offset_bottom + - ctx->frame_offset_size / sizeof(int16); + ctx->frame_offset_boundary = + ctx->frame_offset_bottom + ctx->frame_offset_size / sizeof(int16); ctx->frame_offset = ctx->frame_offset_bottom + cell_num; } return true; @@ -3100,15 +3101,14 @@ free_all_label_patch_lists(BranchBlock *frame_csp, uint32 csp_num) for (uint32 i = 0; i < csp_num; i++) { free_label_patch_list(tmp_csp); - tmp_csp ++; + tmp_csp++; } } #endif static bool -check_stack_push(WASMLoaderContext *ctx, - char *error_buf, uint32 error_buf_size) +check_stack_push(WASMLoaderContext *ctx, char *error_buf, uint32 error_buf_size) { if (ctx->frame_ref >= ctx->frame_ref_boundary) { MEM_REALLOC(ctx->frame_ref_bottom, ctx->frame_ref_size, @@ -3122,7 +3122,6 @@ fail: return false; } - static bool check_stack_top_values(uint8 *frame_ref, int32 stack_cell_num, uint8 type, char *error_buf, uint32 error_buf_size) @@ -3130,32 +3129,31 @@ check_stack_top_values(uint8 *frame_ref, int32 stack_cell_num, uint8 type, bh_assert(!((is_32bit_type(type) && stack_cell_num < 1) || (is_64bit_type(type) && stack_cell_num < 2))); - bh_assert(!((type == VALUE_TYPE_I32 && *(frame_ref - 1) != REF_I32) - || (type == VALUE_TYPE_F32 && *(frame_ref - 1) != REF_F32) - || (type == VALUE_TYPE_I64 - && (*(frame_ref - 2) != REF_I64_1 - || *(frame_ref - 1) != REF_I64_2)) - || (type == VALUE_TYPE_F64 - && (*(frame_ref - 2) != REF_F64_1 - || *(frame_ref - 1) != REF_F64_2)))); + bh_assert(!( + (type == VALUE_TYPE_I32 && *(frame_ref - 1) != REF_I32) + || (type == VALUE_TYPE_F32 && *(frame_ref - 1) != REF_F32) + || (type == VALUE_TYPE_I64 + && (*(frame_ref - 2) != REF_I64_1 || *(frame_ref - 1) != REF_I64_2)) + || (type == VALUE_TYPE_F64 + && (*(frame_ref - 2) != REF_F64_1 + || *(frame_ref - 1) != REF_F64_2)))); return true; } static bool -check_stack_pop(WASMLoaderContext *ctx, uint8 type, - char *error_buf, uint32 error_buf_size) +check_stack_pop(WASMLoaderContext *ctx, uint8 type, char *error_buf, + uint32 error_buf_size) { - int32 block_stack_cell_num = (int32) - (ctx->stack_cell_num - (ctx->frame_csp - 1)->stack_cell_num); + int32 block_stack_cell_num = + (int32)(ctx->stack_cell_num - (ctx->frame_csp - 1)->stack_cell_num); - if (block_stack_cell_num > 0 - && *(ctx->frame_ref - 1) == VALUE_TYPE_ANY) { + if (block_stack_cell_num > 0 && *(ctx->frame_ref - 1) == VALUE_TYPE_ANY) { /* the stack top is a value of any type, return success */ return true; } - if (!check_stack_top_values(ctx->frame_ref, block_stack_cell_num, - type, error_buf, error_buf_size)) + if (!check_stack_top_values(ctx->frame_ref, block_stack_cell_num, type, + error_buf, error_buf_size)) return false; return true; @@ -3183,7 +3181,7 @@ wasm_loader_ctx_destroy(WASMLoaderContext *ctx) } } -static WASMLoaderContext* +static WASMLoaderContext * wasm_loader_ctx_init(WASMFunction *func) { WASMLoaderContext *loader_ctx = @@ -3194,15 +3192,15 @@ wasm_loader_ctx_init(WASMFunction *func) loader_ctx->frame_ref_size = 32; if (!(loader_ctx->frame_ref_bottom = loader_ctx->frame_ref = - wasm_runtime_malloc(loader_ctx->frame_ref_size))) + wasm_runtime_malloc(loader_ctx->frame_ref_size))) goto fail; memset(loader_ctx->frame_ref_bottom, 0, loader_ctx->frame_ref_size); - loader_ctx->frame_ref_boundary = loader_ctx->frame_ref_bottom + - loader_ctx->frame_ref_size; + loader_ctx->frame_ref_boundary = + loader_ctx->frame_ref_bottom + loader_ctx->frame_ref_size; loader_ctx->frame_csp_size = sizeof(BranchBlock) * 8; if (!(loader_ctx->frame_csp_bottom = loader_ctx->frame_csp = - wasm_runtime_malloc(loader_ctx->frame_csp_size))) + wasm_runtime_malloc(loader_ctx->frame_csp_size))) goto fail; memset(loader_ctx->frame_csp_bottom, 0, loader_ctx->frame_csp_size); loader_ctx->frame_csp_boundary = loader_ctx->frame_csp_bottom + 8; @@ -3210,21 +3208,21 @@ wasm_loader_ctx_init(WASMFunction *func) #if WASM_ENABLE_FAST_INTERP != 0 loader_ctx->frame_offset_size = sizeof(int16) * 32; if (!(loader_ctx->frame_offset_bottom = loader_ctx->frame_offset = - wasm_runtime_malloc(loader_ctx->frame_offset_size))) + wasm_runtime_malloc(loader_ctx->frame_offset_size))) goto fail; - memset(loader_ctx->frame_offset_bottom, 0, - loader_ctx->frame_offset_size); + memset(loader_ctx->frame_offset_bottom, 0, loader_ctx->frame_offset_size); loader_ctx->frame_offset_boundary = loader_ctx->frame_offset_bottom + 32; loader_ctx->num_const = 0; loader_ctx->const_buf_size = sizeof(Const) * 8; - if (!(loader_ctx->const_buf = wasm_runtime_malloc(loader_ctx->const_buf_size))) + if (!(loader_ctx->const_buf = + wasm_runtime_malloc(loader_ctx->const_buf_size))) goto fail; memset(loader_ctx->const_buf, 0, loader_ctx->const_buf_size); loader_ctx->start_dynamic_offset = loader_ctx->dynamic_offset = - loader_ctx->max_dynamic_offset = func->param_cell_num + - func->local_cell_num; + loader_ctx->max_dynamic_offset = + func->param_cell_num + func->local_cell_num; #endif return loader_ctx; @@ -3234,8 +3232,8 @@ fail: } static bool -wasm_loader_push_frame_ref(WASMLoaderContext *ctx, uint8 type, - char *error_buf, uint32 error_buf_size) +wasm_loader_push_frame_ref(WASMLoaderContext *ctx, uint8 type, char *error_buf, + uint32 error_buf_size) { if (type == VALUE_TYPE_VOID) return true; @@ -3261,12 +3259,12 @@ wasm_loader_push_frame_ref(WASMLoaderContext *ctx, uint8 type, } static bool -wasm_loader_pop_frame_ref(WASMLoaderContext *ctx, uint8 type, - char *error_buf, uint32 error_buf_size) +wasm_loader_pop_frame_ref(WASMLoaderContext *ctx, uint8 type, char *error_buf, + uint32 error_buf_size) { BranchBlock *cur_block = ctx->frame_csp - 1; - int32 available_stack_cell = (int32) - (ctx->stack_cell_num - cur_block->stack_cell_num); + int32 available_stack_cell = + (int32)(ctx->stack_cell_num - cur_block->stack_cell_num); /* Directly return success if current block is in stack * polymorphic state while stack is empty. */ @@ -3292,11 +3290,12 @@ wasm_loader_pop_frame_ref(WASMLoaderContext *ctx, uint8 type, static bool wasm_loader_push_pop_frame_ref(WASMLoaderContext *ctx, uint8 pop_cnt, - uint8 type_push, uint8 type_pop, - char *error_buf, uint32 error_buf_size) + uint8 type_push, uint8 type_pop, char *error_buf, + uint32 error_buf_size) { for (int i = 0; i < pop_cnt; i++) { - if (!wasm_loader_pop_frame_ref(ctx, type_pop, error_buf, error_buf_size)) + if (!wasm_loader_pop_frame_ref(ctx, type_pop, error_buf, + error_buf_size)) return false; } if (!wasm_loader_push_frame_ref(ctx, type_push, error_buf, error_buf_size)) @@ -3306,7 +3305,7 @@ wasm_loader_push_pop_frame_ref(WASMLoaderContext *ctx, uint8 pop_cnt, static bool wasm_loader_push_frame_csp(WASMLoaderContext *ctx, uint8 label_type, - BlockType block_type, uint8* start_addr, + BlockType block_type, uint8 *start_addr, char *error_buf, uint32 error_buf_size) { CHECK_CSP_PUSH(); @@ -3329,8 +3328,8 @@ fail: } static bool -wasm_loader_pop_frame_csp(WASMLoaderContext *ctx, - char *error_buf, uint32 error_buf_size) +wasm_loader_pop_frame_csp(WASMLoaderContext *ctx, char *error_buf, + uint32 error_buf_size) { CHECK_CSP_POP(); #if WASM_ENABLE_FAST_INTERP != 0 @@ -3346,124 +3345,132 @@ wasm_loader_pop_frame_csp(WASMLoaderContext *ctx, #if WASM_ENABLE_LABELS_AS_VALUES != 0 #if WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS != 0 -#define emit_label(opcode) do { \ - wasm_loader_emit_ptr(loader_ctx, handle_table[opcode]); \ - LOG_OP("\nemit_op [%02x]\t", opcode); \ - } while (0) -#define skip_label() do { \ - wasm_loader_emit_backspace(loader_ctx, sizeof(void *)); \ - LOG_OP("\ndelete last op\n"); \ - } while (0) +#define emit_label(opcode) \ + do { \ + wasm_loader_emit_ptr(loader_ctx, handle_table[opcode]); \ + LOG_OP("\nemit_op [%02x]\t", opcode); \ + } while (0) +#define skip_label() \ + do { \ + wasm_loader_emit_backspace(loader_ctx, sizeof(void *)); \ + LOG_OP("\ndelete last op\n"); \ + } while (0) #else /* else of WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS */ -#define emit_label(opcode) do { \ - int32 offset = (int32)((uint8*)handle_table[opcode] \ - - (uint8*)handle_table[0]); \ - if (!(offset >= INT16_MIN && offset < INT16_MAX)) { \ - set_error_buf(error_buf, error_buf_size, \ - "pre-compiled label offset out of range"); \ - goto fail; \ - } \ - wasm_loader_emit_int16(loader_ctx, offset); \ - LOG_OP("\nemit_op [%02x]\t", opcode); \ - } while (0) -#define skip_label() do { \ - wasm_loader_emit_backspace(loader_ctx, sizeof(int16)); \ - LOG_OP("\ndelete last op\n"); \ - } while (0) +#define emit_label(opcode) \ + do { \ + int32 offset = \ + (int32)((uint8 *)handle_table[opcode] - (uint8 *)handle_table[0]); \ + if (!(offset >= INT16_MIN && offset < INT16_MAX)) { \ + set_error_buf(error_buf, error_buf_size, \ + "pre-compiled label offset out of range"); \ + goto fail; \ + } \ + wasm_loader_emit_int16(loader_ctx, offset); \ + LOG_OP("\nemit_op [%02x]\t", opcode); \ + } while (0) +#define skip_label() \ + do { \ + wasm_loader_emit_backspace(loader_ctx, sizeof(int16)); \ + LOG_OP("\ndelete last op\n"); \ + } while (0) #endif /* end of WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS */ -#else /* else of WASM_ENABLE_LABELS_AS_VALUES */ -#define emit_label(opcode) do { \ - wasm_loader_emit_uint8(loader_ctx, opcode); \ - LOG_OP("\nemit_op [%02x]\t", opcode); \ - } while (0) -#define skip_label() do { \ - wasm_loader_emit_backspace(loader_ctx, sizeof(uint8)); \ - LOG_OP("\ndelete last op\n"); \ - } while (0) +#else /* else of WASM_ENABLE_LABELS_AS_VALUES */ +#define emit_label(opcode) \ + do { \ + wasm_loader_emit_uint8(loader_ctx, opcode); \ + LOG_OP("\nemit_op [%02x]\t", opcode); \ + } while (0) +#define skip_label() \ + do { \ + wasm_loader_emit_backspace(loader_ctx, sizeof(uint8)); \ + LOG_OP("\ndelete last op\n"); \ + } while (0) #endif /* end of WASM_ENABLE_LABELS_AS_VALUES */ -#define emit_empty_label_addr_and_frame_ip(type) do { \ - if (!add_label_patch_to_list(loader_ctx->frame_csp - 1, type, \ - loader_ctx->p_code_compiled, \ - error_buf, error_buf_size)) \ - goto fail; \ - /* label address, to be patched */ \ - wasm_loader_emit_ptr(loader_ctx, NULL); \ - } while (0) +#define emit_empty_label_addr_and_frame_ip(type) \ + do { \ + if (!add_label_patch_to_list(loader_ctx->frame_csp - 1, type, \ + loader_ctx->p_code_compiled, error_buf, \ + error_buf_size)) \ + goto fail; \ + /* label address, to be patched */ \ + wasm_loader_emit_ptr(loader_ctx, NULL); \ + } while (0) -#define emit_br_info(frame_csp) do { \ - if (!wasm_loader_emit_br_info(loader_ctx, frame_csp, \ - error_buf, error_buf_size)) \ - goto fail; \ - } while (0) +#define emit_br_info(frame_csp) \ + do { \ + if (!wasm_loader_emit_br_info(loader_ctx, frame_csp, error_buf, \ + error_buf_size)) \ + goto fail; \ + } while (0) -#define LAST_OP_OUTPUT_I32() (last_op >= WASM_OP_I32_EQZ \ - && last_op <= WASM_OP_I32_ROTR) \ - || (last_op == WASM_OP_I32_LOAD \ - || last_op == WASM_OP_F32_LOAD) \ - || (last_op >= WASM_OP_I32_LOAD8_S \ - && last_op <= WASM_OP_I32_LOAD16_U) \ - || (last_op >= WASM_OP_F32_ABS \ - && last_op <= WASM_OP_F32_COPYSIGN) \ - || (last_op >= WASM_OP_I32_WRAP_I64 \ - && last_op <= WASM_OP_I32_TRUNC_U_F64) \ - || (last_op >= WASM_OP_F32_CONVERT_S_I32 \ - && last_op <= WASM_OP_F32_DEMOTE_F64) \ - || (last_op == WASM_OP_I32_REINTERPRET_F32) \ - || (last_op == WASM_OP_F32_REINTERPRET_I32) \ - || (last_op == EXT_OP_COPY_STACK_TOP) +#define LAST_OP_OUTPUT_I32() \ + (last_op >= WASM_OP_I32_EQZ && last_op <= WASM_OP_I32_ROTR) \ + || (last_op == WASM_OP_I32_LOAD || last_op == WASM_OP_F32_LOAD) \ + || (last_op >= WASM_OP_I32_LOAD8_S && last_op <= WASM_OP_I32_LOAD16_U) \ + || (last_op >= WASM_OP_F32_ABS && last_op <= WASM_OP_F32_COPYSIGN) \ + || (last_op >= WASM_OP_I32_WRAP_I64 \ + && last_op <= WASM_OP_I32_TRUNC_U_F64) \ + || (last_op >= WASM_OP_F32_CONVERT_S_I32 \ + && last_op <= WASM_OP_F32_DEMOTE_F64) \ + || (last_op == WASM_OP_I32_REINTERPRET_F32) \ + || (last_op == WASM_OP_F32_REINTERPRET_I32) \ + || (last_op == EXT_OP_COPY_STACK_TOP) -#define LAST_OP_OUTPUT_I64() (last_op >= WASM_OP_I64_CLZ \ - && last_op <= WASM_OP_I64_ROTR) \ - || (last_op >= WASM_OP_F64_ABS \ - && last_op <= WASM_OP_F64_COPYSIGN) \ - || (last_op == WASM_OP_I64_LOAD \ - || last_op == WASM_OP_F64_LOAD) \ - || (last_op >= WASM_OP_I64_LOAD8_S \ - && last_op <= WASM_OP_I64_LOAD32_U) \ - || (last_op >= WASM_OP_I64_EXTEND_S_I32 \ - && last_op <= WASM_OP_I64_TRUNC_U_F64) \ - || (last_op >= WASM_OP_F64_CONVERT_S_I32 \ - && last_op <= WASM_OP_F64_PROMOTE_F32) \ - || (last_op == WASM_OP_I64_REINTERPRET_F64) \ - || (last_op == WASM_OP_F64_REINTERPRET_I64) \ - || (last_op == EXT_OP_COPY_STACK_TOP_I64) +#define LAST_OP_OUTPUT_I64() \ + (last_op >= WASM_OP_I64_CLZ && last_op <= WASM_OP_I64_ROTR) \ + || (last_op >= WASM_OP_F64_ABS && last_op <= WASM_OP_F64_COPYSIGN) \ + || (last_op == WASM_OP_I64_LOAD || last_op == WASM_OP_F64_LOAD) \ + || (last_op >= WASM_OP_I64_LOAD8_S && last_op <= WASM_OP_I64_LOAD32_U) \ + || (last_op >= WASM_OP_I64_EXTEND_S_I32 \ + && last_op <= WASM_OP_I64_TRUNC_U_F64) \ + || (last_op >= WASM_OP_F64_CONVERT_S_I32 \ + && last_op <= WASM_OP_F64_PROMOTE_F32) \ + || (last_op == WASM_OP_I64_REINTERPRET_F64) \ + || (last_op == WASM_OP_F64_REINTERPRET_I64) \ + || (last_op == EXT_OP_COPY_STACK_TOP_I64) -#define GET_CONST_OFFSET(type, val) do { \ - if (!(wasm_loader_get_const_offset(loader_ctx, type, \ - &val, &operand_offset, \ - error_buf, error_buf_size))) \ - goto fail; \ - } while (0) +#define GET_CONST_OFFSET(type, val) \ + do { \ + if (!(wasm_loader_get_const_offset(loader_ctx, type, &val, \ + &operand_offset, error_buf, \ + error_buf_size))) \ + goto fail; \ + } while (0) -#define GET_CONST_F32_OFFSET(type, fval) do { \ - if (!(wasm_loader_get_const_offset(loader_ctx, type, \ - &fval, &operand_offset, \ - error_buf, error_buf_size))) \ - goto fail; \ - } while (0) +#define GET_CONST_F32_OFFSET(type, fval) \ + do { \ + if (!(wasm_loader_get_const_offset(loader_ctx, type, &fval, \ + &operand_offset, error_buf, \ + error_buf_size))) \ + goto fail; \ + } while (0) -#define GET_CONST_F64_OFFSET(type, fval) do { \ - if (!(wasm_loader_get_const_offset(loader_ctx, type, \ - &fval, &operand_offset, \ - error_buf, error_buf_size))) \ - goto fail; \ - } while (0) +#define GET_CONST_F64_OFFSET(type, fval) \ + do { \ + if (!(wasm_loader_get_const_offset(loader_ctx, type, &fval, \ + &operand_offset, error_buf, \ + error_buf_size))) \ + goto fail; \ + } while (0) -#define emit_operand(ctx, offset) do { \ - wasm_loader_emit_int16(ctx, offset); \ - LOG_OP("%d\t", offset); \ - } while (0) +#define emit_operand(ctx, offset) \ + do { \ + wasm_loader_emit_int16(ctx, offset); \ + LOG_OP("%d\t", offset); \ + } while (0) -#define emit_byte(ctx, byte) do { \ - wasm_loader_emit_uint8(ctx, byte); \ - LOG_OP("%d\t", byte); \ - } while (0) +#define emit_byte(ctx, byte) \ + do { \ + wasm_loader_emit_uint8(ctx, byte); \ + LOG_OP("%d\t", byte); \ + } while (0) -#define emit_uint32(ctx, value) do { \ - wasm_loader_emit_uint32(ctx, value); \ - LOG_OP("%d\t", value); \ - } while (0) +#define emit_uint32(ctx, value) \ + do { \ + wasm_loader_emit_uint32(ctx, value); \ + LOG_OP("%d\t", value); \ + } while (0) static bool wasm_loader_ctx_reinit(WASMLoaderContext *ctx) @@ -3471,8 +3478,7 @@ wasm_loader_ctx_reinit(WASMLoaderContext *ctx) if (!(ctx->p_code_compiled = wasm_runtime_malloc(ctx->code_compiled_size))) return false; memset(ctx->p_code_compiled, 0, ctx->code_compiled_size); - ctx->p_code_compiled_end = ctx->p_code_compiled + - ctx->code_compiled_size; + ctx->p_code_compiled_end = ctx->p_code_compiled + ctx->code_compiled_size; /* clean up frame ref */ memset(ctx->frame_ref_bottom, 0, ctx->frame_ref_size); @@ -3596,8 +3602,9 @@ wasm_loader_emit_backspace(WASMLoaderContext *ctx, uint32 size) static bool preserve_referenced_local(WASMLoaderContext *loader_ctx, uint8 opcode, - uint32 local_index, uint32 local_type, bool *preserved, - char *error_buf, uint32 error_buf_size) + uint32 local_index, uint32 local_type, + bool *preserved, char *error_buf, + uint32 error_buf_size) { uint32 i = 0; int16 preserved_offset = (int16)local_index; @@ -3606,7 +3613,8 @@ preserve_referenced_local(WASMLoaderContext *loader_ctx, uint8 opcode, while (i < loader_ctx->stack_cell_num) { uint8 cur_type = loader_ctx->frame_ref_bottom[i]; - /* move previous local into dynamic space before a set/tee_local opcode */ + /* move previous local into dynamic space before a set/tee_local opcode + */ if (loader_ctx->frame_offset_bottom[i] == (int16)local_index) { if (!(*preserved)) { *preserved = true; @@ -3682,12 +3690,12 @@ preserve_local_for_block(WASMLoaderContext *loader_ctx, uint8 opcode, } static bool -add_label_patch_to_list(BranchBlock *frame_csp, - uint8 patch_type, uint8 *p_code_compiled, - char *error_buf, uint32 error_buf_size) +add_label_patch_to_list(BranchBlock *frame_csp, uint8 patch_type, + uint8 *p_code_compiled, char *error_buf, + uint32 error_buf_size) { - BranchBlockPatch *patch = loader_malloc - (sizeof(BranchBlockPatch), error_buf, error_buf_size); + BranchBlockPatch *patch = + loader_malloc(sizeof(BranchBlockPatch), error_buf, error_buf_size); if (!patch) { return false; } @@ -3705,8 +3713,7 @@ add_label_patch_to_list(BranchBlock *frame_csp, } static void -apply_label_patch(WASMLoaderContext *ctx, uint8 depth, - uint8 patch_type) +apply_label_patch(WASMLoaderContext *ctx, uint8 depth, uint8 patch_type) { BranchBlock *frame_csp = ctx->frame_csp - depth; BranchBlockPatch *node = frame_csp->patch_list; @@ -3780,11 +3787,11 @@ wasm_loader_emit_br_info(WASMLoaderContext *ctx, BranchBlock *frame_csp, for (i = (int32)arity - 1; i >= 0; i--) { cell = (uint8)wasm_value_type_cell_num(types[i]); frame_offset -= cell; - emit_operand(ctx, *(int16*)(frame_offset)); + emit_operand(ctx, *(int16 *)(frame_offset)); } /* Part e */ - dynamic_offset = frame_csp->dynamic_offset - + wasm_get_cell_num(types, arity); + dynamic_offset = + frame_csp->dynamic_offset + wasm_get_cell_num(types, arity); for (i = (int32)arity - 1; i >= 0; i--) { cell = (uint8)wasm_value_type_cell_num(types[i]); dynamic_offset -= cell; @@ -3797,8 +3804,7 @@ wasm_loader_emit_br_info(WASMLoaderContext *ctx, BranchBlock *frame_csp, wasm_loader_emit_ptr(ctx, frame_csp->code_compiled); } else { - if (!add_label_patch_to_list(frame_csp, PATCH_END, - ctx->p_code_compiled, + if (!add_label_patch_to_list(frame_csp, PATCH_END, ctx->p_code_compiled, error_buf, error_buf_size)) return false; /* label address, to be patched */ @@ -3860,8 +3866,8 @@ wasm_loader_pop_frame_offset(WASMLoaderContext *ctx, uint8 type, then current block is the function block */ uint32 depth = ctx->frame_csp > ctx->frame_csp_bottom ? 1 : 0; BranchBlock *cur_block = ctx->frame_csp - depth; - int32 available_stack_cell = (int32) - (ctx->stack_cell_num - cur_block->stack_cell_num); + int32 available_stack_cell = + (int32)(ctx->stack_cell_num - cur_block->stack_cell_num); /* Directly return success if current block is in stack * polymorphic state while stack is empty. */ @@ -3904,12 +3910,13 @@ wasm_loader_push_pop_frame_offset(WASMLoaderContext *ctx, uint8 pop_cnt, char *error_buf, uint32 error_buf_size) { for (int i = 0; i < pop_cnt; i++) { - if (!wasm_loader_pop_frame_offset(ctx, type_pop, error_buf, error_buf_size)) + if (!wasm_loader_pop_frame_offset(ctx, type_pop, error_buf, + error_buf_size)) return false; } - if (!wasm_loader_push_frame_offset(ctx, type_push, - disable_emit, operand_offset, - error_buf, error_buf_size)) + if (!wasm_loader_push_frame_offset(ctx, type_push, disable_emit, + operand_offset, error_buf, + error_buf_size)) return false; return true; @@ -3960,78 +3967,81 @@ wasm_loader_push_pop_frame_ref_offset(WASMLoaderContext *ctx, uint8 pop_cnt, } static bool -wasm_loader_get_const_offset(WASMLoaderContext *ctx, uint8 type, - void *value, int16 *offset, - char *error_buf, uint32 error_buf_size) +wasm_loader_get_const_offset(WASMLoaderContext *ctx, uint8 type, void *value, + int16 *offset, char *error_buf, + uint32 error_buf_size) { int16 operand_offset = 0; Const *c; for (c = (Const *)ctx->const_buf; - (uint8*)c < ctx->const_buf + ctx->num_const * sizeof(Const); c ++) { + (uint8 *)c < ctx->const_buf + ctx->num_const * sizeof(Const); c++) { if ((type == c->value_type) - && ((type == VALUE_TYPE_I64 && *(int64*)value == c->value.i64) - || (type == VALUE_TYPE_I32 && *(int32*)value == c->value.i32) + && ((type == VALUE_TYPE_I64 && *(int64 *)value == c->value.i64) + || (type == VALUE_TYPE_I32 && *(int32 *)value == c->value.i32) #if WASM_ENABLE_REF_TYPES != 0 - || (type == VALUE_TYPE_FUNCREF && *(int32*)value == c->value.i32) - || (type == VALUE_TYPE_EXTERNREF && *(int32*)value == c->value.i32) + || (type == VALUE_TYPE_FUNCREF + && *(int32 *)value == c->value.i32) + || (type == VALUE_TYPE_EXTERNREF + && *(int32 *)value == c->value.i32) #endif - || (type == VALUE_TYPE_F64 - && (0 == memcmp(value, &(c->value.f64), sizeof(float64)))) - || (type == VALUE_TYPE_F32 - && (0 == memcmp(value, &(c->value.f32), sizeof(float32)))))) { + || (type == VALUE_TYPE_F64 + && (0 == memcmp(value, &(c->value.f64), sizeof(float64)))) + || (type == VALUE_TYPE_F32 + && (0 + == memcmp(value, &(c->value.f32), sizeof(float32)))))) { operand_offset = c->slot_index; break; } - if (c->value_type == VALUE_TYPE_I64 - || c->value_type == VALUE_TYPE_F64) + if (c->value_type == VALUE_TYPE_I64 || c->value_type == VALUE_TYPE_F64) operand_offset += 2; else operand_offset += 1; } if ((uint8 *)c == ctx->const_buf + ctx->num_const * sizeof(Const)) { if ((uint8 *)c == ctx->const_buf + ctx->const_buf_size) { - MEM_REALLOC(ctx->const_buf, - ctx->const_buf_size, + MEM_REALLOC(ctx->const_buf, ctx->const_buf_size, ctx->const_buf_size + 4 * sizeof(Const)); ctx->const_buf_size += 4 * sizeof(Const); c = (Const *)(ctx->const_buf + ctx->num_const * sizeof(Const)); } c->value_type = type; switch (type) { - case VALUE_TYPE_F64: - bh_memcpy_s(&(c->value.f64), sizeof(WASMValue), value, sizeof(float64)); - ctx->const_cell_num += 2; - /* The const buf will be reversed, we use the second cell */ - /* of the i64/f64 const so the finnal offset is corrent */ - operand_offset ++; - break; - case VALUE_TYPE_I64: - c->value.i64 = *(int64*)value; - ctx->const_cell_num += 2; - operand_offset ++; - break; - case VALUE_TYPE_F32: - bh_memcpy_s(&(c->value.f32), sizeof(WASMValue), value, sizeof(float32)); - ctx->const_cell_num ++; - break; - case VALUE_TYPE_I32: - c->value.i32 = *(int32*)value; - ctx->const_cell_num ++; - break; + case VALUE_TYPE_F64: + bh_memcpy_s(&(c->value.f64), sizeof(WASMValue), value, + sizeof(float64)); + ctx->const_cell_num += 2; + /* The const buf will be reversed, we use the second cell */ + /* of the i64/f64 const so the finnal offset is corrent */ + operand_offset++; + break; + case VALUE_TYPE_I64: + c->value.i64 = *(int64 *)value; + ctx->const_cell_num += 2; + operand_offset++; + break; + case VALUE_TYPE_F32: + bh_memcpy_s(&(c->value.f32), sizeof(WASMValue), value, + sizeof(float32)); + ctx->const_cell_num++; + break; + case VALUE_TYPE_I32: + c->value.i32 = *(int32 *)value; + ctx->const_cell_num++; + break; #if WASM_ENABLE_REF_TYPES != 0 - case VALUE_TYPE_EXTERNREF: - case VALUE_TYPE_FUNCREF: - c->value.i32 = *(int32*)value; - ctx->const_cell_num ++; - break; + case VALUE_TYPE_EXTERNREF: + case VALUE_TYPE_FUNCREF: + c->value.i32 = *(int32 *)value; + ctx->const_cell_num++; + break; #endif - default: - break; + default: + break; } c->slot_index = operand_offset; - ctx->num_const ++; - LOG_OP("#### new const [%d]: %ld\n", - ctx->num_const, (int64)c->value.i64); + ctx->num_const++; + LOG_OP("#### new const [%d]: %ld\n", ctx->num_const, + (int64)c->value.i64); } /* use negetive index for const */ operand_offset = -(operand_offset + 1); @@ -4057,189 +4067,211 @@ fail: PUSH_XXX(); only push the frame_offset stack, no emit */ -#define PUSH_I32() do { \ - if (!wasm_loader_push_frame_ref_offset(loader_ctx, VALUE_TYPE_I32, \ - disable_emit, operand_offset,\ - error_buf, error_buf_size)) \ - goto fail; \ - } while (0) +#define PUSH_I32() \ + do { \ + if (!wasm_loader_push_frame_ref_offset(loader_ctx, VALUE_TYPE_I32, \ + disable_emit, operand_offset, \ + error_buf, error_buf_size)) \ + goto fail; \ + } while (0) -#define PUSH_F32() do { \ - if (!wasm_loader_push_frame_ref_offset(loader_ctx, VALUE_TYPE_F32, \ - disable_emit, operand_offset,\ - error_buf, error_buf_size)) \ - goto fail; \ - } while (0) +#define PUSH_F32() \ + do { \ + if (!wasm_loader_push_frame_ref_offset(loader_ctx, VALUE_TYPE_F32, \ + disable_emit, operand_offset, \ + error_buf, error_buf_size)) \ + goto fail; \ + } while (0) -#define PUSH_I64() do { \ - if (!wasm_loader_push_frame_ref_offset(loader_ctx, VALUE_TYPE_I64, \ - disable_emit, operand_offset,\ - error_buf, error_buf_size)) \ - goto fail; \ - } while (0) +#define PUSH_I64() \ + do { \ + if (!wasm_loader_push_frame_ref_offset(loader_ctx, VALUE_TYPE_I64, \ + disable_emit, operand_offset, \ + error_buf, error_buf_size)) \ + goto fail; \ + } while (0) -#define PUSH_F64() do { \ - if (!wasm_loader_push_frame_ref_offset(loader_ctx, VALUE_TYPE_F64, \ - disable_emit, operand_offset,\ - error_buf, error_buf_size)) \ - goto fail; \ - } while (0) +#define PUSH_F64() \ + do { \ + if (!wasm_loader_push_frame_ref_offset(loader_ctx, VALUE_TYPE_F64, \ + disable_emit, operand_offset, \ + error_buf, error_buf_size)) \ + goto fail; \ + } while (0) -#define PUSH_FUNCREF() do { \ - if (!wasm_loader_push_frame_ref_offset(loader_ctx, VALUE_TYPE_FUNCREF,\ - disable_emit, operand_offset,\ - error_buf, error_buf_size)) \ - goto fail; \ - } while (0) +#define PUSH_FUNCREF() \ + do { \ + if (!wasm_loader_push_frame_ref_offset(loader_ctx, VALUE_TYPE_FUNCREF, \ + disable_emit, operand_offset, \ + error_buf, error_buf_size)) \ + goto fail; \ + } while (0) -#define POP_I32() do { \ - if (!wasm_loader_pop_frame_ref_offset(loader_ctx, VALUE_TYPE_I32, \ - error_buf, error_buf_size)) \ - goto fail; \ - } while (0) +#define POP_I32() \ + do { \ + if (!wasm_loader_pop_frame_ref_offset(loader_ctx, VALUE_TYPE_I32, \ + error_buf, error_buf_size)) \ + goto fail; \ + } while (0) -#define POP_F32() do { \ - if (!wasm_loader_pop_frame_ref_offset(loader_ctx, VALUE_TYPE_F32, \ - error_buf, error_buf_size)) \ - goto fail; \ - } while (0) +#define POP_F32() \ + do { \ + if (!wasm_loader_pop_frame_ref_offset(loader_ctx, VALUE_TYPE_F32, \ + error_buf, error_buf_size)) \ + goto fail; \ + } while (0) -#define POP_I64() do { \ - if (!wasm_loader_pop_frame_ref_offset(loader_ctx, VALUE_TYPE_I64, \ - error_buf, error_buf_size)) \ - goto fail; \ - } while (0) +#define POP_I64() \ + do { \ + if (!wasm_loader_pop_frame_ref_offset(loader_ctx, VALUE_TYPE_I64, \ + error_buf, error_buf_size)) \ + goto fail; \ + } while (0) -#define POP_F64() do { \ - if (!wasm_loader_pop_frame_ref_offset(loader_ctx, VALUE_TYPE_F64, \ - error_buf, error_buf_size)) \ - goto fail; \ - } while (0) +#define POP_F64() \ + do { \ + if (!wasm_loader_pop_frame_ref_offset(loader_ctx, VALUE_TYPE_F64, \ + error_buf, error_buf_size)) \ + goto fail; \ + } while (0) -#define PUSH_OFFSET_TYPE(type) do { \ - if (!(wasm_loader_push_frame_offset(loader_ctx, type, \ - disable_emit, operand_offset, \ - error_buf, error_buf_size))) \ - goto fail; \ - } while (0) +#define PUSH_OFFSET_TYPE(type) \ + do { \ + if (!(wasm_loader_push_frame_offset(loader_ctx, type, disable_emit, \ + operand_offset, error_buf, \ + error_buf_size))) \ + goto fail; \ + } while (0) -#define POP_OFFSET_TYPE(type) do { \ - if (!(wasm_loader_pop_frame_offset(loader_ctx, type, \ - error_buf, error_buf_size))) \ - goto fail; \ - } while (0) +#define POP_OFFSET_TYPE(type) \ + do { \ + if (!(wasm_loader_pop_frame_offset(loader_ctx, type, error_buf, \ + error_buf_size))) \ + goto fail; \ + } while (0) -#define POP_AND_PUSH(type_pop, type_push) do { \ - if (!(wasm_loader_push_pop_frame_ref_offset(loader_ctx, 1, \ - type_push, type_pop, \ - disable_emit, operand_offset, \ - error_buf, error_buf_size))) \ - goto fail; \ - } while (0) +#define POP_AND_PUSH(type_pop, type_push) \ + do { \ + if (!(wasm_loader_push_pop_frame_ref_offset( \ + loader_ctx, 1, type_push, type_pop, disable_emit, \ + operand_offset, error_buf, error_buf_size))) \ + goto fail; \ + } while (0) /* type of POPs should be the same */ -#define POP2_AND_PUSH(type_pop, type_push) do { \ - if (!(wasm_loader_push_pop_frame_ref_offset(loader_ctx, 2, \ - type_push, type_pop, \ - disable_emit, operand_offset, \ - error_buf, error_buf_size))) \ - goto fail; \ - } while (0) +#define POP2_AND_PUSH(type_pop, type_push) \ + do { \ + if (!(wasm_loader_push_pop_frame_ref_offset( \ + loader_ctx, 2, type_push, type_pop, disable_emit, \ + operand_offset, error_buf, error_buf_size))) \ + goto fail; \ + } while (0) #else /* WASM_ENABLE_FAST_INTERP */ -#define PUSH_I32() do { \ - if (!(wasm_loader_push_frame_ref(loader_ctx, VALUE_TYPE_I32, \ - error_buf, error_buf_size))) \ - goto fail; \ - } while (0) +#define PUSH_I32() \ + do { \ + if (!(wasm_loader_push_frame_ref(loader_ctx, VALUE_TYPE_I32, \ + error_buf, error_buf_size))) \ + goto fail; \ + } while (0) -#define PUSH_F32() do { \ - if (!(wasm_loader_push_frame_ref(loader_ctx, VALUE_TYPE_F32, \ - error_buf, error_buf_size))) \ - goto fail; \ - } while (0) +#define PUSH_F32() \ + do { \ + if (!(wasm_loader_push_frame_ref(loader_ctx, VALUE_TYPE_F32, \ + error_buf, error_buf_size))) \ + goto fail; \ + } while (0) -#define PUSH_I64() do { \ - if (!(wasm_loader_push_frame_ref(loader_ctx, VALUE_TYPE_I64, \ - error_buf, error_buf_size))) \ - goto fail; \ - } while (0) +#define PUSH_I64() \ + do { \ + if (!(wasm_loader_push_frame_ref(loader_ctx, VALUE_TYPE_I64, \ + error_buf, error_buf_size))) \ + goto fail; \ + } while (0) -#define PUSH_F64() do { \ - if (!(wasm_loader_push_frame_ref(loader_ctx, VALUE_TYPE_F64, \ - error_buf, error_buf_size))) \ - goto fail; \ - } while (0) +#define PUSH_F64() \ + do { \ + if (!(wasm_loader_push_frame_ref(loader_ctx, VALUE_TYPE_F64, \ + error_buf, error_buf_size))) \ + goto fail; \ + } while (0) -#define PUSH_FUNCREF() do { \ - if (!(wasm_loader_push_frame_ref(loader_ctx, VALUE_TYPE_FUNCREF,\ - error_buf, error_buf_size))) \ - goto fail; \ - } while (0) - -#define POP_I32() do { \ - if (!(wasm_loader_pop_frame_ref(loader_ctx, VALUE_TYPE_I32, \ - error_buf, error_buf_size))) \ - goto fail; \ - } while (0) - -#define POP_F32() do { \ - if (!(wasm_loader_pop_frame_ref(loader_ctx, VALUE_TYPE_F32, \ - error_buf, error_buf_size))) \ - goto fail; \ - } while (0) - -#define POP_I64() do { \ - if (!(wasm_loader_pop_frame_ref(loader_ctx, VALUE_TYPE_I64, \ - error_buf, error_buf_size))) \ - goto fail; \ - } while (0) - -#define POP_F64() do { \ - if (!(wasm_loader_pop_frame_ref(loader_ctx, VALUE_TYPE_F64, \ - error_buf, error_buf_size))) \ - goto fail; \ - } while (0) - -#define POP_FUNCREF() do { \ - if (!(wasm_loader_pop_frame_ref(loader_ctx, VALUE_TYPE_FUNCREF, \ - error_buf, error_buf_size))) \ - goto fail; \ - } while (0) - -#define POP_AND_PUSH(type_pop, type_push) do { \ - if (!(wasm_loader_push_pop_frame_ref(loader_ctx, 1, \ - type_push, type_pop, \ +#define PUSH_FUNCREF() \ + do { \ + if (!(wasm_loader_push_frame_ref(loader_ctx, VALUE_TYPE_FUNCREF, \ error_buf, error_buf_size))) \ - goto fail; \ - } while (0) + goto fail; \ + } while (0) + +#define POP_I32() \ + do { \ + if (!(wasm_loader_pop_frame_ref(loader_ctx, VALUE_TYPE_I32, error_buf, \ + error_buf_size))) \ + goto fail; \ + } while (0) + +#define POP_F32() \ + do { \ + if (!(wasm_loader_pop_frame_ref(loader_ctx, VALUE_TYPE_F32, error_buf, \ + error_buf_size))) \ + goto fail; \ + } while (0) + +#define POP_I64() \ + do { \ + if (!(wasm_loader_pop_frame_ref(loader_ctx, VALUE_TYPE_I64, error_buf, \ + error_buf_size))) \ + goto fail; \ + } while (0) + +#define POP_F64() \ + do { \ + if (!(wasm_loader_pop_frame_ref(loader_ctx, VALUE_TYPE_F64, error_buf, \ + error_buf_size))) \ + goto fail; \ + } while (0) + +#define POP_FUNCREF() \ + do { \ + if (!(wasm_loader_pop_frame_ref(loader_ctx, VALUE_TYPE_FUNCREF, \ + error_buf, error_buf_size))) \ + goto fail; \ + } while (0) + +#define POP_AND_PUSH(type_pop, type_push) \ + do { \ + if (!(wasm_loader_push_pop_frame_ref(loader_ctx, 1, type_push, \ + type_pop, error_buf, \ + error_buf_size))) \ + goto fail; \ + } while (0) /* type of POPs should be the same */ -#define POP2_AND_PUSH(type_pop, type_push) do { \ - if (!(wasm_loader_push_pop_frame_ref(loader_ctx, 2, \ - type_push, type_pop, \ - error_buf, error_buf_size))) \ - goto fail; \ - } while (0) +#define POP2_AND_PUSH(type_pop, type_push) \ + do { \ + if (!(wasm_loader_push_pop_frame_ref(loader_ctx, 2, type_push, \ + type_pop, error_buf, \ + error_buf_size))) \ + goto fail; \ + } while (0) #endif /* WASM_ENABLE_FAST_INTERP */ #if WASM_ENABLE_FAST_INTERP != 0 static bool -reserve_block_ret(WASMLoaderContext *loader_ctx, - uint8 opcode, bool disable_emit, - char *error_buf, uint32 error_buf_size) +reserve_block_ret(WASMLoaderContext *loader_ctx, uint8 opcode, + bool disable_emit, char *error_buf, uint32 error_buf_size) { int16 operand_offset = 0; - BranchBlock *block = (opcode == WASM_OP_ELSE) ? - loader_ctx->frame_csp - 1 : loader_ctx->frame_csp; + BranchBlock *block = (opcode == WASM_OP_ELSE) ? loader_ctx->frame_csp - 1 + : loader_ctx->frame_csp; BlockType *block_type = &block->block_type; uint8 *return_types = NULL; uint32 return_count = 0, value_count = 0, total_cel_num = 0; int32 i = 0; - int16 dynamic_offset, dynamic_offset_org, - *frame_offset = NULL, *frame_offset_org = NULL; + int16 dynamic_offset, dynamic_offset_org, *frame_offset = NULL, + *frame_offset_org = NULL; return_count = block_type_get_result_types(block_type, &return_types); @@ -4251,7 +4283,8 @@ reserve_block_ret(WASMLoaderContext *loader_ctx, /* insert op_copy before else opcode */ if (opcode == WASM_OP_ELSE) skip_label(); - emit_label(cell == 1 ? EXT_OP_COPY_STACK_TOP : EXT_OP_COPY_STACK_TOP_I64); + emit_label(cell == 1 ? EXT_OP_COPY_STACK_TOP + : EXT_OP_COPY_STACK_TOP_I64); emit_operand(loader_ctx, *(loader_ctx->frame_offset - cell)); emit_operand(loader_ctx, block->dynamic_offset); @@ -4280,8 +4313,7 @@ reserve_block_ret(WASMLoaderContext *loader_ctx, */ frame_offset = frame_offset_org = loader_ctx->frame_offset; dynamic_offset = dynamic_offset_org = - block->dynamic_offset - + wasm_get_cell_num(return_types, return_count); + block->dynamic_offset + wasm_get_cell_num(return_types, return_count); /* First traversal to get the count of values needed to be copied. */ for (i = (int32)return_count - 1; i >= 0; i--) { @@ -4300,9 +4332,9 @@ reserve_block_ret(WASMLoaderContext *loader_ctx, uint8 *emit_data = NULL, *cells = NULL; int16 *src_offsets = NULL; uint16 *dst_offsets = NULL; - uint64 size = (uint64)value_count * (sizeof(*cells) - + sizeof(*src_offsets) - + sizeof(*dst_offsets)); + uint64 size = + (uint64)value_count + * (sizeof(*cells) + sizeof(*src_offsets) + sizeof(*dst_offsets)); /* Allocate memory for the emit data */ if (!(emit_data = loader_malloc(size, error_buf, error_buf_size))) @@ -4321,7 +4353,8 @@ reserve_block_ret(WASMLoaderContext *loader_ctx, /* Part b) */ emit_uint32(loader_ctx, total_cel_num); - /* Second traversal to get each value's cell num, src offset and dst offset. */ + /* Second traversal to get each value's cell num, src offset and dst + * offset. */ frame_offset = frame_offset_org; dynamic_offset = dynamic_offset_org; for (i = (int32)return_count - 1, j = 0; i >= 0; i--) { @@ -4374,56 +4407,62 @@ fail: #endif /* WASM_ENABLE_FAST_INTERP */ -#define RESERVE_BLOCK_RET() do { \ - if (!reserve_block_ret(loader_ctx, opcode, disable_emit, \ - error_buf, error_buf_size)) \ - goto fail; \ - } while (0) +#define RESERVE_BLOCK_RET() \ + do { \ + if (!reserve_block_ret(loader_ctx, opcode, disable_emit, error_buf, \ + error_buf_size)) \ + goto fail; \ + } while (0) -#define PUSH_TYPE(type) do { \ - if (!(wasm_loader_push_frame_ref(loader_ctx, type, \ - error_buf, error_buf_size))) \ - goto fail; \ - } while (0) +#define PUSH_TYPE(type) \ + do { \ + if (!(wasm_loader_push_frame_ref(loader_ctx, type, error_buf, \ + error_buf_size))) \ + goto fail; \ + } while (0) -#define POP_TYPE(type) do { \ - if (!(wasm_loader_pop_frame_ref(loader_ctx, type, \ - error_buf, error_buf_size))) \ - goto fail; \ - } while (0) +#define POP_TYPE(type) \ + do { \ + if (!(wasm_loader_pop_frame_ref(loader_ctx, type, error_buf, \ + error_buf_size))) \ + goto fail; \ + } while (0) -#define PUSH_CSP(label_type, block_type, _start_addr) do { \ - if (!wasm_loader_push_frame_csp(loader_ctx, label_type, block_type, \ - _start_addr, error_buf, \ - error_buf_size)) \ - goto fail; \ - } while (0) +#define PUSH_CSP(label_type, block_type, _start_addr) \ + do { \ + if (!wasm_loader_push_frame_csp(loader_ctx, label_type, block_type, \ + _start_addr, error_buf, \ + error_buf_size)) \ + goto fail; \ + } while (0) -#define POP_CSP() do { \ - if (!wasm_loader_pop_frame_csp(loader_ctx, \ - error_buf, error_buf_size)) \ - goto fail; \ - } while (0) +#define POP_CSP() \ + do { \ + if (!wasm_loader_pop_frame_csp(loader_ctx, error_buf, error_buf_size)) \ + goto fail; \ + } while (0) -#define GET_LOCAL_INDEX_TYPE_AND_OFFSET() do { \ - read_leb_uint32(p, p_end, local_idx); \ - bh_assert(local_idx < param_count + local_count);\ - local_type = local_idx < param_count \ - ? param_types[local_idx] \ - : local_types[local_idx - param_count]; \ - local_offset = local_offsets[local_idx]; \ - } while (0) +#define GET_LOCAL_INDEX_TYPE_AND_OFFSET() \ + do { \ + read_leb_uint32(p, p_end, local_idx); \ + bh_assert(local_idx < param_count + local_count); \ + local_type = local_idx < param_count \ + ? param_types[local_idx] \ + : local_types[local_idx - param_count]; \ + local_offset = local_offsets[local_idx]; \ + } while (0) -#define CHECK_BR(depth) do { \ - if (!wasm_loader_check_br(loader_ctx, depth, \ - error_buf, error_buf_size)) \ - goto fail; \ - } while (0) +#define CHECK_BR(depth) \ + do { \ + if (!wasm_loader_check_br(loader_ctx, depth, error_buf, \ + error_buf_size)) \ + goto fail; \ + } while (0) -#define CHECK_MEMORY() do { \ - bh_assert(module->import_memory_count \ - + module->memory_count > 0); \ - } while (0) +#define CHECK_MEMORY() \ + do { \ + bh_assert(module->import_memory_count + module->memory_count > 0); \ + } while (0) static bool is_value_type(uint8 type) @@ -4445,7 +4484,6 @@ is_byte_a_type(uint8 type) return is_value_type(type) || (type == VALUE_TYPE_VOID); } - static bool wasm_loader_check_br(WASMLoaderContext *loader_ctx, uint32 depth, char *error_buf, uint32 error_buf_size) @@ -4458,10 +4496,10 @@ wasm_loader_check_br(WASMLoaderContext *loader_ctx, uint32 depth, uint16 cell_num; if (loader_ctx->csp_num < depth + 1) { - set_error_buf(error_buf, error_buf_size, - "unknown label, " - "unexpected end of section or function"); - return false; + set_error_buf(error_buf, error_buf_size, + "unknown label, " + "unexpected end of section or function"); + return false; } cur_block = loader_ctx->frame_csp - 1; @@ -4481,7 +4519,7 @@ wasm_loader_check_br(WASMLoaderContext *loader_ctx, uint32 depth, * and then re-push the values to make the stack top values * match block type. */ if (cur_block->is_stack_polymorphic) { - for (i = (int32)arity -1; i >= 0; i--) { + for (i = (int32)arity - 1; i >= 0; i--) { #if WASM_ENABLE_FAST_INTERP != 0 POP_OFFSET_TYPE(types[i]); #endif @@ -4498,13 +4536,12 @@ wasm_loader_check_br(WASMLoaderContext *loader_ctx, uint32 depth, return true; } - available_stack_cell = (int32) - (loader_ctx->stack_cell_num - cur_block->stack_cell_num); + available_stack_cell = + (int32)(loader_ctx->stack_cell_num - cur_block->stack_cell_num); /* Check stack top values match target block type */ - for (i = (int32)arity -1; i >= 0; i--) { - if (!check_stack_top_values(frame_ref, available_stack_cell, - types[i], + for (i = (int32)arity - 1; i >= 0; i--) { + if (!check_stack_top_values(frame_ref, available_stack_cell, types[i], error_buf, error_buf_size)) return false; cell_num = wasm_value_type_cell_num(types[i]); @@ -4519,8 +4556,7 @@ fail: } static BranchBlock * -check_branch_block(WASMLoaderContext *loader_ctx, - uint8 **p_buf, uint8 *buf_end, +check_branch_block(WASMLoaderContext *loader_ctx, uint8 **p_buf, uint8 *buf_end, char *error_buf, uint32 error_buf_size) { uint8 *p = *p_buf, *p_end = buf_end; @@ -4550,19 +4586,18 @@ check_block_stack(WASMLoaderContext *loader_ctx, BranchBlock *block, int32 available_stack_cell, return_cell_num, i; uint8 *frame_ref = NULL; - available_stack_cell = (int32) - (loader_ctx->stack_cell_num - - block->stack_cell_num); + available_stack_cell = + (int32)(loader_ctx->stack_cell_num - block->stack_cell_num); return_count = block_type_get_result_types(block_type, &return_types); - return_cell_num = return_count > 0 ? - wasm_get_cell_num(return_types, return_count) : 0; + return_cell_num = + return_count > 0 ? wasm_get_cell_num(return_types, return_count) : 0; /* If the stack is in polymorphic state, just clear the stack * and then re-push the values to make the stack top values * match block type. */ if (block->is_stack_polymorphic) { - for (i = (int32)return_count -1; i >= 0; i--) { + for (i = (int32)return_count - 1; i >= 0; i--) { #if WASM_ENABLE_FAST_INTERP != 0 POP_OFFSET_TYPE(return_types[i]); #endif @@ -4588,10 +4623,9 @@ check_block_stack(WASMLoaderContext *loader_ctx, BranchBlock *block, /* Check stack values match return types */ frame_ref = loader_ctx->frame_ref; - for (i = (int32)return_count -1; i >= 0; i--) { + for (i = (int32)return_count - 1; i >= 0; i--) { if (!check_stack_top_values(frame_ref, available_stack_cell, - return_types[i], - error_buf, error_buf_size)) + return_types[i], error_buf, error_buf_size)) return false; frame_ref -= wasm_value_type_cell_num(return_types[i]); available_stack_cell -= wasm_value_type_cell_num(return_types[i]); @@ -4617,7 +4651,7 @@ fail: */ static bool copy_params_to_dynamic_space(WASMLoaderContext *loader_ctx, bool is_if_block, - char* error_buf, uint32 error_buf_size) + char *error_buf, uint32 error_buf_size) { int16 *frame_offset = NULL; uint8 *cells = NULL, cell; @@ -4632,8 +4666,7 @@ copy_params_to_dynamic_space(WASMLoaderContext *loader_ctx, bool is_if_block, bool disable_emit = false; int16 operand_offset = 0; - uint64 size = (uint64)param_count * (sizeof(*cells) - + sizeof(*src_offsets)); + uint64 size = (uint64)param_count * (sizeof(*cells) + sizeof(*src_offsets)); /* For if block, we also need copy the condition operand offset. */ if (is_if_block) @@ -4669,9 +4702,8 @@ copy_params_to_dynamic_space(WASMLoaderContext *loader_ctx, bool is_if_block, /* Part a) */ emit_uint32(loader_ctx, is_if_block ? param_count + 1 : param_count); /* Part b) */ - emit_uint32(loader_ctx, is_if_block ? - wasm_type->param_cell_num + 1 : - wasm_type->param_cell_num); + emit_uint32(loader_ctx, is_if_block ? wasm_type->param_cell_num + 1 + : wasm_type->param_cell_num); /* Part c) */ for (i = 0; i < param_count; i++) emit_byte(loader_ctx, cells[i]); @@ -4703,44 +4735,46 @@ fail: /* reset the stack to the state of before entering the last block */ #if WASM_ENABLE_FAST_INTERP != 0 -#define RESET_STACK() do { \ - loader_ctx->stack_cell_num = \ - (loader_ctx->frame_csp - 1)->stack_cell_num; \ - loader_ctx->frame_ref = \ - loader_ctx->frame_ref_bottom + loader_ctx->stack_cell_num; \ - loader_ctx->frame_offset = \ - loader_ctx->frame_offset_bottom + loader_ctx->stack_cell_num; \ -} while (0) +#define RESET_STACK() \ + do { \ + loader_ctx->stack_cell_num = \ + (loader_ctx->frame_csp - 1)->stack_cell_num; \ + loader_ctx->frame_ref = \ + loader_ctx->frame_ref_bottom + loader_ctx->stack_cell_num; \ + loader_ctx->frame_offset = \ + loader_ctx->frame_offset_bottom + loader_ctx->stack_cell_num; \ + } while (0) #else -#define RESET_STACK() do { \ - loader_ctx->stack_cell_num = \ - (loader_ctx->frame_csp - 1)->stack_cell_num; \ - loader_ctx->frame_ref = \ - loader_ctx->frame_ref_bottom + loader_ctx->stack_cell_num; \ -} while (0) +#define RESET_STACK() \ + do { \ + loader_ctx->stack_cell_num = \ + (loader_ctx->frame_csp - 1)->stack_cell_num; \ + loader_ctx->frame_ref = \ + loader_ctx->frame_ref_bottom + loader_ctx->stack_cell_num; \ + } while (0) #endif /* set current block's stack polymorphic state */ -#define SET_CUR_BLOCK_STACK_POLYMORPHIC_STATE(flag) do { \ - BranchBlock *cur_block = loader_ctx->frame_csp - 1; \ - cur_block->is_stack_polymorphic = flag; \ -} while (0) +#define SET_CUR_BLOCK_STACK_POLYMORPHIC_STATE(flag) \ + do { \ + BranchBlock *cur_block = loader_ctx->frame_csp - 1; \ + cur_block->is_stack_polymorphic = flag; \ + } while (0) #define BLOCK_HAS_PARAM(block_type) \ (!block_type.is_value_type && block_type.u.type->param_count > 0) -#define PRESERVE_LOCAL_FOR_BLOCK() do { \ - if (!(preserve_local_for_block(loader_ctx, opcode, \ - error_buf, error_buf_size))) { \ - goto fail; \ - } \ -} while (0) +#define PRESERVE_LOCAL_FOR_BLOCK() \ + do { \ + if (!(preserve_local_for_block(loader_ctx, opcode, error_buf, \ + error_buf_size))) { \ + goto fail; \ + } \ + } while (0) static bool -wasm_loader_prepare_bytecode(WASMModule *module, - WASMFunction *func, - uint32 cur_func_idx, - char *error_buf, +wasm_loader_prepare_bytecode(WASMModule *module, WASMFunction *func, + uint32 cur_func_idx, char *error_buf, uint32 error_buf_size) { uint8 *p = func->code, *p_end = func->code + func->code_size, *p_org; @@ -4767,9 +4801,7 @@ wasm_loader_prepare_bytecode(WASMModule *module, float64 f64; LOG_OP("\nProcessing func | [%d] params | [%d] locals | [%d] return\n", - func->param_cell_num, - func->local_cell_num, - func->ret_cell_num); + func->param_cell_num, func->local_cell_num, func->ret_cell_num); #endif global_count = module->import_global_count + module->global_count; @@ -4785,8 +4817,7 @@ wasm_loader_prepare_bytecode(WASMModule *module, local_offsets = func->local_offsets; if (!(loader_ctx = wasm_loader_ctx_init(func))) { - set_error_buf(error_buf, error_buf_size, - "allocate memory failed"); + set_error_buf(error_buf, error_buf_size, "allocate memory failed"); goto fail; } @@ -4794,8 +4825,7 @@ wasm_loader_prepare_bytecode(WASMModule *module, re_scan: if (loader_ctx->code_compiled_size > 0) { if (!wasm_loader_ctx_reinit(loader_ctx)) { - set_error_buf(error_buf, error_buf_size, - "allocate memory failed"); + set_error_buf(error_buf, error_buf_size, "allocate memory failed"); goto fail; } p = func->code; @@ -4837,7 +4867,7 @@ re_scan: #if WASM_ENABLE_FAST_INTERP != 0 PRESERVE_LOCAL_FOR_BLOCK(); #endif -handle_op_block_and_loop: + handle_op_block_and_loop: { uint8 value_type; BlockType block_type; @@ -4858,12 +4888,11 @@ handle_op_block_and_loop: bh_assert(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 \ - && WASM_ENABLE_WAMR_COMPILER == 0 \ +#if WASM_ENABLE_FAST_INTERP == 0 && WASM_ENABLE_WAMR_COMPILER == 0 \ && WASM_ENABLE_JIT == 0 /* If block use type index as block type, change the opcode - * to new extended opcode so that interpreter can resolve the - * block quickly. + * to new extended opcode so that interpreter can resolve + * the block quickly. */ *(p - 2) = EXT_OP_BLOCK + (opcode - WASM_OP_BLOCK); #endif @@ -4873,10 +4902,12 @@ handle_op_block_and_loop: if (BLOCK_HAS_PARAM(block_type)) { WASMType *wasm_type = block_type.u.type; for (i = 0; i < block_type.u.type->param_count; i++) - POP_TYPE(wasm_type->types[wasm_type->param_count - i - 1]); + POP_TYPE( + wasm_type->types[wasm_type->param_count - i - 1]); } - PUSH_CSP(LABEL_TYPE_BLOCK + (opcode - WASM_OP_BLOCK), block_type, p); + PUSH_CSP(LABEL_TYPE_BLOCK + (opcode - WASM_OP_BLOCK), + block_type, p); /* Pass parameters to block */ if (BLOCK_HAS_PARAM(block_type)) { @@ -4892,14 +4923,12 @@ handle_op_block_and_loop: 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, false, error_buf, error_buf_size)) goto fail; } (loader_ctx->frame_csp - 1)->code_compiled = - loader_ctx->p_code_compiled; + loader_ctx->p_code_compiled; } else if (opcode == WASM_OP_IF) { /* If block has parameters, we should make sure they are in @@ -4909,8 +4938,8 @@ handle_op_block_and_loop: * (func (export "params-id") (param i32) (result i32) * (i32.const 1) * (i32.const 2) - * (if (param i32 i32) (result i32 i32) (local.get 0) (then)) - * (i32.add) + * (if (param i32 i32) (result i32 i32) (local.get 0) + * (then)) (i32.add) * ) * * So we should emit a copy instruction before the if. @@ -4928,10 +4957,8 @@ handle_op_block_and_loop: /* 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, true, error_buf, error_buf_size)) goto fail; /* Emit the if instruction */ @@ -4939,16 +4966,17 @@ handle_op_block_and_loop: /* Emit the new condition operand offset */ POP_OFFSET_TYPE(VALUE_TYPE_I32); - /* Save top param_count values of frame_offset stack, so that - * we can recover it before executing else branch */ - size = sizeof(int16) * - (uint64)block_type.u.type->param_cell_num; - if (!(block->param_frame_offsets = - loader_malloc(size, error_buf, error_buf_size))) + /* Save top param_count values of frame_offset stack, so + * that we can recover it before executing else branch + */ + size = sizeof(int16) + * (uint64)block_type.u.type->param_cell_num; + if (!(block->param_frame_offsets = loader_malloc( + size, error_buf, error_buf_size))) goto fail; - bh_memcpy_s(block->param_frame_offsets, - (uint32)size, - loader_ctx->frame_offset - size/sizeof(int16), + bh_memcpy_s(block->param_frame_offsets, (uint32)size, + loader_ctx->frame_offset + - size / sizeof(int16), (uint32)size); } @@ -4964,7 +4992,7 @@ handle_op_block_and_loop: BlockType block_type = (loader_ctx->frame_csp - 1)->block_type; bh_assert(loader_ctx->csp_num >= 2 && (loader_ctx->frame_csp - 1)->label_type - == LABEL_TYPE_IF); + == LABEL_TYPE_IF); /* check whether if branch's stack matches its result type */ if (!check_block_stack(loader_ctx, loader_ctx->frame_csp - 1, @@ -4974,7 +5002,8 @@ handle_op_block_and_loop: (loader_ctx->frame_csp - 1)->else_addr = p - 1; #if WASM_ENABLE_FAST_INTERP != 0 - /* if the result of if branch is in local or const area, add a copy op */ + /* if the result of if branch is in local or const area, add a + * copy op */ RESERVE_BLOCK_RET(); emit_empty_label_addr_and_frame_ip(PATCH_END); @@ -4994,11 +5023,10 @@ handle_op_block_and_loop: if (BLOCK_HAS_PARAM((block_type))) { uint32 size; BranchBlock *block = loader_ctx->frame_csp - 1; - size = sizeof(int16) * - block_type.u.type->param_cell_num; + size = sizeof(int16) * block_type.u.type->param_cell_num; bh_memcpy_s(loader_ctx->frame_offset, size, block->param_frame_offsets, size); - loader_ctx->frame_offset += (size/sizeof(int16)); + loader_ctx->frame_offset += (size / sizeof(int16)); } #endif @@ -5010,11 +5038,12 @@ handle_op_block_and_loop: BranchBlock *cur_block = loader_ctx->frame_csp - 1; /* check whether block stack matches its result type */ - if (!check_block_stack(loader_ctx, cur_block, - error_buf, error_buf_size)) + if (!check_block_stack(loader_ctx, cur_block, error_buf, + error_buf_size)) goto fail; - /* if no else branch, and return types do not match param types, fail */ + /* if no else branch, and return types do not match param types, + * fail */ if (cur_block->label_type == LABEL_TYPE_IF && !cur_block->else_addr) { uint32 param_count = 0, ret_count = 0; @@ -5032,9 +5061,10 @@ handle_op_block_and_loop: param_types = block_type->u.type->types; ret_types = block_type->u.type->types + param_count; } - bh_assert(param_count == ret_count - && (!param_count - || !memcmp(param_types, ret_types, param_count))); + bh_assert( + param_count == ret_count + && (!param_count + || !memcmp(param_types, ret_types, param_count))); (void)ret_types; (void)ret_count; (void)param_types; @@ -5079,8 +5109,8 @@ handle_op_block_and_loop: case WASM_OP_BR: { - if (!(frame_csp_tmp = check_branch_block(loader_ctx, &p, p_end, - error_buf, error_buf_size))) + if (!(frame_csp_tmp = check_branch_block( + loader_ctx, &p, p_end, error_buf, error_buf_size))) goto fail; RESET_STACK(); @@ -5092,8 +5122,8 @@ handle_op_block_and_loop: { POP_I32(); - if (!(frame_csp_tmp = check_branch_block(loader_ctx, &p, p_end, - error_buf, error_buf_size))) + if (!(frame_csp_tmp = check_branch_block( + loader_ctx, &p, p_end, error_buf, error_buf_size))) goto fail; break; @@ -5112,8 +5142,8 @@ handle_op_block_and_loop: for (i = 0; i <= count; i++) { if (!(frame_csp_tmp = - check_branch_block(loader_ctx, &p, p_end, - error_buf, error_buf_size))) + check_branch_block(loader_ctx, &p, p_end, + error_buf, error_buf_size))) goto fail; } @@ -5129,7 +5159,8 @@ handle_op_block_and_loop: { int32 idx; uint8 ret_type; - for (idx = (int32)func->func_type->result_count - 1; idx >= 0; idx--) { + for (idx = (int32)func->func_type->result_count - 1; idx >= 0; + idx--) { ret_type = *(func->func_type->types + func->func_type->param_count + idx); POP_TYPE(ret_type); @@ -5161,16 +5192,20 @@ handle_op_block_and_loop: #endif bh_assert(func_idx < module->import_function_count - + module->function_count); + + module->function_count); if (func_idx < module->import_function_count) - func_type = module->import_functions[func_idx].u.function.func_type; - else func_type = - module->functions[func_idx - module->import_function_count]->func_type; + module->import_functions[func_idx].u.function.func_type; + else + func_type = module + ->functions[func_idx + - module->import_function_count] + ->func_type; if (func_type->param_count > 0) { - for (idx = (int32)(func_type->param_count - 1); idx >= 0; idx--) { + for (idx = (int32)(func_type->param_count - 1); idx >= 0; + idx--) { POP_TYPE(func_type->types[idx]); #if WASM_ENABLE_FAST_INTERP != 0 POP_OFFSET_TYPE(func_type->types[idx]); @@ -5184,20 +5219,24 @@ handle_op_block_and_loop: for (i = 0; i < func_type->result_count; i++) { PUSH_TYPE(func_type->types[func_type->param_count + i]); #if WASM_ENABLE_FAST_INTERP != 0 - /* Here we emit each return value's dynamic_offset. But in fact - * these offsets are continuous, so interpreter only need to get - * the first return value's offset. + /* Here we emit each return value's dynamic_offset. But + * in fact these offsets are continuous, so interpreter + * only need to get the first return value's offset. */ - PUSH_OFFSET_TYPE(func_type->types[func_type->param_count + i]); + PUSH_OFFSET_TYPE( + func_type->types[func_type->param_count + i]); #endif } #if WASM_ENABLE_TAIL_CALL != 0 } else { - bh_assert(func_type->result_count == func->func_type->result_count); + bh_assert(func_type->result_count + == func->func_type->result_count); for (i = 0; i < func_type->result_count; i++) { - bh_assert(func_type->types[func_type->param_count + i] == - func->func_type->types[func->func_type->param_count + i]); + bh_assert( + func_type->types[func_type->param_count + i] + == func->func_type + ->types[func->func_type->param_count + i]); } } #endif @@ -5214,8 +5253,7 @@ handle_op_block_and_loop: WASMType *func_type; uint32 type_idx, table_idx; - bh_assert(module->import_table_count - + module->table_count > 0); + bh_assert(module->import_table_count + module->table_count > 0); read_leb_uint32(p, p_end, type_idx); @@ -5237,7 +5275,6 @@ handle_op_block_and_loop: goto fail; } - #if WASM_ENABLE_FAST_INTERP != 0 /* we need to emit before arguments */ emit_uint32(loader_ctx, type_idx); @@ -5252,7 +5289,8 @@ handle_op_block_and_loop: func_type = module->types[type_idx]; if (func_type->param_count > 0) { - for (idx = (int32)(func_type->param_count - 1); idx >= 0; idx--) { + for (idx = (int32)(func_type->param_count - 1); idx >= 0; + idx--) { POP_TYPE(func_type->types[idx]); #if WASM_ENABLE_FAST_INTERP != 0 POP_OFFSET_TYPE(func_type->types[idx]); @@ -5266,16 +5304,20 @@ handle_op_block_and_loop: for (i = 0; i < func_type->result_count; i++) { PUSH_TYPE(func_type->types[func_type->param_count + i]); #if WASM_ENABLE_FAST_INTERP != 0 - PUSH_OFFSET_TYPE(func_type->types[func_type->param_count + i]); + PUSH_OFFSET_TYPE( + func_type->types[func_type->param_count + i]); #endif } #if WASM_ENABLE_TAIL_CALL != 0 } else { - bh_assert(func_type->result_count == func->func_type->result_count); + bh_assert(func_type->result_count + == func->func_type->result_count); for (i = 0; i < func_type->result_count; i++) { - bh_assert(func_type->types[func_type->param_count + i] == - func->func_type->types[func->func_type->param_count + i]); + bh_assert( + func_type->types[func_type->param_count + i] + == func->func_type + ->types[func->func_type->param_count + i]); } } #endif @@ -5288,8 +5330,9 @@ handle_op_block_and_loop: case WASM_OP_DROP_64: { BranchBlock *cur_block = loader_ctx->frame_csp - 1; - int32 available_stack_cell = (int32) - (loader_ctx->stack_cell_num - cur_block->stack_cell_num); + int32 available_stack_cell = + (int32)(loader_ctx->stack_cell_num + - cur_block->stack_cell_num); bh_assert(!(available_stack_cell <= 0 && !cur_block->is_stack_polymorphic)); @@ -5302,9 +5345,9 @@ handle_op_block_and_loop: #if WASM_ENABLE_FAST_INTERP != 0 skip_label(); loader_ctx->frame_offset--; - if (*(loader_ctx->frame_offset) > - loader_ctx->start_dynamic_offset) - loader_ctx->dynamic_offset --; + if (*(loader_ctx->frame_offset) + > loader_ctx->start_dynamic_offset) + loader_ctx->dynamic_offset--; #endif } else { @@ -5316,8 +5359,8 @@ handle_op_block_and_loop: #if WASM_ENABLE_FAST_INTERP != 0 skip_label(); loader_ctx->frame_offset -= 2; - if (*(loader_ctx->frame_offset) > - loader_ctx->start_dynamic_offset) + if (*(loader_ctx->frame_offset) + > loader_ctx->start_dynamic_offset) loader_ctx->dynamic_offset -= 2; #endif } @@ -5339,8 +5382,8 @@ handle_op_block_and_loop: POP_I32(); - available_stack_cell = (int32) - (loader_ctx->stack_cell_num - cur_block->stack_cell_num); + available_stack_cell = (int32)(loader_ctx->stack_cell_num + - cur_block->stack_cell_num); bh_assert(!(available_stack_cell <= 0 && !cur_block->is_stack_polymorphic)); @@ -5362,21 +5405,24 @@ handle_op_block_and_loop: loader_ctx->p_code_compiled - 2; #if WASM_ENABLE_LABELS_AS_VALUES != 0 #if WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS != 0 - *(void**)(p_code_compiled_tmp - sizeof(void*)) = - handle_table[opcode_tmp]; + *(void **)(p_code_compiled_tmp + - sizeof(void *)) = + handle_table[opcode_tmp]; #else - int32 offset = (int32) - ((uint8*)handle_table[opcode_tmp] - - (uint8*)handle_table[0]); - if (!(offset >= INT16_MIN && offset < INT16_MAX)) { + int32 offset = + (int32)((uint8 *)handle_table[opcode_tmp] + - (uint8 *)handle_table[0]); + if (!(offset >= INT16_MIN + && offset < INT16_MAX)) { set_error_buf(error_buf, error_buf_size, - "pre-compiled label offset out of range"); + "pre-compiled label offset " + "out of range"); goto fail; } - *(int16*)(p_code_compiled_tmp - sizeof(int16)) = - (int16)offset; + *(int16 *)(p_code_compiled_tmp + - sizeof(int16)) = (int16)offset; #endif /* end of WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS */ -#else /* else of WASM_ENABLE_LABELS_AS_VALUES */ +#else /* else of WASM_ENABLE_LABELS_AS_VALUES */ #if WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS != 0 *(p_code_compiled_tmp - 1) = opcode_tmp; #else @@ -5449,21 +5495,20 @@ handle_op_block_and_loop: #if WASM_ENABLE_LABELS_AS_VALUES != 0 #if WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS != 0 - *(void**)(p_code_compiled_tmp - sizeof(void*)) = - handle_table[opcode_tmp]; + *(void **)(p_code_compiled_tmp - sizeof(void *)) = + handle_table[opcode_tmp]; #else - int32 offset = (int32) - ((uint8*)handle_table[opcode_tmp] - - (uint8*)handle_table[0]); + int32 offset = (int32)((uint8 *)handle_table[opcode_tmp] + - (uint8 *)handle_table[0]); if (!(offset >= INT16_MIN && offset < INT16_MAX)) { set_error_buf(error_buf, error_buf_size, "pre-compiled label offset out of range"); goto fail; } - *(int16*)(p_code_compiled_tmp - sizeof(int16)) = - (int16)offset; + *(int16 *)(p_code_compiled_tmp - sizeof(int16)) = + (int16)offset; #endif /* end of WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS */ -#else /* else of WASM_ENABLE_LABELS_AS_VALUES */ +#else /* else of WASM_ENABLE_LABELS_AS_VALUES */ #if WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS != 0 *(p_code_compiled_tmp - 1) = opcode_tmp; #else @@ -5497,7 +5542,8 @@ handle_op_block_and_loop: uint32 table_idx; if (!wasm_get_ref_types_flag()) { - goto fail;; + goto fail; + ; } read_leb_uint32(p, p_end, table_idx); @@ -5530,7 +5576,8 @@ handle_op_block_and_loop: uint8 ref_type; if (!wasm_get_ref_types_flag()) { - goto fail;; + goto fail; + ; } CHECK_BUF(p, p_end, 1); @@ -5550,25 +5597,25 @@ handle_op_block_and_loop: case WASM_OP_REF_IS_NULL: { if (!wasm_get_ref_types_flag()) { - goto fail;; + goto fail; + ; } #if WASM_ENABLE_FAST_INTERP != 0 - if (!wasm_loader_pop_frame_ref_offset( - loader_ctx, VALUE_TYPE_FUNCREF, - error_buf, error_buf_size) + if (!wasm_loader_pop_frame_ref_offset(loader_ctx, + VALUE_TYPE_FUNCREF, + error_buf, error_buf_size) && !wasm_loader_pop_frame_ref_offset( - loader_ctx, VALUE_TYPE_EXTERNREF, - error_buf, error_buf_size)) { + loader_ctx, VALUE_TYPE_EXTERNREF, error_buf, + error_buf_size)) { goto fail; } #else - if (!wasm_loader_pop_frame_ref( - loader_ctx, VALUE_TYPE_FUNCREF, - error_buf, error_buf_size) - && !wasm_loader_pop_frame_ref( - loader_ctx, VALUE_TYPE_EXTERNREF, - error_buf, error_buf_size)) { + if (!wasm_loader_pop_frame_ref(loader_ctx, VALUE_TYPE_FUNCREF, + error_buf, error_buf_size) + && !wasm_loader_pop_frame_ref(loader_ctx, + VALUE_TYPE_EXTERNREF, + error_buf, error_buf_size)) { goto fail; } #endif @@ -5579,7 +5626,8 @@ handle_op_block_and_loop: { uint32 func_idx = 0; if (!wasm_get_ref_types_flag()) { - goto fail;; + goto fail; + ; } read_leb_uint32(p, p_end, func_idx); @@ -5598,8 +5646,9 @@ handle_op_block_and_loop: for (i = 0; i < module->table_seg_count; i++, table_seg++) { if (table_seg->elem_type == VALUE_TYPE_FUNCREF && wasm_elem_is_declarative(table_seg->mode)) { - for (j =0; j < table_seg->function_count; j++) { - if (table_seg->func_indexes[j] == cur_func_idx) { + for (j = 0; j < table_seg->function_count; j++) { + if (table_seg->func_indexes[j] + == cur_func_idx) { func_declared = true; break; } @@ -5656,22 +5705,24 @@ handle_op_block_and_loop: POP_TYPE(local_type); #if WASM_ENABLE_FAST_INTERP != 0 - if (!(preserve_referenced_local(loader_ctx, opcode, local_offset, - local_type, &preserve_local, - error_buf, error_buf_size))) + if (!(preserve_referenced_local( + loader_ctx, opcode, local_offset, local_type, + &preserve_local, error_buf, error_buf_size))) goto fail; if (local_offset < 256) { skip_label(); if ((!preserve_local) && (LAST_OP_OUTPUT_I32())) { if (loader_ctx->p_code_compiled) - STORE_U16(loader_ctx->p_code_compiled - 2, local_offset); - loader_ctx->frame_offset --; - loader_ctx->dynamic_offset --; + STORE_U16(loader_ctx->p_code_compiled - 2, + local_offset); + loader_ctx->frame_offset--; + loader_ctx->dynamic_offset--; } else if ((!preserve_local) && (LAST_OP_OUTPUT_I64())) { if (loader_ctx->p_code_compiled) - STORE_U16(loader_ctx->p_code_compiled - 2, local_offset); + STORE_U16(loader_ctx->p_code_compiled - 2, + local_offset); loader_ctx->frame_offset -= 2; loader_ctx->dynamic_offset -= 2; } @@ -5687,7 +5738,7 @@ handle_op_block_and_loop: POP_OFFSET_TYPE(local_type); } } - else { /* local index larger than 255, reserve leb */ + else { /* local index larger than 255, reserve leb */ emit_uint32(loader_ctx, local_idx); POP_OFFSET_TYPE(local_type); } @@ -5713,8 +5764,8 @@ handle_op_block_and_loop: GET_LOCAL_INDEX_TYPE_AND_OFFSET(); #if WASM_ENABLE_FAST_INTERP != 0 /* If the stack is in polymorphic state, do fake pop and push on - offset stack to keep the depth of offset stack to be the same - with ref stack */ + offset stack to keep the depth of offset stack to be the + same with ref stack */ BranchBlock *cur_block = loader_ctx->frame_csp - 1; if (cur_block->is_stack_polymorphic) { POP_OFFSET_TYPE(local_type); @@ -5725,9 +5776,9 @@ handle_op_block_and_loop: PUSH_TYPE(local_type); #if WASM_ENABLE_FAST_INTERP != 0 - if (!(preserve_referenced_local(loader_ctx, opcode, local_offset, - local_type, &preserve_local, - error_buf, error_buf_size))) + if (!(preserve_referenced_local( + loader_ctx, opcode, local_offset, local_type, + &preserve_local, error_buf, error_buf_size))) goto fail; if (local_offset < 256) { @@ -5741,11 +5792,12 @@ handle_op_block_and_loop: emit_byte(loader_ctx, (uint8)local_offset); } } - else { /* local index larger than 255, reserve leb */ + else { /* local index larger than 255, reserve leb */ emit_uint32(loader_ctx, local_idx); } - emit_operand(loader_ctx, *(loader_ctx->frame_offset - - wasm_value_type_cell_num(local_type))); + emit_operand(loader_ctx, + *(loader_ctx->frame_offset + - wasm_value_type_cell_num(local_type))); #else #if (WASM_ENABLE_WAMR_COMPILER == 0) && (WASM_ENABLE_JIT == 0) if (local_offset < 0x80) { @@ -5769,10 +5821,12 @@ handle_op_block_and_loop: bh_assert(global_idx < global_count); global_type = - global_idx < module->import_global_count - ? module->import_globals[global_idx].u.global.type - : module->globals[global_idx - module->import_global_count] - .type; + global_idx < module->import_global_count + ? module->import_globals[global_idx].u.global.type + : module + ->globals[global_idx + - module->import_global_count] + .type; PUSH_TYPE(global_type); @@ -5783,7 +5837,7 @@ handle_op_block_and_loop: *p_org = WASM_OP_GET_GLOBAL_64; } #endif -#else /* else of WASM_ENABLE_FAST_INTERP */ +#else /* else of WASM_ENABLE_FAST_INTERP */ if (is_64bit_type(global_type)) { skip_label(); emit_label(WASM_OP_GET_GLOBAL_64); @@ -5803,17 +5857,21 @@ handle_op_block_and_loop: bh_assert(global_idx < global_count); is_mutable = - global_idx < module->import_global_count - ? module->import_globals[global_idx].u.global.is_mutable - : module->globals[global_idx - module->import_global_count] - .is_mutable; + global_idx < module->import_global_count + ? module->import_globals[global_idx].u.global.is_mutable + : module + ->globals[global_idx + - module->import_global_count] + .is_mutable; bh_assert(is_mutable); global_type = - global_idx < module->import_global_count - ? module->import_globals[global_idx].u.global.type - : module->globals[global_idx - module->import_global_count] - .type; + global_idx < module->import_global_count + ? module->import_globals[global_idx].u.global.type + : module + ->globals[global_idx + - module->import_global_count] + .type; POP_TYPE(global_type); @@ -5827,7 +5885,7 @@ handle_op_block_and_loop: *p_org = WASM_OP_SET_GLOBAL_AUX_STACK; } #endif -#else /* else of WASM_ENABLE_FAST_INTERP */ +#else /* else of WASM_ENABLE_FAST_INTERP */ if (is_64bit_type(global_type)) { skip_label(); emit_label(WASM_OP_SET_GLOBAL_64); @@ -5891,13 +5949,12 @@ handle_op_block_and_loop: } #endif CHECK_MEMORY(); - read_leb_uint32(p, p_end, align); /* align */ + read_leb_uint32(p, p_end, align); /* align */ read_leb_uint32(p, p_end, mem_offset); /* offset */ #if WASM_ENABLE_FAST_INTERP != 0 emit_uint32(loader_ctx, mem_offset); #endif - switch (opcode) - { + switch (opcode) { /* load */ case WASM_OP_I32_LOAD: case WASM_OP_I32_LOAD8_S: @@ -5997,7 +6054,8 @@ handle_op_block_and_loop: #if WASM_ENABLE_FAST_INTERP != 0 skip_label(); disable_emit = true; - bh_memcpy_s((uint8*)&f32, sizeof(float32), p_org, sizeof(float32)); + bh_memcpy_s((uint8 *)&f32, sizeof(float32), p_org, + sizeof(float32)); GET_CONST_F32_OFFSET(VALUE_TYPE_F32, f32); #endif PUSH_F32(); @@ -6009,7 +6067,8 @@ handle_op_block_and_loop: skip_label(); disable_emit = true; /* Some MCU may require 8-byte align */ - bh_memcpy_s((uint8*)&f64, sizeof(float64), p_org, sizeof(float64)); + bh_memcpy_s((uint8 *)&f64, sizeof(float64), p_org, + sizeof(float64)); GET_CONST_F64_OFFSET(VALUE_TYPE_F64, f64); #endif PUSH_F64(); @@ -6248,227 +6307,236 @@ handle_op_block_and_loop: emit_byte(loader_ctx, ((uint8)opcode1)); #endif switch (opcode1) { - case WASM_OP_I32_TRUNC_SAT_S_F32: - case WASM_OP_I32_TRUNC_SAT_U_F32: - POP_AND_PUSH(VALUE_TYPE_F32, VALUE_TYPE_I32); - break; - case WASM_OP_I32_TRUNC_SAT_S_F64: - case WASM_OP_I32_TRUNC_SAT_U_F64: - POP_AND_PUSH(VALUE_TYPE_F64, VALUE_TYPE_I32); - break; - case WASM_OP_I64_TRUNC_SAT_S_F32: - case WASM_OP_I64_TRUNC_SAT_U_F32: - POP_AND_PUSH(VALUE_TYPE_F32, VALUE_TYPE_I64); - break; - case WASM_OP_I64_TRUNC_SAT_S_F64: - case WASM_OP_I64_TRUNC_SAT_U_F64: - POP_AND_PUSH(VALUE_TYPE_F64, VALUE_TYPE_I64); - break; + case WASM_OP_I32_TRUNC_SAT_S_F32: + case WASM_OP_I32_TRUNC_SAT_U_F32: + POP_AND_PUSH(VALUE_TYPE_F32, VALUE_TYPE_I32); + break; + case WASM_OP_I32_TRUNC_SAT_S_F64: + case WASM_OP_I32_TRUNC_SAT_U_F64: + POP_AND_PUSH(VALUE_TYPE_F64, VALUE_TYPE_I32); + break; + case WASM_OP_I64_TRUNC_SAT_S_F32: + case WASM_OP_I64_TRUNC_SAT_U_F32: + POP_AND_PUSH(VALUE_TYPE_F32, VALUE_TYPE_I64); + break; + case WASM_OP_I64_TRUNC_SAT_S_F64: + case WASM_OP_I64_TRUNC_SAT_U_F64: + POP_AND_PUSH(VALUE_TYPE_F64, VALUE_TYPE_I64); + break; #if WASM_ENABLE_BULK_MEMORY != 0 - case WASM_OP_MEMORY_INIT: - read_leb_uint32(p, p_end, segment_index); + case WASM_OP_MEMORY_INIT: + read_leb_uint32(p, p_end, segment_index); #if WASM_ENABLE_FAST_INTERP != 0 - emit_uint32(loader_ctx, segment_index); + emit_uint32(loader_ctx, segment_index); #endif - bh_assert(module->import_memory_count - + module->memory_count > 0); + bh_assert(module->import_memory_count + + module->memory_count + > 0); - bh_assert(*p == 0x00); - p++; + bh_assert(*p == 0x00); + p++; - bh_assert(segment_index < module->data_seg_count); - bh_assert(module->data_seg_count1 > 0); + bh_assert(segment_index < module->data_seg_count); + bh_assert(module->data_seg_count1 > 0); - POP_I32(); - POP_I32(); - POP_I32(); - break; - case WASM_OP_DATA_DROP: - read_leb_uint32(p, p_end, segment_index); + POP_I32(); + POP_I32(); + POP_I32(); + break; + case WASM_OP_DATA_DROP: + read_leb_uint32(p, p_end, segment_index); #if WASM_ENABLE_FAST_INTERP != 0 - emit_uint32(loader_ctx, segment_index); + emit_uint32(loader_ctx, segment_index); #endif - bh_assert(segment_index < module->data_seg_count); - bh_assert(module->data_seg_count1 > 0); - break; - case WASM_OP_MEMORY_COPY: - /* both src and dst memory index should be 0 */ - bh_assert(*(int16*)p != 0x0000); - p += 2; + bh_assert(segment_index < module->data_seg_count); + bh_assert(module->data_seg_count1 > 0); + break; + case WASM_OP_MEMORY_COPY: + /* both src and dst memory index should be 0 */ + bh_assert(*(int16 *)p != 0x0000); + p += 2; - bh_assert(module->import_memory_count - + module->memory_count > 0); + bh_assert(module->import_memory_count + + module->memory_count + > 0); - POP_I32(); - POP_I32(); - POP_I32(); - break; - case WASM_OP_MEMORY_FILL: - bh_assert(*p == 0); - p++; + POP_I32(); + POP_I32(); + POP_I32(); + break; + case WASM_OP_MEMORY_FILL: + bh_assert(*p == 0); + p++; - bh_assert(module->import_memory_count - + module->memory_count > 0); + bh_assert(module->import_memory_count + + module->memory_count + > 0); - POP_I32(); - POP_I32(); - POP_I32(); - break; + POP_I32(); + POP_I32(); + POP_I32(); + break; #endif /* WASM_ENABLE_BULK_MEMORY */ #if WASM_ENABLE_REF_TYPES != 0 - case WASM_OP_TABLE_INIT: - { - uint8 seg_ref_type, tbl_ref_type; - uint32 table_seg_idx, table_idx; + case WASM_OP_TABLE_INIT: + { + uint8 seg_ref_type, tbl_ref_type; + uint32 table_seg_idx, table_idx; - if (!wasm_get_ref_types_flag()) { - goto fail; - } + if (!wasm_get_ref_types_flag()) { + goto fail; + } - read_leb_uint32(p, p_end, table_seg_idx); - read_leb_uint32(p, p_end, table_idx); + read_leb_uint32(p, p_end, table_seg_idx); + read_leb_uint32(p, p_end, table_idx); - if (!get_table_elem_type(module, table_idx, &tbl_ref_type, - error_buf, error_buf_size)) - goto fail; - - if (!get_table_seg_elem_type(module, table_seg_idx, - &seg_ref_type, error_buf, + if (!get_table_elem_type(module, table_idx, + &tbl_ref_type, error_buf, error_buf_size)) - goto fail; + goto fail; - if (seg_ref_type != tbl_ref_type) { - set_error_buf(error_buf, error_buf_size, - "type mismatch"); - goto fail; - } + if (!get_table_seg_elem_type(module, table_seg_idx, + &seg_ref_type, error_buf, + error_buf_size)) + goto fail; -#if WASM_ENABLE_FAST_INTERP != 0 - emit_uint32(loader_ctx, table_seg_idx); - emit_uint32(loader_ctx, table_idx); -#endif - POP_I32(); - POP_I32(); - POP_I32(); - break; - } - case WASM_OP_ELEM_DROP: - { - uint32 table_seg_idx; - if (!wasm_get_ref_types_flag()) { - goto fail; - } - - read_leb_uint32(p, p_end, table_seg_idx); - if (!get_table_seg_elem_type(module, table_seg_idx, NULL, - error_buf, error_buf_size)) - goto fail; -#if WASM_ENABLE_FAST_INTERP != 0 - emit_uint32(loader_ctx, table_seg_idx); -#endif - break; - } - case WASM_OP_TABLE_COPY: - { - uint8 src_ref_type, dst_ref_type; - uint32 src_tbl_idx, dst_tbl_idx; - - if (!wasm_get_ref_types_flag()) { - goto fail; - } - - read_leb_uint32(p, p_end, src_tbl_idx); - if (!get_table_elem_type(module, src_tbl_idx, &src_ref_type, - error_buf, error_buf_size)) - goto fail; - - read_leb_uint32(p, p_end, dst_tbl_idx); - if (!get_table_elem_type(module, dst_tbl_idx, &dst_ref_type, - error_buf, error_buf_size)) - goto fail; - - if (src_ref_type != dst_ref_type) { - set_error_buf(error_buf, error_buf_size, - "type mismatch"); - goto fail; - } - -#if WASM_ENABLE_FAST_INTERP != 0 - emit_uint32(loader_ctx, src_tbl_idx); - emit_uint32(loader_ctx, dst_tbl_idx); -#endif - POP_I32(); - POP_I32(); - POP_I32(); - break; - } - case WASM_OP_TABLE_SIZE: - { - uint32 table_idx; - if (!wasm_get_ref_types_flag()) { - goto fail; - } - - read_leb_uint32(p, p_end, table_idx); - /* TODO: shall we create a new function to check - table idx instead of using below function? */ - if (!get_table_elem_type(module, table_idx, NULL, - error_buf, error_buf_size)) - goto fail; - -#if WASM_ENABLE_FAST_INTERP != 0 - emit_uint32(loader_ctx, table_idx); -#endif - - PUSH_I32(); - break; - } - case WASM_OP_TABLE_GROW: - case WASM_OP_TABLE_FILL: - { - uint8 decl_ref_type; - uint32 table_idx; - - if (!wasm_get_ref_types_flag()) { - goto fail; - } - - read_leb_uint32(p, p_end, table_idx); - if (!get_table_elem_type(module, table_idx, - &decl_ref_type, error_buf, - error_buf_size)) - goto fail; - - if (opcode1 == WASM_OP_TABLE_GROW) { - if (table_idx < module->import_table_count) { - module->import_tables[table_idx] - .u.table.possible_grow = true; + if (seg_ref_type != tbl_ref_type) { + set_error_buf(error_buf, error_buf_size, + "type mismatch"); + goto fail; } - else { - module->tables[table_idx - module->import_table_count] - .possible_grow = true; - } - } #if WASM_ENABLE_FAST_INTERP != 0 - emit_uint32(loader_ctx, table_idx); + emit_uint32(loader_ctx, table_seg_idx); + emit_uint32(loader_ctx, table_idx); #endif - - POP_I32(); -#if WASM_ENABLE_FAST_INTERP != 0 - POP_OFFSET_TYPE(decl_ref_type); -#endif - POP_TYPE(decl_ref_type); - if (opcode1 == WASM_OP_TABLE_GROW) - PUSH_I32(); - else POP_I32(); - break; - } + POP_I32(); + POP_I32(); + break; + } + case WASM_OP_ELEM_DROP: + { + uint32 table_seg_idx; + if (!wasm_get_ref_types_flag()) { + goto fail; + } + + read_leb_uint32(p, p_end, table_seg_idx); + if (!get_table_seg_elem_type(module, table_seg_idx, + NULL, error_buf, + error_buf_size)) + goto fail; +#if WASM_ENABLE_FAST_INTERP != 0 + emit_uint32(loader_ctx, table_seg_idx); +#endif + break; + } + case WASM_OP_TABLE_COPY: + { + uint8 src_ref_type, dst_ref_type; + uint32 src_tbl_idx, dst_tbl_idx; + + if (!wasm_get_ref_types_flag()) { + goto fail; + } + + read_leb_uint32(p, p_end, src_tbl_idx); + if (!get_table_elem_type(module, src_tbl_idx, + &src_ref_type, error_buf, + error_buf_size)) + goto fail; + + read_leb_uint32(p, p_end, dst_tbl_idx); + if (!get_table_elem_type(module, dst_tbl_idx, + &dst_ref_type, error_buf, + error_buf_size)) + goto fail; + + if (src_ref_type != dst_ref_type) { + set_error_buf(error_buf, error_buf_size, + "type mismatch"); + goto fail; + } + +#if WASM_ENABLE_FAST_INTERP != 0 + emit_uint32(loader_ctx, src_tbl_idx); + emit_uint32(loader_ctx, dst_tbl_idx); +#endif + POP_I32(); + POP_I32(); + POP_I32(); + break; + } + case WASM_OP_TABLE_SIZE: + { + uint32 table_idx; + if (!wasm_get_ref_types_flag()) { + goto fail; + } + + read_leb_uint32(p, p_end, table_idx); + /* TODO: shall we create a new function to check + table idx instead of using below function? */ + if (!get_table_elem_type(module, table_idx, NULL, + error_buf, error_buf_size)) + goto fail; + +#if WASM_ENABLE_FAST_INTERP != 0 + emit_uint32(loader_ctx, table_idx); +#endif + + PUSH_I32(); + break; + } + case WASM_OP_TABLE_GROW: + case WASM_OP_TABLE_FILL: + { + uint8 decl_ref_type; + uint32 table_idx; + + if (!wasm_get_ref_types_flag()) { + goto fail; + } + + read_leb_uint32(p, p_end, table_idx); + if (!get_table_elem_type(module, table_idx, + &decl_ref_type, error_buf, + error_buf_size)) + goto fail; + + if (opcode1 == WASM_OP_TABLE_GROW) { + if (table_idx < module->import_table_count) { + module->import_tables[table_idx] + .u.table.possible_grow = true; + } + else { + module + ->tables[table_idx + - module->import_table_count] + .possible_grow = true; + } + } + +#if WASM_ENABLE_FAST_INTERP != 0 + emit_uint32(loader_ctx, table_idx); +#endif + + POP_I32(); +#if WASM_ENABLE_FAST_INTERP != 0 + POP_OFFSET_TYPE(decl_ref_type); +#endif + POP_TYPE(decl_ref_type); + if (opcode1 == WASM_OP_TABLE_GROW) + PUSH_I32(); + else + POP_I32(); + break; + } #endif /* WASM_ENABLE_REF_TYPES */ - default: - bh_assert(0); - break; + default: + bh_assert(0); + break; } break; } @@ -6482,7 +6550,7 @@ handle_op_block_and_loop: #endif if (opcode != WASM_OP_ATOMIC_FENCE) { CHECK_MEMORY(); - read_leb_uint32(p, p_end, align); /* align */ + read_leb_uint32(p, p_end, align); /* align */ read_leb_uint32(p, p_end, mem_offset); /* offset */ #if WASM_ENABLE_FAST_INTERP != 0 emit_uint32(loader_ctx, mem_offset); @@ -6628,15 +6696,14 @@ handle_op_block_and_loop: func->const_cell_num = loader_ctx->const_cell_num; if (func->const_cell_num > 0 - && !(func->consts = func_const = - loader_malloc(func->const_cell_num * 4, - error_buf, error_buf_size))) { + && !(func->consts = func_const = loader_malloc( + func->const_cell_num * 4, error_buf, error_buf_size))) { goto fail; } func_const_end = func->consts + func->const_cell_num * 4; /* reverse the const buf */ for (int i = loader_ctx->num_const - 1; i >= 0; i--) { - Const *c = (Const*)(loader_ctx->const_buf + i * sizeof(Const)); + Const *c = (Const *)(loader_ctx->const_buf + i * sizeof(Const)); if (c->value_type == VALUE_TYPE_F64 || c->value_type == VALUE_TYPE_I64) { bh_memcpy_s(func_const, (uint32)(func_const_end - func_const), @@ -6650,8 +6717,8 @@ handle_op_block_and_loop: } } - func->max_stack_cell_num = loader_ctx->preserved_local_offset - - loader_ctx->start_dynamic_offset + 1; + func->max_stack_cell_num = loader_ctx->preserved_local_offset + - loader_ctx->start_dynamic_offset + 1; #else func->max_stack_cell_num = loader_ctx->max_stack_cell_num; #endif diff --git a/core/iwasm/interpreter/wasm_opcode.h b/core/iwasm/interpreter/wasm_opcode.h index 294a87a8..f31d3262 100644 --- a/core/iwasm/interpreter/wasm_opcode.h +++ b/core/iwasm/interpreter/wasm_opcode.h @@ -14,673 +14,668 @@ extern "C" { typedef enum WASMOpcode { /* control instructions */ - WASM_OP_UNREACHABLE = 0x00, /* unreachable */ - WASM_OP_NOP = 0x01, /* nop */ - WASM_OP_BLOCK = 0x02, /* block */ - WASM_OP_LOOP = 0x03, /* loop */ - WASM_OP_IF = 0x04, /* if */ - WASM_OP_ELSE = 0x05, /* else */ + WASM_OP_UNREACHABLE = 0x00, /* unreachable */ + WASM_OP_NOP = 0x01, /* nop */ + WASM_OP_BLOCK = 0x02, /* block */ + WASM_OP_LOOP = 0x03, /* loop */ + WASM_OP_IF = 0x04, /* if */ + WASM_OP_ELSE = 0x05, /* else */ - WASM_OP_UNUSED_0x06 = 0x06, - WASM_OP_UNUSED_0x07 = 0x07, - WASM_OP_UNUSED_0x08 = 0x08, - WASM_OP_UNUSED_0x09 = 0x09, - WASM_OP_UNUSED_0x0a = 0x0a, + WASM_OP_UNUSED_0x06 = 0x06, + WASM_OP_UNUSED_0x07 = 0x07, + WASM_OP_UNUSED_0x08 = 0x08, + WASM_OP_UNUSED_0x09 = 0x09, + WASM_OP_UNUSED_0x0a = 0x0a, - WASM_OP_END = 0x0b, /* end */ - WASM_OP_BR = 0x0c, /* br */ - WASM_OP_BR_IF = 0x0d, /* br if */ - WASM_OP_BR_TABLE = 0x0e, /* br table */ - WASM_OP_RETURN = 0x0f, /* return */ - WASM_OP_CALL = 0x10, /* call */ - WASM_OP_CALL_INDIRECT = 0x11, /* call_indirect */ - WASM_OP_RETURN_CALL = 0x12, /* return_call */ + WASM_OP_END = 0x0b, /* end */ + WASM_OP_BR = 0x0c, /* br */ + WASM_OP_BR_IF = 0x0d, /* br if */ + WASM_OP_BR_TABLE = 0x0e, /* br table */ + WASM_OP_RETURN = 0x0f, /* return */ + WASM_OP_CALL = 0x10, /* call */ + WASM_OP_CALL_INDIRECT = 0x11, /* call_indirect */ + WASM_OP_RETURN_CALL = 0x12, /* return_call */ WASM_OP_RETURN_CALL_INDIRECT = 0x13, /* return_call_indirect */ - WASM_OP_UNUSED_0x14 = 0x14, - WASM_OP_UNUSED_0x15 = 0x15, - WASM_OP_UNUSED_0x16 = 0x16, - WASM_OP_UNUSED_0x17 = 0x17, - WASM_OP_UNUSED_0x18 = 0x18, - WASM_OP_UNUSED_0x19 = 0x19, + WASM_OP_UNUSED_0x14 = 0x14, + WASM_OP_UNUSED_0x15 = 0x15, + WASM_OP_UNUSED_0x16 = 0x16, + WASM_OP_UNUSED_0x17 = 0x17, + WASM_OP_UNUSED_0x18 = 0x18, + WASM_OP_UNUSED_0x19 = 0x19, /* parametric instructions */ - WASM_OP_DROP = 0x1a, /* drop */ - WASM_OP_SELECT = 0x1b, /* select */ - WASM_OP_SELECT_T = 0x1c, /* select t */ + WASM_OP_DROP = 0x1a, /* drop */ + WASM_OP_SELECT = 0x1b, /* select */ + WASM_OP_SELECT_T = 0x1c, /* select t */ WASM_OP_GET_GLOBAL_64 = 0x1d, WASM_OP_SET_GLOBAL_64 = 0x1e, WASM_OP_SET_GLOBAL_AUX_STACK = 0x1f, /* variable instructions */ - WASM_OP_GET_LOCAL = 0x20, /* get_local */ - WASM_OP_SET_LOCAL = 0x21, /* set_local */ - WASM_OP_TEE_LOCAL = 0x22, /* tee_local */ - WASM_OP_GET_GLOBAL = 0x23, /* get_global */ - WASM_OP_SET_GLOBAL = 0x24, /* set_global */ + WASM_OP_GET_LOCAL = 0x20, /* get_local */ + WASM_OP_SET_LOCAL = 0x21, /* set_local */ + WASM_OP_TEE_LOCAL = 0x22, /* tee_local */ + WASM_OP_GET_GLOBAL = 0x23, /* get_global */ + WASM_OP_SET_GLOBAL = 0x24, /* set_global */ - WASM_OP_TABLE_GET = 0x25, /* table.get */ - WASM_OP_TABLE_SET = 0x26, /* table.set */ - WASM_OP_UNUSED_0x27 = 0x27, + WASM_OP_TABLE_GET = 0x25, /* table.get */ + WASM_OP_TABLE_SET = 0x26, /* table.set */ + WASM_OP_UNUSED_0x27 = 0x27, /* memory instructions */ - WASM_OP_I32_LOAD = 0x28, /* i32.load */ - WASM_OP_I64_LOAD = 0x29, /* i64.load */ - WASM_OP_F32_LOAD = 0x2a, /* f32.load */ - WASM_OP_F64_LOAD = 0x2b, /* f64.load */ - WASM_OP_I32_LOAD8_S = 0x2c, /* i32.load8_s */ - WASM_OP_I32_LOAD8_U = 0x2d, /* i32.load8_u */ - WASM_OP_I32_LOAD16_S = 0x2e, /* i32.load16_s */ - WASM_OP_I32_LOAD16_U = 0x2f, /* i32.load16_u */ - WASM_OP_I64_LOAD8_S = 0x30, /* i64.load8_s */ - WASM_OP_I64_LOAD8_U = 0x31, /* i64.load8_u */ - WASM_OP_I64_LOAD16_S = 0x32, /* i64.load16_s */ - WASM_OP_I64_LOAD16_U = 0x33, /* i64.load16_u */ - WASM_OP_I64_LOAD32_S = 0x34, /* i32.load32_s */ - WASM_OP_I64_LOAD32_U = 0x35, /* i32.load32_u */ - WASM_OP_I32_STORE = 0x36, /* i32.store */ - WASM_OP_I64_STORE = 0x37, /* i64.store */ - WASM_OP_F32_STORE = 0x38, /* f32.store */ - WASM_OP_F64_STORE = 0x39, /* f64.store */ - WASM_OP_I32_STORE8 = 0x3a, /* i32.store8 */ - WASM_OP_I32_STORE16 = 0x3b, /* i32.store16 */ - WASM_OP_I64_STORE8 = 0x3c, /* i64.store8 */ - WASM_OP_I64_STORE16 = 0x3d, /* i64.sotre16 */ - WASM_OP_I64_STORE32 = 0x3e, /* i64.store32 */ - WASM_OP_MEMORY_SIZE = 0x3f, /* memory.size */ - WASM_OP_MEMORY_GROW = 0x40, /* memory.grow */ + WASM_OP_I32_LOAD = 0x28, /* i32.load */ + WASM_OP_I64_LOAD = 0x29, /* i64.load */ + WASM_OP_F32_LOAD = 0x2a, /* f32.load */ + WASM_OP_F64_LOAD = 0x2b, /* f64.load */ + WASM_OP_I32_LOAD8_S = 0x2c, /* i32.load8_s */ + WASM_OP_I32_LOAD8_U = 0x2d, /* i32.load8_u */ + WASM_OP_I32_LOAD16_S = 0x2e, /* i32.load16_s */ + WASM_OP_I32_LOAD16_U = 0x2f, /* i32.load16_u */ + WASM_OP_I64_LOAD8_S = 0x30, /* i64.load8_s */ + WASM_OP_I64_LOAD8_U = 0x31, /* i64.load8_u */ + WASM_OP_I64_LOAD16_S = 0x32, /* i64.load16_s */ + WASM_OP_I64_LOAD16_U = 0x33, /* i64.load16_u */ + WASM_OP_I64_LOAD32_S = 0x34, /* i32.load32_s */ + WASM_OP_I64_LOAD32_U = 0x35, /* i32.load32_u */ + WASM_OP_I32_STORE = 0x36, /* i32.store */ + WASM_OP_I64_STORE = 0x37, /* i64.store */ + WASM_OP_F32_STORE = 0x38, /* f32.store */ + WASM_OP_F64_STORE = 0x39, /* f64.store */ + WASM_OP_I32_STORE8 = 0x3a, /* i32.store8 */ + WASM_OP_I32_STORE16 = 0x3b, /* i32.store16 */ + WASM_OP_I64_STORE8 = 0x3c, /* i64.store8 */ + WASM_OP_I64_STORE16 = 0x3d, /* i64.sotre16 */ + WASM_OP_I64_STORE32 = 0x3e, /* i64.store32 */ + WASM_OP_MEMORY_SIZE = 0x3f, /* memory.size */ + WASM_OP_MEMORY_GROW = 0x40, /* memory.grow */ /* constant instructions */ - WASM_OP_I32_CONST = 0x41, /* i32.const */ - WASM_OP_I64_CONST = 0x42, /* i64.const */ - WASM_OP_F32_CONST = 0x43, /* f32.const */ - WASM_OP_F64_CONST = 0x44, /* f64.const */ + WASM_OP_I32_CONST = 0x41, /* i32.const */ + WASM_OP_I64_CONST = 0x42, /* i64.const */ + WASM_OP_F32_CONST = 0x43, /* f32.const */ + WASM_OP_F64_CONST = 0x44, /* f64.const */ /* comparison instructions */ - WASM_OP_I32_EQZ = 0x45, /* i32.eqz */ - WASM_OP_I32_EQ = 0x46, /* i32.eq */ - WASM_OP_I32_NE = 0x47, /* i32.ne */ - WASM_OP_I32_LT_S = 0x48, /* i32.lt_s */ - WASM_OP_I32_LT_U = 0x49, /* i32.lt_u */ - WASM_OP_I32_GT_S = 0x4a, /* i32.gt_s */ - WASM_OP_I32_GT_U = 0x4b, /* i32.gt_u */ - WASM_OP_I32_LE_S = 0x4c, /* i32.le_s */ - WASM_OP_I32_LE_U = 0x4d, /* i32.le_u */ - WASM_OP_I32_GE_S = 0x4e, /* i32.ge_s */ - WASM_OP_I32_GE_U = 0x4f, /* i32.ge_u */ + WASM_OP_I32_EQZ = 0x45, /* i32.eqz */ + WASM_OP_I32_EQ = 0x46, /* i32.eq */ + WASM_OP_I32_NE = 0x47, /* i32.ne */ + WASM_OP_I32_LT_S = 0x48, /* i32.lt_s */ + WASM_OP_I32_LT_U = 0x49, /* i32.lt_u */ + WASM_OP_I32_GT_S = 0x4a, /* i32.gt_s */ + WASM_OP_I32_GT_U = 0x4b, /* i32.gt_u */ + WASM_OP_I32_LE_S = 0x4c, /* i32.le_s */ + WASM_OP_I32_LE_U = 0x4d, /* i32.le_u */ + WASM_OP_I32_GE_S = 0x4e, /* i32.ge_s */ + WASM_OP_I32_GE_U = 0x4f, /* i32.ge_u */ - WASM_OP_I64_EQZ = 0x50, /* i64.eqz */ - WASM_OP_I64_EQ = 0x51, /* i64.eq */ - WASM_OP_I64_NE = 0x52, /* i64.ne */ - WASM_OP_I64_LT_S = 0x53, /* i64.lt_s */ - WASM_OP_I64_LT_U = 0x54, /* i64.lt_u */ - WASM_OP_I64_GT_S = 0x55, /* i64.gt_s */ - WASM_OP_I64_GT_U = 0x56, /* i64.gt_u */ - WASM_OP_I64_LE_S = 0x57, /* i64.le_s */ - WASM_OP_I64_LE_U = 0x58, /* i64.le_u */ - WASM_OP_I64_GE_S = 0x59, /* i64.ge_s */ - WASM_OP_I64_GE_U = 0x5a, /* i64.ge_u */ + WASM_OP_I64_EQZ = 0x50, /* i64.eqz */ + WASM_OP_I64_EQ = 0x51, /* i64.eq */ + WASM_OP_I64_NE = 0x52, /* i64.ne */ + WASM_OP_I64_LT_S = 0x53, /* i64.lt_s */ + WASM_OP_I64_LT_U = 0x54, /* i64.lt_u */ + WASM_OP_I64_GT_S = 0x55, /* i64.gt_s */ + WASM_OP_I64_GT_U = 0x56, /* i64.gt_u */ + WASM_OP_I64_LE_S = 0x57, /* i64.le_s */ + WASM_OP_I64_LE_U = 0x58, /* i64.le_u */ + WASM_OP_I64_GE_S = 0x59, /* i64.ge_s */ + WASM_OP_I64_GE_U = 0x5a, /* i64.ge_u */ - WASM_OP_F32_EQ = 0x5b, /* f32.eq */ - WASM_OP_F32_NE = 0x5c, /* f32.ne */ - WASM_OP_F32_LT = 0x5d, /* f32.lt */ - WASM_OP_F32_GT = 0x5e, /* f32.gt */ - WASM_OP_F32_LE = 0x5f, /* f32.le */ - WASM_OP_F32_GE = 0x60, /* f32.ge */ + WASM_OP_F32_EQ = 0x5b, /* f32.eq */ + WASM_OP_F32_NE = 0x5c, /* f32.ne */ + WASM_OP_F32_LT = 0x5d, /* f32.lt */ + WASM_OP_F32_GT = 0x5e, /* f32.gt */ + WASM_OP_F32_LE = 0x5f, /* f32.le */ + WASM_OP_F32_GE = 0x60, /* f32.ge */ - WASM_OP_F64_EQ = 0x61, /* f64.eq */ - WASM_OP_F64_NE = 0x62, /* f64.ne */ - WASM_OP_F64_LT = 0x63, /* f64.lt */ - WASM_OP_F64_GT = 0x64, /* f64.gt */ - WASM_OP_F64_LE = 0x65, /* f64.le */ - WASM_OP_F64_GE = 0x66, /* f64.ge */ + WASM_OP_F64_EQ = 0x61, /* f64.eq */ + WASM_OP_F64_NE = 0x62, /* f64.ne */ + WASM_OP_F64_LT = 0x63, /* f64.lt */ + WASM_OP_F64_GT = 0x64, /* f64.gt */ + WASM_OP_F64_LE = 0x65, /* f64.le */ + WASM_OP_F64_GE = 0x66, /* f64.ge */ /* numeric operators */ - WASM_OP_I32_CLZ = 0x67, /* i32.clz */ - WASM_OP_I32_CTZ = 0x68, /* i32.ctz */ - WASM_OP_I32_POPCNT = 0x69, /* i32.popcnt */ - WASM_OP_I32_ADD = 0x6a, /* i32.add */ - WASM_OP_I32_SUB = 0x6b, /* i32.sub */ - WASM_OP_I32_MUL = 0x6c, /* i32.mul */ - WASM_OP_I32_DIV_S = 0x6d, /* i32.div_s */ - WASM_OP_I32_DIV_U = 0x6e, /* i32.div_u */ - WASM_OP_I32_REM_S = 0x6f, /* i32.rem_s */ - WASM_OP_I32_REM_U = 0x70, /* i32.rem_u */ - WASM_OP_I32_AND = 0x71, /* i32.and */ - WASM_OP_I32_OR = 0x72, /* i32.or */ - WASM_OP_I32_XOR = 0x73, /* i32.xor */ - WASM_OP_I32_SHL = 0x74, /* i32.shl */ - WASM_OP_I32_SHR_S = 0x75, /* i32.shr_s */ - WASM_OP_I32_SHR_U = 0x76, /* i32.shr_u */ - WASM_OP_I32_ROTL = 0x77, /* i32.rotl */ - WASM_OP_I32_ROTR = 0x78, /* i32.rotr */ + WASM_OP_I32_CLZ = 0x67, /* i32.clz */ + WASM_OP_I32_CTZ = 0x68, /* i32.ctz */ + WASM_OP_I32_POPCNT = 0x69, /* i32.popcnt */ + WASM_OP_I32_ADD = 0x6a, /* i32.add */ + WASM_OP_I32_SUB = 0x6b, /* i32.sub */ + WASM_OP_I32_MUL = 0x6c, /* i32.mul */ + WASM_OP_I32_DIV_S = 0x6d, /* i32.div_s */ + WASM_OP_I32_DIV_U = 0x6e, /* i32.div_u */ + WASM_OP_I32_REM_S = 0x6f, /* i32.rem_s */ + WASM_OP_I32_REM_U = 0x70, /* i32.rem_u */ + WASM_OP_I32_AND = 0x71, /* i32.and */ + WASM_OP_I32_OR = 0x72, /* i32.or */ + WASM_OP_I32_XOR = 0x73, /* i32.xor */ + WASM_OP_I32_SHL = 0x74, /* i32.shl */ + WASM_OP_I32_SHR_S = 0x75, /* i32.shr_s */ + WASM_OP_I32_SHR_U = 0x76, /* i32.shr_u */ + WASM_OP_I32_ROTL = 0x77, /* i32.rotl */ + WASM_OP_I32_ROTR = 0x78, /* i32.rotr */ - WASM_OP_I64_CLZ = 0x79, /* i64.clz */ - WASM_OP_I64_CTZ = 0x7a, /* i64.ctz */ - WASM_OP_I64_POPCNT = 0x7b, /* i64.popcnt */ - WASM_OP_I64_ADD = 0x7c, /* i64.add */ - WASM_OP_I64_SUB = 0x7d, /* i64.sub */ - WASM_OP_I64_MUL = 0x7e, /* i64.mul */ - WASM_OP_I64_DIV_S = 0x7f, /* i64.div_s */ - WASM_OP_I64_DIV_U = 0x80, /* i64.div_u */ - WASM_OP_I64_REM_S = 0x81, /* i64.rem_s */ - WASM_OP_I64_REM_U = 0x82, /* i64.rem_u */ - WASM_OP_I64_AND = 0x83, /* i64.and */ - WASM_OP_I64_OR = 0x84, /* i64.or */ - WASM_OP_I64_XOR = 0x85, /* i64.xor */ - WASM_OP_I64_SHL = 0x86, /* i64.shl */ - WASM_OP_I64_SHR_S = 0x87, /* i64.shr_s */ - WASM_OP_I64_SHR_U = 0x88, /* i64.shr_u */ - WASM_OP_I64_ROTL = 0x89, /* i64.rotl */ - WASM_OP_I64_ROTR = 0x8a, /* i64.rotr */ + WASM_OP_I64_CLZ = 0x79, /* i64.clz */ + WASM_OP_I64_CTZ = 0x7a, /* i64.ctz */ + WASM_OP_I64_POPCNT = 0x7b, /* i64.popcnt */ + WASM_OP_I64_ADD = 0x7c, /* i64.add */ + WASM_OP_I64_SUB = 0x7d, /* i64.sub */ + WASM_OP_I64_MUL = 0x7e, /* i64.mul */ + WASM_OP_I64_DIV_S = 0x7f, /* i64.div_s */ + WASM_OP_I64_DIV_U = 0x80, /* i64.div_u */ + WASM_OP_I64_REM_S = 0x81, /* i64.rem_s */ + WASM_OP_I64_REM_U = 0x82, /* i64.rem_u */ + WASM_OP_I64_AND = 0x83, /* i64.and */ + WASM_OP_I64_OR = 0x84, /* i64.or */ + WASM_OP_I64_XOR = 0x85, /* i64.xor */ + WASM_OP_I64_SHL = 0x86, /* i64.shl */ + WASM_OP_I64_SHR_S = 0x87, /* i64.shr_s */ + WASM_OP_I64_SHR_U = 0x88, /* i64.shr_u */ + WASM_OP_I64_ROTL = 0x89, /* i64.rotl */ + WASM_OP_I64_ROTR = 0x8a, /* i64.rotr */ - WASM_OP_F32_ABS = 0x8b, /* f32.abs */ - WASM_OP_F32_NEG = 0x8c, /* f32.neg */ - WASM_OP_F32_CEIL = 0x8d, /* f32.ceil */ - WASM_OP_F32_FLOOR = 0x8e, /* f32.floor */ - WASM_OP_F32_TRUNC = 0x8f, /* f32.trunc */ - WASM_OP_F32_NEAREST = 0x90, /* f32.nearest */ - WASM_OP_F32_SQRT = 0x91, /* f32.sqrt */ - WASM_OP_F32_ADD = 0x92, /* f32.add */ - WASM_OP_F32_SUB = 0x93, /* f32.sub */ - WASM_OP_F32_MUL = 0x94, /* f32.mul */ - WASM_OP_F32_DIV = 0x95, /* f32.div */ - WASM_OP_F32_MIN = 0x96, /* f32.min */ - WASM_OP_F32_MAX = 0x97, /* f32.max */ - WASM_OP_F32_COPYSIGN = 0x98, /* f32.copysign */ + WASM_OP_F32_ABS = 0x8b, /* f32.abs */ + WASM_OP_F32_NEG = 0x8c, /* f32.neg */ + WASM_OP_F32_CEIL = 0x8d, /* f32.ceil */ + WASM_OP_F32_FLOOR = 0x8e, /* f32.floor */ + WASM_OP_F32_TRUNC = 0x8f, /* f32.trunc */ + WASM_OP_F32_NEAREST = 0x90, /* f32.nearest */ + WASM_OP_F32_SQRT = 0x91, /* f32.sqrt */ + WASM_OP_F32_ADD = 0x92, /* f32.add */ + WASM_OP_F32_SUB = 0x93, /* f32.sub */ + WASM_OP_F32_MUL = 0x94, /* f32.mul */ + WASM_OP_F32_DIV = 0x95, /* f32.div */ + WASM_OP_F32_MIN = 0x96, /* f32.min */ + WASM_OP_F32_MAX = 0x97, /* f32.max */ + WASM_OP_F32_COPYSIGN = 0x98, /* f32.copysign */ - WASM_OP_F64_ABS = 0x99, /* f64.abs */ - WASM_OP_F64_NEG = 0x9a, /* f64.neg */ - WASM_OP_F64_CEIL = 0x9b, /* f64.ceil */ - WASM_OP_F64_FLOOR = 0x9c, /* f64.floor */ - WASM_OP_F64_TRUNC = 0x9d, /* f64.trunc */ - WASM_OP_F64_NEAREST = 0x9e, /* f64.nearest */ - WASM_OP_F64_SQRT = 0x9f, /* f64.sqrt */ - WASM_OP_F64_ADD = 0xa0, /* f64.add */ - WASM_OP_F64_SUB = 0xa1, /* f64.sub */ - WASM_OP_F64_MUL = 0xa2, /* f64.mul */ - WASM_OP_F64_DIV = 0xa3, /* f64.div */ - WASM_OP_F64_MIN = 0xa4, /* f64.min */ - WASM_OP_F64_MAX = 0xa5, /* f64.max */ - WASM_OP_F64_COPYSIGN = 0xa6, /* f64.copysign */ + WASM_OP_F64_ABS = 0x99, /* f64.abs */ + WASM_OP_F64_NEG = 0x9a, /* f64.neg */ + WASM_OP_F64_CEIL = 0x9b, /* f64.ceil */ + WASM_OP_F64_FLOOR = 0x9c, /* f64.floor */ + WASM_OP_F64_TRUNC = 0x9d, /* f64.trunc */ + WASM_OP_F64_NEAREST = 0x9e, /* f64.nearest */ + WASM_OP_F64_SQRT = 0x9f, /* f64.sqrt */ + WASM_OP_F64_ADD = 0xa0, /* f64.add */ + WASM_OP_F64_SUB = 0xa1, /* f64.sub */ + WASM_OP_F64_MUL = 0xa2, /* f64.mul */ + WASM_OP_F64_DIV = 0xa3, /* f64.div */ + WASM_OP_F64_MIN = 0xa4, /* f64.min */ + WASM_OP_F64_MAX = 0xa5, /* f64.max */ + WASM_OP_F64_COPYSIGN = 0xa6, /* f64.copysign */ /* conversions */ - WASM_OP_I32_WRAP_I64 = 0xa7, /* i32.wrap/i64 */ - WASM_OP_I32_TRUNC_S_F32 = 0xa8, /* i32.trunc_s/f32 */ - WASM_OP_I32_TRUNC_U_F32 = 0xa9, /* i32.trunc_u/f32 */ - WASM_OP_I32_TRUNC_S_F64 = 0xaa, /* i32.trunc_s/f64 */ - WASM_OP_I32_TRUNC_U_F64 = 0xab, /* i32.trunc_u/f64 */ + WASM_OP_I32_WRAP_I64 = 0xa7, /* i32.wrap/i64 */ + WASM_OP_I32_TRUNC_S_F32 = 0xa8, /* i32.trunc_s/f32 */ + WASM_OP_I32_TRUNC_U_F32 = 0xa9, /* i32.trunc_u/f32 */ + WASM_OP_I32_TRUNC_S_F64 = 0xaa, /* i32.trunc_s/f64 */ + WASM_OP_I32_TRUNC_U_F64 = 0xab, /* i32.trunc_u/f64 */ - WASM_OP_I64_EXTEND_S_I32 = 0xac, /* i64.extend_s/i32 */ - WASM_OP_I64_EXTEND_U_I32 = 0xad, /* i64.extend_u/i32 */ - WASM_OP_I64_TRUNC_S_F32 = 0xae, /* i64.trunc_s/f32 */ - WASM_OP_I64_TRUNC_U_F32 = 0xaf, /* i64.trunc_u/f32 */ - WASM_OP_I64_TRUNC_S_F64 = 0xb0, /* i64.trunc_s/f64 */ - WASM_OP_I64_TRUNC_U_F64 = 0xb1, /* i64.trunc_u/f64 */ + WASM_OP_I64_EXTEND_S_I32 = 0xac, /* i64.extend_s/i32 */ + WASM_OP_I64_EXTEND_U_I32 = 0xad, /* i64.extend_u/i32 */ + WASM_OP_I64_TRUNC_S_F32 = 0xae, /* i64.trunc_s/f32 */ + WASM_OP_I64_TRUNC_U_F32 = 0xaf, /* i64.trunc_u/f32 */ + WASM_OP_I64_TRUNC_S_F64 = 0xb0, /* i64.trunc_s/f64 */ + WASM_OP_I64_TRUNC_U_F64 = 0xb1, /* i64.trunc_u/f64 */ WASM_OP_F32_CONVERT_S_I32 = 0xb2, /* f32.convert_s/i32 */ WASM_OP_F32_CONVERT_U_I32 = 0xb3, /* f32.convert_u/i32 */ WASM_OP_F32_CONVERT_S_I64 = 0xb4, /* f32.convert_s/i64 */ WASM_OP_F32_CONVERT_U_I64 = 0xb5, /* f32.convert_u/i64 */ - WASM_OP_F32_DEMOTE_F64 = 0xb6, /* f32.demote/f64 */ + WASM_OP_F32_DEMOTE_F64 = 0xb6, /* f32.demote/f64 */ WASM_OP_F64_CONVERT_S_I32 = 0xb7, /* f64.convert_s/i32 */ WASM_OP_F64_CONVERT_U_I32 = 0xb8, /* f64.convert_u/i32 */ WASM_OP_F64_CONVERT_S_I64 = 0xb9, /* f64.convert_s/i64 */ WASM_OP_F64_CONVERT_U_I64 = 0xba, /* f64.convert_u/i64 */ - WASM_OP_F64_PROMOTE_F32 = 0xbb, /* f64.promote/f32 */ + WASM_OP_F64_PROMOTE_F32 = 0xbb, /* f64.promote/f32 */ /* reinterpretations */ - WASM_OP_I32_REINTERPRET_F32 = 0xbc, /* i32.reinterpret/f32 */ - WASM_OP_I64_REINTERPRET_F64 = 0xbd, /* i64.reinterpret/f64 */ - WASM_OP_F32_REINTERPRET_I32 = 0xbe, /* f32.reinterpret/i32 */ - WASM_OP_F64_REINTERPRET_I64 = 0xbf, /* f64.reinterpret/i64 */ + WASM_OP_I32_REINTERPRET_F32 = 0xbc, /* i32.reinterpret/f32 */ + WASM_OP_I64_REINTERPRET_F64 = 0xbd, /* i64.reinterpret/f64 */ + WASM_OP_F32_REINTERPRET_I32 = 0xbe, /* f32.reinterpret/i32 */ + WASM_OP_F64_REINTERPRET_I64 = 0xbf, /* f64.reinterpret/i64 */ - WASM_OP_I32_EXTEND8_S = 0xc0, /* i32.extend8_s */ - WASM_OP_I32_EXTEND16_S = 0xc1, /* i32.extend16_s */ - WASM_OP_I64_EXTEND8_S = 0xc2, /* i64.extend8_s */ - WASM_OP_I64_EXTEND16_S = 0xc3, /* i64.extend16_s */ - WASM_OP_I64_EXTEND32_S = 0xc4, /* i64.extend32_s */ + WASM_OP_I32_EXTEND8_S = 0xc0, /* i32.extend8_s */ + WASM_OP_I32_EXTEND16_S = 0xc1, /* i32.extend16_s */ + WASM_OP_I64_EXTEND8_S = 0xc2, /* i64.extend8_s */ + WASM_OP_I64_EXTEND16_S = 0xc3, /* i64.extend16_s */ + WASM_OP_I64_EXTEND32_S = 0xc4, /* i64.extend32_s */ /* drop/select specified types*/ - WASM_OP_DROP_64 = 0xc5, - WASM_OP_SELECT_64 = 0xc6, + WASM_OP_DROP_64 = 0xc5, + WASM_OP_SELECT_64 = 0xc6, /* extend op code */ - EXT_OP_GET_LOCAL_FAST = 0xc7, - EXT_OP_SET_LOCAL_FAST_I64 = 0xc8, - EXT_OP_SET_LOCAL_FAST = 0xc9, - EXT_OP_TEE_LOCAL_FAST = 0xca, - EXT_OP_TEE_LOCAL_FAST_I64 = 0xcb, - EXT_OP_COPY_STACK_TOP = 0xcc, - EXT_OP_COPY_STACK_TOP_I64 = 0xcd, - EXT_OP_COPY_STACK_VALUES = 0xce, + EXT_OP_GET_LOCAL_FAST = 0xc7, + EXT_OP_SET_LOCAL_FAST_I64 = 0xc8, + EXT_OP_SET_LOCAL_FAST = 0xc9, + EXT_OP_TEE_LOCAL_FAST = 0xca, + EXT_OP_TEE_LOCAL_FAST_I64 = 0xcb, + EXT_OP_COPY_STACK_TOP = 0xcc, + EXT_OP_COPY_STACK_TOP_I64 = 0xcd, + EXT_OP_COPY_STACK_VALUES = 0xce, - WASM_OP_IMPDEP = 0xcf, + WASM_OP_IMPDEP = 0xcf, - WASM_OP_REF_NULL = 0xd0, /* ref.null */ - WASM_OP_REF_IS_NULL = 0xd1, /* ref.is_null */ - WASM_OP_REF_FUNC = 0xd2, /* ref.func */ + WASM_OP_REF_NULL = 0xd0, /* ref.null */ + WASM_OP_REF_IS_NULL = 0xd1, /* ref.is_null */ + WASM_OP_REF_FUNC = 0xd2, /* ref.func */ - EXT_OP_BLOCK = 0xd3, /* block with blocktype */ - EXT_OP_LOOP = 0xd4, /* loop with blocktype */ - EXT_OP_IF = 0xd5, /* if with blocktype */ + EXT_OP_BLOCK = 0xd3, /* block with blocktype */ + EXT_OP_LOOP = 0xd4, /* loop with blocktype */ + EXT_OP_IF = 0xd5, /* if with blocktype */ #if WASM_ENABLE_DEBUG_INTERP != 0 - DEBUG_OP_BREAK = 0xd6, /* debug break point */ + DEBUG_OP_BREAK = 0xd6, /* debug break point */ #endif /* Post-MVP extend op prefix */ - WASM_OP_MISC_PREFIX = 0xfc, - WASM_OP_SIMD_PREFIX = 0xfd, - WASM_OP_ATOMIC_PREFIX = 0xfe, + WASM_OP_MISC_PREFIX = 0xfc, + WASM_OP_SIMD_PREFIX = 0xfd, + WASM_OP_ATOMIC_PREFIX = 0xfe, } WASMOpcode; typedef enum WASMMiscEXTOpcode { - WASM_OP_I32_TRUNC_SAT_S_F32 = 0x00, - WASM_OP_I32_TRUNC_SAT_U_F32 = 0x01, - WASM_OP_I32_TRUNC_SAT_S_F64 = 0x02, - WASM_OP_I32_TRUNC_SAT_U_F64 = 0x03, - WASM_OP_I64_TRUNC_SAT_S_F32 = 0x04, - WASM_OP_I64_TRUNC_SAT_U_F32 = 0x05, - WASM_OP_I64_TRUNC_SAT_S_F64 = 0x06, - WASM_OP_I64_TRUNC_SAT_U_F64 = 0x07, - WASM_OP_MEMORY_INIT = 0x08, - WASM_OP_DATA_DROP = 0x09, - WASM_OP_MEMORY_COPY = 0x0a, - WASM_OP_MEMORY_FILL = 0x0b, - WASM_OP_TABLE_INIT = 0x0c, - WASM_OP_ELEM_DROP = 0x0d, - WASM_OP_TABLE_COPY = 0x0e, - WASM_OP_TABLE_GROW = 0x0f, - WASM_OP_TABLE_SIZE = 0x10, - WASM_OP_TABLE_FILL = 0x11, + WASM_OP_I32_TRUNC_SAT_S_F32 = 0x00, + WASM_OP_I32_TRUNC_SAT_U_F32 = 0x01, + WASM_OP_I32_TRUNC_SAT_S_F64 = 0x02, + WASM_OP_I32_TRUNC_SAT_U_F64 = 0x03, + WASM_OP_I64_TRUNC_SAT_S_F32 = 0x04, + WASM_OP_I64_TRUNC_SAT_U_F32 = 0x05, + WASM_OP_I64_TRUNC_SAT_S_F64 = 0x06, + WASM_OP_I64_TRUNC_SAT_U_F64 = 0x07, + WASM_OP_MEMORY_INIT = 0x08, + WASM_OP_DATA_DROP = 0x09, + WASM_OP_MEMORY_COPY = 0x0a, + WASM_OP_MEMORY_FILL = 0x0b, + WASM_OP_TABLE_INIT = 0x0c, + WASM_OP_ELEM_DROP = 0x0d, + WASM_OP_TABLE_COPY = 0x0e, + WASM_OP_TABLE_GROW = 0x0f, + WASM_OP_TABLE_SIZE = 0x10, + WASM_OP_TABLE_FILL = 0x11, } WASMMiscEXTOpcode; typedef enum WASMSimdEXTOpcode { /* memory instruction */ - SIMD_v128_load = 0x00, - SIMD_v128_load8x8_s = 0x01, - SIMD_v128_load8x8_u = 0x02, - SIMD_v128_load16x4_s = 0x03, - SIMD_v128_load16x4_u = 0x04, - SIMD_v128_load32x2_s = 0x05, - SIMD_v128_load32x2_u = 0x06, - SIMD_v128_load8_splat = 0x07, + SIMD_v128_load = 0x00, + SIMD_v128_load8x8_s = 0x01, + SIMD_v128_load8x8_u = 0x02, + SIMD_v128_load16x4_s = 0x03, + SIMD_v128_load16x4_u = 0x04, + SIMD_v128_load32x2_s = 0x05, + SIMD_v128_load32x2_u = 0x06, + SIMD_v128_load8_splat = 0x07, SIMD_v128_load16_splat = 0x08, SIMD_v128_load32_splat = 0x09, SIMD_v128_load64_splat = 0x0a, - SIMD_v128_store = 0x0b, + SIMD_v128_store = 0x0b, /* basic operation */ - SIMD_v128_const = 0x0c, - SIMD_v8x16_shuffle = 0x0d, - SIMD_v8x16_swizzle = 0x0e, + SIMD_v128_const = 0x0c, + SIMD_v8x16_shuffle = 0x0d, + SIMD_v8x16_swizzle = 0x0e, /* splat operation */ - SIMD_i8x16_splat = 0x0f, - SIMD_i16x8_splat = 0x10, - SIMD_i32x4_splat = 0x11, - SIMD_i64x2_splat = 0x12, - SIMD_f32x4_splat = 0x13, - SIMD_f64x2_splat = 0x14, + SIMD_i8x16_splat = 0x0f, + SIMD_i16x8_splat = 0x10, + SIMD_i32x4_splat = 0x11, + SIMD_i64x2_splat = 0x12, + SIMD_f32x4_splat = 0x13, + SIMD_f64x2_splat = 0x14, /* lane operation */ SIMD_i8x16_extract_lane_s = 0x15, SIMD_i8x16_extract_lane_u = 0x16, - SIMD_i8x16_replace_lane = 0x17, + SIMD_i8x16_replace_lane = 0x17, SIMD_i16x8_extract_lane_s = 0x18, SIMD_i16x8_extract_lane_u = 0x19, - SIMD_i16x8_replace_lane = 0x1a, - SIMD_i32x4_extract_lane = 0x1b, - SIMD_i32x4_replace_lane = 0x1c, - SIMD_i64x2_extract_lane = 0x1d, - SIMD_i64x2_replace_lane = 0x1e, - SIMD_f32x4_extract_lane = 0x1f, - SIMD_f32x4_replace_lane = 0x20, - SIMD_f64x2_extract_lane = 0x21, - SIMD_f64x2_replace_lane = 0x22, + SIMD_i16x8_replace_lane = 0x1a, + SIMD_i32x4_extract_lane = 0x1b, + SIMD_i32x4_replace_lane = 0x1c, + SIMD_i64x2_extract_lane = 0x1d, + SIMD_i64x2_replace_lane = 0x1e, + SIMD_f32x4_extract_lane = 0x1f, + SIMD_f32x4_replace_lane = 0x20, + SIMD_f64x2_extract_lane = 0x21, + SIMD_f64x2_replace_lane = 0x22, /* i8x16 compare operation */ - SIMD_i8x16_eq = 0x23, - SIMD_i8x16_ne = 0x24, - SIMD_i8x16_lt_s = 0x25, - SIMD_i8x16_lt_u = 0x26, - SIMD_i8x16_gt_s = 0x27, - SIMD_i8x16_gt_u = 0x28, - SIMD_i8x16_le_s = 0x29, - SIMD_i8x16_le_u = 0x2a, - SIMD_i8x16_ge_s = 0x2b, - SIMD_i8x16_ge_u = 0x2c, + SIMD_i8x16_eq = 0x23, + SIMD_i8x16_ne = 0x24, + SIMD_i8x16_lt_s = 0x25, + SIMD_i8x16_lt_u = 0x26, + SIMD_i8x16_gt_s = 0x27, + SIMD_i8x16_gt_u = 0x28, + SIMD_i8x16_le_s = 0x29, + SIMD_i8x16_le_u = 0x2a, + SIMD_i8x16_ge_s = 0x2b, + SIMD_i8x16_ge_u = 0x2c, /* i16x8 compare operation */ - SIMD_i16x8_eq = 0x2d, - SIMD_i16x8_ne = 0x2e, - SIMD_i16x8_lt_s = 0x2f, - SIMD_i16x8_lt_u = 0x30, - SIMD_i16x8_gt_s = 0x31, - SIMD_i16x8_gt_u = 0x32, - SIMD_i16x8_le_s = 0x33, - SIMD_i16x8_le_u = 0x34, - SIMD_i16x8_ge_s = 0x35, - SIMD_i16x8_ge_u = 0x36, + SIMD_i16x8_eq = 0x2d, + SIMD_i16x8_ne = 0x2e, + SIMD_i16x8_lt_s = 0x2f, + SIMD_i16x8_lt_u = 0x30, + SIMD_i16x8_gt_s = 0x31, + SIMD_i16x8_gt_u = 0x32, + SIMD_i16x8_le_s = 0x33, + SIMD_i16x8_le_u = 0x34, + SIMD_i16x8_ge_s = 0x35, + SIMD_i16x8_ge_u = 0x36, /* i32x4 compare operation */ - SIMD_i32x4_eq = 0x37, - SIMD_i32x4_ne = 0x38, - SIMD_i32x4_lt_s = 0x39, - SIMD_i32x4_lt_u = 0x3a, - SIMD_i32x4_gt_s = 0x3b, - SIMD_i32x4_gt_u = 0x3c, - SIMD_i32x4_le_s = 0x3d, - SIMD_i32x4_le_u = 0x3e, - SIMD_i32x4_ge_s = 0x3f, - SIMD_i32x4_ge_u = 0x40, + SIMD_i32x4_eq = 0x37, + SIMD_i32x4_ne = 0x38, + SIMD_i32x4_lt_s = 0x39, + SIMD_i32x4_lt_u = 0x3a, + SIMD_i32x4_gt_s = 0x3b, + SIMD_i32x4_gt_u = 0x3c, + SIMD_i32x4_le_s = 0x3d, + SIMD_i32x4_le_u = 0x3e, + SIMD_i32x4_ge_s = 0x3f, + SIMD_i32x4_ge_u = 0x40, /* f32x4 compare operation */ - SIMD_f32x4_eq = 0x41, - SIMD_f32x4_ne = 0x42, - SIMD_f32x4_lt = 0x43, - SIMD_f32x4_gt = 0x44, - SIMD_f32x4_le = 0x45, - SIMD_f32x4_ge = 0x46, + SIMD_f32x4_eq = 0x41, + SIMD_f32x4_ne = 0x42, + SIMD_f32x4_lt = 0x43, + SIMD_f32x4_gt = 0x44, + SIMD_f32x4_le = 0x45, + SIMD_f32x4_ge = 0x46, /* f64x2 compare operation */ - SIMD_f64x2_eq = 0x47, - SIMD_f64x2_ne = 0x48, - SIMD_f64x2_lt = 0x49, - SIMD_f64x2_gt = 0x4a, - SIMD_f64x2_le = 0x4b, - SIMD_f64x2_ge = 0x4c, + SIMD_f64x2_eq = 0x47, + SIMD_f64x2_ne = 0x48, + SIMD_f64x2_lt = 0x49, + SIMD_f64x2_gt = 0x4a, + SIMD_f64x2_le = 0x4b, + SIMD_f64x2_ge = 0x4c, /* v128 operation */ - SIMD_v128_not = 0x4d, - SIMD_v128_and = 0x4e, - SIMD_v128_andnot = 0x4f, - SIMD_v128_or = 0x50, - SIMD_v128_xor = 0x51, + SIMD_v128_not = 0x4d, + SIMD_v128_and = 0x4e, + SIMD_v128_andnot = 0x4f, + SIMD_v128_or = 0x50, + SIMD_v128_xor = 0x51, SIMD_v128_bitselect = 0x52, - SIMD_v128_any_true = 0x53, + SIMD_v128_any_true = 0x53, /* Load Lane Operation */ - SIMD_v128_load8_lane = 0x54, - SIMD_v128_load16_lane = 0x55, - SIMD_v128_load32_lane = 0x56, - SIMD_v128_load64_lane = 0x57, - SIMD_v128_store8_lane = 0x58, + SIMD_v128_load8_lane = 0x54, + SIMD_v128_load16_lane = 0x55, + SIMD_v128_load32_lane = 0x56, + SIMD_v128_load64_lane = 0x57, + SIMD_v128_store8_lane = 0x58, SIMD_v128_store16_lane = 0x59, SIMD_v128_store32_lane = 0x5a, SIMD_v128_store64_lane = 0x5b, - SIMD_v128_load32_zero = 0x5c, - SIMD_v128_load64_zero = 0x5d, + SIMD_v128_load32_zero = 0x5c, + SIMD_v128_load64_zero = 0x5d, /* Float conversion */ - SIMD_f32x4_demote_f64x2_zero = 0x5e, + SIMD_f32x4_demote_f64x2_zero = 0x5e, SIMD_f64x2_promote_low_f32x4_zero = 0x5f, /* i8x16 Operation */ - SIMD_i8x16_abs = 0x60, - SIMD_i8x16_neg = 0x61, - SIMD_i8x16_popcnt = 0x62, - SIMD_i8x16_all_true = 0x63, - SIMD_i8x16_bitmask = 0x64, + SIMD_i8x16_abs = 0x60, + SIMD_i8x16_neg = 0x61, + SIMD_i8x16_popcnt = 0x62, + SIMD_i8x16_all_true = 0x63, + SIMD_i8x16_bitmask = 0x64, SIMD_i8x16_narrow_i16x8_s = 0x65, SIMD_i8x16_narrow_i16x8_u = 0x66, - SIMD_f32x4_ceil = 0x67, - SIMD_f32x4_floor = 0x68, - SIMD_f32x4_trunc = 0x69, - SIMD_f32x4_nearest = 0x6a, - SIMD_i8x16_shl = 0x6b, - SIMD_i8x16_shr_s = 0x6c, - SIMD_i8x16_shr_u = 0x6d, - SIMD_i8x16_add = 0x6e, - SIMD_i8x16_add_sat_s = 0x6f, - SIMD_i8x16_add_sat_u = 0x70, - SIMD_i8x16_sub = 0x71, - SIMD_i8x16_sub_sat_s = 0x72, - SIMD_i8x16_sub_sat_u = 0x73, - SIMD_f64x2_ceil = 0x74, - SIMD_f64x2_floor = 0x75, - SIMD_i8x16_min_s = 0x76, - SIMD_i8x16_min_u = 0x77, - SIMD_i8x16_max_s = 0x78, - SIMD_i8x16_max_u = 0x79, - SIMD_f64x2_trunc = 0x7a, - SIMD_i8x16_avgr_u = 0x7b, + SIMD_f32x4_ceil = 0x67, + SIMD_f32x4_floor = 0x68, + SIMD_f32x4_trunc = 0x69, + SIMD_f32x4_nearest = 0x6a, + SIMD_i8x16_shl = 0x6b, + SIMD_i8x16_shr_s = 0x6c, + SIMD_i8x16_shr_u = 0x6d, + SIMD_i8x16_add = 0x6e, + SIMD_i8x16_add_sat_s = 0x6f, + SIMD_i8x16_add_sat_u = 0x70, + SIMD_i8x16_sub = 0x71, + SIMD_i8x16_sub_sat_s = 0x72, + SIMD_i8x16_sub_sat_u = 0x73, + SIMD_f64x2_ceil = 0x74, + SIMD_f64x2_floor = 0x75, + SIMD_i8x16_min_s = 0x76, + SIMD_i8x16_min_u = 0x77, + SIMD_i8x16_max_s = 0x78, + SIMD_i8x16_max_u = 0x79, + SIMD_f64x2_trunc = 0x7a, + SIMD_i8x16_avgr_u = 0x7b, SIMD_i16x8_extadd_pairwise_i8x16_s = 0x7c, SIMD_i16x8_extadd_pairwise_i8x16_u = 0x7d, SIMD_i32x4_extadd_pairwise_i16x8_s = 0x7e, SIMD_i32x4_extadd_pairwise_i16x8_u = 0x7f, /* i16x8 operation */ - SIMD_i16x8_abs = 0x80, - SIMD_i16x8_neg = 0x81, - SIMD_i16x8_q15mulr_sat_s = 0x82, - SIMD_i16x8_all_true = 0x83, - SIMD_i16x8_bitmask = 0x84, + SIMD_i16x8_abs = 0x80, + SIMD_i16x8_neg = 0x81, + SIMD_i16x8_q15mulr_sat_s = 0x82, + SIMD_i16x8_all_true = 0x83, + SIMD_i16x8_bitmask = 0x84, SIMD_i16x8_narrow_i32x4_s = 0x85, SIMD_i16x8_narrow_i32x4_u = 0x86, - SIMD_i16x8_extend_low_i8x16_s = 0x87, + SIMD_i16x8_extend_low_i8x16_s = 0x87, SIMD_i16x8_extend_high_i8x16_s = 0x88, - SIMD_i16x8_extend_low_i8x16_u = 0x89, + SIMD_i16x8_extend_low_i8x16_u = 0x89, SIMD_i16x8_extend_high_i8x16_u = 0x8a, - SIMD_i16x8_shl = 0x8b, - SIMD_i16x8_shr_s = 0x8c, - SIMD_i16x8_shr_u = 0x8d, - SIMD_i16x8_add = 0x8e, - SIMD_i16x8_add_sat_s = 0x8f, - SIMD_i16x8_add_sat_u = 0x90, - SIMD_i16x8_sub = 0x91, - SIMD_i16x8_sub_sat_s = 0x92, - SIMD_i16x8_sub_sat_u = 0x93, - SIMD_f64x2_nearest = 0x94, - SIMD_i16x8_mul = 0x95, - SIMD_i16x8_min_s = 0x96, - SIMD_i16x8_min_u = 0x97, - SIMD_i16x8_max_s = 0x98, - SIMD_i16x8_max_u = 0x99, + SIMD_i16x8_shl = 0x8b, + SIMD_i16x8_shr_s = 0x8c, + SIMD_i16x8_shr_u = 0x8d, + SIMD_i16x8_add = 0x8e, + SIMD_i16x8_add_sat_s = 0x8f, + SIMD_i16x8_add_sat_u = 0x90, + SIMD_i16x8_sub = 0x91, + SIMD_i16x8_sub_sat_s = 0x92, + SIMD_i16x8_sub_sat_u = 0x93, + SIMD_f64x2_nearest = 0x94, + SIMD_i16x8_mul = 0x95, + SIMD_i16x8_min_s = 0x96, + SIMD_i16x8_min_u = 0x97, + SIMD_i16x8_max_s = 0x98, + SIMD_i16x8_max_u = 0x99, /* placeholder = 0x9a */ - SIMD_i16x8_avgr_u = 0x9b, - SIMD_i16x8_extmul_low_i8x16_s = 0x9c, + SIMD_i16x8_avgr_u = 0x9b, + SIMD_i16x8_extmul_low_i8x16_s = 0x9c, SIMD_i16x8_extmul_high_i8x16_s = 0x9d, - SIMD_i16x8_extmul_low_i8x16_u = 0x9e, + SIMD_i16x8_extmul_low_i8x16_u = 0x9e, SIMD_i16x8_extmul_high_i8x16_u = 0x9f, /* i32x4 operation */ - SIMD_i32x4_abs = 0xa0, - SIMD_i32x4_neg = 0xa1, + SIMD_i32x4_abs = 0xa0, + SIMD_i32x4_neg = 0xa1, /* placeholder = 0xa2 */ - SIMD_i32x4_all_true = 0xa3, - SIMD_i32x4_bitmask = 0xa4, + SIMD_i32x4_all_true = 0xa3, + SIMD_i32x4_bitmask = 0xa4, SIMD_i32x4_narrow_i64x2_s = 0xa5, SIMD_i32x4_narrow_i64x2_u = 0xa6, - SIMD_i32x4_extend_low_i16x8_s = 0xa7, + SIMD_i32x4_extend_low_i16x8_s = 0xa7, SIMD_i32x4_extend_high_i16x8_s = 0xa8, - SIMD_i32x4_extend_low_i16x8_u = 0xa9, + SIMD_i32x4_extend_low_i16x8_u = 0xa9, SIMD_i32x4_extend_high_i16x8_u = 0xaa, - SIMD_i32x4_shl = 0xab, - SIMD_i32x4_shr_s = 0xac, - SIMD_i32x4_shr_u = 0xad, - SIMD_i32x4_add = 0xae, - SIMD_i32x4_add_sat_s = 0xaf, - SIMD_i32x4_add_sat_u = 0xb0, - SIMD_i32x4_sub = 0xb1, - SIMD_i32x4_sub_sat_s = 0xb2, - SIMD_i32x4_sub_sat_u = 0xb3, + SIMD_i32x4_shl = 0xab, + SIMD_i32x4_shr_s = 0xac, + SIMD_i32x4_shr_u = 0xad, + SIMD_i32x4_add = 0xae, + SIMD_i32x4_add_sat_s = 0xaf, + SIMD_i32x4_add_sat_u = 0xb0, + SIMD_i32x4_sub = 0xb1, + SIMD_i32x4_sub_sat_s = 0xb2, + SIMD_i32x4_sub_sat_u = 0xb3, /* placeholder = 0xb4 */ - SIMD_i32x4_mul = 0xb5, - SIMD_i32x4_min_s = 0xb6, - SIMD_i32x4_min_u = 0xb7, - SIMD_i32x4_max_s = 0xb8, - SIMD_i32x4_max_u = 0xb9, - SIMD_i32x4_dot_i16x8_s = 0xba, - SIMD_i32x4_avgr_u = 0xbb, - SIMD_i32x4_extmul_low_i16x8_s = 0xbc, + SIMD_i32x4_mul = 0xb5, + SIMD_i32x4_min_s = 0xb6, + SIMD_i32x4_min_u = 0xb7, + SIMD_i32x4_max_s = 0xb8, + SIMD_i32x4_max_u = 0xb9, + SIMD_i32x4_dot_i16x8_s = 0xba, + SIMD_i32x4_avgr_u = 0xbb, + SIMD_i32x4_extmul_low_i16x8_s = 0xbc, SIMD_i32x4_extmul_high_i16x8_s = 0xbd, - SIMD_i32x4_extmul_low_i16x8_u = 0xbe, + SIMD_i32x4_extmul_low_i16x8_u = 0xbe, SIMD_i32x4_extmul_high_i16x8_u = 0xbf, /* i64x2 operation */ - SIMD_i64x2_abs = 0xc0, - SIMD_i64x2_neg = 0xc1, + SIMD_i64x2_abs = 0xc0, + SIMD_i64x2_neg = 0xc1, /* placeholder = 0xc2 */ - SIMD_i64x2_all_true = 0xc3, - SIMD_i64x2_bitmask = 0xc4, + SIMD_i64x2_all_true = 0xc3, + SIMD_i64x2_bitmask = 0xc4, /* placeholder = 0xc5 */ /* placeholder = 0xc6 */ - SIMD_i64x2_extend_low_i32x4_s = 0xc7, + SIMD_i64x2_extend_low_i32x4_s = 0xc7, SIMD_i64x2_extend_high_i32x4_s = 0xc8, - SIMD_i64x2_extend_low_i32x4_u = 0xc9, + SIMD_i64x2_extend_low_i32x4_u = 0xc9, SIMD_i64x2_extend_high_i32x4_u = 0xca, - SIMD_i64x2_shl = 0xcb, - SIMD_i64x2_shr_s = 0xcc, - SIMD_i64x2_shr_u = 0xcd, - SIMD_i64x2_add = 0xce, + SIMD_i64x2_shl = 0xcb, + SIMD_i64x2_shr_s = 0xcc, + SIMD_i64x2_shr_u = 0xcd, + SIMD_i64x2_add = 0xce, /* placeholder = 0xcf */ /* placeholder = 0xd0 */ - SIMD_i64x2_sub = 0xd1, + SIMD_i64x2_sub = 0xd1, /* placeholder = 0xd2 */ /* placeholder = 0xd3 */ /* placeholder = 0xd4 */ - SIMD_i64x2_mul = 0xd5, - SIMD_i64x2_eq = 0xd6, - SIMD_i64x2_ne = 0xd7, - SIMD_i64x2_lt_s = 0xd8, - SIMD_i64x2_gt_s = 0xd9, - SIMD_i64x2_le_s = 0xda, - SIMD_i64x2_ge_s = 0xdb, - SIMD_i64x2_extmul_low_i32x4_s = 0xdc, + SIMD_i64x2_mul = 0xd5, + SIMD_i64x2_eq = 0xd6, + SIMD_i64x2_ne = 0xd7, + SIMD_i64x2_lt_s = 0xd8, + SIMD_i64x2_gt_s = 0xd9, + SIMD_i64x2_le_s = 0xda, + SIMD_i64x2_ge_s = 0xdb, + SIMD_i64x2_extmul_low_i32x4_s = 0xdc, SIMD_i64x2_extmul_high_i32x4_s = 0xdd, - SIMD_i64x2_extmul_low_i32x4_u = 0xde, + SIMD_i64x2_extmul_low_i32x4_u = 0xde, SIMD_i64x2_extmul_high_i32x4_u = 0xdf, /* f32x4 operation */ - SIMD_f32x4_abs = 0xe0, - SIMD_f32x4_neg = 0xe1, - SIMD_f32x4_round = 0xe2, - SIMD_f32x4_sqrt = 0xe3, - SIMD_f32x4_add = 0xe4, - SIMD_f32x4_sub = 0xe5, - SIMD_f32x4_mul = 0xe6, - SIMD_f32x4_div = 0xe7, - SIMD_f32x4_min = 0xe8, - SIMD_f32x4_max = 0xe9, - SIMD_f32x4_pmin = 0xea, - SIMD_f32x4_pmax = 0xeb, + SIMD_f32x4_abs = 0xe0, + SIMD_f32x4_neg = 0xe1, + SIMD_f32x4_round = 0xe2, + SIMD_f32x4_sqrt = 0xe3, + SIMD_f32x4_add = 0xe4, + SIMD_f32x4_sub = 0xe5, + SIMD_f32x4_mul = 0xe6, + SIMD_f32x4_div = 0xe7, + SIMD_f32x4_min = 0xe8, + SIMD_f32x4_max = 0xe9, + SIMD_f32x4_pmin = 0xea, + SIMD_f32x4_pmax = 0xeb, /* f64x2 operation */ - SIMD_f64x2_abs = 0xec, - SIMD_f64x2_neg = 0xed, - SIMD_f64x2_round = 0xee, - SIMD_f64x2_sqrt = 0xef, - SIMD_f64x2_add = 0xf0, - SIMD_f64x2_sub = 0xf1, - SIMD_f64x2_mul = 0xf2, - SIMD_f64x2_div = 0xf3, - SIMD_f64x2_min = 0xf4, - SIMD_f64x2_max = 0xf5, - SIMD_f64x2_pmin = 0xf6, - SIMD_f64x2_pmax = 0xf7, + SIMD_f64x2_abs = 0xec, + SIMD_f64x2_neg = 0xed, + SIMD_f64x2_round = 0xee, + SIMD_f64x2_sqrt = 0xef, + SIMD_f64x2_add = 0xf0, + SIMD_f64x2_sub = 0xf1, + SIMD_f64x2_mul = 0xf2, + SIMD_f64x2_div = 0xf3, + SIMD_f64x2_min = 0xf4, + SIMD_f64x2_max = 0xf5, + SIMD_f64x2_pmin = 0xf6, + SIMD_f64x2_pmax = 0xf7, /* conversion operation */ - SIMD_i32x4_trunc_sat_f32x4_s = 0xf8, - SIMD_i32x4_trunc_sat_f32x4_u = 0xf9, - SIMD_f32x4_convert_i32x4_s = 0xfa, - SIMD_f32x4_convert_i32x4_u = 0xfb, + SIMD_i32x4_trunc_sat_f32x4_s = 0xf8, + SIMD_i32x4_trunc_sat_f32x4_u = 0xf9, + SIMD_f32x4_convert_i32x4_s = 0xfa, + SIMD_f32x4_convert_i32x4_u = 0xfb, SIMD_i32x4_trunc_sat_f64x2_s_zero = 0xfc, SIMD_i32x4_trunc_sat_f64x2_u_zero = 0xfd, - SIMD_f64x2_convert_low_i32x4_s = 0xfe, - SIMD_f64x2_convert_low_i32x4_u = 0xff, + SIMD_f64x2_convert_low_i32x4_s = 0xfe, + SIMD_f64x2_convert_low_i32x4_u = 0xff, } WASMSimdEXTOpcode; typedef enum WASMAtomicEXTOpcode { /* atomic wait and notify */ - WASM_OP_ATOMIC_NOTIFY = 0x00, - WASM_OP_ATOMIC_WAIT32 = 0x01, - WASM_OP_ATOMIC_WAIT64 = 0x02, - WASM_OP_ATOMIC_FENCE = 0x03, + WASM_OP_ATOMIC_NOTIFY = 0x00, + WASM_OP_ATOMIC_WAIT32 = 0x01, + WASM_OP_ATOMIC_WAIT64 = 0x02, + WASM_OP_ATOMIC_FENCE = 0x03, /* atomic load and store */ - WASM_OP_ATOMIC_I32_LOAD = 0x10, - WASM_OP_ATOMIC_I64_LOAD = 0x11, - WASM_OP_ATOMIC_I32_LOAD8_U = 0x12, - WASM_OP_ATOMIC_I32_LOAD16_U = 0x13, - WASM_OP_ATOMIC_I64_LOAD8_U = 0x14, - WASM_OP_ATOMIC_I64_LOAD16_U = 0x15, - WASM_OP_ATOMIC_I64_LOAD32_U = 0x16, - WASM_OP_ATOMIC_I32_STORE = 0x17, - WASM_OP_ATOMIC_I64_STORE = 0x18, - WASM_OP_ATOMIC_I32_STORE8 = 0x19, - WASM_OP_ATOMIC_I32_STORE16 = 0x1a, - WASM_OP_ATOMIC_I64_STORE8 = 0x1b, - WASM_OP_ATOMIC_I64_STORE16 = 0x1c, - WASM_OP_ATOMIC_I64_STORE32 = 0x1d, + WASM_OP_ATOMIC_I32_LOAD = 0x10, + WASM_OP_ATOMIC_I64_LOAD = 0x11, + WASM_OP_ATOMIC_I32_LOAD8_U = 0x12, + WASM_OP_ATOMIC_I32_LOAD16_U = 0x13, + WASM_OP_ATOMIC_I64_LOAD8_U = 0x14, + WASM_OP_ATOMIC_I64_LOAD16_U = 0x15, + WASM_OP_ATOMIC_I64_LOAD32_U = 0x16, + WASM_OP_ATOMIC_I32_STORE = 0x17, + WASM_OP_ATOMIC_I64_STORE = 0x18, + WASM_OP_ATOMIC_I32_STORE8 = 0x19, + WASM_OP_ATOMIC_I32_STORE16 = 0x1a, + WASM_OP_ATOMIC_I64_STORE8 = 0x1b, + WASM_OP_ATOMIC_I64_STORE16 = 0x1c, + WASM_OP_ATOMIC_I64_STORE32 = 0x1d, /* atomic add */ - WASM_OP_ATOMIC_RMW_I32_ADD = 0x1e, - WASM_OP_ATOMIC_RMW_I64_ADD = 0x1f, - WASM_OP_ATOMIC_RMW_I32_ADD8_U = 0x20, - WASM_OP_ATOMIC_RMW_I32_ADD16_U = 0x21, - WASM_OP_ATOMIC_RMW_I64_ADD8_U = 0x22, - WASM_OP_ATOMIC_RMW_I64_ADD16_U = 0x23, - WASM_OP_ATOMIC_RMW_I64_ADD32_U = 0x24, + WASM_OP_ATOMIC_RMW_I32_ADD = 0x1e, + WASM_OP_ATOMIC_RMW_I64_ADD = 0x1f, + WASM_OP_ATOMIC_RMW_I32_ADD8_U = 0x20, + WASM_OP_ATOMIC_RMW_I32_ADD16_U = 0x21, + WASM_OP_ATOMIC_RMW_I64_ADD8_U = 0x22, + WASM_OP_ATOMIC_RMW_I64_ADD16_U = 0x23, + WASM_OP_ATOMIC_RMW_I64_ADD32_U = 0x24, /* atomic sub */ - WASM_OP_ATOMIC_RMW_I32_SUB = 0x25, - WASM_OP_ATOMIC_RMW_I64_SUB = 0x26, - WASM_OP_ATOMIC_RMW_I32_SUB8_U = 0x27, - WASM_OP_ATOMIC_RMW_I32_SUB16_U = 0x28, - WASM_OP_ATOMIC_RMW_I64_SUB8_U = 0x29, - WASM_OP_ATOMIC_RMW_I64_SUB16_U = 0x2a, - WASM_OP_ATOMIC_RMW_I64_SUB32_U = 0x2b, + WASM_OP_ATOMIC_RMW_I32_SUB = 0x25, + WASM_OP_ATOMIC_RMW_I64_SUB = 0x26, + WASM_OP_ATOMIC_RMW_I32_SUB8_U = 0x27, + WASM_OP_ATOMIC_RMW_I32_SUB16_U = 0x28, + WASM_OP_ATOMIC_RMW_I64_SUB8_U = 0x29, + WASM_OP_ATOMIC_RMW_I64_SUB16_U = 0x2a, + WASM_OP_ATOMIC_RMW_I64_SUB32_U = 0x2b, /* atomic and */ - WASM_OP_ATOMIC_RMW_I32_AND = 0x2c, - WASM_OP_ATOMIC_RMW_I64_AND = 0x2d, - WASM_OP_ATOMIC_RMW_I32_AND8_U = 0x2e, - WASM_OP_ATOMIC_RMW_I32_AND16_U = 0x2f, - WASM_OP_ATOMIC_RMW_I64_AND8_U = 0x30, - WASM_OP_ATOMIC_RMW_I64_AND16_U = 0x31, - WASM_OP_ATOMIC_RMW_I64_AND32_U = 0x32, + WASM_OP_ATOMIC_RMW_I32_AND = 0x2c, + WASM_OP_ATOMIC_RMW_I64_AND = 0x2d, + WASM_OP_ATOMIC_RMW_I32_AND8_U = 0x2e, + WASM_OP_ATOMIC_RMW_I32_AND16_U = 0x2f, + WASM_OP_ATOMIC_RMW_I64_AND8_U = 0x30, + WASM_OP_ATOMIC_RMW_I64_AND16_U = 0x31, + WASM_OP_ATOMIC_RMW_I64_AND32_U = 0x32, /* atomic or */ - WASM_OP_ATOMIC_RMW_I32_OR = 0x33, - WASM_OP_ATOMIC_RMW_I64_OR = 0x34, - WASM_OP_ATOMIC_RMW_I32_OR8_U = 0x35, - WASM_OP_ATOMIC_RMW_I32_OR16_U = 0x36, - WASM_OP_ATOMIC_RMW_I64_OR8_U = 0x37, - WASM_OP_ATOMIC_RMW_I64_OR16_U = 0x38, - WASM_OP_ATOMIC_RMW_I64_OR32_U = 0x39, + WASM_OP_ATOMIC_RMW_I32_OR = 0x33, + WASM_OP_ATOMIC_RMW_I64_OR = 0x34, + WASM_OP_ATOMIC_RMW_I32_OR8_U = 0x35, + WASM_OP_ATOMIC_RMW_I32_OR16_U = 0x36, + WASM_OP_ATOMIC_RMW_I64_OR8_U = 0x37, + WASM_OP_ATOMIC_RMW_I64_OR16_U = 0x38, + WASM_OP_ATOMIC_RMW_I64_OR32_U = 0x39, /* atomic xor */ - WASM_OP_ATOMIC_RMW_I32_XOR = 0x3a, - WASM_OP_ATOMIC_RMW_I64_XOR = 0x3b, - WASM_OP_ATOMIC_RMW_I32_XOR8_U = 0x3c, - WASM_OP_ATOMIC_RMW_I32_XOR16_U = 0x3d, - WASM_OP_ATOMIC_RMW_I64_XOR8_U = 0x3e, - WASM_OP_ATOMIC_RMW_I64_XOR16_U = 0x3f, - WASM_OP_ATOMIC_RMW_I64_XOR32_U = 0x40, + WASM_OP_ATOMIC_RMW_I32_XOR = 0x3a, + WASM_OP_ATOMIC_RMW_I64_XOR = 0x3b, + WASM_OP_ATOMIC_RMW_I32_XOR8_U = 0x3c, + WASM_OP_ATOMIC_RMW_I32_XOR16_U = 0x3d, + WASM_OP_ATOMIC_RMW_I64_XOR8_U = 0x3e, + WASM_OP_ATOMIC_RMW_I64_XOR16_U = 0x3f, + WASM_OP_ATOMIC_RMW_I64_XOR32_U = 0x40, /* atomic xchg */ - WASM_OP_ATOMIC_RMW_I32_XCHG = 0x41, - WASM_OP_ATOMIC_RMW_I64_XCHG = 0x42, - WASM_OP_ATOMIC_RMW_I32_XCHG8_U = 0x43, - WASM_OP_ATOMIC_RMW_I32_XCHG16_U = 0x44, - WASM_OP_ATOMIC_RMW_I64_XCHG8_U = 0x45, - WASM_OP_ATOMIC_RMW_I64_XCHG16_U = 0x46, - WASM_OP_ATOMIC_RMW_I64_XCHG32_U = 0x47, + WASM_OP_ATOMIC_RMW_I32_XCHG = 0x41, + WASM_OP_ATOMIC_RMW_I64_XCHG = 0x42, + WASM_OP_ATOMIC_RMW_I32_XCHG8_U = 0x43, + WASM_OP_ATOMIC_RMW_I32_XCHG16_U = 0x44, + WASM_OP_ATOMIC_RMW_I64_XCHG8_U = 0x45, + WASM_OP_ATOMIC_RMW_I64_XCHG16_U = 0x46, + WASM_OP_ATOMIC_RMW_I64_XCHG32_U = 0x47, /* atomic cmpxchg */ - WASM_OP_ATOMIC_RMW_I32_CMPXCHG = 0x48, - WASM_OP_ATOMIC_RMW_I64_CMPXCHG = 0x49, - WASM_OP_ATOMIC_RMW_I32_CMPXCHG8_U = 0x4a, - WASM_OP_ATOMIC_RMW_I32_CMPXCHG16_U = 0x4b, - WASM_OP_ATOMIC_RMW_I64_CMPXCHG8_U = 0x4c, - WASM_OP_ATOMIC_RMW_I64_CMPXCHG16_U = 0x4d, - WASM_OP_ATOMIC_RMW_I64_CMPXCHG32_U = 0x4e, + WASM_OP_ATOMIC_RMW_I32_CMPXCHG = 0x48, + WASM_OP_ATOMIC_RMW_I64_CMPXCHG = 0x49, + WASM_OP_ATOMIC_RMW_I32_CMPXCHG8_U = 0x4a, + WASM_OP_ATOMIC_RMW_I32_CMPXCHG16_U = 0x4b, + WASM_OP_ATOMIC_RMW_I64_CMPXCHG8_U = 0x4c, + WASM_OP_ATOMIC_RMW_I64_CMPXCHG16_U = 0x4d, + WASM_OP_ATOMIC_RMW_I64_CMPXCHG32_U = 0x4e, } WASMAtomicEXTOpcode; -#ifdef __cplusplus -} -#endif - #if WASM_ENABLE_DEBUG_INTERP != 0 -#define DEF_DEBUG_BREAK_HANDLE(_name) \ - _name[DEBUG_OP_BREAK] = \ - HANDLE_OPCODE (DEBUG_OP_BREAK); /* 0xd6 */ +#define DEF_DEBUG_BREAK_HANDLE(_name) \ + _name[DEBUG_OP_BREAK] = HANDLE_OPCODE(DEBUG_OP_BREAK); /* 0xd6 */ #else #define DEF_DEBUG_BREAK_HANDLE(_name) #endif @@ -690,229 +685,233 @@ typedef enum WASMAtomicEXTOpcode { */ #define WASM_INSTRUCTION_NUM 256 -#define DEFINE_GOTO_TABLE(type, _name) \ -static type _name[WASM_INSTRUCTION_NUM] = { \ - HANDLE_OPCODE (WASM_OP_UNREACHABLE), /* 0x00 */ \ - HANDLE_OPCODE (WASM_OP_NOP), /* 0x01 */ \ - HANDLE_OPCODE (WASM_OP_BLOCK), /* 0x02 */ \ - HANDLE_OPCODE (WASM_OP_LOOP), /* 0x03 */ \ - HANDLE_OPCODE (WASM_OP_IF), /* 0x04 */ \ - HANDLE_OPCODE (WASM_OP_ELSE), /* 0x05 */ \ - HANDLE_OPCODE (WASM_OP_UNUSED_0x06), /* 0x06 */ \ - HANDLE_OPCODE (WASM_OP_UNUSED_0x07), /* 0x07 */ \ - HANDLE_OPCODE (WASM_OP_UNUSED_0x08), /* 0x08 */ \ - HANDLE_OPCODE (WASM_OP_UNUSED_0x09), /* 0x09 */ \ - HANDLE_OPCODE (WASM_OP_UNUSED_0x0a), /* 0x0a */ \ - HANDLE_OPCODE (WASM_OP_END), /* 0x0b */ \ - HANDLE_OPCODE (WASM_OP_BR), /* 0x0c */ \ - HANDLE_OPCODE (WASM_OP_BR_IF), /* 0x0d */ \ - HANDLE_OPCODE (WASM_OP_BR_TABLE), /* 0x0e */ \ - HANDLE_OPCODE (WASM_OP_RETURN), /* 0x0f */ \ - HANDLE_OPCODE (WASM_OP_CALL), /* 0x10 */ \ - HANDLE_OPCODE (WASM_OP_CALL_INDIRECT), /* 0x11 */ \ - HANDLE_OPCODE (WASM_OP_RETURN_CALL), /* 0x12 */ \ - HANDLE_OPCODE (WASM_OP_RETURN_CALL_INDIRECT), /* 0x13 */ \ - HANDLE_OPCODE (WASM_OP_UNUSED_0x14), /* 0x14 */ \ - HANDLE_OPCODE (WASM_OP_UNUSED_0x15), /* 0x15 */ \ - HANDLE_OPCODE (WASM_OP_UNUSED_0x16), /* 0x16 */ \ - HANDLE_OPCODE (WASM_OP_UNUSED_0x17), /* 0x17 */ \ - HANDLE_OPCODE (WASM_OP_UNUSED_0x18), /* 0x18 */ \ - HANDLE_OPCODE (WASM_OP_UNUSED_0x19), /* 0x19 */ \ - HANDLE_OPCODE (WASM_OP_DROP), /* 0x1a */ \ - HANDLE_OPCODE (WASM_OP_SELECT), /* 0x1b */ \ - HANDLE_OPCODE (WASM_OP_SELECT_T), /* 0x1c */ \ - HANDLE_OPCODE (WASM_OP_GET_GLOBAL_64), /* 0x1d */ \ - HANDLE_OPCODE (WASM_OP_SET_GLOBAL_64), /* 0x1e */ \ - HANDLE_OPCODE (WASM_OP_SET_GLOBAL_AUX_STACK), /* 0x1f */ \ - HANDLE_OPCODE (WASM_OP_GET_LOCAL), /* 0x20 */ \ - HANDLE_OPCODE (WASM_OP_SET_LOCAL), /* 0x21 */ \ - HANDLE_OPCODE (WASM_OP_TEE_LOCAL), /* 0x22 */ \ - HANDLE_OPCODE (WASM_OP_GET_GLOBAL), /* 0x23 */ \ - HANDLE_OPCODE (WASM_OP_SET_GLOBAL), /* 0x24 */ \ - HANDLE_OPCODE (WASM_OP_TABLE_GET), /* 0x25 */ \ - HANDLE_OPCODE (WASM_OP_TABLE_SET), /* 0x26 */ \ - HANDLE_OPCODE (WASM_OP_UNUSED_0x27), /* 0x27 */ \ - HANDLE_OPCODE (WASM_OP_I32_LOAD), /* 0x28 */ \ - HANDLE_OPCODE (WASM_OP_I64_LOAD), /* 0x29 */ \ - HANDLE_OPCODE (WASM_OP_F32_LOAD), /* 0x2a */ \ - HANDLE_OPCODE (WASM_OP_F64_LOAD), /* 0x2b */ \ - HANDLE_OPCODE (WASM_OP_I32_LOAD8_S), /* 0x2c */ \ - HANDLE_OPCODE (WASM_OP_I32_LOAD8_U), /* 0x2d */ \ - HANDLE_OPCODE (WASM_OP_I32_LOAD16_S), /* 0x2e */ \ - HANDLE_OPCODE (WASM_OP_I32_LOAD16_U), /* 0x2f */ \ - HANDLE_OPCODE (WASM_OP_I64_LOAD8_S), /* 0x30 */ \ - HANDLE_OPCODE (WASM_OP_I64_LOAD8_U), /* 0x31 */ \ - HANDLE_OPCODE (WASM_OP_I64_LOAD16_S), /* 0x32 */ \ - HANDLE_OPCODE (WASM_OP_I64_LOAD16_U), /* 0x33 */ \ - HANDLE_OPCODE (WASM_OP_I64_LOAD32_S), /* 0x34 */ \ - HANDLE_OPCODE (WASM_OP_I64_LOAD32_U), /* 0x35 */ \ - HANDLE_OPCODE (WASM_OP_I32_STORE), /* 0x36 */ \ - HANDLE_OPCODE (WASM_OP_I64_STORE), /* 0x37 */ \ - HANDLE_OPCODE (WASM_OP_F32_STORE), /* 0x38 */ \ - HANDLE_OPCODE (WASM_OP_F64_STORE), /* 0x39 */ \ - HANDLE_OPCODE (WASM_OP_I32_STORE8), /* 0x3a */ \ - HANDLE_OPCODE (WASM_OP_I32_STORE16), /* 0x3b */ \ - HANDLE_OPCODE (WASM_OP_I64_STORE8), /* 0x3c */ \ - HANDLE_OPCODE (WASM_OP_I64_STORE16), /* 0x3d */ \ - HANDLE_OPCODE (WASM_OP_I64_STORE32), /* 0x3e */ \ - HANDLE_OPCODE (WASM_OP_MEMORY_SIZE), /* 0x3f */ \ - HANDLE_OPCODE (WASM_OP_MEMORY_GROW), /* 0x40 */ \ - HANDLE_OPCODE (WASM_OP_I32_CONST), /* 0x41 */ \ - HANDLE_OPCODE (WASM_OP_I64_CONST), /* 0x42 */ \ - HANDLE_OPCODE (WASM_OP_F32_CONST), /* 0x43 */ \ - HANDLE_OPCODE (WASM_OP_F64_CONST), /* 0x44 */ \ - HANDLE_OPCODE (WASM_OP_I32_EQZ), /* 0x45 */ \ - HANDLE_OPCODE (WASM_OP_I32_EQ), /* 0x46 */ \ - HANDLE_OPCODE (WASM_OP_I32_NE), /* 0x47 */ \ - HANDLE_OPCODE (WASM_OP_I32_LT_S), /* 0x48 */ \ - HANDLE_OPCODE (WASM_OP_I32_LT_U), /* 0x49 */ \ - HANDLE_OPCODE (WASM_OP_I32_GT_S), /* 0x4a */ \ - HANDLE_OPCODE (WASM_OP_I32_GT_U), /* 0x4b */ \ - HANDLE_OPCODE (WASM_OP_I32_LE_S), /* 0x4c */ \ - HANDLE_OPCODE (WASM_OP_I32_LE_U), /* 0x4d */ \ - HANDLE_OPCODE (WASM_OP_I32_GE_S), /* 0x4e */ \ - HANDLE_OPCODE (WASM_OP_I32_GE_U), /* 0x4f */ \ - HANDLE_OPCODE (WASM_OP_I64_EQZ), /* 0x50 */ \ - HANDLE_OPCODE (WASM_OP_I64_EQ), /* 0x51 */ \ - HANDLE_OPCODE (WASM_OP_I64_NE), /* 0x52 */ \ - HANDLE_OPCODE (WASM_OP_I64_LT_S), /* 0x53 */ \ - HANDLE_OPCODE (WASM_OP_I64_LT_U), /* 0x54 */ \ - HANDLE_OPCODE (WASM_OP_I64_GT_S), /* 0x55 */ \ - HANDLE_OPCODE (WASM_OP_I64_GT_U), /* 0x56 */ \ - HANDLE_OPCODE (WASM_OP_I64_LE_S), /* 0x57 */ \ - HANDLE_OPCODE (WASM_OP_I64_LE_U), /* 0x58 */ \ - HANDLE_OPCODE (WASM_OP_I64_GE_S), /* 0x59 */ \ - HANDLE_OPCODE (WASM_OP_I64_GE_U), /* 0x5a */ \ - HANDLE_OPCODE (WASM_OP_F32_EQ), /* 0x5b */ \ - HANDLE_OPCODE (WASM_OP_F32_NE), /* 0x5c */ \ - HANDLE_OPCODE (WASM_OP_F32_LT), /* 0x5d */ \ - HANDLE_OPCODE (WASM_OP_F32_GT), /* 0x5e */ \ - HANDLE_OPCODE (WASM_OP_F32_LE), /* 0x5f */ \ - HANDLE_OPCODE (WASM_OP_F32_GE), /* 0x60 */ \ - HANDLE_OPCODE (WASM_OP_F64_EQ), /* 0x61 */ \ - HANDLE_OPCODE (WASM_OP_F64_NE), /* 0x62 */ \ - HANDLE_OPCODE (WASM_OP_F64_LT), /* 0x63 */ \ - HANDLE_OPCODE (WASM_OP_F64_GT), /* 0x64 */ \ - HANDLE_OPCODE (WASM_OP_F64_LE), /* 0x65 */ \ - HANDLE_OPCODE (WASM_OP_F64_GE), /* 0x66 */ \ - HANDLE_OPCODE (WASM_OP_I32_CLZ), /* 0x67 */ \ - HANDLE_OPCODE (WASM_OP_I32_CTZ), /* 0x68 */ \ - HANDLE_OPCODE (WASM_OP_I32_POPCNT), /* 0x69 */ \ - HANDLE_OPCODE (WASM_OP_I32_ADD), /* 0x6a */ \ - HANDLE_OPCODE (WASM_OP_I32_SUB), /* 0x6b */ \ - HANDLE_OPCODE (WASM_OP_I32_MUL), /* 0x6c */ \ - HANDLE_OPCODE (WASM_OP_I32_DIV_S), /* 0x6d */ \ - HANDLE_OPCODE (WASM_OP_I32_DIV_U), /* 0x6e */ \ - HANDLE_OPCODE (WASM_OP_I32_REM_S), /* 0x6f */ \ - HANDLE_OPCODE (WASM_OP_I32_REM_U), /* 0x70 */ \ - HANDLE_OPCODE (WASM_OP_I32_AND), /* 0x71 */ \ - HANDLE_OPCODE (WASM_OP_I32_OR), /* 0x72 */ \ - HANDLE_OPCODE (WASM_OP_I32_XOR), /* 0x73 */ \ - HANDLE_OPCODE (WASM_OP_I32_SHL), /* 0x74 */ \ - HANDLE_OPCODE (WASM_OP_I32_SHR_S), /* 0x75 */ \ - HANDLE_OPCODE (WASM_OP_I32_SHR_U), /* 0x76 */ \ - HANDLE_OPCODE (WASM_OP_I32_ROTL), /* 0x77 */ \ - HANDLE_OPCODE (WASM_OP_I32_ROTR), /* 0x78 */ \ - HANDLE_OPCODE (WASM_OP_I64_CLZ), /* 0x79 */ \ - HANDLE_OPCODE (WASM_OP_I64_CTZ), /* 0x7a */ \ - HANDLE_OPCODE (WASM_OP_I64_POPCNT), /* 0x7b */ \ - HANDLE_OPCODE (WASM_OP_I64_ADD), /* 0x7c */ \ - HANDLE_OPCODE (WASM_OP_I64_SUB), /* 0x7d */ \ - HANDLE_OPCODE (WASM_OP_I64_MUL), /* 0x7e */ \ - HANDLE_OPCODE (WASM_OP_I64_DIV_S), /* 0x7f */ \ - HANDLE_OPCODE (WASM_OP_I64_DIV_U), /* 0x80 */ \ - HANDLE_OPCODE (WASM_OP_I64_REM_S), /* 0x81 */ \ - HANDLE_OPCODE (WASM_OP_I64_REM_U), /* 0x82 */ \ - HANDLE_OPCODE (WASM_OP_I64_AND), /* 0x83 */ \ - HANDLE_OPCODE (WASM_OP_I64_OR), /* 0x84 */ \ - HANDLE_OPCODE (WASM_OP_I64_XOR), /* 0x85 */ \ - HANDLE_OPCODE (WASM_OP_I64_SHL), /* 0x86 */ \ - HANDLE_OPCODE (WASM_OP_I64_SHR_S), /* 0x87 */ \ - HANDLE_OPCODE (WASM_OP_I64_SHR_U), /* 0x88 */ \ - HANDLE_OPCODE (WASM_OP_I64_ROTL), /* 0x89 */ \ - HANDLE_OPCODE (WASM_OP_I64_ROTR), /* 0x8a */ \ - HANDLE_OPCODE (WASM_OP_F32_ABS), /* 0x8b */ \ - HANDLE_OPCODE (WASM_OP_F32_NEG), /* 0x8c */ \ - HANDLE_OPCODE (WASM_OP_F32_CEIL), /* 0x8d */ \ - HANDLE_OPCODE (WASM_OP_F32_FLOOR), /* 0x8e */ \ - HANDLE_OPCODE (WASM_OP_F32_TRUNC), /* 0x8f */ \ - HANDLE_OPCODE (WASM_OP_F32_NEAREST), /* 0x90 */ \ - HANDLE_OPCODE (WASM_OP_F32_SQRT), /* 0x91 */ \ - HANDLE_OPCODE (WASM_OP_F32_ADD), /* 0x92 */ \ - HANDLE_OPCODE (WASM_OP_F32_SUB), /* 0x93 */ \ - HANDLE_OPCODE (WASM_OP_F32_MUL), /* 0x94 */ \ - HANDLE_OPCODE (WASM_OP_F32_DIV), /* 0x95 */ \ - HANDLE_OPCODE (WASM_OP_F32_MIN), /* 0x96 */ \ - HANDLE_OPCODE (WASM_OP_F32_MAX), /* 0x97 */ \ - HANDLE_OPCODE (WASM_OP_F32_COPYSIGN), /* 0x98 */ \ - HANDLE_OPCODE (WASM_OP_F64_ABS), /* 0x99 */ \ - HANDLE_OPCODE (WASM_OP_F64_NEG), /* 0x9a */ \ - HANDLE_OPCODE (WASM_OP_F64_CEIL), /* 0x9b */ \ - HANDLE_OPCODE (WASM_OP_F64_FLOOR), /* 0x9c */ \ - HANDLE_OPCODE (WASM_OP_F64_TRUNC), /* 0x9d */ \ - HANDLE_OPCODE (WASM_OP_F64_NEAREST), /* 0x9e */ \ - HANDLE_OPCODE (WASM_OP_F64_SQRT), /* 0x9f */ \ - HANDLE_OPCODE (WASM_OP_F64_ADD), /* 0xa0 */ \ - HANDLE_OPCODE (WASM_OP_F64_SUB), /* 0xa1 */ \ - HANDLE_OPCODE (WASM_OP_F64_MUL), /* 0xa2 */ \ - HANDLE_OPCODE (WASM_OP_F64_DIV), /* 0xa3 */ \ - HANDLE_OPCODE (WASM_OP_F64_MIN), /* 0xa4 */ \ - HANDLE_OPCODE (WASM_OP_F64_MAX), /* 0xa5 */ \ - HANDLE_OPCODE (WASM_OP_F64_COPYSIGN), /* 0xa6 */ \ - HANDLE_OPCODE (WASM_OP_I32_WRAP_I64), /* 0xa7 */ \ - HANDLE_OPCODE (WASM_OP_I32_TRUNC_S_F32), /* 0xa8 */ \ - HANDLE_OPCODE (WASM_OP_I32_TRUNC_U_F32), /* 0xa9 */ \ - HANDLE_OPCODE (WASM_OP_I32_TRUNC_S_F64), /* 0xaa */ \ - HANDLE_OPCODE (WASM_OP_I32_TRUNC_U_F64), /* 0xab */ \ - HANDLE_OPCODE (WASM_OP_I64_EXTEND_S_I32), /* 0xac */ \ - HANDLE_OPCODE (WASM_OP_I64_EXTEND_U_I32), /* 0xad */ \ - HANDLE_OPCODE (WASM_OP_I64_TRUNC_S_F32), /* 0xae */ \ - HANDLE_OPCODE (WASM_OP_I64_TRUNC_U_F32), /* 0xaf */ \ - HANDLE_OPCODE (WASM_OP_I64_TRUNC_S_F64), /* 0xb0 */ \ - HANDLE_OPCODE (WASM_OP_I64_TRUNC_U_F64), /* 0xb1 */ \ - HANDLE_OPCODE (WASM_OP_F32_CONVERT_S_I32), /* 0xb2 */ \ - HANDLE_OPCODE (WASM_OP_F32_CONVERT_U_I32), /* 0xb3 */ \ - HANDLE_OPCODE (WASM_OP_F32_CONVERT_S_I64), /* 0xb4 */ \ - HANDLE_OPCODE (WASM_OP_F32_CONVERT_U_I64), /* 0xb5 */ \ - HANDLE_OPCODE (WASM_OP_F32_DEMOTE_F64), /* 0xb6 */ \ - HANDLE_OPCODE (WASM_OP_F64_CONVERT_S_I32), /* 0xb7 */ \ - HANDLE_OPCODE (WASM_OP_F64_CONVERT_U_I32), /* 0xb8 */ \ - HANDLE_OPCODE (WASM_OP_F64_CONVERT_S_I64), /* 0xb9 */ \ - HANDLE_OPCODE (WASM_OP_F64_CONVERT_U_I64), /* 0xba */ \ - HANDLE_OPCODE (WASM_OP_F64_PROMOTE_F32), /* 0xbb */ \ - HANDLE_OPCODE (WASM_OP_I32_REINTERPRET_F32), /* 0xbc */ \ - HANDLE_OPCODE (WASM_OP_I64_REINTERPRET_F64), /* 0xbd */ \ - HANDLE_OPCODE (WASM_OP_F32_REINTERPRET_I32), /* 0xbe */ \ - HANDLE_OPCODE (WASM_OP_F64_REINTERPRET_I64), /* 0xbf */ \ - HANDLE_OPCODE (WASM_OP_I32_EXTEND8_S), /* 0xc0 */ \ - HANDLE_OPCODE (WASM_OP_I32_EXTEND16_S), /* 0xc1 */ \ - HANDLE_OPCODE (WASM_OP_I64_EXTEND8_S), /* 0xc2 */ \ - HANDLE_OPCODE (WASM_OP_I64_EXTEND16_S), /* 0xc3 */ \ - HANDLE_OPCODE (WASM_OP_I64_EXTEND32_S), /* 0xc4 */ \ - HANDLE_OPCODE (WASM_OP_DROP_64), /* 0xc5 */ \ - HANDLE_OPCODE (WASM_OP_SELECT_64), /* 0xc6 */ \ - HANDLE_OPCODE (EXT_OP_GET_LOCAL_FAST), /* 0xc7 */ \ - HANDLE_OPCODE (EXT_OP_SET_LOCAL_FAST_I64), /* 0xc8 */ \ - HANDLE_OPCODE (EXT_OP_SET_LOCAL_FAST), /* 0xc9 */ \ - HANDLE_OPCODE (EXT_OP_TEE_LOCAL_FAST), /* 0xca */ \ - HANDLE_OPCODE (EXT_OP_TEE_LOCAL_FAST_I64), /* 0xcb */ \ - HANDLE_OPCODE (EXT_OP_COPY_STACK_TOP), /* 0xcc */ \ - HANDLE_OPCODE (EXT_OP_COPY_STACK_TOP_I64), /* 0xcd */ \ - HANDLE_OPCODE (EXT_OP_COPY_STACK_VALUES), /* 0xce */ \ - HANDLE_OPCODE (WASM_OP_IMPDEP), /* 0xcf */ \ - HANDLE_OPCODE (WASM_OP_REF_NULL), /* 0xd0 */ \ - HANDLE_OPCODE (WASM_OP_REF_IS_NULL), /* 0xd1 */ \ - HANDLE_OPCODE (WASM_OP_REF_FUNC), /* 0xd2 */ \ - HANDLE_OPCODE (EXT_OP_BLOCK), /* 0xd3 */ \ - HANDLE_OPCODE (EXT_OP_LOOP), /* 0xd4 */ \ - HANDLE_OPCODE (EXT_OP_IF), /* 0xd5 */ \ -}; \ -do { \ - _name[WASM_OP_MISC_PREFIX] = \ - HANDLE_OPCODE (WASM_OP_MISC_PREFIX); /* 0xfc */ \ - _name[WASM_OP_ATOMIC_PREFIX] = \ - HANDLE_OPCODE (WASM_OP_ATOMIC_PREFIX); /* 0xfe */ \ - DEF_DEBUG_BREAK_HANDLE(_name) \ -} while (0) -#endif /* end of _WASM_OPCODE_H */ +#define DEFINE_GOTO_TABLE(type, _name) \ + static type _name[WASM_INSTRUCTION_NUM] = { \ + HANDLE_OPCODE(WASM_OP_UNREACHABLE), /* 0x00 */ \ + HANDLE_OPCODE(WASM_OP_NOP), /* 0x01 */ \ + HANDLE_OPCODE(WASM_OP_BLOCK), /* 0x02 */ \ + HANDLE_OPCODE(WASM_OP_LOOP), /* 0x03 */ \ + HANDLE_OPCODE(WASM_OP_IF), /* 0x04 */ \ + HANDLE_OPCODE(WASM_OP_ELSE), /* 0x05 */ \ + HANDLE_OPCODE(WASM_OP_UNUSED_0x06), /* 0x06 */ \ + HANDLE_OPCODE(WASM_OP_UNUSED_0x07), /* 0x07 */ \ + HANDLE_OPCODE(WASM_OP_UNUSED_0x08), /* 0x08 */ \ + HANDLE_OPCODE(WASM_OP_UNUSED_0x09), /* 0x09 */ \ + HANDLE_OPCODE(WASM_OP_UNUSED_0x0a), /* 0x0a */ \ + HANDLE_OPCODE(WASM_OP_END), /* 0x0b */ \ + HANDLE_OPCODE(WASM_OP_BR), /* 0x0c */ \ + HANDLE_OPCODE(WASM_OP_BR_IF), /* 0x0d */ \ + HANDLE_OPCODE(WASM_OP_BR_TABLE), /* 0x0e */ \ + HANDLE_OPCODE(WASM_OP_RETURN), /* 0x0f */ \ + HANDLE_OPCODE(WASM_OP_CALL), /* 0x10 */ \ + HANDLE_OPCODE(WASM_OP_CALL_INDIRECT), /* 0x11 */ \ + HANDLE_OPCODE(WASM_OP_RETURN_CALL), /* 0x12 */ \ + HANDLE_OPCODE(WASM_OP_RETURN_CALL_INDIRECT), /* 0x13 */ \ + HANDLE_OPCODE(WASM_OP_UNUSED_0x14), /* 0x14 */ \ + HANDLE_OPCODE(WASM_OP_UNUSED_0x15), /* 0x15 */ \ + HANDLE_OPCODE(WASM_OP_UNUSED_0x16), /* 0x16 */ \ + HANDLE_OPCODE(WASM_OP_UNUSED_0x17), /* 0x17 */ \ + HANDLE_OPCODE(WASM_OP_UNUSED_0x18), /* 0x18 */ \ + HANDLE_OPCODE(WASM_OP_UNUSED_0x19), /* 0x19 */ \ + HANDLE_OPCODE(WASM_OP_DROP), /* 0x1a */ \ + HANDLE_OPCODE(WASM_OP_SELECT), /* 0x1b */ \ + HANDLE_OPCODE(WASM_OP_SELECT_T), /* 0x1c */ \ + HANDLE_OPCODE(WASM_OP_GET_GLOBAL_64), /* 0x1d */ \ + HANDLE_OPCODE(WASM_OP_SET_GLOBAL_64), /* 0x1e */ \ + HANDLE_OPCODE(WASM_OP_SET_GLOBAL_AUX_STACK), /* 0x1f */ \ + HANDLE_OPCODE(WASM_OP_GET_LOCAL), /* 0x20 */ \ + HANDLE_OPCODE(WASM_OP_SET_LOCAL), /* 0x21 */ \ + HANDLE_OPCODE(WASM_OP_TEE_LOCAL), /* 0x22 */ \ + HANDLE_OPCODE(WASM_OP_GET_GLOBAL), /* 0x23 */ \ + HANDLE_OPCODE(WASM_OP_SET_GLOBAL), /* 0x24 */ \ + HANDLE_OPCODE(WASM_OP_TABLE_GET), /* 0x25 */ \ + HANDLE_OPCODE(WASM_OP_TABLE_SET), /* 0x26 */ \ + HANDLE_OPCODE(WASM_OP_UNUSED_0x27), /* 0x27 */ \ + HANDLE_OPCODE(WASM_OP_I32_LOAD), /* 0x28 */ \ + HANDLE_OPCODE(WASM_OP_I64_LOAD), /* 0x29 */ \ + HANDLE_OPCODE(WASM_OP_F32_LOAD), /* 0x2a */ \ + HANDLE_OPCODE(WASM_OP_F64_LOAD), /* 0x2b */ \ + HANDLE_OPCODE(WASM_OP_I32_LOAD8_S), /* 0x2c */ \ + HANDLE_OPCODE(WASM_OP_I32_LOAD8_U), /* 0x2d */ \ + HANDLE_OPCODE(WASM_OP_I32_LOAD16_S), /* 0x2e */ \ + HANDLE_OPCODE(WASM_OP_I32_LOAD16_U), /* 0x2f */ \ + HANDLE_OPCODE(WASM_OP_I64_LOAD8_S), /* 0x30 */ \ + HANDLE_OPCODE(WASM_OP_I64_LOAD8_U), /* 0x31 */ \ + HANDLE_OPCODE(WASM_OP_I64_LOAD16_S), /* 0x32 */ \ + HANDLE_OPCODE(WASM_OP_I64_LOAD16_U), /* 0x33 */ \ + HANDLE_OPCODE(WASM_OP_I64_LOAD32_S), /* 0x34 */ \ + HANDLE_OPCODE(WASM_OP_I64_LOAD32_U), /* 0x35 */ \ + HANDLE_OPCODE(WASM_OP_I32_STORE), /* 0x36 */ \ + HANDLE_OPCODE(WASM_OP_I64_STORE), /* 0x37 */ \ + HANDLE_OPCODE(WASM_OP_F32_STORE), /* 0x38 */ \ + HANDLE_OPCODE(WASM_OP_F64_STORE), /* 0x39 */ \ + HANDLE_OPCODE(WASM_OP_I32_STORE8), /* 0x3a */ \ + HANDLE_OPCODE(WASM_OP_I32_STORE16), /* 0x3b */ \ + HANDLE_OPCODE(WASM_OP_I64_STORE8), /* 0x3c */ \ + HANDLE_OPCODE(WASM_OP_I64_STORE16), /* 0x3d */ \ + HANDLE_OPCODE(WASM_OP_I64_STORE32), /* 0x3e */ \ + HANDLE_OPCODE(WASM_OP_MEMORY_SIZE), /* 0x3f */ \ + HANDLE_OPCODE(WASM_OP_MEMORY_GROW), /* 0x40 */ \ + HANDLE_OPCODE(WASM_OP_I32_CONST), /* 0x41 */ \ + HANDLE_OPCODE(WASM_OP_I64_CONST), /* 0x42 */ \ + HANDLE_OPCODE(WASM_OP_F32_CONST), /* 0x43 */ \ + HANDLE_OPCODE(WASM_OP_F64_CONST), /* 0x44 */ \ + HANDLE_OPCODE(WASM_OP_I32_EQZ), /* 0x45 */ \ + HANDLE_OPCODE(WASM_OP_I32_EQ), /* 0x46 */ \ + HANDLE_OPCODE(WASM_OP_I32_NE), /* 0x47 */ \ + HANDLE_OPCODE(WASM_OP_I32_LT_S), /* 0x48 */ \ + HANDLE_OPCODE(WASM_OP_I32_LT_U), /* 0x49 */ \ + HANDLE_OPCODE(WASM_OP_I32_GT_S), /* 0x4a */ \ + HANDLE_OPCODE(WASM_OP_I32_GT_U), /* 0x4b */ \ + HANDLE_OPCODE(WASM_OP_I32_LE_S), /* 0x4c */ \ + HANDLE_OPCODE(WASM_OP_I32_LE_U), /* 0x4d */ \ + HANDLE_OPCODE(WASM_OP_I32_GE_S), /* 0x4e */ \ + HANDLE_OPCODE(WASM_OP_I32_GE_U), /* 0x4f */ \ + HANDLE_OPCODE(WASM_OP_I64_EQZ), /* 0x50 */ \ + HANDLE_OPCODE(WASM_OP_I64_EQ), /* 0x51 */ \ + HANDLE_OPCODE(WASM_OP_I64_NE), /* 0x52 */ \ + HANDLE_OPCODE(WASM_OP_I64_LT_S), /* 0x53 */ \ + HANDLE_OPCODE(WASM_OP_I64_LT_U), /* 0x54 */ \ + HANDLE_OPCODE(WASM_OP_I64_GT_S), /* 0x55 */ \ + HANDLE_OPCODE(WASM_OP_I64_GT_U), /* 0x56 */ \ + HANDLE_OPCODE(WASM_OP_I64_LE_S), /* 0x57 */ \ + HANDLE_OPCODE(WASM_OP_I64_LE_U), /* 0x58 */ \ + HANDLE_OPCODE(WASM_OP_I64_GE_S), /* 0x59 */ \ + HANDLE_OPCODE(WASM_OP_I64_GE_U), /* 0x5a */ \ + HANDLE_OPCODE(WASM_OP_F32_EQ), /* 0x5b */ \ + HANDLE_OPCODE(WASM_OP_F32_NE), /* 0x5c */ \ + HANDLE_OPCODE(WASM_OP_F32_LT), /* 0x5d */ \ + HANDLE_OPCODE(WASM_OP_F32_GT), /* 0x5e */ \ + HANDLE_OPCODE(WASM_OP_F32_LE), /* 0x5f */ \ + HANDLE_OPCODE(WASM_OP_F32_GE), /* 0x60 */ \ + HANDLE_OPCODE(WASM_OP_F64_EQ), /* 0x61 */ \ + HANDLE_OPCODE(WASM_OP_F64_NE), /* 0x62 */ \ + HANDLE_OPCODE(WASM_OP_F64_LT), /* 0x63 */ \ + HANDLE_OPCODE(WASM_OP_F64_GT), /* 0x64 */ \ + HANDLE_OPCODE(WASM_OP_F64_LE), /* 0x65 */ \ + HANDLE_OPCODE(WASM_OP_F64_GE), /* 0x66 */ \ + HANDLE_OPCODE(WASM_OP_I32_CLZ), /* 0x67 */ \ + HANDLE_OPCODE(WASM_OP_I32_CTZ), /* 0x68 */ \ + HANDLE_OPCODE(WASM_OP_I32_POPCNT), /* 0x69 */ \ + HANDLE_OPCODE(WASM_OP_I32_ADD), /* 0x6a */ \ + HANDLE_OPCODE(WASM_OP_I32_SUB), /* 0x6b */ \ + HANDLE_OPCODE(WASM_OP_I32_MUL), /* 0x6c */ \ + HANDLE_OPCODE(WASM_OP_I32_DIV_S), /* 0x6d */ \ + HANDLE_OPCODE(WASM_OP_I32_DIV_U), /* 0x6e */ \ + HANDLE_OPCODE(WASM_OP_I32_REM_S), /* 0x6f */ \ + HANDLE_OPCODE(WASM_OP_I32_REM_U), /* 0x70 */ \ + HANDLE_OPCODE(WASM_OP_I32_AND), /* 0x71 */ \ + HANDLE_OPCODE(WASM_OP_I32_OR), /* 0x72 */ \ + HANDLE_OPCODE(WASM_OP_I32_XOR), /* 0x73 */ \ + HANDLE_OPCODE(WASM_OP_I32_SHL), /* 0x74 */ \ + HANDLE_OPCODE(WASM_OP_I32_SHR_S), /* 0x75 */ \ + HANDLE_OPCODE(WASM_OP_I32_SHR_U), /* 0x76 */ \ + HANDLE_OPCODE(WASM_OP_I32_ROTL), /* 0x77 */ \ + HANDLE_OPCODE(WASM_OP_I32_ROTR), /* 0x78 */ \ + HANDLE_OPCODE(WASM_OP_I64_CLZ), /* 0x79 */ \ + HANDLE_OPCODE(WASM_OP_I64_CTZ), /* 0x7a */ \ + HANDLE_OPCODE(WASM_OP_I64_POPCNT), /* 0x7b */ \ + HANDLE_OPCODE(WASM_OP_I64_ADD), /* 0x7c */ \ + HANDLE_OPCODE(WASM_OP_I64_SUB), /* 0x7d */ \ + HANDLE_OPCODE(WASM_OP_I64_MUL), /* 0x7e */ \ + HANDLE_OPCODE(WASM_OP_I64_DIV_S), /* 0x7f */ \ + HANDLE_OPCODE(WASM_OP_I64_DIV_U), /* 0x80 */ \ + HANDLE_OPCODE(WASM_OP_I64_REM_S), /* 0x81 */ \ + HANDLE_OPCODE(WASM_OP_I64_REM_U), /* 0x82 */ \ + HANDLE_OPCODE(WASM_OP_I64_AND), /* 0x83 */ \ + HANDLE_OPCODE(WASM_OP_I64_OR), /* 0x84 */ \ + HANDLE_OPCODE(WASM_OP_I64_XOR), /* 0x85 */ \ + HANDLE_OPCODE(WASM_OP_I64_SHL), /* 0x86 */ \ + HANDLE_OPCODE(WASM_OP_I64_SHR_S), /* 0x87 */ \ + HANDLE_OPCODE(WASM_OP_I64_SHR_U), /* 0x88 */ \ + HANDLE_OPCODE(WASM_OP_I64_ROTL), /* 0x89 */ \ + HANDLE_OPCODE(WASM_OP_I64_ROTR), /* 0x8a */ \ + HANDLE_OPCODE(WASM_OP_F32_ABS), /* 0x8b */ \ + HANDLE_OPCODE(WASM_OP_F32_NEG), /* 0x8c */ \ + HANDLE_OPCODE(WASM_OP_F32_CEIL), /* 0x8d */ \ + HANDLE_OPCODE(WASM_OP_F32_FLOOR), /* 0x8e */ \ + HANDLE_OPCODE(WASM_OP_F32_TRUNC), /* 0x8f */ \ + HANDLE_OPCODE(WASM_OP_F32_NEAREST), /* 0x90 */ \ + HANDLE_OPCODE(WASM_OP_F32_SQRT), /* 0x91 */ \ + HANDLE_OPCODE(WASM_OP_F32_ADD), /* 0x92 */ \ + HANDLE_OPCODE(WASM_OP_F32_SUB), /* 0x93 */ \ + HANDLE_OPCODE(WASM_OP_F32_MUL), /* 0x94 */ \ + HANDLE_OPCODE(WASM_OP_F32_DIV), /* 0x95 */ \ + HANDLE_OPCODE(WASM_OP_F32_MIN), /* 0x96 */ \ + HANDLE_OPCODE(WASM_OP_F32_MAX), /* 0x97 */ \ + HANDLE_OPCODE(WASM_OP_F32_COPYSIGN), /* 0x98 */ \ + HANDLE_OPCODE(WASM_OP_F64_ABS), /* 0x99 */ \ + HANDLE_OPCODE(WASM_OP_F64_NEG), /* 0x9a */ \ + HANDLE_OPCODE(WASM_OP_F64_CEIL), /* 0x9b */ \ + HANDLE_OPCODE(WASM_OP_F64_FLOOR), /* 0x9c */ \ + HANDLE_OPCODE(WASM_OP_F64_TRUNC), /* 0x9d */ \ + HANDLE_OPCODE(WASM_OP_F64_NEAREST), /* 0x9e */ \ + HANDLE_OPCODE(WASM_OP_F64_SQRT), /* 0x9f */ \ + HANDLE_OPCODE(WASM_OP_F64_ADD), /* 0xa0 */ \ + HANDLE_OPCODE(WASM_OP_F64_SUB), /* 0xa1 */ \ + HANDLE_OPCODE(WASM_OP_F64_MUL), /* 0xa2 */ \ + HANDLE_OPCODE(WASM_OP_F64_DIV), /* 0xa3 */ \ + HANDLE_OPCODE(WASM_OP_F64_MIN), /* 0xa4 */ \ + HANDLE_OPCODE(WASM_OP_F64_MAX), /* 0xa5 */ \ + HANDLE_OPCODE(WASM_OP_F64_COPYSIGN), /* 0xa6 */ \ + HANDLE_OPCODE(WASM_OP_I32_WRAP_I64), /* 0xa7 */ \ + HANDLE_OPCODE(WASM_OP_I32_TRUNC_S_F32), /* 0xa8 */ \ + HANDLE_OPCODE(WASM_OP_I32_TRUNC_U_F32), /* 0xa9 */ \ + HANDLE_OPCODE(WASM_OP_I32_TRUNC_S_F64), /* 0xaa */ \ + HANDLE_OPCODE(WASM_OP_I32_TRUNC_U_F64), /* 0xab */ \ + HANDLE_OPCODE(WASM_OP_I64_EXTEND_S_I32), /* 0xac */ \ + HANDLE_OPCODE(WASM_OP_I64_EXTEND_U_I32), /* 0xad */ \ + HANDLE_OPCODE(WASM_OP_I64_TRUNC_S_F32), /* 0xae */ \ + HANDLE_OPCODE(WASM_OP_I64_TRUNC_U_F32), /* 0xaf */ \ + HANDLE_OPCODE(WASM_OP_I64_TRUNC_S_F64), /* 0xb0 */ \ + HANDLE_OPCODE(WASM_OP_I64_TRUNC_U_F64), /* 0xb1 */ \ + HANDLE_OPCODE(WASM_OP_F32_CONVERT_S_I32), /* 0xb2 */ \ + HANDLE_OPCODE(WASM_OP_F32_CONVERT_U_I32), /* 0xb3 */ \ + HANDLE_OPCODE(WASM_OP_F32_CONVERT_S_I64), /* 0xb4 */ \ + HANDLE_OPCODE(WASM_OP_F32_CONVERT_U_I64), /* 0xb5 */ \ + HANDLE_OPCODE(WASM_OP_F32_DEMOTE_F64), /* 0xb6 */ \ + HANDLE_OPCODE(WASM_OP_F64_CONVERT_S_I32), /* 0xb7 */ \ + HANDLE_OPCODE(WASM_OP_F64_CONVERT_U_I32), /* 0xb8 */ \ + HANDLE_OPCODE(WASM_OP_F64_CONVERT_S_I64), /* 0xb9 */ \ + HANDLE_OPCODE(WASM_OP_F64_CONVERT_U_I64), /* 0xba */ \ + HANDLE_OPCODE(WASM_OP_F64_PROMOTE_F32), /* 0xbb */ \ + HANDLE_OPCODE(WASM_OP_I32_REINTERPRET_F32), /* 0xbc */ \ + HANDLE_OPCODE(WASM_OP_I64_REINTERPRET_F64), /* 0xbd */ \ + HANDLE_OPCODE(WASM_OP_F32_REINTERPRET_I32), /* 0xbe */ \ + HANDLE_OPCODE(WASM_OP_F64_REINTERPRET_I64), /* 0xbf */ \ + HANDLE_OPCODE(WASM_OP_I32_EXTEND8_S), /* 0xc0 */ \ + HANDLE_OPCODE(WASM_OP_I32_EXTEND16_S), /* 0xc1 */ \ + HANDLE_OPCODE(WASM_OP_I64_EXTEND8_S), /* 0xc2 */ \ + HANDLE_OPCODE(WASM_OP_I64_EXTEND16_S), /* 0xc3 */ \ + HANDLE_OPCODE(WASM_OP_I64_EXTEND32_S), /* 0xc4 */ \ + HANDLE_OPCODE(WASM_OP_DROP_64), /* 0xc5 */ \ + HANDLE_OPCODE(WASM_OP_SELECT_64), /* 0xc6 */ \ + HANDLE_OPCODE(EXT_OP_GET_LOCAL_FAST), /* 0xc7 */ \ + HANDLE_OPCODE(EXT_OP_SET_LOCAL_FAST_I64), /* 0xc8 */ \ + HANDLE_OPCODE(EXT_OP_SET_LOCAL_FAST), /* 0xc9 */ \ + HANDLE_OPCODE(EXT_OP_TEE_LOCAL_FAST), /* 0xca */ \ + HANDLE_OPCODE(EXT_OP_TEE_LOCAL_FAST_I64), /* 0xcb */ \ + HANDLE_OPCODE(EXT_OP_COPY_STACK_TOP), /* 0xcc */ \ + HANDLE_OPCODE(EXT_OP_COPY_STACK_TOP_I64), /* 0xcd */ \ + HANDLE_OPCODE(EXT_OP_COPY_STACK_VALUES), /* 0xce */ \ + HANDLE_OPCODE(WASM_OP_IMPDEP), /* 0xcf */ \ + HANDLE_OPCODE(WASM_OP_REF_NULL), /* 0xd0 */ \ + HANDLE_OPCODE(WASM_OP_REF_IS_NULL), /* 0xd1 */ \ + HANDLE_OPCODE(WASM_OP_REF_FUNC), /* 0xd2 */ \ + HANDLE_OPCODE(EXT_OP_BLOCK), /* 0xd3 */ \ + HANDLE_OPCODE(EXT_OP_LOOP), /* 0xd4 */ \ + HANDLE_OPCODE(EXT_OP_IF), /* 0xd5 */ \ + }; \ + do { \ + _name[WASM_OP_MISC_PREFIX] = \ + HANDLE_OPCODE(WASM_OP_MISC_PREFIX); /* 0xfc */ \ + _name[WASM_OP_ATOMIC_PREFIX] = \ + HANDLE_OPCODE(WASM_OP_ATOMIC_PREFIX); /* 0xfe */ \ + DEF_DEBUG_BREAK_HANDLE(_name) \ + } while (0) +#ifdef __cplusplus +} +#endif + +#endif /* end of _WASM_OPCODE_H */ diff --git a/core/iwasm/interpreter/wasm_runtime.c b/core/iwasm/interpreter/wasm_runtime.c index e219ccf2..372d572f 100644 --- a/core/iwasm/interpreter/wasm_runtime.c +++ b/core/iwasm/interpreter/wasm_runtime.c @@ -30,8 +30,7 @@ set_error_buf(char *error_buf, uint32 error_buf_size, const char *string) } static void -set_error_buf_v(char *error_buf, uint32 error_buf_size, - const char *format, ...) +set_error_buf_v(char *error_buf, uint32 error_buf_size, const char *format, ...) { va_list args; char buf[128]; @@ -45,19 +44,18 @@ set_error_buf_v(char *error_buf, uint32 error_buf_size, } } -WASMModule* -wasm_load(const uint8 *buf, uint32 size, - char *error_buf, uint32 error_buf_size) +WASMModule * +wasm_load(const uint8 *buf, uint32 size, char *error_buf, uint32 error_buf_size) { return wasm_loader_load(buf, size, error_buf, error_buf_size); } -WASMModule* -wasm_load_from_sections(WASMSection *section_list, - char *error_buf, uint32_t error_buf_size) +WASMModule * +wasm_load_from_sections(WASMSection *section_list, char *error_buf, + uint32_t error_buf_size) { - return wasm_loader_load_from_sections(section_list, - error_buf, error_buf_size); + return wasm_loader_load_from_sections(section_list, error_buf, + error_buf_size); } void @@ -71,10 +69,8 @@ runtime_malloc(uint64 size, char *error_buf, uint32 error_buf_size) { void *mem; - if (size >= UINT32_MAX - || !(mem = wasm_runtime_malloc((uint32)size))) { - set_error_buf(error_buf, error_buf_size, - "allocate memory failed"); + if (size >= UINT32_MAX || !(mem = wasm_runtime_malloc((uint32)size))) { + set_error_buf(error_buf, error_buf_size, "allocate memory failed"); return NULL; } @@ -102,8 +98,7 @@ get_sub_module_inst(const WASMModuleInstance *parent_module_inst, */ static void memories_deinstantiate(WASMModuleInstance *module_inst, - WASMMemoryInstance **memories, - uint32 count) + WASMMemoryInstance **memories, uint32 count) { uint32 i; if (memories) { @@ -115,9 +110,8 @@ memories_deinstantiate(WASMModuleInstance *module_inst, #endif #if WASM_ENABLE_SHARED_MEMORY != 0 if (memories[i]->is_shared) { - int32 ref_count = - shared_memory_dec_reference( - (WASMModuleCommon *)module_inst->module); + int32 ref_count = shared_memory_dec_reference( + (WASMModuleCommon *)module_inst->module); bh_assert(ref_count >= 0); /* if the reference count is not zero, @@ -138,16 +132,15 @@ memories_deinstantiate(WASMModuleInstance *module_inst, } } wasm_runtime_free(memories); - } - (void)module_inst; + } + (void)module_inst; } -static WASMMemoryInstance* -memory_instantiate(WASMModuleInstance *module_inst, - uint32 num_bytes_per_page, +static WASMMemoryInstance * +memory_instantiate(WASMModuleInstance *module_inst, uint32 num_bytes_per_page, uint32 init_page_count, uint32 max_page_count, - uint32 heap_size, uint32 flags, - char *error_buf, uint32 error_buf_size) + uint32 heap_size, uint32 flags, char *error_buf, + uint32 error_buf_size) { WASMModule *module = module_inst->module; WASMMemoryInstance *memory; @@ -162,15 +155,14 @@ memory_instantiate(WASMModuleInstance *module_inst, /* shared memory */ if (is_shared_memory) { - WASMSharedMemNode *node = - wasm_module_get_shared_memory( - (WASMModuleCommon *)module_inst->module); + WASMSharedMemNode *node = wasm_module_get_shared_memory( + (WASMModuleCommon *)module_inst->module); /* If the memory of this module has been instantiated, return the memory instance directly */ if (node) { uint32 ref_count; ref_count = shared_memory_inc_reference( - (WASMModuleCommon *)module_inst->module); + (WASMModuleCommon *)module_inst->module); bh_assert(ref_count > 0); memory = (WASMMemoryInstance *)shared_memory_get_memory_inst(node); bh_assert(memory); @@ -181,8 +173,7 @@ memory_instantiate(WASMModuleInstance *module_inst, } #endif /* end of WASM_ENABLE_SHARED_MEMORY */ - if (heap_size > 0 - && module_inst->module->malloc_function != (uint32)-1 + if (heap_size > 0 && module_inst->module->malloc_function != (uint32)-1 && module_inst->module->free_function != (uint32)-1) { /* Disable app heap, use malloc/free function exported by wasm app to allocate/free memory instead */ @@ -203,16 +194,16 @@ memory_instantiate(WASMModuleInstance *module_inst, } else if (heap_size > 0) { if (module->aux_heap_base_global_index != (uint32)-1 - && module->aux_heap_base < num_bytes_per_page - * init_page_count) { + && module->aux_heap_base < num_bytes_per_page * init_page_count) { /* Insert app heap before __heap_base */ aux_heap_base = module->aux_heap_base; bytes_of_last_page = aux_heap_base % num_bytes_per_page; if (bytes_of_last_page == 0) bytes_of_last_page = num_bytes_per_page; bytes_to_page_end = num_bytes_per_page - bytes_of_last_page; - inc_page_count = (heap_size - bytes_to_page_end - + num_bytes_per_page - 1) / num_bytes_per_page; + inc_page_count = + (heap_size - bytes_to_page_end + num_bytes_per_page - 1) + / num_bytes_per_page; heap_offset = aux_heap_base; aux_heap_base += heap_size; @@ -227,15 +218,15 @@ memory_instantiate(WASMModuleInstance *module_inst, /* Adjust __heap_base global value */ global_idx = module->aux_heap_base_global_index; - global_addr = module_inst->global_data + - module_inst->globals[global_idx].data_offset; + global_addr = module_inst->global_data + + module_inst->globals[global_idx].data_offset; *(uint32 *)global_addr = aux_heap_base; LOG_VERBOSE("Reset __heap_base global to %u", aux_heap_base); } else { /* Insert app heap before new page */ - inc_page_count = (heap_size + num_bytes_per_page - 1) - / num_bytes_per_page; + inc_page_count = + (heap_size + num_bytes_per_page - 1) / num_bytes_per_page; heap_offset = num_bytes_per_page * init_page_count; heap_size = num_bytes_per_page * inc_page_count; if (heap_size > 0) @@ -266,15 +257,14 @@ memory_instantiate(WASMModuleInstance *module_inst, #endif /* Allocate memory space, addr data and global data */ - if (!(memory = runtime_malloc((uint64)sizeof(WASMMemoryInstance), - error_buf, error_buf_size))) { + if (!(memory = runtime_malloc((uint64)sizeof(WASMMemoryInstance), error_buf, + error_buf_size))) { return NULL; } if (memory_data_size > 0 && !(memory->memory_data = - runtime_malloc(memory_data_size, - error_buf, error_buf_size))) { + runtime_malloc(memory_data_size, error_buf, error_buf_size))) { goto fail1; } @@ -291,13 +281,13 @@ memory_instantiate(WASMModuleInstance *module_inst, if (heap_size > 0) { uint32 heap_struct_size = mem_allocator_get_heap_struct_size(); - if (!(memory->heap_handle = runtime_malloc((uint64)heap_struct_size, - error_buf, error_buf_size))) { + if (!(memory->heap_handle = runtime_malloc( + (uint64)heap_struct_size, error_buf, error_buf_size))) { goto fail2; } - if (!mem_allocator_create_with_struct_and_pool - (memory->heap_handle, heap_struct_size, - memory->heap_data, heap_size)) { + if (!mem_allocator_create_with_struct_and_pool( + memory->heap_handle, heap_struct_size, memory->heap_data, + heap_size)) { set_error_buf(error_buf, error_buf_size, "init app heap failed"); goto fail3; } @@ -313,8 +303,7 @@ memory_instantiate(WASMModuleInstance *module_inst, if (!shared_memory_set_memory_inst( (WASMModuleCommon *)module_inst->module, (WASMMemoryInstanceCommon *)memory)) { - set_error_buf(error_buf, error_buf_size, - "allocate memory failed"); + set_error_buf(error_buf, error_buf_size, "allocate memory failed"); goto fail5; } } @@ -343,20 +332,18 @@ fail1: * Instantiate memories in a module. */ static WASMMemoryInstance ** -memories_instantiate(const WASMModule *module, - WASMModuleInstance *module_inst, +memories_instantiate(const WASMModule *module, WASMModuleInstance *module_inst, uint32 heap_size, char *error_buf, uint32 error_buf_size) { WASMImport *import; - uint32 mem_index = 0, i, memory_count = - module->import_memory_count + module->memory_count; + uint32 mem_index = 0, i, + memory_count = module->import_memory_count + module->memory_count; uint64 total_size; WASMMemoryInstance **memories, *memory; - total_size = sizeof(WASMMemoryInstance*) * (uint64)memory_count; + total_size = sizeof(WASMMemoryInstance *) * (uint64)memory_count; - if (!(memories = runtime_malloc(total_size, - error_buf, error_buf_size))) { + if (!(memories = runtime_malloc(total_size, error_buf, error_buf_size))) { return NULL; } @@ -374,14 +361,14 @@ memories_instantiate(const WASMModule *module, WASMModuleInstance *module_inst_linked; if (!(module_inst_linked = get_sub_module_inst( - module_inst, import->u.memory.import_module))) { + module_inst, import->u.memory.import_module))) { set_error_buf(error_buf, error_buf_size, "unknown memory"); memories_deinstantiate(module_inst, memories, memory_count); return NULL; } if (!(memory = memories[mem_index++] = wasm_lookup_memory( - module_inst_linked, import->u.memory.field_name))) { + module_inst_linked, import->u.memory.field_name))) { set_error_buf(error_buf, error_buf_size, "unknown memory"); memories_deinstantiate(module_inst, memories, memory_count); return NULL; @@ -391,9 +378,9 @@ memories_instantiate(const WASMModule *module, #endif { if (!(memory = memories[mem_index++] = memory_instantiate( - module_inst, num_bytes_per_page, init_page_count, - max_page_count, actual_heap_size, flags, - error_buf, error_buf_size))) { + module_inst, num_bytes_per_page, init_page_count, + max_page_count, actual_heap_size, flags, error_buf, + error_buf_size))) { memories_deinstantiate(module_inst, memories, memory_count); return NULL; } @@ -409,13 +396,11 @@ memories_instantiate(const WASMModule *module, /* instantiate memories from memory section */ for (i = 0; i < module->memory_count; i++) { - if (!(memory = memories[mem_index++] = - memory_instantiate(module_inst, - module->memories[i].num_bytes_per_page, - module->memories[i].init_page_count, - module->memories[i].max_page_count, - heap_size, module->memories[i].flags, - error_buf, error_buf_size))) { + if (!(memory = memories[mem_index++] = memory_instantiate( + module_inst, module->memories[i].num_bytes_per_page, + module->memories[i].init_page_count, + module->memories[i].max_page_count, heap_size, + module->memories[i].flags, error_buf, error_buf_size))) { memories_deinstantiate(module_inst, memories, memory_count); return NULL; } @@ -430,8 +415,8 @@ memories_instantiate(const WASMModule *module, * for wasm code */ if (!(memory = memories[mem_index++] = - memory_instantiate(module_inst, 0, 0, 0, heap_size, 0, - error_buf, error_buf_size))) { + memory_instantiate(module_inst, 0, 0, 0, heap_size, 0, + error_buf, error_buf_size))) { memories_deinstantiate(module_inst, memories, memory_count); return NULL; } @@ -461,18 +446,16 @@ tables_deinstantiate(WASMTableInstance **tables, uint32 count) * Instantiate tables in a module. */ static WASMTableInstance ** -tables_instantiate(const WASMModule *module, - WASMModuleInstance *module_inst, +tables_instantiate(const WASMModule *module, WASMModuleInstance *module_inst, char *error_buf, uint32 error_buf_size) { WASMImport *import; - uint32 table_index = 0, i, table_count = - module->import_table_count + module->table_count; - uint64 total_size = sizeof(WASMTableInstance*) * (uint64)table_count; + uint32 table_index = 0, i, + table_count = module->import_table_count + module->table_count; + uint64 total_size = sizeof(WASMTableInstance *) * (uint64)table_count; WASMTableInstance **tables, *table; - if (!(tables = runtime_malloc(total_size, - error_buf, error_buf_size))) { + if (!(tables = runtime_malloc(total_size, error_buf, error_buf_size))) { return NULL; } @@ -485,15 +468,15 @@ tables_instantiate(const WASMModule *module, WASMModuleInstance *module_inst_linked = NULL; if (import->u.table.import_module) { - if (!(module_inst_linked = - get_sub_module_inst(module_inst, import->u.table.import_module))) { + if (!(module_inst_linked = get_sub_module_inst( + module_inst, import->u.table.import_module))) { set_error_buf(error_buf, error_buf_size, "unknown table"); tables_deinstantiate(tables, table_count); return NULL; } - if (!(table_inst_linked = wasm_lookup_table(module_inst_linked, - import->u.table.field_name))) { + if (!(table_inst_linked = wasm_lookup_table( + module_inst_linked, import->u.table.field_name))) { set_error_buf(error_buf, error_buf_size, "unknown table"); tables_deinstantiate(tables, table_count); return NULL; @@ -506,16 +489,16 @@ tables_instantiate(const WASMModule *module, { /* in order to save memory, alloc resource as few as possible */ max_size_fixed = import->u.table.possible_grow - ? import->u.table.max_size - : import->u.table.init_size; + ? import->u.table.max_size + : import->u.table.init_size; /* it is a built-in table, every module has its own */ total_size = offsetof(WASMTableInstance, base_addr); total_size += (uint64)max_size_fixed * sizeof(uint32); } - if (!(table = tables[table_index++] = runtime_malloc - (total_size, error_buf, error_buf_size))) { + if (!(table = tables[table_index++] = + runtime_malloc(total_size, error_buf, error_buf_size))) { tables_deinstantiate(tables, table_count); return NULL; } @@ -548,15 +531,14 @@ tables_instantiate(const WASMModule *module, /* in case, a module which imports this table will grow it */ max_size_fixed = module->tables[i].max_size; #else - max_size_fixed = - module->tables[i].possible_grow - ? module->tables[i].max_size - : module->tables[i].init_size; + max_size_fixed = module->tables[i].possible_grow + ? module->tables[i].max_size + : module->tables[i].init_size; #endif total_size += sizeof(uint32) * (uint64)max_size_fixed; - if (!(table = tables[table_index++] = runtime_malloc - (total_size, error_buf, error_buf_size))) { + if (!(table = tables[table_index++] = + runtime_malloc(total_size, error_buf, error_buf_size))) { tables_deinstantiate(tables, table_count); return NULL; } @@ -591,18 +573,16 @@ functions_deinstantiate(WASMFunctionInstance *functions, uint32 count) * Instantiate functions in a module. */ static WASMFunctionInstance * -functions_instantiate(const WASMModule *module, - WASMModuleInstance *module_inst, +functions_instantiate(const WASMModule *module, WASMModuleInstance *module_inst, char *error_buf, uint32 error_buf_size) { WASMImport *import; - uint32 i, function_count = - module->import_function_count + module->function_count; + uint32 i, + function_count = module->import_function_count + module->function_count; uint64 total_size = sizeof(WASMFunctionInstance) * (uint64)function_count; WASMFunctionInstance *functions, *function; - if (!(functions = runtime_malloc(total_size, - error_buf, error_buf_size))) { + if (!(functions = runtime_malloc(total_size, error_buf, error_buf_size))) { return NULL; } @@ -614,23 +594,21 @@ functions_instantiate(const WASMModule *module, #if WASM_ENABLE_MULTI_MODULE != 0 if (import->u.function.import_module) { - function->import_module_inst = - get_sub_module_inst(module_inst, - import->u.function.import_module); + function->import_module_inst = get_sub_module_inst( + module_inst, import->u.function.import_module); if (function->import_module_inst) { function->import_func_inst = - wasm_lookup_function(function->import_module_inst, - import->u.function.field_name, NULL); + wasm_lookup_function(function->import_module_inst, + import->u.function.field_name, NULL); } } #endif /* WASM_ENABLE_MULTI_MODULE */ function->u.func_import = &import->u.function; - function->param_cell_num = - import->u.function.func_type->param_cell_num; + function->param_cell_num = import->u.function.func_type->param_cell_num; function->ret_cell_num = import->u.function.func_type->ret_cell_num; function->param_count = - (uint16)function->u.func_import->func_type->param_count; + (uint16)function->u.func_import->func_type->param_count; function->param_types = function->u.func_import->func_type->types; function->local_cell_num = 0; function->local_count = 0; @@ -648,7 +626,8 @@ functions_instantiate(const WASMModule *module, function->ret_cell_num = function->u.func->ret_cell_num; function->local_cell_num = function->u.func->local_cell_num; - function->param_count = (uint16)function->u.func->func_type->param_count; + function->param_count = + (uint16)function->u.func->func_type->param_count; function->local_count = (uint16)function->u.func->local_count; function->param_types = function->u.func->func_type->types; function->local_types = function->u.func->local_types; @@ -682,8 +661,8 @@ check_global_init_expr(const WASMModule *module, uint32 global_index, char *error_buf, uint32 error_buf_size) { if (global_index >= module->import_global_count + module->global_count) { - set_error_buf_v(error_buf, error_buf_size, - "unknown global %d", global_index); + set_error_buf_v(error_buf, error_buf_size, "unknown global %d", + global_index); return false; } @@ -708,20 +687,17 @@ check_global_init_expr(const WASMModule *module, uint32 global_index, * Instantiate globals in a module. */ static WASMGlobalInstance * -globals_instantiate(const WASMModule *module, - WASMModuleInstance *module_inst, +globals_instantiate(const WASMModule *module, WASMModuleInstance *module_inst, uint32 *p_global_data_size, char *error_buf, uint32 error_buf_size) { WASMImport *import; uint32 global_data_offset = 0; - uint32 i, global_count = - module->import_global_count + module->global_count; + uint32 i, global_count = module->import_global_count + module->global_count; uint64 total_size = sizeof(WASMGlobalInstance) * (uint64)global_count; WASMGlobalInstance *globals, *global; - if (!(globals = runtime_malloc(total_size, - error_buf, error_buf_size))) { + if (!(globals = runtime_malloc(total_size, error_buf, error_buf_size))) { return NULL; } @@ -735,13 +711,13 @@ globals_instantiate(const WASMModule *module, #if WASM_ENABLE_MULTI_MODULE != 0 if (global_import->import_module) { if (!(global->import_module_inst = get_sub_module_inst( - module_inst, global_import->import_module))) { + module_inst, global_import->import_module))) { set_error_buf(error_buf, error_buf_size, "unknown global"); return NULL; } if (!(global->import_global_inst = wasm_lookup_global( - global->import_module_inst, global_import->field_name))) { + global->import_module_inst, global_import->field_name))) { set_error_buf(error_buf, error_buf_size, "unknown global"); return NULL; } @@ -783,9 +759,9 @@ globals_instantiate(const WASMModule *module, } bh_memcpy_s( - &(global->initial_value), sizeof(WASMValue), - &(globals[init_expr->u.global_index].initial_value), - sizeof(globals[init_expr->u.global_index].initial_value)); + &(global->initial_value), sizeof(WASMValue), + &(globals[init_expr->u.global_index].initial_value), + sizeof(globals[init_expr->u.global_index].initial_value)); } #if WASM_ENABLE_REF_TYPES != 0 else if (init_expr->init_expr_type == INIT_EXPR_TYPE_REFNULL_CONST) { @@ -814,7 +790,7 @@ get_export_count(const WASMModule *module, uint8 kind) WASMExport *export = module->exports; uint32 count = 0, i; - for (i = 0; i < module->export_count; i++, export++) + for (i = 0; i < module->export_count; i++, export ++) if (export->kind == kind) count++; @@ -834,23 +810,24 @@ export_functions_deinstantiate(WASMExportFuncInstance *functions) /** * Instantiate export functions in a module. */ -static WASMExportFuncInstance* +static WASMExportFuncInstance * export_functions_instantiate(const WASMModule *module, WASMModuleInstance *module_inst, - uint32 export_func_count, - char *error_buf, uint32 error_buf_size) + uint32 export_func_count, char *error_buf, + uint32 error_buf_size) { WASMExportFuncInstance *export_funcs, *export_func; WASMExport *export = module->exports; uint32 i; - uint64 total_size = sizeof(WASMExportFuncInstance) * (uint64)export_func_count; + uint64 total_size = + sizeof(WASMExportFuncInstance) * (uint64)export_func_count; - if (!(export_func = export_funcs = runtime_malloc - (total_size, error_buf, error_buf_size))) { + if (!(export_func = export_funcs = + runtime_malloc(total_size, error_buf, error_buf_size))) { return NULL; } - for (i = 0; i < module->export_count; i++, export++) + for (i = 0; i < module->export_count; i++, export ++) if (export->kind == EXPORT_KIND_FUNC) { export_func->name = export->name; export_func->function = &module_inst->functions[export->index]; @@ -871,21 +848,22 @@ export_globals_deinstantiate(WASMExportGlobInstance *globals) static WASMExportGlobInstance * export_globals_instantiate(const WASMModule *module, - WASMModuleInstance *module_inst, - uint32 export_glob_count, char *error_buf, - uint32 error_buf_size) + WASMModuleInstance *module_inst, + uint32 export_glob_count, char *error_buf, + uint32 error_buf_size) { WASMExportGlobInstance *export_globals, *export_global; WASMExport *export = module->exports; uint32 i; - uint64 total_size = sizeof(WASMExportGlobInstance) * (uint64)export_glob_count; + uint64 total_size = + sizeof(WASMExportGlobInstance) * (uint64)export_glob_count; - if (!(export_global = export_globals = runtime_malloc - (total_size, error_buf, error_buf_size))) { + if (!(export_global = export_globals = + runtime_malloc(total_size, error_buf, error_buf_size))) { return NULL; } - for (i = 0; i < module->export_count; i++, export++) + for (i = 0; i < module->export_count; i++, export ++) if (export->kind == EXPORT_KIND_GLOBAL) { export_global->name = export->name; export_global->global = &module_inst->globals[export->index]; @@ -905,7 +883,8 @@ execute_post_inst_function(WASMModuleInstance *module_inst) uint32 i; for (i = 0; i < module_inst->export_func_count; i++) - if (!strcmp(module_inst->export_functions[i].name, "__post_instantiate")) { + if (!strcmp(module_inst->export_functions[i].name, + "__post_instantiate")) { post_inst_func = module_inst->export_functions[i].function; break; } @@ -933,7 +912,8 @@ execute_memory_init_function(WASMModuleInstance *module_inst) uint32 i; for (i = 0; i < module_inst->export_func_count; i++) - if (!strcmp(module_inst->export_functions[i].name, "__wasm_call_ctors")) { + if (!strcmp(module_inst->export_functions[i].name, + "__wasm_call_ctors")) { memory_init_func = module_inst->export_functions[i].function; break; } @@ -948,8 +928,7 @@ execute_memory_init_function(WASMModuleInstance *module_inst) /* Not a valid function type, ignore it */ return true; - return wasm_create_exec_env_and_call_function(module_inst, - memory_init_func, + return wasm_create_exec_env_and_call_function(module_inst, memory_init_func, 0, NULL); } #endif @@ -971,8 +950,8 @@ execute_start_function(WASMModuleInstance *module_inst) static bool execute_malloc_function(WASMModuleInstance *module_inst, WASMFunctionInstance *malloc_func, - WASMFunctionInstance *retain_func, - uint32 size, uint32 *p_result) + WASMFunctionInstance *retain_func, uint32 size, + uint32 *p_result) { uint32 argv[2], argc; bool ret; @@ -992,12 +971,12 @@ execute_malloc_function(WASMModuleInstance *module_inst, argc = 2; } - ret = wasm_create_exec_env_and_call_function - (module_inst, malloc_func, argc, argv); + ret = wasm_create_exec_env_and_call_function(module_inst, malloc_func, argc, + argv); if (retain_func && ret) { - ret = wasm_create_exec_env_and_call_function - (module_inst, retain_func, 1, argv); + ret = wasm_create_exec_env_and_call_function(module_inst, retain_func, + 1, argv); } if (ret) @@ -1007,40 +986,39 @@ execute_malloc_function(WASMModuleInstance *module_inst, static bool execute_free_function(WASMModuleInstance *module_inst, - WASMFunctionInstance *free_func, - uint32 offset) + WASMFunctionInstance *free_func, uint32 offset) { uint32 argv[2]; argv[0] = offset; - return wasm_create_exec_env_and_call_function - (module_inst, free_func, 1, argv); + return wasm_create_exec_env_and_call_function(module_inst, free_func, 1, + argv); } #if WASM_ENABLE_MULTI_MODULE != 0 static bool sub_module_instantiate(WASMModule *module, WASMModuleInstance *module_inst, - uint32 stack_size, uint32 heap_size, char *error_buf, - uint32 error_buf_size) + uint32 stack_size, uint32 heap_size, char *error_buf, + uint32 error_buf_size) { bh_list *sub_module_inst_list = module_inst->sub_module_inst_list; WASMRegisteredModule *sub_module_list_node = - bh_list_first_elem(module->import_module_list); + bh_list_first_elem(module->import_module_list); while (sub_module_list_node) { WASMSubModInstNode *sub_module_inst_list_node; - WASMModule *sub_module = (WASMModule*)sub_module_list_node->module; + WASMModule *sub_module = (WASMModule *)sub_module_list_node->module; WASMModuleInstance *sub_module_inst = - wasm_instantiate(sub_module, false, stack_size, heap_size, - error_buf, error_buf_size); + wasm_instantiate(sub_module, false, stack_size, heap_size, + error_buf, error_buf_size); if (!sub_module_inst) { LOG_DEBUG("instantiate %s failed", sub_module_list_node->module_name); return false; } - sub_module_inst_list_node = runtime_malloc - (sizeof(WASMSubModInstNode), error_buf, error_buf_size); + sub_module_inst_list_node = runtime_malloc(sizeof(WASMSubModInstNode), + error_buf, error_buf_size); if (!sub_module_inst_list_node) { LOG_DEBUG("Malloc WASMSubModInstNode failed, SZ:%d", sizeof(WASMSubModInstNode)); @@ -1050,9 +1028,9 @@ sub_module_instantiate(WASMModule *module, WASMModuleInstance *module_inst, sub_module_inst_list_node->module_inst = sub_module_inst; sub_module_inst_list_node->module_name = - sub_module_list_node->module_name; + sub_module_list_node->module_name; bh_list_status ret = - bh_list_insert(sub_module_inst_list, sub_module_inst_list_node); + bh_list_insert(sub_module_inst_list, sub_module_inst_list_node); bh_assert(BH_LIST_SUCCESS == ret); (void)ret; @@ -1086,7 +1064,7 @@ check_linked_symbol(WASMModuleInstance *module_inst, char *error_buf, for (i = 0; i < module->import_function_count; i++) { WASMFunctionImport *func = - &((module->import_functions + i)->u.function); + &((module->import_functions + i)->u.function); if (!func->func_ptr_linked #if WASM_ENABLE_MULTI_MODULE != 0 && !func->import_func_linked @@ -1131,10 +1109,9 @@ check_linked_symbol(WASMModuleInstance *module_inst, char *error_buf, /** * Instantiate module */ -WASMModuleInstance* -wasm_instantiate(WASMModule *module, bool is_sub_inst, - uint32 stack_size, uint32 heap_size, - char *error_buf, uint32 error_buf_size) +WASMModuleInstance * +wasm_instantiate(WASMModule *module, bool is_sub_inst, uint32 stack_size, + uint32 heap_size, char *error_buf, uint32 error_buf_size) { WASMModuleInstance *module_inst; WASMGlobalInstance *globals = NULL, *global; @@ -1154,16 +1131,15 @@ wasm_instantiate(WASMModule *module, bool is_sub_inst, heap_size = APP_HEAP_SIZE_MAX; /* Allocate the memory */ - if (!(module_inst = runtime_malloc(sizeof(WASMModuleInstance), - error_buf, error_buf_size))) { + if (!(module_inst = runtime_malloc(sizeof(WASMModuleInstance), error_buf, + error_buf_size))) { return NULL; } module_inst->module = module; #if WASM_ENABLE_MULTI_MODULE != 0 - module_inst->sub_module_inst_list = - &module_inst->sub_module_inst_list_head; + module_inst->sub_module_inst_list = &module_inst->sub_module_inst_list_head; ret = sub_module_instantiate(module, module_inst, stack_size, heap_size, error_buf, error_buf_size); if (!ret) { @@ -1182,9 +1158,9 @@ wasm_instantiate(WASMModule *module, bool is_sub_inst, /* Instantiate global firstly to get the mutable data size */ global_count = module->import_global_count + module->global_count; if (global_count - && !(globals = globals_instantiate(module, module_inst, - &global_data_size, - error_buf, error_buf_size))) { + && !(globals = + globals_instantiate(module, module_inst, &global_data_size, + error_buf, error_buf_size))) { goto fail; } module_inst->global_count = global_count; @@ -1192,8 +1168,7 @@ wasm_instantiate(WASMModule *module, bool is_sub_inst, module_inst->memory_count = module->import_memory_count + module->memory_count; - module_inst->table_count = - module->import_table_count + module->table_count; + module_inst->table_count = module->import_table_count + module->table_count; module_inst->function_count = module->import_function_count + module->function_count; @@ -1201,42 +1176,38 @@ wasm_instantiate(WASMModule *module, bool is_sub_inst, module_inst->export_func_count = get_export_count(module, EXPORT_KIND_FUNC); #if WASM_ENABLE_MULTI_MODULE != 0 module_inst->export_tab_count = get_export_count(module, EXPORT_KIND_TABLE); - module_inst->export_mem_count = get_export_count(module, EXPORT_KIND_MEMORY); - module_inst->export_glob_count = get_export_count(module, EXPORT_KIND_GLOBAL); + module_inst->export_mem_count = + get_export_count(module, EXPORT_KIND_MEMORY); + module_inst->export_glob_count = + get_export_count(module, EXPORT_KIND_GLOBAL); #endif if (global_count > 0) { - if (!(module_inst->global_data = runtime_malloc - (global_data_size, error_buf, error_buf_size))) { + if (!(module_inst->global_data = runtime_malloc( + global_data_size, error_buf, error_buf_size))) { goto fail; } } /* Instantiate memories/tables/functions */ if ((module_inst->memory_count > 0 - && !(module_inst->memories = - memories_instantiate(module, - module_inst, - heap_size, error_buf, error_buf_size))) + && !(module_inst->memories = memories_instantiate( + module, module_inst, heap_size, error_buf, error_buf_size))) || (module_inst->table_count > 0 - && !(module_inst->tables = - tables_instantiate(module, - module_inst, - error_buf, error_buf_size))) + && !(module_inst->tables = tables_instantiate( + module, module_inst, error_buf, error_buf_size))) || (module_inst->function_count > 0 - && !(module_inst->functions = - functions_instantiate(module, - module_inst, - error_buf, error_buf_size))) + && !(module_inst->functions = functions_instantiate( + module, module_inst, error_buf, error_buf_size))) || (module_inst->export_func_count > 0 && !(module_inst->export_functions = export_functions_instantiate( - module, module_inst, module_inst->export_func_count, - error_buf, error_buf_size))) + module, module_inst, module_inst->export_func_count, + error_buf, error_buf_size))) #if WASM_ENABLE_MULTI_MODULE != 0 || (module_inst->export_glob_count > 0 && !(module_inst->export_globals = export_globals_instantiate( - module, module_inst, module_inst->export_glob_count, - error_buf, error_buf_size))) + module, module_inst, module_inst->export_glob_count, + error_buf, error_buf_size))) #endif ) { goto fail; @@ -1255,12 +1226,13 @@ wasm_instantiate(WASMModule *module, bool is_sub_inst, case VALUE_TYPE_FUNCREF: case VALUE_TYPE_EXTERNREF: #endif - *(int32*)global_data = global->initial_value.i32; + *(int32 *)global_data = global->initial_value.i32; global_data += sizeof(int32); break; case VALUE_TYPE_I64: case VALUE_TYPE_F64: - bh_memcpy_s(global_data, (uint32)(global_data_end - global_data), + bh_memcpy_s(global_data, + (uint32)(global_data_end - global_data), &global->initial_value.i64, sizeof(int64)); global_data += sizeof(int64); break; @@ -1277,7 +1249,7 @@ wasm_instantiate(WASMModule *module, bool is_sub_inst, /* Initialize the memory data with data segment section */ module_inst->default_memory = - module_inst->memory_count ? module_inst->memories[0] : NULL; + module_inst->memory_count ? module_inst->memories[0] : NULL; for (i = 0; i < module->data_seg_count; i++) { WASMMemoryInstance *memory = NULL; @@ -1299,12 +1271,11 @@ wasm_instantiate(WASMModule *module, bool is_sub_inst, bh_assert(memory_data || memory_size == 0); bh_assert(data_seg->base_offset.init_expr_type - == INIT_EXPR_TYPE_I32_CONST + == INIT_EXPR_TYPE_I32_CONST || data_seg->base_offset.init_expr_type - == INIT_EXPR_TYPE_GET_GLOBAL); + == INIT_EXPR_TYPE_GET_GLOBAL); - if (data_seg->base_offset.init_expr_type - == INIT_EXPR_TYPE_GET_GLOBAL) { + if (data_seg->base_offset.init_expr_type == INIT_EXPR_TYPE_GET_GLOBAL) { if (!check_global_init_expr(module, data_seg->base_offset.u.global_index, error_buf, error_buf_size)) { @@ -1313,15 +1284,14 @@ wasm_instantiate(WASMModule *module, bool is_sub_inst, if (!globals || globals[data_seg->base_offset.u.global_index].type - != VALUE_TYPE_I32) { + != VALUE_TYPE_I32) { set_error_buf(error_buf, error_buf_size, "data segment does not fit"); goto fail; } data_seg->base_offset.u.i32 = - globals[data_seg->base_offset.u.global_index] - .initial_value.i32; + globals[data_seg->base_offset.u.global_index].initial_value.i32; } /* check offset */ @@ -1362,7 +1332,7 @@ wasm_instantiate(WASMModule *module, bool is_sub_inst, /* Initialize the table data with table segment section */ module_inst->default_table = - module_inst->table_count ? module_inst->tables[0] : NULL; + module_inst->table_count ? module_inst->tables[0] : NULL; /* in case there is no table */ for (i = 0; module_inst->table_count > 0 && i < module->table_seg_count; i++) { @@ -1383,8 +1353,8 @@ wasm_instantiate(WASMModule *module, bool is_sub_inst, uint32 *table_data = (uint32 *)table->base_addr; #if WASM_ENABLE_MULTI_MODULE != 0 table_data = table->table_inst_linked - ? (uint32 *)table->table_inst_linked->base_addr - : table_data; + ? (uint32 *)table->table_inst_linked->base_addr + : table_data; #endif bh_assert(table_data); @@ -1395,11 +1365,14 @@ wasm_instantiate(WASMModule *module, bool is_sub_inst, /* init vec(funcidx) or vec(expr) */ bh_assert( - table_seg->base_offset.init_expr_type == INIT_EXPR_TYPE_I32_CONST - || table_seg->base_offset.init_expr_type == INIT_EXPR_TYPE_GET_GLOBAL + table_seg->base_offset.init_expr_type == INIT_EXPR_TYPE_I32_CONST + || table_seg->base_offset.init_expr_type + == INIT_EXPR_TYPE_GET_GLOBAL #if WASM_ENABLE_REF_TYPES != 0 - || table_seg->base_offset.init_expr_type == INIT_EXPR_TYPE_FUNCREF_CONST - || table_seg->base_offset.init_expr_type == INIT_EXPR_TYPE_REFNULL_CONST + || table_seg->base_offset.init_expr_type + == INIT_EXPR_TYPE_FUNCREF_CONST + || table_seg->base_offset.init_expr_type + == INIT_EXPR_TYPE_REFNULL_CONST #endif ); @@ -1413,14 +1386,15 @@ wasm_instantiate(WASMModule *module, bool is_sub_inst, if (!globals || globals[table_seg->base_offset.u.global_index].type - != VALUE_TYPE_I32) { + != VALUE_TYPE_I32) { set_error_buf(error_buf, error_buf_size, "elements segment does not fit"); goto fail; } table_seg->base_offset.u.i32 = - globals[table_seg->base_offset.u.global_index].initial_value.i32; + globals[table_seg->base_offset.u.global_index] + .initial_value.i32; } /* check offset since length might negative */ @@ -1458,10 +1432,10 @@ wasm_instantiate(WASMModule *module, bool is_sub_inst, * so loader check is enough */ bh_memcpy_s( - table_data + table_seg->base_offset.u.i32, - (uint32)((table->cur_size - (uint32)table_seg->base_offset.u.i32) - * sizeof(uint32)), - table_seg->func_indexes, (uint32)(length * sizeof(uint32))); + table_data + table_seg->base_offset.u.i32, + (uint32)((table->cur_size - (uint32)table_seg->base_offset.u.i32) + * sizeof(uint32)), + table_seg->func_indexes, (uint32)(length * sizeof(uint32))); } /* module instance type */ @@ -1471,7 +1445,7 @@ wasm_instantiate(WASMModule *module, bool is_sub_inst, if (stack_size == 0) stack_size = DEFAULT_WASM_STACK_SIZE; #if WASM_ENABLE_SPEC_TEST != 0 - if (stack_size < 48 *1024) + if (stack_size < 48 * 1024) stack_size = 48 * 1024; #endif module_inst->default_wasm_stack_size = stack_size; @@ -1494,19 +1468,14 @@ wasm_instantiate(WASMModule *module, bool is_sub_inst, #if WASM_ENABLE_LIBC_WASI != 0 /* The sub-instance will get the wasi_ctx from main-instance */ if (!is_sub_inst) { - if (!wasm_runtime_init_wasi((WASMModuleInstanceCommon*)module_inst, - module->wasi_args.dir_list, - module->wasi_args.dir_count, - module->wasi_args.map_dir_list, - module->wasi_args.map_dir_count, - module->wasi_args.env, - module->wasi_args.env_count, - module->wasi_args.argv, - module->wasi_args.argc, - module->wasi_args.stdio[0], - module->wasi_args.stdio[1], - module->wasi_args.stdio[2], - error_buf, error_buf_size)) { + if (!wasm_runtime_init_wasi( + (WASMModuleInstanceCommon *)module_inst, + module->wasi_args.dir_list, module->wasi_args.dir_count, + module->wasi_args.map_dir_list, module->wasi_args.map_dir_count, + module->wasi_args.env, module->wasi_args.env_count, + module->wasi_args.argv, module->wasi_args.argc, + module->wasi_args.stdio[0], module->wasi_args.stdio[1], + module->wasi_args.stdio[2], error_buf, error_buf_size)) { goto fail; } } @@ -1522,8 +1491,7 @@ wasm_instantiate(WASMModule *module, bool is_sub_inst, /* Execute __post_instantiate function */ if (!execute_post_inst_function(module_inst) || !execute_start_function(module_inst)) { - set_error_buf(error_buf, error_buf_size, - module_inst->cur_exception); + set_error_buf(error_buf, error_buf_size, module_inst->cur_exception); goto fail; } @@ -1547,8 +1515,8 @@ wasm_instantiate(WASMModule *module, bool is_sub_inst, #endif #if WASM_ENABLE_MEMORY_TRACING != 0 - wasm_runtime_dump_module_inst_mem_consumption - ((WASMModuleInstanceCommon *)module_inst); + wasm_runtime_dump_module_inst_mem_consumption( + (WASMModuleInstanceCommon *)module_inst); #endif (void)global_data_end; return module_inst; @@ -1574,16 +1542,16 @@ wasm_deinstantiate(WASMModuleInstance *module_inst, bool is_sub_inst) which may allocated from global heap. */ /* Only destroy wasi ctx in the main module instance */ if (!is_sub_inst) - wasm_runtime_destroy_wasi((WASMModuleInstanceCommon*)module_inst); + wasm_runtime_destroy_wasi((WASMModuleInstanceCommon *)module_inst); #endif if (module_inst->memory_count > 0) - memories_deinstantiate( - module_inst, - module_inst->memories, module_inst->memory_count); + memories_deinstantiate(module_inst, module_inst->memories, + module_inst->memory_count); tables_deinstantiate(module_inst->tables, module_inst->table_count); - functions_deinstantiate(module_inst->functions, module_inst->function_count); + functions_deinstantiate(module_inst->functions, + module_inst->function_count); globals_deinstantiate(module_inst->globals); export_functions_deinstantiate(module_inst->export_functions); #if WASM_ENABLE_MULTI_MODULE != 0 @@ -1594,7 +1562,7 @@ wasm_deinstantiate(WASMModuleInstance *module_inst, bool is_sub_inst) wasm_runtime_free(module_inst->global_data); #if WASM_ENABLE_REF_TYPES != 0 - wasm_externref_cleanup((WASMModuleInstanceCommon*)module_inst); + wasm_externref_cleanup((WASMModuleInstanceCommon *)module_inst); #endif if (module_inst->exec_env_singleton) @@ -1611,9 +1579,9 @@ wasm_deinstantiate(WASMModuleInstance *module_inst, bool is_sub_inst) wasm_runtime_free(module_inst); } -WASMFunctionInstance* -wasm_lookup_function(const WASMModuleInstance *module_inst, - const char *name, const char *signature) +WASMFunctionInstance * +wasm_lookup_function(const WASMModuleInstance *module_inst, const char *name, + const char *signature) { uint32 i; for (i = 0; i < module_inst->export_func_count; i++) @@ -1640,7 +1608,7 @@ wasm_lookup_memory(const WASMModuleInstance *module_inst, const char *name) /** * using a strong assumption that one module instance only has * one memory instance - */ + */ (void)module_inst->export_memories; return module_inst->memories[0]; } @@ -1676,11 +1644,11 @@ clear_wasi_proc_exit_exception(WASMModuleInstance *module_inst) } bool -wasm_call_function(WASMExecEnv *exec_env, - WASMFunctionInstance *function, +wasm_call_function(WASMExecEnv *exec_env, WASMFunctionInstance *function, unsigned argc, uint32 argv[]) { - WASMModuleInstance *module_inst = (WASMModuleInstance*)exec_env->module_inst; + WASMModuleInstance *module_inst = + (WASMModuleInstance *)exec_env->module_inst; /* set thread handle and stack boundary */ wasm_exec_env_set_thread_info(exec_env); @@ -1701,13 +1669,12 @@ wasm_create_exec_env_and_call_function(WASMModuleInstance *module_inst, #if WASM_ENABLE_THREAD_MGR != 0 WASMExecEnv *existing_exec_env = NULL; - if (!(existing_exec_env = exec_env = - wasm_clusters_search_exec_env( - (WASMModuleInstanceCommon*)module_inst))) { + if (!(existing_exec_env = exec_env = wasm_clusters_search_exec_env( + (WASMModuleInstanceCommon *)module_inst))) { #endif - if (!(exec_env = wasm_exec_env_create( - (WASMModuleInstanceCommon*)module_inst, - module_inst->default_wasm_stack_size))) { + if (!(exec_env = + wasm_exec_env_create((WASMModuleInstanceCommon *)module_inst, + module_inst->default_wasm_stack_size))) { wasm_set_exception(module_inst, "allocate memory failed"); return false; } @@ -1748,18 +1715,16 @@ wasm_create_exec_env_singleton(WASMModuleInstance *module_inst) } void -wasm_set_exception(WASMModuleInstance *module_inst, - const char *exception) +wasm_set_exception(WASMModuleInstance *module_inst, const char *exception) { if (exception) - snprintf(module_inst->cur_exception, - sizeof(module_inst->cur_exception), + snprintf(module_inst->cur_exception, sizeof(module_inst->cur_exception), "Exception: %s", exception); else module_inst->cur_exception[0] = '\0'; } -const char* +const char * wasm_get_exception(WASMModuleInstance *module_inst) { if (module_inst->cur_exception[0] == '\0') @@ -1800,13 +1765,16 @@ wasm_dump_perf_profiling(const WASMModuleInstance *module_inst) } if (func_name) - os_printf(" func %s, execution time: %.3f ms, execution count: %d times\n", - func_name, module_inst->functions[i].total_exec_time / 1000.0f, - module_inst->functions[i].total_exec_cnt); + os_printf(" func %s, execution time: %.3f ms, execution count: %d " + "times\n", + func_name, + module_inst->functions[i].total_exec_time / 1000.0f, + module_inst->functions[i].total_exec_cnt); else - os_printf(" func %d, execution time: %.3f ms, execution count: %d times\n", - i, module_inst->functions[i].total_exec_time / 1000.0f, - module_inst->functions[i].total_exec_cnt); + os_printf(" func %d, execution time: %.3f ms, execution count: %d " + "times\n", + i, module_inst->functions[i].total_exec_time / 1000.0f, + module_inst->functions[i].total_exec_cnt); } } #endif @@ -1827,8 +1795,7 @@ wasm_module_malloc(WASMModuleInstance *module_inst, uint32 size, if (memory->heap_handle) { addr = mem_allocator_malloc(memory->heap_handle, size); } - else if (module_inst->malloc_function - && module_inst->free_function) { + else if (module_inst->malloc_function && module_inst->free_function) { #if WASM_ENABLE_DEBUG_INTERP != 0 /* TODO: obviously, we can not create debug instance for * module malloc here, so, just disable the engine here, @@ -1839,10 +1806,9 @@ wasm_module_malloc(WASMModuleInstance *module_inst, uint32 size, bool active = wasm_debug_get_engine_active(); wasm_debug_set_engine_active(false); #endif - if (!execute_malloc_function(module_inst, - module_inst->malloc_function, - module_inst->retain_function, - size, &offset)) { + if (!execute_malloc_function(module_inst, module_inst->malloc_function, + module_inst->retain_function, size, + &offset)) { #if WASM_ENABLE_DEBUG_INTERP != 0 wasm_debug_set_engine_active(active); #endif @@ -1917,7 +1883,7 @@ wasm_module_free(WASMModuleInstance *module_inst, uint32 ptr) { if (ptr) { WASMMemoryInstance *memory = module_inst->default_memory; - uint8* addr; + uint8 *addr; if (!memory) { return; @@ -1925,25 +1891,21 @@ wasm_module_free(WASMModuleInstance *module_inst, uint32 ptr) addr = memory->memory_data + ptr; - if (memory->heap_handle - && memory->heap_data <= addr + if (memory->heap_handle && memory->heap_data <= addr && addr < memory->heap_data_end) { mem_allocator_free(memory->heap_handle, addr); } - else if (module_inst->malloc_function - && module_inst->free_function + else if (module_inst->malloc_function && module_inst->free_function && memory->memory_data <= addr && addr < memory->memory_data_end) { #if WASM_ENABLE_DEBUG_INTERP != 0 - /*TODO: obviously, we can not create debug instance for module malloc here, - so, just disable the engine here, it is strange. the wasm's call should be - marshed to its own thread */ + /*TODO: obviously, we can not create debug instance for module + malloc here, so, just disable the engine here, it is strange. the + wasm's call should be marshed to its own thread */ bool active = wasm_debug_get_engine_active(); wasm_debug_set_engine_active(false); #endif - execute_free_function(module_inst, - module_inst->free_function, - ptr); + execute_free_function(module_inst, module_inst->free_function, ptr); #if WASM_ENABLE_DEBUG_INTERP != 0 wasm_debug_set_engine_active(active); #endif @@ -1952,12 +1914,12 @@ wasm_module_free(WASMModuleInstance *module_inst, uint32 ptr) } uint32 -wasm_module_dup_data(WASMModuleInstance *module_inst, - const char *src, uint32 size) +wasm_module_dup_data(WASMModuleInstance *module_inst, const char *src, + uint32 size) { char *buffer; - uint32 buffer_offset = wasm_module_malloc(module_inst, size, - (void**)&buffer); + uint32 buffer_offset = + wasm_module_malloc(module_inst, size, (void **)&buffer); if (buffer_offset != 0) { buffer = wasm_addr_app_to_native(module_inst, buffer_offset); bh_memcpy_s(buffer, size, src, size); @@ -1966,8 +1928,8 @@ wasm_module_dup_data(WASMModuleInstance *module_inst, } bool -wasm_validate_app_addr(WASMModuleInstance *module_inst, - uint32 app_offset, uint32 size) +wasm_validate_app_addr(WASMModuleInstance *module_inst, uint32 app_offset, + uint32 size) { WASMMemoryInstance *memory = module_inst->default_memory; uint32 memory_data_size; @@ -1992,8 +1954,8 @@ fail: } bool -wasm_validate_native_addr(WASMModuleInstance *module_inst, - void *native_ptr, uint32 size) +wasm_validate_native_addr(WASMModuleInstance *module_inst, void *native_ptr, + uint32 size) { WASMMemoryInstance *memory = module_inst->default_memory; uint8 *addr = (uint8 *)native_ptr; @@ -2007,8 +1969,7 @@ wasm_validate_native_addr(WASMModuleInstance *module_inst, goto fail; } - if (memory->memory_data <= addr - && addr + size <= memory->memory_data_end) { + if (memory->memory_data <= addr && addr + size <= memory->memory_data_end) { return true; } fail: @@ -2017,8 +1978,7 @@ fail: } void * -wasm_addr_app_to_native(WASMModuleInstance *module_inst, - uint32 app_offset) +wasm_addr_app_to_native(WASMModuleInstance *module_inst, uint32 app_offset) { WASMMemoryInstance *memory = module_inst->default_memory; uint8 *addr; @@ -2028,15 +1988,13 @@ wasm_addr_app_to_native(WASMModuleInstance *module_inst, addr = memory->memory_data + app_offset; - if (memory->memory_data <= addr - && addr < memory->memory_data_end) + if (memory->memory_data <= addr && addr < memory->memory_data_end) return addr; return NULL; } uint32 -wasm_addr_native_to_app(WASMModuleInstance *module_inst, - void *native_ptr) +wasm_addr_native_to_app(WASMModuleInstance *module_inst, void *native_ptr) { WASMMemoryInstance *memory = module_inst->default_memory; uint8 *addr = (uint8 *)native_ptr; @@ -2044,17 +2002,14 @@ wasm_addr_native_to_app(WASMModuleInstance *module_inst, if (!memory) return 0; - if (memory->memory_data <= addr - && addr < memory->memory_data_end) + if (memory->memory_data <= addr && addr < memory->memory_data_end) return (uint32)(addr - memory->memory_data); return 0; } bool -wasm_get_app_addr_range(WASMModuleInstance *module_inst, - uint32 app_offset, - uint32 *p_app_start_offset, - uint32 *p_app_end_offset) +wasm_get_app_addr_range(WASMModuleInstance *module_inst, uint32 app_offset, + uint32 *p_app_start_offset, uint32 *p_app_end_offset) { WASMMemoryInstance *memory = module_inst->default_memory; uint32 memory_data_size; @@ -2075,8 +2030,7 @@ wasm_get_app_addr_range(WASMModuleInstance *module_inst, } bool -wasm_get_native_addr_range(WASMModuleInstance *module_inst, - uint8 *native_ptr, +wasm_get_native_addr_range(WASMModuleInstance *module_inst, uint8 *native_ptr, uint8 **p_native_start_addr, uint8 **p_native_end_addr) { @@ -2086,8 +2040,7 @@ wasm_get_native_addr_range(WASMModuleInstance *module_inst, if (!memory) return false; - if (memory->memory_data <= addr - && addr < memory->memory_data_end) { + if (memory->memory_data <= addr && addr < memory->memory_data_end) { if (p_native_start_addr) *p_native_start_addr = memory->memory_data; if (p_native_end_addr) @@ -2137,25 +2090,27 @@ wasm_enlarge_memory(WASMModuleInstance *module, uint32 inc_page_count) } #endif - if (!(new_memory_data = wasm_runtime_realloc(memory_data, (uint32)total_size))) { + if (!(new_memory_data = + wasm_runtime_realloc(memory_data, (uint32)total_size))) { if (!(new_memory_data = wasm_runtime_malloc((uint32)total_size))) { return false; } if (memory_data) { - bh_memcpy_s(new_memory_data, (uint32)total_size, - memory_data, total_size_old); + bh_memcpy_s(new_memory_data, (uint32)total_size, memory_data, + total_size_old); wasm_runtime_free(memory_data); } } - memset(new_memory_data + total_size_old, - 0, (uint32)total_size - total_size_old); + memset(new_memory_data + total_size_old, 0, + (uint32)total_size - total_size_old); if (heap_size > 0) { if (mem_allocator_migrate(memory->heap_handle, (char *)heap_data_old - + (new_memory_data - memory_data), - heap_size) != 0) { + + (new_memory_data - memory_data), + heap_size) + != 0) { return false; } } @@ -2164,17 +2119,16 @@ wasm_enlarge_memory(WASMModuleInstance *module, uint32 inc_page_count) memory->cur_page_count = total_page_count; memory->heap_data = heap_data_old + (new_memory_data - memory_data); memory->heap_data_end = memory->heap_data + heap_size; - memory->memory_data_end = memory->memory_data - + memory->num_bytes_per_page - * total_page_count; + memory->memory_data_end = + memory->memory_data + memory->num_bytes_per_page * total_page_count; return true; } #if WASM_ENABLE_REF_TYPES != 0 bool -wasm_enlarge_table(WASMModuleInstance *module_inst, - uint32 table_idx, uint32 inc_entries, uint32 init_val) +wasm_enlarge_table(WASMModuleInstance *module_inst, uint32 table_idx, + uint32 inc_entries, uint32 init_val) { uint32 entry_count, *new_table_data_start, i; WASMTableInstance *table_inst; @@ -2200,8 +2154,8 @@ wasm_enlarge_table(WASMModuleInstance *module_inst, /* fill in */ new_table_data_start = - (uint32 *)((uint8 *)table_inst + offsetof(WASMTableInstance, base_addr)) - + table_inst->cur_size; + (uint32 *)((uint8 *)table_inst + offsetof(WASMTableInstance, base_addr)) + + table_inst->cur_size; for (i = 0; i < inc_entries; ++i) { new_table_data_start[i] = init_val; } @@ -2212,18 +2166,15 @@ wasm_enlarge_table(WASMModuleInstance *module_inst, #endif /* WASM_ENABLE_REF_TYPES != 0 */ bool -wasm_call_indirect(WASMExecEnv *exec_env, - uint32_t tbl_idx, - uint32_t element_indices, - uint32_t argc, uint32_t argv[]) +wasm_call_indirect(WASMExecEnv *exec_env, uint32_t tbl_idx, + uint32_t element_indices, uint32_t argc, uint32_t argv[]) { WASMModuleInstance *module_inst = NULL; WASMTableInstance *table_inst = NULL; uint32_t function_indices = 0; WASMFunctionInstance *function_inst = NULL; - module_inst = - (WASMModuleInstance*)exec_env->module_inst; + module_inst = (WASMModuleInstance *)exec_env->module_inst; bh_assert(module_inst); table_inst = module_inst->tables[tbl_idx]; @@ -2241,7 +2192,7 @@ wasm_call_indirect(WASMExecEnv *exec_env, * please be aware that table_inst->base_addr may point * to another module's table **/ - function_indices = ((uint32_t*)table_inst->base_addr)[element_indices]; + function_indices = ((uint32_t *)table_inst->base_addr)[element_indices]; if (function_indices == NULL_REF) { wasm_set_exception(module_inst, "uninitialized element"); goto got_exception; @@ -2268,16 +2219,14 @@ got_exception: #if WASM_ENABLE_THREAD_MGR != 0 bool -wasm_set_aux_stack(WASMExecEnv *exec_env, - uint32 start_offset, uint32 size) +wasm_set_aux_stack(WASMExecEnv *exec_env, uint32 start_offset, uint32 size) { WASMModuleInstance *module_inst = - (WASMModuleInstance*)exec_env->module_inst; + (WASMModuleInstance *)exec_env->module_inst; uint32 stack_top_idx = module_inst->module->aux_stack_top_global_index; uint32 data_end = module_inst->module->aux_data_end; uint32 stack_bottom = module_inst->module->aux_stack_bottom; - bool is_stack_before_data = - stack_bottom < data_end ? true : false; + bool is_stack_before_data = stack_bottom < data_end ? true : false; /* Check the aux stack space, currently we don't allocate space in heap */ if ((is_stack_before_data && (size > start_offset)) @@ -2287,10 +2236,9 @@ wasm_set_aux_stack(WASMExecEnv *exec_env, if (stack_top_idx != (uint32)-1) { /* The aux stack top is a wasm global, set the initial value for the global */ - uint8 *global_addr = - module_inst->global_data + - module_inst->globals[stack_top_idx].data_offset; - *(int32*)global_addr = start_offset; + uint8 *global_addr = module_inst->global_data + + module_inst->globals[stack_top_idx].data_offset; + *(int32 *)global_addr = start_offset; /* The aux stack boundary is a constant value, set the value to exec_env */ exec_env->aux_stack_boundary.boundary = start_offset - size; @@ -2302,18 +2250,15 @@ wasm_set_aux_stack(WASMExecEnv *exec_env, } bool -wasm_get_aux_stack(WASMExecEnv *exec_env, - uint32 *start_offset, uint32 *size) +wasm_get_aux_stack(WASMExecEnv *exec_env, uint32 *start_offset, uint32 *size) { WASMModuleInstance *module_inst = - (WASMModuleInstance*)exec_env->module_inst; + (WASMModuleInstance *)exec_env->module_inst; /* The aux stack information is resolved in loader and store in module */ - uint32 stack_bottom = - module_inst->module->aux_stack_bottom; - uint32 total_aux_stack_size = - module_inst->module->aux_stack_size; + uint32 stack_bottom = module_inst->module->aux_stack_bottom; + uint32 total_aux_stack_size = module_inst->module->aux_stack_size; if (stack_bottom != 0 && total_aux_stack_size != 0) { if (start_offset) @@ -2340,23 +2285,23 @@ wasm_get_module_mem_consumption(const WASMModule *module, mem_conspn->types_size = sizeof(WASMType *) * module->type_count; for (i = 0; i < module->type_count; i++) { WASMType *type = module->types[i]; - size = offsetof(WASMType, types) + - sizeof(uint8) * (type->param_count + type->result_count); + size = offsetof(WASMType, types) + + sizeof(uint8) * (type->param_count + type->result_count); mem_conspn->types_size += size; } mem_conspn->imports_size = sizeof(WASMImport) * module->import_count; - mem_conspn->functions_size = sizeof(WASMFunction *) - * module->function_count; + mem_conspn->functions_size = + sizeof(WASMFunction *) * module->function_count; for (i = 0; i < module->function_count; i++) { WASMFunction *func = module->functions[i]; WASMType *type = func->func_type; size = sizeof(WASMFunction) + func->local_count + sizeof(uint16) * (type->param_count + func->local_count); #if WASM_ENABLE_FAST_INTERP != 0 - size += func->code_compiled_size - + sizeof(uint32) * func->const_cell_num; + size += + func->code_compiled_size + sizeof(uint32) * func->const_cell_num; #endif mem_conspn->functions_size += size; } @@ -2366,16 +2311,14 @@ wasm_get_module_mem_consumption(const WASMModule *module, mem_conspn->globals_size = sizeof(WASMGlobal) * module->global_count; mem_conspn->exports_size = sizeof(WASMExport) * module->export_count; - mem_conspn->table_segs_size = sizeof(WASMTableSeg) - * module->table_seg_count; + mem_conspn->table_segs_size = + sizeof(WASMTableSeg) * module->table_seg_count; for (i = 0; i < module->table_seg_count; i++) { WASMTableSeg *table_seg = &module->table_segments[i]; - mem_conspn->tables_size += sizeof(uint32) - * table_seg->function_count; + mem_conspn->tables_size += sizeof(uint32) * table_seg->function_count; } - mem_conspn->data_segs_size = sizeof(WASMDataSeg*) - * module->data_seg_count; + mem_conspn->data_segs_size = sizeof(WASMDataSeg *) * module->data_seg_count; for (i = 0; i < module->data_seg_count; i++) { mem_conspn->data_segs_size += sizeof(WASMDataSeg); } @@ -2384,8 +2327,8 @@ wasm_get_module_mem_consumption(const WASMModule *module, StringNode *node = module->const_str_list, *node_next; while (node) { node_next = node->next; - mem_conspn->const_strs_size += sizeof(StringNode) - + strlen(node->str) + 1; + mem_conspn->const_strs_size += + sizeof(StringNode) + strlen(node->str) + 1; node = node_next; } } @@ -2416,22 +2359,20 @@ wasm_get_module_inst_mem_consumption(const WASMModuleInstance *module_inst, mem_conspn->module_inst_struct_size = sizeof(WASMModuleInstance); - mem_conspn->memories_size = sizeof(WASMMemoryInstance *) - * module_inst->memory_count; + mem_conspn->memories_size = + sizeof(WASMMemoryInstance *) * module_inst->memory_count; for (i = 0; i < module_inst->memory_count; i++) { WASMMemoryInstance *memory = module_inst->memories[i]; size = sizeof(WASMMemoryInstance) + memory->num_bytes_per_page * memory->cur_page_count; mem_conspn->memories_size += size; - mem_conspn->app_heap_size += memory->heap_data_end - - memory->heap_data; + mem_conspn->app_heap_size += memory->heap_data_end - memory->heap_data; /* size of app heap structure */ - mem_conspn->memories_size += - mem_allocator_get_heap_struct_size(); + mem_conspn->memories_size += mem_allocator_get_heap_struct_size(); } - mem_conspn->tables_size = sizeof(WASMTableInstance *) - * module_inst->table_count; + mem_conspn->tables_size = + sizeof(WASMTableInstance *) * module_inst->table_count; for (i = 0; i < module_inst->table_count; i++) { WASMTableInstance *table = module_inst->tables[i]; #if WASM_ENABLE_MULTI_MODULE != 0 @@ -2447,20 +2388,20 @@ wasm_get_module_inst_mem_consumption(const WASMModuleInstance *module_inst, mem_conspn->tables_size += size; } - mem_conspn->functions_size = sizeof(WASMFunctionInstance) - * module_inst->function_count; + mem_conspn->functions_size = + sizeof(WASMFunctionInstance) * module_inst->function_count; - mem_conspn->globals_size = sizeof(WASMGlobalInstance) - * module_inst->global_count; + mem_conspn->globals_size = + sizeof(WASMGlobalInstance) * module_inst->global_count; if (module_inst->global_count > 0) { WASMGlobalInstance *global = &module_inst->globals[module_inst->global_count - 1]; - mem_conspn->globals_size += global->data_offset - + wasm_value_type_size(global->type); + mem_conspn->globals_size += + global->data_offset + wasm_value_type_size(global->type); } - mem_conspn->exports_size = sizeof(WASMExportFuncInstance) - * module_inst->export_func_count; + mem_conspn->exports_size = + sizeof(WASMExportFuncInstance) * module_inst->export_func_count; mem_conspn->total_size += mem_conspn->module_inst_struct_size; mem_conspn->total_size += mem_conspn->memories_size; @@ -2469,7 +2410,7 @@ wasm_get_module_inst_mem_consumption(const WASMModuleInstance *module_inst, mem_conspn->total_size += mem_conspn->globals_size; mem_conspn->total_size += mem_conspn->exports_size; } -#endif /* end of (WASM_ENABLE_MEMORY_PROFILING != 0) +#endif /* end of (WASM_ENABLE_MEMORY_PROFILING != 0) \ || (WASM_ENABLE_MEMORY_TRACING != 0) */ #if WASM_ENABLE_DUMP_CALL_STACK != 0 @@ -2477,9 +2418,9 @@ void wasm_interp_dump_call_stack(struct WASMExecEnv *exec_env) { WASMModuleInstance *module_inst = - (WASMModuleInstance *)wasm_exec_env_get_module_inst(exec_env); + (WASMModuleInstance *)wasm_exec_env_get_module_inst(exec_env); WASMInterpFrame *first_frame, - *cur_frame = wasm_exec_env_get_cur_frame(exec_env); + *cur_frame = wasm_exec_env_get_cur_frame(exec_env); uint32 n = 0; /* count frames includes a function */ @@ -2538,7 +2479,7 @@ wasm_interp_dump_call_stack(struct WASMExecEnv *exec_env) uint32 i; for (i = 0; i < module_inst->export_func_count; i++) { WASMExportFuncInstance *export_func = - module_inst->export_functions + i; + module_inst->export_functions + i; if (export_func->function == func_inst) { func_name = export_func->name; break; diff --git a/core/iwasm/interpreter/wasm_runtime.h b/core/iwasm/interpreter/wasm_runtime.h index 745f6faf..56871b36 100644 --- a/core/iwasm/interpreter/wasm_runtime.h +++ b/core/iwasm/interpreter/wasm_runtime.h @@ -247,7 +247,7 @@ typedef struct WASMSubModInstNode { * * @return the code block of the function */ -static inline uint8* +static inline uint8 * wasm_get_func_code(WASMFunctionInstance *func) { #if WASM_ENABLE_FAST_INTERP == 0 @@ -264,34 +264,33 @@ wasm_get_func_code(WASMFunctionInstance *func) * * @return the code block end of the function */ -static inline uint8* +static inline uint8 * wasm_get_func_code_end(WASMFunctionInstance *func) { #if WASM_ENABLE_FAST_INTERP == 0 - return func->is_import_func - ? NULL : func->u.func->code + func->u.func->code_size; + return func->is_import_func ? NULL + : func->u.func->code + func->u.func->code_size; #else return func->is_import_func - ? NULL - : func->u.func->code_compiled + func->u.func->code_compiled_size; + ? NULL + : func->u.func->code_compiled + func->u.func->code_compiled_size; #endif } WASMModule * -wasm_load(const uint8 *buf, uint32 size, - char *error_buf, uint32 error_buf_size); +wasm_load(const uint8 *buf, uint32 size, char *error_buf, + uint32 error_buf_size); WASMModule * -wasm_load_from_sections(WASMSection *section_list, - char *error_buf, uint32_t error_buf_size); +wasm_load_from_sections(WASMSection *section_list, char *error_buf, + uint32_t error_buf_size); void wasm_unload(WASMModule *module); WASMModuleInstance * -wasm_instantiate(WASMModule *module, bool is_sub_inst, - uint32 stack_size, uint32 heap_size, - char *error_buf, uint32 error_buf_size); +wasm_instantiate(WASMModule *module, bool is_sub_inst, uint32 stack_size, + uint32 heap_size, char *error_buf, uint32 error_buf_size); void wasm_dump_perf_profiling(const WASMModuleInstance *module_inst); @@ -300,8 +299,8 @@ void wasm_deinstantiate(WASMModuleInstance *module_inst, bool is_sub_inst); WASMFunctionInstance * -wasm_lookup_function(const WASMModuleInstance *module_inst, - const char *name, const char *signature); +wasm_lookup_function(const WASMModuleInstance *module_inst, const char *name, + const char *signature); #if WASM_ENABLE_MULTI_MODULE != 0 WASMGlobalInstance * @@ -315,8 +314,7 @@ wasm_lookup_table(const WASMModuleInstance *module_inst, const char *name); #endif bool -wasm_call_function(WASMExecEnv *exec_env, - WASMFunctionInstance *function, +wasm_call_function(WASMExecEnv *exec_env, WASMFunctionInstance *function, unsigned argc, uint32 argv[]); bool @@ -330,7 +328,7 @@ wasm_create_exec_env_singleton(WASMModuleInstance *module_inst); void wasm_set_exception(WASMModuleInstance *module, const char *exception); -const char* +const char * wasm_get_exception(WASMModuleInstance *module); uint32 @@ -345,38 +343,32 @@ void wasm_module_free(WASMModuleInstance *module_inst, uint32 ptr); uint32 -wasm_module_dup_data(WASMModuleInstance *module_inst, - const char *src, uint32 size); +wasm_module_dup_data(WASMModuleInstance *module_inst, const char *src, + uint32 size); bool -wasm_validate_app_addr(WASMModuleInstance *module_inst, - uint32 app_offset, uint32 size); +wasm_validate_app_addr(WASMModuleInstance *module_inst, uint32 app_offset, + uint32 size); bool -wasm_validate_app_str_addr(WASMModuleInstance *module_inst, - uint32 app_offset); +wasm_validate_app_str_addr(WASMModuleInstance *module_inst, uint32 app_offset); bool -wasm_validate_native_addr(WASMModuleInstance *module_inst, - void *native_ptr, uint32 size); +wasm_validate_native_addr(WASMModuleInstance *module_inst, void *native_ptr, + uint32 size); void * -wasm_addr_app_to_native(WASMModuleInstance *module_inst, - uint32 app_offset); +wasm_addr_app_to_native(WASMModuleInstance *module_inst, uint32 app_offset); uint32 -wasm_addr_native_to_app(WASMModuleInstance *module_inst, - void *native_ptr); +wasm_addr_native_to_app(WASMModuleInstance *module_inst, void *native_ptr); bool -wasm_get_app_addr_range(WASMModuleInstance *module_inst, - uint32 app_offset, - uint32 *p_app_start_offset, - uint32 *p_app_end_offset); +wasm_get_app_addr_range(WASMModuleInstance *module_inst, uint32 app_offset, + uint32 *p_app_start_offset, uint32 *p_app_end_offset); bool -wasm_get_native_addr_range(WASMModuleInstance *module_inst, - uint8_t *native_ptr, +wasm_get_native_addr_range(WASMModuleInstance *module_inst, uint8_t *native_ptr, uint8_t **p_native_start_addr, uint8_t **p_native_end_addr); @@ -384,19 +376,15 @@ bool wasm_enlarge_memory(WASMModuleInstance *module, uint32 inc_page_count); bool -wasm_call_indirect(WASMExecEnv *exec_env, - uint32_t tbl_idx, - uint32_t element_indices, - uint32_t argc, uint32_t argv[]); +wasm_call_indirect(WASMExecEnv *exec_env, uint32_t tbl_idx, + uint32_t element_indices, uint32_t argc, uint32_t argv[]); #if WASM_ENABLE_THREAD_MGR != 0 bool -wasm_set_aux_stack(WASMExecEnv *exec_env, - uint32 start_offset, uint32 size); +wasm_set_aux_stack(WASMExecEnv *exec_env, uint32 start_offset, uint32 size); bool -wasm_get_aux_stack(WASMExecEnv *exec_env, - uint32 *start_offset, uint32 *size); +wasm_get_aux_stack(WASMExecEnv *exec_env, uint32 *start_offset, uint32 *size); #endif void @@ -427,13 +415,12 @@ wasm_elem_is_declarative(uint32 mode) } bool -wasm_enlarge_table(WASMModuleInstance *module_inst, - uint32 table_idx, uint32 inc_entries, uint32 init_val); +wasm_enlarge_table(WASMModuleInstance *module_inst, uint32 table_idx, + uint32 inc_entries, uint32 init_val); #endif /* WASM_ENABLE_REF_TYPES != 0 */ static inline WASMTableInstance * -wasm_get_table_inst(const WASMModuleInstance *module_inst, - const uint32 tbl_idx) +wasm_get_table_inst(const WASMModuleInstance *module_inst, const uint32 tbl_idx) { /* careful, it might be a table in another module */ WASMTableInstance *tbl_inst = module_inst->tables[tbl_idx]; diff --git a/doc/source_debugging.md b/doc/source_debugging.md index 1543ad5d..60b08240 100644 --- a/doc/source_debugging.md +++ b/doc/source_debugging.md @@ -14,8 +14,12 @@ llvm-dwarfdump-12 test.wasm ``` ## Debugging with interpreter +1. Install dependent libraries +``` bash +apt update && apt install cmake make g++ libxml2-dev -y +``` -1. Build iwasm with source debugging feature +2. Build iwasm with source debugging feature ``` bash cd ${WAMR_ROOT}/product-mini/platforms/linux mkdir build && cd build @@ -23,21 +27,21 @@ cmake .. -DWAMR_BUILD_DEBUG_INTERP=1 make ``` -2. Execute iwasm with debug engine enabled +3. Execute iwasm with debug engine enabled ``` bash iwasm -g=127.0.0.1:1234 test.wasm ``` -3. Build customized lldb (assume you have already built llvm) +4. Build customized lldb (assume you have already cloned llvm) ``` bash cd ${WAMR_ROOT}/core/deps/llvm -git apply ../../../../build-scripts/lldb-wasm.patch -mkdir build && cd build -cmake ../llvm -DLLVM_ENABLE_PROJECTS="clang,lldb" -DLLVM_TARGETS_TO_BUILD:STRING="X86;WebAssembly" +git apply ../../../build-scripts/lldb-wasm.patch +mkdir build_lldb && cd build_lldb +cmake -DCMAKE_BUILD_TYPE:STRING="Release" -DLLVM_ENABLE_PROJECTS="clang;lldb" -DLLVM_TARGETS_TO_BUILD:STRING="X86;WebAssembly" -DLLVM_ENABLE_LIBXML2:BOOL=ON ../llvm make -j $(nproc) ``` -4. Launch customized lldb and connect to iwasm +5. Launch customized lldb and connect to iwasm ``` bash lldb (lldb) process connect -p wasm connect://127.0.0.1:1234