Merge pull request #408 from bytecodealliance/main

Merge bytecodealliance:main into wenyongh:main

Author: wenyongh

README.md

@@ -29,6 +29,7 @@ iwasm VM core
 - [Thread management and pthread library](./doc/pthread_library.md), ref to [sample](samples/multi-thread)
 - [Linux SGX (Intel Software Guard Extension) support](./doc/linux_sgx.md)
 - [Source debugging](./doc/source_debugging.md)
+- [XIP (Execution In Place) support](./doc/xip.md)
 
 ### post-MVP features
 - [Non-trapping float-to-int conversions](https://github.com/WebAssembly/nontrapping-float-to-int-conversions)

build-scripts/config_common.cmake

@@ -61,9 +61,13 @@ if (CMAKE_SIZEOF_VOID_P EQUAL 8)
       set (CMAKE_SHARED_LIBRARY_LINK_C_FLAGS "${CMAKE_SHARED_LIBRARY_LINK_C_FLAGS} -fPIC")
     endif ()
   else ()
-    add_definitions (-m32)
-    set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -m32")
-    set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -m32")
+    include(CheckCCompilerFlag)
+    Check_C_Compiler_Flag( -m32  M32_OK )
+    if (M32_OK)
+      add_definitions (-m32)
+      set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -m32")
+      set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -m32")
+    endif ()
   endif ()
 endif ()
 

core/iwasm/aot/aot_loader.c

@@ -2190,13 +2190,16 @@ load_relocation_section(const uint8 *buf, const uint8 *buf_end,
             || !strcmp(group->section_name, ".text")
 #endif
         ) {
+#if !defined(BH_PLATFORM_LINUX) && !defined(BH_PLATFORM_LINUX_SGX) \
+    && !defined(BH_PLATFORM_DARWIN)
             if (module->native_symbol_count > 0) {
                 set_error_buf(error_buf, error_buf_size,
                               "cannot apply relocation to text section "
                               "for aot file generated with "
                               "\"--enable-indirect-mode\" flag");
                 goto fail;
             }
+#endif
             if (!do_text_relocation(module, group, error_buf, error_buf_size))
                 goto fail;
         }

core/iwasm/common/wasm_exec_env.c

@@ -148,9 +148,6 @@ wasm_exec_env_create(struct WASMModuleInstanceCommon *module_inst,
         wasm_exec_env_destroy_internal(exec_env);
         return NULL;
     }
-#if WASM_ENABLE_DEBUG_INTERP != 0
-    wasm_debug_instance_create(cluster);
-#endif
 #endif /* end of WASM_ENABLE_THREAD_MGR */
 
     return exec_env;
@@ -165,7 +162,6 @@ wasm_exec_env_destroy(WASMExecEnv *exec_env)
     if (cluster) {
 #if WASM_ENABLE_DEBUG_INTERP != 0
         wasm_cluster_thread_exited(exec_env);
-        wasm_debug_instance_destroy(cluster);
 #endif
         wasm_cluster_terminate_all_except_self(cluster, exec_env);
         wasm_cluster_del_exec_env(cluster, exec_env);

core/iwasm/common/wasm_runtime_common.c

@@ -294,6 +294,84 @@ get_package_type(const uint8 *buf, uint32 size)
     return Package_Type_Unknown;
 }
 
+#if WASM_ENABLE_AOT != 0
+static uint8 *
+align_ptr(const uint8 *p, uint32 b)
+{
+    uintptr_t v = (uintptr_t)p;
+    uintptr_t m = b - 1;
+    return (uint8 *)((v + m) & ~m);
+}
+
+#define CHECK_BUF(buf, buf_end, length)                   \
+    do {                                                  \
+        if (buf + length < buf || buf + length > buf_end) \
+            return false;                                 \
+    } while (0)
+
+#define read_uint32(p, p_end, res)                 \
+    do {                                           \
+        p = (uint8 *)align_ptr(p, sizeof(uint32)); \
+        CHECK_BUF(p, p_end, sizeof(uint32));       \
+        res = *(uint32 *)p;                        \
+        p += sizeof(uint32);                       \
+    } while (0)
+
+bool
+wasm_runtime_is_xip_file(const uint8 *buf, uint32 size)
+{
+    const uint8 *p = buf, *p_end = buf + size;
+    uint32 section_type, sub_section_type, section_size;
+
+    if (get_package_type(buf, size) != Wasm_Module_AoT)
+        return false;
+
+    CHECK_BUF(p, p_end, 8);
+    p += 8;
+    while (p < p_end) {
+        read_uint32(p, p_end, section_type);
+        read_uint32(p, p_end, section_size);
+        CHECK_BUF(p, p_end, section_size);
+
+        if (section_type == AOT_SECTION_TYPE_CUSTOM) {
+            read_uint32(p, p_end, sub_section_type);
+            if (sub_section_type == AOT_CUSTOM_SECTION_NATIVE_SYMBOL) {
+                return true;
+            }
+            else {
+                p -= sizeof(uint32);
+            }
+        }
+        else if (section_type >= AOT_SECTION_TYPE_SIGANATURE) {
+            return false;
+        }
+        p += section_size;
+    }
+
+    return false;
+}
+#endif /* end of WASM_ENABLE_AOT */
+
+#if (WASM_ENABLE_THREAD_MGR != 0) && (WASM_ENABLE_DEBUG_INTERP != 0)
+uint32
+wasm_runtime_start_debug_instance(WASMExecEnv *exec_env)
+{
+    WASMCluster *cluster = wasm_exec_env_get_cluster(exec_env);
+    bh_assert(cluster);
+
+    if (cluster->debug_inst) {
+        LOG_WARNING("Cluster already bind to a debug instance");
+        return cluster->debug_inst->control_thread->port;
+    }
+
+    if (wasm_debug_instance_create(cluster)) {
+        return cluster->debug_inst->control_thread->port;
+    }
+
+    return 0;
+}
+#endif
+
 #if WASM_ENABLE_MULTI_MODULE != 0
 static module_reader reader;
 static module_destroyer destroyer;
@@ -1431,7 +1509,7 @@ wasm_runtime_create_exec_env_and_call_wasm(
     if (module_inst->module_type == Wasm_Module_Bytecode)
         ret = wasm_create_exec_env_and_call_function(
             (WASMModuleInstance *)module_inst, (WASMFunctionInstance *)function,
-            argc, argv);
+            argc, argv, true);
 #endif
 #if WASM_ENABLE_AOT != 0
     if (module_inst->module_type == Wasm_Module_AoT)

core/iwasm/common/wasm_runtime_common.h

@@ -406,6 +406,10 @@ wasm_runtime_destroy(void);
 WASM_RUNTIME_API_EXTERN PackageType
 get_package_type(const uint8 *buf, uint32 size);
 
+/* See wasm_export.h for description */
+WASM_RUNTIME_API_EXTERN bool
+wasm_runtime_is_xip_file(const uint8 *buf, uint32 size);
+
 /* See wasm_export.h for description */
 WASM_RUNTIME_API_EXTERN WASMModuleCommon *
 wasm_runtime_load(const uint8 *buf, uint32 size, char *error_buf,
@@ -494,6 +498,12 @@ wasm_runtime_call_wasm_v(WASMExecEnv *exec_env,
                          uint32 num_results, wasm_val_t *results,
                          uint32 num_args, ...);
 
+#if WASM_ENABLE_DEBUG_INTERP != 0
+/* See wasm_export.h for description */
+WASM_RUNTIME_API_EXTERN uint32
+wasm_runtime_start_debug_instance(WASMExecEnv *exec_env);
+#endif
+
 /**
  * Call a function reference of a given WASM runtime instance with
  * arguments.

core/iwasm/include/wasm_export.h

@@ -235,6 +235,17 @@ wasm_runtime_free(void *ptr);
 WASM_RUNTIME_API_EXTERN package_type_t
 get_package_type(const uint8_t *buf, uint32_t size);
 
+/**
+ * Check whether a file is an AOT XIP (Execution In Place) file
+ *
+ * @param buf the package buffer
+ * @param size the package buffer size
+ *
+ * @return true if success, false otherwise
+ */
+WASM_RUNTIME_API_EXTERN bool
+wasm_runtime_is_xip_file(const uint8_t *buf, uint32_t size);
+
 /**
  * It is a callback for WAMR providing by embedding to load a module file
  * into a buffer
@@ -408,6 +419,26 @@ wasm_runtime_create_exec_env(wasm_module_inst_t module_inst,
 WASM_RUNTIME_API_EXTERN void
 wasm_runtime_destroy_exec_env(wasm_exec_env_t exec_env);
 
+/**
+ * Start debug instance based on given execution environment.
+ * Note:
+ *   The debug instance will be destroyed during destroying the
+ *   execution environment, developers don't need to destroy it
+ *   manually.
+ *   If the cluster of this execution environment has already
+ *   been bound to a debug instance, this function will return true
+ *   directly.
+ *   If developer spawns some exec_env by wasm_runtime_spawn_exec_env,
+ *   don't need to call this function for every spawned exec_env as
+ *   they are sharing the same cluster with the main exec_env.
+ *
+ * @param exec_env the execution environment to start debug instance
+ *
+ * @return debug port if success, 0 otherwise.
+ */
+WASM_RUNTIME_API_EXTERN uint32_t
+wasm_runtime_start_debug_instance(wasm_exec_env_t exec_env);
+
 /**
  * Initialize thread environment.
  * Note:

core/iwasm/interpreter/wasm.h

@@ -419,6 +419,20 @@ struct WASMModule {
     uint64 buf_code_size;
 #endif
 
+#if WASM_ENABLE_DEBUG_INTERP != 0
+    /**
+     * Count how many instances reference this module. When source
+     * debugging feature enabled, the debugger may modify the code
+     * section of the module, so we need to report a warning if user
+     * create several instances based on the same module
+     *
+     * Sub_instances created by lib-pthread or spawn API will not
+     * influence or check the ref count
+     */
+    uint32 ref_count;
+    korp_mutex ref_count_lock;
+#endif
+
 #if WASM_ENABLE_CUSTOM_NAME_SECTION != 0
     const uint8 *name_section_buf;
     const uint8 *name_section_buf_end;

core/iwasm/interpreter/wasm_loader.c

@@ -3237,6 +3237,10 @@ create_module(char *error_buf, uint32 error_buf_size)
 #endif
 #if WASM_ENABLE_DEBUG_INTERP != 0
     bh_list_init(&module->fast_opcode_list);
+    if (os_mutex_init(&module->ref_count_lock) != 0) {
+        wasm_runtime_free(module);
+        return NULL;
+    }
 #endif
     return module;
 }
@@ -3568,6 +3572,7 @@ wasm_loader_unload(WASMModule *module)
         wasm_runtime_free(fast_opcode);
         fast_opcode = next;
     }
+    os_mutex_destroy(&module->ref_count_lock);
 #endif
     wasm_runtime_free(module);
 }

core/iwasm/interpreter/wasm_runtime.c

@@ -900,7 +900,7 @@ execute_post_inst_function(WASMModuleInstance *module_inst)
         return true;
 
     return wasm_create_exec_env_and_call_function(module_inst, post_inst_func,
-                                                  0, NULL);
+                                                  0, NULL, false);
 }
 
 #if WASM_ENABLE_BULK_MEMORY != 0
@@ -929,7 +929,7 @@ execute_memory_init_function(WASMModuleInstance *module_inst)
         return true;
 
     return wasm_create_exec_env_and_call_function(module_inst, memory_init_func,
-                                                  0, NULL);
+                                                  0, NULL, false);
 }
 #endif
 
@@ -944,7 +944,8 @@ execute_start_function(WASMModuleInstance *module_inst)
     bh_assert(!func->is_import_func && func->param_cell_num == 0
               && func->ret_cell_num == 0);
 
-    return wasm_create_exec_env_and_call_function(module_inst, func, 0, NULL);
+    return wasm_create_exec_env_and_call_function(module_inst, func, 0, NULL,
+                                                  false);
 }
 
 static bool
@@ -972,11 +973,11 @@ execute_malloc_function(WASMModuleInstance *module_inst,
     }
 
     ret = wasm_create_exec_env_and_call_function(module_inst, malloc_func, argc,
-                                                 argv);
+                                                 argv, false);
 
     if (retain_func && ret) {
         ret = wasm_create_exec_env_and_call_function(module_inst, retain_func,
-                                                     1, argv);
+                                                     1, argv, false);
     }
 
     if (ret)
@@ -992,7 +993,7 @@ execute_free_function(WASMModuleInstance *module_inst,
 
     argv[0] = offset;
     return wasm_create_exec_env_and_call_function(module_inst, free_func, 1,
-                                                  argv);
+                                                  argv, false);
 }
 
 #if WASM_ENABLE_MULTI_MODULE != 0
@@ -1125,6 +1126,19 @@ wasm_instantiate(WASMModule *module, bool is_sub_inst, uint32 stack_size,
     if (!module)
         return NULL;
 
+#if WASM_ENABLE_DEBUG_INTERP != 0
+    if (!is_sub_inst) {
+        os_mutex_lock(&module->ref_count_lock);
+        if (module->ref_count != 0) {
+            LOG_WARNING(
+                "warning: multiple instances referencing the same module may "
+                "cause unexpected behaviour during debugging");
+        }
+        module->ref_count++;
+        os_mutex_unlock(&module->ref_count_lock);
+    }
+#endif
+
     /* Check heap size */
     heap_size = align_uint(heap_size, 8);
     if (heap_size > APP_HEAP_SIZE_MAX)
@@ -1133,6 +1147,13 @@ wasm_instantiate(WASMModule *module, bool is_sub_inst, uint32 stack_size,
     /* Allocate the memory */
     if (!(module_inst = runtime_malloc(sizeof(WASMModuleInstance), error_buf,
                                        error_buf_size))) {
+#if WASM_ENABLE_DEBUG_INTERP != 0
+        if (!is_sub_inst) {
+            os_mutex_lock(&module->ref_count_lock);
+            module->ref_count--;
+            os_mutex_unlock(&module->ref_count_lock);
+        }
+#endif
         return NULL;
     }
 
@@ -1519,7 +1540,9 @@ wasm_instantiate(WASMModule *module, bool is_sub_inst, uint32 stack_size,
         (WASMModuleInstanceCommon *)module_inst);
 #endif
     (void)global_data_end;
+
     return module_inst;
+
 fail:
     wasm_deinstantiate(module_inst, false);
     return NULL;
@@ -1576,6 +1599,14 @@ wasm_deinstantiate(WASMModuleInstance *module_inst, bool is_sub_inst)
     }
 #endif
 
+#if WASM_ENABLE_DEBUG_INTERP != 0
+    if (!is_sub_inst) {
+        os_mutex_lock(&module_inst->module->ref_count_lock);
+        module_inst->module->ref_count--;
+        os_mutex_unlock(&module_inst->module->ref_count_lock);
+    }
+#endif
+
     wasm_runtime_free(module_inst);
 }
 
@@ -1661,7 +1692,8 @@ wasm_call_function(WASMExecEnv *exec_env, WASMFunctionInstance *function,
 bool
 wasm_create_exec_env_and_call_function(WASMModuleInstance *module_inst,
                                        WASMFunctionInstance *func,
-                                       unsigned argc, uint32 argv[])
+                                       unsigned argc, uint32 argv[],
+                                       bool enable_debug)
 {
     WASMExecEnv *exec_env;
     bool ret;
@@ -1680,6 +1712,11 @@ wasm_create_exec_env_and_call_function(WASMModuleInstance *module_inst,
         }
 
 #if WASM_ENABLE_THREAD_MGR != 0
+        if (enable_debug) {
+#if WASM_ENABLE_DEBUG_INTERP != 0
+            wasm_runtime_start_debug_instance(exec_env);
+#endif
+        }
     }
 #endif