koffi 2.3.4 → 2.3.5

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;

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;