koffi 1.0.5 → 1.1.0-beta.2

package/src/call.hh

@@ -24,24 +24,27 @@ namespace RG {
 bool AnalyseFunction(InstanceData *instance, FunctionInfo *func);
 
 class CallData {
-    Napi::Env env;
-    InstanceData *instance;
-    const FunctionInfo *func;
-
     struct OutObject {
-        Napi::Object obj;
+        Napi::ObjectReference ref;
         const uint8_t *ptr;
         const TypeInfo *type;
     };
 
-    Span<uint8_t> *stack_mem;
-    Span<uint8_t> *heap_mem;
-    LocalArray<OutObject, MaxOutParameters> out_objects;
-    BlockAllocator big_alloc;
+    Napi::Env env;
+    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;
+
     union {
         uint32_t u32;
         uint64_t u64;
@@ -53,26 +56,9 @@ class CallData {
     uint8_t *return_ptr = nullptr;
 
 public:
-    CallData(Napi::Env env, InstanceData *instance, const FunctionInfo *func);
+    CallData(Napi::Env env, const FunctionInfo *func, InstanceMemory *mem, bool debug);
     ~CallData();
 
-    Span<uint8_t> GetStack() const
-    {
-        uint8_t *sp = stack_mem->end();
-        Size len = old_stack_mem.end() - sp;
-
-        return MakeSpan(sp, len);
-    }
-    uint8_t *GetSP() const { return stack_mem->end(); };
-
-    Span<uint8_t> GetHeap() const
-    {
-        uint8_t *ptr = old_heap_mem.ptr;
-        Size len = heap_mem->ptr - ptr;
-
-        return MakeSpan(ptr, len);
-    }
-
     bool Prepare(const Napi::CallbackInfo &info);
     void Execute();
     Napi::Value Complete();
@@ -82,11 +68,11 @@ public:
         if (!RG_UNLIKELY(Prepare(info)))
             return env.Null();
 
-        if (instance->debug) {
+        if (debug) {
             DumpDebug();
         }
-
         Execute();
+
         return Complete();
     }
 
@@ -100,28 +86,30 @@ private:
 
     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);
+    bool PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t *dest, int16_t realign = 0);
+    bool PushArray(const Napi::Object &obj, const TypeInfo *type, uint8_t *dest, int16_t realign = 0);
 
-    void PopObject(Napi::Object obj, const uint8_t *ptr, const TypeInfo *type);
-    Napi::Object PopObject(const uint8_t *ptr, const TypeInfo *type);
+    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);
+    Napi::Object PopArray(const uint8_t *src, const TypeInfo *type, int16_t realign = 0);
 };
 
 template <typename T>
 bool CallData::AllocStack(Size size, Size align, T **out_ptr)
 {
-    uint8_t *ptr = AlignDown(stack_mem->end() - size, align);
-    Size delta = stack_mem->end() - ptr;
+    uint8_t *ptr = AlignDown(mem->stack.end() - size, align);
+    Size delta = mem->stack.end() - ptr;
 
-    if (RG_UNLIKELY(stack_mem->len < delta)) {
+    if (RG_UNLIKELY(mem->stack.len < delta)) {
         ThrowError<Napi::Error>(env, "FFI call is taking up too much memory");
         return false;
     }
 
-    if (instance->debug) {
+    if (debug) {
         memset(ptr, 0, delta);
     }
 
-    stack_mem->len -= delta;
+    mem->stack.len -= delta;
 
     if (out_ptr) {
         *out_ptr = (T *)ptr;
@@ -132,20 +120,20 @@ bool CallData::AllocStack(Size size, Size align, T **out_ptr)
 template <typename T>
 bool CallData::AllocHeap(Size size, Size align, T **out_ptr)
 {
-    uint8_t *ptr = AlignUp(heap_mem->ptr, align);
-    Size delta = size + (ptr - heap_mem->ptr);
+    uint8_t *ptr = AlignUp(mem->heap.ptr, align);
+    Size delta = size + (ptr - mem->heap.ptr);
 
-    if (RG_UNLIKELY(delta > heap_mem->len)) {
+    if (RG_UNLIKELY(delta > mem->heap.len)) {
         ThrowError<Napi::Error>(env, "FFI call is taking up too much memory");
         return false;
     }
 
-    if (instance->debug) {
-        memset(heap_mem->ptr, 0, (size_t)delta);
+    if (debug) {
+        memset(mem->heap.ptr, 0, (size_t)delta);
     }
 
-    heap_mem->ptr += delta;
-    heap_mem->len -= delta;
+    mem->heap.ptr += delta;
+    mem->heap.len -= delta;
 
     if (out_ptr) {
         *out_ptr = (T *)ptr;

package/src/ffi.cc

@@ -85,6 +85,10 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
         member.type = ResolveType(instance, value);
         if (!member.type)
             return env.Null();
+        if (member.type->primitive == PrimitiveKind::Void) {
+            ThrowError<Napi::TypeError>(env, "Type Void cannot be used as a member");
+            return env.Null();
+        }
 
         member.align = pad ? member.type->align : 1;
 
@@ -241,6 +245,93 @@ static Napi::Value MarkInOut(const Napi::CallbackInfo &info)
     return EncodePointerDirection(info, 3);
 }
 
+static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (info.Length() < 2) {
+        ThrowError<Napi::TypeError>(env, "Expected 2 arguments, got %1", info.Length());
+        return env.Null();
+    }
+    if (!info[1].IsNumber()) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for length, expected integer", GetValueType(instance, info[1]));
+        return env.Null();
+    }
+
+    const TypeInfo *ref = ResolveType(instance, info[0]);
+    int64_t len = (uint16_t)info[1].As<Napi::Number>().Int64Value();
+
+    if (!ref)
+        return env.Null();
+    if (len <= 0) {
+        ThrowError<Napi::TypeError>(env, "Array length must be non-zero positive");
+        return env.Null();
+    }
+    if (len > INT16_MAX / ref->size) {
+        ThrowError<Napi::TypeError>(env, "Array length is too high (max = %1)", INT16_MAX / ref->size);
+        return env.Null();
+    }
+
+    TypeInfo *type = instance->types.AppendDefault();
+    RG_DEFER_N(err_guard) { instance->types.RemoveLast(1); };
+
+    type->name = Fmt(&instance->str_alloc, "%1[%2]", ref->name, len).ptr;
+
+    type->primitive = PrimitiveKind::Array;
+    type->align = ref->align;
+    type->size = (int16_t)(len * ref->size);
+    type->ref = ref;
+
+    // If the insert succeeds, we cannot fail anymore
+    if (!instance->types_map.TrySet(type).second) {
+        ThrowError<Napi::Error>(env, "Duplicate type name '%1'", type->name);
+        return env.Null();
+    }
+    err_guard.Disable();
+
+    Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, type);
+    SetValueTag(instance, external, &TypeInfoMarker);
+
+    return external;
+}
+
+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 *AllocateCallMemory(InstanceData *instance)
+{
+    for (InstanceMemory *mem: instance->memories) {
+        if (!mem->depth)
+            return mem;
+    }
+
+    InstanceMemory *mem = new InstanceMemory();
+
+    mem->stack = AllocateAndAlign16(&mem->mem_alloc, Mebibytes(1));
+    mem->heap = AllocateAndAlign16(&mem->mem_alloc, Mebibytes(2));
+
+    if (instance->memories.Available()) {
+        instance->memories.Append(mem);
+    } else {
+        mem->temporary = true;
+    }
+
+    return mem;
+}
+
 static Napi::Value TranslateNormalCall(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
@@ -252,7 +343,9 @@ static Napi::Value TranslateNormalCall(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    CallData call(env, instance, func);
+    InstanceMemory *mem = AllocateCallMemory(instance);
+    CallData call(env, func, mem, instance->debug);
+
     return call.Run(info);
 }
 
@@ -286,8 +379,9 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
         param.type = ResolveType(instance, info[i], &param.directions);
         if (!param.type)
             return env.Null();
-        if (param.type->primitive == PrimitiveKind::Void) {
-            ThrowError<Napi::TypeError>(env, "Type void cannot be used as a parameter");
+        if (param.type->primitive == PrimitiveKind::Void ||
+                param.type->primitive == PrimitiveKind::Array) {
+            ThrowError<Napi::TypeError>(env, "Type %1 cannot be used as a parameter", PrimitiveKindNames[(int)param.type->primitive]);
             return env.Null();
         }
 
@@ -309,10 +403,93 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
     if (!AnalyseFunction(instance, &func))
         return env.Null();
 
-    CallData call(env, instance, &func);
+    InstanceMemory *mem = AllocateCallMemory(instance);
+    CallData call(env, &func, mem, instance->debug);
+
     return call.Run(info);
 }
 
+class AsyncCall: public Napi::AsyncWorker {
+    Napi::Env env;
+    const FunctionInfo *func;
+
+    CallData call;
+    bool prepared = false;
+
+public:
+    AsyncCall(Napi::Env env, InstanceMemory *mem, FunctionInfo *func, bool debug,
+              Napi::Function &callback)
+        : Napi::AsyncWorker(callback), env(env), func(func->Ref()),
+          call(env, func, mem, debug) {}
+    ~AsyncCall() { func->Unref(); }
+
+    bool Prepare(const Napi::CallbackInfo &info) {
+        prepared = call.Prepare(info);
+
+        if (!prepared) {
+            Napi::Error err = env.GetAndClearPendingException();
+            SetError(err.Message());
+        }
+
+        return prepared;
+    }
+    void DumpDebug() { call.DumpDebug(); }
+
+    void Execute() override;
+    void OnOK() override;
+};
+
+void AsyncCall::Execute()
+{
+    if (prepared) {
+        call.Execute();
+    }
+}
+
+void AsyncCall::OnOK()
+{
+    RG_ASSERT(prepared);
+
+    Napi::FunctionReference &callback = Callback();
+
+    Napi::Value self = env.Null();
+    napi_value args[] = {
+        env.Null(),
+        call.Complete()
+    };
+
+    callback.Call(self, RG_LEN(args), args);
+}
+
+static Napi::Value TranslateAsyncCall(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    FunctionInfo *func = (FunctionInfo *)info.Data();
+
+    if (info.Length() <= (uint32_t)func->parameters.len) {
+        ThrowError<Napi::TypeError>(env, "Expected %1 arguments, got %2", func->parameters.len + 1, info.Length());
+        return env.Null();
+    }
+
+    Napi::Function callback = info[(uint32_t)func->parameters.len].As<Napi::Function>();
+
+    if (!callback.IsFunction()) {
+        ThrowError<Napi::TypeError>(env, "Expected callback function as last arguments, got %1", GetValueType(instance, callback));
+        return env.Null();
+    }
+
+    InstanceMemory *mem = AllocateCallMemory(instance);
+    AsyncCall *async = new AsyncCall(env, mem, func, instance->debug, callback);
+
+    if (async->Prepare(info) && instance->debug) {
+        async->DumpDebug();
+    }
+    async->Queue();
+
+    return env.Null();
+}
+
 static bool ParseClassicFunction(Napi::Env env, Napi::String name, Napi::Value ret,
                                  Napi::Array parameters, FunctionInfo *func)
 {
@@ -335,6 +512,11 @@ static bool ParseClassicFunction(Napi::Env env, Napi::String name, Napi::Value r
     func->ret.type = ResolveType(instance, ret);
     if (!func->ret.type)
         return false;
+    if (func->ret.type->primitive == PrimitiveKind::Array) {
+        ThrowError<Napi::Error>(env, "You are not allowed to directly return fixed-size arrays");
+        return false;
+    }
+
     if (!parameters.IsArray()) {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for parameters of '%2', expected an array", GetValueType(instance, parameters), func->name);
         return false;
@@ -386,7 +568,7 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConve
     LibraryHolder *lib = (LibraryHolder *)info.Data();
 
     FunctionInfo *func = new FunctionInfo();
-    RG_DEFER_N(func_guard) { delete func; };
+    RG_DEFER { func->Unref(); };
 
     func->lib = lib->Ref();
     func->convention = convention;
@@ -445,9 +627,14 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConve
     }
 
     Napi::Function::Callback call = func->variadic ? TranslateVariadicCall : TranslateNormalCall;
-    Napi::Function wrapper = Napi::Function::New(env, call, func->name, (void *)func);
-    wrapper.AddFinalizer([](Napi::Env, FunctionInfo *func) { delete func; }, func);
-    func_guard.Disable();
+    Napi::Function wrapper = Napi::Function::New(env, call, func->name, (void *)func->Ref());
+    wrapper.AddFinalizer([](Napi::Env, FunctionInfo *func) { func->Unref(); }, func);
+
+    if (!func->variadic) {
+        Napi::Function async = Napi::Function::New(env, TranslateAsyncCall, func->name, (void *)func->Ref());
+        async.AddFinalizer([](Napi::Env, FunctionInfo *func) { func->Unref(); }, func);
+        wrapper.Set("async", async);
+    }
 
     return wrapper;
 }
@@ -540,13 +727,13 @@ LibraryHolder::~LibraryHolder()
 #endif
 }
 
-LibraryHolder *LibraryHolder::Ref()
+const LibraryHolder *LibraryHolder::Ref() const
 {
     refcount++;
     return this;
 }
 
-void LibraryHolder::Unref()
+void LibraryHolder::Unref() const
 {
     if (!--refcount) {
         delete this;
@@ -556,6 +743,8 @@ void LibraryHolder::Unref()
 static void RegisterPrimitiveType(InstanceData *instance, const char *name, PrimitiveKind primitive,
                                   int16_t size, int16_t align)
 {
+    RG_ASSERT(align <= size);
+
     TypeInfo *type = instance->types.AppendDefault();
 
     type->name = name;
@@ -646,21 +835,30 @@ FunctionInfo::~FunctionInfo()
     }
 }
 
-static Span<uint8_t> AllocateAndAlign16(Allocator *alloc, Size size)
+const FunctionInfo *FunctionInfo::Ref() const
 {
-    RG_ASSERT(AlignLen(size, 16) == size);
-
-    uint8_t *ptr = (uint8_t *)Allocator::Allocate(alloc, size);
-    uint8_t *aligned = AlignUp(ptr, 16);
-    Size delta = AlignLen(aligned - ptr, 16);
+    refcount++;
+    return this;
+}
 
-    return MakeSpan(aligned, size - delta);
+void FunctionInfo::Unref() const
+{
+    if (!--refcount) {
+        delete this;
+    }
 }
 
 InstanceData::InstanceData()
 {
-    stack_mem = AllocateAndAlign16(&mem_alloc, Mebibytes(2));
-    heap_mem = AllocateAndAlign16(&mem_alloc, Mebibytes(4));
+    AllocateCallMemory(this);
+    RG_ASSERT(memories.len == 1);
+}
+
+InstanceData::~InstanceData()
+{
+    for (InstanceMemory *mem: memories) {
+        delete mem;
+    }
 }
 
 template <typename Func>
@@ -670,6 +868,7 @@ static void SetExports(Napi::Env env, Func func)
     func("pack", Napi::Function::New(env, CreatePackedStructType));
     func("handle", Napi::Function::New(env, CreateHandleType));
     func("pointer", Napi::Function::New(env, CreatePointerType));
+    func("array", Napi::Function::New(env, CreateArrayType));
     func("load", Napi::Function::New(env, LoadSharedLibrary));
     func("in", Napi::Function::New(env, MarkIn));
     func("out", Napi::Function::New(env, MarkOut));

package/src/ffi.hh

@@ -39,6 +39,7 @@ enum class PrimitiveKind {
     String16,
     Pointer,
     Record,
+    Array,
     Float32,
     Float64
 };
@@ -57,6 +58,7 @@ static const char *const PrimitiveKindNames[] = {
     "String16",
     "Pointer",
     "Record",
+    "Array",
     "Float32",
     "Float64"
 };
@@ -73,7 +75,7 @@ struct TypeInfo {
     int16_t align;
 
     HeapArray<RecordMember> members; // Record only
-    const TypeInfo *ref; // Pointer only
+    const TypeInfo *ref; // Pointer or array
 
     RG_HASHTABLE_HANDLER(TypeInfo, name);
 };
@@ -86,13 +88,13 @@ struct RecordMember {
 
 struct LibraryHolder {
     void *module = nullptr; // HMODULE on Windows
-    std::atomic_int refcount {1};
+    mutable std::atomic_int refcount {1};
 
     LibraryHolder(void *module) : module(module) {}
     ~LibraryHolder();
 
-    LibraryHolder *Ref();
-    void Unref();
+    const LibraryHolder *Ref() const;
+    void Unref() const;
 };
 
 enum class CallConvention {
@@ -132,11 +134,11 @@ struct ParameterInfo {
 };
 
 struct FunctionInfo {
-    ~FunctionInfo();
+    mutable std::atomic_int refcount {1};
 
     const char *name;
     const char *decorated_name;
-    LibraryHolder *lib = nullptr;
+    const LibraryHolder *lib = nullptr;
 
     void *func;
     CallConvention convention;
@@ -152,10 +154,27 @@ struct FunctionInfo {
 #if defined(__arm__) || defined(__aarch64__) || defined(__x86_64__) || defined(_WIN64)
     bool forward_fp;
 #endif
+
+    ~FunctionInfo();
+
+    const FunctionInfo *Ref() const;
+    void Unref() const;
+};
+
+struct InstanceMemory {
+    LinkedAllocator mem_alloc;
+
+    Span<uint8_t> stack;
+    Span<uint8_t> heap;
+    IndirectBlockAllocator big_alloc { &mem_alloc };
+
+    int depth;
+    bool temporary;
 };
 
 struct InstanceData {
     InstanceData();
+    ~InstanceData();
 
     BucketArray<TypeInfo> types;
     HashTable<const char *, TypeInfo *> types_map;
@@ -163,12 +182,9 @@ struct InstanceData {
     bool debug;
     uint64_t tag_lower;
 
-    BlockAllocator str_alloc;
-
-    Span<uint8_t> stack_mem;
-    Span<uint8_t> heap_mem;
+    LocalArray<InstanceMemory *, 8> memories;
 
-    LinkedAllocator mem_alloc;
+    BlockAllocator str_alloc;
 };
 
 }

package/src/parser.cc

@@ -35,6 +35,10 @@ bool PrototypeParser::Parse(Napi::String proto, FunctionInfo *func)
     Tokenize(hold.c_str());
 
     func->ret.type = ParseType();
+    if (func->ret.type->primitive == PrimitiveKind::Array) {
+        MarkError("You are not allowed to directly return fixed-size arrays");
+        return false;
+    }
     if (Match("__cdecl")) {
         func->convention = CallConvention::Cdecl;
     } else if (Match("__stdcall")) {

package/src/util.cc

@@ -126,4 +126,76 @@ bool CheckValueTag(const InstanceData *instance, Napi::Value value, const void *
     return match;
 }
 
+class HfaAnalyser {
+    uint32_t primitives;
+    Size count;
+
+public:
+    bool Analyse(const TypeInfo *type, int min, int max);
+
+private:
+    void AnalyseStruct(const TypeInfo *type);
+    void AnalyseArray(const TypeInfo *type);
+};
+
+bool HfaAnalyser::Analyse(const TypeInfo *type, int min, int max)
+{
+    primitives = 0;
+    count = 0;
+
+    if (type->primitive == PrimitiveKind::Record) {
+        AnalyseStruct(type);
+    } else if (type->primitive == PrimitiveKind::Array) {
+        AnalyseArray(type);
+    } else {
+        return false;
+    }
+
+    bool hfa = (count >= min && count <= max && PopCount(primitives) == 1);
+    return hfa;
+}
+
+void HfaAnalyser::AnalyseStruct(const TypeInfo *type)
+{
+    RG_ASSERT(type->primitive == PrimitiveKind::Record);
+
+    for (const RecordMember &member: type->members) {
+        if (member.type->primitive == PrimitiveKind::Record) {
+            AnalyseStruct(member.type);
+        } else if (member.type->primitive == PrimitiveKind::Array) {
+            AnalyseArray(member.type);
+        } else if (member.type->primitive == PrimitiveKind::Float32 ||
+                   member.type->primitive == PrimitiveKind::Float64) {
+            primitives |= 1u << (int)member.type->primitive;
+            count++;
+        } else {
+            primitives = UINT_MAX;
+            return;
+        }
+    }
+}
+
+void HfaAnalyser::AnalyseArray(const TypeInfo *type)
+{
+    RG_ASSERT(type->primitive == PrimitiveKind::Array);
+
+    if (type->ref->primitive == PrimitiveKind::Record) {
+        AnalyseStruct(type->ref);
+    } else if (type->ref->primitive == PrimitiveKind::Array) {
+        AnalyseArray(type->ref);
+    } else if (type->ref->primitive == PrimitiveKind::Float32 ||
+               type->ref->primitive == PrimitiveKind::Float64) {
+        primitives |= 1u << (int)type->ref->primitive;
+        count += type->size / type->ref->size;;
+    } else {
+        primitives = UINT_MAX;
+    }
+}
+
+bool IsHFA(const TypeInfo *type, int min, int max)
+{
+    HfaAnalyser analyser;
+    return analyser.Analyse(type, min, max);
+}
+
 }

package/src/util.hh

@@ -89,4 +89,6 @@ T CopyNumber(const Napi::Value &value)
     RG_UNREACHABLE();
 }
 
+bool IsHFA(const TypeInfo *type, int min, int max);
+
 }