koffi 1.1.5 → 1.2.0-alpha.3

package/src/abi_arm64_fwd.S

@@ -1,15 +1,15 @@
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program. If not, see https://www.gnu.org/licenses/.
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see https://www.gnu.org/licenses/.
 
 #ifdef __APPLE__
     #define SYMBOL(Symbol) _ ## Symbol
@@ -17,19 +17,23 @@
     #define SYMBOL(Symbol) Symbol
 #endif
 
-// These three are the same, but they differ (in the C side) by their return type.
-// Unlike the three next functions, these ones don't forward XMM argument registers.
+# Forward
+# ----------------------------
+
+# These three are the same, but they differ (in the C side) by their return type.
+# Unlike the three next functions, these ones don't forward XMM argument registers.
 .global SYMBOL(ForwardCallGG)
 .global SYMBOL(ForwardCallF)
 .global SYMBOL(ForwardCallDDDD)
 
-// The X variants are slightly slower, and are used when XMM arguments must be forwarded.
+# The X variants are slightly slower, and are used when XMM arguments must be forwarded.
 .global SYMBOL(ForwardCallXGG)
 .global SYMBOL(ForwardCallXF)
 .global SYMBOL(ForwardCallXDDDD)
 
-// Copy function pointer to r9, in order to save it through argument forwarding.
-// Save RSP in r29 (non-volatile), and use carefully assembled stack provided by caller.
+# Copy function pointer to r9, 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 r29 (non-volatile), and use carefully assembled stack provided by caller.
 .macro prologue
     .cfi_startproc
     stp x29, x30, [sp, -16]!
@@ -38,13 +42,14 @@
     .cfi_offset 30, 8
     mov x29, sp
     .cfi_def_cfa x29, 16
+    str x29, [x2, 0]
     mov x9, x0
     add sp, x1, #136
 .endm
 
-// Call native function.
-// Once done, restore normal stack pointer and return.
-// The return value is passed untouched through r0, r1, v0 and/or v1.
+# Call native function.
+# Once done, restore normal stack pointer and return.
+# The return value is passed untouched through r0, r1, v0 and/or v1.
 .macro epilogue
     blr x9
     mov sp, x29
@@ -57,29 +62,21 @@
     .cfi_endproc
 .endm
 
-// Prepare general purpose argument registers from array passed by caller.
+# Prepare general purpose argument registers from array passed by caller.
 .macro forward_int
     ldr x8, [x1, 64]
-    ldr x7, [x1, 56]
-    ldr x6, [x1, 48]
-    ldr x5, [x1, 40]
-    ldr x4, [x1, 32]
-    ldr x3, [x1, 24]
-    ldr x2, [x1, 16]
-    ldr x0, [x1, 0]
-    ldr x1, [x1, 8]
+    ldp x6, x7, [x1, 48]
+    ldp x4, x5, [x1, 32]
+    ldp x2, x3, [x1, 16]
+    ldp x0, x1, [x1, 0]
 .endm
 
-// Prepare vector argument registers from array passed by caller.
+# Prepare vector argument registers from array passed by caller.
 .macro forward_vec
-    ldr d7, [x1, 128]
-    ldr d6, [x1, 120]
-    ldr d5, [x1, 112]
-    ldr d4, [x1, 104]
-    ldr d3, [x1, 96]
-    ldr d2, [x1, 88]
-    ldr d1, [x1, 80]
-    ldr d0, [x1, 72]
+    ldp d6, d7, [x1, 120]
+    ldp d4, d5, [x1, 104]
+    ldp d2, d3, [x1, 88]
+    ldp d0, d1, [x1, 72]
 .endm
 
 SYMBOL(ForwardCallGG):
@@ -114,3 +111,204 @@ SYMBOL(ForwardCallXDDDD):
     forward_vec
     forward_int
     epilogue
+
+# Callback trampolines
+# ----------------------------
+
+.global SYMBOL(Trampoline0)
+.global SYMBOL(Trampoline1)
+.global SYMBOL(Trampoline2)
+.global SYMBOL(Trampoline3)
+.global SYMBOL(Trampoline4)
+.global SYMBOL(Trampoline5)
+.global SYMBOL(Trampoline6)
+.global SYMBOL(Trampoline7)
+.global SYMBOL(Trampoline8)
+.global SYMBOL(Trampoline9)
+.global SYMBOL(Trampoline10)
+.global SYMBOL(Trampoline11)
+.global SYMBOL(Trampoline12)
+.global SYMBOL(Trampoline13)
+.global SYMBOL(Trampoline14)
+.global SYMBOL(Trampoline15)
+.global SYMBOL(TrampolineX0)
+.global SYMBOL(TrampolineX1)
+.global SYMBOL(TrampolineX2)
+.global SYMBOL(TrampolineX3)
+.global SYMBOL(TrampolineX4)
+.global SYMBOL(TrampolineX5)
+.global SYMBOL(TrampolineX6)
+.global SYMBOL(TrampolineX7)
+.global SYMBOL(TrampolineX8)
+.global SYMBOL(TrampolineX9)
+.global SYMBOL(TrampolineX10)
+.global SYMBOL(TrampolineX11)
+.global SYMBOL(TrampolineX12)
+.global SYMBOL(TrampolineX13)
+.global SYMBOL(TrampolineX14)
+.global SYMBOL(TrampolineX15)
+.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:
+# 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
+    .cfi_startproc
+    stp x29, x30, [sp, -16]!
+    .cfi_def_cfa sp, 16
+    .cfi_offset 29, 16
+    .cfi_offset 30, 8
+    sub sp, sp, #192
+    .cfi_def_cfa sp, 208
+    stp x0, x1, [sp, 0]
+    stp x2, x3, [sp, 16]
+    stp x4, x5, [sp, 32]
+    stp x6, x7, [sp, 48]
+    str x8, [sp, 64]
+    mov x0, \id
+    mov x1, sp
+    add x2, sp, #208
+    add x3, sp, #136
+    bl SYMBOL(RelayCallBack)
+    ldp x0, x1, [sp, 136]
+    add sp, sp, #192
+    .cfi_def_cfa sp, 16
+    ldp x29, x30, [sp], 16
+    .cfi_def_cfa sp, 0
+    .cfi_restore 30
+    .cfi_restore 29
+    ret
+    .cfi_endproc
+.endm
+
+# Same thing, but also forwards the floating-point argument registers and loads them at the end.
+.macro trampoline_vec id
+    .cfi_startproc
+    stp x29, x30, [sp, -16]!
+    .cfi_def_cfa sp, 16
+    .cfi_offset 29, 16
+    .cfi_offset 30, 8
+    sub sp, sp, #192
+    .cfi_def_cfa sp, 208
+    stp x0, x1, [sp, 0]
+    stp x2, x3, [sp, 16]
+    stp x4, x5, [sp, 32]
+    stp x6, x7, [sp, 48]
+    str x8, [sp, 64]
+    stp d0, d1, [sp, 72]
+    stp d2, d3, [sp, 88]
+    stp d4, d5, [sp, 104]
+    stp d6, d7, [sp, 120]
+    mov x0, \id
+    mov x1, sp
+    add x2, sp, #208
+    add x3, sp, #136
+    bl SYMBOL(RelayCallBack)
+    ldp x0, x1, [sp, 136]
+    ldp d0, d1, [sp, 152]
+    ldp d2, d3, [sp, 168]
+    add sp, sp, #192
+    .cfi_def_cfa sp, 16
+    ldp x29, x30, [sp], 16
+    .cfi_def_cfa sp, 0
+    .cfi_restore 30
+    .cfi_restore 29
+    ret
+    .cfi_endproc
+.endm
+
+SYMBOL(Trampoline0):
+    trampoline 0
+SYMBOL(Trampoline1):
+    trampoline 1
+SYMBOL(Trampoline2):
+    trampoline 2
+SYMBOL(Trampoline3):
+    trampoline 3
+SYMBOL(Trampoline4):
+    trampoline 4
+SYMBOL(Trampoline5):
+    trampoline 5
+SYMBOL(Trampoline6):
+    trampoline 6
+SYMBOL(Trampoline7):
+    trampoline 7
+SYMBOL(Trampoline8):
+    trampoline 8
+SYMBOL(Trampoline9):
+    trampoline 9
+SYMBOL(Trampoline10):
+    trampoline 10
+SYMBOL(Trampoline11):
+    trampoline 11
+SYMBOL(Trampoline12):
+    trampoline 12
+SYMBOL(Trampoline13):
+    trampoline 13
+SYMBOL(Trampoline14):
+    trampoline 14
+SYMBOL(Trampoline15):
+    trampoline 15
+
+SYMBOL(TrampolineX0):
+    trampoline_vec 0
+SYMBOL(TrampolineX1):
+    trampoline_vec 1
+SYMBOL(TrampolineX2):
+    trampoline_vec 2
+SYMBOL(TrampolineX3):
+    trampoline_vec 3
+SYMBOL(TrampolineX4):
+    trampoline_vec 4
+SYMBOL(TrampolineX5):
+    trampoline_vec 5
+SYMBOL(TrampolineX6):
+    trampoline_vec 6
+SYMBOL(TrampolineX7):
+    trampoline_vec 7
+SYMBOL(TrampolineX8):
+    trampoline_vec 8
+SYMBOL(TrampolineX9):
+    trampoline_vec 9
+SYMBOL(TrampolineX10):
+    trampoline_vec 10
+SYMBOL(TrampolineX11):
+    trampoline_vec 11
+SYMBOL(TrampolineX12):
+    trampoline_vec 12
+SYMBOL(TrampolineX13):
+    trampoline_vec 13
+SYMBOL(TrampolineX14):
+    trampoline_vec 14
+SYMBOL(TrampolineX15):
+    trampoline_vec 15
+
+# When a callback is relayed, Koffi will call into Node.js and V8 to execute Javascript.
+# The propblem is that we're still running on the separate Koffi stack, and V8 will
+# preobably 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 (x0, x1, x2) are passed through untouched.
+SYMBOL(CallSwitchStack):
+    .cfi_startproc
+    stp x29, x30, [sp, -16]!
+    .cfi_def_cfa sp, 16
+    .cfi_offset 29, 16
+    .cfi_offset 30, 8
+    mov x29, sp
+    ldr x9, [x4, 0]
+    sub x9, sp, x9
+    and x9, x9, #-16
+    str x9, [x4, 8]
+    mov sp, x3
+    blr x5
+    mov sp, x29
+    .cfi_def_cfa sp, 16
+    ldp x29, x30, [sp], 16
+    .cfi_def_cfa sp, 0
+    .cfi_restore 30
+    .cfi_restore 29
+    ret
+    .cfi_endproc

package/src/abi_arm64_fwd.asm

@@ -13,6 +13,20 @@
 
     AREA |.text|, CODE
 
+; Forward
+; ----------------------------
+
+    ; These three are the same, but they differ (in the C side) by their return type.
+    ; Unlike the three next functions, these ones don't forward XMM argument registers.
+    EXPORT ForwardCallGG
+    EXPORT ForwardCallF
+    EXPORT ForwardCallDDDD
+
+    ; The X variants are slightly slower, and are used when XMM arguments must be forwarded.
+    EXPORT ForwardCallXGG
+    EXPORT ForwardCallXF
+    EXPORT ForwardCallXDDDD
+
     ; Copy function pointer to r9, in order to save it through argument forwarding.
     ; Save RSP in r29 (non-volatile), and use carefully assembled stack provided by caller.
     MACRO
@@ -41,28 +55,20 @@
     forward_int
 
     ldr x8, [x1, 64]
-    ldr x7, [x1, 56]
-    ldr x6, [x1, 48]
-    ldr x5, [x1, 40]
-    ldr x4, [x1, 32]
-    ldr x3, [x1, 24]
-    ldr x2, [x1, 16]
-    ldr x0, [x1, 0]
-    ldr x1, [x1, 8]
+    ldp x6, x7, [x1, 48]
+    ldp x4, x5, [x1, 32]
+    ldp x2, x3, [x1, 16]
+    ldp x0, x1, [x1, 0]
     MEND
 
     ; Prepare vector argument registers from array passed by caller.
     MACRO
     forward_vec
 
-    ldr d7, [x1, 128]
-    ldr d6, [x1, 120]
-    ldr d5, [x1, 112]
-    ldr d4, [x1, 104]
-    ldr d3, [x1, 96]
-    ldr d2, [x1, 88]
-    ldr d1, [x1, 80]
-    ldr d0, [x1, 72]
+    ldp d6, d7, [x1, 120]
+    ldp d4, d5, [x1, 104]
+    ldp d2, d3, [x1, 88]
+    ldp d0, d1, [x1, 72]
     MEND
 
 ForwardCallGG PROC
@@ -104,4 +110,214 @@ ForwardCallXDDDD PROC
     epilogue
     ENDP
 
+; Callback trampolines
+; ----------------------------
+
+    EXPORT Trampoline0
+    EXPORT Trampoline1
+    EXPORT Trampoline2
+    EXPORT Trampoline3
+    EXPORT Trampoline4
+    EXPORT Trampoline5
+    EXPORT Trampoline6
+    EXPORT Trampoline7
+    EXPORT Trampoline8
+    EXPORT Trampoline9
+    EXPORT Trampoline10
+    EXPORT Trampoline11
+    EXPORT Trampoline12
+    EXPORT Trampoline13
+    EXPORT Trampoline14
+    EXPORT Trampoline15
+    EXPORT TrampolineX0
+    EXPORT TrampolineX1
+    EXPORT TrampolineX2
+    EXPORT TrampolineX3
+    EXPORT TrampolineX4
+    EXPORT TrampolineX5
+    EXPORT TrampolineX6
+    EXPORT TrampolineX7
+    EXPORT TrampolineX8
+    EXPORT TrampolineX9
+    EXPORT TrampolineX10
+    EXPORT TrampolineX11
+    EXPORT TrampolineX12
+    EXPORT TrampolineX13
+    EXPORT TrampolineX14
+    EXPORT TrampolineX15
+    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:
+    ; 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
+
+    stp x29, x30, [sp, -16]!
+    sub sp, sp, #192
+    stp x0, x1, [sp, 0]
+    stp x2, x3, [sp, 16]
+    stp x4, x5, [sp, 32]
+    stp x6, x7, [sp, 48]
+    str x8, [sp, 64]
+    mov x0, $ID
+    mov x1, sp
+    add x2, sp, #208
+    add x3, sp, #136
+    bl RelayCallBack
+    ldp x0, x1, [sp, 136]
+    add sp, sp, #192
+    ldp x29, x30, [sp], 16
+    ret
+    MEND
+
+    ; Same thing, but also forwards the floating-point argument registers and loads them at the end.
+    MACRO
+    trampoline_vec $ID
+
+    stp x29, x30, [sp, -16]!
+    sub sp, sp, #192
+    stp x0, x1, [sp, 0]
+    stp x2, x3, [sp, 16]
+    stp x4, x5, [sp, 32]
+    stp x6, x7, [sp, 48]
+    str x8, [sp, 64]
+    stp d0, d1, [sp, 72]
+    stp d2, d3, [sp, 88]
+    stp d4, d5, [sp, 104]
+    stp d6, d7, [sp, 120]
+    mov x0, $ID
+    mov x1, sp
+    add x2, sp, #208
+    add x3, sp, #136
+    bl RelayCallBack
+    ldp x0, x1, [sp, 136]
+    ldp d0, d1, [sp, 152]
+    ldp d2, d3, [sp, 168]
+    add sp, sp, #192
+    ldp x29, x30, [sp], 16
+    ret
+    MEND
+
+Trampoline0 PROC
+    trampoline 0
+    ENDP
+Trampoline1 PROC
+    trampoline 1
+    ENDP
+Trampoline2 PROC
+    trampoline 2
+    ENDP
+Trampoline3 PROC
+    trampoline 3
+    ENDP
+Trampoline4 PROC
+    trampoline 4
+    ENDP
+Trampoline5 PROC
+    trampoline 5
+    ENDP
+Trampoline6 PROC
+    trampoline 6
+    ENDP
+Trampoline7 PROC
+    trampoline 7
+    ENDP
+Trampoline8 PROC
+    trampoline 8
+    ENDP
+Trampoline9 PROC
+    trampoline 9
+    ENDP
+Trampoline10 PROC
+    trampoline 10
+    ENDP
+Trampoline11 PROC
+    trampoline 11
+    ENDP
+Trampoline12 PROC
+    trampoline 12
+    ENDP
+Trampoline13 PROC
+    trampoline 13
+    ENDP
+Trampoline14 PROC
+    trampoline 14
+    ENDP
+Trampoline15 PROC
+    trampoline 15
+    ENDP
+
+TrampolineX0 PROC
+    trampoline_vec 0
+    ENDP
+TrampolineX1 PROC
+    trampoline_vec 1
+    ENDP
+TrampolineX2 PROC
+    trampoline_vec 2
+    ENDP
+TrampolineX3 PROC
+    trampoline_vec 3
+    ENDP
+TrampolineX4 PROC
+    trampoline_vec 4
+    ENDP
+TrampolineX5 PROC
+    trampoline_vec 5
+    ENDP
+TrampolineX6 PROC
+    trampoline_vec 6
+    ENDP
+TrampolineX7 PROC
+    trampoline_vec 7
+    ENDP
+TrampolineX8 PROC
+    trampoline_vec 8
+    ENDP
+TrampolineX9 PROC
+    trampoline_vec 9
+    ENDP
+TrampolineX10 PROC
+    trampoline_vec 10
+    ENDP
+TrampolineX11 PROC
+    trampoline_vec 11
+    ENDP
+TrampolineX12 PROC
+    trampoline_vec 12
+    ENDP
+TrampolineX13 PROC
+    trampoline_vec 13
+    ENDP
+TrampolineX14 PROC
+    trampoline_vec 14
+    ENDP
+TrampolineX15 PROC
+    trampoline_vec 15
+    ENDP
+
+; When a callback is relayed, Koffi will call into Node.js and V8 to execute Javascript.
+; The propblem is that we're still running on the separate Koffi stack, and V8 will
+; preobably 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 (x0, x1, x2) are passed through untouched.
+CallSwitchStack PROC
+    stp x29, x30, [sp, -16]!
+    mov x29, sp
+    ldr x9, [x4, 0]
+    sub x9, sp, x9
+    and x9, x9, #-16
+    str x9, [x4, 8]
+    mov sp, x3
+    blr x5
+    mov sp, x29
+    ldp x29, x30, [sp], 16
+    ret
+    ENDP
+
     END