koffi 3.0.1 → 3.1.0

package/src/koffi/src/ffi.hh

@@ -12,6 +12,34 @@ namespace K {
 // #define EXTERNAL_POINTERS
 // #define EXTERNAL_TYPES
 
+#if defined(_MSC_VER)
+    #define FORCE_INLINE __forceinline
+#else
+    #define FORCE_INLINE __attribute__((always_inline)) inline
+#endif
+#if defined(UNITY_BUILD)
+    #define INLINE_UNITY FORCE_INLINE
+#else
+    #define INLINE_UNITY
+#endif
+
+#if defined(__GNUC__) || defined(__clang__)
+    #if  __has_attribute(musttail) && __has_attribute(preserve_none)
+        #define MUST_TAIL __attribute__((musttail))
+        #define PRESERVE_NONE __attribute__((preserve_none))
+    #elif  __has_attribute(musttail) && !defined(__clang__)
+        // GCC regalloc seems better, so the generated code is not too bad even without preserve_none
+        #define MUST_TAIL __attribute__((musttail))
+        #define PRESERVE_NONE
+    #endif
+#endif
+
+#define NAPI_OK(Call) \
+    do { \
+        napi_status _status = (Call); \
+        K_ASSERT(_status == napi_ok); \
+    } while (false)
+
 static const Size DefaultSyncStackSize = Mebibytes(1);
 static const Size DefaultSyncHeapSize = Mebibytes(2);
 static const Size DefaultAsyncStackSize = Kibibytes(128);
@@ -39,7 +67,7 @@ struct RecordMember;
 struct FunctionInfo;
 struct CallData;
 
-typedef void DisposeFunc (Napi::Env env, const TypeInfo *type, const void *ptr);
+typedef void DisposeFunc (InstanceData *instance, const TypeInfo *type, const void *ptr);
 
 enum class TypeFlag {
     HasTypedArray = 1 << 0,
@@ -50,32 +78,42 @@ enum class TypeFlag {
 enum class ArrayHint {
     Array,
     Typed,
+    Buffer,
     String
 };
 static const char *const ArrayHintNames[] = {
     "Array",
     "Typed",
+    "Buffer",
     "String"
 };
 
 struct RecordMember {
     const char *name;
-    napi_ref key;
     const TypeInfo *type;
     int32_t offset;
     Size countedby;
+
+    napi_ref key = nullptr;
+
+#if defined(K_DEBUG)
+    ~RecordMember() { K_ASSERT(!key); }
+#endif
 };
 
 struct TypeInfo {
-    const char *name;
+    K_DELETE_COPY(TypeInfo)
+
+    InstanceData *instance = nullptr;
 
+    const char *name;
     alignas(8) PrimitiveKind primitive;
     int32_t size;
     int16_t align;
     uint16_t flags;
 
-    DisposeFunc *dispose;
-    Napi::FunctionReference dispose_ref;
+    DisposeFunc *dispose = nullptr;
+    napi_ref dispose_ref = nullptr;
 
     HeapArray<RecordMember> members; // Record or Union
     struct {
@@ -86,15 +124,23 @@ struct TypeInfo {
     ArrayHint hint; // Array only
     const char *countedby; // Pointer or array
 
-    mutable Napi::FunctionReference construct; // Union only
-    mutable Napi::ObjectReference defn;
+    mutable napi_ref construct = nullptr; // Union only
+    mutable napi_ref defn = nullptr;
 
-    mutable const TypeInfo *reshaped;
+    mutable const TypeInfo *reshaped = nullptr;
+
+    TypeInfo() = default;
+    ~TypeInfo();
+
+    TypeInfo(TypeInfo &&other) = default;
+    TypeInfo &operator=(TypeInfo &&other) = default;
 
     K_HASHTABLE_HANDLER(TypeInfo, name);
 };
 
 struct LibraryHolder {
+    K_DELETE_COPY(LibraryHolder)
+
     void *module = nullptr; // HMODULE on Windows
     mutable int refcount = 1;
 
@@ -121,7 +167,7 @@ class LibraryHandle: public Napi::ObjectWrap<LibraryHandle> {
     LibraryHolder *lib = nullptr;
 
 public:
-    static Napi::Function InitClass(Napi::Env env);
+    static Napi::Function InitClass(InstanceData *instance);
 
     LibraryHandle(const Napi::CallbackInfo &info);
 
@@ -166,7 +212,9 @@ struct ParameterInfo {
     // ABI-specific part
 
 #if defined(_M_X64)
-    bool regular; // Used for structs and unions
+    struct {
+        bool regular; // Used for structs and unions
+    } abi;
 #elif defined(__x86_64__)
     struct {
         bool regular;
@@ -192,7 +240,9 @@ struct ReturnInfo {
     // ABI-specific part
 
 #if defined(_M_X64)
-    bool regular;
+    struct {
+        bool regular;
+    } abi;
 #elif defined(__x86_64__)
     struct {
         AbiMethod method;
@@ -203,7 +253,9 @@ struct ReturnInfo {
         int offset;
     } abi;
 #elif defined(__i386__) || defined(_M_IX86)
-    bool trivial;
+    struct {
+        bool regular;
+    } abi;
 #elif __riscv_xlen == 64 || defined(__loongarch64)
     struct {
         AbiMethod method;
@@ -322,8 +374,6 @@ struct InstanceData {
     // 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;
 
@@ -389,15 +439,21 @@ struct SharedData {
 };
 static_assert(MaxTrampolines <= INT16_MAX);
 
+extern const napi_type_tag LibraryHandleMarker;
+extern const napi_type_tag TypeObjectMarker;
+extern const napi_type_tag DirectionMarker;
+extern const napi_type_tag UnionValueMarker;
+extern const napi_type_tag CastMarker;
+
 extern SharedData shared;
 
 // Some Node-API functions are loaded dynamically to work around bugs or because they are recent
+extern napi_status (NAPI_CDECL *node_api_delete_reference)(node_api_basic_env env, napi_ref ref);
 extern napi_status (NAPI_CDECL *node_api_get_buffer_info)(napi_env env, napi_value value, void **data, size_t *length);
 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_status (NAPI_CDECL *node_api_create_object_with_properties)(napi_env env, napi_value prototype_or_null, const napi_value *property_names,
                                                                         const napi_value *property_values, size_t property_count, napi_value *result);
-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);

package/src/koffi/src/parser.cc

@@ -2,8 +2,10 @@
 // SPDX-FileCopyrightText: 2026 Niels Martignène <niels.martignene@protonmail.com>
 
 #include "lib/native/base/base.hh"
+#include "call.hh"
 #include "ffi.hh"
 #include "parser.hh"
+#include "type.hh"
 
 #include <napi.h>
 
@@ -159,7 +161,7 @@ const TypeInfo *PrototypeParser::ParseType(int *out_directions)
 
     while (offset >= start) {
         Span<const char> str = MakeSpan(tokens[start].ptr, tokens[offset].end() - tokens[start].ptr);
-        const TypeInfo *type = ResolveType(env, str);
+        const TypeInfo *type = ResolveType(instance, str);
 
         if (type) {
             offset++;
@@ -207,9 +209,9 @@ bool PrototypeParser::IsIdentifier(Span<const char> tok) const
     return IsAsciiAlpha(tok[0]) || tok[0] == '_';
 }
 
-bool ParsePrototype(Napi::Env env, const char *str, bool concrete, FunctionInfo *out_func)
+bool ParsePrototype(InstanceData *instance, const char *str, bool concrete, FunctionInfo *out_func)
 {
-    PrototypeParser parser(env);
+    PrototypeParser parser(instance);
     return parser.Parse(str, concrete, out_func);
 }
 

package/src/koffi/src/parser.hh

@@ -24,7 +24,7 @@ class PrototypeParser {
     bool valid;
 
 public:
-    PrototypeParser(Napi::Env env) : env(env), instance(env.GetInstanceData<InstanceData>()) {}
+    PrototypeParser(InstanceData *instance) : env(instance->env), instance(instance) {}
 
     bool Parse(const char *str, bool concrete, FunctionInfo *out_func);
 
@@ -49,6 +49,6 @@ private:
     }
 };
 
-bool ParsePrototype(Napi::Env env, const char *str, bool concrete, FunctionInfo *out_func);
+bool ParsePrototype(InstanceData *instance, const char *str, bool concrete, FunctionInfo *out_func);
 
 }

package/src/koffi/src/static.cjs

@@ -0,0 +1,122 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2026 Niels Martignène <niels.martignene@protonmail.com>
+
+function loadStatic(pkg) {
+    let native = null;
+
+    if (pkg == 'linux-arm64') {
+        try {
+            native = require('@koromix/koffi-linux-arm64');
+        } catch (err) {
+            // Go on
+        }
+    }
+
+    if (pkg == 'linux-ia32') {
+        try {
+            native = require('@koromix/koffi-linux-ia32');
+        } catch (err) {
+            // Go on
+        }
+    }
+
+    if (pkg == 'linux-x64') {
+        try {
+            native = require('@koromix/koffi-linux-x64');
+        } catch (err) {
+            // Go on
+        }
+    }
+
+    if (pkg == 'linux-riscv64') {
+        try {
+            native = require('@koromix/koffi-linux-riscv64');
+        } catch (err) {
+            // Go on
+        }
+    }
+
+    if (pkg == 'freebsd-ia32') {
+        try {
+            native = require('@koromix/koffi-freebsd-ia32');
+        } catch (err) {
+            // Go on
+        }
+    }
+
+    if (pkg == 'freebsd-x64') {
+        try {
+            native = require('@koromix/koffi-freebsd-x64');
+        } catch (err) {
+            // Go on
+        }
+    }
+
+    if (pkg == 'freebsd-arm64') {
+        try {
+            native = require('@koromix/koffi-freebsd-arm64');
+        } catch (err) {
+            // Go on
+        }
+    }
+
+    if (pkg == 'openbsd-ia32') {
+        try {
+            native = require('@koromix/koffi-openbsd-ia32');
+        } catch (err) {
+            // Go on
+        }
+    }
+
+    if (pkg == 'openbsd-x64') {
+        try {
+            native = require('@koromix/koffi-openbsd-x64');
+        } catch (err) {
+            // Go on
+        }
+    }
+
+    if (pkg == 'win32-ia32') {
+        try {
+            native = require('@koromix/koffi-win32-ia32');
+        } catch (err) {
+            // Go on
+        }
+    }
+
+    if (pkg == 'win32-x64') {
+        try {
+            native = require('@koromix/koffi-win32-x64');
+        } catch (err) {
+            // Go on
+        }
+    }
+
+    if (pkg == 'darwin-x64') {
+        try {
+            native = require('@koromix/koffi-darwin-x64');
+        } catch (err) {
+            // Go on
+        }
+    }
+
+    if (pkg == 'darwin-arm64') {
+        try {
+            native = require('@koromix/koffi-darwin-arm64');
+        } catch (err) {
+            // Go on
+        }
+    }
+
+    if (pkg == 'linux-loong64') {
+        try {
+            native = require('@koromix/koffi-linux-loong64');
+        } catch (err) {
+            // Go on
+        }
+    }
+
+    return native;
+}
+
+module.exports = { loadStatic };

package/src/koffi/src/static.js

@@ -0,0 +1,125 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2026 Niels Martignène <niels.martignene@protonmail.com>
+
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+
+function loadStatic(pkg) {
+    let native = null;
+
+    if (pkg == 'linux-arm64') {
+        try {
+            native = require('@koromix/koffi-linux-arm64');
+        } catch (err) {
+            // Go on
+        }
+    }
+
+    if (pkg == 'linux-ia32') {
+        try {
+            native = require('@koromix/koffi-linux-ia32');
+        } catch (err) {
+            // Go on
+        }
+    }
+
+    if (pkg == 'linux-x64') {
+        try {
+            native = require('@koromix/koffi-linux-x64');
+        } catch (err) {
+            // Go on
+        }
+    }
+
+    if (pkg == 'linux-riscv64') {
+        try {
+            native = require('@koromix/koffi-linux-riscv64');
+        } catch (err) {
+            // Go on
+        }
+    }
+
+    if (pkg == 'freebsd-ia32') {
+        try {
+            native = require('@koromix/koffi-freebsd-ia32');
+        } catch (err) {
+            // Go on
+        }
+    }
+
+    if (pkg == 'freebsd-x64') {
+        try {
+            native = require('@koromix/koffi-freebsd-x64');
+        } catch (err) {
+            // Go on
+        }
+    }
+
+    if (pkg == 'freebsd-arm64') {
+        try {
+            native = require('@koromix/koffi-freebsd-arm64');
+        } catch (err) {
+            // Go on
+        }
+    }
+
+    if (pkg == 'openbsd-ia32') {
+        try {
+            native = require('@koromix/koffi-openbsd-ia32');
+        } catch (err) {
+            // Go on
+        }
+    }
+
+    if (pkg == 'openbsd-x64') {
+        try {
+            native = require('@koromix/koffi-openbsd-x64');
+        } catch (err) {
+            // Go on
+        }
+    }
+
+    if (pkg == 'win32-ia32') {
+        try {
+            native = require('@koromix/koffi-win32-ia32');
+        } catch (err) {
+            // Go on
+        }
+    }
+
+    if (pkg == 'win32-x64') {
+        try {
+            native = require('@koromix/koffi-win32-x64');
+        } catch (err) {
+            // Go on
+        }
+    }
+
+    if (pkg == 'darwin-x64') {
+        try {
+            native = require('@koromix/koffi-darwin-x64');
+        } catch (err) {
+            // Go on
+        }
+    }
+
+    if (pkg == 'darwin-arm64') {
+        try {
+            native = require('@koromix/koffi-darwin-arm64');
+        } catch (err) {
+            // Go on
+        }
+    }
+
+    if (pkg == 'linux-loong64') {
+        try {
+            native = require('@koromix/koffi-linux-loong64');
+        } catch (err) {
+            // Go on
+        }
+    }
+
+    return native;
+}
+
+export { loadStatic }