koffi 3.0.2 → 3.1.1

package/src/koffi/src/abi/arm64.cc

@@ -133,9 +133,9 @@ static HfaInfo IsHFA(const TypeInfo *type)
 
 bool AnalyseFunction(Napi::Env, InstanceData *instance, FunctionInfo *func)
 {
-    Size gpr_index = 0;
-    Size vec_index = 0;
-    Size stack_offset = 0;
+    int gpr_index = 0;
+    int vec_index = 0;
+    int stack_offset = 0;
 
 #if defined(_M_ARM64EC)
     int gpr_max = func->variadic ? 4 : 8;
@@ -542,8 +542,10 @@ bool AnalyseFunction(Napi::Env, InstanceData *instance, FunctionInfo *func)
     return true;
 }
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-parameter"
+#if defined(__GNUC__) || defined(__clang__)
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
 
 namespace {
 #if defined(MUST_TAIL)
@@ -705,14 +707,9 @@ 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();
-        }
-
         uint8_t *ptr = base + inst->b1;
 
-        if (!call->PushObject(arg, inst->type, ptr))
+        if (!call->PushObject(arg, inst->type, ptr)) [[unlikely]]
             return call->env.Null();
 
         NEXT();
@@ -720,15 +717,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();
@@ -750,7 +742,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)
 
@@ -778,42 +770,42 @@ namespace {
     OP(RunUInt64S) { INTEGER_SWAP(GG, uint64_t); }
     OP(RunString) {
         uint64_t x0 = WRAP(ForwardCallGG(call->native, base, &call->saved_sp)).x0;
-        napi_value value = x0 ? Napi::String::New(call->env, (const char *)x0) : call->env.Null();
+        napi_value value = NewString(call->env, (const char *)x0);
         DISPOSE((void *)x0);
         return value;
     }
     OP(RunString16) {
         uint64_t x0 = WRAP(ForwardCallGG(call->native, base, &call->saved_sp)).x0;
-        napi_value value = x0 ? Napi::String::New(call->env, (const char16_t *)x0) : call->env.Null();
+        napi_value value = NewString(call->env, (const char16_t *)x0);
         DISPOSE((void *)x0);
         return value;
     }
     OP(RunString32) {
         uint64_t x0 = WRAP(ForwardCallGG(call->native, base, &call->saved_sp)).x0;
-        napi_value value = x0 ? MakeStringFromUTF32(call->env, (const char32_t *)x0) : call->env.Null();
+        napi_value value = NewString(call->env, (const char32_t *)x0);
         DISPOSE((void *)x0);
         return value;
     }
     OP(RunPointer) {
         uint64_t x0 = WRAP(ForwardCallGG(call->native, base, &call->saved_sp)).x0;
-        napi_value value = x0 ? WrapPointer(call->env, inst->type, (void *)x0) : call->env.Null();
+        napi_value value = WrapPointer(call->env, inst->type, (void *)x0);
         DISPOSE((void *)x0);
         return value;
     }
     OP(RunCallback) {
         uint64_t x0 = WRAP(ForwardCallGG(call->native, base, &call->saved_sp)).x0;
-        return x0 ? WrapPointer(call->env, inst->type, (void *)x0) : call->env.Null();
+        return WrapPointer(call->env, inst->type, (void *)x0);
     }
     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(ForwardCallDDDD(call->native, base, &call->saved_sp)).d0;
-        return Napi::Number::New(call->env, d);
+        return NewFloat(call->env, d);
     }
     OP(RunPrototype) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunAggregateGG) {
@@ -854,42 +846,42 @@ namespace {
     OP(RunUInt64SX) { INTEGER_SWAP(GGX, uint64_t); }
     OP(RunStringX) {
         uint64_t x0 = WRAP(ForwardCallGGX(call->native, base, &call->saved_sp)).x0;
-        napi_value value = x0 ? Napi::String::New(call->env, (const char *)x0) : call->env.Null();
+        napi_value value = NewString(call->env, (const char *)x0);
         DISPOSE((void *)x0);
         return value;
     }
     OP(RunString16X) {
         uint64_t x0 = WRAP(ForwardCallGGX(call->native, base, &call->saved_sp)).x0;
-        napi_value value = x0 ? Napi::String::New(call->env, (const char16_t *)x0) : call->env.Null();
+        napi_value value = NewString(call->env, (const char16_t *)x0);
         DISPOSE((void *)x0);
         return value;
     }
     OP(RunString32X) {
         uint64_t x0 = WRAP(ForwardCallGGX(call->native, base, &call->saved_sp)).x0;
-        napi_value value = x0 ? MakeStringFromUTF32(call->env, (const char32_t *)x0) : call->env.Null();
+        napi_value value = NewString(call->env, (const char32_t *)x0);
         DISPOSE((void *)x0);
         return value;
     }
     OP(RunPointerX) {
         uint64_t x0 = WRAP(ForwardCallGGX(call->native, base, &call->saved_sp)).x0;
-        napi_value value = x0 ? WrapPointer(call->env, inst->type, (void *)x0) : call->env.Null();
+        napi_value value = WrapPointer(call->env, inst->type, (void *)x0);
         DISPOSE((void *)x0);
         return value;
     }
     OP(RunCallbackX) {
         uint64_t x0 = WRAP(ForwardCallGGX(call->native, base, &call->saved_sp)).x0;
-        return x0 ? WrapPointer(call->env, inst->type, (void *)x0) : call->env.Null();
+        return WrapPointer(call->env, inst->type, (void *)x0);
     }
     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(ForwardCallDDDDX(call->native, base, &call->saved_sp)).d0;
-        return Napi::Number::New(call->env, d);
+        return NewFloat(call->env, d);
     }
     OP(RunPrototypeX) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunAggregateGGX) {
@@ -920,7 +912,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) \
@@ -989,42 +981,42 @@ namespace {
     OP(ReturnUInt64S) { INTEGER_SWAP(uint64_t); }
     OP(ReturnString) {
         uint64_t x0 = *(uint64_t *)base;
-        napi_value value = x0 ? Napi::String::New(call->env, (const char *)x0) : call->env.Null();
+        napi_value value = NewString(call->env, (const char *)x0);
         DISPOSE();
         return value;
     }
     OP(ReturnString16) {
         uint64_t x0 = *(uint64_t *)base;
-        napi_value value = x0 ? Napi::String::New(call->env, (const char16_t *)x0) : call->env.Null();
+        napi_value value = NewString(call->env, (const char16_t *)x0);
         DISPOSE();
         return value;
     }
     OP(ReturnString32) {
         uint64_t x0 = *(uint64_t *)base;
-        napi_value value = x0 ? MakeStringFromUTF32(call->env, (const char32_t *)x0) : call->env.Null();
+        napi_value value = NewString(call->env, (const char32_t *)x0);
         DISPOSE();
         return value;
     }
     OP(ReturnPointer) {
         uint64_t x0 = *(uint64_t *)base;
-        napi_value value = x0 ? WrapPointer(call->env, inst->type, (void *)x0) : call->env.Null();
+        napi_value value = WrapPointer(call->env, inst->type, (void *)x0);
         DISPOSE();
         return value;
     }
     OP(ReturnCallback) {
         uint64_t x0 = *(uint64_t *)base;
-        return x0 ? WrapPointer(call->env, inst->type, (void *)x0) : call->env.Null();
+        return WrapPointer(call->env, inst->type, (void *)x0);
     }
     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); }
@@ -1101,7 +1093,9 @@ namespace {
 #undef OP
 }
 
-#pragma GCC diagnostic pop
+#if defined(__GNUC__) || defined(__clang__)
+    #pragma GCC diagnostic pop
+#endif
 
 napi_value CallData::Run(const FunctionInfo *func, napi_value *args)
 {
@@ -1200,30 +1194,30 @@ void CallData::Relay(Size idx, uint8_t *sp)
                 const uint8_t *src = in_ptr + param.abi.offset;
                 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.offset;
                 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.offset;
                 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;
 
@@ -1231,10 +1225,10 @@ void CallData::Relay(Size idx, uint8_t *sp)
                 const uint8_t *src = in_ptr + param.abi.offset;
                 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;
 
@@ -1251,24 +1245,20 @@ void CallData::Relay(Size idx, uint8_t *sp)
                 const uint8_t *src = in_ptr + param.abi.offset;
                 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.offset;
                 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.offset;
                 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;
@@ -1368,15 +1358,10 @@ 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;
-            }
-
             uint64_t *gpr_ptr = (uint64_t *)in_ptr;
             uint8_t *dest = proto->ret.abi.regular ? (uint8_t *)&out_reg + proto->ret.abi.offset : (uint8_t *)gpr_ptr[8]; // x8
 
-            if (!PushObject(value, type, dest))
+            if (!PushObject(value, type, dest)) [[unlikely]]
                 return;
         } break;
         case PrimitiveKind::Array: { K_UNREACHABLE(); } break;

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;