koffi 2.1.5 → 2.2.1

package/src/koffi/src/abi_arm32.cc

@@ -282,7 +282,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 return false; \
             } \
              \
-            CType v = CopyNumber<CType>(value); \
+            CType v = GetNumber<CType>(value); \
             *((param.gpr_count ? gpr_ptr : args_ptr)++) = (uint32_t)v; \
         } while (false)
 #define PUSH_INTEGER_32_SWAP(CType) \
@@ -292,7 +292,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 return false; \
             } \
              \
-            CType v = CopyNumber<CType>(value); \
+            CType v = GetNumber<CType>(value); \
             *((param.gpr_count ? gpr_ptr : args_ptr)++) = (uint32_t)ReverseBytes(v); \
         } while (false)
 #define PUSH_INTEGER_64(CType) \
@@ -302,7 +302,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 return false; \
             } \
              \
-            CType v = CopyNumber<CType>(value); \
+            CType v = GetNumber<CType>(value); \
              \
             if (RG_LIKELY(param.gpr_count)) { \
                 gpr_ptr = AlignUp(gpr_ptr, 8); \
@@ -321,7 +321,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 return false; \
             } \
              \
-            CType v = CopyNumber<CType>(value); \
+            CType v = GetNumber<CType>(value); \
              \
             if (RG_LIKELY(param.gpr_count)) { \
                 gpr_ptr = AlignUp(gpr_ptr, 8); \
@@ -369,14 +369,14 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
             case PrimitiveKind::UInt64S: { PUSH_INTEGER_64_SWAP(uint64_t); } break;
             case PrimitiveKind::String: {
                 const char *str;
-                if (RG_UNLIKELY(!PushString(value, &str)))
+                if (RG_UNLIKELY(!PushString(value, param.directions, &str)))
                     return false;
 
                 *(const char **)((param.gpr_count ? gpr_ptr : args_ptr)++) = str;
             } break;
             case PrimitiveKind::String16: {
                 const char16_t *str16;
-                if (RG_UNLIKELY(!PushString16(value, &str16)))
+                if (RG_UNLIKELY(!PushString16(value, param.directions, &str16)))
                     return false;
 
                 *(const char16_t **)((param.gpr_count ? gpr_ptr : args_ptr)++) = str16;
@@ -427,7 +427,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                     return false;
                 }
 
-                float f = CopyNumber<float>(value);
+                float f = GetNumber<float>(value);
 
                 if (RG_LIKELY(param.vec_count)) {
                     *(float *)(vec_ptr++) = f;
@@ -443,7 +443,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                     return false;
                 }
 
-                double d = CopyNumber<double>(value);
+                double d = GetNumber<double>(value);
 
                 if (RG_LIKELY(param.vec_count)) {
                     *(double *)vec_ptr = d;
@@ -495,6 +495,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
 
 void CallData::Execute()
 {
+    RG_DEFER_C(prev_call = exec_call) { exec_call = prev_call; };
     exec_call = this;
 
 #define PERFORM_CALL(Suffix) \
@@ -588,7 +589,7 @@ Napi::Value CallData::Complete()
             const uint8_t *ptr = return_ptr ? (const uint8_t *)return_ptr
                                             : (const uint8_t *)&result.buf;
 
-            Napi::Object obj = PopObject(ptr, func->ret.type);
+            Napi::Object obj = DecodeObject(env, ptr, func->ret.type);
             return obj;
         } break;
         case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
@@ -625,7 +626,9 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
         return;
     }
 
-    LocalArray<napi_value, MaxParameters> arguments;
+    LocalArray<napi_value, MaxParameters + 1> arguments;
+
+    arguments.Append(!trampoline.recv.IsEmpty() ? trampoline.recv.Value() : env.Undefined());
 
     // Convert to JS arguments
     for (Size i = 0; i < proto->parameters.len; i++) {
@@ -780,7 +783,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
             } break;
             case PrimitiveKind::Record: {
                 if (param.vec_count) {
-                    Napi::Object obj = PopObject((const uint8_t *)vec_ptr, param.type);
+                    Napi::Object obj = DecodeObject(env, (const uint8_t *)vec_ptr, param.type);
                     arguments.Append(obj);
 
                     vec_ptr += param.vec_count;
@@ -799,13 +802,13 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
                         memcpy(ptr, gpr_ptr, gpr_size);
                         memcpy(ptr + gpr_size, args_ptr, param.type->size - gpr_size);
 
-                        Napi::Object obj = PopObject(ptr, param.type);
+                        Napi::Object obj = DecodeObject(env, ptr, param.type);
                         arguments.Append(obj);
 
                         gpr_ptr += param.gpr_count;
                         args_ptr += (param.type->size - gpr_size + 3) / 4;
                     } else {
-                        Napi::Object obj = PopObject((const uint8_t *)gpr_ptr, param.type);
+                        Napi::Object obj = DecodeObject(env, (const uint8_t *)gpr_ptr, param.type);
                         arguments.Append(obj);
 
                         gpr_ptr += param.gpr_count;
@@ -814,7 +817,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
                     int16_t align = (param.type->align <= 4) ? 4 : 8;
                     args_ptr = AlignUp(args_ptr, align);
 
-                    Napi::Object obj = PopObject((const uint8_t *)args_ptr, param.type);
+                    Napi::Object obj = DecodeObject(env, (const uint8_t *)args_ptr, param.type);
                     arguments.Append(obj);
 
                     args_ptr += (param.type->size + 3) / 4;
@@ -861,7 +864,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
 
     // Make the call
     napi_value ret = CallSwitchStack(&func, (size_t)arguments.len, arguments.data, old_sp, &mem->stack,
-                                     [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argc, argv); });
+                                     [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argv[0], argc - 1, argv + 1); });
     Napi::Value value(env, ret);
 
     if (RG_UNLIKELY(env.IsExceptionPending()))
@@ -874,7 +877,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
                 return; \
             } \
              \
-            CType v = CopyNumber<CType>(value); \
+            CType v = GetNumber<CType>(value); \
             out_reg->r0 = (uint32_t)v; \
         } while (false)
 #define RETURN_INTEGER_32_SWAP(CType) \
@@ -884,7 +887,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
                 return; \
             } \
              \
-            CType v = CopyNumber<CType>(value); \
+            CType v = GetNumber<CType>(value); \
             out_reg->r0 = (uint32_t)ReverseBytes(v); \
         } while (false)
 #define RETURN_INTEGER_64(CType) \
@@ -894,7 +897,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
                 return; \
             } \
              \
-            CType v = CopyNumber<CType>(value); \
+            CType v = GetNumber<CType>(value); \
              \
             out_reg->r0 = (uint32_t)((uint64_t)v >> 32); \
             out_reg->r1 = (uint32_t)((uint64_t)v & 0xFFFFFFFFu); \
@@ -906,7 +909,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
                 return; \
             } \
              \
-            CType v = ReverseBytes(CopyNumber<CType>(value)); \
+            CType v = ReverseBytes(GetNumber<CType>(value)); \
              \
             out_reg->r0 = (uint32_t)((uint64_t)v >> 32); \
             out_reg->r1 = (uint32_t)((uint64_t)v & 0xFFFFFFFFu); \
@@ -940,14 +943,14 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
         case PrimitiveKind::UInt64S: { RETURN_INTEGER_64_SWAP(uint64_t); } break;
         case PrimitiveKind::String: {
             const char *str;
-            if (RG_UNLIKELY(!PushString(value, &str)))
+            if (RG_UNLIKELY(!PushString(value, 1, &str)))
                 return;
 
             out_reg->r0 = (uint32_t)str;
         } break;
         case PrimitiveKind::String16: {
             const char16_t *str16;
-            if (RG_UNLIKELY(!PushString16(value, &str16)))
+            if (RG_UNLIKELY(!PushString16(value, 1, &str16)))
                 return;
 
             out_reg->r0 = (uint32_t)str16;
@@ -998,7 +1001,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
                 return;
             }
 
-            float f = CopyNumber<float>(value);
+            float f = GetNumber<float>(value);
 #ifdef __ARM_PCS_VFP
             memcpy(&out_reg->d0, &f, 4);
 #else
@@ -1011,7 +1014,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
                 return;
             }
 
-            double d = CopyNumber<double>(value);
+            double d = GetNumber<double>(value);
 #ifdef __ARM_PCS_VFP
             out_reg->d0 = d;
 #else

package/src/koffi/src/abi_arm64.cc

@@ -307,7 +307,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 return false; \
             } \
              \
-            CType v = CopyNumber<CType>(value); \
+            CType v = GetNumber<CType>(value); \
              \
             if (RG_LIKELY(param.gpr_count)) { \
                 *(gpr_ptr++) = (uint64_t)v; \
@@ -324,7 +324,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 return false; \
             } \
              \
-            CType v = CopyNumber<CType>(value); \
+            CType v = GetNumber<CType>(value); \
              \
             if (RG_LIKELY(param.gpr_count)) { \
                 *(gpr_ptr++) = (uint64_t)ReverseBytes(v); \
@@ -342,7 +342,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 return false; \
             } \
              \
-            CType v = CopyNumber<CType>(value); \
+            CType v = GetNumber<CType>(value); \
             *((param.gpr_count ? gpr_ptr : args_ptr)++) = (uint64_t)v; \
         } while (false)
     #define PUSH_INTEGER_SWAP(CType) \
@@ -352,7 +352,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 return false; \
             } \
              \
-            CType v = CopyNumber<CType>(value); \
+            CType v = GetNumber<CType>(value); \
             *((param.gpr_count ? gpr_ptr : args_ptr)++) = (uint64_t)ReverseBytes(v); \
         } while (false)
 #endif
@@ -402,7 +402,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
             case PrimitiveKind::UInt64S: { PUSH_INTEGER_SWAP(uint64_t); } break;
             case PrimitiveKind::String: {
                 const char *str;
-                if (RG_UNLIKELY(!PushString(value, &str)))
+                if (RG_UNLIKELY(!PushString(value, param.directions, &str)))
                     return false;
 
 #ifdef __APPLE__
@@ -412,7 +412,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
             } break;
             case PrimitiveKind::String16: {
                 const char16_t *str16;
-                if (RG_UNLIKELY(!PushString16(value, &str16)))
+                if (RG_UNLIKELY(!PushString16(value, param.directions, &str16)))
                     return false;
 
 #ifdef __APPLE__
@@ -483,7 +483,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                     return false;
                 }
 
-                float f = CopyNumber<float>(value);
+                float f = GetNumber<float>(value);
 
                 if (RG_LIKELY(param.vec_count)) {
                     memset((uint8_t *)vec_ptr + 4, 0, 4);
@@ -510,7 +510,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                     return false;
                 }
 
-                double d = CopyNumber<double>(value);
+                double d = GetNumber<double>(value);
 
                 if (RG_LIKELY(param.vec_count)) {
                     *(double *)(vec_ptr++) = d;
@@ -563,6 +563,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
 
 void CallData::Execute()
 {
+    RG_DEFER_C(prev_call = exec_call) { exec_call = prev_call; };
     exec_call = this;
 
 #define PERFORM_CALL(Suffix) \
@@ -657,13 +658,13 @@ Napi::Value CallData::Complete()
         } break;
         case PrimitiveKind::Record: {
             if (func->ret.vec_count) { // HFA
-                Napi::Object obj = PopObject((const uint8_t *)&result.buf, func->ret.type, 8);
+                Napi::Object obj = DecodeObject(env, (const uint8_t *)&result.buf, func->ret.type, 8);
                 return obj;
             } else {
                 const uint8_t *ptr = return_ptr ? (const uint8_t *)return_ptr
                                                 : (const uint8_t *)&result.buf;
 
-                Napi::Object obj = PopObject(ptr, func->ret.type);
+                Napi::Object obj = DecodeObject(env, ptr, func->ret.type);
                 return obj;
             }
         } break;
@@ -700,7 +701,9 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
         return;
     }
 
-    LocalArray<napi_value, MaxParameters> arguments;
+    LocalArray<napi_value, MaxParameters + 1> arguments;
+
+    arguments.Append(!trampoline.recv.IsEmpty() ? trampoline.recv.Value() : env.Undefined());
 
     // Convert to JS arguments
     for (Size i = 0; i < proto->parameters.len; i++) {
@@ -1005,7 +1008,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
             } break;
             case PrimitiveKind::Record: {
                 if (param.vec_count) { // HFA
-                    Napi::Object obj = PopObject((uint8_t *)vec_ptr, param.type, 8);
+                    Napi::Object obj = DecodeObject(env, (uint8_t *)vec_ptr, param.type, 8);
                     arguments.Append(obj);
 
                     vec_ptr += param.vec_count;
@@ -1013,14 +1016,14 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
                     if (param.gpr_count) {
                         RG_ASSERT(param.type->align <= 8);
 
-                        Napi::Object obj = PopObject((uint8_t *)gpr_ptr, param.type);
+                        Napi::Object obj = DecodeObject(env, (uint8_t *)gpr_ptr, param.type);
                         arguments.Append(obj);
 
                         gpr_ptr += param.gpr_count;
                     } else if (param.type->size) {
                         args_ptr = AlignUp(args_ptr, param.type->align);
 
-                        Napi::Object obj = PopObject((uint8_t *)args_ptr, param.type);
+                        Napi::Object obj = DecodeObject(env, (uint8_t *)args_ptr, param.type);
                         arguments.Append(obj);
 
                         args_ptr += (param.type->size + 7) / 8;
@@ -1032,7 +1035,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
 
                     void *ptr2 = *(void **)((param.gpr_count ? gpr_ptr : args_ptr)++);
 
-                    Napi::Object obj = PopObject((uint8_t *)ptr2, param.type);
+                    Napi::Object obj = DecodeObject(env, (uint8_t *)ptr2, param.type);
                     arguments.Append(obj);
                 }
             } break;
@@ -1086,7 +1089,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
 
     // Make the call
     napi_value ret = CallSwitchStack(&func, (size_t)arguments.len, arguments.data, old_sp, &mem->stack,
-                                     [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argc, argv); });
+                                     [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argv[0], argc - 1, argv + 1); });
     Napi::Value value(env, ret);
 
     if (RG_UNLIKELY(env.IsExceptionPending()))
@@ -1099,7 +1102,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
                 return; \
             } \
              \
-            CType v = CopyNumber<CType>(value); \
+            CType v = GetNumber<CType>(value); \
             out_reg->x0 = (uint64_t)v; \
         } while (false)
 #define RETURN_INTEGER_SWAP(CType) \
@@ -1109,7 +1112,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
                 return; \
             } \
              \
-            CType v = CopyNumber<CType>(value); \
+            CType v = GetNumber<CType>(value); \
             out_reg->x0 = (uint64_t)ReverseBytes(v); \
         } while (false)
 
@@ -1141,14 +1144,14 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
         case PrimitiveKind::UInt64S: { RETURN_INTEGER_SWAP(uint64_t); } break;
         case PrimitiveKind::String: {
             const char *str;
-            if (RG_UNLIKELY(!PushString(value, &str)))
+            if (RG_UNLIKELY(!PushString(value, 1, &str)))
                 return;
 
             out_reg->x0 = (uint64_t)str;
         } break;
         case PrimitiveKind::String16: {
             const char16_t *str16;
-            if (RG_UNLIKELY(!PushString16(value, &str16)))
+            if (RG_UNLIKELY(!PushString16(value, 1, &str16)))
                 return;
 
             out_reg->x0 = (uint64_t)str16;
@@ -1199,7 +1202,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
                 return;
             }
 
-            float f = CopyNumber<float>(value);
+            float f = GetNumber<float>(value);
 
             memset((uint8_t *)&out_reg->d0 + 4, 0, 4);
             memcpy(&out_reg->d0, &f, 4);
@@ -1210,7 +1213,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
                 return;
             }
 
-            double d = CopyNumber<double>(value);
+            double d = GetNumber<double>(value);
             out_reg->d0 = d;
         } break;
         case PrimitiveKind::Callback: {

package/src/koffi/src/abi_riscv64.cc

@@ -223,7 +223,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 return false; \
             } \
              \
-            CType v = CopyNumber<CType>(value); \
+            CType v = GetNumber<CType>(value); \
             *((param.gpr_count ? gpr_ptr : args_ptr)++) = (uint64_t)v; \
         } while (false)
 #define PUSH_INTEGER_SWAP(CType) \
@@ -233,7 +233,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 return false; \
             } \
              \
-            CType v = CopyNumber<CType>(value); \
+            CType v = GetNumber<CType>(value); \
             *((param.gpr_count ? gpr_ptr : args_ptr)++) = (uint64_t)ReverseBytes(v); \
         } while (false)
 
@@ -272,14 +272,14 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
             case PrimitiveKind::UInt64S: { PUSH_INTEGER_SWAP(uint64_t); } break;
             case PrimitiveKind::String: {
                 const char *str;
-                if (RG_UNLIKELY(!PushString(value, &str)))
+                if (RG_UNLIKELY(!PushString(value, param.directions, &str)))
                     return false;
 
                 *(const char **)((param.gpr_count ? gpr_ptr : args_ptr)++) = str;
             } break;
             case PrimitiveKind::String16: {
                 const char16_t *str16;
-                if (RG_UNLIKELY(!PushString16(value, &str16)))
+                if (RG_UNLIKELY(!PushString16(value, param.directions, &str16)))
                     return false;
 
                 *(const char16_t **)((param.gpr_count ? gpr_ptr : args_ptr)++) = str16;
@@ -346,7 +346,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                     return false;
                 }
 
-                float f = CopyNumber<float>(value);
+                float f = GetNumber<float>(value);
 
                 if (RG_LIKELY(param.vec_count)) {
                     memset((uint8_t *)vec_ptr + 4, 0xFF, 4);
@@ -365,7 +365,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                     return false;
                 }
 
-                double d = CopyNumber<double>(value);
+                double d = GetNumber<double>(value);
 
                 if (RG_LIKELY(param.vec_count)) {
                     *(double *)(vec_ptr++) = d;
@@ -410,6 +410,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
 
 void CallData::Execute()
 {
+    RG_DEFER_C(prev_call = exec_call) { exec_call = prev_call; };
     exec_call = this;
 
 #define PERFORM_CALL(Suffix) \
@@ -508,13 +509,13 @@ Napi::Value CallData::Complete()
         } break;
         case PrimitiveKind::Record: {
             if (func->ret.vec_count) { // HFA
-                Napi::Object obj = PopObject((const uint8_t *)&result.buf, func->ret.type, 8);
+                Napi::Object obj = DecodeObject(env, (const uint8_t *)&result.buf, func->ret.type, 8);
                 return obj;
             } else {
                 const uint8_t *ptr = return_ptr ? (const uint8_t *)return_ptr
                                                 : (const uint8_t *)&result.buf;
 
-                Napi::Object obj = PopObject(ptr, func->ret.type);
+                Napi::Object obj = DecodeObject(env, ptr, func->ret.type);
                 return obj;
             }
         } break;
@@ -552,7 +553,9 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
         return;
     }
 
-    LocalArray<napi_value, MaxParameters> arguments;
+    LocalArray<napi_value, MaxParameters + 1> arguments;
+
+    arguments.Append(!trampoline.recv.IsEmpty() ? trampoline.recv.Value() : env.Undefined());
 
     // Convert to JS arguments
     for (Size i = 0; i < proto->parameters.len; i++) {
@@ -715,12 +718,12 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
                     // Reassemble float or mixed int-float structs from registers
                     int realign = param.vec_count ? 8 : 0;
 
-                    Napi::Object obj = PopObject((const uint8_t *)buf, param.type, realign);
+                    Napi::Object obj = DecodeObject(env, (const uint8_t *)buf, param.type, realign);
                     arguments.Append(obj);
                 } else {
                     uint8_t *ptr = *(uint8_t **)((param.gpr_count ? gpr_ptr : args_ptr)++);
 
-                    Napi::Object obj = PopObject(ptr, param.type);
+                    Napi::Object obj = DecodeObject(env, ptr, param.type);
                     arguments.Append(obj);
                 }
             } break;
@@ -760,7 +763,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
 
     // Make the call
     napi_value ret = CallSwitchStack(&func, (size_t)arguments.len, arguments.data, old_sp, &mem->stack,
-                                     [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argc, argv); });
+                                     [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argv[0], argc - 1, argv + 1); });
     Napi::Value value(env, ret);
 
     if (RG_UNLIKELY(env.IsExceptionPending()))
@@ -773,7 +776,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
                 return; \
             } \
              \
-            CType v = CopyNumber<CType>(value); \
+            CType v = GetNumber<CType>(value); \
             out_reg->a0 = (uint64_t)v; \
         } while (false)
 #define RETURN_INTEGER_SWAP(CType) \
@@ -783,7 +786,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
                 return; \
             } \
              \
-            CType v = CopyNumber<CType>(value); \
+            CType v = GetNumber<CType>(value); \
             out_reg->a0 = (uint64_t)ReverseBytes(v); \
         } while (false)
 
@@ -815,14 +818,14 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
         case PrimitiveKind::UInt64S: { RETURN_INTEGER_SWAP(uint64_t); } break;
         case PrimitiveKind::String: {
             const char *str;
-            if (RG_UNLIKELY(!PushString(value, &str)))
+            if (RG_UNLIKELY(!PushString(value, 1, &str)))
                 return;
 
             out_reg->a0 = (uint64_t)str;
         } break;
         case PrimitiveKind::String16: {
             const char16_t *str16;
-            if (RG_UNLIKELY(!PushString16(value, &str16)))
+            if (RG_UNLIKELY(!PushString16(value, 1, &str16)))
                 return;
 
             out_reg->a0 = (uint64_t)str16;
@@ -873,7 +876,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
                 return;
             }
 
-            float f = CopyNumber<float>(value);
+            float f = GetNumber<float>(value);
             memset((uint8_t *)&out_reg->fa0 + 4, 0xFF, 4);
             memcpy(&out_reg->fa0, &f, 4);
         } break;
@@ -883,7 +886,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
                 return;
             }
 
-            double d = CopyNumber<double>(value);
+            double d = GetNumber<double>(value);
             out_reg->fa0 = d;
         } break;
         case PrimitiveKind::Callback: {