koffi 2.5.21-beta.1 → 2.5.21-beta.3

package/doc/contribute.md

@@ -129,16 +129,24 @@ node qemu.js info debian_x64
 
 ## Making a release
 
-First, change the version numbers in `package.json`. Then publish a new release with the following commands:
+First, you must update the code in three steps:
+
+- Change the version numbers in `package.json` (version and stable for stable releases)
+- Add an entry to `CHANGELOG.md` to summarize the changes since last release
+- Commit theses changes with the message *Bump Koffi to X.Y.Z*
+
+Once this is done, you can publish a new release with the following commands:
 
 ```sh
-node qemu.js test
+node qemu.js test # If not done before
 node qemu.js dist
 
 cd build/dist
 npm publish
 ```
 
+Some platforms are emulated so this can take a few minutes until the pre-built binaries are ready. Go grab a cup of coffee, come back and execute the `npm publish` command!
+
 ## Code style
 
 Koffi is programmed in a mix of C++ and assembly code (architecture-specific code). It uses [node-addon-api](https://github.com/nodejs/node-addon-api) (C++ N-API wrapper) to interact with Node.js.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "koffi",
-    "version": "2.5.21-beta.1",
+    "version": "2.5.21-beta.3",
     "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.1",
+      version: "2.5.21-beta.3",
       stable: "2.5.20",
       description: "Fast and simple C FFI (foreign function interface) for Node.js",
       keywords: [

package/src/koffi/src/call.cc

@@ -1165,6 +1165,61 @@ Size CallData::PushIndirectString(Napi::Array array, const TypeInfo *ref, uint8_
     }
 }
 
+void *CallData::ReserveTrampoline(const FunctionInfo *proto, Napi::Function func)
+{
+    if (!InitAsyncBroker(env, instance)) [[unlikely]]
+        return nullptr;
+
+    int16_t idx;
+    {
+        std::lock_guard<std::mutex> lock(shared.mutex);
+
+        if (!shared.available.len) [[unlikely]] {
+            ThrowError<Napi::Error>(env, "Too many callbacks are in use (max = %1)", MaxTrampolines);
+            return env.Null();
+        }
+        if (!used_trampolines.Available()) [[unlikely]] {
+            ThrowError<Napi::Error>(env, "This call uses too many temporary callbacks (max = %1)", RG_LEN(used_trampolines.data));
+            return env.Null();
+        }
+
+        idx = shared.available.data[--shared.available.len];
+        used_trampolines.Append(idx);
+    }
+
+    TrampolineInfo *trampoline = &shared.trampolines[idx];
+
+    trampoline->instance = instance;
+    trampoline->proto = proto;
+    trampoline->func.Reset(func, 1);
+    trampoline->recv.Reset();
+    trampoline->generation = (int32_t)mem->generation;
+
+    void *ptr = GetTrampoline(idx, proto);
+
+    return ptr;
+}
+
+void CallData::DumpForward(const FunctionInfo *func) const
+{
+    PrintLn(stderr, "%!..+---- %1 (%2) ----%!0", func->name, CallConventionNames[(int)func->convention]);
+
+    if (func->parameters.len) {
+        PrintLn(stderr, "Parameters:");
+        for (Size i = 0; i < func->parameters.len; i++) {
+            const ParameterInfo &param = func->parameters[i];
+            PrintLn(stderr, "  %1 = %2 (%3)", i, param.type->name, FmtMemSize(param.type->size));
+        }
+    }
+    PrintLn(stderr, "Return: %1 (%2)", func->ret.type->name, FmtMemSize(func->ret.type->size));
+
+    Span<const uint8_t> stack = MakeSpan(mem->stack.end(), old_stack_mem.end() - mem->stack.end());
+    Span<const uint8_t> heap = MakeSpan(old_heap_mem.ptr, mem->heap.ptr - old_heap_mem.ptr);
+
+    DumpMemory("Stack", stack);
+    DumpMemory("Heap", heap);
+}
+
 static inline Napi::Value GetReferenceValue(Napi::Env env, napi_ref ref)
 {
     napi_value value;
@@ -1234,59 +1289,4 @@ void CallData::PopOutArguments()
     }
 }
 
-void *CallData::ReserveTrampoline(const FunctionInfo *proto, Napi::Function func)
-{
-    if (!InitAsyncBroker(env, instance)) [[unlikely]]
-        return nullptr;
-
-    int16_t idx;
-    {
-        std::lock_guard<std::mutex> lock(shared.mutex);
-
-        if (!shared.available.len) [[unlikely]] {
-            ThrowError<Napi::Error>(env, "Too many callbacks are in use (max = %1)", MaxTrampolines);
-            return env.Null();
-        }
-        if (!used_trampolines.Available()) [[unlikely]] {
-            ThrowError<Napi::Error>(env, "This call uses too many temporary callbacks (max = %1)", RG_LEN(used_trampolines.data));
-            return env.Null();
-        }
-
-        idx = shared.available.data[--shared.available.len];
-        used_trampolines.Append(idx);
-    }
-
-    TrampolineInfo *trampoline = &shared.trampolines[idx];
-
-    trampoline->instance = instance;
-    trampoline->proto = proto;
-    trampoline->func.Reset(func, 1);
-    trampoline->recv.Reset();
-    trampoline->generation = (int32_t)mem->generation;
-
-    void *ptr = GetTrampoline(idx, proto);
-
-    return ptr;
-}
-
-void CallData::DumpForward(const FunctionInfo *func) const
-{
-    PrintLn(stderr, "%!..+---- %1 (%2) ----%!0", func->name, CallConventionNames[(int)func->convention]);
-
-    if (func->parameters.len) {
-        PrintLn(stderr, "Parameters:");
-        for (Size i = 0; i < func->parameters.len; i++) {
-            const ParameterInfo &param = func->parameters[i];
-            PrintLn(stderr, "  %1 = %2 (%3)", i, param.type->name, FmtMemSize(param.type->size));
-        }
-    }
-    PrintLn(stderr, "Return: %1 (%2)", func->ret.type->name, FmtMemSize(func->ret.type->size));
-
-    Span<const uint8_t> stack = MakeSpan(mem->stack.end(), old_stack_mem.end() - mem->stack.end());
-    Span<const uint8_t> heap = MakeSpan(old_heap_mem.ptr, mem->heap.ptr - old_heap_mem.ptr);
-
-    DumpMemory("Stack", stack);
-    DumpMemory("Heap", heap);
-}
-
 }

package/src/koffi/src/call.hh

@@ -113,12 +113,6 @@ public:
 
     void DumpForward(const FunctionInfo *func) const;
 
-private:
-    template <typename T>
-    bool AllocStack(Size size, Size align, T **out_ptr);
-    template <typename T = uint8_t>
-    T *AllocHeap(Size size, Size align);
-
     bool PushString(Napi::Value value, int directions, const char **out_str);
     Size PushStringValue(Napi::Value value, const char **out_str);
     bool PushString16(Napi::Value value, int directions, const char16_t **out_str16);
@@ -130,9 +124,17 @@ private:
     bool PushPointer(Napi::Value value, const TypeInfo *type, int directions, void **out_ptr);
     Size PushIndirectString(Napi::Array array, const TypeInfo *ref, uint8_t **out_ptr);
 
-    void PopOutArguments();
-
     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);
+    template <typename T = uint8_t>
+    T *AllocHeap(Size size, Size align);
+
+    void PopOutArguments();
 };
 
 template <typename T>

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();
@@ -1654,13 +1691,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 +1706,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;
 }
 
@@ -1897,6 +1939,39 @@ static Napi::Value CallPointerSync(const Napi::CallbackInfo &info)
                            : TranslateNormalCall(proto, ptr, info);
 }
 
+static Napi::Value EncodeValue(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    bool has_offset = (info.Length() >= 2 && info[1].IsNumber());
+    bool has_len = (info.Length() >= 4u + has_offset && info[2u + has_offset].IsNumber());
+
+    if (info.Length() < 3u + has_offset) [[unlikely]] {
+        ThrowError<Napi::TypeError>(env, "Expected %1 to 5 arguments, got %2", 3 + has_offset, info.Length());
+        return env.Null();
+    }
+
+    const TypeInfo *type = ResolveType(info[1u + has_offset]);
+    if (!type) [[unlikely]]
+        return env.Null();
+
+    Napi::Value ref = info[0];
+    int64_t offset = has_offset ? info[1].As<Napi::Number>().Int64Value() : 0;
+    Napi::Value value = info[2u + has_offset + has_len];
+
+    if (has_len) {
+        Size len = info[2u + has_offset].As<Napi::Number>();
+
+        if (!Encode(ref, offset, value, type, &len))
+            return env.Null();
+    } else {
+        if (!Encode(ref, offset, value, type))
+            return env.Null();
+    }
+
+    return env.Undefined();
+}
+
 void LibraryHolder::Unload()
 {
 #ifdef _WIN32
@@ -1980,6 +2055,11 @@ bool InitAsyncBroker(Napi::Env env, InstanceData *instance)
     return true;
 }
 
+CallData *GetThreadCall()
+{
+    return exec_call;
+}
+
 static void RegisterPrimitiveType(Napi::Env env, Napi::Object map, std::initializer_list<const char *> names,
                                   PrimitiveKind primitive, int32_t size, int16_t align, const char *ref = nullptr)
 {
@@ -2193,6 +2273,7 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
     exports.Set("decode", Napi::Function::New(env, DecodeValue));
     exports.Set("address", Napi::Function::New(env, GetPointerAddress));
     exports.Set("call", Napi::Function::New(env, CallPointerSync));
+    exports.Set("encode", Napi::Function::New(env, EncodeValue));
 
     exports.Set("reset", Napi::Function::New(env, ResetKoffi));
 

package/src/koffi/src/ffi.hh

@@ -99,6 +99,7 @@ static const char *const PrimitiveKindNames[] = {
 struct TypeInfo;
 struct RecordMember;
 struct FunctionInfo;
+class CallData;
 
 typedef void DisposeFunc (Napi::Env env, const TypeInfo *type, const void *ptr);
 
@@ -286,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;
@@ -342,5 +346,6 @@ Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info);
 Napi::Value TranslateAsyncCall(const Napi::CallbackInfo &info);
 
 bool InitAsyncBroker(Napi::Env env, InstanceData *instance);
+CallData *GetThreadCall();
 
 }

package/src/koffi/src/util.cc

@@ -1193,6 +1193,216 @@ Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, cons
     return env.Null();
 }
 
+bool Encode(Napi::Value ref, Size offset, Napi::Value value, const TypeInfo *type, const Size *len)
+{
+    Napi::Env env = ref.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    uint8_t *ptr = nullptr;
+
+    if (ref.IsExternal()) {
+        Napi::External<void> external = ref.As<Napi::External<void>>();
+        ptr = (uint8_t *)external.Data();
+    } else if (IsRawBuffer(ref)) {
+        Span<uint8_t> buffer = GetRawBuffer(ref);
+
+        if (buffer.len - offset < type->size) [[unlikely]] {
+            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 = (uint8_t *)buffer.ptr;
+    } else {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for reference, expected external or TypedArray", GetValueType(instance, value));
+        return env.Null();
+    }
+
+    if (!ptr) [[unlikely]] {
+        ThrowError<Napi::Error>(env, "Cannot encode data in NULL pointer");
+        return env.Null();
+    }
+    ptr += offset;
+
+    return Encode(env, ptr, value, type, len);
+}
+
+bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *type, const Size *len)
+{
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (len && type->primitive != PrimitiveKind::String &&
+               type->primitive != PrimitiveKind::String16 &&
+               type->primitive != PrimitiveKind::Prototype) {
+        if (*len < 0) [[unlikely]] {
+            ThrowError<Napi::TypeError>(env, "Automatic (negative) length is only supported when decoding");
+            return env.Null();
+        }
+
+        type = MakeArrayType(instance, type, *len);
+    }
+
+    InstanceMemory mem = {};
+    CallData call(env, instance, &mem);
+
+#define PUSH_INTEGER(CType) \
+        do { \
+            if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] { \
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value)); \
+                return false; \
+            } \
+             \
+            CType v = GetNumber<CType>(value); \
+            *(CType *)origin = v; \
+        } while (false)
+#define PUSH_INTEGER_SWAP(CType) \
+        do { \
+            if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] { \
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value)); \
+                return false; \
+            } \
+             \
+            CType v = GetNumber<CType>(value); \
+            *(CType *)origin = ReverseBytes(v); \
+        } while (false)
+
+    switch (type->primitive) {
+        case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
+
+        case PrimitiveKind::Bool: {
+            if (!value.IsBoolean()) [[unlikely]] {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected boolean", GetValueType(instance, value));
+                return false;
+            }
+
+            bool b = value.As<Napi::Boolean>();
+            *(bool *)origin = b;
+        } break;
+        case PrimitiveKind::Int8: { PUSH_INTEGER(int8_t); } break;
+        case PrimitiveKind::UInt8: { PUSH_INTEGER(uint8_t); } break;
+        case PrimitiveKind::Int16: { PUSH_INTEGER(int16_t); } break;
+        case PrimitiveKind::Int16S: { PUSH_INTEGER_SWAP(int16_t); } break;
+        case PrimitiveKind::UInt16: { PUSH_INTEGER(uint16_t); } break;
+        case PrimitiveKind::UInt16S: { PUSH_INTEGER_SWAP(uint16_t); } break;
+        case PrimitiveKind::Int32: { PUSH_INTEGER(int32_t); } break;
+        case PrimitiveKind::Int32S: { PUSH_INTEGER_SWAP(int32_t); } break;
+        case PrimitiveKind::UInt32: { PUSH_INTEGER(uint32_t); } break;
+        case PrimitiveKind::UInt32S: { PUSH_INTEGER_SWAP(uint32_t); } break;
+        case PrimitiveKind::Int64: { PUSH_INTEGER(int64_t); } break;
+        case PrimitiveKind::Int64S: { PUSH_INTEGER_SWAP(int64_t); } break;
+        case PrimitiveKind::UInt64: { PUSH_INTEGER(uint64_t); } break;
+        case PrimitiveKind::UInt64S: { PUSH_INTEGER_SWAP(uint64_t); } break;
+        case PrimitiveKind::String: {
+            const char *str;
+            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]]
+                return false;
+            *(const char16_t **)origin = str16;
+        } break;
+        case PrimitiveKind::Pointer: {
+            void *ptr;
+            if (!call.PushPointer(value, type, 1, &ptr)) [[unlikely]]
+                return false;
+            *(void **)origin = ptr;
+        } break;
+        case PrimitiveKind::Record:
+        case PrimitiveKind::Union: {
+            if (!IsObject(value)) [[unlikely]] {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected object", GetValueType(instance, value));
+                return false;
+            }
+
+            Napi::Object obj = value.As<Napi::Object>();
+
+            if (!call.PushObject(obj, type, origin))
+                return false;
+        } break;
+        case PrimitiveKind::Array: {
+            if (value.IsArray()) {
+                Napi::Array array = value.As<Napi::Array>();
+                Size len = (Size)type->size / type->ref.type->size;
+
+                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))
+                    return false;
+            } else if (value.IsString()) {
+                if (!call.PushStringArray(value, type, origin))
+                    return false;
+            } else {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected array", GetValueType(instance, value));
+                return false;
+            }
+        } break;
+        case PrimitiveKind::Float32: {
+            if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
+                return false;
+            }
+
+            float f = GetNumber<float>(value);
+            *(float *)origin = f;
+        } break;
+        case PrimitiveKind::Float64: {
+            if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
+                return false;
+            }
+
+            double d = GetNumber<double>(value);
+            *(double *)origin = d;
+        } break;
+        case PrimitiveKind::Callback: {
+            void *ptr;
+
+            if (value.IsFunction()) {
+                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)) {
+                ptr = nullptr;
+            } else {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected %2", GetValueType(instance, value), type->name);
+                return false;
+            }
+
+            *(void **)origin = ptr;
+        } break;
+
+        case PrimitiveKind::Prototype: { RG_UNREACHABLE(); } break;
+    }
+
+#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;
+}
+
 Napi::Function WrapFunction(Napi::Env env, const FunctionInfo *func)
 {
     InstanceData *instance = env.GetInstanceData<InstanceData>();

package/src/koffi/src/util.hh

@@ -170,6 +170,9 @@ void DecodeBuffer(Span<uint8_t> buffer, const uint8_t *origin, const TypeInfo *r
 Napi::Value Decode(Napi::Value value, Size offset, const TypeInfo *type, const Size *len = nullptr);
 Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, const Size *len = nullptr);
 
+bool Encode(Napi::Value ref, Size offset, Napi::Value value, const TypeInfo *type, const Size *len = nullptr);
+bool Encode(Napi::Env env, uint8_t *ptr, Napi::Value value, const TypeInfo *type, const Size *len = nullptr);
+
 static inline Napi::Value NewBigInt(Napi::Env env, int64_t value)
 {
     if (value <= 9007199254740992ll && value >= -9007199254740992ll) {