koffi 1.3.2 → 1.3.5

package/src/ffi.cc

@@ -43,7 +43,7 @@ namespace RG {
 // Value does not matter, the tag system uses memory addresses
 const int TypeInfoMarker = 0xDEADBEEF;
 
-static bool ChangeMemorySize(Napi::Value value, Size *out_size)
+static bool ChangeMemorySize(const char *name, Napi::Value value, Size *out_size)
 {
     const Size MinSize = Kibibytes(1);
     const Size MaxSize = Mebibytes(16);
@@ -51,14 +51,16 @@ static bool ChangeMemorySize(Napi::Value value, Size *out_size)
     Napi::Env env = value.Env();
 
     if (!value.IsNumber()) {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for memory size, expected number");
-        return env.Null();
+        InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for '%2', expected number", GetValueType(instance, value), name);
+        return false;
     }
 
     int64_t size = value.As<Napi::Number>().Int64Value();
 
     if (size < MinSize || size > MaxSize) {
-        ThrowError<Napi::Error>(env, "Memory size must be between %1 and %2", FmtMemSize(MinSize), FmtMemSize(MaxSize));
+        ThrowError<Napi::Error>(env, "Setting '%1' must be between %2 and %3", name, FmtMemSize(MinSize), FmtMemSize(MaxSize));
         return false;
     }
 
@@ -66,6 +68,28 @@ static bool ChangeMemorySize(Napi::Value value, Size *out_size)
     return true;
 }
 
+static bool ChangeAsyncLimit(const char *name, Napi::Value value, int max, int *out_limit)
+{
+    Napi::Env env = value.Env();
+
+    if (!value.IsNumber()) {
+        InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for '%2', expected number", GetValueType(instance, value), name);
+        return false;
+    }
+
+    int64_t n = value.As<Napi::Number>().Int64Value();
+
+    if (n < 0 || n > max) {
+        ThrowError<Napi::Error>(env, "Setting '%1' must be between 0 and %2", name, max);
+        return false;
+    }
+
+    *out_limit = (int)n;
+    return true;
+}
+
 static Napi::Value GetSetConfig(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
@@ -82,6 +106,13 @@ static Napi::Value GetSetConfig(const Napi::CallbackInfo &info)
             return env.Null();
         }
 
+        Size sync_stack_size = instance->sync_stack_size;
+        Size sync_heap_size = instance->sync_heap_size;
+        Size async_stack_size = instance->async_stack_size;
+        Size async_heap_size = instance->async_heap_size;
+        int resident_async_pools = instance->resident_async_pools;
+        int max_async_calls = resident_async_pools + instance->max_temporaries;
+
         Napi::Object obj = info[0].As<Napi::Object>();
         Napi::Array keys = obj.GetPropertyNames();
 
@@ -90,38 +121,40 @@ static Napi::Value GetSetConfig(const Napi::CallbackInfo &info)
             Napi::Value value = obj[key];
 
             if (key == "sync_stack_size") {
-                if (!ChangeMemorySize(value, &instance->sync_stack_size))
+                if (!ChangeMemorySize(key.c_str(), value, &sync_stack_size))
                     return env.Null();
             } else if (key == "sync_heap_size") {
-                if (!ChangeMemorySize(value, &instance->sync_heap_size))
+                if (!ChangeMemorySize(key.c_str(), value, &sync_heap_size))
                     return env.Null();
             } else if (key == "async_stack_size") {
-                if (!ChangeMemorySize(value, &instance->async_stack_size))
+                if (!ChangeMemorySize(key.c_str(), value, &async_stack_size))
                     return env.Null();
             } else if (key == "async_heap_size") {
-                if (!ChangeMemorySize(value, &instance->async_heap_size))
+                if (!ChangeMemorySize(key.c_str(), value, &async_heap_size))
                     return env.Null();
             } else if (key == "resident_async_pools") {
-                RG_STATIC_ASSERT(DefaultResidentAsyncPools <= RG_LEN(instance->memories.data));
-
-                if (!value.IsNumber()) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for resident_async_pools, expected number");
+                if (!ChangeAsyncLimit(key.c_str(), value, RG_LEN(instance->memories.data) - 1, &resident_async_pools))
                     return env.Null();
-                }
-
-                int64_t n = value.As<Napi::Number>().Int64Value();
-
-                if (n < 0 || n > RG_LEN(instance->memories.data)) {
-                    ThrowError<Napi::Error>(env, "Parameter resident_async_pools must be between 0 and %1", RG_LEN(instance->memories.data));
+            } else if (key == "max_async_calls") {
+                if (!ChangeAsyncLimit(key.c_str(), value, MaxAsyncCalls, &max_async_calls))
                     return env.Null();
-                }
-
-                instance->resident_async_pools = (int)n;
             } else {
                 ThrowError<Napi::Error>(env, "Unexpected config member '%1'", key.c_str());
                 return env.Null();
             }
         }
+
+        if (max_async_calls < resident_async_pools) {
+            ThrowError<Napi::Error>(env, "Setting max_async_calls must be >= to resident_async_pools");
+            return env.Null();
+        }
+
+        instance->sync_stack_size = sync_stack_size;
+        instance->sync_heap_size = sync_heap_size;
+        instance->async_stack_size = async_stack_size;
+        instance->async_heap_size = async_heap_size;
+        instance->resident_async_pools = resident_async_pools;
+        instance->max_temporaries = max_async_calls - resident_async_pools;
     }
 
     Napi::Object obj = Napi::Object::New(env);
@@ -131,6 +164,7 @@ static Napi::Value GetSetConfig(const Napi::CallbackInfo &info)
     obj.Set("async_stack_size", instance->async_stack_size);
     obj.Set("async_heap_size", instance->async_heap_size);
     obj.Set("resident_async_pools", instance->resident_async_pools);
+    obj.Set("max_async_calls", instance->resident_async_pools + instance->max_temporaries);
 
     return obj;
 }
@@ -616,6 +650,9 @@ static InstanceMemory *AllocateMemory(InstanceData *instance, Size stack_size, S
             return mem;
     }
 
+    if (RG_UNLIKELY(instance->temporaries >= instance->max_temporaries))
+        return nullptr;
+
     InstanceMemory *mem = new InstanceMemory();
 
     mem->stack.len = stack_size;
@@ -628,6 +665,11 @@ static InstanceMemory *AllocateMemory(InstanceData *instance, Size stack_size, S
 #endif
     RG_CRITICAL(mem->stack.ptr, "Failed to allocate %1 of memory", mem->stack.len);
 
+#ifdef __OpenBSD__
+    // Make sure the SP points inside the MAP_STACK area, or (void) functions may crash on OpenBSD i386
+    mem->stack.len -= 16;
+#endif
+
     mem->heap.len = heap_size;
 #ifdef _WIN32
     mem->heap.ptr = (uint8_t *)VirtualAlloc(nullptr, mem->heap.len, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
@@ -636,9 +678,13 @@ static InstanceMemory *AllocateMemory(InstanceData *instance, Size stack_size, S
 #endif
     RG_CRITICAL(mem->heap.ptr, "Failed to allocate %1 of memory", mem->heap.len);
 
+    mem->depth = 0;
+
     if (instance->memories.len <= instance->resident_async_pools) {
         instance->memories.Append(mem);
+        mem->temporary = false;
     } else {
+        instance->temporaries++;
         mem->temporary = true;
     }
 
@@ -804,11 +850,15 @@ static Napi::Value TranslateAsyncCall(const Napi::CallbackInfo &info)
     Napi::Function callback = info[(uint32_t)func->parameters.len].As<Napi::Function>();
 
     if (!callback.IsFunction()) {
-        ThrowError<Napi::TypeError>(env, "Expected callback function as last arguments, got %1", GetValueType(instance, callback));
+        ThrowError<Napi::TypeError>(env, "Expected callback function as last argument, got %1", GetValueType(instance, callback));
         return env.Null();
     }
 
     InstanceMemory *mem = AllocateMemory(instance, instance->async_stack_size, instance->async_heap_size);
+    if (RG_UNLIKELY(!mem)) {
+        ThrowError<Napi::Error>(env, "Too many asynchronous calls are running");
+        return env.Null();
+    }
     AsyncCall *async = new AsyncCall(env, instance, func, mem, callback);
 
     if (async->Prepare(info) && instance->debug) {
@@ -917,6 +967,7 @@ static Napi::Value LoadSharedLibrary(const Napi::CallbackInfo &info)
 
     if (!instance->memories.len) {
         AllocateMemory(instance, instance->sync_stack_size, instance->sync_heap_size);
+        RG_ASSERT(instance->memories.len);
     }
 
     // Load shared library

package/src/ffi.hh

@@ -21,10 +21,12 @@ namespace RG {
 
 static const Size DefaultSyncStackSize = Mebibytes(1);
 static const Size DefaultSyncHeapSize = Mebibytes(2);
-static const Size DefaultAsyncStackSize = Kibibytes(512);
-static const Size DefaultAsyncHeapSize = Mebibytes(1);
+static const Size DefaultAsyncStackSize = Kibibytes(256);
+static const Size DefaultAsyncHeapSize = Kibibytes(512);
 static const int DefaultResidentAsyncPools = 2;
+static const int DefaultMaxAsyncCalls = 64;
 
+static const int MaxAsyncCalls = 256;
 static const Size MaxParameters = 32;
 static const Size MaxOutParameters = 4;
 static const Size MaxTrampolines = 16;
@@ -216,7 +218,8 @@ struct InstanceData {
     bool debug;
     uint64_t tag_lower;
 
-    LocalArray<InstanceMemory *, 16> memories;
+    LocalArray<InstanceMemory *, 9> memories;
+    int temporaries = 0;
 
     TrampolineInfo trampolines[MaxTrampolines];
     uint32_t free_trampolines = UINT32_MAX;
@@ -228,7 +231,11 @@ struct InstanceData {
     Size async_stack_size = DefaultAsyncStackSize;
     Size async_heap_size = DefaultAsyncHeapSize;
     int resident_async_pools = DefaultResidentAsyncPools;
+    int max_temporaries = DefaultMaxAsyncCalls - DefaultResidentAsyncPools;
 };
-RG_STATIC_ASSERT(MaxTrampolines <= 32);
+RG_STATIC_ASSERT(DefaultResidentAsyncPools <= RG_LEN(InstanceData::memories.data) - 1);
+RG_STATIC_ASSERT(DefaultMaxAsyncCalls >= DefaultResidentAsyncPools);
+RG_STATIC_ASSERT(MaxAsyncCalls >= DefaultMaxAsyncCalls);
+RG_STATIC_ASSERT(MaxTrampolines <= 16);
 
 }

package/src/parser.cc

@@ -44,7 +44,7 @@ bool PrototypeParser::Parse(const char *str, FunctionInfo *out_func)
     out_func->name = ParseIdentifier();
 
     Consume("(");
-    if (offset < tokens.len && tokens[offset] != ")") {
+    if (offset < tokens.len && tokens[offset] != ")" && !Match("void")) {
         for (;;) {
             ParameterInfo param = {};
 

package/src/util.hh

@@ -89,7 +89,7 @@ static inline bool IsObject(Napi::Value value)
 int GetTypedArrayType(const TypeInfo *type);
 
 template <typename T>
-T CopyNumber(const Napi::Value &value)
+T CopyNumber(Napi::Value value)
 {
     RG_ASSERT(value.IsNumber() || value.IsBigInt());
 
@@ -105,6 +105,26 @@ T CopyNumber(const Napi::Value &value)
     RG_UNREACHABLE();
 }
 
+static inline Napi::Value NewBigInt(Napi::Env env, int64_t value)
+{
+    if (value <= 9007199254740992ll && value >= -9007199254740992ll) {
+        double d = (double)value;
+        return Napi::Number::New(env, d);
+    } else {
+        return Napi::BigInt::New(env, value);
+    }
+}
+
+static inline Napi::Value NewBigInt(Napi::Env env, uint64_t value)
+{
+    if (value <= 9007199254740992ull) {
+        double d = (double)value;
+        return Napi::Number::New(env, d);
+    } else {
+        return Napi::BigInt::New(env, value);
+    }
+}
+
 int AnalyseFlat(const TypeInfo *type, FunctionRef<void(const TypeInfo *type, int offset, int count)> func);
 
 int IsHFA(const TypeInfo *type, int min, int max);

package/test/async.js

@@ -51,7 +51,7 @@ async function test() {
     let promises = [];
 
     // Issue several async calls
-    for (let i = 0; i < 64; i++) {
+    for (let i = 0; i < 32; i++) {
         let p = new Promise((resolve, reject) => {
             try {
                 ConcatenateToInt1.async(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7, (err, res) => {

package/test/misc.c

@@ -129,6 +129,26 @@ typedef struct IntContainer {
     int len;
 } IntContainer;
 
+EXPORT int8_t GetMinusOne1(void)
+{
+    return -1;
+}
+
+EXPORT int16_t GetMinusOne2(void)
+{
+    return -1;
+}
+
+EXPORT int32_t GetMinusOne4(void)
+{
+    return -1;
+}
+
+EXPORT int64_t GetMinusOne8(void)
+{
+    return -1;
+}
+
 EXPORT void FillPack1(int a, Pack1 *p)
 {
     p->a = a;

package/test/sync.js

@@ -122,6 +122,10 @@ async function test() {
     let lib_filename = path.dirname(__filename) + '/build/misc' + koffi.extension;
     let lib = koffi.load(lib_filename);
 
+    const GetMinusOne1 = lib.func('int8_t GetMinusOne1(void)');
+    const GetMinusOne2 = lib.func('int16_t GetMinusOne2(void)');
+    const GetMinusOne4 = lib.func('int32_t GetMinusOne4(void)');
+    const GetMinusOne8 = lib.func('int64_t GetMinusOne8(void)');
     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))]);
@@ -172,6 +176,12 @@ async function test() {
     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 signed value returns
+    assert.equal(GetMinusOne1(), -1);
+    assert.equal(GetMinusOne2(), -1);
+    assert.equal(GetMinusOne4(), -1);
+    assert.equal(GetMinusOne8(), -1);
+
     // Simple tests with Pack1
     {
         let p = {};
@@ -250,9 +260,9 @@ async function test() {
 
     // 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(ConcatenateToInt1(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687);
+        assert.equal(ConcatenateToInt4(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687);
+        assert.equal(ConcatenateToInt8(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687);
         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');

package/vendor/libcc/libcc.hh

@@ -3049,7 +3049,7 @@ public:
 
     int repeat = 1;
     int pad_len = 0;
-    char pad_char;
+    char pad_char = 0;
 
     FmtArg() = default;
     FmtArg(std::nullptr_t) : type(FmtType::Str1) { u.str1 = "(null)"; }