koffi 2.2.3-beta.3 → 2.2.3

package/ChangeLog.md

@@ -2,6 +2,16 @@
 
 ## History
 
+### Koffi 2.2.3
+
+**Main fixes:**
+
+- Support native code that uses [Structured Exception Handling (SEH)](https://learn.microsoft.com/en-us/cpp/cpp/structured-exception-handling-c-cpp) on Windows (x86, x64 and ARM64)
+
+**Other changes:**
+
+- Try to use ebp/rbp as frame pointer in x86/x64 ASM code
+
 ### Koffi 2.2.2
 
 **Main fixes:**

package/package.json

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

package/src/koffi/src/abi_arm64.cc

@@ -17,6 +17,9 @@
 #include "ffi.hh"
 #include "call.hh"
 #include "util.hh"
+#ifdef _WIN32
+    #include "win32.hh"
+#endif
 
 #include <napi.h>
 
@@ -494,6 +497,24 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
 
 void CallData::Execute(const FunctionInfo *func)
 {
+#ifdef _WIN32
+    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->StackBase = mem->stack0.end();
+    teb->StackLimit = mem->stack0.ptr;
+    teb->DeallocationStack = mem->stack0.ptr;
+#endif
+
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
             auto ret = (func->forward_fp ? ForwardCallX ## Suffix(func->func, new_sp, &old_sp) \
@@ -611,6 +632,24 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
     if (RG_UNLIKELY(env.IsExceptionPending()))
         return;
 
+#ifdef _WIN32
+    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->StackBase = instance->main_stack_max;
+    teb->StackLimit = instance->main_stack_min;
+    teb->DeallocationStack = instance->main_stack_min;
+#endif
+
     const TrampolineInfo &trampoline = shared.trampolines[idx];
 
     const FunctionInfo *proto = trampoline.proto;

package/src/koffi/src/abi_x64_sysv_fwd.S

@@ -45,11 +45,11 @@
     .cfi_def_cfa rsp, 8
     ENDBR64
     movq %rdi, %r11
-    pushq %rbx
+    pushq %rbp
     .cfi_def_cfa rsp, 16
     movq %rsp, (%rdx)
-    movq %rsp, %rbx
-    .cfi_def_cfa rbx, 16
+    movq %rsp, %rbp
+    .cfi_def_cfa rbp, 16
     leaq 112(%rsi), %rsp
 .endm
 
@@ -58,8 +58,8 @@
 # The return value is passed untouched through RAX or XMM0.
 .macro epilogue
     call *%r11
-    movq %rbx, %rsp
-    popq %rbx
+    movq %rbp, %rsp
+    popq %rbp
     .cfi_def_cfa rsp, 8
     ret
     .cfi_endproc
@@ -241,9 +241,9 @@ SYMBOL(CallSwitchStack):
     .cfi_startproc
     .cfi_def_cfa rsp, 8
     ENDBR64
-    push %rbx
+    push %rbp
     .cfi_def_cfa rsp, 16
-    movq %rsp, %rbx
+    movq %rsp, %rbp
     movq %rsp, %r10
     subq 0(%r8), %r10
     andq $-16, %r10
@@ -251,9 +251,9 @@ SYMBOL(CallSwitchStack):
     movq %rcx, %rsp
     .cfi_def_cfa rsp, 16
     call *%r9
-    mov %rbx, %rsp
+    mov %rbp, %rsp
     .cfi_def_cfa rsp, 16
-    pop %rbx
+    pop %rbp
     .cfi_def_cfa rsp, 8
     ret
     .cfi_endproc

package/src/koffi/src/abi_x64_win_fwd.asm

@@ -33,11 +33,11 @@ public ForwardCallXD
 prologue macro
     endbr64
     mov rax, rcx
-    push rbx
-    .pushreg rbx
-    mov rbx, rsp
+    push rbp
+    .pushreg rbp
+    mov rbp, rsp
     mov qword ptr [r8+0], rsp
-    .setframe rbx, 0
+    .setframe rbp, 0
     .endprolog
     mov rsp, rdx
 endm
@@ -47,8 +47,8 @@ endm
 ; The return value is passed untouched through RAX or XMM0.
 epilogue macro
     call rax
-    mov rsp, rbx
-    pop rbx
+    mov rsp, rbp
+    pop rbp
     ret
 endm
 
@@ -169,10 +169,10 @@ endm
 ; The first three parameters (rcx, rdx, r8) are passed through untouched.
 CallSwitchStack proc frame
     endbr64
-    push rbx
-    .pushreg rbx
-    mov rbx, rsp
-    .setframe rbx, 0
+    push rbp
+    .pushreg rbp
+    mov rbp, rsp
+    .setframe rbp, 0
     .endprolog
     mov rax, qword ptr [rsp+56]
     mov r10, rsp
@@ -182,8 +182,8 @@ CallSwitchStack proc frame
     mov qword ptr [r11+8], r10
     lea rsp, [r9-32]
     call rax
-    mov rsp, rbx
-    pop rbx
+    mov rsp, rbp
+    pop rbp
     ret
 CallSwitchStack endp
 

package/src/koffi/src/abi_x86_fwd.S

@@ -27,10 +27,10 @@
     .cfi_startproc
     .cfi_def_cfa esp, 4
     ENDBR32
-    push %ebx
+    push %ebp
     .cfi_def_cfa esp, 8
-    movl %esp, %ebx
-    .cfi_def_cfa ebx, 8
+    movl %esp, %ebp
+    .cfi_def_cfa ebp, 8
     movl 16(%esp), %eax
     movl %esp, 0(%eax)
     movl 8(%esp), %eax
@@ -48,8 +48,8 @@
 # The return value is passed back untouched.
 .macro epilogue
     call *%eax
-    movl %ebx, %esp
-    pop %ebx
+    movl %ebp, %esp
+    pop %ebp
     .cfi_def_cfa esp, 4
     ret
     .cfi_endproc
@@ -168,10 +168,10 @@ CallSwitchStack:
     .cfi_startproc
     .cfi_def_cfa esp, 4
     ENDBR32
-    push %ebx
+    push %ebp
     .cfi_def_cfa esp, 8
-    movl %esp, %ebx
-    .cfi_def_cfa ebx, 8
+    movl %esp, %ebp
+    .cfi_def_cfa ebp, 8
     movl 28(%esp), %edx
     movl 24(%esp), %ecx
     movl %esp, %eax
@@ -180,16 +180,16 @@ CallSwitchStack:
     movl %eax, 4(%ecx)
     movl 20(%esp), %esp
     subl $28, %esp
-    movl 8(%ebx), %eax
+    movl 8(%ebp), %eax
     movl %eax, 0(%esp)
-    movl 12(%ebx), %eax
+    movl 12(%ebp), %eax
     movl %eax, 4(%esp)
-    movl 16(%ebx), %eax
+    movl 16(%ebp), %eax
     movl %eax, 8(%esp)
     call *%edx
-    mov %ebx, %esp
+    mov %ebp, %esp
     .cfi_def_cfa esp, 8
-    pop %ebx
+    pop %ebp
     .cfi_def_cfa esp, 4
     ret
     .cfi_endproc

package/src/koffi/src/abi_x86_fwd.asm

@@ -29,8 +29,8 @@ public ForwardCallRD
 ; Save ESP in EBX (non-volatile), and use carefully assembled stack provided by caller.
 prologue macro
     endbr32
-    push ebx
-    mov ebx, esp
+    push ebp
+    mov ebp, esp
     mov eax, dword ptr [esp+16]
     mov dword ptr [eax+0], esp
     mov eax, dword ptr [esp+8]
@@ -48,8 +48,8 @@ endm
 ; The return value is passed back untouched.
 epilogue macro
     call eax
-    mov esp, ebx
-    pop ebx
+    mov esp, ebp
+    pop ebp
     ret
 endm
 
@@ -153,8 +153,8 @@ endm
 ; stack pointer, call Node.js/V8 and go back to ours.
 CallSwitchStack proc
     endbr32
-    push ebx
-    mov ebx, esp
+    push ebp
+    mov ebp, esp
     mov edx, dword ptr [esp+28]
     mov ecx, dword ptr [esp+24]
     mov eax, esp
@@ -163,15 +163,15 @@ CallSwitchStack proc
     mov dword ptr [ecx+4], eax
     mov esp, dword ptr [esp+20]
     sub esp, 28
-    mov eax, dword ptr [ebx+8]
+    mov eax, dword ptr [ebp+8]
     mov dword ptr [esp+0], eax
-    mov eax, dword ptr [ebx+12]
+    mov eax, dword ptr [ebp+12]
     mov dword ptr [esp+4], eax
-    mov eax, dword ptr [ebx+16]
+    mov eax, dword ptr [ebp+16]
     mov dword ptr [esp+8], eax
     call edx
-    mov esp, ebx
-    pop ebx
+    mov esp, ebp
+    pop ebp
     ret
 CallSwitchStack endp
 

package/src/koffi/src/ffi.cc

@@ -33,6 +33,9 @@
     #include <dlfcn.h>
     #include <unistd.h>
     #include <sys/mman.h>
+    #ifndef MAP_STACK
+        #define MAP_STACK 0
+    #endif
 #endif
 
 #include <napi.h>
@@ -1019,60 +1022,39 @@ static InstanceMemory *AllocateMemory(InstanceData *instance, Size stack_size, S
     InstanceMemory *mem = new InstanceMemory();
     RG_DEFER_N(mem_guard) { delete mem; };
 
+    stack_size = AlignLen(stack_size, Kibibytes(64));
+
 #if defined(_WIN32)
-    {
-        struct FiberContext {
-            InstanceMemory *mem;
-            void *self;
-            bool was_fiber;
-        };
+    static const int PageSize = ([]() {
+        SYSTEM_INFO info = {};
 
-        FiberContext ctx;
-        bool is_fiber = IsThreadAFiber();
+        GetNativeSystemInfo(&info);
+        RG_ASSERT(info.dwPageSize);
 
-        ctx.mem = mem;
-        ctx.self = is_fiber ? GetCurrentFiber() : ConvertThreadToFiber(nullptr);
-        if (!ctx.self) {
-            LogError("Failed to make initial fiber: %1", GetWin32ErrorString());
-            return nullptr;
-        }
-        RG_DEFER {
-            if (!is_fiber) {
-                ConvertFiberToThread();
-            }
-        };
+        return (int)info.dwPageSize;
+    })();
 
-        // Work around issue with CreateFiber() API and stack size
-        // See here: https://github.com/google/marl/issues/12
-        mem->fiber = CreateFiberEx(stack_size - 1, stack_size,
-                                   FIBER_FLAG_FLOAT_SWITCH, [](void *udata) {
-            FiberContext *ctx = (FiberContext *)udata;
-
-            TEB *teb = GetTEB();
+    // Allocate stack memory
+    {
+        mem->stack.len = stack_size;
+        mem->stack.ptr = (uint8_t *)VirtualAlloc(nullptr, mem->stack.len + 2 * PageSize, MEM_RESERVE, PAGE_NOACCESS);
 
-            ctx->mem->stack.ptr = (uint8_t *)teb->DeallocationStack;
-            ctx->mem->stack.len = (uint8_t *)teb->StackBase - ctx->mem->stack.ptr;
+        RG_CRITICAL(mem->stack.ptr, "Failed to allocate %1 of memory", mem->stack.len);
 
-            SwitchToFiber(ctx->self);
-        }, &ctx);
+        bool success = true;
 
-        if (!mem->fiber) {
-            LogError("Failed to create Win32 fiber: %1", GetWin32ErrorString());
-            return nullptr;
-        }
+        success &= !!VirtualAlloc(mem->stack.ptr + 0 * PageSize, PageSize, MEM_COMMIT, PAGE_NOACCESS);
+        success &= !!VirtualAlloc(mem->stack.ptr + 1 * PageSize, PageSize, MEM_COMMIT, PAGE_READWRITE | PAGE_GUARD);
+        success &= !!VirtualAlloc(mem->stack.ptr + 2 * PageSize, mem->stack.len, MEM_COMMIT, PAGE_READWRITE);
 
-        SwitchToFiber(mem->fiber);
+        RG_CRITICAL(success, "Cannot commit stack memory: %1", GetWin32ErrorString());
     }
-
-    RG_ASSERT(mem->stack.ptr);
-#elif defined(__APPLE__)
-    mem->stack.len = stack_size;
-    mem->stack.ptr = (uint8_t *)mmap(nullptr, mem->stack.len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
 #else
     mem->stack.len = stack_size;
     mem->stack.ptr = (uint8_t *)mmap(nullptr, mem->stack.len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON | MAP_STACK, -1, 0);
-#endif
+
     RG_CRITICAL(mem->stack.ptr, "Failed to allocate %1 of memory", mem->stack.len);
+#endif
 
 #ifdef __OpenBSD__
     // Make sure the SP points inside the MAP_STACK area, or (void) functions may crash on OpenBSD i386
@@ -1773,16 +1755,11 @@ static InstanceData *CreateInstance(Napi::Env env)
     }
     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);
+#ifdef _WIN32
+    TEB *teb = GetTEB();
 
-    instance->main_stack_max = *(void **)((uint8_t *)teb + 0x04); // StackBase
-    instance->main_stack_min = *(void **)((uint8_t *)teb + 0xE0C); // DeallocationStack
+    instance->main_stack_max = teb->StackBase;
+    instance->main_stack_min = teb->DeallocationStack;
 #endif
 
     err_guard.Disable();

package/src/koffi/test/CMakeLists.txt

@@ -116,3 +116,10 @@ if(MSVC)
     target_compile_options(misc PRIVATE /wd4116)
     target_link_options(misc PRIVATE "/DEF:${CMAKE_CURRENT_SOURCE_DIR}/misc.def")
 endif()
+
+# ---- Win32 ----
+
+if(WIN32)
+    add_library(win32 SHARED win32.c)
+    set_target_properties(win32 PROPERTIES PREFIX "")
+endif()

package/src/koffi/test/win32.c

@@ -0,0 +1,39 @@
+// 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/.
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <inttypes.h>
+#include <string.h>
+#include <stdarg.h>
+
+#define NOMINMAX
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+#define EXPORT __declspec(dllexport)
+
+EXPORT int DivideBySafe(int a, int b)
+{
+    __try {
+        return a / b;
+    } __except (GetExceptionCode() == EXCEPTION_INT_DIVIDE_BY_ZERO) {
+        return -42;
+    }
+}
+
+EXPORT int CallThrough(int (*func)(void))
+{
+    int ret = func();
+    return ret;
+}

package/src/koffi/test/win32.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+
+// 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/.
+
+const koffi = require('./build/koffi.node');
+const assert = require('assert');
+const util = require('util');
+
+const CallThroughFunc = koffi.callback('int CallThroughFunc()');
+
+main();
+
+async function main() {
+    try {
+        await test();
+        console.log('Success!');
+    } catch (err) {
+        console.error(err);
+        process.exit(1);
+    }
+}
+
+async function test() {
+    let lib_filename = __dirname + '/build/win32.dll';
+    let lib = koffi.load(lib_filename);
+
+    const DivideBySafe = lib.func('int DivideBySafe(int a, int b)');
+    const CallThrough = lib.func('int CallThrough(CallThroughFunc *func)');
+
+    // Sync SEH support
+    assert.equal(DivideBySafe(12, 3), 4);
+    assert.equal(DivideBySafe(84, 0), -42);
+
+    // Async SEH support
+    {
+        let results = await Promise.all([
+            util.promisify(DivideBySafe.async)(90, -9),
+            util.promisify(DivideBySafe.async)(227, 0)
+        ]);
+
+        assert.equal(results[0], -10);
+        assert.equal(results[1], -42);
+    }
+
+    // Test SEH inside callback
+    assert.equal(CallThrough(() => DivideBySafe(16, 2)), 8);
+    assert.equal(CallThrough(() => DivideBySafe(16 * 2, 0)), -42);
+
+    // Test SEH inside callback running async
+    {
+        let results = await Promise.all([
+            util.promisify(CallThrough.async)(() => DivideBySafe(75, -5)),
+            util.promisify(CallThrough.async)(() => DivideBySafe(7, 5 - 5))
+        ]);
+
+        assert.equal(results[0], -15);
+        assert.equal(results[1], -42);
+    }
+}

package/src/koffi/tools/qemu.js

@@ -571,7 +571,7 @@ async function upload(snapshot_dir, func) {
         }
 
         let status = copied ? chalk.bold.green('[ok]') : chalk.bold.red('[error]');
-        log(machine, 'Copy', status);
+        log(machine, 'Upload', status);
     }));
 
     return success;
@@ -605,7 +605,7 @@ async function test() {
                 let ret = await exec_remote(machine, cmd, cwd);
                 let time = Number((process.hrtime.bigint() - start) / 1000000n);
 
-                if (ret.code == 0) {
+                if (ret.code === 0) {
                     log(machine, `${suite} > ${name}`, chalk.bold.green(`[${(time / 1000).toFixed(2)}s]`));
                 } else {
                     log(machine, `${suite} > ${name}`, chalk.bold.red('[error]'));
@@ -654,8 +654,6 @@ async function stop(all = true) {
 
     console.log('>> Sending shutdown commands...');
     await Promise.all(machines.map(async machine => {
-        if (ignore.has(machine))
-            return;
         if (machine.qemu == null)
             return;
         if (!machine.started && !all)
@@ -916,19 +914,32 @@ function log(machine, action, status) {
 }
 
 async function exec_remote(machine, cmd, cwd = null) {
+    if (typeof cmd == 'string') {
+        cmd = {
+            command: cmd,
+            repeat: 1
+        };
+    }
+
     try {
+        let ret = { code: 0 };
+
         if (machine.platform == 'win32') {
+            let cmd_line = cmd.command;
+
             if (cwd != null) {
                 cwd = cwd.replaceAll('/', '\\');
-                cmd = `cd "${cwd}" && ${cmd}`;
+                cmd_line = `cd "${cwd}" && ${cmd_line}`;
             }
 
-            let ret = await machine.ssh.execCommand(cmd);
-            return ret;
+            for (let i = 0; ret.code === 0 && i < cmd.repeat; i++)
+                ret = await machine.ssh.execCommand(cmd_line);
         } else {
-            let ret = await machine.ssh.execCommand(cmd, { cwd: cwd });
-            return ret;
+            for (let i = 0; ret.code === 0 && i < cmd.repeat; i++)
+                ret = await machine.ssh.execCommand(cmd.command, { cwd: cwd });
         }
+
+        return ret;
     } catch (err) {
         console.log(err);
         return err;

package/src/koffi/tools/registry/machines.json

@@ -230,7 +230,11 @@
                     "Test Async": "C:\\Node32\\node32.cmd node test/async.js",
                     "Test Callbacks": "C:\\Node32\\node32.cmd node test/callbacks.js",
                     "Test Raylib": "seatsh C:\\Node32\\node32.cmd node test/raylib.js",
-                    "Test SQLite": "C:\\Node32\\node32.cmd node test/sqlite.js"
+                    "Test SQLite": "C:\\Node32\\node32.cmd node test/sqlite.js",
+                    "Test Win32": {
+                        "command": "C:\\Node32\\node32.cmd node test/win32.js",
+                        "repeat": 8
+                    }
                 }
             },
 
@@ -244,7 +248,11 @@
                     "Test Async": "C:\\Node64\\node64.cmd node test/async.js",
                     "Test Callbacks": "C:\\Node64\\node64.cmd node test/callbacks.js",
                     "Test Raylib": "seatsh C:\\Node64\\node64.cmd node test/raylib.js",
-                    "Test SQLite": "C:\\Node64\\node64.cmd node test/sqlite.js"
+                    "Test SQLite": "C:\\Node64\\node64.cmd node test/sqlite.js",
+                    "Test Win32": {
+                        "command": "C:\\Node64\\node64.cmd node test/win32.js",
+                        "repeat": 8
+                    }
                 }
             }
         }