koffi 1.1.5 → 1.2.0-alpha.3

package/src/abi_x86_fwd.S

@@ -1,15 +1,15 @@
-// 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/.
+# 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/.
 
 .global ForwardCallG
 .global ForwardCallF
@@ -18,17 +18,20 @@
 .global ForwardCallRF
 .global ForwardCallRD
 
-// Copy function pointer to EAX, in order to save it through argument forwarding.
-// Save ESP in EBX (non-volatile), and use carefully assembled stack provided by caller.
+# 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 %ebx
     .cfi_def_cfa esp, 8
-    movl 8(%esp), %eax
     movl %esp, %ebx
     .cfi_def_cfa ebx, 8
+    movl 16(%esp), %eax
+    movl %esp, 0(%eax)
+    movl 8(%esp), %eax
     movl 12(%esp), %esp
 .endm
 
@@ -38,9 +41,9 @@
     addl $16, %esp
 .endm
 
-// Call native function.
-// Once done, restore normal stack pointer and return.
-// The return value is passed back untouched.
+# Call native function.
+# Once done, restore normal stack pointer and return.
+# The return value is passed back untouched.
 .macro epilogue
     call *%eax
     movl %ebx, %esp
@@ -76,3 +79,205 @@ ForwardCallRD:
     prologue
     fastcall
     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
+
+# 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.
+.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 16(%esp), %eax
+    movl 20(%esp), %edx
+    addl $44, %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_x87 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)
+    cmpb $1, 36(%esp)
+    je 2f
+1:
+    flds 32(%esp)
+    jmp 3f
+2:
+    fldl 24(%esp)
+3:
+    movl 16(%esp), %eax
+    movl 20(%esp), %edx
+    addl $44, %esp
+    .cfi_def_cfa esp, 4
+    ret
+    .cfi_endproc
+.endm
+
+GetEIP:
+    movl (%esp), %ecx
+    ret
+
+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_x87 0
+TrampolineX1:
+    trampoline_x87 1
+TrampolineX2:
+    trampoline_x87 2
+TrampolineX3:
+    trampoline_x87 3
+TrampolineX4:
+    trampoline_x87 4
+TrampolineX5:
+    trampoline_x87 5
+TrampolineX6:
+    trampoline_x87 6
+TrampolineX7:
+    trampoline_x87 7
+TrampolineX8:
+    trampoline_x87 8
+TrampolineX9:
+    trampoline_x87 9
+TrampolineX10:
+    trampoline_x87 10
+TrampolineX11:
+    trampoline_x87 11
+TrampolineX12:
+    trampoline_x87 12
+TrampolineX13:
+    trampoline_x87 13
+TrampolineX14:
+    trampoline_x87 14
+TrampolineX15:
+    trampoline_x87 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.
+CallSwitchStack:
+    .cfi_startproc
+    .cfi_def_cfa esp, 4
+    endbr32
+    push %ebx
+    .cfi_def_cfa esp, 8
+    movl %esp, %ebx
+    .cfi_def_cfa ebx, 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 $16, %esp
+    movl 8(%ebx), %eax
+    movl %eax, 0(%esp)
+    movl 12(%ebx), %eax
+    movl %eax, 4(%esp)
+    movl 16(%ebx), %eax
+    movl %eax, 8(%esp)
+    call *%edx
+    mov %ebx, %esp
+    .cfi_def_cfa esp, 8
+    pop %ebx
+    .cfi_def_cfa esp, 4
+    ret
+    .cfi_endproc

package/src/abi_x86_fwd.asm

@@ -11,6 +11,9 @@
 ; 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
+; ----------------------------
+
 public ForwardCallG
 public ForwardCallF
 public ForwardCallD
@@ -22,11 +25,14 @@ public ForwardCallRD
 .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 ebx
     mov ebx, 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
@@ -80,4 +86,216 @@ ForwardCallRD proc
     epilogue
 ForwardCallRD endp
 
+; Callback trampolines
+; ----------------------------
+
+public Trampoline0
+public Trampoline1
+public Trampoline2
+public Trampoline3
+public Trampoline4
+public Trampoline5
+public Trampoline6
+public Trampoline7
+public Trampoline8
+public Trampoline9
+public Trampoline10
+public Trampoline11
+public Trampoline12
+public Trampoline13
+public Trampoline14
+public Trampoline15
+public TrampolineX0
+public TrampolineX1
+public TrampolineX2
+public TrampolineX3
+public TrampolineX4
+public TrampolineX5
+public TrampolineX6
+public TrampolineX7
+public TrampolineX8
+public TrampolineX9
+public TrampolineX10
+public TrampolineX11
+public TrampolineX12
+public TrampolineX13
+public TrampolineX14
+public TrampolineX15
+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.
+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 eax, dword ptr[esp+16]
+    mov edx, dword ptr[esp+20]
+    add esp, 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_x87 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
+    cmp byte ptr[esp+36], 1
+    je l2
+l1:
+    fld dword ptr [esp+32]
+    jmp l3
+l2:
+    fld qword ptr [esp+24]
+l3:
+    mov eax, dword ptr[esp+16]
+    mov edx, dword ptr[esp+20]
+    add esp, 44
+    ret
+endm
+
+Trampoline0 proc
+    trampoline 0
+Trampoline0 endp
+Trampoline1 proc
+    trampoline 1
+Trampoline1 endp
+Trampoline2 proc
+    trampoline 2
+Trampoline2 endp
+Trampoline3 proc
+    trampoline 3
+Trampoline3 endp
+Trampoline4 proc
+    trampoline 4
+Trampoline4 endp
+Trampoline5 proc
+    trampoline 5
+Trampoline5 endp
+Trampoline6 proc
+    trampoline 6
+Trampoline6 endp
+Trampoline7 proc
+    trampoline 7
+Trampoline7 endp
+Trampoline8 proc
+    trampoline 8
+Trampoline8 endp
+Trampoline9 proc
+    trampoline 9
+Trampoline9 endp
+Trampoline10 proc
+    trampoline 10
+Trampoline10 endp
+Trampoline11 proc
+    trampoline 11
+Trampoline11 endp
+Trampoline12 proc
+    trampoline 12
+Trampoline12 endp
+Trampoline13 proc
+    trampoline 13
+Trampoline13 endp
+Trampoline14 proc
+    trampoline 14
+Trampoline14 endp
+Trampoline15 proc
+    trampoline 15
+Trampoline15 endp
+
+TrampolineX0 proc
+    trampoline_x87 0
+TrampolineX0 endp
+TrampolineX1 proc
+    trampoline_x87 1
+TrampolineX1 endp
+TrampolineX2 proc
+    trampoline_x87 2
+TrampolineX2 endp
+TrampolineX3 proc
+    trampoline_x87 3
+TrampolineX3 endp
+TrampolineX4 proc
+    trampoline_x87 4
+TrampolineX4 endp
+TrampolineX5 proc
+    trampoline_x87 5
+TrampolineX5 endp
+TrampolineX6 proc
+    trampoline_x87 6
+TrampolineX6 endp
+TrampolineX7 proc
+    trampoline_x87 7
+TrampolineX7 endp
+TrampolineX8 proc
+    trampoline_x87 8
+TrampolineX8 endp
+TrampolineX9 proc
+    trampoline_x87 9
+TrampolineX9 endp
+TrampolineX10 proc
+    trampoline_x87 10
+TrampolineX10 endp
+TrampolineX11 proc
+    trampoline_x87 11
+TrampolineX11 endp
+TrampolineX12 proc
+    trampoline_x87 12
+TrampolineX12 endp
+TrampolineX13 proc
+    trampoline_x87 13
+TrampolineX13 endp
+TrampolineX14 proc
+    trampoline_x87 14
+TrampolineX14 endp
+TrampolineX15 proc
+    trampoline_x87 15
+TrampolineX15 endp
+
+; 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.
+CallSwitchStack proc
+    endbr32
+    push ebx
+    mov ebx, 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 [ebx+8]
+    mov dword ptr [esp+0], eax
+    mov eax, dword ptr [ebx+12]
+    mov dword ptr [esp+4], eax
+    mov eax, dword ptr [ebx+16]
+    mov dword ptr [esp+8], eax
+    call edx
+    mov esp, ebx
+    pop ebx
+    ret
+CallSwitchStack endp
+
 end

package/src/call.cc

@@ -35,7 +35,9 @@ CallData::~CallData()
     mem->stack = old_stack_mem;
     mem->heap = old_heap_mem;
 
-    if (!--mem->depth && mem->temporary) {
+    instance->free_trampolines |= used_trampolines;
+
+    if (--mem->depth && mem->temporary) {
         delete mem;
     }
 }
@@ -237,14 +239,16 @@ bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t
                 *(const char16_t **)dest = str16;
             } break;
             case PrimitiveKind::Pointer: {
-                if (RG_UNLIKELY(!CheckValueTag(instance, value, member.type))) {
+                if (CheckValueTag(instance, value, member.type)) {
+                    Napi::External external = value.As<Napi::External<void>>();
+                    void *ptr = external.Data();
+                    *(void **)dest = ptr;
+                } else if (IsNullOrUndefined(value)) {
+                    *(void **)dest = nullptr;
+                } else {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected %3", GetValueType(instance, value), member.name, member.type->name);
                     return false;
                 }
-
-                Napi::External external = value.As<Napi::External<void>>();
-                void *ptr = external.Data();
-                *(void **)dest = ptr;
             } break;
             case PrimitiveKind::Record: {
                 if (RG_UNLIKELY(!IsObject(value))) {
@@ -284,6 +288,29 @@ bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t
                 double d = CopyNumber<double>(value);
                 *(double *)dest = d;
             } break;
+            case PrimitiveKind::Callback: {
+                void *ptr;
+
+                if (value.IsFunction()) {
+                    Napi::Function func = value.As<Napi::Function>();
+
+                    Size idx = ReserveTrampoline(member.type->proto, func);
+                    if (RG_UNLIKELY(idx < 0))
+                        return false;
+
+                    ptr = GetTrampoline(idx, member.type->proto);
+                } else if (CheckValueTag(instance, value, member.type)) {
+                    Napi::External external = value.As<Napi::External<void>>();
+                    ptr = external.Data();
+                } else if (IsNullOrUndefined(value)) {
+                    ptr = nullptr;
+                } else {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected %3", GetValueType(instance, value), member.name, member.type->name);
+                    return false;
+                }
+
+                *(void **)dest = ptr;
+            } break;
         }
 
         dest += member.type->size;
@@ -400,9 +427,13 @@ bool CallData::PushArray(const Napi::Value &obj, const TypeInfo *type, uint8_t *
                 });
             } break;
             case PrimitiveKind::Pointer: {
-                PUSH_ARRAY(CheckValueTag(instance, value, type->ref), type->ref->name, {
-                    Napi::External external = value.As<Napi::External<void>>();
-                    *(void **)dest = external.Data();
+                PUSH_ARRAY(CheckValueTag(instance, value, type->ref) || IsNullOrUndefined(value), type->ref->name, {
+                    if (!IsNullOrUndefined(value)) {
+                        Napi::External external = value.As<Napi::External<void>>();
+                        *(void **)dest = external.Data();
+                    } else {
+                        *(void **)dest = nullptr;
+                    }
                 });
             } break;
             case PrimitiveKind::Record: {
@@ -431,6 +462,38 @@ bool CallData::PushArray(const Napi::Value &obj, const TypeInfo *type, uint8_t *
                     *(double *)dest = d;
                 });
             } break;
+            case PrimitiveKind::Callback: {
+                for (uint32_t i = 0; i < len; i++) {
+                    Napi::Value value = array[i];
+
+                    int16_t align = std::max(type->ref->align, realign);
+                    dest = AlignUp(dest, align);
+
+                    void *ptr;
+
+                    if (value.IsFunction()) {
+                        Napi::Function func = value.As<Napi::Function>();
+
+                        Size idx = ReserveTrampoline(type->ref->proto, func);
+                        if (RG_UNLIKELY(idx < 0))
+                            return false;
+
+                        ptr = GetTrampoline(idx, type->ref->proto);
+                    } else if (CheckValueTag(instance, value, type->ref)) {
+                        Napi::External external = value.As<Napi::External<void>>();
+                        ptr = external.Data();
+                    } else if (IsNullOrUndefined(value)) {
+                        ptr = nullptr;
+                    } else {
+                        ThrowError<Napi::TypeError>(env, "Unexpected value %1 in array, expected %2", GetValueType(instance, value), type->ref->name);
+                        return false;
+                    }
+
+                    *(void **)dest = ptr;
+
+                    dest += type->ref->size;
+                }
+            } break;
         }
 
 #undef PUSH_ARRAY
@@ -493,8 +556,29 @@ bool CallData::PushArray(const Napi::Value &obj, const TypeInfo *type, uint8_t *
     return true;
 }
 
+Size CallData::ReserveTrampoline(const FunctionInfo *proto, Napi::Function func)
+{
+    uint32_t idx = CountTrailingZeros(instance->free_trampolines);
+
+    if (RG_UNLIKELY(idx >= MaxTrampolines)) {
+        ThrowError<Napi::Error>(env, "Too many callbacks are in use (max = %1)", MaxTrampolines);
+        return -1;
+    }
+
+    instance->free_trampolines &= ~(1u << idx);
+    used_trampolines |= 1u << idx;
+
+    instance->trampolines[idx].proto = proto;
+    instance->trampolines[idx].func = func;
+
+    return idx;
+}
+
 void CallData::PopObject(Napi::Object obj, const uint8_t *src, const TypeInfo *type, int16_t realign)
 {
+    Napi::Env env = obj.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
     RG_ASSERT(type->primitive == PrimitiveKind::Record);
 
     for (const RecordMember &member: type->members) {
@@ -548,13 +632,18 @@ void CallData::PopObject(Napi::Object obj, const uint8_t *src, const TypeInfo *t
                 const char16_t *str16 = *(const char16_t **)src;
                 obj.Set(member.name, Napi::String::New(env, str16));
             } break;
-            case PrimitiveKind::Pointer: {
+            case PrimitiveKind::Pointer:
+            case PrimitiveKind::Callback: {
                 void *ptr2 = *(void **)src;
 
-                Napi::External<void> external = Napi::External<void>::New(env, ptr2);
-                SetValueTag(instance, external, member.type);
+                if (ptr2) {
+                    Napi::External<void> external = Napi::External<void>::New(env, ptr2);
+                    SetValueTag(instance, external, member.type);
 
-                obj.Set(member.name, external);
+                    obj.Set(member.name, external);
+                } else {
+                    obj.Set(member.name, env.Null());
+                }
             } break;
             case PrimitiveKind::Record: {
                 Napi::Object obj2 = PopObject(src, member.type, realign);
@@ -598,6 +687,8 @@ Size WideStringLength(const char16_t *str16, Size max)
 
 Napi::Value CallData::PopArray(const uint8_t *src, const TypeInfo *type, int16_t realign)
 {
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
     RG_ASSERT(type->primitive == PrimitiveKind::Array);
 
     uint32_t len = type->size / type->ref->size;
@@ -728,14 +819,19 @@ Napi::Value CallData::PopArray(const uint8_t *src, const TypeInfo *type, int16_t
                 array.Set(i, Napi::String::New(env, str16));
             });
         } break;
-        case PrimitiveKind::Pointer: {
+        case PrimitiveKind::Pointer:
+        case PrimitiveKind::Callback: {
             POP_ARRAY({
                 void *ptr2 = *(void **)src;
 
-                Napi::External<void> external = Napi::External<void>::New(env, ptr2);
-                SetValueTag(instance, external, type->ref);
+                if (ptr2) {
+                    Napi::External<void> external = Napi::External<void>::New(env, ptr2);
+                    SetValueTag(instance, external, type->ref);
 
-                array.Set(i, external);
+                    array.Set(i, external);
+                } else {
+                    array.Set(i, env.Null());
+                }
             });
         } break;
         case PrimitiveKind::Record: {