emnapi 0.41.0 → 0.43.0

package/include/emnapi.h

@@ -1,7 +1,8 @@
 #ifndef EMNAPI_INCLUDE_EMNAPI_H_
 #define EMNAPI_INCLUDE_EMNAPI_H_
 
-#include "js_native_api.h"
+#include <stdbool.h>
+#include "js_native_api_types.h"
 #include "emnapi_common.h"
 
 typedef enum {

package/include/js_native_api.h

@@ -523,6 +523,16 @@ NAPI_EXTERN napi_status NAPI_CDECL napi_add_finalizer(napi_env env,
 
 #endif  // NAPI_VERSION >= 5
 
+#ifdef NAPI_EXPERIMENTAL
+
+NAPI_EXTERN napi_status NAPI_CDECL
+node_api_post_finalizer(napi_env env,
+                        napi_finalize finalize_cb,
+                        void* finalize_data,
+                        void* finalize_hint);
+
+#endif  // NAPI_EXPERIMENTAL
+
 #if NAPI_VERSION >= 6
 
 // BigInt

package/include/node_api.h

@@ -40,7 +40,7 @@ struct uv_loop_s;  // Forward declaration.
 
 typedef napi_value(NAPI_CDECL* napi_addon_register_func)(napi_env env,
                                                          napi_value exports);
-typedef int32_t(NAPI_CDECL* node_api_addon_get_api_version_func)();
+typedef int32_t(NAPI_CDECL* node_api_addon_get_api_version_func)(void);
 
 // Used by deprecated registration method napi_module_register.
 typedef struct napi_module {
@@ -84,7 +84,7 @@ typedef struct napi_module {
 
 #define NAPI_MODULE_INIT()                                                     \
   EXTERN_C_START                                                               \
-  NAPI_MODULE_EXPORT int32_t NODE_API_MODULE_GET_API_VERSION() {               \
+  NAPI_MODULE_EXPORT int32_t NODE_API_MODULE_GET_API_VERSION(void) {           \
     return NAPI_VERSION;                                                       \
   }                                                                            \
   NAPI_MODULE_EXPORT napi_value NAPI_MODULE_INITIALIZER(napi_env env,          \

package/include/uv.h

@@ -84,6 +84,23 @@ typedef void (*uv_thread_cb)(void* arg);
 UV_EXTERN int uv_thread_create(uv_thread_t* tid, uv_thread_cb entry, void* arg);
 UV_EXTERN int uv_thread_join(uv_thread_t *tid);
 
+typedef enum {
+  UV_THREAD_NO_FLAGS = 0x00,
+  UV_THREAD_HAS_STACK_SIZE = 0x01
+} uv_thread_create_flags;
+
+struct uv_thread_options_s {
+  unsigned int flags;
+  size_t stack_size;
+};
+
+typedef struct uv_thread_options_s uv_thread_options_t;
+
+UV_EXTERN int uv_thread_create_ex(uv_thread_t* tid,
+                                  const uv_thread_options_t* params,
+                                  uv_thread_cb entry,
+                                  void* arg);
+
 typedef void (*uv_close_cb)(uv_handle_t* handle);
 typedef void (*uv_async_cb)(uv_async_t* handle);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "emnapi",
-  "version": "0.41.0",
+  "version": "0.43.0",
   "description": "Node-API implementation for Emscripten",
   "main": "index.js",
   "peerDependencies": {

package/src/async_cleanup_hook.c

@@ -1,5 +1,5 @@
-#include "emnapi_internal.h"
 #include "node_api.h"
+#include "emnapi_internal.h"
 
 #if NAPI_VERSION >= 8
 

package/src/async_context.c

@@ -21,6 +21,7 @@ napi_async_init(napi_env env,
                 napi_value async_resource_name,
                 napi_async_context* result) {
   CHECK_ENV(env);
+  _emnapi_env_check_gc_access(env);
   CHECK_ARG(env, async_resource_name);
   CHECK_ARG(env, result);
 
@@ -39,6 +40,7 @@ napi_async_init(napi_env env,
 napi_status napi_async_destroy(napi_env env,
                                napi_async_context async_context) {
   CHECK_ENV(env);
+  _emnapi_env_check_gc_access(env);
   CHECK_ARG(env, async_context);
 
   napi_status status = _emnapi_async_destroy_js(async_context);

package/src/async_work.c

@@ -149,6 +149,7 @@ napi_status napi_create_async_work(napi_env env,
                                    napi_async_work* result) {
 #if EMNAPI_HAVE_THREADS
   CHECK_ENV(env);
+  _emnapi_env_check_gc_access(env);
   CHECK_ARG(env, execute);
   CHECK_ARG(env, result);
 
@@ -188,6 +189,7 @@ napi_status napi_create_async_work(napi_env env,
 napi_status napi_delete_async_work(napi_env env, napi_async_work work) {
 #if EMNAPI_HAVE_THREADS
   CHECK_ENV(env);
+  _emnapi_env_check_gc_access(env);
   CHECK_ARG(env, work);
 
   async_work_delete(work);

package/src/emnapi_internal.h

@@ -156,6 +156,9 @@ napi_status _emnapi_node_make_callback(napi_env env,
                                        double trigger_async_id,
                                        napi_value* result);
 
+EMNAPI_INTERNAL_EXTERN
+void _emnapi_env_check_gc_access(napi_env env);
+
 #define EMNAPI_ASYNC_RESOURCE_CTOR(env, res, name, ar) \
   do { \
     EMNAPI_ASSERT_CALL(napi_create_reference((env), (res), 1, &(ar)->resource_)); \

package/src/malloc/dlmalloc/malloc.c

@@ -4619,14 +4619,14 @@ void* dlmalloc(size_t bytes) {
   ensure_initialization(); /* initialize in sys_alloc if not using locks */
 #endif
 
+  if (!PREACTION(gm)) {
 #if __wasilibc_unmodified_upstream // Try to initialize the allocator.
 #else
-  if (!is_initialized(gm)) {
-    try_init_allocator();
-  }
+    if (!is_initialized(gm)) {
+      try_init_allocator();
+    }
 #endif
 
-  if (!PREACTION(gm)) {
     void* mem;
     size_t nb;
     if (bytes <= MAX_SMALL_REQUEST) {
@@ -5241,7 +5241,7 @@ static void internal_inspect_all(mstate m,
 
 /* Symbol marking the end of data, bss and explicit stack, provided by wasm-ld. */
 extern char __heap_base;
-extern char __heap_end __attribute__((__weak__));
+extern char __heap_end;
 
 /* Initialize the initial state of dlmalloc to be able to use free memory between __heap_base and initial. */
 static void try_init_allocator(void) {
@@ -5253,23 +5253,18 @@ static void try_init_allocator(void) {
 
   char *base = &__heap_base;
   // Try to use the linker pseudo-symbol `__heap_end` for the initial size of
-  // the heap, but if that's not defined due to LLVM being too old perhaps then
-  // round up `base` to the nearest `PAGESIZE`. The initial size of linear
-  // memory will be at least the heap base to this page boundary, and it's then
-  // assumed that the initial linear memory image was truncated at that point.
-  // While this reflects the default behavior of `wasm-ld` it is also possible
-  // for users to craft larger linear memories by passing options to extend
-  // beyond this threshold. In this situation the memory will not be used for
-  // dlmalloc.
-  //
-  // Note that `sbrk(0)`, or in dlmalloc-ese `CALL_MORECORE(0)`, is specifically
-  // not used here. That captures the current size of the heap but is only
-  // correct if the we're the first to try to grow the heap. If the heap has
-  // grown elsewhere, such as a different allocator in place, then this would
-  // incorrectly claim such memroy as our own.
+  // the heap.
   char *end = &__heap_end;
-  if (end == NULL)
-    end = (char*) page_align((size_t) base);
+  if (end < base) {
+    // "end" can be NULL when 1. you are using an old wasm-ld which doesn't
+    // provide `__heap_end` (< 15.0.7) and 2. something (other libraries
+    // or maybe your app?) includes a weak reference to `__heap_end` and
+    // 3. the weak reference is found by the linker before this strong
+    // reference.
+    //
+    // Note: This is a linker bug: https://github.com/llvm/llvm-project/issues/60829
+    __builtin_trap();
+  }
   size_t initial_heap_size = end - base;
 
   /* Check that initial heap is long enough to serve a minimal allocation request. */

package/src/node_api.c

@@ -1,5 +1,5 @@
-#include "emnapi_internal.h"
 #include "node_api.h"
+#include "emnapi_internal.h"
 
 #if EMNAPI_HAVE_THREADS
 #include "uv.h"

package/src/threadsafe_function.c

@@ -409,6 +409,7 @@ napi_create_threadsafe_function(napi_env env,
                                 napi_threadsafe_function* result) {
 #if EMNAPI_HAVE_THREADS
   CHECK_ENV(env);
+  _emnapi_env_check_gc_access(env);
   CHECK_ARG(env, async_resource_name);
   RETURN_STATUS_IF_FALSE(env, initial_thread_count > 0, napi_invalid_arg);
   CHECK_ARG(env, result);

package/src/uv/threadpool.c

@@ -209,9 +209,10 @@ void uv__threadpool_cleanup(void) {
   nthreads = 0;
 }
 
-EMNAPI_EXTERN int _emnapi_async_work_pool_size();
+EMNAPI_INTERNAL_EXTERN int _emnapi_async_work_pool_size();
 
 static void init_threads(void) {
+  uv_thread_options_t config;
   unsigned int i;
 #if !defined(EMNAPI_WORKER_POOL_SIZE) || !(EMNAPI_WORKER_POOL_SIZE > 0)
   const char* val;
@@ -262,11 +263,17 @@ static void init_threads(void) {
     abort();
 #endif
 
+  // config.flags = UV_THREAD_HAS_STACK_SIZE;
+  // config.stack_size = 8u << 20;  /* 8 MB */
+
+  // use DEFAULT_PTHREAD_STACK_SIZE
+  config.flags = UV_THREAD_NO_FLAGS;
+
   for (i = 0; i < nthreads; i++)
 #ifndef __EMNAPI_WASI_THREADS__
-    if (uv_thread_create(threads + i, (uv_thread_cb) worker, &sem))
+    if (uv_thread_create_ex(threads + i, &config, (uv_thread_cb) worker, &sem))
 #else
-    if (uv_thread_create(threads + i, (uv_thread_cb) worker, NULL))
+    if (uv_thread_create_ex(threads + i, &config, (uv_thread_cb) worker, NULL))
 #endif
       abort();
 

package/src/uv/unix/thread.c

@@ -15,6 +15,31 @@
 //     } \
 //   } while (0)
 
+static size_t uv__min_stack_size(void) {
+  static const size_t min = 8192;
+
+#ifdef PTHREAD_STACK_MIN  /* Not defined on NetBSD. */
+  if (min < (size_t) PTHREAD_STACK_MIN)
+    return PTHREAD_STACK_MIN;
+#endif  /* PTHREAD_STACK_MIN */
+
+  return min;
+}
+
+static size_t uv__default_stack_size(void) {
+#if !defined(__linux__)
+  return 0;
+#elif defined(__PPC__) || defined(__ppc__) || defined(__powerpc__)
+  return 4 << 20;  /* glibc default. */
+#else
+  return 2 << 20;  /* glibc default. */
+#endif
+}
+
+size_t uv__thread_stack_size(void) {
+  return uv__default_stack_size();
+}
+
 void uv_sem_post(sem_t* sem) {
   if (sem_post(sem))
     abort();
@@ -104,10 +129,15 @@ void uv_cond_destroy(uv_cond_t* cond) {
 }
 
 int uv_thread_create_ex(uv_thread_t* tid,
-                        void* params,
+                        const uv_thread_options_t* params,
                         void (*entry)(void *arg),
                         void *arg) {
   int err;
+  pthread_attr_t* attr;
+  pthread_attr_t attr_storage;
+  size_t pagesize;
+  size_t stack_size;
+  size_t min_stack_size;
 
   /* Used to squelch a -Wcast-function-type warning. */
   union {
@@ -115,14 +145,43 @@ int uv_thread_create_ex(uv_thread_t* tid,
     void* (*out)(void*);
   } f;
 
+  stack_size =
+      params->flags & UV_THREAD_HAS_STACK_SIZE ? params->stack_size : 0;
+
+  attr = NULL;
+  if (stack_size == 0) {
+    stack_size = uv__thread_stack_size();
+  } else {
+    pagesize = 65536;
+    stack_size = (stack_size + pagesize - 1) &~ (pagesize - 1);
+    min_stack_size = uv__min_stack_size();
+    if (stack_size < min_stack_size)
+      stack_size = min_stack_size;
+  }
+
+  if (stack_size > 0) {
+    attr = &attr_storage;
+
+    if (pthread_attr_init(attr))
+      abort();
+
+    if (pthread_attr_setstacksize(attr, stack_size))
+      abort();
+  }
+
   f.in = entry;
-  err = pthread_create(tid, NULL, f.out, arg);
+  err = pthread_create(tid, attr, f.out, arg);
+
+  if (attr != NULL)
+    pthread_attr_destroy(attr);
 
   return err;
 }
 
 int uv_thread_create(uv_thread_t *tid, void (*entry)(void *arg), void *arg) {
-  return uv_thread_create_ex(tid, NULL, entry, arg);
+  uv_thread_options_t params;
+  params.flags = UV_THREAD_NO_FLAGS;
+  return uv_thread_create_ex(tid, &params, entry, arg);
 }
 
 int uv_thread_join(uv_thread_t *tid) {