koffi 2.3.4 → 2.3.6-beta.1

package/src/koffi/src/abi_x64_win.cc

@@ -143,7 +143,8 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
 
                 *(void **)(args_ptr++) = ptr;
             } break;
-            case PrimitiveKind::Record: {
+            case PrimitiveKind::Record:
+            case PrimitiveKind::Union: {
                 if (RG_UNLIKELY(!IsObject(value))) {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected object", GetValueType(instance, value));
                     return false;
@@ -261,6 +262,7 @@ void CallData::Execute(const FunctionInfo *func)
         case PrimitiveKind::String16:
         case PrimitiveKind::Pointer:
         case PrimitiveKind::Record:
+        case PrimitiveKind::Union:
         case PrimitiveKind::Callback: { result.u64 = PERFORM_CALL(G); } break;
         case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
         case PrimitiveKind::Float32: { result.f = PERFORM_CALL(F); } break;
@@ -312,7 +314,8 @@ Napi::Value CallData::Complete(const FunctionInfo *func)
                 return env.Null();
             }
         } break;
-        case PrimitiveKind::Record: {
+        case PrimitiveKind::Record:
+        case PrimitiveKind::Union: {
             const uint8_t *ptr = return_ptr ? (const uint8_t *)return_ptr
                                             : (const uint8_t *)&result.buf;
 
@@ -529,7 +532,8 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
                     param.type->dispose(env, param.type, ptr2);
                 }
             } break;
-            case PrimitiveKind::Record: {
+            case PrimitiveKind::Record:
+            case PrimitiveKind::Union: {
                 uint8_t *ptr;
                 if (param.regular) {
                     ptr = (uint8_t *)(j < 4 ? gpr_ptr + j : args_ptr);
@@ -641,7 +645,8 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
 
             if (CheckValueTag(instance, value, type->ref.marker)) {
                 ptr = value.As<Napi::External<uint8_t>>().Data();
-            } else if (IsObject(value) && type->ref.type->primitive == PrimitiveKind::Record) {
+            } else if (IsObject(value) && (type->ref.type->primitive == PrimitiveKind::Record ||
+                                           type->ref.type->primitive == PrimitiveKind::Union)) {
                 Napi::Object obj = value.As<Napi::Object>();
 
                 ptr = AllocHeap(type->ref.type->size, 16);
@@ -657,7 +662,8 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
 
             out_reg->rax = (uint64_t)ptr;
         } break;
-        case PrimitiveKind::Record: {
+        case PrimitiveKind::Record:
+        case PrimitiveKind::Union: {
             if (RG_UNLIKELY(!IsObject(value))) {
                 ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected object", GetValueType(instance, value));
                 return;

package/src/koffi/src/abi_x86.cc

@@ -61,7 +61,8 @@ bool AnalyseFunction(Napi::Env env, InstanceData *instance, FunctionInfo *func)
                (func->convention == CallConvention::Thiscall) ? 1 : 0;
     func->fast = fast;
 
-    if (func->ret.type->primitive != PrimitiveKind::Record) {
+    if (func->ret.type->primitive != PrimitiveKind::Record &&
+            func->ret.type->primitive != PrimitiveKind::Union) {
         func->ret.trivial = true;
 #if defined(_WIN32) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
     } else {
@@ -224,7 +225,8 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
 
                 *(void **)((param.fast ? fast_ptr : args_ptr)++) = ptr;
             } break;
-            case PrimitiveKind::Record: {
+            case PrimitiveKind::Record:
+            case PrimitiveKind::Union: {
                 if (RG_UNLIKELY(!IsObject(value))) {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected object", GetValueType(instance, value));
                     return false;
@@ -346,7 +348,8 @@ void CallData::Execute(const FunctionInfo *func)
         case PrimitiveKind::String:
         case PrimitiveKind::String16:
         case PrimitiveKind::Pointer:
-        case PrimitiveKind::Record: 
+        case PrimitiveKind::Record:
+        case PrimitiveKind::Union:
         case PrimitiveKind::Callback: { result.u64 = PERFORM_CALL(G); } break;
         case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
         case PrimitiveKind::Float32: { result.f = PERFORM_CALL(F); } break;
@@ -398,7 +401,8 @@ Napi::Value CallData::Complete(const FunctionInfo *func)
                 return env.Null();
             }
         } break;
-        case PrimitiveKind::Record: {
+        case PrimitiveKind::Record:
+        case PrimitiveKind::Union: {
             const uint8_t *ptr = return_ptr ? (const uint8_t *)return_ptr
                                             : (const uint8_t *)&result.buf;
 
@@ -617,7 +621,8 @@ void CallData::Relay(Size idx, uint8_t *, uint8_t *caller_sp, bool async, BackRe
                     param.type->dispose(env, param.type, ptr2);
                 }
             } break;
-            case PrimitiveKind::Record: {
+            case PrimitiveKind::Record:
+            case PrimitiveKind::Union: {
                 RG_ASSERT(!param.fast);
 
                 uint8_t *ptr = (uint8_t *)args_ptr;
@@ -750,7 +755,8 @@ void CallData::Relay(Size idx, uint8_t *, uint8_t *caller_sp, bool async, BackRe
 
             if (CheckValueTag(instance, value, type->ref.marker)) {
                 ptr = value.As<Napi::External<uint8_t>>().Data();
-            } else if (IsObject(value) && type->ref.type->primitive == PrimitiveKind::Record) {
+            } else if (IsObject(value) && (type->ref.type->primitive == PrimitiveKind::Record ||
+                                           type->ref.type->primitive == PrimitiveKind::Union)) {
                 Napi::Object obj = value.As<Napi::Object>();
 
                 ptr = AllocHeap(type->ref.type->size, 16);
@@ -766,7 +772,8 @@ void CallData::Relay(Size idx, uint8_t *, uint8_t *caller_sp, bool async, BackRe
 
             out_reg->eax = (uint32_t)ptr;
         } break;
-        case PrimitiveKind::Record: {
+        case PrimitiveKind::Record:
+        case PrimitiveKind::Union: {
             if (RG_UNLIKELY(!IsObject(value))) {
                 ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected object", GetValueType(instance, value));
                 return;

package/src/koffi/src/call.cc

@@ -22,6 +22,7 @@ namespace RG {
 
 struct RelayContext {
     CallData *call;
+    bool dispose_call;
 
     Size idx;
     uint8_t *own_sp;
@@ -45,6 +46,14 @@ CallData::CallData(Napi::Env env, InstanceData *instance, InstanceMemory *mem)
 }
 
 CallData::~CallData()
+{
+    if (!instance)
+        return;
+
+    Dispose();
+}
+
+void CallData::Dispose()
 {
     for (const OutArgument &out: out_arguments) {
         napi_delete_reference(env, out.ref);
@@ -71,14 +80,18 @@ CallData::~CallData()
 
     instance->temporaries -= mem->temporary;
 
-    if (!--mem->depth && mem->temporary) {
-        delete mem;
+    if (!--mem->depth) {
+        mem->busy = false;
+
+        if (mem->temporary) {
+            delete mem;
+        }
     }
 
     instance = nullptr;
 }
 
-void CallData::RelaySafe(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
+void CallData::RelaySafe(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool dispose_call, BackRegisters *out_reg)
 {
     if (std::this_thread::get_id() != instance->main_thread_id) {
         // JS/V8 is single-threaded, and runs on main_thread_id. Forward the call
@@ -87,6 +100,7 @@ void CallData::RelaySafe(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegi
         RelayContext ctx;
 
         ctx.call = this;
+        ctx.dispose_call = dispose_call;
         ctx.idx = idx;
         ctx.own_sp = own_sp;
         ctx.caller_sp = caller_sp;
@@ -100,6 +114,7 @@ void CallData::RelaySafe(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegi
             ctx.cv.wait(lock);
         }
     } else {
+        RG_ASSERT(!dispose_call);
         Relay(idx, own_sp, caller_sp, false, out_reg);
     }
 }
@@ -110,6 +125,10 @@ void CallData::RelayAsync(napi_env, napi_value, void *, void *udata)
 
     ctx->call->Relay(ctx->idx, ctx->own_sp, ctx->caller_sp, true, ctx->out_reg);
 
+    if (ctx->dispose_call) {
+        ctx->call->Dispose();
+    }
+
     // We're done!
     std::lock_guard<std::mutex> lock(ctx->mutex);
     ctx->done = true;
@@ -163,7 +182,7 @@ bool CallData::PushString(Napi::Value value, int directions, const char **out_st
             type->align = 1;
             type->size = (int32_t)len;
             type->ref.type = instance->char_type;
-            type->hint = TypeInfo::ArrayHint::String;
+            type->hint = ArrayHint::String;
         }
 
         // Prepare output argument
@@ -264,7 +283,7 @@ bool CallData::PushString16(Napi::Value value, int directions, const char16_t **
             type->align = 1;
             type->size = (int32_t)(len * 2);
             type->ref.type = instance->char16_type;
-            type->hint = TypeInfo::ArrayHint::String;
+            type->hint = ArrayHint::String;
         }
 
         // Prepare output argument
@@ -318,13 +337,44 @@ Size CallData::PushString16Value(Napi::Value value, const char16_t **out_str16)
     return (Size)len;
 }
 
-bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origin, int16_t realign)
+bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origin)
 {
     RG_ASSERT(IsObject(obj));
-    RG_ASSERT(type->primitive == PrimitiveKind::Record);
+    RG_ASSERT(type->primitive == PrimitiveKind::Record ||
+              type->primitive == PrimitiveKind::Union);
+
+    Span<const RecordMember> members = {};
+
+    if (type->primitive == PrimitiveKind::Record) {
+        members = type->members;
+    } else if (type->primitive == PrimitiveKind::Union) {
+        if (RG_UNLIKELY(!CheckValueTag(instance, obj, &MagicUnionMarker))) {
+            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected union value", GetValueType(instance, obj));
+            return false;
+        }
+
+        MagicUnion *u = MagicUnion::Unwrap(obj);
+        const uint8_t *raw = u->GetRaw();
+
+        // Fast path: encoded value already exists, just copy!
+        if (raw) {
+            memcpy(origin, raw, type->size);
+            return true;
+        }
+
+        members.ptr = u->GetMember();
+        members.len = 1;
 
-    for (Size i = 0; i < type->members.len; i++) {
-        const RecordMember &member = type->members[i];
+        if (RG_UNLIKELY(!members.ptr)) {
+            ThrowError<Napi::Error>(env, "Cannot use ambiguous empty union");
+            return false;
+        }
+    } else {
+        RG_UNREACHABLE();
+    }
+
+    for (Size i = 0; i < members.len; i++) {
+        const RecordMember &member = members[i];
         Napi::Value value = obj.Get(member.name);
 
         if (RG_UNLIKELY(value.IsUndefined())) {
@@ -332,8 +382,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
             return false;
         }
 
-        Size offset = realign ? (i * realign) : member.offset;
-        uint8_t *dest = origin + offset;
+        uint8_t *dest = origin + member.offset;
 
         switch (member.type->primitive) {
             case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
@@ -494,14 +543,15 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
 
                 *(void **)dest = ptr;
             } break;
-            case PrimitiveKind::Record: {
+            case PrimitiveKind::Record:
+            case PrimitiveKind::Union: {
                 if (RG_UNLIKELY(!IsObject(value))) {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected object", GetValueType(instance, value));
                     return false;
                 }
 
                 Napi::Object obj2 = value.As<Napi::Object>();
-                if (!PushObject(obj2, member.type, dest, realign))
+                if (!PushObject(obj2, member.type, dest))
                     return false;
             } break;
             case PrimitiveKind::Array: {
@@ -509,14 +559,14 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
                     Napi::Array array = value.As<Napi::Array>();
                     Size len = (Size)member.type->size / member.type->ref.type->size;
 
-                    if (!PushNormalArray(array, len, member.type, dest, realign))
+                    if (!PushNormalArray(array, len, member.type, dest))
                         return false;
                 } else if (IsRawBuffer(value)) {
                     Span<const uint8_t> buffer = GetRawBuffer(value);
 
-                    if (!PushBuffer(buffer, member.type->size, member.type, dest, realign))
+                    if (!PushBuffer(buffer, member.type->size, member.type, dest))
                         return false;
-                } else if (value.IsString() && !realign) {
+                } else if (value.IsString()) {
                     if (!PushStringArray(value, member.type, dest))
                         return false;
                 } else {
@@ -571,7 +621,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
     return true;
 }
 
-bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *type, uint8_t *origin, int16_t realign)
+bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *type, uint8_t *origin)
 {
     RG_ASSERT(array.IsArray());
 
@@ -589,9 +639,7 @@ bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *type
             for (Size i = 0; i < len; i++) { \
                 Napi::Value value = array[(uint32_t)i]; \
                  \
-                int16_t align = std::max(ref->align, realign); \
-                 \
-                offset = AlignLen(offset, align); \
+                offset = AlignLen(offset, ref->align); \
                 uint8_t *dest = origin + offset; \
                  \
                 if (RG_UNLIKELY(!(Check))) { \
@@ -728,10 +776,11 @@ bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *type
                 *(const void **)dest = ptr;
             });
         } break;
-        case PrimitiveKind::Record: {
+        case PrimitiveKind::Record:
+        case PrimitiveKind::Union: {
             PUSH_ARRAY(IsObject(value), "object", {
                 Napi::Object obj2 = value.As<Napi::Object>();
-                if (!PushObject(obj2, ref, dest, realign))
+                if (!PushObject(obj2, ref, dest))
                     return false;
             });
         } break;
@@ -739,8 +788,7 @@ bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *type
             for (Size i = 0; i < len; i++) {
                 Napi::Value value = array[(uint32_t)i];
 
-                int16_t align = std::max(ref->align, realign);
-                offset = AlignLen(offset, align);
+                offset = AlignLen(offset, ref->align);
 
                 uint8_t *dest = origin + offset;
 
@@ -748,14 +796,14 @@ bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *type
                     Napi::Array array2 = value.As<Napi::Array>();
                     Size len2 = (Size)ref->size / ref->ref.type->size;
 
-                    if (!PushNormalArray(array2, len2, ref, dest, realign))
+                    if (!PushNormalArray(array2, len2, ref, dest))
                         return false;
                 } else if (IsRawBuffer(value)) {
                     Span<const uint8_t> buffer = GetRawBuffer(value);
 
-                    if (!PushBuffer(buffer, ref->size, ref, dest, realign))
+                    if (!PushBuffer(buffer, ref->size, ref, dest))
                         return false;
-                } else if (value.IsString() && !realign) {
+                } else if (value.IsString()) {
                     if (!PushStringArray(value, ref, dest))
                         return false;
                 } else {
@@ -782,8 +830,7 @@ bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *type
             for (Size i = 0; i < len; i++) {
                 Napi::Value value = array[(uint32_t)i];
 
-                int16_t align = std::max(ref->align, realign);
-                offset = AlignLen(offset, align);
+                offset = AlignLen(offset, ref->align);
 
                 uint8_t *dest = origin + offset;
 
@@ -819,30 +866,40 @@ bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *type
     return true;
 }
 
-bool CallData::PushBuffer(Span<const uint8_t> buffer, Size size, const TypeInfo *type, uint8_t *origin, int16_t realign)
+bool CallData::PushBuffer(Span<const uint8_t> buffer, Size size, const TypeInfo *type, uint8_t *origin)
 {
     if (RG_UNLIKELY(buffer.len != size)) {
         ThrowError<Napi::Error>(env, "Expected array or buffer of size %1, got %2", size, buffer.len);
         return false;
     }
 
-    if (realign) {
-        Size offset = 0;
-        Size step = type->ref.type->size;
+    // Go fast yeaaaah :)
+    memcpy_safe(origin, buffer.ptr, (size_t)buffer.len);
 
-        for (Size i = 0; i < buffer.len; i += step) {
-            offset = AlignLen(offset, realign);
+#define SWAP(CType) \
+        do { \
+            CType *data = (CType *)origin; \
+            Size len = buffer.len / RG_SIZE(CType); \
+             \
+            for (Size i = 0; i < len; i++) { \
+                data[i] = ReverseBytes(data[i]); \
+            } \
+        } while (false)
 
-            uint8_t *dest = origin + offset;
-            const uint8_t *src = buffer.ptr + i;
+    if (type->primitive == PrimitiveKind::Array || type->primitive == PrimitiveKind::Pointer) {
+        const TypeInfo *ref = type->ref.type;
 
-            memcpy(dest, src, step);
-            offset += step;
+        if (ref->primitive == PrimitiveKind::Int16S || ref->primitive == PrimitiveKind::UInt16S) {
+            SWAP(uint16_t);
+        } else if (ref->primitive == PrimitiveKind::Int32S || ref->primitive == PrimitiveKind::UInt32S) {
+            SWAP(uint32_t);
+        } else if (ref->primitive == PrimitiveKind::Int64S || ref->primitive == PrimitiveKind::UInt64S) {
+            SWAP(uint64_t);
         }
-    } else {
-        memcpy_safe(origin, buffer.ptr, (size_t)buffer.len);
     }
 
+#undef SWAP
+
     return true;
 }
 
@@ -941,7 +998,8 @@ bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directio
                     ptr = buffer.ptr;
                     directions = 1;
                 }
-            } else if (RG_LIKELY(type->ref.type->primitive == PrimitiveKind::Record)) {
+            } else if (RG_LIKELY(type->ref.type->primitive == PrimitiveKind::Record ||
+                                 type->ref.type->primitive == PrimitiveKind::Union)) {
                 if (RG_UNLIKELY(!type->ref.type->size)) {
                     ThrowError<Napi::TypeError>(env, "Cannot pass %1 value to void *, use koffi.as()",
                                                 type->ref.type != instance->void_type ? "opaque" : "ambiguous");
@@ -957,6 +1015,12 @@ bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directio
                     if (!PushObject(obj, type->ref.type, ptr))
                         return false;
                 } else {
+                    if (RG_UNLIKELY(type->ref.type->primitive == PrimitiveKind::Union &&
+                                    !CheckValueTag(instance, obj, &MagicUnionMarker))) {
+                        ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected union value", GetValueType(instance, obj));
+                        return false;
+                    }
+
                     memset_safe(ptr, 0, type->size);
                 }
             } else {
@@ -1008,8 +1072,14 @@ void CallData::PopOutArguments()
             Span<uint8_t> buffer = GetRawBuffer(value);
             DecodeBuffer(buffer, out.ptr, out.type);
         } else {
-            Napi::Object obj(env, value);
-            DecodeObject(obj, out.ptr, out.type);
+            Napi::Object obj = value.As<Napi::Object>();
+
+            if (CheckValueTag(instance, value, &MagicUnionMarker)) {
+                MagicUnion *u = MagicUnion::Unwrap(obj);
+                u->SetRaw(out.ptr);
+            } else {
+                DecodeObject(obj, out.ptr, out.type);
+            }
         }
     }
 }

package/src/koffi/src/call.hh

@@ -69,6 +69,8 @@ public:
     CallData(Napi::Env env, InstanceData *instance, InstanceMemory *mem);
     ~CallData();
 
+    void Dispose();
+
 #ifdef UNITY_BUILD
     #ifdef _MSC_VER
         #define INLINE_IF_UNITY __forceinline
@@ -86,7 +88,7 @@ public:
 #undef INLINE_IF_UNITY
 
     void Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async, BackRegisters *out_reg);
-    void RelaySafe(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg);
+    void RelaySafe(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool dispose_call, BackRegisters *out_reg);
     static void RelayAsync(napi_env, napi_value, void *, void *udata);
 
     void DumpForward(const FunctionInfo *func) const;
@@ -101,9 +103,9 @@ private:
     Size PushStringValue(Napi::Value value, const char **out_str);
     bool PushString16(Napi::Value value, int directions, const char16_t **out_str16);
     Size PushString16Value(Napi::Value value, const char16_t **out_str16);
-    bool PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origin, int16_t realign = 0);
-    bool PushNormalArray(Napi::Array array, Size len, const TypeInfo *type, uint8_t *origin, int16_t realign = 0);
-    bool PushBuffer(Span<const uint8_t> buffer, Size size, const TypeInfo *type, uint8_t *origin, int16_t realign = 0);
+    bool PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origin);
+    bool PushNormalArray(Napi::Array array, Size len, const TypeInfo *type, uint8_t *origin);
+    bool PushBuffer(Span<const uint8_t> buffer, Size size, const TypeInfo *type, uint8_t *origin);
     bool PushStringArray(Napi::Value value, const TypeInfo *type, uint8_t *origin);
     bool PushPointer(Napi::Value value, const TypeInfo *type, int directions, void **out_ptr);