koffi 1.1.3 → 1.1.4

package/CMakeLists.txt

@@ -34,6 +34,7 @@ set(KOFFI_SRC
     src/call.cc
     src/abi_arm32.cc
     src/abi_arm64.cc
+    src/abi_riscv64.cc
     src/abi_x64_sysv.cc
     src/abi_x64_win.cc
     src/abi_x86.cc
@@ -45,6 +46,8 @@ set(KOFFI_SRC
 if(CMAKE_SIZEOF_VOID_P EQUAL 8)
     if(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch|arm")
         list(APPEND KOFFI_SRC src/abi_arm64_fwd.S)
+    elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "riscv")
+        list(APPEND KOFFI_SRC src/abi_riscv64_fwd.S)
     elseif(WIN32)
         list(APPEND KOFFI_SRC src/abi_x64_win_fwd.asm)
     else()

package/README.md

@@ -23,23 +23,22 @@ Koffi is a fast and easy-to-use FFI module for Node.js, with support for primiti
 The following features are planned in the near future:
 
 * 1.2: C to JS callbacks
-* 1.3: RISC-V support (32 and 64 bit)
-* 1.4: Type parser
+* 1.3: Type parser
 
 The following combinations of OS and architectures __are officially supported and tested__ at the moment:
 
-ISA / OS           | Windows  | Linux    | macOS       | FreeBSD  | OpenBSD
------------------- | -------- | -------- | ----------- | -------- | --------
-x86 (IA32) [^1]    | 🟩 Yes   | 🟩 Yes   | ⬜️ N/A      | 🟩 Yes   | 🟧 Maybe
-x86_64 (AMD64)     | 🟩 Yes   | 🟩 Yes   | 🟩 Yes      | 🟩 Yes   | 🟩 Yes
-ARM32 VFP LE       | ⬜️ N/A   | 🟩 Yes   | ⬜️ N/A      | 🟧 Maybe | 🟧 Maybe
-ARM32 (no VFP) LE  | ⬜️ N/A   | 🟧 Maybe | ⬜️ N/A      | 🟧 Maybe | 🟧 Maybe
-ARM64 (AArch64) LE | 🟧 Maybe | 🟩 Yes   | 🟩 Yes [^2] | 🟩 Yes   | 🟧 Maybe
-RISC-V 32          | ⬜️ N/A   | 🟥 No    | ⬜️ N/A      | 🟥 No    | 🟥 No
-RISC-V 64          | ⬜️ N/A   | 🟥 No    | ⬜️ N/A      | 🟥 No    | 🟥 No
-
-[^1]: The following call conventions are supported: cdecl, stdcall, MS fastcall, thiscall
-[^2]: However, we don't provide prebuilt binaries for macOS on Apple M1
+ISA / OS           | Windows     | Linux    | macOS       | FreeBSD     | OpenBSD
+------------------ | ----------- | -------- | ----------- | ----------- | --------
+x86 (IA32) [^1]    | 🟩 Yes      | 🟩 Yes   | ⬜️ *N/A*    | 🟩 Yes      | 🟩 Yes
+x86_64 (AMD64)     | 🟩 Yes      | 🟩 Yes   | 🟩 Yes      | 🟩 Yes      | 🟩 Yes
+ARM32 LE [^2]      | ⬜️ *N/A*    | 🟩 Yes   | ⬜️ *N/A*    | 🟨 Probably | 🟨 Probably
+ARM64 (AArch64) LE | 🟧 Maybe    | 🟩 Yes   | 🟩 Yes [^3] | 🟩 Yes      | 🟨 Probably
+RISC-V 64 [^4]     | ⬜️ *N/A*    | 🟩 Yes   | ⬜️ *N/A*    | 🟨 Probably | 🟨 Probably
+
+[^1]: The following call conventions are supported: cdecl, stdcall, MS fastcall, thiscall.
+[^2]: The prebuilt binary uses the hard float ABI and expects a VFP coprocessor. Build from source to use Koffi with a different ABI (softfp, soft).
+[^3]: However, we don't provide prebuilt binaries for macOS on Apple M1.
+[^4]: Only the LP64D (double-precision float) gets tested. The LP64 ABI is supported in theory (untested), the LP64F ABI is not supported.
 
 This is still in development, bugs are to be expected. More tests will come in the near future.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koffi",
-  "version": "1.1.3",
+  "version": "1.1.4",
   "description": "Fast and simple FFI (foreign function interface) for Node.js",
   "keywords": [
     "foreign",

package/qemu/qemu.js

@@ -124,13 +124,12 @@ async function main() {
             machine.started = false;
 
             machine.qemu.accelerate = null;
-            if (accelerate) {
+            if (accelerate && (machine.qemu.binary == 'qemu-system-x86_64' ||
+                               machine.qemu.binary == 'qemu-system-i386')) {
                 if (process.platform == 'linux') {
-                    if (process.arch == 'x64' && (machine.info.arch == 'x64' || machine.info.arch == 'ia32'))
-                        machine.qemu.accelerate = 'kvm';
+                    machine.qemu.accelerate = 'kvm';
                 } else if (process.platform == 'win32') {
-                    if (process.arch == 'x64' && machine.info.arch == 'x64')
-                        machine.qemu.accelerate = 'whpx';
+                    machine.qemu.accelerate = 'whpx';
                 }
             }
         }
@@ -141,19 +140,23 @@ async function main() {
 
         for (let pattern of patterns) {
             let re = minimatch.makeRe(pattern);
+            let match = false;
 
             for (let name in machines_map) {
                 let machine = machines_map[name];
 
-                if (name.match(re) || machine.name.match(re))
+                if (name.match(re) || machine.name.match(re)) {
                     machines.add(name);
+                    match = true;
+                }
             }
-        }
 
-        if (!machines.size) {
-            console.log('Could not match any machine');
-            process.exit(1);
+            if (!match) {
+                console.log(`Pattern '${pattern}' does not match any machine`);
+                process.exit(1);
+            }
         }
+
     } else {
         machines = new Set(Object.keys(machines_map));
 

package/qemu/registry/machines.json

@@ -461,6 +461,97 @@
                 "commands": {
                     "Test Sync": "node test/sync.js",
                     "Test Async": "node test/async.js",
+                    "Test Raylib": "xvfb-run node test/raylib.js",
+                    "Test SQLite": "node test/sqlite.js"
+                }
+            }
+        }
+    },
+
+    "openbsd_i386": {
+        "name": "OpenBSD i386",
+
+        "qemu": {
+            "binary": "qemu-system-x86_64",
+            "arguments": ["-m", "1G", "-smp", 2, "-hda", "disk.qcow2", "-netdev", "user,id=mynet,hostfwd=tcp::22211-:22", "-device", "e1000,netdev=mynet", "-vnc", "127.0.0.1:21"]
+        },
+
+        "info": {
+            "version": 1,
+            "platform": "openbsd",
+            "arch": "ia32",
+
+            "ssh_port": 22211,
+            "vnc_port": 5921,
+
+            "username": "openbsd",
+            "password": "openbsd",
+
+            "shutdown": "sudo shutdown -p now"
+        },
+
+        "builds": {
+            "OpenBSD i386": {
+                "directory": "/home/openbsd/luigi",
+                "build": "node ../cnoke/cnoke.js"
+            }
+        },
+
+        "tests": {
+            "OpenBSD i386": {
+                "directory": "/home/openbsd/luigi",
+                "build": {
+                    "Build": "node ../cnoke/cnoke.js -C test"
+                },
+                "commands": {
+                    "Test Sync": "node test/sync.js",
+                    "Test Async": "node test/async.js",
+                    "Test Raylib": "xvfb-run node test/raylib.js",
+                    "Test SQLite": "node test/sqlite.js"
+                }
+            }
+        }
+    },
+
+    "debian_riscv64": {
+        "name": "Debian RISC-V 64",
+
+        "qemu": {
+            "binary": "qemu-system-riscv64",
+            "arguments": ["-machine", "virt", "-cpu", "rv64", "-m", "1G", "-smp", 2, "-device", "virtio-blk-device,drive=hd", "-drive", "file=disk.qcow2,if=none,id=hd", "-device", "virtio-net-device,netdev=net", "-netdev", "user,id=net,hostfwd=tcp::22212-:22", "-bios", "fw_jump.elf", "-kernel", "uboot.elf", "-append", "root=LABEL=rootfs console=ttyS0", "-vnc", "127.0.0.1:22"]
+        },
+
+        "info": {
+            "version": 1,
+            "platform": "linux",
+            "arch": "riscv64",
+
+            "ssh_port": 22212,
+            "vnc_port": 5912,
+
+            "username": "debian",
+            "password": "debian",
+
+            "shutdown": "sudo poweroff"
+        },
+
+        "builds": {
+            "Linux RISC-V 64": {
+                "directory": "/home/debian/luigi",
+                "build": "node ../cnoke/cnoke.js"
+            }
+        },
+
+        "tests": {
+            "Linux RISC-V 64": {
+                "directory": "/home/debian/luigi",
+                "build": {
+                    "Build": "node ../cnoke/cnoke.js -C test"
+                },
+                "commands": {
+                    "Test Sync": "node test/sync.js",
+                    "Test Async": "node test/async.js",
+                    "Test Raylib": "xvfb-run node test/raylib.js",
                     "Test SQLite": "node test/sqlite.js"
                 }
             }

package/qemu/registry/sha256sum.txt

@@ -47,3 +47,14 @@ d79538ac489f1948b04b65f12c5618c28e4a5de0be062f5cf1d73e422a091a37 *qemu/macos_x64
 9dcdabfc12ad2ba2da1b9c3d95dc46311a12d6e3190f1bfd0c9b184ac1577c94 *qemu/openbsd_x64/install.sh
 6b86b273ff34fce19d6b804eff5a3f5747ada4eaa22f1d49c01e52ddb7875b4b *qemu/openbsd_x64/VERSION
 7b66bdf8b77fd1c6256ffdab623e37ce099797ad657dcd25af5df0486fadce37 *qemu/openbsd_x64/xvfb-run.sh
+570bc6da16ca3b2b068963e7960e76fd23df3ada54398dfc6b6ddf97348ef5d7 *qemu/openbsd_i386/disk.qcow2
+b82c940781ee678499851e1d2aa4868b7154a16ecc4f01c6c56940276c02748f *qemu/openbsd_i386/install.sh
+6b86b273ff34fce19d6b804eff5a3f5747ada4eaa22f1d49c01e52ddb7875b4b *qemu/openbsd_i386/VERSION
+7b66bdf8b77fd1c6256ffdab623e37ce099797ad657dcd25af5df0486fadce37 *qemu/openbsd_i386/xvfb-run.sh
+64048432020bda960f397b5a138ea98aa6bbd42db02e8bb34ff3b9320763e36d *qemu/debian_riscv64/uboot.elf
+0bdd93879f87c338d62422a65fdcba4d8c834848f2305f31b916539cb523e9e8 *qemu/debian_riscv64/readme.txt
+76a5819cdacc8fe284370f441820620e911877122068a3b391fa064b7e9eb180 *qemu/debian_riscv64/initrd
+6b86b273ff34fce19d6b804eff5a3f5747ada4eaa22f1d49c01e52ddb7875b4b *qemu/debian_riscv64/VERSION
+7b6a36b0c2cdd85f3bbee4156de6c65a6f9b01b6bdf95eeb327b6182807ef111 *qemu/debian_riscv64/disk.qcow2
+45755dd1fec10b7d5d67156bf806d3069a9285d18c5b16f06050e5115cc93f18 *qemu/debian_riscv64/kernel
+16a1077672903239e2e4451e6898f9d813b369f9ceede30da8937a1361a050d7 *qemu/debian_riscv64/fw_jump.elf

package/src/abi_arm32.cc

@@ -39,48 +39,19 @@ extern "C" uint64_t ForwardCallXGG(const void *func, uint8_t *sp);
 extern "C" float ForwardCallXF(const void *func, uint8_t *sp);
 extern "C" HfaRet ForwardCallXDDDD(const void *func, uint8_t *sp);
 
-static bool DetectVFP()
+static inline int IsHFA(const TypeInfo *type)
 {
-    // If anything fails, assume VFP is available (true for most Linux platforms)
-    static volatile bool vfp = true;
-    static jmp_buf env;
-
-    struct sigaction prev;
-    SetSignalHandler(SIGILL, [](int) {
-        vfp = false;
-        longjmp(env, 1);
-    }, &prev);
-
-    if (!setjmp(env)) {
-        __asm__ volatile("vmov.f64 d0, #1.0" ::: "d0");
-    }
-
-    return vfp;
-}
-
-static inline bool HasVFP()
-{
-    static bool init = false;
-    static bool vfp;
-
-    if (!init) {
-        vfp = DetectVFP();
-        init = true;
-    }
-
-    return vfp;
-}
-
-static inline bool IsHFA(const TypeInfo *type)
-{
-    return HasVFP() && IsHFA(type, 1, 4);
+#ifdef __ARM_PCS_VFP
+    return IsHFA(type, 1, 4);
+#else
+    return false;
+#endif
 }
 
 bool AnalyseFunction(InstanceData *, FunctionInfo *func)
 {
-    if (IsHFA(func->ret.type)) {
-        func->ret.vec_count = func->ret.type->members.len *
-                              (func->ret.type->members[0].type->size / 4);
+    if (int hfa = IsHFA(func->ret.type); hfa) {
+        func->ret.vec_count = hfa;
     } else if (func->ret.type->primitive != PrimitiveKind::Record ||
                func->ret.type->size <= 4) {
         func->ret.gpr_count = (func->ret.type->size > 4) ? 2 : 1;
@@ -123,13 +94,12 @@ bool AnalyseFunction(InstanceData *, FunctionInfo *func)
                 }
             } break;
             case PrimitiveKind::Record: {
-                if (IsHFA(param.type)) {
-                    int vec_count = (int)(param.type->members.len *
-                                          param.type->members[0].type->size / 4);
+                int hfa = IsHFA(param.type);
 
-                    if (vec_count <= vec_avail) {
-                        param.vec_count = vec_count;
-                        vec_avail -= vec_count;
+                if (hfa) {
+                    if (hfa <= vec_avail) {
+                        param.vec_count = hfa;
+                        vec_avail -= hfa;
                     } else {
                         vec_avail = 0;
                         started_stack = true;
@@ -151,7 +121,12 @@ bool AnalyseFunction(InstanceData *, FunctionInfo *func)
             case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
             case PrimitiveKind::Float32:
             case PrimitiveKind::Float64: {
-                bool vfp = HasVFP() && !param.variadic;
+#ifdef __ARM_PCS_VFP
+                bool vfp = !param.variadic;
+#else
+                bool vfp = false;
+#endif
+
                 Size need = param.type->size / 4;
 
                 if (vfp) {
@@ -413,8 +388,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
         }
     }
 
-    stack = MakeSpan(mem->stack.end(), old_stack_mem.end() - mem->stack.end());
-    heap = MakeSpan(old_heap_mem.ptr, mem->heap.ptr - old_heap_mem.ptr);
+    sp = mem->stack.end();
 
     return true;
 }
@@ -423,8 +397,8 @@ void CallData::Execute()
 {
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
-            auto ret = (func->forward_fp ? ForwardCallX ## Suffix(func->func, stack.ptr) \
-                                         : ForwardCall ## Suffix(func->func, stack.ptr)); \
+            auto ret = (func->forward_fp ? ForwardCallX ## Suffix(func->func, sp) \
+                                         : ForwardCall ## Suffix(func->func, sp)); \
             return ret; \
         })()
 
@@ -446,7 +420,7 @@ void CallData::Execute()
         case PrimitiveKind::Record: {
             if (func->ret.vec_count) {
                 HfaRet ret = PERFORM_CALL(DDDD);
-                memcpy_safe(&result.buf, &ret, RG_SIZE(ret));
+                memcpy(&result.buf, &ret, RG_SIZE(ret));
             } else {
                 result.u64 = PERFORM_CALL(GG);
             }

package/src/abi_arm64.cc

@@ -41,15 +41,15 @@ extern "C" X0X1Ret ForwardCallXGG(const void *func, uint8_t *sp);
 extern "C" float ForwardCallXF(const void *func, uint8_t *sp);
 extern "C" HfaRet ForwardCallXDDDD(const void *func, uint8_t *sp);
 
-static inline bool IsHFA(const TypeInfo *type)
+static inline int IsHFA(const TypeInfo *type)
 {
     return IsHFA(type, 1, 4);
 }
 
 bool AnalyseFunction(InstanceData *, FunctionInfo *func)
 {
-    if (IsHFA(func->ret.type)) {
-        func->ret.vec_count = func->ret.type->members.len;
+    if (int hfa = IsHFA(func->ret.type); hfa) {
+        func->ret.vec_count = hfa;
     } else if (func->ret.type->size <= 16) {
         func->ret.gpr_count = (func->ret.type->size + 7) / 8;
     } else {
@@ -86,10 +86,12 @@ bool AnalyseFunction(InstanceData *, FunctionInfo *func)
                 }
             } break;
             case PrimitiveKind::Record: {
-                bool hfa = IsHFA(param.type);
+                int hfa = IsHFA(param.type);
 
 #if defined(_WIN32)
-                hfa &= !param.variadic;
+                if (!param.variadic) {
+                    hfa = 0;
+                }
 #elif defined(__APPLE__)
                 if (param.variadic) {
                     param.use_memory = (param.type->size > 16);
@@ -98,11 +100,9 @@ bool AnalyseFunction(InstanceData *, FunctionInfo *func)
 #endif
 
                 if (hfa) {
-                    int vec_count = (int)param.type->members.len;
-
-                    if (vec_count <= vec_avail) {
-                        param.vec_count = vec_count;
-                        vec_avail -= vec_count;
+                    if (hfa <= vec_avail) {
+                        param.vec_count = hfa;
+                        vec_avail -= hfa;
                     } else {
                         vec_avail = 0;
                     }
@@ -395,8 +395,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
         }
     }
 
-    stack = MakeSpan(mem->stack.end(), old_stack_mem.end() - mem->stack.end());
-    heap = MakeSpan(old_heap_mem.ptr, mem->heap.ptr - old_heap_mem.ptr);
+    sp = mem->stack.end();
 
     return true;
 }
@@ -405,8 +404,8 @@ void CallData::Execute()
 {
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
-            auto ret = (func->forward_fp ? ForwardCallX ## Suffix(func->func, stack.ptr) \
-                                         : ForwardCall ## Suffix(func->func, stack.ptr)); \
+            auto ret = (func->forward_fp ? ForwardCallX ## Suffix(func->func, sp) \
+                                         : ForwardCall ## Suffix(func->func, sp)); \
             return ret; \
         })()
 
@@ -428,10 +427,10 @@ void CallData::Execute()
         case PrimitiveKind::Record: {
             if (func->ret.gpr_count) {
                 X0X1Ret ret = PERFORM_CALL(GG);
-                memcpy_safe(&result.buf, &ret, RG_SIZE(ret));
+                memcpy(&result.buf, &ret, RG_SIZE(ret));
             } else if (func->ret.vec_count) {
                 HfaRet ret = PERFORM_CALL(DDDD);
-                memcpy_safe(&result.buf, &ret, RG_SIZE(ret));
+                memcpy(&result.buf, &ret, RG_SIZE(ret));
             } else {
                 PERFORM_CALL(GG);
             }