koffi 3.0.0 → 3.0.1

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

@@ -53,17 +53,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 +76,7 @@ enum class AbiOpcode {
     #define PRIMITIVE(Name) Return ## Name,
     #include "../primitives.inc"
     ReturnAggregateReg,
-    ReturnAggregateStack,
+    ReturnAggregateMem,
 #if defined(_M_ARM64EC)
     SetVariadicRegisters
 #endif
@@ -220,8 +220,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 +262,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 +340,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 +508,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 +716,7 @@ namespace {
 
         NEXT();
     }
-    OP(PushAggregateStack) {
+    OP(PushAggregateMem) {
         napi_value arg = args[inst->a];
 
         if (!IsObject(call->env, arg)) [[unlikely]] {
@@ -817,17 +817,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 +893,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 +1026,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 +1053,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 +1076,7 @@ namespace {
         #define PRIMITIVE(Name) HandleReturn ## Name,
         #include "../primitives.inc"
         HandleReturnAggregateReg,
-        HandleReturnAggregateStack,
+        HandleReturnAggregateMem,
 #if defined(_M_ARM64EC)
         HandleSetVariadicRegisters
 #endif
@@ -1242,7 +1242,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

@@ -52,21 +52,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 +83,7 @@ enum class AbiOpcode {
     #define PRIMITIVE(Name) Return ## Name,
     #include "../primitives.inc"
     ReturnAggregateReg,
-    ReturnAggregateStack
+    ReturnAggregateMem
 };
 
 enum class AbiMethod {
@@ -324,7 +324,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 +407,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 +643,7 @@ namespace {
 
         NEXT();
     }
-    OP(PushAggregateStack) {
+    OP(PushAggregateMem) {
         napi_value arg = args[inst->a];
 
         if (!IsObject(call->env, arg)) [[unlikely]] {
@@ -746,25 +746,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 +830,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 +965,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 +981,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 +1012,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 +1177,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;

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

@@ -59,14 +59,14 @@ enum class AbiOpcode {
     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 +83,7 @@ enum class AbiOpcode {
     #define PRIMITIVE(Name) Return ## Name,
     #include "../primitives.inc"
     ReturnAggregateReg,
-    ReturnAggregateStack
+    ReturnAggregateMem
 };
 
 enum class AbiMethod {
@@ -452,12 +452,12 @@ bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
         case PrimitiveKind::Union: {
             switch (func->ret.abi.method) {
                 case AbiMethod::Stack: {
-                    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 });
 
                     // Allocate stack space for return value
                     func->stk_size += AlignLen(func->ret.type->size, 16);
@@ -801,25 +801,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).rax);
-        return DecodeObject(call->env, ptr, inst->type);
+        return DecodeObject(call->instance, ptr, inst->type);
     }
     OP(RunVoidX) {
         WRAP(ForwardCallGGX(call->native, base, &call->saved_sp));
@@ -885,25 +885,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).rax);
-        return DecodeObject(call->env, ptr, inst->type);
+        return DecodeObject(call->instance, ptr, inst->type);
     }
 
 #undef DISPOSE
@@ -1020,10 +1020,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) {
         uint64_t rax = *(uint64_t *)base;
-        return DecodeObject(call->env, (const uint8_t *)rax, inst->type);
+        return DecodeObject(call->instance, (const uint8_t *)rax, inst->type);
     }
 
 #undef INTEGER_SWAP
@@ -1043,14 +1043,14 @@ namespace {
         HandleRunAggregateDD,
         HandleRunAggregateGD,
         HandleRunAggregateDG,
-        HandleRunAggregateStack,
+        HandleRunAggregateMem,
         #define PRIMITIVE(Name) HandleRun ## Name ## X,
         #include "../primitives.inc"
         HandleRunAggregateGGX,
         HandleRunAggregateDDX,
         HandleRunAggregateGDX,
         HandleRunAggregateDGX,
-        HandleRunAggregateStackX,
+        HandleRunAggregateMemX,
         HandleYield,
         HandleCallGG,
         HandleCallF,
@@ -1067,7 +1067,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)
@@ -1232,9 +1232,9 @@ void CallData::Relay(Size idx, uint8_t *sp)
                     buf[0] = *(uint64_t *)(in_ptr + param.abi.offsets[0]);
                     buf[1] = *(uint64_t *)(in_ptr + param.abi.offsets[1]);
 
-                    arguments[i] = DecodeObject(env, (const uint8_t *)buf, param.type);
+                    arguments[i] = DecodeObject(instance, (const uint8_t *)buf, param.type);
                 } else {
-                    arguments[i] = DecodeObject(env, in_ptr + param.abi.offsets[0], param.type);
+                    arguments[i] = DecodeObject(instance, in_ptr + param.abi.offsets[0], param.type);
                 }
             } break;
             case PrimitiveKind::Array: { K_UNREACHABLE(); } break;