koffi 2.16.1 → 3.0.0-alpha.2

package/src/koffi/src/call.hh

@@ -39,135 +39,114 @@ struct alignas(8) CallData {
 
     Napi::Env env;
     InstanceData *instance;
-
     InstanceMemory *mem;
-    Span<uint8_t> old_stack_mem;
-    Span<uint8_t> old_heap_mem;
-
-    uint8_t *new_sp;
-    uint8_t *old_sp;
-
-    union {
-        int8_t i8;
-        uint8_t u8;
-        int16_t i16;
-        uint16_t u16;
-        int32_t i32;
-        uint32_t u32;
-        int64_t i64;
-        uint64_t u64;
-        float f;
-        double d;
-        void *ptr;
-        uint8_t buf[32];
-    } result;
-    uint8_t *return_ptr = nullptr;
+    void *native;
 
-    LocalArray<int16_t, 16> used_trampolines;
-    HeapArray<OutArgument> out_arguments;
+    uint8_t *prev_stack;
+    uint8_t *prev_heap;
+    uint8_t *saved_sp;
+    bool release_alloc = false;
 
-    BlockAllocator alloc;
+    uint8_t *async_base;
+    const AbiInstruction *async_ip;
 
-public:
-    CallData(Napi::Env env, InstanceData *instance, InstanceMemory *mem);
-    ~CallData();
+    LocalArray<int16_t, 16> used_trampolines;
+    LocalArray<OutArgument, MaxParameters> out_arguments;
 
-    void Dispose();
+#if defined(K_DEBUG)
+    bool finalized = false;
+#endif
 
-#if defined(UNITY_BUILD)
-    #if defined(_MSC_VER)
-        #define INLINE_IF_UNITY __forceinline
-    #else
-        #define INLINE_IF_UNITY __attribute__((always_inline)) inline
-    #endif
-#else
-    #define INLINE_IF_UNITY
+    CallData(napi_env env, InstanceData *instance, InstanceMemory *mem, void *native)
+        : env(env), instance(instance), mem(mem), native(native),
+          prev_stack(mem->stack.end), prev_heap(mem->heap.ptr) {}
+#if defined(K_DEBUG)
+    ~CallData();
 #endif
 
-    INLINE_IF_UNITY bool Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info);
-    INLINE_IF_UNITY void Execute(const FunctionInfo *func, void *native);
-    INLINE_IF_UNITY Napi::Value Complete(const FunctionInfo *func);
+    INLINE_UNITY napi_value Run(const FunctionInfo *func, napi_value *args);
+
+    bool PrepareAsync(const FunctionInfo *func, napi_value *args);
+    void ExecuteAsync();
+    napi_value EndAsync();
 
-#undef INLINE_IF_UNITY
+    INLINE_UNITY void Finalize();
+    INLINE_UNITY void FinalizeFast();
 
     void Relay(Size idx, uint8_t *sp);
     void RelayAsync(Size idx, uint8_t *sp);
 
-    void DumpForward(const FunctionInfo *func) const;
-
-    bool PushString(Napi::Value value, int directions, const char **out_str);
-    bool PushString16(Napi::Value value, int directions, const char16_t **out_str16);
-    bool PushString32(Napi::Value value, int directions, const char32_t **out_str32);
-    Size PushStringValue(Napi::Value value, const char **out_str);
-    Size PushString16Value(Napi::Value value, const char16_t **out_str16);
-    Size PushString32Value(Napi::Value value, const char32_t **out_str32);
-    bool PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origin);
+    INLINE_UNITY bool PushString(napi_value value, int directions, const char **out_str);
+    INLINE_UNITY bool PushString16(napi_value value, int directions, const char16_t **out_str16);
+    INLINE_UNITY bool PushString32(napi_value value, int directions, const char32_t **out_str32);
+    INLINE_UNITY Size PushStringValue(napi_value value, const char **out_str);
+    INLINE_UNITY Size PushString16Value(napi_value value, const char16_t **out_str16);
+    INLINE_UNITY Size PushString32Value(napi_value value, const char32_t **out_str32);
+    bool PushObject(napi_value value, const TypeInfo *type, uint8_t *origin);
     bool PushNormalArray(Napi::Array array, const TypeInfo *type, Size size, uint8_t *origin);
-    void PushBuffer(Span<const uint8_t> buffer, const TypeInfo *type, uint8_t *origin);
-    bool PushStringArray(Napi::Value value, const TypeInfo *type, uint8_t *origin);
-    bool PushPointer(Napi::Value value, const TypeInfo *type, int directions, void **out_ptr);
-    bool PushCallback(Napi::Value value, const TypeInfo *type, void **out_ptr);
-    Size PushIndirectString(Napi::Array array, const TypeInfo *ref, uint8_t **out_ptr);
+    INLINE_UNITY void PushBuffer(Span<const uint8_t> buffer, const TypeInfo *type, uint8_t *origin);
+    bool PushStringArray(napi_value value, const TypeInfo *type, uint8_t *origin);
+    INLINE_UNITY bool PushPointer(napi_value value, const TypeInfo *type, int directions, void **out_ptr);
+    bool PushPointerSlow(napi_value value, const TypeInfo *type, int directions, void **out_ptr);
+    INLINE_UNITY bool PushCallback(napi_value value, const TypeInfo *type, void **out_ptr);
+    Size PushIndirectString(Napi::Array array, const TypeInfo *ref, void **out_ptr);
 
     void *ReserveTrampoline(const FunctionInfo *proto, Napi::Function func);
 
     template <typename T>
-    bool AllocStack(Size size, Size align, T **out_ptr);
+    T *AllocStack(Size size);
     template <typename T = uint8_t>
-    T *AllocHeap(Size size, Size align);
-
-    bool CheckDynamicLength(Napi::Object obj, Size element, const char *countedby, Napi::Value value);
+    T *AllocHeap(Size size);
 
-    void PopOutArguments();
+    bool CheckDynamicLength(napi_value obj, Size element, const char *countedby, napi_value value);
 };
 
 template <typename T>
-inline bool CallData::AllocStack(Size size, Size align, T **out_ptr)
+inline T *CallData::AllocStack(Size size)
 {
-    uint8_t *ptr = AlignDown(mem->stack.end() - size, align);
-    Size delta = mem->stack.end() - ptr;
+    uint8_t *ptr = AlignDown(mem->stack.end, 16) - size;
 
     // Keep 512 bytes for redzone (required in some ABIs)
-    if (mem->stack.len - 512 < delta) [[unlikely]] {
+    if (ptr < mem->stack.ptr + 512) [[unlikely]] {
         ThrowError<Napi::Error>(env, "FFI call is taking up too much memory");
-        return false;
+        return nullptr;
     }
 
 #if defined(K_DEBUG)
-    MemSet(ptr, 0, delta);
+    Size len = mem->stack.end - ptr;
+    MemSet(ptr, 0, len);
 #endif
 
-    mem->stack.len -= delta;
+    mem->stack.end = ptr;
 
-    *out_ptr = (T *)ptr;
-    return true;
+    return (T *)ptr;
 }
 
 template <typename T>
-inline T *CallData::AllocHeap(Size size, Size align)
+inline T *CallData::AllocHeap(Size size)
 {
-    uint8_t *ptr = AlignUp(mem->heap.ptr, align);
-    Size delta = size + (ptr - mem->heap.ptr);
+    K_ASSERT(AlignUp(mem->heap.ptr, 16) == mem->heap.ptr);
 
-    if (size < 4096 && delta <= mem->heap.len) [[likely]] {
+    uint8_t *ptr = mem->heap.ptr;
+    uint8_t *end = AlignUp(ptr + size, 16);
+
+    if (end <= mem->heap.end) [[likely]] {
 #if defined(K_DEBUG)
-        MemSet(mem->heap.ptr, 0, delta);
+        MemSet(ptr, 0, size);
 #endif
 
-        mem->heap.ptr += delta;
-        mem->heap.len -= delta;
+        mem->heap.ptr = end;
 
         return ptr;
     } else {
+        ptr = (uint8_t *)AllocateRaw(&mem->allocator, size + 16);
+        ptr = AlignUp(ptr, 16);
+        release_alloc |= (prev_stack == mem->stack.end);
+
 #if defined(K_DEBUG)
-        int flags = (int)AllocFlag::Zero;
-#else
-        int flags = 0;
+        MemSet(ptr, 0, size);
 #endif
 
-        ptr = (uint8_t *)AllocateRaw(&alloc, size + align, flags);
-        ptr = AlignUp(ptr, align);
-
         return ptr;
     }
 }