koffi 2.2.3-beta.2 → 2.2.3-beta.3

package/package.json

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

package/src/koffi/src/abi_x64_win.cc

@@ -17,6 +17,7 @@
 #include "ffi.hh"
 #include "call.hh"
 #include "util.hh"
+#include "win32.hh"
 
 #include <napi.h>
 
@@ -40,10 +41,6 @@ extern "C" napi_value CallSwitchStack(Napi::Function *func, size_t argc, napi_va
 
 #include "abi_trampolines.inc"
 
-#define TEB_STACK_BASE(TEB) (*(void **)((uint8_t *)(TEB) + 0x08))
-#define TEB_STACK_LIMIT(TEB) (*(void **)((uint8_t *)(TEB) + 0x10))
-#define TEB_DEALLOCATION_STACK(TEB) (*(void **)((uint8_t *)(TEB) + 0x1478))
-
 bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
 {
     func->ret.regular = IsRegularSize(func->ret.type->size, 8);
@@ -220,21 +217,21 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
 
 void CallData::Execute(const FunctionInfo *func)
 {
-    void *teb = (void *)__readgsqword(0x30);
-
-    // Store current stack limits
-    RG_DEFER_C(base = TEB_STACK_BASE(teb),
-               limit = TEB_STACK_LIMIT(teb),
-               dealloc = TEB_DEALLOCATION_STACK(teb)) {
-        TEB_STACK_BASE(teb) = base;
-        TEB_STACK_LIMIT(teb) = limit;
-        TEB_DEALLOCATION_STACK(teb) = dealloc;
+    TEB *teb = GetTEB();
+
+    // Restore previous stack limits at the end
+    RG_DEFER_C(base = teb->StackBase,
+               limit = teb->StackLimit,
+               dealloc = teb->DeallocationStack) {
+        teb->StackBase = base;
+        teb->StackLimit = limit;
+        teb->DeallocationStack = dealloc;
     };
 
     // Adjust stack limits so SEH works correctly
-    TEB_STACK_BASE(teb) = mem->stack0.end();
-    TEB_STACK_LIMIT(teb) = mem->stack0.ptr;
-    TEB_DEALLOCATION_STACK(teb) = mem->stack0.ptr;
+    teb->StackBase = mem->stack0.end();
+    teb->StackLimit = mem->stack0.ptr;
+    teb->DeallocationStack = mem->stack0.ptr;
 
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
@@ -337,20 +334,21 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
     if (RG_UNLIKELY(env.IsExceptionPending()))
         return;
 
-    void *teb = (void *)__readgsqword(0x30);
+    TEB *teb = GetTEB();
 
-    RG_DEFER_C(base = TEB_STACK_BASE(teb),
-               limit = TEB_STACK_LIMIT(teb),
-               dealloc = TEB_DEALLOCATION_STACK(teb)) {
-        TEB_STACK_BASE(teb) = base;
-        TEB_STACK_LIMIT(teb) = limit;
-        TEB_DEALLOCATION_STACK(teb) = dealloc;
+    // Restore previous stack limits at the end
+    RG_DEFER_C(base = teb->StackBase,
+               limit = teb->StackLimit,
+               dealloc = teb->DeallocationStack) {
+        teb->StackBase = base;
+        teb->StackLimit = limit;
+        teb->DeallocationStack = dealloc;
     };
 
-    // Restore real thread stack limits
-    TEB_STACK_BASE(teb) = instance->main_stack_max;
-    TEB_STACK_LIMIT(teb) = instance->main_stack_min;
-    TEB_DEALLOCATION_STACK(teb) = instance->main_stack_min;
+    // Adjust stack limits so SEH works correctly
+    teb->StackBase = instance->main_stack_max;
+    teb->StackLimit = instance->main_stack_min;
+    teb->DeallocationStack = instance->main_stack_min;
 
     const TrampolineInfo &trampoline = shared.trampolines[idx];
 

package/src/koffi/src/abi_x86.cc

@@ -17,6 +17,9 @@
 #include "ffi.hh"
 #include "call.hh"
 #include "util.hh"
+#ifdef _WIN32
+    #include "win32.hh"
+#endif
 
 #include <napi.h>
 
@@ -46,12 +49,6 @@ extern "C" napi_value CallSwitchStack(Napi::Function *func, size_t argc, napi_va
 
 #include "abi_trampolines.inc"
 
-#ifdef _WIN32
-    #define TEB_STACK_BASE(TEB) (*(void **)((uint8_t *)(TEB) + 0x04))
-    #define TEB_STACK_LIMIT(TEB) (*(void **)((uint8_t *)(TEB) + 0x08))
-    #define TEB_DEALLOCATION_STACK(TEB) (*(void **)((uint8_t *)(TEB) + 0xE0C))
-#endif
-
 bool AnalyseFunction(Napi::Env env, InstanceData *instance, FunctionInfo *func)
 {
     if (!func->lib && func->convention != CallConvention::Cdecl &&
@@ -304,21 +301,21 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
 void CallData::Execute(const FunctionInfo *func)
 {
 #ifdef _WIN32
-    void *teb = (void *)__readfsdword(0x18);
-
-    // Store current stack limits
-    RG_DEFER_C(base = TEB_STACK_BASE(teb),
-               limit = TEB_STACK_LIMIT(teb),
-               dealloc = TEB_DEALLOCATION_STACK(teb)) {
-        TEB_STACK_BASE(teb) = base;
-        TEB_STACK_LIMIT(teb) = limit;
-        TEB_DEALLOCATION_STACK(teb) = dealloc;
+    TEB *teb = GetTEB();
+
+    // Restore previous stack limits at the end
+    RG_DEFER_C(base = teb->StackBase,
+               limit = teb->StackLimit,
+               dealloc = teb->DeallocationStack) {
+        teb->StackBase = base;
+        teb->StackLimit = limit;
+        teb->DeallocationStack = dealloc;
     };
 
     // Adjust stack limits so SEH works correctly
-    TEB_STACK_BASE(teb) = mem->stack0.end();
-    TEB_STACK_LIMIT(teb) = mem->stack0.ptr;
-    TEB_DEALLOCATION_STACK(teb) = mem->stack0.ptr;
+    teb->StackBase = mem->stack0.end();
+    teb->StackLimit = mem->stack0.ptr;
+    teb->DeallocationStack = mem->stack0.ptr;
 #endif
 
 #define PERFORM_CALL(Suffix) \
@@ -424,20 +421,21 @@ void CallData::Relay(Size idx, uint8_t *, uint8_t *caller_sp, bool async, BackRe
         return;
 
 #ifdef _WIN32
-    void *teb = (void *)__readfsdword(0x18);
-
-    RG_DEFER_C(base = TEB_STACK_BASE(teb),
-               limit = TEB_STACK_LIMIT(teb),
-               dealloc = TEB_DEALLOCATION_STACK(teb)) {
-        TEB_STACK_BASE(teb) = base;
-        TEB_STACK_LIMIT(teb) = limit;
-        TEB_DEALLOCATION_STACK(teb) = dealloc;
+    TEB *teb = GetTEB();
+
+    // Restore previous stack limits at the end
+    RG_DEFER_C(base = teb->StackBase,
+               limit = teb->StackLimit,
+               dealloc = teb->DeallocationStack) {
+        teb->StackBase = base;
+        teb->StackLimit = limit;
+        teb->DeallocationStack = dealloc;
     };
 
-    // Restore real thread stack limits
-    TEB_STACK_BASE(teb) = instance->main_stack_max;
-    TEB_STACK_LIMIT(teb) = instance->main_stack_min;
-    TEB_DEALLOCATION_STACK(teb) = instance->main_stack_min;
+    // Adjust stack limits so SEH works correctly
+    teb->StackBase = instance->main_stack_max;
+    teb->StackLimit = instance->main_stack_min;
+    teb->DeallocationStack = instance->main_stack_min;
 #endif
 
     const TrampolineInfo &trampoline = shared.trampolines[idx];

package/src/koffi/src/ffi.cc

@@ -16,6 +16,9 @@
 #include "call.hh"
 #include "parser.hh"
 #include "util.hh"
+#ifdef _WIN32
+    #include "win32.hh"
+#endif
 
 #ifdef _WIN32
     #ifndef NOMINMAX
@@ -1045,17 +1048,10 @@ static InstanceMemory *AllocateMemory(InstanceData *instance, Size stack_size, S
                                    FIBER_FLAG_FLOAT_SWITCH, [](void *udata) {
             FiberContext *ctx = (FiberContext *)udata;
 
-            // Handle initial call just below
-#if defined(__aarch64__) || defined(_M_ARM64)
-            NT_TIB *tib = (NT_TIB *)__getReg(18);
-#elif defined(__x86_64__) || defined(_M_AMD64)
-            NT_TIB *tib = (NT_TIB *)__readgsqword(0x30);
-#else
-            NT_TIB *tib = (NT_TIB *)__readfsdword(0x18);
-#endif
+            TEB *teb = GetTEB();
 
-            ctx->mem->stack.ptr = (uint8_t *)tib->StackLimit;
-            ctx->mem->stack.len = (uint8_t *)tib->StackBase - ctx->mem->stack.ptr;
+            ctx->mem->stack.ptr = (uint8_t *)teb->DeallocationStack;
+            ctx->mem->stack.len = (uint8_t *)teb->StackBase - ctx->mem->stack.ptr;
 
             SwitchToFiber(ctx->self);
         }, &ctx);
@@ -1761,6 +1757,38 @@ InstanceMemory::~InstanceMemory()
 #endif
 }
 
+static InstanceData *CreateInstance(Napi::Env env)
+{
+    InstanceData *instance = new InstanceData();
+    RG_DEFER_N(err_guard) { delete instance; };
+
+    instance->main_thread_id = std::this_thread::get_id();
+
+    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) {
+        LogError("Failed to create async callback broker");
+        return nullptr;
+    }
+    napi_unref_threadsafe_function(env, instance->broker);
+
+#if defined(_WIN32) && (defined(__x86_64__) || defined(_M_AMD64))
+    void *teb = (void *)__readgsqword(0x30);
+
+    instance->main_stack_max = *(void **)((uint8_t *)teb + 0x08); // StackBase
+    instance->main_stack_min = *(void **)((uint8_t *)teb + 0x1478); // DeallocationStack
+#elif defined(_WIN32) && (defined(__i386__) || defined(_M_IX86))
+    void *teb = (void *)__readfsdword(0x18);
+
+    instance->main_stack_max = *(void **)((uint8_t *)teb + 0x04); // StackBase
+    instance->main_stack_min = *(void **)((uint8_t *)teb + 0xE0C); // DeallocationStack
+#endif
+
+    err_guard.Disable();
+    return instance;
+}
+
 InstanceData::~InstanceData()
 {
     for (InstanceMemory *mem: memories) {
@@ -1970,38 +1998,6 @@ extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, Bac
     }
 }
 
-static InstanceData *CreateInstance(Napi::Env env)
-{
-    InstanceData *instance = new InstanceData();
-    RG_DEFER_N(err_guard) { delete instance; };
-
-    instance->main_thread_id = std::this_thread::get_id();
-
-    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) {
-        LogError("Failed to create async callback broker");
-        return nullptr;
-    }
-    napi_unref_threadsafe_function(env, instance->broker);
-
-#if defined(_WIN32) && (defined(__x86_64__) || defined(_M_AMD64))
-    void *teb = (void *)__readgsqword(0x30);
-
-    instance->main_stack_max = *(void **)((uint8_t *)teb + 0x08); // StackBase
-    instance->main_stack_min = *(void **)((uint8_t *)teb + 0x1478); // DeallocationStack
-#elif defined(_WIN32) && (defined(__i386__) || defined(_M_IX86))
-    void *teb = (void *)__readfsdword(0x18);
-
-    instance->main_stack_max = *(void **)((uint8_t *)teb + 0x04); // StackBase
-    instance->main_stack_min = *(void **)((uint8_t *)teb + 0xE0C); // DeallocationStack
-#endif
-
-    err_guard.Disable();
-    return instance;
-}
-
 template <typename Func>
 static void SetExports(Napi::Env env, Func func)
 {

package/src/koffi/src/win32.hh

@@ -0,0 +1,59 @@
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see https://www.gnu.org/licenses/.
+
+#pragma once
+
+#include "src/core/libcc/libcc.hh"
+
+#include <intrin.h>
+
+namespace RG {
+
+#if _WIN64
+
+struct TEB {
+    char _pad1[8];
+    void *StackBase;
+    void *StackLimit;
+    char _pad2[5216];
+    void *DeallocationStack;
+};
+RG_STATIC_ASSERT(RG_OFFSET_OF(TEB, DeallocationStack) == 0x1478);
+
+#else
+
+struct TEB {
+    char _pad1[4];
+    void *StackBase;
+    void *StackLimit;
+    char _pad2[3584];
+    void *DeallocationStack;
+};
+RG_STATIC_ASSERT(RG_OFFSET_OF(TEB, DeallocationStack) == 0xE0C);
+
+#endif
+
+static inline TEB *GetTEB()
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    TEB *teb = (TEB *)__getReg(18);
+#elif defined(__x86_64__) || defined(_M_AMD64)
+    TEB *teb = (TEB *)__readgsqword(0x30);
+#else
+    TEB *teb = (TEB *)__readfsdword(0x18);
+#endif
+
+    return teb;
+}
+
+}