koffi 3.0.0 → 3.0.2

package/src/koffi/src/abi/x64sysv.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>
@@ -59,14 +60,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 +84,7 @@ enum class AbiOpcode {
     #define PRIMITIVE(Name) Return ## Name,
     #include "../primitives.inc"
     ReturnAggregateReg,
-    ReturnAggregateStack
+    ReturnAggregateMem
 };
 
 enum class AbiMethod {
@@ -452,12 +453,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 +802,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 +886,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 +1021,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 +1044,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 +1068,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 +1233,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;

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

@@ -6,6 +6,7 @@
 #include "lib/native/base/base.hh"
 #include "../ffi.hh"
 #include "../call.hh"
+#include "../type.hh"
 #include "../util.hh"
 #include "../win32.hh"
 
@@ -29,15 +30,15 @@ enum class AbiOpcode {
     #define PRIMITIVE(Name) Push ## Name,
     #include "../primitives.inc"
     PushAggregateReg,
-    PushAggregateStack,
+    PushAggregateMem,
     #define PRIMITIVE(Name) Run ## Name,
     #include "../primitives.inc"
     RunAggregateReg,
-    RunAggregateStack,
+    RunAggregateMem,
     #define PRIMITIVE(Name) Run ## Name ## X,
     #include "../primitives.inc"
     RunAggregateRegX,
-    RunAggregateStackX,
+    RunAggregateMemX,
     Yield,
     CallG,
     CallF,
@@ -50,12 +51,12 @@ enum class AbiOpcode {
     #define PRIMITIVE(Name) Return ## Name,
     #include "../primitives.inc"
     ReturnAggregateReg,
-    ReturnAggregateStack
+    ReturnAggregateMem
 };
 
 namespace {
 #if defined(MUST_TAIL)
-PRESERVE_NONE typedef napi_value ForwardFunc(CallData *call, napi_value *args, uint64_t *base, const AbiInstruction *inst);
+PRESERVE_NONE typedef napi_value ForwardFunc(CallData *call, napi_value *args, uint8_t *base, const AbiInstruction *inst);
 
 extern ForwardFunc *const ForwardDispatch[256];
 
@@ -82,16 +83,16 @@ bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
         param.regular = IsRegularSize(param.type->size, 8);
 
         if (param.type->primitive == PrimitiveKind::Record || param.type->primitive == PrimitiveKind::Union) {
-            AbiOpcode code = param.regular ? AbiOpcode::PushAggregateReg : AbiOpcode::PushAggregateStack;
+            AbiOpcode code = param.regular ? AbiOpcode::PushAggregateReg : AbiOpcode::PushAggregateMem;
 
-            func->sync.Append({ .op = Code2Op(code), .a = param.offset, .b1 = arg, .b2 = (int16_t)param.directions, .type = param.type });
-            func->async.Append({ .op = Code2Op(code), .a = param.offset, .b1 = arg, .b2 = (int16_t)param.directions, .type = param.type });
+            func->sync.Append({ .op = Code2Op(code), .a = param.offset, .b1 = (int16_t)(arg * 8), .b2 = (int16_t)param.directions, .type = param.type });
+            func->async.Append({ .op = Code2Op(code), .a = param.offset, .b1 = (int16_t)(arg * 8), .b2 = (int16_t)param.directions, .type = param.type });
         } else {
             int delta = (int)AbiOpcode::PushVoid - (int)PrimitiveKind::Void;
             AbiOpcode code = (AbiOpcode)((int)param.type->primitive + delta);
 
-            func->sync.Append({ .op = Code2Op(code), .a = param.offset, .b1 = arg, .b2 = (int16_t)param.directions, .type = param.type });
-            func->async.Append({ .op = Code2Op(code), .a = param.offset, .b1 = arg, .b2 = (int16_t)param.directions, .type = param.type });
+            func->sync.Append({ .op = Code2Op(code), .a = param.offset, .b1 = (int16_t)(arg * 8), .b2 = (int16_t)param.directions, .type = param.type });
+            func->async.Append({ .op = Code2Op(code), .a = param.offset, .b1 = (int16_t)(arg * 8), .b2 = (int16_t)param.directions, .type = param.type });
         }
 
         func->forward_fp |= IsFloat(param.type);
@@ -175,12 +176,12 @@ bool AnalyseFunction(Napi::Env, InstanceData *, 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;
@@ -216,7 +217,7 @@ bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
 namespace {
 #if defined(MUST_TAIL)
     #define OP(Code) \
-        PRESERVE_NONE napi_value Handle ## Code(CallData *call, napi_value *args, uint64_t *base, const AbiInstruction *inst)
+        PRESERVE_NONE napi_value Handle ## Code(CallData *call, napi_value *args, uint8_t *base, const AbiInstruction *inst)
     #define NEXT() \
         do { \
             const AbiInstruction *next = inst + 1; \
@@ -228,7 +229,7 @@ namespace {
     #define NEXT() \
         break
 
-    napi_value RunLoop(CallData *call, napi_value *args, uint64_t *base, const AbiInstruction *inst)
+    napi_value RunLoop(CallData *call, napi_value *args, uint8_t *base, const AbiInstruction *inst)
     {
         for (;; ++inst) {
             switch ((intptr_t)inst->op) {
@@ -255,7 +256,7 @@ namespace {
                 return call->env.Null(); \
             } \
              \
-            *(base + inst->b1) = (uint64_t)v; \
+            *(uint64_t *)(base + inst->b1) = (uint64_t)v; \
         } while (false)
 #define INTEGER_SWAP(CType) \
         do { \
@@ -265,7 +266,7 @@ namespace {
                 return call->env.Null(); \
             } \
              \
-            *(base + inst->b1) = (uint64_t)ReverseBytes(v); \
+            *(uint64_t *)(base + inst->b1) = (uint64_t)ReverseBytes(v); \
         } while (false)
 
     OP(PushVoid) { K_UNREACHABLE(); return call->env.Null(); }
@@ -381,7 +382,7 @@ namespace {
 
         NEXT();
     }
-    OP(PushAggregateStack) {
+    OP(PushAggregateMem) {
         napi_value arg = args[inst->a];
 
         if (!IsObject(call->env, arg)) [[unlikely]] {
@@ -403,12 +404,12 @@ namespace {
 
 #define INTEGER(Suffix, CType) \
         do { \
-            uint64_t rax = WRAP(ForwardCall ## Suffix(call->native, (uint8_t *)base, &call->saved_sp)); \
+            uint64_t rax = WRAP(ForwardCall ## Suffix(call->native, base, &call->saved_sp)); \
             return NewInt(call->env, (CType)rax); \
         } while (false)
 #define INTEGER_SWAP(Suffix, CType) \
         do { \
-            uint64_t rax = WRAP(ForwardCall ## Suffix(call->native, (uint8_t *)base, &call->saved_sp)); \
+            uint64_t rax = WRAP(ForwardCall ## Suffix(call->native, base, &call->saved_sp)); \
             return NewInt(call->env, ReverseBytes((CType)rax)); \
         } while (false)
 #define DISPOSE(Ptr) \
@@ -419,11 +420,11 @@ namespace {
         } while (false)
 
     OP(RunVoid) {
-        WRAP(ForwardCallG(call->native, (uint8_t *)base, &call->saved_sp));
+        WRAP(ForwardCallG(call->native, base, &call->saved_sp));
         return nullptr;
     }
     OP(RunBool) {
-        uint64_t rax = WRAP(ForwardCallG(call->native, (uint8_t *)base, &call->saved_sp));
+        uint64_t rax = WRAP(ForwardCallG(call->native, base, &call->saved_sp));
         return Napi::Boolean::New(call->env, rax & 0x1);
     }
     OP(RunInt8) { INTEGER(G, int8_t); }
@@ -441,60 +442,60 @@ namespace {
     OP(RunUInt64) { INTEGER(G, uint64_t); }
     OP(RunUInt64S) { INTEGER_SWAP(G, uint64_t); }
     OP(RunString) {
-        uint64_t rax = WRAP(ForwardCallG(call->native, (uint8_t *)base, &call->saved_sp));
+        uint64_t rax = WRAP(ForwardCallG(call->native, base, &call->saved_sp));
         napi_value value = rax ? Napi::String::New(call->env, (const char *)rax) : call->env.Null();
         DISPOSE((void *)rax);
         return value;
     }
     OP(RunString16) {
-        uint64_t rax = WRAP(ForwardCallG(call->native, (uint8_t *)base, &call->saved_sp));
+        uint64_t rax = WRAP(ForwardCallG(call->native, base, &call->saved_sp));
         napi_value value = rax ? Napi::String::New(call->env, (const char16_t *)rax) : call->env.Null();
         DISPOSE((void *)rax);
         return value;
     }
     OP(RunString32) {
-        uint64_t rax = WRAP(ForwardCallG(call->native, (uint8_t *)base, &call->saved_sp));
+        uint64_t rax = WRAP(ForwardCallG(call->native, base, &call->saved_sp));
         napi_value value = rax ? MakeStringFromUTF32(call->env, (const char32_t *)rax) : call->env.Null();
         DISPOSE((void *)rax);
         return value;
     }
     OP(RunPointer) {
-        uint64_t rax = WRAP(ForwardCallG(call->native, (uint8_t *)base, &call->saved_sp));
+        uint64_t rax = WRAP(ForwardCallG(call->native, base, &call->saved_sp));
         napi_value value = rax ? WrapPointer(call->env, inst->type, (void *)rax) : call->env.Null();
         DISPOSE((void *)rax);
         return value;
     }
     OP(RunCallback) {
-        uint64_t rax = WRAP(ForwardCallG(call->native, (uint8_t *)base, &call->saved_sp));
+        uint64_t rax = WRAP(ForwardCallG(call->native, base, &call->saved_sp));
         return rax ? WrapPointer(call->env, inst->type, (void *)rax) : call->env.Null();
     }
     OP(RunRecord) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunUnion) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunArray) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunFloat32) {
-        float f = WRAP(ForwardCallF(call->native, (uint8_t *)base, &call->saved_sp));
+        float f = WRAP(ForwardCallF(call->native, base, &call->saved_sp));
         return Napi::Number::New(call->env, (double)f);
     }
     OP(RunFloat64) {
-        double d = WRAP(ForwardCallD(call->native, (uint8_t *)base, &call->saved_sp));
+        double d = WRAP(ForwardCallD(call->native, base, &call->saved_sp));
         return Napi::Number::New(call->env, d);
     }
     OP(RunPrototype) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunAggregateReg) {
-        auto ret = WRAP(ForwardCallG(call->native, (uint8_t *)base, &call->saved_sp));
-        return DecodeObject(call->env, (const uint8_t *)&ret, inst->type);
+        auto ret = WRAP(ForwardCallG(call->native, base, &call->saved_sp));
+        return DecodeObject(call->instance, (const uint8_t *)&ret, inst->type);
     }
-    OP(RunAggregateStack) {
+    OP(RunAggregateMem) {
         *(uint8_t **)base = call->AllocHeap(inst->a);
-        uint64_t rax = WRAP(ForwardCallG(call->native, (uint8_t *)base, &call->saved_sp));
-        return DecodeObject(call->env, (const uint8_t *)rax, inst->type);
+        uint64_t rax = WRAP(ForwardCallG(call->native, base, &call->saved_sp));
+        return DecodeObject(call->instance, (const uint8_t *)rax, inst->type);
     }
     OP(RunVoidX) {
-        WRAP(ForwardCallGX(call->native, (uint8_t *)base, &call->saved_sp));
+        WRAP(ForwardCallGX(call->native, base, &call->saved_sp));
         return nullptr;
     }
     OP(RunBoolX) {
-        uint64_t rax = WRAP(ForwardCallGX(call->native, (uint8_t *)base, &call->saved_sp));
+        uint64_t rax = WRAP(ForwardCallGX(call->native, base, &call->saved_sp));
         return Napi::Boolean::New(call->env, rax & 0x1);
     }
     OP(RunInt8X) { INTEGER(GX, int8_t); }
@@ -512,53 +513,53 @@ namespace {
     OP(RunUInt64X) { INTEGER(GX, uint64_t); }
     OP(RunUInt64SX) { INTEGER_SWAP(GX, uint64_t); }
     OP(RunStringX) {
-        uint64_t rax = WRAP(ForwardCallGX(call->native, (uint8_t *)base, &call->saved_sp));
+        uint64_t rax = WRAP(ForwardCallGX(call->native, base, &call->saved_sp));
         napi_value value = rax ? Napi::String::New(call->env, (const char *)rax) : call->env.Null();
         DISPOSE((void *)rax);
         return value;
     }
     OP(RunString16X) {
-        uint64_t rax = WRAP(ForwardCallGX(call->native, (uint8_t *)base, &call->saved_sp));
+        uint64_t rax = WRAP(ForwardCallGX(call->native, base, &call->saved_sp));
         napi_value value = rax ? Napi::String::New(call->env, (const char16_t *)rax) : call->env.Null();
         DISPOSE((void *)rax);
         return value;
     }
     OP(RunString32X) {
-        uint64_t rax = WRAP(ForwardCallGX(call->native, (uint8_t *)base, &call->saved_sp));
+        uint64_t rax = WRAP(ForwardCallGX(call->native, base, &call->saved_sp));
         napi_value value = rax ? MakeStringFromUTF32(call->env, (const char32_t *)rax) : call->env.Null();
         DISPOSE((void *)rax);
         return value;
     }
     OP(RunPointerX) {
-        uint64_t rax = WRAP(ForwardCallGX(call->native, (uint8_t *)base, &call->saved_sp));
+        uint64_t rax = WRAP(ForwardCallGX(call->native, base, &call->saved_sp));
         napi_value value = rax ? WrapPointer(call->env, inst->type, (void *)rax) : call->env.Null();
         DISPOSE((void *)rax);
         return value;
     }
     OP(RunCallbackX) {
-        uint64_t rax = WRAP(ForwardCallGX(call->native, (uint8_t *)base, &call->saved_sp));
+        uint64_t rax = WRAP(ForwardCallGX(call->native, base, &call->saved_sp));
         return rax ? WrapPointer(call->env, inst->type, (void *)rax) : call->env.Null();
     }
     OP(RunRecordX) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunUnionX) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunArrayX) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunFloat32X) {
-        float f = WRAP(ForwardCallFX(call->native, (uint8_t *)base, &call->saved_sp));
+        float f = WRAP(ForwardCallFX(call->native, base, &call->saved_sp));
         return Napi::Number::New(call->env, (double)f);
     }
     OP(RunFloat64X) {
-        double d = WRAP(ForwardCallDX(call->native, (uint8_t *)base, &call->saved_sp));
+        double d = WRAP(ForwardCallDX(call->native, base, &call->saved_sp));
         return Napi::Number::New(call->env, d);
     }
     OP(RunPrototypeX) { K_UNREACHABLE(); return call->env.Null(); }
     OP(RunAggregateRegX) {
-        auto ret = WRAP(ForwardCallGX(call->native, (uint8_t *)base, &call->saved_sp));
-        return DecodeObject(call->env, (const uint8_t *)&ret, inst->type);
+        auto ret = WRAP(ForwardCallGX(call->native, base, &call->saved_sp));
+        return DecodeObject(call->instance, (const uint8_t *)&ret, inst->type);
     }
-    OP(RunAggregateStackX) {
+    OP(RunAggregateMemX) {
         *(uint8_t **)base = call->AllocHeap(inst->a);
-        uint64_t rax = WRAP(ForwardCallGX(call->native, (uint8_t *)base, &call->saved_sp));
-        return DecodeObject(call->env, (const uint8_t *)rax, inst->type);
+        uint64_t rax = WRAP(ForwardCallGX(call->native, base, &call->saved_sp));
+        return DecodeObject(call->instance, (const uint8_t *)rax, inst->type);
     }
 
 #undef DISPOSE
@@ -567,7 +568,7 @@ namespace {
 
 #define CALL(Suffix) \
         do { \
-            auto ret = WRAP(ForwardCall ## Suffix(call->native, (uint8_t *)base, &call->saved_sp)); \
+            auto ret = WRAP(ForwardCall ## Suffix(call->native, base, &call->saved_sp)); \
             memcpy(base, &ret, K_SIZE(ret)); \
         } while (false)
 #define DISPOSE() \
@@ -598,7 +599,7 @@ namespace {
     OP(CallD) { CALL(D); return nullptr; }
     OP(CallStack) {
         *(uint8_t **)base = call->AllocHeap(inst->a);
-        *(uint64_t *)base = WRAP(ForwardCallG(call->native, (uint8_t *)base, &call->saved_sp));
+        *(uint64_t *)base = WRAP(ForwardCallG(call->native, base, &call->saved_sp));
         return nullptr;
     }
     OP(CallGX) { CALL(GX); return nullptr; }
@@ -606,7 +607,7 @@ namespace {
     OP(CallDX) { CALL(DX); return nullptr; }
     OP(CallStackX) {
         *(uint8_t **)base = call->AllocHeap(inst->a);
-        *(uint64_t *)base = WRAP(ForwardCallGX(call->native, (uint8_t *)base, &call->saved_sp));
+        *(uint64_t *)base = WRAP(ForwardCallGX(call->native, base, &call->saved_sp));
         return nullptr;
     }
 
@@ -669,10 +670,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, 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
@@ -685,15 +686,15 @@ namespace {
         #define PRIMITIVE(Name) HandlePush ## Name,
         #include "../primitives.inc"
         HandlePushAggregateReg,
-        HandlePushAggregateStack,
+        HandlePushAggregateMem,
         #define PRIMITIVE(Name) HandleRun ## Name,
         #include "../primitives.inc"
         HandleRunAggregateReg,
-        HandleRunAggregateStack,
+        HandleRunAggregateMem,
         #define PRIMITIVE(Name) HandleRun ## Name ## X,
         #include "../primitives.inc"
         HandleRunAggregateRegX,
-        HandleRunAggregateStackX,
+        HandleRunAggregateMemX,
         HandleYield,
         HandleCallG,
         HandleCallF,
@@ -706,10 +707,10 @@ namespace {
         #define PRIMITIVE(Name) HandleReturn ## Name,
         #include "../primitives.inc"
         HandleReturnAggregateReg,
-        HandleReturnAggregateStack
+        HandleReturnAggregateMem
     };
 
-    FORCE_INLINE napi_value RunLoop(CallData *call, napi_value *args, uint64_t *base, const AbiInstruction *inst)
+    FORCE_INLINE napi_value RunLoop(CallData *call, napi_value *args, uint8_t *base, const AbiInstruction *inst)
     {
         return ((ForwardFunc *)inst->op)(call, args, base, inst);
     }
@@ -738,7 +739,7 @@ napi_value CallData::Run(const FunctionInfo *func, napi_value *args)
         return env.Null();
 
     const AbiInstruction *first = func->sync.ptr;
-    return RunLoop(this, args, (uint64_t *)base, first);
+    return RunLoop(this, args, base, first);
 }
 
 bool CallData::PrepareAsync(const FunctionInfo *func, napi_value *args)
@@ -749,19 +750,19 @@ bool CallData::PrepareAsync(const FunctionInfo *func, napi_value *args)
     async_base = base;
 
     const AbiInstruction *first = func->async.ptr;
-    return !RunLoop(this, args, (uint64_t *)base, first); // Yield returns nullptr
+    return !RunLoop(this, args, base, first); // Yield returns nullptr
 }
 
 void CallData::ExecuteAsync()
 {
     const AbiInstruction *next = async_ip++;
-    RunLoop(this, nullptr, (uint64_t *)async_base, next);
+    RunLoop(this, nullptr, async_base, next);
 }
 
 napi_value CallData::EndAsync()
 {
     const AbiInstruction *next = async_ip++;
-    return RunLoop(this, nullptr, (uint64_t *)async_base, next);
+    return RunLoop(this, nullptr, async_base, next);
 }
 
 void CallData::Relay(Size idx, uint8_t *sp)
@@ -944,7 +945,7 @@ void CallData::Relay(Size idx, uint8_t *sp)
                 }
                 stk_ptr += (j >= 4);
 
-                arguments[i] = DecodeObject(env, ptr, param.type);
+                arguments[i] = DecodeObject(instance, ptr, param.type);
             } break;
             case PrimitiveKind::Array: { K_UNREACHABLE(); } break;
             case PrimitiveKind::Float32: {