Merge main into dev/fast_jit

Author: wenyongh

CMakeLists.txt

@@ -25,9 +25,11 @@ if (NOT DEFINED WAMR_BUILD_TARGET)
   elseif (CMAKE_SIZEOF_VOID_P EQUAL 8)
     # Build as X86_64 by default in 64-bit platform
     set (WAMR_BUILD_TARGET "X86_64")
-  else ()
+  elseif (CMAKE_SIZEOF_VOID_P EQUAL 4)
     # Build as X86_32 by default in 32-bit platform
     set (WAMR_BUILD_TARGET "X86_32")
+  else ()
+    message(SEND_ERROR "Unsupported build target platform!")
   endif ()
 endif ()
 

build-scripts/runtime_lib.cmake

@@ -41,9 +41,11 @@ if (NOT DEFINED WAMR_BUILD_TARGET)
     elseif (CMAKE_SIZEOF_VOID_P EQUAL 8)
         # Build as X86_64 by default in 64-bit platform
         set (WAMR_BUILD_TARGET "X86_64")
-    else ()
+    elseif (CMAKE_SIZEOF_VOID_P EQUAL 4)
         # Build as X86_32 by default in 32-bit platform
         set (WAMR_BUILD_TARGET "X86_32")
+    else ()
+        message(SEND_ERROR "Unsupported build target platform!")
     endif ()
 endif ()
 

core/iwasm/aot/aot_runtime.c

@@ -1511,7 +1511,9 @@ aot_call_function(WASMExecEnv *exec_env, AOTFunctionInstance *function,
 
 #if WASM_ENABLE_DUMP_CALL_STACK != 0
         if (!ret) {
-            aot_dump_call_stack(exec_env);
+            if (aot_create_call_stack(exec_env)) {
+                aot_dump_call_stack(exec_env, true, NULL, 0);
+            }
         }
 #endif
 
@@ -1568,7 +1570,9 @@ aot_call_function(WASMExecEnv *exec_env, AOTFunctionInstance *function,
 
 #if WASM_ENABLE_DUMP_CALL_STACK != 0
         if (aot_get_exception(module_inst)) {
-            aot_dump_call_stack(exec_env);
+            if (aot_create_call_stack(exec_env)) {
+                aot_dump_call_stack(exec_env, true, NULL, 0);
+            }
         }
 #endif
 
@@ -3018,38 +3022,24 @@ aot_free_frame(WASMExecEnv *exec_env)
                  || (WASM_ENABLE_PERF_PROFILING != 0) */
 
 #if WASM_ENABLE_DUMP_CALL_STACK != 0
-void
-aot_dump_call_stack(WASMExecEnv *exec_env)
+bool
+aot_create_call_stack(struct WASMExecEnv *exec_env)
 {
     AOTFrame *cur_frame = (AOTFrame *)exec_env->cur_frame,
              *first_frame = cur_frame;
     AOTModuleInstance *module_inst = (AOTModuleInstance *)exec_env->module_inst;
-    const char *func_name;
     uint32 n = 0;
 
-    os_printf("\n");
     while (cur_frame) {
-        func_name =
-            get_func_name_from_index(module_inst, cur_frame->func_index);
-
-        /* function name not exported, print number instead */
-        if (func_name == NULL) {
-            os_printf("#%02d $f%d \n", n, cur_frame->func_index);
-        }
-        else {
-            os_printf("#%02d %s \n", n, func_name);
-        }
-
         cur_frame = cur_frame->prev_frame;
         n++;
     }
-    os_printf("\n");
 
     /* release previous stack frames and create new ones */
     if (!bh_vector_destroy(module_inst->frames.ptr)
         || !bh_vector_init(module_inst->frames.ptr, n, sizeof(WASMCApiFrame),
                            false)) {
-        return;
+        return false;
     }
 
     cur_frame = first_frame;
@@ -3059,14 +3049,85 @@ aot_dump_call_stack(WASMExecEnv *exec_env)
         frame.module_offset = 0;
         frame.func_index = cur_frame->func_index;
         frame.func_offset = 0;
+        frame.func_name_wp =
+            get_func_name_from_index(module_inst, cur_frame->func_index);
 
         if (!bh_vector_append(module_inst->frames.ptr, &frame)) {
             bh_vector_destroy(module_inst->frames.ptr);
-            return;
+            return false;
         }
 
         cur_frame = cur_frame->prev_frame;
     }
+
+    return true;
+}
+
+#define PRINT_OR_DUMP()                                                   \
+    do {                                                                  \
+        total_len +=                                                      \
+            wasm_runtime_dump_line_buf_impl(line_buf, print, &buf, &len); \
+        if ((!print) && buf && (len == 0)) {                              \
+            return total_len;                                             \
+        }                                                                 \
+    } while (0)
+
+uint32
+aot_dump_call_stack(WASMExecEnv *exec_env, bool print, char *buf, uint32 len)
+{
+    AOTModuleInstance *module_inst = (AOTModuleInstance *)exec_env->module_inst;
+    uint32 n = 0, total_len = 0, total_frames;
+    /* reserve 256 bytes for line buffer, any line longer than 256 bytes
+     * will be truncated */
+    char line_buf[256];
+
+    if (!module_inst->frames.ptr) {
+        return 0;
+    }
+
+    total_frames = bh_vector_size(module_inst->frames.ptr);
+    if (total_frames == 0) {
+        return 0;
+    }
+
+    snprintf(line_buf, sizeof(line_buf), "\n");
+    PRINT_OR_DUMP();
+
+    while (n < total_frames) {
+        WASMCApiFrame frame = { 0 };
+        uint32 line_length, i;
+
+        if (!bh_vector_get(module_inst->frames.ptr, n, &frame)) {
+            return 0;
+        }
+
+        /* function name not exported, print number instead */
+        if (frame.func_name_wp == NULL) {
+            line_length = snprintf(line_buf, sizeof(line_buf), "#%02d $f%d\n",
+                                   n, frame.func_index);
+        }
+        else {
+            line_length = snprintf(line_buf, sizeof(line_buf), "#%02d %s\n", n,
+                                   frame.func_name_wp);
+        }
+
+        if (line_length >= sizeof(line_buf)) {
+            uint32 line_buffer_len = sizeof(line_buf);
+            /* If line too long, ensure the last character is '\n' */
+            for (i = line_buffer_len - 5; i < line_buffer_len - 2; i++) {
+                line_buf[i] = '.';
+            }
+            line_buf[line_buffer_len - 2] = '\n';
+        }
+
+        PRINT_OR_DUMP();
+
+        n++;
+    }
+    snprintf(line_buf, sizeof(line_buf), "\n");
+    PRINT_OR_DUMP();
+
+    return total_len + 1;
 }
 #endif /* end of WASM_ENABLE_DUMP_CALL_STACK */
 

core/iwasm/aot/aot_runtime.h

@@ -731,8 +731,24 @@ aot_alloc_frame(WASMExecEnv *exec_env, uint32 func_index);
 void
 aot_free_frame(WASMExecEnv *exec_env);
 
-void
-aot_dump_call_stack(WASMExecEnv *exec_env);
+bool
+aot_create_call_stack(struct WASMExecEnv *exec_env);
+
+/**
+ * @brief Dump wasm call stack or get the size
+ *
+ * @param exec_env the execution environment
+ * @param print whether to print to stdout or not
+ * @param buf buffer to store the dumped content
+ * @param len length of the buffer
+ *
+ * @return when print is true, return the bytes printed out to stdout; when
+ * print is false and buf is NULL, return the size required to store the
+ * callstack content; when print is false and buf is not NULL, return the size
+ * dumped to the buffer, 0 means error and data in buf may be invalid
+ */
+uint32
+aot_dump_call_stack(WASMExecEnv *exec_env, bool print, char *buf, uint32 len);
 
 void
 aot_dump_perf_profiling(const AOTModuleInstance *module_inst);

core/iwasm/common/wasm_runtime_common.c

@@ -3068,7 +3068,7 @@ wasm_runtime_invoke_native_raw(WASMExecEnv *exec_env, void *func_ptr,
     || defined(BUILD_TARGET_RISCV32_ILP32D)                          \
     || defined(BUILD_TARGET_RISCV32_ILP32) || defined(BUILD_TARGET_ARC)
 typedef void (*GenericFunctionPointer)();
-int64
+void
 invokeNative(GenericFunctionPointer f, uint32 *args, uint32 n_stacks);
 
 typedef float64 (*Float64FuncPtr)(GenericFunctionPointer, uint32 *, uint32);
@@ -3077,13 +3077,16 @@ typedef int64 (*Int64FuncPtr)(GenericFunctionPointer, uint32 *, uint32);
 typedef int32 (*Int32FuncPtr)(GenericFunctionPointer, uint32 *, uint32);
 typedef void (*VoidFuncPtr)(GenericFunctionPointer, uint32 *, uint32);
 
-static Float64FuncPtr invokeNative_Float64 =
+static volatile Float64FuncPtr invokeNative_Float64 =
     (Float64FuncPtr)(uintptr_t)invokeNative;
-static Float32FuncPtr invokeNative_Float32 =
+static volatile Float32FuncPtr invokeNative_Float32 =
     (Float32FuncPtr)(uintptr_t)invokeNative;
-static Int64FuncPtr invokeNative_Int64 = (Int64FuncPtr)(uintptr_t)invokeNative;
-static Int32FuncPtr invokeNative_Int32 = (Int32FuncPtr)(uintptr_t)invokeNative;
-static VoidFuncPtr invokeNative_Void = (VoidFuncPtr)(uintptr_t)invokeNative;
+static volatile Int64FuncPtr invokeNative_Int64 =
+    (Int64FuncPtr)(uintptr_t)invokeNative;
+static volatile Int32FuncPtr invokeNative_Int32 =
+    (Int32FuncPtr)(uintptr_t)invokeNative;
+static volatile VoidFuncPtr invokeNative_Void =
+    (VoidFuncPtr)(uintptr_t)invokeNative;
 
 #if defined(BUILD_TARGET_ARM_VFP) || defined(BUILD_TARGET_THUMB_VFP)
 #define MAX_REG_INTS 4
@@ -3539,7 +3542,7 @@ wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr,
     || defined(BUILD_TARGET_THUMB) || defined(BUILD_TARGET_MIPS) \
     || defined(BUILD_TARGET_XTENSA)
 typedef void (*GenericFunctionPointer)();
-int64
+void
 invokeNative(GenericFunctionPointer f, uint32 *args, uint32 sz);
 
 typedef float64 (*Float64FuncPtr)(GenericFunctionPointer f, uint32 *, uint32);
@@ -3548,13 +3551,16 @@ typedef int64 (*Int64FuncPtr)(GenericFunctionPointer f, uint32 *, uint32);
 typedef int32 (*Int32FuncPtr)(GenericFunctionPointer f, uint32 *, uint32);
 typedef void (*VoidFuncPtr)(GenericFunctionPointer f, uint32 *, uint32);
 
-static Int64FuncPtr invokeNative_Int64 = (Int64FuncPtr)invokeNative;
-static Int32FuncPtr invokeNative_Int32 = (Int32FuncPtr)(uintptr_t)invokeNative;
-static Float64FuncPtr invokeNative_Float64 =
+static volatile Int64FuncPtr invokeNative_Int64 =
+    (Int64FuncPtr)(uintptr_t)invokeNative;
+static volatile Int32FuncPtr invokeNative_Int32 =
+    (Int32FuncPtr)(uintptr_t)invokeNative;
+static volatile Float64FuncPtr invokeNative_Float64 =
     (Float64FuncPtr)(uintptr_t)invokeNative;
-static Float32FuncPtr invokeNative_Float32 =
+static volatile Float32FuncPtr invokeNative_Float32 =
     (Float32FuncPtr)(uintptr_t)invokeNative;
-static VoidFuncPtr invokeNative_Void = (VoidFuncPtr)(uintptr_t)invokeNative;
+static volatile VoidFuncPtr invokeNative_Void =
+    (VoidFuncPtr)(uintptr_t)invokeNative;
 
 static inline void
 word_copy(uint32 *dest, uint32 *src, unsigned num)
@@ -3781,33 +3787,25 @@ typedef uint32x4_t __m128i;
 #endif /* end of WASM_ENABLE_SIMD != 0 */
 
 typedef void (*GenericFunctionPointer)();
-#if defined(__APPLE__) || defined(__MACH__)
-/**
- * Define the return type as 'void' in MacOS, since after converting
- * 'int64 invokeNative' into 'float64 invokeNative_Float64', the
- * return value passing might be invalid, the caller reads the return
- * value from register rax but not xmm0.
- */
 void
 invokeNative(GenericFunctionPointer f, uint64 *args, uint64 n_stacks);
-#else
-int64
-invokeNative(GenericFunctionPointer f, uint64 *args, uint64 n_stacks);
-#endif
 
 typedef float64 (*Float64FuncPtr)(GenericFunctionPointer, uint64 *, uint64);
 typedef float32 (*Float32FuncPtr)(GenericFunctionPointer, uint64 *, uint64);
 typedef int64 (*Int64FuncPtr)(GenericFunctionPointer, uint64 *, uint64);
 typedef int32 (*Int32FuncPtr)(GenericFunctionPointer, uint64 *, uint64);
 typedef void (*VoidFuncPtr)(GenericFunctionPointer, uint64 *, uint64);
 
-static Float64FuncPtr invokeNative_Float64 =
+static volatile Float64FuncPtr invokeNative_Float64 =
     (Float64FuncPtr)(uintptr_t)invokeNative;
-static Float32FuncPtr invokeNative_Float32 =
+static volatile Float32FuncPtr invokeNative_Float32 =
     (Float32FuncPtr)(uintptr_t)invokeNative;
-static Int64FuncPtr invokeNative_Int64 = (Int64FuncPtr)(uintptr_t)invokeNative;
-static Int32FuncPtr invokeNative_Int32 = (Int32FuncPtr)(uintptr_t)invokeNative;
-static VoidFuncPtr invokeNative_Void = (VoidFuncPtr)(uintptr_t)invokeNative;
+static volatile Int64FuncPtr invokeNative_Int64 =
+    (Int64FuncPtr)(uintptr_t)invokeNative;
+static volatile Int32FuncPtr invokeNative_Int32 =
+    (Int32FuncPtr)(uintptr_t)invokeNative;
+static volatile VoidFuncPtr invokeNative_Void =
+    (VoidFuncPtr)(uintptr_t)invokeNative;
 
 #if WASM_ENABLE_SIMD != 0
 typedef v128 (*V128FuncPtr)(GenericFunctionPointer, uint64 *, uint64);
@@ -4546,21 +4544,86 @@ wasm_externref_retain(uint32 externref_idx)
 #endif /* end of WASM_ENABLE_REF_TYPES */
 
 #if WASM_ENABLE_DUMP_CALL_STACK != 0
+uint32
+wasm_runtime_dump_line_buf_impl(const char *line_buf, bool dump_or_print,
+                                char **buf, uint32 *len)
+{
+    if (dump_or_print) {
+        return (uint32)os_printf("%s", line_buf);
+    }
+    else if (*buf) {
+        uint32 dump_len;
+
+        dump_len = snprintf(*buf, *len, "%s", line_buf);
+        if (dump_len >= *len) {
+            dump_len = *len;
+        }
+
+        *len = *len - dump_len;
+        *buf = *buf + dump_len;
+        return dump_len;
+    }
+    else {
+        return strlen(line_buf);
+    }
+}
+
 void
 wasm_runtime_dump_call_stack(WASMExecEnv *exec_env)
 {
     WASMModuleInstanceCommon *module_inst =
         wasm_exec_env_get_module_inst(exec_env);
 #if WASM_ENABLE_INTERP != 0
     if (module_inst->module_type == Wasm_Module_Bytecode) {
-        wasm_interp_dump_call_stack(exec_env);
+        wasm_interp_dump_call_stack(exec_env, true, NULL, 0);
+    }
+#endif
+#if WASM_ENABLE_AOT != 0
+    if (module_inst->module_type == Wasm_Module_AoT) {
+        aot_dump_call_stack(exec_env, true, NULL, 0);
+    }
+#endif
+}
+
+uint32
+wasm_runtime_get_call_stack_buf_size(wasm_exec_env_t exec_env)
+{
+    WASMModuleInstanceCommon *module_inst =
+        wasm_exec_env_get_module_inst(exec_env);
+
+#if WASM_ENABLE_INTERP != 0
+    if (module_inst->module_type == Wasm_Module_Bytecode) {
+        return wasm_interp_dump_call_stack(exec_env, false, NULL, 0);
+    }
+#endif
+#if WASM_ENABLE_AOT != 0
+    if (module_inst->module_type == Wasm_Module_AoT) {
+        return aot_dump_call_stack(exec_env, false, NULL, 0);
+    }
+#endif
+
+    return 0;
+}
+
+uint32
+wasm_runtime_dump_call_stack_to_buf(wasm_exec_env_t exec_env, char *buf,
+                                    uint32 len)
+{
+    WASMModuleInstanceCommon *module_inst =
+        wasm_exec_env_get_module_inst(exec_env);
+
+#if WASM_ENABLE_INTERP != 0
+    if (module_inst->module_type == Wasm_Module_Bytecode) {
+        return wasm_interp_dump_call_stack(exec_env, false, buf, len);
     }
 #endif
 #if WASM_ENABLE_AOT != 0
     if (module_inst->module_type == Wasm_Module_AoT) {
-        aot_dump_call_stack(exec_env);
+        return aot_dump_call_stack(exec_env, false, buf, len);
     }
 #endif
+
+    return 0;
 }
 #endif /* end of WASM_ENABLE_DUMP_CALL_STACK */