koffi 2.1.5 → 2.2.1

package/src/koffi/src/abi_x64_sysv.cc

@@ -311,7 +311,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) \
@@ -321,7 +321,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)
 
@@ -360,14 +360,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;
@@ -424,7 +424,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                     return false;
                 }
 
-                float f = CopyNumber<float>(value);
+                float f = GetNumber<float>(value);
                 uint64_t *ptr = (param.xmm_count ? xmm_ptr : args_ptr)++;
 
                 memset((uint8_t *)ptr + 4, 0, 4);
@@ -436,7 +436,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                     return false;
                 }
 
-                double d = CopyNumber<double>(value);
+                double d = GetNumber<double>(value);
                 *(double *)((param.xmm_count ? xmm_ptr : args_ptr)++) = d;
             } break;
             case PrimitiveKind::Callback: {
@@ -474,6 +474,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) \
@@ -574,7 +575,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;
@@ -611,7 +612,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++) {
@@ -775,12 +778,12 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
                         }
                     }
 
-                    Napi::Object obj = PopObject((const uint8_t *)buf, param.type);
+                    Napi::Object obj = DecodeObject(env, (const uint8_t *)buf, param.type);
                     arguments.Append(obj);
                 } else if (param.use_memory) {
                     args_ptr = AlignUp(args_ptr, param.type->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 + 7) / 8;
@@ -808,7 +811,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()))
@@ -821,7 +824,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->rax = (uint64_t)v; \
         } while (false)
 #define RETURN_INTEGER_SWAP(CType) \
@@ -831,7 +834,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->rax = (uint64_t)ReverseBytes(v); \
         } while (false)
 
@@ -863,14 +866,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->rax = (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->rax = (uint64_t)str16;
@@ -937,7 +940,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->xmm0 + 4, 0, 4);
             memcpy(&out_reg->xmm0, &f, 4);
@@ -948,7 +951,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->xmm0 = d;
         } break;
         case PrimitiveKind::Callback: {

package/src/koffi/src/abi_x64_win.cc

@@ -142,7 +142,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 return false; \
             } \
              \
-            CType v = CopyNumber<CType>(value); \
+            CType v = GetNumber<CType>(value); \
             *(args_ptr++) = (uint64_t)v; \
         } while (false)
 #define PUSH_INTEGER_SWAP(CType) \
@@ -152,7 +152,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 return false; \
             } \
              \
-            CType v = CopyNumber<CType>(value); \
+            CType v = GetNumber<CType>(value); \
             *(args_ptr++) = (uint64_t)ReverseBytes(v); \
         } while (false)
 
@@ -192,14 +192,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 **)(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 **)(args_ptr++) = str16;
@@ -236,7 +236,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                     return false;
                 }
 
-                float f = CopyNumber<float>(value);
+                float f = GetNumber<float>(value);
 
                 memset((uint8_t *)args_ptr + 4, 0, 4);
                 *(float *)(args_ptr++) = f;
@@ -247,7 +247,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                     return false;
                 }
 
-                double d = CopyNumber<double>(value);
+                double d = GetNumber<double>(value);
                 *(double *)(args_ptr++) = d;
             } break;
             case PrimitiveKind::Callback: {
@@ -285,6 +285,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) \
@@ -370,7 +371,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;
@@ -406,7 +407,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, j = !!return_ptr; i < proto->parameters.len; i++, j++) {
@@ -574,7 +577,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
                 }
                 args_ptr += (j >= 4);
 
-                Napi::Object obj2 = PopObject(ptr, param.type);
+                Napi::Object obj2 = DecodeObject(env, ptr, param.type);
                 arguments.Append(obj2);
             } break;
             case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
@@ -601,7 +604,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()))
@@ -614,7 +617,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->rax = (uint64_t)v; \
         } while (false)
 #define RETURN_INTEGER_SWAP(CType) \
@@ -624,7 +627,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->rax = (uint64_t)ReverseBytes(v); \
         } while (false)
 
@@ -655,14 +658,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->rax = (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->rax = (uint64_t)str16;
@@ -711,7 +714,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->xmm0 + 4, 0, 4);
             memcpy(&out_reg->xmm0, &f, 4);
@@ -722,7 +725,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->xmm0 = d;
         } break;
         case PrimitiveKind::Callback: {

package/src/koffi/src/abi_x86.cc

@@ -198,7 +198,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 return false; \
             } \
              \
-            CType v = CopyNumber<CType>(value); \
+            CType v = GetNumber<CType>(value); \
             *((param.fast ? fast_ptr : args_ptr)++) = (uint32_t)v; \
         } while (false)
 #define PUSH_INTEGER_32_SWAP(CType) \
@@ -208,7 +208,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 return false; \
             } \
              \
-            CType v = CopyNumber<CType>(value); \
+            CType v = GetNumber<CType>(value); \
             *((param.fast ? fast_ptr : args_ptr)++) = (uint32_t)ReverseBytes(v); \
         } while (false)
 #define PUSH_INTEGER_64(CType) \
@@ -218,7 +218,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 return false; \
             } \
              \
-            CType v = CopyNumber<CType>(value); \
+            CType v = GetNumber<CType>(value); \
              \
             *(uint64_t *)args_ptr = (uint64_t)v; \
             args_ptr += 2; \
@@ -230,7 +230,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 return false; \
             } \
              \
-            CType v = CopyNumber<CType>(value); \
+            CType v = GetNumber<CType>(value); \
              \
             *(uint64_t *)args_ptr = (uint64_t)ReverseBytes(v); \
             args_ptr += 2; \
@@ -271,14 +271,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.fast ? fast_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.fast ? fast_ptr : args_ptr)++) = str16;
@@ -316,7 +316,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                     return false;
                 }
 
-                float f = CopyNumber<float>(value);
+                float f = GetNumber<float>(value);
                 *(float *)((param.fast ? fast_ptr : args_ptr)++) = f;
             } break;
             case PrimitiveKind::Float64: {
@@ -325,7 +325,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                     return false;
                 }
 
-                double d = CopyNumber<double>(value);
+                double d = GetNumber<double>(value);
                 *(double *)args_ptr = d;
                 args_ptr += 2;
             } break;
@@ -366,6 +366,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) \
@@ -452,7 +453,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;
@@ -502,7 +503,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++) {
@@ -652,7 +655,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
 
                 uint8_t *ptr = (uint8_t *)args_ptr;
 
-                Napi::Object obj2 = PopObject(ptr, param.type);
+                Napi::Object obj2 = DecodeObject(env, ptr, param.type);
                 arguments.Append(obj2);
 
                 args_ptr = (uint32_t *)AlignUp(ptr + param.type->size, 4);
@@ -680,7 +683,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()))
@@ -693,7 +696,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->eax = (uint32_t)v; \
         } while (false)
 #define RETURN_INTEGER_32_SWAP(CType) \
@@ -703,7 +706,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->eax = (uint32_t)ReverseBytes(v); \
         } while (false)
 #define RETURN_INTEGER_64(CType) \
@@ -713,7 +716,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->eax = (uint32_t)((uint64_t)v >> 32); \
             out_reg->edx = (uint32_t)((uint64_t)v & 0xFFFFFFFFu); \
@@ -725,7 +728,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->eax = (uint32_t)((uint64_t)v >> 32); \
             out_reg->edx = (uint32_t)((uint64_t)v & 0xFFFFFFFFu); \
@@ -758,14 +761,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->eax = (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->eax = (uint32_t)str16;
@@ -814,7 +817,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
                 return;
             }
 
-            out_reg->x87.f = CopyNumber<float>(value);
+            out_reg->x87.f = GetNumber<float>(value);
             out_reg->x87_double = false;
         } break;
         case PrimitiveKind::Float64: {
@@ -823,7 +826,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
                 return;
             }
 
-            out_reg->x87.d = CopyNumber<double>(value);
+            out_reg->x87.d = GetNumber<double>(value);
             out_reg->x87_double = true;
         } break;
         case PrimitiveKind::Callback: {