koffi 1.2.4 → 1.3.0-rc.1

package/src/call.hh

@@ -28,8 +28,8 @@ 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;
+    struct OutArgument {
+        napi_ref ref;
         const uint8_t *ptr;
         const TypeInfo *type;
     };
@@ -44,7 +44,7 @@ class alignas(8) CallData {
 
     uint32_t used_trampolines = 0;
 
-    LocalArray<OutObject, MaxOutParameters> out_objects;
+    LocalArray<OutArgument, MaxOutParameters> out_arguments;
 
     uint8_t *new_sp;
     uint8_t *old_sp;
@@ -79,15 +79,22 @@ private:
     template <typename T = uint8_t>
     T *AllocHeap(Size size, Size align);
 
-    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 *origin, int16_t realign = 0);
-    bool PushArray(const Napi::Value &obj, const TypeInfo *type, uint8_t *origin, int16_t realign = 0);
+    const char *PushString(Napi::Value value);
+    const char16_t *PushString16(Napi::Value value);
+    bool PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origin, int16_t realign = 0);
+    bool PushNormalArray(Napi::Array array, Size len, const TypeInfo *ref, uint8_t *origin, int16_t realign = 0);
+    bool PushTypedArray(Napi::TypedArray array, Size len, const TypeInfo *ref, uint8_t *origin, int16_t realign = 0);
+    bool PushStringArray(Napi::Value value, const TypeInfo *type, uint8_t *origin);
+    bool PushPointer(Napi::Value value, const ParameterInfo &param, void **out_ptr);
 
     void PopObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type, int16_t realign = 0);
     Napi::Object PopObject(const uint8_t *origin, const TypeInfo *type, int16_t realign = 0);
+    void PopNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo *ref, int16_t realign = 0);
+    void PopTypedArray(Napi::TypedArray array, const uint8_t *origin, const TypeInfo *ref, int16_t realign = 0);
     Napi::Value PopArray(const uint8_t *origin, const TypeInfo *type, int16_t realign = 0);
 
+    void PopOutArguments();
+
     void *ReserveTrampoline(const FunctionInfo *proto, Napi::Function func);
 };
 

package/src/ffi.cc

@@ -168,6 +168,8 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
     type->primitive = PrimitiveKind::Record;
     type->align = 1;
 
+    HashSet<const char *> members;
+
     for (uint32_t i = 0; i < keys.Length(); i++) {
         RecordMember member = {};
 
@@ -188,6 +190,11 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
         type->size = (int16_t)(AlignLen(type->size, member.align) + member.type->size);
         type->align = std::max(type->align, member.align);
 
+        if (!members.TrySet(member.name).second) {
+            ThrowError<Napi::Error>(env, "Duplicate member '%1' in struct '%2'", member.name, type->name);
+            return env.Null();
+        }
+
         type->members.Append(member);
     }
 
@@ -314,10 +321,6 @@ static Napi::Value EncodePointerDirection(const Napi::CallbackInfo &info, int di
         ThrowError<Napi::TypeError>(env, "Unexpected %1 type, expected pointer type", PrimitiveKindNames[(int)type->primitive]);
         return env.Null();
     }
-    if ((directions & 2) && type->ref->primitive != PrimitiveKind::Record) {
-        ThrowError<Napi::TypeError>(env, "Only objects can be used as out parameters (for now)");
-        return env.Null();
-    }
 
     // We need to lose the const for Napi::External to work
     TypeInfo *marked = (TypeInfo *)((uint8_t *)type + directions - 1);
@@ -357,6 +360,20 @@ static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
         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 positive and non-zero");
+        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::ArrayHint hint;
     if (info.Length() >= 3 && !IsNullOrUndefined(info[2])) {
         if (!info[2].IsString()) {
@@ -371,29 +388,23 @@ static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
         } else if (to == "array") {
             hint = TypeInfo::ArrayHint::Array;
         } else if (to == "string") {
+            if (ref->primitive != PrimitiveKind::Int8 && ref->primitive != PrimitiveKind::Int16) {
+                ThrowError<Napi::Error>(env, "Array hint 'string' can only be used with 8 and 16-bit signed integer types");
+                return env.Null();
+            }
+
             hint = TypeInfo::ArrayHint::String;
         } else {
-            ThrowError<Napi::Error>(env, "Array conversion hint must be 'typed' or 'array'");
+            ThrowError<Napi::Error>(env, "Array conversion hint must be 'typed', 'array' or 'string'");
             return env.Null();
         }
+    } else if (TestStr(ref->name, "char") || TestStr(ref->name, "char16") ||
+                                             TestStr(ref->name, "char16_t")) {
+        hint = TypeInfo::ArrayHint::String;
     } else {
         hint = TypeInfo::ArrayHint::TypedArray;
     }
 
-    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 positive and non-zero");
-        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();
 
     type->name = Fmt(&instance->str_alloc, "%1[%2]", ref->name, len).ptr;
@@ -1011,6 +1022,16 @@ static void RegisterPrimitiveType(InstanceData *instance, const char *name, Prim
     instance->types_map.Set(type);
 }
 
+static inline PrimitiveKind GetLongPrimitive(bool sign)
+{
+    switch (RG_SIZE(long)) {
+        case 4: return sign ? PrimitiveKind::Int32 : PrimitiveKind::UInt32;
+        case 8: return sign ? PrimitiveKind::Int64 : PrimitiveKind::UInt64;
+    }
+
+    RG_UNREACHABLE();
+}
+
 static Napi::Object InitBaseTypes(Napi::Env env)
 {
     InstanceData *instance = env.GetInstanceData<InstanceData>();
@@ -1047,13 +1068,13 @@ static Napi::Object InitBaseTypes(Napi::Env env)
     RegisterPrimitiveType(instance, "int64_t", PrimitiveKind::Int64, 8, alignof(int64_t));
     RegisterPrimitiveType(instance, "uint64", PrimitiveKind::UInt64, 8, alignof(int64_t));
     RegisterPrimitiveType(instance, "uint64_t", PrimitiveKind::UInt64, 8, alignof(int64_t));
-    RegisterPrimitiveType(instance, "long", PrimitiveKind::Int64, RG_SIZE(long), alignof(long));
-    RegisterPrimitiveType(instance, "ulong", PrimitiveKind::UInt64, RG_SIZE(long), alignof(long));
-    RegisterPrimitiveType(instance, "unsigned long", PrimitiveKind::UInt64, RG_SIZE(long), alignof(long));
-    RegisterPrimitiveType(instance, "longlong", PrimitiveKind::Int64, RG_SIZE(long long), alignof(long long));
-    RegisterPrimitiveType(instance, "long long", PrimitiveKind::Int64, RG_SIZE(long long), alignof(long long));
-    RegisterPrimitiveType(instance, "ulonglong", PrimitiveKind::UInt64, RG_SIZE(long long), alignof(long long));
-    RegisterPrimitiveType(instance, "unsigned long long", PrimitiveKind::UInt64, RG_SIZE(long long), alignof(long long));
+    RegisterPrimitiveType(instance, "long", GetLongPrimitive(true), RG_SIZE(long), alignof(long));
+    RegisterPrimitiveType(instance, "ulong", GetLongPrimitive(false), RG_SIZE(long), alignof(long));
+    RegisterPrimitiveType(instance, "unsigned long", GetLongPrimitive(false), RG_SIZE(long), alignof(long));
+    RegisterPrimitiveType(instance, "longlong", PrimitiveKind::Int64, RG_SIZE(int64_t), alignof(int64_t));
+    RegisterPrimitiveType(instance, "long long", PrimitiveKind::Int64, RG_SIZE(int64_t), alignof(int64_t));
+    RegisterPrimitiveType(instance, "ulonglong", PrimitiveKind::UInt64, RG_SIZE(uint64_t), alignof(uint64_t));
+    RegisterPrimitiveType(instance, "unsigned long long", PrimitiveKind::UInt64, RG_SIZE(uint64_t), alignof(uint64_t));
     RegisterPrimitiveType(instance, "float32", PrimitiveKind::Float32, 4, alignof(float));
     RegisterPrimitiveType(instance, "float64", PrimitiveKind::Float64, 8, alignof(double));
     RegisterPrimitiveType(instance, "float", PrimitiveKind::Float32, 4, alignof(float));

package/src/ffi.hh

@@ -26,7 +26,7 @@ static const Size DefaultAsyncHeapSize = Mebibytes(1);
 static const int DefaultResidentAsyncPools = 2;
 
 static const Size MaxParameters = 32;
-static const Size MaxOutParameters = 8;
+static const Size MaxOutParameters = 4;
 static const Size MaxTrampolines = 16;
 
 extern const int TypeInfoMarker;

package/src/parser.cc

@@ -70,9 +70,8 @@ bool PrototypeParser::Parse(const char *str, FunctionInfo *out_func)
                 return false;
             }
 
-            if ((param.directions & 2) && (param.type->primitive != PrimitiveKind::Pointer ||
-                                           param.type->ref->primitive != PrimitiveKind::Record)) {
-                MarkError("Only object pointers can be used as out parameters (for now)");
+            if ((param.directions & 2) && param.type->primitive != PrimitiveKind::Pointer) {
+                MarkError("Only pointers can be used for output parameters");
                 return false;
             }
 
@@ -171,23 +170,6 @@ const TypeInfo *PrototypeParser::ParseType()
     }
     buf.ptr[--buf.len] = 0;
 
-    if (indirect) {
-        const TypeInfo *type = instance->types_map.FindValue(buf.ptr, nullptr);
-        PrimitiveKind primitive = type ? type->primitive : PrimitiveKind::Void;
-
-        if (primitive == PrimitiveKind::Int8 || primitive == PrimitiveKind::UInt8) {
-            buf.RemoveFrom(0);
-            Fmt(&buf, "string");
-
-            indirect--;
-        } else if (primitive == PrimitiveKind::Int16 || primitive == PrimitiveKind::UInt16) {
-            buf.RemoveFrom(0);
-            Fmt(&buf, "string16");
-
-            indirect--;
-        }
-    }
-
     while (buf.len) {
         const TypeInfo *type = instance->types_map.FindValue(buf.ptr, nullptr);
 

package/src/util.cc

@@ -91,20 +91,41 @@ const char *GetValueType(const InstanceData *instance, Napi::Value value)
             return type.name;
     }
 
+    if (value.IsArray()) {
+        return "Array";
+    } else if (value.IsTypedArray()) {
+        Napi::TypedArray array = value.As<Napi::TypedArray>();
+
+        switch (array.TypedArrayType()) {
+            case napi_int8_array: return "Int8Array";
+            case napi_uint8_array: return "Uint8Array";
+            case napi_uint8_clamped_array: return "Uint8ClampedArray";
+            case napi_int16_array: return "Int16Array";
+            case napi_uint16_array: return "Uint16Array";
+            case napi_int32_array: return "Int32Array";
+            case napi_uint32_array: return "Uint32Array";
+            case napi_float32_array: return "Float32Array";
+            case napi_float64_array: return "Float64Array";
+            case napi_bigint64_array: return "BigInt64Array";
+            case napi_biguint64_array: return "BigUint64Array";
+        }
+    }
+
     switch (value.Type()) {
-        case napi_undefined: return "undefined";
-        case napi_null: return "null";
-        case napi_boolean: return "boolean";
-        case napi_number: return "number";
-        case napi_string: return "string";
-        case napi_symbol: return "symbol";
-        case napi_object: return "object";
-        case napi_function: return "fucntion";
-        case napi_external: return "external";
-        case napi_bigint: return "bigint";
+        case napi_undefined: return "Undefined";
+        case napi_null: return "Null";
+        case napi_boolean: return "Boolean";
+        case napi_number: return "Number";
+        case napi_string: return "String";
+        case napi_symbol: return "Symbol";
+        case napi_object: return "Object";
+        case napi_function: return "Function";
+        case napi_external: return "External";
+        case napi_bigint: return "BigInt";
     }
 
-    return "unknown";
+    // This should not be possible, but who knows...
+    return "Unknown";
 }
 
 void SetValueTag(const InstanceData *instance, Napi::Value value, const void *marker)
@@ -126,6 +147,24 @@ bool CheckValueTag(const InstanceData *instance, Napi::Value value, const void *
     return match;
 }
 
+int GetTypedArrayType(const TypeInfo *type)
+{
+    switch (type->primitive) {
+        case PrimitiveKind::Int8: return napi_int8_array;
+        case PrimitiveKind::UInt8: return napi_uint8_array;
+        case PrimitiveKind::Int16: return napi_int16_array;
+        case PrimitiveKind::UInt16: return napi_uint16_array;
+        case PrimitiveKind::Int32: return napi_int32_array;
+        case PrimitiveKind::UInt32: return napi_uint32_array;
+        case PrimitiveKind::Float32: return napi_float32_array;
+        case PrimitiveKind::Float64: return napi_float64_array;
+
+        default: return -1;
+    }
+
+    RG_UNREACHABLE();
+}
+
 static int AnalyseFlatRec(const TypeInfo *type, int offset, int count, FunctionRef<void(const TypeInfo *type, int offset, int count)> func)
 {
     if (type->primitive == PrimitiveKind::Record) {

package/src/util.hh

@@ -86,6 +86,8 @@ static inline bool IsObject(Napi::Value value)
     return value.IsObject() && !IsNullOrUndefined(value) && !value.IsArray();
 }
 
+int GetTypedArrayType(const TypeInfo *type);
+
 template <typename T>
 T CopyNumber(const Napi::Value &value)
 {

package/test/misc.c

@@ -124,6 +124,11 @@ typedef struct SingleU32 { uint32_t v; } SingleU32;
 typedef struct SingleU64 { uint64_t v; } SingleU64;
 typedef struct SingleI64 { int64_t v; } SingleI64;
 
+typedef struct IntContainer {
+    int values[16];
+    int len;
+} IntContainer;
+
 EXPORT void FillPack1(int a, Pack1 *p)
 {
     p->a = a;
@@ -512,3 +517,29 @@ EXPORT int ApplyStd(int a, int b, int c, ApplyCallback *func)
     int ret = func(a, b, c);
     return ret;
 }
+
+EXPORT IntContainer ArrayToStruct(int *values, int len)
+{
+    IntContainer ic;
+
+    memset(&ic, 0, sizeof(ic));
+    memcpy(ic.values, values, len * sizeof(*values));
+    ic.len = len;
+
+    return ic;
+}
+
+EXPORT void FillRange(int init, int step, int *out, int len)
+{
+    while (--len >= 0) {
+        *(out++) = init;
+        init += step;
+    }
+}
+
+EXPORT void MultiplyIntegers(int multiplier, int *values, int len)
+{
+    for (int i = 0; i < len; i++) {
+        values[i] *= multiplier;
+    }
+}

package/test/sync.js

@@ -84,23 +84,28 @@ const PackedBFG = koffi.pack('PackedBFG', {
 });
 
 const FixedString = koffi.struct('FixedString', {
-    buf: koffi.array('char', 64)
+    buf: koffi.array('int8', 64)
 });
 const FixedString2 = koffi.struct('FixedString2', {
-    buf: koffi.array('char', 64, 'string')
+    buf: koffi.array('char', 64)
 });
 
 const FixedWide = koffi.struct('FixedWide', {
-    buf: koffi.array('char16', 64)
+    buf: koffi.array('char16', 64, 'typed')
 });
 const FixedWide2 = koffi.struct('FixedWide2', {
-    buf: koffi.array('char16', 64, 'string')
+    buf: koffi.array('char16', 64)
 });
 
 const SingleU32 = koffi.struct('SingleU32', { v: 'uint32_t' });
 const SingleU64 = koffi.struct('SingleU64', { v: 'uint64_t' });
 const SingleI64 = koffi.struct('SingleI64', { v: 'int64_t' });
 
+const IntContainer = koffi.struct('IntContainer', {
+    values: koffi.array('int', 16),
+    len: 'int'
+});
+
 main();
 
 async function main() {
@@ -163,6 +168,9 @@ async function test() {
     const ThroughInt64SS = lib.func('SingleI64 ThroughInt64SS(SingleI64 s)');
     const ThroughInt64SI = lib.func('SingleI64 ThroughInt64SI(int64_t v)');
     const ThroughInt64IS = lib.func('int64_t ThroughInt64IS(SingleI64 s)');
+    const ArrayToStruct = lib.func('IntContainer ArrayToStruct(int *ptr, int len)');
+    const FillRange = lib.func('void FillRange(int init, int step, _Out_ int *out, int len)');
+    const MultiplyIntegers = lib.func('void MultiplyIntegers(int multiplier, _Inout_ int *values, int len)');
 
     // Simple tests with Pack1
     {
@@ -320,4 +328,33 @@ async function test() {
         assert.deepEqual(ThroughInt64SI(-9223372036854775803n), { v: -9223372036854775803n });
         assert.equal(ThroughInt64IS({ v: -9223372036854775803n }), -9223372036854775803n);
     }
+
+    // Array pointers as input
+    {
+        let arr1 = [5, 7, 8, 4];
+        let arr2 = Int32Array.from([8, 454, 6, 3, 45]);
+
+        assert.deepEqual(ArrayToStruct(arr1, 0), { values: Int32Array.from(Array(16).fill(0)), len: 0 });
+        assert.deepEqual(ArrayToStruct(arr1, 3), { values: Int32Array.from([5, 7, 8, ...Array(13).fill(0)]), len: 3 });
+        assert.deepEqual(ArrayToStruct(arr2, 4), { values: Int32Array.from([8, 454, 6, 3, ...Array(12).fill(0)]), len: 4 });
+        assert.deepEqual(ArrayToStruct(arr2, 2), { values: Int32Array.from([8, 454, ...Array(14).fill(0)]), len: 2 });
+    }
+
+    // Array pointers as output
+    {
+        let out1 = Array(10);
+        let out2 = new Int32Array(10);
+        let mult = -3;
+
+        FillRange(2, 7, out1, out1.length);
+        FillRange(13, 3, out2, out2.length);
+
+        assert.deepEqual(out1, [2, 9, 16, 23, 30, 37, 44, 51, 58, 65]);
+        assert.deepEqual(out2, new Int32Array([13, 16, 19, 22, 25, 28, 31, 34, 37, 40]));
+
+        MultiplyIntegers(-1, out1, out1.length - 2);
+        MultiplyIntegers(3, out2, out2.length - 3);
+        assert.deepEqual(out1, [-2, -9, -16, -23, -30, -37, -44, -51, 58, 65]);
+        assert.deepEqual(out2, new Int32Array([3 * 13, 3 * 16, 3 * 19, 3 * 22, 3 * 25, 3 * 28, 3 * 31, 34, 37, 40]));
+    }
 }

package/benchmark/atoi_cc.cc

@@ -1,59 +0,0 @@
-// 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"
-
-namespace RG {
-
-static const char * strings[] = {
-    "424242",
-    "foobar",
-    "123456789",
-};
-
-volatile uint64_t sum = 0;
-
-int Main(int argc, char **argv)
-{
-    int iterations = 20000000;
-
-    if (argc >= 2) {
-        if (!ParseInt(argv[1], &iterations))
-            return 1;
-    }
-    LogInfo("Iterations: %1", iterations);
-
-    int64_t start = GetMonotonicTime();
-
-    for (int i = 0; i < iterations; i++) {
-        sum = sum + (uint64_t)atoi(strings[i % RG_LEN(strings)]);
-    }
-
-    // Help prevent optimisation of loop
-    {
-        PushLogFilter([](LogLevel, const char *, const char *, FunctionRef<LogFunc>) {});
-        RG_DEFER { PopLogFilter(); };
-
-        LogInfo("Sum = %1", sum);
-    }
-
-    int64_t time = GetMonotonicTime() - start;
-    LogInfo("Time: %1s", FmtDouble((double)time / 1000.0, 2));
-
-    return 0;
-}
-
-}
-
-// C++ namespaces are stupid
-int main(int argc, char **argv) { return RG::Main(argc, argv); }