koffi 1.0.1 → 1.0.4

package/src/call.cc

@@ -0,0 +1,353 @@
+// 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/.
+
+#include "vendor/libcc/libcc.hh"
+#include "call.hh"
+#include "ffi.hh"
+#include "util.hh"
+
+#include <napi.h>
+
+namespace RG {
+
+CallData::CallData(Napi::Env env, InstanceData *instance, const FunctionInfo *func)
+    : env(env), instance(instance), func(func),
+      stack_mem(&instance->stack_mem), heap_mem(&instance->heap_mem),
+      old_stack_mem(instance->stack_mem), old_heap_mem(instance->heap_mem)
+{
+    RG_ASSERT(AlignUp(stack_mem->ptr, 16) == stack_mem->ptr);
+    RG_ASSERT(AlignUp(stack_mem->end(), 16) == stack_mem->end());
+}
+
+CallData::~CallData()
+{
+    instance->stack_mem = old_stack_mem;
+    instance->heap_mem = old_heap_mem;
+}
+
+const char *CallData::PushString(const Napi::Value &value)
+{
+    RG_ASSERT(value.IsString());
+
+    Napi::Env env = value.Env();
+
+    Span<char> buf;
+    size_t len = 0;
+    napi_status status;
+
+    buf.ptr = (char *)heap_mem->ptr;
+    buf.len = std::max((Size)0, heap_mem->len - Kibibytes(32));
+
+    status = napi_get_value_string_utf8(env, value, buf.ptr, (size_t)buf.len, &len);
+    RG_ASSERT(status == napi_ok);
+
+    len++;
+
+    if (RG_LIKELY(len < (size_t)buf.len)) {
+        heap_mem->ptr += (Size)len;
+        heap_mem->len -= (Size)len;
+    } else {
+        status = napi_get_value_string_utf8(env, value, nullptr, 0, &len);
+        RG_ASSERT(status == napi_ok);
+
+        len++;
+
+        buf.ptr = (char *)Allocator::Allocate(&big_alloc, (Size)len);
+        buf.len = (Size)len;
+
+        status = napi_get_value_string_utf8(env, value, buf.ptr, (size_t)buf.len, &len);
+        RG_ASSERT(status == napi_ok);
+    }
+
+    return buf.ptr;
+}
+
+const char16_t *CallData::PushString16(const Napi::Value &value)
+{
+    RG_ASSERT(value.IsString());
+
+    Napi::Env env = value.Env();
+
+    Span<char16_t> buf;
+    size_t len = 0;
+    napi_status status;
+
+    buf.ptr = (char16_t *)heap_mem->ptr;
+    buf.len = std::max((Size)0, heap_mem->len - Kibibytes(32)) / 2;
+
+    status = napi_get_value_string_utf16(env, value, buf.ptr, (size_t)buf.len, &len);
+    RG_ASSERT(status == napi_ok);
+
+    len++;
+
+    if (RG_LIKELY(len < (size_t)buf.len)) {
+        heap_mem->ptr += (Size)len * 2;
+        heap_mem->len -= (Size)len * 2;
+    } else {
+        status = napi_get_value_string_utf16(env, value, nullptr, 0, &len);
+        RG_ASSERT(status == napi_ok);
+
+        len++;
+
+        buf.ptr = (char16_t *)Allocator::Allocate(&big_alloc, (Size)len * 2);
+        buf.len = (Size)len;
+
+        status = napi_get_value_string_utf16(env, value, buf.ptr, (size_t)buf.len, &len);
+        RG_ASSERT(status == napi_ok);
+    }
+
+    return buf.ptr;
+}
+
+bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t *dest)
+{
+    Napi::Env env = obj.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    RG_ASSERT(IsObject(obj));
+    RG_ASSERT(type->primitive == PrimitiveKind::Record);
+
+    for (const RecordMember &member: type->members) {
+        Napi::Value value = obj.Get(member.name);
+
+        if (RG_UNLIKELY(value.IsUndefined())) {
+            ThrowError<Napi::TypeError>(env, "Missing expected object property '%1'", member.name);
+            return false;
+        }
+
+        dest = AlignUp(dest, member.align);
+
+        switch (member.type->primitive) {
+            case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
+
+            case PrimitiveKind::Bool: {
+                if (RG_UNLIKELY(!value.IsBoolean())) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected boolean", GetValueType(instance, value), member.name);
+                    return false;
+                }
+
+                bool b = value.As<Napi::Boolean>();
+                *(bool *)dest = 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 value %1 for member '%2', expected number", GetValueType(instance, value), member.name);
+                    return false;
+                }
+
+                int64_t v = CopyNumber<int64_t>(value);
+                memcpy(dest, &v, member.type->size); // Little Endian
+            } break;
+            case PrimitiveKind::String: {
+                if (RG_UNLIKELY(!value.IsString())) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected string", GetValueType(instance, value), member.name);
+                    return false;
+                }
+
+                const char *str = PushString(value);
+                if (RG_UNLIKELY(!str))
+                    return false;
+                *(const char **)dest = str;
+            } break;
+            case PrimitiveKind::String16: {
+                if (RG_UNLIKELY(!value.IsString())) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected string", GetValueType(instance, value), member.name);
+                    return false;
+                }
+
+                const char16_t *str16 = PushString16(value);
+                if (RG_UNLIKELY(!str16))
+                    return false;
+                *(const char16_t **)dest = str16;
+            } break;
+            case PrimitiveKind::Pointer: {
+                if (RG_UNLIKELY(!CheckValueTag(instance, value, member.type))) {
+                    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))) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected object", GetValueType(instance, value), member.name);
+                    return false;
+                }
+
+                Napi::Object obj = value.As<Napi::Object>();
+                if (!PushObject(obj, member.type, dest))
+                    return false;
+            } break;
+            case PrimitiveKind::Float32: {
+                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected number", GetValueType(instance, value), member.name);
+                    return false;
+                }
+
+                float f = CopyNumber<float>(value);
+                memcpy(dest, &f, 4);
+            } break;
+            case PrimitiveKind::Float64: {
+                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected number", GetValueType(instance, value), member.name);
+                    return false;
+                }
+
+                double d = CopyNumber<double>(value);
+                memcpy(dest, &d, 8);
+            } break;
+        }
+
+        dest += member.type->size;
+    }
+
+    return true;
+}
+
+void CallData::PopObject(Napi::Object obj, const uint8_t *ptr, const TypeInfo *type)
+{
+    Napi::Env env = obj.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    RG_ASSERT(type->primitive == PrimitiveKind::Record);
+
+    for (const RecordMember &member: type->members) {
+        ptr = AlignUp(ptr, member.align);
+
+        switch (member.type->primitive) {
+            case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
+
+            case PrimitiveKind::Bool: {
+                bool b = *(bool *)ptr;
+                obj.Set(member.name, Napi::Boolean::New(env, b));
+            } break;
+            case PrimitiveKind::Int8: {
+                double d = (double)*(int8_t *)ptr;
+                obj.Set(member.name, Napi::Number::New(env, d));
+            } break;
+            case PrimitiveKind::UInt8: {
+                double d = (double)*(uint8_t *)ptr;
+                obj.Set(member.name, Napi::Number::New(env, d));
+            } break;
+            case PrimitiveKind::Int16: {
+                double d = (double)*(int16_t *)ptr;
+                obj.Set(member.name, Napi::Number::New(env, d));
+            } break;
+            case PrimitiveKind::UInt16: {
+                double d = (double)*(uint16_t *)ptr;
+                obj.Set(member.name, Napi::Number::New(env, d));
+            } break;
+            case PrimitiveKind::Int32: {
+                double d = (double)*(int32_t *)ptr;
+                obj.Set(member.name, Napi::Number::New(env, d));
+            } break;
+            case PrimitiveKind::UInt32: {
+                double d = (double)*(uint32_t *)ptr;
+                obj.Set(member.name, Napi::Number::New(env, d));
+            } break;
+            case PrimitiveKind::Int64: {
+                int64_t v = *(int64_t *)ptr;
+                obj.Set(member.name, Napi::BigInt::New(env, v));
+            } break;
+            case PrimitiveKind::UInt64: {
+                uint64_t v = *(uint64_t *)ptr;
+                obj.Set(member.name, Napi::BigInt::New(env, v));
+            } break;
+            case PrimitiveKind::String: {
+                const char *str = *(const char **)ptr;
+                obj.Set(member.name, Napi::String::New(env, str));
+            } break;
+            case PrimitiveKind::String16: {
+                const char16_t *str16 = *(const char16_t **)ptr;
+                obj.Set(member.name, Napi::String::New(env, str16));
+            } break;
+            case PrimitiveKind::Pointer: {
+                void *ptr2 = *(void **)ptr;
+
+                Napi::External<void> external = Napi::External<void>::New(env, ptr2);
+                SetValueTag(instance, external, member.type);
+
+                obj.Set(member.name, external);
+            } break;
+            case PrimitiveKind::Record: {
+                Napi::Object obj2 = PopObject(ptr, member.type);
+                obj.Set(member.name, obj2);
+            } break;
+            case PrimitiveKind::Float32: {
+                float f;
+                memcpy(&f, ptr, 4);
+                obj.Set(member.name, Napi::Number::New(env, (double)f));
+            } break;
+            case PrimitiveKind::Float64: {
+                double d;
+                memcpy(&d, ptr, 8);
+                obj.Set(member.name, Napi::Number::New(env, d));
+            } break;
+        }
+
+        ptr += member.type->size;
+    }
+}
+
+Napi::Object CallData::PopObject(const uint8_t *ptr, const TypeInfo *type)
+{
+    Napi::Object obj = Napi::Object::New(env);
+    PopObject(obj, ptr, type);
+    return obj;
+}
+
+static void DumpMemory(const char *type, Span<const uint8_t> bytes)
+{
+    if (bytes.len) {
+        PrintLn(stderr, "%1 at 0x%2 (%3):", type, bytes.ptr, FmtMemSize(bytes.len));
+
+        for (const uint8_t *ptr = bytes.begin(); ptr < bytes.end();) {
+            Print(stderr, "  [0x%1 %2 %3]  ", FmtArg(ptr).Pad0(-16),
+                                              FmtArg((ptr - bytes.begin()) / sizeof(void *)).Pad(-4),
+                                              FmtArg(ptr - bytes.begin()).Pad(-4));
+            for (int i = 0; ptr < bytes.end() && i < (int)sizeof(void *); i++, ptr++) {
+                Print(stderr, " %1", FmtHex(*ptr).Pad0(-2));
+            }
+            PrintLn(stderr);
+        }
+    }
+}
+
+void CallData::DumpDebug() const
+{
+    PrintLn(stderr, "%!..+---- %1 (%2) ----%!0", func->name, CallConventionNames[(int)func->convention]);
+
+    if (func->parameters.len) {
+        PrintLn(stderr, "Parameters:");
+        for (Size i = 0; i < func->parameters.len; i++) {
+            const ParameterInfo &param = func->parameters[i];
+            PrintLn(stderr, "  %1 = %2 (%3)", i, param.type->name, FmtMemSize(param.type->size));
+        }
+    }
+    PrintLn(stderr, "Return: %1 (%2)", func->ret.type->name, FmtMemSize(func->ret.type->size));
+
+    DumpMemory("Stack", GetStack());
+    DumpMemory("Heap", GetHeap());
+}
+
+}

package/src/call.hh

@@ -14,15 +14,143 @@
 #pragma once
 
 #include "vendor/libcc/libcc.hh"
+#include "ffi.hh"
+#include "util.hh"
 
 #include <napi.h>
 
 namespace RG {
 
-struct InstanceData;
-struct FunctionInfo;
-
 bool AnalyseFunction(InstanceData *instance, FunctionInfo *func);
-Napi::Value TranslateCall(InstanceData *instance, const FunctionInfo *func, const Napi::CallbackInfo &info);
+
+class CallData {
+    Napi::Env env;
+    InstanceData *instance;
+    const FunctionInfo *func;
+
+    struct OutObject {
+        Napi::Object obj;
+        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;
+
+    Span<uint8_t> old_stack_mem;
+    Span<uint8_t> old_heap_mem;
+
+    union {
+        uint32_t u32;
+        uint64_t u64;
+        float f;
+        double d;
+        void *ptr;
+        uint8_t buf[32];
+    } result;
+    uint8_t *return_ptr = nullptr;
+
+public:
+    CallData(Napi::Env env, InstanceData *instance, const FunctionInfo *func);
+    ~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();
+
+    Napi::Value Run(const Napi::CallbackInfo &info)
+    {
+        if (!RG_UNLIKELY(Prepare(info)))
+            return env.Null();
+
+        if (instance->debug) {
+            DumpDebug();
+        }
+
+        Execute();
+        return Complete();
+    }
+
+    void DumpDebug() const;
+
+private:
+    template <typename T = void>
+    bool AllocStack(Size size, Size align, T **out_ptr = nullptr);
+    template <typename T = void>
+    bool AllocHeap(Size size, Size align, T **out_ptr = nullptr);
+
+    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);
+
+    void PopObject(Napi::Object obj, const uint8_t *ptr, const TypeInfo *type);
+    Napi::Object PopObject(const uint8_t *ptr, const TypeInfo *type);
+};
+
+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;
+
+    if (RG_UNLIKELY(stack_mem->len < delta)) {
+        ThrowError<Napi::Error>(env, "FFI call is taking up too much memory");
+        return false;
+    }
+
+    if (instance->debug) {
+        memset(ptr, 0, delta);
+    }
+
+    stack_mem->len -= delta;
+
+    if (out_ptr) {
+        *out_ptr = (T *)ptr;
+    }
+    return true;
+}
+
+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);
+
+    if (RG_UNLIKELY(delta > heap_mem->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);
+    }
+
+    heap_mem->ptr += delta;
+    heap_mem->len -= delta;
+
+    if (out_ptr) {
+        *out_ptr = (T *)ptr;
+    }
+    return true;
+}
 
 }

package/src/ffi.cc

@@ -247,7 +247,13 @@ static Napi::Value TranslateNormalCall(const Napi::CallbackInfo &info)
     InstanceData *instance = env.GetInstanceData<InstanceData>();
     FunctionInfo *func = (FunctionInfo *)info.Data();
 
-    return TranslateCall(instance, func, info);
+    if (info.Length() < (uint32_t)func->parameters.len) {
+        ThrowError<Napi::TypeError>(env, "Expected %1 arguments, got %2", func->parameters.len, info.Length());
+        return env.Null();
+    }
+
+    CallData call(env, instance, func);
+    return call.Run(info);
 }
 
 static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
@@ -265,6 +271,10 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
         func.parameters.Leak();
     };
 
+    if (info.Length() < (uint32_t)func.parameters.len) {
+        ThrowError<Napi::TypeError>(env, "Expected %1 arguments or more, got %2", func.parameters.len, info.Length());
+        return env.Null();
+    }
     if ((info.Length() - func.parameters.len) % 2) {
         ThrowError<Napi::Error>(env, "Missing value argument for variadic call");
         return env.Null();
@@ -299,7 +309,8 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
     if (!AnalyseFunction(instance, &func))
         return env.Null();
 
-    return TranslateCall(instance, &func, info);
+    CallData call(env, instance, &func);
+    return call.Run(info);
 }
 
 static bool ParseClassicFunction(Napi::Env env, Napi::String name, Napi::Value ret,
@@ -573,6 +584,8 @@ static Napi::Object InitBaseTypes(Napi::Env env)
     RegisterPrimitiveType(instance, "char", PrimitiveKind::Int8, 1, 1);
     RegisterPrimitiveType(instance, "uchar", PrimitiveKind::UInt8, 1, 1);
     RegisterPrimitiveType(instance, "unsigned char", PrimitiveKind::UInt8, 1, 1);
+    RegisterPrimitiveType(instance, "char16", PrimitiveKind::Int16, 2, 2);
+    RegisterPrimitiveType(instance, "char16_t", PrimitiveKind::Int16, 2, 2);
     RegisterPrimitiveType(instance, "int16", PrimitiveKind::Int16, 2, 2);
     RegisterPrimitiveType(instance, "int16_t", PrimitiveKind::Int16, 2, 2);
     RegisterPrimitiveType(instance, "uint16", PrimitiveKind::UInt16, 2, 2);
@@ -603,6 +616,7 @@ static Napi::Object InitBaseTypes(Napi::Env env)
     RegisterPrimitiveType(instance, "float", PrimitiveKind::Float32, 4, alignof(float));
     RegisterPrimitiveType(instance, "double", PrimitiveKind::Float64, 8, alignof(double));
     RegisterPrimitiveType(instance, "string", PrimitiveKind::String, RG_SIZE(void *), alignof(void *));
+    RegisterPrimitiveType(instance, "string16", PrimitiveKind::String16, RG_SIZE(void *), alignof(void *));
 
     Napi::Object types = Napi::Object::New(env);
     for (TypeInfo &type: instance->types) {

package/src/ffi.hh

@@ -26,7 +26,6 @@ extern const int TypeInfoMarker;
 
 enum class PrimitiveKind {
     Void,
-
     Bool,
     Int8,
     UInt8,
@@ -36,17 +35,15 @@ enum class PrimitiveKind {
     UInt32,
     Int64,
     UInt64,
-    Float32,
-    Float64,
     String,
-
+    String16,
     Pointer,
-
-    Record
+    Record,
+    Float32,
+    Float64
 };
 static const char *const PrimitiveKindNames[] = {
     "Void",
-
     "Bool",
     "Int8",
     "UInt8",
@@ -56,13 +53,12 @@ static const char *const PrimitiveKindNames[] = {
     "UInt32",
     "Int64",
     "UInt64",
-    "Float32",
-    "Float64",
     "String",
-
+    "String16",
     "Pointer",
-
-    "Record"
+    "Record",
+    "Float32",
+    "Float64"
 };
 
 struct TypeInfo;