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

Add table type API support (#3515)

Browse Source 
Add `wasm_runtime_get_export_table_inst` and `wasm_table_get_func_inst`,
and related wasm_table_type_get_xxx APIs.
This commit is contained in:
Benbuck Nason 2024-06-18 23:50:46 -07:00 committed by GitHub
parent 72f74b7b51
commit 3746534010
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
15 changed files with 590 additions and 245 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
core/iwasm/aot/aot_loader.c
View File

@ -1330,24 +1330,25 @@ load_import_table_list(const uint8 **p_buf, const uint8 *buf_end,
/* keep sync with aot_emit_table_info() aot_emit_aot_file */ /* keep sync with aot_emit_table_info() aot_emit_aot_file */
for (i = 0; i < module->import_table_count; i++, import_table++) { for (i = 0; i < module->import_table_count; i++, import_table++) {
read_uint8(buf, buf_end, import_table->elem_type); read_uint8(buf, buf_end, import_table->table_type.elem_type);
read_uint8(buf, buf_end, import_table->table_flags); read_uint8(buf, buf_end, import_table->table_type.flags);
read_uint8(buf, buf_end, import_table->possible_grow); read_uint8(buf, buf_end, import_table->table_type.possible_grow);
#if WASM_ENABLE_GC != 0 #if WASM_ENABLE_GC != 0
if (wasm_is_type_multi_byte_type(import_table->elem_type)) { if (wasm_is_type_multi_byte_type(import_table->table_type.elem_type)) {
read_uint8(buf, buf_end, ref_type.ref_ht_common.nullable); read_uint8(buf, buf_end, ref_type.ref_ht_common.nullable);
} }
#endif #endif
read_uint32(buf, buf_end, import_table->table_init_size); read_uint32(buf, buf_end, import_table->table_type.init_size);
read_uint32(buf, buf_end, import_table->table_max_size); read_uint32(buf, buf_end, import_table->table_type.max_size);
#if WASM_ENABLE_GC != 0 #if WASM_ENABLE_GC != 0
if (wasm_is_type_multi_byte_type(import_table->elem_type)) { if (wasm_is_type_multi_byte_type(import_table->table_type.elem_type)) {
read_uint32(buf, buf_end, ref_type.ref_ht_common.heap_type); read_uint32(buf, buf_end, ref_type.ref_ht_common.heap_type);
ref_type.ref_type = import_table->elem_type; ref_type.ref_type = import_table->table_type.elem_type;
/* TODO: check ref_type */ /* TODO: check ref_type */
if (!(import_table->elem_ref_type = wasm_reftype_set_insert( if (!(import_table->table_type.elem_ref_type =
module->ref_type_set, &ref_type))) { wasm_reftype_set_insert(module->ref_type_set,
&ref_type))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"insert ref type to hash set failed"); "insert ref type to hash set failed");
return false; return false;
@ -1383,23 +1384,23 @@ load_table_list(const uint8 **p_buf, const uint8 *buf_end, AOTModule *module,
/* Create each table data segment */ /* Create each table data segment */
for (i = 0; i < module->table_count; i++, table++) { for (i = 0; i < module->table_count; i++, table++) {
read_uint8(buf, buf_end, table->elem_type); read_uint8(buf, buf_end, table->table_type.elem_type);
read_uint8(buf, buf_end, table->table_flags); read_uint8(buf, buf_end, table->table_type.flags);
read_uint8(buf, buf_end, table->possible_grow); read_uint8(buf, buf_end, table->table_type.possible_grow);
#if WASM_ENABLE_GC != 0 #if WASM_ENABLE_GC != 0
if (wasm_is_type_multi_byte_type(table->elem_type)) { if (wasm_is_type_multi_byte_type(table->table_type.elem_type)) {
read_uint8(buf, buf_end, ref_type.ref_ht_common.nullable); read_uint8(buf, buf_end, ref_type.ref_ht_common.nullable);
} }
#endif #endif
read_uint32(buf, buf_end, table->table_init_size); read_uint32(buf, buf_end, table->table_type.init_size);
read_uint32(buf, buf_end, table->table_max_size); read_uint32(buf, buf_end, table->table_type.max_size);
#if WASM_ENABLE_GC != 0 #if WASM_ENABLE_GC != 0
if (wasm_is_type_multi_byte_type(table->elem_type)) { if (wasm_is_type_multi_byte_type(table->table_type.elem_type)) {
read_uint32(buf, buf_end, ref_type.ref_ht_common.heap_type); read_uint32(buf, buf_end, ref_type.ref_ht_common.heap_type);
ref_type.ref_type = table->elem_type; ref_type.ref_type = table->table_type.elem_type;
/* TODO: check ref_type */ /* TODO: check ref_type */
if (!(table->elem_ref_type = wasm_reftype_set_insert( if (!(table->table_type.elem_ref_type = wasm_reftype_set_insert(
module->ref_type_set, &ref_type))) { module->ref_type_set, &ref_type))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"insert ref type to hash set failed"); "insert ref type to hash set failed");

133
core/iwasm/aot/aot_runtime.c
View File

@ -618,23 +618,23 @@ tables_instantiate(AOTModuleInstance *module_inst, AOTModule *module,
for (i = 0; i != module_inst->table_count; ++i) { for (i = 0; i != module_inst->table_count; ++i) {
if (i < module->import_table_count) { if (i < module->import_table_count) {
AOTImportTable *import_table = module->import_tables + i; AOTImportTable *import_table = module->import_tables + i;
tbl_inst->cur_size = import_table->table_init_size; tbl_inst->cur_size = import_table->table_type.init_size;
tbl_inst->max_size = tbl_inst->max_size =
aot_get_imp_tbl_data_slots(import_table, false); aot_get_imp_tbl_data_slots(import_table, false);
tbl_inst->elem_type = module->tables[i].table_type.elem_type;
#if WASM_ENABLE_GC != 0 #if WASM_ENABLE_GC != 0
tbl_inst->elem_type = module->tables[i].elem_type;
tbl_inst->elem_ref_type.elem_ref_type = tbl_inst->elem_ref_type.elem_ref_type =
module->tables[i].elem_ref_type; module->tables[i].table_type.elem_ref_type;
#endif #endif
} }
else { else {
AOTTable *table = module->tables + (i - module->import_table_count); AOTTable *table = module->tables + (i - module->import_table_count);
tbl_inst->cur_size = table->table_init_size; tbl_inst->cur_size = table->table_type.init_size;
tbl_inst->max_size = aot_get_tbl_data_slots(table, false); tbl_inst->max_size = aot_get_tbl_data_slots(table, false);
tbl_inst->elem_type = module->tables[i].table_type.elem_type;
#if WASM_ENABLE_GC != 0 #if WASM_ENABLE_GC != 0
tbl_inst->elem_type = module->tables[i].elem_type;
tbl_inst->elem_ref_type.elem_ref_type = tbl_inst->elem_ref_type.elem_ref_type =
module->tables[i].elem_ref_type; module->tables[i].table_type.elem_ref_type;
#endif #endif
} }
@ -1183,6 +1183,75 @@ init_func_ptrs(AOTModuleInstance *module_inst, AOTModule *module,
return true; return true;
} }
AOTFunctionInstance *
aot_get_function_instance(AOTModuleInstance *module_inst, uint32 func_idx)
{
AOTModule *module = (AOTModule *)module_inst->module;
AOTModuleInstanceExtra *extra = (AOTModuleInstanceExtra *)module_inst->e;
AOTFunctionInstance *export_funcs =
(AOTFunctionInstance *)module_inst->export_functions;
uint32 i;
/* export functions are pre-instantiated */
for (i = 0; i < module_inst->export_func_count; i++) {
if (export_funcs[i].func_index == func_idx)
return &export_funcs[i];
}
exception_lock(module_inst);
/* allocate functions array if needed */
if (!extra->functions) {
uint64 func_count =
((uint64)module->import_func_count + module->func_count);
uint64 total_size = func_count * (uint64)sizeof(AOTFunctionInstance *);
if ((func_count == 0)
|| !(extra->functions = runtime_malloc(total_size, NULL, 0))) {
exception_unlock(module_inst);
return NULL;
}
extra->function_count = func_count;
}
/* instantiate function if needed */
bh_assert(func_idx < extra->function_count);
if (!extra->functions[func_idx]) {
AOTFunctionInstance *function = (AOTFunctionInstance *)runtime_malloc(
sizeof(AOTFunctionInstance), NULL, 0);
if (!function) {
exception_unlock(module_inst);
return NULL;
}
if (func_idx < module->import_func_count) {
/* instantiate function from import section */
function->is_import_func = true;
function->func_name = module->import_funcs[func_idx].func_name;
function->func_index = func_idx;
function->u.func_import = &module->import_funcs[func_idx];
}
else {
/* instantiate non-import function */
uint32 ftype_index =
module->func_type_indexes[func_idx - module->import_func_count];
function->is_import_func = false;
function->func_index = func_idx;
function->u.func.func_type =
(AOTFuncType *)module->types[ftype_index];
function->u.func.func_ptr =
module->func_ptrs[func_idx - module->import_func_count];
}
extra->functions[func_idx] = function;
}
exception_unlock(module_inst);
return extra->functions[func_idx];
}
static bool static bool
init_func_type_indexes(AOTModuleInstance *module_inst, AOTModule *module, init_func_type_indexes(AOTModuleInstance *module_inst, AOTModule *module,
char *error_buf, uint32 error_buf_size) char *error_buf, uint32 error_buf_size)
@ -1490,6 +1559,7 @@ aot_instantiate(AOTModule *module, AOTModuleInstance *parent,
#if WASM_ENABLE_BULK_MEMORY != 0 || WASM_ENABLE_REF_TYPES != 0 #if WASM_ENABLE_BULK_MEMORY != 0 || WASM_ENABLE_REF_TYPES != 0
WASMModuleInstanceExtraCommon *common; WASMModuleInstanceExtraCommon *common;
#endif #endif
AOTModuleInstanceExtra *extra = NULL;
const uint32 module_inst_struct_size = const uint32 module_inst_struct_size =
offsetof(AOTModuleInstance, global_table_data.bytes); offsetof(AOTModuleInstance, global_table_data.bytes);
const uint64 module_inst_mem_inst_size = const uint64 module_inst_mem_inst_size =
@ -1543,14 +1613,13 @@ aot_instantiate(AOTModule *module, AOTModuleInstance *parent,
module_inst->module = (void *)module; module_inst->module = (void *)module;
module_inst->e = module_inst->e =
(WASMModuleInstanceExtra *)((uint8 *)module_inst + extra_info_offset); (WASMModuleInstanceExtra *)((uint8 *)module_inst + extra_info_offset);
extra = (AOTModuleInstanceExtra *)module_inst->e;
#if WASM_ENABLE_GC != 0 #if WASM_ENABLE_GC != 0
/* Initialize gc heap first since it may be used when initializing /* Initialize gc heap first since it may be used when initializing
globals and others */ globals and others */
if (!is_sub_inst) { if (!is_sub_inst) {
uint32 gc_heap_size = wasm_runtime_get_gc_heap_size_default(); uint32 gc_heap_size = wasm_runtime_get_gc_heap_size_default();
AOTModuleInstanceExtra *extra =
(AOTModuleInstanceExtra *)module_inst->e;
if (gc_heap_size < GC_HEAP_SIZE_MIN) if (gc_heap_size < GC_HEAP_SIZE_MIN)
gc_heap_size = GC_HEAP_SIZE_MIN; gc_heap_size = GC_HEAP_SIZE_MIN;
@ -1570,8 +1639,7 @@ aot_instantiate(AOTModule *module, AOTModuleInstance *parent,
#endif #endif
#if WASM_ENABLE_MULTI_MODULE != 0 #if WASM_ENABLE_MULTI_MODULE != 0
((AOTModuleInstanceExtra *)module_inst->e)->sub_module_inst_list = extra->sub_module_inst_list = &extra->sub_module_inst_list_head;
&((AOTModuleInstanceExtra *)module_inst->e)->sub_module_inst_list_head;
ret = wasm_runtime_sub_module_instantiate( ret = wasm_runtime_sub_module_instantiate(
(WASMModuleCommon *)module, (WASMModuleInstanceCommon *)module_inst, (WASMModuleCommon *)module, (WASMModuleInstanceCommon *)module_inst,
stack_size, heap_size, max_memory_pages, error_buf, error_buf_size); stack_size, heap_size, max_memory_pages, error_buf, error_buf_size);
@ -1587,7 +1655,7 @@ aot_instantiate(AOTModule *module, AOTModuleInstance *parent,
goto fail; goto fail;
#if WASM_ENABLE_BULK_MEMORY != 0 || WASM_ENABLE_REF_TYPES != 0 #if WASM_ENABLE_BULK_MEMORY != 0 || WASM_ENABLE_REF_TYPES != 0
common = &((AOTModuleInstanceExtra *)module_inst->e)->common; common = &extra->common;
#endif #endif
#if WASM_ENABLE_BULK_MEMORY != 0 #if WASM_ENABLE_BULK_MEMORY != 0
if (module->mem_init_data_count > 0) { if (module->mem_init_data_count > 0) {
@ -1682,7 +1750,7 @@ aot_instantiate(AOTModule *module, AOTModuleInstance *parent,
#endif #endif
module_inst->default_wasm_stack_size = stack_size; module_inst->default_wasm_stack_size = stack_size;
((AOTModuleInstanceExtra *)module_inst->e)->stack_sizes = extra->stack_sizes =
aot_get_data_section_addr(module, AOT_STACK_SIZES_SECTION_NAME, NULL); aot_get_data_section_addr(module, AOT_STACK_SIZES_SECTION_NAME, NULL);
#if WASM_ENABLE_PERF_PROFILING != 0 #if WASM_ENABLE_PERF_PROFILING != 0
@ -1885,8 +1953,8 @@ destroy_c_api_frames(Vector *frames)
void void
aot_deinstantiate(AOTModuleInstance *module_inst, bool is_sub_inst) aot_deinstantiate(AOTModuleInstance *module_inst, bool is_sub_inst)
{ {
WASMModuleInstanceExtraCommon *common = AOTModuleInstanceExtra *extra = (AOTModuleInstanceExtra *)module_inst->e;
&((AOTModuleInstanceExtra *)module_inst->e)->common; WASMModuleInstanceExtraCommon *common = &extra->common;
if (module_inst->exec_env_singleton) { if (module_inst->exec_env_singleton) {
/* wasm_exec_env_destroy will call /* wasm_exec_env_destroy will call
wasm_cluster_wait_for_all_except_self to wait for other wasm_cluster_wait_for_all_except_self to wait for other
@ -1923,6 +1991,16 @@ aot_deinstantiate(AOTModuleInstance *module_inst, bool is_sub_inst)
if (module_inst->export_functions) if (module_inst->export_functions)
wasm_runtime_free(module_inst->export_functions); wasm_runtime_free(module_inst->export_functions);
if (extra->functions) {
uint32 func_idx;
for (func_idx = 0; func_idx < extra->function_count; ++func_idx) {
if (extra->functions[func_idx]) {
wasm_runtime_free(extra->functions[func_idx]);
}
}
wasm_runtime_free(extra->functions);
}
if (module_inst->func_ptrs) if (module_inst->func_ptrs)
wasm_runtime_free(module_inst->func_ptrs); wasm_runtime_free(module_inst->func_ptrs);
@ -1934,12 +2012,10 @@ aot_deinstantiate(AOTModuleInstance *module_inst, bool is_sub_inst)
#if WASM_ENABLE_GC != 0 #if WASM_ENABLE_GC != 0
if (!is_sub_inst) { if (!is_sub_inst) {
AOTModuleInstanceExtra *extra = if (common->gc_heap_handle)
(AOTModuleInstanceExtra *)module_inst->e; mem_allocator_destroy(common->gc_heap_handle);
if (extra->common.gc_heap_handle) if (common->gc_heap_pool)
mem_allocator_destroy(extra->common.gc_heap_handle); wasm_runtime_free(common->gc_heap_pool);
if (extra->common.gc_heap_pool)
wasm_runtime_free(extra->common.gc_heap_pool);
} }
#endif #endif
@ -2021,7 +2097,9 @@ invoke_native_with_hw_bound_check(WASMExecEnv *exec_env, void *func_ptr,
void (*invoke_native)(void *func_ptr, void *exec_env, uint32 *argv, void (*invoke_native)(void *func_ptr, void *exec_env, uint32 *argv,
uint32 *argv_ret) = uint32 *argv_ret) =
func_type->quick_aot_entry; func_type->quick_aot_entry;
exec_env->attachment = attachment;
invoke_native(func_ptr, exec_env, argv, argv_ret); invoke_native(func_ptr, exec_env, argv, argv_ret);
exec_env->attachment = NULL;
ret = !aot_copy_exception(module_inst, NULL); ret = !aot_copy_exception(module_inst, NULL);
} }
else else
@ -2099,6 +2177,7 @@ aot_call_function(WASMExecEnv *exec_env, AOTFunctionInstance *function,
unsigned argc, uint32 argv[]) unsigned argc, uint32 argv[])
{ {
AOTModuleInstance *module_inst = (AOTModuleInstance *)exec_env->module_inst; AOTModuleInstance *module_inst = (AOTModuleInstance *)exec_env->module_inst;
AOTModule *module = (AOTModule *)module_inst->module;
AOTFuncType *func_type = function->is_import_func AOTFuncType *func_type = function->is_import_func
? function->u.func_import->func_type ? function->u.func_import->func_type
: function->u.func.func_type; : function->u.func.func_type;
@ -2108,6 +2187,7 @@ aot_call_function(WASMExecEnv *exec_env, AOTFunctionInstance *function,
void *func_ptr = function->is_import_func void *func_ptr = function->is_import_func
? function->u.func_import->func_ptr_linked ? function->u.func_import->func_ptr_linked
: function->u.func.func_ptr; : function->u.func.func_ptr;
void *attachment = NULL;
#if WASM_ENABLE_MULTI_MODULE != 0 #if WASM_ENABLE_MULTI_MODULE != 0
bh_list *sub_module_list_node = NULL; bh_list *sub_module_list_node = NULL;
const char *sub_inst_name = NULL; const char *sub_inst_name = NULL;
@ -2167,6 +2247,10 @@ aot_call_function(WASMExecEnv *exec_env, AOTFunctionInstance *function,
hw bound check is enabled */ hw bound check is enabled */
#endif #endif
if (function->func_index < module->import_func_count) {
attachment = function->u.func_import->attachment;
}
/* Set exec env, so it can be later retrieved from instance */ /* Set exec env, so it can be later retrieved from instance */
module_inst->cur_exec_env = exec_env; module_inst->cur_exec_env = exec_env;
@ -2217,7 +2301,8 @@ aot_call_function(WASMExecEnv *exec_env, AOTFunctionInstance *function,
#endif #endif
ret = invoke_native_internal(exec_env, function->u.func.func_ptr, ret = invoke_native_internal(exec_env, function->u.func.func_ptr,
func_type, NULL, NULL, argv1, argc, argv); func_type, NULL, attachment, argv1, argc,
argv);
if (!ret) { if (!ret) {
#ifdef AOT_STACK_FRAME_DEBUG #ifdef AOT_STACK_FRAME_DEBUG
@ -2286,8 +2371,8 @@ aot_call_function(WASMExecEnv *exec_env, AOTFunctionInstance *function,
} }
#endif #endif
ret = invoke_native_internal(exec_env, func_ptr, func_type, NULL, NULL, ret = invoke_native_internal(exec_env, func_ptr, func_type, NULL,
argv, argc, argv); attachment, argv, argc, argv);
if (aot_copy_exception(module_inst, NULL)) { if (aot_copy_exception(module_inst, NULL)) {
#ifdef AOT_STACK_FRAME_DEBUG #ifdef AOT_STACK_FRAME_DEBUG
@ -2888,8 +2973,8 @@ aot_call_indirect(WASMExecEnv *exec_env, uint32 tbl_idx, uint32 table_elem_idx,
/* Call native function */ /* Call native function */
import_func = aot_module->import_funcs + func_idx; import_func = aot_module->import_funcs + func_idx;
signature = import_func->signature; signature = import_func->signature;
if (import_func->call_conv_raw) {
attachment = import_func->attachment; attachment = import_func->attachment;
if (import_func->call_conv_raw) {
ret = wasm_runtime_invoke_native_raw(exec_env, func_ptr, func_type, ret = wasm_runtime_invoke_native_raw(exec_env, func_ptr, func_type,
signature, attachment, argv, signature, attachment, argv,
argc, argv); argc, argv);

13
core/iwasm/aot/aot_runtime.h
View File

@ -104,6 +104,8 @@ typedef struct AOTFunctionInstance {
typedef struct AOTModuleInstanceExtra { typedef struct AOTModuleInstanceExtra {
DefPointer(const uint32 *, stack_sizes); DefPointer(const uint32 *, stack_sizes);
WASMModuleInstanceExtraCommon common; WASMModuleInstanceExtraCommon common;
AOTFunctionInstance **functions;
uint32 function_count;
#if WASM_ENABLE_MULTI_MODULE != 0 #if WASM_ENABLE_MULTI_MODULE != 0
bh_list sub_module_inst_list_head; bh_list sub_module_inst_list_head;
bh_list *sub_module_inst_list; bh_list *sub_module_inst_list;
@ -507,6 +509,17 @@ aot_deinstantiate(AOTModuleInstance *module_inst, bool is_sub_inst);
AOTFunctionInstance * AOTFunctionInstance *
aot_lookup_function(const AOTModuleInstance *module_inst, const char *name); aot_lookup_function(const AOTModuleInstance *module_inst, const char *name);
/**
* Get a function in the AOT module instance.
*
* @param module_inst the module instance
* @param func_idx the index of the function
*
* @return the function instance found
*/
AOTFunctionInstance *
aot_get_function_instance(AOTModuleInstance *module_inst, uint32_t func_idx);
/** /**
* Call the given AOT function of a AOT module instance with * Call the given AOT function of a AOT module instance with
* arguments. * arguments.

16
core/iwasm/common/wasm_c_api.c
View File

@ -2620,9 +2620,9 @@ wasm_module_imports(const wasm_module_t *module, own wasm_importtype_vec_t *out)
- import_memory_count); - import_memory_count);
module_name_rt = import->u.names.module_name; module_name_rt = import->u.names.module_name;
field_name_rt = import->u.names.field_name; field_name_rt = import->u.names.field_name;
elem_type_rt = import->u.table.elem_type; elem_type_rt = import->u.table.table_type.elem_type;
min_size = import->u.table.init_size; min_size = import->u.table.table_type.init_size;
max_size = import->u.table.max_size; max_size = import->u.table.table_type.max_size;
} }
#endif #endif
@ -2634,9 +2634,9 @@ wasm_module_imports(const wasm_module_t *module, own wasm_importtype_vec_t *out)
- import_memory_count); - import_memory_count);
module_name_rt = import->module_name; module_name_rt = import->module_name;
field_name_rt = import->table_name; field_name_rt = import->table_name;
elem_type_rt = import->elem_type; elem_type_rt = import->table_type.elem_type;
min_size = import->table_init_size; min_size = import->table_type.init_size;
max_size = import->table_max_size; max_size = import->table_type.max_size;
} }
#endif #endif
@ -4195,13 +4195,13 @@ wasm_table_size(const wasm_table_t *table)
if (table->table_idx_rt < module_aot->import_table_count) { if (table->table_idx_rt < module_aot->import_table_count) {
AOTImportTable *table_aot = AOTImportTable *table_aot =
module_aot->import_tables + table->table_idx_rt; module_aot->import_tables + table->table_idx_rt;
return table_aot->table_init_size; return table_aot->table_type.init_size;
} }
else { else {
AOTTable *table_aot = AOTTable *table_aot =
module_aot->tables module_aot->tables
+ (table->table_idx_rt - module_aot->import_table_count); + (table->table_idx_rt - module_aot->import_table_count);
return table_aot->table_init_size; return table_aot->table_type.init_size;
} }
} }
#endif #endif

188
core/iwasm/common/wasm_runtime_common.c
View File

@ -1966,6 +1966,118 @@ wasm_runtime_get_export_global_inst(WASMModuleInstanceCommon *const module_inst,
return false; return false;
} }
bool
wasm_runtime_get_export_table_inst(WASMModuleInstanceCommon *const module_inst,
char const *name,
wasm_table_inst_t *table_inst)
{
#if WASM_ENABLE_INTERP != 0
if (module_inst->module_type == Wasm_Module_Bytecode) {
const WASMModuleInstance *wasm_module_inst =
(const WASMModuleInstance *)module_inst;
const WASMModule *wasm_module = wasm_module_inst->module;
uint32 i;
for (i = 0; i < wasm_module->export_count; i++) {
const WASMExport *wasm_export = &wasm_module->exports[i];
if ((wasm_export->kind == WASM_IMPORT_EXPORT_KIND_TABLE)
&& !strcmp(wasm_export->name, name)) {
const WASMTableInstance *wasm_table_inst =
wasm_module_inst->tables[wasm_export->index];
table_inst->elem_kind =
val_type_to_val_kind(wasm_table_inst->elem_type);
table_inst->cur_size = wasm_table_inst->cur_size;
table_inst->max_size = wasm_table_inst->max_size;
table_inst->elems = (void *)wasm_table_inst->elems;
return true;
}
}
}
#endif
#if WASM_ENABLE_AOT != 0
if (module_inst->module_type == Wasm_Module_AoT) {
const AOTModuleInstance *aot_module_inst =
(AOTModuleInstance *)module_inst;
const AOTModule *aot_module = (AOTModule *)aot_module_inst->module;
uint32 i;
for (i = 0; i < aot_module->export_count; i++) {
const AOTExport *aot_export = &aot_module->exports[i];
if ((aot_export->kind == WASM_IMPORT_EXPORT_KIND_TABLE)
&& !strcmp(aot_export->name, name)) {
const AOTTableInstance *aot_table_inst =
aot_module_inst->tables[aot_export->index];
table_inst->elem_kind =
val_type_to_val_kind(aot_table_inst->elem_type);
table_inst->cur_size = aot_table_inst->cur_size;
table_inst->max_size = aot_table_inst->max_size;
table_inst->elems = (void *)aot_table_inst->elems;
return true;
}
}
}
#endif
return false;
}
WASMFunctionInstanceCommon *
wasm_table_get_func_inst(struct WASMModuleInstanceCommon *const module_inst,
const wasm_table_inst_t *table_inst, uint32_t idx)
{
if (!table_inst) {
bh_assert(0);
return NULL;
}
if (idx >= table_inst->cur_size) {
bh_assert(0);
return NULL;
}
#if WASM_ENABLE_INTERP != 0
if (module_inst->module_type == Wasm_Module_Bytecode) {
const WASMModuleInstance *wasm_module_inst =
(const WASMModuleInstance *)module_inst;
table_elem_type_t tbl_elem_val =
((table_elem_type_t *)table_inst->elems)[idx];
if (tbl_elem_val == NULL_REF) {
return NULL;
}
#if WASM_ENABLE_GC == 0
uint32 func_idx = (uint32)tbl_elem_val;
#else
uint32 func_idx =
wasm_func_obj_get_func_idx_bound((WASMFuncObjectRef)tbl_elem_val);
#endif
bh_assert(func_idx < wasm_module_inst->e->function_count);
return wasm_module_inst->e->functions + func_idx;
}
#endif
#if WASM_ENABLE_AOT != 0
if (module_inst->module_type == Wasm_Module_AoT) {
AOTModuleInstance *aot_module_inst = (AOTModuleInstance *)module_inst;
uint32 func_idx;
table_elem_type_t tbl_elem_val =
((table_elem_type_t *)table_inst->elems)[idx];
if (tbl_elem_val == NULL_REF) {
return NULL;
}
#if WASM_ENABLE_GC == 0
func_idx = (uint32)tbl_elem_val;
#else
func_idx =
wasm_func_obj_get_func_idx_bound((WASMFuncObjectRef)tbl_elem_val);
#endif
return aot_get_function_instance(aot_module_inst, func_idx);
}
#endif
return NULL;
}
void * void *
wasm_runtime_get_function_attachment(WASMExecEnv *exec_env) wasm_runtime_get_function_attachment(WASMExecEnv *exec_env)
{ {
@ -3899,6 +4011,8 @@ wasm_runtime_get_import_type(WASMModuleCommon *const module, int32 import_index,
import_type->name = aot_import_table->table_name; import_type->name = aot_import_table->table_name;
import_type->kind = WASM_IMPORT_EXPORT_KIND_TABLE; import_type->kind = WASM_IMPORT_EXPORT_KIND_TABLE;
import_type->linked = false; import_type->linked = false;
import_type->u.table_type =
(WASMTableType *)&aot_import_table->table_type;
return; return;
} }
@ -3946,6 +4060,8 @@ wasm_runtime_get_import_type(WASMModuleCommon *const module, int32 import_index,
break; break;
case WASM_IMPORT_EXPORT_KIND_TABLE: case WASM_IMPORT_EXPORT_KIND_TABLE:
import_type->linked = false; /* not supported */ import_type->linked = false; /* not supported */
import_type->u.table_type =
(WASMTableType *)&wasm_import->u.table.table_type;
break; break;
case WASM_IMPORT_EXPORT_KIND_MEMORY: case WASM_IMPORT_EXPORT_KIND_MEMORY:
import_type->linked = false; /* not supported */ import_type->linked = false; /* not supported */
@ -4030,6 +4146,11 @@ wasm_runtime_get_export_type(WASMModuleCommon *const module, int32 export_index,
.type; .type;
break; break;
case WASM_IMPORT_EXPORT_KIND_TABLE: case WASM_IMPORT_EXPORT_KIND_TABLE:
export_type->u.table_type =
&aot_module
->tables[aot_export->index
- aot_module->import_table_count]
.table_type;
break; break;
case WASM_IMPORT_EXPORT_KIND_MEMORY: case WASM_IMPORT_EXPORT_KIND_MEMORY:
export_type->u.memory_type = export_type->u.memory_type =
@ -4071,6 +4192,11 @@ wasm_runtime_get_export_type(WASMModuleCommon *const module, int32 export_index,
.type; .type;
break; break;
case WASM_IMPORT_EXPORT_KIND_TABLE: case WASM_IMPORT_EXPORT_KIND_TABLE:
export_type->u.table_type =
&wasm_module
->tables[wasm_export->index
- wasm_module->import_table_count]
.table_type;
break; break;
case WASM_IMPORT_EXPORT_KIND_MEMORY: case WASM_IMPORT_EXPORT_KIND_MEMORY:
export_type->u.memory_type = export_type->u.memory_type =
@ -4212,6 +4338,38 @@ wasm_memory_type_get_max_page_count(WASMMemoryType *const memory_type)
return memory_type->max_page_count; return memory_type->max_page_count;
} }
wasm_valkind_t
wasm_table_type_get_elem_kind(WASMTableType *const table_type)
{
bh_assert(table_type);
return val_type_to_val_kind(table_type->elem_type);
}
bool
wasm_table_type_get_shared(WASMTableType *const table_type)
{
bh_assert(table_type);
return (table_type->flags & 2) ? true : false;
}
uint32
wasm_table_type_get_init_size(WASMTableType *const table_type)
{
bh_assert(table_type);
return table_type->init_size;
}
uint32
wasm_table_type_get_max_size(WASMTableType *const table_type)
{
bh_assert(table_type);
return table_type->max_size;
}
bool bool
wasm_runtime_register_natives(const char *module_name, wasm_runtime_register_natives(const char *module_name,
NativeSymbol *native_symbols, NativeSymbol *native_symbols,
@ -6178,7 +6336,7 @@ aot_mark_all_externrefs(AOTModuleInstance *module_inst)
for (i = 0; i < module->table_count; i++) { for (i = 0; i < module->table_count; i++) {
table_inst = module_inst->tables[i]; table_inst = module_inst->tables[i];
if ((table + i)->elem_type == VALUE_TYPE_EXTERNREF) { if ((table + i)->table_type.elem_type == VALUE_TYPE_EXTERNREF) {
while (j < table_inst->cur_size) { while (j < table_inst->cur_size) {
mark_externref(table_inst->elems[j++]); mark_externref(table_inst->elems[j++]);
} }
@ -6374,22 +6532,22 @@ wasm_runtime_get_table_elem_type(const WASMModuleCommon *module_comm,
if (table_idx < module->import_table_count) { if (table_idx < module->import_table_count) {
WASMTableImport *import_table = WASMTableImport *import_table =
&((module->import_tables + table_idx)->u.table); &((module->import_tables + table_idx)->u.table);
*out_elem_type = import_table->elem_type; *out_elem_type = import_table->table_type.elem_type;
#if WASM_ENABLE_GC != 0 #if WASM_ENABLE_GC != 0
*out_ref_type = import_table->elem_ref_type; *out_ref_type = import_table->table_type.elem_ref_type;
#endif #endif
*out_min_size = import_table->init_size; *out_min_size = import_table->table_type.init_size;
*out_max_size = import_table->max_size; *out_max_size = import_table->table_type.max_size;
} }
else { else {
WASMTable *table = WASMTable *table =
module->tables + (table_idx - module->import_table_count); module->tables + (table_idx - module->import_table_count);
*out_elem_type = table->elem_type; *out_elem_type = table->table_type.elem_type;
#if WASM_ENABLE_GC != 0 #if WASM_ENABLE_GC != 0
*out_ref_type = table->elem_ref_type; *out_ref_type = table->table_type.elem_ref_type;
#endif #endif
*out_min_size = table->init_size; *out_min_size = table->table_type.init_size;
*out_max_size = table->max_size; *out_max_size = table->table_type.max_size;
} }
return true; return true;
} }
@ -6401,22 +6559,22 @@ wasm_runtime_get_table_elem_type(const WASMModuleCommon *module_comm,
if (table_idx < module->import_table_count) { if (table_idx < module->import_table_count) {
AOTImportTable *import_table = module->import_tables + table_idx; AOTImportTable *import_table = module->import_tables + table_idx;
*out_elem_type = import_table->elem_type; *out_elem_type = import_table->table_type.elem_type;
#if WASM_ENABLE_GC != 0 #if WASM_ENABLE_GC != 0
*out_ref_type = NULL; /* TODO */ *out_ref_type = NULL; /* TODO */
#endif #endif
*out_min_size = import_table->table_init_size; *out_min_size = import_table->table_type.init_size;
*out_max_size = import_table->table_max_size; *out_max_size = import_table->table_type.max_size;
} }
else { else {
AOTTable *table = AOTTable *table =
module->tables + (table_idx - module->import_table_count); module->tables + (table_idx - module->import_table_count);
*out_elem_type = table->elem_type; *out_elem_type = table->table_type.elem_type;
#if WASM_ENABLE_GC != 0 #if WASM_ENABLE_GC != 0
*out_ref_type = NULL; /* TODO */ *out_ref_type = NULL; /* TODO */
#endif #endif
*out_min_size = table->table_init_size; *out_min_size = table->table_type.init_size;
*out_max_size = table->table_max_size; *out_max_size = table->table_type.max_size;
} }
return true; return true;
} }

46
core/iwasm/compilation/aot.c
View File

@ -599,34 +599,36 @@ aot_create_comp_data(WASMModule *module, const char *target_arch,
memset(comp_data->tables, 0, size); memset(comp_data->tables, 0, size);
for (i = 0; i < comp_data->table_count; i++) { for (i = 0; i < comp_data->table_count; i++) {
if (i < module->import_table_count) { if (i < module->import_table_count) {
comp_data->tables[i].elem_type = comp_data->tables[i].table_type.elem_type =
module->import_tables[i].u.table.elem_type; module->import_tables[i].u.table.table_type.elem_type;
comp_data->tables[i].table_flags = comp_data->tables[i].table_type.flags =
module->import_tables[i].u.table.flags; module->import_tables[i].u.table.table_type.flags;
comp_data->tables[i].table_init_size = comp_data->tables[i].table_type.init_size =
module->import_tables[i].u.table.init_size; module->import_tables[i].u.table.table_type.init_size;
comp_data->tables[i].table_max_size = comp_data->tables[i].table_type.max_size =
module->import_tables[i].u.table.max_size; module->import_tables[i].u.table.table_type.max_size;
#if WASM_ENABLE_GC != 0 #if WASM_ENABLE_GC != 0
comp_data->tables[i].elem_ref_type = comp_data->tables[i].table_type.elem_ref_type =
module->import_tables[i].u.table.elem_ref_type; module->import_tables[i].u.table.table_type.elem_ref_type;
#endif #endif
comp_data->tables[i].possible_grow = comp_data->tables[i].table_type.possible_grow =
module->import_tables[i].u.table.possible_grow; module->import_tables[i].u.table.table_type.possible_grow;
} }
else { else {
j = i - module->import_table_count; j = i - module->import_table_count;
comp_data->tables[i].elem_type = module->tables[j].elem_type; comp_data->tables[i].table_type.elem_type =
comp_data->tables[i].table_flags = module->tables[j].flags; module->tables[j].table_type.elem_type;
comp_data->tables[i].table_init_size = comp_data->tables[i].table_type.flags =
module->tables[j].init_size; module->tables[j].table_type.flags;
comp_data->tables[i].table_max_size = comp_data->tables[i].table_type.init_size =
module->tables[j].max_size; module->tables[j].table_type.init_size;
comp_data->tables[i].possible_grow = comp_data->tables[i].table_type.max_size =
module->tables[j].possible_grow; module->tables[j].table_type.max_size;
comp_data->tables[i].table_type.possible_grow =
module->tables[j].table_type.possible_grow;
#if WASM_ENABLE_GC != 0 #if WASM_ENABLE_GC != 0
comp_data->tables[j].elem_ref_type = comp_data->tables[j].table_type.elem_ref_type =
module->tables[j].elem_ref_type; module->tables[j].table_type.elem_ref_type;
/* Note: if the init_expr contains extra data for struct/array /* Note: if the init_expr contains extra data for struct/array
* initialization information (init_expr.u.data), the pointer is * initialization information (init_expr.u.data), the pointer is
* copied. * copied.

37
core/iwasm/compilation/aot.h
View File

@ -48,6 +48,8 @@ typedef WASMArrayType AOTArrayType;
typedef WASMExport AOTExport; typedef WASMExport AOTExport;
typedef WASMMemory AOTMemory; typedef WASMMemory AOTMemory;
typedef WASMMemoryType AOTMemoryType; typedef WASMMemoryType AOTMemoryType;
typedef WASMTableType AOTTableType;
typedef WASMTable AOTTable;
#if WASM_ENABLE_DEBUG_AOT != 0 #if WASM_ENABLE_DEBUG_AOT != 0
typedef void *dwarf_extractor_handle_t; typedef void *dwarf_extractor_handle_t;
@ -110,32 +112,9 @@ typedef struct AOTMemInitData {
typedef struct AOTImportTable { typedef struct AOTImportTable {
char *module_name; char *module_name;
char *table_name; char *table_name;
uint8 elem_type; AOTTableType table_type;
uint8 table_flags;
bool possible_grow;
uint32 table_init_size;
uint32 table_max_size;
#if WASM_ENABLE_GC != 0
WASMRefType *elem_ref_type;
#endif
} AOTImportTable; } AOTImportTable;
/**
* Table
*/
typedef struct AOTTable {
uint8 elem_type;
uint8 table_flags;
bool possible_grow;
uint32 table_init_size;
uint32 table_max_size;
#if WASM_ENABLE_GC != 0
WASMRefType *elem_ref_type;
/* init expr for the whole table */
InitializerExpression init_expr;
#endif
} AOTTable;
/** /**
* A segment of table init data * A segment of table init data
*/ */
@ -359,11 +338,12 @@ aot_get_imp_tbl_data_slots(const AOTImportTable *tbl, bool is_jit_mode)
{ {
#if WASM_ENABLE_MULTI_MODULE != 0 #if WASM_ENABLE_MULTI_MODULE != 0
if (is_jit_mode) if (is_jit_mode)
return tbl->table_max_size; return tbl->table_type.max_size;
#else #else
(void)is_jit_mode; (void)is_jit_mode;
#endif #endif
return tbl->possible_grow ? tbl->table_max_size : tbl->table_init_size; return tbl->table_type.possible_grow ? tbl->table_type.max_size
: tbl->table_type.init_size;
} }
static inline uint32 static inline uint32
@ -371,11 +351,12 @@ aot_get_tbl_data_slots(const AOTTable *tbl, bool is_jit_mode)
{ {
#if WASM_ENABLE_MULTI_MODULE != 0 #if WASM_ENABLE_MULTI_MODULE != 0
if (is_jit_mode) if (is_jit_mode)
return tbl->table_max_size; return tbl->table_type.max_size;
#else #else
(void)is_jit_mode; (void)is_jit_mode;
#endif #endif
return tbl->possible_grow ? tbl->table_max_size : tbl->table_init_size; return tbl->table_type.possible_grow ? tbl->table_type.max_size
: tbl->table_type.init_size;
} }
#ifdef __cplusplus #ifdef __cplusplus

60
core/iwasm/compilation/aot_emit_aot_file.c
View File

@ -383,11 +383,11 @@ get_import_table_size(const AOTCompContext *comp_ctx,
* | import_table_count * | import_table_count
* ------------------------------ * ------------------------------
* | | U8 elem_type * | | U8 elem_type
* | | U8 table_flags * | | U8 flags
* | | U8 possible_grow * | | U8 possible_grow
* | AOTImportTable[N] | U8 elem_ref_type.nullable (for GC only) * | AOTImportTable[N] | U8 elem_ref_type.nullable (for GC only)
* | | U32 table_init_size * | | U32 init_size
* | | U32 table_max_size * | | U32 max_size
* | | U32 elem_ref_type.heap_type (for GC only) * | | U32 elem_ref_type.heap_type (for GC only)
* ------------------------------ * ------------------------------
*/ */
@ -397,7 +397,8 @@ get_import_table_size(const AOTCompContext *comp_ctx,
for (i = 0; i < comp_data->import_table_count; i++) { for (i = 0; i < comp_data->import_table_count; i++) {
size += sizeof(uint32) * 3; size += sizeof(uint32) * 3;
#if WASM_ENABLE_GC != 0 #if WASM_ENABLE_GC != 0
if (comp_ctx->enable_gc && comp_data->import_tables[i].elem_ref_type) if (comp_ctx->enable_gc
&& comp_data->import_tables[i].table_type.elem_ref_type)
size += sizeof(uint32); size += sizeof(uint32);
#endif #endif
} }
@ -412,11 +413,11 @@ get_table_size(const AOTCompContext *comp_ctx, const AOTCompData *comp_data)
* | table_count * | table_count
* ------------------------------ * ------------------------------
* | | U8 elem_type * | | U8 elem_type
* | | U8 table_flags * | | U8 flags
* | | U8 possible_grow * | | U8 possible_grow
* | AOTTable[N] | U8 elem_ref_type.nullable (for GC only) * | AOTTable[N] | U8 elem_ref_type.nullable (for GC only)
* | | U32 table_init_size * | | U32 init_size
* | | U32 table_max_size * | | U32 max_size
* | | U32 elem_ref_type.heap_type (for GC only) * | | U32 elem_ref_type.heap_type (for GC only)
* | | N init_expr (for GC only) * | | N init_expr (for GC only)
* ------------------------------ * ------------------------------
@ -428,7 +429,7 @@ get_table_size(const AOTCompContext *comp_ctx, const AOTCompData *comp_data)
size += sizeof(uint32) * 3; size += sizeof(uint32) * 3;
#if WASM_ENABLE_GC != 0 #if WASM_ENABLE_GC != 0
if (comp_ctx->enable_gc) { if (comp_ctx->enable_gc) {
if (comp_data->tables[i].elem_ref_type) { if (comp_data->tables[i].table_type.elem_ref_type) {
size += sizeof(uint32); size += sizeof(uint32);
} }
size += get_init_expr_size(comp_ctx, comp_data, size += get_init_expr_size(comp_ctx, comp_data,
@ -1955,13 +1956,14 @@ aot_emit_table_info(uint8 *buf, uint8 *buf_end, uint32 *p_offset,
* EMIT_STR(comp_data->import_tables[i].module_name ); * EMIT_STR(comp_data->import_tables[i].module_name );
* EMIT_STR(comp_data->import_tables[i].table_name); * EMIT_STR(comp_data->import_tables[i].table_name);
*/ */
EMIT_U8(comp_data->import_tables[i].elem_type); EMIT_U8(comp_data->import_tables[i].table_type.elem_type);
EMIT_U8(comp_data->import_tables[i].table_flags); EMIT_U8(comp_data->import_tables[i].table_type.flags);
EMIT_U8(comp_data->import_tables[i].possible_grow); EMIT_U8(comp_data->import_tables[i].table_type.possible_grow);
#if WASM_ENABLE_GC != 0 #if WASM_ENABLE_GC != 0
if (comp_ctx->enable_gc && comp_data->import_tables[i].elem_ref_type) { if (comp_ctx->enable_gc
&& comp_data->import_tables[i].table_type.elem_ref_type) {
EMIT_U8(comp_data->import_tables[i] EMIT_U8(comp_data->import_tables[i]
.elem_ref_type->ref_ht_common.nullable); .table_type.elem_ref_type->ref_ht_common.nullable);
} }
else else
#endif #endif
@ -1969,14 +1971,15 @@ aot_emit_table_info(uint8 *buf, uint8 *buf_end, uint32 *p_offset,
/* emit one placeholder to keep the same size */ /* emit one placeholder to keep the same size */
EMIT_U8(0); EMIT_U8(0);
} }
EMIT_U32(comp_data->import_tables[i].table_init_size); EMIT_U32(comp_data->import_tables[i].table_type.init_size);
EMIT_U32(comp_data->import_tables[i].table_max_size); EMIT_U32(comp_data->import_tables[i].table_type.max_size);
#if WASM_ENABLE_GC != 0 #if WASM_ENABLE_GC != 0
if (comp_ctx->enable_gc && comp_data->import_tables[i].elem_ref_type) { if (comp_ctx->enable_gc
&& comp_data->import_tables[i].table_type.elem_ref_type) {
bh_assert(wasm_is_type_multi_byte_type( bh_assert(wasm_is_type_multi_byte_type(
comp_data->import_tables[i].elem_type)); comp_data->import_tables[i].elem_type));
EMIT_U32(comp_data->import_tables[i] EMIT_U32(comp_data->import_tables[i]
.elem_ref_type->ref_ht_common.heap_type); .table_type.elem_ref_type->ref_ht_common.heap_type);
} }
#endif #endif
} }
@ -1985,12 +1988,14 @@ aot_emit_table_info(uint8 *buf, uint8 *buf_end, uint32 *p_offset,
EMIT_U32(comp_data->table_count); EMIT_U32(comp_data->table_count);
/* Emit table items */ /* Emit table items */
for (i = 0; i < comp_data->table_count; i++) { for (i = 0; i < comp_data->table_count; i++) {
EMIT_U8(comp_data->tables[i].elem_type); EMIT_U8(comp_data->tables[i].table_type.elem_type);
EMIT_U8(comp_data->tables[i].table_flags); EMIT_U8(comp_data->tables[i].table_type.flags);
EMIT_U8(comp_data->tables[i].possible_grow); EMIT_U8(comp_data->tables[i].table_type.possible_grow);
#if WASM_ENABLE_GC != 0 #if WASM_ENABLE_GC != 0
if (comp_ctx->enable_gc && comp_data->tables[i].elem_ref_type) { if (comp_ctx->enable_gc
EMIT_U8(comp_data->tables[i].elem_ref_type->ref_ht_common.nullable); && comp_data->tables[i].table_type.elem_ref_type) {
EMIT_U8(comp_data->tables[i]
.table_type.elem_ref_type->ref_ht_common.nullable);
} }
else else
#endif #endif
@ -1998,15 +2003,16 @@ aot_emit_table_info(uint8 *buf, uint8 *buf_end, uint32 *p_offset,
/* emit one placeholder to keep the same size */ /* emit one placeholder to keep the same size */
EMIT_U8(0); EMIT_U8(0);
} }
EMIT_U32(comp_data->tables[i].table_init_size); EMIT_U32(comp_data->tables[i].table_type.init_size);
EMIT_U32(comp_data->tables[i].table_max_size); EMIT_U32(comp_data->tables[i].table_type.max_size);
#if WASM_ENABLE_GC != 0 #if WASM_ENABLE_GC != 0
if (comp_ctx->enable_gc) { if (comp_ctx->enable_gc) {
if (comp_data->tables[i].elem_ref_type) { if (comp_data->tables[i].table_type.elem_ref_type) {
bh_assert(wasm_is_type_multi_byte_type( bh_assert(wasm_is_type_multi_byte_type(
comp_data->tables[i].elem_type)); comp_data->tables[i].elem_type));
EMIT_U32(comp_data->tables[i] EMIT_U32(
.elem_ref_type->ref_ht_common.heap_type); comp_data->tables[i]
.table_type.elem_ref_type->ref_ht_common.heap_type);
} }
if (!aot_emit_init_expr(buf, buf_end, &offset, comp_ctx, if (!aot_emit_init_expr(buf, buf_end, &offset, comp_ctx,
&comp_data->tables[i].init_expr)) { &comp_data->tables[i].init_expr)) {

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

@ -76,11 +76,12 @@ jit_frontend_get_table_inst_offset(const WASMModule *module, uint32 tbl_idx)
offset += (uint32)offsetof(WASMTableInstance, elems); offset += (uint32)offsetof(WASMTableInstance, elems);
#if WASM_ENABLE_MULTI_MODULE != 0 #if WASM_ENABLE_MULTI_MODULE != 0
offset += (uint32)sizeof(uint32) * import_table->max_size; offset += (uint32)sizeof(uint32) * import_table->table_type.max_size;
#else #else
offset += (uint32)sizeof(uint32) offset += (uint32)sizeof(uint32)
* (import_table->possible_grow ? import_table->max_size * (import_table->table_type.possible_grow
: import_table->init_size); ? import_table->table_type.max_size
: import_table->table_type.init_size);
#endif #endif
i++; i++;
@ -97,10 +98,13 @@ jit_frontend_get_table_inst_offset(const WASMModule *module, uint32 tbl_idx)
offset += (uint32)offsetof(WASMTableInstance, elems); offset += (uint32)offsetof(WASMTableInstance, elems);
#if WASM_ENABLE_MULTI_MODULE != 0 #if WASM_ENABLE_MULTI_MODULE != 0
offset += (uint32)sizeof(table_elem_type_t) * table->max_size; offset +=
(uint32)sizeof(table_elem_type_t) * table->table_type.max_size;
#else #else
offset += (uint32)sizeof(table_elem_type_t) offset +=
* (table->possible_grow ? table->max_size : table->init_size); (uint32)sizeof(table_elem_type_t)
* (table->table_type.possible_grow ? table->table_type.max_size
: table->table_type.init_size);
#endif #endif
i++; i++;

82
core/iwasm/include/wasm_export.h
View File

@ -75,6 +75,9 @@ typedef enum {
struct WASMFuncType; struct WASMFuncType;
typedef struct WASMFuncType *wasm_func_type_t; typedef struct WASMFuncType *wasm_func_type_t;
struct WASMTableType;
typedef struct WASMTableType *wasm_table_type_t;
struct WASMGlobalType; struct WASMGlobalType;
typedef struct WASMGlobalType *wasm_global_type_t; typedef struct WASMGlobalType *wasm_global_type_t;
@ -89,6 +92,7 @@ typedef struct wasm_import_t {
bool linked; bool linked;
union { union {
wasm_func_type_t func_type; wasm_func_type_t func_type;
wasm_table_type_t table_type;
wasm_global_type_t global_type; wasm_global_type_t global_type;
wasm_memory_type_t memory_type; wasm_memory_type_t memory_type;
} u; } u;
@ -99,6 +103,7 @@ typedef struct wasm_export_t {
wasm_import_export_kind_t kind; wasm_import_export_kind_t kind;
union { union {
wasm_func_type_t func_type; wasm_func_type_t func_type;
wasm_table_type_t table_type;
wasm_global_type_t global_type; wasm_global_type_t global_type;
wasm_memory_type_t memory_type; wasm_memory_type_t memory_type;
} u; } u;
@ -295,6 +300,15 @@ typedef struct wasm_global_inst_t {
void *global_data; void *global_data;
} wasm_global_inst_t; } wasm_global_inst_t;
/* Table instance*/
typedef struct wasm_table_inst_t {
wasm_valkind_t elem_kind;
uint32_t cur_size;
uint32_t max_size;
/* represents the elements of the table, for internal use only */
void *elems;
} wasm_table_inst_t;
typedef enum { typedef enum {
WASM_LOG_LEVEL_FATAL = 0, WASM_LOG_LEVEL_FATAL = 0,
WASM_LOG_LEVEL_ERROR = 1, WASM_LOG_LEVEL_ERROR = 1,
@ -1386,6 +1400,46 @@ wasm_memory_type_get_init_page_count(const wasm_memory_type_t memory_type);
WASM_RUNTIME_API_EXTERN uint32_t WASM_RUNTIME_API_EXTERN uint32_t
wasm_memory_type_get_max_page_count(const wasm_memory_type_t memory_type); wasm_memory_type_get_max_page_count(const wasm_memory_type_t memory_type);
/**
* Get the element kind for a table type
*
* @param table_type the table type
*
* @return the element kind
*/
WASM_RUNTIME_API_EXTERN wasm_valkind_t
wasm_table_type_get_elem_kind(const wasm_table_type_t table_type);
/**
* Get the sharing setting for a table type
*
* @param table_type the table type
*
* @return true if shared, false otherwise
*/
WASM_RUNTIME_API_EXTERN bool
wasm_table_type_get_shared(const wasm_table_type_t table_type);
/**
* Get the initial size for a table type
*
* @param table_type the table type
*
* @return the initial table size
*/
WASM_RUNTIME_API_EXTERN uint32_t
wasm_table_type_get_init_size(const wasm_table_type_t table_type);
/**
* Get the maximum size for a table type
*
* @param table_type the table type
*
* @return the maximum table size
*/
WASM_RUNTIME_API_EXTERN uint32_t
wasm_table_type_get_max_size(const wasm_table_type_t table_type);
/** /**
* Register native functions with same module name * Register native functions with same module name
* *
@ -1472,6 +1526,34 @@ wasm_runtime_get_export_global_inst(const wasm_module_inst_t module_inst,
const char *name, const char *name,
wasm_global_inst_t *global_inst); wasm_global_inst_t *global_inst);
/**
* Get an export table instance
*
* @param module_inst the module instance
* @param name the export table name
* @param table_inst location to store the table instance
*
* @return true if success, false otherwise
*
*/
WASM_RUNTIME_API_EXTERN bool
wasm_runtime_get_export_table_inst(const wasm_module_inst_t module_inst,
const char *name,
wasm_table_inst_t *table_inst);
/**
* Get a function instance from a table.
*
* @param module_inst the module instance
* @param table_inst the table instance
* @param idx the index in the table
*
* @return the function instance if successful, NULL otherwise
*/
WASM_RUNTIME_API_EXTERN wasm_function_inst_t
wasm_table_get_func_inst(const wasm_module_inst_t module_inst,
const wasm_table_inst_t *table_inst, uint32_t idx);
/** /**
* Get attachment of native function from execution environment * Get attachment of native function from execution environment
* *

21
core/iwasm/interpreter/wasm.h
View File

@ -480,11 +480,11 @@ typedef void *WASMString;
#endif /* end of WASM_ENABLE_STRINGREF != 0 */ #endif /* end of WASM_ENABLE_STRINGREF != 0 */
#endif /* end of WASM_ENABLE_GC != 0 */ #endif /* end of WASM_ENABLE_GC != 0 */
typedef struct WASMTable { typedef struct WASMTableType {
uint8 elem_type; uint8 elem_type;
/** /**
* 0: no max size and not shared * 0: no max size and not shared
* 1: hax max size * 1: has max size
* 2: shared * 2: shared
*/ */
uint8 flags; uint8 flags;
@ -494,6 +494,12 @@ typedef struct WASMTable {
uint32 max_size; uint32 max_size;
#if WASM_ENABLE_GC != 0 #if WASM_ENABLE_GC != 0
WASMRefType *elem_ref_type; WASMRefType *elem_ref_type;
#endif
} WASMTableType;
typedef struct WASMTable {
WASMTableType table_type;
#if WASM_ENABLE_GC != 0
/* init expr for the whole table */ /* init expr for the whole table */
InitializerExpression init_expr; InitializerExpression init_expr;
#endif #endif
@ -517,16 +523,7 @@ typedef struct WASMMemory {
typedef struct WASMTableImport { typedef struct WASMTableImport {
char *module_name; char *module_name;
char *field_name; char *field_name;
/* 0: no max size, 1: has max size */ WASMTableType table_type;
uint8 elem_type;
uint8 flags;
bool possible_grow;
uint32 init_size;
/* specified if (flags & 1), else it is 0x10000 */
uint32 max_size;
#if WASM_ENABLE_GC != 0
WASMRefType *elem_ref_type;
#endif
#if WASM_ENABLE_MULTI_MODULE != 0 #if WASM_ENABLE_MULTI_MODULE != 0
WASMModule *import_module; WASMModule *import_module;
WASMTable *import_table_linked; WASMTable *import_table_linked;

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

@ -2364,10 +2364,11 @@ wasm_loader_resolve_table(const char *module_name, const char *table_name,
else { else {
table = &(module->tables[export->index - module->import_table_count]); table = &(module->tables[export->index - module->import_table_count]);
} }
if (table->init_size < init_size || table->max_size > max_size) { if (table->table_type.init_size < init_size
|| table->table_type.max_size > max_size) {
LOG_DEBUG("%s,%s failed type check(%d-%d), expected(%d-%d)", LOG_DEBUG("%s,%s failed type check(%d-%d), expected(%d-%d)",
module_name, table_name, table->init_size, table->max_size, module_name, table_name, table->table_type.init_size,
init_size, max_size); table->table_type.max_size, init_size, max_size);
set_error_buf(error_buf, error_buf_size, "incompatible import type"); set_error_buf(error_buf, error_buf_size, "incompatible import type");
return NULL; return NULL;
} }
@ -2652,7 +2653,7 @@ load_table_import(const uint8 **p_buf, const uint8 *buf_end,
} }
declare_elem_type = ref_type.ref_type; declare_elem_type = ref_type.ref_type;
if (need_ref_type_map) { if (need_ref_type_map) {
if (!(table->elem_ref_type = if (!(table->table_type.elem_ref_type =
reftype_set_insert(parent_module->ref_type_set, &ref_type, reftype_set_insert(parent_module->ref_type_set, &ref_type,
error_buf, error_buf_size))) { error_buf, error_buf_size))) {
return false; return false;
@ -2660,7 +2661,7 @@ load_table_import(const uint8 **p_buf, const uint8 *buf_end,
} }
#if TRACE_WASM_LOADER != 0 #if TRACE_WASM_LOADER != 0
os_printf("import table type: "); os_printf("import table type: ");
wasm_dump_value_type(declare_elem_type, table->elem_ref_type); wasm_dump_value_type(declare_elem_type, table->table_type.elem_ref_type);
os_printf("\n"); os_printf("\n");
#endif #endif
#endif /* end of WASM_ENABLE_GC == 0 */ #endif /* end of WASM_ENABLE_GC == 0 */
@ -2702,10 +2703,10 @@ load_table_import(const uint8 **p_buf, const uint8 *buf_end,
} }
/* reset with linked table limit */ /* reset with linked table limit */
declare_elem_type = linked_table->elem_type; declare_elem_type = linked_table->table_type.elem_type;
declare_init_size = linked_table->init_size; declare_init_size = linked_table->table_type.init_size;
declare_max_size = linked_table->max_size; declare_max_size = linked_table->table_type.max_size;
declare_max_size_flag = linked_table->flags; declare_max_size_flag = linked_table->table_type.flags;
table->import_table_linked = linked_table; table->import_table_linked = linked_table;
table->import_module = sub_module; table->import_module = sub_module;
} }
@ -2735,13 +2736,13 @@ load_table_import(const uint8 **p_buf, const uint8 *buf_end,
} }
/* now we believe all declaration are ok */ /* now we believe all declaration are ok */
table->elem_type = declare_elem_type; table->table_type.elem_type = declare_elem_type;
table->init_size = declare_init_size; table->table_type.init_size = declare_init_size;
table->flags = declare_max_size_flag; table->table_type.flags = declare_max_size_flag;
table->max_size = declare_max_size; table->table_type.max_size = declare_max_size;
#if WASM_ENABLE_WAMR_COMPILER != 0 #if WASM_ENABLE_WAMR_COMPILER != 0
if (table->elem_type == VALUE_TYPE_EXTERNREF) if (table->table_type.elem_type == VALUE_TYPE_EXTERNREF)
parent_module->is_ref_types_used = true; parent_module->is_ref_types_used = true;
#endif #endif
(void)parent_module; (void)parent_module;
@ -3141,10 +3142,10 @@ load_table(const uint8 **p_buf, const uint8 *buf_end, WASMModule *module,
#if WASM_ENABLE_GC == 0 #if WASM_ENABLE_GC == 0
CHECK_BUF(p, p_end, 1); CHECK_BUF(p, p_end, 1);
/* 0x70 or 0x6F */ /* 0x70 or 0x6F */
table->elem_type = read_uint8(p); table->table_type.elem_type = read_uint8(p);
if (VALUE_TYPE_FUNCREF != table->elem_type if (VALUE_TYPE_FUNCREF != table->table_type.elem_type
#if WASM_ENABLE_REF_TYPES != 0 #if WASM_ENABLE_REF_TYPES != 0
&& VALUE_TYPE_EXTERNREF != table->elem_type && VALUE_TYPE_EXTERNREF != table->table_type.elem_type
#endif #endif
) { ) {
set_error_buf(error_buf, error_buf_size, "incompatible import type"); set_error_buf(error_buf, error_buf_size, "incompatible import type");
@ -3156,9 +3157,9 @@ load_table(const uint8 **p_buf, const uint8 *buf_end, WASMModule *module,
error_buf_size)) { error_buf_size)) {
return false; return false;
} }
table->elem_type = ref_type.ref_type; table->table_type.elem_type = ref_type.ref_type;
if (need_ref_type_map) { if (need_ref_type_map) {
if (!(table->elem_ref_type = if (!(table->table_type.elem_ref_type =
reftype_set_insert(module->ref_type_set, &ref_type, error_buf, reftype_set_insert(module->ref_type_set, &ref_type, error_buf,
error_buf_size))) { error_buf_size))) {
return false; return false;
@ -3166,20 +3167,21 @@ load_table(const uint8 **p_buf, const uint8 *buf_end, WASMModule *module,
} }
#if TRACE_WASM_LOADER != 0 #if TRACE_WASM_LOADER != 0
os_printf("table type: "); os_printf("table type: ");
wasm_dump_value_type(table->elem_type, table->elem_ref_type); wasm_dump_value_type(table->table_type.elem_type,
table->table_type.elem_ref_type);
os_printf("\n"); os_printf("\n");
#endif #endif
#endif /* end of WASM_ENABLE_GC == 0 */ #endif /* end of WASM_ENABLE_GC == 0 */
p_org = p; p_org = p;
read_leb_uint32(p, p_end, table->flags); read_leb_uint32(p, p_end, table->table_type.flags);
#if WASM_ENABLE_SHARED_MEMORY == 0 #if WASM_ENABLE_SHARED_MEMORY == 0
if (p - p_org > 1) { if (p - p_org > 1) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"integer representation too long"); "integer representation too long");
return false; return false;
} }
if (table->flags > 1) { if (table->table_type.flags > 1) {
set_error_buf(error_buf, error_buf_size, "integer too large"); set_error_buf(error_buf, error_buf_size, "integer too large");
return false; return false;
} }
@ -3188,29 +3190,31 @@ load_table(const uint8 **p_buf, const uint8 *buf_end, WASMModule *module,
set_error_buf(error_buf, error_buf_size, "invalid limits flags"); set_error_buf(error_buf, error_buf_size, "invalid limits flags");
return false; return false;
} }
if (table->flags == 2) { if (table->table_type.flags == 2) {
set_error_buf(error_buf, error_buf_size, "tables cannot be shared"); set_error_buf(error_buf, error_buf_size, "tables cannot be shared");
return false; return false;
} }
if (table->flags > 1) { if (table->table_type.flags > 1) {
set_error_buf(error_buf, error_buf_size, "invalid limits flags"); set_error_buf(error_buf, error_buf_size, "invalid limits flags");
return false; return false;
} }
#endif #endif
read_leb_uint32(p, p_end, table->init_size); read_leb_uint32(p, p_end, table->table_type.init_size);
if (table->flags) { if (table->table_type.flags) {
read_leb_uint32(p, p_end, table->max_size); read_leb_uint32(p, p_end, table->table_type.max_size);
if (!check_table_max_size(table->init_size, table->max_size, error_buf, if (!check_table_max_size(table->table_type.init_size,
table->table_type.max_size, error_buf,
error_buf_size)) error_buf_size))
return false; return false;
} }
adjust_table_max_size(table->init_size, table->flags, &table->max_size); adjust_table_max_size(table->table_type.init_size, table->table_type.flags,
&table->table_type.max_size);
#if WASM_ENABLE_WAMR_COMPILER != 0 #if WASM_ENABLE_WAMR_COMPILER != 0
if (table->elem_type == VALUE_TYPE_EXTERNREF) if (table->table_type.elem_type == VALUE_TYPE_EXTERNREF)
module->is_ref_types_used = true; module->is_ref_types_used = true;
#endif #endif
@ -3915,8 +3919,9 @@ load_table_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
#if WASM_ENABLE_GC != 0 #if WASM_ENABLE_GC != 0
if (has_init) { if (has_init) {
if (!load_init_expr(module, &p, p_end, &table->init_expr, if (!load_init_expr(module, &p, p_end, &table->init_expr,
table->elem_type, table->elem_ref_type, table->table_type.elem_type,
error_buf, error_buf_size)) table->table_type.elem_ref_type, error_buf,
error_buf_size))
return false; return false;
if (table->init_expr.init_expr_type >= INIT_EXPR_TYPE_STRUCT_NEW if (table->init_expr.init_expr_type >= INIT_EXPR_TYPE_STRUCT_NEW
&& table->init_expr.init_expr_type && table->init_expr.init_expr_type
@ -3928,7 +3933,8 @@ load_table_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
} }
} }
else { else {
if (wasm_is_reftype_htref_non_nullable(table->elem_type)) { if (wasm_is_reftype_htref_non_nullable(
table->table_type.elem_type)) {
set_error_buf( set_error_buf(
error_buf, error_buf_size, error_buf, error_buf_size,
"type mismatch: non-nullable table without init expr"); "type mismatch: non-nullable table without init expr");
@ -3938,7 +3944,7 @@ load_table_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
#endif /* end of WASM_ENABLE_GC != 0 */ #endif /* end of WASM_ENABLE_GC != 0 */
#if WASM_ENABLE_WAMR_COMPILER != 0 #if WASM_ENABLE_WAMR_COMPILER != 0
if (table->elem_type == VALUE_TYPE_EXTERNREF) if (table->table_type.elem_type == VALUE_TYPE_EXTERNREF)
module->is_ref_types_used = true; module->is_ref_types_used = true;
#endif #endif
} }
@ -4311,9 +4317,10 @@ check_table_elem_type(WASMModule *module, uint32 table_index,
if (table_index < module->import_table_count) if (table_index < module->import_table_count)
table_declared_elem_type = table_declared_elem_type =
module->import_tables[table_index].u.table.elem_type; module->import_tables[table_index].u.table.table_type.elem_type;
else else
table_declared_elem_type = (module->tables + table_index)->elem_type; table_declared_elem_type =
(module->tables + table_index)->table_type.elem_type;
if (table_declared_elem_type == type_from_elem_seg) if (table_declared_elem_type == type_from_elem_seg)
return true; return true;
@ -10804,23 +10811,25 @@ get_table_elem_type(const WASMModule *module, uint32 table_idx,
if (table_idx < module->import_table_count) { if (table_idx < module->import_table_count) {
if (p_elem_type) if (p_elem_type)
*p_elem_type = module->import_tables[table_idx].u.table.elem_type; *p_elem_type =
module->import_tables[table_idx].u.table.table_type.elem_type;
#if WASM_ENABLE_GC != 0 #if WASM_ENABLE_GC != 0
if (p_ref_type) if (p_ref_type)
*((WASMRefType **)p_ref_type) = *((WASMRefType **)p_ref_type) =
module->import_tables[table_idx].u.table.elem_ref_type; module->import_tables[table_idx]
.u.table.table_type.elem_ref_type;
#endif #endif
} }
else { else {
if (p_elem_type) if (p_elem_type)
*p_elem_type = *p_elem_type =
module->tables[module->import_table_count + table_idx] module->tables[module->import_table_count + table_idx]
.elem_type; .table_type.elem_type;
#if WASM_ENABLE_GC != 0 #if WASM_ENABLE_GC != 0
if (p_ref_type) if (p_ref_type)
*((WASMRefType **)p_ref_type) = *((WASMRefType **)p_ref_type) =
module->tables[module->import_table_count + table_idx] module->tables[module->import_table_count + table_idx]
.elem_ref_type; .table_type.elem_ref_type;
#endif #endif
} }
return true; return true;
@ -14878,13 +14887,13 @@ re_scan:
if (opcode1 == WASM_OP_TABLE_GROW) { if (opcode1 == WASM_OP_TABLE_GROW) {
if (table_idx < module->import_table_count) { if (table_idx < module->import_table_count) {
module->import_tables[table_idx] module->import_tables[table_idx]
.u.table.possible_grow = true; .u.table.table_type.possible_grow = true;
} }
else { else {
module module
->tables[table_idx ->tables[table_idx
- module->import_table_count] - module->import_table_count]
.possible_grow = true; .table_type.possible_grow = true;
} }
} }

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

@ -695,10 +695,10 @@ load_table_import(const uint8 **p_buf, const uint8 *buf_end,
!((declare_max_size_flag & 1) && declare_init_size > declare_max_size)); !((declare_max_size_flag & 1) && declare_init_size > declare_max_size));
/* now we believe all declaration are ok */ /* now we believe all declaration are ok */
table->elem_type = declare_elem_type; table->table_type.elem_type = declare_elem_type;
table->init_size = declare_init_size; table->table_type.init_size = declare_init_size;
table->flags = declare_max_size_flag; table->table_type.flags = declare_max_size_flag;
table->max_size = declare_max_size; table->table_type.max_size = declare_max_size;
return true; return true;
} }
@ -805,26 +805,27 @@ load_table(const uint8 **p_buf, const uint8 *buf_end, WASMTable *table,
CHECK_BUF(p, p_end, 1); CHECK_BUF(p, p_end, 1);
/* 0x70 or 0x6F */ /* 0x70 or 0x6F */
table->elem_type = read_uint8(p); table->table_type.elem_type = read_uint8(p);
bh_assert((VALUE_TYPE_FUNCREF == table->elem_type) bh_assert((VALUE_TYPE_FUNCREF == table->table_type.elem_type)
#if WASM_ENABLE_REF_TYPES != 0 #if WASM_ENABLE_REF_TYPES != 0
|| VALUE_TYPE_EXTERNREF == table->elem_type || VALUE_TYPE_EXTERNREF == table->table_type.elem_type
#endif #endif
); );
p_org = p; p_org = p;
read_leb_uint32(p, p_end, table->flags); read_leb_uint32(p, p_end, table->table_type.flags);
bh_assert(p - p_org <= 1); bh_assert(p - p_org <= 1);
bh_assert(table->flags <= 1); bh_assert(table->table_type.flags <= 1);
(void)p_org; (void)p_org;
read_leb_uint32(p, p_end, table->init_size); read_leb_uint32(p, p_end, table->table_type.init_size);
if (table->flags == 1) { if (table->table_type.flags == 1) {
read_leb_uint32(p, p_end, table->max_size); read_leb_uint32(p, p_end, table->table_type.max_size);
bh_assert(table->init_size <= table->max_size); bh_assert(table->table_type.init_size <= table->table_type.max_size);
} }
adjust_table_max_size(table->init_size, table->flags, &table->max_size); adjust_table_max_size(table->table_type.init_size, table->table_type.flags,
&table->table_type.max_size);
*p_buf = p; *p_buf = p;
return true; return true;
@ -2515,11 +2516,12 @@ get_table_elem_type(const WASMModule *module, uint32 table_idx,
if (p_elem_type) { if (p_elem_type) {
if (table_idx < module->import_table_count) if (table_idx < module->import_table_count)
*p_elem_type = module->import_tables[table_idx].u.table.elem_type; *p_elem_type =
module->import_tables[table_idx].u.table.table_type.elem_type;
else else
*p_elem_type = *p_elem_type =
module->tables[module->import_table_count + table_idx] module->tables[module->import_table_count + table_idx]
.elem_type; .table_type.elem_type;
} }
return true; return true;
} }
@ -7917,13 +7919,13 @@ re_scan:
if (opcode1 == WASM_OP_TABLE_GROW) { if (opcode1 == WASM_OP_TABLE_GROW) {
if (table_idx < module->import_table_count) { if (table_idx < module->import_table_count) {
module->import_tables[table_idx] module->import_tables[table_idx]
.u.table.possible_grow = true; .u.table.table_type.possible_grow = true;
} }
else { else {
module module
->tables[table_idx ->tables[table_idx
- module->import_table_count] - module->import_table_count]
.possible_grow = true; .table_type.possible_grow = true;
} }
} }

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

@ -533,9 +533,9 @@ tables_instantiate(const WASMModule *module, WASMModuleInstance *module_inst,
#endif #endif
{ {
/* in order to save memory, alloc resource as few as possible */ /* in order to save memory, alloc resource as few as possible */
max_size_fixed = import->u.table.possible_grow max_size_fixed = import->u.table.table_type.possible_grow
? import->u.table.max_size ? import->u.table.table_type.max_size
: import->u.table.init_size; : import->u.table.table_type.init_size;
/* it is a built-in table, every module has its own */ /* it is a built-in table, every module has its own */
total_size = offsetof(WASMTableInstance, elems); total_size = offsetof(WASMTableInstance, elems);
@ -556,8 +556,8 @@ tables_instantiate(const WASMModule *module, WASMModuleInstance *module_inst,
#if WASM_ENABLE_MULTI_MODULE != 0 #if WASM_ENABLE_MULTI_MODULE != 0
*table_linked = table_inst_linked; *table_linked = table_inst_linked;
if (table_inst_linked != NULL) { if (table_inst_linked != NULL) {
#if WASM_ENABLE_GC != 0
table->elem_type = table_inst_linked->elem_type; table->elem_type = table_inst_linked->elem_type;
#if WASM_ENABLE_GC != 0
table->elem_ref_type = table_inst_linked->elem_ref_type; table->elem_ref_type = table_inst_linked->elem_ref_type;
#endif #endif
table->cur_size = table_inst_linked->cur_size; table->cur_size = table_inst_linked->cur_size;
@ -566,11 +566,12 @@ tables_instantiate(const WASMModule *module, WASMModuleInstance *module_inst,
else else
#endif #endif
{ {
table->elem_type = import->u.table.table_type.elem_type;
#if WASM_ENABLE_GC != 0 #if WASM_ENABLE_GC != 0
table->elem_type = import->u.table.elem_type; table->elem_ref_type.elem_ref_type =
table->elem_ref_type.elem_ref_type = import->u.table.elem_ref_type; import->u.table.table_type.elem_ref_type;
#endif #endif
table->cur_size = import->u.table.init_size; table->cur_size = import->u.table.table_type.init_size;
table->max_size = max_size_fixed; table->max_size = max_size_fixed;
} }
@ -587,11 +588,11 @@ tables_instantiate(const WASMModule *module, WASMModuleInstance *module_inst,
total_size = offsetof(WASMTableInstance, elems); total_size = offsetof(WASMTableInstance, elems);
#if WASM_ENABLE_MULTI_MODULE != 0 #if WASM_ENABLE_MULTI_MODULE != 0
/* in case, a module which imports this table will grow it */ /* in case, a module which imports this table will grow it */
max_size_fixed = module->tables[i].max_size; max_size_fixed = module->tables[i].table_type.max_size;
#else #else
max_size_fixed = module->tables[i].possible_grow max_size_fixed = module->tables[i].table_type.possible_grow
? module->tables[i].max_size ? module->tables[i].table_type.max_size
: module->tables[i].init_size; : module->tables[i].table_type.init_size;
#endif #endif
#if WASM_ENABLE_GC == 0 #if WASM_ENABLE_GC == 0
/* Store function indexes */ /* Store function indexes */
@ -610,11 +611,12 @@ tables_instantiate(const WASMModule *module, WASMModuleInstance *module_inst,
/* For GC, all elements have already been set to NULL_REF (0) as /* For GC, all elements have already been set to NULL_REF (0) as
uninitialized elements */ uninitialized elements */
#endif #endif
table->elem_type = module->tables[i].table_type.elem_type;
#if WASM_ENABLE_GC != 0 #if WASM_ENABLE_GC != 0
table->elem_type = module->tables[i].elem_type; table->elem_ref_type.elem_ref_type =
table->elem_ref_type.elem_ref_type = module->tables[i].elem_ref_type; module->tables[i].table_type.elem_ref_type;
#endif #endif
table->cur_size = module->tables[i].init_size; table->cur_size = module->tables[i].table_type.init_size;
table->max_size = max_size_fixed; table->max_size = max_size_fixed;
table = (WASMTableInstance *)((uint8 *)table + (uint32)total_size); table = (WASMTableInstance *)((uint8 *)table + (uint32)total_size);
@ -2164,23 +2166,26 @@ wasm_instantiate(WASMModule *module, WASMModuleInstance *parent,
WASMTableImport *import_table = &module->import_tables[i].u.table; WASMTableImport *import_table = &module->import_tables[i].u.table;
table_size += offsetof(WASMTableInstance, elems); table_size += offsetof(WASMTableInstance, elems);
#if WASM_ENABLE_MULTI_MODULE != 0 #if WASM_ENABLE_MULTI_MODULE != 0
table_size += table_size += (uint64)sizeof(table_elem_type_t)
(uint64)sizeof(table_elem_type_t) * import_table->max_size; * import_table->table_type.max_size;
#else #else
table_size += (uint64)sizeof(table_elem_type_t) table_size += (uint64)sizeof(table_elem_type_t)
* (import_table->possible_grow ? import_table->max_size * (import_table->table_type.possible_grow
: import_table->init_size); ? import_table->table_type.max_size
: import_table->table_type.init_size);
#endif #endif
} }
for (i = 0; i < module->table_count; i++) { for (i = 0; i < module->table_count; i++) {
WASMTable *table = module->tables + i; WASMTable *table = module->tables + i;
table_size += offsetof(WASMTableInstance, elems); table_size += offsetof(WASMTableInstance, elems);
#if WASM_ENABLE_MULTI_MODULE != 0 #if WASM_ENABLE_MULTI_MODULE != 0
table_size += (uint64)sizeof(table_elem_type_t) * table->max_size; table_size +=
(uint64)sizeof(table_elem_type_t) * table->table_type.max_size;
#else #else
table_size += table_size +=
(uint64)sizeof(table_elem_type_t) (uint64)sizeof(table_elem_type_t)
* (table->possible_grow ? table->max_size : table->init_size); * (table->table_type.possible_grow ? table->table_type.max_size
: table->table_type.init_size);
#endif #endif
} }
total_size += table_size; total_size += table_size;

8
test-tools/aot-analyzer/src/main.cc
View File

@ -291,8 +291,8 @@ DumpDetails(AoTFile *aot)
#endif #endif
printf(" init_size:%5u max_size:%5u " printf(" init_size:%5u max_size:%5u "
"module_name: %s table_name: %s\n", "module_name: %s table_name: %s\n",
table.table_init_size, table.table_max_size, table.module_name, table.table_type.init_size, table.table_type.max_size,
table.table_name); table.module_name, table.table_type.name);
} }
printf("\n"); printf("\n");
@ -352,8 +352,8 @@ DumpDetails(AoTFile *aot)
#else #else
dump_value_type(table.elem_type); dump_value_type(table.elem_type);
#endif #endif
printf(" init_size:%5u max_size:%5u\n", table.table_init_size, printf(" init_size:%5u max_size:%5u\n",
table.table_max_size); table.table_type.init_size, table.table_type.max_size);
} }
printf("\n\n"); printf("\n\n");