Added comments/questions to the host functions managing module arguments

build-scripts/runtime_lib.cmake

@@ -122,6 +122,17 @@ if (WAMR_BUILD_LIB_WASI_THREADS EQUAL 1)
     set (WAMR_BUILD_SHARED_MEMORY 1)
 endif ()
 
+if (WAMR_BUILD_LIBC_WALI EQUAL 1)
+    include (${IWASM_DIR}/libraries/libc-wali/libc_wali.cmake)
+    # Enable the dependent feature if lib wali is enabled
+    set (WAMR_BUILD_THREAD_MGR 1)
+    set (WAMR_BUILD_BULK_MEMORY 1)
+    set (WAMR_BUILD_SHARED_MEMORY 1)
+    # Currently these settings are required
+    set (WAMR_BUILD_FAST_INTERP 1)
+    set (WAMR_BUILD_MULTI_MODULE 1)
+endif ()
+
 if (WAMR_BUILD_DEBUG_INTERP EQUAL 1)
     set (WAMR_BUILD_THREAD_MGR 1)
     include (${IWASM_DIR}/libraries/debug-engine/debug_engine.cmake)
@@ -194,6 +205,7 @@ set (source_all
     ${LIBC_EMCC_SOURCE}
     ${LIB_RATS_SOURCE}
     ${DEBUG_ENGINE_SOURCE}
+    ${LIBC_WALI_SOURCE}
 )
 
 set (WAMR_RUNTIME_LIB_SOURCE ${source_all})

core/config.h

@@ -180,6 +180,10 @@
 #error "Heap aux stack allocation must be enabled for WASI threads"
 #endif
 
+#ifndef WASM_ENABLE_LIBC_WALI
+#define WASM_ENABLE_LIBC_WALI 0
+#endif
+
 #ifndef WASM_ENABLE_BASE_LIB
 #define WASM_ENABLE_BASE_LIB 0
 #endif
@@ -392,7 +396,7 @@
 #define APP_THREAD_STACK_SIZE_DEFAULT (64 * 1024)
 #define APP_THREAD_STACK_SIZE_MIN (48 * 1024)
 #else
-#define APP_THREAD_STACK_SIZE_DEFAULT (64 * 1024)
+#define APP_THREAD_STACK_SIZE_DEFAULT (128 * 1024)
 #define APP_THREAD_STACK_SIZE_MIN (24 * 1024)
 #endif
 #endif /* end of !(defined(APP_THREAD_STACK_SIZE_DEFAULT) \

core/iwasm/aot/aot_reloc.h

@@ -21,6 +21,9 @@ typedef struct {
 /* clang-format off */
 #define REG_SYM(symbol) { #symbol, (void *)symbol }
 
+#define REG_WALI_SYM()                    \
+    REG_SYM(aot_poll_pending_signal),
+
 #if WASM_ENABLE_BULK_MEMORY != 0
 #define REG_BULK_MEMORY_SYM()             \
     REG_SYM(aot_memory_init),             \
@@ -159,6 +162,7 @@ typedef struct {
     REG_AOT_TRACE_SYM()                   \
     REG_INTRINSIC_SYM()                   \
     REG_LLVM_PGO_SYM()                    \
+    REG_WALI_SYM()                        \
 
 #define CHECK_RELOC_OFFSET(data_size) do {              \
     if (!check_reloc_offset(target_section_size,        \

core/iwasm/aot/aot_runtime.c

@@ -14,6 +14,7 @@
 #if WASM_ENABLE_THREAD_MGR != 0
 #include "../libraries/thread-mgr/thread_manager.h"
 #endif
+#include "../interpreter/sigtable.h"
 
 /*
  * Note: These offsets need to match the values hardcoded in
@@ -42,7 +43,7 @@ bh_static_assert(offsetof(AOTModuleInstance, cur_exception)
 bh_static_assert(offsetof(AOTModuleInstance, global_table_data)
                  == 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) == 8);
 
 bh_static_assert(offsetof(AOTModuleInstanceExtra, stack_sizes) == 0);
@@ -551,6 +552,7 @@ memory_instantiate(AOTModuleInstance *module_inst, AOTModuleInstance *parent,
     memory_inst->module_type = Wasm_Module_AoT;
     memory_inst->num_bytes_per_page = num_bytes_per_page;
     memory_inst->cur_page_count = init_page_count;
+    memory_inst->base_page_count = init_page_count;
     memory_inst->max_page_count = max_page_count;
     memory_inst->memory_data_size = (uint32)total_size;
 
@@ -855,6 +857,48 @@ create_export_funcs(AOTModuleInstance *module_inst, AOTModule *module,
     return true;
 }
 
+static bool
+create_export_globals(AOTModuleInstance *module_inst, AOTModule *module,
+                    char *error_buf, uint32 error_buf_size)
+{
+    AOTExport *exports = module->exports;
+    AOTGlobalInstance *export_global;
+    uint64 size;
+    uint32 i, global_index;
+
+    if (module_inst->export_global_count > 0) {
+        /* Allocate memory */
+        size = sizeof(AOTGlobalInstance)
+               * (uint64)module_inst->export_global_count;
+        if (!(export_global = runtime_malloc(size, error_buf, error_buf_size))) {
+            return false;
+        }
+        module_inst->export_globals = (void *)export_global;
+
+        for (i = 0; i < module->export_count; i++) {
+            if (exports[i].kind == EXPORT_KIND_GLOBAL) {
+                export_global->name = exports[i].name;
+                export_global->index = exports[i].index;
+                if (export_global->index < module->import_global_count) {
+                    export_global->is_import_global = true;
+                    export_global->u.glob_import =
+                        &module->import_globals[export_global->index];
+                }
+                else {
+                    export_global->is_import_global = false;
+                    global_index =
+                        export_global->index - module->import_global_count;
+                    export_global->u.glob =
+                        &module->globals[global_index];
+                }
+                export_global++;
+            }
+        }
+    }
+
+    return true;
+}
+
 static bool
 create_exports(AOTModuleInstance *module_inst, AOTModule *module,
                char *error_buf, uint32 error_buf_size)
@@ -881,7 +925,8 @@ create_exports(AOTModuleInstance *module_inst, AOTModule *module,
         }
     }
 
-    return create_export_funcs(module_inst, module, error_buf, error_buf_size);
+    return create_export_funcs(module_inst, module, error_buf, error_buf_size)
+        && create_export_globals(module_inst, module, error_buf, error_buf_size);
 }
 
 static AOTFunctionInstance *
@@ -1285,6 +1330,9 @@ aot_deinstantiate(AOTModuleInstance *module_inst, bool is_sub_inst)
     if (module_inst->export_functions)
         wasm_runtime_free(module_inst->export_functions);
 
+    if (module_inst->export_globals)
+        wasm_runtime_free(module_inst->export_globals);
+
     if (module_inst->func_ptrs)
         wasm_runtime_free(module_inst->func_ptrs);
 
@@ -1320,6 +1368,19 @@ aot_lookup_function(const AOTModuleInstance *module_inst, const char *name,
     return NULL;
 }
 
+AOTGlobalInstance*
+aot_lookup_global(const AOTModuleInstance *module_inst, const char *name)
+{
+    uint32 i;
+    AOTGlobalInstance *export_globs =
+        (AOTGlobalInstance*)module_inst->export_globals;
+
+    for (i = 0; i < module_inst->export_global_count; i++)
+        if (!strcmp(export_globs[i].name, name))
+            return &export_globs[i];
+    return NULL;
+}
+
 #ifdef OS_ENABLE_HW_BOUND_CHECK
 
 static bool
@@ -1647,6 +1708,25 @@ aot_copy_exception(AOTModuleInstance *module_inst, char *exception_buf)
     return wasm_copy_exception(module_inst, exception_buf);
 }
 
+void
+aot_poll_pending_signal(WASMExecEnv *exec_env)
+{
+  int signo;
+  if ((signo = get_pending_signal()) != -1) {
+    pthread_mutex_lock(&sigtable_mut);
+    AOTModuleInstance *module_inst = (AOTModuleInstance*) wasm_runtime_get_module_inst(exec_env);
+    AOTFunctionInstance* sigfn = wali_sigtable[signo].function;
+    /* Patch function pointer in case of reassignment */
+    uint32 func_idx = wali_sigtable[signo].func_idx;
+    uint32 func_type_idx = module_inst->func_type_indexes[func_idx]; 
+    sigfn->u.func.func_type = ((AOTModule*)module_inst->module)->func_types[func_type_idx];
+    sigfn->u.func.func_ptr = module_inst->func_ptrs[func_idx];
+    /* */
+    pthread_mutex_unlock(&sigtable_mut);
+    wasm_runtime_call_wasm(exec_env, sigfn, 1, (uint32_t*)&signo);
+  }
+}
+
 static bool
 execute_malloc_function(AOTModuleInstance *module_inst, WASMExecEnv *exec_env,
                         AOTFunctionInstance *malloc_func,
@@ -1962,10 +2042,16 @@ aot_module_dup_data(AOTModuleInstance *module_inst, const char *src,
     return buffer_offset;
 }
 
+bool
+aot_can_enlarge_memory(AOTModuleInstance *module_inst, uint32 inc_page_count)
+{
+    return wasm_can_enlarge_memory(module_inst, inc_page_count);
+}
+
 bool
 aot_enlarge_memory(AOTModuleInstance *module_inst, uint32 inc_page_count)
 {
-    return wasm_enlarge_memory(module_inst, inc_page_count);
+    return wasm_enlarge_memory(module_inst, inc_page_count, false);
 }
 
 bool
@@ -2059,18 +2145,60 @@ aot_invoke_native(WASMExecEnv *exec_env, uint32 func_idx, uint32 argc,
     return ret;
 }
 
+
+bool
+aot_get_indirect_function (AOTModuleInstance *module_inst, uint32 tbl_idx,
+                          uint32 table_elem_idx, void **func_ptr_addr, 
+                          uint32* func_idx_addr, AOTFuncType **func_type_addr) {
+
+  AOTModule *aot_module = (AOTModule *)module_inst->module;
+  AOTTableInstance *tbl_inst = NULL;
+  uint32 func_idx = NULL_REF;
+  uint32 *func_type_indexes = module_inst->func_type_indexes;
+  uint32 func_type_idx;
+  void **func_ptrs = module_inst->func_ptrs;
+
+  tbl_inst = module_inst->tables[tbl_idx];
+  bh_assert(tbl_inst);
+  if (table_elem_idx >= tbl_inst->cur_size) {
+      aot_set_exception_with_id(module_inst, EXCE_UNDEFINED_ELEMENT);
+      goto fail;
+  }
+
+  func_idx = tbl_inst->elems[table_elem_idx];
+  if (func_idx == NULL_REF) {
+      aot_set_exception_with_id(module_inst, EXCE_UNINITIALIZED_ELEMENT);
+      goto fail;
+  }
+
+  func_type_idx = func_type_indexes[func_idx];
+  *func_type_addr = aot_module->func_types[func_type_idx];
+
+  if (func_idx >= aot_module->import_func_count) {
+      /* func pointer was looked up previously */
+      bh_assert(func_ptrs[func_idx] != NULL);
+  }
+
+  *func_ptr_addr = func_ptrs[func_idx];
+  *func_idx_addr = func_idx;
+  return true;
+
+fail:
+  *func_ptr_addr = NULL;
+  *func_idx_addr = 0;
+  return false;
+}
+
 bool
 aot_call_indirect(WASMExecEnv *exec_env, uint32 tbl_idx, uint32 table_elem_idx,
                   uint32 argc, uint32 *argv)
 {
     AOTModuleInstance *module_inst =
         (AOTModuleInstance *)wasm_runtime_get_module_inst(exec_env);
     AOTModule *aot_module = (AOTModule *)module_inst->module;
-    uint32 *func_type_indexes = module_inst->func_type_indexes;
-    AOTTableInstance *tbl_inst;
     AOTFuncType *func_type;
-    void **func_ptrs = module_inst->func_ptrs, *func_ptr;
-    uint32 func_type_idx, func_idx, ext_ret_count;
+    void *func_ptr;
+    uint32 func_idx, ext_ret_count;
     AOTImportFunc *import_func;
     const char *signature = NULL;
     void *attachment = NULL;
@@ -2087,29 +2215,13 @@ aot_call_indirect(WASMExecEnv *exec_env, uint32 tbl_idx, uint32 table_elem_idx,
         goto fail;
     }
 
-    tbl_inst = module_inst->tables[tbl_idx];
-    bh_assert(tbl_inst);
-
-    if (table_elem_idx >= tbl_inst->cur_size) {
-        aot_set_exception_with_id(module_inst, EXCE_UNDEFINED_ELEMENT);
-        goto fail;
-    }
-
-    func_idx = tbl_inst->elems[table_elem_idx];
-    if (func_idx == NULL_REF) {
-        aot_set_exception_with_id(module_inst, EXCE_UNINITIALIZED_ELEMENT);
-        goto fail;
-    }
-
-    func_type_idx = func_type_indexes[func_idx];
-    func_type = aot_module->func_types[func_type_idx];
-
-    if (func_idx >= aot_module->import_func_count) {
-        /* func pointer was looked up previously */
-        bh_assert(func_ptrs[func_idx] != NULL);
+    bool success = aot_get_indirect_function(module_inst, tbl_idx, table_elem_idx, 
+                                          &func_ptr, &func_idx, &func_type);
+    if (!success) {
+      goto fail;
     }
 
-    if (!(func_ptr = func_ptrs[func_idx])) {
+    if (!func_ptr) {
         bh_assert(func_idx < aot_module->import_func_count);
         import_func = aot_module->import_funcs + func_idx;
         snprintf(buf, sizeof(buf),

core/iwasm/aot/aot_runtime.h

@@ -87,6 +87,17 @@ typedef struct AOTFunctionInstance {
     } u;
 } AOTFunctionInstance;
 
+/* AOT global instance */
+typedef struct AOTGlobalInstance {
+  char *name;
+  uint32 index;
+  bool is_import_global;
+  union {
+    AOTGlobal *glob;
+    AOTImportGlobal *glob_import;
+  } u;
+} AOTGlobalInstance;
+
 typedef struct AOTModuleInstanceExtra {
     DefPointer(const uint32 *, stack_sizes);
     WASMModuleInstanceExtraCommon common;
@@ -421,6 +432,18 @@ aot_deinstantiate(AOTModuleInstance *module_inst, bool is_sub_inst);
 AOTFunctionInstance *
 aot_lookup_function(const AOTModuleInstance *module_inst, const char *name,
                     const char *signature);
+
+/**
+ * Lookup an exported global in the AOT module instance.
+ *
+ * @param module_inst the module instance
+ * @param name the name of the global
+ *
+ * @return the global instance found
+ */
+AOTGlobalInstance*
+aot_lookup_global(const AOTModuleInstance *module_inst, const char *name);
+
 /**
  * Call the given AOT function of a AOT module instance with
  * arguments.
@@ -472,6 +495,13 @@ aot_get_exception(AOTModuleInstance *module_inst);
 bool
 aot_copy_exception(AOTModuleInstance *module_inst, char *exception_buf);
 
+/**
+ * Poll for pending signals in WALI
+ * @param exec_env the execution environment
+ * @return none
+ */
+void aot_poll_pending_signal(WASMExecEnv *exec_env);
+
 uint32
 aot_module_malloc_internal(AOTModuleInstance *module_inst, WASMExecEnv *env,
                            uint32 size, void **p_native_addr);
@@ -499,6 +529,9 @@ uint32
 aot_module_dup_data(AOTModuleInstance *module_inst, const char *src,
                     uint32 size);
 
+bool
+aot_can_enlarge_memory(AOTModuleInstance *module_inst, uint32 inc_page_count);
+
 bool
 aot_enlarge_memory(AOTModuleInstance *module_inst, uint32 inc_page_count);
 
@@ -509,6 +542,14 @@ bool
 aot_invoke_native(WASMExecEnv *exec_env, uint32 func_idx, uint32 argc,
                   uint32 *argv);
 
+/**
+* Get indirect function and return func_ptr, func_idx, func_type 
+*/
+bool
+aot_get_indirect_function (AOTModuleInstance *module_inst, uint32 tbl_idx,
+                          uint32 table_elem_idx, void **func_ptr_addr, 
+                          uint32* func_idx_addr, AOTFuncType **func_type_addr);
+
 bool
 aot_call_indirect(WASMExecEnv *exec_env, uint32 tbl_idx, uint32 table_elem_idx,
                   uint32 argc, uint32 *argv);