koffi 0.9.28 → 0.9.31

package/package.json

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

package/src/call_arm32.cc

@@ -63,8 +63,9 @@ Napi::Function::Callback 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);
-    } else if (func->ret.type->primitive != PrimitiveKind::Record) {
-        func->ret.gpr_count = (func->ret.type->size >= 4) ? 2 : 1;
+    } else if (func->ret.type->primitive != PrimitiveKind::Record ||
+               func->ret.type->size <= 4) {
+        func->ret.gpr_count = (func->ret.type->size > 4) ? 2 : 1;
     } else {
         func->ret.use_memory = true;
     }
@@ -230,19 +231,21 @@ static Napi::Value TranslateCall(const Napi::CallbackInfo &info)
     uint32_t *gpr_ptr = nullptr;
     uint32_t *vec_ptr = nullptr;
 
-    // Return through registers unless it's too big
+    // Unlike other call conventions, here we put the general-purpose
+    // registers just before the stack (so behind the vector ones).
+    // In the armv7hf calling convention, some arguments can end up
+    // partially in GPR, partially in the stack.
     if (RG_UNLIKELY(!call.AllocStack(func->args_size, 16, &args_ptr)))
         return env.Null();
-    if (RG_UNLIKELY(!call.AllocStack(8 * 8, 8, &vec_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);
 
     LocalArray<OutObject, MaxOutParameters> out_objects;
 
@@ -455,6 +458,8 @@ static Napi::Value TranslateCall(const Napi::CallbackInfo &info)
 
         case PrimitiveKind::Record: {
             if (func->ret.gpr_count) {
+                RG_ASSERT(func->ret.gpr_count <= 1);
+
                 uint64_t ret = PERFORM_CALL(GG);
                 uint32_t r0 = (uint32_t)ret;
 
@@ -469,8 +474,8 @@ static Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                 RG_ASSERT(return_ptr);
 
                 uint64_t ret = PERFORM_CALL(GG);
-                uint64_t r0 = (uint32_t)ret;
-                RG_ASSERT(r0 == (uint64_t)return_ptr);
+                uint32_t r0 = (uint32_t)ret;
+                RG_ASSERT(r0 == (uint32_t)return_ptr);
 
                 Napi::Object obj = PopObject(env, return_ptr, func->ret.type);
                 return obj;

package/src/call_arm32_fwd.S

@@ -56,22 +56,22 @@
 
 // Prepare general purpose argument registers from array passed by caller.
 .macro forward_int
-    ldr r3, [r1, 12]
-    ldr r2, [r1, 8]
-    ldr r0, [r1, 0]
-    ldr r1, [r1, 4]
+    ldr r3, [r1, 76]
+    ldr r2, [r1, 72]
+    ldr r0, [r1, 64]
+    ldr r1, [r1, 68]
 .endm
 
 // Prepare vector argument registers from array passed by caller.
 .macro forward_vec
-    vldr d7, [r1, 72]
-    vldr d6, [r1, 64]
-    vldr d5, [r1, 56]
-    vldr d4, [r1, 48]
-    vldr d3, [r1, 40]
-    vldr d2, [r1, 32]
-    vldr d1, [r1, 24]
-    vldr d0, [r1, 16]
+    vldr d7, [r1, 56]
+    vldr d6, [r1, 48]
+    vldr d5, [r1, 40]
+    vldr d4, [r1, 32]
+    vldr d3, [r1, 24]
+    vldr d2, [r1, 16]
+    vldr d1, [r1, 8]
+    vldr d0, [r1, 0]
 .endm
 
 ForwardCallGG:

package/src/call_x86.cc

@@ -31,21 +31,37 @@ extern "C" double ForwardCallRD(const void *func, uint8_t *sp);
 
 static Napi::Value TranslateCall(const Napi::CallbackInfo &info);
 
+static inline bool IsRegular(Size size)
+{
+    bool regular = (size <= 8 && !(size & (size - 1)));
+    return regular;
+}
+
 Napi::Function::Callback AnalyseFunction(InstanceData *instance, FunctionInfo *func)
 {
-    if (IsIntegral(func->ret.type->primitive)) {
-        func->ret.trivial = true;
-    } else if (func->ret.type->members.len == 1 && IsIntegral(func->ret.type->members[0].type->primitive)) {
+    int fast = (func->convention == CallConvention::Fastcall) ? 2 : 0;
+
+    if (func->ret.type->primitive != PrimitiveKind::Record) {
         func->ret.trivial = true;
 #ifdef _WIN32
-    } else if (func->ret.type->members.len == 2 && IsIntegral(func->ret.type->members[0].type->primitive)
-                                                && IsIntegral(func->ret.type->members[1].type->primitive)) {
-        func->ret.trivial = true;
+    } else {
+        func->ret.trivial = IsRegular(func->ret.type->size);
 #endif
     }
+#ifndef _WIN32
+    if (fast && !func->ret.trivial) {
+        func->ret.fast = true;
+        fast--;
+    }
+#endif
 
     Size params_size = 0;
-    for (const ParameterInfo &param: func->parameters) {
+    for (ParameterInfo &param: func->parameters) {
+        if (fast && param.type->size <= 4) {
+            param.fast = true;
+            fast--;
+        }
+
         params_size += std::max((int16_t)4, param.type->size);
     }
     func->args_size = params_size + 4 * !func->ret.trivial;
@@ -57,7 +73,7 @@ Napi::Function::Callback AnalyseFunction(InstanceData *instance, FunctionInfo *f
         } break;
         case CallConvention::Fastcall: {
             func->decorated_name = Fmt(&instance->str_alloc, "@%1@%2", func->name, params_size).ptr;
-            func->args_size = std::max((Size)8, func->args_size);
+            func->args_size += 16;
         } break;
     }
 
@@ -80,14 +96,19 @@ static Napi::Value TranslateCall(const Napi::CallbackInfo &info)
 
     uint8_t *return_ptr = nullptr;
     uint32_t *args_ptr = nullptr;
+    uint32_t *fast_ptr = nullptr;
 
     // Pass return value in register or through memory
     if (RG_UNLIKELY(!call.AllocStack(func->args_size, 16, &args_ptr)))
         return env.Null();
+    if (func->convention == CallConvention::Fastcall) {
+        fast_ptr = args_ptr;
+        args_ptr += 4;
+    }
     if (!func->ret.trivial) {
         if (RG_UNLIKELY(!call.AllocHeap(func->ret.type->size, 16, &return_ptr)))
             return env.Null();
-        *(args_ptr++) = (uint32_t)return_ptr;
+        *((func->ret.fast ? fast_ptr : args_ptr)++) = (uint32_t)return_ptr;
     }
 
     LocalArray<OutObject, MaxOutParameters> out_objects;
@@ -109,7 +130,7 @@ static Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                 }
 
                 bool b = value.As<Napi::Boolean>();
-                *(bool *)(args_ptr++) = b;
+                *(bool *)((param.fast ? fast_ptr : args_ptr)++) = b;
             } break;
             case PrimitiveKind::Int8:
             case PrimitiveKind::UInt8:
@@ -123,7 +144,7 @@ static Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                 }
 
                 int32_t v = CopyNumber<int32_t>(value);
-                *(args_ptr++) = (uint32_t)v;
+                *((param.fast ? fast_ptr : args_ptr)++) = (uint32_t)v;
             } break;
             case PrimitiveKind::Int64:
             case PrimitiveKind::UInt64: {
@@ -143,7 +164,7 @@ static Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                 }
 
                 float f = CopyNumber<float>(value);
-                *(float *)(args_ptr++) = f;
+                *(float *)((param.fast ? fast_ptr : args_ptr)++) = f;
             } break;
             case PrimitiveKind::Float64: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
@@ -168,7 +189,7 @@ static Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                     return env.Null();
                 }
 
-                *(const char **)(args_ptr++) = str;
+                *(const char **)((param.fast ? fast_ptr : args_ptr)++) = str;
             } break;
             case PrimitiveKind::Pointer: {
                 uint8_t *ptr;
@@ -194,7 +215,7 @@ static Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                     return env.Null();
                 }
 
-                *(uint8_t **)(args_ptr++) = ptr;
+                *(uint8_t **)((param.fast ? fast_ptr : args_ptr)++) = ptr;
             } break;
 
             case PrimitiveKind::Record: {
@@ -205,10 +226,16 @@ static Napi::Value TranslateCall(const Napi::CallbackInfo &info)
 
                 Napi::Object obj = value.As<Napi::Object>();
 
-                uint8_t *ptr = (uint8_t *)AlignUp(args_ptr, param.type->align);
-                if (!call.PushObject(obj, param.type, ptr))
-                    return env.Null();
-                args_ptr = (uint32_t *)AlignUp(ptr + param.type->size, 4);
+                if (param.fast) {
+                    uint8_t *ptr = (uint8_t *)(fast_ptr++);
+                    if (!call.PushObject(obj, param.type, ptr))
+                        return env.Null();
+                } else {
+                    uint8_t *ptr = (uint8_t *)AlignUp(args_ptr, param.type->align);
+                    if (!call.PushObject(obj, param.type, ptr))
+                        return env.Null();
+                    args_ptr = (uint32_t *)AlignUp(ptr + param.type->size, 4);
+                }
             } break;
         }
     }

package/src/call_x86_fwd.S

@@ -35,7 +35,7 @@
 .macro fastcall
     movl 0(%esp), %ecx
     movl 4(%esp), %edx
-    add $8, %esp
+    addl $16, %esp
 .endm
 
 // Call native function.

package/src/call_x86_fwd.asm

@@ -34,7 +34,7 @@ endm
 fastcall macro
     mov ecx, dword ptr [esp+0]
     mov edx, dword ptr [esp+4]
-    add esp, 8
+    add esp, 16
 endm
 
 ; Call native function.

package/src/ffi.cc

@@ -75,20 +75,23 @@ static const TypeInfo *ResolveType(const InstanceData *instance, Napi::Value val
     }
 }
 
-static Napi::Value CreateStructType(const Napi::CallbackInfo &info)
+static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
 {
     Napi::Env env = info.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
-    if (info.Length() < 2) {
-        ThrowError<Napi::TypeError>(env, "Expected 2 arguments, got %1", info.Length());
+    if (info.Length() < 1) {
+        ThrowError<Napi::TypeError>(env, "Expected 1 or 2 arguments, got %1", info.Length());
         return env.Null();
     }
-    if (!info[0].IsString()) {
+
+    bool named = info.Length() > 1;
+
+    if (named && !info[0].IsString()) {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string", GetValueType(instance, info[0]));
         return env.Null();
     }
-    if (!IsObject(info[1])) {
+    if (!IsObject(info[named])) {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for members, expected object", GetValueType(instance, info[1]));
         return env.Null();
     }
@@ -96,8 +99,8 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info)
     TypeInfo *type = instance->types.AppendDefault();
     RG_DEFER_N(err_guard) { instance->types.RemoveLast(1); };
 
-    std::string name = info[0].As<Napi::String>();
-    Napi::Object obj = info[1].As<Napi::Object>();
+    std::string name = named ? info[0].As<Napi::String>() : std::string("<anonymous>");
+    Napi::Object obj = info[named].As<Napi::Object>();
     Napi::Array keys = obj.GetPropertyNames();
 
     type->name = DuplicateString(name.c_str(), &instance->str_alloc).ptr;
@@ -116,8 +119,10 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info)
         if (!member.type)
             return env.Null();
 
-        type->size = (int16_t)(AlignLen(type->size, member.type->align) + member.type->size);
-        type->align = std::max(type->align, member.type->align);
+        member.align = pad ? member.type->align : 1;
+
+        type->size = (int16_t)(AlignLen(type->size, member.align) + member.type->size);
+        type->align = std::max(type->align, member.align);
 
         type->members.Append(member);
     }
@@ -125,7 +130,7 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info)
     type->size = (int16_t)AlignLen(type->size, type->align);
 
     // If the insert succeeds, we cannot fail anymore
-    if (!instance->types_map.TrySet(type).second) {
+    if (named && !instance->types_map.TrySet(type).second) {
         ThrowError<Napi::Error>(env, "Duplicate type name '%1'", type->name);
         return env.Null();
     }
@@ -137,6 +142,16 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info)
     return external;
 }
 
+static Napi::Value CreatePaddedStructType(const Napi::CallbackInfo &info)
+{
+    return CreateStructType(info, true);
+}
+
+static Napi::Value CreatePackedStructType(const Napi::CallbackInfo &info)
+{
+    return CreateStructType(info, false);
+}
+
 static Napi::Value CreateHandleType(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
@@ -159,7 +174,7 @@ static Napi::Value CreateHandleType(const Napi::CallbackInfo &info)
     type->name = DuplicateString(name.c_str(), &instance->str_alloc).ptr;
 
     type->primitive = PrimitiveKind::Record;
-    type->align = RG_SIZE(void *);
+    type->align = alignof(void *);
     type->size = RG_SIZE(void *);
 
     // Add single handle member
@@ -169,6 +184,7 @@ static Napi::Value CreateHandleType(const Napi::CallbackInfo &info)
         member.name = "value";
         member.type = instance->types_map.FindValue("void *", nullptr);
         RG_ASSERT(member.type);
+        member.align = type->align;
 
         type->members.Append(member);
     }
@@ -552,19 +568,28 @@ FunctionInfo::~FunctionInfo()
     }
 }
 
-InstanceData::InstanceData()
+static Span<uint8_t> AllocateAndAlign16(Allocator *alloc, Size size)
 {
-    stack_mem.len = Mebibytes(2);
-    stack_mem.ptr = (uint8_t *)Allocator::Allocate(&mem_alloc, stack_mem.len);
+    RG_ASSERT(AlignLen(size, 16) == size);
+
+    uint8_t *ptr = (uint8_t *)Allocator::Allocate(alloc, size);
+    uint8_t *aligned = AlignUp(ptr, 16);
+    Size delta = AlignLen(aligned - ptr, 16);
 
-    heap_mem.len = Mebibytes(4);
-    heap_mem.ptr = (uint8_t *)Allocator::Allocate(&mem_alloc, heap_mem.len);
+    return MakeSpan(aligned, size - delta);
+}
+
+InstanceData::InstanceData()
+{
+    stack_mem = AllocateAndAlign16(&mem_alloc, Mebibytes(2));
+    heap_mem = AllocateAndAlign16(&mem_alloc, Mebibytes(4));
 }
 
 template <typename Func>
 static void SetExports(Napi::Env env, Func func)
 {
-    func("struct", Napi::Function::New(env, CreateStructType));
+    func("struct", Napi::Function::New(env, CreatePaddedStructType));
+    func("pack", Napi::Function::New(env, CreatePackedStructType));
     func("handle", Napi::Function::New(env, CreateHandleType));
     func("pointer", Napi::Function::New(env, CreatePointerType));
     func("load", Napi::Function::New(env, LoadSharedLibrary));

package/src/ffi.hh

@@ -63,12 +63,6 @@ static const char *const PrimitiveKindNames[] = {
     "Record"
 };
 
-static inline bool IsIntegral(PrimitiveKind primitive)
-{
-    bool integral = ((int)primitive <= (int)PrimitiveKind::Pointer);
-    return integral;
-}
-
 struct TypeInfo;
 struct RecordMember;
 
@@ -89,6 +83,7 @@ struct TypeInfo {
 struct RecordMember {
     const char *name;
     const TypeInfo *type;
+    int16_t align;
 };
 
 struct LibraryHolder {
@@ -107,6 +102,11 @@ enum class CallConvention {
     Stdcall,
     Fastcall
 };
+static const char *const CallConventionNames[] = {
+    "Default",
+    "Stdcall",
+    "Fastcall"
+};
 
 struct ParameterInfo {
     const TypeInfo *type;
@@ -127,6 +127,7 @@ struct ParameterInfo {
     int8_t vec_count;
 #elif defined(__i386__) || defined(_M_IX86)
     bool trivial; // Only matters for return value
+    bool fast;
 #endif
 };
 

package/src/util.cc

@@ -81,36 +81,34 @@ const char *CallData::PushString(const Napi::Value &value)
 {
     RG_ASSERT(value.IsString());
 
-    const Size SmallSize = 32;
-
     Napi::Env env = value.Env();
-    napi_status status;
 
     Span<char> buf;
     size_t len = 0;
+    napi_status status;
 
-    // Optimize for small strings
-    buf.len = SmallSize;
-    if (RG_UNLIKELY(!AllocHeap(buf.len, 1, &buf.ptr)))
-        return nullptr;
-    if (RG_UNLIKELY(napi_get_value_string_utf8(env, value, buf.ptr, (size_t)buf.len, &len) != napi_ok)) {
-        ThrowError<Napi::Error>(env, "Failed to convert string to UTF-8");
-        return nullptr;
-    }
+    buf.ptr = (char *)heap_mem->ptr;
+    buf.len = std::max((Size)0, heap_mem->len - Kibibytes(32));
+
+    status = napi_get_value_string_utf8(env, value, buf.ptr, (size_t)buf.len, &len);
+    RG_ASSERT(status == napi_ok);
 
-    // Slow path for bigger strings
-    if (len >= SmallSize - 1) {
+    len++;
+
+    if (RG_LIKELY(len < (size_t)buf.len)) {
+        heap_mem->ptr += (Size)len;
+        heap_mem->len -= (Size)len;
+    } else {
         status = napi_get_value_string_utf8(env, value, nullptr, 0, &len);
         RG_ASSERT(status == napi_ok);
-        RG_ASSERT(len >= SmallSize);
-
-        buf.len = (Size)len + 1;
-        if (RG_UNLIKELY(!AllocHeap(buf.len - SmallSize, 1)))
-            return nullptr;
-        if (RG_UNLIKELY(napi_get_value_string_utf8(env, value, buf.ptr, (size_t)buf.len, &len) != napi_ok)) {
-            ThrowError<Napi::Error>(env, "Failed to convert string to UTF-8");
-            return nullptr;
-        }
+
+        len++;
+
+        buf.ptr = (char *)Allocator::Allocate(&big_alloc, (Size)len);
+        buf.len = (Size)len;
+
+        status = napi_get_value_string_utf8(env, value, buf.ptr, (size_t)buf.len, &len);
+        RG_ASSERT(status == napi_ok);
     }
 
     return buf.ptr;
@@ -132,7 +130,7 @@ bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t
             return false;
         }
 
-        dest = AlignUp(dest, member.type->align);
+        dest = AlignUp(dest, member.align);
 
         switch (member.type->primitive) {
             case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
@@ -229,7 +227,7 @@ void PopObject(Napi::Object obj, const uint8_t *ptr, const TypeInfo *type)
     RG_ASSERT(type->primitive == PrimitiveKind::Record);
 
     for (const RecordMember &member: type->members) {
-        ptr = AlignUp(ptr, member.type->align);
+        ptr = AlignUp(ptr, member.align);
 
         switch (member.type->primitive) {
             case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
@@ -329,7 +327,7 @@ static void DumpMemory(const char *type, Span<const uint8_t> bytes)
 
 void CallData::DumpDebug() const
 {
-    PrintLn(stderr, "%!..+---- %1 ----%!0", func->name);
+    PrintLn(stderr, "%!..+---- %1 (%2) ----%!0", func->name, CallConventionNames[(int)func->convention]);
 
     if (func->parameters.len) {
         PrintLn(stderr, "Parameters:");

package/src/util.hh

@@ -74,6 +74,7 @@ class CallData {
 
     Span<uint8_t> *stack_mem;
     Span<uint8_t> *heap_mem;
+    BlockAllocator big_alloc;
 
     Span<uint8_t> old_stack_mem;
     Span<uint8_t> old_heap_mem;

package/test/test.js

@@ -276,7 +276,7 @@ async function test() {
                basename !== 'node_modules' &&
                basename !== 'node' &&
                basename !== 'build' &&
-               basename !== 'luigi';
+               basename !== 'luiggi';
     });
 
     success &= await start(false);

package/test/tests/misc.c

@@ -11,8 +11,10 @@
 // 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>
 
 #ifdef _WIN32
     #define EXPORT __declspec(dllexport)
@@ -32,6 +34,13 @@
     #define STDCALL
 #endif
 
+typedef struct Pack1 {
+    int a;
+} Pack1;
+typedef struct Pack2 {
+    int a;
+    int b;
+} Pack2;
 typedef struct Pack3 {
     int a;
     int b;
@@ -53,6 +62,60 @@ typedef struct BFG {
         double g;
     } inner;
 } BFG;
+#pragma pack(push, 1)
+typedef struct PackedBFG {
+    int8_t a;
+    int64_t b;
+    signed char c;
+    const char *d;
+    short e;
+    struct {
+        float f;
+        double g;
+    } inner;
+} PackedBFG;
+#pragma pack(pop)
+
+EXPORT void FillPack1(int a, Pack1 *p)
+{
+    p->a = a;
+}
+
+EXPORT Pack1 RetPack1(int a)
+{
+    Pack1 p;
+
+    p.a = a;
+
+    return p;
+}
+
+EXPORT void FASTCALL AddPack1(int a, Pack1 *p)
+{
+    p->a += a;
+}
+
+EXPORT void FillPack2(int a, int b, Pack2 *p)
+{
+    p->a = a;
+    p->b = b;
+}
+
+EXPORT Pack2 RetPack2(int a, int b)
+{
+    Pack2 p;
+
+    p.a = a;
+    p.b = b;
+
+    return p;
+}
+
+EXPORT void FASTCALL AddPack2(int a, int b, Pack2 *p)
+{
+    p->a += a;
+    p->b += b;
+}
 
 EXPORT void FillPack3(int a, int b, int c, Pack3 *p)
 {
@@ -64,7 +127,7 @@ EXPORT void FillPack3(int a, int b, int c, Pack3 *p)
 EXPORT Pack3 RetPack3(int a, int b, int c)
 {
     Pack3 p;
-    
+
     p.a = a;
     p.b = b;
     p.c = c;
@@ -135,14 +198,17 @@ EXPORT const char *ConcatenateToStr8(int64_t a, int64_t b, int64_t c, int64_t d,
     return buf;
 }
 
-EXPORT BFG STDCALL MakeBFG(int x, double y, BFG *p)
+EXPORT BFG STDCALL MakeBFG(BFG *p, int x, double y, const char *str)
 {
     BFG bfg;
 
+    char buf[64];
+    snprintf(buf, sizeof(buf), "X/%s/X", str);
+
     bfg.a = x;
     bfg.b = x * 2;
     bfg.c = x - 27;
-    bfg.d = "Hello";
+    bfg.d = buf;
     bfg.e = x * 27;
     bfg.inner.f = (float)y * x;
     bfg.inner.g = (double)y - x;
@@ -150,3 +216,32 @@ EXPORT BFG STDCALL MakeBFG(int x, double y, BFG *p)
 
     return bfg;
 }
+
+EXPORT PackedBFG FASTCALL MakePackedBFG(int x, double y, PackedBFG *p, const char *str)
+{
+    PackedBFG bfg;
+
+    char buf[64];
+    snprintf(buf, sizeof(buf), "X/%s/X", str);
+
+    bfg.a = x;
+    bfg.b = x * 2;
+    bfg.c = x - 27;
+    bfg.d = buf;
+    bfg.e = x * 27;
+    bfg.inner.f = (float)y * x;
+    bfg.inner.g = (double)y - x;
+    *p = bfg;
+
+    return bfg;
+}
+
+EXPORT const char *ReturnBigString(const char *str)
+{
+    static char buf[16 * 1024 * 1024];
+
+    size_t len = strlen(str);
+    memcpy(buf, str, len + 1);
+
+    return buf;
+}

package/test/tests/misc.js

@@ -17,6 +17,13 @@ const koffi = require('../build/koffi.node');
 const assert = require('assert');
 const path = require('path');
 
+const Pack1 = koffi.struct('Pack1', {
+    a: 'int'
+});
+const Pack2 = koffi.struct('Pack2', {
+    a: 'int',
+    b: 'int'
+});
 const Pack3 = koffi.struct('Pack3', {
     a: 'int',
     b: 'int',
@@ -29,7 +36,18 @@ const BFG = koffi.struct('BFG', {
     c: 'char',
     d: 'string',
     e: 'short',
-    inner: koffi.struct('BFG.inner', {
+    inner: koffi.struct({
+        f: 'float',
+        g: 'double'
+    })
+});
+const PackedBFG = koffi.pack('PackedBFG', {
+    a: 'int8_t',
+    b: 'int64_t',
+    c: 'char',
+    d: 'string',
+    e: 'short',
+    inner: koffi.pack({
         f: 'float',
         g: 'double'
     })
@@ -51,6 +69,12 @@ async function test() {
     let lib_filename = path.dirname(__filename) + '/../build/misc' + koffi.extension;
     let lib = koffi.load(lib_filename);
 
+    const FillPack1 = lib.cdecl('FillPack1', 'void', ['int', koffi.out(koffi.pointer(Pack1))]);
+    const RetPack1 = lib.cdecl('RetPack1', Pack1, ['int']);
+    const AddPack1 = lib.fastcall('AddPack1', 'void', ['int', koffi.inout(koffi.pointer(Pack1))]);
+    const FillPack2 = lib.cdecl('FillPack2', 'void', ['int', 'int', koffi.out(koffi.pointer(Pack2))]);
+    const RetPack2 = lib.cdecl('RetPack2', Pack2, ['int', 'int']);
+    const AddPack2 = lib.fastcall('AddPack2', 'void', ['int', 'int', koffi.inout(koffi.pointer(Pack2))]);
     const FillPack3 = lib.cdecl('FillPack3', 'void', ['int', 'int', 'int', koffi.out(koffi.pointer(Pack3))]);
     const RetPack3 = lib.cdecl('RetPack3', Pack3, ['int', 'int', 'int']);
     const AddPack3 = lib.fastcall('AddPack3', 'void', ['int', 'int', 'int', koffi.inout(koffi.pointer(Pack3))]);
@@ -60,28 +84,81 @@ async function test() {
     const ConcatenateToStr1 = lib.cdecl('ConcatenateToStr1', 'string', [...Array(8).fill('int8_t'), koffi.struct('IJK1', {i: 'int8_t', j: 'int8_t', k: 'int8_t'}), 'int8_t']);
     const ConcatenateToStr4 = lib.cdecl('ConcatenateToStr4', 'string', [...Array(8).fill('int32_t'), koffi.pointer(koffi.struct('IJK4', {i: 'int32_t', j: 'int32_t', k: 'int32_t'})), 'int32_t']);
     const ConcatenateToStr8 = lib.cdecl('ConcatenateToStr8', 'string', [...Array(8).fill('int64_t'), koffi.struct('IJK8', {i: 'int64_t', j: 'int64_t', k: 'int64_t'}), 'int64_t']);
-    const MakeBFG = lib.stdcall('MakeBFG', BFG, ['int', 'double', koffi.out(koffi.pointer(BFG))]);
+    const MakeBFG = lib.stdcall('MakeBFG', BFG, [koffi.out(koffi.pointer(BFG)), 'int', 'double', 'string']);
+    const MakePackedBFG = lib.fastcall('MakePackedBFG', PackedBFG, ['int', 'double', koffi.out(koffi.pointer(PackedBFG)), 'string']);
+    const ReturnBigString = lib.stdcall('ReturnBigString', 'string', ['string']);
 
-    let p = {};
+    // Simple tests with Pack1
+    {
+        let p = {};
 
-    FillPack3(1, 2, 3, p);
-    assert.deepEqual(p, { a: 1, b: 2, c: 3 });
+        FillPack1(777, p);
+        assert.deepEqual(p, { a: 777 });
+
+        let q = RetPack1(6);
+        assert.deepEqual(q, { a: 6 });
+
+        AddPack1(6, p);
+        assert.deepEqual(p, { a: 783 });
+    }
 
-    let q = RetPack3(6, 9, -12);
-    assert.deepEqual(q, { a: 6, b: 9, c: -12 });
+    // Simple tests with Pack2
+    {
+        let p = {};
 
-    AddPack3(6, 9, -12, p);
-    assert.deepEqual(p, { a: 7, b: 11, c: -9 });
+        FillPack2(123, 456, p);
+        assert.deepEqual(p, { a: 123, b: 456 });
 
-    assert.equal(ConcatenateToInt1(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687n);
-    assert.equal(ConcatenateToInt4(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687n);
-    assert.equal(ConcatenateToInt8(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687n);
-    assert.equal(ConcatenateToStr1(5, 6, 1, 2, 3, 9, 4, 4, {i: 0, j: 6, k: 8}, 7), '561239440687');
-    assert.equal(ConcatenateToStr4(5, 6, 1, 2, 3, 9, 4, 4, {i: 0, j: 6, k: 8}, 7), '561239440687');
-    assert.equal(ConcatenateToStr8(5, 6, 1, 2, 3, 9, 4, 4, {i: 0, j: 6, k: 8}, 7), '561239440687');
+        let q = RetPack2(6, 9);
+        assert.deepEqual(q, { a: 6, b: 9 });
 
-    let out = {};
-    let bfg = MakeBFG(2, 7, out);
-    assert.deepEqual(bfg, { a: 2, b: 4, c: -25, d: 'Hello', e: 54, inner: { f: 14, g: 5 } });
-    assert.deepEqual(out, bfg);
+        AddPack2(6, 9, p);
+        assert.deepEqual(p, { a: 129, b: 465 });
+    }
+
+    // Simple tests with Pack3
+    {
+        let p = {};
+
+        FillPack3(1, 2, 3, p);
+        assert.deepEqual(p, { a: 1, b: 2, c: 3 });
+
+        let q = RetPack3(6, 9, -12);
+        assert.deepEqual(q, { a: 6, b: 9, c: -12 });
+
+        AddPack3(6, 9, -12, p);
+        assert.deepEqual(p, { a: 7, b: 11, c: -9 });
+    }
+
+    // Many parameters
+    {
+        assert.equal(ConcatenateToInt1(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687n);
+        assert.equal(ConcatenateToInt4(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687n);
+        assert.equal(ConcatenateToInt8(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687n);
+        assert.equal(ConcatenateToStr1(5, 6, 1, 2, 3, 9, 4, 4, {i: 0, j: 6, k: 8}, 7), '561239440687');
+        assert.equal(ConcatenateToStr4(5, 6, 1, 2, 3, 9, 4, 4, {i: 0, j: 6, k: 8}, 7), '561239440687');
+        assert.equal(ConcatenateToStr8(5, 6, 1, 2, 3, 9, 4, 4, {i: 0, j: 6, k: 8}, 7), '561239440687');
+    }
+
+    // Big struct
+    {
+        let out = {};
+        let bfg = MakeBFG(out, 2, 7, '__Hello123456789++++foobarFOOBAR!__');
+        assert.deepEqual(bfg, { a: 2, b: 4, c: -25, d: 'X/__Hello123456789++++foobarFOOBAR!__/X', e: 54, inner: { f: 14, g: 5 } });
+        assert.deepEqual(out, bfg);
+    }
+
+    // Packed struct
+    {
+        let out = {};
+        let bfg = MakePackedBFG(2, 7, out, '__Hello123456789++++foobarFOOBAR!__');
+        assert.deepEqual(bfg, { a: 2, b: 4, c: -25, d: 'X/__Hello123456789++++foobarFOOBAR!__/X', e: 54, inner: { f: 14, g: 5 } });
+        assert.deepEqual(out, bfg);
+    }
+
+    // Big string
+    {
+        let str = 'fooBAR!'.repeat(1024 * 1024);
+        assert.equal(ReturnBigString(str), str);
+    }
 }