gnh1201/wasm-micro-runtime
1
0
Fork 0
mirror of https://github.com/bytecodealliance/wasm-micro-runtime.git synced 2025-06-18 02:59:21 +00:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity

Implement load fixed virtual regs (#1083)

Browse Source
This commit is contained in:
Wenyong Huang 2022-04-12 14:54:38 +08:00 committed by GitHub
parent aeeaf4b02e
commit 27446e4b14
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 537 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
core/iwasm/fast-jit/fe/jit_emit_function.c
View File

@ -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;

428
core/iwasm/fast-jit/jit_frontend.c
View File

@ -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;

67
core/iwasm/fast-jit/jit_frontend.h
View File

@ -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

14
core/iwasm/fast-jit/jit_ir.h
View File

@ -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;

34
core/iwasm/interpreter/wasm_runtime.c
View File

@ -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;
}

16
core/iwasm/interpreter/wasm_runtime.h
View File

@ -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 {