koffi 2.3.4 → 2.3.6-beta.1

package/src/koffi/src/ffi.cc

@@ -48,10 +48,6 @@ namespace RG {
 
 SharedData shared;
 
-// Value does not matter, the tag system uses memory addresses
-const int TypeInfoMarker = 0xDEADBEEF;
-const int CastMarker = 0xDEADBEEF;
-
 static RG_THREAD_LOCAL CallData *exec_call;
 
 static bool ChangeSize(const char *name, Napi::Value value, Size min_size, Size max_size, Size *out_size)
@@ -335,6 +331,147 @@ static Napi::Value CreatePackedStructType(const Napi::CallbackInfo &info)
     return CreateStructType(info, false);
 }
 
+static Napi::Value CreateUnionType(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (info.Length() < 1) {
+        ThrowError<Napi::TypeError>(env, "Expected 1 or 2 arguments, got %1", info.Length());
+        return env.Null();
+    }
+
+    bool named = info.Length() > 1;
+
+    if (named && !info[0].IsString()) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string", GetValueType(instance, info[0]));
+        return env.Null();
+    }
+    if (!IsObject(info[named])) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for members, expected object", GetValueType(instance, info[1]));
+        return env.Null();
+    }
+
+    TypeInfo *type = instance->types.AppendDefault();
+    RG_DEFER_N(err_guard) { instance->types.RemoveLast(1); };
+
+    std::string name = named ? info[0].As<Napi::String>() : std::string("<anonymous>");
+    Napi::Object obj = info[named].As<Napi::Object>();
+    Napi::Array keys = obj.GetPropertyNames();
+
+    type->name = DuplicateString(name.c_str(), &instance->str_alloc).ptr;
+
+    type->primitive = PrimitiveKind::Union;
+    type->align = 1;
+
+    HashSet<const char *> members;
+    int32_t size = 0;
+
+    for (uint32_t i = 0; i < keys.Length(); i++) {
+        RecordMember member = {};
+
+        std::string key = ((Napi::Value)keys[i]).As<Napi::String>();
+        Napi::Value value = obj[key];
+        int16_t align = 0;
+
+        member.name = DuplicateString(key.c_str(), &instance->str_alloc).ptr;
+
+        if (value.IsArray()) {
+            Napi::Array array = value.As<Napi::Array>();
+
+            if (array.Length() != 2 || !((Napi::Value)array[0u]).IsNumber()) {
+                ThrowError<Napi::Error>(env, "Member specifier array must contain alignement value and type");
+                return env.Null();
+            }
+
+            int64_t align64 = ((Napi::Value)array[0u]).As<Napi::Number>().Int64Value();
+
+            if (!CheckAlignment(align64)) {
+                ThrowError<Napi::Error>(env, "Alignment of member '%1' must be 1, 2, 4 or 8", member.name);
+                return env.Null();
+            }
+
+            value = array[1u];
+            align = (int16_t)align64;
+        }
+ 
+        member.type = ResolveType(value);
+        if (!member.type)
+            return env.Null();
+        if (!CanStoreType(member.type)) {
+            ThrowError<Napi::TypeError>(env, "Type %1 cannot be used as a member (maybe try %1 *)", member.type->name);
+            return env.Null();
+        }
+
+        align = align ? align : member.type->align;
+        size = std::max(size, member.type->size);
+        type->align = std::max(type->align, align);
+
+        bool inserted;
+        members.TrySet(member.name, &inserted);
+
+        if (!inserted) {
+            ThrowError<Napi::Error>(env, "Duplicate member '%1' in union '%2'", member.name, type->name);
+            return env.Null();
+        }
+
+        type->members.Append(member);
+    }
+
+    size = (int32_t)AlignLen(size, type->align);
+    if (!size) {
+        ThrowError<Napi::Error>(env, "Empty union '%1' is not allowed in C", type->name);
+        return env.Null();
+    }
+    type->size = (int32_t)size;
+
+    // If the insert succeeds, we cannot fail anymore
+    if (named) {
+        bool inserted;
+        instance->types_map.TrySet(type->name, type, &inserted);
+
+        if (!inserted) {
+            ThrowError<Napi::Error>(env, "Duplicate type name '%1'", type->name);
+            return env.Null();
+        }
+    }
+    err_guard.Disable();
+
+    // Union constructor
+    Napi::Function constructor = MagicUnion::InitClass(env, type);
+    type->construct.Reset(constructor, 1);
+
+    return WrapType(env, instance, type);
+}
+
+Napi::Value InstantiateUnion(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (!info.IsConstructCall()) {
+        ThrowError<Napi::TypeError>(env, "This function is a constructor and must be called with new");
+        return env.Null();
+    }
+    if (info.Length() < 1) {
+        ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", info.Length());
+        return env.Null();
+    }
+
+    const TypeInfo *type = ResolveType(info[0]);
+    if (!type)
+        return env.Null();
+    if (type->primitive != PrimitiveKind::Union) {
+        ThrowError<Napi::TypeError>(env, "Expected union type, got %1", PrimitiveKindNames[(int)type->primitive]);
+        return env.Null();
+    }
+
+    Napi::Object wrapper = type->construct.New({}).As<Napi::Object>();
+    SetValueTag(instance, wrapper, &MagicUnionMarker);
+
+    return wrapper;
+}
+
 static Napi::Value CreateOpaqueType(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
@@ -636,21 +773,21 @@ static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
         }
 
         std::string to = info[2].As<Napi::String>();
-        TypeInfo::ArrayHint hint = {};
+        ArrayHint hint = {};
 
-        if (to == "typed") {
-            hint = TypeInfo::ArrayHint::TypedArray;
-        } else if (to == "array") {
-            hint = TypeInfo::ArrayHint::Array;
-        } else if (to == "string") {
+        if (to == "Typed" || to == "typed") {
+            hint = ArrayHint::Typed;
+        } else if (to == "Array" || to == "array") {
+            hint = ArrayHint::Array;
+        } else if (to == "String" || to == "string") {
             if (ref->primitive != PrimitiveKind::Int8 && ref->primitive != PrimitiveKind::Int16) {
-                ThrowError<Napi::Error>(env, "Array hint 'string' can only be used with 8 and 16-bit signed integer types");
+                ThrowError<Napi::Error>(env, "Array hint 'String' can only be used with 8 and 16-bit signed integer types");
                 return env.Null();
             }
 
-            hint = TypeInfo::ArrayHint::String;
+            hint = ArrayHint::String;
         } else {
-            ThrowError<Napi::Error>(env, "Array conversion hint must be 'typed', 'array' or 'string'");
+            ThrowError<Napi::Error>(env, "Array conversion hint must be 'Typed', 'Array' or 'String'");
             return env.Null();
         }
 
@@ -952,12 +1089,14 @@ static Napi::Value GetTypeDefinition(const Napi::CallbackInfo &info)
             case PrimitiveKind::Array: {
                 uint32_t len = type->size / type->ref.type->size;
                 defn.Set("length", Napi::Number::New(env, (double)len));
+                defn.Set("hint", ArrayHintNames[(int)type->hint]);
             } [[fallthrough]];
             case PrimitiveKind::Pointer: {
                 Napi::Value value = WrapType(env, instance, type->ref.type);
                 defn.Set("ref", value);
             } break;
-            case PrimitiveKind::Record: {
+            case PrimitiveKind::Record:
+            case PrimitiveKind::Union: {
                 Napi::Object members = Napi::Object::New(env);
 
                 for (const RecordMember &member: type->members) {
@@ -988,11 +1127,15 @@ static InstanceMemory *AllocateMemory(InstanceData *instance, Size stack_size, S
     for (Size i = 1; i < instance->memories.len; i++) {
         InstanceMemory *mem = instance->memories[i];
 
-        if (!mem->depth)
+        if (!mem->busy) {
+            mem->busy = true;
             return mem;
+        }
     }
 
-    if (RG_UNLIKELY(instance->temporaries >= instance->config.max_temporaries))
+    bool temporary = (instance->memories.len > instance->config.resident_async_pools);
+
+    if (RG_UNLIKELY(temporary && instance->temporaries >= instance->config.max_temporaries))
         return nullptr;
 
     InstanceMemory *mem = new InstanceMemory();
@@ -1048,16 +1191,16 @@ static InstanceMemory *AllocateMemory(InstanceData *instance, Size stack_size, S
 #endif
     RG_CRITICAL(mem->heap.ptr, "Failed to allocate %1 of memory", mem->heap.len);
 
-    mem->depth = 0;
-
-    if (instance->memories.len <= instance->config.resident_async_pools) {
-        instance->memories.Append(mem);
-        mem->temporary = false;
-    } else {
+    if (temporary) {
         instance->temporaries++;
         mem->temporary = true;
+    } else {
+        instance->memories.Append(mem);
+        mem->temporary = false;
     }
 
+    mem->busy = true;
+
     mem_guard.Disable();
     return mem;
 }
@@ -1820,7 +1963,6 @@ static Napi::Value CastValue(const Napi::CallbackInfo &info)
 static Napi::Value DecodeValue(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
 
     bool has_offset = (info.Length() >= 2 && info[1].IsNumber());
     bool has_len = (info.Length() >= 3u + has_offset && info[2u + has_offset].IsNumber());
@@ -1836,136 +1978,16 @@ static Napi::Value DecodeValue(const Napi::CallbackInfo &info)
 
     Napi::Value value = info[0];
     int64_t offset = has_offset ? info[1].As<Napi::Number>().Int64Value() : 0;
-
-    const uint8_t *ptr = nullptr;
-
-    if (value.IsExternal()) {
-        Napi::External<void> external = value.As<Napi::External<void>>();
-        ptr = (const uint8_t *)external.Data();
-    } else if (IsRawBuffer(value)) {
-        Span<uint8_t> buffer = GetRawBuffer(value);
-
-        if (RG_UNLIKELY(buffer.len - offset < type->size)) {
-            ThrowError<Napi::Error>(env, "Expected buffer with size superior or equal to type %1 (%2 bytes)",
-                                    type->name, type->size + offset);
-            return env.Null();
-        }
-
-        ptr = (const uint8_t *)buffer.ptr;
-    } else {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for variable, expected external or TypedArray", GetValueType(instance, info[0]));
-        return env.Null();
-    }
-
-    if (!ptr)
-        return env.Null();
-    ptr += offset;
-
-    // Used for strings and arrays, ignored otherwise
     int64_t len = has_len ? info[2u + has_offset].As<Napi::Number>().Int64Value() : -1;
 
-    if (has_len) {
-        if (RG_UNLIKELY(len < 0)) {
-            ThrowError<Napi::TypeError>(env, "Length must not be a negative value");
-            return env.Null();
-        }
-
-        if (type->primitive != PrimitiveKind::String && type->primitive != PrimitiveKind::String16) {
-            type = MakeArrayType(instance, type, len);
-        }
-    }
-
-#define RETURN_INT(Type, NewCall) \
-        do { \
-            Type v = *(Type *)ptr; \
-            return NewCall(env, v); \
-        } while (false)
-#define RETURN_INT_SWAP(Type, NewCall) \
-        do { \
-            Type v = ReverseBytes(*(Type *)ptr); \
-            return NewCall(env, v); \
-        } while (false)
-
-    switch (type->primitive) {
-        case PrimitiveKind::Void: {
-            ThrowError<Napi::TypeError>(env, "Cannot decode value of type %1", type->name);
-            return env.Null();
-        } break;
-
-        case PrimitiveKind::Bool: {
-            bool v = *(bool *)ptr;
-            return Napi::Boolean::New(env, v);
-        } break;
-        case PrimitiveKind::Int8: { RETURN_INT(int8_t, Napi::Number::New); } break;
-        case PrimitiveKind::UInt8: { RETURN_INT(uint8_t, Napi::Number::New); } break;
-        case PrimitiveKind::Int16: { RETURN_INT(int16_t, Napi::Number::New); } break;
-        case PrimitiveKind::Int16S: { RETURN_INT_SWAP(int16_t, Napi::Number::New); } break;
-        case PrimitiveKind::UInt16: { RETURN_INT(uint16_t, Napi::Number::New); } break;
-        case PrimitiveKind::UInt16S: { RETURN_INT_SWAP(uint16_t, Napi::Number::New); } break;
-        case PrimitiveKind::Int32: { RETURN_INT(int32_t, Napi::Number::New); } break;
-        case PrimitiveKind::Int32S: { RETURN_INT_SWAP(int32_t, Napi::Number::New); } break;
-        case PrimitiveKind::UInt32: { RETURN_INT(uint32_t, Napi::Number::New); } break;
-        case PrimitiveKind::UInt32S: { RETURN_INT_SWAP(uint32_t, Napi::Number::New); } break;
-        case PrimitiveKind::Int64: { RETURN_INT(int64_t, NewBigInt); } break;
-        case PrimitiveKind::Int64S: { RETURN_INT_SWAP(int64_t, NewBigInt); } break;
-        case PrimitiveKind::UInt64: { RETURN_INT(uint64_t, NewBigInt); } break;
-        case PrimitiveKind::UInt64S: { RETURN_INT_SWAP(uint64_t, NewBigInt); } break;
-        case PrimitiveKind::String: {
-            if (len >= 0) {
-                const char *str = *(const char **)ptr;
-                return str ? Napi::String::New(env, str, len) : env.Null();
-            } else {
-                const char *str = *(const char **)ptr;
-                return str ? Napi::String::New(env, str) : env.Null();
-            }
-        } break;
-        case PrimitiveKind::String16: {
-            if (len >= 0) {
-                const char16_t *str16 = *(const char16_t **)ptr;
-                return str16 ? Napi::String::New(env, str16, len) : env.Null();
-            } else {
-                const char16_t *str16 = *(const char16_t **)ptr;
-                return str16 ? Napi::String::New(env, str16) : env.Null();
-            }
-        } break;
-        case PrimitiveKind::Pointer: 
-        case PrimitiveKind::Callback: {
-            void *ptr2 = *(void **)ptr;
-            return ptr2 ? Napi::External<void>::New(env, ptr2, [](Napi::Env, void *) {}) : env.Null();
-        } break;
-        case PrimitiveKind::Array: {
-            Napi::Value array = DecodeArray(env, ptr, type);
-            return array;
-        } break;
-        case PrimitiveKind::Record: {
-            Napi::Object obj = DecodeObject(env, ptr, type);
-            return obj;
-        } break;
-        case PrimitiveKind::Float32: {
-            float f = *(float *)ptr;
-            return Napi::Number::New(env, f);
-        } break;
-        case PrimitiveKind::Float64: {
-            double d = *(double *)ptr;
-            return Napi::Number::New(env, d);
-        } break;
-
-        case PrimitiveKind::Prototype: {
-            ThrowError<Napi::TypeError>(env, "Cannot decode value of type %1", type->name);
-            return env.Null();
-        } break;
-    }
-
-#undef RETURN_BIGINT
-#undef RETURN_INT
-
-    return env.Null();
+    Napi::Value ret = Decode(value, offset, type, len);
+    return ret;
 }
 
 extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
 {
     if (RG_LIKELY(exec_call)) {
-        exec_call->RelaySafe(idx, own_sp, caller_sp, out_reg);
+        exec_call->RelaySafe(idx, own_sp, caller_sp, false, out_reg);
     } else {
         // This happens if the callback pointer is called from a different thread
         // than the one that runs the FFI call (sync or async).
@@ -1985,8 +2007,9 @@ extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, Bac
         RG_DEFER_C(generation = trampoline->generation) { trampoline->generation = generation; };
         trampoline->generation = -1;
 
+        // We set dispose_call to true so that the main thread will dispose of CallData itself
         CallData call(env, instance, mem);
-        call.RelaySafe(idx, own_sp, caller_sp, out_reg);
+        call.RelaySafe(idx, own_sp, caller_sp, true, out_reg);
     }
 }
 
@@ -1998,6 +2021,8 @@ static void SetExports(Napi::Env env, Func func)
 
     func("struct", Napi::Function::New(env, CreatePaddedStructType));
     func("pack", Napi::Function::New(env, CreatePackedStructType));
+    // func("union", Napi::Function::New(env, CreateUnionType));
+    // func("Union", Napi::Function::New(env, InstantiateUnion));
     func("opaque", Napi::Function::New(env, CreateOpaqueType));
     func("pointer", Napi::Function::New(env, CreatePointerType));
     func("array", Napi::Function::New(env, CreateArrayType));

package/src/koffi/src/ffi.hh

@@ -32,9 +32,6 @@ static const Size MaxParameters = 32;
 static const Size MaxOutParameters = 16;
 static const Size MaxTrampolines = 1024;
 
-extern const int TypeInfoMarker;
-extern const int CastMarker;
-
 enum class PrimitiveKind {
     Void,
     Bool,
@@ -56,6 +53,7 @@ enum class PrimitiveKind {
     String16,
     Pointer,
     Record,
+    Union,
     Array,
     Float32,
     Float64,
@@ -83,6 +81,7 @@ static const char *const PrimitiveKindNames[] = {
     "String16",
     "Pointer",
     "Record",
+    "Union",
     "Array",
     "Float32",
     "Float64",
@@ -96,13 +95,18 @@ struct FunctionInfo;
 
 typedef void DisposeFunc (Napi::Env env, const TypeInfo *type, const void *ptr);
 
-struct TypeInfo {
-    enum class ArrayHint {
-        Array,
-        TypedArray,
-        String
-    };
+enum class ArrayHint {
+    Array,
+    Typed,
+    String
+};
+static const char *const ArrayHintNames[] = {
+    "Array",
+    "Typed",
+    "String"
+};
 
+struct TypeInfo {
     const char *name;
 
     PrimitiveKind primitive;
@@ -120,6 +124,7 @@ struct TypeInfo {
     } ref;
     ArrayHint hint; // Array only
 
+    mutable Napi::FunctionReference construct; // Union only
     mutable Napi::ObjectReference defn;
 
     RG_HASHTABLE_HANDLER(TypeInfo, name);
@@ -174,6 +179,7 @@ struct ParameterInfo {
     bool use_memory; // Only used for return value on ARM32
     int8_t gpr_count;
     int8_t vec_count;
+    int8_t vec_bytes; // ARM64
 #elif defined(__i386__) || defined(_M_IX86)
     bool trivial; // Only matters for return value
     bool fast;
@@ -182,6 +188,7 @@ struct ParameterInfo {
     int8_t gpr_count;
     int8_t vec_count;
     bool gpr_first; // Only for structs
+    int8_t reg_size[2];
 #endif
 };
 
@@ -230,8 +237,9 @@ struct InstanceMemory {
 
     uint16_t generation; // Can wrap without risk
 
-    int16_t depth;
+    std::atomic_bool busy;
     bool temporary;
+    int depth;
 };
 
 struct InstanceData {

package/src/koffi/src/index.d.ts

@@ -18,20 +18,28 @@ declare module 'koffi' {
     interface IKoffiPointerCast { __brand: 'IKoffiPointerCast' }
     interface IKoffiRegisteredCallback { __brand: 'IKoffiRegisteredCallback' }
 
+    type PrimitiveKind = 'Void' | 'Bool' | 'Int8' | 'UInt8' | 'Int16' | 'Int16S' | 'UInt16' | 'UInt16S' |
+                         'Int32' | 'Int32S' | 'UInt32' | 'UInt32S' | 'Int64' | 'Int64S' | 'UInt64' | 'UInt64S' |
+                         'String' | 'String16' | 'Pointer' | 'Record' | 'Union' | 'Array' | 'Float32' | 'Float64' |
+                         'Prototype' | 'Callback';
+    type ArrayHint = 'Array' | 'Typed' | 'String';
+
     type TypeSpec = string | IKoffiCType;
     type TypeSpecWithAlignment = TypeSpec | [number, TypeSpec];
     type TypeInfo = {
         name: string;
-        primitive: string;
+        primitive: PrimitiveKind;
         size: number;
         alignment: number;
         disposable: boolean;
-        length: number;
-        ref: IKoffiCType;
-        members: Record<string, { name: string, type: IKoffiCType, offset: number }>;
+        length?: number;
+        hint?: ArrayHint;
+        ref?: IKoffiCType;
+        members?: Record<string, { name: string, type: IKoffiCType, offset: number }>;
     };
-    type KoffiFunction = Function & {
-        async: Function;
+    type KoffiFunction = {
+        (...args: any[]) : any;
+        async: (...args: any[]) => any;
         info: {
             name: string,
             arguments: IKoffiCType[],
@@ -39,6 +47,15 @@ declare module 'koffi' {
         };
     };
 
+    export type KoffiFunc<T extends (...args: any) => any> = T & {
+       async: (...args: [...Parameters<T>, (err: any, result: ReturnType<T>) => void]) => void;
+       info: {
+          name: string;
+          arguments: IKoffiCType[];
+          result: IKoffiCType;
+       };
+    };
+
     export interface IKoffiLib {
         func(definition: string): KoffiFunction;
         func(name: string, result: TypeSpec, arguments: TypeSpec[]): KoffiFunction;
@@ -58,10 +75,14 @@ declare module 'koffi' {
 
     export function struct(name: string, def: Record<string, TypeSpecWithAlignment>): IKoffiCType;
     export function struct(def: Record<string, TypeSpecWithAlignment>): IKoffiCType;
-
     export function pack(name: string, def: Record<string, TypeSpecWithAlignment>): IKoffiCType;
     export function pack(def: Record<string, TypeSpecWithAlignment>): IKoffiCType;
 
+    // export function union(name: string, def: Record<string, TypeSpecWithAlignment>): IKoffiCType;
+    // export function union(def: Record<string, TypeSpecWithAlignment>): IKoffiCType;
+
+    export function array(ref: TypeSpec, len: number, hint?: ArrayHint | null): IKoffiCType;
+
     export function opaque(name: string): IKoffiCType;
     export function opaque(): IKoffiCType;
 

package/src/koffi/src/index.js

@@ -13,12 +13,31 @@
 
 'use strict';
 
-if (process.versions.napi == null || process.versions.napi < 8)
-    throw new Error('This platform does not support N-API 8');
-
+const package = require('../package.json');
+const cnoke = require('../../cnoke');
 const util = require('util');
 
-let filename = __dirname + '/../build/koffi.node';
+if (process.versions.napi == null || process.versions.napi < 8) {
+    let major = parseInt(process.versions.node, 10);
+    let required = cnoke.get_napi_version(8, major);
+
+    if (required != null) {
+        throw new Error(`Project ${pkg.name} requires Node >= ${required} in the Node ${major}.x branch (N-API >= 8)`);
+    } else {
+        throw new Error(`Project ${pkg.name} does not support the Node ${major}.x branch (N-API < 8)`);
+    }
+}
+
+let arch = cnoke.determine_arch();
+let filename = __dirname + `/../build/${package.version}/koffi_${process.platform}_${arch}/koffi.node`;
+
+// Development build
+if (!fs.existsSync(filename)) {
+    let alternative = __dirname + '/../build/koffi.node';
+    if (fs.existsSync(alternative))
+        filename = alternative;
+}
+
 let native = require(filename);
 
 module.exports = {