@psnext/slingcli 2.4.20260526-1 → 2.4.20260527-2

package/node_modules/koffi/src/koffi/src/abi_x86_asm.S

@@ -1,193 +0,0 @@
-# SPDX-License-Identifier: MIT
-# SPDX-FileCopyrightText: 2025 Niels Martignène <niels.martignene@protonmail.com>
-
-#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 SwitchAndRelay
-.global RelayDirect
-.global FindTrampolineStart
-.global FindTrampolineEnd
-
-# 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.
-# We need to branch at the end to avoid x87 stack imbalance.
-.macro trampoline id
-    .cfi_startproc
-    ENDBR32
-    movl $\id, %eax
-    jmp RelayTrampoline
-    .cfi_endproc
-.endm
-
-RelayTrampoline:
-    .cfi_startproc
-    .cfi_def_cfa esp, 4
-    sub $44, %esp
-    .cfi_def_cfa esp, 48
-    movl %eax, 0(%esp)
-    movl %esp, 4(%esp)
-    movl $0, 32(%esp)
-    movl $0, 36(%esp)
-    call GetEIP
-    addl $_GLOBAL_OFFSET_TABLE_, %eax
-    call *RelayCallback@GOT(%eax)
-    movl 44(%esp), %edx
-    movl 36(%esp), %ecx
-    movl %edx, 44(%esp, %ecx)
-    cmpl $1, 32(%esp)
-    je 1f
-    cmpl $2, 32(%esp)
-    je 2f
-0:
-    movl 16(%esp), %eax
-    movl 20(%esp), %edx
-    leal 44(%esp, %ecx), %esp
-    .cfi_def_cfa esp, 4
-    ret
-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
-
-# 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.
-SwitchAndRelay:
-    .cfi_startproc
-    .cfi_def_cfa esp, 4
-    ENDBR32
-    push %ebp
-    .cfi_def_cfa esp, 8
-    movl %esp, %ebp
-    .cfi_def_cfa ebp, 8
-    movl 24(%esp), %ecx
-    movl %esp, %eax
-    subl 0(%ecx), %eax
-    andl $-16, %eax
-    movl %eax, 4(%ecx)
-    movl 20(%esp), %esp
-    subl $24, %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 GetEIP
-    addl $_GLOBAL_OFFSET_TABLE_, %eax
-    call *RelayDirect@GOT(%eax)
-    mov %ebp, %esp
-    .cfi_def_cfa esp, 8
-    pop %ebp
-    .cfi_def_cfa esp, 4
-    ret
-    .cfi_endproc
-
-.balign 16
-FindTrampolineStart:
-    call GetEIP
-    addl $16, %eax
-    andl $0xFFFFFFF0, %eax
-    ret
-.balign 16
-
-#include "gnu.inc"
-
-FindTrampolineEnd:
-    call GetEIP
-    ret
-
-GetEIP:
-    movl (%esp), %eax
-    ret

package/node_modules/koffi/src/koffi/src/abi_x86_asm.asm

@@ -1,177 +0,0 @@
-; SPDX-License-Identifier: MIT
-; SPDX-FileCopyrightText: 2025 Niels Martignène <niels.martignene@protonmail.com>
-
-; 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 SwitchAndRelay
-extern RelayDirect : PROC
-
-; 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.
-; We need to branch at the end to avoid x87 stack imbalance.
-trampoline macro ID
-    endbr32
-    mov eax, ID
-    jmp RelayTrampoline
-endm
-
-RelayTrampoline proc
-    sub esp, 44
-    mov dword ptr [esp+0], eax
-    mov dword ptr [esp+4], esp
-    mov dword ptr [esp+32], 0
-    mov dword ptr [esp+36], 0
-    call RelayCallback
-    mov edx, dword ptr [esp+44]
-    mov ecx, dword ptr [esp+36]
-    mov dword ptr [esp+ecx+44], edx
-    cmp dword ptr [esp+32], 1
-    je l1
-    cmp dword ptr [esp+32], 2
-    je l2
-l0:
-    mov eax, dword ptr [esp+16]
-    mov edx, dword ptr [esp+20]
-    lea esp, dword ptr [esp+ecx+44]
-    ret
-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
-RelayTrampoline endp
-
-; 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.
-SwitchAndRelay proc
-    endbr32
-    push ebp
-    mov ebp, esp
-    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, 24
-    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 RelayDirect
-    mov esp, ebp
-    pop ebp
-    ret
-SwitchAndRelay endp
-
-align 16
-FindTrampolineStart proc
-    call GetEIP
-    add eax, 16
-    and eax, 0FFFFFFF0h
-    ret
-FindTrampolineStart endp
-align 16
-
-include masm32.inc
-
-FindTrampolineEnd proc
-    call GetEIP
-    ret
-FindTrampolineEnd endp
-
-GetEIP proc
-    mov eax, dword ptr [esp]
-    ret
-GetEIP endp
-
-end