koffi 2.3.8 → 2.3.10-beta.1

package/src/koffi/src/abi_arm32_asm.S

@@ -0,0 +1,211 @@
+# Copyright 2023 Niels Martignène <niels.martignene@protonmail.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of
+# this software and associated documentation files (the “Software”), to deal in 
+# the Software without restriction, including without limitation the rights to use,
+# copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
+# Software, and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+# OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+# OTHER DEALINGS IN THE SOFTWARE.
+
+.syntax unified
+
+#define SYMBOL(Symbol) Symbol
+
+# 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 ForwardCallGG
+.global ForwardCallF
+.global ForwardCallDDDD
+
+# The X variants are slightly slower, and are used when XMM arguments must be forwarded.
+.global ForwardCallXGG
+.global ForwardCallXF
+.global ForwardCallXDDDD
+
+# Copy function pointer to r12, 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 fp (non-volatile), and use carefully assembled stack provided by caller.
+.macro prologue
+    .cfi_startproc
+    push {fp, lr}
+    .cfi_def_cfa sp, 8
+    .cfi_offset 11, 4
+    .cfi_offset 14, 8
+    mov fp, sp
+    .cfi_def_cfa fp, 8
+    str fp, [r2, 0]
+    mov r12, r0
+    mov sp, r1
+    add sp, sp, #80
+.endm
+
+# Call native function.
+# Once done, restore normal stack pointer and return.
+# The return value is passed untouched through r0, r1, and or FP registers
+.macro epilogue
+    blx r12
+    mov sp, fp
+    .cfi_def_cfa sp, 8
+    pop {fp, lr}
+    .cfi_def_cfa sp, 0
+    .cfi_restore 11
+    .cfi_restore 14
+    bx lr
+    .cfi_endproc
+.endm
+
+ForwardCallGG:
+    prologue
+    add r1, r1, #64
+    ldmia r1, {r0-r3}
+    epilogue
+
+ForwardCallF:
+    prologue
+    add r1, r1, #64
+    ldmia r1, {r0-r3}
+    epilogue
+
+ForwardCallDDDD:
+    prologue
+    add r1, r1, #64
+    ldmia r1, {r0-r3}
+    epilogue
+
+ForwardCallXGG:
+    prologue
+    vldmia r1!, {d0-d7}
+    ldmia r1, {r0-r3}
+    epilogue
+
+ForwardCallXF:
+    prologue
+    vldmia r1!, {d0-d7}
+    ldmia r1, {r0-r3}
+    epilogue
+
+ForwardCallXDDDD:
+    prologue
+    vldmia r1!, {d0-d7}
+    ldmia r1, {r0-r3}
+    epilogue
+
+# Callbacks
+# ----------------------------
+
+.global RelayCallback
+.global CallSwitchStack
+
+# First, make a copy of the GPR argument registers (r0 to r7).
+# 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
+    push {fp, lr}
+    .cfi_def_cfa sp, 8
+    .cfi_offset 11, 4
+    .cfi_offset 14, 8
+    sub sp, sp, #120
+    .cfi_def_cfa sp, 128
+    add r12, sp, 64
+    stmia r12!, {r0-r3}
+    mov r0, \id
+    mov r1, sp
+    add r2, sp, #128
+    mov r3, r12
+    bl RelayCallback
+    add sp, sp, #80
+    ldmia sp!, {r0-r1}
+    add sp, sp, #32
+    .cfi_def_cfa sp, 8
+    pop {fp, lr}
+    .cfi_def_cfa sp, 0
+    .cfi_restore 11
+    .cfi_restore 14
+    bx lr
+    .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
+    push {fp, lr}
+    .cfi_def_cfa sp, 8
+    .cfi_offset 11, 4
+    .cfi_offset 14, 8
+    sub sp, sp, #120
+    .cfi_def_cfa sp, 128
+    mov r12, sp
+    vstmia r12!, {d0-d7}
+    stmia r12!, {r0-r3}
+    mov r0, \id
+    mov r1, sp
+    add r2, sp, #128
+    mov r3, r12
+    bl RelayCallback
+    add sp, sp, #80
+    ldmia sp!, {r0-r1}
+    vldmia sp!, {d0-d3}
+    .cfi_def_cfa sp, 8
+    pop {fp, lr}
+    .cfi_def_cfa sp, 0
+    .cfi_restore 11
+    .cfi_restore 14
+    bx lr
+    .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
+# 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 (r0, r1, r2) are passed through untouched.
+CallSwitchStack:
+    .cfi_startproc
+    push {fp, lr}
+    .cfi_def_cfa sp, 8
+    push {r4, r5}
+    .cfi_def_cfa sp, 16
+    .cfi_offset 11, 4
+    .cfi_offset 14, 8
+    mov fp, sp
+    ldr r4, [sp, 16]
+    ldr r5, [r4, 0]
+    sub r5, sp, r5
+    and r5, r5, #-16
+    str r5, [r4, 4]
+    ldr r4, [sp, 20]
+    mov sp, r3
+    blx r4
+    mov sp, fp
+    .cfi_def_cfa sp, 16
+    pop {r4, r5}
+    .cfi_def_cfa sp, 8
+    pop {fp, lr}
+    .cfi_def_cfa sp, 0
+    .cfi_restore 11
+    .cfi_restore 14
+    bx lr
+    .cfi_endproc
+
+# Trampolines
+# ----------------------------
+
+#include "trampolines/gnu.inc"

package/src/koffi/src/abi_arm64.cc

@@ -1,15 +1,23 @@
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
+// Copyright 2023 Niels Martignène <niels.martignene@protonmail.com>
 //
-// 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 Lesser General Public License for more details.
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the “Software”), to deal in 
+// the Software without restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
+// Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
 //
-// You should have received a copy of the GNU Lesser General Public License
-// along with this program. If not, see https://www.gnu.org/licenses/.
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
 
 #if defined(__aarch64__) || defined(_M_ARM64)
 
@@ -62,7 +70,7 @@ extern "C" napi_value CallSwitchStack(Napi::Function *func, size_t argc, napi_va
                                       uint8_t *old_sp, Span<uint8_t> *new_stack,
                                       napi_value (*call)(Napi::Function *func, size_t argc, napi_value *argv));
 
-#include "abi_trampolines.inc"
+#include "trampolines/prototypes.inc"
 
 static HfaInfo IsHFA(const TypeInfo *type)
 {

package/src/koffi/src/abi_arm64_asm.S

@@ -0,0 +1,238 @@
+# Copyright 2023 Niels Martignène <niels.martignene@protonmail.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of
+# this software and associated documentation files (the “Software”), to deal in 
+# the Software without restriction, including without limitation the rights to use,
+# copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
+# Software, and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+# OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+# OTHER DEALINGS IN THE SOFTWARE.
+
+#ifdef __APPLE__
+    #define SYMBOL(Symbol) _ ## Symbol
+#else
+    #define SYMBOL(Symbol) Symbol
+#endif
+
+# Forward
+# ----------------------------
+
+#ifdef __APPLE__
+# Fix "arm64 function not 4-byte aligned" linker warnings
+.p2align 2
+#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.
+.global SYMBOL(ForwardCallGG)
+.global SYMBOL(ForwardCallF)
+.global SYMBOL(ForwardCallDDDD)
+
+# 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.
+# 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
+    hint #34
+    stp x29, x30, [sp, -16]!
+    .cfi_def_cfa sp, 16
+    .cfi_offset 29, 16
+    .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.
+.macro epilogue
+    blr x9
+    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
+.endm
+
+# Prepare general purpose argument registers from array passed by caller.
+.macro forward_gpr
+    ldr x8, [x1, 64]
+    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.
+.macro forward_vec
+    ldp d6, d7, [x1, 120]
+    ldp d4, d5, [x1, 104]
+    ldp d2, d3, [x1, 88]
+    ldp d0, d1, [x1, 72]
+.endm
+
+SYMBOL(ForwardCallGG):
+    prologue
+    forward_gpr
+    epilogue
+
+SYMBOL(ForwardCallF):
+    prologue
+    forward_gpr
+    epilogue
+
+SYMBOL(ForwardCallDDDD):
+    prologue
+    forward_gpr
+    epilogue
+
+SYMBOL(ForwardCallXGG):
+    prologue
+    forward_vec
+    forward_gpr
+    epilogue
+
+SYMBOL(ForwardCallXF):
+    prologue
+    forward_vec
+    forward_gpr
+    epilogue
+
+SYMBOL(ForwardCallXDDDD):
+    prologue
+    forward_vec
+    forward_gpr
+    epilogue
+
+# Callbacks
+# ----------------------------
+
+.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
+    hint #34
+    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
+    hint #34
+    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
+
+# 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 (x0, x1, x2) are passed through untouched.
+SYMBOL(CallSwitchStack):
+    .cfi_startproc
+    hint #34
+    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
+
+# Trampolines
+# ----------------------------
+
+#include "trampolines/gnu.inc"

package/src/koffi/src/abi_arm64_asm.asm

@@ -0,0 +1,207 @@
+; Copyright 2023 Niels Martignène <niels.martignene@protonmail.com>
+;
+; Permission is hereby granted, free of charge, to any person obtaining a copy of
+; this software and associated documentation files (the “Software”), to deal in 
+; the Software without restriction, including without limitation the rights to use,
+; copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
+; Software, and to permit persons to whom the Software is furnished to do so,
+; subject to the following conditions:
+;
+; The above copyright notice and this permission notice shall be included in all
+; copies or substantial portions of the Software.
+;
+; THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
+; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+; OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+; FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+; OTHER DEALINGS IN THE SOFTWARE.
+
+    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
+    prologue
+
+    stp x29, x30, [sp, -16]!
+    mov x29, sp
+    str x29, [x2, 0]
+    mov x9, x0
+    add sp, x1, #136
+    MEND
+
+    ; 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
+    ldp x29, x30, [sp], 16
+    ret
+    MEND
+
+    ; Prepare general purpose argument registers from array passed by caller.
+    MACRO
+    forward_gpr
+
+    ldr x8, [x1, 64]
+    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
+
+    ldp d6, d7, [x1, 120]
+    ldp d4, d5, [x1, 104]
+    ldp d2, d3, [x1, 88]
+    ldp d0, d1, [x1, 72]
+    MEND
+
+ForwardCallGG PROC
+    prologue
+    forward_gpr
+    epilogue
+    ENDP
+
+ForwardCallF PROC
+    prologue
+    forward_gpr
+    epilogue
+    ENDP
+
+ForwardCallDDDD PROC
+    prologue
+    forward_gpr
+    epilogue
+    ENDP
+
+ForwardCallXGG PROC
+    prologue
+    forward_vec
+    forward_gpr
+    epilogue
+    ENDP
+
+ForwardCallXF PROC
+    prologue
+    forward_vec
+    forward_gpr
+    epilogue
+    ENDP
+
+ForwardCallXDDDD PROC
+    prologue
+    forward_vec
+    forward_gpr
+    epilogue
+    ENDP
+
+; Callbacks
+; ----------------------------
+
+    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
+
+; 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 (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
+
+; Trampolines
+; ----------------------------
+
+    INCLUDE trampolines/armasm.inc
+
+    END