koffi 2.3.8 → 2.3.9

package/src/koffi/src/abi_x64_win_asm.asm

@@ -0,0 +1,203 @@
+; 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.
+
+; 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.
+public ForwardCallG
+public ForwardCallF
+public ForwardCallD
+
+; The X variants are slightly slower, and are used when XMM arguments must be forwarded.
+public ForwardCallXG
+public ForwardCallXF
+public ForwardCallXD
+
+.code
+
+; Copy function pointer to RAX, 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.
+prologue macro
+    endbr64
+    mov rax, rcx
+    push rbp
+    .pushreg rbp
+    mov rbp, rsp
+    mov qword ptr [r8+0], rsp
+    .setframe rbp, 0
+    .endprolog
+    mov rsp, rdx
+endm
+
+; Call native function.
+; Once done, restore normal stack pointer and return.
+; The return value is passed untouched through RAX or XMM0.
+epilogue macro
+    call rax
+    mov rsp, rbp
+    pop rbp
+    ret
+endm
+
+; Prepare integer argument registers from array passed by caller.
+forward_gpr macro
+    mov r9, qword ptr [rdx+24]
+    mov r8, qword ptr [rdx+16]
+    mov rcx, qword ptr [rdx+0]
+    mov rdx, qword ptr [rdx+8]
+endm
+
+; Prepare XMM argument registers from array passed by caller.
+forward_xmm macro
+    movsd xmm3, qword ptr [rdx+24]
+    movsd xmm2, qword ptr [rdx+16]
+    movsd xmm1, qword ptr [rdx+8]
+    movsd xmm0, qword ptr [rdx+0]
+endm
+
+ForwardCallG proc frame
+    prologue
+    forward_gpr
+    epilogue
+ForwardCallG endp
+
+ForwardCallF proc frame
+    prologue
+    forward_gpr
+    epilogue
+ForwardCallF endp
+
+ForwardCallD proc frame
+    prologue
+    forward_gpr
+    epilogue
+ForwardCallD endp
+
+ForwardCallXG proc frame
+    prologue
+    forward_xmm
+    forward_gpr
+    epilogue
+ForwardCallXG endp
+
+ForwardCallXF proc frame
+    prologue
+    forward_xmm
+    forward_gpr
+    epilogue
+ForwardCallXF endp
+
+ForwardCallXD proc frame
+    prologue
+    forward_xmm
+    forward_gpr
+    epilogue
+ForwardCallXD endp
+
+; Callbacks
+; ----------------------------
+
+extern RelayCallback : PROC
+public CallSwitchStack
+
+; First, make a copy of the GPR argument registers (rcx, rdx, 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.
+trampoline macro ID
+    endbr64
+    sub rsp, 120
+    .allocstack 120
+    .endprolog
+    mov qword ptr [rsp+32], rcx
+    mov qword ptr [rsp+40], rdx
+    mov qword ptr [rsp+48], r8
+    mov qword ptr [rsp+56], r9
+    mov rcx, ID
+    lea rdx, qword ptr [rsp+32]
+    lea r8, qword ptr [rsp+160]
+    lea r9, qword ptr [rsp+96]
+    call RelayCallback
+    mov rax, qword ptr [rsp+96]
+    add rsp, 120
+    ret
+endm
+
+; Same thing, but also forward the XMM argument registers and load the XMM result registers.
+trampoline_vec macro ID
+    endbr64
+    sub rsp, 120
+    .allocstack 120
+    .endprolog
+    mov qword ptr [rsp+32], rcx
+    mov qword ptr [rsp+40], rdx
+    mov qword ptr [rsp+48], r8
+    mov qword ptr [rsp+56], r9
+    movsd qword ptr [rsp+64], xmm0
+    movsd qword ptr [rsp+72], xmm1
+    movsd qword ptr [rsp+80], xmm2
+    movsd qword ptr [rsp+88], xmm3
+    mov rcx, ID
+    lea rdx, qword ptr [rsp+32]
+    lea r8, qword ptr [rsp+160]
+    lea r9, qword ptr [rsp+96]
+    call RelayCallback
+    mov rax, qword ptr [rsp+96]
+    movsd xmm0, qword ptr [rsp+104]
+    add rsp, 120
+    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 (rcx, rdx, r8) are passed through untouched.
+CallSwitchStack proc frame
+    endbr64
+    push rbp
+    .pushreg rbp
+    mov rbp, rsp
+    .setframe rbp, 0
+    .endprolog
+    mov rax, qword ptr [rsp+56]
+    mov r10, rsp
+    mov r11, qword ptr [rsp+48]
+    sub r10, qword ptr [r11+0]
+    and r10, -16
+    mov qword ptr [r11+8], r10
+    lea rsp, [r9-32]
+    call rax
+    mov rsp, rbp
+    pop rbp
+    ret
+CallSwitchStack endp
+
+; Trampolines
+; ----------------------------
+
+include trampolines/masm64.inc
+
+end

package/src/koffi/src/abi_x86.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(__i386__) || defined(_M_IX86)
 
@@ -47,7 +55,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 env, InstanceData *instance, FunctionInfo *func)
 {

package/src/koffi/src/abi_x86_asm.S

@@ -0,0 +1,213 @@
+# 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
+# ----------------------------
+
+.global ForwardCallG
+.global ForwardCallF
+.global ForwardCallD
+.global ForwardCallRG
+.global ForwardCallRF
+.global ForwardCallRD
+
+#define ENDBR32 .byte 0xf3, 0x0f, 0x1e, 0xfb
+
+# Copy function pointer to EAX, 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 ESP in EBX (non-volatile), and use carefully assembled stack provided by caller.
+.macro prologue
+    .cfi_startproc
+    .cfi_def_cfa esp, 4
+    ENDBR32
+    push %ebp
+    .cfi_def_cfa esp, 8
+    movl %esp, %ebp
+    .cfi_def_cfa ebp, 8
+    movl 16(%esp), %eax
+    movl %esp, 0(%eax)
+    movl 8(%esp), %eax
+    movl 12(%esp), %esp
+.endm
+
+.macro fastcall
+    movl 0(%esp), %ecx
+    movl 4(%esp), %edx
+    addl $16, %esp
+.endm
+
+# Call native function.
+# Once done, restore normal stack pointer and return.
+# The return value is passed back untouched.
+.macro epilogue
+    call *%eax
+    movl %ebp, %esp
+    pop %ebp
+    .cfi_def_cfa esp, 4
+    ret
+    .cfi_endproc
+.endm
+
+ForwardCallG:
+    prologue
+    epilogue
+
+ForwardCallF:
+    prologue
+    epilogue
+
+ForwardCallD:
+    prologue
+    epilogue
+
+ForwardCallRG:
+    prologue
+    fastcall
+    epilogue
+
+ForwardCallRF:
+    prologue
+    fastcall
+    epilogue
+
+ForwardCallRD:
+    prologue
+    fastcall
+    epilogue
+
+# Callbacks
+# ----------------------------
+
+.global RelayCallback
+.global CallSwitchStack
+
+# 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,
+# and a pointer to a struct that will contain the result registers.
+# After the call, simply load these registers from the output struct.
+# Depending on ABI, call convention and return value size, we need to issue ret <something>. Since ret
+# only takes an immediate value, and I prefer not to branch, the return address is moved instead according
+# to BackRegisters::ret_pop before ret is issued.
+.macro trampoline id
+    .cfi_startproc
+    .cfi_def_cfa esp, 4
+    ENDBR32
+    sub $44, %esp
+    .cfi_def_cfa esp, 48
+    movl $\id, 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)
+    movl 44(%esp), %edx
+    movl 36(%esp), %ecx
+    movl %edx, 44(%esp, %ecx)
+    movl 16(%esp), %eax
+    movl 20(%esp), %edx
+    leal 44(%esp, %ecx), %esp
+    .cfi_def_cfa esp, 4
+    ret
+    .cfi_endproc
+.endm
+
+# This version also loads the x87 stack with the result, if need be.
+# We have to branch to avoid x87 stack imbalance.
+.macro trampoline_vec id
+    .cfi_startproc
+    .cfi_def_cfa esp, 4
+    ENDBR32
+    sub $44, %esp
+    .cfi_def_cfa esp, 48
+    movl $\id, 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)
+    movl 44(%esp), %edx
+    movl 36(%esp), %ecx
+    movl %edx, 44(%esp, %ecx, 4)
+    cmpb $0, 32(%esp)
+    jne 2f
+1:
+    flds 24(%esp)
+    leal 44(%esp, %ecx), %esp
+    .cfi_def_cfa esp, 4
+    ret
+2:
+    fldl 24(%esp)
+    leal 44(%esp, %ecx), %esp
+    .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:
+    .cfi_startproc
+    .cfi_def_cfa esp, 4
+    ENDBR32
+    push %ebp
+    .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
+    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
+    mov %ebp, %esp
+    .cfi_def_cfa esp, 8
+    pop %ebp
+    .cfi_def_cfa esp, 4
+    ret
+    .cfi_endproc
+
+# Trampolines
+# ----------------------------
+
+#include "trampolines/gnu.inc"

package/src/koffi/src/abi_x86_asm.asm

@@ -0,0 +1,191 @@
+; 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.
+
+; Forward
+; ----------------------------
+
+public ForwardCallG
+public ForwardCallF
+public ForwardCallD
+public ForwardCallRG
+public ForwardCallRF
+public ForwardCallRD
+
+.model flat, C
+.code
+
+; Copy function pointer to EAX, 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 ESP in EBX (non-volatile), and use carefully assembled stack provided by caller.
+prologue macro
+    endbr32
+    push ebp
+    mov ebp, esp
+    mov eax, dword ptr [esp+16]
+    mov dword ptr [eax+0], esp
+    mov eax, dword ptr [esp+8]
+    mov esp, dword ptr [esp+12]
+endm
+
+fastcall macro
+    mov ecx, dword ptr [esp+0]
+    mov edx, dword ptr [esp+4]
+    add esp, 16
+endm
+
+; Call native function.
+; Once done, restore normal stack pointer and return.
+; The return value is passed back untouched.
+epilogue macro
+    call eax
+    mov esp, ebp
+    pop ebp
+    ret
+endm
+
+ForwardCallG proc
+    prologue
+    epilogue
+ForwardCallG endp
+
+ForwardCallF proc
+    prologue
+    epilogue
+ForwardCallF endp
+
+ForwardCallD proc
+    prologue
+    epilogue
+ForwardCallD endp
+
+ForwardCallRG proc
+    prologue
+    fastcall
+    epilogue
+ForwardCallRG endp
+
+ForwardCallRF proc
+    prologue
+    fastcall
+    epilogue
+ForwardCallRF endp
+
+ForwardCallRD proc
+    prologue
+    fastcall
+    epilogue
+ForwardCallRD endp
+
+; Callbacks
+; ----------------------------
+
+extern RelayCallback : PROC
+public CallSwitchStack
+
+; 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,
+; and a pointer to a struct that will contain the result registers.
+; After the call, simply load these registers from the output struct.
+; Depending on ABI, call convention and return value size, we need to issue ret <something>. Since ret
+; only takes an immediate value, and I prefer not to branch, the return address is moved instead according
+; to BackRegisters::ret_pop before ret is issued.
+trampoline macro ID
+    endbr32
+    sub esp, 44
+    mov dword ptr [esp+0], ID
+    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]
+    mov dword ptr [esp+ecx+44], edx
+    mov eax, dword ptr [esp+16]
+    mov edx, dword ptr [esp+20]
+    lea esp, [esp+ecx+44]
+    ret
+endm
+
+; This version also loads the x87 stack with the result, if need be.
+; We have to branch to avoid x87 stack imbalance.
+trampoline_vec macro ID
+    local l1, l2, l3
+
+    endbr32
+    sub esp, 44
+    mov dword ptr [esp+0], ID
+    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]
+    mov dword ptr [esp+ecx+44], edx
+    cmp byte ptr [esp+32], 0
+    jne l2
+l1:
+    fld dword ptr [esp+24]
+    lea esp, dword ptr [esp+ecx+44]
+    ret
+l2:
+    fld qword ptr [esp+24]
+    lea esp, dword ptr [esp+ecx+44]
+    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.
+CallSwitchStack 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
+    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
+    mov esp, ebp
+    pop ebp
+    ret
+CallSwitchStack endp
+
+; Trampolines
+; ----------------------------
+
+include trampolines/masm32.inc
+
+end

package/src/koffi/src/call.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.
 
 #include "src/core/libcc/libcc.hh"
 #include "call.hh"