koffi 1.2.0 → 1.2.1

package/CMakeLists.txt

@@ -18,7 +18,7 @@ find_package(CNoke)
 
 set(CMAKE_CXX_STANDARD 17)
 if(MSVC)
-    add_compile_options(/W4 /wd4200 /wd4458 /wd4706 /wd4100 /wd4127 /wd4702 /wd4201)
+    add_compile_options(/W4 /wd4200 /wd4458 /wd4706 /wd4100 /wd4127 /wd4702 /wd4201 /wd4324)
     enable_language(ASM_MASM)
 else()
     add_compile_options(-Wall -Wextra -Wno-missing-field-initializers -Wno-unused-parameter)

package/README.md

@@ -341,6 +341,8 @@ console.log(ret);
 // This example prints "Hello Niels!" first, and then prints 42
 ```
 
+On x86 platforms, only Cdecl and Stdcall callbacks are supported.
+
 ## Memory settings
 
 For synchronous/normal calls, Koffi uses two preallocated memory blocks, one to construct the C stack and the other to allocate strings and big objects/structs. Unless very big strings or objects (at least more than one page of memory) are used, no extra allocation is needed during calls or callbacks.

package/benchmark/CMakeLists.txt

@@ -26,7 +26,7 @@ add_subdirectory(../test test)
 
 set(CMAKE_CXX_STANDARD 17)
 if(MSVC)
-    add_compile_options(/W4 /wd4200 /wd4458 /wd4706 /wd4100 /wd4127 /wd4702 /wd4201)
+    add_compile_options(/W4 /wd4200 /wd4458 /wd4706 /wd4100 /wd4127 /wd4702 /wd4201 /wd4324)
 else()
     add_compile_options(-Wall -Wextra -Wno-missing-field-initializers -Wno-unused-parameter)
     if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")

package/package.json

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

package/src/abi_arm32.cc

@@ -100,7 +100,7 @@ static inline int IsHFA(const TypeInfo *type)
 #endif
 }
 
-bool AnalyseFunction(InstanceData *, FunctionInfo *func)
+bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
 {
     if (int hfa = IsHFA(func->ret.type); hfa) {
         func->ret.vec_count = hfa;
@@ -931,7 +931,7 @@ void *GetTrampoline(Size idx, const FunctionInfo *proto)
     return Trampolines[idx][vec];
 }
 
-extern "C" void RelayCallBack(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
+extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
 {
     exec_call->Relay(idx, own_sp, caller_sp, out_reg);
 }

package/src/abi_arm32_fwd.S

@@ -144,11 +144,11 @@ ForwardCallXDDDD:
 .global TrampolineX13
 .global TrampolineX14
 .global TrampolineX15
-.global RelayCallBack
+.global RelayCallback
 .global CallSwitchStack
 
 # First, make a copy of the GPR argument registers (r0 to r7).
-# Then call the C function RelayCallBack with the following arguments:
+# Then call the C function RelayCallback with the following arguments:
 # static trampoline ID, a pointer to the saved GPR array, a pointer to the stack
 # arguments of this call, and a pointer to a struct that will contain the result registers.
 # After the call, simply load these registers from the output struct.
@@ -168,7 +168,7 @@ ForwardCallXDDDD:
     mov r1, sp
     add r2, sp, #128
     add r3, sp, #80
-    bl RelayCallBack
+    bl RelayCallback
     ldr r0, [sp, 80]
     ldr r1, [sp, 84]
     add sp, sp, #120
@@ -206,7 +206,7 @@ ForwardCallXDDDD:
     mov r1, sp
     add r2, sp, #128
     add r3, sp, #80
-    bl RelayCallBack
+    bl RelayCallback
     ldr r0, [sp, 80]
     ldr r1, [sp, 84]
     vldr d0, [sp, 88]

package/src/abi_arm64.cc

@@ -98,7 +98,7 @@ static inline int IsHFA(const TypeInfo *type)
     return IsHFA(type, 1, 4);
 }
 
-bool AnalyseFunction(InstanceData *, FunctionInfo *func)
+bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
 {
     if (int hfa = IsHFA(func->ret.type); hfa) {
         func->ret.vec_count = hfa;
@@ -999,7 +999,7 @@ void *GetTrampoline(Size idx, const FunctionInfo *proto)
     return Trampolines[idx][vec];
 }
 
-extern "C" void RelayCallBack(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
+extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
 {
     exec_call->Relay(idx, own_sp, caller_sp, out_reg);
 }

package/src/abi_arm64_fwd.S

@@ -147,11 +147,11 @@ SYMBOL(ForwardCallXDDDD):
 .global SYMBOL(TrampolineX13)
 .global SYMBOL(TrampolineX14)
 .global SYMBOL(TrampolineX15)
-.global SYMBOL(RelayCallBack)
+.global SYMBOL(RelayCallback)
 .global SYMBOL(CallSwitchStack)
 
 # First, make a copy of the GPR argument registers (x0 to x7).
-# Then call the C function RelayCallBack with the following arguments:
+# Then call the C function RelayCallback with the following arguments:
 # static trampoline ID, a pointer to the saved GPR array, a pointer to the stack
 # arguments of this call, and a pointer to a struct that will contain the result registers.
 # After the call, simply load these registers from the output struct.
@@ -172,7 +172,7 @@ SYMBOL(ForwardCallXDDDD):
     mov x1, sp
     add x2, sp, #208
     add x3, sp, #136
-    bl SYMBOL(RelayCallBack)
+    bl SYMBOL(RelayCallback)
     ldp x0, x1, [sp, 136]
     add sp, sp, #192
     .cfi_def_cfa sp, 16
@@ -206,7 +206,7 @@ SYMBOL(ForwardCallXDDDD):
     mov x1, sp
     add x2, sp, #208
     add x3, sp, #136
-    bl SYMBOL(RelayCallBack)
+    bl SYMBOL(RelayCallback)
     ldp x0, x1, [sp, 136]
     ldp d0, d1, [sp, 152]
     ldp d2, d3, [sp, 168]

package/src/abi_arm64_fwd.asm

@@ -145,12 +145,12 @@ ForwardCallXDDDD PROC
     EXPORT TrampolineX13
     EXPORT TrampolineX14
     EXPORT TrampolineX15
-    EXPORT RelayCallBack
-    EXTERN RelayCallBack
+    EXPORT RelayCallback
+    EXTERN RelayCallback
     EXPORT CallSwitchStack
 
     ; First, make a copy of the GPR argument registers (x0 to x7).
-    ; Then call the C function RelayCallBack with the following arguments:
+    ; Then call the C function RelayCallback with the following arguments:
     ; static trampoline ID, a pointer to the saved GPR array, a pointer to the stack
     ; arguments of this call, and a pointer to a struct that will contain the result registers.
     ; After the call, simply load these registers from the output struct.
@@ -168,7 +168,7 @@ ForwardCallXDDDD PROC
     mov x1, sp
     add x2, sp, #208
     add x3, sp, #136
-    bl RelayCallBack
+    bl RelayCallback
     ldp x0, x1, [sp, 136]
     add sp, sp, #192
     ldp x29, x30, [sp], 16
@@ -194,7 +194,7 @@ ForwardCallXDDDD PROC
     mov x1, sp
     add x2, sp, #208
     add x3, sp, #136
-    bl RelayCallBack
+    bl RelayCallback
     ldp x0, x1, [sp, 136]
     ldp d0, d1, [sp, 152]
     ldp d2, d3, [sp, 168]

package/src/abi_riscv64.cc

@@ -146,7 +146,7 @@ static void AnalyseParameter(ParameterInfo *param, int gpr_avail, int vec_avail)
     }
 }
 
-bool AnalyseFunction(InstanceData *, FunctionInfo *func)
+bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
 {
     AnalyseParameter(&func->ret, 2, 2);
 
@@ -817,7 +817,7 @@ void *GetTrampoline(Size idx, const FunctionInfo *proto)
     return Trampolines[idx][fp];
 }
 
-extern "C" void RelayCallBack(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
+extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
 {
     exec_call->Relay(idx, own_sp, caller_sp, out_reg);
 }

package/src/abi_riscv64_fwd.S

@@ -168,11 +168,11 @@ ForwardCallXDD:
 .global TrampolineX13
 .global TrampolineX14
 .global TrampolineX15
-.global RelayCallBack
+.global RelayCallback
 .global CallSwitchStack
 
 # First, make a copy of the GPR argument registers (a0 to a7).
-# Then call the C function RelayCallBack with the following arguments:
+# Then call the C function RelayCallback with the following arguments:
 # static trampoline ID, a pointer to the saved GPR array, a pointer to the stack
 # arguments of this call, and a pointer to a struct that will contain the result registers.
 # After the call, simply load these registers from the output struct.
@@ -191,7 +191,7 @@ ForwardCallXDD:
     addi a1, sp, 8
     addi a2, sp, 176
     addi a3, sp, 136
-    jal RelayCallBack
+    jal RelayCallback
     ld ra, 0(sp)
     ld a0, 136(sp)
     ld a1, 144(sp)
@@ -223,7 +223,7 @@ ForwardCallXDD:
     addi a1, sp, 8
     addi a2, sp, 176
     addi a3, sp, 136
-    jal RelayCallBack
+    jal RelayCallback
     ld ra, 0(sp)
     ld a0, 136(sp)
     ld a1, 144(sp)

package/src/abi_x64_sysv.cc

@@ -225,7 +225,7 @@ static void AnalyseParameter(ParameterInfo *param, int gpr_avail, int xmm_avail)
     }
 }
 
-bool AnalyseFunction(InstanceData *, FunctionInfo *func)
+bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
 {
     AnalyseParameter(&func->ret, 2, 2);
 
@@ -874,7 +874,7 @@ void *GetTrampoline(Size idx, const FunctionInfo *proto)
     return Trampolines[idx][xmm];
 }
 
-extern "C" void RelayCallBack(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
+extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
 {
     exec_call->Relay(idx, own_sp, caller_sp, out_reg);
 }

package/src/abi_x64_sysv_fwd.S

@@ -185,11 +185,11 @@ SYMBOL(ForwardCallXDD):
 .global SYMBOL(TrampolineX13)
 .global SYMBOL(TrampolineX14)
 .global SYMBOL(TrampolineX15)
-.global SYMBOL(RelayCallBack)
+.global SYMBOL(RelayCallback)
 .global SYMBOL(CallSwitchStack)
 
 # First, make a copy of the GPR argument registers (rdi, rsi, rdx, rcx, r8, r9).
-# Then call the C function RelayCallBack with the following arguments:
+# Then call the C function RelayCallback with the following arguments:
 # static trampoline ID, a pointer to the saved GPR array, a pointer to the stack
 # arguments of this call, and a pointer to a struct that will contain the result registers.
 # After the call, simply load these registers from the output struct.
@@ -209,7 +209,7 @@ SYMBOL(ForwardCallXDD):
     movq %rsp, %rsi
     leaq 160(%rsp), %rdx
     leaq 112(%rsp), %rcx
-    call SYMBOL(RelayCallBack)
+    call SYMBOL(RelayCallback)
     movq 112(%rsp), %rax
     movq 120(%rsp), %rdx
     addq $152, %rsp
@@ -243,7 +243,7 @@ SYMBOL(ForwardCallXDD):
     movq %rsp, %rsi
     leaq 160(%rsp), %rdx
     leaq 112(%rsp), %rcx
-    call SYMBOL(RelayCallBack)
+    call SYMBOL(RelayCallback)
     movq 112(%rsp), %rax
     movq 120(%rsp), %rdx
     movsd 128(%rsp), %xmm0

package/src/abi_x64_win.cc

@@ -83,7 +83,7 @@ static inline bool IsRegular(Size size)
     return regular;
 }
 
-bool AnalyseFunction(InstanceData *, FunctionInfo *func)
+bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
 {
     func->ret.regular = IsRegular(func->ret.type->size);
 
@@ -656,7 +656,7 @@ void *GetTrampoline(Size idx, const FunctionInfo *proto)
     return Trampolines[idx][xmm];
 }
 
-extern "C" void RelayCallBack(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
+extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
 {
     exec_call->Relay(idx, own_sp, caller_sp, out_reg);
 }

package/src/abi_x64_win_fwd.asm

@@ -142,11 +142,11 @@ public TrampolineX12
 public TrampolineX13
 public TrampolineX14
 public TrampolineX15
-extern RelayCallBack : PROC
+extern RelayCallback : PROC
 public CallSwitchStack
 
 ; First, make a copy of the GPR argument registers (rcx, rdx, r8, r9).
-; Then call the C function RelayCallBack with the following arguments:
+; Then call the C function RelayCallback with the following arguments:
 ; static trampoline ID, a pointer to the saved GPR array, a pointer to the stack
 ; arguments of this call, and a pointer to a struct that will contain the result registers.
 ; After the call, simply load these registers from the output struct.
@@ -163,7 +163,7 @@ trampoline macro ID
     lea rdx, qword ptr [rsp+32]
     lea r8, qword ptr [rsp+128]
     lea r9, qword ptr [rsp+96]
-    call RelayCallBack
+    call RelayCallback
     mov rax, qword ptr [rsp+96]
     add rsp, 120
     ret
@@ -187,7 +187,7 @@ trampoline_xmm macro ID
     lea rdx, qword ptr [rsp+32]
     lea r8, qword ptr [rsp+128]
     lea r9, qword ptr [rsp+96]
-    call RelayCallBack
+    call RelayCallback
     mov rax, qword ptr [rsp+96]
     movsd xmm0, qword ptr [rsp+104]
     add rsp, 120

package/src/abi_x86.cc

@@ -25,12 +25,12 @@ namespace RG {
 struct BackRegisters {
     uint32_t eax;
     uint32_t edx;
-    double d;
-    float f;
-    bool is_double;
-#ifndef _WIN32
-    bool ret4;
-#endif
+    union {
+        double d;
+        float f;
+    } x87;
+    bool x87_double;
+    int ret_pop;
 };
 
 extern "C" uint64_t ForwardCallG(const void *func, uint8_t *sp, uint8_t **out_old_sp);
@@ -89,8 +89,14 @@ static inline bool IsRegular(Size size)
     return regular;
 }
 
-bool AnalyseFunction(InstanceData *instance, FunctionInfo *func)
+bool AnalyseFunction(Napi::Env env, InstanceData *instance, FunctionInfo *func)
 {
+    if (!func->lib && func->convention != CallConvention::Cdecl &&
+                      func->convention != CallConvention::Stdcall) {
+        ThrowError<Napi::Error>(env, "Only Cdecl and Stdcall callbacks are supported");
+        return false;
+    }
+
     int fast = (func->convention == CallConvention::Fastcall) ? 2 :
                (func->convention == CallConvention::Thiscall) ? 1 : 0;
     func->fast = fast;
@@ -116,7 +122,7 @@ bool AnalyseFunction(InstanceData *instance, FunctionInfo *func)
             fast--;
         }
 
-        params_size += std::max((int16_t)4, param.type->size);
+        params_size += std::max(4, AlignLen(param.type->size, 4));
     }
     func->args_size = params_size + 4 * !func->ret.trivial;
 
@@ -441,9 +447,15 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
     uint8_t *return_ptr = !proto->ret.trivial ? (uint8_t *)args_ptr[0] : nullptr;
     args_ptr += !proto->ret.trivial;
 
+    if (proto->convention == CallConvention::Stdcall) {
+        out_reg->ret_pop = (int)proto->args_size;
 #ifndef _WIN32
-    out_reg->ret4 = !!return_ptr;
+    } else if (return_ptr) {
+        out_reg->ret_pop = 4;
 #endif
+    } else {
+        out_reg->ret_pop = 0;
+    }
 
     LocalArray<napi_value, MaxParameters> arguments;
 
@@ -680,8 +692,8 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
                 return;
             }
 
-            out_reg->f = CopyNumber<float>(value);
-            out_reg->is_double = false;
+            out_reg->x87.f = CopyNumber<float>(value);
+            out_reg->x87_double = false;
         } break;
         case PrimitiveKind::Float64: {
             if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
@@ -689,8 +701,8 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
                 return;
             }
 
-            out_reg->d = CopyNumber<double>(value);
-            out_reg->is_double = true;
+            out_reg->x87.d = CopyNumber<double>(value);
+            out_reg->x87_double = true;
         } break;
         case PrimitiveKind::Callback: {
             void *ptr;
@@ -721,7 +733,7 @@ void *GetTrampoline(Size idx, const FunctionInfo *proto)
     return Trampolines[idx][x87];
 }
 
-extern "C" void RelayCallBack(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
+extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
 {
     exec_call->Relay(idx, own_sp, caller_sp, out_reg);
 }

package/src/abi_x86_fwd.S

@@ -115,10 +115,10 @@ ForwardCallRD:
 .global TrampolineX13
 .global TrampolineX14
 .global TrampolineX15
-.global RelayCallBack
+.global RelayCallback
 .global CallSwitchStack
 
-# Call the C function RelayCallBack with the following arguments:
+# Call the C function RelayCallback with the following arguments:
 # static trampoline ID, the current stack pointer, a pointer to the stack arguments of this call,
 # and a pointer to a struct that will contain the result registers.
 # After the call, simply load these registers from the output struct.
@@ -136,19 +136,15 @@ ForwardCallRD:
     movl %eax, 12(%esp)
     call GetEIP
     addl $_GLOBAL_OFFSET_TABLE_, %ecx
-    call *RelayCallBack@GOT(%ecx)
+    call *RelayCallback@GOT(%ecx)
+    movl 44(%esp), %edx
+    movl 36(%esp), %ecx
+    movl %edx, 44(%esp, %ecx)
     movl 16(%esp), %eax
     movl 20(%esp), %edx
-    cmpb $0, 37(%esp)
-    jne 2f
-1:
-    addl $44, %esp
+    leal 44(%esp, %ecx), %esp
     .cfi_def_cfa esp, 4
     ret
-2:
-    addl $44, %esp
-    .cfi_def_cfa esp, 4
-    ret $4
     .cfi_endproc
 .endm
 
@@ -168,17 +164,20 @@ ForwardCallRD:
     movl %eax, 12(%esp)
     call GetEIP
     addl $_GLOBAL_OFFSET_TABLE_, %ecx
-    call *RelayCallBack@GOT(%ecx)
-    cmpb $0, 36(%esp)
+    call *RelayCallback@GOT(%ecx)
+    movl 44(%esp), %edx
+    movl 36(%esp), %ecx
+    movl %edx, 44(%esp, %ecx, 4)
+    cmpb $0, 32(%esp)
     jne 2f
 1:
-    flds 32(%esp)
-    addl $44, %esp
+    flds 24(%esp)
+    leal 44(%esp, %ecx), %esp
     .cfi_def_cfa esp, 4
     ret
 2:
     fldl 24(%esp)
-    addl $44, %esp
+    leal 44(%esp, %ecx), %esp
     .cfi_def_cfa esp, 4
     ret
     .cfi_endproc

package/src/abi_x86_fwd.asm

@@ -121,10 +121,10 @@ public TrampolineX12
 public TrampolineX13
 public TrampolineX14
 public TrampolineX15
-extern RelayCallBack : PROC
+extern RelayCallback : PROC
 public CallSwitchStack
 
-; Call the C function RelayCallBack with the following arguments:
+; Call the C function RelayCallback with the following arguments:
 ; static trampoline ID, the current stack pointer, a pointer to the stack arguments of this call,
 ; and a pointer to a struct that will contain the result registers.
 ; After the call, simply load these registers from the output struct.
@@ -137,10 +137,13 @@ trampoline macro ID
     mov dword ptr [esp+8], eax
     lea eax, dword ptr [esp+16]
     mov dword ptr [esp+12], eax
-    call RelayCallBack
+    call RelayCallback
+    mov edx, dword ptr [esp+44]
+    mov ecx, dword ptr [esp+36]
+    mov dword ptr [esp+ecx+44], edx
     mov eax, dword ptr [esp+16]
     mov edx, dword ptr [esp+20]
-    add esp, 44
+    lea esp, [esp+ecx+44]
     ret
 endm
 
@@ -157,16 +160,19 @@ trampoline_x87 macro ID
     mov dword ptr [esp+8], eax
     lea eax, dword ptr [esp+16]
     mov dword ptr [esp+12], eax
-    call RelayCallBack
-    cmp byte ptr [esp+36], 0
+    call RelayCallback
+    mov edx, dword ptr [esp+44]
+    mov ecx, dword ptr [esp+36]
+    mov dword ptr [esp+ecx+44], edx
+    cmp byte ptr [esp+32], 0
     jne l2
 l1:
-    fld dword ptr [esp+32]
-    add esp, 44
+    fld dword ptr [esp+24]
+    lea esp, dword ptr [esp+ecx+44]
     ret
 l2:
     fld qword ptr [esp+24]
-    add esp, 44
+    lea esp, dword ptr [esp+ecx+44]
     ret
 endm
 

package/src/call.hh

@@ -21,7 +21,7 @@
 
 namespace RG {
 
-bool AnalyseFunction(InstanceData *instance, FunctionInfo *func);
+bool AnalyseFunction(Napi::Env env, InstanceData *instance, FunctionInfo *func);
 
 struct BackRegisters;
 

package/src/ffi.cc

@@ -511,13 +511,8 @@ static Napi::Value CreateCallbackType(const Napi::CallbackInfo &info)
         LogError("Variadic callbacks are not supported");
         return env.Null();
     }
-    if (func->convention != CallConvention::Cdecl &&
-            func->convention != CallConvention::Stdcall) {
-        ThrowError<Napi::Error>(env, "Only Cdecl and Stdcall callbacks are supported");
-        return env.Null();
-    }
 
-    if (!AnalyseFunction(instance, func))
+    if (!AnalyseFunction(env, instance, func))
         return env.Null();
 
     // We cannot fail after this check
@@ -713,7 +708,7 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
         func.parameters.Append(param);
     }
 
-    if (RG_UNLIKELY(!AnalyseFunction(instance, &func)))
+    if (RG_UNLIKELY(!AnalyseFunction(env, instance, &func)))
         return env.Null();
 
     InstanceMemory *mem = instance->memories[0];
@@ -846,7 +841,7 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConve
         func->convention = CallConvention::Cdecl;
     }
 
-    if (!AnalyseFunction(instance, func))
+    if (!AnalyseFunction(env, instance, func))
         return env.Null();
     if (func->variadic) {
         // Minimize reallocations

package/test/callbacks.js

@@ -32,6 +32,7 @@ const BFG = koffi.struct('BFG', {
 const SimpleCallback = koffi.callback('int SimpleCallback(const char *str)');
 const RecursiveCallback = koffi.callback('RecursiveCallback', 'float', ['int', 'string', 'double']);
 const BigCallback = koffi.callback('BFG BigCallback(BFG bfg)');
+const ApplyCallback = koffi.callback('int __stdcall ApplyCallback(int a, int b, int c)');
 
 main();
 
@@ -52,6 +53,7 @@ async function test() {
     const CallJS = lib.func('int CallJS(const char *str, SimpleCallback cb)');
     const CallRecursiveJS = lib.func('float CallRecursiveJS(int i, RecursiveCallback func)');
     const ModifyBFG = lib.func('BFG ModifyBFG(int x, double y, const char *str, BigCallback func, _Out_ BFG *p)');
+    const ApplyStd = lib.func('int ApplyStd(int a, int b, int c, ApplyCallback func)');
 
     // Simple test similar to README example
     {
@@ -84,4 +86,10 @@ async function test() {
         assert.deepEqual(bfg, { a: 2, b: 4, c: -25, d: 'New!', e: 54, inner: { f: -10, g: 3 } });
         assert.deepEqual(out, { a: 2, b: 4, c: -25, d: 'X/Yo!/X', e: 54, inner: { f: 10, g: 3 } });
     }
+
+    // Stdcall callbacks
+    {
+        let ret = ApplyStd(1, 5, 9, (a, b, c) => a + b * c);
+        assert.equal(ret, 46);
+    }
 }

package/test/misc.c

@@ -504,3 +504,11 @@ EXPORT BFG ModifyBFG(int x, double y, const char *str, BFG (*func)(BFG bfg), BFG
     bfg = func(bfg);
     return bfg;
 }
+
+typedef int STDCALL ApplyCallback(int a, int b, int c);
+
+EXPORT int ApplyStd(int a, int b, int c, ApplyCallback *func)
+{
+    int ret = func(a, b, c);
+    return ret;
+}