Merge pull request #692 from bytecodealliance/main

Merge bytecodealliance:main into wenyongh:main

Author: wenyongh

.github/workflows/compilation_on_android_ubuntu.yml

@@ -424,7 +424,8 @@ jobs:
 
       - name: set env variable(if x86_32 test needed)
         if: >
-          (matrix.test_option == '$DEFAULT_TEST_OPTIONS' || matrix.test_option == '$THREADS_TEST_OPTIONS')
+          (matrix.test_option == '$DEFAULT_TEST_OPTIONS' || matrix.test_option == '$THREADS_TEST_OPTIONS'
+           || matrix.test_option == '$WASI_TEST_OPTIONS')
           && matrix.running_mode != 'fast-jit' && matrix.running_mode != 'jit'
         run: echo "TEST_ON_X86_32=true" >> $GITHUB_ENV
 

core/iwasm/aot/aot_loader.c

@@ -1226,7 +1226,10 @@ load_import_globals(const uint8 **p_buf, const uint8 *buf_end,
             }
             import_globals[i].global_data_linked =
                 tmp_global.global_data_linked;
+            import_globals[i].is_linked = true;
         }
+#else
+        import_globals[i].is_linked = false;
 #endif
 
         import_globals[i].size = wasm_value_type_size(import_globals[i].type);

core/iwasm/aot/aot_runtime.c

@@ -976,6 +976,26 @@ execute_memory_init_function(AOTModuleInstance *module_inst)
 }
 #endif
 
+static bool
+check_linked_symbol(AOTModule *module, char *error_buf, uint32 error_buf_size)
+{
+    uint32 i;
+
+    /* init_func_ptrs() will go through import functions */
+
+    for (i = 0; i < module->import_global_count; i++) {
+        AOTImportGlobal *global = module->import_globals + i;
+        if (!global->is_linked) {
+            set_error_buf_v(error_buf, error_buf_size,
+                            "failed to link import global (%s, %s)",
+                            global->module_name, global->global_name);
+            return false;
+        }
+    }
+
+    return true;
+}
+
 AOTModuleInstance *
 aot_instantiate(AOTModule *module, bool is_sub_inst, uint32 stack_size,
                 uint32 heap_size, char *error_buf, uint32 error_buf_size)
@@ -1059,6 +1079,9 @@ aot_instantiate(AOTModule *module, bool is_sub_inst, uint32 stack_size,
     if (!init_func_type_indexes(module_inst, module, error_buf, error_buf_size))
         goto fail;
 
+    if (!check_linked_symbol(module, error_buf, error_buf_size))
+        goto fail;
+
     if (!create_exports(module_inst, module, error_buf, error_buf_size))
         goto fail;
 

core/iwasm/common/wasm_c_api.c

@@ -4555,6 +4555,7 @@ aot_link_global(const AOTModule *module_aot, uint16 global_idx_rt,
     }
 
     import->global_idx_rt = global_idx_rt;
+    import_aot_global->is_linked = true;
     return true;
 
 failed:

core/iwasm/compilation/aot.h

@@ -149,6 +149,7 @@ typedef struct AOTImportGlobal {
     uint32 data_offset;
     /* global data after linked */
     WASMValue global_data_linked;
+    bool is_linked;
 } AOTImportGlobal;
 
 /**

core/iwasm/interpreter/wasm_runtime.c

@@ -1235,6 +1235,7 @@ check_linked_symbol(WASMModuleInstance *module_inst, char *error_buf,
 #if WASM_ENABLE_WAMR_COMPILER == 0
             LOG_WARNING("warning: failed to link import function (%s, %s)",
                         func->module_name, func->field_name);
+            /* will throw exception only if calling */
 #else
             /* do nothing to avoid confused message */
 #endif /* WASM_ENABLE_WAMR_COMPILER == 0 */
@@ -1250,8 +1251,10 @@ check_linked_symbol(WASMModuleInstance *module_inst, char *error_buf,
             return false;
 #else
 #if WASM_ENABLE_WAMR_COMPILER == 0
-            LOG_DEBUG("warning: failed to link import global (%s, %s)",
-                      global->module_name, global->field_name);
+            set_error_buf_v(error_buf, error_buf_size,
+                            "failed to link import global (%s, %s)",
+                            global->module_name, global->field_name);
+            return false;
 #else
             /* do nothing to avoid confused message */
 #endif /* WASM_ENABLE_WAMR_COMPILER == 0 */

core/shared/platform/windows/platform_internal.h

@@ -72,6 +72,7 @@ typedef struct os_thread_wait_node *os_thread_wait_list;
 typedef struct korp_cond {
     korp_mutex wait_list_lock;
     os_thread_wait_list thread_wait_list;
+    struct os_thread_wait_node *thread_wait_list_end;
 } korp_cond;
 
 #define bh_socket_t SOCKET

core/shared/platform/windows/win_thread.c

@@ -37,6 +37,8 @@ typedef struct os_thread_data {
     korp_mutex wait_lock;
     /* Waiting list of other threads who are joining this thread */
     os_thread_wait_list thread_wait_list;
+    /* End node of the waiting list */
+    os_thread_wait_node *thread_wait_list_end;
     /* Whether the thread has exited */
     bool thread_exited;
     /* Thread return value */
@@ -174,7 +176,8 @@ os_thread_cleanup(void *retval)
             os_sem_signal(&head->sem);
             head = next;
         }
-        thread_data->thread_wait_list = NULL;
+        thread_data->thread_wait_list = thread_data->thread_wait_list_end =
+            NULL;
     }
     /* Set thread status and thread return value */
     thread_data->thread_exited = true;
@@ -313,14 +316,14 @@ os_thread_join(korp_tid thread, void **p_retval)
     }
 
     /* Thread is running */
-    if (!thread_data->thread_wait_list)
-        thread_data->thread_wait_list = &curr_thread_data->wait_node;
-    else {
+    if (!thread_data->thread_wait_list) { /* Waiting list is empty */
+        thread_data->thread_wait_list = thread_data->thread_wait_list_end =
+            &curr_thread_data->wait_node;
+    }
+    else { /* Waiting list isn't empty */
         /* Add to end of waiting list */
-        os_thread_wait_node *p = thread_data->thread_wait_list;
-        while (p->next)
-            p = p->next;
-        p->next = &curr_thread_data->wait_node;
+        thread_data->thread_wait_list_end->next = &curr_thread_data->wait_node;
+        thread_data->thread_wait_list_end = &curr_thread_data->wait_node;
     }
 
     os_mutex_unlock(&thread_data->wait_lock);
@@ -545,7 +548,7 @@ os_cond_init(korp_cond *cond)
     if (os_mutex_init(&cond->wait_list_lock) != BHT_OK)
         return BHT_ERROR;
 
-    cond->thread_wait_list = NULL;
+    cond->thread_wait_list = cond->thread_wait_list_end = NULL;
     return BHT_OK;
 }
 
@@ -568,14 +571,13 @@ os_cond_wait_internal(korp_cond *cond, korp_mutex *mutex, bool timed,
     bh_assert(cond);
     bh_assert(mutex);
     os_mutex_lock(&cond->wait_list_lock);
-    if (!cond->thread_wait_list)
-        cond->thread_wait_list = node;
-    else {
+    if (!cond->thread_wait_list) { /* Waiting list is empty */
+        cond->thread_wait_list = cond->thread_wait_list_end = node;
+    }
+    else { /* Waiting list isn't empty */
         /* Add to end of wait list */
-        os_thread_wait_node *p = cond->thread_wait_list;
-        while (p->next)
-            p = p->next;
-        p->next = node;
+        cond->thread_wait_list_end->next = node;
+        cond->thread_wait_list_end = node;
     }
     os_mutex_unlock(&cond->wait_list_lock);
 
@@ -590,14 +592,24 @@ os_cond_wait_internal(korp_cond *cond, korp_mutex *mutex, bool timed,
 
     /* Remove wait node from wait list */
     os_mutex_lock(&cond->wait_list_lock);
-    if (cond->thread_wait_list == node)
+    if (cond->thread_wait_list == node) {
         cond->thread_wait_list = node->next;
+
+        if (cond->thread_wait_list_end == node) {
+            bh_assert(node->next == NULL);
+            cond->thread_wait_list_end = NULL;
+        }
+    }
     else {
         /* Remove from the wait list */
         os_thread_wait_node *p = cond->thread_wait_list;
         while (p->next != node)
             p = p->next;
         p->next = node->next;
+
+        if (cond->thread_wait_list_end == node) {
+            cond->thread_wait_list_end = p;
+        }
     }
     os_mutex_unlock(&cond->wait_list_lock);