koffi 2.16.0-beta.2 → 2.16.0

package/src/koffi/src/{abi/x64_win_asm.S → abi_x64_win_asm.S}

@@ -13,6 +13,8 @@
 .global ForwardCallXF
 .global ForwardCallXD
 
+.global SehHandler
+
 # Copy function pointer to RAX, in order to save it through argument forwarding.
 # Also make a copy of the SP to CallData::old_sp because the callback system might need it.
 # Save RSP in RBX (non-volatile), and use carefully assembled stack provided by caller.
@@ -25,16 +27,6 @@
     movq %rdx, %rsp
 .endm
 
-# Call native function.
-# Once done, restore normal stack pointer and return.
-# The return value is passed untouched through RAX or XMM0.
-.macro epilogue
-    call *%rax
-    movq %rbp, %rsp
-    pop %rbp
-    ret
-.endm
-
 # Prepare integer argument registers from array passed by caller.
 .macro forward_gpr
     movq 24(%rdx), %r9
@@ -51,44 +43,64 @@
     movsd 0(%rdx), %xmm0
 .endm
 
+# CallNative is a minimal wrapper around the native function call.
+# Its frame lives entirely on the custom stack, so its EstablisherFrame passes
+# the TEB stack bounds check. This ensures that SehHandler is found by
+# RtlDispatchException before it tries to cross back to the original stack
+# (through ForwardCall*), which would fail the bounds check and terminate.
+# After the native call returns, CallNative restores the original stack via
+# RBP (non-volatile, preserved by native) and returns directly to the C++ caller.
+CallNative:
+    .seh_proc CallNative
+    .seh_handler SehHandler, @except
+    .seh_endprologue
+    call *%rax
+    movq %rbp, %rsp
+    pop %rbp
+    ret
+    .seh_endproc
+
 ForwardCallG:
     prologue
     forward_gpr
-    epilogue
+    jmp CallNative
 
 ForwardCallF:
     prologue
     forward_gpr
-    epilogue
+    jmp CallNative
 
 ForwardCallD:
     prologue
     forward_gpr
-    epilogue
+    jmp CallNative
 
 ForwardCallXG:
     prologue
     forward_xmm
     forward_gpr
-    epilogue
+    jmp CallNative
 
 ForwardCallXF:
     prologue
     forward_xmm
     forward_gpr
-    epilogue
+    jmp CallNative
 
 ForwardCallXD:
     prologue
     forward_xmm
     forward_gpr
-    epilogue
+    jmp CallNative
 
 # Callbacks
 # ----------------------------
 
 .global RelayCallback
-.global CallSwitchStack
+.global SwitchAndRelay
+.global RelayDirect
+.global FindTrampolineStart
+.global FindTrampolineEnd
 
 # First, make a copy of argument registers.
 # Then call the C function RelayCallback with the following arguments:
@@ -96,6 +108,12 @@ ForwardCallXD:
 # 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
+    movq $\id, %rax
+    jmp RelayTrampoline
+.endm
+
+RelayTrampoline:
     endbr64
     subq $120, %rsp
     movq %rcx, 32(%rsp)
@@ -106,39 +124,43 @@ ForwardCallXD:
     movsd %xmm1, 72(%rsp)
     movsd %xmm2, 80(%rsp)
     movsd %xmm3, 88(%rsp)
-    movq $\id, %rcx
+    movq %rax, %rcx
     leaq 32(%rsp), %rdx
-    leaq 160(%rsp), %r8
-    leaq 96(%rsp), %r9
     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
 # probably misdetect this as a "stack overflow". We have to restore the old
 # stack pointer, call Node.js/V8 and go back to ours.
 # The first three parameters (rcx, rdx, r8) are passed through untouched.
-CallSwitchStack:
+SwitchAndRelay:
     endbr64
     push %rbp
     movq %rsp, %rbp
-    movq 56(%rsp), %rax
     movq %rsp, %r10
     movq 48(%rsp), %r11
     subq 0(%r11), %r10
     andq $-16, %r10
     movq %r10, 8(%r11)
     leaq -32(%r9), %rsp
-    call *%rax
+    call RelayDirect
     movq %rbp, %rsp
     pop %rbp
     ret
 
-# Trampolines
-# ----------------------------
+.align 4
+FindTrampolineStart:
+    leaq 16(%rip), %rax
+    andq $0xFFFFFFFFFFFFFFF0, %rax
+    ret
+.align 4
 
-#include "../trampolines/gnu.inc"
+#include "gnu.inc"
+
+FindTrampolineEnd:
+    leaq (%rip), %rax
+    ret

package/src/koffi/src/{abi/x64_win_asm.asm → abi_x64_win_asm.asm}

@@ -15,6 +15,8 @@ public ForwardCallXG
 public ForwardCallXF
 public ForwardCallXD
 
+extern SehHandler : PROC
+
 .code
 
 ; Copy function pointer to RAX, in order to save it through argument forwarding.
@@ -32,16 +34,6 @@ prologue macro
     mov rsp, rdx
 endm
 
-; Call native function.
-; Once done, restore normal stack pointer and return.
-; The return value is passed untouched through RAX or XMM0.
-epilogue macro
-    call rax
-    mov rsp, rbp
-    pop rbp
-    ret
-endm
-
 ; Prepare integer argument registers from array passed by caller.
 forward_gpr macro
     mov r9, qword ptr [rdx+24]
@@ -58,50 +50,68 @@ forward_xmm macro
     movsd xmm0, qword ptr [rdx+0]
 endm
 
+; CallNative is a minimal wrapper around the native function call.
+; Its frame lives entirely on the custom stack, so its EstablisherFrame passes
+; the TEB stack bounds check. This ensures that SehHandler is found by
+; RtlDispatchException before it tries to cross back to the original stack
+; (through ForwardCall*), which would fail the bounds check and terminate.
+; After the native call returns, CallNative restores the original stack via
+; RBP (non-volatile, preserved by native) and returns directly to the C++ caller.
+CallNative proc frame:SehHandler
+    .endprolog
+    call rax
+    mov rsp, rbp
+    pop rbp
+    ret
+CallNative endp
+
 ForwardCallG proc frame
     prologue
     forward_gpr
-    epilogue
+    jmp CallNative
 ForwardCallG endp
 
 ForwardCallF proc frame
     prologue
     forward_gpr
-    epilogue
+    jmp CallNative
 ForwardCallF endp
 
 ForwardCallD proc frame
     prologue
     forward_gpr
-    epilogue
+    jmp CallNative
 ForwardCallD endp
 
 ForwardCallXG proc frame
     prologue
     forward_xmm
     forward_gpr
-    epilogue
+    jmp CallNative
 ForwardCallXG endp
 
 ForwardCallXF proc frame
     prologue
     forward_xmm
     forward_gpr
-    epilogue
+    jmp CallNative
 ForwardCallXF endp
 
 ForwardCallXD proc frame
     prologue
     forward_xmm
     forward_gpr
-    epilogue
+    jmp CallNative
 ForwardCallXD endp
 
 ; Callbacks
 ; ----------------------------
 
 extern RelayCallback : PROC
-public CallSwitchStack
+public SwitchAndRelay
+extern RelayDirect : PROC
+public FindTrampolineStart
+public FindTrampolineEnd
 
 ; First, make a copy of argument registers.
 ; Then call the C function RelayCallback with the following arguments:
@@ -109,7 +119,13 @@ public CallSwitchStack
 ; 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
+    .endprolog
     endbr64
+    mov rax, ID
+    jmp RelayTrampoline
+endm
+
+RelayTrampoline proc frame
     sub rsp, 120
     .allocstack 120
     .endprolog
@@ -121,45 +137,56 @@ trampoline 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]
-    lea r8, qword ptr [rsp+160]
-    lea r9, qword ptr [rsp+96]
     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
 ; probably misdetect this as a "stack overflow". We have to restore the old
 ; stack pointer, call Node.js/V8 and go back to ours.
 ; The first three parameters (rcx, rdx, r8) are passed through untouched.
-CallSwitchStack proc frame
+SwitchAndRelay proc frame
     endbr64
     push rbp
     .pushreg rbp
     mov rbp, rsp
     .setframe rbp, 0
     .endprolog
-    mov rax, qword ptr [rsp+56]
     mov r10, rsp
     mov r11, qword ptr [rsp+48]
     sub r10, qword ptr [r11+0]
     and r10, -16
     mov qword ptr [r11+8], r10
     lea rsp, [r9-32]
-    call rax
+    call RelayDirect
     mov rsp, rbp
     pop rbp
     ret
-CallSwitchStack endp
+SwitchAndRelay endp
 
-; Trampolines
-; ----------------------------
+align 16
+FindTrampolineStart:
+    call GetRIP
+    add rax, 16
+    and rax, 0FFFFFFFFFFFFFFF0h
+    ret
+align 16
 
 include masm64.inc
 
+FindTrampolineEnd:
+    call GetRIP
+    ret
+
+; I could not f*cking find how to use lea with RIP-relative addressing in MASM64. Oh well.
+GetRIP:
+    mov rax, qword ptr [rsp]
+    ret
+
 end