koffi 2.15.3 → 2.15.5

package/src/koffi/src/abi_x64_win.cc

@@ -25,8 +25,6 @@ extern "C" uint64_t ForwardCallXG(const void *func, uint8_t *sp, uint8_t **out_o
 extern "C" float ForwardCallXF(const void *func, uint8_t *sp, uint8_t **out_old_sp);
 extern "C" double ForwardCallXD(const void *func, uint8_t *sp, uint8_t **out_old_sp);
 
-#include "trampolines/prototypes.inc"
-
 bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
 {
     func->ret.regular = IsRegularSize(func->ret.type->size, 8);
@@ -736,12 +734,6 @@ void CallData::Relay(Size idx, uint8_t *sp)
     err_guard.Disable();
 }
 
-void *GetTrampoline(int16_t idx, const FunctionInfo *proto)
-{
-    bool xmm = proto->forward_fp || IsFloat(proto->ret.type);
-    return Trampolines[idx][xmm];
-}
-
 }
 
 #endif

package/src/koffi/src/abi_x64_win_asm.S

@@ -100,28 +100,18 @@ ForwardCallXD:
 .global SwitchAndRelay
 .global RelayDirect
 
-# First, make a copy of the GPR argument registers (rcx, rdx, r8, r9).
+# First, make a copy of argument registers.
 # 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.
 .macro trampoline id
     endbr64
-    subq $120, %rsp
-    movq %rcx, 32(%rsp)
-    movq %rdx, 40(%rsp)
-    movq %r8, 48(%rsp)
-    movq %r9, 56(%rsp)
-    movq $\id, %rcx
-    leaq 32(%rsp), %rdx
-    call RelayCallback
-    movq 96(%rsp), %rax
-    addq $120, %rsp
-    ret
+    movq $\id, %rax
+    jmp RelayTrampoline
 .endm
 
-# Same thing, but also forward the XMM argument registers and load the XMM result registers.
-.macro trampoline_vec id
+RelayTrampoline:
     endbr64
     subq $120, %rsp
     movq %rcx, 32(%rsp)
@@ -132,14 +122,13 @@ ForwardCallXD:
     movsd %xmm1, 72(%rsp)
     movsd %xmm2, 80(%rsp)
     movsd %xmm3, 88(%rsp)
-    movq $\id, %rcx
+    movq %rax, %rcx
     leaq 32(%rsp), %rdx
     call RelayCallback
     movq 96(%rsp), %rax
     movsd 104(%rsp), %xmm0
     addq $120, %rsp
     ret
-.endm
 
 # When a callback is relayed, Koffi will call into Node.js and V8 to execute Javascript.
 # The problem is that we're still running on the separate Koffi stack, and V8 will

package/src/koffi/src/abi_x64_win_asm.asm

@@ -111,31 +111,19 @@ extern RelayCallback : PROC
 public SwitchAndRelay
 extern RelayDirect : PROC
 
-; First, make a copy of the GPR argument registers (rcx, rdx, r8, r9).
+; First, make a copy of argument registers.
 ; 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.
 trampoline macro ID
-    endbr64
-    sub rsp, 120
-    .allocstack 120
     .endprolog
-    mov qword ptr [rsp+32], rcx
-    mov qword ptr [rsp+40], rdx
-    mov qword ptr [rsp+48], r8
-    mov qword ptr [rsp+56], r9
-    mov rcx, ID
-    lea rdx, qword ptr [rsp+32]
-    call RelayCallback
-    mov rax, qword ptr [rsp+96]
-    add rsp, 120
-    ret
+    endbr64
+    mov rax, ID
+    jmp RelayTrampoline
 endm
 
-; Same thing, but also forward the XMM argument registers and load the XMM result registers.
-trampoline_vec macro ID
-    endbr64
+RelayTrampoline proc frame
     sub rsp, 120
     .allocstack 120
     .endprolog
@@ -147,14 +135,14 @@ trampoline_vec macro ID
     movsd qword ptr [rsp+72], xmm1
     movsd qword ptr [rsp+80], xmm2
     movsd qword ptr [rsp+88], xmm3
-    mov rcx, ID
+    mov rcx, rax
     lea rdx, qword ptr [rsp+32]
     call RelayCallback
     mov rax, qword ptr [rsp+96]
     movsd xmm0, qword ptr [rsp+104]
     add rsp, 120
     ret
-endm
+RelayTrampoline endp
 
 ; When a callback is relayed, Koffi will call into Node.js and V8 to execute Javascript.
 ; The problem is that we're still running on the separate Koffi stack, and V8 will

package/src/koffi/src/abi_x86.cc

@@ -22,7 +22,7 @@ struct BackRegisters {
         double d;
         float f;
     } x87;
-    bool x87_double;
+    int ret_type;
     int ret_pop;
 };
 
@@ -40,8 +40,6 @@ extern "C" uint64_t ForwardCallRG(const void *func, uint8_t *sp, uint8_t **out_o
 extern "C" float ForwardCallRF(const void *func, uint8_t *sp, uint8_t **out_old_sp);
 extern "C" double ForwardCallRD(const void *func, uint8_t *sp, uint8_t **out_old_sp);
 
-#include "trampolines/prototypes.inc"
-
 bool AnalyseFunction(Napi::Env env, InstanceData *instance, FunctionInfo *func)
 {
     if (!func->lib && func->convention != CallConvention::Cdecl &&
@@ -500,7 +498,7 @@ void CallData::Relay(Size idx, uint8_t *sp)
     K_DEFER_N(err_guard) {
         int pop = out_reg->ret_pop;
         memset(out_reg, 0, K_SIZE(*out_reg));
-        out_reg->x87_double = true;
+        out_reg->ret_type = 0;
         out_reg->ret_pop = pop;
     };
 
@@ -709,6 +707,7 @@ void CallData::Relay(Size idx, uint8_t *sp)
              \
             CType v = GetNumber<CType>(value); \
             out_reg->eax = (uint32_t)v; \
+            out_reg->ret_type = 0; \
         } while (false)
 #define RETURN_INTEGER_32_SWAP(CType) \
         do { \
@@ -719,6 +718,7 @@ void CallData::Relay(Size idx, uint8_t *sp)
              \
             CType v = GetNumber<CType>(value); \
             out_reg->eax = (uint32_t)ReverseBytes(v); \
+            out_reg->ret_type = 0; \
         } while (false)
 #define RETURN_INTEGER_64(CType) \
         do { \
@@ -731,6 +731,7 @@ void CallData::Relay(Size idx, uint8_t *sp)
              \
             out_reg->eax = (uint32_t)((uint64_t)v >> 32); \
             out_reg->edx = (uint32_t)((uint64_t)v & 0xFFFFFFFFu); \
+            out_reg->ret_type = 0; \
         } while (false)
 #define RETURN_INTEGER_64_SWAP(CType) \
         do { \
@@ -743,10 +744,11 @@ void CallData::Relay(Size idx, uint8_t *sp)
              \
             out_reg->eax = (uint32_t)((uint64_t)v >> 32); \
             out_reg->edx = (uint32_t)((uint64_t)v & 0xFFFFFFFFu); \
+            out_reg->ret_type = 0; \
         } while (false)
 
     switch (type->primitive) {
-        case PrimitiveKind::Void: {} break;
+        case PrimitiveKind::Void: { out_reg->ret_type = 0; } break;
         case PrimitiveKind::Bool: {
             if (!value.IsBoolean()) [[unlikely]] {
                 ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected boolean", GetValueType(instance, value));
@@ -755,6 +757,7 @@ void CallData::Relay(Size idx, uint8_t *sp)
 
             bool b = value.As<Napi::Boolean>();
             out_reg->eax = (uint32_t)b;
+            out_reg->ret_type = 0;
         } break;
         case PrimitiveKind::Int8: { RETURN_INTEGER_32(int8_t); } break;
         case PrimitiveKind::UInt8: { RETURN_INTEGER_32(uint8_t); } break;
@@ -776,6 +779,7 @@ void CallData::Relay(Size idx, uint8_t *sp)
                 return;
 
             out_reg->eax = (uint32_t)str;
+            out_reg->ret_type = 0;
         } break;
         case PrimitiveKind::String16: {
             const char16_t *str16;
@@ -783,6 +787,7 @@ void CallData::Relay(Size idx, uint8_t *sp)
                 return;
 
             out_reg->eax = (uint32_t)str16;
+            out_reg->ret_type = 0;
         } break;
         case PrimitiveKind::String32: {
             const char32_t *str32;
@@ -790,6 +795,7 @@ void CallData::Relay(Size idx, uint8_t *sp)
                 return;
 
             out_reg->eax = (uint32_t)str32;
+            out_reg->ret_type = 0;
         } break;
         case PrimitiveKind::Pointer: {
             uint8_t *ptr;
@@ -812,6 +818,7 @@ void CallData::Relay(Size idx, uint8_t *sp)
             }
 
             out_reg->eax = (uint32_t)ptr;
+            out_reg->ret_type = 0;
         } break;
         case PrimitiveKind::Record:
         case PrimitiveKind::Union: {
@@ -829,6 +836,8 @@ void CallData::Relay(Size idx, uint8_t *sp)
             } else {
                 PushObject(obj, type, (uint8_t *)&out_reg->eax);
             }
+
+            out_reg->ret_type = 0;
         } break;
         case PrimitiveKind::Array: { K_UNREACHABLE(); } break;
         case PrimitiveKind::Float32: {
@@ -838,7 +847,7 @@ void CallData::Relay(Size idx, uint8_t *sp)
             }
 
             out_reg->x87.f = GetNumber<float>(value);
-            out_reg->x87_double = false;
+            out_reg->ret_type = 1;
         } break;
         case PrimitiveKind::Float64: {
             if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
@@ -847,7 +856,7 @@ void CallData::Relay(Size idx, uint8_t *sp)
             }
 
             out_reg->x87.d = GetNumber<double>(value);
-            out_reg->x87_double = true;
+            out_reg->ret_type = 2;
         } break;
         case PrimitiveKind::Callback: {
             void *ptr;
@@ -868,6 +877,7 @@ void CallData::Relay(Size idx, uint8_t *sp)
             }
 
             out_reg->eax = (uint32_t)ptr;
+            out_reg->ret_type = 0;
         } break;
 
         case PrimitiveKind::Prototype: { K_UNREACHABLE(); } break;
@@ -881,12 +891,6 @@ void CallData::Relay(Size idx, uint8_t *sp)
     err_guard.Disable();
 }
 
-void *GetTrampoline(int16_t idx, const FunctionInfo *proto)
-{
-    bool x87 = IsFloat(proto->ret.type);
-    return Trampolines[idx][x87];
-}
-
 }
 
 #endif

package/src/koffi/src/abi_x86_asm.S

@@ -91,13 +91,21 @@ ForwardCallRD:
 # Depending on ABI, call convention and return value size, we need to issue ret <something>. Since ret
 # only takes an immediate value, and I prefer not to branch, the return address is moved instead according
 # to BackRegisters::ret_pop before ret is issued.
+# We need to branch at the end to avoid x87 stack imbalance.
 .macro trampoline id
     .cfi_startproc
-    .cfi_def_cfa esp, 4
     ENDBR32
+    movl $\id, %eax
+    jmp RelayTrampoline
+    .cfi_endproc
+.endm
+
+RelayTrampoline:
+    .cfi_startproc
+    .cfi_def_cfa esp, 4
     sub $44, %esp
     .cfi_def_cfa esp, 48
-    movl $\id, 0(%esp)
+    movl %eax, 0(%esp)
     movl %esp, 4(%esp)
     call GetEIP
     addl $_GLOBAL_OFFSET_TABLE_, %ecx
@@ -105,32 +113,16 @@ ForwardCallRD:
     movl 44(%esp), %edx
     movl 36(%esp), %ecx
     movl %edx, 44(%esp, %ecx)
+    cmpl $1, 32(%esp)
+    je 1f
+    cmpl $2, 32(%esp)
+    je 2f
+0:
     movl 16(%esp), %eax
     movl 20(%esp), %edx
     leal 44(%esp, %ecx), %esp
     .cfi_def_cfa esp, 4
     ret
-    .cfi_endproc
-.endm
-
-# This version also loads the x87 stack with the result, if need be.
-# We have to branch to avoid x87 stack imbalance.
-.macro trampoline_vec id
-    .cfi_startproc
-    .cfi_def_cfa esp, 4
-    ENDBR32
-    sub $44, %esp
-    .cfi_def_cfa esp, 48
-    movl $\id, 0(%esp)
-    movl %esp, 4(%esp)
-    call GetEIP
-    addl $_GLOBAL_OFFSET_TABLE_, %ecx
-    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 24(%esp)
     leal 44(%esp, %ecx), %esp
@@ -142,7 +134,6 @@ ForwardCallRD:
     .cfi_def_cfa esp, 4
     ret
     .cfi_endproc
-.endm
 
 # When a callback is relayed, Koffi will call into Node.js and V8 to execute Javascript.
 # The problem is that we're still running on the separate Koffi stack, and V8 will

package/src/koffi/src/abi_x86_asm.asm

@@ -90,36 +90,30 @@ extern RelayDirect : PROC
 ; Depending on ABI, call convention and return value size, we need to issue ret <something>. Since ret
 ; only takes an immediate value, and I prefer not to branch, the return address is moved instead according
 ; to BackRegisters::ret_pop before ret is issued.
+; We need to branch at the end to avoid x87 stack imbalance.
 trampoline macro ID
     endbr32
+    mov eax, ID
+    jmp RelayTrampoline
+endm
+
+RelayTrampoline proc
     sub esp, 44
-    mov dword ptr [esp+0], ID
+    mov dword ptr [esp+0], eax
     mov dword ptr [esp+4], esp
     call RelayCallback
     mov edx, dword ptr [esp+44]
     mov ecx, dword ptr [esp+36]
     mov dword ptr [esp+ecx+44], edx
+    cmp dword ptr [esp+32], 1
+    je l1
+    cmp dword ptr [esp+32], 2
+    je l2
+l0:
     mov eax, dword ptr [esp+16]
     mov edx, dword ptr [esp+20]
-    lea esp, [esp+ecx+44]
+    lea esp, dword ptr [esp+ecx+44]
     ret
-endm
-
-; This version also loads the x87 stack with the result, if need be.
-; We have to branch to avoid x87 stack imbalance.
-trampoline_vec macro ID
-    local l1, l2, l3
-
-    endbr32
-    sub esp, 44
-    mov dword ptr [esp+0], ID
-    mov dword ptr [esp+4], esp
-    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+24]
     lea esp, dword ptr [esp+ecx+44]
@@ -128,7 +122,7 @@ l2:
     fld qword ptr [esp+24]
     lea esp, dword ptr [esp+ecx+44]
     ret
-endm
+RelayTrampoline endp
 
 ; When a callback is relayed, Koffi will call into Node.js and V8 to execute Javascript.
 ; The problem is that we're still running on the separate Koffi stack, and V8 will

package/src/koffi/src/call.cc

@@ -21,6 +21,8 @@ struct RelayContext {
     bool done = false;
 };
 
+#include "trampolines/prototypes.inc"
+
 CallData::CallData(Napi::Env env, InstanceData *instance, InstanceMemory *mem)
     : env(env), instance(instance),
       mem(mem), old_stack_mem(mem->stack), old_heap_mem(mem->heap)
@@ -29,7 +31,6 @@ CallData::CallData(Napi::Env env, InstanceData *instance, InstanceMemory *mem)
     mem->depth++;
 
     K_ASSERT(AlignUp(mem->stack.ptr, 16) == mem->stack.ptr);
-    K_ASSERT(AlignUp(mem->stack.end(), 16) == mem->stack.end());
 }
 
 CallData::~CallData()
@@ -1139,7 +1140,7 @@ void *CallData::ReserveTrampoline(const FunctionInfo *proto, Napi::Function func
     trampoline->recv.Reset();
     trampoline->generation = (int32_t)mem->generation;
 
-    void *ptr = GetTrampoline(idx, proto);
+    void *ptr = GetTrampoline(idx);
 
     return ptr;
 }
@@ -1306,4 +1307,9 @@ void PerformAsyncRelay(napi_env, napi_value, void *, void *udata)
     ctx->cv.notify_one();
 }
 
+void *GetTrampoline(int16_t idx)
+{
+    return Trampolines[idx];
+}
+
 }

package/src/koffi/src/call.hh

@@ -174,6 +174,6 @@ inline T *CallData::AllocHeap(Size size, Size align)
 
 void PerformAsyncRelay(napi_env env, napi_value callback, void *ctx, void *udata);
 
-void *GetTrampoline(int16_t idx, const FunctionInfo *proto);
+void *GetTrampoline(int16_t idx);
 
 }

package/src/koffi/src/ffi.cc

@@ -2013,7 +2013,7 @@ static Napi::Value RegisterCallback(const Napi::CallbackInfo &info)
     }
     trampoline->generation = -1;
 
-    void *ptr = GetTrampoline(idx, type->ref.proto);
+    void *ptr = GetTrampoline(idx);
 
     Napi::External<void> external = Napi::External<void>::New(env, ptr);
     SetValueTag(external, type->ref.marker);