koffi 0.9.6 → 0.9.9

package/src/call_arm64.cc

@@ -60,7 +60,7 @@ static bool IsHFA(const TypeInfo *type)
     return true;
 }
 
-bool AnalyseFunction(FunctionInfo *func)
+bool AnalyseFunction(InstanceData *, FunctionInfo *func)
 {
     if (IsHFA(func->ret.type)) {
         func->ret.vec_count = func->ret.type->members.len;
@@ -133,6 +133,7 @@ bool AnalyseFunction(FunctionInfo *func)
         }
     }
 
+    func->args_size = 16 * func->parameters.len;
     func->forward_fp = (vec_avail < 8);
 
     return true;
@@ -143,7 +144,7 @@ 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(obj.IsObject());
+    RG_ASSERT(IsObject(obj));
     RG_ASSERT(type->primitive == PrimitiveKind::Record);
     RG_ASSERT(AlignUp(dest, 8) == dest);
 
@@ -156,14 +157,14 @@ static bool PushHFA(const Napi::Object &obj, const TypeInfo *type, uint8_t *dest
                 return false;
             }
 
-            *(float *)dest = CopyNodeNumber<float>(value);
+            *(float *)dest = CopyNumber<float>(value);
         } else if (member.type->primitive == PrimitiveKind::Float64) {
             if (!value.IsNumber() && !value.IsBigInt()) {
                 ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected number", GetValueType(instance, value), member.name);
                 return false;
             }
 
-            *(double *)dest = CopyNodeNumber<double>(value);
+            *(double *)dest = CopyNumber<double>(value);
         } else {
             RG_UNREACHABLE();
         }
@@ -201,11 +202,9 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
-
     FunctionInfo *func = (FunctionInfo *)info.Data();
-    LibraryData *lib = func->lib.get();
 
-    RG_DEFER { lib->tmp_alloc.ReleaseAll(); };
+    CallData call(env, instance, func);
 
     // Sanity checks
     if (info.Length() < (uint32_t)func->parameters.len) {
@@ -213,46 +212,31 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    // Stack pointer and register
-    uint8_t *top_ptr = lib->stack.end();
-    uint8_t *scratch_ptr = top_ptr - func->scratch_size;
     uint8_t *return_ptr = nullptr;
     uint8_t *args_ptr = nullptr;
-    uint64_t *gpr_ptr = nullptr, *vec_ptr = nullptr;
-    uint8_t *sp_ptr = nullptr;
+    uint64_t *gpr_ptr = nullptr;
+    uint64_t *vec_ptr = nullptr;
 
     // Return through registers unless it's too big
-    if (!func->ret.use_memory) {
-        args_ptr = scratch_ptr - AlignLen(8 * func->parameters.len, 16);
-        vec_ptr = (uint64_t *)args_ptr - 8;
-        gpr_ptr = vec_ptr - 9;
-        sp_ptr = (uint8_t *)gpr_ptr;
-
-#ifdef RG_DEBUG
-        memset(sp_ptr, 0, top_ptr - sp_ptr);
-#endif
-    } else {
-        return_ptr = scratch_ptr - AlignLen(func->ret.type->size, 16);
-
-        args_ptr = return_ptr - AlignLen(8 * func->parameters.len, 16);
-        vec_ptr = (uint64_t *)args_ptr - 8;
-        gpr_ptr = vec_ptr - 9;
-        sp_ptr = (uint8_t *)gpr_ptr;
-
-#ifdef RG_DEBUG
-        memset(sp_ptr, 0, top_ptr - sp_ptr);
-#endif
-
+    if (RG_UNLIKELY(!call.AllocStack(func->args_size, 16, &args_ptr)))
+        return env.Null();
+    if (RG_UNLIKELY(!call.AllocStack(8 * 8, 8, &vec_ptr)))
+        return env.Null();
+    if (RG_UNLIKELY(!call.AllocStack(9 * 8, 8, &gpr_ptr)))
+        return env.Null();
+    if (func->ret.use_memory) {
+        if (RG_UNLIKELY(!call.AllocHeap(func->ret.type->size, 16, &return_ptr)))
+            return env.Null();
         gpr_ptr[8] = (uint64_t)return_ptr;
     }
 
-    RG_ASSERT(AlignUp(lib->stack.ptr, 16) == lib->stack.ptr);
-    RG_ASSERT(AlignUp(lib->stack.end(), 16) == lib->stack.end());
-    RG_ASSERT(AlignUp(sp_ptr - 8, 16) == sp_ptr);
+    LocalArray<OutObject, MaxOutParameters> out_objects;
 
     // Push arguments
     for (Size i = 0; i < func->parameters.len; i++) {
         const ParameterInfo &param = func->parameters[i];
+        RG_ASSERT(param.directions >= 1 && param.directions <= 3);
+
         Napi::Value value = info[i];
 
         switch (param.type->primitive) {
@@ -285,7 +269,7 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                     return env.Null();
                 }
 
-                int64_t v = CopyNodeNumber<int64_t>(value);
+                int64_t v = CopyNumber<int64_t>(value);
 
                 if (RG_LIKELY(param.gpr_count)) {
                     *(gpr_ptr++) = (uint64_t)v;
@@ -301,7 +285,7 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                     return env.Null();
                 }
 
-                float f = CopyNodeNumber<float>(value);
+                float f = CopyNumber<float>(value);
 
                 if (RG_LIKELY(param.vec_count)) {
                     memcpy(vec_ptr++, &f, 4);
@@ -317,7 +301,7 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                     return env.Null();
                 }
 
-                double d = CopyNodeNumber<double>(value);
+                double d = CopyNumber<double>(value);
 
                 if (RG_LIKELY(param.vec_count)) {
                     memcpy(vec_ptr++, &d, 8);
@@ -328,13 +312,18 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                 }
             } break;
             case PrimitiveKind::String: {
-                if (RG_UNLIKELY(!value.IsString())) {
+                const char *str;
+                if (RG_LIKELY(value.IsString())) {
+                    str = call.PushString(value);
+                    if (RG_UNLIKELY(!str))
+                        return env.Null();
+                } else if (IsNullOrUndefined(value)) {
+                    str = nullptr;
+                } else {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected string", GetValueType(instance, value), i + 1);
                     return env.Null();
                 }
 
-                const char *str = CopyNodeString(value, &lib->tmp_alloc);
-
                 if (RG_LIKELY(param.gpr_count)) {
                     *(gpr_ptr++) = (uint64_t)str;
                 } else {
@@ -344,13 +333,29 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                 }
             } break;
             case PrimitiveKind::Pointer: {
-                if (RG_UNLIKELY(!CheckValueTag(instance, value, param.type))) {
+                uint8_t *ptr;
+
+                if (CheckValueTag(instance, value, param.type)) {
+                    ptr = value.As<Napi::External<uint8_t>>().Data();
+                } else if (IsObject(value) && param.type->ref->primitive == PrimitiveKind::Record) {
+                    Napi::Object obj = value.As<Napi::Object>();
+
+                    if (RG_UNLIKELY(!call.AllocHeap(param.type->ref->size, 16, &ptr)))
+                        return env.Null();
+
+                    if ((param.directions & 1) && !call.PushObject(obj, param.type->ref, ptr))
+                        return env.Null();
+                    if (param.directions & 2) {
+                        OutObject out = {obj, ptr, param.type->ref};
+                        out_objects.Append(out);
+                    }
+                } else if (IsNullOrUndefined(value)) {
+                    ptr = nullptr;
+                } else {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected %3", GetValueType(instance, value), i + 1, param.type->name);
                     return env.Null();
                 }
 
-                void *ptr = value.As<Napi::External<void>>();
-
                 if (RG_LIKELY(param.gpr_count)) {
                     *(gpr_ptr++) = (uint64_t)ptr;
                 } else {
@@ -361,7 +366,7 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
             } break;
 
             case PrimitiveKind::Record: {
-                if (RG_UNLIKELY(!value.IsObject())) {
+                if (RG_UNLIKELY(!IsObject(value))) {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected object", GetValueType(instance, value), i + 1);
                     return env.Null();
                 }
@@ -376,20 +381,21 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                     if (param.gpr_count) {
                         RG_ASSERT(param.type->align <= 8);
 
-                        if (!PushObject(obj, param.type, &lib->tmp_alloc, (uint8_t *)gpr_ptr))
+                        if (!call.PushObject(obj, param.type, (uint8_t *)gpr_ptr))
                             return env.Null();
                         gpr_ptr += param.gpr_count;
                     } else if (param.type->size) {
                         int16_t align = (param.type->align <= 4) ? 4 : 8;
 
                         args_ptr = AlignUp(args_ptr, align);
-                        if (!PushObject(obj, param.type, &lib->tmp_alloc, args_ptr))
+                        if (!call.PushObject(obj, param.type, args_ptr))
                             return env.Null();
                         args_ptr += AlignLen(param.type->size, 8);
                     }
                 } else {
-                    uint8_t *ptr = scratch_ptr;
-                    scratch_ptr += AlignLen(param.type->size, 16);
+                    uint8_t *ptr;
+                    if (RG_UNLIKELY(!call.AllocHeap(param.type->size, 16, &ptr)))
+                        return env.Null();
 
                     if (param.gpr_count) {
                         RG_ASSERT(param.gpr_count == 1);
@@ -402,18 +408,24 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                         args_ptr += 8;
                     }
 
-                    if (!PushObject(obj, param.type, &lib->tmp_alloc, ptr))
+                    if (!call.PushObject(obj, param.type, ptr))
                         return env.Null();
                 }
             } break;
         }
     }
 
-    // DumpStack(func, MakeSpan(sp_ptr, top_ptr - sp_ptr));
+    if (instance->debug) {
+        call.DumpDebug();
+    }
 
 #define PERFORM_CALL(Suffix) \
-        (func->forward_fp ? ForwardCallX ## Suffix(func->func, sp_ptr) \
-                          : ForwardCall ## Suffix(func->func, sp_ptr))
+        ([&]() { \
+            auto ret = (func->forward_fp ? ForwardCallX ## Suffix(func->func, call.GetSP()) \
+                                         : ForwardCall ## Suffix(func->func, call.GetSP())); \
+            PopOutArguments(out_objects); \
+            return ret; \
+        })()
 
     // Execute and convert return value
     switch (func->ret.type->primitive) {

package/src/call_x64_sysv.cc

@@ -159,7 +159,7 @@ static void AnalyseParameter(ParameterInfo *param, int gpr_avail, int xmm_avail)
     }
 }
 
-bool AnalyseFunction(FunctionInfo *func)
+bool AnalyseFunction(InstanceData *, FunctionInfo *func)
 {
     AnalyseParameter(&func->ret, 2, 2);
 
@@ -171,6 +171,8 @@ bool AnalyseFunction(FunctionInfo *func)
 
         gpr_avail -= param.gpr_count;
         xmm_avail -= param.xmm_count;
+
+        func->args_size += AlignLen(param.type->size, 16);
     }
 
     func->forward_fp = (xmm_avail < 8);
@@ -182,11 +184,9 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
-
     FunctionInfo *func = (FunctionInfo *)info.Data();
-    LibraryData *lib = func->lib.get();
 
-    RG_DEFER { lib->tmp_alloc.ReleaseAll(); };
+    CallData call(env, instance, func);
 
     // Sanity checks
     if (info.Length() < (uint32_t)func->parameters.len) {
@@ -194,45 +194,31 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    // Stack pointer and register
-    uint8_t *top_ptr = lib->stack.end();
     uint8_t *return_ptr = nullptr;
     uint8_t *args_ptr = nullptr;
-    uint64_t *gpr_ptr = nullptr, *xmm_ptr = nullptr;
-    uint8_t *sp_ptr = nullptr;
+    uint64_t *gpr_ptr = nullptr;
+    uint64_t *xmm_ptr = nullptr;
 
     // Return through registers unless it's too big
-    if (!func->ret.use_memory) {
-        args_ptr = top_ptr - func->scratch_size;
-        xmm_ptr = (uint64_t *)args_ptr - 8;
-        gpr_ptr = xmm_ptr - 6;
-        sp_ptr = (uint8_t *)gpr_ptr;
-
-#ifdef RG_DEBUG
-        memset(sp_ptr, 0, top_ptr - sp_ptr);
-#endif
-    } else {
-        return_ptr = top_ptr - AlignLen(func->ret.type->size, 16);
-
-        args_ptr = return_ptr - func->scratch_size;
-        xmm_ptr = (uint64_t *)args_ptr - 8;
-        gpr_ptr = xmm_ptr - 6;
-        sp_ptr = (uint8_t *)gpr_ptr;
-
-#ifdef RG_DEBUG
-        memset(sp_ptr, 0, top_ptr - sp_ptr);
-#endif
-
-        *(gpr_ptr++) = (uint64_t)return_ptr;
+    if (RG_UNLIKELY(!call.AllocStack(func->args_size, 16, &args_ptr)))
+        return env.Null();
+    if (RG_UNLIKELY(!call.AllocStack(8 * 8, 8, &xmm_ptr)))
+        return env.Null();
+    if (RG_UNLIKELY(!call.AllocStack(6 * 8, 8, &gpr_ptr)))
+        return env.Null();
+    if (func->ret.use_memory) {
+        if (RG_UNLIKELY(!call.AllocHeap(func->ret.type->size, 16, &return_ptr)))
+            return env.Null();
+        *(uint8_t **)(gpr_ptr++) = return_ptr;
     }
 
-    RG_ASSERT(AlignUp(lib->stack.ptr, 16) == lib->stack.ptr);
-    RG_ASSERT(AlignUp(lib->stack.end(), 16) == lib->stack.end());
-    RG_ASSERT(AlignUp(sp_ptr, 16) == sp_ptr);
+    LocalArray<OutObject, MaxOutParameters> out_objects;
 
     // Push arguments
     for (Size i = 0; i < func->parameters.len; i++) {
         const ParameterInfo &param = func->parameters[i];
+        RG_ASSERT(param.directions >= 1 && param.directions <= 3);
+
         Napi::Value value = info[i];
 
         switch (param.type->primitive) {
@@ -265,7 +251,7 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                     return env.Null();
                 }
 
-                int64_t v = CopyNodeNumber<int64_t>(value);
+                int64_t v = CopyNumber<int64_t>(value);
 
                 if (RG_LIKELY(param.gpr_count)) {
                     *(gpr_ptr++) = (uint64_t)v;
@@ -281,7 +267,7 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                     return env.Null();
                 }
 
-                float f = CopyNodeNumber<float>(value);
+                float f = CopyNumber<float>(value);
 
                 if (RG_LIKELY(param.xmm_count)) {
                     memcpy(xmm_ptr++, &f, 4);
@@ -297,7 +283,7 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                     return env.Null();
                 }
 
-                double d = CopyNodeNumber<double>(value);
+                double d = CopyNumber<double>(value);
 
                 if (RG_LIKELY(param.xmm_count)) {
                     memcpy(xmm_ptr++, &d, 8);
@@ -308,13 +294,18 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                 }
             } break;
             case PrimitiveKind::String: {
-                if (RG_UNLIKELY(!value.IsString())) {
+                const char *str;
+                if (RG_LIKELY(value.IsString())) {
+                    str = call.PushString(value);
+                    if (RG_UNLIKELY(!str))
+                        return env.Null();
+                } else if (IsNullOrUndefined(value)) {
+                    str = nullptr;
+                } else {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected string", GetValueType(instance, value), i + 1);
                     return env.Null();
                 }
 
-                const char *str = CopyNodeString(value, &lib->tmp_alloc);
-
                 if (RG_LIKELY(param.gpr_count)) {
                     *(gpr_ptr++) = (uint64_t)str;
                 } else {
@@ -324,13 +315,29 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                 }
             } break;
             case PrimitiveKind::Pointer: {
-                if (RG_UNLIKELY(!CheckValueTag(instance, value, param.type))) {
+                uint8_t *ptr;
+
+                if (CheckValueTag(instance, value, param.type)) {
+                    ptr = value.As<Napi::External<uint8_t>>().Data();
+                } else if (IsObject(value) && param.type->ref->primitive == PrimitiveKind::Record) {
+                    Napi::Object obj = value.As<Napi::Object>();
+
+                    if (RG_UNLIKELY(!call.AllocHeap(param.type->ref->size, 16, &ptr)))
+                        return env.Null();
+
+                    if ((param.directions & 1) && !call.PushObject(obj, param.type->ref, ptr))
+                        return env.Null();
+                    if (param.directions & 2) {
+                        OutObject out = {obj, ptr, param.type->ref};
+                        out_objects.Append(out);
+                    }
+                } else if (IsNullOrUndefined(value)) {
+                    ptr = nullptr;
+                } else {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected %3", GetValueType(instance, value), i + 1, param.type->name);
                     return env.Null();
                 }
 
-                void *ptr = value.As<Napi::External<void>>();
-
                 if (RG_LIKELY(param.gpr_count)) {
                     *(gpr_ptr++) = (uint64_t)ptr;
                 } else {
@@ -341,7 +348,7 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
             } break;
 
             case PrimitiveKind::Record: {
-                if (RG_UNLIKELY(!value.IsObject())) {
+                if (RG_UNLIKELY(!IsObject(value))) {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected object", GetValueType(instance, value), i + 1);
                     return env.Null();
                 }
@@ -352,7 +359,7 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                     RG_ASSERT(param.type->size <= 16);
 
                     uint64_t buf[2] = {};
-                    if (!PushObject(obj, param.type, &lib->tmp_alloc, (uint8_t *)buf))
+                    if (!call.PushObject(obj, param.type, (uint8_t *)buf))
                         return env.Null();
 
                     if (param.gpr_first) {
@@ -376,7 +383,7 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                     }
                 } else if (param.use_memory) {
                     args_ptr = AlignUp(args_ptr, param.type->align);
-                    if (!PushObject(obj, param.type, &lib->tmp_alloc, args_ptr))
+                    if (!call.PushObject(obj, param.type, args_ptr))
                         return env.Null();
                     args_ptr += param.type->size;
                 }
@@ -384,11 +391,17 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
         }
     }
 
-    // DumpStack(func, MakeSpan(sp_ptr, top_ptr - sp_ptr));
+    if (instance->debug) {
+        call.DumpDebug();
+    }
 
 #define PERFORM_CALL(Suffix) \
-        (func->forward_fp ? ForwardCallX ## Suffix(func->func, sp_ptr) \
-                          : ForwardCall ## Suffix(func->func, sp_ptr))
+        ([&]() { \
+            auto ret = (func->forward_fp ? ForwardCallX ## Suffix(func->func, call.GetSP()) \
+                                         : ForwardCall ## Suffix(func->func, call.GetSP())); \
+            PopOutArguments(out_objects); \
+            return ret; \
+        })()
 
     // Execute and convert return value
     switch (func->ret.type->primitive) {