koffi 1.0.5 → 1.1.0-beta.2

package/src/abi_arm64.cc

@@ -41,28 +41,9 @@ extern "C" X0X1Ret ForwardCallXGG(const void *func, uint8_t *sp);
 extern "C" float ForwardCallXF(const void *func, uint8_t *sp);
 extern "C" HfaRet ForwardCallXDDDD(const void *func, uint8_t *sp);
 
-static bool IsHFA(const TypeInfo *type)
-{
-    if (type->primitive != PrimitiveKind::Record)
-        return false;
-
-    if (type->members.len < 1 || type->members.len > 4)
-        return false;
-    if (type->members[0].type->primitive != PrimitiveKind::Float32 &&
-            type->members[0].type->primitive != PrimitiveKind::Float64)
-        return false;
-
-    for (Size i = 1; i < type->members.len; i++) {
-        if (type->members[i].type != type->members[0].type)
-            return false;
-    }
-
-    return true;
-}
-
 bool AnalyseFunction(InstanceData *, FunctionInfo *func)
 {
-    if (IsHFA(func->ret.type)) {
+    if (IsHFA(func->ret.type, 1, 4)) {
         func->ret.vec_count = func->ret.type->members.len;
     } else if (func->ret.type->size <= 16) {
         func->ret.gpr_count = (func->ret.type->size + 7) / 8;
@@ -99,20 +80,6 @@ bool AnalyseFunction(InstanceData *, FunctionInfo *func)
                     gpr_avail--;
                 }
             } break;
-
-            case PrimitiveKind::Float32:
-            case PrimitiveKind::Float64: {
-#ifdef __APPLE__
-                if (param.variadic)
-                    break;
-#endif
-
-                if (vec_avail) {
-                    param.vec_count = 1;
-                    vec_avail--;
-                }
-            } break;
-
             case PrimitiveKind::Record: {
 #ifdef __APPLE__
                 if (param.variadic) {
@@ -121,7 +88,7 @@ bool AnalyseFunction(InstanceData *, FunctionInfo *func)
                 }
 #endif
 
-                if (IsHFA(param.type)) {
+                if (IsHFA(param.type, 1, 4)) {
                     int vec_count = (int)param.type->members.len;
 
                     if (vec_count <= vec_avail) {
@@ -148,6 +115,19 @@ bool AnalyseFunction(InstanceData *, FunctionInfo *func)
                     param.use_memory = true;
                 }
             } break;
+            case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
+            case PrimitiveKind::Float32:
+            case PrimitiveKind::Float64: {
+#ifdef __APPLE__
+                if (param.variadic)
+                    break;
+#endif
+
+                if (vec_avail) {
+                    param.vec_count = 1;
+                    vec_avail--;
+                }
+            } break;
         }
     }
 
@@ -157,62 +137,6 @@ bool AnalyseFunction(InstanceData *, FunctionInfo *func)
     return true;
 }
 
-static bool PushHFA(const Napi::Object &obj, const TypeInfo *type, uint8_t *dest)
-{
-    Napi::Env env = obj.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
-
-    RG_ASSERT(IsObject(obj));
-    RG_ASSERT(IsHFA(type));
-    RG_ASSERT(type->primitive == PrimitiveKind::Record);
-    RG_ASSERT(AlignUp(dest, type->members[0].type->size) == dest);
-
-    bool float32 = (type->members[0].type->primitive == PrimitiveKind::Float32);
-
-    for (const RecordMember &member: type->members) {
-        Napi::Value value = obj.Get(member.name);
-
-        if (!value.IsNumber() && !value.IsBigInt()) {
-            ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected number", GetValueType(instance, value), member.name);
-            return false;
-        }
-
-        if (float32) {
-            *(float *)dest = CopyNumber<float>(value);
-        } else {
-            *(double *)dest = CopyNumber<double>(value);
-        }
-
-        dest += 8;
-    }
-
-    return true;
-}
-
-static Napi::Object PopHFA(napi_env env, const uint8_t *ptr, const TypeInfo *type)
-{
-    RG_ASSERT(type->primitive == PrimitiveKind::Record);
-    RG_ASSERT(IsHFA(type));
-
-    Napi::Object obj = Napi::Object::New(env);
-
-    bool float32 = (type->members[0].type->primitive == PrimitiveKind::Float32);
-
-    for (const RecordMember &member: type->members) {
-        if (float32) {
-            float f = *(float *)ptr;
-            obj.Set(member.name, Napi::Number::New(env, (double)f));
-        } else {
-            double d = *(double *)ptr;
-            obj.Set(member.name, Napi::Number::New(env, d));
-        }
-
-        ptr += 8;
-    }
-
-    return obj;
-}
-
 bool CallData::Prepare(const Napi::CallbackInfo &info)
 {
     uint8_t *args_ptr = nullptr;
@@ -288,42 +212,6 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
 #endif
                 }
             } break;
-            case PrimitiveKind::Float32: {
-                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
-                    return false;
-                }
-
-                float f = CopyNumber<float>(value);
-
-                if (RG_LIKELY(param.vec_count)) {
-                    memcpy(vec_ptr++, &f, 4);
-                } else {
-                    args_ptr = AlignUp(args_ptr, 4);
-                    memcpy(args_ptr, &f, 4);
-#ifdef __APPLE__
-                    args_ptr += 4;
-#else
-                    args_ptr += 8;
-#endif
-                }
-            } break;
-            case PrimitiveKind::Float64: {
-                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
-                    return false;
-                }
-
-                double d = CopyNumber<double>(value);
-
-                if (RG_LIKELY(param.vec_count)) {
-                    memcpy(vec_ptr++, &d, 8);
-                } else {
-                    args_ptr = AlignUp(args_ptr, 8);
-                    memcpy(args_ptr, &d, 8);
-                    args_ptr += 8;
-                }
-            } break;
             case PrimitiveKind::String: {
                 const char *str;
                 if (RG_LIKELY(value.IsString())) {
@@ -384,8 +272,11 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                         memset(ptr, 0, param.type->size);
                     }
                     if (param.directions & 2) {
-                        OutObject out = {obj, ptr, param.type->ref};
-                        out_objects.Append(out);
+                        OutObject *out = out_objects.AppendDefault();
+
+                        out->ref.Reset(obj, 1);
+                        out->ptr = ptr;
+                        out->type = param.type->ref;
                     }
                 } else if (IsNullOrUndefined(value)) {
                     ptr = nullptr;
@@ -402,7 +293,6 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                     args_ptr += 8;
                 }
             } break;
-
             case PrimitiveKind::Record: {
                 if (RG_UNLIKELY(!IsObject(value))) {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected object", GetValueType(instance, value), i + 1);
@@ -411,8 +301,8 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
 
                 Napi::Object obj = value.As<Napi::Object>();
 
-                if (param.vec_count) {
-                    if (!PushHFA(obj, param.type, (uint8_t *)vec_ptr))
+                if (param.vec_count) { // HFA
+                    if (!PushObject(obj, param.type, (uint8_t *)vec_ptr, 8))
                         return false;
                     vec_ptr += param.vec_count;
                 } else if (!param.use_memory) {
@@ -448,9 +338,49 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                         return false;
                 }
             } break;
+            case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
+            case PrimitiveKind::Float32: {
+                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
+                    return false;
+                }
+
+                float f = CopyNumber<float>(value);
+
+                if (RG_LIKELY(param.vec_count)) {
+                    memcpy(vec_ptr++, &f, 4);
+                } else {
+                    args_ptr = AlignUp(args_ptr, 4);
+                    memcpy(args_ptr, &f, 4);
+#ifdef __APPLE__
+                    args_ptr += 4;
+#else
+                    args_ptr += 8;
+#endif
+                }
+            } break;
+            case PrimitiveKind::Float64: {
+                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
+                    return false;
+                }
+
+                double d = CopyNumber<double>(value);
+
+                if (RG_LIKELY(param.vec_count)) {
+                    memcpy(vec_ptr++, &d, 8);
+                } else {
+                    args_ptr = AlignUp(args_ptr, 8);
+                    memcpy(args_ptr, &d, 8);
+                    args_ptr += 8;
+                }
+            } break;
         }
     }
 
+    stack = MakeSpan(mem->stack.end(), old_stack_mem.end() - mem->stack.end());
+    heap = MakeSpan(old_heap_mem.ptr, mem->heap.ptr - old_heap_mem.ptr);
+
     return true;
 }
 
@@ -458,8 +388,8 @@ void CallData::Execute()
 {
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
-            auto ret = (func->forward_fp ? ForwardCallX ## Suffix(func->func, GetSP()) \
-                                         : ForwardCall ## Suffix(func->func, GetSP())); \
+            auto ret = (func->forward_fp ? ForwardCallX ## Suffix(func->func, stack.ptr) \
+                                         : ForwardCall ## Suffix(func->func, stack.ptr)); \
             return ret; \
         })()
 
@@ -489,6 +419,7 @@ void CallData::Execute()
                 PERFORM_CALL(GG);
             }
         } break;
+        case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
         case PrimitiveKind::Float32: { result.f = PERFORM_CALL(F); } break;
         case PrimitiveKind::Float64: { result.d = PERFORM_CALL(DDDD).d0; } break;
     }
@@ -498,8 +429,9 @@ void CallData::Execute()
 
 Napi::Value CallData::Complete()
 {
-    for (const OutObject &obj: out_objects) {
-        PopObject(obj.obj, obj.ptr, obj.type);
+    for (const OutObject &out: out_objects) {
+        Napi::Object obj = out.ref.Value().As<Napi::Object>();
+        PopObject(obj, out.ptr, out.type);
     }
 
     switch (func->ret.type->primitive) {
@@ -522,8 +454,8 @@ Napi::Value CallData::Complete()
             return external;
         } break;
         case PrimitiveKind::Record: {
-            if (func->ret.vec_count) {
-                Napi::Object obj = PopHFA(env, (const uint8_t *)&result.buf, func->ret.type);
+            if (func->ret.vec_count) { // HFA
+                Napi::Object obj = PopObject((const uint8_t *)&result.buf, func->ret.type, 8);
                 return obj;
             } else {
                 const uint8_t *ptr = return_ptr ? (const uint8_t *)return_ptr
@@ -533,6 +465,7 @@ Napi::Value CallData::Complete()
                 return obj;
             }
         } break;
+        case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
         case PrimitiveKind::Float32: return Napi::Number::New(env, (double)result.f);
         case PrimitiveKind::Float64: return Napi::Number::New(env, result.d);
     }

package/src/abi_x64_sysv.cc

@@ -98,13 +98,6 @@ static Size ClassifyType(const TypeInfo *type, Size offset, Span<RegisterClass>
             classes[0] = MergeClasses(classes[0], RegisterClass::Integer);
             return 1;
         } break;
-
-        case PrimitiveKind::Float32:
-        case PrimitiveKind::Float64: {
-            classes[0] = MergeClasses(classes[0], RegisterClass::SSE);
-            return 1;
-        } break;
-
         case PrimitiveKind::Record: {
             if (type->size > 64) {
                 classes[0] = MergeClasses(classes[0], RegisterClass::Memory);
@@ -119,6 +112,27 @@ static Size ClassifyType(const TypeInfo *type, Size offset, Span<RegisterClass>
 
             return (offset + 7) / 8;
         } break;
+        case PrimitiveKind::Array: {
+            if (type->size > 64) {
+                classes[0] = MergeClasses(classes[0], RegisterClass::Memory);
+                return 1;
+            }
+
+            Size len = type->size / type->ref->size;
+
+            for (Size i = 0; i < len; i++) {
+                Size start = offset / 8;
+                ClassifyType(type->ref, offset % 8, classes.Take(start, classes.len - start));
+                offset += type->ref->size;
+            }
+
+            return (offset + 7) / 8;
+        } break;
+        case PrimitiveKind::Float32:
+        case PrimitiveKind::Float64: {
+            classes[0] = MergeClasses(classes[0], RegisterClass::SSE);
+            return 1;
+        } break;
     }
 
     RG_UNREACHABLE();
@@ -308,8 +322,11 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                         memset(ptr, 0, param.type->size);
                     }
                     if (param.directions & 2) {
-                        OutObject out = {obj, ptr, param.type->ref};
-                        out_objects.Append(out);
+                        OutObject *out = out_objects.AppendDefault();
+
+                        out->ref.Reset(obj, 1);
+                        out->ptr = ptr;
+                        out->type = param.type->ref;
                     }
                 } else if (IsNullOrUndefined(value)) {
                     ptr = nullptr;
@@ -367,6 +384,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                     args_ptr += AlignLen(param.type->size, 8);
                 }
             } break;
+            case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
             case PrimitiveKind::Float32: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
@@ -402,6 +420,9 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
         }
     }
 
+    stack = MakeSpan(mem->stack.end(), old_stack_mem.end() - mem->stack.end());
+    heap = MakeSpan(old_heap_mem.ptr, mem->heap.ptr - old_heap_mem.ptr);
+
     return true;
 }
 
@@ -409,8 +430,8 @@ void CallData::Execute()
 {
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
-            auto ret = (func->forward_fp ? ForwardCallX ## Suffix(func->func, GetSP()) \
-                                         : ForwardCall ## Suffix(func->func, GetSP())); \
+            auto ret = (func->forward_fp ? ForwardCallX ## Suffix(func->func, stack.ptr) \
+                                         : ForwardCall ## Suffix(func->func, stack.ptr)); \
             return ret; \
         })()
 
@@ -444,6 +465,7 @@ void CallData::Execute()
                 memcpy_safe(&result.buf, &ret, RG_SIZE(ret));
             }
         } break;
+        case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
         case PrimitiveKind::Float32: { result.f = PERFORM_CALL(F); } break;
         case PrimitiveKind::Float64: { result.d = PERFORM_CALL(DG).xmm0; } break;
     }
@@ -453,8 +475,9 @@ void CallData::Execute()
 
 Napi::Value CallData::Complete()
 {
-    for (const OutObject &obj: out_objects) {
-        PopObject(obj.obj, obj.ptr, obj.type);
+    for (const OutObject &out: out_objects) {
+        Napi::Object obj = out.ref.Value().As<Napi::Object>();
+        PopObject(obj, out.ptr, out.type);
     }
 
     switch (func->ret.type->primitive) {
@@ -483,6 +506,7 @@ Napi::Value CallData::Complete()
             Napi::Object obj = PopObject(ptr, func->ret.type);
             return obj;
         } break;
+        case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
         case PrimitiveKind::Float32: return Napi::Number::New(env, (double)result.f);
         case PrimitiveKind::Float64: return Napi::Number::New(env, result.d);
     }

package/src/abi_x64_win.cc

@@ -148,8 +148,11 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                         memset(ptr, 0, param.type->size);
                     }
                     if (param.directions & 2) {
-                        OutObject out = {obj, ptr, param.type->ref};
-                        out_objects.Append(out);
+                        OutObject *out = out_objects.AppendDefault();
+
+                        out->ref.Reset(obj, 1);
+                        out->ptr = ptr;
+                        out->type = param.type->ref;
                     }
                 } else if (IsNullOrUndefined(value)) {
                     ptr = nullptr;
@@ -179,6 +182,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 if (!PushObject(obj, param.type, ptr))
                     return false;
             } break;
+            case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
             case PrimitiveKind::Float32: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
@@ -200,6 +204,9 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
         }
     }
 
+    stack = MakeSpan(mem->stack.end(), old_stack_mem.end() - mem->stack.end());
+    heap = MakeSpan(old_heap_mem.ptr, mem->heap.ptr - old_heap_mem.ptr);
+
     return true;
 }
 
@@ -207,8 +214,8 @@ void CallData::Execute()
 {
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
-            auto ret = (func->forward_fp ? ForwardCallX ## Suffix(func->func, GetSP()) \
-                                         : ForwardCall ## Suffix(func->func, GetSP())); \
+            auto ret = (func->forward_fp ? ForwardCallX ## Suffix(func->func, stack.ptr) \
+                                         : ForwardCall ## Suffix(func->func, stack.ptr)); \
             return ret; \
         })()
 
@@ -227,6 +234,7 @@ void CallData::Execute()
         case PrimitiveKind::String16:
         case PrimitiveKind::Pointer:
         case PrimitiveKind::Record: { result.u64 = PERFORM_CALL(G); } break;
+        case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
         case PrimitiveKind::Float32: { result.f = PERFORM_CALL(F); } break;
         case PrimitiveKind::Float64: { result.d = PERFORM_CALL(D); } break;
     }
@@ -236,8 +244,9 @@ void CallData::Execute()
 
 Napi::Value CallData::Complete()
 {
-    for (const OutObject &obj: out_objects) {
-        PopObject(obj.obj, obj.ptr, obj.type);
+    for (const OutObject &out: out_objects) {
+        Napi::Object obj = out.ref.Value().As<Napi::Object>();
+        PopObject(obj, out.ptr, out.type);
     }
 
     switch (func->ret.type->primitive) {
@@ -266,6 +275,7 @@ Napi::Value CallData::Complete()
             Napi::Object obj = PopObject(ptr, func->ret.type);
             return obj;
         } break;
+        case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
         case PrimitiveKind::Float32: return Napi::Number::New(env, (double)result.f);
         case PrimitiveKind::Float64: return Napi::Number::New(env, result.d);
     }

package/src/abi_x86.cc

@@ -192,8 +192,11 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                         memset(ptr, 0, param.type->size);
                     }
                     if (param.directions & 2) {
-                        OutObject out = {obj, ptr, param.type->ref};
-                        out_objects.Append(out);
+                        OutObject *out = out_objects.AppendDefault();
+
+                        out->ref.Reset(obj, 1);
+                        out->ptr = ptr;
+                        out->type = param.type->ref;
                     }
                 } else if (IsNullOrUndefined(value)) {
                     ptr = nullptr;
@@ -223,6 +226,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                     args_ptr = (uint32_t *)AlignUp(ptr + param.type->size, 4);
                 }
             } break;
+            case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
             case PrimitiveKind::Float32: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
@@ -245,6 +249,9 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
         }
     }
 
+    stack = MakeSpan(mem->stack.end(), old_stack_mem.end() - mem->stack.end());
+    heap = MakeSpan(old_heap_mem.ptr, mem->heap.ptr - old_heap_mem.ptr);
+
     return true;
 }
 
@@ -252,8 +259,8 @@ void CallData::Execute()
 {
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
-            auto ret = (func->convention == CallConvention::Fastcall ? ForwardCallR ## Suffix(func->func, GetSP()) \
-                                                                     : ForwardCall ## Suffix(func->func, GetSP())); \
+            auto ret = (func->convention == CallConvention::Fastcall ? ForwardCallR ## Suffix(func->func, stack.ptr) \
+                                                                     : ForwardCall ## Suffix(func->func, stack.ptr)); \
             return ret; \
         })()
 
@@ -273,6 +280,7 @@ void CallData::Execute()
         case PrimitiveKind::String16:
         case PrimitiveKind::Pointer:
         case PrimitiveKind::Record: { result.u64 = PERFORM_CALL(G); } break;
+        case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
         case PrimitiveKind::Float32: { result.f = PERFORM_CALL(F); } break;
         case PrimitiveKind::Float64: { result.d = PERFORM_CALL(D); } break;
     }
@@ -282,8 +290,9 @@ void CallData::Execute()
 
 Napi::Value CallData::Complete()
 {
-    for (const OutObject &obj: out_objects) {
-        PopObject(obj.obj, obj.ptr, obj.type);
+    for (const OutObject &out: out_objects) {
+        Napi::Object obj = out.ref.Value().As<Napi::Object>();
+        PopObject(obj, out.ptr, out.type);
     }
 
     switch (func->ret.type->primitive) {
@@ -312,6 +321,7 @@ Napi::Value CallData::Complete()
             Napi::Object obj = PopObject(ptr, func->ret.type);
             return obj;
         } break;
+        case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
         case PrimitiveKind::Float32: return Napi::Number::New(env, (double)result.f);
         case PrimitiveKind::Float64: return Napi::Number::New(env, result.d);
     }