koffi 0.9.30 → 0.9.33

package/package.json

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

package/src/call.hh

@@ -22,6 +22,7 @@ namespace RG {
 struct InstanceData;
 struct FunctionInfo;
 
-Napi::Function::Callback AnalyseFunction(InstanceData *instance, FunctionInfo *func);
+bool AnalyseFunction(InstanceData *instance, FunctionInfo *func);
+Napi::Value TranslateCall(InstanceData *instance, const FunctionInfo *func, const Napi::CallbackInfo &info);
 
 }

package/src/call_arm32.cc

@@ -37,8 +37,6 @@ 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 Napi::Value TranslateCall(const Napi::CallbackInfo &info);
-
 static bool IsHFA(const TypeInfo *type)
 {
     if (type->primitive != PrimitiveKind::Record)
@@ -58,13 +56,14 @@ static bool IsHFA(const TypeInfo *type)
     return true;
 }
 
-Napi::Function::Callback AnalyseFunction(InstanceData *, FunctionInfo *func)
+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);
-    } 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;
     }
@@ -108,11 +107,20 @@ Napi::Function::Callback AnalyseFunction(InstanceData *, FunctionInfo *func)
             case PrimitiveKind::Float64: {
                 Size need = param.type->size / 4;
 
-                if (need <= vec_avail) {
-                    param.vec_count = need;
-                    vec_avail -= need;
+                if (param.variadic) {
+                    if (need <= gpr_avail) {
+                        param.gpr_count = need;
+                        gpr_avail -= need;
+                    } else {
+                        started_stack = true;
+                    }
                 } else {
-                    started_stack = true;
+                    if (need <= vec_avail) {
+                        param.vec_count = need;
+                        vec_avail -= need;
+                    } else {
+                        started_stack = true;
+                    }
                 }
             } break;
 
@@ -149,7 +157,7 @@ Napi::Function::Callback AnalyseFunction(InstanceData *, FunctionInfo *func)
 
     func->forward_fp = (vec_avail < 16);
 
-    return TranslateCall;
+    return true;
 }
 
 static bool PushHFA(const Napi::Object &obj, const TypeInfo *type, uint8_t *dest)
@@ -211,12 +219,9 @@ static Napi::Object PopHFA(napi_env env, const uint8_t *ptr, const TypeInfo *typ
     return obj;
 }
 
-static Napi::Value TranslateCall(const Napi::CallbackInfo &info)
+Napi::Value TranslateCall(InstanceData *instance, const FunctionInfo *func, const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
-    FunctionInfo *func = (FunctionInfo *)info.Data();
-
     CallData call(env, instance, func);
 
     // Sanity checks
@@ -253,7 +258,7 @@ static Napi::Value TranslateCall(const Napi::CallbackInfo &info)
         const ParameterInfo &param = func->parameters[i];
         RG_ASSERT(param.directions >= 1 && param.directions <= 3);
 
-        Napi::Value value = info[i];
+        Napi::Value value = info[param.offset];
 
         switch (param.type->primitive) {
             case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
@@ -321,6 +326,8 @@ static Napi::Value TranslateCall(const Napi::CallbackInfo &info)
 
                 if (RG_LIKELY(param.vec_count)) {
                     memcpy(vec_ptr++, &f, 4);
+                } else if (param.gpr_count) {
+                    memcpy(gpr_ptr++, &f, 4);
                 } else {
                     memcpy(args_ptr, &f, 4);
                     args_ptr += 4;
@@ -337,6 +344,9 @@ static Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                 if (RG_LIKELY(param.vec_count)) {
                     memcpy(vec_ptr, &d, 8);
                     vec_ptr += 2;
+                } else if (param.gpr_count) {
+                    memcpy(gpr_ptr, &d, 8);
+                    gpr_ptr += 2;
                 } else {
                     args_ptr = AlignUp(args_ptr, 8);
                     memcpy(args_ptr, &d, 8);
@@ -457,6 +467,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;
 

package/src/call_arm64.cc

@@ -41,8 +41,6 @@ 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 Napi::Value TranslateCall(const Napi::CallbackInfo &info);
-
 static bool IsHFA(const TypeInfo *type)
 {
     if (type->primitive != PrimitiveKind::Record)
@@ -62,7 +60,7 @@ static bool IsHFA(const TypeInfo *type)
     return true;
 }
 
-Napi::Function::Callback AnalyseFunction(InstanceData *, FunctionInfo *func)
+bool AnalyseFunction(InstanceData *, FunctionInfo *func)
 {
     if (IsHFA(func->ret.type)) {
         func->ret.vec_count = func->ret.type->members.len;
@@ -138,7 +136,7 @@ Napi::Function::Callback AnalyseFunction(InstanceData *, FunctionInfo *func)
     func->args_size = 16 * func->parameters.len;
     func->forward_fp = (vec_avail < 8);
 
-    return TranslateCall;
+    return true;
 }
 
 static bool PushHFA(const Napi::Object &obj, const TypeInfo *type, uint8_t *dest)
@@ -200,12 +198,9 @@ static Napi::Object PopHFA(napi_env env, const uint8_t *ptr, const TypeInfo *typ
     return obj;
 }
 
-static Napi::Value TranslateCall(const Napi::CallbackInfo &info)
+Napi::Value TranslateCall(InstanceData *instance, const FunctionInfo *func, const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
-    FunctionInfo *func = (FunctionInfo *)info.Data();
-
     CallData call(env, instance, func);
 
     // Sanity checks
@@ -239,7 +234,7 @@ static Napi::Value TranslateCall(const Napi::CallbackInfo &info)
         const ParameterInfo &param = func->parameters[i];
         RG_ASSERT(param.directions >= 1 && param.directions <= 3);
 
-        Napi::Value value = info[i];
+        Napi::Value value = info[param.offset];
 
         switch (param.type->primitive) {
             case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;

package/src/call_x64_sysv.cc

@@ -58,8 +58,6 @@ extern "C" Xmm0RaxRet ForwardCallXDG(const void *func, uint8_t *sp);
 extern "C" RaxXmm0Ret ForwardCallXGD(const void *func, uint8_t *sp);
 extern "C" Xmm0Xmm1Ret ForwardCallXDD(const void *func, uint8_t *sp);
 
-static Napi::Value TranslateCall(const Napi::CallbackInfo &info);
-
 static inline RegisterClass MergeClasses(RegisterClass cls1, RegisterClass cls2)
 {
     if (cls1 == cls2)
@@ -161,7 +159,7 @@ static void AnalyseParameter(ParameterInfo *param, int gpr_avail, int xmm_avail)
     }
 }
 
-Napi::Function::Callback AnalyseFunction(InstanceData *, FunctionInfo *func)
+bool AnalyseFunction(InstanceData *, FunctionInfo *func)
 {
     AnalyseParameter(&func->ret, 2, 2);
 
@@ -179,15 +177,12 @@ Napi::Function::Callback AnalyseFunction(InstanceData *, FunctionInfo *func)
 
     func->forward_fp = (xmm_avail < 8);
 
-    return TranslateCall;
+    return true;
 }
 
-static Napi::Value TranslateCall(const Napi::CallbackInfo &info)
+Napi::Value TranslateCall(InstanceData *instance, const FunctionInfo *func, const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
-    FunctionInfo *func = (FunctionInfo *)info.Data();
-
     CallData call(env, instance, func);
 
     // Sanity checks
@@ -221,7 +216,7 @@ static Napi::Value TranslateCall(const Napi::CallbackInfo &info)
         const ParameterInfo &param = func->parameters[i];
         RG_ASSERT(param.directions >= 1 && param.directions <= 3);
 
-        Napi::Value value = info[i];
+        Napi::Value value = info[param.offset];
 
         switch (param.type->primitive) {
             case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;

package/src/call_x64_sysv_fwd.S

@@ -32,13 +32,13 @@
 .global SYMBOL(ForwardCallXGD)
 .global SYMBOL(ForwardCallXDD)
 
-// Copy function pointer to RAX, in order to save it through argument forwarding.
+// Copy function pointer to R11, in order to save it through argument forwarding.
 // Save RSP in RBX (non-volatile), and use carefully assembled stack provided by caller.
 .macro prologue
     .cfi_startproc
     .cfi_def_cfa rsp, 8
     endbr64
-    movq %rdi, %rax
+    movq %rdi, %r11
     pushq %rbx
     .cfi_def_cfa rsp, 16
     movq %rsp, %rbx
@@ -50,7 +50,7 @@
 // Once done, restore normal stack pointer and return.
 // The return value is passed untouched through RAX or XMM0.
 .macro epilogue
-    call *%rax
+    call *%r11
     movq %rbx, %rsp
     popq %rbx
     .cfi_def_cfa rsp, 8
@@ -83,54 +83,64 @@
 SYMBOL(ForwardCallGG):
     prologue
     forward_int
+    movb $0, %al
     epilogue
 
 SYMBOL(ForwardCallF):
     prologue
     forward_int
+    movb $0, %al
     epilogue
 
 SYMBOL(ForwardCallDG):
     prologue
     forward_int
+    movb $0, %al
     epilogue
 
 SYMBOL(ForwardCallGD):
     prologue
     forward_int
+    movb $0, %al
     epilogue
 
 SYMBOL(ForwardCallDD):
     prologue
     forward_int
+    movb $0, %al
     epilogue
 
 SYMBOL(ForwardCallXGG):
     prologue
     forward_xmm
     forward_int
+    movb $8, %al
     epilogue
 
 SYMBOL(ForwardCallXF):
     prologue
     forward_xmm
     forward_int
+    movb $8, %al
     epilogue
 
 SYMBOL(ForwardCallXDG):
     prologue
     forward_xmm
     forward_int
+    movb $8, %al
     epilogue
 
 SYMBOL(ForwardCallXGD):
     prologue
     forward_xmm
     forward_int
+    movb $8, %al
     epilogue
 
 SYMBOL(ForwardCallXDD):
     prologue
     forward_xmm
     forward_int
+    movb $8, %al
     epilogue

package/src/call_x64_win.cc

@@ -29,15 +29,13 @@ extern "C" uint64_t ForwardCallXG(const void *func, uint8_t *sp);
 extern "C" float ForwardCallXF(const void *func, uint8_t *sp);
 extern "C" double ForwardCallXD(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 *, FunctionInfo *func)
+bool AnalyseFunction(InstanceData *, FunctionInfo *func)
 {
     func->ret.regular = IsRegular(func->ret.type->size);
 
@@ -50,15 +48,12 @@ Napi::Function::Callback AnalyseFunction(InstanceData *, FunctionInfo *func)
 
     func->args_size = AlignLen(8 * std::max((Size)4, func->parameters.len + !func->ret.regular), 16);
 
-    return TranslateCall;
+    return true;
 }
 
-static Napi::Value TranslateCall(const Napi::CallbackInfo &info)
+Napi::Value TranslateCall(InstanceData *instance, const FunctionInfo *func, const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
-    FunctionInfo *func = (FunctionInfo *)info.Data();
-
     CallData call(env, instance, func);
 
     // Sanity checks
@@ -86,7 +81,7 @@ static Napi::Value TranslateCall(const Napi::CallbackInfo &info)
         const ParameterInfo &param = func->parameters[i];
         RG_ASSERT(param.directions >= 1 && param.directions <= 3);
 
-        Napi::Value value = info[i];
+        Napi::Value value = info[param.offset];
 
         switch (param.type->primitive) {
             case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;

package/src/call_x86.cc

@@ -29,20 +29,21 @@ extern "C" uint64_t ForwardCallRG(const void *func, uint8_t *sp);
 extern "C" float ForwardCallRF(const void *func, uint8_t *sp);
 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)
+bool AnalyseFunction(InstanceData *instance, FunctionInfo *func)
 {
     int fast = (func->convention == CallConvention::Fastcall) ? 2 : 0;
 
-    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)) {
-        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)) {
+    if (func->ret.type->primitive != PrimitiveKind::Record) {
         func->ret.trivial = true;
+#if defined(_WIN32) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
+    } else {
+        func->ret.trivial = IsRegular(func->ret.type->size);
 #endif
     }
 #ifndef _WIN32
@@ -64,25 +65,26 @@ Napi::Function::Callback AnalyseFunction(InstanceData *instance, FunctionInfo *f
     func->args_size = params_size + 4 * !func->ret.trivial;
 
     switch (func->convention) {
-        case CallConvention::Default: {} break;
+        case CallConvention::Default: {
+            func->decorated_name = Fmt(&instance->str_alloc, "_%1", func->name).ptr;
+        } break;
         case CallConvention::Stdcall: {
+            RG_ASSERT(!func->variadic);
             func->decorated_name = Fmt(&instance->str_alloc, "_%1@%2", func->name, params_size).ptr;
         } break;
         case CallConvention::Fastcall: {
+            RG_ASSERT(!func->variadic);
             func->decorated_name = Fmt(&instance->str_alloc, "@%1@%2", func->name, params_size).ptr;
             func->args_size += 16;
         } break;
     }
 
-    return TranslateCall;
+    return true;
 }
 
-static Napi::Value TranslateCall(const Napi::CallbackInfo &info)
+Napi::Value TranslateCall(InstanceData *instance, const FunctionInfo *func, const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
-    FunctionInfo *func = (FunctionInfo *)info.Data();
-
     CallData call(env, instance, func);
 
     // Sanity checks
@@ -115,7 +117,7 @@ static Napi::Value TranslateCall(const Napi::CallbackInfo &info)
         const ParameterInfo &param = func->parameters[i];
         RG_ASSERT(param.directions >= 1 && param.directions <= 3);
 
-        Napi::Value value = info[i];
+        Napi::Value value = info[param.offset];
 
         switch (param.type->primitive) {
             case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;

package/src/ffi.cc

@@ -39,41 +39,7 @@
 namespace RG {
 
 // Value does not matter, the tag system uses memory addresses
-static const int TypeInfoMarker = 0xDEADBEEF;
-
-static const TypeInfo *ResolveType(const InstanceData *instance, Napi::Value value, int *out_directions = nullptr)
-{
-    if (value.IsString()) {
-        std::string str = value.As<Napi::String>();
-
-        const TypeInfo *type = instance->types_map.FindValue(str.c_str(), nullptr);
-
-        if (!type) {
-            ThrowError<Napi::TypeError>(value.Env(), "Unknown type string '%1'", str.c_str());
-            return nullptr;
-        }
-
-        if (out_directions) {
-            *out_directions = 1;
-        }
-        return type;
-    } else if (CheckValueTag(instance, value, &TypeInfoMarker)) {
-        Napi::External<TypeInfo> external = value.As<Napi::External<TypeInfo>>();
-
-        const TypeInfo *raw = external.Data();
-        const TypeInfo *type = AlignDown(raw, 4);
-        RG_ASSERT(type);
-
-        if (out_directions) {
-            Size delta = (uint8_t *)raw - (uint8_t *)type;
-            *out_directions = 1 + (int)delta;
-        }
-        return type;
-    } else {
-        ThrowError<Napi::TypeError>(value.Env(), "Unexpected %1 value as type specifier, expected string or type", GetValueType(instance, value));
-        return nullptr;
-    }
-}
+const int TypeInfoMarker = 0xDEADBEEF;
 
 static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
 {
@@ -289,7 +255,68 @@ static Napi::Value MarkInOut(const Napi::CallbackInfo &info)
     return EncodePointerDirection(info, 3);
 }
 
-static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConvention convention)
+static Napi::Value TranslateNormalCall(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    FunctionInfo *func = (FunctionInfo *)info.Data();
+
+    return TranslateCall(instance, func, info);
+}
+
+static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    FunctionInfo func;
+    memcpy(&func, info.Data(), RG_SIZE(FunctionInfo));
+    func.lib = nullptr;
+
+    // This makes variadic calls non-reentrant
+    RG_DEFER_C(len = func.parameters.len) {
+        func.parameters.RemoveFrom(len);
+        func.parameters.Leak();
+    };
+
+    if ((info.Length() - func.parameters.len) % 2) {
+        ThrowError<Napi::Error>(env, "Missing value argument for variadic call");
+        return env.Null();
+    }
+
+    for (Size i = func.parameters.len; i < info.Length(); i += 2) {
+        ParameterInfo param = {};
+
+        param.type = ResolveType(instance, info[i], &param.directions);
+        if (!param.type)
+            return env.Null();
+        if (param.type->primitive == PrimitiveKind::Void) {
+            ThrowError<Napi::TypeError>(env, "Type void cannot be used as a parameter");
+            return env.Null();
+        }
+
+        if (func.parameters.len >= MaxParameters) {
+            ThrowError<Napi::TypeError>(env, "Functions cannot have more than %1 parameters", MaxParameters);
+            return env.Null();
+        }
+        if ((param.directions & 2) && ++func.out_parameters >= MaxOutParameters) {
+            ThrowError<Napi::TypeError>(env, "Functions cannot have more than out %1 parameters", MaxOutParameters);
+            return env.Null();
+        }
+
+        param.variadic = true;
+        param.offset = i + 1;
+
+        func.parameters.Append(param);
+    }
+
+    if (!AnalyseFunction(instance, &func))
+        return env.Null();
+
+    return TranslateCall(instance, &func, info);
+}
+
+static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConvention convention, bool variadic)
 {
     Napi::Env env = info.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
@@ -321,9 +348,23 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConve
     }
 
     Napi::Array parameters = ((Napi::Value)info[2u]).As<Napi::Array>();
-    Size out_counter = 0;
+    Size parameters_len = parameters.Length();
+
+    if (parameters_len) {
+        Napi::String str = ((Napi::Value)parameters[(uint32_t)(parameters_len - 1)]).As<Napi::String>();
 
-    for (uint32_t j = 0; j < parameters.Length(); j++) {
+        if (str.IsString() && str.Utf8Value() == "...") {
+            func->variadic = true;
+            parameters_len--;
+        }
+
+        if (!variadic && func->variadic) {
+            LogError("Call convention '%1' does not support variadic functions, ignoring");
+            func->convention = CallConvention::Default;
+        }
+    }
+
+    for (uint32_t j = 0; j < parameters_len; j++) {
         ParameterInfo param = {};
 
         param.type = ResolveType(instance, parameters[j], &param.directions);
@@ -338,17 +379,22 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConve
             ThrowError<Napi::TypeError>(env, "Functions cannot have more than %1 parameters", MaxParameters);
             return env.Null();
         }
-        if ((param.directions & 2) && ++out_counter >= MaxOutParameters) {
+        if ((param.directions & 2) && ++func->out_parameters >= MaxOutParameters) {
             ThrowError<Napi::TypeError>(env, "Functions cannot have more than out %1 parameters", MaxOutParameters);
             return env.Null();
         }
 
+        param.offset = j;
+
         func->parameters.Append(param);
     }
 
-    Napi::Function::Callback call = AnalyseFunction(instance, func);
-    if (!call)
+    if (!AnalyseFunction(instance, func))
         return env.Null();
+    if (func->variadic) {
+        // Minimize reallocations
+        func->parameters.Grow(32);
+    }
 
 #ifdef _WIN32
     if (func->decorated_name) {
@@ -370,6 +416,7 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConve
         return env.Null();
     }
 
+    Napi::Function::Callback call = func->variadic ? TranslateVariadicCall : TranslateNormalCall;
     Napi::Function wrapper = Napi::Function::New(env, call, name.c_str(), (void *)func);
     wrapper.AddFinalizer([](Napi::Env, FunctionInfo *func) { delete func; }, func);
     func_guard.Disable();
@@ -434,17 +481,17 @@ static Napi::Value LoadSharedLibrary(const Napi::CallbackInfo &info)
 
     Napi::Object obj = Napi::Object::New(env);
 
-#define ADD_CONVENTION(Name, Value) \
+#define ADD_CONVENTION(Name, Value, Variadic) \
         do { \
-            const auto wrapper = [](const Napi::CallbackInfo &info) { return FindLibraryFunction(info, (Value)); }; \
+            const auto wrapper = [](const Napi::CallbackInfo &info) { return FindLibraryFunction(info, (Value), (Variadic)); }; \
             Napi::Function func = Napi::Function::New(env, wrapper, (Name), (void *)lib->Ref()); \
             func.AddFinalizer([](Napi::Env, LibraryHolder *lib) { lib->Unref(); }, lib); \
             obj.Set((Name), func); \
         } while (false)
 
-    ADD_CONVENTION("cdecl", CallConvention::Default);
-    ADD_CONVENTION("stdcall", CallConvention::Stdcall);
-    ADD_CONVENTION("fastcall", CallConvention::Fastcall);
+    ADD_CONVENTION("cdecl", CallConvention::Default, true);
+    ADD_CONVENTION("stdcall", CallConvention::Stdcall, false);
+    ADD_CONVENTION("fastcall", CallConvention::Fastcall, false);
 
 #undef ADD_CONVENTION
 

package/src/ffi.hh

@@ -22,6 +22,8 @@ namespace RG {
 static const Size MaxParameters = 32;
 static const Size MaxOutParameters = 8;
 
+extern const int TypeInfoMarker;
+
 enum class PrimitiveKind {
     Void,
 
@@ -63,12 +65,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;
 
@@ -108,10 +104,17 @@ enum class CallConvention {
     Stdcall,
     Fastcall
 };
+static const char *const CallConventionNames[] = {
+    "Default",
+    "Stdcall",
+    "Fastcall"
+};
 
 struct ParameterInfo {
     const TypeInfo *type;
     int directions;
+    bool variadic;
+    Size offset;
 
     // ABI-specific part
 
@@ -144,6 +147,8 @@ struct FunctionInfo {
 
     ParameterInfo ret;
     HeapArray<ParameterInfo> parameters;
+    Size out_parameters;
+    bool variadic;
 
     // ABI-specific part