koffi 1.1.5 → 1.2.0-alpha.3

package/src/abi_riscv64_fwd.S

@@ -1,45 +1,50 @@
-// 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/.
-
-// 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 FA argument registers.
+# 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/.
+
+# 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 FA argument registers.
 .global ForwardCallGG
 .global ForwardCallF
 .global ForwardCallDG
 .global ForwardCallGD
 .global ForwardCallDD
 
-// The X variants are slightly slower, and are used when FA arguments must be forwarded.
+# The X variants are slightly slower, and are used when FA arguments must be forwarded.
 .global ForwardCallXGG
 .global ForwardCallXF
 .global ForwardCallXDG
 .global ForwardCallXGD
 .global ForwardCallXDD
 
-// Copy function pointer to t0, in order to save it through argument forwarding.
-// Save SP in s1, and use carefully assembled stack provided by caller.
+# Copy function pointer to t0, 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 SP in s1, and use carefully assembled stack provided by caller.
 .macro prologue
     addi sp, sp, -16
     mv t0, a0
     sd ra, 0(sp)
     sd s1, 8(sp)
     mv s1, sp
+    sd sp, 0(a2)
     addi sp, a1, 128
 .endm
 
-// Call native function.
-// Once done, restore normal stack pointer and return.
-// The return value is passed untouched through registers.
+# Call native function.
+# Once done, restore normal stack pointer and return.
+# The return value is passed untouched through registers.
 .macro epilogue
     jalr t0
     mv sp, s1
@@ -49,7 +54,7 @@
     ret
 .endm
 
-// Prepare general purpose argument registers from array passed by caller.
+# Prepare general purpose argument registers from array passed by caller.
 .macro forward_int
     ld a7, 120(a1)
     ld a6, 112(a1)
@@ -61,7 +66,7 @@
     ld a1, 72(a1)
 .endm
 
-// Prepare vector argument registers from array passed by caller.
+# Prepare vector argument registers from array passed by caller.
 .macro forward_vec
     fld fa7, 56(a1)
     fld fa6, 48(a1)
@@ -127,3 +132,191 @@ ForwardCallXDD:
     forward_vec
     forward_int
     epilogue
+
+# Callback trampolines
+# ----------------------------
+
+.global Trampoline0
+.global Trampoline1
+.global Trampoline2
+.global Trampoline3
+.global Trampoline4
+.global Trampoline5
+.global Trampoline6
+.global Trampoline7
+.global Trampoline8
+.global Trampoline9
+.global Trampoline10
+.global Trampoline11
+.global Trampoline12
+.global Trampoline13
+.global Trampoline14
+.global Trampoline15
+.global TrampolineX0
+.global TrampolineX1
+.global TrampolineX2
+.global TrampolineX3
+.global TrampolineX4
+.global TrampolineX5
+.global TrampolineX6
+.global TrampolineX7
+.global TrampolineX8
+.global TrampolineX9
+.global TrampolineX10
+.global TrampolineX11
+.global TrampolineX12
+.global TrampolineX13
+.global TrampolineX14
+.global TrampolineX15
+.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:
+# 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
+    addi sp, sp, -176
+    sd ra, 0(sp)
+    sd a0, 8(sp)
+    sd a1, 16(sp)
+    sd a2, 24(sp)
+    sd a3, 32(sp)
+    sd a4, 40(sp)
+    sd a5, 48(sp)
+    sd a6, 56(sp)
+    sd a7, 64(sp)
+    li a0, \id
+    addi a1, sp, 8
+    addi a2, sp, 176
+    addi a3, sp, 136
+    jal RelayCallBack
+    ld ra, 0(sp)
+    ld a0, 136(sp)
+    ld a1, 144(sp)
+    addi sp, sp, 176
+    ret
+.endm
+
+# Same thing, but also forwards the floating-point argument registers and loads them at the end.
+.macro trampoline_vec id
+    addi sp, sp, -176
+    sd ra, 0(sp)
+    sd a0, 8(sp)
+    sd a1, 16(sp)
+    sd a2, 24(sp)
+    sd a3, 32(sp)
+    sd a4, 40(sp)
+    sd a5, 48(sp)
+    sd a6, 56(sp)
+    sd a7, 64(sp)
+    fsd fa0, 72(sp)
+    fsd fa1, 80(sp)
+    fsd fa2, 88(sp)
+    fsd fa3, 96(sp)
+    fsd fa4, 104(sp)
+    fsd fa5, 112(sp)
+    fsd fa6, 120(sp)
+    fsd fa7, 128(sp)
+    li a0, \id
+    addi a1, sp, 8
+    addi a2, sp, 176
+    addi a3, sp, 136
+    jal RelayCallBack
+    ld ra, 0(sp)
+    ld a0, 136(sp)
+    ld a1, 144(sp)
+    fld fa0, 152(sp)
+    fld fa1, 160(sp)
+    addi sp, sp, 176
+    ret
+.endm
+
+Trampoline0:
+    trampoline 0
+Trampoline1:
+    trampoline 1
+Trampoline2:
+    trampoline 2
+Trampoline3:
+    trampoline 3
+Trampoline4:
+    trampoline 4
+Trampoline5:
+    trampoline 5
+Trampoline6:
+    trampoline 6
+Trampoline7:
+    trampoline 7
+Trampoline8:
+    trampoline 8
+Trampoline9:
+    trampoline 9
+Trampoline10:
+    trampoline 10
+Trampoline11:
+    trampoline 11
+Trampoline12:
+    trampoline 12
+Trampoline13:
+    trampoline 13
+Trampoline14:
+    trampoline 14
+Trampoline15:
+    trampoline 15
+
+TrampolineX0:
+    trampoline_vec 0
+TrampolineX1:
+    trampoline_vec 1
+TrampolineX2:
+    trampoline_vec 2
+TrampolineX3:
+    trampoline_vec 3
+TrampolineX4:
+    trampoline_vec 4
+TrampolineX5:
+    trampoline_vec 5
+TrampolineX6:
+    trampoline_vec 6
+TrampolineX7:
+    trampoline_vec 7
+TrampolineX8:
+    trampoline_vec 8
+TrampolineX9:
+    trampoline_vec 9
+TrampolineX10:
+    trampoline_vec 10
+TrampolineX11:
+    trampoline_vec 11
+TrampolineX12:
+    trampoline_vec 12
+TrampolineX13:
+    trampoline_vec 13
+TrampolineX14:
+    trampoline_vec 14
+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 (a0, a1, a2) are passed through untouched.
+CallSwitchStack:
+    addi sp, sp, -16
+    sd ra, 0(sp)
+    sd s1, 8(sp)
+    mv s1, sp
+    ld t0, 0(a4)
+    sub t0, sp, t0
+    andi t0, t0, -16
+    sd t0, 8(a4)
+    mv sp, a3
+    jalr a5
+    mv sp, s1
+    ld ra, 0(sp)
+    ld s1, 8(sp)
+    addi sp, sp, 16
+    ret