koffi 2.3.8 → 2.3.10-beta.1

package/src/koffi/src/abi_riscv64.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 __riscv_xlen == 64
 
@@ -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 inline void ExpandPair(const uint8_t raw[16], int size1, int size2, uint64_t out_regs[2])
 {

package/src/koffi/src/abi_riscv64_asm.S

@@ -0,0 +1,239 @@
+# 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.
+
+#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 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.
+.global ForwardCallXGG
+.global ForwardCallXF
+.global ForwardCallXDG
+.global ForwardCallXGD
+.global ForwardCallXDD
+
+# 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.
+.macro epilogue
+    jalr t0
+    mv sp, s1
+    ld ra, 0(sp)
+    ld s1, 8(sp)
+    addi sp, sp, 16
+    ret
+.endm
+
+# Prepare general purpose argument registers from array passed by caller.
+.macro forward_gpr
+    ld a7, 120(a1)
+    ld a6, 112(a1)
+    ld a5, 104(a1)
+    ld a4, 96(a1)
+    ld a3, 88(a1)
+    ld a2, 80(a1)
+    ld a0, 64(a1)
+    ld a1, 72(a1)
+.endm
+
+# Prepare vector argument registers from array passed by caller.
+.macro forward_vec
+    fld fa7, 56(a1)
+    fld fa6, 48(a1)
+    fld fa5, 40(a1)
+    fld fa4, 32(a1)
+    fld fa3, 24(a1)
+    fld fa2, 16(a1)
+    fld fa1, 8(a1)
+    fld fa0, 0(a1)
+.endm
+
+ForwardCallGG:
+    prologue
+    forward_gpr
+    epilogue
+
+ForwardCallF:
+    prologue
+    forward_gpr
+    epilogue
+
+ForwardCallDG:
+    prologue
+    forward_gpr
+    epilogue
+
+ForwardCallGD:
+    prologue
+    forward_gpr
+    epilogue
+
+ForwardCallDD:
+    prologue
+    forward_gpr
+    epilogue
+
+ForwardCallXGG:
+    prologue
+    forward_vec
+    forward_gpr
+    epilogue
+
+ForwardCallXF:
+    prologue
+    forward_vec
+    forward_gpr
+    epilogue
+
+ForwardCallXDG:
+    prologue
+    forward_vec
+    forward_gpr
+    epilogue
+
+ForwardCallXGD:
+    prologue
+    forward_vec
+    forward_gpr
+    epilogue
+
+ForwardCallXDD:
+    prologue
+    forward_vec
+    forward_gpr
+    epilogue
+
+# Callbacks
+# ----------------------------
+
+.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
+
+# 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 (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
+
+# Trampolines
+# ----------------------------
+
+#include "trampolines/gnu.inc"

package/src/koffi/src/abi_x64_sysv.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(__x86_64__) && !defined(_WIN32)
 
@@ -69,7 +77,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 inline RegisterClass MergeClasses(RegisterClass cls1, RegisterClass cls2)
 {

package/src/koffi/src/abi_x64_sysv_asm.S

@@ -0,0 +1,272 @@
+# 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
+# ----------------------------
+
+# These five are the same, but they differ (in the C side) by their return type.
+# Unlike the five next functions, these ones don't forward XMM argument registers.
+.global SYMBOL(ForwardCallGG)
+.global SYMBOL(ForwardCallF)
+.global SYMBOL(ForwardCallDG)
+.global SYMBOL(ForwardCallGD)
+.global SYMBOL(ForwardCallDD)
+
+# The X variants are slightly slower, and are used when XMM arguments must be forwarded.
+.global SYMBOL(ForwardCallXGG)
+.global SYMBOL(ForwardCallXF)
+.global SYMBOL(ForwardCallXDG)
+.global SYMBOL(ForwardCallXGD)
+.global SYMBOL(ForwardCallXDD)
+
+#define ENDBR64 .byte 0xf3, 0x0f, 0x1e, 0xfa
+
+# Copy function pointer to R11, 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.
+.macro prologue
+    .cfi_startproc
+    .cfi_def_cfa rsp, 8
+    ENDBR64
+    movq %rdi, %r11
+    pushq %rbp
+    .cfi_def_cfa rsp, 16
+    movq %rsp, (%rdx)
+    movq %rsp, %rbp
+    .cfi_def_cfa rbp, 16
+    leaq 112(%rsi), %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 *%r11
+    movq %rbp, %rsp
+    popq %rbp
+    .cfi_def_cfa rsp, 8
+    ret
+    .cfi_endproc
+.endm
+
+# Prepare integer argument registers from array passed by caller.
+.macro forward_gpr
+    movq 40(%rsi), %r9
+    movq 32(%rsi), %r8
+    movq 24(%rsi), %rcx
+    movq 16(%rsi), %rdx
+    movq 0(%rsi), %rdi
+    movq 8(%rsi), %rsi
+.endm
+
+# Prepare XMM argument registers from array passed by caller.
+.macro forward_xmm
+    movsd 104(%rsi), %xmm7
+    movsd 96(%rsi), %xmm6
+    movsd 88(%rsi), %xmm5
+    movsd 80(%rsi), %xmm4
+    movsd 72(%rsi), %xmm3
+    movsd 64(%rsi), %xmm2
+    movsd 56(%rsi), %xmm1
+    movsd 48(%rsi), %xmm0
+.endm
+
+SYMBOL(ForwardCallGG):
+    prologue
+    forward_gpr
+    movb $0, %al
+    epilogue
+
+SYMBOL(ForwardCallF):
+    prologue
+    forward_gpr
+    movb $0, %al
+    epilogue
+
+SYMBOL(ForwardCallDG):
+    prologue
+    forward_gpr
+    movb $0, %al
+    epilogue
+
+SYMBOL(ForwardCallGD):
+    prologue
+    forward_gpr
+    movb $0, %al
+    epilogue
+
+SYMBOL(ForwardCallDD):
+    prologue
+    forward_gpr
+    movb $0, %al
+    epilogue
+
+SYMBOL(ForwardCallXGG):
+    prologue
+    forward_xmm
+    forward_gpr
+    movb $8, %al
+    epilogue
+
+SYMBOL(ForwardCallXF):
+    prologue
+    forward_xmm
+    forward_gpr
+    movb $8, %al
+    epilogue
+
+SYMBOL(ForwardCallXDG):
+    prologue
+    forward_xmm
+    forward_gpr
+    movb $8, %al
+    epilogue
+
+SYMBOL(ForwardCallXGD):
+    prologue
+    forward_xmm
+    forward_gpr
+    movb $8, %al
+    epilogue
+
+SYMBOL(ForwardCallXDD):
+    prologue
+    forward_xmm
+    forward_gpr
+    movb $8, %al
+    epilogue
+
+# Callbacks
+# ----------------------------
+
+.global SYMBOL(RelayCallback)
+.global SYMBOL(CallSwitchStack)
+
+# First, make a copy of the GPR argument registers (rdi, rsi, rdx, rcx, r8, r9).
+# 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
+    .cfi_def_cfa rsp, 8
+    ENDBR64
+    subq $152, %rsp
+    .cfi_def_cfa rsp, 160
+    movq %rdi, 0(%rsp)
+    movq %rsi, 8(%rsp)
+    movq %rdx, 16(%rsp)
+    movq %rcx, 24(%rsp)
+    movq %r8, 32(%rsp)
+    movq %r9, 40(%rsp)
+    movq $\id, %rdi
+    movq %rsp, %rsi
+    leaq 160(%rsp), %rdx
+    leaq 112(%rsp), %rcx
+#ifdef __linux__
+    call *RelayCallback@GOTPCREL(%rip)
+#else
+    call SYMBOL(RelayCallback)
+#endif
+    movq 112(%rsp), %rax
+    movq 120(%rsp), %rdx
+    addq $152, %rsp
+    .cfi_def_cfa rsp, 8
+    ret
+    .cfi_endproc
+.endm
+
+# Same thing, but also forward the XMM argument registers and load the XMM result registers.
+.macro trampoline_vec id
+    .cfi_startproc
+    .cfi_def_cfa rsp, 8
+    ENDBR64
+    subq $152, %rsp
+    .cfi_def_cfa rsp, 160
+    movq %rdi, 0(%rsp)
+    movq %rsi, 8(%rsp)
+    movq %rdx, 16(%rsp)
+    movq %rcx, 24(%rsp)
+    movq %r8, 32(%rsp)
+    movq %r9, 40(%rsp)
+    movsd %xmm0, 48(%rsp)
+    movsd %xmm1, 56(%rsp)
+    movsd %xmm2, 64(%rsp)
+    movsd %xmm3, 72(%rsp)
+    movsd %xmm4, 80(%rsp)
+    movsd %xmm5, 88(%rsp)
+    movsd %xmm6, 96(%rsp)
+    movsd %xmm7, 104(%rsp)
+    movq $\id, %rdi
+    movq %rsp, %rsi
+    leaq 160(%rsp), %rdx
+    leaq 112(%rsp), %rcx
+#ifdef __linux__
+    call *RelayCallback@GOTPCREL(%rip)
+#else
+    call SYMBOL(RelayCallback)
+#endif
+    movq 112(%rsp), %rax
+    movq 120(%rsp), %rdx
+    movsd 128(%rsp), %xmm0
+    movsd 136(%rsp), %xmm1
+    addq $152, %rsp
+    .cfi_def_cfa rsp, 8
+    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 (rdi, rsi, rdx) are passed through untouched.
+SYMBOL(CallSwitchStack):
+    .cfi_startproc
+    .cfi_def_cfa rsp, 8
+    ENDBR64
+    push %rbp
+    .cfi_def_cfa rsp, 16
+    movq %rsp, %rbp
+    movq %rsp, %r10
+    subq 0(%r8), %r10
+    andq $-16, %r10
+    movq %r10, 8(%r8)
+    movq %rcx, %rsp
+    .cfi_def_cfa rsp, 16
+    call *%r9
+    mov %rbp, %rsp
+    .cfi_def_cfa rsp, 16
+    pop %rbp
+    .cfi_def_cfa rsp, 8
+    ret
+    .cfi_endproc
+
+# Trampolines
+# ----------------------------
+
+#include "trampolines/gnu.inc"

package/src/koffi/src/abi_x64_win.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(_WIN32) && (defined(__x86_64__) || defined(_M_AMD64))
 
@@ -39,7 +47,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"
 
 bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
 {