Update simple test

 * don't assume the return value of the `__wasi_thread_spawn` API should be zero; assert on thread ID
 * implement wasi_thread_start in ASM to avoid potential stack corruption

Author: loganek

test/build.sh

@@ -7,6 +7,6 @@ for input in testsuite/*.c; do
 
   if [ "$input" -nt "$output" ]; then
     echo "Compiling $input"
-    $CC "$input" -o "$output"
+    $CC "$input" testsuite/wasi_thread_spawn.S -o "$output"
   fi
 done

test/testsuite/thread_spawn-simple.c

@@ -1,9 +1,12 @@
 #include <assert.h>
+#include <stdlib.h>
 #include <wasi/api.h>
 
 static const int64_t SECOND = 1000 * 1000 * 1000;
 
-typedef struct {
+typedef struct
+{
+    char *stack;
     int th_ready;
     int th_continue;
     int th_done;
@@ -12,16 +15,16 @@ typedef struct {
     int value;
 } shared_t;
 
-__attribute__((export_name("wasi_thread_start"))) void
-wasi_thread_start(int thread_id, int *start_arg)
+void __wasi_thread_start_C(int thread_id, int *start_arg)
 {
     shared_t *data = (shared_t *)start_arg;
 
     data->th_ready = 1;
     __builtin_wasm_memory_atomic_notify(&data->th_ready, 1);
 
     // so we can have all the threads alive at the same time
-    if (__builtin_wasm_memory_atomic_wait32(&data->th_continue, 0, SECOND) == 2) {
+    if (__builtin_wasm_memory_atomic_wait32(&data->th_continue, 0, SECOND) == 2)
+    {
         data->failed = 1;
         return;
     }
@@ -35,36 +38,42 @@ wasi_thread_start(int thread_id, int *start_arg)
     __builtin_wasm_memory_atomic_notify(&data->th_done, 1);
 }
 
-int
-main(int argc, char **argv)
+int main(int argc, char **argv)
 {
-    shared_t data[3] = { 0 };
+    shared_t data[3] = {0};
+    int tid[3];
     int data_count = sizeof(data) / sizeof(data[0]);
     int i, j;
 
-    for (i = 0; i < data_count; i++) {
+    for (i = 0; i < data_count; i++)
+    {
+        data[i].stack = malloc(128);
         data[i].value = 52;
-        assert(__wasi_thread_spawn(&data[i]) == 0);
+        tid[i] = __wasi_thread_spawn(&data[i]);
+        assert(tid[i] > 0);
         assert(__builtin_wasm_memory_atomic_wait32(&data[i].th_ready, 0,
-                                                   SECOND)
-               != 2); // not a timeout
+                                                   SECOND) != 2); // not a timeout
     }
 
-    for (i = 0; i < data_count; i++) {
+    for (i = 0; i < data_count; i++)
+    {
         __builtin_wasm_memory_atomic_notify(&data[i].th_continue, 1);
     }
 
-    for (i = 0; i < data_count; i++) {
+    for (i = 0; i < data_count; i++)
+    {
         assert(__builtin_wasm_memory_atomic_wait32(&data[i].th_done, 0,
-                                                   SECOND)
-               != 2); // not a timeout
+                                                   SECOND) != 2); // not a timeout
+        assert(data[i].tid == tid[i]);
         assert(data[i].value == 60);
 
-        for (j = i + 1; j < data_count; j++) {
+        for (j = i + 1; j < data_count; j++)
+        {
             assert(data[i].tid != data[j].tid);
         }
 
         assert(data[i].failed == 0);
+        free(data[i].stack);
     }
 
     return 0;

test/testsuite/wasi_thread_spawn.S

@@ -0,0 +1,28 @@
+# A copy of the wasi-libc implementation:
+# https://github.com/WebAssembly/wasi-libc/blob/main/libc-top-half/musl/src/thread/wasm32/wasi_thread_start.s
+	.text
+
+	.export_name	wasi_thread_start, wasi_thread_start
+
+	.globaltype	__stack_pointer, i32
+	.functype	__wasi_thread_start_C (i32, i32) -> ()
+
+	.hidden	wasi_thread_start
+	.globl	wasi_thread_start
+	.type	wasi_thread_start,@function
+
+wasi_thread_start:
+	.functype	wasi_thread_start (i32, i32) -> ()
+
+	# Set up the minimum C environment.
+	# Note: offsetof(start_arg, stack) == 0
+	local.get   1  # start_arg
+	i32.load    0  # stack
+	global.set  __stack_pointer
+
+	# Make the C function do the rest of work.
+	local.get   0  # tid
+	local.get   1  # start_arg
+	call __wasi_thread_start_C
+
+	end_function