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

Add wasm_export.h APIs to expose memory type (#3496)

Browse Source 
Support to get `wasm_memory_type_t memory_type` from API
`wasm_runtime_get_import_type` and `wasm_runtime_get_export_type`,
and then get shared flag, initial page cout, maximum page count
from the memory_type:
```C
bool
wasm_memory_type_get_shared(const wasm_memory_type_t memory_type);
uint32_t
wasm_memory_type_get_init_page_count(const wasm_memory_type_t memory_type);
uint32_t
wasm_memory_type_get_max_page_count(const wasm_memory_type_t memory_type);
```
This commit is contained in:
Benbuck Nason 2024-06-05 18:20:24 -07:00 committed by GitHub
parent 3fbb7fca25
commit 8239dd4aa7
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
18 changed files with 184 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1043,16 +1043,16 @@ load_memory_info(const uint8 **p_buf, const uint8 *buf_end, AOTModule *module,
} }
for (i = 0; i < module->memory_count; i++) { for (i = 0; i < module->memory_count; i++) {
read_uint32(buf, buf_end, module->memories[i].memory_flags); read_uint32(buf, buf_end, module->memories[i].flags);
if (!wasm_memory_check_flags(module->memories[i].memory_flags, if (!wasm_memory_check_flags(module->memories[i].flags, error_buf,
error_buf, error_buf_size, true)) { error_buf_size, true)) {
return false; return false;
} }
read_uint32(buf, buf_end, module->memories[i].num_bytes_per_page); read_uint32(buf, buf_end, module->memories[i].num_bytes_per_page);
read_uint32(buf, buf_end, module->memories[i].mem_init_page_count); read_uint32(buf, buf_end, module->memories[i].init_page_count);
read_uint32(buf, buf_end, module->memories[i].mem_max_page_count); read_uint32(buf, buf_end, module->memories[i].max_page_count);
} }
read_uint32(buf, buf_end, module->mem_init_data_count); read_uint32(buf, buf_end, module->mem_init_data_count);
@ -3637,9 +3637,9 @@ has_module_memory64(AOTModule *module)
/* TODO: multi-memories for now assuming the memory idx type is consistent /* TODO: multi-memories for now assuming the memory idx type is consistent
* across multi-memories */ * across multi-memories */
if (module->import_memory_count > 0) if (module->import_memory_count > 0)
return !!(module->import_memories[0].memory_flags & MEMORY64_FLAG); return !!(module->import_memories[0].mem_type.flags & MEMORY64_FLAG);
else if (module->memory_count > 0) else if (module->memory_count > 0)
return !!(module->memories[0].memory_flags & MEMORY64_FLAG); return !!(module->memories[0].flags & MEMORY64_FLAG);
return false; return false;
} }

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

@ -789,10 +789,9 @@ memory_instantiate(AOTModuleInstance *module_inst, AOTModuleInstance *parent,
{ {
void *heap_handle; void *heap_handle;
uint32 num_bytes_per_page = memory->num_bytes_per_page; uint32 num_bytes_per_page = memory->num_bytes_per_page;
uint32 init_page_count = memory->mem_init_page_count; uint32 init_page_count = memory->init_page_count;
uint32 max_page_count = uint32 max_page_count = wasm_runtime_get_max_mem(
wasm_runtime_get_max_mem(max_memory_pages, memory->mem_init_page_count, max_memory_pages, memory->init_page_count, memory->max_page_count);
memory->mem_max_page_count);
uint32 default_max_pages; uint32 default_max_pages;
uint32 inc_page_count, global_idx; uint32 inc_page_count, global_idx;
uint32 bytes_of_last_page, bytes_to_page_end; uint32 bytes_of_last_page, bytes_to_page_end;
@ -800,11 +799,11 @@ memory_instantiate(AOTModuleInstance *module_inst, AOTModuleInstance *parent,
heap_offset = (uint64)num_bytes_per_page * init_page_count; heap_offset = (uint64)num_bytes_per_page * init_page_count;
uint64 memory_data_size, max_memory_data_size; uint64 memory_data_size, max_memory_data_size;
uint8 *p = NULL, *global_addr; uint8 *p = NULL, *global_addr;
bool is_memory64 = memory->memory_flags & MEMORY64_FLAG; bool is_memory64 = memory->flags & MEMORY64_FLAG;
bool is_shared_memory = false; bool is_shared_memory = false;
#if WASM_ENABLE_SHARED_MEMORY != 0 #if WASM_ENABLE_SHARED_MEMORY != 0
is_shared_memory = memory->memory_flags & SHARED_MEMORY_FLAG ? true : false; is_shared_memory = memory->flags & SHARED_MEMORY_FLAG ? true : false;
/* Shared memory */ /* Shared memory */
if (is_shared_memory && parent != NULL) { if (is_shared_memory && parent != NULL) {
AOTMemoryInstance *shared_memory_instance; AOTMemoryInstance *shared_memory_instance;

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

@ -2580,8 +2580,8 @@ wasm_module_imports(const wasm_module_t *module, own wasm_importtype_vec_t *out)
+ (i - import_func_count - import_global_count); + (i - import_func_count - import_global_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;
min_page = import->u.memory.init_page_count; min_page = import->u.memory.mem_type.init_page_count;
max_page = import->u.memory.max_page_count; max_page = import->u.memory.mem_type.max_page_count;
} }
#endif #endif
@ -2592,8 +2592,8 @@ wasm_module_imports(const wasm_module_t *module, own wasm_importtype_vec_t *out)
+ (i - import_func_count - import_global_count); + (i - import_func_count - import_global_count);
module_name_rt = import->module_name; module_name_rt = import->module_name;
field_name_rt = import->memory_name; field_name_rt = import->memory_name;
min_page = import->mem_init_page_count; min_page = import->mem_type.init_page_count;
max_page = import->mem_max_page_count; max_page = import->mem_type.max_page_count;
} }
#endif #endif
@ -4308,12 +4308,12 @@ wasm_memory_new_internal(wasm_store_t *store, uint16 memory_idx_rt,
AOTModule *module_aot = (AOTModule *)inst_aot->module; AOTModule *module_aot = (AOTModule *)inst_aot->module;
if (memory_idx_rt < module_aot->import_memory_count) { if (memory_idx_rt < module_aot->import_memory_count) {
min_pages = module_aot->import_memories->mem_init_page_count; min_pages = module_aot->import_memories->mem_type.init_page_count;
max_pages = module_aot->import_memories->mem_max_page_count; max_pages = module_aot->import_memories->mem_type.max_page_count;
} }
else { else {
min_pages = module_aot->memories->mem_init_page_count; min_pages = module_aot->memories->init_page_count;
max_pages = module_aot->memories->mem_max_page_count; max_pages = module_aot->memories->max_page_count;
} }
init_flag = true; init_flag = true;
} }

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

@ -3873,7 +3873,8 @@ wasm_runtime_get_import_type(WASMModuleCommon *const module, int32 import_index,
import_type->kind = WASM_IMPORT_EXPORT_KIND_FUNC; import_type->kind = WASM_IMPORT_EXPORT_KIND_FUNC;
import_type->linked = import_type->linked =
aot_import_func->func_ptr_linked ? true : false; aot_import_func->func_ptr_linked ? true : false;
import_type->u.func_type = aot_import_func->func_type; import_type->u.func_type =
(WASMFuncType *)aot_import_func->func_type;
return; return;
} }
@ -3909,6 +3910,8 @@ wasm_runtime_get_import_type(WASMModuleCommon *const module, int32 import_index,
import_type->name = aot_import_memory->memory_name; import_type->name = aot_import_memory->memory_name;
import_type->kind = WASM_IMPORT_EXPORT_KIND_MEMORY; import_type->kind = WASM_IMPORT_EXPORT_KIND_MEMORY;
import_type->linked = false; import_type->linked = false;
import_type->u.memory_type =
(WASMMemoryType *)&aot_import_memory->mem_type;
return; return;
} }
@ -3933,7 +3936,8 @@ wasm_runtime_get_import_type(WASMModuleCommon *const module, int32 import_index,
switch (import_type->kind) { switch (import_type->kind) {
case WASM_IMPORT_EXPORT_KIND_FUNC: case WASM_IMPORT_EXPORT_KIND_FUNC:
import_type->linked = wasm_import->u.function.func_ptr_linked; import_type->linked = wasm_import->u.function.func_ptr_linked;
import_type->u.func_type = wasm_import->u.function.func_type; import_type->u.func_type =
(WASMFuncType *)wasm_import->u.function.func_type;
break; break;
case WASM_IMPORT_EXPORT_KIND_GLOBAL: case WASM_IMPORT_EXPORT_KIND_GLOBAL:
import_type->linked = wasm_import->u.global.is_linked; import_type->linked = wasm_import->u.global.is_linked;
@ -3941,12 +3945,12 @@ wasm_runtime_get_import_type(WASMModuleCommon *const module, int32 import_index,
(WASMGlobalType *)&wasm_import->u.global.type; (WASMGlobalType *)&wasm_import->u.global.type;
break; break;
case WASM_IMPORT_EXPORT_KIND_TABLE: case WASM_IMPORT_EXPORT_KIND_TABLE:
/* not supported */ import_type->linked = false; /* not supported */
import_type->linked = false;
break; break;
case WASM_IMPORT_EXPORT_KIND_MEMORY: case WASM_IMPORT_EXPORT_KIND_MEMORY:
/* not supported */ import_type->linked = false; /* not supported */
import_type->linked = false; import_type->u.memory_type =
(WASMMemoryType *)&wasm_import->u.memory.mem_type;
break; break;
default: default:
bh_assert(0); bh_assert(0);
@ -4026,12 +4030,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:
/* not supported */
// export_type->linked = false;
break; break;
case WASM_IMPORT_EXPORT_KIND_MEMORY: case WASM_IMPORT_EXPORT_KIND_MEMORY:
/* not supported */ export_type->u.memory_type =
// export_type->linked = false; &aot_module->memories[aot_export->index
- aot_module->import_memory_count];
break; break;
default: default:
bh_assert(0); bh_assert(0);
@ -4068,13 +4071,13 @@ 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:
/* not supported */
// export_type->linked = false;
break; break;
case WASM_IMPORT_EXPORT_KIND_MEMORY: case WASM_IMPORT_EXPORT_KIND_MEMORY:
/* not supported */ export_type->u.memory_type =
// export_type->linked = false; &wasm_module->memories[wasm_export->index
- wasm_module->import_memory_count];
break; break;
default:
bh_assert(0); bh_assert(0);
break; break;
} }
@ -4185,6 +4188,30 @@ wasm_global_type_get_mutable(WASMGlobalType *const global_type)
return global_type->is_mutable; return global_type->is_mutable;
} }
bool
wasm_memory_type_get_shared(WASMMemoryType *const memory_type)
{
bh_assert(memory_type);
return (memory_type->flags & SHARED_MEMORY_FLAG) ? true : false;
}
uint32
wasm_memory_type_get_init_page_count(WASMMemoryType *const memory_type)
{
bh_assert(memory_type);
return memory_type->init_page_count;
}
uint32
wasm_memory_type_get_max_page_count(WASMMemoryType *const memory_type)
{
bh_assert(memory_type);
return memory_type->max_page_count;
}
bool bool
wasm_runtime_register_natives(const char *module_name, wasm_runtime_register_natives(const char *module_name,
NativeSymbol *native_symbols, NativeSymbol *native_symbols,
@ -6519,8 +6546,8 @@ wasm_runtime_get_export_memory_type(const WASMModuleCommon *module_comm,
if (export->index < module->import_memory_count) { if (export->index < module->import_memory_count) {
WASMMemoryImport *import_memory = WASMMemoryImport *import_memory =
&((module->import_memories + export->index)->u.memory); &((module->import_memories + export->index)->u.memory);
*out_min_page = import_memory->init_page_count; *out_min_page = import_memory->mem_type.init_page_count;
*out_max_page = import_memory->max_page_count; *out_max_page = import_memory->mem_type.max_page_count;
} }
else { else {
WASMMemory *memory = WASMMemory *memory =
@ -6540,14 +6567,14 @@ wasm_runtime_get_export_memory_type(const WASMModuleCommon *module_comm,
if (export->index < module->import_memory_count) { if (export->index < module->import_memory_count) {
AOTImportMemory *import_memory = AOTImportMemory *import_memory =
module->import_memories + export->index; module->import_memories + export->index;
*out_min_page = import_memory->mem_init_page_count; *out_min_page = import_memory->mem_type.init_page_count;
*out_max_page = import_memory->mem_max_page_count; *out_max_page = import_memory->mem_type.max_page_count;
} }
else { else {
AOTMemory *memory = module->memories AOTMemory *memory = module->memories
+ (export->index - module->import_memory_count); + (export->index - module->import_memory_count);
*out_min_page = memory->mem_init_page_count; *out_min_page = memory->init_page_count;
*out_max_page = memory->mem_max_page_count; *out_max_page = memory->max_page_count;
} }
return true; return true;
} }

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

@ -558,28 +558,24 @@ aot_create_comp_data(WASMModule *module, const char *target_arch,
/* Set memory page count */ /* Set memory page count */
for (i = 0; i < module->import_memory_count + module->memory_count; i++) { for (i = 0; i < module->import_memory_count + module->memory_count; i++) {
if (i < module->import_memory_count) { if (i < module->import_memory_count) {
comp_data->memories[i].memory_flags = comp_data->memories[i].flags =
module->import_memories[i].u.memory.flags; module->import_memories[i].u.memory.mem_type.flags;
comp_data->memories[i].num_bytes_per_page = comp_data->memories[i].num_bytes_per_page =
module->import_memories[i].u.memory.num_bytes_per_page; module->import_memories[i].u.memory.mem_type.num_bytes_per_page;
comp_data->memories[i].mem_init_page_count = comp_data->memories[i].init_page_count =
module->import_memories[i].u.memory.init_page_count; module->import_memories[i].u.memory.mem_type.init_page_count;
comp_data->memories[i].mem_max_page_count = comp_data->memories[i].max_page_count =
module->import_memories[i].u.memory.max_page_count; module->import_memories[i].u.memory.mem_type.max_page_count;
comp_data->memories[i].num_bytes_per_page =
module->import_memories[i].u.memory.num_bytes_per_page;
} }
else { else {
j = i - module->import_memory_count; j = i - module->import_memory_count;
comp_data->memories[i].memory_flags = module->memories[j].flags; comp_data->memories[i].flags = module->memories[j].flags;
comp_data->memories[i].num_bytes_per_page = comp_data->memories[i].num_bytes_per_page =
module->memories[j].num_bytes_per_page; module->memories[j].num_bytes_per_page;
comp_data->memories[i].mem_init_page_count = comp_data->memories[i].init_page_count =
module->memories[j].init_page_count; module->memories[j].init_page_count;
comp_data->memories[i].mem_max_page_count = comp_data->memories[i].max_page_count =
module->memories[j].max_page_count; module->memories[j].max_page_count;
comp_data->memories[i].num_bytes_per_page =
module->memories[j].num_bytes_per_page;
} }
} }

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

@ -46,6 +46,8 @@ typedef WASMStructType AOTStructType;
typedef WASMArrayType AOTArrayType; typedef WASMArrayType AOTArrayType;
#endif #endif
typedef WASMExport AOTExport; typedef WASMExport AOTExport;
typedef WASMMemory AOTMemory;
typedef WASMMemoryType AOTMemoryType;
#if WASM_ENABLE_DEBUG_AOT != 0 #if WASM_ENABLE_DEBUG_AOT != 0
typedef void *dwarf_extractor_handle_t; typedef void *dwarf_extractor_handle_t;
@ -81,23 +83,9 @@ typedef enum AOTFloatCond {
typedef struct AOTImportMemory { typedef struct AOTImportMemory {
char *module_name; char *module_name;
char *memory_name; char *memory_name;
uint32 memory_flags; AOTMemoryType mem_type;
uint32 num_bytes_per_page;
uint32 mem_init_page_count;
uint32 mem_max_page_count;
} AOTImportMemory; } AOTImportMemory;
/**
* Memory information
*/
typedef struct AOTMemory {
/* memory info */
uint32 memory_flags;
uint32 num_bytes_per_page;
uint32 mem_init_page_count;
uint32 mem_max_page_count;
} AOTMemory;
/** /**
* A segment of memory init data * A segment of memory init data
*/ */

3
core/iwasm/compilation/aot_compiler.h
View File

@ -520,8 +520,7 @@ set_local_gc_ref(AOTCompFrame *frame, int n, LLVMValueRef value, uint8 ref_type)
} while (0) } while (0)
#if WASM_ENABLE_MEMORY64 != 0 #if WASM_ENABLE_MEMORY64 != 0
#define IS_MEMORY64 \ #define IS_MEMORY64 (comp_ctx->comp_data->memories[0].flags & MEMORY64_FLAG)
(comp_ctx->comp_data->memories[0].memory_flags & MEMORY64_FLAG)
#define MEMORY64_COND_VALUE(VAL_IF_ENABLED, VAL_IF_DISABLED) \ #define MEMORY64_COND_VALUE(VAL_IF_ENABLED, VAL_IF_DISABLED) \
(IS_MEMORY64 ? VAL_IF_ENABLED : VAL_IF_DISABLED) (IS_MEMORY64 ? VAL_IF_ENABLED : VAL_IF_DISABLED)
#else #else

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

@ -189,7 +189,7 @@ get_import_memory_size(AOTCompData *comp_data)
static uint32 static uint32
get_memory_size(AOTCompData *comp_data) get_memory_size(AOTCompData *comp_data)
{ {
/* memory_count + count * (memory_flags + num_bytes_per_page + /* memory_count + count * (flags + num_bytes_per_page +
init_page_count + max_page_count) */ init_page_count + max_page_count) */
return (uint32)(sizeof(uint32) return (uint32)(sizeof(uint32)
+ comp_data->memory_count * sizeof(uint32) * 4); + comp_data->memory_count * sizeof(uint32) * 4);
@ -1762,10 +1762,10 @@ aot_emit_mem_info(uint8 *buf, uint8 *buf_end, uint32 *p_offset,
EMIT_U32(comp_data->memory_count); EMIT_U32(comp_data->memory_count);
/* Emit memory items */ /* Emit memory items */
for (i = 0; i < comp_data->memory_count; i++) { for (i = 0; i < comp_data->memory_count; i++) {
EMIT_U32(comp_data->memories[i].memory_flags); EMIT_U32(comp_data->memories[i].flags);
EMIT_U32(comp_data->memories[i].num_bytes_per_page); EMIT_U32(comp_data->memories[i].num_bytes_per_page);
EMIT_U32(comp_data->memories[i].mem_init_page_count); EMIT_U32(comp_data->memories[i].init_page_count);
EMIT_U32(comp_data->memories[i].mem_max_page_count); EMIT_U32(comp_data->memories[i].max_page_count);
} }
/* Emit mem init data count */ /* Emit mem init data count */

2
core/iwasm/compilation/aot_emit_control.c
View File

@ -853,7 +853,7 @@ check_suspend_flags(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
LLVMBasicBlockRef terminate_block, non_terminate_block; LLVMBasicBlockRef terminate_block, non_terminate_block;
AOTFuncType *aot_func_type = func_ctx->aot_func->func_type; AOTFuncType *aot_func_type = func_ctx->aot_func->func_type;
bool is_shared_memory = bool is_shared_memory =
comp_ctx->comp_data->memories[0].memory_flags & 0x02 ? true : false; comp_ctx->comp_data->memories[0].flags & 0x02 ? true : false;
/* Only need to check the suspend flags when memory is shared since /* Only need to check the suspend flags when memory is shared since
shared memory must be enabled for multi-threading */ shared memory must be enabled for multi-threading */

11
core/iwasm/compilation/aot_emit_memory.c
View File

@ -109,7 +109,7 @@ aot_check_memory_overflow(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
bool is_target_64bit, is_local_of_aot_value = false; bool is_target_64bit, is_local_of_aot_value = false;
#if WASM_ENABLE_SHARED_MEMORY != 0 #if WASM_ENABLE_SHARED_MEMORY != 0
bool is_shared_memory = bool is_shared_memory =
comp_ctx->comp_data->memories[0].memory_flags & SHARED_MEMORY_FLAG; comp_ctx->comp_data->memories[0].flags & SHARED_MEMORY_FLAG;
#endif #endif
is_target_64bit = (comp_ctx->pointer_size == sizeof(uint64)) ? true : false; is_target_64bit = (comp_ctx->pointer_size == sizeof(uint64)) ? true : false;
@ -177,7 +177,7 @@ aot_check_memory_overflow(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
uint32 num_bytes_per_page = uint32 num_bytes_per_page =
comp_ctx->comp_data->memories[0].num_bytes_per_page; comp_ctx->comp_data->memories[0].num_bytes_per_page;
uint32 init_page_count = uint32 init_page_count =
comp_ctx->comp_data->memories[0].mem_init_page_count; comp_ctx->comp_data->memories[0].init_page_count;
uint64 mem_data_size = (uint64)num_bytes_per_page * init_page_count; uint64 mem_data_size = (uint64)num_bytes_per_page * init_page_count;
if (mem_offset + bytes <= mem_data_size) { if (mem_offset + bytes <= mem_data_size) {
@ -224,7 +224,7 @@ aot_check_memory_overflow(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
&& aot_checked_addr_list_find(func_ctx, local_idx_of_aot_value, && aot_checked_addr_list_find(func_ctx, local_idx_of_aot_value,
offset, bytes))) { offset, bytes))) {
uint32 init_page_count = uint32 init_page_count =
comp_ctx->comp_data->memories[0].mem_init_page_count; comp_ctx->comp_data->memories[0].init_page_count;
if (init_page_count == 0) { if (init_page_count == 0) {
LLVMValueRef mem_size; LLVMValueRef mem_size;
@ -932,8 +932,7 @@ check_bulk_memory_overflow(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
/* Get memory base address and memory data size */ /* Get memory base address and memory data size */
#if WASM_ENABLE_SHARED_MEMORY != 0 #if WASM_ENABLE_SHARED_MEMORY != 0
bool is_shared_memory = bool is_shared_memory = comp_ctx->comp_data->memories[0].flags & 0x02;
comp_ctx->comp_data->memories[0].memory_flags & 0x02;
if (func_ctx->mem_space_unchanged || is_shared_memory) { if (func_ctx->mem_space_unchanged || is_shared_memory) {
#else #else
@ -961,7 +960,7 @@ check_bulk_memory_overflow(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
uint32 num_bytes_per_page = uint32 num_bytes_per_page =
comp_ctx->comp_data->memories[0].num_bytes_per_page; comp_ctx->comp_data->memories[0].num_bytes_per_page;
uint32 init_page_count = uint32 init_page_count =
comp_ctx->comp_data->memories[0].mem_init_page_count; comp_ctx->comp_data->memories[0].init_page_count;
uint64 mem_data_size = (uint64)num_bytes_per_page * init_page_count; uint64 mem_data_size = (uint64)num_bytes_per_page * init_page_count;
if (mem_data_size > 0 && mem_offset + mem_len <= mem_data_size) { if (mem_data_size > 0 && mem_offset + mem_len <= mem_data_size) {
/* inside memory space */ /* inside memory space */

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

@ -1219,7 +1219,7 @@ create_memory_info(const AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
/* Load memory base address */ /* Load memory base address */
#if WASM_ENABLE_SHARED_MEMORY != 0 #if WASM_ENABLE_SHARED_MEMORY != 0
is_shared_memory = is_shared_memory =
comp_ctx->comp_data->memories[0].memory_flags & 0x02 ? true : false; comp_ctx->comp_data->memories[0].flags & 0x02 ? true : false;
if (is_shared_memory) { if (is_shared_memory) {
LLVMValueRef shared_mem_addr; LLVMValueRef shared_mem_addr;
offset = I32_CONST(offsetof(AOTModuleInstance, memories)); offset = I32_CONST(offsetof(AOTModuleInstance, memories));

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

@ -234,7 +234,7 @@ is_shared_memory(WASMModule *module, uint32 mem_idx)
if (mem_idx < module->import_memory_count) { if (mem_idx < module->import_memory_count) {
memory_import = &(module->import_memories[mem_idx].u.memory); memory_import = &(module->import_memories[mem_idx].u.memory);
is_shared = memory_import->flags & 0x02 ? true : false; is_shared = memory_import->mem_type.flags & 0x02 ? true : false;
} }
else { else {
memory = &module->memories[mem_idx - module->import_memory_count]; memory = &module->memories[mem_idx - module->import_memory_count];

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

@ -78,6 +78,10 @@ typedef struct WASMFuncType *wasm_func_type_t;
struct WASMGlobalType; struct WASMGlobalType;
typedef struct WASMGlobalType *wasm_global_type_t; typedef struct WASMGlobalType *wasm_global_type_t;
struct WASMMemory;
typedef struct WASMMemory WASMMemoryType;
typedef WASMMemoryType *wasm_memory_type_t;
typedef struct wasm_import_t { typedef struct wasm_import_t {
const char *module_name; const char *module_name;
const char *name; const char *name;
@ -86,6 +90,7 @@ typedef struct wasm_import_t {
union { union {
wasm_func_type_t func_type; wasm_func_type_t func_type;
wasm_global_type_t global_type; wasm_global_type_t global_type;
wasm_memory_type_t memory_type;
} u; } u;
} wasm_import_t; } wasm_import_t;
@ -95,6 +100,7 @@ typedef struct wasm_export_t {
union { union {
wasm_func_type_t func_type; wasm_func_type_t func_type;
wasm_global_type_t global_type; wasm_global_type_t global_type;
wasm_memory_type_t memory_type;
} u; } u;
} wasm_export_t; } wasm_export_t;
@ -1350,6 +1356,36 @@ wasm_global_type_get_valkind(const wasm_global_type_t global_type);
WASM_RUNTIME_API_EXTERN bool WASM_RUNTIME_API_EXTERN bool
wasm_global_type_get_mutable(const wasm_global_type_t global_type); wasm_global_type_get_mutable(const wasm_global_type_t global_type);
/**
* Get the shared setting for a memory type
*
* @param memory_type the memory type
*
* @return true if shared, false otherwise
*/
WASM_RUNTIME_API_EXTERN bool
wasm_memory_type_get_shared(const wasm_memory_type_t memory_type);
/**
* Get the initial page count for a memory type
*
* @param memory_type the memory type
*
* @return the initial memory page count
*/
WASM_RUNTIME_API_EXTERN uint32_t
wasm_memory_type_get_init_page_count(const wasm_memory_type_t memory_type);
/**
* Get the maximum page count for a memory type
*
* @param memory_type the memory type
*
* @return the maximum memory page count
*/
WASM_RUNTIME_API_EXTERN uint32_t
wasm_memory_type_get_max_page_count(const wasm_memory_type_t memory_type);
/** /**
* Register native functions with same module name * Register native functions with same module name
* *

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

@ -512,7 +512,7 @@ typedef struct WASMMemory {
uint32 num_bytes_per_page; uint32 num_bytes_per_page;
uint32 init_page_count; uint32 init_page_count;
uint32 max_page_count; uint32 max_page_count;
} WASMMemory; } WASMMemory, WASMMemoryType;
typedef struct WASMTableImport { typedef struct WASMTableImport {
char *module_name; char *module_name;
@ -536,10 +536,7 @@ typedef struct WASMTableImport {
typedef struct WASMMemoryImport { typedef struct WASMMemoryImport {
char *module_name; char *module_name;
char *field_name; char *field_name;
uint32 flags; WASMMemoryType mem_type;
uint32 num_bytes_per_page;
uint32 init_page_count;
uint32 max_page_count;
#if WASM_ENABLE_MULTI_MODULE != 0 #if WASM_ENABLE_MULTI_MODULE != 0
WASMModule *import_module; WASMModule *import_module;
WASMMemory *import_memory_linked; WASMMemory *import_memory_linked;

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

@ -44,7 +44,8 @@ has_module_memory64(WASMModule *module)
/* TODO: multi-memories for now assuming the memory idx type is consistent /* TODO: multi-memories for now assuming the memory idx type is consistent
* across multi-memories */ * across multi-memories */
if (module->import_memory_count > 0) if (module->import_memory_count > 0)
return !!(module->import_memories[0].u.memory.flags & MEMORY64_FLAG); return !!(module->import_memories[0].u.memory.mem_type.flags
& MEMORY64_FLAG);
else if (module->memory_count > 0) else if (module->memory_count > 0)
return !!(module->memories[0].flags & MEMORY64_FLAG); return !!(module->memories[0].flags & MEMORY64_FLAG);
@ -2935,10 +2936,10 @@ load_memory_import(const uint8 **p_buf, const uint8 *buf_end,
} }
/* now we believe all declaration are ok */ /* now we believe all declaration are ok */
memory->flags = mem_flag; memory->mem_type.flags = mem_flag;
memory->init_page_count = declare_init_page_count; memory->mem_type.init_page_count = declare_init_page_count;
memory->max_page_count = declare_max_page_count; memory->mem_type.max_page_count = declare_max_page_count;
memory->num_bytes_per_page = DEFAULT_NUM_BYTES_PER_PAGE; memory->mem_type.num_bytes_per_page = DEFAULT_NUM_BYTES_PER_PAGE;
*p_buf = p; *p_buf = p;
@ -4805,8 +4806,8 @@ load_data_segment_section(const uint8 *buf, const uint8 *buf_end,
/* This memory_flag is from memory instead of data segment */ /* This memory_flag is from memory instead of data segment */
uint8 memory_flag; uint8 memory_flag;
if (module->import_memory_count > 0) { if (module->import_memory_count > 0) {
memory_flag = memory_flag = module->import_memories[mem_index]
module->import_memories[mem_index].u.memory.flags; .u.memory.mem_type.flags;
} }
else { else {
memory_flag = memory_flag =
@ -6153,13 +6154,14 @@ load_from_sections(WASMModule *module, WASMSection *sections,
if (shrunk_memory_size <= UINT32_MAX) { if (shrunk_memory_size <= UINT32_MAX) {
if (module->import_memory_count) { if (module->import_memory_count) {
memory_import = &module->import_memories[0].u.memory; memory_import = &module->import_memories[0].u.memory;
init_memory_size = (uint64)memory_import->num_bytes_per_page init_memory_size =
* memory_import->init_page_count; (uint64)memory_import->mem_type.num_bytes_per_page
* memory_import->mem_type.init_page_count;
if (shrunk_memory_size <= init_memory_size) { if (shrunk_memory_size <= init_memory_size) {
/* Reset memory info to decrease memory usage */ /* Reset memory info to decrease memory usage */
memory_import->num_bytes_per_page = memory_import->mem_type.num_bytes_per_page =
(uint32)shrunk_memory_size; (uint32)shrunk_memory_size;
memory_import->init_page_count = 1; memory_import->mem_type.init_page_count = 1;
LOG_VERBOSE("Shrink import memory size to %" PRIu64, LOG_VERBOSE("Shrink import memory size to %" PRIu64,
shrunk_memory_size); shrunk_memory_size);
} }
@ -6185,16 +6187,16 @@ load_from_sections(WASMModule *module, WASMSection *sections,
memory_import = &module->import_memories[0].u.memory; memory_import = &module->import_memories[0].u.memory;
/* Only resize the memory to one big page if num_bytes_per_page is /* Only resize the memory to one big page if num_bytes_per_page is
* in valid range of uint32 */ * in valid range of uint32 */
if (memory_import->init_page_count < DEFAULT_MAX_PAGES) { if (memory_import->mem_type.init_page_count < DEFAULT_MAX_PAGES) {
memory_import->num_bytes_per_page *= memory_import->mem_type.num_bytes_per_page *=
memory_import->init_page_count; memory_import->mem_type.init_page_count;
if (memory_import->init_page_count > 0) if (memory_import->mem_type.init_page_count > 0)
memory_import->init_page_count = memory_import->mem_type.init_page_count =
memory_import->max_page_count = 1; memory_import->mem_type.max_page_count = 1;
else else
memory_import->init_page_count = memory_import->mem_type.init_page_count =
memory_import->max_page_count = 0; memory_import->mem_type.max_page_count = 0;
} }
} }
if (module->memory_count) { if (module->memory_count) {

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

@ -33,7 +33,7 @@ has_module_memory64(WASMModule *module)
/* TODO: multi-memories for now assuming the memory idx type is consistent /* TODO: multi-memories for now assuming the memory idx type is consistent
* across multi-memories */ * across multi-memories */
if (module->import_memory_count > 0) if (module->import_memory_count > 0)
return !!(module->import_memories[0].u.memory.flags & MEMORY64_FLAG); return !!(module->import_memories[0].u.mem_type.flags & MEMORY64_FLAG);
else if (module->memory_count > 0) else if (module->memory_count > 0)
return !!(module->memories[0].flags & MEMORY64_FLAG); return !!(module->memories[0].flags & MEMORY64_FLAG);
@ -761,10 +761,10 @@ load_memory_import(const uint8 **p_buf, const uint8 *buf_end,
} }
/* now we believe all declaration are ok */ /* now we believe all declaration are ok */
memory->flags = mem_flag; memory->mem_type.flags = mem_flag;
memory->init_page_count = declare_init_page_count; memory->mem_type.init_page_count = declare_init_page_count;
memory->max_page_count = declare_max_page_count; memory->mem_type.max_page_count = declare_max_page_count;
memory->num_bytes_per_page = DEFAULT_NUM_BYTES_PER_PAGE; memory->mem_type.num_bytes_per_page = DEFAULT_NUM_BYTES_PER_PAGE;
*p_buf = p; *p_buf = p;
return true; return true;
@ -1812,7 +1812,7 @@ load_data_segment_section(const uint8 *buf, const uint8 *buf_end,
uint8 memory_flag; uint8 memory_flag;
if (module->import_memory_count > 0) { if (module->import_memory_count > 0) {
memory_flag = memory_flag =
module->import_memories[mem_index].u.memory.flags; module->import_memories[mem_index].u.mem_type.flags;
} }
else { else {
memory_flag = memory_flag =
@ -2922,12 +2922,14 @@ load_from_sections(WASMModule *module, WASMSection *sections,
if (shrunk_memory_size <= UINT32_MAX) { if (shrunk_memory_size <= UINT32_MAX) {
if (module->import_memory_count) { if (module->import_memory_count) {
memory_import = &module->import_memories[0].u.memory; memory_import = &module->import_memories[0].u.memory;
init_memory_size = (uint64)memory_import->num_bytes_per_page init_memory_size =
* memory_import->init_page_count; (uint64)memory_import->mem_type.num_bytes_per_page
* memory_import->mem_type.init_page_count;
if (shrunk_memory_size <= init_memory_size) { if (shrunk_memory_size <= init_memory_size) {
/* Reset memory info to decrease memory usage */ /* Reset memory info to decrease memory usage */
memory_import->num_bytes_per_page = shrunk_memory_size; memory_import->mem_type.num_bytes_per_page =
memory_import->init_page_count = 1; shrunk_memory_size;
memory_import->mem_type.init_page_count = 1;
LOG_VERBOSE("Shrink import memory size to %" PRIu64, LOG_VERBOSE("Shrink import memory size to %" PRIu64,
shrunk_memory_size); shrunk_memory_size);
} }
@ -2950,15 +2952,15 @@ load_from_sections(WASMModule *module, WASMSection *sections,
if (module->import_memory_count) { if (module->import_memory_count) {
memory_import = &module->import_memories[0].u.memory; memory_import = &module->import_memories[0].u.memory;
if (memory_import->init_page_count < DEFAULT_MAX_PAGES) { if (memory_import->mem_type.init_page_count < DEFAULT_MAX_PAGES) {
memory_import->num_bytes_per_page *= memory_import->mem_type.num_bytes_per_page *=
memory_import->init_page_count; memory_import->mem_type.init_page_count;
if (memory_import->init_page_count > 0) if (memory_import->mem_type.init_page_count > 0)
memory_import->init_page_count = memory_import->mem_type.init_page_count =
memory_import->max_page_count = 1; memory_import->mem_type.max_page_count = 1;
else else
memory_import->init_page_count = memory_import->mem_type.init_page_count =
memory_import->max_page_count = 0; memory_import->mem_type.max_page_count = 0;
} }
} }

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

@ -396,12 +396,13 @@ memories_instantiate(const WASMModule *module, WASMModuleInstance *module_inst,
/* instantiate memories from import section */ /* instantiate memories from import section */
import = module->import_memories; import = module->import_memories;
for (i = 0; i < module->import_memory_count; i++, import++, memory++) { for (i = 0; i < module->import_memory_count; i++, import++, memory++) {
uint32 num_bytes_per_page = import->u.memory.num_bytes_per_page; uint32 num_bytes_per_page =
uint32 init_page_count = import->u.memory.init_page_count; import->u.memory.mem_type.num_bytes_per_page;
uint32 init_page_count = import->u.memory.mem_type.init_page_count;
uint32 max_page_count = wasm_runtime_get_max_mem( uint32 max_page_count = wasm_runtime_get_max_mem(
max_memory_pages, import->u.memory.init_page_count, max_memory_pages, import->u.memory.mem_type.init_page_count,
import->u.memory.max_page_count); import->u.memory.mem_type.max_page_count);
uint32 flags = import->u.memory.flags; uint32 flags = import->u.memory.mem_type.flags;
uint32 actual_heap_size = heap_size; uint32 actual_heap_size = heap_size;
#if WASM_ENABLE_MULTI_MODULE != 0 #if WASM_ENABLE_MULTI_MODULE != 0

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

@ -272,9 +272,9 @@ DumpDetails(AoTFile *aot)
AOTImportMemory memory = import_memories[index]; AOTImportMemory memory = import_memories[index];
printf(" -[%u] num_bytes_per_page:%5u init_page_count:%5u " printf(" -[%u] num_bytes_per_page:%5u init_page_count:%5u "
"max_page_count:%5u module_name: %s memory_name: %s\n", "max_page_count:%5u module_name: %s memory_name: %s\n",
index, memory.num_bytes_per_page, memory.mem_init_page_count, index, memory.memory.num_bytes_per_page,
memory.mem_max_page_count, memory.module_name, memory.memory.init_page_count, memory.memory.max_page_count,
memory.memory_name); memory.module_name, memory.memory_name);
} }
printf("\n"); printf("\n");
@ -365,10 +365,10 @@ DumpDetails(AoTFile *aot)
for (uint32_t index = 0; index < memory_count; index++) { for (uint32_t index = 0; index < memory_count; index++) {
AOTMemory memory = memories[index]; AOTMemory memory = memories[index];
printf(" -[%u] memory_flags:%5u bytes_per_page:%5u " printf(" -[%u] flags:%5u bytes_per_page:%5u "
"init_page_count:%5u max_page_count:%5u\n", "init_page_count:%5u max_page_count:%5u\n",
index, memory.memory_flags, memory.num_bytes_per_page, index, memory.flags, memory.num_bytes_per_page,
memory.mem_init_page_count, memory.mem_max_page_count); memory.init_page_count, memory.max_page_count);
} }
printf("\n\n"); printf("\n\n");