koffi 1.1.5 → 1.2.0-alpha.3

package/src/call.hh

@@ -23,7 +23,11 @@ namespace RG {
 
 bool AnalyseFunction(InstanceData *instance, FunctionInfo *func);
 
-class CallData {
+struct BackRegisters;
+
+// I'm not sure why the alignas(8), because alignof(CallData) is 8 without it.
+// But on Windows i386, without it, the alignment may not be correct (compiler bug?).
+class alignas(8) CallData {
     struct OutObject {
         Napi::ObjectReference ref;
         const uint8_t *ptr;
@@ -37,9 +41,12 @@ class CallData {
     InstanceMemory *mem;
     Span<uint8_t> old_stack_mem;
     Span<uint8_t> old_heap_mem;
+    uint32_t used_trampolines = 0;
 
     LocalArray<OutObject, MaxOutParameters> out_objects;
-    uint8_t *sp;
+
+    uint8_t *new_sp;
+    uint8_t *old_sp;
 
     union {
         uint32_t u32;
@@ -61,6 +68,8 @@ public:
     void Execute();
     Napi::Value Complete();
 
+    void Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg);
+
     void DumpDebug() const;
 
 private:
@@ -77,6 +86,8 @@ private:
     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::Value PopArray(const uint8_t *src, const TypeInfo *type, int16_t realign = 0);
+
+    Size ReserveTrampoline(const FunctionInfo *proto, Napi::Function func);
 };
 
 template <typename T>
@@ -85,7 +96,8 @@ 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;
 
-    if (RG_UNLIKELY(mem->stack.len < delta)) {
+    // Keep 512 bytes for redzone (required in some ABIs)
+    if (RG_UNLIKELY(mem->stack.len - 512 < delta)) {
         ThrowError<Napi::Error>(env, "FFI call is taking up too much memory");
         return false;
     }
@@ -122,4 +134,6 @@ inline bool CallData::AllocHeap(Size size, Size align, T **out_ptr)
     return true;
 }
 
+void *GetTrampoline(Size idx, const FunctionInfo *proto);
+
 }

package/src/ffi.cc

@@ -40,11 +40,6 @@
 
 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;
 
@@ -325,6 +320,140 @@ static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
     return external;
 }
 
+static bool ParseClassicFunction(Napi::Env env, Napi::String name, Napi::Value ret,
+                                 Napi::Array parameters, FunctionInfo *func)
+{
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+#ifdef _WIN32
+    if (!name.IsString() && !name.IsNumber()) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string or integer", GetValueType(instance, name));
+        return false;
+    }
+#else
+    if (!name.IsString()) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string", GetValueType(instance, name));
+        return false;
+    }
+#endif
+
+    func->name = DuplicateString(name.ToString().Utf8Value().c_str(), &instance->str_alloc).ptr;
+
+    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;
+    }
+
+    uint32_t parameters_len = parameters.Length();
+
+    if (parameters_len) {
+        Napi::String str = ((Napi::Value)parameters[parameters_len - 1]).As<Napi::String>();
+
+        if (str.IsString() && str.Utf8Value() == "...") {
+            func->variadic = true;
+            parameters_len--;
+        }
+    }
+
+    for (uint32_t j = 0; j < parameters_len; j++) {
+        ParameterInfo param = {};
+
+        param.type = ResolveType(instance, parameters[j], &param.directions);
+        if (!param.type)
+            return false;
+        if (param.type->primitive == PrimitiveKind::Void ||
+                param.type->primitive == PrimitiveKind::Array) {
+            ThrowError<Napi::TypeError>(env, "Type %1 cannot be used as a parameter", param.type->name);
+            return false;
+        }
+
+        if (func->parameters.len >= MaxParameters) {
+            ThrowError<Napi::TypeError>(env, "Functions cannot have more than %1 parameters", MaxParameters);
+            return false;
+        }
+        if ((param.directions & 2) && ++func->out_parameters >= MaxOutParameters) {
+            ThrowError<Napi::TypeError>(env, "Functions cannot have more than out %1 parameters", MaxOutParameters);
+            return false;
+        }
+
+        param.offset = (int8_t)j;
+
+        func->parameters.Append(param);
+    }
+
+    return true;
+}
+
+static Napi::Value CreateCallbackType(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    FunctionInfo *func = instance->callbacks.AppendDefault();
+    RG_DEFER_N(err_guard) { instance->callbacks.RemoveLast(1); };
+
+    if (info.Length() >= 3) {
+        if (!ParseClassicFunction(env, info[0u].As<Napi::String>(), info[1u], info[2u].As<Napi::Array>(), func))
+            return env.Null();
+    } else if (info.Length() >= 1) {
+        if (!info[0].IsString()) {
+            ThrowError<Napi::TypeError>(env, "Unexpected %1 value for prototype, expected string", GetValueType(instance, info[0]));
+            return env.Null();
+        }
+
+        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());
+        return env.Null();
+    }
+
+    if (func->variadic) {
+        LogError("Variadic callbacks are not supported");
+        return env.Null();
+    }
+    if (func->convention != CallConvention::Cdecl &&
+            func->convention != CallConvention::Stdcall) {
+        ThrowError<Napi::Error>(env, "Only Cdecl and Stdcall callbacks are supported");
+        return env.Null();
+    }
+
+    if (!AnalyseFunction(instance, func))
+        return env.Null();
+
+    // We cannot fail after this check
+    if (instance->types_map.Find(func->name)) {
+        ThrowError<Napi::Error>(env, "Duplicate type name '%1'", func->name);
+        return env.Null();
+    }
+    err_guard.Disable();
+
+    TypeInfo *type = instance->types.AppendDefault();
+
+    type->name = func->name;
+
+    type->primitive = PrimitiveKind::Callback;
+    type->align = alignof(void *);
+    type->size = RG_SIZE(void *);
+    type->proto = func;
+
+    instance->types_map.Set(type);
+
+    Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, type);
+    SetValueTag(instance, external, &TypeInfoMarker);
+
+    return external;
+}
+
 static Napi::Value GetTypeSize(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
@@ -380,7 +509,7 @@ static Napi::Value GetTypeDefinition(const Napi::CallbackInfo &info)
     return type->defn.Value();
 }
 
-static InstanceMemory *AllocateAsyncMemory(InstanceData *instance)
+static InstanceMemory *AllocateMemory(InstanceData *instance)
 {
     for (Size i = 1; i < instance->memories.len; i++) {
         InstanceMemory *mem = instance->memories[i];
@@ -391,7 +520,7 @@ static InstanceMemory *AllocateAsyncMemory(InstanceData *instance)
 
     InstanceMemory *mem = new InstanceMemory();
 
-    mem->stack.len = AsyncStackSize;
+    mem->stack.len = StackSize;
 #if defined(_WIN32)
     mem->stack.ptr = (uint8_t *)VirtualAlloc(nullptr, mem->stack.len, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
 #elif defined(__APPLE__)
@@ -401,7 +530,7 @@ static InstanceMemory *AllocateAsyncMemory(InstanceData *instance)
 #endif
     RG_CRITICAL(mem->stack.ptr, "Failed to allocate %1 of memory", mem->stack.len);
 
-    mem->heap.len = AsyncHeapSize;
+    mem->heap.len = HeapSize;
 #ifdef _WIN32
     mem->heap.ptr = (uint8_t *)VirtualAlloc(nullptr, mem->heap.len, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
 #else
@@ -489,7 +618,7 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
         }
 
         param.variadic = true;
-        param.offset = i + 1;
+        param.offset = (int8_t)(i + 1);
 
         func.parameters.Append(param);
     }
@@ -581,7 +710,7 @@ static Napi::Value TranslateAsyncCall(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    InstanceMemory *mem = AllocateAsyncMemory(instance);
+    InstanceMemory *mem = AllocateMemory(instance);
     AsyncCall *async = new AsyncCall(env, instance, func, mem, callback);
 
     if (async->Prepare(info) && instance->debug) {
@@ -592,78 +721,6 @@ static Napi::Value TranslateAsyncCall(const Napi::CallbackInfo &info)
     return env.Null();
 }
 
-static bool ParseClassicFunction(Napi::Env env, Napi::String name, Napi::Value ret,
-                                 Napi::Array parameters, FunctionInfo *func)
-{
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
-
-#ifdef _WIN32
-    if (!name.IsString() && !name.IsNumber()) {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string or integer", GetValueType(instance, name));
-        return false;
-    }
-#else
-    if (!name.IsString()) {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string", GetValueType(instance, name));
-        return false;
-    }
-#endif
-
-    func->name = DuplicateString(name.ToString().Utf8Value().c_str(), &instance->str_alloc).ptr;
-
-    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;
-    }
-
-    uint32_t parameters_len = parameters.Length();
-
-    if (parameters_len) {
-        Napi::String str = ((Napi::Value)parameters[parameters_len - 1]).As<Napi::String>();
-
-        if (str.IsString() && str.Utf8Value() == "...") {
-            func->variadic = true;
-            parameters_len--;
-        }
-    }
-
-    for (uint32_t j = 0; j < parameters_len; j++) {
-        ParameterInfo param = {};
-
-        param.type = ResolveType(instance, parameters[j], &param.directions);
-        if (!param.type)
-            return false;
-        if (param.type->primitive == PrimitiveKind::Void ||
-                param.type->primitive == PrimitiveKind::Array) {
-            ThrowError<Napi::TypeError>(env, "Type %1 cannot be used as a parameter", param.type->name);
-            return false;
-        }
-
-        if (func->parameters.len >= MaxParameters) {
-            ThrowError<Napi::TypeError>(env, "Functions cannot have more than %1 parameters", MaxParameters);
-            return false;
-        }
-        if ((param.directions & 2) && ++func->out_parameters >= MaxOutParameters) {
-            ThrowError<Napi::TypeError>(env, "Functions cannot have more than out %1 parameters", MaxOutParameters);
-            return false;
-        }
-
-        param.offset = j;
-
-        func->parameters.Append(param);
-    }
-
-    return true;
-}
-
 static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConvention convention)
 {
     Napi::Env env = info.Env();
@@ -977,27 +1034,8 @@ InstanceMemory::~InstanceMemory()
 
 InstanceData::InstanceData()
 {
-    InstanceMemory *mem = new InstanceMemory();
-
-    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);
+    AllocateMemory(this);
+    RG_ASSERT(memories.len == 1);
 }
 
 InstanceData::~InstanceData()
@@ -1015,6 +1053,7 @@ static void SetExports(Napi::Env env, Func func)
     func("handle", Napi::Function::New(env, CreateHandleType));
     func("pointer", Napi::Function::New(env, CreatePointerType));
     func("array", Napi::Function::New(env, CreateArrayType));
+    func("callback", Napi::Function::New(env, CreateCallbackType));
     func("sizeof", Napi::Function::New(env, GetTypeSize));
     func("alignof", Napi::Function::New(env, GetTypeAlign));
     func("introspect", Napi::Function::New(env, GetTypeDefinition));

package/src/ffi.hh

@@ -19,8 +19,12 @@
 
 namespace RG {
 
+static const Size StackSize = Mebibytes(1);
+static const Size HeapSize = Mebibytes(2);
+
 static const Size MaxParameters = 32;
 static const Size MaxOutParameters = 8;
+static const Size MaxTrampolines = 16;
 
 extern const int TypeInfoMarker;
 
@@ -41,7 +45,8 @@ enum class PrimitiveKind {
     Record,
     Array,
     Float32,
-    Float64
+    Float64,
+    Callback
 };
 static const char *const PrimitiveKindNames[] = {
     "Void",
@@ -60,11 +65,13 @@ static const char *const PrimitiveKindNames[] = {
     "Record",
     "Array",
     "Float32",
-    "Float64"
+    "Float64",
+    "Callback"
 };
 
 struct TypeInfo;
 struct RecordMember;
+struct FunctionInfo;
 
 struct TypeInfo {
     enum class ArrayHint {
@@ -85,6 +92,7 @@ struct TypeInfo {
     HeapArray<RecordMember> members; // Record only
     const TypeInfo *ref; // Pointer or array
     ArrayHint hint; // Array only
+    const FunctionInfo *proto; // Callback only
 
     RG_HASHTABLE_HANDLER(TypeInfo, name);
 };
@@ -123,7 +131,7 @@ struct ParameterInfo {
     const TypeInfo *type;
     int directions;
     bool variadic;
-    Size offset;
+    int8_t offset;
 
     // ABI-specific part
 
@@ -149,11 +157,12 @@ struct ParameterInfo {
 #endif
 };
 
+// Also used for callbacks, even though many members are not used in this case
 struct FunctionInfo {
     mutable std::atomic_int refcount {1};
 
     const char *name;
-    const char *decorated_name;
+    const char *decorated_name; // Only set for some platforms/calling conventions
     const LibraryHolder *lib = nullptr;
 
     void *func;
@@ -161,7 +170,7 @@ struct FunctionInfo {
 
     ParameterInfo ret;
     HeapArray<ParameterInfo> parameters;
-    Size out_parameters;
+    int8_t out_parameters;
     bool variadic;
 
     // ABI-specific part
@@ -190,19 +199,29 @@ struct InstanceMemory {
     bool temporary;
 };
 
+struct TrampolineInfo {
+    const FunctionInfo *proto;
+    Napi::Function func;
+};
+
 struct InstanceData {
     InstanceData();
     ~InstanceData();
 
     BucketArray<TypeInfo> types;
     HashTable<const char *, TypeInfo *> types_map;
+    BucketArray<FunctionInfo> callbacks;
 
     bool debug;
     uint64_t tag_lower;
 
     LocalArray<InstanceMemory *, 6> memories;
 
+    TrampolineInfo trampolines[MaxTrampolines];
+    uint32_t free_trampolines = UINT32_MAX;
+
     BlockAllocator str_alloc;
 };
+RG_STATIC_ASSERT(MaxTrampolines <= 32);
 
 }

package/src/parser.cc

@@ -87,7 +87,7 @@ bool PrototypeParser::Parse(const char *str, FunctionInfo *out_func)
                 return false;
             }
 
-            param.offset = out_func->parameters.len;
+            param.offset = (int8_t)out_func->parameters.len;
 
             out_func->parameters.Append(param);
 

package/test/misc.c

@@ -120,6 +120,10 @@ typedef struct FixedWide {
     int16_t buf[64];
 } FixedWide;
 
+typedef struct SingleU32 { uint32_t v; } SingleU32;
+typedef struct SingleU64 { uint64_t v; } SingleU64;
+typedef struct SingleI64 { int64_t v; } SingleI64;
+
 EXPORT void FillPack1(int a, Pack1 *p)
 {
     p->a = a;
@@ -410,3 +414,73 @@ EXPORT FixedWide ReturnFixedWide(FixedWide str)
 {
     return str;
 }
+
+EXPORT uint32_t ThroughUInt32UU(uint32_t v)
+{
+    return v;
+}
+EXPORT SingleU32 ThroughUInt32SS(SingleU32 s)
+{
+    return s;
+}
+EXPORT SingleU32 ThroughUInt32SU(uint32_t v)
+{
+    SingleU32 s;
+    s.v = v;
+    return s;
+}
+EXPORT uint32_t ThroughUInt32US(SingleU32 s)
+{
+    return s.v;
+}
+
+EXPORT uint64_t ThroughUInt64UU(uint64_t v)
+{
+    return v;
+}
+EXPORT SingleU64 ThroughUInt64SS(SingleU64 s)
+{
+    return s;
+}
+EXPORT SingleU64 ThroughUInt64SU(uint64_t v)
+{
+    SingleU64 s;
+    s.v = v;
+    return s;
+}
+EXPORT uint64_t ThroughUInt64US(SingleU64 s)
+{
+    return s.v;
+}
+
+EXPORT int64_t ThroughInt64II(int64_t v)
+{
+    return v;
+}
+EXPORT SingleI64 ThroughInt64SS(SingleI64 s)
+{
+    return s;
+}
+EXPORT SingleI64 ThroughInt64SI(int64_t v)
+{
+    SingleI64 s;
+    s.v = v;
+    return s;
+}
+EXPORT int64_t ThroughInt64IS(SingleI64 s)
+{
+    return s.v;
+}
+
+EXPORT float CallSimpleJS(int i, float (*func)(int i, const char *str, double d))
+{
+    float f = func(i, "Hello!", 42.0);
+    return f;
+}
+
+EXPORT int TransferToJS(const char *str, int (*cb)(const char *str))
+{
+    char buf[64];
+    snprintf(buf, sizeof(buf), "Hello %s!", str);
+    return cb(buf);
+}