koffi 0.9.6 → 0.9.9

package/README.md

@@ -1,6 +1,15 @@
+# Table of contents
+
+- [Introduction](#introduction)
+- [Installation](#installation)
+  * [Windows](#windows)
+  * [Other platforms](#other-platforms)
+- [Get started](#get-started)
+- [Tests](#tests)
+
 # Introduction
 
-koffi is a fast and easy-to-use FFI module for Node.js, with support for complex data types such as structs.
+Koffi is a fast and easy-to-use FFI module for Node.js, with support for complex data types such as structs.
 
 The following platforms __are supported__ at the moment:
 
@@ -8,8 +17,8 @@ The following platforms __are supported__ at the moment:
 * Windows x86_64
 * Linux x86
 * Linux x86_64
-* Linux ARM32+VFP Little Endian *(Raspberry Pi OS 32-bit)*
-* Linux ARM64 Little Endian *(Raspberry Pi OS 64-bit)*
+* Linux ARM32+VFP Little Endian
+* Linux ARM64 Little Endian
 
 The following platforms are __not yet supported__ but will be soon:
 
@@ -36,7 +45,7 @@ Once this is done, run this command from the project root:
 npm install koffi
 ```
 
-## Other platforms (Linux, macOS, etc.)
+## Other platforms
 
 Make sure the following dependencies are met:
 
@@ -50,14 +59,14 @@ Once these dependencies are met, simply run the follow command:
 npm install koffi
 ```
 
-# How to use
+# Get started
 
 This section assumes you know how to build C shared libraries.
 
-This examples illustrates how to use koffi with a Raylib shared library:
+This examples illustrates how to use Koffi with a Raylib shared library:
 
 ```js
-const koffi = require('koffi/build/Release/koffi.node');
+const koffi = require('build/koffi.node');
 
 const Color = koffi.struct('Color', {
     r: 'uchar',
@@ -160,3 +169,60 @@ while (!raylib.WindowShouldClose()) {
 }
 
 ```
+
+# Tests
+
+Koffi is tested on multiple architectures using emulated (accelerated when possible) QEMU machines. First, you need to install qemu packages, such as `qemu-system` (or even `qemu-system-gui`) on Ubuntu.
+
+These machines are not included directly in this repository (for license and size reasons), but they are available here: https://koromix.dev/files/koffi/
+
+For example, if you want to run the tests on Debian ARM64, run the following commands:
+
+```sh
+cd luigi/koffi/test/
+wget -q -O- https://koromix.dev/files/koffi/qemu_debian_arm64.tar.zst | zstd -d | tar xv
+sha256sum -c --ignore-missing registry/sha256sum.txt
+```
+
+Note that the machine disk content may change each time the machine runs, so the checksum test will fail once a machine has been used at least once.
+
+And now you can run the tests with:
+
+```sh
+node test.js # Several options are available, use --help
+```
+
+And be patient, this can be pretty slow for emulated machines. The Linux machines have and use ccache to build Koffi, so subsequent build steps will get much more tolerable.
+
+By default, machines are started and stopped for each test. But you can start the machines ahead of time and run the tests multiple times instead:
+
+```sh
+node test.js start # Start the machines
+node test.js # Test (without shutting down)
+node test.js # Test again
+node test.js stop # Stop everything
+```
+
+You can also restrict the test to a subset of machines:
+
+```sh
+# Full test cycle
+node test.js test debian_x64 debian_i386
+
+# Separate start, test, shutdown
+node test.js start debian_x64 debian_i386
+node test.js test debian_x64 debian_i386
+node test.js stop
+```
+
+Finally, you can join a running machine with SSH with the following shortcut, if you need to do some debugging or any other manual procedure:
+
+```sh
+node test.js ssh debian_i386
+```
+
+Each machine is configured to run a VNC server available locally, which you can use to access the display, using KRDC or any other compatible viewer. Use the `info` command to get the VNC port.
+
+```sh
+node test.js info debian_x64
+```

package/package.json

@@ -1,19 +1,42 @@
 {
   "name": "koffi",
-  "version": "0.9.6",
+  "version": "0.9.9",
   "description": "Fast and simple FFI (foreign function interface) for Node.js",
-  "keywords": ["foreign", "function", "interface", "ffi", "binding", "c", "napi"],
+  "keywords": [
+    "foreign",
+    "function",
+    "interface",
+    "ffi",
+    "binding",
+    "c",
+    "napi"
+  ],
   "repository": {
     "type": "git",
     "url": "https://github.com/Koromix/luigi.git"
   },
   "author": "Niels Martignène <niels.martignene@protonmail.com>",
-  "main": "build/Release/koffi.node",
+  "main": "build/koffi.node",
   "scripts": {
-    "install": "cmake-js"
+    "install": "node ../cnoke/cnoke.js",
+    "test": "node test/test.js"
   },
   "license": "AGPL-3.0",
   "dependencies": {
-    "cmake-js": "^6.3.0"
-  }
+    "cnoke": "^0.9.22"
+  },
+  "devDependencies": {
+    "chalk": "^4.1.2",
+    "node-ssh": "^12.0.3"
+  },
+  "files": [
+    "src",
+    "test/files",
+    "test/registry",
+    "test/tests",
+    "test/test.js",
+    "vendor",
+    "LICENSE.txt",
+    "README.md"
+  ]
 }

package/src/call.hh

@@ -19,9 +19,10 @@
 
 namespace RG {
 
+struct InstanceData;
 struct FunctionInfo;
 
-bool AnalyseFunction(FunctionInfo *func);
+bool AnalyseFunction(InstanceData *instance, FunctionInfo *func);
 Napi::Value TranslateCall(const Napi::CallbackInfo &info);
 
 }

package/src/call_arm32.cc

@@ -56,7 +56,7 @@ static bool IsHFA(const TypeInfo *type)
     return true;
 }
 
-bool AnalyseFunction(FunctionInfo *func)
+bool AnalyseFunction(InstanceData *, FunctionInfo *func)
 {
     if (IsHFA(func->ret.type)) {
         func->ret.vec_count = func->ret.type->members.len *
@@ -132,17 +132,17 @@ bool AnalyseFunction(FunctionInfo *func)
                     if (gpr_count <= gpr_avail) {
                         param.gpr_count = gpr_count;
                         gpr_avail -= gpr_count;
-                    } else {
-                        if (!started_stack) {
-                            param.gpr_count = gpr_avail;
-                            gpr_avail = 0;
+                    } else if (!started_stack) {
+                        param.gpr_count = gpr_avail;
+                        gpr_avail = 0;
 
-                            started_stack = true;
-                        }
+                        started_stack = true;
                     }
                 }
             } break;
         }
+
+        func->args_size += AlignLen(param.type->size, 16);
     }
 
     func->forward_fp = (vec_avail < 16);
@@ -155,7 +155,7 @@ static bool PushHFA(const Napi::Object &obj, const TypeInfo *type, uint8_t *dest
     Napi::Env env = obj.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
-    RG_ASSERT(obj.IsObject());
+    RG_ASSERT(IsObject(obj));
     RG_ASSERT(type->primitive == PrimitiveKind::Record);
     RG_ASSERT(AlignUp(dest, type->members[0].type->size) == dest);
 
@@ -168,14 +168,14 @@ static bool PushHFA(const Napi::Object &obj, const TypeInfo *type, uint8_t *dest
                 return false;
             }
 
-            *(float *)dest = CopyNodeNumber<float>(value);
+            *(float *)dest = CopyNumber<float>(value);
         } else if (member.type->primitive == PrimitiveKind::Float64) {
             if (!value.IsNumber() && !value.IsBigInt()) {
                 ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected number", GetValueType(instance, value), member.name);
                 return false;
             }
 
-            *(double *)dest = CopyNodeNumber<double>(value);
+            *(double *)dest = CopyNumber<double>(value);
         } else {
             RG_UNREACHABLE();
         }
@@ -213,11 +213,9 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
-
     FunctionInfo *func = (FunctionInfo *)info.Data();
-    LibraryData *lib = func->lib.get();
 
-    RG_DEFER { lib->tmp_alloc.ReleaseAll(); };
+    CallData call(env, instance, func);
 
     // Sanity checks
     if (info.Length() < (uint32_t)func->parameters.len) {
@@ -225,46 +223,32 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    // Stack pointer and register
-    uint8_t *top_ptr = lib->stack.end();
     uint8_t *return_ptr = nullptr;
     uint8_t *args_ptr = nullptr;
     uint32_t *gpr_ptr = nullptr;
     uint32_t *vec_ptr = nullptr;
-    uint8_t *sp_ptr = nullptr;
 
     // Return through registers unless it's too big
-    if (!func->ret.use_memory) {
-        args_ptr = top_ptr - func->scratch_size;
-        gpr_ptr = (uint32_t *)args_ptr - 4;
-        vec_ptr = gpr_ptr - 16;
-        sp_ptr = (uint8_t *)vec_ptr;
-
-#ifdef RG_DEBUG
-        memset(sp_ptr, 0, top_ptr - sp_ptr);
-#endif
-    } else {
-        return_ptr = top_ptr - AlignLen(func->ret.type->size, 16);
-
-        args_ptr = return_ptr - func->scratch_size;
-        gpr_ptr = (uint32_t *)args_ptr - 4;
-        vec_ptr = gpr_ptr - 16;
-        sp_ptr = (uint8_t *)vec_ptr;
-
-#ifdef RG_DEBUG
-        memset(sp_ptr, 0, top_ptr - sp_ptr);
-#endif
-
-        *(gpr_ptr++) = (uint32_t)return_ptr;
+    if (RG_UNLIKELY(!call.AllocStack(func->args_size, 16, &args_ptr)))
+        return env.Null();
+    if (RG_UNLIKELY(!call.AllocStack(4 * 4, 8, &gpr_ptr)))
+        return env.Null();
+    if (RG_UNLIKELY(!call.AllocStack(8 * 8, 8, &vec_ptr)))
+        return env.Null();
+    if (func->ret.use_memory) {
+        if (RG_UNLIKELY(!call.AllocHeap(func->ret.type->size, 16, &return_ptr)))
+            return env.Null();
+        *(uint8_t **)(gpr_ptr++) = return_ptr;
     }
+    RG_ASSERT((uint8_t *)gpr_ptr + 16 == args_ptr);
 
-    RG_ASSERT(AlignUp(lib->stack.ptr, 16) == lib->stack.ptr);
-    RG_ASSERT(AlignUp(lib->stack.end(), 16) == lib->stack.end());
-    RG_ASSERT(AlignUp(sp_ptr, 16) == sp_ptr);
+    LocalArray<OutObject, MaxOutParameters> out_objects;
 
     // Push arguments
     for (Size i = 0; i < func->parameters.len; i++) {
         const ParameterInfo &param = func->parameters[i];
+        RG_ASSERT(param.directions >= 1 && param.directions <= 3);
+
         Napi::Value value = info[i];
 
         switch (param.type->primitive) {
@@ -295,7 +279,7 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                     return env.Null();
                 }
 
-                int64_t v = CopyNodeNumber<int64_t>(value);
+                int64_t v = CopyNumber<int64_t>(value);
 
                 if (RG_LIKELY(param.gpr_count)) {
                     *(gpr_ptr++) = (uint32_t)v;
@@ -312,7 +296,7 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                     return env.Null();
                 }
 
-                int64_t v = CopyNodeNumber<int64_t>(value);
+                int64_t v = CopyNumber<int64_t>(value);
 
                 if (RG_LIKELY(param.gpr_count)) {
                     *(uint64_t *)gpr_ptr = (uint64_t)v;
@@ -329,7 +313,7 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                     return env.Null();
                 }
 
-                float f = CopyNodeNumber<float>(value);
+                float f = CopyNumber<float>(value);
 
                 if (RG_LIKELY(param.vec_count)) {
                     memcpy(vec_ptr++, &f, 4);
@@ -345,7 +329,7 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                     return env.Null();
                 }
 
-                double d = CopyNodeNumber<double>(value);
+                double d = CopyNumber<double>(value);
 
                 if (RG_LIKELY(param.vec_count)) {
                     memcpy(vec_ptr, &d, 8);
@@ -357,13 +341,18 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                 }
             } break;
             case PrimitiveKind::String: {
-                if (RG_UNLIKELY(!value.IsString())) {
+                const char *str;
+                if (RG_LIKELY(value.IsString())) {
+                    str = call.PushString(value);
+                    if (RG_UNLIKELY(!str))
+                        return env.Null();
+                } else if (IsNullOrUndefined(value)) {
+                    str = nullptr;
+                } else {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected string", GetValueType(instance, value), i + 1);
                     return env.Null();
                 }
 
-                const char *str = CopyNodeString(value, &lib->tmp_alloc);
-
                 if (RG_LIKELY(param.gpr_count)) {
                     *(gpr_ptr++) = (uint64_t)str;
                 } else {
@@ -373,13 +362,29 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                 }
             } break;
             case PrimitiveKind::Pointer: {
-                if (RG_UNLIKELY(!CheckValueTag(instance, value, param.type))) {
+                uint8_t *ptr;
+
+                if (CheckValueTag(instance, value, param.type)) {
+                    ptr = value.As<Napi::External<uint8_t>>().Data();
+                } else if (IsObject(value) && param.type->ref->primitive == PrimitiveKind::Record) {
+                    Napi::Object obj = value.As<Napi::Object>();
+
+                    if (RG_UNLIKELY(!call.AllocHeap(param.type->ref->size, 16, &ptr)))
+                        return env.Null();
+
+                    if ((param.directions & 1) && !call.PushObject(obj, param.type->ref, ptr))
+                        return env.Null();
+                    if (param.directions & 2) {
+                        OutObject out = {obj, ptr, param.type->ref};
+                        out_objects.Append(out);
+                    }
+                } else if (IsNullOrUndefined(value)) {
+                    ptr = nullptr;
+                } else {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected %3", GetValueType(instance, value), i + 1, param.type->name);
                     return env.Null();
                 }
 
-                void *ptr = value.As<Napi::External<void>>();
-
                 if (RG_LIKELY(param.gpr_count)) {
                     *(gpr_ptr++) = (uint64_t)ptr;
                 } else {
@@ -390,7 +395,7 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
             } break;
 
             case PrimitiveKind::Record: {
-                if (RG_UNLIKELY(!value.IsObject())) {
+                if (RG_UNLIKELY(!IsObject(value))) {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected object", GetValueType(instance, value), i + 1);
                     return env.Null();
                 }
@@ -405,16 +410,16 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                     if (param.gpr_count) {
                         RG_ASSERT(param.type->align <= 8);
 
-                        if (!PushObject(obj, param.type, &lib->tmp_alloc, (uint8_t *)gpr_ptr))
+                        if (!call.PushObject(obj, param.type, (uint8_t *)gpr_ptr))
                             return env.Null();
 
-                        args_ptr += AlignLen(param.type->size - param.gpr_count * 4, 4);
                         gpr_ptr += param.gpr_count;
+                        args_ptr += AlignLen(param.type->size - param.gpr_count * 4, 4);
                     } else if (param.type->size) {
                         int16_t align = (param.type->align <= 4) ? 4 : 8;
 
                         args_ptr = AlignUp(args_ptr, align);
-                        if (!PushObject(obj, param.type, &lib->tmp_alloc, args_ptr))
+                        if (!call.PushObject(obj, param.type, args_ptr))
                             return env.Null();
                         args_ptr += AlignLen(param.type->size, 4);
                     }
@@ -423,11 +428,17 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
         }
     }
 
-    // DumpStack(func, MakeSpan(sp_ptr, top_ptr - sp_ptr));
+    if (instance->debug) {
+        call.DumpDebug();
+    }
 
 #define PERFORM_CALL(Suffix) \
-        (func->forward_fp ? ForwardCallX ## Suffix(func->func, sp_ptr) \
-                          : ForwardCall ## Suffix(func->func, sp_ptr))
+        ([&]() { \
+            auto ret = (func->forward_fp ? ForwardCallX ## Suffix(func->func, call.GetSP()) \
+                                         : ForwardCall ## Suffix(func->func, call.GetSP())); \
+            PopOutArguments(out_objects); \
+            return ret; \
+        })()
 
     // Execute and convert return value
     switch (func->ret.type->primitive) {