koffi 2.5.21-beta.1 → 2.5.21-beta.2

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.2",
     "stable": "2.5.20",
     "description": "Fast and simple C FFI (foreign function interface) for Node.js",
     "keywords": [

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.2",
       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,15 @@ 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);
+
+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

@@ -1897,6 +1897,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 +2013,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 +2231,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);
 
@@ -342,5 +343,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,206 @@ 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>();
+    CallData *call = GetThreadCall();
+
+    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);
+    }
+
+    if (!call) [[unlikely]] {
+        ThrowError<Napi::Error>(env, "koffi.encode() can only be used inside callbacks");
+        return false;
+    }
+
+#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()) {
+                Napi::Function func = value.As<Napi::Function>();
+
+                ptr = call->ReserveTrampoline(type->ref.proto, func);
+                if (!ptr) [[unlikely]]
+                    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
+
+    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) {