koffi 2.16.0-beta.2 → 2.16.1

package/src/koffi/src/call.cc

@@ -12,26 +12,28 @@ namespace K {
 
 struct RelayContext {
     CallData *call;
-    bool dispose_call;
 
     Size idx;
-    uint8_t *own_sp;
-    uint8_t *caller_sp;
-    BackRegisters *out_reg;
+    uint8_t *sp;
 
-    std::mutex mutex;
-    std::condition_variable cv;
+    std::mutex mutex = {};
+    std::condition_variable cv = {};
     bool done = false;
 };
 
-#include "trampolines/prototypes.inc"
+extern "C" void *FindTrampolineStart();
+extern "C" void *FindTrampolineEnd();
+
+static const uint8_t *TrampolineStart = (const uint8_t *)FindTrampolineStart();
+static const Size TrampolineSize = ((const uint8_t *)FindTrampolineEnd() - TrampolineStart) / MaxTrampolines;
 
 CallData::CallData(Napi::Env env, InstanceData *instance, InstanceMemory *mem)
     : env(env), instance(instance),
       mem(mem), old_stack_mem(mem->stack), old_heap_mem(mem->heap)
 {
-    mem->generation += !mem->depth;
     mem->depth++;
+
+    K_ASSERT(AlignUp(mem->stack.ptr, 16) == mem->stack.ptr);
 }
 
 CallData::~CallData()
@@ -61,9 +63,9 @@ void CallData::Dispose()
             K_ASSERT(trampoline->instance == instance);
             K_ASSERT(!trampoline->func.IsEmpty());
 
-            trampoline->instance = nullptr;
             trampoline->func.Reset();
             trampoline->recv.Reset();
+            trampoline->used = false;
 
             shared.available.Append(idx);
         }
@@ -74,50 +76,26 @@ void CallData::Dispose()
     instance = nullptr;
 }
 
-void CallData::RelaySafe(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool outside_call, BackRegisters *out_reg)
+void CallData::RelayAsync(Size idx, uint8_t *sp)
 {
-    if (std::this_thread::get_id() != instance->main_thread_id) {
-        // JS/V8 is single-threaded, and runs on main_thread_id. Forward the call
-        // to the JS event loop.
-
-        RelayContext ctx;
+    // JS/V8 is single-threaded, and runs on main_thread_id. Forward the call
+    // to the JS event loop.
 
-        ctx.call = this;
-        ctx.dispose_call = outside_call;
-        ctx.idx = idx;
-        ctx.own_sp = own_sp;
-        ctx.caller_sp = caller_sp;
-        ctx.out_reg = out_reg;
+    RelayContext ctx = {
+        .call = this,
+        .idx = idx,
+        .sp = sp
+    };
 
-        napi_call_threadsafe_function(instance->broker, &ctx, napi_tsfn_blocking);
+    napi_call_threadsafe_function(instance->broker, &ctx, napi_tsfn_blocking);
 
-        // Wait until it executes
-        std::unique_lock<std::mutex> lock(ctx.mutex);
-        while (!ctx.done) {
-            ctx.cv.wait(lock);
-        }
-    } else {
-        Napi::HandleScope scope(env);
-        Relay(idx, own_sp, caller_sp, !outside_call, out_reg);
+    // Wait until it executes
+    std::unique_lock<std::mutex> lock(ctx.mutex);
+    while (!ctx.done) {
+        ctx.cv.wait(lock);
     }
 }
 
-void CallData::RelayAsync(napi_env, napi_value, void *, void *udata)
-{
-    RelayContext *ctx = (RelayContext *)udata;
-
-    ctx->call->Relay(ctx->idx, ctx->own_sp, ctx->caller_sp, false, ctx->out_reg);
-
-    if (ctx->dispose_call) {
-        ctx->call->Dispose();
-    }
-
-    // We're done!
-    std::lock_guard<std::mutex> lock(ctx->mutex);
-    ctx->done = true;
-    ctx->cv.notify_one();
-}
-
 bool CallData::PushString(Napi::Value value, int directions, const char **out_str)
 {
     // Fast path
@@ -188,7 +166,7 @@ Size CallData::PushStringValue(Napi::Value value, const char **out_str)
         K_ASSERT(status == napi_ok);
 
         len++;
-        buf = AllocateSpan<char>(&call_alloc, (Size)len);
+        buf = AllocateSpan<char>(&alloc, (Size)len);
 
         status = napi_get_value_string_utf8(env, value, buf.ptr, (size_t)buf.len, &len);
         K_ASSERT(status == napi_ok);
@@ -223,7 +201,7 @@ Size CallData::PushString16Value(Napi::Value value, const char16_t **out_str16)
         K_ASSERT(status == napi_ok);
 
         len++;
-        buf = AllocateSpan<char16_t>(&call_alloc, (Size)len);
+        buf = AllocateSpan<char16_t>(&alloc, (Size)len);
 
         status = napi_get_value_string_utf16(env, value, buf.ptr, (size_t)buf.len, &len);
         K_ASSERT(status == napi_ok);
@@ -254,7 +232,7 @@ Size CallData::PushString32Value(Napi::Value value, const char32_t **out_str32)
         mem->heap.ptr += buf16.len * 4;
         mem->heap.len -= buf16.len * 4;
     } else {
-        buf = AllocateSpan<char32_t>(&call_alloc, buf16.len);
+        buf = AllocateSpan<char32_t>(&alloc, buf16.len);
     }
 
     Size j = 0;
@@ -342,29 +320,6 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
 
     MemSet(origin, 0, type->size);
 
-#define PUSH_NUMBER(CType) \
-        do { \
-            CType v; \
-            \
-            if (!TryNumber(value, &v)) [[unlikely]] { \
-                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value)); \
-                return false; \
-            } \
-             \
-            *(CType *)dest = v; \
-        } while (false)
-#define PUSH_NUMBER_SWAP(CType) \
-        do { \
-            CType v; \
-            \
-            if (!TryNumber(value, &v)) [[unlikely]] { \
-                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value)); \
-                return false; \
-            } \
-             \
-            *(CType *)dest = ReverseBytes(v); \
-        } while (false)
-
     for (Size i = 0; i < members.len; i++) {
         const RecordMember &member = members[i];
         Napi::Value value = obj.Get(member.name);
@@ -385,30 +340,140 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
             case PrimitiveKind::Void: { K_UNREACHABLE(); } break;
 
             case PrimitiveKind::Bool: {
-                bool b;
-                napi_status status = napi_get_value_bool(env, value, &b);
-
-                if (status != napi_ok) [[unlikely]] {
+                if (!value.IsBoolean()) [[unlikely]] {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected boolean", GetValueType(instance, value));
                     return false;
                 }
 
+                bool b = value.As<Napi::Boolean>();
                 *(bool *)dest = b;
             } break;
-            case PrimitiveKind::Int8: { PUSH_NUMBER(int8_t); } break;
-            case PrimitiveKind::UInt8: { PUSH_NUMBER(uint8_t); } break;
-            case PrimitiveKind::Int16: { PUSH_NUMBER(int16_t); } break;
-            case PrimitiveKind::Int16S: { PUSH_NUMBER_SWAP(int16_t); } break;
-            case PrimitiveKind::UInt16: { PUSH_NUMBER(uint16_t); } break;
-            case PrimitiveKind::UInt16S: { PUSH_NUMBER_SWAP(uint16_t); } break;
-            case PrimitiveKind::Int32: { PUSH_NUMBER(int32_t); } break;
-            case PrimitiveKind::Int32S: { PUSH_NUMBER_SWAP(int32_t); } break;
-            case PrimitiveKind::UInt32: { PUSH_NUMBER(uint32_t); } break;
-            case PrimitiveKind::UInt32S: { PUSH_NUMBER_SWAP(uint32_t); } break;
-            case PrimitiveKind::Int64: { PUSH_NUMBER(int64_t); } break;
-            case PrimitiveKind::Int64S: { PUSH_NUMBER_SWAP(int64_t); } break;
-            case PrimitiveKind::UInt64: { PUSH_NUMBER(uint64_t); } break;
-            case PrimitiveKind::UInt64S: { PUSH_NUMBER_SWAP(uint64_t); } break;
+            case PrimitiveKind::Int8: {
+                if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
+                    return false;
+                }
+
+                int8_t v = GetNumber<int8_t>(value);
+                *(int8_t *)dest = v;
+            } break;
+            case PrimitiveKind::UInt8: {
+                if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
+                    return false;
+                }
+
+                uint8_t v = GetNumber<uint8_t>(value);
+                *(uint8_t *)dest = v;
+            } break;
+            case PrimitiveKind::Int16: {
+                if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
+                    return false;
+                }
+
+                int16_t v = GetNumber<int16_t>(value);
+                *(int16_t *)dest = v;
+            } break;
+            case PrimitiveKind::Int16S: {
+                if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
+                    return false;
+                }
+
+                int16_t v = GetNumber<int16_t>(value);
+                *(int16_t *)dest = ReverseBytes(v);
+            } break;
+            case PrimitiveKind::UInt16: {
+                if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
+                    return false;
+                }
+
+                uint16_t v = GetNumber<uint16_t>(value);
+                *(uint16_t *)dest = v;
+            } break;
+            case PrimitiveKind::UInt16S: {
+                if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
+                    return false;
+                }
+
+                uint16_t v = GetNumber<uint16_t>(value);
+                *(uint16_t *)dest = ReverseBytes(v);
+            } break;
+            case PrimitiveKind::Int32: {
+                if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
+                    return false;
+                }
+
+                int32_t v = GetNumber<int32_t>(value);
+                *(int32_t *)dest = v;
+            } break;
+            case PrimitiveKind::Int32S: {
+                if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
+                    return false;
+                }
+
+                int32_t v = GetNumber<int32_t>(value);
+                *(int32_t *)dest = ReverseBytes(v);
+            } break;
+            case PrimitiveKind::UInt32: {
+                if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
+                    return false;
+                }
+
+                uint32_t v = GetNumber<uint32_t>(value);
+                *(uint32_t *)dest = v;
+            } break;
+            case PrimitiveKind::UInt32S: {
+                if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
+                    return false;
+                }
+
+                uint32_t v = GetNumber<uint32_t>(value);
+                *(uint32_t *)dest = ReverseBytes(v);
+            } break;
+            case PrimitiveKind::Int64: {
+                if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
+                    return false;
+                }
+
+                int64_t v = GetNumber<int64_t>(value);
+                *(int64_t *)dest = v;
+            } break;
+            case PrimitiveKind::Int64S: {
+                if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
+                    return false;
+                }
+
+                int64_t v = GetNumber<int64_t>(value);
+                *(int64_t *)dest = ReverseBytes(v);
+            } break;
+            case PrimitiveKind::UInt64: {
+                if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
+                    return false;
+                }
+
+                uint64_t v = GetNumber<uint64_t>(value);
+                *(uint64_t *)dest = v;
+            } break;
+            case PrimitiveKind::UInt64S: {
+                if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
+                    return false;
+                }
+
+                uint64_t v = GetNumber<uint64_t>(value);
+                *(uint64_t *)dest = ReverseBytes(v);
+            } break;
             case PrimitiveKind::String: {
                 const char *str;
                 if (!PushString(value, 1, &str)) [[unlikely]]
@@ -453,7 +518,8 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
                     Napi::Array array = value.As<Napi::Array>();
                     if (!PushNormalArray(array, member.type, member.type->size, dest))
                         return false;
-                } else if (Span<uint8_t> buffer = {}; TryBuffer(value, &buffer)) {
+                } else if (IsRawBuffer(value)) {
+                    Span<const uint8_t> buffer = GetRawBuffer(value);
                     PushBuffer(buffer, member.type, dest);
                 } else if (value.IsString()) {
                     if (!PushStringArray(value, member.type, dest))
@@ -463,8 +529,24 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
                     return false;
                 }
             } break;
-            case PrimitiveKind::Float32: { PUSH_NUMBER(float); } break;
-            case PrimitiveKind::Float64: { PUSH_NUMBER(double); } break;
+            case PrimitiveKind::Float32: {
+                if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
+                    return false;
+                }
+
+                float f = GetNumber<float>(value);
+                *(float *)dest = f;
+            } break;
+            case PrimitiveKind::Float64: {
+                if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
+                    return false;
+                }
+
+                double d = GetNumber<double>(value);
+                *(double *)dest = d;
+            } break;
             case PrimitiveKind::Callback: {
                 void *ptr;
                 if (!PushCallback(value, member.type, &ptr))
@@ -477,9 +559,6 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
         }
     }
 
-#undef PUSH_NUMBER_SWAP
-#undef PUSH_NUMBER
-
     return true;
 }
 
@@ -499,7 +578,7 @@ bool CallData::PushNormalArray(Napi::Array array, const TypeInfo *type, Size siz
 
     Size offset = 0;
 
-#define PUSH_ARRAY(Code) \
+#define PUSH_ARRAY(Check, Expected, GetCode) \
         do { \
             for (Size i = 0; i < len; i++) { \
                 Napi::Value value = array[(uint32_t)i]; \
@@ -507,33 +586,16 @@ bool CallData::PushNormalArray(Napi::Array array, const TypeInfo *type, Size siz
                 offset = AlignLen(offset, ref->align); \
                 uint8_t *dest = origin + offset; \
                  \
-                Code \
+                if (!(Check)) [[unlikely]] { \
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected %2", GetValueType(instance, value), (Expected)); \
+                    return false; \
+                } \
+                 \
+                GetCode \
                  \
                 offset += ref->size; \
             } \
         } while (false)
-#define PUSH_NUMBERS(CType) \
-        PUSH_ARRAY({ \
-            CType v; \
-             \
-            if (!TryNumber(value, &v)) [[unlikely]] { \
-                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value)); \
-                return false; \
-            } \
-             \
-            *(CType *)dest = v; \
-        })
-#define PUSH_NUMBERS_SWAP(CType) \
-        PUSH_ARRAY({ \
-            CType v; \
-             \
-            if (!TryNumber(value, &v)) [[unlikely]] { \
-                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value)); \
-                return false; \
-            } \
-             \
-            *(CType *)dest = ReverseBytes(v); \
-        })
 
     switch (ref->primitive) {
         case PrimitiveKind::Void: {
@@ -542,34 +604,97 @@ bool CallData::PushNormalArray(Napi::Array array, const TypeInfo *type, Size siz
         } break;
 
         case PrimitiveKind::Bool: {
-            PUSH_ARRAY({
-                bool b;
-                napi_status status = napi_get_value_bool(env, value, &b);
-
-                if (status != napi_ok) [[unlikely]] {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected boolean", GetValueType(instance, value));
-                    return false;
-                }
-
+            PUSH_ARRAY(value.IsBoolean(), "boolean", {
+                bool b = value.As<Napi::Boolean>();
                 *(bool *)dest = b;
             });
         } break;
-        case PrimitiveKind::Int8: { PUSH_NUMBERS(int8_t); } break;
-        case PrimitiveKind::UInt8: { PUSH_NUMBERS(uint8_t); } break;
-        case PrimitiveKind::Int16: { PUSH_NUMBERS(int16_t); } break;
-        case PrimitiveKind::Int16S: { PUSH_NUMBERS_SWAP(int16_t); } break;
-        case PrimitiveKind::UInt16: { PUSH_NUMBERS(uint16_t); } break;
-        case PrimitiveKind::UInt16S: { PUSH_NUMBERS_SWAP(uint16_t); } break;
-        case PrimitiveKind::Int32: { PUSH_NUMBERS(int32_t); } break;
-        case PrimitiveKind::Int32S: { PUSH_NUMBERS_SWAP(int32_t); } break;
-        case PrimitiveKind::UInt32: { PUSH_NUMBERS(uint32_t); } break;
-        case PrimitiveKind::UInt32S: { PUSH_NUMBERS_SWAP(uint32_t); } break;
-        case PrimitiveKind::Int64: { PUSH_NUMBERS(int64_t); } break;
-        case PrimitiveKind::Int64S: { PUSH_NUMBERS_SWAP(int64_t); } break;
-        case PrimitiveKind::UInt64: { PUSH_NUMBERS(uint64_t); } break;
-        case PrimitiveKind::UInt64S: { PUSH_NUMBERS_SWAP(uint64_t); } break;
+        case PrimitiveKind::Int8: {
+            PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
+                int8_t v = GetNumber<int8_t>(value);
+                *(int8_t *)dest = v;
+            });
+        } break;
+        case PrimitiveKind::UInt8: {
+            PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
+                uint8_t v = GetNumber<uint8_t>(value);
+                *(uint8_t *)dest = v;
+            });
+        } break;
+        case PrimitiveKind::Int16: {
+            PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
+                int16_t v = GetNumber<int16_t>(value);
+                *(int16_t *)dest = v;
+            });
+        } break;
+        case PrimitiveKind::Int16S: {
+            PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
+                int16_t v = GetNumber<int16_t>(value);
+                *(int16_t *)dest = ReverseBytes(v);
+            });
+        } break;
+        case PrimitiveKind::UInt16: {
+            PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
+                uint16_t v = GetNumber<uint16_t>(value);
+                *(uint16_t *)dest = v;
+            });
+        } break;
+        case PrimitiveKind::UInt16S: {
+            PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
+                uint16_t v = GetNumber<uint16_t>(value);
+                *(uint16_t *)dest = ReverseBytes(v);
+            });
+        } break;
+        case PrimitiveKind::Int32: {
+            PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
+                int32_t v = GetNumber<int32_t>(value);
+                *(int32_t *)dest = v;
+            });
+        } break;
+        case PrimitiveKind::Int32S: {
+            PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
+                int32_t v = GetNumber<int32_t>(value);
+                *(int32_t *)dest = ReverseBytes(v);
+            });
+        } break;
+        case PrimitiveKind::UInt32: {
+            PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
+                uint32_t v = GetNumber<uint32_t>(value);
+                *(uint32_t *)dest = v;
+            });
+        } break;
+        case PrimitiveKind::UInt32S: {
+            PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
+                uint32_t v = GetNumber<uint32_t>(value);
+                *(uint32_t *)dest = ReverseBytes(v);
+            });
+        } break;
+        case PrimitiveKind::Int64: {
+            PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
+                int64_t v = GetNumber<int64_t>(value);
+                *(int64_t *)dest = v;
+            });
+        } break;
+        case PrimitiveKind::Int64S: {
+            PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
+                int64_t v = GetNumber<int64_t>(value);
+                *(int64_t *)dest = ReverseBytes(v);
+            });
+        } break;
+        case PrimitiveKind::UInt64: {
+            PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
+                uint64_t v = GetNumber<uint64_t>(value);
+                *(uint64_t *)dest = v;
+            });
+        } break;
+        case PrimitiveKind::UInt64S: {
+            PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
+                uint64_t v = GetNumber<uint64_t>(value);
+                *(uint64_t *)dest = ReverseBytes(v);
+            });
+        } break;
         case PrimitiveKind::String: {
-            PUSH_ARRAY({
+            PUSH_ARRAY(true, "string", {
                 const char *str;
                 if (!PushString(value, 1, &str)) [[unlikely]]
                     return false;
@@ -578,7 +703,7 @@ bool CallData::PushNormalArray(Napi::Array array, const TypeInfo *type, Size siz
             });
         } break;
         case PrimitiveKind::String16: {
-            PUSH_ARRAY({
+            PUSH_ARRAY(true, "string", {
                 const char16_t *str16;
                 if (!PushString16(value, 1, &str16)) [[unlikely]]
                     return false;
@@ -587,7 +712,7 @@ bool CallData::PushNormalArray(Napi::Array array, const TypeInfo *type, Size siz
             });
         } break;
         case PrimitiveKind::String32: {
-            PUSH_ARRAY({
+            PUSH_ARRAY(true, "string", {
                 const char32_t *str32;
                 if (!PushString32(value, 1, &str32)) [[unlikely]]
                     return false;
@@ -596,12 +721,7 @@ bool CallData::PushNormalArray(Napi::Array array, const TypeInfo *type, Size siz
             });
         } break;
         case PrimitiveKind::Pointer: {
-            PUSH_ARRAY({
-                if (!IsObject(value)) [[unlikely]] {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected object", GetValueType(instance, value));
-                    return false;
-                }
-
+            PUSH_ARRAY(true, ref->name, {
                 void *ptr;
                 if (!PushPointer(value, ref, 1, &ptr)) [[unlikely]]
                     return false;
@@ -611,12 +731,7 @@ bool CallData::PushNormalArray(Napi::Array array, const TypeInfo *type, Size siz
         } break;
         case PrimitiveKind::Record:
         case PrimitiveKind::Union: {
-            PUSH_ARRAY({
-                if (!IsObject(value)) [[unlikely]] {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected object", GetValueType(instance, value));
-                    return false;
-                }
-
+            PUSH_ARRAY(IsObject(value), "object", {
                 Napi::Object obj2 = value.As<Napi::Object>();
                 if (!PushObject(obj2, ref, dest))
                     return false;
@@ -634,7 +749,8 @@ bool CallData::PushNormalArray(Napi::Array array, const TypeInfo *type, Size siz
                     Napi::Array array2 = value.As<Napi::Array>();
                     if (!PushNormalArray(array2, ref, (Size)ref->size, dest))
                         return false;
-                } else if (Span<uint8_t> buffer = {}; TryBuffer(value, &buffer)) {
+                } else if (IsRawBuffer(value)) {
+                    Span<const uint8_t> buffer = GetRawBuffer(value);
                     PushBuffer(buffer, ref, dest);
                 } else if (value.IsString()) {
                     if (!PushStringArray(value, ref, dest))
@@ -647,8 +763,18 @@ bool CallData::PushNormalArray(Napi::Array array, const TypeInfo *type, Size siz
                 offset += ref->size;
             }
         } break;
-        case PrimitiveKind::Float32: { PUSH_NUMBERS(float); } break;
-        case PrimitiveKind::Float64: { PUSH_NUMBERS(double); } break;
+        case PrimitiveKind::Float32: {
+            PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
+                float f = GetNumber<float>(value);
+                *(float *)dest = f;
+            });
+        } break;
+        case PrimitiveKind::Float64: {
+            PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
+                double d = GetNumber<double>(value);
+                *(double *)dest = d;
+            });
+        } break;
         case PrimitiveKind::Callback: {
             for (Size i = 0; i < len; i++) {
                 Napi::Value value = array[(uint32_t)i];
@@ -670,8 +796,6 @@ bool CallData::PushNormalArray(Napi::Array array, const TypeInfo *type, Size siz
         case PrimitiveKind::Prototype: { K_UNREACHABLE(); } break;
     }
 
-#undef PUSH_NUMBERS_SWAP
-#undef PUSH_NUMBERS
 #undef PUSH_ARRAY
 
     return true;
@@ -752,140 +876,178 @@ bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directio
 
     const TypeInfo *ref = type->ref.type;
 
-    // In the past we were naively using napi_typeof() and a switch to "reduce" branching,
-    // but it did not match the common types very well (so there was still various if tests),
-    // and it turns out that napi_typeof() is made of successive type tests anyway so it
-    // just made things worse. Oh, well.
+    switch (value.Type()) {
+        case napi_undefined:
+        case napi_null: {
+            *out_ptr = nullptr;
+            return true;
+        } break;
 
-    if (void *ptr = nullptr; TryPointer(value, &ptr)) {
-        *out_ptr = ptr;
-        return true;
-    } else if (value.IsArray()) {
-        uint8_t *ptr = nullptr;
+        case napi_external: {
+            K_ASSERT(type->primitive == PrimitiveKind::Pointer ||
+                      type->primitive == PrimitiveKind::String ||
+                      type->primitive == PrimitiveKind::String16 ||
+                      type->primitive == PrimitiveKind::String32);
 
-        Napi::Array array = value.As<Napi::Array>();
-        Size len = PushIndirectString(array, ref, &ptr);
+            if (!CheckValueTag(value, type->ref.marker) &&
+                    !CheckValueTag(value, instance->void_type) &&
+                    ref != instance->void_type) [[unlikely]]
+                goto unexpected;
 
-        OutArgument::Kind out_kind;
-        Size out_max_len = -1;
+            *out_ptr = value.As<Napi::External<uint8_t>>().Data();
+            return true;
+        } break;
 
-        if (len >= 0) {
-            if (!ref->size && ref != instance->void_type) [[unlikely]] {
-                ThrowError<Napi::TypeError>(env, "Cannot pass [string] value to %1", type->name);
-                return false;
-            }
+        case napi_object: {
+            uint8_t *ptr = nullptr;
 
-            switch (ref->size) {
-                default: { out_kind = OutArgument::Kind::String; } break;
-                case 2: { out_kind = OutArgument::Kind::String16; } break;
-                case 4: { out_kind = OutArgument::Kind::String32; } break;
-            }
-            out_max_len = len;
-        } else {
-            if (!ref->size) [[unlikely]] {
-                ThrowError<Napi::TypeError>(env, "Cannot pass %1 value to %2, use koffi.as()",
-                                            ref != instance->void_type ? "opaque" : "ambiguous", type->name);
-                return false;
-            }
+            OutArgument::Kind out_kind;
+            Size out_max_len = -1;
 
-            Size len = (Size)array.Length();
-            Size size = len * ref->size;
+            if (value.IsArray()) {
+                Napi::Array array = value.As<Napi::Array>();
+                Size len = PushIndirectString(array, ref, &ptr);
 
-            ptr = AllocHeap(size, 16);
+                if (len >= 0) {
+                    if (!ref->size && ref != instance->void_type) [[unlikely]] {
+                        ThrowError<Napi::TypeError>(env, "Cannot pass [string] value to %1", type->name);
+                        return false;
+                    }
+
+                    switch (ref->size) {
+                        default: { out_kind = OutArgument::Kind::String; } break;
+                        case 2: { out_kind = OutArgument::Kind::String16; } break;
+                        case 4: { out_kind = OutArgument::Kind::String32; } break;
+                    }
+                    out_max_len = len;
+                } else {
+                    if (!ref->size) [[unlikely]] {
+                        ThrowError<Napi::TypeError>(env, "Cannot pass %1 value to %2, use koffi.as()",
+                                                    ref != instance->void_type ? "opaque" : "ambiguous", type->name);
+                        return false;
+                    }
+
+                    Size len = (Size)array.Length();
+                    Size size = len * ref->size;
+
+                    ptr = AllocHeap(size, 16);
+
+                    if (directions & 1) {
+                        if (!PushNormalArray(array, type, size, ptr))
+                            return false;
+                    } else {
+                        MemSet(ptr, 0, size);
+                    }
+
+                    out_kind = OutArgument::Kind::Array;
+                }
+            } else if (IsRawBuffer(value)) {
+                Span<uint8_t> buffer = GetRawBuffer(value);
+
+                // We can fast path
+                ptr = buffer.ptr;
+                directions = 1;
+
+                out_kind = OutArgument::Kind::Buffer;
+            } else if (ref->primitive == PrimitiveKind::Record ||
+                       ref->primitive == PrimitiveKind::Union) [[likely]] {
+                Napi::Object obj = value.As<Napi::Object>();
+                K_ASSERT(IsObject(value));
+
+                ptr = AllocHeap(ref->size, 16);
 
-            if (directions & 1) {
-                if (!PushNormalArray(array, type, size, ptr))
+                if (ref->primitive == PrimitiveKind::Union &&
+                        (directions & 2) && !CheckValueTag(obj, &MagicUnionMarker)) [[unlikely]] {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected union value", GetValueType(instance, obj));
                     return false;
+                }
+
+                if (directions & 1) {
+                    if (!PushObject(obj, ref, ptr))
+                        return false;
+                } else {
+                    MemSet(ptr, 0, ref->size);
+                }
+
+                out_kind = OutArgument::Kind::Object;
             } else {
-                MemSet(ptr, 0, size);
+                goto unexpected;
             }
 
-            out_kind = OutArgument::Kind::Array;
-        }
+            if (directions & 2) {
+                OutArgument *out = out_arguments.AppendDefault();
 
-        if (directions & 2) {
-            OutArgument *out = out_arguments.AppendDefault();
+                napi_status status = napi_create_reference(env, value, 1, &out->ref);
+                K_ASSERT(status == napi_ok);
 
-            napi_status status = napi_create_reference(env, value, 1, &out->ref);
-            K_ASSERT(status == napi_ok);
+                out->kind = out_kind;
+                out->ptr = ptr;
+                out->type = ref;
+                out->max_len = out_max_len;
+            }
 
-            out->kind = out_kind;
-            out->ptr = ptr;
-            out->type = ref;
-            out->max_len = out_max_len;
-        }
+            *out_ptr = ptr;
+            return true;
+        } break;
 
-        *out_ptr = ptr;
-        return true;
-    } else if (ref->primitive == PrimitiveKind::Record ||
-               ref->primitive == PrimitiveKind::Union) [[likely]] {
-        Napi::Object obj = value.As<Napi::Object>();
-        K_ASSERT(IsObject(value));
+        case napi_string: {
+            K_ASSERT(type->primitive == PrimitiveKind::Pointer);
 
-        uint8_t *ptr = AllocHeap(ref->size, 16);
+            if (directions & 2) [[unlikely]]
+                goto unexpected;
 
-        if (ref->primitive == PrimitiveKind::Union &&
-                (directions & 2) && !CheckValueTag(obj, &MagicUnionMarker)) [[unlikely]] {
-            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected union value", GetValueType(instance, obj));
-            return false;
-        }
+            if (ref == instance->void_type) {
+                PushStringValue(value, (const char **)out_ptr);
+                return true;
+            } else if (ref->primitive == PrimitiveKind::Int8) {
+                PushStringValue(value, (const char **)out_ptr);
+                return true;
+            } else if (ref->primitive == PrimitiveKind::Int16) {
+                PushString16Value(value, (const char16_t **)out_ptr);
+                return true;
+            } else if (ref->primitive == PrimitiveKind::Int32) {
+                PushString32Value(value, (const char32_t **)out_ptr);
+                return true;
+            } else {
+                goto unexpected;
+            }
+        } break;
 
-        if (directions & 1) {
-            if (!PushObject(obj, ref, ptr))
+        case napi_function: {
+            if (type->primitive != PrimitiveKind::Callback) [[unlikely]] {
+                ThrowError<Napi::TypeError>(env, "Cannot pass function to type %1", type->name);
                 return false;
-        } else {
-            MemSet(ptr, 0, ref->size);
-        }
-
-        if (directions & 2) {
-            OutArgument *out = out_arguments.AppendDefault();
+            }
 
-            napi_status status = napi_create_reference(env, value, 1, &out->ref);
-            K_ASSERT(status == napi_ok);
+            Napi::Function func = value.As<Napi::Function>();
 
-            out->kind = OutArgument::Kind::Object;
-            out->ptr = ptr;
-            out->type = ref;
-            out->max_len = -1;
-        }
+            void *ptr = ReserveTrampoline(type->ref.proto, func);
+            if (!ptr) [[unlikely]]
+                return false;
 
-        *out_ptr = ptr;
-        return true;
-    } else if (value.IsString()) {
-        K_ASSERT(type->primitive == PrimitiveKind::Pointer);
+            *out_ptr = (void *)ptr;
+            return true;
+        } break;
 
-        if (directions & 2) [[unlikely]]
-            goto unexpected;
+        case napi_number: {
+            Napi::Number number = value.As<Napi::Number>();
+            intptr_t ptr = (intptr_t)number.Int32Value();
 
-        if (ref == instance->void_type) {
-            PushStringValue(value, (const char **)out_ptr);
-            return true;
-        } else if (ref->primitive == PrimitiveKind::Int8) {
-            PushStringValue(value, (const char **)out_ptr);
-            return true;
-        } else if (ref->primitive == PrimitiveKind::Int16) {
-            PushString16Value(value, (const char16_t **)out_ptr);
-            return true;
-        } else if (ref->primitive == PrimitiveKind::Int32) {
-            PushString32Value(value, (const char32_t **)out_ptr);
+            *out_ptr = (void *)ptr;
             return true;
-        } else {
-            goto unexpected;
-        }
-    } else if (value.IsFunction()) {
-        if (type->primitive != PrimitiveKind::Callback) [[unlikely]] {
-            ThrowError<Napi::TypeError>(env, "Cannot pass function to type %1", type->name);
-            return false;
-        }
+        } break;
 
-        Napi::Function func = value.As<Napi::Function>();
+        case napi_bigint: {
+            Napi::BigInt bigint = value.As<Napi::BigInt>();
 
-        void *ptr = ReserveTrampoline(type->ref.proto, func);
-        if (!ptr) [[unlikely]]
-            return false;
+            bool lossless;
+            intptr_t ptr = (intptr_t)bigint.Int64Value(&lossless);
 
-        *out_ptr = (void *)ptr;
-        return true;
+            *out_ptr = (void *)ptr;
+            return true;
+        } break;
+
+        default: {} break;
     }
 
 unexpected:
@@ -895,18 +1057,7 @@ unexpected:
 
 bool CallData::PushCallback(Napi::Value value, const TypeInfo *type, void **out_ptr)
 {
-    if (CheckValueTag(value, &CastMarker)) {
-        Napi::External<ValueCast> external = value.As<Napi::External<ValueCast>>();
-        ValueCast *cast = external.Data();
-
-        value = cast->ref.Value();
-        type = cast->type;
-    }
-
-    if (void *ptr = nullptr; TryPointer(value, &ptr)) {
-        *out_ptr = ptr;
-        return true;
-    } else if (value.IsFunction()) {
+    if (value.IsFunction()) {
         Napi::Function func = value.As<Napi::Function>();
 
         void *ptr = ReserveTrampoline(type->ref.proto, func);
@@ -914,9 +1065,27 @@ bool CallData::PushCallback(Napi::Value value, const TypeInfo *type, void **out_
             return false;
 
         *out_ptr = ptr;
-        return true;
+    } else if (CheckValueTag(value, type->ref.marker)) {
+        *out_ptr = value.As<Napi::External<void>>().Data();
+    } else if (CheckValueTag(value, &CastMarker)) {
+        Napi::External<ValueCast> external = value.As<Napi::External<ValueCast>>();
+        ValueCast *cast = external.Data();
+
+        value = cast->ref.Value();
+
+        if (!value.IsExternal() || cast->type != type)
+            goto unexpected;
+
+        *out_ptr = value.As<Napi::External<void>>().Data();
+    } else if (IsNullOrUndefined(value)) {
+        *out_ptr = nullptr;
+    } else {
+        goto unexpected;
     }
 
+    return true;
+
+unexpected:
     ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected %2", GetValueType(instance, value), type->name);
     return false;
 }
@@ -972,7 +1141,7 @@ void *CallData::ReserveTrampoline(const FunctionInfo *proto, Napi::Function func
     trampoline->proto = proto;
     trampoline->func.Reset(func, 1);
     trampoline->recv.Reset();
-    trampoline->generation = (int32_t)mem->generation;
+    trampoline->used = true;
 
     void *ptr = GetTrampoline(idx);
 
@@ -1008,14 +1177,14 @@ bool CallData::CheckDynamicLength(Napi::Object obj, Size element, const char *co
     {
         Napi::Value by = obj.Get(countedby);
 
-        if (!TryNumber(by, &expected)) [[unlikely]] {
+        if (!by.IsNumber() && !by.IsBigInt()) [[unlikely]] {
             ThrowError<Napi::Error>(env, "Unexpected %1 value for dynamic length, expected number", GetValueType(instance, by));
             return false;
         }
 
         // If we get anywhere near overflow there are other problems to worry about.
         // So let's not worry about that.
-        expected *= element;
+        expected = GetNumber<int64_t>(by) * element;
     }
 
     // Get actual size
@@ -1067,11 +1236,9 @@ void CallData::PopOutArguments()
             } break;
 
             case OutArgument::Kind::Buffer: {
-                Span<uint8_t> buffer;
-
-                bool success = TryBuffer(value, &buffer);
-                K_ASSERT(success);
+                K_ASSERT(IsRawBuffer(value));
 
+                Span<uint8_t> buffer = GetRawBuffer(value);
                 DecodeBuffer(buffer, out.ptr, out.type);
             } break;
 
@@ -1125,9 +1292,27 @@ void CallData::PopOutArguments()
     }
 }
 
-void *GetTrampoline(int16_t idx)
+void PerformAsyncRelay(napi_env, napi_value, void *, void *udata)
+{
+    RelayContext *ctx = (RelayContext *)udata;
+    CallData *call = ctx->call;
+
+    call->Relay(ctx->idx, ctx->sp);
+
+    // This CallData was created artificially just to perform the callback. Which means the
+    // creator may not run on the main thread, and cannot properly destroy it, because some
+    // members are managed by Node.
+    call->Dispose();
+
+    // We're done!
+    std::lock_guard<std::mutex> lock(ctx->mutex);
+    ctx->done = true;
+    ctx->cv.notify_one();
+}
+
+void *GetTrampoline(int idx)
 {
-    return Trampolines[idx];
+    return (void *)(TrampolineStart + TrampolineSize * idx);
 }
 
 }