mono/utils/mono-threads-wasm.c

   1 #include "config.h"
   2
   3 #include <mono/utils/mono-threads.h>
   4 #include <mono/utils/mono-mmap.h>
   5
   6
   7 #if defined (USE_WASM_BACKEND)
   8
   9 #include <mono/utils/mono-threads.h>
  10 #include <mono/utils/mono-mmap.h>
  11
  12 #include <emscripten.h>
  13 #include <glib.h>
  14
  15 #define round_down(addr, val) ((void*)((addr) & ~((val) - 1)))
  16
  17 EMSCRIPTEN_KEEPALIVE
  18 static int
  19 wasm_get_stack_base (void)
  20 {
  21         // Return the bottom limit of the stack
  22         return EM_ASM_INT ({
  23                 return STACK_MAX;
  24         });
  25 }
  26
  27 EMSCRIPTEN_KEEPALIVE
  28 static int
  29 wasm_get_stack_size (void)
  30 {
  31         return EM_ASM_INT ({
  32                 return TOTAL_STACK;
  33         });
  34 }
  35
  36 int
  37 mono_thread_info_get_system_max_stack_size (void)
  38 {
  39         return wasm_get_stack_size ();
  40 }
  41
  42
  43 void
  44 mono_threads_suspend_init_signals (void)
  45 {
  46 }
  47
  48 void
  49 mono_threads_suspend_init (void)
  50 {
  51 }
  52
  53 void
  54 mono_threads_suspend_register (MonoThreadInfo *info)
  55 {
  56 }
  57
  58 gboolean
  59 mono_threads_suspend_begin_async_resume (MonoThreadInfo *info)
  60 {
  61         return TRUE;
  62 }
  63
  64 void
  65 mono_threads_suspend_free (MonoThreadInfo *info)
  66 {
  67 }
  68
  69 gboolean
  70 mono_threads_suspend_begin_async_suspend (MonoThreadInfo *info, gboolean interrupt_kernel)
  71 {
  72         return TRUE;
  73 }
  74
  75 gboolean
  76 mono_threads_suspend_check_suspend_result (MonoThreadInfo *info)
  77 {
  78         return TRUE;
  79 }
  80
  81 void
  82 mono_threads_suspend_abort_syscall (MonoThreadInfo *info)
  83 {
  84 }
  85
  86 //----
  87
  88 gboolean
  89 mono_native_thread_id_equals (MonoNativeThreadId id1, MonoNativeThreadId id2)
  90 {
  91         return id1 == id2;
  92 }
  93
  94
  95 MonoNativeThreadId
  96 mono_native_thread_id_get (void)
  97 {
  98         return (MonoNativeThreadId)1;
  99 }
 100
 101 MONO_API gboolean
 102 mono_native_thread_create (MonoNativeThreadId *tid, gpointer func, gpointer arg)
 103 {
 104         g_error ("WASM doesn't support threading");
 105 }
 106
 107 static const char *thread_name;
 108
 109 void
 110 mono_native_thread_set_name (MonoNativeThreadId tid, const char *name)
 111 {
 112         thread_name = g_strdup (name);
 113 }
 114
 115 gboolean
 116 mono_native_thread_join (MonoNativeThreadId tid)
 117 {
 118         g_error ("WASM doesn't support threading");
 119         return FALSE;
 120 }
 121
 122 //----
 123
 124 gboolean
 125 mono_threads_platform_yield (void)
 126 {
 127         return TRUE;
 128 }
 129
 130 void
 131 mono_threads_platform_get_stack_bounds (guint8 **staddr, size_t *stsize)
 132 {
 133         *staddr = (guint8*)wasm_get_stack_base ();
 134         *stsize = wasm_get_stack_size ();
 135 }
 136
 137
 138 gboolean
 139 mono_thread_platform_create_thread (MonoThreadStart thread_fn, gpointer thread_data, gsize* const stack_size, MonoNativeThreadId *tid)
 140 {
 141         g_warning ("WASM doesn't support threading");
 142         return FALSE;
 143 }
 144
 145 void mono_threads_platform_init (void)
 146 {
 147 }
 148
 149 void
 150 mono_threads_platform_exit (gsize exit_code)
 151 {
 152         g_error ("WASM doesn't support threading");
 153 }
 154
 155 gboolean
 156 mono_threads_platform_in_critical_region (THREAD_INFO_TYPE *info)
 157 {
 158         return FALSE;
 159 }
 160
 161 G_EXTERN_C
 162 extern void schedule_background_exec (void);
 163
 164 static GSList *jobs;
 165
 166 void
 167 mono_threads_schedule_background_job (background_job_cb cb)
 168 {
 169         if (!jobs)
 170                 schedule_background_exec ();
 171
 172         if (!g_slist_find (jobs, (gconstpointer)cb))
 173                 jobs = g_slist_prepend (jobs, (gpointer)cb);
 174 }
 175
 176 G_EXTERN_C
 177 EMSCRIPTEN_KEEPALIVE void
 178 mono_background_exec (void)
 179 {
 180         GSList *j = jobs, *cur;
 181         jobs = NULL;
 182
 183         for (cur = j; cur; cur = cur->next) {
 184                 background_job_cb cb = (background_job_cb)cur->data;
 185                 cb ();
 186         }
 187         g_slist_free (j);
 188 }
 189
 190 void
 191 mono_memory_barrier_process_wide (void)
 192 {
 193 }
 194
 195 #endif