koffi 1.0.3 → 1.1.0-beta.0

package/src/call.cc

@@ -20,19 +20,24 @@
 
 namespace RG {
 
-CallData::CallData(Napi::Env env, InstanceData *instance, const FunctionInfo *func)
-    : env(env), instance(instance), func(func),
-      stack_mem(&instance->stack_mem), heap_mem(&instance->heap_mem),
-      old_stack_mem(instance->stack_mem), old_heap_mem(instance->heap_mem)
+CallData::CallData(Napi::Env env, const FunctionInfo *func, InstanceMemory *mem, bool debug)
+    : env(env), instance(env.GetInstanceData<InstanceData>()), func(func), debug(debug),
+      mem(mem), old_stack_mem(mem->stack), old_heap_mem(mem->heap)
 {
-    RG_ASSERT(AlignUp(stack_mem->ptr, 16) == stack_mem->ptr);
-    RG_ASSERT(AlignUp(stack_mem->end(), 16) == stack_mem->end());
+    mem->depth++;
+
+    RG_ASSERT(AlignUp(mem->stack.ptr, 16) == mem->stack.ptr);
+    RG_ASSERT(AlignUp(mem->stack.end(), 16) == mem->stack.end());
 }
 
 CallData::~CallData()
 {
-    instance->stack_mem = old_stack_mem;
-    instance->heap_mem = old_heap_mem;
+    mem->stack = old_stack_mem;
+    mem->heap = old_heap_mem;
+
+    if (!--mem->depth && mem->temporary) {
+        delete mem;
+    }
 }
 
 const char *CallData::PushString(const Napi::Value &value)
@@ -45,8 +50,8 @@ const char *CallData::PushString(const Napi::Value &value)
     size_t len = 0;
     napi_status status;
 
-    buf.ptr = (char *)heap_mem->ptr;
-    buf.len = std::max((Size)0, heap_mem->len - Kibibytes(32));
+    buf.ptr = (char *)mem->heap.ptr;
+    buf.len = std::max((Size)0, mem->heap.len - Kibibytes(32));
 
     status = napi_get_value_string_utf8(env, value, buf.ptr, (size_t)buf.len, &len);
     RG_ASSERT(status == napi_ok);
@@ -54,15 +59,15 @@ const char *CallData::PushString(const Napi::Value &value)
     len++;
 
     if (RG_LIKELY(len < (size_t)buf.len)) {
-        heap_mem->ptr += (Size)len;
-        heap_mem->len -= (Size)len;
+        mem->heap.ptr += (Size)len;
+        mem->heap.len -= (Size)len;
     } else {
         status = napi_get_value_string_utf8(env, value, nullptr, 0, &len);
         RG_ASSERT(status == napi_ok);
 
         len++;
 
-        buf.ptr = (char *)Allocator::Allocate(&big_alloc, (Size)len);
+        buf.ptr = (char *)Allocator::Allocate(&mem->big_alloc, (Size)len);
         buf.len = (Size)len;
 
         status = napi_get_value_string_utf8(env, value, buf.ptr, (size_t)buf.len, &len);
@@ -82,8 +87,8 @@ const char16_t *CallData::PushString16(const Napi::Value &value)
     size_t len = 0;
     napi_status status;
 
-    buf.ptr = (char16_t *)heap_mem->ptr;
-    buf.len = std::max((Size)0, heap_mem->len - Kibibytes(32)) / 2;
+    buf.ptr = (char16_t *)mem->heap.ptr;
+    buf.len = std::max((Size)0, mem->heap.len - Kibibytes(32)) / 2;
 
     status = napi_get_value_string_utf16(env, value, buf.ptr, (size_t)buf.len, &len);
     RG_ASSERT(status == napi_ok);
@@ -91,15 +96,15 @@ const char16_t *CallData::PushString16(const Napi::Value &value)
     len++;
 
     if (RG_LIKELY(len < (size_t)buf.len)) {
-        heap_mem->ptr += (Size)len * 2;
-        heap_mem->len -= (Size)len * 2;
+        mem->heap.ptr += (Size)len * 2;
+        mem->heap.len -= (Size)len * 2;
     } else {
         status = napi_get_value_string_utf16(env, value, nullptr, 0, &len);
         RG_ASSERT(status == napi_ok);
 
         len++;
 
-        buf.ptr = (char16_t *)Allocator::Allocate(&big_alloc, (Size)len * 2);
+        buf.ptr = (char16_t *)Allocator::Allocate(&mem->big_alloc, (Size)len * 2);
         buf.len = (Size)len;
 
         status = napi_get_value_string_utf16(env, value, buf.ptr, (size_t)buf.len, &len);
@@ -111,9 +116,6 @@ const char16_t *CallData::PushString16(const Napi::Value &value)
 
 bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t *dest)
 {
-    Napi::Env env = obj.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
-
     RG_ASSERT(IsObject(obj));
     RG_ASSERT(type->primitive == PrimitiveKind::Record);
 
@@ -156,24 +158,6 @@ bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t
                 int64_t v = CopyNumber<int64_t>(value);
                 memcpy(dest, &v, member.type->size); // Little Endian
             } break;
-            case PrimitiveKind::Float32: {
-                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected number", GetValueType(instance, value), member.name);
-                    return false;
-                }
-
-                float f = CopyNumber<float>(value);
-                memcpy(dest, &f, 4);
-            } break;
-            case PrimitiveKind::Float64: {
-                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected number", GetValueType(instance, value), member.name);
-                    return false;
-                }
-
-                double d = CopyNumber<double>(value);
-                memcpy(dest, &d, 8);
-            } break;
             case PrimitiveKind::String: {
                 if (RG_UNLIKELY(!value.IsString())) {
                     ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected string", GetValueType(instance, value), member.name);
@@ -206,7 +190,6 @@ bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t
                 void *ptr = external.Data();
                 *(void **)dest = ptr;
             } break;
-
             case PrimitiveKind::Record: {
                 if (RG_UNLIKELY(!IsObject(value))) {
                     ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected object", GetValueType(instance, value), member.name);
@@ -217,6 +200,24 @@ bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t
                 if (!PushObject(obj, member.type, dest))
                     return false;
             } break;
+            case PrimitiveKind::Float32: {
+                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected number", GetValueType(instance, value), member.name);
+                    return false;
+                }
+
+                float f = CopyNumber<float>(value);
+                memcpy(dest, &f, 4);
+            } break;
+            case PrimitiveKind::Float64: {
+                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected number", GetValueType(instance, value), member.name);
+                    return false;
+                }
+
+                double d = CopyNumber<double>(value);
+                memcpy(dest, &d, 8);
+            } break;
         }
 
         dest += member.type->size;
@@ -225,4 +226,127 @@ bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t
     return true;
 }
 
+void CallData::PopObject(Napi::Object obj, const uint8_t *ptr, const TypeInfo *type)
+{
+    RG_ASSERT(type->primitive == PrimitiveKind::Record);
+
+    for (const RecordMember &member: type->members) {
+        ptr = AlignUp(ptr, member.align);
+
+        switch (member.type->primitive) {
+            case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
+
+            case PrimitiveKind::Bool: {
+                bool b = *(bool *)ptr;
+                obj.Set(member.name, Napi::Boolean::New(env, b));
+            } break;
+            case PrimitiveKind::Int8: {
+                double d = (double)*(int8_t *)ptr;
+                obj.Set(member.name, Napi::Number::New(env, d));
+            } break;
+            case PrimitiveKind::UInt8: {
+                double d = (double)*(uint8_t *)ptr;
+                obj.Set(member.name, Napi::Number::New(env, d));
+            } break;
+            case PrimitiveKind::Int16: {
+                double d = (double)*(int16_t *)ptr;
+                obj.Set(member.name, Napi::Number::New(env, d));
+            } break;
+            case PrimitiveKind::UInt16: {
+                double d = (double)*(uint16_t *)ptr;
+                obj.Set(member.name, Napi::Number::New(env, d));
+            } break;
+            case PrimitiveKind::Int32: {
+                double d = (double)*(int32_t *)ptr;
+                obj.Set(member.name, Napi::Number::New(env, d));
+            } break;
+            case PrimitiveKind::UInt32: {
+                double d = (double)*(uint32_t *)ptr;
+                obj.Set(member.name, Napi::Number::New(env, d));
+            } break;
+            case PrimitiveKind::Int64: {
+                int64_t v = *(int64_t *)ptr;
+                obj.Set(member.name, Napi::BigInt::New(env, v));
+            } break;
+            case PrimitiveKind::UInt64: {
+                uint64_t v = *(uint64_t *)ptr;
+                obj.Set(member.name, Napi::BigInt::New(env, v));
+            } break;
+            case PrimitiveKind::String: {
+                const char *str = *(const char **)ptr;
+                obj.Set(member.name, Napi::String::New(env, str));
+            } break;
+            case PrimitiveKind::String16: {
+                const char16_t *str16 = *(const char16_t **)ptr;
+                obj.Set(member.name, Napi::String::New(env, str16));
+            } break;
+            case PrimitiveKind::Pointer: {
+                void *ptr2 = *(void **)ptr;
+
+                Napi::External<void> external = Napi::External<void>::New(env, ptr2);
+                SetValueTag(instance, external, member.type);
+
+                obj.Set(member.name, external);
+            } break;
+            case PrimitiveKind::Record: {
+                Napi::Object obj2 = PopObject(ptr, member.type);
+                obj.Set(member.name, obj2);
+            } break;
+            case PrimitiveKind::Float32: {
+                float f;
+                memcpy(&f, ptr, 4);
+                obj.Set(member.name, Napi::Number::New(env, (double)f));
+            } break;
+            case PrimitiveKind::Float64: {
+                double d;
+                memcpy(&d, ptr, 8);
+                obj.Set(member.name, Napi::Number::New(env, d));
+            } break;
+        }
+
+        ptr += member.type->size;
+    }
+}
+
+Napi::Object CallData::PopObject(const uint8_t *ptr, const TypeInfo *type)
+{
+    Napi::Object obj = Napi::Object::New(env);
+    PopObject(obj, ptr, type);
+    return obj;
+}
+
+static void DumpMemory(const char *type, Span<const uint8_t> bytes)
+{
+    if (bytes.len) {
+        PrintLn(stderr, "%1 at 0x%2 (%3):", type, bytes.ptr, FmtMemSize(bytes.len));
+
+        for (const uint8_t *ptr = bytes.begin(); ptr < bytes.end();) {
+            Print(stderr, "  [0x%1 %2 %3]  ", FmtArg(ptr).Pad0(-16),
+                                              FmtArg((ptr - bytes.begin()) / sizeof(void *)).Pad(-4),
+                                              FmtArg(ptr - bytes.begin()).Pad(-4));
+            for (int i = 0; ptr < bytes.end() && i < (int)sizeof(void *); i++, ptr++) {
+                Print(stderr, " %1", FmtHex(*ptr).Pad0(-2));
+            }
+            PrintLn(stderr);
+        }
+    }
+}
+
+void CallData::DumpDebug() const
+{
+    PrintLn(stderr, "%!..+---- %1 (%2) ----%!0", func->name, CallConventionNames[(int)func->convention]);
+
+    if (func->parameters.len) {
+        PrintLn(stderr, "Parameters:");
+        for (Size i = 0; i < func->parameters.len; i++) {
+            const ParameterInfo &param = func->parameters[i];
+            PrintLn(stderr, "  %1 = %2 (%3)", i, param.type->name, FmtMemSize(param.type->size));
+        }
+    }
+    PrintLn(stderr, "Return: %1 (%2)", func->ret.type->name, FmtMemSize(func->ret.type->size));
+
+    DumpMemory("Stack", stack);
+    DumpMemory("Heap", heap);
+}
+
 }

package/src/call.hh

@@ -24,38 +24,61 @@ namespace RG {
 bool AnalyseFunction(InstanceData *instance, FunctionInfo *func);
 
 class CallData {
+    struct OutObject {
+        Napi::ObjectReference ref;
+        const uint8_t *ptr;
+        const TypeInfo *type;
+    };
+
     Napi::Env env;
     InstanceData *instance;
     const FunctionInfo *func;
 
-    Span<uint8_t> *stack_mem;
-    Span<uint8_t> *heap_mem;
-    BlockAllocator big_alloc;
+    bool debug;
 
+    InstanceMemory *mem;
     Span<uint8_t> old_stack_mem;
     Span<uint8_t> old_heap_mem;
 
+    LocalArray<OutObject, MaxOutParameters> out_objects;
+
+    Span<uint8_t> heap;
+    Span<uint8_t> stack;
+
+    union {
+        uint32_t u32;
+        uint64_t u64;
+        float f;
+        double d;
+        void *ptr;
+        uint8_t buf[32];
+    } result;
+    uint8_t *return_ptr = nullptr;
+
 public:
-    CallData(Napi::Env env, InstanceData *instance, const FunctionInfo *func);
+    CallData(Napi::Env env, const FunctionInfo *func, InstanceMemory *mem, bool debug);
     ~CallData();
 
-    Span<uint8_t> GetStack() const
-    {
-        uint8_t *sp = stack_mem->end();
-        Size len = old_stack_mem.end() - sp;
-
-        return MakeSpan(sp, len);
-    }
-    uint8_t *GetSP() const { return stack_mem->end(); };
+    bool Prepare(const Napi::CallbackInfo &info);
+    void Execute();
+    Napi::Value Complete();
 
-    Span<uint8_t> GetHeap() const
+    Napi::Value Run(const Napi::CallbackInfo &info)
     {
-        uint8_t *ptr = old_heap_mem.ptr;
-        Size len = heap_mem->ptr - ptr;
+        if (!RG_UNLIKELY(Prepare(info)))
+            return env.Null();
+
+        if (debug) {
+            DumpDebug();
+        }
+        Execute();
 
-        return MakeSpan(ptr, len);
+        return Complete();
     }
 
+    void DumpDebug() const;
+
+private:
     template <typename T = void>
     bool AllocStack(Size size, Size align, T **out_ptr = nullptr);
     template <typename T = void>
@@ -65,27 +88,26 @@ public:
     const char16_t *PushString16(const Napi::Value &value);
     bool PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t *dest);
 
-    void DumpDebug() const;
-
-    Napi::Value Execute(const Napi::CallbackInfo &info);
+    void PopObject(Napi::Object obj, const uint8_t *ptr, const TypeInfo *type);
+    Napi::Object PopObject(const uint8_t *ptr, const TypeInfo *type);
 };
 
 template <typename T>
 bool CallData::AllocStack(Size size, Size align, T **out_ptr)
 {
-    uint8_t *ptr = AlignDown(stack_mem->end() - size, align);
-    Size delta = stack_mem->end() - ptr;
+    uint8_t *ptr = AlignDown(mem->stack.end() - size, align);
+    Size delta = mem->stack.end() - ptr;
 
-    if (RG_UNLIKELY(stack_mem->len < delta)) {
+    if (RG_UNLIKELY(mem->stack.len < delta)) {
         ThrowError<Napi::Error>(env, "FFI call is taking up too much memory");
         return false;
     }
 
-    if (instance->debug) {
+    if (debug) {
         memset(ptr, 0, delta);
     }
 
-    stack_mem->len -= delta;
+    mem->stack.len -= delta;
 
     if (out_ptr) {
         *out_ptr = (T *)ptr;
@@ -96,20 +118,20 @@ bool CallData::AllocStack(Size size, Size align, T **out_ptr)
 template <typename T>
 bool CallData::AllocHeap(Size size, Size align, T **out_ptr)
 {
-    uint8_t *ptr = AlignUp(heap_mem->ptr, align);
-    Size delta = size + (ptr - heap_mem->ptr);
+    uint8_t *ptr = AlignUp(mem->heap.ptr, align);
+    Size delta = size + (ptr - mem->heap.ptr);
 
-    if (RG_UNLIKELY(delta > heap_mem->len)) {
+    if (RG_UNLIKELY(delta > mem->heap.len)) {
         ThrowError<Napi::Error>(env, "FFI call is taking up too much memory");
         return false;
     }
 
-    if (instance->debug) {
-        memset(heap_mem->ptr, 0, (size_t)delta);
+    if (debug) {
+        memset(mem->heap.ptr, 0, (size_t)delta);
     }
 
-    heap_mem->ptr += delta;
-    heap_mem->len -= delta;
+    mem->heap.ptr += delta;
+    mem->heap.len -= delta;
 
     if (out_ptr) {
         *out_ptr = (T *)ptr;

package/src/ffi.cc

@@ -241,14 +241,57 @@ static Napi::Value MarkInOut(const Napi::CallbackInfo &info)
     return EncodePointerDirection(info, 3);
 }
 
+static Span<uint8_t> AllocateAndAlign16(Allocator *alloc, Size size)
+{
+    RG_ASSERT(AlignLen(size, 16) == size);
+    RG_ASSERT(size >= Kibibytes(1));
+
+    // Account for allocator overhead
+    size -= 256;
+
+    uint8_t *ptr = (uint8_t *)Allocator::Allocate(alloc, size);
+    uint8_t *aligned = AlignUp(ptr, 16);
+    Size delta = AlignLen(aligned - ptr, 16);
+
+    return MakeSpan(aligned, size - delta);
+}
+
+static InstanceMemory *AllocateCallMemory(InstanceData *instance)
+{
+    for (InstanceMemory *mem: instance->memories) {
+        if (!mem->depth)
+            return mem;
+    }
+
+    InstanceMemory *mem = new InstanceMemory();
+
+    mem->stack = AllocateAndAlign16(&mem->mem_alloc, Mebibytes(1));
+    mem->heap = AllocateAndAlign16(&mem->mem_alloc, Mebibytes(2));
+
+    if (instance->memories.Available()) {
+        instance->memories.Append(mem);
+    } else {
+        mem->temporary = true;
+    }
+
+    return mem;
+}
+
 static Napi::Value TranslateNormalCall(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
     FunctionInfo *func = (FunctionInfo *)info.Data();
 
-    CallData call(env, instance, func);
-    return call.Execute(info);
+    if (info.Length() < (uint32_t)func->parameters.len) {
+        ThrowError<Napi::TypeError>(env, "Expected %1 arguments, got %2", func->parameters.len, info.Length());
+        return env.Null();
+    }
+
+    InstanceMemory *mem = AllocateCallMemory(instance);
+    CallData call(env, func, mem, instance->debug);
+
+    return call.Run(info);
 }
 
 static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
@@ -266,6 +309,10 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
         func.parameters.Leak();
     };
 
+    if (info.Length() < (uint32_t)func.parameters.len) {
+        ThrowError<Napi::TypeError>(env, "Expected %1 arguments or more, got %2", func.parameters.len, info.Length());
+        return env.Null();
+    }
     if ((info.Length() - func.parameters.len) % 2) {
         ThrowError<Napi::Error>(env, "Missing value argument for variadic call");
         return env.Null();
@@ -300,8 +347,91 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
     if (!AnalyseFunction(instance, &func))
         return env.Null();
 
-    CallData call(env, instance, &func);
-    return call.Execute(info);
+    InstanceMemory *mem = AllocateCallMemory(instance);
+    CallData call(env, &func, mem, instance->debug);
+
+    return call.Run(info);
+}
+
+class AsyncCall: public Napi::AsyncWorker {
+    Napi::Env env;
+    const FunctionInfo *func;
+
+    CallData call;
+    bool prepared = false;
+
+public:
+    AsyncCall(Napi::Env env, InstanceMemory *mem, FunctionInfo *func, bool debug,
+              Napi::Function &callback)
+        : Napi::AsyncWorker(callback), env(env), func(func->Ref()),
+          call(env, func, mem, debug) {}
+    ~AsyncCall() { func->Unref(); }
+
+    bool Prepare(const Napi::CallbackInfo &info) {
+        prepared = call.Prepare(info);
+
+        if (!prepared) {
+            Napi::Error err = env.GetAndClearPendingException();
+            SetError(err.Message());
+        }
+
+        return prepared;
+    }
+    void DumpDebug() { call.DumpDebug(); }
+
+    void Execute() override;
+    void OnOK() override;
+};
+
+void AsyncCall::Execute()
+{
+    if (prepared) {
+        call.Execute();
+    }
+}
+
+void AsyncCall::OnOK()
+{
+    RG_ASSERT(prepared);
+
+    Napi::FunctionReference &callback = Callback();
+
+    Napi::Value self = env.Null();
+    napi_value args[] = {
+        env.Null(),
+        call.Complete()
+    };
+
+    callback.Call(self, RG_LEN(args), args);
+}
+
+static Napi::Value TranslateAsyncCall(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    FunctionInfo *func = (FunctionInfo *)info.Data();
+
+    if (info.Length() <= (uint32_t)func->parameters.len) {
+        ThrowError<Napi::TypeError>(env, "Expected %1 arguments, got %2", func->parameters.len + 1, info.Length());
+        return env.Null();
+    }
+
+    Napi::Function callback = info[(uint32_t)func->parameters.len].As<Napi::Function>();
+
+    if (!callback.IsFunction()) {
+        ThrowError<Napi::TypeError>(env, "Expected callback function as last arguments, got %1", GetValueType(instance, callback));
+        return env.Null();
+    }
+
+    InstanceMemory *mem = AllocateCallMemory(instance);
+    AsyncCall *async = new AsyncCall(env, mem, func, instance->debug, callback);
+
+    if (async->Prepare(info) && instance->debug) {
+        async->DumpDebug();
+    }
+    async->Queue();
+
+    return env.Null();
 }
 
 static bool ParseClassicFunction(Napi::Env env, Napi::String name, Napi::Value ret,
@@ -377,7 +507,7 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConve
     LibraryHolder *lib = (LibraryHolder *)info.Data();
 
     FunctionInfo *func = new FunctionInfo();
-    RG_DEFER_N(func_guard) { delete func; };
+    RG_DEFER { func->Unref(); };
 
     func->lib = lib->Ref();
     func->convention = convention;
@@ -436,9 +566,14 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConve
     }
 
     Napi::Function::Callback call = func->variadic ? TranslateVariadicCall : TranslateNormalCall;
-    Napi::Function wrapper = Napi::Function::New(env, call, func->name, (void *)func);
-    wrapper.AddFinalizer([](Napi::Env, FunctionInfo *func) { delete func; }, func);
-    func_guard.Disable();
+    Napi::Function wrapper = Napi::Function::New(env, call, func->name, (void *)func->Ref());
+    wrapper.AddFinalizer([](Napi::Env, FunctionInfo *func) { func->Unref(); }, func);
+
+    if (!func->variadic) {
+        Napi::Function async = Napi::Function::New(env, TranslateAsyncCall, func->name, (void *)func->Ref());
+        async.AddFinalizer([](Napi::Env, FunctionInfo *func) { func->Unref(); }, func);
+        wrapper.Set("async", async);
+    }
 
     return wrapper;
 }
@@ -531,13 +666,13 @@ LibraryHolder::~LibraryHolder()
 #endif
 }
 
-LibraryHolder *LibraryHolder::Ref()
+const LibraryHolder *LibraryHolder::Ref() const
 {
     refcount++;
     return this;
 }
 
-void LibraryHolder::Unref()
+void LibraryHolder::Unref() const
 {
     if (!--refcount) {
         delete this;
@@ -637,21 +772,30 @@ FunctionInfo::~FunctionInfo()
     }
 }
 
-static Span<uint8_t> AllocateAndAlign16(Allocator *alloc, Size size)
+const FunctionInfo *FunctionInfo::Ref() const
 {
-    RG_ASSERT(AlignLen(size, 16) == size);
-
-    uint8_t *ptr = (uint8_t *)Allocator::Allocate(alloc, size);
-    uint8_t *aligned = AlignUp(ptr, 16);
-    Size delta = AlignLen(aligned - ptr, 16);
+    refcount++;
+    return this;
+}
 
-    return MakeSpan(aligned, size - delta);
+void FunctionInfo::Unref() const
+{
+    if (!--refcount) {
+        delete this;
+    }
 }
 
 InstanceData::InstanceData()
 {
-    stack_mem = AllocateAndAlign16(&mem_alloc, Mebibytes(2));
-    heap_mem = AllocateAndAlign16(&mem_alloc, Mebibytes(4));
+    AllocateCallMemory(this);
+    RG_ASSERT(memories.len == 1);
+}
+
+InstanceData::~InstanceData()
+{
+    for (InstanceMemory *mem: memories) {
+        delete mem;
+    }
 }
 
 template <typename Func>