koffi 2.16.1 → 3.0.0-alpha.2

package/src/koffi/src/ffi.hh

@@ -22,66 +22,15 @@ static const Size MaxParameters = 64;
 static const Size MaxTrampolines = 8192;
 
 enum class PrimitiveKind {
-    // Void is explictly not first so that it is not 0, for reasons related to N-API type tags.
-    // Look at TypeInfo definition for more information!
-    Bool,
-    Void,
-    Int8,
-    UInt8,
-    Int16,
-    Int16S,  // Keep behind Int16
-    UInt16,
-    UInt16S, // Keep behind UInt16
-    Int32,
-    Int32S,  // Keep behind Int32
-    UInt32,
-    UInt32S, // Keep behind UInt32
-    Int64,
-    Int64S,  // Keep behind Int64
-    UInt64,
-    UInt64S, // Keep behind UInt64
-    String,
-    String16,
-    String32,
-    Pointer,
-    Record,
-    Union,
-    Array,
-    Float32,
-    Float64,
-    Prototype,
-    Callback
+    #define PRIMITIVE(Name) Name,
+    #include "primitives.inc"
 };
 static const char *const PrimitiveKindNames[] = {
-    "Bool",
-    "Void",
-    "Int8",
-    "UInt8",
-    "Int16",
-    "Int16S",
-    "UInt16",
-    "UInt16S",
-    "Int32",
-    "Int32S",
-    "UInt32",
-    "UInt32S",
-    "Int64",
-    "Int64S",
-    "UInt64",
-    "UInt64S",
-    "String",
-    "String16",
-    "String32",
-    "Pointer",
-    "Record",
-    "Union",
-    "Array",
-    "Float32",
-    "Float64",
-    "Prototype",
-    "Callback"
+    #define PRIMITIVE(Name) K_STRINGIFY(Name),
+    #include "primitives.inc"
 };
 
+struct InstanceData;
 struct TypeInfo;
 struct RecordMember;
 struct FunctionInfo;
@@ -109,7 +58,7 @@ static const char *const ArrayHintNames[] = {
 struct TypeInfo {
     const char *name;
 
-    // Make sure primitie ends up as the upper N-API tag value when we cast TypeInfo pointers to
+    // Make sure primitive ends up as the upper N-API tag value when we cast TypeInfo pointers to
     // napi_type_tag pointers. Yes, I want to do this. We don't do strict aliasing here.
     // N.B. Some node versions don't like when one of the two tag values is 0, so make sure
     // this does not happen! It would happen if primitive is 0 and size is 0. To avoid this
@@ -124,7 +73,6 @@ struct TypeInfo {
 
     HeapArray<RecordMember> members; // Record only
     union {
-        const void *marker;
         const TypeInfo *type; // Pointer or array
         const FunctionInfo *proto; // Callback only
     } ref;
@@ -139,6 +87,7 @@ struct TypeInfo {
 
 struct RecordMember {
     const char *name;
+    napi_ref key;
     const TypeInfo *type;
     int32_t offset;
     Size countedby;
@@ -170,6 +119,16 @@ static const char *const CallConventionNames[] = {
     "Thiscall"
 };
 
+enum class AbiMethod : int;
+
+struct AbiInstruction {
+    void *op;
+    int32_t a;
+    int16_t b1;
+    int16_t b2;
+    const TypeInfo *type;
+};
+
 struct ParameterInfo {
     const TypeInfo *type;
     int directions;
@@ -179,20 +138,47 @@ struct ParameterInfo {
     // ABI-specific part
 
 #if defined(_M_X64)
-    bool regular;
+    bool regular; // Used for structs and unions
 #elif defined(__x86_64__)
-    bool use_memory;
-    int8_t gpr_count;
-    int8_t xmm_count;
-    bool gpr_first;
+    struct {
+        bool regular;
+        int offsets[2];
+    } abi;
 #elif defined(__arm__) || defined(__aarch64__) || defined(_M_ARM64)
-    bool use_memory; // Only used for return value on ARM32
+    struct {
+        bool regular;
+        bool indirect;
+        int hfa32;
+        int offset;
+    } abi;
+#elif __riscv_xlen == 64 || defined(__loongarch64)
+    bool use_memory;
     int8_t gpr_count;
     int8_t vec_count;
-    int8_t vec_bytes; // ARM64
+    bool gpr_first; // Only for structs
+    int8_t reg_size[2];
+#endif
+};
+
+struct ReturnInfo {
+    const TypeInfo *type;
+
+    // ABI-specific part
+
+#if defined(_M_X64)
+    bool regular;
+#elif defined(__x86_64__)
+    struct {
+        AbiMethod method;
+    } abi;
+#elif defined(__arm__) || defined(__aarch64__) || defined(_M_ARM64)
+    struct {
+        bool regular;
+        int hfa32;
+        int offset;
+    } abi;
 #elif defined(__i386__) || defined(_M_IX86)
-    bool trivial; // Only matters for return value
-    int8_t fast;
+    bool trivial;
 #elif __riscv_xlen == 64 || defined(__loongarch64)
     bool use_memory;
     int8_t gpr_count;
@@ -203,35 +189,42 @@ struct ParameterInfo {
 };
 
 struct ValueCast {
-    Napi::Reference<Napi::Value> ref;
+    napi_env env;
+    napi_ref ref;
     const TypeInfo *type;
+
+    ~ValueCast();
 };
 
 // Also used for callbacks, even though many members are not used in this case
 struct FunctionInfo {
     mutable std::atomic_int refcount { 1 };
 
+    napi_env env;
+    InstanceData *instance;
+    const LibraryHolder *lib = nullptr;
+
     const char *name;
     const char *decorated_name; // Only set for some platforms/calling conventions
 #if defined(_WIN32)
     int ordinal_name = -1;
 #endif
-    const LibraryHolder *lib = nullptr;
 
     void *native;
     CallConvention convention;
 
-    ParameterInfo ret;
+    ReturnInfo ret;
     HeapArray<ParameterInfo> parameters;
     int8_t required_parameters;
-    int8_t out_parameters;
     bool variadic;
 
     // ABI-specific part
 
-    Size args_size;
+    HeapArray<AbiInstruction> sync;
+    HeapArray<AbiInstruction> async;
+    Size stk_size;
 #if defined(__i386__) || defined(_M_IX86)
-    bool fast;
+    int ret_pop;
 #else
     bool forward_fp;
 #endif
@@ -242,28 +235,36 @@ struct FunctionInfo {
     void Unref() const;
 };
 
+template <typename T>
+struct MemoryRange {
+    T *ptr;
+    T *end;
+};
+
 struct InstanceMemory {
     ~InstanceMemory();
 
-    Span<uint8_t> stack;
-    Span<uint8_t> stack0;
-    Span<uint8_t> heap;
+    MemoryRange<uint8_t> stack;
+    MemoryRange<uint8_t> stack0;
+    MemoryRange<uint8_t> heap;
+
+    // For big heap allocations
+    LinkedAllocator allocator;
 
     bool busy;
     bool temporary;
-    int depth;
 };
 
 struct InstanceData {
     ~InstanceData();
 
+    napi_env env;
+
     BucketArray<TypeInfo> types;
     HashMap<const char *, const TypeInfo *> types_map;
     BucketArray<FunctionInfo> callbacks;
     Size base_types_count;
 
-    bool debug;
-
     const TypeInfo *void_type;
     const TypeInfo *char_type;
     const TypeInfo *char16_type;
@@ -278,18 +279,23 @@ struct InstanceData {
     LocalArray<InstanceMemory *, 17> memories;
     int temporaries = 0;
 
+    // Variadic cache
+    FunctionInfo *variadic_func = nullptr;
+
+    napi_value (*translate_zero_call)(napi_env env, napi_callback_info info);
+
     std::thread::id main_thread_id;
     napi_threadsafe_function broker = nullptr;
 
+    CallData *sync_call = nullptr;
+
 #if defined(_WIN32)
     void *main_stack_max;
     void *main_stack_min;
-
-    uint32_t last_error = 0;
 #endif
 
-    BucketArray<BlockAllocator> encode_allocators;
-    HashMap<void *, BlockAllocator *> encode_map;
+    BucketArray<LinkedAllocator> encode_allocators;
+    HashMap<void *, LinkedAllocator *> encode_map;
 
     HashMap<void *, int16_t> trampolines_map;
 
@@ -303,6 +309,9 @@ struct InstanceData {
         int resident_async_pools = DefaultResidentAsyncPools;
         int max_temporaries = DefaultMaxAsyncCalls - DefaultResidentAsyncPools;
         Size max_type_size = DefaultMaxTypeSize;
+
+        bool fast_pointers = true;
+        bool fast_callbacks = true;
     } config;
 
     struct {
@@ -314,13 +323,12 @@ static_assert(DefaultMaxAsyncCalls >= DefaultResidentAsyncPools);
 static_assert(MaxAsyncCalls >= DefaultMaxAsyncCalls);
 
 struct TrampolineInfo {
-    InstanceData *instance;
+    int state;
 
+    InstanceData *instance;
     const FunctionInfo *proto;
     Napi::FunctionReference func;
     Napi::Reference<Napi::Value> recv;
-
-    bool used;
 };
 
 struct SharedData {
@@ -342,12 +350,18 @@ static_assert(MaxTrampolines <= INT16_MAX);
 
 extern SharedData shared;
 
+// Recent N-API functions are loaded dynamically
+extern napi_status (NAPI_CDECL *node_api_create_property_key_utf8)(napi_env env, const char* str, size_t length, napi_value* result);
+extern napi_status (NAPI_CDECL *node_api_post_finalizer)(node_api_basic_env env, napi_finalize finalize_cb, void* finalize_data, void* finalize_hint);
+extern napi_value (*translate_zero_call)(napi_env env, napi_callback_info info);
+
 InstanceMemory *AllocateMemory(InstanceData *instance, Size stack_size, Size heap_size);
 void ReleaseMemory(InstanceData *instance, InstanceMemory *mem);
 
-Napi::Value TranslateNormalCall(const Napi::CallbackInfo &info);
-Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info);
-Napi::Value TranslateAsyncCall(const Napi::CallbackInfo &info);
+napi_value TranslateFastCall(napi_env env, napi_callback_info info);
+napi_value TranslateNormalCall(napi_env env, napi_callback_info info);
+napi_value TranslateVariadicCall(napi_env env, napi_callback_info info);
+napi_value TranslateAsyncCall(napi_env env, napi_callback_info info);
 
 bool InitAsyncBroker(Napi::Env env, InstanceData *instance);
 

package/src/koffi/src/parser.cc

@@ -60,10 +60,6 @@ bool PrototypeParser::Parse(const char *str, bool concrete, FunctionInfo *out_fu
                 MarkError("Functions cannot have more than %1 parameters", MaxParameters);
                 return false;
             }
-            if ((param.directions & 2) && ++out_func->out_parameters >= MaxParameters) {
-                MarkError("Functions cannot have more than out %1 parameters", MaxParameters);
-                return false;
-            }
 
             param.offset = (int8_t)out_func->parameters.len;
 

package/src/koffi/src/primitives.inc

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// SPDX-FileCopyrightText: 2025 Niels Martignène <niels.martignene@protonmail.com>
+
+#if !defined(PRIMITIVE)
+    #error Please define PRIMITIVE() before including primitives.inc
+#endif
+
+// Void is explictly not first so that it is not 0, for reasons related to N-API type tags.
+// Look at TypeInfo definition for more information!
+
+PRIMITIVE(Bool)
+PRIMITIVE(Void)
+PRIMITIVE(Int8)
+PRIMITIVE(UInt8)
+PRIMITIVE(Int16)
+PRIMITIVE(Int16S)  // Keep behind Int16
+PRIMITIVE(UInt16)
+PRIMITIVE(UInt16S) // Keep behind UInt16
+PRIMITIVE(Int32)
+PRIMITIVE(Int32S)  // Keep behind Int32
+PRIMITIVE(UInt32)
+PRIMITIVE(UInt32S) // Keep behind UInt32
+PRIMITIVE(Int64)
+PRIMITIVE(Int64S)  // Keep behind Int64
+PRIMITIVE(UInt64)
+PRIMITIVE(UInt64S) // Keep behind UInt64
+PRIMITIVE(String)
+PRIMITIVE(String16)
+PRIMITIVE(String32)
+PRIMITIVE(Pointer)
+PRIMITIVE(Record)
+PRIMITIVE(Union)
+PRIMITIVE(Array)
+PRIMITIVE(Float32)
+PRIMITIVE(Float64)
+PRIMITIVE(Callback)
+PRIMITIVE(Prototype)
+
+#undef PRIMITIVE

package/src/koffi/{tools/write_trampolines.js → src/trampolines.js}

@@ -20,7 +20,7 @@ function run() {
     let args = process.argv.slice(2);
 
     if (args.length < 2)
-        throw new Error('Usage: write_trampolines.js DIRECTORY N');
+        throw new Error('Usage: trampolines.js DIRECTORY N');
 
     let dest_dir = args[0]?.trim?.();
     let n = parseInt(args[1], 10);