koffi 3.0.0 → 3.0.1

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

@@ -36,19 +36,19 @@ extern "C" double ForwardCallDR(const void *func, uint8_t *sp, uint8_t **out_sav
 enum class AbiOpcode {
     #define PRIMITIVE(Name) Push ## Name,
     #include "../primitives.inc"
-    PushAggregate,
+    PushAggregateStack,
     #define PRIMITIVE(Name) Run ## Name,
     #include "../primitives.inc"
     RunAggregateG,
     RunAggregateF,
     RunAggregateD,
-    RunAggregateStack,
+    RunAggregateMem,
     #define PRIMITIVE(Name) Run ## Name ## R,
     #include "../primitives.inc"
     RunAggregateGR,
     RunAggregateFR,
     RunAggregateDR,
-    RunAggregateStackR,
+    RunAggregateMemR,
     Yield,
     CallG,
     CallF,
@@ -61,7 +61,7 @@ enum class AbiOpcode {
     #define PRIMITIVE(Name) Return ## Name,
     #include "../primitives.inc"
     ReturnAggregateReg,
-    ReturnAggregateStack
+    ReturnAggregateMem
 };
 
 static inline void *Code2Op(AbiOpcode code)
@@ -119,14 +119,14 @@ bool AnalyseFunction(Napi::Env env, InstanceData *instance, FunctionInfo *func)
         }
 
         if (param.type->primitive == PrimitiveKind::Record || param.type->primitive == PrimitiveKind::Union) {
-            func->sync.Append({ .op = Code2Op(AbiOpcode::PushAggregate), .a = param.offset, .b1 = offset, .b2 = (int16_t)param.directions, .type = param.type });
-            func->async.Append({ .op = Code2Op(AbiOpcode::PushAggregate), .a = param.offset, .b1 = offset, .b2 = (int16_t)param.directions, .type = param.type });
+            func->sync.Append({ .op = Code2Op(AbiOpcode::PushAggregateStack), .a = param.offset, .b1 = (int16_t)(offset * 4), .b2 = (int16_t)param.directions, .type = param.type });
+            func->async.Append({ .op = Code2Op(AbiOpcode::PushAggregateStack), .a = param.offset, .b1 = (int16_t)(offset * 4), .b2 = (int16_t)param.directions, .type = param.type });
         } else {
             int delta = (int)AbiOpcode::PushVoid - (int)PrimitiveKind::Void;
             AbiOpcode code = (AbiOpcode)((int)param.type->primitive + delta);
 
-            func->sync.Append({ .op = Code2Op(code), .a = param.offset, .b1 = offset, .b2 = (int16_t)param.directions, .type = param.type });
-            func->async.Append({ .op = Code2Op(code), .a = param.offset, .b1 = offset, .b2 = (int16_t)param.directions, .type = param.type });
+            func->sync.Append({ .op = Code2Op(code), .a = param.offset, .b1 = (int16_t)(offset * 4), .b2 = (int16_t)param.directions, .type = param.type });
+            func->async.Append({ .op = Code2Op(code), .a = param.offset, .b1 = (int16_t)(offset * 4), .b2 = (int16_t)param.directions, .type = param.type });
         }
     }
 
@@ -232,12 +232,12 @@ bool AnalyseFunction(Napi::Env env, InstanceData *instance, FunctionInfo *func)
                 func->async.Append({ .op = Code2Op(call) });
                 func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregateReg), .type = func->ret.type });
             } else {
-                AbiOpcode run = fast ? AbiOpcode::RunAggregateStackR : AbiOpcode::RunAggregateStack;
+                AbiOpcode run = fast ? AbiOpcode::RunAggregateMemR : AbiOpcode::RunAggregateMem;
                 AbiOpcode call = fast ? AbiOpcode::CallStackR : AbiOpcode::CallStack;
 
                 func->sync.Append({ .op = Code2Op(run), .a = (int32_t)func->ret.type->size, .type = func->ret.type });
                 func->async.Append({ .op = Code2Op(call), .a = (int32_t)func->ret.type->size });
-                func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregateStack), .type = func->ret.type });
+                func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregateMem), .type = func->ret.type });
             }
         } break;
         case PrimitiveKind::Array: { K_UNREACHABLE(); } break;
@@ -298,7 +298,7 @@ namespace {
     #define NEXT() \
         break
 
-napi_value RunLoop(CallData *call, napi_value *args, uint32_t *base, const AbiInstruction *inst)
+napi_value RunLoop(CallData *call, napi_value *args, uint8_t *base, const AbiInstruction *inst)
 {
     for (;; ++inst) {
         switch ((intptr_t)inst->op) {
@@ -328,7 +328,7 @@ napi_value RunLoop(CallData *call, napi_value *args, uint32_t *base, const AbiIn
                 return call->env.Null(); \
             } \
              \
-            *(base + inst->b1) = (uint32_t)v; \
+            *(uint32_t *)(base + inst->b1) = (uint32_t)v; \
         } while (false)
 #define INTEGER32_SWAP(CType) \
         do { \
@@ -338,7 +338,7 @@ napi_value RunLoop(CallData *call, napi_value *args, uint32_t *base, const AbiIn
                 return call->env.Null(); \
             } \
              \
-            *(base + inst->b1) = (uint32_t)ReverseBytes(v); \
+            *(uint32_t *)(base + inst->b1) = (uint32_t)ReverseBytes(v); \
         } while (false)
 #define INTEGER64(CType) \
         do { \
@@ -459,7 +459,7 @@ napi_value RunLoop(CallData *call, napi_value *args, uint32_t *base, const AbiIn
         NEXT();
     }
     OP(PushPrototype) { K_UNREACHABLE(); return call->env.Null(); }
-    OP(PushAggregate) {
+    OP(PushAggregateStack) {
         napi_value arg = args[inst->a];
 
         if (!IsObject(call->env, arg)) [[unlikely]] {
@@ -482,22 +482,22 @@ napi_value RunLoop(CallData *call, napi_value *args, uint32_t *base, const AbiIn
 
 #define INTEGER32(Suffix, CType) \
         do { \
-            uint32_t eax = (uint32_t)WRAP(ForwardCall ## Suffix(call->native, (uint8_t *)base, &call->saved_sp)); \
+            uint32_t eax = (uint32_t)WRAP(ForwardCall ## Suffix(call->native, base, &call->saved_sp)); \
             return NewInt(call->env, (CType)eax); \
         } while (false)
 #define INTEGER32_SWAP(Suffix, CType) \
         do { \
-            uint32_t eax = (uint32_t)WRAP(ForwardCall ## Suffix(call->native, (uint8_t *)base, &call->saved_sp)); \
+            uint32_t eax = (uint32_t)WRAP(ForwardCall ## Suffix(call->native, base, &call->saved_sp)); \
             return NewInt(call->env, ReverseBytes((CType)eax)); \
         } while (false)
 #define INTEGER64(Suffix, CType) \
         do { \
-            uint64_t ret = WRAP(ForwardCall ## Suffix(call->native, (uint8_t *)base, &call->saved_sp)); \
+            uint64_t ret = WRAP(ForwardCall ## Suffix(call->native, base, &call->saved_sp)); \
             return NewInt(call->env, (CType)ret); \
         } while (false)
 #define INTEGER64_SWAP(Suffix, CType) \
         do { \
-            uint64_t ret = WRAP(ForwardCall ## Suffix(call->native, (uint8_t *)base, &call->saved_sp)); \
+            uint64_t ret = WRAP(ForwardCall ## Suffix(call->native, base, &call->saved_sp)); \
             return NewInt(call->env, ReverseBytes((CType)ret)); \
         } while (false)
 #define DISPOSE(Ptr) \
@@ -508,11 +508,11 @@ napi_value RunLoop(CallData *call, napi_value *args, uint32_t *base, const AbiIn
         } while (false)
 
     OP(RunVoid) {
-        WRAP(ForwardCallG(call->native, (uint8_t *)base, &call->saved_sp));
+        WRAP(ForwardCallG(call->native, base, &call->saved_sp));
         return nullptr;
     }
     OP(RunBool) {
-        uint32_t eax = (uint32_t)WRAP(ForwardCallG(call->native, (uint8_t *)base, &call->saved_sp));
+        uint32_t eax = (uint32_t)WRAP(ForwardCallG(call->native, base, &call->saved_sp));
         return Napi::Boolean::New(call->env, eax & 0x1);
     }
     OP(RunInt8) { INTEGER32(G, int8_t); }
@@ -530,68 +530,68 @@ napi_value RunLoop(CallData *call, napi_value *args, uint32_t *base, const AbiIn
     OP(RunUInt64) { INTEGER64(G, uint64_t); }
     OP(RunUInt64S) { INTEGER64_SWAP(G, uint64_t); }
     OP(RunString) {
-        uint32_t eax = (uint32_t)WRAP(ForwardCallG(call->native, (uint8_t *)base, &call->saved_sp));
+        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();
         DISPOSE((void *)eax);
         return value;
     }
     OP(RunString16) {
-        uint32_t eax = (uint32_t)WRAP(ForwardCallG(call->native, (uint8_t *)base, &call->saved_sp));
+        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();
         DISPOSE((void *)eax);
         return value;
     }
     OP(RunString32) {
-        uint32_t eax = (uint32_t)WRAP(ForwardCallG(call->native, (uint8_t *)base, &call->saved_sp));
+        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();
         DISPOSE((void *)eax);
         return value;
     }
     OP(RunPointer) {
-        uint32_t eax = (uint32_t)WRAP(ForwardCallG(call->native, (uint8_t *)base, &call->saved_sp));
+        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();
         DISPOSE((void *)eax);
         return value;
     }
     OP(RunCallback) {
-        uint32_t eax = (uint32_t)WRAP(ForwardCallG(call->native, (uint8_t *)base, &call->saved_sp));
+        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();
     }
     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, (uint8_t *)base, &call->saved_sp));
+        float f = WRAP(ForwardCallF(call->native, base, &call->saved_sp));
         return Napi::Number::New(call->env, (double)f);
     }
     OP(RunFloat64) {
-        double d = WRAP(ForwardCallD(call->native, (uint8_t *)base, &call->saved_sp));
+        double d = WRAP(ForwardCallD(call->native, base, &call->saved_sp));
         return Napi::Number::New(call->env, d);
     }
     OP(RunPrototype) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunAggregateG) {
-        auto ret = WRAP(ForwardCallG(call->native, (uint8_t *)base, &call->saved_sp));
-        return DecodeObject(call->env, (const uint8_t *)&ret, inst->type);
+        auto ret = WRAP(ForwardCallG(call->native, base, &call->saved_sp));
+        return DecodeObject(call->instance, (const uint8_t *)&ret, inst->type);
     }
     OP(RunAggregateF) {
-        auto ret = WRAP(ForwardCallF(call->native, (uint8_t *)base, &call->saved_sp));
-        return DecodeObject(call->env, (const uint8_t *)&ret, inst->type);
+        auto ret = WRAP(ForwardCallF(call->native, base, &call->saved_sp));
+        return DecodeObject(call->instance, (const uint8_t *)&ret, inst->type);
     }
     OP(RunAggregateD) {
-        auto ret = WRAP(ForwardCallD(call->native, (uint8_t *)base, &call->saved_sp));
-        return DecodeObject(call->env, (const uint8_t *)&ret, inst->type);
+        auto ret = WRAP(ForwardCallD(call->native, base, &call->saved_sp));
+        return DecodeObject(call->instance, (const uint8_t *)&ret, inst->type);
     }
-    OP(RunAggregateStack) {
+    OP(RunAggregateMem) {
         *(uint8_t **)base = call->AllocHeap(inst->a);
-        uint32_t eax = (uint32_t)WRAP(ForwardCallG(call->native, (uint8_t *)base, &call->saved_sp));
-        return DecodeObject(call->env, (const uint8_t *)eax, inst->type);
+        uint32_t eax = (uint32_t)WRAP(ForwardCallG(call->native, base, &call->saved_sp));
+        return DecodeObject(call->instance, (const uint8_t *)eax, inst->type);
     }
     OP(RunVoidR) {
-        WRAP(ForwardCallGR(call->native, (uint8_t *)base, &call->saved_sp));
+        WRAP(ForwardCallGR(call->native, base, &call->saved_sp));
         return nullptr;
     }
     OP(RunBoolR) {
-        uint32_t eax = (uint32_t)WRAP(ForwardCallGR(call->native, (uint8_t *)base, &call->saved_sp));
+        uint32_t eax = (uint32_t)WRAP(ForwardCallGR(call->native, base, &call->saved_sp));
         return Napi::Boolean::New(call->env, eax & 0x1);
     }
     OP(RunInt8R) { INTEGER32(GR, int8_t); }
@@ -609,65 +609,65 @@ napi_value RunLoop(CallData *call, napi_value *args, uint32_t *base, const AbiIn
     OP(RunUInt64R) { INTEGER64(GR, uint64_t); }
     OP(RunUInt64SR) { INTEGER64_SWAP(GR, uint64_t); }
     OP(RunStringR) {
-        uint32_t eax = (uint32_t)WRAP(ForwardCallGR(call->native, (uint8_t *)base, &call->saved_sp));
+        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();
         DISPOSE((void *)eax);
         return value;
     }
     OP(RunString16R) {
-        uint32_t eax = (uint32_t)WRAP(ForwardCallGR(call->native, (uint8_t *)base, &call->saved_sp));
+        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();
         DISPOSE((void *)eax);
         return value;
     }
     OP(RunString32R) {
-        uint32_t eax = (uint32_t)WRAP(ForwardCallGR(call->native, (uint8_t *)base, &call->saved_sp));
+        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();
         DISPOSE((void *)eax);
         return value;
     }
     OP(RunPointerR) {
-        uint32_t eax = (uint32_t)WRAP(ForwardCallGR(call->native, (uint8_t *)base, &call->saved_sp));
+        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();
         DISPOSE((void *)eax);
         return value;
     }
     OP(RunCallbackR) {
-        uint32_t eax = (uint32_t)WRAP(ForwardCallGR(call->native, (uint8_t *)base, &call->saved_sp));
+        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();
     }
     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, (uint8_t *)base, &call->saved_sp));
+        float f = WRAP(ForwardCallFR(call->native, base, &call->saved_sp));
         return Napi::Number::New(call->env, (double)f);
     }
     OP(RunFloat64R) {
-        double d = WRAP(ForwardCallDR(call->native, (uint8_t *)base, &call->saved_sp));
+        double d = WRAP(ForwardCallDR(call->native, base, &call->saved_sp));
         return Napi::Number::New(call->env, d);
     }
     OP(RunPrototypeR) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunAggregateGR) {
-        auto ret = WRAP(ForwardCallGR(call->native, (uint8_t *)base, &call->saved_sp));
-        return DecodeObject(call->env, (const uint8_t *)&ret, inst->type);
+        auto ret = WRAP(ForwardCallGR(call->native, base, &call->saved_sp));
+        return DecodeObject(call->instance, (const uint8_t *)&ret, inst->type);
     }
     OP(RunAggregateFR) {
-        auto ret = WRAP(ForwardCallFR(call->native, (uint8_t *)base, &call->saved_sp));
-        return DecodeObject(call->env, (const uint8_t *)&ret, inst->type);
+        auto ret = WRAP(ForwardCallFR(call->native, base, &call->saved_sp));
+        return DecodeObject(call->instance, (const uint8_t *)&ret, inst->type);
     }
     OP(RunAggregateDR) {
-        auto ret = WRAP(ForwardCallDR(call->native, (uint8_t *)base, &call->saved_sp));
-        return DecodeObject(call->env, (const uint8_t *)&ret, inst->type);
+        auto ret = WRAP(ForwardCallDR(call->native, base, &call->saved_sp));
+        return DecodeObject(call->instance, (const uint8_t *)&ret, inst->type);
     }
-    OP(RunAggregateStackR) {
+    OP(RunAggregateMemR) {
 #if defined(_WIN32)
-        *(uint8_t **)(base + 4) = call->AllocHeap(inst->a);
+        *(uint8_t **)(base + 16) = call->AllocHeap(inst->a);
 #else
         *(uint8_t **)base = call->AllocHeap(inst->a);
 #endif
-        uint32_t eax = (uint32_t)WRAP(ForwardCallGR(call->native, (uint8_t *)base, &call->saved_sp));
-        return DecodeObject(call->env, (const uint8_t *)eax, inst->type);
+        uint32_t eax = (uint32_t)WRAP(ForwardCallGR(call->native, base, &call->saved_sp));
+        return DecodeObject(call->instance, (const uint8_t *)eax, inst->type);
     }
 
 #undef DISPOSE
@@ -678,7 +678,7 @@ napi_value RunLoop(CallData *call, napi_value *args, uint32_t *base, const AbiIn
 
 #define CALL(Suffix) \
         do { \
-            auto ret = WRAP(ForwardCall ## Suffix(call->native, (uint8_t *)base, &call->saved_sp)); \
+            auto ret = WRAP(ForwardCall ## Suffix(call->native, base, &call->saved_sp)); \
             memcpy(base, &ret, K_SIZE(ret)); \
         } while (false)
 #define DISPOSE() \
@@ -711,6 +711,7 @@ napi_value RunLoop(CallData *call, napi_value *args, uint32_t *base, const AbiIn
 
     OP(Yield) {
         call->async_ip = inst + 1;
+        call->async_base = base;
         return nullptr;
     }
 
@@ -727,7 +728,7 @@ napi_value RunLoop(CallData *call, napi_value *args, uint32_t *base, const AbiIn
     OP(CallDR) { CALL(DR); return nullptr; }
     OP(CallStackR) {
 #if defined(_WIN32)
-        *(uint8_t **)(base + 4) = call->AllocHeap(inst->a);
+        *(uint8_t **)(base + 16) = call->AllocHeap(inst->a);
 #else
         *(uint8_t **)base = call->AllocHeap(inst->a);
 #endif
@@ -794,10 +795,10 @@ napi_value RunLoop(CallData *call, napi_value *args, uint32_t *base, const AbiIn
         return Napi::Number::New(call->env, d);
     }
     OP(ReturnPrototype) { K_UNREACHABLE(); return call->env.Null(); }
-    OP(ReturnAggregateReg) { return DecodeObject(call->env, (const uint8_t *)base, inst->type); }
-    OP(ReturnAggregateStack) {
+    OP(ReturnAggregateReg) { return DecodeObject(call->instance, (const uint8_t *)base, inst->type); }
+    OP(ReturnAggregateMem) {
         uint32_t eax = *(uint32_t *)base;
-        return DecodeObject(call->env, (const uint8_t *)eax, inst->type);
+        return DecodeObject(call->instance, (const uint8_t *)eax, inst->type);
     }
 
 #undef DISPOSE
@@ -821,7 +822,7 @@ napi_value CallData::Run(const FunctionInfo *func, napi_value *args)
         return env.Null();
 
     const AbiInstruction *first = func->sync.ptr;
-    return RunLoop(this, args, (uint32_t *)base, first);
+    return RunLoop(this, args, base, first);
 }
 
 bool CallData::PrepareAsync(const FunctionInfo *func, napi_value *args)
@@ -832,19 +833,19 @@ bool CallData::PrepareAsync(const FunctionInfo *func, napi_value *args)
     async_base = base;
 
     const AbiInstruction *first = func->async.ptr;
-    return !RunLoop(this, args, (uint32_t *)base, first); // Yield returns nullptr
+    return !RunLoop(this, args, base, first); // Yield returns nullptr
 }
 
 void CallData::ExecuteAsync()
 {
     const AbiInstruction *next = async_ip++;
-    RunLoop(this, nullptr, (uint32_t *)async_base, next);
+    RunLoop(this, nullptr, async_base, next);
 }
 
 napi_value CallData::EndAsync()
 {
     const AbiInstruction *next = async_ip++;
-    return RunLoop(this, nullptr, (uint32_t *)async_base, next);
+    return RunLoop(this, nullptr, async_base, next);
 }
 
 void CallData::Relay(Size idx, uint8_t *sp)
@@ -1000,7 +1001,7 @@ void CallData::Relay(Size idx, uint8_t *sp)
             case PrimitiveKind::Record:
             case PrimitiveKind::Union: {
                 uint8_t *ptr = (uint8_t *)args_ptr;
-                arguments[i] = DecodeObject(env, ptr, param.type);
+                arguments[i] = DecodeObject(instance, ptr, param.type);
 
                 args_ptr = (uint32_t *)AlignUp(ptr + param.type->size, 4);
             } break;

package/src/koffi/src/call.cc

@@ -68,7 +68,7 @@ void CallData::Finalize()
                         K_ASSERT(IsArray(env, value));
 
                         uint32_t len = GetArrayLength(env, value);
-                        DecodeElements(env, value, out.ptr, out.type, len);
+                        DecodeElements(instance, value, out.ptr, out.type, len);
                     } break;
 
                     case OutArgument::Kind::Buffer: {
@@ -117,7 +117,7 @@ void CallData::Finalize()
 
                             u->SetRaw(out.ptr);
                         } else {
-                            DecodeObject(env, value, out.ptr, out.type->ref.type);
+                            DecodeObject(instance, value, out.ptr, out.type->ref.type);
                         }
                     } break;
                 }

package/src/koffi/src/ffi.cc

@@ -37,10 +37,12 @@ namespace K {
 
 SharedData shared;
 
-// Some N-API functions are loaded dynamically to work around bugs or because they are recent
+// Some Node-API functions are loaded dynamically to work around bugs or because they are recent
 napi_status (NAPI_CDECL *node_api_get_buffer_info)(napi_env env, napi_value value, void **data, size_t *length);
 napi_status (NAPI_CDECL *node_api_create_property_key_utf8)(napi_env env, const char* str, size_t length, napi_value* result);
 napi_status (NAPI_CDECL *node_api_post_finalizer)(node_api_basic_env env, napi_finalize finalize_cb, void* finalize_data, void* finalize_hint);
+napi_status (NAPI_CDECL *node_api_create_object_with_properties)(napi_env env, napi_value prototype_or_null, const napi_value *property_names,
+                                                                 const napi_value *property_values, size_t property_count, napi_value *result);
 napi_value (*translate_zero_call)(napi_env env, napi_callback_info info);
 
 static bool ChangeSize(const char *name, Napi::Value value, Size min_size, Size max_size, Size *out_size)
@@ -254,7 +256,11 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
 
     bool skip = (info.Length() > 1);
     bool named = skip && !IsNullOrUndefined(env, info[0]);
+#if defined(EXTERNAL_TYPES)
+    bool redefine = named && info[0].IsExternal() && CheckValueTag(env, info[0], &TypeObjectMarker);
+#else
     bool redefine = named && info[0].IsObject() && CheckValueTag(env, info[0], &TypeObjectMarker);
+#endif
 
     if (named && !info[0].IsString() && !redefine) {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string", GetValueType(instance, info[0]));
@@ -288,10 +294,16 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
     TypeInfo *replace = nullptr;
 
     if (redefine) {
+#if defined(EXTERNAL_TYPES)
+        Napi::External<TypeInfo> external = name.As<Napi::External<TypeInfo>>();
+        replace = external.Data();
+#else
         TypeObject *defn = nullptr;
         napi_unwrap(env, name, (void **)&defn);
 
         replace = (TypeInfo *)defn->GetType();
+#endif
+
         type->name = replace->name;
 
         if (replace->primitive != PrimitiveKind::Void || replace == instance->void_type) {
@@ -442,7 +454,11 @@ static Napi::Value CreateUnionType(const Napi::CallbackInfo &info)
 
     bool skip = (info.Length() > 1);
     bool named = skip && !IsNullOrUndefined(env, info[0]);
+#if defined(EXTERNAL_TYPES)
+    bool redefine = named && info[0].IsExternal() && CheckValueTag(env, info[0], &TypeObjectMarker);
+#else
     bool redefine = named && info[0].IsObject() && CheckValueTag(env, info[0], &TypeObjectMarker);
+#endif
 
     if (named && !info[0].IsString() && !redefine) {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string", GetValueType(instance, info[0]));
@@ -476,10 +492,16 @@ static Napi::Value CreateUnionType(const Napi::CallbackInfo &info)
     TypeInfo *replace = nullptr;
 
     if (redefine) {
+#if defined(EXTERNAL_TYPES)
+        Napi::External<TypeInfo> external = name.As<Napi::External<TypeInfo>>();
+        replace = external.Data();
+#else
         TypeObject *defn = nullptr;
         napi_unwrap(env, name, (void **)&defn);
 
         replace = (TypeInfo *)defn->GetType();
+#endif
+
         type->name = replace->name;
 
         if (replace->primitive != PrimitiveKind::Void || replace == instance->void_type) {
@@ -1338,12 +1360,13 @@ static Napi::Value CreateEnumType(const Napi::CallbackInfo &info)
         return env.Null();
     err_guard.Disable();
 
-    Napi::Object defn = WrapType(env, type, false);
+    Napi::Value wrapper = WrapType(env, type, false);
+    Napi::Object defn = type->defn.Value();
 
     defn.Set("values", values);
     defn.Freeze();
 
-    return defn;
+    return wrapper;
 }
 
 static Napi::Value CreateTypeAlias(const Napi::CallbackInfo &info)
@@ -1390,6 +1413,29 @@ static Napi::Value GetResolvedType(const Napi::CallbackInfo &info)
     return WrapType(env, type);
 }
 
+#if defined(EXTERNAL_TYPES)
+
+static Napi::Value GetTypeDefinition(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 1) {
+        ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", info.Length());
+        return env.Null();
+    }
+
+    const TypeInfo *type = ResolveType(info[0]);
+    if (!type)
+        return env.Null();
+
+    // Make sure definition is available
+    WrapType(env, type);
+
+    return type->defn.Value();
+}
+
+#endif
+
 InstanceMemory *AllocateMemory(InstanceData *instance, Size stack_size, Size heap_size)
 {
     std::lock_guard<std::mutex> lock(instance->mem_mutex);
@@ -1878,11 +1924,11 @@ static Napi::Value DecodeValue(const Napi::CallbackInfo &info)
     if (has_len) {
         Size len = info[2 + has_offset].As<Napi::Number>();
 
-        Napi::Value ret = Decode(value, (Size)offset, type, &len);
-        return ret;
+        napi_value ret = Decode(value, (Size)offset, type, &len);
+        return Napi::Value(env, ret);
     } else {
-        Napi::Value ret = Decode(value, (Size)offset, type);
-        return ret;
+        napi_value ret = Decode(value, (Size)offset, type);
+        return Napi::Value(env, ret);
     }
 }
 
@@ -2417,7 +2463,7 @@ static napi_value CreateFunction(napi_env env, napi_callback native, const char
 
 static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
 {
-    // Load recent N-API functions (version >= 9) functions dynamically
+    // Load recent Node-API functions (version >= 9) functions dynamically
     {
         static std::once_flag flag;
 
@@ -2464,6 +2510,8 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
                 node_api_post_finalizer = SYMBOL(node_api_post_finalizer);
             }
 
+            node_api_create_object_with_properties = SYMBOL(node_api_create_object_with_properties);
+
 #undef SYMBOL
         });
     }
@@ -2495,6 +2543,9 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
     exports.Set("enumeration", Napi::Function::New(env, CreateEnumType, "enumeration"));
 
     exports.Set("type", Napi::Function::New(env, GetResolvedType, "type"));
+#if defined(EXTERNAL_TYPES)
+    exports.Set("introspect", Napi::Function::New(env, GetTypeDefinition, "introspect"));
+#endif
 
     exports.Set("load", Napi::Function::New(env, LoadSharedLibrary, "load"));
 
@@ -2573,13 +2624,18 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
 
     // Init object classes and symbols
     {
+        instance->object_constructor = Napi::Persistent(env.RunScript("Object.prototype").As<Napi::Object>());
         instance->construct_lib = Napi::Persistent(LibraryHandle::InitClass(env));
+#if !defined(EXTERNAL_TYPES)
         instance->construct_type = Napi::Persistent(TypeObject::InitClass(env));
+#endif
         instance->construct_poll = Napi::Persistent(PollHandle::InitClass(env));
         instance->active_symbol = Napi::Persistent(Napi::Symbol::New(env, "active"));
 
         exports.Set("LibraryHandle", instance->construct_lib.Value());
+#if !defined(EXTERNAL_TYPES)
         exports.Set("TypeObject", instance->construct_type.Value());
+#endif
     }
 
     // Init base types

package/src/koffi/src/ffi.hh

@@ -9,6 +9,9 @@
 
 namespace K {
 
+// #define EXTERNAL_POINTERS
+// #define EXTERNAL_TYPES
+
 static const Size DefaultSyncStackSize = Mebibytes(1);
 static const Size DefaultSyncHeapSize = Mebibytes(2);
 static const Size DefaultAsyncStackSize = Kibibytes(128);
@@ -66,11 +69,6 @@ struct RecordMember {
 struct TypeInfo {
     const char *name;
 
-    // Make sure primitive ends up as the upper N-API tag value when we cast TypeInfo pointers to
-    // napi_type_tag pointers. Yes, I want to do this. We don't do strict aliasing here.
-    // N.B. Some node versions don't like when one of the two tag values is 0, so make sure
-    // this does not happen! It would happen if primitive is 0 and size is 0. To avoid this
-    // situation, PrimitiveKind::Void (the only type with size 0) is explictly not 0.
     alignas(8) PrimitiveKind primitive;
     int32_t size;
     int16_t align;
@@ -309,8 +307,11 @@ struct InstanceData {
     const TypeInfo *str16_type;
     const TypeInfo *str32_type;
 
+    Napi::ObjectReference object_constructor;
     Napi::FunctionReference construct_lib;
+#if !defined(EXTERNAL_TYPES)
     Napi::FunctionReference construct_type;
+#endif
     Napi::FunctionReference construct_poll;
     Napi::Reference<Napi::Symbol> active_symbol;
 
@@ -390,10 +391,12 @@ static_assert(MaxTrampolines <= INT16_MAX);
 
 extern SharedData shared;
 
-// Some N-API functions are loaded dynamically to work around bugs or because they are recent
+// Some Node-API functions are loaded dynamically to work around bugs or because they are recent
 extern napi_status (NAPI_CDECL *node_api_get_buffer_info)(napi_env env, napi_value value, void **data, size_t *length);
 extern napi_status (NAPI_CDECL *node_api_create_property_key_utf8)(napi_env env, const char* str, size_t length, napi_value* result);
 extern napi_status (NAPI_CDECL *node_api_post_finalizer)(node_api_basic_env env, napi_finalize finalize_cb, void* finalize_data, void* finalize_hint);
+extern napi_status (NAPI_CDECL *node_api_create_object_with_properties)(napi_env env, napi_value prototype_or_null, const napi_value *property_names,
+                                                                        const napi_value *property_values, size_t property_count, napi_value *result);
 extern napi_value (*translate_zero_call)(napi_env env, napi_callback_info info);
 
 InstanceMemory *AllocateMemory(InstanceData *instance, Size stack_size, Size heap_size);

package/src/koffi/src/primitives.inc

@@ -5,11 +5,8 @@
     #error Please define PRIMITIVE() before including primitives.inc
 #endif
 
-// Void is explictly not first so that it is not 0, for reasons related to N-API type tags.
-// Look at TypeInfo definition for more information!
-
-PRIMITIVE(Bool)
 PRIMITIVE(Void)
+PRIMITIVE(Bool)
 PRIMITIVE(Int8)
 PRIMITIVE(UInt8)
 PRIMITIVE(Int16)