diff --git a/core/iwasm/fast-jit/fe/jit_emit_function.c b/core/iwasm/fast-jit/fe/jit_emit_function.c index 393fddb1d..371aa6200 100644 --- a/core/iwasm/fast-jit/fe/jit_emit_function.c +++ b/core/iwasm/fast-jit/fe/jit_emit_function.c @@ -18,25 +18,15 @@ jit_compile_op_call(JitCompContext *cc, uint32 func_idx, bool tail_call) WASMFunctionImport *func_import; WASMFunction *func; WASMType *func_type; - JitReg value, result = 0, module_inst, native_ret; - JitReg module, func_ptrs, jitted_code = 0; + JitFrame *jit_frame = cc->jit_frame; + JitReg value, result = 0, native_ret; + JitReg func_ptrs, jitted_code = 0; JitInsn *insn; uint32 i, n, outs_off, jitted_func_idx; - module_inst = jit_cc_new_reg_ptr(cc); - /* module_inst = exec_env->module_inst */ - GEN_INSN(LDPTR, module_inst, cc->exec_env_reg, - NEW_CONST(I32, offsetof(WASMExecEnv, module_inst))); if (func_idx >= wasm_module->import_function_count) { - module = jit_cc_new_reg_ptr(cc); - func_ptrs = jit_cc_new_reg_ptr(cc); + func_ptrs = get_func_ptrs_reg(jit_frame); jitted_code = jit_cc_new_reg_ptr(cc); - /* module = module_inst->module */ - GEN_INSN(LDPTR, module, module_inst, - NEW_CONST(I32, offsetof(WASMModuleInstance, module))); - /* func_ptrs = module->fast_jit_func_ptrs */ - GEN_INSN(LDPTR, func_ptrs, module, - NEW_CONST(I32, offsetof(WASMModule, fast_jit_func_ptrs))); /* jitted_code = func_ptrs[func_idx - import_function_count] */ jitted_func_idx = func_idx - wasm_module->import_function_count; GEN_INSN(LDPTR, jitted_code, func_ptrs, @@ -195,6 +185,11 @@ jit_compile_op_call(JitCompContext *cc, uint32 func_idx, bool tail_call) } } + /* Clear part of memory regs and table regs as their values + may be changed in the function call */ + clear_memory_regs(jit_frame); + clear_table_regs(jit_frame); + /* Ignore tail call currently */ (void)tail_call; return true; diff --git a/core/iwasm/fast-jit/jit_frontend.c b/core/iwasm/fast-jit/jit_frontend.c index f2e99d3fd..1799dd5b2 100644 --- a/core/iwasm/fast-jit/jit_frontend.c +++ b/core/iwasm/fast-jit/jit_frontend.c @@ -42,6 +42,346 @@ static const char *jit_exception_msgs[] = { }; /* clang-format on */ +JitReg +get_module_inst_reg(JitFrame *frame) +{ + JitCompContext *cc = frame->cc; + + if (!frame->module_inst_reg) { + frame->module_inst_reg = cc->module_inst_reg; + GEN_INSN(LDPTR, frame->module_inst_reg, cc->exec_env_reg, + NEW_CONST(I32, offsetof(WASMExecEnv, module_inst))); + } + return frame->module_inst_reg; +} + +JitReg +get_module_reg(JitFrame *frame) +{ + JitCompContext *cc = frame->cc; + JitReg module_inst_reg = get_module_inst_reg(frame); + + if (!frame->module_reg) { + frame->module_reg = cc->module_reg; + GEN_INSN(LDPTR, frame->module_reg, module_inst_reg, + NEW_CONST(I32, offsetof(WASMModuleInstance, module))); + } + return frame->module_reg; +} + +JitReg +get_func_ptrs_reg(JitFrame *frame) +{ + JitCompContext *cc = frame->cc; + JitReg module_reg = get_module_reg(frame); + + if (!frame->func_ptrs_reg) { + frame->func_ptrs_reg = cc->func_ptrs_reg; + GEN_INSN(LDPTR, frame->func_ptrs_reg, module_reg, + NEW_CONST(I32, offsetof(WASMModule, fast_jit_func_ptrs))); + } + return frame->func_ptrs_reg; +} + +JitReg +get_global_data_reg(JitFrame *frame) +{ + JitCompContext *cc = frame->cc; + JitReg module_inst_reg = get_module_inst_reg(frame); + + if (!frame->global_data_reg) { + frame->global_data_reg = cc->global_data_reg; + GEN_INSN(LDPTR, frame->global_data_reg, module_inst_reg, + NEW_CONST(I32, offsetof(WASMModuleInstance, global_data))); + } + return frame->global_data_reg; +} + +JitReg +get_aux_stack_bound_reg(JitFrame *frame) +{ + /* TODO */ + return 0; +} + +JitReg +get_aux_stack_bottom_reg(JitFrame *frame) +{ + /* TODO */ + return 0; +} + +JitReg +get_memories_reg(JitFrame *frame) +{ + JitCompContext *cc = frame->cc; + JitReg module_inst_reg = get_module_inst_reg(frame); + + if (!frame->memories_reg) { + frame->memories_reg = cc->memories_reg; + GEN_INSN(LDPTR, frame->memories_reg, module_inst_reg, + NEW_CONST(I32, offsetof(WASMModuleInstance, memories))); + } + return frame->memories_reg; +} + +JitReg +get_memory_inst_reg(JitFrame *frame, uint32 mem_idx) +{ + JitCompContext *cc = frame->cc; + JitReg memories_reg = get_memories_reg(frame); + + if (!frame->memory_regs[mem_idx].memory_inst) { + frame->memory_regs[mem_idx].memory_inst = + cc->memory_regs[mem_idx].memory_inst; + GEN_INSN( + LDPTR, frame->memory_regs[mem_idx].memory_inst, memories_reg, + NEW_CONST(I32, (uint32)sizeof(WASMMemoryInstance *) * mem_idx)); + } + return frame->memory_regs[mem_idx].memory_inst; +} + +JitReg +get_memory_data_reg(JitFrame *frame, uint32 mem_idx) +{ + JitCompContext *cc = frame->cc; + JitReg memory_inst_reg = get_memory_inst_reg(frame, mem_idx); + + if (!frame->memory_regs[mem_idx].memory_data) { + frame->memory_regs[mem_idx].memory_data = + cc->memory_regs[mem_idx].memory_data; + GEN_INSN(LDPTR, frame->memory_regs[mem_idx].memory_data, + memory_inst_reg, + NEW_CONST(I32, offsetof(WASMMemoryInstance, memory_data))); + } + return frame->memory_regs[mem_idx].memory_data; +} + +JitReg +get_memory_data_end_reg(JitFrame *frame, uint32 mem_idx) +{ + JitCompContext *cc = frame->cc; + JitReg memory_inst_reg = get_memory_inst_reg(frame, mem_idx); + + if (!frame->memory_regs[mem_idx].memory_data_end) { + frame->memory_regs[mem_idx].memory_data_end = + cc->memory_regs[mem_idx].memory_data_end; + GEN_INSN(LDPTR, frame->memory_regs[mem_idx].memory_data_end, + memory_inst_reg, + NEW_CONST(I32, offsetof(WASMMemoryInstance, memory_data_end))); + } + return frame->memory_regs[mem_idx].memory_data_end; +} + +JitReg +get_mem_bound_check_1byte_reg(JitFrame *frame, uint32 mem_idx) +{ + JitCompContext *cc = frame->cc; + JitReg memory_inst_reg = get_memory_inst_reg(frame, mem_idx); + + if (!frame->memory_regs[mem_idx].mem_bound_check_1byte) { + frame->memory_regs[mem_idx].mem_bound_check_1byte = + cc->memory_regs[mem_idx].mem_bound_check_1byte; +#if UINTPTR_MAX == UINT64_MAX + GEN_INSN(LDI64, frame->memory_regs[mem_idx].mem_bound_check_1byte, + memory_inst_reg, + NEW_CONST( + I32, offsetof(WASMMemoryInstance, mem_bound_check_1byte))); +#else + GEN_INSN(LDI32, frame->memory_regs[mem_idx].mem_bound_check_1byte, + memory_inst_reg, + NEW_CONST( + I32, offsetof(WASMMemoryInstance, mem_bound_check_1byte))); +#endif + } + return frame->memory_regs[mem_idx].mem_bound_check_1byte; +} + +JitReg +get_mem_bound_check_2bytes_reg(JitFrame *frame, uint32 mem_idx) +{ + JitCompContext *cc = frame->cc; + JitReg memory_inst_reg = get_memory_inst_reg(frame, mem_idx); + + if (!frame->memory_regs[mem_idx].mem_bound_check_2bytes) { + frame->memory_regs[mem_idx].mem_bound_check_2bytes = + cc->memory_regs[mem_idx].mem_bound_check_2bytes; +#if UINTPTR_MAX == UINT64_MAX + GEN_INSN(LDI64, frame->memory_regs[mem_idx].mem_bound_check_2bytes, + memory_inst_reg, + NEW_CONST(I32, offsetof(WASMMemoryInstance, + mem_bound_check_2bytes))); +#else + GEN_INSN(LDI32, frame->memory_regs[mem_idx].mem_bound_check_2bytes, + memory_inst_reg, + NEW_CONST(I32, offsetof(WASMMemoryInstance, + mem_bound_check_2bytes))); +#endif + } + return frame->memory_regs[mem_idx].mem_bound_check_2bytes; +} + +JitReg +get_mem_bound_check_4bytes_reg(JitFrame *frame, uint32 mem_idx) +{ + JitCompContext *cc = frame->cc; + JitReg memory_inst_reg = get_memory_inst_reg(frame, mem_idx); + + if (!frame->memory_regs[mem_idx].mem_bound_check_4bytes) { + frame->memory_regs[mem_idx].mem_bound_check_4bytes = + cc->memory_regs[mem_idx].mem_bound_check_4bytes; +#if UINTPTR_MAX == UINT64_MAX + GEN_INSN(LDI64, frame->memory_regs[mem_idx].mem_bound_check_4bytes, + memory_inst_reg, + NEW_CONST(I32, offsetof(WASMMemoryInstance, + mem_bound_check_4bytes))); +#else + GEN_INSN(LDI32, frame->memory_regs[mem_idx].mem_bound_check_4bytes, + memory_inst_reg, + NEW_CONST(I32, offsetof(WASMMemoryInstance, + mem_bound_check_4bytes))); +#endif + } + return frame->memory_regs[mem_idx].mem_bound_check_4bytes; +} + +JitReg +get_mem_bound_check_8bytes_reg(JitFrame *frame, uint32 mem_idx) +{ + JitCompContext *cc = frame->cc; + JitReg memory_inst_reg = get_memory_inst_reg(frame, mem_idx); + + if (!frame->memory_regs[mem_idx].mem_bound_check_8bytes) { + frame->memory_regs[mem_idx].mem_bound_check_8bytes = + cc->memory_regs[mem_idx].mem_bound_check_8bytes; +#if UINTPTR_MAX == UINT64_MAX + GEN_INSN(LDI64, frame->memory_regs[mem_idx].mem_bound_check_8bytes, + memory_inst_reg, + NEW_CONST(I32, offsetof(WASMMemoryInstance, + mem_bound_check_8bytes))); +#else + GEN_INSN(LDI32, frame->memory_regs[mem_idx].mem_bound_check_8bytes, + memory_inst_reg, + NEW_CONST(I32, offsetof(WASMMemoryInstance, + mem_bound_check_8bytes))); +#endif + } + return frame->memory_regs[mem_idx].mem_bound_check_8bytes; +} + +JitReg +get_mem_bound_check_16bytes_reg(JitFrame *frame, uint32 mem_idx) +{ + JitCompContext *cc = frame->cc; + JitReg memory_inst_reg = get_memory_inst_reg(frame, mem_idx); + + if (!frame->memory_regs[mem_idx].mem_bound_check_16bytes) { + frame->memory_regs[mem_idx].mem_bound_check_16bytes = + cc->memory_regs[mem_idx].mem_bound_check_16bytes; +#if UINTPTR_MAX == UINT64_MAX + GEN_INSN(LDI64, frame->memory_regs[mem_idx].mem_bound_check_16bytes, + memory_inst_reg, + NEW_CONST(I32, offsetof(WASMMemoryInstance, + mem_bound_check_16bytes))); +#else + GEN_INSN(LDI32, frame->memory_regs[mem_idx].mem_bound_check_16bytes, + memory_inst_reg, + NEW_CONST(I32, offsetof(WASMMemoryInstance, + mem_bound_check_16bytes))); +#endif + } + return frame->memory_regs[mem_idx].mem_bound_check_16bytes; +} + +JitReg +get_tables_reg(JitFrame *frame) +{ + return 0; +} + +JitReg +get_table_inst_reg(JitFrame *frame, uint32 table_idx) +{ + return 0; +} + +JitReg +get_table_data_reg(JitFrame *frame, uint32 table_idx) +{ + return 0; +} + +JitReg +get_table_cur_size_reg(JitFrame *frame, uint32 table_idx) +{ + return 0; +} + +void +clear_fixed_virtual_regs(JitFrame *frame) +{ + WASMModule *module = frame->cc->cur_wasm_module; + uint32 count, i; + + frame->module_inst_reg = 0; + frame->module_reg = 0; + frame->func_ptrs_reg = 0; + frame->global_data_reg = 0; + frame->aux_stack_bound_reg = 0; + frame->aux_stack_bottom_reg = 0; + frame->memories_reg = 0; + frame->tables_reg = 0; + + count = module->import_memory_count + module->memory_count; + for (i = 0; i < count; i++) { + frame->memory_regs[i].memory_inst = 0; + frame->memory_regs[i].memory_data = 0; + frame->memory_regs[i].memory_data_end = 0; + frame->memory_regs[i].mem_bound_check_1byte = 0; + frame->memory_regs[i].mem_bound_check_2bytes = 0; + frame->memory_regs[i].mem_bound_check_4bytes = 0; + frame->memory_regs[i].mem_bound_check_8bytes = 0; + frame->memory_regs[i].mem_bound_check_16bytes = 0; + } + + count = module->import_table_count + module->table_count; + for (i = 0; i < count; i++) { + frame->table_regs[i].table_inst = 0; + frame->table_regs[i].table_data = 0; + frame->table_regs[i].table_cur_size = 0; + } +} + +void +clear_memory_regs(JitFrame *frame) +{ + WASMModule *module = frame->cc->cur_wasm_module; + uint32 count, i; + + count = module->import_memory_count + module->memory_count; + for (i = 0; i < count; i++) { + frame->memory_regs[i].memory_data = 0; + frame->memory_regs[i].memory_data_end = 0; + frame->memory_regs[i].mem_bound_check_1byte = 0; + frame->memory_regs[i].mem_bound_check_2bytes = 0; + frame->memory_regs[i].mem_bound_check_4bytes = 0; + frame->memory_regs[i].mem_bound_check_8bytes = 0; + frame->memory_regs[i].mem_bound_check_16bytes = 0; + } +} + +void +clear_table_regs(JitFrame *frame) +{ + WASMModule *module = frame->cc->cur_wasm_module; + uint32 count, i; + + count = module->import_table_count + module->table_count; + for (i = 0; i < count; i++) { + frame->table_regs[i].table_cur_size = 0; + } +} + JitReg gen_load_i32(JitFrame *frame, unsigned n) { @@ -171,7 +511,7 @@ jit_set_exception_with_id(WASMModuleInstance *module_inst, uint32 id) } static bool -create_fix_virtual_regs(JitCompContext *cc) +create_fixed_virtual_regs(JitCompContext *cc) { WASMModule *module = cc->cur_wasm_module; uint64 total_size; @@ -183,38 +523,44 @@ create_fix_virtual_regs(JitCompContext *cc) cc->global_data_reg = jit_cc_new_reg_ptr(cc); cc->aux_stack_bound_reg = jit_cc_new_reg_I32(cc); cc->aux_stack_bottom_reg = jit_cc_new_reg_I32(cc); + cc->memories_reg = jit_cc_new_reg_ptr(cc); + cc->tables_reg = jit_cc_new_reg_ptr(cc); count = module->import_memory_count + module->memory_count; - total_size = (uint64)sizeof(JitMemRegs) * count; - if (total_size > UINT32_MAX - || !(cc->memory_regs = jit_calloc((uint32)total_size))) { - jit_set_last_error(cc, "allocate memory failed"); - return false; - } + if (count > 0) { + total_size = (uint64)sizeof(JitMemRegs) * count; + if (total_size > UINT32_MAX + || !(cc->memory_regs = jit_calloc((uint32)total_size))) { + jit_set_last_error(cc, "allocate memory failed"); + return false; + } - for (i = 0; i < count; i++) { - cc->memory_regs[i].memory_inst = jit_cc_new_reg_ptr(cc); - cc->memory_regs[i].memory_data = jit_cc_new_reg_ptr(cc); - cc->memory_regs[i].memory_data_end = jit_cc_new_reg_ptr(cc); - cc->memory_regs[i].mem_bound_check_1byte = jit_cc_new_reg_I32(cc); - cc->memory_regs[i].mem_bound_check_2bytes = jit_cc_new_reg_I32(cc); - cc->memory_regs[i].mem_bound_check_4bytes = jit_cc_new_reg_I32(cc); - cc->memory_regs[i].mem_bound_check_8bytes = jit_cc_new_reg_I32(cc); - cc->memory_regs[i].mem_bound_check_16bytes = jit_cc_new_reg_I32(cc); + for (i = 0; i < count; i++) { + cc->memory_regs[i].memory_inst = jit_cc_new_reg_ptr(cc); + cc->memory_regs[i].memory_data = jit_cc_new_reg_ptr(cc); + cc->memory_regs[i].memory_data_end = jit_cc_new_reg_ptr(cc); + cc->memory_regs[i].mem_bound_check_1byte = jit_cc_new_reg_ptr(cc); + cc->memory_regs[i].mem_bound_check_2bytes = jit_cc_new_reg_ptr(cc); + cc->memory_regs[i].mem_bound_check_4bytes = jit_cc_new_reg_ptr(cc); + cc->memory_regs[i].mem_bound_check_8bytes = jit_cc_new_reg_ptr(cc); + cc->memory_regs[i].mem_bound_check_16bytes = jit_cc_new_reg_ptr(cc); + } } count = module->import_table_count + module->table_count; - total_size = (uint64)sizeof(JitTableRegs) * count; - if (total_size > UINT32_MAX - || !(cc->table_regs = jit_calloc((uint32)total_size))) { - jit_set_last_error(cc, "allocate memory failed"); - return false; - } + if (count > 0) { + total_size = (uint64)sizeof(JitTableRegs) * count; + if (total_size > UINT32_MAX + || !(cc->table_regs = jit_calloc((uint32)total_size))) { + jit_set_last_error(cc, "allocate memory failed"); + return false; + } - for (i = 0; i < count; i++) { - cc->table_regs[i].table_inst = jit_cc_new_reg_ptr(cc); - cc->table_regs[i].table_data = jit_cc_new_reg_ptr(cc); - cc->table_regs[i].table_cur_size = jit_cc_new_reg_I32(cc); + for (i = 0; i < count; i++) { + cc->table_regs[i].table_inst = jit_cc_new_reg_ptr(cc); + cc->table_regs[i].table_data = jit_cc_new_reg_ptr(cc); + cc->table_regs[i].table_cur_size = jit_cc_new_reg_I32(cc); + } } return true; @@ -229,7 +575,7 @@ form_and_translate_func(JitCompContext *cc) JitIncomingInsn *incoming_insn, *incoming_insn_next; uint32 i; - if (!create_fix_virtual_regs(cc)) + if (!create_fixed_virtual_regs(cc)) return false; if (!(func_entry_basic_block = jit_frontend_translate_func(cc))) @@ -340,7 +686,8 @@ init_func_translation(JitCompContext *cc) + (uint64)cur_wasm_func->local_cell_num + (uint64)cur_wasm_func->max_stack_cell_num + ((uint64)cur_wasm_func->max_block_num) * sizeof(WASMBranchBlock) / 4; - uint32 frame_size, outs_size, local_size; + uint32 frame_size, outs_size, local_size, count; + uint64 total_size; if ((uint64)max_locals + (uint64)max_stacks >= UINT32_MAX || total_cell_num >= UINT32_MAX @@ -351,6 +698,31 @@ init_func_translation(JitCompContext *cc) return NULL; } + count = + cur_wasm_module->import_memory_count + cur_wasm_module->memory_count; + if (count > 0) { + total_size = (uint64)sizeof(JitMemRegs) * count; + if (total_size > UINT32_MAX + || !(jit_frame->memory_regs = jit_calloc((uint32)total_size))) { + jit_set_last_error(cc, "allocate memory failed"); + jit_free(jit_frame); + return NULL; + } + } + + count = cur_wasm_module->import_table_count + cur_wasm_module->table_count; + if (count > 0) { + total_size = (uint64)sizeof(JitTableRegs) * count; + if (total_size > UINT32_MAX + || !(jit_frame->table_regs = jit_calloc((uint32)total_size))) { + jit_set_last_error(cc, "allocate memory failed"); + if (jit_frame->memory_regs) + jit_free(jit_frame->memory_regs); + jit_free(jit_frame); + return NULL; + } + } + jit_frame->cur_wasm_module = cur_wasm_module; jit_frame->cur_wasm_func = cur_wasm_func; jit_frame->cur_wasm_func_idx = cur_wasm_func_idx; diff --git a/core/iwasm/fast-jit/jit_frontend.h b/core/iwasm/fast-jit/jit_frontend.h index d4819414a..760dd1692 100644 --- a/core/iwasm/fast-jit/jit_frontend.h +++ b/core/iwasm/fast-jit/jit_frontend.h @@ -208,6 +208,72 @@ jit_frontend_bcip_to_offset(void *function, void *bcip); bool jit_frontend_lower(JitCompContext *cc); +JitReg +get_module_inst_reg(JitFrame *frame); + +JitReg +get_module_reg(JitFrame *frame); + +JitReg +get_func_ptrs_reg(JitFrame *frame); + +JitReg +get_global_data_reg(JitFrame *frame); + +JitReg +get_aux_stack_bound_reg(JitFrame *frame); + +JitReg +get_aux_stack_bottom_reg(JitFrame *frame); + +JitReg +get_memories_reg(JitFrame *frame); + +JitReg +get_memory_inst_reg(JitFrame *frame, uint32 mem_idx); + +JitReg +get_memory_data_reg(JitFrame *frame, uint32 mem_idx); + +JitReg +get_memory_data_end_reg(JitFrame *frame, uint32 mem_idx); + +JitReg +get_mem_bound_check_1byte_reg(JitFrame *frame, uint32 mem_idx); + +JitReg +get_mem_bound_check_2bytes_reg(JitFrame *frame, uint32 mem_idx); + +JitReg +get_mem_bound_check_4bytes_reg(JitFrame *frame, uint32 mem_idx); + +JitReg +get_mem_bound_check_8bytes_reg(JitFrame *frame, uint32 mem_idx); + +JitReg +get_mem_bound_check_16bytes_reg(JitFrame *frame, uint32 mem_idx); + +JitReg +get_tables_reg(JitFrame *frame); + +JitReg +get_table_inst_reg(JitFrame *frame, uint32 table_idx); + +JitReg +get_table_data_reg(JitFrame *frame, uint32 table_idx); + +JitReg +get_table_cur_size_reg(JitFrame *frame, uint32 table_idx); + +void +clear_fixed_virtual_regs(JitFrame *frame); + +void +clear_memory_regs(JitFrame *frame); + +void +clear_table_regs(JitFrame *frame); + /** * Get the offset from frame pointer to the n-th local variable slot. * @@ -330,6 +396,7 @@ clear_values(JitFrame *frame) size_t total_size = sizeof(JitValueSlot) * (frame->max_locals + frame->max_stacks); memset(frame->lp, 0, total_size); + clear_fixed_virtual_regs(frame); } static inline void diff --git a/core/iwasm/fast-jit/jit_ir.h b/core/iwasm/fast-jit/jit_ir.h index 46bf09329..226e5bbe1 100644 --- a/core/iwasm/fast-jit/jit_ir.h +++ b/core/iwasm/fast-jit/jit_ir.h @@ -898,8 +898,8 @@ typedef struct JitValueSlot { typedef struct JitMemRegs { JitReg memory_inst; - /* The following registers should be re-loaded after memory.grow, - and callbc, callnative */ + /* The following registers should be re-loaded after + memory.grow, callbc and callnative */ JitReg memory_data; JitReg memory_data_end; JitReg mem_bound_check_1byte; @@ -913,7 +913,7 @@ typedef struct JitTableRegs { JitReg table_inst; JitReg table_data; /* Should be re-loaded after table.grow, - and callbc, callnative */ + callbc and callnative */ JitReg table_cur_size; } JitTableRegs; @@ -958,8 +958,12 @@ typedef struct JitFrame { JitReg aux_stack_bound_reg; /* Bottom of auxiliary stack */ JitReg aux_stack_bottom_reg; + /* Memory instances */ + JitReg memories_reg; /* Data of memory instances */ JitMemRegs *memory_regs; + /* Table instances */ + JitReg tables_reg; /* Data of table instances */ JitTableRegs *table_regs; @@ -1071,8 +1075,12 @@ typedef struct JitCompContext { JitReg aux_stack_bound_reg; /* Bottom of auxiliary stack */ JitReg aux_stack_bottom_reg; + /* Memory instances */ + JitReg memories_reg; /* Data of memory instances */ JitMemRegs *memory_regs; + /* Table instances */ + JitReg tables_reg; /* Data of table instances */ JitTableRegs *table_regs; diff --git a/core/iwasm/interpreter/wasm_runtime.c b/core/iwasm/interpreter/wasm_runtime.c index d5c662222..d352b8e75 100644 --- a/core/iwasm/interpreter/wasm_runtime.c +++ b/core/iwasm/interpreter/wasm_runtime.c @@ -297,6 +297,24 @@ memory_instantiate(WASMModuleInstance *module_inst, uint32 num_bytes_per_page, } } +#if WASM_ENABLE_FAST_JIT != 0 + if (memory_data_size > 0) { +#if UINTPTR_MAX == UINT64_MAX + memory->mem_bound_check_1byte = memory_data_size - 1; + memory->mem_bound_check_2bytes = memory_data_size - 2; + memory->mem_bound_check_4bytes = memory_data_size - 4; + memory->mem_bound_check_8bytes = memory_data_size - 8; + memory->mem_bound_check_16bytes = memory_data_size - 16; +#else + memory->mem_bound_check_1byte = (uint32)memory_data_size - 1; + memory->mem_bound_check_2bytes = (uint32)memory_data_size - 2; + memory->mem_bound_check_4bytes = (uint32)memory_data_size - 4; + memory->mem_bound_check_8bytes = (uint32)memory_data_size - 8; + memory->mem_bound_check_16bytes = (uint32)memory_data_size - 16; +#endif + } +#endif + #if WASM_ENABLE_SHARED_MEMORY != 0 if (0 != os_mutex_init(&memory->mem_lock)) { set_error_buf(error_buf, error_buf_size, "init mutex failed"); @@ -2192,6 +2210,22 @@ wasm_enlarge_memory(WASMModuleInstance *module, uint32 inc_page_count) memory->memory_data_end = memory->memory_data + memory->num_bytes_per_page * total_page_count; +#if WASM_ENABLE_FAST_JIT != 0 +#if UINTPTR_MAX == UINT64_MAX + memory->mem_bound_check_1byte = total_size - 1; + memory->mem_bound_check_2bytes = total_size - 2; + memory->mem_bound_check_4bytes = total_size - 4; + memory->mem_bound_check_8bytes = total_size - 8; + memory->mem_bound_check_16bytes = total_size - 16; +#else + memory->mem_bound_check_1byte = (uint32)total_size - 1; + memory->mem_bound_check_2bytes = (uint32)total_size - 2; + memory->mem_bound_check_4bytes = (uint32)total_size - 4; + memory->mem_bound_check_8bytes = (uint32)total_size - 8; + memory->mem_bound_check_16bytes = (uint32)total_size - 16; +#endif +#endif + return ret; } diff --git a/core/iwasm/interpreter/wasm_runtime.h b/core/iwasm/interpreter/wasm_runtime.h index 6f1fb6ddf..e8f72152e 100644 --- a/core/iwasm/interpreter/wasm_runtime.h +++ b/core/iwasm/interpreter/wasm_runtime.h @@ -52,6 +52,22 @@ struct WASMMemoryInstance { Note: when memory is re-allocated, the heap data and memory data must be copied to new memory also. */ uint8 *memory_data; + +#if WASM_ENABLE_FAST_JIT != 0 +#if UINTPTR_MAX == UINT64_MAX + uint64 mem_bound_check_1byte; + uint64 mem_bound_check_2bytes; + uint64 mem_bound_check_4bytes; + uint64 mem_bound_check_8bytes; + uint64 mem_bound_check_16bytes; +#else + uint32 mem_bound_check_1byte; + uint32 mem_bound_check_2bytes; + uint32 mem_bound_check_4bytes; + uint32 mem_bound_check_8bytes; + uint32 mem_bound_check_16bytes; +#endif +#endif }; struct WASMTableInstance {