koffi 3.0.2 → 3.1.0

package/src/koffi/src/abi/riscv64.cc

@@ -626,13 +626,8 @@ namespace {
     OP(PushAggregateReg) {
         napi_value arg = args[inst->a];
 
-        if (!IsObject(call->env, arg)) [[unlikely]] {
-            ThrowError<Napi::TypeError>(call->env, "Unexpected %1 value, expected object", GetValueType(call->instance, arg));
-            return call->env.Null();
-        }
-
         uint64_t buf[2] = {};
-        if (!call->PushObject(arg, inst->type, (uint8_t *)buf))
+        if (!call->PushObject(arg, inst->type, (uint8_t *)buf)) [[unlikely]]
             return call->env.Null();
 
         // The second part might be useless (if object fits in one register), in
@@ -647,15 +642,10 @@ namespace {
     OP(PushAggregateMem) {
         napi_value arg = args[inst->a];
 
-        if (!IsObject(call->env, arg)) [[unlikely]] {
-            ThrowError<Napi::TypeError>(call->env, "Unexpected %1 value, expected object", GetValueType(call->instance, arg));
-            return call->env.Null();
-        }
-
         uint8_t *ptr = call->AllocHeap(inst->type->size);
         *(uint8_t **)(base + inst->b1) = ptr;
 
-        if (!call->PushObject(arg, inst->type, ptr))
+        if (!call->PushObject(arg, inst->type, ptr)) [[unlikely]]
             return call->env.Null();
 
         NEXT();
@@ -679,7 +669,7 @@ namespace {
 #define DISPOSE(Ptr) \
         do { \
             if (inst->type->dispose) { \
-                inst->type->dispose(call->env, inst->type, (Ptr)); \
+                inst->type->dispose(call->instance, inst->type, (Ptr)); \
             } \
         } while (false)
 
@@ -707,42 +697,42 @@ namespace {
     OP(RunUInt64S) { INTEGER_SWAP(GG, uint64_t); }
     OP(RunString) {
         uint64_t a0 = WRAP(ForwardCallGG(call->native, base, &call->saved_sp).a0);
-        napi_value value = a0 ? Napi::String::New(call->env, (const char *)a0) : call->env.Null();
+        napi_value value = NewString(call->env, (const char *)a0);
         DISPOSE((void *)a0);
         return value;
     }
     OP(RunString16) {
         uint64_t a0 = WRAP(ForwardCallGG(call->native, base, &call->saved_sp).a0);
-        napi_value value = a0 ? Napi::String::New(call->env, (const char16_t *)a0) : call->env.Null();
+        napi_value value = NewString(call->env, (const char16_t *)a0);
         DISPOSE((void *)a0);
         return value;
     }
     OP(RunString32) {
         uint64_t a0 = WRAP(ForwardCallGG(call->native, base, &call->saved_sp).a0);
-        napi_value value = a0 ? MakeStringFromUTF32(call->env, (const char32_t *)a0) : call->env.Null();
+        napi_value value = NewString(call->env, (const char32_t *)a0);
         DISPOSE((void *)a0);
         return value;
     }
     OP(RunPointer) {
         uint64_t a0 = WRAP(ForwardCallGG(call->native, base, &call->saved_sp).a0);
-        napi_value value = a0 ? WrapPointer(call->env, inst->type, (void *)a0) : call->env.Null();
+        napi_value value = WrapPointer(call->env, inst->type, (void *)a0);
         DISPOSE((void *)a0);
         return value;
     }
     OP(RunCallback) {
         uint64_t a0 = WRAP(ForwardCallGG(call->native, base, &call->saved_sp).a0);
-        return a0 ? WrapPointer(call->env, inst->type, (void *)a0) : call->env.Null();
+        return WrapPointer(call->env, inst->type, (void *)a0);
     }
     OP(RunRecord) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunUnion) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunArray) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunFloat32) {
         float f = WRAP(ForwardCallF(call->native, base, &call->saved_sp));
-        return Napi::Number::New(call->env, (double)f);
+        return NewFloat(call->env, f);
     }
     OP(RunFloat64) {
         double d = WRAP(ForwardCallDD(call->native, base, &call->saved_sp).fa0);
-        return Napi::Number::New(call->env, d);
+        return NewFloat(call->env, d);
     }
     OP(RunPrototype) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunAggregateGG) {
@@ -791,42 +781,42 @@ namespace {
     OP(RunUInt64SX) { INTEGER_SWAP(GGX, uint64_t); }
     OP(RunStringX) {
         uint64_t a0 = WRAP(ForwardCallGGX(call->native, base, &call->saved_sp).a0);
-        napi_value value = a0 ? Napi::String::New(call->env, (const char *)a0) : call->env.Null();
+        napi_value value = NewString(call->env, (const char *)a0);
         DISPOSE((void *)a0);
         return value;
     }
     OP(RunString16X) {
         uint64_t a0 = WRAP(ForwardCallGGX(call->native, base, &call->saved_sp).a0);
-        napi_value value = a0 ? Napi::String::New(call->env, (const char16_t *)a0) : call->env.Null();
+        napi_value value = NewString(call->env, (const char16_t *)a0);
         DISPOSE((void *)a0);
         return value;
     }
     OP(RunString32X) {
         uint64_t a0 = WRAP(ForwardCallGGX(call->native, base, &call->saved_sp).a0);
-        napi_value value = a0 ? MakeStringFromUTF32(call->env, (const char32_t *)a0) : call->env.Null();
+        napi_value value = NewString(call->env, (const char32_t *)a0);
         DISPOSE((void *)a0);
         return value;
     }
     OP(RunPointerX) {
         uint64_t a0 = WRAP(ForwardCallGGX(call->native, base, &call->saved_sp).a0);
-        napi_value value = a0 ? WrapPointer(call->env, inst->type, (void *)a0) : call->env.Null();
+        napi_value value = WrapPointer(call->env, inst->type, (void *)a0);
         DISPOSE((void *)a0);
         return value;
     }
     OP(RunCallbackX) {
         uint64_t a0 = WRAP(ForwardCallGGX(call->native, base, &call->saved_sp).a0);
-        return a0 ? WrapPointer(call->env, inst->type, (void *)a0) : call->env.Null();
+        return WrapPointer(call->env, inst->type, (void *)a0);
     }
     OP(RunRecordX) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunUnionX) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunArrayX) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunFloat32X) {
         float f = WRAP(ForwardCallFX(call->native, base, &call->saved_sp));
-        return Napi::Number::New(call->env, (double)f);
+        return NewFloat(call->env, f);
     }
     OP(RunFloat64X) {
         double d = WRAP(ForwardCallDDX(call->native, base, &call->saved_sp).fa0);
-        return Napi::Number::New(call->env, d);
+        return NewFloat(call->env, d);
     }
     OP(RunPrototypeX) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunAggregateGGX) {
@@ -865,7 +855,7 @@ namespace {
         do { \
             if (inst->type->dispose) { \
                 void *ptr = *(void **)base; \
-                inst->type->dispose(call->env, inst->type, ptr); \
+                inst->type->dispose(call->instance, inst->type, ptr); \
             } \
         } while (false)
 #define INTEGER(CType) \
@@ -928,42 +918,42 @@ namespace {
     OP(ReturnUInt64S) { INTEGER_SWAP(uint64_t); }
     OP(ReturnString) {
         uint64_t a0 = *(uint64_t *)base;
-        napi_value value = a0 ? Napi::String::New(call->env, (const char *)a0) : call->env.Null();
+        napi_value value = NewString(call->env, (const char *)a0);
         DISPOSE();
         return value;
     }
     OP(ReturnString16) {
         uint64_t a0 = *(uint64_t *)base;
-        napi_value value = a0 ? Napi::String::New(call->env, (const char16_t *)a0) : call->env.Null();
+        napi_value value = NewString(call->env, (const char16_t *)a0);
         DISPOSE();
         return value;
     }
     OP(ReturnString32) {
         uint64_t a0 = *(uint64_t *)base;
-        napi_value value = a0 ? MakeStringFromUTF32(call->env, (const char32_t *)a0) : call->env.Null();
+        napi_value value = NewString(call->env, (const char32_t *)a0);
         DISPOSE();
         return value;
     }
     OP(ReturnPointer) {
         uint64_t a0 = *(uint64_t *)base;
-        napi_value value = a0 ? WrapPointer(call->env, inst->type, (void *)a0) : call->env.Null();
+        napi_value value = WrapPointer(call->env, inst->type, (void *)a0);
         DISPOSE();
         return value;
     }
     OP(ReturnCallback) {
         uint64_t a0 = *(uint64_t *)base;
-        return a0 ? WrapPointer(call->env, inst->type, (void *)a0) : call->env.Null();
+        return WrapPointer(call->env, inst->type, (void *)a0);
     }
     OP(ReturnRecord) { K_UNREACHABLE(); return call->env.Null(); }
     OP(ReturnUnion) { K_UNREACHABLE(); return call->env.Null(); }
     OP(ReturnArray) { K_UNREACHABLE(); return call->env.Null(); }
     OP(ReturnFloat32) {
         float f = *(float *)base;
-        return Napi::Number::New(call->env, (double)f);
+        return NewFloat(call->env, f);
     }
     OP(ReturnFloat64) {
         double d = *(double *)base;
-        return Napi::Number::New(call->env, d);
+        return NewFloat(call->env, d);
     }
     OP(ReturnPrototype) { K_UNREACHABLE(); return call->env.Null(); }
     OP(ReturnAggregateReg) { return DecodeObject(call->instance, (const uint8_t *)base, inst->type); }
@@ -1133,30 +1123,30 @@ void CallData::Relay(Size idx, uint8_t *sp)
                 const uint8_t *src = in_ptr + param.abi.offsets[0];
                 const char *str = *(const char **)src;
 
-                arguments[i] = str ? Napi::String::New(env, str) : env.Null();
+                arguments[i] = NewString(env, str);
 
                 if (param.type->dispose) {
-                    param.type->dispose(env, param.type, str);
+                    param.type->dispose(instance, param.type, str);
                 }
             } break;
             case PrimitiveKind::String16: {
                 const uint8_t *src = in_ptr + param.abi.offsets[0];
                 const char16_t *str16 = *(const char16_t **)src;
 
-                arguments[i] = str16 ? Napi::String::New(env, str16) : env.Null();
+                arguments[i] = NewString(env, str16);
 
                 if (param.type->dispose) {
-                    param.type->dispose(env, param.type, str16);
+                    param.type->dispose(instance, param.type, str16);
                 }
             } break;
             case PrimitiveKind::String32: {
                 const uint8_t *src = in_ptr + param.abi.offsets[0];
                 const char32_t *str32 = *(const char32_t **)src;
 
-                arguments[i] = str32 ? MakeStringFromUTF32(env, str32) : env.Null();
+                arguments[i] = NewString(env, str32);
 
                 if (param.type->dispose) {
-                    param.type->dispose(env, param.type, str32);
+                    param.type->dispose(instance, param.type, str32);
                 }
             } break;
 
@@ -1164,10 +1154,10 @@ void CallData::Relay(Size idx, uint8_t *sp)
                 const uint8_t *src = in_ptr + param.abi.offsets[0];
                 void *ptr2 = *(void **)src;
 
-                arguments[i] = ptr2 ? WrapPointer(env, param.type->ref.type, ptr2) : env.Null();
+                arguments[i] = WrapPointer(env, param.type->ref.type, ptr2);
 
                 if (param.type->dispose) {
-                    param.type->dispose(env, param.type, ptr2);
+                    param.type->dispose(instance, param.type, ptr2);
                 }
             } break;
 
@@ -1190,24 +1180,20 @@ void CallData::Relay(Size idx, uint8_t *sp)
                 const uint8_t *src = in_ptr + param.abi.offsets[0];
                 float f = *(float *)src;
 
-                arguments[i] = Napi::Number::New(env, (double)f);
+                arguments[i] = NewFloat(env, f);
             } break;
             case PrimitiveKind::Float64: {
                 const uint8_t *src = in_ptr + param.abi.offsets[0];
                 double d = *(double *)src;
 
-                arguments[i] = Napi::Number::New(env, d);
+                arguments[i] = NewFloat(env, d);
             } break;
 
             case PrimitiveKind::Callback: {
                 const uint8_t *src = in_ptr + param.abi.offsets[0];
                 void *ptr2 = *(void **)src;
 
-                arguments[i] = ptr2 ? WrapPointer(env, param.type->ref.type, ptr2) : env.Null();
-
-                if (param.type->dispose) {
-                    param.type->dispose(env, param.type, ptr2);
-                }
+                arguments[i] = WrapPointer(env, param.type->ref.type, ptr2);
             } break;
 
             case PrimitiveKind::Prototype: { K_UNREACHABLE(); } break;
@@ -1302,14 +1288,9 @@ void CallData::Relay(Size idx, uint8_t *sp)
         } break;
         case PrimitiveKind::Record:
         case PrimitiveKind::Union: {
-            if (!IsObject(env, value)) [[unlikely]] {
-                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected object", GetValueType(instance, value));
-                return;
-            }
-
             if (proto->ret.abi.method != AbiMethod::Memory) {
                 uint64_t buf[2];
-                if (!PushObject(value, type, (uint8_t *)buf))
+                if (!PushObject(value, type, (uint8_t *)buf)) [[unlikely]]
                     return;
 
                 memcpy((uint8_t *)&out_reg + proto->ret.abi.offsets[0], (const uint8_t *)buf, 8);
@@ -1318,7 +1299,7 @@ void CallData::Relay(Size idx, uint8_t *sp)
                 uint64_t *gpr_ptr = (uint64_t *)in_ptr;
                 uint8_t *dest = (uint8_t *)gpr_ptr[0]; // a0
 
-                if (!PushObject(value, type, dest))
+                if (!PushObject(value, type, dest)) [[unlikely]]
                     return;
             }
         } break;

package/src/koffi/src/abi/x64sysv.cc

@@ -684,13 +684,8 @@ namespace {
     OP(PushAggregateReg) {
         napi_value arg = args[inst->a];
 
-        if (!IsObject(call->env, arg)) [[unlikely]] {
-            ThrowError<Napi::TypeError>(call->env, "Unexpected %1 value, expected object", GetValueType(call->instance, args[inst->a]));
-            return call->env.Null();
-        }
-
         uint64_t buf[2];
-        if (!call->PushObject(arg, inst->type, (uint8_t *)buf))
+        if (!call->PushObject(arg, inst->type, (uint8_t *)buf)) [[unlikely]]
             return call->env.Null();
 
         // The second part might be useless (if object fits in one register), in
@@ -705,12 +700,7 @@ namespace {
     OP(PushAggregateStack) {
         napi_value arg = args[inst->a];
 
-        if (!IsObject(call->env, arg)) [[unlikely]] {
-            ThrowError<Napi::TypeError>(call->env, "Unexpected %1 value, expected object", GetValueType(call->instance, arg));
-            return call->env.Null();
-        }
-
-        if (!call->PushObject(arg, inst->type, base + inst->b1))
+        if (!call->PushObject(arg, inst->type, base + inst->b1)) [[unlikely]]
             return call->env.Null();
 
         NEXT();
@@ -734,7 +724,7 @@ namespace {
 #define DISPOSE(Ptr) \
         do { \
             if (inst->type->dispose) { \
-                inst->type->dispose(call->env, inst->type, (Ptr)); \
+                inst->type->dispose(call->instance, inst->type, (Ptr)); \
             } \
         } while (false)
 
@@ -762,42 +752,42 @@ namespace {
     OP(RunUInt64S) { INTEGER_SWAP(GG, uint64_t); }
     OP(RunString) {
         uint64_t rax = WRAP(ForwardCallGG(call->native, base, &call->saved_sp).rax);
-        napi_value value = rax ? Napi::String::New(call->env, (const char *)rax) : call->env.Null();
+        napi_value value = NewString(call->env, (const char *)rax);
         DISPOSE((void *)rax);
         return value;
     }
     OP(RunString16) {
         uint64_t rax = WRAP(ForwardCallGG(call->native, base, &call->saved_sp).rax);
-        napi_value value = rax ? Napi::String::New(call->env, (const char16_t *)rax) : call->env.Null();
+        napi_value value = NewString(call->env, (const char16_t *)rax);
         DISPOSE((void *)rax);
         return value;
     }
     OP(RunString32) {
         uint64_t rax = WRAP(ForwardCallGG(call->native, base, &call->saved_sp).rax);
-        napi_value value = rax ? MakeStringFromUTF32(call->env, (const char32_t *)rax) : call->env.Null();
+        napi_value value = NewString(call->env, (const char32_t *)rax);
         DISPOSE((void *)rax);
         return value;
     }
     OP(RunPointer) {
         uint64_t rax = WRAP(ForwardCallGG(call->native, base, &call->saved_sp).rax);
-        napi_value value = rax ? WrapPointer(call->env, inst->type, (void *)rax) : call->env.Null();
+        napi_value value = WrapPointer(call->env, inst->type, (void *)rax);
         DISPOSE((void *)rax);
         return value;
     }
     OP(RunCallback) {
         uint64_t rax = WRAP(ForwardCallGG(call->native, base, &call->saved_sp).rax);
-        return rax ? WrapPointer(call->env, inst->type, (void *)rax) : call->env.Null();
+        return WrapPointer(call->env, inst->type, (void *)rax);
     }
     OP(RunRecord) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunUnion) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunArray) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunFloat32) {
         float f = WRAP(ForwardCallF(call->native, base, &call->saved_sp));
-        return Napi::Number::New(call->env, (double)f);
+        return NewFloat(call->env, f);
     }
     OP(RunFloat64) {
         double d = WRAP(ForwardCallDD(call->native, base, &call->saved_sp).xmm0);
-        return Napi::Number::New(call->env, d);
+        return NewFloat(call->env, d);
     }
     OP(RunPrototype) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunAggregateGG) {
@@ -846,42 +836,42 @@ namespace {
     OP(RunUInt64SX) { INTEGER_SWAP(GGX, uint64_t); }
     OP(RunStringX) {
         uint64_t rax = WRAP(ForwardCallGGX(call->native, base, &call->saved_sp).rax);
-        napi_value value = rax ? Napi::String::New(call->env, (const char *)rax) : call->env.Null();
+        napi_value value = NewString(call->env, (const char *)rax);
         DISPOSE((void *)rax);
         return value;
     }
     OP(RunString16X) {
         uint64_t rax = WRAP(ForwardCallGGX(call->native, base, &call->saved_sp).rax);
-        napi_value value = rax ? Napi::String::New(call->env, (const char16_t *)rax) : call->env.Null();
+        napi_value value = NewString(call->env, (const char16_t *)rax);
         DISPOSE((void *)rax);
         return value;
     }
     OP(RunString32X) {
         uint64_t rax = WRAP(ForwardCallGGX(call->native, base, &call->saved_sp).rax);
-        napi_value value = rax ? MakeStringFromUTF32(call->env, (const char32_t *)rax) : call->env.Null();
+        napi_value value = NewString(call->env, (const char32_t *)rax);
         DISPOSE((void *)rax);
         return value;
     }
     OP(RunPointerX) {
         uint64_t rax = WRAP(ForwardCallGGX(call->native, base, &call->saved_sp).rax);
-        napi_value value = rax ? WrapPointer(call->env, inst->type, (void *)rax) : call->env.Null();
+        napi_value value = WrapPointer(call->env, inst->type, (void *)rax);
         DISPOSE((void *)rax);
         return value;
     }
     OP(RunCallbackX) {
         uint64_t rax = WRAP(ForwardCallGGX(call->native, base, &call->saved_sp).rax);
-        return rax ? WrapPointer(call->env, inst->type, (void *)rax) : call->env.Null();
+        return WrapPointer(call->env, inst->type, (void *)rax);
     }
     OP(RunRecordX) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunUnionX) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunArrayX) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunFloat32X) {
         float f = WRAP(ForwardCallFX(call->native, base, &call->saved_sp));
-        return Napi::Number::New(call->env, (double)f);
+        return NewFloat(call->env, f);
     }
     OP(RunFloat64X) {
         double d = WRAP(ForwardCallDDX(call->native, base, &call->saved_sp).xmm0);
-        return Napi::Number::New(call->env, d);
+        return NewFloat(call->env, d);
     }
     OP(RunPrototypeX) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunAggregateGGX) {
@@ -920,7 +910,7 @@ namespace {
         do { \
             if (inst->type->dispose) { \
                 void *ptr = *(void **)base; \
-                inst->type->dispose(call->env, inst->type, ptr); \
+                inst->type->dispose(call->instance, inst->type, ptr); \
             } \
         } while (false)
 #define INTEGER(CType) \
@@ -983,42 +973,42 @@ namespace {
     OP(ReturnUInt64S) { INTEGER_SWAP(uint64_t); }
     OP(ReturnString) {
         uint64_t rax = *(uint64_t *)base;
-        napi_value value = rax ? Napi::String::New(call->env, (const char *)rax) : call->env.Null();
+        napi_value value = NewString(call->env, (const char *)rax);
         DISPOSE();
         return value;
     }
     OP(ReturnString16) {
         uint64_t rax = *(uint64_t *)base;
-        napi_value value = rax ? Napi::String::New(call->env, (const char16_t *)rax) : call->env.Null();
+        napi_value value = NewString(call->env, (const char16_t *)rax);
         DISPOSE();
         return value;
     }
     OP(ReturnString32) {
         uint64_t rax = *(uint64_t *)base;
-        napi_value value = rax ? MakeStringFromUTF32(call->env, (const char32_t *)rax) : call->env.Null();
+        napi_value value = NewString(call->env, (const char32_t *)rax);
         DISPOSE();
         return value;
     }
     OP(ReturnPointer) {
         uint64_t rax = *(uint64_t *)base;
-        napi_value value = rax ? WrapPointer(call->env, inst->type, (void *)rax) : call->env.Null();
+        napi_value value = WrapPointer(call->env, inst->type, (void *)rax);
         DISPOSE();
         return value;
     }
     OP(ReturnCallback) {
         uint64_t rax = *(uint64_t *)base;
-        return rax ? WrapPointer(call->env, inst->type, (void *)rax) : call->env.Null();
+        return WrapPointer(call->env, inst->type, (void *)rax);
     }
     OP(ReturnRecord) { K_UNREACHABLE(); return call->env.Null(); }
     OP(ReturnUnion) { K_UNREACHABLE(); return call->env.Null(); }
     OP(ReturnArray) { K_UNREACHABLE(); return call->env.Null(); }
     OP(ReturnFloat32) {
         float f = *(float *)base;
-        return Napi::Number::New(call->env, (double)f);
+        return NewFloat(call->env, f);
     }
     OP(ReturnFloat64) {
         double d = *(double *)base;
-        return Napi::Number::New(call->env, d);
+        return NewFloat(call->env, d);
     }
     OP(ReturnPrototype) { K_UNREACHABLE(); return call->env.Null(); }
     OP(ReturnAggregateReg) { return DecodeObject(call->instance, base, inst->type); }
@@ -1188,30 +1178,30 @@ void CallData::Relay(Size idx, uint8_t *sp)
                 const uint8_t *src = in_ptr + param.abi.offsets[0];
                 const char *str = *(const char **)src;
 
-                arguments[i] = str ? Napi::String::New(env, str) : env.Null();
+                arguments[i] = NewString(env, str);
 
                 if (param.type->dispose) {
-                    param.type->dispose(env, param.type, str);
+                    param.type->dispose(instance, param.type, str);
                 }
             } break;
             case PrimitiveKind::String16: {
                 const uint8_t *src = in_ptr + param.abi.offsets[0];
                 const char16_t *str16 = *(const char16_t **)src;
 
-                arguments[i] = str16 ? Napi::String::New(env, str16) : env.Null();
+                arguments[i] = NewString(env, str16);
 
                 if (param.type->dispose) {
-                    param.type->dispose(env, param.type, str16);
+                    param.type->dispose(instance, param.type, str16);
                 }
             } break;
             case PrimitiveKind::String32: {
                 const uint8_t *src = in_ptr + param.abi.offsets[0];
                 const char32_t *str32 = *(const char32_t **)src;
 
-                arguments[i] = str32 ? MakeStringFromUTF32(env, str32) : env.Null();
+                arguments[i] = NewString(env, str32);
 
                 if (param.type->dispose) {
-                    param.type->dispose(env, param.type, str32);
+                    param.type->dispose(instance, param.type, str32);
                 }
             } break;
 
@@ -1219,10 +1209,10 @@ void CallData::Relay(Size idx, uint8_t *sp)
                 const uint8_t *src = in_ptr + param.abi.offsets[0];
                 void *ptr2 = *(void **)src;
 
-                arguments[i] = ptr2 ? WrapPointer(env, param.type->ref.type, ptr2) : env.Null();
+                arguments[i] = WrapPointer(env, param.type->ref.type, ptr2);
 
                 if (param.type->dispose) {
-                    param.type->dispose(env, param.type, ptr2);
+                    param.type->dispose(instance, param.type, ptr2);
                 }
             } break;
 
@@ -1244,24 +1234,20 @@ void CallData::Relay(Size idx, uint8_t *sp)
                 const uint8_t *src = in_ptr + param.abi.offsets[0];
                 float f = *(float *)src;
 
-                arguments[i] = Napi::Number::New(env, (double)f);
+                arguments[i] = NewFloat(env, f);
             } break;
             case PrimitiveKind::Float64: {
                 const uint8_t *src = in_ptr + param.abi.offsets[0];
                 double d = *(double *)src;
 
-                arguments[i] = Napi::Number::New(env, d);
+                arguments[i] = NewFloat(env, d);
             } break;
 
             case PrimitiveKind::Callback: {
                 const uint8_t *src = in_ptr + param.abi.offsets[0];
                 void *ptr2 = *(void **)src;
 
-                arguments[i] = ptr2 ? WrapPointer(env, param.type->ref.type, ptr2) : env.Null();
-
-                if (param.type->dispose) {
-                    param.type->dispose(env, param.type, ptr2);
-                }
+                arguments[i] = WrapPointer(env, param.type->ref.type, ptr2);
             } break;
 
             case PrimitiveKind::Prototype: { K_UNREACHABLE(); } break;
@@ -1361,16 +1347,11 @@ void CallData::Relay(Size idx, uint8_t *sp)
 
         case PrimitiveKind::Record:
         case PrimitiveKind::Union: {
-            if (!IsObject(env, value)) [[unlikely]] {
-                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected object", GetValueType(instance, value));
-                return;
-            }
-
             if (proto->ret.abi.method == AbiMethod::Stack) {
                 uint64_t *gpr_ptr = (uint64_t *)in_ptr;
                 uint8_t *dest = (uint8_t *)gpr_ptr[0];
 
-                if (!PushObject(value, type, dest))
+                if (!PushObject(value, type, dest)) [[unlikely]]
                     return;
 
                 out_reg->rax = (uint64_t)dest;
@@ -1378,7 +1359,7 @@ void CallData::Relay(Size idx, uint8_t *sp)
                 K_ASSERT(type->size <= 16);
 
                 uint8_t buf[16] = {};
-                if (!PushObject(value, type, buf))
+                if (!PushObject(value, type, buf)) [[unlikely]]
                     return;
 
                 switch (proto->ret.abi.method) {