koffi 2.5.20 → 2.5.21-beta.2

package/doc/contribute.md

@@ -127,6 +127,26 @@ Each machine is configured to run a VNC server available locally, which you can
 node qemu.js info debian_x64
 ```
 
+## Making a release
+
+First, you must update the code in three steps:
+
+- Change the version numbers in `package.json` (version and stable for stable releases)
+- Add an entry to `CHANGELOG.md` to summarize the changes since last release
+- Commit theses changes with the message *Bump Koffi to X.Y.Z*
+
+Once this is done, you can publish a new release with the following commands:
+
+```sh
+node qemu.js test # If not done before
+node qemu.js dist
+
+cd build/dist
+npm publish
+```
+
+Some platforms are emulated so this can take a few minutes until the pre-built binaries are ready. Go grab a cup of coffee, come back and execute the `npm publish` command!
+
 ## Code style
 
 Koffi is programmed in a mix of C++ and assembly code (architecture-specific code). It uses [node-addon-api](https://github.com/nodejs/node-addon-api) (C++ N-API wrapper) to interact with Node.js.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "koffi",
-    "version": "2.5.20",
+    "version": "2.5.21-beta.2",
     "stable": "2.5.20",
     "description": "Fast and simple C FFI (foreign function interface) for Node.js",
     "keywords": [

package/src/index.js

@@ -378,7 +378,7 @@ var require_package = __commonJS({
   "build/dist/src/koffi/package.json"(exports2, module2) {
     module2.exports = {
       name: "koffi",
-      version: "2.5.20",
+      version: "2.5.21-beta.2",
       stable: "2.5.20",
       description: "Fast and simple C FFI (foreign function interface) for Node.js",
       keywords: [
@@ -413,6 +413,7 @@ var require_package = __commonJS({
         chalk: "^4.1.2",
         esbuild: "^0.19.2",
         "ffi-napi": "^4.0.3",
+        "ffi-rs": "^1.0.12",
         minimatch: "^5.0.1",
         "node-ssh": "^12.0.3",
         raylib: "^0.9.2",

package/src/koffi/CMakeLists.txt

@@ -66,6 +66,7 @@ set(KOFFI_SRC
     src/ffi.cc
     src/parser.cc
     src/util.cc
+    src/win32.cc
     ../../src/core/libcc/libcc.cc
 )
 if(CMAKE_SIZEOF_VOID_P EQUAL 8)

package/src/koffi/src/call.cc

@@ -1165,6 +1165,61 @@ Size CallData::PushIndirectString(Napi::Array array, const TypeInfo *ref, uint8_
     }
 }
 
+void *CallData::ReserveTrampoline(const FunctionInfo *proto, Napi::Function func)
+{
+    if (!InitAsyncBroker(env, instance)) [[unlikely]]
+        return nullptr;
+
+    int16_t idx;
+    {
+        std::lock_guard<std::mutex> lock(shared.mutex);
+
+        if (!shared.available.len) [[unlikely]] {
+            ThrowError<Napi::Error>(env, "Too many callbacks are in use (max = %1)", MaxTrampolines);
+            return env.Null();
+        }
+        if (!used_trampolines.Available()) [[unlikely]] {
+            ThrowError<Napi::Error>(env, "This call uses too many temporary callbacks (max = %1)", RG_LEN(used_trampolines.data));
+            return env.Null();
+        }
+
+        idx = shared.available.data[--shared.available.len];
+        used_trampolines.Append(idx);
+    }
+
+    TrampolineInfo *trampoline = &shared.trampolines[idx];
+
+    trampoline->instance = instance;
+    trampoline->proto = proto;
+    trampoline->func.Reset(func, 1);
+    trampoline->recv.Reset();
+    trampoline->generation = (int32_t)mem->generation;
+
+    void *ptr = GetTrampoline(idx, proto);
+
+    return ptr;
+}
+
+void CallData::DumpForward(const FunctionInfo *func) 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));
+
+    Span<const uint8_t> stack = MakeSpan(mem->stack.end(), old_stack_mem.end() - mem->stack.end());
+    Span<const uint8_t> heap = MakeSpan(old_heap_mem.ptr, mem->heap.ptr - old_heap_mem.ptr);
+
+    DumpMemory("Stack", stack);
+    DumpMemory("Heap", heap);
+}
+
 static inline Napi::Value GetReferenceValue(Napi::Env env, napi_ref ref)
 {
     napi_value value;
@@ -1234,59 +1289,4 @@ void CallData::PopOutArguments()
     }
 }
 
-void *CallData::ReserveTrampoline(const FunctionInfo *proto, Napi::Function func)
-{
-    if (!InitAsyncBroker(env, instance)) [[unlikely]]
-        return nullptr;
-
-    int16_t idx;
-    {
-        std::lock_guard<std::mutex> lock(shared.mutex);
-
-        if (!shared.available.len) [[unlikely]] {
-            ThrowError<Napi::Error>(env, "Too many callbacks are in use (max = %1)", MaxTrampolines);
-            return env.Null();
-        }
-        if (!used_trampolines.Available()) [[unlikely]] {
-            ThrowError<Napi::Error>(env, "This call uses too many temporary callbacks (max = %1)", RG_LEN(used_trampolines.data));
-            return env.Null();
-        }
-
-        idx = shared.available.data[--shared.available.len];
-        used_trampolines.Append(idx);
-    }
-
-    TrampolineInfo *trampoline = &shared.trampolines[idx];
-
-    trampoline->instance = instance;
-    trampoline->proto = proto;
-    trampoline->func.Reset(func, 1);
-    trampoline->recv.Reset();
-    trampoline->generation = (int32_t)mem->generation;
-
-    void *ptr = GetTrampoline(idx, proto);
-
-    return ptr;
-}
-
-void CallData::DumpForward(const FunctionInfo *func) 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));
-
-    Span<const uint8_t> stack = MakeSpan(mem->stack.end(), old_stack_mem.end() - mem->stack.end());
-    Span<const uint8_t> heap = MakeSpan(old_heap_mem.ptr, mem->heap.ptr - old_heap_mem.ptr);
-
-    DumpMemory("Stack", stack);
-    DumpMemory("Heap", heap);
-}
-
 }

package/src/koffi/src/call.hh

@@ -113,12 +113,6 @@ public:
 
     void DumpForward(const FunctionInfo *func) const;
 
-private:
-    template <typename T>
-    bool AllocStack(Size size, Size align, T **out_ptr);
-    template <typename T = uint8_t>
-    T *AllocHeap(Size size, Size align);
-
     bool PushString(Napi::Value value, int directions, const char **out_str);
     Size PushStringValue(Napi::Value value, const char **out_str);
     bool PushString16(Napi::Value value, int directions, const char16_t **out_str16);
@@ -130,9 +124,15 @@ private:
     bool PushPointer(Napi::Value value, const TypeInfo *type, int directions, void **out_ptr);
     Size PushIndirectString(Napi::Array array, const TypeInfo *ref, uint8_t **out_ptr);
 
-    void PopOutArguments();
-
     void *ReserveTrampoline(const FunctionInfo *proto, Napi::Function func);
+
+private:
+    template <typename T>
+    bool AllocStack(Size size, Size align, T **out_ptr);
+    template <typename T = uint8_t>
+    T *AllocHeap(Size size, Size align);
+
+    void PopOutArguments();
 };
 
 template <typename T>

package/src/koffi/src/ffi.cc

@@ -1568,6 +1568,32 @@ static Napi::Value UnloadLibrary(const Napi::CallbackInfo &info)
     return env.Undefined();
 }
 
+#ifdef _WIN32
+static HANDLE LoadWindowsLibrary(Napi::Env env, const char16_t *filename)
+{
+    HANDLE module = LoadLibraryW((LPCWSTR)filename);
+
+    if (!module) {
+        if (GetLastError() == ERROR_BAD_EXE_FORMAT) {
+            int process = GetSelfMachine();
+            int dll = GetDllMachine(filename);
+
+            if (process >= 0 && dll >= 0 && dll != process) {
+                ThrowError<Napi::Error>(env, "Cannot load '%1' DLL in '%2' process",
+                                        WindowsMachineNames.FindValue(dll, "Unknown"),
+                                        WindowsMachineNames.FindValue(process, "Unknown"));
+                return nullptr;
+            }
+        }
+
+        ThrowError<Napi::Error>(env, "Failed to load shared library: %1", GetWin32ErrorString());
+        return nullptr;
+    }
+
+    return module;
+}
+#endif
+
 static Napi::Value LoadSharedLibrary(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
@@ -1592,12 +1618,10 @@ static Napi::Value LoadSharedLibrary(const Napi::CallbackInfo &info)
 #ifdef _WIN32
     if (info[0].IsString()) {
         std::u16string filename = info[0].As<Napi::String>();
-        module = LoadLibraryW((LPCWSTR)filename.c_str());
+        module = LoadWindowsLibrary(env, filename.c_str());
 
-        if (!module) {
-            ThrowError<Napi::Error>(env, "Failed to load shared library: %1", GetWin32ErrorString());
+        if (!module)
             return env.Null();
-        }
     } else {
         module = GetModuleHandle(nullptr);
         RG_ASSERT(module);
@@ -1873,6 +1897,39 @@ static Napi::Value CallPointerSync(const Napi::CallbackInfo &info)
                            : TranslateNormalCall(proto, ptr, info);
 }
 
+static Napi::Value EncodeValue(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    bool has_offset = (info.Length() >= 2 && info[1].IsNumber());
+    bool has_len = (info.Length() >= 4u + has_offset && info[2u + has_offset].IsNumber());
+
+    if (info.Length() < 3u + has_offset) [[unlikely]] {
+        ThrowError<Napi::TypeError>(env, "Expected %1 to 5 arguments, got %2", 3 + has_offset, info.Length());
+        return env.Null();
+    }
+
+    const TypeInfo *type = ResolveType(info[1u + has_offset]);
+    if (!type) [[unlikely]]
+        return env.Null();
+
+    Napi::Value ref = info[0];
+    int64_t offset = has_offset ? info[1].As<Napi::Number>().Int64Value() : 0;
+    Napi::Value value = info[2u + has_offset + has_len];
+
+    if (has_len) {
+        Size len = info[2u + has_offset].As<Napi::Number>();
+
+        if (!Encode(ref, offset, value, type, &len))
+            return env.Null();
+    } else {
+        if (!Encode(ref, offset, value, type))
+            return env.Null();
+    }
+
+    return env.Undefined();
+}
+
 void LibraryHolder::Unload()
 {
 #ifdef _WIN32
@@ -1956,6 +2013,11 @@ bool InitAsyncBroker(Napi::Env env, InstanceData *instance)
     return true;
 }
 
+CallData *GetThreadCall()
+{
+    return exec_call;
+}
+
 static void RegisterPrimitiveType(Napi::Env env, Napi::Object map, std::initializer_list<const char *> names,
                                   PrimitiveKind primitive, int32_t size, int16_t align, const char *ref = nullptr)
 {
@@ -2169,6 +2231,7 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
     exports.Set("decode", Napi::Function::New(env, DecodeValue));
     exports.Set("address", Napi::Function::New(env, GetPointerAddress));
     exports.Set("call", Napi::Function::New(env, CallPointerSync));
+    exports.Set("encode", Napi::Function::New(env, EncodeValue));
 
     exports.Set("reset", Napi::Function::New(env, ResetKoffi));
 

package/src/koffi/src/ffi.hh

@@ -99,6 +99,7 @@ static const char *const PrimitiveKindNames[] = {
 struct TypeInfo;
 struct RecordMember;
 struct FunctionInfo;
+class CallData;
 
 typedef void DisposeFunc (Napi::Env env, const TypeInfo *type, const void *ptr);
 
@@ -342,5 +343,6 @@ Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info);
 Napi::Value TranslateAsyncCall(const Napi::CallbackInfo &info);
 
 bool InitAsyncBroker(Napi::Env env, InstanceData *instance);
+CallData *GetThreadCall();
 
 }

package/src/koffi/src/util.cc

@@ -1193,6 +1193,206 @@ Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, cons
     return env.Null();
 }
 
+bool Encode(Napi::Value ref, Size offset, Napi::Value value, const TypeInfo *type, const Size *len)
+{
+    Napi::Env env = ref.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    uint8_t *ptr = nullptr;
+
+    if (ref.IsExternal()) {
+        Napi::External<void> external = ref.As<Napi::External<void>>();
+        ptr = (uint8_t *)external.Data();
+    } else if (IsRawBuffer(ref)) {
+        Span<uint8_t> buffer = GetRawBuffer(ref);
+
+        if (buffer.len - offset < type->size) [[unlikely]] {
+            ThrowError<Napi::Error>(env, "Expected buffer with size superior or equal to type %1 (%2 bytes)",
+                                    type->name, type->size + offset);
+            return env.Null();
+        }
+
+        ptr = (uint8_t *)buffer.ptr;
+    } else {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for reference, expected external or TypedArray", GetValueType(instance, value));
+        return env.Null();
+    }
+
+    if (!ptr) [[unlikely]] {
+        ThrowError<Napi::Error>(env, "Cannot encode data in NULL pointer");
+        return env.Null();
+    }
+    ptr += offset;
+
+    return Encode(env, ptr, value, type, len);
+}
+
+bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *type, const Size *len)
+{
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    CallData *call = GetThreadCall();
+
+    if (len && type->primitive != PrimitiveKind::String &&
+               type->primitive != PrimitiveKind::String16 &&
+               type->primitive != PrimitiveKind::Prototype) {
+        if (*len < 0) [[unlikely]] {
+            ThrowError<Napi::TypeError>(env, "Automatic (negative) length is only supported when decoding");
+            return env.Null();
+        }
+
+        type = MakeArrayType(instance, type, *len);
+    }
+
+    if (!call) [[unlikely]] {
+        ThrowError<Napi::Error>(env, "koffi.encode() can only be used inside callbacks");
+        return false;
+    }
+
+#define PUSH_INTEGER(CType) \
+        do { \
+            if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] { \
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value)); \
+                return false; \
+            } \
+             \
+            CType v = GetNumber<CType>(value); \
+            *(CType *)origin = v; \
+        } while (false)
+#define PUSH_INTEGER_SWAP(CType) \
+        do { \
+            if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] { \
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value)); \
+                return false; \
+            } \
+             \
+            CType v = GetNumber<CType>(value); \
+            *(CType *)origin = ReverseBytes(v); \
+        } while (false)
+
+    switch (type->primitive) {
+        case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
+
+        case PrimitiveKind::Bool: {
+            if (!value.IsBoolean()) [[unlikely]] {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected boolean", GetValueType(instance, value));
+                return false;
+            }
+
+            bool b = value.As<Napi::Boolean>();
+            *(bool *)origin = b;
+        } break;
+        case PrimitiveKind::Int8: { PUSH_INTEGER(int8_t); } break;
+        case PrimitiveKind::UInt8: { PUSH_INTEGER(uint8_t); } break;
+        case PrimitiveKind::Int16: { PUSH_INTEGER(int16_t); } break;
+        case PrimitiveKind::Int16S: { PUSH_INTEGER_SWAP(int16_t); } break;
+        case PrimitiveKind::UInt16: { PUSH_INTEGER(uint16_t); } break;
+        case PrimitiveKind::UInt16S: { PUSH_INTEGER_SWAP(uint16_t); } break;
+        case PrimitiveKind::Int32: { PUSH_INTEGER(int32_t); } break;
+        case PrimitiveKind::Int32S: { PUSH_INTEGER_SWAP(int32_t); } break;
+        case PrimitiveKind::UInt32: { PUSH_INTEGER(uint32_t); } break;
+        case PrimitiveKind::UInt32S: { PUSH_INTEGER_SWAP(uint32_t); } break;
+        case PrimitiveKind::Int64: { PUSH_INTEGER(int64_t); } break;
+        case PrimitiveKind::Int64S: { PUSH_INTEGER_SWAP(int64_t); } break;
+        case PrimitiveKind::UInt64: { PUSH_INTEGER(uint64_t); } break;
+        case PrimitiveKind::UInt64S: { PUSH_INTEGER_SWAP(uint64_t); } break;
+        case PrimitiveKind::String: {
+            const char *str;
+            if (!call->PushString(value, 1, &str)) [[unlikely]]
+                return false;
+            *(const char **)origin = str;
+        } break;
+        case PrimitiveKind::String16: {
+            const char16_t *str16;
+            if (!call->PushString16(value, 1, &str16)) [[unlikely]]
+                return false;
+            *(const char16_t **)origin = str16;
+        } break;
+        case PrimitiveKind::Pointer: {
+            void *ptr;
+            if (!call->PushPointer(value, type, 1, &ptr)) [[unlikely]]
+                return false;
+            *(void **)origin = ptr;
+        } break;
+        case PrimitiveKind::Record:
+        case PrimitiveKind::Union: {
+            if (!IsObject(value)) [[unlikely]] {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected object", GetValueType(instance, value));
+                return false;
+            }
+
+            Napi::Object obj = value.As<Napi::Object>();
+
+            if (!call->PushObject(obj, type, origin))
+                return false;
+        } break;
+        case PrimitiveKind::Array: {
+            if (value.IsArray()) {
+                Napi::Array array = value.As<Napi::Array>();
+                Size len = (Size)type->size / type->ref.type->size;
+
+                if (!call->PushNormalArray(array, len, type, origin))
+                    return false;
+            } else if (IsRawBuffer(value)) {
+                Span<const uint8_t> buffer = GetRawBuffer(value);
+
+                if (!call->PushBuffer(buffer, type->size, type, origin))
+                    return false;
+            } else if (value.IsString()) {
+                if (!call->PushStringArray(value, type, origin))
+                    return false;
+            } else {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected array", GetValueType(instance, value));
+                return false;
+            }
+        } break;
+        case PrimitiveKind::Float32: {
+            if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
+                return false;
+            }
+
+            float f = GetNumber<float>(value);
+            *(float *)origin = f;
+        } break;
+        case PrimitiveKind::Float64: {
+            if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
+                return false;
+            }
+
+            double d = GetNumber<double>(value);
+            *(double *)origin = d;
+        } break;
+        case PrimitiveKind::Callback: {
+            void *ptr;
+
+            if (value.IsFunction()) {
+                Napi::Function func = value.As<Napi::Function>();
+
+                ptr = call->ReserveTrampoline(type->ref.proto, func);
+                if (!ptr) [[unlikely]]
+                    return false;
+            } else if (CheckValueTag(instance, value, type->ref.marker)) {
+                ptr = value.As<Napi::External<void>>().Data();
+            } else if (IsNullOrUndefined(value)) {
+                ptr = nullptr;
+            } else {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected %2", GetValueType(instance, value), type->name);
+                return false;
+            }
+
+            *(void **)origin = ptr;
+        } break;
+
+        case PrimitiveKind::Prototype: { RG_UNREACHABLE(); } break;
+    }
+
+#undef PUSH_INTEGER_SWAP
+#undef PUSH_INTEGER
+
+    return true;
+}
+
 Napi::Function WrapFunction(Napi::Env env, const FunctionInfo *func)
 {
     InstanceData *instance = env.GetInstanceData<InstanceData>();

package/src/koffi/src/util.hh

@@ -170,6 +170,9 @@ void DecodeBuffer(Span<uint8_t> buffer, const uint8_t *origin, const TypeInfo *r
 Napi::Value Decode(Napi::Value value, Size offset, const TypeInfo *type, const Size *len = nullptr);
 Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, const Size *len = nullptr);
 
+bool Encode(Napi::Value ref, Size offset, Napi::Value value, const TypeInfo *type, const Size *len = nullptr);
+bool Encode(Napi::Env env, uint8_t *ptr, Napi::Value value, const TypeInfo *type, const Size *len = nullptr);
+
 static inline Napi::Value NewBigInt(Napi::Env env, int64_t value)
 {
     if (value <= 9007199254740992ll && value >= -9007199254740992ll) {

package/src/koffi/src/win32.cc

@@ -0,0 +1,155 @@
+// Copyright 2023 Niels Martignène <niels.martignene@protonmail.com>
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the “Software”), to deal in 
+// the Software without restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
+// Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+
+#ifdef _WIN32
+
+#include "win32.hh"
+
+#ifndef NOMINMAX
+    #define NOMINMAX
+#endif
+#ifndef WIN32_LEAN_AND_MEAN
+    #define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#include <ntsecapi.h>
+#include <processthreadsapi.h>
+
+namespace RG {
+
+const HashMap<int, const char *> WindowsMachineNames = {
+    { 0x184, "Alpha AXP, 32-bit" },
+    { 0x284, "Alpha 64" },
+    { 0x1d3, "Matsushita AM33" },
+    { 0x8664, "AMD x64" },
+    { 0x1c0, "ARM little endian" },
+    { 0xaa64, "ARM64 little endian" },
+    { 0x1c4, "ARM Thumb-2 little endian" },
+    { 0x284, "AXP 64" },
+    { 0xebc, "EFI byte code" },
+    { 0x14c, "Intel 386+" },
+    { 0x200, "Intel Itanium" },
+    { 0x6232, "LoongArch 32-bit" },
+    { 0x6264, "LoongArch 64-bit" },
+    { 0x9041, "Mitsubishi M32R little endian" },
+    { 0x266, "MIPS16" },
+    { 0x366, "MIPS with FPU" },
+    { 0x466, "MIPS16 with FPU" },
+    { 0x1f0, "Power PC little endian" },
+    { 0x1f1, "Power PC with FP support" },
+    { 0x166, "MIPS little endian" },
+    { 0x5032, "RISC-V 32-bit" },
+    { 0x5064, "RISC-V 64-bit" },
+    { 0x5128, "RISC-V 128-bit" },
+    { 0x1a2, "Hitachi SH3" },
+    { 0x1a3, "Hitachi SH3 DSP" },
+    { 0x1a6, "Hitachi SH4" },
+    { 0x1a8, "Hitachi SH5" },
+    { 0x1c2, "Thumb" },
+    { 0x169, "MIPS little-endian WCE v2" }
+};
+
+// Fails silently on purpose
+static bool ReadAt(HANDLE h, int32_t offset, void *buf, int len)
+{
+    OVERLAPPED ov = {};
+    DWORD read;
+
+    ov.Offset = offset & 0x7FFFFFFFu;
+
+    if (offset < 0)
+        return false;
+    if (!ReadFile(h, buf, (DWORD)len, &read, &ov))
+        return false;
+    if (read != len)
+        return false;
+
+    return true;
+}
+
+static int GetFileMachine(HANDLE h, bool check_dll)
+{
+    PE_DOS_HEADER dos = {};
+    PE_NT_HEADERS nt = {};
+
+    if (!ReadAt(h, 0, &dos, RG_SIZE(dos)))
+        goto generic;
+    if (!ReadAt(h, dos.e_lfanew, &nt, RG_SIZE(nt)))
+        goto generic;
+
+    if (dos.e_magic != 0x5A4D) // MZ
+        goto generic;
+    if (nt.Signature != 0x00004550) // PE\0\0
+        goto generic;
+    if (check_dll && !(nt.FileHeader.Characteristics & IMAGE_FILE_DLL))
+        goto generic;
+
+    return (int)nt.FileHeader.Machine;
+
+generic:
+    LogError("Invalid or forbidden %1 file: %2", check_dll ? "DLL" : "executable", GetWin32ErrorString());
+    return -1;
+}
+
+int GetSelfMachine()
+{
+    const char *filename = GetApplicationExecutable();
+
+    HANDLE h;
+    if (IsWin32Utf8()) {
+        h = CreateFileA(filename, GENERIC_READ,
+                        FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                        nullptr, OPEN_EXISTING, 0, nullptr);
+    } else {
+        wchar_t filename_w[4096];
+        if (ConvertUtf8ToWin32Wide(filename, filename_w) < 0)
+            return -1;
+
+        h = CreateFileW(filename_w, GENERIC_READ,
+                        FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                        nullptr, OPEN_EXISTING, 0, nullptr);
+    }
+    if (h == INVALID_HANDLE_VALUE) {
+        LogError("Cannot open '%1': %2", filename, GetWin32ErrorString());
+        return -1;
+    }
+    RG_DEFER { CloseHandle(h); };
+
+    return GetFileMachine(h, false);
+}
+
+int GetDllMachine(const char16_t *filename)
+{
+    HANDLE h = CreateFileW((LPCWSTR)filename, GENERIC_READ,
+                           FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                           nullptr, OPEN_EXISTING, 0, nullptr);
+    if (h == INVALID_HANDLE_VALUE) {
+        LogError("Cannot open '%1': %2", filename, GetWin32ErrorString());
+        return -1;
+    }
+    RG_DEFER { CloseHandle(h); };
+
+    return GetFileMachine(h, true);
+}
+
+}
+
+#endif

package/src/koffi/src/win32.hh

@@ -27,6 +27,45 @@
 
 namespace RG {
 
+struct PE_DOS_HEADER {
+    uint16_t e_magic;
+    uint16_t e_cblp;
+    uint16_t e_cp;
+    uint16_t e_crlc;
+    uint16_t e_cparhdr;
+    uint16_t e_minalloc;
+    uint16_t e_maxalloc;
+    uint16_t e_ss;
+    uint16_t e_sp;
+    uint16_t e_csum;
+    uint16_t e_ip;
+    uint16_t e_cs;
+    uint16_t e_lfarlc;
+    uint16_t e_ovno;
+    uint16_t e_res[4];
+    uint16_t e_oemid;
+    uint16_t e_oeminfo;
+    uint16_t e_res2[10];
+    uint32_t e_lfanew;
+};
+
+struct PE_FILE_HEADER {
+    uint16_t Machine;
+    uint16_t NumberOfSections;
+    uint32_t TimeDateStamp;
+    uint32_t PointerToSymbolTable;
+    uint32_t NumberOfSymbols;
+    uint16_t SizeOfOptionalHeader;
+    uint16_t Characteristics;
+};
+
+struct PE_NT_HEADERS {
+    uint32_t Signature;
+    PE_FILE_HEADER FileHeader;
+
+    // ... OptionalHeader;
+};
+
 #if _WIN64
 
 struct TEB {
@@ -70,4 +109,9 @@ static inline TEB *GetTEB()
     return teb;
 }
 
+extern const HashMap<int, const char *> WindowsMachineNames;
+
+int GetSelfMachine();
+int GetDllMachine(const char16_t *filename);
+
 }