koffi 1.0.2 → 1.0.5

package/src/util.cc

@@ -126,131 +126,4 @@ bool CheckValueTag(const InstanceData *instance, Napi::Value value, const void *
     return match;
 }
 
-void 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::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;
-            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(env, ptr, member.type);
-                obj.Set(member.name, obj2);
-            } break;
-        }
-
-        ptr += member.type->size;
-    }
-}
-
-void PopOutArguments(Span<const OutObject> objects)
-{
-    for (const OutObject &obj: objects) {
-        PopObject(obj.obj, obj.ptr, obj.type);
-    }
-}
-
-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/util.hh

@@ -89,20 +89,4 @@ T CopyNumber(const Napi::Value &value)
     RG_UNREACHABLE();
 }
 
-void PopObject(Napi::Object obj, const uint8_t *ptr, const TypeInfo *type);
-static inline Napi::Object PopObject(Napi::Env env, const uint8_t *ptr, const TypeInfo *type)
-{
-    Napi::Object obj = Napi::Object::New(env);
-    PopObject(obj, ptr, type);
-    return obj;
-}
-
-struct OutObject {
-    Napi::Object obj;
-    const uint8_t *ptr;
-    const TypeInfo *type;
-};
-
-void PopOutArguments(Span<const OutObject> objects);
-
 }

package/test/misc.c

@@ -54,6 +54,26 @@ typedef struct Pack3 {
     int c;
 } Pack3;
 
+typedef struct Float2 {
+    float a;
+    float b;
+} Float2;
+typedef struct Float3 {
+    float a;
+    float b;
+    float c;
+} Float3;
+
+typedef struct Double2 {
+    double a;
+    double b;
+} Double2;
+typedef struct Double3 {
+    double a;
+    double b;
+    double c;
+} Double3;
+
 typedef struct IJK1 { int8_t i; int8_t j; int8_t k; } IJK1;
 typedef struct IJK4 { int32_t i; int32_t j; int32_t k; } IJK4;
 typedef struct IJK8 { int64_t i; int64_t j; int64_t k; } IJK8;
@@ -149,6 +169,52 @@ EXPORT void FASTCALL AddPack3(int a, int b, int c, Pack3 *p)
     p->c += c;
 }
 
+EXPORT Float2 PackFloat2(float a, float b, Float2 *out)
+{
+    Float2 ret;
+
+    ret.a = a;
+    ret.b = b;
+    *out = ret;
+
+    return ret;
+}
+
+EXPORT Float3 PackFloat3(float a, float b, float c, Float3 *out)
+{
+    Float3 ret;
+
+    ret.a = a;
+    ret.b = b;
+    ret.c = c;
+    *out = ret;
+
+    return ret;
+}
+
+EXPORT Double2 PackDouble2(double a, double b, Double2 *out)
+{
+    Double2 ret;
+
+    ret.a = a;
+    ret.b = b;
+    *out = ret;
+
+    return ret;
+}
+
+EXPORT Double3 PackDouble3(double a, double b, double c, Double3 *out)
+{
+    Double3 ret;
+
+    ret.a = a;
+    ret.b = b;
+    ret.c = c;
+    *out = ret;
+
+    return ret;
+}
+
 EXPORT int64_t ConcatenateToInt1(int8_t a, int8_t b, int8_t c, int8_t d, int8_t e, int8_t f,
                                  int8_t g, int8_t h, int8_t i, int8_t j, int8_t k, int8_t l)
 {

package/test/misc.js

@@ -30,6 +30,26 @@ const Pack3 = koffi.struct('Pack3', {
     c: 'int'
 });
 
+const Float2 = koffi.struct('Float2', {
+    a: 'float',
+    b: 'float'
+});
+const Float3 = koffi.struct('Float3', {
+    a: 'float',
+    b: 'float',
+    c: 'float'
+});
+
+const Double2 = koffi.struct('Double2', {
+    a: 'double',
+    b: 'double'
+});
+const Double3 = koffi.struct('Double3', {
+    a: 'double',
+    b: 'double',
+    c: 'double'
+});
+
 const BFG = koffi.struct('BFG', {
     a: 'int8_t',
     b: 'int64_t',
@@ -78,6 +98,10 @@ async function test() {
     const FillPack3 = lib.func('FillPack3', 'void', ['int', 'int', 'int', koffi.out(koffi.pointer(Pack3))]);
     const RetPack3 = lib.func('RetPack3', Pack3, ['int', 'int', 'int']);
     const AddPack3 = lib.fastcall('AddPack3', 'void', ['int', 'int', 'int', koffi.inout(koffi.pointer(Pack3))]);
+    const PackFloat2 = lib.func('Float2 PackFloat2(float a, float b, _Out_ Float2 *out)');
+    const PackFloat3 = lib.func('Float3 PackFloat3(float a, float b, float c, _Out_ Float3 *out)');
+    const PackDouble2 = lib.func('Double2 PackDouble2(double a, double b, _Out_ Double2 *out)');
+    const PackDouble3 = lib.func('Double3 PackDouble3(double a, double b, double c, _Out_ Double3 *out)');
     const ConcatenateToInt1 = lib.func('ConcatenateToInt1', 'int64_t', Array(12).fill('int8_t'));
     const ConcatenateToInt4 = lib.func('ConcatenateToInt4', 'int64_t', Array(12).fill('int32_t'));
     const ConcatenateToInt8 = lib.func('ConcatenateToInt8', 'int64_t', Array(12).fill('int64_t'));
@@ -134,6 +158,29 @@ async function test() {
         assert.deepEqual(p, { a: 7, b: 11, c: -9 });
     }
 
+    // HFA tests
+    {
+        let f2p = {};
+        let f2 = PackFloat2(1.5, 3.0, f2p);
+        assert.deepEqual(f2, { a: 1.5, b: 3.0 });
+        assert.deepEqual(f2, f2p);
+
+        let f3p = {};
+        let f3 = PackFloat3(20.0, 30.0, 40.0, f3p);
+        assert.deepEqual(f3, { a: 20.0, b: 30.0, c: 40.0 });
+        assert.deepEqual(f3, f3p);
+
+        let d2p = {};
+        let d2 = PackDouble2(1.0, 2.0, d2p);
+        assert.deepEqual(d2, { a: 1.0, b: 2.0 });
+        assert.deepEqual(d2, d2p);
+
+        let d3p = {};
+        let d3 = PackDouble3(0.5, 10.0, 5.0, d3p);
+        assert.deepEqual(d3, { a: 0.5, b: 10.0, c: 5.0 });
+        assert.deepEqual(d3, d3p);
+    }
+
     // Many parameters
     {
         assert.equal(ConcatenateToInt1(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687n);

package/vendor/libcc/libcc.hh

@@ -3982,7 +3982,7 @@ void SignalWaitFor();
 int GetCoreCount();
 
 #ifndef _WIN32
-bool DropSetuid();
+bool DropRootIdentity();
 #endif
 #ifdef __linux__
 bool NotifySystemd();