koffi 2.3.4 → 2.3.6-beta.1

package/src/koffi/src/abi_arm64.cc

@@ -25,6 +25,11 @@
 
 namespace RG {
 
+struct HfaInfo {
+    int count;
+    bool float32;
+};
+
 struct X0X1Ret {
     uint64_t x0;
     uint64_t x1;
@@ -59,15 +64,61 @@ extern "C" napi_value CallSwitchStack(Napi::Function *func, size_t argc, napi_va
 
 #include "abi_trampolines.inc"
 
-static inline int IsHFA(const TypeInfo *type)
+static HfaInfo IsHFA(const TypeInfo *type)
+{
+    bool float32 = false;
+    bool float64 = false;
+    int count = 0;
+
+    count = AnalyseFlat(type, [&](const TypeInfo *type, int, int) {
+        if (type->primitive == PrimitiveKind::Float32) {
+            float32 = true;
+        } else if (type->primitive == PrimitiveKind::Float64) {
+            float64 = true;
+        } else {
+            float32 = true;
+            float64 = true;
+        }
+    });
+
+    HfaInfo info = {};
+
+    if (count < 1 || count > 4)
+        return info;
+    if (float32 && float64)
+        return info;
+
+    info.count = count;
+    info.float32 = float32;
+
+    return info;
+}
+
+static inline void ExpandFloats(uint8_t *ptr, Size len, Size bytes)
+{
+    for (Size i = len - 1; i >= 0; i--) {
+        const uint8_t *src = ptr + i * bytes;
+        uint8_t *dest = ptr + i * 8;
+
+        memmove(dest, src, bytes);
+    }
+}
+
+static inline void CompactFloats(uint8_t *ptr, Size len, Size bytes)
 {
-    return IsHFA(type, 1, 4);
+    for (Size i = 0; i < len; i++) {
+        const uint8_t *src = ptr + i * 8;
+        uint8_t *dest = ptr + i * bytes;
+
+        memmove(dest, src, bytes);
+    }
 }
 
 bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
 {
-    if (int hfa = IsHFA(func->ret.type); hfa) {
-        func->ret.vec_count = (int8_t)hfa;
+    if (HfaInfo hfa = IsHFA(func->ret.type); hfa.count) {
+        func->ret.vec_count = (int8_t)hfa.count;
+        func->ret.vec_bytes = hfa.float32 ? 4 : 8;
     } else if (func->ret.type->size <= 16) {
         func->ret.gpr_count = (int8_t)((func->ret.type->size + 7) / 8);
     } else {
@@ -115,8 +166,9 @@ bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
                     gpr_avail--;
                 }
             } break;
-            case PrimitiveKind::Record: {
-                int hfa = IsHFA(param.type);
+            case PrimitiveKind::Record:
+            case PrimitiveKind::Union: {
+                HfaInfo hfa = IsHFA(param.type);
 
 #ifdef _M_ARM64EC
                 if (func->variadic) {
@@ -137,7 +189,7 @@ bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
 
 #if defined(_WIN32)
                 if (param.variadic) {
-                    hfa = 0;
+                    hfa.count = 0;
                 }
 #elif defined(__APPLE__)
                 if (param.variadic) {
@@ -146,10 +198,11 @@ bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
                 }
 #endif
 
-                if (hfa) {
-                    if (hfa <= vec_avail) {
-                        param.vec_count = (int8_t)hfa;
-                        vec_avail -= hfa;
+                if (hfa.count) {
+                    if (hfa.count <= vec_avail) {
+                        param.vec_count = (int8_t)hfa.count;
+                        param.vec_bytes = hfa.float32 ? 4 : 8;
+                        vec_avail -= hfa.count;
                     } else {
                         vec_avail = 0;
                     }
@@ -364,7 +417,8 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
 #endif
                 *(void **)((param.gpr_count ? gpr_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;
@@ -373,8 +427,12 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
                 Napi::Object obj = value.As<Napi::Object>();
 
                 if (param.vec_count) { // HFA
-                    if (!PushObject(obj, param.type, (uint8_t *)vec_ptr, 8))
+                    uint8_t *ptr = (uint8_t *)vec_ptr;
+
+                    if (!PushObject(obj, param.type, ptr))
                         return false;
+                    ExpandFloats(ptr, param.vec_count, param.vec_bytes);
+
                     vec_ptr += param.vec_count;
                 } else if (!param.use_memory) {
                     if (param.gpr_count) {
@@ -544,7 +602,8 @@ void CallData::Execute(const FunctionInfo *func)
         case PrimitiveKind::String16:
         case PrimitiveKind::Pointer:
         case PrimitiveKind::Callback: { result.u64 = PERFORM_CALL(GG).x0; } break;
-        case PrimitiveKind::Record: {
+        case PrimitiveKind::Record:
+        case PrimitiveKind::Union: {
             if (func->ret.gpr_count) {
                 X0X1Ret ret = PERFORM_CALL(GG);
                 memcpy(&result.buf, &ret, RG_SIZE(ret));
@@ -605,9 +664,14 @@ Napi::Value CallData::Complete(const FunctionInfo *func)
                 return env.Null();
             }
         } break;
-        case PrimitiveKind::Record: {
+        case PrimitiveKind::Record:
+        case PrimitiveKind::Union: {
             if (func->ret.vec_count) { // HFA
-                Napi::Object obj = DecodeObject(env, (const uint8_t *)&result.buf, func->ret.type, 8);
+                uint8_t *ptr = (uint8_t *)&result.buf;
+
+                CompactFloats(ptr, func->ret.vec_count, func->ret.vec_bytes);
+
+                Napi::Object obj = DecodeObject(env, ptr, func->ret.type);
                 return obj;
             } else {
                 const uint8_t *ptr = return_ptr ? (const uint8_t *)return_ptr
@@ -973,9 +1037,14 @@ 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: {
                 if (param.vec_count) { // HFA
-                    Napi::Object obj = DecodeObject(env, (uint8_t *)vec_ptr, param.type, 8);
+                    uint8_t *ptr = (uint8_t *)vec_ptr;
+
+                    CompactFloats(ptr, param.vec_count, param.vec_bytes);
+
+                    Napi::Object obj = DecodeObject(env, ptr, param.type);
                     arguments.Append(obj);
 
                     vec_ptr += param.vec_count;
@@ -1133,7 +1202,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);
@@ -1149,7 +1219,8 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
 
             out_reg->x0 = (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;
@@ -1162,7 +1233,10 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
                     return;
                 out_reg->x0 = (uint64_t)return_ptr;
             } else if (proto->ret.vec_count) { // HFA
-                PushObject(obj, type, (uint8_t *)&out_reg->d0, 8);
+                uint8_t *ptr = (uint8_t *)&out_reg->d0;
+
+                ExpandFloats(ptr, proto->ret.vec_count, proto->ret.vec_bytes);
+                PushObject(obj, type, ptr);
             } else {
                 PushObject(obj, type, (uint8_t *)&out_reg->x0);
             }

package/src/koffi/src/abi_riscv64.cc

@@ -64,11 +64,21 @@ extern "C" napi_value CallSwitchStack(Napi::Function *func, size_t argc, napi_va
 
 #include "abi_trampolines.inc"
 
-static void AnalyseParameter(ParameterInfo *param, int gpr_avail, int vec_avail)
+static inline void ExpandPair(const uint8_t raw[16], int size1, int size2, uint64_t out_regs[2])
 {
-    gpr_avail = std::min(2, gpr_avail);
-    vec_avail = std::min(2, vec_avail);
+    memcpy(out_regs + 0, raw, size1);
+    memcpy(out_regs + 1, raw + size1, size2);
+}
 
+static inline void CompactPair(const uint64_t regs[2], int size1, int size2, uint8_t out_raw[16])
+{
+    memcpy(out_raw, regs + 0, size1);
+    memcpy(out_raw + size1, regs + 1, size2);
+}
+
+static void AnalyseParameter(ParameterInfo *param, int gpr_avail, int vec_avail)
+{
+    // Too big, pass pointer to struct
     if (param->type->size > 16) {
         param->gpr_count = gpr_avail ? 1 : 0;
         param->use_memory = true;
@@ -76,36 +86,55 @@ static void AnalyseParameter(ParameterInfo *param, int gpr_avail, int vec_avail)
         return;
     }
 
-    int gpr_count = 0;
-    int vec_count = 0;
-    bool gpr_first = false;
+    gpr_avail = std::min(2, gpr_avail);
+    vec_avail = std::min(2, vec_avail);
 
-    AnalyseFlat(param->type, [&](const TypeInfo *type, int offset, int count) {
 #if defined(__riscv_float_abi_double)
-        bool fp = IsFloat(type);
+    if (param->type->primitive != PrimitiveKind::Union) {
+        int gpr_count = 0;
+        int vec_count = 0;
+        bool gpr_first = false;
+
+        AnalyseFlat(param->type, [&](const TypeInfo *type, int offset, int count) {
+            if (IsFloat(type)) {
+                vec_count += count;
+            } else {
+                gpr_count += count;
+                gpr_first |= !vec_count;
+            }
+
+            // We'll reset reg_size if the following conditions don't match,
+            // such as having more than two values.
+            param->reg_size[offset % 2] = (int8_t)type->size;
+        });
+
+        // Pass mixed float-integer structs in one GPR and one FP register
+        if (gpr_count == 1 && vec_count == 1 && gpr_avail && vec_avail) {
+            param->gpr_count = 1;
+            param->vec_count = 1;
+            param->gpr_first = gpr_first;
+
+            return;
+        }
+
+        // HFA rules
+        if (vec_count && !gpr_count && vec_count <= vec_avail) {
+            param->vec_count = vec_count;
+            return;
+        }
+    }
 #elif defined(__riscv_float_abi_soft)
-        bool fp = false;
+    // Use integer conventions
 #else
-        #error The RISC-V single-precision float ABI (LP64F) is not supported
+    #error The RISC-V single-precision float ABI (LP64F) is not supported
 #endif
 
-        if (fp) {
-            vec_count += count;
-        } else {
-            gpr_count += count;
-            gpr_first |= !vec_count;
-        }
-    });
-
-    if (gpr_count == 1 && vec_count == 1 && gpr_avail && vec_avail) {
-        param->gpr_count = 1;
-        param->vec_count = 1;
-        param->gpr_first = gpr_first;
-    } else if (vec_count && !gpr_count && vec_count <= vec_avail) {
-        param->vec_count = vec_count;
-    } else if (gpr_avail) {
-        param->gpr_count = (param->type->size + 7) / 8;
-        param->gpr_first = true;
+    param->reg_size[0] = 8;
+    param->reg_size[1] = 8;
+
+    if (gpr_avail) {
+        param->gpr_count = std::min(gpr_avail, (param->type->size + 7) / 8);
+        param->gpr_first = param->gpr_count;
     }
 }
 
@@ -222,7 +251,8 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
 
                 *(void **)((param.gpr_count ? gpr_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;
@@ -233,25 +263,34 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
                 if (!param.use_memory) {
                     RG_ASSERT(param.type->size <= 16);
 
-                    // Split float or mixed int-float structs to registers
-                    int realign = param.vec_count ? 8 : 0;
-
-                    uint64_t buf[2] = { 0xFFFFFFFFFFFFFFFFull, 0xFFFFFFFFFFFFFFFFull };
-                    if (!PushObject(obj, param.type, (uint8_t *)buf, realign))
-                        return false;
-                    uint64_t *ptr = buf;
+                    uint64_t regs[2] = { 0xFFFFFFFFFFFFFFFFull, 0xFFFFFFFFFFFFFFFFull };
+                    {
+                        uint8_t buf[16] = {};
+                        if (!PushObject(obj, param.type, buf))
+                            return false;
+                        ExpandPair(buf, param.reg_size[0], param.reg_size[1], regs);
+                    }
 
                     if (param.gpr_first) {
-                        *(gpr_ptr++) = *(ptr++);
-                        *((param.vec_count ? vec_ptr : gpr_ptr)++) = *(ptr++);
-                        gpr_ptr -= (param.gpr_count == 1);
+                        *(gpr_ptr++) = regs[0];
+                        if (param.gpr_count == 2) {
+                            *(gpr_ptr++) = regs[1];
+                        } else if (param.vec_count == 1) {
+                            *(vec_ptr++) = regs[1];
+                        }
+
+                        args_ptr = std::max(gpr_ptr, args_ptr);
                     } else if (param.vec_count) {
-                        *(vec_ptr++) = *(ptr++);
-                        *((param.gpr_count ? gpr_ptr : vec_ptr)++) = *(ptr++);
+                        *(vec_ptr++) = regs[0];
+                        if (param.vec_count == 2) {
+                            *(vec_ptr++) = regs[1];
+                        } else if (param.gpr_count == 1) {
+                            *(gpr_ptr++) = regs[1];
+                        }
                     } else {
                         RG_ASSERT(param.type->align <= 8);
 
-                        memcpy_safe(args_ptr, ptr, param.type->size);
+                        memcpy_safe(args_ptr, regs, param.type->size);
                         args_ptr += (param.type->size + 7) / 8;
                     }
                 } else {
@@ -370,7 +409,8 @@ void CallData::Execute(const FunctionInfo *func)
         case PrimitiveKind::String16:
         case PrimitiveKind::Pointer:
         case PrimitiveKind::Callback: { result.u64 = PERFORM_CALL(GG).a0; } break;
-        case PrimitiveKind::Record: {
+        case PrimitiveKind::Record:
+        case PrimitiveKind::Union: {
             if (func->ret.gpr_first && !func->ret.vec_count) {
                 A0A1Ret ret = PERFORM_CALL(GG);
                 memcpy(&result.buf, &ret, RG_SIZE(ret));
@@ -435,15 +475,16 @@ Napi::Value CallData::Complete(const FunctionInfo *func)
                 return env.Null();
             }
         } break;
-        case PrimitiveKind::Record: {
-            if (func->ret.vec_count) { // HFA
-                Napi::Object obj = DecodeObject(env, (const uint8_t *)&result.buf, func->ret.type, 8);
+        case PrimitiveKind::Record:
+        case PrimitiveKind::Union: {
+            if (return_ptr) {
+                Napi::Object obj = DecodeObject(env, return_ptr, func->ret.type);
                 return obj;
             } else {
-                const uint8_t *ptr = return_ptr ? (const uint8_t *)return_ptr
-                                                : (const uint8_t *)&result.buf;
+                uint8_t buf[16] = {};
+                CompactPair(&result.u64, func->ret.reg_size[0], func->ret.reg_size[1], buf);
 
-                Napi::Object obj = DecodeObject(env, ptr, func->ret.type);
+                Napi::Object obj = DecodeObject(env, buf, func->ret.type);
                 return obj;
             }
         } break;
@@ -624,29 +665,29 @@ 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: {
                 if (!param.use_memory) {
-                    uint64_t buf[2] = {};
-                    uint64_t *ptr = buf;
+                    uint64_t regs[2] = {};
 
                     if (param.gpr_first) {
-                        *(ptr++) = *(gpr_ptr++);
-                        *(ptr++) = *((param.vec_count ? vec_ptr : gpr_ptr)++);
+                        regs[0] = *(gpr_ptr++);
+                        regs[1] = *((param.vec_count ? vec_ptr : gpr_ptr)++);
                         gpr_ptr -= (param.gpr_count == 1);
                     } else if (param.vec_count) {
-                        *(ptr++) = *(vec_ptr++);
-                        *(ptr++) = *((param.gpr_count ? gpr_ptr : vec_ptr)++);
+                        regs[0] = *(vec_ptr++);
+                        regs[1] = *((param.gpr_count ? gpr_ptr : vec_ptr)++);
                     } else {
                         RG_ASSERT(param.type->align <= 8);
 
-                        memcpy_safe(ptr, args_ptr, param.type->size);
+                        memcpy_safe(regs, args_ptr, param.type->size);
                         args_ptr += (param.type->size + 7) / 8;
                     }
 
-                    // Reassemble float or mixed int-float structs from registers
-                    int realign = param.vec_count ? 8 : 0;
+                    uint8_t buf[16] = {};
+                    CompactPair(regs, param.reg_size[0], param.reg_size[1], buf);
 
-                    Napi::Object obj = DecodeObject(env, (const uint8_t *)buf, param.type, realign);
+                    Napi::Object obj = DecodeObject(env, buf, param.type);
                     arguments.Append(obj);
                 } else {
                     uint8_t *ptr = *(uint8_t **)((param.gpr_count ? gpr_ptr : args_ptr)++);
@@ -768,7 +809,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);
@@ -784,7 +826,8 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
 
             out_reg->a0 = (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;
@@ -796,10 +839,28 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
                 if (!PushObject(obj, type, return_ptr))
                     return;
                 out_reg->a0 = (uint64_t)return_ptr;
-            } else if (proto->ret.vec_count) { // HFA
-                PushObject(obj, type, (uint8_t *)&out_reg->fa0, 8);
             } else {
-                PushObject(obj, type, (uint8_t *)&out_reg->a0);
+                uint64_t regs[2] = { 0xFFFFFFFFFFFFFFFFull, 0xFFFFFFFFFFFFFFFFull };
+                {
+                    uint8_t buf[16] = {};
+                    if (!PushObject(obj, type, buf))
+                        return;
+                    ExpandPair(buf, proto->ret.reg_size[0], proto->ret.reg_size[1], regs);
+                }
+
+                if (proto->ret.gpr_first && !proto->ret.vec_count) {
+                    out_reg->a0 = regs[0];
+                    out_reg->a1 = regs[1];
+                } else if (proto->ret.gpr_first) {
+                    out_reg->a0 = regs[0];
+                    out_reg->fa0 = *(double *)&regs[1];
+                } else if (proto->ret.vec_count == 2) {
+                    out_reg->fa0 = *(double *)&regs[0];
+                    out_reg->fa1 = *(double *)&regs[1];
+                } else {
+                    out_reg->fa0 = *(double *)&regs[0];
+                    out_reg->a0 = regs[1];
+                }
             }
         } break;
         case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;

package/src/koffi/src/abi_x64_sysv.cc

@@ -132,6 +132,20 @@ static Size ClassifyType(const TypeInfo *type, Size offset, Span<RegisterClass>
 
             return (offset + 7) / 8;
         } break;
+        case PrimitiveKind::Union: {
+            if (type->size > 64) {
+                classes[0] = MergeClasses(classes[0], RegisterClass::Memory);
+                return 1;
+            }
+
+            for (const RecordMember &member: type->members) {
+                Size start = offset / 8;
+                ClassifyType(member.type, offset % 8, classes.Take(start, classes.len - start));
+            }
+            offset += type->size;
+
+            return (offset + 7) / 8;
+        } break;
         case PrimitiveKind::Array: {
             if (type->size > 64) {
                 classes[0] = MergeClasses(classes[0], RegisterClass::Memory);
@@ -310,7 +324,8 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
 
                 *(void **)((param.gpr_count ? gpr_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;
@@ -324,21 +339,20 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
                     uint64_t buf[2] = {};
                     if (!PushObject(obj, param.type, (uint8_t *)buf))
                         return false;
-                    uint64_t *ptr = buf;
 
                     if (param.gpr_first) {
-                        *(gpr_ptr++) = *(ptr++);
+                        *(gpr_ptr++) = buf[0];
                         if (param.gpr_count == 2) {
-                            *(gpr_ptr++) = *(ptr++);
+                            *(gpr_ptr++) = buf[1];
                         } else if (param.xmm_count == 1) {
-                            *(xmm_ptr++) = *(ptr++);
+                            *(xmm_ptr++) = buf[1];
                         }
                     } else {
-                        *(xmm_ptr++) = *(ptr++);
+                        *(xmm_ptr++) = buf[0];
                         if (param.xmm_count == 2) {
-                            *(xmm_ptr++) = *(ptr++);
+                            *(xmm_ptr++) = buf[1];
                         } else if (param.gpr_count == 1) {
-                            *(gpr_ptr++) = *(ptr++);
+                            *(gpr_ptr++) = buf[1];
                         }
                     }
                 } else if (param.use_memory) {
@@ -434,7 +448,8 @@ void CallData::Execute(const FunctionInfo *func)
         case PrimitiveKind::String16:
         case PrimitiveKind::Pointer:
         case PrimitiveKind::Callback: { result.u64 = PERFORM_CALL(GG).rax; } break;
-        case PrimitiveKind::Record: {
+        case PrimitiveKind::Record:
+        case PrimitiveKind::Union: {
             if (func->ret.gpr_first && !func->ret.xmm_count) {
                 RaxRdxRet ret = PERFORM_CALL(GG);
                 memcpy(&result.buf, &ret, RG_SIZE(ret));
@@ -499,7 +514,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;
 
@@ -683,26 +699,26 @@ 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: {
                 if (param.gpr_count || param.xmm_count) {
                     RG_ASSERT(param.type->size <= 16);
 
                     uint64_t buf[2] = {};
-                    uint64_t *ptr = buf;
 
                     if (param.gpr_first) {
-                        *(ptr++) = *(gpr_ptr++);
+                        buf[0] = *(gpr_ptr++);
                         if (param.gpr_count == 2) {
-                            *(ptr++) = *(gpr_ptr++);
+                            buf[1] = *(gpr_ptr++);
                         } else if (param.xmm_count == 1) {
-                            *(ptr++) = *(xmm_ptr++);
+                            buf[1] = *(xmm_ptr++);
                         }
                     } else {
-                        *(ptr++) = *(xmm_ptr++);
+                        buf[0] = *(xmm_ptr++);
                         if (param.xmm_count == 2) {
-                            *(ptr++) = *(xmm_ptr++);
+                            buf[1] = *(xmm_ptr++);
                         } else if (param.gpr_count == 1) {
-                            *(ptr++) = *(gpr_ptr++);
+                            buf[1] = *(gpr_ptr++);
                         }
                     }
 
@@ -816,7 +832,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);
@@ -832,7 +849,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;