koffi 2.16.0-beta.2 → 2.16.0

package/src/koffi/src/{abi/x86_asm.S → abi_x86_asm.S}

@@ -81,7 +81,10 @@ ForwardCallRD:
 # ----------------------------
 
 .global RelayCallback
-.global CallSwitchStack
+.global SwitchAndRelay
+.global RelayDirect
+.global FindTrampolineStart
+.global FindTrampolineEnd
 
 # 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,
@@ -93,19 +96,22 @@ ForwardCallRD:
 # 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)
-    leal 48(%esp), %eax
-    movl %eax, 8(%esp)
-    leal 16(%esp), %eax
-    movl %eax, 12(%esp)
     call GetEIP
-    addl $_GLOBAL_OFFSET_TABLE_, %ecx
-    call *RelayCallback@GOT(%ecx)
+    addl $_GLOBAL_OFFSET_TABLE_, %eax
+    call *RelayCallback@GOT(%eax)
     movl 44(%esp), %edx
     movl 36(%esp), %ecx
     movl %edx, 44(%esp, %ecx)
@@ -130,17 +136,12 @@ ForwardCallRD:
     .cfi_def_cfa esp, 4
     ret
     .cfi_endproc
-.endm
-
-GetEIP:
-    movl (%esp), %ecx
-    ret
 
 # 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.
-CallSwitchStack:
+SwitchAndRelay:
     .cfi_startproc
     .cfi_def_cfa esp, 4
     ENDBR32
@@ -148,21 +149,22 @@ CallSwitchStack:
     .cfi_def_cfa esp, 8
     movl %esp, %ebp
     .cfi_def_cfa ebp, 8
-    movl 28(%esp), %edx
     movl 24(%esp), %ecx
     movl %esp, %eax
     subl 0(%ecx), %eax
     andl $-16, %eax
     movl %eax, 4(%ecx)
     movl 20(%esp), %esp
-    subl $28, %esp
+    subl $24, %esp
     movl 8(%ebp), %eax
     movl %eax, 0(%esp)
     movl 12(%ebp), %eax
     movl %eax, 4(%esp)
     movl 16(%ebp), %eax
     movl %eax, 8(%esp)
-    call *%edx
+    call GetEIP
+    addl $_GLOBAL_OFFSET_TABLE_, %eax
+    call *RelayDirect@GOT(%eax)
     mov %ebp, %esp
     .cfi_def_cfa esp, 8
     pop %ebp
@@ -170,7 +172,20 @@ CallSwitchStack:
     ret
     .cfi_endproc
 
-# Trampolines
-# ----------------------------
+.align 4
+FindTrampolineStart:
+    call GetEIP
+    addl $16, %eax
+    andl $0xFFFFFFF0, %eax
+    ret
+.align 4
+
+#include "gnu.inc"
 
-#include "../trampolines/gnu.inc"
+FindTrampolineEnd:
+    call GetEIP
+    ret
+
+GetEIP:
+    movl (%esp), %eax
+    ret

package/src/koffi/src/{abi/x86_asm.asm → abi_x86_asm.asm}

@@ -80,7 +80,8 @@ ForwardCallRD endp
 ; ----------------------------
 
 extern RelayCallback : PROC
-public CallSwitchStack
+public SwitchAndRelay
+extern RelayDirect : PROC
 
 ; 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,
@@ -91,16 +92,15 @@ public CallSwitchStack
 ; to BackRegisters::ret_pop before ret is issued.
 ; We need to branch at the end to avoid x87 stack imbalance.
 trampoline macro ID
-    local l0, l1, l2
-
     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
-    lea eax, dword ptr [esp+48]
-    mov dword ptr [esp+8], eax
-    lea eax, dword ptr [esp+16]
-    mov dword ptr [esp+12], eax
     call RelayCallback
     mov edx, dword ptr [esp+44]
     mov ecx, dword ptr [esp+36]
@@ -122,39 +122,54 @@ 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
 ; probably misdetect this as a "stack overflow". We have to restore the old
 ; stack pointer, call Node.js/V8 and go back to ours.
-CallSwitchStack proc
+SwitchAndRelay proc
     endbr32
     push ebp
     mov ebp, esp
-    mov edx, dword ptr [esp+28]
     mov ecx, dword ptr [esp+24]
     mov eax, esp
     sub eax, dword ptr [ecx+0]
     and eax, -16
     mov dword ptr [ecx+4], eax
     mov esp, dword ptr [esp+20]
-    sub esp, 28
+    sub esp, 24
     mov eax, dword ptr [ebp+8]
     mov dword ptr [esp+0], eax
     mov eax, dword ptr [ebp+12]
     mov dword ptr [esp+4], eax
     mov eax, dword ptr [ebp+16]
     mov dword ptr [esp+8], eax
-    call edx
+    call RelayDirect
     mov esp, ebp
     pop ebp
     ret
-CallSwitchStack endp
+SwitchAndRelay endp
 
-; Trampolines
-; ----------------------------
+align 16
+FindTrampolineStart proc
+    call GetEIP
+    add eax, 16
+    and eax, 0FFFFFFF0h
+    ret
+FindTrampolineStart endp
+align 16
 
 include masm32.inc
 
+FindTrampolineEnd proc
+    call GetEIP
+    ret
+FindTrampolineEnd endp
+
+GetEIP proc
+    mov eax, dword ptr [esp]
+    ret
+GetEIP endp
+
 end