koffi 3.0.0-alpha.11 → 3.0.0-alpha.12

package/index.d.ts

@@ -121,18 +121,49 @@ export function register(callback: Function, type: TypeSpec): bigint;
 export function unregister(callback: bigint): void;
 
 export function as(value: any, type: TypeSpec): IKoffiPointerCast;
-export function decode(value: any, type: TypeSpec): any;
-export function decode(value: any, type: TypeSpec, len: number): any;
-export function decode(value: any, offset: number, type: TypeSpec): any;
-export function decode(value: any, offset: number, type: TypeSpec, len: number): any;
 export function address(value: any): bigint;
 export function call(value: any, type: TypeSpec, ...args: any[]): any;
+export function view(ref: any, len: number): ArrayBuffer;
+
+export const decode: {
+    (value: any, type: TypeSpec): any;
+    (value: any, type: TypeSpec, len: number): any;
+    (value: any, offset: number, type: TypeSpec): any;
+    (value: any, offset: number, type: TypeSpec, len: number): any;
+
+    char(ptr: any): number;
+    short(ptr: any): number;
+    int(ptr: any): number;
+    long(ptr: any): number | bigint;
+    longlong(ptr: any): number | bigint;
+    uchar(ptr: any): number;
+    ushort(ptr: any): number;
+    uint(ptr: any): number;
+    ulong(ptr: any): number | bigint;
+    ulonglong(ptr: any): number | bigint;
+
+    int8(ptr: any): number;
+    int16(ptr: any): number;
+    int32(ptr: any): number;
+    int64(ptr: any): number | bigint;
+    uint8(ptr: any): number;
+    uint16(ptr: any): number;
+    uint32(ptr: any): number;
+    uint64(ptr: any): number | bigint;
+
+    float(ptr: any): number;
+    double(ptr: any): number;
+
+    string(ptr: any, length?: number | bigint | null): string;
+    string16(ptr: any, length?: number | bigint | null): string;
+    string32(ptr: any, length?: number | bigint | null): string;
+};
+
 export function encode(ref: any, type: TypeSpec, value: any): void;
 export function encode(ref: any, type: TypeSpec, value: any, len: number): void;
 export function encode(ref: any, offset: number, type: TypeSpec): void;
 export function encode(ref: any, offset: number, type: TypeSpec, value: any): void;
 export function encode(ref: any, offset: number, type: TypeSpec, value: any, len: number): void;
-export function view(ref: any, len: number): ArrayBuffer;
 
 export function type(type: TypeSpec): TypeObject;
 export function sizeof(type: TypeSpec): number;

package/lib/native/base/base.cc

@@ -2082,6 +2082,9 @@ bool GetDebugFlag(const char *name)
         if (!ParseBool(debug, &ret, K_DEFAULT_PARSE_FLAGS & ~(int)ParseFlag::Log)) {
             LogError("Environment variable '%1' is not a boolean", name);
         }
+        if (ret) {
+            LogWarning("Debug flag '%1' is in effect", name);
+        }
         return ret;
     } else {
         return false;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "koffi",
-    "version": "3.0.0-alpha.11",
+    "version": "3.0.0-alpha.12",
     "description": "Fast and simple C FFI (foreign function interface) for Node.js",
     "keywords": [
         "foreign",

package/src/koffi/index.cjs

@@ -131,7 +131,7 @@ var init_abi = __esm({
 var package_default;
 var init_package = __esm({
   "package.json"() {
-    package_default = { name: "koffi", version: "3.0.0-alpha.11", cnoke: { api: "../../vendor/node-api-headers", output: "../../bin/Koffi/{{ toolchain }}", node: 16, napi: 8 } };
+    package_default = { name: "koffi", version: "3.0.0-alpha.12", cnoke: { api: "../../vendor/node-api-headers", output: "../../bin/Koffi/{{ toolchain }}", node: 16, napi: 8 } };
   }
 });
 

package/src/koffi/index.js

@@ -94,7 +94,7 @@ function decodeElfHeader(buf) {
 }
 
 // package.json
-var package_default = { name: "koffi", version: "3.0.0-alpha.11", cnoke: { api: "../../vendor/node-api-headers", output: "../../bin/Koffi/{{ toolchain }}", node: 16, napi: 8 } };
+var package_default = { name: "koffi", version: "3.0.0-alpha.12", cnoke: { api: "../../vendor/node-api-headers", output: "../../bin/Koffi/{{ toolchain }}", node: 16, napi: 8 } };
 
 // src/init.js
 var requireNative = createRequire(import.meta.url);

package/src/koffi/indirect.cjs

@@ -131,7 +131,7 @@ var init_abi = __esm({
 var package_default;
 var init_package = __esm({
   "package.json"() {
-    package_default = { name: "koffi", version: "3.0.0-alpha.11", cnoke: { api: "../../vendor/node-api-headers", output: "../../bin/Koffi/{{ toolchain }}", node: 16, napi: 8 } };
+    package_default = { name: "koffi", version: "3.0.0-alpha.12", cnoke: { api: "../../vendor/node-api-headers", output: "../../bin/Koffi/{{ toolchain }}", node: 16, napi: 8 } };
   }
 });
 

package/src/koffi/indirect.js

@@ -94,7 +94,7 @@ function decodeElfHeader(buf) {
 }
 
 // package.json
-var package_default = { name: "koffi", version: "3.0.0-alpha.11", cnoke: { api: "../../vendor/node-api-headers", output: "../../bin/Koffi/{{ toolchain }}", node: 16, napi: 8 } };
+var package_default = { name: "koffi", version: "3.0.0-alpha.12", cnoke: { api: "../../vendor/node-api-headers", output: "../../bin/Koffi/{{ toolchain }}", node: 16, napi: 8 } };
 
 // src/init.js
 var requireNative = createRequire(import.meta.url);

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

@@ -948,8 +948,8 @@ namespace {
     OP(CallStack) {
         uint8_t *ptr = call->AllocHeap(inst->a);
         *(uint8_t **)(base + 8 * 8) = ptr; // x8
-        CALL(GG);
-        *(uint8_t **)base = ptr; // Store pointer for ReturnAggregateStack
+        WRAP(ForwardCallGG(call->native, base, &call->saved_sp));
+        *(uint8_t **)base = ptr;
         return nullptr;
     }
     OP(CallGGX) {
@@ -962,8 +962,8 @@ namespace {
     OP(CallStackX) {
         uint8_t *ptr = call->AllocHeap(inst->a);
         *(uint8_t **)(base + 8 * 8) = ptr; // x8
-        CALL(GGX);
-        *(uint8_t **)base = ptr; // Store pointer for ReturnAggregateStack
+        WRAP(ForwardCallGGX(call->native, base, &call->saved_sp));
+        *(uint8_t **)base = ptr;
         return nullptr;
     }
 

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

@@ -82,7 +82,8 @@ enum class AbiOpcode {
     CallStackX,
     #define PRIMITIVE(Name) Return ## Name,
     #include "../primitives.inc"
-    ReturnAggregate
+    ReturnAggregateReg,
+    ReturnAggregateStack
 };
 
 enum class AbiMethod {
@@ -411,7 +412,7 @@ bool AnalyseFunction(Napi::Env, InstanceData *instance, FunctionInfo *func)
 
                     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::ReturnAggregate), .type = func->ret.type });
+                    func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregateStack), .type = func->ret.type });
                 } break;
 
                 case AbiMethod::Gpr:
@@ -422,7 +423,7 @@ bool AnalyseFunction(Napi::Env, InstanceData *instance, FunctionInfo *func)
 
                     func->sync.Append({ .op = Code2Op(run), .type = func->ret.type });
                     func->async.Append({ .op = Code2Op(call) });
-                    func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregate), .type = func->ret.type });
+                    func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregateReg), .type = func->ret.type });
                 } break;
                 case AbiMethod::Vec:
                 case AbiMethod::VecVec: {
@@ -431,7 +432,7 @@ bool AnalyseFunction(Napi::Env, InstanceData *instance, FunctionInfo *func)
 
                     func->sync.Append({ .op = Code2Op(run), .type = func->ret.type });
                     func->async.Append({ .op = Code2Op(call) });
-                    func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregate), .type = func->ret.type });
+                    func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregateReg), .type = func->ret.type });
                 } break;
                 case AbiMethod::GprVec: {
                     AbiOpcode run = func->forward_fp ? AbiOpcode::RunAggregateGDX : AbiOpcode::RunAggregateGD;
@@ -439,7 +440,7 @@ bool AnalyseFunction(Napi::Env, InstanceData *instance, FunctionInfo *func)
 
                     func->sync.Append({ .op = Code2Op(run), .type = func->ret.type });
                     func->async.Append({ .op = Code2Op(call) });
-                    func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregate), .type = func->ret.type });
+                    func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregateReg), .type = func->ret.type });
                 } break;
                 case AbiMethod::VecGpr: {
                     AbiOpcode run = func->forward_fp ? AbiOpcode::RunAggregateDGX : AbiOpcode::RunAggregateDG;
@@ -447,7 +448,7 @@ bool AnalyseFunction(Napi::Env, InstanceData *instance, FunctionInfo *func)
 
                     func->sync.Append({ .op = Code2Op(run), .type = func->ret.type });
                     func->async.Append({ .op = Code2Op(call) });
-                    func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregate), .type = func->ret.type });
+                    func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregateReg), .type = func->ret.type });
                 } break;
             }
         } break;
@@ -964,7 +965,8 @@ namespace {
         return Napi::Number::New(call->env, d);
     }
     OP(ReturnPrototype) { K_UNREACHABLE(); return call->env.Null(); }
-    OP(ReturnAggregate) {
+    OP(ReturnAggregateReg) { return DecodeObject(call->env, (const uint8_t *)base, inst->type); }
+    OP(ReturnAggregateStack) {
         uint64_t a0 = *(uint64_t *)base;
         return DecodeObject(call->env, (const uint8_t *)a0, inst->type);
     }
@@ -1009,7 +1011,8 @@ namespace {
         HandleCallStackX,
         #define PRIMITIVE(Name) HandleReturn ## Name,
         #include "../primitives.inc"
-        HandleReturnAggregate
+        HandleReturnAggregateReg,
+        HandleReturnAggregateStack
     };
 
     FORCE_INLINE napi_value RunLoop(CallData *call, napi_value *args, uint8_t *base, const AbiInstruction *inst)

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

@@ -82,7 +82,8 @@ enum class AbiOpcode {
     CallStackX,
     #define PRIMITIVE(Name) Return ## Name,
     #include "../primitives.inc"
-    ReturnAggregate
+    ReturnAggregateReg,
+    ReturnAggregateStack
 };
 
 enum class AbiMethod {
@@ -454,9 +455,9 @@ bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
                     AbiOpcode run = func->forward_fp ? AbiOpcode::RunAggregateStackX : AbiOpcode::RunAggregateStack;
                     AbiOpcode call = func->forward_fp ? AbiOpcode::CallStackX : AbiOpcode::CallStack;
 
-                    func->sync.Append({ .op = Code2Op(run), .a = (int32_t)func->stk_size, .type = func->ret.type });
-                    func->async.Append({ .op = Code2Op(call), .a = (int32_t)func->stk_size });
-                    func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregate), .type = func->ret.type });
+                    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 });
 
                     // Allocate stack space for return value
                     func->stk_size += AlignLen(func->ret.type->size, 16);
@@ -467,7 +468,7 @@ bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
 
                     func->sync.Append({ .op = Code2Op(run), .type = func->ret.type });
                     func->async.Append({ .op = Code2Op(call) });
-                    func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregate), .type = func->ret.type });
+                    func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregateReg), .type = func->ret.type });
                 } break;
                 case AbiMethod::GprGpr: {
                     AbiOpcode run = func->forward_fp ? AbiOpcode::RunAggregateGGX : AbiOpcode::RunAggregateGG;
@@ -475,7 +476,7 @@ bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
 
                     func->sync.Append({ .op = Code2Op(run), .type = func->ret.type });
                     func->async.Append({ .op = Code2Op(call) });
-                    func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregate), .type = func->ret.type });
+                    func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregateReg), .type = func->ret.type });
                 } break;
                 case AbiMethod::Xmm: {
                     AbiOpcode run = func->forward_fp ? AbiOpcode::RunAggregateDDX : AbiOpcode::RunAggregateDD;
@@ -483,7 +484,7 @@ bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
 
                     func->sync.Append({ .op = Code2Op(run), .type = func->ret.type });
                     func->async.Append({ .op = Code2Op(call) });
-                    func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregate), .type = func->ret.type });
+                    func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregateReg), .type = func->ret.type });
                 } break;
                 case AbiMethod::XmmXmm: {
                     AbiOpcode run = func->forward_fp ? AbiOpcode::RunAggregateDDX : AbiOpcode::RunAggregateDD;
@@ -491,7 +492,7 @@ bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
 
                     func->sync.Append({ .op = Code2Op(run), .type = func->ret.type });
                     func->async.Append({ .op = Code2Op(call) });
-                    func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregate), .type = func->ret.type });
+                    func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregateReg), .type = func->ret.type });
                 } break;
                 case AbiMethod::GprXmm: {
                     AbiOpcode run = func->forward_fp ? AbiOpcode::RunAggregateGDX : AbiOpcode::RunAggregateGD;
@@ -499,7 +500,7 @@ bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
 
                     func->sync.Append({ .op = Code2Op(run), .type = func->ret.type });
                     func->async.Append({ .op = Code2Op(call) });
-                    func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregate), .type = func->ret.type });
+                    func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregateReg), .type = func->ret.type });
                 } break;
                 case AbiMethod::XmmGpr: {
                     AbiOpcode run = func->forward_fp ? AbiOpcode::RunAggregateDGX : AbiOpcode::RunAggregateDG;
@@ -507,7 +508,7 @@ bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
 
                     func->sync.Append({ .op = Code2Op(run), .type = func->ret.type });
                     func->async.Append({ .op = Code2Op(call) });
-                    func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregate), .type = func->ret.type });
+                    func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregateReg), .type = func->ret.type });
                 } break;
             }
         } break;
@@ -815,9 +816,10 @@ namespace {
         return DecodeObject(call->env, (const uint8_t *)&ret, inst->type);
     }
     OP(RunAggregateStack) {
-        *(uint8_t **)base = base + inst->a;
-        uint64_t rax = WRAP(ForwardCallGG(call->native, base, &call->saved_sp).rax);
-        return DecodeObject(call->env, (const uint8_t *)rax, inst->type);
+        uint8_t *ptr = call->AllocHeap(inst->a);
+        *(uint8_t **)base = ptr;
+        WRAP(ForwardCallGG(call->native, base, &call->saved_sp).rax);
+        return DecodeObject(call->env, ptr, inst->type);
     }
     OP(RunVoidX) {
         WRAP(ForwardCallGGX(call->native, base, &call->saved_sp));
@@ -898,9 +900,10 @@ namespace {
         return DecodeObject(call->env, (const uint8_t *)&ret, inst->type);
     }
     OP(RunAggregateStackX) {
-        *(uint8_t **)base = base + inst->a;
-        uint64_t rax = WRAP(ForwardCallGGX(call->native, base, &call->saved_sp).rax);
-        return DecodeObject(call->env, (const uint8_t *)rax, inst->type);
+        uint8_t *ptr = call->AllocHeap(inst->a);
+        *(uint8_t **)base = ptr;
+        WRAP(ForwardCallGGX(call->native, base, &call->saved_sp).rax);
+        return DecodeObject(call->env, ptr, inst->type);
     }
 
 #undef DISPOSE
@@ -941,7 +944,8 @@ namespace {
     OP(CallGD) { CALL(GD); return nullptr; }
     OP(CallDD) { CALL(DD); return nullptr; }
     OP(CallStack) {
-        *(uint8_t **)base = base + inst->a;
+        uint8_t *ptr = call->AllocHeap(inst->a);
+        *(uint8_t **)base = ptr;
         CALL(GG);
         return nullptr;
     }
@@ -951,7 +955,8 @@ namespace {
     OP(CallGDX) { CALL(GDX); return nullptr; }
     OP(CallDDX) { CALL(DDX); return nullptr; }
     OP(CallStackX) {
-        *(uint8_t **)base = base + inst->a;
+        uint8_t *ptr = call->AllocHeap(inst->a);
+        *(uint8_t **)base = ptr;
         CALL(GGX);
         return nullptr;
     }
@@ -1015,7 +1020,8 @@ namespace {
         return Napi::Number::New(call->env, d);
     }
     OP(ReturnPrototype) { K_UNREACHABLE(); return call->env.Null(); }
-    OP(ReturnAggregate) {
+    OP(ReturnAggregateReg) { return DecodeObject(call->env, base, inst->type); }
+    OP(ReturnAggregateStack) {
         uint64_t rax = *(uint64_t *)base;
         return DecodeObject(call->env, (const uint8_t *)rax, inst->type);
     }
@@ -1060,7 +1066,8 @@ namespace {
         HandleCallStackX,
         #define PRIMITIVE(Name) HandleReturn ## Name,
         #include "../primitives.inc"
-        HandleReturnAggregate
+        HandleReturnAggregateReg,
+        HandleReturnAggregateStack
     };
 
     FORCE_INLINE napi_value RunLoop(CallData *call, napi_value *args, uint8_t *base, const AbiInstruction *inst)

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

@@ -49,7 +49,8 @@ enum class AbiOpcode {
     CallStackX,
     #define PRIMITIVE(Name) Return ## Name,
     #include "../primitives.inc"
-    ReturnAggregate
+    ReturnAggregateReg,
+    ReturnAggregateStack
 };
 
 namespace {
@@ -172,14 +173,14 @@ bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
 
                 func->sync.Append({ .op = Code2Op(run), .type = func->ret.type });
                 func->async.Append({ .op = Code2Op(call) });
-                func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregate), .type = func->ret.type });
+                func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregateReg), .type = func->ret.type });
             } else {
                 AbiOpcode run = func->forward_fp ? AbiOpcode::RunAggregateStackX : AbiOpcode::RunAggregateStack;
                 AbiOpcode call = func->forward_fp ? AbiOpcode::CallStackX : 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::ReturnAggregate), .type = func->ret.type });
+                func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregateStack), .type = func->ret.type });
             }
         } break;
         case PrimitiveKind::Array: { K_UNREACHABLE(); } break;
@@ -597,7 +598,7 @@ namespace {
     OP(CallD) { CALL(D); return nullptr; }
     OP(CallStack) {
         *(uint8_t **)base = call->AllocHeap(inst->a);
-        CALL(G);
+        WRAP(ForwardCallG(call->native, (uint8_t *)base, &call->saved_sp));
         return nullptr;
     }
     OP(CallGX) { CALL(GX); return nullptr; }
@@ -605,7 +606,7 @@ namespace {
     OP(CallDX) { CALL(DX); return nullptr; }
     OP(CallStackX) {
         *(uint8_t **)base = call->AllocHeap(inst->a);
-        CALL(GX);
+        WRAP(ForwardCallGX(call->native, (uint8_t *)base, &call->saved_sp));
         return nullptr;
     }
 
@@ -668,7 +669,8 @@ namespace {
         return Napi::Number::New(call->env, d);
     }
     OP(ReturnPrototype) { K_UNREACHABLE(); return call->env.Null(); }
-    OP(ReturnAggregate) {
+    OP(ReturnAggregateReg) { return DecodeObject(call->env, (const uint8_t *)base, inst->type); }
+    OP(ReturnAggregateStack) {
         uint64_t rax = *(uint64_t *)base;
         return DecodeObject(call->env, (const uint8_t *)rax, inst->type);
     }
@@ -703,7 +705,8 @@ namespace {
         HandleCallStackX,
         #define PRIMITIVE(Name) HandleReturn ## Name,
         #include "../primitives.inc"
-        HandleReturnAggregate
+        HandleReturnAggregateReg,
+        HandleReturnAggregateStack
     };
 
     FORCE_INLINE napi_value RunLoop(CallData *call, napi_value *args, uint64_t *base, const AbiInstruction *inst)

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

@@ -60,7 +60,8 @@ enum class AbiOpcode {
     CallStackR,
     #define PRIMITIVE(Name) Return ## Name,
     #include "../primitives.inc"
-    ReturnAggregate
+    ReturnAggregateReg,
+    ReturnAggregateStack
 };
 
 static inline void *Code2Op(AbiOpcode code)
@@ -207,7 +208,7 @@ bool AnalyseFunction(Napi::Env env, InstanceData *instance, FunctionInfo *func)
 
                     func->sync.Append({ .op = Code2Op(run), .type = func->ret.type });
                     func->async.Append({ .op = Code2Op(call) });
-                    func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregate), .type = func->ret.type });
+                    func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregateReg), .type = func->ret.type });
 
                     break;
                 } else if (member.type->primitive == PrimitiveKind::Float64) {
@@ -216,7 +217,7 @@ bool AnalyseFunction(Napi::Env env, InstanceData *instance, FunctionInfo *func)
 
                     func->sync.Append({ .op = Code2Op(run), .type = func->ret.type });
                     func->async.Append({ .op = Code2Op(call) });
-                    func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregate), .type = func->ret.type });
+                    func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregateReg), .type = func->ret.type });
 
                     break;
                 }
@@ -229,14 +230,14 @@ bool AnalyseFunction(Napi::Env env, InstanceData *instance, FunctionInfo *func)
 
                 func->sync.Append({ .op = Code2Op(run), .type = func->ret.type });
                 func->async.Append({ .op = Code2Op(call) });
-                func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregate), .type = func->ret.type });
+                func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregateReg), .type = func->ret.type });
             } else {
                 AbiOpcode run = fast ? AbiOpcode::RunAggregateStackR : AbiOpcode::RunAggregateStack;
                 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::ReturnAggregate), .type = func->ret.type });
+                func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregateStack), .type = func->ret.type });
             }
         } break;
         case PrimitiveKind::Array: { K_UNREACHABLE(); } break;
@@ -793,8 +794,13 @@ 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(ReturnAggregate) {
+    OP(ReturnAggregateReg) { return DecodeObject(call->env, (const uint8_t *)base, inst->type); }
+    OP(ReturnAggregateStack) {
+#if defined(_WIN32)
+        uint32_t eax = *(uint32_t *)(base + 4);
+#else
         uint32_t eax = *(uint32_t *)base;
+#endif
         return DecodeObject(call->env, (const uint8_t *)eax, inst->type);
     }
 

package/src/koffi/src/call.cc

@@ -1220,15 +1220,12 @@ bool CallData::CheckDynamicLength(napi_value obj, Size element, const char *coun
     }
 
     // Get actual size
-    if (IsArray(env, value)) {
-        Napi::Array array = Napi::Array(env, value);
-        size = array.Length() * element;
-    } else if (IsTypedArray(env, value)) {
-        Napi::TypedArray typed = Napi::TypedArray(env, value);
-        size = typed.ByteLength();
-    } else if (IsArrayBuffer(env, value)) {
-        Napi::ArrayBuffer buffer = Napi::ArrayBuffer(env, value);
-        size = buffer.ByteLength();
+    if (uint32_t len = 0; napi_get_array_length(env, value, &len) == napi_ok) {
+        size = (int64_t)len * element;
+    } else if (size_t len = 0; node_api_get_buffer_info(env, value, nullptr, &len) == napi_ok) {
+        size = (int64_t)len;
+    } else if (size_t len = 0; napi_get_arraybuffer_info(env, value, nullptr, &len) == napi_ok) {
+        size = (int64_t)len;
     } else if (!IsNullOrUndefined(env, value)) {
         size = element;
     } else {
@@ -1245,7 +1242,7 @@ bool CallData::CheckDynamicLength(napi_value obj, Size element, const char *coun
 
 #if defined(K_DEBUG)
 
-static bool IsDebugEnabled()
+static bool IsDebugCallsEnabled()
 {
     static bool debug = GetDebugFlag("DEBUG_CALLS");
     return debug;
@@ -1253,7 +1250,7 @@ static bool IsDebugEnabled()
 
 void CallData::DebugCall(const FunctionInfo *func)
 {
-    if (!IsDebugEnabled())
+    if (!IsDebugCallsEnabled())
         return;
 
     PrintLn(StdErr, "%!..+---- %1 (%2) ----%!0", func->name, CallConventionNames[(int)func->convention]);
@@ -1271,7 +1268,7 @@ void CallData::DebugCall(const FunctionInfo *func)
 
 void CallData::DebugForward()
 {
-    if (!IsDebugEnabled())
+    if (!IsDebugCallsEnabled())
         return;
 
     Span<const uint8_t> stack = MakeSpan(mem->stack.end, prev_stack - mem->stack.end);
@@ -1382,13 +1379,12 @@ napi_value TranslateFastCall(napi_env env, napi_callback_info info)
     napi_status status = napi_get_cb_info(env, info, &count, args, nullptr, (void **)&func);
     K_ASSERT(status == napi_ok);
 
-    InstanceData *instance = func->instance;
-
     if (count < (size_t)func->required_parameters) [[unlikely]] {
         ThrowError<Napi::TypeError>(env, "Expected %1 arguments, got %2", func->parameters.len, count);
         return Napi::Env(env).Null();
     }
 
+    InstanceData *instance = func->instance;
     InstanceMemory *mem = instance->memories[0];
     CallData call(env, instance, mem, func->native);
 
@@ -1405,13 +1401,12 @@ napi_value TranslateFastCall(napi_env env, napi_callback_info info)
 
 static FORCE_INLINE napi_value TranslateNormalCall(napi_env env, const FunctionInfo *func, void *native, napi_value *args, Size count)
 {
-    InstanceData *instance = func->instance;
-
     if (count < func->required_parameters) [[unlikely]] {
         ThrowError<Napi::TypeError>(env, "Expected %1 arguments, got %2", func->parameters.len, count);
         return Napi::Env(env).Null();
     }
 
+    InstanceData *instance = func->instance;
     InstanceMemory *mem = instance->memories[0];
     CallData call(env, instance, mem, native);
 
@@ -1447,13 +1442,68 @@ napi_value TranslateNormalCall(napi_env env, napi_callback_info info)
     return TranslateNormalCall(env, func, func->native, args, (Size)count);
 }
 
-static napi_value TranslateVariadicCall(napi_env env, const FunctionInfo *func, void *native, napi_value *args, Size count)
+static FORCE_INLINE napi_value TranslateNormalCallDebugAsync(napi_env env, const FunctionInfo *func, void *native, napi_value *args, Size count)
 {
+    if (count < func->required_parameters) [[unlikely]] {
+        ThrowError<Napi::TypeError>(env, "Expected %1 arguments, got %2", func->parameters.len, count);
+        return Napi::Env(env).Null();
+    }
+
     InstanceData *instance = func->instance;
+    InstanceMemory *mem = instance->memories[0];
+    CallData call(env, instance, mem, native);
+
+    K_DEFER_C(prev_call = instance->sync_call) { instance->sync_call = prev_call; };
+    instance->sync_call = &call;
+
+    call.DebugCall(func);
+
+    // The async call code partly works differently, with Yield and Return instructions which do not
+    // get used for normal sync calls. To exercise them, we also run the sync tests using async
+    // instructions, by setting DEBUG_ASYNC=1.
+
+    napi_value ret;
+    if (call.PrepareAsync(func, args)) {
+        call.ExecuteAsync();
+        ret = call.EndAsync();
+    } else {
+        ret = Napi::Env(env).Null();
+    }
+    call.Finalize();
+
+    return ret;
+}
 
+napi_value TranslateNormalCallDebugAsync(napi_env env, napi_callback_info info)
+{
+    static_assert(MaxParameters >= 8);
+
+    napi_value args[MaxParameters];
+    size_t count = 8;
+    FunctionInfo *func;
+
+    napi_status status = napi_get_cb_info(env, info, &count, args, nullptr, (void **)&func);
+    K_ASSERT(status == napi_ok);
+
+    if (count > 8) {
+        napi_status status = napi_get_cb_info(env, info, &count, args, nullptr, nullptr);
+        K_ASSERT(status == napi_ok);
+
+        count = std::min(count, (size_t)MaxParameters);
+    }
+
+    return TranslateNormalCallDebugAsync(env, func, func->native, args, count);
+}
+
+static napi_value TranslateVariadicCall(napi_env env, const FunctionInfo *func, void *native, napi_value *args, Size count)
+{
     FunctionInfo *variadic = nullptr;
     K_DEFER_N(err_guard) { delete variadic; };
 
+    InstanceData *instance = func->instance;
+    InstanceMemory *mem = instance->memories[0];
+    CallData call(env, instance, mem, native);
+
     // Try cached function
     {
         FunctionInfo *prev = instance->variadic_func;
@@ -1531,9 +1581,6 @@ static napi_value TranslateVariadicCall(napi_env env, const FunctionInfo *func,
             return Napi::Env(env).Null();
     }
 
-    InstanceMemory *mem = instance->memories[0];
-    CallData call(env, instance, mem, native);
-
     K_DEFER_C(prev_call = instance->sync_call) { instance->sync_call = prev_call; };
     instance->sync_call = &call;
 

package/src/koffi/src/call.hh

@@ -170,6 +170,7 @@ bool InitAsyncBroker(Napi::Env env, InstanceData *instance);
 napi_value TranslateZeroCall(napi_env env, napi_callback_info info);
 napi_value TranslateFastCall(napi_env env, napi_callback_info info);
 napi_value TranslateNormalCall(napi_env env, napi_callback_info info);
+napi_value TranslateNormalCallDebugAsync(napi_env env, napi_callback_info info);
 napi_value TranslateVariadicCall(napi_env env, napi_callback_info info);
 napi_value TranslateAsyncCall(napi_env env, napi_callback_info info);
 

package/src/koffi/src/ffi.cc

@@ -37,7 +37,8 @@ namespace K {
 
 SharedData shared;
 
-// Recent N-API functions are loaded dynamically
+// Some N-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_value (*translate_zero_call)(napi_env env, napi_callback_info info);
@@ -2365,30 +2366,40 @@ static inline PrimitiveKind GetBigEndianPrimitive(PrimitiveKind kind)
 #endif
 }
 
-static bool CanReferencePrimitiveValues(napi_env env)
+static bool CanCallNapiGetBufferInfoDirectly(const napi_node_version &node, uint32_t napi)
 {
-    uint32_t version = 0;
-    napi_get_version(env, &version);
+    if (napi >= 10)
+        return true;
+    if (node.major >= 22)
+        return true;
 
-    return version >= 10;
+    // Made by looking at the git history of each release branch
+    if (node.major == 21 && node.minor >= 7)
+        return true;
+    if (node.major == 20 && node.minor >= 12)
+        return true;
+
+    return false;
 }
 
-static bool CanDeleteReferenceInFinalizer(napi_env env)
+static bool CanReferencePrimitiveValues(const napi_node_version &node, uint32_t napi)
 {
-    const napi_node_version *version = nullptr;
-    napi_get_node_version(env, &version);
+    return napi >= 10;
+}
 
-    if (version->major >= 24)
+static bool CanDeleteReferenceInFinalizer(const napi_node_version &node, uint32_t napi)
+{
+    if (node.major >= 24)
         return true;
 
     // Made by looking at the git history of each release branch
-    if (version->major == 23 && version->minor >= 5)
+    if (node.major == 23 && node.minor >= 5)
         return true;
-    if (version->major == 22 && version->minor >= 13)
+    if (node.major == 22 && node.minor >= 13)
         return true;
-    if (version->major == 20 && version->minor >= 19)
+    if (node.major == 20 && node.minor >= 19)
         return true;
-    if (version->major == 20 && version->minor == 18 && version->patch >= 3)
+    if (node.major == 20 && node.minor == 18 && node.patch >= 3)
         return true;
 
     return false;
@@ -2421,13 +2432,32 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
     #define SYMBOL(Symbol) ((decltype(Symbol))dlsym(h, K_STRINGIFY(Symbol)))
 #endif
 
-            if (CanReferencePrimitiveValues(env)) {
+            const napi_node_version *node_version = nullptr;
+            uint32_t napi_version = 0;
+            napi_get_node_version(env, &node_version);
+            napi_get_version(env, &napi_version);
+
+            if (CanCallNapiGetBufferInfoDirectly(*node_version, napi_version)) {
+                node_api_get_buffer_info = napi_get_buffer_info;
+            } else {
+                // Before Node 20.12, napi_get_buffer_info() would assert/crash
+                // when used with something it did not support, instead of returning napi_invalid_arg.
+                // So we need to call napi_is_buffer() for old versions before trying napi_get_buffer_info().
+
+                node_api_get_buffer_info = [](napi_env env, napi_value value, void **data, size_t *length) {
+                    if (!IsBuffer(env, value))
+                        return napi_invalid_arg;
+                    return napi_get_buffer_info(env, value, data, length);
+                };
+            }
+
+            if (CanReferencePrimitiveValues(*node_version, napi_version)) {
                 // We can't use optimized property keys in older versions because we need to create
                 // references to them, but napi_create_reference() was not usable with primitive values.
                 node_api_create_property_key_utf8 = SYMBOL(node_api_create_property_key_utf8);
             }
 
-            if (!CanDeleteReferenceInFinalizer(env)) {
+            if (!CanDeleteReferenceInFinalizer(*node_version, napi_version)) {
                 // napi_delete_reference cannot be safely used in older Node versions because it
                 // errors out (or even asserts) if it gets called in a finalizer. In this case,
                 // use experimental API to try to run it later.

package/src/koffi/src/ffi.hh

@@ -390,7 +390,8 @@ static_assert(MaxTrampolines <= INT16_MAX);
 
 extern SharedData shared;
 
-// Recent N-API functions are loaded dynamically
+// Some N-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_value (*translate_zero_call)(napi_env env, napi_callback_info info);

package/src/koffi/src/util.cc

@@ -1948,6 +1948,12 @@ Napi::Object DescribeFunction(Napi::Env env, const FunctionInfo *func)
     return meta;
 }
 
+static bool IsDebugAsyncEnabled()
+{
+    static bool debug = GetDebugFlag("DEBUG_ASYNC");
+    return debug;
+}
+
 Napi::Function WrapFunction(Napi::Env env, const FunctionInfo *func)
 {
     Napi::Function wrapper;
@@ -1959,6 +1965,9 @@ Napi::Function WrapFunction(Napi::Env env, const FunctionInfo *func)
         if (func->variadic) {
             napi_status status = napi_create_function(env, func->name, NAPI_AUTO_LENGTH, TranslateVariadicCall, (void *)func->Ref(), &value);
             K_ASSERT(status == napi_ok);
+        } else if (IsDebugAsyncEnabled()) {
+            napi_status status = napi_create_function(env, func->name, NAPI_AUTO_LENGTH, TranslateNormalCallDebugAsync, (void *)func->Ref(), &value);
+            K_ASSERT(status == napi_ok);
         } else if (!func->parameters.len) {
             InstanceData *instance = env.GetInstanceData<InstanceData>();
             napi_status status = napi_create_function(env, func->name, NAPI_AUTO_LENGTH, instance->translate_zero_call, (void *)func->Ref(), &value);

package/src/koffi/src/util.hh

@@ -275,10 +275,8 @@ static FORCE_INLINE bool TryPointer(napi_env env, napi_value value, void **out_p
         }
     }
 
-    if (IsTypedArray(env, value)) {
-        napi_get_typedarray_info(env, value, nullptr, nullptr, out_ptr, nullptr, nullptr);
+    if (node_api_get_buffer_info(env, value, out_ptr, nullptr) == napi_ok)
         return true;
-    }
 
     napi_valuetype kind = GetKindOf(env, value);
 
@@ -299,12 +297,10 @@ static FORCE_INLINE bool TryPointer(napi_env env, napi_value value, void **out_p
         *out_ptr = (void *)external.Data();
         return true;
 #endif
-    } else if (IsArrayBuffer(env, value)) {
-        Napi::ArrayBuffer buffer = Napi::ArrayBuffer(env, value);
+    }
 
-        *out_ptr = (void *)buffer.Data();
+    if (napi_get_arraybuffer_info(env, value, out_ptr, nullptr) == napi_ok)
         return true;
-    }
 
     return false;
 }
@@ -325,10 +321,8 @@ static FORCE_INLINE bool TryPointer(napi_env env, napi_value value, void **out_p
         }
     }
 
-    if (IsTypedArray(env, value)) {
-        napi_get_typedarray_info(env, value, nullptr, nullptr, out_ptr, nullptr, nullptr);
+    if (node_api_get_buffer_info(env, value, out_ptr, nullptr) == napi_ok) {
         *out_kind = napi_object;
-
         return true;
     }
 
@@ -357,12 +351,10 @@ static FORCE_INLINE bool TryPointer(napi_env env, napi_value value, void **out_p
 
         return true;
 #endif
-    } else if (IsArrayBuffer(env, value)) {
-        Napi::ArrayBuffer buffer = Napi::ArrayBuffer(env, value);
+    }
 
-        *out_ptr = (void *)buffer.Data();
+    if (napi_get_arraybuffer_info(env, value, out_ptr, nullptr) == napi_ok) {
         *out_kind = napi_object;
-
         return true;
     }
 
@@ -372,23 +364,14 @@ static FORCE_INLINE bool TryPointer(napi_env env, napi_value value, void **out_p
 
 static FORCE_INLINE bool TryBuffer(napi_env env, napi_value value, Span<uint8_t> *out_buffer)
 {
-    // Before somewhere around Node 20.12, napi_get_buffer_info() would assert/crash
-    // when used with something it did not support, instead of returning napi_invalid_arg.
-    // So we need to call napi_is_buffer(), at least for now.
-
-    if (IsBuffer(env, value)) {
-        void *ptr = nullptr;
-        size_t length = 0;
+    void *ptr = nullptr;
+    size_t len = 0;
 
-        // Assume it works
-        napi_get_buffer_info(env, value, &ptr, &length);
-
-        *out_buffer = MakeSpan((uint8_t *)ptr, (Size)length);
+    if (node_api_get_buffer_info(env, value, &ptr, &len) == napi_ok) {
+        *out_buffer = MakeSpan((uint8_t *)ptr, (Size)len);
         return true;
-    } else if (IsArrayBuffer(env, value)) {
-        Napi::ArrayBuffer buffer = Napi::ArrayBuffer(env, value);
-
-        *out_buffer = MakeSpan((uint8_t *)buffer.Data(), (Size)buffer.ByteLength());
+    } else if (napi_get_arraybuffer_info(env, value, &ptr, &len) == napi_ok) {
+        *out_buffer = MakeSpan((uint8_t *)ptr, (Size)len);
         return true;
     }