koffi 2.3.3 → 2.3.5

package/CHANGELOG.md

@@ -4,7 +4,23 @@
 
 ### Koffi 2.3
 
-#### Koffi 2.3.3
+#### Koffi 2.3.5
+
+**Main fixes:**
+
+- Fix rare random crashes with async callbacks
+- Fix some bugs with RISC-V 64 ABI
+
+**Other changes:**
+
+- Expose array type hint in `koffi.introspect()`
+- Add missing `koffi.array()` export in TS definition
+- Make KoffiFunction more flexible in TS definition ([@insraq](https://github.com/insraq))
+- Add a KoffiFunc<T> helper type in TS typing ([@insraq](https://github.com/insraq))
+- Mark optional properties in TS TypeInfo class
+- Minor performance improvements
+
+#### Koffi 2.3.4
 
 **Main fixes:**
 
@@ -37,7 +53,7 @@
 
 - Allow buffers (TypedArray or ArrayBuffer) values for input and/or output pointer arguments (for polymorphic arguments)
 - Support opaque buffers (TypedArray or ArrayBuffer) values in `koffi.decode()` to [decode output buffers](calls.md#output-buffers)
-- Decode non-string types as arrays when an [explicit length is passed to koffi.decode()](callbacks.md#pointer-arguments)
+- Decode non-string types as arrays when an [explicit length is passed to koffi.decode()](callbacks.md#decoding-pointer-arguments)
 
 **Other changes:**
 
@@ -100,7 +116,7 @@
 
 **New features:**
 
-- Add [koffi.decode()](callbacks.md#pointer-arguments) for callback pointer arguments
+- Add [koffi.decode()](callbacks.md#decoding-pointer-arguments) for callback pointer arguments
 - Support transparent [output string parameters](calls.md#output-parameters)
 - Add `koffi.offsetof()` utility function
 - Support optional *this* binding in `koffi.register()`

package/doc/changelog.md

@@ -1 +1,5 @@
+---
+tocdepth: 3
+---
+
 {{ "```{include} " ~ root ~ "/CHANGELOG.md" ~ "\n```" }}

package/doc/index.rst

@@ -11,7 +11,6 @@ Koffi is a **fast and easy-to-use C FFI module for Node.js**, featuring:
 * Javascript functions can be used as C callbacks (since 1.2.0)
 * Well-tested code base for :ref:`popular OS/architecture combinations<Supported platforms>`
 
-
 Koffi requires a recent `Node.js <https://nodejs.org/>`_ version with N-API version 8 support, see :ref:`this page<Node.js>` for more information.
 
 The source code is available here: https://github.com/Koromix/rygel/ (in the *src/koffi* subdirectory).
@@ -20,7 +19,7 @@ Table of contents
 -----------------
 
 .. toctree::
-   :maxdepth: 2
+   :maxdepth: 3
 
    platforms
    start

package/doc/types.md

@@ -339,7 +339,7 @@ Fixed-size arrays are declared with `koffi.array(type, length)`. Just like in C,
 Koffi applies the following conversion rules when passing arrays to/from C:
 
 - **JS to C**: Koffi can take a normal Array (e.g. `[1, 2]`) or a TypedArray of the correct type (e.g. `Uint8Array` for an array of `uint8_t` numbers)
-- **C to JS** (return value, output parameters, callbacks): Koffi will use a TypedArray if possible. But you can change this behavior when you create the array type with the optional hint argument: `koffi.array('uint8_t', 64, 'array')`. For non-number types, such as arrays of strings or structs, Koffi creates normal arrays.
+- **C to JS** (return value, output parameters, callbacks): Koffi will use a TypedArray if possible. But you can change this behavior when you create the array type with the optional hint argument: `koffi.array('uint8_t', 64, 'Array')`. For non-number types, such as arrays of strings or structs, Koffi creates normal arrays.
 
 See the example below:
 
@@ -353,7 +353,7 @@ const Foo1 = koffi.struct('Foo', {
 });
 const Foo2 = koffi.struct('Foo', {
     i: 'int',
-    a16: koffi.array('int16_t', 8, 'array')
+    a16: koffi.array('int16_t', 8, 'Array')
 });
 
 // Uses an hypothetical C function that just returns the struct passed as a parameter
@@ -371,7 +371,7 @@ Koffi can also convert JS strings to fixed-sized arrays in the following cases:
 - **char arrays** are filled with the UTF-8 encoded string, truncated if needed. The buffer is always NUL-terminated.
 - **char16 (or char16_t) arrays** are filled with the UTF-16 encoded string, truncated if needed. The buffer is always NUL-terminated.
 
-The reverse case is also true, Koffi can convert a C fixed-size buffer to a JS string. This happens by default for char, char16 and char16_t arrays, but you can also explicitly ask for this with the `string` array hint (e.g. `koffi.array('char', 8, 'string')`).
+The reverse case is also true, Koffi can convert a C fixed-size buffer to a JS string. This happens by default for char, char16 and char16_t arrays, but you can also explicitly ask for this with the `String` array hint (e.g. `koffi.array('char', 8, 'String')`).
 
 ### Array pointers (dynamic arrays)
 

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "koffi",
-    "version": "2.3.3",
-    "stable": "2.3.3",
+    "version": "2.3.5",
+    "stable": "2.3.5",
     "description": "Fast and simple C FFI (foreign function interface) for Node.js",
     "keywords": [
         "foreign",

package/src/core/libcc/libcc.cc

@@ -4048,8 +4048,8 @@ static void DefaultSignalHandler(int signal)
 
 RG_INIT(SetupDefaultHandlers)
 {
-    int ret = setpgid(0, 0);
-    RG_ASSERT(!ret);
+    // Best effort
+    setpgid(0, 0);
 
     SetSignalHandler(SIGINT, DefaultSignalHandler);
     SetSignalHandler(SIGTERM, DefaultSignalHandler);

package/src/koffi/src/abi_arm32.cc

@@ -54,12 +54,32 @@ extern "C" napi_value CallSwitchStack(Napi::Function *func, size_t argc, napi_va
 
 #include "abi_trampolines.inc"
 
-static inline int IsHFA(const TypeInfo *type)
+static int IsHFA(const TypeInfo *type)
 {
 #ifdef __ARM_PCS_VFP
-    return IsHFA(type, 1, 4);
+    bool float32 = false;
+    bool float64 = false;
+    int count = 0;
+
+    count = AnalyseFlat(type, [&](const TypeInfo *type, int, int) {
+        if (type->primitive == PrimitiveKind::Float32) {
+            float32 = true;
+        } else if (type->primitive == PrimitiveKind::Float64) {
+            float64 = true;
+        } else {
+            float32 = true;
+            float64 = true;
+        }
+    });
+
+    if (count < 1 || count > 4)
+        return 0;
+    if (float32 && float64)
+        return 0;
+
+    return count;
 #else
-    return false;
+    return 0;
 #endif
 }
 
@@ -67,9 +87,11 @@ bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
 {
     if (int hfa = IsHFA(func->ret.type); hfa) {
         func->ret.vec_count = hfa;
-    } else if (func->ret.type->primitive != PrimitiveKind::Record ||
-               func->ret.type->size <= 4) {
+    } else if (func->ret.type->primitive != PrimitiveKind::Record &&
+               func->ret.type->primitive != PrimitiveKind::Union) {
         func->ret.gpr_count = (func->ret.type->size > 4) ? 2 : 1;
+    } else if (func->ret.type->size <= 4) {
+        func->ret.gpr_count = 1;
     } else {
         func->ret.use_memory = true;
     }
@@ -118,7 +140,8 @@ bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
                     started_stack = true;
                 }
             } break;
-            case PrimitiveKind::Record: {
+            case PrimitiveKind::Record:
+            case PrimitiveKind::Union: {
                 int hfa = IsHFA(param.type);
 
                 if (hfa) {
@@ -319,7 +342,8 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
 
                 *(void **)((param.gpr_count ? gpr_ptr : args_ptr)++) = ptr;
             } break;
-            case PrimitiveKind::Record: {
+            case PrimitiveKind::Record:
+            case PrimitiveKind::Union: {
                 if (RG_UNLIKELY(!IsObject(value))) {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected object", GetValueType(instance, value));
                     return false;
@@ -455,7 +479,8 @@ void CallData::Execute(const FunctionInfo *func)
         case PrimitiveKind::String16:
         case PrimitiveKind::Pointer:
         case PrimitiveKind::Callback: { result.u64 = PERFORM_CALL(GG); } break;
-        case PrimitiveKind::Record: {
+        case PrimitiveKind::Record:
+        case PrimitiveKind::Union: {
             if (func->ret.vec_count) {
                 HfaRet ret = PERFORM_CALL(DDDD);
                 memcpy(&result.buf, &ret, RG_SIZE(ret));
@@ -513,7 +538,8 @@ Napi::Value CallData::Complete(const FunctionInfo *func)
                 return env.Null();
             }
         } break;
-        case PrimitiveKind::Record: {
+        case PrimitiveKind::Record:
+        case PrimitiveKind::Union: {
             const uint8_t *ptr = return_ptr ? (const uint8_t *)return_ptr
                                             : (const uint8_t *)&result.buf;
 
@@ -709,7 +735,8 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
                     param.type->dispose(env, param.type, ptr2);
                 }
             } break;
-            case PrimitiveKind::Record: {
+            case PrimitiveKind::Record:
+            case PrimitiveKind::Union: {
                 if (param.vec_count) {
                     Napi::Object obj = DecodeObject(env, (const uint8_t *)vec_ptr, param.type);
                     arguments.Append(obj);
@@ -893,7 +920,8 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
 
             if (CheckValueTag(instance, value, type->ref.marker)) {
                 ptr = value.As<Napi::External<uint8_t>>().Data();
-            } else if (IsObject(value) && type->ref.type->primitive == PrimitiveKind::Record) {
+            } else if (IsObject(value) && (type->ref.type->primitive == PrimitiveKind::Record ||
+                                           type->ref.type->primitive == PrimitiveKind::Union)) {
                 Napi::Object obj = value.As<Napi::Object>();
 
                 ptr = AllocHeap(type->ref.type->size, 16);
@@ -909,7 +937,8 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
 
             out_reg->r0 = (uint32_t)ptr;
         } break;
-        case PrimitiveKind::Record: {
+        case PrimitiveKind::Record:
+        case PrimitiveKind::Union: {
             if (RG_UNLIKELY(!IsObject(value))) {
                 ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected object", GetValueType(instance, value));
                 return;
@@ -921,8 +950,8 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
                 if (!PushObject(obj, type, return_ptr))
                     return;
                 out_reg->r0 = (uint32_t)return_ptr;
-            } else if (proto->ret.vec_count) { // HFA
-                PushObject(obj, type, (uint8_t *)&out_reg->d0, 8);
+            } else if (proto->ret.vec_count) {
+                PushObject(obj, type, (uint8_t *)&out_reg->d0);
             } else {
                 PushObject(obj, type, (uint8_t *)&out_reg->r0);
             }

package/src/koffi/src/abi_arm64.cc

@@ -25,6 +25,11 @@
 
 namespace RG {
 
+struct HfaInfo {
+    int count;
+    bool float32;
+};
+
 struct X0X1Ret {
     uint64_t x0;
     uint64_t x1;
@@ -59,15 +64,61 @@ extern "C" napi_value CallSwitchStack(Napi::Function *func, size_t argc, napi_va
 
 #include "abi_trampolines.inc"
 
-static inline int IsHFA(const TypeInfo *type)
+static HfaInfo IsHFA(const TypeInfo *type)
+{
+    bool float32 = false;
+    bool float64 = false;
+    int count = 0;
+
+    count = AnalyseFlat(type, [&](const TypeInfo *type, int, int) {
+        if (type->primitive == PrimitiveKind::Float32) {
+            float32 = true;
+        } else if (type->primitive == PrimitiveKind::Float64) {
+            float64 = true;
+        } else {
+            float32 = true;
+            float64 = true;
+        }
+    });
+
+    HfaInfo info = {};
+
+    if (count < 1 || count > 4)
+        return info;
+    if (float32 && float64)
+        return info;
+
+    info.count = count;
+    info.float32 = float32;
+
+    return info;
+}
+
+static inline void ExpandFloats(uint8_t *ptr, Size len, Size bytes)
+{
+    for (Size i = len - 1; i >= 0; i--) {
+        const uint8_t *src = ptr + i * bytes;
+        uint8_t *dest = ptr + i * 8;
+
+        memmove(dest, src, bytes);
+    }
+}
+
+static inline void CompactFloats(uint8_t *ptr, Size len, Size bytes)
 {
-    return IsHFA(type, 1, 4);
+    for (Size i = 0; i < len; i++) {
+        const uint8_t *src = ptr + i * 8;
+        uint8_t *dest = ptr + i * bytes;
+
+        memmove(dest, src, bytes);
+    }
 }
 
 bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
 {
-    if (int hfa = IsHFA(func->ret.type); hfa) {
-        func->ret.vec_count = (int8_t)hfa;
+    if (HfaInfo hfa = IsHFA(func->ret.type); hfa.count) {
+        func->ret.vec_count = (int8_t)hfa.count;
+        func->ret.vec_bytes = hfa.float32 ? 4 : 8;
     } else if (func->ret.type->size <= 16) {
         func->ret.gpr_count = (int8_t)((func->ret.type->size + 7) / 8);
     } else {
@@ -115,8 +166,9 @@ bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
                     gpr_avail--;
                 }
             } break;
-            case PrimitiveKind::Record: {
-                int hfa = IsHFA(param.type);
+            case PrimitiveKind::Record:
+            case PrimitiveKind::Union: {
+                HfaInfo hfa = IsHFA(param.type);
 
 #ifdef _M_ARM64EC
                 if (func->variadic) {
@@ -137,7 +189,7 @@ bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
 
 #if defined(_WIN32)
                 if (param.variadic) {
-                    hfa = 0;
+                    hfa.count = 0;
                 }
 #elif defined(__APPLE__)
                 if (param.variadic) {
@@ -146,10 +198,11 @@ bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
                 }
 #endif
 
-                if (hfa) {
-                    if (hfa <= vec_avail) {
-                        param.vec_count = (int8_t)hfa;
-                        vec_avail -= hfa;
+                if (hfa.count) {
+                    if (hfa.count <= vec_avail) {
+                        param.vec_count = (int8_t)hfa.count;
+                        param.vec_bytes = hfa.float32 ? 4 : 8;
+                        vec_avail -= hfa.count;
                     } else {
                         vec_avail = 0;
                     }
@@ -364,7 +417,8 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
 #endif
                 *(void **)((param.gpr_count ? gpr_ptr : args_ptr)++) = ptr;
             } break;
-            case PrimitiveKind::Record: {
+            case PrimitiveKind::Record:
+            case PrimitiveKind::Union: {
                 if (RG_UNLIKELY(!IsObject(value))) {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected object", GetValueType(instance, value));
                     return false;
@@ -373,8 +427,12 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
                 Napi::Object obj = value.As<Napi::Object>();
 
                 if (param.vec_count) { // HFA
-                    if (!PushObject(obj, param.type, (uint8_t *)vec_ptr, 8))
+                    uint8_t *ptr = (uint8_t *)vec_ptr;
+
+                    if (!PushObject(obj, param.type, ptr))
                         return false;
+                    ExpandFloats(ptr, param.vec_count, param.vec_bytes);
+
                     vec_ptr += param.vec_count;
                 } else if (!param.use_memory) {
                     if (param.gpr_count) {
@@ -544,7 +602,8 @@ void CallData::Execute(const FunctionInfo *func)
         case PrimitiveKind::String16:
         case PrimitiveKind::Pointer:
         case PrimitiveKind::Callback: { result.u64 = PERFORM_CALL(GG).x0; } break;
-        case PrimitiveKind::Record: {
+        case PrimitiveKind::Record:
+        case PrimitiveKind::Union: {
             if (func->ret.gpr_count) {
                 X0X1Ret ret = PERFORM_CALL(GG);
                 memcpy(&result.buf, &ret, RG_SIZE(ret));
@@ -605,9 +664,14 @@ Napi::Value CallData::Complete(const FunctionInfo *func)
                 return env.Null();
             }
         } break;
-        case PrimitiveKind::Record: {
+        case PrimitiveKind::Record:
+        case PrimitiveKind::Union: {
             if (func->ret.vec_count) { // HFA
-                Napi::Object obj = DecodeObject(env, (const uint8_t *)&result.buf, func->ret.type, 8);
+                uint8_t *ptr = (uint8_t *)&result.buf;
+
+                CompactFloats(ptr, func->ret.vec_count, func->ret.vec_bytes);
+
+                Napi::Object obj = DecodeObject(env, ptr, func->ret.type);
                 return obj;
             } else {
                 const uint8_t *ptr = return_ptr ? (const uint8_t *)return_ptr
@@ -973,9 +1037,14 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
                     param.type->dispose(env, param.type, ptr2);
                 }
             } break;
-            case PrimitiveKind::Record: {
+            case PrimitiveKind::Record:
+            case PrimitiveKind::Union: {
                 if (param.vec_count) { // HFA
-                    Napi::Object obj = DecodeObject(env, (uint8_t *)vec_ptr, param.type, 8);
+                    uint8_t *ptr = (uint8_t *)vec_ptr;
+
+                    CompactFloats(ptr, param.vec_count, param.vec_bytes);
+
+                    Napi::Object obj = DecodeObject(env, ptr, param.type);
                     arguments.Append(obj);
 
                     vec_ptr += param.vec_count;
@@ -1133,7 +1202,8 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
 
             if (CheckValueTag(instance, value, type->ref.marker)) {
                 ptr = value.As<Napi::External<uint8_t>>().Data();
-            } else if (IsObject(value) && type->ref.type->primitive == PrimitiveKind::Record) {
+            } else if (IsObject(value) && (type->ref.type->primitive == PrimitiveKind::Record ||
+                                           type->ref.type->primitive == PrimitiveKind::Union)) {
                 Napi::Object obj = value.As<Napi::Object>();
 
                 ptr = AllocHeap(type->ref.type->size, 16);
@@ -1149,7 +1219,8 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
 
             out_reg->x0 = (uint64_t)ptr;
         } break;
-        case PrimitiveKind::Record: {
+        case PrimitiveKind::Record:
+        case PrimitiveKind::Union: {
             if (RG_UNLIKELY(!IsObject(value))) {
                 ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected object", GetValueType(instance, value));
                 return;
@@ -1162,7 +1233,10 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
                     return;
                 out_reg->x0 = (uint64_t)return_ptr;
             } else if (proto->ret.vec_count) { // HFA
-                PushObject(obj, type, (uint8_t *)&out_reg->d0, 8);
+                uint8_t *ptr = (uint8_t *)&out_reg->d0;
+
+                ExpandFloats(ptr, proto->ret.vec_count, proto->ret.vec_bytes);
+                PushObject(obj, type, ptr);
             } else {
                 PushObject(obj, type, (uint8_t *)&out_reg->x0);
             }