koffi 1.3.12 → 2.1.0-beta.1

package/src/call.cc

@@ -40,7 +40,7 @@ CallData::~CallData()
     mem->stack = old_stack_mem;
     mem->heap = old_heap_mem;
 
-    instance->free_trampolines |= used_trampolines;
+    instance->temp_trampolines -= used_trampolines;
     instance->temporaries -= mem->temporary;
 
     if (!--mem->depth && mem->temporary) {
@@ -127,9 +127,8 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
     RG_ASSERT(IsObject(obj));
     RG_ASSERT(type->primitive == PrimitiveKind::Record);
 
-    Size offset = 0;
-
-    for (const RecordMember &member: type->members) {
+    for (Size i = 0; i < type->members.len; i++) {
+        const RecordMember &member = type->members[i];
         Napi::Value value = obj.Get(member.name);
 
         if (RG_UNLIKELY(value.IsUndefined())) {
@@ -137,9 +136,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
             return false;
         }
 
-        int16_t align = std::max(member.align, realign);
-        offset = AlignLen(offset, align);
-
+        Size offset = realign ? (i * realign) : member.offset;
         uint8_t *dest = origin + offset;
 
         switch (member.type->primitive) {
@@ -257,7 +254,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
                 *(const char16_t **)dest = str16;
             } break;
             case PrimitiveKind::Pointer: {
-                if (CheckValueTag(instance, value, member.type)) {
+                if (CheckValueTag(instance, value, member.type->ref.marker)) {
                     Napi::External<void> external = value.As<Napi::External<void>>();
                     void *ptr = external.Data();
                     *(void **)dest = ptr;
@@ -281,15 +278,15 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
             case PrimitiveKind::Array: {
                 if (value.IsArray()) {
                     Napi::Array array = value.As<Napi::Array>();
-                    Size len = (Size)member.type->size / member.type->ref->size;
+                    Size len = (Size)member.type->size / member.type->ref.type->size;
 
-                    if (!PushNormalArray(array, len, member.type->ref, dest, realign))
+                    if (!PushNormalArray(array, len, member.type->ref.type, dest, realign))
                         return false;
                 } else if (value.IsTypedArray()) {
                     Napi::TypedArray array = value.As<Napi::TypedArray>();
-                    Size len = (Size)member.type->size / member.type->ref->size;
+                    Size len = (Size)member.type->size / member.type->ref.type->size;
 
-                    if (!PushTypedArray(array, len, member.type->ref, dest, realign))
+                    if (!PushTypedArray(array, len, member.type->ref.type, dest, realign))
                         return false;
                 } else if (value.IsString() && !realign) {
                     if (!PushStringArray(value, member.type, dest))
@@ -323,10 +320,10 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
                 if (value.IsFunction()) {
                     Napi::Function func = value.As<Napi::Function>();
 
-                    ptr = ReserveTrampoline(member.type->proto, func);
+                    ptr = ReserveTrampoline(member.type->ref.proto, func);
                     if (RG_UNLIKELY(!ptr))
                         return false;
-                } else if (CheckValueTag(instance, value, member.type)) {
+                } else if (CheckValueTag(instance, value, member.type->ref.marker)) {
                     Napi::External<void> external = value.As<Napi::External<void>>();
                     ptr = external.Data();
                 } else if (IsNullOrUndefined(value)) {
@@ -338,9 +335,9 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
 
                 *(void **)dest = ptr;
             } break;
-        }
 
-        offset += member.type->size;
+            case PrimitiveKind::Prototype: { RG_UNREACHABLE(); } break;
+        }
     }
 
     return true;
@@ -460,7 +457,7 @@ bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *ref,
             });
         } break;
         case PrimitiveKind::Pointer: {
-            PUSH_ARRAY(CheckValueTag(instance, value, ref) || IsNullOrUndefined(value), ref->name, {
+            PUSH_ARRAY(CheckValueTag(instance, value, ref->ref.marker) || IsNullOrUndefined(value), ref->name, {
                 if (!IsNullOrUndefined(value)) {
                     Napi::External<void> external = value.As<Napi::External<void>>();
                     *(void **)dest = external.Data();
@@ -487,15 +484,15 @@ bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *ref,
 
                 if (value.IsArray()) {
                     Napi::Array array2 = value.As<Napi::Array>();
-                    Size len2 = (Size)ref->size / ref->ref->size;
+                    Size len2 = (Size)ref->size / ref->ref.type->size;
 
-                    if (!PushNormalArray(array2, len2, ref->ref, dest, realign))
+                    if (!PushNormalArray(array2, len2, ref->ref.type, dest, realign))
                         return false;
                 } else if (value.IsTypedArray()) {
                     Napi::TypedArray array2 = value.As<Napi::TypedArray>();
-                    Size len2 = (Size)ref->size / ref->ref->size;
+                    Size len2 = (Size)ref->size / ref->ref.type->size;
 
-                    if (!PushTypedArray(array2, len2, ref->ref, dest, realign))
+                    if (!PushTypedArray(array2, len2, ref->ref.type, dest, realign))
                         return false;
                 } else if (value.IsString() && !realign) {
                     if (!PushStringArray(value, ref, dest))
@@ -534,10 +531,10 @@ bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *ref,
                 if (value.IsFunction()) {
                     Napi::Function func = value.As<Napi::Function>();
 
-                    ptr = ReserveTrampoline(ref->proto, func);
+                    ptr = ReserveTrampoline(ref->ref.proto, func);
                     if (RG_UNLIKELY(!ptr))
                         return false;
-                } else if (CheckValueTag(instance, value, ref)) {
+                } else if (CheckValueTag(instance, value, ref->ref.marker)) {
                     Napi::External<void> external = value.As<Napi::External<void>>();
                     ptr = external.Data();
                 } else if (IsNullOrUndefined(value)) {
@@ -552,6 +549,8 @@ bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *ref,
                 offset += ref->size;
             }
         } break;
+
+        case PrimitiveKind::Prototype: { RG_UNREACHABLE(); } break;
     }
 
 #undef PUSH_ARRAY
@@ -568,24 +567,26 @@ bool CallData::PushTypedArray(Napi::TypedArray array, Size len, const TypeInfo *
         return false;
     }
 
-    Size offset = 0;
     const uint8_t *buf = (const uint8_t *)array.ArrayBuffer().Data();
 
-    if (RG_UNLIKELY(array.TypedArrayType() != GetTypedArrayType(ref))) {
+    if (RG_UNLIKELY(array.TypedArrayType() != GetTypedArrayType(ref) &&
+                    ref != instance->void_type)) {
         ThrowError<Napi::TypeError>(env, "Cannot use %1 value for %2 array", GetValueType(instance, array), ref->name);
         return false;
     }
 
     if (realign) {
+        Size offset = 0;
+        Size size = (Size)array.ElementSize();
+
         for (uint32_t i = 0; i < len; i++) {
-            int16_t align = std::max(ref->align, realign);
-            offset = AlignLen(offset, align);
+            offset = AlignLen(offset, realign);
 
             uint8_t *dest = origin + offset;
+            const uint8_t *src = buf + i * size;
 
-            memcpy(dest, buf + i * ref->size, ref->size);
-
-            offset += ref->size;
+            memcpy(dest, src, size);
+            offset += size;
         }
     } else {
         memcpy_safe(origin, buf, (size_t)array.ByteLength());
@@ -601,7 +602,7 @@ bool CallData::PushStringArray(Napi::Value obj, const TypeInfo *type, uint8_t *o
 
     size_t encoded = 0;
 
-    switch (type->ref->primitive) {
+    switch (type->ref.type->primitive) {
         case PrimitiveKind::Int8: {
             napi_status status = napi_get_value_string_utf8(env, obj, (char *)origin, type->size, &encoded);
             RG_ASSERT(status == napi_ok);
@@ -614,7 +615,7 @@ bool CallData::PushStringArray(Napi::Value obj, const TypeInfo *type, uint8_t *o
         } break;
 
         default: {
-            ThrowError<Napi::TypeError>(env, "Strings cannot be converted to %1 array", type->ref->name);
+            ThrowError<Napi::TypeError>(env, "Strings cannot be converted to %1 array", type->ref.type->name);
             return false;
         } break;
     }
@@ -626,6 +627,16 @@ bool CallData::PushStringArray(Napi::Value obj, const TypeInfo *type, uint8_t *o
 
 bool CallData::PushPointer(Napi::Value value, const ParameterInfo &param, void **out_ptr)
 {
+    const TypeInfo *type = param.type;
+
+    if (CheckValueTag(instance, value, &CastMarker)) {
+        Napi::External<ValueCast> external = value.As<Napi::External<ValueCast>>();
+        ValueCast *cast = external.Data();
+
+        value = cast->ref.Value();
+        type = cast->type;
+    }
+
     switch (value.Type()) {
         case napi_undefined:
         case napi_null: {
@@ -634,7 +645,11 @@ bool CallData::PushPointer(Napi::Value value, const ParameterInfo &param, void *
         } break;
 
         case napi_external: {
-            if (RG_UNLIKELY(!CheckValueTag(instance, value, param.type)))
+            RG_ASSERT(type->primitive == PrimitiveKind::Pointer);
+
+            if (RG_UNLIKELY(!CheckValueTag(instance, value, type->ref.marker) &&
+                            !CheckValueTag(instance, value, instance->void_type) &&
+                            type->ref.type != instance->void_type))
                 goto unexpected;
 
             *out_ptr = value.As<Napi::External<uint8_t>>().Data();
@@ -648,12 +663,12 @@ bool CallData::PushPointer(Napi::Value value, const ParameterInfo &param, void *
                 Napi::Array array = value.As<Napi::Array>();
 
                 Size len = (Size)array.Length();
-                Size size = len * param.type->ref->size;
+                Size size = len * type->ref.type->size;
 
                 ptr = AllocHeap(size, 16);
 
                 if (param.directions & 1) {
-                    if (!PushNormalArray(array, len, param.type->ref, ptr))
+                    if (!PushNormalArray(array, len, type->ref.type, ptr))
                         return false;
                 } else {
                     memset(ptr, 0, size);
@@ -667,27 +682,28 @@ bool CallData::PushPointer(Napi::Value value, const ParameterInfo &param, void *
                 ptr = AllocHeap(size, 16);
 
                 if (param.directions & 1) {
-                    if (!PushTypedArray(array, len, param.type->ref, ptr))
+                    if (!PushTypedArray(array, len, type->ref.type, ptr))
                         return false;
                 } else {
-                    if (RG_UNLIKELY(array.TypedArrayType() != GetTypedArrayType(param.type->ref))) {
-                        ThrowError<Napi::TypeError>(env, "Cannot use %1 value for %2 array", GetValueType(instance, array), param.type->ref->name);
+                    if (RG_UNLIKELY(array.TypedArrayType() != GetTypedArrayType(type->ref.type) &&
+                                    type->ref.type != instance->void_type)) {
+                        ThrowError<Napi::TypeError>(env, "Cannot use %1 value for %2 array", GetValueType(instance, array), type->ref.type->name);
                         return false;
                     }
 
                     memset(ptr, 0, size);
                 }
-            } else if (RG_LIKELY(param.type->ref->primitive == PrimitiveKind::Record)) {
+            } else if (RG_LIKELY(type->ref.type->primitive == PrimitiveKind::Record)) {
                 Napi::Object obj = value.As<Napi::Object>();
                 RG_ASSERT(IsObject(value));
 
-                ptr = AllocHeap(param.type->ref->size, 16);
+                ptr = AllocHeap(type->ref.type->size, 16);
 
                 if (param.directions & 1) {
-                    if (!PushObject(obj, param.type->ref, ptr))
+                    if (!PushObject(obj, type->ref.type, ptr))
                         return false;
                 } else {
-                    memset(ptr, 0, param.type->size);
+                    memset(ptr, 0, type->size);
                 }
             } else {
                 goto unexpected;
@@ -700,7 +716,7 @@ bool CallData::PushPointer(Napi::Value value, const ParameterInfo &param, void *
                 RG_ASSERT(status == napi_ok);
 
                 out->ptr = ptr;
-                out->type = param.type->ref;
+                out->type = type->ref.type;
             }
 
             *out_ptr = ptr;
@@ -711,7 +727,7 @@ bool CallData::PushPointer(Napi::Value value, const ParameterInfo &param, void *
     }
 
 unexpected:
-    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected %3", GetValueType(instance, value), param.offset + 1, param.type->name);
+    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected %3", GetValueType(instance, value), param.offset + 1, type->name);
     return false;
 }
 
@@ -741,27 +757,34 @@ void CallData::PopOutArguments()
             Napi::Object obj(env, value);
             PopObject(obj, out.ptr, out.type);
         }
+
+        if (out.type->dispose) {
+            out.type->dispose(env, out.type, out.ptr);
+        }
     }
 }
 
 void *CallData::ReserveTrampoline(const FunctionInfo *proto, Napi::Function func)
 {
-    uint32_t idx = CountTrailingZeros(instance->free_trampolines);
-
-    if (RG_UNLIKELY(idx >= MaxTrampolines)) {
-        ThrowError<Napi::Error>(env, "Too many callbacks are in use (max = %1)", MaxTrampolines);
+    if (RG_UNLIKELY(instance->temp_trampolines >= MaxTrampolines)) {
+        ThrowError<Napi::Error>(env, "Too many temporary callbacks are in use (max = %1)", MaxTrampolines);
         return nullptr;
     }
 
-    instance->free_trampolines &= ~(1u << idx);
-    used_trampolines |= 1u << idx;
+    int idx = instance->next_trampoline;
+
+    instance->next_trampoline = (int16_t)((instance->next_trampoline + 1) % MaxTrampolines);
+    instance->temp_trampolines++;
+    used_trampolines++;
 
-    instance->trampolines[idx].proto = proto;
-    instance->trampolines[idx].func.Reset(func, 1);
-    instance->trampolines[idx].generation = mem->generation;
+    TrampolineInfo *trampoline = &instance->trampolines[idx];
 
-    void *trampoline = GetTrampoline(idx, proto);
-    return trampoline;
+    trampoline->proto = proto;
+    trampoline->func.Reset(func, 1);
+    trampoline->generation = (int32_t)mem->generation;
+
+    void *ptr = GetTrampoline(idx, proto);
+    return ptr;
 }
 
 void CallData::PopObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type, int16_t realign)
@@ -771,12 +794,10 @@ void CallData::PopObject(Napi::Object obj, const uint8_t *origin, const TypeInfo
 
     RG_ASSERT(type->primitive == PrimitiveKind::Record);
 
-    Size offset = 0;
-
-    for (const RecordMember &member: type->members) {
-        int16_t align = std::max(realign, member.align);
-        offset = AlignLen(offset, align);
+    for (Size i = 0; i < type->members.len; i++) {
+        const RecordMember &member = type->members[i];
 
+        Size offset = realign ? (i * realign) : member.offset;
         const uint8_t *src = origin + offset;
 
         switch (member.type->primitive) {
@@ -821,10 +842,18 @@ void CallData::PopObject(Napi::Object obj, const uint8_t *origin, const TypeInfo
             case PrimitiveKind::String: {
                 const char *str = *(const char **)src;
                 obj.Set(member.name, str ? Napi::String::New(env, str) : env.Null());
+
+                if (member.type->dispose) {
+                    member.type->dispose(env, member.type, str);
+                }
             } break;
             case PrimitiveKind::String16: {
                 const char16_t *str16 = *(const char16_t **)src;
                 obj.Set(member.name, str16 ? Napi::String::New(env, str16) : env.Null());
+
+                if (member.type->dispose) {
+                    member.type->dispose(env, member.type, str16);
+                }
             } break;
             case PrimitiveKind::Pointer:
             case PrimitiveKind::Callback: {
@@ -832,12 +861,16 @@ void CallData::PopObject(Napi::Object obj, const uint8_t *origin, const TypeInfo
 
                 if (ptr2) {
                     Napi::External<void> external = Napi::External<void>::New(env, ptr2);
-                    SetValueTag(instance, external, member.type);
+                    SetValueTag(instance, external, member.type->ref.marker);
 
                     obj.Set(member.name, external);
                 } else {
                     obj.Set(member.name, env.Null());
                 }
+
+                if (member.type->dispose) {
+                    member.type->dispose(env, member.type, ptr2);
+                }
             } break;
             case PrimitiveKind::Record: {
                 Napi::Object obj2 = PopObject(src, member.type, realign);
@@ -855,9 +888,9 @@ void CallData::PopObject(Napi::Object obj, const uint8_t *origin, const TypeInfo
                 double d = *(double *)src;
                 obj.Set(member.name, Napi::Number::New(env, d));
             } break;
-        }
 
-        offset += member.type->size;
+            case PrimitiveKind::Prototype: { RG_UNREACHABLE(); } break;
+        }
     }
 }
 
@@ -938,12 +971,20 @@ void CallData::PopNormalArray(Napi::Array array, const uint8_t *origin, const Ty
             POP_ARRAY({
                 const char *str = *(const char **)src;
                 array.Set(i, str ? Napi::String::New(env, str) : env.Null());
+
+                if (ref->dispose) {
+                    ref->dispose(env, ref, str);
+                }
             });
         } break;
         case PrimitiveKind::String16: {
             POP_ARRAY({
                 const char16_t *str16 = *(const char16_t **)src;
                 array.Set(i, str16 ? Napi::String::New(env, str16) : env.Null());
+
+                if (ref->dispose) {
+                    ref->dispose(env, ref, str16);
+                }
             });
         } break;
         case PrimitiveKind::Pointer:
@@ -953,12 +994,16 @@ void CallData::PopNormalArray(Napi::Array array, const uint8_t *origin, const Ty
 
                 if (ptr2) {
                     Napi::External<void> external = Napi::External<void>::New(env, ptr2);
-                    SetValueTag(instance, external, ref);
+                    SetValueTag(instance, external, ref->ref.marker);
 
                     array.Set(i, external);
                 } else {
                     array.Set(i, env.Null());
                 }
+
+                if (ref->dispose) {
+                    ref->dispose(env, ref, ptr2);
+                }
             });
         } break;
         case PrimitiveKind::Record: {
@@ -975,6 +1020,8 @@ void CallData::PopNormalArray(Napi::Array array, const uint8_t *origin, const Ty
         } break;
         case PrimitiveKind::Float32: { POP_NUMBER_ARRAY(float); } break;
         case PrimitiveKind::Float64: { POP_NUMBER_ARRAY(double); } break;
+
+        case PrimitiveKind::Prototype: { RG_UNREACHABLE(); } break;
     }
 
 #undef POP_NUMBER_ARRAY
@@ -984,24 +1031,25 @@ void CallData::PopNormalArray(Napi::Array array, const uint8_t *origin, const Ty
 void CallData::PopTypedArray(Napi::TypedArray array, const uint8_t *origin, const TypeInfo *ref, int16_t realign)
 {
     RG_ASSERT(array.IsTypedArray());
-    RG_ASSERT(GetTypedArrayType(ref) == array.TypedArrayType());
+    RG_ASSERT(GetTypedArrayType(ref) == array.TypedArrayType() ||
+              ref == instance->void_type);
 
     uint8_t *buf = (uint8_t *)array.ArrayBuffer().Data();
 
     if (realign) {
         Size offset = 0;
         Size len = (Size)array.ElementLength();
+        Size size = (Size)array.ElementSize();
 
         for (Size i = 0; i < len; i++) {
-            int16_t align = std::max(ref->align, realign);
-            offset = AlignLen(offset, align);
+            offset = AlignLen(offset, realign);
 
-            uint8_t *dest = buf + i * ref->size;
+            uint8_t *dest = buf + i * size;
             const uint8_t *src = origin + offset;
 
-            memcpy(dest, src, ref->size);
+            memcpy(dest, src, size);
 
-            offset += ref->size;
+            offset += size;
         }
     } else {
         memcpy_safe(buf, origin, (size_t)array.ByteLength());
@@ -1012,7 +1060,7 @@ Napi::Value CallData::PopArray(const uint8_t *origin, const TypeInfo *type, int1
 {
     RG_ASSERT(type->primitive == PrimitiveKind::Array);
 
-    uint32_t len = type->size / type->ref->size;
+    uint32_t len = type->size / type->ref.type->size;
     Size offset = 0;
 
 #define POP_ARRAY(SetCode) \
@@ -1020,14 +1068,14 @@ Napi::Value CallData::PopArray(const uint8_t *origin, const TypeInfo *type, int1
             Napi::Array array = Napi::Array::New(env); \
              \
             for (uint32_t i = 0; i < len; i++) { \
-                int16_t align = std::max(realign, type->ref->align); \
+                int16_t align = std::max(realign, type->ref.type->align); \
                 offset = AlignLen(offset, align); \
                  \
                 const uint8_t *src = origin + offset; \
                  \
                 SetCode \
                  \
-                offset += type->ref->size; \
+                offset += type->ref.type->size; \
             } \
              \
             return array; \
@@ -1041,13 +1089,13 @@ Napi::Value CallData::PopArray(const uint8_t *origin, const TypeInfo *type, int1
                 }); \
             } else { \
                 Napi::TypedArrayType array = Napi::TypedArrayType::New(env, len); \
-                PopTypedArray(array, origin, type->ref, realign); \
+                PopTypedArray(array, origin, type->ref.type, realign); \
                  \
                 return array; \
             } \
         } while (false)
 
-    switch (type->ref->primitive) {
+    switch (type->ref.type->primitive) {
         case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
 
         case PrimitiveKind::Bool: {
@@ -1117,7 +1165,7 @@ Napi::Value CallData::PopArray(const uint8_t *origin, const TypeInfo *type, int1
 
                 if (ptr2) {
                     Napi::External<void> external = Napi::External<void>::New(env, ptr2);
-                    SetValueTag(instance, external, type->ref);
+                    SetValueTag(instance, external, type->ref.type->ref.marker);
 
                     array.Set(i, external);
                 } else {
@@ -1127,18 +1175,20 @@ Napi::Value CallData::PopArray(const uint8_t *origin, const TypeInfo *type, int1
         } break;
         case PrimitiveKind::Record: {
             POP_ARRAY({
-                Napi::Object obj = PopObject(src, type->ref, realign);
+                Napi::Object obj = PopObject(src, type->ref.type, realign);
                 array.Set(i, obj);
             });
         } break;
         case PrimitiveKind::Array: {
             POP_ARRAY({
-                Napi::Value value = PopArray(src, type->ref, realign);
+                Napi::Value value = PopArray(src, type->ref.type, realign);
                 array.Set(i, value);
             });
         } break;
         case PrimitiveKind::Float32: { POP_NUMBER_ARRAY(Float32Array, float); } break;
         case PrimitiveKind::Float64: { POP_NUMBER_ARRAY(Float64Array, double); } break;
+
+        case PrimitiveKind::Prototype: { RG_UNREACHABLE(); } break;
     }
 
 #undef POP_NUMBER_ARRAY

package/src/call.hh

@@ -42,7 +42,7 @@ class alignas(8) CallData {
     Span<uint8_t> old_stack_mem;
     Span<uint8_t> old_heap_mem;
 
-    uint32_t used_trampolines = 0;
+    int16_t used_trampolines = 0;
 
     LocalArray<OutArgument, MaxOutParameters> out_arguments;
 
@@ -71,9 +71,21 @@ public:
     CallData(Napi::Env env, InstanceData *instance, const FunctionInfo *func, InstanceMemory *mem);
     ~CallData();
 
-    bool Prepare(const Napi::CallbackInfo &info);
-    void Execute();
-    Napi::Value Complete();
+#ifdef UNITY_BUILD
+    #ifdef _MSC_VER
+        #define INLINE_IF_UNITY __forceinline
+    #else
+        #define INLINE_IF_UNITY __attribute__((always_inline)) inline
+    #endif
+#else
+    #define INLINE_IF_UNITY
+#endif
+
+    INLINE_IF_UNITY bool Prepare(const Napi::CallbackInfo &info);
+    INLINE_IF_UNITY void Execute();
+    INLINE_IF_UNITY Napi::Value Complete();
+
+#undef INLINE_IF_UNITY
 
     void Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg);
 
@@ -103,6 +115,7 @@ private:
 
     void *ReserveTrampoline(const FunctionInfo *proto, Napi::Function func);
 };
+RG_STATIC_ASSERT(MaxTrampolines <= 32);
 
 template <typename T>
 inline bool CallData::AllocStack(Size size, Size align, T **out_ptr)