koffi 3.0.2 → 3.1.0

package/src/koffi/src/abi/x64win.cc

@@ -74,16 +74,16 @@ inline void *Code2Op(AbiOpcode code)
 
 bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
 {
-    func->ret.regular = IsRegularSize(func->ret.type->size, 8);
+    func->ret.abi.regular = IsRegularSize(func->ret.type->size, 8);
 
     for (Size i = 0; i < func->parameters.len; i++) {
-        int16_t arg = (int16_t)(!func->ret.regular + i);
+        int16_t arg = (int16_t)(!func->ret.abi.regular + i);
         ParameterInfo &param = func->parameters[i];
 
-        param.regular = IsRegularSize(param.type->size, 8);
+        param.abi.regular = IsRegularSize(param.type->size, 8);
 
         if (param.type->primitive == PrimitiveKind::Record || param.type->primitive == PrimitiveKind::Union) {
-            AbiOpcode code = param.regular ? AbiOpcode::PushAggregateReg : AbiOpcode::PushAggregateMem;
+            AbiOpcode code = param.abi.regular ? AbiOpcode::PushAggregateReg : AbiOpcode::PushAggregateMem;
 
             func->sync.Append({ .op = Code2Op(code), .a = param.offset, .b1 = (int16_t)(arg * 8), .b2 = (int16_t)param.directions, .type = param.type });
             func->async.Append({ .op = Code2Op(code), .a = param.offset, .b1 = (int16_t)(arg * 8), .b2 = (int16_t)param.directions, .type = param.type });
@@ -100,7 +100,7 @@ bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
 
     // At least 4 parameter registers
     {
-        Size count = std::max((Size)4, func->parameters.len + !func->ret.regular);
+        Size count = std::max((Size)4, func->parameters.len + !func->ret.abi.regular);
         func->stk_size = AlignLen(8 * count, 16);
     }
 
@@ -168,7 +168,7 @@ bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
 
         case PrimitiveKind::Record:
         case PrimitiveKind::Union: {
-            if (func->ret.regular) {
+            if (func->ret.abi.regular) {
                 AbiOpcode run = func->forward_fp ? AbiOpcode::RunAggregateRegX : AbiOpcode::RunAggregateReg;
                 AbiOpcode call = func->forward_fp ? AbiOpcode::CallGX : AbiOpcode::CallG;
 
@@ -370,14 +370,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 = (uint8_t *)(base + inst->b1);
 
-        if (!call->PushObject(arg, inst->type, ptr))
+        if (!call->PushObject(arg, inst->type, ptr)) [[unlikely]]
             return call->env.Null();
 
         NEXT();
@@ -385,15 +380,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();
@@ -415,7 +405,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)
 
@@ -443,42 +433,42 @@ namespace {
     OP(RunUInt64S) { INTEGER_SWAP(G, uint64_t); }
     OP(RunString) {
         uint64_t rax = WRAP(ForwardCallG(call->native, base, &call->saved_sp));
-        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(ForwardCallG(call->native, base, &call->saved_sp));
-        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(ForwardCallG(call->native, base, &call->saved_sp));
-        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(ForwardCallG(call->native, base, &call->saved_sp));
-        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(ForwardCallG(call->native, base, &call->saved_sp));
-        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(ForwardCallD(call->native, base, &call->saved_sp));
-        return Napi::Number::New(call->env, d);
+        return NewFloat(call->env, d);
     }
     OP(RunPrototype) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunAggregateReg) {
@@ -514,42 +504,42 @@ namespace {
     OP(RunUInt64SX) { INTEGER_SWAP(GX, uint64_t); }
     OP(RunStringX) {
         uint64_t rax = WRAP(ForwardCallGX(call->native, base, &call->saved_sp));
-        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(ForwardCallGX(call->native, base, &call->saved_sp));
-        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(ForwardCallGX(call->native, base, &call->saved_sp));
-        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(ForwardCallGX(call->native, base, &call->saved_sp));
-        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(ForwardCallGX(call->native, base, &call->saved_sp));
-        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(ForwardCallDX(call->native, base, &call->saved_sp));
-        return Napi::Number::New(call->env, d);
+        return NewFloat(call->env, d);
     }
     OP(RunPrototypeX) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunAggregateRegX) {
@@ -575,7 +565,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) \
@@ -632,42 +622,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); }
@@ -778,7 +768,7 @@ void CallData::Relay(Size idx, uint8_t *sp)
     uint64_t *xmm_ptr = gpr_ptr + 4;
     uint64_t *stk_ptr = (uint64_t *)caller_sp;
 
-    uint8_t *return_ptr = !proto->ret.regular ? (uint8_t *)gpr_ptr[0] : nullptr;
+    uint8_t *return_ptr = !proto->ret.abi.regular ? (uint8_t *)gpr_ptr[0] : nullptr;
 
     K_DEFER_N(err_guard) {
         trampoline->state = -1;
@@ -889,56 +879,52 @@ void CallData::Relay(Size idx, uint8_t *sp)
                 const char *str = *(const char **)(j < 4 ? gpr_ptr + j : stk_ptr);
                 stk_ptr += (j >= 4);
 
-                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 char16_t *str16 = *(const char16_t **)(j < 4 ? gpr_ptr + j : stk_ptr);
                 stk_ptr += (j >= 4);
 
-                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 char32_t *str32 = *(const char32_t **)(j < 4 ? gpr_ptr + j : stk_ptr);
                 stk_ptr += (j >= 4);
 
-                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;
             case PrimitiveKind::Pointer: {
                 void *ptr2 = *(void **)(j < 4 ? gpr_ptr + j : stk_ptr);
                 stk_ptr += (j >= 4);
 
-                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;
             case PrimitiveKind::Callback: {
                 void *ptr2 = *(void **)(j < 4 ? gpr_ptr + j : stk_ptr);
                 stk_ptr += (j >= 4);
 
-                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::Record:
             case PrimitiveKind::Union: {
                 uint8_t *ptr;
-                if (param.regular) {
+                if (param.abi.regular) {
                     ptr = (uint8_t *)(j < 4 ? gpr_ptr + j : stk_ptr);
                 } else {
                     ptr = *(uint8_t **)(j < 4 ? gpr_ptr + j : stk_ptr);
@@ -952,13 +938,13 @@ void CallData::Relay(Size idx, uint8_t *sp)
                 float f = *(float *)(j < 4 ? xmm_ptr + j : stk_ptr);
                 stk_ptr += (j >= 4);
 
-                arguments[i] = Napi::Number::New(env, (double)f);
+                arguments[i] = NewFloat(env, f);
             } break;
             case PrimitiveKind::Float64: {
                 double d = *(double *)(j < 4 ? xmm_ptr + j : stk_ptr);
                 stk_ptr += (j >= 4);
 
-                arguments[i] = Napi::Number::New(env, d);
+                arguments[i] = NewFloat(env, d);
             } break;
 
             case PrimitiveKind::Prototype: { K_UNREACHABLE(); } break;
@@ -1049,17 +1035,13 @@ 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 (return_ptr) {
-                if (!PushObject(value, type, return_ptr))
+                if (!PushObject(value, type, return_ptr)) [[unlikely]]
                     return;
                 out_reg->rax = (uint64_t)return_ptr;
             } else {
-                PushObject(value, type, (uint8_t *)&out_reg->rax);
+                if (!PushObject(value, type, (uint8_t *)&out_reg->rax)) [[unlikely]]
+                    return;
             }
         } break;
         case PrimitiveKind::Array: { K_UNREACHABLE(); } break;