koffi 1.0.3 → 1.1.0-beta.0

package/src/ffi.hh

@@ -26,7 +26,6 @@ extern const int TypeInfoMarker;
 
 enum class PrimitiveKind {
     Void,
-
     Bool,
     Int8,
     UInt8,
@@ -36,18 +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",
@@ -57,14 +53,12 @@ static const char *const PrimitiveKindNames[] = {
     "UInt32",
     "Int64",
     "UInt64",
-    "Float32",
-    "Float64",
     "String",
     "String16",
-
     "Pointer",
-
-    "Record"
+    "Record",
+    "Float32",
+    "Float64"
 };
 
 struct TypeInfo;
@@ -92,13 +86,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 {
@@ -138,11 +132,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;
@@ -158,10 +152,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;
@@ -169,12 +180,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/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)
 {
@@ -209,7 +275,7 @@ EXPORT BFG STDCALL MakeBFG(BFG *p, int x, double y, const char *str)
 {
     BFG bfg;
 
-    char buf[64];
+    static char buf[64];
     snprintf(buf, sizeof(buf), "X/%s/X", str);
 
     bfg.a = x;
@@ -228,7 +294,7 @@ EXPORT PackedBFG FASTCALL MakePackedBFG(int x, double y, PackedBFG *p, const cha
 {
     PackedBFG bfg;
 
-    char buf[64];
+    static char buf[64];
     snprintf(buf, sizeof(buf), "X/%s/X", str);
 
     bfg.a = x;

package/vendor/libcc/libcc.hh

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

package/test/misc.js

@@ -1,180 +0,0 @@
-#!/usr/bin/env node
-
-// 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/.
-
-const koffi = require('./build/koffi.node');
-const assert = require('assert');
-const path = require('path');
-
-const Pack1 = koffi.struct('Pack1', {
-    a: 'int'
-});
-const Pack2 = koffi.struct('Pack2', {
-    a: 'int',
-    b: 'int'
-});
-const Pack3 = koffi.struct('Pack3', {
-    a: 'int',
-    b: 'int',
-    c: 'int'
-});
-
-const BFG = koffi.struct('BFG', {
-    a: 'int8_t',
-    b: 'int64_t',
-    c: 'char',
-    d: 'string',
-    e: 'short',
-    inner: koffi.struct({
-        f: 'float',
-        g: 'double'
-    })
-});
-const PackedBFG = koffi.pack('PackedBFG', {
-    a: 'int8_t',
-    b: 'int64_t',
-    c: 'char',
-    d: 'string',
-    e: 'short',
-    inner: koffi.pack({
-        f: 'float',
-        g: 'double'
-    })
-});
-
-main();
-
-async function main() {
-    try {
-        await test();
-        console.log('Success!');
-    } catch (err) {
-        console.error(err);
-        process.exit(1);
-    }
-}
-
-async function test() {
-    let lib_filename = path.dirname(__filename) + '/build/misc' + koffi.extension;
-    let lib = koffi.load(lib_filename);
-
-    const FillPack1 = lib.func('FillPack1', 'void', ['int', koffi.out(koffi.pointer(Pack1))]);
-    const RetPack1 = lib.func('RetPack1', Pack1, ['int']);
-    const AddPack1 = lib.fastcall('AddPack1', 'void', ['int', koffi.inout(koffi.pointer(Pack1))]);
-    const FillPack2 = lib.func('FillPack2', 'void', ['int', 'int', koffi.out(koffi.pointer(Pack2))]);
-    const RetPack2 = lib.func('RetPack2', Pack2, ['int', 'int']);
-    const AddPack2 = lib.fastcall('AddPack2', 'void', ['int', 'int', koffi.inout(koffi.pointer(Pack2))]);
-    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 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'));
-    const ConcatenateToStr1 = lib.func('ConcatenateToStr1', 'string', [...Array(8).fill('int8_t'), koffi.struct('IJK1', {i: 'int8_t', j: 'int8_t', k: 'int8_t'}), 'int8_t']);
-    const ConcatenateToStr4 = lib.func('ConcatenateToStr4', 'string', [...Array(8).fill('int32_t'), koffi.pointer(koffi.struct('IJK4', {i: 'int32_t', j: 'int32_t', k: 'int32_t'})), 'int32_t']);
-    const ConcatenateToStr8 = lib.func('ConcatenateToStr8', 'string', [...Array(8).fill('int64_t'), koffi.struct('IJK8', {i: 'int64_t', j: 'int64_t', k: 'int64_t'}), 'int64_t']);
-    const MakeBFG = lib.func('BFG __stdcall MakeBFG(_Out_ BFG *p, int x, double y, const char *str)');
-    const MakePackedBFG = lib.func('PackedBFG __fastcall MakePackedBFG(int x, double y, _Out_ PackedBFG *p, const char *str)');
-    const ReturnBigString = process.platform == 'win32' ?
-                            lib.stdcall(1, 'string', ['string']) :
-                            lib.func('const char * __stdcall ReturnBigString(const char *str)');
-    const PrintFmt = lib.func('const char *PrintFmt(const char *fmt, ...)');
-    const Concat16 = lib.func('const char16_t *Concat16(const char16_t *str1, const char16_t *str2)')
-
-    // Simple tests with Pack1
-    {
-        let p = {};
-
-        FillPack1(777, p);
-        assert.deepEqual(p, { a: 777 });
-
-        let q = RetPack1(6);
-        assert.deepEqual(q, { a: 6 });
-
-        AddPack1(6, p);
-        assert.deepEqual(p, { a: 783 });
-    }
-
-    // Simple tests with Pack2
-    {
-        let p = {};
-
-        FillPack2(123, 456, p);
-        assert.deepEqual(p, { a: 123, b: 456 });
-
-        let q = RetPack2(6, 9);
-        assert.deepEqual(q, { a: 6, b: 9 });
-
-        AddPack2(6, 9, p);
-        assert.deepEqual(p, { a: 129, b: 465 });
-    }
-
-    // Simple tests with Pack3
-    {
-        let p = {};
-
-        FillPack3(1, 2, 3, p);
-        assert.deepEqual(p, { a: 1, b: 2, c: 3 });
-
-        let q = RetPack3(6, 9, -12);
-        assert.deepEqual(q, { a: 6, b: 9, c: -12 });
-
-        AddPack3(6, 9, -12, p);
-        assert.deepEqual(p, { a: 7, b: 11, c: -9 });
-    }
-
-    // Many parameters
-    {
-        assert.equal(ConcatenateToInt1(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687n);
-        assert.equal(ConcatenateToInt4(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687n);
-        assert.equal(ConcatenateToInt8(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687n);
-        assert.equal(ConcatenateToStr1(5, 6, 1, 2, 3, 9, 4, 4, {i: 0, j: 6, k: 8}, 7), '561239440687');
-        assert.equal(ConcatenateToStr4(5, 6, 1, 2, 3, 9, 4, 4, {i: 0, j: 6, k: 8}, 7), '561239440687');
-        assert.equal(ConcatenateToStr8(5, 6, 1, 2, 3, 9, 4, 4, {i: 0, j: 6, k: 8}, 7), '561239440687');
-    }
-
-    // Big struct
-    {
-        let out = {};
-        let bfg = MakeBFG(out, 2, 7, '__Hello123456789++++foobarFOOBAR!__');
-        assert.deepEqual(bfg, { a: 2, b: 4, c: -25, d: 'X/__Hello123456789++++foobarFOOBAR!__/X', e: 54, inner: { f: 14, g: 5 } });
-        assert.deepEqual(out, bfg);
-    }
-
-    // Packed struct
-    {
-        let out = {};
-        let bfg = MakePackedBFG(2, 7, out, '__Hello123456789++++foobarFOOBAR!__');
-        assert.deepEqual(bfg, { a: 2, b: 4, c: -25, d: 'X/__Hello123456789++++foobarFOOBAR!__/X', e: 54, inner: { f: 14, g: 5 } });
-        assert.deepEqual(out, bfg);
-    }
-
-    // Big string
-    {
-        let str = 'fooBAR!'.repeat(1024 * 1024);
-        assert.equal(ReturnBigString(str), str);
-    }
-
-    // Variadic
-    {
-        let str = PrintFmt('foo %d %g %s', 'int', 200, 'double', 1.5, 'string', 'BAR');
-        assert.equal(str, 'foo 200 1.5 BAR');
-    }
-
-    // UTF-16LE strings
-    {
-        let str = Concat16('Hello ', 'World!');
-        assert.equal(str, 'Hello World!');
-    }
-}

package/vendor/node-addon-api/CODE_OF_CONDUCT.md

@@ -1,4 +0,0 @@
-# Code of Conduct
-
-The Node.js Code of Conduct, which applies to this project, can be found at
-https://github.com/nodejs/admin/blob/HEAD/CODE_OF_CONDUCT.md.

package/vendor/node-addon-api/CONTRIBUTING.md

@@ -1,93 +0,0 @@
-
-# Developer's Certificate of Origin 1.1
-
-By making a contribution to this project, I certify that:
-
- (a) The contribution was created in whole or in part by me and I
-     have the right to submit it under the open source license
-     indicated in the file; or
-
- (b) The contribution is based upon previous work that, to the best
-     of my knowledge, is covered under an appropriate open source
-     license and I have the right under that license to submit that
-     work with modifications, whether created in whole or in part
-     by me, under the same open source license (unless I am
-     permitted to submit under a different license), as indicated
-     in the file; or
-
- (c) The contribution was provided directly to me by some other
-     person who certified (a), (b) or (c) and I have not modified
-     it.
-
- (d) I understand and agree that this project and the contribution
-     are public and that a record of the contribution (including all
-     personal information I submit with it, including my sign-off) is
-     maintained indefinitely and may be redistributed consistent with
-     this project or the open source license(s) involved.
-
-# **node-addon-api** Contribution Philosophy
-
-The **node-addon-api** team loves contributions. There are many ways in which you can
-contribute to **node-addon-api**:
-- Source code fixes
-- Additional tests
-- Documentation improvements
-- Joining the Node-API working group and participating in meetings
-
-## Source changes
-
-**node-addon-api** is meant to be a thin convenience wrapper around Node-API. With this
-in mind, contributions of any new APIs that wrap around a core Node-API API will
-be considered for merge. However, changes that wrap existing **node-addon-api**
-APIs are encouraged to instead be provided as an ecosystem module. The
-**node-addon-api** team is happy to link to a curated set of modules that build on
-top of **node-addon-api** if they have broad usefulness to the community and promote
-a recommended idiom or pattern.
-
-### Rationale
-
-The Node-API team considered a couple different approaches with regards to changes
-extending **node-addon-api**
-- Larger core module - Incorporate these helpers and patterns into **node-addon-api**
-- Extras package - Create a new package (strawman name '**node-addon-api**-extras')
-that contain utility classes and methods that help promote good patterns and
-idioms while writing native addons with **node-addon-api**.
-- Ecosystem - Encourage creation of a module ecosystem around **node-addon-api**
-where folks can build on top of it.
-
-#### Larger Core
-This is probably our simplest option in terms of immediate action needed. It
-would involve landing any open PRs against **node-addon-api**, and continuing to
-encourage folks to make PRs for utility helpers against the same repository.
-
-The downside of the approach is the following:
-- Less coherency for our API set
-- More maintenance burden on the Node-API WG core team.
-
-#### Extras Package
-This involves us spinning up a new package which contains the utility classes
-and methods. This has the benefit of having a separate module where helpers
-which make it easier to implement certain patterns and idioms for native addons
-easier.
-
-The downside of this approach is the following:
-- Potential for confusion - we'll need to provide clear documentation to help the
-community understand where a particular contribution should be directed to (what
-belongs in **node-addon-api** vs **node-addon-api-extras**)
-- Need to define the level of support/API guarantees
-- Unclear if the maintenance burden on the Node-API WG is reduced or not
-
-#### Ecosystem
-This doesn't require a ton of up-front work from the Node-API WG. Instead of
-accepting utility PRs into **node-addon-api** or creating and maintaining a new
-module, the WG will encourage the creation of an ecosystem of modules that
-build on top of **node-addon-api**, and provide some level of advertising for these
-modules (listing them out on the repository/wiki, using them in workshops/tutorials
-etc).
-
-The downside of this approach is the following:
-- Potential for lack of visibility - evangelism and education is hard, and module
-authors might not find right patterns and instead implement things themselves
-- There might be greater friction for the Node-API WG in evolving APIs since the
-ecosystem would have taken dependencies on the API shape of **node-addon-api**
-