koffi 2.5.21-beta.2 → 2.5.21-beta.4

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "koffi",
-    "version": "2.5.21-beta.2",
+    "version": "2.5.21-beta.4",
     "stable": "2.5.20",
     "description": "Fast and simple C FFI (foreign function interface) for Node.js",
     "keywords": [

package/src/core/libcc/libcc.hh

@@ -976,6 +976,8 @@ public:
     void *Resize(void *ptr, Size old_size, Size new_size, unsigned int flags = 0) override;
     void Release(const void *ptr, Size size) override;
 
+    bool IsUsed() const { return list.next; }
+
 private:
     static Bucket *PointerToBucket(void *ptr);
 };
@@ -1002,6 +1004,12 @@ public:
     void *Resize(void *ptr, Size old_size, Size new_size, unsigned int flags = 0) override;
     void Release(const void *ptr, Size size) override;
 
+    bool IsUsed() const
+    {
+        LinkedAllocator *alloc = ((BlockAllocatorBase *)this)->GetAllocator();
+        return alloc->IsUsed();
+    }
+
 protected:
     void CopyFrom(BlockAllocatorBase *other);
     void ForgetCurrentBlock();

package/src/index.d.ts

@@ -28,7 +28,7 @@ declare module 'koffi' {
 
     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' |
+                         'String' | 'String16' | 'Pointer' | 'Record' | 'Union' | 'Array' | 'Float32' | 'Float64' |
                          'Prototype' | 'Callback';
     type ArrayHint = 'Array' | 'Typed' | 'String';
 
@@ -80,6 +80,8 @@ declare module 'koffi' {
         thiscall(definition: string): KoffiFunction;
         thiscall(name: string, result: TypeSpec, arguments: TypeSpec[]): KoffiFunction;
 
+        symbol(name: string, type: TypeSpec): any;
+
         unload(): void;
     }
 
@@ -129,6 +131,12 @@ declare module 'koffi' {
     export function decode(value: any, offset: number, type: TypeSpec): any;
     export function decode(value: any, offset: number, type: TypeSpec, len: number): any;
     export function address(value: any): bigint;
+    export function encode(ref: any, type: TypeSpec): void;
+    export function encode(ref: any, type: TypeSpec, value: any): void;
+    export function encode(ref: any, type: TypeSpec, value: any, len: number): void;
+    export function encode(ref: any, offset: number, type: TypeSpec): void;
+    export function encode(ref: any, offset: number, type: TypeSpec, value: any): void;
+    export function encode(ref: any, offset: number, type: TypeSpec, value: any, len: number): void;
 
     export function sizeof(type: TypeSpec): number;
     export function alignof(type: TypeSpec): number;

package/src/index.js

@@ -378,7 +378,7 @@ var require_package = __commonJS({
   "build/dist/src/koffi/package.json"(exports2, module2) {
     module2.exports = {
       name: "koffi",
-      version: "2.5.21-beta.2",
+      version: "2.5.21-beta.4",
       stable: "2.5.20",
       description: "Fast and simple C FFI (foreign function interface) for Node.js",
       keywords: [

package/src/koffi/src/call.hh

@@ -126,6 +126,8 @@ public:
 
     void *ReserveTrampoline(const FunctionInfo *proto, Napi::Function func);
 
+    BlockAllocator *GetAllocator() { return &call_alloc; }
+
 private:
     template <typename T>
     bool AllocStack(Size size, Size align, T **out_ptr);

package/src/koffi/src/ffi.cc

@@ -1558,6 +1558,43 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConve
     return wrapper;
 }
 
+static Napi::Value FindSymbol(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    LibraryHolder *lib = (LibraryHolder *)info.Data();
+
+    if (info.Length() < 2) {
+        ThrowError<Napi::TypeError>(env, "Expected 2, got %1", info.Length());
+        return env.Null();
+    }
+     if (!info[0].IsString()) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string", GetValueType(instance, info[0]));
+        return env.Null();
+    }
+
+    std::string name = info[0].As<Napi::String>();
+
+    const TypeInfo *type = ResolveType(info[1]);
+    if (!type)
+        return env.Null();
+
+#ifdef _WIN32
+    void *ptr = (void *)GetProcAddress((HMODULE)lib->module, name.c_str());
+#else
+    void *ptr = (void *)dlsym(lib->module, name.c_str());
+#endif
+    if (!ptr) {
+        ThrowError<Napi::Error>(env, "Cannot find symbol '%1' in shared library", name.c_str());
+        return env.Null();
+    }
+
+    Napi::External<void> external = Napi::External<void>::New(env, ptr);
+    SetValueTag(instance, external, &type);
+
+    return external;
+}
+
 static Napi::Value UnloadLibrary(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
@@ -1607,6 +1644,18 @@ static Napi::Value LoadSharedLibrary(const Napi::CallbackInfo &info)
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for filename, expected string or null", GetValueType(instance, info[0]));
         return env.Null();
     }
+    if (info.Length() >= 2 && !IsObject(info[1])) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for options, expected object", GetValueType(instance, info[1]));
+        return env.Null();
+    }
+
+#ifndef _WIN32
+    bool lazy = false;
+    if (info.Length() >= 2) {
+        Napi::Object options = info[1].As<Napi::Object>();
+        lazy = options.Get("lazy").ToBoolean();
+    }
+#endif
 
     if (!instance->memories.len) {
         AllocateMemory(instance, instance->config.sync_stack_size, instance->config.sync_heap_size);
@@ -1628,8 +1677,10 @@ static Napi::Value LoadSharedLibrary(const Napi::CallbackInfo &info)
     }
 #else
     if (info[0].IsString()) {
+        int flags = lazy ? RTLD_LAZY : RTLD_NOW;
+
         std::string filename = info[0].As<Napi::String>();
-        module = dlopen(filename.c_str(), RTLD_NOW);
+        module = dlopen(filename.c_str(), flags);
 
         if (!module) {
             const char *msg = dlerror();
@@ -1654,13 +1705,14 @@ static Napi::Value LoadSharedLibrary(const Napi::CallbackInfo &info)
 
     Napi::Object obj = Napi::Object::New(env);
 
-#define ADD_CONVENTION(Name, Value) \
+#define ADD_METHOD(Name, Call) \
         do { \
-            const auto wrapper = [](const Napi::CallbackInfo &info) { return FindLibraryFunction(info, (Value)); }; \
+            const auto wrapper = [](const Napi::CallbackInfo &info) { return Call; }; \
             Napi::Function func = Napi::Function::New(env, wrapper, (Name), (void *)lib->Ref()); \
             func.AddFinalizer([](Napi::Env, LibraryHolder *lib) { lib->Unref(); }, lib); \
             obj.Set((Name), func); \
         } while (false)
+#define ADD_CONVENTION(Name, Value) ADD_METHOD((Name), FindLibraryFunction(info, Value))
 
     ADD_CONVENTION("func", CallConvention::Cdecl);
     ADD_CONVENTION("cdecl", CallConvention::Cdecl);
@@ -1668,10 +1720,14 @@ static Napi::Value LoadSharedLibrary(const Napi::CallbackInfo &info)
     ADD_CONVENTION("fastcall", CallConvention::Fastcall);
     ADD_CONVENTION("thiscall", CallConvention::Thiscall);
 
-#undef ADD_CONVENTION
+    ADD_METHOD("symbol", FindSymbol(info));
 
+    // We can't unref the library after unload, obviously
     obj.Set("unload", Napi::Function::New(env, UnloadLibrary, "unload", (void *)lib->Ref()));
 
+#undef ADD_CONVENTION
+#undef ADD_METHOD
+
     return obj;
 }
 

package/src/koffi/src/ffi.hh

@@ -287,6 +287,9 @@ struct InstanceData {
     void *main_stack_min;
 #endif
 
+    BucketArray<BlockAllocator> encode_allocators;
+    HashMap<void *, BlockAllocator *> encode_map;
+
     HashMap<void *, int16_t> trampolines_map;
 
     BlockAllocator str_alloc;

package/src/koffi/src/util.cc

@@ -1230,7 +1230,6 @@ bool Encode(Napi::Value ref, Size offset, Napi::Value value, const TypeInfo *typ
 bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *type, const Size *len)
 {
     InstanceData *instance = env.GetInstanceData<InstanceData>();
-    CallData *call = GetThreadCall();
 
     if (len && type->primitive != PrimitiveKind::String &&
                type->primitive != PrimitiveKind::String16 &&
@@ -1243,10 +1242,8 @@ bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *t
         type = MakeArrayType(instance, type, *len);
     }
 
-    if (!call) [[unlikely]] {
-        ThrowError<Napi::Error>(env, "koffi.encode() can only be used inside callbacks");
-        return false;
-    }
+    InstanceMemory mem = {};
+    CallData call(env, instance, &mem);
 
 #define PUSH_INTEGER(CType) \
         do { \
@@ -1297,19 +1294,19 @@ bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *t
         case PrimitiveKind::UInt64S: { PUSH_INTEGER_SWAP(uint64_t); } break;
         case PrimitiveKind::String: {
             const char *str;
-            if (!call->PushString(value, 1, &str)) [[unlikely]]
+            if (!call.PushString(value, 1, &str)) [[unlikely]]
                 return false;
             *(const char **)origin = str;
         } break;
         case PrimitiveKind::String16: {
             const char16_t *str16;
-            if (!call->PushString16(value, 1, &str16)) [[unlikely]]
+            if (!call.PushString16(value, 1, &str16)) [[unlikely]]
                 return false;
             *(const char16_t **)origin = str16;
         } break;
         case PrimitiveKind::Pointer: {
             void *ptr;
-            if (!call->PushPointer(value, type, 1, &ptr)) [[unlikely]]
+            if (!call.PushPointer(value, type, 1, &ptr)) [[unlikely]]
                 return false;
             *(void **)origin = ptr;
         } break;
@@ -1322,7 +1319,7 @@ bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *t
 
             Napi::Object obj = value.As<Napi::Object>();
 
-            if (!call->PushObject(obj, type, origin))
+            if (!call.PushObject(obj, type, origin))
                 return false;
         } break;
         case PrimitiveKind::Array: {
@@ -1330,15 +1327,15 @@ bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *t
                 Napi::Array array = value.As<Napi::Array>();
                 Size len = (Size)type->size / type->ref.type->size;
 
-                if (!call->PushNormalArray(array, len, type, origin))
+                if (!call.PushNormalArray(array, len, type, origin))
                     return false;
             } else if (IsRawBuffer(value)) {
                 Span<const uint8_t> buffer = GetRawBuffer(value);
 
-                if (!call->PushBuffer(buffer, type->size, type, origin))
+                if (!call.PushBuffer(buffer, type->size, type, origin))
                     return false;
             } else if (value.IsString()) {
-                if (!call->PushStringArray(value, type, origin))
+                if (!call.PushStringArray(value, type, origin))
                     return false;
             } else {
                 ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected array", GetValueType(instance, value));
@@ -1367,11 +1364,8 @@ bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *t
             void *ptr;
 
             if (value.IsFunction()) {
-                Napi::Function func = value.As<Napi::Function>();
-
-                ptr = call->ReserveTrampoline(type->ref.proto, func);
-                if (!ptr) [[unlikely]]
-                    return false;
+                ThrowError<Napi::Error>(env, "Cannot encode non-registered callback");
+                return false;
             } else if (CheckValueTag(instance, value, type->ref.marker)) {
                 ptr = value.As<Napi::External<void>>().Data();
             } else if (IsNullOrUndefined(value)) {
@@ -1390,6 +1384,22 @@ bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *t
 #undef PUSH_INTEGER_SWAP
 #undef PUSH_INTEGER
 
+    // Keep memory around if any was allocated
+    {
+        BlockAllocator *alloc = call.GetAllocator();
+
+        if (alloc->IsUsed()) {
+            BlockAllocator *copy = instance->encode_map.FindValue(origin, nullptr);
+
+            if (!copy) {
+                copy = instance->encode_allocators.AppendDefault();
+                instance->encode_map.Set(origin, copy);
+            }
+
+            std::swap(*alloc, *copy);
+        }
+    }
+
     return true;
 }