koffi 1.1.5 → 1.2.0-alpha.3

package/src/abi_x64_win.cc

@@ -22,12 +22,60 @@
 
 namespace RG {
 
-extern "C" uint64_t ForwardCallG(const void *func, uint8_t *sp);
-extern "C" float ForwardCallF(const void *func, uint8_t *sp);
-extern "C" double ForwardCallD(const void *func, uint8_t *sp);
-extern "C" uint64_t ForwardCallXG(const void *func, uint8_t *sp);
-extern "C" float ForwardCallXF(const void *func, uint8_t *sp);
-extern "C" double ForwardCallXD(const void *func, uint8_t *sp);
+struct BackRegisters {
+    uint64_t rax;
+    double xmm0;
+};
+
+extern "C" uint64_t ForwardCallG(const void *func, uint8_t *sp, uint8_t **out_old_sp);
+extern "C" float ForwardCallF(const void *func, uint8_t *sp, uint8_t **out_old_sp);
+extern "C" double ForwardCallD(const void *func, uint8_t *sp, uint8_t **out_old_sp);
+extern "C" uint64_t ForwardCallXG(const void *func, uint8_t *sp, uint8_t **out_old_sp);
+extern "C" float ForwardCallXF(const void *func, uint8_t *sp, uint8_t **out_old_sp);
+extern "C" double ForwardCallXD(const void *func, uint8_t *sp, uint8_t **out_old_sp);
+
+extern "C" int Trampoline0; extern "C" int TrampolineX0;
+extern "C" int Trampoline1; extern "C" int TrampolineX1;
+extern "C" int Trampoline2; extern "C" int TrampolineX2;
+extern "C" int Trampoline3; extern "C" int TrampolineX3;
+extern "C" int Trampoline4; extern "C" int TrampolineX4;
+extern "C" int Trampoline5; extern "C" int TrampolineX5;
+extern "C" int Trampoline6; extern "C" int TrampolineX6;
+extern "C" int Trampoline7; extern "C" int TrampolineX7;
+extern "C" int Trampoline8; extern "C" int TrampolineX8;
+extern "C" int Trampoline9; extern "C" int TrampolineX9;
+extern "C" int Trampoline10; extern "C" int TrampolineX10;
+extern "C" int Trampoline11; extern "C" int TrampolineX11;
+extern "C" int Trampoline12; extern "C" int TrampolineX12;
+extern "C" int Trampoline13; extern "C" int TrampolineX13;
+extern "C" int Trampoline14; extern "C" int TrampolineX14;
+extern "C" int Trampoline15; extern "C" int TrampolineX15;
+
+extern "C" napi_value CallSwitchStack(Napi::Function *func, size_t argc, napi_value *argv,
+                                      uint8_t *old_sp, Span<uint8_t> *new_stack,
+                                      napi_value (*call)(Napi::Function *func, size_t argc, napi_value *argv));
+
+static void *const Trampolines[][2] = {
+    { &Trampoline0, &TrampolineX0 },
+    { &Trampoline1, &TrampolineX1 },
+    { &Trampoline2, &TrampolineX2 },
+    { &Trampoline3, &TrampolineX3 },
+    { &Trampoline4, &TrampolineX4 },
+    { &Trampoline5, &TrampolineX5 },
+    { &Trampoline6, &TrampolineX6 },
+    { &Trampoline7, &TrampolineX7 },
+    { &Trampoline8, &TrampolineX8 },
+    { &Trampoline9, &TrampolineX9 },
+    { &Trampoline10, &TrampolineX10 },
+    { &Trampoline11, &TrampolineX11 },
+    { &Trampoline12, &TrampolineX12 },
+    { &Trampoline13, &TrampolineX13 },
+    { &Trampoline14, &TrampolineX14 },
+    { &Trampoline15, &TrampolineX15 }
+};
+RG_STATIC_ASSERT(RG_LEN(Trampolines) == MaxTrampolines);
+
+static RG_THREAD_LOCAL CallData *exec_call;
 
 static inline bool IsRegular(Size size)
 {
@@ -88,15 +136,23 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
             case PrimitiveKind::UInt16:
             case PrimitiveKind::Int32:
             case PrimitiveKind::UInt32:
-            case PrimitiveKind::Int64:
-            case PrimitiveKind::UInt64: {
+            case PrimitiveKind::Int64: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
                     return false;
                 }
 
                 int64_t v = CopyNumber<int64_t>(value);
-                *(args_ptr++) = (uint64_t)v;
+                *(int64_t *)(args_ptr++) = v;
+            } break;
+            case PrimitiveKind::UInt64: {
+                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
+                    return false;
+                }
+
+                uint64_t v = CopyNumber<uint64_t>(value);
+                *(args_ptr++) = v;
             } break;
             case PrimitiveKind::String: {
                 const char *str;
@@ -199,20 +255,44 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 double d = CopyNumber<double>(value);
                 *(double *)(args_ptr++) = d;
             } break;
+            case PrimitiveKind::Callback: {
+                void *ptr;
+
+                if (value.IsFunction()) {
+                    Napi::Function func = value.As<Napi::Function>();
+
+                    Size idx = ReserveTrampoline(param.type->proto, func);
+                    if (RG_UNLIKELY(idx < 0))
+                        return false;
+
+                    ptr = GetTrampoline(idx, param.type->proto);
+                } else if (CheckValueTag(instance, value, param.type)) {
+                    ptr = value.As<Napi::External<uint8_t>>().Data();
+                } else if (IsNullOrUndefined(value)) {
+                    ptr = nullptr;
+                } else {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected %3", GetValueType(instance, value), i + 1, param.type->name);
+                    return false;
+                }
+
+                *(void **)(args_ptr++) = ptr;
+            } break;
         }
     }
 
-    sp = mem->stack.end();
+    new_sp = mem->stack.end();
 
     return true;
 }
 
 void CallData::Execute()
 {
+    exec_call = this;
+
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
-            auto ret = (func->forward_fp ? ForwardCallX ## Suffix(func->func, sp) \
-                                         : ForwardCall ## Suffix(func->func, sp)); \
+            auto ret = (func->forward_fp ? ForwardCallX ## Suffix(func->func, new_sp, &old_sp) \
+                                         : ForwardCall ## Suffix(func->func, new_sp, &old_sp)); \
             return ret; \
         })()
 
@@ -230,7 +310,8 @@ void CallData::Execute()
         case PrimitiveKind::String:
         case PrimitiveKind::String16:
         case PrimitiveKind::Pointer:
-        case PrimitiveKind::Record: { result.u64 = PERFORM_CALL(G); } break;
+        case PrimitiveKind::Record:
+        case PrimitiveKind::Callback: { result.u64 = PERFORM_CALL(G); } break;
         case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
         case PrimitiveKind::Float32: { result.f = PERFORM_CALL(F); } break;
         case PrimitiveKind::Float64: { result.d = PERFORM_CALL(D); } break;
@@ -259,11 +340,16 @@ Napi::Value CallData::Complete()
         case PrimitiveKind::UInt64: return Napi::BigInt::New(env, result.u64);
         case PrimitiveKind::String: return Napi::String::New(env, (const char *)result.ptr);
         case PrimitiveKind::String16: return Napi::String::New(env, (const char16_t *)result.ptr);
-        case PrimitiveKind::Pointer: {
-            Napi::External<void> external = Napi::External<void>::New(env, result.ptr);
-            SetValueTag(instance, external, func->ret.type);
-
-            return external;
+        case PrimitiveKind::Pointer:
+        case PrimitiveKind::Callback: {
+            if (result.ptr) {
+                Napi::External<void> external = Napi::External<void>::New(env, result.ptr);
+                SetValueTag(instance, external, func->ret.type);
+
+                return external;
+            } else {
+                return env.Null();
+            }
         } break;
         case PrimitiveKind::Record: {
             const uint8_t *ptr = return_ptr ? (const uint8_t *)return_ptr
@@ -280,6 +366,309 @@ Napi::Value CallData::Complete()
     RG_UNREACHABLE();
 }
 
+void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
+{
+    const FunctionInfo *proto = instance->trampolines[idx].proto;
+    Napi::Function func = instance->trampolines[idx].func;
+
+    // Allow reuse of static trampoline
+    instance->free_trampolines |= 1u << idx;
+    used_trampolines &= ~(1u << idx);
+
+    uint64_t *gpr_ptr = (uint64_t *)own_sp;
+    uint64_t *xmm_ptr = gpr_ptr + 4;
+    uint64_t *args_ptr = (uint64_t *)caller_sp;
+
+    uint8_t *return_ptr = !proto->ret.regular ? (uint8_t *)gpr_ptr[0] : nullptr;
+
+    LocalArray<napi_value, MaxParameters> arguments;
+
+    // Convert to JS arguments
+    for (Size i = 0, j = !!return_ptr; i < proto->parameters.len; i++, j++) {
+        const ParameterInfo &param = proto->parameters[i];
+        RG_ASSERT(param.directions >= 1 && param.directions <= 3);
+
+        switch (param.type->primitive) {
+            case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
+
+            case PrimitiveKind::Bool: {
+                bool b = *(bool *)(j < 4 ? gpr_ptr + j : args_ptr);
+                args_ptr += (j >= 4);
+
+                Napi::Value arg = Napi::Boolean::New(env, b);
+                arguments.Append(arg);
+            } break;
+            case PrimitiveKind::Int8: {
+                double d = (double)*(int8_t *)(j < 4 ? gpr_ptr + j : args_ptr);
+                args_ptr += (j >= 4);
+
+                Napi::Value arg = Napi::Number::New(env, d);
+                arguments.Append(arg);
+            } break;
+            case PrimitiveKind::UInt8: {
+                double d = (double)*(uint8_t *)(j < 4 ? gpr_ptr + j : args_ptr);
+                args_ptr += (j >= 4);
+
+                Napi::Value arg = Napi::Number::New(env, d);
+                arguments.Append(arg);
+            } break;
+            case PrimitiveKind::Int16: {
+                double d = (double)*(int16_t *)(j < 4 ? gpr_ptr + j : args_ptr);
+                args_ptr += (j >= 4);
+
+                Napi::Value arg = Napi::Number::New(env, d);
+                arguments.Append(arg);
+            } break;
+            case PrimitiveKind::UInt16: {
+                double d = (double)*(uint16_t *)(j < 4 ? gpr_ptr + j : args_ptr);
+                args_ptr += (j >= 4);
+
+                Napi::Value arg = Napi::Number::New(env, d);
+                arguments.Append(arg);
+            } break;
+            case PrimitiveKind::Int32: {
+                double d = (double)*(int32_t *)(j < 4 ? gpr_ptr + j : args_ptr);
+                args_ptr += (j >= 4);
+
+                Napi::Value arg = Napi::Number::New(env, d);
+                arguments.Append(arg);
+            } break;
+            case PrimitiveKind::UInt32: {
+                double d = (double)*(int32_t *)(j < 4 ? gpr_ptr + j : args_ptr);
+                args_ptr += (j >= 4);
+
+                Napi::Value arg = Napi::Number::New(env, d);
+                arguments.Append(arg);
+            } break;
+            case PrimitiveKind::Int64: {
+                int64_t v = *(int64_t *)(j < 4 ? gpr_ptr + j : args_ptr);
+                args_ptr += (j >= 4);
+
+                Napi::Value arg = Napi::BigInt::New(env, v);
+                arguments.Append(arg);
+            } break;
+            case PrimitiveKind::UInt64: {
+                uint64_t v = *(uint64_t *)(j < 4 ? gpr_ptr + j : args_ptr);
+                args_ptr += (j >= 4);
+
+                Napi::Value arg = Napi::BigInt::New(env, v);
+                arguments.Append(arg);
+            } break;
+            case PrimitiveKind::String: {
+                const char *str = *(const char **)(j < 4 ? gpr_ptr + j : args_ptr);
+                args_ptr += (j >= 4);
+
+                Napi::Value arg = Napi::String::New(env, str);
+                arguments.Append(arg);
+            } break;
+            case PrimitiveKind::String16: {
+                const char16_t *str16 = *(const char16_t **)(j < 4 ? gpr_ptr + j : args_ptr);
+                args_ptr += (j >= 4);
+
+                Napi::Value arg = Napi::String::New(env, str16);
+                arguments.Append(arg);
+            } break;
+            case PrimitiveKind::Pointer:
+            case PrimitiveKind::Callback: {
+                void *ptr2 = *(void **)(j < 4 ? gpr_ptr + j : args_ptr);
+                args_ptr += (j >= 4);
+
+                if (ptr2) {
+                    Napi::External<void> external = Napi::External<void>::New(env, ptr2);
+                    SetValueTag(instance, external, param.type);
+
+                    arguments.Append(external);
+                } else {
+                    arguments.Append(env.Null());
+                }
+            } break;
+            case PrimitiveKind::Record: {
+                uint8_t *ptr;
+                if (param.regular) {
+                    ptr = (uint8_t *)(j < 4 ? gpr_ptr + j : args_ptr);
+                } else {
+                    ptr = *(uint8_t **)(j < 4 ? gpr_ptr + j : args_ptr);
+                }
+                args_ptr += (j >= 4);
+
+                Napi::Object obj2 = PopObject(ptr, param.type);
+                arguments.Append(obj2);
+            } break;
+            case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
+            case PrimitiveKind::Float32: {
+                float f = *(float *)(j < 4 ? xmm_ptr + j : args_ptr);
+                args_ptr += (j >= 4);
+
+                Napi::Value arg = Napi::Number::New(env, (double)f);
+                arguments.Append(arg);
+            } break;
+            case PrimitiveKind::Float64: {
+                double d = *(double *)(j < 4 ? xmm_ptr + j : args_ptr);
+                args_ptr += (j >= 4);
+
+                Napi::Value arg = Napi::Number::New(env, d);
+                arguments.Append(arg);
+            } break;
+        }
+    }
+
+    const TypeInfo *type = proto->ret.type;
+
+    // Make the call
+    napi_value ret = CallSwitchStack(&func, (size_t)arguments.len, arguments.data, old_sp, &mem->stack,
+                                     [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argc, argv); });
+    Napi::Value value(env, ret);
+
+    switch (type->primitive) {
+        case PrimitiveKind::Void: {} break;
+        case PrimitiveKind::Bool: {
+            if (RG_UNLIKELY(!value.IsBoolean())) {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value for return value, expected boolean", GetValueType(instance, value));
+                return;
+            }
+
+            bool b = value.As<Napi::Boolean>();
+            out_reg->rax = (uint64_t)b;
+        } break;
+        case PrimitiveKind::Int8:
+        case PrimitiveKind::UInt8:
+        case PrimitiveKind::Int16:
+        case PrimitiveKind::UInt16:
+        case PrimitiveKind::Int32:
+        case PrimitiveKind::UInt32:
+        case PrimitiveKind::Int64:
+        case PrimitiveKind::UInt64: {
+            if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value for return value, expected number", GetValueType(instance, value));
+                return;
+            }
+
+            int64_t v = CopyNumber<int64_t>(value);
+            out_reg->rax = (uint64_t)v;
+        } break;
+        case PrimitiveKind::String: {
+            const char *str;
+            if (RG_LIKELY(value.IsString())) {
+                str = PushString(value);
+                if (RG_UNLIKELY(!str))
+                    return;
+            } else if (IsNullOrUndefined(value)) {
+                str = nullptr;
+            } else {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value for return value, expected string", GetValueType(instance, value));
+                return;
+            }
+
+            out_reg->rax = (uint64_t)str;
+        } break;
+        case PrimitiveKind::String16: {
+            const char16_t *str16;
+            if (RG_LIKELY(value.IsString())) {
+                str16 = PushString16(value);
+                if (RG_UNLIKELY(!str16))
+                    return;
+            } else if (IsNullOrUndefined(value)) {
+                str16 = nullptr;
+            } else {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value for return value, expected string", GetValueType(instance, value));
+                return;
+            }
+
+            out_reg->rax = (uint64_t)str16;
+        } break;
+        case PrimitiveKind::Pointer: {
+            uint8_t *ptr;
+
+            if (CheckValueTag(instance, value, type)) {
+                ptr = value.As<Napi::External<uint8_t>>().Data();
+            } else if (IsObject(value) && type->ref->primitive == PrimitiveKind::Record) {
+                Napi::Object obj = value.As<Napi::Object>();
+
+                if (RG_UNLIKELY(!AllocHeap(type->ref->size, 16, &ptr)))
+                    return;
+
+                if (!PushObject(obj, type->ref, ptr))
+                    return;
+            } else if (IsNullOrUndefined(value)) {
+                ptr = nullptr;
+            } else {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value for return value, expected %2", GetValueType(instance, value), type->name);
+                return;
+            }
+
+            out_reg->rax = (uint64_t)ptr;
+        } break;
+        case PrimitiveKind::Record: {
+            if (RG_UNLIKELY(!IsObject(value))) {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value for return value, expected object", GetValueType(instance, value));
+                return;
+            }
+
+            Napi::Object obj = value.As<Napi::Object>();
+
+            if (return_ptr) {
+                if (!PushObject(obj, type, return_ptr))
+                    return;
+                out_reg->rax = (uint64_t)return_ptr;
+            } else {
+                PushObject(obj, type, (uint8_t *)&out_reg->rax);
+            }
+        } break;
+        case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
+        case PrimitiveKind::Float32: {
+            if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value for return value, expected number", GetValueType(instance, value));
+                return;
+            }
+
+            float f = CopyNumber<float>(value);
+            memcpy(&out_reg->xmm0, &f, 4);
+        } break;
+        case PrimitiveKind::Float64: {
+            if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value for return value, expected number", GetValueType(instance, value));
+                return;
+            }
+
+            double d = CopyNumber<double>(value);
+            out_reg->xmm0 = d;
+        } break;
+        case PrimitiveKind::Callback: {
+            void *ptr;
+
+            if (value.IsFunction()) {
+                Napi::Function func = value.As<Napi::Function>();
+
+                Size idx = ReserveTrampoline(type->proto, func);
+                if (RG_UNLIKELY(idx < 0))
+                    return;
+
+                ptr = GetTrampoline(idx, type->proto);
+            } else if (CheckValueTag(instance, value, type)) {
+                ptr = value.As<Napi::External<uint8_t>>().Data();
+            } else if (IsNullOrUndefined(value)) {
+                ptr = nullptr;
+            } else {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value for return value, expected %2", GetValueType(instance, value), type->name);
+                return;
+            }
+
+            out_reg->rax = (uint64_t)ptr;
+        } break;
+    }
+}
+
+void *GetTrampoline(Size idx, const FunctionInfo *proto)
+{
+    bool xmm = proto->forward_fp || IsFloat(proto->ret.type);
+    return Trampolines[idx][xmm];
+}
+
+extern "C" void RelayCallBack(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
+{
+    exec_call->Relay(idx, own_sp, caller_sp, out_reg);
+}
+
 }
 
 #endif