koffi 3.0.1 → 3.1.0

package/src/koffi/src/abi/x86.cc

@@ -6,6 +6,7 @@
 #include "lib/native/base/base.hh"
 #include "../ffi.hh"
 #include "../call.hh"
+#include "../type.hh"
 #include "../util.hh"
 #if defined(_WIN32)
     #include "../win32.hh"
@@ -80,10 +81,10 @@ bool AnalyseFunction(Napi::Env env, InstanceData *instance, FunctionInfo *func)
     if (func->ret.type->primitive != PrimitiveKind::Record &&
             func->ret.type->primitive != PrimitiveKind::Union) {
         K_ASSERT(IsRegularSize(func->ret.type->size, 8));
-        func->ret.trivial = true;
+        func->ret.abi.regular = true;
 #if defined(_WIN32) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
     } else {
-        func->ret.trivial = IsRegularSize(func->ret.type->size, 8);
+        func->ret.abi.regular = IsRegularSize(func->ret.type->size, 8);
 #endif
     }
 
@@ -94,7 +95,7 @@ bool AnalyseFunction(Napi::Env env, InstanceData *instance, FunctionInfo *func)
     Size fast_offset = 0;
     Size stk_offset = fast ? 4 : 0;
 
-    if (!func->ret.trivial) {
+    if (!func->ret.abi.regular) {
 #if defined(_WIN32)
         stk_offset++;
 #else
@@ -224,7 +225,7 @@ bool AnalyseFunction(Napi::Env env, InstanceData *instance, FunctionInfo *func)
             }
 #endif
 
-            if (func->ret.trivial) {
+            if (func->ret.abi.regular) {
                 AbiOpcode run = fast ? AbiOpcode::RunAggregateGR : AbiOpcode::RunAggregateG;
                 AbiOpcode call = fast ? AbiOpcode::CallGR : AbiOpcode::CallG;
 
@@ -269,13 +270,13 @@ bool AnalyseFunction(Napi::Env env, InstanceData *instance, FunctionInfo *func)
         case CallConvention::Stdcall: {
             K_ASSERT(!func->variadic);
 
-            Size suffix = (stk_offset - !func->ret.trivial) * 4;
+            Size suffix = (stk_offset - !func->ret.abi.regular) * 4;
             func->decorated_name = Fmt(&instance->str_alloc, "_%1@%2", func->name, suffix).ptr;
         } break;
         case CallConvention::Fastcall: {
             K_ASSERT(!func->variadic);
 
-            Size suffix = (fast_offset + stk_offset - 4 - !func->ret.trivial) * 4;
+            Size suffix = (fast_offset + stk_offset - 4 - !func->ret.abi.regular) * 4;
             func->decorated_name = Fmt(&instance->str_alloc, "@%1@%2", func->name, suffix).ptr;
         } break;
         case CallConvention::Thiscall: {
@@ -462,14 +463,9 @@ napi_value RunLoop(CallData *call, napi_value *args, uint8_t *base, const AbiIns
     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();
-        }
-
         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();
@@ -503,7 +499,7 @@ napi_value RunLoop(CallData *call, napi_value *args, uint8_t *base, const AbiIns
 #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)
 
@@ -531,42 +527,42 @@ napi_value RunLoop(CallData *call, napi_value *args, uint8_t *base, const AbiIns
     OP(RunUInt64S) { INTEGER64_SWAP(G, uint64_t); }
     OP(RunString) {
         uint32_t eax = (uint32_t)WRAP(ForwardCallG(call->native, base, &call->saved_sp));
-        napi_value value = eax ? Napi::String::New(call->env, (const char *)eax) : call->env.Null();
+        napi_value value = NewString(call->env, (const char *)eax);
         DISPOSE((void *)eax);
         return value;
     }
     OP(RunString16) {
         uint32_t eax = (uint32_t)WRAP(ForwardCallG(call->native, base, &call->saved_sp));
-        napi_value value = eax ? Napi::String::New(call->env, (const char16_t *)eax) : call->env.Null();
+        napi_value value = NewString(call->env, (const char16_t *)eax);
         DISPOSE((void *)eax);
         return value;
     }
     OP(RunString32) {
         uint32_t eax = (uint32_t)WRAP(ForwardCallG(call->native, base, &call->saved_sp));
-        napi_value value = eax ? MakeStringFromUTF32(call->env, (const char32_t *)eax) : call->env.Null();
+        napi_value value = NewString(call->env, (const char32_t *)eax);
         DISPOSE((void *)eax);
         return value;
     }
     OP(RunPointer) {
         uint32_t eax = (uint32_t)WRAP(ForwardCallG(call->native, base, &call->saved_sp));
-        napi_value value = eax ? WrapPointer(call->env, inst->type, (void *)eax) : call->env.Null();
+        napi_value value = WrapPointer(call->env, inst->type, (void *)eax);
         DISPOSE((void *)eax);
         return value;
     }
     OP(RunCallback) {
         uint32_t eax = (uint32_t)WRAP(ForwardCallG(call->native, base, &call->saved_sp));
-        return eax ? WrapPointer(call->env, inst->type, (void *)eax) : call->env.Null();
+        return WrapPointer(call->env, inst->type, (void *)eax);
     }
     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(RunAggregateG) {
@@ -610,42 +606,42 @@ napi_value RunLoop(CallData *call, napi_value *args, uint8_t *base, const AbiIns
     OP(RunUInt64SR) { INTEGER64_SWAP(GR, uint64_t); }
     OP(RunStringR) {
         uint32_t eax = (uint32_t)WRAP(ForwardCallGR(call->native, base, &call->saved_sp));
-        napi_value value = eax ? Napi::String::New(call->env, (const char *)eax) : call->env.Null();
+        napi_value value = NewString(call->env, (const char *)eax);
         DISPOSE((void *)eax);
         return value;
     }
     OP(RunString16R) {
         uint32_t eax = (uint32_t)WRAP(ForwardCallGR(call->native, base, &call->saved_sp));
-        napi_value value = eax ? Napi::String::New(call->env, (const char16_t *)eax) : call->env.Null();
+        napi_value value = NewString(call->env, (const char16_t *)eax);
         DISPOSE((void *)eax);
         return value;
     }
     OP(RunString32R) {
         uint32_t eax = (uint32_t)WRAP(ForwardCallGR(call->native, base, &call->saved_sp));
-        napi_value value = eax ? MakeStringFromUTF32(call->env, (const char32_t *)eax) : call->env.Null();
+        napi_value value = NewString(call->env, (const char32_t *)eax);
         DISPOSE((void *)eax);
         return value;
     }
     OP(RunPointerR) {
         uint32_t eax = (uint32_t)WRAP(ForwardCallGR(call->native, base, &call->saved_sp));
-        napi_value value = eax ? WrapPointer(call->env, inst->type, (void *)eax) : call->env.Null();
+        napi_value value = WrapPointer(call->env, inst->type, (void *)eax);
         DISPOSE((void *)eax);
         return value;
     }
     OP(RunCallbackR) {
         uint32_t eax = (uint32_t)WRAP(ForwardCallGR(call->native, base, &call->saved_sp));
-        return eax ? WrapPointer(call->env, inst->type, (void *)eax) : call->env.Null();
+        return WrapPointer(call->env, inst->type, (void *)eax);
     }
     OP(RunRecordR) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunUnionR) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunArrayR) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunFloat32R) {
         float f = WRAP(ForwardCallFR(call->native, base, &call->saved_sp));
-        return Napi::Number::New(call->env, (double)f);
+        return NewFloat(call->env, f);
     }
     OP(RunFloat64R) {
         double d = WRAP(ForwardCallDR(call->native, base, &call->saved_sp));
-        return Napi::Number::New(call->env, d);
+        return NewFloat(call->env, d);
     }
     OP(RunPrototypeR) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunAggregateGR) {
@@ -685,7 +681,7 @@ napi_value RunLoop(CallData *call, napi_value *args, uint8_t *base, const AbiIns
         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 INTEGER32(CType) \
@@ -757,42 +753,42 @@ napi_value RunLoop(CallData *call, napi_value *args, uint8_t *base, const AbiIns
     OP(ReturnUInt64S) { INTEGER64_SWAP(uint64_t); }
     OP(ReturnString) {
         uint32_t eax = *(uint32_t *)base;
-        napi_value value = eax ? Napi::String::New(call->env, (const char *)eax) : call->env.Null();
+        napi_value value = NewString(call->env, (const char *)eax);
         DISPOSE();
         return value;
     }
     OP(ReturnString16) {
         uint32_t eax = *(uint32_t *)base;
-        napi_value value = eax ? Napi::String::New(call->env, (const char16_t *)eax) : call->env.Null();
+        napi_value value = NewString(call->env, (const char16_t *)eax);
         DISPOSE();
         return value;
     }
     OP(ReturnString32) {
         uint32_t eax = *(uint32_t *)base;
-        napi_value value = eax ? MakeStringFromUTF32(call->env, (const char32_t *)eax) : call->env.Null();
+        napi_value value = NewString(call->env, (const char32_t *)eax);
         DISPOSE();
         return value;
     }
     OP(ReturnPointer) {
         uint32_t eax = *(uint32_t *)base;
-        napi_value value = eax ? WrapPointer(call->env, inst->type, (void *)eax) : call->env.Null();
+        napi_value value = WrapPointer(call->env, inst->type, (void *)eax);
         DISPOSE();
         return value;
     }
     OP(ReturnCallback) {
         uint32_t eax = *(uint32_t *)base;
-        return eax ? WrapPointer(call->env, inst->type, (void *)eax) : call->env.Null();
+        return WrapPointer(call->env, inst->type, (void *)eax);
     }
     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); }
@@ -858,8 +854,8 @@ void CallData::Relay(Size idx, uint8_t *sp)
 
     uint32_t *args_ptr = (uint32_t *)caller_sp;
 
-    uint8_t *return_ptr = !proto->ret.trivial ? (uint8_t *)args_ptr[0] : nullptr;
-    args_ptr += !proto->ret.trivial;
+    uint8_t *return_ptr = !proto->ret.abi.regular ? (uint8_t *)args_ptr[0] : nullptr;
+    args_ptr += !proto->ret.abi.regular;
 
     if (proto->convention == CallConvention::Stdcall) {
         out_reg->ret_pop = (int)proto->ret_pop;
@@ -960,43 +956,39 @@ void CallData::Relay(Size idx, uint8_t *sp)
             } break;
             case PrimitiveKind::String: {
                 const char *str = *(const char **)(args_ptr++);
-                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 **)(args_ptr++);
-                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 **)(args_ptr++);
-                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 **)(args_ptr++);
-                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 **)(args_ptr++);
-                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: {
@@ -1008,13 +1000,13 @@ void CallData::Relay(Size idx, uint8_t *sp)
             case PrimitiveKind::Array: { K_UNREACHABLE(); } break;
             case PrimitiveKind::Float32: {
                 float f = *(float *)(args_ptr++);
-                arguments[i] = Napi::Number::New(env, (double)f);
+                arguments[i] = NewFloat(env, f);
             } break;
             case PrimitiveKind::Float64: {
                 double d = *(double *)args_ptr;
                 args_ptr += 2;
 
-                arguments[i] = Napi::Number::New(env, d);
+                arguments[i] = NewFloat(env, d);
             } break;
 
             case PrimitiveKind::Prototype: { K_UNREACHABLE(); } break;
@@ -1136,17 +1128,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->eax = (uint32_t)return_ptr;
             } else {
-                PushObject(value, type, (uint8_t *)&out_reg->eax);
+                if (!PushObject(value, type, (uint8_t *)&out_reg->eax))
+                    return;
             }
 
             out_reg->ret_type = 0;