koffi 1.1.0-beta.5 → 1.1.0-beta.8

package/CMakeLists.txt

@@ -65,9 +65,6 @@ if(WIN32)
     target_compile_definitions(koffi PRIVATE _CRT_SECURE_NO_WARNINGS _CRT_NONSTDC_NO_DEPRECATE)
     target_link_libraries(koffi PRIVATE ws2_32)
 endif()
-if(MSVC)
-    target_compile_options(koffi PRIVATE /wd4200)
-else()
-    target_compile_options(koffi PRIVATE -fno-exceptions -Wno-missing-field-initializers
-                                         -fno-strict-aliasing)
+if(NOT MSVC)
+    target_compile_options(koffi PRIVATE -fno-exceptions -fno-strict-aliasing)
 endif()

package/README.md

@@ -231,6 +231,33 @@ Koffi exposes three functions to explore type information:
 Fixed-size arrays are declared with `koffi.array(type, length)`. Just like in C, they cannot be passed
 as functions parameters (they degenerate to pointers), or returned by value. You can however embed them in struct types.
 
+Special rules apply for arrays of primitive integer and float types (uint32_t, double, etc...):
+- When converting from JS to C, Koffi can take a normal Array (e.g. `[1, 2]`) or a TypedArray of the correct type (e.g. `Uint8Array` for an array of `uint8_t` numbers)
+- When converting from C to JS (for return value or output parameters), Koffi will by default use a TypedArray. But you can change this behavior when you create the array type with the optional hint argument: `koffi.array('uint8_t', 64, 'array')`
+
+See the example below:
+
+```js
+const koffi = require('koffi');
+
+// Those two structs are exactly the same, only the array conversion hint is different
+const Foo1 = koffi.struct('Foo', {
+    i: 'int',
+    a16: koffi.array('int16_t', 8)
+});
+const Foo2 = koffi.struct('Foo', {
+    i: 'int',
+    a16: koffi.array('int16_t', 8, 'array')
+});
+
+// Uses an hypothetical C function that just returns the struct passed as a parameter
+const ReturnFoo1 = lib.func('Foo1 ReturnFoo(Foo1 p)');
+const ReturnFoo2 = lib.func('Foo2 ReturnFoo(Foo2 p)');
+
+console.log(ReturnFoo1({ i: 5, a16: [6, 8] })) // Prints { i: 5, a16: Int16Array(2) [6, 8] }
+console.log(ReturnFoo2({ i: 5, a16: [6, 8] })) // Prints { i: 5, a16: [6, 8] }
+```
+
 ## Variadic functions
 
 Variadic functions are declared with an ellipsis as the last argument.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koffi",
-  "version": "1.1.0-beta.5",
+  "version": "1.1.0-beta.8",
   "description": "Fast and simple FFI (foreign function interface) for Node.js",
   "keywords": [
     "foreign",

package/src/call.cc

@@ -20,8 +20,8 @@
 
 namespace RG {
 
-CallData::CallData(Napi::Env env, const FunctionInfo *func, InstanceMemory *mem, bool debug)
-    : env(env), instance(env.GetInstanceData<InstanceData>()), func(func), debug(debug),
+CallData::CallData(Napi::Env env, InstanceData *instance, const FunctionInfo *func, InstanceMemory *mem)
+    : env(env), instance(instance), func(func), debug(instance->debug),
       mem(mem), old_stack_mem(mem->stack), old_heap_mem(mem->heap)
 {
     mem->depth++;
@@ -67,7 +67,7 @@ const char *CallData::PushString(const Napi::Value &value)
 
         len++;
 
-        buf.ptr = (char *)Allocator::Allocate(&mem->big_alloc, (Size)len);
+        buf.ptr = (char *)Allocator::Allocate(&call_alloc, (Size)len);
         buf.len = (Size)len;
 
         status = napi_get_value_string_utf8(env, value, buf.ptr, (size_t)buf.len, &len);
@@ -104,7 +104,7 @@ const char16_t *CallData::PushString16(const Napi::Value &value)
 
         len++;
 
-        buf.ptr = (char16_t *)Allocator::Allocate(&mem->big_alloc, (Size)len * 2);
+        buf.ptr = (char16_t *)Allocator::Allocate(&call_alloc, (Size)len * 2);
         buf.len = (Size)len;
 
         status = napi_get_value_string_utf16(env, value, buf.ptr, (size_t)buf.len, &len);
@@ -246,31 +246,38 @@ bool CallData::PushArray(const Napi::Object &obj, const TypeInfo *type, uint8_t
     if (obj.IsArray()) {
         Napi::Array array = obj.As<Napi::Array>();
 
-        if (array.Length() != len) {
+        if (RG_UNLIKELY(array.Length() != len)) {
             ThrowError<Napi::Error>(env, "Expected array of length %1, got %2", len, array.Length());
             return false;
         }
 
+#define PUSH_ARRAY(Check, Expected, GetCode) \
+            do { \
+                for (uint32_t i = 0; i < len; i++) { \
+                    Napi::Value value = array[i]; \
+                     \
+                    int16_t align = std::max(type->ref->align, realign); \
+                    dest = AlignUp(dest, align); \
+                     \
+                    if (RG_UNLIKELY(!(Check))) { \
+                        ThrowError<Napi::TypeError>(env, "Unexpected value %1 in array, expected %2", GetValueType(instance, value), (Expected)); \
+                        return false; \
+                    } \
+                     \
+                    GetCode \
+                     \
+                    dest += type->ref->size; \
+                } \
+            } while (false)
+
         switch (type->ref->primitive) {
             case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
 
             case PrimitiveKind::Bool: {
-                for (uint32_t i = 0; i < len; i++) {
-                    Napi::Value value = array[i];
-
-                    int16_t align = std::max(type->ref->align, realign);
-                    dest = AlignUp(dest, align);
-
-                    if (RG_UNLIKELY(!value.IsBoolean())) {
-                        ThrowError<Napi::TypeError>(env, "Unexpected value %1 in array, expected boolean", GetValueType(instance, value));
-                        return false;
-                    }
-
+                PUSH_ARRAY(value.IsBoolean(), "boolean", {
                     bool b = value.As<Napi::Boolean>();
                     *(bool *)dest = b;
-
-                    dest += type->ref->size;
-                }
+                });
             } break;
             case PrimitiveKind::Int8:
             case PrimitiveKind::UInt8:
@@ -280,161 +287,67 @@ bool CallData::PushArray(const Napi::Object &obj, const TypeInfo *type, uint8_t
             case PrimitiveKind::UInt32:
             case PrimitiveKind::Int64:
             case PrimitiveKind::UInt64: {
-                for (uint32_t i = 0; i < len; i++) {
-                    Napi::Value value = array[i];
-
-                    int16_t align = std::max(type->ref->align, realign);
-                    dest = AlignUp(dest, align);
-
-                    if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                        ThrowError<Napi::TypeError>(env, "Unexpected value %1 in array, expected number", GetValueType(instance, value));
-                        return false;
-                    }
-
+                PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
                     int64_t v = CopyNumber<int64_t>(value);
                     memcpy(dest, &v, type->ref->size); // Little Endian
-
-                    dest += type->ref->size;
-                }
+                });
             } break;
             case PrimitiveKind::String: {
-                for (uint32_t i = 0; i < len; i++) {
-                    Napi::Value value = array[i];
-
-                    int16_t align = std::max(type->ref->align, realign);
-                    dest = AlignUp(dest, align);
-
-                    if (RG_UNLIKELY(!value.IsString())) {
-                        ThrowError<Napi::TypeError>(env, "Unexpected value %1 in array, expected string", GetValueType(instance, value));
-                        return false;
-                    }
-
+                PUSH_ARRAY(value.IsString(), "string", {
                     const char *str = PushString(value);
                     if (RG_UNLIKELY(!str))
                         return false;
                     *(const char **)dest = str;
-
-                    dest += type->ref->size;
-                }
+                });
             } break;
             case PrimitiveKind::String16: {
-                for (uint32_t i = 0; i < len; i++) {
-                    Napi::Value value = array[i];
-
-                    int16_t align = std::max(type->ref->align, realign);
-                    dest = AlignUp(dest, align);
-
-                    if (RG_UNLIKELY(!value.IsString())) {
-                        ThrowError<Napi::TypeError>(env, "Unexpected value %1 in array, expected string", GetValueType(instance, value));
-                        return false;
-                    }
-
+                PUSH_ARRAY(value.IsString(), "string", {
                     const char16_t *str16 = PushString16(value);
                     if (RG_UNLIKELY(!str16))
                         return false;
                     *(const char16_t **)dest = str16;
-
-                    dest += type->ref->size;
-                }
+                });
             } break;
             case PrimitiveKind::Pointer: {
-                for (uint32_t i = 0; i < len; i++) {
-                    Napi::Value value = array[i];
-
-                    int16_t align = std::max(type->ref->align, realign);
-                    dest = AlignUp(dest, align);
-
-                    if (RG_UNLIKELY(!CheckValueTag(instance, value, type->ref))) {
-                        ThrowError<Napi::TypeError>(env, "Unexpected value %1 in array, expected %2", GetValueType(instance, value), type->ref->name);
-                        return false;
-                    }
-
+                PUSH_ARRAY(CheckValueTag(instance, value, type->ref), type->ref->name, {
                     Napi::External external = value.As<Napi::External<void>>();
                     *(void **)dest = external.Data();
-
-                    dest += type->ref->size;
-                }
+                });
             } break;
             case PrimitiveKind::Record: {
-                for (uint32_t i = 0; i < len; i++) {
-                    Napi::Value value = array[i];
-
-                    int16_t align = std::max(type->ref->align, realign);
-                    dest = AlignUp(dest, align);
-
-                    if (RG_UNLIKELY(!IsObject(value))) {
-                        ThrowError<Napi::TypeError>(env, "Unexpected value %1 in array, expected object", GetValueType(instance, value));
-                        return false;
-                    }
-
+                PUSH_ARRAY(IsObject(value), "object", {
                     Napi::Object obj = value.As<Napi::Object>();
                     if (!PushObject(obj, type->ref, dest, realign))
                         return false;
-
-                    dest += type->ref->size;
-                }
+                });
             } break;
             case PrimitiveKind::Array: {
-                for (uint32_t i = 0; i < len; i++) {
-                    Napi::Value value = array[i];
-
-                    int16_t align = std::max(type->ref->align, realign);
-                    dest = AlignUp(dest, align);
-
-                    if (RG_UNLIKELY(!value.IsArray() && !value.IsTypedArray())) {
-                        ThrowError<Napi::TypeError>(env, "Unexpected value %1 in array, expected array", GetValueType(instance, value));
-                        return false;
-                    }
-
-                    Napi::Array array = value.As<Napi::Array>();
+                PUSH_ARRAY(value.IsArray() || value.IsTypedArray(), "array", {
+                    Napi::Object array = value.As<Napi::Array>();
                     if (!PushArray(array, type->ref, dest, realign))
                         return false;
-
-                    dest += type->ref->size;
-                }
+                });
             } break;
             case PrimitiveKind::Float32: {
-                for (uint32_t i = 0; i < len; i++) {
-                    Napi::Value value = array[i];
-
-                    int16_t align = std::max(type->ref->align, realign);
-                    dest = AlignUp(dest, align);
-
-                    if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                        ThrowError<Napi::TypeError>(env, "Unexpected value %1 in array, expected number", GetValueType(instance, value));
-                        return false;
-                    }
-
+                PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
                     float f = CopyNumber<float>(value);
                     *(float *)dest = f;
-
-                    dest += type->ref->size;
-                }
+                });
             } break;
             case PrimitiveKind::Float64: {
-                for (uint32_t i = 0; i < len; i++) {
-                    Napi::Value value = array[i];
-
-                    int16_t align = std::max(type->ref->align, realign);
-                    dest = AlignUp(dest, align);
-
-                    if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                        ThrowError<Napi::TypeError>(env, "Unexpected value %1 in array, expected number", GetValueType(instance, value));
-                        return false;
-                    }
-
+                PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
                     double d = CopyNumber<double>(value);
                     *(double *)dest = d;
-
-                    dest += type->ref->size;
-                }
+                });
             } break;
         }
+
+#undef PUSH_ARRAY
     } else {
         Napi::TypedArray array = obj.As<Napi::TypedArray>();
         const uint8_t *buf = (const uint8_t *)array.ArrayBuffer().Data();
 
-        if (array.ElementLength() != len) {
+        if (RG_UNLIKELY(array.ElementLength() != len)) {
             ThrowError<Napi::Error>(env, "Expected array of length %1, got %2", len, array.ElementLength());
             return false;
         }
@@ -452,7 +365,7 @@ bool CallData::PushArray(const Napi::Object &obj, const TypeInfo *type, uint8_t
 
             default: { match = false; } break;
         }
-        if (!match) {
+        if (RG_UNLIKELY(!match)) {
             ThrowError<Napi::TypeError>(env, "TypedArray is not approriate for %1 array", type->ref->name);
             return false;
         }
@@ -570,256 +483,127 @@ Napi::Object CallData::PopArray(const uint8_t *src, const TypeInfo *type, int16_
 
     uint32_t len = type->size / type->ref->size;
 
+#define POP_ARRAY(SetCode) \
+        do { \
+            Napi::Array array = Napi::Array::New(env); \
+             \
+            for (uint32_t i = 0; i < len; i++) { \
+                int16_t align = std::max(realign, type->ref->align); \
+                src = AlignUp(src, align); \
+                 \
+                SetCode \
+                 \
+                src += type->ref->size; \
+            } \
+             \
+            return array; \
+        } while (false)
+#define POP_NUMBER_ARRAY(TypedArrayType, CType) \
+        do { \
+            if (type->hint == TypeInfo::ArrayHint::TypedArray) { \
+                Napi::TypedArrayType array = Napi::TypedArrayType::New(env, len); \
+                 \
+                for (uint32_t i = 0; i < len; i++) { \
+                    int16_t align = std::max(realign, type->ref->align); \
+                    src = AlignUp(src, align); \
+                     \
+                    CType f = *(CType *)src; \
+                    array[i] = f; \
+                     \
+                    src += type->ref->size; \
+                } \
+                 \
+                return array; \
+            } else { \
+                POP_ARRAY({ \
+                    double d = (double)*(CType *)src; \
+                    array.Set(i, Napi::Number::New(env, d)); \
+                }); \
+            } \
+        } while (false)
+
     switch (type->ref->primitive) {
         case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
 
         case PrimitiveKind::Bool: {
-            Napi::Array array = Napi::Array::New(env);
-
-            for (uint32_t i = 0; i < len; i++) {
-                int16_t align = std::max(realign, type->ref->align);
-                src = AlignUp(src, align);
-
+            POP_ARRAY({
                 bool b = *(bool *)src;
                 array.Set(i, Napi::Boolean::New(env, b));
-
-                src += type->ref->size;
-            }
-
-            return array;
-        } break;
-        case PrimitiveKind::Int8: {
-            Napi::Int8Array array = Napi::Int8Array::New(env, len);
-
-            for (uint32_t i = 0; i < len; i++) {
-                int16_t align = std::max(realign, type->ref->align);
-                src = AlignUp(src, align);
-
-                int8_t v = *(int8_t *)src;
-                array[i] = v;
-
-                src += type->ref->size;
-            }
-
-            return array;
-        } break;
-        case PrimitiveKind::UInt8: {
-            Napi::Uint8Array array = Napi::Uint8Array::New(env, len);
-
-            for (uint32_t i = 0; i < len; i++) {
-                int16_t align = std::max(realign, type->ref->align);
-                src = AlignUp(src, align);
-
-                uint8_t v = *(uint8_t *)src;
-                array[i] = v;
-
-                src += type->ref->size;
-            }
-
-            return array;
-        } break;
-        case PrimitiveKind::Int16: {
-            Napi::Int16Array array = Napi::Int16Array::New(env, len);
-
-            for (uint32_t i = 0; i < len; i++) {
-                int16_t align = std::max(realign, type->ref->align);
-                src = AlignUp(src, align);
-
-                int16_t v = *(int16_t *)src;
-                array[i] = v;
-
-                src += type->ref->size;
-            }
-
-            return array;
-        } break;
-        case PrimitiveKind::UInt16: {
-            Napi::Uint16Array array = Napi::Uint16Array::New(env, len);
-
-            for (uint32_t i = 0; i < len; i++) {
-                int16_t align = std::max(realign, type->ref->align);
-                src = AlignUp(src, align);
-
-                uint16_t v = *(uint16_t *)src;
-                array[i] = v;
-
-                src += type->ref->size;
-            }
-
-            return array;
-        } break;
-        case PrimitiveKind::Int32: {
-            Napi::Int32Array array = Napi::Int32Array::New(env, len);
-
-            for (uint32_t i = 0; i < len; i++) {
-                int16_t align = std::max(realign, type->ref->align);
-                src = AlignUp(src, align);
-
-                int32_t v = *(int32_t *)src;
-                array[i] = v;
-
-                src += type->ref->size;
-            }
-
-            return array;
-        } break;
-        case PrimitiveKind::UInt32: {
-            Napi::Uint32Array array = Napi::Uint32Array::New(env, len);
-
-            for (uint32_t i = 0; i < len; i++) {
-                int16_t align = std::max(realign, type->ref->align);
-                src = AlignUp(src, align);
-
-                uint32_t v = *(uint32_t *)src;
-                array[i] = v;
-
-                src += type->ref->size;
-            }
-
-            return array;
+            });
         } break;
+        case PrimitiveKind::Int8: { POP_NUMBER_ARRAY(Int8Array, int8_t); } break;
+        case PrimitiveKind::UInt8: { POP_NUMBER_ARRAY(Uint8Array, uint8_t); } break;
+        case PrimitiveKind::Int16: { POP_NUMBER_ARRAY(Int16Array, int16_t); } break;
+        case PrimitiveKind::UInt16: { POP_NUMBER_ARRAY(Uint16Array, uint16_t); } break;
+        case PrimitiveKind::Int32: { POP_NUMBER_ARRAY(Int32Array, int32_t); } break;
+        case PrimitiveKind::UInt32: { POP_NUMBER_ARRAY(Uint32Array, uint32_t); } break;
         case PrimitiveKind::Int64: {
-            Napi::Array array = Napi::Array::New(env);
-
-            for (uint32_t i = 0; i < len; i++) {
-                int16_t align = std::max(realign, type->ref->align);
-                src = AlignUp(src, align);
-
+            POP_ARRAY({
                 int64_t v = *(int64_t *)src;
                 array.Set(i, Napi::BigInt::New(env, v));
-
-                src += type->ref->size;
-            }
-
-            return array;
+            });
         } break;
         case PrimitiveKind::UInt64: {
-            Napi::Array array = Napi::Array::New(env);
-
-            for (uint32_t i = 0; i < len; i++) {
-                int16_t align = std::max(realign, type->ref->align);
-                src = AlignUp(src, align);
-
+            POP_ARRAY({
                 uint64_t v = *(uint64_t *)src;
                 array.Set(i, Napi::BigInt::New(env, v));
-
-                src += type->ref->size;
-            }
-
-            return array;
+            });
         } break;
         case PrimitiveKind::String: {
-            Napi::Array array = Napi::Array::New(env);
-
-            for (uint32_t i = 0; i < len; i++) {
-                int16_t align = std::max(realign, type->ref->align);
-                src = AlignUp(src, align);
-
+            POP_ARRAY({
                 const char *str = *(const char **)src;
                 array.Set(i, Napi::String::New(env, str));
-
-                src += type->ref->size;
-            }
-
-            return array;
+            });
         } break;
         case PrimitiveKind::String16: {
-            Napi::Array array = Napi::Array::New(env);
-
-            for (uint32_t i = 0; i < len; i++) {
-                int16_t align = std::max(realign, type->ref->align);
-                src = AlignUp(src, align);
-
+            POP_ARRAY({
                 const char16_t *str16 = *(const char16_t **)src;
                 array.Set(i, Napi::String::New(env, str16));
-
-                src += type->ref->size;
-            }
-
-            return array;
+            });
         } break;
         case PrimitiveKind::Pointer: {
-            Napi::Array array = Napi::Array::New(env);
-
-            for (uint32_t i = 0; i < len; i++) {
-                int16_t align = std::max(realign, type->ref->align);
-                src = AlignUp(src, align);
-
+            POP_ARRAY({
                 void *ptr2 = *(void **)src;
 
                 Napi::External<void> external = Napi::External<void>::New(env, ptr2);
                 SetValueTag(instance, external, type->ref);
 
                 array.Set(i, external);
-
-                src += type->ref->size;
-            }
-
-            return array;
+            });
         } break;
         case PrimitiveKind::Record: {
-            Napi::Array array = Napi::Array::New(env);
-
-            for (uint32_t i = 0; i < len; i++) {
-                int16_t align = std::max(realign, type->ref->align);
-                src = AlignUp(src, align);
-
+            POP_ARRAY({
                 Napi::Object obj = PopObject(src, type->ref, realign);
                 array.Set(i, obj);
-
-                src += type->ref->size;
-            }
-
-            return array;
+            });
         } break;
         case PrimitiveKind::Array: {
-            Napi::Array array = Napi::Array::New(env);
-
-            for (uint32_t i = 0; i < len; i++) {
-                int16_t align = std::max(realign, type->ref->align);
-                src = AlignUp(src, align);
-
+            POP_ARRAY({
                 Napi::Object obj = PopArray(src, type->ref, realign);
                 array.Set(i, obj);
-
-                src += type->ref->size;
-            }
-
-            return array;
-        } break;
-        case PrimitiveKind::Float32: {
-            Napi::Float32Array array = Napi::Float32Array::New(env, len);
-
-            for (uint32_t i = 0; i < len; i++) {
-                int16_t align = std::max(realign, type->ref->align);
-                src = AlignUp(src, align);
-
-                float f = *(float *)src;
-                array[i] = f;
-
-                src += type->ref->size;
-            }
-
-            return array;
+            });
         } break;
-        case PrimitiveKind::Float64: {
-            Napi::Float64Array array = Napi::Float64Array::New(env, len);
+        case PrimitiveKind::Float32: { POP_NUMBER_ARRAY(Float32Array, float); } break;
+        case PrimitiveKind::Float64: { POP_NUMBER_ARRAY(Float64Array, double); } break;
+    }
 
-            for (uint32_t i = 0; i < len; i++) {
-                int16_t align = std::max(realign, type->ref->align);
-                src = AlignUp(src, align);
+#undef POP_NUMBER_ARRAY
+#undef POP_ARRAY
 
-                double d = *(double *)src;
-                array[i] = d;
+    RG_UNREACHABLE();
+}
 
-                src += type->ref->size;
-            }
+Napi::Value CallData::Run(const Napi::CallbackInfo &info)
+{
+    if (!RG_UNLIKELY(Prepare(info)))
+        return env.Null();
 
-            return array;
-        } break;
+    if (debug) {
+        DumpDebug();
     }
+    Execute();
 
-    RG_UNREACHABLE();
+    return Complete();
 }
 
 static void DumpMemory(const char *type, Span<const uint8_t> bytes)

package/src/call.hh

@@ -55,26 +55,17 @@ class CallData {
     } result;
     uint8_t *return_ptr = nullptr;
 
+    LinkedAllocator call_alloc;
+
 public:
-    CallData(Napi::Env env, const FunctionInfo *func, InstanceMemory *mem, bool debug);
+    CallData(Napi::Env env, InstanceData *instance, const FunctionInfo *func, InstanceMemory *mem);
     ~CallData();
 
     bool Prepare(const Napi::CallbackInfo &info);
     void Execute();
     Napi::Value Complete();
 
-    Napi::Value Run(const Napi::CallbackInfo &info)
-    {
-        if (!RG_UNLIKELY(Prepare(info)))
-            return env.Null();
-
-        if (debug) {
-            DumpDebug();
-        }
-        Execute();
-
-        return Complete();
-    }
+    Napi::Value Run(const Napi::CallbackInfo &info);
 
     void DumpDebug() const;
 

package/src/ffi.cc

@@ -261,6 +261,27 @@ static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
+    TypeInfo::ArrayHint hint;
+    if (info.Length() >= 3 && !IsNullOrUndefined(info[2])) {
+        if (!info[2].IsString()) {
+            ThrowError<Napi::TypeError>(env, "Unexpected %1 value for hint, expected string", GetValueType(instance, info[2]));
+            return env.Null();
+        }
+
+        std::string to = info[2].As<Napi::String>();
+
+        if (to == "typed") {
+            hint = TypeInfo::ArrayHint::TypedArray;
+        } else if (to == "array") {
+            hint = TypeInfo::ArrayHint::Array;
+        } else {
+            ThrowError<Napi::Error>(env, "Array conversion hint must be 'typed' or 'array'");
+            return env.Null();
+        }
+    } else {
+        hint = TypeInfo::ArrayHint::TypedArray;
+    }
+
     const TypeInfo *ref = ResolveType(instance, info[0]);
     int64_t len = (uint16_t)info[1].As<Napi::Number>().Int64Value();
 
@@ -284,6 +305,7 @@ static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
     type->align = ref->align;
     type->size = (int16_t)(len * ref->size);
     type->ref = ref;
+    type->hint = hint;
 
     // If the insert succeeds, we cannot fail anymore
     if (!instance->types_map.TrySet(type).second) {
@@ -395,13 +417,13 @@ static Napi::Value TranslateNormalCall(const Napi::CallbackInfo &info)
     InstanceData *instance = env.GetInstanceData<InstanceData>();
     FunctionInfo *func = (FunctionInfo *)info.Data();
 
-    if (info.Length() < (uint32_t)func->parameters.len) {
+    if (RG_UNLIKELY(info.Length() < (uint32_t)func->parameters.len)) {
         ThrowError<Napi::TypeError>(env, "Expected %1 arguments, got %2", func->parameters.len, info.Length());
         return env.Null();
     }
 
     InstanceMemory *mem = AllocateCallMemory(instance);
-    CallData call(env, func, mem, instance->debug);
+    CallData call(env, instance, func, mem);
 
     return call.Run(info);
 }
@@ -421,11 +443,11 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
         func.parameters.Leak();
     };
 
-    if (info.Length() < (uint32_t)func.parameters.len) {
+    if (RG_UNLIKELY(info.Length() < (uint32_t)func.parameters.len)) {
         ThrowError<Napi::TypeError>(env, "Expected %1 arguments or more, got %2", func.parameters.len, info.Length());
         return env.Null();
     }
-    if ((info.Length() - func.parameters.len) % 2) {
+    if (RG_UNLIKELY((info.Length() - func.parameters.len) % 2)) {
         ThrowError<Napi::Error>(env, "Missing value argument for variadic call");
         return env.Null();
     }
@@ -434,19 +456,19 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
         ParameterInfo param = {};
 
         param.type = ResolveType(instance, info[i], &param.directions);
-        if (!param.type)
+        if (RG_UNLIKELY(!param.type))
             return env.Null();
-        if (param.type->primitive == PrimitiveKind::Void ||
-                param.type->primitive == PrimitiveKind::Array) {
+        if (RG_UNLIKELY(param.type->primitive == PrimitiveKind::Void ||
+                        param.type->primitive == PrimitiveKind::Array)) {
             ThrowError<Napi::TypeError>(env, "Type %1 cannot be used as a parameter", PrimitiveKindNames[(int)param.type->primitive]);
             return env.Null();
         }
 
-        if (func.parameters.len >= MaxParameters) {
+        if (RG_UNLIKELY(func.parameters.len >= MaxParameters)) {
             ThrowError<Napi::TypeError>(env, "Functions cannot have more than %1 parameters", MaxParameters);
             return env.Null();
         }
-        if ((param.directions & 2) && ++func.out_parameters >= MaxOutParameters) {
+        if (RG_UNLIKELY((param.directions & 2) && ++func.out_parameters >= MaxOutParameters)) {
             ThrowError<Napi::TypeError>(env, "Functions cannot have more than out %1 parameters", MaxOutParameters);
             return env.Null();
         }
@@ -457,11 +479,11 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
         func.parameters.Append(param);
     }
 
-    if (!AnalyseFunction(instance, &func))
+    if (RG_UNLIKELY(!AnalyseFunction(instance, &func)))
         return env.Null();
 
     InstanceMemory *mem = AllocateCallMemory(instance);
-    CallData call(env, &func, mem, instance->debug);
+    CallData call(env, instance, &func, mem);
 
     return call.Run(info);
 }
@@ -474,10 +496,10 @@ class AsyncCall: public Napi::AsyncWorker {
     bool prepared = false;
 
 public:
-    AsyncCall(Napi::Env env, InstanceMemory *mem, FunctionInfo *func, bool debug,
-              Napi::Function &callback)
+    AsyncCall(Napi::Env env, InstanceData *instance, const FunctionInfo *func,
+              InstanceMemory *mem, Napi::Function &callback)
         : Napi::AsyncWorker(callback), env(env), func(func->Ref()),
-          call(env, func, mem, debug) {}
+          call(env, instance, func, mem) {}
     ~AsyncCall() { func->Unref(); }
 
     bool Prepare(const Napi::CallbackInfo &info) {
@@ -537,7 +559,7 @@ static Napi::Value TranslateAsyncCall(const Napi::CallbackInfo &info)
     }
 
     InstanceMemory *mem = AllocateCallMemory(instance);
-    AsyncCall *async = new AsyncCall(env, mem, func, instance->debug, callback);
+    AsyncCall *async = new AsyncCall(env, instance, func, mem, callback);
 
     if (async->Prepare(info) && instance->debug) {
         async->DumpDebug();

package/src/ffi.hh

@@ -67,6 +67,11 @@ struct TypeInfo;
 struct RecordMember;
 
 struct TypeInfo {
+    enum class ArrayHint {
+        Array,
+        TypedArray
+    };
+
     const char *name;
     napi_type_tag tag;
 
@@ -78,6 +83,7 @@ struct TypeInfo {
 
     HeapArray<RecordMember> members; // Record only
     const TypeInfo *ref; // Pointer or array
+    ArrayHint hint; // Array only
 
     RG_HASHTABLE_HANDLER(TypeInfo, name);
 };
@@ -168,7 +174,6 @@ struct InstanceMemory {
 
     Span<uint8_t> stack;
     Span<uint8_t> heap;
-    IndirectBlockAllocator big_alloc { &mem_alloc };
 
     int depth;
     bool temporary;