koffi 1.1.1 → 1.1.4

package/src/abi_x86.cc

@@ -37,7 +37,9 @@ static inline bool IsRegular(Size size)
 
 bool AnalyseFunction(InstanceData *instance, FunctionInfo *func)
 {
-    int fast = (func->convention == CallConvention::Fastcall) ? 2 : 0;
+    int fast = (func->convention == CallConvention::Fastcall) ? 2 :
+               (func->convention == CallConvention::Thiscall) ? 1 : 0;
+    func->fast = fast;
 
     if (func->ret.type->primitive != PrimitiveKind::Record) {
         func->ret.trivial = true;
@@ -77,6 +79,10 @@ bool AnalyseFunction(InstanceData *instance, FunctionInfo *func)
             func->decorated_name = Fmt(&instance->str_alloc, "@%1@%2", func->name, params_size).ptr;
             func->args_size += 16;
         } break;
+        case CallConvention::Thiscall: {
+            RG_ASSERT(!func->variadic);
+            func->args_size += 16;
+        } break;
     }
 
     return true;
@@ -90,7 +96,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
     // Pass return value in register or through memory
     if (RG_UNLIKELY(!AllocStack(func->args_size, 16, &args_ptr)))
         return false;
-    if (func->convention == CallConvention::Fastcall) {
+    if (func->fast) {
         fast_ptr = args_ptr;
         args_ptr += 4;
     }
@@ -249,8 +255,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
         }
     }
 
-    stack = MakeSpan(mem->stack.end(), old_stack_mem.end() - mem->stack.end());
-    heap = MakeSpan(old_heap_mem.ptr, mem->heap.ptr - old_heap_mem.ptr);
+    sp = mem->stack.end();
 
     return true;
 }
@@ -259,8 +264,8 @@ void CallData::Execute()
 {
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
-            auto ret = (func->convention == CallConvention::Fastcall ? ForwardCallR ## Suffix(func->func, stack.ptr) \
-                                                                     : ForwardCall ## Suffix(func->func, stack.ptr)); \
+            auto ret = (func->fast ? ForwardCallR ## Suffix(func->func, sp) \
+                                   : ForwardCall ## Suffix(func->func, sp)); \
             return ret; \
         })()
 

package/src/call.cc

@@ -21,7 +21,7 @@
 namespace RG {
 
 CallData::CallData(Napi::Env env, InstanceData *instance, const FunctionInfo *func, InstanceMemory *mem)
-    : env(env), instance(instance), func(func), debug(instance->debug),
+    : env(env), instance(instance), func(func),
       mem(mem), old_stack_mem(mem->stack), old_heap_mem(mem->heap)
 {
     mem->depth++;
@@ -252,8 +252,8 @@ bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t
                     return false;
                 }
 
-                Napi::Object obj = value.As<Napi::Object>();
-                if (!PushObject(obj, member.type, dest, realign))
+                Napi::Object obj2 = value.As<Napi::Object>();
+                if (!PushObject(obj2, member.type, dest, realign))
                     return false;
             } break;
             case PrimitiveKind::Array: {
@@ -292,15 +292,15 @@ bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t
     return true;
 }
 
-bool CallData::PushArray(const Napi::Value &value, const TypeInfo *type, uint8_t *dest, int16_t realign)
+bool CallData::PushArray(const Napi::Value &obj, const TypeInfo *type, uint8_t *dest, int16_t realign)
 {
-    RG_ASSERT(value.IsArray() || value.IsTypedArray() || value.IsString());
+    RG_ASSERT(obj.IsArray() || obj.IsTypedArray() || obj.IsString());
     RG_ASSERT(type->primitive == PrimitiveKind::Array);
 
     uint32_t len = type->size / type->ref->size;
 
-    if (value.IsArray()) {
-        Napi::Array array = value.As<Napi::Array>();
+    if (obj.IsArray()) {
+        Napi::Array array = obj.As<Napi::Array>();
 
         if (RG_UNLIKELY(array.Length() != len)) {
             ThrowError<Napi::Error>(env, "Expected array of length %1, got %2", len, array.Length());
@@ -407,15 +407,15 @@ bool CallData::PushArray(const Napi::Value &value, const TypeInfo *type, uint8_t
             } break;
             case PrimitiveKind::Record: {
                 PUSH_ARRAY(IsObject(value), "object", {
-                    Napi::Object obj = value.As<Napi::Object>();
-                    if (!PushObject(obj, type->ref, dest, realign))
+                    Napi::Object obj2 = value.As<Napi::Object>();
+                    if (!PushObject(obj2, type->ref, dest, realign))
                         return false;
                 });
             } break;
             case PrimitiveKind::Array: {
                 PUSH_ARRAY(value.IsArray() || value.IsTypedArray() || value.IsString(), "array", {
-                    Napi::Object array = value.As<Napi::Array>();
-                    if (!PushArray(array, type->ref, dest, realign))
+                    Napi::Object array2 = value.As<Napi::Array>();
+                    if (!PushArray(array2, type->ref, dest, realign))
                         return false;
                 });
             } break;
@@ -434,8 +434,8 @@ bool CallData::PushArray(const Napi::Value &value, const TypeInfo *type, uint8_t
         }
 
 #undef PUSH_ARRAY
-    } else if (value.IsTypedArray()) {
-        Napi::TypedArray array = value.As<Napi::TypedArray>();
+    } else if (obj.IsTypedArray()) {
+        Napi::TypedArray array = obj.As<Napi::TypedArray>();
         const uint8_t *buf = (const uint8_t *)array.ArrayBuffer().Data();
 
         if (RG_UNLIKELY(array.ElementLength() != len)) {
@@ -469,23 +469,23 @@ bool CallData::PushArray(const Napi::Value &value, const TypeInfo *type, uint8_t
 
             dest += type->ref->size;
         }
-    } else if (value.IsString()) {
-        size_t len = 0;
+    } else if (obj.IsString()) {
+        size_t encoded = 0;
 
         if (type->ref->primitive == PrimitiveKind::Int8 || type->ref->primitive == PrimitiveKind::UInt8) {
-            napi_status status = napi_get_value_string_utf8(env, value, (char *)dest, type->size, &len);
+            napi_status status = napi_get_value_string_utf8(env, obj, (char *)dest, type->size, &encoded);
             RG_ASSERT(status == napi_ok);
         } else if (type->ref->primitive == PrimitiveKind::Int16 || type->ref->primitive == PrimitiveKind::UInt16) {
-            napi_status status = napi_get_value_string_utf16(env, value, (char16_t *)dest, type->size / 2, &len);
+            napi_status status = napi_get_value_string_utf16(env, obj, (char16_t *)dest, type->size / 2, &encoded);
             RG_ASSERT(status == napi_ok);
 
-            len *= 2;
+            encoded *= 2;
         } else {
             ThrowError<Napi::TypeError>(env, "Strings cannot be converted to %1 array", type->ref->name);
             return false;
         }
 
-        memset_safe(dest + len, 0, type->size - len);
+        memset_safe(dest + encoded, 0, type->size - encoded);
     } else {
         RG_UNREACHABLE();
     }
@@ -565,13 +565,11 @@ void CallData::PopObject(Napi::Object obj, const uint8_t *src, const TypeInfo *t
                 obj.Set(member.name, value);
             } break;
             case PrimitiveKind::Float32: {
-                float f;
-                memcpy(&f, src, 4);
+                float f = *(float *)src;
                 obj.Set(member.name, Napi::Number::New(env, (double)f));
             } break;
             case PrimitiveKind::Float64: {
-                double d;
-                memcpy(&d, src, 8);
+                double d = *(double *)src;
                 obj.Set(member.name, Napi::Number::New(env, d));
             } break;
         }
@@ -762,19 +760,6 @@ Napi::Value CallData::PopArray(const uint8_t *src, const TypeInfo *type, int16_t
     RG_UNREACHABLE();
 }
 
-Napi::Value CallData::Run(const Napi::CallbackInfo &info)
-{
-    if (!RG_UNLIKELY(Prepare(info)))
-        return env.Null();
-
-    if (debug) {
-        DumpDebug();
-    }
-    Execute();
-
-    return Complete();
-}
-
 static void DumpMemory(const char *type, Span<const uint8_t> bytes)
 {
     if (bytes.len) {
@@ -805,6 +790,9 @@ void CallData::DumpDebug() const
     }
     PrintLn(stderr, "Return: %1 (%2)", func->ret.type->name, FmtMemSize(func->ret.type->size));
 
+    Span<const uint8_t> stack = MakeSpan(mem->stack.end(), old_stack_mem.end() - mem->stack.end());
+    Span<const uint8_t> heap = MakeSpan(old_heap_mem.ptr, mem->heap.ptr - old_heap_mem.ptr);
+
     DumpMemory("Stack", stack);
     DumpMemory("Heap", heap);
 }

package/src/call.hh

@@ -34,16 +34,12 @@ class CallData {
     InstanceData *instance;
     const FunctionInfo *func;
 
-    bool debug;
-
     InstanceMemory *mem;
     Span<uint8_t> old_stack_mem;
     Span<uint8_t> old_heap_mem;
 
     LocalArray<OutObject, MaxOutParameters> out_objects;
-
-    Span<uint8_t> heap;
-    Span<uint8_t> stack;
+    uint8_t *sp;
 
     union {
         uint32_t u32;
@@ -65,20 +61,18 @@ public:
     void Execute();
     Napi::Value Complete();
 
-    Napi::Value Run(const Napi::CallbackInfo &info);
-
     void DumpDebug() const;
 
 private:
     template <typename T = void>
-    bool AllocStack(Size size, Size align, T **out_ptr = nullptr);
+    bool AllocStack(Size size, Size align, T **out_ptr);
     template <typename T = void>
-    bool AllocHeap(Size size, Size align, T **out_ptr = nullptr);
+    bool AllocHeap(Size size, Size align, T **out_ptr);
 
     const char *PushString(const Napi::Value &value);
     const char16_t *PushString16(const Napi::Value &value);
     bool PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t *dest, int16_t realign = 0);
-    bool PushArray(const Napi::Value &value, const TypeInfo *type, uint8_t *dest, int16_t realign = 0);
+    bool PushArray(const Napi::Value &obj, const TypeInfo *type, uint8_t *dest, int16_t realign = 0);
 
     void PopObject(Napi::Object obj, const uint8_t *src, const TypeInfo *type, int16_t realign = 0);
     Napi::Object PopObject(const uint8_t *src, const TypeInfo *type, int16_t realign = 0);
@@ -86,7 +80,7 @@ private:
 };
 
 template <typename T>
-bool CallData::AllocStack(Size size, Size align, T **out_ptr)
+inline bool CallData::AllocStack(Size size, Size align, T **out_ptr)
 {
     uint8_t *ptr = AlignDown(mem->stack.end() - size, align);
     Size delta = mem->stack.end() - ptr;
@@ -96,20 +90,18 @@ bool CallData::AllocStack(Size size, Size align, T **out_ptr)
         return false;
     }
 
-    if (debug) {
-        memset(ptr, 0, delta);
-    }
+#ifdef RG_DEBUG
+    memset(ptr, 0, delta);
+#endif
 
     mem->stack.len -= delta;
 
-    if (out_ptr) {
-        *out_ptr = (T *)ptr;
-    }
+    *out_ptr = (T *)ptr;
     return true;
 }
 
 template <typename T>
-bool CallData::AllocHeap(Size size, Size align, T **out_ptr)
+inline bool CallData::AllocHeap(Size size, Size align, T **out_ptr)
 {
     uint8_t *ptr = AlignUp(mem->heap.ptr, align);
     Size delta = size + (ptr - mem->heap.ptr);
@@ -119,16 +111,14 @@ bool CallData::AllocHeap(Size size, Size align, T **out_ptr)
         return false;
     }
 
-    if (debug) {
-        memset(mem->heap.ptr, 0, (size_t)delta);
-    }
+#ifdef RG_DEBUG
+    memset(mem->heap.ptr, 0, (size_t)delta);
+#endif
 
     mem->heap.ptr += delta;
     mem->heap.len -= delta;
 
-    if (out_ptr) {
-        *out_ptr = (T *)ptr;
-    }
+    *out_ptr = (T *)ptr;
     return true;
 }
 

package/src/ffi.cc

@@ -29,6 +29,7 @@
 #else
     #include <dlfcn.h>
     #include <unistd.h>
+    #include <sys/mman.h>
 #endif
 
 #include <napi.h>
@@ -39,6 +40,11 @@
 
 namespace RG {
 
+const Size SyncStackSize = Mebibytes(2);
+const Size SyncHeapSize = Mebibytes(4);
+const Size AsyncStackSize = Mebibytes(1);
+const Size AsyncHeapSize = Mebibytes(2);
+
 // Value does not matter, the tag system uses memory addresses
 const int TypeInfoMarker = 0xDEADBEEF;
 
@@ -100,6 +106,11 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
         type->members.Append(member);
     }
 
+    if (!type->size) {
+        ThrowError<Napi::TypeError>(env, "Empty struct '%1' is not allowed in C", type->name);
+        return env.Null();
+    }
+
     type->size = (int16_t)AlignLen(type->size, type->align);
 
     // If the insert succeeds, we cannot fail anymore
@@ -290,7 +301,7 @@ static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
     if (!ref)
         return env.Null();
     if (len <= 0) {
-        ThrowError<Napi::TypeError>(env, "Array length must be non-zero positive");
+        ThrowError<Napi::TypeError>(env, "Array length must be positive and non-zero");
         return env.Null();
     }
     if (len > INT16_MAX / ref->size) {
@@ -369,21 +380,6 @@ static Napi::Value GetTypeDefinition(const Napi::CallbackInfo &info)
     return type->defn.Value();
 }
 
-static Span<uint8_t> AllocateAndAlign16(Allocator *alloc, Size size)
-{
-    RG_ASSERT(AlignLen(size, 16) == size);
-    RG_ASSERT(size >= Kibibytes(1));
-
-    // Account for allocator overhead
-    size -= 256;
-
-    uint8_t *ptr = (uint8_t *)Allocator::Allocate(alloc, size);
-    uint8_t *aligned = AlignUp(ptr, 16);
-    Size delta = AlignLen(aligned - ptr, 16);
-
-    return MakeSpan(aligned, size - delta);
-}
-
 static InstanceMemory *AllocateAsyncMemory(InstanceData *instance)
 {
     for (Size i = 1; i < instance->memories.len; i++) {
@@ -395,8 +391,23 @@ static InstanceMemory *AllocateAsyncMemory(InstanceData *instance)
 
     InstanceMemory *mem = new InstanceMemory();
 
-    mem->stack = AllocateAndAlign16(&mem->mem_alloc, Mebibytes(1));
-    mem->heap = AllocateAndAlign16(&mem->mem_alloc, Mebibytes(2));
+    mem->stack.len = AsyncStackSize;
+#if defined(_WIN32)
+    mem->stack.ptr = (uint8_t *)VirtualAlloc(nullptr, mem->stack.len, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
+#elif defined(__APPLE__)
+    mem->stack.ptr = (uint8_t *)mmap(nullptr, mem->stack.len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
+#else
+    mem->stack.ptr = (uint8_t *)mmap(nullptr, mem->stack.len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON | MAP_STACK, -1, 0);
+#endif
+    RG_CRITICAL(mem->stack.ptr, "Failed to allocate %1 of memory", mem->stack.len);
+
+    mem->heap.len = AsyncHeapSize;
+#ifdef _WIN32
+    mem->heap.ptr = (uint8_t *)VirtualAlloc(nullptr, mem->heap.len, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
+#else
+    mem->heap.ptr = (uint8_t *)mmap(nullptr, mem->heap.len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
+#endif
+    RG_CRITICAL(mem->heap.ptr, "Failed to allocate %1 of memory", mem->heap.len);
 
     if (instance->memories.Available()) {
         instance->memories.Append(mem);
@@ -421,7 +432,15 @@ static Napi::Value TranslateNormalCall(const Napi::CallbackInfo &info)
     InstanceMemory *mem = instance->memories[0];
     CallData call(env, instance, func, mem);
 
-    return call.Run(info);
+    if (!RG_UNLIKELY(call.Prepare(info)))
+        return env.Null();
+
+    if (instance->debug) {
+        call.DumpDebug();
+    }
+    call.Execute();
+
+    return call.Complete();
 }
 
 static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
@@ -481,7 +500,15 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
     InstanceMemory *mem = instance->memories[0];
     CallData call(env, instance, &func, mem);
 
-    return call.Run(info);
+    if (!RG_UNLIKELY(call.Prepare(info)))
+        return env.Null();
+
+    if (instance->debug) {
+        call.DumpDebug();
+    }
+    call.Execute();
+
+    return call.Complete();
 }
 
 class AsyncCall: public Napi::AsyncWorker {
@@ -597,10 +624,10 @@ static bool ParseClassicFunction(Napi::Env env, Napi::String name, Napi::Value r
         return false;
     }
 
-    Size parameters_len = parameters.Length();
+    uint32_t parameters_len = parameters.Length();
 
     if (parameters_len) {
-        Napi::String str = ((Napi::Value)parameters[(uint32_t)(parameters_len - 1)]).As<Napi::String>();
+        Napi::String str = ((Napi::Value)parameters[parameters_len - 1]).As<Napi::String>();
 
         if (str.IsString() && str.Utf8Value() == "...") {
             func->variadic = true;
@@ -653,9 +680,13 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConve
         if (!ParseClassicFunction(env, info[0u].As<Napi::String>(), info[1u], info[2u].As<Napi::Array>(), func))
             return env.Null();
     } else if (info.Length() >= 1) {
-        PrototypeParser parser(env);
+        if (!info[0].IsString()) {
+            ThrowError<Napi::TypeError>(env, "Unexpected %1 value for prototype, expected string", GetValueType(instance, info[0]));
+            return env.Null();
+        }
 
-        if (!parser.Parse(info[0u].As<Napi::String>(), func))
+        std::string proto = info[0u].As<Napi::String>();
+        if (!ParsePrototype(env, proto.c_str(), func))
             return env.Null();
     } else {
         ThrowError<Napi::TypeError>(env, "Expected 1 or 3 arguments, not %1", info.Length());
@@ -784,6 +815,7 @@ static Napi::Value LoadSharedLibrary(const Napi::CallbackInfo &info)
     ADD_CONVENTION("cdecl", CallConvention::Cdecl);
     ADD_CONVENTION("stdcall", CallConvention::Stdcall);
     ADD_CONVENTION("fastcall", CallConvention::Fastcall);
+    ADD_CONVENTION("thiscall", CallConvention::Thiscall);
 
 #undef ADD_CONVENTION
 
@@ -928,8 +960,23 @@ InstanceData::InstanceData()
 {
     InstanceMemory *mem = new InstanceMemory();
 
-    mem->stack = AllocateAndAlign16(&mem->mem_alloc, Mebibytes(2));
-    mem->heap = AllocateAndAlign16(&mem->mem_alloc, Mebibytes(4));
+    mem->stack.len = SyncStackSize;
+#if defined(_WIN32)
+    mem->stack.ptr = (uint8_t *)VirtualAlloc(nullptr, mem->stack.len, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
+#elif defined(__APPLE__)
+    mem->stack.ptr = (uint8_t *)mmap(nullptr, mem->stack.len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
+#else
+    mem->stack.ptr = (uint8_t *)mmap(nullptr, mem->stack.len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON | MAP_STACK, -1, 0);
+#endif
+    RG_CRITICAL(mem->stack.ptr, "Failed to allocate %1 of memory", mem->stack.len);
+
+    mem->heap.len = SyncHeapSize;
+#ifdef _WIN32
+    mem->heap.ptr = (uint8_t *)VirtualAlloc(nullptr, mem->heap.len, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
+#else
+    mem->heap.ptr = (uint8_t *)mmap(nullptr, mem->heap.len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
+#endif
+    RG_CRITICAL(mem->heap.ptr, "Failed to allocate %1 of memory", mem->heap.len);
 
     memories.Append(mem);
 }
@@ -957,7 +1004,6 @@ static void SetExports(Napi::Env env, Func func)
     func("out", Napi::Function::New(env, MarkOut));
     func("inout", Napi::Function::New(env, MarkInOut));
 
-    func("internal", Napi::Boolean::New(env, true));
 #if defined(_WIN32)
     func("extension", Napi::String::New(env, ".dll"));
 #elif defined(__APPLE__)
@@ -1009,6 +1055,7 @@ static void InitInternal(v8::Local<v8::Object> target, v8::Local<v8::Value>,
     FillRandomSafe(&instance->tag_lower, RG_SIZE(instance->tag_lower));
 
     SetExports(env_napi, [&](const char *name, Napi::Value value) { SetValue(env, target, name, value); });
+    SetValue(env, target, "internal", Napi::Boolean::New(env_cxx, true));
 }
 
 #else
@@ -1024,6 +1071,7 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
     FillRandomSafe(&instance->tag_lower, RG_SIZE(instance->tag_lower));
 
     SetExports(env, [&](const char *name, Napi::Value value) { exports.Set(name, value); });
+    exports.Set("internal", Napi::Boolean::New(env, false));
 
     return exports;
 }

package/src/ffi.hh

@@ -109,12 +109,14 @@ struct LibraryHolder {
 enum class CallConvention {
     Cdecl,
     Stdcall,
-    Fastcall
+    Fastcall,
+    Thiscall
 };
 static const char *const CallConventionNames[] = {
     "Cdecl",
     "Stdcall",
-    "Fastcall"
+    "Fastcall",
+    "Thiscall"
 };
 
 struct ParameterInfo {
@@ -139,6 +141,11 @@ struct ParameterInfo {
 #elif defined(__i386__) || defined(_M_IX86)
     bool trivial; // Only matters for return value
     bool fast;
+#elif __riscv_xlen == 64
+    bool use_memory;
+    int8_t gpr_count;
+    int8_t vec_count;
+    bool gpr_first; // Only for structs
 #endif
 };
 
@@ -160,9 +167,12 @@ struct FunctionInfo {
     // ABI-specific part
 
     Size args_size;
-#if defined(__arm__) || defined(__aarch64__) || defined(__x86_64__) || defined(_WIN64)
+#if defined(__arm__) || defined(__aarch64__) || defined(__x86_64__) || defined(_WIN64) || defined(__riscv)
     bool forward_fp;
 #endif
+#if defined(__i386__) || defined(_M_IX86)
+    bool fast;
+#endif
 
     ~FunctionInfo();
 
@@ -171,8 +181,6 @@ struct FunctionInfo {
 };
 
 struct InstanceMemory {
-    LinkedAllocator mem_alloc;
-
     Span<uint8_t> stack;
     Span<uint8_t> heap;