koffi 0.9.4 → 0.9.7

package/src/call_x64_win.cc

@@ -35,7 +35,7 @@ static inline bool IsRegular(Size size)
     return regular;
 }
 
-bool AnalyseFunction(FunctionInfo *func)
+bool AnalyseFunction(InstanceData *, FunctionInfo *func)
 {
     func->ret.regular = IsRegular(func->ret.type->size);
 
@@ -46,6 +46,8 @@ bool AnalyseFunction(FunctionInfo *func)
                              param.type->primitive == PrimitiveKind::Float64);
     }
 
+    func->args_size = AlignLen(8 * std::max((Size)4, func->parameters.len + !func->ret.regular), 16);
+
     return true;
 }
 
@@ -53,11 +55,9 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
-
     FunctionInfo *func = (FunctionInfo *)info.Data();
-    LibraryData *lib = func->lib.get();
 
-    RG_DEFER { lib->tmp_alloc.ReleaseAll(); };
+    CallData call(env, instance, func);
 
     // Sanity checks
     if (info.Length() < (uint32_t)func->parameters.len) {
@@ -65,28 +65,20 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    // Stack pointer and register
-    uint8_t *top_ptr = lib->stack.end();
-    uint8_t *scratch_ptr = top_ptr - func->scratch_size;
     uint8_t *return_ptr = nullptr;
-    uint8_t *args_ptr = nullptr;
-
-    // Reserve space for return value if needed
-    if (func->ret.regular) {
-        args_ptr = scratch_ptr - AlignLen(8 * std::max((Size)4, func->parameters.len), 16);
-    } else {
-        return_ptr = scratch_ptr - AlignLen(func->ret.type->size, 16);
+    uint64_t *args_ptr = nullptr;
 
-        args_ptr = return_ptr - AlignLen(8 * std::max((Size)4, func->parameters.len + 1), 16);
-        *(uint64_t *)args_ptr = (uint64_t)return_ptr;
+    // Pass return value in register or through memory
+    if (RG_UNLIKELY(!call.AllocStack(func->args_size, 16, &args_ptr)))
+        return env.Null();
+    if (!func->ret.regular) {
+        if (RG_UNLIKELY(!call.AllocHeap(func->ret.type->size, 16, &return_ptr)))
+            return env.Null();
+        *(uint8_t **)(args_ptr++) = return_ptr;
     }
 
-    RG_ASSERT(AlignUp(lib->stack.ptr, 16) == lib->stack.ptr);
-    RG_ASSERT(AlignUp(lib->stack.end(), 16) == lib->stack.end());
-    RG_ASSERT(AlignUp(args_ptr, 16) == args_ptr);
-
     // Push arguments
-    for (Size i = 0, j = return_ptr ? 8 : 0; i < func->parameters.len; i++, j += 8) {
+    for (Size i = 0; i < func->parameters.len; i++) {
         const ParameterInfo &param = func->parameters[i];
         Napi::Value value = info[i];
 
@@ -100,7 +92,8 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                 }
 
                 bool b = value.As<Napi::Boolean>();
-                *(bool *)(args_ptr + j) = b;
+
+                *(bool *)(args_ptr++) = b;
             } break;
             case PrimitiveKind::Int8:
             case PrimitiveKind::UInt8:
@@ -115,8 +108,8 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                     return env.Null();
                 }
 
-                int64_t v = CopyNodeNumber<int64_t>(value);
-                *(uint64_t *)(args_ptr + j) = (uint64_t)v;
+                int64_t v = CopyNumber<int64_t>(value);
+                *(args_ptr++) = (uint64_t)v;
             } break;
             case PrimitiveKind::Float32: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
@@ -124,8 +117,8 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                     return env.Null();
                 }
 
-                float f = CopyNodeNumber<float>(value);
-                *(float *)(args_ptr + j) = f;
+                float f = CopyNumber<float>(value);
+                *(float *)(args_ptr++) = f;
             } break;
             case PrimitiveKind::Float64: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
@@ -133,8 +126,8 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                     return env.Null();
                 }
 
-                double d = CopyNodeNumber<double>(value);
-                *(double *)(args_ptr + j) = d;
+                double d = CopyNumber<double>(value);
+                *(double *)(args_ptr++) = d;
             } break;
             case PrimitiveKind::String: {
                 if (RG_UNLIKELY(!value.IsString())) {
@@ -142,9 +135,12 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                     return env.Null();
                 }
 
-                const char *str = CopyNodeString(value, &lib->tmp_alloc);
-                *(const char **)(args_ptr + j) = str;
+                const char *str = call.PushString(value);
+                if (RG_UNLIKELY(!str))
+                    return env.Null();
+                *(const char **)(args_ptr++) = str;
             } break;
+
             case PrimitiveKind::Pointer: {
                 if (RG_UNLIKELY(!CheckValueTag(instance, value, param.type))) {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected %3", GetValueType(instance, value), i + 1, param.type->name);
@@ -152,7 +148,7 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                 }
 
                 void *ptr = value.As<Napi::External<void>>();
-                *(void **)(args_ptr + j) = ptr;
+                *(void **)(args_ptr++) = ptr;
             } break;
 
             case PrimitiveKind::Record: {
@@ -163,26 +159,27 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
 
                 uint8_t *ptr;
                 if (param.regular) {
-                    ptr = (uint8_t *)(args_ptr + j);
+                    ptr = (uint8_t *)(args_ptr++);
                 } else {
-                    ptr = scratch_ptr;
-                    *(uint8_t **)(args_ptr + j) = ptr;
-
-                    scratch_ptr = AlignUp(scratch_ptr + param.type->size, 16);
+                    if (RG_UNLIKELY(!call.AllocHeap(param.type->size, 16, &ptr)))
+                        return env.Null();
+                    *(uint8_t **)(args_ptr++) = ptr;
                 }
 
                 Napi::Object obj = value.As<Napi::Object>();
-                if (!PushObject(obj, param.type, &lib->tmp_alloc, ptr))
+                if (!call.PushObject(obj, param.type, ptr))
                     return env.Null();
             } break;
         }
     }
 
-    // DumpStack(func, MakeSpan(args_ptr, top_ptr - args_ptr));
+    if (instance->debug) {
+        call.DumpDebug();
+    }
 
 #define PERFORM_CALL(Suffix) \
-        (func->forward_fp ? ForwardCallX ## Suffix(func->func, args_ptr) \
-                          : ForwardCall ## Suffix(func->func, args_ptr))
+        (func->forward_fp ? ForwardCallX ## Suffix(func->func, call.GetSP()) \
+                          : ForwardCall ## Suffix(func->func, call.GetSP()))
 
     // Execute and convert return value
     switch (func->ret.type->primitive) {

package/src/call_x86.cc

@@ -26,19 +26,8 @@ extern "C" uint64_t ForwardCallG(const void *func, uint8_t *sp);
 extern "C" float ForwardCallF(const void *func, uint8_t *sp);
 extern "C" double ForwardCallD(const void *func, uint8_t *sp);
 
-bool AnalyseFunction(FunctionInfo *func)
+bool AnalyseFunction(InstanceData *instance, FunctionInfo *func)
 {
-#ifdef _WIN32
-    if (func->convention == CallConvention::Stdcall) {
-        Size total = 0;
-        for (const ParameterInfo &param: func->parameters) {
-            total += param.type->size;
-        }
-
-        func->decorated_name = Fmt(&func->lib->str_alloc, "_%1@%2", func->name, total).ptr;
-    }
-#endif
-
     if (IsIntegral(func->ret.type->primitive)) {
         func->ret.trivial = true;
     } else if (func->ret.type->members.len == 1 && IsIntegral(func->ret.type->members[0].type->primitive)) {
@@ -50,6 +39,18 @@ bool AnalyseFunction(FunctionInfo *func)
 #endif
     }
 
+    Size params_size = 0;
+    for (const ParameterInfo &param: func->parameters) {
+        params_size += std::max((int16_t)4, param.type->size);
+    }
+    func->args_size = params_size + 4 * !func->ret.trivial;
+
+#ifdef _WIN32
+    if (func->convention == CallConvention::Stdcall) {
+        func->decorated_name = Fmt(&instance->str_alloc, "_%1@%2", func->name, params_size).ptr;
+    }
+#endif
+
     return true;
 }
 
@@ -57,11 +58,9 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
-
     FunctionInfo *func = (FunctionInfo *)info.Data();
-    LibraryData *lib = func->lib.get();
 
-    RG_DEFER { lib->tmp_alloc.ReleaseAll(); };
+    CallData call(env, instance, func);
 
     // Sanity checks
     if (info.Length() < (uint32_t)func->parameters.len) {
@@ -69,28 +68,17 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    // Stack pointer and register
-    uint8_t *top_ptr = lib->stack.end();
     uint8_t *return_ptr = nullptr;
-    uint8_t *args_ptr = nullptr;
-    uint8_t *sp_ptr = nullptr;
-
-    // Reserve space for return value if needed
-    if (func->ret.trivial) {
-        args_ptr = top_ptr - func->scratch_size;
-        sp_ptr = args_ptr;
-    } else {
-        return_ptr = top_ptr - AlignLen(func->ret.type->size, 16);
-        args_ptr = return_ptr - func->scratch_size;
-        sp_ptr = args_ptr;
-
-        *(uint32_t *)args_ptr = (uint32_t)return_ptr;
-        args_ptr += 4;
-    }
+    uint32_t *args_ptr = nullptr;
 
-    RG_ASSERT(AlignUp(lib->stack.ptr, 16) == lib->stack.ptr);
-    RG_ASSERT(AlignUp(lib->stack.end(), 16) == lib->stack.end());
-    RG_ASSERT(AlignUp(args_ptr, 16) == args_ptr);
+    // Pass return value in register or through memory
+    if (RG_UNLIKELY(!call.AllocStack(func->args_size, 16, &args_ptr)))
+        return env.Null();
+    if (!func->ret.trivial) {
+        if (RG_UNLIKELY(!call.AllocHeap(func->ret.type->size, 16, &return_ptr)))
+            return env.Null();
+        *(args_ptr++) = (uint32_t)return_ptr;
+    }
 
     // Push arguments
     for (Size i = 0; i < func->parameters.len; i++) {
@@ -107,8 +95,7 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                 }
 
                 bool b = value.As<Napi::Boolean>();
-                *(bool *)args_ptr = b;
-                args_ptr += 4;
+                *(bool *)(args_ptr++) = b;
             } break;
             case PrimitiveKind::Int8:
             case PrimitiveKind::UInt8:
@@ -121,9 +108,8 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                     return env.Null();
                 }
 
-                int32_t v = CopyNodeNumber<int32_t>(value);
-                *(uint32_t *)args_ptr = (uint32_t)v;
-                args_ptr += 4;
+                int32_t v = CopyNumber<int32_t>(value);
+                *(args_ptr++) = (uint32_t)v;
             } break;
             case PrimitiveKind::Int64:
             case PrimitiveKind::UInt64: {
@@ -132,9 +118,9 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                     return env.Null();
                 }
 
-                int64_t v = CopyNodeNumber<int64_t>(value);
+                int64_t v = CopyNumber<int64_t>(value);
                 *(uint64_t *)args_ptr = (uint64_t)v;
-                args_ptr += 8;
+                args_ptr += 2;
             } break;
             case PrimitiveKind::Float32: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
@@ -142,9 +128,8 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                     return env.Null();
                 }
 
-                float f = CopyNodeNumber<float>(value);
-                *(float *)args_ptr = f;
-                args_ptr += 4;
+                float f = CopyNumber<float>(value);
+                *(float *)(args_ptr++) = f;
             } break;
             case PrimitiveKind::Float64: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
@@ -152,9 +137,9 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                     return env.Null();
                 }
 
-                double d = CopyNodeNumber<double>(value);
+                double d = CopyNumber<double>(value);
                 *(double *)args_ptr = d;
-                args_ptr += 8;
+                args_ptr += 2;
             } break;
             case PrimitiveKind::String: {
                 if (RG_UNLIKELY(!value.IsString())) {
@@ -162,9 +147,10 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                     return env.Null();
                 }
 
-                const char *str = CopyNodeString(value, &lib->tmp_alloc);
-                *(const char **)args_ptr = str;
-                args_ptr += 4;
+                const char *str = call.PushString(value);
+                if (RG_UNLIKELY(!str))
+                    return env.Null();
+                *(const char **)(args_ptr++) = str;
             } break;
             case PrimitiveKind::Pointer: {
                 if (RG_UNLIKELY(!CheckValueTag(instance, value, param.type))) {
@@ -173,8 +159,7 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                 }
 
                 void *ptr = value.As<Napi::External<void>>();
-                *(void **)args_ptr = ptr;
-                args_ptr += 4;
+                *(void **)(args_ptr++) = ptr;
             } break;
 
             case PrimitiveKind::Record: {
@@ -185,26 +170,28 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
 
                 Napi::Object obj = value.As<Napi::Object>();
 
-                args_ptr = AlignUp(args_ptr, param.type->align);
-                if (!PushObject(obj, param.type, &lib->tmp_alloc, args_ptr))
+                uint8_t *ptr = (uint8_t *)AlignUp(args_ptr, param.type->align);
+                if (!call.PushObject(obj, param.type, ptr))
                     return env.Null();
-                args_ptr += param.type->size;
+                args_ptr = (uint32_t *)AlignUp(ptr + param.type->size, 4);
             } break;
         }
     }
 
-    // DumpStack(func, MakeSpan(sp_ptr, top_ptr - sp_ptr));
+    if (instance->debug) {
+        call.DumpDebug();
+    }
 
     // Execute and convert return value
     switch (func->ret.type->primitive) {
         case PrimitiveKind::Float32: {
-            float f = ForwardCallF(func->func, sp_ptr);
+            float f = ForwardCallF(func->func, call.GetSP());
 
             return Napi::Number::New(env, (double)f);
         } break;
 
         case PrimitiveKind::Float64: {
-            double d = ForwardCallD(func->func, sp_ptr);
+            double d = ForwardCallD(func->func, call.GetSP());
 
             return Napi::Number::New(env, d);
         } break;
@@ -212,7 +199,7 @@ Napi::Value TranslateCall(const Napi::CallbackInfo &info)
         default: {
             // We can't directly use the struct as a return value, because not all platforms
             // treat it the same: it is trivial only on Windows (see AnalyseFunction).
-            uint64_t raw = ForwardCallG(func->func, sp_ptr);
+            uint64_t raw = ForwardCallG(func->func, call.GetSP());
             struct {
                 uint32_t rax;
                 uint32_t rdx;

package/src/ffi.cc

@@ -157,6 +157,8 @@ static Napi::Value CreatePointerType(const Napi::CallbackInfo &info)
         type->size = sizeof(void *);
         type->align = sizeof(void *);
         type->ref = ref;
+
+        instance->types_map.Set(type);
     }
 
     Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, type);
@@ -183,30 +185,27 @@ static Napi::Value LoadSharedLibrary(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    std::shared_ptr<LibraryData> lib = std::make_shared<LibraryData>();
-
-    Napi::Object obj = Napi::Object::New(env);
-
     // Load shared library
+    void *module = nullptr;
 #ifdef _WIN32
     if (info[0].IsString()) {
         std::u16string filename = info[0].As<Napi::String>();
-        lib->module = LoadLibraryW((LPCWSTR)filename.c_str());
+        module = LoadLibraryW((LPCWSTR)filename.c_str());
 
-        if (!lib->module) {
+        if (!module) {
             ThrowError<Napi::Error>(env, "Failed to load shared library: %1", GetWin32ErrorString());
             return env.Null();
         }
     } else {
-        lib->module = GetModuleHandle(nullptr);
-        RG_ASSERT(lib->module);
+        module = GetModuleHandle(nullptr);
+        RG_ASSERT(module);
     }
 #else
     if (info[0].IsString()) {
         std::string filename = info[0].As<Napi::String>();
-        lib->module = dlopen(filename.c_str(), RTLD_NOW);
+        module = dlopen(filename.c_str(), RTLD_NOW);
 
-        if (!lib->module) {
+        if (!module) {
             const char *msg = dlerror();
 
             if (StartsWith(msg, filename.c_str())) {
@@ -220,13 +219,14 @@ static Napi::Value LoadSharedLibrary(const Napi::CallbackInfo &info)
             return env.Null();
         }
     } else {
-        lib->module = RTLD_DEFAULT;
+        module = RTLD_DEFAULT;
     }
 #endif
 
+    std::shared_ptr<LibraryHolder> lib = std::make_shared<LibraryHolder>(module);
+    Napi::Object obj = Napi::Object::New(env);
     Napi::Object functions = info[1].As<Napi::Array>();
     Napi::Array keys = functions.GetPropertyNames();
-    Size extra_size = 0;
 
     for (uint32_t i = 0; i < keys.Length(); i++) {
         FunctionInfo *func = new FunctionInfo();
@@ -235,7 +235,7 @@ static Napi::Value LoadSharedLibrary(const Napi::CallbackInfo &info)
         std::string key = ((Napi::Value)keys[i]).As<Napi::String>();
         Napi::Array value = ((Napi::Value)functions[key]).As<Napi::Array>();
 
-        func->name = DuplicateString(key.c_str(), &lib->str_alloc).ptr;
+        func->name = DuplicateString(key.c_str(), &instance->str_alloc).ptr;
         func->decorated_name = func->name;
         func->lib = lib;
 
@@ -280,7 +280,6 @@ static Napi::Value LoadSharedLibrary(const Napi::CallbackInfo &info)
         func->ret.type = ResolveType(instance, value[0u]);
         if (!func->ret.type)
             return env.Null();
-        func->scratch_size = AlignLen(func->ret.type->size, 16);
 
         for (uint32_t j = 0; j < parameters.Length(); j++) {
             ParameterInfo param = {};
@@ -293,22 +292,15 @@ static Napi::Value LoadSharedLibrary(const Napi::CallbackInfo &info)
                 return env.Null();
             }
             func->parameters.Append(param);
-
-            func->scratch_size += AlignLen(param.type->size, 16);
         }
 
-        // That's enough extra space for pretty much every ABI supported, with 16 bytes of
-        // bonus for each in case we need to put pointers and exta-align them.
-        extra_size = std::max(extra_size, func->scratch_size +
-                                          AlignLen(8 * (func->parameters.len + 1), 16));
-
-        if (!AnalyseFunction(func))
+        if (!AnalyseFunction(instance, func))
             return env.Null();
 
 #ifdef _WIN32
-        func->func = (void *)GetProcAddress((HMODULE)lib->module, func->decorated_name);
+        func->func = (void *)GetProcAddress((HMODULE)module, func->decorated_name);
 #else
-        func->func = dlsym(lib->module, func->decorated_name);
+        func->func = dlsym(module, func->decorated_name);
 #endif
         if (!func->func) {
             ThrowError<Napi::Error>(env, "Cannot find function '%1' in shared library", key.c_str());
@@ -322,12 +314,10 @@ static Napi::Value LoadSharedLibrary(const Napi::CallbackInfo &info)
         obj.Set(key, wrapper);
     }
 
-    lib->stack.AppendDefault(Mebibytes(1) + extra_size);
-
     return obj;
 }
 
-LibraryData::~LibraryData()
+LibraryHolder::~LibraryHolder()
 {
 #ifdef _WIN32
     if (module && module != GetModuleHandle(nullptr)) {
@@ -405,6 +395,7 @@ static Napi::Object InitBaseTypes(Napi::Env env)
     RegisterPrimitiveType(instance, "float", PrimitiveKind::Float32, 4);
     RegisterPrimitiveType(instance, "double", PrimitiveKind::Float64, 8);
     RegisterPrimitiveType(instance, "string", PrimitiveKind::String, sizeof(void *));
+    RegisterPrimitiveType(instance, "str", PrimitiveKind::String, sizeof(void *));
 
     Napi::Object types = Napi::Object::New(env);
     for (TypeInfo &type: instance->types) {
@@ -427,6 +418,15 @@ static Napi::Object InitBaseTypes(Napi::Env env)
     return types;
 }
 
+InstanceData::InstanceData()
+{
+    stack_mem.len = Mebibytes(2);
+    stack_mem.ptr = (uint8_t *)Allocator::Allocate(&mem_alloc, stack_mem.len);
+
+    heap_mem.len = Mebibytes(4);
+    heap_mem.ptr = (uint8_t *)Allocator::Allocate(&mem_alloc, heap_mem.len);
+}
+
 }
 
 #if NODE_WANT_INTERNALS
@@ -462,6 +462,7 @@ static void InitInternal(v8::Local<v8::Object> target, v8::Local<v8::Value>,
     InstanceData *instance = new InstanceData();
     env_cxx.SetInstanceData(instance);
 
+    instance->debug = GetDebugFlag("DUMP_CALLS");
     FillRandomSafe(&instance->tag_lower, RG_SIZE(instance->tag_lower));
 
     SetValue(env, target, "struct", Napi::Function::New(env_napi, CreateStructType));
@@ -482,6 +483,7 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
     InstanceData *instance = new InstanceData();
     env.SetInstanceData(instance);
 
+    instance->debug = GetDebugFlag("DUMP_CALLS");
     FillRandomSafe(&instance->tag_lower, RG_SIZE(instance->tag_lower));
 
     exports.Set("struct", Napi::Function::New(env, CreateStructType));

package/src/ffi.hh

@@ -34,6 +34,7 @@ enum class PrimitiveKind {
     Float32,
     Float64,
     String,
+
     Pointer,
 
     Record
@@ -67,16 +68,12 @@ struct RecordMember {
     const TypeInfo *type;
 };
 
-class LibraryData {
-public:
-    ~LibraryData();
-
+class LibraryHolder {
     void *module = nullptr; // HMODULE on Windows
 
-    BlockAllocator tmp_alloc;
-    HeapArray<uint8_t> stack;
-
-    BlockAllocator str_alloc;
+public:
+    LibraryHolder(void *module) : module(module) {}
+    ~LibraryHolder();
 };
 
 enum class CallConvention {
@@ -96,7 +93,8 @@ struct ParameterInfo {
     int8_t gpr_count;
     int8_t xmm_count;
     bool gpr_first;
-#elif defined(__aarch64__)
+#elif defined(__arm__) || defined(__aarch64__)
+    bool use_memory; // Only used for return value on ARM32
     int8_t gpr_count;
     int8_t vec_count;
 #elif defined(__i386__) || defined(_M_IX86)
@@ -107,29 +105,38 @@ struct ParameterInfo {
 struct FunctionInfo {
     const char *name;
     const char *decorated_name;
-    std::shared_ptr<LibraryData> lib;
+
+    std::shared_ptr<LibraryHolder> lib;
 
     void *func;
     CallConvention convention;
 
     ParameterInfo ret;
     HeapArray<ParameterInfo> parameters;
-    Size scratch_size; // Total size needed if all arguments were copied together (with align = 16)
 
     // ABI-specific part
 
-#if defined(__aarch64__) || defined(__x86_64__) || defined(_WIN64)
+    Size args_size;
+#if defined(__arm__) || defined(__aarch64__) || defined(__x86_64__) || defined(_WIN64)
     bool forward_fp;
 #endif
 };
 
 struct InstanceData {
+    InstanceData();
+
     BucketArray<TypeInfo> types;
     HashTable<const char *, TypeInfo *> types_map;
 
+    bool debug;
     uint64_t tag_lower;
 
     BlockAllocator str_alloc;
+
+    Span<uint8_t> stack_mem;
+    Span<uint8_t> heap_mem;
+
+    LinkedAllocator mem_alloc;
 };
 
 }