koffi 1.1.5 → 1.2.0-alpha.3

package/src/abi_arm32.cc

@@ -31,13 +31,65 @@ struct HfaRet {
     double d3;
 };
 
-extern "C" uint64_t ForwardCallGG(const void *func, uint8_t *sp);
-extern "C" float ForwardCallF(const void *func, uint8_t *sp);
-extern "C" HfaRet ForwardCallDDDD(const void *func, uint8_t *sp);
+struct BackRegisters {
+    uint32_t r0;
+    uint32_t r1;
+    double d0;
+    double d1;
+    double d2;
+    double d3;
+};
+
+extern "C" uint64_t ForwardCallGG(const void *func, uint8_t *sp, uint8_t **out_old_sp);
+extern "C" float ForwardCallF(const void *func, uint8_t *sp, uint8_t **out_old_sp);
+extern "C" HfaRet ForwardCallDDDD(const void *func, uint8_t *sp, uint8_t **out_old_sp);
+
+extern "C" uint64_t ForwardCallXGG(const void *func, uint8_t *sp, uint8_t **out_old_sp);
+extern "C" float ForwardCallXF(const void *func, uint8_t *sp, uint8_t **out_old_sp);
+extern "C" HfaRet ForwardCallXDDDD(const void *func, uint8_t *sp, uint8_t **out_old_sp);
+
+extern "C" int Trampoline0; extern "C" int TrampolineX0;
+extern "C" int Trampoline1; extern "C" int TrampolineX1;
+extern "C" int Trampoline2; extern "C" int TrampolineX2;
+extern "C" int Trampoline3; extern "C" int TrampolineX3;
+extern "C" int Trampoline4; extern "C" int TrampolineX4;
+extern "C" int Trampoline5; extern "C" int TrampolineX5;
+extern "C" int Trampoline6; extern "C" int TrampolineX6;
+extern "C" int Trampoline7; extern "C" int TrampolineX7;
+extern "C" int Trampoline8; extern "C" int TrampolineX8;
+extern "C" int Trampoline9; extern "C" int TrampolineX9;
+extern "C" int Trampoline10; extern "C" int TrampolineX10;
+extern "C" int Trampoline11; extern "C" int TrampolineX11;
+extern "C" int Trampoline12; extern "C" int TrampolineX12;
+extern "C" int Trampoline13; extern "C" int TrampolineX13;
+extern "C" int Trampoline14; extern "C" int TrampolineX14;
+extern "C" int Trampoline15; extern "C" int TrampolineX15;
+
+extern "C" napi_value CallSwitchStack(Napi::Function *func, size_t argc, napi_value *argv,
+                                      uint8_t *old_sp, Span<uint8_t> *new_stack,
+                                      napi_value (*call)(Napi::Function *func, size_t argc, napi_value *argv));
+
+static void *const Trampolines[][2] = {
+    { &Trampoline0, &TrampolineX0 },
+    { &Trampoline1, &TrampolineX1 },
+    { &Trampoline2, &TrampolineX2 },
+    { &Trampoline3, &TrampolineX3 },
+    { &Trampoline4, &TrampolineX4 },
+    { &Trampoline5, &TrampolineX5 },
+    { &Trampoline6, &TrampolineX6 },
+    { &Trampoline7, &TrampolineX7 },
+    { &Trampoline8, &TrampolineX8 },
+    { &Trampoline9, &TrampolineX9 },
+    { &Trampoline10, &TrampolineX10 },
+    { &Trampoline11, &TrampolineX11 },
+    { &Trampoline12, &TrampolineX12 },
+    { &Trampoline13, &TrampolineX13 },
+    { &Trampoline14, &TrampolineX14 },
+    { &Trampoline15, &TrampolineX15 }
+};
+RG_STATIC_ASSERT(RG_LEN(Trampolines) == MaxTrampolines);
 
-extern "C" uint64_t ForwardCallXGG(const void *func, uint8_t *sp);
-extern "C" float ForwardCallXF(const void *func, uint8_t *sp);
-extern "C" HfaRet ForwardCallXDDDD(const void *func, uint8_t *sp);
+static RG_THREAD_LOCAL CallData *exec_call;
 
 static inline int IsHFA(const TypeInfo *type)
 {
@@ -76,7 +128,8 @@ bool AnalyseFunction(InstanceData *, FunctionInfo *func)
             case PrimitiveKind::UInt32:
             case PrimitiveKind::String:
             case PrimitiveKind::String16:
-            case PrimitiveKind::Pointer: {
+            case PrimitiveKind::Pointer:
+            case PrimitiveKind::Callback: {
                 if (gpr_avail) {
                     param.gpr_count = 1;
                     gpr_avail--;
@@ -86,9 +139,11 @@ bool AnalyseFunction(InstanceData *, FunctionInfo *func)
             } break;
             case PrimitiveKind::Int64:
             case PrimitiveKind::UInt64: {
-                if (gpr_avail >= 2) {
-                    param.gpr_count = 2;
-                    gpr_avail -= 2;
+                int need = 2 + (gpr_avail % 2);
+
+                if (gpr_avail >= need) {
+                    param.gpr_count = need;
+                    gpr_avail -= need;
                 } else {
                     started_stack = true;
                 }
@@ -127,7 +182,7 @@ bool AnalyseFunction(InstanceData *, FunctionInfo *func)
                 bool vfp = false;
 #endif
 
-                Size need = param.type->size / 4;
+                int need = param.type->size / 4;
 
                 if (vfp) {
                     if (need <= vec_avail) {
@@ -137,6 +192,8 @@ bool AnalyseFunction(InstanceData *, FunctionInfo *func)
                         started_stack = true;
                     }
                 } else {
+                    need += (gpr_avail % 2);
+
                     if (need <= gpr_avail) {
                         param.gpr_count = need;
                         gpr_avail -= need;
@@ -206,24 +263,37 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
             case PrimitiveKind::UInt8:
             case PrimitiveKind::Int16:
             case PrimitiveKind::UInt16:
-            case PrimitiveKind::Int32:
+            case PrimitiveKind::Int32: {
+                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
+                    return false;
+                }
+
+                int32_t v = CopyNumber<int32_t>(value);
+
+                if (RG_LIKELY(param.gpr_count)) {
+                    *(int32_t *)(gpr_ptr++) = v;
+                } else {
+                    *(int32_t *)args_ptr = v;
+                    args_ptr += 4;
+                }
+            } break;
             case PrimitiveKind::UInt32: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
                     return false;
                 }
 
-                int64_t v = CopyNumber<int64_t>(value);
+                uint32_t v = CopyNumber<uint32_t>(value);
 
                 if (RG_LIKELY(param.gpr_count)) {
-                    *(gpr_ptr++) = (uint32_t)v;
+                    *(gpr_ptr++) = v;
                 } else {
-                    memcpy(args_ptr, &v, param.type->size); // Little Endian
+                    *(uint32_t *)args_ptr = v;
                     args_ptr += 4;
                 }
             } break;
-            case PrimitiveKind::Int64:
-            case PrimitiveKind::UInt64: {
+            case PrimitiveKind::Int64: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
                     return false;
@@ -232,11 +302,30 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 int64_t v = CopyNumber<int64_t>(value);
 
                 if (RG_LIKELY(param.gpr_count)) {
-                    *(uint64_t *)gpr_ptr = (uint64_t)v;
-                    gpr_ptr += 2;
+                    gpr_ptr += param.gpr_count - 2;
+                    *(int64_t *)gpr_ptr = v;
+                    gpr_ptr += param.gpr_count;
                 } else {
                     args_ptr = AlignUp(args_ptr, 8);
-                    memcpy(args_ptr, &v, param.type->size); // Little Endian
+                    *(int64_t *)args_ptr = v;
+                    args_ptr += 8;
+                }
+            } break;
+            case PrimitiveKind::UInt64: {
+                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
+                    return false;
+                }
+
+                uint64_t v = CopyNumber<uint64_t>(value);
+
+                if (RG_LIKELY(param.gpr_count)) {
+                    gpr_ptr += param.gpr_count - 2;
+                    *(uint64_t *)gpr_ptr = v;
+                    gpr_ptr += param.gpr_count;
+                } else {
+                    args_ptr = AlignUp(args_ptr, 8);
+                    *(uint64_t *)args_ptr = v;
                     args_ptr += 8;
                 }
             } break;
@@ -357,11 +446,11 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 float f = CopyNumber<float>(value);
 
                 if (RG_LIKELY(param.vec_count)) {
-                    memcpy(vec_ptr++, &f, 4);
+                    *(float *)(vec_ptr++) = f;
                 } else if (param.gpr_count) {
-                    memcpy(gpr_ptr++, &f, 4);
+                    *(float *)(gpr_ptr++) = f;
                 } else {
-                    memcpy(args_ptr, &f, 4);
+                    *(float *)args_ptr = f;
                     args_ptr += 4;
                 }
             } break;
@@ -374,31 +463,61 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 double d = CopyNumber<double>(value);
 
                 if (RG_LIKELY(param.vec_count)) {
-                    memcpy(vec_ptr, &d, 8);
+                    *(double *)vec_ptr = d;
                     vec_ptr += 2;
                 } else if (param.gpr_count) {
-                    memcpy(gpr_ptr, &d, 8);
+                    gpr_ptr += (param.gpr_count - 2);
+                    *(double *)gpr_ptr = d;
                     gpr_ptr += 2;
                 } else {
                     args_ptr = AlignUp(args_ptr, 8);
-                    memcpy(args_ptr, &d, 8);
+                    *(double *)args_ptr = d;
                     args_ptr += 8;
                 }
             } break;
+            case PrimitiveKind::Callback: {
+                void *ptr;
+
+                if (value.IsFunction()) {
+                    Napi::Function func = value.As<Napi::Function>();
+
+                    Size idx = ReserveTrampoline(param.type->proto, func);
+                    if (RG_UNLIKELY(idx < 0))
+                        return false;
+
+                    ptr = GetTrampoline(idx, param.type->proto);
+                } else if (CheckValueTag(instance, value, param.type)) {
+                    ptr = value.As<Napi::External<void>>().Data();
+                } else if (IsNullOrUndefined(value)) {
+                    ptr = nullptr;
+                } else {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected %3", GetValueType(instance, value), i + 1, param.type->name);
+                    return false;
+                }
+
+                if (RG_LIKELY(param.gpr_count)) {
+                    *(gpr_ptr++) = (uint32_t)ptr;
+                } else {
+                    *(void **)args_ptr = ptr;
+                    args_ptr += 4;
+                }
+            } break;
         }
     }
 
-    sp = mem->stack.end();
+    new_sp = mem->stack.end();
 
     return true;
 }
 
 void CallData::Execute()
 {
+    exec_call = this;
+
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
-            auto ret = (func->forward_fp ? ForwardCallX ## Suffix(func->func, sp) \
-                                         : ForwardCall ## Suffix(func->func, sp)); \
+            auto ret = (func->forward_fp ? ForwardCallX ## Suffix(func->func, new_sp, &old_sp) \
+                                         : ForwardCall ## Suffix(func->func, new_sp, &old_sp)); \
             return ret; \
         })()
 
@@ -416,7 +535,8 @@ void CallData::Execute()
         case PrimitiveKind::UInt64:
         case PrimitiveKind::String:
         case PrimitiveKind::String16:
-        case PrimitiveKind::Pointer: { result.u64 = PERFORM_CALL(GG); } break;
+        case PrimitiveKind::Pointer:
+        case PrimitiveKind::Callback: { result.u64 = PERFORM_CALL(GG); } break;
         case PrimitiveKind::Record: {
             if (func->ret.vec_count) {
                 HfaRet ret = PERFORM_CALL(DDDD);
@@ -453,11 +573,16 @@ Napi::Value CallData::Complete()
         case PrimitiveKind::UInt64: return Napi::BigInt::New(env, result.u64);
         case PrimitiveKind::String: return Napi::String::New(env, (const char *)result.ptr);
         case PrimitiveKind::String16: return Napi::String::New(env, (const char16_t *)result.ptr);
-        case PrimitiveKind::Pointer: {
-            Napi::External<void> external = Napi::External<void>::New(env, result.ptr);
-            SetValueTag(instance, external, func->ret.type);
+        case PrimitiveKind::Pointer:
+        case PrimitiveKind::Callback: {
+            if (result.ptr) {
+                Napi::External<void> external = Napi::External<void>::New(env, result.ptr);
+                SetValueTag(instance, external, func->ret.type);
 
-            return external;
+                return external;
+            } else {
+                return env.Null();
+            }
         } break;
         case PrimitiveKind::Record: {
             const uint8_t *ptr = return_ptr ? (const uint8_t *)return_ptr
@@ -474,6 +599,367 @@ Napi::Value CallData::Complete()
     RG_UNREACHABLE();
 }
 
+void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
+{
+    const FunctionInfo *proto = instance->trampolines[idx].proto;
+    Napi::Function func = instance->trampolines[idx].func;
+
+    // Allow reuse of static trampoline
+    instance->free_trampolines |= 1u << idx;
+    used_trampolines &= ~(1u << idx);
+
+    uint64_t *vec_ptr = (uint64_t *)own_sp;
+    uint32_t *gpr_ptr = (uint32_t *)(vec_ptr + 8);
+    uint32_t *args_ptr = (uint32_t *)caller_sp;
+
+    uint8_t *return_ptr = proto->ret.use_memory ? (uint8_t *)gpr_ptr[0] : nullptr;
+    gpr_ptr += proto->ret.use_memory;
+
+    LocalArray<napi_value, MaxParameters> arguments;
+
+    // Convert to JS arguments
+    for (Size i = 0; i < proto->parameters.len; i++) {
+        const ParameterInfo &param = proto->parameters[i];
+        RG_ASSERT(param.directions >= 1 && param.directions <= 3);
+
+        switch (param.type->primitive) {
+            case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
+
+            case PrimitiveKind::Bool: {
+                bool b = *(bool *)((param.gpr_count ? gpr_ptr : args_ptr)++);
+
+                Napi::Value arg = Napi::Boolean::New(env, b);
+                arguments.Append(arg);
+            } break;
+            case PrimitiveKind::Int8: {
+                double d = (double)*(int8_t *)((param.gpr_count ? gpr_ptr : args_ptr)++);
+
+                Napi::Value arg = Napi::Number::New(env, d);
+                arguments.Append(arg);
+            } break;
+            case PrimitiveKind::UInt8: {
+                double d = (double)*(uint8_t *)((param.gpr_count ? gpr_ptr : args_ptr)++);
+
+                Napi::Value arg = Napi::Number::New(env, d);
+                arguments.Append(arg);
+            } break;
+            case PrimitiveKind::Int16: {
+                double d = (double)*(int16_t *)((param.gpr_count ? gpr_ptr : args_ptr)++);
+
+                Napi::Value arg = Napi::Number::New(env, d);
+                arguments.Append(arg);
+            } break;
+            case PrimitiveKind::UInt16: {
+                double d = (double)*(uint16_t *)((param.gpr_count ? gpr_ptr : args_ptr)++);
+
+                Napi::Value arg = Napi::Number::New(env, d);
+                arguments.Append(arg);
+            } break;
+            case PrimitiveKind::Int32: {
+                double d = (double)*(int32_t *)((param.gpr_count ? gpr_ptr : args_ptr)++);
+
+                Napi::Value arg = Napi::Number::New(env, d);
+                arguments.Append(arg);
+            } break;
+            case PrimitiveKind::UInt32: {
+                double d = (double)*(int32_t *)((param.gpr_count ? gpr_ptr : args_ptr)++);
+
+                Napi::Value arg = Napi::Number::New(env, d);
+                arguments.Append(arg);
+            } break;
+            case PrimitiveKind::Int64: {
+                gpr_ptr += param.gpr_count - 2;
+                int64_t v = *(int64_t *)(param.gpr_count ? gpr_ptr : args_ptr);
+                (param.gpr_count ? gpr_ptr : args_ptr) += 2;
+
+                Napi::Value arg = Napi::BigInt::New(env, v);
+                arguments.Append(arg);
+            } break;
+            case PrimitiveKind::UInt64: {
+                gpr_ptr += param.gpr_count - 2;
+                uint64_t v = *(uint64_t *)(param.gpr_count ? gpr_ptr : args_ptr);
+                (param.gpr_count ? gpr_ptr : args_ptr) += 2;
+
+                Napi::Value arg = Napi::BigInt::New(env, v);
+                arguments.Append(arg);
+            } break;
+            case PrimitiveKind::String: {
+                const char *str = *(const char **)((param.gpr_count ? gpr_ptr : args_ptr)++);
+
+                Napi::Value arg = Napi::String::New(env, str);
+                arguments.Append(arg);
+            } break;
+            case PrimitiveKind::String16: {
+                const char16_t *str16 = *(const char16_t **)((param.gpr_count ? gpr_ptr : args_ptr)++);
+
+                Napi::Value arg = Napi::String::New(env, str16);
+                arguments.Append(arg);
+            } break;
+            case PrimitiveKind::Pointer:
+            case PrimitiveKind::Callback: {
+                void *ptr2 = *(void **)((param.gpr_count ? gpr_ptr : args_ptr)++);
+
+                if (ptr2) {
+                    Napi::External<void> external = Napi::External<void>::New(env, ptr2);
+                    SetValueTag(instance, external, param.type);
+
+                    arguments.Append(external);
+                } else {
+                    arguments.Append(env.Null());
+                }
+            } break;
+            case PrimitiveKind::Record: {
+                if (param.vec_count) {
+                    Napi::Object obj = PopObject((const uint8_t *)vec_ptr, param.type);
+                    arguments.Append(obj);
+
+                    vec_ptr += param.vec_count;
+                } else if (param.gpr_count) {
+                    RG_ASSERT(param.type->align <= 8);
+
+                    Napi::Object obj = PopObject((const uint8_t *)gpr_ptr, param.type);
+                    arguments.Append(obj);
+
+                    gpr_ptr += param.gpr_count;
+                    args_ptr += (param.type->size - param.gpr_count * 4 + 3) / 4;
+                } else if (param.type->size) {
+                    int16_t align = (param.type->align <= 4) ? 4 : 8;
+                    args_ptr = AlignUp(args_ptr, align);
+
+                    Napi::Object obj = PopObject((const uint8_t *)args_ptr, param.type);
+                    arguments.Append(obj);
+
+                    args_ptr += (param.type->size + 3) / 4;
+                }
+            } break;
+            case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
+            case PrimitiveKind::Float32: {
+                float f;
+                if (RG_LIKELY(param.vec_count)) {
+                    f = *(float *)(vec_ptr++);
+                } else if (param.gpr_count) {
+                    f = *(float *)(gpr_ptr++);
+                } else {
+                    f = *(float *)(args_ptr++);
+                }
+
+                Napi::Value arg = Napi::Number::New(env, (double)f);
+                arguments.Append(arg);
+            } break;
+            case PrimitiveKind::Float64: {
+                double d;
+                if (RG_LIKELY(param.vec_count)) {
+                    d = *(double *)vec_ptr;
+                    vec_ptr += 2;
+                } else if (param.gpr_count) {
+                    gpr_ptr += param.gpr_count - 2;
+                    d = *(double *)gpr_ptr;
+                    gpr_ptr += 2;
+                } else {
+                    d = *(double *)args_ptr;
+                    args_ptr += 2;
+                }
+
+                Napi::Value arg = Napi::Number::New(env, d);
+                arguments.Append(arg);
+            } break;
+        }
+    }
+
+    const TypeInfo *type = proto->ret.type;
+
+    // Make the call
+    napi_value ret = CallSwitchStack(&func, (size_t)arguments.len, arguments.data, old_sp, &mem->stack,
+                                     [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argc, argv); });
+    Napi::Value value(env, ret);
+
+    // Convert the result
+    switch (type->primitive) {
+        case PrimitiveKind::Void: {} break;
+        case PrimitiveKind::Bool: {
+            if (RG_UNLIKELY(!value.IsBoolean())) {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value for return value, expected boolean", GetValueType(instance, value));
+                return;
+            }
+
+            bool b = value.As<Napi::Boolean>();
+            out_reg->r0 = (uint32_t)b;
+        } break;
+        case PrimitiveKind::Int8:
+        case PrimitiveKind::UInt8:
+        case PrimitiveKind::Int16:
+        case PrimitiveKind::UInt16:
+        case PrimitiveKind::Int32: {
+            if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value for return value, expected number", GetValueType(instance, value));
+                return;
+            }
+
+            int32_t v = CopyNumber<int32_t>(value);
+            out_reg->r0 = (uint32_t)v;
+        } break;
+        case PrimitiveKind::UInt32: {
+            if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value for return value, expected number", GetValueType(instance, value));
+                return;
+            }
+
+            uint32_t v = CopyNumber<uint32_t>(value);
+            out_reg->r0 = v;
+        } break;
+        case PrimitiveKind::Int64: {
+            if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value for return value, expected number", GetValueType(instance, value));
+                return;
+            }
+
+            int64_t v = CopyNumber<int64_t>(value);
+            out_reg->r0 = (uint32_t)(v >> 32);
+            out_reg->r1 = (uint32_t)((uint64_t)v & 0xFFFFFFFFu);
+        } break;
+        case PrimitiveKind::UInt64: {
+            if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value for return value, expected number", GetValueType(instance, value));
+                return;
+            }
+
+            uint64_t v = CopyNumber<uint64_t>(value);
+            out_reg->r0 = (uint32_t)(v >> 32);
+            out_reg->r1 = (uint32_t)((uint64_t)v & 0xFFFFFFFFu);
+        } break;
+        case PrimitiveKind::String: {
+            const char *str;
+            if (RG_LIKELY(value.IsString())) {
+                str = PushString(value);
+                if (RG_UNLIKELY(!str))
+                    return;
+            } else if (IsNullOrUndefined(value)) {
+                str = nullptr;
+            } else {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value for return value, expected string", GetValueType(instance, value));
+                return;
+            }
+
+            out_reg->r0 = (uint32_t)str;
+        } break;
+        case PrimitiveKind::String16: {
+            const char16_t *str16;
+            if (RG_LIKELY(value.IsString())) {
+                str16 = PushString16(value);
+                if (RG_UNLIKELY(!str16))
+                    return;
+            } else if (IsNullOrUndefined(value)) {
+                str16 = nullptr;
+            } else {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value for return value, expected string", GetValueType(instance, value));
+                return;
+            }
+
+            out_reg->r0 = (uint32_t)str16;
+        } break;
+        case PrimitiveKind::Pointer: {
+            uint8_t *ptr;
+
+            if (CheckValueTag(instance, value, type)) {
+                ptr = value.As<Napi::External<uint8_t>>().Data();
+            } else if (IsObject(value) && type->ref->primitive == PrimitiveKind::Record) {
+                Napi::Object obj = value.As<Napi::Object>();
+
+                if (RG_UNLIKELY(!AllocHeap(type->ref->size, 16, &ptr)))
+                    return;
+
+                if (!PushObject(obj, type->ref, ptr))
+                    return;
+            } else if (IsNullOrUndefined(value)) {
+                ptr = nullptr;
+            } else {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value for return value, expected %2", GetValueType(instance, value), type->name);
+                return;
+            }
+
+            out_reg->r0 = (uint32_t)ptr;
+        } break;
+        case PrimitiveKind::Record: {
+            if (RG_UNLIKELY(!IsObject(value))) {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value for return value, expected object", GetValueType(instance, value));
+                return;
+            }
+
+            Napi::Object obj = value.As<Napi::Object>();
+
+            if (return_ptr) {
+                if (!PushObject(obj, type, return_ptr))
+                    return;
+                out_reg->r0 = (uint32_t)return_ptr;
+            } else if (proto->ret.vec_count) { // HFA
+                PushObject(obj, type, (uint8_t *)&out_reg->d0, 8);
+            } else {
+                PushObject(obj, type, (uint8_t *)&out_reg->r0);
+            }
+        } break;
+        case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
+        case PrimitiveKind::Float32: {
+            if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value for return value, expected number", GetValueType(instance, value));
+                return;
+            }
+
+            float f = CopyNumber<float>(value);
+#ifdef __ARM_PCS_VFP
+            memcpy(&out_reg->d0, &f, 4);
+#else
+            memcpy(&out_reg->r0, &f, 4);
+#endif
+        } break;
+        case PrimitiveKind::Float64: {
+            if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value for return value, expected number", GetValueType(instance, value));
+                return;
+            }
+
+            double d = CopyNumber<double>(value);
+#ifdef __ARM_PCS_VFP
+            out_reg->d0 = d;
+#else
+            memcpy(&out_reg->r0, &d, 8);
+#endif
+        } break;
+        case PrimitiveKind::Callback: {
+            void *ptr;
+
+            if (value.IsFunction()) {
+                Napi::Function func = value.As<Napi::Function>();
+
+                Size idx = ReserveTrampoline(type->proto, func);
+                if (RG_UNLIKELY(idx < 0))
+                    return;
+
+                ptr = GetTrampoline(idx, type->proto);
+            } else if (CheckValueTag(instance, value, type)) {
+                ptr = value.As<Napi::External<uint8_t>>().Data();
+            } else if (IsNullOrUndefined(value)) {
+                ptr = nullptr;
+            } else {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value for return value, expected %2", GetValueType(instance, value), type->name);
+                return;
+            }
+
+            out_reg->r0 = (uint32_t)ptr;
+        } break;
+    }
+}
+
+void *GetTrampoline(Size idx, const FunctionInfo *proto)
+{
+    bool vec = proto->forward_fp || IsFloat(proto->ret.type);
+    return Trampolines[idx][vec];
+}
+
+extern "C" void RelayCallBack(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
+{
+    exec_call->Relay(idx, own_sp, caller_sp, out_reg);
+}
+
 }
 
 #endif