koffi 0.9.0

package/src/call_x86_fwd.asm

@@ -0,0 +1,50 @@
+; This program is free software: you can redistribute it and/or modify
+; it under the terms of the GNU Affero General Public License as published by
+; the Free Software Foundation, either version 3 of the License, or
+; (at your option) any later version.
+;
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU Affero General Public License for more details.
+;
+; You should have received a copy of the GNU Affero General Public License
+; along with this program. If not, see https://www.gnu.org/licenses/.
+
+public ForwardCallG
+public ForwardCallF
+public ForwardCallD
+
+.model flat, C
+.code
+
+; Copy function pointer to EAX, in order to save it through argument forwarding.
+; Save ESP in EBX (non-volatile), and use carefully assembled stack provided by caller.
+; Call native function.
+; Once done, restore normal stack pointer and return.
+; The return value is passed back untouched.
+forward macro
+    endbr32
+    push ebx
+    mov ebx, esp
+    mov eax, dword ptr [esp+8]
+    mov esp, dword ptr [esp+12]
+    call eax
+    mov esp, ebx
+    pop ebx
+    ret
+endm
+
+ForwardCallG proc
+    forward
+ForwardCallG endp
+
+ForwardCallF proc
+    forward
+ForwardCallF endp
+
+ForwardCallD proc
+    forward
+ForwardCallD endp
+
+end

package/src/ffi.cc

@@ -0,0 +1,504 @@
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see https://www.gnu.org/licenses/.
+
+#include "vendor/libcc/libcc.hh"
+#include "ffi.hh"
+#include "call.hh"
+#include "util.hh"
+
+#ifdef _WIN32
+    #ifndef NOMINMAX
+        #define NOMINMAX
+    #endif
+    #ifndef WIN32_LEAN_AND_MEAN
+        #define WIN32_LEAN_AND_MEAN
+    #endif
+    #include <windows.h>
+    #include <ntsecapi.h>
+#else
+    #include <dlfcn.h>
+    #include <unistd.h>
+#endif
+
+#include <napi.h>
+#if NODE_WANT_INTERNALS
+    #include <env-inl.h>
+    #include <js_native_api_v8.h>
+#endif
+
+namespace RG {
+
+// Value does not matter, the tag system uses memory addresses
+static const int TypeInfoMarker = 0xdeadbeef;
+
+static const TypeInfo *ResolveType(const InstanceData *instance, Napi::Value value)
+{
+    if (value.IsString()) {
+        std::string str = value.As<Napi::String>();
+
+        const TypeInfo *type = instance->types_map.FindValue(str.c_str(), nullptr);
+
+        if (!type) {
+            ThrowError<Napi::TypeError>(value.Env(), "Unknown type string '%1'", str.c_str());
+            return nullptr;
+        }
+
+        return type;
+    } else if (CheckValueTag(instance, value, &TypeInfoMarker)) {
+        Napi::External<TypeInfo> external = value.As<Napi::External<TypeInfo>>();
+
+        const TypeInfo *type = external.Data();
+        RG_ASSERT(type);
+
+        return type;
+    } else {
+        ThrowError<Napi::TypeError>(value.Env(), "Unexpected %1 value as type specifier, expected string or type", GetValueType(instance, value));
+        return nullptr;
+    }
+}
+
+static Napi::Value CreateStructType(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (info.Length() < 2) {
+        ThrowError<Napi::TypeError>(env, "Expected 2 arguments, got %1", info.Length());
+        return env.Null();
+    }
+    if (!info[0].IsString()) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string", GetValueType(instance, info[0]));
+        return env.Null();
+    }
+    if (!info[1].IsObject()) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for members, expected object", GetValueType(instance, info[1]));
+        return env.Null();
+    }
+
+    TypeInfo *type = instance->types.AppendDefault();
+    RG_DEFER_N(err_guard) { instance->types.RemoveLast(1); };
+
+    std::string name = info[0].As<Napi::String>();
+    Napi::Object obj = info[1].As<Napi::Object>();
+    Napi::Array keys = obj.GetPropertyNames();
+
+    type->name = DuplicateString(name.c_str(), &instance->str_alloc).ptr;
+
+    type->primitive = PrimitiveKind::Record;
+    type->align = 1;
+
+    for (uint32_t i = 0; i < keys.Length(); i++) {
+        RecordMember member = {};
+
+        std::string key = ((Napi::Value)keys[i]).As<Napi::String>();
+        Napi::Value value = obj[key];
+
+        member.name = DuplicateString(key.c_str(), &instance->str_alloc).ptr;
+        member.type = ResolveType(instance, value);
+        if (!member.type)
+            return env.Null();
+
+        type->size += member.type->size;
+        type->align = std::max(type->align, member.type->align);
+
+        type->members.Append(member);
+    }
+
+    type->size = (int16_t)AlignLen(type->size, type->align);
+
+    // If the insert succeeds, we cannot fail anymore
+    if (!instance->types_map.TrySet(type).second) {
+        ThrowError<Napi::Error>(env, "Duplicate type name '%1'", type->name);
+        return env.Null();
+    }
+    err_guard.Disable();
+
+    Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, type);
+    SetValueTag(instance, external, &TypeInfoMarker);
+
+    return external;
+}
+
+static Napi::Value CreatePointerType(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (info.Length() < 1) {
+        ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", info.Length());
+        return env.Null();
+    }
+
+    const TypeInfo *ref = ResolveType(instance, info[0]);
+    if (!ref)
+        return env.Null();
+
+    char name_buf[256];
+    Fmt(name_buf, "%1%2*", ref->name, ref->primitive == PrimitiveKind::Pointer ? "" : " ");
+
+    TypeInfo *type = instance->types_map.FindValue(name_buf, nullptr);
+
+    if (!type) {
+        type = instance->types.AppendDefault();
+
+        type->name = DuplicateString(name_buf, &instance->str_alloc).ptr;
+
+        type->primitive = PrimitiveKind::Pointer;
+        type->size = sizeof(void *);
+        type->align = sizeof(void *);
+        type->ref = ref;
+    }
+
+    Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, type);
+    SetValueTag(instance, external, &TypeInfoMarker);
+
+    return external;
+}
+
+static Napi::Value LoadSharedLibrary(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (info.Length() < 2) {
+        ThrowError<Napi::TypeError>(env, "Expected 2 arguments, not %1", info.Length());
+        return env.Null();
+    }
+    if (!info[0].IsString() && !info[0].IsNull()) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for filename, expected string or null", GetValueType(instance, info[0]));
+        return env.Null();
+    }
+    if (!info[1].IsObject()) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for functions, expected object", GetValueType(instance, info[1]));
+        return env.Null();
+    }
+
+    std::shared_ptr<LibraryData> lib = std::make_shared<LibraryData>();
+
+    Napi::Object obj = Napi::Object::New(env);
+
+    // Load shared library
+#ifdef _WIN32
+    if (info[0].IsString()) {
+        std::u16string filename = info[0].As<Napi::String>();
+        lib->module = LoadLibraryW((LPCWSTR)filename.c_str());
+
+        if (!lib->module) {
+            ThrowError<Napi::Error>(env, "Failed to load shared library: %1", GetWin32ErrorString());
+            return env.Null();
+        }
+    } else {
+        lib->module = GetModuleHandle(nullptr);
+        RG_ASSERT(lib->module);
+    }
+#else
+    if (info[0].IsString()) {
+        std::string filename = info[0].As<Napi::String>();
+        lib->module = dlopen(filename.c_str(), RTLD_NOW);
+
+        if (!lib->module) {
+            const char *msg = dlerror();
+
+            if (StartsWith(msg, filename.c_str())) {
+                msg += filename.length();
+            }
+            while (strchr(": ", msg[0])) {
+                msg++;
+            }
+
+            ThrowError<Napi::Error>(env, "Failed to load shared library: %1", msg);
+            return env.Null();
+        }
+    } else {
+        lib->module = RTLD_DEFAULT;
+    }
+#endif
+
+    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();
+        RG_DEFER_N(func_guard) { delete func; };
+
+        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->decorated_name = func->name;
+        func->lib = lib;
+
+        if (!value.IsArray()) {
+            ThrowError<Napi::TypeError>(env, "Unexpexted %1 value for signature of '%2', expected an array", GetValueType(instance, value), func->name);
+            return env.Null();
+        }
+        if (value.Length() < 2 || value.Length() > 3) {
+            ThrowError<Napi::TypeError>(env, "Unexpected array of length %1 for '%2', expected 2 or 3 elements", value.Length(), func->name);
+            return env.Null();
+        }
+
+        Napi::Array parameters;
+
+        if (((Napi::Value)value[1u]).IsString()) {
+            std::string conv = ((Napi::Value)value[1u]).As<Napi::String>();
+
+            if (conv == "cdecl" || conv == "__cdecl") {
+                func->convention = CallConvention::Default;
+            } else if (conv == "stdcall" || conv == "__stdcall") {
+                func->convention = CallConvention::Stdcall;
+            } else {
+                ThrowError<Napi::Error>(env, "Unknown calling convention '%1'", conv.c_str());
+                return env.Null();
+            }
+
+            if (!((Napi::Value)value[2u]).IsArray()) {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value for parameters of '%2', expected an array", GetValueType(instance, (Napi::Value)value[1u]), func->name);
+                return env.Null();
+            }
+
+            parameters = ((Napi::Value)value[2u]).As<Napi::Array>();
+        } else {
+            if (!((Napi::Value)value[1u]).IsArray()) {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value for parameters of '%2', expected an array", GetValueType(instance, (Napi::Value)value[1u]), func->name);
+                return env.Null();
+            }
+
+            parameters = ((Napi::Value)value[1u]).As<Napi::Array>();
+        }
+
+        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 = {};
+
+            param.type = ResolveType(instance, parameters[j]);
+            if (!param.type)
+                return env.Null();
+            if (param.type->primitive == PrimitiveKind::Void) {
+                ThrowError<Napi::TypeError>(env, "Type void cannot be used as a parameter");
+                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))
+            return env.Null();
+
+#ifdef _WIN32
+        func->func = (void *)GetProcAddress((HMODULE)lib->module, func->decorated_name);
+#else
+        func->func = dlsym(lib->module, func->decorated_name);
+#endif
+        if (!func->func) {
+            ThrowError<Napi::Error>(env, "Cannot find function '%1' in shared library", key.c_str());
+            return env.Null();
+        }
+
+        Napi::Function wrapper = Napi::Function::New(env, TranslateCall, key.c_str(), (void *)func);
+        wrapper.AddFinalizer([](Napi::Env, FunctionInfo *func) { delete func; }, func);
+        func_guard.Disable();
+
+        obj.Set(key, wrapper);
+    }
+
+    lib->stack.AppendDefault(Mebibytes(1) + extra_size);
+
+    return obj;
+}
+
+LibraryData::~LibraryData()
+{
+#ifdef _WIN32
+    if (module && module != GetModuleHandle(nullptr)) {
+        FreeLibrary((HMODULE)module);
+    }
+#else
+    if (module && module != RTLD_DEFAULT) {
+        dlclose(module);
+    }
+#endif
+}
+
+static void RegisterPrimitiveType(InstanceData *instance, const char *name, PrimitiveKind primitive, int16_t size)
+{
+    TypeInfo *type = instance->types.AppendDefault();
+
+    type->name = name;
+
+    type->primitive = primitive;
+    type->size = size;
+    type->align = size;
+
+    RG_ASSERT(!instance->types_map.Find(name));
+    instance->types_map.Set(type);
+}
+
+static Napi::Object InitBaseTypes(Napi::Env env)
+{
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    RG_ASSERT(!instance->types.len);
+
+    RegisterPrimitiveType(instance, "void", PrimitiveKind::Void, 0);
+    RegisterPrimitiveType(instance, "bool", PrimitiveKind::Bool, 1);
+    RegisterPrimitiveType(instance, "int8", PrimitiveKind::Int8, 1);
+    RegisterPrimitiveType(instance, "int8_t", PrimitiveKind::Int8, 1);
+    RegisterPrimitiveType(instance, "uint8", PrimitiveKind::UInt8, 1);
+    RegisterPrimitiveType(instance, "uint8_t", PrimitiveKind::UInt8, 1);
+    RegisterPrimitiveType(instance, "char", PrimitiveKind::Int8, 1);
+    RegisterPrimitiveType(instance, "uchar", PrimitiveKind::UInt8, 1);
+    RegisterPrimitiveType(instance, "unsigned char", PrimitiveKind::UInt8, 1);
+    RegisterPrimitiveType(instance, "int16", PrimitiveKind::Int16, 2);
+    RegisterPrimitiveType(instance, "int16_t", PrimitiveKind::Int16, 2);
+    RegisterPrimitiveType(instance, "uint16", PrimitiveKind::UInt16, 2);
+    RegisterPrimitiveType(instance, "uint16_t", PrimitiveKind::UInt16, 2);
+    RegisterPrimitiveType(instance, "short", PrimitiveKind::Int16, 2);
+    RegisterPrimitiveType(instance, "ushort", PrimitiveKind::UInt16, 2);
+    RegisterPrimitiveType(instance, "unsigned short", PrimitiveKind::UInt16, 2);
+    RegisterPrimitiveType(instance, "int32", PrimitiveKind::Int32, 4);
+    RegisterPrimitiveType(instance, "int32_t", PrimitiveKind::Int32, 4);
+    RegisterPrimitiveType(instance, "uint32", PrimitiveKind::UInt32, 4);
+    RegisterPrimitiveType(instance, "uint32_t", PrimitiveKind::UInt32, 4);
+    RegisterPrimitiveType(instance, "int", PrimitiveKind::Int32, 4);
+    RegisterPrimitiveType(instance, "uint", PrimitiveKind::UInt32, 4);
+    RegisterPrimitiveType(instance, "unsigned int", PrimitiveKind::UInt32, 4);
+    RegisterPrimitiveType(instance, "int64", PrimitiveKind::Int64, 8);
+    RegisterPrimitiveType(instance, "int64_t", PrimitiveKind::Int64, 8);
+    RegisterPrimitiveType(instance, "uint64", PrimitiveKind::UInt64, 8);
+    RegisterPrimitiveType(instance, "uint64_t", PrimitiveKind::UInt64, 8);
+#if ULONG_MAX == UINT64_MAX
+    RegisterPrimitiveType(instance, "long", PrimitiveKind::Int64, 8);
+    RegisterPrimitiveType(instance, "ulong", PrimitiveKind::UInt64, 8);
+    RegisterPrimitiveType(instance, "unsigned long", PrimitiveKind::UInt64, 8);
+#else
+    RegisterPrimitiveType(instance, "long", PrimitiveKind::Int32, 4);
+    RegisterPrimitiveType(instance, "ulong", PrimitiveKind::UInt32, 4);
+    RegisterPrimitiveType(instance, "unsigned long", PrimitiveKind::UInt64, 4);
+#endif
+    RegisterPrimitiveType(instance, "longlong", PrimitiveKind::Int64, 8);
+    RegisterPrimitiveType(instance, "long long", PrimitiveKind::Int64, 8);
+    RegisterPrimitiveType(instance, "ulonglong", PrimitiveKind::UInt64, 8);
+    RegisterPrimitiveType(instance, "unsigned long long", PrimitiveKind::UInt64, 8);
+    RegisterPrimitiveType(instance, "float32", PrimitiveKind::Float32, 4);
+    RegisterPrimitiveType(instance, "float64", PrimitiveKind::Float64, 8);
+    RegisterPrimitiveType(instance, "float", PrimitiveKind::Float32, 4);
+    RegisterPrimitiveType(instance, "double", PrimitiveKind::Float64, 8);
+    RegisterPrimitiveType(instance, "string", PrimitiveKind::String, sizeof(void *));
+
+    Napi::Object types = Napi::Object::New(env);
+    for (TypeInfo &type: instance->types) {
+        Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, &type);
+        SetValueTag(instance, external, &TypeInfoMarker);
+
+        types.Set(type.name, external);
+
+        if (strchr(type.name, ' ')) {
+            char name_buf[64] = {};
+            for (Size i = 0; type.name[i]; i++) {
+                RG_ASSERT(i < RG_SIZE(name_buf) - 1);
+                name_buf[i] = type.name[i] != ' ' ? type.name[i] : '_';
+            }
+            types.Set(name_buf, external);
+        }
+    }
+    types.Freeze();
+
+    return types;
+}
+
+}
+
+#if NODE_WANT_INTERNALS
+
+static void SetValue(node::Environment *env, v8::Local<v8::Object> target,
+                     const char *name, Napi::Value value)
+{
+    v8::Isolate *isolate = env->isolate();
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
+
+    v8::NewStringType str_type = v8::NewStringType::kInternalized;
+    v8::Local<v8::String> str = v8::String::NewFromUtf8(isolate, name, str_type).ToLocalChecked();
+
+    target->Set(context, str, v8impl::V8LocalValueFromJsValue(value)).Check();
+}
+
+static void InitInternal(v8::Local<v8::Object> target, v8::Local<v8::Value>,
+                         v8::Local<v8::Context> context, void *)
+{
+    using namespace RG;
+
+    node::Environment *env = node::Environment::GetCurrent(context);
+
+    // Not very clean but I don't know enough about Node and V8 to do better...
+    // ... and it seems to work okay.
+    napi_env env_napi = new napi_env__(context);
+    Napi::Env env_cxx(env_napi);
+    env->AtExit([](void *udata) {
+        napi_env env_napi = (napi_env)udata;
+        delete env_napi;
+    }, env_napi);
+
+    InstanceData *instance = new InstanceData();
+    env_cxx.SetInstanceData(instance);
+
+    FillRandomSafe(&instance->tag_lower, RG_SIZE(instance->tag_lower));
+
+    SetValue(env, target, "struct", Napi::Function::New(env_napi, CreateStructType));
+    SetValue(env, target, "pointer", Napi::Function::New(env_napi, CreatePointerType));
+    SetValue(env, target, "load", Napi::Function::New(env_napi, LoadSharedLibrary));
+    SetValue(env, target, "internal", Napi::Boolean::New(env_napi, true));
+
+    Napi::Object types = InitBaseTypes(env_cxx);
+    SetValue(env, target, "types", types);
+}
+
+#else
+
+static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
+{
+    using namespace RG;
+
+    InstanceData *instance = new InstanceData();
+    env.SetInstanceData(instance);
+
+    FillRandomSafe(&instance->tag_lower, RG_SIZE(instance->tag_lower));
+
+    exports.Set("struct", Napi::Function::New(env, CreateStructType));
+    exports.Set("pointer", Napi::Function::New(env, CreatePointerType));
+    exports.Set("load", Napi::Function::New(env, LoadSharedLibrary));
+    exports.Set("internal", Napi::Boolean::New(env, false));
+
+    Napi::Object types = InitBaseTypes(env);
+    exports.Set("types", types);
+
+    return exports;
+}
+
+#endif
+
+#if NODE_WANT_INTERNALS
+    NODE_MODULE_CONTEXT_AWARE_INTERNAL(koffi, InitInternal);
+#else
+    NODE_API_MODULE(koffi, InitModule);
+#endif

package/src/ffi.hh

@@ -0,0 +1,135 @@
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see https://www.gnu.org/licenses/.
+
+#pragma once
+
+#include "vendor/libcc/libcc.hh"
+
+#include <napi.h>
+
+namespace RG {
+
+enum class PrimitiveKind {
+    Void,
+
+    Bool,
+    Int8,
+    UInt8,
+    Int16,
+    UInt16,
+    Int32,
+    UInt32,
+    Int64,
+    UInt64,
+    Float32,
+    Float64,
+    String,
+    Pointer,
+
+    Record
+};
+
+static inline bool IsIntegral(PrimitiveKind primitive)
+{
+    bool integral = ((int)primitive <= (int)PrimitiveKind::Pointer);
+    return integral;
+}
+
+struct TypeInfo;
+struct RecordMember;
+
+struct TypeInfo {
+    const char *name;
+    napi_type_tag tag;
+
+    PrimitiveKind primitive;
+    int16_t size;
+    int16_t align;
+
+    HeapArray<RecordMember> members; // Record only
+    const TypeInfo *ref; // Pointer only
+
+    RG_HASHTABLE_HANDLER(TypeInfo, name);
+};
+
+struct RecordMember {
+    const char *name;
+    const TypeInfo *type;
+};
+
+class LibraryData {
+public:
+    ~LibraryData();
+
+    void *module = nullptr; // HMODULE on Windows
+
+    BlockAllocator tmp_alloc;
+    HeapArray<uint8_t> stack;
+
+    BlockAllocator str_alloc;
+};
+
+enum class CallConvention {
+    Default,
+    Stdcall
+};
+
+struct ParameterInfo {
+    const TypeInfo *type;
+
+    // ABI-specific part
+
+#if defined(_WIN64)
+    bool regular;
+#elif defined(__x86_64__)
+    bool use_memory;
+    int8_t gpr_count;
+    int8_t xmm_count;
+    bool gpr_first;
+#elif defined(__aarch64__)
+    int8_t gpr_count;
+    int8_t vec_count;
+#elif defined(__i386__) || defined(_M_IX86)
+    bool trivial; // Only matters for return value
+#endif
+};
+
+struct FunctionInfo {
+    const char *name;
+    const char *decorated_name;
+    std::shared_ptr<LibraryData> 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)
+    bool forward_fp;
+#endif
+};
+
+struct InstanceData {
+    BucketArray<TypeInfo> types;
+    HashTable<const char *, TypeInfo *> types_map;
+
+    uint64_t tag_lower;
+
+    BlockAllocator str_alloc;
+};
+
+}