koffi 3.0.2 → 3.1.1

package/src/koffi/src/call.cc

@@ -45,6 +45,8 @@ static const Size TrampolineSize = ((const uint8_t *)&TrampolineEnd - Trampoline
 
 #endif
 
+static napi_value (*translate_zero_call)(napi_env env, napi_callback_info info);
+
 #if defined(K_DEBUG)
 CallData::~CallData()
 {
@@ -77,7 +79,7 @@ void CallData::Finalize()
                         K_ASSERT(GetArrayLength(env, value) == 1);
 
                         Size len = strnlen((const char *)out.ptr, out.max_len);
-                        Napi::String str = Napi::String::New(env, (const char *)out.ptr, len);
+                        napi_value str = NewString(env, (const char *)out.ptr, len);
 
                         napi_set_element(env, value, 0, str);
                     } break;
@@ -87,7 +89,7 @@ void CallData::Finalize()
                         K_ASSERT(GetArrayLength(env, value) == 1);
 
                         Size len = NullTerminatedLength((const char16_t *)out.ptr, out.max_len);
-                        Napi::String str = Napi::String::New(env, (const char16_t *)out.ptr, len);
+                        napi_value str = NewString(env, (const char16_t *)out.ptr, len);
 
                         napi_set_element(env, value, 0, str);
                     } break;
@@ -97,7 +99,7 @@ void CallData::Finalize()
                         K_ASSERT(GetArrayLength(env, value) == 1);
 
                         Size len = NullTerminatedLength((const char32_t *)out.ptr, out.max_len);
-                        Napi::String str = MakeStringFromUTF32(env, (const char32_t *)out.ptr, len);
+                        napi_value str = NewString(env, (const char32_t *)out.ptr, len);
 
                         napi_set_element(env, value, 0, str);
                     } break;
@@ -117,7 +119,7 @@ void CallData::Finalize()
         }
 
         for (const OutArgument &out: out_arguments) {
-            napi_delete_reference(env, out.ref);
+            node_api_delete_reference(env, out.ref);
         }
     }
 
@@ -132,7 +134,7 @@ void CallData::Finalize()
             K_ASSERT(trampoline->func);
 
             trampoline->state = 0;
-            napi_delete_reference(env, trampoline->func);
+            node_api_delete_reference(env, trampoline->func);
             trampoline->func = nullptr;
 
             shared.available.Append(idx);
@@ -255,8 +257,6 @@ Size CallData::PushStringValue(napi_value value, const char **out_str)
 
     // Fast path for small strings
     if (available >= 4096) [[likely]] {
-        char *ptr = (char *)mem->heap.ptr;
-
         napi_status status = napi_get_value_string_utf8(env, value, ptr, 4096, &len);
         if (status == napi_string_expected)
             return -1;
@@ -376,17 +376,16 @@ Size CallData::PushString32Value(napi_value value, const char32_t **out_str32)
     return j;
 }
 
-static inline napi_value GetMemberValue(napi_env env, napi_value obj, const RecordMember &member)
+static FORCE_INLINE napi_value GetMemberValue(napi_env env, napi_value obj, const RecordMember &member)
 {
-    napi_value value = nullptr;
+    napi_value value;
 
     if (member.key) {
-        napi_value key = nullptr;
-        napi_get_reference_value(env, member.key, &key);
-
-        napi_get_property(env, obj, key, &value);
+        napi_value key;
+        NAPI_OK(napi_get_reference_value(env, member.key, &key));
+        NAPI_OK(napi_get_property(env, obj, key, &value));
     } else {
-        napi_get_named_property(env, obj, member.name, &value);
+        NAPI_OK(napi_get_named_property(env, obj, member.name, &value));
     }
 
     return value;
@@ -394,10 +393,14 @@ static inline napi_value GetMemberValue(napi_env env, napi_value obj, const Reco
 
 bool CallData::PushObject(napi_value obj, const TypeInfo *type, uint8_t *origin)
 {
-    K_ASSERT(IsObject(env, obj));
     K_ASSERT(type->primitive == PrimitiveKind::Record ||
              type->primitive == PrimitiveKind::Union);
 
+    if (GetKindOf(env, obj) != napi_object) [[unlikely]] {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected object", GetValueType(instance, obj));
+        return false;
+    }
+
     Span<const RecordMember> members = type->members;
 
     if (type->primitive == PrimitiveKind::Union) {
@@ -547,12 +550,7 @@ bool CallData::PushObject(napi_value obj, const TypeInfo *type, uint8_t *origin)
             } break;
             case PrimitiveKind::Record:
             case PrimitiveKind::Union: {
-                if (!IsObject(env, value)) [[unlikely]] {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected object", GetValueType(instance, value));
-                    return false;
-                }
-
-                if (!PushObject(value, member.type, dest))
+                if (!PushObject(value, member.type, dest)) [[unlikely]]
                     return false;
             } break;
             case PrimitiveKind::Array: {
@@ -739,12 +737,7 @@ bool CallData::PushNormalArray(Napi::Array array, const TypeInfo *type, Size siz
         case PrimitiveKind::Record:
         case PrimitiveKind::Union: {
             PUSH_ARRAY({
-                if (!IsObject(env, value)) [[unlikely]] {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected object", GetValueType(instance, value));
-                    return false;
-                }
-
-                if (!PushObject(value, ref, dest))
+                if (!PushObject(value, ref, dest)) [[unlikely]]
                     return false;
             });
         } break;
@@ -1010,8 +1003,6 @@ bool CallData::PushPointerSlow(napi_value value, napi_valuetype kind, const Type
         return true;
     } else if (ref->primitive == PrimitiveKind::Record ||
                ref->primitive == PrimitiveKind::Union) [[likely]] {
-        K_ASSERT(IsObject(env, value));
-
         ptr = (void *)AllocHeap(ref->size);
 
         if (ref->primitive == PrimitiveKind::Union &&
@@ -1021,9 +1012,12 @@ bool CallData::PushPointerSlow(napi_value value, napi_valuetype kind, const Type
         }
 
         if (directions & 1) {
-            if (!PushObject(value, ref, (uint8_t *)ptr))
+            if (!PushObject(value, ref, (uint8_t *)ptr)) [[unlikely]]
                 return false;
         } else {
+            if (kind != napi_object) [[unlikely]]
+                return false;
+
             MemSet(ptr, 0, ref->size);
         }
 
@@ -1247,71 +1241,7 @@ void CallData::DebugForward()
 
 #endif
 
-static bool DetectDeno(Napi::Env env)
-{
-    Napi::Value ret = env.RunScript("typeof Deno != 'undefined'");
-    Napi::Boolean b = ret.ToBoolean();
-
-    return b.Value();
-}
-
-static bool DetectBun(Napi::Env env)
-{
-    Napi::Value ret = env.RunScript("process.isBun");
-    Napi::Boolean b = ret.ToBoolean();
-
-    return b.Value();
-}
-
-void InitTranslateZeroCall(Napi::Env env)
-{
-    if (DetectDeno(env) || DetectBun(env)) {
-        translate_zero_call = TranslateFastCall;
-        return;
-    }
-
-    Napi::Object self = Napi::Object::New(env);
-
-    napi_value func;
-    napi_value ret;
-
-    auto cb = [](napi_env env, napi_callback_info info) {
-        napi_value self;
-        NAPI_OK(napi_get_cb_info(env, info, nullptr, nullptr, &self, nullptr));
-
-        napi_value *ptr = (napi_value *)info;
-
-        if (ptr[0] != self && ptr[1] != self) {
-            translate_zero_call = TranslateZeroCall;
-        } else {
-            translate_zero_call = TranslateFastCall;
-        }
-
-        return self;
-    };
-
-    NAPI_OK(napi_create_function(env, nullptr, 0, cb, nullptr, &func));
-    NAPI_OK(napi_call_function(env, self, func, 0, nullptr, &ret));
-}
-
-bool InitAsyncBroker(Napi::Env env, InstanceData *instance)
-{
-    if (!instance->broker) {
-        if (napi_create_threadsafe_function(env, nullptr, nullptr,
-                                            Napi::String::New(env, "Koffi Async Callback Broker"),
-                                            0, 1, nullptr, nullptr, nullptr,
-                                            PerformAsyncRelay, &instance->broker) != napi_ok) {
-            LogError("Failed to create async callback broker");
-            return false;
-        }
-
-        NAPI_OK(napi_unref_threadsafe_function(env, instance->broker));
-    }
-
-    return true;
-}
-
-napi_value TranslateZeroCall(napi_env env, napi_callback_info info)
+static napi_value TranslateZeroCall(napi_env env, napi_callback_info info)
 {
     struct CallbackBundle {
         napi_env env;
@@ -1386,7 +1316,7 @@ static FORCE_INLINE napi_value TranslateNormalCall(napi_env env, const FunctionI
     return ret;
 }
 
-napi_value TranslateNormalCall(napi_env env, napi_callback_info info)
+static napi_value TranslateNormalCall(napi_env env, napi_callback_info info)
 {
     static_assert(MaxParameters >= 8);
 
@@ -1436,7 +1366,7 @@ static FORCE_INLINE napi_value TranslateNormalCallDebugAsync(napi_env env, const
     return ret;
 }
 
-napi_value TranslateNormalCallDebugAsync(napi_env env, napi_callback_info info)
+static napi_value TranslateNormalCallDebugAsync(napi_env env, napi_callback_info info)
 {
     static_assert(MaxParameters >= 8);
 
@@ -1558,7 +1488,7 @@ static napi_value TranslateVariadicCall(napi_env env, const FunctionInfo *func,
     return ret;
 }
 
-napi_value TranslateVariadicCall(napi_env env, napi_callback_info info)
+static napi_value TranslateVariadicCall(napi_env env, napi_callback_info info)
 {
     static_assert(MaxParameters >= 8);
 
@@ -1651,7 +1581,7 @@ void AsyncCall::OnError(const Napi::Error& err)
     callback.Call(self, K_LEN(args), args);
 }
 
-napi_value TranslateAsyncCall(napi_env env, napi_callback_info info)
+static napi_value TranslateAsyncCall(napi_env env, napi_callback_info info)
 {
     static_assert(MaxParameters >= 6);
 
@@ -1693,6 +1623,215 @@ napi_value TranslateAsyncCall(napi_env env, napi_callback_info info)
     return Napi::Env(env).Undefined();
 }
 
+static bool DetectDeno(Napi::Env env)
+{
+    Napi::Value ret = env.RunScript("typeof Deno != 'undefined'");
+    Napi::Boolean b = ret.ToBoolean();
+
+    return b.Value();
+}
+
+static bool DetectBun(Napi::Env env)
+{
+    Napi::Value ret = env.RunScript("process.isBun");
+    Napi::Boolean b = ret.ToBoolean();
+
+    return b.Value();
+}
+
+void InitTranslateZeroCall(Napi::Env env)
+{
+    if (DetectDeno(env) || DetectBun(env)) {
+        translate_zero_call = TranslateFastCall;
+        return;
+    }
+
+    Napi::Object self = Napi::Object::New(env);
+
+    napi_value func;
+    napi_value ret;
+
+    auto cb = [](napi_env env, napi_callback_info info) {
+        napi_value self;
+        NAPI_OK(napi_get_cb_info(env, info, nullptr, nullptr, &self, nullptr));
+
+        napi_value *ptr = (napi_value *)info;
+
+        if (ptr[0] != self && ptr[1] != self) {
+            translate_zero_call = TranslateZeroCall;
+        } else {
+            translate_zero_call = TranslateFastCall;
+        }
+
+        return self;
+    };
+
+    NAPI_OK(napi_create_function(env, nullptr, 0, cb, nullptr, &func));
+    NAPI_OK(napi_call_function(env, self, func, 0, nullptr, &ret));
+}
+
+napi_value CallPointer(Napi::Env env, const FunctionInfo *proto, void *native, napi_value *args, Size count)
+{
+    if (proto->variadic) {
+        return TranslateVariadicCall(env, proto, native, args, count);
+    } else {
+        return TranslateNormalCall(env, proto, native, args, count);
+    }
+}
+
+static void PerformAsyncRelay(napi_env, napi_value, void *, void *udata)
+{
+    RelayContext *ctx = (RelayContext *)udata;
+    CallData *call = ctx->call;
+
+    call->Relay(ctx->idx, ctx->sp);
+    call->Finalize();
+
+    // We're done!
+    std::lock_guard<std::mutex> lock(ctx->mutex);
+    ctx->done = true;
+    ctx->cv.notify_one();
+}
+
+bool InitAsyncBroker(Napi::Env env, InstanceData *instance)
+{
+    if (!instance->broker) {
+        if (napi_create_threadsafe_function(env, nullptr, nullptr,
+                                            NewString(env, "Koffi Async Callback Broker"),
+                                            0, 1, nullptr, nullptr, nullptr,
+                                            PerformAsyncRelay, &instance->broker) != napi_ok) {
+            LogError("Failed to create async callback broker");
+            return false;
+        }
+
+        NAPI_OK(napi_unref_threadsafe_function(env, instance->broker));
+    }
+
+    return true;
+}
+
+void *GetTrampoline(int idx)
+{
+    return (void *)(TrampolineStart + TrampolineSize * idx);
+}
+
+static bool CanTypeAcceptCallbacks(const TypeInfo *type)
+{
+    if (type->primitive == PrimitiveKind::Pointer)
+        return true;
+    if (type->primitive == PrimitiveKind::Callback)
+        return true;
+
+    if (type->primitive == PrimitiveKind::Record ||
+            type->primitive == PrimitiveKind::Union) {
+        for (const RecordMember &member: type->members) {
+            if (CanTypeAcceptCallbacks(member.type))
+                return false;
+        }
+    }
+
+    return true;
+}
+
+static bool CanUseFastCall(const FunctionInfo *func)
+{
+    if (func->parameters.len > 6)
+        return false;
+
+    // Fast calls basically skip CallData::Finalize(), which handles output arguments
+    // and temporary callback trampolines. If the function does not use any
+    // output argument and cannot accept callbacks (so no pointer or callback arguments),
+    // we can skip finalization!
+
+    for (const ParameterInfo &param: func->parameters) {
+        if (param.directions & 2)
+            return false;
+        if (CanTypeAcceptCallbacks(param.type))
+            return false;
+    }
+
+    return true;
+}
+
+napi_value DescribeFunction(InstanceData *instance, const FunctionInfo *func)
+{
+    static const char *const DirectionNames[] = {
+        nullptr,
+        "Input",
+        "Output",
+        "Input/Output"
+    };
+
+    Napi::Env env = instance->env;
+
+    Napi::Object meta = Napi::Object::New(env);
+    Napi::Array arguments = Napi::Array::New(env, func->parameters.len);
+
+    meta.Set("name", NewString(env, func->name));
+    meta.Set("arguments", arguments);
+    meta.Set("result", WrapType(instance, func->ret.type));
+
+    for (Size i = 0; i < func->parameters.len; i++) {
+        const ParameterInfo &param = func->parameters[i];
+        Napi::Object obj = Napi::Object::New(env);
+
+        obj.Set("type", WrapType(instance, param.type));
+        obj.Set("direction", NewString(env, DirectionNames[param.directions]));
+
+        arguments.Set((uint32_t)i, obj);
+    }
+
+    meta.Freeze();
+
+    return meta;
+}
+
+static bool IsDebugAsyncEnabled()
+{
+    static bool debug = GetDebugFlag("DEBUG_ASYNC");
+    return debug;
+}
+
+napi_value WrapFunction(InstanceData *instance, const FunctionInfo *func)
+{
+    Napi::Env env = instance->env;
+
+    Napi::Function wrapper;
+    {
+        napi_value value;
+
+        if (func->variadic) {
+            NAPI_OK(napi_create_function(env, func->name, NAPI_AUTO_LENGTH, TranslateVariadicCall, (void *)func->Ref(), &value));
+        } else if (IsDebugAsyncEnabled()) {
+            NAPI_OK(napi_create_function(env, func->name, NAPI_AUTO_LENGTH, TranslateNormalCallDebugAsync, (void *)func->Ref(), &value));
+        } else if (!func->parameters.len) {
+            NAPI_OK(napi_create_function(env, func->name, NAPI_AUTO_LENGTH, translate_zero_call, (void *)func->Ref(), &value));
+        } else if (CanUseFastCall(func)) {
+            NAPI_OK(napi_create_function(env, func->name, NAPI_AUTO_LENGTH, TranslateFastCall, (void *)func->Ref(), &value));
+        } else {
+            NAPI_OK(napi_create_function(env, func->name, NAPI_AUTO_LENGTH, TranslateNormalCall, (void *)func->Ref(), &value));
+        }
+
+        wrapper = Napi::Function(env, value);
+        wrapper.AddFinalizer([](Napi::BasicEnv, FunctionInfo *func) { func->Unref(); }, (FunctionInfo *)func);
+    }
+
+    if (!func->variadic) {
+        napi_value value;
+        NAPI_OK(napi_create_function(env, func->name, NAPI_AUTO_LENGTH, TranslateAsyncCall, (void *)func->Ref(), &value));
+
+        Napi::Function async = Napi::Function(env, value);
+        async.AddFinalizer([](Napi::BasicEnv, FunctionInfo *func) { func->Unref(); }, (FunctionInfo *)func);
+
+        wrapper.Set("async", async);
+    }
+
+    napi_value meta = DescribeFunction(instance, func);
+    wrapper.Set("info", meta);
+
+    return wrapper;
+}
+
 static FORCE_INLINE bool CheckTrampolineStatus(TrampolineInfo *trampoline)
 {
     if (trampoline->state == 1) [[likely]]
@@ -1799,34 +1938,6 @@ extern "C" void RelayDirect(CallData *call, Size idx, uint8_t *sp)
     }
 }
 
-napi_value CallPointer(napi_env env, const FunctionInfo *proto, void *native, napi_value *args, Size count)
-{
-    if (proto->variadic) {
-        return TranslateVariadicCall(env, proto, native, args, count);
-    } else {
-        return TranslateNormalCall(env, proto, native, args, count);
-    }
-}
-
-void PerformAsyncRelay(napi_env, napi_value, void *, void *udata)
-{
-    RelayContext *ctx = (RelayContext *)udata;
-    CallData *call = ctx->call;
-
-    call->Relay(ctx->idx, ctx->sp);
-    call->Finalize();
-
-    // We're done!
-    std::lock_guard<std::mutex> lock(ctx->mutex);
-    ctx->done = true;
-    ctx->cv.notify_one();
-}
-
-void *GetTrampoline(int idx)
-{
-    return (void *)(TrampolineStart + TrampolineSize * idx);
-}
-
 bool Encode(InstanceData *instance, uint8_t *origin, napi_value value, const TypeInfo *type)
 {
     Napi::Env env = instance->env;
@@ -1909,12 +2020,7 @@ bool Encode(InstanceData *instance, uint8_t *origin, napi_value value, const Typ
         } break;
         case PrimitiveKind::Record:
         case PrimitiveKind::Union: {
-            if (!IsObject(env, value)) [[unlikely]] {
-                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected object", GetValueType(instance, value));
-                return false;
-            }
-
-            if (!call.PushObject(value, type, origin))
+            if (!call.PushObject(value, type, origin)) [[unlikely]]
                 return false;
         } break;
         case PrimitiveKind::Array: {

package/src/koffi/src/call.hh

@@ -164,19 +164,14 @@ inline T *CallData::AllocHeap(Size size)
 }
 
 void InitTranslateZeroCall(Napi::Env env);
-bool InitAsyncBroker(Napi::Env env, InstanceData *instance);
-
-napi_value TranslateZeroCall(napi_env env, napi_callback_info info);
-napi_value TranslateFastCall(napi_env env, napi_callback_info info);
-napi_value TranslateNormalCall(napi_env env, napi_callback_info info);
-napi_value TranslateNormalCallDebugAsync(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);
 
-napi_value CallPointer(napi_env env, const FunctionInfo *proto, void *native, napi_value *args, Size count);
+napi_value DescribeFunction(InstanceData *instance, const FunctionInfo *func);
+napi_value WrapFunction(InstanceData *instance, const FunctionInfo *func);
+bool DetectCallConvention(Span<const char> name, CallConvention *out_convention);
 
-void PerformAsyncRelay(napi_env env, napi_value callback, void *ctx, void *udata);
+napi_value CallPointer(Napi::Env env, const FunctionInfo *proto, void *native, napi_value *args, Size count);
 
+bool InitAsyncBroker(Napi::Env env, InstanceData *instance);
 void *GetTrampoline(int idx);
 
 bool Encode(InstanceData *instance, uint8_t *ptr, napi_value value, const TypeInfo *type);