koffi 2.15.2 → 2.15.4

package/src/koffi/src/call.hh

@@ -17,7 +17,7 @@ struct BackRegisters;
 
 // I'm not sure why the alignas(8), because alignof(CallData) is 8 without it.
 // But on Windows i386, without it, the alignment may not be correct (compiler bug?).
-class alignas(8) CallData {
+struct alignas(8) CallData {
     struct OutArgument {
         enum class Kind {
             Array,
@@ -66,7 +66,7 @@ class alignas(8) CallData {
     LocalArray<int16_t, 16> used_trampolines;
     HeapArray<OutArgument> out_arguments;
 
-    BlockAllocator call_alloc;
+    BlockAllocator alloc;
 
 public:
     CallData(Napi::Env env, InstanceData *instance, InstanceMemory *mem);
@@ -90,9 +90,8 @@ public:
 
 #undef INLINE_IF_UNITY
 
-    void Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool switch_stack, BackRegisters *out_reg);
-    void RelaySafe(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool outside_call, BackRegisters *out_reg);
-    static void RelayAsync(napi_env, napi_value, void *, void *udata);
+    void Relay(Size idx, uint8_t *sp);
+    void RelayAsync(Size idx, uint8_t *sp);
 
     void DumpForward(const FunctionInfo *func) const;
 
@@ -112,9 +111,6 @@ 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);
     template <typename T = uint8_t>
@@ -169,13 +165,15 @@ inline T *CallData::AllocHeap(Size size, Size align)
         int flags = 0;
 #endif
 
-        ptr = (uint8_t *)AllocateRaw(&call_alloc, size + align, flags);
+        ptr = (uint8_t *)AllocateRaw(&alloc, size + align, flags);
         ptr = AlignUp(ptr, align);
 
         return ptr;
     }
 }
 
+void PerformAsyncRelay(napi_env env, napi_value callback, void *ctx, void *udata);
+
 void *GetTrampoline(int16_t idx, const FunctionInfo *proto);
 
 }

package/src/koffi/src/ffi.cc

@@ -39,6 +39,8 @@ SharedData shared;
 
 static thread_local CallData *exec_call;
 
+extern "C" napi_value SwitchAndRelay(CallData *call, Size idx, uint8_t *sp, uint8_t *saved_sp, Span<uint8_t> *new_stack);
+
 static bool ChangeSize(const char *name, Napi::Value value, Size min_size, Size max_size, Size *out_size)
 {
     Napi::Env env = value.Env();
@@ -1690,35 +1692,54 @@ Napi::Value TranslateAsyncCall(const Napi::CallbackInfo &info)
     return TranslateAsyncCall(func, func->native, info);
 }
 
-extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
+extern "C" void RelayCallback(Size idx, uint8_t *sp)
 {
-    if (exec_call) [[likely]] {
-        exec_call->RelaySafe(idx, own_sp, caller_sp, false, out_reg);
-    } else {
-        // This happens if the callback pointer is called from a different thread
-        // than the one that runs the FFI call (sync or async).
+    CallData *call = exec_call;
 
-        TrampolineInfo *trampoline = &shared.trampolines[idx];
+    // Try the fast path first: we are on the main thread and we are running a native call through Koffi.
+    // It should be easy, but in this case we are running on the custom Koffi stack, which will trip up
+    // Node and V8. So we need to switch back to the normal/main stack.
+    if (call && std::this_thread::get_id() == call->instance->main_thread_id) {
+        SwitchAndRelay(call, idx, sp, call->old_sp, &call->mem->stack);
+        return;
+    }
 
-        Napi::Env env = trampoline->func.Env();
-        InstanceData *instance = env.GetInstanceData<InstanceData>();
+    // Otherwise, we need to allocate memory to perform the callback.
+    // Since the necessary machinery live in CallData, just use a temporary instance.
+    // In some cases we would reuse the existing call (exec_call may be not null),
+    // but it is rare so let's ignore this for simplicity.
 
-        InstanceMemory *mem = AllocateMemory(instance, instance->config.async_stack_size, instance->config.async_heap_size);
-        if (!mem) [[unlikely]] {
-            ThrowError<Napi::Error>(env, "Too many asynchronous calls are running");
-            return;
-        }
+    TrampolineInfo *trampoline = &shared.trampolines[idx];
+    Napi::Env env = trampoline->func.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    InstanceMemory *mem = AllocateMemory(instance, instance->config.async_stack_size, instance->config.async_heap_size);
+    if (!mem) [[unlikely]] {
+        ThrowError<Napi::Error>(env, "Too many asynchronous calls are running");
+        return;
+    }
 
-        // Avoid triggering the "use callback beyond FFI" check
-        K_DEFER_C(generation = trampoline->generation) { trampoline->generation = generation; };
-        trampoline->generation = -1;
+    // Avoid triggering the "use callback beyond FFI" check
+    K_DEFER_C(generation = trampoline->generation) { trampoline->generation = generation; };
+    trampoline->generation = -1;
 
-        // We set dispose_call to true so that the main thread will dispose of CallData itself
+    if (std::this_thread::get_id() == instance->main_thread_id) {
         CallData call(env, instance, mem);
-        call.RelaySafe(idx, own_sp, caller_sp, true, out_reg);
+
+        Napi::HandleScope scope(env);
+        call.Relay(idx, sp);
+    } else {
+        CallData call(env, instance, mem);
+        call.RelayAsync(idx, sp);
     }
 }
 
+extern "C" void RelayDirect(CallData *call, Size idx, uint8_t *sp)
+{
+    Napi::HandleScope scope(call->env);
+    call->Relay(idx, sp);
+}
+
 static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
@@ -2338,7 +2359,7 @@ bool InitAsyncBroker(Napi::Env env, InstanceData *instance)
         if (napi_create_threadsafe_function(env, nullptr, nullptr,
                                             Napi::String::New(env, "Koffi Async Callback Broker"),
                                             0, 1, nullptr, nullptr, nullptr,
-                                            CallData::RelayAsync, &instance->broker) != napi_ok) {
+                                            PerformAsyncRelay, &instance->broker) != napi_ok) {
             LogError("Failed to create async callback broker");
             return false;
         }

package/src/koffi/src/ffi.hh

@@ -85,7 +85,7 @@ static const char *const PrimitiveKindNames[] = {
 struct TypeInfo;
 struct RecordMember;
 struct FunctionInfo;
-class CallData;
+struct CallData;
 
 typedef void DisposeFunc (Napi::Env env, const TypeInfo *type, const void *ptr);
 

package/src/koffi/src/util.cc

@@ -1683,19 +1683,15 @@ bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *t
 #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 (call.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);
+        if (!copy) {
+            copy = instance->encode_allocators.AppendDefault();
+            instance->encode_map.Set(origin, copy);
         }
+
+        std::swap(call.alloc, *copy);
     }
 
     return true;

package/src/koffi/src/win32.cc

@@ -180,6 +180,19 @@ int GetDllMachine(const wchar_t *filename)
     return GetFileMachine(h, true);
 }
 
+extern "C" int __cdecl SehHandler(void *ptr, void *, void *ctx, void *)
+{
+    EXCEPTION_RECORD *rec = (EXCEPTION_RECORD *)ptr;
+
+    if (!(rec->ExceptionFlags & (EXCEPTION_UNWINDING | EXCEPTION_EXIT_UNWIND))) {
+        EXCEPTION_POINTERS ep = { rec, (CONTEXT *)ctx };
+        UnhandledExceptionFilter(&ep);
+        ExitProcess(rec->ExceptionCode);
+    }
+
+    return ExceptionContinueSearch;
+}
+
 }
 
 #endif

package/src/koffi/src/win32.hh

@@ -109,4 +109,6 @@ void *LoadWindowsLibrary(Napi::Env env, Span<const char> path); // Returns HANDL
 int GetSelfMachine();
 int GetDllMachine(const wchar_t *filename);
 
+extern "C" int __cdecl SehHandler(void *ptr, void *, void *ctx, void *);
+
 }