koffi 1.0.5 → 1.1.0-beta.2

package/src/call.cc

@@ -20,19 +20,24 @@
 
 namespace RG {
 
-CallData::CallData(Napi::Env env, InstanceData *instance, const FunctionInfo *func)
-    : env(env), instance(instance), func(func),
-      stack_mem(&instance->stack_mem), heap_mem(&instance->heap_mem),
-      old_stack_mem(instance->stack_mem), old_heap_mem(instance->heap_mem)
+CallData::CallData(Napi::Env env, const FunctionInfo *func, InstanceMemory *mem, bool debug)
+    : env(env), instance(env.GetInstanceData<InstanceData>()), func(func), debug(debug),
+      mem(mem), old_stack_mem(mem->stack), old_heap_mem(mem->heap)
 {
-    RG_ASSERT(AlignUp(stack_mem->ptr, 16) == stack_mem->ptr);
-    RG_ASSERT(AlignUp(stack_mem->end(), 16) == stack_mem->end());
+    mem->depth++;
+
+    RG_ASSERT(AlignUp(mem->stack.ptr, 16) == mem->stack.ptr);
+    RG_ASSERT(AlignUp(mem->stack.end(), 16) == mem->stack.end());
 }
 
 CallData::~CallData()
 {
-    instance->stack_mem = old_stack_mem;
-    instance->heap_mem = old_heap_mem;
+    mem->stack = old_stack_mem;
+    mem->heap = old_heap_mem;
+
+    if (!--mem->depth && mem->temporary) {
+        delete mem;
+    }
 }
 
 const char *CallData::PushString(const Napi::Value &value)
@@ -45,8 +50,8 @@ const char *CallData::PushString(const Napi::Value &value)
     size_t len = 0;
     napi_status status;
 
-    buf.ptr = (char *)heap_mem->ptr;
-    buf.len = std::max((Size)0, heap_mem->len - Kibibytes(32));
+    buf.ptr = (char *)mem->heap.ptr;
+    buf.len = std::max((Size)0, mem->heap.len - Kibibytes(32));
 
     status = napi_get_value_string_utf8(env, value, buf.ptr, (size_t)buf.len, &len);
     RG_ASSERT(status == napi_ok);
@@ -54,15 +59,15 @@ const char *CallData::PushString(const Napi::Value &value)
     len++;
 
     if (RG_LIKELY(len < (size_t)buf.len)) {
-        heap_mem->ptr += (Size)len;
-        heap_mem->len -= (Size)len;
+        mem->heap.ptr += (Size)len;
+        mem->heap.len -= (Size)len;
     } else {
         status = napi_get_value_string_utf8(env, value, nullptr, 0, &len);
         RG_ASSERT(status == napi_ok);
 
         len++;
 
-        buf.ptr = (char *)Allocator::Allocate(&big_alloc, (Size)len);
+        buf.ptr = (char *)Allocator::Allocate(&mem->big_alloc, (Size)len);
         buf.len = (Size)len;
 
         status = napi_get_value_string_utf8(env, value, buf.ptr, (size_t)buf.len, &len);
@@ -82,8 +87,8 @@ const char16_t *CallData::PushString16(const Napi::Value &value)
     size_t len = 0;
     napi_status status;
 
-    buf.ptr = (char16_t *)heap_mem->ptr;
-    buf.len = std::max((Size)0, heap_mem->len - Kibibytes(32)) / 2;
+    buf.ptr = (char16_t *)mem->heap.ptr;
+    buf.len = std::max((Size)0, mem->heap.len - Kibibytes(32)) / 2;
 
     status = napi_get_value_string_utf16(env, value, buf.ptr, (size_t)buf.len, &len);
     RG_ASSERT(status == napi_ok);
@@ -91,15 +96,15 @@ const char16_t *CallData::PushString16(const Napi::Value &value)
     len++;
 
     if (RG_LIKELY(len < (size_t)buf.len)) {
-        heap_mem->ptr += (Size)len * 2;
-        heap_mem->len -= (Size)len * 2;
+        mem->heap.ptr += (Size)len * 2;
+        mem->heap.len -= (Size)len * 2;
     } else {
         status = napi_get_value_string_utf16(env, value, nullptr, 0, &len);
         RG_ASSERT(status == napi_ok);
 
         len++;
 
-        buf.ptr = (char16_t *)Allocator::Allocate(&big_alloc, (Size)len * 2);
+        buf.ptr = (char16_t *)Allocator::Allocate(&mem->big_alloc, (Size)len * 2);
         buf.len = (Size)len;
 
         status = napi_get_value_string_utf16(env, value, buf.ptr, (size_t)buf.len, &len);
@@ -109,11 +114,8 @@ const char16_t *CallData::PushString16(const Napi::Value &value)
     return buf.ptr;
 }
 
-bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t *dest)
+bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t *dest, int16_t realign)
 {
-    Napi::Env env = obj.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
-
     RG_ASSERT(IsObject(obj));
     RG_ASSERT(type->primitive == PrimitiveKind::Record);
 
@@ -125,21 +127,21 @@ bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t
             return false;
         }
 
-        dest = AlignUp(dest, member.align);
+        int16_t align = std::max(member.align, realign);
+        dest = AlignUp(dest, align);
 
         switch (member.type->primitive) {
             case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
 
             case PrimitiveKind::Bool: {
                 if (RG_UNLIKELY(!value.IsBoolean())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected boolean", GetValueType(instance, value), member.name);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected boolean", GetValueType(instance, value), member.name);
                     return false;
                 }
 
                 bool b = value.As<Napi::Boolean>();
                 *(bool *)dest = b;
             } break;
-
             case PrimitiveKind::Int8:
             case PrimitiveKind::UInt8:
             case PrimitiveKind::Int16:
@@ -149,7 +151,7 @@ bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t
             case PrimitiveKind::Int64:
             case PrimitiveKind::UInt64: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected number", GetValueType(instance, value), member.name);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected number", GetValueType(instance, value), member.name);
                     return false;
                 }
 
@@ -158,7 +160,7 @@ bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t
             } break;
             case PrimitiveKind::String: {
                 if (RG_UNLIKELY(!value.IsString())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected string", GetValueType(instance, value), member.name);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected string", GetValueType(instance, value), member.name);
                     return false;
                 }
 
@@ -169,7 +171,7 @@ bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t
             } break;
             case PrimitiveKind::String16: {
                 if (RG_UNLIKELY(!value.IsString())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected string", GetValueType(instance, value), member.name);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected string", GetValueType(instance, value), member.name);
                     return false;
                 }
 
@@ -190,31 +192,41 @@ bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t
             } break;
             case PrimitiveKind::Record: {
                 if (RG_UNLIKELY(!IsObject(value))) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected object", GetValueType(instance, value), member.name);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected object", GetValueType(instance, value), member.name);
                     return false;
                 }
 
                 Napi::Object obj = value.As<Napi::Object>();
-                if (!PushObject(obj, member.type, dest))
+                if (!PushObject(obj, member.type, dest, realign))
+                    return false;
+            } break;
+            case PrimitiveKind::Array: {
+                if (RG_UNLIKELY(!value.IsArray() && !value.IsTypedArray())) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected array", GetValueType(instance, value), member.name);
+                    return false;
+                }
+
+                Napi::Array array = value.As<Napi::Array>();
+                if (!PushArray(array, member.type, dest, realign))
                     return false;
             } break;
             case PrimitiveKind::Float32: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected number", GetValueType(instance, value), member.name);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected number", GetValueType(instance, value), member.name);
                     return false;
                 }
 
                 float f = CopyNumber<float>(value);
-                memcpy(dest, &f, 4);
+                *(float *)dest = f;
             } break;
             case PrimitiveKind::Float64: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected number", GetValueType(instance, value), member.name);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected number", GetValueType(instance, value), member.name);
                     return false;
                 }
 
                 double d = CopyNumber<double>(value);
-                memcpy(dest, &d, 8);
+                *(double *)dest = d;
             } break;
         }
 
@@ -224,65 +236,297 @@ bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t
     return true;
 }
 
-void CallData::PopObject(Napi::Object obj, const uint8_t *ptr, const TypeInfo *type)
+bool CallData::PushArray(const Napi::Object &obj, const TypeInfo *type, uint8_t *dest, int16_t realign)
 {
-    Napi::Env env = obj.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    RG_ASSERT(obj.IsArray() || obj.IsTypedArray());
+    RG_ASSERT(type->primitive == PrimitiveKind::Array);
+
+    uint32_t len = type->size / type->ref->size;
+
+    if (obj.IsArray()) {
+        Napi::Array array = obj.As<Napi::Array>();
+
+        if (array.Length() != len) {
+            ThrowError<Napi::Error>(env, "Expected array of length %1, got %2", len, array.Length());
+            return 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;
+                    }
+
+                    bool b = value.As<Napi::Boolean>();
+                    *(bool *)dest = b;
+
+                    dest += type->ref->size;
+                }
+            } break;
+            case PrimitiveKind::Int8:
+            case PrimitiveKind::UInt8:
+            case PrimitiveKind::Int16:
+            case PrimitiveKind::UInt16:
+            case PrimitiveKind::Int32:
+            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;
+                    }
+
+                    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;
+                    }
+
+                    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;
+                    }
+
+                    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;
+                    }
+
+                    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;
+                    }
+
+                    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>();
+                    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;
+                    }
+
+                    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;
+                    }
+
+                    double d = CopyNumber<double>(value);
+                    *(double *)dest = d;
+
+                    dest += type->ref->size;
+                }
+            } break;
+        }
+    } else {
+        Napi::TypedArray array = obj.As<Napi::TypedArray>();
+        const uint8_t *buf = (const uint8_t *)array.ArrayBuffer().Data();
+
+        if (array.ElementLength() != len) {
+            ThrowError<Napi::Error>(env, "Expected array of length %1, got %2", len, array.ElementLength());
+            return false;
+        }
+
+        bool match;
+        switch (type->ref->primitive) {
+            case PrimitiveKind::Int8: { match = (array.TypedArrayType() == napi_int8_array); } break;
+            case PrimitiveKind::UInt8: { match = (array.TypedArrayType() == napi_uint8_array); } break;
+            case PrimitiveKind::Int16: { match = (array.TypedArrayType() == napi_int16_array); } break;
+            case PrimitiveKind::UInt16: { match = (array.TypedArrayType() == napi_uint16_array); } break;
+            case PrimitiveKind::Int32: { match = (array.TypedArrayType() == napi_int32_array); } break;
+            case PrimitiveKind::UInt32: { match = (array.TypedArrayType() == napi_uint32_array); } break;
+            case PrimitiveKind::Float32: { match = (array.TypedArrayType() == napi_float32_array); } break;
+            case PrimitiveKind::Float64: { match = (array.TypedArrayType() == napi_float64_array); } break;
+
+            default: { match = false; } break;
+        }
+        if (!match) {
+            ThrowError<Napi::TypeError>(env, "TypedArray is not approriate for %1 array", type->ref->name);
+            return false;
+        }
+
+        for (uint32_t i = 0; i < len; i++) {
+            int16_t align = std::max(type->ref->align, realign);
+            dest = AlignUp(dest, align);
+
+            memcpy(dest, buf + i * type->ref->size, type->ref->size);
+
+            dest += type->ref->size;
+        }
+    }
 
+    return true;
+}
+
+void CallData::PopObject(Napi::Object obj, const uint8_t *src, const TypeInfo *type, int16_t realign)
+{
     RG_ASSERT(type->primitive == PrimitiveKind::Record);
 
     for (const RecordMember &member: type->members) {
-        ptr = AlignUp(ptr, member.align);
+        int16_t align = std::max(realign, member.align);
+        src = AlignUp(src, align);
 
         switch (member.type->primitive) {
             case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
 
             case PrimitiveKind::Bool: {
-                bool b = *(bool *)ptr;
+                bool b = *(bool *)src;
                 obj.Set(member.name, Napi::Boolean::New(env, b));
             } break;
             case PrimitiveKind::Int8: {
-                double d = (double)*(int8_t *)ptr;
+                double d = (double)*(int8_t *)src;
                 obj.Set(member.name, Napi::Number::New(env, d));
             } break;
             case PrimitiveKind::UInt8: {
-                double d = (double)*(uint8_t *)ptr;
+                double d = (double)*(uint8_t *)src;
                 obj.Set(member.name, Napi::Number::New(env, d));
             } break;
             case PrimitiveKind::Int16: {
-                double d = (double)*(int16_t *)ptr;
+                double d = (double)*(int16_t *)src;
                 obj.Set(member.name, Napi::Number::New(env, d));
             } break;
             case PrimitiveKind::UInt16: {
-                double d = (double)*(uint16_t *)ptr;
+                double d = (double)*(uint16_t *)src;
                 obj.Set(member.name, Napi::Number::New(env, d));
             } break;
             case PrimitiveKind::Int32: {
-                double d = (double)*(int32_t *)ptr;
+                double d = (double)*(int32_t *)src;
                 obj.Set(member.name, Napi::Number::New(env, d));
             } break;
             case PrimitiveKind::UInt32: {
-                double d = (double)*(uint32_t *)ptr;
+                double d = (double)*(uint32_t *)src;
                 obj.Set(member.name, Napi::Number::New(env, d));
             } break;
             case PrimitiveKind::Int64: {
-                int64_t v = *(int64_t *)ptr;
+                int64_t v = *(int64_t *)src;
                 obj.Set(member.name, Napi::BigInt::New(env, v));
             } break;
             case PrimitiveKind::UInt64: {
-                uint64_t v = *(uint64_t *)ptr;
+                uint64_t v = *(uint64_t *)src;
                 obj.Set(member.name, Napi::BigInt::New(env, v));
             } break;
             case PrimitiveKind::String: {
-                const char *str = *(const char **)ptr;
+                const char *str = *(const char **)src;
                 obj.Set(member.name, Napi::String::New(env, str));
             } break;
             case PrimitiveKind::String16: {
-                const char16_t *str16 = *(const char16_t **)ptr;
+                const char16_t *str16 = *(const char16_t **)src;
                 obj.Set(member.name, Napi::String::New(env, str16));
             } break;
             case PrimitiveKind::Pointer: {
-                void *ptr2 = *(void **)ptr;
+                void *ptr2 = *(void **)src;
 
                 Napi::External<void> external = Napi::External<void>::New(env, ptr2);
                 SetValueTag(instance, external, member.type);
@@ -290,32 +534,294 @@ void CallData::PopObject(Napi::Object obj, const uint8_t *ptr, const TypeInfo *t
                 obj.Set(member.name, external);
             } break;
             case PrimitiveKind::Record: {
-                Napi::Object obj2 = PopObject(ptr, member.type);
+                Napi::Object obj2 = PopObject(src, member.type, realign);
+                obj.Set(member.name, obj2);
+            } break;
+            case PrimitiveKind::Array: {
+                Napi::Object obj2 = PopArray(src, member.type, realign);
                 obj.Set(member.name, obj2);
             } break;
             case PrimitiveKind::Float32: {
                 float f;
-                memcpy(&f, ptr, 4);
+                memcpy(&f, src, 4);
                 obj.Set(member.name, Napi::Number::New(env, (double)f));
             } break;
             case PrimitiveKind::Float64: {
                 double d;
-                memcpy(&d, ptr, 8);
+                memcpy(&d, src, 8);
                 obj.Set(member.name, Napi::Number::New(env, d));
             } break;
         }
 
-        ptr += member.type->size;
+        src += member.type->size;
     }
 }
 
-Napi::Object CallData::PopObject(const uint8_t *ptr, const TypeInfo *type)
+Napi::Object CallData::PopObject(const uint8_t *src, const TypeInfo *type, int16_t realign)
 {
     Napi::Object obj = Napi::Object::New(env);
-    PopObject(obj, ptr, type);
+    PopObject(obj, src, type, realign);
     return obj;
 }
 
+Napi::Object CallData::PopArray(const uint8_t *src, const TypeInfo *type, int16_t realign)
+{
+    RG_ASSERT(type->primitive == PrimitiveKind::Array);
+
+    uint32_t len = type->size / type->ref->size;
+
+    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);
+
+                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::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);
+
+                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);
+
+                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);
+
+                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);
+
+                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);
+
+                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);
+
+                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);
+
+                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);
+
+            for (uint32_t i = 0; i < len; i++) {
+                int16_t align = std::max(realign, type->ref->align);
+                src = AlignUp(src, align);
+
+                double d = *(double *)src;
+                array[i] = d;
+
+                src += type->ref->size;
+            }
+
+            return array;
+        } break;
+    }
+
+    RG_UNREACHABLE();
+}
+
 static void DumpMemory(const char *type, Span<const uint8_t> bytes)
 {
     if (bytes.len) {
@@ -346,8 +852,8 @@ void CallData::DumpDebug() const
     }
     PrintLn(stderr, "Return: %1 (%2)", func->ret.type->name, FmtMemSize(func->ret.type->size));
 
-    DumpMemory("Stack", GetStack());
-    DumpMemory("Heap", GetHeap());
+    DumpMemory("Stack", stack);
+    DumpMemory("Heap", heap);
 }
 
 }