gnh1201/wasm-micro-runtime
1
0
Fork 0
mirror of https://github.com/bytecodealliance/wasm-micro-runtime.git synced 2024-10-04 15:12:25 +00:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity

Refactor APIs and data structures as preliminary work for Memory64 (#3209)

Browse Source 
# Change the data type representing linear memory address from u32 to u64

## APIs signature changes
- (Export)wasm_runtime_module_malloc
  - wasm_module_malloc
    - wasm_module_malloc_internal
  - aot_module_malloc
    - aot_module_malloc_internal
- wasm_runtime_module_realloc
  - wasm_module_realloc
    - wasm_module_realloc_internal
  - aot_module_realloc
    - aot_module_realloc_internal
- (Export)wasm_runtime_module_free
  - wasm_module_free
    - wasm_module_free_internal
  - aot_module_malloc
    - aot_module_free_internal
- (Export)wasm_runtime_module_dup_data
  - wasm_module_dup_data
  - aot_module_dup_data
- (Export)wasm_runtime_validate_app_addr
- (Export)wasm_runtime_validate_app_str_addr
- (Export)wasm_runtime_validate_native_addr
- (Export)wasm_runtime_addr_app_to_native
- (Export)wasm_runtime_addr_native_to_app
- (Export)wasm_runtime_get_app_addr_range
- aot_set_aux_stack
- aot_get_aux_stack
- wasm_set_aux_stack
- wasm_get_aux_stack
- aot_check_app_addr_and_convert, wasm_check_app_addr_and_convert
  and jit_check_app_addr_and_convert
- wasm_exec_env_set_aux_stack
- wasm_exec_env_get_aux_stack
- wasm_cluster_create_thread
- wasm_cluster_allocate_aux_stack
- wasm_cluster_free_aux_stack

## Data structure changes
- WASMModule and AOTModule
  - field aux_data_end, aux_heap_base and aux_stack_bottom
- WASMExecEnv
  - field aux_stack_boundary and aux_stack_bottom
- AOTCompData
  - field aux_data_end, aux_heap_base and aux_stack_bottom
- WASMMemoryInstance(AOTMemoryInstance)
  - field memory_data_size and change __padding to is_memory64
- WASMModuleInstMemConsumption
  - field total_size and memories_size
- WASMDebugExecutionMemory
  - field start_offset and current_pos
- WASMCluster
  - field stack_tops

## Components that are affected by the APIs and data structure changes
- libc-builtin
- libc-emcc
- libc-uvwasi
- libc-wasi
- Python and Go Language Embedding
- Interpreter Debug engine
- Multi-thread: lib-pthread, wasi-threads and thread manager
This commit is contained in:
Wenyong Huang 2024-03-12 11:38:50 +08:00 committed by GitHub
parent b6216a5f8a
commit 0ee5ffce85
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
46 changed files with 1006 additions and 754 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -2423,13 +2423,22 @@ load_init_data_section(const uint8 *buf, const uint8 *buf_end,
} }
read_uint32(p, p_end, module->aux_data_end_global_index); read_uint32(p, p_end, module->aux_data_end_global_index);
read_uint32(p, p_end, module->aux_data_end); read_uint64(p, p_end, module->aux_data_end);
read_uint32(p, p_end, module->aux_heap_base_global_index); read_uint32(p, p_end, module->aux_heap_base_global_index);
read_uint32(p, p_end, module->aux_heap_base); read_uint64(p, p_end, module->aux_heap_base);
read_uint32(p, p_end, module->aux_stack_top_global_index); read_uint32(p, p_end, module->aux_stack_top_global_index);
read_uint32(p, p_end, module->aux_stack_bottom); read_uint64(p, p_end, module->aux_stack_bottom);
read_uint32(p, p_end, module->aux_stack_size); read_uint32(p, p_end, module->aux_stack_size);
if (module->aux_data_end >= MAX_LINEAR_MEMORY_SIZE
|| module->aux_heap_base >= MAX_LINEAR_MEMORY_SIZE
|| module->aux_stack_bottom >= MAX_LINEAR_MEMORY_SIZE) {
set_error_buf(
error_buf, error_buf_size,
"invalid range of aux_date_end/aux_heap_base/aux_stack_bottom");
return false;
}
if (!load_object_data_sections_info(&p, p_end, module, if (!load_object_data_sections_info(&p, p_end, module,
is_load_from_file_buf, error_buf, is_load_from_file_buf, error_buf,
error_buf_size)) error_buf_size))

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

@ -50,7 +50,7 @@ bh_static_assert(offsetof(AOTModuleInstance, cur_exception)
bh_static_assert(offsetof(AOTModuleInstance, global_table_data) bh_static_assert(offsetof(AOTModuleInstance, global_table_data)
== 13 * sizeof(uint64) + 128 + 11 * sizeof(uint64)); == 13 * sizeof(uint64) + 128 + 11 * sizeof(uint64));
bh_static_assert(sizeof(AOTMemoryInstance) == 104); bh_static_assert(sizeof(AOTMemoryInstance) == 112);
bh_static_assert(offsetof(AOTTableInstance, elems) == 24); bh_static_assert(offsetof(AOTTableInstance, elems) == 24);
bh_static_assert(offsetof(AOTModuleInstanceExtra, stack_sizes) == 0); bh_static_assert(offsetof(AOTModuleInstanceExtra, stack_sizes) == 0);
@ -792,9 +792,10 @@ memory_instantiate(AOTModuleInstance *module_inst, AOTModuleInstance *parent,
uint32 max_page_count = uint32 max_page_count =
wasm_runtime_get_max_mem(max_memory_pages, memory->mem_init_page_count, wasm_runtime_get_max_mem(max_memory_pages, memory->mem_init_page_count,
memory->mem_max_page_count); memory->mem_max_page_count);
uint32 inc_page_count, aux_heap_base, 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;
uint32 heap_offset = num_bytes_per_page * init_page_count; uint64 aux_heap_base,
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;
@ -819,6 +820,15 @@ memory_instantiate(AOTModuleInstance *module_inst, AOTModuleInstance *parent,
heap_size = 0; heap_size = 0;
} }
/* If initial memory is the largest size allowed, disallowing insert host
* managed heap */
if (heap_size > 0 && heap_offset == MAX_LINEAR_MEMORY_SIZE) {
set_error_buf(error_buf, error_buf_size,
"failed to insert app heap into linear memory, "
"try using `--heap-size=0` option");
return NULL;
}
if (init_page_count == max_page_count && init_page_count == 1) { if (init_page_count == max_page_count && init_page_count == 1) {
/* If only one page and at most one page, we just append /* If only one page and at most one page, we just append
the app heap to the end of linear memory, enlarge the the app heap to the end of linear memory, enlarge the
@ -842,7 +852,7 @@ memory_instantiate(AOTModuleInstance *module_inst, AOTModuleInstance *parent,
} }
else if (module->aux_heap_base_global_index != (uint32)-1 else if (module->aux_heap_base_global_index != (uint32)-1
&& module->aux_heap_base && module->aux_heap_base
< num_bytes_per_page * init_page_count) { < (uint64)num_bytes_per_page * init_page_count) {
/* Insert app heap before __heap_base */ /* Insert app heap before __heap_base */
aux_heap_base = module->aux_heap_base; aux_heap_base = module->aux_heap_base;
bytes_of_last_page = aux_heap_base % num_bytes_per_page; bytes_of_last_page = aux_heap_base % num_bytes_per_page;
@ -869,15 +879,15 @@ memory_instantiate(AOTModuleInstance *module_inst, AOTModuleInstance *parent,
- module->import_global_count; - module->import_global_count;
global_addr = module_inst->global_data global_addr = module_inst->global_data
+ module->globals[global_idx].data_offset; + module->globals[global_idx].data_offset;
*(uint32 *)global_addr = aux_heap_base; *(uint32 *)global_addr = (uint32)aux_heap_base;
LOG_VERBOSE("Reset __heap_base global to %u", aux_heap_base); LOG_VERBOSE("Reset __heap_base global to %u", aux_heap_base);
} }
else { else {
/* Insert app heap before new page */ /* Insert app heap before new page */
inc_page_count = inc_page_count =
(heap_size + num_bytes_per_page - 1) / num_bytes_per_page; (heap_size + num_bytes_per_page - 1) / num_bytes_per_page;
heap_offset = num_bytes_per_page * init_page_count; heap_offset = (uint64)num_bytes_per_page * init_page_count;
heap_size = num_bytes_per_page * inc_page_count; heap_size = (uint64)num_bytes_per_page * inc_page_count;
if (heap_size > 0) if (heap_size > 0)
heap_size -= 1 * BH_KB; heap_size -= 1 * BH_KB;
} }
@ -889,19 +899,9 @@ memory_instantiate(AOTModuleInstance *module_inst, AOTModuleInstance *parent,
"try using `--heap-size=0` option"); "try using `--heap-size=0` option");
return NULL; return NULL;
} }
else if (init_page_count == DEFAULT_MAX_PAGES) {
num_bytes_per_page = UINT32_MAX;
init_page_count = max_page_count = 1;
}
if (max_page_count > DEFAULT_MAX_PAGES) if (max_page_count > DEFAULT_MAX_PAGES)
max_page_count = DEFAULT_MAX_PAGES; max_page_count = DEFAULT_MAX_PAGES;
} }
else { /* heap_size == 0 */
if (init_page_count == DEFAULT_MAX_PAGES) {
num_bytes_per_page = UINT32_MAX;
init_page_count = max_page_count = 1;
}
}
LOG_VERBOSE("Memory instantiate:"); LOG_VERBOSE("Memory instantiate:");
LOG_VERBOSE(" page bytes: %u, init pages: %u, max pages: %u", LOG_VERBOSE(" page bytes: %u, init pages: %u, max pages: %u",
@ -911,7 +911,7 @@ memory_instantiate(AOTModuleInstance *module_inst, AOTModuleInstance *parent,
LOG_VERBOSE(" heap offset: %u, heap size: %d\n", heap_offset, heap_size); LOG_VERBOSE(" heap offset: %u, heap size: %d\n", heap_offset, heap_size);
max_memory_data_size = (uint64)num_bytes_per_page * max_page_count; max_memory_data_size = (uint64)num_bytes_per_page * max_page_count;
bh_assert(max_memory_data_size <= 4 * (uint64)BH_GB); bh_assert(max_memory_data_size <= MAX_LINEAR_MEMORY_SIZE);
(void)max_memory_data_size; (void)max_memory_data_size;
if (wasm_allocate_linear_memory(&p, is_shared_memory, num_bytes_per_page, if (wasm_allocate_linear_memory(&p, is_shared_memory, num_bytes_per_page,
@ -927,11 +927,11 @@ memory_instantiate(AOTModuleInstance *module_inst, AOTModuleInstance *parent,
memory_inst->num_bytes_per_page = num_bytes_per_page; memory_inst->num_bytes_per_page = num_bytes_per_page;
memory_inst->cur_page_count = init_page_count; memory_inst->cur_page_count = init_page_count;
memory_inst->max_page_count = max_page_count; memory_inst->max_page_count = max_page_count;
memory_inst->memory_data_size = (uint32)memory_data_size; memory_inst->memory_data_size = memory_data_size;
/* Init memory info */ /* Init memory info */
memory_inst->memory_data = p; memory_inst->memory_data = p;
memory_inst->memory_data_end = p + (uint32)memory_data_size; memory_inst->memory_data_end = p + memory_data_size;
/* Initialize heap info */ /* Initialize heap info */
memory_inst->heap_data = p + heap_offset; memory_inst->heap_data = p + heap_offset;
@ -1098,7 +1098,7 @@ memories_instantiate(AOTModuleInstance *module_inst, AOTModuleInstance *parent,
if (memory_inst->memory_data) { if (memory_inst->memory_data) {
bh_memcpy_s((uint8 *)memory_inst->memory_data + base_offset, bh_memcpy_s((uint8 *)memory_inst->memory_data + base_offset,
memory_inst->memory_data_size - base_offset, (uint32)memory_inst->memory_data_size - base_offset,
data_seg->bytes, length); data_seg->bytes, length);
} }
} }
@ -2472,9 +2472,9 @@ execute_free_function(AOTModuleInstance *module_inst, WASMExecEnv *exec_env,
return ret; return ret;
} }
uint32 uint64
aot_module_malloc_internal(AOTModuleInstance *module_inst, aot_module_malloc_internal(AOTModuleInstance *module_inst,
WASMExecEnv *exec_env, uint32 size, WASMExecEnv *exec_env, uint64 size,
void **p_native_addr) void **p_native_addr)
{ {
AOTMemoryInstance *memory_inst = aot_get_default_memory(module_inst); AOTMemoryInstance *memory_inst = aot_get_default_memory(module_inst);
@ -2482,13 +2482,16 @@ aot_module_malloc_internal(AOTModuleInstance *module_inst,
uint8 *addr = NULL; uint8 *addr = NULL;
uint32 offset = 0; uint32 offset = 0;
/* TODO: Memory64 size check based on memory idx type */
bh_assert(size <= UINT32_MAX);
if (!memory_inst) { if (!memory_inst) {
aot_set_exception(module_inst, "uninitialized memory"); aot_set_exception(module_inst, "uninitialized memory");
return 0; return 0;
} }
if (memory_inst->heap_handle) { if (memory_inst->heap_handle) {
addr = mem_allocator_malloc(memory_inst->heap_handle, size); addr = mem_allocator_malloc(memory_inst->heap_handle, (uint32)size);
} }
else if (module->malloc_func_index != (uint32)-1 else if (module->malloc_func_index != (uint32)-1
&& module->free_func_index != (uint32)-1) { && module->free_func_index != (uint32)-1) {
@ -2513,7 +2516,7 @@ aot_module_malloc_internal(AOTModuleInstance *module_inst,
if (!malloc_func if (!malloc_func
|| !execute_malloc_function(module_inst, exec_env, malloc_func, || !execute_malloc_function(module_inst, exec_env, malloc_func,
retain_func, size, &offset)) { retain_func, (uint32)size, &offset)) {
return 0; return 0;
} }
addr = offset ? (uint8 *)memory_inst->memory_data + offset : NULL; addr = offset ? (uint8 *)memory_inst->memory_data + offset : NULL;
@ -2532,17 +2535,21 @@ aot_module_malloc_internal(AOTModuleInstance *module_inst,
} }
if (p_native_addr) if (p_native_addr)
*p_native_addr = addr; *p_native_addr = addr;
return (uint32)(addr - memory_inst->memory_data); return (uint64)(addr - memory_inst->memory_data);
} }
uint32 uint64
aot_module_realloc_internal(AOTModuleInstance *module_inst, aot_module_realloc_internal(AOTModuleInstance *module_inst,
WASMExecEnv *exec_env, uint32 ptr, uint32 size, WASMExecEnv *exec_env, uint64 ptr, uint64 size,
void **p_native_addr) void **p_native_addr)
{ {
AOTMemoryInstance *memory_inst = aot_get_default_memory(module_inst); AOTMemoryInstance *memory_inst = aot_get_default_memory(module_inst);
uint8 *addr = NULL; uint8 *addr = NULL;
/* TODO: Memory64 ptr and size check based on memory idx type */
bh_assert(ptr <= UINT32_MAX);
bh_assert(size <= UINT32_MAX);
if (!memory_inst) { if (!memory_inst) {
aot_set_exception(module_inst, "uninitialized memory"); aot_set_exception(module_inst, "uninitialized memory");
return 0; return 0;
@ -2551,7 +2558,8 @@ aot_module_realloc_internal(AOTModuleInstance *module_inst,
if (memory_inst->heap_handle) { if (memory_inst->heap_handle) {
addr = mem_allocator_realloc( addr = mem_allocator_realloc(
memory_inst->heap_handle, memory_inst->heap_handle,
ptr ? memory_inst->memory_data + ptr : NULL, size); (uint32)ptr ? memory_inst->memory_data + (uint32)ptr : NULL,
(uint32)size);
} }
/* Only support realloc in WAMR's app heap */ /* Only support realloc in WAMR's app heap */
@ -2570,12 +2578,12 @@ aot_module_realloc_internal(AOTModuleInstance *module_inst,
if (p_native_addr) if (p_native_addr)
*p_native_addr = addr; *p_native_addr = addr;
return (uint32)(addr - memory_inst->memory_data); return (uint64)(addr - memory_inst->memory_data);
} }
void void
aot_module_free_internal(AOTModuleInstance *module_inst, WASMExecEnv *exec_env, aot_module_free_internal(AOTModuleInstance *module_inst, WASMExecEnv *exec_env,
uint32 ptr) uint64 ptr)
{ {
AOTMemoryInstance *memory_inst = aot_get_default_memory(module_inst); AOTMemoryInstance *memory_inst = aot_get_default_memory(module_inst);
AOTModule *module = (AOTModule *)module_inst->module; AOTModule *module = (AOTModule *)module_inst->module;
@ -2584,8 +2592,11 @@ aot_module_free_internal(AOTModuleInstance *module_inst, WASMExecEnv *exec_env,
return; return;
} }
/* TODO: Memory64 ptr and size check based on memory idx type */
bh_assert(ptr <= UINT32_MAX);
if (ptr) { if (ptr) {
uint8 *addr = memory_inst->memory_data + ptr; uint8 *addr = memory_inst->memory_data + (uint32)ptr;
uint8 *memory_data_end; uint8 *memory_data_end;
/* memory->memory_data_end may be changed in memory grow */ /* memory->memory_data_end may be changed in memory grow */
@ -2616,20 +2627,21 @@ aot_module_free_internal(AOTModuleInstance *module_inst, WASMExecEnv *exec_env,
free_func = aot_lookup_function(module_inst, "__unpin", "(i)i"); free_func = aot_lookup_function(module_inst, "__unpin", "(i)i");
if (free_func) if (free_func)
execute_free_function(module_inst, exec_env, free_func, ptr); execute_free_function(module_inst, exec_env, free_func,
(uint32)ptr);
} }
} }
} }
uint32 uint64
aot_module_malloc(AOTModuleInstance *module_inst, uint32 size, aot_module_malloc(AOTModuleInstance *module_inst, uint64 size,
void **p_native_addr) void **p_native_addr)
{ {
return aot_module_malloc_internal(module_inst, NULL, size, p_native_addr); return aot_module_malloc_internal(module_inst, NULL, size, p_native_addr);
} }
uint32 uint64
aot_module_realloc(AOTModuleInstance *module_inst, uint32 ptr, uint32 size, aot_module_realloc(AOTModuleInstance *module_inst, uint64 ptr, uint64 size,
void **p_native_addr) void **p_native_addr)
{ {
return aot_module_realloc_internal(module_inst, NULL, ptr, size, return aot_module_realloc_internal(module_inst, NULL, ptr, size,
@ -2637,23 +2649,27 @@ aot_module_realloc(AOTModuleInstance *module_inst, uint32 ptr, uint32 size,
} }
void void
aot_module_free(AOTModuleInstance *module_inst, uint32 ptr) aot_module_free(AOTModuleInstance *module_inst, uint64 ptr)
{ {
aot_module_free_internal(module_inst, NULL, ptr); aot_module_free_internal(module_inst, NULL, ptr);
} }
uint32 uint64
aot_module_dup_data(AOTModuleInstance *module_inst, const char *src, aot_module_dup_data(AOTModuleInstance *module_inst, const char *src,
uint32 size) uint64 size)
{ {
char *buffer; char *buffer;
uint32 buffer_offset = uint64 buffer_offset;
aot_module_malloc(module_inst, size, (void **)&buffer);
/* TODO: Memory64 size check based on memory idx type */
bh_assert(size <= UINT32_MAX);
buffer_offset = aot_module_malloc(module_inst, size, (void **)&buffer);
if (buffer_offset != 0) { if (buffer_offset != 0) {
buffer = wasm_runtime_addr_app_to_native( buffer = wasm_runtime_addr_app_to_native(
(WASMModuleInstanceCommon *)module_inst, buffer_offset); (WASMModuleInstanceCommon *)module_inst, buffer_offset);
bh_memcpy_s(buffer, size, src, size); bh_memcpy_s(buffer, (uint32)size, src, (uint32)size);
} }
return buffer_offset; return buffer_offset;
} }
@ -2935,7 +2951,7 @@ fail:
bool bool
aot_check_app_addr_and_convert(AOTModuleInstance *module_inst, bool is_str, aot_check_app_addr_and_convert(AOTModuleInstance *module_inst, bool is_str,
uint32 app_buf_addr, uint32 app_buf_size, uint64 app_buf_addr, uint64 app_buf_size,
void **p_native_addr) void **p_native_addr)
{ {
bool ret; bool ret;
@ -2999,7 +3015,7 @@ aot_memory_init(AOTModuleInstance *module_inst, uint32 seg_index, uint32 offset,
} }
if (!wasm_runtime_validate_app_addr((WASMModuleInstanceCommon *)module_inst, if (!wasm_runtime_validate_app_addr((WASMModuleInstanceCommon *)module_inst,
dst, len)) (uint64)dst, (uint64)len))
return false; return false;
if ((uint64)offset + (uint64)len > seg_len) { if ((uint64)offset + (uint64)len > seg_len) {
@ -3008,10 +3024,11 @@ aot_memory_init(AOTModuleInstance *module_inst, uint32 seg_index, uint32 offset,
} }
maddr = wasm_runtime_addr_app_to_native( maddr = wasm_runtime_addr_app_to_native(
(WASMModuleInstanceCommon *)module_inst, dst); (WASMModuleInstanceCommon *)module_inst, (uint64)dst);
SHARED_MEMORY_LOCK(memory_inst); SHARED_MEMORY_LOCK(memory_inst);
bh_memcpy_s(maddr, memory_inst->memory_data_size - dst, data + offset, len); bh_memcpy_s(maddr, (uint32)(memory_inst->memory_data_size - dst),
data + offset, len);
SHARED_MEMORY_UNLOCK(memory_inst); SHARED_MEMORY_UNLOCK(memory_inst);
return true; return true;
} }
@ -3030,14 +3047,14 @@ aot_data_drop(AOTModuleInstance *module_inst, uint32 seg_index)
#if WASM_ENABLE_THREAD_MGR != 0 #if WASM_ENABLE_THREAD_MGR != 0
bool bool
aot_set_aux_stack(WASMExecEnv *exec_env, uint32 start_offset, uint32 size) aot_set_aux_stack(WASMExecEnv *exec_env, uint64 start_offset, uint32 size)
{ {
AOTModuleInstance *module_inst = (AOTModuleInstance *)exec_env->module_inst; AOTModuleInstance *module_inst = (AOTModuleInstance *)exec_env->module_inst;
AOTModule *module = (AOTModule *)module_inst->module; AOTModule *module = (AOTModule *)module_inst->module;
uint32 stack_top_idx = module->aux_stack_top_global_index; uint32 stack_top_idx = module->aux_stack_top_global_index;
uint32 data_end = module->aux_data_end; uint64 data_end = module->aux_data_end;
uint32 stack_bottom = module->aux_stack_bottom; uint64 stack_bottom = module->aux_stack_bottom;
bool is_stack_before_data = stack_bottom < data_end ? true : false; bool is_stack_before_data = stack_bottom < data_end ? true : false;
/* Check the aux stack space, currently we don't allocate space in heap */ /* Check the aux stack space, currently we don't allocate space in heap */
@ -3050,12 +3067,13 @@ aot_set_aux_stack(WASMExecEnv *exec_env, uint32 start_offset, uint32 size)
set the initial value for the global */ set the initial value for the global */
uint32 global_offset = module->globals[stack_top_idx].data_offset; uint32 global_offset = module->globals[stack_top_idx].data_offset;
uint8 *global_addr = module_inst->global_data + global_offset; uint8 *global_addr = module_inst->global_data + global_offset;
*(int32 *)global_addr = start_offset; /* TODO: Memory64 the type i32/i64 depends on memory idx type*/
*(int32 *)global_addr = (uint32)start_offset;
/* The aux stack boundary is a constant value, /* The aux stack boundary is a constant value,
set the value to exec_env */ set the value to exec_env */
exec_env->aux_stack_boundary.boundary = start_offset - size; exec_env->aux_stack_boundary = (uintptr_t)start_offset - size;
exec_env->aux_stack_bottom.bottom = start_offset; exec_env->aux_stack_bottom = (uintptr_t)start_offset;
return true; return true;
} }
@ -3063,14 +3081,14 @@ aot_set_aux_stack(WASMExecEnv *exec_env, uint32 start_offset, uint32 size)
} }
bool bool
aot_get_aux_stack(WASMExecEnv *exec_env, uint32 *start_offset, uint32 *size) aot_get_aux_stack(WASMExecEnv *exec_env, uint64 *start_offset, uint32 *size)
{ {
AOTModuleInstance *module_inst = (AOTModuleInstance *)exec_env->module_inst; AOTModuleInstance *module_inst = (AOTModuleInstance *)exec_env->module_inst;
AOTModule *module = (AOTModule *)module_inst->module; AOTModule *module = (AOTModule *)module_inst->module;
/* The aux stack information is resolved in loader /* The aux stack information is resolved in loader
and store in module */ and store in module */
uint32 stack_bottom = module->aux_stack_bottom; uint64 stack_bottom = module->aux_stack_bottom;
uint32 total_aux_stack_size = module->aux_stack_size; uint32 total_aux_stack_size = module->aux_stack_size;
if (stack_bottom != 0 && total_aux_stack_size != 0) { if (stack_bottom != 0 && total_aux_stack_size != 0) {

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

@ -246,19 +246,19 @@ typedef struct AOTModule {
-1 means unexported */ -1 means unexported */
uint32 aux_data_end_global_index; uint32 aux_data_end_global_index;
/* auxiliary __data_end exported by wasm app */ /* auxiliary __data_end exported by wasm app */
uint32 aux_data_end; uint64 aux_data_end;
/* the index of auxiliary __heap_base global, /* the index of auxiliary __heap_base global,
-1 means unexported */ -1 means unexported */
uint32 aux_heap_base_global_index; uint32 aux_heap_base_global_index;
/* auxiliary __heap_base exported by wasm app */ /* auxiliary __heap_base exported by wasm app */
uint32 aux_heap_base; uint64 aux_heap_base;
/* the index of auxiliary stack top global, /* the index of auxiliary stack top global,
-1 means unexported */ -1 means unexported */
uint32 aux_stack_top_global_index; uint32 aux_stack_top_global_index;
/* auxiliary stack bottom resolved */ /* auxiliary stack bottom resolved */
uint32 aux_stack_bottom; uint64 aux_stack_bottom;
/* auxiliary stack size resolved */ /* auxiliary stack size resolved */
uint32 aux_stack_size; uint32 aux_stack_size;
@ -558,32 +558,32 @@ aot_get_exception(AOTModuleInstance *module_inst);
bool bool
aot_copy_exception(AOTModuleInstance *module_inst, char *exception_buf); aot_copy_exception(AOTModuleInstance *module_inst, char *exception_buf);
uint32 uint64
aot_module_malloc_internal(AOTModuleInstance *module_inst, WASMExecEnv *env, aot_module_malloc_internal(AOTModuleInstance *module_inst, WASMExecEnv *env,
uint32 size, void **p_native_addr); uint64 size, void **p_native_addr);
uint32 uint64
aot_module_realloc_internal(AOTModuleInstance *module_inst, WASMExecEnv *env, aot_module_realloc_internal(AOTModuleInstance *module_inst, WASMExecEnv *env,
uint32 ptr, uint32 size, void **p_native_addr); uint64 ptr, uint64 size, void **p_native_addr);
void void
aot_module_free_internal(AOTModuleInstance *module_inst, WASMExecEnv *env, aot_module_free_internal(AOTModuleInstance *module_inst, WASMExecEnv *env,
uint32 ptr); uint64 ptr);
uint32 uint64
aot_module_malloc(AOTModuleInstance *module_inst, uint32 size, aot_module_malloc(AOTModuleInstance *module_inst, uint64 size,
void **p_native_addr); void **p_native_addr);
uint32 uint64
aot_module_realloc(AOTModuleInstance *module_inst, uint32 ptr, uint32 size, aot_module_realloc(AOTModuleInstance *module_inst, uint64 ptr, uint64 size,
void **p_native_addr); void **p_native_addr);
void void
aot_module_free(AOTModuleInstance *module_inst, uint32 ptr); aot_module_free(AOTModuleInstance *module_inst, uint64 ptr);
uint32 uint64
aot_module_dup_data(AOTModuleInstance *module_inst, const char *src, aot_module_dup_data(AOTModuleInstance *module_inst, const char *src,
uint32 size); uint64 size);
bool bool
aot_enlarge_memory(AOTModuleInstance *module_inst, uint32 inc_page_count); aot_enlarge_memory(AOTModuleInstance *module_inst, uint32 inc_page_count);
@ -605,7 +605,7 @@ aot_call_indirect(WASMExecEnv *exec_env, uint32 tbl_idx, uint32 table_elem_idx,
*/ */
bool bool
aot_check_app_addr_and_convert(AOTModuleInstance *module_inst, bool is_str, aot_check_app_addr_and_convert(AOTModuleInstance *module_inst, bool is_str,
uint32 app_buf_addr, uint32 app_buf_size, uint64 app_buf_addr, uint64 app_buf_size,
void **p_native_addr); void **p_native_addr);
uint32 uint32
@ -634,10 +634,10 @@ aot_data_drop(AOTModuleInstance *module_inst, uint32 seg_index);
#if WASM_ENABLE_THREAD_MGR != 0 #if WASM_ENABLE_THREAD_MGR != 0
bool bool
aot_set_aux_stack(WASMExecEnv *exec_env, uint32 start_offset, uint32 size); aot_set_aux_stack(WASMExecEnv *exec_env, uint64 start_offset, uint32 size);
bool bool
aot_get_aux_stack(WASMExecEnv *exec_env, uint32 *start_offset, uint32 *size); aot_get_aux_stack(WASMExecEnv *exec_env, uint64 *start_offset, uint32 *size);
#endif #endif
void void

7
core/iwasm/common/wasm_application.c
View File

@ -97,7 +97,7 @@ execute_main(WASMModuleInstanceCommon *module_inst, int32 argc, char *argv[])
uint32 argc1 = 0, argv1[2] = { 0 }; uint32 argc1 = 0, argv1[2] = { 0 };
uint32 total_argv_size = 0; uint32 total_argv_size = 0;
uint64 total_size; uint64 total_size;
uint32 argv_buf_offset = 0; uint64 argv_buf_offset = 0;
int32 i; int32 i;
char *argv_buf, *p, *p_end; char *argv_buf, *p, *p_end;
uint32 *argv_offsets, module_type; uint32 *argv_offsets, module_type;
@ -202,7 +202,7 @@ execute_main(WASMModuleInstanceCommon *module_inst, int32 argc, char *argv[])
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(argv_buf_offset = wasm_runtime_module_malloc( || !(argv_buf_offset = wasm_runtime_module_malloc(
module_inst, (uint32)total_size, (void **)&argv_buf))) { module_inst, total_size, (void **)&argv_buf))) {
wasm_runtime_set_exception(module_inst, "allocate memory failed"); wasm_runtime_set_exception(module_inst, "allocate memory failed");
return false; return false;
} }
@ -214,12 +214,13 @@ execute_main(WASMModuleInstanceCommon *module_inst, int32 argc, char *argv[])
for (i = 0; i < argc; i++) { for (i = 0; i < argc; i++) {
bh_memcpy_s(p, (uint32)(p_end - p), argv[i], bh_memcpy_s(p, (uint32)(p_end - p), argv[i],
(uint32)(strlen(argv[i]) + 1)); (uint32)(strlen(argv[i]) + 1));
argv_offsets[i] = argv_buf_offset + (uint32)(p - argv_buf); argv_offsets[i] = (uint32)argv_buf_offset + (uint32)(p - argv_buf);
p += strlen(argv[i]) + 1; p += strlen(argv[i]) + 1;
} }
argc1 = 2; argc1 = 2;
argv1[0] = (uint32)argc; argv1[0] = (uint32)argc;
/* TODO: memory64 uint64 when the memory idx is i64 */
argv1[1] = argv1[1] =
(uint32)wasm_runtime_addr_native_to_app(module_inst, argv_offsets); (uint32)wasm_runtime_addr_native_to_app(module_inst, argv_offsets);
} }

12
core/iwasm/common/wasm_exec_env.c
View File

@ -149,9 +149,9 @@ wasm_exec_env_create(struct WASMModuleInstanceCommon *module_inst,
/* Set the aux_stack_boundary and aux_stack_bottom */ /* Set the aux_stack_boundary and aux_stack_bottom */
if (module_inst->module_type == Wasm_Module_Bytecode) { if (module_inst->module_type == Wasm_Module_Bytecode) {
WASMModule *module = ((WASMModuleInstance *)module_inst)->module; WASMModule *module = ((WASMModuleInstance *)module_inst)->module;
exec_env->aux_stack_bottom.bottom = module->aux_stack_bottom; exec_env->aux_stack_bottom = (uintptr_t)module->aux_stack_bottom;
exec_env->aux_stack_boundary.boundary = exec_env->aux_stack_boundary =
module->aux_stack_bottom - module->aux_stack_size; (uintptr_t)module->aux_stack_bottom - module->aux_stack_size;
#if WASM_ENABLE_GC != 0 #if WASM_ENABLE_GC != 0
gc_heap_handle = gc_heap_handle =
((WASMModuleInstance *)module_inst)->e->common.gc_heap_pool; ((WASMModuleInstance *)module_inst)->e->common.gc_heap_pool;
@ -163,9 +163,9 @@ wasm_exec_env_create(struct WASMModuleInstanceCommon *module_inst,
if (module_inst->module_type == Wasm_Module_AoT) { if (module_inst->module_type == Wasm_Module_AoT) {
AOTModule *module = AOTModule *module =
(AOTModule *)((AOTModuleInstance *)module_inst)->module; (AOTModule *)((AOTModuleInstance *)module_inst)->module;
exec_env->aux_stack_bottom.bottom = module->aux_stack_bottom; exec_env->aux_stack_bottom = (uintptr_t)module->aux_stack_bottom;
exec_env->aux_stack_boundary.boundary = exec_env->aux_stack_boundary =
module->aux_stack_bottom - module->aux_stack_size; (uintptr_t)module->aux_stack_bottom - module->aux_stack_size;
#if WASM_ENABLE_GC != 0 #if WASM_ENABLE_GC != 0
gc_heap_handle = gc_heap_handle =
((AOTModuleInstanceExtra *)((AOTModuleInstance *)module_inst)->e) ((AOTModuleInstanceExtra *)((AOTModuleInstance *)module_inst)->e)

13
core/iwasm/common/wasm_exec_env.h
View File

@ -62,16 +62,10 @@ typedef struct WASMExecEnv {
WASMSuspendFlags suspend_flags; WASMSuspendFlags suspend_flags;
/* Auxiliary stack boundary */ /* Auxiliary stack boundary */
union { uintptr_t aux_stack_boundary;
uint32 boundary;
uintptr_t __padding__;
} aux_stack_boundary;
/* Auxiliary stack bottom */ /* Auxiliary stack bottom */
union { uintptr_t aux_stack_bottom;
uint32 bottom;
uintptr_t __padding__;
} aux_stack_bottom;
#if WASM_ENABLE_AOT != 0 #if WASM_ENABLE_AOT != 0
/* Native symbol list, reserved */ /* Native symbol list, reserved */
@ -195,8 +189,7 @@ wasm_exec_env_destroy(WASMExecEnv *exec_env);
static inline bool static inline bool
wasm_exec_env_is_aux_stack_managed_by_runtime(WASMExecEnv *exec_env) wasm_exec_env_is_aux_stack_managed_by_runtime(WASMExecEnv *exec_env)
{ {
return exec_env->aux_stack_boundary.boundary != 0 return exec_env->aux_stack_boundary != 0 || exec_env->aux_stack_bottom != 0;
|| exec_env->aux_stack_bottom.bottom != 0;
} }
/** /**

77
core/iwasm/common/wasm_memory.c
View File

@ -282,7 +282,7 @@ wasm_runtime_get_mem_alloc_info(mem_alloc_info_t *mem_alloc_info)
bool bool
wasm_runtime_validate_app_addr(WASMModuleInstanceCommon *module_inst_comm, wasm_runtime_validate_app_addr(WASMModuleInstanceCommon *module_inst_comm,
uint32 app_offset, uint32 size) uint64 app_offset, uint64 size)
{ {
WASMModuleInstance *module_inst = (WASMModuleInstance *)module_inst_comm; WASMModuleInstance *module_inst = (WASMModuleInstance *)module_inst_comm;
WASMMemoryInstance *memory_inst; WASMMemoryInstance *memory_inst;
@ -299,8 +299,9 @@ wasm_runtime_validate_app_addr(WASMModuleInstanceCommon *module_inst_comm,
goto fail; goto fail;
} }
/* integer overflow check */ /* boundary overflow check */
if (app_offset > UINT32_MAX - size) { if (size > MAX_LINEAR_MEMORY_SIZE
|| app_offset > MAX_LINEAR_MEMORY_SIZE - size) {
goto fail; goto fail;
} }
@ -320,10 +321,10 @@ fail:
bool bool
wasm_runtime_validate_app_str_addr(WASMModuleInstanceCommon *module_inst_comm, wasm_runtime_validate_app_str_addr(WASMModuleInstanceCommon *module_inst_comm,
uint32 app_str_offset) uint64 app_str_offset)
{ {
WASMModuleInstance *module_inst = (WASMModuleInstance *)module_inst_comm; WASMModuleInstance *module_inst = (WASMModuleInstance *)module_inst_comm;
uint32 app_end_offset; uint64 app_end_offset;
char *str, *str_end; char *str, *str_end;
bh_assert(module_inst_comm->module_type == Wasm_Module_Bytecode bh_assert(module_inst_comm->module_type == Wasm_Module_Bytecode
@ -337,6 +338,12 @@ wasm_runtime_validate_app_str_addr(WASMModuleInstanceCommon *module_inst_comm,
&app_end_offset)) &app_end_offset))
goto fail; goto fail;
/* boundary overflow check, max start offset can only be size - 1, while end
* offset can be size */
if (app_str_offset >= MAX_LINEAR_MEMORY_SIZE
|| app_end_offset > MAX_LINEAR_MEMORY_SIZE)
goto fail;
str = wasm_runtime_addr_app_to_native(module_inst_comm, app_str_offset); str = wasm_runtime_addr_app_to_native(module_inst_comm, app_str_offset);
str_end = str + (app_end_offset - app_str_offset); str_end = str + (app_end_offset - app_str_offset);
while (str < str_end && *str != '\0') while (str < str_end && *str != '\0')
@ -352,7 +359,7 @@ fail:
bool bool
wasm_runtime_validate_native_addr(WASMModuleInstanceCommon *module_inst_comm, wasm_runtime_validate_native_addr(WASMModuleInstanceCommon *module_inst_comm,
void *native_ptr, uint32 size) void *native_ptr, uint64 size)
{ {
WASMModuleInstance *module_inst = (WASMModuleInstance *)module_inst_comm; WASMModuleInstance *module_inst = (WASMModuleInstance *)module_inst_comm;
WASMMemoryInstance *memory_inst; WASMMemoryInstance *memory_inst;
@ -370,8 +377,8 @@ wasm_runtime_validate_native_addr(WASMModuleInstanceCommon *module_inst_comm,
goto fail; goto fail;
} }
/* integer overflow check */ /* boundary overflow check */
if ((uintptr_t)addr > UINTPTR_MAX - size) { if (size > MAX_LINEAR_MEMORY_SIZE || (uintptr_t)addr > UINTPTR_MAX - size) {
goto fail; goto fail;
} }
@ -392,7 +399,7 @@ fail:
void * void *
wasm_runtime_addr_app_to_native(WASMModuleInstanceCommon *module_inst_comm, wasm_runtime_addr_app_to_native(WASMModuleInstanceCommon *module_inst_comm,
uint32 app_offset) uint64 app_offset)
{ {
WASMModuleInstance *module_inst = (WASMModuleInstance *)module_inst_comm; WASMModuleInstance *module_inst = (WASMModuleInstance *)module_inst_comm;
WASMMemoryInstance *memory_inst; WASMMemoryInstance *memory_inst;
@ -411,7 +418,7 @@ wasm_runtime_addr_app_to_native(WASMModuleInstanceCommon *module_inst_comm,
SHARED_MEMORY_LOCK(memory_inst); SHARED_MEMORY_LOCK(memory_inst);
addr = memory_inst->memory_data + app_offset; addr = memory_inst->memory_data + (uintptr_t)app_offset;
if (bounds_checks) { if (bounds_checks) {
if (memory_inst->memory_data <= addr if (memory_inst->memory_data <= addr
@ -430,7 +437,7 @@ wasm_runtime_addr_app_to_native(WASMModuleInstanceCommon *module_inst_comm,
return NULL; return NULL;
} }
uint32 uint64
wasm_runtime_addr_native_to_app(WASMModuleInstanceCommon *module_inst_comm, wasm_runtime_addr_native_to_app(WASMModuleInstanceCommon *module_inst_comm,
void *native_ptr) void *native_ptr)
{ {
@ -438,7 +445,7 @@ wasm_runtime_addr_native_to_app(WASMModuleInstanceCommon *module_inst_comm,
WASMMemoryInstance *memory_inst; WASMMemoryInstance *memory_inst;
uint8 *addr = (uint8 *)native_ptr; uint8 *addr = (uint8 *)native_ptr;
bool bounds_checks; bool bounds_checks;
uint32 ret; uint64 ret;
bh_assert(module_inst_comm->module_type == Wasm_Module_Bytecode bh_assert(module_inst_comm->module_type == Wasm_Module_Bytecode
|| module_inst_comm->module_type == Wasm_Module_AoT); || module_inst_comm->module_type == Wasm_Module_AoT);
@ -455,14 +462,14 @@ wasm_runtime_addr_native_to_app(WASMModuleInstanceCommon *module_inst_comm,
if (bounds_checks) { if (bounds_checks) {
if (memory_inst->memory_data <= addr if (memory_inst->memory_data <= addr
&& addr < memory_inst->memory_data_end) { && addr < memory_inst->memory_data_end) {
ret = (uint32)(addr - memory_inst->memory_data); ret = (uint64)(addr - memory_inst->memory_data);
SHARED_MEMORY_UNLOCK(memory_inst); SHARED_MEMORY_UNLOCK(memory_inst);
return ret; return ret;
} }
} }
/* If bounds checks is disabled, return the offset directly */ /* If bounds checks is disabled, return the offset directly */
else if (addr != NULL) { else if (addr != NULL) {
ret = (uint32)(addr - memory_inst->memory_data); ret = (uint64)(addr - memory_inst->memory_data);
SHARED_MEMORY_UNLOCK(memory_inst); SHARED_MEMORY_UNLOCK(memory_inst);
return ret; return ret;
} }
@ -473,12 +480,12 @@ wasm_runtime_addr_native_to_app(WASMModuleInstanceCommon *module_inst_comm,
bool bool
wasm_runtime_get_app_addr_range(WASMModuleInstanceCommon *module_inst_comm, wasm_runtime_get_app_addr_range(WASMModuleInstanceCommon *module_inst_comm,
uint32 app_offset, uint32 *p_app_start_offset, uint64 app_offset, uint64 *p_app_start_offset,
uint32 *p_app_end_offset) uint64 *p_app_end_offset)
{ {
WASMModuleInstance *module_inst = (WASMModuleInstance *)module_inst_comm; WASMModuleInstance *module_inst = (WASMModuleInstance *)module_inst_comm;
WASMMemoryInstance *memory_inst; WASMMemoryInstance *memory_inst;
uint32 memory_data_size; uint64 memory_data_size;
bh_assert(module_inst_comm->module_type == Wasm_Module_Bytecode bh_assert(module_inst_comm->module_type == Wasm_Module_Bytecode
|| module_inst_comm->module_type == Wasm_Module_AoT); || module_inst_comm->module_type == Wasm_Module_AoT);
@ -541,19 +548,21 @@ wasm_runtime_get_native_addr_range(WASMModuleInstanceCommon *module_inst_comm,
bool bool
wasm_check_app_addr_and_convert(WASMModuleInstance *module_inst, bool is_str, wasm_check_app_addr_and_convert(WASMModuleInstance *module_inst, bool is_str,
uint32 app_buf_addr, uint32 app_buf_size, uint64 app_buf_addr, uint64 app_buf_size,
void **p_native_addr) void **p_native_addr)
{ {
WASMMemoryInstance *memory_inst = wasm_get_default_memory(module_inst); WASMMemoryInstance *memory_inst = wasm_get_default_memory(module_inst);
uint8 *native_addr; uint8 *native_addr;
bool bounds_checks; bool bounds_checks;
bh_assert(app_buf_addr <= UINTPTR_MAX && app_buf_size <= UINTPTR_MAX);
if (!memory_inst) { if (!memory_inst) {
wasm_set_exception(module_inst, "out of bounds memory access"); wasm_set_exception(module_inst, "out of bounds memory access");
return false; return false;
} }
native_addr = memory_inst->memory_data + app_buf_addr; native_addr = memory_inst->memory_data + (uintptr_t)app_buf_addr;
bounds_checks = is_bounds_checks_enabled((wasm_module_inst_t)module_inst); bounds_checks = is_bounds_checks_enabled((wasm_module_inst_t)module_inst);
@ -695,9 +704,9 @@ wasm_enlarge_memory_internal(WASMModuleInstance *module, uint32 inc_page_count)
{ {
WASMMemoryInstance *memory = wasm_get_default_memory(module); WASMMemoryInstance *memory = wasm_get_default_memory(module);
uint8 *memory_data_old, *memory_data_new, *heap_data_old; uint8 *memory_data_old, *memory_data_new, *heap_data_old;
uint32 num_bytes_per_page, heap_size, total_size_old = 0; uint32 num_bytes_per_page, heap_size;
uint32 cur_page_count, max_page_count, total_page_count; uint32 cur_page_count, max_page_count, total_page_count;
uint64 total_size_new; uint64 total_size_old = 0, total_size_new;
bool ret = true, full_size_mmaped; bool ret = true, full_size_mmaped;
enlarge_memory_error_reason_t failure_reason = INTERNAL_ERROR; enlarge_memory_error_reason_t failure_reason = INTERNAL_ERROR;
@ -741,18 +750,12 @@ wasm_enlarge_memory_internal(WASMModuleInstance *module, uint32 inc_page_count)
goto return_func; goto return_func;
} }
bh_assert(total_size_new <= 4 * (uint64)BH_GB); bh_assert(total_size_new <= MAX_LINEAR_MEMORY_SIZE);
if (total_size_new > UINT32_MAX) {
/* Resize to 1 page with size 4G-1 */
num_bytes_per_page = UINT32_MAX;
total_page_count = max_page_count = 1;
total_size_new = UINT32_MAX;
}
if (full_size_mmaped) { if (full_size_mmaped) {
#ifdef BH_PLATFORM_WINDOWS #ifdef BH_PLATFORM_WINDOWS
if (!os_mem_commit(memory->memory_data_end, if (!os_mem_commit(memory->memory_data_end,
(uint32)total_size_new - total_size_old, (uint32)(total_size_new - total_size_old),
MMAP_PROT_READ | MMAP_PROT_WRITE)) { MMAP_PROT_READ | MMAP_PROT_WRITE)) {
ret = false; ret = false;
goto return_func; goto return_func;
@ -760,12 +763,12 @@ wasm_enlarge_memory_internal(WASMModuleInstance *module, uint32 inc_page_count)
#endif #endif
if (os_mprotect(memory->memory_data_end, if (os_mprotect(memory->memory_data_end,
(uint32)total_size_new - total_size_old, (uint32)(total_size_new - total_size_old),
MMAP_PROT_READ | MMAP_PROT_WRITE) MMAP_PROT_READ | MMAP_PROT_WRITE)
!= 0) { != 0) {
#ifdef BH_PLATFORM_WINDOWS #ifdef BH_PLATFORM_WINDOWS
os_mem_decommit(memory->memory_data_end, os_mem_decommit(memory->memory_data_end,
(uint32)total_size_new - total_size_old); (uint32)(total_size_new - total_size_old));
#endif #endif
ret = false; ret = false;
goto return_func; goto return_func;
@ -780,9 +783,9 @@ wasm_enlarge_memory_internal(WASMModuleInstance *module, uint32 inc_page_count)
} }
} }
if (!(memory_data_new = wasm_mremap_linear_memory( if (!(memory_data_new =
memory_data_old, total_size_old, (uint32)total_size_new, wasm_mremap_linear_memory(memory_data_old, total_size_old,
(uint32)total_size_new))) { total_size_new, total_size_new))) {
ret = false; ret = false;
goto return_func; goto return_func;
} }
@ -811,8 +814,8 @@ wasm_enlarge_memory_internal(WASMModuleInstance *module, uint32 inc_page_count)
memory->num_bytes_per_page = num_bytes_per_page; memory->num_bytes_per_page = num_bytes_per_page;
memory->cur_page_count = total_page_count; memory->cur_page_count = total_page_count;
memory->max_page_count = max_page_count; memory->max_page_count = max_page_count;
SET_LINEAR_MEMORY_SIZE(memory, (uint32)total_size_new); SET_LINEAR_MEMORY_SIZE(memory, total_size_new);
memory->memory_data_end = memory->memory_data + (uint32)total_size_new; memory->memory_data_end = memory->memory_data + total_size_new;
wasm_runtime_set_mem_bound_check_bytes(memory, total_size_new); wasm_runtime_set_mem_bound_check_bytes(memory, total_size_new);
@ -926,7 +929,7 @@ wasm_allocate_linear_memory(uint8 **data, bool is_shared_memory,
page_size = os_getpagesize(); page_size = os_getpagesize();
*memory_data_size = init_page_count * num_bytes_per_page; *memory_data_size = init_page_count * num_bytes_per_page;
bh_assert(*memory_data_size <= UINT32_MAX); bh_assert(*memory_data_size <= MAX_LINEAR_MEMORY_SIZE);
align_as_and_cast(*memory_data_size, page_size); align_as_and_cast(*memory_data_size, page_size);
if (map_size > 0) { if (map_size > 0) {

23
core/iwasm/common/wasm_memory.h
View File

@ -9,16 +9,33 @@
#include "bh_common.h" #include "bh_common.h"
#include "../include/wasm_export.h" #include "../include/wasm_export.h"
#include "../interpreter/wasm_runtime.h" #include "../interpreter/wasm_runtime.h"
#include "../common/wasm_shared_memory.h"
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#if WASM_ENABLE_SHARED_MEMORY != 0 #if WASM_ENABLE_SHARED_MEMORY != 0 && BH_ATOMIC_64_IS_ATOMIC != 0
#define GET_LINEAR_MEMORY_SIZE(memory) \ #define GET_LINEAR_MEMORY_SIZE(memory) \
BH_ATOMIC_32_LOAD(memory->memory_data_size) BH_ATOMIC_64_LOAD(memory->memory_data_size)
#define SET_LINEAR_MEMORY_SIZE(memory, size) \ #define SET_LINEAR_MEMORY_SIZE(memory, size) \
BH_ATOMIC_32_STORE(memory->memory_data_size, size) BH_ATOMIC_64_STORE(memory->memory_data_size, size)
#elif WASM_ENABLE_SHARED_MEMORY != 0
static inline uint64
GET_LINEAR_MEMORY_SIZE(const WASMMemoryInstance *memory)
{
SHARED_MEMORY_LOCK(memory);
uint64 memory_data_size = BH_ATOMIC_64_LOAD(memory->memory_data_size);
SHARED_MEMORY_UNLOCK(memory);
return memory_data_size;
}
static inline void
SET_LINEAR_MEMORY_SIZE(WASMMemoryInstance *memory, uint64 size)
{
SHARED_MEMORY_LOCK(memory);
BH_ATOMIC_64_STORE(memory->memory_data_size, size);
SHARED_MEMORY_UNLOCK(memory);
}
#else #else
#define GET_LINEAR_MEMORY_SIZE(memory) memory->memory_data_size #define GET_LINEAR_MEMORY_SIZE(memory) memory->memory_data_size
#define SET_LINEAR_MEMORY_SIZE(memory, size) memory->memory_data_size = size #define SET_LINEAR_MEMORY_SIZE(memory, size) memory->memory_data_size = size

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

@ -1190,7 +1190,7 @@ wasm_runtime_is_built_in_module(const char *module_name)
#if WASM_ENABLE_THREAD_MGR != 0 #if WASM_ENABLE_THREAD_MGR != 0
bool bool
wasm_exec_env_set_aux_stack(WASMExecEnv *exec_env, uint32 start_offset, wasm_exec_env_set_aux_stack(WASMExecEnv *exec_env, uint64 start_offset,
uint32 size) uint32 size)
{ {
WASMModuleInstanceCommon *module_inst = WASMModuleInstanceCommon *module_inst =
@ -1209,7 +1209,7 @@ wasm_exec_env_set_aux_stack(WASMExecEnv *exec_env, uint32 start_offset,
} }
bool bool
wasm_exec_env_get_aux_stack(WASMExecEnv *exec_env, uint32 *start_offset, wasm_exec_env_get_aux_stack(WASMExecEnv *exec_env, uint64 *start_offset,
uint32 *size) uint32 *size)
{ {
WASMModuleInstanceCommon *module_inst = WASMModuleInstanceCommon *module_inst =
@ -1611,11 +1611,11 @@ wasm_runtime_dump_module_inst_mem_consumption(
} }
#endif #endif
os_printf("WASM module inst memory consumption, total size: %u\n", os_printf("WASM module inst memory consumption, total size: %lu\n",
mem_conspn.total_size); mem_conspn.total_size);
os_printf(" module inst struct size: %u\n", os_printf(" module inst struct size: %u\n",
mem_conspn.module_inst_struct_size); mem_conspn.module_inst_struct_size);
os_printf(" memories size: %u\n", mem_conspn.memories_size); os_printf(" memories size: %lu\n", mem_conspn.memories_size);
os_printf(" app heap size: %u\n", mem_conspn.app_heap_size); os_printf(" app heap size: %u\n", mem_conspn.app_heap_size);
os_printf(" tables size: %u\n", mem_conspn.tables_size); os_printf(" tables size: %u\n", mem_conspn.tables_size);
os_printf(" functions size: %u\n", mem_conspn.functions_size); os_printf(" functions size: %u\n", mem_conspn.functions_size);
@ -1650,8 +1650,9 @@ wasm_runtime_dump_mem_consumption(WASMExecEnv *exec_env)
WASMModuleInstanceCommon *module_inst_common; WASMModuleInstanceCommon *module_inst_common;
WASMModuleCommon *module_common = NULL; WASMModuleCommon *module_common = NULL;
void *heap_handle = NULL; void *heap_handle = NULL;
uint32 total_size = 0, app_heap_peak_size = 0; uint32 app_heap_peak_size = 0;
uint32 max_aux_stack_used = -1; uint32 max_aux_stack_used = -1;
uint64 total_size = 0;
module_inst_common = exec_env->module_inst; module_inst_common = exec_env->module_inst;
#if WASM_ENABLE_INTERP != 0 #if WASM_ENABLE_INTERP != 0
@ -2772,9 +2773,9 @@ wasm_runtime_is_bounds_checks_enabled(WASMModuleInstanceCommon *module_inst)
} }
#endif #endif
uint32 uint64
wasm_runtime_module_malloc_internal(WASMModuleInstanceCommon *module_inst, wasm_runtime_module_malloc_internal(WASMModuleInstanceCommon *module_inst,
WASMExecEnv *exec_env, uint32 size, WASMExecEnv *exec_env, uint64 size,
void **p_native_addr) void **p_native_addr)
{ {
#if WASM_ENABLE_INTERP != 0 #if WASM_ENABLE_INTERP != 0
@ -2790,10 +2791,10 @@ wasm_runtime_module_malloc_internal(WASMModuleInstanceCommon *module_inst,
return 0; return 0;
} }
uint32 uint64
wasm_runtime_module_realloc_internal(WASMModuleInstanceCommon *module_inst, wasm_runtime_module_realloc_internal(WASMModuleInstanceCommon *module_inst,
WASMExecEnv *exec_env, uint32 ptr, WASMExecEnv *exec_env, uint64 ptr,
uint32 size, void **p_native_addr) uint64 size, void **p_native_addr)
{ {
#if WASM_ENABLE_INTERP != 0 #if WASM_ENABLE_INTERP != 0
if (module_inst->module_type == Wasm_Module_Bytecode) if (module_inst->module_type == Wasm_Module_Bytecode)
@ -2810,7 +2811,7 @@ wasm_runtime_module_realloc_internal(WASMModuleInstanceCommon *module_inst,
void void
wasm_runtime_module_free_internal(WASMModuleInstanceCommon *module_inst, wasm_runtime_module_free_internal(WASMModuleInstanceCommon *module_inst,
WASMExecEnv *exec_env, uint32 ptr) WASMExecEnv *exec_env, uint64 ptr)
{ {
#if WASM_ENABLE_INTERP != 0 #if WASM_ENABLE_INTERP != 0
if (module_inst->module_type == Wasm_Module_Bytecode) { if (module_inst->module_type == Wasm_Module_Bytecode) {
@ -2828,8 +2829,8 @@ wasm_runtime_module_free_internal(WASMModuleInstanceCommon *module_inst,
#endif #endif
} }
uint32 uint64
wasm_runtime_module_malloc(WASMModuleInstanceCommon *module_inst, uint32 size, wasm_runtime_module_malloc(WASMModuleInstanceCommon *module_inst, uint64 size,
void **p_native_addr) void **p_native_addr)
{ {
#if WASM_ENABLE_INTERP != 0 #if WASM_ENABLE_INTERP != 0
@ -2845,9 +2846,9 @@ wasm_runtime_module_malloc(WASMModuleInstanceCommon *module_inst, uint32 size,
return 0; return 0;
} }
uint32 uint64
wasm_runtime_module_realloc(WASMModuleInstanceCommon *module_inst, uint32 ptr, wasm_runtime_module_realloc(WASMModuleInstanceCommon *module_inst, uint64 ptr,
uint32 size, void **p_native_addr) uint64 size, void **p_native_addr)
{ {
#if WASM_ENABLE_INTERP != 0 #if WASM_ENABLE_INTERP != 0
if (module_inst->module_type == Wasm_Module_Bytecode) if (module_inst->module_type == Wasm_Module_Bytecode)
@ -2863,7 +2864,7 @@ wasm_runtime_module_realloc(WASMModuleInstanceCommon *module_inst, uint32 ptr,
} }
void void
wasm_runtime_module_free(WASMModuleInstanceCommon *module_inst, uint32 ptr) wasm_runtime_module_free(WASMModuleInstanceCommon *module_inst, uint64 ptr)
{ {
#if WASM_ENABLE_INTERP != 0 #if WASM_ENABLE_INTERP != 0
if (module_inst->module_type == Wasm_Module_Bytecode) { if (module_inst->module_type == Wasm_Module_Bytecode) {
@ -2879,9 +2880,9 @@ wasm_runtime_module_free(WASMModuleInstanceCommon *module_inst, uint32 ptr)
#endif #endif
} }
uint32 uint64
wasm_runtime_module_dup_data(WASMModuleInstanceCommon *module_inst, wasm_runtime_module_dup_data(WASMModuleInstanceCommon *module_inst,
const char *src, uint32 size) const char *src, uint64 size)
{ {
#if WASM_ENABLE_INTERP != 0 #if WASM_ENABLE_INTERP != 0
if (module_inst->module_type == Wasm_Module_Bytecode) { if (module_inst->module_type == Wasm_Module_Bytecode) {
@ -3691,6 +3692,8 @@ wasm_runtime_invoke_native_raw(WASMExecEnv *exec_env, void *func_ptr,
case VALUE_TYPE_FUNCREF: case VALUE_TYPE_FUNCREF:
#endif #endif
{ {
/* TODO: memory64 the data type of ptr_len and argc depends on
* mem idx type */
*(uint32 *)argv_dst = arg_i32 = *argv_src++; *(uint32 *)argv_dst = arg_i32 = *argv_src++;
if (signature) { if (signature) {
if (signature[i + 1] == '*') { if (signature[i + 1] == '*') {
@ -3702,23 +3705,23 @@ wasm_runtime_invoke_native_raw(WASMExecEnv *exec_env, void *func_ptr,
/* pointer without length followed */ /* pointer without length followed */
ptr_len = 1; ptr_len = 1;
if (!wasm_runtime_validate_app_addr(module, arg_i32, if (!wasm_runtime_validate_app_addr(
ptr_len)) module, (uint64)arg_i32, (uint64)ptr_len))
goto fail; goto fail;
*(uintptr_t *)argv_dst = *(uintptr_t *)argv_dst =
(uintptr_t)wasm_runtime_addr_app_to_native(module, (uintptr_t)wasm_runtime_addr_app_to_native(
arg_i32); module, (uint64)arg_i32);
} }
else if (signature[i + 1] == '$') { else if (signature[i + 1] == '$') {
/* param is a string */ /* param is a string */
if (!wasm_runtime_validate_app_str_addr(module, if (!wasm_runtime_validate_app_str_addr(
arg_i32)) module, (uint64)arg_i32))
goto fail; goto fail;
*(uintptr_t *)argv_dst = *(uintptr_t *)argv_dst =
(uintptr_t)wasm_runtime_addr_app_to_native(module, (uintptr_t)wasm_runtime_addr_app_to_native(
arg_i32); module, (uint64)arg_i32);
} }
} }
break; break;
@ -4114,6 +4117,8 @@ wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr,
{ {
arg_i32 = *argv_src++; arg_i32 = *argv_src++;
/* TODO: memory64 the data type of ptr_len and argc depends on
* mem idx type */
if (signature) { if (signature) {
if (signature[i + 1] == '*') { if (signature[i + 1] == '*') {
/* param is a pointer */ /* param is a pointer */
@ -4124,21 +4129,21 @@ wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr,
/* pointer without length followed */ /* pointer without length followed */
ptr_len = 1; ptr_len = 1;
if (!wasm_runtime_validate_app_addr(module, arg_i32, if (!wasm_runtime_validate_app_addr(
ptr_len)) module, (uint64)arg_i32, (uint64)ptr_len))
goto fail; goto fail;
arg_i32 = (uintptr_t)wasm_runtime_addr_app_to_native( arg_i32 = (uintptr_t)wasm_runtime_addr_app_to_native(
module, arg_i32); module, (uint64)arg_i32);
} }
else if (signature[i + 1] == '$') { else if (signature[i + 1] == '$') {
/* param is a string */ /* param is a string */
if (!wasm_runtime_validate_app_str_addr(module, if (!wasm_runtime_validate_app_str_addr(
arg_i32)) module, (uint64)arg_i32))
goto fail; goto fail;
arg_i32 = (uintptr_t)wasm_runtime_addr_app_to_native( arg_i32 = (uintptr_t)wasm_runtime_addr_app_to_native(
module, arg_i32); module, (uint64)arg_i32);
} }
} }
@ -4489,6 +4494,8 @@ wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr,
{ {
arg_i32 = *argv++; arg_i32 = *argv++;
/* TODO: memory64 the data type of ptr_len and argc depends on
* mem idx type */
if (signature) { if (signature) {
if (signature[i + 1] == '*') { if (signature[i + 1] == '*') {
/* param is a pointer */ /* param is a pointer */
@ -4499,21 +4506,21 @@ wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr,
/* pointer without length followed */ /* pointer without length followed */
ptr_len = 1; ptr_len = 1;
if (!wasm_runtime_validate_app_addr(module, arg_i32, if (!wasm_runtime_validate_app_addr(
ptr_len)) module, (uint64)arg_i32, (uint64)ptr_len))
goto fail; goto fail;
arg_i32 = (uintptr_t)wasm_runtime_addr_app_to_native( arg_i32 = (uintptr_t)wasm_runtime_addr_app_to_native(
module, arg_i32); module, (uint64)arg_i32);
} }
else if (signature[i + 1] == '$') { else if (signature[i + 1] == '$') {
/* param is a string */ /* param is a string */
if (!wasm_runtime_validate_app_str_addr(module, if (!wasm_runtime_validate_app_str_addr(
arg_i32)) module, (uint64)arg_i32))
goto fail; goto fail;
arg_i32 = (uintptr_t)wasm_runtime_addr_app_to_native( arg_i32 = (uintptr_t)wasm_runtime_addr_app_to_native(
module, arg_i32); module, (uint64)arg_i32);
} }
} }
@ -4804,6 +4811,8 @@ wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr,
{ {
arg_i32 = *argv_src++; arg_i32 = *argv_src++;
arg_i64 = arg_i32; arg_i64 = arg_i32;
/* TODO: memory64 the data type of ptr_len and argc depends on
* mem idx type */
if (signature) { if (signature) {
if (signature[i + 1] == '*') { if (signature[i + 1] == '*') {
/* param is a pointer */ /* param is a pointer */
@ -4814,21 +4823,21 @@ wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr,
/* pointer without length followed */ /* pointer without length followed */
ptr_len = 1; ptr_len = 1;
if (!wasm_runtime_validate_app_addr(module, arg_i32, if (!wasm_runtime_validate_app_addr(
ptr_len)) module, (uint64)arg_i32, (uint64)ptr_len))
goto fail; goto fail;
arg_i64 = (uintptr_t)wasm_runtime_addr_app_to_native( arg_i64 = (uintptr_t)wasm_runtime_addr_app_to_native(
module, arg_i32); module, (uint64)arg_i32);
} }
else if (signature[i + 1] == '$') { else if (signature[i + 1] == '$') {
/* param is a string */ /* param is a string */
if (!wasm_runtime_validate_app_str_addr(module, if (!wasm_runtime_validate_app_str_addr(
arg_i32)) module, (uint64)arg_i32))
goto fail; goto fail;
arg_i64 = (uintptr_t)wasm_runtime_addr_app_to_native( arg_i64 = (uintptr_t)wasm_runtime_addr_app_to_native(
module, arg_i32); module, (uint64)arg_i32);
} }
} }
if (n_ints < MAX_REG_INTS) if (n_ints < MAX_REG_INTS)

44
core/iwasm/common/wasm_runtime_common.h
View File

@ -413,10 +413,10 @@ typedef struct WASMModuleMemConsumption {
} WASMModuleMemConsumption; } WASMModuleMemConsumption;
typedef struct WASMModuleInstMemConsumption { typedef struct WASMModuleInstMemConsumption {
uint32 total_size; uint64 total_size;
uint32 module_inst_struct_size; uint32 module_inst_struct_size;
uint32 memories_size;
uint32 app_heap_size; uint32 app_heap_size;
uint64 memories_size;
uint32 tables_size; uint32 tables_size;
uint32 globals_size; uint32 globals_size;
uint32 functions_size; uint32 functions_size;
@ -770,66 +770,66 @@ WASM_RUNTIME_API_EXTERN void *
wasm_runtime_get_custom_data(WASMModuleInstanceCommon *module_inst); wasm_runtime_get_custom_data(WASMModuleInstanceCommon *module_inst);
/* Internal API */ /* Internal API */
uint32 uint64
wasm_runtime_module_malloc_internal(WASMModuleInstanceCommon *module_inst, wasm_runtime_module_malloc_internal(WASMModuleInstanceCommon *module_inst,
WASMExecEnv *exec_env, uint32 size, WASMExecEnv *exec_env, uint64 size,
void **p_native_addr); void **p_native_addr);
/* Internal API */ /* Internal API */
uint32 uint64
wasm_runtime_module_realloc_internal(WASMModuleInstanceCommon *module_inst, wasm_runtime_module_realloc_internal(WASMModuleInstanceCommon *module_inst,
WASMExecEnv *exec_env, uint32 ptr, WASMExecEnv *exec_env, uint64 ptr,
uint32 size, void **p_native_addr); uint64 size, void **p_native_addr);
/* Internal API */ /* Internal API */
void void
wasm_runtime_module_free_internal(WASMModuleInstanceCommon *module_inst, wasm_runtime_module_free_internal(WASMModuleInstanceCommon *module_inst,
WASMExecEnv *exec_env, uint32 ptr); WASMExecEnv *exec_env, uint64 ptr);
/* See wasm_export.h for description */ /* See wasm_export.h for description */
WASM_RUNTIME_API_EXTERN uint32 WASM_RUNTIME_API_EXTERN uint64
wasm_runtime_module_malloc(WASMModuleInstanceCommon *module_inst, uint32 size, wasm_runtime_module_malloc(WASMModuleInstanceCommon *module_inst, uint64 size,
void **p_native_addr); void **p_native_addr);
/* See wasm_export.h for description */ /* See wasm_export.h for description */
WASM_RUNTIME_API_EXTERN void WASM_RUNTIME_API_EXTERN void
wasm_runtime_module_free(WASMModuleInstanceCommon *module_inst, uint32 ptr); wasm_runtime_module_free(WASMModuleInstanceCommon *module_inst, uint64 ptr);
/* See wasm_export.h for description */ /* See wasm_export.h for description */
WASM_RUNTIME_API_EXTERN uint32 WASM_RUNTIME_API_EXTERN uint64
wasm_runtime_module_dup_data(WASMModuleInstanceCommon *module_inst, wasm_runtime_module_dup_data(WASMModuleInstanceCommon *module_inst,
const char *src, uint32 size); const char *src, uint64 size);
/* See wasm_export.h for description */ /* See wasm_export.h for description */
WASM_RUNTIME_API_EXTERN bool WASM_RUNTIME_API_EXTERN bool
wasm_runtime_validate_app_addr(WASMModuleInstanceCommon *module_inst, wasm_runtime_validate_app_addr(WASMModuleInstanceCommon *module_inst,
uint32 app_offset, uint32 size); uint64 app_offset, uint64 size);
/* See wasm_export.h for description */ /* See wasm_export.h for description */
WASM_RUNTIME_API_EXTERN bool WASM_RUNTIME_API_EXTERN bool
wasm_runtime_validate_app_str_addr(WASMModuleInstanceCommon *module_inst, wasm_runtime_validate_app_str_addr(WASMModuleInstanceCommon *module_inst,
uint32 app_str_offset); uint64 app_str_offset);
/* See wasm_export.h for description */ /* See wasm_export.h for description */
WASM_RUNTIME_API_EXTERN bool WASM_RUNTIME_API_EXTERN bool
wasm_runtime_validate_native_addr(WASMModuleInstanceCommon *module_inst, wasm_runtime_validate_native_addr(WASMModuleInstanceCommon *module_inst,
void *native_ptr, uint32 size); void *native_ptr, uint64 size);
/* See wasm_export.h for description */ /* See wasm_export.h for description */
WASM_RUNTIME_API_EXTERN void * WASM_RUNTIME_API_EXTERN void *
wasm_runtime_addr_app_to_native(WASMModuleInstanceCommon *module_inst, wasm_runtime_addr_app_to_native(WASMModuleInstanceCommon *module_inst,
uint32 app_offset); uint64 app_offset);
/* See wasm_export.h for description */ /* See wasm_export.h for description */
WASM_RUNTIME_API_EXTERN uint32 WASM_RUNTIME_API_EXTERN uint64
wasm_runtime_addr_native_to_app(WASMModuleInstanceCommon *module_inst, wasm_runtime_addr_native_to_app(WASMModuleInstanceCommon *module_inst,
void *native_ptr); void *native_ptr);
/* See wasm_export.h for description */ /* See wasm_export.h for description */
WASM_RUNTIME_API_EXTERN bool WASM_RUNTIME_API_EXTERN bool
wasm_runtime_get_app_addr_range(WASMModuleInstanceCommon *module_inst, wasm_runtime_get_app_addr_range(WASMModuleInstanceCommon *module_inst,
uint32 app_offset, uint32 *p_app_start_offset, uint64 app_offset, uint64 *p_app_start_offset,
uint32 *p_app_end_offset); uint64 *p_app_end_offset);
/* See wasm_export.h for description */ /* See wasm_export.h for description */
WASM_RUNTIME_API_EXTERN bool WASM_RUNTIME_API_EXTERN bool
@ -916,11 +916,11 @@ wasm_runtime_is_built_in_module(const char *module_name);
#if WASM_ENABLE_THREAD_MGR != 0 #if WASM_ENABLE_THREAD_MGR != 0
bool bool
wasm_exec_env_get_aux_stack(WASMExecEnv *exec_env, uint32 *start_offset, wasm_exec_env_get_aux_stack(WASMExecEnv *exec_env, uint64 *start_offset,
uint32 *size); uint32 *size);
bool bool
wasm_exec_env_set_aux_stack(WASMExecEnv *exec_env, uint32 start_offset, wasm_exec_env_set_aux_stack(WASMExecEnv *exec_env, uint64 start_offset,
uint32 size); uint32 size);
#endif #endif

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

@ -316,11 +316,11 @@ typedef struct AOTCompData {
uint32 retain_func_index; uint32 retain_func_index;
uint32 aux_data_end_global_index; uint32 aux_data_end_global_index;
uint32 aux_data_end; uint64 aux_data_end;
uint32 aux_heap_base_global_index; uint32 aux_heap_base_global_index;
uint32 aux_heap_base; uint64 aux_heap_base;
uint32 aux_stack_top_global_index; uint32 aux_stack_top_global_index;
uint32 aux_stack_bottom; uint64 aux_stack_bottom;
uint32 aux_stack_size; uint32 aux_stack_size;
#if WASM_ENABLE_STRINGREF != 0 #if WASM_ENABLE_STRINGREF != 0

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

@ -850,7 +850,7 @@ get_init_data_section_size(AOTCompContext *comp_ctx, AOTCompData *comp_data,
size += (uint32)sizeof(uint32) * 2; size += (uint32)sizeof(uint32) * 2;
/* aux data/heap/stack data */ /* aux data/heap/stack data */
size += sizeof(uint32) * 7; size += sizeof(uint32) * 10;
size += get_object_data_section_info_size(comp_ctx, obj_data); size += get_object_data_section_info_size(comp_ctx, obj_data);
return size; return size;
@ -2428,11 +2428,11 @@ aot_emit_init_data_section(uint8 *buf, uint8 *buf_end, uint32 *p_offset,
EMIT_U32(comp_data->start_func_index); EMIT_U32(comp_data->start_func_index);
EMIT_U32(comp_data->aux_data_end_global_index); EMIT_U32(comp_data->aux_data_end_global_index);
EMIT_U32(comp_data->aux_data_end); EMIT_U64(comp_data->aux_data_end);
EMIT_U32(comp_data->aux_heap_base_global_index); EMIT_U32(comp_data->aux_heap_base_global_index);
EMIT_U32(comp_data->aux_heap_base); EMIT_U64(comp_data->aux_heap_base);
EMIT_U32(comp_data->aux_stack_top_global_index); EMIT_U32(comp_data->aux_stack_top_global_index);
EMIT_U32(comp_data->aux_stack_bottom); EMIT_U64(comp_data->aux_stack_bottom);
EMIT_U32(comp_data->aux_stack_size); EMIT_U32(comp_data->aux_stack_size);
if (!aot_emit_object_data_section_info(buf, buf_end, &offset, comp_ctx, if (!aot_emit_object_data_section_info(buf, buf_end, &offset, comp_ctx,

26
core/iwasm/compilation/aot_emit_function.c
View File

@ -1167,8 +1167,8 @@ check_app_addr_and_convert(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
/* prepare function type of aot_check_app_addr_and_convert */ /* prepare function type of aot_check_app_addr_and_convert */
func_param_types[0] = comp_ctx->aot_inst_type; /* module_inst */ func_param_types[0] = comp_ctx->aot_inst_type; /* module_inst */
func_param_types[1] = INT8_TYPE; /* is_str_arg */ func_param_types[1] = INT8_TYPE; /* is_str_arg */
func_param_types[2] = I32_TYPE; /* app_offset */ func_param_types[2] = I64_TYPE; /* app_offset */
func_param_types[3] = I32_TYPE; /* buf_size */ func_param_types[3] = I64_TYPE; /* buf_size */
func_param_types[4] = func_param_types[4] =
comp_ctx->basic_types.int8_pptr_type; /* p_native_addr */ comp_ctx->basic_types.int8_pptr_type; /* p_native_addr */
if (!(func_type = if (!(func_type =
@ -1555,7 +1555,19 @@ aot_compile_op_call(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
if (signature[i + 2] == '~') if (signature[i + 2] == '~')
native_addr_size = param_values[i + 2]; native_addr_size = param_values[i + 2];
else else
native_addr_size = I32_ONE; native_addr_size = I64_CONST(1);
if (!(native_addr_size = LLVMBuildZExtOrBitCast(
comp_ctx->builder, native_addr_size, I64_TYPE,
"native_addr_size_i64"))) {
aot_set_last_error("llvm build zextOrBitCast failed.");
goto fail;
}
if (!(param_values[j] = LLVMBuildZExtOrBitCast(
comp_ctx->builder, param_values[j], I64_TYPE,
"native_addr_i64"))) {
aot_set_last_error("llvm build zextOrBitCast failed.");
goto fail;
}
if (!check_app_addr_and_convert( if (!check_app_addr_and_convert(
comp_ctx, func_ctx, false, param_values[j], comp_ctx, func_ctx, false, param_values[j],
native_addr_size, &native_addr)) { native_addr_size, &native_addr)) {
@ -1564,7 +1576,13 @@ aot_compile_op_call(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
param_values[j] = native_addr; param_values[j] = native_addr;
} }
else if (signature[i + 1] == '$') { else if (signature[i + 1] == '$') {
native_addr_size = I32_ZERO; native_addr_size = I64_ZERO;
if (!(param_values[j] = LLVMBuildZExtOrBitCast(
comp_ctx->builder, param_values[j], I64_TYPE,
"native_addr_i64"))) {
aot_set_last_error("llvm build zextOrBitCast failed.");
goto fail;
}
if (!check_app_addr_and_convert( if (!check_app_addr_and_convert(
comp_ctx, func_ctx, true, param_values[j], comp_ctx, func_ctx, true, param_values[j],
native_addr_size, &native_addr)) { native_addr_size, &native_addr)) {

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

@ -919,7 +919,7 @@ check_bulk_memory_overflow(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
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].mem_init_page_count;
uint32 mem_data_size = 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 */
/* maddr = mem_base_addr + moffset */ /* maddr = mem_base_addr + moffset */
@ -938,7 +938,7 @@ check_bulk_memory_overflow(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
} }
else { else {
if (!(mem_size = LLVMBuildLoad2( if (!(mem_size = LLVMBuildLoad2(
comp_ctx->builder, I32_TYPE, comp_ctx->builder, I64_TYPE,
func_ctx->mem_info[0].mem_data_size_addr, "mem_size"))) { func_ctx->mem_info[0].mem_data_size_addr, "mem_size"))) {
aot_set_last_error("llvm build load failed."); aot_set_last_error("llvm build load failed.");
goto fail; goto fail;
@ -951,8 +951,6 @@ check_bulk_memory_overflow(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
offset = offset =
LLVMBuildZExt(comp_ctx->builder, offset, I64_TYPE, "extend_offset"); LLVMBuildZExt(comp_ctx->builder, offset, I64_TYPE, "extend_offset");
bytes = LLVMBuildZExt(comp_ctx->builder, bytes, I64_TYPE, "extend_len"); bytes = LLVMBuildZExt(comp_ctx->builder, bytes, I64_TYPE, "extend_len");
mem_size =
LLVMBuildZExt(comp_ctx->builder, mem_size, I64_TYPE, "extend_size");
BUILD_OP(Add, offset, bytes, max_addr, "max_addr"); BUILD_OP(Add, offset, bytes, max_addr, "max_addr");
BUILD_ICMP(LLVMIntUGT, max_addr, mem_size, cmp, "cmp_max_mem_addr"); BUILD_ICMP(LLVMIntUGT, max_addr, mem_size, cmp, "cmp_max_mem_addr");

12
core/iwasm/compilation/aot_emit_variable.c
View File

@ -251,7 +251,7 @@ compile_global(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
LLVMBasicBlockRef block_curr = LLVMBasicBlockRef block_curr =
LLVMGetInsertBlock(comp_ctx->builder); LLVMGetInsertBlock(comp_ctx->builder);
LLVMBasicBlockRef check_overflow_succ, check_underflow_succ; LLVMBasicBlockRef check_overflow_succ, check_underflow_succ;
LLVMValueRef cmp; LLVMValueRef cmp, global_i64;
/* Add basic blocks */ /* Add basic blocks */
if (!(check_overflow_succ = LLVMAppendBasicBlockInContext( if (!(check_overflow_succ = LLVMAppendBasicBlockInContext(
@ -270,8 +270,14 @@ compile_global(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
} }
LLVMMoveBasicBlockAfter(check_underflow_succ, check_overflow_succ); LLVMMoveBasicBlockAfter(check_underflow_succ, check_overflow_succ);
if (!(global_i64 = LLVMBuildZExt(comp_ctx->builder, global,
I64_TYPE, "global_i64"))) {
aot_set_last_error("llvm build zext failed.");
return false;
}
/* Check aux stack overflow */ /* Check aux stack overflow */
if (!(cmp = LLVMBuildICmp(comp_ctx->builder, LLVMIntULE, global, if (!(cmp = LLVMBuildICmp(comp_ctx->builder, LLVMIntULE, global_i64,
func_ctx->aux_stack_bound, "cmp"))) { func_ctx->aux_stack_bound, "cmp"))) {
aot_set_last_error("llvm build icmp failed."); aot_set_last_error("llvm build icmp failed.");
return false; return false;
@ -283,7 +289,7 @@ compile_global(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
/* Check aux stack underflow */ /* Check aux stack underflow */
LLVMPositionBuilderAtEnd(comp_ctx->builder, check_overflow_succ); LLVMPositionBuilderAtEnd(comp_ctx->builder, check_overflow_succ);
if (!(cmp = LLVMBuildICmp(comp_ctx->builder, LLVMIntUGT, global, if (!(cmp = LLVMBuildICmp(comp_ctx->builder, LLVMIntUGT, global_i64,
func_ctx->aux_stack_bottom, "cmp"))) { func_ctx->aux_stack_bottom, "cmp"))) {
aot_set_last_error("llvm build icmp failed."); aot_set_last_error("llvm build icmp failed.");
return false; return false;

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

@ -1004,17 +1004,23 @@ create_aux_stack_info(const AOTCompContext *comp_ctx, AOTFuncContext *func_ctx)
if (!(aux_stack_bound_addr = if (!(aux_stack_bound_addr =
LLVMBuildBitCast(comp_ctx->builder, aux_stack_bound_addr, LLVMBuildBitCast(comp_ctx->builder, aux_stack_bound_addr,
INT32_PTR_TYPE, "aux_stack_bound_ptr"))) { INTPTR_T_PTR_TYPE, "aux_stack_bound_ptr"))) {
aot_set_last_error("llvm build bit cast failed"); aot_set_last_error("llvm build bit cast failed");
return false; return false;
} }
if (!(func_ctx->aux_stack_bound = if (!(func_ctx->aux_stack_bound =
LLVMBuildLoad2(comp_ctx->builder, I32_TYPE, aux_stack_bound_addr, LLVMBuildLoad2(comp_ctx->builder, INTPTR_T_TYPE,
"aux_stack_bound"))) { aux_stack_bound_addr, "aux_stack_bound_intptr"))) {
aot_set_last_error("llvm build load failed"); aot_set_last_error("llvm build load failed");
return false; return false;
} }
if (!(func_ctx->aux_stack_bound =
LLVMBuildZExt(comp_ctx->builder, func_ctx->aux_stack_bound,
I64_TYPE, "aux_stack_bound_i64"))) {
aot_set_last_error("llvm build truncOrBitCast failed.");
return false;
}
/* Get aux stack bottom address */ /* Get aux stack bottom address */
if (!(aux_stack_bottom_addr = LLVMBuildInBoundsGEP2( if (!(aux_stack_bottom_addr = LLVMBuildInBoundsGEP2(
@ -1026,16 +1032,23 @@ create_aux_stack_info(const AOTCompContext *comp_ctx, AOTFuncContext *func_ctx)
if (!(aux_stack_bottom_addr = if (!(aux_stack_bottom_addr =
LLVMBuildBitCast(comp_ctx->builder, aux_stack_bottom_addr, LLVMBuildBitCast(comp_ctx->builder, aux_stack_bottom_addr,
INT32_PTR_TYPE, "aux_stack_bottom_ptr"))) { INTPTR_T_PTR_TYPE, "aux_stack_bottom_ptr"))) {
aot_set_last_error("llvm build bit cast failed"); aot_set_last_error("llvm build bit cast failed");
return false; return false;
} }
if (!(func_ctx->aux_stack_bottom = if (!(func_ctx->aux_stack_bottom =
LLVMBuildLoad2(comp_ctx->builder, I32_TYPE, aux_stack_bottom_addr, LLVMBuildLoad2(comp_ctx->builder, INTPTR_T_TYPE,
"aux_stack_bottom"))) { aux_stack_bottom_addr, "aux_stack_bottom"))) {
aot_set_last_error("llvm build load failed"); aot_set_last_error("llvm build load failed");
return false; return false;
} }
if (!(func_ctx->aux_stack_bottom =
LLVMBuildZExt(comp_ctx->builder, func_ctx->aux_stack_bottom,
I64_TYPE, "aux_stack_bottom_i64"))) {
aot_set_last_error("llvm build truncOrBitCast failed.");
return false;
}
return true; return true;
} }
@ -1365,7 +1378,7 @@ create_memory_info(const AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
} }
if (!(func_ctx->mem_info[0].mem_data_size_addr = LLVMBuildBitCast( if (!(func_ctx->mem_info[0].mem_data_size_addr = LLVMBuildBitCast(
comp_ctx->builder, func_ctx->mem_info[0].mem_data_size_addr, comp_ctx->builder, func_ctx->mem_info[0].mem_data_size_addr,
INT32_PTR_TYPE, "mem_data_size_ptr"))) { INT64_PTR_TYPE, "mem_data_size_ptr"))) {
aot_set_last_error("llvm build bit cast failed"); aot_set_last_error("llvm build bit cast failed");
return false; return false;
} }
@ -1384,7 +1397,7 @@ create_memory_info(const AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
return false; return false;
} }
if (!(func_ctx->mem_info[0].mem_data_size_addr = LLVMBuildLoad2( if (!(func_ctx->mem_info[0].mem_data_size_addr = LLVMBuildLoad2(
comp_ctx->builder, I32_TYPE, comp_ctx->builder, I64_TYPE,
func_ctx->mem_info[0].mem_data_size_addr, "mem_data_size"))) { func_ctx->mem_info[0].mem_data_size_addr, "mem_data_size"))) {
aot_set_last_error("llvm build load failed"); aot_set_last_error("llvm build load failed");
return false; return false;

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

@ -331,12 +331,14 @@ jit_compile_op_call(JitCompContext *cc, uint32 func_idx, bool tail_call)
func_params[1] = NEW_CONST(I32, false); /* is_str = false */ func_params[1] = NEW_CONST(I32, false); /* is_str = false */
func_params[2] = argvs[i]; func_params[2] = argvs[i];
if (signature[i + 2] == '~') { if (signature[i + 2] == '~') {
/* TODO: Memory64 no need to convert if mem idx type i64 */
func_params[3] = jit_cc_new_reg_I64(cc);
/* pointer with length followed */ /* pointer with length followed */
func_params[3] = argvs[i + 1]; GEN_INSN(I32TOI64, func_params[3], argvs[i + 1]);
} }
else { else {
/* pointer with length followed */ /* pointer with length followed */
func_params[3] = NEW_CONST(I32, 1); func_params[3] = NEW_CONST(I64, 1);
} }
} }
else if (signature[i + 1] == '$') { else if (signature[i + 1] == '$') {
@ -344,10 +346,15 @@ jit_compile_op_call(JitCompContext *cc, uint32 func_idx, bool tail_call)
is_pointer_arg = true; is_pointer_arg = true;
func_params[1] = NEW_CONST(I32, true); /* is_str = true */ func_params[1] = NEW_CONST(I32, true); /* is_str = true */
func_params[2] = argvs[i]; func_params[2] = argvs[i];
func_params[3] = NEW_CONST(I32, 1); func_params[3] = NEW_CONST(I64, 1);
} }
if (is_pointer_arg) { if (is_pointer_arg) {
JitReg native_addr_64 = jit_cc_new_reg_I64(cc);
/* TODO: Memory64 no need to convert if mem idx type i64 */
GEN_INSN(I32TOI64, native_addr_64, func_params[2]);
func_params[2] = native_addr_64;
if (!jit_emit_callnative(cc, jit_check_app_addr_and_convert, if (!jit_emit_callnative(cc, jit_check_app_addr_and_convert,
ret, func_params, 5)) { ret, func_params, 5)) {
goto fail; goto fail;

10
core/iwasm/fast-jit/fe/jit_emit_memory.c
View File

@ -630,7 +630,7 @@ wasm_init_memory(WASMModuleInstance *inst, uint32 mem_idx, uint32 seg_idx,
{ {
WASMMemoryInstance *mem_inst; WASMMemoryInstance *mem_inst;
WASMDataSeg *data_segment; WASMDataSeg *data_segment;
uint32 mem_size; uint64 mem_size;
uint8 *mem_addr, *data_addr; uint8 *mem_addr, *data_addr;
uint32 seg_len; uint32 seg_len;
@ -655,7 +655,7 @@ wasm_init_memory(WASMModuleInstance *inst, uint32 mem_idx, uint32 seg_idx,
goto out_of_bounds; goto out_of_bounds;
mem_addr = mem_inst->memory_data + mem_offset; mem_addr = mem_inst->memory_data + mem_offset;
bh_memcpy_s(mem_addr, mem_size - mem_offset, data_addr, len); bh_memcpy_s(mem_addr, (uint32)(mem_size - mem_offset), data_addr, len);
return 0; return 0;
out_of_bounds: out_of_bounds:
@ -719,7 +719,7 @@ wasm_copy_memory(WASMModuleInstance *inst, uint32 src_mem_idx,
uint32 dst_offset) uint32 dst_offset)
{ {
WASMMemoryInstance *src_mem, *dst_mem; WASMMemoryInstance *src_mem, *dst_mem;
uint32 src_mem_size, dst_mem_size; uint64 src_mem_size, dst_mem_size;
uint8 *src_addr, *dst_addr; uint8 *src_addr, *dst_addr;
src_mem = inst->memories[src_mem_idx]; src_mem = inst->memories[src_mem_idx];
@ -738,7 +738,7 @@ wasm_copy_memory(WASMModuleInstance *inst, uint32 src_mem_idx,
src_addr = src_mem->memory_data + src_offset; src_addr = src_mem->memory_data + src_offset;
dst_addr = dst_mem->memory_data + dst_offset; dst_addr = dst_mem->memory_data + dst_offset;
/* allowing the destination and source to overlap */ /* allowing the destination and source to overlap */
bh_memmove_s(dst_addr, dst_mem_size - dst_offset, src_addr, len); bh_memmove_s(dst_addr, (uint32)(dst_mem_size - dst_offset), src_addr, len);
return 0; return 0;
out_of_bounds: out_of_bounds:
@ -784,7 +784,7 @@ wasm_fill_memory(WASMModuleInstance *inst, uint32 mem_idx, uint32 len,
uint32 val, uint32 dst) uint32 val, uint32 dst)
{ {
WASMMemoryInstance *mem_inst; WASMMemoryInstance *mem_inst;
uint32 mem_size; uint64 mem_size;
uint8 *dst_addr; uint8 *dst_addr;
mem_inst = inst->memories[mem_idx]; mem_inst = inst->memories[mem_idx];

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

@ -194,12 +194,15 @@ JitReg
get_aux_stack_bound_reg(JitFrame *frame) get_aux_stack_bound_reg(JitFrame *frame)
{ {
JitCompContext *cc = frame->cc; JitCompContext *cc = frame->cc;
JitReg tmp = jit_cc_new_reg_I32(cc);
if (!frame->aux_stack_bound_reg) { if (!frame->aux_stack_bound_reg) {
frame->aux_stack_bound_reg = cc->aux_stack_bound_reg; frame->aux_stack_bound_reg = cc->aux_stack_bound_reg;
GEN_INSN( GEN_INSN(LDPTR, frame->aux_stack_bound_reg, cc->exec_env_reg,
LDI32, frame->aux_stack_bound_reg, cc->exec_env_reg, NEW_CONST(I32, offsetof(WASMExecEnv, aux_stack_boundary)));
NEW_CONST(I32, offsetof(WASMExecEnv, aux_stack_boundary.boundary))); /* TODO: Memory64 whether to convert depends on memory idx type */
GEN_INSN(I64TOI32, tmp, frame->aux_stack_bound_reg);
frame->aux_stack_bound_reg = tmp;
} }
return frame->aux_stack_bound_reg; return frame->aux_stack_bound_reg;
} }
@ -208,12 +211,15 @@ JitReg
get_aux_stack_bottom_reg(JitFrame *frame) get_aux_stack_bottom_reg(JitFrame *frame)
{ {
JitCompContext *cc = frame->cc; JitCompContext *cc = frame->cc;
JitReg tmp = jit_cc_new_reg_I32(cc);
if (!frame->aux_stack_bottom_reg) { if (!frame->aux_stack_bottom_reg) {
frame->aux_stack_bottom_reg = cc->aux_stack_bottom_reg; frame->aux_stack_bottom_reg = cc->aux_stack_bottom_reg;
GEN_INSN( GEN_INSN(LDPTR, frame->aux_stack_bottom_reg, cc->exec_env_reg,
LDI32, frame->aux_stack_bottom_reg, cc->exec_env_reg, NEW_CONST(I32, offsetof(WASMExecEnv, aux_stack_bottom)));
NEW_CONST(I32, offsetof(WASMExecEnv, aux_stack_bottom.bottom))); /* TODO: Memory64 whether to convert depends on memory idx type */
GEN_INSN(I64TOI32, tmp, frame->aux_stack_bottom_reg);
frame->aux_stack_bottom_reg = tmp;
} }
return frame->aux_stack_bottom_reg; return frame->aux_stack_bottom_reg;
} }
@ -915,8 +921,8 @@ create_fixed_virtual_regs(JitCompContext *cc)
cc->import_func_ptrs_reg = jit_cc_new_reg_ptr(cc); cc->import_func_ptrs_reg = jit_cc_new_reg_ptr(cc);
cc->fast_jit_func_ptrs_reg = jit_cc_new_reg_ptr(cc); cc->fast_jit_func_ptrs_reg = jit_cc_new_reg_ptr(cc);
cc->func_type_indexes_reg = jit_cc_new_reg_ptr(cc); cc->func_type_indexes_reg = jit_cc_new_reg_ptr(cc);
cc->aux_stack_bound_reg = jit_cc_new_reg_I32(cc); cc->aux_stack_bound_reg = jit_cc_new_reg_ptr(cc);
cc->aux_stack_bottom_reg = jit_cc_new_reg_I32(cc); cc->aux_stack_bottom_reg = jit_cc_new_reg_ptr(cc);
count = module->import_memory_count + module->memory_count; count = module->import_memory_count + module->memory_count;
if (count > 0) { if (count > 0) {

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

@ -1031,8 +1031,8 @@ wasm_runtime_is_bounds_checks_enabled(
* it is not an absolute address. * it is not an absolute address.
* Return non-zero if success, zero if failed. * Return non-zero if success, zero if failed.
*/ */
WASM_RUNTIME_API_EXTERN uint32_t WASM_RUNTIME_API_EXTERN uint64_t
wasm_runtime_module_malloc(wasm_module_inst_t module_inst, uint32_t size, wasm_runtime_module_malloc(wasm_module_inst_t module_inst, uint64_t size,
void **p_native_addr); void **p_native_addr);
/** /**
@ -1042,7 +1042,7 @@ wasm_runtime_module_malloc(wasm_module_inst_t module_inst, uint32_t size,
* @param ptr the pointer to free * @param ptr the pointer to free
*/ */
WASM_RUNTIME_API_EXTERN void WASM_RUNTIME_API_EXTERN void
wasm_runtime_module_free(wasm_module_inst_t module_inst, uint32_t ptr); wasm_runtime_module_free(wasm_module_inst_t module_inst, uint64_t ptr);
/** /**
* Allocate memory from the heap of WASM module instance and initialize * Allocate memory from the heap of WASM module instance and initialize
@ -1057,9 +1057,9 @@ wasm_runtime_module_free(wasm_module_inst_t module_inst, uint32_t ptr);
* it is not an absolute address. * it is not an absolute address.
* Return non-zero if success, zero if failed. * Return non-zero if success, zero if failed.
*/ */
WASM_RUNTIME_API_EXTERN uint32_t WASM_RUNTIME_API_EXTERN uint64_t
wasm_runtime_module_dup_data(wasm_module_inst_t module_inst, wasm_runtime_module_dup_data(wasm_module_inst_t module_inst,
const char *src, uint32_t size); const char *src, uint64_t size);
/** /**
* Validate the app address, check whether it belongs to WASM module * Validate the app address, check whether it belongs to WASM module
@ -1074,7 +1074,7 @@ wasm_runtime_module_dup_data(wasm_module_inst_t module_inst,
*/ */
WASM_RUNTIME_API_EXTERN bool WASM_RUNTIME_API_EXTERN bool
wasm_runtime_validate_app_addr(wasm_module_inst_t module_inst, wasm_runtime_validate_app_addr(wasm_module_inst_t module_inst,
uint32_t app_offset, uint32_t size); uint64_t app_offset, uint64_t size);
/** /**
* Similar to wasm_runtime_validate_app_addr(), except that the size parameter * Similar to wasm_runtime_validate_app_addr(), except that the size parameter
@ -1096,7 +1096,7 @@ wasm_runtime_validate_app_addr(wasm_module_inst_t module_inst,
*/ */
WASM_RUNTIME_API_EXTERN bool WASM_RUNTIME_API_EXTERN bool
wasm_runtime_validate_app_str_addr(wasm_module_inst_t module_inst, wasm_runtime_validate_app_str_addr(wasm_module_inst_t module_inst,
uint32_t app_str_offset); uint64_t app_str_offset);
/** /**
* Validate the native address, check whether it belongs to WASM module * Validate the native address, check whether it belongs to WASM module
@ -1112,7 +1112,7 @@ wasm_runtime_validate_app_str_addr(wasm_module_inst_t module_inst,
*/ */
WASM_RUNTIME_API_EXTERN bool WASM_RUNTIME_API_EXTERN bool
wasm_runtime_validate_native_addr(wasm_module_inst_t module_inst, wasm_runtime_validate_native_addr(wasm_module_inst_t module_inst,
void *native_ptr, uint32_t size); void *native_ptr, uint64_t size);
/** /**
* Convert app address(relative address) to native address(absolute address) * Convert app address(relative address) to native address(absolute address)
@ -1128,7 +1128,7 @@ wasm_runtime_validate_native_addr(wasm_module_inst_t module_inst,
*/ */
WASM_RUNTIME_API_EXTERN void * WASM_RUNTIME_API_EXTERN void *
wasm_runtime_addr_app_to_native(wasm_module_inst_t module_inst, wasm_runtime_addr_app_to_native(wasm_module_inst_t module_inst,
uint32_t app_offset); uint64_t app_offset);
/** /**
* Convert native address(absolute address) to app address(relative address) * Convert native address(absolute address) to app address(relative address)
@ -1138,7 +1138,7 @@ wasm_runtime_addr_app_to_native(wasm_module_inst_t module_inst,
* *
* @return the app address converted * @return the app address converted
*/ */
WASM_RUNTIME_API_EXTERN uint32_t WASM_RUNTIME_API_EXTERN uint64_t
wasm_runtime_addr_native_to_app(wasm_module_inst_t module_inst, wasm_runtime_addr_native_to_app(wasm_module_inst_t module_inst,
void *native_ptr); void *native_ptr);
@ -1154,9 +1154,9 @@ wasm_runtime_addr_native_to_app(wasm_module_inst_t module_inst,
*/ */
WASM_RUNTIME_API_EXTERN bool WASM_RUNTIME_API_EXTERN bool
wasm_runtime_get_app_addr_range(wasm_module_inst_t module_inst, wasm_runtime_get_app_addr_range(wasm_module_inst_t module_inst,
uint32_t app_offset, uint64_t app_offset,
uint32_t *p_app_start_offset, uint64_t *p_app_start_offset,
uint32_t *p_app_end_offset); uint64_t *p_app_end_offset);
/** /**
* Get the native address range (absolute address) that a native address * Get the native address range (absolute address) that a native address

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

@ -93,6 +93,9 @@ extern "C" {
#define DEFAULT_NUM_BYTES_PER_PAGE 65536 #define DEFAULT_NUM_BYTES_PER_PAGE 65536
#define DEFAULT_MAX_PAGES 65536 #define DEFAULT_MAX_PAGES 65536
/* Max size of linear memory */
#define MAX_LINEAR_MEMORY_SIZE (4 * (uint64)BH_GB)
#if WASM_ENABLE_GC == 0 #if WASM_ENABLE_GC == 0
typedef uintptr_t table_elem_type_t; typedef uintptr_t table_elem_type_t;
#define NULL_REF (0xFFFFFFFF) #define NULL_REF (0xFFFFFFFF)
@ -870,19 +873,19 @@ struct WASMModule {
-1 means unexported */ -1 means unexported */
uint32 aux_data_end_global_index; uint32 aux_data_end_global_index;
/* auxiliary __data_end exported by wasm app */ /* auxiliary __data_end exported by wasm app */
uint32 aux_data_end; uint64 aux_data_end;
/* the index of auxiliary __heap_base global, /* the index of auxiliary __heap_base global,
-1 means unexported */ -1 means unexported */
uint32 aux_heap_base_global_index; uint32 aux_heap_base_global_index;
/* auxiliary __heap_base exported by wasm app */ /* auxiliary __heap_base exported by wasm app */
uint32 aux_heap_base; uint64 aux_heap_base;
/* the index of auxiliary stack top global, /* the index of auxiliary stack top global,
-1 means unexported */ -1 means unexported */
uint32 aux_stack_top_global_index; uint32 aux_stack_top_global_index;
/* auxiliary stack bottom resolved */ /* auxiliary stack bottom resolved */
uint32 aux_stack_bottom; uint64 aux_stack_bottom;
/* auxiliary stack size resolved */ /* auxiliary stack size resolved */
uint32 aux_stack_size; uint32 aux_stack_size;
@ -1091,6 +1094,21 @@ align_uint(unsigned v, unsigned b)
return (v + m) & ~m; return (v + m) & ~m;
} }
/**
* Align an 64 bit unsigned value on a alignment boundary.
*
* @param v the value to be aligned
* @param b the alignment boundary (2, 4, 8, ...)
*
* @return the aligned value
*/
inline static uint64
align_uint64(uint64 v, uint64 b)
{
uint64 m = b - 1;
return (v + m) & ~m;
}
/** /**
* Check whether a piece of data is out of range * Check whether a piece of data is out of range
* *

77
core/iwasm/interpreter/wasm_interp_classic.c
View File

@ -48,28 +48,26 @@ typedef float64 CellType_F64;
#if !defined(OS_ENABLE_HW_BOUND_CHECK) \ #if !defined(OS_ENABLE_HW_BOUND_CHECK) \
|| WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS == 0 || WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS == 0
#define CHECK_MEMORY_OVERFLOW(bytes) \ #define CHECK_MEMORY_OVERFLOW(bytes) \
do { \ do { \
uint64 offset1 = (uint64)offset + (uint64)addr; \ uint64 offset1 = (uint64)offset + (uint64)addr; \
if (disable_bounds_checks \ if (disable_bounds_checks || offset1 + bytes <= get_linear_mem_size()) \
|| offset1 + bytes <= (uint64)get_linear_mem_size()) \ /* If offset1 is in valid range, maddr must also \
/* If offset1 is in valid range, maddr must also \ be in valid range, no need to check it again. */ \
be in valid range, no need to check it again. */ \ maddr = memory->memory_data + offset1; \
maddr = memory->memory_data + offset1; \ else \
else \ goto out_of_bounds; \
goto out_of_bounds; \
} while (0) } while (0)
#define CHECK_BULK_MEMORY_OVERFLOW(start, bytes, maddr) \ #define CHECK_BULK_MEMORY_OVERFLOW(start, bytes, maddr) \
do { \ do { \
uint64 offset1 = (uint32)(start); \ uint64 offset1 = (uint32)(start); \
if (disable_bounds_checks \ if (disable_bounds_checks || offset1 + bytes <= get_linear_mem_size()) \
|| offset1 + bytes <= (uint64)get_linear_mem_size()) \ /* App heap space is not valid space for \
/* App heap space is not valid space for \ bulk memory operation */ \
bulk memory operation */ \ maddr = memory->memory_data + offset1; \
maddr = memory->memory_data + offset1; \ else \
else \ goto out_of_bounds; \
goto out_of_bounds; \
} while (0) } while (0)
#else #else
#define CHECK_MEMORY_OVERFLOW(bytes) \ #define CHECK_MEMORY_OVERFLOW(bytes) \
@ -1211,8 +1209,8 @@ wasm_interp_call_func_import(WASMModuleInstance *module_inst,
uint8 *ip = prev_frame->ip; uint8 *ip = prev_frame->ip;
char buf[128]; char buf[128];
WASMExecEnv *sub_module_exec_env = NULL; WASMExecEnv *sub_module_exec_env = NULL;
uint32 aux_stack_origin_boundary = 0; uintptr_t aux_stack_origin_boundary = 0;
uint32 aux_stack_origin_bottom = 0; uintptr_t aux_stack_origin_bottom = 0;
if (!sub_func_inst) { if (!sub_func_inst) {
snprintf(buf, sizeof(buf), snprintf(buf, sizeof(buf),
@ -1235,13 +1233,11 @@ wasm_interp_call_func_import(WASMModuleInstance *module_inst,
wasm_exec_env_set_module_inst(exec_env, wasm_exec_env_set_module_inst(exec_env,
(WASMModuleInstanceCommon *)sub_module_inst); (WASMModuleInstanceCommon *)sub_module_inst);
/* - aux_stack_boundary */ /* - aux_stack_boundary */
aux_stack_origin_boundary = exec_env->aux_stack_boundary.boundary; aux_stack_origin_boundary = exec_env->aux_stack_boundary;
exec_env->aux_stack_boundary.boundary = exec_env->aux_stack_boundary = sub_module_exec_env->aux_stack_boundary;
sub_module_exec_env->aux_stack_boundary.boundary;
/* - aux_stack_bottom */ /* - aux_stack_bottom */
aux_stack_origin_bottom = exec_env->aux_stack_bottom.bottom; aux_stack_origin_bottom = exec_env->aux_stack_bottom;
exec_env->aux_stack_bottom.bottom = exec_env->aux_stack_bottom = sub_module_exec_env->aux_stack_bottom;
sub_module_exec_env->aux_stack_bottom.bottom;
/* set ip NULL to make call_func_bytecode return after executing /* set ip NULL to make call_func_bytecode return after executing
this function */ this function */
@ -1253,8 +1249,8 @@ wasm_interp_call_func_import(WASMModuleInstance *module_inst,
/* restore ip and other replaced */ /* restore ip and other replaced */
prev_frame->ip = ip; prev_frame->ip = ip;
exec_env->aux_stack_boundary.boundary = aux_stack_origin_boundary; exec_env->aux_stack_boundary = aux_stack_origin_boundary;
exec_env->aux_stack_bottom.bottom = aux_stack_origin_bottom; exec_env->aux_stack_bottom = aux_stack_origin_bottom;
wasm_exec_env_restore_module_inst(exec_env, wasm_exec_env_restore_module_inst(exec_env,
(WASMModuleInstanceCommon *)module_inst); (WASMModuleInstanceCommon *)module_inst);
} }
@ -1374,7 +1370,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
#if !defined(OS_ENABLE_HW_BOUND_CHECK) \ #if !defined(OS_ENABLE_HW_BOUND_CHECK) \
|| WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS == 0 \ || WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS == 0 \
|| WASM_ENABLE_BULK_MEMORY != 0 || WASM_ENABLE_BULK_MEMORY != 0
uint32 linear_mem_size = 0; uint64 linear_mem_size = 0;
if (memory) if (memory)
#if WASM_ENABLE_THREAD_MGR == 0 #if WASM_ENABLE_THREAD_MGR == 0
linear_mem_size = memory->memory_data_size; linear_mem_size = memory->memory_data_size;
@ -4086,18 +4082,19 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
HANDLE_OP(WASM_OP_SET_GLOBAL_AUX_STACK) HANDLE_OP(WASM_OP_SET_GLOBAL_AUX_STACK)
{ {
uint32 aux_stack_top; uint64 aux_stack_top;
read_leb_uint32(frame_ip, frame_ip_end, global_idx); read_leb_uint32(frame_ip, frame_ip_end, global_idx);
bh_assert(global_idx < module->e->global_count); bh_assert(global_idx < module->e->global_count);
global = globals + global_idx; global = globals + global_idx;
global_addr = get_global_addr(global_data, global); global_addr = get_global_addr(global_data, global);
aux_stack_top = *(uint32 *)(frame_sp - 1); /* TODO: Memory64 the data type depends on mem idx type */
if (aux_stack_top <= exec_env->aux_stack_boundary.boundary) { aux_stack_top = (uint64)(*(uint32 *)(frame_sp - 1));
if (aux_stack_top <= (uint64)exec_env->aux_stack_boundary) {
wasm_set_exception(module, "wasm auxiliary stack overflow"); wasm_set_exception(module, "wasm auxiliary stack overflow");
goto got_exception; goto got_exception;
} }
if (aux_stack_top > exec_env->aux_stack_bottom.bottom) { if (aux_stack_top > (uint64)exec_env->aux_stack_bottom) {
wasm_set_exception(module, wasm_set_exception(module,
"wasm auxiliary stack underflow"); "wasm auxiliary stack underflow");
goto got_exception; goto got_exception;
@ -4106,8 +4103,9 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
frame_sp--; frame_sp--;
#if WASM_ENABLE_MEMORY_PROFILING != 0 #if WASM_ENABLE_MEMORY_PROFILING != 0
if (module->module->aux_stack_top_global_index != (uint32)-1) { if (module->module->aux_stack_top_global_index != (uint32)-1) {
uint32 aux_stack_used = module->module->aux_stack_bottom uint32 aux_stack_used =
- *(uint32 *)global_addr; (uint32)(module->module->aux_stack_bottom
- *(uint32 *)global_addr);
if (aux_stack_used > module->e->max_aux_stack_used) if (aux_stack_used > module->e->max_aux_stack_used)
module->e->max_aux_stack_used = aux_stack_used; module->e->max_aux_stack_used = aux_stack_used;
} }
@ -5491,7 +5489,8 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
#endif #endif
/* allowing the destination and source to overlap */ /* allowing the destination and source to overlap */
bh_memmove_s(mdst, linear_mem_size - dst, msrc, len); bh_memmove_s(mdst, (uint32)(linear_mem_size - dst),
msrc, len);
break; break;
} }
case WASM_OP_MEMORY_FILL: case WASM_OP_MEMORY_FILL:
@ -5511,7 +5510,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
#ifndef OS_ENABLE_HW_BOUND_CHECK #ifndef OS_ENABLE_HW_BOUND_CHECK
CHECK_BULK_MEMORY_OVERFLOW(dst, len, mdst); CHECK_BULK_MEMORY_OVERFLOW(dst, len, mdst);
#else #else
if ((uint64)(uint32)dst + len > (uint64)linear_mem_size) if ((uint64)(uint32)dst + len > linear_mem_size)
goto out_of_bounds; goto out_of_bounds;
mdst = memory->memory_data + (uint32)dst; mdst = memory->memory_data + (uint32)dst;
#endif #endif

69
core/iwasm/interpreter/wasm_interp_fast.c
View File

@ -39,16 +39,15 @@ typedef float64 CellType_F64;
#if !defined(OS_ENABLE_HW_BOUND_CHECK) \ #if !defined(OS_ENABLE_HW_BOUND_CHECK) \
|| WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS == 0 || WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS == 0
#define CHECK_MEMORY_OVERFLOW(bytes) \ #define CHECK_MEMORY_OVERFLOW(bytes) \
do { \ do { \
uint64 offset1 = (uint64)offset + (uint64)addr; \ uint64 offset1 = (uint64)offset + (uint64)addr; \
if (disable_bounds_checks \ if (disable_bounds_checks || offset1 + bytes <= get_linear_mem_size()) \
|| offset1 + bytes <= (uint64)get_linear_mem_size()) \ /* If offset1 is in valid range, maddr must also \
/* If offset1 is in valid range, maddr must also \ be in valid range, no need to check it again. */ \
be in valid range, no need to check it again. */ \ maddr = memory->memory_data + offset1; \
maddr = memory->memory_data + offset1; \ else \
else \ goto out_of_bounds; \
goto out_of_bounds; \
} while (0) } while (0)
#define CHECK_BULK_MEMORY_OVERFLOW(start, bytes, maddr) \ #define CHECK_BULK_MEMORY_OVERFLOW(start, bytes, maddr) \
@ -1274,8 +1273,8 @@ wasm_interp_call_func_import(WASMModuleInstance *module_inst,
uint8 *ip = prev_frame->ip; uint8 *ip = prev_frame->ip;
char buf[128]; char buf[128];
WASMExecEnv *sub_module_exec_env = NULL; WASMExecEnv *sub_module_exec_env = NULL;
uint32 aux_stack_origin_boundary = 0; uintptr_t aux_stack_origin_boundary = 0;
uint32 aux_stack_origin_bottom = 0; uintptr_t aux_stack_origin_bottom = 0;
if (!sub_func_inst) { if (!sub_func_inst) {
snprintf(buf, sizeof(buf), snprintf(buf, sizeof(buf),
@ -1298,13 +1297,11 @@ wasm_interp_call_func_import(WASMModuleInstance *module_inst,
wasm_exec_env_set_module_inst(exec_env, wasm_exec_env_set_module_inst(exec_env,
(WASMModuleInstanceCommon *)sub_module_inst); (WASMModuleInstanceCommon *)sub_module_inst);
/* - aux_stack_boundary */ /* - aux_stack_boundary */
aux_stack_origin_boundary = exec_env->aux_stack_boundary.boundary; aux_stack_origin_boundary = exec_env->aux_stack_boundary;
exec_env->aux_stack_boundary.boundary = exec_env->aux_stack_boundary = sub_module_exec_env->aux_stack_boundary;
sub_module_exec_env->aux_stack_boundary.boundary;
/* - aux_stack_bottom */ /* - aux_stack_bottom */
aux_stack_origin_bottom = exec_env->aux_stack_bottom.bottom; aux_stack_origin_bottom = exec_env->aux_stack_bottom;
exec_env->aux_stack_bottom.bottom = exec_env->aux_stack_bottom = sub_module_exec_env->aux_stack_bottom;
sub_module_exec_env->aux_stack_bottom.bottom;
/* set ip NULL to make call_func_bytecode return after executing /* set ip NULL to make call_func_bytecode return after executing
this function */ this function */
@ -1316,8 +1313,8 @@ wasm_interp_call_func_import(WASMModuleInstance *module_inst,
/* restore ip and other replaced */ /* restore ip and other replaced */
prev_frame->ip = ip; prev_frame->ip = ip;
exec_env->aux_stack_boundary.boundary = aux_stack_origin_boundary; exec_env->aux_stack_boundary = aux_stack_origin_boundary;
exec_env->aux_stack_bottom.bottom = aux_stack_origin_bottom; exec_env->aux_stack_bottom = aux_stack_origin_bottom;
wasm_exec_env_restore_module_inst(exec_env, wasm_exec_env_restore_module_inst(exec_env,
(WASMModuleInstanceCommon *)module_inst); (WASMModuleInstanceCommon *)module_inst);
} }
@ -1444,7 +1441,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
#if !defined(OS_ENABLE_HW_BOUND_CHECK) \ #if !defined(OS_ENABLE_HW_BOUND_CHECK) \
|| WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS == 0 \ || WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS == 0 \
|| WASM_ENABLE_BULK_MEMORY != 0 || WASM_ENABLE_BULK_MEMORY != 0
uint32 linear_mem_size = 0; uint64 linear_mem_size = 0;
if (memory) if (memory)
#if WASM_ENABLE_THREAD_MGR == 0 #if WASM_ENABLE_THREAD_MGR == 0
linear_mem_size = memory->memory_data_size; linear_mem_size = memory->memory_data_size;
@ -3527,27 +3524,29 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
HANDLE_OP(WASM_OP_SET_GLOBAL_AUX_STACK) HANDLE_OP(WASM_OP_SET_GLOBAL_AUX_STACK)
{ {
uint32 aux_stack_top; uint64 aux_stack_top;
global_idx = read_uint32(frame_ip); global_idx = read_uint32(frame_ip);
bh_assert(global_idx < module->e->global_count); bh_assert(global_idx < module->e->global_count);
global = globals + global_idx; global = globals + global_idx;
global_addr = get_global_addr(global_data, global); global_addr = get_global_addr(global_data, global);
aux_stack_top = frame_lp[GET_OFFSET()]; /* TODO: Memory64 the data type depends on mem idx type */
if (aux_stack_top <= exec_env->aux_stack_boundary.boundary) { aux_stack_top = (uint64)frame_lp[GET_OFFSET()];
if (aux_stack_top <= (uint64)exec_env->aux_stack_boundary) {
wasm_set_exception(module, "wasm auxiliary stack overflow"); wasm_set_exception(module, "wasm auxiliary stack overflow");
goto got_exception; goto got_exception;
} }
if (aux_stack_top > exec_env->aux_stack_bottom.bottom) { if (aux_stack_top > (uint64)exec_env->aux_stack_bottom) {
wasm_set_exception(module, wasm_set_exception(module,
"wasm auxiliary stack underflow"); "wasm auxiliary stack underflow");
goto got_exception; goto got_exception;
} }
*(int32 *)global_addr = aux_stack_top; *(int32 *)global_addr = (uint32)aux_stack_top;
#if WASM_ENABLE_MEMORY_PROFILING != 0 #if WASM_ENABLE_MEMORY_PROFILING != 0
if (module->module->aux_stack_top_global_index != (uint32)-1) { if (module->module->aux_stack_top_global_index != (uint32)-1) {
uint32 aux_stack_used = module->module->aux_stack_bottom uint32 aux_stack_used =
- *(uint32 *)global_addr; (uint32)(module->module->aux_stack_bottom
- *(uint32 *)global_addr);
if (aux_stack_used > module->e->max_aux_stack_used) if (aux_stack_used > module->e->max_aux_stack_used)
module->e->max_aux_stack_used = aux_stack_used; module->e->max_aux_stack_used = aux_stack_used;
} }
@ -4968,8 +4967,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
#ifndef OS_ENABLE_HW_BOUND_CHECK #ifndef OS_ENABLE_HW_BOUND_CHECK
CHECK_BULK_MEMORY_OVERFLOW(addr, bytes, maddr); CHECK_BULK_MEMORY_OVERFLOW(addr, bytes, maddr);
#else #else
if ((uint64)(uint32)addr + bytes if ((uint64)(uint32)addr + bytes > linear_mem_size)
> (uint64)linear_mem_size)
goto out_of_bounds; goto out_of_bounds;
maddr = memory->memory_data + (uint32)addr; maddr = memory->memory_data + (uint32)addr;
#endif #endif
@ -4987,7 +4985,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
if (offset + bytes > seg_len) if (offset + bytes > seg_len)
goto out_of_bounds; goto out_of_bounds;
bh_memcpy_s(maddr, linear_mem_size - addr, bh_memcpy_s(maddr, (uint32)(linear_mem_size - addr),
data + offset, (uint32)bytes); data + offset, (uint32)bytes);
break; break;
} }
@ -5017,17 +5015,18 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
CHECK_BULK_MEMORY_OVERFLOW(src, len, msrc); CHECK_BULK_MEMORY_OVERFLOW(src, len, msrc);
CHECK_BULK_MEMORY_OVERFLOW(dst, len, mdst); CHECK_BULK_MEMORY_OVERFLOW(dst, len, mdst);
#else #else
if ((uint64)(uint32)src + len > (uint64)linear_mem_size) if ((uint64)(uint32)src + len > linear_mem_size)
goto out_of_bounds; goto out_of_bounds;
msrc = memory->memory_data + (uint32)src; msrc = memory->memory_data + (uint32)src;
if ((uint64)(uint32)dst + len > (uint64)linear_mem_size) if ((uint64)(uint32)dst + len > linear_mem_size)
goto out_of_bounds; goto out_of_bounds;
mdst = memory->memory_data + (uint32)dst; mdst = memory->memory_data + (uint32)dst;
#endif #endif
/* allowing the destination and source to overlap */ /* allowing the destination and source to overlap */
bh_memmove_s(mdst, linear_mem_size - dst, msrc, len); bh_memmove_s(mdst, (uint32)(linear_mem_size - dst),
msrc, len);
break; break;
} }
case WASM_OP_MEMORY_FILL: case WASM_OP_MEMORY_FILL:
@ -5046,7 +5045,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
#ifndef OS_ENABLE_HW_BOUND_CHECK #ifndef OS_ENABLE_HW_BOUND_CHECK
CHECK_BULK_MEMORY_OVERFLOW(dst, len, mdst); CHECK_BULK_MEMORY_OVERFLOW(dst, len, mdst);
#else #else
if ((uint64)(uint32)dst + len > (uint64)linear_mem_size) if ((uint64)(uint32)dst + len > linear_mem_size)
goto out_of_bounds; goto out_of_bounds;
mdst = memory->memory_data + (uint32)dst; mdst = memory->memory_data + (uint32)dst;
#endif #endif

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

@ -5597,8 +5597,9 @@ load_from_sections(WASMModule *module, WASMSection *sections,
*buf_func = NULL, *buf_func_end = NULL; *buf_func = NULL, *buf_func_end = NULL;
WASMGlobal *aux_data_end_global = NULL, *aux_heap_base_global = NULL; WASMGlobal *aux_data_end_global = NULL, *aux_heap_base_global = NULL;
WASMGlobal *aux_stack_top_global = NULL, *global; WASMGlobal *aux_stack_top_global = NULL, *global;
uint32 aux_data_end = (uint32)-1, aux_heap_base = (uint32)-1; uint64 aux_data_end = (uint64)-1, aux_heap_base = (uint64)-1,
uint32 aux_stack_top = (uint32)-1, global_index, func_index, i; aux_stack_top = (uint64)-1;
uint32 global_index, func_index, i;
uint32 aux_data_end_global_index = (uint32)-1; uint32 aux_data_end_global_index = (uint32)-1;
uint32 aux_heap_base_global_index = (uint32)-1; uint32 aux_heap_base_global_index = (uint32)-1;
WASMFuncType *func_type; WASMFuncType *func_type;
@ -5735,7 +5736,7 @@ load_from_sections(WASMModule *module, WASMSection *sections,
&& global->init_expr.init_expr_type && global->init_expr.init_expr_type
== INIT_EXPR_TYPE_I32_CONST) { == INIT_EXPR_TYPE_I32_CONST) {
aux_heap_base_global = global; aux_heap_base_global = global;
aux_heap_base = global->init_expr.u.i32; aux_heap_base = (uint64)(uint32)global->init_expr.u.i32;
aux_heap_base_global_index = export->index; aux_heap_base_global_index = export->index;
LOG_VERBOSE("Found aux __heap_base global, value: %d", LOG_VERBOSE("Found aux __heap_base global, value: %d",
aux_heap_base); aux_heap_base);
@ -5748,12 +5749,12 @@ load_from_sections(WASMModule *module, WASMSection *sections,
&& global->init_expr.init_expr_type && global->init_expr.init_expr_type
== INIT_EXPR_TYPE_I32_CONST) { == INIT_EXPR_TYPE_I32_CONST) {
aux_data_end_global = global; aux_data_end_global = global;
aux_data_end = global->init_expr.u.i32; aux_data_end = (uint64)(uint32)global->init_expr.u.i32;
aux_data_end_global_index = export->index; aux_data_end_global_index = export->index;
LOG_VERBOSE("Found aux __data_end global, value: %d", LOG_VERBOSE("Found aux __data_end global, value: %d",
aux_data_end); aux_data_end);
aux_data_end = align_uint(aux_data_end, 16); aux_data_end = align_uint64(aux_data_end, 16);
} }
} }
@ -5789,16 +5790,17 @@ load_from_sections(WASMModule *module, WASMSection *sections,
&& global->type == VALUE_TYPE_I32 && global->type == VALUE_TYPE_I32
&& global->init_expr.init_expr_type && global->init_expr.init_expr_type
== INIT_EXPR_TYPE_I32_CONST == INIT_EXPR_TYPE_I32_CONST
&& (uint32)global->init_expr.u.i32 <= aux_heap_base) { && (uint64)(uint32)global->init_expr.u.i32
<= aux_heap_base) {
aux_stack_top_global = global; aux_stack_top_global = global;
aux_stack_top = (uint32)global->init_expr.u.i32; aux_stack_top = (uint64)(uint32)global->init_expr.u.i32;
module->aux_stack_top_global_index = module->aux_stack_top_global_index =
module->import_global_count + global_index; module->import_global_count + global_index;
module->aux_stack_bottom = aux_stack_top; module->aux_stack_bottom = aux_stack_top;
module->aux_stack_size = module->aux_stack_size =
aux_stack_top > aux_data_end aux_stack_top > aux_data_end
? aux_stack_top - aux_data_end ? (uint32)(aux_stack_top - aux_data_end)
: aux_stack_top; : (uint32)aux_stack_top;
LOG_VERBOSE("Found aux stack top global, value: %d, " LOG_VERBOSE("Found aux stack top global, value: %d, "
"global index: %d, stack size: %d", "global index: %d, stack size: %d",
aux_stack_top, global_index, aux_stack_top, global_index,
@ -5939,29 +5941,35 @@ load_from_sections(WASMModule *module, WASMSection *sections,
if (aux_data_end_global && aux_heap_base_global if (aux_data_end_global && aux_heap_base_global
&& aux_stack_top_global) { && aux_stack_top_global) {
uint64 init_memory_size; uint64 init_memory_size;
uint32 shrunk_memory_size = align_uint(aux_heap_base, 8); uint64 shrunk_memory_size = align_uint64(aux_heap_base, 8);
if (module->import_memory_count) { /* Only resize(shrunk) the memory size if num_bytes_per_page is in
memory_import = &module->import_memories[0].u.memory; * valid range of uint32 */
init_memory_size = (uint64)memory_import->num_bytes_per_page if (shrunk_memory_size <= UINT32_MAX) {
* memory_import->init_page_count; if (module->import_memory_count) {
if (shrunk_memory_size <= init_memory_size) { memory_import = &module->import_memories[0].u.memory;
/* Reset memory info to decrease memory usage */ init_memory_size = (uint64)memory_import->num_bytes_per_page
memory_import->num_bytes_per_page = shrunk_memory_size; * memory_import->init_page_count;
memory_import->init_page_count = 1; if (shrunk_memory_size <= init_memory_size) {
LOG_VERBOSE("Shrink import memory size to %d", /* Reset memory info to decrease memory usage */
shrunk_memory_size); memory_import->num_bytes_per_page = shrunk_memory_size;
memory_import->init_page_count = 1;
LOG_VERBOSE("Shrink import memory size to %d",
shrunk_memory_size);
}
} }
}
if (module->memory_count) { if (module->memory_count) {
memory = &module->memories[0]; memory = &module->memories[0];
init_memory_size = (uint64)memory->num_bytes_per_page init_memory_size = (uint64)memory->num_bytes_per_page
* memory->init_page_count; * memory->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->num_bytes_per_page = shrunk_memory_size; memory->num_bytes_per_page = shrunk_memory_size;
memory->init_page_count = 1; memory->init_page_count = 1;
LOG_VERBOSE("Shrink memory size to %d", shrunk_memory_size); LOG_VERBOSE("Shrink memory size to %d",
shrunk_memory_size);
}
} }
} }
} }
@ -5969,30 +5977,31 @@ load_from_sections(WASMModule *module, WASMSection *sections,
#if WASM_ENABLE_MULTI_MODULE == 0 #if WASM_ENABLE_MULTI_MODULE == 0
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) /* Only resize the memory to one big page if num_bytes_per_page is
* in valid range of uint32 */
if (memory_import->init_page_count < DEFAULT_MAX_PAGES) {
memory_import->num_bytes_per_page *= memory_import->num_bytes_per_page *=
memory_import->init_page_count; memory_import->init_page_count;
else
memory_import->num_bytes_per_page = UINT32_MAX;
if (memory_import->init_page_count > 0) if (memory_import->init_page_count > 0)
memory_import->init_page_count = memory_import->max_page_count = memory_import->init_page_count =
1; memory_import->max_page_count = 1;
else else
memory_import->init_page_count = memory_import->max_page_count = memory_import->init_page_count =
0; memory_import->max_page_count = 0;
}
} }
if (module->memory_count) { if (module->memory_count) {
memory = &module->memories[0]; memory = &module->memories[0];
if (memory->init_page_count < DEFAULT_MAX_PAGES) /* Only resize(shrunk) the memory size if num_bytes_per_page is in
* valid range of uint32 */
if (memory->init_page_count < DEFAULT_MAX_PAGES) {
memory->num_bytes_per_page *= memory->init_page_count; memory->num_bytes_per_page *= memory->init_page_count;
else if (memory->init_page_count > 0)
memory->num_bytes_per_page = UINT32_MAX; memory->init_page_count = memory->max_page_count = 1;
else
if (memory->init_page_count > 0) memory->init_page_count = memory->max_page_count = 0;
memory->init_page_count = memory->max_page_count = 1; }
else
memory->init_page_count = memory->max_page_count = 0;
} }
#endif #endif
} }

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

@ -2542,8 +2542,9 @@ load_from_sections(WASMModule *module, WASMSection *sections,
*buf_func = NULL, *buf_func_end = NULL; *buf_func = NULL, *buf_func_end = NULL;
WASMGlobal *aux_data_end_global = NULL, *aux_heap_base_global = NULL; WASMGlobal *aux_data_end_global = NULL, *aux_heap_base_global = NULL;
WASMGlobal *aux_stack_top_global = NULL, *global; WASMGlobal *aux_stack_top_global = NULL, *global;
uint32 aux_data_end = (uint32)-1, aux_heap_base = (uint32)-1; uint64 aux_data_end = (uint64)-1, aux_heap_base = (uint64)-1,
uint32 aux_stack_top = (uint32)-1, global_index, func_index, i; aux_stack_top = (uint64)-1;
uint32 global_index, func_index, i;
uint32 aux_data_end_global_index = (uint32)-1; uint32 aux_data_end_global_index = (uint32)-1;
uint32 aux_heap_base_global_index = (uint32)-1; uint32 aux_heap_base_global_index = (uint32)-1;
WASMFuncType *func_type; WASMFuncType *func_type;
@ -2661,7 +2662,7 @@ load_from_sections(WASMModule *module, WASMSection *sections,
&& global->init_expr.init_expr_type && global->init_expr.init_expr_type
== INIT_EXPR_TYPE_I32_CONST) { == INIT_EXPR_TYPE_I32_CONST) {
aux_heap_base_global = global; aux_heap_base_global = global;
aux_heap_base = global->init_expr.u.i32; aux_heap_base = (uint64)(uint32)global->init_expr.u.i32;
aux_heap_base_global_index = export->index; aux_heap_base_global_index = export->index;
LOG_VERBOSE("Found aux __heap_base global, value: %d", LOG_VERBOSE("Found aux __heap_base global, value: %d",
aux_heap_base); aux_heap_base);
@ -2674,12 +2675,11 @@ load_from_sections(WASMModule *module, WASMSection *sections,
&& global->init_expr.init_expr_type && global->init_expr.init_expr_type
== INIT_EXPR_TYPE_I32_CONST) { == INIT_EXPR_TYPE_I32_CONST) {
aux_data_end_global = global; aux_data_end_global = global;
aux_data_end = global->init_expr.u.i32; aux_data_end = (uint64)(uint32)global->init_expr.u.i32;
aux_data_end_global_index = export->index; aux_data_end_global_index = export->index;
LOG_VERBOSE("Found aux __data_end global, value: %d", LOG_VERBOSE("Found aux __data_end global, value: %d",
aux_data_end); aux_data_end);
aux_data_end = align_uint64(aux_data_end, 16);
aux_data_end = align_uint(aux_data_end, 16);
} }
} }
@ -2715,16 +2715,17 @@ load_from_sections(WASMModule *module, WASMSection *sections,
&& global->type == VALUE_TYPE_I32 && global->type == VALUE_TYPE_I32
&& global->init_expr.init_expr_type && global->init_expr.init_expr_type
== INIT_EXPR_TYPE_I32_CONST == INIT_EXPR_TYPE_I32_CONST
&& (uint32)global->init_expr.u.i32 <= aux_heap_base) { && (uint64)(uint32)global->init_expr.u.i32
<= aux_heap_base) {
aux_stack_top_global = global; aux_stack_top_global = global;
aux_stack_top = (uint32)global->init_expr.u.i32; aux_stack_top = (uint64)(uint32)global->init_expr.u.i32;
module->aux_stack_top_global_index = module->aux_stack_top_global_index =
module->import_global_count + global_index; module->import_global_count + global_index;
module->aux_stack_bottom = aux_stack_top; module->aux_stack_bottom = aux_stack_top;
module->aux_stack_size = module->aux_stack_size =
aux_stack_top > aux_data_end aux_stack_top > aux_data_end
? aux_stack_top - aux_data_end ? (uint32)(aux_stack_top - aux_data_end)
: aux_stack_top; : (uint32)aux_stack_top;
LOG_VERBOSE("Found aux stack top global, value: %d, " LOG_VERBOSE("Found aux stack top global, value: %d, "
"global index: %d, stack size: %d", "global index: %d, stack size: %d",
aux_stack_top, global_index, aux_stack_top, global_index,
@ -2862,60 +2863,62 @@ load_from_sections(WASMModule *module, WASMSection *sections,
if (aux_data_end_global && aux_heap_base_global if (aux_data_end_global && aux_heap_base_global
&& aux_stack_top_global) { && aux_stack_top_global) {
uint64 init_memory_size; uint64 init_memory_size;
uint32 shrunk_memory_size = align_uint(aux_heap_base, 8); uint64 shrunk_memory_size = align_uint64(aux_heap_base, 8);
if (module->import_memory_count) { /* Only resize(shrunk) the memory size if num_bytes_per_page is in
memory_import = &module->import_memories[0].u.memory; * valid range of uint32 */
init_memory_size = (uint64)memory_import->num_bytes_per_page if (shrunk_memory_size <= UINT32_MAX) {
* memory_import->init_page_count; if (module->import_memory_count) {
if (shrunk_memory_size <= init_memory_size) { memory_import = &module->import_memories[0].u.memory;
/* Reset memory info to decrease memory usage */ init_memory_size = (uint64)memory_import->num_bytes_per_page
memory_import->num_bytes_per_page = shrunk_memory_size; * memory_import->init_page_count;
memory_import->init_page_count = 1; if (shrunk_memory_size <= init_memory_size) {
LOG_VERBOSE("Shrink import memory size to %d", /* Reset memory info to decrease memory usage */
shrunk_memory_size); memory_import->num_bytes_per_page = shrunk_memory_size;
memory_import->init_page_count = 1;
LOG_VERBOSE("Shrink import memory size to %d",
shrunk_memory_size);
}
} }
}
if (module->memory_count) { if (module->memory_count) {
memory = &module->memories[0]; memory = &module->memories[0];
init_memory_size = (uint64)memory->num_bytes_per_page init_memory_size = (uint64)memory->num_bytes_per_page
* memory->init_page_count; * memory->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->num_bytes_per_page = shrunk_memory_size; memory->num_bytes_per_page = shrunk_memory_size;
memory->init_page_count = 1; memory->init_page_count = 1;
LOG_VERBOSE("Shrink memory size to %d", shrunk_memory_size); LOG_VERBOSE("Shrink memory size to %d",
shrunk_memory_size);
}
} }
} }
} }
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->init_page_count < DEFAULT_MAX_PAGES) {
memory_import->num_bytes_per_page *= memory_import->num_bytes_per_page *=
memory_import->init_page_count; memory_import->init_page_count;
else if (memory_import->init_page_count > 0)
memory_import->num_bytes_per_page = UINT32_MAX; memory_import->init_page_count =
memory_import->max_page_count = 1;
if (memory_import->init_page_count > 0) else
memory_import->init_page_count = memory_import->max_page_count = memory_import->init_page_count =
1; memory_import->max_page_count = 0;
else }
memory_import->init_page_count = memory_import->max_page_count =
0;
} }
if (module->memory_count) { if (module->memory_count) {
memory = &module->memories[0]; memory = &module->memories[0];
if (memory->init_page_count < DEFAULT_MAX_PAGES) if (memory->init_page_count < DEFAULT_MAX_PAGES) {
memory->num_bytes_per_page *= memory->init_page_count; memory->num_bytes_per_page *= memory->init_page_count;
else if (memory->init_page_count > 0)
memory->num_bytes_per_page = UINT32_MAX; memory->init_page_count = memory->max_page_count = 1;
else
if (memory->init_page_count > 0) memory->init_page_count = memory->max_page_count = 0;
memory->init_page_count = memory->max_page_count = 1; }
else
memory->init_page_count = memory->max_page_count = 0;
} }
} }

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

@ -162,10 +162,11 @@ memory_instantiate(WASMModuleInstance *module_inst, WASMModuleInstance *parent,
char *error_buf, uint32 error_buf_size) char *error_buf, uint32 error_buf_size)
{ {
WASMModule *module = module_inst->module; WASMModule *module = module_inst->module;
uint64 memory_data_size, max_memory_data_size; uint32 inc_page_count, global_idx;
uint32 heap_offset = num_bytes_per_page * init_page_count;
uint32 inc_page_count, aux_heap_base, global_idx;
uint32 bytes_of_last_page, bytes_to_page_end; uint32 bytes_of_last_page, bytes_to_page_end;
uint64 aux_heap_base,
heap_offset = (uint64)num_bytes_per_page * init_page_count;
uint64 memory_data_size, max_memory_data_size;
uint8 *global_addr; uint8 *global_addr;
bool is_shared_memory = false; bool is_shared_memory = false;
@ -192,6 +193,15 @@ memory_instantiate(WASMModuleInstance *module_inst, WASMModuleInstance *parent,
heap_size = 0; heap_size = 0;
} }
/* If initial memory is the largest size allowed, disallowing insert host
* managed heap */
if (heap_size > 0 && heap_offset == MAX_LINEAR_MEMORY_SIZE) {
set_error_buf(error_buf, error_buf_size,
"failed to insert app heap into linear memory, "
"try using `--heap-size=0` option");
return NULL;
}
if (init_page_count == max_page_count && init_page_count == 1) { if (init_page_count == max_page_count && init_page_count == 1) {
/* If only one page and at most one page, we just append /* If only one page and at most one page, we just append
the app heap to the end of linear memory, enlarge the the app heap to the end of linear memory, enlarge the
@ -215,7 +225,7 @@ memory_instantiate(WASMModuleInstance *module_inst, WASMModuleInstance *parent,
} }
else if (module->aux_heap_base_global_index != (uint32)-1 else if (module->aux_heap_base_global_index != (uint32)-1
&& module->aux_heap_base && module->aux_heap_base
< num_bytes_per_page * init_page_count) { < (uint64)num_bytes_per_page * init_page_count) {
/* Insert app heap before __heap_base */ /* Insert app heap before __heap_base */
aux_heap_base = module->aux_heap_base; aux_heap_base = module->aux_heap_base;
bytes_of_last_page = aux_heap_base % num_bytes_per_page; bytes_of_last_page = aux_heap_base % num_bytes_per_page;
@ -243,15 +253,15 @@ memory_instantiate(WASMModuleInstance *module_inst, WASMModuleInstance *parent,
&& global_idx < module_inst->e->global_count); && global_idx < module_inst->e->global_count);
global_addr = module_inst->global_data global_addr = module_inst->global_data
+ module_inst->e->globals[global_idx].data_offset; + module_inst->e->globals[global_idx].data_offset;
*(uint32 *)global_addr = aux_heap_base; *(uint32 *)global_addr = (uint32)aux_heap_base;
LOG_VERBOSE("Reset __heap_base global to %u", aux_heap_base); LOG_VERBOSE("Reset __heap_base global to %u", aux_heap_base);
} }
else { else {
/* Insert app heap before new page */ /* Insert app heap before new page */
inc_page_count = inc_page_count =
(heap_size + num_bytes_per_page - 1) / num_bytes_per_page; (heap_size + num_bytes_per_page - 1) / num_bytes_per_page;
heap_offset = num_bytes_per_page * init_page_count; heap_offset = (uint64)num_bytes_per_page * init_page_count;
heap_size = num_bytes_per_page * inc_page_count; heap_size = (uint64)num_bytes_per_page * inc_page_count;
if (heap_size > 0) if (heap_size > 0)
heap_size -= 1 * BH_KB; heap_size -= 1 * BH_KB;
} }
@ -263,19 +273,9 @@ memory_instantiate(WASMModuleInstance *module_inst, WASMModuleInstance *parent,
"try using `--heap-size=0` option"); "try using `--heap-size=0` option");
return NULL; return NULL;
} }
else if (init_page_count == DEFAULT_MAX_PAGES) {
num_bytes_per_page = UINT32_MAX;
init_page_count = max_page_count = 1;
}
if (max_page_count > DEFAULT_MAX_PAGES) if (max_page_count > DEFAULT_MAX_PAGES)
max_page_count = DEFAULT_MAX_PAGES; max_page_count = DEFAULT_MAX_PAGES;
} }
else { /* heap_size == 0 */
if (init_page_count == DEFAULT_MAX_PAGES) {
num_bytes_per_page = UINT32_MAX;
init_page_count = max_page_count = 1;
}
}
LOG_VERBOSE("Memory instantiate:"); LOG_VERBOSE("Memory instantiate:");
LOG_VERBOSE(" page bytes: %u, init pages: %u, max pages: %u", LOG_VERBOSE(" page bytes: %u, init pages: %u, max pages: %u",
@ -283,7 +283,7 @@ memory_instantiate(WASMModuleInstance *module_inst, WASMModuleInstance *parent,
LOG_VERBOSE(" heap offset: %u, heap size: %d\n", heap_offset, heap_size); LOG_VERBOSE(" heap offset: %u, heap size: %d\n", heap_offset, heap_size);
max_memory_data_size = (uint64)num_bytes_per_page * max_page_count; max_memory_data_size = (uint64)num_bytes_per_page * max_page_count;
bh_assert(max_memory_data_size <= 4 * (uint64)BH_GB); bh_assert(max_memory_data_size <= MAX_LINEAR_MEMORY_SIZE);
(void)max_memory_data_size; (void)max_memory_data_size;
bh_assert(memory != NULL); bh_assert(memory != NULL);
@ -301,11 +301,11 @@ memory_instantiate(WASMModuleInstance *module_inst, WASMModuleInstance *parent,
memory->num_bytes_per_page = num_bytes_per_page; memory->num_bytes_per_page = num_bytes_per_page;
memory->cur_page_count = init_page_count; memory->cur_page_count = init_page_count;
memory->max_page_count = max_page_count; memory->max_page_count = max_page_count;
memory->memory_data_size = (uint32)memory_data_size; memory->memory_data_size = memory_data_size;
memory->heap_data = memory->memory_data + heap_offset; memory->heap_data = memory->memory_data + heap_offset;
memory->heap_data_end = memory->heap_data + heap_size; memory->heap_data_end = memory->heap_data + heap_size;
memory->memory_data_end = memory->memory_data + (uint32)memory_data_size; memory->memory_data_end = memory->memory_data + memory_data_size;
/* Initialize heap */ /* Initialize heap */
if (heap_size > 0) { if (heap_size > 0) {
@ -3274,27 +3274,30 @@ wasm_get_wasm_func_exec_time(const WASMModuleInstance *inst,
} }
#endif /*WASM_ENABLE_PERF_PROFILING != 0*/ #endif /*WASM_ENABLE_PERF_PROFILING != 0*/
uint32 uint64
wasm_module_malloc_internal(WASMModuleInstance *module_inst, wasm_module_malloc_internal(WASMModuleInstance *module_inst,
WASMExecEnv *exec_env, uint32 size, WASMExecEnv *exec_env, uint64 size,
void **p_native_addr) void **p_native_addr)
{ {
WASMMemoryInstance *memory = wasm_get_default_memory(module_inst); WASMMemoryInstance *memory = wasm_get_default_memory(module_inst);
uint8 *addr = NULL; uint8 *addr = NULL;
uint32 offset = 0; uint32 offset = 0;
/* TODO: Memory64 size check based on memory idx type */
bh_assert(size <= UINT32_MAX);
if (!memory) { if (!memory) {
wasm_set_exception(module_inst, "uninitialized memory"); wasm_set_exception(module_inst, "uninitialized memory");
return 0; return 0;
} }
if (memory->heap_handle) { if (memory->heap_handle) {
addr = mem_allocator_malloc(memory->heap_handle, size); addr = mem_allocator_malloc(memory->heap_handle, (uint32)size);
} }
else if (module_inst->e->malloc_function && module_inst->e->free_function) { else if (module_inst->e->malloc_function && module_inst->e->free_function) {
if (!execute_malloc_function( if (!execute_malloc_function(
module_inst, exec_env, module_inst->e->malloc_function, module_inst, exec_env, module_inst->e->malloc_function,
module_inst->e->retain_function, size, &offset)) { module_inst->e->retain_function, (uint32)size, &offset)) {
return 0; return 0;
} }
/* If we use app's malloc function, /* If we use app's malloc function,
@ -3317,17 +3320,21 @@ wasm_module_malloc_internal(WASMModuleInstance *module_inst,
if (p_native_addr) if (p_native_addr)
*p_native_addr = addr; *p_native_addr = addr;
return (uint32)(addr - memory->memory_data); return (uint64)(addr - memory->memory_data);
} }
uint32 uint64
wasm_module_realloc_internal(WASMModuleInstance *module_inst, wasm_module_realloc_internal(WASMModuleInstance *module_inst,
WASMExecEnv *exec_env, uint32 ptr, uint32 size, WASMExecEnv *exec_env, uint64 ptr, uint64 size,
void **p_native_addr) void **p_native_addr)
{ {
WASMMemoryInstance *memory = wasm_get_default_memory(module_inst); WASMMemoryInstance *memory = wasm_get_default_memory(module_inst);
uint8 *addr = NULL; uint8 *addr = NULL;
/* TODO: Memory64 ptr and size check based on memory idx type */
bh_assert(ptr <= UINT32_MAX);
bh_assert(size <= UINT32_MAX);
if (!memory) { if (!memory) {
wasm_set_exception(module_inst, "uninitialized memory"); wasm_set_exception(module_inst, "uninitialized memory");
return 0; return 0;
@ -3335,7 +3342,9 @@ wasm_module_realloc_internal(WASMModuleInstance *module_inst,
if (memory->heap_handle) { if (memory->heap_handle) {
addr = mem_allocator_realloc( addr = mem_allocator_realloc(
memory->heap_handle, ptr ? memory->memory_data + ptr : NULL, size); memory->heap_handle,
(uint32)ptr ? memory->memory_data + (uint32)ptr : NULL,
(uint32)size);
} }
/* Only support realloc in WAMR's app heap */ /* Only support realloc in WAMR's app heap */
@ -3354,21 +3363,24 @@ wasm_module_realloc_internal(WASMModuleInstance *module_inst,
if (p_native_addr) if (p_native_addr)
*p_native_addr = addr; *p_native_addr = addr;
return (uint32)(addr - memory->memory_data); return (uint64)(addr - memory->memory_data);
} }
void void
wasm_module_free_internal(WASMModuleInstance *module_inst, wasm_module_free_internal(WASMModuleInstance *module_inst,
WASMExecEnv *exec_env, uint32 ptr) WASMExecEnv *exec_env, uint64 ptr)
{ {
WASMMemoryInstance *memory = wasm_get_default_memory(module_inst); WASMMemoryInstance *memory = wasm_get_default_memory(module_inst);
/* TODO: Memory64 ptr and size check based on memory idx type */
bh_assert(ptr <= UINT32_MAX);
if (!memory) { if (!memory) {
return; return;
} }
if (ptr) { if (ptr) {
uint8 *addr = memory->memory_data + ptr; uint8 *addr = memory->memory_data + (uint32)ptr;
uint8 *memory_data_end; uint8 *memory_data_end;
/* memory->memory_data_end may be changed in memory grow */ /* memory->memory_data_end may be changed in memory grow */
@ -3384,20 +3396,20 @@ wasm_module_free_internal(WASMModuleInstance *module_inst,
&& module_inst->e->free_function && memory->memory_data <= addr && module_inst->e->free_function && memory->memory_data <= addr
&& addr < memory_data_end) { && addr < memory_data_end) {
execute_free_function(module_inst, exec_env, execute_free_function(module_inst, exec_env,
module_inst->e->free_function, ptr); module_inst->e->free_function, (uint32)ptr);
} }
} }
} }
uint32 uint64
wasm_module_malloc(WASMModuleInstance *module_inst, uint32 size, wasm_module_malloc(WASMModuleInstance *module_inst, uint64 size,
void **p_native_addr) void **p_native_addr)
{ {
return wasm_module_malloc_internal(module_inst, NULL, size, p_native_addr); return wasm_module_malloc_internal(module_inst, NULL, size, p_native_addr);
} }
uint32 uint64
wasm_module_realloc(WASMModuleInstance *module_inst, uint32 ptr, uint32 size, wasm_module_realloc(WASMModuleInstance *module_inst, uint64 ptr, uint64 size,
void **p_native_addr) void **p_native_addr)
{ {
return wasm_module_realloc_internal(module_inst, NULL, ptr, size, return wasm_module_realloc_internal(module_inst, NULL, ptr, size,
@ -3405,22 +3417,27 @@ wasm_module_realloc(WASMModuleInstance *module_inst, uint32 ptr, uint32 size,
} }
void void
wasm_module_free(WASMModuleInstance *module_inst, uint32 ptr) wasm_module_free(WASMModuleInstance *module_inst, uint64 ptr)
{ {
wasm_module_free_internal(module_inst, NULL, ptr); wasm_module_free_internal(module_inst, NULL, ptr);
} }
uint32 uint64
wasm_module_dup_data(WASMModuleInstance *module_inst, const char *src, wasm_module_dup_data(WASMModuleInstance *module_inst, const char *src,
uint32 size) uint64 size)
{ {
char *buffer; char *buffer;
uint32 buffer_offset = uint64 buffer_offset;
wasm_module_malloc(module_inst, size, (void **)&buffer);
/* TODO: Memory64 size check based on memory idx type */
bh_assert(size <= UINT32_MAX);
buffer_offset = wasm_module_malloc(module_inst, size, (void **)&buffer);
if (buffer_offset != 0) { if (buffer_offset != 0) {
buffer = wasm_runtime_addr_app_to_native( buffer = wasm_runtime_addr_app_to_native(
(WASMModuleInstanceCommon *)module_inst, buffer_offset); (WASMModuleInstanceCommon *)module_inst, buffer_offset);
bh_memcpy_s(buffer, size, src, size); bh_memcpy_s(buffer, (uint32)size, src, (uint32)size);
} }
return buffer_offset; return buffer_offset;
} }
@ -3543,7 +3560,7 @@ wasm_call_indirect(WASMExecEnv *exec_env, uint32 tbl_idx, uint32 elem_idx,
#if WASM_ENABLE_THREAD_MGR != 0 #if WASM_ENABLE_THREAD_MGR != 0
bool bool
wasm_set_aux_stack(WASMExecEnv *exec_env, uint32 start_offset, uint32 size) wasm_set_aux_stack(WASMExecEnv *exec_env, uint64 start_offset, uint32 size)
{ {
WASMModuleInstance *module_inst = WASMModuleInstance *module_inst =
(WASMModuleInstance *)exec_env->module_inst; (WASMModuleInstance *)exec_env->module_inst;
@ -3551,8 +3568,8 @@ wasm_set_aux_stack(WASMExecEnv *exec_env, uint32 start_offset, uint32 size)
#if WASM_ENABLE_HEAP_AUX_STACK_ALLOCATION == 0 #if WASM_ENABLE_HEAP_AUX_STACK_ALLOCATION == 0
/* Check the aux stack space */ /* Check the aux stack space */
uint32 data_end = module_inst->module->aux_data_end; uint64 data_end = module_inst->module->aux_data_end;
uint32 stack_bottom = module_inst->module->aux_stack_bottom; uint64 stack_bottom = module_inst->module->aux_stack_bottom;
bool is_stack_before_data = stack_bottom < data_end ? true : false; bool is_stack_before_data = stack_bottom < data_end ? true : false;
if ((is_stack_before_data && (size > start_offset)) if ((is_stack_before_data && (size > start_offset))
|| ((!is_stack_before_data) && (start_offset - data_end < size))) || ((!is_stack_before_data) && (start_offset - data_end < size)))
@ -3565,11 +3582,11 @@ wasm_set_aux_stack(WASMExecEnv *exec_env, uint32 start_offset, uint32 size)
uint8 *global_addr = uint8 *global_addr =
module_inst->global_data module_inst->global_data
+ module_inst->e->globals[stack_top_idx].data_offset; + module_inst->e->globals[stack_top_idx].data_offset;
*(int32 *)global_addr = start_offset; *(int32 *)global_addr = (uint32)start_offset;
/* The aux stack boundary is a constant value, /* The aux stack boundary is a constant value,
set the value to exec_env */ set the value to exec_env */
exec_env->aux_stack_boundary.boundary = start_offset - size; exec_env->aux_stack_boundary = (uintptr_t)start_offset - size;
exec_env->aux_stack_bottom.bottom = start_offset; exec_env->aux_stack_bottom = (uintptr_t)start_offset;
return true; return true;
} }
@ -3577,14 +3594,14 @@ wasm_set_aux_stack(WASMExecEnv *exec_env, uint32 start_offset, uint32 size)
} }
bool bool
wasm_get_aux_stack(WASMExecEnv *exec_env, uint32 *start_offset, uint32 *size) wasm_get_aux_stack(WASMExecEnv *exec_env, uint64 *start_offset, uint32 *size)
{ {
WASMModuleInstance *module_inst = WASMModuleInstance *module_inst =
(WASMModuleInstance *)exec_env->module_inst; (WASMModuleInstance *)exec_env->module_inst;
/* The aux stack information is resolved in loader /* The aux stack information is resolved in loader
and store in module */ and store in module */
uint32 stack_bottom = module_inst->module->aux_stack_bottom; uint64 stack_bottom = module_inst->module->aux_stack_bottom;
uint32 total_aux_stack_size = module_inst->module->aux_stack_size; uint32 total_aux_stack_size = module_inst->module->aux_stack_size;
if (stack_bottom != 0 && total_aux_stack_size != 0) { if (stack_bottom != 0 && total_aux_stack_size != 0) {
@ -3678,7 +3695,8 @@ void
wasm_get_module_inst_mem_consumption(const WASMModuleInstance *module_inst, wasm_get_module_inst_mem_consumption(const WASMModuleInstance *module_inst,
WASMModuleInstMemConsumption *mem_conspn) WASMModuleInstMemConsumption *mem_conspn)
{ {
uint32 i, size; uint32 i;
uint64 size;
memset(mem_conspn, 0, sizeof(*mem_conspn)); memset(mem_conspn, 0, sizeof(*mem_conspn));
@ -3958,7 +3976,7 @@ jit_set_exception_with_id(WASMModuleInstance *module_inst, uint32 id)
bool bool
jit_check_app_addr_and_convert(WASMModuleInstance *module_inst, bool is_str, jit_check_app_addr_and_convert(WASMModuleInstance *module_inst, bool is_str,
uint32 app_buf_addr, uint32 app_buf_size, uint64 app_buf_addr, uint64 app_buf_size,
void **p_native_addr) void **p_native_addr)
{ {
bool ret = wasm_check_app_addr_and_convert( bool ret = wasm_check_app_addr_and_convert(
@ -4104,7 +4122,7 @@ llvm_jit_memory_init(WASMModuleInstance *module_inst, uint32 seg_index,
} }
if (!wasm_runtime_validate_app_addr((WASMModuleInstanceCommon *)module_inst, if (!wasm_runtime_validate_app_addr((WASMModuleInstanceCommon *)module_inst,
dst, len)) (uint64)dst, (uint64)len))
return false; return false;
if ((uint64)offset + (uint64)len > seg_len) { if ((uint64)offset + (uint64)len > seg_len) {
@ -4113,10 +4131,11 @@ llvm_jit_memory_init(WASMModuleInstance *module_inst, uint32 seg_index,
} }
maddr = wasm_runtime_addr_app_to_native( maddr = wasm_runtime_addr_app_to_native(
(WASMModuleInstanceCommon *)module_inst, dst); (WASMModuleInstanceCommon *)module_inst, (uint64)dst);
SHARED_MEMORY_LOCK(memory_inst); SHARED_MEMORY_LOCK(memory_inst);
bh_memcpy_s(maddr, memory_inst->memory_data_size - dst, data + offset, len); bh_memcpy_s(maddr, (uint32)(memory_inst->memory_data_size - dst),
data + offset, len);
SHARED_MEMORY_UNLOCK(memory_inst); SHARED_MEMORY_UNLOCK(memory_inst);
return true; return true;
} }

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

@ -103,13 +103,17 @@ struct WASMMemoryInstance {
/* Whether the memory is shared */ /* Whether the memory is shared */
uint8 is_shared_memory; uint8 is_shared_memory;
/* One byte padding */ /* TODO: Memory64 whether the memory has 64-bit memory addresses */
uint8 __padding__; uint8 is_memory64;
/* Reference count of the memory instance: /* Reference count of the memory instance:
0: non-shared memory, > 0: shared memory */ 0: non-shared memory, > 0: shared memory */
bh_atomic_16_t ref_count; bh_atomic_16_t ref_count;
/* Four-byte paddings to ensure the layout of WASMMemoryInstance is the same
* in both 64-bit and 32-bit */
uint8 __paddings[4];
/* Number bytes per page */ /* Number bytes per page */
uint32 num_bytes_per_page; uint32 num_bytes_per_page;
/* Current page count */ /* Current page count */
@ -117,7 +121,7 @@ struct WASMMemoryInstance {
/* Maximum page count */ /* Maximum page count */
uint32 max_page_count; uint32 max_page_count;
/* Memory data size */ /* Memory data size */
uint32 memory_data_size; uint64 memory_data_size;
/** /**
* Memory data begin address, Note: * Memory data begin address, Note:
* the app-heap might be inserted in to the linear memory, * the app-heap might be inserted in to the linear memory,
@ -175,7 +179,8 @@ struct WASMGlobalInstance {
uint8 type; uint8 type;
/* mutable or constant */ /* mutable or constant */
bool is_mutable; bool is_mutable;
/* data offset to base_addr of WASMMemoryInstance */ /* data offset to the address of initial_value, started from the end of
* WASMMemoryInstance(start of WASMGlobalInstance)*/
uint32 data_offset; uint32 data_offset;
/* initial value */ /* initial value */
WASMValue initial_value; WASMValue initial_value;
@ -577,34 +582,34 @@ wasm_get_exception(WASMModuleInstance *module);
bool bool
wasm_copy_exception(WASMModuleInstance *module_inst, char *exception_buf); wasm_copy_exception(WASMModuleInstance *module_inst, char *exception_buf);
uint32 uint64
wasm_module_malloc_internal(WASMModuleInstance *module_inst, wasm_module_malloc_internal(WASMModuleInstance *module_inst,
WASMExecEnv *exec_env, uint32 size, WASMExecEnv *exec_env, uint64 size,
void **p_native_addr); void **p_native_addr);
uint32 uint64
wasm_module_realloc_internal(WASMModuleInstance *module_inst, wasm_module_realloc_internal(WASMModuleInstance *module_inst,
WASMExecEnv *exec_env, uint32 ptr, uint32 size, WASMExecEnv *exec_env, uint64 ptr, uint64 size,
void **p_native_addr); void **p_native_addr);
void void
wasm_module_free_internal(WASMModuleInstance *module_inst, wasm_module_free_internal(WASMModuleInstance *module_inst,
WASMExecEnv *exec_env, uint32 ptr); WASMExecEnv *exec_env, uint64 ptr);
uint32 uint64
wasm_module_malloc(WASMModuleInstance *module_inst, uint32 size, wasm_module_malloc(WASMModuleInstance *module_inst, uint64 size,
void **p_native_addr); void **p_native_addr);
uint32 uint64
wasm_module_realloc(WASMModuleInstance *module_inst, uint32 ptr, uint32 size, wasm_module_realloc(WASMModuleInstance *module_inst, uint64 ptr, uint64 size,
void **p_native_addr); void **p_native_addr);
void void
wasm_module_free(WASMModuleInstance *module_inst, uint32 ptr); wasm_module_free(WASMModuleInstance *module_inst, uint64 ptr);
uint32 uint64
wasm_module_dup_data(WASMModuleInstance *module_inst, const char *src, wasm_module_dup_data(WASMModuleInstance *module_inst, const char *src,
uint32 size); uint64 size);
/** /**
* Check whether the app address and the buf is inside the linear memory, * Check whether the app address and the buf is inside the linear memory,
@ -612,7 +617,7 @@ wasm_module_dup_data(WASMModuleInstance *module_inst, const char *src,
*/ */
bool bool
wasm_check_app_addr_and_convert(WASMModuleInstance *module_inst, bool is_str, wasm_check_app_addr_and_convert(WASMModuleInstance *module_inst, bool is_str,
uint32 app_buf_addr, uint32 app_buf_size, uint64 app_buf_addr, uint64 app_buf_size,
void **p_native_addr); void **p_native_addr);
WASMMemoryInstance * WASMMemoryInstance *
@ -627,10 +632,10 @@ wasm_call_indirect(WASMExecEnv *exec_env, uint32 tbl_idx, uint32 elem_idx,
#if WASM_ENABLE_THREAD_MGR != 0 #if WASM_ENABLE_THREAD_MGR != 0
bool bool
wasm_set_aux_stack(WASMExecEnv *exec_env, uint32 start_offset, uint32 size); wasm_set_aux_stack(WASMExecEnv *exec_env, uint64 start_offset, uint32 size);
bool bool
wasm_get_aux_stack(WASMExecEnv *exec_env, uint32 *start_offset, uint32 *size); wasm_get_aux_stack(WASMExecEnv *exec_env, uint64 *start_offset, uint32 *size);
#endif #endif
void void
@ -727,7 +732,7 @@ jit_set_exception_with_id(WASMModuleInstance *module_inst, uint32 id);
*/ */
bool bool
jit_check_app_addr_and_convert(WASMModuleInstance *module_inst, bool is_str, jit_check_app_addr_and_convert(WASMModuleInstance *module_inst, bool is_str,
uint32 app_buf_addr, uint32 app_buf_size, uint64 app_buf_addr, uint64 app_buf_size,
void **p_native_addr); void **p_native_addr);
#endif /* end of WASM_ENABLE_FAST_JIT != 0 || WASM_ENABLE_JIT != 0 \ #endif /* end of WASM_ENABLE_FAST_JIT != 0 || WASM_ENABLE_JIT != 0 \
|| WASM_ENABLE_WAMR_COMPILER != 0 */ || WASM_ENABLE_WAMR_COMPILER != 0 */

4
core/iwasm/libraries/debug-engine/debug_engine.c
View File

@ -409,7 +409,7 @@ wasm_debug_instance_create(WASMCluster *cluster, int32 port)
* expressions */ * expressions */
instance->exec_mem_info.size = DEBUG_EXECUTION_MEMORY_SIZE; instance->exec_mem_info.size = DEBUG_EXECUTION_MEMORY_SIZE;
instance->exec_mem_info.start_offset = wasm_runtime_module_malloc( instance->exec_mem_info.start_offset = wasm_runtime_module_malloc(
module_inst, instance->exec_mem_info.size, NULL); module_inst, (uint64)instance->exec_mem_info.size, NULL);
if (instance->exec_mem_info.start_offset == 0) { if (instance->exec_mem_info.start_offset == 0) {
LOG_WARNING( LOG_WARNING(
"WASM Debug Engine warning: failed to allocate linear memory for " "WASM Debug Engine warning: failed to allocate linear memory for "
@ -1393,7 +1393,7 @@ wasm_debug_instance_mmap(WASMDebugInstance *instance, uint32 size,
return 0; return 0;
} }
if ((uint64)instance->exec_mem_info.current_pos if (instance->exec_mem_info.current_pos
- instance->exec_mem_info.start_offset + size - instance->exec_mem_info.start_offset + size
<= (uint64)instance->exec_mem_info.size) { <= (uint64)instance->exec_mem_info.size) {
offset = instance->exec_mem_info.current_pos; offset = instance->exec_mem_info.current_pos;

4
core/iwasm/libraries/debug-engine/debug_engine.h
View File

@ -53,9 +53,9 @@ typedef enum debug_state_t {
} debug_state_t; } debug_state_t;
typedef struct WASMDebugExecutionMemory { typedef struct WASMDebugExecutionMemory {
uint32 start_offset; uint64 start_offset;
uint64 current_pos;
uint32 size; uint32 size;
uint32 current_pos;
} WASMDebugExecutionMemory; } WASMDebugExecutionMemory;
struct WASMDebugInstance { struct WASMDebugInstance {

9
core/iwasm/libraries/lib-pthread/lib_pthread_wrapper.c
View File

@ -558,7 +558,8 @@ pthread_create_wrapper(wasm_exec_env_t exec_env,
ThreadRoutineArgs *routine_args = NULL; ThreadRoutineArgs *routine_args = NULL;
uint32 thread_handle; uint32 thread_handle;
uint32 stack_size = 8192; uint32 stack_size = 8192;
uint32 aux_stack_start = 0, aux_stack_size; uint32 aux_stack_size;
uint64 aux_stack_start = 0;
int32 ret = -1; int32 ret = -1;
bh_assert(module); bh_assert(module);
@ -669,14 +670,14 @@ pthread_join_wrapper(wasm_exec_env_t exec_env, uint32 thread,
/* validate addr, we can use current thread's /* validate addr, we can use current thread's
module instance here as the memory is shared */ module instance here as the memory is shared */
if (!validate_app_addr(retval_offset, sizeof(int32))) { if (!validate_app_addr((uint64)retval_offset, (uint64)sizeof(int32))) {
/* Join failed, but we don't want to terminate all threads, /* Join failed, but we don't want to terminate all threads,
do not spread exception here */ do not spread exception here */
wasm_runtime_set_exception(module_inst, NULL); wasm_runtime_set_exception(module_inst, NULL);
return -1; return -1;
} }
retval = (void **)addr_app_to_native(retval_offset); retval = (void **)addr_app_to_native((uint64)retval_offset);
node = get_thread_info(exec_env, thread); node = get_thread_info(exec_env, thread);
if (!node) { if (!node) {
@ -1263,7 +1264,7 @@ sem_getvalue_wrapper(wasm_exec_env_t exec_env, uint32 sem, int32 *sval)
(void)exec_env; (void)exec_env;
SemCallbackArgs args = { sem, NULL }; SemCallbackArgs args = { sem, NULL };
if (validate_native_addr(sval, sizeof(int32))) { if (validate_native_addr(sval, (uint64)sizeof(int32))) {
bh_hash_map_traverse(sem_info_map, sem_fetch_cb, &args); bh_hash_map_traverse(sem_info_map, sem_fetch_cb, &args);

64
core/iwasm/libraries/libc-builtin/libc_builtin_wrapper.c
View File

@ -233,7 +233,7 @@ _vprintf_wa(out_func_t out, void *ctx, const char *fmt, _va_list ap,
return false; return false;
} }
s = start = addr_app_to_native(s_offset); s = start = addr_app_to_native((uint64)s_offset);
str_len = (uint32)strlen(start); str_len = (uint32)strlen(start);
if (str_len >= UINT32_MAX - 64) { if (str_len >= UINT32_MAX - 64) {
@ -401,7 +401,7 @@ printf_wrapper(wasm_exec_env_t exec_env, const char *format, _va_list va_args)
struct str_context ctx = { NULL, 0, 0 }; struct str_context ctx = { NULL, 0, 0 };
/* format has been checked by runtime */ /* format has been checked by runtime */
if (!validate_native_addr(va_args, sizeof(int32))) if (!validate_native_addr(va_args, (uint64)sizeof(int32)))
return 0; return 0;
if (!_vprintf_wa((out_func_t)printf_out, &ctx, format, va_args, if (!_vprintf_wa((out_func_t)printf_out, &ctx, format, va_args,
@ -420,7 +420,7 @@ sprintf_wrapper(wasm_exec_env_t exec_env, char *str, const char *format,
struct str_context ctx; struct str_context ctx;
/* str and format have been checked by runtime */ /* str and format have been checked by runtime */
if (!validate_native_addr(va_args, sizeof(uint32))) if (!validate_native_addr(va_args, (uint64)sizeof(uint32)))
return 0; return 0;
if (!wasm_runtime_get_native_addr_range(module_inst, (uint8 *)str, NULL, if (!wasm_runtime_get_native_addr_range(module_inst, (uint8 *)str, NULL,
@ -452,7 +452,7 @@ snprintf_wrapper(wasm_exec_env_t exec_env, char *str, uint32 size,
struct str_context ctx; struct str_context ctx;
/* str and format have been checked by runtime */ /* str and format have been checked by runtime */
if (!validate_native_addr(va_args, sizeof(uint32))) if (!validate_native_addr(va_args, (uint64)sizeof(uint32)))
return 0; return 0;
ctx.str = str; ctx.str = str;
@ -499,7 +499,7 @@ strdup_wrapper(wasm_exec_env_t exec_env, const char *str)
if (str) { if (str) {
len = (uint32)strlen(str) + 1; len = (uint32)strlen(str) + 1;
str_ret_offset = module_malloc(len, (void **)&str_ret); str_ret_offset = (uint32)module_malloc((uint64)len, (void **)&str_ret);
if (str_ret_offset) { if (str_ret_offset) {
bh_memcpy_s(str_ret, len, str, len); bh_memcpy_s(str_ret, len, str, len);
} }
@ -521,7 +521,7 @@ memcmp_wrapper(wasm_exec_env_t exec_env, const void *s1, const void *s2,
wasm_module_inst_t module_inst = get_module_inst(exec_env); wasm_module_inst_t module_inst = get_module_inst(exec_env);
/* s2 has been checked by runtime */ /* s2 has been checked by runtime */
if (!validate_native_addr((void *)s1, size)) if (!validate_native_addr((void *)s1, (uint64)size))
return 0; return 0;
return memcmp(s1, s2, size); return memcmp(s1, s2, size);
@ -532,13 +532,13 @@ memcpy_wrapper(wasm_exec_env_t exec_env, void *dst, const void *src,
uint32 size) uint32 size)
{ {
wasm_module_inst_t module_inst = get_module_inst(exec_env); wasm_module_inst_t module_inst = get_module_inst(exec_env);
uint32 dst_offset = addr_native_to_app(dst); uint32 dst_offset = (uint32)addr_native_to_app(dst);
if (size == 0) if (size == 0)
return dst_offset; return dst_offset;
/* src has been checked by runtime */ /* src has been checked by runtime */
if (!validate_native_addr(dst, size)) if (!validate_native_addr(dst, (uint64)size))
return dst_offset; return dst_offset;
bh_memcpy_s(dst, size, src, size); bh_memcpy_s(dst, size, src, size);
@ -549,13 +549,13 @@ static uint32
memmove_wrapper(wasm_exec_env_t exec_env, void *dst, void *src, uint32 size) memmove_wrapper(wasm_exec_env_t exec_env, void *dst, void *src, uint32 size)
{ {
wasm_module_inst_t module_inst = get_module_inst(exec_env); wasm_module_inst_t module_inst = get_module_inst(exec_env);
uint32 dst_offset = addr_native_to_app(dst); uint32 dst_offset = (uint32)addr_native_to_app(dst);
if (size == 0) if (size == 0)
return dst_offset; return dst_offset;
/* src has been checked by runtime */ /* src has been checked by runtime */
if (!validate_native_addr(dst, size)) if (!validate_native_addr(dst, (uint64)size))
return dst_offset; return dst_offset;
memmove(dst, src, size); memmove(dst, src, size);
@ -566,9 +566,9 @@ static uint32
memset_wrapper(wasm_exec_env_t exec_env, void *s, int32 c, uint32 size) memset_wrapper(wasm_exec_env_t exec_env, void *s, int32 c, uint32 size)
{ {
wasm_module_inst_t module_inst = get_module_inst(exec_env); wasm_module_inst_t module_inst = get_module_inst(exec_env);
uint32 s_offset = addr_native_to_app(s); uint32 s_offset = (uint32)addr_native_to_app(s);
if (!validate_native_addr(s, size)) if (!validate_native_addr(s, (uint64)size))
return s_offset; return s_offset;
memset(s, c, size); memset(s, c, size);
@ -583,7 +583,7 @@ strchr_wrapper(wasm_exec_env_t exec_env, const char *s, int32 c)
/* s has been checked by runtime */ /* s has been checked by runtime */
ret = strchr(s, c); ret = strchr(s, c);
return ret ? addr_native_to_app(ret) : 0; return ret ? (uint32)addr_native_to_app(ret) : 0;
} }
static int32 static int32
@ -602,7 +602,7 @@ strncmp_wrapper(wasm_exec_env_t exec_env, const char *s1, const char *s2,
wasm_module_inst_t module_inst = get_module_inst(exec_env); wasm_module_inst_t module_inst = get_module_inst(exec_env);
/* s2 has been checked by runtime */ /* s2 has been checked by runtime */
if (!validate_native_addr((void *)s1, size)) if (!validate_native_addr((void *)s1, (uint64)size))
return 0; return 0;
return strncmp(s1, s2, size); return strncmp(s1, s2, size);
@ -615,7 +615,7 @@ strcpy_wrapper(wasm_exec_env_t exec_env, char *dst, const char *src)
uint32 len = (uint32)strlen(src) + 1; uint32 len = (uint32)strlen(src) + 1;
/* src has been checked by runtime */ /* src has been checked by runtime */
if (!validate_native_addr(dst, len)) if (!validate_native_addr(dst, (uint64)len))
return 0; return 0;
#ifndef BH_PLATFORM_WINDOWS #ifndef BH_PLATFORM_WINDOWS
@ -623,7 +623,7 @@ strcpy_wrapper(wasm_exec_env_t exec_env, char *dst, const char *src)
#else #else
strncpy_s(dst, len, src, len); strncpy_s(dst, len, src, len);
#endif #endif
return addr_native_to_app(dst); return (uint32)addr_native_to_app(dst);
} }
static uint32 static uint32
@ -633,7 +633,7 @@ strncpy_wrapper(wasm_exec_env_t exec_env, char *dst, const char *src,
wasm_module_inst_t module_inst = get_module_inst(exec_env); wasm_module_inst_t module_inst = get_module_inst(exec_env);
/* src has been checked by runtime */ /* src has been checked by runtime */
if (!validate_native_addr(dst, size)) if (!validate_native_addr(dst, (uint64)size))
return 0; return 0;
#ifndef BH_PLATFORM_WINDOWS #ifndef BH_PLATFORM_WINDOWS
@ -641,7 +641,7 @@ strncpy_wrapper(wasm_exec_env_t exec_env, char *dst, const char *src,
#else #else
strncpy_s(dst, size, src, size); strncpy_s(dst, size, src, size);
#endif #endif
return addr_native_to_app(dst); return (uint32)addr_native_to_app(dst);
} }
static uint32 static uint32
@ -657,7 +657,7 @@ static uint32
malloc_wrapper(wasm_exec_env_t exec_env, uint32 size) malloc_wrapper(wasm_exec_env_t exec_env, uint32 size)
{ {
wasm_module_inst_t module_inst = get_module_inst(exec_env); wasm_module_inst_t module_inst = get_module_inst(exec_env);
return module_malloc(size, NULL); return (uint32)module_malloc((uint64)size, NULL);
} }
static uint32 static uint32
@ -671,7 +671,7 @@ calloc_wrapper(wasm_exec_env_t exec_env, uint32 nmemb, uint32 size)
if (total_size >= UINT32_MAX) if (total_size >= UINT32_MAX)
return 0; return 0;
ret_offset = module_malloc((uint32)total_size, (void **)&ret_ptr); ret_offset = (uint32)module_malloc(total_size, (void **)&ret_ptr);
if (ret_offset) { if (ret_offset) {
memset(ret_ptr, 0, (uint32)total_size); memset(ret_ptr, 0, (uint32)total_size);
} }
@ -692,7 +692,7 @@ free_wrapper(wasm_exec_env_t exec_env, void *ptr)
{ {
wasm_module_inst_t module_inst = get_module_inst(exec_env); wasm_module_inst_t module_inst = get_module_inst(exec_env);
if (!validate_native_addr(ptr, sizeof(uint32))) if (!validate_native_addr(ptr, (uint64)sizeof(uint32)))
return; return;
module_free(addr_native_to_app(ptr)); module_free(addr_native_to_app(ptr));
@ -723,11 +723,11 @@ strtol_wrapper(wasm_exec_env_t exec_env, const char *nptr, char **endptr,
int32 num = 0; int32 num = 0;
/* nptr has been checked by runtime */ /* nptr has been checked by runtime */
if (!validate_native_addr(endptr, sizeof(uint32))) if (!validate_native_addr(endptr, (uint64)sizeof(uint32)))
return 0; return 0;
num = (int32)strtol(nptr, endptr, base); num = (int32)strtol(nptr, endptr, base);
*(uint32 *)endptr = addr_native_to_app(*endptr); *(uint32 *)endptr = (uint32)addr_native_to_app(*endptr);
return num; return num;
} }
@ -740,11 +740,11 @@ strtoul_wrapper(wasm_exec_env_t exec_env, const char *nptr, char **endptr,
uint32 num = 0; uint32 num = 0;
/* nptr has been checked by runtime */ /* nptr has been checked by runtime */
if (!validate_native_addr(endptr, sizeof(uint32))) if (!validate_native_addr(endptr, (uint64)sizeof(uint32)))
return 0; return 0;
num = (uint32)strtoul(nptr, endptr, base); num = (uint32)strtoul(nptr, endptr, base);
*(uint32 *)endptr = addr_native_to_app(*endptr); *(uint32 *)endptr = (uint32)addr_native_to_app(*endptr);
return num; return num;
} }
@ -755,11 +755,11 @@ memchr_wrapper(wasm_exec_env_t exec_env, const void *s, int32 c, uint32 n)
wasm_module_inst_t module_inst = get_module_inst(exec_env); wasm_module_inst_t module_inst = get_module_inst(exec_env);
void *res; void *res;
if (!validate_native_addr((void *)s, n)) if (!validate_native_addr((void *)s, (uint64)n))
return 0; return 0;
res = memchr(s, c, n); res = memchr(s, c, n);
return addr_native_to_app(res); return (uint32)addr_native_to_app(res);
} }
static int32 static int32
@ -796,7 +796,7 @@ strstr_wrapper(wasm_exec_env_t exec_env, const char *s, const char *find)
wasm_module_inst_t module_inst = get_module_inst(exec_env); wasm_module_inst_t module_inst = get_module_inst(exec_env);
/* s and find have been checked by runtime */ /* s and find have been checked by runtime */
char *res = strstr(s, find); char *res = strstr(s, find);
return addr_native_to_app(res); return (uint32)addr_native_to_app(res);
} }
static int32 static int32
@ -884,10 +884,10 @@ emscripten_memcpy_big_wrapper(wasm_exec_env_t exec_env, void *dst,
const void *src, uint32 size) const void *src, uint32 size)
{ {
wasm_module_inst_t module_inst = get_module_inst(exec_env); wasm_module_inst_t module_inst = get_module_inst(exec_env);
uint32 dst_offset = addr_native_to_app(dst); uint32 dst_offset = (uint32)addr_native_to_app(dst);
/* src has been checked by runtime */ /* src has been checked by runtime */
if (!validate_native_addr(dst, size)) if (!validate_native_addr(dst, (uint64)size))
return dst_offset; return dst_offset;
bh_memcpy_s(dst, size, src, size); bh_memcpy_s(dst, size, src, size);
@ -925,7 +925,7 @@ static uint32
__cxa_allocate_exception_wrapper(wasm_exec_env_t exec_env, uint32 thrown_size) __cxa_allocate_exception_wrapper(wasm_exec_env_t exec_env, uint32 thrown_size)
{ {
wasm_module_inst_t module_inst = get_module_inst(exec_env); wasm_module_inst_t module_inst = get_module_inst(exec_env);
uint32 exception = module_malloc(thrown_size, NULL); uint32 exception = (uint32)module_malloc((uint64)thrown_size, NULL);
if (!exception) if (!exception)
return 0; return 0;
@ -968,7 +968,7 @@ clock_gettime_wrapper(wasm_exec_env_t exec_env, uint32 clk_id,
(void)clk_id; (void)clk_id;
if (!validate_native_addr(ts_app, sizeof(struct timespec_app))) if (!validate_native_addr(ts_app, (uint64)sizeof(struct timespec_app)))
return (uint32)-1; return (uint32)-1;
time = os_time_get_boot_us(); time = os_time_get_boot_us();

14
core/iwasm/libraries/libc-emcc/libc_emcc_wrapper.c
View File

@ -184,7 +184,8 @@ __sys_stat64_wrapper(wasm_exec_env_t exec_env, const char *pathname,
int ret; int ret;
struct stat statbuf; struct stat statbuf;
if (!validate_native_addr((void *)statbuf_app, sizeof(struct stat_emcc))) if (!validate_native_addr((void *)statbuf_app,
(uint64)sizeof(struct stat_emcc)))
return -1; return -1;
if (pathname == NULL) if (pathname == NULL)
@ -204,7 +205,8 @@ __sys_fstat64_wrapper(wasm_exec_env_t exec_env, int fd,
int ret; int ret;
struct stat statbuf; struct stat statbuf;
if (!validate_native_addr((void *)statbuf_app, sizeof(struct stat_emcc))) if (!validate_native_addr((void *)statbuf_app,
(uint64)sizeof(struct stat_emcc)))
return -1; return -1;
if (fd <= 0) if (fd <= 0)
@ -225,7 +227,7 @@ mmap_wrapper(wasm_exec_env_t exec_env, void *addr, int length, int prot,
char *buf; char *buf;
int size_read; int size_read;
buf_offset = module_malloc(length, (void **)&buf); buf_offset = module_malloc((uint64)length, (void **)&buf);
if (buf_offset == 0) if (buf_offset == 0)
return -1; return -1;
@ -244,7 +246,7 @@ static int
munmap_wrapper(wasm_exec_env_t exec_env, uint32 buf_offset, int length) munmap_wrapper(wasm_exec_env_t exec_env, uint32 buf_offset, int length)
{ {
wasm_module_inst_t module_inst = get_module_inst(exec_env); wasm_module_inst_t module_inst = get_module_inst(exec_env);
module_free(buf_offset); module_free((uint64)buf_offset);
return 0; return 0;
} }
@ -422,7 +424,7 @@ __sys_getcwd_wrapper(wasm_exec_env_t exec_env, char *buf, uint32 size)
return -1; return -1;
ret = getcwd(buf, size); ret = getcwd(buf, size);
return ret ? addr_native_to_app(ret) : 0; return ret ? (uint32)addr_native_to_app(ret) : 0;
} }
#include <sys/utsname.h> #include <sys/utsname.h>
@ -443,7 +445,7 @@ __sys_uname_wrapper(wasm_exec_env_t exec_env, struct utsname_app *uname_app)
struct utsname uname_native = { 0 }; struct utsname uname_native = { 0 };
uint32 length; uint32 length;
if (!validate_native_addr(uname_app, sizeof(struct utsname_app))) if (!validate_native_addr(uname_app, (uint64)sizeof(struct utsname_app)))
return -1; return -1;
if (uname(&uname_native) != 0) { if (uname(&uname_native) != 0) {

98
core/iwasm/libraries/libc-uvwasi/libc_uvwasi_wrapper.c
View File

@ -115,9 +115,9 @@ wasi_args_get(wasm_exec_env_t exec_env, uint32 *argv_offsets, char *argv_buf)
total_size = sizeof(int32) * ((uint64)argc + 1); total_size = sizeof(int32) * ((uint64)argc + 1);
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !validate_native_addr(argv_offsets, (uint32)total_size) || !validate_native_addr(argv_offsets, total_size)
|| argv_buf_size >= UINT32_MAX || argv_buf_size >= UINT32_MAX
|| !validate_native_addr(argv_buf, (uint32)argv_buf_size)) || !validate_native_addr(argv_buf, (uint64)argv_buf_size))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
total_size = sizeof(char *) * ((uint64)argc + 1); total_size = sizeof(char *) * ((uint64)argc + 1);
@ -132,7 +132,7 @@ wasi_args_get(wasm_exec_env_t exec_env, uint32 *argv_offsets, char *argv_buf)
} }
for (i = 0; i < argc; i++) for (i = 0; i < argc; i++)
argv_offsets[i] = addr_native_to_app(argv[i]); argv_offsets[i] = (uint32)addr_native_to_app(argv[i]);
wasm_runtime_free(argv); wasm_runtime_free(argv);
return 0; return 0;
@ -150,8 +150,8 @@ wasi_args_sizes_get(wasm_exec_env_t exec_env, uint32 *argc_app,
if (!uvwasi) if (!uvwasi)
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
if (!validate_native_addr(argc_app, sizeof(uint32)) if (!validate_native_addr(argc_app, (uint64)sizeof(uint32))
|| !validate_native_addr(argv_buf_size_app, sizeof(uint32))) || !validate_native_addr(argv_buf_size_app, (uint64)sizeof(uint32)))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
err = uvwasi_args_sizes_get(uvwasi, &argc, &argv_buf_size); err = uvwasi_args_sizes_get(uvwasi, &argc, &argv_buf_size);
@ -170,7 +170,7 @@ wasi_clock_res_get(wasm_exec_env_t exec_env, wasi_clockid_t clock_id,
wasm_module_inst_t module_inst = get_module_inst(exec_env); wasm_module_inst_t module_inst = get_module_inst(exec_env);
uvwasi_t *uvwasi = get_wasi_ctx(module_inst); uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
if (!validate_native_addr(resolution, sizeof(wasi_timestamp_t))) if (!validate_native_addr(resolution, (uint64)sizeof(wasi_timestamp_t)))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
return uvwasi_clock_res_get(uvwasi, clock_id, resolution); return uvwasi_clock_res_get(uvwasi, clock_id, resolution);
@ -183,7 +183,7 @@ wasi_clock_time_get(wasm_exec_env_t exec_env, wasi_clockid_t clock_id,
wasm_module_inst_t module_inst = get_module_inst(exec_env); wasm_module_inst_t module_inst = get_module_inst(exec_env);
uvwasi_t *uvwasi = get_wasi_ctx(module_inst); uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
if (!validate_native_addr(time, sizeof(wasi_timestamp_t))) if (!validate_native_addr(time, (uint64)sizeof(wasi_timestamp_t)))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
return uvwasi_clock_time_get(uvwasi, clock_id, precision, time); return uvwasi_clock_time_get(uvwasi, clock_id, precision, time);
@ -212,9 +212,9 @@ wasi_environ_get(wasm_exec_env_t exec_env, uint32 *environ_offsets,
total_size = sizeof(int32) * ((uint64)environ_count + 1); total_size = sizeof(int32) * ((uint64)environ_count + 1);
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !validate_native_addr(environ_offsets, (uint32)total_size) || !validate_native_addr(environ_offsets, total_size)
|| environ_buf_size >= UINT32_MAX || environ_buf_size >= UINT32_MAX
|| !validate_native_addr(environ_buf, (uint32)environ_buf_size)) || !validate_native_addr(environ_buf, (uint64)environ_buf_size))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
total_size = sizeof(char *) * (((uint64)environ_count + 1)); total_size = sizeof(char *) * (((uint64)environ_count + 1));
@ -230,7 +230,7 @@ wasi_environ_get(wasm_exec_env_t exec_env, uint32 *environ_offsets,
} }
for (i = 0; i < environ_count; i++) for (i = 0; i < environ_count; i++)
environ_offsets[i] = addr_native_to_app(environs[i]); environ_offsets[i] = (uint32)addr_native_to_app(environs[i]);
wasm_runtime_free(environs); wasm_runtime_free(environs);
return 0; return 0;
@ -248,8 +248,8 @@ wasi_environ_sizes_get(wasm_exec_env_t exec_env, uint32 *environ_count_app,
if (!uvwasi) if (!uvwasi)
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
if (!validate_native_addr(environ_count_app, sizeof(uint32)) if (!validate_native_addr(environ_count_app, (uint64)sizeof(uint32))
|| !validate_native_addr(environ_buf_size_app, sizeof(uint32))) || !validate_native_addr(environ_buf_size_app, (uint64)sizeof(uint32)))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
err = uvwasi_environ_sizes_get(uvwasi, &environ_count, &environ_buf_size); err = uvwasi_environ_sizes_get(uvwasi, &environ_count, &environ_buf_size);
@ -273,7 +273,7 @@ wasi_fd_prestat_get(wasm_exec_env_t exec_env, wasi_fd_t fd,
if (!uvwasi) if (!uvwasi)
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
if (!validate_native_addr(prestat_app, sizeof(wasi_prestat_app_t))) if (!validate_native_addr(prestat_app, (uint64)sizeof(wasi_prestat_app_t)))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
err = uvwasi_fd_prestat_get(uvwasi, fd, &prestat); err = uvwasi_fd_prestat_get(uvwasi, fd, &prestat);
@ -338,9 +338,9 @@ wasi_fd_pread(wasm_exec_env_t exec_env, wasi_fd_t fd, iovec_app_t *iovec_app,
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
total_size = sizeof(iovec_app_t) * (uint64)iovs_len; total_size = sizeof(iovec_app_t) * (uint64)iovs_len;
if (!validate_native_addr(nread_app, (uint32)sizeof(uint32)) if (!validate_native_addr(nread_app, (uint64)sizeof(uint32))
|| total_size >= UINT32_MAX || total_size >= UINT32_MAX
|| !validate_native_addr(iovec_app, (uint32)total_size)) || !validate_native_addr(iovec_app, total_size))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
total_size = sizeof(wasi_iovec_t) * (uint64)iovs_len; total_size = sizeof(wasi_iovec_t) * (uint64)iovs_len;
@ -350,11 +350,12 @@ wasi_fd_pread(wasm_exec_env_t exec_env, wasi_fd_t fd, iovec_app_t *iovec_app,
iovec = iovec_begin; iovec = iovec_begin;
for (i = 0; i < iovs_len; i++, iovec_app++, iovec++) { for (i = 0; i < iovs_len; i++, iovec_app++, iovec++) {
if (!validate_app_addr(iovec_app->buf_offset, iovec_app->buf_len)) { if (!validate_app_addr((uint64)iovec_app->buf_offset,
(uint64)iovec_app->buf_len)) {
err = (wasi_errno_t)-1; err = (wasi_errno_t)-1;
goto fail; goto fail;
} }
iovec->buf = (void *)addr_app_to_native(iovec_app->buf_offset); iovec->buf = (void *)addr_app_to_native((uint64)iovec_app->buf_offset);
iovec->buf_len = iovec_app->buf_len; iovec->buf_len = iovec_app->buf_len;
} }
@ -389,9 +390,9 @@ wasi_fd_pwrite(wasm_exec_env_t exec_env, wasi_fd_t fd,
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
total_size = sizeof(iovec_app_t) * (uint64)iovs_len; total_size = sizeof(iovec_app_t) * (uint64)iovs_len;
if (!validate_native_addr(nwritten_app, (uint32)sizeof(uint32)) if (!validate_native_addr(nwritten_app, (uint64)sizeof(uint32))
|| total_size >= UINT32_MAX || total_size >= UINT32_MAX
|| !validate_native_addr((void *)iovec_app, (uint32)total_size)) || !validate_native_addr((void *)iovec_app, total_size))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
total_size = sizeof(wasi_ciovec_t) * (uint64)iovs_len; total_size = sizeof(wasi_ciovec_t) * (uint64)iovs_len;
@ -401,11 +402,12 @@ wasi_fd_pwrite(wasm_exec_env_t exec_env, wasi_fd_t fd,
ciovec = ciovec_begin; ciovec = ciovec_begin;
for (i = 0; i < iovs_len; i++, iovec_app++, ciovec++) { for (i = 0; i < iovs_len; i++, iovec_app++, ciovec++) {
if (!validate_app_addr(iovec_app->buf_offset, iovec_app->buf_len)) { if (!validate_app_addr((uint64)iovec_app->buf_offset,
(uint64)iovec_app->buf_len)) {
err = (wasi_errno_t)-1; err = (wasi_errno_t)-1;
goto fail; goto fail;
} }
ciovec->buf = (char *)addr_app_to_native(iovec_app->buf_offset); ciovec->buf = (char *)addr_app_to_native((uint64)iovec_app->buf_offset);
ciovec->buf_len = iovec_app->buf_len; ciovec->buf_len = iovec_app->buf_len;
} }
@ -440,9 +442,9 @@ wasi_fd_read(wasm_exec_env_t exec_env, wasi_fd_t fd,
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
total_size = sizeof(iovec_app_t) * (uint64)iovs_len; total_size = sizeof(iovec_app_t) * (uint64)iovs_len;
if (!validate_native_addr(nread_app, (uint32)sizeof(uint32)) if (!validate_native_addr(nread_app, (uint64)sizeof(uint32))
|| total_size >= UINT32_MAX || total_size >= UINT32_MAX
|| !validate_native_addr((void *)iovec_app, (uint32)total_size)) || !validate_native_addr((void *)iovec_app, total_size))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
total_size = sizeof(wasi_iovec_t) * (uint64)iovs_len; total_size = sizeof(wasi_iovec_t) * (uint64)iovs_len;
@ -452,11 +454,12 @@ wasi_fd_read(wasm_exec_env_t exec_env, wasi_fd_t fd,
iovec = iovec_begin; iovec = iovec_begin;
for (i = 0; i < iovs_len; i++, iovec_app++, iovec++) { for (i = 0; i < iovs_len; i++, iovec_app++, iovec++) {
if (!validate_app_addr(iovec_app->buf_offset, iovec_app->buf_len)) { if (!validate_app_addr((uint64)iovec_app->buf_offset,
(uint64)iovec_app->buf_len)) {
err = (wasi_errno_t)-1; err = (wasi_errno_t)-1;
goto fail; goto fail;
} }
iovec->buf = (void *)addr_app_to_native(iovec_app->buf_offset); iovec->buf = (void *)addr_app_to_native((uint64)iovec_app->buf_offset);
iovec->buf_len = iovec_app->buf_len; iovec->buf_len = iovec_app->buf_len;
} }
@ -496,7 +499,7 @@ wasi_fd_seek(wasm_exec_env_t exec_env, wasi_fd_t fd, wasi_filedelta_t offset,
if (!uvwasi) if (!uvwasi)
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
if (!validate_native_addr(newoffset, sizeof(wasi_filesize_t))) if (!validate_native_addr(newoffset, (uint64)sizeof(wasi_filesize_t)))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
return uvwasi_fd_seek(uvwasi, fd, offset, whence, newoffset); return uvwasi_fd_seek(uvwasi, fd, offset, whence, newoffset);
@ -511,7 +514,7 @@ wasi_fd_tell(wasm_exec_env_t exec_env, wasi_fd_t fd, wasi_filesize_t *newoffset)
if (!uvwasi) if (!uvwasi)
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
if (!validate_native_addr(newoffset, sizeof(wasi_filesize_t))) if (!validate_native_addr(newoffset, (uint64)sizeof(wasi_filesize_t)))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
return uvwasi_fd_tell(uvwasi, fd, newoffset); return uvwasi_fd_tell(uvwasi, fd, newoffset);
@ -529,7 +532,7 @@ wasi_fd_fdstat_get(wasm_exec_env_t exec_env, wasi_fd_t fd,
if (!uvwasi) if (!uvwasi)
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
if (!validate_native_addr(fdstat_app, sizeof(wasi_fdstat_t))) if (!validate_native_addr(fdstat_app, (uint64)sizeof(wasi_fdstat_t)))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
err = uvwasi_fd_fdstat_get(uvwasi, fd, &fdstat); err = uvwasi_fd_fdstat_get(uvwasi, fd, &fdstat);
@ -597,9 +600,9 @@ wasi_fd_write(wasm_exec_env_t exec_env, wasi_fd_t fd,
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
total_size = sizeof(iovec_app_t) * (uint64)iovs_len; total_size = sizeof(iovec_app_t) * (uint64)iovs_len;
if (!validate_native_addr(nwritten_app, (uint32)sizeof(uint32)) if (!validate_native_addr(nwritten_app, (uint64)sizeof(uint32))
|| total_size >= UINT32_MAX || total_size >= UINT32_MAX
|| !validate_native_addr((void *)iovec_app, (uint32)total_size)) || !validate_native_addr((void *)iovec_app, total_size))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
total_size = sizeof(wasi_ciovec_t) * (uint64)iovs_len; total_size = sizeof(wasi_ciovec_t) * (uint64)iovs_len;
@ -609,11 +612,12 @@ wasi_fd_write(wasm_exec_env_t exec_env, wasi_fd_t fd,
ciovec = ciovec_begin; ciovec = ciovec_begin;
for (i = 0; i < iovs_len; i++, iovec_app++, ciovec++) { for (i = 0; i < iovs_len; i++, iovec_app++, ciovec++) {
if (!validate_app_addr(iovec_app->buf_offset, iovec_app->buf_len)) { if (!validate_app_addr((uint64)iovec_app->buf_offset,
(uint64)iovec_app->buf_len)) {
err = (wasi_errno_t)-1; err = (wasi_errno_t)-1;
goto fail; goto fail;
} }
ciovec->buf = (char *)addr_app_to_native(iovec_app->buf_offset); ciovec->buf = (char *)addr_app_to_native((uint64)iovec_app->buf_offset);
ciovec->buf_len = iovec_app->buf_len; ciovec->buf_len = iovec_app->buf_len;
} }
@ -725,7 +729,7 @@ wasi_path_open(wasm_exec_env_t exec_env, wasi_fd_t dirfd,
if (!uvwasi) if (!uvwasi)
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
if (!validate_native_addr(fd_app, sizeof(wasi_fd_t))) if (!validate_native_addr(fd_app, (uint64)sizeof(wasi_fd_t)))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
err = uvwasi_path_open(uvwasi, dirfd, dirflags, path, path_len, oflags, err = uvwasi_path_open(uvwasi, dirfd, dirflags, path, path_len, oflags,
@ -747,7 +751,7 @@ wasi_fd_readdir(wasm_exec_env_t exec_env, wasi_fd_t fd, void *buf,
if (!uvwasi) if (!uvwasi)
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
if (!validate_native_addr(bufused_app, sizeof(uint32))) if (!validate_native_addr(bufused_app, (uint64)sizeof(uint32)))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
err = uvwasi_fd_readdir(uvwasi, fd, buf, buf_len, cookie, &bufused); err = uvwasi_fd_readdir(uvwasi, fd, buf, buf_len, cookie, &bufused);
@ -771,7 +775,7 @@ wasi_path_readlink(wasm_exec_env_t exec_env, wasi_fd_t fd, const char *path,
if (!uvwasi) if (!uvwasi)
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
if (!validate_native_addr(bufused_app, sizeof(uint32))) if (!validate_native_addr(bufused_app, (uint64)sizeof(uint32)))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
err = uvwasi_path_readlink(uvwasi, fd, path, path_len, buf, buf_len, err = uvwasi_path_readlink(uvwasi, fd, path, path_len, buf, buf_len,
@ -808,7 +812,7 @@ wasi_fd_filestat_get(wasm_exec_env_t exec_env, wasi_fd_t fd,
if (!uvwasi) if (!uvwasi)
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
if (!validate_native_addr(filestat, sizeof(wasi_filestat_t))) if (!validate_native_addr(filestat, (uint64)sizeof(wasi_filestat_t)))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
return uvwasi_fd_filestat_get(uvwasi, fd, filestat); return uvwasi_fd_filestat_get(uvwasi, fd, filestat);
@ -852,7 +856,7 @@ wasi_path_filestat_get(wasm_exec_env_t exec_env, wasi_fd_t fd,
if (!uvwasi) if (!uvwasi)
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
if (!validate_native_addr(filestat, sizeof(wasi_filestat_t))) if (!validate_native_addr(filestat, (uint64)sizeof(wasi_filestat_t)))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
return uvwasi_path_filestat_get(uvwasi, fd, flags, path, path_len, return uvwasi_path_filestat_get(uvwasi, fd, flags, path, path_len,
@ -928,9 +932,9 @@ wasi_poll_oneoff(wasm_exec_env_t exec_env, const wasi_subscription_t *in,
if (!uvwasi) if (!uvwasi)
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
if (!validate_native_addr((void *)in, sizeof(wasi_subscription_t)) if (!validate_native_addr((void *)in, (uint64)sizeof(wasi_subscription_t))
|| !validate_native_addr(out, sizeof(wasi_event_t)) || !validate_native_addr(out, (uint64)sizeof(wasi_event_t))
|| !validate_native_addr(nevents_app, sizeof(uint32))) || !validate_native_addr(nevents_app, (uint64)sizeof(uint32)))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
err = uvwasi_poll_oneoff(uvwasi, in, out, nsubscriptions, &nevents); err = uvwasi_poll_oneoff(uvwasi, in, out, nsubscriptions, &nevents);
@ -1002,11 +1006,12 @@ wasi_sock_recv(wasm_exec_env_t exec_env, wasi_fd_t sock, iovec_app_t *ri_data,
iovec = iovec_begin; iovec = iovec_begin;
for (i = 0; i < ri_data_len; i++, ri_data++, iovec++) { for (i = 0; i < ri_data_len; i++, ri_data++, iovec++) {
if (!validate_app_addr(ri_data->buf_offset, ri_data->buf_len)) { if (!validate_app_addr((uint64)ri_data->buf_offset,
(uint64)ri_data->buf_len)) {
err = (wasi_errno_t)-1; err = (wasi_errno_t)-1;
goto fail; goto fail;
} }
iovec->buf = (void *)addr_app_to_native(ri_data->buf_offset); iovec->buf = (void *)addr_app_to_native((uint64)ri_data->buf_offset);
iovec->buf_len = ri_data->buf_len; iovec->buf_len = ri_data->buf_len;
} }
@ -1042,9 +1047,9 @@ wasi_sock_send(wasm_exec_env_t exec_env, wasi_fd_t sock,
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
total_size = sizeof(iovec_app_t) * (uint64)si_data_len; total_size = sizeof(iovec_app_t) * (uint64)si_data_len;
if (!validate_native_addr(so_datalen_app, sizeof(uint32)) if (!validate_native_addr(so_datalen_app, (uint64)sizeof(uint32))
|| total_size >= UINT32_MAX || total_size >= UINT32_MAX
|| !validate_native_addr((void *)si_data, (uint32)total_size)) || !validate_native_addr((void *)si_data, total_size))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
total_size = sizeof(wasi_ciovec_t) * (uint64)si_data_len; total_size = sizeof(wasi_ciovec_t) * (uint64)si_data_len;
@ -1054,11 +1059,12 @@ wasi_sock_send(wasm_exec_env_t exec_env, wasi_fd_t sock,
ciovec = ciovec_begin; ciovec = ciovec_begin;
for (i = 0; i < si_data_len; i++, si_data++, ciovec++) { for (i = 0; i < si_data_len; i++, si_data++, ciovec++) {
if (!validate_app_addr(si_data->buf_offset, si_data->buf_len)) { if (!validate_app_addr((uint64)si_data->buf_offset,
(uint64)si_data->buf_len)) {
err = (wasi_errno_t)-1; err = (wasi_errno_t)-1;
goto fail; goto fail;
} }
ciovec->buf = (char *)addr_app_to_native(si_data->buf_offset); ciovec->buf = (char *)addr_app_to_native((uint64)si_data->buf_offset);
ciovec->buf_len = si_data->buf_len; ciovec->buf_len = si_data->buf_len;
} }

150
core/iwasm/libraries/libc-wasi/libc_wasi_wrapper.c
View File

@ -132,9 +132,9 @@ wasi_args_get(wasm_exec_env_t exec_env, uint32 *argv_offsets, char *argv_buf)
total_size = sizeof(int32) * ((uint64)argc + 1); total_size = sizeof(int32) * ((uint64)argc + 1);
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !validate_native_addr(argv_offsets, (uint32)total_size) || !validate_native_addr(argv_offsets, total_size)
|| argv_buf_size >= UINT32_MAX || argv_buf_size >= UINT32_MAX
|| !validate_native_addr(argv_buf, (uint32)argv_buf_size)) || !validate_native_addr(argv_buf, (uint64)argv_buf_size))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
total_size = sizeof(char *) * ((uint64)argc + 1); total_size = sizeof(char *) * ((uint64)argc + 1);
@ -149,7 +149,7 @@ wasi_args_get(wasm_exec_env_t exec_env, uint32 *argv_offsets, char *argv_buf)
} }
for (i = 0; i < argc; i++) for (i = 0; i < argc; i++)
argv_offsets[i] = addr_native_to_app(argv[i]); argv_offsets[i] = (uint32)addr_native_to_app(argv[i]);
wasm_runtime_free(argv); wasm_runtime_free(argv);
return 0; return 0;
@ -168,8 +168,8 @@ wasi_args_sizes_get(wasm_exec_env_t exec_env, uint32 *argc_app,
if (!wasi_ctx) if (!wasi_ctx)
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
if (!validate_native_addr(argc_app, sizeof(uint32)) if (!validate_native_addr(argc_app, (uint64)sizeof(uint32))
|| !validate_native_addr(argv_buf_size_app, sizeof(uint32))) || !validate_native_addr(argv_buf_size_app, (uint64)sizeof(uint32)))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
argv_environ = wasi_ctx->argv_environ; argv_environ = wasi_ctx->argv_environ;
@ -190,7 +190,7 @@ wasi_clock_res_get(wasm_exec_env_t exec_env,
{ {
wasm_module_inst_t module_inst = get_module_inst(exec_env); wasm_module_inst_t module_inst = get_module_inst(exec_env);
if (!validate_native_addr(resolution, sizeof(wasi_timestamp_t))) if (!validate_native_addr(resolution, (uint64)sizeof(wasi_timestamp_t)))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
return os_clock_res_get(clock_id, resolution); return os_clock_res_get(clock_id, resolution);
@ -204,7 +204,7 @@ wasi_clock_time_get(wasm_exec_env_t exec_env,
{ {
wasm_module_inst_t module_inst = get_module_inst(exec_env); wasm_module_inst_t module_inst = get_module_inst(exec_env);
if (!validate_native_addr(time, sizeof(wasi_timestamp_t))) if (!validate_native_addr(time, (uint64)sizeof(wasi_timestamp_t)))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
return os_clock_time_get(clock_id, precision, time); return os_clock_time_get(clock_id, precision, time);
@ -233,9 +233,9 @@ wasi_environ_get(wasm_exec_env_t exec_env, uint32 *environ_offsets,
total_size = sizeof(int32) * ((uint64)environ_count + 1); total_size = sizeof(int32) * ((uint64)environ_count + 1);
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !validate_native_addr(environ_offsets, (uint32)total_size) || !validate_native_addr(environ_offsets, total_size)
|| environ_buf_size >= UINT32_MAX || environ_buf_size >= UINT32_MAX
|| !validate_native_addr(environ_buf, (uint32)environ_buf_size)) || !validate_native_addr(environ_buf, (uint64)environ_buf_size))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
total_size = sizeof(char *) * (((uint64)environ_count + 1)); total_size = sizeof(char *) * (((uint64)environ_count + 1));
@ -251,7 +251,7 @@ wasi_environ_get(wasm_exec_env_t exec_env, uint32 *environ_offsets,
} }
for (i = 0; i < environ_count; i++) for (i = 0; i < environ_count; i++)
environ_offsets[i] = addr_native_to_app(environs[i]); environ_offsets[i] = (uint32)addr_native_to_app(environs[i]);
wasm_runtime_free(environs); wasm_runtime_free(environs);
return 0; return 0;
@ -271,8 +271,8 @@ wasi_environ_sizes_get(wasm_exec_env_t exec_env, uint32 *environ_count_app,
if (!wasi_ctx) if (!wasi_ctx)
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
if (!validate_native_addr(environ_count_app, sizeof(uint32)) if (!validate_native_addr(environ_count_app, (uint64)sizeof(uint32))
|| !validate_native_addr(environ_buf_size_app, sizeof(uint32))) || !validate_native_addr(environ_buf_size_app, (uint64)sizeof(uint32)))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
err = wasmtime_ssp_environ_sizes_get(argv_environ, &environ_count, err = wasmtime_ssp_environ_sizes_get(argv_environ, &environ_count,
@ -299,7 +299,7 @@ wasi_fd_prestat_get(wasm_exec_env_t exec_env, wasi_fd_t fd,
if (!wasi_ctx) if (!wasi_ctx)
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
if (!validate_native_addr(prestat_app, sizeof(wasi_prestat_app_t))) if (!validate_native_addr(prestat_app, (uint64)sizeof(wasi_prestat_app_t)))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
err = wasmtime_ssp_fd_prestat_get(prestats, fd, &prestat); err = wasmtime_ssp_fd_prestat_get(prestats, fd, &prestat);
@ -369,9 +369,9 @@ wasi_fd_pread(wasm_exec_env_t exec_env, wasi_fd_t fd, iovec_app_t *iovec_app,
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
total_size = sizeof(iovec_app_t) * (uint64)iovs_len; total_size = sizeof(iovec_app_t) * (uint64)iovs_len;
if (!validate_native_addr(nread_app, (uint32)sizeof(uint32)) if (!validate_native_addr(nread_app, (uint64)sizeof(uint32))
|| total_size >= UINT32_MAX || total_size >= UINT32_MAX
|| !validate_native_addr(iovec_app, (uint32)total_size)) || !validate_native_addr(iovec_app, total_size))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
total_size = sizeof(wasi_iovec_t) * (uint64)iovs_len; total_size = sizeof(wasi_iovec_t) * (uint64)iovs_len;
@ -382,11 +382,12 @@ wasi_fd_pread(wasm_exec_env_t exec_env, wasi_fd_t fd, iovec_app_t *iovec_app,
iovec = iovec_begin; iovec = iovec_begin;
for (i = 0; i < iovs_len; i++, iovec_app++, iovec++) { for (i = 0; i < iovs_len; i++, iovec_app++, iovec++) {
if (!validate_app_addr(iovec_app->buf_offset, iovec_app->buf_len)) { if (!validate_app_addr((uint64)iovec_app->buf_offset,
(uint64)iovec_app->buf_len)) {
err = (wasi_errno_t)-1; err = (wasi_errno_t)-1;
goto fail; goto fail;
} }
iovec->buf = (void *)addr_app_to_native(iovec_app->buf_offset); iovec->buf = (void *)addr_app_to_native((uint64)iovec_app->buf_offset);
iovec->buf_len = iovec_app->buf_len; iovec->buf_len = iovec_app->buf_len;
} }
@ -423,9 +424,9 @@ wasi_fd_pwrite(wasm_exec_env_t exec_env, wasi_fd_t fd,
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
total_size = sizeof(iovec_app_t) * (uint64)iovs_len; total_size = sizeof(iovec_app_t) * (uint64)iovs_len;
if (!validate_native_addr(nwritten_app, (uint32)sizeof(uint32)) if (!validate_native_addr(nwritten_app, (uint64)sizeof(uint32))
|| total_size >= UINT32_MAX || total_size >= UINT32_MAX
|| !validate_native_addr((void *)iovec_app, (uint32)total_size)) || !validate_native_addr((void *)iovec_app, total_size))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
total_size = sizeof(wasi_ciovec_t) * (uint64)iovs_len; total_size = sizeof(wasi_ciovec_t) * (uint64)iovs_len;
@ -436,11 +437,12 @@ wasi_fd_pwrite(wasm_exec_env_t exec_env, wasi_fd_t fd,
ciovec = ciovec_begin; ciovec = ciovec_begin;
for (i = 0; i < iovs_len; i++, iovec_app++, ciovec++) { for (i = 0; i < iovs_len; i++, iovec_app++, ciovec++) {
if (!validate_app_addr(iovec_app->buf_offset, iovec_app->buf_len)) { if (!validate_app_addr((uint64)iovec_app->buf_offset,
(uint64)iovec_app->buf_len)) {
err = (wasi_errno_t)-1; err = (wasi_errno_t)-1;
goto fail; goto fail;
} }
ciovec->buf = (char *)addr_app_to_native(iovec_app->buf_offset); ciovec->buf = (char *)addr_app_to_native((uint64)iovec_app->buf_offset);
ciovec->buf_len = iovec_app->buf_len; ciovec->buf_len = iovec_app->buf_len;
} }
@ -476,9 +478,9 @@ wasi_fd_read(wasm_exec_env_t exec_env, wasi_fd_t fd,
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
total_size = sizeof(iovec_app_t) * (uint64)iovs_len; total_size = sizeof(iovec_app_t) * (uint64)iovs_len;
if (!validate_native_addr(nread_app, (uint32)sizeof(uint32)) if (!validate_native_addr(nread_app, (uint64)sizeof(uint32))
|| total_size >= UINT32_MAX || total_size >= UINT32_MAX
|| !validate_native_addr((void *)iovec_app, (uint32)total_size)) || !validate_native_addr((void *)iovec_app, total_size))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
total_size = sizeof(wasi_iovec_t) * (uint64)iovs_len; total_size = sizeof(wasi_iovec_t) * (uint64)iovs_len;
@ -489,11 +491,12 @@ wasi_fd_read(wasm_exec_env_t exec_env, wasi_fd_t fd,
iovec = iovec_begin; iovec = iovec_begin;
for (i = 0; i < iovs_len; i++, iovec_app++, iovec++) { for (i = 0; i < iovs_len; i++, iovec_app++, iovec++) {
if (!validate_app_addr(iovec_app->buf_offset, iovec_app->buf_len)) { if (!validate_app_addr((uint64)iovec_app->buf_offset,
(uint64)iovec_app->buf_len)) {
err = (wasi_errno_t)-1; err = (wasi_errno_t)-1;
goto fail; goto fail;
} }
iovec->buf = (void *)addr_app_to_native(iovec_app->buf_offset); iovec->buf = (void *)addr_app_to_native((uint64)iovec_app->buf_offset);
iovec->buf_len = iovec_app->buf_len; iovec->buf_len = iovec_app->buf_len;
} }
@ -537,7 +540,7 @@ wasi_fd_seek(wasm_exec_env_t exec_env, wasi_fd_t fd, wasi_filedelta_t offset,
if (!wasi_ctx) if (!wasi_ctx)
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
if (!validate_native_addr(newoffset, sizeof(wasi_filesize_t))) if (!validate_native_addr(newoffset, (uint64)sizeof(wasi_filesize_t)))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
return wasmtime_ssp_fd_seek(exec_env, curfds, fd, offset, whence, return wasmtime_ssp_fd_seek(exec_env, curfds, fd, offset, whence,
@ -554,7 +557,7 @@ wasi_fd_tell(wasm_exec_env_t exec_env, wasi_fd_t fd, wasi_filesize_t *newoffset)
if (!wasi_ctx) if (!wasi_ctx)
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
if (!validate_native_addr(newoffset, sizeof(wasi_filesize_t))) if (!validate_native_addr(newoffset, (uint64)sizeof(wasi_filesize_t)))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
return wasmtime_ssp_fd_tell(exec_env, curfds, fd, newoffset); return wasmtime_ssp_fd_tell(exec_env, curfds, fd, newoffset);
@ -573,7 +576,7 @@ wasi_fd_fdstat_get(wasm_exec_env_t exec_env, wasi_fd_t fd,
if (!wasi_ctx) if (!wasi_ctx)
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
if (!validate_native_addr(fdstat_app, sizeof(wasi_fdstat_t))) if (!validate_native_addr(fdstat_app, (uint64)sizeof(wasi_fdstat_t)))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
err = wasmtime_ssp_fd_fdstat_get(exec_env, curfds, fd, &fdstat); err = wasmtime_ssp_fd_fdstat_get(exec_env, curfds, fd, &fdstat);
@ -645,9 +648,9 @@ wasi_fd_write(wasm_exec_env_t exec_env, wasi_fd_t fd,
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
total_size = sizeof(iovec_app_t) * (uint64)iovs_len; total_size = sizeof(iovec_app_t) * (uint64)iovs_len;
if (!validate_native_addr(nwritten_app, (uint32)sizeof(uint32)) if (!validate_native_addr(nwritten_app, (uint64)sizeof(uint32))
|| total_size >= UINT32_MAX || total_size >= UINT32_MAX
|| !validate_native_addr((void *)iovec_app, (uint32)total_size)) || !validate_native_addr((void *)iovec_app, total_size))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
total_size = sizeof(wasi_ciovec_t) * (uint64)iovs_len; total_size = sizeof(wasi_ciovec_t) * (uint64)iovs_len;
@ -658,11 +661,12 @@ wasi_fd_write(wasm_exec_env_t exec_env, wasi_fd_t fd,
ciovec = ciovec_begin; ciovec = ciovec_begin;
for (i = 0; i < iovs_len; i++, iovec_app++, ciovec++) { for (i = 0; i < iovs_len; i++, iovec_app++, ciovec++) {
if (!validate_app_addr(iovec_app->buf_offset, iovec_app->buf_len)) { if (!validate_app_addr((uint64)iovec_app->buf_offset,
(uint64)iovec_app->buf_len)) {
err = (wasi_errno_t)-1; err = (wasi_errno_t)-1;
goto fail; goto fail;
} }
ciovec->buf = (char *)addr_app_to_native(iovec_app->buf_offset); ciovec->buf = (char *)addr_app_to_native((uint64)iovec_app->buf_offset);
ciovec->buf_len = iovec_app->buf_len; ciovec->buf_len = iovec_app->buf_len;
} }
@ -759,7 +763,7 @@ wasi_path_open(wasm_exec_env_t exec_env, wasi_fd_t dirfd,
if (!wasi_ctx) if (!wasi_ctx)
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
if (!validate_native_addr(fd_app, sizeof(wasi_fd_t))) if (!validate_native_addr(fd_app, (uint64)sizeof(wasi_fd_t)))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
err = wasmtime_ssp_path_open(exec_env, curfds, dirfd, dirflags, path, err = wasmtime_ssp_path_open(exec_env, curfds, dirfd, dirflags, path,
@ -783,7 +787,7 @@ wasi_fd_readdir(wasm_exec_env_t exec_env, wasi_fd_t fd, void *buf,
if (!wasi_ctx) if (!wasi_ctx)
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
if (!validate_native_addr(bufused_app, sizeof(uint32))) if (!validate_native_addr(bufused_app, (uint64)sizeof(uint32)))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
err = wasmtime_ssp_fd_readdir(exec_env, curfds, fd, buf, buf_len, cookie, err = wasmtime_ssp_fd_readdir(exec_env, curfds, fd, buf, buf_len, cookie,
@ -809,7 +813,7 @@ wasi_path_readlink(wasm_exec_env_t exec_env, wasi_fd_t fd, const char *path,
if (!wasi_ctx) if (!wasi_ctx)
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
if (!validate_native_addr(bufused_app, sizeof(uint32))) if (!validate_native_addr(bufused_app, (uint64)sizeof(uint32)))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
err = wasmtime_ssp_path_readlink(exec_env, curfds, fd, path, path_len, buf, err = wasmtime_ssp_path_readlink(exec_env, curfds, fd, path, path_len, buf,
@ -849,7 +853,7 @@ wasi_fd_filestat_get(wasm_exec_env_t exec_env, wasi_fd_t fd,
if (!wasi_ctx) if (!wasi_ctx)
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
if (!validate_native_addr(filestat, sizeof(wasi_filestat_t))) if (!validate_native_addr(filestat, (uint64)sizeof(wasi_filestat_t)))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
return wasmtime_ssp_fd_filestat_get(exec_env, curfds, fd, filestat); return wasmtime_ssp_fd_filestat_get(exec_env, curfds, fd, filestat);
@ -897,7 +901,7 @@ wasi_path_filestat_get(wasm_exec_env_t exec_env, wasi_fd_t fd,
if (!wasi_ctx) if (!wasi_ctx)
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
if (!validate_native_addr(filestat, sizeof(wasi_filestat_t))) if (!validate_native_addr(filestat, (uint64)sizeof(wasi_filestat_t)))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
return wasmtime_ssp_path_filestat_get(exec_env, curfds, fd, flags, path, return wasmtime_ssp_path_filestat_get(exec_env, curfds, fd, flags, path,
@ -1083,9 +1087,9 @@ wasi_poll_oneoff(wasm_exec_env_t exec_env, const wasi_subscription_t *in,
if (!wasi_ctx) if (!wasi_ctx)
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
if (!validate_native_addr((void *)in, sizeof(wasi_subscription_t)) if (!validate_native_addr((void *)in, (uint64)sizeof(wasi_subscription_t))
|| !validate_native_addr(out, sizeof(wasi_event_t)) || !validate_native_addr(out, (uint64)sizeof(wasi_event_t))
|| !validate_native_addr(nevents_app, sizeof(uint32))) || !validate_native_addr(nevents_app, (uint64)sizeof(uint32)))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
#if WASM_ENABLE_THREAD_MGR == 0 #if WASM_ENABLE_THREAD_MGR == 0
@ -1160,7 +1164,7 @@ wasi_sock_addr_local(wasm_exec_env_t exec_env, wasi_fd_t fd,
if (!wasi_ctx) if (!wasi_ctx)
return __WASI_EACCES; return __WASI_EACCES;
if (!validate_native_addr(addr, sizeof(__wasi_addr_t))) if (!validate_native_addr(addr, (uint64)sizeof(__wasi_addr_t)))
return __WASI_EINVAL; return __WASI_EINVAL;
curfds = wasi_ctx_get_curfds(wasi_ctx); curfds = wasi_ctx_get_curfds(wasi_ctx);
@ -1179,7 +1183,7 @@ wasi_sock_addr_remote(wasm_exec_env_t exec_env, wasi_fd_t fd,
if (!wasi_ctx) if (!wasi_ctx)
return __WASI_EACCES; return __WASI_EACCES;
if (!validate_native_addr(addr, sizeof(__wasi_addr_t))) if (!validate_native_addr(addr, (uint64)sizeof(__wasi_addr_t)))
return __WASI_EINVAL; return __WASI_EINVAL;
curfds = wasi_ctx_get_curfds(wasi_ctx); curfds = wasi_ctx_get_curfds(wasi_ctx);
@ -1264,7 +1268,7 @@ wasi_sock_get_broadcast(wasm_exec_env_t exec_env, wasi_fd_t fd,
if (!wasi_ctx) if (!wasi_ctx)
return __WASI_EACCES; return __WASI_EACCES;
if (!validate_native_addr(is_enabled, sizeof(bool))) if (!validate_native_addr(is_enabled, (uint64)sizeof(bool)))
return __WASI_EINVAL; return __WASI_EINVAL;
curfds = wasi_ctx_get_curfds(wasi_ctx); curfds = wasi_ctx_get_curfds(wasi_ctx);
@ -1283,7 +1287,7 @@ wasi_sock_get_keep_alive(wasm_exec_env_t exec_env, wasi_fd_t fd,
if (!wasi_ctx) if (!wasi_ctx)
return __WASI_EACCES; return __WASI_EACCES;
if (!validate_native_addr(is_enabled, sizeof(bool))) if (!validate_native_addr(is_enabled, (uint64)sizeof(bool)))
return __WASI_EINVAL; return __WASI_EINVAL;
curfds = wasi_ctx_get_curfds(wasi_ctx); curfds = wasi_ctx_get_curfds(wasi_ctx);
@ -1302,8 +1306,8 @@ wasi_sock_get_linger(wasm_exec_env_t exec_env, wasi_fd_t fd, bool *is_enabled,
if (!wasi_ctx) if (!wasi_ctx)
return __WASI_EACCES; return __WASI_EACCES;
if (!validate_native_addr(is_enabled, sizeof(bool)) if (!validate_native_addr(is_enabled, (uint64)sizeof(bool))
|| !validate_native_addr(linger_s, sizeof(int))) || !validate_native_addr(linger_s, (uint64)sizeof(int)))
return __WASI_EINVAL; return __WASI_EINVAL;
curfds = wasi_ctx_get_curfds(wasi_ctx); curfds = wasi_ctx_get_curfds(wasi_ctx);
@ -1323,7 +1327,7 @@ wasi_sock_get_recv_buf_size(wasm_exec_env_t exec_env, wasi_fd_t fd,
if (!wasi_ctx) if (!wasi_ctx)
return __WASI_EACCES; return __WASI_EACCES;
if (!validate_native_addr(size, sizeof(wasi_size_t))) if (!validate_native_addr(size, (uint64)sizeof(wasi_size_t)))
return __WASI_EINVAL; return __WASI_EINVAL;
curfds = wasi_ctx_get_curfds(wasi_ctx); curfds = wasi_ctx_get_curfds(wasi_ctx);
@ -1342,7 +1346,7 @@ wasi_sock_get_recv_timeout(wasm_exec_env_t exec_env, wasi_fd_t fd,
if (!wasi_ctx) if (!wasi_ctx)
return __WASI_EACCES; return __WASI_EACCES;
if (!validate_native_addr(timeout_us, sizeof(uint64_t))) if (!validate_native_addr(timeout_us, (uint64)sizeof(uint64_t)))
return __WASI_EINVAL; return __WASI_EINVAL;
curfds = wasi_ctx_get_curfds(wasi_ctx); curfds = wasi_ctx_get_curfds(wasi_ctx);
@ -1361,7 +1365,7 @@ wasi_sock_get_reuse_addr(wasm_exec_env_t exec_env, wasi_fd_t fd,
if (!wasi_ctx) if (!wasi_ctx)
return __WASI_EACCES; return __WASI_EACCES;
if (!validate_native_addr(is_enabled, sizeof(bool))) if (!validate_native_addr(is_enabled, (uint64)sizeof(bool)))
return __WASI_EINVAL; return __WASI_EINVAL;
curfds = wasi_ctx_get_curfds(wasi_ctx); curfds = wasi_ctx_get_curfds(wasi_ctx);
@ -1380,7 +1384,7 @@ wasi_sock_get_reuse_port(wasm_exec_env_t exec_env, wasi_fd_t fd,
if (!wasi_ctx) if (!wasi_ctx)
return __WASI_EACCES; return __WASI_EACCES;
if (!validate_native_addr(is_enabled, sizeof(bool))) if (!validate_native_addr(is_enabled, (uint64)sizeof(bool)))
return __WASI_EINVAL; return __WASI_EINVAL;
curfds = wasi_ctx_get_curfds(wasi_ctx); curfds = wasi_ctx_get_curfds(wasi_ctx);
@ -1399,7 +1403,7 @@ wasi_sock_get_send_buf_size(wasm_exec_env_t exec_env, wasi_fd_t fd,
if (!wasi_ctx) if (!wasi_ctx)
return __WASI_EACCES; return __WASI_EACCES;
if (!validate_native_addr(size, sizeof(__wasi_size_t))) if (!validate_native_addr(size, (uint64)sizeof(__wasi_size_t)))
return __WASI_EINVAL; return __WASI_EINVAL;
curfds = wasi_ctx_get_curfds(wasi_ctx); curfds = wasi_ctx_get_curfds(wasi_ctx);
@ -1418,7 +1422,7 @@ wasi_sock_get_send_timeout(wasm_exec_env_t exec_env, wasi_fd_t fd,
if (!wasi_ctx) if (!wasi_ctx)
return __WASI_EACCES; return __WASI_EACCES;
if (!validate_native_addr(timeout_us, sizeof(uint64_t))) if (!validate_native_addr(timeout_us, (uint64)sizeof(uint64_t)))
return __WASI_EINVAL; return __WASI_EINVAL;
curfds = wasi_ctx_get_curfds(wasi_ctx); curfds = wasi_ctx_get_curfds(wasi_ctx);
@ -1437,7 +1441,7 @@ wasi_sock_get_tcp_fastopen_connect(wasm_exec_env_t exec_env, wasi_fd_t fd,
if (!wasi_ctx) if (!wasi_ctx)
return __WASI_EACCES; return __WASI_EACCES;
if (!validate_native_addr(is_enabled, sizeof(bool))) if (!validate_native_addr(is_enabled, (uint64)sizeof(bool)))
return __WASI_EINVAL; return __WASI_EINVAL;
curfds = wasi_ctx_get_curfds(wasi_ctx); curfds = wasi_ctx_get_curfds(wasi_ctx);
@ -1457,7 +1461,7 @@ wasi_sock_get_tcp_no_delay(wasm_exec_env_t exec_env, wasi_fd_t fd,
if (!wasi_ctx) if (!wasi_ctx)
return __WASI_EACCES; return __WASI_EACCES;
if (!validate_native_addr(is_enabled, sizeof(bool))) if (!validate_native_addr(is_enabled, (uint64)sizeof(bool)))
return __WASI_EINVAL; return __WASI_EINVAL;
curfds = wasi_ctx_get_curfds(wasi_ctx); curfds = wasi_ctx_get_curfds(wasi_ctx);
@ -1476,7 +1480,7 @@ wasi_sock_get_tcp_quick_ack(wasm_exec_env_t exec_env, wasi_fd_t fd,
if (!wasi_ctx) if (!wasi_ctx)
return __WASI_EACCES; return __WASI_EACCES;
if (!validate_native_addr(is_enabled, sizeof(bool))) if (!validate_native_addr(is_enabled, (uint64)sizeof(bool)))
return __WASI_EINVAL; return __WASI_EINVAL;
curfds = wasi_ctx_get_curfds(wasi_ctx); curfds = wasi_ctx_get_curfds(wasi_ctx);
@ -1496,7 +1500,7 @@ wasi_sock_get_tcp_keep_idle(wasm_exec_env_t exec_env, wasi_fd_t fd,
if (!wasi_ctx) if (!wasi_ctx)
return __WASI_EACCES; return __WASI_EACCES;
if (!validate_native_addr(time_s, sizeof(uint32_t))) if (!validate_native_addr(time_s, (uint64)sizeof(uint32_t)))
return __WASI_EINVAL; return __WASI_EINVAL;
curfds = wasi_ctx_get_curfds(wasi_ctx); curfds = wasi_ctx_get_curfds(wasi_ctx);
@ -1515,7 +1519,7 @@ wasi_sock_get_tcp_keep_intvl(wasm_exec_env_t exec_env, wasi_fd_t fd,
if (!wasi_ctx) if (!wasi_ctx)
return __WASI_EACCES; return __WASI_EACCES;
if (!validate_native_addr(time_s, sizeof(uint32_t))) if (!validate_native_addr(time_s, (uint64)sizeof(uint32_t)))
return __WASI_EINVAL; return __WASI_EINVAL;
curfds = wasi_ctx_get_curfds(wasi_ctx); curfds = wasi_ctx_get_curfds(wasi_ctx);
@ -1534,7 +1538,7 @@ wasi_sock_get_ip_multicast_loop(wasm_exec_env_t exec_env, wasi_fd_t fd,
if (!wasi_ctx) if (!wasi_ctx)
return __WASI_EACCES; return __WASI_EACCES;
if (!validate_native_addr(is_enabled, sizeof(bool))) if (!validate_native_addr(is_enabled, (uint64)sizeof(bool)))
return __WASI_EINVAL; return __WASI_EINVAL;
curfds = wasi_ctx_get_curfds(wasi_ctx); curfds = wasi_ctx_get_curfds(wasi_ctx);
@ -1553,7 +1557,7 @@ wasi_sock_get_ip_ttl(wasm_exec_env_t exec_env, wasi_fd_t fd, uint8_t *ttl_s)
if (!wasi_ctx) if (!wasi_ctx)
return __WASI_EACCES; return __WASI_EACCES;
if (!validate_native_addr(ttl_s, sizeof(uint8_t))) if (!validate_native_addr(ttl_s, (uint64)sizeof(uint8_t)))
return __WASI_EINVAL; return __WASI_EINVAL;
curfds = wasi_ctx_get_curfds(wasi_ctx); curfds = wasi_ctx_get_curfds(wasi_ctx);
@ -1572,7 +1576,7 @@ wasi_sock_get_ip_multicast_ttl(wasm_exec_env_t exec_env, wasi_fd_t fd,
if (!wasi_ctx) if (!wasi_ctx)
return __WASI_EACCES; return __WASI_EACCES;
if (!validate_native_addr(ttl_s, sizeof(uint8_t))) if (!validate_native_addr(ttl_s, (uint64)sizeof(uint8_t)))
return __WASI_EINVAL; return __WASI_EINVAL;
curfds = wasi_ctx_get_curfds(wasi_ctx); curfds = wasi_ctx_get_curfds(wasi_ctx);
@ -1591,7 +1595,7 @@ wasi_sock_get_ipv6_only(wasm_exec_env_t exec_env, wasi_fd_t fd,
if (!wasi_ctx) if (!wasi_ctx)
return __WASI_EACCES; return __WASI_EACCES;
if (!validate_native_addr(is_enabled, sizeof(bool))) if (!validate_native_addr(is_enabled, (uint64)sizeof(bool)))
return __WASI_EINVAL; return __WASI_EINVAL;
curfds = wasi_ctx_get_curfds(wasi_ctx); curfds = wasi_ctx_get_curfds(wasi_ctx);
@ -1884,7 +1888,7 @@ wasi_sock_set_ip_add_membership(wasm_exec_env_t exec_env, wasi_fd_t fd,
if (!wasi_ctx) if (!wasi_ctx)
return __WASI_EACCES; return __WASI_EACCES;
if (!validate_native_addr(imr_multiaddr, sizeof(__wasi_addr_ip_t))) if (!validate_native_addr(imr_multiaddr, (uint64)sizeof(__wasi_addr_ip_t)))
return __WASI_EINVAL; return __WASI_EINVAL;
curfds = wasi_ctx_get_curfds(wasi_ctx); curfds = wasi_ctx_get_curfds(wasi_ctx);
@ -1905,7 +1909,7 @@ wasi_sock_set_ip_drop_membership(wasm_exec_env_t exec_env, wasi_fd_t fd,
if (!wasi_ctx) if (!wasi_ctx)
return __WASI_EACCES; return __WASI_EACCES;
if (!validate_native_addr(imr_multiaddr, sizeof(__wasi_addr_ip_t))) if (!validate_native_addr(imr_multiaddr, (uint64)sizeof(__wasi_addr_ip_t)))
return __WASI_EINVAL; return __WASI_EINVAL;
curfds = wasi_ctx_get_curfds(wasi_ctx); curfds = wasi_ctx_get_curfds(wasi_ctx);
@ -1975,7 +1979,7 @@ allocate_iovec_app_buffer(wasm_module_inst_t module_inst,
total_size = sizeof(iovec_app_t) * (uint64)data_len; total_size = sizeof(iovec_app_t) * (uint64)data_len;
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !validate_native_addr((void *)data, (uint32)total_size)) || !validate_native_addr((void *)data, total_size))
return __WASI_EINVAL; return __WASI_EINVAL;
for (total_size = 0, i = 0; i < data_len; i++, data++) { for (total_size = 0, i = 0; i < data_len; i++, data++) {
@ -2013,7 +2017,8 @@ copy_buffer_to_iovec_app(wasm_module_inst_t module_inst, uint8 *buf_begin,
for (i = 0; i < data_len; data++, i++) { for (i = 0; i < data_len; data++, i++) {
char *native_addr; char *native_addr;
if (!validate_app_addr(data->buf_offset, data->buf_len)) { if (!validate_app_addr((uint64)data->buf_offset,
(uint64)data->buf_len)) {
return __WASI_EINVAL; return __WASI_EINVAL;
} }
@ -2032,7 +2037,7 @@ copy_buffer_to_iovec_app(wasm_module_inst_t module_inst, uint8 *buf_begin,
*/ */
size_to_copy_into_iovec = min_uint32(data->buf_len, size_to_copy); size_to_copy_into_iovec = min_uint32(data->buf_len, size_to_copy);
native_addr = (void *)addr_app_to_native(data->buf_offset); native_addr = (void *)addr_app_to_native((uint64)data->buf_offset);
bh_memcpy_s(native_addr, size_to_copy_into_iovec, buf, bh_memcpy_s(native_addr, size_to_copy_into_iovec, buf,
size_to_copy_into_iovec); size_to_copy_into_iovec);
buf += size_to_copy_into_iovec; buf += size_to_copy_into_iovec;
@ -2064,7 +2069,7 @@ wasi_sock_recv_from(wasm_exec_env_t exec_env, wasi_fd_t sock,
return __WASI_EINVAL; return __WASI_EINVAL;
} }
if (!validate_native_addr(ro_data_len, (uint32)sizeof(uint32))) if (!validate_native_addr(ro_data_len, (uint64)sizeof(uint32)))
return __WASI_EINVAL; return __WASI_EINVAL;
err = allocate_iovec_app_buffer(module_inst, ri_data, ri_data_len, err = allocate_iovec_app_buffer(module_inst, ri_data, ri_data_len,
@ -2103,7 +2108,7 @@ wasi_sock_recv(wasm_exec_env_t exec_env, wasi_fd_t sock, iovec_app_t *ri_data,
__wasi_addr_t src_addr; __wasi_addr_t src_addr;
wasi_errno_t error; wasi_errno_t error;
if (!validate_native_addr(ro_flags, (uint32)sizeof(wasi_roflags_t))) if (!validate_native_addr(ro_flags, (uint64)sizeof(wasi_roflags_t)))
return __WASI_EINVAL; return __WASI_EINVAL;
error = wasi_sock_recv_from(exec_env, sock, ri_data, ri_data_len, ri_flags, error = wasi_sock_recv_from(exec_env, sock, ri_data, ri_data_len, ri_flags,
@ -2134,12 +2139,13 @@ convert_iovec_app_to_buffer(wasm_module_inst_t module_inst,
for (i = 0; i < si_data_len; i++, si_data++) { for (i = 0; i < si_data_len; i++, si_data++) {
char *native_addr; char *native_addr;
if (!validate_app_addr(si_data->buf_offset, si_data->buf_len)) { if (!validate_app_addr((uint64)si_data->buf_offset,
(uint64)si_data->buf_len)) {
wasm_runtime_free(*buf_ptr); wasm_runtime_free(*buf_ptr);
return __WASI_EINVAL; return __WASI_EINVAL;
} }
native_addr = (char *)addr_app_to_native(si_data->buf_offset); native_addr = (char *)addr_app_to_native((uint64)si_data->buf_offset);
bh_memcpy_s(buf, si_data->buf_len, native_addr, si_data->buf_len); bh_memcpy_s(buf, si_data->buf_len, native_addr, si_data->buf_len);
buf += si_data->buf_len; buf += si_data->buf_len;
} }
@ -2168,7 +2174,7 @@ wasi_sock_send(wasm_exec_env_t exec_env, wasi_fd_t sock,
return __WASI_EINVAL; return __WASI_EINVAL;
} }
if (!validate_native_addr(so_data_len, sizeof(uint32))) if (!validate_native_addr(so_data_len, (uint64)sizeof(uint32)))
return __WASI_EINVAL; return __WASI_EINVAL;
err = convert_iovec_app_to_buffer(module_inst, si_data, si_data_len, &buf, err = convert_iovec_app_to_buffer(module_inst, si_data, si_data_len, &buf,
@ -2209,7 +2215,7 @@ wasi_sock_send_to(wasm_exec_env_t exec_env, wasi_fd_t sock,
return __WASI_EINVAL; return __WASI_EINVAL;
} }
if (!validate_native_addr(so_data_len, sizeof(uint32))) if (!validate_native_addr(so_data_len, (uint64)sizeof(uint32)))
return __WASI_EINVAL; return __WASI_EINVAL;
err = convert_iovec_app_to_buffer(module_inst, si_data, si_data_len, &buf, err = convert_iovec_app_to_buffer(module_inst, si_data, si_data_len, &buf,

26
core/iwasm/libraries/thread-mgr/thread_manager.c
View File

@ -139,14 +139,14 @@ final:
/* The caller must not have any locks */ /* The caller must not have any locks */
bool bool
wasm_cluster_allocate_aux_stack(WASMExecEnv *exec_env, uint32 *p_start, wasm_cluster_allocate_aux_stack(WASMExecEnv *exec_env, uint64 *p_start,
uint32 *p_size) uint32 *p_size)
{ {
WASMCluster *cluster = wasm_exec_env_get_cluster(exec_env); WASMCluster *cluster = wasm_exec_env_get_cluster(exec_env);
#if WASM_ENABLE_HEAP_AUX_STACK_ALLOCATION != 0 #if WASM_ENABLE_HEAP_AUX_STACK_ALLOCATION != 0
WASMModuleInstanceCommon *module_inst = WASMModuleInstanceCommon *module_inst =
wasm_exec_env_get_module_inst(exec_env); wasm_exec_env_get_module_inst(exec_env);
uint32 stack_end; uint64 stack_end;
stack_end = wasm_runtime_module_malloc_internal(module_inst, exec_env, stack_end = wasm_runtime_module_malloc_internal(module_inst, exec_env,
cluster->stack_size, NULL); cluster->stack_size, NULL);
@ -185,7 +185,7 @@ wasm_cluster_allocate_aux_stack(WASMExecEnv *exec_env, uint32 *p_start,
/* The caller must not have any locks */ /* The caller must not have any locks */
bool bool
wasm_cluster_free_aux_stack(WASMExecEnv *exec_env, uint32 start) wasm_cluster_free_aux_stack(WASMExecEnv *exec_env, uint64 start)
{ {
WASMCluster *cluster = wasm_exec_env_get_cluster(exec_env); WASMCluster *cluster = wasm_exec_env_get_cluster(exec_env);
@ -223,7 +223,8 @@ WASMCluster *
wasm_cluster_create(WASMExecEnv *exec_env) wasm_cluster_create(WASMExecEnv *exec_env)
{ {
WASMCluster *cluster; WASMCluster *cluster;
uint32 aux_stack_start, aux_stack_size; uint32 aux_stack_size;
uint64 aux_stack_start;
bh_assert(exec_env->cluster == NULL); bh_assert(exec_env->cluster == NULL);
if (!(cluster = wasm_runtime_malloc(sizeof(WASMCluster)))) { if (!(cluster = wasm_runtime_malloc(sizeof(WASMCluster)))) {
@ -280,7 +281,7 @@ wasm_cluster_create(WASMExecEnv *exec_env)
#if WASM_ENABLE_HEAP_AUX_STACK_ALLOCATION == 0 #if WASM_ENABLE_HEAP_AUX_STACK_ALLOCATION == 0
if (cluster_max_thread_num != 0) { if (cluster_max_thread_num != 0) {
uint64 total_size = cluster_max_thread_num * sizeof(uint32); uint64 total_size = cluster_max_thread_num * sizeof(uint64);
uint32 i; uint32 i;
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(cluster->stack_tops = || !(cluster->stack_tops =
@ -496,7 +497,8 @@ wasm_cluster_spawn_exec_env(WASMExecEnv *exec_env)
wasm_module_t module; wasm_module_t module;
wasm_module_inst_t new_module_inst; wasm_module_inst_t new_module_inst;
WASMExecEnv *new_exec_env; WASMExecEnv *new_exec_env;
uint32 aux_stack_start, aux_stack_size; uint32 aux_stack_size;
uint64 aux_stack_start;
uint32 stack_size = 8192; uint32 stack_size = 8192;
if (!module_inst || !(module = wasm_exec_env_get_module(exec_env))) { if (!module_inst || !(module = wasm_exec_env_get_module(exec_env))) {
@ -603,7 +605,7 @@ wasm_cluster_destroy_spawned_exec_env(WASMExecEnv *exec_env)
/* Free aux stack space */ /* Free aux stack space */
wasm_cluster_free_aux_stack(exec_env_tls, wasm_cluster_free_aux_stack(exec_env_tls,
exec_env->aux_stack_bottom.bottom); (uint64)exec_env->aux_stack_bottom);
os_mutex_lock(&cluster->lock); os_mutex_lock(&cluster->lock);
@ -653,7 +655,7 @@ thread_manager_start_routine(void *arg)
#endif #endif
/* Free aux stack space */ /* Free aux stack space */
wasm_cluster_free_aux_stack(exec_env, exec_env->aux_stack_bottom.bottom); wasm_cluster_free_aux_stack(exec_env, (uint64)exec_env->aux_stack_bottom);
os_mutex_lock(&cluster_list_lock); os_mutex_lock(&cluster_list_lock);
@ -693,7 +695,7 @@ thread_manager_start_routine(void *arg)
int32 int32
wasm_cluster_create_thread(WASMExecEnv *exec_env, wasm_cluster_create_thread(WASMExecEnv *exec_env,
wasm_module_inst_t module_inst, wasm_module_inst_t module_inst,
bool is_aux_stack_allocated, uint32 aux_stack_start, bool is_aux_stack_allocated, uint64 aux_stack_start,
uint32 aux_stack_size, uint32 aux_stack_size,
void *(*thread_routine)(void *), void *arg) void *(*thread_routine)(void *), void *arg)
{ {
@ -724,8 +726,8 @@ wasm_cluster_create_thread(WASMExecEnv *exec_env,
} }
else { else {
/* Disable aux stack */ /* Disable aux stack */
new_exec_env->aux_stack_boundary.boundary = 0; new_exec_env->aux_stack_boundary = 0;
new_exec_env->aux_stack_bottom.bottom = UINT32_MAX; new_exec_env->aux_stack_bottom = UINTPTR_MAX;
} }
/* Inherit suspend_flags of parent thread */ /* Inherit suspend_flags of parent thread */
@ -1050,7 +1052,7 @@ wasm_cluster_exit_thread(WASMExecEnv *exec_env, void *retval)
#endif #endif
/* Free aux stack space */ /* Free aux stack space */
wasm_cluster_free_aux_stack(exec_env, exec_env->aux_stack_bottom.bottom); wasm_cluster_free_aux_stack(exec_env, (uint64)exec_env->aux_stack_bottom);
/* App exit the thread, free the resources before exit native thread */ /* App exit the thread, free the resources before exit native thread */

8
core/iwasm/libraries/thread-mgr/thread_manager.h
View File

@ -30,7 +30,7 @@ struct WASMCluster {
/* The aux stack of a module with shared memory will be /* The aux stack of a module with shared memory will be
divided into several segments. This array store the divided into several segments. This array store the
stack top of different segments */ stack top of different segments */
uint32 *stack_tops; uint64 *stack_tops;
/* Record which segments are occupied */ /* Record which segments are occupied */
bool *stack_segment_occupied; bool *stack_segment_occupied;
#endif #endif
@ -89,7 +89,7 @@ wasm_cluster_dup_c_api_imports(WASMModuleInstanceCommon *module_inst_dst,
int32 int32
wasm_cluster_create_thread(WASMExecEnv *exec_env, wasm_cluster_create_thread(WASMExecEnv *exec_env,
wasm_module_inst_t module_inst, wasm_module_inst_t module_inst,
bool is_aux_stack_allocated, uint32 aux_stack_start, bool is_aux_stack_allocated, uint64 aux_stack_start,
uint32 aux_stack_size, uint32 aux_stack_size,
void *(*thread_routine)(void *), void *arg); void *(*thread_routine)(void *), void *arg);
@ -231,11 +231,11 @@ void
wasm_cluster_traverse_unlock(WASMExecEnv *exec_env); wasm_cluster_traverse_unlock(WASMExecEnv *exec_env);
bool bool
wasm_cluster_allocate_aux_stack(WASMExecEnv *exec_env, uint32 *p_start, wasm_cluster_allocate_aux_stack(WASMExecEnv *exec_env, uint64 *p_start,
uint32 *p_size); uint32 *p_size);
bool bool
wasm_cluster_free_aux_stack(WASMExecEnv *exec_env, uint32 start); wasm_cluster_free_aux_stack(WASMExecEnv *exec_env, uint64 start);
#ifdef __cplusplus #ifdef __cplusplus
} }

42
core/iwasm/libraries/wasi-nn/src/utils/wasi_nn_app_native.c
View File

@ -10,14 +10,15 @@ graph_builder_app_native(wasm_module_inst_t instance,
graph_builder_wasm *builder_wasm, graph_builder_wasm *builder_wasm,
graph_builder *builder) graph_builder *builder)
{ {
if (!wasm_runtime_validate_app_addr(instance, builder_wasm->buf_offset, if (!wasm_runtime_validate_app_addr(
builder_wasm->size * sizeof(uint8_t))) { instance, (uint64)builder_wasm->buf_offset,
(uint64)builder_wasm->size * sizeof(uint8_t))) {
NN_ERR_PRINTF("builder_wasm->buf_offset is invalid"); NN_ERR_PRINTF("builder_wasm->buf_offset is invalid");
return invalid_argument; return invalid_argument;
} }
builder->buf = (uint8_t *)wasm_runtime_addr_app_to_native( builder->buf = (uint8_t *)wasm_runtime_addr_app_to_native(
instance, builder_wasm->buf_offset); instance, (uint64)builder_wasm->buf_offset);
builder->size = builder_wasm->size; builder->size = builder_wasm->size;
return success; return success;
} }
@ -27,8 +28,9 @@ graph_builder_array_app_native(wasm_module_inst_t instance,
graph_builder_array_wasm *builder_array_wasm, graph_builder_array_wasm *builder_array_wasm,
graph_builder_array *builder_array) graph_builder_array *builder_array)
{ {
if (!wasm_runtime_validate_native_addr(instance, builder_array_wasm, if (!wasm_runtime_validate_native_addr(
sizeof(graph_builder_array_wasm))) { instance, builder_array_wasm,
(uint64)sizeof(graph_builder_array_wasm))) {
NN_ERR_PRINTF("builder_array_wasm is invalid"); NN_ERR_PRINTF("builder_array_wasm is invalid");
return invalid_argument; return invalid_argument;
} }
@ -37,15 +39,15 @@ graph_builder_array_app_native(wasm_module_inst_t instance,
builder_array_wasm->size); builder_array_wasm->size);
if (!wasm_runtime_validate_app_addr( if (!wasm_runtime_validate_app_addr(
instance, builder_array_wasm->buf_offset, instance, (uint64)builder_array_wasm->buf_offset,
builder_array_wasm->size * sizeof(graph_builder_wasm))) { (uint64)builder_array_wasm->size * sizeof(graph_builder_wasm))) {
NN_ERR_PRINTF("builder_array_wasm->buf_offset is invalid"); NN_ERR_PRINTF("builder_array_wasm->buf_offset is invalid");
return invalid_argument; return invalid_argument;
} }
graph_builder_wasm *builder_wasm = graph_builder_wasm *builder_wasm =
(graph_builder_wasm *)wasm_runtime_addr_app_to_native( (graph_builder_wasm *)wasm_runtime_addr_app_to_native(
instance, builder_array_wasm->buf_offset); instance, (uint64)builder_array_wasm->buf_offset);
graph_builder *builder = (graph_builder *)wasm_runtime_malloc( graph_builder *builder = (graph_builder *)wasm_runtime_malloc(
builder_array_wasm->size * sizeof(graph_builder)); builder_array_wasm->size * sizeof(graph_builder));
@ -74,13 +76,14 @@ static error
tensor_data_app_native(wasm_module_inst_t instance, uint32_t total_elements, tensor_data_app_native(wasm_module_inst_t instance, uint32_t total_elements,
tensor_wasm *input_tensor_wasm, tensor_data *data) tensor_wasm *input_tensor_wasm, tensor_data *data)
{ {
if (!wasm_runtime_validate_app_addr( if (!wasm_runtime_validate_app_addr(instance,
instance, input_tensor_wasm->data_offset, total_elements)) { (uint64)input_tensor_wasm->data_offset,
(uint64)total_elements)) {
NN_ERR_PRINTF("input_tensor_wasm->data_offset is invalid"); NN_ERR_PRINTF("input_tensor_wasm->data_offset is invalid");
return invalid_argument; return invalid_argument;
} }
*data = (tensor_data)wasm_runtime_addr_app_to_native( *data = (tensor_data)wasm_runtime_addr_app_to_native(
instance, input_tensor_wasm->data_offset); instance, (uint64)input_tensor_wasm->data_offset);
return success; return success;
} }
@ -89,19 +92,20 @@ tensor_dimensions_app_native(wasm_module_inst_t instance,
tensor_wasm *input_tensor_wasm, tensor_wasm *input_tensor_wasm,
tensor_dimensions **dimensions) tensor_dimensions **dimensions)
{ {
if (!wasm_runtime_validate_app_addr(instance, if (!wasm_runtime_validate_app_addr(
input_tensor_wasm->dimensions_offset, instance, (uint64)input_tensor_wasm->dimensions_offset,
sizeof(tensor_dimensions_wasm))) { (uint64)sizeof(tensor_dimensions_wasm))) {
NN_ERR_PRINTF("input_tensor_wasm->dimensions_offset is invalid"); NN_ERR_PRINTF("input_tensor_wasm->dimensions_offset is invalid");
return invalid_argument; return invalid_argument;
} }
tensor_dimensions_wasm *dimensions_wasm = tensor_dimensions_wasm *dimensions_wasm =
(tensor_dimensions_wasm *)wasm_runtime_addr_app_to_native( (tensor_dimensions_wasm *)wasm_runtime_addr_app_to_native(
instance, input_tensor_wasm->dimensions_offset); instance, (uint64)input_tensor_wasm->dimensions_offset);
if (!wasm_runtime_validate_app_addr(instance, dimensions_wasm->buf_offset, if (!wasm_runtime_validate_app_addr(instance,
sizeof(tensor_dimensions))) { (uint64)dimensions_wasm->buf_offset,
(uint64)sizeof(tensor_dimensions))) {
NN_ERR_PRINTF("dimensions_wasm->buf_offset is invalid"); NN_ERR_PRINTF("dimensions_wasm->buf_offset is invalid");
return invalid_argument; return invalid_argument;
} }
@ -113,7 +117,7 @@ tensor_dimensions_app_native(wasm_module_inst_t instance,
(*dimensions)->size = dimensions_wasm->size; (*dimensions)->size = dimensions_wasm->size;
(*dimensions)->buf = (uint32_t *)wasm_runtime_addr_app_to_native( (*dimensions)->buf = (uint32_t *)wasm_runtime_addr_app_to_native(
instance, dimensions_wasm->buf_offset); instance, (uint64)dimensions_wasm->buf_offset);
NN_DBG_PRINTF("Number of dimensions: %d", (*dimensions)->size); NN_DBG_PRINTF("Number of dimensions: %d", (*dimensions)->size);
return success; return success;
@ -125,7 +129,7 @@ tensor_app_native(wasm_module_inst_t instance, tensor_wasm *input_tensor_wasm,
{ {
NN_DBG_PRINTF("Converting tensor_wasm to tensor"); NN_DBG_PRINTF("Converting tensor_wasm to tensor");
if (!wasm_runtime_validate_native_addr(instance, input_tensor_wasm, if (!wasm_runtime_validate_native_addr(instance, input_tensor_wasm,
sizeof(tensor_wasm))) { (uint64)sizeof(tensor_wasm))) {
NN_ERR_PRINTF("input_tensor_wasm is invalid"); NN_ERR_PRINTF("input_tensor_wasm is invalid");
return invalid_argument; return invalid_argument;
} }

9
core/iwasm/libraries/wasi-nn/src/wasi_nn.c
View File

@ -211,7 +211,8 @@ wasi_nn_load(wasm_exec_env_t exec_env, graph_builder_array_wasm *builder,
&builder_native))) &builder_native)))
return res; return res;
if (!wasm_runtime_validate_native_addr(instance, g, sizeof(graph))) { if (!wasm_runtime_validate_native_addr(instance, g,
(uint64)sizeof(graph))) {
NN_ERR_PRINTF("graph is invalid"); NN_ERR_PRINTF("graph is invalid");
res = invalid_argument; res = invalid_argument;
goto fail; goto fail;
@ -248,8 +249,8 @@ wasi_nn_init_execution_context(wasm_exec_env_t exec_env, graph g,
if (success != (res = is_model_initialized(wasi_nn_ctx))) if (success != (res = is_model_initialized(wasi_nn_ctx)))
return res; return res;
if (!wasm_runtime_validate_native_addr(instance, ctx, if (!wasm_runtime_validate_native_addr(
sizeof(graph_execution_context))) { instance, ctx, (uint64)sizeof(graph_execution_context))) {
NN_ERR_PRINTF("ctx is invalid"); NN_ERR_PRINTF("ctx is invalid");
return invalid_argument; return invalid_argument;
} }
@ -331,7 +332,7 @@ wasi_nn_get_output(wasm_exec_env_t exec_env, graph_execution_context ctx,
return res; return res;
if (!wasm_runtime_validate_native_addr(instance, output_tensor_size, if (!wasm_runtime_validate_native_addr(instance, output_tensor_size,
sizeof(uint32_t))) { (uint64)sizeof(uint32_t))) {
NN_ERR_PRINTF("output_tensor_size is invalid"); NN_ERR_PRINTF("output_tensor_size is invalid");
return invalid_argument; return invalid_argument;
} }

2
core/shared/platform/common/posix/posix_memmap.c
View File

@ -134,7 +134,7 @@ os_mmap(void *hint, size_t size, int prot, int flags, os_file_handle file)
} }
#endif /* end of BUILD_TARGET_RISCV64_LP64D || BUILD_TARGET_RISCV64_LP64 */ #endif /* end of BUILD_TARGET_RISCV64_LP64D || BUILD_TARGET_RISCV64_LP64 */
/* memory has't been mapped or was mapped failed previously */ /* memory hasn't been mapped or was mapped failed previously */
if (addr == MAP_FAILED) { if (addr == MAP_FAILED) {
/* try 5 times */ /* try 5 times */
for (i = 0; i < 5; i++) { for (i = 0; i < 5; i++) {

77
core/shared/utils/bh_atomic.h
View File

@ -44,6 +44,7 @@ extern "C" {
* #endif * #endif
*/ */
typedef uint64 bh_atomic_64_t;
typedef uint32 bh_atomic_32_t; typedef uint32 bh_atomic_32_t;
typedef uint16 bh_atomic_16_t; typedef uint16 bh_atomic_16_t;
@ -52,6 +53,10 @@ typedef uint16 bh_atomic_16_t;
* If left undefined, it will be automatically defined * If left undefined, it will be automatically defined
* according to the platform. * according to the platform.
*/ */
#ifdef WASM_UINT64_IS_ATOMIC
#define BH_ATOMIC_64_IS_ATOMIC WASM_UINT64_IS_ATOMIC
#endif /* WASM_UINT64_IS_ATOMIC */
#ifdef WASM_UINT32_IS_ATOMIC #ifdef WASM_UINT32_IS_ATOMIC
#define BH_ATOMIC_32_IS_ATOMIC WASM_UINT32_IS_ATOMIC #define BH_ATOMIC_32_IS_ATOMIC WASM_UINT32_IS_ATOMIC
#endif /* WASM_UINT32_IS_ATOMIC */ #endif /* WASM_UINT32_IS_ATOMIC */
@ -71,6 +76,9 @@ typedef uint16 bh_atomic_16_t;
#endif #endif
#if defined(CLANG_GCC_HAS_ATOMIC_BUILTIN) #if defined(CLANG_GCC_HAS_ATOMIC_BUILTIN)
#ifndef BH_ATOMIC_64_IS_ATOMIC
#define BH_ATOMIC_64_IS_ATOMIC 1
#endif
#ifndef BH_ATOMIC_32_IS_ATOMIC #ifndef BH_ATOMIC_32_IS_ATOMIC
#define BH_ATOMIC_32_IS_ATOMIC 1 #define BH_ATOMIC_32_IS_ATOMIC 1
#endif #endif
@ -78,6 +86,9 @@ typedef uint16 bh_atomic_16_t;
#define BH_ATOMIC_16_IS_ATOMIC 1 #define BH_ATOMIC_16_IS_ATOMIC 1
#endif #endif
#else #else
#ifndef BH_ATOMIC_64_IS_ATOMIC
#define BH_ATOMIC_64_IS_ATOMIC 0
#endif
#ifndef BH_ATOMIC_32_IS_ATOMIC #ifndef BH_ATOMIC_32_IS_ATOMIC
#define BH_ATOMIC_32_IS_ATOMIC 0 #define BH_ATOMIC_32_IS_ATOMIC 0
#endif #endif
@ -101,6 +112,72 @@ typedef uint16 bh_atomic_16_t;
#endif #endif
#endif #endif
/* On some 32-bit platform, disable 64-bit atomic operations, otherwise
* undefined reference to `__atomic_load_8' */
#ifndef WASM_UINT64_IS_ATOMIC
#if !defined(__linux__) && !defined(__FreeBSD__) && !defined(__NetBSD__) \
&& !defined(__OpenBSD__) && (defined(__riscv) || defined(__arm__)) \
&& UINT32_MAX == UINTPTR_MAX
#undef BH_ATOMIC_64_IS_ATOMIC
#define BH_ATOMIC_64_IS_ATOMIC 0
#endif
#endif
#if BH_ATOMIC_64_IS_ATOMIC != 0
#define BH_ATOMIC_64_LOAD(v) __atomic_load_n(&(v), __ATOMIC_SEQ_CST)
#define BH_ATOMIC_64_STORE(v, val) __atomic_store_n(&(v), val, __ATOMIC_SEQ_CST)
#define BH_ATOMIC_64_FETCH_OR(v, val) \
__atomic_fetch_or(&(v), (val), __ATOMIC_SEQ_CST)
#define BH_ATOMIC_64_FETCH_AND(v, val) \
__atomic_fetch_and(&(v), (val), __ATOMIC_SEQ_CST)
#define BH_ATOMIC_64_FETCH_ADD(v, val) \
__atomic_fetch_add(&(v), (val), __ATOMIC_SEQ_CST)
#define BH_ATOMIC_64_FETCH_SUB(v, val) \
__atomic_fetch_sub(&(v), (val), __ATOMIC_SEQ_CST)
#else /* else of BH_ATOMIC_64_IS_ATOMIC != 0 */
#define BH_ATOMIC_64_LOAD(v) (v)
#define BH_ATOMIC_64_STORE(v, val) (v) = val
#define BH_ATOMIC_64_FETCH_OR(v, val) nonatomic_64_fetch_or(&(v), val)
#define BH_ATOMIC_64_FETCH_AND(v, val) nonatomic_64_fetch_and(&(v), val)
#define BH_ATOMIC_64_FETCH_ADD(v, val) nonatomic_64_fetch_add(&(v), val)
#define BH_ATOMIC_64_FETCH_SUB(v, val) nonatomic_64_fetch_sub(&(v), val)
static inline uint64
nonatomic_64_fetch_or(bh_atomic_64_t *p, uint64 val)
{
uint64 old = *p;
*p |= val;
return old;
}
static inline uint64
nonatomic_64_fetch_and(bh_atomic_64_t *p, uint64 val)
{
uint64 old = *p;
*p &= val;
return old;
}
static inline uint64
nonatomic_64_fetch_add(bh_atomic_64_t *p, uint64 val)
{
uint64 old = *p;
*p += val;
return old;
}
static inline uint64
nonatomic_64_fetch_sub(bh_atomic_64_t *p, uint64 val)
{
uint64 old = *p;
*p -= val;
return old;
}
#endif
#if BH_ATOMIC_32_IS_ATOMIC != 0 #if BH_ATOMIC_32_IS_ATOMIC != 0
#define BH_ATOMIC_32_LOAD(v) __atomic_load_n(&(v), __ATOMIC_SEQ_CST) #define BH_ATOMIC_32_LOAD(v) __atomic_load_n(&(v), __ATOMIC_SEQ_CST)

18
doc/embed_wamr.md
View File

@ -211,9 +211,9 @@ There are two runtime APIs available for this purpose.
* p_native_addr: return the native address of allocated memory * p_native_addr: return the native address of allocated memory
* size: the buffer size to allocate * size: the buffer size to allocate
*/ */
uint32_t uint64_t
wasm_runtime_module_malloc(wasm_module_inst_t module_inst, wasm_runtime_module_malloc(wasm_module_inst_t module_inst,
uint32_t size, void **p_native_addr); uint64_t size, void **p_native_addr);
/** /**
* malloc a buffer from instance's private memory space, * malloc a buffer from instance's private memory space,
@ -223,28 +223,28 @@ wasm_runtime_module_malloc(wasm_module_inst_t module_inst,
* src: the native buffer address * src: the native buffer address
* size: the size of buffer to be allocated and copy data * size: the size of buffer to be allocated and copy data
*/ */
uint32_t uint64_t
wasm_runtime_module_dup_data(wasm_module_inst_t module_inst, wasm_runtime_module_dup_data(wasm_module_inst_t module_inst,
const char *src, uint32_t size); const char *src, uint64_t size);
/* free the memory allocated from module memory space */ /* free the memory allocated from module memory space */
void void
wasm_runtime_module_free(wasm_module_inst_t module_inst, uint32_t ptr); wasm_runtime_module_free(wasm_module_inst_t module_inst, uint64_t ptr);
``` ```
Usage sample: Usage sample:
```c ```c
char * buffer = NULL; char * buffer = NULL;
uint32_t buffer_for_wasm; uint64_t buffer_for_wasm;
buffer_for_wasm = wasm_runtime_module_malloc(module_inst, 100, &buffer); buffer_for_wasm = wasm_runtime_module_malloc(module_inst, 100, &buffer);
if (buffer_for_wasm != 0) { if (buffer_for_wasm != 0) {
uint32 argv[2]; uint32 argv[3];
strncpy(buffer, "hello", 100); /* use native address for accessing in runtime */ strncpy(buffer, "hello", 100); /* use native address for accessing in runtime */
argv[0] = buffer_for_wasm; /* pass the buffer address for WASM space */ argv[0] = buffer_for_wasm; /* pass the buffer address for WASM space */
argv[1] = 100; /* the size of buffer */ argv[2] = 100; /* the size of buffer */
wasm_runtime_call_wasm(exec_env, func, 2, argv); wasm_runtime_call_wasm(exec_env, func, 3, argv);
/* it is runtime embedder's responsibility to release the memory, /* it is runtime embedder's responsibility to release the memory,
unless the WASM app will free the passed pointer in its code */ unless the WASM app will free the passed pointer in its code */

6
doc/export_native_api.md
View File

@ -170,12 +170,12 @@ void foo2(wasm_exec_env_t exec_env,
if (!wasm_runtime_validate_app_str_add(msg_offset)) if (!wasm_runtime_validate_app_str_add(msg_offset))
return 0; return 0;
if (!wasm_runtime_validate_app_addr(buffer_offset, buf_len)) if (!wasm_runtime_validate_app_addr((uint64)buffer_offset, (uint64)buf_len))
return; return;
// do address conversion // do address conversion
buffer = wasm_runtime_addr_app_to_native(buffer_offset); buffer = wasm_runtime_addr_app_to_native((uint64)buffer_offset);
msg = wasm_runtime_addr_app_to_native(msg_offset); msg = wasm_runtime_addr_app_to_native((uint64)msg_offset);
strncpy(buffer, msg, buf_len); strncpy(buffer, msg, buf_len);
} }

46
language-bindings/go/wamr/instance.go
View File

@ -309,62 +309,62 @@ func (self *Instance) GetException() string {
} }
/* Allocate memory from the heap of the instance */ /* Allocate memory from the heap of the instance */
func (self Instance) ModuleMalloc(size uint32) (uint32, *uint8) { func (self Instance) ModuleMalloc(size uint64) (uint64, *uint8) {
var offset C.uint32_t var offset C.uint64_t
native_addrs := make([]*uint8, 1, 1) native_addrs := make([]*uint8, 1, 1)
ptr := unsafe.Pointer(&native_addrs[0]) ptr := unsafe.Pointer(&native_addrs[0])
offset = C.wasm_runtime_module_malloc(self._instance, (C.uint32_t)(size), offset = C.wasm_runtime_module_malloc(self._instance, (C.uint64_t)(size),
(*unsafe.Pointer)(ptr)) (*unsafe.Pointer)(ptr))
return (uint32)(offset), native_addrs[0] return (uint64)(offset), native_addrs[0]
} }
/* Free memory to the heap of the instance */ /* Free memory to the heap of the instance */
func (self Instance) ModuleFree(offset uint32) { func (self Instance) ModuleFree(offset uint64) {
C.wasm_runtime_module_free(self._instance, (C.uint32_t)(offset)) C.wasm_runtime_module_free(self._instance, (C.uint64_t)(offset))
} }
func (self Instance) ValidateAppAddr(app_offset uint32, size uint32) bool { func (self Instance) ValidateAppAddr(app_offset uint64, size uint64) bool {
ret := C.wasm_runtime_validate_app_addr(self._instance, ret := C.wasm_runtime_validate_app_addr(self._instance,
(C.uint32_t)(app_offset), (C.uint64_t)(app_offset),
(C.uint32_t)(size)) (C.uint64_t)(size))
return (bool)(ret) return (bool)(ret)
} }
func (self Instance) ValidateStrAddr(app_str_offset uint32) bool { func (self Instance) ValidateStrAddr(app_str_offset uint64) bool {
ret := C.wasm_runtime_validate_app_str_addr(self._instance, ret := C.wasm_runtime_validate_app_str_addr(self._instance,
(C.uint32_t)(app_str_offset)) (C.uint64_t)(app_str_offset))
return (bool)(ret) return (bool)(ret)
} }
func (self Instance) ValidateNativeAddr(native_ptr *uint8, size uint32) bool { func (self Instance) ValidateNativeAddr(native_ptr *uint8, size uint64) bool {
native_ptr_C := (unsafe.Pointer)(native_ptr) native_ptr_C := (unsafe.Pointer)(native_ptr)
ret := C.wasm_runtime_validate_native_addr(self._instance, ret := C.wasm_runtime_validate_native_addr(self._instance,
native_ptr_C, native_ptr_C,
(C.uint32_t)(size)) (C.uint64_t)(size))
return (bool)(ret) return (bool)(ret)
} }
func (self Instance) AddrAppToNative(app_offset uint32) *uint8 { func (self Instance) AddrAppToNative(app_offset uint64) *uint8 {
native_ptr := C.wasm_runtime_addr_app_to_native(self._instance, native_ptr := C.wasm_runtime_addr_app_to_native(self._instance,
(C.uint32_t)(app_offset)) (C.uint64_t)(app_offset))
return (*uint8)(native_ptr) return (*uint8)(native_ptr)
} }
func (self Instance) AddrNativeToApp(native_ptr *uint8) uint32 { func (self Instance) AddrNativeToApp(native_ptr *uint8) uint64 {
native_ptr_C := (unsafe.Pointer)(native_ptr) native_ptr_C := (unsafe.Pointer)(native_ptr)
offset := C.wasm_runtime_addr_native_to_app(self._instance, offset := C.wasm_runtime_addr_native_to_app(self._instance,
native_ptr_C) native_ptr_C)
return (uint32)(offset) return (uint64)(offset)
} }
func (self Instance) GetAppAddrRange(app_offset uint32) (bool, func (self Instance) GetAppAddrRange(app_offset uint64) (bool,
uint32, uint64,
uint32) { uint64) {
var start_offset, end_offset C.uint32_t var start_offset, end_offset C.uint64_t
ret := C.wasm_runtime_get_app_addr_range(self._instance, ret := C.wasm_runtime_get_app_addr_range(self._instance,
(C.uint32_t)(app_offset), (C.uint64_t)(app_offset),
&start_offset, &end_offset) &start_offset, &end_offset)
return (bool)(ret), (uint32)(start_offset), (uint32)(end_offset) return (bool)(ret), (uint64)(start_offset), (uint64)(end_offset)
} }
func (self Instance) GetNativeAddrRange(native_ptr *uint8) (bool, func (self Instance) GetNativeAddrRange(native_ptr *uint8) (bool,

3
language-bindings/python/src/wamr/wamrapi/wamr.py
View File

@ -6,6 +6,7 @@ from ctypes import addressof
from ctypes import c_char from ctypes import c_char
from ctypes import c_uint from ctypes import c_uint
from ctypes import c_uint8 from ctypes import c_uint8
from ctypes import c_uint64
from ctypes import c_void_p from ctypes import c_void_p
from ctypes import cast from ctypes import cast
from ctypes import create_string_buffer from ctypes import create_string_buffer
@ -167,7 +168,7 @@ class Instance:
raise Exception("Error while creating module instance") raise Exception("Error while creating module instance")
return module_inst return module_inst
def malloc(self, nbytes: int, native_handler) -> c_uint: def malloc(self, nbytes: int, native_handler) -> c_uint64:
return wasm_runtime_module_malloc(self.module_inst, nbytes, native_handler) return wasm_runtime_module_malloc(self.module_inst, nbytes, native_handler)
def free(self, wasm_handler) -> None: def free(self, wasm_handler) -> None:

10
samples/basic/src/main.c
View File

@ -61,7 +61,7 @@ main(int argc, char *argv_main[])
wasm_function_inst_t func = NULL; wasm_function_inst_t func = NULL;
wasm_function_inst_t func2 = NULL; wasm_function_inst_t func2 = NULL;
char *native_buffer = NULL; char *native_buffer = NULL;
uint32_t wasm_buffer = 0; uint64_t wasm_buffer = 0;
RuntimeInitArgs init_args; RuntimeInitArgs init_args;
memset(&init_args, 0, sizeof(RuntimeInitArgs)); memset(&init_args, 0, sizeof(RuntimeInitArgs));
@ -176,7 +176,7 @@ main(int argc, char *argv_main[])
ret_val); ret_val);
// Next we will pass a buffer to the WASM function // Next we will pass a buffer to the WASM function
uint32 argv2[4]; uint32 argv2[5];
// must allocate buffer from wasm instance memory space (never use pointer // must allocate buffer from wasm instance memory space (never use pointer
// from host runtime) // from host runtime)
@ -185,8 +185,8 @@ main(int argc, char *argv_main[])
memcpy(argv2, &ret_val, sizeof(float)); // the first argument memcpy(argv2, &ret_val, sizeof(float)); // the first argument
argv2[1] = wasm_buffer; // the second argument is the wasm buffer address argv2[1] = wasm_buffer; // the second argument is the wasm buffer address
argv2[2] = 100; // the third argument is the wasm buffer size argv2[3] = 100; // the third argument is the wasm buffer size
argv2[3] = 3; // the last argument is the digits after decimal point for argv2[4] = 3; // the last argument is the digits after decimal point for
// converting float to string // converting float to string
if (!(func2 = wasm_runtime_lookup_function(module_inst, "float_to_string", if (!(func2 = wasm_runtime_lookup_function(module_inst, "float_to_string",
@ -231,7 +231,7 @@ fail:
wasm_runtime_destroy_exec_env(exec_env); wasm_runtime_destroy_exec_env(exec_env);
if (module_inst) { if (module_inst) {
if (wasm_buffer) if (wasm_buffer)
wasm_runtime_module_free(module_inst, wasm_buffer); wasm_runtime_module_free(module_inst, (uint64)wasm_buffer);
wasm_runtime_deinstantiate(module_inst); wasm_runtime_deinstantiate(module_inst);
} }
if (module) if (module)

10
samples/native-lib/test_hello2.c
View File

@ -30,12 +30,14 @@ test_hello2_wrapper(wasm_exec_env_t exec_env, uint32_t nameaddr,
wasm_runtime_free(p); wasm_runtime_free(p);
wasm_module_inst_t inst = wasm_runtime_get_module_inst(exec_env); wasm_module_inst_t inst = wasm_runtime_get_module_inst(exec_env);
if (!wasm_runtime_validate_app_str_addr(inst, nameaddr) if (!wasm_runtime_validate_app_str_addr(inst, (uint64_t)nameaddr)
|| !wasm_runtime_validate_app_addr(inst, resultaddr, resultlen)) { || !wasm_runtime_validate_app_addr(inst, (uint64_t)resultaddr,
(uint64_t)resultlen)) {
return -1; return -1;
} }
const char *name = wasm_runtime_addr_app_to_native(inst, nameaddr); const char *name =
char *result = wasm_runtime_addr_app_to_native(inst, resultaddr); wasm_runtime_addr_app_to_native(inst, (uint64_t)nameaddr);
char *result = wasm_runtime_addr_app_to_native(inst, (uint64_t)resultaddr);
return snprintf(result, resultlen, return snprintf(result, resultlen,
"Hello, %s. This is %s! Your wasm_module_inst_t is %p.\n", "Hello, %s. This is %s! Your wasm_module_inst_t is %p.\n",
name, __func__, inst); name, __func__, inst);