[instantiation linking] Create and import WASMGlobalInstance

.gitignore

@@ -40,4 +40,5 @@ tests/benchmarks/coremark/coremark*
 samples/workload/include/**
 !samples/workload/include/.gitkeep
 
-# core/iwasm/libraries/wasi-threads
+core/iwasm/libraries/lib-wasi-threads/**/*.aot
+core/iwasm/libraries/lib-wasi-threads/**/*.wasm

core/config.h

@@ -84,7 +84,8 @@
 #endif
 
 #define AOT_MAGIC_NUMBER 0x746f6100
-#define AOT_CURRENT_VERSION 3
+/* FIXME: remove me when merged into main */
+#define AOT_CURRENT_VERSION 4
 
 #ifndef WASM_ENABLE_JIT
 #define WASM_ENABLE_JIT 0

core/iwasm/aot/aot_loader.c

@@ -506,6 +506,14 @@ check_feature_flags(char *error_buf, uint32 error_buf_size,
     }
 #endif
 
+#if WASM_ENABLE_MULTI_MODULE == 0
+    if (feature_flags & WASM_FEATURE_MULTI_MODULE) {
+        set_error_buf(error_buf, error_buf_size,
+                      "multi-module is not enabled in this build");
+        return false;
+    }
+#endif
+
     return true;
 }
 
@@ -529,7 +537,7 @@ load_target_info_section(const uint8 *buf, const uint8 *buf_end,
                          AOTModule *module, char *error_buf,
                          uint32 error_buf_size)
 {
-    AOTTargetInfo target_info;
+    AOTTargetInfo target_info = { 0 };
     const uint8 *p = buf, *p_end = buf_end;
     bool is_target_little_endian, is_target_64_bit;
 
@@ -988,18 +996,17 @@ load_mem_init_data_list(const uint8 **p_buf, const uint8 *buf_end,
 {
     const uint8 *buf = *p_buf;
     AOTMemInitData **data_list;
-    uint64 size;
-    uint32 i;
 
     /* Allocate memory */
-    size = sizeof(AOTMemInitData *) * (uint64)module->mem_init_data_count;
+    uint64 size =
+        sizeof(AOTMemInitData *) * (uint64)module->mem_init_data_count;
     if (!(module->mem_init_data_list = data_list =
               loader_malloc(size, error_buf, error_buf_size))) {
         return false;
     }
 
     /* Create each memory data segment */
-    for (i = 0; i < module->mem_init_data_count; i++) {
+    for (uint32 i = 0; i < module->mem_init_data_count; i++) {
         uint32 byte_count;
         uint32 is_passive;
         uint32 memory_index;
@@ -1036,26 +1043,57 @@ load_mem_init_data_list(const uint8 **p_buf, const uint8 *buf_end,
 }
 
 static bool
-load_memory_info(const uint8 **p_buf, const uint8 *buf_end, AOTModule *module,
-                 char *error_buf, uint32 error_buf_size)
+load_import_memory_list(const uint8 **p_buf, const uint8 *buf_end,
+                        AOTModule *module, bool is_load_from_file_buf,
+                        char *error_buf, uint32 error_buf_size)
 {
-    uint32 i;
-    uint64 total_size;
     const uint8 *buf = *p_buf;
 
-    read_uint32(buf, buf_end, module->import_memory_count);
-    /* We don't support import_memory_count > 0 currently */
-    if (module->import_memory_count > 0)
+    uint64 size = sizeof(AOTImportMemory) * (uint64)module->import_memory_count;
+    AOTImportMemory *import_memories =
+        loader_malloc(size, error_buf, error_buf_size);
+    if (!import_memories) {
+        set_error_buf(error_buf, error_buf_size,
+                      "allocate import_memories failed");
         return false;
+    }
 
-    read_uint32(buf, buf_end, module->memory_count);
-    total_size = sizeof(AOTMemory) * (uint64)module->memory_count;
+    module->import_memories = import_memories;
+    for (uint32 i = 0; i < module->import_memory_count; i++) {
+        AOTImportMemory *import_memory = import_memories + i;
+
+        read_uint32(buf, buf_end, import_memory->mem_type.flags);
+        if (!wasm_memory_check_flags(import_memory->mem_type.flags, error_buf,
+                                     error_buf_size, true)) {
+            set_error_buf(error_buf, error_buf_size, "invalid memory flags");
+            return false;
+        }
+
+        read_uint32(buf, buf_end, import_memory->mem_type.num_bytes_per_page);
+        read_uint32(buf, buf_end, import_memory->mem_type.init_page_count);
+        read_uint32(buf, buf_end, import_memory->mem_type.max_page_count);
+        read_string(buf, buf_end, import_memory->module_name);
+        read_string(buf, buf_end, import_memory->memory_name);
+    }
+
+    *p_buf = buf;
+    return true;
+fail:
+    return false;
+}
+
+static bool
+load_memory_list(const uint8 **p_buf, const uint8 *buf_end, AOTModule *module,
+                 char *error_buf, uint32 error_buf_size)
+{
+    uint64 total_size = sizeof(AOTMemory) * (uint64)module->memory_count;
     if (!(module->memories =
               loader_malloc(total_size, error_buf, error_buf_size))) {
         return false;
     }
 
-    for (i = 0; i < module->memory_count; i++) {
+    const uint8 *buf = *p_buf;
+    for (uint32 i = 0; i < module->memory_count; i++) {
         read_uint32(buf, buf_end, module->memories[i].flags);
 
         if (!wasm_memory_check_flags(module->memories[i].flags, error_buf,
@@ -1068,13 +1106,43 @@ load_memory_info(const uint8 **p_buf, const uint8 *buf_end, AOTModule *module,
         read_uint32(buf, buf_end, module->memories[i].max_page_count);
     }
 
-    read_uint32(buf, buf_end, module->mem_init_data_count);
+    *p_buf = buf;
+    return true;
+fail:
+    return false;
+}
 
-    /* load memory init data list */
-    if (module->mem_init_data_count > 0
-        && !load_mem_init_data_list(&buf, buf_end, module, error_buf,
-                                    error_buf_size))
-        return false;
+static bool
+load_memory_info(const uint8 **p_buf, const uint8 *buf_end, AOTModule *module,
+                 bool is_load_from_file_buf, char *error_buf,
+                 uint32 error_buf_size)
+{
+    const uint8 *buf = *p_buf;
+
+    read_uint32(buf, buf_end, module->import_memory_count);
+    if (module->import_memory_count > 0) {
+        if (!load_import_memory_list(&buf, buf_end, module,
+                                     is_load_from_file_buf, error_buf,
+                                     error_buf_size)) {
+            return false;
+        }
+    }
+
+    read_uint32(buf, buf_end, module->memory_count);
+    if (module->memory_count > 0) {
+        if (!load_memory_list(&buf, buf_end, module, error_buf,
+                              error_buf_size)) {
+            return false;
+        }
+    }
+
+    read_uint32(buf, buf_end, module->mem_init_data_count);
+    if (module->mem_init_data_count > 0) {
+        if (!load_mem_init_data_list(&buf, buf_end, module, error_buf,
+                                     error_buf_size)) {
+            return false;
+        }
+    }
 
     *p_buf = buf;
     return true;
@@ -1305,8 +1373,8 @@ load_init_expr(const uint8 **p_buf, const uint8 *buf_end, AOTModule *module,
 
 static bool
 load_import_table_list(const uint8 **p_buf, const uint8 *buf_end,
-                       AOTModule *module, char *error_buf,
-                       uint32 error_buf_size)
+                       AOTModule *module, bool is_load_from_file_buf,
+                       char *error_buf, uint32 error_buf_size)
 {
     const uint8 *buf = *p_buf;
     AOTImportTable *import_table;
@@ -1323,7 +1391,7 @@ load_import_table_list(const uint8 **p_buf, const uint8 *buf_end,
         return false;
     }
 
-    /* keep sync with aot_emit_table_info() aot_emit_aot_file */
+    /* keep sync with aot_emit_import_table_info() aot_emit_aot_file */
     for (i = 0; i < module->import_table_count; i++, import_table++) {
         read_uint8(buf, buf_end, import_table->table_type.elem_type);
         read_uint8(buf, buf_end, import_table->table_type.flags);
@@ -1332,6 +1400,13 @@ load_import_table_list(const uint8 **p_buf, const uint8 *buf_end,
         if (wasm_is_type_multi_byte_type(import_table->table_type.elem_type)) {
             read_uint8(buf, buf_end, ref_type.ref_ht_common.nullable);
         }
+#else
+        {
+            /* TBC: placeholder */
+            uint8 placeholder;
+            read_uint8(buf, buf_end, placeholder);
+            (void)placeholder;
+        }
 #endif
         read_uint32(buf, buf_end, import_table->table_type.init_size);
         read_uint32(buf, buf_end, import_table->table_type.max_size);
@@ -1350,6 +1425,12 @@ load_import_table_list(const uint8 **p_buf, const uint8 *buf_end,
             }
         }
 #endif
+
+        /* v3 doesn't emit names */
+        if (module->package_version >= 4) {
+            read_string(buf, buf_end, import_table->module_name);
+            read_string(buf, buf_end, import_table->table_name);
+        }
     }
 
     *p_buf = buf;
@@ -1392,6 +1473,13 @@ load_table_list(const uint8 **p_buf, const uint8 *buf_end, AOTModule *module,
         if (wasm_is_type_multi_byte_type(table->table_type.elem_type)) {
             read_uint8(buf, buf_end, ref_type.ref_ht_common.nullable);
         }
+#else
+        {
+            /* TBC: placeholder */
+            uint8 placeholder;
+            read_uint8(buf, buf_end, placeholder);
+            (void)placeholder;
+        }
 #endif
         read_uint32(buf, buf_end, table->table_type.init_size);
         read_uint32(buf, buf_end, table->table_type.max_size);
@@ -1523,14 +1611,15 @@ load_table_init_data_list(const uint8 **p_buf, const uint8 *buf_end,
 
 static bool
 load_table_info(const uint8 **p_buf, const uint8 *buf_end, AOTModule *module,
-                char *error_buf, uint32 error_buf_size)
+                bool is_load_from_file_buf, char *error_buf,
+                uint32 error_buf_size)
 {
     const uint8 *buf = *p_buf;
 
     read_uint32(buf, buf_end, module->import_table_count);
     if (module->import_table_count > 0
-        && !load_import_table_list(&buf, buf_end, module, error_buf,
-                                   error_buf_size))
+        && !load_import_table_list(&buf, buf_end, module, is_load_from_file_buf,
+                                   error_buf, error_buf_size))
         return false;
 
     read_uint32(buf, buf_end, module->table_count);
@@ -2084,24 +2173,26 @@ load_import_globals(const uint8 **p_buf, const uint8 *buf_end,
             return false;
         }
 
-#if WASM_ENABLE_LIBC_BUILTIN != 0
-        if (wasm_native_lookup_libc_builtin_global(
-                import_globals[i].module_name, import_globals[i].global_name,
-                &tmp_global)) {
-            if (tmp_global.type.val_type != import_globals[i].type.val_type
-                || tmp_global.type.is_mutable
-                       != import_globals[i].type.is_mutable) {
-                set_error_buf(error_buf, error_buf_size,
-                              "incompatible import type");
-                return false;
-            }
-            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
+        /*TODO: move to built-in linker */
+        // #if WASM_ENABLE_LIBC_BUILTIN != 0
+        //         if (wasm_native_lookup_libc_builtin_global(
+        //                 import_globals[i].module_name,
+        //                 import_globals[i].global_name, &tmp_global)) {
+        //             if (tmp_global.type.val_type !=
+        //             import_globals[i].type.val_type
+        //                 || tmp_global.type.is_mutable
+        //                        != import_globals[i].type.is_mutable) {
+        //                 set_error_buf(error_buf, error_buf_size,
+        //                               "incompatible import type");
+        //                 return false;
+        //             }
+        //             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.val_type);
@@ -2414,8 +2505,10 @@ load_init_data_section(const uint8 *buf, const uint8 *buf_end,
 {
     const uint8 *p = buf, *p_end = buf_end;
 
-    if (!load_memory_info(&p, p_end, module, error_buf, error_buf_size)
-        || !load_table_info(&p, p_end, module, error_buf, error_buf_size)
+    if (!load_memory_info(&p, p_end, module, is_load_from_file_buf, error_buf,
+                          error_buf_size)
+        || !load_table_info(&p, p_end, module, is_load_from_file_buf, error_buf,
+                            error_buf_size)
         || !load_type_info(&p, p_end, module, error_buf, error_buf_size)
         || !load_import_global_info(&p, p_end, module, is_load_from_file_buf,
                                     error_buf, error_buf_size)