koffi 3.0.0 → 3.0.2

package/src/koffi/indirect.js

@@ -1,12 +1,12 @@
-// src/init.js
+// src/koffi/src/init.js
 import util from "node:util";
 import fs2 from "node:fs";
 import { createRequire } from "node:module";
 
-// ../cnoke/src/abi.js
+// src/cnoke/src/abi.js
 import fs from "node:fs";
 function determineAbi() {
-  let abi = process.arch;
+  let abi = process.arch.toString();
   if (abi == "riscv32" || abi == "riscv64") {
     let buf = readFileHeader(process.execPath, 512);
     let header = decodeElfHeader(buf);
@@ -93,15 +93,15 @@ function decodeElfHeader(buf) {
   return header;
 }
 
-// package.json
-var package_default = { name: "koffi", version: "3.0.0", cnoke: { api: "../../vendor/node-api-headers", output: "../../bin/Koffi/{{ toolchain }}", node: 16, napi: 8 } };
+// src/koffi/package.json
+var package_default = { name: "koffi", version: "3.0.2", cnoke: { api: "../../vendor/node-api-headers", output: "../../bin/Koffi/{{ toolchain }}", node: 16, napi: 8 } };
 
-// src/init.js
-var requireNative = createRequire(import.meta.url);
+// src/koffi/src/init.js
+var require2 = createRequire(import.meta.url);
 function detectPlatform() {
   if (process.versions.napi == null || process.versions.napi < package_default.cnoke.napi) {
     let major = parseInt(process.versions.node, 10);
-    throw new Error(`This engine is based on Node ${process.versions.node}, but ${package_default.name} does not support the Node ${major}.x branch (N-API < ${package_default.cnoke.napi})`);
+    throw new Error(`This engine is based on Node ${process.versions.node}, but ${package_default.name} does not support the Node ${major}.x branch (Node-API < ${package_default.cnoke.napi})`);
   }
   let abi = determineAbi();
   let pkg2 = `${process.platform}-${process.arch}`;
@@ -110,13 +110,20 @@ function detectPlatform() {
     triplets2.push(`musl_${abi}`);
   return [package_default.version, pkg2, triplets2];
 }
-function loadDynamic(root, pkg2, triplets2) {
+function loadDynamic(dirname, pkg2, triplets2) {
+  let suffix = "/../../build/koffi";
+  let root = dirname + suffix;
   let roots = [root];
   let native2 = null;
   let err = null;
-  if (process.resourcesPath != null) {
-    roots.push(process.resourcesPath);
-    roots.push(process.resourcesPath + "/node_modules/koffi");
+  if (process["resourcesPath"] != null) {
+    let suffixes = [
+      "/koffi",
+      "/koffi/build",
+      "/node_modules/koffi/build"
+    ];
+    for (let suffix2 of suffixes)
+      roots.push(process["resourcesPath"] + suffix2);
   }
   let names = [
     `${import.meta.dirname}/../../../@koromix/koffi-${pkg2}`,
@@ -126,42 +133,43 @@ function loadDynamic(root, pkg2, triplets2) {
     if (!fs2.existsSync(name))
       continue;
     try {
-      native2 = requireNative(name);
+      native2 = require2(name);
       break;
     } catch (e) {
       err ??= e;
     }
   }
-  if (native2 == null) {
-    err ??= new Error("Cannot find the native Koffi module; did you bundle it correctly?");
+  if (native2 == null && err != null)
     throw err;
-  }
   return native2;
 }
-function wrapNative(native2) {
+function wrapNative(native2, version2) {
+  if (native2 == null)
+    throw new Error("Cannot find the native Koffi module; did you bundle it correctly?");
+  if (native2.version != version2)
+    throw new Error("Mismatched native Koffi modules");
   let load = native2.load;
   let register = native2.register;
-  native2.sizeof = (spec) => native2.type(spec).size;
-  native2.alignof = (spec) => native2.type(spec).alignment;
+  let introspect = native2.introspect ?? native2.type;
+  native2.sizeof = (spec) => introspect(spec).size;
+  native2.alignof = (spec) => introspect(spec).alignment;
   native2.offsetof = (spec, name) => {
-    let type = native2.type(spec);
-    if (type.primitive != "Record")
+    let info = introspect(spec);
+    if (info.primitive != "Record")
       throw new TypeError("The offsetof() function can only be used with record types");
-    let member = type.members[name];
+    let member = info.members[name];
     if (member == null)
-      throw new Error(`Record type ${type.name} does not have member '${name}'`);
+      throw new Error(`Record type ${info.name} does not have member '${name}'`);
     return member.offset;
   };
   native2.register = (...args) => {
     if (args.length >= 3 && typeof args[1] == "function") {
-      process.emitWarning("Using koffi.register() with a custom this value was deprecated in Koffi 3.0, use function.bind() instead", "DeprecationWarning", "KOFFI009");
+      process.emitWarning("Using koffi.register() with a custom this value was deprecated in Koffi 2.17, use function.bind() instead", "DeprecationWarning", "KOFFI009");
       args[1] = args[1].bind(args[0]);
       args = args.slice(1);
     }
     return register(...args);
   };
-  native2.resolve = util.deprecate(native2.type, "The koffi.resolve() function was deprecated in Koffi 3.0, use koffi.type() instead", "KOFFI007");
-  native2.introspect = util.deprecate(native2.type, "The koffi.introspect() function was deprecated in Koffi 3.0, use koffi.type() instead", "KOFFI008");
   native2.load = (...args) => {
     let lib = load(...args);
     lib.cdecl = util.deprecate((...args2) => lib.func("__cdecl", ...args2), "The koffi.cdecl() function was deprecated in Koffi 2.7, use koffi.func(...) instead", "KOFFI003");
@@ -170,22 +178,103 @@ function wrapNative(native2) {
     lib.thiscall = util.deprecate((...args2) => lib.func("__thiscall", ...args2), 'The koffi.thiscall() function was deprecated in Koffi 2.7, use koffi.func("__thiscall", ...) instead', "KOFFI006");
     return lib;
   };
+  if (native2.introspect == null) {
+    native2.resolve = util.deprecate(native2.type, "The koffi.resolve() function was deprecated in Koffi 3.0, use koffi.type() instead", "KOFFI007");
+    native2.introspect = util.deprecate(native2.type, "The koffi.introspect() function was deprecated in Koffi 3.0, use koffi.type() instead", "KOFFI008");
+  } else {
+    native2.resolve = native2.type;
+  }
 }
 
-// src/static.js
-import { createRequire as createRequire2 } from "node:module";
-var requireNative2 = createRequire2(import.meta.url);
-var BINARY_ROOT = import.meta.dirname + "/../../build/koffi";
-
-// index.js
+// src/koffi/indirect.js
 var [version, pkg, triplets] = detectPlatform();
-var native = null;
-if (native == null)
-  native = loadDynamic(BINARY_ROOT, pkg, triplets);
-if (native.version != version)
-  throw new Error("Mismatched native Koffi modules");
-wrapNative(native);
-var index_default = native;
+var native = loadDynamic(import.meta.dirname, pkg, triplets);
+wrapNative(native, version);
+var mod_LibraryHandle = native.LibraryHandle;
+var mod_TypeObject = native.TypeObject;
+var mod_Union = native.Union;
+var mod_address = native.address;
+var mod_alias = native.alias;
+var mod_alignof = native.alignof;
+var mod_alloc = native.alloc;
+var mod_array = native.array;
+var mod_as = native.as;
+var mod_call = native.call;
+var mod_config = native.config;
+var mod_decode = native.decode;
+var mod_disposable = native.disposable;
+var mod_encode = native.encode;
+var mod_enumeration = native.enumeration;
+var mod_errno = native.errno;
+var mod_extension = native.extension;
+var mod_free = native.free;
+var mod_in = native.in;
+var mod_inout = native.inout;
+var mod_introspect = native.introspect;
+var mod_load = native.load;
+var mod_node = native.node;
+var mod_offsetof = native.offsetof;
+var mod_opaque = native.opaque;
+var mod_os = native.os;
+var mod_out = native.out;
+var mod_pack = native.pack;
+var mod_pointer = native.pointer;
+var mod_proto = native.proto;
+var mod_register = native.register;
+var mod_reset = native.reset;
+var mod_resolve = native.resolve;
+var mod_sizeof = native.sizeof;
+var mod_stats = native.stats;
+var mod_struct = native.struct;
+var mod_type = native.type;
+var mod_types = native.types;
+var mod_union = native.union;
+var mod_unregister = native.unregister;
+var mod_version = native.version;
+var mod_view = native.view;
+var indirect_default = native;
 export {
-  index_default as default
+  mod_LibraryHandle as LibraryHandle,
+  mod_TypeObject as TypeObject,
+  mod_Union as Union,
+  mod_address as address,
+  mod_alias as alias,
+  mod_alignof as alignof,
+  mod_alloc as alloc,
+  mod_array as array,
+  mod_as as as,
+  mod_call as call,
+  mod_config as config,
+  mod_decode as decode,
+  indirect_default as default,
+  mod_disposable as disposable,
+  mod_encode as encode,
+  mod_enumeration as enumeration,
+  mod_errno as errno,
+  mod_extension as extension,
+  mod_free as free,
+  mod_in as in,
+  mod_inout as inout,
+  mod_introspect as introspect,
+  mod_load as load,
+  mod_node as node,
+  mod_offsetof as offsetof,
+  mod_opaque as opaque,
+  mod_os as os,
+  mod_out as out,
+  mod_pack as pack,
+  mod_pointer as pointer,
+  mod_proto as proto,
+  mod_register as register,
+  mod_reset as reset,
+  mod_resolve as resolve,
+  mod_sizeof as sizeof,
+  mod_stats as stats,
+  mod_struct as struct,
+  mod_type as type,
+  mod_types as types,
+  mod_union as union,
+  mod_unregister as unregister,
+  mod_version as version,
+  mod_view as view
 };

package/src/koffi/src/abi/arm64.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"
@@ -53,17 +54,17 @@ enum class AbiOpcode {
     #define PRIMITIVE(Name) Push ## Name,
     #include "../primitives.inc"
     PushAggregateReg,
-    PushAggregateStack,
+    PushAggregateMem,
     #define PRIMITIVE(Name) Run ## Name,
     #include "../primitives.inc"
     RunAggregateGG,
     RunAggregateDDDD,
-    RunAggregateStack,
+    RunAggregateMem,
     #define PRIMITIVE(Name) Run ## Name ## X,
     #include "../primitives.inc"
     RunAggregateGGX,
     RunAggregateDDDDX,
-    RunAggregateStackX,
+    RunAggregateMemX,
     Yield,
     CallGG,
     CallF,
@@ -76,7 +77,7 @@ enum class AbiOpcode {
     #define PRIMITIVE(Name) Return ## Name,
     #include "../primitives.inc"
     ReturnAggregateReg,
-    ReturnAggregateStack,
+    ReturnAggregateMem,
 #if defined(_M_ARM64EC)
     SetVariadicRegisters
 #endif
@@ -220,8 +221,8 @@ bool AnalyseFunction(Napi::Env, InstanceData *instance, FunctionInfo *func)
 
                         param.abi.indirect = true;
 
-                        func->sync.Append({ .op = Code2Op(AbiOpcode::PushAggregateStack), .a = param.offset, .b1 = (int16_t)param.abi.offset, .type = param.type });
-                        func->async.Append({ .op = Code2Op(AbiOpcode::PushAggregateStack), .a = param.offset, .b1 = (int16_t)param.abi.offset, .type = param.type });
+                        func->sync.Append({ .op = Code2Op(AbiOpcode::PushAggregateMem), .a = param.offset, .b1 = (int16_t)param.abi.offset, .type = param.type });
+                        func->async.Append({ .op = Code2Op(AbiOpcode::PushAggregateMem), .a = param.offset, .b1 = (int16_t)param.abi.offset, .type = param.type });
                     }
 
                     break;
@@ -262,8 +263,8 @@ bool AnalyseFunction(Napi::Env, InstanceData *instance, FunctionInfo *func)
 
                         param.abi.indirect = true;
 
-                        func->sync.Append({ .op = Code2Op(AbiOpcode::PushAggregateStack), .a = param.offset, .b1 = (int16_t)param.abi.offset, .type = param.type });
-                        func->async.Append({ .op = Code2Op(AbiOpcode::PushAggregateStack), .a = param.offset, .b1 = (int16_t)param.abi.offset, .type = param.type });
+                        func->sync.Append({ .op = Code2Op(AbiOpcode::PushAggregateMem), .a = param.offset, .b1 = (int16_t)param.abi.offset, .type = param.type });
+                        func->async.Append({ .op = Code2Op(AbiOpcode::PushAggregateMem), .a = param.offset, .b1 = (int16_t)param.abi.offset, .type = param.type });
                     }
 
                     break;
@@ -340,8 +341,8 @@ bool AnalyseFunction(Napi::Env, InstanceData *instance, FunctionInfo *func)
 
                     param.abi.indirect = true;
 
-                    func->sync.Append({ .op = Code2Op(AbiOpcode::PushAggregateStack), .a = param.offset, .b1 = (int16_t)param.abi.offset, .type = param.type });
-                    func->async.Append({ .op = Code2Op(AbiOpcode::PushAggregateStack), .a = param.offset, .b1 = (int16_t)param.abi.offset, .type = param.type });
+                    func->sync.Append({ .op = Code2Op(AbiOpcode::PushAggregateMem), .a = param.offset, .b1 = (int16_t)param.abi.offset, .type = param.type });
+                    func->async.Append({ .op = Code2Op(AbiOpcode::PushAggregateMem), .a = param.offset, .b1 = (int16_t)param.abi.offset, .type = param.type });
                 }
             } break;
             case PrimitiveKind::Array: { K_UNREACHABLE(); } break;
@@ -508,12 +509,12 @@ bool AnalyseFunction(Napi::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 = func->forward_fp ? AbiOpcode::RunAggregateStackX : AbiOpcode::RunAggregateStack;
+                AbiOpcode run = func->forward_fp ? AbiOpcode::RunAggregateMemX : AbiOpcode::RunAggregateMem;
                 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::ReturnAggregateStack), .type = func->ret.type });
+                func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregateMem), .type = func->ret.type });
             }
         } break;
         case PrimitiveKind::Array: { K_UNREACHABLE(); } break;
@@ -716,7 +717,7 @@ namespace {
 
         NEXT();
     }
-    OP(PushAggregateStack) {
+    OP(PushAggregateMem) {
         napi_value arg = args[inst->a];
 
         if (!IsObject(call->env, arg)) [[unlikely]] {
@@ -817,17 +818,17 @@ namespace {
     OP(RunPrototype) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunAggregateGG) {
         auto ret = WRAP(ForwardCallGG(call->native, base, &call->saved_sp));
-        return DecodeObject(call->env, (const uint8_t *)&ret, inst->type);
+        return DecodeObject(call->instance, (const uint8_t *)&ret, inst->type);
     }
     OP(RunAggregateDDDD) {
         auto ret = WRAP(ForwardCallDDDD(call->native, base, &call->saved_sp));
-        return DecodeObject(call->env, (const uint8_t *)&ret, inst->type);
+        return DecodeObject(call->instance, (const uint8_t *)&ret, inst->type);
     }
-    OP(RunAggregateStack) {
+    OP(RunAggregateMem) {
         uint8_t *ptr = call->AllocHeap(inst->a);
         *(uint8_t **)(base + 8 * 8) = ptr; // x8
         WRAP(ForwardCallGG(call->native, base, &call->saved_sp));
-        return DecodeObject(call->env, ptr, inst->type);
+        return DecodeObject(call->instance, ptr, inst->type);
     }
     OP(RunVoidX) {
         WRAP(ForwardCallGGX(call->native, base, &call->saved_sp));
@@ -893,17 +894,17 @@ namespace {
     OP(RunPrototypeX) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunAggregateGGX) {
         auto ret = WRAP(ForwardCallGGX(call->native, base, &call->saved_sp));
-        return DecodeObject(call->env, (const uint8_t *)&ret, inst->type);
+        return DecodeObject(call->instance, (const uint8_t *)&ret, inst->type);
     }
     OP(RunAggregateDDDDX) {
         auto ret = WRAP(ForwardCallDDDDX(call->native, base, &call->saved_sp));
-        return DecodeObject(call->env, (const uint8_t *)&ret, inst->type);
+        return DecodeObject(call->instance, (const uint8_t *)&ret, inst->type);
     }
-    OP(RunAggregateStackX) {
+    OP(RunAggregateMemX) {
         uint8_t *ptr = call->AllocHeap(inst->a);
         *(uint8_t **)(base + 8 * 8) = ptr; // x8
         WRAP(ForwardCallGGX(call->native, base, &call->saved_sp));
-        return DecodeObject(call->env, ptr, inst->type);
+        return DecodeObject(call->instance, ptr, inst->type);
     }
 
 #undef DISPOSE
@@ -1026,10 +1027,10 @@ namespace {
         return Napi::Number::New(call->env, d);
     }
     OP(ReturnPrototype) { K_UNREACHABLE(); return call->env.Null(); }
-    OP(ReturnAggregateReg) { return DecodeObject(call->env, base, inst->type); }
-    OP(ReturnAggregateStack) {
+    OP(ReturnAggregateReg) { return DecodeObject(call->instance, base, inst->type); }
+    OP(ReturnAggregateMem) {
         const uint8_t *ptr = *(const uint8_t **)base;
-        return DecodeObject(call->env, ptr, inst->type);
+        return DecodeObject(call->instance, ptr, inst->type);
     }
 
 #if defined(_M_ARM64EC)
@@ -1053,17 +1054,17 @@ namespace {
         #define PRIMITIVE(Name) HandlePush ## Name,
         #include "../primitives.inc"
         HandlePushAggregateReg,
-        HandlePushAggregateStack,
+        HandlePushAggregateMem,
         #define PRIMITIVE(Name) HandleRun ## Name,
         #include "../primitives.inc"
         HandleRunAggregateGG,
         HandleRunAggregateDDDD,
-        HandleRunAggregateStack,
+        HandleRunAggregateMem,
         #define PRIMITIVE(Name) HandleRun ## Name ## X,
         #include "../primitives.inc"
         HandleRunAggregateGGX,
         HandleRunAggregateDDDDX,
-        HandleRunAggregateStackX,
+        HandleRunAggregateMemX,
         HandleYield,
         HandleCallGG,
         HandleCallF,
@@ -1076,7 +1077,7 @@ namespace {
         #define PRIMITIVE(Name) HandleReturn ## Name,
         #include "../primitives.inc"
         HandleReturnAggregateReg,
-        HandleReturnAggregateStack,
+        HandleReturnAggregateMem,
 #if defined(_M_ARM64EC)
         HandleSetVariadicRegisters
 #endif
@@ -1242,7 +1243,7 @@ void CallData::Relay(Size idx, uint8_t *sp)
                 uint8_t *ptr = in_ptr + param.abi.offset;
                 uint8_t *src = param.abi.indirect ? *(uint8_t **)ptr : ptr;
 
-                arguments[i] = DecodeObject(env, src, param.type);
+                arguments[i] = DecodeObject(instance, src, param.type);
             } break;
             case PrimitiveKind::Array: { K_UNREACHABLE(); } break;
 

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

@@ -6,6 +6,7 @@
 #include "lib/native/base/base.hh"
 #include "../ffi.hh"
 #include "../call.hh"
+#include "../type.hh"
 #include "../util.hh"
 
 #include <napi.h>
@@ -52,21 +53,21 @@ enum class AbiOpcode {
     #define PRIMITIVE(Name) Push ## Name,
     #include "../primitives.inc"
     PushAggregateReg,
-    PushAggregateStack,
+    PushAggregateMem,
     #define PRIMITIVE(Name) Run ## Name,
     #include "../primitives.inc"
     RunAggregateGG,
     RunAggregateDD,
     RunAggregateGD,
     RunAggregateDG,
-    RunAggregateStack,
+    RunAggregateMem,
     #define PRIMITIVE(Name) Run ## Name ## X,
     #include "../primitives.inc"
     RunAggregateGGX,
     RunAggregateDDX,
     RunAggregateGDX,
     RunAggregateDGX,
-    RunAggregateStackX,
+    RunAggregateMemX,
     Yield,
     CallGG,
     CallF,
@@ -83,7 +84,7 @@ enum class AbiOpcode {
     #define PRIMITIVE(Name) Return ## Name,
     #include "../primitives.inc"
     ReturnAggregateReg,
-    ReturnAggregateStack
+    ReturnAggregateMem
 };
 
 enum class AbiMethod {
@@ -324,7 +325,7 @@ bool AnalyseFunction(Napi::Env, InstanceData *instance, FunctionInfo *func)
             }
 
             if (param.type->primitive == PrimitiveKind::Record || param.type->primitive == PrimitiveKind::Union) {
-                AbiOpcode code = (param.abi.method != AbiMethod::Memory) ? AbiOpcode::PushAggregateReg : AbiOpcode::PushAggregateStack;
+                AbiOpcode code = (param.abi.method != AbiMethod::Memory) ? AbiOpcode::PushAggregateReg : AbiOpcode::PushAggregateMem;
 
                 func->sync.Append({ .op = Code2Op(code), .a = param.offset, .b1 = (int16_t)param.abi.offsets[0], .b2 = (int16_t)param.abi.offsets[1], .type = param.type });
                 func->async.Append({ .op = Code2Op(code), .a = param.offset, .b1 = (int16_t)param.abi.offsets[0], .b2 = (int16_t)param.abi.offsets[1], .type = param.type });
@@ -407,12 +408,12 @@ bool AnalyseFunction(Napi::Env, InstanceData *instance, FunctionInfo *func)
         case PrimitiveKind::Union: {
             switch (func->ret.abi.method) {
                 case AbiMethod::Memory: {
-                    AbiOpcode run = func->forward_fp ? AbiOpcode::RunAggregateStackX : AbiOpcode::RunAggregateStack;
+                    AbiOpcode run = func->forward_fp ? AbiOpcode::RunAggregateMemX : AbiOpcode::RunAggregateMem;
                     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::ReturnAggregateStack), .type = func->ret.type });
+                    func->async.Append({ .op = Code2Op(AbiOpcode::ReturnAggregateMem), .type = func->ret.type });
                 } break;
 
                 case AbiMethod::Gpr:
@@ -643,7 +644,7 @@ namespace {
 
         NEXT();
     }
-    OP(PushAggregateStack) {
+    OP(PushAggregateMem) {
         napi_value arg = args[inst->a];
 
         if (!IsObject(call->env, arg)) [[unlikely]] {
@@ -746,25 +747,25 @@ namespace {
     OP(RunPrototype) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunAggregateGG) {
         auto ret = WRAP(ForwardCallGG(call->native, base, &call->saved_sp));
-        return DecodeObject(call->env, (const uint8_t *)&ret, inst->type);
+        return DecodeObject(call->instance, (const uint8_t *)&ret, inst->type);
     }
     OP(RunAggregateDD) {
         auto ret = WRAP(ForwardCallDD(call->native, base, &call->saved_sp));
-        return DecodeObject(call->env, (const uint8_t *)&ret, inst->type);
+        return DecodeObject(call->instance, (const uint8_t *)&ret, inst->type);
     }
     OP(RunAggregateGD) {
         auto ret = WRAP(ForwardCallGD(call->native, base, &call->saved_sp));
-        return DecodeObject(call->env, (const uint8_t *)&ret, inst->type);
+        return DecodeObject(call->instance, (const uint8_t *)&ret, inst->type);
     }
     OP(RunAggregateDG) {
         auto ret = WRAP(ForwardCallDG(call->native, base, &call->saved_sp));
-        return DecodeObject(call->env, (const uint8_t *)&ret, inst->type);
+        return DecodeObject(call->instance, (const uint8_t *)&ret, inst->type);
     }
-    OP(RunAggregateStack) {
+    OP(RunAggregateMem) {
         uint8_t *ptr = call->AllocHeap(inst->a);
         *(uint8_t **)base = ptr;
         WRAP(ForwardCallGG(call->native, base, &call->saved_sp));
-        return DecodeObject(call->env, ptr, inst->type);
+        return DecodeObject(call->instance, ptr, inst->type);
     }
     OP(RunVoidX) {
         WRAP(ForwardCallGGX(call->native, base, &call->saved_sp));
@@ -830,25 +831,25 @@ namespace {
     OP(RunPrototypeX) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunAggregateGGX) {
         auto ret = WRAP(ForwardCallGGX(call->native, base, &call->saved_sp));
-        return DecodeObject(call->env, (const uint8_t *)&ret, inst->type);
+        return DecodeObject(call->instance, (const uint8_t *)&ret, inst->type);
     }
     OP(RunAggregateDDX) {
         auto ret = WRAP(ForwardCallDDX(call->native, base, &call->saved_sp));
-        return DecodeObject(call->env, (const uint8_t *)&ret, inst->type);
+        return DecodeObject(call->instance, (const uint8_t *)&ret, inst->type);
     }
     OP(RunAggregateGDX) {
         auto ret = WRAP(ForwardCallGDX(call->native, base, &call->saved_sp));
-        return DecodeObject(call->env, (const uint8_t *)&ret, inst->type);
+        return DecodeObject(call->instance, (const uint8_t *)&ret, inst->type);
     }
     OP(RunAggregateDGX) {
         auto ret = WRAP(ForwardCallDGX(call->native, base, &call->saved_sp));
-        return DecodeObject(call->env, (const uint8_t *)&ret, inst->type);
+        return DecodeObject(call->instance, (const uint8_t *)&ret, inst->type);
     }
-    OP(RunAggregateStackX) {
+    OP(RunAggregateMemX) {
         uint8_t *ptr = call->AllocHeap(inst->a);
         *(uint8_t **)base = ptr;
         WRAP(ForwardCallGGX(call->native, base, &call->saved_sp));
-        return DecodeObject(call->env, ptr, inst->type);
+        return DecodeObject(call->instance, ptr, inst->type);
     }
 
 #undef DISPOSE
@@ -965,10 +966,10 @@ namespace {
         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) {
         uint64_t a0 = *(uint64_t *)base;
-        return DecodeObject(call->env, (const uint8_t *)a0, inst->type);
+        return DecodeObject(call->instance, (const uint8_t *)a0, inst->type);
     }
 
 #undef INTEGER_SWAP
@@ -981,21 +982,21 @@ namespace {
         #define PRIMITIVE(Name) HandlePush ## Name,
         #include "../primitives.inc"
         HandlePushAggregateReg,
-        HandlePushAggregateStack,
+        HandlePushAggregateMem,
         #define PRIMITIVE(Name) HandleRun ## Name,
         #include "../primitives.inc"
         HandleRunAggregateGG,
         HandleRunAggregateDD,
         HandleRunAggregateGD,
         HandleRunAggregateDG,
-        HandleRunAggregateStack,
+        HandleRunAggregateMem,
         #define PRIMITIVE(Name) HandleRun ## Name ## X,
         #include "../primitives.inc"
         HandleRunAggregateGGX,
         HandleRunAggregateDDX,
         HandleRunAggregateGDX,
         HandleRunAggregateDGX,
-        HandleRunAggregateStackX,
+        HandleRunAggregateMemX,
         HandleYield,
         HandleCallGG,
         HandleCallF,
@@ -1012,7 +1013,7 @@ namespace {
         #define PRIMITIVE(Name) HandleReturn ## Name,
         #include "../primitives.inc"
         HandleReturnAggregateReg,
-        HandleReturnAggregateStack
+        HandleReturnAggregateMem
     };
 
     FORCE_INLINE napi_value RunLoop(CallData *call, napi_value *args, uint8_t *base, const AbiInstruction *inst)
@@ -1177,10 +1178,10 @@ void CallData::Relay(Size idx, uint8_t *sp)
                     memcpy(buf, in_ptr + param.abi.offsets[0], 8);
                     memcpy(buf + 8, in_ptr + param.abi.offsets[1], 8);
 
-                    arguments[i] = DecodeObject(env, buf, param.type);
+                    arguments[i] = DecodeObject(instance, buf, param.type);
                 } else {
                     uint8_t *ptr = *(uint8_t **)(in_ptr + param.abi.offsets[0]);
-                    arguments[i] = DecodeObject(env, ptr, param.type);
+                    arguments[i] = DecodeObject(instance, ptr, param.type);
                 }
             } break;
             case PrimitiveKind::Array: { K_UNREACHABLE(); } break;