emnapi 0.41.0 → 0.42.0

package/CMakeLists.txt

@@ -97,12 +97,14 @@ if(IS_WASM32)
     ${MALLOC_PUBLIC_SOURCES}
     "${CMAKE_CURRENT_SOURCE_DIR}/src/malloc/emmalloc/emmalloc.c"
   )
+  target_compile_options(${EMMALLOC_TARGET_NAME} PRIVATE "-fno-strict-aliasing")
   target_compile_definitions(${EMMALLOC_TARGET_NAME} PRIVATE "PAGESIZE=65536")
 
   add_library(${EMMALLOC_MT_TARGET_NAME} STATIC
     ${MALLOC_PUBLIC_SOURCES}
     "${CMAKE_CURRENT_SOURCE_DIR}/src/malloc/emmalloc/emmalloc.c"
   )
+  target_compile_options(${EMMALLOC_MT_TARGET_NAME} PRIVATE "-fno-strict-aliasing")
   target_compile_options(${EMMALLOC_MT_TARGET_NAME} PUBLIC "-matomics" "-mbulk-memory")
   target_compile_definitions(${EMMALLOC_MT_TARGET_NAME} PRIVATE "PAGESIZE=65536" "__EMSCRIPTEN_SHARED_MEMORY__=1")
 endif()

package/README.md

@@ -109,7 +109,7 @@ Create `hello.c`.
 ```c
 #include <node_api.h>
 
-#define NAPI_CALL(env, the_call)                                \
+#define NODE_API_CALL(env, the_call)                                \
   do {                                                          \
     if ((the_call) != napi_ok) {                                \
       const napi_extended_error_info *error_info;               \
@@ -130,15 +130,15 @@ Create `hello.c`.
 static napi_value js_hello(napi_env env, napi_callback_info info) {
   napi_value world;
   const char* str = "world";
-  NAPI_CALL(env, napi_create_string_utf8(env, str, NAPI_AUTO_LENGTH, &world));
+  NODE_API_CALL(env, napi_create_string_utf8(env, str, NAPI_AUTO_LENGTH, &world));
   return world;
 }
 
 NAPI_MODULE_INIT() {
   napi_value hello;
-  NAPI_CALL(env, napi_create_function(env, "hello", NAPI_AUTO_LENGTH,
+  NODE_API_CALL(env, napi_create_function(env, "hello", NAPI_AUTO_LENGTH,
                                       js_hello, NULL, &hello));
-  NAPI_CALL(env, napi_set_named_property(env, exports, "hello", hello));
+  NODE_API_CALL(env, napi_set_named_property(env, exports, "hello", hello));
   return exports;
 }
 ```

package/dist/library_napi.js

@@ -802,11 +802,11 @@ function napi_create_function(env, utf8name, length, cb, data, result) {
         return envObject.setLastError(10 /* napi_status.napi_pending_exception */);
     }
 }
-function napi_get_cb_info(env, _cbinfo, argc, argv, this_arg, data) {
+function napi_get_cb_info(env, cbinfo, argc, argv, this_arg, data) {
     if (!env)
         return 1 /* napi_status.napi_invalid_arg */;
     var envObject = emnapiCtx.envStore.get(env);
-    var cbinfoValue = emnapiCtx.cbinfoStack.current;
+    var cbinfoValue = emnapiCtx.cbinfoStack.get(cbinfo);
     {{{ from64('argc') }}};
     {{{ from64('argv') }}};
     if (argv) {
@@ -949,14 +949,14 @@ function napi_new_instance(env, constructor, argc, argv, result) {
         return envObject.setLastError(10 /* napi_status.napi_pending_exception */);
     }
 }
-function napi_get_new_target(env, _cbinfo, result) {
+function napi_get_new_target(env, cbinfo, result) {
     if (!env)
         return 1 /* napi_status.napi_invalid_arg */;
     var envObject = emnapiCtx.envStore.get(env);
     if (!result)
         return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
     {{{ from64('result') }}};
-    var cbinfoValue = emnapiCtx.cbinfoStack.current;
+    var cbinfoValue = emnapiCtx.cbinfoStack.get(cbinfo);
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     var value = cbinfoValue.getNewTarget(envObject);
     {{{ makeSetValue('result', 0, 'value', '*') }}};
@@ -976,11 +976,11 @@ function emnapiCreateFunction(envObject, utf8name, length, cb, data) {
     var f;
     var makeFunction = function () { return function () {
         'use strict';
-        emnapiCtx.cbinfoStack.push(this, data, arguments, f);
+        var cbinfo = emnapiCtx.cbinfoStack.push(this, data, arguments, f);
         var scope = emnapiCtx.openScope(envObject);
         try {
             return envObject.callIntoModule(function (envObject) {
-                var napiValue = {{{ makeDynCall('ppp', 'cb') }}}(envObject.id, 0);
+                var napiValue = {{{ makeDynCall('ppp', 'cb') }}}(envObject.id, cbinfo);
                 return (!napiValue) ? undefined : emnapiCtx.handleStore.get(napiValue).value;
             });
         }
@@ -1548,13 +1548,13 @@ function __emnapi_node_emit_async_destroy(async_id, trigger_async_id) {
   })
 
   {{{ from64('result') }}}
-  {{{ makeSetValue('result', 0, 'nativeCallbackScopePointer', 'i64') }}}
+  $_TODO_makeSetValue('result', 0, 'nativeCallbackScopePointer', 'i64')
 }
 
 function __emnapi_node_close_callback_scope (scope: Pointer<int64_t>): void {
   if (!emnapiNodeBinding || !scope) return
   {{{ from64('scope') }}}
-  const nativeCallbackScopePointer = {{{ makeGetValue('scope', 0, 'i64') }}}
+  const nativeCallbackScopePointer = $_TODO_makeGetValue('scope', 0, 'i64')
   emnapiNodeBinding.node.closeCallbackScope(BigInt(nativeCallbackScopePointer))
 } */
 function __emnapi_node_make_callback(env, async_resource, cb, argv, size, async_id, trigger_async_id, result) {
@@ -1685,7 +1685,7 @@ function napi_make_callback(env, async_context, recv, func, argc, argv, result)
             v = envObject.ensureHandleId(ret.value);
             {{{ makeSetValue('result', 0, 'v', '*') }}};
         }
-        return envObject.clearLastError();
+        return envObject.getReturnStatus();
     }
     catch (err) {
         envObject.tryCatch.setError(err);
@@ -2171,7 +2171,7 @@ function napi_set_named_property(env, object, cname, value) {
         }
         {{{ from64('cname') }}};
         emnapiCtx.handleStore.get(object).value[emnapiString.UTF8ToString(cname, -1)] = emnapiCtx.handleStore.get(value).value;
-        return 0 /* napi_status.napi_ok */;
+        return envObject.getReturnStatus();
     }
     catch (err) {
         envObject.tryCatch.setError(err);
@@ -2462,7 +2462,7 @@ function napi_define_properties(env, object, property_count, properties) {
             }
             emnapiDefineProperty(envObject, maybeObject, propertyName, method, getter, setter, value, attributes, data);
         }
-        return 0 /* napi_status.napi_ok */;
+        return envObject.getReturnStatus();
     }
     catch (err) {
         envObject.tryCatch.setError(err);
@@ -4141,9 +4141,8 @@ function napi_detach_arraybuffer(env, arraybuffer) {
         var messageChannel = new MessageChannel_1();
         messageChannel.port1.postMessage(value, [value]);
     }
-    catch (err) {
-        envObject.tryCatch.setError(err);
-        return envObject.setLastError(10 /* napi_status.napi_pending_exception */);
+    catch (_) {
+        return envObject.setLastError(9 /* napi_status.napi_generic_failure */);
     }
     return envObject.clearLastError();
 }
@@ -4205,8 +4204,8 @@ function _napi_get_version(env, result) {
     if (!result)
         return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    var NAPI_VERSION = 9 /* Version.NAPI_VERSION */;
-    {{{ makeSetValue('result', 0, 'NAPI_VERSION', 'u32') }}};
+    var NODE_API_SUPPORTED_VERSION_MAX = 9 /* Version.NODE_API_SUPPORTED_VERSION_MAX */;
+    {{{ makeSetValue('result', 0, 'NODE_API_SUPPORTED_VERSION_MAX', 'u32') }}};
     return envObject.clearLastError();
 }
 emnapiImplement('napi_get_version', 'ipp', _napi_get_version, []);
@@ -4685,8 +4684,7 @@ function napi_get_value_bigint_int64(env, value, result, lossless) {
         return 1 /* napi_status.napi_invalid_arg */;
     var envObject = emnapiCtx.envStore.get(env);
     if (!emnapiCtx.feature.supportBigInt) {
-        envObject.tryCatch.setError(emnapiCtx.createNotSupportBigIntError('napi_get_value_bigint_int64', 'This API is unavailable'));
-        return envObject.setLastError(10 /* napi_status.napi_pending_exception */);
+        return envObject.setLastError(9 /* napi_status.napi_generic_failure */);
     }
     if (!value)
         return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
@@ -4724,8 +4722,7 @@ function napi_get_value_bigint_uint64(env, value, result, lossless) {
         return 1 /* napi_status.napi_invalid_arg */;
     var envObject = emnapiCtx.envStore.get(env);
     if (!emnapiCtx.feature.supportBigInt) {
-        envObject.tryCatch.setError(emnapiCtx.createNotSupportBigIntError('napi_get_value_bigint_uint64', 'This API is unavailable'));
-        return envObject.setLastError(10 /* napi_status.napi_pending_exception */);
+        return envObject.setLastError(9 /* napi_status.napi_generic_failure */);
     }
     if (!value)
         return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
@@ -4760,8 +4757,7 @@ function napi_get_value_bigint_words(env, value, sign_bit, word_count, words) {
         return 1 /* napi_status.napi_invalid_arg */;
     var envObject = emnapiCtx.envStore.get(env);
     if (!emnapiCtx.feature.supportBigInt) {
-        envObject.tryCatch.setError(emnapiCtx.createNotSupportBigIntError('napi_get_value_bigint_words', 'This API is unavailable'));
-        return envObject.setLastError(10 /* napi_status.napi_pending_exception */);
+        return envObject.setLastError(9 /* napi_status.napi_generic_failure */);
     }
     if (!value)
         return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
@@ -5130,8 +5126,7 @@ function napi_create_bigint_int64(env, low, high, result) {
         return 1 /* napi_status.napi_invalid_arg */;
     var envObject = emnapiCtx.envStore.get(env);
     if (!emnapiCtx.feature.supportBigInt) {
-        envObject.tryCatch.setError(emnapiCtx.createNotSupportBigIntError('napi_create_bigint_int64', 'This API is unavailable'));
-        return envObject.setLastError(10 /* napi_status.napi_pending_exception */);
+        return envObject.setLastError(9 /* napi_status.napi_generic_failure */);
     }
     var value;
 #if WASM_BIGINT
@@ -5157,8 +5152,7 @@ function napi_create_bigint_uint64(env, low, high, result) {
         return 1 /* napi_status.napi_invalid_arg */;
     var envObject = emnapiCtx.envStore.get(env);
     if (!emnapiCtx.feature.supportBigInt) {
-        envObject.tryCatch.setError(emnapiCtx.createNotSupportBigIntError('napi_create_bigint_uint64', 'This API is unavailable'));
-        return envObject.setLastError(10 /* napi_status.napi_pending_exception */);
+        return envObject.setLastError(9 /* napi_status.napi_generic_failure */);
     }
     var value;
 #if WASM_BIGINT
@@ -5193,7 +5187,7 @@ function napi_create_bigint_words(env, sign_bit, word_count, words, result) {
     envObject.clearLastError();
     try {
         if (!emnapiCtx.feature.supportBigInt) {
-            throw emnapiCtx.createNotSupportBigIntError('napi_create_bigint_words', 'This API is unavailable');
+            return envObject.setLastError(9 /* napi_status.napi_generic_failure */);
         }
         if (!result)
             return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
@@ -5217,7 +5211,7 @@ function napi_create_bigint_words(env, sign_bit, word_count, words, result) {
         {{{ from64('result') }}};
         v = emnapiCtx.addToCurrentScope(value).id;
         {{{ makeSetValue('result', 0, 'v', '*') }}};
-        return envObject.clearLastError();
+        return envObject.getReturnStatus();
     }
     catch (err) {
         envObject.tryCatch.setError(err);
@@ -5675,8 +5669,7 @@ function napi_create_dataview(env, byte_length, arraybuffer, byte_offset, result
         if ((byte_length + byte_offset) > buffer.byteLength) {
             var err = new RangeError('byte_offset + byte_length should be less than or equal to the size in bytes of the array passed in');
             err.code = 'ERR_NAPI_INVALID_DATAVIEW_ARGS';
-            envObject.tryCatch.setError(err);
-            return envObject.setLastError(10 /* napi_status.napi_pending_exception */);
+            throw err;
         }
         var dataview = new DataView(buffer, byte_offset, byte_length);
         if (buffer === wasmMemory.buffer) {

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.42.0",
   "description": "Node-API implementation for Emscripten",
   "main": "index.js",
   "peerDependencies": {

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/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) {