koffi 2.16.0-beta.2 → 2.16.0

package/src/koffi/src/call.hh

@@ -17,7 +17,7 @@ struct BackRegisters;
 
 // I'm not sure why the alignas(8), because alignof(CallData) is 8 without it.
 // But on Windows i386, without it, the alignment may not be correct (compiler bug?).
-class alignas(8) CallData {
+struct alignas(8) CallData {
     struct OutArgument {
         enum class Kind {
             Array,
@@ -66,7 +66,7 @@ class alignas(8) CallData {
     LocalArray<int16_t, 16> used_trampolines;
     HeapArray<OutArgument> out_arguments;
 
-    BlockAllocator call_alloc;
+    BlockAllocator alloc;
 
 public:
     CallData(Napi::Env env, InstanceData *instance, InstanceMemory *mem);
@@ -77,10 +77,8 @@ public:
 #if defined(UNITY_BUILD)
     #if defined(_MSC_VER)
         #define INLINE_IF_UNITY __forceinline
-    #elif defined(__clang__)
-        #define INLINE_IF_UNITY __attribute__((always_inline)) inline
     #else
-        #define INLINE_IF_UNITY
+        #define INLINE_IF_UNITY __attribute__((always_inline)) inline
     #endif
 #else
     #define INLINE_IF_UNITY
@@ -92,9 +90,8 @@ public:
 
 #undef INLINE_IF_UNITY
 
-    void Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool switch_stack, BackRegisters *out_reg);
-    void RelaySafe(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool outside_call, BackRegisters *out_reg);
-    static void RelayAsync(napi_env, napi_value, void *, void *udata);
+    void Relay(Size idx, uint8_t *sp);
+    void RelayAsync(Size idx, uint8_t *sp);
 
     void DumpForward(const FunctionInfo *func) const;
 
@@ -114,11 +111,8 @@ public:
 
     void *ReserveTrampoline(const FunctionInfo *proto, Napi::Function func);
 
-    BlockAllocator *GetAllocator() { return &call_alloc; }
-
-private:
     template <typename T>
-    T *AllocStack(Size size);
+    bool AllocStack(Size size, Size align, T **out_ptr);
     template <typename T = uint8_t>
     T *AllocHeap(Size size, Size align);
 
@@ -128,15 +122,15 @@ private:
 };
 
 template <typename T>
-inline T *CallData::AllocStack(Size size)
+inline bool CallData::AllocStack(Size size, Size align, T **out_ptr)
 {
-    uint8_t *ptr = AlignDown(mem->stack.end(), 16) - size;
+    uint8_t *ptr = AlignDown(mem->stack.end() - size, align);
     Size delta = mem->stack.end() - ptr;
 
     // Keep 512 bytes for redzone (required in some ABIs)
     if (mem->stack.len - 512 < delta) [[unlikely]] {
         ThrowError<Napi::Error>(env, "FFI call is taking up too much memory");
-        return nullptr;
+        return false;
     }
 
 #if defined(K_DEBUG)
@@ -145,7 +139,8 @@ inline T *CallData::AllocStack(Size size)
 
     mem->stack.len -= delta;
 
-    return (T *)ptr;
+    *out_ptr = (T *)ptr;
+    return true;
 }
 
 template <typename T>
@@ -170,13 +165,15 @@ inline T *CallData::AllocHeap(Size size, Size align)
         int flags = 0;
 #endif
 
-        ptr = (uint8_t *)AllocateRaw(&call_alloc, size + align, flags);
+        ptr = (uint8_t *)AllocateRaw(&alloc, size + align, flags);
         ptr = AlignUp(ptr, align);
 
         return ptr;
     }
 }
 
-void *GetTrampoline(int16_t idx);
+void PerformAsyncRelay(napi_env env, napi_value callback, void *ctx, void *udata);
+
+void *GetTrampoline(int idx);
 
 }

package/src/koffi/src/ffi.cc

@@ -39,6 +39,8 @@ SharedData shared;
 
 static thread_local CallData *exec_call;
 
+extern "C" napi_value SwitchAndRelay(CallData *call, Size idx, uint8_t *sp, uint8_t *saved_sp, Span<uint8_t> *new_stack);
+
 static bool ChangeSize(const char *name, Napi::Value value, Size min_size, Size max_size, Size *out_size)
 {
     Napi::Env env = value.Env();
@@ -138,20 +140,6 @@ static Napi::Value GetSetConfig(const Napi::CallbackInfo &info)
             } else if (key == "max_type_size") {
                 if (!ChangeSize(key.c_str(), value, 32, Mebibytes(512), &new_config.max_type_size))
                     return env.Null();
-            } else if (key == "fast_pointers") {
-                if (!value.IsBoolean()) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for '%2', expected boolean", GetValueType(instance, value), key.c_str());
-                    return env.Null();
-                }
-
-                new_config.fast_pointers = value.As<Napi::Boolean>();
-            } else if (key == "fast_callbacks") {
-                if (!value.IsBoolean()) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for '%2', expected boolean", GetValueType(instance, value), key.c_str());
-                    return env.Null();
-                }
-
-                new_config.fast_callbacks = value.As<Napi::Boolean>();
             } else {
                 ThrowError<Napi::Error>(env, "Unexpected config member '%1'", key.c_str());
                 return env.Null();
@@ -176,8 +164,6 @@ static Napi::Value GetSetConfig(const Napi::CallbackInfo &info)
     obj.Set("resident_async_pools", instance->config.resident_async_pools);
     obj.Set("max_async_calls", instance->config.resident_async_pools + instance->config.max_temporaries);
     obj.Set("max_type_size", instance->config.max_type_size);
-    obj.Set("fast_pointers", instance->config.fast_pointers);
-    obj.Set("fast_callbacks", instance->config.fast_callbacks);
 
     return obj;
 }
@@ -806,10 +792,13 @@ static Napi::Value CreateDisposableType(const Napi::CallbackInfo &info)
             InstanceData *instance = env.GetInstanceData<InstanceData>();
             const Napi::FunctionReference &ref = type->dispose_ref;
 
-            Napi::Value p = WrapPointer(env, type->ref.type, (void *)ptr);
+            Napi::External<void> external = Napi::External<void>::New(env, (void *)ptr);
+            SetValueTag(external, type->ref.marker);
 
-            napi_value self = env.Null();
-            napi_value args[] = { p };
+            Napi::Value self = env.Null();
+            napi_value args[] = {
+                external
+            };
 
             ref.Call(self, K_LEN(args), args);
             instance->stats.disposed++;
@@ -837,15 +826,8 @@ static Napi::Value CreateDisposableType(const Napi::CallbackInfo &info)
     type->dispose_ref = Napi::Persistent(dispose_func);
 
     // If the insert succeeds, we cannot fail anymore
-    if (named) {
-        bool inserted;
-        instance->types_map.InsertOrGet(type->name, type, &inserted);
-
-        if (!inserted) {
-            ThrowError<Napi::Error>(env, "Duplicate type name '%1'", type->name);
-            return env.Null();
-        }
-    }
+    if (named && !MapType(env, instance, type, type->name))
+        return env.Null();
     err_guard.Disable();
 
     return WrapType(env, type);
@@ -855,12 +837,26 @@ static inline bool GetExternalPointer(Napi::Env env, Napi::Value value, void **o
 {
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
-    if (!TryPointer(value, out_ptr)) {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for ptr, expected pointer", GetValueType(instance, value));
+    if (IsNullOrUndefined(value)) {
+        *out_ptr = 0;
+        return true;
+    } else if (IsRawBuffer(value)) {
+        Span<uint8_t> buffer = GetRawBuffer(value);
+
+        *out_ptr = buffer.ptr;
+        return true;
+    } else if (value.IsExternal() && !CheckValueTag(value, &TypeInfoMarker) &&
+                                     !CheckValueTag(value, &CastMarker) &&
+                                     !CheckValueTag(value, &MagicUnionMarker)) {
+        Napi::External<void> external = value.As<Napi::External<void>>();
+        void *ptr = external.Data();
+
+        *out_ptr = ptr;
+        return true;
+    } else {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for ptr, expected external pointer", GetValueType(instance, value));
         return false;
     }
-
-    return true;
 }
 
 static Napi::Value CallAlloc(const Napi::CallbackInfo &info)
@@ -906,7 +902,10 @@ static Napi::Value CallAlloc(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    return WrapPointer(env, type, ptr);
+    Napi::External<void> external = Napi::External<void>::New(env, ptr);
+    SetValueTag(external, type);
+
+    return external;
 }
 
 static Napi::Value CallFree(const Napi::CallbackInfo &info)
@@ -1140,7 +1139,12 @@ static Napi::Value CreateFunctionType(const Napi::CallbackInfo &info)
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
     FunctionInfo *func = instance->callbacks.AppendDefault();
-    K_DEFER_N(err_guard) { instance->callbacks.RemoveLast(1); };
+    TypeInfo *type = instance->types.AppendDefault();
+
+    K_DEFER_N(err_guard) {
+        instance->callbacks.RemoveLast(1);
+        instance->types.RemoveLast(1);
+    };
 
     if (info.Length() >= 2) {
         if (!ParseClassicFunction(info, false, func))
@@ -1168,29 +1172,12 @@ static Napi::Value CreateFunctionType(const Napi::CallbackInfo &info)
     if (!AnalyseFunction(env, instance, func))
         return env.Null();
 
-    // Branchless push loop
-    for (const ParameterInfo &param: func->parameters) {
-        func->primitives.Append(param.type->primitive);
-    }
-    if (!func->variadic) {
-        func->primitives.Append(PrimitiveKind::Prototype);
-    }
-
     // Adjust parameter offsets for koffi.call()
     for (ParameterInfo &param: func->parameters) {
         param.offset += 2;
     }
     func->required_parameters += 2;
 
-    // We cannot fail after this check
-    if (named && instance->types_map.Find(func->name)) {
-        ThrowError<Napi::Error>(env, "Duplicate type name '%1'", func->name);
-        return env.Null();
-    }
-    err_guard.Disable();
-
-    TypeInfo *type = instance->types.AppendDefault();
-
     type->name = func->name;
 
     type->primitive = PrimitiveKind::Prototype;
@@ -1198,7 +1185,10 @@ static Napi::Value CreateFunctionType(const Napi::CallbackInfo &info)
     type->size = K_SIZE(void *);
     type->ref.proto = func;
 
-    instance->types_map.Set(type->name, type);
+    // If the insert succeeds, we cannot fail anymore
+    if (named && !MapType(env, instance, type, type->name))
+        return env.Null();
+    err_guard.Disable();
 
     return WrapType(env, type);
 }
@@ -1441,6 +1431,18 @@ InstanceMemory *AllocateMemory(InstanceData *instance, Size stack_size, Size hea
     // Keep real stack limits intact, in case we need them
     mem->stack0 = mem->stack;
 
+#if defined(_WIN32) && !defined(_WIN64)
+    mem->stack.len -= K_SIZE(SehFrame);
+
+    // Prepare at the top SEH frame record
+    {
+        SehFrame *seh = (SehFrame *)mem->stack.end();
+
+        seh->Next = (void *)-1;
+        seh->Handler = (void *)SehHandler;
+    }
+#endif
+
     mem->heap.len = heap_size;
 #if defined(_WIN32)
     mem->heap.ptr = (uint8_t *)VirtualAlloc(nullptr, mem->heap.len, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
@@ -1526,105 +1528,62 @@ static Napi::Value TranslateVariadicCall(const FunctionInfo *func, void *native,
     Napi::Env env = info.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
-    FunctionInfo *variadic = nullptr;
-    K_DEFER_N(err_guard) { delete variadic; };
-
-    // Try cached function
-    {
-        FunctionInfo *prev = instance->variadic_func;
-
-        if (prev && prev->native == native) {
-            Size specified = (info.Length() - prev->required_parameters);
-            Size processed = (prev->parameters.len - prev->required_parameters) * 2;
-
-            if (specified == processed) {
-                bool match = true;
+    FunctionInfo copy;
+    memcpy((void *)&copy, func, K_SIZE(*func));
+    copy.lib = nullptr;
 
-                for (Size i = prev->required_parameters, j = prev->required_parameters; i < (Size)info.Length(); i += 2, j++) {
-                    int directions;
-                    const TypeInfo *type = ResolveType(info[(uint32_t)i], &directions);
-
-                    if (type != prev->parameters[j].type || directions != prev->parameters[j].directions) [[unlikely]] {
-                        match = false;
-                        break;
-                    }
-                }
-
-                if (match) [[likely]] {
-                    variadic = prev;
+    // This makes variadic calls non-reentrant
+    K_DEFER_C(len = copy.parameters.len) {
+        copy.parameters.RemoveFrom(len);
+        copy.parameters.Leak();
+    };
 
-                    // If an error happens it'll get destroyed, so don't keep it around
-                    instance->variadic_func = nullptr;
-                }
-            }
-        }
+    if (info.Length() < (uint32_t)copy.required_parameters) [[unlikely]] {
+        ThrowError<Napi::TypeError>(env, "Expected %1 arguments or more, got %2", copy.parameters.len, info.Length());
+        return env.Null();
+    }
+    if ((info.Length() - copy.required_parameters) % 2) [[unlikely]] {
+        ThrowError<Napi::Error>(env, "Missing value argument for variadic call");
+        return env.Null();
     }
 
-    if (!variadic) {
-        variadic = new FunctionInfo();
-
-        memcpy((void *)variadic, func, K_SIZE(*func));
-        memset((void *)&variadic->parameters, 0, K_SIZE(variadic->parameters));
-        memset((void *)&variadic->primitives, 0, K_SIZE(variadic->primitives));
+    for (Size i = copy.required_parameters; i < (Size)info.Length(); i += 2) {
+        ParameterInfo param = {};
 
-        variadic->parameters = func->parameters;
-        variadic->primitives = func->primitives;
-        variadic->lib = nullptr;
+        param.type = ResolveType(info[(uint32_t)i], &param.directions);
 
-        if (info.Length() < (uint32_t)variadic->required_parameters) [[unlikely]] {
-            ThrowError<Napi::TypeError>(env, "Expected %1 arguments or more, got %2", variadic->parameters.len, info.Length());
+        if (!param.type) [[unlikely]]
+            return env.Null();
+        if (!CanPassType(param.type, param.directions)) [[unlikely]] {
+            ThrowError<Napi::TypeError>(env, "Type %1 cannot be used as a parameter", param.type->name);
             return env.Null();
         }
-        if ((info.Length() - variadic->required_parameters) % 2) [[unlikely]] {
-            ThrowError<Napi::Error>(env, "Missing value argument for variadic call");
+        if (copy.parameters.len >= MaxParameters) [[unlikely]] {
+            ThrowError<Napi::TypeError>(env, "Functions cannot have more than %1 parameters", MaxParameters);
             return env.Null();
         }
-
-        for (Size i = variadic->required_parameters; i < (Size)info.Length(); i += 2) {
-            ParameterInfo param = {};
-
-            param.type = ResolveType(info[(uint32_t)i], &param.directions);
-
-            if (!param.type) [[unlikely]]
-                return env.Null();
-            if (!CanPassType(param.type, param.directions)) [[unlikely]] {
-                ThrowError<Napi::TypeError>(env, "Type %1 cannot be used as a parameter", param.type->name);
-                return env.Null();
-            }
-            if (variadic->parameters.len >= MaxParameters) [[unlikely]] {
-                ThrowError<Napi::TypeError>(env, "Functions cannot have more than %1 parameters", MaxParameters);
-                return env.Null();
-            }
-            if ((param.directions & 2) && ++variadic->out_parameters >= MaxParameters) [[unlikely]] {
-                ThrowError<Napi::TypeError>(env, "Functions cannot have more than %1 output parameters", MaxParameters);
-                return env.Null();
-            }
-
-            param.variadic = true;
-            param.offset = (int8_t)(i + 1);
-
-            variadic->parameters.Append(param);
+        if ((param.directions & 2) && ++copy.out_parameters >= MaxParameters) [[unlikely]] {
+            ThrowError<Napi::TypeError>(env, "Functions cannot have more than %1 output parameters", MaxParameters);
+            return env.Null();
         }
 
-        if (!AnalyseFunction(env, instance, variadic)) [[unlikely]]
-            return env.Null();
+        param.variadic = true;
+        param.offset = (int8_t)(i + 1);
 
-        // Branchless push loop
-        for (Size i = func->parameters.len; i < variadic->parameters.len; i++) {
-            const ParameterInfo &param = variadic->parameters[i];
-            variadic->primitives.Append(param.type->primitive);
-        }
-        variadic->primitives.Append(PrimitiveKind::Prototype);
+        copy.parameters.Append(param);
     }
 
+    if (!AnalyseFunction(env, instance, &copy)) [[unlikely]]
+        return env.Null();
+
     InstanceMemory *mem = instance->memories[0];
     CallData call(env, instance, mem);
 
-    if (!call.Prepare(variadic, info)) [[unlikely]]
+    if (!call.Prepare(&copy, info)) [[unlikely]]
         return env.Null();
 
     if (instance->debug) {
-        call.DumpForward(variadic);
+        call.DumpForward(&copy);
     }
 
     // Execute call
@@ -1632,17 +1591,10 @@ static Napi::Value TranslateVariadicCall(const FunctionInfo *func, void *native,
         K_DEFER_C(prev_call = exec_call) { exec_call = prev_call; };
         exec_call = &call;
 
-        call.Execute(variadic, native);
-    }
-
-    if (variadic != instance->variadic_func) {
-        err_guard.Disable();
-
-        delete instance->variadic_func;
-        instance->variadic_func = variadic;
+        call.Execute(&copy, native);
     }
 
-    return call.Complete(variadic);
+    return call.Complete(&copy);
 }
 
 Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
@@ -1699,8 +1651,11 @@ void AsyncCall::OnOK()
 
     Napi::FunctionReference &callback = Callback();
 
-    napi_value self = env.Null();
-    napi_value args[] = { env.Null(), call.Complete(func) };
+    Napi::Value self = env.Null();
+    napi_value args[] = {
+        env.Null(),
+        call.Complete(func)
+    };
 
     callback.Call(self, K_LEN(args), args);
 }
@@ -1746,35 +1701,54 @@ Napi::Value TranslateAsyncCall(const Napi::CallbackInfo &info)
     return TranslateAsyncCall(func, func->native, info);
 }
 
-extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
+extern "C" void RelayCallback(Size idx, uint8_t *sp)
 {
-    if (exec_call) [[likely]] {
-        exec_call->RelaySafe(idx, own_sp, caller_sp, false, out_reg);
-    } else {
-        // This happens if the callback pointer is called from a different thread
-        // than the one that runs the FFI call (sync or async).
+    CallData *call = exec_call;
 
-        TrampolineInfo *trampoline = &shared.trampolines[idx];
+    // Try the fast path first: we are on the main thread and we are running a native call through Koffi.
+    // It should be easy, but in this case we are running on the custom Koffi stack, which will trip up
+    // Node and V8. So we need to switch back to the normal/main stack.
+    if (call && std::this_thread::get_id() == call->instance->main_thread_id) {
+        SwitchAndRelay(call, idx, sp, call->old_sp, &call->mem->stack);
+        return;
+    }
 
-        Napi::Env env = trampoline->func.Env();
-        InstanceData *instance = env.GetInstanceData<InstanceData>();
+    // Otherwise, we need to allocate memory to perform the callback.
+    // Since the necessary machinery live in CallData, just use a temporary instance.
+    // In some cases we would reuse the existing call (exec_call may be not null),
+    // but it is rare so let's ignore this for simplicity.
 
-        InstanceMemory *mem = AllocateMemory(instance, instance->config.async_stack_size, instance->config.async_heap_size);
-        if (!mem) [[unlikely]] {
-            ThrowError<Napi::Error>(env, "Too many asynchronous calls are running");
-            return;
-        }
+    TrampolineInfo *trampoline = &shared.trampolines[idx];
+    Napi::Env env = trampoline->func.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    InstanceMemory *mem = AllocateMemory(instance, instance->config.async_stack_size, instance->config.async_heap_size);
+    if (!mem) [[unlikely]] {
+        ThrowError<Napi::Error>(env, "Too many asynchronous calls are running");
+        return;
+    }
+
+    // Avoid triggering the "use callback beyond FFI" check
+    K_DEFER_C(generation = trampoline->generation) { trampoline->generation = generation; };
+    trampoline->generation = -1;
 
-        // Avoid triggering the "use callback beyond FFI" check
-        K_DEFER_C(generation = trampoline->generation) { trampoline->generation = generation; };
-        trampoline->generation = -1;
+    if (std::this_thread::get_id() == instance->main_thread_id) {
+        CallData call(env, instance, mem);
 
-        // We set dispose_call to true so that the main thread will dispose of CallData itself
+        Napi::HandleScope scope(env);
+        call.Relay(idx, sp);
+    } else {
         CallData call(env, instance, mem);
-        call.RelaySafe(idx, own_sp, caller_sp, true, out_reg);
+        call.RelayAsync(idx, sp);
     }
 }
 
+extern "C" void RelayDirect(CallData *call, Size idx, uint8_t *sp)
+{
+    Napi::HandleScope scope(call->env);
+    call->Relay(idx, sp);
+}
+
 static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
@@ -1811,16 +1785,9 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info)
 
     if (!AnalyseFunction(env, instance, func))
         return env.Null();
-
-    // Branchless push loop
-    for (const ParameterInfo &param: func->parameters) {
-        func->primitives.Append(param.type->primitive);
-    }
     if (func->variadic) {
+        // Minimize reallocations
         func->parameters.Grow(32);
-        func->primitives.Grow(32);
-    } else {
-        func->primitives.Append(PrimitiveKind::Prototype);
     }
 
 #if defined(_WIN32)
@@ -1885,7 +1852,10 @@ static Napi::Value FindSymbol(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    return WrapPointer(env, type, ptr);
+    Napi::External<void> external = Napi::External<void>::New(env, ptr);
+    SetValueTag(external, &type);
+
+    return external;
 }
 
 static Napi::Value UnloadLibrary(const Napi::CallbackInfo &info)
@@ -2054,10 +2024,13 @@ static Napi::Value RegisterCallback(const Napi::CallbackInfo &info)
 
     void *ptr = GetTrampoline(idx);
 
+    Napi::External<void> external = Napi::External<void>::New(env, ptr);
+    SetValueTag(external, type->ref.marker);
+
     // Cache index for fast unregistration
     instance->trampolines_map.Set(ptr, idx);
 
-    return WrapCallback(env, type->ref.type, ptr);
+    return external;
 }
 
 static Napi::Value UnregisterCallback(const Napi::CallbackInfo &info)
@@ -2069,13 +2042,14 @@ static Napi::Value UnregisterCallback(const Napi::CallbackInfo &info)
         ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", info.Length());
         return env.Null();
     }
-
-    void *ptr;
-    if (!TryPointer(info[0], &ptr)) {
+    if (!info[0].IsExternal()) {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for id, expected registered callback", GetValueType(instance, info[0]));
         return env.Null();
     }
 
+    Napi::External<void> external = info[0].As<Napi::External<void>>();
+    void *ptr = external.Data();
+
     int16_t idx;
     {
         int16_t *it = instance->trampolines_map.Find(ptr);
@@ -2394,7 +2368,7 @@ bool InitAsyncBroker(Napi::Env env, InstanceData *instance)
         if (napi_create_threadsafe_function(env, nullptr, nullptr,
                                             Napi::String::New(env, "Koffi Async Callback Broker"),
                                             0, 1, nullptr, nullptr, nullptr,
-                                            CallData::RelayAsync, &instance->broker) != napi_ok) {
+                                            PerformAsyncRelay, &instance->broker) != napi_ok) {
             LogError("Failed to create async callback broker");
             return false;
         }
@@ -2431,8 +2405,10 @@ static void RegisterPrimitiveType(Napi::Env env, Napi::Object map, std::initiali
     }
 
     if (ref) {
-        type->ref.type = instance->types_map.FindValue(ref, nullptr);
-        K_ASSERT(type->ref.type);
+        const TypeInfo *marker = instance->types_map.FindValue(ref, nullptr);
+        K_ASSERT(marker);
+
+        type->ref.marker = marker;
     }
 
     Napi::Value wrapper = WrapType(env, type);
@@ -2647,7 +2623,10 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
         Napi::Object node = Napi::Object::New(env);
         exports.Set("node", node);
 
-        node.Set("env", WrapPointer(env, instance->void_type, (napi_env)env));
+        Napi::External<void> external = Napi::External<void>::New(env, (napi_env)env);
+        SetValueTag(external, instance->void_type);
+
+        node.Set("env", external);
 
         node.Set("poll", Napi::Function::New(env, &Poll, "poll"));
         node.Set("PollHandle", PollHandle::Define(env));
@@ -2655,13 +2634,22 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
 
     exports.Set("version", Napi::String::New(env, K_STRINGIFY(VERSION)));
 
+    napi_add_env_cleanup_hook(env, [](void *udata) {
+        InstanceData *instance = (InstanceData *)udata;
+
+        if (instance->broker) {
+            // This deadlocks if we try to do this when the module is destroyed, when
+            // the InstanceData destructor runs, so run in the env cleanup hook instead,
+            // where it seems to go okay.
+            napi_release_threadsafe_function(instance->broker, napi_tsfn_abort);
+        }
+    }, instance);
+
     return exports;
 }
 
 InstanceData::~InstanceData()
 {
-    delete variadic_func;
-
     for (InstanceMemory *mem: memories) {
         delete mem;
     }
@@ -2680,10 +2668,6 @@ InstanceData::~InstanceData()
             }
         }
     }
-
-    if (broker) {
-        napi_release_threadsafe_function(broker, napi_tsfn_abort);
-    }
 }
 
 NODE_API_MODULE(koffi, InitModule);